parameter of semctl.

The sem_op element operations are values specifying the amount by which the semaphore value is to be changed.

• If sem_op is an integer greater than zero, semop adds the value to the corresponding semaphore element value and awakens all processes that are waiting for the element to increase.

• If sem_op is 0 and the semaphore element value is not 0, semop blocks the calling process (waiting for 0) and increments the count of processes waiting for a zero value of that element.

• If sem_op is a negative number, semop adds the sem_op value to the corresponding semaphore element value provided that the result would not be negative. If the operation would make the element value negative, semop blocks the process on the event that the semaphore element value increases. If the resulting value is 0, semop wakes the processes waiting for 0.

The description of semop assumes that sem_flg is 0 for all the element operations. If sem_flg & IPC_NOWAIT is true, the element operation never causes the semop call to block. If a semop returns because it would have blocked on that element operation, it returns “1 with errno set to EAGAIN . If sem_flg & SEM_UNDO is true, the function also modifies the semaphore adjustment value for the process. This adjustment value allows the process to undo its effect on the semaphore when it exits. You should read the man page carefully regarding the interaction of semop with various settings of the flags.

Example 15.7

What is wrong with the following code to declare myopbuf and initialize it so that sem_num is 1, sem_op is 1, and sem_flg is 0?

struct sembuf myopbuf = {1, -1, 0};

Answer:

The direct assignment assumes that the members of struct sembuf appear in the order sem_num, sem_op and sem_flg . You may see this type of initialization in legacy code and it may work on your system, but try to avoid it. Although the POSIX:XSI Extension specifies that the struct sembuf structure has sem_num, sem_op and sem_flg members, the standard does not specify the order in which these members appear in the definition nor does the standard restrict struct sembuf to contain only these members.

Example 15.8 setsembuf.c

The function setsembuf initializes the struct sembuf structure members sem_num, sem_op and sem_flg in an implementation-independent manner.

#include <sys/sem.h>



void setsembuf(struct sembuf *s, int num, int op, int flg) {

   s->sem_num = (short)num;

   s->sem_op = (short)op;

   s->sem_flg = (short)flg;

   return;

}

Example 15.9

The following code segment atomically increments element zero of semid by 1 and element one of semid by 2, using setsembuf of Example 15.8.

struct sembuf myop[2];



setsembuf(myop, 0, 1, 0);

setsembuf(myop + 1, 1, 2, 0);

if (semop(semid, myop, 2) == -1)

   perror("Failed to perform semaphore operation");

Example 15.10

Suppose a two-element semaphore set, S , represents a tape drive system in which Process 1 uses Tape A, Process 2 uses Tape A and B, and Process 3 uses Tape B. The following pseudocode segment defines semaphore operations that allow the processes to access one or both tape drives in a mutually exclusive manner.

struct sembuf get_tapes[2];

struct sembuf release_tapes[2];



setsembuf(&(get_tapes[0]), 0, -1, 0);

setsembuf(&(get_tapes[1]), 1, -1, 0);

setsembuf(&(release_tapes[0]), 0, 1, 0);

setsembuf(&(release_tapes[1]), 1, 1, 0);



Process 1:     semop(S, get_tapes, 1);

           <use tape A>

           semop(S, release_tapes, 1);



Process 2: semop(S, get_tapes, 2);

           <use tapes A and B>

           semop(S, release_tapes, 2);



Process 3: semop(S, get_tapes + 1, 1);

           <use tape B>

           semop(S, release_tapes + 1, 1);

S[0] represents tape A, and S[1] represents tape B. We assume that both elements of S have been initialized to 1.

If semop is interrupted by a signal, it returns “1 and sets errno to EINTR . Program 15.2 shows a function that restarts semop if it is interrupted by a signal.

Program 15.2 r_semop.c

A function that restarts semop after a signal .

#include <errno.h>

#include <sys/sem.h>



int r_semop(int semid, struct sembuf *sops, int nsops) {

   while (semop(semid, sops, nsops) == -1)

      if (errno != EINTR)

         return -1;

   return 0;

}

Program 15.3 modifies Program 14.1 to use POSIX:XSI semaphore sets to protect a critical section. Program 15.3 calls setsembuf (Example 15.8) and removesem (Example 15.6). It restarts semop operations if interrupted by a signal, even though the program does not catch any signals. You should get into the habit of restarting functions that can set errno equal to EINTR .

Once the semaphore of Program 15.3 is created, it persists until it is removed. If a child process generates an error, it just exits. If the parent generates an error, it falls through to the wait call and then removes the semaphore. A program that creates a semaphore for its own use should be sure to remove the semaphore before the program terminates. Be careful to remove the semaphore exactly once.

Program 15.3 chainsemset.c

A modification of Program 14.1 that uses semaphore sets to protect the critical section .

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/sem.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include "restart.h"

#define BUFSIZE 1024

#define PERMS (S_IRUSR  S_IWUSR)



int initelement(int semid, int semnum, int semvalue);

int r_semop(int semid, struct sembuf *sops, int nsops);

int removesem(int semid);

void setsembuf(struct sembuf *s, int num, int op, int flg);



void printerror(char *msg, int error) {

   fprintf(stderr, "[%ld] %s: %s\n", (long)getpid(), msg, strerror(error));

}



int main (int argc, char *argv[]) {

   char buffer[MAX_CANON];

   char *c;

   pid_t childpid;

   int delay;

   int error;

   int i, j, n;

   int semid;

   struct sembuf semsignal[1];

   struct sembuf semwait[1];



   if ((argc != 3)  ((n = atoi(argv[1])) <= 0) 

        ((delay = atoi(argv[2])) < 0))  {

      fprintf (stderr, "Usage: %s processes delay\n", argv[0]);

      return 1;

   }

                        /* create a semaphore containing a single element */

   if ((semid = semget(IPC_PRIVATE, 1, PERMS)) == -1) {

      perror("Failed to create a private semaphore");

      return 1;

   }

   setsembuf(semwait, 0, -1, 0);                   /* decrement element 0 */

   setsembuf(semsignal, 0, 1, 0);                  /* increment element 0 */

   if (initelement(semid, 0, 1) == -1) {

      perror("Failed to initialize semaphore element to 1");

      if (removesem(semid) == -1)

         perror("Failed to remove failed semaphore");

      return 1;

   }

   for (i = 1; i < n; i++)

      if (childpid = fork())

         break;

   snprintf(buffer, BUFSIZE, "i:%d PID:%ld  parent PID:%ld  child PID:%ld\n",

           i, (long)getpid(), (long)getppid(), (long)childpid);

   c = buffer;

   /******************** entry section ************************************/

   if (((error = r_semop(semid, semwait, 1)) == -1) && (i > 1)) {

      printerror("Child failed to lock semid", error);

      return 1;

   }

   else if (!error) {

      /***************** start of critical section ************************/

      while (*c != '
#include <errno.h> #include <limits.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/sem.h> #include <sys/stat.h> #include <sys/wait.h> #include "restart.h" #define BUFSIZE 1024 #define PERMS (S_IRUSR  S_IWUSR) int initelement(int semid, int semnum, int semvalue); int r_semop(int semid, struct sembuf *sops, int nsops); int removesem(int semid); void setsembuf(struct sembuf *s, int num, int op, int flg); void

printerror

(char *msg, int error) { fprintf(stderr, "[%ld] %s: %s\n", (long)getpid(), msg, strerror(error)); } int main (int argc, char *argv[]) { char buffer[MAX_CANON]; char *c; pid_t childpid; int delay; int error; int i, j, n; int semid; struct sembuf semsignal[1]; struct sembuf semwait[1]; if ((argc != 3)  ((n = atoi(argv[1])) <= 0)  ((delay = atoi(argv[2])) < 0)) { fprintf (stderr, "Usage: %s processes delay\n", argv[0]); return 1; } /* create a semaphore containing a single element */ if ((semid = semget(IPC_PRIVATE, 1, PERMS)) == -1) { perror("Failed to create a private semaphore"); return 1; } setsembuf(semwait, 0, -1, 0); /* decrement element 0 */ setsembuf(semsignal, 0, 1, 0); /* increment element 0 */ if (initelement(semid, 0, 1) == -1) { perror("Failed to initialize semaphore element to 1"); if (removesem(semid) == -1) perror("Failed to remove failed semaphore"); return 1; } for (i = 1; i < n; i++) if (childpid = fork()) break;

snprintf

(buffer, BUFSIZE, "i:%d PID:%ld parent PID:%ld child PID:%ld\n", i, (long)getpid(), (long)getppid(), (long)childpid); c = buffer; /******************** entry section ************************************/ if (((error = r_semop(semid, semwait, 1)) == -1) && (i > 1)) { printerror("Child failed to lock semid", error); return 1; } else if (!error) { /***************** start of critical section ************************/ while (*c != '\0') {

fputc

(*c, stderr); c++; for (j = 0; j < delay; j++) ; } /***************** exit section ************************************/ if ((error = r_semop(semid, semsignal, 1)) == -1) printerror("Failed to unlock semid", error); } /******************** remainder section *******************************/ if ((r_wait(NULL) == -1) && (errno != ECHILD)) printerror("Failed to wait", errno); if ((i == 1) && ((error = removesem(semid)) == -1)) { printerror("Failed to clean up", error); return 1; } return 0; }

') {

         fputc(*c, stderr);

         c++;

         for (j = 0; j < delay; j++) ;

       }

      /***************** exit section ************************************/

      if ((error = r_semop(semid, semsignal, 1)) == -1)

         printerror("Failed to unlock semid", error);

   }

   /******************** remainder section *******************************/

   if ((r_wait(NULL) == -1) && (errno != ECHILD))

      printerror("Failed to wait", errno);

   if ((i == 1) && ((error = removesem(semid)) == -1)) {

      printerror("Failed to clean up", error);

      return 1;

   }

   return 0;

}

A program calls semget to create or access a semaphore set and calls semctl to initialize it. If one process creates and initializes a semaphore and another process calls semop between the creation and initialization, the results of the execution are unpredictable. This unpredictability is an example of a race condition because the occurrence of the error depends on the precise timing between instructions in different processes. Program 15.3 does not have a race condition because the original parent creates and initializes the semaphore before doing a fork. The program avoids a race condition because only the original process can access the semaphore at the time of creation. One of the major problems with semaphore sets is that the creation and initialization are separate operations and therefore not atomic. Recall that POSIX:SEM named and unnamed semaphores are initialized at the time of creation and do not have this problem.

Program 15.4 can be used to create or access a semaphore set containing a single semaphore element. It takes three parameters, a semaphore key, an initial value and a pointer to a variable of type sig_atomic_t that is initialized to 0 and shared among all processes and threads that call this function. If this function is used among threads of a single process, the sig_atomic_t variable could be defined outside a block and statically initialized. Using initsemset among processes requires shared memory. We use Program 15.4 later in the chapter to protect a shared memory segment. The busy-waiting used in initsemset is not as inefficient as it may seem, since it is only used when the thread that creates the semaphore set loses the CPU before it can initialize it.

Program 15.4 initsemset.c

A function that creates and initializes a semaphore set containing a single semaphore .

#include <errno.h>

#include <signal.h>

#include <stdio.h>

#include <time.h>

#include <sys/sem.h>

#include <sys/stat.h>

#define PERMS (S_IRUSR  S_IWUSR)

#define TEN_MILLION 10000000L

int initelement(int semid, int semnum, int semvalue);



int initsemset(key_t mykey, int value, sig_atomic_t *readyp) {

   int semid;

   struct timespec sleeptime;



   sleeptime.tv_sec = 0;

   sleeptime.tv_nsec = TEN_MILLION;

   semid = semget(mykey, 2, PERMS  IPC_CREAT  IPC_EXCL);

   if ((semid == -1) && (errno != EEXIST))         /* real error, so return */

      return -1;

   if (semid >= 0) {          /* we created the semaphore, so initialize it */

      if (initelement(semid, 0, value) == -1)

         return -1;

      *readyp = 1;

      return semid;

   }

   if ((semid = semget(mykey, 2, PERMS)) == -1)           /* just access it */

      return -1;

   while (*readyp == 0)                            /* wait for initialization */

      nanosleep(&sleeptime, NULL);

   return semid;

}