sys/kern/lwkt_serialize.c

   1 /*
   2  * Copyright (c) 2005 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_serialize.c,v 1.15 2008/05/05 12:35:03 sephe Exp $
  35  */
  36 /*
  37  * This API provides a fast locked-bus-cycle-based serializer.  It's
  38  * basically a low level NON-RECURSIVE exclusive lock that can be held across
  39  * a blocking condition.  It is NOT a mutex.
  40  *
  41  * This serializer is primarily designed for low level situations and
  42  * interrupt/device interaction.  There are two primary facilities.  First,
  43  * the serializer facility itself.  Second, an integrated interrupt handler
  44  * disablement facility.
  45  */
  46
  47 #include "opt_serializer.h"
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/kernel.h>
  52 #include <sys/proc.h>
  53 #include <sys/rtprio.h>
  54 #include <sys/queue.h>
  55 #include <sys/thread2.h>
  56 #include <sys/serialize.h>
  57 #include <sys/sysctl.h>
  58 #include <sys/ktr.h>
  59 #include <sys/kthread.h>
  60 #include <machine/cpu.h>
  61 #include <machine/cpufunc.h>
  62 #include <machine/specialreg.h>
  63 #include <sys/lock.h>
  64 #include <sys/caps.h>
  65
  66 struct exp_backoff {
  67         int backoff;
  68         int round;
  69         lwkt_serialize_t s;
  70 };
  71
  72 #define SLZ_KTR_STRING          "slz=%p"
  73 #define SLZ_KTR_ARG_SIZE        (sizeof(void *))
  74
  75 #ifndef KTR_SERIALIZER
  76 #define KTR_SERIALIZER  KTR_ALL
  77 #endif
  78
  79 KTR_INFO_MASTER(slz);
  80 KTR_INFO(KTR_SERIALIZER, slz, enter_beg, 0, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  81 KTR_INFO(KTR_SERIALIZER, slz, sleep_beg, 1, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  82 KTR_INFO(KTR_SERIALIZER, slz, sleep_end, 2, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  83 KTR_INFO(KTR_SERIALIZER, slz, exit_end, 3, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  84 KTR_INFO(KTR_SERIALIZER, slz, wakeup_beg, 4, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  85 KTR_INFO(KTR_SERIALIZER, slz, wakeup_end, 5, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  86 KTR_INFO(KTR_SERIALIZER, slz, try, 6, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  87 KTR_INFO(KTR_SERIALIZER, slz, tryfail, 7, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  88 KTR_INFO(KTR_SERIALIZER, slz, tryok, 8, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  89 KTR_INFO(KTR_SERIALIZER, slz, spinbo, 9,
  90          "slz=%p bo1=%d bo=%d", (sizeof(void *) + (2 * sizeof(int))));
  91 KTR_INFO(KTR_SERIALIZER, slz, enter_end, 10, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  92 KTR_INFO(KTR_SERIALIZER, slz, exit_beg, 11, SLZ_KTR_STRING, SLZ_KTR_ARG_SIZE);
  93
  94 #define logslz(name, slz)               KTR_LOG(slz_ ## name, slz)
  95 #define logslz_spinbo(slz, bo1, bo)     KTR_LOG(slz_spinbo, slz, bo1, bo)
  96
  97 static void lwkt_serialize_sleep(void *info);
  98 #ifdef SMP
  99 static void lwkt_serialize_adaptive_sleep(void *bo);
 100 #endif
 101 static void lwkt_serialize_wakeup(void *info);
 102
 103 #ifdef SMP
 104 static int slz_backoff_limit = 128;
 105 SYSCTL_INT(_debug, OID_AUTO, serialize_bolimit, CTLFLAG_RW,
 106            &slz_backoff_limit, 0, "");
 107
 108 static int slz_backoff_shift = 1;
 109 SYSCTL_INT(_debug, OID_AUTO, serialize_boshift, CTLFLAG_RW,
 110            &slz_backoff_shift, 0, "");
 111
 112 static int slz_backoff_round;
 113 TUNABLE_INT("debug.serialize_boround", &slz_backoff_round);
 114 SYSCTL_INT(_debug, OID_AUTO, serialize_boround, CTLFLAG_RW,
 115            &slz_backoff_round, 0, "");
 116 #endif  /* SMP */
 117
 118 void
 119 lwkt_serialize_init(lwkt_serialize_t s)
 120 {
 121     atomic_intr_init(&s->interlock);
 122 #ifdef INVARIANTS
 123     s->last_td = (void *)-4;
 124 #endif
 125     s->sleep_cnt = 0;
 126     s->tryfail_cnt = 0;
 127     s->enter_cnt = 0;
 128     s->try_cnt = 0;
 129 }
 130
 131 #ifdef SMP
 132
 133 void
 134 lwkt_serialize_adaptive_enter(lwkt_serialize_t s)
 135 {
 136     struct exp_backoff bo;
 137
 138     bo.backoff = 1;
 139     bo.round = 0;
 140     bo.s = s;
 141
 142 #ifdef INVARIANTS
 143     KKASSERT(s->last_td != curthread);
 144 #endif
 145     logslz(enter_beg, s);
 146     atomic_intr_cond_enter(&s->interlock, lwkt_serialize_adaptive_sleep, &bo);
 147     logslz(enter_end, s);
 148 #ifdef INVARIANTS
 149     s->last_td = curthread;
 150 #endif
 151 #ifdef PROFILE_SERIALIZER
 152     s->enter_cnt++;
 153 #endif
 154 }
 155
 156 #endif  /* SMP */
 157
 158 void
 159 lwkt_serialize_enter(lwkt_serialize_t s)
 160 {
 161 #ifdef INVARIANTS
 162     KKASSERT(s->last_td != curthread);
 163 #endif
 164     logslz(enter_beg, s);
 165     atomic_intr_cond_enter(&s->interlock, lwkt_serialize_sleep, s);
 166     logslz(enter_end, s);
 167 #ifdef INVARIANTS
 168     s->last_td = curthread;
 169 #endif
 170 #ifdef PROFILE_SERIALIZER
 171     s->enter_cnt++;
 172 #endif
 173 }
 174
 175 /*
 176  * Returns non-zero on success
 177  */
 178 int
 179 lwkt_serialize_try(lwkt_serialize_t s)
 180 {
 181     int error;
 182
 183 #ifdef INVARIANTS
 184     KKASSERT(s->last_td != curthread);
 185 #endif
 186 #ifdef PROFILE_SERIALIZER
 187     s->try_cnt++;
 188 #endif
 189     logslz(try, s);
 190     if ((error = atomic_intr_cond_try(&s->interlock)) == 0) {
 191 #ifdef INVARIANTS
 192         s->last_td = curthread;
 193 #endif
 194         logslz(tryok, s);
 195         return(1);
 196     }
 197 #ifdef PROFILE_SERIALIZER
 198     s->tryfail_cnt++;
 199 #endif
 200     logslz(tryfail, s);
 201     return (0);
 202 }
 203
 204 void
 205 lwkt_serialize_exit(lwkt_serialize_t s)
 206 {
 207 #ifdef INVARIANTS
 208     KKASSERT(s->last_td == curthread);
 209     s->last_td = (void *)-2;
 210 #endif
 211     logslz(exit_beg, s);
 212     atomic_intr_cond_exit(&s->interlock, lwkt_serialize_wakeup, s);
 213     logslz(exit_end, s);
 214 }
 215
 216 /*
 217  * Interrupt handler disablement support, used by drivers.  Non-stackable
 218  * (uses bit 30).
 219  */
 220 void
 221 lwkt_serialize_handler_disable(lwkt_serialize_t s)
 222 {
 223     atomic_intr_handler_disable(&s->interlock);
 224 }
 225
 226 void
 227 lwkt_serialize_handler_enable(lwkt_serialize_t s)
 228 {
 229     atomic_intr_handler_enable(&s->interlock);
 230 }
 231
 232 void
 233 lwkt_serialize_handler_call(lwkt_serialize_t s, void (*func)(void *, void *),
 234                             void *arg, void *frame)
 235 {
 236     /*
 237      * note: a return value of 0 indicates that the interrupt handler is
 238      * enabled.
 239      */
 240     if (atomic_intr_handler_is_enabled(&s->interlock) == 0) {
 241         logslz(enter_beg, s);
 242         atomic_intr_cond_enter(&s->interlock, lwkt_serialize_sleep, s);
 243         logslz(enter_end, s);
 244 #ifdef INVARIANTS
 245         s->last_td = curthread;
 246 #endif
 247 #ifdef PROFILE_SERIALIZER
 248         s->enter_cnt++;
 249 #endif
 250         if (atomic_intr_handler_is_enabled(&s->interlock) == 0)
 251             func(arg, frame);
 252 #ifdef INVARIANTS
 253         KKASSERT(s->last_td == curthread);
 254         s->last_td = (void *)-2;
 255 #endif
 256         logslz(exit_beg, s);
 257         atomic_intr_cond_exit(&s->interlock, lwkt_serialize_wakeup, s);
 258         logslz(exit_end, s);
 259     }
 260 }
 261
 262 /*
 263  * Similar to handler_call but does not block.  Returns 0 on success,
 264  * and 1 on failure.
 265  */
 266 int
 267 lwkt_serialize_handler_try(lwkt_serialize_t s, void (*func)(void *, void *),
 268                            void *arg, void *frame)
 269 {
 270     /*
 271      * note: a return value of 0 indicates that the interrupt handler is
 272      * enabled.
 273      */
 274     if (atomic_intr_handler_is_enabled(&s->interlock) == 0) {
 275 #ifdef PROFILE_SERIALIZER
 276         s->try_cnt++;
 277 #endif
 278         logslz(try, s);
 279         if (atomic_intr_cond_try(&s->interlock) == 0) {
 280 #ifdef INVARIANTS
 281             s->last_td = curthread;
 282 #endif
 283             logslz(tryok, s);
 284             func(arg, frame);
 285 #ifdef INVARIANTS
 286             KKASSERT(s->last_td == curthread);
 287             s->last_td = (void *)-2;
 288 #endif
 289             logslz(exit_beg, s);
 290             atomic_intr_cond_exit(&s->interlock, lwkt_serialize_wakeup, s);
 291             logslz(exit_end, s);
 292             return(0);
 293         }
 294     }
 295 #ifdef PROFILE_SERIALIZER
 296     s->tryfail_cnt++;
 297 #endif
 298     logslz(tryfail, s);
 299     return(1);
 300 }
 301
 302
 303 /*
 304  * Helper functions
 305  *
 306  * It is possible to race an interrupt which acquires and releases the
 307  * bit, then calls wakeup before we actually go to sleep, so we
 308  * need to check that the interlock is still acquired from within
 309  * a critical section prior to sleeping.
 310  */
 311 static void
 312 lwkt_serialize_sleep(void *info)
 313 {
 314     lwkt_serialize_t s = info;
 315     crit_enter();
 316     tsleep_interlock(s);
 317     if (atomic_intr_cond_test(&s->interlock) != 0) {
 318 #ifdef PROFILE_SERIALIZER
 319         s->sleep_cnt++;
 320 #endif
 321         logslz(sleep_beg, s);
 322         tsleep(s, 0, "slize", 0);
 323         logslz(sleep_end, s);
 324     }
 325     crit_exit();
 326 }
 327
 328 #ifdef SMP
 329
 330 static void
 331 lwkt_serialize_adaptive_sleep(void *arg)
 332 {
 333     struct exp_backoff *bo = arg;
 334     lwkt_serialize_t s = bo->s;
 335     int backoff;
 336
 337     /*
 338      * Randomize backoff value
 339      */
 340 #ifdef _RDTSC_SUPPORTED_
 341     if (cpu_feature & CPUID_TSC) {
 342         backoff =
 343         (((u_long)rdtsc() ^ (((u_long)curthread) >> 5)) &
 344          (bo->backoff - 1)) + 1;
 345     } else
 346 #endif
 347         backoff = bo->backoff;
 348
 349     logslz_spinbo(s, bo->backoff, backoff);
 350
 351     /*
 352      * Quick backoff
 353      */
 354     for (; backoff; --backoff)
 355         cpu_nop();
 356     if (bo->backoff < slz_backoff_limit) {
 357         bo->backoff <<= slz_backoff_shift;
 358         return;
 359     } else {
 360         bo->backoff = 1;
 361         bo->round++;
 362         if (bo->round >= slz_backoff_round)
 363             bo->round = 0;
 364         else
 365             return;
 366     }
 367
 368     crit_enter();
 369     tsleep_interlock(s);
 370     if (atomic_intr_cond_test(&s->interlock) != 0) {
 371 #ifdef PROFILE_SERIALIZER
 372         s->sleep_cnt++;
 373 #endif
 374         logslz(sleep_beg, s);
 375         tsleep(s, 0, "slize", 0);
 376         logslz(sleep_end, s);
 377     }
 378     crit_exit();
 379 }
 380
 381 #endif  /* SMP */
 382
 383 static void
 384 lwkt_serialize_wakeup(void *info)
 385 {
 386     logslz(wakeup_beg, info);
 387     wakeup(info);
 388     logslz(wakeup_end, info);
 389 }
 390
 391 #ifdef SMP
 392 static void
 393 lwkt_serialize_sysinit(void *dummy __unused)
 394 {
 395         if (slz_backoff_round <= 0)
 396                 slz_backoff_round = ncpus * 2;
 397 }
 398 SYSINIT(lwkt_serialize, SI_SUB_PRE_DRIVERS, SI_ORDER_SECOND,
 399         lwkt_serialize_sysinit, NULL);
 400 #endif