#include <sys/sem.h>
int semop(int semid, struct sembuf *sops,
size_t nsops);
The semop() function operates on XSI semaphores (see the Base Definitions volume of IEEE Std 1003.1-2001, Section 4.15, Semaphore). It is unspecified whether this function interoperates with the realtime interprocess communication facilities defined in Realtime .
The semop() function shall perform atomically a user-defined array of semaphore operations on the set of semaphores associated with the semaphore identifier specified by the argument semid.
The argument sops is a pointer to a user-defined array of semaphore operation structures. The implementation shall not modify elements of this array unless the application uses implementation-defined extensions.
The argument nsops is the number of such structures in the array.
Each structure, sembuf, includes the following members:
| Member Type | Member Name | Description | |||
| short | sem_num | Semaphore number. | |||
| short | sem_op | Semaphore operation. | |||
| short | sem_flg | Operation flags. |
Each semaphore operation specified by sem_op is performed on the corresponding semaphore specified by semid and sem_num.
The variable sem_op specifies one of three semaphore operations:
Upon successful completion, the value of sempid for each semaphore specified in the array pointed to by sops shall be set equal to the process ID of the calling process.
Upon successful completion, semop() shall return 0; otherwise, it shall return -1 and set errno to indicate the error.
The semop() function shall fail if:
The following sections are informative.
The following example sets the values of the two semaphores associated with the semid identifier to the values contained in the sb array.
#include <sys/sem.h> ... int semid; struct sembuf sb[2]; int nsops = 2; int result; /* Adjust value of semaphore in the semaphore array semid. */ sb[0].sem_num = 0; sb[0].sem_op = -1; sb[0].sem_flg = SEM_UNDO | IPC_NOWAIT; sb[1].sem_num = 1; sb[1].sem_op = 1; sb[1].sem_flg = 0; result = semop(semid, sb, nsops);
The following example gets a unique semaphore key using the ftok() function, then gets a semaphore ID associated with that key using the semget() function (the first call also tests to make sure the semaphore exists). If the semaphore does not exist, the program creates it, as shown by the second call to semget(). In creating the semaphore for the queuing process, the program attempts to create one semaphore with read/write permission for all. It also uses the IPC_EXCL flag, which forces semget() to fail if the semaphore already exists.
After creating the semaphore, the program uses a call to semop() to initialize it to the values in the sbuf array. The number of processes that can execute concurrently without queuing is initially set to 2. The final call to semget() creates a semaphore identifier that can be used later in the program.
The final call to semop() acquires the semaphore and waits until it is free; the SEM_UNDO option releases the semaphore when the process exits, waiting until there are less than two processes running concurrently.
#include <sys/types.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <pwd.h>
#include <fcntl.h>
#include <limits.h>
...
key_t semkey;
int semid, pfd, fv;
struct sembuf sbuf;
char *lgn;
char filename[PATH_MAX+1];
struct stat outstat;
struct passwd *pw;
...
/* Get unique key for semaphore. */
if ((semkey = ftok("/tmp", 'a')) == (key_t) -1) {
perror("IPC error: ftok"); exit(1);
}
/* Get semaphore ID associated with this key. */
if ((semid = semget(semkey, 0, 0)) == -1) {
/* Semaphore does not exist - Create. */
if ((semid = semget(semkey, 1, IPC_CREAT | IPC_EXCL | S_IRUSR |
S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) != -1)
{
/* Initialize the semaphore. */
sbuf.sem_num = 0;
sbuf.sem_op = 2; /* This is the number of runs without queuing. */
sbuf.sem_flg = 0;
if (semop(semid, &sbuf, 1) == -1) {
perror("IPC error: semop"); exit(1);
}
}
else if (errno == EEXIST) {
if ((semid = semget(semkey, 0, 0)) == -1) {
perror("IPC error 1: semget"); exit(1);
}
}
else {
perror("IPC error 2: semget"); exit(1);
}
}
...
sbuf.sem_num = 0;
sbuf.sem_op = -1;
sbuf.sem_flg = SEM_UNDO;
if (semop(semid, &sbuf, 1) == -1) {
perror("IPC Error: semop"); exit(1);
}
The POSIX Realtime Extension defines alternative interfaces for interprocess communication. Application developers who need to use IPC should design their applications so that modules using the IPC routines described in XSI Interprocess Communication can be easily modified to use the alternative interfaces.
XSI Interprocess Communication , Realtime , exec() , exit() , fork() , semctl() , semget() , sem_close() , sem_destroy() , sem_getvalue() , sem_init() , sem_open() , sem_post() , sem_unlink() , sem_wait() , the Base Definitions volume of IEEE Std 1003.1-2001, <sys/ipc.h>, <sys/sem.h>, <sys/types.h>