| /* |
| * Provide an simpler and easier to understand interface to the System V |
| * semaphore system calls. There are 7 routines available to the user: |
| * |
| * id = sem_create(key, initval); # create with initial value or open |
| * id = sem_open(key); # open (must already exist) |
| * sem_wait(id); # wait = P = down by 1 |
| * sem_signal(id); # signal = V = up by 1 |
| * sem_op(id, amount); # wait if (amount < 0) |
| * # signal if (amount > 0) |
| * sem_close(id); # close |
| * sem_rm(id); # remove (delete) |
| * |
| * We create and use a 3-member set for the requested semaphore. |
| * The first member, [0], is the actual semaphore value, and the second |
| * member, [1], is a counter used to know when all processes have finished |
| * with the semaphore. The counter is initialized to a large number, |
| * decremented on every create or open and incremented on every close. |
| * This way we can use the "adjust" feature provided by System V so that |
| * any process that exit's without calling sem_close() is accounted |
| * for. It doesn't help us if the last process does this (as we have |
| * no way of getting control to remove the semaphore) but it will |
| * work if any process other than the last does an exit (intentional |
| * or unintentional). |
| * The third member, [2], of the semaphore set is used as a lock variable |
| * to avoid any race conditions in the sem_create() and sem_close() |
| * functions. |
| */ |
| |
| #ifndef BOOST_INTERPROCESS_SYNC_XSI_ADVANCED_XSI_SEMAPHORE_HPP |
| #define BOOST_INTERPROCESS_SYNC_XSI_ADVANCED_XSI_SEMAPHORE_HPP |
| |
| #include <sys/ipc.h> |
| #include <sys/sem.h> |
| #include <errno.h> |
| |
| namespace boost { |
| namespace interprocess { |
| namespace xsi { |
| |
| // Create a semaphore with a specified initial value. |
| // If the semaphore already exists, we don't initialize it (of course). |
| // We return the semaphore ID if all OK, else -1. |
| |
| inline bool advanced_sem_open_or_create(::key_t key, int initval, int &semid, int perm) |
| { |
| semid = -1; |
| int id, semval; |
| union semun { |
| int val; |
| ::semid_ds *buf; |
| ushort *array; |
| } semctl_arg; |
| |
| if (key == IPC_PRIVATE) |
| return false; //not intended for private semaphores |
| |
| else if (key == (::key_t) -1) |
| return false; //probably an ftok() error by caller |
| |
| again: |
| if ((id = ::semget(key, 3, (perm & 0x01FF) | IPC_CREAT)) < 0) |
| return false; //permission problem or tables full |
| |
| // When the semaphore is created, we know that the value of all |
| // 3 members is 0. |
| // Get a lock on the semaphore by waiting for [2] to equal 0, |
| // then increment it. |
| // |
| // There is a race condition here. There is a possibility that |
| // between the semget() above and the ::semop() below, another |
| // process can call our sem_close() function which can remove |
| // the semaphore if that process is the last one using it. |
| // Therefore, we handle the error condition of an invalid |
| // semaphore ID specially below, and if it does happen, we just |
| // go back and create it again. |
| struct sembuf op_lock[2] = { |
| {2, 0, 0}, // wait for [2] (lock) to equal 0 |
| {2, 1, SEM_UNDO} // then increment [2] to 1 - this locks it |
| // UNDO to release the lock if processes exits |
| // before explicitly unlocking |
| }; |
| |
| if (::semop(id, &op_lock[0], 2) < 0) { |
| if (errno == EINVAL) |
| goto again; |
| } |
| |
| // Get the value of the process counter. If it equals 0, |
| // then no one has initialized the semaphore yet. |
| if ((semval = ::semctl(id, 1, GETVAL, 0)) < 0) |
| return false; |
| |
| if (semval == 0) { |
| // We could initialize by doing a SETALL, but that |
| // would clear the adjust value that we set when we |
| // locked the semaphore above. Instead, we'll do 2 |
| // system calls to initialize [0] and [1]. |
| semctl_arg.val = initval; |
| if (::semctl(id, 0, SETVAL, semctl_arg) < 0) |
| return false; |
| |
| semctl_arg.val = 1; |
| if (::semctl(id, 1, SETVAL, semctl_arg) < 0) |
| return false; |
| } |
| |
| // Decrement the process counter and then release the lock. |
| struct sembuf op_unlock[1] = { |
| 2, -1, 0/*SEM_UNDO*/ // decrement [2] (lock) back to 0 |
| }; |
| |
| if (::semop(id, &op_unlock[0], 1) < 0) |
| return false; |
| |
| semid = id; |
| return true; |
| } |
| |
| // Open a semaphore that must already exist. |
| // This function should be used, instead of sem_create(), if the caller |
| // knows that the semaphore must already exist. For example a client |
| // from a client-server pair would use this, if its the server's |
| // responsibility to create the semaphore. |
| // We return the semaphore ID if all OK, else -1. |
| /* |
| inline bool advanced_sem_open(key_t key, int &semid) |
| { |
| semid = -1; |
| if (key == IPC_PRIVATE) |
| return false; // not intended for private semaphores |
| |
| else if (key == (::key_t) -1) |
| return false; // probably an ftok() error by caller |
| |
| if ((semid = ::semget(key, 3, 0)) < 0) |
| return false; // doesn't exist, or tables full |
| |
| // Decrement the process counter. We don't need a lock |
| struct sembuf op_open[1] = { |
| 1, -1, SEM_UNDO // decrement [1] (proc counter) with undo on exit |
| }; |
| |
| if (::semop(id, &op_open[0], 1) < 0) |
| return false; |
| |
| return true; |
| } |
| */ |
| /**************************************************************************** |
| * Remove a semaphore. |
| * This call is intended to be called by a server, for example, |
| * when it is being shut down, as we do an IPC_RMID on the semaphore, |
| * regardless whether other processes may be using it or not. |
| * Most other processes should use sem_close() below. |
| */ |
| |
| inline bool advanced_sem_rm(int id) |
| { |
| if (::semctl(id, 0, IPC_RMID, 0) < 0) |
| return false; |
| return true; |
| } |
| |
| |
| /**************************************************************************** |
| * General semaphore operation. Increment or decrement by a user-specified |
| * amount (positive or negative; amount can't be zero). |
| */ |
| |
| inline bool advanced_sem_op(int id, int value, bool undo = true) |
| { |
| ::sembuf op_op[1] = { |
| 0, 99, 0 // decrement or increment [0] with undo on exit |
| // the 99 is set to the actual amount to add |
| // or subtract (positive or negative) |
| }; |
| if(undo){ |
| op_op[0].sem_flg = SEM_UNDO; |
| } |
| if ((op_op[0].sem_op = value) == 0) |
| return false; |
| |
| if (::semop(id, &op_op[0], 1) < 0) |
| return false; |
| return true; |
| } |
| |
| } //namespace xsi { |
| } //namespace interprocess { |
| } //namespace boost { |
| |
| #endif //BOOST_INTERPROCESS_SYNC_XSI_ADVANCED_XSI_SEMAPHORE_HPP |