Linux 内核中大页的实现与分析，第 1 部分

介绍

本文介绍了 Linux 操作系统中大页的实现。分别从 memory 层、文件系统层、libhugetlbfs，以及用户如何使用大页等这几个方面进行了分析和介绍。让您更好的了解 大页在内核的实现机制以及用户使用方法。

大页主要是为了用户使用大量的内存时提供优化的方法。它通过硬件平台提供的支持，操作系统对内存操作进行优化，提高了系统的效率。本篇文章首先介绍了硬件平台对大页的支持，然后分析它在 Linux 内核中的实现，最后通过一个例子来了解用户如何使用这些大页的。 随着硬件的价格越来越低，用户需要访问更多的内存，系统有两种方法来适应内存的增加。一种方法就是保持页的大小不变而增加页表的级数，另一种方法就是页表的级别不变而增加页的大小。第一种方法，会容易出现性能的问题。页表级数的增加和小页就会增加访问内存的次数。而第二种方法可以减少访问内存的次数。相对于小页来说，系统的性能是比较高的。这就是为何有越来越多的方法支持大页。

回页首

大页的硬件支持

这里以 x86 架构为例，介绍硬件平台对大页的支持。下面表格显示了页的大小与物理地址长度的关系。控制寄存器 CR0、CR4 中的某些位决定了页的大小。此表格来自 Intel 64 IA and IA32 Architectures Software Developer ’s Manual。

Paging Mode	PG Flag CR0	PAE Flag CR4	LME IA32_EFFER	Page Size	Linear Address	Physical Address Width
None	0	X	X	-	32 bit	32 bit
32 bit	1	0	0	4KB 4MB	32 bit	Up to 40 bit
PAE	1	1	0	4KB 2MB	32 bit	Up to 52 bit
IA-32e	1	1	2	4KB 2MB 1GB	48 bit	Up to 52 bit

回页首

大页总体结构

大页的结构主要有内核代码中的 hugetlb.c， memory.c，hugtlbpage.c 和 fs/hugetlbfs/inode.c，还有用户空间提供的 libhugetlbfs。其中 hugetlb.c, memory.c 属于内存管理的部分，hugetlbpage.c 是跟具体的架构相关的页表的管理，fs/hugetlbfs/inode.c 是文件系统层，hugetlbfs 是一个伪文件系统，没有一个提供的设备文件，它提供了使用和管理大页的一种方式。最后，libhugetlbfs 为用户提供了管理大页的工具。这几部分的关系如下图所示：

图 1. 大页结构图

图 2. 大页使用的时序图

上面时序图展示了用户使用大页时，从用户空间调用到内核空间，最终分配页给用户的过程。

回页首

大页文件系统

大页文件系统作为一个伪文件系统，它通过 mmap 将文件映射到内存中，对内存操作。内存分配的页即是大页。在 hugetlbfs 文件系统中实现了 mmap 的回调函数。本文的代码都是基于 Linux 内核 -3.0.4 的版本。下面为 hugetlbfs 的文件操作的定义。

清单 1. 大页文件操作的函数

 const struct file_operations hugetlbfs_file_operations = { 
 .read= hugetlbfs_read, 
 .mmap= hugetlbfs_file_mmap, 
 .fsync= noop_fsync, 
 .get_unmapped_area= hugetlb_get_unmapped_area, 
 .llseek= default_llseek, 
 };

大页文件系统中仅仅提供了这几个回调函数，其中重要的一对函数为 hugetlbfs_file_mmap、hugetlb_get_unmapped_area。基本的文件读操作函数 hugetlbfs_read，这个函数有点儿类似 do_generic_mapping_read()。这里没有使用它是因为它假设了 PAGE_CACHE_SIZE 的大小。文件系统并没有提供文件写的操作，这个操作对于用户来说没有意义的。通常用户会通过 mmap 获得内存地址，通过内存地址对内存进行读写。

文件与内存间的映射

在 Linux 内核中，文件系统 hugetlbfs 提供了 mmap 的回调函数，为映射的文件保留一个内存区域。通过调用函数 hugetlb_reserve_pages() 来实现。mmap 的回调函数定义如下。

清单 2. hugetlbfs 提供的 mmap 函数

 static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma) 
 { 
 struct inode *inode = file->f_path.dentry->d_inode; 
 loff_t len, vma_len; 
 int ret; 
 struct hstate *h = hstate_file(file); 

 /* 
 * vma address alignment (but not the pgoff alignment) has 
 * already been checked by prepare_ 大页 _range.  If you add 
 * any error returns here, do so after setting VM_HUGETLB, so 
 * is_vm_hugetlb_page tests below unmap_region go the right 
 * way when do_mmap_pgoff unwinds (may be important on powerpc 
 * and ia64). 
 */ 
 vma->vm_flags |= VM_HUGETLB | VM_RESERVED; 
 vma->vm_ops = &hugetlb_vm_ops; 

 if (vma->vm_pgoff & ~(huge_page_mask(h) >> PAGE_SHIFT)) 
 return -EINVAL; 

 vma_len = (loff_t)(vma->vm_end - vma->vm_start); 

 mutex_lock(&inode->i_mutex); 
 file_accessed(file); 

 ret = -ENOMEM 
 len = vma_len + ((loff_t)vma->vm_pgoff << PAGE_SHIFT); 

 if (hugetlb_reserve_pages(inode, 
 vma->vm_pgoff >> huge_page_order(h), 
 len >> huge_page_shift(h), vma, 
 vma->vm_flags)) 
 goto out; 

 ret = 0; 
 hugetlb_prefault_arch_hook(vma->vm_mm); 
 if (vma->vm_flags & VM_WRITE && inode->i_size < len) 
 inode->i_size = len; 
 out: 
 mutex_unlock(&inode->i_mutex); 

 return ret; 
 }

在上面的代码中，将 VMA 的 flags 设置为 VM_HUGETLB，并赋值 VMA 的操作为 hugetlb_vm_ops。另外 hugetlb_reserve_pages() 函数会保留 大页的内存的区域，并从 buddy 系统中分配所请求的大小的内存。

下面分析一下 hugetlb_reserve_pages() 函数，它的定义如下：

清单 4. hugetlb_reserve_pages in mm/hugetlb.c

 int hugetlb_reserve_pages(struct inode *inode, 
 long from, long to, 
 struct vm_area_struct *vma, 
 vm_flags_t vm_flags) 
 { 
 long ret, chg; 
 struct hstate *h = hstate_inode(inode); 

 /* 
 * Only apply 大页 reservation if asked. At fault time, an 
 * attempt will be made for VM_NORESERVE to allocate a page 
 * and filesystem quota without using reserves 
 */ 
 if (vm_flags & VM_NORESERVE) 
 return 0; 

 /* 
 * Shared mappings base their reservation on the number of pages that 
 * are already allocated on behalf of the file. Private mappings need 
 * to reserve the full area even if read-only as mprotect() may be 
 * called to make the mapping read-write. Assume !vma is a shm mapping 
 */ 
 if (!vma || vma->vm_flags & VM_MAYSHARE) 
 chg = region_chg(&inode->i_mapping->private_list, from, to); 
 else { 
 struct resv_map *resv_map = resv_map_alloc(); 
 if (!resv_map) 
 return -ENOMEM; 

 chg = to - from; 

 set_vma_resv_map(vma, resv_map); 
 set_vma_resv_flags(vma, HPAGE_RESV_OWNER); 
 } 

 if (chg < 0) 
 return chg; 

 /* There must be enough filesystem quota for the mapping */ 
 if (hugetlb_get_quota(inode->i_mapping, chg)) 
 return -ENOSPC; 

 /* 
 * Check enough 大页 s are available for the reservation. 
 * Hand back the quota if there are not 
 */ 
 ret = hugetlb_acct_memory(h, chg); 
 if (ret < 0) { 
 hugetlb_put_quota(inode->i_mapping, chg); 
 return ret; 
 } 

 /* 
 * Account for the reservations made. Shared mappings record regions 
 * that have reservations as they are shared by multiple VMAs. 
 * When the last VMA disappears, the region map says how much 
 * the reservation was and the page cache tells how much of 
 * the reservation was consumed. Private mappings are per-VMA and 
 * only the consumed reservations are tracked. When the VMA 
 * disappears, the original reservation is the VMA size and the 
 * consumed reservations are stored in the map. Hence, nothing 
 * else has to be done for private mappings here 
 */ 
 if (!vma || vma->vm_flags & VM_MAYSHARE) 
 region_add(&inode->i_mapping->private_list, from, to); 
 return 0; 
 }

在上面的函数中，主要处理了为映射请求足够的内存。内存的映射分两种情况，一种是私有的映射，另一种是共享的映射。用户在映射的时候，可以指定 flag 为私有还是共享。那么下面分析一下对于这两种映射的不同的处理。

私有映射：内核在保留映射的内存区域时，将内存区域存放在 resv_map 中。这个结构体用来对一个保留的页表进行跟踪。共享映射：这些被多个进程共享的区域被存放在文件的 inode 的 page cache 中。也就是 inode->i_mapping->private_list。这些内存映射区域，会通过 hugetlb_acct_memory() 函数分配内存。下面介绍 memory 层定义的内存操作。

回页首

memory 层大页的管理

在 memory 层，定义了内存操作与文件关联的 vm_operation_struct 的函数，以及一系列的 VMA 的相关的操作。定义如下：

清单 3. 大页文件系统提供的 mmap 函数

 const struct vm_operations_struct hugetlb_vm_ops = { 
 .fault = hugetlb_vm_op_fault, 
 .open = hugetlb_vm_op_open, 
 .close = hugetlb_vm_op_close, 
 };

这个结构体中，定义了三个回调函数。我们下面分析一下这三个函数的用处。

Hugetlb_vm_op_fault()，这个函数中只是包含了一个 BUG() 方法，在 handle_mm_fault 中不会调用 hugetlb_vm_ops->fault()。在 handle_mm_fault 中，对于大页有特殊的处理。在大页中，定义了 hugetlb_fault() 函数，它会被 handle_mm_fault() 调用来处理大页的缺页异常。

下图描述了从系统调用到 hugetlb_fault 的调用。

图 3. mmap() 系统调用 fault() 分配页表

从上图中，可以看出，对于大页情况，会调用 hugetlb_fault()。对于小页情况，会调用它们的 vm_ops->fault()。另外，mmap() 系统调用时，页表最终会被分配好，不是在写数据时分配，这样提高了系统的效率。

那么大页的页表是如何管理的呢？下面介绍简单介绍一下页表管理。

页表管理

下面是以 x86_64 的系统为例，系统支持 48 位虚拟地址和 36 位的物理地址（PAE enabled），4KB 和 2M 的页表分别如下面的图。

图 4. 4KB 小页的页表管理

由上图可以看出，对于小页的管理，页表分为 4 级页表，每次需要访问一次页表也就是 4K 的内存，需要访问 4 次内存。

图 5. 2MB 大页的页表管理

由上图可以看出，PTE 不再使用。PMD 页表的 entry 直接指向页的物理地址。读一个 2M 的页，需要访问 3 次内存。

我们来比较一下小页和大页的访问内存的效率。如果使用小页的话，若访问一个 2M 的内存，那么至少需要放问 512 × 4 次。而如果使用大页的话，如果访问 2M 页表，需要访问内存次数为 3 次。使用小页的话，访问内存的次数是 2M 的内存的 512 倍多。可见使用大页提高的系统性能。

清单 4. 在 memory.c 中的 huge_pte_offset 定义

 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr) 
 { 
 pgd_t *pgd; 
 pud_t *pud; 
 pmd_t *pmd = NULL; 

 pgd = pgd_offset(mm, addr); 
 if (pgd_present(*pgd)) { 
 pud = pud_offset(pgd, addr); 
 if (pud_present(*pud)) { 
 if (pud_large(*pud)) 
 return (pte_t *)pud; 
 pmd = pmd_offset(pud, addr); 
 } 
 } 
 return (pte_t *) pmd; 
 }

从这个函数，可以看到，大页的 pte 是从普通页中的 pmd 获得。也就是上面我们介绍的大页的页表，pte 不再使用，pmd 的 entry 直接指向物理内存的地址。

hugetlb 模块

这个模块初始化大页，向内核的命令行提供了参数的设置，使得大页在内核启动阶段即可进行初始化页的大小。另外内核也提供了 sys 文件系统，用户可以在内核启动以后，通过写 sys 的文件来设置大页的参数。这个模块提供的参数有：nr_hugepages、nr_overcommit_hugepages、free_hugepages、surplus_hugepages、nr_hugepages_mempolicy。

下面介绍一下这几个参数。

nr_hugepages: 这个参数为系统所有的大页的总数。

nr_overcommit_hugepages: 这个参数的意思是，当用户需求更多的内存，这个内存大于 nr_hugepages 的数目，那么内核就会从 surplus 中获得内存来满足这个需求。

surplus_hugepages: 分配超过 nr_hugepages 大页的个数。

nr_hugepages_mempolicy: 设置 NUMA memory 的策略。例如下面的一行，设置某些 node 中 nr_hugepages 的数目。

numactl --interleave <node-list> echo 20 \ >/proc/sys/vm/nr_hugepages_mempolicy

回页首

系统调用 mmap

我们来看一下，mmap 如何调用到 hugetlbfs 的。

图 6. mmap 调用流程

上图为一个简单的流程，中间还有很多细节，这里不在详细的介绍了。hugetlb_file_mmap() 向内存的调用前面已经介绍过了。

下面是一个大页被用户使用的一个例子，这是内核代码中的例子，document/vm/hugepage-mmap.c

清单 5. 大页使用的例子

 #include <stdlib.h> 
 #include <stdio.h> 
 #include <unistd.h> 
 #include <sys/mman.h> 
 #include <fcntl.h> 

 #define FILE_NAME "/mnt/ 大页 file"
 #define LENGTH (256UL*1024*1024) 
 #define PROTECTION (PROT_READ | PROT_WRITE) 

 /* Only ia64 requires this */ 
 #ifdef __ia64__ 
 #define ADDR (void *)(0x8000000000000000UL) 
 #define FLAGS (MAP_SHARED | MAP_FIXED) 
 #else 
 #define ADDR (void *)(0x0UL) 
 #define FLAGS (MAP_SHARED) 
 #endif 

 static void check_bytes(char *addr) 
 { 
 printf("First hex is %x\n", *((unsigned int *)addr)); 
 } 

 static void write_bytes(char *addr) 
 { 
 unsigned long i; 

 for (i = 0; i < LENGTH; i++) 
 *(addr + i) = (char)i; 
 } 

 static void read_bytes(char *addr) 
 { 
 unsigned long i; 

 check_bytes(addr); 
 for (i = 0; i < LENGTH; i++) 
 if (*(addr + i) != (char)i) { 
 printf("Mismatch at %lu\n", i); 
 break; 
 } 
 } 

 int main(void) 
 { 
 void *addr; 
 int fd; 

 fd = open(FILE_NAME, O_CREAT | O_RDWR, 0755); 
 if (fd < 0) { 
 perror("Open failed"); 
 exit(1); 
 } 

 addr = mmap(ADDR, LENGTH, PROTECTION, FLAGS, fd, 0); 
 if (addr == MAP_FAILED) { 
 perror("mmap"); 
 unlink(FILE_NAME); 
 exit(1); 
 } 

 printf("Returned address is %p\n", addr); 
 check_bytes(addr); 
 write_bytes(addr); 
 read_bytes(addr); 

 munmap(addr, LENGTH); 
 close(fd); 
 unlink(FILE_NAME); 

 return 0; 
 }

这里的映射是一个 SHARED 的映射。当写完数据以后，close() 和 unlink() 被调用，close 函数会将 page 的引用减小。unlink() 会帮助删除文件，并刷新页缓存，最后将内存释放到预存的大页的池中。

回页首

libhugetlbfs

这个为用户提供了上层操作系统的接口，而且也提供了一套工具。在 Fedora 或者 Redhat 中提供了 libhugetlbfs 以及 libhugetlbfs-utils 的 rpm 包。安装以后可以使用它提供的工具来分配和管理大页。例如：hugeadm --pool-pages-min 2M:512，这个命令创建了 512 个 2MB 大小的页，一共有 1GB 的内存。

回页首

总结

本文从内核到用户层来分析大页的管理，可以更多地了解到大页在内核中如何实现，以及对系统的性能的影响。本文主要介绍通过 hugetlbfs 使用和分配大页，但是这种方式还存在一些弊端。内核中又引入了另一种新的方法来管理和使用大页。那就是 THP（Transparent 大页）。我们将在第 2 部分来介绍一下 THP。

参考资料

学习

• 关于大页分析：对大页进行了深入的分析。
• Linux 大页面使用与实现简介：本文对 Linux 大页面机制的使用和实现进行了简要的介绍和分析。
• HugeTLB - Large Page Support in the Linux Kernel：介绍内核对大页的支持
• 在 developerWorks Linux 专区寻找为 Linux 开发人员（包括 Linux 新手入门）准备的更多参考资料。

讨论

• 加入 developerWorks 中文社区。查看开发人员推动的博客、论坛、组和维基，并与其他 developerWorks 用户交流。