Loading...
Note: File does not exist in v3.15.
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>