![[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 / coh.386|
Return to exec.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386 |
1.1 root 1: /* (lgl-
2: * The information contained herein is a trade secret of Mark Williams
3: * Company, and is confidential information. It is provided under a
4: * license agreement, and may be copied or disclosed only under the
5: * terms of that agreement. Any reproduction or disclosure of this
6: * material without the express written authorization of Mark Williams
7: * Company or persuant to the license agreement is unlawful.
8: *
9: * COHERENT Version 2.3.37
10: * Copyright (c) 1982, 1983, 1984.
11: * An unpublished work by Mark Williams Company, Chicago.
12: * All rights reserved.
13: *
14: * Intel 386 port and extensions (16/32 bit compatibility)
15: * Copyright (c) Ciaran O'Donnell, Bievres (FRANCE), 1991
16: *
17: * $Log: exec.c,v $
18: * Revision 1.10 92/07/16 16:33:31 hal
19: * Kernel #58
20: *
21: * Revision 1.9 92/06/11 21:39:19 root
22: * Add close on exec.
23: *
24: * Revision 1.8 92/06/10 12:51:09 hal
25: * Do click roundup on call to salloc for eveinit.
26: * Assorted cosmetic changes.
27: *
28: * Revision 1.6 92/02/11 10:09:57 hal
29: * Execute shared l.out's now
30: *
31: * Revision 1.5 92/02/10 18:11:27 hal
32: * Ignore SHR bit in l.out's for now.
33: *
34: * Revision 1.4 92/01/23 18:15:28 hal
35: * Add "double sfree" fix from Ciaran.
36: *
37: * Revision 1.3 92/01/15 11:11:26 hal
38: * Remove exlock temporary fix.
39: *
40: * Revision 1.2 92/01/06 11:58:57 hal
41: * Compile with cc.mwc.
42: *
43: *
44: -lgl) */
45: #include <sys/coherent.h>
46: #include <acct.h>
47: #include <sys/buf.h>
48: #include <canon.h>
49: #include <sys/con.h>
50: #include <errno.h>
51: #include <fcntl.h>
52: #include <sys/filsys.h>
53: #include <sys/ino.h>
54: #include <sys/inode.h>
55: #include <a.out.h>
56: #include <l.out.h>
57: #include <sys/proc.h>
58: #include <sys/sched.h>
59: #include <sys/seg.h>
60: #include <signal.h>
61: #include <sys/reg.h>
62: #include <sys/stat.h>
63: #include <sys/fd.h>
64:
65: /*
66: * Pass control to an image in a file.
67: * Make sure the format is acceptable. Release
68: * the old segments. Read in the new ones. Some special
69: * care is taken so that shared and (more important) shared
70: * and separated images can be run on the 8086.
71: */
72: pexece(np, argp, envp)
73: char *np;
74: char *argp[];
75: char *envp[];
76: {
77: struct xechdr head;
78: register INODE *ip; /* Load file INODE */
79: register PROC *pp; /* A cheap copy of SELF */
80: register SEG *segp;
81: SEG *ssegp;
82: register int i; /* For looping over segments*/
83: register BUF *bp;
84: int roundup;
85: int shrdsize;
86:
87: pp = SELF;
88: kclear(&head, sizeof(head));
89: if ((ip=exlopen(&head, np, &shrdsize)) == NULL)
90: goto done;
91: roundup = (shrdsize) & 0xf;
92: ssegp = exstack(&head,argp, envp, wdsize());
93:
94: if (!ssegp) {
95: idetach(ip);
96: goto done;
97: }
98:
99: /*
100: * At this point the file has been
101: * validated as an object module, and the
102: * argument list has been built. Release all of
103: * the original segments. At this point we have
104: * committed to the new image. A "sys exec" that
105: * gets an I/O error is doomed.
106: * NOTE: User-area segment is NOT released.
107: * Segment pointer in proc is erased BEFORE invoking sfree().
108: */
109:
110: for ( i = 1; i < NUSEG; ++i ) {
111: if ((segp = pp->p_segp[i]) != NULL) {
112: pp->p_segp[i] = NULL;
113: sfree(segp);
114: }
115: }
116: pp->p_segp[SISTACK] = ssegp;
117:
118: /*
119: * Read in the loadable segments.
120: */
121: switch (head.magic) {
122: case XMAGIC( I286MAGIC,I_MAGIC ):
123: u.u_regl[CS] = SEG_286_UII | R_USR;
124: u.u_regl[DS] = SEG_286_UD | R_USR;
125: segp = pp->p_segp[SISTEXT] = ssalloc(ip,SFTEXT,
126: head.segs[SISTEXT].size);
127: if (!exsread(segp, ip, &head.segs[SISTEXT], 0)) {
128: goto out;
129: }
130: segp = ssalloc(ip,0,roundup+
131: head.segs[SIPDATA].size+head.segs[SIBSS].size);
132: pp->p_segp[SIPDATA] = segp;
133: if (!exsread(segp,ip,&head.segs[SIPDATA],shrdsize)) {
134: goto out;
135: }
136: head.segs[SIPDATA].size += roundup;
137: break;
138: case XMAGIC( I386MAGIC,Z_MAGIC ):
139: u.u_regl[CS] = SEG_386_UI | R_USR;
140: u.u_regl[DS] = SEG_386_UD | R_USR;
141: segp = pp->p_segp[SISTEXT] = ssalloc(ip,SFTEXT|SFSHRX,
142: head.segs[SISTEXT].size);
143: if (segp->s_ip==0) {
144: if (!exsread(segp, ip, &head.segs[SISTEXT], 0)) {
145: goto out;
146: }
147: segp->s_ip = ip;
148: ip->i_refc++;
149: }
150: segp = ssalloc(ip,0,
151: head.segs[SIPDATA].size+head.segs[SIBSS].size);
152: pp->p_segp[SIPDATA] = segp;
153: if (segp->s_ip==0 &&
154: !exsread(segp, ip, &head.segs[SIPDATA], 0)) {
155: goto out;
156: }
157: break;
158: default:
159: panic("pexece");
160: }
161:
162: u.u_regl[SS] = u.u_regl[ES] = u.u_regl[DS];
163: if (sproto(&head) == 0) {
164: goto out;
165: }
166:
167: /*
168: * The new image is read in
169: * and mapped. Perform the final grunge
170: * (set-uid stuff, accounting, loading up
171: * registers, etc).
172: */
173: u.u_flag &= ~AFORK;
174: kkcopy(u.u_direct.d_name, u.u_comm, sizeof(u.u_comm));
175: if (iaccess(ip, IPR) == 0) { /* Can't read ? no dump or trace */
176: pp->p_flags |= PFNDMP;
177: pp->p_flags &= ~PFTRAC;
178: }
179:
180: /*
181: * Norm says Frank says we need to drop this for db to work.
182: */
183: if (iaccess(ip, IPW) == 0) /* Can't write ? no trace */
184: pp->p_flags &= ~PFTRAC;
185:
186: if ((ip->i_mode&ISUID) != 0) { /* Set user id ? no trace */
187: pp->p_uid = u.u_uid = ip->i_uid;
188: pp->p_flags &= ~PFTRAC;
189: }
190: if ((ip->i_mode&ISGID) != 0) { /* Set group id ? no trace */
191: u.u_gid = ip->i_gid;
192: pp->p_flags &= ~PFTRAC;
193: }
194: for (i=0; i < NUFILE; i++) {
195: if (u.u_filep[i]!=NULL && (u.u_filep[i]->f_flag2&FD_CLOEXEC)) {
196: fdclose(i); /* close fd on exec bit set */
197: }
198: }
199: /*
200: * Default every signal that is not ignored.
201: */
202: for (i=0; i<NSIG; ++i) {
203: if (u.u_sfunc[i] != SIG_IGN) {
204: u.u_sfunc[i] = SIG_DFL;
205: pp->p_dfsig |= ((sig_t) 1) << (i - 1);
206: }
207: }
208: if ((pp->p_flags&PFTRAC) != 0) /* Being traced */
209: sendsig(SIGTRAP, pp);
210: idetach(ip);
211: msetusr(head.entry, head.initsp);
212:
213: segload();
214: goto done;
215:
216: /*
217: * We did not make it.
218: * Release the INODE for the load
219: * file, and return through the "sys exit"
220: * code with a "SIGSYS", or with the signal actually received
221: * if we are aborting due to interrupted exec.
222: */
223: out:
224: idetach(ip);
225: if (u.u_error == EINTR)
226: pexit(nondsig());
227: pexit(SIGSYS);
228:
229: done:
230: return 0;
231: }
232:
233: /*
234: * Open an l.out, make sure it is an l.out and executable and return the
235: * appropriate information.
236: */
237: INODE *
238: exlopen(xhp, np, shrds)
239: register struct xechdr *xhp;
240: char *np;
241: int *shrds;
242: {
243: register INODE *ip;
244: int i, nscn, diff, hdrsize;
245: register BUF *bp;
246: unsigned short magic;
247: struct ldheader head;
248: struct filehdr fhead;
249: struct aouthdr ahead;
250: struct scnhdr scnhdr;
251:
252: /*
253: * Make sure the file is really an executable l.out and read the
254: * header in.
255: */
256: if (ftoi(np, 'r') != 0)
257: return (NULL);
258: ip = u.u_cdiri;
259: if (iaccess(ip, IPE) == 0) {
260: idetach(ip);
261: return (NULL);
262: }
263: if ((ip->i_mode&(IPE|IPE<<3|IPE<<6))==0 || (ip->i_mode&IFMT)!=IFREG) {
264: u.u_error = EACCES;
265: idetach(ip);
266: return (NULL);
267: }
268: if ((bp=vread(ip, (daddr_t)0)) == NULL)
269: goto bad;
270: /*
271: * Copy everything we need from the l.out header and check magic
272: * number and machine type.
273: */
274: *shrds = 0; /* set return arg shrds nonzero only for shared l.out */
275: kkcopy(bp->b_vaddr, &magic, sizeof(magic));
276: canint(magic);
277: switch (magic) {
278: case L_MAGIC: /* Coherent 286 format */
279: kkcopy(bp->b_vaddr, &head, sizeof(struct ldheader));
280: canint(head.l_machine);
281: if (head.l_machine!=M_8086)
282: goto bad;
283: for (i=0; i<NXSEG; i++) {
284: cansize(head.l_ssize[i]);
285: }
286: canint(head.l_flag);
287: canvaddr(head.l_entry);
288:
289: /*
290: * If a shared and separated image
291: * has stuff in segments that makes it impossible
292: * to share, give an error immediately so that we don't
293: * lose the parent.
294: */
295: head.l_flag &= LF_SHR|LF_SEP|LF_KER;
296:
297: if ((head.l_flag&LF_SEP==0) || (head.l_flag &LF_KER)
298: || head.l_ssize[L_PRVI] || head.l_ssize[L_BSSI]) {
299: goto bad;
300: }
301: xhp->magic = XMAGIC( I286MAGIC,I_MAGIC );
302: xhp->entry = head.l_entry;
303:
304: xhp->segs[SISTEXT].fbase = sizeof(struct ldheader);
305: xhp->segs[SISTEXT].mbase = NBPS;
306: xhp->segs[SISTEXT].size = head.l_ssize[L_SHRI];
307:
308: xhp->segs[SIPDATA].fbase = sizeof(struct ldheader) +
309: xhp->segs[SISTEXT].size;
310: xhp->segs[SIPDATA].mbase = 0;
311: xhp->segs[SIPDATA].size = head.l_ssize[L_SHRD] +
312: head.l_ssize[L_PRVD];
313: if (head.l_flag & LF_SHR)
314: *shrds = head.l_ssize[L_SHRD];
315:
316: xhp->segs[SIBSS].fbase = 0;
317: xhp->segs[SIBSS].mbase = xhp->segs[SIPDATA].size;
318: xhp->segs[SIBSS].size = head.l_ssize[L_BSSD];
319:
320: xhp->segs[SISTACK].mbase = ISP_286; /* size 0, fbase 0 */
321: brelease(bp);
322: return ip;
323:
324: case I386MAGIC: /* ... COFF */
325: kkcopy(bp->b_vaddr, &fhead, sizeof(struct filehdr));
326: hdrsize = sizeof(ahead)+sizeof(fhead);
327: if(fhead.f_opthdr!=sizeof (ahead) || !(fhead.f_flags&F_EXEC)||
328: fhead.f_nscns*sizeof(scnhdr) > BSIZE)
329: goto bad;
330:
331: kkcopy(bp->b_vaddr+sizeof(fhead), &ahead, sizeof(ahead));
332: if ((/*ahead.magic!=O_MAGIC && ahead.magic!=N_MAGIC && */
333: ahead.magic!=Z_MAGIC))
334: goto bad;
335:
336: xhp->magic = XMAGIC( I386MAGIC,ahead.magic );
337: xhp->entry = ahead.entry;
338:
339: for (i=0; i<fhead.f_nscns; i++) {
340: kkcopy(bp->b_vaddr + hdrsize + sizeof(scnhdr)*i,
341: &scnhdr, sizeof(scnhdr));
342: switch ((int)(scnhdr.s_flags)) {
343: case STYP_INFO:
344: continue;
345: case STYP_BSS:
346: nscn = SIBSS;
347: break;
348: case STYP_TEXT:
349: nscn = SISTEXT; goto common;
350: case STYP_DATA:
351: nscn = SIPDATA;
352: common:
353: diff = scnhdr.s_scnptr & (NBPC-1);
354: scnhdr.s_vaddr -= diff;
355: scnhdr.s_scnptr -= diff;
356: scnhdr.s_size += diff;
357: break;
358: default:
359: goto bad;
360: }
361:
362: if (xhp->segs[nscn].size!=0
363: || (unsigned)scnhdr.s_vaddr >= ISP_386)
364: goto bad;
365:
366: xhp->segs[nscn].mbase = scnhdr.s_vaddr;
367: xhp->segs[nscn].fbase = scnhdr.s_scnptr;
368: xhp->segs[nscn].size = scnhdr.s_size;
369: }
370:
371: if (!xhp->segs[SISTEXT].size || !xhp->segs[SIPDATA].size)
372: goto bad;
373:
374: xhp->entry = ahead.entry;
375: if (xhp->entry >= xhp->segs[SISTEXT].size)
376: goto bad;
377:
378: xhp->segs[SISTACK].mbase = ISP_386; /* size 0, fbase 0 */
379: xhp->magic = XMAGIC( I386MAGIC,ahead.magic );
380: brelease(bp);
381: return ip;
382: default:
383: bad:
384: brelease(bp);
385: u.u_error = ENOEXEC;
386: idetach(ip);
387: return NULL;
388: }
389: }
390:
391: /*
392: * Given a segment `sp', read `ss' bytes from the inode `ip' starting
393: * at seek address `sa' into offset `so' in the segment.
394: *
395: * Argument "first" is nonzero only when loading data for l.out -
396: * need this because *shared* l.out's need PRVD to be aligned on the next
397: * 16 byte boundary after the end of SHRD. So we need to leave a hole
398: * between SHRD and PRVD in this case.
399: */
400: static SEG *
401: exsread(sp, ip, xsp, first)
402: register SEG *sp;
403: INODE *ip;
404: struct xecseg *xsp;
405: int first;
406: {
407: register int ss, sa, so, did;
408: int overshoot;
409:
410: sa = xsp->fbase;
411: so = 0;
412:
413: for (ss = first ? first : xsp->size;; ss -= did) {
414: if (!ss) { /* we finished a hunk */
415: /* is there more to read */
416: if (!first || (!(ss = xsp->size - first)))
417: break;
418: so = (so + 15) & ~15; /* round up */
419: first = 0; /* don't go again */
420: }
421: u.u_io.io_seg = IOPHY;
422: u.u_io.io_seek = sa;
423: u.u_io.io.pbase = MAPIO(sp->s_vmem, so);
424: u.u_io.io_flag = 0;
425: /*
426: * "did" is how many bytes to read in with this request.
427: */
428: if (ss >= 4096)
429: did = u.u_io.io_ioc = 4096;
430: else
431: did = u.u_io.io_ioc = ss;
432: /*
433: * Don't allow incoming data to straddle a 4k segment.
434: */
435: overshoot = did + (so & 4095) - 4096;
436: if (overshoot > 0)
437: did -= overshoot;
438: sp->s_lrefc++;
439: iread(ip, &u.u_io);
440: sp->s_lrefc--;
441: if (nondsig()) {
442: u.u_error = EINTR;
443: break;
444: }
445: sa += did;
446: so += did;
447: }
448: if (u.u_error == 0)
449: return (sp);
450: return (NULL);
451: }
452:
453: struct adata { /* Storage for arg and env data */
454: int np; /* Number of pointers in vector */
455: int nc; /* Number of characters in strings */
456: };
457:
458: /*
459: * Given a pointer to a list of arguments and a pointer to a list of
460: * environments, return a stack with the arguments and environments on it.
461: */
462: SEG *
463: exstack(xhp, argp, envp, wdin)
464: register struct xechdr *xhp;
465: vaddr_t argp, envp;
466: {
467: register SEG *sp; /* Stack segment pointer */
468: struct sdata { /* To keep segment pointers */
469: vaddr_t vp; /* Argv[i], envp[i] pointer */
470: vaddr_t cp; /* Argv[i][j], envp[i][j] pointer */
471: } stk;
472: struct adata arg, env;
473: int chrsz, vecsz, stksz, wdmask, wdout, stkoff, stktop;
474: int stkenvp;
475: register int i;
476:
477: /* Validate and evaluate size of args and envs */
478: if (!excount(argp, &arg, wdin) || !excount(envp, &env, wdin))
479: return NULL;
480:
481: /* Calculate stack size and allocate it */
482: chrsz = roundu(arg.nc + env.nc, sizeof(int));
483: vecsz = (arg.np+1 + env.np+1) * sizeof(long);
484: stksz = roundu(vecsz+chrsz+ISTSIZE, NBPC);
485: if (stksz > MADSIZE || !(sp = salloc(stksz, SFDOWN))) {
486: u.u_error = E2BIG;
487: return NULL;
488: }
489:
490: /* Set up target stack */
491: stktop = xhp->segs[SISTACK].mbase;
492: stk.cp = stktop - chrsz;
493: stk.vp = stktop - chrsz - vecsz;
494: stkoff = MAPIO(sp->s_vmem, stksz - stktop);
495: u.u_argc = arg.np;
496: u.u_argp = stk.vp;
497: wdmask = -1;
498: if (wdin==sizeof(short))
499: wdmask = (unsigned short)wdmask;
500:
501: switch (stktop) {
502:
503: case ISP_386:
504: wdout = sizeof(long);
505: xhp->initsp = stk.vp - sizeof(long);
506: dmaout(sizeof(long), xhp->initsp+stkoff, &arg.np);
507: break;
508:
509: case ISP_286:
510: wdout = sizeof(short);
511: xhp->initsp = stk.vp - 3*sizeof(short);
512: stkenvp = stk.vp + (arg.np+1) * sizeof(short);
513: dmaout(sizeof(short), xhp->initsp+stkoff, &arg.np);
514: dmaout(sizeof(short), xhp->initsp+sizeof(short)+stkoff,
515: &stk.vp);
516: dmaout(sizeof(short), xhp->initsp+2*sizeof(short)+stkoff,
517: &stkenvp);
518: break;
519:
520: default:
521: panic("exstack");
522:
523: }
524:
525: /* Arguments */
526: for (i = 0; i<arg.np; i++, argp += wdin, stk.vp += wdout) {
527: dmaout(wdout, stk.vp+stkoff, &stk.cp);
528: stk.cp += exarg(stk.cp+stkoff, getupd(argp) & wdmask);
529: }
530:
531: /* skip null word after arguments */
532: stk.vp += wdout;
533:
534: /* Environments */
535: for (i = 0; i<env.np; i++, envp += wdin, stk.vp += wdout) {
536: dmaout(wdout, stk.vp+stkoff, &stk.cp);
537: stk.cp += exarg(stk.cp+stkoff, getupd(envp) & wdmask);
538: }
539:
540: return sp;
541: }
542:
543: exarg(out, in)
544: vaddr_t in, out;
545: {
546: char c;
547: vaddr_t init_in;
548:
549: init_in = in;
550: do {
551: c = getubd(in++);
552: dmaout(sizeof(char), out++, &c);
553: } while (c);
554: return in - init_in;
555: }
556:
557:
558: /*
559: * Given a pointer to a list of arguments, a pointer to an argument count
560: * and a pointer to a byte count, count the #characters/#strigns
561: * in the arguments
562: */
563: excount(usrvp, adp, wdin)
564: register vaddr_t usrvp;
565: struct adata *adp;
566: {
567: register vaddr_t usrcp;
568: register int c;
569: register unsigned nb;
570: register unsigned na;
571: int wdmask;
572:
573: wdmask = -1;
574: if (wdin==sizeof(short))
575: wdmask = (unsigned short)wdmask;
576: na = nb = 0;
577: if (usrvp != NULL) {
578: for (;;) {
579: usrcp = getupd(usrvp) & wdmask;
580: usrvp += wdin;
581: if (u.u_error)
582: return (0);
583: if (usrcp == NULL)
584: break;
585: na++;
586: for (;;) {
587: c = getubd(usrcp++);
588: if (u.u_error)
589: return (0);
590: nb++;
591: if (c == '\0')
592: break;
593: }
594: }
595: }
596: adp->np = na;
597: adp->nc = nb;
598: return (1);
599: }
600:
601: /*
602: * Round up a size to a paragraph
603: * (mod 16) boundry.
604: * This is really mod 512 to make swapping work
605: */
606: off_t
607: exround(s)
608: off_t s;
609: {
610: return ((s+15)&~0x0F);
611: }
612:
613: pload( np )
614: char * np;
615: {
616: return -1;
617:
618: }
619: /*
620: * Set up the first process, a small programme which will exec
621: * the init programme.
622: */
623: eveinit()
624: {
625: SEG *sp;
626: register PROC *pp;
627: SELF = pp = eprocp;
628: /* static struct xechdr xecinit[NUSEG+1] = { {0},{0},{0},{ISP_386}}; */
629:
630: /*
631: * Allocate, record, initialize code segment, make it executable.
632: */
633: if ((sp = salloc(roundu(icodes, NBPC), 0)) == NULL)
634: panic("eveinit(code)");
635: pp->p_segp[SIPDATA] = sp;
636:
637: /*
638: * Start process.
639: */
640: u.u_argp = 0;
641: if (sproto(0) == 0)
642: panic("eveinit()");
643: segload();
644: kucopy(icodep, 0, icodes);
645: }
646:
647: /*
648: * Given a major number, undo the previous function.
649: */
650: puload(m)
651: int m;
652: {
653: register CON *cp;
654: register DRV *dp;
655:
656: dp = &drvl[m];
657: lock(dp->d_gate);
658: if (m>=drvn || (cp=dp->d_conp)==NULL) {
659: u.u_error = ENXIO;
660: goto ret;
661: }
662: (*cp->c_uload)();
663: if ( ! u.u_error)
664: dp->d_conp = NULL;
665: ret:
666: unlock(dp->d_gate);
667: return (0);
668: }
669:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.