1 /* $NetBSD: sysv_sem.c,v 1.65 2006/10/12 01:32:18 christos 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.65 2006/10/12 01:32:18 christos 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/malloc.h> 58 #include <sys/mount.h> /* XXX for <sys/syscallargs.h> */ 59 #include <sys/sa.h> 60 #include <sys/syscallargs.h> 61 #include <sys/kauth.h> 62 63 static int semtot = 0; 64 struct semid_ds *sema; /* semaphore id pool */ 65 static struct __sem *sem; /* semaphore pool */ 66 static struct sem_undo *semu_list; /* list of active undo structures */ 67 static int *semu; /* undo structure pool */ 68 69 #ifdef SEM_DEBUG 70 #define SEM_PRINTF(a) printf a 71 #else 72 #define SEM_PRINTF(a) 73 #endif 74 75 struct sem_undo *semu_alloc(struct proc *); 76 int semundo_adjust(struct proc *, struct sem_undo **, int, int, int); 77 void semundo_clear(int, int); 78 79 /* 80 * XXXSMP Once we go MP, there needs to be a lock for the semaphore system. 81 * Until then, we're saved by being a non-preemptive kernel. 82 */ 83 84 void 85 seminit(void) 86 { 87 int i, sz; 88 vaddr_t v; 89 90 /* Allocate pageable memory for our structures */ 91 sz = seminfo.semmni * sizeof(struct semid_ds) + 92 seminfo.semmns * sizeof(struct __sem) + 93 seminfo.semmnu * seminfo.semusz; 94 v = uvm_km_alloc(kernel_map, round_page(sz), 0, 95 UVM_KMF_WIRED|UVM_KMF_ZERO); 96 if (v == 0) 97 panic("sysv_sem: cannot allocate memory"); 98 sema = (void *)v; 99 sem = (void *)(sema + seminfo.semmni); 100 semu = (void *)(sem + seminfo.semmns); 101 102 for (i = 0; i < seminfo.semmni; i++) { 103 sema[i]._sem_base = 0; 104 sema[i].sem_perm.mode = 0; 105 } 106 for (i = 0; i < seminfo.semmnu; i++) { 107 struct sem_undo *suptr = SEMU(i); 108 suptr->un_proc = NULL; 109 } 110 semu_list = NULL; 111 exithook_establish(semexit, NULL); 112 } 113 114 /* 115 * Placebo. 116 */ 117 118 int 119 sys_semconfig(struct lwp *l __unused, void *v __unused, register_t *retval) 120 { 121 122 *retval = 0; 123 return 0; 124 } 125 126 /* 127 * Allocate a new sem_undo structure for a process 128 * (returns ptr to structure or NULL if no more room) 129 */ 130 131 struct sem_undo * 132 semu_alloc(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(struct proc *p, struct sem_undo **supptr, int semid, int semnum, 202 int adjval) 203 { 204 struct sem_undo *suptr; 205 struct undo *sunptr; 206 int i; 207 208 /* 209 * Look for and remember the sem_undo if the caller doesn't 210 * provide it 211 */ 212 213 suptr = *supptr; 214 if (suptr == NULL) { 215 for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) 216 if (suptr->un_proc == p) 217 break; 218 219 if (suptr == NULL) { 220 suptr = semu_alloc(p); 221 if (suptr == NULL) 222 return (ENOSPC); 223 } 224 *supptr = suptr; 225 } 226 227 /* 228 * Look for the requested entry and adjust it (delete if 229 * adjval becomes 0). 230 */ 231 sunptr = &suptr->un_ent[0]; 232 for (i = 0; i < suptr->un_cnt; i++, sunptr++) { 233 if (sunptr->un_id != semid || sunptr->un_num != semnum) 234 continue; 235 sunptr->un_adjval += adjval; 236 if (sunptr->un_adjval == 0) { 237 suptr->un_cnt--; 238 if (i < suptr->un_cnt) 239 suptr->un_ent[i] = 240 suptr->un_ent[suptr->un_cnt]; 241 } 242 return (0); 243 } 244 245 /* Didn't find the right entry - create it */ 246 if (suptr->un_cnt == SEMUME) 247 return (EINVAL); 248 249 sunptr = &suptr->un_ent[suptr->un_cnt]; 250 suptr->un_cnt++; 251 sunptr->un_adjval = adjval; 252 sunptr->un_id = semid; 253 sunptr->un_num = semnum; 254 return (0); 255 } 256 257 void 258 semundo_clear(int semid, int semnum) 259 { 260 struct sem_undo *suptr; 261 struct undo *sunptr, *sunend; 262 263 for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) 264 for (sunptr = &suptr->un_ent[0], 265 sunend = sunptr + suptr->un_cnt; sunptr < sunend;) { 266 if (sunptr->un_id == semid) { 267 if (semnum == -1 || sunptr->un_num == semnum) { 268 suptr->un_cnt--; 269 sunend--; 270 if (sunptr != sunend) 271 *sunptr = *sunend; 272 if (semnum != -1) 273 break; 274 else 275 continue; 276 } 277 } 278 sunptr++; 279 } 280 } 281 282 int 283 sys_____semctl13(struct lwp *l, void *v, register_t *retval) 284 { 285 struct sys_____semctl13_args /* { 286 syscallarg(int) semid; 287 syscallarg(int) semnum; 288 syscallarg(int) cmd; 289 syscallarg(union __semun *) arg; 290 } */ *uap = v; 291 struct semid_ds sembuf; 292 int cmd, error; 293 void *pass_arg; 294 union __semun karg; 295 296 cmd = SCARG(uap, cmd); 297 298 switch (cmd) { 299 case IPC_SET: 300 case IPC_STAT: 301 pass_arg = &sembuf; 302 break; 303 304 case GETALL: 305 case SETVAL: 306 case SETALL: 307 pass_arg = &karg; 308 break; 309 default: 310 pass_arg = NULL; 311 break; 312 } 313 314 if (pass_arg) { 315 error = copyin(SCARG(uap, arg), &karg, sizeof(karg)); 316 if (error) 317 return error; 318 if (cmd == IPC_SET) { 319 error = copyin(karg.buf, &sembuf, sizeof(sembuf)); 320 if (error) 321 return (error); 322 } 323 } 324 325 error = semctl1(l, SCARG(uap, semid), SCARG(uap, semnum), cmd, 326 pass_arg, retval); 327 328 if (error == 0 && cmd == IPC_STAT) 329 error = copyout(&sembuf, karg.buf, sizeof(sembuf)); 330 331 return (error); 332 } 333 334 int 335 semctl1(struct lwp *l, int semid, int semnum, int cmd, void *v, 336 register_t *retval) 337 { 338 kauth_cred_t cred = l->l_cred; 339 union __semun *arg = v; 340 struct semid_ds *sembuf = v, *semaptr; 341 int i, error, ix; 342 343 SEM_PRINTF(("call to semctl(%d, %d, %d, %p)\n", 344 semid, semnum, cmd, v)); 345 346 ix = IPCID_TO_IX(semid); 347 if (ix < 0 || ix >= seminfo.semmni) 348 return (EINVAL); 349 350 semaptr = &sema[ix]; 351 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || 352 semaptr->sem_perm._seq != IPCID_TO_SEQ(semid)) 353 return (EINVAL); 354 355 switch (cmd) { 356 case IPC_RMID: 357 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)) != 0) 358 return (error); 359 semaptr->sem_perm.cuid = kauth_cred_geteuid(cred); 360 semaptr->sem_perm.uid = kauth_cred_geteuid(cred); 361 semtot -= semaptr->sem_nsems; 362 for (i = semaptr->_sem_base - sem; i < semtot; i++) 363 sem[i] = sem[i + semaptr->sem_nsems]; 364 for (i = 0; i < seminfo.semmni; i++) { 365 if ((sema[i].sem_perm.mode & SEM_ALLOC) && 366 sema[i]._sem_base > semaptr->_sem_base) 367 sema[i]._sem_base -= semaptr->sem_nsems; 368 } 369 semaptr->sem_perm.mode = 0; 370 semundo_clear(ix, -1); 371 wakeup(semaptr); 372 break; 373 374 case IPC_SET: 375 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M))) 376 return (error); 377 KASSERT(sembuf != NULL); 378 semaptr->sem_perm.uid = sembuf->sem_perm.uid; 379 semaptr->sem_perm.gid = sembuf->sem_perm.gid; 380 semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) | 381 (sembuf->sem_perm.mode & 0777); 382 semaptr->sem_ctime = time_second; 383 break; 384 385 case IPC_STAT: 386 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 387 return (error); 388 KASSERT(sembuf != NULL); 389 memcpy(sembuf, semaptr, sizeof(struct semid_ds)); 390 break; 391 392 case GETNCNT: 393 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 394 return (error); 395 if (semnum < 0 || semnum >= semaptr->sem_nsems) 396 return (EINVAL); 397 *retval = semaptr->_sem_base[semnum].semncnt; 398 break; 399 400 case GETPID: 401 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 402 return (error); 403 if (semnum < 0 || semnum >= semaptr->sem_nsems) 404 return (EINVAL); 405 *retval = semaptr->_sem_base[semnum].sempid; 406 break; 407 408 case GETVAL: 409 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 410 return (error); 411 if (semnum < 0 || semnum >= semaptr->sem_nsems) 412 return (EINVAL); 413 *retval = semaptr->_sem_base[semnum].semval; 414 break; 415 416 case GETALL: 417 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 418 return (error); 419 KASSERT(arg != NULL); 420 for (i = 0; i < semaptr->sem_nsems; i++) { 421 error = copyout(&semaptr->_sem_base[i].semval, 422 &arg->array[i], sizeof(arg->array[i])); 423 if (error != 0) 424 break; 425 } 426 break; 427 428 case GETZCNT: 429 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R))) 430 return (error); 431 if (semnum < 0 || semnum >= semaptr->sem_nsems) 432 return (EINVAL); 433 *retval = semaptr->_sem_base[semnum].semzcnt; 434 break; 435 436 case SETVAL: 437 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W))) 438 return (error); 439 if (semnum < 0 || semnum >= semaptr->sem_nsems) 440 return (EINVAL); 441 KASSERT(arg != NULL); 442 semaptr->_sem_base[semnum].semval = arg->val; 443 semundo_clear(ix, semnum); 444 wakeup(semaptr); 445 break; 446 447 case SETALL: 448 if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W))) 449 return (error); 450 KASSERT(arg != NULL); 451 for (i = 0; i < semaptr->sem_nsems; i++) { 452 error = copyin(&arg->array[i], 453 &semaptr->_sem_base[i].semval, 454 sizeof(arg->array[i])); 455 if (error != 0) 456 break; 457 } 458 semundo_clear(ix, -1); 459 wakeup(semaptr); 460 break; 461 462 default: 463 return (EINVAL); 464 } 465 466 return (error); 467 } 468 469 int 470 sys_semget(struct lwp *l, void *v, register_t *retval) 471 { 472 struct sys_semget_args /* { 473 syscallarg(key_t) key; 474 syscallarg(int) nsems; 475 syscallarg(int) semflg; 476 } */ *uap = v; 477 int semid, eval; 478 int key = SCARG(uap, key); 479 int nsems = SCARG(uap, nsems); 480 int semflg = SCARG(uap, semflg); 481 kauth_cred_t cred = l->l_cred; 482 483 SEM_PRINTF(("semget(0x%x, %d, 0%o)\n", key, nsems, semflg)); 484 485 if (key != IPC_PRIVATE) { 486 for (semid = 0; semid < seminfo.semmni; semid++) { 487 if ((sema[semid].sem_perm.mode & SEM_ALLOC) && 488 sema[semid].sem_perm._key == key) 489 break; 490 } 491 if (semid < seminfo.semmni) { 492 SEM_PRINTF(("found public key\n")); 493 if ((eval = ipcperm(cred, &sema[semid].sem_perm, 494 semflg & 0700))) 495 return (eval); 496 if (nsems > 0 && sema[semid].sem_nsems < nsems) { 497 SEM_PRINTF(("too small\n")); 498 return (EINVAL); 499 } 500 if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) { 501 SEM_PRINTF(("not exclusive\n")); 502 return (EEXIST); 503 } 504 goto found; 505 } 506 } 507 508 SEM_PRINTF(("need to allocate the semid_ds\n")); 509 if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) { 510 if (nsems <= 0 || nsems > seminfo.semmsl) { 511 SEM_PRINTF(("nsems out of range (0<%d<=%d)\n", nsems, 512 seminfo.semmsl)); 513 return (EINVAL); 514 } 515 if (nsems > seminfo.semmns - semtot) { 516 SEM_PRINTF(("not enough semaphores left " 517 "(need %d, got %d)\n", 518 nsems, seminfo.semmns - semtot)); 519 return (ENOSPC); 520 } 521 for (semid = 0; semid < seminfo.semmni; semid++) { 522 if ((sema[semid].sem_perm.mode & SEM_ALLOC) == 0) 523 break; 524 } 525 if (semid == seminfo.semmni) { 526 SEM_PRINTF(("no more semid_ds's available\n")); 527 return (ENOSPC); 528 } 529 SEM_PRINTF(("semid %d is available\n", semid)); 530 sema[semid].sem_perm._key = key; 531 sema[semid].sem_perm.cuid = kauth_cred_geteuid(cred); 532 sema[semid].sem_perm.uid = kauth_cred_geteuid(cred); 533 sema[semid].sem_perm.cgid = kauth_cred_getegid(cred); 534 sema[semid].sem_perm.gid = kauth_cred_getegid(cred); 535 sema[semid].sem_perm.mode = (semflg & 0777) | SEM_ALLOC; 536 sema[semid].sem_perm._seq = 537 (sema[semid].sem_perm._seq + 1) & 0x7fff; 538 sema[semid].sem_nsems = nsems; 539 sema[semid].sem_otime = 0; 540 sema[semid].sem_ctime = time_second; 541 sema[semid]._sem_base = &sem[semtot]; 542 semtot += nsems; 543 memset(sema[semid]._sem_base, 0, 544 sizeof(sema[semid]._sem_base[0]) * nsems); 545 SEM_PRINTF(("sembase = %p, next = %p\n", sema[semid]._sem_base, 546 &sem[semtot])); 547 } else { 548 SEM_PRINTF(("didn't find it and wasn't asked to create it\n")); 549 return (ENOENT); 550 } 551 552 found: 553 *retval = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm); 554 return (0); 555 } 556 557 #define SMALL_SOPS 8 558 559 int 560 sys_semop(struct lwp *l, void *v, register_t *retval) 561 { 562 struct sys_semop_args /* { 563 syscallarg(int) semid; 564 syscallarg(struct sembuf *) sops; 565 syscallarg(size_t) nsops; 566 } */ *uap = v; 567 struct proc *p = l->l_proc; 568 int semid = SCARG(uap, semid), seq; 569 size_t nsops = SCARG(uap, nsops); 570 struct sembuf small_sops[SMALL_SOPS]; 571 struct sembuf *sops; 572 struct semid_ds *semaptr; 573 struct sembuf *sopptr = NULL; 574 struct __sem *semptr = NULL; 575 struct sem_undo *suptr = NULL; 576 kauth_cred_t cred = l->l_cred; 577 int i, eval; 578 int do_wakeup, do_undos; 579 580 SEM_PRINTF(("call to semop(%d, %p, %zd)\n", semid, SCARG(uap,sops), nsops)); 581 582 semid = IPCID_TO_IX(semid); /* Convert back to zero origin */ 583 if (semid < 0 || semid >= seminfo.semmni) 584 return (EINVAL); 585 586 semaptr = &sema[semid]; 587 seq = IPCID_TO_SEQ(SCARG(uap, semid)); 588 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || 589 semaptr->sem_perm._seq != seq) 590 return (EINVAL); 591 592 if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) { 593 SEM_PRINTF(("eval = %d from ipaccess\n", eval)); 594 return (eval); 595 } 596 597 if (nsops <= SMALL_SOPS) { 598 sops = small_sops; 599 } else if (nsops <= seminfo.semopm) { 600 sops = malloc(nsops * sizeof(*sops), M_TEMP, M_WAITOK); 601 } else { 602 SEM_PRINTF(("too many sops (max=%d, nsops=%zd)\n", 603 seminfo.semopm, nsops)); 604 return (E2BIG); 605 } 606 607 if ((eval = copyin(SCARG(uap, sops), 608 sops, nsops * sizeof(sops[0]))) != 0) { 609 SEM_PRINTF(("eval = %d from copyin(%p, %p, %zd)\n", eval, 610 SCARG(uap, sops), &sops, nsops * sizeof(sops[0]))); 611 goto out; 612 } 613 614 for (i = 0; i < nsops; i++) 615 if (sops[i].sem_num >= semaptr->sem_nsems) { 616 eval = EFBIG; 617 goto out; 618 } 619 620 /* 621 * Loop trying to satisfy the vector of requests. 622 * If we reach a point where we must wait, any requests already 623 * performed are rolled back and we go to sleep until some other 624 * process wakes us up. At this point, we start all over again. 625 * 626 * This ensures that from the perspective of other tasks, a set 627 * of requests is atomic (never partially satisfied). 628 */ 629 do_undos = 0; 630 631 for (;;) { 632 do_wakeup = 0; 633 634 for (i = 0; i < nsops; i++) { 635 sopptr = &sops[i]; 636 semptr = &semaptr->_sem_base[sopptr->sem_num]; 637 638 SEM_PRINTF(("semop: semaptr=%p, sem_base=%p, " 639 "semptr=%p, sem[%d]=%d : op=%d, flag=%s\n", 640 semaptr, semaptr->_sem_base, semptr, 641 sopptr->sem_num, semptr->semval, sopptr->sem_op, 642 (sopptr->sem_flg & IPC_NOWAIT) ? 643 "nowait" : "wait")); 644 645 if (sopptr->sem_op < 0) { 646 if ((int)(semptr->semval + 647 sopptr->sem_op) < 0) { 648 SEM_PRINTF(("semop: " 649 "can't do it now\n")); 650 break; 651 } else { 652 semptr->semval += sopptr->sem_op; 653 if (semptr->semval == 0 && 654 semptr->semzcnt > 0) 655 do_wakeup = 1; 656 } 657 if (sopptr->sem_flg & SEM_UNDO) 658 do_undos = 1; 659 } else if (sopptr->sem_op == 0) { 660 if (semptr->semval > 0) { 661 SEM_PRINTF(("semop: not zero now\n")); 662 break; 663 } 664 } else { 665 if (semptr->semncnt > 0) 666 do_wakeup = 1; 667 semptr->semval += sopptr->sem_op; 668 if (sopptr->sem_flg & SEM_UNDO) 669 do_undos = 1; 670 } 671 } 672 673 /* 674 * Did we get through the entire vector? 675 */ 676 if (i >= nsops) 677 goto done; 678 679 /* 680 * No ... rollback anything that we've already done 681 */ 682 SEM_PRINTF(("semop: rollback 0 through %d\n", i - 1)); 683 while (i-- > 0) 684 semaptr->_sem_base[sops[i].sem_num].semval -= 685 sops[i].sem_op; 686 687 /* 688 * If the request that we couldn't satisfy has the 689 * NOWAIT flag set then return with EAGAIN. 690 */ 691 if (sopptr->sem_flg & IPC_NOWAIT) { 692 eval = EAGAIN; 693 goto out; 694 } 695 696 if (sopptr->sem_op == 0) 697 semptr->semzcnt++; 698 else 699 semptr->semncnt++; 700 701 SEM_PRINTF(("semop: good night!\n")); 702 eval = tsleep((caddr_t)semaptr, (PZERO - 4) | PCATCH, 703 "semwait", 0); 704 SEM_PRINTF(("semop: good morning (eval=%d)!\n", eval)); 705 706 /* 707 * Make sure that the semaphore still exists 708 */ 709 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || 710 semaptr->sem_perm._seq != seq) { 711 eval = EIDRM; 712 goto out; 713 } 714 715 /* 716 * The semaphore is still alive. Readjust the count of 717 * waiting processes. 718 */ 719 semptr = &semaptr->_sem_base[sopptr->sem_num]; 720 if (sopptr->sem_op == 0) 721 semptr->semzcnt--; 722 else 723 semptr->semncnt--; 724 /* 725 * Is it really morning, or was our sleep interrupted? 726 * (Delayed check of tsleep() return code because we 727 * need to decrement sem[nz]cnt either way.) 728 */ 729 if (eval != 0) { 730 eval = EINTR; 731 goto out; 732 } 733 SEM_PRINTF(("semop: good morning!\n")); 734 } 735 736 done: 737 /* 738 * Process any SEM_UNDO requests. 739 */ 740 if (do_undos) { 741 for (i = 0; i < nsops; i++) { 742 /* 743 * We only need to deal with SEM_UNDO's for non-zero 744 * op's. 745 */ 746 int adjval; 747 748 if ((sops[i].sem_flg & SEM_UNDO) == 0) 749 continue; 750 adjval = sops[i].sem_op; 751 if (adjval == 0) 752 continue; 753 eval = semundo_adjust(p, &suptr, semid, 754 sops[i].sem_num, -adjval); 755 if (eval == 0) 756 continue; 757 758 /* 759 * Oh-Oh! We ran out of either sem_undo's or undo's. 760 * Rollback the adjustments to this point and then 761 * rollback the semaphore ups and down so we can return 762 * with an error with all structures restored. We 763 * rollback the undo's in the exact reverse order that 764 * we applied them. This guarantees that we won't run 765 * out of space as we roll things back out. 766 */ 767 while (i-- > 0) { 768 if ((sops[i].sem_flg & SEM_UNDO) == 0) 769 continue; 770 adjval = sops[i].sem_op; 771 if (adjval == 0) 772 continue; 773 if (semundo_adjust(p, &suptr, semid, 774 sops[i].sem_num, adjval) != 0) 775 panic("semop - can't undo undos"); 776 } 777 778 for (i = 0; i < nsops; i++) 779 semaptr->_sem_base[sops[i].sem_num].semval -= 780 sops[i].sem_op; 781 782 SEM_PRINTF(("eval = %d from semundo_adjust\n", eval)); 783 goto out; 784 } /* loop through the sops */ 785 } /* if (do_undos) */ 786 787 /* We're definitely done - set the sempid's */ 788 for (i = 0; i < nsops; i++) { 789 sopptr = &sops[i]; 790 semptr = &semaptr->_sem_base[sopptr->sem_num]; 791 semptr->sempid = p->p_pid; 792 } 793 794 /* Update sem_otime */ 795 semaptr->sem_otime = time_second; 796 797 /* Do a wakeup if any semaphore was up'd. */ 798 if (do_wakeup) { 799 SEM_PRINTF(("semop: doing wakeup\n")); 800 #ifdef SEM_WAKEUP 801 sem_wakeup((caddr_t)semaptr); 802 #else 803 wakeup((caddr_t)semaptr); 804 #endif 805 SEM_PRINTF(("semop: back from wakeup\n")); 806 } 807 SEM_PRINTF(("semop: done\n")); 808 *retval = 0; 809 810 out: 811 if (sops != small_sops) { 812 free(sops, M_TEMP); 813 } 814 return eval; 815 } 816 817 /* 818 * Go through the undo structures for this process and apply the 819 * adjustments to semaphores. 820 */ 821 /*ARGSUSED*/ 822 void 823 semexit(struct proc *p, void *v __unused) 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 } 900