Do some fairly major include file cleanups to further separate kernelland
[dragonfly.git] / sys / kern / lwkt_thread.c
1 /*
2  * Copyright (c) 2003 Matthew Dillon <dillon@backplane.com>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $DragonFly: src/sys/kern/lwkt_thread.c,v 1.42 2003/11/21 22:46:08 dillon Exp $
27  */
28
29 /*
30  * Each cpu in a system has its own self-contained light weight kernel
31  * thread scheduler, which means that generally speaking we only need
32  * to use a critical section to avoid problems.  Foreign thread 
33  * scheduling is queued via (async) IPIs.
34  *
35  * NOTE: on UP machines smp_active is defined to be 0.  On SMP machines
36  * smp_active is 0 prior to SMP activation, then it is 1.  The LWKT module
37  * uses smp_active to optimize UP builds and to avoid sending IPIs during
38  * early boot (primarily interrupt and network thread initialization).
39  */
40
41 #ifdef _KERNEL
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/kernel.h>
46 #include <sys/proc.h>
47 #include <sys/rtprio.h>
48 #include <sys/queue.h>
49 #include <sys/thread2.h>
50 #include <sys/sysctl.h>
51 #include <sys/kthread.h>
52 #include <machine/cpu.h>
53 #include <sys/lock.h>
54
55 #include <vm/vm.h>
56 #include <vm/vm_param.h>
57 #include <vm/vm_kern.h>
58 #include <vm/vm_object.h>
59 #include <vm/vm_page.h>
60 #include <vm/vm_map.h>
61 #include <vm/vm_pager.h>
62 #include <vm/vm_extern.h>
63 #include <vm/vm_zone.h>
64
65 #include <machine/stdarg.h>
66 #include <machine/ipl.h>
67 #include <machine/smp.h>
68
69 #define THREAD_STACK    (UPAGES * PAGE_SIZE)
70
71 #else
72
73 #include <sys/stdint.h>
74 #include <liblwkt/thread.h>
75 #include <sys/thread.h>
76 #include <sys/msgport.h>
77 #include <sys/errno.h>
78 #include <liblwkt/globaldata.h>
79 #include <sys/thread2.h>
80 #include <sys/msgport2.h>
81 #include <stdlib.h>
82
83 #endif
84
85 static int untimely_switch = 0;
86 #ifdef INVARIANTS
87 static int token_debug = 0;
88 #endif
89 static __int64_t switch_count = 0;
90 static __int64_t preempt_hit = 0;
91 static __int64_t preempt_miss = 0;
92 static __int64_t preempt_weird = 0;
93 static __int64_t ipiq_count = 0;
94 static __int64_t ipiq_fifofull = 0;
95
96 #ifdef _KERNEL
97
98 SYSCTL_INT(_lwkt, OID_AUTO, untimely_switch, CTLFLAG_RW, &untimely_switch, 0, "");
99 #ifdef INVARIANTS
100 SYSCTL_INT(_lwkt, OID_AUTO, token_debug, CTLFLAG_RW, &token_debug, 0, "");
101 #endif
102 SYSCTL_QUAD(_lwkt, OID_AUTO, switch_count, CTLFLAG_RW, &switch_count, 0, "");
103 SYSCTL_QUAD(_lwkt, OID_AUTO, preempt_hit, CTLFLAG_RW, &preempt_hit, 0, "");
104 SYSCTL_QUAD(_lwkt, OID_AUTO, preempt_miss, CTLFLAG_RW, &preempt_miss, 0, "");
105 SYSCTL_QUAD(_lwkt, OID_AUTO, preempt_weird, CTLFLAG_RW, &preempt_weird, 0, "");
106 SYSCTL_QUAD(_lwkt, OID_AUTO, ipiq_count, CTLFLAG_RW, &ipiq_count, 0, "");
107 SYSCTL_QUAD(_lwkt, OID_AUTO, ipiq_fifofull, CTLFLAG_RW, &ipiq_fifofull, 0, "");
108
109 #endif
110
111 /*
112  * These helper procedures handle the runq, they can only be called from
113  * within a critical section.
114  *
115  * WARNING!  Prior to SMP being brought up it is possible to enqueue and
116  * dequeue threads belonging to other cpus, so be sure to use td->td_gd
117  * instead of 'mycpu' when referencing the globaldata structure.   Once
118  * SMP live enqueuing and dequeueing only occurs on the current cpu.
119  */
120 static __inline
121 void
122 _lwkt_dequeue(thread_t td)
123 {
124     if (td->td_flags & TDF_RUNQ) {
125         int nq = td->td_pri & TDPRI_MASK;
126         struct globaldata *gd = td->td_gd;
127
128         td->td_flags &= ~TDF_RUNQ;
129         TAILQ_REMOVE(&gd->gd_tdrunq[nq], td, td_threadq);
130         /* runqmask is passively cleaned up by the switcher */
131     }
132 }
133
134 static __inline
135 void
136 _lwkt_enqueue(thread_t td)
137 {
138     if ((td->td_flags & TDF_RUNQ) == 0) {
139         int nq = td->td_pri & TDPRI_MASK;
140         struct globaldata *gd = td->td_gd;
141
142         td->td_flags |= TDF_RUNQ;
143         TAILQ_INSERT_TAIL(&gd->gd_tdrunq[nq], td, td_threadq);
144         gd->gd_runqmask |= 1 << nq;
145     }
146 }
147
148 static __inline
149 int
150 _lwkt_wantresched(thread_t ntd, thread_t cur)
151 {
152     return((ntd->td_pri & TDPRI_MASK) > (cur->td_pri & TDPRI_MASK));
153 }
154
155 /*
156  * LWKTs operate on a per-cpu basis
157  *
158  * WARNING!  Called from early boot, 'mycpu' may not work yet.
159  */
160 void
161 lwkt_gdinit(struct globaldata *gd)
162 {
163     int i;
164
165     for (i = 0; i < sizeof(gd->gd_tdrunq)/sizeof(gd->gd_tdrunq[0]); ++i)
166         TAILQ_INIT(&gd->gd_tdrunq[i]);
167     gd->gd_runqmask = 0;
168     TAILQ_INIT(&gd->gd_tdallq);
169 }
170
171 /*
172  * Initialize a thread wait structure prior to first use.
173  *
174  * NOTE!  called from low level boot code, we cannot do anything fancy!
175  */
176 void
177 lwkt_init_wait(lwkt_wait_t w)
178 {
179     TAILQ_INIT(&w->wa_waitq);
180 }
181
182 /*
183  * Create a new thread.  The thread must be associated with a process context
184  * or LWKT start address before it can be scheduled.  If the target cpu is
185  * -1 the thread will be created on the current cpu.
186  *
187  * If you intend to create a thread without a process context this function
188  * does everything except load the startup and switcher function.
189  */
190 thread_t
191 lwkt_alloc_thread(struct thread *td, int cpu)
192 {
193     void *stack;
194     int flags = 0;
195
196     if (td == NULL) {
197         crit_enter();
198         if (mycpu->gd_tdfreecount > 0) {
199             --mycpu->gd_tdfreecount;
200             td = TAILQ_FIRST(&mycpu->gd_tdfreeq);
201             KASSERT(td != NULL && (td->td_flags & TDF_RUNNING) == 0,
202                 ("lwkt_alloc_thread: unexpected NULL or corrupted td"));
203             TAILQ_REMOVE(&mycpu->gd_tdfreeq, td, td_threadq);
204             crit_exit();
205             stack = td->td_kstack;
206             flags = td->td_flags & (TDF_ALLOCATED_STACK|TDF_ALLOCATED_THREAD);
207         } else {
208             crit_exit();
209 #ifdef _KERNEL
210             td = zalloc(thread_zone);
211 #else
212             td = malloc(sizeof(struct thread));
213 #endif
214             td->td_kstack = NULL;
215             flags |= TDF_ALLOCATED_THREAD;
216         }
217     }
218     if ((stack = td->td_kstack) == NULL) {
219 #ifdef _KERNEL
220         stack = (void *)kmem_alloc(kernel_map, THREAD_STACK);
221 #else
222         stack = liblwkt_alloc_stack(THREAD_STACK);
223 #endif
224         flags |= TDF_ALLOCATED_STACK;
225     }
226     if (cpu < 0)
227         lwkt_init_thread(td, stack, flags, mycpu);
228     else
229         lwkt_init_thread(td, stack, flags, globaldata_find(cpu));
230     return(td);
231 }
232
233 /*
234  * Initialize a preexisting thread structure.  This function is used by
235  * lwkt_alloc_thread() and also used to initialize the per-cpu idlethread.
236  *
237  * All threads start out in a critical section at a priority of
238  * TDPRI_KERN_DAEMON.  Higher level code will modify the priority as
239  * appropriate.  This function may send an IPI message when the 
240  * requested cpu is not the current cpu and consequently gd_tdallq may
241  * not be initialized synchronously from the point of view of the originating
242  * cpu.
243  *
244  * NOTE! we have to be careful in regards to creating threads for other cpus
245  * if SMP has not yet been activated.
246  */
247 static void
248 lwkt_init_thread_remote(void *arg)
249 {
250     thread_t td = arg;
251
252     TAILQ_INSERT_TAIL(&td->td_gd->gd_tdallq, td, td_allq);
253 }
254
255 void
256 lwkt_init_thread(thread_t td, void *stack, int flags, struct globaldata *gd)
257 {
258     bzero(td, sizeof(struct thread));
259     td->td_kstack = stack;
260     td->td_flags |= flags;
261     td->td_gd = gd;
262     td->td_pri = TDPRI_KERN_DAEMON + TDPRI_CRIT;
263     lwkt_init_port(&td->td_msgport, td);
264     pmap_init_thread(td);
265     if (smp_active == 0 || gd == mycpu) {
266         crit_enter();
267         TAILQ_INSERT_TAIL(&gd->gd_tdallq, td, td_allq);
268         crit_exit();
269     } else {
270         lwkt_send_ipiq(gd->gd_cpuid, lwkt_init_thread_remote, td);
271     }
272 }
273
274 void
275 lwkt_set_comm(thread_t td, const char *ctl, ...)
276 {
277     __va_list va;
278
279     __va_start(va, ctl);
280     vsnprintf(td->td_comm, sizeof(td->td_comm), ctl, va);
281     __va_end(va);
282 }
283
284 void
285 lwkt_hold(thread_t td)
286 {
287     ++td->td_refs;
288 }
289
290 void
291 lwkt_rele(thread_t td)
292 {
293     KKASSERT(td->td_refs > 0);
294     --td->td_refs;
295 }
296
297 void
298 lwkt_wait_free(thread_t td)
299 {
300     while (td->td_refs)
301         tsleep(td, 0, "tdreap", hz);
302 }
303
304 void
305 lwkt_free_thread(thread_t td)
306 {
307     struct globaldata *gd = mycpu;
308
309     KASSERT((td->td_flags & TDF_RUNNING) == 0,
310         ("lwkt_free_thread: did not exit! %p", td));
311
312     crit_enter();
313     TAILQ_REMOVE(&gd->gd_tdallq, td, td_allq);
314     if (gd->gd_tdfreecount < CACHE_NTHREADS &&
315         (td->td_flags & TDF_ALLOCATED_THREAD)
316     ) {
317         ++gd->gd_tdfreecount;
318         TAILQ_INSERT_HEAD(&gd->gd_tdfreeq, td, td_threadq);
319         crit_exit();
320     } else {
321         crit_exit();
322         if (td->td_kstack && (td->td_flags & TDF_ALLOCATED_STACK)) {
323 #ifdef _KERNEL
324             kmem_free(kernel_map, (vm_offset_t)td->td_kstack, THREAD_STACK);
325 #else
326             liblwkt_free_stack(td->td_kstack, THREAD_STACK);
327 #endif
328             /* gd invalid */
329             td->td_kstack = NULL;
330         }
331         if (td->td_flags & TDF_ALLOCATED_THREAD) {
332 #ifdef _KERNEL
333             zfree(thread_zone, td);
334 #else
335             free(td);
336 #endif
337         }
338     }
339 }
340
341
342 /*
343  * Switch to the next runnable lwkt.  If no LWKTs are runnable then 
344  * switch to the idlethread.  Switching must occur within a critical
345  * section to avoid races with the scheduling queue.
346  *
347  * We always have full control over our cpu's run queue.  Other cpus
348  * that wish to manipulate our queue must use the cpu_*msg() calls to
349  * talk to our cpu, so a critical section is all that is needed and
350  * the result is very, very fast thread switching.
351  *
352  * The LWKT scheduler uses a fixed priority model and round-robins at
353  * each priority level.  User process scheduling is a totally
354  * different beast and LWKT priorities should not be confused with
355  * user process priorities.
356  *
357  * The MP lock may be out of sync with the thread's td_mpcount.  lwkt_switch()
358  * cleans it up.  Note that the td_switch() function cannot do anything that
359  * requires the MP lock since the MP lock will have already been setup for
360  * the target thread (not the current thread).  It's nice to have a scheduler
361  * that does not need the MP lock to work because it allows us to do some
362  * really cool high-performance MP lock optimizations.
363  */
364
365 void
366 lwkt_switch(void)
367 {
368     struct globaldata *gd;
369     thread_t td = curthread;
370     thread_t ntd;
371 #ifdef SMP
372     int mpheld;
373 #endif
374
375     /*
376      * Switching from within a 'fast' (non thread switched) interrupt is
377      * illegal.
378      */
379     if (mycpu->gd_intr_nesting_level && panicstr == NULL) {
380         panic("lwkt_switch: cannot switch from within a fast interrupt, yet\n");
381     }
382
383     /*
384      * Passive release (used to transition from user to kernel mode
385      * when we block or switch rather then when we enter the kernel).
386      * This function is NOT called if we are switching into a preemption
387      * or returning from a preemption.  Typically this causes us to lose
388      * our P_CURPROC designation (if we have one) and become a true LWKT
389      * thread, and may also hand P_CURPROC to another process and schedule
390      * its thread.
391      */
392     if (td->td_release)
393             td->td_release(td);
394
395     crit_enter();
396     ++switch_count;
397
398 #ifdef SMP
399     /*
400      * td_mpcount cannot be used to determine if we currently hold the
401      * MP lock because get_mplock() will increment it prior to attempting
402      * to get the lock, and switch out if it can't.  Our ownership of 
403      * the actual lock will remain stable while we are in a critical section
404      * (but, of course, another cpu may own or release the lock so the
405      * actual value of mp_lock is not stable).
406      */
407     mpheld = MP_LOCK_HELD();
408 #endif
409     if ((ntd = td->td_preempted) != NULL) {
410         /*
411          * We had preempted another thread on this cpu, resume the preempted
412          * thread.  This occurs transparently, whether the preempted thread
413          * was scheduled or not (it may have been preempted after descheduling
414          * itself). 
415          *
416          * We have to setup the MP lock for the original thread after backing
417          * out the adjustment that was made to curthread when the original
418          * was preempted.
419          */
420         KKASSERT(ntd->td_flags & TDF_PREEMPT_LOCK);
421 #ifdef SMP
422         if (ntd->td_mpcount && mpheld == 0) {
423             panic("MPLOCK NOT HELD ON RETURN: %p %p %d %d\n",
424                td, ntd, td->td_mpcount, ntd->td_mpcount);
425         }
426         if (ntd->td_mpcount) {
427             td->td_mpcount -= ntd->td_mpcount;
428             KKASSERT(td->td_mpcount >= 0);
429         }
430 #endif
431         ntd->td_flags |= TDF_PREEMPT_DONE;
432         /* YYY release mp lock on switchback if original doesn't need it */
433     } else {
434         /*
435          * Priority queue / round-robin at each priority.  Note that user
436          * processes run at a fixed, low priority and the user process
437          * scheduler deals with interactions between user processes
438          * by scheduling and descheduling them from the LWKT queue as
439          * necessary.
440          *
441          * We have to adjust the MP lock for the target thread.  If we 
442          * need the MP lock and cannot obtain it we try to locate a
443          * thread that does not need the MP lock.
444          */
445         gd = mycpu;
446 again:
447         if (gd->gd_runqmask) {
448             int nq = bsrl(gd->gd_runqmask);
449             if ((ntd = TAILQ_FIRST(&gd->gd_tdrunq[nq])) == NULL) {
450                 gd->gd_runqmask &= ~(1 << nq);
451                 goto again;
452             }
453 #ifdef SMP
454             if (ntd->td_mpcount && mpheld == 0 && !cpu_try_mplock()) {
455                 /*
456                  * Target needs MP lock and we couldn't get it, try
457                  * to locate a thread which does not need the MP lock
458                  * to run.  If we cannot locate a thread spin in idle.
459                  */
460                 u_int32_t rqmask = gd->gd_runqmask;
461                 while (rqmask) {
462                     TAILQ_FOREACH(ntd, &gd->gd_tdrunq[nq], td_threadq) {
463                         if (ntd->td_mpcount == 0)
464                             break;
465                     }
466                     if (ntd)
467                         break;
468                     rqmask &= ~(1 << nq);
469                     nq = bsrl(rqmask);
470                 }
471                 if (ntd == NULL) {
472                     ntd = &gd->gd_idlethread;
473                     ntd->td_flags |= TDF_IDLE_NOHLT;
474                 } else {
475                     TAILQ_REMOVE(&gd->gd_tdrunq[nq], ntd, td_threadq);
476                     TAILQ_INSERT_TAIL(&gd->gd_tdrunq[nq], ntd, td_threadq);
477                 }
478             } else {
479                 TAILQ_REMOVE(&gd->gd_tdrunq[nq], ntd, td_threadq);
480                 TAILQ_INSERT_TAIL(&gd->gd_tdrunq[nq], ntd, td_threadq);
481             }
482 #else
483             TAILQ_REMOVE(&gd->gd_tdrunq[nq], ntd, td_threadq);
484             TAILQ_INSERT_TAIL(&gd->gd_tdrunq[nq], ntd, td_threadq);
485 #endif
486         } else {
487             /*
488              * Nothing to run but we may still need the BGL to deal with
489              * pending interrupts, spin in idle if so.
490              */
491             ntd = &gd->gd_idlethread;
492             if (gd->gd_reqflags)
493                 ntd->td_flags |= TDF_IDLE_NOHLT;
494         }
495     }
496     KASSERT(ntd->td_pri >= TDPRI_CRIT,
497         ("priority problem in lwkt_switch %d %d", td->td_pri, ntd->td_pri));
498
499     /*
500      * Do the actual switch.  If the new target does not need the MP lock
501      * and we are holding it, release the MP lock.  If the new target requires
502      * the MP lock we have already acquired it for the target.
503      */
504 #ifdef SMP
505     if (ntd->td_mpcount == 0 ) {
506         if (MP_LOCK_HELD())
507             cpu_rel_mplock();
508     } else {
509         ASSERT_MP_LOCK_HELD();
510     }
511 #endif
512     if (td != ntd) {
513         td->td_switch(ntd);
514     }
515
516     crit_exit();
517 }
518
519 /*
520  * Switch if another thread has a higher priority.  Do not switch to other
521  * threads at the same priority.
522  */
523 void
524 lwkt_maybe_switch()
525 {
526     struct globaldata *gd = mycpu;
527     struct thread *td = gd->gd_curthread;
528
529     if ((td->td_pri & TDPRI_MASK) < bsrl(gd->gd_runqmask)) {
530         lwkt_switch();
531     }
532 }
533
534 /*
535  * Request that the target thread preempt the current thread.  Preemption
536  * only works under a specific set of conditions:
537  *
538  *      - We are not preempting ourselves
539  *      - The target thread is owned by the current cpu
540  *      - We are not currently being preempted
541  *      - The target is not currently being preempted
542  *      - We are able to satisfy the target's MP lock requirements (if any).
543  *
544  * THE CALLER OF LWKT_PREEMPT() MUST BE IN A CRITICAL SECTION.  Typically
545  * this is called via lwkt_schedule() through the td_preemptable callback.
546  * critpri is the managed critical priority that we should ignore in order
547  * to determine whether preemption is possible (aka usually just the crit
548  * priority of lwkt_schedule() itself).
549  *
550  * XXX at the moment we run the target thread in a critical section during
551  * the preemption in order to prevent the target from taking interrupts
552  * that *WE* can't.  Preemption is strictly limited to interrupt threads
553  * and interrupt-like threads, outside of a critical section, and the
554  * preempted source thread will be resumed the instant the target blocks
555  * whether or not the source is scheduled (i.e. preemption is supposed to
556  * be as transparent as possible).
557  *
558  * The target thread inherits our MP count (added to its own) for the
559  * duration of the preemption in order to preserve the atomicy of the
560  * MP lock during the preemption.  Therefore, any preempting targets must be
561  * careful in regards to MP assertions.  Note that the MP count may be
562  * out of sync with the physical mp_lock, but we do not have to preserve
563  * the original ownership of the lock if it was out of synch (that is, we
564  * can leave it synchronized on return).
565  */
566 void
567 lwkt_preempt(thread_t ntd, int critpri)
568 {
569     struct globaldata *gd = mycpu;
570     thread_t td = gd->gd_curthread;
571 #ifdef SMP
572     int mpheld;
573     int savecnt;
574 #endif
575
576     /*
577      * The caller has put us in a critical section.  We can only preempt
578      * if the caller of the caller was not in a critical section (basically
579      * a local interrupt), as determined by the 'critpri' parameter.   If
580      * we are unable to preempt 
581      *
582      * YYY The target thread must be in a critical section (else it must
583      * inherit our critical section?  I dunno yet).
584      */
585     KASSERT(ntd->td_pri >= TDPRI_CRIT, ("BADCRIT0 %d", ntd->td_pri));
586
587     need_resched();
588     if (!_lwkt_wantresched(ntd, td)) {
589         ++preempt_miss;
590         return;
591     }
592     if ((td->td_pri & ~TDPRI_MASK) > critpri) {
593         ++preempt_miss;
594         return;
595     }
596 #ifdef SMP
597     if (ntd->td_gd != gd) {
598         ++preempt_miss;
599         return;
600     }
601 #endif
602     if (td == ntd || ((td->td_flags | ntd->td_flags) & TDF_PREEMPT_LOCK)) {
603         ++preempt_weird;
604         return;
605     }
606     if (ntd->td_preempted) {
607         ++preempt_hit;
608         return;
609     }
610 #ifdef SMP
611     /*
612      * note: an interrupt might have occured just as we were transitioning
613      * to or from the MP lock.  In this case td_mpcount will be pre-disposed
614      * (non-zero) but not actually synchronized with the actual state of the
615      * lock.  We can use it to imply an MP lock requirement for the
616      * preemption but we cannot use it to test whether we hold the MP lock
617      * or not.
618      */
619     savecnt = td->td_mpcount;
620     mpheld = MP_LOCK_HELD();
621     ntd->td_mpcount += td->td_mpcount;
622     if (mpheld == 0 && ntd->td_mpcount && !cpu_try_mplock()) {
623         ntd->td_mpcount -= td->td_mpcount;
624         ++preempt_miss;
625         return;
626     }
627 #endif
628
629     ++preempt_hit;
630     ntd->td_preempted = td;
631     td->td_flags |= TDF_PREEMPT_LOCK;
632     td->td_switch(ntd);
633     KKASSERT(ntd->td_preempted && (td->td_flags & TDF_PREEMPT_DONE));
634 #ifdef SMP
635     KKASSERT(savecnt == td->td_mpcount);
636     mpheld = MP_LOCK_HELD();
637     if (mpheld && td->td_mpcount == 0)
638         cpu_rel_mplock();
639     else if (mpheld == 0 && td->td_mpcount)
640         panic("lwkt_preempt(): MP lock was not held through");
641 #endif
642     ntd->td_preempted = NULL;
643     td->td_flags &= ~(TDF_PREEMPT_LOCK|TDF_PREEMPT_DONE);
644 }
645
646 /*
647  * Yield our thread while higher priority threads are pending.  This is
648  * typically called when we leave a critical section but it can be safely
649  * called while we are in a critical section.
650  *
651  * This function will not generally yield to equal priority threads but it
652  * can occur as a side effect.  Note that lwkt_switch() is called from
653  * inside the critical section to prevent its own crit_exit() from reentering
654  * lwkt_yield_quick().
655  *
656  * gd_reqflags indicates that *something* changed, e.g. an interrupt or softint
657  * came along but was blocked and made pending.
658  *
659  * (self contained on a per cpu basis)
660  */
661 void
662 lwkt_yield_quick(void)
663 {
664     globaldata_t gd = mycpu;
665     thread_t td = gd->gd_curthread;
666
667     /*
668      * gd_reqflags is cleared in splz if the cpl is 0.  If we were to clear
669      * it with a non-zero cpl then we might not wind up calling splz after
670      * a task switch when the critical section is exited even though the
671      * new task could accept the interrupt.
672      *
673      * XXX from crit_exit() only called after last crit section is released.
674      * If called directly will run splz() even if in a critical section.
675      *
676      * td_nest_count prevent deep nesting via splz() or doreti().  Note that
677      * except for this special case, we MUST call splz() here to handle any
678      * pending ints, particularly after we switch, or we might accidently
679      * halt the cpu with interrupts pending.
680      */
681     if (gd->gd_reqflags && td->td_nest_count < 2)
682         splz();
683
684     /*
685      * YYY enabling will cause wakeup() to task-switch, which really
686      * confused the old 4.x code.  This is a good way to simulate
687      * preemption and MP without actually doing preemption or MP, because a
688      * lot of code assumes that wakeup() does not block.
689      */
690     if (untimely_switch && td->td_nest_count == 0 &&
691         gd->gd_intr_nesting_level == 0
692     ) {
693         crit_enter();
694         /*
695          * YYY temporary hacks until we disassociate the userland scheduler
696          * from the LWKT scheduler.
697          */
698         if (td->td_flags & TDF_RUNQ) {
699             lwkt_switch();              /* will not reenter yield function */
700         } else {
701             lwkt_schedule_self();       /* make sure we are scheduled */
702             lwkt_switch();              /* will not reenter yield function */
703             lwkt_deschedule_self();     /* make sure we are descheduled */
704         }
705         crit_exit_noyield(td);
706     }
707 }
708
709 /*
710  * This implements a normal yield which, unlike _quick, will yield to equal
711  * priority threads as well.  Note that gd_reqflags tests will be handled by
712  * the crit_exit() call in lwkt_switch().
713  *
714  * (self contained on a per cpu basis)
715  */
716 void
717 lwkt_yield(void)
718 {
719     lwkt_schedule_self();
720     lwkt_switch();
721 }
722
723 /*
724  * Schedule a thread to run.  As the current thread we can always safely
725  * schedule ourselves, and a shortcut procedure is provided for that
726  * function.
727  *
728  * (non-blocking, self contained on a per cpu basis)
729  */
730 void
731 lwkt_schedule_self(void)
732 {
733     thread_t td = curthread;
734
735     crit_enter();
736     KASSERT(td->td_wait == NULL, ("lwkt_schedule_self(): td_wait not NULL!"));
737     _lwkt_enqueue(td);
738 #ifdef _KERNEL
739     if (td->td_proc && td->td_proc->p_stat == SSLEEP)
740         panic("SCHED SELF PANIC");
741 #endif
742     crit_exit();
743 }
744
745 /*
746  * Generic schedule.  Possibly schedule threads belonging to other cpus and
747  * deal with threads that might be blocked on a wait queue.
748  *
749  * YYY this is one of the best places to implement load balancing code.
750  * Load balancing can be accomplished by requesting other sorts of actions
751  * for the thread in question.
752  */
753 void
754 lwkt_schedule(thread_t td)
755 {
756 #ifdef  INVARIANTS
757     if ((td->td_flags & TDF_PREEMPT_LOCK) == 0 && td->td_proc 
758         && td->td_proc->p_stat == SSLEEP
759     ) {
760         printf("PANIC schedule curtd = %p (%d %d) target %p (%d %d)\n",
761             curthread,
762             curthread->td_proc ? curthread->td_proc->p_pid : -1,
763             curthread->td_proc ? curthread->td_proc->p_stat : -1,
764             td,
765             td->td_proc ? curthread->td_proc->p_pid : -1,
766             td->td_proc ? curthread->td_proc->p_stat : -1
767         );
768         panic("SCHED PANIC");
769     }
770 #endif
771     crit_enter();
772     if (td == curthread) {
773         _lwkt_enqueue(td);
774     } else {
775         lwkt_wait_t w;
776
777         /*
778          * If the thread is on a wait list we have to send our scheduling
779          * request to the owner of the wait structure.  Otherwise we send
780          * the scheduling request to the cpu owning the thread.  Races
781          * are ok, the target will forward the message as necessary (the
782          * message may chase the thread around before it finally gets
783          * acted upon).
784          *
785          * (remember, wait structures use stable storage)
786          */
787         if ((w = td->td_wait) != NULL) {
788             if (lwkt_trytoken(&w->wa_token)) {
789                 TAILQ_REMOVE(&w->wa_waitq, td, td_threadq);
790                 --w->wa_count;
791                 td->td_wait = NULL;
792                 if (smp_active == 0 || td->td_gd == mycpu) {
793                     _lwkt_enqueue(td);
794                     if (td->td_preemptable) {
795                         td->td_preemptable(td, TDPRI_CRIT*2); /* YYY +token */
796                     } else if (_lwkt_wantresched(td, curthread)) {
797                         need_resched();
798                     }
799                 } else {
800                     lwkt_send_ipiq(td->td_gd->gd_cpuid, (ipifunc_t)lwkt_schedule, td);
801                 }
802                 lwkt_reltoken(&w->wa_token);
803             } else {
804                 lwkt_send_ipiq(w->wa_token.t_cpu, (ipifunc_t)lwkt_schedule, td);
805             }
806         } else {
807             /*
808              * If the wait structure is NULL and we own the thread, there
809              * is no race (since we are in a critical section).  If we
810              * do not own the thread there might be a race but the
811              * target cpu will deal with it.
812              */
813             if (smp_active == 0 || td->td_gd == mycpu) {
814                 _lwkt_enqueue(td);
815                 if (td->td_preemptable) {
816                     td->td_preemptable(td, TDPRI_CRIT);
817                 } else if (_lwkt_wantresched(td, curthread)) {
818                     need_resched();
819                 }
820             } else {
821                 lwkt_send_ipiq(td->td_gd->gd_cpuid, (ipifunc_t)lwkt_schedule, td);
822             }
823         }
824     }
825     crit_exit();
826 }
827
828 /*
829  * Managed acquisition.  This code assumes that the MP lock is held for
830  * the tdallq operation and that the thread has been descheduled from its
831  * original cpu.  We also have to wait for the thread to be entirely switched
832  * out on its original cpu (this is usually fast enough that we never loop)
833  * since the LWKT system does not have to hold the MP lock while switching
834  * and the target may have released it before switching.
835  */
836 void
837 lwkt_acquire(thread_t td)
838 {
839     struct globaldata *gd;
840
841     gd = td->td_gd;
842     KKASSERT((td->td_flags & TDF_RUNQ) == 0);
843     while (td->td_flags & TDF_RUNNING)  /* XXX spin */
844         ;
845     if (gd != mycpu) {
846         crit_enter();
847         TAILQ_REMOVE(&gd->gd_tdallq, td, td_allq);      /* protected by BGL */
848         gd = mycpu;
849         td->td_gd = gd;
850         TAILQ_INSERT_TAIL(&gd->gd_tdallq, td, td_allq); /* protected by BGL */
851         crit_exit();
852     }
853 }
854
855 /*
856  * Deschedule a thread.
857  *
858  * (non-blocking, self contained on a per cpu basis)
859  */
860 void
861 lwkt_deschedule_self(void)
862 {
863     thread_t td = curthread;
864
865     crit_enter();
866     KASSERT(td->td_wait == NULL, ("lwkt_schedule_self(): td_wait not NULL!"));
867     _lwkt_dequeue(td);
868     crit_exit();
869 }
870
871 /*
872  * Generic deschedule.  Descheduling threads other then your own should be
873  * done only in carefully controlled circumstances.  Descheduling is 
874  * asynchronous.  
875  *
876  * This function may block if the cpu has run out of messages.
877  */
878 void
879 lwkt_deschedule(thread_t td)
880 {
881     crit_enter();
882     if (td == curthread) {
883         _lwkt_dequeue(td);
884     } else {
885         if (td->td_gd == mycpu) {
886             _lwkt_dequeue(td);
887         } else {
888             lwkt_send_ipiq(td->td_gd->gd_cpuid, (ipifunc_t)lwkt_deschedule, td);
889         }
890     }
891     crit_exit();
892 }
893
894 /*
895  * Set the target thread's priority.  This routine does not automatically
896  * switch to a higher priority thread, LWKT threads are not designed for
897  * continuous priority changes.  Yield if you want to switch.
898  *
899  * We have to retain the critical section count which uses the high bits
900  * of the td_pri field.  The specified priority may also indicate zero or
901  * more critical sections by adding TDPRI_CRIT*N.
902  */
903 void
904 lwkt_setpri(thread_t td, int pri)
905 {
906     KKASSERT(pri >= 0);
907     KKASSERT(td->td_gd == mycpu);
908     crit_enter();
909     if (td->td_flags & TDF_RUNQ) {
910         _lwkt_dequeue(td);
911         td->td_pri = (td->td_pri & ~TDPRI_MASK) + pri;
912         _lwkt_enqueue(td);
913     } else {
914         td->td_pri = (td->td_pri & ~TDPRI_MASK) + pri;
915     }
916     crit_exit();
917 }
918
919 void
920 lwkt_setpri_self(int pri)
921 {
922     thread_t td = curthread;
923
924     KKASSERT(pri >= 0 && pri <= TDPRI_MAX);
925     crit_enter();
926     if (td->td_flags & TDF_RUNQ) {
927         _lwkt_dequeue(td);
928         td->td_pri = (td->td_pri & ~TDPRI_MASK) + pri;
929         _lwkt_enqueue(td);
930     } else {
931         td->td_pri = (td->td_pri & ~TDPRI_MASK) + pri;
932     }
933     crit_exit();
934 }
935
936 struct proc *
937 lwkt_preempted_proc(void)
938 {
939     thread_t td = curthread;
940     while (td->td_preempted)
941         td = td->td_preempted;
942     return(td->td_proc);
943 }
944
945 typedef struct lwkt_gettoken_req {
946     lwkt_token_t tok;
947     int cpu;
948 } lwkt_gettoken_req;
949
950 #if 0
951
952 /*
953  * This function deschedules the current thread and blocks on the specified
954  * wait queue.  We obtain ownership of the wait queue in order to block
955  * on it.  A generation number is used to interlock the wait queue in case
956  * it gets signalled while we are blocked waiting on the token.
957  *
958  * Note: alternatively we could dequeue our thread and then message the
959  * target cpu owning the wait queue.  YYY implement as sysctl.
960  *
961  * Note: wait queue signals normally ping-pong the cpu as an optimization.
962  */
963
964 void
965 lwkt_block(lwkt_wait_t w, const char *wmesg, int *gen)
966 {
967     thread_t td = curthread;
968
969     lwkt_gettoken(&w->wa_token);
970     if (w->wa_gen == *gen) {
971         _lwkt_dequeue(td);
972         TAILQ_INSERT_TAIL(&w->wa_waitq, td, td_threadq);
973         ++w->wa_count;
974         td->td_wait = w;
975         td->td_wmesg = wmesg;
976 again:
977         lwkt_switch();
978         lwkt_regettoken(&w->wa_token);
979         if (td->td_wmesg != NULL) {
980             _lwkt_dequeue(td);
981             goto again;
982         }
983     }
984     /* token might be lost, doesn't matter for gen update */
985     *gen = w->wa_gen;
986     lwkt_reltoken(&w->wa_token);
987 }
988
989 /*
990  * Signal a wait queue.  We gain ownership of the wait queue in order to
991  * signal it.  Once a thread is removed from the wait queue we have to
992  * deal with the cpu owning the thread.
993  *
994  * Note: alternatively we could message the target cpu owning the wait
995  * queue.  YYY implement as sysctl.
996  */
997 void
998 lwkt_signal(lwkt_wait_t w, int count)
999 {
1000     thread_t td;
1001     int count;
1002
1003     lwkt_gettoken(&w->wa_token);
1004     ++w->wa_gen;
1005     if (count < 0)
1006         count = w->wa_count;
1007     while ((td = TAILQ_FIRST(&w->wa_waitq)) != NULL && count) {
1008         --count;
1009         --w->wa_count;
1010         TAILQ_REMOVE(&w->wa_waitq, td, td_threadq);
1011         td->td_wait = NULL;
1012         td->td_wmesg = NULL;
1013         if (td->td_gd == mycpu) {
1014             _lwkt_enqueue(td);
1015         } else {
1016             lwkt_send_ipiq(td->td_gd->gd_cpuid, (ipifunc_t)lwkt_schedule, td);
1017         }
1018         lwkt_regettoken(&w->wa_token);
1019     }
1020     lwkt_reltoken(&w->wa_token);
1021 }
1022
1023 #endif
1024
1025 /*
1026  * Acquire ownership of a token
1027  *
1028  * Acquire ownership of a token.  The token may have spl and/or critical
1029  * section side effects, depending on its purpose.  These side effects
1030  * guarentee that you will maintain ownership of the token as long as you
1031  * do not block.  If you block you may lose access to the token (but you
1032  * must still release it even if you lose your access to it).
1033  *
1034  * YYY for now we use a critical section to prevent IPIs from taking away
1035  * a token, but do we really only need to disable IPIs ?
1036  *
1037  * YYY certain tokens could be made to act like mutexes when performance
1038  * would be better (e.g. t_cpu == -1).  This is not yet implemented.
1039  *
1040  * YYY the tokens replace 4.x's simplelocks for the most part, but this
1041  * means that 4.x does not expect a switch so for now we cannot switch
1042  * when waiting for an IPI to be returned.  
1043  *
1044  * YYY If the token is owned by another cpu we may have to send an IPI to
1045  * it and then block.   The IPI causes the token to be given away to the
1046  * requesting cpu, unless it has already changed hands.  Since only the
1047  * current cpu can give away a token it owns we do not need a memory barrier.
1048  * This needs serious optimization.
1049  */
1050
1051 #ifdef SMP
1052
1053 static
1054 void
1055 lwkt_gettoken_remote(void *arg)
1056 {
1057     lwkt_gettoken_req *req = arg;
1058     if (req->tok->t_cpu == mycpu->gd_cpuid) {
1059 #ifdef INVARIANTS
1060         if (token_debug)
1061             printf("GT(%d,%d) ", req->tok->t_cpu, req->cpu);
1062 #endif
1063         req->tok->t_cpu = req->cpu;
1064         req->tok->t_reqcpu = req->cpu;  /* YYY leave owned by target cpu */
1065         /* else set reqcpu to point to current cpu for release */
1066     }
1067 }
1068
1069 #endif
1070
1071 int
1072 lwkt_gettoken(lwkt_token_t tok)
1073 {
1074     /*
1075      * Prevent preemption so the token can't be taken away from us once
1076      * we gain ownership of it.  Use a synchronous request which might
1077      * block.  The request will be forwarded as necessary playing catchup
1078      * to the token.
1079      */
1080
1081     crit_enter();
1082 #ifdef INVARIANTS
1083     if (curthread->td_pri > 1800) {
1084         printf("lwkt_gettoken: %p called from %p: crit sect nesting warning\n",
1085             tok, ((int **)&tok)[-1]);
1086     }
1087     if (curthread->td_pri > 2000) {
1088         curthread->td_pri = 1000;
1089         panic("too HIGH!");
1090     }
1091 #endif
1092 #ifdef SMP
1093     while (tok->t_cpu != mycpu->gd_cpuid) {
1094         struct lwkt_gettoken_req req;
1095         int seq;
1096         int dcpu;
1097
1098         req.cpu = mycpu->gd_cpuid;
1099         req.tok = tok;
1100         dcpu = (volatile int)tok->t_cpu;
1101         KKASSERT(dcpu >= 0 && dcpu < ncpus);
1102 #ifdef INVARIANTS
1103         if (token_debug)
1104             printf("REQT%d ", dcpu);
1105 #endif
1106         seq = lwkt_send_ipiq(dcpu, lwkt_gettoken_remote, &req);
1107         lwkt_wait_ipiq(dcpu, seq);
1108 #ifdef INVARIANTS
1109         if (token_debug)
1110             printf("REQR%d ", tok->t_cpu);
1111 #endif
1112     }
1113 #endif
1114     /*
1115      * leave us in a critical section on return.  This will be undone
1116      * by lwkt_reltoken().  Bump the generation number.
1117      */
1118     return(++tok->t_gen);
1119 }
1120
1121 /*
1122  * Attempt to acquire ownership of a token.  Returns 1 on success, 0 on
1123  * failure.
1124  */
1125 int
1126 lwkt_trytoken(lwkt_token_t tok)
1127 {
1128     crit_enter();
1129 #ifdef SMP
1130     if (tok->t_cpu != mycpu->gd_cpuid) {
1131         crit_exit();
1132         return(0);
1133     } 
1134 #endif
1135     /* leave us in the critical section */
1136     ++tok->t_gen;
1137     return(1);
1138 }
1139
1140 /*
1141  * Release your ownership of a token.  Releases must occur in reverse
1142  * order to aquisitions, eventually so priorities can be unwound properly
1143  * like SPLs.  At the moment the actual implemention doesn't care.
1144  *
1145  * We can safely hand a token that we own to another cpu without notifying
1146  * it, but once we do we can't get it back without requesting it (unless
1147  * the other cpu hands it back to us before we check).
1148  *
1149  * We might have lost the token, so check that.
1150  *
1151  * Return the token's generation number.  The number is useful to callers
1152  * who may want to know if the token was stolen during potential blockages.
1153  */
1154 int
1155 lwkt_reltoken(lwkt_token_t tok)
1156 {
1157     int gen;
1158
1159     if (tok->t_cpu == mycpu->gd_cpuid) {
1160         tok->t_cpu = tok->t_reqcpu;
1161     }
1162     gen = tok->t_gen;
1163     crit_exit();
1164     return(gen);
1165 }
1166
1167 /*
1168  * Reacquire a token that might have been lost.  0 is returned if the 
1169  * generation has not changed (nobody stole the token from us), -1 is 
1170  * returned otherwise.  The token is reacquired regardless but the
1171  * generation number is not bumped further if we already own the token.
1172  *
1173  * For efficiency we inline the best-case situation for lwkt_regettoken()
1174  * (i.e .we still own the token).
1175  */
1176 int
1177 lwkt_gentoken(lwkt_token_t tok, int *gen)
1178 {
1179     if (tok->t_cpu == mycpu->gd_cpuid && tok->t_gen == *gen)
1180         return(0);
1181     *gen = lwkt_regettoken(tok);
1182     return(-1);
1183 }
1184
1185 /*
1186  * Re-acquire a token that might have been lost.   The generation number
1187  * is bumped and returned regardless of whether the token had been lost
1188  * or not (because we only have cpu granularity we have to bump the token
1189  * either way).
1190  */
1191 int
1192 lwkt_regettoken(lwkt_token_t tok)
1193 {
1194     /* assert we are in a critical section */
1195     if (tok->t_cpu != mycpu->gd_cpuid) {
1196 #ifdef SMP
1197         while (tok->t_cpu != mycpu->gd_cpuid) {
1198             struct lwkt_gettoken_req req;
1199             int seq;
1200             int dcpu;
1201
1202             req.cpu = mycpu->gd_cpuid;
1203             req.tok = tok;
1204             dcpu = (volatile int)tok->t_cpu;
1205             KKASSERT(dcpu >= 0 && dcpu < ncpus);
1206 #ifdef INVARIANTS
1207             if (token_debug)
1208                 printf("REQT%d ", dcpu);
1209 #endif
1210             seq = lwkt_send_ipiq(dcpu, lwkt_gettoken_remote, &req);
1211             lwkt_wait_ipiq(dcpu, seq);
1212 #ifdef INVARIATNS
1213             if (token_debug)
1214                 printf("REQR%d ", tok->t_cpu);
1215 #endif
1216         }
1217 #endif
1218     }
1219     ++tok->t_gen;
1220     return(tok->t_gen);
1221 }
1222
1223 void
1224 lwkt_inittoken(lwkt_token_t tok)
1225 {
1226     /*
1227      * Zero structure and set cpu owner and reqcpu to cpu 0.
1228      */
1229     bzero(tok, sizeof(*tok));
1230 }
1231
1232 /*
1233  * Create a kernel process/thread/whatever.  It shares it's address space
1234  * with proc0 - ie: kernel only.
1235  *
1236  * NOTE!  By default new threads are created with the MP lock held.  A 
1237  * thread which does not require the MP lock should release it by calling
1238  * rel_mplock() at the start of the new thread.
1239  */
1240 int
1241 lwkt_create(void (*func)(void *), void *arg,
1242     struct thread **tdp, thread_t template, int tdflags, int cpu,
1243     const char *fmt, ...)
1244 {
1245     thread_t td;
1246     __va_list ap;
1247
1248     td = lwkt_alloc_thread(template, cpu);
1249     if (tdp)
1250         *tdp = td;
1251     cpu_set_thread_handler(td, kthread_exit, func, arg);
1252     td->td_flags |= TDF_VERBOSE | tdflags;
1253 #ifdef SMP
1254     td->td_mpcount = 1;
1255 #endif
1256
1257     /*
1258      * Set up arg0 for 'ps' etc
1259      */
1260     __va_start(ap, fmt);
1261     vsnprintf(td->td_comm, sizeof(td->td_comm), fmt, ap);
1262     __va_end(ap);
1263
1264     /*
1265      * Schedule the thread to run
1266      */
1267     if ((td->td_flags & TDF_STOPREQ) == 0)
1268         lwkt_schedule(td);
1269     else
1270         td->td_flags &= ~TDF_STOPREQ;
1271     return 0;
1272 }
1273
1274 /*
1275  * Destroy an LWKT thread.   Warning!  This function is not called when
1276  * a process exits, cpu_proc_exit() directly calls cpu_thread_exit() and
1277  * uses a different reaping mechanism.
1278  */
1279 void
1280 lwkt_exit(void)
1281 {
1282     thread_t td = curthread;
1283
1284     if (td->td_flags & TDF_VERBOSE)
1285         printf("kthread %p %s has exited\n", td, td->td_comm);
1286     crit_enter();
1287     lwkt_deschedule_self();
1288     ++mycpu->gd_tdfreecount;
1289     TAILQ_INSERT_TAIL(&mycpu->gd_tdfreeq, td, td_threadq);
1290     cpu_thread_exit();
1291 }
1292
1293 #ifdef _KERNEL
1294 /*
1295  * Create a kernel process/thread/whatever.  It shares it's address space
1296  * with proc0 - ie: kernel only.  5.x compatible.
1297  *
1298  * NOTE!  By default kthreads are created with the MP lock held.  A
1299  * thread which does not require the MP lock should release it by calling
1300  * rel_mplock() at the start of the new thread.
1301  */
1302 int
1303 kthread_create(void (*func)(void *), void *arg,
1304     struct thread **tdp, const char *fmt, ...)
1305 {
1306     thread_t td;
1307     __va_list ap;
1308
1309     td = lwkt_alloc_thread(NULL, -1);
1310     if (tdp)
1311         *tdp = td;
1312     cpu_set_thread_handler(td, kthread_exit, func, arg);
1313     td->td_flags |= TDF_VERBOSE;
1314 #ifdef SMP
1315     td->td_mpcount = 1;
1316 #endif
1317
1318     /*
1319      * Set up arg0 for 'ps' etc
1320      */
1321     __va_start(ap, fmt);
1322     vsnprintf(td->td_comm, sizeof(td->td_comm), fmt, ap);
1323     __va_end(ap);
1324
1325     /*
1326      * Schedule the thread to run
1327      */
1328     lwkt_schedule(td);
1329     return 0;
1330 }
1331
1332 #endif
1333
1334 void
1335 crit_panic(void)
1336 {
1337     thread_t td = curthread;
1338     int lpri = td->td_pri;
1339
1340     td->td_pri = 0;
1341     panic("td_pri is/would-go negative! %p %d", td, lpri);
1342 }
1343
1344 /*
1345  * Destroy an LWKT thread.   Warning!  This function is not called when
1346  * a process exits, cpu_proc_exit() directly calls cpu_thread_exit() and
1347  * uses a different reaping mechanism.
1348  *
1349  * XXX duplicates lwkt_exit()
1350  */
1351 void
1352 kthread_exit(void)
1353 {
1354     lwkt_exit();
1355 }
1356
1357 #ifdef SMP
1358
1359 /*
1360  * Send a function execution request to another cpu.  The request is queued
1361  * on the cpu<->cpu ipiq matrix.  Each cpu owns a unique ipiq FIFO for every
1362  * possible target cpu.  The FIFO can be written.
1363  *
1364  * YYY If the FIFO fills up we have to enable interrupts and process the
1365  * IPIQ while waiting for it to empty or we may deadlock with another cpu.
1366  * Create a CPU_*() function to do this!
1367  *
1368  * We can safely bump gd_intr_nesting_level because our crit_exit() at the
1369  * end will take care of any pending interrupts.
1370  *
1371  * Must be called from a critical section.
1372  */
1373 int
1374 lwkt_send_ipiq(int dcpu, ipifunc_t func, void *arg)
1375 {
1376     lwkt_ipiq_t ip;
1377     int windex;
1378     struct globaldata *gd = mycpu;
1379
1380     if (dcpu == gd->gd_cpuid) {
1381         func(arg);
1382         return(0);
1383     } 
1384     crit_enter();
1385     ++gd->gd_intr_nesting_level;
1386 #ifdef INVARIANTS
1387     if (gd->gd_intr_nesting_level > 20)
1388         panic("lwkt_send_ipiq: TOO HEAVILY NESTED!");
1389 #endif
1390     KKASSERT(curthread->td_pri >= TDPRI_CRIT);
1391     KKASSERT(dcpu >= 0 && dcpu < ncpus);
1392     ++ipiq_count;
1393     ip = &gd->gd_ipiq[dcpu];
1394
1395     /*
1396      * We always drain before the FIFO becomes full so it should never
1397      * become full.  We need to leave enough entries to deal with 
1398      * reentrancy.
1399      */
1400     KKASSERT(ip->ip_windex - ip->ip_rindex != MAXCPUFIFO);
1401     windex = ip->ip_windex & MAXCPUFIFO_MASK;
1402     ip->ip_func[windex] = func;
1403     ip->ip_arg[windex] = arg;
1404     /* YYY memory barrier */
1405     ++ip->ip_windex;
1406     if (ip->ip_windex - ip->ip_rindex > MAXCPUFIFO / 2) {
1407         unsigned int eflags = read_eflags();
1408         cpu_enable_intr();
1409         ++ipiq_fifofull;
1410         while (ip->ip_windex - ip->ip_rindex > MAXCPUFIFO / 4) {
1411             KKASSERT(ip->ip_windex - ip->ip_rindex != MAXCPUFIFO - 1);
1412             lwkt_process_ipiq();
1413         }
1414         write_eflags(eflags);
1415     }
1416     --gd->gd_intr_nesting_level;
1417     cpu_send_ipiq(dcpu);        /* issues memory barrier if appropriate */
1418     crit_exit();
1419     return(ip->ip_windex);
1420 }
1421
1422 /*
1423  * Send a message to several target cpus.  Typically used for scheduling.
1424  * The message will not be sent to stopped cpus.
1425  */
1426 void
1427 lwkt_send_ipiq_mask(u_int32_t mask, ipifunc_t func, void *arg)
1428 {
1429     int cpuid;
1430
1431     mask &= ~stopped_cpus;
1432     while (mask) {
1433             cpuid = bsfl(mask);
1434             lwkt_send_ipiq(cpuid, func, arg);
1435             mask &= ~(1 << cpuid);
1436     }
1437 }
1438
1439 /*
1440  * Wait for the remote cpu to finish processing a function.
1441  *
1442  * YYY we have to enable interrupts and process the IPIQ while waiting
1443  * for it to empty or we may deadlock with another cpu.  Create a CPU_*()
1444  * function to do this!  YYY we really should 'block' here.
1445  *
1446  * Must be called from a critical section.  Thsi routine may be called
1447  * from an interrupt (for example, if an interrupt wakes a foreign thread
1448  * up).
1449  */
1450 void
1451 lwkt_wait_ipiq(int dcpu, int seq)
1452 {
1453     lwkt_ipiq_t ip;
1454     int maxc = 100000000;
1455
1456     if (dcpu != mycpu->gd_cpuid) {
1457         KKASSERT(dcpu >= 0 && dcpu < ncpus);
1458         ip = &mycpu->gd_ipiq[dcpu];
1459         if ((int)(ip->ip_xindex - seq) < 0) {
1460             unsigned int eflags = read_eflags();
1461             cpu_enable_intr();
1462             while ((int)(ip->ip_xindex - seq) < 0) {
1463                 lwkt_process_ipiq();
1464                 if (--maxc == 0)
1465                         printf("LWKT_WAIT_IPIQ WARNING! %d wait %d (%d)\n", mycpu->gd_cpuid, dcpu, ip->ip_xindex - seq);
1466                 if (maxc < -1000000)
1467                         panic("LWKT_WAIT_IPIQ");
1468             }
1469             write_eflags(eflags);
1470         }
1471     }
1472 }
1473
1474 /*
1475  * Called from IPI interrupt (like a fast interrupt), which has placed
1476  * us in a critical section.  The MP lock may or may not be held.
1477  * May also be called from doreti or splz, or be reentrantly called
1478  * indirectly through the ip_func[] we run.
1479  */
1480 void
1481 lwkt_process_ipiq(void)
1482 {
1483     int n;
1484     int cpuid = mycpu->gd_cpuid;
1485
1486     for (n = 0; n < ncpus; ++n) {
1487         lwkt_ipiq_t ip;
1488         int ri;
1489
1490         if (n == cpuid)
1491             continue;
1492         ip = globaldata_find(n)->gd_ipiq;
1493         if (ip == NULL)
1494             continue;
1495         ip = &ip[cpuid];
1496
1497         /*
1498          * Note: xindex is only updated after we are sure the function has
1499          * finished execution.  Beware lwkt_process_ipiq() reentrancy!  The
1500          * function may send an IPI which may block/drain.
1501          */
1502         while (ip->ip_rindex != ip->ip_windex) {
1503             ri = ip->ip_rindex & MAXCPUFIFO_MASK;
1504             ++ip->ip_rindex;
1505             ip->ip_func[ri](ip->ip_arg[ri]);
1506             /* YYY memory barrier */
1507             ip->ip_xindex = ip->ip_rindex;
1508         }
1509     }
1510 }
1511
1512 #else
1513
1514 int
1515 lwkt_send_ipiq(int dcpu, ipifunc_t func, void *arg)
1516 {
1517     panic("lwkt_send_ipiq: UP box! (%d,%p,%p)", dcpu, func, arg);
1518     return(0); /* NOT REACHED */
1519 }
1520
1521 void
1522 lwkt_wait_ipiq(int dcpu, int seq)
1523 {
1524     panic("lwkt_wait_ipiq: UP box! (%d,%d)", dcpu, seq);
1525 }
1526
1527 #endif