ipc/shm_semaph.c

   1 /***************************************************************************
   2  * Copyright 1995, Technion, Israel Institute of Technology
   3  * Electrical Eng, Software Lab.
   4  * Author:    Michael Veksler.
   5  ***************************************************************************
   6  * File:      shm_semaph.c
   7  * Purpose:   Handle semaphores for shared memory operations.
   8  ***************************************************************************
   9  */
  10 #define inline __inline__
  11 #include <assert.h>
  12 #include <unistd.h>
  13 #include <sys/sem.h>
  14 #include <stdio.h>
  15 #include <errno.h>
  16 #include <stddebug.h>
  17 #include <debug.h>
  18 #include "shm_semaph.h"
  19 #define SEM_READ  0
  20 #define SEM_WRITE 1
  21
  22 /* IMPORTANT: Make sure that killed process will not lock everything.
  23  *            If possible, restrict usage of these functions.
  24  */
  25 void shm_read_wait(shm_sem semid)
  26 {
  27   struct sembuf sop[2];
  28   int ret;
  29
  30   dprintf_sem(stddeb,"shm_read_wait(%d)\n",semid);
  31   sop[0].sem_num=SEM_READ;
  32   sop[0].sem_op=1;                 /* add this read instance */
  33   sop[0].sem_flg=SEM_UNDO;         /* undo in case process dies */
  34
  35   sop[1].sem_num=SEM_WRITE;
  36   sop[1].sem_op=0;                 /* wait until no writing instance exists */
  37   sop[1].sem_flg=SEM_UNDO;
  38
  39   do {
  40      ret=semop (semid,sop , 2);
  41   } while (ret<0 && errno==EINTR);  /* interrupted system call? */
  42
  43   if (ret<0)
  44      fprintf(stderr,"failed semaphore lock for read. semid=%d,errno=%d\n",
  45              semid, errno);
  46 }
  47 void shm_write_wait(shm_sem semid)
  48 {
  49   struct sembuf sop[3];
  50   int ret;
  51
  52   dprintf_sem(stddeb,"shm_write_wait(%d)\n",semid);
  53   sop[0].sem_num=SEM_READ;
  54   sop[0].sem_op=0;                 /* wait until no reading instance exist */
  55   sop[0].sem_flg=SEM_UNDO;
  56
  57   sop[1].sem_num=SEM_WRITE;
  58   sop[1].sem_op=1;                 /* writing is in progress - disable read */
  59   sop[1].sem_flg=SEM_UNDO;         /* undo if process dies */
  60
  61   sop[2].sem_num=SEM_READ;
  62   sop[2].sem_op=1;                 /* disable new writes */
  63   sop[2].sem_flg=SEM_UNDO;
  64
  65   do {
  66      ret=semop (semid,sop , 3);
  67   } while (ret<0 && errno==EINTR);  /* interrupted system call? */
  68
  69   if (ret<0)                       /* test for the error */
  70      fprintf(stderr,"failed semaphore lock for write. semid=%d,errno=%d\n",
  71              semid, errno);
  72 }
  73 void shm_write_signal(shm_sem semid)
  74 {
  75   struct sembuf sop[2];
  76   int ret;
  77
  78   dprintf_sem(stddeb,"shm_write_signal(%d)\n",semid);
  79   sop[0].sem_num=SEM_READ;
  80   sop[0].sem_op=-1;
  81   sop[0].sem_flg=IPC_NOWAIT | SEM_UNDO; /* no reason to wait */
  82
  83   sop[1].sem_num=SEM_WRITE;
  84   sop[1].sem_op=-1;
  85   sop[1].sem_flg=IPC_NOWAIT | SEM_UNDO; /* no reason to wait */
  86
  87   do {
  88      ret=semop (semid,sop , 2);
  89   } while (ret<0 && errno==EINTR);  /* interrupted system call? */
  90
  91   if (ret<0)                       /* test for the error */
  92      fprintf(stderr,"failed semaphore unlock for write. semid=%d,errno=%d\n",
  93              semid, errno);
  94 }
  95
  96 void shm_read_signal(shm_sem semid)
  97 {
  98   struct sembuf sop[2];
  99   int ret;
 100
 101   dprintf_sem(stddeb,"shm_read_signal(%d)\n",semid);
 102   sop[0].sem_num=SEM_READ;
 103   sop[0].sem_op=-1;
 104   sop[0].sem_flg=IPC_NOWAIT | SEM_UNDO; /* no reason to wait */
 105
 106   do {
 107      ret=semop (semid,sop , 1);
 108   } while (ret<0 && errno==EINTR);  /* interrupted system call? */
 109
 110   if (ret<0)                       /* test for the error */
 111      fprintf(stderr,"failed semaphore unlock for read. semid=%d,errno=%d\n",
 112              semid, errno);
 113 }
 114
 115 void shm_sem_init(shm_sem *sptr)
 116 {
 117   shm_sem semid;
 118   union semun arg;
 119
 120   semid=semget (IPC_PRIVATE, 2, 0700 | IPC_CREAT);
 121
 122   arg.val=0;
 123   semctl (semid, 0, SETVAL, arg);
 124   semctl (semid, 1, SETVAL, arg);
 125   *sptr=semid;
 126 }
 127
 128 void shm_sem_done(shm_sem *semptr)
 129 {
 130   union semun arg;
 131
 132   semctl (*semptr, 0, IPC_RMID , arg);
 133   semctl (*semptr, 1, IPC_RMID , arg);
 134
 135   *semptr= -1;
 136 }