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