![[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 [Research Unix] / researchv10no / sys / os|
Return to sys1.c CVS log | Up to [Research Unix] / researchv10no / sys / os |
1.1 ! root 1: #include "sys/param.h" ! 2: #include "sys/systm.h" ! 3: #include "sys/map.h" ! 4: #include "sys/mtpr.h" ! 5: #include "sys/user.h" ! 6: #include "sys/proc.h" ! 7: #include "sys/buf.h" ! 8: #include "sys/reg.h" ! 9: #include "sys/inode.h" ! 10: #include "sys/acct.h" ! 11: #include "/usr/include/wait.h" ! 12: #include "sys/pte.h" ! 13: #include "sys/vm.h" ! 14: #include "sys/text.h" ! 15: #include "sys/psl.h" ! 16: #include "sys/vlimit.h" ! 17: #include "sys/file.h" ! 18: ! 19: /* ! 20: * exec system call ! 21: */ ! 22: struct execa { ! 23: char *fname; ! 24: char **argp; ! 25: char **envp; ! 26: }; ! 27: ! 28: struct shdata { ! 29: char sd_save[DIRSIZ]; ! 30: int sd_gid; ! 31: int sd_uid; ! 32: int sd_indir; ! 33: char sd_flag[SHSIZE]; ! 34: }; ! 35: ! 36: struct swargs { ! 37: char *sw_cp; ! 38: int sw_argc; ! 39: int sw_envc; ! 40: int sw_chars; ! 41: int sw_bn; ! 42: struct buf *sw_bp; ! 43: }; ! 44: ! 45: void ! 46: str_stash(s, sp) ! 47: register char *s; ! 48: register struct swargs *sp; ! 49: { ! 50: register char *cp; ! 51: register int nc; ! 52: register int bmask; ! 53: ! 54: cp = sp->sw_cp; ! 55: nc = sp->sw_chars; ! 56: bmask = BMASK(argdev); ! 57: ! 58: do { ! 59: if ((nc & bmask) == 0) { ! 60: if (nc >= NCARGS) { ! 61: u.u_error = E2BIG; ! 62: return; ! 63: } ! 64: if (sp->sw_bp != NULL) ! 65: bdwrite(sp->sw_bp); ! 66: sp->sw_bp = getblk(argdev, (daddr_t)(dbtofsb(argdev, ! 67: sp->sw_bn) + (nc>>BSHIFT(argdev)))); ! 68: cp = sp->sw_bp->b_un.b_addr; ! 69: } ! 70: nc++; ! 71: } while ((*cp++ = *s++) != '\0'); ! 72: ! 73: sp->sw_chars = nc; ! 74: sp->sw_cp = cp; ! 75: sp->sw_argc++; ! 76: } ! 77: ! 78: int ! 79: vec_stash(v, sp) ! 80: register char **v; ! 81: register struct swargs *sp; ! 82: { ! 83: register char *s; ! 84: register int nc; ! 85: register int nleft; ! 86: register int i; ! 87: int bsize; ! 88: int count; ! 89: int ap; ! 90: ! 91: if (v == NULL) ! 92: return 0; ! 93: ! 94: nc = sp->sw_chars; ! 95: bsize = BSIZE(argdev); ! 96: nleft = ((nc + bsize-1) & ~(bsize-1)) - nc; ! 97: count = 0; ! 98: ! 99: for (;;) { ! 100: if ((ap = fuword((caddr_t)v++)) < 0) { ! 101: u.u_error = EFAULT; ! 102: return 0; ! 103: } ! 104: if ((s = (char *)ap) == NULL) ! 105: break; ! 106: if ((i = fustrlen(s)) < 0) { ! 107: u.u_error = EFAULT; ! 108: return 0; ! 109: } ! 110: while (i > nleft) { ! 111: if (sp->sw_bp) { ! 112: bcopy(s, sp->sw_cp, nleft); ! 113: s += nleft; ! 114: nc += nleft; ! 115: i -= nleft; ! 116: if (nc >= NCARGS) { ! 117: u.u_error = E2BIG; ! 118: return 0; ! 119: } ! 120: bdwrite(sp->sw_bp); ! 121: } ! 122: sp->sw_bp = getblk(argdev, (daddr_t)(dbtofsb(argdev, ! 123: sp->sw_bn) + (nc>>BSHIFT(argdev)))); ! 124: sp->sw_cp = sp->sw_bp->b_un.b_addr; ! 125: nleft = bsize; ! 126: } ! 127: bcopy(s, sp->sw_cp, i); ! 128: sp->sw_cp += i; ! 129: nc += i; ! 130: nleft -= i; ! 131: count++; ! 132: } ! 133: sp->sw_chars = nc; ! 134: sp->sw_argc += count; ! 135: return count; ! 136: } ! 137: ! 138: exece() ! 139: { ! 140: register int i; ! 141: register int ap; ! 142: register int bsize; ! 143: register char *cp; ! 144: register char *ucp; ! 145: register struct execa *uap; ! 146: struct buf *bp; ! 147: struct inode *ip; ! 148: struct shdata sh; ! 149: struct swargs sw; ! 150: extern struct map argmap[]; ! 151: extern struct inode *gethead(); ! 152: ! 153: uap = (struct execa *)u.u_ap; ! 154: sh.sd_uid = u.u_uid; ! 155: sh.sd_gid = u.u_gid; ! 156: sh.sd_indir = 0; ! 157: sh.sd_flag[0] = '\0'; ! 158: if ((ip = gethead(uap->fname, &sh)) == NULL) ! 159: return; ! 160: ! 161: sw.sw_argc = 0; ! 162: sw.sw_chars = 0; ! 163: sw.sw_bp = NULL; ! 164: bsize = BSIZE(argdev); ! 165: if ((sw.sw_bn = rmalloc(argmap, ctod(clrnd((int)btoc(NCARGS))))) == 0) { ! 166: swkill(u.u_procp, "exece"); ! 167: iput(ip); ! 168: return; ! 169: } ! 170: if (sw.sw_bn % CLSIZE) ! 171: panic("exece rmalloc"); ! 172: if (sh.sd_indir) { ! 173: if ((ap = fuword((caddr_t)uap->argp)) < 0){ ! 174: u.u_error = EFAULT; ! 175: goto out; ! 176: } ! 177: if (ap) { ! 178: uap->argp++; ! 179: if (fustrlen((char *)ap) < 0) { ! 180: u.u_error = EFAULT; ! 181: goto out; ! 182: } ! 183: /* ! 184: * improper assumption ! 185: * ap is a user address; ! 186: * str_stash assumes kernel-accessible ! 187: */ ! 188: str_stash((char *)ap, &sw); ! 189: } ! 190: if (sh.sd_flag[0] != '\0') ! 191: str_stash(sh.sd_flag, &sw); ! 192: str_stash(uap->fname, &sw); ! 193: } ! 194: vec_stash(uap->argp, &sw); ! 195: sw.sw_envc = vec_stash(uap->envp, &sw); ! 196: bp = sw.sw_bp; ! 197: if (bp) { ! 198: bdwrite(bp); ! 199: bp = NULL; ! 200: } ! 201: ! 202: if (u.u_error) ! 203: goto out; ! 204: ! 205: sw.sw_chars = (sw.sw_chars + NBPW-1) & ~(NBPW-1); ! 206: /* 4: argc, null after args, null after env, null after everything, */ ! 207: getxfile(ip, sw.sw_chars + (sw.sw_argc+4)*NBPW, sh.sd_uid, sh.sd_gid); ! 208: ! 209: if (u.u_error) ! 210: goto out; ! 211: ! 212: iput(ip); ! 213: ucp = (char *)(USRSTACK - sw.sw_chars - NBPW); ! 214: ap = (int)ucp - (sw.sw_argc + 3) * NBPW; ! 215: u.u_ar0[SP] = ap; ! 216: *(int *)ap = sw.sw_argc - sw.sw_envc; ! 217: ! 218: for (i = 0, cp = ucp; sw.sw_chars > 0; i++, cp += bsize, sw.sw_chars -= bsize) { ! 219: if (bp) ! 220: brelse(bp); ! 221: bp = bread(argdev, (daddr_t)(dbtofsb(argdev, sw.sw_bn)+i)); ! 222: bcopy(bp->b_un.b_addr, cp, min(bsize, sw.sw_chars)); ! 223: bp->b_flags |= B_AGE; ! 224: bp->b_flags &= ~B_DELWRI; ! 225: } ! 226: ! 227: if (bp) ! 228: brelse(bp); ! 229: ! 230: for (cp = ucp; ; cp += fustrlen(cp)) { ! 231: ap += NBPW; ! 232: if (sw.sw_argc == sw.sw_envc) ! 233: ap += NBPW; ! 234: if (--sw.sw_argc < 0) ! 235: break; ! 236: *(char **)ap = cp; ! 237: } ! 238: setregs(sh.sd_save); ! 239: rmfree(argmap, ctod(clrnd((int) btoc(NCARGS))), sw.sw_bn); ! 240: return; ! 241: ! 242: out: ! 243: iput(ip); ! 244: for (i = (((sw.sw_chars+bsize-1)&~(bsize-1))>>BSHIFT(argdev))-1; ! 245: i >= 0; i--) { ! 246: bp = getblk(argdev, (daddr_t)(dbtofsb(argdev, sw.sw_bn)+i)); ! 247: bp->b_flags |= B_AGE; ! 248: bp->b_flags &= ~B_DELWRI; ! 249: brelse(bp); ! 250: } ! 251: rmfree(argmap, ctod(clrnd((int) btoc(NCARGS))), sw.sw_bn); ! 252: } ! 253: ! 254: /* ! 255: * Get a shell after #! magic number. ! 256: */ ! 257: struct inode * ! 258: getshell(ip, sp) ! 259: struct inode *ip; ! 260: struct shdata *sp; ! 261: { ! 262: register char *cp, *fname; ! 263: extern struct inode *gethead(); ! 264: ! 265: if(u.u_exdata.ux_shell[0] != '#' || u.u_exdata.ux_shell[1] != '!' || sp->sd_indir) ! 266: goto error; ! 267: cp = &u.u_exdata.ux_shell[2]; ! 268: for (;;) { ! 269: if (cp == &u.u_exdata.ux_shell[SHSIZE]) ! 270: goto error; ! 271: if (*cp == '\n') { ! 272: *cp = '\0'; ! 273: break; ! 274: } ! 275: if (*cp == '\t') ! 276: *cp = ' '; ! 277: cp++; ! 278: } ! 279: for (cp = &u.u_exdata.ux_shell[2]; *cp == ' '; cp++); ! 280: if (*cp == '\0') ! 281: goto error; ! 282: fname = cp; ! 283: while (*cp != '\0') { ! 284: if (*cp == ' ') { ! 285: *cp++ = '\0'; ! 286: while (*cp == ' ') ! 287: cp++; ! 288: /* ! 289: * Shell argument (one only). ! 290: */ ! 291: if (*cp != '\0') { ! 292: register int i; ! 293: ! 294: i = 0; ! 295: do ! 296: sp->sd_flag[i++] = *cp++; ! 297: while (*cp != ' ' && *cp != '\0'); ! 298: sp->sd_flag[i] = '\0'; ! 299: } ! 300: break; ! 301: } ! 302: else ! 303: cp++; ! 304: } ! 305: iput(ip); ! 306: sp->sd_indir = 1; ! 307: return gethead(fname, sp); ! 308: ! 309: error: ! 310: iput(ip); ! 311: u.u_error = ENOEXEC; ! 312: return NULL; ! 313: } ! 314: ! 315: /* ! 316: * Get the header of an executable and do all the right tests. ! 317: */ ! 318: struct inode * ! 319: gethead(fname, sp) ! 320: char *fname; ! 321: struct shdata *sp; ! 322: { ! 323: register struct inode *ip; ! 324: struct argnamei nmarg; ! 325: ! 326: nmarg = nilargnamei; ! 327: if(sp->sd_indir == 0) { ! 328: nmarg.un.buf = (caddr_t)sp->sd_save; ! 329: nmarg.len = sizeof(sp->sd_save); ! 330: if((ip = namei(fname, SEGUDATA, &nmarg, 1)) == NULL) ! 331: return NULL; ! 332: } ! 333: else if((ip = namei(fname, SEGSYS, &nmarg, 1)) == NULL) ! 334: return NULL; ! 335: ! 336: /* ! 337: * Setuid and setgid denied for network root. ! 338: */ ! 339: if (!(ip->i_mode & ICONC)) { ! 340: if ((ip->i_mode & ISUID) != 0 && ip->i_uid != -1) ! 341: sp->sd_uid = ip->i_uid; ! 342: ! 343: if ((ip->i_mode & ISGID) != 0 && ip->i_gid != -1) ! 344: sp->sd_gid = ip->i_gid; ! 345: } ! 346: ! 347: /* ! 348: * Check permission. May not trace something we can't read. ! 349: */ ! 350: if(access(ip, IEXEC) || (PTRACED(u.u_procp) && access(ip, IREAD))) ! 351: goto out; ! 352: ! 353: /* ! 354: * Must be a regular file and must really be executable. ! 355: */ ! 356: if ((ip->i_mode & IFMT) != IFREG || ! 357: (ip->i_mode & (IEXEC | (IEXEC >> 3) | (IEXEC >> 6))) == 0) { ! 358: u.u_error = EACCES; ! 359: goto out; ! 360: } ! 361: ! 362: /* ! 363: * ux_mag = 407/410/413 ! 364: * 407 is plain executable ! 365: * 410 is RO text ! 366: * 413 is demand paged RO text ! 367: * ! 368: * Also an ASCII line beginning with #! is ! 369: * the file name of a ``shell'' and arguments may be prepended ! 370: * to the argument list if given here. ! 371: * ! 372: * Shell names are limited in length. ! 373: * ! 374: * Only one argument may be passed to the shell from the ASCII line. ! 375: */ ! 376: u.u_base = (caddr_t)&u.u_exdata; ! 377: u.u_count = sizeof(u.u_exdata); ! 378: u.u_offset = ltoL(0); ! 379: u.u_segflg = SEGSYS; ! 380: readi(ip); ! 381: u.u_segflg = SEGUDATA; ! 382: ! 383: if (u.u_error) ! 384: goto out; ! 385: ! 386: if (u.u_count > sizeof (u.u_exdata) - sizeof (u.u_exdata.Ux_A)) ! 387: ip = getshell(ip, sp); ! 388: else { ! 389: switch (u.u_exdata.ux_mag) { ! 390: case 0407: ! 391: u.u_exdata.ux_dsize += u.u_exdata.ux_tsize; ! 392: u.u_exdata.ux_tsize = 0; ! 393: break; ! 394: ! 395: case 0410: ! 396: case 0413: ! 397: if (u.u_exdata.ux_tsize == 0) ! 398: u.u_error = ENOEXEC; ! 399: break; ! 400: ! 401: default: ! 402: ip = getshell(ip, sp); ! 403: } ! 404: } ! 405: ! 406: out: ! 407: if (u.u_error && ip != NULL) { ! 408: iput(ip); ! 409: ip = NULL; ! 410: } ! 411: ! 412: return ip; ! 413: } ! 414: ! 415: /* ! 416: * Read in and set up memory for executed file. ! 417: */ ! 418: getxfile(ip, nargc, uid, gid) ! 419: register struct inode *ip; ! 420: { ! 421: register clicks_t ts, ds, ss; ! 422: int pagi; ! 423: ! 424: /* for now, no paging off alternate file systems */ ! 425: if (u.u_exdata.ux_mag == 0413 && !BITFS(ip->i_dev) && !ip->i_fstyp) ! 426: pagi = SPAGI; ! 427: else ! 428: pagi = 0; ! 429: /* never demand-page if process is traced (panic pagein mfind) */ ! 430: if (PTRACED(u.u_procp)) ! 431: pagi = 0; ! 432: ! 433: if(u.u_exdata.ux_tsize!=0 && (ip->i_flag&ITEXT)==0 && ip->i_count!=1) { ! 434: register struct file *fp; ! 435: ! 436: for (fp = file; fp < fileNFILE; fp++) ! 437: if (fp->f_count && fp->f_inode==ip ! 438: && (fp->f_flag&FWRITE)) { ! 439: u.u_error = ETXTBSY; ! 440: goto bad; ! 441: } ! 442: } ! 443: ! 444: /* ! 445: * find text and data sizes ! 446: * try them out for possible ! 447: * exceed of max sizes ! 448: */ ! 449: ! 450: ts = clrnd(btoc(u.u_exdata.ux_tsize)); ! 451: ds = clrnd(btoc((u.u_exdata.ux_dsize+u.u_exdata.ux_bsize))); ! 452: ss = clrnd(SSIZE + btoc(nargc)); ! 453: if (chksize(ts, ds, ss)) ! 454: goto bad; ! 455: u.u_cdmap = zdmap; ! 456: u.u_csmap = zdmap; ! 457: if (swpexpand(ds, ss, &u.u_cdmap, &u.u_csmap) == NULL) ! 458: goto bad; ! 459: ! 460: /* ! 461: * At this point, committed to the new image! ! 462: * Release virtual memory resources of old process, and ! 463: * initialize the virtual memory of the new process. ! 464: */ ! 465: u.u_prof.pr_scale = 0; ! 466: vrelvm(); ! 467: u.u_procp->p_flag &= ~(SPAGI|SSEQL|SUANOM); ! 468: u.u_procp->p_flag |= pagi; ! 469: u.u_dmap = u.u_cdmap; ! 470: u.u_smap = u.u_csmap; ! 471: vgetvm(ts, ds, ss); ! 472: ! 473: if (pagi == 0) { ! 474: /* ! 475: * Read in data segment. ! 476: */ ! 477: u.u_base = (char *)ctob(ts); ! 478: if(u.u_exdata.ux_mag != 0413) ! 479: u.u_offset = ltoL(sizeof(u.u_exdata)+u.u_exdata.ux_tsize); ! 480: else /* stupid 1k 0413 files */ ! 481: u.u_offset = ltoL(BSIZE(0) + u.u_exdata.ux_tsize); ! 482: u.u_count = u.u_exdata.ux_dsize; ! 483: readi(ip); ! 484: } ! 485: xalloc(ip, pagi); ! 486: if (pagi && u.u_procp->p_textp) ! 487: vinifod((struct fpte *)dptopte(u.u_procp, 0), ! 488: u.u_procp->p_textp->x_iptr, ! 489: 1 + ts/CLSIZE, (int)btoc(u.u_exdata.ux_dsize)); ! 490: ! 491: /* THIS SHOULD BE DONE AT A LOWER LEVEL, IF AT ALL */ ! 492: mtpr(TBIA, 0); ! 493: ! 494: /* ! 495: * set SUID/SGID protections, if no tracing ! 496: */ ! 497: if (!PTRACED(u.u_procp)) { ! 498: u.u_uid = uid; ! 499: u.u_procp->p_uid = uid; ! 500: u.u_gid = gid; ! 501: } ! 502: if (u.u_procp->p_flag&SSEXEC) ! 503: psignal(u.u_procp, SIGSTOP); ! 504: u.u_tsize = ts; ! 505: u.u_dsize = ds; ! 506: u.u_ssize = ss; ! 507: bad: ! 508: return; ! 509: } ! 510: ! 511: /* ! 512: * Reset context on exec ! 513: */ ! 514: setregs(comm) ! 515: char *comm; ! 516: { ! 517: register i; ! 518: register int (*f)(); ! 519: ! 520: for (i = 0; i < NSIG; i++) { ! 521: if ((f = u.u_signal[i]) == SIG_DFL ! 522: || f == SIG_IGN || f == SIG_HOLD) ! 523: continue; ! 524: spl6(); /* needed? */ ! 525: u.u_signal[i] = SIG_DFL; ! 526: P_SETDFL(u.u_procp, SIGMASK(i)); ! 527: spl0(); ! 528: } ! 529: /* ! 530: for(rp = &u.u_ar0[0]; rp < &u.u_ar0[16];) ! 531: *rp++ = 0; ! 532: */ ! 533: u.u_ar0[PC] = u.u_exdata.ux_entloc + 2; /* skip over entry mask */ ! 534: for(i=0; i<NOFILE; i++) { ! 535: if (u.u_pofile[i]&EXCLOSE) { ! 536: closef(u.u_ofile[i]); ! 537: u.u_ofile[i] = NULL; ! 538: u.u_pofile[i] &= ~EXCLOSE; ! 539: } ! 540: } ! 541: /* ! 542: * Remember file name for accounting. ! 543: */ ! 544: u.u_acflag &= ~AFORK; ! 545: bcopy((caddr_t)comm, (caddr_t)u.u_comm, sizeof(u.u_comm)); ! 546: } ! 547: ! 548: /* ! 549: * exit system call: ! 550: * pass back caller's arg ! 551: */ ! 552: rexit() ! 553: { ! 554: register struct a { ! 555: int rval; ! 556: } *uap; ! 557: ! 558: uap = (struct a *)u.u_ap; ! 559: exit((uap->rval & 0377) << 8); ! 560: } ! 561: ! 562: /* ! 563: * Release resources. ! 564: * Save u. area for parent to look at. ! 565: * Enter zombie state. ! 566: * Wake up parent and init processes, ! 567: * and dispose of children. ! 568: */ ! 569: exit(rv) ! 570: { ! 571: register int i; ! 572: register struct proc *p, *q; ! 573: register struct file *f; ! 574: ! 575: vmsizmon(); ! 576: p = u.u_procp; ! 577: p->p_flag &= ~(STRC|SULOCK); ! 578: p->p_flag |= SWEXIT; ! 579: p->p_clktim = 0; ! 580: (void) spl6(); ! 581: p->p_siga0 = p->p_siga1 = 0; ! 582: p->p_ignsig = ~0; /* magic: ignore all */ ! 583: (void) spl0(); ! 584: p->p_cpticks = 0; ! 585: p->p_pctcpu = 0; ! 586: for(i=0; i<NSIG; i++) ! 587: u.u_signal[i] = SIG_IGN; ! 588: vrelvm(); ! 589: for(i=0; i<NOFILE; i++) { ! 590: if ((f = u.u_ofile[i]) == NULL) ! 591: continue; ! 592: u.u_ofile[i] = NULL; ! 593: closef(f); ! 594: } ! 595: plock(u.u_cdir); ! 596: iput(u.u_cdir); ! 597: if (u.u_rdir) { ! 598: plock(u.u_rdir); ! 599: iput(u.u_rdir); ! 600: } ! 601: u.u_limit[LIM_FSIZE] = INFINITY; ! 602: acct(); ! 603: vrelpt(u.u_procp); ! 604: vrelu(u.u_procp, 0); ! 605: p->p_stat = SZOMB; ! 606: noproc = 1; ! 607: if (p->p_pid < SYSPIDS) ! 608: printf("process %d died\n", p->p_pid); ! 609: done: ! 610: ((struct xproc *)p)->xp_xstat = rv; /* overlay */ ! 611: ((struct xproc *)p)->xp_vm = u.u_vm; /* overlay */ ! 612: vmsadd(&((struct xproc *)p)->xp_vm, &u.u_cvm); ! 613: for(q = proc; q < procNPROC; q++) ! 614: if (q->p_stat != 0 && q->p_pptr == p) { ! 615: q->p_pptr = &proc[INITPID]; ! 616: q->p_ppid = 1; ! 617: wakeup((caddr_t)&proc[INITPID]); ! 618: /* ! 619: * Traced processes are killed ! 620: * since their existence means someone is screwing up. ! 621: * this is probably wrong now ! 622: * Stopped processes are sent a hangup and a continue. ! 623: * This is designed to be ``safe'' for setuid ! 624: * processes since they must be willing to tolerate ! 625: * hangups anyways. ! 626: */ ! 627: if (q->p_flag&STRC) { ! 628: q->p_flag &= ~STRC; ! 629: psignal(q, SIGKILL); ! 630: } else if (q->p_stat == SSTOP) { ! 631: psignal(q, SIGHUP); ! 632: psignal(q, SIGCONT); ! 633: } ! 634: (void) spgrp(q, -1); ! 635: } ! 636: wakeup((caddr_t)p->p_pptr); ! 637: if (p->p_trace) ! 638: wakeup((caddr_t)p->p_trace); ! 639: psignal(p->p_pptr, SIGCHLD); ! 640: swtch(); ! 641: } ! 642: ! 643: wait() ! 644: { ! 645: struct vtimes vm; ! 646: struct vtimes *vp; ! 647: ! 648: if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) { ! 649: wait1(0, (struct vtimes *)0); ! 650: return; ! 651: } ! 652: vp = (struct vtimes *)u.u_ar0[R1]; ! 653: wait1(u.u_ar0[R0], &vm); ! 654: if (u.u_error) ! 655: return; ! 656: (void) copyout((caddr_t)&vm, (caddr_t)vp, sizeof (struct vtimes)); ! 657: } ! 658: ! 659: /* ! 660: * Wait system call. ! 661: * Search for a terminated (zombie) child, ! 662: * finally lay it to rest, and collect its status. ! 663: * Look also for stopped (traced) children, ! 664: * and pass back status from them. ! 665: */ ! 666: wait1(options, vp) ! 667: register options; ! 668: struct vtimes *vp; ! 669: { ! 670: register f; ! 671: register struct proc *p; ! 672: register struct proc *myp; /* optimization */ ! 673: ! 674: f = 0; ! 675: myp = u.u_procp; ! 676: loop: ! 677: for(p = proc; p < procNPROC; p++) { ! 678: if (p->p_stat == 0 || p->p_pptr != myp) ! 679: continue; ! 680: f++; ! 681: if(p->p_stat == SZOMB) { ! 682: u.u_r.r_val1 = p->p_pid; ! 683: u.u_r.r_val2 = ((struct xproc *)p)->xp_xstat; ! 684: if (vp) ! 685: *vp = ((struct xproc *)p)->xp_vm; ! 686: vmsadd(&u.u_cvm, &((struct xproc *)p)->xp_vm); ! 687: p->p_stat = 0; ! 688: /* if it mattered, we could bzero(p, sizeof(*p)) here */ ! 689: if (p == procNPROC - 1) { ! 690: do ! 691: --p; ! 692: while (p->p_stat == 0); ! 693: procNPROC = p + 1; ! 694: } ! 695: return; ! 696: } ! 697: if (p->p_stat == SSTOP && (p->p_flag&SWTED)==0 && ! 698: (p->p_flag&STRC)==0) { ! 699: p->p_flag |= SWTED; ! 700: u.u_r.r_val1 = p->p_pid; ! 701: u.u_r.r_val2 = (p->p_cursig<<8) | WSTOPPED; ! 702: return; ! 703: } ! 704: } ! 705: if (f==0) { ! 706: u.u_error = ECHILD; ! 707: return; ! 708: } ! 709: if (options&WNOHANG) { ! 710: u.u_r.r_val1 = 0; ! 711: return; ! 712: } ! 713: sleep((caddr_t)myp, PWAIT); ! 714: goto loop; ! 715: } ! 716: ! 717: /* ! 718: * fork system call. ! 719: */ ! 720: fork() ! 721: { ! 722: register struct proc *p1, *p2; ! 723: register int a, pid; ! 724: static int mpid = 0; ! 725: ! 726: u.u_cdmap = zdmap; ! 727: u.u_csmap = zdmap; ! 728: if (swpexpand(u.u_dsize, u.u_ssize, &u.u_cdmap, &u.u_csmap) == 0) ! 729: goto out; ! 730: retry: ! 731: pid = ++mpid; ! 732: if (pid > MAXPID) ! 733: pid = mpid = 1; ! 734: a = 0; ! 735: p2 = NULL; ! 736: for(p1 = proc; p1 < procNPROC; p1++) { ! 737: if (p1->p_stat == 0) { ! 738: if (p2 == NULL) ! 739: p2 = p1; ! 740: continue; ! 741: } ! 742: if (p1->p_pid == pid || p1->p_pgrp == pid) ! 743: goto retry; ! 744: if (p1->p_uid == u.u_uid) ! 745: a++; ! 746: } ! 747: if (p2 == NULL) { /* try pushing up high water mark */ ! 748: for (; p1 < &proc[proccnt]; p1++) ! 749: if (p1->p_stat == 0) { ! 750: p2 = p1; ! 751: p1++; ! 752: break; ! 753: } ! 754: procNPROC = p1; ! 755: } ! 756: /* ! 757: * Disallow if ! 758: * No processes at all; ! 759: * not su and too many procs owned; or ! 760: * not su and would take last slot. ! 761: */ ! 762: if (p2==NULL) ! 763: tablefull("proc"); ! 764: if (p2==NULL || (u.u_uid!=0 && (p2==&proc[proccnt-1] || a>MAXUPRC))) { ! 765: u.u_error = EAGAIN; ! 766: (void) vsexpand(0, &u.u_cdmap, 1); ! 767: (void) vsexpand(0, &u.u_csmap, 1); ! 768: goto out; ! 769: } ! 770: p1 = u.u_procp; ! 771: if(newproc(p2, pid)) { ! 772: u.u_r.r_val1 = p1->p_pid; ! 773: u.u_r.r_val2 = 1; /* child */ ! 774: u.u_start = time; ! 775: u.u_acflag = AFORK; ! 776: u.u_nbadio = 0; ! 777: return; ! 778: } ! 779: u.u_r.r_val1 = pid; ! 780: out: ! 781: u.u_r.r_val2 = 0; ! 782: } ! 783: ! 784: /* ! 785: * break system call. ! 786: * -- bad planning: "break" is a dirty word in C. ! 787: */ ! 788: sbreak() ! 789: { ! 790: struct a { ! 791: char *nsiz; ! 792: }; ! 793: register int n, d; ! 794: ! 795: /* ! 796: * set n to new data size ! 797: * set d to new-old ! 798: */ ! 799: ! 800: n = btoc(((struct a *)u.u_ap)->nsiz); ! 801: #if NOTDEF ! 802: if (!u.u_sep) ! 803: #endif ! 804: n -= ctos(u.u_tsize) * stoc(1); ! 805: if (n < 0) ! 806: n = 0; ! 807: d = clrnd(n - u.u_dsize); ! 808: if (ctob(u.u_dsize+d) > u.u_limit[LIM_DATA]) { ! 809: u.u_error = ENOMEM; ! 810: return; ! 811: } ! 812: if (chksize(u.u_tsize, u.u_dsize+d, u.u_ssize)) ! 813: return; ! 814: if (swpexpand(u.u_dsize+d, u.u_ssize, &u.u_dmap, &u.u_smap)==0) ! 815: return; ! 816: expand(d, P0BR); ! 817: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.