![[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 / d / PS2_KERNEL / i286|
Return to exec.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / i286 |
1.1 ! root 1: /* $Header: /kernel/kersrc/i286/RCS/exec.c,v 1.1 92/07/17 15:21:27 bin Exp Locker: bin $ */ ! 2: /* (lgl- ! 3: * The information contained herein is a trade secret of Mark Williams ! 4: * Company, and is confidential information. It is provided under a ! 5: * license agreement, and may be copied or disclosed only under the ! 6: * terms of that agreement. Any reproduction or disclosure of this ! 7: * material without the express written authorization of Mark Williams ! 8: * Company or persuant to the license agreement is unlawful. ! 9: * ! 10: * COHERENT Version 2.3.37 ! 11: * Copyright (c) 1982, 1983, 1984. ! 12: * An unpublished work by Mark Williams Company, Chicago. ! 13: * All rights reserved. ! 14: -lgl) */ ! 15: /* ! 16: * This file contains a special version ! 17: * of "sys exec" for the i8086. This version has ! 18: * no driver load code in it (save space) and has ! 19: * special load code so that the text of a shared ! 20: * and separated image can be shared. ! 21: * Loadable kernel processes are partially supported: ! 22: * the process text and data must be ld'ed with the system ! 23: * and the l.out executed must have no loadable or allocateable ! 24: * segments. ! 25: * ! 26: * $Log: exec.c,v $ ! 27: * Revision 1.1 92/07/17 15:21:27 bin ! 28: * Initial revision ! 29: * ! 30: * Revision 1.1 88/03/24 17:39:26 src ! 31: * Initial revision ! 32: * ! 33: * 88/01/21 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 34: * Segments are now de-associated from processes before freeing the segment. ! 35: * ! 36: * 87/12/03 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 37: * ld_start() now reverts to kernel mode [depth=0] from user mode [depth=1]. ! 38: * ! 39: * 87/11/25 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 40: * vaddr_t bp->b_vaddr --> faddr_t bp->b_faddr. ! 41: * ! 42: * 87/11/14 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 43: * Init code+data now split into icodep/icodes and idatap/idatas. ! 44: * ! 45: * 87/11/05 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 46: * New seg struct now used to allow extended addressing. ! 47: * ! 48: * 87/10/09 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 49: * pload() now handles new format [separate code] loadable device drivers. ! 50: * ! 51: * 87/10/08 Allan Cornish /usr/src/sys/i8086/src/exec.c ! 52: * Exsread() initializes the (IO).io_flag field to 0. ! 53: */ ! 54: #include <sys/coherent.h> ! 55: #include <acct.h> ! 56: #include <sys/buf.h> ! 57: #include <canon.h> ! 58: #include <sys/con.h> ! 59: #include <errno.h> ! 60: #include <sys/filsys.h> ! 61: #include <sys/ino.h> ! 62: #include <sys/inode.h> ! 63: #include <l.out.h> ! 64: #include <sys/proc.h> ! 65: #include <sys/sched.h> ! 66: #include <sys/seg.h> ! 67: #include <signal.h> ! 68: #include <sys/i8086.h> ! 69: ! 70: /* ! 71: * Sizes. ! 72: */ ! 73: #define sh ((fsize_t)sizeof(struct ldheader)) ! 74: #define si lssize[L_SHRI] ! 75: #define pi lssize[L_PRVI] ! 76: #define bi lssize[L_BSSI] ! 77: #define sd lssize[L_SHRD] ! 78: #define pd lssize[L_PRVD] ! 79: #define bd lssize[L_BSSD] ! 80: ! 81: /* ! 82: * Segments. ! 83: */ ! 84: #define upsp pp->p_segp[SIUSERP] ! 85: #define sssp pp->p_segp[SISTACK] ! 86: #define sisp pp->p_segp[SISTEXT] ! 87: #define pisp pp->p_segp[SIPTEXT] ! 88: #define pdsp pp->p_segp[SIPDATA] ! 89: ! 90: /* ! 91: * Loadable driver initiation point. ! 92: */ ! 93: static ! 94: ld_start() ! 95: { ! 96: register SEG * sp; ! 97: register int ret; ! 98: ! 99: /* ! 100: * Kernel processes start by default at user level. ! 101: * Revert to kernel level. ! 102: */ ! 103: if ( depth == 1 ) ! 104: depth--; ! 105: ! 106: /* ! 107: * Initialize memory references. ! 108: */ ! 109: u.u_btime = timer.t_time; ! 110: sproto(); ! 111: segload(); ! 112: ! 113: ! 114: /* ! 115: * Invoke the driver if it has a shared or private code segment. ! 116: */ ! 117: ret = 100; ! 118: if ( (sp = SELF->p_segp[SISTEXT]) || (sp = SELF->p_segp[SIPTEXT]) ) { ! 119: ret = ld_xcall( sp->s_faddr ); ! 120: } ! 121: ! 122: uexit( ret ); ! 123: } ! 124: ! 125: /* ! 126: * Set up the first process, a small programme which will exec ! 127: * the init programme. ! 128: */ ! 129: eveinit(sp) ! 130: SEG *sp; ! 131: { ! 132: register PROC *pp; ! 133: SELF = pp = eprocp; ! 134: ! 135: /* ! 136: * Record user area. ! 137: */ ! 138: pp->p_segp[SIUSERP] = sp; ! 139: ! 140: /* ! 141: * Allocate, record, initialize code segment, make it executable. ! 142: */ ! 143: if ((sp=salloc((fsize_t)icodes, 0)) == NULL) ! 144: panic("eveinit(code)"); ! 145: pp->p_segp[SIPTEXT] = sp; ! 146: kfcopy( icodep, sp->s_faddr, icodes ); ! 147: sp->s_flags |= SFTEXT; ! 148: vremap(sp); ! 149: ! 150: /* ! 151: * Allocate, record, and initialize data segment. ! 152: */ ! 153: if ((sp=salloc((fsize_t)idatas, 0)) == NULL) ! 154: panic("eveinit(data)"); ! 155: pp->p_segp[SIPDATA] = sp; ! 156: kfcopy( idatap, sp->s_faddr, idatas ); ! 157: ! 158: /* ! 159: * Allocate and record stack segment. ! 160: */ ! 161: if ((sp=salloc((fsize_t)UPASIZE, SFDOWN)) == NULL) ! 162: panic("eveinit()"); ! 163: pp->p_segp[SISTACK] = sp; ! 164: ! 165: /* ! 166: * Start process. ! 167: */ ! 168: u.u_argp = 0; ! 169: if (sproto() == 0) ! 170: panic("eveinit()"); ! 171: segload(); ! 172: } ! 173: ! 174: /* ! 175: * Load a driver which has already been linked into the system image. ! 176: */ ! 177: pload( np ) ! 178: char * np; ! 179: { ! 180: register INODE * ip; ! 181: register PROC * cpp; ! 182: struct seg * sp; ! 183: fsize_t lssize[NUSEG]; /* Segment sizes */ ! 184: int lflag; /* l_flags from l.out */ ! 185: vaddr_t pc; /* l_entry from l.out */ ! 186: int r; /* Flag for "exload" */ ! 187: int s; ! 188: extern char end[]; ! 189: ! 190: ! 191: if (super() == 0) { ! 192: return( -1 ); ! 193: } ! 194: ! 195: /* ! 196: * Coalesce memory BEFORE loading driver, since it can't be moved. ! 197: */ ! 198: krunch(10000); ! 199: ! 200: if ((ip=exlopen(np, lssize, &lflag, &pc)) == NULL) { ! 201: return( -1 ); ! 202: } ! 203: ! 204: /* ! 205: * New format loadable drivers must have separate code/data. ! 206: * It must have executable code, but no initialized data. ! 207: * Uninitialized data must match the kernel data size. ! 208: */ ! 209: if ( ((lflag & (LF_KER|LF_SHR|LF_SEP)) != (LF_SEP|LF_KER)) ! 210: || (si==0) || (sd!=0) || (pd!=0) || (bd != (int)end) ) { ! 211: u.u_error = EBADFMT; ! 212: idetach(ip); ! 213: return( -1 ); ! 214: } ! 215: ! 216: /* ! 217: * Allocate and initialize driver code segment. ! 218: * NOTE: Must be system segment to prevent relocation. ! 219: */ ! 220: sp = ssalloc(&r, ip, SFTEXT|SFHIGH|SFNSWP|SFSYST, si+pi+bi, sh, si+pi); ! 221: ! 222: /* ! 223: * Release driver object file. ! 224: */ ! 225: idetach(ip); ! 226: ! 227: if ( r < 0 ) { ! 228: u.u_error = ENOMEM; ! 229: return( -1 ); ! 230: } ! 231: ! 232: /* ! 233: * Spawn kernel process to service driver. ! 234: */ ! 235: if ((cpp = process(ld_start)) == NULL ) { ! 236: u.u_error = ENOMEM; ! 237: sfree(sp); ! 238: return( -1 ); ! 239: } ! 240: ! 241: /* ! 242: * Record the basename of the loaded driver. ! 243: */ ! 244: kscopy( u.u_direct.d_name, cpp->p_segp[SIUSERP], ! 245: offset(uproc,u_comm[0]), sizeof(u.u_comm) ); ! 246: ! 247: /* ! 248: * Record the driver code segment in the process's private code. ! 249: */ ! 250: cpp->p_segp[SIPTEXT] = sp; ! 251: cpp->p_cval = CVCHILD; ! 252: cpp->p_sval = SVCHILD; ! 253: cpp->p_rval = RVCHILD; ! 254: cpp->p_ppid = 1; ! 255: ! 256: /* ! 257: * Make the process executable. ! 258: */ ! 259: s = sphi(); ! 260: setrun( cpp ); ! 261: spl( s ); ! 262: ! 263: /* ! 264: * Return driver process id. ! 265: */ ! 266: return( cpp->p_pid ); ! 267: } ! 268: ! 269: /* ! 270: * Given a major number, undo the previous function. ! 271: */ ! 272: puload(m) ! 273: int m; ! 274: { ! 275: register CON *cp; ! 276: register DRV *dp; ! 277: ! 278: dp = &drvl[m]; ! 279: lock(dp->d_gate); ! 280: if (m>=drvn || (cp=dp->d_conp)==NULL) { ! 281: u.u_error = ENXIO; ! 282: goto ret; ! 283: } ! 284: (*cp->c_uload)(); ! 285: if ( ! u.u_error) ! 286: dp->d_conp = NULL; ! 287: ret: ! 288: unlock(dp->d_gate); ! 289: return (0); ! 290: } ! 291: ! 292: /* ! 293: * Pass control to an image in a file. ! 294: * Make sure the format is acceptable. Release ! 295: * the old segments. Read in the new ones. Some special ! 296: * care is taken so that shared and (more important) shared ! 297: * and separated images can be run on the 8086. ! 298: */ ! 299: pexece(np, argp, envp) ! 300: char *np; ! 301: char *argp[]; ! 302: char *envp[]; ! 303: { ! 304: register INODE *ip; /* Load file INODE */ ! 305: register PROC *pp; /* A cheap copy of SELF */ ! 306: register SEG *ssp; /* New stack segment */ ! 307: register SEG *segp; ! 308: register fsize_t ss; /* Segment size temp. */ ! 309: register int i; /* For looping over segments */ ! 310: int r; /* Flag for "exload" */ ! 311: int lflag; /* l_flags from l.out */ ! 312: vaddr_t pc; /* l_entry from l.out */ ! 313: vaddr_t sp; /* Initial stack pointer */ ! 314: fsize_t lssize[NUSEG]; /* Segment sizes */ ! 315: fsize_t codsize; /* Total if CS segment */ ! 316: fsize_t datsize; /* Total of DS segment */ ! 317: extern fsize_t exround(); /* Paragraph rounder */ ! 318: ! 319: pp = SELF; ! 320: if ((ip=exlopen(np, lssize, &lflag, &pc)) == NULL) { ! 321: return; ! 322: } ! 323: ! 324: if ( (lflag & LF_SEP) == 0 ) { ! 325: u.u_error = EBADFMT; ! 326: idetach(ip); ! 327: return; ! 328: } ! 329: ! 330: /* ! 331: * Kernel processes are now supported through the sload() system call. ! 332: * 87/10/09 Allan Cornish. ! 333: */ ! 334: if ((lflag&LF_KER) != 0) { ! 335: u.u_error = EBADFMT; ! 336: idetach(ip); ! 337: return; ! 338: } ! 339: ! 340: /* ! 341: * If a shared and separated image ! 342: * has stuff in segments that makes it impossible ! 343: * to share, give an error immediately so that we don't ! 344: * lose the parent. ! 345: */ ! 346: lflag &= LF_SHR|LF_SEP; ! 347: ! 348: if (lflag==(LF_SHR|LF_SEP) && (pi!=0 || bi!=0)) { ! 349: u.u_error = EBADFMT; ! 350: idetach(ip); ! 351: return; ! 352: } ! 353: ! 354: if ((ssp=exstack(&sp, argp, envp)) == NULL) { ! 355: idetach(ip); ! 356: return; ! 357: } ! 358: ! 359: switch (lflag) { ! 360: case LF_SEP: ! 361: codsize = si+pi+bi; ! 362: datsize = ssp->s_size+sd+pd+bd; ! 363: break; ! 364: case LF_SHR|LF_SEP: ! 365: codsize = si; ! 366: datsize = ssp->s_size+exround(sd)+pd+bd; ! 367: break; ! 368: } ! 369: codsize = (codsize+(BSIZE-1)) & ~(BSIZE-1); ! 370: datsize = (datsize+(BSIZE-1)) & ~(BSIZE-1); ! 371: if ( (codsize >= MAXU) || (datsize >= MAXU) ) { ! 372: u.u_error = E2BIG; ! 373: idetach(ip); ! 374: return; ! 375: } ! 376: ! 377: /* ! 378: * At this point the file has been ! 379: * validated as an object module, and the ! 380: * argument list has been built. Release all of ! 381: * the original segments. At this point we have ! 382: * committed to the new image. A "sys exec" that ! 383: * gets an I/O error is doomed. ! 384: * NOTE: User-area segment is NOT released. ! 385: * Segment pointer in proc is erased BEFORE invoking sfree(). ! 386: */ ! 387: for ( i = 1; i < NUSEG; ++i ) { ! 388: if ((segp = pp->p_segp[i]) != NULL) { ! 389: pp->p_segp[i] = NULL; ! 390: sfree(segp); ! 391: } ! 392: } ! 393: ! 394: /* ! 395: * Read in the loadable segments. ! 396: */ ! 397: sssp = ssp; ! 398: switch (lflag) { ! 399: case 0: ! 400: ss = si+pi+sd+pd; ! 401: pdsp = ssalloc(&r, ip, 0, ss+bi+bd, sh, ss); ! 402: if (r < 0) ! 403: goto out; ! 404: break; ! 405: ! 406: case LF_SHR: ! 407: ss = exround(si+sd); ! 408: pdsp = ssalloc(&r, ip, 0, ss+pi+pd+bi+bd, sh, si); ! 409: if (r < 0) ! 410: goto out; ! 411: if (exsread(pdsp, ip, sd, sh+si+pi, si) == NULL) ! 412: goto out; ! 413: if (exsread(pdsp, ip, pi, sh+si, ss) == NULL) ! 414: goto out; ! 415: if (exsread(pdsp, ip, pd, sh+si+pi+sd, ss+pi) == NULL) ! 416: goto out; ! 417: break; ! 418: ! 419: case LF_SEP: ! 420: pisp = ssalloc(&r, ip, SFTEXT, si+pi+bi, sh, si+pi); ! 421: if (r < 0) ! 422: goto out; ! 423: pdsp = ssalloc(&r, ip, 0, sd+pd+bd, sh+si+pi, sd+pd); ! 424: if (r < 0) ! 425: goto out; ! 426: break; ! 427: ! 428: case LF_SHR|LF_SEP: ! 429: /* pi=0, bi=0 */ ! 430: sisp = ssalloc(&r, ip, SFSHRX|SFTEXT, si, sh, si); ! 431: if (r < 0) ! 432: goto out; ! 433: ss = exround(sd); ! 434: pdsp = ssalloc(&r, ip, 0, ss+pd+bd, sh+si, sd); ! 435: if (r<0 || exsread(pdsp, ip, pd, sh+si+sd, ss) == NULL) ! 436: goto out; ! 437: } ! 438: if (sproto() == 0) ! 439: goto out; ! 440: #if 0 ! 441: if ( (datsize != pdsp->s_size) || ! 442: ( (lflag==LF_SEP) && (codsize != pisp->s_size) ) || ! 443: ( (lflag==(LF_SEP|LF_SHR)) && (codsize != sisp->s_size) ) ) { ! 444: printf("\nExec ERROR: codsize: 0x%X datsize: 0x%X\n", ! 445: codsize, datsize); ! 446: printf( ! 447: "pdsp->s_size: 0x%X pisp->s_size: 0x%X sisp->s_size: 0x%X\n", ! 448: pdsp->s_size, pisp->s_size, sisp->s_size); ! 449: } ! 450: #endif ! 451: /* ! 452: * The new image is read in ! 453: * and mapped. Perform the final grunge ! 454: * (set-uid stuff, accounting, loading up ! 455: * registers, etc). ! 456: */ ! 457: u.u_flag &= ~AFORK; ! 458: kkcopy(u.u_direct.d_name, u.u_comm, sizeof(u.u_comm)); ! 459: if (iaccess(ip, IPR) == 0) { /* Can't read ? no dump or trace */ ! 460: pp->p_flags |= PFNDMP; ! 461: pp->p_flags &= ~PFTRAC; ! 462: } ! 463: if (iaccess(ip, IPW) == 0) /* Can't write ? no trace */ ! 464: pp->p_flags &= ~PFTRAC; ! 465: if ((ip->i_mode&ISUID) != 0) { /* Set user id ? no trace */ ! 466: pp->p_uid = u.u_uid = ip->i_uid; ! 467: pp->p_flags &= ~PFTRAC; ! 468: } ! 469: if ((ip->i_mode&ISGID) != 0) { /* Set group id ? no trace */ ! 470: u.u_gid = ip->i_gid; ! 471: pp->p_flags &= ~PFTRAC; ! 472: } ! 473: for (i=0; i<NSIG; ++i) ! 474: if (u.u_sfunc[i] != SIG_IGN) ! 475: u.u_sfunc[i] = SIG_DFL; ! 476: if ((pp->p_flags&PFTRAC) != 0) /* Being traced */ ! 477: sendsig(SIGTRAP, pp); ! 478: idetach(ip); ! 479: msetusr(pc, sp); ! 480: segload(); ! 481: return (0); ! 482: ! 483: /* ! 484: * We did not make it. ! 485: * Release the INODE for the load ! 486: * file, and return through the "sys exit" ! 487: * code with a "SIGSYS", or with the signal actually received ! 488: * if we are aborting due to interrupted exec. ! 489: */ ! 490: out: ! 491: idetach(ip); ! 492: if (u.u_error == EINTR) ! 493: pexit(nondsig()); ! 494: pexit(SIGSYS); ! 495: } ! 496: ! 497: /* ! 498: * Open an l.out, make sure it is an l.out and executable and return the ! 499: * appropriate information. ! 500: */ ! 501: INODE * ! 502: exlopen(np, ssizep, flagp, pcp) ! 503: char *np; ! 504: fsize_t *ssizep; ! 505: int *flagp; ! 506: vaddr_t *pcp; ! 507: { ! 508: register INODE *ip; ! 509: register struct ldheader *ldp; ! 510: register int n; ! 511: register BUF *bp; ! 512: int m; ! 513: ! 514: /* ! 515: * Make sure the file is really an executable l.out and read the ! 516: * header in. ! 517: */ ! 518: if (ftoi(np, 'r') != 0) ! 519: return (NULL); ! 520: ip = u.u_cdiri; ! 521: if (iaccess(ip, IPE) == 0) { ! 522: idetach(ip); ! 523: return (NULL); ! 524: } ! 525: if ((ip->i_mode&(IPE|IPE<<3|IPE<<6))==0 || (ip->i_mode&IFMT)!=IFREG) { ! 526: u.u_error = EACCES; ! 527: idetach(ip); ! 528: return (NULL); ! 529: } ! 530: if ((bp=vread(ip, (daddr_t)0)) == NULL) { ! 531: u.u_error = EBADFMT; ! 532: idetach(ip); ! 533: return (NULL); ! 534: } ! 535: ! 536: /* ! 537: * Copy everything we need from the l.out header and check magic ! 538: * number and machine type. ! 539: */ ! 540: ldp = FP_OFF(bp->b_faddr); ! 541: m = ldp->l_magic; ! 542: canint(m); ! 543: if (m != L_MAGIC) { ! 544: u.u_error = ENOEXEC; ! 545: brelease(bp); ! 546: idetach(ip); ! 547: return (NULL); ! 548: } ! 549: m = ldp->l_machine; ! 550: canint(m); ! 551: if (m != mactype) { ! 552: u.u_error = EBADFMT; ! 553: brelease(bp); ! 554: idetach(ip); ! 555: return (NULL); ! 556: } ! 557: kkcopy(ldp->l_ssize, ssizep, NXSEG*sizeof(fsize_t)); ! 558: for (n=0; n<NXSEG; n++) ! 559: cansize(ssizep[n]); ! 560: *flagp = ldp->l_flag; ! 561: canint(*flagp); ! 562: *pcp = ldp->l_entry; ! 563: canvaddr(*pcp); ! 564: brelease(bp); ! 565: return (ip); ! 566: } ! 567: ! 568: /* ! 569: * Given a segment `sp', read `ss' bytes from the inode `ip' starting ! 570: * at seek address `sa' into offset `so' in the segment. ! 571: */ ! 572: SEG * ! 573: exsread(sp, ip, ss, sa, so) ! 574: register SEG *sp; ! 575: INODE *ip; ! 576: fsize_t ss; ! 577: fsize_t sa; ! 578: fsize_t so; ! 579: { ! 580: while (ss > 0) { ! 581: u.u_io.io_seg = IOPHY; ! 582: u.u_io.io_seek = sa; ! 583: u.u_io.io_phys = sp->s_paddr + so; ! 584: u.u_io.io_flag = 0; ! 585: if (ss >= 4096) { ! 586: u.u_io.io_ioc = 4096; ! 587: ss -= 4096; ! 588: } else { ! 589: u.u_io.io_ioc = ss; ! 590: ss = 0; ! 591: } ! 592: sp->s_lrefc++; ! 593: iread(ip, &u.u_io); ! 594: sp->s_lrefc--; ! 595: if (nondsig()) { ! 596: u.u_error = EINTR; ! 597: break; ! 598: } ! 599: sa += 4096; ! 600: so += 4096; ! 601: } ! 602: if (u.u_error == 0) ! 603: return (sp); ! 604: return (NULL); ! 605: } ! 606: ! 607: /* ! 608: * Given a pointer to a list of arguments and a pointer to a list of ! 609: * environments, return a stack with the arguments and environments on it. ! 610: */ ! 611: SEG * ! 612: exstack(iusp, argp, envp) ! 613: char **iusp; /* Back patch sp value */ ! 614: char *argp[]; /* Arguments for new process */ ! 615: char *envp[]; /* Environments for new process */ ! 616: { ! 617: SEG *sp; /* Stack segment pointer */ ! 618: struct adata { /* Storage for arg and env data */ ! 619: char **up; /* User vector pointer */ ! 620: int np; /* Number of pointers in vector */ ! 621: int nc; /* Number of characters in strings */ ! 622: } arg, env; ! 623: struct sdata { /* To keep segment pointers */ ! 624: vaddr_t base; /* Top of segment virtual */ ! 625: vaddr_t ap; /* Argc, argv, envp pointer */ ! 626: vaddr_t vp; /* Argv[i], envp[i] pointer */ ! 627: vaddr_t cp; /* Argv[i][j], envp[i][j] pointer */ ! 628: } aux, stk; ! 629: aold_t aold; /* Auxiliary map storage */ ! 630: register char **usrvp; /* Vector pointer into user seg */ ! 631: register char *usrcp; /* Character pointer into user seg */ ! 632: register int c; /* Character fetched from user */ ! 633: register int chrsz; /* Size of strings */ ! 634: register struct adata *adp; /* Arg and env scanner */ ! 635: register int vecsz; /* Size of vectors */ ! 636: register int stksz; /* Size of stack argument region */ ! 637: ! 638: /* Validate and evaluate size of args and envs */ ! 639: arg.up = argp; ! 640: env.up = envp; ! 641: chrsz = 0; ! 642: vecsz = 0; ! 643: for (adp = &arg; ; adp = &env) { ! 644: adp->np = 0; ! 645: adp->nc = 0; ! 646: if (excount(adp->up, &adp->np, &adp->nc) == 0) ! 647: return (NULL); ! 648: chrsz += adp->nc * sizeof(char); ! 649: vecsz += adp->np * sizeof(char *); ! 650: if (adp == &env) ! 651: break; ! 652: } ! 653: ! 654: /* Calculate stack size and allocate it */ ! 655: chrsz = roundu(chrsz, sizeof(int)); ! 656: stksz = sizeof(int) /* argc */ ! 657: + sizeof(char **) /* argv */ ! 658: + sizeof(char **) /* envp */ ! 659: + vecsz /* argv[i] and envp[i] */ ! 660: + chrsz /* *argv[i] and *envp[i] */ ! 661: + sizeof(int) /* Mystery zero word */ ! 662: + sizeof(char *) /* Splimit for z8000 */ ! 663: + sizeof(int); /* errno */ ! 664: stksz += ISTSIZE; ! 665: if (stksz > MADSIZE) { ! 666: u.u_error = E2BIG; ! 667: return (NULL); ! 668: } ! 669: if ((sp=salloc((fsize_t)stksz, SFDOWN)) == NULL) ! 670: return (NULL); ! 671: stksz -= ISTSIZE; ! 672: ! 673: /* ! 674: * Initialize segment data. ! 675: */ ! 676: asave(aold); ! 677: ! 678: abase(FP_SEL(sp->s_faddr)); ! 679: aux.base = sp->s_size; ! 680: aux.ap = aux.base - stksz; ! 681: aux.vp = aux.ap + sizeof(int) + 2*sizeof(char **); ! 682: aux.cp = aux.vp + vecsz; ! 683: ! 684: stk.base = ISTVIRT; ! 685: stk.ap = stk.base - stksz; ! 686: stk.vp = stk.ap + sizeof(int) + 2*sizeof(char **); ! 687: stk.cp = stk.vp + vecsz; ! 688: ! 689: /* ! 690: * Write argc. ! 691: */ ! 692: aputi((int *)aux.ap, arg.np-1); ! 693: aux.ap += sizeof(int); ! 694: ! 695: /* ! 696: * Arguments and environments. ! 697: */ ! 698: for (adp = &arg; ; adp = &env) { ! 699: ! 700: /* Write argv or envp */ ! 701: aputp((char ***)aux.ap, (char **)stk.vp); ! 702: aux.ap += sizeof(char **); ! 703: if ((usrvp = adp->up) != NULL) { ! 704: ! 705: /* Write argv[i] or envp[i] */ ! 706: while ((usrcp = getupd(usrvp++)) != NULL) { ! 707: aputp((char **)aux.vp, (char *)stk.cp); ! 708: aux.vp += sizeof(char *); ! 709: stk.vp += sizeof(char *); ! 710: ! 711: /* Write argv[i][j] or envp[i][j] */ ! 712: do { ! 713: c = getubd(usrcp++); ! 714: aputc((char *)aux.cp, c); ! 715: aux.cp += sizeof(char); ! 716: stk.cp += sizeof(char); ! 717: } while (c != '\0'); ! 718: } ! 719: } ! 720: ! 721: /* Write argv[argc] or envp[envc] */ ! 722: aputp((char **)aux.vp, NULL); ! 723: aux.vp += sizeof(char *); ! 724: stk.vp += sizeof(char *); ! 725: if (adp == &env) ! 726: break; ! 727: } ! 728: ! 729: /* ! 730: * Clear out the slop. ! 731: */ ! 732: aux.base -= sizeof(int); ! 733: aputi((int *) aux.base, 0); /* errno */ ! 734: aux.base -= sizeof(char *); ! 735: aputp((char **) aux.base, (char *)stk.base - sp->s_size + SOVSIZE); ! 736: aux.base -= sizeof(int); ! 737: aputi((int *) aux.base, 0); /* mystery word */ ! 738: ! 739: arest(aold); ! 740: ! 741: /* ! 742: * Patch some values and return. ! 743: */ ! 744: *iusp = stk.ap; /* Patch initial usp */ ! 745: u.u_argc = arg.np-1; ! 746: u.u_argp = stk.vp; /* Points after NULL of envs */ ! 747: return (sp); ! 748: } ! 749: ! 750: /* ! 751: * Given a pointer to a list of arguments, a pointer to an argument count ! 752: * and a pointer to a byte count, update incrementally the argument count ! 753: * and the byte count. ! 754: */ ! 755: excount(usrvp, nap, nbp) ! 756: register char **usrvp; ! 757: int *nap; ! 758: int *nbp; ! 759: { ! 760: register char *usrcp; ! 761: register int c; ! 762: register unsigned nb; ! 763: register unsigned na; ! 764: ! 765: na = 1; ! 766: nb = 0; ! 767: if (usrvp != NULL) { ! 768: for (;;) { ! 769: usrcp = getupd(usrvp++); ! 770: if (u.u_error) ! 771: return (0); ! 772: if (usrcp == NULL) ! 773: break; ! 774: na++; ! 775: for (;;) { ! 776: c = getubd(usrcp++); ! 777: if (u.u_error) ! 778: return (0); ! 779: nb++; ! 780: if (c == '\0') ! 781: break; ! 782: } ! 783: } ! 784: } ! 785: *nap += na; ! 786: *nbp += nb; ! 787: return (1); ! 788: } ! 789: ! 790: /* ! 791: * Round up a size to a paragraph ! 792: * (mod 16) boundry. ! 793: * This is really mod 512 to make swapping work ! 794: */ ! 795: fsize_t ! 796: exround(s) ! 797: fsize_t s; ! 798: { ! 799: return ((s+15)&~0x0F); ! 800: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.