![[BACK]](/icons/back.gif){kind=icon}
Return to sysv_sem.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to sysv_sem.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: sysv_sem.c,v 1.33 2006/08/10 17:03:48 millert Exp $ */
2: /* $NetBSD: sysv_sem.c,v 1.26 1996/02/09 19:00:25 christos Exp $ */
3:
4: /*
5: * Copyright (c) 2002,2003 Todd C. Miller <Todd.Miller@courtesan.com>
6: *
7: * Permission to use, copy, modify, and distribute this software for any
8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
10: *
11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18: *
19: * Sponsored in part by the Defense Advanced Research Projects
20: * Agency (DARPA) and Air Force Research Laboratory, Air Force
21: * Materiel Command, USAF, under agreement number F39502-99-1-0512.
22: */
23: /*
24: * Implementation of SVID semaphores
25: *
26: * Author: Daniel Boulet
27: *
28: * This software is provided ``AS IS'' without any warranties of any kind.
29: */
30:
31: #include <sys/param.h>
32: #include <sys/systm.h>
33: #include <sys/kernel.h>
34: #include <sys/proc.h>
35: #include <sys/sem.h>
36: #include <sys/sysctl.h>
37: #include <sys/malloc.h>
38: #include <sys/pool.h>
39:
40: #include <sys/mount.h>
41: #include <sys/syscallargs.h>
42:
43: /* SVID defines EIDRM but BSD does not */
44: #ifndef EIDRM
45: #define EIDRM EINVAL
46: #endif
47:
48: #ifdef SEM_DEBUG
49: #define DPRINTF(x) printf x
50: #else
51: #define DPRINTF(x)
52: #endif
53:
54: int semtot = 0;
55: int semutot = 0;
56: struct semid_ds **sema; /* semaphore id list */
57: SLIST_HEAD(, sem_undo) semu_list; /* list of undo structures */
58: struct pool sema_pool; /* pool for struct semid_ds */
59: struct pool semu_pool; /* pool for struct sem_undo (SEMUSZ) */
60: unsigned short *semseqs; /* array of sem sequence numbers */
61:
62: struct sem_undo *semu_alloc(struct proc *);
63: int semundo_adjust(struct proc *, struct sem_undo **, int, int, int);
64: void semundo_clear(int, int);
65:
66: void
67: seminit(void)
68: {
69:
70: pool_init(&sema_pool, sizeof(struct semid_ds), 0, 0, 0, "semapl",
71: &pool_allocator_nointr);
72: pool_init(&semu_pool, SEMUSZ, 0, 0, 0, "semupl",
73: &pool_allocator_nointr);
74: sema = malloc(seminfo.semmni * sizeof(struct semid_ds *),
75: M_SEM, M_WAITOK);
76: bzero(sema, seminfo.semmni * sizeof(struct semid_ds *));
77: semseqs = malloc(seminfo.semmni * sizeof(unsigned short),
78: M_SEM, M_WAITOK);
79: bzero(semseqs, seminfo.semmni * sizeof(unsigned short));
80: SLIST_INIT(&semu_list);
81: }
82:
83: /*
84: * Allocate a new sem_undo structure for a process
85: * (returns ptr to structure or NULL if no more room)
86: */
87: struct sem_undo *
88: semu_alloc(struct proc *p)
89: {
90: struct sem_undo *suptr, *sutmp;
91:
92: if (semutot == seminfo.semmnu)
93: return (NULL); /* no space */
94:
95: /*
96: * Allocate a semu w/o waiting if possible.
97: * If we do have to wait, we must check to verify that a semu
98: * with un_proc == p has not been allocated in the meantime.
99: */
100: semutot++;
101: if ((suptr = pool_get(&semu_pool, 0)) == NULL) {
102: sutmp = pool_get(&semu_pool, PR_WAITOK);
103: SLIST_FOREACH(suptr, &semu_list, un_next) {
104: if (suptr->un_proc == p) {
105: pool_put(&semu_pool, sutmp);
106: semutot--;
107: return (suptr);
108: }
109: }
110: suptr = sutmp;
111: }
112: suptr->un_cnt = 0;
113: suptr->un_proc = p;
114: SLIST_INSERT_HEAD(&semu_list, suptr, un_next);
115: return (suptr);
116: }
117:
118: /*
119: * Adjust a particular entry for a particular proc
120: */
121: int
122: semundo_adjust(struct proc *p, struct sem_undo **supptr, int semid, int semnum,
123: int adjval)
124: {
125: struct sem_undo *suptr;
126: struct undo *sunptr;
127: int i;
128:
129: /*
130: * Look for and remember the sem_undo if the caller doesn't provide it.
131: */
132: suptr = *supptr;
133: if (suptr == NULL) {
134: SLIST_FOREACH(suptr, &semu_list, un_next) {
135: if (suptr->un_proc == p) {
136: *supptr = suptr;
137: break;
138: }
139: }
140: if (suptr == NULL) {
141: if (adjval == 0)
142: return (0);
143: suptr = semu_alloc(p);
144: if (suptr == NULL)
145: return (ENOSPC);
146: *supptr = suptr;
147: }
148: }
149:
150: /*
151: * Look for the requested entry and adjust it
152: * (delete if adjval becomes 0).
153: */
154: sunptr = &suptr->un_ent[0];
155: for (i = 0; i < suptr->un_cnt; i++, sunptr++) {
156: if (sunptr->un_id != semid || sunptr->un_num != semnum)
157: continue;
158: if (adjval == 0)
159: sunptr->un_adjval = 0;
160: else
161: sunptr->un_adjval += adjval;
162: if (sunptr->un_adjval != 0)
163: return (0);
164:
165: if (--suptr->un_cnt == 0) {
166: SLIST_REMOVE(&semu_list, suptr, sem_undo, un_next);
167: pool_put(&semu_pool, suptr);
168: semutot--;
169: } else if (i < suptr->un_cnt)
170: suptr->un_ent[i] =
171: suptr->un_ent[suptr->un_cnt];
172: return (0);
173: }
174:
175: /* Didn't find the right entry - create it */
176: if (adjval == 0)
177: return (0);
178: if (suptr->un_cnt == SEMUME)
179: return (EINVAL);
180:
181: sunptr = &suptr->un_ent[suptr->un_cnt];
182: suptr->un_cnt++;
183: sunptr->un_adjval = adjval;
184: sunptr->un_id = semid;
185: sunptr->un_num = semnum;
186: return (0);
187: }
188:
189: void
190: semundo_clear(int semid, int semnum)
191: {
192: struct sem_undo *suptr = SLIST_FIRST(&semu_list);
193: struct sem_undo *suprev = SLIST_END(&semu_list);
194: struct undo *sunptr;
195: int i;
196:
197: while (suptr != SLIST_END(&semu_list)) {
198: sunptr = &suptr->un_ent[0];
199: for (i = 0; i < suptr->un_cnt; i++, sunptr++) {
200: if (sunptr->un_id == semid) {
201: if (semnum == -1 || sunptr->un_num == semnum) {
202: suptr->un_cnt--;
203: if (i < suptr->un_cnt) {
204: suptr->un_ent[i] =
205: suptr->un_ent[suptr->un_cnt];
206: i--, sunptr--;
207: }
208: }
209: if (semnum != -1)
210: break;
211: }
212: }
213: if (suptr->un_cnt == 0) {
214: struct sem_undo *sutmp = suptr;
215:
216: if (suptr == SLIST_FIRST(&semu_list))
217: SLIST_REMOVE_HEAD(&semu_list, un_next);
218: else
219: SLIST_REMOVE_NEXT(&semu_list, suprev, un_next);
220: suptr = SLIST_NEXT(suptr, un_next);
221: pool_put(&semu_pool, sutmp);
222: semutot--;
223: } else {
224: suprev = suptr;
225: suptr = SLIST_NEXT(suptr, un_next);
226: }
227: }
228: }
229:
230: int
231: sys___semctl(struct proc *p, void *v, register_t *retval)
232: {
233: struct sys___semctl_args /* {
234: syscallarg(int) semid;
235: syscallarg(int) semnum;
236: syscallarg(int) cmd;
237: syscallarg(union semun *) arg;
238: } */ *uap = v;
239: union semun arg;
240: int error = 0, cmd = SCARG(uap, cmd);
241:
242: switch (cmd) {
243: case IPC_SET:
244: case IPC_STAT:
245: case GETALL:
246: case SETVAL:
247: case SETALL:
248: error = copyin(SCARG(uap, arg), &arg, sizeof(arg));
249: break;
250: }
251: if (error == 0) {
252: error = semctl1(p, SCARG(uap, semid), SCARG(uap, semnum),
253: cmd, &arg, retval, copyin, copyout);
254: }
255: return (error);
256: }
257:
258: int
259: semctl1(struct proc *p, int semid, int semnum, int cmd, union semun *arg,
260: register_t *retval, int (*ds_copyin)(const void *, void *, size_t),
261: int (*ds_copyout)(const void *, void *, size_t))
262: {
263: struct ucred *cred = p->p_ucred;
264: int i, ix, error = 0;
265: struct semid_ds sbuf;
266: struct semid_ds *semaptr;
267:
268: DPRINTF(("call to semctl(%d, %d, %d, %p)\n", semid, semnum, cmd, arg));
269:
270: ix = IPCID_TO_IX(semid);
271: if (ix < 0 || ix >= seminfo.semmni)
272: return (EINVAL);
273:
274: if ((semaptr = sema[ix]) == NULL ||
275: semaptr->sem_perm.seq != IPCID_TO_SEQ(semid))
276: return (EINVAL);
277:
278: switch (cmd) {
279: case IPC_RMID:
280: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)) != 0)
281: return (error);
282: semaptr->sem_perm.cuid = cred->cr_uid;
283: semaptr->sem_perm.uid = cred->cr_uid;
284: semtot -= semaptr->sem_nsems;
285: free(semaptr->sem_base, M_SEM);
286: pool_put(&sema_pool, semaptr);
287: sema[ix] = NULL;
288: semundo_clear(ix, -1);
289: wakeup(&sema[ix]);
290: break;
291:
292: case IPC_SET:
293: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)))
294: return (error);
295: if ((error = ds_copyin(arg->buf, &sbuf, sizeof(sbuf))) != 0)
296: return (error);
297: semaptr->sem_perm.uid = sbuf.sem_perm.uid;
298: semaptr->sem_perm.gid = sbuf.sem_perm.gid;
299: semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) |
300: (sbuf.sem_perm.mode & 0777);
301: semaptr->sem_ctime = time_second;
302: break;
303:
304: case IPC_STAT:
305: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
306: return (error);
307: error = ds_copyout(semaptr, arg->buf, sizeof(struct semid_ds));
308: break;
309:
310: case GETNCNT:
311: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
312: return (error);
313: if (semnum < 0 || semnum >= semaptr->sem_nsems)
314: return (EINVAL);
315: *retval = semaptr->sem_base[semnum].semncnt;
316: break;
317:
318: case GETPID:
319: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
320: return (error);
321: if (semnum < 0 || semnum >= semaptr->sem_nsems)
322: return (EINVAL);
323: *retval = semaptr->sem_base[semnum].sempid;
324: break;
325:
326: case GETVAL:
327: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
328: return (error);
329: if (semnum < 0 || semnum >= semaptr->sem_nsems)
330: return (EINVAL);
331: *retval = semaptr->sem_base[semnum].semval;
332: break;
333:
334: case GETALL:
335: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
336: return (error);
337: for (i = 0; i < semaptr->sem_nsems; i++) {
338: error = ds_copyout(&semaptr->sem_base[i].semval,
339: &arg->array[i], sizeof(arg->array[0]));
340: if (error != 0)
341: break;
342: }
343: break;
344:
345: case GETZCNT:
346: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
347: return (error);
348: if (semnum < 0 || semnum >= semaptr->sem_nsems)
349: return (EINVAL);
350: *retval = semaptr->sem_base[semnum].semzcnt;
351: break;
352:
353: case SETVAL:
354: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
355: return (error);
356: if (semnum < 0 || semnum >= semaptr->sem_nsems)
357: return (EINVAL);
358: semaptr->sem_base[semnum].semval = arg->val;
359: semundo_clear(ix, semnum);
360: wakeup(&sema[ix]);
361: break;
362:
363: case SETALL:
364: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
365: return (error);
366: for (i = 0; i < semaptr->sem_nsems; i++) {
367: error = ds_copyin(&arg->array[i],
368: &semaptr->sem_base[i].semval,
369: sizeof(arg->array[0]));
370: if (error != 0)
371: break;
372: }
373: semundo_clear(ix, -1);
374: wakeup(&sema[ix]);
375: break;
376:
377: default:
378: return (EINVAL);
379: }
380:
381: return (error);
382: }
383:
384: int
385: sys_semget(struct proc *p, void *v, register_t *retval)
386: {
387: struct sys_semget_args /* {
388: syscallarg(key_t) key;
389: syscallarg(int) nsems;
390: syscallarg(int) semflg;
391: } */ *uap = v;
392: int semid, error;
393: int key = SCARG(uap, key);
394: int nsems = SCARG(uap, nsems);
395: int semflg = SCARG(uap, semflg);
396: struct semid_ds *semaptr, *semaptr_new = NULL;
397: struct ucred *cred = p->p_ucred;
398:
399: DPRINTF(("semget(0x%x, %d, 0%o)\n", key, nsems, semflg));
400:
401: /*
402: * Preallocate space for the new semaphore. If we are going
403: * to sleep, we want to sleep now to eliminate any race
404: * condition in allocating a semaphore with a specific key.
405: */
406: if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) {
407: if (nsems <= 0 || nsems > seminfo.semmsl) {
408: DPRINTF(("nsems out of range (0<%d<=%d)\n", nsems,
409: seminfo.semmsl));
410: return (EINVAL);
411: }
412: if (nsems > seminfo.semmns - semtot) {
413: DPRINTF(("not enough semaphores left (need %d, got %d)\n",
414: nsems, seminfo.semmns - semtot));
415: return (ENOSPC);
416: }
417: semaptr_new = pool_get(&sema_pool, PR_WAITOK);
418: semaptr_new->sem_base = malloc(nsems * sizeof(struct sem),
419: M_SEM, M_WAITOK);
420: bzero(semaptr_new->sem_base, nsems * sizeof(struct sem));
421: }
422:
423: if (key != IPC_PRIVATE) {
424: for (semid = 0, semaptr = NULL; semid < seminfo.semmni; semid++) {
425: if ((semaptr = sema[semid]) != NULL &&
426: semaptr->sem_perm.key == key) {
427: DPRINTF(("found public key\n"));
428: if ((error = ipcperm(cred, &semaptr->sem_perm,
429: semflg & 0700)))
430: goto error;
431: if (nsems > 0 && semaptr->sem_nsems < nsems) {
432: DPRINTF(("too small\n"));
433: error = EINVAL;
434: goto error;
435: }
436: if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) {
437: DPRINTF(("not exclusive\n"));
438: error = EEXIST;
439: goto error;
440: }
441: goto found;
442: }
443: }
444: }
445:
446: DPRINTF(("need to allocate the semid_ds\n"));
447: if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) {
448: for (semid = 0; semid < seminfo.semmni; semid++) {
449: if ((semaptr = sema[semid]) == NULL)
450: break;
451: }
452: if (semid == seminfo.semmni) {
453: DPRINTF(("no more semid_ds's available\n"));
454: error = ENOSPC;
455: goto error;
456: }
457: DPRINTF(("semid %d is available\n", semid));
458: semaptr_new->sem_perm.key = key;
459: semaptr_new->sem_perm.cuid = cred->cr_uid;
460: semaptr_new->sem_perm.uid = cred->cr_uid;
461: semaptr_new->sem_perm.cgid = cred->cr_gid;
462: semaptr_new->sem_perm.gid = cred->cr_gid;
463: semaptr_new->sem_perm.mode = (semflg & 0777);
464: semaptr_new->sem_perm.seq = semseqs[semid] =
465: (semseqs[semid] + 1) & 0x7fff;
466: semaptr_new->sem_nsems = nsems;
467: semaptr_new->sem_otime = 0;
468: semaptr_new->sem_ctime = time_second;
469: sema[semid] = semaptr_new;
470: semtot += nsems;
471: } else {
472: DPRINTF(("didn't find it and wasn't asked to create it\n"));
473: return (ENOENT);
474: }
475:
476: found:
477: *retval = IXSEQ_TO_IPCID(semid, sema[semid]->sem_perm);
478: return (0);
479: error:
480: if (semaptr_new != NULL) {
481: free(semaptr_new->sem_base, M_SEM);
482: pool_put(&sema_pool, semaptr_new);
483: }
484: return (error);
485: }
486:
487: int
488: sys_semop(struct proc *p, void *v, register_t *retval)
489: {
490: struct sys_semop_args /* {
491: syscallarg(int) semid;
492: syscallarg(struct sembuf *) sops;
493: syscallarg(size_t) nsops;
494: } */ *uap = v;
495: #define NSOPS 8
496: struct sembuf sopbuf[NSOPS];
497: int semid = SCARG(uap, semid);
498: size_t nsops = SCARG(uap, nsops);
499: struct sembuf *sops;
500: struct semid_ds *semaptr;
501: struct sembuf *sopptr = NULL;
502: struct sem *semptr = NULL;
503: struct sem_undo *suptr = NULL;
504: struct ucred *cred = p->p_ucred;
505: size_t i, j;
506: int do_wakeup, do_undos, error;
507:
508: DPRINTF(("call to semop(%d, %p, %lu)\n", semid, SCARG(uap, sops),
509: (u_long)nsops));
510:
511: semid = IPCID_TO_IX(semid); /* Convert back to zero origin */
512:
513: if (semid < 0 || semid >= seminfo.semmni)
514: return (EINVAL);
515:
516: if ((semaptr = sema[semid]) == NULL ||
517: semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid)))
518: return (EINVAL);
519:
520: if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W))) {
521: DPRINTF(("error = %d from ipaccess\n", error));
522: return (error);
523: }
524:
525: if (nsops == 0) {
526: *retval = 0;
527: return (0);
528: } else if (nsops > (size_t)seminfo.semopm) {
529: DPRINTF(("too many sops (max=%d, nsops=%lu)\n", seminfo.semopm,
530: (u_long)nsops));
531: return (E2BIG);
532: }
533:
534: if (nsops <= NSOPS)
535: sops = sopbuf;
536: else
537: sops = malloc(nsops * sizeof(struct sembuf), M_SEM, M_WAITOK);
538: error = copyin(SCARG(uap, sops), sops, nsops * sizeof(struct sembuf));
539: if (error != 0) {
540: DPRINTF(("error = %d from copyin(%p, %p, %u)\n", error,
541: SCARG(uap, sops), &sops, nsops * sizeof(struct sembuf)));
542: goto done2;
543: }
544:
545: /*
546: * Loop trying to satisfy the vector of requests.
547: * If we reach a point where we must wait, any requests already
548: * performed are rolled back and we go to sleep until some other
549: * process wakes us up. At this point, we start all over again.
550: *
551: * This ensures that from the perspective of other tasks, a set
552: * of requests is atomic (never partially satisfied).
553: */
554: do_undos = 0;
555:
556: for (;;) {
557: do_wakeup = 0;
558:
559: for (i = 0; i < nsops; i++) {
560: sopptr = &sops[i];
561:
562: if (sopptr->sem_num >= semaptr->sem_nsems) {
563: error = EFBIG;
564: goto done2;
565: }
566:
567: semptr = &semaptr->sem_base[sopptr->sem_num];
568:
569: DPRINTF(("semop: semaptr=%x, sem_base=%x, semptr=%x, sem[%d]=%d : op=%d, flag=%s\n",
570: semaptr, semaptr->sem_base, semptr,
571: sopptr->sem_num, semptr->semval, sopptr->sem_op,
572: (sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait"));
573:
574: if (sopptr->sem_op < 0) {
575: if ((int)(semptr->semval +
576: sopptr->sem_op) < 0) {
577: DPRINTF(("semop: can't do it now\n"));
578: break;
579: } else {
580: semptr->semval += sopptr->sem_op;
581: if (semptr->semval == 0 &&
582: semptr->semzcnt > 0)
583: do_wakeup = 1;
584: }
585: if (sopptr->sem_flg & SEM_UNDO)
586: do_undos = 1;
587: } else if (sopptr->sem_op == 0) {
588: if (semptr->semval > 0) {
589: DPRINTF(("semop: not zero now\n"));
590: break;
591: }
592: } else {
593: if (semptr->semncnt > 0)
594: do_wakeup = 1;
595: semptr->semval += sopptr->sem_op;
596: if (sopptr->sem_flg & SEM_UNDO)
597: do_undos = 1;
598: }
599: }
600:
601: /*
602: * Did we get through the entire vector?
603: */
604: if (i >= nsops)
605: goto done;
606:
607: /*
608: * No ... rollback anything that we've already done
609: */
610: DPRINTF(("semop: rollback 0 through %d\n", i - 1));
611: for (j = 0; j < i; j++)
612: semaptr->sem_base[sops[j].sem_num].semval -=
613: sops[j].sem_op;
614:
615: /*
616: * If the request that we couldn't satisfy has the
617: * NOWAIT flag set then return with EAGAIN.
618: */
619: if (sopptr->sem_flg & IPC_NOWAIT) {
620: error = EAGAIN;
621: goto done2;
622: }
623:
624: if (sopptr->sem_op == 0)
625: semptr->semzcnt++;
626: else
627: semptr->semncnt++;
628:
629: DPRINTF(("semop: good night!\n"));
630: error = tsleep(&sema[semid], PLOCK | PCATCH,
631: "semwait", 0);
632: DPRINTF(("semop: good morning (error=%d)!\n", error));
633:
634: suptr = NULL; /* sem_undo may have been reallocated */
635:
636: /*
637: * Make sure that the semaphore still exists
638: */
639: if (sema[semid] == NULL ||
640: semaptr->sem_perm.seq != IPCID_TO_SEQ(SCARG(uap, semid))) {
641: error = EIDRM;
642: goto done2;
643: }
644:
645: /*
646: * The semaphore is still alive. Readjust the count of
647: * waiting processes.
648: */
649: if (sopptr->sem_op == 0)
650: semptr->semzcnt--;
651: else
652: semptr->semncnt--;
653:
654: /*
655: * Is it really morning, or was our sleep interrupted?
656: * (Delayed check of tsleep() return code because we
657: * need to decrement sem[nz]cnt either way.)
658: */
659: if (error != 0) {
660: error = EINTR;
661: goto done2;
662: }
663: DPRINTF(("semop: good morning!\n"));
664: }
665:
666: done:
667: /*
668: * Process any SEM_UNDO requests.
669: */
670: if (do_undos) {
671: for (i = 0; i < nsops; i++) {
672: /*
673: * We only need to deal with SEM_UNDO's for non-zero
674: * op's.
675: */
676: int adjval;
677:
678: if ((sops[i].sem_flg & SEM_UNDO) == 0)
679: continue;
680: adjval = sops[i].sem_op;
681: if (adjval == 0)
682: continue;
683: error = semundo_adjust(p, &suptr, semid,
684: sops[i].sem_num, -adjval);
685: if (error == 0)
686: continue;
687:
688: /*
689: * Uh-Oh! We ran out of either sem_undo's or undo's.
690: * Rollback the adjustments to this point and then
691: * rollback the semaphore ups and down so we can return
692: * with an error with all structures restored. We
693: * rollback the undo's in the exact reverse order that
694: * we applied them. This guarantees that we won't run
695: * out of space as we roll things back out.
696: */
697: if (i != 0) {
698: for (j = i - 1; j >= 0; j--) {
699: if ((sops[j].sem_flg & SEM_UNDO) == 0)
700: continue;
701: adjval = sops[j].sem_op;
702: if (adjval == 0)
703: continue;
704: if (semundo_adjust(p, &suptr, semid,
705: sops[j].sem_num, adjval) != 0)
706: panic("semop - can't undo undos");
707: }
708: }
709:
710: for (j = 0; j < nsops; j++)
711: semaptr->sem_base[sops[j].sem_num].semval -=
712: sops[j].sem_op;
713:
714: DPRINTF(("error = %d from semundo_adjust\n", error));
715: goto done2;
716: } /* loop through the sops */
717: } /* if (do_undos) */
718:
719: /* We're definitely done - set the sempid's */
720: for (i = 0; i < nsops; i++) {
721: sopptr = &sops[i];
722: semptr = &semaptr->sem_base[sopptr->sem_num];
723: semptr->sempid = p->p_pid;
724: }
725:
726: /* Do a wakeup if any semaphore was up'd. */
727: if (do_wakeup) {
728: DPRINTF(("semop: doing wakeup\n"));
729: wakeup(&sema[semid]);
730: DPRINTF(("semop: back from wakeup\n"));
731: }
732: DPRINTF(("semop: done\n"));
733: *retval = 0;
734: done2:
735: if (sops != sopbuf)
736: free(sops, M_SEM);
737: return (error);
738: }
739:
740: /*
741: * Go through the undo structures for this process and apply the adjustments to
742: * semaphores.
743: */
744: void
745: semexit(struct proc *p)
746: {
747: struct sem_undo *suptr;
748: struct sem_undo **supptr;
749:
750: /*
751: * Go through the chain of undo vectors looking for one associated with
752: * this process.
753: */
754: SLIST_FOREACH_PREVPTR(suptr, supptr, &semu_list, un_next) {
755: if (suptr->un_proc == p)
756: break;
757: }
758:
759: /*
760: * If there is no undo vector, skip to the end.
761: */
762: if (suptr == NULL)
763: return;
764:
765: /*
766: * We now have an undo vector for this process.
767: */
768: DPRINTF(("proc @%p has undo structure with %d entries\n", p,
769: suptr->un_cnt));
770:
771: /*
772: * If there are any active undo elements then process them.
773: */
774: if (suptr->un_cnt > 0) {
775: int ix;
776:
777: for (ix = 0; ix < suptr->un_cnt; ix++) {
778: int semid = suptr->un_ent[ix].un_id;
779: int semnum = suptr->un_ent[ix].un_num;
780: int adjval = suptr->un_ent[ix].un_adjval;
781: struct semid_ds *semaptr;
782:
783: if ((semaptr = sema[semid]) == NULL)
784: panic("semexit - semid not allocated");
785: if (semnum >= semaptr->sem_nsems)
786: panic("semexit - semnum out of range");
787:
788: DPRINTF(("semexit: %p id=%d num=%d(adj=%d) ; sem=%d\n",
789: suptr->un_proc, suptr->un_ent[ix].un_id,
790: suptr->un_ent[ix].un_num,
791: suptr->un_ent[ix].un_adjval,
792: semaptr->sem_base[semnum].semval));
793:
794: if (adjval < 0 &&
795: semaptr->sem_base[semnum].semval < -adjval)
796: semaptr->sem_base[semnum].semval = 0;
797: else
798: semaptr->sem_base[semnum].semval += adjval;
799:
800: wakeup(&sema[semid]);
801: DPRINTF(("semexit: back from wakeup\n"));
802: }
803: }
804:
805: /*
806: * Deallocate the undo vector.
807: */
808: DPRINTF(("removing vector\n"));
809: *supptr = SLIST_NEXT(suptr, un_next);
810: pool_put(&semu_pool, suptr);
811: semutot--;
812: }
813:
814: /*
815: * Userland access to struct seminfo.
816: */
817: int
818: sysctl_sysvsem(int *name, u_int namelen, void *oldp, size_t *oldlenp,
819: void *newp, size_t newlen)
820: {
821: int error, val;
822: struct semid_ds **sema_new;
823: unsigned short *newseqs;
824:
825: if (namelen != 2) {
826: switch (name[0]) {
827: case KERN_SEMINFO_SEMMNI:
828: case KERN_SEMINFO_SEMMNS:
829: case KERN_SEMINFO_SEMMNU:
830: case KERN_SEMINFO_SEMMSL:
831: case KERN_SEMINFO_SEMOPM:
832: case KERN_SEMINFO_SEMUME:
833: case KERN_SEMINFO_SEMUSZ:
834: case KERN_SEMINFO_SEMVMX:
835: case KERN_SEMINFO_SEMAEM:
836: break;
837: default:
838: return (ENOTDIR); /* overloaded */
839: }
840: }
841:
842: switch (name[0]) {
843: case KERN_SEMINFO_SEMMNI:
844: val = seminfo.semmni;
845: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
846: val == seminfo.semmni)
847: return (error);
848:
849: if (val < seminfo.semmni || val > 0xffff)
850: return (EINVAL);
851:
852: /* Expand semsegs and semseqs arrays */
853: sema_new = malloc(val * sizeof(struct semid_ds *),
854: M_SEM, M_WAITOK);
855: bcopy(sema, sema_new,
856: seminfo.semmni * sizeof(struct semid_ds *));
857: bzero(sema_new + seminfo.semmni,
858: (val - seminfo.semmni) * sizeof(struct semid_ds *));
859: newseqs = malloc(val * sizeof(unsigned short), M_SEM, M_WAITOK);
860: bcopy(semseqs, newseqs,
861: seminfo.semmni * sizeof(unsigned short));
862: bzero(newseqs + seminfo.semmni,
863: (val - seminfo.semmni) * sizeof(unsigned short));
864: free(sema, M_SEM);
865: free(semseqs, M_SEM);
866: sema = sema_new;
867: semseqs = newseqs;
868: seminfo.semmni = val;
869: return (0);
870: case KERN_SEMINFO_SEMMNS:
871: val = seminfo.semmns;
872: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
873: val == seminfo.semmns)
874: return (error);
875: if (val < seminfo.semmns || val > 0xffff)
876: return (EINVAL); /* can't decrease semmns */
877: seminfo.semmns = val;
878: return (0);
879: case KERN_SEMINFO_SEMMNU:
880: val = seminfo.semmnu;
881: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
882: val == seminfo.semmnu)
883: return (error);
884: if (val < seminfo.semmnu)
885: return (EINVAL); /* can't decrease semmnu */
886: seminfo.semmnu = val;
887: return (0);
888: case KERN_SEMINFO_SEMMSL:
889: val = seminfo.semmsl;
890: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
891: val == seminfo.semmsl)
892: return (error);
893: if (val < seminfo.semmsl || val > 0xffff)
894: return (EINVAL); /* can't decrease semmsl */
895: seminfo.semmsl = val;
896: return (0);
897: case KERN_SEMINFO_SEMOPM:
898: val = seminfo.semopm;
899: if ((error = sysctl_int(oldp, oldlenp, newp, newlen, &val)) ||
900: val == seminfo.semopm)
901: return (error);
902: if (val <= 0)
903: return (EINVAL); /* semopm must be >= 1 */
904: seminfo.semopm = val;
905: return (0);
906: case KERN_SEMINFO_SEMUME:
907: return (sysctl_rdint(oldp, oldlenp, newp, seminfo.semume));
908: case KERN_SEMINFO_SEMUSZ:
909: return (sysctl_rdint(oldp, oldlenp, newp, seminfo.semusz));
910: case KERN_SEMINFO_SEMVMX:
911: return (sysctl_rdint(oldp, oldlenp, newp, seminfo.semvmx));
912: case KERN_SEMINFO_SEMAEM:
913: return (sysctl_rdint(oldp, oldlenp, newp, seminfo.semaem));
914: default:
915: return (EOPNOTSUPP);
916: }
917: /* NOTREACHED */
918: }