/* $NetBSD: sysv_sem.c,v 1.20 1995/03/19 23:44:59 mycroft Exp $ */ /* * Implementation of SVID semaphores * * Author: Daniel Boulet * * This software is provided ``AS IS'' without any warranties of any kind. */ #include #include #include #include #include #include #include #include int semtot = 0; struct proc *semlock_holder = NULL; int seminit() { register int i; vm_offset_t whocares1, whocares2; if (sema == NULL) panic("sema is NULL"); if (semu == NULL) panic("semu is NULL"); for (i = 0; i < seminfo.semmni; i++) { sema[i].sem_base = 0; sema[i].sem_perm.mode = 0; } for (i = 0; i < seminfo.semmnu; i++) { register struct sem_undo *suptr = SEMU(i); suptr->un_proc = NULL; } semu_list = NULL; } void semlock(p) struct proc *p; { while (semlock_holder != NULL && semlock_holder != p) sleep((caddr_t)&semlock_holder, (PZERO - 4)); } /* * Lock or unlock the entire semaphore facility. * * This will probably eventually evolve into a general purpose semaphore * facility status enquiry mechanism (I don't like the "read /dev/kmem" * approach currently taken by ipcs and the amount of info that we want * to be able to extract for ipcs is probably beyond the capability of * the getkerninfo facility. * * At the time that the current version of semconfig was written, ipcs is * the only user of the semconfig facility. It uses it to ensure that the * semaphore facility data structures remain static while it fishes around * in /dev/kmem. */ int semconfig(p, uap, retval) struct proc *p; struct semconfig_args /* { syscallarg(int) flag; } */ *uap; register_t *retval; { int eval = 0; semlock(p); switch (SCARG(uap, flag)) { case SEM_CONFIG_FREEZE: semlock_holder = p; break; case SEM_CONFIG_THAW: semlock_holder = NULL; wakeup((caddr_t)&semlock_holder); break; default: printf( "semconfig: unknown flag parameter value (%d) - ignored\n", SCARG(uap, flag)); eval = EINVAL; break; } *retval = 0; return(eval); } /* * Allocate a new sem_undo structure for a process * (returns ptr to structure or NULL if no more room) */ struct sem_undo * semu_alloc(p) struct proc *p; { register int i; register struct sem_undo *suptr; register struct sem_undo **supptr; int attempt; /* * Try twice to allocate something. * (we'll purge any empty structures after the first pass so * two passes are always enough) */ for (attempt = 0; attempt < 2; attempt++) { /* * Look for a free structure. * Fill it in and return it if we find one. */ for (i = 0; i < seminfo.semmnu; i++) { suptr = SEMU(i); if (suptr->un_proc == NULL) { suptr->un_next = semu_list; semu_list = suptr; suptr->un_cnt = 0; suptr->un_proc = p; return(suptr); } } /* * We didn't find a free one, if this is the first attempt * then try to free some structures. */ if (attempt == 0) { /* All the structures are in use - try to free some */ int did_something = 0; supptr = &semu_list; while ((suptr = *supptr) != NULL) { if (suptr->un_cnt == 0) { suptr->un_proc = NULL; *supptr = suptr->un_next; did_something = 1; } else supptr = &(suptr->un_next); } /* If we didn't free anything then just give-up */ if (!did_something) return(NULL); } else { /* * The second pass failed even though we freed * something after the first pass! * This is IMPOSSIBLE! */ panic("semu_alloc - second attempt failed"); } } } /* * Adjust a particular entry for a particular proc */ int semundo_adjust(p, supptr, semid, semnum, adjval) register struct proc *p; struct sem_undo **supptr; int semid, semnum; int adjval; { register struct sem_undo *suptr; register struct undo *sunptr; int i; /* Look for and remember the sem_undo if the caller doesn't provide it */ suptr = *supptr; if (suptr == NULL) { for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) { if (suptr->un_proc == p) { *supptr = suptr; break; } } if (suptr == NULL) { if (adjval == 0) return(0); suptr = semu_alloc(p); if (suptr == NULL) return(ENOSPC); *supptr = suptr; } } /* * Look for the requested entry and adjust it (delete if adjval becomes * 0). */ sunptr = &suptr->un_ent[0]; for (i = 0; i < suptr->un_cnt; i++, sunptr++) { if (sunptr->un_id != semid || sunptr->un_num != semnum) continue; if (adjval == 0) sunptr->un_adjval = 0; else sunptr->un_adjval += adjval; if (sunptr->un_adjval == 0) { suptr->un_cnt--; if (i < suptr->un_cnt) suptr->un_ent[i] = suptr->un_ent[suptr->un_cnt]; } return(0); } /* Didn't find the right entry - create it */ if (adjval == 0) return(0); if (suptr->un_cnt == SEMUME) return(EINVAL); sunptr = &suptr->un_ent[suptr->un_cnt]; suptr->un_cnt++; sunptr->un_adjval = adjval; sunptr->un_id = semid; sunptr->un_num = semnum; return(0); } void semundo_clear(semid, semnum) int semid, semnum; { register struct sem_undo *suptr; for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) { register struct undo *sunptr; register int i; sunptr = &suptr->un_ent[0]; for (i = 0; i < suptr->un_cnt; i++, sunptr++) { if (sunptr->un_id == semid) { if (semnum == -1 || sunptr->un_num == semnum) { suptr->un_cnt--; if (i < suptr->un_cnt) { suptr->un_ent[i] = suptr->un_ent[suptr->un_cnt]; i--, sunptr--; } } if (semnum != -1) break; } } } } int __semctl(p, uap, retval) struct proc *p; register struct __semctl_args /* { syscallarg(int) semid; syscallarg(int) semnum; syscallarg(int) cmd; syscallarg(union semun *) arg; } */ *uap; register_t *retval; { int semid = SCARG(uap, semid); int semnum = SCARG(uap, semnum); int cmd = SCARG(uap, cmd); union semun *arg = SCARG(uap, arg); union semun real_arg; struct ucred *cred = p->p_ucred; int i, rval, eval; struct semid_ds sbuf; register struct semid_ds *semaptr; #ifdef SEM_DEBUG printf("call to semctl(%d, %d, %d, %p)\n", semid, semnum, cmd, arg); #endif semlock(p); semid = IPCID_TO_IX(semid); if (semid < 0 || semid >= seminfo.semmsl) return(EINVAL); semaptr = &sema[semid]; if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) return(EINVAL); eval = 0; rval = 0; switch (cmd) { case IPC_RMID: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_M))) return(eval); semaptr->sem_perm.cuid = cred->cr_uid; semaptr->sem_perm.uid = cred->cr_uid; semtot -= semaptr->sem_nsems; for (i = semaptr->sem_base - sem; i < semtot; i++) sem[i] = sem[i + semaptr->sem_nsems]; for (i = 0; i < seminfo.semmni; i++) { if ((sema[i].sem_perm.mode & SEM_ALLOC) && sema[i].sem_base > semaptr->sem_base) sema[i].sem_base -= semaptr->sem_nsems; } semaptr->sem_perm.mode = 0; semundo_clear(semid, -1); wakeup((caddr_t)semaptr); break; case IPC_SET: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_M))) return(eval); if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) return(eval); if ((eval = copyin(real_arg.buf, (caddr_t)&sbuf, sizeof(sbuf))) != 0) return(eval); semaptr->sem_perm.uid = sbuf.sem_perm.uid; semaptr->sem_perm.gid = sbuf.sem_perm.gid; semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) | (sbuf.sem_perm.mode & 0777); semaptr->sem_ctime = time.tv_sec; break; case IPC_STAT: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) return(eval); if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) return(eval); eval = copyout((caddr_t)semaptr, real_arg.buf, sizeof(struct semid_ds)); break; case GETNCNT: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) return(eval); if (semnum < 0 || semnum >= semaptr->sem_nsems) return(EINVAL); rval = semaptr->sem_base[semnum].semncnt; break; case GETPID: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) return(eval); if (semnum < 0 || semnum >= semaptr->sem_nsems) return(EINVAL); rval = semaptr->sem_base[semnum].sempid; break; case GETVAL: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) return(eval); if (semnum < 0 || semnum >= semaptr->sem_nsems) return(EINVAL); rval = semaptr->sem_base[semnum].semval; break; case GETALL: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) return(eval); if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) return(eval); for (i = 0; i < semaptr->sem_nsems; i++) { eval = copyout((caddr_t)&semaptr->sem_base[i].semval, &real_arg.array[i], sizeof(real_arg.array[0])); if (eval != 0) break; } break; case GETZCNT: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_R))) return(eval); if (semnum < 0 || semnum >= semaptr->sem_nsems) return(EINVAL); rval = semaptr->sem_base[semnum].semzcnt; break; case SETVAL: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) return(eval); if (semnum < 0 || semnum >= semaptr->sem_nsems) return(EINVAL); if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) return(eval); semaptr->sem_base[semnum].semval = real_arg.val; semundo_clear(semid, semnum); wakeup((caddr_t)semaptr); break; case SETALL: if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) return(eval); if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) return(eval); for (i = 0; i < semaptr->sem_nsems; i++) { eval = copyin(&real_arg.array[i], (caddr_t)&semaptr->sem_base[i].semval, sizeof(real_arg.array[0])); if (eval != 0) break; } semundo_clear(semid, -1); wakeup((caddr_t)semaptr); break; default: return(EINVAL); } if (eval == 0) *retval = rval; return(eval); } int semget(p, uap, retval) struct proc *p; register struct semget_args /* { syscallarg(key_t) key; syscallarg(int) nsems; syscallarg(int) semflg; } */ *uap; register_t *retval; { int semid, eval; int key = SCARG(uap, key); int nsems = SCARG(uap, nsems); int semflg = SCARG(uap, semflg); struct ucred *cred = p->p_ucred; #ifdef SEM_DEBUG printf("semget(0x%x, %d, 0%o)\n", key, nsems, semflg); #endif semlock(p); if (key != IPC_PRIVATE) { for (semid = 0; semid < seminfo.semmni; semid++) { if ((sema[semid].sem_perm.mode & SEM_ALLOC) && sema[semid].sem_perm.key == key) break; } if (semid < seminfo.semmni) { #ifdef SEM_DEBUG printf("found public key\n"); #endif if ((eval = ipcperm(cred, &sema[semid].sem_perm, semflg & 0700))) return(eval); if (nsems > 0 && sema[semid].sem_nsems < nsems) { #ifdef SEM_DEBUG printf("too small\n"); #endif return(EINVAL); } if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) { #ifdef SEM_DEBUG printf("not exclusive\n"); #endif return(EEXIST); } goto found; } } #ifdef SEM_DEBUG printf("need to allocate the semid_ds\n"); #endif if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) { if (nsems <= 0 || nsems > seminfo.semmsl) { #ifdef SEM_DEBUG printf("nsems out of range (0<%d<=%d)\n", nsems, seminfo.semmsl); #endif return(EINVAL); } if (nsems > seminfo.semmns - semtot) { #ifdef SEM_DEBUG printf("not enough semaphores left (need %d, got %d)\n", nsems, seminfo.semmns - semtot); #endif return(ENOSPC); } for (semid = 0; semid < seminfo.semmni; semid++) { if ((sema[semid].sem_perm.mode & SEM_ALLOC) == 0) break; } if (semid == seminfo.semmni) { #ifdef SEM_DEBUG printf("no more semid_ds's available\n"); #endif return(ENOSPC); } #ifdef SEM_DEBUG printf("semid %d is available\n", semid); #endif sema[semid].sem_perm.key = key; sema[semid].sem_perm.cuid = cred->cr_uid; sema[semid].sem_perm.uid = cred->cr_uid; sema[semid].sem_perm.cgid = cred->cr_gid; sema[semid].sem_perm.gid = cred->cr_gid; sema[semid].sem_perm.mode = (semflg & 0777) | SEM_ALLOC; sema[semid].sem_perm.seq = (sema[semid].sem_perm.seq + 1) & 0x7fff; sema[semid].sem_nsems = nsems; sema[semid].sem_otime = 0; sema[semid].sem_ctime = time.tv_sec; sema[semid].sem_base = &sem[semtot]; semtot += nsems; bzero(sema[semid].sem_base, sizeof(sema[semid].sem_base[0])*nsems); #ifdef SEM_DEBUG printf("sembase = %p, next = %p\n", sema[semid].sem_base, &sem[semtot]); #endif } else { #ifdef SEM_DEBUG printf("didn't find it and wasn't asked to create it\n"); #endif return(ENOENT); } found: *retval = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm); return(0); } int semop(p, uap, retval) struct proc *p; register struct semop_args /* { syscallarg(int) semid; syscallarg(struct sembuf *) sops; syscallarg(u_int) nsops; } */ *uap; register_t *retval; { int semid = SCARG(uap, semid); int nsops = SCARG(uap, nsops); struct sembuf sops[MAX_SOPS]; register struct semid_ds *semaptr; register struct sembuf *sopptr; register struct sem *semptr; struct sem_undo *suptr = NULL; struct ucred *cred = p->p_ucred; int i, j, eval; int all_ok, do_wakeup, do_undos; #ifdef SEM_DEBUG printf("call to semop(%d, %p, %d)\n", semid, sops, nsops); #endif semlock(p); semid = IPCID_TO_IX(semid); /* Convert back to zero origin */ if (semid < 0 || semid >= seminfo.semmsl) return(EINVAL); semaptr = &sema[semid]; if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) return(EINVAL); if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) { #ifdef SEM_DEBUG printf("eval = %d from ipaccess\n", eval); #endif return(eval); } if (nsops > MAX_SOPS) { #ifdef SEM_DEBUG printf("too many sops (max=%d, nsops=%d)\n", MAX_SOPS, nsops); #endif return(E2BIG); } if ((eval = copyin(SCARG(uap, sops), sops, nsops * sizeof(sops[0]))) != 0) { #ifdef SEM_DEBUG printf("eval = %d from copyin(%p, %p, %d)\n", eval, SCARG(uap, sops), &sops, nsops * sizeof(sops[0])); #endif return(eval); } /* * 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 (;;) { do_wakeup = 0; for (i = 0; i < nsops; i++) { sopptr = &sops[i]; if (sopptr->sem_num >= semaptr->sem_nsems) return(EFBIG); semptr = &semaptr->sem_base[sopptr->sem_num]; #ifdef SEM_DEBUG printf("semop: semaptr=%x, sem_base=%x, semptr=%x, sem[%d]=%d : op=%d, flag=%s\n", semaptr, semaptr->sem_base, semptr, sopptr->sem_num, semptr->semval, sopptr->sem_op, (sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait"); #endif if (sopptr->sem_op < 0) { if (semptr->semval + sopptr->sem_op < 0) { #ifdef SEM_DEBUG printf("semop: can't do it now\n"); #endif break; } else { semptr->semval += sopptr->sem_op; if (semptr->semval == 0 && semptr->semzcnt > 0) do_wakeup = 1; } if (sopptr->sem_flg & SEM_UNDO) do_undos = 1; } else if (sopptr->sem_op == 0) { if (semptr->semval > 0) { #ifdef SEM_DEBUG printf("semop: not zero now\n"); #endif break; } } else { if (semptr->semncnt > 0) do_wakeup = 1; semptr->semval += sopptr->sem_op; if (sopptr->sem_flg & SEM_UNDO) do_undos = 1; } } /* * Did we get through the entire vector? */ if (i >= nsops) goto done; /* * No ... rollback anything that we've already done */ #ifdef SEM_DEBUG printf("semop: rollback 0 through %d\n", i-1); #endif for (j = 0; j < i; j++) semaptr->sem_base[sops[j].sem_num].semval -= sops[j].sem_op; /* * If the request that we couldn't satisfy has the * NOWAIT flag set then return with EAGAIN. */ if (sopptr->sem_flg & IPC_NOWAIT) return(EAGAIN); if (sopptr->sem_op == 0) semptr->semzcnt++; else semptr->semncnt++; #ifdef SEM_DEBUG printf("semop: good night!\n"); #endif eval = tsleep((caddr_t)semaptr, (PZERO - 4) | PCATCH, "semwait", 0); #ifdef SEM_DEBUG printf("semop: good morning (eval=%d)!\n", eval); #endif suptr = NULL; /* sem_undo may have been reallocated */ if (eval != 0) return(EINTR); #ifdef SEM_DEBUG printf("semop: good morning!\n"); #endif /* * Make sure that the semaphore still exists */ if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) { /* The man page says to return EIDRM. */ /* Unfortunately, BSD doesn't define that code! */ #ifdef EIDRM return(EIDRM); #else return(EINVAL); #endif } /* * The semaphore is still alive. Readjust the count of * waiting processes. */ if (sopptr->sem_op == 0) semptr->semzcnt--; else semptr->semncnt--; } done: /* * Process any SEM_UNDO requests. */ if (do_undos) { for (i = 0; i < 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(p, &suptr, 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(p, &suptr, semid, sops[j].sem_num, adjval) != 0) panic("semop - can't undo undos"); } for (j = 0; j < nsops; j++) semaptr->sem_base[sops[j].sem_num].semval -= sops[j].sem_op; #ifdef SEM_DEBUG printf("eval = %d from semundo_adjust\n", eval); #endif return(eval); } /* loop through the sops */ } /* if (do_undos) */ /* We're definitely done - set the sempid's */ for (i = 0; i < nsops; i++) { sopptr = &sops[i]; semptr = &semaptr->sem_base[sopptr->sem_num]; semptr->sempid = p->p_pid; } /* Do a wakeup if any semaphore was up'd. */ if (do_wakeup) { #ifdef SEM_DEBUG printf("semop: doing wakeup\n"); #ifdef SEM_WAKEUP sem_wakeup((caddr_t)semaptr); #else wakeup((caddr_t)semaptr); #endif printf("semop: back from wakeup\n"); #else wakeup((caddr_t)semaptr); #endif } #ifdef SEM_DEBUG printf("semop: done\n"); #endif *retval = 0; return(0); } /* * Go through the undo structures for this process and apply the adjustments to * semaphores. */ semexit(p) struct proc *p; { register struct sem_undo *suptr; register struct sem_undo **supptr; /* * Go through the chain of undo vectors looking for one associated with * this process. */ for (supptr = &semu_list; (suptr = *supptr) != NULL; supptr = &suptr->un_next) { if (suptr->un_proc == p) break; } /* * There are a few possibilities to consider here ... * * 1) The semaphore facility isn't currently locked. In this case, * this call should proceed normally. * 2) The semaphore facility is locked by this process (i.e. the one * that is exiting). In this case, this call should proceed as * usual and the facility should be unlocked at the end of this * routine (since the locker is exiting). * 3) The semaphore facility is locked by some other process and this * process doesn't have an undo structure allocated for it. In this * case, this call should proceed normally (i.e. not accomplish * anything and, most importantly, not block since that is * unnecessary and could result in a LOT of processes blocking in * here if the facility is locked for a long time). * 4) The semaphore facility is locked by some other process and this * process has an undo structure allocated for it. In this case, * this call should block until the facility has been unlocked since * the holder of the lock may be examining this process's proc entry * (the ipcs utility does this when printing out the information * from the allocated sem undo elements). * * This leads to the conclusion that we should not block unless we * discover that the someone else has the semaphore facility locked and * this process has an undo structure. Let's do that... * * Note that we do this in a separate pass from the one that processes * any existing undo structure since we don't want to risk blocking at * that time (it would make the actual unlinking of the element from * the chain of allocated undo structures rather messy). */ /* * Does someone else hold the semaphore facility's lock? */ if (semlock_holder != NULL && semlock_holder != p) { /* * Yes (i.e. we are in case 3 or 4). * * If we didn't find an undo vector associated with this * process than we can just return (i.e. we are in case 3). * * Note that we know that someone else is holding the lock so * we don't even have to see if we're holding it... */ if (suptr == NULL) return; /* * We are in case 4. * * Go to sleep as long as someone else is locking the semaphore * facility (note that we won't get here if we are holding the * lock so we don't need to check for that possibility). */ while (semlock_holder != NULL) sleep((caddr_t)&semlock_holder, (PZERO - 4)); /* * Nobody is holding the facility (i.e. we are now in case 1). * We can proceed safely according to the argument outlined * above. * * We look up the undo vector again, in case the list changed * while we were asleep, and the parent is now different. */ for (supptr = &semu_list; (suptr = *supptr) != NULL; supptr = &suptr->un_next) { if (suptr->un_proc == p) break; } if (suptr == NULL) panic("semexit: undo vector disappeared"); } else { /* * No (i.e. we are in case 1 or 2). * * If there is no undo vector, skip to the end and unlock the * semaphore facility if necessary. */ if (suptr == NULL) goto unlock; } /* * We are now in case 1 or 2, and we have an undo vector for this * process. */ #ifdef SEM_DEBUG printf("proc @%p has undo structure with %d entries\n", p, suptr->un_cnt); #endif /* * If there are any active undo elements then process them. */ if (suptr->un_cnt > 0) { int ix; for (ix = 0; ix < suptr->un_cnt; ix++) { int semid = suptr->un_ent[ix].un_id; int semnum = suptr->un_ent[ix].un_num; int adjval = suptr->un_ent[ix].un_adjval; struct semid_ds *semaptr; semaptr = &sema[semid]; if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0) panic("semexit - semid not allocated"); if (semnum >= semaptr->sem_nsems) panic("semexit - semnum out of range"); #ifdef SEM_DEBUG printf("semexit: %p id=%d num=%d(adj=%d) ; sem=%d\n", suptr->un_proc, suptr->un_ent[ix].un_id, suptr->un_ent[ix].un_num, suptr->un_ent[ix].un_adjval, semaptr->sem_base[semnum].semval); #endif if (adjval < 0 && semaptr->sem_base[semnum].semval < -adjval) semaptr->sem_base[semnum].semval = 0; else semaptr->sem_base[semnum].semval += adjval; #ifdef SEM_WAKEUP sem_wakeup((caddr_t)semaptr); #else wakeup((caddr_t)semaptr); #endif #ifdef SEM_DEBUG printf("semexit: back from wakeup\n"); #endif } } /* * Deallocate the undo vector. */ #ifdef SEM_DEBUG printf("removing vector\n"); #endif suptr->un_proc = NULL; *supptr = suptr->un_next; unlock: /* * If the exiting process is holding the global semaphore facility * lock (i.e. we are in case 2) then release it. */ if (semlock_holder == p) { semlock_holder = NULL; wakeup((caddr_t)&semlock_holder); } } #if defined(COMPAT_10) && !defined(alpha) int compat_10_semsys(p, uap, retval) struct proc *p; struct compat_10_semsys_args /* { syscallarg(int) which; syscallarg(int) a2; syscallarg(int) a3; syscallarg(int) a4; syscallarg(int) a5; } */ *uap; register_t *retval; { struct __semctl_args /* { syscallarg(int) semid; syscallarg(int) semnum; syscallarg(int) cmd; syscallarg(union semun *) arg; } */ __semctl_args; struct semget_args /* { syscallarg(key_t) key; syscallarg(int) nsems; syscallarg(int) semflg; } */ semget_args; struct semop_args /* { syscallarg(int) semid; syscallarg(struct sembuf *) sops; syscallarg(u_int) nsops; } */ semop_args; struct semconfig_args /* { syscallarg(int) flag; } */ semconfig_args; switch (SCARG(uap, which)) { case 0: /* __semctl() */ SCARG(&__semctl_args, semid) = SCARG(uap, a2); SCARG(&__semctl_args, semnum) = SCARG(uap, a3); SCARG(&__semctl_args, cmd) = SCARG(uap, a4); SCARG(&__semctl_args, arg) = (union semun *)SCARG(uap, a5); return (__semctl(p, &__semctl_args, retval)); case 1: /* semget() */ SCARG(&semget_args, key) = SCARG(uap, a2); SCARG(&semget_args, nsems) = SCARG(uap, a3); SCARG(&semget_args, semflg) = SCARG(uap, a4); return (semget(p, &semget_args, retval)); case 2: /* semop() */ SCARG(&semop_args, semid) = SCARG(uap, a2); SCARG(&semop_args, sops) = (struct sembuf *)SCARG(uap, a3); SCARG(&semop_args, nsops) = SCARG(uap, a4); return (semop(p, &semop_args, retval)); case 3: /* semconfig() */ SCARG(&semconfig_args, flag) = SCARG(uap, a2); return (semconfig(p, &semconfig_args, retval)); default: return (EINVAL); } } #endif /* defined(COMPAT_10) && !defined(alpha) */