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