2.17-2.18内存映射

效率较高由于对内存进行直接的操作

本质:还是通过对内存操作来对文件操作进行通信

 父子进程间的内存映射区通信：

/*
    #include <sys/mman.h>

    void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
        功能:将一个文件或者设备的数据映射到内存中
        参数:
            void *addr:NULL,由内核指定
            length：要映射的数据的长度，这个值不能为0.建议使用文件的长度
                    获取文件的长度:stat lseek
            prot:对申请内存映射区的操作权限
                -PROT_EXEC  :可执行权限
                -PROT_READ  :读权限
                -PROT_WRITE :写权限
                -PROT_NONE  :没有权限
                要操作映射内存，必须要有读权限(只有写权限操作不了！)
                PROT_READ、PROT_READ|PROT_WRITE
            flags:
                -PROT_WRITE:映射区的数据会自动和磁盘文件进行同步，进程间通信，必须设置这个选项
                -MAP_PRIVATE:不同步，内存映射区的数据改变了，对原来的文件不会修改，会创建一个新的文件。(copy on write)
            fd:需要映射的那个文件的文件描述符
                通过open得到，open的是一个磁盘文件
                注意:文件的大小要大于0，open指定的权限不能和prot参数有冲突。prot的权限<=open的权限
                    prot:PROT_READ                  open:只读/读写  
                    prot:PROT_READ | PROT_WRITE     open:读写
            offset:偏移量，一般不用。必须指定的是4k的整数倍，0表示不偏移。
    
        返回值:返回创建的内存的首地址
            失败返回 MAP_FAILED (that is, (void *) -1) 
    int munmap(void *addr, size_t length);
        功能:释放内存映射
        参数:
            addr:要释放的内存的首地址
            length:要释放的内存的大小，要和mmap函数中的length参数的值一样
*/
/*
    使用内存映射实现进程间通信
    1.有关系的进程(父子进程)
        还没有子进程的时候
            通过唯一的父进程，先创建内存映射区
        有了内存映射区以后，创建子进程
        父子进程共享创建的内存映射区

    2.没有关系的进程间通信
        准备一个大小不是0的磁盘文件
        进程1通过磁盘文件创建内存映射区
            得到一个操作这块内存的指针
        进程2通过磁盘文件创建内存映射区
            得到一个操作这块内存的指针
        使用内存映射区通信
    注意:内存映射区通信是非阻塞
*/  
#include <sys/mman.h>
#include <stdio.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){
        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{
        //子进程
        strcpy((char *)ptr,"nihao a i am child!!!");
    }

    //关闭内存映射区
    munmap(ptr,size);
    return 0;
}

 

1.如果对mmap的返回值 (ptr)做++操作(ptr++)，munmap是 否能够成功?

void *ptr = mmap(...);

ptr++; 可以对其进行++操作但是不建议

munmap(ptr,len);//如果对其进行++操作在这里释放的时候会有错误

2.如果open时0 RDONLY, mmap时prot参 数指定PROT READI PROT WRITE会 怎样?

错误，返回MAP_FAILED

open()函数中的权限建议和port参数的权限保持一致

3.如果文件偏移量为1000会怎样?

偏移量必须是4k的整数倍，返回MAP_FAILED

4.mmap什么情况下会调用失败?

    -第二个参数:length=0

    -第三个参数:prot

        -只制定了写权限

        -prot PROT_READ | PROT_WRITE

         第五个参数 fd 通过open函数时指定的O_RDONLY / O_WRONLY

5.可以open的时候O_CREAT一个新文件来创建映射区吗?

    可以的,但是创建的文件大小如果为0的话，肯定不行

    可以对新的文件进行拓展

        lseek()

        truncate()

6.mmap后关闭文件描述符,对mmap映射有没有影响?

    int fd = open("xxx");

    mmap(,,,,fd,0);

    close(fd);

    映射区还存在，创建映射区的fd被关闭了，没有任何影响

7.对ptr越界操作会怎样?

void *ptr =mmap(NULL,100,,,,);

4K

越界操作操作的时非法的内存 -> 段错误

文件拷贝(不能太大因为内存不一定放的下):

//使用内存映射实现文件拷贝的功能
/*
    思路
        1.对原始的文件进行内存映射
        2.创建一个新的文件(拓展该文件)
        3.把新文件的数据映射到内存中
        4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
        5.释放资源
*/
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.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||ptr1==MAP_FAILED){
        perror("mmap");
        exit(0);
    }

    //内存拷贝
    memcpy(ptr1,ptr,len);

    //释放资源
    munmap(ptr1,len);
    munmap(ptr,len);
    
    close(fd1);
    close(fd);
    
    return 0;
}

匿名映射(父子进程通信):

/*
    匿名映射：不需要文件实体进程一个内存映射
*/
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.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);//MAP_ANONYMOUS表示匿名的
    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;
}