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