失败返回值为-1

ftok应用范围

         英文是这样描述的; generate  a  key_t  type  System V IPC key, suitable for use with msgget(2),semget(2), or shmget(2).

系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。

在一般的UNIX实现中，是将pathname指定文件的索引节点号取出，前面加上子序号得到key_t的返回值。

如指定文件的索引节点号为65538，换算成16进制为0x010002，而你指定的ID值为38，换算成16进制为0x26，则最后的key_t返回值为0x26010002。
    查询文件索引节点号可通过命令： ls -i    来查看

    nux Programmer's Manual                   FTOK(3)
                                                                                                                                      
NAME
       ftok - convert a pathname and a project identifier to a System V IPC
       key
                                                                                                                                      
SYNOPSIS
       # include <sys/types.h>
       # include <sys/ipc.h>
                                                                                                                                      
       key_t ftok(const char *pathname, int proj_id);
                                                                                                                                      
DESCRIPTION
       The ftok function uses the identity of the file named by the given  pathname (which must refer to an existing, accessible file) and the
least significant 8 bits of proj_id (which must be nonzero) to generate a key_t type System V IPC key, suitable for use with msgget(2),
semget(2), or shmget(2).
                                                                                                                                      
       The resulting value is the same for all pathnames that name the same file, when the same value of proj_id is used. The value returned should be different when the (simultaneously existing) files or the project  IDs differ.
                                                                                                                                      
RETURN VALUE
       On success the generated key_t value is returned. On failure -1 is returned, with errno indicating the error as for the stat(2) system
call.

　　 #include <sys/types.h>
　　 #include <sys/ipc.h>
　　 #include <sys/sem.h>
　　 int semget(key_t key, int nsems, int flag);

　  key是前面讲过的IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量个数。如果是创建新 集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。

     每个信号量至少包含如下数据结构
     struct sem {
          short       sempid;/* pid of last operaton */
          ushort     semval;/* current value */
          ushort     semncnt;/* num procs awaiting increase in semval */
          ushort     semzcnt;/* num procs awaiting semval = 0 */
    }

　　 semctl函数用来对信号量进行操作。
　　 int semctl(int semid, int semnum, int cmd, union semun arg);
　　 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。
　　
     semop函数自动执行信号量集合上的操作数组。
　　 int semop(int semid, struct sembuf semoparray[], size_t nops);
　　 semoparray是一个指针，它指向这样一个数组:元素用来描述对semid代表的信号量集合中第几个信号进行怎么样的操作。nops规定该数组中操作的数量。

　　 下面，我们看一个具体的例子，它创建一个特定的IPC结构的关键字和一个信号量，建立此信号量的索引，修改索引指向的信号量的值，最后我们清除信号量。在下面的代码中，函数ftok生成我们上文所说的唯一的IPC关键字。

#include <stdio.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/ipc.h>
void main() { 
    key_t unique_key; /* 定义一个IPC关键字*/ 
    int id; 
    struct sembuf lock_it; 
    union semun options;//存放semctl要使用的入参或者代表结果的出参 
    int i;

    unique_key = ftok(".", 'a'); /* 生成关键字，字符'a'是一个随机种子*/ 
    /* 创建一个新的信号量集合*/ 
    id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666); 
    printf("semaphore id=%d\n", id); 
    options.val = 1; /*设置变量值*/ 
    semctl(id, 0, SETVAL, options); /*设置索引0的信号量*/

    /*打印出信号量的值*/ 
    i = semctl(id, 0, GETVAL, 0); 
    printf("value of semaphore at index 0 is %d\n", i);

    /*下面重新设置信号量*/ 
    lock_it.sem_num = 0; /*设置哪个信号量*/ 
    lock_it.sem_op = -1; /*定义操作*/ 
    lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/ 
    if (semop(id, &lock_it, 1) == -1) { 
        printf("can not lock semaphore.\n"); 
        exit(1); 
    }

    i = semctl(id, 0, GETVAL, 0); 
    printf("value of semaphore at index 0 is %d\n", i);

    /*清除信号量*/ 
    semctl(id, 0, IPC_RMID, 0);
}

semget()

     可以使用系统调用semget()创建一个新的信号量集，或者存取一个已经存在的信号量集：

    系统调用：semget();
    原型：int    semget(key_t key,int nsems,int semflg);
    返回值：如果成功，则返回信号量集的IPC标识符。
                   如果失败，则返回-1：errno=EACCESS(没有权限)
                    EEXIST(信号量集已经存在，无法创建)
                    EIDRM(信号量集已经删除)
                    ENOENT(信号量集不存在，同时没有使用IPC_CREAT)
                    ENOMEM(没有足够的内存创建新的信号量集)
                    ENOSPC(超出限制)
        系统调用semget()的第一个参数是关键字值（一般是由系统调用ftok()返回的）。系统内核将此值和系统中存在的其他的信号量集的关键字值进行比较。打开和存取操作与参数semflg中的内容相关。IPC_CREAT如果信号量集在系统内核中不存在，则创建信号量集。如果单独使用IPC_CREAT，则semget()要么返回新创建的信号量集的标识符，要么返回系统中已经存在的同样的关键字值的信号量的标识符。如果IPC_EXCL和IPC_CREAT一同使用，则要么返回新创建的信号量集的标识符，要么返回-1。IPC_EXCL单独使用没有意义。参数nsems指出了一个新的信号量集中应该创建的信号量的个数。信号量集中最多的信号量的个数是在linux/sem.h中定义的：
#defineSEMMSL32/*<=512maxnumofsemaphoresperid*/
下面是一个打开和创建信号量集的程序：
    int    open_semaphore_set(key_t keyval,int numsems)
    {
        intsid;
        if(!numsems)
            return(-1);
        if((sid=semget(mykey,numsems,IPC_CREAT|0660))==-1)
        {
            return(-1);
        }
        return(sid);
    };
==============================================================
semop()

系统调用：semop();
调用原型：int semop(int semid,struct sembuf*sops,unsign ednsops);
返回值：0，如果成功。
               -1，如果失败：errno=E2BIG(nsops大于最大的ops数目)
        EACCESS(权限不够)
        EAGAIN(使用了IPC_NOWAIT，但操作不能继续进行)
        EFAULT(sops指向的地址无效)
        EIDRM(信号量集已经删除)
        EINTR(当睡眠时接收到其他信号)
        EINVAL(信号量集不存在,或者semid无效)
        ENOMEM(使用了SEM_UNDO,但无足够的内存创建所需的数据结构)
        ERANGE(信号量值超出范围)

        第一个参数是关键字值。第二个参数是指向将要操作的数组的指针。第三个参数是数组中的操作的个数。参数sops指向由sembuf组成的数组。此数组是在linux/sem.h中定义的：
        /*semop systemcall takes an array of these*/
        struct    sembuf{
                ushort    sem_num;/*semaphore index in array*/
                short    sem_op;/*semaphore operation*/
                short    sem_flg;/*operation flags*/
       }
                sem_num将要处理的信号量的index。
                sem_op要执行的操作。
                sem_flg操作标志。
    如果sem_op是负数，那么信号量将减去它的值。这和信号量控制的资源有关。如果没有使用IPC_NOWAIT，那么调用进程将进入睡眠状态，直到信号量控制的资源可以使用为止。如果sem_op是正数，则信号量加上它的值。这也就是进程释放信号量控制的资源。最后，如果sem_op是0，那么调用进程将调用sleep()，直到信号量的值为0。这在一个进程等待完全空闲的资源时使用。
===============================================================
semctl()

系统调用：semctl();
原型：int semctl(int semid,int semnum,int cmd,union semunarg);
返回值： 如果成功，则为一个正数。
                如果失败，则为-1：errno=EACCESS(权限不够)
                EFAULT(arg指向的地址无效)
                EIDRM(信号量集已经删除)
                EINVAL(信号量集不存在，或者semid无效)
                EPERM(EUID没有cmd的权利)
                ERANGE(信号量值超出范围)

        系统调用semctl()的第一个参数指定要对哪个信号量集合操作。第二个参数是指定被操作的信号量相对于集合的偏移量。第三个参数是要执行的操作,第四个操作要使用的数据.
        参数cmd中可以使用的命令如下：
        ·IPC_STAT    读取一个semid指定的信号量集合的数据结构 将其存储在semunarg中的buf成员中。因为是copy本身信息,所以参数semnum无效.
        ·IPC_SET       用semunarg的buf成员来设置信号量集的数据结构。
        ·IPC_RMID    将信号量集从内存中删除。
        ·GETALL       用于读取信号量集中的所有信号量的值到semunarg的array成员中。
        ·GETNCNT    返回正在等待资源(被该信号阻塞)的进程数目。
        ·GETPID        返回该信号量上最后一个执行semop操作的进程的PID。
        ·GETVAL       返回信号量集中的一个单个的信号量的值。
        ·GETZCNT    返回这在等待该信号量完全空闲的资源的进程数目。
        ·SETALL        用semumarg的array成员来设置信号量集中的所有的信号量的值。
        ·SETVAL        用semnumarg的val成员设置信号量集中的一个单独的信号量的值。
    参数semnumarg代表一个semun的实例。semun是在linux/sem.h中定义的：
    /*arg for semctl systemcalls.*/
    union    semun{
            int    val;/*value for SETVAL*/
            struct    semid_ds  * buf;/*buffer for IPC_STAT&IPC_SET*/
            ushort * array;/*array for GETALL&SETALL*/
            struct    seminfo* __buf;/*buffer for IPC_INFO*/
    }
      是一个union 变量 ,也就是说任何是否都只能使用它的一个成员,至于使用哪个成员,就要cmd参数指定什么操作了.
       val当执行SETVAL命令时使用。buf在IPC_STAT/IPC_SET命令中使用。代表了内核中使用的信号量的数据结构。array在使用GETALL/SETALL命令时使用的指针,代表一个数组,是存放要使用的入参,或者是操作结果的出参.
    下面的程序返回信号量的值。当使用GETVAL命令时，调用中的最后一个参数被忽略：
    int    get_sem_val(intsid,intsemnum)
    {
        return(semctl(sid,semnum,GETVAL,0));
    }
    下面是一个实际应用的例子：
    #define    MAX_PRINTERS    5
    void printer_usage()
    {
        int x;
        for(x=0;x<MAX_PRINTERS;x++)
            printf("Printer%d:%d\n\r",x,get_sem_val(sid,x));
    }
    下面的程序可以用来初始化一个新的信号量值：
    void init_semaphore(int sid,int semnum,int initval)
    {
    union semun    semopts;
    semopts.val=initval;
    semctl(sid,semnum,SETVAL,semopts);
    }

#define SEMKEY  (key_t)0x20

#define SIZ 5*BUFSIZ

#define IFLAGS (IPC_CREAT|IPC_EXCL)
#define ERR ((struct databuf*)-1)
//p1,v1是针对第一个信号进行的操作
struct sembuf p1 = {0, -1, 0};
struct sembuf v1 = {0, 1, 0};
//p2,v1是针对第二个信号进行的操作
struct sembuf p2 = {1, -1, 0};
struct sembuf v2 = {1, 1, 0};
//表示两个内存共享区和一个信号量集合
static int shmid1, shmid2, semid;
//作为暂时存放数据的结构体
struct databuf
{
    int d_nread;
    char d_buf[SIZ];
};

void fatal(char *mes)
{
      perror(mes);
      exit (1);
}
/**创建两个共享内存,并且分别shmat给两个参数*/
void getshm (struct databuf **p1, struct databuf **p2)
{      //创建共享内存
      if ((shmid1=shmget(SHMKEY1, sizeof(struct databuf), 0600|IFLAGS)) < 0)
      {
        fatal ("shmget");
      }

      if ((shmid2=shmget(SHMKEY2, sizeof(struct databuf), 0600|IFLAGS)) < 0)
      {
        fatal ("shmget");
      }
      //映射
      if ((*p1=(struct databuf*)(shmat(shmid1, 0, 0))) == ERR)
      {
        fatal("shmat");
      }

      if((*p2=(struct databuf*)(shmat(shmid2, 0, 0))) == ERR)
      {
        fatal("shmat");
      }

}

int getsem()
{
         //获取一个长度为2的信号量集合;
          if ((semid=semget(SEMKEY, 2, 0600|IFLAGS)) < 0)
          {
          fatal("segmet");
          }
          //初始化信号量,假定第一个信号灯没有资源
          if (semctl(semid, 0, SETVAL, 0) < 0)
          {
           fatal ("semctl");
          }
          //第二个有信息,如果两个信号都没有资源,将会出现死锁
          //书上该处有问题
          if (semctl(semid, 1, SETVAL, 1) < 0)
          {
            fatal ("semctl");
          }

          return (semid);
}
//回收共享两个内存区和一个信号量集合
void myremove()
{
      if (shmctl(shmid1, IPC_RMID, NULL) < 0)
      {
        fatal("shmctl");
      }
      if (shmctl(shmid2, IPC_RMID, NULL) < 0)
      {
        fatal("shmctl");
      }
      if (semctl(semid, 0, IPC_RMID, NULL) < 0)
         fatal("semctl");
       
      exit(0);
}

void reader(int semid, struct databuf *buf1, struct databuf *buf2)
{
      for(;;)
      {
       unsigned short val= semctl(semid,0,GETVAL,null);
       if(val<=0)
       {
         semop(semid,&v1,1);
       }
       else{
         //申请第一个信号灯资源
         semop(semid, &p1, 1)
       }
       //从键盘读入数据,放在buf1->d_buf，
       //read第一个参数是文件描述符，其中0表示从终端输入：如键盘
       buf1->d_nread = read(0, buf1->d_buf, SIZ);
       //v操作,释放第一个信号灯资源   
       semop(semid, &v1, 1);
      
       //p操作,申请第二个信号灯资源,若没有资源,则阻塞进程直到有资源.
       semop(semid, &p2, 1);
     
       buf2->d_nread = read(0, buf2->d_buf, SIZ);
      //v操作,释放第二个信号灯资源
       semop(semid, &v2, 1);
     }
            
}

void writer(int semid, struct databuf *buf1, struct databuf *buf2)
{
      for(;;)
      {
        //p操作,等待第一个信号的资源    
        semop(semid, &p1, 1);
        //1代表输出到屏幕
        write(1, buf1->d_buf, buf1->d_nread);
        //释放第一个信号灯资源
        semop(semid, &v1, 1);
     
        //p操作,申请第二个信号灯资源,若没有资源,则阻塞进程直到有资源.
        semop(semid, &p2, 1);
      
        write(1, buf2->d_buf, buf2->d_nread);
 
        semop(semid, &v2, 1);
                                                          }
}

int main()
{
      int semid, pid;
       
      struct databuf *buf1, *buf2;
     
      semid = getsem();
      getshm (&buf1, &buf2);

      switch(pid=fork())
      {
        case -1:
            fatal("fork");
            break;
        case 0:
            writer(semid, buf1, buf2);
            break;
        default:
       
        //在主进程中把中断程序的ctrl+c和myremove函数建立联系,
        //来回收系统资源:共享内存区,信号量.
        signal (SIGINT, myremove);
        reader(semid, buf1, buf2);
        break;
     }
      exit(0);
}

         象所有的 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则是该共享内存对象占用内存页面的个数，以页为单位。这个数量当然涵盖了申请空间的最小整数倍.
    (A new shared memory segment,  with size  equal to the value of size rounded up to a multiple of PAGE_SIZE)
    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结构是维系共享内存和使用它的进程之间的关系的,所以除了要关联进程信息外，还要指明这个共享内存数据结构shmid_kernel所在位置; 另外,便于管理这些经常变化的vm_area_struct,所以采取了链表形式组织这些数据结构,链表由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，则总是会创建一个新的共享内存对象。
 但是  (The name choice IPC_PRIVATE was perhaps unfortunate, IPC_NEW would more clearly show its function)
    * 算出size要占用的页数，检查其合法性。
    * 申请一块内存用于建立shmid_kernel数据结构，注意这里申请的内存区域大小不包括真正的共享内存区，实际上，要等到第一个进程试图访问它的时候才真正创建共享内存区。
    * 根据该共享内存区所占用的页数，为其申请一块空间用于建立页表（每页4个字节），将页表清0。
    * 搜索向量表shm_segs，为新创建的共享内存对象找一个空位置。
    * 填写shmid_kernel数据结构，将其加入到向量表shm_segs中为其找到的空位置。
    * 返回该共享内存对象的引用标识符。
 
    2) 在向量表shm_segs中查找键值为key的共享内存对象，结果有三：
    * 如果没有找到，而且在操作标志shmflg中没有指明要创建新共享内存，则错误返回，否则创建一个新的共享内存对象。
    * 如果找到了，但该次操作要求必须创建一个键值为key的新对象，那么错误返回。
    * 否则，合法性、认证检查，如有错，则错误返回；否则，返回该内存对象的引用标识符。
 
    共享内存对象的创建者可以控制对于这块内存的访问权限和它的key是公开还是私有。如果有足够的权限，它也可以把共享内存锁定在物理内存中。
    参见include/linux/shm.h
 
    2. 关联。在创建或获得某个共享内存区域的引用标识符后，还必须将共享内存区域映射（粘附）到进程的虚拟地址空间，然后才能使用该共享内存区域。系统调用 sys_ipc（call值为SHMAT）用于共享内存区到进程虚拟地址空间的映射，而真正完成粘附动作的是函数sys_shmat，
 
其定义如下：   

       #include <sys/types.h>
       #include <sys/shm.h>

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

 
    其中：
     shmid是shmget返回的共享内存对象的引用标识符；
    shmaddr用来指定该共享内存区域在进程的虚拟地址空间对应的虚拟地址；
    shmflg是映射标志；
    返回的是 在进程中的虚拟地址
 
    该函数所做的工作如下：
    1) 根据shmid找到共享内存对象。
    2) 如果shmaddr为0，即用户没有指定该共享内存区域在它的虚拟空间中的位置，则由系统在进程的虚拟地址空间中为其找一块区域（从1G开始）；否则，就用shmaddr作为映射的虚拟地址。
   (If  shmaddr  is NULL, the system chooses a suitable (unused) address a他 which to attach the segment)
    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数据结构从进程的虚拟内存中摘下，清除它在进程页表中对应的页表项（可能占多个页表项）. 
  
    如果共享的虚拟内存没有被锁定在物理内存中，分离会更加复杂。因为在这种情况下，共享内存的页可能在系统大量使用内存的时候被交换到系统的交换磁盘。为了避免这种情况，可以通过下面的控制操作，将某共享内存页锁定在物理内存不允许向外交换。共享内存的换出和换入，已在第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);