2 * Copyright (c) 2009 Robert N. M. Watson
5 * This software was developed at the University of Cambridge Computer
6 * Laboratory with support from a grant from Google, Inc.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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 the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
33 #include <sys/param.h>
34 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/module.h>
40 #include <sys/dtrace.h>
41 #include <sys/dtrace_bsd.h>
43 #include <fs/nfs/nfsproto.h>
45 #include <fs/nfsclient/nfs_kdtrace.h>
48 * dtnfscl is a DTrace provider that tracks the intent to perform RPCs
49 * in the NFS client, as well as acess to and maintenance of the access and
50 * attribute caches. This is not quite the same as RPCs, because NFS may
51 * issue multiple RPC transactions in the event that authentication fails,
52 * there's a jukebox error, or none at all if the access or attribute cache
53 * hits. However, it cleanly represents the logical layer between RPC
54 * transmission and vnode/vfs operations, providing access to state linking
58 static int dtnfsclient_unload(void);
59 static void dtnfsclient_getargdesc(void *, dtrace_id_t, void *,
61 static void dtnfsclient_provide(void *, dtrace_probedesc_t *);
62 static void dtnfsclient_destroy(void *, dtrace_id_t, void *);
63 static void dtnfsclient_enable(void *, dtrace_id_t, void *);
64 static void dtnfsclient_disable(void *, dtrace_id_t, void *);
65 static void dtnfsclient_load(void *);
67 static dtrace_pattr_t dtnfsclient_attr = {
68 { DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
69 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
70 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
71 { DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
72 { DTRACE_STABILITY_STABLE, DTRACE_STABILITY_STABLE, DTRACE_CLASS_COMMON },
76 * Description of NFSv4, NFSv3 and (optional) NFSv2 probes for a procedure.
78 struct dtnfsclient_rpc {
80 char *nr_v3_name; /* Or NULL if none. */
81 char *nr_v2_name; /* Or NULL if none. */
84 * IDs for the start and done cases, for NFSv2, NFSv3 and NFSv4.
86 uint32_t nr_v2_id_start, nr_v2_id_done;
87 uint32_t nr_v3_id_start, nr_v3_id_done;
88 uint32_t nr_v4_id_start, nr_v4_id_done;
92 * This table is indexed by NFSv3 procedure number, but also used for NFSv2
93 * procedure names and NFSv4 operations.
95 static struct dtnfsclient_rpc dtnfsclient_rpcs[NFSV41_NPROCS + 1] = {
96 { "null", "null", "null" },
97 { "getattr", "getattr", "getattr" },
98 { "setattr", "setattr", "setattr" },
99 { "lookup", "lookup", "lookup" },
100 { "access", "access", "noop" },
101 { "readlink", "readlink", "readlink" },
102 { "read", "read", "read" },
103 { "write", "write", "write" },
104 { "create", "create", "create" },
105 { "mkdir", "mkdir", "mkdir" },
106 { "symlink", "symlink", "symlink" },
107 { "mknod", "mknod" },
108 { "remove", "remove", "remove" },
109 { "rmdir", "rmdir", "rmdir" },
110 { "rename", "rename", "rename" },
111 { "link", "link", "link" },
112 { "readdir", "readdir", "readdir" },
113 { "readdirplus", "readdirplus" },
114 { "fsstat", "fsstat", "statfs" },
115 { "fsinfo", "fsinfo" },
116 { "pathconf", "pathconf" },
117 { "commit", "commit" },
120 { "setclientidcfrm" },
132 { "retdelegremove" },
133 { "retdelegrename1" },
134 { "retdelegrename2" },
137 { "noop", "noop", "noop" }
141 * Module name strings.
143 static char *dtnfsclient_accesscache_str = "accesscache";
144 static char *dtnfsclient_attrcache_str = "attrcache";
145 static char *dtnfsclient_nfs2_str = "nfs2";
146 static char *dtnfsclient_nfs3_str = "nfs3";
147 static char *dtnfsclient_nfs4_str = "nfs4";
150 * Function name strings.
152 static char *dtnfsclient_flush_str = "flush";
153 static char *dtnfsclient_load_str = "load";
154 static char *dtnfsclient_get_str = "get";
159 static char *dtnfsclient_done_str = "done";
160 static char *dtnfsclient_hit_str = "hit";
161 static char *dtnfsclient_miss_str = "miss";
162 static char *dtnfsclient_start_str = "start";
164 static dtrace_pops_t dtnfsclient_pops = {
171 dtnfsclient_getargdesc,
177 static dtrace_provider_id_t dtnfsclient_id;
180 * Most probes are generated from the above RPC table, but for access and
181 * attribute caches, we have specific IDs we recognize and handle specially
184 extern uint32_t nfscl_accesscache_flush_done_id;
185 extern uint32_t nfscl_accesscache_get_hit_id;
186 extern uint32_t nfscl_accesscache_get_miss_id;
187 extern uint32_t nfscl_accesscache_load_done_id;
189 extern uint32_t nfscl_attrcache_flush_done_id;
190 extern uint32_t nfscl_attrcache_get_hit_id;
191 extern uint32_t nfscl_attrcache_get_miss_id;
192 extern uint32_t nfscl_attrcache_load_done_id;
195 * When tracing on a procedure is enabled, the DTrace ID for an RPC event is
196 * stored in one of these two NFS client-allocated arrays; 0 indicates that
197 * the event is not being traced so probes should not be called.
199 * For simplicity, we allocate both v2, v3 and v4 arrays as NFSV41_NPROCS + 1,
200 * and the v2, v3 arrays are simply sparse.
202 extern uint32_t nfscl_nfs2_start_probes[NFSV41_NPROCS + 1];
203 extern uint32_t nfscl_nfs2_done_probes[NFSV41_NPROCS + 1];
205 extern uint32_t nfscl_nfs3_start_probes[NFSV41_NPROCS + 1];
206 extern uint32_t nfscl_nfs3_done_probes[NFSV41_NPROCS + 1];
208 extern uint32_t nfscl_nfs4_start_probes[NFSV41_NPROCS + 1];
209 extern uint32_t nfscl_nfs4_done_probes[NFSV41_NPROCS + 1];
212 * Look up a DTrace probe ID to see if it's associated with a "done" event --
213 * if so, we will return a fourth argument type of "int".
216 dtnfs234_isdoneprobe(dtrace_id_t id)
220 for (i = 0; i < NFSV41_NPROCS + 1; i++) {
221 if (dtnfsclient_rpcs[i].nr_v4_id_done == id ||
222 dtnfsclient_rpcs[i].nr_v3_id_done == id ||
223 dtnfsclient_rpcs[i].nr_v2_id_done == id)
230 dtnfsclient_getargdesc(void *arg, dtrace_id_t id, void *parg,
231 dtrace_argdesc_t *desc)
233 const char *p = NULL;
235 if (id == nfscl_accesscache_flush_done_id ||
236 id == nfscl_attrcache_flush_done_id ||
237 id == nfscl_attrcache_get_miss_id) {
238 switch (desc->dtargd_ndx) {
240 p = "struct vnode *";
243 desc->dtargd_ndx = DTRACE_ARGNONE;
246 } else if (id == nfscl_accesscache_get_hit_id ||
247 id == nfscl_accesscache_get_miss_id) {
248 switch (desc->dtargd_ndx) {
250 p = "struct vnode *";
259 desc->dtargd_ndx = DTRACE_ARGNONE;
262 } else if (id == nfscl_accesscache_load_done_id) {
263 switch (desc->dtargd_ndx) {
265 p = "struct vnode *";
277 desc->dtargd_ndx = DTRACE_ARGNONE;
280 } else if (id == nfscl_attrcache_get_hit_id) {
281 switch (desc->dtargd_ndx) {
283 p = "struct vnode *";
286 p = "struct vattr *";
289 desc->dtargd_ndx = DTRACE_ARGNONE;
292 } else if (id == nfscl_attrcache_load_done_id) {
293 switch (desc->dtargd_ndx) {
295 p = "struct vnode *";
298 p = "struct vattr *";
304 desc->dtargd_ndx = DTRACE_ARGNONE;
308 switch (desc->dtargd_ndx) {
310 p = "struct vnode *";
316 p = "struct ucred *";
322 if (dtnfs234_isdoneprobe(id)) {
328 desc->dtargd_ndx = DTRACE_ARGNONE;
333 strlcpy(desc->dtargd_native, p, sizeof(desc->dtargd_native));
337 dtnfsclient_provide(void *arg, dtrace_probedesc_t *desc)
345 * Register access cache probes.
347 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
348 dtnfsclient_flush_str, dtnfsclient_done_str) == 0) {
349 nfscl_accesscache_flush_done_id = dtrace_probe_create(
350 dtnfsclient_id, dtnfsclient_accesscache_str,
351 dtnfsclient_flush_str, dtnfsclient_done_str, 0, NULL);
353 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
354 dtnfsclient_get_str, dtnfsclient_hit_str) == 0) {
355 nfscl_accesscache_get_hit_id = dtrace_probe_create(
356 dtnfsclient_id, dtnfsclient_accesscache_str,
357 dtnfsclient_get_str, dtnfsclient_hit_str, 0, NULL);
359 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
360 dtnfsclient_get_str, dtnfsclient_miss_str) == 0) {
361 nfscl_accesscache_get_miss_id = dtrace_probe_create(
362 dtnfsclient_id, dtnfsclient_accesscache_str,
363 dtnfsclient_get_str, dtnfsclient_miss_str, 0, NULL);
365 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_accesscache_str,
366 dtnfsclient_load_str, dtnfsclient_done_str) == 0) {
367 nfscl_accesscache_load_done_id = dtrace_probe_create(
368 dtnfsclient_id, dtnfsclient_accesscache_str,
369 dtnfsclient_load_str, dtnfsclient_done_str, 0, NULL);
373 * Register attribute cache probes.
375 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
376 dtnfsclient_flush_str, dtnfsclient_done_str) == 0) {
377 nfscl_attrcache_flush_done_id = dtrace_probe_create(
378 dtnfsclient_id, dtnfsclient_attrcache_str,
379 dtnfsclient_flush_str, dtnfsclient_done_str, 0, NULL);
381 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
382 dtnfsclient_get_str, dtnfsclient_hit_str) == 0) {
383 nfscl_attrcache_get_hit_id = dtrace_probe_create(
384 dtnfsclient_id, dtnfsclient_attrcache_str,
385 dtnfsclient_get_str, dtnfsclient_hit_str, 0, NULL);
387 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
388 dtnfsclient_get_str, dtnfsclient_miss_str) == 0) {
389 nfscl_attrcache_get_miss_id = dtrace_probe_create(
390 dtnfsclient_id, dtnfsclient_attrcache_str,
391 dtnfsclient_get_str, dtnfsclient_miss_str, 0, NULL);
393 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_attrcache_str,
394 dtnfsclient_load_str, dtnfsclient_done_str) == 0) {
395 nfscl_attrcache_load_done_id = dtrace_probe_create(
396 dtnfsclient_id, dtnfsclient_attrcache_str,
397 dtnfsclient_load_str, dtnfsclient_done_str, 0, NULL);
401 * Register NFSv2 RPC procedures; note sparseness check for each slot
402 * in the NFSv3, NFSv4 procnum-indexed array.
404 for (i = 0; i < NFSV41_NPROCS + 1; i++) {
405 if (dtnfsclient_rpcs[i].nr_v2_name != NULL &&
406 dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs2_str,
407 dtnfsclient_rpcs[i].nr_v2_name, dtnfsclient_start_str) ==
409 dtnfsclient_rpcs[i].nr_v2_id_start =
410 dtrace_probe_create(dtnfsclient_id,
411 dtnfsclient_nfs2_str,
412 dtnfsclient_rpcs[i].nr_v2_name,
413 dtnfsclient_start_str, 0,
414 &nfscl_nfs2_start_probes[i]);
416 if (dtnfsclient_rpcs[i].nr_v2_name != NULL &&
417 dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs2_str,
418 dtnfsclient_rpcs[i].nr_v2_name, dtnfsclient_done_str) ==
420 dtnfsclient_rpcs[i].nr_v2_id_done =
421 dtrace_probe_create(dtnfsclient_id,
422 dtnfsclient_nfs2_str,
423 dtnfsclient_rpcs[i].nr_v2_name,
424 dtnfsclient_done_str, 0,
425 &nfscl_nfs2_done_probes[i]);
430 * Register NFSv3 RPC procedures; note sparseness check for each slot
431 * in the NFSv4 procnum-indexed array.
433 for (i = 0; i < NFSV41_NPROCS + 1; i++) {
434 if (dtnfsclient_rpcs[i].nr_v3_name != NULL &&
435 dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs3_str,
436 dtnfsclient_rpcs[i].nr_v3_name, dtnfsclient_start_str) ==
438 dtnfsclient_rpcs[i].nr_v3_id_start =
439 dtrace_probe_create(dtnfsclient_id,
440 dtnfsclient_nfs3_str,
441 dtnfsclient_rpcs[i].nr_v3_name,
442 dtnfsclient_start_str, 0,
443 &nfscl_nfs3_start_probes[i]);
445 if (dtnfsclient_rpcs[i].nr_v3_name != NULL &&
446 dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs3_str,
447 dtnfsclient_rpcs[i].nr_v3_name, dtnfsclient_done_str) ==
449 dtnfsclient_rpcs[i].nr_v3_id_done =
450 dtrace_probe_create(dtnfsclient_id,
451 dtnfsclient_nfs3_str,
452 dtnfsclient_rpcs[i].nr_v3_name,
453 dtnfsclient_done_str, 0,
454 &nfscl_nfs3_done_probes[i]);
459 * Register NFSv4 RPC procedures.
461 for (i = 0; i < NFSV41_NPROCS + 1; i++) {
462 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs4_str,
463 dtnfsclient_rpcs[i].nr_v4_name, dtnfsclient_start_str) ==
465 dtnfsclient_rpcs[i].nr_v4_id_start =
466 dtrace_probe_create(dtnfsclient_id,
467 dtnfsclient_nfs4_str,
468 dtnfsclient_rpcs[i].nr_v4_name,
469 dtnfsclient_start_str, 0,
470 &nfscl_nfs4_start_probes[i]);
472 if (dtrace_probe_lookup(dtnfsclient_id, dtnfsclient_nfs4_str,
473 dtnfsclient_rpcs[i].nr_v4_name, dtnfsclient_done_str) ==
475 dtnfsclient_rpcs[i].nr_v4_id_done =
476 dtrace_probe_create(dtnfsclient_id,
477 dtnfsclient_nfs4_str,
478 dtnfsclient_rpcs[i].nr_v4_name,
479 dtnfsclient_done_str, 0,
480 &nfscl_nfs4_done_probes[i]);
486 dtnfsclient_destroy(void *arg, dtrace_id_t id, void *parg)
491 dtnfsclient_enable(void *arg, dtrace_id_t id, void *parg)
494 void *f = dtrace_probe;
496 if (id == nfscl_accesscache_flush_done_id)
497 dtrace_nfscl_accesscache_flush_done_probe = f;
498 else if (id == nfscl_accesscache_get_hit_id)
499 dtrace_nfscl_accesscache_get_hit_probe = f;
500 else if (id == nfscl_accesscache_get_miss_id)
501 dtrace_nfscl_accesscache_get_miss_probe = f;
502 else if (id == nfscl_accesscache_load_done_id)
503 dtrace_nfscl_accesscache_load_done_probe = f;
504 else if (id == nfscl_attrcache_flush_done_id)
505 dtrace_nfscl_attrcache_flush_done_probe = f;
506 else if (id == nfscl_attrcache_get_hit_id)
507 dtrace_nfscl_attrcache_get_hit_probe = f;
508 else if (id == nfscl_attrcache_get_miss_id)
509 dtrace_nfscl_attrcache_get_miss_probe = f;
510 else if (id == nfscl_attrcache_load_done_id)
511 dtrace_nfscl_attrcache_load_done_probe = f;
517 dtnfsclient_disable(void *arg, dtrace_id_t id, void *parg)
521 if (id == nfscl_accesscache_flush_done_id)
522 dtrace_nfscl_accesscache_flush_done_probe = NULL;
523 else if (id == nfscl_accesscache_get_hit_id)
524 dtrace_nfscl_accesscache_get_hit_probe = NULL;
525 else if (id == nfscl_accesscache_get_miss_id)
526 dtrace_nfscl_accesscache_get_miss_probe = NULL;
527 else if (id == nfscl_accesscache_load_done_id)
528 dtrace_nfscl_accesscache_load_done_probe = NULL;
529 else if (id == nfscl_attrcache_flush_done_id)
530 dtrace_nfscl_attrcache_flush_done_probe = NULL;
531 else if (id == nfscl_attrcache_get_hit_id)
532 dtrace_nfscl_attrcache_get_hit_probe = NULL;
533 else if (id == nfscl_attrcache_get_miss_id)
534 dtrace_nfscl_attrcache_get_miss_probe = NULL;
535 else if (id == nfscl_attrcache_load_done_id)
536 dtrace_nfscl_attrcache_load_done_probe = NULL;
542 dtnfsclient_load(void *dummy)
545 if (dtrace_register("nfscl", &dtnfsclient_attr,
546 DTRACE_PRIV_USER, NULL, &dtnfsclient_pops, NULL,
547 &dtnfsclient_id) != 0)
550 dtrace_nfscl_nfs234_start_probe =
551 (dtrace_nfsclient_nfs23_start_probe_func_t)dtrace_probe;
552 dtrace_nfscl_nfs234_done_probe =
553 (dtrace_nfsclient_nfs23_done_probe_func_t)dtrace_probe;
561 dtrace_nfscl_nfs234_start_probe = NULL;
562 dtrace_nfscl_nfs234_done_probe = NULL;
564 return (dtrace_unregister(dtnfsclient_id));
568 dtnfsclient_modevent(module_t mod __unused, int type, void *data __unused)
590 SYSINIT(dtnfsclient_load, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY,
591 dtnfsclient_load, NULL);
592 SYSUNINIT(dtnfsclient_unload, SI_SUB_DTRACE_PROVIDER, SI_ORDER_ANY,
593 dtnfsclient_unload, NULL);
595 DEV_MODULE(dtnfscl, dtnfsclient_modevent, NULL);
596 MODULE_VERSION(dtnfscl, 1);
597 MODULE_DEPEND(dtnfscl, dtrace, 1, 1, 1);
598 MODULE_DEPEND(dtnfscl, opensolaris, 1, 1, 1);
599 MODULE_DEPEND(dtnfscl, nfscl, 1, 1, 1);
600 MODULE_DEPEND(dtnfscl, nfscommon, 1, 1, 1);