Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Copyright (c) 2014 Christoph Hellwig.
4 */
5#undef TRACE_SYSTEM
6#define TRACE_SYSTEM nfsd
7
8#if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
9#define _NFSD_TRACE_H
10
11#include <linux/tracepoint.h>
12#include <linux/sunrpc/xprt.h>
13#include <trace/misc/nfs.h>
14
15#include "export.h"
16#include "nfsfh.h"
17#include "xdr4.h"
18
19#define NFSD_TRACE_PROC_RES_FIELDS \
20 __field(unsigned int, netns_ino) \
21 __field(u32, xid) \
22 __field(unsigned long, status) \
23 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \
24 __array(unsigned char, client, sizeof(struct sockaddr_in6))
25
26#define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \
27 do { \
28 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \
29 __entry->xid = be32_to_cpu(rqstp->rq_xid); \
30 __entry->status = be32_to_cpu(error); \
31 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \
32 rqstp->rq_xprt->xpt_locallen); \
33 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \
34 rqstp->rq_xprt->xpt_remotelen); \
35 } while (0);
36
37DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
38 TP_PROTO(
39 const struct svc_rqst *rqstp
40 ),
41 TP_ARGS(rqstp),
42 TP_STRUCT__entry(
43 __field(unsigned int, netns_ino)
44 __field(u32, xid)
45 __field(u32, vers)
46 __field(u32, proc)
47 __sockaddr(server, rqstp->rq_xprt->xpt_locallen)
48 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
49 ),
50 TP_fast_assign(
51 const struct svc_xprt *xprt = rqstp->rq_xprt;
52
53 __entry->netns_ino = xprt->xpt_net->ns.inum;
54 __entry->xid = be32_to_cpu(rqstp->rq_xid);
55 __entry->vers = rqstp->rq_vers;
56 __entry->proc = rqstp->rq_proc;
57 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);
58 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen);
59 ),
60 TP_printk("xid=0x%08x vers=%u proc=%u",
61 __entry->xid, __entry->vers, __entry->proc
62 )
63);
64
65#define DEFINE_NFSD_XDR_ERR_EVENT(name) \
66DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
67 TP_PROTO(const struct svc_rqst *rqstp), \
68 TP_ARGS(rqstp))
69
70DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
71DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
72
73#define show_nfsd_may_flags(x) \
74 __print_flags(x, "|", \
75 { NFSD_MAY_EXEC, "EXEC" }, \
76 { NFSD_MAY_WRITE, "WRITE" }, \
77 { NFSD_MAY_READ, "READ" }, \
78 { NFSD_MAY_SATTR, "SATTR" }, \
79 { NFSD_MAY_TRUNC, "TRUNC" }, \
80 { NFSD_MAY_LOCK, "LOCK" }, \
81 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \
82 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \
83 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \
84 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \
85 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \
86 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \
87 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" })
88
89TRACE_EVENT(nfsd_compound,
90 TP_PROTO(
91 const struct svc_rqst *rqst,
92 const char *tag,
93 u32 taglen,
94 u32 opcnt
95 ),
96 TP_ARGS(rqst, tag, taglen, opcnt),
97 TP_STRUCT__entry(
98 __field(u32, xid)
99 __field(u32, opcnt)
100 __string_len(tag, tag, taglen)
101 ),
102 TP_fast_assign(
103 __entry->xid = be32_to_cpu(rqst->rq_xid);
104 __entry->opcnt = opcnt;
105 __assign_str_len(tag, tag, taglen);
106 ),
107 TP_printk("xid=0x%08x opcnt=%u tag=%s",
108 __entry->xid, __entry->opcnt, __get_str(tag)
109 )
110)
111
112TRACE_EVENT(nfsd_compound_status,
113 TP_PROTO(u32 args_opcnt,
114 u32 resp_opcnt,
115 __be32 status,
116 const char *name),
117 TP_ARGS(args_opcnt, resp_opcnt, status, name),
118 TP_STRUCT__entry(
119 __field(u32, args_opcnt)
120 __field(u32, resp_opcnt)
121 __field(int, status)
122 __string(name, name)
123 ),
124 TP_fast_assign(
125 __entry->args_opcnt = args_opcnt;
126 __entry->resp_opcnt = resp_opcnt;
127 __entry->status = be32_to_cpu(status);
128 __assign_str(name, name);
129 ),
130 TP_printk("op=%u/%u %s status=%d",
131 __entry->resp_opcnt, __entry->args_opcnt,
132 __get_str(name), __entry->status)
133)
134
135TRACE_EVENT(nfsd_compound_decode_err,
136 TP_PROTO(
137 const struct svc_rqst *rqstp,
138 u32 args_opcnt,
139 u32 resp_opcnt,
140 u32 opnum,
141 __be32 status
142 ),
143 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status),
144 TP_STRUCT__entry(
145 NFSD_TRACE_PROC_RES_FIELDS
146
147 __field(u32, args_opcnt)
148 __field(u32, resp_opcnt)
149 __field(u32, opnum)
150 ),
151 TP_fast_assign(
152 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
153
154 __entry->args_opcnt = args_opcnt;
155 __entry->resp_opcnt = resp_opcnt;
156 __entry->opnum = opnum;
157 ),
158 TP_printk("op=%u/%u opnum=%u status=%lu",
159 __entry->resp_opcnt, __entry->args_opcnt,
160 __entry->opnum, __entry->status)
161);
162
163TRACE_EVENT(nfsd_compound_encode_err,
164 TP_PROTO(
165 const struct svc_rqst *rqstp,
166 u32 opnum,
167 __be32 status
168 ),
169 TP_ARGS(rqstp, opnum, status),
170 TP_STRUCT__entry(
171 NFSD_TRACE_PROC_RES_FIELDS
172
173 __field(u32, opnum)
174 ),
175 TP_fast_assign(
176 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
177
178 __entry->opnum = opnum;
179 ),
180 TP_printk("opnum=%u status=%lu",
181 __entry->opnum, __entry->status)
182);
183
184#define show_fs_file_type(x) \
185 __print_symbolic(x, \
186 { S_IFLNK, "LNK" }, \
187 { S_IFREG, "REG" }, \
188 { S_IFDIR, "DIR" }, \
189 { S_IFCHR, "CHR" }, \
190 { S_IFBLK, "BLK" }, \
191 { S_IFIFO, "FIFO" }, \
192 { S_IFSOCK, "SOCK" })
193
194TRACE_EVENT(nfsd_fh_verify,
195 TP_PROTO(
196 const struct svc_rqst *rqstp,
197 const struct svc_fh *fhp,
198 umode_t type,
199 int access
200 ),
201 TP_ARGS(rqstp, fhp, type, access),
202 TP_STRUCT__entry(
203 __field(unsigned int, netns_ino)
204 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
205 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
206 __field(u32, xid)
207 __field(u32, fh_hash)
208 __field(const void *, inode)
209 __field(unsigned long, type)
210 __field(unsigned long, access)
211 ),
212 TP_fast_assign(
213 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
214 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
215 rqstp->rq_xprt->xpt_locallen);
216 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
217 rqstp->rq_xprt->xpt_remotelen);
218 __entry->xid = be32_to_cpu(rqstp->rq_xid);
219 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
220 __entry->inode = d_inode(fhp->fh_dentry);
221 __entry->type = type;
222 __entry->access = access;
223 ),
224 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s",
225 __entry->xid, __entry->fh_hash,
226 show_fs_file_type(__entry->type),
227 show_nfsd_may_flags(__entry->access)
228 )
229);
230
231TRACE_EVENT_CONDITION(nfsd_fh_verify_err,
232 TP_PROTO(
233 const struct svc_rqst *rqstp,
234 const struct svc_fh *fhp,
235 umode_t type,
236 int access,
237 __be32 error
238 ),
239 TP_ARGS(rqstp, fhp, type, access, error),
240 TP_CONDITION(error),
241 TP_STRUCT__entry(
242 __field(unsigned int, netns_ino)
243 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
244 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
245 __field(u32, xid)
246 __field(u32, fh_hash)
247 __field(const void *, inode)
248 __field(unsigned long, type)
249 __field(unsigned long, access)
250 __field(int, error)
251 ),
252 TP_fast_assign(
253 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
254 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
255 rqstp->rq_xprt->xpt_locallen);
256 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
257 rqstp->rq_xprt->xpt_remotelen);
258 __entry->xid = be32_to_cpu(rqstp->rq_xid);
259 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
260 if (fhp->fh_dentry)
261 __entry->inode = d_inode(fhp->fh_dentry);
262 else
263 __entry->inode = NULL;
264 __entry->type = type;
265 __entry->access = access;
266 __entry->error = be32_to_cpu(error);
267 ),
268 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d",
269 __entry->xid, __entry->fh_hash,
270 show_fs_file_type(__entry->type),
271 show_nfsd_may_flags(__entry->access),
272 __entry->error
273 )
274);
275
276DECLARE_EVENT_CLASS(nfsd_fh_err_class,
277 TP_PROTO(struct svc_rqst *rqstp,
278 struct svc_fh *fhp,
279 int status),
280 TP_ARGS(rqstp, fhp, status),
281 TP_STRUCT__entry(
282 __field(u32, xid)
283 __field(u32, fh_hash)
284 __field(int, status)
285 ),
286 TP_fast_assign(
287 __entry->xid = be32_to_cpu(rqstp->rq_xid);
288 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
289 __entry->status = status;
290 ),
291 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
292 __entry->xid, __entry->fh_hash,
293 __entry->status)
294)
295
296#define DEFINE_NFSD_FH_ERR_EVENT(name) \
297DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \
298 TP_PROTO(struct svc_rqst *rqstp, \
299 struct svc_fh *fhp, \
300 int status), \
301 TP_ARGS(rqstp, fhp, status))
302
303DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
304DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
305
306TRACE_EVENT(nfsd_exp_find_key,
307 TP_PROTO(const struct svc_expkey *key,
308 int status),
309 TP_ARGS(key, status),
310 TP_STRUCT__entry(
311 __field(int, fsidtype)
312 __array(u32, fsid, 6)
313 __string(auth_domain, key->ek_client->name)
314 __field(int, status)
315 ),
316 TP_fast_assign(
317 __entry->fsidtype = key->ek_fsidtype;
318 memcpy(__entry->fsid, key->ek_fsid, 4*6);
319 __assign_str(auth_domain, key->ek_client->name);
320 __entry->status = status;
321 ),
322 TP_printk("fsid=%x::%s domain=%s status=%d",
323 __entry->fsidtype,
324 __print_array(__entry->fsid, 6, 4),
325 __get_str(auth_domain),
326 __entry->status
327 )
328);
329
330TRACE_EVENT(nfsd_expkey_update,
331 TP_PROTO(const struct svc_expkey *key, const char *exp_path),
332 TP_ARGS(key, exp_path),
333 TP_STRUCT__entry(
334 __field(int, fsidtype)
335 __array(u32, fsid, 6)
336 __string(auth_domain, key->ek_client->name)
337 __string(path, exp_path)
338 __field(bool, cache)
339 ),
340 TP_fast_assign(
341 __entry->fsidtype = key->ek_fsidtype;
342 memcpy(__entry->fsid, key->ek_fsid, 4*6);
343 __assign_str(auth_domain, key->ek_client->name);
344 __assign_str(path, exp_path);
345 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
346 ),
347 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
348 __entry->fsidtype,
349 __print_array(__entry->fsid, 6, 4),
350 __get_str(auth_domain),
351 __get_str(path),
352 __entry->cache ? "pos" : "neg"
353 )
354);
355
356TRACE_EVENT(nfsd_exp_get_by_name,
357 TP_PROTO(const struct svc_export *key,
358 int status),
359 TP_ARGS(key, status),
360 TP_STRUCT__entry(
361 __string(path, key->ex_path.dentry->d_name.name)
362 __string(auth_domain, key->ex_client->name)
363 __field(int, status)
364 ),
365 TP_fast_assign(
366 __assign_str(path, key->ex_path.dentry->d_name.name);
367 __assign_str(auth_domain, key->ex_client->name);
368 __entry->status = status;
369 ),
370 TP_printk("path=%s domain=%s status=%d",
371 __get_str(path),
372 __get_str(auth_domain),
373 __entry->status
374 )
375);
376
377TRACE_EVENT(nfsd_export_update,
378 TP_PROTO(const struct svc_export *key),
379 TP_ARGS(key),
380 TP_STRUCT__entry(
381 __string(path, key->ex_path.dentry->d_name.name)
382 __string(auth_domain, key->ex_client->name)
383 __field(bool, cache)
384 ),
385 TP_fast_assign(
386 __assign_str(path, key->ex_path.dentry->d_name.name);
387 __assign_str(auth_domain, key->ex_client->name);
388 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
389 ),
390 TP_printk("path=%s domain=%s cache=%s",
391 __get_str(path),
392 __get_str(auth_domain),
393 __entry->cache ? "pos" : "neg"
394 )
395);
396
397DECLARE_EVENT_CLASS(nfsd_io_class,
398 TP_PROTO(struct svc_rqst *rqstp,
399 struct svc_fh *fhp,
400 u64 offset,
401 u32 len),
402 TP_ARGS(rqstp, fhp, offset, len),
403 TP_STRUCT__entry(
404 __field(u32, xid)
405 __field(u32, fh_hash)
406 __field(u64, offset)
407 __field(u32, len)
408 ),
409 TP_fast_assign(
410 __entry->xid = be32_to_cpu(rqstp->rq_xid);
411 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
412 __entry->offset = offset;
413 __entry->len = len;
414 ),
415 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
416 __entry->xid, __entry->fh_hash,
417 __entry->offset, __entry->len)
418)
419
420#define DEFINE_NFSD_IO_EVENT(name) \
421DEFINE_EVENT(nfsd_io_class, nfsd_##name, \
422 TP_PROTO(struct svc_rqst *rqstp, \
423 struct svc_fh *fhp, \
424 u64 offset, \
425 u32 len), \
426 TP_ARGS(rqstp, fhp, offset, len))
427
428DEFINE_NFSD_IO_EVENT(read_start);
429DEFINE_NFSD_IO_EVENT(read_splice);
430DEFINE_NFSD_IO_EVENT(read_vector);
431DEFINE_NFSD_IO_EVENT(read_io_done);
432DEFINE_NFSD_IO_EVENT(read_done);
433DEFINE_NFSD_IO_EVENT(write_start);
434DEFINE_NFSD_IO_EVENT(write_opened);
435DEFINE_NFSD_IO_EVENT(write_io_done);
436DEFINE_NFSD_IO_EVENT(write_done);
437
438DECLARE_EVENT_CLASS(nfsd_err_class,
439 TP_PROTO(struct svc_rqst *rqstp,
440 struct svc_fh *fhp,
441 loff_t offset,
442 int status),
443 TP_ARGS(rqstp, fhp, offset, status),
444 TP_STRUCT__entry(
445 __field(u32, xid)
446 __field(u32, fh_hash)
447 __field(loff_t, offset)
448 __field(int, status)
449 ),
450 TP_fast_assign(
451 __entry->xid = be32_to_cpu(rqstp->rq_xid);
452 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
453 __entry->offset = offset;
454 __entry->status = status;
455 ),
456 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
457 __entry->xid, __entry->fh_hash,
458 __entry->offset, __entry->status)
459)
460
461#define DEFINE_NFSD_ERR_EVENT(name) \
462DEFINE_EVENT(nfsd_err_class, nfsd_##name, \
463 TP_PROTO(struct svc_rqst *rqstp, \
464 struct svc_fh *fhp, \
465 loff_t offset, \
466 int len), \
467 TP_ARGS(rqstp, fhp, offset, len))
468
469DEFINE_NFSD_ERR_EVENT(read_err);
470DEFINE_NFSD_ERR_EVENT(write_err);
471
472TRACE_EVENT(nfsd_dirent,
473 TP_PROTO(struct svc_fh *fhp,
474 u64 ino,
475 const char *name,
476 int namlen),
477 TP_ARGS(fhp, ino, name, namlen),
478 TP_STRUCT__entry(
479 __field(u32, fh_hash)
480 __field(u64, ino)
481 __string_len(name, name, namlen)
482 ),
483 TP_fast_assign(
484 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0;
485 __entry->ino = ino;
486 __assign_str_len(name, name, namlen)
487 ),
488 TP_printk("fh_hash=0x%08x ino=%llu name=%s",
489 __entry->fh_hash, __entry->ino, __get_str(name)
490 )
491)
492
493DECLARE_EVENT_CLASS(nfsd_copy_err_class,
494 TP_PROTO(struct svc_rqst *rqstp,
495 struct svc_fh *src_fhp,
496 loff_t src_offset,
497 struct svc_fh *dst_fhp,
498 loff_t dst_offset,
499 u64 count,
500 int status),
501 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
502 TP_STRUCT__entry(
503 __field(u32, xid)
504 __field(u32, src_fh_hash)
505 __field(loff_t, src_offset)
506 __field(u32, dst_fh_hash)
507 __field(loff_t, dst_offset)
508 __field(u64, count)
509 __field(int, status)
510 ),
511 TP_fast_assign(
512 __entry->xid = be32_to_cpu(rqstp->rq_xid);
513 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
514 __entry->src_offset = src_offset;
515 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
516 __entry->dst_offset = dst_offset;
517 __entry->count = count;
518 __entry->status = status;
519 ),
520 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
521 "dst_fh_hash=0x%08x dst_offset=%lld "
522 "count=%llu status=%d",
523 __entry->xid, __entry->src_fh_hash, __entry->src_offset,
524 __entry->dst_fh_hash, __entry->dst_offset,
525 (unsigned long long)__entry->count,
526 __entry->status)
527)
528
529#define DEFINE_NFSD_COPY_ERR_EVENT(name) \
530DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \
531 TP_PROTO(struct svc_rqst *rqstp, \
532 struct svc_fh *src_fhp, \
533 loff_t src_offset, \
534 struct svc_fh *dst_fhp, \
535 loff_t dst_offset, \
536 u64 count, \
537 int status), \
538 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
539 count, status))
540
541DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
542
543#include "state.h"
544#include "filecache.h"
545#include "vfs.h"
546
547TRACE_EVENT(nfsd_delegret_wakeup,
548 TP_PROTO(
549 const struct svc_rqst *rqstp,
550 const struct inode *inode,
551 long timeo
552 ),
553 TP_ARGS(rqstp, inode, timeo),
554 TP_STRUCT__entry(
555 __field(u32, xid)
556 __field(const void *, inode)
557 __field(long, timeo)
558 ),
559 TP_fast_assign(
560 __entry->xid = be32_to_cpu(rqstp->rq_xid);
561 __entry->inode = inode;
562 __entry->timeo = timeo;
563 ),
564 TP_printk("xid=0x%08x inode=%p%s",
565 __entry->xid, __entry->inode,
566 __entry->timeo == 0 ? " (timed out)" : ""
567 )
568);
569
570DECLARE_EVENT_CLASS(nfsd_stateid_class,
571 TP_PROTO(stateid_t *stp),
572 TP_ARGS(stp),
573 TP_STRUCT__entry(
574 __field(u32, cl_boot)
575 __field(u32, cl_id)
576 __field(u32, si_id)
577 __field(u32, si_generation)
578 ),
579 TP_fast_assign(
580 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
581 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
582 __entry->si_id = stp->si_opaque.so_id;
583 __entry->si_generation = stp->si_generation;
584 ),
585 TP_printk("client %08x:%08x stateid %08x:%08x",
586 __entry->cl_boot,
587 __entry->cl_id,
588 __entry->si_id,
589 __entry->si_generation)
590)
591
592#define DEFINE_STATEID_EVENT(name) \
593DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
594 TP_PROTO(stateid_t *stp), \
595 TP_ARGS(stp))
596
597DEFINE_STATEID_EVENT(layoutstate_alloc);
598DEFINE_STATEID_EVENT(layoutstate_unhash);
599DEFINE_STATEID_EVENT(layoutstate_free);
600DEFINE_STATEID_EVENT(layout_get_lookup_fail);
601DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
602DEFINE_STATEID_EVENT(layout_return_lookup_fail);
603DEFINE_STATEID_EVENT(layout_recall);
604DEFINE_STATEID_EVENT(layout_recall_done);
605DEFINE_STATEID_EVENT(layout_recall_fail);
606DEFINE_STATEID_EVENT(layout_recall_release);
607
608DEFINE_STATEID_EVENT(open);
609DEFINE_STATEID_EVENT(deleg_read);
610DEFINE_STATEID_EVENT(deleg_return);
611DEFINE_STATEID_EVENT(deleg_recall);
612
613DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
614 TP_PROTO(u32 seqid, const stateid_t *stp),
615 TP_ARGS(seqid, stp),
616 TP_STRUCT__entry(
617 __field(u32, seqid)
618 __field(u32, cl_boot)
619 __field(u32, cl_id)
620 __field(u32, si_id)
621 __field(u32, si_generation)
622 ),
623 TP_fast_assign(
624 __entry->seqid = seqid;
625 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
626 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
627 __entry->si_id = stp->si_opaque.so_id;
628 __entry->si_generation = stp->si_generation;
629 ),
630 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
631 __entry->seqid, __entry->cl_boot, __entry->cl_id,
632 __entry->si_id, __entry->si_generation)
633)
634
635#define DEFINE_STATESEQID_EVENT(name) \
636DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
637 TP_PROTO(u32 seqid, const stateid_t *stp), \
638 TP_ARGS(seqid, stp))
639
640DEFINE_STATESEQID_EVENT(preprocess);
641DEFINE_STATESEQID_EVENT(open_confirm);
642
643TRACE_DEFINE_ENUM(NFS4_OPEN_STID);
644TRACE_DEFINE_ENUM(NFS4_LOCK_STID);
645TRACE_DEFINE_ENUM(NFS4_DELEG_STID);
646TRACE_DEFINE_ENUM(NFS4_CLOSED_STID);
647TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID);
648TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID);
649TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID);
650
651#define show_stid_type(x) \
652 __print_flags(x, "|", \
653 { NFS4_OPEN_STID, "OPEN" }, \
654 { NFS4_LOCK_STID, "LOCK" }, \
655 { NFS4_DELEG_STID, "DELEG" }, \
656 { NFS4_CLOSED_STID, "CLOSED" }, \
657 { NFS4_REVOKED_DELEG_STID, "REVOKED" }, \
658 { NFS4_CLOSED_DELEG_STID, "CLOSED_DELEG" }, \
659 { NFS4_LAYOUT_STID, "LAYOUT" })
660
661DECLARE_EVENT_CLASS(nfsd_stid_class,
662 TP_PROTO(
663 const struct nfs4_stid *stid
664 ),
665 TP_ARGS(stid),
666 TP_STRUCT__entry(
667 __field(unsigned long, sc_type)
668 __field(int, sc_count)
669 __field(u32, cl_boot)
670 __field(u32, cl_id)
671 __field(u32, si_id)
672 __field(u32, si_generation)
673 ),
674 TP_fast_assign(
675 const stateid_t *stp = &stid->sc_stateid;
676
677 __entry->sc_type = stid->sc_type;
678 __entry->sc_count = refcount_read(&stid->sc_count);
679 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
680 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
681 __entry->si_id = stp->si_opaque.so_id;
682 __entry->si_generation = stp->si_generation;
683 ),
684 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s",
685 __entry->cl_boot, __entry->cl_id,
686 __entry->si_id, __entry->si_generation,
687 __entry->sc_count, show_stid_type(__entry->sc_type)
688 )
689);
690
691#define DEFINE_STID_EVENT(name) \
692DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \
693 TP_PROTO(const struct nfs4_stid *stid), \
694 TP_ARGS(stid))
695
696DEFINE_STID_EVENT(revoke);
697
698DECLARE_EVENT_CLASS(nfsd_clientid_class,
699 TP_PROTO(const clientid_t *clid),
700 TP_ARGS(clid),
701 TP_STRUCT__entry(
702 __field(u32, cl_boot)
703 __field(u32, cl_id)
704 ),
705 TP_fast_assign(
706 __entry->cl_boot = clid->cl_boot;
707 __entry->cl_id = clid->cl_id;
708 ),
709 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
710)
711
712#define DEFINE_CLIENTID_EVENT(name) \
713DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
714 TP_PROTO(const clientid_t *clid), \
715 TP_ARGS(clid))
716
717DEFINE_CLIENTID_EVENT(expire_unconf);
718DEFINE_CLIENTID_EVENT(reclaim_complete);
719DEFINE_CLIENTID_EVENT(confirmed);
720DEFINE_CLIENTID_EVENT(destroyed);
721DEFINE_CLIENTID_EVENT(admin_expired);
722DEFINE_CLIENTID_EVENT(replaced);
723DEFINE_CLIENTID_EVENT(purged);
724DEFINE_CLIENTID_EVENT(renew);
725DEFINE_CLIENTID_EVENT(stale);
726
727DECLARE_EVENT_CLASS(nfsd_net_class,
728 TP_PROTO(const struct nfsd_net *nn),
729 TP_ARGS(nn),
730 TP_STRUCT__entry(
731 __field(unsigned long long, boot_time)
732 ),
733 TP_fast_assign(
734 __entry->boot_time = nn->boot_time;
735 ),
736 TP_printk("boot_time=%16llx", __entry->boot_time)
737)
738
739#define DEFINE_NET_EVENT(name) \
740DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
741 TP_PROTO(const struct nfsd_net *nn), \
742 TP_ARGS(nn))
743
744DEFINE_NET_EVENT(grace_start);
745DEFINE_NET_EVENT(grace_complete);
746
747TRACE_EVENT(nfsd_writeverf_reset,
748 TP_PROTO(
749 const struct nfsd_net *nn,
750 const struct svc_rqst *rqstp,
751 int error
752 ),
753 TP_ARGS(nn, rqstp, error),
754 TP_STRUCT__entry(
755 __field(unsigned long long, boot_time)
756 __field(u32, xid)
757 __field(int, error)
758 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
759 ),
760 TP_fast_assign(
761 __entry->boot_time = nn->boot_time;
762 __entry->xid = be32_to_cpu(rqstp->rq_xid);
763 __entry->error = error;
764
765 /* avoid seqlock inside TP_fast_assign */
766 memcpy(__entry->verifier, nn->writeverf,
767 NFS4_VERIFIER_SIZE);
768 ),
769 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
770 __entry->boot_time, __entry->xid, __entry->error,
771 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
772 )
773);
774
775TRACE_EVENT(nfsd_clid_cred_mismatch,
776 TP_PROTO(
777 const struct nfs4_client *clp,
778 const struct svc_rqst *rqstp
779 ),
780 TP_ARGS(clp, rqstp),
781 TP_STRUCT__entry(
782 __field(u32, cl_boot)
783 __field(u32, cl_id)
784 __field(unsigned long, cl_flavor)
785 __field(unsigned long, new_flavor)
786 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
787 ),
788 TP_fast_assign(
789 __entry->cl_boot = clp->cl_clientid.cl_boot;
790 __entry->cl_id = clp->cl_clientid.cl_id;
791 __entry->cl_flavor = clp->cl_cred.cr_flavor;
792 __entry->new_flavor = rqstp->rq_cred.cr_flavor;
793 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
794 rqstp->rq_xprt->xpt_remotelen);
795 ),
796 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
797 __entry->cl_boot, __entry->cl_id,
798 show_nfsd_authflavor(__entry->cl_flavor),
799 show_nfsd_authflavor(__entry->new_flavor),
800 __get_sockaddr(addr)
801 )
802)
803
804TRACE_EVENT(nfsd_clid_verf_mismatch,
805 TP_PROTO(
806 const struct nfs4_client *clp,
807 const struct svc_rqst *rqstp,
808 const nfs4_verifier *verf
809 ),
810 TP_ARGS(clp, rqstp, verf),
811 TP_STRUCT__entry(
812 __field(u32, cl_boot)
813 __field(u32, cl_id)
814 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
815 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
816 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
817 ),
818 TP_fast_assign(
819 __entry->cl_boot = clp->cl_clientid.cl_boot;
820 __entry->cl_id = clp->cl_clientid.cl_id;
821 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
822 NFS4_VERIFIER_SIZE);
823 memcpy(__entry->new_verifier, (void *)verf,
824 NFS4_VERIFIER_SIZE);
825 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
826 rqstp->rq_xprt->xpt_remotelen);
827 ),
828 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
829 __entry->cl_boot, __entry->cl_id,
830 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
831 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
832 __get_sockaddr(addr)
833 )
834);
835
836DECLARE_EVENT_CLASS(nfsd_clid_class,
837 TP_PROTO(const struct nfs4_client *clp),
838 TP_ARGS(clp),
839 TP_STRUCT__entry(
840 __field(u32, cl_boot)
841 __field(u32, cl_id)
842 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
843 __field(unsigned long, flavor)
844 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
845 __string_len(name, name, clp->cl_name.len)
846 ),
847 TP_fast_assign(
848 __entry->cl_boot = clp->cl_clientid.cl_boot;
849 __entry->cl_id = clp->cl_clientid.cl_id;
850 memcpy(__entry->addr, &clp->cl_addr,
851 sizeof(struct sockaddr_in6));
852 __entry->flavor = clp->cl_cred.cr_flavor;
853 memcpy(__entry->verifier, (void *)&clp->cl_verifier,
854 NFS4_VERIFIER_SIZE);
855 __assign_str_len(name, clp->cl_name.data, clp->cl_name.len);
856 ),
857 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
858 __entry->addr, __get_str(name),
859 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
860 show_nfsd_authflavor(__entry->flavor),
861 __entry->cl_boot, __entry->cl_id)
862);
863
864#define DEFINE_CLID_EVENT(name) \
865DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
866 TP_PROTO(const struct nfs4_client *clp), \
867 TP_ARGS(clp))
868
869DEFINE_CLID_EVENT(fresh);
870DEFINE_CLID_EVENT(confirmed_r);
871
872/*
873 * from fs/nfsd/filecache.h
874 */
875#define show_nf_flags(val) \
876 __print_flags(val, "|", \
877 { 1 << NFSD_FILE_HASHED, "HASHED" }, \
878 { 1 << NFSD_FILE_PENDING, "PENDING" }, \
879 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \
880 { 1 << NFSD_FILE_GC, "GC" })
881
882DECLARE_EVENT_CLASS(nfsd_file_class,
883 TP_PROTO(struct nfsd_file *nf),
884 TP_ARGS(nf),
885 TP_STRUCT__entry(
886 __field(void *, nf_inode)
887 __field(int, nf_ref)
888 __field(unsigned long, nf_flags)
889 __field(unsigned char, nf_may)
890 __field(struct file *, nf_file)
891 ),
892 TP_fast_assign(
893 __entry->nf_inode = nf->nf_inode;
894 __entry->nf_ref = refcount_read(&nf->nf_ref);
895 __entry->nf_flags = nf->nf_flags;
896 __entry->nf_may = nf->nf_may;
897 __entry->nf_file = nf->nf_file;
898 ),
899 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
900 __entry->nf_inode,
901 __entry->nf_ref,
902 show_nf_flags(__entry->nf_flags),
903 show_nfsd_may_flags(__entry->nf_may),
904 __entry->nf_file)
905)
906
907#define DEFINE_NFSD_FILE_EVENT(name) \
908DEFINE_EVENT(nfsd_file_class, name, \
909 TP_PROTO(struct nfsd_file *nf), \
910 TP_ARGS(nf))
911
912DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
913DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
914DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
915DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
916DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue);
917
918TRACE_EVENT(nfsd_file_alloc,
919 TP_PROTO(
920 const struct nfsd_file *nf
921 ),
922 TP_ARGS(nf),
923 TP_STRUCT__entry(
924 __field(const void *, nf_inode)
925 __field(unsigned long, nf_flags)
926 __field(unsigned long, nf_may)
927 __field(unsigned int, nf_ref)
928 ),
929 TP_fast_assign(
930 __entry->nf_inode = nf->nf_inode;
931 __entry->nf_flags = nf->nf_flags;
932 __entry->nf_ref = refcount_read(&nf->nf_ref);
933 __entry->nf_may = nf->nf_may;
934 ),
935 TP_printk("inode=%p ref=%u flags=%s may=%s",
936 __entry->nf_inode, __entry->nf_ref,
937 show_nf_flags(__entry->nf_flags),
938 show_nfsd_may_flags(__entry->nf_may)
939 )
940);
941
942TRACE_EVENT(nfsd_file_acquire,
943 TP_PROTO(
944 const struct svc_rqst *rqstp,
945 const struct inode *inode,
946 unsigned int may_flags,
947 const struct nfsd_file *nf,
948 __be32 status
949 ),
950
951 TP_ARGS(rqstp, inode, may_flags, nf, status),
952
953 TP_STRUCT__entry(
954 __field(u32, xid)
955 __field(const void *, inode)
956 __field(unsigned long, may_flags)
957 __field(unsigned int, nf_ref)
958 __field(unsigned long, nf_flags)
959 __field(unsigned long, nf_may)
960 __field(const void *, nf_file)
961 __field(u32, status)
962 ),
963
964 TP_fast_assign(
965 __entry->xid = be32_to_cpu(rqstp->rq_xid);
966 __entry->inode = inode;
967 __entry->may_flags = may_flags;
968 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
969 __entry->nf_flags = nf ? nf->nf_flags : 0;
970 __entry->nf_may = nf ? nf->nf_may : 0;
971 __entry->nf_file = nf ? nf->nf_file : NULL;
972 __entry->status = be32_to_cpu(status);
973 ),
974
975 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
976 __entry->xid, __entry->inode,
977 show_nfsd_may_flags(__entry->may_flags),
978 __entry->nf_ref, show_nf_flags(__entry->nf_flags),
979 show_nfsd_may_flags(__entry->nf_may),
980 __entry->nf_file, __entry->status
981 )
982);
983
984TRACE_EVENT(nfsd_file_insert_err,
985 TP_PROTO(
986 const struct svc_rqst *rqstp,
987 const struct inode *inode,
988 unsigned int may_flags,
989 long error
990 ),
991 TP_ARGS(rqstp, inode, may_flags, error),
992 TP_STRUCT__entry(
993 __field(u32, xid)
994 __field(const void *, inode)
995 __field(unsigned long, may_flags)
996 __field(long, error)
997 ),
998 TP_fast_assign(
999 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1000 __entry->inode = inode;
1001 __entry->may_flags = may_flags;
1002 __entry->error = error;
1003 ),
1004 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1005 __entry->xid, __entry->inode,
1006 show_nfsd_may_flags(__entry->may_flags),
1007 __entry->error
1008 )
1009);
1010
1011TRACE_EVENT(nfsd_file_cons_err,
1012 TP_PROTO(
1013 const struct svc_rqst *rqstp,
1014 const struct inode *inode,
1015 unsigned int may_flags,
1016 const struct nfsd_file *nf
1017 ),
1018 TP_ARGS(rqstp, inode, may_flags, nf),
1019 TP_STRUCT__entry(
1020 __field(u32, xid)
1021 __field(const void *, inode)
1022 __field(unsigned long, may_flags)
1023 __field(unsigned int, nf_ref)
1024 __field(unsigned long, nf_flags)
1025 __field(unsigned long, nf_may)
1026 __field(const void *, nf_file)
1027 ),
1028 TP_fast_assign(
1029 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1030 __entry->inode = inode;
1031 __entry->may_flags = may_flags;
1032 __entry->nf_ref = refcount_read(&nf->nf_ref);
1033 __entry->nf_flags = nf->nf_flags;
1034 __entry->nf_may = nf->nf_may;
1035 __entry->nf_file = nf->nf_file;
1036 ),
1037 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1038 __entry->xid, __entry->inode,
1039 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1040 show_nf_flags(__entry->nf_flags),
1041 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1042 )
1043);
1044
1045DECLARE_EVENT_CLASS(nfsd_file_open_class,
1046 TP_PROTO(const struct nfsd_file *nf, __be32 status),
1047 TP_ARGS(nf, status),
1048 TP_STRUCT__entry(
1049 __field(void *, nf_inode) /* cannot be dereferenced */
1050 __field(int, nf_ref)
1051 __field(unsigned long, nf_flags)
1052 __field(unsigned long, nf_may)
1053 __field(void *, nf_file) /* cannot be dereferenced */
1054 ),
1055 TP_fast_assign(
1056 __entry->nf_inode = nf->nf_inode;
1057 __entry->nf_ref = refcount_read(&nf->nf_ref);
1058 __entry->nf_flags = nf->nf_flags;
1059 __entry->nf_may = nf->nf_may;
1060 __entry->nf_file = nf->nf_file;
1061 ),
1062 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1063 __entry->nf_inode,
1064 __entry->nf_ref,
1065 show_nf_flags(__entry->nf_flags),
1066 show_nfsd_may_flags(__entry->nf_may),
1067 __entry->nf_file)
1068)
1069
1070#define DEFINE_NFSD_FILE_OPEN_EVENT(name) \
1071DEFINE_EVENT(nfsd_file_open_class, name, \
1072 TP_PROTO( \
1073 const struct nfsd_file *nf, \
1074 __be32 status \
1075 ), \
1076 TP_ARGS(nf, status))
1077
1078DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1079DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1080
1081TRACE_EVENT(nfsd_file_is_cached,
1082 TP_PROTO(
1083 const struct inode *inode,
1084 int found
1085 ),
1086 TP_ARGS(inode, found),
1087 TP_STRUCT__entry(
1088 __field(const struct inode *, inode)
1089 __field(int, found)
1090 ),
1091 TP_fast_assign(
1092 __entry->inode = inode;
1093 __entry->found = found;
1094 ),
1095 TP_printk("inode=%p is %scached",
1096 __entry->inode,
1097 __entry->found ? "" : "not "
1098 )
1099);
1100
1101TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1102 TP_PROTO(struct inode *inode, u32 mask),
1103 TP_ARGS(inode, mask),
1104 TP_STRUCT__entry(
1105 __field(struct inode *, inode)
1106 __field(unsigned int, nlink)
1107 __field(umode_t, mode)
1108 __field(u32, mask)
1109 ),
1110 TP_fast_assign(
1111 __entry->inode = inode;
1112 __entry->nlink = inode->i_nlink;
1113 __entry->mode = inode->i_mode;
1114 __entry->mask = mask;
1115 ),
1116 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1117 __entry->nlink, __entry->mode, __entry->mask)
1118);
1119
1120DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1121 TP_PROTO(
1122 const struct nfsd_file *nf
1123 ),
1124 TP_ARGS(nf),
1125 TP_STRUCT__entry(
1126 __field(void *, nf_inode)
1127 __field(void *, nf_file)
1128 __field(int, nf_ref)
1129 __field(unsigned long, nf_flags)
1130 ),
1131 TP_fast_assign(
1132 __entry->nf_inode = nf->nf_inode;
1133 __entry->nf_file = nf->nf_file;
1134 __entry->nf_ref = refcount_read(&nf->nf_ref);
1135 __entry->nf_flags = nf->nf_flags;
1136 ),
1137 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1138 __entry->nf_inode, __entry->nf_ref,
1139 show_nf_flags(__entry->nf_flags),
1140 __entry->nf_file
1141 )
1142);
1143
1144#define DEFINE_NFSD_FILE_GC_EVENT(name) \
1145DEFINE_EVENT(nfsd_file_gc_class, name, \
1146 TP_PROTO( \
1147 const struct nfsd_file *nf \
1148 ), \
1149 TP_ARGS(nf))
1150
1151DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1152DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1153DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1154DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1155DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1156DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1157DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1158DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1159
1160DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1161 TP_PROTO(
1162 unsigned long removed,
1163 unsigned long remaining
1164 ),
1165 TP_ARGS(removed, remaining),
1166 TP_STRUCT__entry(
1167 __field(unsigned long, removed)
1168 __field(unsigned long, remaining)
1169 ),
1170 TP_fast_assign(
1171 __entry->removed = removed;
1172 __entry->remaining = remaining;
1173 ),
1174 TP_printk("%lu entries removed, %lu remaining",
1175 __entry->removed, __entry->remaining)
1176);
1177
1178#define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \
1179DEFINE_EVENT(nfsd_file_lruwalk_class, name, \
1180 TP_PROTO( \
1181 unsigned long removed, \
1182 unsigned long remaining \
1183 ), \
1184 TP_ARGS(removed, remaining))
1185
1186DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1187DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1188
1189TRACE_EVENT(nfsd_file_close,
1190 TP_PROTO(
1191 const struct inode *inode
1192 ),
1193 TP_ARGS(inode),
1194 TP_STRUCT__entry(
1195 __field(const void *, inode)
1196 ),
1197 TP_fast_assign(
1198 __entry->inode = inode;
1199 ),
1200 TP_printk("inode=%p",
1201 __entry->inode
1202 )
1203);
1204
1205TRACE_EVENT(nfsd_file_fsync,
1206 TP_PROTO(
1207 const struct nfsd_file *nf,
1208 int ret
1209 ),
1210 TP_ARGS(nf, ret),
1211 TP_STRUCT__entry(
1212 __field(void *, nf_inode)
1213 __field(int, nf_ref)
1214 __field(int, ret)
1215 __field(unsigned long, nf_flags)
1216 __field(unsigned char, nf_may)
1217 __field(struct file *, nf_file)
1218 ),
1219 TP_fast_assign(
1220 __entry->nf_inode = nf->nf_inode;
1221 __entry->nf_ref = refcount_read(&nf->nf_ref);
1222 __entry->ret = ret;
1223 __entry->nf_flags = nf->nf_flags;
1224 __entry->nf_may = nf->nf_may;
1225 __entry->nf_file = nf->nf_file;
1226 ),
1227 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p ret=%d",
1228 __entry->nf_inode,
1229 __entry->nf_ref,
1230 show_nf_flags(__entry->nf_flags),
1231 show_nfsd_may_flags(__entry->nf_may),
1232 __entry->nf_file, __entry->ret
1233 )
1234);
1235
1236#include "cache.h"
1237
1238TRACE_DEFINE_ENUM(RC_DROPIT);
1239TRACE_DEFINE_ENUM(RC_REPLY);
1240TRACE_DEFINE_ENUM(RC_DOIT);
1241
1242#define show_drc_retval(x) \
1243 __print_symbolic(x, \
1244 { RC_DROPIT, "DROPIT" }, \
1245 { RC_REPLY, "REPLY" }, \
1246 { RC_DOIT, "DOIT" })
1247
1248TRACE_EVENT(nfsd_drc_found,
1249 TP_PROTO(
1250 const struct nfsd_net *nn,
1251 const struct svc_rqst *rqstp,
1252 int result
1253 ),
1254 TP_ARGS(nn, rqstp, result),
1255 TP_STRUCT__entry(
1256 __field(unsigned long long, boot_time)
1257 __field(unsigned long, result)
1258 __field(u32, xid)
1259 ),
1260 TP_fast_assign(
1261 __entry->boot_time = nn->boot_time;
1262 __entry->result = result;
1263 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1264 ),
1265 TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1266 __entry->boot_time, __entry->xid,
1267 show_drc_retval(__entry->result))
1268
1269);
1270
1271TRACE_EVENT(nfsd_drc_mismatch,
1272 TP_PROTO(
1273 const struct nfsd_net *nn,
1274 const struct svc_cacherep *key,
1275 const struct svc_cacherep *rp
1276 ),
1277 TP_ARGS(nn, key, rp),
1278 TP_STRUCT__entry(
1279 __field(unsigned long long, boot_time)
1280 __field(u32, xid)
1281 __field(u32, cached)
1282 __field(u32, ingress)
1283 ),
1284 TP_fast_assign(
1285 __entry->boot_time = nn->boot_time;
1286 __entry->xid = be32_to_cpu(key->c_key.k_xid);
1287 __entry->cached = (__force u32)key->c_key.k_csum;
1288 __entry->ingress = (__force u32)rp->c_key.k_csum;
1289 ),
1290 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1291 __entry->boot_time, __entry->xid, __entry->cached,
1292 __entry->ingress)
1293);
1294
1295TRACE_EVENT(nfsd_cb_args,
1296 TP_PROTO(
1297 const struct nfs4_client *clp,
1298 const struct nfs4_cb_conn *conn
1299 ),
1300 TP_ARGS(clp, conn),
1301 TP_STRUCT__entry(
1302 __field(u32, cl_boot)
1303 __field(u32, cl_id)
1304 __field(u32, prog)
1305 __field(u32, ident)
1306 __sockaddr(addr, conn->cb_addrlen)
1307 ),
1308 TP_fast_assign(
1309 __entry->cl_boot = clp->cl_clientid.cl_boot;
1310 __entry->cl_id = clp->cl_clientid.cl_id;
1311 __entry->prog = conn->cb_prog;
1312 __entry->ident = conn->cb_ident;
1313 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1314 ),
1315 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1316 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1317 __entry->prog, __entry->ident)
1318);
1319
1320TRACE_EVENT(nfsd_cb_nodelegs,
1321 TP_PROTO(const struct nfs4_client *clp),
1322 TP_ARGS(clp),
1323 TP_STRUCT__entry(
1324 __field(u32, cl_boot)
1325 __field(u32, cl_id)
1326 ),
1327 TP_fast_assign(
1328 __entry->cl_boot = clp->cl_clientid.cl_boot;
1329 __entry->cl_id = clp->cl_clientid.cl_id;
1330 ),
1331 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1332)
1333
1334#define show_cb_state(val) \
1335 __print_symbolic(val, \
1336 { NFSD4_CB_UP, "UP" }, \
1337 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \
1338 { NFSD4_CB_DOWN, "DOWN" }, \
1339 { NFSD4_CB_FAULT, "FAULT"})
1340
1341DECLARE_EVENT_CLASS(nfsd_cb_class,
1342 TP_PROTO(const struct nfs4_client *clp),
1343 TP_ARGS(clp),
1344 TP_STRUCT__entry(
1345 __field(unsigned long, state)
1346 __field(u32, cl_boot)
1347 __field(u32, cl_id)
1348 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1349 ),
1350 TP_fast_assign(
1351 __entry->state = clp->cl_cb_state;
1352 __entry->cl_boot = clp->cl_clientid.cl_boot;
1353 __entry->cl_id = clp->cl_clientid.cl_id;
1354 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1355 clp->cl_cb_conn.cb_addrlen)
1356 ),
1357 TP_printk("addr=%pISpc client %08x:%08x state=%s",
1358 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1359 show_cb_state(__entry->state))
1360);
1361
1362#define DEFINE_NFSD_CB_EVENT(name) \
1363DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \
1364 TP_PROTO(const struct nfs4_client *clp), \
1365 TP_ARGS(clp))
1366
1367DEFINE_NFSD_CB_EVENT(state);
1368DEFINE_NFSD_CB_EVENT(probe);
1369DEFINE_NFSD_CB_EVENT(lost);
1370DEFINE_NFSD_CB_EVENT(shutdown);
1371
1372TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1373TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1374TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1375TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1376TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1377TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1378
1379#define show_nfsd_authflavor(val) \
1380 __print_symbolic(val, \
1381 { RPC_AUTH_NULL, "none" }, \
1382 { RPC_AUTH_UNIX, "sys" }, \
1383 { RPC_AUTH_GSS, "gss" }, \
1384 { RPC_AUTH_GSS_KRB5, "krb5" }, \
1385 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \
1386 { RPC_AUTH_GSS_KRB5P, "krb5p" })
1387
1388TRACE_EVENT(nfsd_cb_setup,
1389 TP_PROTO(const struct nfs4_client *clp,
1390 const char *netid,
1391 rpc_authflavor_t authflavor
1392 ),
1393 TP_ARGS(clp, netid, authflavor),
1394 TP_STRUCT__entry(
1395 __field(u32, cl_boot)
1396 __field(u32, cl_id)
1397 __field(unsigned long, authflavor)
1398 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1399 __array(unsigned char, netid, 8)
1400 ),
1401 TP_fast_assign(
1402 __entry->cl_boot = clp->cl_clientid.cl_boot;
1403 __entry->cl_id = clp->cl_clientid.cl_id;
1404 strlcpy(__entry->netid, netid, sizeof(__entry->netid));
1405 __entry->authflavor = authflavor;
1406 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1407 clp->cl_cb_conn.cb_addrlen)
1408 ),
1409 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1410 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1411 __entry->netid, show_nfsd_authflavor(__entry->authflavor))
1412);
1413
1414TRACE_EVENT(nfsd_cb_setup_err,
1415 TP_PROTO(
1416 const struct nfs4_client *clp,
1417 long error
1418 ),
1419 TP_ARGS(clp, error),
1420 TP_STRUCT__entry(
1421 __field(long, error)
1422 __field(u32, cl_boot)
1423 __field(u32, cl_id)
1424 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1425 ),
1426 TP_fast_assign(
1427 __entry->error = error;
1428 __entry->cl_boot = clp->cl_clientid.cl_boot;
1429 __entry->cl_id = clp->cl_clientid.cl_id;
1430 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1431 clp->cl_cb_conn.cb_addrlen)
1432 ),
1433 TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1434 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1435 __entry->error)
1436);
1437
1438TRACE_EVENT_CONDITION(nfsd_cb_recall,
1439 TP_PROTO(
1440 const struct nfs4_stid *stid
1441 ),
1442 TP_ARGS(stid),
1443 TP_CONDITION(stid->sc_client),
1444 TP_STRUCT__entry(
1445 __field(u32, cl_boot)
1446 __field(u32, cl_id)
1447 __field(u32, si_id)
1448 __field(u32, si_generation)
1449 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1450 ),
1451 TP_fast_assign(
1452 const stateid_t *stp = &stid->sc_stateid;
1453 const struct nfs4_client *clp = stid->sc_client;
1454
1455 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1456 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1457 __entry->si_id = stp->si_opaque.so_id;
1458 __entry->si_generation = stp->si_generation;
1459 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1460 clp->cl_cb_conn.cb_addrlen)
1461 ),
1462 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1463 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1464 __entry->si_id, __entry->si_generation)
1465);
1466
1467TRACE_EVENT(nfsd_cb_notify_lock,
1468 TP_PROTO(
1469 const struct nfs4_lockowner *lo,
1470 const struct nfsd4_blocked_lock *nbl
1471 ),
1472 TP_ARGS(lo, nbl),
1473 TP_STRUCT__entry(
1474 __field(u32, cl_boot)
1475 __field(u32, cl_id)
1476 __field(u32, fh_hash)
1477 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1478 ),
1479 TP_fast_assign(
1480 const struct nfs4_client *clp = lo->lo_owner.so_client;
1481
1482 __entry->cl_boot = clp->cl_clientid.cl_boot;
1483 __entry->cl_id = clp->cl_clientid.cl_id;
1484 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1485 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1486 clp->cl_cb_conn.cb_addrlen)
1487 ),
1488 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1489 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1490 __entry->fh_hash)
1491);
1492
1493TRACE_EVENT(nfsd_cb_offload,
1494 TP_PROTO(
1495 const struct nfs4_client *clp,
1496 const stateid_t *stp,
1497 const struct knfsd_fh *fh,
1498 u64 count,
1499 __be32 status
1500 ),
1501 TP_ARGS(clp, stp, fh, count, status),
1502 TP_STRUCT__entry(
1503 __field(u32, cl_boot)
1504 __field(u32, cl_id)
1505 __field(u32, si_id)
1506 __field(u32, si_generation)
1507 __field(u32, fh_hash)
1508 __field(int, status)
1509 __field(u64, count)
1510 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1511 ),
1512 TP_fast_assign(
1513 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1514 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1515 __entry->si_id = stp->si_opaque.so_id;
1516 __entry->si_generation = stp->si_generation;
1517 __entry->fh_hash = knfsd_fh_hash(fh);
1518 __entry->status = be32_to_cpu(status);
1519 __entry->count = count;
1520 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1521 clp->cl_cb_conn.cb_addrlen)
1522 ),
1523 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1524 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1525 __entry->si_id, __entry->si_generation,
1526 __entry->fh_hash, __entry->count, __entry->status)
1527);
1528
1529TRACE_EVENT(nfsd_cb_recall_any,
1530 TP_PROTO(
1531 const struct nfsd4_cb_recall_any *ra
1532 ),
1533 TP_ARGS(ra),
1534 TP_STRUCT__entry(
1535 __field(u32, cl_boot)
1536 __field(u32, cl_id)
1537 __field(u32, keep)
1538 __field(unsigned long, bmval0)
1539 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1540 ),
1541 TP_fast_assign(
1542 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1543 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1544 __entry->keep = ra->ra_keep;
1545 __entry->bmval0 = ra->ra_bmval[0];
1546 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1547 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1548 ),
1549 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1550 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1551 __entry->keep, show_rca_mask(__entry->bmval0)
1552 )
1553);
1554
1555DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1556 TP_PROTO(
1557 const stateid_t *stp,
1558 const struct rpc_task *task
1559 ),
1560 TP_ARGS(stp, task),
1561 TP_STRUCT__entry(
1562 __field(u32, cl_boot)
1563 __field(u32, cl_id)
1564 __field(u32, si_id)
1565 __field(u32, si_generation)
1566 __field(int, status)
1567 ),
1568 TP_fast_assign(
1569 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1570 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1571 __entry->si_id = stp->si_opaque.so_id;
1572 __entry->si_generation = stp->si_generation;
1573 __entry->status = task->tk_status;
1574 ),
1575 TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1576 __entry->cl_boot, __entry->cl_id, __entry->si_id,
1577 __entry->si_generation, __entry->status
1578 )
1579);
1580
1581#define DEFINE_NFSD_CB_DONE_EVENT(name) \
1582DEFINE_EVENT(nfsd_cb_done_class, name, \
1583 TP_PROTO( \
1584 const stateid_t *stp, \
1585 const struct rpc_task *task \
1586 ), \
1587 TP_ARGS(stp, task))
1588
1589DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1590DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1591DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1592DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1593
1594TRACE_EVENT(nfsd_cb_recall_any_done,
1595 TP_PROTO(
1596 const struct nfsd4_callback *cb,
1597 const struct rpc_task *task
1598 ),
1599 TP_ARGS(cb, task),
1600 TP_STRUCT__entry(
1601 __field(u32, cl_boot)
1602 __field(u32, cl_id)
1603 __field(int, status)
1604 ),
1605 TP_fast_assign(
1606 __entry->status = task->tk_status;
1607 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1608 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1609 ),
1610 TP_printk("client %08x:%08x status=%d",
1611 __entry->cl_boot, __entry->cl_id, __entry->status
1612 )
1613);
1614
1615#endif /* _NFSD_TRACE_H */
1616
1617#undef TRACE_INCLUDE_PATH
1618#define TRACE_INCLUDE_PATH .
1619#define TRACE_INCLUDE_FILE trace
1620#include <trace/define_trace.h>
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Copyright (c) 2014 Christoph Hellwig.
4 */
5#undef TRACE_SYSTEM
6#define TRACE_SYSTEM nfsd
7
8#if !defined(_NFSD_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
9#define _NFSD_TRACE_H
10
11#include <linux/tracepoint.h>
12#include <linux/sunrpc/clnt.h>
13#include <linux/sunrpc/xprt.h>
14#include <trace/misc/nfs.h>
15#include <trace/misc/sunrpc.h>
16
17#include "export.h"
18#include "nfsfh.h"
19#include "xdr4.h"
20
21#define NFSD_TRACE_PROC_RES_FIELDS \
22 __field(unsigned int, netns_ino) \
23 __field(u32, xid) \
24 __field(unsigned long, status) \
25 __array(unsigned char, server, sizeof(struct sockaddr_in6)) \
26 __array(unsigned char, client, sizeof(struct sockaddr_in6))
27
28#define NFSD_TRACE_PROC_RES_ASSIGNMENTS(error) \
29 do { \
30 __entry->netns_ino = SVC_NET(rqstp)->ns.inum; \
31 __entry->xid = be32_to_cpu(rqstp->rq_xid); \
32 __entry->status = be32_to_cpu(error); \
33 memcpy(__entry->server, &rqstp->rq_xprt->xpt_local, \
34 rqstp->rq_xprt->xpt_locallen); \
35 memcpy(__entry->client, &rqstp->rq_xprt->xpt_remote, \
36 rqstp->rq_xprt->xpt_remotelen); \
37 } while (0);
38
39DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
40 TP_PROTO(
41 const struct svc_rqst *rqstp
42 ),
43 TP_ARGS(rqstp),
44 TP_STRUCT__entry(
45 __field(unsigned int, netns_ino)
46 __field(u32, xid)
47 __field(u32, vers)
48 __field(u32, proc)
49 __sockaddr(server, rqstp->rq_xprt->xpt_locallen)
50 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
51 ),
52 TP_fast_assign(
53 const struct svc_xprt *xprt = rqstp->rq_xprt;
54
55 __entry->netns_ino = xprt->xpt_net->ns.inum;
56 __entry->xid = be32_to_cpu(rqstp->rq_xid);
57 __entry->vers = rqstp->rq_vers;
58 __entry->proc = rqstp->rq_proc;
59 __assign_sockaddr(server, &xprt->xpt_local, xprt->xpt_locallen);
60 __assign_sockaddr(client, &xprt->xpt_remote, xprt->xpt_remotelen);
61 ),
62 TP_printk("xid=0x%08x vers=%u proc=%u",
63 __entry->xid, __entry->vers, __entry->proc
64 )
65);
66
67#define DEFINE_NFSD_XDR_ERR_EVENT(name) \
68DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
69 TP_PROTO(const struct svc_rqst *rqstp), \
70 TP_ARGS(rqstp))
71
72DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
73DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
74
75#define show_nfsd_may_flags(x) \
76 __print_flags(x, "|", \
77 { NFSD_MAY_EXEC, "EXEC" }, \
78 { NFSD_MAY_WRITE, "WRITE" }, \
79 { NFSD_MAY_READ, "READ" }, \
80 { NFSD_MAY_SATTR, "SATTR" }, \
81 { NFSD_MAY_TRUNC, "TRUNC" }, \
82 { NFSD_MAY_LOCK, "LOCK" }, \
83 { NFSD_MAY_OWNER_OVERRIDE, "OWNER_OVERRIDE" }, \
84 { NFSD_MAY_LOCAL_ACCESS, "LOCAL_ACCESS" }, \
85 { NFSD_MAY_BYPASS_GSS_ON_ROOT, "BYPASS_GSS_ON_ROOT" }, \
86 { NFSD_MAY_NOT_BREAK_LEASE, "NOT_BREAK_LEASE" }, \
87 { NFSD_MAY_BYPASS_GSS, "BYPASS_GSS" }, \
88 { NFSD_MAY_READ_IF_EXEC, "READ_IF_EXEC" }, \
89 { NFSD_MAY_64BIT_COOKIE, "64BIT_COOKIE" })
90
91TRACE_EVENT(nfsd_compound,
92 TP_PROTO(
93 const struct svc_rqst *rqst,
94 const char *tag,
95 u32 taglen,
96 u32 opcnt
97 ),
98 TP_ARGS(rqst, tag, taglen, opcnt),
99 TP_STRUCT__entry(
100 __field(u32, xid)
101 __field(u32, opcnt)
102 __string_len(tag, tag, taglen)
103 ),
104 TP_fast_assign(
105 __entry->xid = be32_to_cpu(rqst->rq_xid);
106 __entry->opcnt = opcnt;
107 __assign_str(tag, tag);
108 ),
109 TP_printk("xid=0x%08x opcnt=%u tag=%s",
110 __entry->xid, __entry->opcnt, __get_str(tag)
111 )
112)
113
114TRACE_EVENT(nfsd_compound_status,
115 TP_PROTO(u32 args_opcnt,
116 u32 resp_opcnt,
117 __be32 status,
118 const char *name),
119 TP_ARGS(args_opcnt, resp_opcnt, status, name),
120 TP_STRUCT__entry(
121 __field(u32, args_opcnt)
122 __field(u32, resp_opcnt)
123 __field(int, status)
124 __string(name, name)
125 ),
126 TP_fast_assign(
127 __entry->args_opcnt = args_opcnt;
128 __entry->resp_opcnt = resp_opcnt;
129 __entry->status = be32_to_cpu(status);
130 __assign_str(name, name);
131 ),
132 TP_printk("op=%u/%u %s status=%d",
133 __entry->resp_opcnt, __entry->args_opcnt,
134 __get_str(name), __entry->status)
135)
136
137TRACE_EVENT(nfsd_compound_decode_err,
138 TP_PROTO(
139 const struct svc_rqst *rqstp,
140 u32 args_opcnt,
141 u32 resp_opcnt,
142 u32 opnum,
143 __be32 status
144 ),
145 TP_ARGS(rqstp, args_opcnt, resp_opcnt, opnum, status),
146 TP_STRUCT__entry(
147 NFSD_TRACE_PROC_RES_FIELDS
148
149 __field(u32, args_opcnt)
150 __field(u32, resp_opcnt)
151 __field(u32, opnum)
152 ),
153 TP_fast_assign(
154 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
155
156 __entry->args_opcnt = args_opcnt;
157 __entry->resp_opcnt = resp_opcnt;
158 __entry->opnum = opnum;
159 ),
160 TP_printk("op=%u/%u opnum=%u status=%lu",
161 __entry->resp_opcnt, __entry->args_opcnt,
162 __entry->opnum, __entry->status)
163);
164
165TRACE_EVENT(nfsd_compound_encode_err,
166 TP_PROTO(
167 const struct svc_rqst *rqstp,
168 u32 opnum,
169 __be32 status
170 ),
171 TP_ARGS(rqstp, opnum, status),
172 TP_STRUCT__entry(
173 NFSD_TRACE_PROC_RES_FIELDS
174
175 __field(u32, opnum)
176 ),
177 TP_fast_assign(
178 NFSD_TRACE_PROC_RES_ASSIGNMENTS(status)
179
180 __entry->opnum = opnum;
181 ),
182 TP_printk("opnum=%u status=%lu",
183 __entry->opnum, __entry->status)
184);
185
186#define show_fs_file_type(x) \
187 __print_symbolic(x, \
188 { S_IFLNK, "LNK" }, \
189 { S_IFREG, "REG" }, \
190 { S_IFDIR, "DIR" }, \
191 { S_IFCHR, "CHR" }, \
192 { S_IFBLK, "BLK" }, \
193 { S_IFIFO, "FIFO" }, \
194 { S_IFSOCK, "SOCK" })
195
196TRACE_EVENT(nfsd_fh_verify,
197 TP_PROTO(
198 const struct svc_rqst *rqstp,
199 const struct svc_fh *fhp,
200 umode_t type,
201 int access
202 ),
203 TP_ARGS(rqstp, fhp, type, access),
204 TP_STRUCT__entry(
205 __field(unsigned int, netns_ino)
206 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
207 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
208 __field(u32, xid)
209 __field(u32, fh_hash)
210 __field(const void *, inode)
211 __field(unsigned long, type)
212 __field(unsigned long, access)
213 ),
214 TP_fast_assign(
215 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
216 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
217 rqstp->rq_xprt->xpt_locallen);
218 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
219 rqstp->rq_xprt->xpt_remotelen);
220 __entry->xid = be32_to_cpu(rqstp->rq_xid);
221 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
222 __entry->inode = d_inode(fhp->fh_dentry);
223 __entry->type = type;
224 __entry->access = access;
225 ),
226 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s",
227 __entry->xid, __entry->fh_hash,
228 show_fs_file_type(__entry->type),
229 show_nfsd_may_flags(__entry->access)
230 )
231);
232
233TRACE_EVENT_CONDITION(nfsd_fh_verify_err,
234 TP_PROTO(
235 const struct svc_rqst *rqstp,
236 const struct svc_fh *fhp,
237 umode_t type,
238 int access,
239 __be32 error
240 ),
241 TP_ARGS(rqstp, fhp, type, access, error),
242 TP_CONDITION(error),
243 TP_STRUCT__entry(
244 __field(unsigned int, netns_ino)
245 __sockaddr(server, rqstp->rq_xprt->xpt_remotelen)
246 __sockaddr(client, rqstp->rq_xprt->xpt_remotelen)
247 __field(u32, xid)
248 __field(u32, fh_hash)
249 __field(const void *, inode)
250 __field(unsigned long, type)
251 __field(unsigned long, access)
252 __field(int, error)
253 ),
254 TP_fast_assign(
255 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
256 __assign_sockaddr(server, &rqstp->rq_xprt->xpt_local,
257 rqstp->rq_xprt->xpt_locallen);
258 __assign_sockaddr(client, &rqstp->rq_xprt->xpt_remote,
259 rqstp->rq_xprt->xpt_remotelen);
260 __entry->xid = be32_to_cpu(rqstp->rq_xid);
261 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
262 if (fhp->fh_dentry)
263 __entry->inode = d_inode(fhp->fh_dentry);
264 else
265 __entry->inode = NULL;
266 __entry->type = type;
267 __entry->access = access;
268 __entry->error = be32_to_cpu(error);
269 ),
270 TP_printk("xid=0x%08x fh_hash=0x%08x type=%s access=%s error=%d",
271 __entry->xid, __entry->fh_hash,
272 show_fs_file_type(__entry->type),
273 show_nfsd_may_flags(__entry->access),
274 __entry->error
275 )
276);
277
278DECLARE_EVENT_CLASS(nfsd_fh_err_class,
279 TP_PROTO(struct svc_rqst *rqstp,
280 struct svc_fh *fhp,
281 int status),
282 TP_ARGS(rqstp, fhp, status),
283 TP_STRUCT__entry(
284 __field(u32, xid)
285 __field(u32, fh_hash)
286 __field(int, status)
287 ),
288 TP_fast_assign(
289 __entry->xid = be32_to_cpu(rqstp->rq_xid);
290 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
291 __entry->status = status;
292 ),
293 TP_printk("xid=0x%08x fh_hash=0x%08x status=%d",
294 __entry->xid, __entry->fh_hash,
295 __entry->status)
296)
297
298#define DEFINE_NFSD_FH_ERR_EVENT(name) \
299DEFINE_EVENT(nfsd_fh_err_class, nfsd_##name, \
300 TP_PROTO(struct svc_rqst *rqstp, \
301 struct svc_fh *fhp, \
302 int status), \
303 TP_ARGS(rqstp, fhp, status))
304
305DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
306DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
307
308TRACE_EVENT(nfsd_exp_find_key,
309 TP_PROTO(const struct svc_expkey *key,
310 int status),
311 TP_ARGS(key, status),
312 TP_STRUCT__entry(
313 __field(int, fsidtype)
314 __array(u32, fsid, 6)
315 __string(auth_domain, key->ek_client->name)
316 __field(int, status)
317 ),
318 TP_fast_assign(
319 __entry->fsidtype = key->ek_fsidtype;
320 memcpy(__entry->fsid, key->ek_fsid, 4*6);
321 __assign_str(auth_domain, key->ek_client->name);
322 __entry->status = status;
323 ),
324 TP_printk("fsid=%x::%s domain=%s status=%d",
325 __entry->fsidtype,
326 __print_array(__entry->fsid, 6, 4),
327 __get_str(auth_domain),
328 __entry->status
329 )
330);
331
332TRACE_EVENT(nfsd_expkey_update,
333 TP_PROTO(const struct svc_expkey *key, const char *exp_path),
334 TP_ARGS(key, exp_path),
335 TP_STRUCT__entry(
336 __field(int, fsidtype)
337 __array(u32, fsid, 6)
338 __string(auth_domain, key->ek_client->name)
339 __string(path, exp_path)
340 __field(bool, cache)
341 ),
342 TP_fast_assign(
343 __entry->fsidtype = key->ek_fsidtype;
344 memcpy(__entry->fsid, key->ek_fsid, 4*6);
345 __assign_str(auth_domain, key->ek_client->name);
346 __assign_str(path, exp_path);
347 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
348 ),
349 TP_printk("fsid=%x::%s domain=%s path=%s cache=%s",
350 __entry->fsidtype,
351 __print_array(__entry->fsid, 6, 4),
352 __get_str(auth_domain),
353 __get_str(path),
354 __entry->cache ? "pos" : "neg"
355 )
356);
357
358TRACE_EVENT(nfsd_exp_get_by_name,
359 TP_PROTO(const struct svc_export *key,
360 int status),
361 TP_ARGS(key, status),
362 TP_STRUCT__entry(
363 __string(path, key->ex_path.dentry->d_name.name)
364 __string(auth_domain, key->ex_client->name)
365 __field(int, status)
366 ),
367 TP_fast_assign(
368 __assign_str(path, key->ex_path.dentry->d_name.name);
369 __assign_str(auth_domain, key->ex_client->name);
370 __entry->status = status;
371 ),
372 TP_printk("path=%s domain=%s status=%d",
373 __get_str(path),
374 __get_str(auth_domain),
375 __entry->status
376 )
377);
378
379TRACE_EVENT(nfsd_export_update,
380 TP_PROTO(const struct svc_export *key),
381 TP_ARGS(key),
382 TP_STRUCT__entry(
383 __string(path, key->ex_path.dentry->d_name.name)
384 __string(auth_domain, key->ex_client->name)
385 __field(bool, cache)
386 ),
387 TP_fast_assign(
388 __assign_str(path, key->ex_path.dentry->d_name.name);
389 __assign_str(auth_domain, key->ex_client->name);
390 __entry->cache = !test_bit(CACHE_NEGATIVE, &key->h.flags);
391 ),
392 TP_printk("path=%s domain=%s cache=%s",
393 __get_str(path),
394 __get_str(auth_domain),
395 __entry->cache ? "pos" : "neg"
396 )
397);
398
399DECLARE_EVENT_CLASS(nfsd_io_class,
400 TP_PROTO(struct svc_rqst *rqstp,
401 struct svc_fh *fhp,
402 u64 offset,
403 u32 len),
404 TP_ARGS(rqstp, fhp, offset, len),
405 TP_STRUCT__entry(
406 __field(u32, xid)
407 __field(u32, fh_hash)
408 __field(u64, offset)
409 __field(u32, len)
410 ),
411 TP_fast_assign(
412 __entry->xid = be32_to_cpu(rqstp->rq_xid);
413 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
414 __entry->offset = offset;
415 __entry->len = len;
416 ),
417 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%llu len=%u",
418 __entry->xid, __entry->fh_hash,
419 __entry->offset, __entry->len)
420)
421
422#define DEFINE_NFSD_IO_EVENT(name) \
423DEFINE_EVENT(nfsd_io_class, nfsd_##name, \
424 TP_PROTO(struct svc_rqst *rqstp, \
425 struct svc_fh *fhp, \
426 u64 offset, \
427 u32 len), \
428 TP_ARGS(rqstp, fhp, offset, len))
429
430DEFINE_NFSD_IO_EVENT(read_start);
431DEFINE_NFSD_IO_EVENT(read_splice);
432DEFINE_NFSD_IO_EVENT(read_vector);
433DEFINE_NFSD_IO_EVENT(read_io_done);
434DEFINE_NFSD_IO_EVENT(read_done);
435DEFINE_NFSD_IO_EVENT(write_start);
436DEFINE_NFSD_IO_EVENT(write_opened);
437DEFINE_NFSD_IO_EVENT(write_io_done);
438DEFINE_NFSD_IO_EVENT(write_done);
439
440DECLARE_EVENT_CLASS(nfsd_err_class,
441 TP_PROTO(struct svc_rqst *rqstp,
442 struct svc_fh *fhp,
443 loff_t offset,
444 int status),
445 TP_ARGS(rqstp, fhp, offset, status),
446 TP_STRUCT__entry(
447 __field(u32, xid)
448 __field(u32, fh_hash)
449 __field(loff_t, offset)
450 __field(int, status)
451 ),
452 TP_fast_assign(
453 __entry->xid = be32_to_cpu(rqstp->rq_xid);
454 __entry->fh_hash = knfsd_fh_hash(&fhp->fh_handle);
455 __entry->offset = offset;
456 __entry->status = status;
457 ),
458 TP_printk("xid=0x%08x fh_hash=0x%08x offset=%lld status=%d",
459 __entry->xid, __entry->fh_hash,
460 __entry->offset, __entry->status)
461)
462
463#define DEFINE_NFSD_ERR_EVENT(name) \
464DEFINE_EVENT(nfsd_err_class, nfsd_##name, \
465 TP_PROTO(struct svc_rqst *rqstp, \
466 struct svc_fh *fhp, \
467 loff_t offset, \
468 int len), \
469 TP_ARGS(rqstp, fhp, offset, len))
470
471DEFINE_NFSD_ERR_EVENT(read_err);
472DEFINE_NFSD_ERR_EVENT(write_err);
473
474TRACE_EVENT(nfsd_dirent,
475 TP_PROTO(struct svc_fh *fhp,
476 u64 ino,
477 const char *name,
478 int namlen),
479 TP_ARGS(fhp, ino, name, namlen),
480 TP_STRUCT__entry(
481 __field(u32, fh_hash)
482 __field(u64, ino)
483 __string_len(name, name, namlen)
484 ),
485 TP_fast_assign(
486 __entry->fh_hash = fhp ? knfsd_fh_hash(&fhp->fh_handle) : 0;
487 __entry->ino = ino;
488 __assign_str(name, name);
489 ),
490 TP_printk("fh_hash=0x%08x ino=%llu name=%s",
491 __entry->fh_hash, __entry->ino, __get_str(name)
492 )
493)
494
495DECLARE_EVENT_CLASS(nfsd_copy_err_class,
496 TP_PROTO(struct svc_rqst *rqstp,
497 struct svc_fh *src_fhp,
498 loff_t src_offset,
499 struct svc_fh *dst_fhp,
500 loff_t dst_offset,
501 u64 count,
502 int status),
503 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
504 TP_STRUCT__entry(
505 __field(u32, xid)
506 __field(u32, src_fh_hash)
507 __field(loff_t, src_offset)
508 __field(u32, dst_fh_hash)
509 __field(loff_t, dst_offset)
510 __field(u64, count)
511 __field(int, status)
512 ),
513 TP_fast_assign(
514 __entry->xid = be32_to_cpu(rqstp->rq_xid);
515 __entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
516 __entry->src_offset = src_offset;
517 __entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
518 __entry->dst_offset = dst_offset;
519 __entry->count = count;
520 __entry->status = status;
521 ),
522 TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
523 "dst_fh_hash=0x%08x dst_offset=%lld "
524 "count=%llu status=%d",
525 __entry->xid, __entry->src_fh_hash, __entry->src_offset,
526 __entry->dst_fh_hash, __entry->dst_offset,
527 (unsigned long long)__entry->count,
528 __entry->status)
529)
530
531#define DEFINE_NFSD_COPY_ERR_EVENT(name) \
532DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \
533 TP_PROTO(struct svc_rqst *rqstp, \
534 struct svc_fh *src_fhp, \
535 loff_t src_offset, \
536 struct svc_fh *dst_fhp, \
537 loff_t dst_offset, \
538 u64 count, \
539 int status), \
540 TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
541 count, status))
542
543DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
544
545#include "state.h"
546#include "filecache.h"
547#include "vfs.h"
548
549TRACE_EVENT(nfsd_delegret_wakeup,
550 TP_PROTO(
551 const struct svc_rqst *rqstp,
552 const struct inode *inode,
553 long timeo
554 ),
555 TP_ARGS(rqstp, inode, timeo),
556 TP_STRUCT__entry(
557 __field(u32, xid)
558 __field(const void *, inode)
559 __field(long, timeo)
560 ),
561 TP_fast_assign(
562 __entry->xid = be32_to_cpu(rqstp->rq_xid);
563 __entry->inode = inode;
564 __entry->timeo = timeo;
565 ),
566 TP_printk("xid=0x%08x inode=%p%s",
567 __entry->xid, __entry->inode,
568 __entry->timeo == 0 ? " (timed out)" : ""
569 )
570);
571
572DECLARE_EVENT_CLASS(nfsd_stateid_class,
573 TP_PROTO(stateid_t *stp),
574 TP_ARGS(stp),
575 TP_STRUCT__entry(
576 __field(u32, cl_boot)
577 __field(u32, cl_id)
578 __field(u32, si_id)
579 __field(u32, si_generation)
580 ),
581 TP_fast_assign(
582 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
583 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
584 __entry->si_id = stp->si_opaque.so_id;
585 __entry->si_generation = stp->si_generation;
586 ),
587 TP_printk("client %08x:%08x stateid %08x:%08x",
588 __entry->cl_boot,
589 __entry->cl_id,
590 __entry->si_id,
591 __entry->si_generation)
592)
593
594#define DEFINE_STATEID_EVENT(name) \
595DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
596 TP_PROTO(stateid_t *stp), \
597 TP_ARGS(stp))
598
599DEFINE_STATEID_EVENT(layoutstate_alloc);
600DEFINE_STATEID_EVENT(layoutstate_unhash);
601DEFINE_STATEID_EVENT(layoutstate_free);
602DEFINE_STATEID_EVENT(layout_get_lookup_fail);
603DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
604DEFINE_STATEID_EVENT(layout_return_lookup_fail);
605DEFINE_STATEID_EVENT(layout_recall);
606DEFINE_STATEID_EVENT(layout_recall_done);
607DEFINE_STATEID_EVENT(layout_recall_fail);
608DEFINE_STATEID_EVENT(layout_recall_release);
609
610DEFINE_STATEID_EVENT(open);
611DEFINE_STATEID_EVENT(deleg_read);
612DEFINE_STATEID_EVENT(deleg_write);
613DEFINE_STATEID_EVENT(deleg_return);
614DEFINE_STATEID_EVENT(deleg_recall);
615
616DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
617 TP_PROTO(u32 seqid, const stateid_t *stp),
618 TP_ARGS(seqid, stp),
619 TP_STRUCT__entry(
620 __field(u32, seqid)
621 __field(u32, cl_boot)
622 __field(u32, cl_id)
623 __field(u32, si_id)
624 __field(u32, si_generation)
625 ),
626 TP_fast_assign(
627 __entry->seqid = seqid;
628 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
629 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
630 __entry->si_id = stp->si_opaque.so_id;
631 __entry->si_generation = stp->si_generation;
632 ),
633 TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
634 __entry->seqid, __entry->cl_boot, __entry->cl_id,
635 __entry->si_id, __entry->si_generation)
636)
637
638#define DEFINE_STATESEQID_EVENT(name) \
639DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
640 TP_PROTO(u32 seqid, const stateid_t *stp), \
641 TP_ARGS(seqid, stp))
642
643DEFINE_STATESEQID_EVENT(preprocess);
644DEFINE_STATESEQID_EVENT(open_confirm);
645
646#define show_stid_type(x) \
647 __print_flags(x, "|", \
648 { SC_TYPE_OPEN, "OPEN" }, \
649 { SC_TYPE_LOCK, "LOCK" }, \
650 { SC_TYPE_DELEG, "DELEG" }, \
651 { SC_TYPE_LAYOUT, "LAYOUT" })
652
653#define show_stid_status(x) \
654 __print_flags(x, "|", \
655 { SC_STATUS_CLOSED, "CLOSED" }, \
656 { SC_STATUS_REVOKED, "REVOKED" }, \
657 { SC_STATUS_ADMIN_REVOKED, "ADMIN_REVOKED" })
658
659DECLARE_EVENT_CLASS(nfsd_stid_class,
660 TP_PROTO(
661 const struct nfs4_stid *stid
662 ),
663 TP_ARGS(stid),
664 TP_STRUCT__entry(
665 __field(unsigned long, sc_type)
666 __field(unsigned long, sc_status)
667 __field(int, sc_count)
668 __field(u32, cl_boot)
669 __field(u32, cl_id)
670 __field(u32, si_id)
671 __field(u32, si_generation)
672 ),
673 TP_fast_assign(
674 const stateid_t *stp = &stid->sc_stateid;
675
676 __entry->sc_type = stid->sc_type;
677 __entry->sc_status = stid->sc_status;
678 __entry->sc_count = refcount_read(&stid->sc_count);
679 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
680 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
681 __entry->si_id = stp->si_opaque.so_id;
682 __entry->si_generation = stp->si_generation;
683 ),
684 TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s state=%s",
685 __entry->cl_boot, __entry->cl_id,
686 __entry->si_id, __entry->si_generation,
687 __entry->sc_count, show_stid_type(__entry->sc_type),
688 show_stid_status(__entry->sc_status)
689 )
690);
691
692#define DEFINE_STID_EVENT(name) \
693DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name, \
694 TP_PROTO(const struct nfs4_stid *stid), \
695 TP_ARGS(stid))
696
697DEFINE_STID_EVENT(revoke);
698
699TRACE_EVENT(nfsd_stateowner_replay,
700 TP_PROTO(
701 u32 opnum,
702 const struct nfs4_replay *rp
703 ),
704 TP_ARGS(opnum, rp),
705 TP_STRUCT__entry(
706 __field(unsigned long, status)
707 __field(u32, opnum)
708 ),
709 TP_fast_assign(
710 __entry->status = be32_to_cpu(rp->rp_status);
711 __entry->opnum = opnum;
712 ),
713 TP_printk("opnum=%u status=%lu",
714 __entry->opnum, __entry->status)
715);
716
717TRACE_EVENT_CONDITION(nfsd_seq4_status,
718 TP_PROTO(
719 const struct svc_rqst *rqstp,
720 const struct nfsd4_sequence *sequence
721 ),
722 TP_ARGS(rqstp, sequence),
723 TP_CONDITION(sequence->status_flags),
724 TP_STRUCT__entry(
725 __field(unsigned int, netns_ino)
726 __field(u32, xid)
727 __field(u32, cl_boot)
728 __field(u32, cl_id)
729 __field(u32, seqno)
730 __field(u32, reserved)
731 __field(unsigned long, status_flags)
732 ),
733 TP_fast_assign(
734 const struct nfsd4_sessionid *sid =
735 (struct nfsd4_sessionid *)&sequence->sessionid;
736
737 __entry->netns_ino = SVC_NET(rqstp)->ns.inum;
738 __entry->xid = be32_to_cpu(rqstp->rq_xid);
739 __entry->cl_boot = sid->clientid.cl_boot;
740 __entry->cl_id = sid->clientid.cl_id;
741 __entry->seqno = sid->sequence;
742 __entry->reserved = sid->reserved;
743 __entry->status_flags = sequence->status_flags;
744 ),
745 TP_printk("xid=0x%08x sessionid=%08x:%08x:%08x:%08x status_flags=%s",
746 __entry->xid, __entry->cl_boot, __entry->cl_id,
747 __entry->seqno, __entry->reserved,
748 show_nfs4_seq4_status(__entry->status_flags)
749 )
750);
751
752DECLARE_EVENT_CLASS(nfsd_clientid_class,
753 TP_PROTO(const clientid_t *clid),
754 TP_ARGS(clid),
755 TP_STRUCT__entry(
756 __field(u32, cl_boot)
757 __field(u32, cl_id)
758 ),
759 TP_fast_assign(
760 __entry->cl_boot = clid->cl_boot;
761 __entry->cl_id = clid->cl_id;
762 ),
763 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
764)
765
766#define DEFINE_CLIENTID_EVENT(name) \
767DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
768 TP_PROTO(const clientid_t *clid), \
769 TP_ARGS(clid))
770
771DEFINE_CLIENTID_EVENT(expire_unconf);
772DEFINE_CLIENTID_EVENT(reclaim_complete);
773DEFINE_CLIENTID_EVENT(confirmed);
774DEFINE_CLIENTID_EVENT(destroyed);
775DEFINE_CLIENTID_EVENT(admin_expired);
776DEFINE_CLIENTID_EVENT(replaced);
777DEFINE_CLIENTID_EVENT(purged);
778DEFINE_CLIENTID_EVENT(renew);
779DEFINE_CLIENTID_EVENT(stale);
780
781DECLARE_EVENT_CLASS(nfsd_net_class,
782 TP_PROTO(const struct nfsd_net *nn),
783 TP_ARGS(nn),
784 TP_STRUCT__entry(
785 __field(unsigned long long, boot_time)
786 ),
787 TP_fast_assign(
788 __entry->boot_time = nn->boot_time;
789 ),
790 TP_printk("boot_time=%16llx", __entry->boot_time)
791)
792
793#define DEFINE_NET_EVENT(name) \
794DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
795 TP_PROTO(const struct nfsd_net *nn), \
796 TP_ARGS(nn))
797
798DEFINE_NET_EVENT(grace_start);
799DEFINE_NET_EVENT(grace_complete);
800
801TRACE_EVENT(nfsd_writeverf_reset,
802 TP_PROTO(
803 const struct nfsd_net *nn,
804 const struct svc_rqst *rqstp,
805 int error
806 ),
807 TP_ARGS(nn, rqstp, error),
808 TP_STRUCT__entry(
809 __field(unsigned long long, boot_time)
810 __field(u32, xid)
811 __field(int, error)
812 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
813 ),
814 TP_fast_assign(
815 __entry->boot_time = nn->boot_time;
816 __entry->xid = be32_to_cpu(rqstp->rq_xid);
817 __entry->error = error;
818
819 /* avoid seqlock inside TP_fast_assign */
820 memcpy(__entry->verifier, nn->writeverf,
821 NFS4_VERIFIER_SIZE);
822 ),
823 TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
824 __entry->boot_time, __entry->xid, __entry->error,
825 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
826 )
827);
828
829TRACE_EVENT(nfsd_clid_cred_mismatch,
830 TP_PROTO(
831 const struct nfs4_client *clp,
832 const struct svc_rqst *rqstp
833 ),
834 TP_ARGS(clp, rqstp),
835 TP_STRUCT__entry(
836 __field(u32, cl_boot)
837 __field(u32, cl_id)
838 __field(unsigned long, cl_flavor)
839 __field(unsigned long, new_flavor)
840 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
841 ),
842 TP_fast_assign(
843 __entry->cl_boot = clp->cl_clientid.cl_boot;
844 __entry->cl_id = clp->cl_clientid.cl_id;
845 __entry->cl_flavor = clp->cl_cred.cr_flavor;
846 __entry->new_flavor = rqstp->rq_cred.cr_flavor;
847 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
848 rqstp->rq_xprt->xpt_remotelen);
849 ),
850 TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
851 __entry->cl_boot, __entry->cl_id,
852 show_nfsd_authflavor(__entry->cl_flavor),
853 show_nfsd_authflavor(__entry->new_flavor),
854 __get_sockaddr(addr)
855 )
856)
857
858TRACE_EVENT(nfsd_clid_verf_mismatch,
859 TP_PROTO(
860 const struct nfs4_client *clp,
861 const struct svc_rqst *rqstp,
862 const nfs4_verifier *verf
863 ),
864 TP_ARGS(clp, rqstp, verf),
865 TP_STRUCT__entry(
866 __field(u32, cl_boot)
867 __field(u32, cl_id)
868 __array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
869 __array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
870 __sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
871 ),
872 TP_fast_assign(
873 __entry->cl_boot = clp->cl_clientid.cl_boot;
874 __entry->cl_id = clp->cl_clientid.cl_id;
875 memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
876 NFS4_VERIFIER_SIZE);
877 memcpy(__entry->new_verifier, (void *)verf,
878 NFS4_VERIFIER_SIZE);
879 __assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
880 rqstp->rq_xprt->xpt_remotelen);
881 ),
882 TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
883 __entry->cl_boot, __entry->cl_id,
884 __print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
885 __print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
886 __get_sockaddr(addr)
887 )
888);
889
890DECLARE_EVENT_CLASS(nfsd_clid_class,
891 TP_PROTO(const struct nfs4_client *clp),
892 TP_ARGS(clp),
893 TP_STRUCT__entry(
894 __field(u32, cl_boot)
895 __field(u32, cl_id)
896 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
897 __field(unsigned long, flavor)
898 __array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
899 __string_len(name, clp->cl_name.data, clp->cl_name.len)
900 ),
901 TP_fast_assign(
902 __entry->cl_boot = clp->cl_clientid.cl_boot;
903 __entry->cl_id = clp->cl_clientid.cl_id;
904 memcpy(__entry->addr, &clp->cl_addr,
905 sizeof(struct sockaddr_in6));
906 __entry->flavor = clp->cl_cred.cr_flavor;
907 memcpy(__entry->verifier, (void *)&clp->cl_verifier,
908 NFS4_VERIFIER_SIZE);
909 __assign_str(name, clp->cl_name.data);
910 ),
911 TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
912 __entry->addr, __get_str(name),
913 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
914 show_nfsd_authflavor(__entry->flavor),
915 __entry->cl_boot, __entry->cl_id)
916);
917
918#define DEFINE_CLID_EVENT(name) \
919DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
920 TP_PROTO(const struct nfs4_client *clp), \
921 TP_ARGS(clp))
922
923DEFINE_CLID_EVENT(fresh);
924DEFINE_CLID_EVENT(confirmed_r);
925
926/*
927 * from fs/nfsd/filecache.h
928 */
929#define show_nf_flags(val) \
930 __print_flags(val, "|", \
931 { 1 << NFSD_FILE_HASHED, "HASHED" }, \
932 { 1 << NFSD_FILE_PENDING, "PENDING" }, \
933 { 1 << NFSD_FILE_REFERENCED, "REFERENCED" }, \
934 { 1 << NFSD_FILE_GC, "GC" })
935
936DECLARE_EVENT_CLASS(nfsd_file_class,
937 TP_PROTO(struct nfsd_file *nf),
938 TP_ARGS(nf),
939 TP_STRUCT__entry(
940 __field(void *, nf_inode)
941 __field(int, nf_ref)
942 __field(unsigned long, nf_flags)
943 __field(unsigned char, nf_may)
944 __field(struct file *, nf_file)
945 ),
946 TP_fast_assign(
947 __entry->nf_inode = nf->nf_inode;
948 __entry->nf_ref = refcount_read(&nf->nf_ref);
949 __entry->nf_flags = nf->nf_flags;
950 __entry->nf_may = nf->nf_may;
951 __entry->nf_file = nf->nf_file;
952 ),
953 TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
954 __entry->nf_inode,
955 __entry->nf_ref,
956 show_nf_flags(__entry->nf_flags),
957 show_nfsd_may_flags(__entry->nf_may),
958 __entry->nf_file)
959)
960
961#define DEFINE_NFSD_FILE_EVENT(name) \
962DEFINE_EVENT(nfsd_file_class, name, \
963 TP_PROTO(struct nfsd_file *nf), \
964 TP_ARGS(nf))
965
966DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
967DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
968DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
969DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
970DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue);
971
972TRACE_EVENT(nfsd_file_alloc,
973 TP_PROTO(
974 const struct nfsd_file *nf
975 ),
976 TP_ARGS(nf),
977 TP_STRUCT__entry(
978 __field(const void *, nf_inode)
979 __field(unsigned long, nf_flags)
980 __field(unsigned long, nf_may)
981 __field(unsigned int, nf_ref)
982 ),
983 TP_fast_assign(
984 __entry->nf_inode = nf->nf_inode;
985 __entry->nf_flags = nf->nf_flags;
986 __entry->nf_ref = refcount_read(&nf->nf_ref);
987 __entry->nf_may = nf->nf_may;
988 ),
989 TP_printk("inode=%p ref=%u flags=%s may=%s",
990 __entry->nf_inode, __entry->nf_ref,
991 show_nf_flags(__entry->nf_flags),
992 show_nfsd_may_flags(__entry->nf_may)
993 )
994);
995
996TRACE_EVENT(nfsd_file_acquire,
997 TP_PROTO(
998 const struct svc_rqst *rqstp,
999 const struct inode *inode,
1000 unsigned int may_flags,
1001 const struct nfsd_file *nf,
1002 __be32 status
1003 ),
1004
1005 TP_ARGS(rqstp, inode, may_flags, nf, status),
1006
1007 TP_STRUCT__entry(
1008 __field(u32, xid)
1009 __field(const void *, inode)
1010 __field(unsigned long, may_flags)
1011 __field(unsigned int, nf_ref)
1012 __field(unsigned long, nf_flags)
1013 __field(unsigned long, nf_may)
1014 __field(const void *, nf_file)
1015 __field(u32, status)
1016 ),
1017
1018 TP_fast_assign(
1019 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1020 __entry->inode = inode;
1021 __entry->may_flags = may_flags;
1022 __entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
1023 __entry->nf_flags = nf ? nf->nf_flags : 0;
1024 __entry->nf_may = nf ? nf->nf_may : 0;
1025 __entry->nf_file = nf ? nf->nf_file : NULL;
1026 __entry->status = be32_to_cpu(status);
1027 ),
1028
1029 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
1030 __entry->xid, __entry->inode,
1031 show_nfsd_may_flags(__entry->may_flags),
1032 __entry->nf_ref, show_nf_flags(__entry->nf_flags),
1033 show_nfsd_may_flags(__entry->nf_may),
1034 __entry->nf_file, __entry->status
1035 )
1036);
1037
1038TRACE_EVENT(nfsd_file_insert_err,
1039 TP_PROTO(
1040 const struct svc_rqst *rqstp,
1041 const struct inode *inode,
1042 unsigned int may_flags,
1043 long error
1044 ),
1045 TP_ARGS(rqstp, inode, may_flags, error),
1046 TP_STRUCT__entry(
1047 __field(u32, xid)
1048 __field(const void *, inode)
1049 __field(unsigned long, may_flags)
1050 __field(long, error)
1051 ),
1052 TP_fast_assign(
1053 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1054 __entry->inode = inode;
1055 __entry->may_flags = may_flags;
1056 __entry->error = error;
1057 ),
1058 TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1059 __entry->xid, __entry->inode,
1060 show_nfsd_may_flags(__entry->may_flags),
1061 __entry->error
1062 )
1063);
1064
1065TRACE_EVENT(nfsd_file_cons_err,
1066 TP_PROTO(
1067 const struct svc_rqst *rqstp,
1068 const struct inode *inode,
1069 unsigned int may_flags,
1070 const struct nfsd_file *nf
1071 ),
1072 TP_ARGS(rqstp, inode, may_flags, nf),
1073 TP_STRUCT__entry(
1074 __field(u32, xid)
1075 __field(const void *, inode)
1076 __field(unsigned long, may_flags)
1077 __field(unsigned int, nf_ref)
1078 __field(unsigned long, nf_flags)
1079 __field(unsigned long, nf_may)
1080 __field(const void *, nf_file)
1081 ),
1082 TP_fast_assign(
1083 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1084 __entry->inode = inode;
1085 __entry->may_flags = may_flags;
1086 __entry->nf_ref = refcount_read(&nf->nf_ref);
1087 __entry->nf_flags = nf->nf_flags;
1088 __entry->nf_may = nf->nf_may;
1089 __entry->nf_file = nf->nf_file;
1090 ),
1091 TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1092 __entry->xid, __entry->inode,
1093 show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1094 show_nf_flags(__entry->nf_flags),
1095 show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1096 )
1097);
1098
1099DECLARE_EVENT_CLASS(nfsd_file_open_class,
1100 TP_PROTO(const struct nfsd_file *nf, __be32 status),
1101 TP_ARGS(nf, status),
1102 TP_STRUCT__entry(
1103 __field(void *, nf_inode) /* cannot be dereferenced */
1104 __field(int, nf_ref)
1105 __field(unsigned long, nf_flags)
1106 __field(unsigned long, nf_may)
1107 __field(void *, nf_file) /* cannot be dereferenced */
1108 ),
1109 TP_fast_assign(
1110 __entry->nf_inode = nf->nf_inode;
1111 __entry->nf_ref = refcount_read(&nf->nf_ref);
1112 __entry->nf_flags = nf->nf_flags;
1113 __entry->nf_may = nf->nf_may;
1114 __entry->nf_file = nf->nf_file;
1115 ),
1116 TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1117 __entry->nf_inode,
1118 __entry->nf_ref,
1119 show_nf_flags(__entry->nf_flags),
1120 show_nfsd_may_flags(__entry->nf_may),
1121 __entry->nf_file)
1122)
1123
1124#define DEFINE_NFSD_FILE_OPEN_EVENT(name) \
1125DEFINE_EVENT(nfsd_file_open_class, name, \
1126 TP_PROTO( \
1127 const struct nfsd_file *nf, \
1128 __be32 status \
1129 ), \
1130 TP_ARGS(nf, status))
1131
1132DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1133DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1134
1135TRACE_EVENT(nfsd_file_is_cached,
1136 TP_PROTO(
1137 const struct inode *inode,
1138 int found
1139 ),
1140 TP_ARGS(inode, found),
1141 TP_STRUCT__entry(
1142 __field(const struct inode *, inode)
1143 __field(int, found)
1144 ),
1145 TP_fast_assign(
1146 __entry->inode = inode;
1147 __entry->found = found;
1148 ),
1149 TP_printk("inode=%p is %scached",
1150 __entry->inode,
1151 __entry->found ? "" : "not "
1152 )
1153);
1154
1155TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1156 TP_PROTO(struct inode *inode, u32 mask),
1157 TP_ARGS(inode, mask),
1158 TP_STRUCT__entry(
1159 __field(struct inode *, inode)
1160 __field(unsigned int, nlink)
1161 __field(umode_t, mode)
1162 __field(u32, mask)
1163 ),
1164 TP_fast_assign(
1165 __entry->inode = inode;
1166 __entry->nlink = inode->i_nlink;
1167 __entry->mode = inode->i_mode;
1168 __entry->mask = mask;
1169 ),
1170 TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1171 __entry->nlink, __entry->mode, __entry->mask)
1172);
1173
1174DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1175 TP_PROTO(
1176 const struct nfsd_file *nf
1177 ),
1178 TP_ARGS(nf),
1179 TP_STRUCT__entry(
1180 __field(void *, nf_inode)
1181 __field(void *, nf_file)
1182 __field(int, nf_ref)
1183 __field(unsigned long, nf_flags)
1184 ),
1185 TP_fast_assign(
1186 __entry->nf_inode = nf->nf_inode;
1187 __entry->nf_file = nf->nf_file;
1188 __entry->nf_ref = refcount_read(&nf->nf_ref);
1189 __entry->nf_flags = nf->nf_flags;
1190 ),
1191 TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1192 __entry->nf_inode, __entry->nf_ref,
1193 show_nf_flags(__entry->nf_flags),
1194 __entry->nf_file
1195 )
1196);
1197
1198#define DEFINE_NFSD_FILE_GC_EVENT(name) \
1199DEFINE_EVENT(nfsd_file_gc_class, name, \
1200 TP_PROTO( \
1201 const struct nfsd_file *nf \
1202 ), \
1203 TP_ARGS(nf))
1204
1205DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1206DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1207DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1208DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1209DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1210DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1211DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1212DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1213
1214DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1215 TP_PROTO(
1216 unsigned long removed,
1217 unsigned long remaining
1218 ),
1219 TP_ARGS(removed, remaining),
1220 TP_STRUCT__entry(
1221 __field(unsigned long, removed)
1222 __field(unsigned long, remaining)
1223 ),
1224 TP_fast_assign(
1225 __entry->removed = removed;
1226 __entry->remaining = remaining;
1227 ),
1228 TP_printk("%lu entries removed, %lu remaining",
1229 __entry->removed, __entry->remaining)
1230);
1231
1232#define DEFINE_NFSD_FILE_LRUWALK_EVENT(name) \
1233DEFINE_EVENT(nfsd_file_lruwalk_class, name, \
1234 TP_PROTO( \
1235 unsigned long removed, \
1236 unsigned long remaining \
1237 ), \
1238 TP_ARGS(removed, remaining))
1239
1240DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1241DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1242
1243TRACE_EVENT(nfsd_file_close,
1244 TP_PROTO(
1245 const struct inode *inode
1246 ),
1247 TP_ARGS(inode),
1248 TP_STRUCT__entry(
1249 __field(const void *, inode)
1250 ),
1251 TP_fast_assign(
1252 __entry->inode = inode;
1253 ),
1254 TP_printk("inode=%p",
1255 __entry->inode
1256 )
1257);
1258
1259#include "cache.h"
1260
1261TRACE_DEFINE_ENUM(RC_DROPIT);
1262TRACE_DEFINE_ENUM(RC_REPLY);
1263TRACE_DEFINE_ENUM(RC_DOIT);
1264
1265#define show_drc_retval(x) \
1266 __print_symbolic(x, \
1267 { RC_DROPIT, "DROPIT" }, \
1268 { RC_REPLY, "REPLY" }, \
1269 { RC_DOIT, "DOIT" })
1270
1271TRACE_EVENT(nfsd_drc_found,
1272 TP_PROTO(
1273 const struct nfsd_net *nn,
1274 const struct svc_rqst *rqstp,
1275 int result
1276 ),
1277 TP_ARGS(nn, rqstp, result),
1278 TP_STRUCT__entry(
1279 __field(unsigned long long, boot_time)
1280 __field(unsigned long, result)
1281 __field(u32, xid)
1282 ),
1283 TP_fast_assign(
1284 __entry->boot_time = nn->boot_time;
1285 __entry->result = result;
1286 __entry->xid = be32_to_cpu(rqstp->rq_xid);
1287 ),
1288 TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1289 __entry->boot_time, __entry->xid,
1290 show_drc_retval(__entry->result))
1291
1292);
1293
1294TRACE_EVENT(nfsd_drc_mismatch,
1295 TP_PROTO(
1296 const struct nfsd_net *nn,
1297 const struct nfsd_cacherep *key,
1298 const struct nfsd_cacherep *rp
1299 ),
1300 TP_ARGS(nn, key, rp),
1301 TP_STRUCT__entry(
1302 __field(unsigned long long, boot_time)
1303 __field(u32, xid)
1304 __field(u32, cached)
1305 __field(u32, ingress)
1306 ),
1307 TP_fast_assign(
1308 __entry->boot_time = nn->boot_time;
1309 __entry->xid = be32_to_cpu(key->c_key.k_xid);
1310 __entry->cached = (__force u32)key->c_key.k_csum;
1311 __entry->ingress = (__force u32)rp->c_key.k_csum;
1312 ),
1313 TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1314 __entry->boot_time, __entry->xid, __entry->cached,
1315 __entry->ingress)
1316);
1317
1318TRACE_EVENT(nfsd_cb_args,
1319 TP_PROTO(
1320 const struct nfs4_client *clp,
1321 const struct nfs4_cb_conn *conn
1322 ),
1323 TP_ARGS(clp, conn),
1324 TP_STRUCT__entry(
1325 __field(u32, cl_boot)
1326 __field(u32, cl_id)
1327 __field(u32, prog)
1328 __field(u32, ident)
1329 __sockaddr(addr, conn->cb_addrlen)
1330 ),
1331 TP_fast_assign(
1332 __entry->cl_boot = clp->cl_clientid.cl_boot;
1333 __entry->cl_id = clp->cl_clientid.cl_id;
1334 __entry->prog = conn->cb_prog;
1335 __entry->ident = conn->cb_ident;
1336 __assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1337 ),
1338 TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1339 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1340 __entry->prog, __entry->ident)
1341);
1342
1343TRACE_EVENT(nfsd_cb_nodelegs,
1344 TP_PROTO(const struct nfs4_client *clp),
1345 TP_ARGS(clp),
1346 TP_STRUCT__entry(
1347 __field(u32, cl_boot)
1348 __field(u32, cl_id)
1349 ),
1350 TP_fast_assign(
1351 __entry->cl_boot = clp->cl_clientid.cl_boot;
1352 __entry->cl_id = clp->cl_clientid.cl_id;
1353 ),
1354 TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1355)
1356
1357#define show_cb_state(val) \
1358 __print_symbolic(val, \
1359 { NFSD4_CB_UP, "UP" }, \
1360 { NFSD4_CB_UNKNOWN, "UNKNOWN" }, \
1361 { NFSD4_CB_DOWN, "DOWN" }, \
1362 { NFSD4_CB_FAULT, "FAULT"})
1363
1364DECLARE_EVENT_CLASS(nfsd_cb_class,
1365 TP_PROTO(const struct nfs4_client *clp),
1366 TP_ARGS(clp),
1367 TP_STRUCT__entry(
1368 __field(unsigned long, state)
1369 __field(u32, cl_boot)
1370 __field(u32, cl_id)
1371 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1372 ),
1373 TP_fast_assign(
1374 __entry->state = clp->cl_cb_state;
1375 __entry->cl_boot = clp->cl_clientid.cl_boot;
1376 __entry->cl_id = clp->cl_clientid.cl_id;
1377 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1378 clp->cl_cb_conn.cb_addrlen)
1379 ),
1380 TP_printk("addr=%pISpc client %08x:%08x state=%s",
1381 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1382 show_cb_state(__entry->state))
1383);
1384
1385#define DEFINE_NFSD_CB_EVENT(name) \
1386DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name, \
1387 TP_PROTO(const struct nfs4_client *clp), \
1388 TP_ARGS(clp))
1389
1390DEFINE_NFSD_CB_EVENT(start);
1391DEFINE_NFSD_CB_EVENT(new_state);
1392DEFINE_NFSD_CB_EVENT(probe);
1393DEFINE_NFSD_CB_EVENT(lost);
1394DEFINE_NFSD_CB_EVENT(shutdown);
1395
1396TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1397TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1398TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1399TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1400TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1401TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1402
1403#define show_nfsd_authflavor(val) \
1404 __print_symbolic(val, \
1405 { RPC_AUTH_NULL, "none" }, \
1406 { RPC_AUTH_UNIX, "sys" }, \
1407 { RPC_AUTH_GSS, "gss" }, \
1408 { RPC_AUTH_GSS_KRB5, "krb5" }, \
1409 { RPC_AUTH_GSS_KRB5I, "krb5i" }, \
1410 { RPC_AUTH_GSS_KRB5P, "krb5p" })
1411
1412TRACE_EVENT(nfsd_cb_setup,
1413 TP_PROTO(const struct nfs4_client *clp,
1414 const char *netid,
1415 rpc_authflavor_t authflavor
1416 ),
1417 TP_ARGS(clp, netid, authflavor),
1418 TP_STRUCT__entry(
1419 __field(u32, cl_boot)
1420 __field(u32, cl_id)
1421 __field(unsigned long, authflavor)
1422 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1423 __string(netid, netid)
1424 ),
1425 TP_fast_assign(
1426 __entry->cl_boot = clp->cl_clientid.cl_boot;
1427 __entry->cl_id = clp->cl_clientid.cl_id;
1428 __assign_str(netid, netid);
1429 __entry->authflavor = authflavor;
1430 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1431 clp->cl_cb_conn.cb_addrlen)
1432 ),
1433 TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1434 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1435 __get_str(netid), show_nfsd_authflavor(__entry->authflavor))
1436);
1437
1438TRACE_EVENT(nfsd_cb_setup_err,
1439 TP_PROTO(
1440 const struct nfs4_client *clp,
1441 long error
1442 ),
1443 TP_ARGS(clp, error),
1444 TP_STRUCT__entry(
1445 __field(long, error)
1446 __field(u32, cl_boot)
1447 __field(u32, cl_id)
1448 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1449 ),
1450 TP_fast_assign(
1451 __entry->error = error;
1452 __entry->cl_boot = clp->cl_clientid.cl_boot;
1453 __entry->cl_id = clp->cl_clientid.cl_id;
1454 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1455 clp->cl_cb_conn.cb_addrlen)
1456 ),
1457 TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1458 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1459 __entry->error)
1460);
1461
1462DECLARE_EVENT_CLASS(nfsd_cb_lifetime_class,
1463 TP_PROTO(
1464 const struct nfs4_client *clp,
1465 const struct nfsd4_callback *cb
1466 ),
1467 TP_ARGS(clp, cb),
1468 TP_STRUCT__entry(
1469 __field(u32, cl_boot)
1470 __field(u32, cl_id)
1471 __field(const void *, cb)
1472 __field(bool, need_restart)
1473 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1474 ),
1475 TP_fast_assign(
1476 __entry->cl_boot = clp->cl_clientid.cl_boot;
1477 __entry->cl_id = clp->cl_clientid.cl_id;
1478 __entry->cb = cb;
1479 __entry->need_restart = cb->cb_need_restart;
1480 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1481 clp->cl_cb_conn.cb_addrlen)
1482 ),
1483 TP_printk("addr=%pISpc client %08x:%08x cb=%p%s",
1484 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1485 __entry->cb, __entry->need_restart ?
1486 " (need restart)" : " (first try)"
1487 )
1488);
1489
1490#define DEFINE_NFSD_CB_LIFETIME_EVENT(name) \
1491DEFINE_EVENT(nfsd_cb_lifetime_class, nfsd_cb_##name, \
1492 TP_PROTO( \
1493 const struct nfs4_client *clp, \
1494 const struct nfsd4_callback *cb \
1495 ), \
1496 TP_ARGS(clp, cb))
1497
1498DEFINE_NFSD_CB_LIFETIME_EVENT(queue);
1499DEFINE_NFSD_CB_LIFETIME_EVENT(destroy);
1500DEFINE_NFSD_CB_LIFETIME_EVENT(restart);
1501DEFINE_NFSD_CB_LIFETIME_EVENT(bc_update);
1502DEFINE_NFSD_CB_LIFETIME_EVENT(bc_shutdown);
1503
1504TRACE_EVENT(nfsd_cb_seq_status,
1505 TP_PROTO(
1506 const struct rpc_task *task,
1507 const struct nfsd4_callback *cb
1508 ),
1509 TP_ARGS(task, cb),
1510 TP_STRUCT__entry(
1511 __field(unsigned int, task_id)
1512 __field(unsigned int, client_id)
1513 __field(u32, cl_boot)
1514 __field(u32, cl_id)
1515 __field(u32, seqno)
1516 __field(u32, reserved)
1517 __field(int, tk_status)
1518 __field(int, seq_status)
1519 ),
1520 TP_fast_assign(
1521 const struct nfs4_client *clp = cb->cb_clp;
1522 const struct nfsd4_session *session = clp->cl_cb_session;
1523 const struct nfsd4_sessionid *sid =
1524 (struct nfsd4_sessionid *)&session->se_sessionid;
1525
1526 __entry->task_id = task->tk_pid;
1527 __entry->client_id = task->tk_client ?
1528 task->tk_client->cl_clid : -1;
1529 __entry->cl_boot = sid->clientid.cl_boot;
1530 __entry->cl_id = sid->clientid.cl_id;
1531 __entry->seqno = sid->sequence;
1532 __entry->reserved = sid->reserved;
1533 __entry->tk_status = task->tk_status;
1534 __entry->seq_status = cb->cb_seq_status;
1535 ),
1536 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1537 " sessionid=%08x:%08x:%08x:%08x tk_status=%d seq_status=%d\n",
1538 __entry->task_id, __entry->client_id,
1539 __entry->cl_boot, __entry->cl_id,
1540 __entry->seqno, __entry->reserved,
1541 __entry->tk_status, __entry->seq_status
1542 )
1543);
1544
1545TRACE_EVENT(nfsd_cb_free_slot,
1546 TP_PROTO(
1547 const struct rpc_task *task,
1548 const struct nfsd4_callback *cb
1549 ),
1550 TP_ARGS(task, cb),
1551 TP_STRUCT__entry(
1552 __field(unsigned int, task_id)
1553 __field(unsigned int, client_id)
1554 __field(u32, cl_boot)
1555 __field(u32, cl_id)
1556 __field(u32, seqno)
1557 __field(u32, reserved)
1558 __field(u32, slot_seqno)
1559 ),
1560 TP_fast_assign(
1561 const struct nfs4_client *clp = cb->cb_clp;
1562 const struct nfsd4_session *session = clp->cl_cb_session;
1563 const struct nfsd4_sessionid *sid =
1564 (struct nfsd4_sessionid *)&session->se_sessionid;
1565
1566 __entry->task_id = task->tk_pid;
1567 __entry->client_id = task->tk_client ?
1568 task->tk_client->cl_clid : -1;
1569 __entry->cl_boot = sid->clientid.cl_boot;
1570 __entry->cl_id = sid->clientid.cl_id;
1571 __entry->seqno = sid->sequence;
1572 __entry->reserved = sid->reserved;
1573 __entry->slot_seqno = session->se_cb_seq_nr;
1574 ),
1575 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1576 " sessionid=%08x:%08x:%08x:%08x new slot seqno=%u\n",
1577 __entry->task_id, __entry->client_id,
1578 __entry->cl_boot, __entry->cl_id,
1579 __entry->seqno, __entry->reserved,
1580 __entry->slot_seqno
1581 )
1582);
1583
1584TRACE_EVENT_CONDITION(nfsd_cb_recall,
1585 TP_PROTO(
1586 const struct nfs4_stid *stid
1587 ),
1588 TP_ARGS(stid),
1589 TP_CONDITION(stid->sc_client),
1590 TP_STRUCT__entry(
1591 __field(u32, cl_boot)
1592 __field(u32, cl_id)
1593 __field(u32, si_id)
1594 __field(u32, si_generation)
1595 __sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1596 ),
1597 TP_fast_assign(
1598 const stateid_t *stp = &stid->sc_stateid;
1599 const struct nfs4_client *clp = stid->sc_client;
1600
1601 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1602 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1603 __entry->si_id = stp->si_opaque.so_id;
1604 __entry->si_generation = stp->si_generation;
1605 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1606 clp->cl_cb_conn.cb_addrlen)
1607 ),
1608 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1609 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1610 __entry->si_id, __entry->si_generation)
1611);
1612
1613TRACE_EVENT(nfsd_cb_notify_lock,
1614 TP_PROTO(
1615 const struct nfs4_lockowner *lo,
1616 const struct nfsd4_blocked_lock *nbl
1617 ),
1618 TP_ARGS(lo, nbl),
1619 TP_STRUCT__entry(
1620 __field(u32, cl_boot)
1621 __field(u32, cl_id)
1622 __field(u32, fh_hash)
1623 __sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1624 ),
1625 TP_fast_assign(
1626 const struct nfs4_client *clp = lo->lo_owner.so_client;
1627
1628 __entry->cl_boot = clp->cl_clientid.cl_boot;
1629 __entry->cl_id = clp->cl_clientid.cl_id;
1630 __entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1631 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1632 clp->cl_cb_conn.cb_addrlen)
1633 ),
1634 TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1635 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1636 __entry->fh_hash)
1637);
1638
1639TRACE_EVENT(nfsd_cb_offload,
1640 TP_PROTO(
1641 const struct nfs4_client *clp,
1642 const stateid_t *stp,
1643 const struct knfsd_fh *fh,
1644 u64 count,
1645 __be32 status
1646 ),
1647 TP_ARGS(clp, stp, fh, count, status),
1648 TP_STRUCT__entry(
1649 __field(u32, cl_boot)
1650 __field(u32, cl_id)
1651 __field(u32, si_id)
1652 __field(u32, si_generation)
1653 __field(u32, fh_hash)
1654 __field(int, status)
1655 __field(u64, count)
1656 __sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1657 ),
1658 TP_fast_assign(
1659 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1660 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1661 __entry->si_id = stp->si_opaque.so_id;
1662 __entry->si_generation = stp->si_generation;
1663 __entry->fh_hash = knfsd_fh_hash(fh);
1664 __entry->status = be32_to_cpu(status);
1665 __entry->count = count;
1666 __assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1667 clp->cl_cb_conn.cb_addrlen)
1668 ),
1669 TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1670 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1671 __entry->si_id, __entry->si_generation,
1672 __entry->fh_hash, __entry->count, __entry->status)
1673);
1674
1675TRACE_EVENT(nfsd_cb_recall_any,
1676 TP_PROTO(
1677 const struct nfsd4_cb_recall_any *ra
1678 ),
1679 TP_ARGS(ra),
1680 TP_STRUCT__entry(
1681 __field(u32, cl_boot)
1682 __field(u32, cl_id)
1683 __field(u32, keep)
1684 __field(unsigned long, bmval0)
1685 __sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1686 ),
1687 TP_fast_assign(
1688 __entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1689 __entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1690 __entry->keep = ra->ra_keep;
1691 __entry->bmval0 = ra->ra_bmval[0];
1692 __assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1693 ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1694 ),
1695 TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1696 __get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1697 __entry->keep, show_rca_mask(__entry->bmval0)
1698 )
1699);
1700
1701DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1702 TP_PROTO(
1703 const stateid_t *stp,
1704 const struct rpc_task *task
1705 ),
1706 TP_ARGS(stp, task),
1707 TP_STRUCT__entry(
1708 __field(u32, cl_boot)
1709 __field(u32, cl_id)
1710 __field(u32, si_id)
1711 __field(u32, si_generation)
1712 __field(int, status)
1713 ),
1714 TP_fast_assign(
1715 __entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1716 __entry->cl_id = stp->si_opaque.so_clid.cl_id;
1717 __entry->si_id = stp->si_opaque.so_id;
1718 __entry->si_generation = stp->si_generation;
1719 __entry->status = task->tk_status;
1720 ),
1721 TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1722 __entry->cl_boot, __entry->cl_id, __entry->si_id,
1723 __entry->si_generation, __entry->status
1724 )
1725);
1726
1727#define DEFINE_NFSD_CB_DONE_EVENT(name) \
1728DEFINE_EVENT(nfsd_cb_done_class, name, \
1729 TP_PROTO( \
1730 const stateid_t *stp, \
1731 const struct rpc_task *task \
1732 ), \
1733 TP_ARGS(stp, task))
1734
1735DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1736DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1737DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1738DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1739
1740TRACE_EVENT(nfsd_cb_recall_any_done,
1741 TP_PROTO(
1742 const struct nfsd4_callback *cb,
1743 const struct rpc_task *task
1744 ),
1745 TP_ARGS(cb, task),
1746 TP_STRUCT__entry(
1747 __field(u32, cl_boot)
1748 __field(u32, cl_id)
1749 __field(int, status)
1750 ),
1751 TP_fast_assign(
1752 __entry->status = task->tk_status;
1753 __entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1754 __entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1755 ),
1756 TP_printk("client %08x:%08x status=%d",
1757 __entry->cl_boot, __entry->cl_id, __entry->status
1758 )
1759);
1760
1761TRACE_EVENT(nfsd_ctl_unlock_ip,
1762 TP_PROTO(
1763 const struct net *net,
1764 const char *address
1765 ),
1766 TP_ARGS(net, address),
1767 TP_STRUCT__entry(
1768 __field(unsigned int, netns_ino)
1769 __string(address, address)
1770 ),
1771 TP_fast_assign(
1772 __entry->netns_ino = net->ns.inum;
1773 __assign_str(address, address);
1774 ),
1775 TP_printk("address=%s",
1776 __get_str(address)
1777 )
1778);
1779
1780TRACE_EVENT(nfsd_ctl_unlock_fs,
1781 TP_PROTO(
1782 const struct net *net,
1783 const char *path
1784 ),
1785 TP_ARGS(net, path),
1786 TP_STRUCT__entry(
1787 __field(unsigned int, netns_ino)
1788 __string(path, path)
1789 ),
1790 TP_fast_assign(
1791 __entry->netns_ino = net->ns.inum;
1792 __assign_str(path, path);
1793 ),
1794 TP_printk("path=%s",
1795 __get_str(path)
1796 )
1797);
1798
1799TRACE_EVENT(nfsd_ctl_filehandle,
1800 TP_PROTO(
1801 const struct net *net,
1802 const char *domain,
1803 const char *path,
1804 int maxsize
1805 ),
1806 TP_ARGS(net, domain, path, maxsize),
1807 TP_STRUCT__entry(
1808 __field(unsigned int, netns_ino)
1809 __field(int, maxsize)
1810 __string(domain, domain)
1811 __string(path, path)
1812 ),
1813 TP_fast_assign(
1814 __entry->netns_ino = net->ns.inum;
1815 __entry->maxsize = maxsize;
1816 __assign_str(domain, domain);
1817 __assign_str(path, path);
1818 ),
1819 TP_printk("domain=%s path=%s maxsize=%d",
1820 __get_str(domain), __get_str(path), __entry->maxsize
1821 )
1822);
1823
1824TRACE_EVENT(nfsd_ctl_threads,
1825 TP_PROTO(
1826 const struct net *net,
1827 int newthreads
1828 ),
1829 TP_ARGS(net, newthreads),
1830 TP_STRUCT__entry(
1831 __field(unsigned int, netns_ino)
1832 __field(int, newthreads)
1833 ),
1834 TP_fast_assign(
1835 __entry->netns_ino = net->ns.inum;
1836 __entry->newthreads = newthreads;
1837 ),
1838 TP_printk("newthreads=%d",
1839 __entry->newthreads
1840 )
1841);
1842
1843TRACE_EVENT(nfsd_ctl_pool_threads,
1844 TP_PROTO(
1845 const struct net *net,
1846 int pool,
1847 int nrthreads
1848 ),
1849 TP_ARGS(net, pool, nrthreads),
1850 TP_STRUCT__entry(
1851 __field(unsigned int, netns_ino)
1852 __field(int, pool)
1853 __field(int, nrthreads)
1854 ),
1855 TP_fast_assign(
1856 __entry->netns_ino = net->ns.inum;
1857 __entry->pool = pool;
1858 __entry->nrthreads = nrthreads;
1859 ),
1860 TP_printk("pool=%d nrthreads=%d",
1861 __entry->pool, __entry->nrthreads
1862 )
1863);
1864
1865TRACE_EVENT(nfsd_ctl_version,
1866 TP_PROTO(
1867 const struct net *net,
1868 const char *mesg
1869 ),
1870 TP_ARGS(net, mesg),
1871 TP_STRUCT__entry(
1872 __field(unsigned int, netns_ino)
1873 __string(mesg, mesg)
1874 ),
1875 TP_fast_assign(
1876 __entry->netns_ino = net->ns.inum;
1877 __assign_str(mesg, mesg);
1878 ),
1879 TP_printk("%s",
1880 __get_str(mesg)
1881 )
1882);
1883
1884TRACE_EVENT(nfsd_ctl_ports_addfd,
1885 TP_PROTO(
1886 const struct net *net,
1887 int fd
1888 ),
1889 TP_ARGS(net, fd),
1890 TP_STRUCT__entry(
1891 __field(unsigned int, netns_ino)
1892 __field(int, fd)
1893 ),
1894 TP_fast_assign(
1895 __entry->netns_ino = net->ns.inum;
1896 __entry->fd = fd;
1897 ),
1898 TP_printk("fd=%d",
1899 __entry->fd
1900 )
1901);
1902
1903TRACE_EVENT(nfsd_ctl_ports_addxprt,
1904 TP_PROTO(
1905 const struct net *net,
1906 const char *transport,
1907 int port
1908 ),
1909 TP_ARGS(net, transport, port),
1910 TP_STRUCT__entry(
1911 __field(unsigned int, netns_ino)
1912 __field(int, port)
1913 __string(transport, transport)
1914 ),
1915 TP_fast_assign(
1916 __entry->netns_ino = net->ns.inum;
1917 __entry->port = port;
1918 __assign_str(transport, transport);
1919 ),
1920 TP_printk("transport=%s port=%d",
1921 __get_str(transport), __entry->port
1922 )
1923);
1924
1925TRACE_EVENT(nfsd_ctl_maxblksize,
1926 TP_PROTO(
1927 const struct net *net,
1928 int bsize
1929 ),
1930 TP_ARGS(net, bsize),
1931 TP_STRUCT__entry(
1932 __field(unsigned int, netns_ino)
1933 __field(int, bsize)
1934 ),
1935 TP_fast_assign(
1936 __entry->netns_ino = net->ns.inum;
1937 __entry->bsize = bsize;
1938 ),
1939 TP_printk("bsize=%d",
1940 __entry->bsize
1941 )
1942);
1943
1944TRACE_EVENT(nfsd_ctl_maxconn,
1945 TP_PROTO(
1946 const struct net *net,
1947 int maxconn
1948 ),
1949 TP_ARGS(net, maxconn),
1950 TP_STRUCT__entry(
1951 __field(unsigned int, netns_ino)
1952 __field(int, maxconn)
1953 ),
1954 TP_fast_assign(
1955 __entry->netns_ino = net->ns.inum;
1956 __entry->maxconn = maxconn;
1957 ),
1958 TP_printk("maxconn=%d",
1959 __entry->maxconn
1960 )
1961);
1962
1963TRACE_EVENT(nfsd_ctl_time,
1964 TP_PROTO(
1965 const struct net *net,
1966 const char *name,
1967 size_t namelen,
1968 int time
1969 ),
1970 TP_ARGS(net, name, namelen, time),
1971 TP_STRUCT__entry(
1972 __field(unsigned int, netns_ino)
1973 __field(int, time)
1974 __string_len(name, name, namelen)
1975 ),
1976 TP_fast_assign(
1977 __entry->netns_ino = net->ns.inum;
1978 __entry->time = time;
1979 __assign_str(name, name);
1980 ),
1981 TP_printk("file=%s time=%d\n",
1982 __get_str(name), __entry->time
1983 )
1984);
1985
1986TRACE_EVENT(nfsd_ctl_recoverydir,
1987 TP_PROTO(
1988 const struct net *net,
1989 const char *recdir
1990 ),
1991 TP_ARGS(net, recdir),
1992 TP_STRUCT__entry(
1993 __field(unsigned int, netns_ino)
1994 __string(recdir, recdir)
1995 ),
1996 TP_fast_assign(
1997 __entry->netns_ino = net->ns.inum;
1998 __assign_str(recdir, recdir);
1999 ),
2000 TP_printk("recdir=%s",
2001 __get_str(recdir)
2002 )
2003);
2004
2005TRACE_EVENT(nfsd_end_grace,
2006 TP_PROTO(
2007 const struct net *net
2008 ),
2009 TP_ARGS(net),
2010 TP_STRUCT__entry(
2011 __field(unsigned int, netns_ino)
2012 ),
2013 TP_fast_assign(
2014 __entry->netns_ino = net->ns.inum;
2015 ),
2016 TP_printk("nn=%d", __entry->netns_ino
2017 )
2018);
2019
2020DECLARE_EVENT_CLASS(nfsd_copy_class,
2021 TP_PROTO(
2022 const struct nfsd4_copy *copy
2023 ),
2024 TP_ARGS(copy),
2025 TP_STRUCT__entry(
2026 __field(bool, intra)
2027 __field(bool, async)
2028 __field(u32, src_cl_boot)
2029 __field(u32, src_cl_id)
2030 __field(u32, src_so_id)
2031 __field(u32, src_si_generation)
2032 __field(u32, dst_cl_boot)
2033 __field(u32, dst_cl_id)
2034 __field(u32, dst_so_id)
2035 __field(u32, dst_si_generation)
2036 __field(u64, src_cp_pos)
2037 __field(u64, dst_cp_pos)
2038 __field(u64, cp_count)
2039 __sockaddr(addr, sizeof(struct sockaddr_in6))
2040 ),
2041 TP_fast_assign(
2042 const stateid_t *src_stp = ©->cp_src_stateid;
2043 const stateid_t *dst_stp = ©->cp_dst_stateid;
2044
2045 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags);
2046 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags);
2047 __entry->src_cl_boot = src_stp->si_opaque.so_clid.cl_boot;
2048 __entry->src_cl_id = src_stp->si_opaque.so_clid.cl_id;
2049 __entry->src_so_id = src_stp->si_opaque.so_id;
2050 __entry->src_si_generation = src_stp->si_generation;
2051 __entry->dst_cl_boot = dst_stp->si_opaque.so_clid.cl_boot;
2052 __entry->dst_cl_id = dst_stp->si_opaque.so_clid.cl_id;
2053 __entry->dst_so_id = dst_stp->si_opaque.so_id;
2054 __entry->dst_si_generation = dst_stp->si_generation;
2055 __entry->src_cp_pos = copy->cp_src_pos;
2056 __entry->dst_cp_pos = copy->cp_dst_pos;
2057 __entry->cp_count = copy->cp_count;
2058 __assign_sockaddr(addr, ©->cp_clp->cl_addr,
2059 sizeof(struct sockaddr_in6));
2060 ),
2061 TP_printk("client=%pISpc intra=%d async=%d "
2062 "src_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] "
2063 "dst_stateid[si_generation:0x%x cl_boot:0x%x cl_id:0x%x so_id:0x%x] "
2064 "cp_src_pos=%llu cp_dst_pos=%llu cp_count=%llu",
2065 __get_sockaddr(addr), __entry->intra, __entry->async,
2066 __entry->src_si_generation, __entry->src_cl_boot,
2067 __entry->src_cl_id, __entry->src_so_id,
2068 __entry->dst_si_generation, __entry->dst_cl_boot,
2069 __entry->dst_cl_id, __entry->dst_so_id,
2070 __entry->src_cp_pos, __entry->dst_cp_pos, __entry->cp_count
2071 )
2072);
2073
2074#define DEFINE_COPY_EVENT(name) \
2075DEFINE_EVENT(nfsd_copy_class, nfsd_copy_##name, \
2076 TP_PROTO(const struct nfsd4_copy *copy), \
2077 TP_ARGS(copy))
2078
2079DEFINE_COPY_EVENT(inter);
2080DEFINE_COPY_EVENT(intra);
2081DEFINE_COPY_EVENT(do_async);
2082
2083TRACE_EVENT(nfsd_copy_done,
2084 TP_PROTO(
2085 const struct nfsd4_copy *copy,
2086 __be32 status
2087 ),
2088 TP_ARGS(copy, status),
2089 TP_STRUCT__entry(
2090 __field(int, status)
2091 __field(bool, intra)
2092 __field(bool, async)
2093 __sockaddr(addr, sizeof(struct sockaddr_in6))
2094 ),
2095 TP_fast_assign(
2096 __entry->status = be32_to_cpu(status);
2097 __entry->intra = test_bit(NFSD4_COPY_F_INTRA, ©->cp_flags);
2098 __entry->async = !test_bit(NFSD4_COPY_F_SYNCHRONOUS, ©->cp_flags);
2099 __assign_sockaddr(addr, ©->cp_clp->cl_addr,
2100 sizeof(struct sockaddr_in6));
2101 ),
2102 TP_printk("addr=%pISpc status=%d intra=%d async=%d ",
2103 __get_sockaddr(addr), __entry->status, __entry->intra, __entry->async
2104 )
2105);
2106
2107#endif /* _NFSD_TRACE_H */
2108
2109#undef TRACE_INCLUDE_PATH
2110#define TRACE_INCLUDE_PATH .
2111#define TRACE_INCLUDE_FILE trace
2112#include <trace/define_trace.h>