另一种内存映射方法--mmap函数

最新推荐文章于 2023-03-13 20:16:35 发布
最新推荐文章于 2023-03-13 20:16:35 发布
阅读量532 收藏 1
点赞数
分类专栏： linux系统编程
原文链接：https://blog.csdn.net/weixin_33862993/article/details/85977165
版权

介绍

除了标准的文件 IO，例如 open, read, write，内核还提供接口允许应用将文件 map 到内存。使得内存中的一个字节与文件中的一个字节一一对应。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。munmap执行相反的操作，删除特定地址区域的对象映射。 

两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。

  • 优势
    • 读写文件避免了 read() 和 write() 系统调用，也避免了数据的拷贝。
    • 除了潜在的页错误，读写 map 后的文件不引起系统调用或者上下文切换。就像访问内存一样简单。
    • 多个进程 map 同一个对象，可以共享数据。
    • 可以直接使用指针来跳转到文件某个位置，不必使用 lseek() 系统调用。
  • 劣势
    • 内存浪费。由于必须要使用整数页的内存。
    • 导致难以找到连续的内存区域
    • 创建和维护映射和相关的数据结构的额外开销。在大文件和频繁访问的文件中，这个开销相比 read write 的 copy 开销小。

页面对齐

内存拥有独立权限的最小单位就是页。因此，mmap 的最小单位也是页。addr 和 offset 参数都必须页对齐，len 会被 roundup。被 roundup 的多余的内存会以 \0 填充。对这一部分的写入操作不会影响文件。我们可以通过如下方式获取本机的页面大小：

mmap函数说明

函数原型为：

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

函数功能：

mmap的作用是映射文件描述符fd指定文件的 [off,off + len]区域至调用进程的[addr, addr + len]的内存区域, 如下图所示:

函数参数：

  • addr
    这个参数是建议地址（hint），需要映射的共享内存起始地址，一般传入NULL。

  • len   

        映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起

  • prot
    表明对这块内存的保护方式，不可与文件访问方式冲突。
    PROT_NONE
    无权限，基本没有用
    PROT_READ
    读权限
    PROT_WRITE
    写权限
    PROT_EXEC
    执行权限

  • flags
    描述了映射的类型。
    MAP_FIXED
    开启这个选项，则 addr 参数指定的地址是作为必须而不是建议。如果由于空间不足等问题无法映射则调用失败。不建议使用。
    MAP_PRIVATE
    表明这个映射不是共享的。文件使用 copy on write 机制映射，任何内存中的改动并不反映到文件之中。也不反映到其他映射了这个文件的进程之中。如果只需要读取某个文件而不改变文件内容，可以使用这种模式。
    MAP_SHARED
    和其他进程共享这个文件。往内存中写入相当于往文件中写入。会影响映射了这个文件的其他进程。与 MAP_PRIVATE冲突。

  • fd

    参数fd为即将映射到进程空间的文件描述字，一般由open()返回，同时，fd可以指定为-1，此时须指定flags参数中的

    MAP_ANON，表明进行的是匿名映射（不涉及具体的文件名，避免了文件的创建及打开，很显然只能用于具有亲缘关系的

    进程间通信）。

  • offset
    文件偏移，参数一般设为0，表示从文件头开始映射。

返回值： 
　　　　成功执行时，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：试着访问不属于进程的内存区 

 

munmap函数说明

函数头文件：#include<unistd.h> #include<sys/mman.h>

函数原型：int munmap( void * start, size_t length )
函数功能：　解除内存映射

参数说明：start 是调用mmap()时返回的地址，length 是映射区的大小, length 必须是 mmap 时的 length，如果小于当初 mmap 时的那个 length。当进程结束或使用exec相关函数来执行其他程序时，映射内存会自动解除，但关闭相应的文件描述符不会解除映射。当映射关系解除后，对原来映射地址的访问将导致段错误发生。

函数返回值：成功：0，失败：-1


msync函数说明

函数头文件：#include<unistd.h>    #include<sys/mman.h>

函数原型：int msync ( void * addr , size_t len, int flags) /标志和权限/
函数功能：进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

函数参数说明：

addr：文件映射到进程空间的地址；

len：映射空间的大小；

flags：刷新的参数设置，可以取值MS_ASYNC/ MS_SYNC/ MS_INVALIDATE

其中：

取值为MS_ASYNC（异步）时，调用会立即返回，不等到更新的完成；

取值为MS_SYNC（同步）时，调用会等到更新完成之后返回；

取MS_INVALIDATE（通知使用该共享区域的进程，数据已经改变）时，在共享内容更改之后，使得文件的其他映射失效，从而使得共享该文件的其他进程去重新获取最新值；

函数返回值

成功则返回0；失败则返回-1；

可能的错误

EBUSY/ EINVAL/ ENOMEM

 

函数的注意事项：

1.创建映射区的过程中，隐含着一次对映射文件的读操作，因此在打开文件时必须包括读权限，才能创建映射区；

2.当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对文件的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制；

3.映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。在建立好映射区之后就可以关闭文件了，以后在对映射区的读写操作不再需要文件描述符了，因为映射关系已经被mmap系统调用确定了。

4.特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！不能为0。mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。malloc（或new）分配的地址大小（堆空间）都可以指定为0（使用完后，需要free（或delete）释放），但是mmap不可以！！

5.munmap传入的地址一定是mmap的返回地址，坚决杜绝指针++操作（必须完全对应）；

6.文件偏移量必须为4K的整数倍，因为MMU完成了从线性地址到物理地址的映射，映射时以页为单位进行的，一页一页进行映射；

7.mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

因此，对于新创建的文件，必须对文件进行拓展（ftruncate、truncate和lseek），然后才能创建映射区。对于lseek、mmap等函数的指针移动都是以字节为单位的（char为1个字节）。

8. 最终被映射文件的内容的长度不会超过文件本身的初始大小，即映射不能改变文件的大小；

9. 可以用于进程通信的有效地址空间大小大体上受限于被映射文件的大小，但不完全受限于文件大小。

注：在linux中，内存的保护是以页为基本单位的，即使被映射文件只有一个字节大小，内核也会为映射分配一个页面大小的内存。当被映射文件小于一个页面大小时，进程可以对从mmap()返回地址开始的一个页面大小进行访问，而不会出错；但是，如果对一个页面以外的地址空间进行访问，则导致错误发生，后面将进一步描述。因此，可用于进程间通信的有效地址空间大小不会超过文件大小及一个页面大小的和。

10. 文件一旦被映射后，调用mmap()的进程对返回地址的访问是对某一内存区域的访问，暂时脱离了磁盘上文件的影响。所有对mmap()返回地址空间的操作只在内存中有意义，只有在调用了munmap()后或者msync()时，才把内存中的相应内容写回磁盘文件，所写内容仍然不能超过文件的大小。

 

创建内存映射的两种方法：

1.  mmap MAP_ANONYMOUS

在支持MAP_ANONYMOUS的系统上，直接用匿名共享内存就可以，

mmap(NULL, sizeof(int), PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_SHARED, -1, 0);

2. mmap  /dev/zero

       有些系统不支持匿名内存映射，则能够使用fopen打开/dev/zero文件，然后对该文件进行映射。能够相同达到匿名内存映射的效果。

fd=open("/dev/zero",O_RDWR);

if(fd==-1){

         printf("open /dev/zero null\n");

         return -1;

}

addr=mmap(NULL,sizeof(int),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);

if(addr == NULL){

    printf("mmap error\n");

    return -1;

}

 

mmap实例说明

测试文件 data.txt  收藏代码

  1. aaaaaaaaa  
  2. bbbbbbbbb  
  3. ccccccccc  
  4. ddddddddd  

 

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

C代码  收藏代码

  1. #include <sys/mman.h>  
  2. #include <sys/stat.h>  
  3. #include <fcntl.h>  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6. #include <unistd.h>  
  7. #include <error.h>  
  8.   
  9. #define BUF_SIZE 100  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     int fd, nread, i;  
  14.     struct stat sb;  
  15.     char *mapped, buf[BUF_SIZE];  
  16.   
  17.     for (i = 0; i < BUF_SIZE; i++) {  
  18.         buf[i] = '#';  
  19.     }  
  20.   
  21.     /* 打开文件 */  
  22.     if ((fd = open(argv[1], O_RDWR)) < 0) {  
  23.         perror("open");  
  24.     }  
  25.   
  26.     /* 获取文件的属性 */  
  27.     if ((fstat(fd, &sb)) == -1) {  
  28.         perror("fstat");  
  29.     }  
  30.   
  31.     /* 将文件映射至进程的地址空间 */  
  32.     if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
  33.                     PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
  34.         perror("mmap");  
  35.     }  
  36.   
  37.     /* 映射完后, 关闭文件也可以操纵内存 */  
  38.     close(fd);  
  39.   
  40.     printf("%s", mapped);  
  41.   
  42.     /* 修改一个字符,同步到磁盘文件 */  
  43.     mapped[20] = '9';  
  44.     if ((msync((void *)mapped, sb.st_size, MS_SYNC)) == -1) {  
  45.         perror("msync");  
  46.     }  
  47.   
  48.     /* 释放存储映射区 */  
  49.     if ((munmap((void *)mapped, sb.st_size)) == -1) {  
  50.         perror("munmap");  
  51.     }  
  52.   
  53.     return 0;  
  54. }  

 

2 私有映射无法修改文件

/* 将文件映射至进程的地址空间 */

if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ | 

                    PROT_WRITE, MAP_PRIVATE, fd, 0)) == (void *)-1) {

    perror("mmap");

}

3 使用共享映射实现两个进程之间的通信

两个程序映射同一个文件到自己的地址空间, 进程A先运行, 每隔两秒读取映射区域, 看是否发生变化. 

进程B后运行, 它修改映射区域, 然后推出, 此时进程A能够观察到存储映射区的变化

进程A的代码:

C代码  收藏代码

  1. #include <sys/mman.h>  
  2. #include <sys/stat.h>  
  3. #include <fcntl.h>  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6. #include <unistd.h>  
  7. #include <error.h>  
  8.   
  9. #define BUF_SIZE 100  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     int fd, nread, i;  
  14.     struct stat sb;  
  15.     char *mapped, buf[BUF_SIZE];  
  16.   
  17.     for (i = 0; i < BUF_SIZE; i++) {  
  18.         buf[i] = '#';  
  19.     }  
  20.   
  21.     /* 打开文件 */  
  22.     if ((fd = open(argv[1], O_RDWR)) < 0) {  
  23.         perror("open");  
  24.     }  
  25.   
  26.     /* 获取文件的属性 */  
  27.     if ((fstat(fd, &sb)) == -1) {  
  28.         perror("fstat");  
  29.     }  
  30.   
  31.     /* 将文件映射至进程的地址空间 */  
  32.     if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
  33.                     PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
  34.         perror("mmap");  
  35.     }  
  36.   
  37.     /* 文件已在内存, 关闭文件也可以操纵内存 */  
  38.     close(fd);  
  39.       
  40.     /* 每隔两秒查看存储映射区是否被修改 */  
  41.     while (1) {  
  42.         printf("%s\n", mapped);  
  43.         sleep(2);  
  44.     }  
  45.   
  46.     return 0;  
  47. }  

 

进程B的代码:

C代码  收藏代码

  1. #include <sys/mman.h>  
  2. #include <sys/stat.h>  
  3. #include <fcntl.h>  
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6. #include <unistd.h>  
  7. #include <error.h>  
  8.   
  9. #define BUF_SIZE 100  
  10.   
  11. int main(int argc, char **argv)  
  12. {  
  13.     int fd, nread, i;  
  14.     struct stat sb;  
  15.     char *mapped, buf[BUF_SIZE];  
  16.   
  17.     for (i = 0; i < BUF_SIZE; i++) {  
  18.         buf[i] = '#';  
  19.     }  
  20.   
  21.     /* 打开文件 */  
  22.     if ((fd = open(argv[1], O_RDWR)) < 0) {  
  23.         perror("open");  
  24.     }  
  25.   
  26.     /* 获取文件的属性 */  
  27.     if ((fstat(fd, &sb)) == -1) {  
  28.         perror("fstat");  
  29.     }  
  30.   
  31.     /* 私有文件映射将无法修改文件 */  
  32.     if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
  33.                     PROT_WRITE, MAP_PRIVATE, fd, 0)) == (void *)-1) {  
  34.         perror("mmap");  
  35.     }  
  36.   
  37.     /* 映射完后, 关闭文件也可以操纵内存 */  
  38.     close(fd);  
  39.   
  40.     /* 修改一个字符 */  
  41.     mapped[20] = '9';  
  42.    
  43.     return 0;  
  44. }  

 

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

C代码  收藏代码

  1. #include <sys/mman.h>  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <unistd.h>  
  5.   
  6. #define BUF_SIZE 100  
  7.   
  8. int main(int argc, char** argv)  
  9. {  
  10.     char    *p_map;  
  11.   
  12.     /* 匿名映射,创建一块内存供父子进程通信 */  
  13.     p_map = (char *)mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,  
  14.             MAP_SHARED | MAP_ANONYMOUS, -1, 0);  
  15.   
  16.     if(fork() == 0) {  
  17.         sleep(1);  
  18.         printf("child got a message: %s\n", p_map);  
  19.         sprintf(p_map, "%s", "hi, dad, this is son");  
  20.         munmap(p_map, BUF_SIZE); //实际上，进程终止时，会自动解除映射。  
  21.         exit(0);  
  22.     }  
  23.   
  24.     sprintf(p_map, "%s", "hi, this is father");  
  25.     sleep(2);  
  26.     printf("parent got a message: %s\n", p_map);  
  27.   
  28.     return 0;  
  29. }  

 

 mmap()返回地址的访问

linux采用的是页式管理机制。对于用mmap()映射普通文件来说，进程会在自己的地址空间新增一块空间，空间大

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

 

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

进程能访问的大小. 下面看一个实例:

C代码  收藏代码

  1. #include <sys/mman.h>  
  2. #include <sys/types.h>  
  3. #include <sys/stat.h>  
  4. #include <fcntl.h>  
  5. #include <unistd.h>  
  6. #include <stdio.h>  
  7.   
  8. int main(int argc, char** argv)  
  9. {  
  10.     int fd,i;  
  11.     int pagesize,offset;  
  12.     char *p_map;  
  13.     struct stat sb;  
  14.   
  15.     /* 取得page size */  
  16.     pagesize = sysconf(_SC_PAGESIZE);  
  17.     printf("pagesize is %d\n",pagesize);  
  18.   
  19.     /* 打开文件 */  
  20.     fd = open(argv[1], O_RDWR, 00777);  
  21.     fstat(fd, &sb);  
  22.     printf("file size is %zd\n", (size_t)sb.st_size);  
  23.   
  24.     offset = 0;   
  25.     p_map = (char *)mmap(NULL, pagesize * 2, PROT_READ|PROT_WRITE,   
  26.             MAP_SHARED, fd, offset);  
  27.     close(fd);  
  28.       
  29.     p_map[sb.st_size] = '9';  /* 导致总线错误 */  
  30.     p_map[pagesize] = '9';    /* 导致段错误 */  
  31.   
  32.     munmap(p_map, pagesize * 2);  
  33.   
  34.     return 0;  
  35. }  


参考资料：
https://www.jianshu.com/p/187eada7b900

https://blog.csdn.net/bluehawksky/article/details/39805565

https://blog.csdn.net/weixin_33862993/article/details/85977165

https://blog.csdn.net/qq_33883085/article/details/88919041

 

lanhuazui10
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内存管理子系统——mmap内存映射原理分析(dax文件系统的mmap)
Imagine Miracle的博客
04-18 2723
Linux mmap分析 内核版本：linux-5.16 1. 虚拟内存概要内容简介 1.1. mm_struct 和 vm_area_struct // mm_struct 和 vm_area_struct 的简要成员 struct mm_struct { unsigned long start_brk, brk, start_stack; } __attribute__((preserve_access_index)); struct vm_area_struct { unsigned lo
Linux内存映射mmap相关内核代码分析
weixin_48101150的博客
01-25 428
mmap malloc的两种情况 再用malloc分配内存的时候有两种情况： 一种是小于128k的时候调用brk系统调用 brk是将数据段(.data)的最高地址指针_edata往高地址推(只分配虚拟空间，不对应物理内存(因此没有初始化)，第一次读/写数据时，引起内核缺页中断，内核才分配对应的物理内存，然后虚拟地址空间建立映射关系)，如下图： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ay5OhIcw-1610196484204)(https://i.loli.net/2
mmap&shm
weixin_44233369的博客
07-18 704
共享内存允许两个或多个进程共享一给定的存储区，因为数据不需要来回复制，所以是最快的一种进程间通信机制。共享内存可以通过mmap()映射普通文件（特殊情况下还可以采用匿名映射）机制实现，也可以通过系统V共享内存机制实现。应用接口和原理很简单，内部机制复杂。为了实现更安全通信，往往还与信号灯等同步机制共同使用。 1.mmap mmap的机制如：就是在磁盘上建立一个文件，每个进程存储器里面，单独开辟一个...
mmap(内存映射)和shm(共享存储)
cai0612123的专栏
12-13 3674
mmap(内存影射)和shm(共享存储): 1、mmap是在磁盘上建立一个文件，每个进程地址空间中开辟出一块空间进行映射。 而对于shm而言，shm每个进程最终会映射到同一块物理内存。 shm保存在物理内存，这样读写的速度要比磁盘要快，但是存储量不是特别大。 2、相对于shm来说，mmap更加简单，调用更加方便，所以这也是大家都喜欢用的原因。 3、另外mmap有一个好处是当机器重
mmap 还是 shmget ？
wlh_flame的专栏
04-16 1万+
By firework2@foxmail.com类Unix系统的共享内存有好几种机制，网上一搜就一大堆了，下面是几个我认为介绍的还不错的 : )http://www.ibm.com/developerworks/cn/linux/l-ipc/part5/index1.htmlhttp://www.ibm.com/developerworks/cn/linux/l-ipc/part5/index2.htmlhttp://blog.csdn.net/nellson/archive/2010/03/20/5398
共享内存mmap学习 及与 shmxxx操作的区别
weixin_34059951的博客
12-10 135
上一篇学习了共享内存： http://www.cnblogs.com/charlesblc/p/6142139.html   根据这个 http://blog.chinaunix.net/uid-26335251-id-3493125.html 再来一篇：  1. 共享内存允许两个或多个进程共享一给定的存储区，因为数据不需要来回复制，所以是最快的一种进程间通信机制。共享内存可以通过mmap()映射...
mmap和shmget的区别
f905699146的博客
09-04 5098
二者本质上是类似的，mmap可以看到文件的实体，而 shmget 对应的文件在交换分区上的 shm 文件系统内，无法直接 cat 查看 安全性：mmap 方式对应的真实文件，如果用户有权限即可查看，甚至删除                  shmget 方式其实也一样，好了一层皮罢了（ipcrm -m …） 一致性：mmap 方式下各进程映射文件的相同部分可以共享内存
mmap内存映射
KDF5000的专栏
04-15 3259
内存映射是个很有用，也很有意思的思想。我们都知道操作系统分为用户态和内核态，用户态是不能直接和物理设备打交道的，如果想把硬盘的一块区域读到用户态，则需要两次拷贝(硬盘->内核->用户)，但是内存映射的设计只需要发生一次的拷贝，大大的提高了读取数据的效率。那么内存映射的原理和内核是如何实现的呢？因为内存映射涉及到虚拟内存的管理，虚拟内存到物理内存的映射，因此在详细介绍内存映射前先普及(回忆)一下相关的
Linux mmap内存映射
最新发布
m0_74282605的博客
03-13 621
mmap除了可以减少read,write等系统调用以外，还可以减少内存的拷贝次数，比如在read调用时，一个完整的流程是操作系统读磁盘文件到页缓存，再从页缓存将数据拷贝到read传递的buffer里，而如果使用mmap之后，操作系统只需要将磁盘读到页缓存，然后用户就可以直接通过指针的方式操作mmap映射的内存，减少了从内核态到用户态的数据拷贝。（1）实际拷贝数据前，需要建立映射信息，内存文件映射已经提前准备好了映射关系，内核调度好了进程内的内存块，交付给内核进行了预先处理，内存文件映射会消耗掉一些时间。
浅谈Linux mmap内存映射
m0_73494896的博客
09-17 1180
mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系，函数原型如下 void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。如下图所示。
Linux内核中—— mmap内存映射
m0_74282605的博客
11-24 326
mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系，函数原型如下实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。如下图所示。
共享内存机制——mmap和shm
PPprogrammer的博客
03-29 2888
共享内存是进程间通信的一种方法，常用到的有mmap和shm，下面做一个比较。 mmap机制： 在磁盘上建立一个文件，然后把文件内容映射到虚拟内存上，在每个进程的虚拟存储器里面，单独开辟一个空间来进行映射。在多进程情况下，不会对实际的物理存储器（主存）消耗太大。 即将一个文件或者其它对象映射到进程的虚拟地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一 一对映关系。 实现这样的映射关系后...
mmap映射区和shm共享内存的区别总结
热门推荐
hj605635529的博客
06-13 2万+
linux中的两种共享内存。一种是我们的IPC通信System V版本的共享内存，另外的一种就是我们今天提到的存储映射I/O（mmap函数） 在说mmap之前我们先说一下普通的读写文件的原理，进程调用read或是write后会陷入内核，因为这两个函数都是系统调用，进入系统调用后，内核开始读写文件，假设内核在读取文件，内核首先把文件读入自己的内核空间，读完之后进程在内核回归用户态，内核
编程了解共享内存--mmap和shmget两种方式实现
但行前路 无问西东
09-07 1004
mmapread.c #include <stdio.h> #include <sys/stat.h> #include <fcntl.h> #include <sys/mman.h> #include <unistd.h> #include <semaphore.h> #include <string.h> #i...
shmget物理内存_linux下共享内存mmap()方法和shmget()方法的疑问？
weixin_39755824的博客
12-19 138
谢邀我也是1个linux初学者，水平有限，只能说下我对mmap()的理解。以下内容不能保证正确性，请各位网友指正。首先说结论：你在问题中说：“第一次调用mmap后，要访问时，进程空间已经和物理地址进行映射，但磁盘文件还没有加载到物理内存，所以会返回一个缺页异常，然后缺页处理程序会去把磁盘文件加载物理内存中。”我觉得不尽正确，并不会在mmap()中将进程空间映射到具体的物理地址空间。我的理解是：第一...
shmget物理内存_共享内存 mmap shmget 区别
weixin_39821330的博客
12-19 369
请参考apache对于共享内存的scoreboard的初始化，ap_init_scoreboard()得有一个内存变量ap_scoreboard_image来索引对应的共享内存By firework2@foxmail.com类Unix系统的共享内存有好几种机制，网上一搜就一大堆了，下面是几个我认为介绍的还不错的 : )初学的同学多半都会想横向对比一下，到底用mmap实现共享内存好呢，还是用shmg...
linux shmget mmap 性能,高性能IO 之 Linux shm和mmap的区别
weixin_35663718的博客
05-14 603
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？前言这几天看了不少关于mmap的资料，发现在查阅的过程对mmap存在两种不同的说法。第一种：将磁盘文件与虚拟内存进行映射，通过页表在物理内存发现缺页的情况，于是将磁盘上的文件拷贝到对应的物理内存上。这个是正确的说法。另外一种：mmap将一段内核内存和用户内存进行映射，这样当内核把磁盘的文件拷到内核缓存的时候，就不需要再拷...
mmap 和 shm 区别
布袋和尚
02-23 1461
英文全称 mmap：memory mapping。 shm：shared memory。 mmap 1、实现原理 建立虚拟空间一段区域和磁盘上的文件的映射。 当访问虚拟空间中该区域时，通过 MMU，得到该区域对应的物理地址，OS 发现该区域没有数据，故产生缺页中断。OS 从磁盘中读取相应页的数据直接 copy 到物理内存中。 对于传统的 read 系统调用来说，他们需要将磁盘中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值