FreeBSD/Linux Kernel Cross Reference
sys/kern/sysv_sem.c
1 /* $NetBSD: sysv_sem.c,v 1.53 2004/03/23 13:22:04 junyoung Exp $ */
2
3 /*-
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 /*
41 * Implementation of SVID semaphores
42 *
43 * Author: Daniel Boulet
44 *
45 * This software is provided ``AS IS'' without any warranties of any kind.
46 */
47
48 #include <sys/cdefs.h>
49 __KERNEL_RCSID(0, "$NetBSD: sysv_sem.c,v 1.53 2004/03/23 13:22:04 junyoung Exp $");
50
51 #define SYSVSEM
52
53 #include <sys/param.h>
54 #include <sys/kernel.h>
55 #include <sys/sem.h>
56 #include <sys/sysctl.h>
57 #include <sys/mount.h> /* XXX for <sys/syscallargs.h> */
58 #include <sys/sa.h>
59 #include <sys/syscallargs.h>
60
61 static int semtot = 0;
62 struct semid_ds *sema; /* semaphore id pool */
63 static struct __sem *sem; /* semaphore pool */
64 static struct sem_undo *semu_list; /* list of active undo structures */
65 static int *semu; /* undo structure pool */
66
67 #ifdef SEM_DEBUG
68 #define SEM_PRINTF(a) printf a
69 #else
70 #define SEM_PRINTF(a)
71 #endif
72
73 struct sem_undo *semu_alloc(struct proc *);
74 int semundo_adjust(struct proc *, struct sem_undo **, int, int, int);
75 void semundo_clear(int, int);
76
77 /*
78 * XXXSMP Once we go MP, there needs to be a lock for the semaphore system.
79 * Until then, we're saved by being a non-preemptive kernel.
80 */
81
82 void
83 seminit()
84 {
85 int i, sz;
86 vaddr_t v;
87
88 /* Allocate pageable memory for our structures */
89 sz = seminfo.semmni * sizeof(struct semid_ds) +
90 seminfo.semmns * sizeof(struct __sem) +
91 seminfo.semmnu * seminfo.semusz;
92 if ((v = uvm_km_zalloc(kernel_map, round_page(sz))) == 0)
93 panic("sysv_sem: cannot allocate memory");
94 sema = (void *)v;
95 sem = (void *)(sema + seminfo.semmni);
96 semu = (void *)(sem + seminfo.semmns);
97
98 for (i = 0; i < seminfo.semmni; i++) {
99 sema[i]._sem_base = 0;
100 sema[i].sem_perm.mode = 0;
101 }
102 for (i = 0; i < seminfo.semmnu; i++) {
103 struct sem_undo *suptr = SEMU(i);
104 suptr->un_proc = NULL;
105 }
106 semu_list = NULL;
107 exithook_establish(semexit, NULL);
108 }
109
110 /*
111 * Placebo.
112 */
113
114 int
115 sys_semconfig(l, v, retval)
116 struct lwp *l;
117 void *v;
118 register_t *retval;
119 {
120
121 *retval = 0;
122 return 0;
123 }
124
125 /*
126 * Allocate a new sem_undo structure for a process
127 * (returns ptr to structure or NULL if no more room)
128 */
129
130 struct sem_undo *
131 semu_alloc(p)
132 struct proc *p;
133 {
134 int i;
135 struct sem_undo *suptr;
136 struct sem_undo **supptr;
137 int attempt;
138
139 /*
140 * Try twice to allocate something.
141 * (we'll purge any empty structures after the first pass so
142 * two passes are always enough)
143 */
144
145 for (attempt = 0; attempt < 2; attempt++) {
146 /*
147 * Look for a free structure.
148 * Fill it in and return it if we find one.
149 */
150
151 for (i = 0; i < seminfo.semmnu; i++) {
152 suptr = SEMU(i);
153 if (suptr->un_proc == NULL) {
154 suptr->un_next = semu_list;
155 semu_list = suptr;
156 suptr->un_cnt = 0;
157 suptr->un_proc = p;
158 return (suptr);
159 }
160 }
161
162 /*
163 * We didn't find a free one, if this is the first attempt
164 * then try to free some structures.
165 */
166
167 if (attempt == 0) {
168 /* All the structures are in use - try to free some */
169 int did_something = 0;
170
171 supptr = &semu_list;
172 while ((suptr = *supptr) != NULL) {
173 if (suptr->un_cnt == 0) {
174 suptr->un_proc = NULL;
175 *supptr = suptr->un_next;
176 did_something = 1;
177 } else
178 supptr = &suptr->un_next;
179 }
180
181 /* If we didn't free anything then just give-up */
182 if (!did_something)
183 return (NULL);
184 } else {
185 /*
186 * The second pass failed even though we freed
187 * something after the first pass!
188 * This is IMPOSSIBLE!
189 */
190 panic("semu_alloc - second attempt failed");
191 }
192 }
193 return NULL;
194 }
195
196 /*
197 * Adjust a particular entry for a particular proc
198 */
199
200 int
201 semundo_adjust(p, supptr, semid, semnum, adjval)
202 struct proc *p;
203 struct sem_undo **supptr;
204 int semid, semnum;
205 int adjval;
206 {
207 struct sem_undo *suptr;
208 struct undo *sunptr;
209 int i;
210
211 /*
212 * Look for and remember the sem_undo if the caller doesn't
213 * provide it
214 */
215
216 suptr = *supptr;
217 if (suptr == NULL) {
218 for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next)
219 if (suptr->un_proc == p)
220 break;
221
222 if (suptr == NULL) {
223 suptr = semu_alloc(p);
224 if (suptr == NULL)
225 return (ENOSPC);
226 }
227 *supptr = suptr;
228 }
229
230 /*
231 * Look for the requested entry and adjust it (delete if
232 * adjval becomes 0).
233 */
234 sunptr = &suptr->un_ent[0];
235 for (i = 0; i < suptr->un_cnt; i++, sunptr++) {
236 if (sunptr->un_id != semid || sunptr->un_num != semnum)
237 continue;
238 sunptr->un_adjval += adjval;
239 if (sunptr->un_adjval == 0) {
240 suptr->un_cnt--;
241 if (i < suptr->un_cnt)
242 suptr->un_ent[i] =
243 suptr->un_ent[suptr->un_cnt];
244 }
245 return (0);
246 }
247
248 /* Didn't find the right entry - create it */
249 if (suptr->un_cnt == SEMUME)
250 return (EINVAL);
251
252 sunptr = &suptr->un_ent[suptr->un_cnt];
253 suptr->un_cnt++;
254 sunptr->un_adjval = adjval;
255 sunptr->un_id = semid;
256 sunptr->un_num = semnum;
257 return (0);
258 }
259
260 void
261 semundo_clear(semid, semnum)
262 int semid, semnum;
263 {
264 struct sem_undo *suptr;
265 struct undo *sunptr, *sunend;
266
267 for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next)
268 for (sunptr = &suptr->un_ent[0],
269 sunend = sunptr + suptr->un_cnt; sunptr < sunend;) {
270 if (sunptr->un_id == semid) {
271 if (semnum == -1 || sunptr->un_num == semnum) {
272 suptr->un_cnt--;
273 sunend--;
274 if (sunptr != sunend)
275 *sunptr = *sunend;
276 if (semnum != -1)
277 break;
278 else
279 continue;
280 }
281 }
282 sunptr++;
283 }
284 }
285
286 int
287 sys_____semctl13(l, v, retval)
288 struct lwp *l;
289 void *v;
290 register_t *retval;
291 {
292 struct sys_____semctl13_args /* {
293 syscallarg(int) semid;
294 syscallarg(int) semnum;
295 syscallarg(int) cmd;
296 syscallarg(union __semun *) arg;
297 } */ *uap = v;
298 struct proc *p = l->l_proc;
299 struct semid_ds sembuf;
300 int cmd, error;
301 void *pass_arg;
302 union __semun karg;
303
304 cmd = SCARG(uap, cmd);
305
306 switch (cmd) {
307 case IPC_SET:
308 case IPC_STAT:
309 pass_arg = &sembuf;
310 break;
311
312 case GETALL:
313 case SETVAL:
314 case SETALL:
315 pass_arg = &karg;
316 break;
317 default:
318 pass_arg = NULL;
319 break;
320 }
321
322 if (pass_arg) {
323 error = copyin(SCARG(uap, arg), &karg, sizeof(karg));
324 if (error)
325 return error;
326 if (cmd == IPC_SET) {
327 error = copyin(karg.buf, &sembuf, sizeof(sembuf));
328 if (error)
329 return (error);
330 }
331 }
332
333 error = semctl1(p, SCARG(uap, semid), SCARG(uap, semnum), cmd,
334 pass_arg, retval);
335
336 if (error == 0 && cmd == IPC_STAT)
337 error = copyout(&sembuf, karg.buf, sizeof(sembuf));
338
339 return (error);
340 }
341
342 int
343 semctl1(p, semid, semnum, cmd, v, retval)
344 struct proc *p;
345 int semid, semnum, cmd;
346 void *v;
347 register_t *retval;
348 {
349 struct ucred *cred = p->p_ucred;
350 union __semun *arg = v;
351 struct semid_ds *sembuf = v, *semaptr;
352 int i, error, ix;
353
354 SEM_PRINTF(("call to semctl(%d, %d, %d, %p)\n",
355 semid, semnum, cmd, v));
356
357 ix = IPCID_TO_IX(semid);
358 if (ix < 0 || ix >= seminfo.semmni)
359 return (EINVAL);
360
361 semaptr = &sema[ix];
362 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
363 semaptr->sem_perm._seq != IPCID_TO_SEQ(semid))
364 return (EINVAL);
365
366 switch (cmd) {
367 case IPC_RMID:
368 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)) != 0)
369 return (error);
370 semaptr->sem_perm.cuid = cred->cr_uid;
371 semaptr->sem_perm.uid = cred->cr_uid;
372 semtot -= semaptr->sem_nsems;
373 for (i = semaptr->_sem_base - sem; i < semtot; i++)
374 sem[i] = sem[i + semaptr->sem_nsems];
375 for (i = 0; i < seminfo.semmni; i++) {
376 if ((sema[i].sem_perm.mode & SEM_ALLOC) &&
377 sema[i]._sem_base > semaptr->_sem_base)
378 sema[i]._sem_base -= semaptr->sem_nsems;
379 }
380 semaptr->sem_perm.mode = 0;
381 semundo_clear(ix, -1);
382 wakeup(semaptr);
383 break;
384
385 case IPC_SET:
386 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)))
387 return (error);
388 semaptr->sem_perm.uid = sembuf->sem_perm.uid;
389 semaptr->sem_perm.gid = sembuf->sem_perm.gid;
390 semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) |
391 (sembuf->sem_perm.mode & 0777);
392 semaptr->sem_ctime = time.tv_sec;
393 break;
394
395 case IPC_STAT:
396 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
397 return (error);
398 memcpy(sembuf, semaptr, sizeof(struct semid_ds));
399 break;
400
401 case GETNCNT:
402 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
403 return (error);
404 if (semnum < 0 || semnum >= semaptr->sem_nsems)
405 return (EINVAL);
406 *retval = semaptr->_sem_base[semnum].semncnt;
407 break;
408
409 case GETPID:
410 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
411 return (error);
412 if (semnum < 0 || semnum >= semaptr->sem_nsems)
413 return (EINVAL);
414 *retval = semaptr->_sem_base[semnum].sempid;
415 break;
416
417 case GETVAL:
418 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
419 return (error);
420 if (semnum < 0 || semnum >= semaptr->sem_nsems)
421 return (EINVAL);
422 *retval = semaptr->_sem_base[semnum].semval;
423 break;
424
425 case GETALL:
426 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
427 return (error);
428 for (i = 0; i < semaptr->sem_nsems; i++) {
429 error = copyout(&semaptr->_sem_base[i].semval,
430 &arg->array[i], sizeof(arg->array[i]));
431 if (error != 0)
432 break;
433 }
434 break;
435
436 case GETZCNT:
437 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
438 return (error);
439 if (semnum < 0 || semnum >= semaptr->sem_nsems)
440 return (EINVAL);
441 *retval = semaptr->_sem_base[semnum].semzcnt;
442 break;
443
444 case SETVAL:
445 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
446 return (error);
447 if (semnum < 0 || semnum >= semaptr->sem_nsems)
448 return (EINVAL);
449 semaptr->_sem_base[semnum].semval = arg->val;
450 semundo_clear(ix, semnum);
451 wakeup(semaptr);
452 break;
453
454 case SETALL:
455 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
456 return (error);
457 for (i = 0; i < semaptr->sem_nsems; i++) {
458 error = copyin(&arg->array[i],
459 &semaptr->_sem_base[i].semval,
460 sizeof(arg->array[i]));
461 if (error != 0)
462 break;
463 }
464 semundo_clear(ix, -1);
465 wakeup(semaptr);
466 break;
467
468 default:
469 return (EINVAL);
470 }
471
472 return (error);
473 }
474
475 int
476 sys_semget(l, v, retval)
477 struct lwp *l;
478 void *v;
479 register_t *retval;
480 {
481 struct sys_semget_args /* {
482 syscallarg(key_t) key;
483 syscallarg(int) nsems;
484 syscallarg(int) semflg;
485 } */ *uap = v;
486 int semid, eval;
487 int key = SCARG(uap, key);
488 int nsems = SCARG(uap, nsems);
489 int semflg = SCARG(uap, semflg);
490 struct ucred *cred = l->l_proc->p_ucred;
491
492 SEM_PRINTF(("semget(0x%x, %d, 0%o)\n", key, nsems, semflg));
493
494 if (key != IPC_PRIVATE) {
495 for (semid = 0; semid < seminfo.semmni; semid++) {
496 if ((sema[semid].sem_perm.mode & SEM_ALLOC) &&
497 sema[semid].sem_perm._key == key)
498 break;
499 }
500 if (semid < seminfo.semmni) {
501 SEM_PRINTF(("found public key\n"));
502 if ((eval = ipcperm(cred, &sema[semid].sem_perm,
503 semflg & 0700)))
504 return (eval);
505 if (nsems > 0 && sema[semid].sem_nsems < nsems) {
506 SEM_PRINTF(("too small\n"));
507 return (EINVAL);
508 }
509 if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) {
510 SEM_PRINTF(("not exclusive\n"));
511 return (EEXIST);
512 }
513 goto found;
514 }
515 }
516
517 SEM_PRINTF(("need to allocate the semid_ds\n"));
518 if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) {
519 if (nsems <= 0 || nsems > seminfo.semmsl) {
520 SEM_PRINTF(("nsems out of range (0<%d<=%d)\n", nsems,
521 seminfo.semmsl));
522 return (EINVAL);
523 }
524 if (nsems > seminfo.semmns - semtot) {
525 SEM_PRINTF(("not enough semaphores left "
526 "(need %d, got %d)\n",
527 nsems, seminfo.semmns - semtot));
528 return (ENOSPC);
529 }
530 for (semid = 0; semid < seminfo.semmni; semid++) {
531 if ((sema[semid].sem_perm.mode & SEM_ALLOC) == 0)
532 break;
533 }
534 if (semid == seminfo.semmni) {
535 SEM_PRINTF(("no more semid_ds's available\n"));
536 return (ENOSPC);
537 }
538 SEM_PRINTF(("semid %d is available\n", semid));
539 sema[semid].sem_perm._key = key;
540 sema[semid].sem_perm.cuid = cred->cr_uid;
541 sema[semid].sem_perm.uid = cred->cr_uid;
542 sema[semid].sem_perm.cgid = cred->cr_gid;
543 sema[semid].sem_perm.gid = cred->cr_gid;
544 sema[semid].sem_perm.mode = (semflg & 0777) | SEM_ALLOC;
545 sema[semid].sem_perm._seq =
546 (sema[semid].sem_perm._seq + 1) & 0x7fff;
547 sema[semid].sem_nsems = nsems;
548 sema[semid].sem_otime = 0;
549 sema[semid].sem_ctime = time.tv_sec;
550 sema[semid]._sem_base = &sem[semtot];
551 semtot += nsems;
552 memset(sema[semid]._sem_base, 0,
553 sizeof(sema[semid]._sem_base[0]) * nsems);
554 SEM_PRINTF(("sembase = %p, next = %p\n", sema[semid]._sem_base,
555 &sem[semtot]));
556 } else {
557 SEM_PRINTF(("didn't find it and wasn't asked to create it\n"));
558 return (ENOENT);
559 }
560
561 found:
562 *retval = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm);
563 return (0);
564 }
565
566 int
567 sys_semop(l, v, retval)
568 struct lwp *l;
569 void *v;
570 register_t *retval;
571 {
572 struct sys_semop_args /* {
573 syscallarg(int) semid;
574 syscallarg(struct sembuf *) sops;
575 syscallarg(size_t) nsops;
576 } */ *uap = v;
577 struct proc *p = l->l_proc;
578 int semid = SCARG(uap, semid), seq;
579 size_t nsops = SCARG(uap, nsops);
580 struct sembuf sops[MAX_SOPS];
581 struct semid_ds *semaptr;
582 struct sembuf *sopptr = NULL;
583 struct __sem *semptr = NULL;
584 struct sem_undo *suptr = NULL;
585 struct ucred *cred = p->p_ucred;
586 int i, j, eval;
587 int do_wakeup, do_undos;
588
589 SEM_PRINTF(("call to semop(%d, %p, %lld)\n", semid, sops,
590 (long long)nsops));
591
592 semid = IPCID_TO_IX(semid); /* Convert back to zero origin */
593 if (semid < 0 || semid >= seminfo.semmni)
594 return (EINVAL);
595
596 semaptr = &sema[semid];
597 seq = IPCID_TO_SEQ(SCARG(uap, semid));
598 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
599 semaptr->sem_perm._seq != seq)
600 return (EINVAL);
601
602 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) {
603 SEM_PRINTF(("eval = %d from ipaccess\n", eval));
604 return (eval);
605 }
606
607 if (nsops > MAX_SOPS) {
608 SEM_PRINTF(("too many sops (max=%d, nsops=%lld)\n", MAX_SOPS,
609 (long long)nsops));
610 return (E2BIG);
611 }
612
613 if ((eval = copyin(SCARG(uap, sops),
614 sops, nsops * sizeof(sops[0]))) != 0) {
615 SEM_PRINTF(("eval = %d from copyin(%p, %p, %lld)\n", eval,
616 SCARG(uap, sops), &sops,
617 (long long)(nsops * sizeof(sops[0]))));
618 return (eval);
619 }
620
621 for (i = 0; i < nsops; i++)
622 if (sops[i].sem_num >= semaptr->sem_nsems)
623 return (EFBIG);
624
625 /*
626 * Loop trying to satisfy the vector of requests.
627 * If we reach a point where we must wait, any requests already
628 * performed are rolled back and we go to sleep until some other
629 * process wakes us up. At this point, we start all over again.
630 *
631 * This ensures that from the perspective of other tasks, a set
632 * of requests is atomic (never partially satisfied).
633 */
634 do_undos = 0;
635
636 for (;;) {
637 do_wakeup = 0;
638
639 for (i = 0; i < nsops; i++) {
640 sopptr = &sops[i];
641 semptr = &semaptr->_sem_base[sopptr->sem_num];
642
643 SEM_PRINTF(("semop: semaptr=%p, sem_base=%p, "
644 "semptr=%p, sem[%d]=%d : op=%d, flag=%s\n",
645 semaptr, semaptr->_sem_base, semptr,
646 sopptr->sem_num, semptr->semval, sopptr->sem_op,
647 (sopptr->sem_flg & IPC_NOWAIT) ?
648 "nowait" : "wait"));
649
650 if (sopptr->sem_op < 0) {
651 if ((int)(semptr->semval +
652 sopptr->sem_op) < 0) {
653 SEM_PRINTF(("semop: "
654 "can't do it now\n"));
655 break;
656 } else {
657 semptr->semval += sopptr->sem_op;
658 if (semptr->semval == 0 &&
659 semptr->semzcnt > 0)
660 do_wakeup = 1;
661 }
662 if (sopptr->sem_flg & SEM_UNDO)
663 do_undos = 1;
664 } else if (sopptr->sem_op == 0) {
665 if (semptr->semval > 0) {
666 SEM_PRINTF(("semop: not zero now\n"));
667 break;
668 }
669 } else {
670 if (semptr->semncnt > 0)
671 do_wakeup = 1;
672 semptr->semval += sopptr->sem_op;
673 if (sopptr->sem_flg & SEM_UNDO)
674 do_undos = 1;
675 }
676 }
677
678 /*
679 * Did we get through the entire vector?
680 */
681 if (i >= nsops)
682 goto done;
683
684 /*
685 * No ... rollback anything that we've already done
686 */
687 SEM_PRINTF(("semop: rollback 0 through %d\n", i - 1));
688 while (i-- > 0)
689 semaptr->_sem_base[sops[i].sem_num].semval -=
690 sops[i].sem_op;
691
692 /*
693 * If the request that we couldn't satisfy has the
694 * NOWAIT flag set then return with EAGAIN.
695 */
696 if (sopptr->sem_flg & IPC_NOWAIT)
697 return (EAGAIN);
698
699 if (sopptr->sem_op == 0)
700 semptr->semzcnt++;
701 else
702 semptr->semncnt++;
703
704 SEM_PRINTF(("semop: good night!\n"));
705 eval = tsleep((caddr_t)semaptr, (PZERO - 4) | PCATCH,
706 "semwait", 0);
707 SEM_PRINTF(("semop: good morning (eval=%d)!\n", eval));
708
709 /*
710 * Make sure that the semaphore still exists
711 */
712 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
713 semaptr->sem_perm._seq != seq) {
714 /* The man page says to return EIDRM. */
715 /* Unfortunately, BSD doesn't define that code! */
716 #ifdef EIDRM
717 return (EIDRM);
718 #else
719 return (EINVAL);
720 #endif
721 }
722
723 /*
724 * The semaphore is still alive. Readjust the count of
725 * waiting processes.
726 */
727 semptr = &semaptr->_sem_base[sopptr->sem_num];
728 if (sopptr->sem_op == 0)
729 semptr->semzcnt--;
730 else
731 semptr->semncnt--;
732 /*
733 * Is it really morning, or was our sleep interrupted?
734 * (Delayed check of tsleep() return code because we
735 * need to decrement sem[nz]cnt either way.)
736 */
737 if (eval != 0)
738 return (EINTR);
739 SEM_PRINTF(("semop: good morning!\n"));
740 }
741
742 done:
743 /*
744 * Process any SEM_UNDO requests.
745 */
746 if (do_undos) {
747 for (i = 0; i < nsops; i++) {
748 /*
749 * We only need to deal with SEM_UNDO's for non-zero
750 * op's.
751 */
752 int adjval;
753
754 if ((sops[i].sem_flg & SEM_UNDO) == 0)
755 continue;
756 adjval = sops[i].sem_op;
757 if (adjval == 0)
758 continue;
759 eval = semundo_adjust(p, &suptr, semid,
760 sops[i].sem_num, -adjval);
761 if (eval == 0)
762 continue;
763
764 /*
765 * Oh-Oh! We ran out of either sem_undo's or undo's.
766 * Rollback the adjustments to this point and then
767 * rollback the semaphore ups and down so we can return
768 * with an error with all structures restored. We
769 * rollback the undo's in the exact reverse order that
770 * we applied them. This guarantees that we won't run
771 * out of space as we roll things back out.
772 */
773 while (i-- > 0) {
774 if ((sops[i].sem_flg & SEM_UNDO) == 0)
775 continue;
776 adjval = sops[i].sem_op;
777 if (adjval == 0)
778 continue;
779 if (semundo_adjust(p, &suptr, semid,
780 sops[i].sem_num, adjval) != 0)
781 panic("semop - can't undo undos");
782 }
783
784 for (j = 0; j < nsops; j++)
785 semaptr->_sem_base[sops[j].sem_num].semval -=
786 sops[j].sem_op;
787
788 SEM_PRINTF(("eval = %d from semundo_adjust\n", eval));
789 return (eval);
790 } /* loop through the sops */
791 } /* if (do_undos) */
792
793 /* We're definitely done - set the sempid's */
794 for (i = 0; i < nsops; i++) {
795 sopptr = &sops[i];
796 semptr = &semaptr->_sem_base[sopptr->sem_num];
797 semptr->sempid = p->p_pid;
798 }
799
800 /* Do a wakeup if any semaphore was up'd. */
801 if (do_wakeup) {
802 SEM_PRINTF(("semop: doing wakeup\n"));
803 #ifdef SEM_WAKEUP
804 sem_wakeup((caddr_t)semaptr);
805 #else
806 wakeup((caddr_t)semaptr);
807 #endif
808 SEM_PRINTF(("semop: back from wakeup\n"));
809 }
810 SEM_PRINTF(("semop: done\n"));
811 *retval = 0;
812 return (0);
813 }
814
815 /*
816 * Go through the undo structures for this process and apply the
817 * adjustments to semaphores.
818 */
819 /*ARGSUSED*/
820 void
821 semexit(p, v)
822 struct proc *p;
823 void *v;
824 {
825 struct sem_undo *suptr;
826 struct sem_undo **supptr;
827
828 /*
829 * Go through the chain of undo vectors looking for one
830 * associated with this process.
831 */
832
833 for (supptr = &semu_list; (suptr = *supptr) != NULL;
834 supptr = &suptr->un_next) {
835 if (suptr->un_proc == p)
836 break;
837 }
838
839 /*
840 * If there is no undo vector, skip to the end.
841 */
842
843 if (suptr == NULL)
844 return;
845
846 /*
847 * We now have an undo vector for this process.
848 */
849
850 SEM_PRINTF(("proc @%p has undo structure with %d entries\n", p,
851 suptr->un_cnt));
852
853 /*
854 * If there are any active undo elements then process them.
855 */
856 if (suptr->un_cnt > 0) {
857 int ix;
858
859 for (ix = 0; ix < suptr->un_cnt; ix++) {
860 int semid = suptr->un_ent[ix].un_id;
861 int semnum = suptr->un_ent[ix].un_num;
862 int adjval = suptr->un_ent[ix].un_adjval;
863 struct semid_ds *semaptr;
864
865 semaptr = &sema[semid];
866 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0)
867 panic("semexit - semid not allocated");
868 if (semnum >= semaptr->sem_nsems)
869 panic("semexit - semnum out of range");
870
871 SEM_PRINTF(("semexit: %p id=%d num=%d(adj=%d) ; "
872 "sem=%d\n",
873 suptr->un_proc, suptr->un_ent[ix].un_id,
874 suptr->un_ent[ix].un_num,
875 suptr->un_ent[ix].un_adjval,
876 semaptr->_sem_base[semnum].semval));
877
878 if (adjval < 0 &&
879 semaptr->_sem_base[semnum].semval < -adjval)
880 semaptr->_sem_base[semnum].semval = 0;
881 else
882 semaptr->_sem_base[semnum].semval += adjval;
883
884 #ifdef SEM_WAKEUP
885 sem_wakeup((caddr_t)semaptr);
886 #else
887 wakeup((caddr_t)semaptr);
888 #endif
889 SEM_PRINTF(("semexit: back from wakeup\n"));
890 }
891 }
892
893 /*
894 * Deallocate the undo vector.
895 */
896 SEM_PRINTF(("removing vector\n"));
897 suptr->un_proc = NULL;
898 *supptr = suptr->un_next;
899 }
Cache object: 0198a510b2cbde7390d8ef27bcb6acfc
|