xref: /openbmc/linux/fs/nfsd/trace.h (revision 6244036a)
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 
37 DECLARE_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) \
66 DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
67 	TP_PROTO(const struct svc_rqst *rqstp), \
68 	TP_ARGS(rqstp))
69 
70 DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
71 DEFINE_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 
89 TRACE_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 
112 TRACE_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 
135 TRACE_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 
163 TRACE_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 
194 TRACE_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 
231 TRACE_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 
276 DECLARE_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)		\
297 DEFINE_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 
303 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badexport);
304 DEFINE_NFSD_FH_ERR_EVENT(set_fh_dentry_badhandle);
305 
306 TRACE_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 
330 TRACE_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 
356 TRACE_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 
377 TRACE_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 
397 DECLARE_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)		\
421 DEFINE_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 
428 DEFINE_NFSD_IO_EVENT(read_start);
429 DEFINE_NFSD_IO_EVENT(read_splice);
430 DEFINE_NFSD_IO_EVENT(read_vector);
431 DEFINE_NFSD_IO_EVENT(read_io_done);
432 DEFINE_NFSD_IO_EVENT(read_done);
433 DEFINE_NFSD_IO_EVENT(write_start);
434 DEFINE_NFSD_IO_EVENT(write_opened);
435 DEFINE_NFSD_IO_EVENT(write_io_done);
436 DEFINE_NFSD_IO_EVENT(write_done);
437 
438 DECLARE_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)		\
462 DEFINE_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 
469 DEFINE_NFSD_ERR_EVENT(read_err);
470 DEFINE_NFSD_ERR_EVENT(write_err);
471 
472 TRACE_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 
493 DECLARE_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)		\
530 DEFINE_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 
541 DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
542 
543 #include "state.h"
544 #include "filecache.h"
545 #include "vfs.h"
546 
547 TRACE_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 
570 DECLARE_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) \
593 DEFINE_EVENT(nfsd_stateid_class, nfsd_##name, \
594 	TP_PROTO(stateid_t *stp), \
595 	TP_ARGS(stp))
596 
597 DEFINE_STATEID_EVENT(layoutstate_alloc);
598 DEFINE_STATEID_EVENT(layoutstate_unhash);
599 DEFINE_STATEID_EVENT(layoutstate_free);
600 DEFINE_STATEID_EVENT(layout_get_lookup_fail);
601 DEFINE_STATEID_EVENT(layout_commit_lookup_fail);
602 DEFINE_STATEID_EVENT(layout_return_lookup_fail);
603 DEFINE_STATEID_EVENT(layout_recall);
604 DEFINE_STATEID_EVENT(layout_recall_done);
605 DEFINE_STATEID_EVENT(layout_recall_fail);
606 DEFINE_STATEID_EVENT(layout_recall_release);
607 
608 DEFINE_STATEID_EVENT(open);
609 DEFINE_STATEID_EVENT(deleg_read);
610 DEFINE_STATEID_EVENT(deleg_write);
611 DEFINE_STATEID_EVENT(deleg_return);
612 DEFINE_STATEID_EVENT(deleg_recall);
613 
614 DECLARE_EVENT_CLASS(nfsd_stateseqid_class,
615 	TP_PROTO(u32 seqid, const stateid_t *stp),
616 	TP_ARGS(seqid, stp),
617 	TP_STRUCT__entry(
618 		__field(u32, seqid)
619 		__field(u32, cl_boot)
620 		__field(u32, cl_id)
621 		__field(u32, si_id)
622 		__field(u32, si_generation)
623 	),
624 	TP_fast_assign(
625 		__entry->seqid = seqid;
626 		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
627 		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
628 		__entry->si_id = stp->si_opaque.so_id;
629 		__entry->si_generation = stp->si_generation;
630 	),
631 	TP_printk("seqid=%u client %08x:%08x stateid %08x:%08x",
632 		__entry->seqid, __entry->cl_boot, __entry->cl_id,
633 		__entry->si_id, __entry->si_generation)
634 )
635 
636 #define DEFINE_STATESEQID_EVENT(name) \
637 DEFINE_EVENT(nfsd_stateseqid_class, nfsd_##name, \
638 	TP_PROTO(u32 seqid, const stateid_t *stp), \
639 	TP_ARGS(seqid, stp))
640 
641 DEFINE_STATESEQID_EVENT(preprocess);
642 DEFINE_STATESEQID_EVENT(open_confirm);
643 
644 TRACE_DEFINE_ENUM(NFS4_OPEN_STID);
645 TRACE_DEFINE_ENUM(NFS4_LOCK_STID);
646 TRACE_DEFINE_ENUM(NFS4_DELEG_STID);
647 TRACE_DEFINE_ENUM(NFS4_CLOSED_STID);
648 TRACE_DEFINE_ENUM(NFS4_REVOKED_DELEG_STID);
649 TRACE_DEFINE_ENUM(NFS4_CLOSED_DELEG_STID);
650 TRACE_DEFINE_ENUM(NFS4_LAYOUT_STID);
651 
652 #define show_stid_type(x)						\
653 	__print_flags(x, "|",						\
654 		{ NFS4_OPEN_STID,		"OPEN" },		\
655 		{ NFS4_LOCK_STID,		"LOCK" },		\
656 		{ NFS4_DELEG_STID,		"DELEG" },		\
657 		{ NFS4_CLOSED_STID,		"CLOSED" },		\
658 		{ NFS4_REVOKED_DELEG_STID,	"REVOKED" },		\
659 		{ NFS4_CLOSED_DELEG_STID,	"CLOSED_DELEG" },	\
660 		{ NFS4_LAYOUT_STID,		"LAYOUT" })
661 
662 DECLARE_EVENT_CLASS(nfsd_stid_class,
663 	TP_PROTO(
664 		const struct nfs4_stid *stid
665 	),
666 	TP_ARGS(stid),
667 	TP_STRUCT__entry(
668 		__field(unsigned long, sc_type)
669 		__field(int, sc_count)
670 		__field(u32, cl_boot)
671 		__field(u32, cl_id)
672 		__field(u32, si_id)
673 		__field(u32, si_generation)
674 	),
675 	TP_fast_assign(
676 		const stateid_t *stp = &stid->sc_stateid;
677 
678 		__entry->sc_type = stid->sc_type;
679 		__entry->sc_count = refcount_read(&stid->sc_count);
680 		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
681 		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
682 		__entry->si_id = stp->si_opaque.so_id;
683 		__entry->si_generation = stp->si_generation;
684 	),
685 	TP_printk("client %08x:%08x stateid %08x:%08x ref=%d type=%s",
686 		__entry->cl_boot, __entry->cl_id,
687 		__entry->si_id, __entry->si_generation,
688 		__entry->sc_count, show_stid_type(__entry->sc_type)
689 	)
690 );
691 
692 #define DEFINE_STID_EVENT(name)					\
693 DEFINE_EVENT(nfsd_stid_class, nfsd_stid_##name,			\
694 	TP_PROTO(const struct nfs4_stid *stid),			\
695 	TP_ARGS(stid))
696 
697 DEFINE_STID_EVENT(revoke);
698 
699 DECLARE_EVENT_CLASS(nfsd_clientid_class,
700 	TP_PROTO(const clientid_t *clid),
701 	TP_ARGS(clid),
702 	TP_STRUCT__entry(
703 		__field(u32, cl_boot)
704 		__field(u32, cl_id)
705 	),
706 	TP_fast_assign(
707 		__entry->cl_boot = clid->cl_boot;
708 		__entry->cl_id = clid->cl_id;
709 	),
710 	TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
711 )
712 
713 #define DEFINE_CLIENTID_EVENT(name) \
714 DEFINE_EVENT(nfsd_clientid_class, nfsd_clid_##name, \
715 	TP_PROTO(const clientid_t *clid), \
716 	TP_ARGS(clid))
717 
718 DEFINE_CLIENTID_EVENT(expire_unconf);
719 DEFINE_CLIENTID_EVENT(reclaim_complete);
720 DEFINE_CLIENTID_EVENT(confirmed);
721 DEFINE_CLIENTID_EVENT(destroyed);
722 DEFINE_CLIENTID_EVENT(admin_expired);
723 DEFINE_CLIENTID_EVENT(replaced);
724 DEFINE_CLIENTID_EVENT(purged);
725 DEFINE_CLIENTID_EVENT(renew);
726 DEFINE_CLIENTID_EVENT(stale);
727 
728 DECLARE_EVENT_CLASS(nfsd_net_class,
729 	TP_PROTO(const struct nfsd_net *nn),
730 	TP_ARGS(nn),
731 	TP_STRUCT__entry(
732 		__field(unsigned long long, boot_time)
733 	),
734 	TP_fast_assign(
735 		__entry->boot_time = nn->boot_time;
736 	),
737 	TP_printk("boot_time=%16llx", __entry->boot_time)
738 )
739 
740 #define DEFINE_NET_EVENT(name) \
741 DEFINE_EVENT(nfsd_net_class, nfsd_##name, \
742 	TP_PROTO(const struct nfsd_net *nn), \
743 	TP_ARGS(nn))
744 
745 DEFINE_NET_EVENT(grace_start);
746 DEFINE_NET_EVENT(grace_complete);
747 
748 TRACE_EVENT(nfsd_writeverf_reset,
749 	TP_PROTO(
750 		const struct nfsd_net *nn,
751 		const struct svc_rqst *rqstp,
752 		int error
753 	),
754 	TP_ARGS(nn, rqstp, error),
755 	TP_STRUCT__entry(
756 		__field(unsigned long long, boot_time)
757 		__field(u32, xid)
758 		__field(int, error)
759 		__array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
760 	),
761 	TP_fast_assign(
762 		__entry->boot_time = nn->boot_time;
763 		__entry->xid = be32_to_cpu(rqstp->rq_xid);
764 		__entry->error = error;
765 
766 		/* avoid seqlock inside TP_fast_assign */
767 		memcpy(__entry->verifier, nn->writeverf,
768 		       NFS4_VERIFIER_SIZE);
769 	),
770 	TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
771 		__entry->boot_time, __entry->xid, __entry->error,
772 		__print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
773 	)
774 );
775 
776 TRACE_EVENT(nfsd_clid_cred_mismatch,
777 	TP_PROTO(
778 		const struct nfs4_client *clp,
779 		const struct svc_rqst *rqstp
780 	),
781 	TP_ARGS(clp, rqstp),
782 	TP_STRUCT__entry(
783 		__field(u32, cl_boot)
784 		__field(u32, cl_id)
785 		__field(unsigned long, cl_flavor)
786 		__field(unsigned long, new_flavor)
787 		__sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
788 	),
789 	TP_fast_assign(
790 		__entry->cl_boot = clp->cl_clientid.cl_boot;
791 		__entry->cl_id = clp->cl_clientid.cl_id;
792 		__entry->cl_flavor = clp->cl_cred.cr_flavor;
793 		__entry->new_flavor = rqstp->rq_cred.cr_flavor;
794 		__assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
795 				  rqstp->rq_xprt->xpt_remotelen);
796 	),
797 	TP_printk("client %08x:%08x flavor=%s, conflict=%s from addr=%pISpc",
798 		__entry->cl_boot, __entry->cl_id,
799 		show_nfsd_authflavor(__entry->cl_flavor),
800 		show_nfsd_authflavor(__entry->new_flavor),
801 		__get_sockaddr(addr)
802 	)
803 )
804 
805 TRACE_EVENT(nfsd_clid_verf_mismatch,
806 	TP_PROTO(
807 		const struct nfs4_client *clp,
808 		const struct svc_rqst *rqstp,
809 		const nfs4_verifier *verf
810 	),
811 	TP_ARGS(clp, rqstp, verf),
812 	TP_STRUCT__entry(
813 		__field(u32, cl_boot)
814 		__field(u32, cl_id)
815 		__array(unsigned char, cl_verifier, NFS4_VERIFIER_SIZE)
816 		__array(unsigned char, new_verifier, NFS4_VERIFIER_SIZE)
817 		__sockaddr(addr, rqstp->rq_xprt->xpt_remotelen)
818 	),
819 	TP_fast_assign(
820 		__entry->cl_boot = clp->cl_clientid.cl_boot;
821 		__entry->cl_id = clp->cl_clientid.cl_id;
822 		memcpy(__entry->cl_verifier, (void *)&clp->cl_verifier,
823 		       NFS4_VERIFIER_SIZE);
824 		memcpy(__entry->new_verifier, (void *)verf,
825 		       NFS4_VERIFIER_SIZE);
826 		__assign_sockaddr(addr, &rqstp->rq_xprt->xpt_remote,
827 				  rqstp->rq_xprt->xpt_remotelen);
828 	),
829 	TP_printk("client %08x:%08x verf=0x%s, updated=0x%s from addr=%pISpc",
830 		__entry->cl_boot, __entry->cl_id,
831 		__print_hex_str(__entry->cl_verifier, NFS4_VERIFIER_SIZE),
832 		__print_hex_str(__entry->new_verifier, NFS4_VERIFIER_SIZE),
833 		__get_sockaddr(addr)
834 	)
835 );
836 
837 DECLARE_EVENT_CLASS(nfsd_clid_class,
838 	TP_PROTO(const struct nfs4_client *clp),
839 	TP_ARGS(clp),
840 	TP_STRUCT__entry(
841 		__field(u32, cl_boot)
842 		__field(u32, cl_id)
843 		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
844 		__field(unsigned long, flavor)
845 		__array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
846 		__string_len(name, clp->cl_name.data, clp->cl_name.len)
847 	),
848 	TP_fast_assign(
849 		__entry->cl_boot = clp->cl_clientid.cl_boot;
850 		__entry->cl_id = clp->cl_clientid.cl_id;
851 		memcpy(__entry->addr, &clp->cl_addr,
852 			sizeof(struct sockaddr_in6));
853 		__entry->flavor = clp->cl_cred.cr_flavor;
854 		memcpy(__entry->verifier, (void *)&clp->cl_verifier,
855 		       NFS4_VERIFIER_SIZE);
856 		__assign_str_len(name, clp->cl_name.data, clp->cl_name.len);
857 	),
858 	TP_printk("addr=%pISpc name='%s' verifier=0x%s flavor=%s client=%08x:%08x",
859 		__entry->addr, __get_str(name),
860 		__print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE),
861 		show_nfsd_authflavor(__entry->flavor),
862 		__entry->cl_boot, __entry->cl_id)
863 );
864 
865 #define DEFINE_CLID_EVENT(name) \
866 DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \
867 	TP_PROTO(const struct nfs4_client *clp), \
868 	TP_ARGS(clp))
869 
870 DEFINE_CLID_EVENT(fresh);
871 DEFINE_CLID_EVENT(confirmed_r);
872 
873 /*
874  * from fs/nfsd/filecache.h
875  */
876 #define show_nf_flags(val)						\
877 	__print_flags(val, "|",						\
878 		{ 1 << NFSD_FILE_HASHED,	"HASHED" },		\
879 		{ 1 << NFSD_FILE_PENDING,	"PENDING" },		\
880 		{ 1 << NFSD_FILE_REFERENCED,	"REFERENCED" },		\
881 		{ 1 << NFSD_FILE_GC,		"GC" })
882 
883 DECLARE_EVENT_CLASS(nfsd_file_class,
884 	TP_PROTO(struct nfsd_file *nf),
885 	TP_ARGS(nf),
886 	TP_STRUCT__entry(
887 		__field(void *, nf_inode)
888 		__field(int, nf_ref)
889 		__field(unsigned long, nf_flags)
890 		__field(unsigned char, nf_may)
891 		__field(struct file *, nf_file)
892 	),
893 	TP_fast_assign(
894 		__entry->nf_inode = nf->nf_inode;
895 		__entry->nf_ref = refcount_read(&nf->nf_ref);
896 		__entry->nf_flags = nf->nf_flags;
897 		__entry->nf_may = nf->nf_may;
898 		__entry->nf_file = nf->nf_file;
899 	),
900 	TP_printk("inode=%p ref=%d flags=%s may=%s nf_file=%p",
901 		__entry->nf_inode,
902 		__entry->nf_ref,
903 		show_nf_flags(__entry->nf_flags),
904 		show_nfsd_may_flags(__entry->nf_may),
905 		__entry->nf_file)
906 )
907 
908 #define DEFINE_NFSD_FILE_EVENT(name) \
909 DEFINE_EVENT(nfsd_file_class, name, \
910 	TP_PROTO(struct nfsd_file *nf), \
911 	TP_ARGS(nf))
912 
913 DEFINE_NFSD_FILE_EVENT(nfsd_file_free);
914 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash);
915 DEFINE_NFSD_FILE_EVENT(nfsd_file_put);
916 DEFINE_NFSD_FILE_EVENT(nfsd_file_closing);
917 DEFINE_NFSD_FILE_EVENT(nfsd_file_unhash_and_queue);
918 
919 TRACE_EVENT(nfsd_file_alloc,
920 	TP_PROTO(
921 		const struct nfsd_file *nf
922 	),
923 	TP_ARGS(nf),
924 	TP_STRUCT__entry(
925 		__field(const void *, nf_inode)
926 		__field(unsigned long, nf_flags)
927 		__field(unsigned long, nf_may)
928 		__field(unsigned int, nf_ref)
929 	),
930 	TP_fast_assign(
931 		__entry->nf_inode = nf->nf_inode;
932 		__entry->nf_flags = nf->nf_flags;
933 		__entry->nf_ref = refcount_read(&nf->nf_ref);
934 		__entry->nf_may = nf->nf_may;
935 	),
936 	TP_printk("inode=%p ref=%u flags=%s may=%s",
937 		__entry->nf_inode, __entry->nf_ref,
938 		show_nf_flags(__entry->nf_flags),
939 		show_nfsd_may_flags(__entry->nf_may)
940 	)
941 );
942 
943 TRACE_EVENT(nfsd_file_acquire,
944 	TP_PROTO(
945 		const struct svc_rqst *rqstp,
946 		const struct inode *inode,
947 		unsigned int may_flags,
948 		const struct nfsd_file *nf,
949 		__be32 status
950 	),
951 
952 	TP_ARGS(rqstp, inode, may_flags, nf, status),
953 
954 	TP_STRUCT__entry(
955 		__field(u32, xid)
956 		__field(const void *, inode)
957 		__field(unsigned long, may_flags)
958 		__field(unsigned int, nf_ref)
959 		__field(unsigned long, nf_flags)
960 		__field(unsigned long, nf_may)
961 		__field(const void *, nf_file)
962 		__field(u32, status)
963 	),
964 
965 	TP_fast_assign(
966 		__entry->xid = be32_to_cpu(rqstp->rq_xid);
967 		__entry->inode = inode;
968 		__entry->may_flags = may_flags;
969 		__entry->nf_ref = nf ? refcount_read(&nf->nf_ref) : 0;
970 		__entry->nf_flags = nf ? nf->nf_flags : 0;
971 		__entry->nf_may = nf ? nf->nf_may : 0;
972 		__entry->nf_file = nf ? nf->nf_file : NULL;
973 		__entry->status = be32_to_cpu(status);
974 	),
975 
976 	TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p status=%u",
977 			__entry->xid, __entry->inode,
978 			show_nfsd_may_flags(__entry->may_flags),
979 			__entry->nf_ref, show_nf_flags(__entry->nf_flags),
980 			show_nfsd_may_flags(__entry->nf_may),
981 			__entry->nf_file, __entry->status
982 	)
983 );
984 
985 TRACE_EVENT(nfsd_file_insert_err,
986 	TP_PROTO(
987 		const struct svc_rqst *rqstp,
988 		const struct inode *inode,
989 		unsigned int may_flags,
990 		long error
991 	),
992 	TP_ARGS(rqstp, inode, may_flags, error),
993 	TP_STRUCT__entry(
994 		__field(u32, xid)
995 		__field(const void *, inode)
996 		__field(unsigned long, may_flags)
997 		__field(long, error)
998 	),
999 	TP_fast_assign(
1000 		__entry->xid = be32_to_cpu(rqstp->rq_xid);
1001 		__entry->inode = inode;
1002 		__entry->may_flags = may_flags;
1003 		__entry->error = error;
1004 	),
1005 	TP_printk("xid=0x%x inode=%p may_flags=%s error=%ld",
1006 		__entry->xid, __entry->inode,
1007 		show_nfsd_may_flags(__entry->may_flags),
1008 		__entry->error
1009 	)
1010 );
1011 
1012 TRACE_EVENT(nfsd_file_cons_err,
1013 	TP_PROTO(
1014 		const struct svc_rqst *rqstp,
1015 		const struct inode *inode,
1016 		unsigned int may_flags,
1017 		const struct nfsd_file *nf
1018 	),
1019 	TP_ARGS(rqstp, inode, may_flags, nf),
1020 	TP_STRUCT__entry(
1021 		__field(u32, xid)
1022 		__field(const void *, inode)
1023 		__field(unsigned long, may_flags)
1024 		__field(unsigned int, nf_ref)
1025 		__field(unsigned long, nf_flags)
1026 		__field(unsigned long, nf_may)
1027 		__field(const void *, nf_file)
1028 	),
1029 	TP_fast_assign(
1030 		__entry->xid = be32_to_cpu(rqstp->rq_xid);
1031 		__entry->inode = inode;
1032 		__entry->may_flags = may_flags;
1033 		__entry->nf_ref = refcount_read(&nf->nf_ref);
1034 		__entry->nf_flags = nf->nf_flags;
1035 		__entry->nf_may = nf->nf_may;
1036 		__entry->nf_file = nf->nf_file;
1037 	),
1038 	TP_printk("xid=0x%x inode=%p may_flags=%s ref=%u nf_flags=%s nf_may=%s nf_file=%p",
1039 		__entry->xid, __entry->inode,
1040 		show_nfsd_may_flags(__entry->may_flags), __entry->nf_ref,
1041 		show_nf_flags(__entry->nf_flags),
1042 		show_nfsd_may_flags(__entry->nf_may), __entry->nf_file
1043 	)
1044 );
1045 
1046 DECLARE_EVENT_CLASS(nfsd_file_open_class,
1047 	TP_PROTO(const struct nfsd_file *nf, __be32 status),
1048 	TP_ARGS(nf, status),
1049 	TP_STRUCT__entry(
1050 		__field(void *, nf_inode)	/* cannot be dereferenced */
1051 		__field(int, nf_ref)
1052 		__field(unsigned long, nf_flags)
1053 		__field(unsigned long, nf_may)
1054 		__field(void *, nf_file)	/* cannot be dereferenced */
1055 	),
1056 	TP_fast_assign(
1057 		__entry->nf_inode = nf->nf_inode;
1058 		__entry->nf_ref = refcount_read(&nf->nf_ref);
1059 		__entry->nf_flags = nf->nf_flags;
1060 		__entry->nf_may = nf->nf_may;
1061 		__entry->nf_file = nf->nf_file;
1062 	),
1063 	TP_printk("inode=%p ref=%d flags=%s may=%s file=%p",
1064 		__entry->nf_inode,
1065 		__entry->nf_ref,
1066 		show_nf_flags(__entry->nf_flags),
1067 		show_nfsd_may_flags(__entry->nf_may),
1068 		__entry->nf_file)
1069 )
1070 
1071 #define DEFINE_NFSD_FILE_OPEN_EVENT(name)					\
1072 DEFINE_EVENT(nfsd_file_open_class, name,					\
1073 	TP_PROTO(							\
1074 		const struct nfsd_file *nf,				\
1075 		__be32 status						\
1076 	),								\
1077 	TP_ARGS(nf, status))
1078 
1079 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_open);
1080 DEFINE_NFSD_FILE_OPEN_EVENT(nfsd_file_opened);
1081 
1082 TRACE_EVENT(nfsd_file_is_cached,
1083 	TP_PROTO(
1084 		const struct inode *inode,
1085 		int found
1086 	),
1087 	TP_ARGS(inode, found),
1088 	TP_STRUCT__entry(
1089 		__field(const struct inode *, inode)
1090 		__field(int, found)
1091 	),
1092 	TP_fast_assign(
1093 		__entry->inode = inode;
1094 		__entry->found = found;
1095 	),
1096 	TP_printk("inode=%p is %scached",
1097 		__entry->inode,
1098 		__entry->found ? "" : "not "
1099 	)
1100 );
1101 
1102 TRACE_EVENT(nfsd_file_fsnotify_handle_event,
1103 	TP_PROTO(struct inode *inode, u32 mask),
1104 	TP_ARGS(inode, mask),
1105 	TP_STRUCT__entry(
1106 		__field(struct inode *, inode)
1107 		__field(unsigned int, nlink)
1108 		__field(umode_t, mode)
1109 		__field(u32, mask)
1110 	),
1111 	TP_fast_assign(
1112 		__entry->inode = inode;
1113 		__entry->nlink = inode->i_nlink;
1114 		__entry->mode = inode->i_mode;
1115 		__entry->mask = mask;
1116 	),
1117 	TP_printk("inode=%p nlink=%u mode=0%ho mask=0x%x", __entry->inode,
1118 			__entry->nlink, __entry->mode, __entry->mask)
1119 );
1120 
1121 DECLARE_EVENT_CLASS(nfsd_file_gc_class,
1122 	TP_PROTO(
1123 		const struct nfsd_file *nf
1124 	),
1125 	TP_ARGS(nf),
1126 	TP_STRUCT__entry(
1127 		__field(void *, nf_inode)
1128 		__field(void *, nf_file)
1129 		__field(int, nf_ref)
1130 		__field(unsigned long, nf_flags)
1131 	),
1132 	TP_fast_assign(
1133 		__entry->nf_inode = nf->nf_inode;
1134 		__entry->nf_file = nf->nf_file;
1135 		__entry->nf_ref = refcount_read(&nf->nf_ref);
1136 		__entry->nf_flags = nf->nf_flags;
1137 	),
1138 	TP_printk("inode=%p ref=%d nf_flags=%s nf_file=%p",
1139 		__entry->nf_inode, __entry->nf_ref,
1140 		show_nf_flags(__entry->nf_flags),
1141 		__entry->nf_file
1142 	)
1143 );
1144 
1145 #define DEFINE_NFSD_FILE_GC_EVENT(name)					\
1146 DEFINE_EVENT(nfsd_file_gc_class, name,					\
1147 	TP_PROTO(							\
1148 		const struct nfsd_file *nf				\
1149 	),								\
1150 	TP_ARGS(nf))
1151 
1152 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add);
1153 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_add_disposed);
1154 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del);
1155 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_lru_del_disposed);
1156 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_in_use);
1157 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_writeback);
1158 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_referenced);
1159 DEFINE_NFSD_FILE_GC_EVENT(nfsd_file_gc_disposed);
1160 
1161 DECLARE_EVENT_CLASS(nfsd_file_lruwalk_class,
1162 	TP_PROTO(
1163 		unsigned long removed,
1164 		unsigned long remaining
1165 	),
1166 	TP_ARGS(removed, remaining),
1167 	TP_STRUCT__entry(
1168 		__field(unsigned long, removed)
1169 		__field(unsigned long, remaining)
1170 	),
1171 	TP_fast_assign(
1172 		__entry->removed = removed;
1173 		__entry->remaining = remaining;
1174 	),
1175 	TP_printk("%lu entries removed, %lu remaining",
1176 		__entry->removed, __entry->remaining)
1177 );
1178 
1179 #define DEFINE_NFSD_FILE_LRUWALK_EVENT(name)				\
1180 DEFINE_EVENT(nfsd_file_lruwalk_class, name,				\
1181 	TP_PROTO(							\
1182 		unsigned long removed,					\
1183 		unsigned long remaining					\
1184 	),								\
1185 	TP_ARGS(removed, remaining))
1186 
1187 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_gc_removed);
1188 DEFINE_NFSD_FILE_LRUWALK_EVENT(nfsd_file_shrinker_removed);
1189 
1190 TRACE_EVENT(nfsd_file_close,
1191 	TP_PROTO(
1192 		const struct inode *inode
1193 	),
1194 	TP_ARGS(inode),
1195 	TP_STRUCT__entry(
1196 		__field(const void *, inode)
1197 	),
1198 	TP_fast_assign(
1199 		__entry->inode = inode;
1200 	),
1201 	TP_printk("inode=%p",
1202 		__entry->inode
1203 	)
1204 );
1205 
1206 #include "cache.h"
1207 
1208 TRACE_DEFINE_ENUM(RC_DROPIT);
1209 TRACE_DEFINE_ENUM(RC_REPLY);
1210 TRACE_DEFINE_ENUM(RC_DOIT);
1211 
1212 #define show_drc_retval(x)						\
1213 	__print_symbolic(x,						\
1214 		{ RC_DROPIT, "DROPIT" },				\
1215 		{ RC_REPLY, "REPLY" },					\
1216 		{ RC_DOIT, "DOIT" })
1217 
1218 TRACE_EVENT(nfsd_drc_found,
1219 	TP_PROTO(
1220 		const struct nfsd_net *nn,
1221 		const struct svc_rqst *rqstp,
1222 		int result
1223 	),
1224 	TP_ARGS(nn, rqstp, result),
1225 	TP_STRUCT__entry(
1226 		__field(unsigned long long, boot_time)
1227 		__field(unsigned long, result)
1228 		__field(u32, xid)
1229 	),
1230 	TP_fast_assign(
1231 		__entry->boot_time = nn->boot_time;
1232 		__entry->result = result;
1233 		__entry->xid = be32_to_cpu(rqstp->rq_xid);
1234 	),
1235 	TP_printk("boot_time=%16llx xid=0x%08x result=%s",
1236 		__entry->boot_time, __entry->xid,
1237 		show_drc_retval(__entry->result))
1238 
1239 );
1240 
1241 TRACE_EVENT(nfsd_drc_mismatch,
1242 	TP_PROTO(
1243 		const struct nfsd_net *nn,
1244 		const struct nfsd_cacherep *key,
1245 		const struct nfsd_cacherep *rp
1246 	),
1247 	TP_ARGS(nn, key, rp),
1248 	TP_STRUCT__entry(
1249 		__field(unsigned long long, boot_time)
1250 		__field(u32, xid)
1251 		__field(u32, cached)
1252 		__field(u32, ingress)
1253 	),
1254 	TP_fast_assign(
1255 		__entry->boot_time = nn->boot_time;
1256 		__entry->xid = be32_to_cpu(key->c_key.k_xid);
1257 		__entry->cached = (__force u32)key->c_key.k_csum;
1258 		__entry->ingress = (__force u32)rp->c_key.k_csum;
1259 	),
1260 	TP_printk("boot_time=%16llx xid=0x%08x cached-csum=0x%08x ingress-csum=0x%08x",
1261 		__entry->boot_time, __entry->xid, __entry->cached,
1262 		__entry->ingress)
1263 );
1264 
1265 TRACE_EVENT_CONDITION(nfsd_drc_gc,
1266 	TP_PROTO(
1267 		const struct nfsd_net *nn,
1268 		unsigned long freed
1269 	),
1270 	TP_ARGS(nn, freed),
1271 	TP_CONDITION(freed > 0),
1272 	TP_STRUCT__entry(
1273 		__field(unsigned long long, boot_time)
1274 		__field(unsigned long, freed)
1275 		__field(int, total)
1276 	),
1277 	TP_fast_assign(
1278 		__entry->boot_time = nn->boot_time;
1279 		__entry->freed = freed;
1280 		__entry->total = atomic_read(&nn->num_drc_entries);
1281 	),
1282 	TP_printk("boot_time=%16llx total=%d freed=%lu",
1283 		__entry->boot_time, __entry->total, __entry->freed
1284 	)
1285 );
1286 
1287 TRACE_EVENT(nfsd_cb_args,
1288 	TP_PROTO(
1289 		const struct nfs4_client *clp,
1290 		const struct nfs4_cb_conn *conn
1291 	),
1292 	TP_ARGS(clp, conn),
1293 	TP_STRUCT__entry(
1294 		__field(u32, cl_boot)
1295 		__field(u32, cl_id)
1296 		__field(u32, prog)
1297 		__field(u32, ident)
1298 		__sockaddr(addr, conn->cb_addrlen)
1299 	),
1300 	TP_fast_assign(
1301 		__entry->cl_boot = clp->cl_clientid.cl_boot;
1302 		__entry->cl_id = clp->cl_clientid.cl_id;
1303 		__entry->prog = conn->cb_prog;
1304 		__entry->ident = conn->cb_ident;
1305 		__assign_sockaddr(addr, &conn->cb_addr, conn->cb_addrlen);
1306 	),
1307 	TP_printk("addr=%pISpc client %08x:%08x prog=%u ident=%u",
1308 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1309 		__entry->prog, __entry->ident)
1310 );
1311 
1312 TRACE_EVENT(nfsd_cb_nodelegs,
1313 	TP_PROTO(const struct nfs4_client *clp),
1314 	TP_ARGS(clp),
1315 	TP_STRUCT__entry(
1316 		__field(u32, cl_boot)
1317 		__field(u32, cl_id)
1318 	),
1319 	TP_fast_assign(
1320 		__entry->cl_boot = clp->cl_clientid.cl_boot;
1321 		__entry->cl_id = clp->cl_clientid.cl_id;
1322 	),
1323 	TP_printk("client %08x:%08x", __entry->cl_boot, __entry->cl_id)
1324 )
1325 
1326 #define show_cb_state(val)						\
1327 	__print_symbolic(val,						\
1328 		{ NFSD4_CB_UP,		"UP" },				\
1329 		{ NFSD4_CB_UNKNOWN,	"UNKNOWN" },			\
1330 		{ NFSD4_CB_DOWN,	"DOWN" },			\
1331 		{ NFSD4_CB_FAULT,	"FAULT"})
1332 
1333 DECLARE_EVENT_CLASS(nfsd_cb_class,
1334 	TP_PROTO(const struct nfs4_client *clp),
1335 	TP_ARGS(clp),
1336 	TP_STRUCT__entry(
1337 		__field(unsigned long, state)
1338 		__field(u32, cl_boot)
1339 		__field(u32, cl_id)
1340 		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1341 	),
1342 	TP_fast_assign(
1343 		__entry->state = clp->cl_cb_state;
1344 		__entry->cl_boot = clp->cl_clientid.cl_boot;
1345 		__entry->cl_id = clp->cl_clientid.cl_id;
1346 		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1347 				  clp->cl_cb_conn.cb_addrlen)
1348 	),
1349 	TP_printk("addr=%pISpc client %08x:%08x state=%s",
1350 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1351 		show_cb_state(__entry->state))
1352 );
1353 
1354 #define DEFINE_NFSD_CB_EVENT(name)			\
1355 DEFINE_EVENT(nfsd_cb_class, nfsd_cb_##name,		\
1356 	TP_PROTO(const struct nfs4_client *clp),	\
1357 	TP_ARGS(clp))
1358 
1359 DEFINE_NFSD_CB_EVENT(state);
1360 DEFINE_NFSD_CB_EVENT(probe);
1361 DEFINE_NFSD_CB_EVENT(lost);
1362 DEFINE_NFSD_CB_EVENT(shutdown);
1363 
1364 TRACE_DEFINE_ENUM(RPC_AUTH_NULL);
1365 TRACE_DEFINE_ENUM(RPC_AUTH_UNIX);
1366 TRACE_DEFINE_ENUM(RPC_AUTH_GSS);
1367 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5);
1368 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5I);
1369 TRACE_DEFINE_ENUM(RPC_AUTH_GSS_KRB5P);
1370 
1371 #define show_nfsd_authflavor(val)					\
1372 	__print_symbolic(val,						\
1373 		{ RPC_AUTH_NULL,		"none" },		\
1374 		{ RPC_AUTH_UNIX,		"sys" },		\
1375 		{ RPC_AUTH_GSS,			"gss" },		\
1376 		{ RPC_AUTH_GSS_KRB5,		"krb5" },		\
1377 		{ RPC_AUTH_GSS_KRB5I,		"krb5i" },		\
1378 		{ RPC_AUTH_GSS_KRB5P,		"krb5p" })
1379 
1380 TRACE_EVENT(nfsd_cb_setup,
1381 	TP_PROTO(const struct nfs4_client *clp,
1382 		 const char *netid,
1383 		 rpc_authflavor_t authflavor
1384 	),
1385 	TP_ARGS(clp, netid, authflavor),
1386 	TP_STRUCT__entry(
1387 		__field(u32, cl_boot)
1388 		__field(u32, cl_id)
1389 		__field(unsigned long, authflavor)
1390 		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1391 		__string(netid, netid)
1392 	),
1393 	TP_fast_assign(
1394 		__entry->cl_boot = clp->cl_clientid.cl_boot;
1395 		__entry->cl_id = clp->cl_clientid.cl_id;
1396 		__assign_str(netid, netid);
1397 		__entry->authflavor = authflavor;
1398 		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1399 				  clp->cl_cb_conn.cb_addrlen)
1400 	),
1401 	TP_printk("addr=%pISpc client %08x:%08x proto=%s flavor=%s",
1402 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1403 		__get_str(netid), show_nfsd_authflavor(__entry->authflavor))
1404 );
1405 
1406 TRACE_EVENT(nfsd_cb_setup_err,
1407 	TP_PROTO(
1408 		const struct nfs4_client *clp,
1409 		long error
1410 	),
1411 	TP_ARGS(clp, error),
1412 	TP_STRUCT__entry(
1413 		__field(long, error)
1414 		__field(u32, cl_boot)
1415 		__field(u32, cl_id)
1416 		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1417 	),
1418 	TP_fast_assign(
1419 		__entry->error = error;
1420 		__entry->cl_boot = clp->cl_clientid.cl_boot;
1421 		__entry->cl_id = clp->cl_clientid.cl_id;
1422 		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1423 				  clp->cl_cb_conn.cb_addrlen)
1424 	),
1425 	TP_printk("addr=%pISpc client %08x:%08x error=%ld",
1426 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1427 		__entry->error)
1428 );
1429 
1430 TRACE_EVENT_CONDITION(nfsd_cb_recall,
1431 	TP_PROTO(
1432 		const struct nfs4_stid *stid
1433 	),
1434 	TP_ARGS(stid),
1435 	TP_CONDITION(stid->sc_client),
1436 	TP_STRUCT__entry(
1437 		__field(u32, cl_boot)
1438 		__field(u32, cl_id)
1439 		__field(u32, si_id)
1440 		__field(u32, si_generation)
1441 		__sockaddr(addr, stid->sc_client->cl_cb_conn.cb_addrlen)
1442 	),
1443 	TP_fast_assign(
1444 		const stateid_t *stp = &stid->sc_stateid;
1445 		const struct nfs4_client *clp = stid->sc_client;
1446 
1447 		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1448 		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
1449 		__entry->si_id = stp->si_opaque.so_id;
1450 		__entry->si_generation = stp->si_generation;
1451 		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1452 				  clp->cl_cb_conn.cb_addrlen)
1453 	),
1454 	TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x",
1455 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1456 		__entry->si_id, __entry->si_generation)
1457 );
1458 
1459 TRACE_EVENT(nfsd_cb_notify_lock,
1460 	TP_PROTO(
1461 		const struct nfs4_lockowner *lo,
1462 		const struct nfsd4_blocked_lock *nbl
1463 	),
1464 	TP_ARGS(lo, nbl),
1465 	TP_STRUCT__entry(
1466 		__field(u32, cl_boot)
1467 		__field(u32, cl_id)
1468 		__field(u32, fh_hash)
1469 		__sockaddr(addr, lo->lo_owner.so_client->cl_cb_conn.cb_addrlen)
1470 	),
1471 	TP_fast_assign(
1472 		const struct nfs4_client *clp = lo->lo_owner.so_client;
1473 
1474 		__entry->cl_boot = clp->cl_clientid.cl_boot;
1475 		__entry->cl_id = clp->cl_clientid.cl_id;
1476 		__entry->fh_hash = knfsd_fh_hash(&nbl->nbl_fh);
1477 		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1478 				  clp->cl_cb_conn.cb_addrlen)
1479 	),
1480 	TP_printk("addr=%pISpc client %08x:%08x fh_hash=0x%08x",
1481 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1482 		__entry->fh_hash)
1483 );
1484 
1485 TRACE_EVENT(nfsd_cb_offload,
1486 	TP_PROTO(
1487 		const struct nfs4_client *clp,
1488 		const stateid_t *stp,
1489 		const struct knfsd_fh *fh,
1490 		u64 count,
1491 		__be32 status
1492 	),
1493 	TP_ARGS(clp, stp, fh, count, status),
1494 	TP_STRUCT__entry(
1495 		__field(u32, cl_boot)
1496 		__field(u32, cl_id)
1497 		__field(u32, si_id)
1498 		__field(u32, si_generation)
1499 		__field(u32, fh_hash)
1500 		__field(int, status)
1501 		__field(u64, count)
1502 		__sockaddr(addr, clp->cl_cb_conn.cb_addrlen)
1503 	),
1504 	TP_fast_assign(
1505 		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1506 		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
1507 		__entry->si_id = stp->si_opaque.so_id;
1508 		__entry->si_generation = stp->si_generation;
1509 		__entry->fh_hash = knfsd_fh_hash(fh);
1510 		__entry->status = be32_to_cpu(status);
1511 		__entry->count = count;
1512 		__assign_sockaddr(addr, &clp->cl_cb_conn.cb_addr,
1513 				  clp->cl_cb_conn.cb_addrlen)
1514 	),
1515 	TP_printk("addr=%pISpc client %08x:%08x stateid %08x:%08x fh_hash=0x%08x count=%llu status=%d",
1516 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1517 		__entry->si_id, __entry->si_generation,
1518 		__entry->fh_hash, __entry->count, __entry->status)
1519 );
1520 
1521 TRACE_EVENT(nfsd_cb_recall_any,
1522 	TP_PROTO(
1523 		const struct nfsd4_cb_recall_any *ra
1524 	),
1525 	TP_ARGS(ra),
1526 	TP_STRUCT__entry(
1527 		__field(u32, cl_boot)
1528 		__field(u32, cl_id)
1529 		__field(u32, keep)
1530 		__field(unsigned long, bmval0)
1531 		__sockaddr(addr, ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen)
1532 	),
1533 	TP_fast_assign(
1534 		__entry->cl_boot = ra->ra_cb.cb_clp->cl_clientid.cl_boot;
1535 		__entry->cl_id = ra->ra_cb.cb_clp->cl_clientid.cl_id;
1536 		__entry->keep = ra->ra_keep;
1537 		__entry->bmval0 = ra->ra_bmval[0];
1538 		__assign_sockaddr(addr, &ra->ra_cb.cb_clp->cl_addr,
1539 				  ra->ra_cb.cb_clp->cl_cb_conn.cb_addrlen);
1540 	),
1541 	TP_printk("addr=%pISpc client %08x:%08x keep=%u bmval0=%s",
1542 		__get_sockaddr(addr), __entry->cl_boot, __entry->cl_id,
1543 		__entry->keep, show_rca_mask(__entry->bmval0)
1544 	)
1545 );
1546 
1547 DECLARE_EVENT_CLASS(nfsd_cb_done_class,
1548 	TP_PROTO(
1549 		const stateid_t *stp,
1550 		const struct rpc_task *task
1551 	),
1552 	TP_ARGS(stp, task),
1553 	TP_STRUCT__entry(
1554 		__field(u32, cl_boot)
1555 		__field(u32, cl_id)
1556 		__field(u32, si_id)
1557 		__field(u32, si_generation)
1558 		__field(int, status)
1559 	),
1560 	TP_fast_assign(
1561 		__entry->cl_boot = stp->si_opaque.so_clid.cl_boot;
1562 		__entry->cl_id = stp->si_opaque.so_clid.cl_id;
1563 		__entry->si_id = stp->si_opaque.so_id;
1564 		__entry->si_generation = stp->si_generation;
1565 		__entry->status = task->tk_status;
1566 	),
1567 	TP_printk("client %08x:%08x stateid %08x:%08x status=%d",
1568 		__entry->cl_boot, __entry->cl_id, __entry->si_id,
1569 		__entry->si_generation, __entry->status
1570 	)
1571 );
1572 
1573 #define DEFINE_NFSD_CB_DONE_EVENT(name)			\
1574 DEFINE_EVENT(nfsd_cb_done_class, name,			\
1575 	TP_PROTO(					\
1576 		const stateid_t *stp,			\
1577 		const struct rpc_task *task		\
1578 	),						\
1579 	TP_ARGS(stp, task))
1580 
1581 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_recall_done);
1582 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_notify_lock_done);
1583 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_layout_done);
1584 DEFINE_NFSD_CB_DONE_EVENT(nfsd_cb_offload_done);
1585 
1586 TRACE_EVENT(nfsd_cb_recall_any_done,
1587 	TP_PROTO(
1588 		const struct nfsd4_callback *cb,
1589 		const struct rpc_task *task
1590 	),
1591 	TP_ARGS(cb, task),
1592 	TP_STRUCT__entry(
1593 		__field(u32, cl_boot)
1594 		__field(u32, cl_id)
1595 		__field(int, status)
1596 	),
1597 	TP_fast_assign(
1598 		__entry->status = task->tk_status;
1599 		__entry->cl_boot = cb->cb_clp->cl_clientid.cl_boot;
1600 		__entry->cl_id = cb->cb_clp->cl_clientid.cl_id;
1601 	),
1602 	TP_printk("client %08x:%08x status=%d",
1603 		__entry->cl_boot, __entry->cl_id, __entry->status
1604 	)
1605 );
1606 
1607 TRACE_EVENT(nfsd_ctl_unlock_ip,
1608 	TP_PROTO(
1609 		const struct net *net,
1610 		const char *address
1611 	),
1612 	TP_ARGS(net, address),
1613 	TP_STRUCT__entry(
1614 		__field(unsigned int, netns_ino)
1615 		__string(address, address)
1616 	),
1617 	TP_fast_assign(
1618 		__entry->netns_ino = net->ns.inum;
1619 		__assign_str(address, address);
1620 	),
1621 	TP_printk("address=%s",
1622 		__get_str(address)
1623 	)
1624 );
1625 
1626 TRACE_EVENT(nfsd_ctl_unlock_fs,
1627 	TP_PROTO(
1628 		const struct net *net,
1629 		const char *path
1630 	),
1631 	TP_ARGS(net, path),
1632 	TP_STRUCT__entry(
1633 		__field(unsigned int, netns_ino)
1634 		__string(path, path)
1635 	),
1636 	TP_fast_assign(
1637 		__entry->netns_ino = net->ns.inum;
1638 		__assign_str(path, path);
1639 	),
1640 	TP_printk("path=%s",
1641 		__get_str(path)
1642 	)
1643 );
1644 
1645 TRACE_EVENT(nfsd_ctl_filehandle,
1646 	TP_PROTO(
1647 		const struct net *net,
1648 		const char *domain,
1649 		const char *path,
1650 		int maxsize
1651 	),
1652 	TP_ARGS(net, domain, path, maxsize),
1653 	TP_STRUCT__entry(
1654 		__field(unsigned int, netns_ino)
1655 		__field(int, maxsize)
1656 		__string(domain, domain)
1657 		__string(path, path)
1658 	),
1659 	TP_fast_assign(
1660 		__entry->netns_ino = net->ns.inum;
1661 		__entry->maxsize = maxsize;
1662 		__assign_str(domain, domain);
1663 		__assign_str(path, path);
1664 	),
1665 	TP_printk("domain=%s path=%s maxsize=%d",
1666 		__get_str(domain), __get_str(path), __entry->maxsize
1667 	)
1668 );
1669 
1670 TRACE_EVENT(nfsd_ctl_threads,
1671 	TP_PROTO(
1672 		const struct net *net,
1673 		int newthreads
1674 	),
1675 	TP_ARGS(net, newthreads),
1676 	TP_STRUCT__entry(
1677 		__field(unsigned int, netns_ino)
1678 		__field(int, newthreads)
1679 	),
1680 	TP_fast_assign(
1681 		__entry->netns_ino = net->ns.inum;
1682 		__entry->newthreads = newthreads;
1683 	),
1684 	TP_printk("newthreads=%d",
1685 		__entry->newthreads
1686 	)
1687 );
1688 
1689 TRACE_EVENT(nfsd_ctl_pool_threads,
1690 	TP_PROTO(
1691 		const struct net *net,
1692 		int pool,
1693 		int nrthreads
1694 	),
1695 	TP_ARGS(net, pool, nrthreads),
1696 	TP_STRUCT__entry(
1697 		__field(unsigned int, netns_ino)
1698 		__field(int, pool)
1699 		__field(int, nrthreads)
1700 	),
1701 	TP_fast_assign(
1702 		__entry->netns_ino = net->ns.inum;
1703 		__entry->pool = pool;
1704 		__entry->nrthreads = nrthreads;
1705 	),
1706 	TP_printk("pool=%d nrthreads=%d",
1707 		__entry->pool, __entry->nrthreads
1708 	)
1709 );
1710 
1711 TRACE_EVENT(nfsd_ctl_version,
1712 	TP_PROTO(
1713 		const struct net *net,
1714 		const char *mesg
1715 	),
1716 	TP_ARGS(net, mesg),
1717 	TP_STRUCT__entry(
1718 		__field(unsigned int, netns_ino)
1719 		__string(mesg, mesg)
1720 	),
1721 	TP_fast_assign(
1722 		__entry->netns_ino = net->ns.inum;
1723 		__assign_str(mesg, mesg);
1724 	),
1725 	TP_printk("%s",
1726 		__get_str(mesg)
1727 	)
1728 );
1729 
1730 TRACE_EVENT(nfsd_ctl_ports_addfd,
1731 	TP_PROTO(
1732 		const struct net *net,
1733 		int fd
1734 	),
1735 	TP_ARGS(net, fd),
1736 	TP_STRUCT__entry(
1737 		__field(unsigned int, netns_ino)
1738 		__field(int, fd)
1739 	),
1740 	TP_fast_assign(
1741 		__entry->netns_ino = net->ns.inum;
1742 		__entry->fd = fd;
1743 	),
1744 	TP_printk("fd=%d",
1745 		__entry->fd
1746 	)
1747 );
1748 
1749 TRACE_EVENT(nfsd_ctl_ports_addxprt,
1750 	TP_PROTO(
1751 		const struct net *net,
1752 		const char *transport,
1753 		int port
1754 	),
1755 	TP_ARGS(net, transport, port),
1756 	TP_STRUCT__entry(
1757 		__field(unsigned int, netns_ino)
1758 		__field(int, port)
1759 		__string(transport, transport)
1760 	),
1761 	TP_fast_assign(
1762 		__entry->netns_ino = net->ns.inum;
1763 		__entry->port = port;
1764 		__assign_str(transport, transport);
1765 	),
1766 	TP_printk("transport=%s port=%d",
1767 		__get_str(transport), __entry->port
1768 	)
1769 );
1770 
1771 TRACE_EVENT(nfsd_ctl_maxblksize,
1772 	TP_PROTO(
1773 		const struct net *net,
1774 		int bsize
1775 	),
1776 	TP_ARGS(net, bsize),
1777 	TP_STRUCT__entry(
1778 		__field(unsigned int, netns_ino)
1779 		__field(int, bsize)
1780 	),
1781 	TP_fast_assign(
1782 		__entry->netns_ino = net->ns.inum;
1783 		__entry->bsize = bsize;
1784 	),
1785 	TP_printk("bsize=%d",
1786 		__entry->bsize
1787 	)
1788 );
1789 
1790 TRACE_EVENT(nfsd_ctl_maxconn,
1791 	TP_PROTO(
1792 		const struct net *net,
1793 		int maxconn
1794 	),
1795 	TP_ARGS(net, maxconn),
1796 	TP_STRUCT__entry(
1797 		__field(unsigned int, netns_ino)
1798 		__field(int, maxconn)
1799 	),
1800 	TP_fast_assign(
1801 		__entry->netns_ino = net->ns.inum;
1802 		__entry->maxconn = maxconn;
1803 	),
1804 	TP_printk("maxconn=%d",
1805 		__entry->maxconn
1806 	)
1807 );
1808 
1809 TRACE_EVENT(nfsd_ctl_time,
1810 	TP_PROTO(
1811 		const struct net *net,
1812 		const char *name,
1813 		size_t namelen,
1814 		int time
1815 	),
1816 	TP_ARGS(net, name, namelen, time),
1817 	TP_STRUCT__entry(
1818 		__field(unsigned int, netns_ino)
1819 		__field(int, time)
1820 		__string_len(name, name, namelen)
1821 	),
1822 	TP_fast_assign(
1823 		__entry->netns_ino = net->ns.inum;
1824 		__entry->time = time;
1825 		__assign_str_len(name, name, namelen);
1826 	),
1827 	TP_printk("file=%s time=%d\n",
1828 		__get_str(name), __entry->time
1829 	)
1830 );
1831 
1832 TRACE_EVENT(nfsd_ctl_recoverydir,
1833 	TP_PROTO(
1834 		const struct net *net,
1835 		const char *recdir
1836 	),
1837 	TP_ARGS(net, recdir),
1838 	TP_STRUCT__entry(
1839 		__field(unsigned int, netns_ino)
1840 		__string(recdir, recdir)
1841 	),
1842 	TP_fast_assign(
1843 		__entry->netns_ino = net->ns.inum;
1844 		__assign_str(recdir, recdir);
1845 	),
1846 	TP_printk("recdir=%s",
1847 		__get_str(recdir)
1848 	)
1849 );
1850 
1851 TRACE_EVENT(nfsd_end_grace,
1852 	TP_PROTO(
1853 		const struct net *net
1854 	),
1855 	TP_ARGS(net),
1856 	TP_STRUCT__entry(
1857 		__field(unsigned int, netns_ino)
1858 	),
1859 	TP_fast_assign(
1860 		__entry->netns_ino = net->ns.inum;
1861 	),
1862 	TP_printk("nn=%d", __entry->netns_ino
1863 	)
1864 );
1865 
1866 #endif /* _NFSD_TRACE_H */
1867 
1868 #undef TRACE_INCLUDE_PATH
1869 #define TRACE_INCLUDE_PATH .
1870 #define TRACE_INCLUDE_FILE trace
1871 #include <trace/define_trace.h>
1872