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