1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Copyright (c) 2013 Trond Myklebust <Trond.Myklebust@netapp.com>
4 */
5#undef TRACE_SYSTEM
6#define TRACE_SYSTEM nfs4
7
8#if !defined(_TRACE_NFS4_H) || defined(TRACE_HEADER_MULTI_READ)
9#define _TRACE_NFS4_H
10
11#include <linux/tracepoint.h>
12#include <trace/misc/sunrpc.h>
13
14#include <trace/misc/fs.h>
15#include <trace/misc/nfs.h>
16
17#include "delegation.h"
18
19#define show_nfs_fattr_flags(valid) \
20 __print_flags((unsigned long)valid, "|", \
21 { NFS_ATTR_FATTR_TYPE, "TYPE" }, \
22 { NFS_ATTR_FATTR_MODE, "MODE" }, \
23 { NFS_ATTR_FATTR_NLINK, "NLINK" }, \
24 { NFS_ATTR_FATTR_OWNER, "OWNER" }, \
25 { NFS_ATTR_FATTR_GROUP, "GROUP" }, \
26 { NFS_ATTR_FATTR_RDEV, "RDEV" }, \
27 { NFS_ATTR_FATTR_SIZE, "SIZE" }, \
28 { NFS_ATTR_FATTR_FSID, "FSID" }, \
29 { NFS_ATTR_FATTR_FILEID, "FILEID" }, \
30 { NFS_ATTR_FATTR_ATIME, "ATIME" }, \
31 { NFS_ATTR_FATTR_MTIME, "MTIME" }, \
32 { NFS_ATTR_FATTR_CTIME, "CTIME" }, \
33 { NFS_ATTR_FATTR_CHANGE, "CHANGE" }, \
34 { NFS_ATTR_FATTR_OWNER_NAME, "OWNER_NAME" }, \
35 { NFS_ATTR_FATTR_GROUP_NAME, "GROUP_NAME" }, \
36 { NFS_ATTR_FATTR_BTIME, "BTIME" })
37
38DECLARE_EVENT_CLASS(nfs4_clientid_event,
39 TP_PROTO(
40 const struct nfs_client *clp,
41 int error
42 ),
43
44 TP_ARGS(clp, error),
45
46 TP_STRUCT__entry(
47 __string(dstaddr, clp->cl_hostname)
48 __field(unsigned long, error)
49 ),
50
51 TP_fast_assign(
52 __entry->error = error < 0 ? -error : 0;
53 __assign_str(dstaddr);
54 ),
55
56 TP_printk(
57 "error=%ld (%s) dstaddr=%s",
58 -__entry->error,
59 show_nfs4_status(__entry->error),
60 __get_str(dstaddr)
61 )
62);
63#define DEFINE_NFS4_CLIENTID_EVENT(name) \
64 DEFINE_EVENT(nfs4_clientid_event, name, \
65 TP_PROTO( \
66 const struct nfs_client *clp, \
67 int error \
68 ), \
69 TP_ARGS(clp, error))
70DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid);
71DEFINE_NFS4_CLIENTID_EVENT(nfs4_setclientid_confirm);
72DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew);
73DEFINE_NFS4_CLIENTID_EVENT(nfs4_renew_async);
74#ifdef CONFIG_NFS_V4_1
75DEFINE_NFS4_CLIENTID_EVENT(nfs4_exchange_id);
76DEFINE_NFS4_CLIENTID_EVENT(nfs4_create_session);
77DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_session);
78DEFINE_NFS4_CLIENTID_EVENT(nfs4_destroy_clientid);
79DEFINE_NFS4_CLIENTID_EVENT(nfs4_bind_conn_to_session);
80DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence);
81DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete);
82
83TRACE_EVENT(nfs4_trunked_exchange_id,
84 TP_PROTO(
85 const struct nfs_client *clp,
86 const char *addr,
87 int error
88 ),
89
90 TP_ARGS(clp, addr, error),
91
92 TP_STRUCT__entry(
93 __string(main_addr, clp->cl_hostname)
94 __string(trunk_addr, addr)
95 __field(unsigned long, error)
96 ),
97
98 TP_fast_assign(
99 __entry->error = error < 0 ? -error : 0;
100 __assign_str(main_addr);
101 __assign_str(trunk_addr);
102 ),
103
104 TP_printk(
105 "error=%ld (%s) main_addr=%s trunk_addr=%s",
106 -__entry->error,
107 show_nfs4_status(__entry->error),
108 __get_str(main_addr),
109 __get_str(trunk_addr)
110 )
111);
112
113TRACE_EVENT(nfs4_sequence_done,
114 TP_PROTO(
115 const struct nfs4_session *session,
116 const struct nfs4_sequence_res *res
117 ),
118 TP_ARGS(session, res),
119
120 TP_STRUCT__entry(
121 __field(unsigned int, session)
122 __field(unsigned int, slot_nr)
123 __field(unsigned int, seq_nr)
124 __field(unsigned int, highest_slotid)
125 __field(unsigned int, target_highest_slotid)
126 __field(unsigned long, status_flags)
127 __field(unsigned long, error)
128 ),
129
130 TP_fast_assign(
131 const struct nfs4_slot *sr_slot = res->sr_slot;
132 __entry->session = nfs_session_id_hash(&session->sess_id);
133 __entry->slot_nr = sr_slot->slot_nr;
134 __entry->seq_nr = sr_slot->seq_nr;
135 __entry->highest_slotid = res->sr_highest_slotid;
136 __entry->target_highest_slotid =
137 res->sr_target_highest_slotid;
138 __entry->status_flags = res->sr_status_flags;
139 __entry->error = res->sr_status < 0 ?
140 -res->sr_status : 0;
141 ),
142 TP_printk(
143 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
144 "highest_slotid=%u target_highest_slotid=%u "
145 "status_flags=0x%lx (%s)",
146 -__entry->error,
147 show_nfs4_status(__entry->error),
148 __entry->session,
149 __entry->slot_nr,
150 __entry->seq_nr,
151 __entry->highest_slotid,
152 __entry->target_highest_slotid,
153 __entry->status_flags,
154 show_nfs4_seq4_status(__entry->status_flags)
155 )
156);
157
158struct cb_sequenceargs;
159struct cb_sequenceres;
160
161TRACE_EVENT(nfs4_cb_sequence,
162 TP_PROTO(
163 const struct cb_sequenceargs *args,
164 const struct cb_sequenceres *res,
165 __be32 status
166 ),
167 TP_ARGS(args, res, status),
168
169 TP_STRUCT__entry(
170 __field(unsigned int, session)
171 __field(unsigned int, slot_nr)
172 __field(unsigned int, seq_nr)
173 __field(unsigned int, highest_slotid)
174 __field(unsigned int, cachethis)
175 __field(unsigned long, error)
176 ),
177
178 TP_fast_assign(
179 __entry->session = nfs_session_id_hash(&args->csa_sessionid);
180 __entry->slot_nr = args->csa_slotid;
181 __entry->seq_nr = args->csa_sequenceid;
182 __entry->highest_slotid = args->csa_highestslotid;
183 __entry->cachethis = args->csa_cachethis;
184 __entry->error = be32_to_cpu(status);
185 ),
186
187 TP_printk(
188 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
189 "highest_slotid=%u",
190 -__entry->error,
191 show_nfs4_status(__entry->error),
192 __entry->session,
193 __entry->slot_nr,
194 __entry->seq_nr,
195 __entry->highest_slotid
196 )
197);
198
199TRACE_EVENT(nfs4_cb_seqid_err,
200 TP_PROTO(
201 const struct cb_sequenceargs *args,
202 __be32 status
203 ),
204 TP_ARGS(args, status),
205
206 TP_STRUCT__entry(
207 __field(unsigned int, session)
208 __field(unsigned int, slot_nr)
209 __field(unsigned int, seq_nr)
210 __field(unsigned int, highest_slotid)
211 __field(unsigned int, cachethis)
212 __field(unsigned long, error)
213 ),
214
215 TP_fast_assign(
216 __entry->session = nfs_session_id_hash(&args->csa_sessionid);
217 __entry->slot_nr = args->csa_slotid;
218 __entry->seq_nr = args->csa_sequenceid;
219 __entry->highest_slotid = args->csa_highestslotid;
220 __entry->cachethis = args->csa_cachethis;
221 __entry->error = be32_to_cpu(status);
222 ),
223
224 TP_printk(
225 "error=%ld (%s) session=0x%08x slot_nr=%u seq_nr=%u "
226 "highest_slotid=%u",
227 -__entry->error,
228 show_nfs4_status(__entry->error),
229 __entry->session,
230 __entry->slot_nr,
231 __entry->seq_nr,
232 __entry->highest_slotid
233 )
234);
235
236TRACE_EVENT(nfs4_cb_offload,
237 TP_PROTO(
238 const struct nfs_fh *cb_fh,
239 const nfs4_stateid *cb_stateid,
240 uint64_t cb_count,
241 int cb_error,
242 int cb_how_stable
243 ),
244
245 TP_ARGS(cb_fh, cb_stateid, cb_count, cb_error,
246 cb_how_stable),
247
248 TP_STRUCT__entry(
249 __field(unsigned long, error)
250 __field(u32, fhandle)
251 __field(loff_t, cb_count)
252 __field(int, cb_how)
253 __field(int, cb_stateid_seq)
254 __field(u32, cb_stateid_hash)
255 ),
256
257 TP_fast_assign(
258 __entry->error = cb_error < 0 ? -cb_error : 0;
259 __entry->fhandle = nfs_fhandle_hash(cb_fh);
260 __entry->cb_stateid_seq =
261 be32_to_cpu(cb_stateid->seqid);
262 __entry->cb_stateid_hash =
263 nfs_stateid_hash(cb_stateid);
264 __entry->cb_count = cb_count;
265 __entry->cb_how = cb_how_stable;
266 ),
267
268 TP_printk(
269 "error=%ld (%s) fhandle=0x%08x cb_stateid=%d:0x%08x "
270 "cb_count=%llu cb_how=%s",
271 -__entry->error,
272 show_nfs4_status(__entry->error),
273 __entry->fhandle,
274 __entry->cb_stateid_seq, __entry->cb_stateid_hash,
275 __entry->cb_count,
276 show_nfs_stable_how(__entry->cb_how)
277 )
278);
279
280TRACE_EVENT(pnfs_ds_connect,
281 TP_PROTO(
282 char *ds_remotestr,
283 int status
284 ),
285
286 TP_ARGS(ds_remotestr, status),
287
288 TP_STRUCT__entry(
289 __string(ds_ips, ds_remotestr)
290 __field(int, status)
291 ),
292
293 TP_fast_assign(
294 __assign_str(ds_ips);
295 __entry->status = status;
296 ),
297
298 TP_printk(
299 "ds_ips=%s, status=%d",
300 __get_str(ds_ips),
301 __entry->status
302 )
303);
304
305#endif /* CONFIG_NFS_V4_1 */
306
307TRACE_EVENT(nfs4_setup_sequence,
308 TP_PROTO(
309 const struct nfs4_session *session,
310 const struct nfs4_sequence_args *args
311 ),
312 TP_ARGS(session, args),
313
314 TP_STRUCT__entry(
315 __field(unsigned int, session)
316 __field(unsigned int, slot_nr)
317 __field(unsigned int, seq_nr)
318 __field(unsigned int, highest_used_slotid)
319 ),
320
321 TP_fast_assign(
322 const struct nfs4_slot *sa_slot = args->sa_slot;
323 __entry->session = session ? nfs_session_id_hash(&session->sess_id) : 0;
324 __entry->slot_nr = sa_slot->slot_nr;
325 __entry->seq_nr = sa_slot->seq_nr;
326 __entry->highest_used_slotid =
327 sa_slot->table->highest_used_slotid;
328 ),
329 TP_printk(
330 "session=0x%08x slot_nr=%u seq_nr=%u "
331 "highest_used_slotid=%u",
332 __entry->session,
333 __entry->slot_nr,
334 __entry->seq_nr,
335 __entry->highest_used_slotid
336 )
337);
338
339TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_RUNNING);
340TRACE_DEFINE_ENUM(NFS4CLNT_CHECK_LEASE);
341TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_EXPIRED);
342TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_REBOOT);
343TRACE_DEFINE_ENUM(NFS4CLNT_RECLAIM_NOGRACE);
344TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN);
345TRACE_DEFINE_ENUM(NFS4CLNT_SESSION_RESET);
346TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_CONFIRM);
347TRACE_DEFINE_ENUM(NFS4CLNT_SERVER_SCOPE_MISMATCH);
348TRACE_DEFINE_ENUM(NFS4CLNT_PURGE_STATE);
349TRACE_DEFINE_ENUM(NFS4CLNT_BIND_CONN_TO_SESSION);
350TRACE_DEFINE_ENUM(NFS4CLNT_MOVED);
351TRACE_DEFINE_ENUM(NFS4CLNT_LEASE_MOVED);
352TRACE_DEFINE_ENUM(NFS4CLNT_DELEGATION_EXPIRED);
353TRACE_DEFINE_ENUM(NFS4CLNT_RUN_MANAGER);
354TRACE_DEFINE_ENUM(NFS4CLNT_MANAGER_AVAILABLE);
355TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_RUNNING);
356TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_READ);
357TRACE_DEFINE_ENUM(NFS4CLNT_RECALL_ANY_LAYOUT_RW);
358TRACE_DEFINE_ENUM(NFS4CLNT_DELEGRETURN_DELAYED);
359
360#define show_nfs4_clp_state(state) \
361 __print_flags(state, "|", \
362 { BIT(NFS4CLNT_MANAGER_RUNNING), "MANAGER_RUNNING" }, \
363 { BIT(NFS4CLNT_CHECK_LEASE), "CHECK_LEASE" }, \
364 { BIT(NFS4CLNT_LEASE_EXPIRED), "LEASE_EXPIRED" }, \
365 { BIT(NFS4CLNT_RECLAIM_REBOOT), "RECLAIM_REBOOT" }, \
366 { BIT(NFS4CLNT_RECLAIM_NOGRACE), "RECLAIM_NOGRACE" }, \
367 { BIT(NFS4CLNT_DELEGRETURN), "DELEGRETURN" }, \
368 { BIT(NFS4CLNT_SESSION_RESET), "SESSION_RESET" }, \
369 { BIT(NFS4CLNT_LEASE_CONFIRM), "LEASE_CONFIRM" }, \
370 { BIT(NFS4CLNT_SERVER_SCOPE_MISMATCH), "SERVER_SCOPE_MISMATCH" }, \
371 { BIT(NFS4CLNT_PURGE_STATE), "PURGE_STATE" }, \
372 { BIT(NFS4CLNT_BIND_CONN_TO_SESSION), "BIND_CONN_TO_SESSION" }, \
373 { BIT(NFS4CLNT_MOVED), "MOVED" }, \
374 { BIT(NFS4CLNT_LEASE_MOVED), "LEASE_MOVED" }, \
375 { BIT(NFS4CLNT_DELEGATION_EXPIRED), "DELEGATION_EXPIRED" }, \
376 { BIT(NFS4CLNT_RUN_MANAGER), "RUN_MANAGER" }, \
377 { BIT(NFS4CLNT_MANAGER_AVAILABLE), "MANAGER_AVAILABLE" }, \
378 { BIT(NFS4CLNT_RECALL_RUNNING), "RECALL_RUNNING" }, \
379 { BIT(NFS4CLNT_RECALL_ANY_LAYOUT_READ), "RECALL_ANY_LAYOUT_READ" }, \
380 { BIT(NFS4CLNT_RECALL_ANY_LAYOUT_RW), "RECALL_ANY_LAYOUT_RW" }, \
381 { BIT(NFS4CLNT_DELEGRETURN_DELAYED), "DELERETURN_DELAYED" })
382
383TRACE_EVENT(nfs4_state_mgr,
384 TP_PROTO(
385 const struct nfs_client *clp
386 ),
387
388 TP_ARGS(clp),
389
390 TP_STRUCT__entry(
391 __field(unsigned long, state)
392 __string(hostname, clp->cl_hostname)
393 ),
394
395 TP_fast_assign(
396 __entry->state = clp->cl_state;
397 __assign_str(hostname);
398 ),
399
400 TP_printk(
401 "hostname=%s clp state=%s", __get_str(hostname),
402 show_nfs4_clp_state(__entry->state)
403 )
404)
405
406TRACE_EVENT(nfs4_state_mgr_failed,
407 TP_PROTO(
408 const struct nfs_client *clp,
409 const char *section,
410 int status
411 ),
412
413 TP_ARGS(clp, section, status),
414
415 TP_STRUCT__entry(
416 __field(unsigned long, error)
417 __field(unsigned long, state)
418 __string(hostname, clp->cl_hostname)
419 __string(section, section)
420 ),
421
422 TP_fast_assign(
423 __entry->error = status < 0 ? -status : 0;
424 __entry->state = clp->cl_state;
425 __assign_str(hostname);
426 __assign_str(section);
427 ),
428
429 TP_printk(
430 "hostname=%s clp state=%s error=%ld (%s) section=%s",
431 __get_str(hostname),
432 show_nfs4_clp_state(__entry->state), -__entry->error,
433 show_nfs4_status(__entry->error), __get_str(section)
434
435 )
436)
437
438TRACE_EVENT(nfs4_xdr_bad_operation,
439 TP_PROTO(
440 const struct xdr_stream *xdr,
441 u32 op,
442 u32 expected
443 ),
444
445 TP_ARGS(xdr, op, expected),
446
447 TP_STRUCT__entry(
448 __field(unsigned int, task_id)
449 __field(unsigned int, client_id)
450 __field(u32, xid)
451 __field(u32, op)
452 __field(u32, expected)
453 ),
454
455 TP_fast_assign(
456 const struct rpc_rqst *rqstp = xdr->rqst;
457 const struct rpc_task *task = rqstp->rq_task;
458
459 __entry->task_id = task->tk_pid;
460 __entry->client_id = task->tk_client->cl_clid;
461 __entry->xid = be32_to_cpu(rqstp->rq_xid);
462 __entry->op = op;
463 __entry->expected = expected;
464 ),
465
466 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
467 " xid=0x%08x operation=%u, expected=%u",
468 __entry->task_id, __entry->client_id, __entry->xid,
469 __entry->op, __entry->expected
470 )
471);
472
473DECLARE_EVENT_CLASS(nfs4_xdr_event,
474 TP_PROTO(
475 const struct xdr_stream *xdr,
476 u32 op,
477 u32 error
478 ),
479
480 TP_ARGS(xdr, op, error),
481
482 TP_STRUCT__entry(
483 __field(unsigned int, task_id)
484 __field(unsigned int, client_id)
485 __field(u32, xid)
486 __field(u32, op)
487 __field(unsigned long, error)
488 ),
489
490 TP_fast_assign(
491 const struct rpc_rqst *rqstp = xdr->rqst;
492 const struct rpc_task *task = rqstp->rq_task;
493
494 __entry->task_id = task->tk_pid;
495 __entry->client_id = task->tk_client->cl_clid;
496 __entry->xid = be32_to_cpu(rqstp->rq_xid);
497 __entry->op = op;
498 __entry->error = error;
499 ),
500
501 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
502 " xid=0x%08x error=%ld (%s) operation=%u",
503 __entry->task_id, __entry->client_id, __entry->xid,
504 -__entry->error, show_nfs4_status(__entry->error),
505 __entry->op
506 )
507);
508#define DEFINE_NFS4_XDR_EVENT(name) \
509 DEFINE_EVENT(nfs4_xdr_event, name, \
510 TP_PROTO( \
511 const struct xdr_stream *xdr, \
512 u32 op, \
513 u32 error \
514 ), \
515 TP_ARGS(xdr, op, error))
516DEFINE_NFS4_XDR_EVENT(nfs4_xdr_status);
517DEFINE_NFS4_XDR_EVENT(nfs4_xdr_bad_filehandle);
518
519DECLARE_EVENT_CLASS(nfs4_cb_error_class,
520 TP_PROTO(
521 __be32 xid,
522 u32 cb_ident
523 ),
524
525 TP_ARGS(xid, cb_ident),
526
527 TP_STRUCT__entry(
528 __field(u32, xid)
529 __field(u32, cbident)
530 ),
531
532 TP_fast_assign(
533 __entry->xid = be32_to_cpu(xid);
534 __entry->cbident = cb_ident;
535 ),
536
537 TP_printk(
538 "xid=0x%08x cb_ident=0x%08x",
539 __entry->xid, __entry->cbident
540 )
541);
542
543#define DEFINE_CB_ERROR_EVENT(name) \
544 DEFINE_EVENT(nfs4_cb_error_class, nfs_cb_##name, \
545 TP_PROTO( \
546 __be32 xid, \
547 u32 cb_ident \
548 ), \
549 TP_ARGS(xid, cb_ident))
550
551DEFINE_CB_ERROR_EVENT(no_clp);
552DEFINE_CB_ERROR_EVENT(badprinc);
553
554DECLARE_EVENT_CLASS(nfs4_open_event,
555 TP_PROTO(
556 const struct nfs_open_context *ctx,
557 int flags,
558 int error
559 ),
560
561 TP_ARGS(ctx, flags, error),
562
563 TP_STRUCT__entry(
564 __field(unsigned long, error)
565 __field(unsigned long, flags)
566 __field(unsigned long, fmode)
567 __field(dev_t, dev)
568 __field(u32, fhandle)
569 __field(u64, fileid)
570 __field(u64, dir)
571 __string(name, ctx->dentry->d_name.name)
572 __field(int, stateid_seq)
573 __field(u32, stateid_hash)
574 __field(int, openstateid_seq)
575 __field(u32, openstateid_hash)
576 ),
577
578 TP_fast_assign(
579 const struct nfs4_state *state = ctx->state;
580 const struct inode *inode = NULL;
581
582 __entry->error = -error;
583 __entry->flags = flags;
584 __entry->fmode = (__force unsigned long)ctx->mode;
585 __entry->dev = ctx->dentry->d_sb->s_dev;
586 if (!IS_ERR_OR_NULL(state)) {
587 inode = state->inode;
588 __entry->stateid_seq =
589 be32_to_cpu(state->stateid.seqid);
590 __entry->stateid_hash =
591 nfs_stateid_hash(&state->stateid);
592 __entry->openstateid_seq =
593 be32_to_cpu(state->open_stateid.seqid);
594 __entry->openstateid_hash =
595 nfs_stateid_hash(&state->open_stateid);
596 } else {
597 __entry->stateid_seq = 0;
598 __entry->stateid_hash = 0;
599 __entry->openstateid_seq = 0;
600 __entry->openstateid_hash = 0;
601 }
602 if (inode != NULL) {
603 __entry->fileid = NFS_FILEID(inode);
604 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
605 } else {
606 __entry->fileid = 0;
607 __entry->fhandle = 0;
608 }
609 __entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent));
610 __assign_str(name);
611 ),
612
613 TP_printk(
614 "error=%ld (%s) flags=%lu (%s) fmode=%s "
615 "fileid=%02x:%02x:%llu fhandle=0x%08x "
616 "name=%02x:%02x:%llu/%s stateid=%d:0x%08x "
617 "openstateid=%d:0x%08x",
618 -__entry->error,
619 show_nfs4_status(__entry->error),
620 __entry->flags,
621 show_fs_fcntl_open_flags(__entry->flags),
622 show_fs_fmode_flags(__entry->fmode),
623 MAJOR(__entry->dev), MINOR(__entry->dev),
624 (unsigned long long)__entry->fileid,
625 __entry->fhandle,
626 MAJOR(__entry->dev), MINOR(__entry->dev),
627 (unsigned long long)__entry->dir,
628 __get_str(name),
629 __entry->stateid_seq, __entry->stateid_hash,
630 __entry->openstateid_seq, __entry->openstateid_hash
631 )
632);
633
634#define DEFINE_NFS4_OPEN_EVENT(name) \
635 DEFINE_EVENT(nfs4_open_event, name, \
636 TP_PROTO( \
637 const struct nfs_open_context *ctx, \
638 int flags, \
639 int error \
640 ), \
641 TP_ARGS(ctx, flags, error))
642DEFINE_NFS4_OPEN_EVENT(nfs4_open_reclaim);
643DEFINE_NFS4_OPEN_EVENT(nfs4_open_expired);
644DEFINE_NFS4_OPEN_EVENT(nfs4_open_file);
645
646TRACE_EVENT(nfs4_cached_open,
647 TP_PROTO(
648 const struct nfs4_state *state
649 ),
650 TP_ARGS(state),
651 TP_STRUCT__entry(
652 __field(dev_t, dev)
653 __field(u32, fhandle)
654 __field(u64, fileid)
655 __field(unsigned int, fmode)
656 __field(int, stateid_seq)
657 __field(u32, stateid_hash)
658 ),
659
660 TP_fast_assign(
661 const struct inode *inode = state->inode;
662
663 __entry->dev = inode->i_sb->s_dev;
664 __entry->fileid = NFS_FILEID(inode);
665 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
666 __entry->fmode = (__force unsigned int)state->state;
667 __entry->stateid_seq =
668 be32_to_cpu(state->stateid.seqid);
669 __entry->stateid_hash =
670 nfs_stateid_hash(&state->stateid);
671 ),
672
673 TP_printk(
674 "fmode=%s fileid=%02x:%02x:%llu "
675 "fhandle=0x%08x stateid=%d:0x%08x",
676 __entry->fmode ? show_fs_fmode_flags(__entry->fmode) :
677 "closed",
678 MAJOR(__entry->dev), MINOR(__entry->dev),
679 (unsigned long long)__entry->fileid,
680 __entry->fhandle,
681 __entry->stateid_seq, __entry->stateid_hash
682 )
683);
684
685TRACE_EVENT(nfs4_close,
686 TP_PROTO(
687 const struct nfs4_state *state,
688 const struct nfs_closeargs *args,
689 const struct nfs_closeres *res,
690 int error
691 ),
692
693 TP_ARGS(state, args, res, error),
694
695 TP_STRUCT__entry(
696 __field(dev_t, dev)
697 __field(u32, fhandle)
698 __field(u64, fileid)
699 __field(unsigned int, fmode)
700 __field(unsigned long, error)
701 __field(int, stateid_seq)
702 __field(u32, stateid_hash)
703 ),
704
705 TP_fast_assign(
706 const struct inode *inode = state->inode;
707
708 __entry->dev = inode->i_sb->s_dev;
709 __entry->fileid = NFS_FILEID(inode);
710 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
711 __entry->fmode = (__force unsigned int)state->state;
712 __entry->error = error < 0 ? -error : 0;
713 __entry->stateid_seq =
714 be32_to_cpu(args->stateid.seqid);
715 __entry->stateid_hash =
716 nfs_stateid_hash(&args->stateid);
717 ),
718
719 TP_printk(
720 "error=%ld (%s) fmode=%s fileid=%02x:%02x:%llu "
721 "fhandle=0x%08x openstateid=%d:0x%08x",
722 -__entry->error,
723 show_nfs4_status(__entry->error),
724 __entry->fmode ? show_fs_fmode_flags(__entry->fmode) :
725 "closed",
726 MAJOR(__entry->dev), MINOR(__entry->dev),
727 (unsigned long long)__entry->fileid,
728 __entry->fhandle,
729 __entry->stateid_seq, __entry->stateid_hash
730 )
731);
732
733DECLARE_EVENT_CLASS(nfs4_lock_event,
734 TP_PROTO(
735 const struct file_lock *request,
736 const struct nfs4_state *state,
737 int cmd,
738 int error
739 ),
740
741 TP_ARGS(request, state, cmd, error),
742
743 TP_STRUCT__entry(
744 __field(unsigned long, error)
745 __field(unsigned long, cmd)
746 __field(unsigned long, type)
747 __field(loff_t, start)
748 __field(loff_t, end)
749 __field(dev_t, dev)
750 __field(u32, fhandle)
751 __field(u64, fileid)
752 __field(int, stateid_seq)
753 __field(u32, stateid_hash)
754 ),
755
756 TP_fast_assign(
757 const struct inode *inode = state->inode;
758
759 __entry->error = error < 0 ? -error : 0;
760 __entry->cmd = cmd;
761 __entry->type = request->c.flc_type;
762 __entry->start = request->fl_start;
763 __entry->end = request->fl_end;
764 __entry->dev = inode->i_sb->s_dev;
765 __entry->fileid = NFS_FILEID(inode);
766 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
767 __entry->stateid_seq =
768 be32_to_cpu(state->stateid.seqid);
769 __entry->stateid_hash =
770 nfs_stateid_hash(&state->stateid);
771 ),
772
773 TP_printk(
774 "error=%ld (%s) cmd=%s:%s range=%lld:%lld "
775 "fileid=%02x:%02x:%llu fhandle=0x%08x "
776 "stateid=%d:0x%08x",
777 -__entry->error,
778 show_nfs4_status(__entry->error),
779 show_fs_fcntl_cmd(__entry->cmd),
780 show_fs_fcntl_lock_type(__entry->type),
781 (long long)__entry->start,
782 (long long)__entry->end,
783 MAJOR(__entry->dev), MINOR(__entry->dev),
784 (unsigned long long)__entry->fileid,
785 __entry->fhandle,
786 __entry->stateid_seq, __entry->stateid_hash
787 )
788);
789
790#define DEFINE_NFS4_LOCK_EVENT(name) \
791 DEFINE_EVENT(nfs4_lock_event, name, \
792 TP_PROTO( \
793 const struct file_lock *request, \
794 const struct nfs4_state *state, \
795 int cmd, \
796 int error \
797 ), \
798 TP_ARGS(request, state, cmd, error))
799DEFINE_NFS4_LOCK_EVENT(nfs4_get_lock);
800DEFINE_NFS4_LOCK_EVENT(nfs4_unlock);
801
802TRACE_EVENT(nfs4_set_lock,
803 TP_PROTO(
804 const struct file_lock *request,
805 const struct nfs4_state *state,
806 const nfs4_stateid *lockstateid,
807 int cmd,
808 int error
809 ),
810
811 TP_ARGS(request, state, lockstateid, cmd, error),
812
813 TP_STRUCT__entry(
814 __field(unsigned long, error)
815 __field(unsigned long, cmd)
816 __field(unsigned long, type)
817 __field(loff_t, start)
818 __field(loff_t, end)
819 __field(dev_t, dev)
820 __field(u32, fhandle)
821 __field(u64, fileid)
822 __field(int, stateid_seq)
823 __field(u32, stateid_hash)
824 __field(int, lockstateid_seq)
825 __field(u32, lockstateid_hash)
826 ),
827
828 TP_fast_assign(
829 const struct inode *inode = state->inode;
830
831 __entry->error = error < 0 ? -error : 0;
832 __entry->cmd = cmd;
833 __entry->type = request->c.flc_type;
834 __entry->start = request->fl_start;
835 __entry->end = request->fl_end;
836 __entry->dev = inode->i_sb->s_dev;
837 __entry->fileid = NFS_FILEID(inode);
838 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
839 __entry->stateid_seq =
840 be32_to_cpu(state->stateid.seqid);
841 __entry->stateid_hash =
842 nfs_stateid_hash(&state->stateid);
843 __entry->lockstateid_seq =
844 be32_to_cpu(lockstateid->seqid);
845 __entry->lockstateid_hash =
846 nfs_stateid_hash(lockstateid);
847 ),
848
849 TP_printk(
850 "error=%ld (%s) cmd=%s:%s range=%lld:%lld "
851 "fileid=%02x:%02x:%llu fhandle=0x%08x "
852 "stateid=%d:0x%08x lockstateid=%d:0x%08x",
853 -__entry->error,
854 show_nfs4_status(__entry->error),
855 show_fs_fcntl_cmd(__entry->cmd),
856 show_fs_fcntl_lock_type(__entry->type),
857 (long long)__entry->start,
858 (long long)__entry->end,
859 MAJOR(__entry->dev), MINOR(__entry->dev),
860 (unsigned long long)__entry->fileid,
861 __entry->fhandle,
862 __entry->stateid_seq, __entry->stateid_hash,
863 __entry->lockstateid_seq, __entry->lockstateid_hash
864 )
865);
866
867TRACE_DEFINE_ENUM(LK_STATE_IN_USE);
868TRACE_DEFINE_ENUM(NFS_DELEGATED_STATE);
869TRACE_DEFINE_ENUM(NFS_OPEN_STATE);
870TRACE_DEFINE_ENUM(NFS_O_RDONLY_STATE);
871TRACE_DEFINE_ENUM(NFS_O_WRONLY_STATE);
872TRACE_DEFINE_ENUM(NFS_O_RDWR_STATE);
873TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_REBOOT);
874TRACE_DEFINE_ENUM(NFS_STATE_RECLAIM_NOGRACE);
875TRACE_DEFINE_ENUM(NFS_STATE_POSIX_LOCKS);
876TRACE_DEFINE_ENUM(NFS_STATE_RECOVERY_FAILED);
877TRACE_DEFINE_ENUM(NFS_STATE_MAY_NOTIFY_LOCK);
878TRACE_DEFINE_ENUM(NFS_STATE_CHANGE_WAIT);
879TRACE_DEFINE_ENUM(NFS_CLNT_DST_SSC_COPY_STATE);
880TRACE_DEFINE_ENUM(NFS_CLNT_SRC_SSC_COPY_STATE);
881TRACE_DEFINE_ENUM(NFS_SRV_SSC_COPY_STATE);
882
883#define show_nfs4_state_flags(flags) \
884 __print_flags(flags, "|", \
885 { LK_STATE_IN_USE, "IN_USE" }, \
886 { NFS_DELEGATED_STATE, "DELEGATED" }, \
887 { NFS_OPEN_STATE, "OPEN" }, \
888 { NFS_O_RDONLY_STATE, "O_RDONLY" }, \
889 { NFS_O_WRONLY_STATE, "O_WRONLY" }, \
890 { NFS_O_RDWR_STATE, "O_RDWR" }, \
891 { NFS_STATE_RECLAIM_REBOOT, "RECLAIM_REBOOT" }, \
892 { NFS_STATE_RECLAIM_NOGRACE, "RECLAIM_NOGRACE" }, \
893 { NFS_STATE_POSIX_LOCKS, "POSIX_LOCKS" }, \
894 { NFS_STATE_RECOVERY_FAILED, "RECOVERY_FAILED" }, \
895 { NFS_STATE_MAY_NOTIFY_LOCK, "MAY_NOTIFY_LOCK" }, \
896 { NFS_STATE_CHANGE_WAIT, "CHANGE_WAIT" }, \
897 { NFS_CLNT_DST_SSC_COPY_STATE, "CLNT_DST_SSC_COPY" }, \
898 { NFS_CLNT_SRC_SSC_COPY_STATE, "CLNT_SRC_SSC_COPY" }, \
899 { NFS_SRV_SSC_COPY_STATE, "SRV_SSC_COPY" })
900
901#define show_nfs4_lock_flags(flags) \
902 __print_flags(flags, "|", \
903 { BIT(NFS_LOCK_INITIALIZED), "INITIALIZED" }, \
904 { BIT(NFS_LOCK_LOST), "LOST" })
905
906TRACE_EVENT(nfs4_state_lock_reclaim,
907 TP_PROTO(
908 const struct nfs4_state *state,
909 const struct nfs4_lock_state *lock
910 ),
911
912 TP_ARGS(state, lock),
913
914 TP_STRUCT__entry(
915 __field(dev_t, dev)
916 __field(u32, fhandle)
917 __field(u64, fileid)
918 __field(unsigned long, state_flags)
919 __field(unsigned long, lock_flags)
920 __field(int, stateid_seq)
921 __field(u32, stateid_hash)
922 ),
923
924 TP_fast_assign(
925 const struct inode *inode = state->inode;
926
927 __entry->dev = inode->i_sb->s_dev;
928 __entry->fileid = NFS_FILEID(inode);
929 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
930 __entry->state_flags = state->flags;
931 __entry->lock_flags = lock->ls_flags;
932 __entry->stateid_seq =
933 be32_to_cpu(state->stateid.seqid);
934 __entry->stateid_hash =
935 nfs_stateid_hash(&state->stateid);
936 ),
937
938 TP_printk(
939 "fileid=%02x:%02x:%llu fhandle=0x%08x "
940 "stateid=%d:0x%08x state_flags=%s lock_flags=%s",
941 MAJOR(__entry->dev), MINOR(__entry->dev),
942 (unsigned long long)__entry->fileid, __entry->fhandle,
943 __entry->stateid_seq, __entry->stateid_hash,
944 show_nfs4_state_flags(__entry->state_flags),
945 show_nfs4_lock_flags(__entry->lock_flags)
946 )
947)
948
949DECLARE_EVENT_CLASS(nfs4_set_delegation_event,
950 TP_PROTO(
951 const struct inode *inode,
952 fmode_t fmode
953 ),
954
955 TP_ARGS(inode, fmode),
956
957 TP_STRUCT__entry(
958 __field(dev_t, dev)
959 __field(u32, fhandle)
960 __field(u64, fileid)
961 __field(unsigned int, fmode)
962 ),
963
964 TP_fast_assign(
965 __entry->dev = inode->i_sb->s_dev;
966 __entry->fileid = NFS_FILEID(inode);
967 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
968 __entry->fmode = (__force unsigned int)fmode;
969 ),
970
971 TP_printk(
972 "fmode=%s fileid=%02x:%02x:%llu fhandle=0x%08x",
973 show_fs_fmode_flags(__entry->fmode),
974 MAJOR(__entry->dev), MINOR(__entry->dev),
975 (unsigned long long)__entry->fileid,
976 __entry->fhandle
977 )
978);
979#define DEFINE_NFS4_SET_DELEGATION_EVENT(name) \
980 DEFINE_EVENT(nfs4_set_delegation_event, name, \
981 TP_PROTO( \
982 const struct inode *inode, \
983 fmode_t fmode \
984 ), \
985 TP_ARGS(inode, fmode))
986DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_set_delegation);
987DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_reclaim_delegation);
988DEFINE_NFS4_SET_DELEGATION_EVENT(nfs4_detach_delegation);
989
990#define show_delegation_flags(flags) \
991 __print_flags(flags, "|", \
992 { BIT(NFS_DELEGATION_NEED_RECLAIM), "NEED_RECLAIM" }, \
993 { BIT(NFS_DELEGATION_RETURN), "RETURN" }, \
994 { BIT(NFS_DELEGATION_RETURN_IF_CLOSED), "RETURN_IF_CLOSED" }, \
995 { BIT(NFS_DELEGATION_REFERENCED), "REFERENCED" }, \
996 { BIT(NFS_DELEGATION_RETURNING), "RETURNING" }, \
997 { BIT(NFS_DELEGATION_REVOKED), "REVOKED" }, \
998 { BIT(NFS_DELEGATION_TEST_EXPIRED), "TEST_EXPIRED" }, \
999 { BIT(NFS_DELEGATION_INODE_FREEING), "INODE_FREEING" }, \
1000 { BIT(NFS_DELEGATION_RETURN_DELAYED), "RETURN_DELAYED" })
1001
1002DECLARE_EVENT_CLASS(nfs4_delegation_event,
1003 TP_PROTO(
1004 const struct nfs_delegation *delegation
1005 ),
1006
1007 TP_ARGS(delegation),
1008
1009 TP_STRUCT__entry(
1010 __field(u32, fhandle)
1011 __field(unsigned int, fmode)
1012 __field(unsigned long, flags)
1013 ),
1014
1015 TP_fast_assign(
1016 __entry->fhandle = nfs_fhandle_hash(NFS_FH(delegation->inode));
1017 __entry->fmode = delegation->type;
1018 __entry->flags = delegation->flags;
1019 ),
1020
1021 TP_printk(
1022 "fhandle=0x%08x fmode=%s flags=%s",
1023 __entry->fhandle, show_fs_fmode_flags(__entry->fmode),
1024 show_delegation_flags(__entry->flags)
1025 )
1026);
1027#define DEFINE_NFS4_DELEGATION_EVENT(name) \
1028 DEFINE_EVENT(nfs4_delegation_event, name, \
1029 TP_PROTO( \
1030 const struct nfs_delegation *delegation \
1031 ), \
1032 TP_ARGS(delegation))
1033DEFINE_NFS4_DELEGATION_EVENT(nfs_delegation_need_return);
1034
1035TRACE_EVENT(nfs4_delegreturn_exit,
1036 TP_PROTO(
1037 const struct nfs4_delegreturnargs *args,
1038 const struct nfs4_delegreturnres *res,
1039 int error
1040 ),
1041
1042 TP_ARGS(args, res, error),
1043
1044 TP_STRUCT__entry(
1045 __field(dev_t, dev)
1046 __field(u32, fhandle)
1047 __field(unsigned long, error)
1048 __field(int, stateid_seq)
1049 __field(u32, stateid_hash)
1050 ),
1051
1052 TP_fast_assign(
1053 __entry->dev = res->server->s_dev;
1054 __entry->fhandle = nfs_fhandle_hash(args->fhandle);
1055 __entry->error = error < 0 ? -error : 0;
1056 __entry->stateid_seq =
1057 be32_to_cpu(args->stateid->seqid);
1058 __entry->stateid_hash =
1059 nfs_stateid_hash(args->stateid);
1060 ),
1061
1062 TP_printk(
1063 "error=%ld (%s) dev=%02x:%02x fhandle=0x%08x "
1064 "stateid=%d:0x%08x",
1065 -__entry->error,
1066 show_nfs4_status(__entry->error),
1067 MAJOR(__entry->dev), MINOR(__entry->dev),
1068 __entry->fhandle,
1069 __entry->stateid_seq, __entry->stateid_hash
1070 )
1071);
1072
1073#ifdef CONFIG_NFS_V4_1
1074DECLARE_EVENT_CLASS(nfs4_test_stateid_event,
1075 TP_PROTO(
1076 const struct nfs4_state *state,
1077 const struct nfs4_lock_state *lsp,
1078 int error
1079 ),
1080
1081 TP_ARGS(state, lsp, error),
1082
1083 TP_STRUCT__entry(
1084 __field(unsigned long, error)
1085 __field(dev_t, dev)
1086 __field(u32, fhandle)
1087 __field(u64, fileid)
1088 __field(int, stateid_seq)
1089 __field(u32, stateid_hash)
1090 ),
1091
1092 TP_fast_assign(
1093 const struct inode *inode = state->inode;
1094
1095 __entry->error = error < 0 ? -error : 0;
1096 __entry->dev = inode->i_sb->s_dev;
1097 __entry->fileid = NFS_FILEID(inode);
1098 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1099 __entry->stateid_seq =
1100 be32_to_cpu(state->stateid.seqid);
1101 __entry->stateid_hash =
1102 nfs_stateid_hash(&state->stateid);
1103 ),
1104
1105 TP_printk(
1106 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1107 "stateid=%d:0x%08x",
1108 -__entry->error,
1109 show_nfs4_status(__entry->error),
1110 MAJOR(__entry->dev), MINOR(__entry->dev),
1111 (unsigned long long)__entry->fileid,
1112 __entry->fhandle,
1113 __entry->stateid_seq, __entry->stateid_hash
1114 )
1115);
1116
1117#define DEFINE_NFS4_TEST_STATEID_EVENT(name) \
1118 DEFINE_EVENT(nfs4_test_stateid_event, name, \
1119 TP_PROTO( \
1120 const struct nfs4_state *state, \
1121 const struct nfs4_lock_state *lsp, \
1122 int error \
1123 ), \
1124 TP_ARGS(state, lsp, error))
1125DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_delegation_stateid);
1126DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_open_stateid);
1127DEFINE_NFS4_TEST_STATEID_EVENT(nfs4_test_lock_stateid);
1128#endif /* CONFIG_NFS_V4_1 */
1129
1130DECLARE_EVENT_CLASS(nfs4_lookup_event,
1131 TP_PROTO(
1132 const struct inode *dir,
1133 const struct qstr *name,
1134 int error
1135 ),
1136
1137 TP_ARGS(dir, name, error),
1138
1139 TP_STRUCT__entry(
1140 __field(dev_t, dev)
1141 __field(unsigned long, error)
1142 __field(u64, dir)
1143 __string(name, name->name)
1144 ),
1145
1146 TP_fast_assign(
1147 __entry->dev = dir->i_sb->s_dev;
1148 __entry->dir = NFS_FILEID(dir);
1149 __entry->error = -error;
1150 __assign_str(name);
1151 ),
1152
1153 TP_printk(
1154 "error=%ld (%s) name=%02x:%02x:%llu/%s",
1155 -__entry->error,
1156 show_nfs4_status(__entry->error),
1157 MAJOR(__entry->dev), MINOR(__entry->dev),
1158 (unsigned long long)__entry->dir,
1159 __get_str(name)
1160 )
1161);
1162
1163#define DEFINE_NFS4_LOOKUP_EVENT(name) \
1164 DEFINE_EVENT(nfs4_lookup_event, name, \
1165 TP_PROTO( \
1166 const struct inode *dir, \
1167 const struct qstr *name, \
1168 int error \
1169 ), \
1170 TP_ARGS(dir, name, error))
1171
1172DEFINE_NFS4_LOOKUP_EVENT(nfs4_lookup);
1173DEFINE_NFS4_LOOKUP_EVENT(nfs4_symlink);
1174DEFINE_NFS4_LOOKUP_EVENT(nfs4_mkdir);
1175DEFINE_NFS4_LOOKUP_EVENT(nfs4_mknod);
1176DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove);
1177DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
1178DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
1179
1180TRACE_EVENT(nfs4_lookupp,
1181 TP_PROTO(
1182 const struct inode *inode,
1183 int error
1184 ),
1185
1186 TP_ARGS(inode, error),
1187
1188 TP_STRUCT__entry(
1189 __field(dev_t, dev)
1190 __field(u64, ino)
1191 __field(unsigned long, error)
1192 ),
1193
1194 TP_fast_assign(
1195 __entry->dev = inode->i_sb->s_dev;
1196 __entry->ino = NFS_FILEID(inode);
1197 __entry->error = error < 0 ? -error : 0;
1198 ),
1199
1200 TP_printk(
1201 "error=%ld (%s) inode=%02x:%02x:%llu",
1202 -__entry->error,
1203 show_nfs4_status(__entry->error),
1204 MAJOR(__entry->dev), MINOR(__entry->dev),
1205 (unsigned long long)__entry->ino
1206 )
1207);
1208
1209TRACE_EVENT(nfs4_rename,
1210 TP_PROTO(
1211 const struct inode *olddir,
1212 const struct qstr *oldname,
1213 const struct inode *newdir,
1214 const struct qstr *newname,
1215 int error
1216 ),
1217
1218 TP_ARGS(olddir, oldname, newdir, newname, error),
1219
1220 TP_STRUCT__entry(
1221 __field(dev_t, dev)
1222 __field(unsigned long, error)
1223 __field(u64, olddir)
1224 __string(oldname, oldname->name)
1225 __field(u64, newdir)
1226 __string(newname, newname->name)
1227 ),
1228
1229 TP_fast_assign(
1230 __entry->dev = olddir->i_sb->s_dev;
1231 __entry->olddir = NFS_FILEID(olddir);
1232 __entry->newdir = NFS_FILEID(newdir);
1233 __entry->error = error < 0 ? -error : 0;
1234 __assign_str(oldname);
1235 __assign_str(newname);
1236 ),
1237
1238 TP_printk(
1239 "error=%ld (%s) oldname=%02x:%02x:%llu/%s "
1240 "newname=%02x:%02x:%llu/%s",
1241 -__entry->error,
1242 show_nfs4_status(__entry->error),
1243 MAJOR(__entry->dev), MINOR(__entry->dev),
1244 (unsigned long long)__entry->olddir,
1245 __get_str(oldname),
1246 MAJOR(__entry->dev), MINOR(__entry->dev),
1247 (unsigned long long)__entry->newdir,
1248 __get_str(newname)
1249 )
1250);
1251
1252DECLARE_EVENT_CLASS(nfs4_inode_event,
1253 TP_PROTO(
1254 const struct inode *inode,
1255 int error
1256 ),
1257
1258 TP_ARGS(inode, error),
1259
1260 TP_STRUCT__entry(
1261 __field(dev_t, dev)
1262 __field(u32, fhandle)
1263 __field(u64, fileid)
1264 __field(unsigned long, error)
1265 ),
1266
1267 TP_fast_assign(
1268 __entry->dev = inode->i_sb->s_dev;
1269 __entry->fileid = NFS_FILEID(inode);
1270 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1271 __entry->error = error < 0 ? -error : 0;
1272 ),
1273
1274 TP_printk(
1275 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x",
1276 -__entry->error,
1277 show_nfs4_status(__entry->error),
1278 MAJOR(__entry->dev), MINOR(__entry->dev),
1279 (unsigned long long)__entry->fileid,
1280 __entry->fhandle
1281 )
1282);
1283
1284#define DEFINE_NFS4_INODE_EVENT(name) \
1285 DEFINE_EVENT(nfs4_inode_event, name, \
1286 TP_PROTO( \
1287 const struct inode *inode, \
1288 int error \
1289 ), \
1290 TP_ARGS(inode, error))
1291
1292DEFINE_NFS4_INODE_EVENT(nfs4_access);
1293DEFINE_NFS4_INODE_EVENT(nfs4_readlink);
1294DEFINE_NFS4_INODE_EVENT(nfs4_readdir);
1295DEFINE_NFS4_INODE_EVENT(nfs4_get_acl);
1296DEFINE_NFS4_INODE_EVENT(nfs4_set_acl);
1297#ifdef CONFIG_NFS_V4_SECURITY_LABEL
1298DEFINE_NFS4_INODE_EVENT(nfs4_get_security_label);
1299DEFINE_NFS4_INODE_EVENT(nfs4_set_security_label);
1300#endif /* CONFIG_NFS_V4_SECURITY_LABEL */
1301
1302DECLARE_EVENT_CLASS(nfs4_inode_stateid_event,
1303 TP_PROTO(
1304 const struct inode *inode,
1305 const nfs4_stateid *stateid,
1306 int error
1307 ),
1308
1309 TP_ARGS(inode, stateid, error),
1310
1311 TP_STRUCT__entry(
1312 __field(dev_t, dev)
1313 __field(u32, fhandle)
1314 __field(u64, fileid)
1315 __field(unsigned long, error)
1316 __field(int, stateid_seq)
1317 __field(u32, stateid_hash)
1318 ),
1319
1320 TP_fast_assign(
1321 __entry->dev = inode->i_sb->s_dev;
1322 __entry->fileid = NFS_FILEID(inode);
1323 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1324 __entry->error = error < 0 ? -error : 0;
1325 __entry->stateid_seq =
1326 be32_to_cpu(stateid->seqid);
1327 __entry->stateid_hash =
1328 nfs_stateid_hash(stateid);
1329 ),
1330
1331 TP_printk(
1332 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1333 "stateid=%d:0x%08x",
1334 -__entry->error,
1335 show_nfs4_status(__entry->error),
1336 MAJOR(__entry->dev), MINOR(__entry->dev),
1337 (unsigned long long)__entry->fileid,
1338 __entry->fhandle,
1339 __entry->stateid_seq, __entry->stateid_hash
1340 )
1341);
1342
1343#define DEFINE_NFS4_INODE_STATEID_EVENT(name) \
1344 DEFINE_EVENT(nfs4_inode_stateid_event, name, \
1345 TP_PROTO( \
1346 const struct inode *inode, \
1347 const nfs4_stateid *stateid, \
1348 int error \
1349 ), \
1350 TP_ARGS(inode, stateid, error))
1351
1352DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_setattr);
1353DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_delegreturn);
1354DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update);
1355DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_open_stateid_update_wait);
1356DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_close_stateid_update_wait);
1357
1358DECLARE_EVENT_CLASS(nfs4_getattr_event,
1359 TP_PROTO(
1360 const struct nfs_server *server,
1361 const struct nfs_fh *fhandle,
1362 const struct nfs_fattr *fattr,
1363 int error
1364 ),
1365
1366 TP_ARGS(server, fhandle, fattr, error),
1367
1368 TP_STRUCT__entry(
1369 __field(dev_t, dev)
1370 __field(u32, fhandle)
1371 __field(u64, fileid)
1372 __field(unsigned int, valid)
1373 __field(unsigned long, error)
1374 ),
1375
1376 TP_fast_assign(
1377 __entry->dev = server->s_dev;
1378 __entry->valid = fattr->valid;
1379 __entry->fhandle = nfs_fhandle_hash(fhandle);
1380 __entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0;
1381 __entry->error = error < 0 ? -error : 0;
1382 ),
1383
1384 TP_printk(
1385 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1386 "valid=%s",
1387 -__entry->error,
1388 show_nfs4_status(__entry->error),
1389 MAJOR(__entry->dev), MINOR(__entry->dev),
1390 (unsigned long long)__entry->fileid,
1391 __entry->fhandle,
1392 show_nfs_fattr_flags(__entry->valid)
1393 )
1394);
1395
1396#define DEFINE_NFS4_GETATTR_EVENT(name) \
1397 DEFINE_EVENT(nfs4_getattr_event, name, \
1398 TP_PROTO( \
1399 const struct nfs_server *server, \
1400 const struct nfs_fh *fhandle, \
1401 const struct nfs_fattr *fattr, \
1402 int error \
1403 ), \
1404 TP_ARGS(server, fhandle, fattr, error))
1405DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr);
1406DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root);
1407DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo);
1408
1409DECLARE_EVENT_CLASS(nfs4_inode_callback_event,
1410 TP_PROTO(
1411 const struct nfs_client *clp,
1412 const struct nfs_fh *fhandle,
1413 const struct inode *inode,
1414 int error
1415 ),
1416
1417 TP_ARGS(clp, fhandle, inode, error),
1418
1419 TP_STRUCT__entry(
1420 __field(unsigned long, error)
1421 __field(dev_t, dev)
1422 __field(u32, fhandle)
1423 __field(u64, fileid)
1424 __string(dstaddr, clp ? clp->cl_hostname : "unknown")
1425 ),
1426
1427 TP_fast_assign(
1428 __entry->error = error < 0 ? -error : 0;
1429 __entry->fhandle = nfs_fhandle_hash(fhandle);
1430 if (!IS_ERR_OR_NULL(inode)) {
1431 __entry->fileid = NFS_FILEID(inode);
1432 __entry->dev = inode->i_sb->s_dev;
1433 } else {
1434 __entry->fileid = 0;
1435 __entry->dev = 0;
1436 }
1437 __assign_str(dstaddr);
1438 ),
1439
1440 TP_printk(
1441 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1442 "dstaddr=%s",
1443 -__entry->error,
1444 show_nfs4_status(__entry->error),
1445 MAJOR(__entry->dev), MINOR(__entry->dev),
1446 (unsigned long long)__entry->fileid,
1447 __entry->fhandle,
1448 __get_str(dstaddr)
1449 )
1450);
1451
1452#define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \
1453 DEFINE_EVENT(nfs4_inode_callback_event, name, \
1454 TP_PROTO( \
1455 const struct nfs_client *clp, \
1456 const struct nfs_fh *fhandle, \
1457 const struct inode *inode, \
1458 int error \
1459 ), \
1460 TP_ARGS(clp, fhandle, inode, error))
1461DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr);
1462
1463DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event,
1464 TP_PROTO(
1465 const struct nfs_client *clp,
1466 const struct nfs_fh *fhandle,
1467 const struct inode *inode,
1468 const nfs4_stateid *stateid,
1469 int error
1470 ),
1471
1472 TP_ARGS(clp, fhandle, inode, stateid, error),
1473
1474 TP_STRUCT__entry(
1475 __field(unsigned long, error)
1476 __field(dev_t, dev)
1477 __field(u32, fhandle)
1478 __field(u64, fileid)
1479 __string(dstaddr, clp ? clp->cl_hostname : "unknown")
1480 __field(int, stateid_seq)
1481 __field(u32, stateid_hash)
1482 ),
1483
1484 TP_fast_assign(
1485 __entry->error = error < 0 ? -error : 0;
1486 __entry->fhandle = nfs_fhandle_hash(fhandle);
1487 if (!IS_ERR_OR_NULL(inode)) {
1488 __entry->fileid = NFS_FILEID(inode);
1489 __entry->dev = inode->i_sb->s_dev;
1490 } else {
1491 __entry->fileid = 0;
1492 __entry->dev = 0;
1493 }
1494 __assign_str(dstaddr);
1495 __entry->stateid_seq =
1496 be32_to_cpu(stateid->seqid);
1497 __entry->stateid_hash =
1498 nfs_stateid_hash(stateid);
1499 ),
1500
1501 TP_printk(
1502 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1503 "stateid=%d:0x%08x dstaddr=%s",
1504 -__entry->error,
1505 show_nfs4_status(__entry->error),
1506 MAJOR(__entry->dev), MINOR(__entry->dev),
1507 (unsigned long long)__entry->fileid,
1508 __entry->fhandle,
1509 __entry->stateid_seq, __entry->stateid_hash,
1510 __get_str(dstaddr)
1511 )
1512);
1513
1514#define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \
1515 DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \
1516 TP_PROTO( \
1517 const struct nfs_client *clp, \
1518 const struct nfs_fh *fhandle, \
1519 const struct inode *inode, \
1520 const nfs4_stateid *stateid, \
1521 int error \
1522 ), \
1523 TP_ARGS(clp, fhandle, inode, stateid, error))
1524DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall);
1525DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file);
1526
1527#define show_stateid_type(type) \
1528 __print_symbolic(type, \
1529 { NFS4_INVALID_STATEID_TYPE, "INVALID" }, \
1530 { NFS4_SPECIAL_STATEID_TYPE, "SPECIAL" }, \
1531 { NFS4_OPEN_STATEID_TYPE, "OPEN" }, \
1532 { NFS4_LOCK_STATEID_TYPE, "LOCK" }, \
1533 { NFS4_DELEGATION_STATEID_TYPE, "DELEGATION" }, \
1534 { NFS4_LAYOUT_STATEID_TYPE, "LAYOUT" }, \
1535 { NFS4_PNFS_DS_STATEID_TYPE, "PNFS_DS" }, \
1536 { NFS4_REVOKED_STATEID_TYPE, "REVOKED" }, \
1537 { NFS4_FREED_STATEID_TYPE, "FREED" })
1538
1539DECLARE_EVENT_CLASS(nfs4_match_stateid_event,
1540 TP_PROTO(
1541 const nfs4_stateid *s1,
1542 const nfs4_stateid *s2
1543 ),
1544
1545 TP_ARGS(s1, s2),
1546
1547 TP_STRUCT__entry(
1548 __field(int, s1_seq)
1549 __field(int, s2_seq)
1550 __field(u32, s1_hash)
1551 __field(u32, s2_hash)
1552 __field(int, s1_type)
1553 __field(int, s2_type)
1554 ),
1555
1556 TP_fast_assign(
1557 __entry->s1_seq = s1->seqid;
1558 __entry->s1_hash = nfs_stateid_hash(s1);
1559 __entry->s1_type = s1->type;
1560 __entry->s2_seq = s2->seqid;
1561 __entry->s2_hash = nfs_stateid_hash(s2);
1562 __entry->s2_type = s2->type;
1563 ),
1564
1565 TP_printk(
1566 "s1=%s:%x:%u s2=%s:%x:%u",
1567 show_stateid_type(__entry->s1_type),
1568 __entry->s1_hash, __entry->s1_seq,
1569 show_stateid_type(__entry->s2_type),
1570 __entry->s2_hash, __entry->s2_seq
1571 )
1572);
1573
1574#define DEFINE_NFS4_MATCH_STATEID_EVENT(name) \
1575 DEFINE_EVENT(nfs4_match_stateid_event, name, \
1576 TP_PROTO( \
1577 const nfs4_stateid *s1, \
1578 const nfs4_stateid *s2 \
1579 ), \
1580 TP_ARGS(s1, s2))
1581DEFINE_NFS4_MATCH_STATEID_EVENT(nfs41_match_stateid);
1582DEFINE_NFS4_MATCH_STATEID_EVENT(nfs4_match_stateid);
1583
1584DECLARE_EVENT_CLASS(nfs4_idmap_event,
1585 TP_PROTO(
1586 const char *name,
1587 int len,
1588 u32 id,
1589 int error
1590 ),
1591
1592 TP_ARGS(name, len, id, error),
1593
1594 TP_STRUCT__entry(
1595 __field(unsigned long, error)
1596 __field(u32, id)
1597 __dynamic_array(char, name, len > 0 ? len + 1 : 1)
1598 ),
1599
1600 TP_fast_assign(
1601 if (len < 0)
1602 len = 0;
1603 __entry->error = error < 0 ? error : 0;
1604 __entry->id = id;
1605 memcpy(__get_str(name), name, len);
1606 __get_str(name)[len] = 0;
1607 ),
1608
1609 TP_printk(
1610 "error=%ld (%s) id=%u name=%s",
1611 -__entry->error, show_nfs4_status(__entry->error),
1612 __entry->id,
1613 __get_str(name)
1614 )
1615);
1616#define DEFINE_NFS4_IDMAP_EVENT(name) \
1617 DEFINE_EVENT(nfs4_idmap_event, name, \
1618 TP_PROTO( \
1619 const char *name, \
1620 int len, \
1621 u32 id, \
1622 int error \
1623 ), \
1624 TP_ARGS(name, len, id, error))
1625DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid);
1626DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
1627DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
1628DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
1629
1630#ifdef CONFIG_NFS_V4_1
1631#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \
1632 (lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0)
1633#else
1634#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0)
1635#endif
1636
1637DECLARE_EVENT_CLASS(nfs4_read_event,
1638 TP_PROTO(
1639 const struct nfs_pgio_header *hdr,
1640 int error
1641 ),
1642
1643 TP_ARGS(hdr, error),
1644
1645 TP_STRUCT__entry(
1646 __field(dev_t, dev)
1647 __field(u32, fhandle)
1648 __field(u64, fileid)
1649 __field(loff_t, offset)
1650 __field(u32, arg_count)
1651 __field(u32, res_count)
1652 __field(unsigned long, error)
1653 __field(int, stateid_seq)
1654 __field(u32, stateid_hash)
1655 __field(int, layoutstateid_seq)
1656 __field(u32, layoutstateid_hash)
1657 ),
1658
1659 TP_fast_assign(
1660 const struct inode *inode = hdr->inode;
1661 const struct nfs_inode *nfsi = NFS_I(inode);
1662 const struct nfs_fh *fh = hdr->args.fh ?
1663 hdr->args.fh : &nfsi->fh;
1664 const struct nfs4_state *state =
1665 hdr->args.context->state;
1666 const struct pnfs_layout_segment *lseg = hdr->lseg;
1667
1668 __entry->dev = inode->i_sb->s_dev;
1669 __entry->fileid = nfsi->fileid;
1670 __entry->fhandle = nfs_fhandle_hash(fh);
1671 __entry->offset = hdr->args.offset;
1672 __entry->arg_count = hdr->args.count;
1673 __entry->res_count = hdr->res.count;
1674 __entry->error = error < 0 ? -error : 0;
1675 __entry->stateid_seq =
1676 be32_to_cpu(state->stateid.seqid);
1677 __entry->stateid_hash =
1678 nfs_stateid_hash(&state->stateid);
1679 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1680 __entry->layoutstateid_hash =
1681 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1682 ),
1683
1684 TP_printk(
1685 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1686 "offset=%lld count=%u res=%u stateid=%d:0x%08x "
1687 "layoutstateid=%d:0x%08x",
1688 -__entry->error,
1689 show_nfs4_status(__entry->error),
1690 MAJOR(__entry->dev), MINOR(__entry->dev),
1691 (unsigned long long)__entry->fileid,
1692 __entry->fhandle,
1693 (long long)__entry->offset,
1694 __entry->arg_count, __entry->res_count,
1695 __entry->stateid_seq, __entry->stateid_hash,
1696 __entry->layoutstateid_seq, __entry->layoutstateid_hash
1697 )
1698);
1699#define DEFINE_NFS4_READ_EVENT(name) \
1700 DEFINE_EVENT(nfs4_read_event, name, \
1701 TP_PROTO( \
1702 const struct nfs_pgio_header *hdr, \
1703 int error \
1704 ), \
1705 TP_ARGS(hdr, error))
1706DEFINE_NFS4_READ_EVENT(nfs4_read);
1707#ifdef CONFIG_NFS_V4_1
1708DEFINE_NFS4_READ_EVENT(nfs4_pnfs_read);
1709#endif /* CONFIG_NFS_V4_1 */
1710
1711DECLARE_EVENT_CLASS(nfs4_write_event,
1712 TP_PROTO(
1713 const struct nfs_pgio_header *hdr,
1714 int error
1715 ),
1716
1717 TP_ARGS(hdr, error),
1718
1719 TP_STRUCT__entry(
1720 __field(dev_t, dev)
1721 __field(u32, fhandle)
1722 __field(u64, fileid)
1723 __field(loff_t, offset)
1724 __field(u32, arg_count)
1725 __field(u32, res_count)
1726 __field(unsigned long, error)
1727 __field(int, stateid_seq)
1728 __field(u32, stateid_hash)
1729 __field(int, layoutstateid_seq)
1730 __field(u32, layoutstateid_hash)
1731 ),
1732
1733 TP_fast_assign(
1734 const struct inode *inode = hdr->inode;
1735 const struct nfs_inode *nfsi = NFS_I(inode);
1736 const struct nfs_fh *fh = hdr->args.fh ?
1737 hdr->args.fh : &nfsi->fh;
1738 const struct nfs4_state *state =
1739 hdr->args.context->state;
1740 const struct pnfs_layout_segment *lseg = hdr->lseg;
1741
1742 __entry->dev = inode->i_sb->s_dev;
1743 __entry->fileid = nfsi->fileid;
1744 __entry->fhandle = nfs_fhandle_hash(fh);
1745 __entry->offset = hdr->args.offset;
1746 __entry->arg_count = hdr->args.count;
1747 __entry->res_count = hdr->res.count;
1748 __entry->error = error < 0 ? -error : 0;
1749 __entry->stateid_seq =
1750 be32_to_cpu(state->stateid.seqid);
1751 __entry->stateid_hash =
1752 nfs_stateid_hash(&state->stateid);
1753 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1754 __entry->layoutstateid_hash =
1755 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1756 ),
1757
1758 TP_printk(
1759 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1760 "offset=%lld count=%u res=%u stateid=%d:0x%08x "
1761 "layoutstateid=%d:0x%08x",
1762 -__entry->error,
1763 show_nfs4_status(__entry->error),
1764 MAJOR(__entry->dev), MINOR(__entry->dev),
1765 (unsigned long long)__entry->fileid,
1766 __entry->fhandle,
1767 (long long)__entry->offset,
1768 __entry->arg_count, __entry->res_count,
1769 __entry->stateid_seq, __entry->stateid_hash,
1770 __entry->layoutstateid_seq, __entry->layoutstateid_hash
1771 )
1772);
1773
1774#define DEFINE_NFS4_WRITE_EVENT(name) \
1775 DEFINE_EVENT(nfs4_write_event, name, \
1776 TP_PROTO( \
1777 const struct nfs_pgio_header *hdr, \
1778 int error \
1779 ), \
1780 TP_ARGS(hdr, error))
1781DEFINE_NFS4_WRITE_EVENT(nfs4_write);
1782#ifdef CONFIG_NFS_V4_1
1783DEFINE_NFS4_WRITE_EVENT(nfs4_pnfs_write);
1784#endif /* CONFIG_NFS_V4_1 */
1785
1786DECLARE_EVENT_CLASS(nfs4_commit_event,
1787 TP_PROTO(
1788 const struct nfs_commit_data *data,
1789 int error
1790 ),
1791
1792 TP_ARGS(data, error),
1793
1794 TP_STRUCT__entry(
1795 __field(dev_t, dev)
1796 __field(u32, fhandle)
1797 __field(u64, fileid)
1798 __field(unsigned long, error)
1799 __field(loff_t, offset)
1800 __field(u32, count)
1801 __field(int, layoutstateid_seq)
1802 __field(u32, layoutstateid_hash)
1803 ),
1804
1805 TP_fast_assign(
1806 const struct inode *inode = data->inode;
1807 const struct nfs_inode *nfsi = NFS_I(inode);
1808 const struct nfs_fh *fh = data->args.fh ?
1809 data->args.fh : &nfsi->fh;
1810 const struct pnfs_layout_segment *lseg = data->lseg;
1811
1812 __entry->dev = inode->i_sb->s_dev;
1813 __entry->fileid = nfsi->fileid;
1814 __entry->fhandle = nfs_fhandle_hash(fh);
1815 __entry->offset = data->args.offset;
1816 __entry->count = data->args.count;
1817 __entry->error = error < 0 ? -error : 0;
1818 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
1819 __entry->layoutstateid_hash =
1820 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
1821 ),
1822
1823 TP_printk(
1824 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1825 "offset=%lld count=%u layoutstateid=%d:0x%08x",
1826 -__entry->error,
1827 show_nfs4_status(__entry->error),
1828 MAJOR(__entry->dev), MINOR(__entry->dev),
1829 (unsigned long long)__entry->fileid,
1830 __entry->fhandle,
1831 (long long)__entry->offset,
1832 __entry->count,
1833 __entry->layoutstateid_seq, __entry->layoutstateid_hash
1834 )
1835);
1836#define DEFINE_NFS4_COMMIT_EVENT(name) \
1837 DEFINE_EVENT(nfs4_commit_event, name, \
1838 TP_PROTO( \
1839 const struct nfs_commit_data *data, \
1840 int error \
1841 ), \
1842 TP_ARGS(data, error))
1843DEFINE_NFS4_COMMIT_EVENT(nfs4_commit);
1844#ifdef CONFIG_NFS_V4_1
1845DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds);
1846
1847TRACE_EVENT(nfs4_layoutget,
1848 TP_PROTO(
1849 const struct nfs_open_context *ctx,
1850 const struct pnfs_layout_range *args,
1851 const struct pnfs_layout_range *res,
1852 const nfs4_stateid *layout_stateid,
1853 int error
1854 ),
1855
1856 TP_ARGS(ctx, args, res, layout_stateid, error),
1857
1858 TP_STRUCT__entry(
1859 __field(dev_t, dev)
1860 __field(u32, fhandle)
1861 __field(u64, fileid)
1862 __field(u32, iomode)
1863 __field(u64, offset)
1864 __field(u64, count)
1865 __field(unsigned long, error)
1866 __field(int, stateid_seq)
1867 __field(u32, stateid_hash)
1868 __field(int, layoutstateid_seq)
1869 __field(u32, layoutstateid_hash)
1870 ),
1871
1872 TP_fast_assign(
1873 const struct inode *inode = d_inode(ctx->dentry);
1874 const struct nfs4_state *state = ctx->state;
1875 __entry->dev = inode->i_sb->s_dev;
1876 __entry->fileid = NFS_FILEID(inode);
1877 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1878 __entry->iomode = args->iomode;
1879 __entry->offset = args->offset;
1880 __entry->count = args->length;
1881 __entry->error = error < 0 ? -error : 0;
1882 __entry->stateid_seq =
1883 be32_to_cpu(state->stateid.seqid);
1884 __entry->stateid_hash =
1885 nfs_stateid_hash(&state->stateid);
1886 if (!error) {
1887 __entry->layoutstateid_seq =
1888 be32_to_cpu(layout_stateid->seqid);
1889 __entry->layoutstateid_hash =
1890 nfs_stateid_hash(layout_stateid);
1891 } else {
1892 __entry->layoutstateid_seq = 0;
1893 __entry->layoutstateid_hash = 0;
1894 }
1895 ),
1896
1897 TP_printk(
1898 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
1899 "iomode=%s offset=%llu count=%llu stateid=%d:0x%08x "
1900 "layoutstateid=%d:0x%08x",
1901 -__entry->error,
1902 show_nfs4_status(__entry->error),
1903 MAJOR(__entry->dev), MINOR(__entry->dev),
1904 (unsigned long long)__entry->fileid,
1905 __entry->fhandle,
1906 show_pnfs_layout_iomode(__entry->iomode),
1907 (unsigned long long)__entry->offset,
1908 (unsigned long long)__entry->count,
1909 __entry->stateid_seq, __entry->stateid_hash,
1910 __entry->layoutstateid_seq, __entry->layoutstateid_hash
1911 )
1912);
1913
1914DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);
1915DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);
1916DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close);
1917DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror);
1918DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats);
1919
1920TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN);
1921TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS);
1922TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN);
1923TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH);
1924TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM);
1925TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL);
1926TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL);
1927TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED);
1928TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN);
1929TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED);
1930TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN);
1931TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY);
1932TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET);
1933TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT);
1934
1935#define show_pnfs_update_layout_reason(reason) \
1936 __print_symbolic(reason, \
1937 { PNFS_UPDATE_LAYOUT_UNKNOWN, "unknown" }, \
1938 { PNFS_UPDATE_LAYOUT_NO_PNFS, "no pnfs" }, \
1939 { PNFS_UPDATE_LAYOUT_RD_ZEROLEN, "read+zerolen" }, \
1940 { PNFS_UPDATE_LAYOUT_MDSTHRESH, "mdsthresh" }, \
1941 { PNFS_UPDATE_LAYOUT_NOMEM, "nomem" }, \
1942 { PNFS_UPDATE_LAYOUT_BULK_RECALL, "bulk recall" }, \
1943 { PNFS_UPDATE_LAYOUT_IO_TEST_FAIL, "io test fail" }, \
1944 { PNFS_UPDATE_LAYOUT_FOUND_CACHED, "found cached" }, \
1945 { PNFS_UPDATE_LAYOUT_RETURN, "layoutreturn" }, \
1946 { PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" }, \
1947 { PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" }, \
1948 { PNFS_UPDATE_LAYOUT_RETRY, "retrying" }, \
1949 { PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \
1950 { PNFS_UPDATE_LAYOUT_EXIT, "exit" })
1951
1952TRACE_EVENT(pnfs_update_layout,
1953 TP_PROTO(struct inode *inode,
1954 loff_t pos,
1955 u64 count,
1956 enum pnfs_iomode iomode,
1957 struct pnfs_layout_hdr *lo,
1958 struct pnfs_layout_segment *lseg,
1959 enum pnfs_update_layout_reason reason
1960 ),
1961 TP_ARGS(inode, pos, count, iomode, lo, lseg, reason),
1962 TP_STRUCT__entry(
1963 __field(dev_t, dev)
1964 __field(u64, fileid)
1965 __field(u32, fhandle)
1966 __field(loff_t, pos)
1967 __field(u64, count)
1968 __field(enum pnfs_iomode, iomode)
1969 __field(int, layoutstateid_seq)
1970 __field(u32, layoutstateid_hash)
1971 __field(long, lseg)
1972 __field(enum pnfs_update_layout_reason, reason)
1973 ),
1974 TP_fast_assign(
1975 __entry->dev = inode->i_sb->s_dev;
1976 __entry->fileid = NFS_FILEID(inode);
1977 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
1978 __entry->pos = pos;
1979 __entry->count = count;
1980 __entry->iomode = iomode;
1981 __entry->reason = reason;
1982 if (lo != NULL && pnfs_layout_is_valid(lo)) {
1983 __entry->layoutstateid_seq =
1984 be32_to_cpu(lo->plh_stateid.seqid);
1985 __entry->layoutstateid_hash =
1986 nfs_stateid_hash(&lo->plh_stateid);
1987 } else {
1988 __entry->layoutstateid_seq = 0;
1989 __entry->layoutstateid_hash = 0;
1990 }
1991 __entry->lseg = (long)lseg;
1992 ),
1993 TP_printk(
1994 "fileid=%02x:%02x:%llu fhandle=0x%08x "
1995 "iomode=%s pos=%llu count=%llu "
1996 "layoutstateid=%d:0x%08x lseg=0x%lx (%s)",
1997 MAJOR(__entry->dev), MINOR(__entry->dev),
1998 (unsigned long long)__entry->fileid,
1999 __entry->fhandle,
2000 show_pnfs_layout_iomode(__entry->iomode),
2001 (unsigned long long)__entry->pos,
2002 (unsigned long long)__entry->count,
2003 __entry->layoutstateid_seq, __entry->layoutstateid_hash,
2004 __entry->lseg,
2005 show_pnfs_update_layout_reason(__entry->reason)
2006 )
2007);
2008
2009DECLARE_EVENT_CLASS(pnfs_layout_event,
2010 TP_PROTO(struct inode *inode,
2011 loff_t pos,
2012 u64 count,
2013 enum pnfs_iomode iomode,
2014 struct pnfs_layout_hdr *lo,
2015 struct pnfs_layout_segment *lseg
2016 ),
2017 TP_ARGS(inode, pos, count, iomode, lo, lseg),
2018 TP_STRUCT__entry(
2019 __field(dev_t, dev)
2020 __field(u64, fileid)
2021 __field(u32, fhandle)
2022 __field(loff_t, pos)
2023 __field(u64, count)
2024 __field(enum pnfs_iomode, iomode)
2025 __field(int, layoutstateid_seq)
2026 __field(u32, layoutstateid_hash)
2027 __field(long, lseg)
2028 ),
2029 TP_fast_assign(
2030 __entry->dev = inode->i_sb->s_dev;
2031 __entry->fileid = NFS_FILEID(inode);
2032 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2033 __entry->pos = pos;
2034 __entry->count = count;
2035 __entry->iomode = iomode;
2036 if (lo != NULL && pnfs_layout_is_valid(lo)) {
2037 __entry->layoutstateid_seq =
2038 be32_to_cpu(lo->plh_stateid.seqid);
2039 __entry->layoutstateid_hash =
2040 nfs_stateid_hash(&lo->plh_stateid);
2041 } else {
2042 __entry->layoutstateid_seq = 0;
2043 __entry->layoutstateid_hash = 0;
2044 }
2045 __entry->lseg = (long)lseg;
2046 ),
2047 TP_printk(
2048 "fileid=%02x:%02x:%llu fhandle=0x%08x "
2049 "iomode=%s pos=%llu count=%llu "
2050 "layoutstateid=%d:0x%08x lseg=0x%lx",
2051 MAJOR(__entry->dev), MINOR(__entry->dev),
2052 (unsigned long long)__entry->fileid,
2053 __entry->fhandle,
2054 show_pnfs_layout_iomode(__entry->iomode),
2055 (unsigned long long)__entry->pos,
2056 (unsigned long long)__entry->count,
2057 __entry->layoutstateid_seq, __entry->layoutstateid_hash,
2058 __entry->lseg
2059 )
2060);
2061
2062#define DEFINE_PNFS_LAYOUT_EVENT(name) \
2063 DEFINE_EVENT(pnfs_layout_event, name, \
2064 TP_PROTO(struct inode *inode, \
2065 loff_t pos, \
2066 u64 count, \
2067 enum pnfs_iomode iomode, \
2068 struct pnfs_layout_hdr *lo, \
2069 struct pnfs_layout_segment *lseg \
2070 ), \
2071 TP_ARGS(inode, pos, count, iomode, lo, lseg))
2072
2073DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read);
2074DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write);
2075DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count);
2076DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done);
2077DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done);
2078DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist);
2079DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist);
2080
2081DECLARE_EVENT_CLASS(nfs4_deviceid_event,
2082 TP_PROTO(
2083 const struct nfs_client *clp,
2084 const struct nfs4_deviceid *deviceid
2085 ),
2086
2087 TP_ARGS(clp, deviceid),
2088
2089 TP_STRUCT__entry(
2090 __string(dstaddr, clp->cl_hostname)
2091 __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE)
2092 ),
2093
2094 TP_fast_assign(
2095 __assign_str(dstaddr);
2096 memcpy(__entry->deviceid, deviceid->data,
2097 NFS4_DEVICEID4_SIZE);
2098 ),
2099
2100 TP_printk(
2101 "deviceid=%s, dstaddr=%s",
2102 __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE),
2103 __get_str(dstaddr)
2104 )
2105);
2106#define DEFINE_PNFS_DEVICEID_EVENT(name) \
2107 DEFINE_EVENT(nfs4_deviceid_event, name, \
2108 TP_PROTO(const struct nfs_client *clp, \
2109 const struct nfs4_deviceid *deviceid \
2110 ), \
2111 TP_ARGS(clp, deviceid))
2112DEFINE_PNFS_DEVICEID_EVENT(nfs4_deviceid_free);
2113
2114DECLARE_EVENT_CLASS(nfs4_deviceid_status,
2115 TP_PROTO(
2116 const struct nfs_server *server,
2117 const struct nfs4_deviceid *deviceid,
2118 int status
2119 ),
2120
2121 TP_ARGS(server, deviceid, status),
2122
2123 TP_STRUCT__entry(
2124 __field(dev_t, dev)
2125 __field(int, status)
2126 __string(dstaddr, server->nfs_client->cl_hostname)
2127 __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE)
2128 ),
2129
2130 TP_fast_assign(
2131 __entry->dev = server->s_dev;
2132 __entry->status = status;
2133 __assign_str(dstaddr);
2134 memcpy(__entry->deviceid, deviceid->data,
2135 NFS4_DEVICEID4_SIZE);
2136 ),
2137
2138 TP_printk(
2139 "dev=%02x:%02x: deviceid=%s, dstaddr=%s, status=%d",
2140 MAJOR(__entry->dev), MINOR(__entry->dev),
2141 __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE),
2142 __get_str(dstaddr),
2143 __entry->status
2144 )
2145);
2146#define DEFINE_PNFS_DEVICEID_STATUS(name) \
2147 DEFINE_EVENT(nfs4_deviceid_status, name, \
2148 TP_PROTO(const struct nfs_server *server, \
2149 const struct nfs4_deviceid *deviceid, \
2150 int status \
2151 ), \
2152 TP_ARGS(server, deviceid, status))
2153DEFINE_PNFS_DEVICEID_STATUS(nfs4_getdeviceinfo);
2154DEFINE_PNFS_DEVICEID_STATUS(nfs4_find_deviceid);
2155
2156TRACE_EVENT(fl_getdevinfo,
2157 TP_PROTO(
2158 const struct nfs_server *server,
2159 const struct nfs4_deviceid *deviceid,
2160 char *ds_remotestr
2161 ),
2162 TP_ARGS(server, deviceid, ds_remotestr),
2163
2164 TP_STRUCT__entry(
2165 __string(mds_addr, server->nfs_client->cl_hostname)
2166 __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE)
2167 __string(ds_ips, ds_remotestr)
2168 ),
2169
2170 TP_fast_assign(
2171 __assign_str(mds_addr);
2172 __assign_str(ds_ips);
2173 memcpy(__entry->deviceid, deviceid->data,
2174 NFS4_DEVICEID4_SIZE);
2175 ),
2176 TP_printk(
2177 "deviceid=%s, mds_addr=%s, ds_ips=%s",
2178 __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE),
2179 __get_str(mds_addr),
2180 __get_str(ds_ips)
2181 )
2182);
2183
2184DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event,
2185 TP_PROTO(
2186 const struct nfs_pgio_header *hdr,
2187 int error
2188 ),
2189
2190 TP_ARGS(hdr, error),
2191
2192 TP_STRUCT__entry(
2193 __field(unsigned long, error)
2194 __field(unsigned long, nfs_error)
2195 __field(dev_t, dev)
2196 __field(u32, fhandle)
2197 __field(u64, fileid)
2198 __field(loff_t, offset)
2199 __field(u32, count)
2200 __field(int, stateid_seq)
2201 __field(u32, stateid_hash)
2202 __string(dstaddr, hdr->ds_clp ?
2203 rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient,
2204 RPC_DISPLAY_ADDR) : "unknown")
2205 ),
2206
2207 TP_fast_assign(
2208 const struct inode *inode = hdr->inode;
2209
2210 __entry->error = -error;
2211 __entry->nfs_error = hdr->res.op_status;
2212 __entry->fhandle = nfs_fhandle_hash(hdr->args.fh);
2213 __entry->fileid = NFS_FILEID(inode);
2214 __entry->dev = inode->i_sb->s_dev;
2215 __entry->offset = hdr->args.offset;
2216 __entry->count = hdr->args.count;
2217 __entry->stateid_seq =
2218 be32_to_cpu(hdr->args.stateid.seqid);
2219 __entry->stateid_hash =
2220 nfs_stateid_hash(&hdr->args.stateid);
2221 __assign_str(dstaddr);
2222 ),
2223
2224 TP_printk(
2225 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2226 "offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s "
2227 "nfs_error=%lu (%s)",
2228 -__entry->error,
2229 show_nfs4_status(__entry->error),
2230 MAJOR(__entry->dev), MINOR(__entry->dev),
2231 (unsigned long long)__entry->fileid,
2232 __entry->fhandle,
2233 __entry->offset, __entry->count,
2234 __entry->stateid_seq, __entry->stateid_hash,
2235 __get_str(dstaddr), __entry->nfs_error,
2236 show_nfs4_status(__entry->nfs_error)
2237 )
2238);
2239
2240#define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \
2241 DEFINE_EVENT(nfs4_flexfiles_io_event, name, \
2242 TP_PROTO( \
2243 const struct nfs_pgio_header *hdr, \
2244 int error \
2245 ), \
2246 TP_ARGS(hdr, error))
2247DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error);
2248DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error);
2249
2250TRACE_EVENT(ff_layout_commit_error,
2251 TP_PROTO(
2252 const struct nfs_commit_data *data,
2253 int error
2254 ),
2255
2256 TP_ARGS(data, error),
2257
2258 TP_STRUCT__entry(
2259 __field(unsigned long, error)
2260 __field(unsigned long, nfs_error)
2261 __field(dev_t, dev)
2262 __field(u32, fhandle)
2263 __field(u64, fileid)
2264 __field(loff_t, offset)
2265 __field(u32, count)
2266 __string(dstaddr, data->ds_clp ?
2267 rpc_peeraddr2str(data->ds_clp->cl_rpcclient,
2268 RPC_DISPLAY_ADDR) : "unknown")
2269 ),
2270
2271 TP_fast_assign(
2272 const struct inode *inode = data->inode;
2273
2274 __entry->error = -error;
2275 __entry->nfs_error = data->res.op_status;
2276 __entry->fhandle = nfs_fhandle_hash(data->args.fh);
2277 __entry->fileid = NFS_FILEID(inode);
2278 __entry->dev = inode->i_sb->s_dev;
2279 __entry->offset = data->args.offset;
2280 __entry->count = data->args.count;
2281 __assign_str(dstaddr);
2282 ),
2283
2284 TP_printk(
2285 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2286 "offset=%llu count=%u dstaddr=%s nfs_error=%lu (%s)",
2287 -__entry->error,
2288 show_nfs4_status(__entry->error),
2289 MAJOR(__entry->dev), MINOR(__entry->dev),
2290 (unsigned long long)__entry->fileid,
2291 __entry->fhandle,
2292 __entry->offset, __entry->count,
2293 __get_str(dstaddr), __entry->nfs_error,
2294 show_nfs4_status(__entry->nfs_error)
2295 )
2296);
2297
2298TRACE_EVENT(bl_ext_tree_prepare_commit,
2299 TP_PROTO(
2300 int ret,
2301 size_t count,
2302 u64 lwb,
2303 bool not_all_ranges
2304 ),
2305
2306 TP_ARGS(ret, count, lwb, not_all_ranges),
2307
2308 TP_STRUCT__entry(
2309 __field(int, ret)
2310 __field(size_t, count)
2311 __field(u64, lwb)
2312 __field(bool, not_all_ranges)
2313 ),
2314
2315 TP_fast_assign(
2316 __entry->ret = ret;
2317 __entry->count = count;
2318 __entry->lwb = lwb;
2319 __entry->not_all_ranges = not_all_ranges;
2320 ),
2321
2322 TP_printk(
2323 "ret=%d, found %zu ranges, lwb=%llu%s",
2324 __entry->ret,
2325 __entry->count,
2326 __entry->lwb,
2327 __entry->not_all_ranges ? ", not all ranges encoded" :
2328 ""
2329 )
2330);
2331
2332DECLARE_EVENT_CLASS(pnfs_bl_pr_key_class,
2333 TP_PROTO(
2334 const struct block_device *bdev,
2335 u64 key
2336 ),
2337 TP_ARGS(bdev, key),
2338 TP_STRUCT__entry(
2339 __field(u64, key)
2340 __field(dev_t, dev)
2341 __string(device, bdev->bd_disk->disk_name)
2342 ),
2343 TP_fast_assign(
2344 __entry->key = key;
2345 __entry->dev = bdev->bd_dev;
2346 __assign_str(device);
2347 ),
2348 TP_printk("dev=%d,%d (%s) key=0x%016llx",
2349 MAJOR(__entry->dev), MINOR(__entry->dev),
2350 __get_str(device), __entry->key
2351 )
2352);
2353
2354#define DEFINE_NFS4_BLOCK_PRKEY_EVENT(name) \
2355 DEFINE_EVENT(pnfs_bl_pr_key_class, name, \
2356 TP_PROTO( \
2357 const struct block_device *bdev, \
2358 u64 key \
2359 ), \
2360 TP_ARGS(bdev, key))
2361DEFINE_NFS4_BLOCK_PRKEY_EVENT(bl_pr_key_reg);
2362DEFINE_NFS4_BLOCK_PRKEY_EVENT(bl_pr_key_unreg);
2363
2364/*
2365 * From uapi/linux/pr.h
2366 */
2367TRACE_DEFINE_ENUM(PR_STS_SUCCESS);
2368TRACE_DEFINE_ENUM(PR_STS_IOERR);
2369TRACE_DEFINE_ENUM(PR_STS_RESERVATION_CONFLICT);
2370TRACE_DEFINE_ENUM(PR_STS_RETRY_PATH_FAILURE);
2371TRACE_DEFINE_ENUM(PR_STS_PATH_FAST_FAILED);
2372TRACE_DEFINE_ENUM(PR_STS_PATH_FAILED);
2373
2374#define show_pr_status(x) \
2375 __print_symbolic(x, \
2376 { PR_STS_SUCCESS, "SUCCESS" }, \
2377 { PR_STS_IOERR, "IOERR" }, \
2378 { PR_STS_RESERVATION_CONFLICT, "RESERVATION_CONFLICT" }, \
2379 { PR_STS_RETRY_PATH_FAILURE, "RETRY_PATH_FAILURE" }, \
2380 { PR_STS_PATH_FAST_FAILED, "PATH_FAST_FAILED" }, \
2381 { PR_STS_PATH_FAILED, "PATH_FAILED" })
2382
2383DECLARE_EVENT_CLASS(pnfs_bl_pr_key_err_class,
2384 TP_PROTO(
2385 const struct block_device *bdev,
2386 u64 key,
2387 int status
2388 ),
2389 TP_ARGS(bdev, key, status),
2390 TP_STRUCT__entry(
2391 __field(u64, key)
2392 __field(dev_t, dev)
2393 __field(unsigned long, status)
2394 __string(device, bdev->bd_disk->disk_name)
2395 ),
2396 TP_fast_assign(
2397 __entry->key = key;
2398 __entry->dev = bdev->bd_dev;
2399 __entry->status = status;
2400 __assign_str(device);
2401 ),
2402 TP_printk("dev=%d,%d (%s) key=0x%016llx status=%s",
2403 MAJOR(__entry->dev), MINOR(__entry->dev),
2404 __get_str(device), __entry->key,
2405 show_pr_status(__entry->status)
2406 )
2407);
2408
2409#define DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(name) \
2410 DEFINE_EVENT(pnfs_bl_pr_key_err_class, name, \
2411 TP_PROTO( \
2412 const struct block_device *bdev, \
2413 u64 key, \
2414 int status \
2415 ), \
2416 TP_ARGS(bdev, key, status))
2417DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(bl_pr_key_reg_err);
2418DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(bl_pr_key_unreg_err);
2419
2420#ifdef CONFIG_NFS_V4_2
2421TRACE_DEFINE_ENUM(NFS4_CONTENT_DATA);
2422TRACE_DEFINE_ENUM(NFS4_CONTENT_HOLE);
2423
2424#define show_llseek_mode(what) \
2425 __print_symbolic(what, \
2426 { NFS4_CONTENT_DATA, "DATA" }, \
2427 { NFS4_CONTENT_HOLE, "HOLE" })
2428
2429TRACE_EVENT(nfs4_llseek,
2430 TP_PROTO(
2431 const struct inode *inode,
2432 const struct nfs42_seek_args *args,
2433 const struct nfs42_seek_res *res,
2434 int error
2435 ),
2436
2437 TP_ARGS(inode, args, res, error),
2438
2439 TP_STRUCT__entry(
2440 __field(unsigned long, error)
2441 __field(u32, fhandle)
2442 __field(u32, fileid)
2443 __field(dev_t, dev)
2444 __field(int, stateid_seq)
2445 __field(u32, stateid_hash)
2446 __field(loff_t, offset_s)
2447 __field(u32, what)
2448 __field(loff_t, offset_r)
2449 __field(u32, eof)
2450 ),
2451
2452 TP_fast_assign(
2453 const struct nfs_inode *nfsi = NFS_I(inode);
2454 const struct nfs_fh *fh = args->sa_fh;
2455
2456 __entry->fileid = nfsi->fileid;
2457 __entry->dev = inode->i_sb->s_dev;
2458 __entry->fhandle = nfs_fhandle_hash(fh);
2459 __entry->offset_s = args->sa_offset;
2460 __entry->stateid_seq =
2461 be32_to_cpu(args->sa_stateid.seqid);
2462 __entry->stateid_hash =
2463 nfs_stateid_hash(&args->sa_stateid);
2464 __entry->what = args->sa_what;
2465 if (error) {
2466 __entry->error = -error;
2467 __entry->offset_r = 0;
2468 __entry->eof = 0;
2469 } else {
2470 __entry->error = 0;
2471 __entry->offset_r = res->sr_offset;
2472 __entry->eof = res->sr_eof;
2473 }
2474 ),
2475
2476 TP_printk(
2477 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2478 "stateid=%d:0x%08x offset_s=%llu what=%s "
2479 "offset_r=%llu eof=%u",
2480 -__entry->error,
2481 show_nfs4_status(__entry->error),
2482 MAJOR(__entry->dev), MINOR(__entry->dev),
2483 (unsigned long long)__entry->fileid,
2484 __entry->fhandle,
2485 __entry->stateid_seq, __entry->stateid_hash,
2486 __entry->offset_s,
2487 show_llseek_mode(__entry->what),
2488 __entry->offset_r,
2489 __entry->eof
2490 )
2491);
2492
2493DECLARE_EVENT_CLASS(nfs4_sparse_event,
2494 TP_PROTO(
2495 const struct inode *inode,
2496 const struct nfs42_falloc_args *args,
2497 int error
2498 ),
2499
2500 TP_ARGS(inode, args, error),
2501
2502 TP_STRUCT__entry(
2503 __field(unsigned long, error)
2504 __field(loff_t, offset)
2505 __field(loff_t, len)
2506 __field(dev_t, dev)
2507 __field(u32, fhandle)
2508 __field(u64, fileid)
2509 __field(int, stateid_seq)
2510 __field(u32, stateid_hash)
2511 ),
2512
2513 TP_fast_assign(
2514 __entry->error = error < 0 ? -error : 0;
2515 __entry->offset = args->falloc_offset;
2516 __entry->len = args->falloc_length;
2517 __entry->dev = inode->i_sb->s_dev;
2518 __entry->fileid = NFS_FILEID(inode);
2519 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2520 __entry->stateid_seq =
2521 be32_to_cpu(args->falloc_stateid.seqid);
2522 __entry->stateid_hash =
2523 nfs_stateid_hash(&args->falloc_stateid);
2524 ),
2525
2526 TP_printk(
2527 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2528 "stateid=%d:0x%08x offset=%llu len=%llu",
2529 -__entry->error,
2530 show_nfs4_status(__entry->error),
2531 MAJOR(__entry->dev), MINOR(__entry->dev),
2532 (unsigned long long)__entry->fileid,
2533 __entry->fhandle,
2534 __entry->stateid_seq, __entry->stateid_hash,
2535 (long long)__entry->offset,
2536 (long long)__entry->len
2537 )
2538);
2539#define DEFINE_NFS4_SPARSE_EVENT(name) \
2540 DEFINE_EVENT(nfs4_sparse_event, name, \
2541 TP_PROTO( \
2542 const struct inode *inode, \
2543 const struct nfs42_falloc_args *args, \
2544 int error \
2545 ), \
2546 TP_ARGS(inode, args, error))
2547DEFINE_NFS4_SPARSE_EVENT(nfs4_fallocate);
2548DEFINE_NFS4_SPARSE_EVENT(nfs4_deallocate);
2549
2550TRACE_EVENT(nfs4_copy,
2551 TP_PROTO(
2552 const struct inode *src_inode,
2553 const struct inode *dst_inode,
2554 const struct nfs42_copy_args *args,
2555 const struct nfs42_copy_res *res,
2556 const struct nl4_server *nss,
2557 int error
2558 ),
2559
2560 TP_ARGS(src_inode, dst_inode, args, res, nss, error),
2561
2562 TP_STRUCT__entry(
2563 __field(unsigned long, error)
2564 __field(u32, src_fhandle)
2565 __field(u32, src_fileid)
2566 __field(u32, dst_fhandle)
2567 __field(u32, dst_fileid)
2568 __field(dev_t, src_dev)
2569 __field(dev_t, dst_dev)
2570 __field(int, src_stateid_seq)
2571 __field(u32, src_stateid_hash)
2572 __field(int, dst_stateid_seq)
2573 __field(u32, dst_stateid_hash)
2574 __field(loff_t, src_offset)
2575 __field(loff_t, dst_offset)
2576 __field(bool, sync)
2577 __field(loff_t, len)
2578 __field(int, res_stateid_seq)
2579 __field(u32, res_stateid_hash)
2580 __field(loff_t, res_count)
2581 __field(bool, res_sync)
2582 __field(bool, res_cons)
2583 __field(bool, intra)
2584 ),
2585
2586 TP_fast_assign(
2587 const struct nfs_inode *src_nfsi = NFS_I(src_inode);
2588 const struct nfs_inode *dst_nfsi = NFS_I(dst_inode);
2589
2590 __entry->src_fileid = src_nfsi->fileid;
2591 __entry->src_dev = src_inode->i_sb->s_dev;
2592 __entry->src_fhandle = nfs_fhandle_hash(args->src_fh);
2593 __entry->src_offset = args->src_pos;
2594 __entry->dst_fileid = dst_nfsi->fileid;
2595 __entry->dst_dev = dst_inode->i_sb->s_dev;
2596 __entry->dst_fhandle = nfs_fhandle_hash(args->dst_fh);
2597 __entry->dst_offset = args->dst_pos;
2598 __entry->len = args->count;
2599 __entry->sync = args->sync;
2600 __entry->src_stateid_seq =
2601 be32_to_cpu(args->src_stateid.seqid);
2602 __entry->src_stateid_hash =
2603 nfs_stateid_hash(&args->src_stateid);
2604 __entry->dst_stateid_seq =
2605 be32_to_cpu(args->dst_stateid.seqid);
2606 __entry->dst_stateid_hash =
2607 nfs_stateid_hash(&args->dst_stateid);
2608 __entry->intra = nss ? 0 : 1;
2609 if (error) {
2610 __entry->error = -error;
2611 __entry->res_stateid_seq = 0;
2612 __entry->res_stateid_hash = 0;
2613 __entry->res_count = 0;
2614 __entry->res_sync = 0;
2615 __entry->res_cons = 0;
2616 } else {
2617 __entry->error = 0;
2618 __entry->res_stateid_seq =
2619 be32_to_cpu(res->write_res.stateid.seqid);
2620 __entry->res_stateid_hash =
2621 nfs_stateid_hash(&res->write_res.stateid);
2622 __entry->res_count = res->write_res.count;
2623 __entry->res_sync = res->synchronous;
2624 __entry->res_cons = res->consecutive;
2625 }
2626 ),
2627
2628 TP_printk(
2629 "error=%ld (%s) intra=%d src_fileid=%02x:%02x:%llu "
2630 "src_fhandle=0x%08x dst_fileid=%02x:%02x:%llu "
2631 "dst_fhandle=0x%08x src_stateid=%d:0x%08x "
2632 "dst_stateid=%d:0x%08x src_offset=%llu dst_offset=%llu "
2633 "len=%llu sync=%d cb_stateid=%d:0x%08x res_sync=%d "
2634 "res_cons=%d res_count=%llu",
2635 -__entry->error,
2636 show_nfs4_status(__entry->error),
2637 __entry->intra,
2638 MAJOR(__entry->src_dev), MINOR(__entry->src_dev),
2639 (unsigned long long)__entry->src_fileid,
2640 __entry->src_fhandle,
2641 MAJOR(__entry->dst_dev), MINOR(__entry->dst_dev),
2642 (unsigned long long)__entry->dst_fileid,
2643 __entry->dst_fhandle,
2644 __entry->src_stateid_seq, __entry->src_stateid_hash,
2645 __entry->dst_stateid_seq, __entry->dst_stateid_hash,
2646 __entry->src_offset,
2647 __entry->dst_offset,
2648 __entry->len,
2649 __entry->sync,
2650 __entry->res_stateid_seq, __entry->res_stateid_hash,
2651 __entry->res_sync,
2652 __entry->res_cons,
2653 __entry->res_count
2654 )
2655);
2656
2657TRACE_EVENT(nfs4_clone,
2658 TP_PROTO(
2659 const struct inode *src_inode,
2660 const struct inode *dst_inode,
2661 const struct nfs42_clone_args *args,
2662 int error
2663 ),
2664
2665 TP_ARGS(src_inode, dst_inode, args, error),
2666
2667 TP_STRUCT__entry(
2668 __field(unsigned long, error)
2669 __field(u32, src_fhandle)
2670 __field(u32, src_fileid)
2671 __field(u32, dst_fhandle)
2672 __field(u32, dst_fileid)
2673 __field(dev_t, src_dev)
2674 __field(dev_t, dst_dev)
2675 __field(loff_t, src_offset)
2676 __field(loff_t, dst_offset)
2677 __field(int, src_stateid_seq)
2678 __field(u32, src_stateid_hash)
2679 __field(int, dst_stateid_seq)
2680 __field(u32, dst_stateid_hash)
2681 __field(loff_t, len)
2682 ),
2683
2684 TP_fast_assign(
2685 const struct nfs_inode *src_nfsi = NFS_I(src_inode);
2686 const struct nfs_inode *dst_nfsi = NFS_I(dst_inode);
2687
2688 __entry->src_fileid = src_nfsi->fileid;
2689 __entry->src_dev = src_inode->i_sb->s_dev;
2690 __entry->src_fhandle = nfs_fhandle_hash(args->src_fh);
2691 __entry->src_offset = args->src_offset;
2692 __entry->dst_fileid = dst_nfsi->fileid;
2693 __entry->dst_dev = dst_inode->i_sb->s_dev;
2694 __entry->dst_fhandle = nfs_fhandle_hash(args->dst_fh);
2695 __entry->dst_offset = args->dst_offset;
2696 __entry->len = args->count;
2697 __entry->error = error < 0 ? -error : 0;
2698 __entry->src_stateid_seq =
2699 be32_to_cpu(args->src_stateid.seqid);
2700 __entry->src_stateid_hash =
2701 nfs_stateid_hash(&args->src_stateid);
2702 __entry->dst_stateid_seq =
2703 be32_to_cpu(args->dst_stateid.seqid);
2704 __entry->dst_stateid_hash =
2705 nfs_stateid_hash(&args->dst_stateid);
2706 ),
2707
2708 TP_printk(
2709 "error=%ld (%s) src_fileid=%02x:%02x:%llu "
2710 "src_fhandle=0x%08x dst_fileid=%02x:%02x:%llu "
2711 "dst_fhandle=0x%08x src_stateid=%d:0x%08x "
2712 "dst_stateid=%d:0x%08x src_offset=%llu "
2713 "dst_offset=%llu len=%llu",
2714 -__entry->error,
2715 show_nfs4_status(__entry->error),
2716 MAJOR(__entry->src_dev), MINOR(__entry->src_dev),
2717 (unsigned long long)__entry->src_fileid,
2718 __entry->src_fhandle,
2719 MAJOR(__entry->dst_dev), MINOR(__entry->dst_dev),
2720 (unsigned long long)__entry->dst_fileid,
2721 __entry->dst_fhandle,
2722 __entry->src_stateid_seq, __entry->src_stateid_hash,
2723 __entry->dst_stateid_seq, __entry->dst_stateid_hash,
2724 __entry->src_offset,
2725 __entry->dst_offset,
2726 __entry->len
2727 )
2728);
2729
2730TRACE_EVENT(nfs4_copy_notify,
2731 TP_PROTO(
2732 const struct inode *inode,
2733 const struct nfs42_copy_notify_args *args,
2734 const struct nfs42_copy_notify_res *res,
2735 int error
2736 ),
2737
2738 TP_ARGS(inode, args, res, error),
2739
2740 TP_STRUCT__entry(
2741 __field(unsigned long, error)
2742 __field(u32, fhandle)
2743 __field(u32, fileid)
2744 __field(dev_t, dev)
2745 __field(int, stateid_seq)
2746 __field(u32, stateid_hash)
2747 __field(int, res_stateid_seq)
2748 __field(u32, res_stateid_hash)
2749 ),
2750
2751 TP_fast_assign(
2752 const struct nfs_inode *nfsi = NFS_I(inode);
2753
2754 __entry->fileid = nfsi->fileid;
2755 __entry->dev = inode->i_sb->s_dev;
2756 __entry->fhandle = nfs_fhandle_hash(args->cna_src_fh);
2757 __entry->stateid_seq =
2758 be32_to_cpu(args->cna_src_stateid.seqid);
2759 __entry->stateid_hash =
2760 nfs_stateid_hash(&args->cna_src_stateid);
2761 if (error) {
2762 __entry->error = -error;
2763 __entry->res_stateid_seq = 0;
2764 __entry->res_stateid_hash = 0;
2765 } else {
2766 __entry->error = 0;
2767 __entry->res_stateid_seq =
2768 be32_to_cpu(res->cnr_stateid.seqid);
2769 __entry->res_stateid_hash =
2770 nfs_stateid_hash(&res->cnr_stateid);
2771 }
2772 ),
2773
2774 TP_printk(
2775 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2776 "stateid=%d:0x%08x res_stateid=%d:0x%08x",
2777 -__entry->error,
2778 show_nfs4_status(__entry->error),
2779 MAJOR(__entry->dev), MINOR(__entry->dev),
2780 (unsigned long long)__entry->fileid,
2781 __entry->fhandle,
2782 __entry->stateid_seq, __entry->stateid_hash,
2783 __entry->res_stateid_seq, __entry->res_stateid_hash
2784 )
2785);
2786
2787DECLARE_EVENT_CLASS(nfs4_offload_class,
2788 TP_PROTO(
2789 const struct nfs42_offload_status_args *args,
2790 int error
2791 ),
2792
2793 TP_ARGS(args, error),
2794
2795 TP_STRUCT__entry(
2796 __field(unsigned long, error)
2797 __field(u32, fhandle)
2798 __field(int, stateid_seq)
2799 __field(u32, stateid_hash)
2800 ),
2801
2802 TP_fast_assign(
2803 __entry->fhandle = nfs_fhandle_hash(args->osa_src_fh);
2804 __entry->error = error < 0 ? -error : 0;
2805 __entry->stateid_seq =
2806 be32_to_cpu(args->osa_stateid.seqid);
2807 __entry->stateid_hash =
2808 nfs_stateid_hash(&args->osa_stateid);
2809 ),
2810
2811 TP_printk(
2812 "error=%ld (%s) fhandle=0x%08x stateid=%d:0x%08x",
2813 -__entry->error,
2814 show_nfs4_status(__entry->error),
2815 __entry->fhandle,
2816 __entry->stateid_seq, __entry->stateid_hash
2817 )
2818);
2819#define DEFINE_NFS4_OFFLOAD_EVENT(name) \
2820 DEFINE_EVENT(nfs4_offload_class, name, \
2821 TP_PROTO( \
2822 const struct nfs42_offload_status_args *args, \
2823 int error \
2824 ), \
2825 TP_ARGS(args, error))
2826DEFINE_NFS4_OFFLOAD_EVENT(nfs4_offload_cancel);
2827DEFINE_NFS4_OFFLOAD_EVENT(nfs4_offload_status);
2828
2829DECLARE_EVENT_CLASS(nfs4_xattr_event,
2830 TP_PROTO(
2831 const struct inode *inode,
2832 const char *name,
2833 int error
2834 ),
2835
2836 TP_ARGS(inode, name, error),
2837
2838 TP_STRUCT__entry(
2839 __field(unsigned long, error)
2840 __field(dev_t, dev)
2841 __field(u32, fhandle)
2842 __field(u64, fileid)
2843 __string(name, name)
2844 ),
2845
2846 TP_fast_assign(
2847 __entry->error = error < 0 ? -error : 0;
2848 __entry->dev = inode->i_sb->s_dev;
2849 __entry->fileid = NFS_FILEID(inode);
2850 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));
2851 __assign_str(name);
2852 ),
2853
2854 TP_printk(
2855 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
2856 "name=%s",
2857 -__entry->error, show_nfs4_status(__entry->error),
2858 MAJOR(__entry->dev), MINOR(__entry->dev),
2859 (unsigned long long)__entry->fileid,
2860 __entry->fhandle, __get_str(name)
2861 )
2862);
2863#define DEFINE_NFS4_XATTR_EVENT(name) \
2864 DEFINE_EVENT(nfs4_xattr_event, name, \
2865 TP_PROTO( \
2866 const struct inode *inode, \
2867 const char *name, \
2868 int error \
2869 ), \
2870 TP_ARGS(inode, name, error))
2871DEFINE_NFS4_XATTR_EVENT(nfs4_getxattr);
2872DEFINE_NFS4_XATTR_EVENT(nfs4_setxattr);
2873DEFINE_NFS4_XATTR_EVENT(nfs4_removexattr);
2874
2875DEFINE_NFS4_INODE_EVENT(nfs4_listxattr);
2876#endif /* CONFIG_NFS_V4_2 */
2877
2878#endif /* CONFIG_NFS_V4_1 */
2879
2880#endif /* _TRACE_NFS4_H */
2881
2882#undef TRACE_INCLUDE_PATH
2883#define TRACE_INCLUDE_PATH .
2884#define TRACE_INCLUDE_FILE nfs4trace
2885/* This part must be outside protection */
2886#include <trace/define_trace.h>
2887