initial commit
[freebsd-arm:freebsd-arm.git] / cddl / contrib / opensolaris / uts / common / dtrace / 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 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25
26 #pragma ident   "%Z%%M% %I%     %E% SMI"
27
28 #include <sys/types.h>
29 #include <sys/param.h>
30 #include <sys/stat.h>
31 #include <sys/open.h>
32 #include <sys/file.h>
33 #include <sys/conf.h>
34 #include <sys/modctl.h>
35 #include <sys/cmn_err.h>
36 #include <sys/bitmap.h>
37 #include <sys/debug.h>
38 #include <sys/kmem.h>
39 #include <sys/errno.h>
40 #include <sys/sysmacros.h>
41 #include <sys/lockstat.h>
42 #include <sys/atomic.h>
43 #include <sys/dtrace.h>
44
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47
48 typedef struct lockstat_probe {
49         const char      *lsp_func;
50         const char      *lsp_name;
51         int             lsp_probe;
52         dtrace_id_t     lsp_id;
53 } lockstat_probe_t;
54
55 lockstat_probe_t lockstat_probes[] =
56 {
57         { LS_MUTEX_ENTER,       LSA_ACQUIRE,    LS_MUTEX_ENTER_ACQUIRE },
58         { LS_MUTEX_ENTER,       LSA_BLOCK,      LS_MUTEX_ENTER_BLOCK },
59         { LS_MUTEX_ENTER,       LSA_SPIN,       LS_MUTEX_ENTER_SPIN },
60         { LS_MUTEX_EXIT,        LSA_RELEASE,    LS_MUTEX_EXIT_RELEASE },
61         { LS_MUTEX_DESTROY,     LSA_RELEASE,    LS_MUTEX_DESTROY_RELEASE },
62         { LS_MUTEX_TRYENTER,    LSA_ACQUIRE,    LS_MUTEX_TRYENTER_ACQUIRE },
63         { LS_LOCK_SET,          LSS_ACQUIRE,    LS_LOCK_SET_ACQUIRE },
64         { LS_LOCK_SET,          LSS_SPIN,       LS_LOCK_SET_SPIN },
65         { LS_LOCK_SET_SPL,      LSS_ACQUIRE,    LS_LOCK_SET_SPL_ACQUIRE },
66         { LS_LOCK_SET_SPL,      LSS_SPIN,       LS_LOCK_SET_SPL_SPIN },
67         { LS_LOCK_TRY,          LSS_ACQUIRE,    LS_LOCK_TRY_ACQUIRE },
68         { LS_LOCK_CLEAR,        LSS_RELEASE,    LS_LOCK_CLEAR_RELEASE },
69         { LS_LOCK_CLEAR_SPLX,   LSS_RELEASE,    LS_LOCK_CLEAR_SPLX_RELEASE },
70         { LS_CLOCK_UNLOCK,      LSS_RELEASE,    LS_CLOCK_UNLOCK_RELEASE },
71         { LS_RW_ENTER,          LSR_ACQUIRE,    LS_RW_ENTER_ACQUIRE },
72         { LS_RW_ENTER,          LSR_BLOCK,      LS_RW_ENTER_BLOCK },
73         { LS_RW_EXIT,           LSR_RELEASE,    LS_RW_EXIT_RELEASE },
74         { LS_RW_TRYENTER,       LSR_ACQUIRE,    LS_RW_TRYENTER_ACQUIRE },
75         { LS_RW_TRYUPGRADE,     LSR_UPGRADE,    LS_RW_TRYUPGRADE_UPGRADE },
76         { LS_RW_DOWNGRADE,      LSR_DOWNGRADE,  LS_RW_DOWNGRADE_DOWNGRADE },
77         { LS_THREAD_LOCK,       LST_SPIN,       LS_THREAD_LOCK_SPIN },
78         { LS_THREAD_LOCK_HIGH,  LST_SPIN,       LS_THREAD_LOCK_HIGH_SPIN },
79         { NULL }
80 };
81
82 static dev_info_t       *lockstat_devi; /* saved in xxattach() for xxinfo() */
83 static kmutex_t         lockstat_test;  /* for testing purposes only */
84 static dtrace_provider_id_t lockstat_id;
85
86 /*ARGSUSED*/
87 static void
88 lockstat_enable(void *arg, dtrace_id_t id, void *parg)
89 {
90         lockstat_probe_t *probe = parg;
91
92         ASSERT(!lockstat_probemap[probe->lsp_probe]);
93
94         lockstat_probemap[probe->lsp_probe] = id;
95         membar_producer();
96
97         lockstat_hot_patch();
98         membar_producer();
99
100         /*
101          * Immediately generate a record for the lockstat_test mutex
102          * to verify that the mutex hot-patch code worked as expected.
103          */
104         mutex_enter(&lockstat_test);
105         mutex_exit(&lockstat_test);
106 }
107
108 /*ARGSUSED*/
109 static void
110 lockstat_disable(void *arg, dtrace_id_t id, void *parg)
111 {
112         lockstat_probe_t *probe = parg;
113         int i;
114
115         ASSERT(lockstat_probemap[probe->lsp_probe]);
116
117         lockstat_probemap[probe->lsp_probe] = 0;
118         lockstat_hot_patch();
119         membar_producer();
120
121         /*
122          * See if we have any probes left enabled.
123          */
124         for (i = 0; i < LS_NPROBES; i++) {
125                 if (lockstat_probemap[i]) {
126                         /*
127                          * This probe is still enabled.  We don't need to deal
128                          * with waiting for all threads to be out of the
129                          * lockstat critical sections; just return.
130                          */
131                         return;
132                 }
133         }
134
135         /*
136          * The delay() here isn't as cheesy as you might think.  We don't
137          * want to busy-loop in the kernel, so we have to give up the
138          * CPU between calls to lockstat_active_threads(); that much is
139          * obvious.  But the reason it's a do..while loop rather than a
140          * while loop is subtle.  The memory barrier above guarantees that
141          * no threads will enter the lockstat code from this point forward.
142          * However, another thread could already be executing lockstat code
143          * without our knowledge if the update to its t_lockstat field hasn't
144          * cleared its CPU's store buffer.  Delaying for one clock tick
145          * guarantees that either (1) the thread will have *ample* time to
146          * complete its work, or (2) the thread will be preempted, in which
147          * case it will have to grab and release a dispatcher lock, which
148          * will flush that CPU's store buffer.  Either way we're covered.
149          */
150         do {
151                 delay(1);
152         } while (lockstat_active_threads());
153 }
154
155 /*ARGSUSED*/
156 static int
157 lockstat_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
158 {
159         return (0);
160 }
161
162 /* ARGSUSED */
163 static int
164 lockstat_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
165 {
166         int error;
167
168         switch (infocmd) {
169         case DDI_INFO_DEVT2DEVINFO:
170                 *result = (void *) lockstat_devi;
171                 error = DDI_SUCCESS;
172                 break;
173         case DDI_INFO_DEVT2INSTANCE:
174                 *result = (void *)0;
175                 error = DDI_SUCCESS;
176                 break;
177         default:
178                 error = DDI_FAILURE;
179         }
180         return (error);
181 }
182
183 /*ARGSUSED*/
184 static void
185 lockstat_provide(void *arg, const dtrace_probedesc_t *desc)
186 {
187         int i = 0;
188
189         for (i = 0; lockstat_probes[i].lsp_func != NULL; i++) {
190                 lockstat_probe_t *probe = &lockstat_probes[i];
191
192                 if (dtrace_probe_lookup(lockstat_id, "genunix",
193                     probe->lsp_func, probe->lsp_name) != 0)
194                         continue;
195
196                 ASSERT(!probe->lsp_id);
197                 probe->lsp_id = dtrace_probe_create(lockstat_id,
198                     "genunix", probe->lsp_func, probe->lsp_name,
199                     1, probe);
200         }
201 }
202
203 /*ARGSUSED*/
204 static void
205 lockstat_destroy(void *arg, dtrace_id_t id, void *parg)
206 {
207         lockstat_probe_t *probe = parg;
208
209         ASSERT(!lockstat_probemap[probe->lsp_probe]);
210         probe->lsp_id = 0;
211 }
212
213 static dtrace_pattr_t lockstat_attr = {
214 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
215 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
216 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
217 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
218 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
219 };
220
221 static dtrace_pops_t lockstat_pops = {
222         lockstat_provide,
223         NULL,
224         lockstat_enable,
225         lockstat_disable,
226         NULL,
227         NULL,
228         NULL,
229         NULL,
230         NULL,
231         lockstat_destroy
232 };
233
234 static int
235 lockstat_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
236 {
237         switch (cmd) {
238         case DDI_ATTACH:
239                 break;
240         case DDI_RESUME:
241                 return (DDI_SUCCESS);
242         default:
243                 return (DDI_FAILURE);
244         }
245
246         if (ddi_create_minor_node(devi, "lockstat", S_IFCHR, 0,
247             DDI_PSEUDO, 0) == DDI_FAILURE ||
248             dtrace_register("lockstat", &lockstat_attr, DTRACE_PRIV_KERNEL,
249             NULL, &lockstat_pops, NULL, &lockstat_id) != 0) {
250                 ddi_remove_minor_node(devi, NULL);
251                 return (DDI_FAILURE);
252         }
253
254         lockstat_probe = dtrace_probe;
255         membar_producer();
256
257         ddi_report_dev(devi);
258         lockstat_devi = devi;
259         return (DDI_SUCCESS);
260 }
261
262 static int
263 lockstat_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
264 {
265         switch (cmd) {
266         case DDI_DETACH:
267                 break;
268         case DDI_SUSPEND:
269                 return (DDI_SUCCESS);
270         default:
271                 return (DDI_FAILURE);
272         }
273
274         if (dtrace_unregister(lockstat_id) != 0)
275                 return (DDI_FAILURE);
276
277         ddi_remove_minor_node(devi, NULL);
278         return (DDI_SUCCESS);
279 }
280
281 /*
282  * Configuration data structures
283  */
284 static struct cb_ops lockstat_cb_ops = {
285         lockstat_open,          /* open */
286         nodev,                  /* close */
287         nulldev,                /* strategy */
288         nulldev,                /* print */
289         nodev,                  /* dump */
290         nodev,                  /* read */
291         nodev,                  /* write */
292         nodev,                  /* ioctl */
293         nodev,                  /* devmap */
294         nodev,                  /* mmap */
295         nodev,                  /* segmap */
296         nochpoll,               /* poll */
297         ddi_prop_op,            /* cb_prop_op */
298         0,                      /* streamtab */
299         D_MP | D_NEW            /* Driver compatibility flag */
300 };
301
302 static struct dev_ops lockstat_ops = {
303         DEVO_REV,               /* devo_rev, */
304         0,                      /* refcnt */
305         lockstat_info,          /* getinfo */
306         nulldev,                /* identify */
307         nulldev,                /* probe */
308         lockstat_attach,        /* attach */
309         lockstat_detach,        /* detach */
310         nulldev,                /* reset */
311         &lockstat_cb_ops,       /* cb_ops */
312         NULL,                   /* bus_ops */
313 };
314
315 static struct modldrv modldrv = {
316         &mod_driverops,         /* Type of module.  This one is a driver */
317         "Lock Statistics %I%",  /* name of module */
318         &lockstat_ops,          /* driver ops */
319 };
320
321 static struct modlinkage modlinkage = {
322         MODREV_1, (void *)&modldrv, NULL
323 };
324
325 int
326 _init(void)
327 {
328         return (mod_install(&modlinkage));
329 }
330
331 int
332 _fini(void)
333 {
334         return (mod_remove(&modlinkage));
335 }
336
337 int
338 _info(struct modinfo *modinfop)
339 {
340         return (mod_info(&modlinkage, modinfop));
341 }