![[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 [CSRG BSD Unix] / 41BSD / sys / newsys|
Return to sys1.c CVS log | Up to [CSRG BSD Unix] / 41BSD / sys / newsys |
1.1 ! root 1: From uucp Thu Jan 10 01:37:58 1980 ! 2: >From dmr Thu Jan 10 04:25:49 1980 remote from research ! 3: The system has been changed so that if a file being executed ! 4: begins with the magic characters #! , the rest of the line is understood ! 5: to be the name of an interpreter for the executed file. ! 6: Previously (and in fact still) the shell did much of this job; ! 7: it automatically executed itself on a text file with executable mode ! 8: when the text file's name was typed as a command. ! 9: Putting the facility into the system gives the following ! 10: benefits. ! 11: ! 12: 1) It makes shell scripts more like real executable files, ! 13: because they can be the subject of 'exec.' ! 14: ! 15: 2) If you do a 'ps' while such a command is running, its real ! 16: name appears instead of 'sh'. ! 17: Likewise, accounting is done on the basis of the real name. ! 18: ! 19: 3) Shell scripts can be set-user-ID. ! 20: ! 21: 4) It is simpler to have alternate shells available; ! 22: e.g. if you like the Berkeley csh there is no question about ! 23: which shell is to interpret a file. ! 24: ! 25: 5) It will allow other interpreters to fit in more smoothly. ! 26: ! 27: To take advantage of this wonderful opportunity, ! 28: put ! 29: ! 30: #! /bin/sh ! 31: ! 32: at the left margin of the first line of your shell scripts. ! 33: Blanks after ! are OK. Use a complete pathname (no search is done). ! 34: At the moment the whole line is restricted to 16 characters but ! 35: this limit will be raised. ! 36: ! 37: ! 38: From uucp Thu Jan 10 01:37:49 1980 ! 39: >From dmr Thu Jan 10 04:23:53 1980 remote from research ! 40: #include "../h/param.h" ! 41: #include "../h/systm.h" ! 42: #include "../h/map.h" ! 43: #include "../h/dir.h" ! 44: #include "../h/user.h" ! 45: #include "../h/proc.h" ! 46: #include "../h/buf.h" ! 47: #include "../h/reg.h" ! 48: #include "../h/inode.h" ! 49: #include "../h/seg.h" ! 50: #include "../h/acct.h" ! 51: ! 52: ! 53: /* ! 54: * exec system call, with and without environments. ! 55: */ ! 56: struct execa { ! 57: char *fname; ! 58: char **argp; ! 59: char **envp; ! 60: }; ! 61: ! 62: exec() ! 63: { ! 64: ((struct execa *)u.u_ap)->envp = NULL; ! 65: exece(); ! 66: } ! 67: ! 68: exece() ! 69: { ! 70: register nc; ! 71: register char *cp; ! 72: register struct buf *bp; ! 73: register struct execa *uap; ! 74: int na, ne, bno, ucp, ap, c, indir, uid, gid; ! 75: struct inode *ip; ! 76: ! 77: bno = 0; ! 78: bp = 0; ! 79: indir = 0; ! 80: if ((ip = namei(uchar, 0)) == NULL) ! 81: return; ! 82: uid = u.u_uid; ! 83: gid = u.u_gid; ! 84: if (ip->i_mode&ISUID) ! 85: uid = ip->i_uid; ! 86: if (ip->i_mode&ISGID) ! 87: gid = ip->i_gid; ! 88: again: ! 89: if(access(ip, IEXEC)) ! 90: goto bad; ! 91: if((ip->i_mode & IFMT) != IFREG || ! 92: (ip->i_mode & (IEXEC|(IEXEC>>3)|(IEXEC>>6))) == 0) { ! 93: u.u_error = EACCES; ! 94: goto bad; ! 95: } ! 96: /* ! 97: * read in first few bytes ! 98: * of file for segment ! 99: * types and sizes: ! 100: * ux_mag = 407/410/411/405 ! 101: * 407 is plain executable ! 102: * 410 is RO text ! 103: * 411 is separated ID ! 104: * 405 is overlaid text ! 105: * ! 106: * Also, an ascii line beginning ! 107: * with '#!' is the file name of a shell. ! 108: */ ! 109: u.u_base = (caddr_t)&u.u_exdata; ! 110: u.u_count = sizeof(u.u_exdata); ! 111: u.u_offset = 0; ! 112: u.u_segflg = 1; ! 113: readi(ip); ! 114: u.u_segflg = 0; ! 115: if(u.u_error) ! 116: goto bad; ! 117: if (u.u_count > sizeof(u.u_exdata) - sizeof(u.u_exdata.A) ! 118: && u.u_exdata.S[0] != '#') { ! 119: u.u_error = ENOEXEC; ! 120: goto bad; ! 121: } ! 122: if(u.u_exdata.A.ux_mag == 0407) ! 123: ; ! 124: else if (u.u_exdata.A.ux_mag == 0411) ! 125: ; ! 126: else if (u.u_exdata.A.ux_mag == 0405) ! 127: ; ! 128: else if (u.u_exdata.A.ux_mag == 0410) ! 129: ; ! 130: else if (u.u_exdata.S[0]=='#' && u.u_exdata.S[1]=='!' && indir==0) { ! 131: cp = &u.u_exdata.S[2]; ! 132: while (*cp==' ' && cp<&u.u_exdata.S[SHSIZ]) ! 133: cp++; ! 134: u.u_dirp = cp; ! 135: while (cp < &u.u_exdata.S[SHSIZ-1] && *cp != '\n') ! 136: cp++; ! 137: *cp = '\0'; ! 138: indir++; ! 139: iput(ip); ! 140: ip = namei(schar, 0); ! 141: if (ip==NULL) ! 142: return; ! 143: goto again; ! 144: } else { ! 145: u.u_error = ENOEXEC; ! 146: goto bad; ! 147: } ! 148: /* ! 149: * Collect arguments on "file" in swap space. ! 150: */ ! 151: na = 0; ! 152: ne = 0; ! 153: nc = 0; ! 154: uap = (struct execa *)u.u_ap; ! 155: while ((bno = malloc(argmap,(NCARGS+BSIZE-1)/BSIZE)) == 0) ! 156: sleep((caddr_t)&argmap, PRIBIO); ! 157: if (uap->argp) for (;;) { ! 158: ap = NULL; ! 159: if (indir && na==1) ! 160: ap = uap->fname; ! 161: else if (uap->argp) { ! 162: ap = fuword((caddr_t)uap->argp); ! 163: uap->argp++; ! 164: } ! 165: if (ap==NULL && uap->envp) { ! 166: uap->argp = NULL; ! 167: if ((ap = fuword((caddr_t)uap->envp)) == NULL) ! 168: break; ! 169: uap->envp++; ! 170: ne++; ! 171: } ! 172: if (ap==NULL) ! 173: break; ! 174: na++; ! 175: if(ap == -1) ! 176: u.u_error = EFAULT; ! 177: do { ! 178: if (nc >= NCARGS-1) ! 179: u.u_error = E2BIG; ! 180: if ((c = fubyte((caddr_t)ap++)) < 0) ! 181: u.u_error = EFAULT; ! 182: if (u.u_error) ! 183: goto bad; ! 184: if ((nc&BMASK) == 0) { ! 185: if (bp) ! 186: bawrite(bp); ! 187: bp = getblk(swapdev, swplo+bno+(nc>>BSHIFT)); ! 188: cp = bp->b_un.b_addr; ! 189: } ! 190: nc++; ! 191: *cp++ = c; ! 192: } while (c>0); ! 193: } ! 194: if (bp) ! 195: bawrite(bp); ! 196: bp = 0; ! 197: nc = (nc + NBPW-1) & ~(NBPW-1); ! 198: getxfile(ip, nc, uid, gid); ! 199: if (u.u_error || u.u_exdata.A.ux_mag==0405) ! 200: goto bad; ! 201: ! 202: /* ! 203: * copy back arglist ! 204: */ ! 205: ucp = -nc - NBPW; ! 206: ap = ucp - na*NBPW - 3*NBPW; ! 207: u.u_ar0[R6] = ap; ! 208: suword((caddr_t)ap, na-ne); ! 209: nc = 0; ! 210: for (;;) { ! 211: ap += NBPW; ! 212: if (na==ne) { ! 213: suword((caddr_t)ap, 0); ! 214: ap += NBPW; ! 215: } ! 216: if (--na < 0) ! 217: break; ! 218: suword((caddr_t)ap, ucp); ! 219: do { ! 220: if ((nc&BMASK) == 0) { ! 221: if (bp) ! 222: brelse(bp); ! 223: bp = bread(swapdev, swplo+bno+(nc>>BSHIFT)); ! 224: bp->b_flags &= ~B_DELWRI; ! 225: cp = bp->b_un.b_addr; ! 226: if (nc==0 && indir) ! 227: bcopy(cp, (caddr_t)u.u_dbuf, DIRSIZ); ! 228: } ! 229: subyte((caddr_t)ucp++, (c = *cp++)); ! 230: nc++; ! 231: } while(c&0377); ! 232: } ! 233: suword((caddr_t)ap, 0); ! 234: suword((caddr_t)ucp, 0); ! 235: setregs(); ! 236: bad: ! 237: if (bp) ! 238: brelse(bp); ! 239: if(bno) { ! 240: mfree(argmap, (NCARGS+BSIZE-1)/BSIZE, bno); ! 241: wakeup((caddr_t)&argmap); ! 242: } ! 243: iput(ip); ! 244: } ! 245: ! 246: /* ! 247: * Read in and set up memory for executed file. ! 248: */ ! 249: getxfile(ip, nargc, uid, gid) ! 250: register struct inode *ip; ! 251: { ! 252: register unsigned ds; ! 253: register sep; ! 254: register unsigned ts, ss; ! 255: int i; ! 256: long lsize; ! 257: ! 258: sep = 0; ! 259: if(u.u_exdata.A.ux_mag == 0407) { ! 260: lsize = (long)u.u_exdata.A.ux_dsize + u.u_exdata.A.ux_tsize; ! 261: u.u_exdata.A.ux_dsize = lsize; ! 262: if (lsize != u.u_exdata.A.ux_dsize) { /* check overflow */ ! 263: u.u_error = ENOMEM; ! 264: return; ! 265: } ! 266: u.u_exdata.A.ux_tsize = 0; ! 267: } else if (u.u_exdata.A.ux_mag == 0411) ! 268: sep++; ! 269: if(u.u_exdata.A.ux_tsize!=0 && (ip->i_flag&ITEXT)==0 && ip->i_count!=1) { ! 270: u.u_error = ETXTBSY; ! 271: return; ! 272: } ! 273: ! 274: /* ! 275: * find text and data sizes ! 276: * try them out for possible ! 277: * overflow of max sizes ! 278: */ ! 279: ts = btoc(u.u_exdata.A.ux_tsize); ! 280: lsize = (long)u.u_exdata.A.ux_dsize + u.u_exdata.A.ux_bsize; ! 281: if (lsize != (unsigned)lsize) { ! 282: u.u_error = ENOMEM; ! 283: return; ! 284: } ! 285: ds = btoc(lsize); ! 286: ss = SSIZE + btoc(nargc); ! 287: if (u.u_exdata.A.ux_mag==0405) { ! 288: if (u.u_sep==0 && ctos(ts) != ctos(u.u_tsize) || nargc) { ! 289: u.u_error = ENOMEM; ! 290: return; ! 291: } ! 292: ds = u.u_dsize; ! 293: ss = u.u_ssize; ! 294: sep = u.u_sep; ! 295: xfree(); ! 296: xalloc(ip); ! 297: u.u_ar0[PC] = u.u_exdata.A.ux_entloc & ~01; ! 298: } else { ! 299: if(estabur(ts, ds, ss, sep, RO)) ! 300: return; ! 301: ! 302: /* ! 303: * allocate and clear core ! 304: * at this point, committed ! 305: * to the new image ! 306: */ ! 307: u.u_prof.pr_scale = 0; ! 308: xfree(); ! 309: i = USIZE+ds+ss; ! 310: expand(i); ! 311: while(--i >= USIZE) ! 312: clearseg(u.u_procp->p_addr+i); ! 313: xalloc(ip); ! 314: ! 315: /* ! 316: * read in data segment ! 317: */ ! 318: estabur((unsigned)0, ds, (unsigned)0, 0, RO); ! 319: u.u_base = 0; ! 320: u.u_offset = sizeof(u.u_exdata.A)+u.u_exdata.A.ux_tsize; ! 321: u.u_count = u.u_exdata.A.ux_dsize; ! 322: readi(ip); ! 323: /* ! 324: * set SUID/SGID protections, if no tracing ! 325: */ ! 326: if ((u.u_procp->p_flag&STRC)==0) { ! 327: u.u_uid = uid; ! 328: u.u_gid = gid; ! 329: } else ! 330: psignal(u.u_procp, SIGTRC); ! 331: } ! 332: u.u_tsize = ts; ! 333: u.u_dsize = ds; ! 334: u.u_ssize = ss; ! 335: u.u_sep = sep; ! 336: estabur(ts, ds, ss, sep, RO); ! 337: } ! 338: ! 339: /* ! 340: * Clear registers on exec ! 341: */ ! 342: setregs() ! 343: { ! 344: register int *rp; ! 345: register char *cp; ! 346: register i; ! 347: ! 348: for(rp = &u.u_signal[0]; rp < &u.u_signal[NSIG]; rp++) ! 349: if((*rp & 1) == 0) ! 350: *rp = 0; ! 351: for(cp = ®loc[0]; cp < ®loc[6];) ! 352: u.u_ar0[*cp++] = 0; ! 353: u.u_ar0[PC] = u.u_exdata.A.ux_entloc & ~01; ! 354: for(rp = (int *)&u.u_fps; rp < (int *)&u.u_fps.u_fpregs[6];) ! 355: *rp++ = 0; ! 356: for(i=0; i<NOFILE; i++) { ! 357: if (u.u_pofile[i]&EXCLOSE) { ! 358: closef(u.u_ofile[i]); ! 359: u.u_ofile[i] = NULL; ! 360: u.u_pofile[i] &= ~EXCLOSE; ! 361: } ! 362: } ! 363: /* ! 364: * Remember file name for accounting. ! 365: */ ! 366: u.u_acflag &= ~AFORK; ! 367: bcopy((caddr_t)u.u_dbuf, (caddr_t)u.u_comm, DIRSIZ); ! 368: } ! 369: ! 370: /* ! 371: * exit system call: ! 372: * pass back caller's arg ! 373: */ ! 374: rexit() ! 375: { ! 376: register struct a { ! 377: int rval; ! 378: } *uap; ! 379: ! 380: uap = (struct a *)u.u_ap; ! 381: exit((uap->rval & 0377) << 8); ! 382: } ! 383: ! 384: /* ! 385: * Release resources. ! 386: * Save u. area for parent to look at. ! 387: * Enter zombie state. ! 388: * Wake up parent and init processes, ! 389: * and dispose of children. ! 390: */ ! 391: exit(rv) ! 392: { ! 393: register int i; ! 394: register struct proc *p, *q; ! 395: register struct file *f; ! 396: ! 397: p = u.u_procp; ! 398: p->p_flag &= ~(STRC|SULOCK); ! 399: p->p_clktim = 0; ! 400: for(i=0; i<NSIG; i++) ! 401: u.u_signal[i] = 1; ! 402: for(i=0; i<NOFILE; i++) { ! 403: f = u.u_ofile[i]; ! 404: u.u_ofile[i] = NULL; ! 405: closef(f); ! 406: } ! 407: plock(u.u_cdir); ! 408: iput(u.u_cdir); ! 409: if (u.u_rdir) { ! 410: plock(u.u_rdir); ! 411: iput(u.u_rdir); ! 412: } ! 413: xfree(); ! 414: acct(); ! 415: mfree(coremap, p->p_size, p->p_addr); ! 416: p->p_stat = SZOMB; ! 417: ((struct xproc *)p)->xp_xstat = rv; ! 418: ((struct xproc *)p)->xp_utime = u.u_cutime + u.u_utime; ! 419: ((struct xproc *)p)->xp_stime = u.u_cstime + u.u_stime; ! 420: for(q = &proc[0]; q < &proc[NPROC]; q++) ! 421: if(q->p_ppid == p->p_pid) { ! 422: wakeup((caddr_t)&proc[1]); ! 423: q->p_ppid = 1; ! 424: if (q->p_stat==SSTOP) ! 425: setrun(q); ! 426: } ! 427: for(q = &proc[0]; q < &proc[NPROC]; q++) ! 428: if(p->p_ppid == q->p_pid) { ! 429: wakeup((caddr_t)q); ! 430: swtch(); ! 431: /* no return */ ! 432: } ! 433: swtch(); ! 434: } ! 435: ! 436: /* ! 437: * Wait system call. ! 438: * Search for a terminated (zombie) child, ! 439: * finally lay it to rest, and collect its status. ! 440: * Look also for stopped (traced) children, ! 441: * and pass back status from them. ! 442: */ ! 443: wait() ! 444: { ! 445: register f; ! 446: register struct proc *p; ! 447: ! 448: f = 0; ! 449: ! 450: loop: ! 451: for(p = &proc[0]; p < &proc[NPROC]; p++) ! 452: if(p->p_ppid == u.u_procp->p_pid) { ! 453: f++; ! 454: if(p->p_stat == SZOMB) { ! 455: u.u_r.V.r_val1 = p->p_pid; ! 456: u.u_r.V.r_val2 = ((struct xproc *)p)->xp_xstat; ! 457: u.u_cutime += ((struct xproc *)p)->xp_utime; ! 458: u.u_cstime += ((struct xproc *)p)->xp_stime; ! 459: p->p_pid = 0; ! 460: p->p_ppid = 0; ! 461: p->p_pgrp = 0; ! 462: p->p_sig = 0; ! 463: p->p_flag = 0; ! 464: p->p_wchan = 0; ! 465: p->p_stat = NULL; ! 466: return; ! 467: } ! 468: if(p->p_stat == SSTOP) { ! 469: if((p->p_flag&SWTED) == 0) { ! 470: p->p_flag |= SWTED; ! 471: u.u_r.V.r_val1 = p->p_pid; ! 472: u.u_r.V.r_val2 = (fsig(p)<<8) | 0177; ! 473: return; ! 474: } ! 475: continue; ! 476: } ! 477: } ! 478: if(f) { ! 479: sleep((caddr_t)u.u_procp, PWAIT); ! 480: goto loop; ! 481: } ! 482: u.u_error = ECHILD; ! 483: } ! 484: ! 485: /* ! 486: * fork system call. ! 487: */ ! 488: fork() ! 489: { ! 490: register struct proc *p1, *p2; ! 491: register a; ! 492: ! 493: /* ! 494: * Make sure there's enough swap space for max ! 495: * core image, thus reducing chances of running out ! 496: */ ! 497: if ((a = malloc(swapmap, ctod(MAXMEM))) == 0) { ! 498: u.u_error = ENOMEM; ! 499: goto out; ! 500: } ! 501: mfree(swapmap, ctod(MAXMEM), a); ! 502: a = 0; ! 503: p2 = NULL; ! 504: for(p1 = &proc[0]; p1 < &proc[NPROC]; p1++) { ! 505: if (p1->p_stat==NULL && p2==NULL) ! 506: p2 = p1; ! 507: else { ! 508: if (p1->p_uid==u.u_uid && p1->p_stat!=NULL) ! 509: a++; ! 510: } ! 511: } ! 512: /* ! 513: * Disallow if ! 514: * No processes at all; ! 515: * not su and too many procs owned; or ! 516: * not su and would take last slot. ! 517: */ ! 518: if (p2==NULL || (u.u_uid!=0 && (p2==&proc[NPROC-1] || a>MAXUPRC))) { ! 519: u.u_error = EAGAIN; ! 520: goto out; ! 521: } ! 522: p1 = u.u_procp; ! 523: if(newproc()) { ! 524: u.u_r.V.r_val1 = p1->p_pid; ! 525: u.u_start = time; ! 526: u.u_cstime = 0; ! 527: u.u_stime = 0; ! 528: u.u_cutime = 0; ! 529: u.u_utime = 0; ! 530: u.u_acflag = AFORK; ! 531: return; ! 532: } ! 533: u.u_r.V.r_val1 = p2->p_pid; ! 534: ! 535: out: ! 536: u.u_ar0[R7] += NBPW; ! 537: } ! 538: ! 539: /* ! 540: * break system call. ! 541: * -- bad planning: "break" is a dirty word in C. ! 542: */ ! 543: sbreak() ! 544: { ! 545: struct a { ! 546: char *nsiz; ! 547: }; ! 548: register a, n, d; ! 549: int i; ! 550: ! 551: /* ! 552: * set n to new data size ! 553: * set d to new-old ! 554: * set n to new total size ! 555: */ ! 556: ! 557: n = btoc((int)((struct a *)u.u_ap)->nsiz); ! 558: if(!u.u_sep) ! 559: n -= ctos(u.u_tsize) * stoc(1); ! 560: if(n < 0) ! 561: n = 0; ! 562: d = n - u.u_dsize; ! 563: n += USIZE+u.u_ssize; ! 564: if(estabur(u.u_tsize, u.u_dsize+d, u.u_ssize, u.u_sep, RO)) ! 565: return; ! 566: u.u_dsize += d; ! 567: if(d > 0) ! 568: goto bigger; ! 569: a = u.u_procp->p_addr + n - u.u_ssize; ! 570: i = n; ! 571: n = u.u_ssize; ! 572: while(n--) { ! 573: copyseg(a-d, a); ! 574: a++; ! 575: } ! 576: expand(i); ! 577: return; ! 578: ! 579: bigger: ! 580: expand(n); ! 581: a = u.u_procp->p_addr + n; ! 582: n = u.u_ssize; ! 583: while(n--) { ! 584: a--; ! 585: copyseg(a-d, a); ! 586: } ! 587: while(d--) ! 588: clearseg(--a); ! 589: } ! 590: ! 591:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.