c38e816b8268745acd5b05a9b7656b883fc1e862
[dragonfly.git] / sys / kern / lwkt_token.c
1 /*
2  * Copyright (c) 2003,2004 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/kern/lwkt_token.c,v 1.18 2005/06/20 07:58:39 dillon Exp $
35  */
36
37 #ifdef _KERNEL
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/kernel.h>
42 #include <sys/proc.h>
43 #include <sys/rtprio.h>
44 #include <sys/queue.h>
45 #include <sys/thread2.h>
46 #include <sys/sysctl.h>
47 #include <sys/kthread.h>
48 #include <machine/cpu.h>
49 #include <sys/lock.h>
50 #include <sys/caps.h>
51
52 #include <vm/vm.h>
53 #include <vm/vm_param.h>
54 #include <vm/vm_kern.h>
55 #include <vm/vm_object.h>
56 #include <vm/vm_page.h>
57 #include <vm/vm_map.h>
58 #include <vm/vm_pager.h>
59 #include <vm/vm_extern.h>
60 #include <vm/vm_zone.h>
61
62 #include <machine/stdarg.h>
63 #include <machine/ipl.h>
64 #include <machine/smp.h>
65
66 #define THREAD_STACK    (UPAGES * PAGE_SIZE)
67
68 #else
69
70 #include <sys/stdint.h>
71 #include <libcaps/thread.h>
72 #include <sys/thread.h>
73 #include <sys/msgport.h>
74 #include <sys/errno.h>
75 #include <libcaps/globaldata.h>
76 #include <machine/cpufunc.h>
77 #include <sys/thread2.h>
78 #include <sys/msgport2.h>
79 #include <stdio.h>
80 #include <stdlib.h>
81 #include <string.h>
82 #include <machine/lock.h>
83 #include <machine/cpu.h>
84
85 #endif
86
87 #define MAKE_TOKENS_SPIN
88 /* #define MAKE_TOKENS_YIELD */
89
90 #ifndef LWKT_NUM_POOL_TOKENS
91 #define LWKT_NUM_POOL_TOKENS    1024    /* power of 2 */
92 #endif
93 #define LWKT_MASK_POOL_TOKENS   (LWKT_NUM_POOL_TOKENS - 1)
94
95 #ifdef INVARIANTS
96 static int token_debug = 0;
97 #endif
98
99 #ifdef SMP
100 static void lwkt_reqtoken_remote(void *data);
101 #endif
102
103 static lwkt_token       pool_tokens[LWKT_NUM_POOL_TOKENS];
104
105 /*
106  * Token debugging code, log token operations and who called them.
107  */
108 #ifdef DEBUG_TOKENS
109
110 static struct toklog {
111     enum tokenum { TOKTRY, TOKGET, TOKREL1, TOKREL2, TOKREMOTE,
112                    TOKREQREMOTE, TOKREQFAIL, TOKDRAIN } type;
113     int toremote;
114     lwkt_tokref_t ref;
115     lwkt_token_t tok;
116     thread_t td;
117     void *caller;
118 } toklog[SMP_MAXCPU][2048];
119
120 static int tokindex[SMP_MAXCPU];
121
122 static void
123 logtoken(lwkt_tokref_t ref, void *stackptr, enum tokenum type)
124 {
125     struct toklog *log;
126     globaldata_t gd;
127
128     if (panicstr == NULL) {
129         gd = mycpu;
130         crit_enter();
131         log = &toklog[gd->gd_cpuid][tokindex[gd->gd_cpuid]];
132         log->type = type;
133         log->ref = ref;
134         log->tok = ref->tr_tok;
135         if (stackptr)
136             log->caller = ((void **)stackptr)[-1];
137         else
138             log->caller = NULL;
139         log->td = gd->gd_curthread;
140         tokindex[gd->gd_cpuid] = (tokindex[gd->gd_cpuid] + 1) & 2047;
141         crit_exit();
142     }
143 }
144
145 #else
146
147 #define logtoken(ref, stackptr, type)
148
149 #endif
150
151 #ifdef _KERNEL
152
153 #ifdef INVARIANTS
154 SYSCTL_INT(_lwkt, OID_AUTO, token_debug, CTLFLAG_RW, &token_debug, 0, "");
155 #endif
156
157 #endif
158
159 #ifdef SMP
160
161 /*
162  * Determine if we own all the tokens in the token reference list.
163  * Return 1 on success, 0 on failure. 
164  *
165  * As a side effect, queue requests for tokens we want which are owned
166  * by other cpus.  The magic number is used to communicate when the 
167  * target cpu has processed the request.  Note, however, that the
168  * target cpu may not be able to assign the token to us which is why
169  * the scheduler must spin.
170  */
171 int
172 lwkt_chktokens(thread_t td)
173 {
174     globaldata_t gd = td->td_gd;        /* mycpu */
175     lwkt_tokref_t refs;
176     globaldata_t dgd;
177     lwkt_token_t tok;
178     __uint32_t magic;
179     int r = 1;
180
181     KKASSERT(gd->gd_curthread->td_pri >= TDPRI_CRIT);
182     for (refs = td->td_toks; refs; refs = refs->tr_next) {
183         tok = refs->tr_tok;
184         if ((dgd = tok->t_cpu) != gd) {
185             cpu_ccfence();      /* don't let the compiler reload tok->t_cpu */
186             r = 0;
187
188             /*
189              * Queue a request to the target cpu, exit the loop early if
190              * we are unable to queue the IPI message.  The magic number
191              * flags whether we have a pending ipi request queued or not.
192              * It can be set from MAGIC2 to MAGIC1 by a remote cpu but can
193              * only be set from MAGIC1 to MAGIC2 by our cpu.
194              */
195             magic = refs->tr_magic;
196             cpu_ccfence();
197             if (magic == LWKT_TOKREF_MAGIC1) {
198                 refs->tr_magic = LWKT_TOKREF_MAGIC2;    /* MP synched slowreq*/
199                 refs->tr_reqgd = gd;
200                 tok->t_reqcpu = gd;     /* MP unsynchronized 'fast' req */
201
202                 logtoken(refs, &td, TOKREQREMOTE);
203
204                 if (lwkt_send_ipiq_nowait(dgd, lwkt_reqtoken_remote, refs)) {
205                     /* failed */
206                     refs->tr_magic = LWKT_TOKREF_MAGIC1;
207
208                     logtoken(refs, &td, TOKREQFAIL);
209                     break;
210                 }
211             } else if (magic != LWKT_TOKREF_MAGIC2) {
212                 panic("lwkt_chktoken(): token ref %p tok %p bad magic %08x\n",
213                         refs, refs->tr_tok, magic);
214             }
215         }
216     }
217     return(r);
218 }
219
220 #endif
221
222 /*
223  * Check if we already own the token.  Return 1 on success, 0 on failure.
224  */
225 int
226 lwkt_havetoken(lwkt_token_t tok)
227 {
228     globaldata_t gd = mycpu;
229     thread_t td = gd->gd_curthread;
230     lwkt_tokref_t ref;
231
232     for (ref = td->td_toks; ref; ref = ref->tr_next) {
233         if (ref->tr_tok == tok)
234             return(1);
235     }
236     return(0);
237 }
238
239 int
240 lwkt_havetokref(lwkt_tokref_t xref)
241 {
242     globaldata_t gd = mycpu;
243     thread_t td = gd->gd_curthread;
244     lwkt_tokref_t ref;
245
246     for (ref = td->td_toks; ref; ref = ref->tr_next) {
247         if (ref == xref)
248             return(1);
249     }
250     return(0);
251 }
252
253 #ifdef SMP
254
255 /*
256  * Returns 1 if it is ok to give a token away, 0 if it is not.
257  */
258 static int
259 lwkt_oktogiveaway_token(lwkt_token_t tok)
260 {
261     globaldata_t gd = mycpu;
262     lwkt_tokref_t ref;
263     thread_t td;
264
265     for (td = gd->gd_curthread; td; td = td->td_preempted) {
266         for (ref = td->td_toks; ref; ref = ref->tr_next) {
267             if (ref->tr_tok == tok)
268                 return(0);
269         }
270     }
271     return(1);
272 }
273
274 #endif
275
276 /*
277  * Acquire a serializing token
278  */
279
280 static __inline
281 void
282 _lwkt_gettokref(lwkt_tokref_t ref)
283 {
284     lwkt_tokref_t scan;
285     lwkt_token_t tok;
286     globaldata_t gd;
287     thread_t td;
288
289     gd = mycpu;                 /* our cpu */
290     KKASSERT(ref->tr_magic == LWKT_TOKREF_MAGIC1);
291     KKASSERT(gd->gd_intr_nesting_level == 0);
292     td = gd->gd_curthread;      /* our thread */
293
294     /*
295      * Link the request into our thread's list.  This interlocks against
296      * remote requests from other cpus, prevents the token from being
297      * given away if our cpu already owns it, and interlocks against 
298      * preempting threads which may want the token.  This also allows us to
299      * avoid using a critical section.
300      */
301     ref->tr_next = td->td_toks;
302     cpu_ccfence();      /* prevent compiler reordering */
303     td->td_toks = ref;
304     tok = ref->tr_tok;
305
306     /*
307      * If we are preempting another thread which owns the token we have to
308      * yield to get out from the preemption because we cannot obtain a token
309      * owned by the thread we are preempting.
310      */
311     if (td->td_preempted) {
312         while ((td = td->td_preempted) != NULL) {
313             for (scan = td->td_toks; scan; scan = scan->tr_next) {
314                 if (scan->tr_tok == tok) {
315                     lwkt_yield();
316                     KKASSERT(tok->t_cpu == gd);
317                     goto breakout;
318                 }
319             }
320         }
321 breakout: ;
322         td = gd->gd_curthread;  /* our thread, again */
323     }
324
325     /*
326      * If our cpu does not own the token then (currently) spin while we
327      * await it.  XXX we should yield here but some testing is required
328      * before we do so, there could be some interlock issues with e.g.
329      * softupdates before we can yield.  ZZZ
330      */
331 #ifdef SMP
332     if (tok->t_cpu != gd) {
333 #if defined(MAKE_TOKENS_SPIN)
334         int x = 40000000;
335         int y = 10;
336         crit_enter();
337         while (lwkt_chktokens(td) == 0) {
338             lwkt_process_ipiq();
339             lwkt_drain_token_requests();
340             if (--x == 0) {
341                 x = 40000000;
342                 printf("CHKTOKEN looping on cpu %d\n", gd->gd_cpuid);
343 #ifdef _KERNEL
344                 if (--y == 0)
345                         panic("CHKTOKEN looping on cpu %d", gd->gd_cpuid);
346 #endif
347             }
348             splz();
349         }
350         crit_exit();
351 #elif defined(MAKE_TOKENS_YIELD)
352         lwkt_yield();
353 #else
354 #error MAKE_TOKENS_XXX ?
355 #endif
356         KKASSERT(tok->t_cpu == gd);
357     }
358 #endif
359 }
360
361
362 /*
363  * Attempt to acquire a serializing token
364  */
365 static __inline
366 int
367 _lwkt_trytokref(lwkt_tokref_t ref)
368 {
369     lwkt_token_t tok;
370     globaldata_t gd;
371     thread_t td;
372
373     gd = mycpu;                 /* our cpu */
374     KKASSERT(ref->tr_magic == LWKT_TOKREF_MAGIC1);
375     KKASSERT(gd->gd_intr_nesting_level == 0);
376     td = gd->gd_curthread;      /* our thread */
377
378     /*
379      * Link the request into our thread's list.  This interlocks against
380      * remote requests from other cpus and prevents the token from being
381      * given away if our cpu already owns it.  This also allows us to
382      * avoid using a critical section.
383      *
384      * Force a panic to occur if chktokens is called while the reference
385      * is linked to td_toks but before we have resolved whether we can
386      * keep it.  chktokens should never be called on our ref list
387      * preemptively.
388      */
389     ref->tr_magic = LWKT_TOKREF_MAGIC3;
390     ref->tr_next = td->td_toks;
391     cpu_ccfence();      /* prevent compiler reordering */
392     td->td_toks = ref;
393
394     /*
395      * If our cpu does not own the token then stop now.
396      *
397      * Otherwise make sure the token is not held by a thread we are
398      * preempting.  If it is, stop.
399      */
400     tok = ref->tr_tok;
401 #ifdef SMP
402     if (tok->t_cpu != gd) {
403         td->td_toks = ref->tr_next;     /* remove ref */
404         ref->tr_magic = LWKT_TOKREF_MAGIC1;
405         return(0);
406     }
407 #endif
408     if (td->td_preempted) {
409         while ((td = td->td_preempted) != NULL) {
410             lwkt_tokref_t scan;
411             for (scan = td->td_toks; scan; scan = scan->tr_next) {
412                 if (scan->tr_tok == tok) {
413                     td = gd->gd_curthread;      /* our thread */
414                     td->td_toks = ref->tr_next; /* remove ref */
415                     ref->tr_magic = LWKT_TOKREF_MAGIC1;
416                     return(0);
417                 }
418             }
419         }
420     }
421
422     /*
423      * We own the token, legitimize the reference.
424      */
425     ref->tr_magic = LWKT_TOKREF_MAGIC1;
426     /* 'td' variable no longer valid */
427     return(1);
428 }
429
430 void
431 lwkt_gettoken(lwkt_tokref_t ref, lwkt_token_t tok)
432 {
433     lwkt_tokref_init(ref, tok);
434     logtoken(ref, &ref, TOKGET);
435     _lwkt_gettokref(ref);
436 }
437
438 void
439 lwkt_gettokref(lwkt_tokref_t ref)
440 {
441     logtoken(ref, &ref, TOKGET);
442     _lwkt_gettokref(ref);
443 }
444
445 int
446 lwkt_trytoken(lwkt_tokref_t ref, lwkt_token_t tok)
447 {
448     lwkt_tokref_init(ref, tok);
449     logtoken(ref, &ref, TOKTRY);
450     return(_lwkt_trytokref(ref));
451 }
452
453 int
454 lwkt_trytokref(lwkt_tokref_t ref)
455 {
456     logtoken(ref, &ref, TOKTRY);
457     return(_lwkt_trytokref(ref));
458 }
459
460 /*
461  * Release a serializing token
462  */
463 void
464 lwkt_reltoken(lwkt_tokref *_ref)
465 {
466     lwkt_tokref_t scan;
467     lwkt_tokref *ref;
468     lwkt_tokref **pref;
469     lwkt_token_t tok;
470     globaldata_t gd;
471     thread_t td;
472     int giveaway;
473
474     logtoken(_ref, &_ref, TOKREL1);
475     /*
476      * Guard check and stack check (if in the same stack page).  We must
477      * also wait for any action pending on remote cpus which we do by
478      * checking the magic number and yielding in a loop.
479      */
480     ref = _ref;
481 #ifdef INVARIANTS
482     if ((((intptr_t)ref ^ (intptr_t)&_ref) & ~(intptr_t)PAGE_MASK) == 0)
483         KKASSERT((char *)ref > (char *)&_ref);
484     KKASSERT(ref->tr_magic == LWKT_TOKREF_MAGIC1 || 
485              ref->tr_magic == LWKT_TOKREF_MAGIC2);
486 #endif
487
488     tok = ref->tr_tok;
489     gd = mycpu;
490     td = gd->gd_curthread;
491
492     KKASSERT(tok->t_cpu == gd);
493     KKASSERT(gd->gd_intr_nesting_level == 0);
494
495     /*
496      * We can only give away the token if we aren't holding it recursively.
497      * Also use the opportunity to locate the link field for the token.
498      *
499      * We do not have to scan preempted threads since by definition we cannot
500      * be holding any token held by a thread we are preempting.
501      */
502     giveaway = 1;
503     for (pref = &td->td_toks; (ref = *pref) != _ref; pref = &ref->tr_next) {
504         KKASSERT(ref != NULL);
505         if (ref->tr_tok == tok)
506             giveaway = 0;
507     }
508     for (scan = ref->tr_next; scan; scan = scan->tr_next) {
509         if (scan->tr_tok == tok)
510             giveaway = 0;
511     }
512
513     /*
514      * Give the token away (if we can) before removing the interlock.  Once
515      * the interlock is removed, the token can be given away by an IPI.
516      */
517     if (giveaway)
518         tok->t_cpu = tok->t_reqcpu;     
519     KKASSERT(*pref == ref);
520     *pref = ref->tr_next;
521
522     /*
523      * If we had gotten the token opportunistically and it still happens to
524      * be queued to a target cpu, we have to wait for the target cpu
525      * to finish processing it.  This does not happen very often and does
526      * not need to be optimal.
527      */
528     while (ref->tr_magic == LWKT_TOKREF_MAGIC2) {
529 #if defined(MAKE_TOKENS_SPIN)
530         crit_enter();
531 #ifdef SMP
532         lwkt_process_ipiq();
533 #endif
534         splz();
535         crit_exit();
536 #elif defined(MAKE_TOKENS_YIELD)
537         lwkt_yield();
538 #else
539 #error MAKE_TOKENS_XXX ?
540 #endif
541     }
542     KKASSERT(ref->tr_magic == LWKT_TOKREF_MAGIC1);
543 }
544
545 /*
546  * Pool tokens are used to provide a type-stable serializing token
547  * pointer that does not race against disappearing data structures.
548  *
549  * This routine is called in early boot just after we setup the BSP's
550  * globaldata structure.
551  */
552 void
553 lwkt_token_pool_init(void)
554 {
555     int i;
556
557     for (i = 0; i < LWKT_NUM_POOL_TOKENS; ++i)
558         lwkt_token_init(&pool_tokens[i]);
559 }
560
561 lwkt_token_t
562 lwkt_token_pool_get(void *ptraddr)
563 {
564     int i;
565
566     i = ((int)(intptr_t)ptraddr >> 2) ^ ((int)(intptr_t)ptraddr >> 12);
567     return(&pool_tokens[i & LWKT_MASK_POOL_TOKENS]);
568 }
569
570 #ifdef SMP
571
572 /*
573  * This is the receiving side of a remote IPI requesting a token.  If we
574  * cannot immediately hand the token off to another cpu we queue it.
575  *
576  * NOTE!  we 'own' the ref structure, but we only 'own' the token if
577  * t_cpu == mycpu.
578  */
579 static void
580 lwkt_reqtoken_remote(void *data)
581 {
582     lwkt_tokref_t ref = data;
583     globaldata_t gd = mycpu;
584     lwkt_token_t tok = ref->tr_tok;
585
586     logtoken(ref, &data, TOKREMOTE);
587     /*
588      * We do not have to queue the token if we can give it away
589      * immediately.  Otherwise we queue it to our globaldata structure.
590      */
591     KKASSERT(ref->tr_magic == LWKT_TOKREF_MAGIC2);
592     if (lwkt_oktogiveaway_token(tok)) {
593         if (tok->t_cpu == gd)
594             tok->t_cpu = ref->tr_reqgd;
595         cpu_ccfence();  /* prevent compiler reordering */
596         ref->tr_magic = LWKT_TOKREF_MAGIC1;
597     } else {
598         ref->tr_gdreqnext = gd->gd_tokreqbase;
599         gd->gd_tokreqbase = ref;
600     }
601 }
602
603 /*
604  * Must be called from a critical section.  Satisfy all remote token
605  * requests that are pending on our globaldata structure.  The request
606  * does not have to be satisfied with a successful change of ownership
607  * but we do have to acknowledge that we have completed processing the
608  * request by setting the magic number back to MAGIC1.
609  *
610  * NOTE!  we 'own' the ref structure, but we only 'own' the token if
611  * t_cpu == mycpu.
612  */
613 void
614 lwkt_drain_token_requests(void)
615 {
616     globaldata_t gd = mycpu;
617     lwkt_tokref_t ref;
618
619     KKASSERT(gd->gd_curthread->td_pri >= TDPRI_CRIT);
620     while ((ref = gd->gd_tokreqbase) != NULL) {
621         gd->gd_tokreqbase = ref->tr_gdreqnext;
622         KKASSERT(ref->tr_magic == LWKT_TOKREF_MAGIC2);
623         if (ref->tr_tok->t_cpu == gd)
624             ref->tr_tok->t_cpu = ref->tr_reqgd;
625         cpu_ccfence();  /* prevent compiler reordering */
626         ref->tr_magic = LWKT_TOKREF_MAGIC1;
627     }
628 }
629
630 #endif
631
632 /*
633  * Initialize the owner and release-to cpu to the current cpu
634  * and reset the generation count.
635  */
636 void
637 lwkt_token_init(lwkt_token_t tok)
638 {
639     tok->t_cpu = tok->t_reqcpu = mycpu;
640 }
641
642 void
643 lwkt_token_uninit(lwkt_token_t tok)
644 {
645     /* empty */
646 }