(0001423)
weeks (reporter)
2012-11-19 14:21
edited on: 2012-12-02 23:17
|
(Update: on the mailing list & in the Nov. 28 teleconference, Don Cragun stated that the Linux behavior in the following case---where semncnt and semzcnt effectively represent the number of semaphore operations waiting for semval to become greater-than-the-current-value or zero---doesn't match the intent of the designers of System V IPC, and that the and that OS X/AIX/HP-UX/Solaris behavior is correct)
So this information gets recorded for implementors who address this issue,
there is a related issue exemplified by the attached program getxcnt.c,
which does the following:
1. Creates a set of 2 semaphores
2. Initializes semaphore 0 <- 0 and semaphore 1 <- 1
3. Forks a child process that executes semaphore operations (-1, 0)
4. Checks semncnt for semaphore 0 and semzcnt for semaphore 1
If both semaphore operations in the array were executed atomically, the result
should look like that reported on Linux (kernel 2.6.18-274 from RHEL 5.7):
########################################
$ gcc getxcnt.c
$ ./a.out
semncnt 0: 1
semzcnt 1: 1
semop: Identifier removed
########################################
Other implementations tested (Solaris 10, AIX 7.1, HP-UX 11i v2, and
OS X 10.8.2) perform only the first semaphore operation in the array:
########################################
$ gcc getxcnt.c
$ ./a.out
semncnt 0: 1
semzcnt 1: 0
semop: Identifier removed
########################################
|
(0001429)
Don Cragun (manager)
2012-12-12 16:23
|
Interpretation response
------------------------
The standard states on P1839, L58733-58735 that "the semop() function
shall perform atomically a user-defined array of semaphore operations"
but on P1839, L58759-58765 it says:
The value of semval becomes greater than or equal to the absolute
value of sem_op. When this occurs, the value of semncnt associated
with the specified semaphore shall be decremented, the absolute
value of sem_op shall be subtracted from semval and, if (sem_flg
&SEM_UNDO) is non-zero, the absolute value of sem_op shall be added
to the semadj value of the calling process for the specified
semaphore.
and P1840, L58783-58784 it says:
The value of semval becomes 0, at which time the value of semzcnt
associated with the specified semaphore shall be decremented.
which require that the semaphore operations be acted on individually if
initial conditions cause the array of semaphore operations to block.
Conforming implementations must conform to these requirements. However,
concerns have been raised about this which are being referred to the
sponsor.
Rationale:
-------------
The stated requirements can only be met by an implementation if
each of the operations in the array of semaphore operations can be
completed successfully without blocking when semop() is called or
if there is only one semaphore operation in the array of semaphore
operations. The original intent of semop() was to atomically
complete the array of semaphore operations. If one of the operations
in the array causes semop() to block, the entire array of operations
should be attempted again when there is a change to the value of the
semaphore that caused the call to block.
Notes to the Editor (not part of this interpretation):
-------------------------------------------------------
Change the entire description of processing the array of sempahore
operations in the DESCRIPTION section of semop() on P1839-1840,
L58747-58793 to the following:
If all of the semaphore operations complete successfully, semop()
shall return 0. If a semaphore operation fails or blocks, all
changes to semadj and semval values performed by completed semaphore
operations in the array before the operation that failed or blocked
shall be undone before semop() returns or blocks, respectively. When
a semaphore operation blocks, the change to semncnt or semzcnt
indicating which semphore operation blocked shall not be undone until
the operation unblocks.
For each operation in the array of semaphore operations, the variable
sem_op specifies one of three semaphore operations:
1. If sem_op is a negative integer and the calling process has alter
permission, one of the following shall occur:
• If semval(see <sys/sem.h>) is greater than or equal to the
absolute value of sem_op, the absolute value of sem_op shall be
subtracted from semval. Also, if (sem_flg & SEM_UNDO) is
non-zero, the absolute value of sem_op shall be added to the
semadj value of the calling process for the specified
semaphore. If this is not the last operation in the array of
semaphore operations to be performed, processing shall continue
with the next operation in the array.
• If semval is less than the absolute value of sem_op and
(sem_flg & IPC_NOWAIT) is non-zero, the operation shall fail
with errno set to EAGAIN.
• If semval is less than the absolute value of sem_op and
(sem_flg & IPC_NOWAIT) is 0, semop() shall increment the
semncnt associated with the specified semaphore and suspend
execution of the calling thread (block) until one of the
following conditions occurs:
— The value of semval changes. When this occurs, the value of
semncnt associated with the specified semaphore shall be
decremented and the array of semaphore operations shall be
reevaluated.
— The semid for which the calling thread is awaiting action is
removed from the system. When this occurs the operation
shall fail with errno set to [EIDRM].
— The calling thread receives a signal that is to be caught.
When this occurs, the value of semncnt associated with the
specified semaphore shall be decremented, and the calling
thread shall resume execution in the manner prescribed in
sigaction().
2. If sem_op is a positive integer and the calling process has alter
permission, the value of sem_op shall be added to semval and, if
(sem_flg & SEM_UNDO) is non-zero, the value of sem_op shall be
subtracted from the semadj value of the calling process for the
specified semaphore. If this is not the last operation in the
array of semaphore operations to be performed, processing shall
continue with the next operation in the array.
3. If sem_op is 0 and the calling process has read permission, one
of the following shall occur:
• If semval is 0, this is a successful operation. If this is not
the last operation in the array of semaphore operations to be
performed, processing shall continue with the next operation in
the array.
• If semval is non-zero and (sem_flg & IPC_NOWAIT) is non-zero,
the operation shall fail with errno set to EAGAIN.
• If semval is non-zero and (sem_flg & IPC_NOWAIT) is 0, semop()
shall increment the semzcnt associated with the specified
semaphore and suspend execution of the calling thread (block)
until one of the following occurs:
— The value of semval changes. When this occurs, the value of
semzcnt associated with the specified semaphore shall be
decremented and the array of semaphore operations shall be
reevaluated.
— The semid for which the calling thread is awaiting action is
removed from the system. When this occurs, the operation
shall fail with errno set to [EIDRM].
— The calling thread receives a signal that is to be caught.
When this occurs, the value of semzcnt associated with the
specified semaphore shall be decremented, and the calling
thread shall resume execution in the manner prescribed in
sigaction().
Upon successful completion of all of the semaphore operations
specified in the array pointed to by sops the value of sempid for
each semaphore specified in the array shall be set to the process ID
of the calling process and the sem_otime timestamp associated with
the semaphore set shall be set to the current time, as described in
Section 2.7.1 (on page xxx). |
semop.c [^] (1,702 bytes) 2012-11-03 13:42
