diff options
Diffstat (limited to 'boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp')
| -rw-r--r-- | boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp | 193 |
1 files changed, 193 insertions, 0 deletions
diff --git a/boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp b/boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp new file mode 100644 index 0000000000..a0c3a91adf --- /dev/null +++ b/boost/interprocess/sync/xsi/advanced_xsi_semaphore.hpp @@ -0,0 +1,193 @@ +/* + * 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 |