Linux进程间通信 共享内存

共享内存（Shared Memory）

　　共享内存区域是被多个进程共享的一部分物理内存。如果多个进程都把该内存区域映射到自己的虚拟地址空间，则这些进程就都可以直接访问该共享内存区域，从而 可以通过该区域进行通信。共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中 的内容。这块共享虚拟内存的页面，出现在每一个共享该页面的进程的页表中。但是它不需要在所有进程的虚拟内存中都有相同的虚拟地址。

　　
　　　　　　　　　　　　　　　　　　图 共享内存映射图

　　象所有的 System V IPC对象一样，对于共享内存对象的访问由key控制，并要进行访问权限检查。内存共享之后，对进程如何使用这块内存就不再做检查。它们必须依赖于其它机 制，比如System V的信号灯来同步对于共享内存区域的访问。

　　每一个新创建的共享内存对象都用一个shmid_kernel数据结构来表达。系统中所有的shmid_kernel数据结构都保存在shm_segs向 量表中，该向量表的每一个元素都是一个指向shmid_kernel数据结构的指针。shm_segs向量表的定义如下：

　　struct shmid_kernel *shm_segs[SHMMNI];

　　SHMMNI为128，表示系统中最多可以有128个共享内存对象。

　　数据结构shmid_kernel的定义如下：

　　struct shmid_kernel

　　{

　　struct shmid_ds u;         /* the following are private */

　　unsigned long shm_npages;  /* size of segment (pages) */

　　unsigned long *shm_pages;  /* array of ptrs to frames -> SHMMAX */

　　struct vm_area_struct *attaches;  /* descriptors for attaches */

　　};

　　其中：shm_pages是该共享内存对象的页表，每个共享内存对象一个，它描述了如何把该共享内存区域映射到进程的地址空间的信息。

　　shm_npages是该共享内存区域的大小，以页为单位。

　　shmid_ds是一个数据结构，它描述了这个共享内存区的认证信息，字节大小，最后一次粘附时间、分离时间、改变时间，创建该共享区域的进程，最后一次 对它操作的进程，当前有多少个进程在使用它等信息。其定义如下：

　　struct shmid_ds {

　　struct ipc_perm shm_perm;   /* operation perms */

　　int shm_segsz;              /* size of segment (bytes) */

　　__kernel_time_t shm_atime;  /* last attach time */

　　__kernel_time_t shm_dtime;  /* last detach time */

　　__kernel_time_t shm_ctime;  /* last change time */

　　__kernel_ipc_pid_t shm_cpid; /* pid of creator */

　　__kernel_ipc_pid_t shm_lpid; /* pid of last operator */

　　unsigned short shm_nattch;   /* no. of current attaches */

　　unsigned short shm_unused;   /* compatibility */

　　void *shm_unused2;           /* ditto - used by DIPC */

　　void *shm_unused3;           /* unused */

　　};

　　attaches描述被共享的物理内存对象所映射的各进程的虚拟内存区域。每一个希望共享这块内存的进程都必须通过系统调用将其粘附（attach）到它 的虚拟内存中。这一过程将为该进程创建了一个新的描述这块共享内存的vm_area_struct数据结构。进程可以选择共享内存在它的虚拟地址空间的位 置，也可以让Linux为它选择一块足够的空闲区域。

　　这个新的vm_area_struct结构除了要连接到进程的内存结构mm中以外，还被连接到共享内存数据结构shmid_kernel的一个链表中，该 结构中的attaches指针指向该链表。vm_area_struct数据结构中专门提供了两个指针：vm_next_shared和 vm_prev_shared，用于连接该共享区域在使用它的各进程中所对应的vm_area_struct数据结构。其实，虚拟内存并没有在粘附的时候 创建，而要等到第一个进程试图访问它的时候才创建。

　　
　　　　　　　　　　　　　　图 System V IPC 机制 - 共享内存

 

 

 

　　Linux为共享内存提供了四种操作。

　　1. 共享内存对象的创建或获得。与其它两种IPC机制一样，进程在使用共享内存区域以前，必须通过系统调用sys_ipc （call值为SHMGET）创建一个键值为key的共享内存对象，或获得已经存在的键值为key的某共享内存对象的引用标识符。以后对共享内存对象的访 问都通过该引用标识符进行。对共享内存对象的创建或获得由函数sys_shmget完成，其定义如下：

　　int sys_shmget (key_t key, int size, int shmflg)

　　这里key是表示该共享内存对象的键值，size是该共享内存区域的大小（以字节为单位），shmflg是标志（对该共享内存对象的特殊要求）。

　　它所做的工作如下：

　　1) 如果key == IPC_PRIVATE，则创建一个新的共享内存对象。

　　* 算出size对应的页数，检查其合法性。

　　* 搜索向量表shm_segs，为新创建的共享内存对象找一个空位置。

　　* 申请一块内存用于建立shmid_kernel数据结构，注意这里申请的内存区域大小不包括真正的共享内存区，实际上，要等到第一个进程试图访问它的时候 才真正创建共享内存区。

　　* 根据该共享内存区所占用的页数，为其申请一块空间用于建立页表（每页4个字节），将页表清0。

　　* 填写shmid_kernel数据结构，将其加入到向量表shm_segs中为其找到的空位置。

　　* 返回该共享内存对象的引用标识符。

　　2) 在向量表shm_segs中查找键值为key的共享内存对象，结果有三：

　　* 如果没有找到，而且在操作标志shmflg中没有指明要创建新共享内存，则错误返回，否则创建一个新的共享内存对象。

　　* 如果找到了，但该次操作要求必须创建一个键值为key的新对象，那么错误返回。

　　* 否则，合法性、认证检查，如有错，则错误返回；否则，返回该内存对象的引用标识符。

　　共享内存对象的创建者可以控制对于这块内存的访问权限和它的key是公开还是私有。如果有足够的权限，它也可以把共享内存锁定在物理内存中。

　　参见include/linux/shm.h

　　2. 粘附。在创建或获得某个共享内存区域的引用标识符后，还必须将共享内存区域映射（粘附）到进程的虚拟地址空间，然后才能使用该共享内存区域。系统调用 sys_ipc（call值为SHMAT）用于共享内存区到进程虚拟地址空间的映射，而真正完成粘附动作的是函数sys_shmat，其定义如下：

　　int sys_shmat (int shmid, char *shmaddr, int shmflg, ulong *raddr)

　　其中：shmid是共享内存对象的引用标识符；

　　shmaddr该共享内存区域在进程的虚拟地址空间对应的虚拟地址；

　　shmflg是映射标志；

　　raddr是实际映射的虚拟空间地址。

　　该函数所做的工作如下：

　　1) 根据shmid找到共享内存对象。

　　2) 如果shmaddr为0，即用户没有指定该共享内存区域在它的虚拟空间中的位置，则由系统在进程的虚拟地址空间中为其找一块区域（从1G开始）；否则，就 用shmaddr作为映射的虚拟地址。

　　3) 检查虚拟地址的合法性（不能超过进程的最大虚拟空间大小—3G，不能太接近堆栈栈顶）。

　　4) 认证检查。

　　5) 申请一块内存用于建立数据结构vm_area_struct，填写该结构。

　　6) 检查该内存区域，将其加入到进程的mm结构和该共享内存对象的vm_area_struct队列中。

　　共享内存的粘附只是创建一个vm_area_struct数据结构，并将其加入到相应的队列中，此时并没有创建真正的共享内存页。

　　当进程第一次访问共享虚拟内存的某页时，因为所有的共享内存页还都没有分配，所以会发生一个page fault异常。当Linux处理这个page fault的时候，它找到发生异常的虚拟地址所在的vm_area_struct数据结构。在该数据结构中包含有这类共享虚拟内存的一组处理例程，其中的 nopage操作用来处理虚拟页对应的物理页不存在的情况。对共享内存，该操作是shm_nopage（定义在ipc/shm.c中）。该操作在描述这个 共享内存的shmid_kernel数据结构的页表shm_pages中查找发生page fault异常的虚拟地址所对应的页表条目，看共享页是否存在（页表条目为0，表示共享页是第一次使用）。如果不存在，它就分配一个物理页，并为它创建一 个页表条目。这个条目不但进入当前进程的页表，同时也存到shmid_kernel数据结构的页表shm_pages中。

　　当下一个进程试图访问这块内存并得到一个page fault的时候，经过同样的路径，也会走到函数shm_nopage。此时，该函数查看shmid_kernel数据结构的页表shm_pages时， 发现共享页已经存在，它只需把这里的页表项填到进程页表的相应位置即可，而不需要重新创建物理页。所以，是第一个访问共享内存页的进程使得这一页被创建， 而随后访问它的其它进程仅把此页加到它们的虚拟地址空间。

　　3. 分离。当进程不再需要共享虚拟内存的时候，它们与之分离（detach）。只要仍旧有其它进程在使用这块内存，这种分离就只会影响当前的进程，而不会影响 其它进程。当前进程的vm_area_struct数据结构被从shmid_ds中删除，并被释放。当前进程的页表也被更新，共享内存对应的虚拟内存页被 标记为无效。当共享这块内存的最后一个进程与之分离时，共享内存页被释放，同时，这块共享内存的shmid_kernel数据结构也被释放。

　　系统调用sys_ipc（call值为SHMDT）用于共享内存区与进程虚拟地址空间的分离，而真正完成分离动作的是函数sys_shmdt，其定义如 下：

　　int sys_shmdt (char *shmaddr)

　　其中shmaddr是进程要分离的共享页的开始虚拟地址。

　　该函数搜索进程的内存结构中的所有vm_area_struct数据结构，找到地址shmaddr对应的一个，调用函数do_munmap将其释放。

　　在函数do_munmap中，将要释放的vm_area_struct数据结构从进程的虚拟内存中摘下，清除它在进程页表中对应的页表项（可能占多个页表 项），调用该共享内存数据结构vm_area_struct的操作例程中的close操作（此处为shm_close）做进一步的处理。

　　在函数shm_close（定义在ipc/shm.c中）中，找到该共享内存对象在向量表shm_segs中的索引，从而找到该共享内存对象，将该共享内 存在当前进程中对应的vm_area_struct数据结构从对象的共享内存区域链表（由vm_next_share和vm_pprev_share指针 连接）中摘下。如果目前与该共享内存对象粘附的进程数变成了0，则释放共享内存页，释放共享内存页表，释放该对象的shmid_kernel数据结构，将 向量表shm_segs中该共享内存对象所占用的项改为IPC_UNUSED。

 

 

 

　　如果共享的虚拟内存没有被锁定在物理内存中，分离会更加复杂。因为在这种情况下，共享内存的页可能在系统大量使用内存的时候被交换到系统的交换磁盘。为了 避免这种情况，可以通过下面的控制操作，将某共享内存页锁定在物理内存不允许向外交换。共享内存的换出和换入，已在第3章中讨论。

　　4. 控制。Linux在共享内存上实现的第四种操作是共享内存的控制（call值为SHMCTL的sys_ipc调用），它由函数sys_shmctl实现。 控制操作包括获得共享内存对象的状态，设置共享内存对象的参数（如uid、gid、mode、ctime等），将共享内存对象在内存中锁定和释放（在对象 的mode上增加或去除SHM_LOCKED标志），释放共享内存对象资源等。

　　共享内存提供了一种快速灵活的机制，它允许进程之间直接共享大量的数据，而无须使用拷贝或系统调用。共享内存的主要局限性是它不能提供同步，如果两个进程 企图修改相同的共享内存区域，由于内核不能串行化这些动作，因此写的数据可能任意地互相混合。所以使用共享内存的进程必须设计它们自己的同步协议，如用信 号灯等。

　　以下是使用共享内存机制进行进程间通信的基本操作：

　　需要包含的头文件：

　　#include <sys/types.h>

　　#include <sys/ipc.h>

　　#include <sys/shm.h>

　　1.创建共享内存：

　　int shmget(key_t key,int size,int shmflg);

　　参数说明：

　　key:用来表示新建或者已经存在的共享内存去的关键字。

　　size：创建共享内存的大小。

　　shmflg：可以指定的特殊标志。IPC_CREATE,IPC_EXCL以及低九位的权限。

　　eg：

　　int shmid;

　　shmid=shmget(IPC_PRIVATE,4096,IPC_CREATE|IPC_EXCL|0660);

　　if(shmid==-1)

　　perror("shmget()");

　　2.连接共享内存

　　char *shmat(int shmid,char *shmaddr,int shmflg);

　　参数说明：

　　shmid：共享内存的关键字

　　shmaddr：指定共享内存出现在进程内存地址的什么位置，通常我们让内核自己决定一个合适的地址位置，用的时候设为0。

　　shmflg：制定特殊的标志位。

　　eg：

　　int shmid;

　　char *shmp;

　　shmp=shmat(shmid,0,0);

　　if(shmp==(char *)(-1))

　　perror("shmat()/n");

　　3.使用共享内存

　　在使用共享内存是需要注意的是，为防止内存访问冲突，我们一般与信号量结合使用。

　　4.分离共享内存：当程序不再需要共享内后，我们需要将共享内存分离以便对其进行释放，分离共享内存的函数原形如下：

　　int shmdt(char *shmaddr);

　　5.

　　释放共享内存

　　int shmctl(int shmid,int cmd,struct shmid_ds *buf);

 

共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。共享内存往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
首先要用的函数是shmget，它获得一个共享存储标识符。

＃i nclude <sys/types.h>
        ＃i nclude <sys/ipc.h>
        ＃i nclude <sys/shm.h>
        int shmget(key_t key, int size, int flag);

这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。

当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。

void *shmat(int shmid, void *addr, int flag);

shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。

使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。

共享内存机制使得两个不相关进程可以读取和修改同一段内存从而实现数据共享。主要函数定义:

#include <sys/shm.h>

void *shmat(int shm_id, const void *shm_addr, int shmflg);

int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

int shmdt(const void *shm_addr);

int shmget(key_t key, size_t size, int shmflag);

C代码 

1. /*server.c:向共享内存中写入People*/
2. #include <stdio.h>
3. #include <sys/types.h>
4. #include <sys/ipc.h>
5. #include <sys/sem.h>
6. int main()  
7. {  
8. struct People{  
9. char name[10];  
10. int age;  
11.     };  
12. int semid;  
13. int shmid;  
14.     key_t semkey;  
15.     key_t shmkey;  
16.     semkey=ftok("server.c",0);  
17.     shmkey=ftok("client.c",0);  
18. /*创建共享内存和信号量的IPC*/
19.     semid=semget(semkey,1,0666|IPC_CREAT);  
20. if(semid==-1)  
21.     printf("creat sem is fail/n");  
22.     shmid=shmget(shmkey,1024,0666|IPC_CREAT);  
23. if(shmid==-1)  
24.     printf("creat shm is fail/n");  
25. /*设置信号量的初始值，就是资源个数*/
26. union semun{  
27. int val;  
28. struct semid_ds *buf;  
29.         ushort *array;  
30.     }sem_u;  
31.     sem_u.val=1;  
32.     semctl(semid,0,SETVAL,sem_u);  
33. /*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
34. struct People * addr;  
35.     addr=(struct People*)shmat(shmid,0,0);  
36. if(addr==(struct People*)-1)  
37.     printf("shm shmat is fail/n");  
38. /*信号量的P操作*/
39. void p()  
40.     {  
41. struct sembuf sem_p;  
42.         sem_p.sem_num=0;  
43.         sem_p.sem_op=-1;  
44. if(semop(semid,&sem_p,1)==-1)  
45.         printf("p operation is fail/n");          
46.     }  
47. /*信号量的V操作*/
48. void v()  
49.     {  
50. struct sembuf sem_v;  
51.         sem_v.sem_num=0;  
52.         sem_v.sem_op=1;  
53. if(semop(semid,&sem_v,1)==-1)  
54.         printf("v operation is fail/n");  
55.     }  
56. /*向共享内存写入数据*/
57.     p();  
58.     strcpy((*addr).name,"xiaoming");  
59. /*注意：①此处只能给指针指向的地址直接赋值，不能在定义一个  struct People people_1;addr=&people_1;因为addr在addr=(struct People*)shmat(shmid,0,0);时,已经由系统自动分配了一个地址，这个地址与共享内存相关联，所以不能改变这个指针的指向，否则他将不指向共享内存，无法完成通信了。
60. 注意：②给字符数组赋值的方法。刚才太虎了。。*/
61.     (*addr).age=10;  
62.     v();  
63. /*将共享内存与当前进程断开*/
64. if(shmdt(addr)==-1)  
65.     printf("shmdt is fail/n");    
66. } 

C代码 

1. /*client.c:从共享内存中读出People*/
2. #include <stdio.h>
3. #include <sys/types.h>
4. #include <sys/ipc.h>
5. #include <sys/sem.h>
6. int main()  
7. {  
8. int semid;  
9. int shmid;  
10.     key_t semkey;  
11.     key_t shmkey;  
12.     semkey=ftok("server.c",0);  
13.     shmkey=ftok("client.c",0);  
14. struct People{  
15. char name[10];  
16. int age;  
17.     };  
18. /*读取共享内存和信号量的IPC*/
19.     semid=semget(semkey,0,0666);  
20. if(semid==-1)  
21.     printf("creat sem is fail/n");  
22.     shmid=shmget(shmkey,0,0666);  
23. if(shmid==-1)  
24.     printf("creat shm is fail/n");  
25. /*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
26. struct People * addr;  
27.     addr=(struct People*)shmat(shmid,0,0);  
28. if(addr==(struct People*)-1)  
29.     printf("shm shmat is fail/n");  
30. /*信号量的P操作*/
31. void p()  
32.     {  
33. struct sembuf sem_p;  
34.         sem_p.sem_num=0;  
35.         sem_p.sem_op=-1;  
36. if(semop(semid,&sem_p,1)==-1)  
37.         printf("p operation is fail/n");          
38.     }  
39. /*信号量的V操作*/
40. void v()  
41.     {  
42. struct sembuf sem_v;  
43.         sem_v.sem_num=0;  
44.         sem_v.sem_op=1;  
45. if(semop(semid,&sem_v,1)==-1)  
46.         printf("v operation is fail/n");  
47.     }  
48. /*从共享内存读出数据*/
49.     p();  
50.     printf("name:%s/n",addr->name);  
51.     printf("age:%d/n",addr->age);  
52.     v();  
53. /*将共享内存与当前进程断开*/
54. if(shmdt(addr)==-1)  
55.     printf("shmdt is fail/n");  
56. /*IPC必须显示删除。否则会一直留存在系统中*/
57. if(semctl(semid,0,IPC_RMID,0)==-1)  
58.     printf("semctl delete error/n");  
59. if(shmctl(shmid,IPC_RMID,NULL)==-1)  
60.     printf("shmctl delete error/n");  
61. }