f6c250dad7c72a8e0e00a70425b5f028433c45da
[dragonfly.git] / sys / kern / kern_synch.c
1 /*-
2  * Copyright (c) 1982, 1986, 1990, 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *      @(#)kern_synch.c        8.9 (Berkeley) 5/19/95
39  * $FreeBSD: src/sys/kern/kern_synch.c,v 1.87.2.6 2002/10/13 07:29:53 kbyanc Exp $
40  * $DragonFly: src/sys/kern/kern_synch.c,v 1.35 2004/09/16 05:01:17 dillon Exp $
41  */
42
43 #include "opt_ktrace.h"
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/proc.h>
48 #include <sys/kernel.h>
49 #include <sys/signalvar.h>
50 #include <sys/resourcevar.h>
51 #include <sys/vmmeter.h>
52 #include <sys/sysctl.h>
53 #include <sys/thread2.h>
54 #ifdef KTRACE
55 #include <sys/uio.h>
56 #include <sys/ktrace.h>
57 #endif
58 #include <sys/xwait.h>
59
60 #include <machine/cpu.h>
61 #include <machine/ipl.h>
62 #include <machine/smp.h>
63
64 static void sched_setup (void *dummy);
65 SYSINIT(sched_setup, SI_SUB_KICK_SCHEDULER, SI_ORDER_FIRST, sched_setup, NULL)
66
67 int     hogticks;
68 int     lbolt;
69 int     sched_quantum;          /* Roundrobin scheduling quantum in ticks. */
70 int     ncpus;
71 int     ncpus2, ncpus2_shift, ncpus2_mask;
72
73 static struct callout loadav_callout;
74
75 struct loadavg averunnable =
76         { {0, 0, 0}, FSCALE };  /* load average, of runnable procs */
77 /*
78  * Constants for averages over 1, 5, and 15 minutes
79  * when sampling at 5 second intervals.
80  */
81 static fixpt_t cexp[3] = {
82         0.9200444146293232 * FSCALE,    /* exp(-1/12) */
83         0.9834714538216174 * FSCALE,    /* exp(-1/60) */
84         0.9944598480048967 * FSCALE,    /* exp(-1/180) */
85 };
86
87 static void     endtsleep (void *);
88 static void     loadav (void *arg);
89 static void     roundrobin (void *arg);
90 static void     schedcpu (void *arg);
91 static void     updatepri (struct proc *p);
92 static void     crit_panicints(void);
93
94 static int
95 sysctl_kern_quantum(SYSCTL_HANDLER_ARGS)
96 {
97         int error, new_val;
98
99         new_val = sched_quantum * tick;
100         error = sysctl_handle_int(oidp, &new_val, 0, req);
101         if (error != 0 || req->newptr == NULL)
102                 return (error);
103         if (new_val < tick)
104                 return (EINVAL);
105         sched_quantum = new_val / tick;
106         hogticks = 2 * sched_quantum;
107         return (0);
108 }
109
110 SYSCTL_PROC(_kern, OID_AUTO, quantum, CTLTYPE_INT|CTLFLAG_RW,
111         0, sizeof sched_quantum, sysctl_kern_quantum, "I", "");
112
113 int 
114 roundrobin_interval(void)
115 {
116         return (sched_quantum);
117 }
118
119 /*
120  * Force switch among equal priority processes every 100ms. 
121  *
122  * WARNING!  The MP lock is not held on ipi message remotes.
123  */
124 #ifdef SMP
125
126 static void
127 roundrobin_remote(void *arg)
128 {
129         struct proc *p = lwkt_preempted_proc();
130         if (p == NULL || RTP_PRIO_NEED_RR(p->p_rtprio.type))
131                 need_user_resched();
132 }
133
134 #endif
135
136 static void
137 roundrobin(void *arg)
138 {
139         struct proc *p = lwkt_preempted_proc();
140         if (p == NULL || RTP_PRIO_NEED_RR(p->p_rtprio.type))
141                 need_user_resched();
142 #ifdef SMP
143         lwkt_send_ipiq_mask(mycpu->gd_other_cpus, roundrobin_remote, NULL);
144 #endif
145         timeout(roundrobin, NULL, sched_quantum);
146 }
147
148 #ifdef SMP
149
150 void
151 resched_cpus(u_int32_t mask)
152 {
153         lwkt_send_ipiq_mask(mask, roundrobin_remote, NULL);
154 }
155
156 #endif
157
158 /*
159  * The load average is scaled by FSCALE (2048 typ).  The estimated cpu is
160  * incremented at a rate of ESTCPUVFREQ per second (40hz typ), but this is
161  * divided up across all cpu bound processes running in the system so an
162  * individual process will get less under load.  ESTCPULIM typicaly caps
163  * out at ESTCPUMAX (around 376, or 11 nice levels).
164  *
165  * Generally speaking the decay equation needs to break-even on growth
166  * at the limit at all load levels >= 1.0, so if the estimated cpu for
167  * a process increases by (ESTVCPUFREQ / load) per second, then the decay
168  * should reach this value when estcpu reaches ESTCPUMAX.  That calculation
169  * is:
170  *
171  *      ESTCPUMAX * decay = ESTCPUVFREQ / load
172  *      decay = ESTCPUVFREQ / (load * ESTCPUMAX)
173  *      decay = estcpu * 0.053 / load
174  *
175  * If the load is less then 1.0 we assume a load of 1.0.
176  */
177
178 #define cload(loadav)   ((loadav) < FSCALE ? FSCALE : (loadav))
179 #define decay_cpu(loadav,estcpu)        \
180     ((estcpu) * (FSCALE * ESTCPUVFREQ / ESTCPUMAX) / cload(loadav))
181
182 /* decay 95% of `p_pctcpu' in 60 seconds; see CCPU_SHIFT before changing */
183 static fixpt_t  ccpu = 0.95122942450071400909 * FSCALE; /* exp(-1/20) */
184 SYSCTL_INT(_kern, OID_AUTO, ccpu, CTLFLAG_RD, &ccpu, 0, "");
185
186 /* kernel uses `FSCALE', userland (SHOULD) use kern.fscale */
187 static int      fscale __unused = FSCALE;
188 SYSCTL_INT(_kern, OID_AUTO, fscale, CTLFLAG_RD, 0, FSCALE, "");
189
190 /*
191  * If `ccpu' is not equal to `exp(-1/20)' and you still want to use the
192  * faster/more-accurate formula, you'll have to estimate CCPU_SHIFT below
193  * and possibly adjust FSHIFT in "param.h" so that (FSHIFT >= CCPU_SHIFT).
194  *
195  * To estimate CCPU_SHIFT for exp(-1/20), the following formula was used:
196  *      1 - exp(-1/20) ~= 0.0487 ~= 0.0488 == 1 (fixed pt, *11* bits).
197  *
198  * If you don't want to bother with the faster/more-accurate formula, you
199  * can set CCPU_SHIFT to (FSHIFT + 1) which will use a slower/less-accurate
200  * (more general) method of calculating the %age of CPU used by a process.
201  */
202 #define CCPU_SHIFT      11
203
204 /*
205  * Recompute process priorities, once a second.
206  */
207 /* ARGSUSED */
208 static void
209 schedcpu(void *arg)
210 {
211         fixpt_t loadfac = averunnable.ldavg[0];
212         struct proc *p;
213         int s;
214         unsigned int ndecay;
215
216         FOREACH_PROC_IN_SYSTEM(p) {
217                 /*
218                  * Increment time in/out of memory and sleep time
219                  * (if sleeping).  We ignore overflow; with 16-bit int's
220                  * (remember them?) overflow takes 45 days.
221                  */
222                 p->p_swtime++;
223                 if (p->p_stat == SSLEEP || p->p_stat == SSTOP)
224                         p->p_slptime++;
225                 p->p_pctcpu = (p->p_pctcpu * ccpu) >> FSHIFT;
226
227                 /*
228                  * If the process has slept the entire second,
229                  * stop recalculating its priority until it wakes up.
230                  *
231                  * Note that interactive calculations do not occur for
232                  * long sleeps (because that isn't necessarily indicative
233                  * of an interactive process).
234                  */
235                 if (p->p_slptime > 1)
236                         continue;
237                 /* prevent state changes and protect run queue */
238                 s = splhigh();
239                 /*
240                  * p_cpticks runs at ESTCPUFREQ but must be divided by the
241                  * load average for par-100% use.  Higher p_interactive
242                  * values mean less interactive, lower values mean more 
243                  * interactive.
244                  */
245                 if ((((fixpt_t)p->p_cpticks * cload(loadfac)) >> FSHIFT)  >
246                     ESTCPUFREQ / 4) {
247                         if (p->p_interactive < 127)
248                                 ++p->p_interactive;
249                 } else {
250                         if (p->p_interactive > -127)
251                                 --p->p_interactive;
252                 }
253                 /*
254                  * p_pctcpu is only for ps.
255                  */
256 #if     (FSHIFT >= CCPU_SHIFT)
257                 p->p_pctcpu += (ESTCPUFREQ == 100)?
258                         ((fixpt_t) p->p_cpticks) << (FSHIFT - CCPU_SHIFT):
259                         100 * (((fixpt_t) p->p_cpticks)
260                                 << (FSHIFT - CCPU_SHIFT)) / ESTCPUFREQ;
261 #else
262                 p->p_pctcpu += ((FSCALE - ccpu) *
263                         (p->p_cpticks * FSCALE / ESTCPUFREQ)) >> FSHIFT;
264 #endif
265                 p->p_cpticks = 0;
266                 ndecay = decay_cpu(loadfac, p->p_estcpu);
267                 if (p->p_estcpu > ndecay)
268                         p->p_estcpu -= ndecay;
269                 else
270                         p->p_estcpu = 0;
271                 resetpriority(p);
272                 splx(s);
273         }
274         wakeup((caddr_t)&lbolt);
275         timeout(schedcpu, (void *)0, hz);
276 }
277
278 /*
279  * Recalculate the priority of a process after it has slept for a while.
280  * For all load averages >= 1 and max p_estcpu of 255, sleeping for at
281  * least six times the loadfactor will decay p_estcpu to zero.
282  */
283 static void
284 updatepri(struct proc *p)
285 {
286         unsigned int ndecay;
287
288         ndecay = decay_cpu(averunnable.ldavg[0], p->p_estcpu) * p->p_slptime;
289         if (p->p_estcpu > ndecay)
290                 p->p_estcpu -= ndecay;
291         else
292                 p->p_estcpu = 0;
293         resetpriority(p);
294 }
295
296 /*
297  * We're only looking at 7 bits of the address; everything is
298  * aligned to 4, lots of things are aligned to greater powers
299  * of 2.  Shift right by 8, i.e. drop the bottom 256 worth.
300  */
301 #define TABLESIZE       128
302 static TAILQ_HEAD(slpquehead, thread) slpque[TABLESIZE];
303 #define LOOKUP(x)       (((intptr_t)(x) >> 8) & (TABLESIZE - 1))
304
305 /*
306  * During autoconfiguration or after a panic, a sleep will simply
307  * lower the priority briefly to allow interrupts, then return.
308  * The priority to be used (safepri) is machine-dependent, thus this
309  * value is initialized and maintained in the machine-dependent layers.
310  * This priority will typically be 0, or the lowest priority
311  * that is safe for use on the interrupt stack; it can be made
312  * higher to block network software interrupts after panics.
313  */
314 int safepri;
315
316 void
317 sleepinit(void)
318 {
319         int i;
320
321         sched_quantum = hz/10;
322         hogticks = 2 * sched_quantum;
323         for (i = 0; i < TABLESIZE; i++)
324                 TAILQ_INIT(&slpque[i]);
325 }
326
327 /*
328  * General sleep call.  Suspends the current process until a wakeup is
329  * performed on the specified identifier.  The process will then be made
330  * runnable with the specified priority.  Sleeps at most timo/hz seconds
331  * (0 means no timeout).  If flags includes PCATCH flag, signals are checked
332  * before and after sleeping, else signals are not checked.  Returns 0 if
333  * awakened, EWOULDBLOCK if the timeout expires.  If PCATCH is set and a
334  * signal needs to be delivered, ERESTART is returned if the current system
335  * call should be restarted if possible, and EINTR is returned if the system
336  * call should be interrupted by the signal (return EINTR).
337  *
338  * Note that if we are a process, we release_curproc() before messing with
339  * the LWKT scheduler.
340  */
341 int
342 tsleep(void *ident, int flags, const char *wmesg, int timo)
343 {
344         struct thread *td = curthread;
345         struct proc *p = td->td_proc;           /* may be NULL */
346         int sig = 0, catch = flags & PCATCH;
347         int id = LOOKUP(ident);
348         struct callout thandle;
349
350         /*
351          * NOTE: removed KTRPOINT, it could cause races due to blocking
352          * even in stable.  Just scrap it for now.
353          */
354         if (cold || panicstr) {
355                 /*
356                  * After a panic, or during autoconfiguration,
357                  * just give interrupts a chance, then just return;
358                  * don't run any other procs or panic below,
359                  * in case this is the idle process and already asleep.
360                  */
361                 crit_panicints();
362                 return (0);
363         }
364         KKASSERT(td != &mycpu->gd_idlethread);  /* you must be kidding! */
365         crit_enter_quick(td);
366         KASSERT(ident != NULL, ("tsleep: no ident"));
367         KASSERT(p == NULL || p->p_stat == SRUN, ("tsleep %p %s %d",
368                 ident, wmesg, p->p_stat));
369
370         td->td_wchan = ident;
371         td->td_wmesg = wmesg;
372         if (p) {
373                 if (flags & PNORESCHED)
374                         td->td_flags |= TDF_NORESCHED;
375                 release_curproc(p);
376                 p->p_slptime = 0;
377         }
378         lwkt_deschedule_self(td);
379         TAILQ_INSERT_TAIL(&slpque[id], td, td_threadq);
380         if (timo) {
381                 callout_init(&thandle);
382                 callout_reset(&thandle, timo, endtsleep, td);
383         }
384         /*
385          * We put ourselves on the sleep queue and start our timeout
386          * before calling CURSIG, as we could stop there, and a wakeup
387          * or a SIGCONT (or both) could occur while we were stopped.
388          * A SIGCONT would cause us to be marked as SSLEEP
389          * without resuming us, thus we must be ready for sleep
390          * when CURSIG is called.  If the wakeup happens while we're
391          * stopped, td->td_wchan will be 0 upon return from CURSIG.
392          */
393         if (p) {
394                 if (catch) {
395                         p->p_flag |= P_SINTR;
396                         if ((sig = CURSIG(p))) {
397                                 if (td->td_wchan) {
398                                         unsleep(td);
399                                         lwkt_schedule_self(td);
400                                 }
401                                 p->p_stat = SRUN;
402                                 goto resume;
403                         }
404                         if (td->td_wchan == NULL) {
405                                 catch = 0;
406                                 goto resume;
407                         }
408                 } else {
409                         sig = 0;
410                 }
411
412                 /*
413                  * If we are not the current process we have to remove ourself
414                  * from the run queue.
415                  */
416                 KASSERT(p->p_stat == SRUN, ("PSTAT NOT SRUN %d %d", p->p_pid, p->p_stat));
417                 /*
418                  * If this is the current 'user' process schedule another one.
419                  */
420                 clrrunnable(p, SSLEEP);
421                 p->p_stats->p_ru.ru_nvcsw++;
422                 mi_switch(p);
423                 KASSERT(p->p_stat == SRUN, ("tsleep: stat not srun"));
424         } else {
425                 lwkt_switch();
426         }
427 resume:
428         if (p)
429                 p->p_flag &= ~P_SINTR;
430         crit_exit_quick(td);
431         td->td_flags &= ~TDF_NORESCHED;
432         if (td->td_flags & TDF_TIMEOUT) {
433                 td->td_flags &= ~TDF_TIMEOUT;
434                 if (sig == 0)
435                         return (EWOULDBLOCK);
436         } else if (timo) {
437                 callout_stop(&thandle);
438         } else if (td->td_wmesg) {
439                 /*
440                  * This can happen if a thread is woken up directly.  Clear
441                  * wmesg to avoid debugging confusion.
442                  */
443                 td->td_wmesg = NULL;
444         }
445         /* inline of iscaught() */
446         if (p) {
447                 if (catch && (sig != 0 || (sig = CURSIG(p)))) {
448                         if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig))
449                                 return (EINTR);
450                         return (ERESTART);
451                 }
452         }
453         return (0);
454 }
455
456 /*
457  * Implement the timeout for tsleep.  We interlock against
458  * wchan when setting TDF_TIMEOUT.  For processes we remove
459  * the sleep if the process is stopped rather then sleeping,
460  * so it remains stopped.
461  */
462 static void
463 endtsleep(void *arg)
464 {
465         thread_t td = arg;
466         struct proc *p;
467
468         crit_enter();
469         if (td->td_wchan) {
470                 td->td_flags |= TDF_TIMEOUT;
471                 if ((p = td->td_proc) != NULL) {
472                         if (p->p_stat == SSLEEP)
473                                 setrunnable(p);
474                         else
475                                 unsleep(td);
476                 } else {
477                         unsleep(td);
478                         lwkt_schedule(td);
479                 }
480         }
481         crit_exit();
482 }
483
484 /*
485  * Remove a process from its wait queue
486  */
487 void
488 unsleep(struct thread *td)
489 {
490         crit_enter();
491         if (td->td_wchan) {
492 #if 0
493                 if (p->p_flag & P_XSLEEP) {
494                         struct xwait *w = p->p_wchan;
495                         TAILQ_REMOVE(&w->waitq, p, p_procq);
496                         p->p_flag &= ~P_XSLEEP;
497                 } else
498 #endif
499                 TAILQ_REMOVE(&slpque[LOOKUP(td->td_wchan)], td, td_threadq);
500                 td->td_wchan = NULL;
501         }
502         crit_exit();
503 }
504
505 #if 0
506 /*
507  * Make all processes sleeping on the explicit lock structure runnable.
508  */
509 void
510 xwakeup(struct xwait *w)
511 {
512         struct proc *p;
513
514         crit_enter();
515         ++w->gen;
516         while ((p = TAILQ_FIRST(&w->waitq)) != NULL) {
517                 TAILQ_REMOVE(&w->waitq, p, p_procq);
518                 KASSERT(p->p_wchan == w && (p->p_flag & P_XSLEEP),
519                     ("xwakeup: wchan mismatch for %p (%p/%p) %08x", p, p->p_wchan, w, p->p_flag & P_XSLEEP));
520                 p->p_wchan = NULL;
521                 p->p_flag &= ~P_XSLEEP;
522                 if (p->p_stat == SSLEEP) {
523                         /* OPTIMIZED EXPANSION OF setrunnable(p); */
524                         if (p->p_slptime > 1)
525                                 updatepri(p);
526                         p->p_slptime = 0;
527                         p->p_stat = SRUN;
528                         if (p->p_flag & P_INMEM) {
529                                 lwkt_schedule(td);
530                         } else {
531                                 p->p_flag |= P_SWAPINREQ;
532                                 wakeup((caddr_t)&proc0);
533                         }
534                 }
535         }
536         crit_exit();
537 }
538 #endif
539
540 /*
541  * Make all processes sleeping on the specified identifier runnable.
542  */
543 static void
544 _wakeup(void *ident, int count)
545 {
546         struct slpquehead *qp;
547         struct thread *td;
548         struct thread *ntd;
549         struct proc *p;
550         int id = LOOKUP(ident);
551
552         crit_enter();
553         qp = &slpque[id];
554 restart:
555         for (td = TAILQ_FIRST(qp); td != NULL; td = ntd) {
556                 ntd = TAILQ_NEXT(td, td_threadq);
557                 if (td->td_wchan == ident) {
558                         TAILQ_REMOVE(qp, td, td_threadq);
559                         td->td_wchan = NULL;
560                         if ((p = td->td_proc) != NULL && p->p_stat == SSLEEP) {
561                                 /* OPTIMIZED EXPANSION OF setrunnable(p); */
562                                 if (p->p_slptime > 1)
563                                         updatepri(p);
564                                 p->p_slptime = 0;
565                                 p->p_stat = SRUN;
566                                 if (p->p_flag & P_INMEM) {
567                                         /*
568                                          * LWKT scheduled now, there is no
569                                          * userland runq interaction until
570                                          * the thread tries to return to user
571                                          * mode.
572                                          *
573                                          * setrunqueue(p); 
574                                          */
575                                         lwkt_schedule(td);
576                                 } else {
577                                         p->p_flag |= P_SWAPINREQ;
578                                         wakeup((caddr_t)&proc0);
579                                 }
580                                 /* END INLINE EXPANSION */
581                         } else if (p == NULL) {
582                                 lwkt_schedule(td);
583                         }
584                         if (--count == 0)
585                                 break;
586                         goto restart;
587                 }
588         }
589         crit_exit();
590 }
591
592 void
593 wakeup(void *ident)
594 {
595     _wakeup(ident, 0);
596 }
597
598 void
599 wakeup_one(void *ident)
600 {
601     _wakeup(ident, 1);
602 }
603
604 /*
605  * The machine independent parts of mi_switch().
606  *
607  * 'p' must be the current process.
608  */
609 void
610 mi_switch(struct proc *p)
611 {
612         thread_t td = p->p_thread;
613         struct rlimit *rlim;
614         u_int64_t ttime;
615
616         KKASSERT(td == mycpu->gd_curthread);
617
618         crit_enter_quick(td);
619
620         /*
621          * Check if the process exceeds its cpu resource allocation.
622          * If over max, kill it.  Time spent in interrupts is not 
623          * included.  YYY 64 bit match is expensive.  Ick.
624          */
625         ttime = td->td_sticks + td->td_uticks;
626         if (p->p_stat != SZOMB && p->p_limit->p_cpulimit != RLIM_INFINITY &&
627             ttime > p->p_limit->p_cpulimit) {
628                 rlim = &p->p_rlimit[RLIMIT_CPU];
629                 if (ttime / (rlim_t)1000000 >= rlim->rlim_max) {
630                         killproc(p, "exceeded maximum CPU limit");
631                 } else {
632                         psignal(p, SIGXCPU);
633                         if (rlim->rlim_cur < rlim->rlim_max) {
634                                 /* XXX: we should make a private copy */
635                                 rlim->rlim_cur += 5;
636                         }
637                 }
638         }
639
640         /*
641          * If we are in a SSTOPped state we deschedule ourselves.  
642          * YYY this needs to be cleaned up, remember that LWKTs stay on
643          * their run queue which works differently then the user scheduler
644          * which removes the process from the runq when it runs it.
645          */
646         mycpu->gd_cnt.v_swtch++;
647         if (p->p_stat == SSTOP)
648                 lwkt_deschedule_self(td);
649         lwkt_switch();
650         crit_exit_quick(td);
651 }
652
653 /*
654  * Change process state to be runnable,
655  * placing it on the run queue if it is in memory,
656  * and awakening the swapper if it isn't in memory.
657  */
658 void
659 setrunnable(struct proc *p)
660 {
661         int s;
662
663         s = splhigh();
664         switch (p->p_stat) {
665         case 0:
666         case SRUN:
667         case SZOMB:
668         default:
669                 panic("setrunnable");
670         case SSTOP:
671         case SSLEEP:
672                 unsleep(p->p_thread);   /* e.g. when sending signals */
673                 break;
674
675         case SIDL:
676                 break;
677         }
678         p->p_stat = SRUN;
679
680         /*
681          * The process is controlled by LWKT at this point, we do not mess
682          * around with the userland scheduler until the thread tries to 
683          * return to user mode.
684          */
685 #if 0
686         if (p->p_flag & P_INMEM)
687                 setrunqueue(p);
688 #endif
689         if (p->p_flag & P_INMEM)
690                 lwkt_schedule(p->p_thread);
691         splx(s);
692         if (p->p_slptime > 1)
693                 updatepri(p);
694         p->p_slptime = 0;
695         if ((p->p_flag & P_INMEM) == 0) {
696                 p->p_flag |= P_SWAPINREQ;
697                 wakeup((caddr_t)&proc0);
698         }
699 }
700
701 /*
702  * Change the process state to NOT be runnable, removing it from the run
703  * queue.
704  */
705 void
706 clrrunnable(struct proc *p, int stat)
707 {
708         crit_enter_quick(p->p_thread);
709         if (p->p_stat == SRUN && (p->p_flag & P_ONRUNQ))
710                 remrunqueue(p);
711         p->p_stat = stat;
712         crit_exit_quick(p->p_thread);
713 }
714
715 /*
716  * Compute the priority of a process when running in user mode.
717  * Arrange to reschedule if the resulting priority is better
718  * than that of the current process.
719  */
720 void
721 resetpriority(struct proc *p)
722 {
723         int newpriority;
724         int interactive;
725         int opq;
726         int npq;
727
728         /*
729          * Set p_priority for general process comparisons
730          */
731         switch(p->p_rtprio.type) {
732         case RTP_PRIO_REALTIME:
733                 p->p_priority = PRIBASE_REALTIME + p->p_rtprio.prio;
734                 return;
735         case RTP_PRIO_NORMAL:
736                 break;
737         case RTP_PRIO_IDLE:
738                 p->p_priority = PRIBASE_IDLE + p->p_rtprio.prio;
739                 return;
740         case RTP_PRIO_THREAD:
741                 p->p_priority = PRIBASE_THREAD + p->p_rtprio.prio;
742                 return;
743         }
744
745         /*
746          * NORMAL priorities fall through.  These are based on niceness
747          * and cpu use.  Lower numbers == higher priorities.
748          */
749         newpriority = (int)(NICE_ADJUST(p->p_nice - PRIO_MIN) +
750                         p->p_estcpu / ESTCPURAMP);
751
752         /*
753          * p_interactive is -128 to +127 and represents very long term
754          * interactivity or batch (whereas estcpu is a much faster variable).
755          * Interactivity can modify the priority by up to 8 units either way.
756          * (8 units == approximately 4 nice levels).
757          */
758         interactive = p->p_interactive / 10;
759         newpriority += interactive;
760
761         newpriority = min(newpriority, MAXPRI);
762         newpriority = max(newpriority, 0);
763         npq = newpriority / PPQ;
764         crit_enter();
765         opq = (p->p_priority & PRIMASK) / PPQ;
766         if (p->p_stat == SRUN && (p->p_flag & P_ONRUNQ) && opq != npq) {
767                 /*
768                  * We have to move the process to another queue
769                  */
770                 remrunqueue(p);
771                 p->p_priority = PRIBASE_NORMAL + newpriority;
772                 setrunqueue(p);
773         } else {
774                 /*
775                  * We can just adjust the priority and it will be picked
776                  * up later.
777                  */
778                 KKASSERT(opq == npq || (p->p_flag & P_ONRUNQ) == 0);
779                 p->p_priority = PRIBASE_NORMAL + newpriority;
780         }
781         crit_exit();
782 }
783
784 /*
785  * Compute a tenex style load average of a quantity on
786  * 1, 5 and 15 minute intervals.
787  */
788 static void
789 loadav(void *arg)
790 {
791         int i, nrun;
792         struct loadavg *avg;
793         struct proc *p;
794         thread_t td;
795
796         avg = &averunnable;
797         nrun = 0;
798         FOREACH_PROC_IN_SYSTEM(p) {
799                 switch (p->p_stat) {
800                 case SRUN:
801                         if ((td = p->p_thread) == NULL)
802                                 break;
803                         if (td->td_flags & TDF_BLOCKED)
804                                 break;
805                         /* fall through */
806                 case SIDL:
807                         nrun++;
808                         break;
809                 default:
810                         break;
811                 }
812         }
813         for (i = 0; i < 3; i++)
814                 avg->ldavg[i] = (cexp[i] * avg->ldavg[i] +
815                     nrun * FSCALE * (FSCALE - cexp[i])) >> FSHIFT;
816
817         /*
818          * Schedule the next update to occur after 5 seconds, but add a
819          * random variation to avoid synchronisation with processes that
820          * run at regular intervals.
821          */
822         callout_reset(&loadav_callout, hz * 4 + (int)(random() % (hz * 2 + 1)),
823             loadav, NULL);
824 }
825
826 /* ARGSUSED */
827 static void
828 sched_setup(void *dummy)
829 {
830
831         callout_init(&loadav_callout);
832
833         /* Kick off timeout driven events by calling first time. */
834         roundrobin(NULL);
835         schedcpu(NULL);
836         loadav(NULL);
837 }
838
839 /*
840  * We adjust the priority of the current process.  The priority of
841  * a process gets worse as it accumulates CPU time.  The cpu usage
842  * estimator (p_estcpu) is increased here.  resetpriority() will
843  * compute a different priority each time p_estcpu increases by
844  * INVERSE_ESTCPU_WEIGHT * (until MAXPRI is reached).
845  *
846  * The cpu usage estimator ramps up quite quickly when the process is 
847  * running (linearly), and decays away exponentially, at a rate which
848  * is proportionally slower when the system is busy.  The basic principle
849  * is that the system will 90% forget that the process used a lot of CPU
850  * time in 5 * loadav seconds.  This causes the system to favor processes
851  * which haven't run much recently, and to round-robin among other processes.
852  *
853  * The actual schedulerclock interrupt rate is ESTCPUFREQ, but we generally
854  * want to ramp-up at a faster rate, ESTCPUVFREQ, so p_estcpu is scaled
855  * by (ESTCPUVFREQ / ESTCPUFREQ).  You can control the ramp-up/ramp-down
856  * rate by adjusting ESTCPUVFREQ in sys/proc.h in integer multiples
857  * of ESTCPUFREQ.
858  *
859  * WARNING! called from a fast-int or an IPI, the MP lock MIGHT NOT BE HELD
860  * and we cannot block.
861  */
862 void
863 schedulerclock(void *dummy)
864 {
865         struct thread *td;
866         struct proc *p;
867
868         td = curthread;
869         if ((p = td->td_proc) != NULL) {
870                 p->p_cpticks++;         /* cpticks runs at ESTCPUFREQ */
871                 p->p_estcpu = ESTCPULIM(p->p_estcpu + ESTCPUVFREQ / ESTCPUFREQ);
872                 if (try_mplock()) {
873                         resetpriority(p);
874                         rel_mplock();
875                 }
876         }
877 }
878
879 static
880 void
881 crit_panicints(void)
882 {
883     int s;
884     int cpri;
885
886     s = splhigh();
887     cpri = crit_panic_save();
888     splx(safepri);
889     crit_panic_restore(cpri);
890     splx(s);
891 }
892