![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys1.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 / coh.386|
Return to sys1.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / coh.386 |
1.1 ! root 1: /* (lgl- ! 2: * The information contained herein is a trade secret of Mark Williams ! 3: * Company, and is confidential information. It is provided under a ! 4: * license agreement, and may be copied or disclosed only under the ! 5: * terms of that agreement. Any reproduction or disclosure of this ! 6: * material without the express written authorization of Mark Williams ! 7: * Company or persuant to the license agreement is unlawful. ! 8: * ! 9: * COHERENT Version 2.3.37 ! 10: * Copyright (c) 1982, 1983, 1984. ! 11: * An unpublished work by Mark Williams Company, Chicago. ! 12: * All rights reserved. ! 13: -lgl) */ ! 14: /* ! 15: * coh.386/sys1.c ! 16: * ! 17: * Coherent. ! 18: * General system calls. ! 19: * ! 20: * Revised: Tue May 11 11:12:03 1993 CDT ! 21: */ ! 22: #include <sys/coherent.h> ! 23: #include <sys/acct.h> ! 24: #include <sys/con.h> ! 25: #include <sys/wait.h> ! 26: #include <errno.h> ! 27: #include <sys/proc.h> ! 28: #include <sys/sched.h> ! 29: #include <sys/seg.h> ! 30: #include <sys/stat.h> ! 31: #include <signal.h> ! 32: #include <sys/times.h> ! 33: ! 34: /* ! 35: * Send alarm signal to specified process - function timed by ualarm() ! 36: */ ! 37: sigalrm(pp) ! 38: register PROC * pp; ! 39: { ! 40: sendsig(SIGALRM, pp); ! 41: } ! 42: ! 43: /* ! 44: * Send a SIGALARM signal in `n' seconds. ! 45: */ ! 46: ualarm(n) ! 47: unsigned n; ! 48: { ! 49: register PROC * pp = SELF; ! 50: register unsigned s; ! 51: ! 52: /* ! 53: * Calculate time left before current alarm timeout. ! 54: */ ! 55: s = 0; ! 56: if (pp->p_alrmtim.t_last != NULL) ! 57: s = (pp->p_alrmtim.t_lbolt - lbolt + HZ - 1) / HZ; ! 58: ! 59: /* ! 60: * Cancel previous alarm [if any], start new alarm [if n != 0]. ! 61: */ ! 62: timeout2(&pp->p_alrmtim, (long) n * HZ, sigalrm, pp); ! 63: ! 64: /* ! 65: * Return time left before previous alarm timeout. ! 66: */ ! 67: return(s); ! 68: } ! 69: ! 70: ! 71: /* ! 72: * Change the size of our data segment. ! 73: */ ! 74: char * ! 75: ubrk(cp) ! 76: caddr_t cp; ! 77: { ! 78: register SEG *sp; ! 79: register caddr_t sb; ! 80: register SR *stack_sr; ! 81: caddr_t top_of_stack; ! 82: ! 83: T_HAL(0x8000, printf("%s:ubrk(%x) ", u.u_comm, cp)); ! 84: ! 85: /* ! 86: * Pick up the segment handle for our data segment. ! 87: */ ! 88: sp = SELF->p_segp[SIPDATA]; ! 89: ! 90: /* ! 91: * Extract the starting virtual address for our data segment, ! 92: * as it is currently mapped into the memory space. ! 93: */ ! 94: sb = u.u_segl[SIPDATA].sr_base; ! 95: ! 96: /* ! 97: * We can not move the top of the data segment below the ! 98: * start of the data segment. ! 99: */ ! 100: if (cp < sb) { ! 101: SET_U_ERROR(ENOMEM, ! 102: "Requested brk address is below start of data segment."); ! 103: return 0; ! 104: } ! 105: ! 106: /* ! 107: * Would the request cause a collision with the stack segment? ! 108: * ! 109: * Since the stack grows downward, its top is below its base :-). ! 110: */ ! 111: stack_sr = &u.u_segl[SISTACK]; ! 112: top_of_stack = (stack_sr->sr_base) - (stack_sr->sr_size); ! 113: ! 114: if (btoc(cp) >= btoc(top_of_stack)) { ! 115: SET_U_ERROR(ENOMEM, ! 116: "Requested brk address would collide with stack segment."); ! 117: return 0; ! 118: } ! 119: ! 120: /* ! 121: * Attempt to establish the segment with the newly requested size. ! 122: */ ! 123: segsize(sp, (cp - sb)); ! 124: ! 125: /* ! 126: * Be sure to return the true new top of data segment. ! 127: */ ! 128: sb += sp->s_size; ! 129: ! 130: T_HAL(0x8000, printf("=%x ", sb)); ! 131: return sb; ! 132: } ! 133: ! 134: /* ! 135: * Execute a l.out. ! 136: */ ! 137: uexece(np, argp, envp) ! 138: char *np; ! 139: char *argp[]; ! 140: char *envp[]; ! 141: { ! 142: pexece(np, argp, envp); ! 143: } ! 144: ! 145: /* ! 146: * Exit. ! 147: */ ! 148: uexit(s) ! 149: { ! 150: pexit(s<<8); ! 151: } ! 152: ! 153: /* ! 154: * Fork. ! 155: */ ! 156: ufork() ! 157: { ! 158: return (pfork()); ! 159: } ! 160: ! 161: /* ! 162: * Get group id. ! 163: * Get effective group id. ! 164: */ ! 165: ugetgid() ! 166: { ! 167: u.u_rval2 = u.u_gid; ! 168: return u.u_rgid; ! 169: } ! 170: ! 171: /* ! 172: * Get user id. ! 173: * Get effective user id. ! 174: */ ! 175: ugetuid() ! 176: { ! 177: u.u_rval2 = u.u_uid; ! 178: return u.u_ruid; ! 179: } ! 180: ! 181: /* ! 182: * Get process group. ! 183: * Set the process group. ! 184: * ! 185: * This is System V type setpgrp(). ! 186: * Set process group equal to process id (make process its own group leader). ! 187: * If process was NOT already a group leader, lose its controlling terminal. ! 188: */ ! 189: upgrp(fl) ! 190: { ! 191: register PROC * pp = SELF; ! 192: ! 193: if (fl) { ! 194: if (pp->p_group != pp->p_pid) ! 195: pp->p_ttdev = NODEV; ! 196: pp->p_group = pp->p_pid; ! 197: } ! 198: return pp->p_group; ! 199: } ! 200: ! 201: /* ! 202: * Get process id. ! 203: */ ! 204: ugetpid() ! 205: { ! 206: register PROC *pp = SELF; ! 207: ! 208: u.u_rval2 = pp->p_ppid; ! 209: return pp->p_pid; ! 210: } ! 211: ! 212: /* ! 213: * Send the signal `sig' to the process with id `pid'. ! 214: */ ! 215: ukill(pid, sig) ! 216: int pid; ! 217: register unsigned sig; ! 218: { ! 219: register PROC *pp; ! 220: register int sigflag; ! 221: ! 222: if (sig > NSIG) { ! 223: u.u_error = EINVAL; ! 224: return; ! 225: } ! 226: sigflag = 0; ! 227: lock(pnxgate); ! 228: if (pid > 0) { /* send to matching process */ ! 229: for (pp=procq.p_nforw; pp != &procq; pp=pp->p_nforw) { ! 230: if (pp->p_state == PSDEAD) ! 231: continue; ! 232: if (pp->p_pid == pid) { ! 233: sigflag = 1; ! 234: if (sig) { ! 235: if (sigperm(sig, pp)) ! 236: sendsig(sig, pp); ! 237: else ! 238: u.u_error = EPERM; ! 239: } ! 240: break; ! 241: } ! 242: } ! 243: } ! 244: else if (pid < -1) { ! 245: pid = -pid; ! 246: for (pp=procq.p_nforw; pp != &procq; pp=pp->p_nforw) { ! 247: if (pp->p_state == PSDEAD) ! 248: continue; ! 249: if (pp->p_group == pid) { ! 250: sigflag = 1; ! 251: if (sig) { ! 252: if (sigperm(sig, pp)) ! 253: sendsig(sig,pp); ! 254: else ! 255: u.u_error = EPERM; ! 256: } ! 257: } ! 258: } ! 259: } ! 260: else if (pid == 0) { ! 261: for (pp=procq.p_nforw; pp != &procq; pp=pp->p_nforw) { ! 262: if (pp->p_state == PSDEAD) ! 263: continue; ! 264: if (pp->p_group == SELF->p_group) { ! 265: sigflag = 1; ! 266: if (sig && sigperm(sig, pp)) ! 267: sendsig(sig, pp); ! 268: } ! 269: } ! 270: } ! 271: else if (pid == -1) { ! 272: for (pp=procq.p_nforw; pp != &procq; pp=pp->p_nforw) { ! 273: if (pp->p_state == PSDEAD) ! 274: continue; ! 275: if (pp->p_pid == 0) ! 276: continue; ! 277: if (pp->p_pid == 1) ! 278: continue; ! 279: if (pp->p_flags & PFKERN) ! 280: continue; ! 281: sigflag = 1; ! 282: if (sig && super()) ! 283: sendsig(sig, pp); ! 284: } ! 285: } ! 286: unlock(pnxgate); ! 287: if (sigflag == 0) ! 288: u.u_error = ESRCH; ! 289: return 0; ! 290: } ! 291: ! 292: /* ! 293: * See if we have permission to send the signal, `sig' to the process, `pp'. ! 294: */ ! 295: sigperm(sig, pp) ! 296: register PROC *pp; ! 297: { ! 298: if (u.u_uid == pp->p_uid) ! 299: return (1); ! 300: if (u.u_ruid == pp->p_ruid) { ! 301: if (sig == SIGHUP ! 302: || sig == SIGINT ! 303: || sig == SIGQUIT ! 304: || sig == SIGTERM) ! 305: return (1); ! 306: } ! 307: if (u.u_uid == 0) { ! 308: u.u_flag |= ASU; ! 309: return (1); ! 310: } ! 311: return 0; ! 312: } ! 313: ! 314: /* ! 315: * Lock a process in core. ! 316: */ ! 317: ulock(f) ! 318: { ! 319: if (super() == 0) ! 320: return; ! 321: if (f) ! 322: SELF->p_flags |= PFLOCK; ! 323: else ! 324: SELF->p_flags &= ~PFLOCK; ! 325: return 0; ! 326: } ! 327: ! 328: /* ! 329: * Change priority by the given increment. ! 330: */ ! 331: unice(n) ! 332: register int n; ! 333: { ! 334: n += SELF->p_nice; ! 335: if (n < MINNICE) ! 336: n = MINNICE; ! 337: if (n > MAXNICE) ! 338: n = MAXNICE; ! 339: if (n<SELF->p_nice && super()==0) ! 340: return; ! 341: SELF->p_nice = n; ! 342: return 0; ! 343: } ! 344: ! 345: /* ! 346: * Non existant system call. ! 347: */ ! 348: unone() ! 349: { ! 350: u.u_error = EFAULT; ! 351: } ! 352: ! 353: /* ! 354: * Null system call. ! 355: */ ! 356: unull() ! 357: { ! 358: } ! 359: ! 360: /* ! 361: * Pause. Go to sleep on a channel that nobody will wakeup so that only ! 362: * signals will wake us up. ! 363: */ ! 364: upause() ! 365: { ! 366: x_sleep((char *)&u, prilo, slpriSigLjmp, "pause"); ! 367: } ! 368: ! 369: /* ! 370: * Start/stop profiling. ! 371: * ! 372: * buff: address in user data of an array of shorts ! 373: * bufsiz: number of bytes in the area at buff ! 374: * offset: address in user text of start of profiling area ! 375: * scale: 0 or 1 - turn off profiling ! 376: * other - treat as 16 bit scale factor ! 377: * ! 378: * For purposes of compatibility with System 5, scale values work as follows: ! 379: * 0xFFFF profile buffer is same length as text being profiled. ! 380: * 0x7FFF profile buffer is half as long as text being profiled. ! 381: * 0x4000 profile buffer is one fourth as long as text profiled. ! 382: * (each short in the buffer covers 8 bytes of text) ! 383: * ... ... ! 384: * 0x0002 each short in the buffer covers 64K bytes of text. ! 385: * ! 386: * Values 0xFFFF and 0x7FFF are used, for historical reasons, when 0x10000 ! 387: * and 0x8000, respectively, should be used. To clean up the ensuing ! 388: * arithmetic, there is an upward rounding kluge below. ! 389: * ! 390: * Each clock interrupt, take (pc - offset) * scale * (2**-16) as a byte ! 391: * offset into pbase. Add 1 to the short at or below the given address ! 392: * when profiling. ! 393: */ ! 394: uprofil(buff, bufsiz, offset, scale) ! 395: short * buff; ! 396: int bufsiz, offset, scale; ! 397: { ! 398: u.u_pbase = buff; ! 399: u.u_pbend = buff + bufsiz; ! 400: u.u_pofft = offset; ! 401: u.u_pscale = scale & 0xffff; /* scale is really unsigned short */ ! 402: ! 403: /* round up kluge - see above */ ! 404: if ((scale & 0xfff) == 0xfff) ! 405: u.u_pscale++; ! 406: } ! 407: ! 408: /* ! 409: * Process trace. ! 410: */ ! 411: uptrace(req, pid, add, data) ! 412: int *add; ! 413: { ! 414: int ret; ! 415: ! 416: #ifdef TRACER ! 417: int readChild = 0; /* for debug, true if reading child memory */ ! 418: ! 419: if (t_hal & 0x10000) { ! 420: switch(req) { ! 421: case 0: /* init called by child */ ! 422: printf("PSetup: child=%d ", SELF->p_pid); ! 423: break; ! 424: case 1: /* parent reads child text */ ! 425: printf("PRdT: add=%x ", add); ! 426: readChild = 1; ! 427: break; ! 428: case 2: /* parent reads child data */ ! 429: printf("PRdD: add=%x ", add); ! 430: readChild = 1; ! 431: break; ! 432: case 3: /* parent reads child u area */ ! 433: printf("PRdU: add=%x ", add); ! 434: readChild = 1; ! 435: break; ! 436: case 4: /* parent writes child text */ ! 437: printf("PWrT: add=%x data=%x ", add, data); ! 438: break; ! 439: case 5: /* parent writes child data */ ! 440: printf("PWrD: add=%x data=%x ", add, data); ! 441: break; ! 442: case 6: /* parent writes child u area */ ! 443: printf("PWrU: add=%x data=%x ", add, data); ! 444: break; ! 445: case 7: /* resume child, maybe fake signal to child */ ! 446: printf("PResume: sig=%d ", data); ! 447: break; ! 448: case 8: /* terminate child */ ! 449: printf("PTerm: pid=%d ", pid); ! 450: break; ! 451: case 9: /* single-step child, maybe fake signal to child */ ! 452: printf("PSStp: sig=%d ", data); ! 453: break; ! 454: } ! 455: } ! 456: #endif ! 457: ! 458: if (req == 0) { ! 459: SELF->p_flags |= PFTRAC; ! 460: ret = 0; ! 461: } else ! 462: ret = ptset(req, pid, add, data); ! 463: ! 464: #ifdef TRACER ! 465: if (t_hal & 0x10000) { ! 466: if (readChild) ! 467: printf("data=%x ", ret); ! 468: } ! 469: #endif ! 470: ! 471: return ret; ! 472: } ! 473: ! 474: /* ! 475: * Set group id. ! 476: * ! 477: * As in SVID issue 2: ! 478: * ! 479: * if effective gid is superuser ! 480: * set real, effective, and saved effective gid to argument "gid" ! 481: * else if real gid is same as "gid" ! 482: * set effective gid to "gid" ! 483: * else if saved effective gid is same as "gid" ! 484: * set effective gid to "gid" ! 485: */ ! 486: usetgid(gid) ! 487: register int gid; ! 488: { ! 489: if (super()) { ! 490: u.u_gid = u.u_rgid = u.u_egid = gid; ! 491: SELF->p_rgid = gid; ! 492: } else { ! 493: u.u_error = 0; /* super() sets u_error when it fails */ ! 494: if (u.u_rgid == gid || u.u_egid == gid) { ! 495: u.u_gid = gid; ! 496: } else { ! 497: SET_U_ERROR(EPERM, "Illegal gid"); ! 498: } ! 499: } ! 500: return 0; ! 501: } ! 502: ! 503: /* ! 504: * Set user id. ! 505: * ! 506: * As in SVID issue 2: ! 507: * ! 508: * if effective uid is superuser ! 509: * set real, effective, and saved effective uid to argument "uid" ! 510: * else if real uid is same as "uid" ! 511: * set effective uid to "uid" ! 512: * else if saved effective uid is same as "uid" ! 513: * set effective uid to "uid" ! 514: */ ! 515: usetuid(uid) ! 516: register int uid; ! 517: { ! 518: if (super()) { ! 519: u.u_uid = u.u_ruid = u.u_euid = uid; ! 520: SELF->p_uid = SELF->p_ruid = uid; ! 521: } else { ! 522: u.u_error = 0; /* super() sets u_error when it fails */ ! 523: if (u.u_ruid == uid || u.u_euid == uid) { ! 524: SELF->p_uid = u.u_uid = uid; ! 525: } else { ! 526: SET_U_ERROR(EPERM, "Illegal uid"); ! 527: } ! 528: } ! 529: return 0; ! 530: } ! 531: ! 532: /* ! 533: * Load a device driver. ! 534: */ ! 535: usload(np) ! 536: char *np; ! 537: { ! 538: return pload(np); ! 539: } ! 540: ! 541: /* ! 542: * Set time and date. ! 543: * ! 544: * Unlike the libc interface, this routine expects a time_t value ! 545: * as an arg, not a time_t pointer. ! 546: */ ! 547: ustime(tp) ! 548: time_t tp; ! 549: { ! 550: register int s; ! 551: ! 552: if (super() == 0) { ! 553: return; ! 554: } ! 555: s = sphi(); ! 556: ukcopy(&tp, &timer.t_time, sizeof(tp)); ! 557: spl(s); ! 558: return 0; ! 559: } ! 560: ! 561: /* ! 562: * Return process times. ! 563: */ ! 564: utimes(tp) ! 565: struct tms *tp; ! 566: { ! 567: register PROC *pp; ! 568: struct tms tbuffer; ! 569: ! 570: if (tp) { ! 571: pp = SELF; ! 572: tbuffer.tms_utime = pp->p_utime; ! 573: tbuffer.tms_stime = pp->p_stime; ! 574: tbuffer.tms_cutime = pp->p_cutime; ! 575: tbuffer.tms_cstime = pp->p_cstime; ! 576: kucopyS(&tbuffer, tp, sizeof(tbuffer)); ! 577: } ! 578: return lbolt; ! 579: } ! 580: ! 581: /* ! 582: * Unload a device driver. ! 583: */ ! 584: usuload(m) ! 585: register int m; ! 586: { ! 587: if (super() == 0) ! 588: return; ! 589: puload(m); ! 590: return 0; ! 591: } ! 592: ! 593: /* ! 594: * Wait for a child to terminate. ! 595: * ! 596: * iBCS2 says the same system call number is wait() and waitpid(), the ! 597: * distinction being in how the psw is set on entry. ! 598: * ! 599: * iBCS2 fails to mention that when wait() or waitpid() report status ! 600: * by writing into the pointer supplied, the status is put into %edx by ! 601: * the kernel, and moved from there into user space by the function in ! 602: * libc.a. uwait() and uwaitpid() specify a value for %edx by writing ! 603: * to u.u_rval2. ! 604: * ! 605: * Do wait() unless (ZF|PF|SF|OF) (=WPMASK) are set in psw. ! 606: */ ! 607: #define WPMASK 0x8C4 ! 608: ! 609: uwait(arg1, arg2, arg3) ! 610: { ! 611: register PROC *pp; ! 612: register PROC *ppp; ! 613: register PROC *cpp; ! 614: register int pid; ! 615: ! 616: if ((u.u_regl[EFL] & WPMASK) == WPMASK) ! 617: return uwaitpid(arg1, arg2, arg3); ! 618: ! 619: /* Wait for a child to stop or die. */ ! 620: T_HAL(8, printf("[%d]waits ", SELF->p_pid)); ! 621: ppp = SELF; ! 622: for (;;) { ! 623: int x_s; ! 624: ! 625: /* Look at all processes. */ ! 626: lock(pnxgate); ! 627: cpp = NULL; ! 628: pp = &procq; ! 629: while ((pp=pp->p_nforw) != &procq) { ! 630: ! 631: /* Ignore the current process. */ ! 632: if (pp == ppp) ! 633: continue; ! 634: /* ! 635: * Ignore processes that aren't children of the ! 636: * current one. ! 637: */ ! 638: if (pp->p_ppid != ppp->p_pid) ! 639: continue; ! 640: if (pp->p_flags&PFSTOP) ! 641: continue; ! 642: ! 643: /* Here is a child that hit a breakpoint. */ ! 644: if (pp->p_flags&PFWAIT) { ! 645: int work; /* virtual click number */ ! 646: int childUseg; /* system global addr */ ! 647: UPROC * uprc; ! 648: SEG * sp; ! 649: ! 650: pp->p_flags &= ~PFWAIT; ! 651: pp->p_flags |= PFSTOP; ! 652: ! 653: /* fetch u.u_signo from the child */ ! 654: ! 655: /* Find u area for child process pp */ ! 656: sp = pp->p_segp[SIUSERP]; ! 657: childUseg = MAPIO(sp->s_vmem, U_OFFSET); ! 658: work = workAlloc(); ! 659: ptable1_v[work] = ! 660: sysmem.u.pbase[btocrd(childUseg)] | SEG_RW; ! 661: mmuupd(); ! 662: uprc = (UPROC *) (ctob(work) + U_OFFSET); ! 663: u.u_rval2 = ((uprc->u_signo)<<8) | 0177; ! 664: workFree(work); ! 665: ! 666: unlock(pnxgate); ! 667: T_HAL(8, printf("[%d]ends waiting, %d stopped ", ! 668: SELF->p_pid, pid)); ! 669: return pp->p_pid; ! 670: } ! 671: if (pp->p_state == PSDEAD) { ! 672: ppp->p_cutime += pp->p_utime + pp->p_cutime; ! 673: ppp->p_cstime += pp->p_stime + pp->p_cstime; ! 674: u.u_rval2 = pp->p_exit; ! 675: pid = pp->p_pid; ! 676: unlock(pnxgate); ! 677: relproc(pp); ! 678: if (SIG_BIT(SIGCLD) & ppp->p_isig) ! 679: continue; ! 680: else { ! 681: T_HAL(8, printf("[%d]ends waiting," ! 682: " %d died ", SELF->p_pid, pid)); ! 683: return pid; ! 684: } ! 685: } ! 686: cpp = pp; ! 687: } ! 688: unlock(pnxgate); ! 689: if (cpp == NULL) { ! 690: T_HAL(8, printf("[%d]ends waiting, no children ", ! 691: SELF->p_pid)); ! 692: u.u_error = ECHILD; ! 693: return; ! 694: } ! 695: x_s = x_sleep((char *)ppp, prilo, slpriSigLjmp, "wait"); ! 696: /* Wait for a child to terminate. */ ! 697: } ! 698: } ! 699: ! 700: /* ! 701: * waitpid() and wait() share the same system call number under BCS. ! 702: * ! 703: * pid argument: ! 704: * > 0 wait for child whose process matches pid ! 705: * = 0 wait for any child in current process group ! 706: * = -1 wait for any child - same as wait() ! 707: * < -1 wait for any child in group given by -pid ! 708: * ! 709: * The only waitpid() options supported are WNOHANG and WUNTRACED. ! 710: * ! 711: */ ! 712: int ! 713: uwaitpid(opid, stat_loc, options) ! 714: register pid_t opid; ! 715: int *stat_loc, options; ! 716: { ! 717: register PROC *pp; ! 718: register PROC *ppp; ! 719: register PROC *cpp; ! 720: register int pid; ! 721: ! 722: if (options & WUNTRACED) { ! 723: printf("waitpid(%d,%d, WUNTRACED): unsupported\n", opid, ! 724: stat_loc); ! 725: u.u_error = EINVAL; ! 726: return; ! 727: } ! 728: ! 729: /* Wait for a child to stop or die. */ ! 730: ppp = SELF; ! 731: for (;;) { ! 732: int x_s; ! 733: ! 734: /* Look at all processes. */ ! 735: lock(pnxgate); ! 736: cpp = NULL; ! 737: pp = &procq; ! 738: while ((pp=pp->p_nforw) != &procq) { ! 739: ! 740: /* Ignore the current process. */ ! 741: if (pp == ppp) ! 742: continue; ! 743: /* ! 744: * Ignore processes that aren't children of the ! 745: * current one. ! 746: */ ! 747: if (pp->p_ppid != ppp->p_pid) ! 748: continue; ! 749: ! 750: if (pp->p_flags&PFSTOP) ! 751: continue; ! 752: ! 753: /* If opid == 0 we want to match gids */ ! 754: if ((opid == 0) && (pp->p_group != ppp->p_group)) ! 755: continue; ! 756: ! 757: /* If opid>0, want to match opid to child pid */ ! 758: else if ((opid > 0) && (opid != pp->p_pid)) ! 759: continue; ! 760: ! 761: /* If opid<-1, want to match -opid to child gid */ ! 762: else if ((opid < -1) && ((-opid) != pp->p_group)) ! 763: continue; ! 764: ! 765: /* if opid == -1, then any child is acceptable */ ! 766: ! 767: /* Here is an acceptable child that hit a breakpoint. */ ! 768: if (pp->p_flags&PFWAIT) { ! 769: int work; /* virtual click number */ ! 770: int childUseg; /* system global addr */ ! 771: UPROC * uprc; ! 772: SEG * sp; ! 773: ! 774: pp->p_flags &= ~PFWAIT; ! 775: pp->p_flags |= PFSTOP; ! 776: ! 777: /* fetch u.u_signo from the child */ ! 778: ! 779: /* Find u area for child process pp */ ! 780: sp = pp->p_segp[SIUSERP]; ! 781: childUseg = MAPIO(sp->s_vmem, U_OFFSET); ! 782: work = workAlloc(); ! 783: ptable1_v[work] = ! 784: sysmem.u.pbase[btocrd(childUseg)] | SEG_RW; ! 785: mmuupd(); ! 786: uprc = (UPROC *) (ctob(work) + U_OFFSET); ! 787: u.u_rval2 = ((uprc->u_signo)<<8) | 0177; ! 788: workFree(work); ! 789: ! 790: unlock(pnxgate); ! 791: return pp->p_pid; ! 792: } ! 793: ! 794: /* Here is an acceptable child that is a zombie. */ ! 795: if (pp->p_state == PSDEAD) { ! 796: ppp->p_cutime += pp->p_utime + pp->p_cutime; ! 797: ppp->p_cstime += pp->p_stime + pp->p_cstime; ! 798: u.u_rval2 = pp->p_exit; ! 799: pid = pp->p_pid; ! 800: unlock(pnxgate); ! 801: relproc(pp); ! 802: if (SIG_BIT(SIGCLD) & ppp->p_isig) ! 803: continue; ! 804: else { ! 805: return pid; ! 806: } ! 807: } ! 808: cpp = pp; ! 809: } ! 810: unlock(pnxgate); ! 811: if (cpp == NULL) { ! 812: u.u_error = ECHILD; ! 813: return; ! 814: } ! 815: ! 816: if (options & WNOHANG) { ! 817: u.u_rval2 = 0; ! 818: return 0; ! 819: } ! 820: else ! 821: /* Wait for a child to terminate. */ ! 822: x_s = x_sleep((char *)ppp, prilo, slpriSigLjmp, ! 823: "waitpid"); ! 824: } ! 825: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.