![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to proc.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 proc.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: -lgl) */
14: /*
15: * Coherent.
16: * Process handling and scheduling.
17: *
18: * $Log: proc.c,v $
19: * Revision 1.2 92/08/04 12:34:18 bin
20: * changed for ker 59
21: *
22: * Revision 1.5 92/04/03 14:35:36 hal
23: * Kernel #49: piggy trace variable.
24: *
25: * Revision 1.4 92/02/03 17:00:09 piggy
26: * Send SIGHUP to all group members on death of group leader.
27: */
28: #include <sys/coherent.h>
29: #include <acct.h>
30: #include <errno.h>
31: #include <sys/inode.h>
32: #include <sys/proc.h>
33: #include <sys/ptrace.h>
34: #include <sys/sched.h>
35: #include <sys/seg.h>
36: #include <signal.h>
37: #include <sys/stat.h>
38:
39: /*
40: * Initialization.
41: * Set up the hash table queues.
42: */
43: pcsinit()
44: {
45: register PROC *pp;
46: register PLINK *lp;
47:
48: /*
49: * Explicitly initialize everything in the first process.
50: */
51: pp = &procq;
52: SELF = pp;
53: procq.p_nforw = pp;
54: procq.p_nback = pp;
55: procq.p_lforw = pp;
56: procq.p_lback = pp;
57:
58: #ifdef _I386
59: /* Segments are initialized in mchinit() and eveinit(). */
60:
61: procq.p_uid = 0; /* Effective uid */
62: procq.p_ruid = 0; /* Real uid */
63: procq.p_rgid = 0; /* Real gid */
64: procq.p_state = 0; /* Scheduling state */
65: procq.p_flags = 0; /* Flags */
66: procq.p_ssig = (sig_t) 0; /* Signals which have been set */
67: #ifdef _I386
68: procq.p_dfsig = (sig_t) 0xffffffff; /* All signals are defaulted. */
69: procq.p_hsig = (sig_t) 0; /* Signals which are being held */
70: procq.p_dsig = (sig_t) 0; /* Signals which are being deferred */
71: #endif
72: procq.p_isig = (sig_t) 0; /* Signals which are being ignored */
73: procq.p_event = NULL; /* Wakeup event channel */
74: procq.p_alarm = 0; /* Timer for alarms */
75: procq.p_group = 0; /* Process group */
76: /*
77: * Set ttdev to null so that we do not accidentally set a tty for init.
78: */
79: procq.p_ttdev = makedev(0,0); /* Controlling terminal */
80: procq.p_nice = 0; /* Nice value */
81: procq.p_cval = 0; /* Cpu schedule value */
82: procq.p_sval = 0; /* Swap schedule value */
83: procq.p_ival = 0; /* Importance value */
84: procq.p_rval = 0; /* Response value */
85: procq.p_lctim = 0; /* Last time cval was updated */
86: procq.p_utime = 0L; /* User time (HZ) */
87: procq.p_stime = 0L; /* System time */
88: procq.p_cutime = 0L; /* Sum of childs user time */
89: procq.p_cstime = 0L; /* Sum of childs system time */
90: procq.p_exit = 0; /* Exit status */
91: procq.p_polls = NULL; /* Enabled polls */
92: /* Poll timer */
93: procq.p_polltim.t_next = NULL;
94: procq.p_polltim.t_last = NULL;
95: procq.p_polltim.t_lbolt = 0L;
96: procq.p_polltim.t_func = NULL;
97: procq.p_polltim.t_farg = NULL;
98: #ifndef _I386
99: procq.p_polltim.t_ldrv = 0;
100: #endif /* _I386 */
101:
102: /* Alarm timer */
103: procq.p_alrmtim.t_next = NULL;
104: procq.p_alrmtim.t_last = NULL;
105: procq.p_alrmtim.t_lbolt = 0L;
106: procq.p_alrmtim.t_func = NULL;
107: procq.p_alrmtim.t_farg = NULL;
108: #ifndef _I386
109: procq.p_alrmtim.t_ldrv = 0;
110: #endif /* _I386 */
111:
112: procq.p_prl = NULL; /* Pending record lock */
113: #endif /* _I386 */
114:
115: for (lp=&linkq[0]; lp<&linkq[NHPLINK]; lp++) {
116: lp->p_lforw = lp;
117: lp->p_lback = lp;
118: }
119: }
120:
121: /*
122: * Initiate a process.
123: */
124: PROC *
125: #ifdef _I386
126: process()
127: #else
128: process(f)
129: int (*f)();
130: #endif
131: {
132: register PROC *pp1;
133: register PROC *pp;
134: register SEG *sp;
135: MCON mcon;
136:
137: if ((pp=kalloc(sizeof(PROC))) == NULL)
138: return (NULL);
139:
140: pp->p_flags = PFCORE;
141: pp->p_state = PSRUN;
142: pp->p_ttdev = NODEV;
143: #ifndef _I386
144: /*
145: * What is this, and why is it 286 only?
146: */
147: if (f != NULL) {
148: pp->p_flags |= PFKERN;
149: sp = salloc((fsize_t)UPASIZE, SFSYST|SFHIGH|SFNSWP);
150: if (sp == NULL) {
151: kfree(pp);
152: return (NULL);
153: }
154: pp->p_segp[SIUSERP] = sp;
155: msetsys(&mcon, f, FP_SEL(sp->s_faddr));
156: kfcopy( (char *)&mcon,
157: sp->s_faddr + offset(uproc, u_syscon),
158: sizeof(mcon));
159: }
160: #endif
161: lock(pnxgate);
162: next:
163:
164: /*
165: * Pick the next process id.
166: */
167: /* DO NOT MESS WITH THE FOLLOWING CONDITIONAL UNLESS YOU
168: TEST THE RESULTS ON BOTH 286 AND 386 */
169: #ifdef _I386
170: if (++cpid >= NPID)
171: cpid = 2;
172: pp->p_pid = cpid;
173: #else
174: pp->p_pid = cpid++;
175: if (cpid >= NPID)
176: cpid = 2;
177: #endif
178:
179: /*
180: * Make sure that process id is not in use.
181: */
182: pp1 = &procq;
183: while ((pp1=pp1->p_nforw) != &procq) {
184: if (pp1->p_pid < pp->p_pid)
185: break;
186: if (pp1->p_pid == pp->p_pid)
187: goto next;
188: }
189:
190: /*
191: * We've got a valid pid, so let's put this process into
192: * the process table.
193: */
194: pp->p_nback = pp1->p_nback;
195: pp1->p_nback->p_nforw = pp;
196: pp->p_nforw = pp1;
197: pp1->p_nback = pp;
198: unlock(pnxgate);
199: return (pp);
200: }
201:
202: /*
203: * Remove a process from the next queue and release and space.
204: */
205: relproc(pp)
206: register PROC *pp;
207: {
208: register SEG * sp;
209:
210: /*
211: * Child process still has a user-area.
212: */
213: if ((sp = pp->p_segp[SIUSERP]) != NULL) {
214:
215: /*
216: * Detach user-area from child process.
217: */
218: pp->p_segp[SIUSERP] = NULL;
219:
220: /*
221: * Child process is swapped out.
222: */
223: if (pp->p_flags & PFSWAP)
224: sp->s_lrefc++;
225:
226: /*
227: * Release child's user-area.
228: */
229: sfree(sp);
230: }
231:
232: /*
233: * Remove process from doubly-linked list of all processes.
234: * Release space allocated for proc structure.
235: */
236: lock(pnxgate);
237: pp->p_nback->p_nforw = pp->p_nforw;
238: pp->p_nforw->p_nback = pp->p_nback;
239: unlock(pnxgate);
240: kfree(pp);
241: }
242:
243: /*
244: * Create a clone of ourselves.
245: * N.B. - consave(&mcon) returns twice; anything not initialized
246: * in automatic storage before the call to segadup() will not be
247: * initialized when the second return from consave() commences.
248: */
249: pfork()
250: {
251: register PROC *cpp;
252: register PROC *pp;
253: register int s;
254: MCON mcon;
255:
256: #ifdef _I386
257: if ((cpp=process()) == NULL) {
258: #else
259: if ((cpp=process(NULL)) == NULL) {
260: #endif
261: SET_U_ERROR( EAGAIN, "no more process table entries" );
262: return -1;
263: }
264:
265: #ifndef _I386
266: s = sphi();
267: usave(); /* Put the current copy of uarea into its segment */
268: spl(s);
269: #endif
270:
271: pp = SELF;
272: s = sphi(); /* put current interrupt level into s before segadup */
273: spl(s);
274: /*
275: * As stated above, no auto variable may be changed between calls
276: * to segadup() and consave().
277: */
278: if (segadup(cpp) == 0) {
279: SET_U_ERROR( EAGAIN, "can not duplicate segments" );
280: relproc(cpp);
281: return -1;
282: }
283: if (u.u_rdir != NULL)
284: u.u_rdir->i_refc++;
285: if (u.u_cdir != NULL)
286: u.u_cdir->i_refc++;
287: fdadupl();
288: cpp->p_uid = pp->p_uid;
289: cpp->p_ruid = pp->p_ruid;
290: cpp->p_rgid = pp->p_rgid;
291: cpp->p_ppid = pp->p_pid;
292: cpp->p_ttdev = pp->p_ttdev;
293: cpp->p_group = pp->p_group;
294: cpp->p_ssig = pp->p_ssig;
295: #ifdef _I386
296: cpp->p_dfsig = pp->p_dfsig;
297: cpp->p_dsig = pp->p_dsig;
298: cpp->p_hsig = pp->p_hsig;
299: #endif /* _I386 */
300: cpp->p_isig = pp->p_isig;
301: cpp->p_cval = CVCHILD;
302: cpp->p_ival = IVCHILD;
303: cpp->p_sval = SVCHILD;
304: cpp->p_rval = RVCHILD;
305: #ifdef _I386
306: cpp->p_prl = NULL;
307: #endif
308:
309: sphi(); /* s = sphi() was done before segadup() */
310: consave(&mcon);
311: spl(s);
312:
313: /*
314: * Parent process.
315: */
316: if ((pp = SELF) != cpp) {
317: segfinm(cpp->p_segp[SIUSERP]);
318: #ifdef _I386
319: dmaout(sizeof(mcon),
320: MAPIO(cpp->p_segp[SIUSERP]->s_vmem,offset(uproc,u_syscon)),
321: (char *)&mcon);
322: #else
323: kfcopy((char *)&mcon,
324: cpp->p_segp[SIUSERP]->s_faddr + offset(uproc,u_syscon),
325: sizeof(mcon));
326: #endif
327: mfixcon(cpp);
328: s = sphi();
329: setrun(cpp);
330: spl(s);
331: #ifdef _I386
332: u.u_rval2 = 0;
333: #endif
334: return(cpp->p_pid);
335: }
336:
337: /*
338: * Child process.
339: */
340: else {
341: u.u_btime = timer.t_time;
342: u.u_flag = AFORK;
343: #ifdef _I386
344: #ifdef UPROC_VERSION
345: u.u_version = UPROC_VERSION;
346: #endif /* UPROC_VERSION */
347: u.u_sleep[0] = '\0'; /* We are not sleeping to start with. */
348: sproto(0);
349: #else
350: sproto();
351: #endif
352: segload();
353: #ifdef _I386
354: u.u_rval2 = SELF->p_ppid;
355: #endif
356: return 0;
357: }
358: }
359:
360: /*
361: * Die.
362: */
363: pexit(s)
364: {
365: register PROC *pp1;
366: register PROC *pp;
367: register SEG *sp;
368: register int n;
369: PROC *parent;
370:
371: pp = SELF;
372:
373: T_PIGGY( 0x1, printf("%s:pexit(%x)", u.u_comm, s); );
374: /*
375: * Cancel alarm and poll timers [if any].
376: */
377: timeout(&pp->p_alrmtim, 0, NULL, 0);
378: timeout(&pp->p_polltim, 0, NULL, 0);
379:
380: /*
381: * Write out accounting directory and close all files associated with
382: * this process.
383: */
384: setacct();
385: if (u.u_rdir)
386: ldetach(u.u_rdir);
387: if (u.u_cdir)
388: ldetach(u.u_cdir);
389: fdaclose();
390:
391: /*
392: * Free all segments in reverse order, except for user-area.
393: */
394: for (n = NUSEG; --n > 0;) {
395: if ((sp = pp->p_segp[n]) != NULL) {
396: pp->p_segp[n] = NULL;
397: sfree(sp);
398: }
399: }
400:
401: /*
402: * Wakeup our parent. If we have any children, init will become the
403: * new parent. If there are any children we are tracing who are
404: * waiting for us, we wake them up.
405: */
406: pp1 = &procq;
407: while ((pp1=pp1->p_nforw) != &procq) {
408: if (pp1->p_pid == pp->p_ppid) {
409: parent = pp1; /* Remember our parent. */
410: if (pp1->p_state==PSSLEEP && pp1->p_event==(char *)pp1)
411: wakeup((char *)pp1);
412: }
413: if (pp1->p_ppid == pp->p_pid) {
414: pp1->p_ppid = 1;
415: if (pp1->p_state == PSDEAD)
416: wakeup((char *)eprocp);
417: if ((pp1->p_flags&PFTRAC) != 0)
418: wakeup((char *)&pts.pt_req);
419: }
420: }
421:
422: /*
423: * Wake up swapper if swap timer is active.
424: */
425: if (stimer.t_last != 0)
426: wakeup((char *) &stimer);
427:
428: /*
429: * Mark us as dead and give up the processor forever.
430: */
431: pp->p_exit = s;
432: pp->p_state = PSDEAD;
433:
434: #ifdef _I386
435: /*
436: * If this is a process group leader, inform all members of the group
437: * of the recent death with a HUP signal.
438: */
439: if (pp->p_group == pp->p_pid) {
440: ukill(-pp->p_pid, SIGHUP);
441: }
442: #else
443: uasa = 0;
444: #endif
445:
446: #ifdef _I386
447: T_PIGGY( 0x100, printf("<CHLD pid: %d ppid: %d>",
448: pp->p_pid, parent->p_pid); );
449:
450: /*
451: * If the parent is ignoring SIGCHLD,
452: * remove the zombie right away.
453: */
454: # define CHLDBIT (((sig_t) 1) << (SIGCHLD - 1))
455: if (CHLDBIT & parent->p_isig) {
456: parent->p_cutime += pp->p_utime + pp->p_cutime;
457: parent->p_cstime += pp->p_stime + pp->p_cstime;
458: relproc(pp);
459: } else {
460: /*
461: * If SIGCHLD is not defaulted, notify our parent
462: * of our demise.
463: */
464: if (!(CHLDBIT & parent->p_dfsig)) {
465: sendsig(SIGCHLD, parent );
466: }
467: }
468: #endif /* _I386 */
469:
470: dispatch();
471: }
472:
473: #ifdef _I386
474: /*
475: * Sleep verbosely. Put a short string describing our reason for sleeping
476: * into our U area, and then go to sleep.
477: */
478: v_sleep(e, cl, sl, sr, msg)
479: char *e;
480: int cl, sl, sr;
481: char *msg;
482: {
483: int i;
484:
485: /*
486: * The descriptive string may be at most 10 characters long.
487: * It will only be NUL terminated if it has 9 or fewer characters.
488: */
489: for (i = 0; i < 10; ++i) {
490: if ('\0' == (u.u_sleep[i] = msg[i])) {
491: break;
492: }
493: }
494:
495: sleep(e, cl, sl, sr);
496: } /* v_sleep() */
497: #endif
498:
499: /*
500: * Sleep on the event `e'. This gives up the processor until someone
501: * wakes us up. Since it is possible for many people to sleep on the
502: * same event, the caller when awakened should make sure that what he
503: * was waiting for has completed and if not, go to sleep again. `cl'
504: * is the cpu value we get to get the cpu as soon as we are woken up.
505: * `sl' is the swap value we get to keep us in memory for the duration
506: * of the sleep. `sr' is the swap value that allows us to get swapped
507: * in if we have been swapped out.
508: */
509: sleep(e, cl, sl, sr)
510: char *e;
511: {
512: register PROC *bp;
513: register PROC *fp;
514: register PROC *pp;
515: register int s;
516:
517: pp = SELF;
518:
519: /*
520: * See if we have a signal awaiting.
521: */
522: if (cl<CVNOSIG && pp->p_ssig && nondsig()) {
523: sphi();
524: envrest(&u.u_sigenv);
525: }
526:
527: /*
528: * Get ready to go to sleep and do so.
529: */
530: s = sphi();
531: pp->p_state = PSSLEEP;
532: pp->p_event = e;
533: pp->p_lctim = utimer;
534: addu(pp->p_cval, cl);
535: pp->p_ival = sl;
536: pp->p_rval = sr;
537: fp = &linkq[hash(e)];
538: bp = fp->p_lback;
539: pp->p_lforw = fp;
540: fp->p_lback = pp;
541: pp->p_lback = bp;
542: bp->p_lforw = pp;
543: spl(s);
544: dispatch();
545:
546: /*
547: * We have just woken up. Get ready to return.
548: */
549: subu(pp->p_cval, cl);
550: pp->p_ival = 0;
551: pp->p_rval = 0;
552:
553: /*
554: * Since we are no longer asleep, we no longer need
555: * to publish a reason for sleeping.
556: */
557: #ifdef _I386
558: u.u_sleep[0] = '\0';
559: #endif
560:
561: /*
562: * Check for an interrupted system call.
563: */
564: if (cl<CVNOSIG && pp->p_ssig && nondsig()) {
565: sphi();
566: envrest(&u.u_sigenv);
567: }
568: }
569:
570: /*
571: * Defer function to wake up all processes sleeping on the event `e'.
572: */
573: wakeup(e)
574: char *e;
575: {
576: void dwakeup();
577:
578: #ifdef TRACER
579: /*
580: * In diagnostic kernel, keep return addr on queue as well.
581: */
582: int *r=(int*)(&e);
583: defer0(dwakeup, e, *(r-1));
584: #else
585: defer(dwakeup, e);
586: #endif
587: }
588:
589: /*
590: * Wake up all processes sleeping on the event `e'.
591: */
592: void
593: dwakeup(e)
594: char *e;
595: {
596: register PROC *pp;
597: register PROC *pp1;
598: register int s;
599:
600: /*
601: * Identify event queue to check.
602: * Disable interrupts.
603: */
604: pp1 = &linkq[hash(e)];
605: pp = pp1;
606: s = sphi();
607:
608: /*
609: * Traverse doubly-linked circular event-queue.
610: */
611: while ((pp = pp->p_lforw) != pp1) {
612:
613: /*
614: * Process is waiting on event 'e'.
615: */
616: if (pp->p_event == e) {
617: /*
618: * Remove process from event queue.
619: * Update process priority.
620: * Insert process into run queue.
621: */
622: pp->p_lback->p_lforw = pp->p_lforw;
623: pp->p_lforw->p_lback = pp->p_lback;
624: addu(pp->p_cval, (utimer-pp->p_lctim)*CVCLOCK);
625: setrun(pp);
626:
627: /*
628: * Enable interrupts.
629: * Restart search at start of event queue.
630: * Disable interrupts.
631: */
632: spl(s);
633: pp = pp1;
634: s = sphi();
635: }
636: }
637: spl(s);
638: }
639:
640: /*
641: * Reschedule the processor.
642: */
643: dispatch()
644: {
645: register PROC *pp1;
646: register PROC *pp2;
647: register unsigned v;
648: register int s;
649:
650: s = sphi();
651: pp1 = iprocp;
652: pp2 = &procq;
653: v = 0;
654: while ((pp2=pp2->p_lforw) != &procq) {
655: v -= pp2->p_cval;
656: if ((pp2->p_flags&PFCORE) == 0)
657: continue;
658: pp1 = pp2->p_lforw;
659: pp1->p_cval += pp2->p_cval;
660: pp2->p_cval = v;
661: pp1->p_lback = pp2->p_lback;
662: pp1->p_lback->p_lforw = pp1;
663: pp1 = pp2;
664: break;
665: }
666: spl(s);
667:
668: quantum = NCRTICK;
669: disflag = 0;
670: if (pp1 != SELF) {
671: /*
672: * Consave() returns twice.
673: * 1st time is after our context is saved in u.u_syscon,
674: * whereupon we should restore other proc's context.
675: * 2nd time is after our context is restored by another proc.
676: * Conrest() forces a context switch to a new process.
677: */
678: s = sphi();
679: SELF = pp1;
680: if (consave(&u.u_syscon) == 0) {
681: #ifdef _I386
682: conrest(*pp1->p_segp[SIUSERP]->s_vmem, &u.u_syscon);
683: #else
684: conrest(
685: FP_SEL(pp1->p_u->s_faddr), offset(uproc,u_syscon));
686: #endif
687: }
688: if (SELF->p_pid != 0)
689: segload();
690: spl(s);
691: }
692: }
693:
694: /*
695: * Add a process to the run queue.
696: * This routine must be called at high priority.
697: */
698: setrun(pp1)
699: register PROC *pp1;
700: {
701: register PROC *pp2;
702: register unsigned v;
703:
704: v = 0;
705: pp2 = &procq;
706: for (;;) {
707: pp2 = pp2->p_lback;
708: if ((v+=pp2->p_lforw->p_cval) >= pp1->p_cval)
709: break;
710: if (pp2 == &procq)
711: break;
712: }
713: pp2->p_lforw->p_lback = pp1;
714: pp1->p_lforw = pp2->p_lforw;
715: pp2->p_lforw = pp1;
716: pp1->p_lback = pp2;
717: v -= pp1->p_cval;
718: pp1->p_cval = v;
719: pp1->p_lforw->p_cval -= v;
720: pp1->p_state = PSRUN;
721: }
722:
723: /*
724: * Wait for the gate `g' to unlock, and then lock it.
725: */
726: lock(g)
727: register GATE g;
728: {
729: register int s;
730:
731: s = sphi();
732: while (g[0]) {
733: g[1] = 1;
734: v_sleep((char *)g, CVGATE, IVGATE, SVGATE, "lock");
735: /* Waiting for a gate to unlock. */
736: }
737: g[0] = 1;
738: spl(s);
739: }
740:
741: /*
742: * Unlock the gate `g'.
743: */
744: unlock(g)
745: register GATE g;
746: {
747: g[0] = 0;
748: if (g[1]) {
749: g[1] = 0;
750: disflag = 1;
751: wakeup((char *)g);
752: }
753: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.