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