/* $FreeBSD: src/sys/kern/sysv_sem.c,v 1.69 2004/03/17 09:37:13 cperciva Exp $ */

/*
 * Implementation of SVID semaphores
 *
 * Author:  Daniel Boulet
 * Copyright (c) 2013 Larisa Grigore <larisagrigore@gmail.com>
 *
 * This software is provided ``AS IS'' without any warranties of any kind.
 */

#include "namespace.h"
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <err.h>
#include <pthread.h>
#include <string.h>
#include <stdarg.h>
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/mman.h>
#include <sys/sem.h>
#include "un-namespace.h"

#include "sysvipc_lock.h"
#include "sysvipc_ipc.h"
#include "sysvipc_shm.h"
#include "sysvipc_sem.h"
#include "sysvipc_hash.h"


#define SYSV_MUTEX_LOCK(x)      if (__isthreaded) _pthread_mutex_lock(x)
#define SYSV_MUTEX_UNLOCK(x)    if (__isthreaded) _pthread_mutex_unlock(x)
#define SYSV_MUTEX_DESTROY(x)   if (__isthreaded) _pthread_mutex_destroy(x)

extern struct hashtable *shmaddrs;
extern struct hashtable *shmres;
extern pthread_mutex_t lock_resources;

struct sem_undo *undos = NULL;
pthread_mutex_t lock_undo = PTHREAD_MUTEX_INITIALIZER;

static int semundo_clear(int, int);

static int
put_shmdata(int id)
{
        struct shm_data *data;
        int ret = -1;

        SYSV_MUTEX_LOCK(&lock_resources);
        data = _hash_lookup(shmres, id);
        if (!data) {
                sysv_print_err("something wrong put_shmdata\n");
                goto done; /* It should not reach here. */
        }

        data->used--;
        if (data->used == 0 && data->removed) {
                sysv_print("really remove the sem\n");
                SYSV_MUTEX_UNLOCK(&lock_resources);
                /* OBS: Even if the shmctl fails (the thread doesn't
                 * have IPC_M permissions), all structures associated
                 * with it will be removed in the current process.*/
                sysvipc_shmdt(data->internal);
                semundo_clear(id, -1);
                if (data->removed == SEG_ALREADY_REMOVED)
                        return 1; /* The semaphore was removed
                        by another process so there is nothing else
                        we must do. */
                /* Else inform the daemon that the segment is removed. */
                return (sysvipc_shmctl(id, IPC_RMID, NULL));
        }

        ret = 0;
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);
        return (ret);
}

static struct semid_pool *
get_semaptr(int semid, int to_remove, int shm_access)
{
        struct semid_pool *semaptr;

        struct shm_data *shmdata = get_shmdata(semid, to_remove, shm_access);
        if (!shmdata) {
                /* Error is set in get_shmdata. */
                return (NULL);
        }

        semaptr = (struct semid_pool *)shmdata->internal;
        if (!semaptr) {
                put_shmdata(semid);
                errno = EINVAL;
                return (NULL);
        }

        return (semaptr);
}

static int
sema_exist(int semid, struct semid_pool *semaptr)
{
        /* Was it removed? */
        if (semaptr->gen == -1 ||
                        semaptr->ds.sem_perm.seq != IPCID_TO_SEQ(semid))
                return (0);

        return (1);
}

/* This is the function called when a the semaphore
 * is descovered as removed. It marks the process
 * internal data and munmap the */
static void
mark_for_removal(int shmid)
{
        sysv_print("Mark that the segment was removed\n");
        get_shmdata(shmid, SEG_ALREADY_REMOVED, 0);
         /* Setting SEG_ALREADY_REMOVED parameter, when put_shmdata
          * is called, the internal resources will be freed.
          */
        /* Decrement the "usage" field. */
        put_shmdata(shmid);
}

static int
try_rwlock_rdlock(int semid, struct semid_pool *semaptr)
{
        sysv_print(" before rd lock id = %d %p\n", semid, semaptr);
#ifdef SYSV_RWLOCK
        sysv_rwlock_rdlock(&semaptr->rwlock);
        sysv_print("rd lock id = %d\n", semid);
#else
        sysv_mutex_lock(&semaptr->mutex);
        sysv_print("lock id = %d\n", semid);
#endif
        if (!sema_exist(semid, semaptr)) {
                errno = EINVAL;
                sysv_print("error sema %d doesn't exist\n", semid);
#ifdef SYSV_RWLOCK
                sysv_rwlock_unlock(&semaptr->rwlock);
#else
                sysv_mutex_unlock(&semaptr->mutex);
#endif
                /* Internal resources must be freed. */
                mark_for_removal(semid);
                return (-1);
        }
        return (0);
}

static int
try_rwlock_wrlock(int semid, struct semid_pool *semaptr)
{
#ifdef SYSV_RWLOCK
        sysv_print("before wrlock id = %d %p\n", semid, semaptr);
        sysv_rwlock_wrlock(&semaptr->rwlock);
#else
        sysv_print("before lock id = %d %x\n", semid, semaptr);
        sysv_mutex_lock(&semaptr->mutex);
#endif
        sysv_print("lock id = %d\n", semid);
        if (!sema_exist(semid, semaptr)) {
                errno = EINVAL;
                sysv_print("error sema %d doesn't exist\n", semid);
#ifdef SYSV_RWLOCK
                sysv_rwlock_unlock(&semaptr->rwlock);
#else
                sysv_mutex_unlock(&semaptr->mutex);
#endif
                /* Internal resources must be freed. */
                mark_for_removal(semid);
                return (-1);
        }
        return (0);
}

static int
rwlock_unlock(int semid, struct semid_pool *semaptr)
{
        sysv_print("unlock id = %d %p\n", semid, semaptr);
        if (!sema_exist(semid, semaptr)) {
                /* Internal resources must be freed. */
                mark_for_removal(semid);
                errno = EINVAL;
                return (-1);
        }
#ifdef SYSV_RWLOCK
        sysv_rwlock_unlock(&semaptr->rwlock);
#else
        sysv_mutex_unlock(&semaptr->mutex);
#endif
        return (0);
}

int
sysvipc_semget(key_t key, int nsems, int semflg)
{
        int semid;
        void *shmaddr;
        //int shm_access;
        int size = sizeof(struct semid_pool) + nsems * sizeof(struct sem);

        //TODO resources limits
        sysv_print("handle semget\n");

        semid = _shmget(key, size, semflg, SEMGET);
        if (semid == -1) {
                /* errno already set. */
                goto done;
        }

        /* If the semaphore is in process of being removed there are two cases:
         * - the daemon knows that and it will handle this situation.
         * - one of the threads from this address space remove it and the daemon
         *   wasn't announced yet; in this scenario, the semaphore is marked
         *   using "removed" field of shm_data and future calls will return
         *   EIDRM error.
         */

#if 0
        /* Set access type. */
        shm_access = semflg & (IPC_W | IPC_R);
        if(set_shmdata_access(semid, shm_access) != 0) {
                /* errno already set. */
                goto done;
        }
#endif
        shmaddr = sysvipc_shmat(semid, NULL, 0);
        if (!shmaddr) {
                semid = -1;
                sysvipc_shmctl(semid, IPC_RMID, NULL);
                goto done;
        }

        //TODO more semaphores in a single file

done:
        sysv_print("end handle semget %d\n", semid);
        return (semid);
}

static int
semundo_clear(int semid, int semnum)
{
        struct undo *sunptr;
        int i;

        sysv_print("semundo clear\n");

        SYSV_MUTEX_LOCK(&lock_undo);
        if (!undos)
                goto done;

        sunptr = &undos->un_ent[0];
        i = 0;

        while (i < undos->un_cnt) {
                if (sunptr->un_id == semid) {
                        if (semnum == -1 || sunptr->un_num == semnum) {
                                undos->un_cnt--;
                                if (i < undos->un_cnt) {
                                        undos->un_ent[i] =
                                          undos->un_ent[undos->un_cnt];
                                        continue;
                                }
                        }
                        if (semnum != -1)
                                break;
                }
                ++i;
                ++sunptr;
        }

        //TODO Shrink memory if case; not sure if necessary
done:
        SYSV_MUTEX_UNLOCK(&lock_undo);
        sysv_print("end semundo clear\n");
        return (0);
}

int
sysvipc___semctl(int semid, int semnum, int cmd, union semun *arg)
{
        int i, error;
        struct semid_pool *semaptr = NULL;
        struct sem *semptr = NULL;
        struct shmid_ds shmds;
        int shm_access = 0;

        /*if (!jail_sysvipc_allowed && cred->cr_prison != NULL)
                return (ENOSYS);
*/

        sysv_print("semctl cmd = %d\n", cmd);

        error = 0;

        switch (cmd) {
                case IPC_SET: /* Originally was IPC_M but this is checked
                                 by daemon. */
                case SETVAL:
                case SETALL:
                        shm_access = IPC_W;
                        break;
                case IPC_STAT:
                case GETNCNT:
                case GETPID:
                case GETVAL:
                case GETALL:
                case GETZCNT:
                        shm_access = IPC_R;
                        break;
                default:
                        break;
        }

        semaptr = get_semaptr(semid, cmd==IPC_RMID, shm_access);
        if (!semaptr) {
                /* errno already set. */
                return (-1);
        }

        switch (cmd) {
        case IPC_RMID:
                /* Mark that the segment is removed. This is done in
                 * get_semaptr call in order to announce other processes.
                 * It will be actually removed after put_shmdata call and
                 * not other thread from this address space use shm_data
                 * structure.
                 */
                break;

        case IPC_SET:
                if (!arg->buf) {
                        error = EFAULT;
                        break;
                }

                memset(&shmds, 0, sizeof(shmds)/sizeof(unsigned char));
                memcpy(&shmds.shm_perm, &arg->buf->sem_perm,
                                sizeof(struct ipc_perm));
                error = sysvipc_shmctl(semid, cmd, &shmds);
                /* OBS: didn't update ctime and mode as in kernel implementation
                 * it is done. Those fields are already updated for shmid_ds
                 * struct when calling shmctl
                 */
                break;

        case IPC_STAT:
                if (!arg->buf) {
                        error = EFAULT;
                        break;
                }

                error = sysvipc_shmctl(semid, cmd, &shmds);
                if (error)
                        break;

                memcpy(&arg->buf->sem_perm, &shmds.shm_perm,
                                sizeof(struct ipc_perm));
                arg->buf->sem_nsems = (shmds.shm_segsz - sizeof(struct semid_pool)) /
                        sizeof(struct sem);
                arg->buf->sem_ctime = shmds.shm_ctime;

                /* otime is semaphore specific so read it from
                 * semaptr
                 */
                error = try_rwlock_rdlock(semid, semaptr);
                if (error)
                        break;
                arg->buf->sem_otime = semaptr->ds.sem_otime;
                rwlock_unlock(semid, semaptr);
                break;

        case GETNCNT:
                if (semnum < 0 || semnum >= semaptr->ds.sem_nsems) {
                        errno = EINVAL;
                        break;
                }

                error = try_rwlock_rdlock(semid, semaptr);
                if (error)
                        break;
                error = semaptr->ds.sem_base[semnum].semncnt;
                rwlock_unlock(semid, semaptr);
                break;

        case GETPID:
                if (semnum < 0 || semnum >= semaptr->ds.sem_nsems) {
                        errno = EINVAL;
                        break;
                }

                error = try_rwlock_rdlock(semid, semaptr);
                if (error)
                        break;
                error = semaptr->ds.sem_base[semnum].sempid;
                rwlock_unlock(semid, semaptr);
                break;

        case GETVAL:
                if (semnum < 0 || semnum >= semaptr->ds.sem_nsems) {
                        errno = EINVAL;
                        break;
                }

                error = try_rwlock_rdlock(semid, semaptr);
                if (error)
                        break;
                error = semaptr->ds.sem_base[semnum].semval;
                rwlock_unlock(semid, semaptr);
                break;

        case GETALL:
                if (!arg->array) {
                        error = EFAULT;
                        break;
                }

                error = try_rwlock_rdlock(semid, semaptr);
                if (error)
                        break;
                for (i = 0; i < semaptr->ds.sem_nsems; i++) {
                        arg->array[i] = semaptr->ds.sem_base[i].semval;
                }
                rwlock_unlock(semid, semaptr);
                break;

        case GETZCNT:
                if (semnum < 0 || semnum >= semaptr->ds.sem_nsems) {
                        errno = EINVAL;
                        break;
                }

                error = try_rwlock_rdlock(semid, semaptr);
                if (error)
                        break;
                error = semaptr->ds.sem_base[semnum].semzcnt;
                rwlock_unlock(semid, semaptr);
                break;

        case SETVAL:
                if (semnum < 0 || semnum >= semaptr->ds.sem_nsems) {
                        errno = EINVAL;
                        break;
                }

                error = try_rwlock_wrlock(semid, semaptr);
                if (error)
                        break;
                semptr = &semaptr->ds.sem_base[semnum];
                semptr->semval = arg->val;
                semundo_clear(semid, semnum);
                if (semptr->semzcnt || semptr->semncnt)
                        umtx_wakeup((int *)&semptr->semval, 0);
                rwlock_unlock(semid, semaptr);
                break;

        case SETALL:
                if (!arg->array) {
                        error = EFAULT;
                        break;
                }

                error = try_rwlock_wrlock(semid, semaptr);
                if (error)
                        break;
                for (i = 0; i < semaptr->ds.sem_nsems; i++) {
                        semptr = &semaptr->ds.sem_base[i];
                        semptr->semval = arg->array[i];
                        if (semptr->semzcnt || semptr->semncnt)
                                umtx_wakeup((int *)&semptr->semval, 0);
                }
                semundo_clear(semid, -1);
                rwlock_unlock(semid, semaptr);
                break;

        default:
                errno = EINVAL;
                break;
        }

        put_shmdata(semid);

        sysv_print("end semctl\n");
        return (error);
}

/*
 * Adjust a particular entry for a particular proc
 */
static int
semundo_adjust(int semid, int semnum, int adjval)
{
        struct undo *sunptr;
        int i;
        int error = 0;
        size_t size;
        int undoid;
        void *addr;
        struct shm_data *data;

        sysv_print("semundo adjust\n");
        if (!adjval)
                goto done;

        SYSV_MUTEX_LOCK(&lock_undo);
        if (!undos) {
                sysv_print("get undo segment\n");
                undoid = _shmget(IPC_PRIVATE, PAGE_SIZE, IPC_CREAT | IPC_EXCL | 0600,
                                UNDOGET);
                if (undoid == -1) {
                        sysv_print_err("no undo segment\n");
                        return (-1);
                }

                addr = sysvipc_shmat(undoid, NULL, 0);
                if (!addr) {
                        sysv_print_err("can not map undo segment\n");
                        sysvipc_shmctl(undoid, IPC_RMID, NULL);
                        return (-1);
                }

                undos = (struct sem_undo *)addr;
                undos->un_pages = 1;
                undos->un_cnt = 0;
        }

        /*
         * Look for the requested entry and adjust it (delete if adjval becomes
         * 0).
         */
        sunptr = &undos->un_ent[0];
        for (i = 0; i < undos->un_cnt; i++, sunptr++) {
                if (sunptr->un_id != semid && sunptr->un_num != semnum)
                        continue;
                sunptr->un_adjval += adjval;
                if (sunptr->un_adjval == 0) {
                        undos->un_cnt--;
                        if (i < undos->un_cnt)
                                undos->un_ent[i] = undos->un_ent[undos->un_cnt];
                }
                goto done;
        }

        /* Didn't find the right entry - create it */
        size = sizeof(struct sem_undo) + (undos->un_cnt + 1) *
                sizeof(struct sem_undo);
        if (size > (unsigned int)(undos->un_pages * PAGE_SIZE)) {
                sysv_print("need more undo space\n");
                sysvipc_shmdt(undos);
                undos->un_pages++;

                SYSV_MUTEX_LOCK(&lock_resources);
                data = _hash_lookup(shmaddrs, (u_long)undos);
                SYSV_MUTEX_UNLOCK(&lock_resources);

                /* It is not necessary any lock on "size" because it is used
                 * only by shmat and shmdt.
                 * shmat for undoid is called only from this function and it
                 * is protected by undo_lock.
                 * shmdt for undoid is not called anywhere because the segment
                 * is destroyed by the daemon when the client dies.
                 */
                data->size = undos->un_pages * PAGE_SIZE;
                undos = sysvipc_shmat(data->shmid, NULL, 0);
        }

        sunptr = &undos->un_ent[undos->un_cnt];
        undos->un_cnt++;
        sunptr->un_adjval = adjval;
        sunptr->un_id = semid;
        sunptr->un_num = semnum;
        //if (suptr->un_cnt == seminfo.semume) TODO move it in daemon
        /*} else {
          error = EINVAL; //se face prin notificare
          }*/
done:
        SYSV_MUTEX_UNLOCK(&lock_undo);

        sysv_print("semundo adjust end\n");
        return (error);
}

int
sysvipc_semop(int semid, struct sembuf *sops, unsigned nsops)
{
        struct semid_pool *semaptr = NULL, *auxsemaptr = NULL;
        struct sembuf *sopptr;
        struct sem *semptr = NULL;
        struct sem *xsemptr = NULL;
        int eval = 0;
        int i, j;
        int do_undos;
        int val_to_sleep;

        sysv_print("[client %d] call to semop(%d, %u)\n",
                        getpid(), semid, nsops);
//TODO
        /*if (!jail_sysvipc_allowed && td->td_ucred->cr_prison != NULL)
          return (ENOSYS);
          */

        semaptr = get_semaptr(semid, 0, IPC_W);
        if (!semaptr) {
                errno = EINVAL;
                return (-1);
        }

#ifdef SYSV_SEMS
        if (try_rwlock_rdlock(semid, semaptr) == -1) {
#else
        if (try_rwlock_wrlock(semid, semaptr) == -1) {
#endif
                sysv_print("sema removed\n");
                errno = EIDRM;
                goto done2;
        }

        if (nsops > MAX_SOPS) {
                sysv_print("too many sops (max=%d, nsops=%u)\n",
                    MAX_SOPS, nsops);
                eval = E2BIG;
                goto done;
        }

        /*
        * Loop trying to satisfy the vector of requests.
        * If we reach a point where we must wait, any requests already
        * performed are rolled back and we go to sleep until some other
        * process wakes us up.  At this point, we start all over again.
        *
        * This ensures that from the perspective of other tasks, a set
        * of requests is atomic (never partially satisfied).
        */
        do_undos = 0;

        for (;;) {

                semptr = NULL;

                for (i = 0; i < (int)nsops; i++) {
                        sopptr = &sops[i];

                        if (sopptr->sem_num >= semaptr->ds.sem_nsems) {
                                eval = EFBIG;
                                goto done;
                        }

                        semptr = &semaptr->ds.sem_base[sopptr->sem_num];
#ifdef SYSV_SEMS
                        sysv_mutex_lock(&semptr->sem_mutex);
#endif
                        sysv_print("semop: sem[%d]=%d : op=%d, flag=%s\n",
                                sopptr->sem_num, semptr->semval, sopptr->sem_op,
                                (sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait");

                        if (sopptr->sem_op < 0) {
                                if (semptr->semval + sopptr->sem_op < 0) {
                                        sysv_print("semop:  can't do it now\n");
                                        break;
                                } else {
                                        semptr->semval += sopptr->sem_op;
                                        if (semptr->semval == 0 &&
                                                semptr->semzcnt > 0)
                                                umtx_wakeup((int *)&semptr->semval, 0);
                                }
                                if (sopptr->sem_flg & SEM_UNDO)
                                        do_undos = 1;
                        } else if (sopptr->sem_op == 0) {
                                if (semptr->semval > 0) {
                                        sysv_print("semop:  not zero now\n");
                                        break;
                                }
                        } else {
                                semptr->semval += sopptr->sem_op;
                                if (sopptr->sem_flg & SEM_UNDO)
                                        do_undos = 1;
                                if (semptr->semncnt > 0)
                                        umtx_wakeup((int *)&semptr->semval, 0);
                        }
#ifdef SYSV_SEMS
                        sysv_mutex_unlock(&semptr->sem_mutex);
#endif
                }

                /*
                 * Did we get through the entire vector?
                 */
                if (i >= (int)nsops)
                        goto donex;

                if (sopptr->sem_op == 0)
                        semptr->semzcnt++;
                else
                        semptr->semncnt++;

                /*
                 * Get interlock value before rleeasing sem_mutex.
                 *
                 * XXX horrible hack until we get a umtx_sleep16() (and a umtx_sleep64())
                 * system call.
                 */
                val_to_sleep = *(int *)&semptr->semval;
#ifdef SYSV_SEMS
                sysv_mutex_unlock(&semptr->sem_mutex);
#endif
                /*
                 * Rollback the semaphores we had acquired.
                 */
                sysv_print("semop:  rollback 0 through %d\n", i-1);
                for (j = 0; j < i; j++) {
                        xsemptr = &semaptr->ds.sem_base[sops[j].sem_num];
#ifdef SYSV_SEMS
                        sysv_mutex_lock(&xsemptr->sem_mutex);
#endif
                        xsemptr->semval -= sops[j].sem_op;
                        if (xsemptr->semval == 0 && xsemptr->semzcnt > 0)
                                umtx_wakeup((int *)&xsemptr->semval, 0);
                        if (xsemptr->semval <= 0 && xsemptr->semncnt > 0)
                                umtx_wakeup((int *)&xsemptr->semval, 0); //?!
#ifdef SYSV_SEMS
                        sysv_mutex_unlock(&xsemptr->sem_mutex);
#endif
                }

                /*
                 * If the request that we couldn't satisfy has the
                 * NOWAIT flag set then return with EAGAIN.
                 */
                if (sopptr->sem_flg & IPC_NOWAIT) {
                        eval = EAGAIN;
                        goto done;
                }

                /*
                 * Release semaptr->lock while sleeping, allowing other
                 * semops (like SETVAL, SETALL, etc), which require an
                 * exclusive lock and might wake us up.
                 *
                 * Reload and recheck the validity of semaptr on return.
                 * Note that semptr itself might have changed too, but
                 * we've already interlocked for semptr and that is what
                 * will be woken up if it wakes up the tsleep on a MP
                 * race.
                 *
                 */
                sysv_print("semop:  good night!\n");
                rwlock_unlock(semid, semaptr);
                put_shmdata(semid);

                /* We don't sleep more than SYSV_TIMEOUT because we could
                 * go to sleep after another process calls wakeup and remain
                 * blocked.
                 */
                eval = umtx_sleep((int *)&semptr->semval, val_to_sleep, SYSV_TIMEOUT);
                /* return code is checked below, after sem[nz]cnt-- */

                /*
                 * Make sure that the semaphore still exists
                 */

                /* Check if another thread didn't remove the semaphore. */
                auxsemaptr = get_semaptr(semid, 0, IPC_W); /* Redundant access check. */
                if (!auxsemaptr) {
                        errno = EIDRM;
                        return (-1);
                }
                        
                if (auxsemaptr != semaptr) {
                        errno = EIDRM;
                        goto done;
                }

                /* Check if another process didn't remove the semaphore. */
#ifdef SYSV_SEMS
                if (try_rwlock_rdlock(semid, semaptr) == -1) {
#else
                if (try_rwlock_wrlock(semid, semaptr) == -1) {
#endif
                        errno = EIDRM;
                        goto done;
                }
                sysv_print("semop:  good morning (eval=%d)!\n", eval);

                /* The semaphore is still alive.  Readjust the count of
                 * waiting processes.
                 */
                semptr = &semaptr->ds.sem_base[sopptr->sem_num];
#ifdef SYSV_SEMS
                sysv_mutex_lock(&semptr->sem_mutex);
#endif
                if (sopptr->sem_op == 0)
                        semptr->semzcnt--;
                else
                        semptr->semncnt--;
#ifdef SYSV_SEMS
                sysv_mutex_unlock(&semptr->sem_mutex);
#endif

                /*
                 * Is it really morning, or was our sleep interrupted?
                 * (Delayed check of tsleep() return code because we
                 * need to decrement sem[nz]cnt either way.)
                 *
                 * Always retry on EBUSY
                 */
                if (eval == EAGAIN) {
                        eval = EINTR;
                        goto done;
                }

                sysv_print("semop:  good morning!\n");
                /* RETRY LOOP */
}

donex:
        /*
        * Process any SEM_UNDO requests.
        */
        if (do_undos) {
                for (i = 0; i < (int)nsops; i++) {
                        /*
                         * We only need to deal with SEM_UNDO's for non-zero
                         * op's.
                         */
                        int adjval;

                        if ((sops[i].sem_flg & SEM_UNDO) == 0)
                                continue;
                        adjval = sops[i].sem_op;
                        if (adjval == 0)
                                continue;
                        eval = semundo_adjust(semid, sops[i].sem_num, -adjval);
                        if (eval == 0)
                                continue;

                        /*
                         * Oh-Oh!  We ran out of either sem_undo's or undo's.
                         * Rollback the adjustments to this point and then
                         * rollback the semaphore ups and down so we can return
                         * with an error with all structures restored.  We
                         * rollback the undo's in the exact reverse order that
                         * we applied them.  This guarantees that we won't run
                         * out of space as we roll things back out.
                         */
                        for (j = i - 1; j >= 0; j--) {
                                if ((sops[j].sem_flg & SEM_UNDO) == 0)
                                        continue;
                                adjval = sops[j].sem_op;
                                if (adjval == 0)
                                        continue;
                                if (semundo_adjust(semid, sops[j].sem_num,
                                                        adjval) != 0)
                                        sysv_print("semop - can't undo undos");
                        }

                        for (j = 0; j < (int)nsops; j++) {
                                xsemptr = &semaptr->ds.sem_base[
                                        sops[j].sem_num];
#ifdef SYSV_SEMS
                                sysv_mutex_lock(&semptr->sem_mutex);
#endif
                                xsemptr->semval -= sops[j].sem_op;
                                if (xsemptr->semval == 0 &&
                                                xsemptr->semzcnt > 0)
                                        umtx_wakeup((int *)&xsemptr->semval, 0);
                                if (xsemptr->semval <= 0 &&
                                                xsemptr->semncnt > 0)
                                        umtx_wakeup((int *)&xsemptr->semval, 0); //?!
#ifdef SYSV_SEMS
                                sysv_mutex_unlock(&semptr->sem_mutex);
#endif
                        }

                        sysv_print("eval = %d from semundo_adjust\n", eval);
                        goto done;
                }
        }

        /* Set sempid field for each semaphore. */
        for (i = 0; i < (int)nsops; i++) {
                sopptr = &sops[i];
                semptr = &semaptr->ds.sem_base[sopptr->sem_num];
#ifdef SYSV_SEMS
                sysv_mutex_lock(&semptr->sem_mutex);
#endif
                semptr->sempid = getpid();
#ifdef SYSV_SEMS
                sysv_mutex_unlock(&semptr->sem_mutex);
#endif
        }

        sysv_print("semop:  done\n");
        semaptr->ds.sem_otime = time(NULL);
done:
        rwlock_unlock(semid, semaptr);
done2:
        put_shmdata(semid);

        return (eval);
}