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