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