sys/kern/lwkt_token.c

   1 /*
   2  * Copyright (c) 2003,2004,2009 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
  35 /*
  36  * lwkt_token - Implement soft token locks.
  37  *
  38  * Tokens are locks which serialize a thread only while the thread is
  39  * running.  If the thread blocks all tokens are released, then reacquired
  40  * when the thread resumes.
  41  *
  42  * This implementation requires no critical sections or spin locks, but
  43  * does use atomic_cmpset_ptr().
  44  *
  45  * Tokens may be recursively acquired by the same thread.  However the
  46  * caller must be sure to release such tokens in reverse order.
  47  */
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/kernel.h>
  51 #include <sys/proc.h>
  52 #include <sys/rtprio.h>
  53 #include <sys/queue.h>
  54 #include <sys/sysctl.h>
  55 #include <sys/ktr.h>
  56 #include <sys/kthread.h>
  57 #include <machine/cpu.h>
  58 #include <sys/lock.h>
  59 #include <sys/caps.h>
  60 #include <sys/spinlock.h>
  61
  62 #include <sys/thread2.h>
  63 #include <sys/spinlock2.h>
  64 #include <sys/mplock2.h>
  65
  66 #include <vm/vm.h>
  67 #include <vm/vm_param.h>
  68 #include <vm/vm_kern.h>
  69 #include <vm/vm_object.h>
  70 #include <vm/vm_page.h>
  71 #include <vm/vm_map.h>
  72 #include <vm/vm_pager.h>
  73 #include <vm/vm_extern.h>
  74 #include <vm/vm_zone.h>
  75
  76 #include <machine/stdarg.h>
  77 #include <machine/smp.h>
  78
  79 #ifndef LWKT_NUM_POOL_TOKENS
  80 #define LWKT_NUM_POOL_TOKENS    1024    /* power of 2 */
  81 #endif
  82 #define LWKT_MASK_POOL_TOKENS   (LWKT_NUM_POOL_TOKENS - 1)
  83
  84 #ifdef INVARIANTS
  85 static int token_debug = 0;
  86 #endif
  87
  88 static lwkt_token       pool_tokens[LWKT_NUM_POOL_TOKENS];
  89
  90 #define TOKEN_STRING    "REF=%p TOK=%p TD=%p"
  91 #define CONTENDED_STRING        "REF=%p TOK=%p TD=%p (contention started)"
  92 #define UNCONTENDED_STRING      "REF=%p TOK=%p TD=%p (contention stopped)"
  93 #if !defined(KTR_TOKENS)
  94 #define KTR_TOKENS      KTR_ALL
  95 #endif
  96
  97 KTR_INFO_MASTER(tokens);
  98 KTR_INFO(KTR_TOKENS, tokens, fail, 0, TOKEN_STRING, sizeof(void *) * 3);
  99 KTR_INFO(KTR_TOKENS, tokens, succ, 1, TOKEN_STRING, sizeof(void *) * 3);
 100 #if 0
 101 KTR_INFO(KTR_TOKENS, tokens, release, 2, TOKEN_STRING, sizeof(void *) * 3);
 102 KTR_INFO(KTR_TOKENS, tokens, remote, 3, TOKEN_STRING, sizeof(void *) * 3);
 103 KTR_INFO(KTR_TOKENS, tokens, reqremote, 4, TOKEN_STRING, sizeof(void *) * 3);
 104 KTR_INFO(KTR_TOKENS, tokens, reqfail, 5, TOKEN_STRING, sizeof(void *) * 3);
 105 KTR_INFO(KTR_TOKENS, tokens, drain, 6, TOKEN_STRING, sizeof(void *) * 3);
 106 KTR_INFO(KTR_TOKENS, tokens, contention_start, 7, CONTENDED_STRING, sizeof(void *) * 3);
 107 KTR_INFO(KTR_TOKENS, tokens, contention_stop, 7, UNCONTENDED_STRING, sizeof(void *) * 3);
 108 #endif
 109
 110 #define logtoken(name, ref)                                             \
 111         KTR_LOG(tokens_ ## name, ref, ref->tr_tok, curthread)
 112
 113 #ifdef INVARIANTS
 114 SYSCTL_INT(_lwkt, OID_AUTO, token_debug, CTLFLAG_RW, &token_debug, 0, "");
 115 #endif
 116
 117 /*
 118  * Return a pool token given an address
 119  */
 120 static __inline
 121 lwkt_token_t
 122 _lwkt_token_pool_lookup(void *ptr)
 123 {
 124         int i;
 125
 126         i = ((int)(intptr_t)ptr >> 2) ^ ((int)(intptr_t)ptr >> 12);
 127         return(&pool_tokens[i & LWKT_MASK_POOL_TOKENS]);
 128 }
 129
 130 /*
 131  * Initialize a tokref_t prior to making it visible in the thread's
 132  * token array.
 133  */
 134 static __inline
 135 void
 136 _lwkt_tokref_init(lwkt_tokref_t ref, lwkt_token_t tok, thread_t td)
 137 {
 138         ref->tr_tok = tok;
 139         ref->tr_owner = td;
 140         ref->tr_flags = tok->t_flags;
 141 }
 142
 143 /*
 144  * Obtain all the tokens required by the specified thread on the current
 145  * cpu, return 0 on failure and non-zero on success.  If a failure occurs
 146  * any partially acquired tokens will be released prior to return.
 147  *
 148  * lwkt_getalltokens is called by the LWKT scheduler to acquire all
 149  * tokens that the thread had acquired prior to going to sleep.
 150  *
 151  * The scheduler is responsible for maintaining the MP lock count, so
 152  * we don't need to deal with tr_flags here.
 153  *
 154  * Called from a critical section.
 155  */
 156 int
 157 lwkt_getalltokens(thread_t td)
 158 {
 159         lwkt_tokref_t scan;
 160         lwkt_tokref_t ref;
 161         lwkt_token_t tok;
 162
 163         /*
 164          * Acquire tokens in forward order, assign or validate tok->t_ref.
 165          */
 166         for (scan = &td->td_toks_base; scan < td->td_toks_stop; ++scan) {
 167                 tok = scan->tr_tok;
 168                 for (;;) {
 169                         /*
 170                          * Try to acquire the token if we do not already have
 171                          * it.
 172                          *
 173                          * NOTE: If atomic_cmpset_ptr() fails we have to
 174                          *       loop and try again.  It just means we
 175                          *       lost a cpu race.
 176                          */
 177                         ref = tok->t_ref;
 178                         if (ref == NULL) {
 179                                 if (atomic_cmpset_ptr(&tok->t_ref, NULL, scan))
 180                                         break;
 181                                 continue;
 182                         }
 183
 184                         /*
 185                          * Test if ref is already recursively held by this
 186                          * thread.  We cannot safely dereference tok->t_ref
 187                          * (it might belong to another thread and is thus
 188                          * unstable), but we don't have to. We can simply
 189                          * range-check it.
 190                          */
 191                         if (ref >= &td->td_toks_base && ref < td->td_toks_stop)
 192                                 break;
 193
 194                         /*
 195                          * Otherwise we failed to acquire all the tokens.
 196                          * Undo and return.
 197                          */
 198                         lwkt_relalltokens(td);
 199                         return(FALSE);
 200                 }
 201         }
 202         return (TRUE);
 203 }
 204
 205 /*
 206  * Release all tokens owned by the specified thread on the current cpu.
 207  *
 208  * This code is really simple.  Even in cases where we own all the tokens
 209  * note that t_ref may not match the scan for recursively held tokens,
 210  * or for the case where a lwkt_getalltokens() failed.
 211  *
 212  * The scheduler is responsible for maintaining the MP lock count, so
 213  * we don't need to deal with tr_flags here.
 214  *
 215  * Called from a critical section.
 216  */
 217 void
 218 lwkt_relalltokens(thread_t td)
 219 {
 220         lwkt_tokref_t scan;
 221         lwkt_token_t tok;
 222
 223         for (scan = &td->td_toks_base; scan < td->td_toks_stop; ++scan) {
 224                 tok = scan->tr_tok;
 225                 if (tok->t_ref == scan)
 226                         tok->t_ref = NULL;
 227         }
 228 }
 229
 230 /*
 231  * Token acquisition helper function.  The caller must have already
 232  * made nref visible by adjusting td_toks_stop and will be responsible
 233  * for the disposition of nref on either success or failure.
 234  *
 235  * When acquiring tokens recursively we want tok->t_ref to point to
 236  * the outer (first) acquisition so it gets cleared only on the last
 237  * release.
 238  */
 239 static __inline
 240 int
 241 _lwkt_trytokref2(lwkt_tokref_t nref, thread_t td)
 242 {
 243         lwkt_token_t tok;
 244         lwkt_tokref_t ref;
 245
 246         KKASSERT(td->td_gd->gd_intr_nesting_level == 0);
 247
 248         /*
 249          * Make sure the compiler does not reorder prior instructions
 250          * beyond this demark.
 251          */
 252         cpu_ccfence();
 253
 254         /*
 255          * Attempt to gain ownership
 256          */
 257         tok = nref->tr_tok;
 258         for (;;) {
 259                 /*
 260                  * Try to acquire the token if we do not already have
 261                  * it.
 262                  */
 263                 ref = tok->t_ref;
 264                 if (ref == NULL) {
 265                         /*
 266                          * NOTE: If atomic_cmpset_ptr() fails we have to
 267                          *       loop and try again.  It just means we
 268                          *       lost a cpu race.
 269                          */
 270                         if (atomic_cmpset_ptr(&tok->t_ref, NULL, nref))
 271                                 return (TRUE);
 272                         continue;
 273                 }
 274
 275                 /*
 276                  * Test if ref is already recursively held by this
 277                  * thread.  We cannot safely dereference tok->t_ref
 278                  * (it might belong to another thread and is thus
 279                  * unstable), but we don't have to. We can simply
 280                  * range-check it.
 281                  */
 282                 if (ref >= &td->td_toks_base && ref < td->td_toks_stop)
 283                         return(TRUE);
 284
 285                 /*
 286                  * Otherwise we failed.
 287                  */
 288                 return(FALSE);
 289         }
 290 }
 291
 292 /*
 293  * Acquire a serializing token.  This routine does not block.
 294  */
 295 static __inline
 296 int
 297 _lwkt_trytokref(lwkt_tokref_t ref, thread_t td)
 298 {
 299         if ((ref->tr_flags & LWKT_TOKEN_MPSAFE) == 0) {
 300                 if (try_mplock() == 0)
 301                         return (FALSE);
 302         }
 303         if (_lwkt_trytokref2(ref, td) == FALSE) {
 304                 /*
 305                  * Cleanup, deactivate the failed token.
 306                  */
 307                 --td->td_toks_stop;
 308                 if ((ref->tr_flags & LWKT_TOKEN_MPSAFE) == 0)
 309                         rel_mplock();
 310                 return (FALSE);
 311         }
 312         return (TRUE);
 313 }
 314
 315 /*
 316  * Acquire a serializing token.  This routine can block.
 317  */
 318 static __inline
 319 void
 320 _lwkt_gettokref(lwkt_tokref_t ref, thread_t td)
 321 {
 322         if ((ref->tr_flags & LWKT_TOKEN_MPSAFE) == 0)
 323                 get_mplock();
 324         if (_lwkt_trytokref2(ref, td) == FALSE) {
 325                 /*
 326                  * Give up running if we can't acquire the token right now.
 327                  *
 328                  * Since the tokref is already active the scheduler now
 329                  * takes care of acquisition, so we need only call
 330                  * lwkt_yield().
 331                  *
 332                  * Since we failed this was not a recursive token so upon
 333                  * return tr_tok->t_ref should be assigned to this specific
 334                  * ref.
 335                  */
 336                 logtoken(fail, ref);
 337                 lwkt_yield();
 338                 logtoken(succ, ref);
 339                 KKASSERT(ref->tr_tok->t_ref == ref);
 340         }
 341 }
 342
 343 void
 344 lwkt_gettoken(lwkt_token_t tok)
 345 {
 346         thread_t td = curthread;
 347         lwkt_tokref_t ref;
 348
 349         ref = td->td_toks_stop;
 350         KKASSERT(ref < &td->td_toks_end);
 351         _lwkt_tokref_init(ref, tok, td);
 352         ++td->td_toks_stop;
 353         _lwkt_gettokref(ref, td);
 354 }
 355
 356 lwkt_token_t
 357 lwkt_getpooltoken(void *ptr)
 358 {
 359         thread_t td = curthread;
 360         lwkt_token_t tok;
 361         lwkt_tokref_t ref;
 362
 363         ref = td->td_toks_stop;
 364         KKASSERT(ref < &td->td_toks_end);
 365         tok = _lwkt_token_pool_lookup(ptr);
 366         _lwkt_tokref_init(ref, tok, td);
 367         ++td->td_toks_stop;
 368         _lwkt_gettokref(ref, td);
 369         return(tok);
 370 }
 371
 372 int
 373 lwkt_trytoken(lwkt_token_t tok)
 374 {
 375         thread_t td = curthread;
 376         lwkt_tokref_t ref;
 377
 378         ref = td->td_toks_stop;
 379         KKASSERT(ref < &td->td_toks_end);
 380         _lwkt_tokref_init(ref, tok, td);
 381         ++td->td_toks_stop;
 382         return(_lwkt_trytokref(ref, td));
 383 }
 384
 385 /*
 386  * Release a serializing token.
 387  *
 388  * WARNING!  All tokens must be released in reverse order.  This will be
 389  *           asserted.
 390  */
 391 void
 392 lwkt_reltoken(lwkt_token_t tok)
 393 {
 394         thread_t td = curthread;
 395         lwkt_tokref_t ref;
 396
 397         /*
 398          * Remove ref from thread token list and assert that it matches
 399          * the token passed in.  Tokens must be released in reverse order.
 400          */
 401         ref = td->td_toks_stop - 1;
 402         KKASSERT(ref >= &td->td_toks_base && ref->tr_tok == tok);
 403         td->td_toks_stop = ref;
 404
 405         /*
 406          * If the token was not MPSAFE release the MP lock.
 407          */
 408         if ((ref->tr_flags & LWKT_TOKEN_MPSAFE) == 0)
 409                 rel_mplock();
 410
 411         /*
 412          * Make sure the compiler does not reorder the clearing of
 413          * tok->t_ref.
 414          */
 415         cpu_ccfence();
 416
 417         /*
 418          * Only clear the token if it matches ref.  If ref was a recursively
 419          * acquired token it may not match.
 420          */
 421         if (tok->t_ref == ref)
 422                 tok->t_ref = NULL;
 423 }
 424
 425 /*
 426  * Pool tokens are used to provide a type-stable serializing token
 427  * pointer that does not race against disappearing data structures.
 428  *
 429  * This routine is called in early boot just after we setup the BSP's
 430  * globaldata structure.
 431  */
 432 void
 433 lwkt_token_pool_init(void)
 434 {
 435         int i;
 436
 437         for (i = 0; i < LWKT_NUM_POOL_TOKENS; ++i)
 438                 lwkt_token_init(&pool_tokens[i], 1);
 439 }
 440
 441 lwkt_token_t
 442 lwkt_token_pool_lookup(void *ptr)
 443 {
 444         return (_lwkt_token_pool_lookup(ptr));
 445 }
 446
 447 /*
 448  * Initialize the owner and release-to cpu to the current cpu
 449  * and reset the generation count.
 450  */
 451 void
 452 lwkt_token_init(lwkt_token_t tok, int mpsafe)
 453 {
 454         tok->t_ref = NULL;
 455         tok->t_flags = mpsafe ? LWKT_TOKEN_MPSAFE : 0;
 456 }
 457
 458 void
 459 lwkt_token_uninit(lwkt_token_t tok)
 460 {
 461         /* empty */
 462 }
 463
 464 #if 0
 465 int
 466 lwkt_token_is_stale(lwkt_tokref_t ref)
 467 {
 468         lwkt_token_t tok = ref->tr_tok;
 469
 470         KKASSERT(tok->t_owner == curthread && ref->tr_state == 1 &&
 471                  tok->t_count > 0);
 472
 473         /* Token is not stale */
 474         if (tok->t_lastowner == tok->t_owner)
 475                 return (FALSE);
 476
 477         /*
 478          * The token is stale. Reset to not stale so that the next call to
 479          * lwkt_token_is_stale will return "not stale" unless the token
 480          * was acquired in-between by another thread.
 481          */
 482         tok->t_lastowner = tok->t_owner;
 483         return (TRUE);
 484 }
 485 #endif