Linux 进程通信系列——共享内存

末蓝、 2022-05-16 01:09 384阅读 0赞

1.概述

共享内存是进程通信的一种方式。此方式会开辟一部分可以被多个进程共享访问的物理内存区域。进行通信的多个进程分别将该内存区域映射到自己的虚拟地址空间，则这些进程就可直接访问共享内存，从而达到通信的目的。这种方法进程间共享数据时最快，一个进程修改共享内存的数据后，其他进程可以立即看到。

2 通信步骤

头文件：\#include<sys/ipc.h>   \#include<sys/shm.h>

<1>创建共享内存

int shmget(key\_t key, int size,int shmflg);

shmget()用来取得参数key所关联的共享内存标识号。若key为IPC\_PRIVATE则会创建新的共享内存，大小有size决定。若key不为IPC\_PRIVATE,也不是已建立的共享内存，则会根据shmflg决定。

参数：key   0：IPC\_PRIVATE

size 内存大小

shmflg 旗标位

返回值：成功返回共享内存识别shmid，失败返回-1，错误存储在errno中

<2>连接到共享内存

void \* shmat(int shmid,const void \*shmaddr,int shmflg);

shmat()用来将参数shmid所指的共享内存和目前的进程连接。

参数:shmid 与连接的共享内存标识码

shmaddr  0 内核自动选择一个地址

shmaddr  不为0且shmflg未指定SHM\_RND,以shmaddr为连接地址

shmaddr 不为0但shmflg指定SHM\_RND，shmaddr会调整为SHMLBA整数倍

返回值：成功返回已连接地址，失败返回-1，错误存储在errno中

<3>断开连接

int shmdt(const void \*shmaddr);

shmdt()使当前进程与共享内存断开连接

参数：shmaddr为先前shmat()返回的共享内存地址

返回值 成功返回0，失败返回-1，错误存储在errno中

<4>对共享内存进行操作

int shmctl(int shmid,int cmd,struct shmid\_ds \*buf);

shmctl()提供了几种控制共享内存的方式

参数：shmid 为共享内存的标识码

cmd 如下

IPC\_STAT 得到共享内存的状态,

IPC\_SET 改变共享内存的状态

IPC\_RMID 删除共享内存

struct shmid\_ds \*buf是一个结构体指针。IPC\_STAT的时候，取得的状态放在这个结构体中。如果要改变共享内存的状态，用这个结构体指定。

返回值 成功返回0，失败返回-1，错误存储在errno中

举例

创建一个共享内存，子进程写入HelloWorld，由父进程读出

#include<sys/types.h> 
       #include<sys/ipc.h> 
       #include<sys/shm.h> 
       #include<stdio.h> 
       #include<sys/stat.h> 
       #include<stdlib.h> 
        
       #define KEY 1234 
       #define SIZE 2048 
       int main() 
       { 
         pid_t pid; 
         int shmid; /*共享内存ID*/ 
         char * shmaddr; /*连接地址*/ 
         struct shmid_ds buf; 
         
         shmid=shmget(KEY,SIZE,IPC_CREAT|0600);/*建立共享内存*/ 
         pid=fork(); 
         if(pid<0) 
          { 
            perror("fork error!\n"); 
           exit(0); 
          } 
         if(pid==0)/*子进程将"Hello world!\n写入共享内存"*/ 
         { 
           shmaddr=shmat(shmid,NULL,0);/*子进程与共享内存连接*/ 
           sprintf(shmaddr,"Hello world!\n");/*写入共享内存*/ 
           printf("Messgae have been write to shared memory！\n"); 
           shmdt(shmaddr);/*断开子进程与共享内存的连接*/ 
           exit(0); 
          } 
        
          sleep(3);/*待子进程结束*/ 
          shmctl(shmid,IPC_STAT,&buf);/*共享内存状态存入buf中*/ 
          shmaddr=(char *)shmat(shmid,NULL,0);/*父进程与共享内存连接*/ 
           
          printf("Message in shared memory:%s\n",shmaddr);/*输出共享内存数据*/ 
          shmdt(shmaddr);/*断开父进程与共享内存的连接*/ 
          shmctl(shmid,IPC_RMID,NULL);/*删除共享内存*/ 
       }

输出

Messgae have been write to shared memory！  
Message in shared memory:Hello world!

另外也可重新创建一个进程，读取该共享内存的数据。将上个c文件中最后一行删除，使得程序结束时不删除共享内存，再执行下面程序，使新进程读取共享内存数据。（共享内存需一致，创建时KEY相同）

PS:更详细的解释如下：

共享内存是系统出于多个进程之间通讯的考虑，而预留的的一块内存区。在/proc/sys/kernel/目录下，记录着共享内存的一些限制，如一个共享内存区的最大字节数shmmax，系统范围内最大共享内存区标识符数shmmni等，可以手工对其调整，但不推荐这样做。

一、应用

共享内存的使用，主要有以下几个API：ftok()、shmget()、shmat()、shmdt()及shmctl()。

1)用ftok()函数获得一个ID号.

应用说明:  
在IPC中，我们经常用用key\_t的值来创建或者打开信号量，共享内存和消息队列。

函数原型:  
key\_t ftok(const char \*pathname, int proj\_id);

Keys：  
1）pathname一定要在系统中存在并且进程能够访问的  
3）proj\_id是一个1－255之间的一个整数值，典型的值是一个ASCII值。  
当成功执行的时候，一个key\_t值将会被返回，否则－1被返回。我们可以使用strerror(errno)来确定具体的错误信息。

考虑到应用系统可能在不同的主机上应用，可以直接定义一个key，而不用ftok获得：  
\#define IPCKEY 0x344378

2)shmget()用来开辟/指向一块共享内存的函数

应用说明:  
shmget（）用来获得共享内存区域的ID，如果不存在指定的共享区域就创建相应的区域。

函数原型:  
int shmget(key\_t key, size\_t size, int shmflg);

key\_t key 是这块共享内存的标识符。如果是父子关系的进程间通信的话，这个标识符用IPC\_PRIVATE来代替。如果两个进程没有任何关系，所以就用ftok()算出来一个标识符（或者自己定义一个）使用了。

int size 是这块内存的大小．  
int flag 是这块内存的模式(mode)以及权限标识。  
模式可取如下值：          
IPC\_CREAT 新建（如果已创建则返回目前共享内存的id）  
IPC\_EXCL   与IPC\_CREAT结合使用，如果已创建则则返回错误  
然后将“模式” 和“权限标识”进行“或”运算，做为第三个参数。  
如：    IPC\_CREAT | IPC\_EXCL | 0640     
例子中的0666为权限标识,4/2/1 分别表示读/写/执行3种权限，第一个0是UID,第一个6（4+2）表示拥有者的权限，第二个4表示同组权限，第3个0表示他人的权限。  
这个函数成功时返回共享内存的ID，失败时返回-1。

关于这个函数，要多说两句。  
创建共享内存时，shmflg参数至少需要 IPC\_CREAT | 权限标识，如果只有IPC\_CREAT 则申请的地址都是k=0xffffffff，不能使用；  
获取已创建的共享内存时，shmflg不要用IPC\_CREAT（只能用创建共享内存时的权限标识，如0640），否则在某些情况下，比如用ipcrm删除共享内存后，用该函数并用IPC\_CREAT参数获取一次共享内存（当然，获取失败），则即使再次创建共享内存也不能成功，此时必须更改key来重建共享内存。

3) shmat()将这个内存区映射到本进程的虚拟地址空间。

函数原型:  
void    \*shmat( int shmid , char \*shmaddr , int shmflag );

shmat()是用来允许本进程访问一块共享内存的函数。  
int shmid是那块共享内存的ID。  
char \*shmaddr是共享内存的起始地址，如果shmaddr为0，内核会把共享内存映像到调用进程的地址空间中选定位置；如果shmaddr不为0，内核会把共享内存映像到shmaddr指定的位置。所以一般把shmaddr设为0。  
int shmflag是本进程对该内存的操作模式。如果是SHM\_RDONLY的话，就是只读模式。其它的是读写模式  
成功时，这个函数返回共享内存的起始地址。失败时返回-1。

4) shmdt()函数删除本进程对这块内存的使用，shmdt()与shmat()相反，是用来禁止本进程访问一块共享内存的函数。

函数原型:  
int shmdt( char \*shmaddr );  
参数char \*shmaddr是那块共享内存的起始地址。  
成功时返回0。失败时返回-1。

5) shmctl() 控制对这块共享内存的使用

函数原型：  
int     shmctl( int shmid , int cmd , struct shmid\_ds \*buf );  
int shmid是共享内存的ID。  
int cmd是控制命令，可取值如下：  
        IPC\_STAT        得到共享内存的状态  
        IPC\_SET         改变共享内存的状态  
        IPC\_RMID        删除共享内存  
struct shmid\_ds \*buf是一个结构体指针。IPC\_STAT的时候，取得的状态放在这个结构体中。如果要改变共享内存的状态，用这个结构体指定。  
返回值：        成功：0  
                失败：-1

示例程序:

\#include <sys/ipc.h>  
\#include <sys/shm.h>  
\#include <string.h>  
\#include <stdio.h>  
\#include <stdlib.h>

\#define IPCKEY 0x366378

typedef struct\{  
char agen\[10\];  
unsigned char file\_no;  
\} st\_setting;

int main(int argc, char\*\* argv)  
\{   
    int shm\_id;  
    key\_t key;  
    st\_setting \*p\_setting;  
      
    //首先检查共享内存是否存在，存在则先删除  
    shm\_id = shmget(IPCKEY ,1028,0640);       
    if(shm\_id != -1)  
    \{  
        p\_setting = (st\_setting\*)shmat(shm\_id,NULL,0);  
      if ( p\_setting != (void \*)-1)  
      \{  
      shmdt(p\_setting);  
          shmctl(shm\_id,IPC\_RMID,0) ;  
      \}  
    \}  
          
    shm\_id=shmget(IPCKEY,1028,0640|IPC\_CREAT|IPC\_EXCL);   
    if(shm\_id==-1)  
    \{  
        printf("shmget error\\n");  
        return -1;  
    \}  
    //将这块共享内存区附加到自己的内存段  
    p\_setting=(st\_setting\*)shmat(shm\_id,NULL,0);  
      
    strncpy(p\_setting->agen,"jinyh",10);   
    printf( "agen:%s\\n",p\_setting->agen );  
      
    p\_setting->file\_no = 1;  
    printf( "file\_no:%d\\n",p\_setting->file\_no );  
      
    system("ipcs -m");//此时可看到有进程关联到共享内存的信息，nattch为1  
      
    //将这块共享内存区从自己的内存段删除出去  
    if(shmdt(p\_setting) == -1)  
       perror(" detach error ");  
      
    system("ipcs -m");//此时可看到有进程关联到共享内存的信息，nattch为0  
      
    //删除共享内存  
    if (shmctl( shm\_id , IPC\_RMID , NULL ) == -1)  
      perror(" delete error ");  
        
     //exit(0);  
        
\}

注意：在使用共享内存，结束程序退出后。如果你没在程序中用shmctl()删除共享内存的话，一定要在命令行下用ipcrm命令删除这块共享内存。你要是不管的话，它就一直在那儿放着了。  
简单解释一下ipcs命令和ipcrm命令。

取得ipc信息：  
ipcs \[-m|-q|-s\]  
\-m      输出有关共享内存(shared memory)的信息  
\-q      输出有关信息队列(message queue)的信息  
\-s      输出有关“遮断器”(semaphore)的信息  
%ipcs -m

删除ipc  
ipcrm -m|-q|-s shm\_id  
%ipcrm -m 105

二、陷阱（参考http://www.ibm.com/developerworks/cn/aix/library/au-cn-sharemem/）

1）ftok陷阱

采用ftok来生成key的情况下，如果ftok的参数pathname指定文件被删除后重建，则文件系统会赋予这个同名文件（或目录）新的i节点信息，于是这些进程所调用的ftok虽然都能正常返回，但得到的键值却并不能保证相同。

2）3. AIX中shmat的问题

AIX系统中，System V各类进程间通信机制在使用中均存在限制。区别于其它UNIX操作系统对IPC机制的资源配置方式，AIX使用了不同的方法；在AIX中定义了 IPC 机制的上限, 且是不可配置的。就共享内存机制而言，在4.2.1及以上版本的AIX系统上，存在下列限制：

对于64位进程，同一进程可连接最多268435456个共享内存段；   
对于32位进程，同一进程可连接最多11个共享内存段，除非使用扩展的shmat；   
上述限制对于64位应用不会带来麻烦，因为可供连接的数量已经足够大了；

但对于32位应用，却很容易带来意外的问题，因为最大的连接数量只有11个。

下面的例程test02.c演示了这个问题，为了精简代码，它反复连接的是同一个共享内存对象；

实际上，无论所连接的共享内存对象是否相同，该限制制约的是连接次数：

\#include <stdio.h>  
\#include <errno.h>   
\#include <sys/types.h>  
\#include <sys/ipc.h>  
\#include <sys/shm.h>  
\#define MAX\_ATTACH\_NUM 15

void main(int argc, char\* argv\[\])  
\{  
    key\_t       mem\_key;  
    long        mem\_id;  
    void\*       mem\_addr\[MAX\_ATTACH\_NUM\];  
    int          i;  
    if ( ( mem\_key = ftok("/tmp/mykeyfile", 1) ) == (key\_t)(-1) ) \{  
            printf("Failed to generate shared memory access key, ERRNO=%d\\n",    errno);  
            goto MOD\_EXIT;  
    \}  
    if ( ( mem\_id = shmget(mem\_key, 256, IPC\_CREAT) ) == (-1) ) \{  
            printf("Failed to obtain shared memory ID, ERRNO=%d\\n", errno);  
            goto MOD\_EXIT;  
    \}  
    for ( i=1; i<=MAX\_ATTACH\_NUM; i++ ) \{  
   if ( ( mem\_addr\[i\] = (void \*)shmat(mem\_id, 0, 0) ) == (void \*)(-1) )  
    printf("Failed to attach shared memory, times \[%02d\], errno:%d\\n", i,  
    errno);  
   else  
    printf("Successfully attached shared memory, times \[%02d\]\\n", i);  
    \}  
MOD\_EXIT:  
    shmctl(mem\_id, IPC\_RMID, NULL);  
\}

在AIX系统上，我们将其编译为test02，并运行，可以看到如下输出：

Successfully attached shared memory, times \[01\]   
Successfully attached shared memory, times \[02\]   
Successfully attached shared memory, times \[03\]   
Successfully attached shared memory, times \[04\]   
Successfully attached shared memory, times \[05\]   
Successfully attached shared memory, times \[06\]   
Successfully attached shared memory, times \[07\]   
Successfully attached shared memory, times \[08\]   
Successfully attached shared memory, times \[09\]   
Successfully attached shared memory, times \[10\]   
Successfully attached shared memory, times \[11\]   
Failed to attach shared memory, times \[12\], errno:24  
Failed to attach shared memory, times \[13\], errno:24  
Failed to attach shared memory, times \[14\], errno:24  
Failed to attach shared memory, times \[15\], errno:24

说明超出11个连接之后，所有后续的共享内存连接都将无法建立。错误码24的定义是EMFILE，AIX给予的解释是：

The number of shared memory segments attached to the calling process exceeds the system-imposed limit。

解决这个问题的方法是，使用扩展的shmat；具体而言就是，在运行相关应用之前（确切地说，是在共享内存被创建之前），首先在shell中设置EXTSHM环境变量，通过它扩展shmat，对于源代码本身无需作任何修改：

export EXTSHM=ON

值得注意的是，虽然设置环境变量，在程序中也可通过setenv函数来做到，比如在程序的开始，加入下列代码：

setenv("EXTSHM", "ON", 1);

但实践证明这样的方法在解决这个问题上是无效的；也就是说唯一可行的办法，就是在shell中设置EXTSHM环境变量，而非在程序中。

在AIX上配置32位DB2实例时，也要求确保将环境变量 EXTSHM 设为 ON，这是运行 Warehouse Manager 和 Query Patroller 之前必需的操作：  
export EXTSHM=ON  
db2set DB2ENVLIST=EXTSHM  
db2start  
其原因即来自我们刚刚介绍的AIX中32位应用连接共享内存时，存在最大连接数限制。这个问题同样普遍存在于AIX平台上Oracle等软件产品中。

3）HP-UX中shmget和shmat的问题

3.1 32位和64位应用兼容问题

在HP-UX平台上，如果同时运行32位应用和64位应用，而且它们访问的是一个相同的共享内存区，则会遇到兼容性问题。

在HP-UX中，应用程序设置IPC\_CREAT标志调用shmget，所创建的共享内存区，只可被同类型的应用所访问；即32位应用程序所创建的共享内存区只可被其它的32位应用程序访问，同样地，64位应用程序所创建的共享内存区只可被其它的64位应用程序访问。

如果，32位应用企图访问一个由64位应用创建的共享内存区，则会在调用shmget时失败，得到EINVAL错误码，其解释是：

A shared memory identifier exists for key but is in 64-bit address space and the process performing the request has been compiled as a 32-bit executable.

解决这一问题的方法是，当64位应用创建共享内存时，合并IPC\_CREAT标志，同时给定IPC\_SHARE32标志：

shmget(mem\_key, size, 0666 | IPC\_CREAT | IPC\_SHARE32)

对于32位应用，没有设定IPC\_SHARE32标志的要求，但设置该标志并不会带来任何问题，也就是说无论应用程序将被编译为32位还是64位模式，都可采用如上相同的代码；并且由此解决32位应用和64位应用在共享内存访问上的兼容性问题。

3.2 对同一共享内存的连接数限制

在HP-UX上，应用进程对同一个共享内存区的连接次数被限制为最多1次；区别于上面第3节所介绍的AIX上的连接数限制，HP-UX并未对指向不同共享内存区的连接数设置上限，也就是说，运行在HP-UX上的应用进程可以同时连接很多个不同的共享内存区，但对于同一个共享内存区，最多只允许连接1次；否则，shmat调用将失败，返回错误码EINVAL，在shmat的man帮助中，对该错误码有下列解释：

shmid is not a valid shared memory identifier, (possibly because the shared memory segment was already removed using shmctl(2) with IPC\_RMID), or the calling process is already attached to shmid.

这个限制会对多线程应用带来无法避免的问题，只要一个应用进程中有超过1个以上的线程企图连接同一个共享内存区，则都将以失败而告终。

解决这个问题，需要修改应用程序设计，使应用进程具备对同一共享内存的多线程访问能力。相对于前述问题的解决方法，解决这个问题的方法要复杂一些。

作为可供参考的方法之一，以下介绍的逻辑可以很好地解决这个问题：

基本思路是，对于每一个共享内存区，应用进程首次连接上之后，将其键值（ftok的返回值）、系统标识符（shmid，shmget调用的返回值）和访问地址（即shmat调用的返回值）保存下来，以这个进程的全局数组或者链表的形式留下记录。在任何对共享内存的连接操作之前，程序都将先行检索这个记录列表，根据键值和标志符去匹配希望访问的共享内存，如果找到匹配记录，则从记录中直接读取访问地址，而无需再次调用shmat函数，从而解决这一问题；如果没有找到匹配目标，则调用shmat建立连接，并且为新连接上来的共享内存添加一个新记录。

记录条目的数据结构，可定义为如下形式：

typedef struct \_Shared\_Memory\_Record  
\{  
key\_t   mem\_key;   // key generated by ftok()     
int    mem\_id;    // id returned by shmget()     
void\*   mem\_addr;   // access address returned by shmat()   
int    nattach;    // times of attachment      
\} Shared\_

4）Solaris中的shmdt函数原型问题

Solaris系统中的shmdt调用，在原型上与System V标准有所不同，

Default  
     int shmdt(char \*shmaddr);

即形参shmaddr的数据类型在Solaris上是char \*，而System V定义的是void \* 类型；实际上Solaris上shmdt调用遵循的函数原型规范是SVID-v4之前的标准；以Linux系统为例，libc4和libc5 采用的是char \* 类型的形参，而遵循SVID-v4及后续标准的glibc2及其更新版本，均改为采用void \* 类型的形参。

如果仍在代码中采用System V的标准原型，就会在Solaris上编译代码时造成编译错误；比如：

Error: Formal argument 1 of type char\* in call to shmdt(char\*)   
is being passed void\*.  
  
解决方法是，引入一个条件编译宏，在编译平台是Solaris时，采用char \* 类型的形参，而对其它平台，均仍采用System V标准的void \* 类型形参，比如：

\#ifdef \_SOLARIS\_SHARED\_MEMORY           
shmdt((char \*)mem\_addr);   
\#else                   
shmdt((void \*)mem\_addr);   
\#endif

5）通过shmctl删除共享内存的风险

如果共享内存已经与所有访问它的进程断开了连接，则调用IPC\_RMID子命令后，系统将立即删除共享内存的标识符，并删除该共享内存区，以及所有相关的数据结构；   
如果仍有别的进程与该共享内存保持连接，则调用IPC\_RMID子命令后，该共享内存并不会被立即从系统中删除，而是被设置为IPC\_PRIVATE状态，并被标记为"已被删除"；直到已有连接全部断开，该共享内存才会最终从系统中消失。

需要说明的是：一旦通过shmctl对共享内存进行了删除操作，则该共享内存将不能再接受任何新的连接，即使它依然存在于系统中！所以，可以确知，在对共享内存删除之后不可能再有新的连接，则执行删除操作是安全的；否则，在删除操作之后如仍有新的连接发生，则这些连接都将失败！

[http://www.cnblogs.com/skyme/archive/2011/01/04/1925404.html][http_www.cnblogs.com_skyme_archive_2011_01_04_1925404.html]

补充: [http://linux.chinaitlab.com/administer/805071.html][http_linux.chinaitlab.com_administer_805071.html]

共享内存（Shared Memory）

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

![20100403090132323.jpg][]  
　　　　　　　　　　　　　　　　　　图 共享内存映射图

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

每一个新创建的共享内存对象都用一个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数据结构。其实，虚拟内存并没有在粘附的时候创建，而要等到第一个进程试图访问它的时候才创建。

![20100403090132478.jpg][]  
　　　　　　　　　　　　　　图 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。

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

4. 控制。

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

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

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

需要包含的头文件：

\#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.使用共享内存

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

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

int shmdt(char \*shmaddr);

5.释放共享内存

int shmctl(int shmid,int cmd,struct shmid\_ds \*buf);

[http_www.cnblogs.com_skyme_archive_2011_01_04_1925404.html]: http://www.cnblogs.com/skyme/archive/2011/01/04/1925404.html
[http_linux.chinaitlab.com_administer_805071.html]: http://linux.chinaitlab.com/administer/805071.html
[20100403090132323.jpg]: http://linux.chinaitlab.com/UploadFiles_7565/201004/20100403090132323.jpg
[20100403090132478.jpg]: http://linux.chinaitlab.com/UploadFiles_7565/201004/20100403090132478.jpg
[linux]: http://linux.chinaitlab.com/
[Link 1]: http://cisco.chinaitlab.com/List_7.html
[Link 2]: http://cisco.chinaitlab.com/List_11.html