perform_atomic_semop

/**
 * perform_atomic_semop[_slow] - Attempt to perform semaphore
 *                               operations on a given array.
 * @sma: semaphore array
 * @q: struct sem_queue that describes the operation
 *
 * Caller blocking are as follows, based the value
 * indicated by the semaphore operation (sem_op):
 *
 *  (1) >0 never blocks.
 *  (2)  0 (wait-for-zero operation): semval is non-zero.
 *  (3) <0 attempting to decrement semval to a value smaller than zero.
 *
 * Returns 0 if the operation was possible.
 * Returns 1 if the operation is impossible, the caller must sleep.
 * Returns <0 for error codes.
 */
static int perform_atomic_semop_slow(struct sem_array *sma, struct sem_queue *q)
{
    int result, sem_op, nsops;
    struct pid *pid;
    struct sembuf *sop;
    struct sem *curr;
    struct sembuf *sops;
    struct sem_undo *un;
 
    sops = q->sops;
    nsops = q->nsops;
    un = q->undo;
 
    for (sop = sops; sop < sops + nsops; sop++) {
        int idx = array_index_nospec(sop->sem_num, sma->sem_nsems);
        curr = &sma->sems[idx];
        sem_op = sop->sem_op;
        result = curr->semval;
 
        if (!sem_op && result)
            goto would_block;
 
        result += sem_op;
        if (result < 0)
            goto would_block;
        if (result > SEMVMX)
            goto out_of_range;
 
        if (sop->sem_flg & SEM_UNDO) {
            int undo = un->semadj[sop->sem_num] - sem_op;
            /* Exceeding the undo range is an error. */
            if (undo < (-SEMAEM - 1) || undo > SEMAEM)
                goto out_of_range;
            un->semadj[sop->sem_num] = undo;
        }
 
        curr->semval = result;
    }
 
    sop--;
    pid = q->pid;
    while (sop >= sops) {
        ipc_update_pid(&sma->sems[sop->sem_num].sempid, pid);
        sop--;
    }
 
    return 0;
 
out_of_range:
    result = -ERANGE;
    goto undo;
 
would_block:
    q->blocking = sop;
 
    if (sop->sem_flg & IPC_NOWAIT)
        result = -EAGAIN;
    else
        result = 1;
 
undo:
    sop--;
    while (sop >= sops) {
        sem_op = sop->sem_op;
        sma->sems[sop->sem_num].semval -= sem_op;
        if (sop->sem_flg & SEM_UNDO)
            un->semadj[sop->sem_num] += sem_op;
        sop--;
    }
 
    return result;
}
函数源码
