![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exec.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 exec.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 ! root 1: /* $Header: /src386/STREAMS/coh.386/RCS/exec.c,v 2.3 93/08/09 13:35:18 bin Exp Locker: bin $ */ ! 2: /* ! 3: * Processing of the exec () system call. ! 4: * ! 5: * $Log: exec.c,v $ ! 6: * Revision 2.3 93/08/09 13:35:18 bin ! 7: * Kernel 82 changes ! 8: * ! 9: * Revision 2.2 93/07/26 15:22:36 nigel ! 10: * Nigel's R80 ! 11: * ! 12: * Revision 2.3 93/07/26 14:47:30 nigel ! 13: * Nigel's R80 ! 14: * ! 15: */ ! 16: ! 17: #include <common/_gregset.h> ! 18: #include <common/_tricks.h> ! 19: #include <kernel/sigproc.h> ! 20: ! 21: #include <sys/coherent.h> ! 22: #include <sys/acct.h> ! 23: #include <sys/buf.h> ! 24: #include <canon.h> ! 25: #include <sys/con.h> ! 26: #include <sys/errno.h> ! 27: #include <fcntl.h> ! 28: #include <sys/filsys.h> ! 29: #include <sys/ino.h> ! 30: #include <sys/inode.h> ! 31: #include <sys/file.h> ! 32: #include <a.out.h> ! 33: #include <l.out.h> ! 34: #include <sys/proc.h> ! 35: #include <sys/sched.h> ! 36: #include <sys/seg.h> ! 37: #include <signal.h> ! 38: #include <sys/stat.h> ! 39: #include <sys/fd.h> ! 40: ! 41: /* ! 42: * Round section and segment start address to nearest lower click boundary. ! 43: */ ! 44: ! 45: static void ! 46: xecrnd(xsp) ! 47: struct xecseg * xsp; ! 48: { ! 49: int diff; ! 50: ! 51: diff = xsp->fbase & (NBPC - 1); ! 52: xsp->mbase -= diff; ! 53: xsp->fbase -= diff; ! 54: xsp->size += diff; ! 55: } ! 56: ! 57: /* ! 58: * Pass control to an image in a file. ! 59: * Make sure the format is acceptable. Release ! 60: * the old segments. Read in the new ones. Some special ! 61: * care is taken so that shared and (more important) shared ! 62: * and separated images can be run on the 8086. ! 63: */ ! 64: ! 65: pexece(np, argp, envp, regsetp) ! 66: char * np; ! 67: char * argp []; ! 68: char * envp []; ! 69: gregset_t * regsetp; ! 70: { ! 71: struct xechdr head; ! 72: register INODE *ip; /* Load file INODE */ ! 73: register PROC *pp; /* A cheap copy of SELF */ ! 74: register SEG *segp; ! 75: SEG *ssegp; ! 76: register int i; /* For looping over segments*/ ! 77: int roundup; ! 78: int shrdsize; ! 79: struct xecnode * xlist = NULL; /* list head */ ! 80: struct xecnode * xp; ! 81: struct xecseg tempseg; ! 82: unsigned int textSize; ! 83: struct direct dir; ! 84: ! 85: pp = SELF; ! 86: memset (& head, 0, sizeof (head)); ! 87: if ((ip = exlopen (& head, np, & shrdsize, & xlist, & dir)) == NULL) ! 88: goto done; ! 89: ! 90: roundup = shrdsize & 0xf; ! 91: ssegp = exstack (& head, argp, envp, ! 92: __xmode_286 (regsetp) ? sizeof (short) : ! 93: sizeof (int)); ! 94: ! 95: if (! ssegp) { ! 96: idetach(ip); ! 97: goto done; ! 98: } ! 99: ! 100: /* Release shared memory. */ ! 101: shmAllDt (); ! 102: ! 103: /* ! 104: * At this point the file has been ! 105: * validated as an object module, and the ! 106: * argument list has been built. Release all of ! 107: * the original segments. At this point we have ! 108: * committed to the new image. A "sys exec" that ! 109: * gets an I/O error is doomed. ! 110: * NOTE: User-area segment is NOT released. ! 111: * Segment pointer in proc is erased BEFORE invoking sfree(). ! 112: */ ! 113: ! 114: for (i = 1 ; i < NUSEG ; ++ i) { ! 115: if ((segp = pp->p_segp [i]) != NULL) { ! 116: pp->p_segp [i] = NULL; ! 117: sfree (segp); ! 118: } ! 119: } ! 120: pp->p_segp [SISTACK] = ssegp; ! 121: ! 122: /* ! 123: * Read in the loadable segments. ! 124: */ ! 125: ! 126: switch (head.magic) { ! 127: case XMAGIC (I286MAGIC, I_MAGIC): ! 128: if ((segp = ssalloc (ip, SFTEXT, ! 129: head.segs [SISTEXT].size)) == NULL) ! 130: goto out; ! 131: pp->p_segp [SISTEXT] = segp; ! 132: ! 133: if (! exsread (segp, ip, & head.segs [SISTEXT], 0)) ! 134: goto out; ! 135: ! 136: if ((segp = ssalloc (ip, 0, roundup + ! 137: head.segs [SIPDATA].size + ! 138: head.segs [SIBSS].size)) == NULL) ! 139: goto out; ! 140: pp->p_segp [SIPDATA] = segp; ! 141: ! 142: if (! exsread(segp, ip, & head.segs [SIPDATA], shrdsize)) { ! 143: goto out; ! 144: } ! 145: head.segs [SIPDATA].size += roundup; ! 146: break; ! 147: ! 148: case XMAGIC (I386MAGIC, Z_MAGIC): ! 149: /* ! 150: * Round segment address down to nearest click boundary. ! 151: * Ciaran did this. I'm not sure why, but will preserve ! 152: * it for now. -hws- ! 153: */ ! 154: ! 155: tempseg = head.segs [SISTEXT]; /* save pre-rounding value */ ! 156: xecrnd (head.segs + SISTEXT); ! 157: xecrnd (head.segs + SIPDATA); ! 158: ! 159: /* ! 160: * Compute text segment size by taking highest address ! 161: * seen in any text section. ! 162: */ ! 163: ! 164: textSize = head.segs [SISTEXT].size + ! 165: head.segs [SISTEXT].mbase; ! 166: for (xp = xlist ; xp ; xp = xp->xn) { ! 167: unsigned int tmpSize; ! 168: if (xp->segtype != SISTEXT) ! 169: continue; ! 170: tmpSize = xp->xseg.size + xp->xseg.mbase; ! 171: if (tmpSize > textSize) ! 172: textSize = tmpSize; ! 173: } ! 174: ! 175: /* Entry point must be within text segment. */ ! 176: if (head.entry >= textSize) ! 177: goto out; ! 178: ! 179: if ((segp = ssalloc (ip, SFTEXT | SFSHRX, ! 180: textSize)) == NULL) ! 181: goto out; ! 182: ! 183: pp->p_segp [SISTEXT] = segp; ! 184: ! 185: if (segp->s_ip == 0) { ! 186: if (! exsread (segp, ip, & tempseg, 0)) ! 187: goto out; ! 188: ! 189: /* load additional text sections, if any */ ! 190: for (xp = xlist ; xp ; xp = xp->xn) { ! 191: if (xp->segtype != SISTEXT) ! 192: continue; ! 193: if (! exsread (segp, ip, & xlist->xseg, 0)) ! 194: goto out; ! 195: } ! 196: ! 197: segp->s_ip = ip; ! 198: ip->i_refc ++; ! 199: } ! 200: if ((segp = ssalloc (ip, 0, head.segs [SIPDATA].size + ! 201: head.segs[SIBSS].size)) == NULL) ! 202: goto out; ! 203: ! 204: pp->p_segp [SIPDATA] = segp; ! 205: ! 206: if (segp->s_ip == 0 && ! 207: ! exsread (segp, ip, & head.segs [SIPDATA], 0)) ! 208: goto out; ! 209: ! 210: /* Deallocate nodes hooked into xlist by exlopen. */ ! 211: while (xlist != NULL) { ! 212: struct xecnode * tmp = xlist->xn; ! 213: kfree (xlist); ! 214: xlist = tmp; ! 215: } ! 216: break; ! 217: ! 218: default: ! 219: panic("pexece"); ! 220: } ! 221: ! 222: if (sproto (& head) == 0) ! 223: goto out; ! 224: ! 225: /* ! 226: * At this point, and no earlier, we can modify the user register ! 227: * image for the new process because now we are committed to executing ! 228: * the new image. ! 229: * ! 230: * As a general security thing, we begin by zeroing out the user-level ! 231: * register image. ! 232: */ ! 233: ! 234: memset (regsetp, 0, sizeof (* regsetp)); ! 235: ! 236: switch (head.magic) { ! 237: case XMAGIC (I286MAGIC, I_MAGIC): ! 238: regsetp->_i286._cs = SEG_286_UII | R_USR; ! 239: regsetp->_i286._ss = regsetp->_i286._es = ! 240: regsetp->_i286._ds = SEG_286_UD | R_USR; ! 241: regsetp->_i286._ip = head.entry; ! 242: regsetp->_i286._usp = head.initsp; ! 243: break; ! 244: ! 245: case XMAGIC (I386MAGIC, Z_MAGIC): ! 246: regsetp->_i386._cs = SEG_386_UI | R_USR; ! 247: regsetp->_i386._ss = regsetp->_i386._es = ! 248: regsetp->_i386._ds = SEG_386_UD | R_USR; ! 249: regsetp->_i386._eip = head.entry; ! 250: regsetp->_i386._uesp = head.initsp; ! 251: break; ! 252: } ! 253: ! 254: ! 255: /* ! 256: * The new image is read in ! 257: * and mapped. Perform the final grunge ! 258: * (set-uid stuff, accounting, loading up ! 259: * registers, etc). ! 260: */ ! 261: ! 262: u.u_flag &= ~AFORK; ! 263: ! 264: memcpy (u.u_comm, dir.d_name, sizeof (u.u_comm)); ! 265: ! 266: if (iaccess (ip, IPR) == 0) { /* Can't read ? no dump or trace */ ! 267: pp->p_flags |= PFNDMP; ! 268: pp->p_flags &= ~PFTRAC; ! 269: } ! 270: ! 271: ! 272: /* ! 273: * Norm says Frank says we need to drop this for db to work. ! 274: */ ! 275: #if 0 ! 276: if (iaccess(ip, IPW) == 0) { /* Can't write ? no trace */ ! 277: pp->p_flags &= ~PFTRAC; ! 278: printf("Can't write - no trace! "); ! 279: u.u_error = 0; ! 280: } ! 281: #endif ! 282: ! 283: if ((ip->i_mode & ISUID) != 0) { /* Set user id ? no trace */ ! 284: pp->p_uid = u.u_uid = u.u_euid = ip->i_uid; ! 285: pp->p_flags &= ~PFTRAC; ! 286: } ! 287: ! 288: if ((ip->i_mode & ISGID) != 0) { /* Set group id ? no trace */ ! 289: u.u_egid = u.u_gid = ip->i_gid; ! 290: pp->p_flags &= ~PFTRAC; ! 291: } ! 292: ! 293: for (i = 0 ; i < NOFILE; i ++) { ! 294: int j = fdgetflags (i); ! 295: if (j != -1 && (j & FD_CLOEXEC) != 0) ! 296: fdclose (i); /* close fd on exec bit set */ ! 297: } ! 298: ! 299: ! 300: /* ! 301: * Default every signal that is not ignored. ! 302: */ ! 303: ! 304: for (i = 1 ; i <= NSIG ; ++ i) { ! 305: __sigaction_t act; ! 306: ! 307: curr_signal_action (i, NULL, & act); ! 308: if (act.sa_handler != SIG_IGN) { ! 309: act.sa_handler = SIG_DFL; ! 310: act.sa_flags = 0; ! 311: __SIGSET_EMPTY (act.sa_mask); ! 312: curr_signal_action (i, & act, NULL); ! 313: } ! 314: } ! 315: ! 316: if (pp->p_flags & PFTRAC) /* Being traced */ ! 317: sendsig (SIGTRAP, pp); ! 318: idetach (ip); ! 319: ! 320: /* initialize u area ndp fields */ ! 321: ndpNewProc (); ! 322: ! 323: segload (); ! 324: goto done; ! 325: ! 326: ! 327: /* ! 328: * Alas, exec() has failed.. ! 329: */ ! 330: out: ! 331: /* Deallocate nodes hooked into xlist by exlopen. */ ! 332: while (xlist != NULL) { ! 333: struct xecnode * tmp = xlist->xn; ! 334: kfree (xlist); ! 335: xlist = tmp; ! 336: } ! 337: ! 338: /* Release the INODE for the load file. */ ! 339: idetach (ip); ! 340: ! 341: /* If we allocated a text segment, let it go. */ ! 342: if ((segp = pp->p_segp [SISTEXT]) != NULL) { ! 343: pp->p_segp [SISTEXT] = NULL; ! 344: sfree (segp); ! 345: } ! 346: ! 347: /* If we allocated a data segment, let it go. */ ! 348: if ((segp = pp->p_segp[SIPDATA]) != NULL) { ! 349: pp->p_segp [SIPDATA] = NULL; ! 350: sfree (segp); ! 351: } ! 352: ! 353: /* ! 354: * Return through the "sys exit" code with a "SIGSYS", or with the ! 355: * signal actually received if we are aborting due to interrupted exec. ! 356: */ ! 357: ! 358: pexit (u.u_error == EINTR ? curr_signal_pending () : SIGSYS); ! 359: ! 360: done: ! 361: return 0; ! 362: } ! 363: ! 364: ! 365: /* ! 366: * Open a file, make sure it is l.out, coff, or v86 as well as ! 367: * executable. ! 368: * ! 369: * "xhp" points to a cleared xechdr supplied by the caller. ! 370: * "np" is the file name. ! 371: * "shrds" points to an int that will be written by exlopen(). ! 372: * *shrds is set nonzero only for shared l.out. ! 373: * ! 374: * If file is COFF, there may be multiple text (or data?) sections. ! 375: * Use "xlist" linked structure to keep track of variably many sections ! 376: * after the first text and data sections. ! 377: * ! 378: * return NULL if failure, else return inode pointer for the file. ! 379: */ ! 380: ! 381: INODE * ! 382: exlopen(xhp, np, shrds, xlist, dirent) ! 383: register struct xechdr *xhp; ! 384: char *np; ! 385: int *shrds; ! 386: struct xecnode ** xlist; ! 387: struct direct * dirent; ! 388: { ! 389: register INODE *ip; ! 390: int i, nscn, hdrsize; ! 391: register BUF *bp; ! 392: unsigned short magic; ! 393: struct ldheader head; ! 394: struct filehdr fhead; ! 395: struct aouthdr ahead; ! 396: struct scnhdr scnhdr; ! 397: IO io; ! 398: ! 399: /* ! 400: * Make sure the file is executable and read the header. Note that ! 401: * this about the only case of ftoi () with mode 'r' that actually ! 402: * uses the resulting filename information. ! 403: */ ! 404: ! 405: if (ftoi (np, 'r', & io, dirent)) ! 406: return NULL; ! 407: ! 408: ip = u.u_cdiri; ! 409: if (iaccess (ip, IPE) == 0) { ! 410: idetach (ip); ! 411: return NULL; ! 412: } ! 413: ! 414: if ((ip->i_mode & (IPE | (IPE << 3) | (IPE << 6))) == 0 || ! 415: (ip->i_mode & IFMT) != IFREG) { ! 416: u.u_error = EACCES; ! 417: idetach (ip); ! 418: return NULL; ! 419: } ! 420: ! 421: if ((bp = vread (ip, (daddr_t) 0)) == NULL) { ! 422: u.u_error = ENOEXEC; ! 423: idetach (ip); ! 424: return NULL; ! 425: } ! 426: ! 427: ! 428: /* ! 429: * Copy everything we need from the l.out header and check magic ! 430: * number and machine type. ! 431: */ ! 432: ! 433: * shrds = 0; ! 434: magic = * (unsigned short *) bp->b_vaddr; ! 435: canint (magic); ! 436: ! 437: switch (magic) { ! 438: case L_MAGIC: /* Coherent 286 format */ ! 439: memcpy (& head, bp->b_vaddr, sizeof (struct ldheader)); ! 440: ! 441: canint (head.l_machine); ! 442: if (head.l_machine != M_8086) ! 443: goto bad; ! 444: ! 445: for (i = 0 ; i < NXSEG ; i ++) ! 446: cansize (head.l_ssize [i]); ! 447: ! 448: canint (head.l_flag); ! 449: canvaddr (head.l_entry); ! 450: ! 451: /* ! 452: * If a shared and separated image ! 453: * has stuff in segments that makes it impossible ! 454: * to share, give an error immediately so that we don't ! 455: * lose the parent. ! 456: */ ! 457: head.l_flag &= LF_SHR | LF_SEP | LF_KER; ! 458: ! 459: if ((head.l_flag & LF_SEP) == 0 || ! 460: (head.l_flag & LF_KER) != 0 || ! 461: head.l_ssize [L_PRVI] || head.l_ssize [L_BSSI]) ! 462: goto bad; ! 463: ! 464: xhp->magic = XMAGIC (I286MAGIC,I_MAGIC); ! 465: xhp->entry = head.l_entry; ! 466: ! 467: xhp->segs [SISTEXT].fbase = sizeof (struct ldheader); ! 468: xhp->segs [SISTEXT].mbase = NBPS; ! 469: xhp->segs [SISTEXT].size = head.l_ssize [L_SHRI]; ! 470: ! 471: xhp->segs [SIPDATA].fbase = sizeof (struct ldheader) + ! 472: xhp->segs [SISTEXT].size; ! 473: xhp->segs [SIPDATA].mbase = 0; ! 474: xhp->segs [SIPDATA].size = head.l_ssize [L_SHRD] + ! 475: head.l_ssize [L_PRVD]; ! 476: if (head.l_flag & LF_SHR) ! 477: * shrds = head.l_ssize [L_SHRD]; ! 478: ! 479: xhp->segs [SIBSS].fbase = 0; ! 480: xhp->segs [SIBSS].mbase = xhp->segs [SIPDATA].size; ! 481: xhp->segs [SIBSS].size = head.l_ssize [L_BSSD]; ! 482: ! 483: xhp->segs [SISTACK].mbase = ISP_286; /* size 0, fbase 0 */ ! 484: brelease (bp); ! 485: return ip; ! 486: ! 487: case I386MAGIC: /* ... COFF */ ! 488: memcpy (& fhead, bp->b_vaddr, sizeof (struct filehdr)); ! 489: hdrsize = sizeof (ahead) + sizeof (fhead); ! 490: ! 491: if (fhead.f_opthdr != sizeof (ahead) || ! 492: (fhead.f_flags & F_EXEC) == 0 || ! 493: fhead.f_nscns * sizeof (scnhdr) > BSIZE) ! 494: goto bad; ! 495: ! 496: memcpy (& ahead, bp->b_vaddr + sizeof (fhead), ! 497: sizeof (ahead)); ! 498: if (ahead.magic != Z_MAGIC) ! 499: goto bad; ! 500: ! 501: xhp->magic = XMAGIC (I386MAGIC, ahead.magic); ! 502: xhp->entry = ahead.entry; ! 503: ! 504: for (i = 0 ; i < fhead.f_nscns ; i ++) { ! 505: memcpy (& scnhdr, ! 506: bp->b_vaddr + hdrsize + sizeof (scnhdr) * i, ! 507: sizeof (scnhdr)); ! 508: ! 509: switch ((int) (scnhdr.s_flags)) { ! 510: case STYP_INFO: ! 511: continue; ! 512: ! 513: case STYP_BSS: ! 514: nscn = SIBSS; ! 515: break; ! 516: ! 517: case STYP_TEXT: ! 518: nscn = SISTEXT; ! 519: break; ! 520: ! 521: case STYP_DATA: ! 522: nscn = SIPDATA; ! 523: break; ! 524: ! 525: default: ! 526: goto bad; ! 527: } ! 528: ! 529: /* Text/data shouldn't collide with stack. */ ! 530: if ((unsigned) scnhdr.s_vaddr >= ISP_386) ! 531: goto bad; ! 532: ! 533: /* Have we already seen a segment of this type? */ ! 534: if (xhp->segs [nscn].size) { ! 535: struct xecnode * tmp; ! 536: ! 537: if (nscn != SISTEXT) ! 538: goto bad; ! 539: ! 540: /* insert new node at head of "xlist" */ ! 541: tmp = (struct xecnode *) ! 542: kalloc (sizeof (struct xecnode)); ! 543: ! 544: if (tmp == NULL) { ! 545: printf ("can't kalloc(xecnode)\n"); ! 546: goto bad; ! 547: } ! 548: ! 549: tmp->xn = * xlist; ! 550: * xlist = tmp; ! 551: tmp->segtype = nscn; ! 552: tmp->xseg.mbase = scnhdr.s_vaddr; ! 553: tmp->xseg.fbase = scnhdr.s_scnptr; ! 554: tmp->xseg.size = scnhdr.s_size; ! 555: } else { ! 556: xhp->segs [nscn].mbase = scnhdr.s_vaddr; ! 557: xhp->segs [nscn].fbase = scnhdr.s_scnptr; ! 558: xhp->segs [nscn].size = scnhdr.s_size; ! 559: } ! 560: } ! 561: ! 562: /* Text and data segments must both be nonempty. */ ! 563: if (! xhp->segs [SISTEXT].size || ! xhp->segs [SIPDATA].size) ! 564: goto bad; ! 565: ! 566: xhp->entry = ahead.entry; ! 567: ! 568: xhp->segs [SISTACK].mbase = ISP_386; /* size 0, fbase 0 */ ! 569: xhp->magic = XMAGIC (I386MAGIC, ahead.magic); ! 570: brelease (bp); ! 571: return ip; ! 572: default: ! 573: bad: ! 574: brelease (bp); ! 575: u.u_error = ENOEXEC; ! 576: idetach (ip); ! 577: return NULL; ! 578: } ! 579: } ! 580: ! 581: static SEG * ! 582: exsread(sp, ip, xsp, shrdSz) ! 583: register SEG *sp; ! 584: INODE *ip; ! 585: struct xecseg *xsp; ! 586: int shrdSz; ! 587: { ! 588: register int sa, so; ! 589: IO io; ! 590: ! 591: sa = xsp->fbase; ! 592: so = xsp->mbase & (NBPC - 1); ! 593: ! 594: io.io_seg = IOPHY; ! 595: io.io_seek = sa; ! 596: io.io.pbase = MAPIO (sp->s_vmem, so); ! 597: io.io_flag = 0; ! 598: ! 599: if (shrdSz) { /* shared l.out? */ ! 600: ! 601: /* Load SHRD. */ ! 602: io.io_ioc = shrdSz; ! 603: sp->s_lrefc ++; ! 604: iread (ip, & io); ! 605: sp->s_lrefc --; ! 606: ! 607: if ((io.io_ioc = xsp->size - shrdSz) != 0) { ! 608: ! 609: /* Advance file and RAM offsets past SHRD. */ ! 610: sa += shrdSz; ! 611: so += shrdSz; ! 612: ! 613: /* Advance RAM offset to next 16-byte boundary. */ ! 614: so = (so + 15) & ~ 15; /* round up */ ! 615: ! 616: /* Load PRVD. */ ! 617: io.io_seg = IOPHY; ! 618: io.io_seek = sa; ! 619: io.io.pbase = MAPIO (sp->s_vmem, so); ! 620: io.io_flag = 0; ! 621: ! 622: sp->s_lrefc ++; ! 623: iread (ip, & io); ! 624: sp->s_lrefc --; ! 625: } ! 626: } else { /* NOT shared l.out */ ! 627: io.io_ioc = xsp->size; ! 628: ! 629: sp->s_lrefc ++; ! 630: iread (ip, & io); ! 631: sp->s_lrefc --; ! 632: } ! 633: ! 634: /* ! 635: * NIGEL: This perturbs me. This check seems to really belong ! 636: * somewhere at the top-level, and/or from testing the return values ! 637: * from the read calls. Why isn't the residual from the read tested? ! 638: */ ! 639: ! 640: if (curr_signal_pending ()) ! 641: u.u_error = EINTR; ! 642: ! 643: if (u.u_error == 0) ! 644: return sp; ! 645: return NULL; ! 646: } ! 647: ! 648: ! 649: struct adata { /* Storage for arg and env data */ ! 650: int np; /* Number of pointers in vector */ ! 651: int nc; /* Number of characters in strings */ ! 652: }; ! 653: ! 654: ! 655: /* ! 656: * Given a pointer to a list of arguments and a pointer to a list of ! 657: * environments, return a stack with the arguments and environments on it. ! 658: */ ! 659: ! 660: SEG * ! 661: exstack(xhp, argp, envp, wdin) ! 662: register struct xechdr *xhp; ! 663: caddr_t argp, envp; ! 664: { ! 665: register SEG *sp; /* Stack segment pointer */ ! 666: struct sdata { /* To keep segment pointers */ ! 667: caddr_t vp; /* Argv[i], envp[i] pointer */ ! 668: caddr_t cp; /* Argv[i][j], envp[i][j] pointer */ ! 669: } stk; ! 670: struct adata arg, env; ! 671: int chrsz, vecsz, stksz, wdmask, wdout, stkoff, stktop; ! 672: int stkenvp; ! 673: register int i; ! 674: ! 675: /* Validate and evaluate size of args and envs */ ! 676: if (! excount (argp, & arg, wdin) || ! excount (envp, & env, wdin)) ! 677: return NULL; ! 678: ! 679: /* Calculate stack size and allocate it */ ! 680: chrsz = __ROUND_UP_TO_MULTIPLE (arg.nc + env.nc, sizeof (int)); ! 681: vecsz = (arg.np + 1 + env.np + 1) * sizeof (long); ! 682: stksz = __ROUND_UP_TO_MULTIPLE (vecsz + chrsz + ISTSIZE, NBPC); ! 683: ! 684: if (stksz > MADSIZE || (sp = salloc (stksz, SFDOWN)) == NULL) { ! 685: u.u_error = E2BIG; ! 686: return NULL; ! 687: } ! 688: ! 689: /* Set up target stack */ ! 690: stktop = xhp->segs [SISTACK].mbase; ! 691: stk.cp = stktop - chrsz; ! 692: stk.vp = stktop - chrsz - vecsz; ! 693: stkoff = MAPIO (sp->s_vmem, stksz - stktop); ! 694: u.u_argc = arg.np; ! 695: u.u_argp = stk.vp; ! 696: wdmask = -1; ! 697: if (wdin == sizeof (short)) ! 698: wdmask = (unsigned short) wdmask; ! 699: ! 700: switch (stktop) { ! 701: ! 702: case ISP_386: ! 703: wdout = sizeof (long); ! 704: xhp->initsp = stk.vp - sizeof (long); ! 705: dmaout (sizeof (long), xhp->initsp + stkoff, & arg.np); ! 706: break; ! 707: ! 708: case ISP_286: ! 709: wdout = sizeof (short); ! 710: xhp->initsp = stk.vp - 3 * sizeof (short); ! 711: stkenvp = stk.vp + (arg.np + 1) * sizeof (short); ! 712: dmaout (sizeof (short), xhp->initsp + stkoff, & arg.np); ! 713: dmaout (sizeof (short), xhp->initsp + sizeof (short) + stkoff, ! 714: & stk.vp); ! 715: dmaout (sizeof (short), xhp->initsp + 2 * sizeof (short) + ! 716: stkoff, & stkenvp); ! 717: break; ! 718: ! 719: default: ! 720: panic("exstack"); ! 721: ! 722: } ! 723: ! 724: /* Arguments */ ! 725: for (i = 0 ; i < arg.np ; i ++, argp += wdin, stk.vp += wdout) { ! 726: dmaout (wdout, stk.vp + stkoff, & stk.cp); ! 727: stk.cp += exarg (stk.cp + stkoff, getupd (argp) & wdmask); ! 728: } ! 729: ! 730: /* skip null word after arguments */ ! 731: stk.vp += wdout; ! 732: ! 733: /* Environments */ ! 734: for (i = 0; i < env.np ; i ++, envp += wdin, stk.vp += wdout) { ! 735: dmaout (wdout, stk.vp + stkoff, & stk.cp); ! 736: stk.cp += exarg (stk.cp + stkoff, getupd (envp) & wdmask); ! 737: } ! 738: ! 739: return sp; ! 740: } ! 741: ! 742: exarg(out, in) ! 743: caddr_t in, out; ! 744: { ! 745: char c; ! 746: caddr_t init_in; ! 747: ! 748: init_in = in; ! 749: do { ! 750: c = getubd (in ++); ! 751: dmaout (sizeof (char), out ++, & c); ! 752: } while (c); ! 753: return in - init_in; ! 754: } ! 755: ! 756: /* ! 757: * Given a pointer to a list of arguments, a pointer to an argument count ! 758: * and a pointer to a byte count, count the #characters/#strings ! 759: * in the arguments ! 760: */ ! 761: excount(usrvp, adp, wdin) ! 762: register caddr_t usrvp; ! 763: struct adata *adp; ! 764: { ! 765: register caddr_t usrcp; ! 766: register int c; ! 767: register unsigned nb; ! 768: register unsigned na; ! 769: int wdmask; ! 770: ! 771: wdmask = -1; ! 772: if (wdin == sizeof (short)) ! 773: wdmask = (unsigned short) wdmask; ! 774: na = nb = 0; ! 775: if (usrvp != NULL) { ! 776: for (;;) { ! 777: usrcp = getupd (usrvp) & wdmask; ! 778: usrvp += wdin; ! 779: if (u.u_error) ! 780: return 0; ! 781: if (usrcp == NULL) ! 782: break; ! 783: na ++; ! 784: for (;;) { ! 785: c = getubd (usrcp ++); ! 786: if (u.u_error) ! 787: return 0; ! 788: nb ++; ! 789: if (c == '\0') ! 790: break; ! 791: } ! 792: } ! 793: } ! 794: adp->np = na; ! 795: adp->nc = nb; ! 796: return 1; ! 797: } ! 798: ! 799: /* ! 800: * Round up a size to a paragraph ! 801: * (mod 16) boundry. ! 802: * This is really mod 512 to make swapping work ! 803: */ ! 804: off_t ! 805: exround(s) ! 806: off_t s; ! 807: { ! 808: return (s + 15) & ~ 0x0F; ! 809: } ! 810: ! 811: pload(np) ! 812: char * np; ! 813: { ! 814: return -1; ! 815: ! 816: } ! 817: /* ! 818: * Set up the first process, a small program which will exec ! 819: * the init program. ! 820: */ ! 821: extern char aicodep[]; ! 822: ! 823: eveinit() ! 824: { ! 825: SEG *sp; ! 826: register PROC *pp; ! 827: SELF = pp = eprocp; ! 828: /* static struct xechdr xecinit[NUSEG+1] = { {0},{0},{0},{ISP_386}}; */ ! 829: ! 830: /* ! 831: * Allocate, record, initialize code segment, make it executable. ! 832: */ ! 833: if ((sp = salloc (__ROUND_UP_TO_MULTIPLE (icodes, NBPC), 0)) == NULL) ! 834: panic ("eveinit(code)"); ! 835: pp->p_segp [SIPDATA] = sp; ! 836: ! 837: /* ! 838: * Start process. ! 839: */ ! 840: u.u_argp = 0; ! 841: if (sproto (0) == 0) ! 842: panic ("eveinit()"); ! 843: segload (); ! 844: setspace (SEG_386_UD | R_USR); ! 845: kucopy (aicodep, 0, icodes); ! 846: } ! 847: ! 848: /* ! 849: * Given a major number, undo the previous function. ! 850: */ ! 851: puload(m) ! 852: int m; ! 853: { ! 854: register CON *cp; ! 855: register DRV *dp; ! 856: ! 857: dp = & drvl [m]; ! 858: ! 859: if (m >= drvn || (cp = dp->d_conp) == NULL) { ! 860: u.u_error = ENXIO; ! 861: goto ret; ! 862: } ! 863: (* cp->c_uload) (); ! 864: if (! u.u_error) ! 865: dp->d_conp = NULL; ! 866: ret: ! 867: return 0; ! 868: } ! 869:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.