Init

sys/lwp/schedule.c

@@ -0,0 +1,131 @@
+/* Copyright (C) 1986 Sun Microsystems Inc. */
+
+#include <lwp/common.h>
+#include <lwp/queue.h>
+#include <machlwp/machdep.h>
+#include <lwp/lwperror.h>
+#include <lwp/schedule.h>
+#include <lwp/alloc.h>
+#include <lwp/condvar.h>
+#include <lwp/process.h>
+#include <lwp/monitor.h>
+#include <lwp/cntxt.h>
+#ifndef lint
+SCCSID(@(#) schedule.c 1.1 94/10/31 Copyr 1987 Sun Micro);
+#endif lint
+
+lwp_t Nullproc;			/* have something for lwp_errno until init */
+lwp_t *__Curproc = &Nullproc;	/* the current running process */
+qheader_t *__RunQ = QHNULL;	/* set of run queues (1 per priority) */
+int __MaxPrio = MINPRIO;	/* highest available scheduling priority */
+int __UniqId = 0;		/* unique id for locks and keys */
+
+extern label_t kernelret;
+
+/*
+ * __lwp_init: initialize library.
+ * N.B. Order of initialization is important.
+ */
+void
+__lwp_init()
+{
+	extern void __init_util();
+
+	INIT_QUEUE(&Nullproc.lwp_ctx);
+	Nullproc.lwp_prio = NUGPRIO;
+	__RunQ = (qheader_t *)MEM_ALLOC(sizeof (qheader_t) * (__MaxPrio + 1));
+	__init_lwp();
+	__init_mon();
+	__init_cv();
+	__init_machdep();
+	__init_ctx();
+	__init_util();
+}
+
+/*
+ * Scheduler loop for the set of lwps.
+ * Find the highest priority runnable lwp and set it going.
+ * If returning from an interrupt to the same process, it is probably cheaper
+ * to restore the saved context than to return back through the call
+ * chain to the rti.
+ * We had to always save full context on interrupt because we didn't know
+ * in advance if this would be the case.
+ */
+
+void
+__schedule()
+{
+	register int i;
+	register lwp_t *oldproc = __Curproc;
+	register lwp_t *newproc;
+	register qheader_t *rq;
+	int s;
+
+	s = splclock();
+#ifdef	MULTIPROCESSOR
+	klock_require(__FILE__, __LINE__, "__schedule");
+#endif	MULTIPROCESSOR
+	LWPTRACE(tr_SCHEDULE, 5, ("scheduling\n"));
+
+	for (i = __MaxPrio; i >= NUGPRIO; i--) {
+		rq = &__RunQ[i];
+#ifndef	MULTIPROCESSOR
+		if (!ISEMPTYQ(rq)) {
+			newproc = __Curproc = (lwp_t *)FIRSTQ(rq);
+#else	MULTIPROCESSOR
+		for (newproc = (lwp_t *)FIRSTQ(rq);
+		     newproc != (lwp_t *)0;
+		     newproc = newproc->lwp_next)
+		    if (lwp_can_run(newproc)) {
+			__Curproc = newproc;
+#endif	MULTIPROCESSOR
+			if (((oldproc != LWPNULL) &&
+			     !ISEMPTYQ(&oldproc->lwp_ctx)) ||
+			    !ISEMPTYQ(&newproc->lwp_ctx)) {
+				__ctx_change(oldproc, newproc);
+			}
+			LWPTRACE(tr_SCHEDULE, 2,
+				 ("about to schedule %x\n", (int)__Curproc));
+			if (!newproc->lwp_full) {
+
+				/*
+				 * do a simple context switch (only non-volatile
+				 * registers, no temps or sr.)
+				 * This is the case on a yield or where
+				 * there is no asynchronous event indirectly
+				 * responsible for the context switch (i.e.,
+				 * waiting for a monitor or a message).
+				 */
+
+				LWPTRACE(tr_SCHEDULE, 2, ("swtch call\n"));
+				(void) splx(s);
+				CSWTCH();
+
+				/*NOTREACHED*/
+
+			} else {
+
+				/*
+				 * do a full context switch,restoring temps,sr,
+				 * etc., as needed.
+				 */
+
+				LWPTRACE(tr_SCHEDULE, 2, ("full swtch call\n"));
+				__panic("full_swtch attempt");
+				/* NOTREACHED */
+			}
+			__panic("return from swtch");
+			/* NOTREACHED */
+		}
+	}
+
+	LWPTRACE(tr_SCHEDULE, 1, ("schedule exiting\n"));
+
+	/* return to resume, etc. */
+	__Curproc = &Nullproc;
+	(void) splx(s);
+#ifdef	MULTIPROCESSOR
+	klock_require(__FILE__, __LINE__, "__schedule");
+#endif	MULTIPROCESSOR
+	longjmp(&kernelret);
+}