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