linux 内存映射

内存映射：Memory-mapped I/O

　　内存映射是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件 

进程的虚拟地址空间会对应于实际的物理内存当中。。映射到  动态库（共享库）之中，内存动态保存文件的数据。

mmap函数： 

/*
    man 2 mmap:(m:memory内存  map:mapping映射)    kernel:内核
    #include <sys/mman.h>
    void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_offset);
        - 功能: 将一个文件或者设备的数据映射到内存中
        - 参数:
            - void* addr:NULL,由内核指定
            - length: 要映射的数据的长度,这个值不能为0,一般使用文件的长度.(分配的大小为最少(分页)的整数倍)
                获取文件的长度:stat lseek
            - prot:对申请的内存映射区的操作权限
                PROT_EXEC: 可执行权限
                PROT_READ: 读权限
                PROT_WRITE:写权限
                PROT_NONE: 没有权限
                要操作映射区,必须要有读的权限
                PROT_READ、 PROT_READ | PROT_WRITE 一般这两种形式 
            - flags:
                MAP_SHARED: 映射区的数据会自动和磁盘文件进行同步,进程间通信,必须要设置这个选项
                MAP_PRIVATE: 不同步,内存映射区的数据改变了,对原来的文件不会修改,会重新创建一个新的文件(copy on write)
            - fd:需要映射的文件的文件描述符
                - 通过open得到,open的是一个磁盘文件
                - 注意:文件的大小不能为0,open指定的权限不能和prot参数有冲突
                    prot:PROT_READ                   open: 只读/读写
                    prot:PROT_READ | PROT_WRITE      open: 读写
                    prot权限要小于等于 open的权限
            - off_offset:偏移量,一般不用.必须指定的是 4K的整数倍,0表示不偏移.
        - 返回值:
            成功:返回创建的内存的首地址     
            失败:返回MAPFAILED : (void*) -1

    int munmap(void* addr, size_t length);
        - 功能: 释放内存映射
        - 参数:
            - addr:要释放的内存的首地址
            - length:要释放的内存的大小,要和mmap函数中的length参数的值一样
*/

父子进程间通信：

/*
    使用内存映射实现进程间通信:
        1.有关系的进程(父子进程)
            - 还没有子进程的时候
                - 通过唯一的父进程,先创建内存映射区
            - 有了内存映射区以后,再创建子进程
            - 父子进程共享创建的内存映射区
        2.没有关系的进程间通信
            - 准备一个大小不是0的磁盘文件
            - 进程1 通过磁盘文件创建内存映射区
                - 得到一个操作这块内存的指针
            - 进程2 通过磁盘文件创建内存映射区
                - 得到一个操作这块内存的指针
            - 使用内存映射区通信
        注意:内存映射区通信,是非阻塞的
*/
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <wait.h>
int main()
{
    //1.打开一个文件
    int fd = open("test.txt",O_RDWR);
    int size = lseek(fd, 0, SEEK_END);//返回值获取偏移量:获取文件的大小
    //2.创建内存映射区
    void* ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED)//MAP_FAILED:void* -1
    {
        perror("mmap");
        exit(0);
    }
    //3.创建子进程
    pid_t pid = fork();
    if(pid > 0)
    {
        wait(NULL);//回收完子进程资源后再读取数据
        //父进程
        char buf[64];
        strcpy(buf, (char*)ptr);
        printf("read data: %s\n",buf);
    }
    else if(pid == 0)
    {
        //子进程
        strcpy((char*)ptr, "nihao a, dad!");//ptr为 void型  strcpy需要char型 因此强制转换
    }
    //关闭内存映射区
    munmap(ptr, size);
    return 0;
}

 内存映射的注意事项： 

1.如果对 mmap的返回值(ptr)做++操作(ptr++),munmap是否能够成功?
void* ptr = mmap(...);
prt++;可以对其进行++操作
munmap(ptr,len);//错误,要保存地址,释放的时候释放正确的地址

2.如果open时 O_RDONLY, mmap时prot参数指定 PROT_READ | PROT_WRITE会怎么样?
错误,返回MAP_FAILED(将-1转换为 void*)
open()函数中权限建议和prot参数的权限保持一致  prot权限 <= open权限

3.如果文件偏移量(offset)为1000会如何?
偏移量必须是4K的整数倍,否则返回MAP_FAILED

4.mmap什么情况下会调用失败?
    - 第二个参数:length = 0
    - 第三个参数:prot
        - 只指定了写权限(必须要有读权限)
        - prot权限 <= open权限

5.可以open的时候O_CREAT一个新文件来创建映射区吗?
    - 可以的,打死你创建的文件的大小如果为0的话,肯定不行
    - 可以对新的文件进行扩展
        - lseek() 移动偏移量
        - truncate()
    
6.mmap后关闭文件描述符,对mmap映射有没有影响
    int fd = open("xxx");
    mmap(...);
    close(fd);
    映射区还存在,创建映射区的fd被关闭,无影响。

7.对ptr越界操作会怎样?
    void* ptr = mmap(NULL,100...);//默认开辟分页大小 普遍4K 不同系统大小不同
    越界操作: 操作的是非法的内存 - 段错误

内存映射实现文件拷贝：基本不使用，因为内存太小

//使用内存映射实现文件拷贝的功能
/*
    1.对原始的文件进行内存映射
    2.创建一个新的文件(拓展该文件)
    3.把新文件的数据映射到内存中
    4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
    5.释放资源
*/
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    //1.对原始的文件进行内存映射
    int fd = open("english.txt",O_RDWR);
    if(fd == -1)
    {
        perror("open");
        exit(0);
    }
    //获取原始文件的大小
    int len = lseek(fd,0,SEEK_END);
    //2.创建一个新文件(预先拓展该文件)
    int fd1 = open("cpy.txt",O_RDWR | O_CREAT,0664);
    if(fd1 == -1)
    {
        perror("open");
        exit(0);
    }
    //对新创建的文件进行拓展
    truncate("cpy.txt", len);
    write(fd1," ",1);
    //3.分别做内存映射 
    void* ptr = mmap(NULL, len, PROT_READ| PROT_WRITE, MAP_SHARED,fd,0);
    void* ptr1 = mmap(NULL, len, PROT_READ| PROT_WRITE, MAP_SHARED,fd1,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    if(ptr1 == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    //内存拷贝 
    memcpy(ptr1, ptr, len);//往哪拷贝,从那拷贝,拷贝长度
    //释放资源  谁先打开后释放  后打开先释放
    munmap(ptr1,len);
    munmap(ptr,len);
    close(fd1);
    close(fd);
    return 0;
}

匿名映射：

/*
    匿名映射:不需要文件实体进行一个内存映射
*/
// 编译的时候  MAP_ANONYMOUS  未定义的话，在gcc编译时末尾加上-std=gnu99
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
    //1.创建匿名内存映射区
    int len = 4096;
    void* ptr =mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    //父子间通信
    pid_t pid = fork();
    if(pid > 0)
    {
        //父进程
        strcpy((char*)ptr,"hello,world");
        wait(NULL);
    }
    else if(pid == 0)
    {
        //子进程
        sleep(1);
        printf("%s\n",(char*)ptr);
    }
    //释放内存映射区
    int ret = munmap(ptr,len);
    if(ret == -1)
    {
        perror("munmap");
        exit(0);
    }
    return 0;
}