Linux 0.11下信号量的实现和应用

时间:2022-07-05 15:17:12

Linux 0.11下信号量的实现和应用

1.生产者-消费者问题

从一个实际的问题:生产者与消费者出发,谈一谈为什么要有信号量?信号量用来做什么?

问题描述:现在存在一个文件”.\buffer.txt”作为一个共享缓冲区,缓冲区同时最多只能保存10个数。现有一个生产者进程,依次向缓冲区写入整数0,1,2,……,M,M>=500;有N个消费者进程,消费者进程从缓冲区读数,每次读一个,并将读出的数从缓冲区删除。

  • 为什么要有信号量?
    对于生产者来说,当缓冲区满,也就是空闲缓冲区个数为0时,此时生产者不能继续向缓冲区写数,必须等待,直到有消费者从满缓冲区取走数后,再次有了空闲缓冲区,生产者才能向缓冲区写数。
    对于消费者来说,当缓冲区空时,此时没有数可以被取走,消费者必须等待,直到有生产者向缓冲区写数后,消费者才能取数。并且如果当缓冲区空时,先后有多个消费者均想从缓冲区取数,那么它们均需要等待,此时需要记录下等待的消费者的个数,以便缓冲区有数可取后,能将所有等待的消费者唤醒,确保请求取数的消费者最终都能取到数。
    也就是说,当多个进程需要协同合作时,需要根据某个信息,判断当前进程是否需要停下来等待;同时,其他进程需要根据这个信息判断是否有进程在等待,或者有几个进程在等待,以决定是否需要唤醒等待的进程。而这个信息,就是信号量。
  • 信号量用来做什么?
    设有一整形变量sem,作为一个信号量。此时缓冲区为空,sem=0。
    1. 消费者C1请求从缓冲区取数,不能取到,睡眠等待。sem=-1<0,表示有一个进程因缺资源而等待。
    2. 消费者C2也请求从缓冲区取数,睡眠等待。sem=-2<0,表示有两个进程因缺资源而等待。
    3. 生产者P往缓冲区写入一个数,sem=sem+1=-1<=0,并唤醒等待队列的头进程C1,C1处于就绪态,C2仍处于睡眠等待。
    4. 生产者P继续往缓冲区写入一个数,sem=0<=0,并唤醒C2,C1、C2就处于就绪状态。
      由此可见,通过判断sem的值以及改变sem的值,就保证了多进程合作的合理有序的推进,这就是信号量的作用。

2. 实现信号量

  • 信号量有什么组成?

    1. 需要有一个整形变量value,用作进程同步。
    2. 需要有一个PCB指针,指向睡眠的进程队列。
    3. 需要有一个名字来表示这个结构的信号量。

    同时,由于该value的值是所有进程都可以看到和访问的共享变量,所以必须在内核中定义;同样,这个名字的信号量也是可供所有进程访问的,必须在内核中定义;同时,又要操作内核中的数据结构:进程控制块PCB,所以信号量一定要在内核中定义,而且必须是全局变量。由于信号量要定义在内核中,所以和信号量相关的操作函数也必须做成系统调用,还是那句话:系统调用是应用程序访问内核的唯一方法。

  • 和信号量相关的函数

    Linux在0.11版还没有实现信号量,我们可以先弄一套缩水版的类POSIX信号量,它的函数原型和标准并不完全相同,而且只包含如下系统调用:

    sem_t *sem_open(const char  *name, unsigned int value);
    int sem_wait(sem_t *sem);
    int sem_post(sem_t *sem);
    int sem_unlink(const char *name);

    sem_t是信号量类型,根据实现的需要自己定义。

  • 信号量的保护
    使用信号量还需要注意一个问题,这个问题是由多进程的调度引起的。当一个进程正在修改信号量的值时,由于时间片耗完,引发调度,该修改信号量的进程被切换出去,而得到CPU使用权的新进程也开始修改此信号量,那么该信号量的值就很有可能发生错误,如果信号量的值出错了,那么进程的同步也会出错。所以在执行修改信号量的代码时,必须加以保护,保证在修改过程中其他进程不能修改同一个信号量的值。也就是说,当一个进程在修改信号量时,由于某种原因引发调度,该进程被切换出去,新的进程如果也想修改该信号量,是不能操作的,必须等待,直到原来修改该信号量的进程完成修改,其他进程才能修改此信号量。修改信号量的代码一次只允许一个进程执行,这样的代码称为临界区,所以信号量的保护,又称临界区保护。
    实现临界区的保护有几种不同的方法,在Linux 0.11上比较简单的方法是通过开、关中断来阻止时钟中断,从而避免因时间片耗完引发的调度,来实现信号量的保护。但是开关中断的方法,只适合单CPU的情况,对于多CPU的情况,不适用。Linux 0.11就是单CPU,可以使用这种方法。

3. 信号量的代码实现

  1. sem_open()
    原型:sem_t *sem_open(const char *name, unsigned int value)
    功能:创建一个信号量,或打开一个已经存在的信号量
    参数:

    • name,信号量的名字。不同的进程可以通过同样的name而共享同一个信号量。如果该信号量不存在,就创建新的名为name的信号量;如果存在,就打开已经存在的名为name的信号量。
    • value,信号量的初值,仅当新建信号量时,此参数才有效,其余情况下它被忽略。
    • 返回值。当成功时,返回值是该信号量的唯一标识(比如,在内核的地址、ID等)。如失败,返回值是NULL。

    由于要做成系统调用,所以会穿插讲解系统调用的相关知识。
    首先,在linux-0.11/kernel目录下,新建实现信号量函数的源代码文件sem.c。同时,在linux-0.11/include/linux目录下新建sem.h,定义信号量的数据结构。
    linux-0.11/include/linux/sem.h

     1 #ifndef _SEM_H
     2 #define _SEM_H
     3 
     4 #include <linux/sched.h>
     5 
     6 #define SEMTABLE_LEN    20
     7 #define SEM_NAME_LEN    20
     8 
     9 
    10 typedef struct semaphore{
    11     char name[SEM_NAME_LEN];
    12     int value;
    13     struct task_struct *queue;
    14 } sem_t;
    15 extern sem_t semtable[SEMTABLE_LEN];
    16 
    17 #endif

     

    由于sem_open()的第一个参数name,传入的是应用程序所在地址空间的逻辑地址,在内核中如果直接访问这个地址,访问到的是内核空间中的数据,不会是用户空间的。所以要用get_fs_byte()函数获取用户空间的数据。get_fs_byte()函数的功能是获得一个字节的用户空间中的数据。同样,sem_unlink()函数的参数name也要进行相同的处理。
  2. sem_unlink()
    原型:int sem_unlink(const char *name)
    功能:删除名为name的信号量。
    返回值:返回0表示成功,返回-1表示失败
  3. sem_wait()
    原型:int sem_wait(sem_t *sem)
    功能:信号量的P原子操作(检查信号量是不是为负值,如果是,则停下来睡眠等待,如果不是,则向下执行)。
    返回值:返回0表示成功,返回-1表示失败。

  4. sem_post()
    原型:int sem_post(sem_t *sem)
    功能:信号量的V原子操作(检查信号量的值是不是为0,如果是,表示有进程在睡眠等待,则唤醒队首进程,如果不是,向下执行)。

    返回值:返回0表示成功,返回-1表示失败。

关于sem_wait()和sem_post()

我们可以利用linux 0.11提供的函数sleep_on()实现进程的睡眠,用wake_up()实现进程的唤醒。
但是,sleep_on()比较难以理解。我们先看下sleep_on()的源码。

 1 void sleep_on(struct task_struct **p)
 2 {
 3     struct task_struct *tmp;
 4 
 5     if (!p)
 6         return;
 7     if (current == &(init_task.task))
 8         panic("task[0] trying to sleep");
 9     tmp = *p;
10     *p = current;
11     current->state = TASK_UNINTERRUPTIBLE;
12     schedule();
13     if (tmp)
14         tmp->state=0;
15 }

 

还拿生产者和消费者的例子来说,依然是有一个生产者和N个消费者,目前缓冲区为空,没有数可取。
  1. 消费者C1请求取数,调用sleep_on(&sem->queue)。此时,tmp指向NULL,p指向C1,调用schedule(),让出CPU的使用权。此时,信号量sem处等待队列的情况如下:

    Linux 0.11下信号量的实现和应用

    由于tmp是进程C1调用sleep_on()函数时申请的局部变量,所以会保存在C1运行到sleep_on()函数中时C1的内核栈中,只要进程C1还没有从sleep_on()函数中退出,tmp就会一直保存在C1的内核栈中。而进程C1是在sleep_on()中调用schedule()切出去的,所以在C1睡眠期间,tmp自然会保存在C1的内核栈中。这一点对于理解sleep_on()上如何形成隐式的等待队列很重要。

  2. 消费者C2请求取数,调用sleep_on(&sem->queue)。此时,信号量sem处的等待队列如下:

    Linux 0.11下信号量的实现和应用

    从这里就可以看到隐式的等待队列已经形成了。由于进程C2也会由于调用schedule()函数在sleep_on()函数中睡眠,所以进程C2内核栈上的tmp便指向之前的等待队列的队首,也就是C1,通过C2的内核栈便可以找到睡眠的进程C1。这样就可以找到在信号量sem处睡眠的所有进程。

  3. 我们在看下唤醒函数wake_up()

    1 void wake_up(struct task_struct **p)
    2 {
    3     if (p && *p) {
    4         (**p).state=0;
    5         *p=NULL;
    6     }
    7 }

     

    从中我们可以看到唤醒函数wake_up()负责唤醒的是等待队列队首的进程。
    当队首进程C2被唤醒时,从schedule()函数退出,执行语句:

    1 if (tmp)
    2     tmp->state=0;

     

    会将内核栈上由tmp指向的进程C1唤醒,如果进程C1的tmp还指向其他睡眠的进程,当C1被调度执行时,会将其tmp指向的进程唤醒,这样只要执行一次wake_up()操作,就可以依次将所有等待在信号量sem处的睡眠进程唤醒。

sem_wait()和sem_post()函数的代码实现

由于我们要调用sleep_on()实现进程的睡眠,调用wake_up()实现进程的唤醒,我们在上面已经讲清楚了sleep_on()wake_up()的工作机制,接下来,便可以具体实现sem_wait()sem_post()函数了。

  1. sem_wait()的实现
    考虑到sleep_on()会形成一个隐式的等待队列,而wake_up()只要唤醒了等待队列的头结点,就可以依靠sleep_on()内部的判断语句,实现依次唤醒全部的等待进程。所以,sem_wait()的代码实现,必须考虑到这个情况。
    参考linux 0.11内部的代码,对于进程是否需要等待的判断,不能用简单的if语句,而应该用while()语句,假设现在sem=-1,生产者往缓冲区写入了一个数,sem=0<=0,此时应该将等待队列队首的进程唤醒。当被唤醒的队首进程再次调度执行,从sleep_on()函数退出,不会再执行if判断,而直接从if语句退出,继续向下执行。而等待队列后面被唤醒的进程随后也会被调度执行,同样也不会执行if判断,退出if语句,继续向下执行,这显然是不应该的。因为生产者只往缓冲区写入了一个数,被等待队列的队首进程取走了,由于等待队列的队首进程已经取走了那个数,它应该已经将sem修改为sem=-1,其他等待的进程应该再次执行if判断,由于sem=-1<0,会继续睡眠。要让其他等待进程再次执行时,要重新进行判断,所以不能是if语句了,必须是while()语句才可以。
    下面是我第一次实现sem_wait()的代码:

    1 int sys_sem_wait(sem_t *sem)
    2 {
    3     cli();
    4     sem->value--;
    5     while( sem->value < 0 )
    6         sleep_on(&(sem->queue))
    7     sti();
    8     return 0;
    9 }

     

    但是没有考虑到有一种特殊的信号量:互斥信号量。比如要读写一个文件,一次只能允许一个进程读写,当一个进程要读写该文件时,需要先执行sem_wait(file),此后在该进程读写文件期间,若有其他进程也要读写该文件,则执行流程分析如下:

    • 进程P1申请读写该文件,value=-1,sleep_on(&file->queue)
    • 进程P2申请读写该文件,value=-2,sleep_on(&file->queue)
    • 原来读写该文件的进程读写完毕,置value=-1,并唤醒等待队列的队首进程P2。
    • 进程P2再次执行,唤醒进程P1,此时执行while()判断,不能跳出while()判断,继续睡眠等待。此时文件并没有被占用,P2完全可以读写该文件,所以程序运行出错了。出错原因在于,修改信号量的语句,必须放在while()判断的后面,因为执行while()判断,进程有可能睡眠,而这种情况下,是不需要记录有多少个进程在睡眠的,因为sleep_on()函数形成的隐式的等待队列已经记录下了进程的等待情况。

    正确的sem_wait()代码如下:

    1 int sys_sem_wait(sem_t *sem)
    2 {
    3     cli();
    4     while( sem->value <= 0 )        //
    5         sleep_on(&(sem->queue));    //这两条语句顺序不能颠倒,很重要,是关于互斥信号量能不
    6     sem->value--;               //能正确工作的!!!
    7     sti();
    8     return 0;
    9 }

     

  2. sem_post()的实现
    sem_post的实现必须结合sem_wait()的实现情况。
    还拿生产者和消费者的例子来分析。当前缓冲区为空,没有数可取,value=0。

    • 消费者C1执行sem_wait(),value=0,sleep_on(&queue)
    • 消费者C2执行sem_wait(),value=0,sleep_on(&queue)。等待队列的情况如下:
    Linux 0.11下信号量的实现和应用
    • 生产者执行sem_post(),value=1,wake_up(&queue),唤醒消费者C2。队列的情况如下:
    Linux 0.11下信号量的实现和应用
    • 生产者再次执行sem_post(),value=2,wake_up(&queue)相当于wake_up(NULL)。队列情况如上。
    • 消费者C2再次执行,唤醒C1,跳出while(),value=1,继续向下执行。
    • 消费者C1再次执行,跳出while(),value=0,继续向下执行。

    由此可以看出,sem_post()里面唤醒进程的判断条件是:value<=1。

    sem_post的实现代码如下:

    1 int sys_sem_post(sem_t *sem)
    2 {
    3     cli();
    4     sem->value++;
    5     if( (sem->value) <= 1)
    6         wake_up(&(sem->queue));
    7     sti();
    8     return 0;
    9 }

     

信号量的完整代码

linux-0.11/kernel/sem.c

  1 #include <linux/sem.h>
  2 #include <linux/sched.h>
  3 #include <unistd.h>
  4 #include <asm/segment.h>
  5 #include <linux/tty.h>
  6 #include <linux/kernel.h>
  7 #include <linux/fdreg.h>
  8 #include <asm/system.h>
  9 #include <asm/io.h>
 10 //#include <string.h>
 11 
 12 sem_t semtable[SEMTABLE_LEN];
 13 int cnt = 0;
 14 
 15 sem_t *sys_sem_open(const char *name,unsigned int value)
 16 {
 17     char kernelname[100];   /* 应该足够大了 */
 18     int isExist = 0;
 19     int i=0;
 20     int name_cnt=0;
 21     while( get_fs_byte(name+name_cnt) != '\0')
 22     name_cnt++;
 23     if(name_cnt>SEM_NAME_LEN)
 24     return NULL;
 25     for(i=0;i<name_cnt;i++)
 26     kernelname[i]=get_fs_byte(name+i);
 27     int name_len = strlen(kernelname);
 28     int sem_name_len =0;
 29     sem_t *p=NULL;
 30     for(i=0;i<cnt;i++)
 31     {
 32         sem_name_len = strlen(semtable[i].name);
 33         if(sem_name_len == name_len)
 34         {
 35                 if( !strcmp(kernelname,semtable[i].name) )
 36                 {
 37                     isExist = 1;
 38                     break;
 39                 }
 40         }
 41     }
 42     if(isExist == 1)
 43     {
 44         p=(sem_t*)(&semtable[i]);
 45         //printk("find previous name!\n");
 46     }
 47     else
 48     {
 49         i=0;
 50         for(i=0;i<name_len;i++)
 51         {
 52             semtable[cnt].name[i]=kernelname[i];
 53         }
 54         semtable[cnt].value = value;
 55         p=(sem_t*)(&semtable[cnt]);
 56          //printk("creat name!\n");
 57         cnt++;
 58      }
 59     return p;
 60 }
 61 
 62 
 63 int sys_sem_wait(sem_t *sem)
 64 {
 65     cli();
 66     while( sem->value <= 0 )        //
 67         sleep_on(&(sem->queue));    //这两条语句顺序不能颠倒,很重要,是关于互斥信号量能不
 68     sem->value--;               //能正确工作的!!!
 69     sti();
 70     return 0;
 71 }
 72 int sys_sem_post(sem_t *sem)
 73 {
 74     cli();
 75     sem->value++;
 76     if( (sem->value) <= 1)
 77         wake_up(&(sem->queue));
 78     sti();
 79     return 0;
 80 }
 81 
 82 int sys_sem_unlink(const char *name)
 83 {
 84     char kernelname[100];   /* 应该足够大了 */
 85     int isExist = 0;
 86     int i=0;
 87     int name_cnt=0;
 88     while( get_fs_byte(name+name_cnt) != '\0')
 89             name_cnt++;
 90     if(name_cnt>SEM_NAME_LEN)
 91             return NULL;
 92     for(i=0;i<name_cnt;i++)
 93             kernelname[i]=get_fs_byte(name+i);
 94     int name_len = strlen(name);
 95     int sem_name_len =0;
 96     for(i=0;i<cnt;i++)
 97     {
 98         sem_name_len = strlen(semtable[i].name);
 99         if(sem_name_len == name_len)
100         {
101                 if( !strcmp(kernelname,semtable[i].name))
102                 {
103                         isExist = 1;
104                         break;
105                 }
106         }
107     }
108     if(isExist == 1)
109     {
110         int tmp=0;
111         for(tmp=i;tmp<=cnt;tmp++)
112         {
113             semtable[tmp]=semtable[tmp+1];
114         }
115         cnt = cnt-1;
116         return 0;
117     }
118     else
119         return -1;
120 }

 

4. 实现信号量的系统调用

  1. 应用程序包含的宏定义和头文件
    由于系统调用是借助内嵌汇编_syscall实现的,而_syscall的内嵌汇编实现是在linux-0.11/include/unistd.h中,所以必须包含#include <unistd.h>这个头文件,另外由于_syscall的内嵌汇编实现是包含在一个条件编译里面,所以必须包含这样一个宏定义#define __LIBRARY__

  2. 修改unistd.h
    添加我们新增的系统调用的编号。
    添加的代码如下:

    1 #define __NR_sem_open   72  /* !!! */
    2 #define __NR_sem_wait   73
    3 #define __NR_sem_post   74
    4 #define __NR_sem_unlink 75

     

  3. 修改system_call.s
    由于新增了4个系统调用,所以需要修改总的系统调用的和值。
    修改代码如下:

    1 nr_system_calls = 76    /* !!! */

     

  4. 修改sys.h
    要在linux-0.11/include/linux/sys.h中,声明这4个新增的函数。
    修改代码如下:

     1 extern int sys_sem_open();
     2 extern int sys_sem_wait();
     3 extern int sys_sem_post();
     4 extern int sys_sem_unlink();
     5 
     6 fn_ptr sys_call_table[] = { sys_setup, sys_exit, sys_fork, sys_read,
     7 sys_write, sys_open, sys_close, sys_waitpid, sys_creat, sys_link,
     8 sys_unlink, sys_execve, sys_chdir, sys_time, sys_mknod, sys_chmod,
     9 sys_chown, sys_break, sys_stat, sys_lseek, sys_getpid, sys_mount,
    10 sys_umount, sys_setuid, sys_getuid, sys_stime, sys_ptrace,  sys_alarm,
    11 sys_fstat, sys_pause, sys_utime, sys_stty, sys_gtty, sys_access,
    12 sys_nice, sys_ftime, sys_sync, sys_kill, sys_rename, sys_mkdir,
    13 sys_rmdir, sys_dup, sys_pipe, sys_times, sys_prof, sys_brk,     sys_setgid,
    14 sys_getgid, sys_signal, sys_geteuid, sys_getegid, sys_acct,     sys_phys,
    15 sys_lock, sys_ioctl, sys_fcntl, sys_mpx, sys_setpgid, sys_ulimit,
    16 sys_uname, sys_umask, sys_chroot, sys_ustat, sys_dup2, sys_getppid,
    17 sys_getpgrp, sys_setsid, sys_sigaction, sys_sgetmask, sys_ssetmask,
    18 sys_setreuid,sys_setregid,sys_sem_open,sys_sem_wait,sys_sem_post,sys_sem_unlink };

     

  5. 修改linux-0.11/kernel目录下的Makefile
    修改代码如下:

    ......
    OBJS  = sched.o system_call.o traps.o asm.o fork.o \
    panic.o printk.o vsprintf.o sys.o exit.o \
    signal.o mktime.o sem.o
    ......
    
    ### Dependencies:
    
    sem.s sem.o: sem.c ../include/linux/sem.h ../include/linux/kernel.h \
    ../include/unistd.h
    ......

     

  6. 在0.11环境下的/usr/include目录下,将修改过的unistd.h文件拷贝覆盖那里原有的unistd.h文件。

5. 测试用的应用程序的实现

  1. 基本要求

    1. 建立一个生产者进程,N个消费者进程( N>1 )
    2. 用文件建立一个共享缓冲区
    3. 生产者进程依次向缓冲区写入整数0,1,2,…,M,M>=500
    4. 消费者进程从缓冲区读数,每次读一个,并将读出的数字从缓冲区删除,然后将本进程ID和+ 数字输出到标准输出
    5. 缓冲区同时最多只能保存10个数
      一种可能的输出效果是:
      10: 0
  2. 文件IO函数

    由于要用文件建立一个共享缓冲区,同时生产者要往文件中写数,消费者要从文件中读数,所以要用到open()、read()、write()、lseek()、close()这些文件IO系统调用。
    应用程序实现的难点在于,消费者进程每次读一个数,要将读出的数字从缓冲区删除,这几个文件IO系统调用函数中,并没有可以删除一个数字的函数。解决办法是,当消费者进程要从缓冲区读数时,首先调用lseek()系统调用获取到目前文件指针的位置,保存生产者目前写文件的位置。由于被消费者进程读过的数都被删除了,所以同时最多只能保存10个数的缓冲区已有的数,一定是消费者进程未读的,也就是说每次消费者要从缓冲区读数时,要读的数一定是缓冲区的第一个数。这样,让消费者进程每次都从缓冲区读10个数出来,取读出的10个数中的第一个数送标准输出显示,再将后面的9个数再次写入到缓冲区中,这样,就可以做到删除读出的那个数。最后,再调用lseek()系统调用将文件指针定位到之前保存的文件指针减1的位置,这样,生产者进程再次写缓冲区时,也能正确定位删除了一个数字的缓冲区的写位置。

  3. 终端也是临界资源

    用printf()向终端输出信息是很自然的事情,但当多个进程同时输出时,终端也成为了临界资源,需要做好互斥保护,否则输出的信息可能错乱。
    另外,printf()之后,信息只是保存在输出缓冲区内,还没有真正送到终端上,这也可能造成输出信息时序不一致。用fflush(stdout)可以确保数据送到终端。

  4. 应用程序的实现代码如下:

  1 #define __LIBRARY__
  2 #include <unistd.h>
  3 
  4 #include <stdio.h>
  5 #include <linux/sem.h>
  6 #include <sys/types.h>
  7 #include <sys/stat.h>
  8 #include <fcntl.h>
  9 
 10 
 11 _syscall2(int,sem_open,const char*,name,unsigned int,vaule)
 12 _syscall1(int,sem_wait,sem_t *,sem)
 13 _syscall1(int,sem_post,sem_t *,sem)
 14 _syscall1(int,sem_unlink,const char *,name)
 15 
 16 #define BUFFER_LEN 10
 17 #define M 60
 18 #define CONSUMER1   20
 19 #define CONSUMER2   20
 20 #define CONSUMER3   20
 21 
 22 /*
 23  * producer---father process
 24  * consumer1---son1 process
 25  * consumer2---son2 processs
 26  * consumer3---son3 process
 27  */
 28 
 29 int main(void)
 30 {
 31     pid_t father,producer,consumer1,consumer2,consumer3,tmp1,tmp2,tmp3;
 32     sem_t *p_empty_buf;
 33     sem_t *p_full_buf;
 34     sem_t *p_mutex;
 35     int fd;
 36     int data[10];
 37     int pos=0;
 38     int num=0;
 39     int a,b,c;
 40     int i;
 41     p_empty_buf=(sem_t *)sem_open("Empty",BUFFER_LEN);
 42     p_full_buf=(sem_t *)sem_open("Full",0);
 43     p_mutex=(sem_t *)sem_open("Mutex",1);
 44 
 45     if( (fd=open("./buffer.txt",O_RDWR|O_CREAT|O_TRUNC,0644)) <0 ){
 46         printf("open error\n");
 47         exit(-1);
 48     }
 49     else{
 50         printf("open success\n");
 51     }
 52     tmp1=fork();
 53     if(tmp1==0)         /* son1---consumer1 */
 54     {
 55         consumer1=getpid();
 56         printf("consumer1 is runing!\n");
 57         for(a=0;a<CONSUMER1;a++)
 58         {
 59             sem_wait(p_full_buf);
 60             sem_wait(p_mutex);
 61             if( (pos=lseek(fd,0,SEEK_CUR)) == -1){
 62                 printf("seek pos error\n");
 63             }
 64             if( (num = lseek(fd,0,SEEK_SET)) == -1){
 65                 printf("lseek error\n");
 66             }
 67             if( (num=read(fd,data,sizeof(int)*10)) == -1){
 68                 printf("read error\n");
 69             }
 70             else{
 71                 printf("%d: %d\n",consumer1,data[0]);
 72             }
 73             fflush(stdout);
 74             if( (num = lseek(fd,0,SEEK_SET))== -1){
 75                 printf("lseek error\n");
 76             }
 77             if( (num = write(fd,&data[1],sizeof(int)*9)) == -1){
 78                 printf("read and write error\n");
 79             }
 80             if( (num = lseek(fd,pos-sizeof(int),SEEK_SET))== -1){
 81                 printf("lseek error\n");
 82             }
 83             sem_post(p_mutex);
 84             sem_post(p_empty_buf);
 85         }
 86         printf("Son1 is finished!\n");
 87 
 88     }
 89     else if(tmp1>0)
 90     {
 91         tmp2 = fork();
 92         if(tmp2==0)
 93         {
 94             consumer2=getpid();
 95             printf("consumer2 is runing!\n");
 96             for(b=0;b<CONSUMER2;b++)
 97             {
 98                 sem_wait(p_full_buf);
 99                 sem_wait(p_mutex);
100                 if( (pos=lseek(fd,0,SEEK_CUR)) == -1){
101                     printf("seek pos error\n");
102                 }
103                 if( (num = lseek(fd,0,SEEK_SET)) == -1){
104                     printf("lseek error\n");
105                 }
106                 if( (num=read(fd,data,sizeof(int)*10)) == -1){
107                     printf("read error\n");
108                 }
109                 else{
110                     printf("%d: %d\n",consumer2,data[0]);
111                 }
112                 fflush(stdout);
113                 if( (num = lseek(fd,0,SEEK_SET))== -1){
114                     printf("lseek error\n");
115                 }
116                 if( (num = write(fd,&data[1],sizeof(int)*9)) == -1){
117                     printf("read and write error\n");
118                 }
119                 if( (num = lseek(fd,pos-sizeof(int),SEEK_SET))== -1){
120                     printf("lseek error\n");
121                 }
122                 sem_post(p_mutex);
123                 sem_post(p_empty_buf);
124             }
125             printf("Son2 is finished!\n");
126         }
127         else if(tmp2>0)
128         {
129             tmp3 =fork();
130             if(tmp3 == 0)
131             {
132                 consumer3 = getpid();
133                 printf("consumer3 is runing!\n");
134                 for(c=0;c<CONSUMER3;c++)
135                 {
136                     sem_wait(p_full_buf);
137                     sem_wait(p_mutex);
138                     if( (pos=lseek(fd,0,SEEK_CUR)) == -1){
139                         printf("seek pos error\n");
140                     }
141                     if( (num = lseek(fd,0,SEEK_SET)) == -1){
142                         printf("lseek error\n");
143                     }
144                     if( (num=read(fd,data,sizeof(int)*10)) == -1){
145                         printf("read error\n");
146                     }
147                     else{
148                         printf("%d: %d\n",consumer3,data[0]);
149                     }
150                     fflush(stdout);
151                     if( (num = lseek(fd,0,SEEK_SET))== -1){
152                         printf("lseek error\n");
153                     }
154                     if( (num = write(fd,&data[1],sizeof(int)*9)) == -1){
155                         printf("read and write error\n");
156                     }
157                     if( (num = lseek(fd,pos-sizeof(int),SEEK_SET))== -1){
158                         printf("lseek error\n");
159                     }
160                     sem_post(p_mutex);
161                     sem_post(p_empty_buf);
162                 }
163                 printf("Son3 is finished!\n");
164             }
165             else if(tmp3>0)
166             {
167                 producer=getpid();
168                 printf("producer is runing!\n");    
169                 for(i=0;i<M;i++)
170                 {
171                     sem_wait(p_empty_buf);  /* P(empty) */
172                     sem_wait(p_mutex);  /* P(mutex) */
173                     if( (num=write(fd,&i,sizeof(int))) == -1){
174                         printf("write error\n");
175                     }
176                     /*else{
177                         printf("write in buffer %d\n",i);
178                     }*/
179                     sem_post(p_mutex);  /* V(mutex) */
180                     sem_post(p_full_buf);   /* V(full) */
181                 }
182                 wait((int *)NULL);
183                 wait((int *)NULL);
184                 wait((int *)NULL);
185                 close(fd);
186                 sem_unlink("Empty");
187                 sem_unlink("Full");
188                 sem_unlink("Mutex");
189                 printf("The father is finished\n");
190             }   
191             else
192                 printf("Creat son3 failed\n");
193         }
194         else
195             printf("Creat son2 failed\n");
196     }   
197     else
198         printf("Creat son1 failed\n");
199     return 0;
200 }