linux 内存管理(15)

了解mmap机制。参考此处

1.概述

mmap 即地址的映射, 是一种内存映射文件的方法,将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。

Linux通过内存映像机制来提供用户程序对内存直接访问的能力。内存映像的意思是把内核中特定部分的内存空间映射到用户级程序的内存空间去。也就是说，用户空间和内核空间共享一块相同的内存。这样做的直观效果显而易见：内核在这块地址内存储变更的任何数据，用户可以立即发现和使用，根本无须数据拷贝。举个例子理解一下，使用mmap方式获取磁盘上的文件信息，只需要将磁盘上的数据拷贝至那块共享内存中去，用户进程可以直接获取到信息，而相对于传统的write/read　IO系统调用, 必须先把数据从磁盘拷贝至到内核缓冲区中(页缓冲)，然后再把数据拷贝至用户进程中。两者相比，mmap会少一次拷贝数据，这样带来的性能提升是巨大的。

使用内存访问来取代read()和write()系统调用能够简化一些应用程序的逻辑。在一些情况下，它能够比使用传统的I/O系统调用执行文件I/O这种做法提供更好的性能。原因是：

正常的read()或write()需要两次传输：一次是在文件和内核高速缓冲区之间，另一次是在高速缓冲区和用户空间缓冲区之间。使用mmap()就不需要第二次传输了。对于输入来讲，一旦内核将相应的文件块映射进内存之后，用户进程就能够使用这些数据了；对于输出来讲，用户进程仅仅需要修改内核中的内容，然后可以依靠内核内存管理器来自动更新底层的文件。
除了节省内核空间和用户空间之间的一次传输之外，mmap()还能够通过减少所需使用的内存来提升性能。当使用read()或write()时，数据将被保存在两个缓冲区中：一个位于用户空间，另个一位于内核空间。当使用mmap()时，内核空间和用户空间会共享同一个缓冲区。此外，如果多个进程正在同一个文件上执行I/O，那么它们通过使用mmap()就能够共享同一个内核缓冲区，从而又能够节省内存的消耗。

2.函数

void* mmap(void* start, size_t length, int prot, int flags, int fd, off_t offset)

描述：mmap()系统调用把fd文件描述符对象从offset位置开始(字节为单位)，映射到以addr为起始地址的页面。

2.1.参数解释

start：映射区的开始地址，一般为空，选址工作交给内核
length：映射区的长度
prot：期望的内存保护标志，有以下取值
- PROT_NONE: 页面不允许访问
- PROT_READ: 页面可读
- PROT_WRITE: 页面可写
- PROT_EXEC: 页面可执行
  通常可写意味着可读，可读意味着可执行，因此不应该完全依赖于flag决定读写模式
flags：自定映射对象的类型，映射选项以及对被映射对象的修改是否只对进程可见(copy on write)。
- MAP_ANONYOUS: 匿名映射，不指定文件名
- MAP_ANON: 和上一个是同义词
- MAP_FILE: 从普通文件映射而来(默认选型)
- MAP_FIXED: 要求addr必须是页面大小的整数倍，如果不是，调用失败。不推荐使用
- MAP_PRIVATE: 对被映射对象的修改尽进程自己可见（Copy on Write）
- MAP_SHARED: 修改对其他进程都可见
fd：要被映射的文件描述符(可以是普通文件，管道，连接等)，一般由open返回， -1表示匿名映射。
offset：被映射对象内容的起始地址

2.2.返回值

一旦调用成功，mmap返回被映射区域的指针，进程可以对这个指针进行读写。根据flags指定的模式，这些读写有可能被其他进程觉察到，由此实现基于共享内存的进程通信。

2.3.mmap用于共享内存的两种方式

匿名映射：把fd置为-1，指涉特殊文件，flags置为MAP_ANON，适用于具有亲缘关系的进程间通信
基于文件的映射：fd大于0，指涉普通文件，适用于任何进程间的通信。

2.3.1.匿名映射

匿名映射是一种没用对应文件的一种映射，是使用特殊文件提供的匿名内存映射：一个匿名映射没有对应的文件，这种映射的分页会被初始化为0。可以把它看成是一个内容总是被初始化为0的虚拟文件映射，比如在具有血缘关系的进程之间，如父子进程之间,　当一个进程调用mmap().之后又调用了fork(), 之后子进程会继承(拷贝)父进程映射后的空间，同时也继承了mmap()的返回地址，通过修改数据共享内存里的数据,　父子进程够可以感知到数据的变化，这样一来，父子进程就可以通过这块共享内存来实现进程间通信。

/* 例如一些网络套接字进行共享*/
ptr = mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0); pid = fork();
switch (pid)
{case pid < 0:printf ("err\n");case pid = 0:/* 使用互斥的方式访问共享内存 */lock(ptr)修改数据；unlock(ptr);case pid > 0:/* 使用互斥的方式访问共享内存 */lock(ptr)修改数据；unlock(ptr);
}

2.3.2.基于文件的映射：

适用于任何进程之间, 此时，需要打开或创建一个文件，然后再调用mmap(), 典型调用代码如下：

fd = open (name, flag, mode);
if(fd<0)
{printf("error!\n");
}/* 这块内存可读可写可执行 */
ptr = mmap(NULL, len , PROT_READ|PROT_WRITE|PROT_EXEC, MAP_SHARED , fd , 0);

这样用户进程就可以像读取内存一样读取文件了,效率非常高。

2.4.msync(void* addr, size_t len, int flags)

一般来说，进程对地址空间中共享内容的修改不会立即写入磁盘，而是等待munmap的调用后才执行写磁盘操作，而msync允许我们手工指定同步行为的发生。

2.5.int munmap(void* addr, size_t len)

解除进程空间某个地址(就是mmap返回的那个地址)和内核某个文件(就是mmap中的那个fd)之间的映射关系。

3.mmap系统调用

mmap属于系统调用，用户控件间接通过swi指令触发软中断，进入内核态（各种环境的切换），进入内核态之后，便可以调用内核函数进行处理。调用流程如下：

mmap->sys_mmap2-> sys_mmap_pgoff ->vm_mmap_pgoff->do_mmap_pgoff

3.1.sys_mmap2
include/uapi/asm-generic/unistd.h:

#define __NR_mmap __NR3264_mmap
#define __NR_mmap2 __NR3264_mmap
645 #define __NR3264_mmap 222
646 __SC_3264(__NR3264_mmap, sys_mmap2, sys_mmap)

sys_mmap2：

 arch/arm/kernel/entry-common.S:
410 sys_mmap2:
411         str r5, [sp, #4]
412         b   sys_mmap_pgoff
413 ENDPROC(sys_mmap2)

3.2.sys_mmap_pgoff：

kernel/mm/mmap.c:1509 SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,1510         unsigned long, prot, unsigned long, flags,1511         unsigned long, fd, unsigned long, pgoff)1512 {1513     struct file *file = NULL;1514     unsigned long retval;1515     //对非匿名文件映射的检查，必须能根据文件句柄找到struct file1516     if (!(flags & MAP_ANONYMOUS)) {1517         audit_mmap_fd(fd, flags);1518         file = fget(fd);1519         if (!file)1520             return -EBADF;1521         if (is_file_hugepages(file))1522             len = ALIGN(len, huge_page_size(hstate_file(file)));   //根据file->f_op来判断是否是hugepage，然后进行hugepage页面对齐。1523         retval = -EINVAL;                                                                             1524         if (unlikely(flags & MAP_HUGETLB && !is_file_hugepages(file)))1525             goto out_fput;1526     } else if (flags & MAP_HUGETLB) {1527         struct user_struct *user = NULL;1528         struct hstate *hs;1530         hs = hstate_sizelog((flags >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK);1531         if (!hs)1532             return -EINVAL;1533 1534         len = ALIGN(len, huge_page_size(hs));1535         /*1536          * VM_NORESERVE is used because the reservations will be1537          * taken when vm_ops->mmap() is called1538          * A dummy user value is used because we are not locking1539          * memory so no accounting is necessary1540          */1541         file = hugetlb_file_setup(HUGETLB_ANON_FILE, len,1542                 VM_NORESERVE,1543                 &user, HUGETLB_ANONHUGE_INODE,1544                 (flags >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK);                                           1545         if (IS_ERR(file))1546             return PTR_ERR(file);1547     }1548 1549     flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);1551     retval = vm_mmap_pgoff(file, addr, len, prot, flags, pgoff);   1552 out_fput:1553     if (file)1554         fput(file);                                                                                   1555     return retval;1556 }

一些常规的错误检查工作；
通过file = fget(fd);得到对应的struct file对象指针；
调用vm_mmap_pgoff(file, addr, len, prot, flags, pgoff)函数完成后续的映射工作。

3.3.调用 vm_mmap_pgoff：

  320 unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,321     unsigned long len, unsigned long prot,322     unsigned long flag, unsigned long pgoff)323 {324     unsigned long ret;325     struct mm_struct *mm = current->mm;                                                                326     unsigned long populate;327     LIST_HEAD(uf);328 329     ret = security_mmap_file(file, prot, flag);330     if (!ret) {331         if (down_write_killable(&mm->mmap_sem))332             return -EINTR;333         ret = do_mmap_pgoff(file, addr, len, prot, flag, pgoff,334                     &populate, &uf);335         up_write(&mm->mmap_sem);336         userfaultfd_unmap_complete(mm, &uf);337         if (populate)338             mm_populate(ret, populate);339     }340     return ret;341 }

3.4.do_mmap_pgoff

2172 static inline unsigned long
2173 do_mmap_pgoff(struct file *file, unsigned long addr,
2174     unsigned long len, unsigned long prot, unsigned long flags,
2175     unsigned long pgoff, unsigned long *populate,
2176     struct list_head *uf)
2177 {
2178     return do_mmap(file, addr, len, prot, flags, 0, pgoff, populate, uf);
2179 }

3.5.do_mmap

unsigned long do_mmap(struct file *file, unsigned long addr,unsigned long len, unsigned long prot,unsigned long flags, vm_flags_t vm_flags,unsigned long pgoff, unsigned long *populate)
{struct mm_struct *mm = current->mm;*populate = 0;if (!len)return -EINVAL;if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))if (!(file && path_noexec(&file->f_path)))prot |= PROT_EXEC;if (!(flags & MAP_FIXED)) //对于非MAP_FIXED，addr不能小于mmap_min_addr大小，如果小于则使用mmap_min_addr页对齐后的地址。addr = round_hint_to_min(addr);/* Careful about overflows.. */len = PAGE_ALIGN(len);if (!len)     //这里不是判断len是否为0，而是检查len是否溢出。return -ENOMEM;/* offset overflow? */if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)  //检查offset是否溢出return -EOVERFLOW;/* Too many mappings? */if (mm->map_count > sysctl_max_map_count)   //进程中mmap个数限制，超出返回ENOMEM错误。return -ENOMEM;addr = get_unmapped_area(file, addr, len, pgoff, flags); //在创建新的ma区域之前首先寻找一块足够大小的空闲区域，本函数就是用于查找未映射的区域，返回值addr就是这段空间的首地址。if (offset_in_page(addr))return addr;vm_flags |= calc_vm_prot_bits(prot) | calc_vm_flag_bits(flags) |mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC; //根据prot/flags以及mm->flags来得到vm_flags。if (flags & MAP_LOCKED)if (!can_do_mlock())return -EPERM;if (mlock_future_check(mm, vm_flags, len))return -EAGAIN;if (file) { //文件映射情况处理，主要更新vm_flags。struct inode *inode = file_inode(file);if (!file_mmap_ok(file, inode, pgoff, len))return -EOVERFLOW;switch (flags & MAP_TYPE) {case MAP_SHARED:   ///共享文件映射if ((prot&PROT_WRITE) && !(file->f_mode&FMODE_WRITE))return -EACCES;if (IS_APPEND(inode) && (file->f_mode & FMODE_WRITE))return -EACCES;if (locks_verify_locked(file))return -EAGAIN;vm_flags |= VM_SHARED | VM_MAYSHARE;if (!(file->f_mode & FMODE_WRITE))vm_flags &= ~(VM_MAYWRITE | VM_SHARED);case MAP_PRIVATE: //私有文件映射if (!(file->f_mode & FMODE_READ))return -EACCES;if (path_noexec(&file->f_path)) {if (vm_flags & VM_EXEC)return -EPERM;vm_flags &= ~VM_MAYEXEC;}if (!file->f_op->mmap)return -ENODEV;if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))return -EINVAL;break;default:return -EINVAL;}} else {   //匿名映射情况处理switch (flags & MAP_TYPE) {case MAP_SHARED:   //共享匿名映射if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))return -EINVAL;pgoff = 0;vm_flags |= VM_SHARED | VM_MAYSHARE;break;case MAP_PRIVATE:  //私有匿名映射pgoff = addr >> PAGE_SHIFT;break;default:return -EINVAL;}}if (flags & MAP_NORESERVE) {/* We honor MAP_NORESERVE if allowed to overcommit */if (sysctl_overcommit_memory != OVERCOMMIT_NEVER)vm_flags |= VM_NORESERVE;/* hugetlb applies strict overcommit unless MAP_NORESERVE */if (file && is_file_hugepages(file))vm_flags |= VM_NORESERVE;}addr = mmap_region(file, addr, len, vm_flags, pgoff);  //实际创建vmaif (!IS_ERR_VALUE(addr) &&((vm_flags & VM_LOCKED) ||(flags & (MAP_POPULATE | MAP_NONBLOCK)) == MAP_POPULATE))*populate = len;return addr;
}

3.5.1.get_unmapped_area()

  2104 unsigned long2105 get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,2106         unsigned long pgoff, unsigned long flags)2107 {2108     unsigned long (*get_area)(struct file *, unsigned long,2109                   unsigned long, unsigned long, unsigned long);                                       2110 2111     unsigned long error = arch_mmap_check(addr, len, flags);2112     if (error)2113         return error;2114 2115     /* Careful about overflows.. */2116     if (len > TASK_SIZE)2117         return -ENOMEM;2118     #匿名映射，指向当前进程的unmap 空间的分配函数2119     get_area = current->mm->get_unmapped_area;    #file 不为空的话，则unmap 空间的分配函数执行file中指定的函数2120     if (file) {2121         if (file->f_op->get_unmapped_area)2122             get_area = file->f_op->get_unmapped_area;2123     } else if (flags & MAP_SHARED) {#如果file为空，说明可能申请的是匿名空间，这里检查如果是共享内存的话，则分配函数执行共享内存的分配函数2129         pgoff = 0;2130         get_area = shmem_get_unmapped_area;2131     }2132    /* * 当不是用于文件内存映射或是匿名内存映射，* 调用current->mm->get_unmapped_area. * 即调用arch_get_unmapped_area或arch_get_unmapped_area_topdown*/2133     addr = get_area(file, addr, len, pgoff, flags);2134     if (IS_ERR_VALUE(addr))2135         return addr;2136 2137     if (addr > TASK_SIZE - len)                                                                       2138         return -ENOMEM;2139     if (offset_in_page(addr))2140         return -EINVAL;2141 2142     error = security_mmap_addr(addr);2143     return error ? error : addr;2144 }

get_unmapped_area是mmap实现的一个关键点，它实现mm-> get_unmapped_area与file->f_op->get_unmapped_area的选择。

如果是匿名映射，使用mm-> get_unmapped_area，如下所示：

  /* 每个进程的mm_struct里面都有一个get_unmapped_area函数比如arch/arm/mm/mmap.c里面，arch_pick_mmap_layout 函数对get_unmapped_area赋值。void arch_pick_mmap_layout(struct mm_struct *mm){...if (mmap_is_legacy()) {mm->mmap_base = mm->mmap_legacy_base;mm->get_unmapped_area = arch_get_unmapped_area;mm->unmap_area = arch_unmap_area;} else {mm->get_unmapped_area = arch_get_unmapped_area_topdown;mm->unmap_area = arch_unmap_area_topdown;}

选择布局的工作由arch_pick_mmap_layout完成。
arch_get_unmapped_area()完成从低地址向高地址创建新的映射；
arch_get_unmapped_area_topdown()完成从高地址向低地址创建新的映射。

如果驱动程序的file_operations定义了get_unmapped_area，则会使用驱动程序定义的方法file->f_op->get_unmapped_area，但是通常都不会有驱动程序定义这个方法，所以一般都是使用current->mm->get_unmapped_area 这个方法。目的是在mmap区域找到一块没有被映射过的vm_area_struct对象。

1>.以arch_get_unmapped_area为例：

当addr非空，表示指定了一个特定的优先选用地址，内核会检查该区域是否与现存区域重叠，由find_vma()完成查找功能。当addr为空或是指定的优先地址不满足分配条件时，内核必须遍历进程中可用的区域，设法找到一个大小适当的空闲区域，有vm_unmapped_area()做实际的工作。

unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,unsigned long len, unsigned long pgoff, unsigned long flags)
{struct mm_struct *mm = current->mm;struct vm_area_struct *vma;struct vm_unmapped_area_info info;if (len > TASK_SIZE - mmap_min_addr)return -ENOMEM;/* MAP_FIXED : 表示映射将在固定地址创建 */if (flags & MAP_FIXED)return addr;if (addr) {addr = PAGE_ALIGN(addr);/* * find_vma() 寻找第一个满足 addr < vm_area_struct->vm_end 的vma区* vma = NULL 在vma红黑树的右子树，addr 是所存在的所有线性区线性地址最大* vma != NULL 一定是tmp == NULL (tmp在find_vma指向当前结点)跳出循环的*/ vma = find_vma(mm, addr);/** 以下分别判断：* 1: 请求分配的长度是否小于进程虚拟地址空间大小* 2: 新分配的虚拟地址空间的起始地址是否在mmap_min_addr(允许分配虚拟地址空间的最低地址)之上* 3: vma是否空* 4: vma非空，新分配的虚拟地址空间，是否与相邻的vma重合*/if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&(!vma || addr + len <= vma->vm_start))return addr;
}info.flags = 0;info.length = len;info.low_limit = mm->mmap_base;info.high_limit = TASK_SIZE;info.align_mask = 0;return vm_unmapped_area(&info);
}//当addr为空或者指定的优选地址不满足分配条件时，内核必须遍历进程中可用的区域，设法找到一个大小适当的空闲区域，vm_unmapped_area()完成实际的工作。
static inline unsigned long vm_unmapped_area(struct vm_unmapped_area_info *info)
{/* arch_get_unmapped_area是低地址到高地址创建映射 所以这时默认调用unmapped_area */if (info->flags & VM_UNMAPPED_AREA_TOPDOWN)return unmapped_area_topdown(info); 从高地址到低地址穿点映射。elsereturn unmapped_area(info); 从低地址到高地址创建映射。
}

3.5.2.mmap_region

mmap_region是mmap实现的另一个关键点，它实现对设备文件或普通文件的file->f_op->mmap(file, vma)函数的调用mmap_region。

unsigned long mmap_region(struct file *file, unsigned long addr,unsigned long len, vm_flags_t vm_flags, unsigned long pgoff,struct list_head *uf)
{struct mm_struct *mm = current->mm;struct vm_area_struct *vma, *prev;...vma = vm_area_alloc(mm);...vma->vm_start = addr;vma->vm_end = addr + len;vma->vm_flags = vm_flags;vma->vm_page_prot = vm_get_page_prot(vm_flags);vma->vm_pgoff = pgoff;if (file) {...vma->vm_file = get_file(file);error = call_mmap(file, vma);...} else if (vm_flags & VM_SHARED) {...} else {vma_set_anonymous(vma);}vma_link(mm, vma, prev, rb_link, rb_parent);...return addr;...
}

该方法先调用vm_area_alloc，分配一个类型为struct vm_area_struct的实例，并赋值给vma，然后设置vma的起始地址、结束地址等信息。这个vma里包含的内容，就是上面pmap命令输出的内存段。之后，如果我们是想mmap一个file，则调用call_mmap：

static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
{return file->f_op->mmap(file, vma);
}

该方法又调用了file->f_op->mmap指针指向的方法，以ext4文件系统为例，该方法为ext4_file_mmap：

// fs/ext4/file.c
static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
{...if (IS_DAX(file_inode(file))) {...} else {vma->vm_ops = &ext4_file_vm_ops;}return 0;
}

最后 mmap_region方法返回该内存段的起始地址给用户。mmap系统调用只是为当前进程分配并初始化了一个vma实例，用来标识该进程拥有这段以vma表示的内存空间，并没有实际分配物理内存。

4.mmap案例测试

mmap_test.c:
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/time.h>
#include<fcntl.h>
#include<sys/mman.h>#define MAX 1024*128int main()
{int i=0;int count=0, fd=0;struct timeval tv1, tv2;char *array = (char *)malloc(MAX);/*read*/gettimeofday( &tv1, NULL );fd = open( "./mmap_test", O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);if(fd<0)printf("Open file failed\n");if(MAX != read( fd, (char*)array, MAX )){printf("Reading data failed...\n");return -1;}memset(array, 'a', MAX);lseek(fd,0,SEEK_SET);if(MAX != write(fd, (void *)array, MAX)){printf( "Writing data failed...\n" );return -1;}close( fd );gettimeofday( &tv2, NULL );free( array );printf( "Time of read/write: %ldus\n", (tv2.tv_usec - tv1.tv_usec));/*mmap*/gettimeofday( &tv1, NULL );fd = open( "./mmap_test2", O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);array = mmap( NULL, MAX, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);memset(array, 'b', MAX);munmap( array, MAX );msync( array, MAX, MS_SYNC );close( fd );gettimeofday( &tv2, NULL );printf( "Time of mmap/munmap/msync: %ldus\n", (tv2.tv_usec - tv1.tv_usec));return 0;
}

首先创建两个128KB的空文件，然后执行./mmap_test

dd bs=1024 count=128 if=/dev/zero of=./mmap_test
dd bs=1024 count=128 if=/dev/zero of=./mmap_test2

两个文件内容分别变成了’A’和’B’：

Time of read/write: 134us
Time of mmap/munmap/msync: 91us

refer to

https://www.jianshu.com/p/755338d11865
https://www.jianshu.com/p/71c9b73d788e
https://www.cnblogs.com/holyxp/p/10016582.html

linux 内存管理(15) - mmap相关推荐

Linux内存管理 brk(),mmap()系统调用源码分析2：brk()的内存释放流程
Linux brk(),mmap()系统调用源码分析 brk()的内存释放流程荣涛 2021年4月30日内核版本:linux-5.10.13 注释版代码:https://github.com/Rt ...
Linux内存管理 brk(),mmap()系统调用源码分析1：基础部分
Linux内存管理 brk(),mmap(),munmap()系统调用源码分析基础部分荣涛 2021年4月30日内核版本:linux-5.10.13 注释版代码:https://github.c ...
Linux内存管理子系统——mmap内存映射原理分析(dax文件系统的mmap)
Linux mmap分析内核版本:linux-5.16 1. 虚拟内存概要及相关内容简介内存映射是学习过操作系统的大家都耳熟能详的词,理解起来也很简单.所谓"映射"就是为一种事 ...
Linux内存管理之mmap详解
一. mmap系统调用 1. mmap系统调用 mmap将一个文件或者其它对象映射进内存.文件被映射到多个页上,如果文件的大小不是所有页的大小之和,最后一个页不被使用的空间将会清零.munmap执行相 ...
linux内存管理函数mmap和brk,brk() 和 mmap() 内存映射
参考博文:http://www.cnblogs.com/huxiao-tee/p/4660352.html x86平台下linux进程虚拟地址空间分布(2.6.7以前版本) mmap区域与栈区域相对增 ...
Linux内存管理基础
系统启动之Linux内存管理基础 Keywords 非一致内存访问(NUMA)模型.节点(node).内存管理区(Zone).一致内存访问(UMA)模型.内核页表.内存管理区分配器(伙伴系统Buddy ...
Windows内存管理和linux内存管理
windows内存管理 windows 内存管理方式主要分为:页式管理,段式管理,段页式管理. 页式管理的基本原理是将各进程的虚拟空间划分为若干个长度相等的页:页式管理把内存空间按照页的大小划分成片或 ...
Linux内存管理原理【转】
转自:http://www.cnblogs.com/zhaoyl/p/3695517.html 本文以32位机器为准,串讲一些内存管理的知识点. 1. 虚拟地址.物理地址.逻辑地址.线性地址虚拟地址 ...
Linux内存管理原理
本文以32位机器为准,串讲一些内存管理的知识点. 1. 虚拟地址.物理地址.逻辑地址.线性地址虚拟地址又叫线性地址.linux没有采用分段机制,所以逻辑地址和虚拟地址(线性地址)(在用户态,内核态逻 ...

linux 内存管理(15) - mmap

linux 内存管理(15) - mmap相关推荐

最新文章

热门文章