semop - Perform semaphore operations
#include <sys/sem.h>
int semop(
int semid,
struct sembuf *sops,
size_t nsops );
The following declaration of the nsops parameter does not
conform to current standards and is supported only for
backward compatibility: u_int nsops
Application developers may want to specify #include statements
for <sys/types.h> and <sys/ipc.h> before the one for
<sys/sem.h> if programs are being developed for multiple
platforms. The additional #include statements are not
required on Tru64 UNIX systems or by ISO or XSH specifications,
but may be required on other vendors' systems that
conform to these standards.
Interfaces documented on this reference page conform to
industry standards as follows:
semop(): XSH4.0, XSH4.2, XSH5.0
Refer to the standards(5) reference page for more information
about industry standards and associated tags.
Specifies the ID of the semaphore set. Points to the
user-defined array of sembuf structures that contain the
semaphore operations. The number of sembuf structures in
the array.
The semop() function performs operations on the semaphores
in the specified semaphore set. The semaphore operations
are defined in the sops array. The sops array contains
nsops elements, each of which is represented by a sembuf
structure.
The sembuf structure (from <sys/sem.h>) is shown here:
struct sembuf {
u_short sem_num;
short sem_op;
short sem_flg; };
The fields in the sembuf structure are defined as follows:
Specifies an individual semaphore within the semaphore
set. Specifies the operation to perform on the semaphore.
Specifies various options for the operations. The possible
values are: Instructs the kernel to adjust the process's
adjust-on-exit value for a modified semaphore. When the
process exits, the kernel uses this value to restore the
semaphore to the value it had before any modifications by
the process. This option is used to prevent semaphore
locking by a process that no longer exists. Instructs the
kernel to return an error condition if a requested operation
would cause the process to sleep. If the kernel
returns an error condition, none of the requested
semaphore operations are performed.
The sem_op operation is specified as a negative integer, a
positive integer, or 0 (zero). The effects of these three
values are described below.
If sem_op is a negative integer and the calling process
has modify permission, the semop() function does one of
the following: If the semaphore's current value (in semval)
is equal to or greater than the absolute value of
sem_op, the absolute value of sem_op is subtracted from
semval. If SEM_UNDO is set, the absolute value of sem_op
is added to the calling process' adjust-on-exit value for
the semaphore. If semval is less than the absolute value
of sem_op and IPC_NOWAIT is set, semop() returns immediately.
If semval is less than the absolute value of
sem_op and IPC_NOWAIT is not set, semop() increments the
semaphore's semncnt value and suspends the calling process.
If the process is suspended, it sleeps until one of the
following occurs: The semval value becomes equal to or
greater than the absolute value of sem_op. In this case,
the semaphore's semncnt value is decremented; the absolute
value of sem_op is subtracted from semval; and, if
SEM_UNDO is set, the absolute value of sem_op is added to
the calling process's adjust-on-exit value for the
semaphore. The semaphore set (specified by semid) is
removed from the system. In this case, errno is set equal
to [EIDRM] and a value of -1 is returned to the calling
process. The calling process catches a signal. In this
case, the semaphore's semncnt value is decremented, and
the calling process resumes execution as directed by the
sigaction() function.
If sem_op is a positive integer and the calling process
has modify permission, semop() adds the sem_op value to
the semaphore's current semval value. If SEM_UNDO is set,
the sem_op value is subtracted from the calling process's
adjust-on-exit value for the semaphore.
If sem_op is 0 (zero) and the calling process has read
permission, semop() does one of the following: If semval
is 0, semop() returns immediately. If semval is not equal
to 0 and IPC_NOWAIT is set, semop() returns immediately.
If semval is not equal to 0 and IPC_NOWAIT is not set,
semop() increments the semaphore's semzcnt value and suspends
the calling process.
If the process is suspended, it sleeps until one of the
following occurs: The semval value becomes 0 (zero). In
this case, the semaphore's semncnt value is decremented.
The semaphore set (specified by semid) is removed from the
system. In this case, errno is set equal to [EIDRM] and a
value of -1 is returned to the calling process. The calling
process catches a signal. In this case, the
semaphore's semncnt value is decremented, and the calling
process resumes execution as directed by the sigaction()
function.
The calling process must have read (sense) or write
(alter) permission to the semaphore set for all access
control policies for each specified operation. If any
operation accesses the semaphore set in a way that is not
allowed according to one of the access control policies,
access is denied.
[Tru64 UNIX] Semaphore operations are performed atomically;
that is, either all of the requested operations are
performed, or none are. If the kernel goes to sleep while
doing the operations, it restores all of the semaphores in
the set to their previous values, at the start of the
semop() function.
The librt library contains alternative interfaces for
interprocess communication. The names of these routines
adhere to the format sem_* and their reference pages are
listed in SEE ALSO.
Upon successful completion, the semop() function returns a
value of 0 (zero) and the sempid value for each semaphore
that is operated upon is set to the process ID of the
calling process.
If the semop() function fails, a value of -1 is returned
and errno is set to indicate the error.
The semop() function sets errno to the specified values
for the following conditions: The nsops parameter is
greater than the system-defined maximum. The calling process
does not have the required permission. The process
does not have read or write access permission to the
semaphore set with respect to all access control policies.
Both sem_flg and IPC_NOWAIT are true, but the requested
operation would cause the calling process to be suspended.
[Tru64 UNIX] Indicates that the requested address is in
some way invalid, for example, out of bounds. The sem_num
value is greater than or equal to the number of semaphores
in the set associated with semid. The semaphore ID specified
by the semid parameter has been removed from the system.
The semop() function was interrupted by a signal.
One of the following conditions applies: The semid value
is not a valid semaphore ID. The number of semaphores for
which SEM_UNDO is requested exceeds the system-defined
limit. [Tru64 UNIX] The sem_num value is less than zero.
The system-defined limit on the number of processes using
SEM_UNDO was exceeded. An operation caused a semval value
to overflow the system-defined limit, or an operation
caused an adjust-on-exit value to exceed the systemdefined
limit. [Tru64 UNIX] The requested operation is
not supported by this implementation.
Functions: exec(2), exit(2), fork(2), semctl(2),
semget(2), sem_close(3), sem_destroy(3), sem_getvalue(3),
sem_init(3), sem_open(3), sem_post(3), sem_unlink(3),
sem_wait(3)
Data Structures: semid_ds(4)
Standards: standards(5)
semop(2)
[ Back ] |
