mmap - 用户空间与内核空间

mmap概述

共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式, 因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据: 一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。

传统文件访问
UNIX访问文件的传统方法是用open打开它们, 如果有多个进程访问同一个文件, 则每一个进程在自己的地址空间都包含有该文件的副本,这不必要地浪费了存储空间. 下图说明了两个进程同时读一个文件的同一页的情形. 系统要将该页从磁盘读到高速缓冲区中, 每个进程再执行一个存储器内的复制操作将数据从高速缓冲区读到自己的地址空间.

共享存储映射
现在考虑另一种处理方法:　进程A和进程B都将该页映射到自己的地址空间, 当进程A第一次访问该页中的数据时, 它生成一个缺页中断. 内核此时读入这一页到内存并更新页表使之指向它.以后, 当进程B访问同一页面而出现缺页中断时, 该页已经在内存, 内核只需要将进程B的页表登记项指向次页即可. 如下图所示:

mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存，普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read和write等。

---

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);
int msync ( void * addr , size_t len, int flags) 通过调用msync()实现磁盘上文件内容与共享内存区的内容一致

作用：
mmap将一个文件或者其他对象映射进内存，当文件映射到进程后，就可以直接操作这段虚拟地址进行文件的读写等操作。

参数说明：
start：映射区的开始地址
length：映射区的长度
prot：期望的内存保护标志
—-PROT_EXEC //页内容可以被执行
—-PROT_READ //页内容可以被读取
—-PROT_WRITE //页可以被写入
—-PROT_NONE //页不可访问
flags：指定映射对象的类型
—-MAP_FIXED
—-MAP_SHARED 与其它所有映射这个对象的进程共享映射空间
—-MAP_PRIVATE 建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件
—-MAP_ANONYMOUS 匿名映射，映射区不与任何文件关联
fd：如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1
offset：被映射对象内容的起点

---

通过共享映射的方式修改文件

系统调用mmap可以将文件映射至内存(进程空间)，如此可以把对文件的操作转为对内存的操作，以此避免更多的lseek()、read()、write()等系统调用，这点对于大文件或者频繁访问的文件尤其有用，提高了I/O效率。
下面例子中测试所需的data.txt文件内容如下：

aaaaaaaaa
bbbbbbbbb
ccccccccc
ddddddddd

/*
 * mmap file to memory
 * ./mmap1 data.txt
 */
#include <stdio.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
        int fd = -1;
        struct stat sb;
        char *mmaped = NULL;

        fd = open(argv[1], O_RDWR);
        if (fd < 0) {
                fprintf(stderr, "open %s fail\n", argv[1]);
                exit(-1);
        }

        if (stat(argv[1], &sb) < 0) {
                fprintf(stderr, "stat %s fail\n", argv[1]);
                goto err;
        }

        /* 将文件映射至进程的地址空间 */
        mmaped = (char *)mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (mmaped == (char *)-1) {
                fprintf(stderr, "mmap fail\n");
                goto err;
        }

        /* 映射完后, 关闭文件也可以操纵内存 */
        close(fd);
        printf("%s", mmaped);

        mmaped[5] = '$';
        if (msync(mmaped, sb.st_size, MS_SYNC) < 0) {
                fprintf(stderr, "msync fail\n");
                goto err;
        }

        return 0;

err:
        if (fd > 0)
                close(fd);

        if (mmaped != (char *)-1)
                munmap(mmaped, sb.st_size);

        return -1;
}

---

通过共享映射实现两个进程之间的通信

两个程序映射同一个文件到自己的地址空间, 进程A先运行, 每隔两秒读取映射区域, 看是否发生变化.
进程B后运行, 它修改映射区域, 然后推出, 此时进程A能够观察到存储映射区的变化
进程A的代码：

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

    #define BUF_SIZE 100  

    int main(int argc, char **argv)  
    {  
        int fd, nread, i;  
        struct stat sb;  
        char *mapped, buf[BUF_SIZE];  

        for (i = 0; i < BUF_SIZE; i++) {  
            buf[i] = '#';  
        }  

        /* 打开文件 */  
        if ((fd = open(argv[1], O_RDWR)) < 0) {  
            perror("open");  
        }  

        /* 获取文件的属性 */  
        if ((fstat(fd, &sb)) == -1) {  
            perror("fstat");  
        }  

        /* 将文件映射至进程的地址空间 */  
        if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
                        PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
            perror("mmap");  
        }  

        /* 文件已在内存, 关闭文件也可以操纵内存 */  
        close(fd);  

        /* 每隔两秒查看存储映射区是否被修改 */  
        while (1) {  
            printf("%s\n", mapped);  
            sleep(2);  
        }  

        return 0;  
    }  

进程B的代码：

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

    #define BUF_SIZE 100  

    int main(int argc, char **argv)  
    {  
        int fd, nread, i;  
        struct stat sb;  
        char *mapped, buf[BUF_SIZE];  

        for (i = 0; i < BUF_SIZE; i++) {  
            buf[i] = '#';  
        }  

        /* 打开文件 */  
        if ((fd = open(argv[1], O_RDWR)) < 0) {  
            perror("open");  
        }  

        /* 获取文件的属性 */  
        if ((fstat(fd, &sb)) == -1) {  
            perror("fstat");  
        }  

        /* 私有文件映射将无法修改文件 */  
        if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
                        PROT_WRITE, MAP_PRIVATE, fd, 0)) == (void *)-1) {  
            perror("mmap");  
        }  

        /* 映射完后, 关闭文件也可以操纵内存 */  
        close(fd);  

        /* 修改一个字符 */  
        mapped[20] = '9';  

        return 0;  
    }  

---

通过匿名映射实现父子进程通信

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

    #define BUF_SIZE 100  

    int main(int argc, char** argv)  
    {  
        char    *p_map;  

        /* 匿名映射,创建一块内存供父子进程通信 */  
        p_map = (char *)mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,  
                MAP_SHARED | MAP_ANONYMOUS, -1, 0);  

        if(fork() == 0) {  
            sleep(1);  
            printf("child got a message: %s\n", p_map);  
            sprintf(p_map, "%s", "hi, dad, this is son");  
            munmap(p_map, BUF_SIZE); //实际上，进程终止时，会自动解除映射。  
            exit(0);  
        }  

        sprintf(p_map, "%s", "hi, this is father");  
        sleep(2);  
        printf("parent got a message: %s\n", p_map);  

        return 0;  
    }  

---

对mmap返回地址的访问

linux采用的是页式管理机制。对于用mmap()映射普通文件来说，进程会在自己的地址空间新增一块空间，空间大
小由mmap()的len参数指定，注意，进程并不一定能够对全部新增空间都能进行有效访问。进程能够访问的有效地址大小取决于文件被映射部分的大小。简单的说，能够容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，能够有效访问的地址空间大小。超过这个空间大小，内核会根据超过的严重程度返回发送不同的信号给进程。可用如下图示说明：

总结一下就是, 文件大小, mmap的参数 len 都不能决定进程能访问的大小, 而是容纳文件被映射部分的最小页面数决定进程能访问的大小. 下面看一个实例：

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

    int main(int argc, char** argv)  
    {  
        int fd,i;  
        int pagesize,offset;  
        char *p_map;  
        struct stat sb;  

        /* 取得page size */  
        pagesize = sysconf(_SC_PAGESIZE);  
        printf("pagesize is %d\n",pagesize);  

        /* 打开文件 */  
        fd = open(argv[1], O_RDWR, 00777);  
        fstat(fd, &sb);  
        printf("file size is %zd\n", (size_t)sb.st_size);  

        offset = 0;   
        p_map = (char *)mmap(NULL, pagesize * 2, PROT_READ|PROT_WRITE,   
                MAP_SHARED, fd, offset);  
        close(fd);  

        p_map[sb.st_size] = '9';  /* 导致总线错误 */  
        p_map[pagesize] = '9';    /* 导致段错误 */  

        munmap(p_map, pagesize * 2);  

        return 0;  
    }  

---

mmap内核空间

内核空间mmap函数原型

内核空间的mmap函数原型为：int (*map)(struct file *filp, struct vm_area_struct *vma);
作用是实现用户进程中的地址与内核中物理页面的映射

---

mmap函数实现步骤

内核空间mmap函数具体实现步骤如下：
1. 通过kmalloc, get_free_pages, vmalloc等分配一段虚拟地址
2. 如果是使用kmalloc, get_free_pages分配的虚拟地址，那么使用virt_to_phys()将其转化为物理地址，再将得到的物理地址通过”phys>>PAGE_SHIFT”获取其对应的物理页面帧号。或者直接使用virt_to_page从虚拟地址获取得到对应的物理页面帧号。
如果是使用vmalloc分配的虚拟地址，那么使用vmalloc_to_pfn获取虚拟地址对应的物理页面的帧号。
3. 对每个页面调用SetPageReserved()标记为保留才可以。
4. 通过remap_pfn_range为物理页面的帧号建立页表，并映射到用户空间。
说明：kmalloc, get_free_pages, vmalloc分配的物理内存页面最好还是不要用remap_pfn_range，建议使用VMA的nopage方法。

说明：
若共享小块连续内存，上面所说的get_free_pages就可以分配多达几M的连续空间，
若共享大块连续内存，就得靠uboot帮忙，给linux kernel传递参数的时候指定”mem=”，然后在内核中使用下面两个函数来预留和释放内存。
void *alloc_bootmem(unsigned long size);
void free_bootmem(unsigned long addr, unsigned long size);

---

mmap函数实现例子

在字符设备驱动中，有一个struct file_operation结构提，其中fops->mmap指向你自己的mmap钩子函数，用户空间对一个字符设备文件进行mmap系统调用后，最终会调用驱动模块里的mmap钩子函数。在mmap钩子函数中需要调用下面这个API：

int remap_pfn_range(struct vm_area_struct *vma, //这个结构很重要！！后面讲
                    unsigned long virt_addr,    //要映射的范围的首地址
                    unsigned long pfn,          //要映射的范围对应的物理内存的页帧号！！重要
                    unsigned long size,         //要映射的范围的大小
                    pgprot_t prot);             //PROTECT属性，mmap()中来的

在mmap钩子函数中，像下面这样就可以了

    int my_mmap(struct file *filp, struct vm_area_struct *vma){
       //......省略，page很重要,其他的参数一般照下面就可以了
       remap_pfn_range(vma, vma->vm_start, page, (vma->vm_end - vma->vm_start), vma->vm_page_prot);
       //......省略
    }

来看一个例子：
内核空间代码mymap.c

#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 phys;

        //得到物理地址
        phys = virt_to_phys(buffer);
        //将用户空间的一个vma虚拟内存区映射到以page开始的一段连续物理页面上
        if(remap_pfn_range(vma,
                        vma->vm_start,
                        phys >> PAGE_SHIFT,//第三个参数是页帧号，由物理地址右移PAGE_SHIFT得>到
                        vma->vm_end - vma->vm_start,
                        vma->vm_page_prot))
                return -1;

        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 ssize_t hwrng_attr_current_show(struct device *dev,
                                struct device_attribute *attr, char *buf)
{
        int i;

        for(i = 0; i < 10 ; i++){
                printk("%d\n", buffer[i]);
        }

        return 0;
}
static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR, hwrng_attr_current_show, NULL);

static int __init dev_init(void)
{
        int ret;
        unsigned char i;

        //内存分配
        buffer = (unsigned char *)kmalloc(PAGE_SIZE,GFP_KERNEL);
        //driver起来时初始化内存前10个字节数据
        for(i = 0;i < 10;i++)
                buffer[i] = array[i];
        //将该段内存设置为保留
        SetPageReserved(virt_to_page(buffer));

        //注册混杂设备
        ret = misc_register(&misc);
        ret = device_create_file(misc.this_device, &dev_attr_rng_current);

        return ret;
}

static void __exit dev_exit(void)
{
        device_remove_file(misc.this_device, &dev_attr_rng_current);
        //注销设备
        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");

用户空间代码mymap_app.c

/*
 * /home/lei_wang/xxx/xxx_linux/toolchain/xxx/bin/xxx-linux-gcc mymap_app.c -o mymap_app
 */
#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>
#include <errno.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(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if(p_map == (void *)-1) {
                printf("mmap fail\n");
                goto here;
        }

        close(fd);
        //打印映射后的内存中的前10个字节内容,
        //并将前10个字节中的内容都加上10，写入内存中
        //通过cat cat /sys/devices/virtual/misc/mymap/rng_current查看内存是否被修改
        for(i = 0;i < 10;i++) {
                printf("%d\n",p_map[i]);
                p_map[i] = p_map[i] + 10;
        }

here:
        munmap(p_map, PAGE_SIZE);
        return 0;
}

从上面这张图可以看出：
当系统开机，driver起来的时候会将内存前10个字节初始化，通过cat /sys/devices/virtual/misc/mymap/rng_current，可以看出此时内存中的值。
当执行mymap_app时会将前10个字节的内容加上10再写进内存，再通过cat /sys/devices/virtual/misc/mymap/rng_current，可以看出修改后的内存中的值。

---

参考文章

1. linux 内存映射 remap_pfn_range操作
2. mmap详解

---

资源下载

1. mmap内核驱动与应用程序