![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sem386.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / io.386|
Return to sem386.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / io.386 |
1.1 ! root 1: /* ! 2: * File: sem1.c ! 3: * ! 4: * Purpose: This module provides System V compatible semaphore operations. ! 5: * ! 6: * $Log: sem386.c,v $ ! 7: * Revision 1.2 93/04/20 10:00:32 bin ! 8: * kernel 77: vlad: sem_undo and other changes ! 9: * ! 10: * Revision 1.1 93/04/09 08:48:23 bin ! 11: * Initial revision ! 12: * ! 13: */ ! 14: ! 15: /* ! 16: * ---------------------------------------------------------------------- ! 17: * Includes. ! 18: */ ! 19: #include <sys/coherent.h> ! 20: #include <sys/sched.h> ! 21: #if 0 ! 22: #include <sys/proc.h> ! 23: #endif ! 24: #include <sys/types.h> ! 25: #include <sys/uproc.h> ! 26: #include <errno.h> ! 27: #include <sys/stat.h> ! 28: #include <sys/con.h> ! 29: #include <sys/sem.h> ! 30: ! 31: /* ! 32: * ---------------------------------------------------------------------- ! 33: * Definitions. ! 34: * Constants. ! 35: * Macros with argument lists. ! 36: * Typedefs. ! 37: * Enums. ! 38: */ ! 39: ! 40: /* ! 41: * ---------------------------------------------------------------------- ! 42: * Functions. ! 43: * Import Functions. ! 44: * Export Functions. ! 45: * Local Functions. ! 46: */ ! 47: int iSemPerm(); /* Check permissions */ ! 48: int iSanityCheck(); /* Sanity check */ ! 49: int iSemInit(); /* Init semaphores */ ! 50: void vClearAdj(); /* Clear the adjust value */ ! 51: int iSubAdj(); /* Subtract value from the sem adjust */ ! 52: /* ! 53: * ---------------------------------------------------------------------- ! 54: * Global Data. ! 55: * Import Variables. ! 56: * Export Variables. ! 57: * Local Variables. ! 58: */ ! 59: /* Patchable values */ ! 60: int SEMMNI = 10; /* max # of the semaphore sets, systemwide */ ! 61: int SEMMNS = 60; /* max # of semaphores, systemwide */ ! 62: int SEMMSL = 25; /* max # of semaphores per set */ ! 63: int SEMVMX = 32767; /* max value of any semaphore */ ! 64: ! 65: struct semid_ds *semids = NULL; /* Array of semaphore sets */ ! 66: int iSemTotal = 0; /* Total number of semaphores, systemwide */ ! 67: GATE gSemGate; /* Semaphore gate. */ ! 68: unsigned short usSEM_R = 0444; /* Permission definition for read */ ! 69: unsigned short usSEM_A = 0222; /* and alter */ ! 70: ! 71: /* ! 72: * ---------------------------------------------------------------------- ! 73: * Code. ! 74: */ ! 75: ! 76: /* ! 77: * Semget gets set of semaphores. Returns semaphore set id on suuccess, ! 78: * or sets u.u_error on error. ! 79: */ ! 80: usemget(skey, nsems, semflg) ! 81: key_t skey; /* Semaphore key */ ! 82: int nsems, /* # of semaphores in the set */ ! 83: semflg; /* Permission flag */ ! 84: { ! 85: register struct semid_ds *semidp; /* Semaphore set */ ! 86: register struct sem *semp; /* Semaphores */ ! 87: struct semid_ds *freeidp = 0; /* Oldest free set */ ! 88: ! 89: if (iSanityCheck(nsems)) ! 90: return; ! 91: ! 92: /* Allocate memmory on the first semget. This memory (~300 bytes) ! 93: * will stay alloc up to the next reboot. The alloced unused memory ! 94: * is smaller than code that will allow to manage it more sophisticated. ! 95: * Allocaton is used to allow patchability of the semaphores. ! 96: */ ! 97: if (semids == NULL) { ! 98: if (iSemInit()) { ! 99: u.u_error = ENOSPC; ! 100: return; ! 101: } ! 102: } ! 103: lock(gSemGate); /* Lock semaphore operations */ ! 104: ! 105: /* Now we will go through all semaphores. */ ! 106: for (semidp = semids; semidp < semids + SEMMNI; semidp++) { ! 107: /* If set is free look for the oldest */ ! 108: if ((semidp->sem_perm.mode & IPC_ALLOC) == 0) { ! 109: if ((freeidp == 0) || ! 110: (freeidp->sem_ctime > semidp->sem_ctime)) ! 111: freeidp = semidp; ! 112: continue; ! 113: } ! 114: ! 115: /* Check if a request was for the private set */ ! 116: if (skey == IPC_PRIVATE) ! 117: continue; ! 118: ! 119: if (skey != semidp->sem_perm.key) ! 120: continue; ! 121: /* Found */ ! 122: /* Exclusive set cannot be created */ ! 123: if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) { ! 124: unlock(gSemGate); ! 125: u.u_error = EEXIST; ! 126: return; ! 127: } ! 128: ! 129: /* Check the permissions */ ! 130: if (iSemPerm(semidp, semflg)) { ! 131: unlock(gSemGate); ! 132: return; ! 133: } ! 134: ! 135: /* Check the requested number of semaphores */ ! 136: if (semidp->sem_nsems < nsems) { ! 137: unlock(gSemGate); ! 138: u.u_error = EINVAL; ! 139: return; ! 140: } ! 141: /* Semaphore set id number is the number of an array element */ ! 142: unlock(gSemGate); ! 143: return semidp - semids; ! 144: } ! 145: ! 146: /* Set does not exist. So, we have to create it */ ! 147: /* Now nsems should be > 0 */ ! 148: if (nsems < 1) { ! 149: unlock(gSemGate); ! 150: u.u_error = EINVAL; ! 151: return; ! 152: } ! 153: ! 154: /* Check the total number of semaphores */ ! 155: if ((iSemTotal + nsems > SEMMNS)) { ! 156: unlock(gSemGate); ! 157: u.u_error = ENOSPC; ! 158: return; ! 159: } ! 160: ! 161: /* Check if there is the request for creation */ ! 162: if (!(semflg & IPC_CREAT)) { ! 163: unlock(gSemGate); ! 164: u.u_error = ENOENT; ! 165: return; ! 166: } ! 167: ! 168: /* Out of system limits */ ! 169: if (freeidp == 0) { ! 170: unlock(gSemGate); ! 171: u.u_error = ENOSPC; ! 172: return; ! 173: } ! 174: ! 175: /* Now we have to creat a new set. freeidp points to the oldest free ! 176: * set which we will use. ! 177: */ ! 178: semidp = freeidp; ! 179: /* Get space for semaphores */ ! 180: semidp->sem_base = kalloc(nsems * sizeof(struct sem)); ! 181: if (semidp->sem_base == 0) { ! 182: unlock(gSemGate); ! 183: u.u_error = ENOSPC; ! 184: return; ! 185: } ! 186: ! 187: /* Initialize created set */ ! 188: /* ipc_perm */ ! 189: semidp->sem_perm.cuid = semidp->sem_perm.uid = u.u_uid; ! 190: semidp->sem_perm.cgid = semidp->sem_perm.gid = u.u_gid; ! 191: semidp->sem_perm.mode = (semflg & 0777) | IPC_ALLOC; ! 192: semidp->sem_perm.key = skey; ! 193: semidp->sem_perm.seq = semidp - semids; ! 194: ! 195: semidp->sem_nsems = nsems; ! 196: semidp->sem_otime = 0; ! 197: semidp->sem_ctime = timer.t_time; ! 198: ! 199: /* Increment number of semaphores in used */ ! 200: iSemTotal += nsems; ! 201: ! 202: /* Set values of the semaphores to 0. ! 203: * SVR3 does not do it and suggests set up sem struct using ! 204: * semctl() call. SVR4 manual says nothing about it. ! 205: */ ! 206: for (semp = semidp->sem_base; semp < semidp->sem_base + nsems; semp++){ ! 207: semp->semval = semp->sempid = semp->semncnt = semp->semzcnt = 0; ! 208: } ! 209: unlock(gSemGate); ! 210: return semidp - semids; ! 211: } ! 212: ! 213: /* ! 214: * Semctl provides semaphore control operation as specify by cmd. ! 215: * On success return value depends on cmd, sets u.u_error on error. ! 216: */ ! 217: usemctl(semid, semnum, cmd, arg) ! 218: int semid, /* Semaphore set id */ ! 219: cmd; /* Command */ ! 220: int semnum; /* Semaphore # */ ! 221: union semun { ! 222: int val; /* Used for SETVAL only */ ! 223: struct semid_ds *buf; /* Used for IPC_STAT and IPC_SET */ ! 224: unsigned short *array; /* Used for IPC_GET_ALL and IPC_SETALL */ ! 225: } arg; ! 226: ! 227: { ! 228: register struct semid_ds *semidp; /* Semaphore set */ ! 229: register struct sem *semp; /* Semaphore */ ! 230: int val; /* Semaphore value */ ! 231: int i; /* Loopindex */ ! 232: unsigned short *pusUserAr; /* User array */ ! 233: ! 234: if (iSanityCheck(semnum)) ! 235: return; ! 236: ! 237: /* Check if there was any successfull semget before. ! 238: * Problem may be if somebody does semctl() before semids was ! 239: * alloced. ! 240: */ ! 241: if (semids == 0) { ! 242: u.u_error = EINVAL; ! 243: return; ! 244: } ! 245: ! 246: /* semid cannot be < 0 and more than systemwide limit */ ! 247: if (semid < 0 || semid >= SEMMNI) { ! 248: u.u_error = EINVAL; ! 249: return; ! 250: } ! 251: semidp = semids + semid; ! 252: ! 253: /* Check if the requested set is alloced */ ! 254: if ((semidp->sem_perm.mode & IPC_ALLOC) == 0) { ! 255: u.u_error = EINVAL; ! 256: return; ! 257: } ! 258: ! 259: /* Check if semnum is a correct semaphore number. ! 260: * SV would do it only when there is request for a ! 261: * single semaphore value, as GETVAL or SETVAL. ! 262: */ ! 263: if (semnum >= semidp->sem_nsems) { ! 264: u.u_error = EFBIG; ! 265: return; ! 266: } ! 267: ! 268: semp = semidp->sem_base + semnum; ! 269: ! 270: switch (cmd) { ! 271: case GETVAL: /* Return value of semval */ ! 272: if (iSemPerm(semidp, usSEM_R)) /* cannot read */ ! 273: return; ! 274: return semp->semval; ! 275: case SETVAL: /* Set semval. Clear all semadj values on success. */ ! 276: if (iSemPerm(semidp, usSEM_A)) /* cannot alter */ ! 277: return; ! 278: /* semval always >= 0 */ ! 279: if (arg.val > SEMVMX || arg.val < 0) { /* illegal value */ ! 280: u.u_error = ERANGE; ! 281: return; ! 282: } ! 283: /* Set semval and wakeup whatever should be */ ! 284: if (semp->semval = arg.val) { ! 285: if (semp->semncnt) ! 286: wakeup(&semp->semncnt); ! 287: } else { ! 288: if (semp->semzcnt) ! 289: wakeup(&semp->semzcnt); ! 290: } ! 291: semidp->sem_ctime = timer.t_time; ! 292: /* Clear corresponding adjust value in all processes */ ! 293: vClearAdj(semid, semnum); ! 294: return 0; ! 295: case GETPID: /* Return value of sempid */ ! 296: if (iSemPerm(semidp, usSEM_R)) /* cannot read */ ! 297: return; ! 298: return semp->sempid; ! 299: case GETNCNT: /* Return value of semncnt */ ! 300: if (iSemPerm(semidp, usSEM_R)) /* cannot read */ ! 301: return; ! 302: return semp->semncnt; ! 303: case GETZCNT: /* Return value of semzcnt */ ! 304: if (iSemPerm(semidp, usSEM_R)) /* cannot read */ ! 305: return; ! 306: return semp->semzcnt; ! 307: case GETALL: /* Return semvals array */ ! 308: if (iSemPerm(semidp, usSEM_R)) /* cannot read */ ! 309: return; ! 310: /* Copy all values to user array */ ! 311: semp = semidp->sem_base; ! 312: pusUserAr = arg.array; ! 313: for (i = 0; i < semidp->sem_nsems; i++) { ! 314: putusd(pusUserAr, semp->semval); ! 315: if (u.u_error) ! 316: return; ! 317: semp++; ! 318: pusUserAr++; ! 319: } ! 320: return 0; ! 321: case SETALL: /* Set semvals array */ ! 322: if (iSemPerm(semidp, SEM_A)) /* cannot alter */ ! 323: return; ! 324: ! 325: /* Set semvals accoding to the arg.array */ ! 326: semp = semidp->sem_base; ! 327: pusUserAr = arg.array; ! 328: lock(gSemGate); ! 329: for (i = 0; i < semidp->sem_nsems; i++) { ! 330: val = getusd(pusUserAr++); ! 331: if (u.u_error) { ! 332: unlock(gSemGate); ! 333: return; ! 334: } ! 335: if (val < 0 || val > SEMVMX) { ! 336: u.u_error = ERANGE; ! 337: unlock(gSemGate); ! 338: return; ! 339: } ! 340: semp->semval = val; ! 341: /* Clear corresponding adjust value in all processes. */ ! 342: vClearAdj(semid, i); ! 343: semp++; ! 344: } ! 345: semidp->sem_ctime = timer.t_time; ! 346: unlock(gSemGate); ! 347: return 0; ! 348: case IPC_STAT: ! 349: if (iSemPerm(semidp, usSEM_R)) /* cannot read */ ! 350: return; ! 351: kucopy(semidp, arg.buf, sizeof(struct semid_ds)); ! 352: return 0; ! 353: case IPC_SET: ! 354: if (iSemPerm(semidp, SEM_A)) /* cannot alter */ ! 355: return; ! 356: semidp->sem_perm.uid = getusd(&((arg.buf)->sem_perm.uid)); ! 357: semidp->sem_perm.gid = getusd(&((arg.buf)->sem_perm.gid)); ! 358: semidp->sem_perm.mode = ! 359: (getusd(&((arg.buf)->sem_perm.mode))&0777) | IPC_ALLOC; ! 360: semidp->sem_ctime = timer.t_time; ! 361: return 0; ! 362: case IPC_RMID: ! 363: if ((u.u_uid != 0) && (u.u_uid != semidp->sem_perm.uid) ! 364: && u.u_uid != semidp->sem_perm.cuid) { ! 365: u.u_error = EPERM; ! 366: return; ! 367: } ! 368: ! 369: /* We have to wake up all waiting proccesses */ ! 370: for (semp = semidp->sem_base; semp < semidp->sem_base + ! 371: semidp->sem_nsems; semp++) { ! 372: if (semp->semncnt) ! 373: wakeup(&semp->semncnt); ! 374: if (semp->semzcnt) ! 375: wakeup(&semp->semzcnt); ! 376: } ! 377: /* We do not cleane up adjust values here */ ! 378: iSemTotal -= semidp->sem_nsems; ! 379: semidp->sem_perm.mode = 0; ! 380: kfree(semidp->sem_base); ! 381: return 0; ! 382: default: ! 383: u.u_error = EINVAL; ! 384: return; ! 385: } ! 386: } ! 387: ! 388: /* ! 389: * Semop - Semaphore Operations. ! 390: */ ! 391: usemop(iSemId, pstSops, uNsops) ! 392: int iSemId; /* Semaphore identifier */ ! 393: struct sembuf *pstSops; /* Array of sem. operations */ ! 394: unsigned uNsops; /* # of elements in the array */ ! 395: { ! 396: register struct semid_ds *rpstSemSet; /* Semaphore set */ ! 397: register struct sem *rpstSem; /* Semaphore */ ! 398: struct sembuf *pstSemBuf; /* Operations */ ! 399: unsigned short usSemNum; /* Semaphore number */ ! 400: short sSemFlg; /* Semaphore flag */ ! 401: short sSemOper; /* Operation */ ! 402: int i; /* Loop index */ ! 403: short change = 0; /* Sem was changed */ ! 404: ! 405: /* Check if semids was alloced */ ! 406: if (semids == 0) { ! 407: u.u_error = EINVAL; ! 408: return; ! 409: } ! 410: /* iSemId cannot be < 0 and more than systemwide limit */ ! 411: if (iSemId < 0 || iSemId >= SEMMNI) { ! 412: u.u_error = EINVAL; ! 413: return; ! 414: } ! 415: if (!useracc(pstSops, sizeof(struct sembuf) * uNsops, 0) || uNsops<1) { ! 416: u.u_error = EFAULT; ! 417: return; ! 418: } ! 419: ! 420: rpstSemSet = semids + iSemId; /* Requested set */ ! 421: ! 422: if ((rpstSemSet->sem_perm.mode & IPC_ALLOC) == 0) { ! 423: u.u_error = EINVAL; ! 424: return -1; ! 425: } ! 426: TRY_AGAIN: /* Repeat the semaphore set */ ! 427: ! 428: /* Lock semaphore system */ ! 429: lock(gSemGate); ! 430: ! 431: /* do semaphore ops */ ! 432: for (i = 0, pstSemBuf = pstSops; i < uNsops; i++, pstSemBuf++) { ! 433: usSemNum = getusd(&(pstSemBuf->sem_num)); ! 434: sSemOper = getusd(&(pstSemBuf->sem_op)); ! 435: sSemFlg = getusd(&(pstSemBuf->sem_flg)); ! 436: ! 437: if (sSemOper < -SEMVMX || sSemOper > SEMVMX) { ! 438: semundo(rpstSemSet, pstSops, i); ! 439: u.u_error = E2BIG; ! 440: unlock(gSemGate); ! 441: return; ! 442: } ! 443: if ((u.u_error != 0) || (usSemNum >= rpstSemSet->sem_nsems)) { ! 444: /* We have falure here. undo all previous ! 445: * operations. ! 446: */ ! 447: semundo(rpstSemSet, pstSops, i); ! 448: /* If u_error was not set it means that sem_number ! 449: * is bad. So, set error to EFBIG. ! 450: */ ! 451: if (u.u_error == 0) ! 452: u.u_error = EFBIG; ! 453: unlock(gSemGate); ! 454: return; ! 455: } ! 456: ! 457: /* Go to proper semaphore */ ! 458: rpstSem = rpstSemSet->sem_base + usSemNum; ! 459: ! 460: /* We can have 3 different cases: sSemOper < 0, ! 461: * sSemOper == 0, & sSemOper > 0. ! 462: */ ! 463: if (sSemOper < 0) { /* want to decrement semval */ ! 464: /* We do not have to undo anything. If we cannot alter ! 465: * we did not change any value in the set. But we ! 466: * have to check here because other requests could be ! 467: * for read (sSemOper=0) ! 468: */ ! 469: if (iSemPerm(rpstSemSet, SEM_A)) { /* cannot alter */ ! 470: unlock(gSemGate); ! 471: return; ! 472: } ! 473: ! 474: /* If we can decrement semval, do it. If ! 475: * semval becomes 0 wakeup all processes ! 476: * waiting for semval==0. ! 477: */ ! 478: if (rpstSem->semval >= -sSemOper) { ! 479: if (!(rpstSem->semval += sSemOper)) ! 480: if (rpstSem->semzcnt) ! 481: wakeup(&rpstSem->semzcnt); ! 482: if (sSemFlg & SEM_UNDO) { ! 483: if (iSubAdj(iSemId,usSemNum,sSemOper)) { ! 484: semundo(rpstSemSet, pstSops, i); ! 485: unlock(gSemGate); ! 486: return; ! 487: } ! 488: } ! 489: change++; ! 490: continue; ! 491: } ! 492: /* Can't decrement. */ ! 493: semundo(rpstSemSet, pstSops, i); ! 494: if (sSemFlg & IPC_NOWAIT) { ! 495: if (u.u_error == 0) ! 496: u.u_error = EAGAIN; ! 497: unlock(gSemGate); ! 498: return; ! 499: } else {/* Go to sleep */ ! 500: unlock(gSemGate); ! 501: if (semwait(iSemId, &rpstSem->semncnt) < 0) { ! 502: return; ! 503: } ! 504: /* Now we can retry semaphore set */ ! 505: goto TRY_AGAIN; ! 506: } ! 507: } ! 508: if (sSemOper == 0) { ! 509: if (iSemPerm(rpstSemSet, SEM_R)) { /* cannot read */ ! 510: /* If somebody cannot read it does not ! 511: * mean that one couldn't alter. ! 512: */ ! 513: if (iSemPerm(rpstSemSet, SEM_A)) ! 514: semundo(rpstSemSet, pstSops, i); ! 515: ! 516: unlock(gSemGate); ! 517: return; ! 518: } ! 519: if (rpstSem->semval == 0) { ! 520: continue; ! 521: } ! 522: /* Semaphore value isn't 0. Undo all previous ! 523: * operations. ! 524: */ ! 525: semundo(rpstSemSet, pstSops, i); ! 526: ! 527: if (sSemFlg & IPC_NOWAIT) { ! 528: if (u.u_error == 0) ! 529: u.u_error = EAGAIN; ! 530: unlock(gSemGate); ! 531: return; ! 532: } ! 533: ! 534: unlock(gSemGate); ! 535: if (semwait(iSemId, &rpstSem->semzcnt) < 0) { ! 536: return; ! 537: } ! 538: goto TRY_AGAIN; ! 539: } ! 540: if (sSemOper > 0) { ! 541: if (iSemPerm(rpstSemSet, SEM_A)) { /* cannot alter */ ! 542: unlock(gSemGate); ! 543: return; ! 544: } ! 545: if (sSemFlg & SEM_UNDO) { ! 546: if (iSubAdj(iSemId, usSemNum, sSemOper)) { ! 547: semundo(rpstSemSet, pstSops, i); ! 548: unlock(gSemGate); ! 549: return; ! 550: } ! 551: } ! 552: if (rpstSem->semval > SEMVMX - sSemOper) { ! 553: semundo(rpstSemSet, pstSops, i); ! 554: /* semundo would not adjust current semaphore */ ! 555: if (sSemFlg & SEM_UNDO) { ! 556: iSubAdj(iSemId, usSemNum, -sSemOper); ! 557: } ! 558: u.u_error = ERANGE; ! 559: unlock(gSemGate); ! 560: return; ! 561: } ! 562: rpstSem->semval += sSemOper; ! 563: ! 564: /* Wake up waiting processes */ ! 565: if (rpstSem->semncnt) ! 566: wakeup(&rpstSem->semncnt); ! 567: change++; ! 568: continue; ! 569: } ! 570: } ! 571: rpstSemSet->sem_otime = timer.t_time; /* adjust semop time */ ! 572: if (change) /* Semaphore was changed */ ! 573: rpstSemSet->sem_ctime = timer.t_time; ! 574: ! 575: /* Go through all set again and set pid of last semop */ ! 576: for (i = 0, pstSemBuf = pstSops; i < uNsops; i++, pstSemBuf++) { ! 577: usSemNum = getusd(&(pstSemBuf->sem_num)); ! 578: rpstSem = rpstSemSet->sem_base + usSemNum; ! 579: rpstSem->sempid = SELF->p_pid; ! 580: } ! 581: unlock(gSemGate); ! 582: return 0; /* return last prev semval */ ! 583: } ! 584: ! 585: /* ! 586: * Wait for an event. ! 587: */ ! 588: semwait(iSemId, usSleepEvent) ! 589: int iSemId; /* Semaphore set id */ ! 590: unsigned short *usSleepEvent; /* Could be semcnt or semzcnt */ ! 591: { ! 592: register struct semid_ds *rpstSemSet; /* Semaphore set */ ! 593: ! 594: (*usSleepEvent)++; ! 595: ! 596: rpstSemSet = semids + iSemId; ! 597: ! 598: x_sleep(usSleepEvent, pritty, slpriSigCatch, "semwait"); ! 599: ! 600: if (!(rpstSemSet->sem_perm.mode & IPC_ALLOC)) { /* Semaphore gone */ ! 601: u.u_error = EIDRM; ! 602: return -1; ! 603: } ! 604: (*usSleepEvent)--; ! 605: ! 606: if (SELF->p_ssig && nondsig()) { /* Signal received */ ! 607: u.u_error = EINTR; ! 608: return -1; ! 609: } ! 610: return 0; ! 611: } ! 612: ! 613: /* ! 614: * Undo a Semaphore Operation. It should undo an adjust values too. ! 615: */ ! 616: semundo(pstSemSet, pstSemOp, iUndo) ! 617: struct semid_ds *pstSemSet; /* Pointer to the semaphore set */ ! 618: struct sembuf *pstSemOp; /* Pointer to the undo operation */ ! 619: int iUndo; /* Number of semaphores to undo */ ! 620: { ! 621: register struct sem *rpstSem; /* */ ! 622: register struct sembuf *rpstBuf; /* */ ! 623: register int i; /* Loop index */ ! 624: int iSemId; /* Semaphore id */ ! 625: unsigned short usSemNum; /* Semaphore number */ ! 626: short sSemOper; /* Value to undo */ ! 627: short sSemFlg; /* Semaphore flag */ ! 628: ! 629: rpstSem = pstSemSet->sem_base; ! 630: rpstBuf = pstSemOp; ! 631: iSemId = pstSemSet - semids; ! 632: for (i = 0; i < iUndo; i++) { ! 633: usSemNum = getusd( &(rpstBuf->sem_num) ); ! 634: sSemOper = getusd( &(rpstBuf->sem_op) ); ! 635: sSemFlg = getusd( &(rpstBuf->sem_flg) ); ! 636: rpstSem->semval -= sSemOper; ! 637: if (sSemFlg & SEM_UNDO) { ! 638: iSubAdj(iSemId, usSemNum, -sSemOper); ! 639: } ! 640: rpstBuf++; ! 641: rpstSem++; ! 642: } ! 643: } ! 644: ! 645: /* ! 646: * Check permissions of the semaphore set. ! 647: * Return 0 on success, -1 and set errno on error. ! 648: */ ! 649: int iSemPerm(pstSemId, iSemFlg) ! 650: struct semid_ds *pstSemId; /* Pointer to the semaphor set */ ! 651: int iSemFlg; /* Requested permissions */ ! 652: { ! 653: int iSemMode; ! 654: ! 655: /* Check if resource is alloced */ ! 656: if ((pstSemId->sem_perm.mode & IPC_ALLOC) == 0) { ! 657: u.u_error = EINVAL; ! 658: return -1; ! 659: } ! 660: ! 661: /* We need 9 lower order bits. There is a question what we have to do ! 662: * if someone sets an execute bits on. At this point we just ignore ! 663: * them. ! 664: */ ! 665: iSemMode = iSemFlg & 0666; ! 666: ! 667: /* For superuser or if mode is 0 */ ! 668: if (u.u_uid == 0 || !iSemMode) ! 669: return 0; ! 670: ! 671: /* For owner or creator */ ! 672: if (u.u_uid == pstSemId->sem_perm.uid || u.u_uid ! 673: == pstSemId->sem_perm.cuid) { ! 674: if ((iSemMode & pstSemId->sem_perm.mode) & 0600) ! 675: return 0; ! 676: else { ! 677: u.u_error = EACCES; ! 678: return -1; ! 679: } ! 680: } ! 681: /* For group */ ! 682: if (u.u_gid == pstSemId->sem_perm.gid ! 683: || u.u_gid == pstSemId->sem_perm.cgid) { ! 684: if ((iSemMode & pstSemId->sem_perm.mode) & 060) ! 685: return 0; ! 686: else { ! 687: u.u_error = EACCES; ! 688: return -1; ! 689: } ! 690: } ! 691: /* For the rest of the world */ ! 692: if ((iSemMode & pstSemId->sem_perm.mode) & 06) ! 693: return 0; ! 694: else { ! 695: u.u_error = EACCES; ! 696: return -1; ! 697: } ! 698: /* We should never come here */ ! 699: u.u_error = EACCES; ! 700: return -1; ! 701: } ! 702: ! 703: /* ! 704: * Allocate and clear space for semapohore sets ! 705: * Return 0 on success, -1 and set errno on error. ! 706: */ ! 707: iSemInit() ! 708: { ! 709: unsigned uSize; /* Size of the alloc memmory */ ! 710: ! 711: uSize = sizeof(struct semid_ds) * SEMMNI; ! 712: ! 713: if ((semids = (struct semid_ds *) kalloc(uSize)) == NULL) ! 714: return -1; ! 715: memset((char *) semids, 0, uSize); ! 716: return 0; ! 717: } ! 718: ! 719: /* ! 720: * Check if semaphore number is a valid number. ! 721: */ ! 722: iSanityCheck(iSemNumber) ! 723: int iSemNumber; /* Requested number of the semaphores in the set */ ! 724: { ! 725: /* Just to be on safe side */ ! 726: if (u.u_error) ! 727: return -1; ! 728: ! 729: /* Check if we are inside system limits. */ ! 730: if (iSemNumber >= SEMMSL || iSemNumber < 0) { ! 731: u.u_error = EINVAL; ! 732: return -1; ! 733: } ! 734: return 0; ! 735: } ! 736: ! 737: /* ! 738: * Subtract iValue from the adjust value for the specified ! 739: * semaphore for the specified process. ! 740: */ ! 741: int iSubAdj(iSemId, usSemNum, sValue) ! 742: int iSemId; /* Semaphore set id */ ! 743: unsigned short usSemNum; /* Semaphore number */ ! 744: short sValue; /* Adjust value */ ! 745: { ! 746: PROC *pp; /* Current process */ ! 747: struct sem_undo *unPrev, /* Previous and next pointers to */ ! 748: *unNext; /* sem_undo structures link list */ ! 749: int newAdjust; /* New adjust value */ ! 750: ! 751: pp = SELF; /* Get the current process */ ! 752: ! 753: /* Look if adjust value for semaphore was set */ ! 754: for (unNext = pp->p_semu; unNext != NULL; unNext = unPrev->un_np) { ! 755: if (unNext->un_num == usSemNum && unNext->un_id == iSemId) { ! 756: newAdjust = unNext->un_aoe - sValue; ! 757: if (newAdjust < -SEMVMX || newAdjust > SEMVMX) { ! 758: u.u_error = ERANGE; ! 759: return -1; ! 760: } ! 761: unNext->un_aoe = newAdjust; /* Found and adjust */ ! 762: return 0; ! 763: } ! 764: unPrev = unNext; ! 765: } ! 766: /* There is no adjust value for semaphore. ! 767: * We have to allocate space and creat a new adjust value. ! 768: */ ! 769: if ((unNext = kalloc(sizeof(struct sem_undo))) == NULL) { ! 770: u.u_error = ENOSPC; ! 771: return -1; ! 772: } ! 773: /* Set values for the next entry */ ! 774: unNext->un_np = NULL; ! 775: unNext->un_aoe -= sValue; ! 776: unNext->un_num = usSemNum; ! 777: unNext->un_id = iSemId; ! 778: ! 779: /* Put new entry at the end of link list */ ! 780: if (pp->p_semu == NULL) ! 781: pp->p_semu = unNext; /* New link list */ ! 782: else /* Add entry to the existing list */ ! 783: unPrev->un_np = unNext; /* unPrev is a last entry in the list */ ! 784: return 0; ! 785: } ! 786: ! 787: /* ! 788: * Clear adjust value for all process. ! 789: */ ! 790: void vClearAdj(iSemId, usSemNum) ! 791: int iSemId; /* Semaphore set id */ ! 792: int usSemNum; /* Semaphore number */ ! 793: { ! 794: PROC *pp; /* process */ ! 795: struct sem_undo *unNext; /* sem_undo structures */ ! 796: ! 797: /* Go through all processes and zero the proper undo entry */ ! 798: for (pp = &procq; (pp = pp->p_nforw) != &procq; ) { ! 799: /* Look if adjust value for semaphore was set. */ ! 800: for (unNext = pp->p_semu; unNext != NULL; ! 801: unNext = unNext->un_np) { ! 802: if (unNext->un_num == usSemNum ! 803: && unNext->un_id == iSemId) ! 804: unNext->un_aoe = 0; /* Found */ ! 805: } ! 806: } ! 807: } ! 808: ! 809: /* ! 810: * Adjust all semaphores and remove sem_undo link list. ! 811: */ ! 812: semAllAdjust(pp) ! 813: PROC *pp; ! 814: { ! 815: struct sem_undo *unPrev, /* Previous and next pointers to */ ! 816: *unNext; /* sem_undo structures link list */ ! 817: struct semid_ds *pstSemSet; /* Semaphore set */ ! 818: struct sem *pstSem; /* Semaphore */ ! 819: ! 820: if ((unNext = pp->p_semu) == NULL) ! 821: return; ! 822: ! 823: while (unNext != NULL) { ! 824: pstSemSet = semids + unNext->un_id; /* Requested set */ ! 825: pstSem = pstSemSet->sem_base + unNext->un_num; ! 826: pstSem->semval += unNext->un_aoe; ! 827: pstSem->sempid = SELF->p_pid; ! 828: pstSemSet->sem_ctime = timer.t_time; ! 829: unPrev = unNext; ! 830: unNext = unPrev->un_np; ! 831: kfree(unPrev); ! 832: } ! 833: /*kfree(pp->p_semu);*/ ! 834: pp->p_semu = NULL; ! 835: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.