cached mmap() 系统调用能够将文件映射到内存空间,然后可以通过读写内存来读写文件

 

 

 mmap内存映射在应用和内核/驱动交互,进程间交互,大规模数据传输/大文件读写中的使用_mmap函数是用在内核么_王道泼的博客-CSDN博客 https://blog.csdn.net/sam2009944096/article/details/113040116

 

Linux 内存映射函数 mmap()函数详解 - 知乎 https://zhuanlan.zhihu.com/p/477641987

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上,如果文件的大小不是所有页的大小之和,最后一个页不被使用的空间将会清零。mmap在用户空间映射调用系统中作用很大。

头文件 <sys/mman.h>

函数原型

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

int munmap(void* start,size_t length);

mmap()[1] 必须以PAGE_SIZE为单位进行映射,而内存也只能以页为单位进行映射,若要映射非PAGE_SIZE整数倍的地址范围,要先进行内存对齐,强行以PAGE_SIZE的倍数大小进行映射。

用法:

下面说一下内存映射的步骤:
用open系统调用打开文件, 并返回描述符fd.
用mmap建立内存映射, 并返回映射首地址指针start.
对映射(文件)进行各种操作, 显示(printf), 修改(sprintf).
用munmap(void *start, size_t lenght)关闭内存映射.
用close系统调用关闭文件fd.

主要用途

UNIX网络编程第二卷进程间通信对mmap函数进行了说明。该函数主要用途有三个:
1、将一个普通文件映射到内存中,通常在需要对文件进行频繁读写时使用,这样用内存读写取代I/O读写,以获得较高的性能;
2、将特殊文件进行匿名内存映射,可以为关联进程提供共享内存空间;
3、为无关联的进程提供共享内存空间,一般也是将一个普通文件映射到内存中。

函数:void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize);
参数start:指向欲映射的内存起始地址,通常设为 NULL,代表让系统自动选定地址,映射成功后返回该地址。

参数length:代表将文件中多大的部分映射到内存。

参数prot:映射区域的保护方式。可以为以下几种方式的组合:
PROT_EXEC 映射区域可被执行
PROT_READ 映射区域可被读取
PROT_WRITE 映射区域可被写入
PROT_NONE 映射区域不能存取

参数flags:影响映射区域的各种特性。在调用mmap()时必须要指定MAP_SHARED 或MAP_PRIVATE。
MAP_FIXED 如果参数start所指的地址无法成功建立映射时,则放弃映射,不对地址做修正。通常不鼓励用此旗标。
MAP_SHARED对映射区域的写入数据会复制回文件内,而且允许其他映射该文件的进程共享。
MAP_PRIVATE 对映射区域的写入操作会产生一个映射文件的复制,即私人的“写入时复制”(copy on write)对此区域作的任何修改都不会写回原来的文件内容。
MAP_ANONYMOUS建立匿名映射。此时会忽略参数fd,不涉及文件,而且映射区域无法和其他进程共享。
MAP_DENYWRITE只允许对映射区域的写入操作,其他对文件直接写入的操作将会被拒绝。
MAP_LOCKED 将映射区域锁定住,这表示该区域不会被置换(swap)。

参数fd:要映射到内存中的文件描述符。如果使用匿名内存映射时,即flags中设置了MAP_ANONYMOUS,fd设为-1。有些系统不支持匿名内存映射,则可以使用fopen打开/dev/zero文件,然后对该文件进行映射,可以同样达到匿名内存映射的效果。

参数offset:文件映射的偏移量,通常设置为0,代表从文件最前方开始对应,offset必须是分页大小的整数倍。

返回值:

若映射成功则返回映射区的内存起始地址,否则返回MAP_FAILED(-1),错误原因存于errno 中。

错误代码:

EBADF 参数fd 不是有效的文件描述词
EACCES 存取权限有误。如果是MAP_PRIVATE 情况下文件必须可读,使用MAP_SHARED则要有PROT_WRITE以及该文件要能写入。
EINVAL 参数start、length 或offset有一个不合法。
EAGAIN 文件被锁住,或是有太多内存被锁住。
ENOMEM 内存不足。

系统调用mmap()用于共享内存的两种方式:
(1)使用普通文件提供的内存映射:

适用于任何进程之间。此时,需要打开或创建一个文件,然后再调用mmap()

典型调用代码如下:

fd=open(name, flag, mode); if(fd<0) ...

ptr=mmap(NULL, len , PROT_READ|PROT_WRITE, MAP_SHARED , fd , 0);

通过mmap()实现共享内存的通信方式有许多特点和要注意的地方,可以参看UNIX网络编程第二卷。

(2)使用特殊文件提供匿名内存映射:

适用于具有亲缘关系的进程之间。由于父子进程特殊的亲缘关系,在父进程中先调用mmap(),然后调用 fork()。那么在调用fork()之后,子进程继承父进程匿名映射后的地址空间,同样也继承mmap()返回的地址,这样,父子进程就可以通过映射区 域进行通信了。注意,这里不是一般的继承关系。一般来说,子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址,却由父子进程共同维护。 对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时,不必指定具体的文件,只要设置相应的标志即可。


一、概述

内存映射,简而言之就是将用户空间的一段内存区域映射到内核空间,映射成功后,用户对这段内存区域的修改可以直接反映到内核空间,同样,内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。
以下是一个把普遍文件映射到用户空间的内存区域的示意图。
图一:

 


二、基本函数


mmap函数是unix/linux下的系统调用,详细内容可参考《Unix Netword programming》卷二12.2节。
mmap系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式,进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的,当然mmap()实现共享内存也是其主要应用之一。
mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后,进程可以像访问普通内存一样对文件进行访问,不必再调用read(),write()等操作。mmap并不分配空间, 只是将文件映射到调用进程的地址空间里(但是会占掉你的 virutal memory), 然后你就可以用memcpy等操作写文件, 而不用write()了.写完后,内存中的内容并不会立即更新到文件中,而是有一段时间的延迟,你可以调用msync()来显式同步一下, 这样你所写的内容就能立即保存到文件里了.这点应该和驱动相关。 不过通过mmap来写文件这种方式没办法增加文件的长度, 因为要映射的长度在调用mmap()的时候就决定了.如果想取消内存映射,可以调用munmap()来取消内存映射

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

mmap用于把文件映射到内存空间中,简单说mmap就是把一个文件的内容在内存里面做一个映像。映射成功后,用户对这段内存区域的修改可以直接反映到内核空间,同样,内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。
start:要映射到的内存区域的起始地址,通常都是用NULL(NULL即为0)。NULL表示由内核来指定该内存地址

length:要映射的内存区域的大小
prot:期望的内存保护标志,不能与文件的打开模式冲突。是以下的某个值,可以通过or运算合理地组合在一起
PROT_EXEC //页内容可以被执行
PROT_READ //页内容可以被读取
PROT_WRITE //页可以被写入
PROT_NONE //页不可访问
flags:指定映射对象的类型,映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体
MAP_FIXED :使用指定的映射起始地址,如果由start和len参数指定的内存区重叠于现存的映射空间,重叠部分将会被丢弃。如果指定的起始地址不可用,操作将会失败。并且起始地址必须落在页的边界上。
MAP_SHARED :对映射区域的写入数据会复制回文件内, 而且允许其他映射该文件的进程共享。
MAP_PRIVATE :建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的,只能使用其中一个。
MAP_DENYWRITE :这个标志被忽略。
MAP_EXECUTABLE :同上
MAP_NORESERVE :不要为这个映射保留交换空间。当交换空间被保留,对映射区修改的可能会得到保证。当交换空间不被保留,同时内存不足,对映射区的修改会引起段违例信号。
MAP_LOCKED :锁定映射区的页面,从而防止页面被交换出内存。
MAP_GROWSDOWN :用于堆栈,告诉内核VM系统,映射区可以向下扩展。
MAP_ANONYMOUS :匿名映射,映射区不与任何文件关联。
MAP_ANON :MAP_ANONYMOUS的别称,不再被使用。
MAP_FILE :兼容标志,被忽略。
MAP_32BIT :将映射区放在进程地址空间的低2GB,MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。
MAP_POPULATE :为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
MAP_NONBLOCK :仅和MAP_POPULATE一起使用时才有意义。不执行预读,只为已存在于内存中的页面建立页表入口。

fd:文件描述符(由open函数返回)

offset:表示被映射对象(即文件)从那里开始对映,通常都是用0。 该值应该为大小为PAGE_SIZE的整数倍

返回说明
成功执行时,mmap()返回被映射区的指针,munmap()返回0。失败时,mmap()返回MAP_FAILED[其值为(void *)-1],munmap返回-1。errno被设为以下的某个值
EACCES:访问出错
EAGAIN:文件已被锁定,或者太多的内存已被锁定
EBADF:fd不是有效的文件描述词
EINVAL:一个或者多个参数无效
ENFILE:已达到系统对打开文件的限制
ENODEV:指定文件所在的文件系统不支持内存映射
ENOMEM:内存不足,或者进程已超出最大内存映射数量
EPERM:权能不足,操作不允许
ETXTBSY:已写的方式打开文件,同时指定MAP_DENYWRITE标志
SIGSEGV:试着向只读区写入
SIGBUS:试着访问不属于进程的内存区

int munmap(void *start, size_t length) 

start:要取消映射的内存区域的起始地址
length:要取消映射的内存区域的大小。
返回说明
成功执行时munmap()返回0。失败时munmap返回-1.
int msync(const void *start, size_t length, int flags);

对映射内存的内容的更改并不会立即更新到文件中,而是有一段时间的延迟,你可以调用msync()来显式同步一下, 这样你内存的更新就能立即保存到文件里
start:要进行同步的映射的内存区域的起始地址。
length:要同步的内存区域的大小
flag:flags可以为以下三个值之一:
MS_ASYNC : 请Kernel快将资料写入。
MS_SYNC : 在msync结束返回前,将资料写入。
MS_INVALIDATE : 让核心自行决定是否写入,仅在特殊状况下使用

三、用户空间和驱动程序的内存映射

3.1、基本过程

首先,驱动程序先分配好一段内存,接着用户进程通过库函数mmap()来告诉内核要将多大的内存映射到内核空间,内核经过一系列函数调用后调用对应的驱动程序的file_operation中指定的mmap函数,在该函数中调用remap_pfn_range()来建立映射关系。

3.2、映射的实现

首先在驱动程序分配一页大小的内存,然后用户进程通过mmap()将用户空间中大小也为一页的内存映射到内核空间这页内存上。映射完成后,驱动程序往这段内存写10个字节数据,用户进程将这些数据显示出来。

驱动程序:

#include <linux/miscdevice.h> 
#include <linux/delay.h> 
#include <linux/kernel.h> 
#include <linux/module.h> 
#include <linux/init.h> 
#include <linux/mm.h> 
#include <linux/fs.h> 
#include <linux/types.h> 
#include <linux/delay.h> 
#include <linux/moduleparam.h> 
#include <linux/slab.h> 
#include <linux/errno.h> 
#include <linux/ioctl.h> 
#include <linux/cdev.h> 
#include <linux/string.h> 
#include <linux/list.h> 
#include <linux/pci.h> 
#include <linux/gpio.h> 
 
 
#define DEVICE_NAME "mymap" 
 
 
static unsigned char array[10]={0,1,2,3,4,5,6,7,8,9}; 
static unsigned char *buffer; 
 
 
static int my_open(struct inode *inode, struct file *file) 
{ 
return 0; 
} 
 
 
static int my_map(struct file *filp, struct vm_area_struct *vma) 
{ 
unsigned long page; 
unsigned char i; 
unsigned long start = (unsigned long)vma->vm_start; 
//unsigned long end = (unsigned long)vma->vm_end; 
unsigned long size = (unsigned long)(vma->vm_end - vma->vm_start); 
 
//得到物理地址 
page = virt_to_phys(buffer); 
//将用户空间的一个vma虚拟内存区映射到以page开始的一段连续物理页面上 
if(remap_pfn_range(vma,start,page>>PAGE_SHIFT,size,PAGE_SHARED))//第三个参数是页帧号,由物理地址右移PAGE_SHIFT得到 
return -1; 
 
//往该内存写10字节数据 
for(i=0;i<10;i++) 
buffer[i] = array[i]; 
 
return 0; 
} 
 
 
static struct file_operations dev_fops = { 
.owner = THIS_MODULE, 
.open = my_open, 
.mmap = my_map, 
}; 
 
static struct miscdevice misc = { 
.minor = MISC_DYNAMIC_MINOR, 
.name = DEVICE_NAME, 
.fops = &dev_fops, 
}; 
 
 
static int __init dev_init(void) 
{ 
int ret; 
 
//注册混杂设备 
ret = misc_register(&misc); 
//内存分配 
buffer = (unsigned char *)kmalloc(PAGE_SIZE,GFP_KERNEL); 
//将该段内存设置为保留 
SetPageReserved(virt_to_page(buffer)); 
 
return ret; 
} 
 
 
static void __exit dev_exit(void) 
{ 
//注销设备 
misc_deregister(&misc); 
//清除保留 
ClearPageReserved(virt_to_page(buffer)); 
//释放内存 
kfree(buffer); 
} 
 
 
module_init(dev_init); 
module_exit(dev_exit); 
MODULE_LICENSE("GPL"); 
MODULE_AUTHOR("LKN@SCUT"); 

应用程序

#include <unistd.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <fcntl.h> 
#include <linux/fb.h> 
#include <sys/mman.h> 
#include <sys/ioctl.h> 
 
#define PAGE_SIZE 4096 
 
 
int main(int argc , char *argv[]) 
{ 
int fd; 
int i; 
unsigned char *p_map; 
 
//打开设备 
fd = open("/dev/mymap",O_RDWR); 
if(fd < 0) 
{ 
printf("open fail\n"); 
exit(1); 
} 
 
//内存映射 
p_map = (unsigned char *)mmap(0, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0); 
if(p_map == MAP_FAILED) 
{ 
printf("mmap fail\n"); 
goto here; 
} 
 
//打印映射后的内存中的前10个字节内容 
for(i=0;i<10;i++) 
printf("%d\n",p_map[i]); 
 
 
here: 
munmap(p_map, PAGE_SIZE); 
return 0; 
} 

先加载驱动后执行应用程序,用户空间打印如下:

 

 

Linux 内存映射函数 mmap()函数详解 - 知乎 https://zhuanlan.zhihu.com/p/477641987

 

在《一文看懂零拷贝技术》中我们介绍了 零拷贝技术 的原理,而且我们知道 mmap 也是零拷贝技术的一种实现。在本文中,我们主要介绍 mmap 的原理。

一、传统的读写文件

一般来说,修改一个文件的内容需要如下3个步骤:

  • 把文件内容读入到内存中。
  • 修改内存中的内容。
  • 把内存的数据写入到文件中。

过程如图 1 所示:

如果使用代码来实现上面的过程,代码如下:

read(fd, buf, 1024);  // 读取文件的内容到buf
...                   // 修改buf的内容
write(fd, buf, 1024); // buf的内容写入到文件

从图 1 中可以看出,页缓存(page cache) 是读写文件时的中间层,内核使用 页缓存 与文件的数据块关联起来。所以应用程序读写文件时,实际操作的是 页缓存

二、使用 mmap 读写文件

从传统读写文件的过程中,我们可以发现有个地方可以优化:如果可以直接在用户空间读写 页缓存,那么就可以免去将 页缓存 的数据复制到用户空间缓冲区的过程。

那么,有没有这样的技术能实现上面所说的方式呢?答案是肯定的,就是 mmap

使用 mmap 系统调用可以将用户空间的虚拟内存地址与文件进行映射(绑定),对映射后的虚拟内存地址进行读写操作就如同对文件进行读写操作一样。原理如图 2 所示:

前面我们介绍过,读写文件都需要经过 页缓存,所以 mmap 映射的正是文件的 页缓存,而非磁盘中的文件本身。由于 mmap 映射的是文件的 页缓存,所以就涉及到同步的问题,即 页缓存 会在什么时候把数据同步到磁盘。

Linux 内核并不会主动把 mmap 映射的 页缓存 同步到磁盘,而是需要用户主动触发。同步 mmap 映射的内存到磁盘有 4 个时机:

  • 调用 msync 函数主动进行数据同步(主动)。
  • 调用 munmap 函数对文件进行解除映射关系时(主动)。
  • 进程退出时(被动)。
  • 系统关机时(被动)。

三、mmap的使用方式

下面我们介绍一下怎么使用 mmapmmap 函数的原型如下:

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

下面介绍一下 mmap 函数的各个参数作用:

  • addr:指定映射的虚拟内存地址,可以设置为 NULL,让 Linux 内核自动选择合适的虚拟内存地址。
  • length:映射的长度。
  • prot:映射内存的保护模式,可选值如下:
    • PROT_EXEC:可以被执行。
    • PROT_READ:可以被读取。
    • PROT_WRITE:可以被写入。
    • PROT_NONE:不可访问。
  • flags:指定映射的类型,常用的可选值如下:
    • MAP_FIXED:使用指定的起始虚拟内存地址进行映射。
    • MAP_SHARED:与其它所有映射到这个文件的进程共享映射空间(可实现共享内存)。
    • MAP_PRIVATE:建立一个写时复制(Copy on Write)的私有映射空间。
    • MAP_LOCKED:锁定映射区的页面,从而防止页面被交换出内存。
    • ...
  • fd:进行映射的文件句柄。
  • offset:文件偏移量(从文件的何处开始映射)。

介绍完 mmap 函数的原型后,我们现在通过一个简单的例子介绍怎么使用 mmap

int fd = open(filepath, O_RDWR, 0644);                           // 打开文件
void *addr = mmap(NULL, 8192, PROT_WRITE, MAP_SHARED, fd, 4096); // 对文件进行映射

在上面例子中,我们先通过 open 函数以可读写的方式打开文件,然后通过 mmap 函数对文件进行映射,映射的方式如下:

  • addr 参数设置为 NULL,表示让操作系统自动选择合适的虚拟内存地址进行映射。
  • length 参数设置为 8192 表示映射的区域为 2 个内存页的大小(一个内存页的大小为 4 KB)。
  • prot 参数设置为 PROT_WRITE 表示映射的内存区为可读写。
  • flags 参数设置为 MAP_SHARED 表示共享映射区。
  • fd 参数设置打开的文件句柄。
  • offset 参数设置为 4096 表示从文件的 4096 处开始映射。

mmap 函数会返回映射后的内存地址,我们可以通过此内存地址对文件进行读写操作。我们通过图 3 展示上面例子在内核中的结构:

四、总结

本文主要介绍了 mmap 的原理和使用方式,通过本文我们可以知道,使用 mmap 对文件进行读写操作时可以减少内存拷贝的次数,并且可以减少系统调用的次数,从而提高对读写文件操作的效率。

由于内核不会主动同步 mmap 所映射的内存区中的数据,所以在某些特殊的场景下可能会出现数据丢失的情况(如断电)。为了避免数据丢失,在使用 mmap 的时候可以在适当时主动调用 msync 函数来同步映射内存区的数据。

 

 一文读懂 mmap 原理 - 知乎 https://zhuanlan.zhihu.com/p/366964820

mmap() 系统调用介绍

mmap() 系统调用能够将文件映射到内存空间,然后可以通过读写内存来读写文件。我们先来看看 mmap() 系统调用的用法吧,mmap() 函数的原型如下:

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

参数说明:

  • start:指定要映射的内存地址,一般设置为 NULL 让操作系统自动选择合适的内存地址。
  • length:映射地址空间的字节数,它从被映射文件开头 offset 个字节开始算起。
  • prot:指定共享内存的访问权限。可取如下几个值的可选:PROT_READ(可读), PROT_WRITE(可写), PROT_EXEC(可执行), PROT_NONE(不可访问)。
  • flags:由以下几个常值指定:MAP_SHARED(共享的) MAP_PRIVATE(私有的), MAP_FIXED(表示必须使用 start 参数作为开始地址,如果失败不进行修正),其中,MAP_SHARED , MAP_PRIVATE必选其一,而 MAP_FIXED 则不推荐使用。
  • fd:表示要映射的文件句柄。
  • offset:表示映射文件的偏移量,一般设置为 0 表示从文件头部开始映射。

函数的返回值为最后文件映射到进程空间的地址,进程可直接操作起始地址为该值的有效地址。

下面通过一个例子来说明 mmap() 系统调用的用法:

int main() {
...
fd = open(name, flag, mode);
if (fd < 0) {
// error process...
exit(1);
}

addr = mmap(NULL, len, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_SHARED, fd, 0);
if (addr < 0) {
// error process...
exit(1);
}

memset(addr, 0, len);
...
exit(0);
}

上面的例子首先通过 open() 系统调用打开一个文件,然后通过调用 mmap() 把文件映射到内存空间,映射成功后就可以通过操作函数返回的内存地址来对文件进行读写操作。

mmap() 底层原理

在分析 mmap() 系统调用原理之前,首先要知道操作系统的虚拟内存空间与物理内存空间的概念。

在 32位的 Linux 内核中,每个进程都独有 4GB 的虚拟内存空间,但所有进程却共用相同的物理内存空间。物理内存空间就是安装在电脑上的内存条,如果内存条只有 1GB,那么物理内存空间就只有 1GB。但虚拟内存空间是逻辑上的内存空间,虚拟内存空间必须映射到物理内存空间才能使用。

虚拟内存空间与物理内存空间映射关系如下:

映射是按内存页进行的,一个内存页为 4KB 大小。在上图中,P1 是进程1,P2 是进程2。进程1的虚拟内存页A映射到物理内存页A,进程2的虚拟内存页A映射到物理内存页B。进程1的虚拟内存页B和进程2的虚拟内存页B同时映射到物理内存页C,也就是说进程1和进程2共享了物理内存页C。

vm_area_struct 结构

在Linux内核中,虚拟内存是用过结构体 vm_area_struct 来管理的,通过 vm_area_struct 结构体可以把虚拟内存划分为多个用途不相同的内存区,比如可以划分为数据段区、代码段区等等,vm_area_struct 结构体的定义如下:

struct vm_area_struct {
struct mm_struct * vm_mm;   /* The address space we belong to. */
unsigned long vm_start;     /* Our start address within vm_mm. */
unsigned long vm_end;       /* The first byte after our end address
                       within vm_mm. */

/* linked list of VM areas per task, sorted by address */
struct vm_area_struct *vm_next;

pgprot_t vm_page_prot;      /* Access permissions of this VMA. */
unsigned long vm_flags;     /* Flags, listed below. */

rb_node_t vm_rb;

struct vm_area_struct *vm_next_share;
struct vm_area_struct **vm_pprev_share;

/* Function pointers to deal with this struct. */
struct vm_operations_struct * vm_ops;
...
struct file * vm_file;       /* File we map to (can be NULL). */
...
};

vm_area_struct 结构各个字段作用:

  • vm_mm:指向进程内存空间管理对象。
  • vm_start:内存区的开始地址。
  • vm_end:内存区的结束地址。
  • vm_next:用于连接进程的所有内存区。
  • vm_page_prot:指定内存区的访问权限。
  • vm_flags:内存区的一些标志。
  • vm_file:指向映射的文件对象。
  • vm_ops:内存区的一些操作函数。

 

vm_area_struct 结构与虚拟内存地址的关系如下图:

每个进程都由 task_struct 结构进行管理,task_struct 结构中的 mm 成员指向了每个进程的内存管理结构 mm_struct,而 mm_struct 结构的 mmap 成员记录了进程虚拟内存空间各个内存区的 vm_area_struct 结构链表。

当调用 mmap() 时,内核会创建一个 vm_area_struct 结构,并且把 vm_start 和 vm_end 指向虚拟内存空间的某个内存区,并且把 vm_file 字段指向映射的文件对象。然后调用文件对象的 mmap 接口来对 vm_area_struct 结构的 vm_ops 成员进行初始化,如 ext2 文件系统的文件对象会调用 generic_file_mmap() 函数进行初始化,代码如下:

static struct vm_operations_struct generic_file_vm_ops = {
nopage:     filemap_nopage,
};

int generic_file_mmap(struct file * file, struct vm_area_struct * vma)
{
struct address_space *mapping = file->f_dentry->d_inode->i_mapping;
struct inode *inode = mapping->host;
  
if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) {
if (!mapping->a_ops->writepage)
return -EINVAL;
}
if (!mapping->a_ops->readpage)
return -ENOEXEC;
UPDATE_ATIME(inode);
vma->vm_ops = &generic_file_vm_ops;
return 0;
}

vm_operations_struct 结构的 nopage 接口会在访问内存发生异常时被调用,上面指向的是 filemap_nopage() 函数,filemap_nopage() 函数的主要工作是:

  1. 把映射到虚拟内存区的文件内容读入到物理内存页中。
  2. 对访问发生异常的虚拟内存地址与物理内存地址进行映射。

处理过程如下图:

如上图所示,虚拟内存页m 映射到 物理内存页x,并且把映射的文件的内容读入到物理内存中,这样就把内存与文件的映射关系建立起来,对映射的内存区进行读写操作实际上就是对文件的读写操作。

一般来说,对映射的内存空间进行读写并不会实时写入到文件中,所以要对内存与文件进行同步时需要调用 msync() 函数来实现。

对文件的读写

像 read()/write() 这些系统调用,首先需要进行内核空间,然后把文件内容读入到缓存中,然后再对缓存进行读写操作,最后由内核定时同步到文件中。过程如下图:

而调用 mmap() 系统调用对文件进行映射后,用户对映射后的内存进行读写实际上是对文件缓存的读写,所以减少了一次系统调用,从而加速了对文件读写的效率。如下图:

 

 

Linux mmap完全剖析 - 知乎 https://zhuanlan.zhihu.com/p/348586130

 

 

 /proc/sys/vm/

 

[root@iZ config]# ll -as /proc/sys/vm/
total 0
0 dr-xr-xr-x 1 root root 0 Mar 15 11:05 .
0 dr-xr-xr-x 1 root root 0 Jan 5 04:41 ..
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 admin_reserve_kbytes
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 block_dump
0 --w------- 1 root root 0 Mar 15 11:05 compact_memory
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 dirty_background_bytes
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 dirty_background_ratio
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 dirty_bytes
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 dirty_expire_centisecs
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 dirty_ratio
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 dirty_writeback_centisecs
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 drop_caches
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 extfrag_threshold
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 hugepages_treat_as_movable
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 hugetlb_shm_group
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 laptop_mode
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 legacy_va_layout
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 lowmem_reserve_ratio
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 max_map_count
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 memory_failure_early_kill
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 memory_failure_recovery
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 min_free_kbytes
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 min_slab_ratio
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 min_unmapped_ratio
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 mmap_min_addr
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 nr_hugepages
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 nr_hugepages_mempolicy
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 nr_overcommit_hugepages
0 -r--r--r-- 1 root root 0 Mar 15 11:05 nr_pdflush_threads
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 numa_zonelist_order
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 oom_dump_tasks
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 oom_kill_allocating_task
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 overcommit_kbytes
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 overcommit_memory
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 overcommit_ratio
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 page-cluster
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 panic_on_oom
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 percpu_pagelist_fraction
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 scan_unevictable_pages
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 stat_interval
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 swappiness
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 user_reserve_kbytes
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 vfs_cache_pressure
0 -rw-r--r-- 1 root root 0 Mar 15 11:05 zone_reclaim_mode
[root@iZ config]# free -g

 

 

 

posted @ 2018-03-15 11:11  papering  阅读(396)  评论(0编辑  收藏  举报