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