1 /* $FreeBSD$ */ 2 3 /* 4 * Implementation of SVID semaphores 5 * 6 * Author: Daniel Boulet 7 * 8 * This software is provided ``AS IS'' without any warranties of any kind. 9 */ 10 11 #include "opt_sysvipc.h" 12 13 #include <sys/param.h> 14 #include <sys/systm.h> 15 #include <sys/sysproto.h> 16 #include <sys/kernel.h> 17 #include <sys/proc.h> 18 #include <sys/sem.h> 19 #include <sys/sysent.h> 20 #include <sys/sysctl.h> 21 #include <sys/malloc.h> 22 #include <sys/jail.h> 23 24 static MALLOC_DEFINE(M_SEM, "sem", "SVID compatible semaphores"); 25 26 static void seminit __P((void *)); 27 28 #ifndef _SYS_SYSPROTO_H_ 29 struct __semctl_args; 30 int __semctl __P((struct proc *p, struct __semctl_args *uap)); 31 struct semget_args; 32 int semget __P((struct proc *p, struct semget_args *uap)); 33 struct semop_args; 34 int semop __P((struct proc *p, struct semop_args *uap)); 35 #endif 36 37 static struct sem_undo *semu_alloc __P((struct proc *p)); 38 static int semundo_adjust __P((struct proc *p, struct sem_undo **supptr, 39 int semid, int semnum, int adjval)); 40 static void semundo_clear __P((int semid, int semnum)); 41 42 /* XXX casting to (sy_call_t *) is bogus, as usual. */ 43 static sy_call_t *semcalls[] = { 44 (sy_call_t *)__semctl, (sy_call_t *)semget, 45 (sy_call_t *)semop 46 }; 47 48 static int semtot = 0; 49 static struct semid_ds *sema; /* semaphore id pool */ 50 static struct sem *sem; /* semaphore pool */ 51 static struct sem_undo *semu_list; /* list of active undo structures */ 52 static int *semu; /* undo structure pool */ 53 54 struct sem { 55 u_short semval; /* semaphore value */ 56 pid_t sempid; /* pid of last operation */ 57 u_short semncnt; /* # awaiting semval > cval */ 58 u_short semzcnt; /* # awaiting semval = 0 */ 59 }; 60 61 /* 62 * Undo structure (one per process) 63 */ 64 struct sem_undo { 65 struct sem_undo *un_next; /* ptr to next active undo structure */ 66 struct proc *un_proc; /* owner of this structure */ 67 short un_cnt; /* # of active entries */ 68 struct undo { 69 short un_adjval; /* adjust on exit values */ 70 short un_num; /* semaphore # */ 71 int un_id; /* semid */ 72 } un_ent[1]; /* undo entries */ 73 }; 74 75 /* 76 * Configuration parameters 77 */ 78 #ifndef SEMMNI 79 #define SEMMNI 10 /* # of semaphore identifiers */ 80 #endif 81 #ifndef SEMMNS 82 #define SEMMNS 60 /* # of semaphores in system */ 83 #endif 84 #ifndef SEMUME 85 #define SEMUME 10 /* max # of undo entries per process */ 86 #endif 87 #ifndef SEMMNU 88 #define SEMMNU 30 /* # of undo structures in system */ 89 #endif 90 91 /* shouldn't need tuning */ 92 #ifndef SEMMAP 93 #define SEMMAP 30 /* # of entries in semaphore map */ 94 #endif 95 #ifndef SEMMSL 96 #define SEMMSL SEMMNS /* max # of semaphores per id */ 97 #endif 98 #ifndef SEMOPM 99 #define SEMOPM 100 /* max # of operations per semop call */ 100 #endif 101 102 #define SEMVMX 32767 /* semaphore maximum value */ 103 #define SEMAEM 16384 /* adjust on exit max value */ 104 105 /* 106 * Due to the way semaphore memory is allocated, we have to ensure that 107 * SEMUSZ is properly aligned. 108 */ 109 110 #define SEM_ALIGN(bytes) (((bytes) + (sizeof(long) - 1)) & ~(sizeof(long) - 1)) 111 112 /* actual size of an undo structure */ 113 #define SEMUSZ SEM_ALIGN(offsetof(struct sem_undo, un_ent[SEMUME])) 114 115 /* 116 * Macro to find a particular sem_undo vector 117 */ 118 #define SEMU(ix) ((struct sem_undo *)(((intptr_t)semu)+ix * seminfo.semusz)) 119 120 /* 121 * semaphore info struct 122 */ 123 struct seminfo seminfo = { 124 SEMMAP, /* # of entries in semaphore map */ 125 SEMMNI, /* # of semaphore identifiers */ 126 SEMMNS, /* # of semaphores in system */ 127 SEMMNU, /* # of undo structures in system */ 128 SEMMSL, /* max # of semaphores per id */ 129 SEMOPM, /* max # of operations per semop call */ 130 SEMUME, /* max # of undo entries per process */ 131 SEMUSZ, /* size in bytes of undo structure */ 132 SEMVMX, /* semaphore maximum value */ 133 SEMAEM /* adjust on exit max value */ 134 }; 135 136 SYSCTL_DECL(_kern_ipc); 137 SYSCTL_INT(_kern_ipc, OID_AUTO, semmap, CTLFLAG_RW, &seminfo.semmap, 0, ""); 138 SYSCTL_INT(_kern_ipc, OID_AUTO, semmni, CTLFLAG_RD, &seminfo.semmni, 0, ""); 139 SYSCTL_INT(_kern_ipc, OID_AUTO, semmns, CTLFLAG_RD, &seminfo.semmns, 0, ""); 140 SYSCTL_INT(_kern_ipc, OID_AUTO, semmnu, CTLFLAG_RD, &seminfo.semmnu, 0, ""); 141 SYSCTL_INT(_kern_ipc, OID_AUTO, semmsl, CTLFLAG_RW, &seminfo.semmsl, 0, ""); 142 SYSCTL_INT(_kern_ipc, OID_AUTO, semopm, CTLFLAG_RD, &seminfo.semopm, 0, ""); 143 SYSCTL_INT(_kern_ipc, OID_AUTO, semume, CTLFLAG_RD, &seminfo.semume, 0, ""); 144 SYSCTL_INT(_kern_ipc, OID_AUTO, semusz, CTLFLAG_RD, &seminfo.semusz, 0, ""); 145 SYSCTL_INT(_kern_ipc, OID_AUTO, semvmx, CTLFLAG_RW, &seminfo.semvmx, 0, ""); 146 SYSCTL_INT(_kern_ipc, OID_AUTO, semaem, CTLFLAG_RW, &seminfo.semaem, 0, ""); 147 148 #if 0 149 RO seminfo.semmap /* SEMMAP unused */ 150 RO seminfo.semmni 151 RO seminfo.semmns 152 RO seminfo.semmnu /* undo entries per system */ 153 RW seminfo.semmsl 154 RO seminfo.semopm /* SEMOPM unused */ 155 RO seminfo.semume 156 RO seminfo.semusz /* param - derived from SEMUME for per-proc sizeof */ 157 RO seminfo.semvmx /* SEMVMX unused - user param */ 158 RO seminfo.semaem /* SEMAEM unused - user param */ 159 #endif 160 161 static void 162 seminit(dummy) 163 void *dummy; 164 { 165 register int i; 166 167 sem = malloc(sizeof(struct sem) * seminfo.semmns, M_SEM, M_WAITOK); 168 if (sem == NULL) 169 panic("sem is NULL"); 170 sema = malloc(sizeof(struct semid_ds) * seminfo.semmni, M_SEM, M_WAITOK); 171 if (sema == NULL) 172 panic("sema is NULL"); 173 semu = malloc(seminfo.semmnu * seminfo.semusz, M_SEM, M_WAITOK); 174 if (semu == NULL) 175 panic("semu is NULL"); 176 177 for (i = 0; i < seminfo.semmni; i++) { 178 sema[i].sem_base = 0; 179 sema[i].sem_perm.mode = 0; 180 } 181 for (i = 0; i < seminfo.semmnu; i++) { 182 register struct sem_undo *suptr = SEMU(i); 183 suptr->un_proc = NULL; 184 } 185 semu_list = NULL; 186 } 187 SYSINIT(sysv_sem, SI_SUB_SYSV_SEM, SI_ORDER_FIRST, seminit, NULL) 188 189 /* 190 * Entry point for all SEM calls 191 */ 192 int 193 semsys(p, uap) 194 struct proc *p; 195 /* XXX actually varargs. */ 196 struct semsys_args /* { 197 u_int which; 198 int a2; 199 int a3; 200 int a4; 201 int a5; 202 } */ *uap; 203 { 204 205 if (!jail_sysvipc_allowed && p->p_prison != NULL) 206 return (ENOSYS); 207 208 if (uap->which >= sizeof(semcalls)/sizeof(semcalls[0])) 209 return (EINVAL); 210 return ((*semcalls[uap->which])(p, &uap->a2)); 211 } 212 213 /* 214 * Allocate a new sem_undo structure for a process 215 * (returns ptr to structure or NULL if no more room) 216 */ 217 218 static struct sem_undo * 219 semu_alloc(p) 220 struct proc *p; 221 { 222 register int i; 223 register struct sem_undo *suptr; 224 register struct sem_undo **supptr; 225 int attempt; 226 227 /* 228 * Try twice to allocate something. 229 * (we'll purge any empty structures after the first pass so 230 * two passes are always enough) 231 */ 232 233 for (attempt = 0; attempt < 2; attempt++) { 234 /* 235 * Look for a free structure. 236 * Fill it in and return it if we find one. 237 */ 238 239 for (i = 0; i < seminfo.semmnu; i++) { 240 suptr = SEMU(i); 241 if (suptr->un_proc == NULL) { 242 suptr->un_next = semu_list; 243 semu_list = suptr; 244 suptr->un_cnt = 0; 245 suptr->un_proc = p; 246 return(suptr); 247 } 248 } 249 250 /* 251 * We didn't find a free one, if this is the first attempt 252 * then try to free some structures. 253 */ 254 255 if (attempt == 0) { 256 /* All the structures are in use - try to free some */ 257 int did_something = 0; 258 259 supptr = &semu_list; 260 while ((suptr = *supptr) != NULL) { 261 if (suptr->un_cnt == 0) { 262 suptr->un_proc = NULL; 263 *supptr = suptr->un_next; 264 did_something = 1; 265 } else 266 supptr = &(suptr->un_next); 267 } 268 269 /* If we didn't free anything then just give-up */ 270 if (!did_something) 271 return(NULL); 272 } else { 273 /* 274 * The second pass failed even though we freed 275 * something after the first pass! 276 * This is IMPOSSIBLE! 277 */ 278 panic("semu_alloc - second attempt failed"); 279 } 280 } 281 return (NULL); 282 } 283 284 /* 285 * Adjust a particular entry for a particular proc 286 */ 287 288 static int 289 semundo_adjust(p, supptr, semid, semnum, adjval) 290 register struct proc *p; 291 struct sem_undo **supptr; 292 int semid, semnum; 293 int adjval; 294 { 295 register struct sem_undo *suptr; 296 register struct undo *sunptr; 297 int i; 298 299 /* Look for and remember the sem_undo if the caller doesn't provide 300 it */ 301 302 suptr = *supptr; 303 if (suptr == NULL) { 304 for (suptr = semu_list; suptr != NULL; 305 suptr = suptr->un_next) { 306 if (suptr->un_proc == p) { 307 *supptr = suptr; 308 break; 309 } 310 } 311 if (suptr == NULL) { 312 if (adjval == 0) 313 return(0); 314 suptr = semu_alloc(p); 315 if (suptr == NULL) 316 return(ENOSPC); 317 *supptr = suptr; 318 } 319 } 320 321 /* 322 * Look for the requested entry and adjust it (delete if adjval becomes 323 * 0). 324 */ 325 sunptr = &suptr->un_ent[0]; 326 for (i = 0; i < suptr->un_cnt; i++, sunptr++) { 327 if (sunptr->un_id != semid || sunptr->un_num != semnum) 328 continue; 329 if (adjval == 0) 330 sunptr->un_adjval = 0; 331 else 332 sunptr->un_adjval += adjval; 333 if (sunptr->un_adjval == 0) { 334 suptr->un_cnt--; 335 if (i < suptr->un_cnt) 336 suptr->un_ent[i] = 337 suptr->un_ent[suptr->un_cnt]; 338 } 339 return(0); 340 } 341 342 /* Didn't find the right entry - create it */ 343 if (adjval == 0) 344 return(0); 345 if (suptr->un_cnt != seminfo.semume) { 346 sunptr = &suptr->un_ent[suptr->un_cnt]; 347 suptr->un_cnt++; 348 sunptr->un_adjval = adjval; 349 sunptr->un_id = semid; sunptr->un_num = semnum; 350 } else 351 return(EINVAL); 352 return(0); 353 } 354 355 static void 356 semundo_clear(semid, semnum) 357 int semid, semnum; 358 { 359 register struct sem_undo *suptr; 360 361 for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) { 362 register struct undo *sunptr = &suptr->un_ent[0]; 363 register int i = 0; 364 365 while (i < suptr->un_cnt) { 366 if (sunptr->un_id == semid) { 367 if (semnum == -1 || sunptr->un_num == semnum) { 368 suptr->un_cnt--; 369 if (i < suptr->un_cnt) { 370 suptr->un_ent[i] = 371 suptr->un_ent[suptr->un_cnt]; 372 continue; 373 } 374 } 375 if (semnum != -1) 376 break; 377 } 378 i++, sunptr++; 379 } 380 } 381 } 382 383 /* 384 * Note that the user-mode half of this passes a union, not a pointer 385 */ 386 #ifndef _SYS_SYSPROTO_H_ 387 struct __semctl_args { 388 int semid; 389 int semnum; 390 int cmd; 391 union semun *arg; 392 }; 393 #endif 394 395 int 396 __semctl(p, uap) 397 struct proc *p; 398 register struct __semctl_args *uap; 399 { 400 int semid = uap->semid; 401 int semnum = uap->semnum; 402 int cmd = uap->cmd; 403 union semun *arg = uap->arg; 404 union semun real_arg; 405 struct ucred *cred = p->p_ucred; 406 int i, rval, eval; 407 struct semid_ds sbuf; 408 register struct semid_ds *semaptr; 409 410 #ifdef SEM_DEBUG 411 printf("call to semctl(%d, %d, %d, 0x%x)\n", semid, semnum, cmd, arg); 412 #endif 413 414 if (!jail_sysvipc_allowed && p->p_prison != NULL) 415 return (ENOSYS); 416 417 semid = IPCID_TO_IX(semid); 418 if (semid < 0 || semid >= seminfo.semmsl) 419 return(EINVAL); 420 421 semaptr = &sema[semid]; 422 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || 423 semaptr->sem_perm.seq != IPCID_TO_SEQ(uap->semid)) 424 return(EINVAL); 425 426 eval = 0; 427 rval = 0; 428 429 switch (cmd) { 430 case IPC_RMID: 431 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_M))) 432 return(eval); 433 semaptr->sem_perm.cuid = cred->cr_uid; 434 semaptr->sem_perm.uid = cred->cr_uid; 435 semtot -= semaptr->sem_nsems; 436 for (i = semaptr->sem_base - sem; i < semtot; i++) 437 sem[i] = sem[i + semaptr->sem_nsems]; 438 for (i = 0; i < seminfo.semmni; i++) { 439 if ((sema[i].sem_perm.mode & SEM_ALLOC) && 440 sema[i].sem_base > semaptr->sem_base) 441 sema[i].sem_base -= semaptr->sem_nsems; 442 } 443 semaptr->sem_perm.mode = 0; 444 semundo_clear(semid, -1); 445 wakeup((caddr_t)semaptr); 446 break; 447 448 case IPC_SET: 449 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_M))) 450 return(eval); 451 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 452 return(eval); 453 if ((eval = copyin(real_arg.buf, (caddr_t)&sbuf, 454 sizeof(sbuf))) != 0) 455 return(eval); 456 semaptr->sem_perm.uid = sbuf.sem_perm.uid; 457 semaptr->sem_perm.gid = sbuf.sem_perm.gid; 458 semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) | 459 (sbuf.sem_perm.mode & 0777); 460 semaptr->sem_ctime = time_second; 461 break; 462 463 case IPC_STAT: 464 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_R))) 465 return(eval); 466 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 467 return(eval); 468 eval = copyout((caddr_t)semaptr, real_arg.buf, 469 sizeof(struct semid_ds)); 470 break; 471 472 case GETNCNT: 473 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_R))) 474 return(eval); 475 if (semnum < 0 || semnum >= semaptr->sem_nsems) 476 return(EINVAL); 477 rval = semaptr->sem_base[semnum].semncnt; 478 break; 479 480 case GETPID: 481 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_R))) 482 return(eval); 483 if (semnum < 0 || semnum >= semaptr->sem_nsems) 484 return(EINVAL); 485 rval = semaptr->sem_base[semnum].sempid; 486 break; 487 488 case GETVAL: 489 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_R))) 490 return(eval); 491 if (semnum < 0 || semnum >= semaptr->sem_nsems) 492 return(EINVAL); 493 rval = semaptr->sem_base[semnum].semval; 494 break; 495 496 case GETALL: 497 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_R))) 498 return(eval); 499 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 500 return(eval); 501 for (i = 0; i < semaptr->sem_nsems; i++) { 502 eval = copyout((caddr_t)&semaptr->sem_base[i].semval, 503 &real_arg.array[i], sizeof(real_arg.array[0])); 504 if (eval != 0) 505 break; 506 } 507 break; 508 509 case GETZCNT: 510 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_R))) 511 return(eval); 512 if (semnum < 0 || semnum >= semaptr->sem_nsems) 513 return(EINVAL); 514 rval = semaptr->sem_base[semnum].semzcnt; 515 break; 516 517 case SETVAL: 518 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_W))) 519 return(eval); 520 if (semnum < 0 || semnum >= semaptr->sem_nsems) 521 return(EINVAL); 522 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 523 return(eval); 524 semaptr->sem_base[semnum].semval = real_arg.val; 525 semundo_clear(semid, semnum); 526 wakeup((caddr_t)semaptr); 527 break; 528 529 case SETALL: 530 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_W))) 531 return(eval); 532 if ((eval = copyin(arg, &real_arg, sizeof(real_arg))) != 0) 533 return(eval); 534 for (i = 0; i < semaptr->sem_nsems; i++) { 535 eval = copyin(&real_arg.array[i], 536 (caddr_t)&semaptr->sem_base[i].semval, 537 sizeof(real_arg.array[0])); 538 if (eval != 0) 539 break; 540 } 541 semundo_clear(semid, -1); 542 wakeup((caddr_t)semaptr); 543 break; 544 545 default: 546 return(EINVAL); 547 } 548 549 if (eval == 0) 550 p->p_retval[0] = rval; 551 return(eval); 552 } 553 554 #ifndef _SYS_SYSPROTO_H_ 555 struct semget_args { 556 key_t key; 557 int nsems; 558 int semflg; 559 }; 560 #endif 561 562 int 563 semget(p, uap) 564 struct proc *p; 565 register struct semget_args *uap; 566 { 567 int semid, eval; 568 int key = uap->key; 569 int nsems = uap->nsems; 570 int semflg = uap->semflg; 571 struct ucred *cred = p->p_ucred; 572 573 #ifdef SEM_DEBUG 574 printf("semget(0x%x, %d, 0%o)\n", key, nsems, semflg); 575 #endif 576 577 if (!jail_sysvipc_allowed && p->p_prison != NULL) 578 return (ENOSYS); 579 580 if (key != IPC_PRIVATE) { 581 for (semid = 0; semid < seminfo.semmni; semid++) { 582 if ((sema[semid].sem_perm.mode & SEM_ALLOC) && 583 sema[semid].sem_perm.key == key) 584 break; 585 } 586 if (semid < seminfo.semmni) { 587 #ifdef SEM_DEBUG 588 printf("found public key\n"); 589 #endif 590 if ((eval = ipcperm(p, &sema[semid].sem_perm, 591 semflg & 0700))) 592 return(eval); 593 if (nsems > 0 && sema[semid].sem_nsems < nsems) { 594 #ifdef SEM_DEBUG 595 printf("too small\n"); 596 #endif 597 return(EINVAL); 598 } 599 if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) { 600 #ifdef SEM_DEBUG 601 printf("not exclusive\n"); 602 #endif 603 return(EEXIST); 604 } 605 goto found; 606 } 607 } 608 609 #ifdef SEM_DEBUG 610 printf("need to allocate the semid_ds\n"); 611 #endif 612 if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) { 613 if (nsems <= 0 || nsems > seminfo.semmsl) { 614 #ifdef SEM_DEBUG 615 printf("nsems out of range (0<%d<=%d)\n", nsems, 616 seminfo.semmsl); 617 #endif 618 return(EINVAL); 619 } 620 if (nsems > seminfo.semmns - semtot) { 621 #ifdef SEM_DEBUG 622 printf("not enough semaphores left (need %d, got %d)\n", 623 nsems, seminfo.semmns - semtot); 624 #endif 625 return(ENOSPC); 626 } 627 for (semid = 0; semid < seminfo.semmni; semid++) { 628 if ((sema[semid].sem_perm.mode & SEM_ALLOC) == 0) 629 break; 630 } 631 if (semid == seminfo.semmni) { 632 #ifdef SEM_DEBUG 633 printf("no more semid_ds's available\n"); 634 #endif 635 return(ENOSPC); 636 } 637 #ifdef SEM_DEBUG 638 printf("semid %d is available\n", semid); 639 #endif 640 sema[semid].sem_perm.key = key; 641 sema[semid].sem_perm.cuid = cred->cr_uid; 642 sema[semid].sem_perm.uid = cred->cr_uid; 643 sema[semid].sem_perm.cgid = cred->cr_gid; 644 sema[semid].sem_perm.gid = cred->cr_gid; 645 sema[semid].sem_perm.mode = (semflg & 0777) | SEM_ALLOC; 646 sema[semid].sem_perm.seq = 647 (sema[semid].sem_perm.seq + 1) & 0x7fff; 648 sema[semid].sem_nsems = nsems; 649 sema[semid].sem_otime = 0; 650 sema[semid].sem_ctime = time_second; 651 sema[semid].sem_base = &sem[semtot]; 652 semtot += nsems; 653 bzero(sema[semid].sem_base, 654 sizeof(sema[semid].sem_base[0])*nsems); 655 #ifdef SEM_DEBUG 656 printf("sembase = 0x%x, next = 0x%x\n", sema[semid].sem_base, 657 &sem[semtot]); 658 #endif 659 } else { 660 #ifdef SEM_DEBUG 661 printf("didn't find it and wasn't asked to create it\n"); 662 #endif 663 return(ENOENT); 664 } 665 666 found: 667 p->p_retval[0] = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm); 668 return(0); 669 } 670 671 #ifndef _SYS_SYSPROTO_H_ 672 struct semop_args { 673 int semid; 674 struct sembuf *sops; 675 int nsops; 676 }; 677 #endif 678 679 int 680 semop(p, uap) 681 struct proc *p; 682 register struct semop_args *uap; 683 { 684 int semid = uap->semid; 685 int nsops = uap->nsops; 686 struct sembuf sops[MAX_SOPS]; 687 register struct semid_ds *semaptr; 688 register struct sembuf *sopptr; 689 register struct sem *semptr; 690 struct sem_undo *suptr = NULL; 691 int i, j, eval; 692 int do_wakeup, do_undos; 693 694 #ifdef SEM_DEBUG 695 printf("call to semop(%d, 0x%x, %d)\n", semid, sops, nsops); 696 #endif 697 698 if (!jail_sysvipc_allowed && p->p_prison != NULL) 699 return (ENOSYS); 700 701 semid = IPCID_TO_IX(semid); /* Convert back to zero origin */ 702 703 if (semid < 0 || semid >= seminfo.semmsl) 704 return(EINVAL); 705 706 semaptr = &sema[semid]; 707 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0) 708 return(EINVAL); 709 if (semaptr->sem_perm.seq != IPCID_TO_SEQ(uap->semid)) 710 return(EINVAL); 711 712 if ((eval = ipcperm(p, &semaptr->sem_perm, IPC_W))) { 713 #ifdef SEM_DEBUG 714 printf("eval = %d from ipaccess\n", eval); 715 #endif 716 return(eval); 717 } 718 719 if (nsops > MAX_SOPS) { 720 #ifdef SEM_DEBUG 721 printf("too many sops (max=%d, nsops=%d)\n", MAX_SOPS, nsops); 722 #endif 723 return(E2BIG); 724 } 725 726 if ((eval = copyin(uap->sops, &sops, nsops * sizeof(sops[0]))) != 0) { 727 #ifdef SEM_DEBUG 728 printf("eval = %d from copyin(%08x, %08x, %d)\n", eval, 729 uap->sops, &sops, nsops * sizeof(sops[0])); 730 #endif 731 return(eval); 732 } 733 734 /* 735 * Loop trying to satisfy the vector of requests. 736 * If we reach a point where we must wait, any requests already 737 * performed are rolled back and we go to sleep until some other 738 * process wakes us up. At this point, we start all over again. 739 * 740 * This ensures that from the perspective of other tasks, a set 741 * of requests is atomic (never partially satisfied). 742 */ 743 do_undos = 0; 744 745 for (;;) { 746 do_wakeup = 0; 747 748 for (i = 0; i < nsops; i++) { 749 sopptr = &sops[i]; 750 751 if (sopptr->sem_num >= semaptr->sem_nsems) 752 return(EFBIG); 753 754 semptr = &semaptr->sem_base[sopptr->sem_num]; 755 756 #ifdef SEM_DEBUG 757 printf("semop: semaptr=%x, sem_base=%x, semptr=%x, sem[%d]=%d : op=%d, flag=%s\n", 758 semaptr, semaptr->sem_base, semptr, 759 sopptr->sem_num, semptr->semval, sopptr->sem_op, 760 (sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait"); 761 #endif 762 763 if (sopptr->sem_op < 0) { 764 if (semptr->semval + sopptr->sem_op < 0) { 765 #ifdef SEM_DEBUG 766 printf("semop: can't do it now\n"); 767 #endif 768 break; 769 } else { 770 semptr->semval += sopptr->sem_op; 771 if (semptr->semval == 0 && 772 semptr->semzcnt > 0) 773 do_wakeup = 1; 774 } 775 if (sopptr->sem_flg & SEM_UNDO) 776 do_undos = 1; 777 } else if (sopptr->sem_op == 0) { 778 if (semptr->semval > 0) { 779 #ifdef SEM_DEBUG 780 printf("semop: not zero now\n"); 781 #endif 782 break; 783 } 784 } else { 785 if (semptr->semncnt > 0) 786 do_wakeup = 1; 787 semptr->semval += sopptr->sem_op; 788 if (sopptr->sem_flg & SEM_UNDO) 789 do_undos = 1; 790 } 791 } 792 793 /* 794 * Did we get through the entire vector? 795 */ 796 if (i >= nsops) 797 goto done; 798 799 /* 800 * No ... rollback anything that we've already done 801 */ 802 #ifdef SEM_DEBUG 803 printf("semop: rollback 0 through %d\n", i-1); 804 #endif 805 for (j = 0; j < i; j++) 806 semaptr->sem_base[sops[j].sem_num].semval -= 807 sops[j].sem_op; 808 809 /* 810 * If the request that we couldn't satisfy has the 811 * NOWAIT flag set then return with EAGAIN. 812 */ 813 if (sopptr->sem_flg & IPC_NOWAIT) 814 return(EAGAIN); 815 816 if (sopptr->sem_op == 0) 817 semptr->semzcnt++; 818 else 819 semptr->semncnt++; 820 821 #ifdef SEM_DEBUG 822 printf("semop: good night!\n"); 823 #endif 824 eval = tsleep((caddr_t)semaptr, (PZERO - 4) | PCATCH, 825 "semwait", 0); 826 #ifdef SEM_DEBUG 827 printf("semop: good morning (eval=%d)!\n", eval); 828 #endif 829 830 suptr = NULL; /* sem_undo may have been reallocated */ 831 832 if (eval != 0) 833 return(EINTR); 834 #ifdef SEM_DEBUG 835 printf("semop: good morning!\n"); 836 #endif 837 838 /* 839 * Make sure that the semaphore still exists 840 */ 841 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 || 842 semaptr->sem_perm.seq != IPCID_TO_SEQ(uap->semid)) 843 return(EIDRM); 844 845 /* 846 * The semaphore is still alive. Readjust the count of 847 * waiting processes. 848 */ 849 if (sopptr->sem_op == 0) 850 semptr->semzcnt--; 851 else 852 semptr->semncnt--; 853 } 854 855 done: 856 /* 857 * Process any SEM_UNDO requests. 858 */ 859 if (do_undos) { 860 for (i = 0; i < nsops; i++) { 861 /* 862 * We only need to deal with SEM_UNDO's for non-zero 863 * op's. 864 */ 865 int adjval; 866 867 if ((sops[i].sem_flg & SEM_UNDO) == 0) 868 continue; 869 adjval = sops[i].sem_op; 870 if (adjval == 0) 871 continue; 872 eval = semundo_adjust(p, &suptr, semid, 873 sops[i].sem_num, -adjval); 874 if (eval == 0) 875 continue; 876 877 /* 878 * Oh-Oh! We ran out of either sem_undo's or undo's. 879 * Rollback the adjustments to this point and then 880 * rollback the semaphore ups and down so we can return 881 * with an error with all structures restored. We 882 * rollback the undo's in the exact reverse order that 883 * we applied them. This guarantees that we won't run 884 * out of space as we roll things back out. 885 */ 886 for (j = i - 1; j >= 0; j--) { 887 if ((sops[j].sem_flg & SEM_UNDO) == 0) 888 continue; 889 adjval = sops[j].sem_op; 890 if (adjval == 0) 891 continue; 892 if (semundo_adjust(p, &suptr, semid, 893 sops[j].sem_num, adjval) != 0) 894 panic("semop - can't undo undos"); 895 } 896 897 for (j = 0; j < nsops; j++) 898 semaptr->sem_base[sops[j].sem_num].semval -= 899 sops[j].sem_op; 900 901 #ifdef SEM_DEBUG 902 printf("eval = %d from semundo_adjust\n", eval); 903 #endif 904 return(eval); 905 } /* loop through the sops */ 906 } /* if (do_undos) */ 907 908 /* We're definitely done - set the sempid's */ 909 for (i = 0; i < nsops; i++) { 910 sopptr = &sops[i]; 911 semptr = &semaptr->sem_base[sopptr->sem_num]; 912 semptr->sempid = p->p_pid; 913 } 914 915 /* Do a wakeup if any semaphore was up'd. */ 916 if (do_wakeup) { 917 #ifdef SEM_DEBUG 918 printf("semop: doing wakeup\n"); 919 #endif 920 wakeup((caddr_t)semaptr); 921 #ifdef SEM_DEBUG 922 printf("semop: back from wakeup\n"); 923 #endif 924 } 925 #ifdef SEM_DEBUG 926 printf("semop: done\n"); 927 #endif 928 p->p_retval[0] = 0; 929 return(0); 930 } 931 932 /* 933 * Go through the undo structures for this process and apply the adjustments to 934 * semaphores. 935 */ 936 void 937 semexit(p) 938 struct proc *p; 939 { 940 register struct sem_undo *suptr; 941 register struct sem_undo **supptr; 942 int did_something; 943 944 did_something = 0; 945 946 /* 947 * Go through the chain of undo vectors looking for one 948 * associated with this process. 949 */ 950 951 for (supptr = &semu_list; (suptr = *supptr) != NULL; 952 supptr = &suptr->un_next) { 953 if (suptr->un_proc == p) 954 break; 955 } 956 957 if (suptr == NULL) 958 return; 959 960 #ifdef SEM_DEBUG 961 printf("proc @%08x has undo structure with %d entries\n", p, 962 suptr->un_cnt); 963 #endif 964 965 /* 966 * If there are any active undo elements then process them. 967 */ 968 if (suptr->un_cnt > 0) { 969 int ix; 970 971 for (ix = 0; ix < suptr->un_cnt; ix++) { 972 int semid = suptr->un_ent[ix].un_id; 973 int semnum = suptr->un_ent[ix].un_num; 974 int adjval = suptr->un_ent[ix].un_adjval; 975 struct semid_ds *semaptr; 976 977 semaptr = &sema[semid]; 978 if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0) 979 panic("semexit - semid not allocated"); 980 if (semnum >= semaptr->sem_nsems) 981 panic("semexit - semnum out of range"); 982 983 #ifdef SEM_DEBUG 984 printf("semexit: %08x id=%d num=%d(adj=%d) ; sem=%d\n", 985 suptr->un_proc, suptr->un_ent[ix].un_id, 986 suptr->un_ent[ix].un_num, 987 suptr->un_ent[ix].un_adjval, 988 semaptr->sem_base[semnum].semval); 989 #endif 990 991 if (adjval < 0) { 992 if (semaptr->sem_base[semnum].semval < -adjval) 993 semaptr->sem_base[semnum].semval = 0; 994 else 995 semaptr->sem_base[semnum].semval += 996 adjval; 997 } else 998 semaptr->sem_base[semnum].semval += adjval; 999 1000 wakeup((caddr_t)semaptr); 1001 #ifdef SEM_DEBUG 1002 printf("semexit: back from wakeup\n"); 1003 #endif 1004 } 1005 } 1006 1007 /* 1008 * Deallocate the undo vector. 1009 */ 1010 #ifdef SEM_DEBUG 1011 printf("removing vector\n"); 1012 #endif 1013 suptr->un_proc = NULL; 1014 *supptr = suptr->un_next; 1015 } 1016