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