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