sys/cddl/dev/lockstat/lockstat.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  *
  21  * Portions Copyright (c) 2008-2009 Stacey Son <sson@FreeBSD.org>
  22  *
  23  * $FreeBSD$
  24  *
  25  */
  26
  27 /*
  28  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  29  * Use is subject to license terms.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/conf.h>
  36 #include <sys/kernel.h>
  37 #include <sys/limits.h>
  38 #include <sys/lock.h>
  39 #include <sys/linker.h>
  40 #include <sys/module.h>
  41 #include <sys/mutex.h>
  42
  43 #include <sys/dtrace.h>
  44 #include <sys/lockstat.h>
  45
  46 #if defined(__i386__) || defined(__amd64__) || \
  47         defined(__mips__) || defined(__powerpc__)
  48 #define LOCKSTAT_AFRAMES 1
  49 #else
  50 #error "architecture not supported"
  51 #endif
  52
  53 static d_open_t lockstat_open;
  54 static void     lockstat_provide(void *, dtrace_probedesc_t *);
  55 static void     lockstat_destroy(void *, dtrace_id_t, void *);
  56 static void     lockstat_enable(void *, dtrace_id_t, void *);
  57 static void     lockstat_disable(void *, dtrace_id_t, void *);
  58 static void     lockstat_load(void *);
  59 static int      lockstat_unload(void);
  60
  61
  62 typedef struct lockstat_probe {
  63         char            *lsp_func;
  64         char            *lsp_name;
  65         int             lsp_probe;
  66         dtrace_id_t     lsp_id;
  67 #ifdef __FreeBSD__
  68         int             lsp_frame;
  69 #endif
  70 } lockstat_probe_t;
  71
  72 #ifdef __FreeBSD__
  73 lockstat_probe_t lockstat_probes[] =
  74 {
  75   /* Spin Locks */
  76   { LS_MTX_SPIN_LOCK,   LSS_ACQUIRE,    LS_MTX_SPIN_LOCK_ACQUIRE,
  77           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  78   { LS_MTX_SPIN_LOCK,   LSS_SPIN,       LS_MTX_SPIN_LOCK_SPIN,
  79           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  80   { LS_MTX_SPIN_UNLOCK, LSS_RELEASE,    LS_MTX_SPIN_UNLOCK_RELEASE,
  81           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  82   /* Adaptive Locks */
  83   { LS_MTX_LOCK,        LSA_ACQUIRE,    LS_MTX_LOCK_ACQUIRE,
  84           DTRACE_IDNONE, (LOCKSTAT_AFRAMES + 1) },
  85   { LS_MTX_LOCK,        LSA_BLOCK,      LS_MTX_LOCK_BLOCK,
  86           DTRACE_IDNONE, (LOCKSTAT_AFRAMES + 1) },
  87   { LS_MTX_LOCK,        LSA_SPIN,       LS_MTX_LOCK_SPIN,
  88           DTRACE_IDNONE, (LOCKSTAT_AFRAMES + 1) },
  89   { LS_MTX_UNLOCK,      LSA_RELEASE,    LS_MTX_UNLOCK_RELEASE,
  90           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  91   { LS_MTX_TRYLOCK,     LSA_ACQUIRE,    LS_MTX_TRYLOCK_ACQUIRE,
  92           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  93   /* Reader/Writer Locks */
  94   { LS_RW_RLOCK,        LSR_ACQUIRE,    LS_RW_RLOCK_ACQUIRE,
  95           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  96   { LS_RW_RLOCK,        LSR_BLOCK,      LS_RW_RLOCK_BLOCK,
  97           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
  98   { LS_RW_RLOCK,        LSR_SPIN,       LS_RW_RLOCK_SPIN,
  99           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 100   { LS_RW_RUNLOCK,      LSR_RELEASE,    LS_RW_RUNLOCK_RELEASE,
 101           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 102   { LS_RW_WLOCK,        LSR_ACQUIRE,    LS_RW_WLOCK_ACQUIRE,
 103           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 104   { LS_RW_WLOCK,        LSR_BLOCK,      LS_RW_WLOCK_BLOCK,
 105           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 106   { LS_RW_WLOCK,        LSR_SPIN,       LS_RW_WLOCK_SPIN,
 107           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 108   { LS_RW_WUNLOCK,      LSR_RELEASE,    LS_RW_WUNLOCK_RELEASE,
 109           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 110   { LS_RW_TRYUPGRADE,   LSR_UPGRADE,    LS_RW_TRYUPGRADE_UPGRADE,
 111           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 112   { LS_RW_DOWNGRADE,    LSR_DOWNGRADE,  LS_RW_DOWNGRADE_DOWNGRADE,
 113           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 114   /* Shared/Exclusive Locks */
 115   { LS_SX_SLOCK,        LSX_ACQUIRE,    LS_SX_SLOCK_ACQUIRE,
 116           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 117   { LS_SX_SLOCK,        LSX_BLOCK,      LS_SX_SLOCK_BLOCK,
 118           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 119   { LS_SX_SLOCK,        LSX_SPIN,       LS_SX_SLOCK_SPIN,
 120           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 121   { LS_SX_SUNLOCK,      LSX_RELEASE,    LS_SX_SUNLOCK_RELEASE,
 122           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 123   { LS_SX_XLOCK,        LSX_ACQUIRE,    LS_SX_XLOCK_ACQUIRE,
 124           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 125   { LS_SX_XLOCK,        LSX_BLOCK,      LS_SX_XLOCK_BLOCK,
 126           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 127   { LS_SX_XLOCK,        LSX_SPIN,       LS_SX_XLOCK_SPIN,
 128           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 129   { LS_SX_XUNLOCK,      LSX_RELEASE,    LS_SX_XUNLOCK_RELEASE,
 130           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 131   { LS_SX_TRYUPGRADE,   LSX_UPGRADE,    LS_SX_TRYUPGRADE_UPGRADE,
 132           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 133   { LS_SX_DOWNGRADE,    LSX_DOWNGRADE,  LS_SX_DOWNGRADE_DOWNGRADE,
 134           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 135   /* Thread Locks */
 136   { LS_THREAD_LOCK,     LST_SPIN,       LS_THREAD_LOCK_SPIN,
 137           DTRACE_IDNONE, LOCKSTAT_AFRAMES },
 138   { NULL }
 139 };
 140 #else
 141 #error "OS not supported"
 142 #endif
 143
 144
 145 static struct cdevsw lockstat_cdevsw = {
 146         .d_version      = D_VERSION,
 147         .d_open         = lockstat_open,
 148         .d_name         = "lockstat",
 149 };
 150
 151 static struct cdev              *lockstat_cdev;
 152 static dtrace_provider_id_t     lockstat_id;
 153
 154 /*ARGSUSED*/
 155 static void
 156 lockstat_enable(void *arg, dtrace_id_t id, void *parg)
 157 {
 158         lockstat_probe_t *probe = parg;
 159
 160         ASSERT(!lockstat_probemap[probe->lsp_probe]);
 161
 162         lockstat_probemap[probe->lsp_probe] = id;
 163 #ifdef DOODAD
 164         membar_producer();
 165 #endif
 166
 167         lockstat_probe_func = dtrace_probe;
 168 #ifdef DOODAD
 169         membar_producer();
 170
 171         lockstat_hot_patch();
 172         membar_producer();
 173 #endif
 174 }
 175
 176 /*ARGSUSED*/
 177 static void
 178 lockstat_disable(void *arg, dtrace_id_t id, void *parg)
 179 {
 180         lockstat_probe_t *probe = parg;
 181         int i;
 182
 183         ASSERT(lockstat_probemap[probe->lsp_probe]);
 184
 185         lockstat_probemap[probe->lsp_probe] = 0;
 186 #ifdef DOODAD
 187         lockstat_hot_patch();
 188         membar_producer();
 189 #endif
 190
 191         /*
 192          * See if we have any probes left enabled.
 193          */
 194         for (i = 0; i < LS_NPROBES; i++) {
 195                 if (lockstat_probemap[i]) {
 196                         /*
 197                          * This probe is still enabled.  We don't need to deal
 198                          * with waiting for all threads to be out of the
 199                          * lockstat critical sections; just return.
 200                          */
 201                         return;
 202                 }
 203         }
 204
 205 }
 206
 207 /*ARGSUSED*/
 208 static int
 209 lockstat_open(struct cdev *dev __unused, int oflags __unused,
 210               int devtype __unused, struct thread *td __unused)
 211 {
 212         return (0);
 213 }
 214
 215 /*ARGSUSED*/
 216 static void
 217 lockstat_provide(void *arg, dtrace_probedesc_t *desc)
 218 {
 219         int i = 0;
 220
 221         for (i = 0; lockstat_probes[i].lsp_func != NULL; i++) {
 222                 lockstat_probe_t *probe = &lockstat_probes[i];
 223
 224                 if (dtrace_probe_lookup(lockstat_id, "kernel",
 225                     probe->lsp_func, probe->lsp_name) != 0)
 226                         continue;
 227
 228                 ASSERT(!probe->lsp_id);
 229 #ifdef __FreeBSD__
 230                 probe->lsp_id = dtrace_probe_create(lockstat_id,
 231                     "kernel", probe->lsp_func, probe->lsp_name,
 232                     probe->lsp_frame, probe);
 233 #else
 234                 probe->lsp_id = dtrace_probe_create(lockstat_id,
 235                     "kernel", probe->lsp_func, probe->lsp_name,
 236                     LOCKSTAT_AFRAMES, probe);
 237 #endif
 238         }
 239 }
 240
 241 /*ARGSUSED*/
 242 static void
 243 lockstat_destroy(void *arg, dtrace_id_t id, void *parg)
 244 {
 245         lockstat_probe_t *probe = parg;
 246
 247         ASSERT(!lockstat_probemap[probe->lsp_probe]);
 248         probe->lsp_id = 0;
 249 }
 250
 251 static dtrace_pattr_t lockstat_attr = {
 252 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
 253 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
 254 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
 255 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
 256 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
 257 };
 258
 259 static dtrace_pops_t lockstat_pops = {
 260         lockstat_provide,
 261         NULL,
 262         lockstat_enable,
 263         lockstat_disable,
 264         NULL,
 265         NULL,
 266         NULL,
 267         NULL,
 268         NULL,
 269         lockstat_destroy
 270 };
 271
 272 static void
 273 lockstat_load(void *dummy)
 274 {
 275         /* Create the /dev/dtrace/lockstat entry. */
 276         lockstat_cdev = make_dev(&lockstat_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
 277             "dtrace/lockstat");
 278
 279         if (dtrace_register("lockstat", &lockstat_attr, DTRACE_PRIV_USER,
 280             NULL, &lockstat_pops, NULL, &lockstat_id) != 0)
 281                 return;
 282 }
 283
 284 static int
 285 lockstat_unload()
 286 {
 287         int error = 0;
 288
 289         if ((error = dtrace_unregister(lockstat_id)) != 0)
 290             return (error);
 291
 292         destroy_dev(lockstat_cdev);
 293
 294         return (error);
 295 }
 296
 297 /* ARGSUSED */
 298 static int
 299 lockstat_modevent(module_t mod __unused, int type, void *data __unused)
 300 {
 301         int error = 0;
 302
 303         switch (type) {
 304         case MOD_LOAD:
 305                 break;
 306
 307         case MOD_UNLOAD:
 308                 break;
 309
 310         case MOD_SHUTDOWN:
 311                 break;
 312
 313         default:
 314                 error = EOPNOTSUPP;
 315                 break;
 316         }
 317         return (error);
 318 }
 319
 320 SYSINIT(lockstat_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, lockstat_load, NULL);
 321 SYSUNINIT(lockstat_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY, lockstat_unload, NULL);
 322
 323 DEV_MODULE(lockstat, lockstat_modevent, NULL);
 324 MODULE_VERSION(lockstat, 1);
 325 MODULE_DEPEND(lockstat, dtrace, 1, 1, 1);
 326 MODULE_DEPEND(lockstat, opensolaris, 1, 1, 1);