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