Back to Operating Systems Home Page

Semaphores in System V UNIX

The System V specification of the UNIX operating system introduces semaphores among the other facilities for Inter-Process Communication (IPC). This implementation is a (rather messy) generalization of the above described scheme. Three features contribute to this unnecessary complication:

• A semaphore counter is not just a single value. It's rather a set of one or more values, and the exact number of values is specified upon semaphore creation.
• The creation of a semaphore is independent of its initialization. This is a fatal flaw, since we cannot atomically create a new semaphore set and initialize all the values in the set: a competing process may sneak in and access the semaphore after creation but before initialization, thus finding semagarbage.
• A semaphore must be explicitly destroyed when the shared resource is no longer necessary, since the systemwide total number of semaphore sets is limited.

Moreover, semaphore counters are always nonnegative, a zero causing the waiting process to be put to sleep

A semaphore is created by the semget(3) system call, whose synopsis is:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key, int nsems, int flag);

This system call returns an integer id for the semaphore (analogous to a file descriptor), or -1 in case of error.

The key argument is analogous to a file name, and is used to identify exclusively a semaphore set (and other IPC objects as well) all over the system, while the semaphore id is - like a file descriptor - known only by one process and by its siblings that inherit it through variables after a fork(). Cooperating processes wishing to access the semaphore set must use the same key, much like a file name is used to store on disk shared data by cooperating processes. A key is implemented as an integer (whose size is specified by the key_t type), and a library function called ftok() is provided for the purpose of generating meaningful keys (see its manpage).

The value of nsems specifies the number of semaphores in newly created semaphore set.

The value of flag is a bit mask obtained ORing constants that specify:

• The access permissions for the semaphore set, in the same way as for a file;
• The creation mode, which can be:
  • IPC_PRIVATE: if this is specified, the value of the key is ignored, and a private semaphore set is created, that can be used by a process and its siblings through semaphore id inheritance. Since there's no key, other unrelated processes have no way to access the semaphore set.
  • IPC_CREAT: if this is specified, and a semaphore with the given key does not exist, it is created, otherwise the call returns with -1, setting the appropriate errno value.

For example, to create one semaphore with key 333, readable an writable by an user and his group, you'd use a code fragment like:

int sid;
...
sid=semget((key_t)333, 1, SEM_R|SEM_W|(SEM_R>>3)|(SEM_W>>3)|IPC_CREAT);
if (sid<0) 
{
    perror(``Semaphore 333'');
    exit(1);
}
...

Once a semaphore has been created, a process accesses it either directly via its id, if its a private semaphore and the id has been inherited from a creating ancestor, or by calling semget() to get its id in exchange for the right key, much like opening an already existing file. In this case the IPC_PRIVATE and IPC_CREAT bits are not set.

Semaphore initialization and flagging are performed respectively via the semctl() and semop() system calls. Refer to their manpages for details on their usage

Back to Operating Systems Home Page