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_close_stateid_update_wait); 1357 1358 DECLARE_EVENT_CLASS(nfs4_getattr_event, 1359 TP_PROTO( 1360 const struct nfs_server *server, 1361 const struct nfs_fh *fhandle, 1362 const struct nfs_fattr *fattr, 1363 int error 1364 ), 1365 1366 TP_ARGS(server, fhandle, fattr, error), 1367 1368 TP_STRUCT__entry( 1369 __field(dev_t, dev) 1370 __field(u32, fhandle) 1371 __field(u64, fileid) 1372 __field(unsigned int, valid) 1373 __field(unsigned long, error) 1374 ), 1375 1376 TP_fast_assign( 1377 __entry->dev = server->s_dev; 1378 __entry->valid = fattr->valid; 1379 __entry->fhandle = nfs_fhandle_hash(fhandle); 1380 __entry->fileid = (fattr->valid & NFS_ATTR_FATTR_FILEID) ? fattr->fileid : 0; 1381 __entry->error = error < 0 ? -error : 0; 1382 ), 1383 1384 TP_printk( 1385 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1386 "valid=%s", 1387 -__entry->error, 1388 show_nfs4_status(__entry->error), 1389 MAJOR(__entry->dev), MINOR(__entry->dev), 1390 (unsigned long long)__entry->fileid, 1391 __entry->fhandle, 1392 show_nfs_fattr_flags(__entry->valid) 1393 ) 1394 ); 1395 1396 #define DEFINE_NFS4_GETATTR_EVENT(name) \ 1397 DEFINE_EVENT(nfs4_getattr_event, name, \ 1398 TP_PROTO( \ 1399 const struct nfs_server *server, \ 1400 const struct nfs_fh *fhandle, \ 1401 const struct nfs_fattr *fattr, \ 1402 int error \ 1403 ), \ 1404 TP_ARGS(server, fhandle, fattr, error)) 1405 DEFINE_NFS4_GETATTR_EVENT(nfs4_getattr); 1406 DEFINE_NFS4_GETATTR_EVENT(nfs4_lookup_root); 1407 DEFINE_NFS4_GETATTR_EVENT(nfs4_fsinfo); 1408 1409 DECLARE_EVENT_CLASS(nfs4_inode_callback_event, 1410 TP_PROTO( 1411 const struct nfs_client *clp, 1412 const struct nfs_fh *fhandle, 1413 const struct inode *inode, 1414 int error 1415 ), 1416 1417 TP_ARGS(clp, fhandle, inode, error), 1418 1419 TP_STRUCT__entry( 1420 __field(unsigned long, error) 1421 __field(dev_t, dev) 1422 __field(u32, fhandle) 1423 __field(u64, fileid) 1424 __string(dstaddr, clp ? clp->cl_hostname : "unknown") 1425 ), 1426 1427 TP_fast_assign( 1428 __entry->error = error < 0 ? -error : 0; 1429 __entry->fhandle = nfs_fhandle_hash(fhandle); 1430 if (!IS_ERR_OR_NULL(inode)) { 1431 __entry->fileid = NFS_FILEID(inode); 1432 __entry->dev = inode->i_sb->s_dev; 1433 } else { 1434 __entry->fileid = 0; 1435 __entry->dev = 0; 1436 } 1437 __assign_str(dstaddr); 1438 ), 1439 1440 TP_printk( 1441 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1442 "dstaddr=%s", 1443 -__entry->error, 1444 show_nfs4_status(__entry->error), 1445 MAJOR(__entry->dev), MINOR(__entry->dev), 1446 (unsigned long long)__entry->fileid, 1447 __entry->fhandle, 1448 __get_str(dstaddr) 1449 ) 1450 ); 1451 1452 #define DEFINE_NFS4_INODE_CALLBACK_EVENT(name) \ 1453 DEFINE_EVENT(nfs4_inode_callback_event, name, \ 1454 TP_PROTO( \ 1455 const struct nfs_client *clp, \ 1456 const struct nfs_fh *fhandle, \ 1457 const struct inode *inode, \ 1458 int error \ 1459 ), \ 1460 TP_ARGS(clp, fhandle, inode, error)) 1461 DEFINE_NFS4_INODE_CALLBACK_EVENT(nfs4_cb_getattr); 1462 1463 DECLARE_EVENT_CLASS(nfs4_inode_stateid_callback_event, 1464 TP_PROTO( 1465 const struct nfs_client *clp, 1466 const struct nfs_fh *fhandle, 1467 const struct inode *inode, 1468 const nfs4_stateid *stateid, 1469 int error 1470 ), 1471 1472 TP_ARGS(clp, fhandle, inode, stateid, error), 1473 1474 TP_STRUCT__entry( 1475 __field(unsigned long, error) 1476 __field(dev_t, dev) 1477 __field(u32, fhandle) 1478 __field(u64, fileid) 1479 __string(dstaddr, clp ? clp->cl_hostname : "unknown") 1480 __field(int, stateid_seq) 1481 __field(u32, stateid_hash) 1482 ), 1483 1484 TP_fast_assign( 1485 __entry->error = error < 0 ? -error : 0; 1486 __entry->fhandle = nfs_fhandle_hash(fhandle); 1487 if (!IS_ERR_OR_NULL(inode)) { 1488 __entry->fileid = NFS_FILEID(inode); 1489 __entry->dev = inode->i_sb->s_dev; 1490 } else { 1491 __entry->fileid = 0; 1492 __entry->dev = 0; 1493 } 1494 __assign_str(dstaddr); 1495 __entry->stateid_seq = 1496 be32_to_cpu(stateid->seqid); 1497 __entry->stateid_hash = 1498 nfs_stateid_hash(stateid); 1499 ), 1500 1501 TP_printk( 1502 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1503 "stateid=%d:0x%08x dstaddr=%s", 1504 -__entry->error, 1505 show_nfs4_status(__entry->error), 1506 MAJOR(__entry->dev), MINOR(__entry->dev), 1507 (unsigned long long)__entry->fileid, 1508 __entry->fhandle, 1509 __entry->stateid_seq, __entry->stateid_hash, 1510 __get_str(dstaddr) 1511 ) 1512 ); 1513 1514 #define DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(name) \ 1515 DEFINE_EVENT(nfs4_inode_stateid_callback_event, name, \ 1516 TP_PROTO( \ 1517 const struct nfs_client *clp, \ 1518 const struct nfs_fh *fhandle, \ 1519 const struct inode *inode, \ 1520 const nfs4_stateid *stateid, \ 1521 int error \ 1522 ), \ 1523 TP_ARGS(clp, fhandle, inode, stateid, error)) 1524 DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_recall); 1525 DEFINE_NFS4_INODE_STATEID_CALLBACK_EVENT(nfs4_cb_layoutrecall_file); 1526 1527 #define show_stateid_type(type) \ 1528 __print_symbolic(type, \ 1529 { NFS4_INVALID_STATEID_TYPE, "INVALID" }, \ 1530 { NFS4_SPECIAL_STATEID_TYPE, "SPECIAL" }, \ 1531 { NFS4_OPEN_STATEID_TYPE, "OPEN" }, \ 1532 { NFS4_LOCK_STATEID_TYPE, "LOCK" }, \ 1533 { NFS4_DELEGATION_STATEID_TYPE, "DELEGATION" }, \ 1534 { NFS4_LAYOUT_STATEID_TYPE, "LAYOUT" }, \ 1535 { NFS4_PNFS_DS_STATEID_TYPE, "PNFS_DS" }, \ 1536 { NFS4_REVOKED_STATEID_TYPE, "REVOKED" }, \ 1537 { NFS4_FREED_STATEID_TYPE, "FREED" }) 1538 1539 DECLARE_EVENT_CLASS(nfs4_match_stateid_event, 1540 TP_PROTO( 1541 const nfs4_stateid *s1, 1542 const nfs4_stateid *s2 1543 ), 1544 1545 TP_ARGS(s1, s2), 1546 1547 TP_STRUCT__entry( 1548 __field(int, s1_seq) 1549 __field(int, s2_seq) 1550 __field(u32, s1_hash) 1551 __field(u32, s2_hash) 1552 __field(int, s1_type) 1553 __field(int, s2_type) 1554 ), 1555 1556 TP_fast_assign( 1557 __entry->s1_seq = s1->seqid; 1558 __entry->s1_hash = nfs_stateid_hash(s1); 1559 __entry->s1_type = s1->type; 1560 __entry->s2_seq = s2->seqid; 1561 __entry->s2_hash = nfs_stateid_hash(s2); 1562 __entry->s2_type = s2->type; 1563 ), 1564 1565 TP_printk( 1566 "s1=%s:%x:%u s2=%s:%x:%u", 1567 show_stateid_type(__entry->s1_type), 1568 __entry->s1_hash, __entry->s1_seq, 1569 show_stateid_type(__entry->s2_type), 1570 __entry->s2_hash, __entry->s2_seq 1571 ) 1572 ); 1573 1574 #define DEFINE_NFS4_MATCH_STATEID_EVENT(name) \ 1575 DEFINE_EVENT(nfs4_match_stateid_event, name, \ 1576 TP_PROTO( \ 1577 const nfs4_stateid *s1, \ 1578 const nfs4_stateid *s2 \ 1579 ), \ 1580 TP_ARGS(s1, s2)) 1581 DEFINE_NFS4_MATCH_STATEID_EVENT(nfs41_match_stateid); 1582 DEFINE_NFS4_MATCH_STATEID_EVENT(nfs4_match_stateid); 1583 1584 DECLARE_EVENT_CLASS(nfs4_idmap_event, 1585 TP_PROTO( 1586 const char *name, 1587 int len, 1588 u32 id, 1589 int error 1590 ), 1591 1592 TP_ARGS(name, len, id, error), 1593 1594 TP_STRUCT__entry( 1595 __field(unsigned long, error) 1596 __field(u32, id) 1597 __dynamic_array(char, name, len > 0 ? len + 1 : 1) 1598 ), 1599 1600 TP_fast_assign( 1601 if (len < 0) 1602 len = 0; 1603 __entry->error = error < 0 ? error : 0; 1604 __entry->id = id; 1605 memcpy(__get_str(name), name, len); 1606 __get_str(name)[len] = 0; 1607 ), 1608 1609 TP_printk( 1610 "error=%ld (%s) id=%u name=%s", 1611 -__entry->error, show_nfs4_status(__entry->error), 1612 __entry->id, 1613 __get_str(name) 1614 ) 1615 ); 1616 #define DEFINE_NFS4_IDMAP_EVENT(name) \ 1617 DEFINE_EVENT(nfs4_idmap_event, name, \ 1618 TP_PROTO( \ 1619 const char *name, \ 1620 int len, \ 1621 u32 id, \ 1622 int error \ 1623 ), \ 1624 TP_ARGS(name, len, id, error)) 1625 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_name_to_uid); 1626 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid); 1627 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name); 1628 DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group); 1629 1630 #ifdef CONFIG_NFS_V4_1 1631 #define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \ 1632 (lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0) 1633 #else 1634 #define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0) 1635 #endif 1636 1637 DECLARE_EVENT_CLASS(nfs4_read_event, 1638 TP_PROTO( 1639 const struct nfs_pgio_header *hdr, 1640 int error 1641 ), 1642 1643 TP_ARGS(hdr, error), 1644 1645 TP_STRUCT__entry( 1646 __field(dev_t, dev) 1647 __field(u32, fhandle) 1648 __field(u64, fileid) 1649 __field(loff_t, offset) 1650 __field(u32, arg_count) 1651 __field(u32, res_count) 1652 __field(unsigned long, error) 1653 __field(int, stateid_seq) 1654 __field(u32, stateid_hash) 1655 __field(int, layoutstateid_seq) 1656 __field(u32, layoutstateid_hash) 1657 ), 1658 1659 TP_fast_assign( 1660 const struct inode *inode = hdr->inode; 1661 const struct nfs_inode *nfsi = NFS_I(inode); 1662 const struct nfs_fh *fh = hdr->args.fh ? 1663 hdr->args.fh : &nfsi->fh; 1664 const struct nfs4_state *state = 1665 hdr->args.context->state; 1666 const struct pnfs_layout_segment *lseg = hdr->lseg; 1667 1668 __entry->dev = inode->i_sb->s_dev; 1669 __entry->fileid = nfsi->fileid; 1670 __entry->fhandle = nfs_fhandle_hash(fh); 1671 __entry->offset = hdr->args.offset; 1672 __entry->arg_count = hdr->args.count; 1673 __entry->res_count = hdr->res.count; 1674 __entry->error = error < 0 ? -error : 0; 1675 __entry->stateid_seq = 1676 be32_to_cpu(state->stateid.seqid); 1677 __entry->stateid_hash = 1678 nfs_stateid_hash(&state->stateid); 1679 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0; 1680 __entry->layoutstateid_hash = 1681 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg); 1682 ), 1683 1684 TP_printk( 1685 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1686 "offset=%lld count=%u res=%u stateid=%d:0x%08x " 1687 "layoutstateid=%d:0x%08x", 1688 -__entry->error, 1689 show_nfs4_status(__entry->error), 1690 MAJOR(__entry->dev), MINOR(__entry->dev), 1691 (unsigned long long)__entry->fileid, 1692 __entry->fhandle, 1693 (long long)__entry->offset, 1694 __entry->arg_count, __entry->res_count, 1695 __entry->stateid_seq, __entry->stateid_hash, 1696 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1697 ) 1698 ); 1699 #define DEFINE_NFS4_READ_EVENT(name) \ 1700 DEFINE_EVENT(nfs4_read_event, name, \ 1701 TP_PROTO( \ 1702 const struct nfs_pgio_header *hdr, \ 1703 int error \ 1704 ), \ 1705 TP_ARGS(hdr, error)) 1706 DEFINE_NFS4_READ_EVENT(nfs4_read); 1707 #ifdef CONFIG_NFS_V4_1 1708 DEFINE_NFS4_READ_EVENT(nfs4_pnfs_read); 1709 #endif /* CONFIG_NFS_V4_1 */ 1710 1711 DECLARE_EVENT_CLASS(nfs4_write_event, 1712 TP_PROTO( 1713 const struct nfs_pgio_header *hdr, 1714 int error 1715 ), 1716 1717 TP_ARGS(hdr, error), 1718 1719 TP_STRUCT__entry( 1720 __field(dev_t, dev) 1721 __field(u32, fhandle) 1722 __field(u64, fileid) 1723 __field(loff_t, offset) 1724 __field(u32, arg_count) 1725 __field(u32, res_count) 1726 __field(unsigned long, error) 1727 __field(int, stateid_seq) 1728 __field(u32, stateid_hash) 1729 __field(int, layoutstateid_seq) 1730 __field(u32, layoutstateid_hash) 1731 ), 1732 1733 TP_fast_assign( 1734 const struct inode *inode = hdr->inode; 1735 const struct nfs_inode *nfsi = NFS_I(inode); 1736 const struct nfs_fh *fh = hdr->args.fh ? 1737 hdr->args.fh : &nfsi->fh; 1738 const struct nfs4_state *state = 1739 hdr->args.context->state; 1740 const struct pnfs_layout_segment *lseg = hdr->lseg; 1741 1742 __entry->dev = inode->i_sb->s_dev; 1743 __entry->fileid = nfsi->fileid; 1744 __entry->fhandle = nfs_fhandle_hash(fh); 1745 __entry->offset = hdr->args.offset; 1746 __entry->arg_count = hdr->args.count; 1747 __entry->res_count = hdr->res.count; 1748 __entry->error = error < 0 ? -error : 0; 1749 __entry->stateid_seq = 1750 be32_to_cpu(state->stateid.seqid); 1751 __entry->stateid_hash = 1752 nfs_stateid_hash(&state->stateid); 1753 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0; 1754 __entry->layoutstateid_hash = 1755 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg); 1756 ), 1757 1758 TP_printk( 1759 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1760 "offset=%lld count=%u res=%u stateid=%d:0x%08x " 1761 "layoutstateid=%d:0x%08x", 1762 -__entry->error, 1763 show_nfs4_status(__entry->error), 1764 MAJOR(__entry->dev), MINOR(__entry->dev), 1765 (unsigned long long)__entry->fileid, 1766 __entry->fhandle, 1767 (long long)__entry->offset, 1768 __entry->arg_count, __entry->res_count, 1769 __entry->stateid_seq, __entry->stateid_hash, 1770 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1771 ) 1772 ); 1773 1774 #define DEFINE_NFS4_WRITE_EVENT(name) \ 1775 DEFINE_EVENT(nfs4_write_event, name, \ 1776 TP_PROTO( \ 1777 const struct nfs_pgio_header *hdr, \ 1778 int error \ 1779 ), \ 1780 TP_ARGS(hdr, error)) 1781 DEFINE_NFS4_WRITE_EVENT(nfs4_write); 1782 #ifdef CONFIG_NFS_V4_1 1783 DEFINE_NFS4_WRITE_EVENT(nfs4_pnfs_write); 1784 #endif /* CONFIG_NFS_V4_1 */ 1785 1786 DECLARE_EVENT_CLASS(nfs4_commit_event, 1787 TP_PROTO( 1788 const struct nfs_commit_data *data, 1789 int error 1790 ), 1791 1792 TP_ARGS(data, error), 1793 1794 TP_STRUCT__entry( 1795 __field(dev_t, dev) 1796 __field(u32, fhandle) 1797 __field(u64, fileid) 1798 __field(unsigned long, error) 1799 __field(loff_t, offset) 1800 __field(u32, count) 1801 __field(int, layoutstateid_seq) 1802 __field(u32, layoutstateid_hash) 1803 ), 1804 1805 TP_fast_assign( 1806 const struct inode *inode = data->inode; 1807 const struct nfs_inode *nfsi = NFS_I(inode); 1808 const struct nfs_fh *fh = data->args.fh ? 1809 data->args.fh : &nfsi->fh; 1810 const struct pnfs_layout_segment *lseg = data->lseg; 1811 1812 __entry->dev = inode->i_sb->s_dev; 1813 __entry->fileid = nfsi->fileid; 1814 __entry->fhandle = nfs_fhandle_hash(fh); 1815 __entry->offset = data->args.offset; 1816 __entry->count = data->args.count; 1817 __entry->error = error < 0 ? -error : 0; 1818 __entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0; 1819 __entry->layoutstateid_hash = 1820 NFS4_LSEG_LAYOUT_STATEID_HASH(lseg); 1821 ), 1822 1823 TP_printk( 1824 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1825 "offset=%lld count=%u layoutstateid=%d:0x%08x", 1826 -__entry->error, 1827 show_nfs4_status(__entry->error), 1828 MAJOR(__entry->dev), MINOR(__entry->dev), 1829 (unsigned long long)__entry->fileid, 1830 __entry->fhandle, 1831 (long long)__entry->offset, 1832 __entry->count, 1833 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1834 ) 1835 ); 1836 #define DEFINE_NFS4_COMMIT_EVENT(name) \ 1837 DEFINE_EVENT(nfs4_commit_event, name, \ 1838 TP_PROTO( \ 1839 const struct nfs_commit_data *data, \ 1840 int error \ 1841 ), \ 1842 TP_ARGS(data, error)) 1843 DEFINE_NFS4_COMMIT_EVENT(nfs4_commit); 1844 #ifdef CONFIG_NFS_V4_1 1845 DEFINE_NFS4_COMMIT_EVENT(nfs4_pnfs_commit_ds); 1846 1847 TRACE_EVENT(nfs4_layoutget, 1848 TP_PROTO( 1849 const struct nfs_open_context *ctx, 1850 const struct pnfs_layout_range *args, 1851 const struct pnfs_layout_range *res, 1852 const nfs4_stateid *layout_stateid, 1853 int error 1854 ), 1855 1856 TP_ARGS(ctx, args, res, layout_stateid, error), 1857 1858 TP_STRUCT__entry( 1859 __field(dev_t, dev) 1860 __field(u32, fhandle) 1861 __field(u64, fileid) 1862 __field(u32, iomode) 1863 __field(u64, offset) 1864 __field(u64, count) 1865 __field(unsigned long, error) 1866 __field(int, stateid_seq) 1867 __field(u32, stateid_hash) 1868 __field(int, layoutstateid_seq) 1869 __field(u32, layoutstateid_hash) 1870 ), 1871 1872 TP_fast_assign( 1873 const struct inode *inode = d_inode(ctx->dentry); 1874 const struct nfs4_state *state = ctx->state; 1875 __entry->dev = inode->i_sb->s_dev; 1876 __entry->fileid = NFS_FILEID(inode); 1877 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1878 __entry->iomode = args->iomode; 1879 __entry->offset = args->offset; 1880 __entry->count = args->length; 1881 __entry->error = error < 0 ? -error : 0; 1882 __entry->stateid_seq = 1883 be32_to_cpu(state->stateid.seqid); 1884 __entry->stateid_hash = 1885 nfs_stateid_hash(&state->stateid); 1886 if (!error) { 1887 __entry->layoutstateid_seq = 1888 be32_to_cpu(layout_stateid->seqid); 1889 __entry->layoutstateid_hash = 1890 nfs_stateid_hash(layout_stateid); 1891 } else { 1892 __entry->layoutstateid_seq = 0; 1893 __entry->layoutstateid_hash = 0; 1894 } 1895 ), 1896 1897 TP_printk( 1898 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 1899 "iomode=%s offset=%llu count=%llu stateid=%d:0x%08x " 1900 "layoutstateid=%d:0x%08x", 1901 -__entry->error, 1902 show_nfs4_status(__entry->error), 1903 MAJOR(__entry->dev), MINOR(__entry->dev), 1904 (unsigned long long)__entry->fileid, 1905 __entry->fhandle, 1906 show_pnfs_layout_iomode(__entry->iomode), 1907 (unsigned long long)__entry->offset, 1908 (unsigned long long)__entry->count, 1909 __entry->stateid_seq, __entry->stateid_hash, 1910 __entry->layoutstateid_seq, __entry->layoutstateid_hash 1911 ) 1912 ); 1913 1914 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit); 1915 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn); 1916 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close); 1917 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror); 1918 DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats); 1919 1920 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN); 1921 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS); 1922 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RD_ZEROLEN); 1923 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_MDSTHRESH); 1924 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NOMEM); 1925 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BULK_RECALL); 1926 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_IO_TEST_FAIL); 1927 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_FOUND_CACHED); 1928 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETURN); 1929 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_BLOCKED); 1930 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_INVALID_OPEN); 1931 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_RETRY); 1932 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET); 1933 TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_EXIT); 1934 1935 #define show_pnfs_update_layout_reason(reason) \ 1936 __print_symbolic(reason, \ 1937 { PNFS_UPDATE_LAYOUT_UNKNOWN, "unknown" }, \ 1938 { PNFS_UPDATE_LAYOUT_NO_PNFS, "no pnfs" }, \ 1939 { PNFS_UPDATE_LAYOUT_RD_ZEROLEN, "read+zerolen" }, \ 1940 { PNFS_UPDATE_LAYOUT_MDSTHRESH, "mdsthresh" }, \ 1941 { PNFS_UPDATE_LAYOUT_NOMEM, "nomem" }, \ 1942 { PNFS_UPDATE_LAYOUT_BULK_RECALL, "bulk recall" }, \ 1943 { PNFS_UPDATE_LAYOUT_IO_TEST_FAIL, "io test fail" }, \ 1944 { PNFS_UPDATE_LAYOUT_FOUND_CACHED, "found cached" }, \ 1945 { PNFS_UPDATE_LAYOUT_RETURN, "layoutreturn" }, \ 1946 { PNFS_UPDATE_LAYOUT_BLOCKED, "layouts blocked" }, \ 1947 { PNFS_UPDATE_LAYOUT_INVALID_OPEN, "invalid open" }, \ 1948 { PNFS_UPDATE_LAYOUT_RETRY, "retrying" }, \ 1949 { PNFS_UPDATE_LAYOUT_SEND_LAYOUTGET, "sent layoutget" }, \ 1950 { PNFS_UPDATE_LAYOUT_EXIT, "exit" }) 1951 1952 TRACE_EVENT(pnfs_update_layout, 1953 TP_PROTO(struct inode *inode, 1954 loff_t pos, 1955 u64 count, 1956 enum pnfs_iomode iomode, 1957 struct pnfs_layout_hdr *lo, 1958 struct pnfs_layout_segment *lseg, 1959 enum pnfs_update_layout_reason reason 1960 ), 1961 TP_ARGS(inode, pos, count, iomode, lo, lseg, reason), 1962 TP_STRUCT__entry( 1963 __field(dev_t, dev) 1964 __field(u64, fileid) 1965 __field(u32, fhandle) 1966 __field(loff_t, pos) 1967 __field(u64, count) 1968 __field(enum pnfs_iomode, iomode) 1969 __field(int, layoutstateid_seq) 1970 __field(u32, layoutstateid_hash) 1971 __field(long, lseg) 1972 __field(enum pnfs_update_layout_reason, reason) 1973 ), 1974 TP_fast_assign( 1975 __entry->dev = inode->i_sb->s_dev; 1976 __entry->fileid = NFS_FILEID(inode); 1977 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 1978 __entry->pos = pos; 1979 __entry->count = count; 1980 __entry->iomode = iomode; 1981 __entry->reason = reason; 1982 if (lo != NULL && pnfs_layout_is_valid(lo)) { 1983 __entry->layoutstateid_seq = 1984 be32_to_cpu(lo->plh_stateid.seqid); 1985 __entry->layoutstateid_hash = 1986 nfs_stateid_hash(&lo->plh_stateid); 1987 } else { 1988 __entry->layoutstateid_seq = 0; 1989 __entry->layoutstateid_hash = 0; 1990 } 1991 __entry->lseg = (long)lseg; 1992 ), 1993 TP_printk( 1994 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1995 "iomode=%s pos=%llu count=%llu " 1996 "layoutstateid=%d:0x%08x lseg=0x%lx (%s)", 1997 MAJOR(__entry->dev), MINOR(__entry->dev), 1998 (unsigned long long)__entry->fileid, 1999 __entry->fhandle, 2000 show_pnfs_layout_iomode(__entry->iomode), 2001 (unsigned long long)__entry->pos, 2002 (unsigned long long)__entry->count, 2003 __entry->layoutstateid_seq, __entry->layoutstateid_hash, 2004 __entry->lseg, 2005 show_pnfs_update_layout_reason(__entry->reason) 2006 ) 2007 ); 2008 2009 DECLARE_EVENT_CLASS(pnfs_layout_event, 2010 TP_PROTO(struct inode *inode, 2011 loff_t pos, 2012 u64 count, 2013 enum pnfs_iomode iomode, 2014 struct pnfs_layout_hdr *lo, 2015 struct pnfs_layout_segment *lseg 2016 ), 2017 TP_ARGS(inode, pos, count, iomode, lo, lseg), 2018 TP_STRUCT__entry( 2019 __field(dev_t, dev) 2020 __field(u64, fileid) 2021 __field(u32, fhandle) 2022 __field(loff_t, pos) 2023 __field(u64, count) 2024 __field(enum pnfs_iomode, iomode) 2025 __field(int, layoutstateid_seq) 2026 __field(u32, layoutstateid_hash) 2027 __field(long, lseg) 2028 ), 2029 TP_fast_assign( 2030 __entry->dev = inode->i_sb->s_dev; 2031 __entry->fileid = NFS_FILEID(inode); 2032 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 2033 __entry->pos = pos; 2034 __entry->count = count; 2035 __entry->iomode = iomode; 2036 if (lo != NULL && pnfs_layout_is_valid(lo)) { 2037 __entry->layoutstateid_seq = 2038 be32_to_cpu(lo->plh_stateid.seqid); 2039 __entry->layoutstateid_hash = 2040 nfs_stateid_hash(&lo->plh_stateid); 2041 } else { 2042 __entry->layoutstateid_seq = 0; 2043 __entry->layoutstateid_hash = 0; 2044 } 2045 __entry->lseg = (long)lseg; 2046 ), 2047 TP_printk( 2048 "fileid=%02x:%02x:%llu fhandle=0x%08x " 2049 "iomode=%s pos=%llu count=%llu " 2050 "layoutstateid=%d:0x%08x lseg=0x%lx", 2051 MAJOR(__entry->dev), MINOR(__entry->dev), 2052 (unsigned long long)__entry->fileid, 2053 __entry->fhandle, 2054 show_pnfs_layout_iomode(__entry->iomode), 2055 (unsigned long long)__entry->pos, 2056 (unsigned long long)__entry->count, 2057 __entry->layoutstateid_seq, __entry->layoutstateid_hash, 2058 __entry->lseg 2059 ) 2060 ); 2061 2062 #define DEFINE_PNFS_LAYOUT_EVENT(name) \ 2063 DEFINE_EVENT(pnfs_layout_event, name, \ 2064 TP_PROTO(struct inode *inode, \ 2065 loff_t pos, \ 2066 u64 count, \ 2067 enum pnfs_iomode iomode, \ 2068 struct pnfs_layout_hdr *lo, \ 2069 struct pnfs_layout_segment *lseg \ 2070 ), \ 2071 TP_ARGS(inode, pos, count, iomode, lo, lseg)) 2072 2073 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_read); 2074 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_init_write); 2075 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_pg_get_mirror_count); 2076 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_done); 2077 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_done); 2078 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_read_pagelist); 2079 DEFINE_PNFS_LAYOUT_EVENT(pnfs_mds_fallback_write_pagelist); 2080 2081 DECLARE_EVENT_CLASS(nfs4_deviceid_event, 2082 TP_PROTO( 2083 const struct nfs_client *clp, 2084 const struct nfs4_deviceid *deviceid 2085 ), 2086 2087 TP_ARGS(clp, deviceid), 2088 2089 TP_STRUCT__entry( 2090 __string(dstaddr, clp->cl_hostname) 2091 __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE) 2092 ), 2093 2094 TP_fast_assign( 2095 __assign_str(dstaddr); 2096 memcpy(__entry->deviceid, deviceid->data, 2097 NFS4_DEVICEID4_SIZE); 2098 ), 2099 2100 TP_printk( 2101 "deviceid=%s, dstaddr=%s", 2102 __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE), 2103 __get_str(dstaddr) 2104 ) 2105 ); 2106 #define DEFINE_PNFS_DEVICEID_EVENT(name) \ 2107 DEFINE_EVENT(nfs4_deviceid_event, name, \ 2108 TP_PROTO(const struct nfs_client *clp, \ 2109 const struct nfs4_deviceid *deviceid \ 2110 ), \ 2111 TP_ARGS(clp, deviceid)) 2112 DEFINE_PNFS_DEVICEID_EVENT(nfs4_deviceid_free); 2113 2114 DECLARE_EVENT_CLASS(nfs4_deviceid_status, 2115 TP_PROTO( 2116 const struct nfs_server *server, 2117 const struct nfs4_deviceid *deviceid, 2118 int status 2119 ), 2120 2121 TP_ARGS(server, deviceid, status), 2122 2123 TP_STRUCT__entry( 2124 __field(dev_t, dev) 2125 __field(int, status) 2126 __string(dstaddr, server->nfs_client->cl_hostname) 2127 __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE) 2128 ), 2129 2130 TP_fast_assign( 2131 __entry->dev = server->s_dev; 2132 __entry->status = status; 2133 __assign_str(dstaddr); 2134 memcpy(__entry->deviceid, deviceid->data, 2135 NFS4_DEVICEID4_SIZE); 2136 ), 2137 2138 TP_printk( 2139 "dev=%02x:%02x: deviceid=%s, dstaddr=%s, status=%d", 2140 MAJOR(__entry->dev), MINOR(__entry->dev), 2141 __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE), 2142 __get_str(dstaddr), 2143 __entry->status 2144 ) 2145 ); 2146 #define DEFINE_PNFS_DEVICEID_STATUS(name) \ 2147 DEFINE_EVENT(nfs4_deviceid_status, name, \ 2148 TP_PROTO(const struct nfs_server *server, \ 2149 const struct nfs4_deviceid *deviceid, \ 2150 int status \ 2151 ), \ 2152 TP_ARGS(server, deviceid, status)) 2153 DEFINE_PNFS_DEVICEID_STATUS(nfs4_getdeviceinfo); 2154 DEFINE_PNFS_DEVICEID_STATUS(nfs4_find_deviceid); 2155 2156 TRACE_EVENT(fl_getdevinfo, 2157 TP_PROTO( 2158 const struct nfs_server *server, 2159 const struct nfs4_deviceid *deviceid, 2160 char *ds_remotestr 2161 ), 2162 TP_ARGS(server, deviceid, ds_remotestr), 2163 2164 TP_STRUCT__entry( 2165 __string(mds_addr, server->nfs_client->cl_hostname) 2166 __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE) 2167 __string(ds_ips, ds_remotestr) 2168 ), 2169 2170 TP_fast_assign( 2171 __assign_str(mds_addr); 2172 __assign_str(ds_ips); 2173 memcpy(__entry->deviceid, deviceid->data, 2174 NFS4_DEVICEID4_SIZE); 2175 ), 2176 TP_printk( 2177 "deviceid=%s, mds_addr=%s, ds_ips=%s", 2178 __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE), 2179 __get_str(mds_addr), 2180 __get_str(ds_ips) 2181 ) 2182 ); 2183 2184 DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event, 2185 TP_PROTO( 2186 const struct nfs_pgio_header *hdr, 2187 int error 2188 ), 2189 2190 TP_ARGS(hdr, error), 2191 2192 TP_STRUCT__entry( 2193 __field(unsigned long, error) 2194 __field(unsigned long, nfs_error) 2195 __field(dev_t, dev) 2196 __field(u32, fhandle) 2197 __field(u64, fileid) 2198 __field(loff_t, offset) 2199 __field(u32, count) 2200 __field(int, stateid_seq) 2201 __field(u32, stateid_hash) 2202 __string(dstaddr, hdr->ds_clp ? 2203 rpc_peeraddr2str(hdr->ds_clp->cl_rpcclient, 2204 RPC_DISPLAY_ADDR) : "unknown") 2205 ), 2206 2207 TP_fast_assign( 2208 const struct inode *inode = hdr->inode; 2209 2210 __entry->error = -error; 2211 __entry->nfs_error = hdr->res.op_status; 2212 __entry->fhandle = nfs_fhandle_hash(hdr->args.fh); 2213 __entry->fileid = NFS_FILEID(inode); 2214 __entry->dev = inode->i_sb->s_dev; 2215 __entry->offset = hdr->args.offset; 2216 __entry->count = hdr->args.count; 2217 __entry->stateid_seq = 2218 be32_to_cpu(hdr->args.stateid.seqid); 2219 __entry->stateid_hash = 2220 nfs_stateid_hash(&hdr->args.stateid); 2221 __assign_str(dstaddr); 2222 ), 2223 2224 TP_printk( 2225 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2226 "offset=%llu count=%u stateid=%d:0x%08x dstaddr=%s " 2227 "nfs_error=%lu (%s)", 2228 -__entry->error, 2229 show_nfs4_status(__entry->error), 2230 MAJOR(__entry->dev), MINOR(__entry->dev), 2231 (unsigned long long)__entry->fileid, 2232 __entry->fhandle, 2233 __entry->offset, __entry->count, 2234 __entry->stateid_seq, __entry->stateid_hash, 2235 __get_str(dstaddr), __entry->nfs_error, 2236 show_nfs4_status(__entry->nfs_error) 2237 ) 2238 ); 2239 2240 #define DEFINE_NFS4_FLEXFILES_IO_EVENT(name) \ 2241 DEFINE_EVENT(nfs4_flexfiles_io_event, name, \ 2242 TP_PROTO( \ 2243 const struct nfs_pgio_header *hdr, \ 2244 int error \ 2245 ), \ 2246 TP_ARGS(hdr, error)) 2247 DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_read_error); 2248 DEFINE_NFS4_FLEXFILES_IO_EVENT(ff_layout_write_error); 2249 2250 TRACE_EVENT(ff_layout_commit_error, 2251 TP_PROTO( 2252 const struct nfs_commit_data *data, 2253 int error 2254 ), 2255 2256 TP_ARGS(data, error), 2257 2258 TP_STRUCT__entry( 2259 __field(unsigned long, error) 2260 __field(unsigned long, nfs_error) 2261 __field(dev_t, dev) 2262 __field(u32, fhandle) 2263 __field(u64, fileid) 2264 __field(loff_t, offset) 2265 __field(u32, count) 2266 __string(dstaddr, data->ds_clp ? 2267 rpc_peeraddr2str(data->ds_clp->cl_rpcclient, 2268 RPC_DISPLAY_ADDR) : "unknown") 2269 ), 2270 2271 TP_fast_assign( 2272 const struct inode *inode = data->inode; 2273 2274 __entry->error = -error; 2275 __entry->nfs_error = data->res.op_status; 2276 __entry->fhandle = nfs_fhandle_hash(data->args.fh); 2277 __entry->fileid = NFS_FILEID(inode); 2278 __entry->dev = inode->i_sb->s_dev; 2279 __entry->offset = data->args.offset; 2280 __entry->count = data->args.count; 2281 __assign_str(dstaddr); 2282 ), 2283 2284 TP_printk( 2285 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2286 "offset=%llu count=%u dstaddr=%s nfs_error=%lu (%s)", 2287 -__entry->error, 2288 show_nfs4_status(__entry->error), 2289 MAJOR(__entry->dev), MINOR(__entry->dev), 2290 (unsigned long long)__entry->fileid, 2291 __entry->fhandle, 2292 __entry->offset, __entry->count, 2293 __get_str(dstaddr), __entry->nfs_error, 2294 show_nfs4_status(__entry->nfs_error) 2295 ) 2296 ); 2297 2298 TRACE_EVENT(bl_ext_tree_prepare_commit, 2299 TP_PROTO( 2300 int ret, 2301 size_t count, 2302 u64 lwb, 2303 bool not_all_ranges 2304 ), 2305 2306 TP_ARGS(ret, count, lwb, not_all_ranges), 2307 2308 TP_STRUCT__entry( 2309 __field(int, ret) 2310 __field(size_t, count) 2311 __field(u64, lwb) 2312 __field(bool, not_all_ranges) 2313 ), 2314 2315 TP_fast_assign( 2316 __entry->ret = ret; 2317 __entry->count = count; 2318 __entry->lwb = lwb; 2319 __entry->not_all_ranges = not_all_ranges; 2320 ), 2321 2322 TP_printk( 2323 "ret=%d, found %zu ranges, lwb=%llu%s", 2324 __entry->ret, 2325 __entry->count, 2326 __entry->lwb, 2327 __entry->not_all_ranges ? ", not all ranges encoded" : 2328 "" 2329 ) 2330 ); 2331 2332 DECLARE_EVENT_CLASS(pnfs_bl_pr_key_class, 2333 TP_PROTO( 2334 const struct block_device *bdev, 2335 u64 key 2336 ), 2337 TP_ARGS(bdev, key), 2338 TP_STRUCT__entry( 2339 __field(u64, key) 2340 __field(dev_t, dev) 2341 __string(device, bdev->bd_disk->disk_name) 2342 ), 2343 TP_fast_assign( 2344 __entry->key = key; 2345 __entry->dev = bdev->bd_dev; 2346 __assign_str(device); 2347 ), 2348 TP_printk("dev=%d,%d (%s) key=0x%016llx", 2349 MAJOR(__entry->dev), MINOR(__entry->dev), 2350 __get_str(device), __entry->key 2351 ) 2352 ); 2353 2354 #define DEFINE_NFS4_BLOCK_PRKEY_EVENT(name) \ 2355 DEFINE_EVENT(pnfs_bl_pr_key_class, name, \ 2356 TP_PROTO( \ 2357 const struct block_device *bdev, \ 2358 u64 key \ 2359 ), \ 2360 TP_ARGS(bdev, key)) 2361 DEFINE_NFS4_BLOCK_PRKEY_EVENT(bl_pr_key_reg); 2362 DEFINE_NFS4_BLOCK_PRKEY_EVENT(bl_pr_key_unreg); 2363 2364 /* 2365 * From uapi/linux/pr.h 2366 */ 2367 TRACE_DEFINE_ENUM(PR_STS_SUCCESS); 2368 TRACE_DEFINE_ENUM(PR_STS_IOERR); 2369 TRACE_DEFINE_ENUM(PR_STS_RESERVATION_CONFLICT); 2370 TRACE_DEFINE_ENUM(PR_STS_RETRY_PATH_FAILURE); 2371 TRACE_DEFINE_ENUM(PR_STS_PATH_FAST_FAILED); 2372 TRACE_DEFINE_ENUM(PR_STS_PATH_FAILED); 2373 2374 #define show_pr_status(x) \ 2375 __print_symbolic(x, \ 2376 { PR_STS_SUCCESS, "SUCCESS" }, \ 2377 { PR_STS_IOERR, "IOERR" }, \ 2378 { PR_STS_RESERVATION_CONFLICT, "RESERVATION_CONFLICT" }, \ 2379 { PR_STS_RETRY_PATH_FAILURE, "RETRY_PATH_FAILURE" }, \ 2380 { PR_STS_PATH_FAST_FAILED, "PATH_FAST_FAILED" }, \ 2381 { PR_STS_PATH_FAILED, "PATH_FAILED" }) 2382 2383 DECLARE_EVENT_CLASS(pnfs_bl_pr_key_err_class, 2384 TP_PROTO( 2385 const struct block_device *bdev, 2386 u64 key, 2387 int status 2388 ), 2389 TP_ARGS(bdev, key, status), 2390 TP_STRUCT__entry( 2391 __field(u64, key) 2392 __field(dev_t, dev) 2393 __field(unsigned long, status) 2394 __string(device, bdev->bd_disk->disk_name) 2395 ), 2396 TP_fast_assign( 2397 __entry->key = key; 2398 __entry->dev = bdev->bd_dev; 2399 __entry->status = status; 2400 __assign_str(device); 2401 ), 2402 TP_printk("dev=%d,%d (%s) key=0x%016llx status=%s", 2403 MAJOR(__entry->dev), MINOR(__entry->dev), 2404 __get_str(device), __entry->key, 2405 show_pr_status(__entry->status) 2406 ) 2407 ); 2408 2409 #define DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(name) \ 2410 DEFINE_EVENT(pnfs_bl_pr_key_err_class, name, \ 2411 TP_PROTO( \ 2412 const struct block_device *bdev, \ 2413 u64 key, \ 2414 int status \ 2415 ), \ 2416 TP_ARGS(bdev, key, status)) 2417 DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(bl_pr_key_reg_err); 2418 DEFINE_NFS4_BLOCK_PRKEY_ERR_EVENT(bl_pr_key_unreg_err); 2419 2420 #ifdef CONFIG_NFS_V4_2 2421 TRACE_DEFINE_ENUM(NFS4_CONTENT_DATA); 2422 TRACE_DEFINE_ENUM(NFS4_CONTENT_HOLE); 2423 2424 #define show_llseek_mode(what) \ 2425 __print_symbolic(what, \ 2426 { NFS4_CONTENT_DATA, "DATA" }, \ 2427 { NFS4_CONTENT_HOLE, "HOLE" }) 2428 2429 TRACE_EVENT(nfs4_llseek, 2430 TP_PROTO( 2431 const struct inode *inode, 2432 const struct nfs42_seek_args *args, 2433 const struct nfs42_seek_res *res, 2434 int error 2435 ), 2436 2437 TP_ARGS(inode, args, res, error), 2438 2439 TP_STRUCT__entry( 2440 __field(unsigned long, error) 2441 __field(u32, fhandle) 2442 __field(u32, fileid) 2443 __field(dev_t, dev) 2444 __field(int, stateid_seq) 2445 __field(u32, stateid_hash) 2446 __field(loff_t, offset_s) 2447 __field(u32, what) 2448 __field(loff_t, offset_r) 2449 __field(u32, eof) 2450 ), 2451 2452 TP_fast_assign( 2453 const struct nfs_inode *nfsi = NFS_I(inode); 2454 const struct nfs_fh *fh = args->sa_fh; 2455 2456 __entry->fileid = nfsi->fileid; 2457 __entry->dev = inode->i_sb->s_dev; 2458 __entry->fhandle = nfs_fhandle_hash(fh); 2459 __entry->offset_s = args->sa_offset; 2460 __entry->stateid_seq = 2461 be32_to_cpu(args->sa_stateid.seqid); 2462 __entry->stateid_hash = 2463 nfs_stateid_hash(&args->sa_stateid); 2464 __entry->what = args->sa_what; 2465 if (error) { 2466 __entry->error = -error; 2467 __entry->offset_r = 0; 2468 __entry->eof = 0; 2469 } else { 2470 __entry->error = 0; 2471 __entry->offset_r = res->sr_offset; 2472 __entry->eof = res->sr_eof; 2473 } 2474 ), 2475 2476 TP_printk( 2477 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2478 "stateid=%d:0x%08x offset_s=%llu what=%s " 2479 "offset_r=%llu eof=%u", 2480 -__entry->error, 2481 show_nfs4_status(__entry->error), 2482 MAJOR(__entry->dev), MINOR(__entry->dev), 2483 (unsigned long long)__entry->fileid, 2484 __entry->fhandle, 2485 __entry->stateid_seq, __entry->stateid_hash, 2486 __entry->offset_s, 2487 show_llseek_mode(__entry->what), 2488 __entry->offset_r, 2489 __entry->eof 2490 ) 2491 ); 2492 2493 DECLARE_EVENT_CLASS(nfs4_sparse_event, 2494 TP_PROTO( 2495 const struct inode *inode, 2496 const struct nfs42_falloc_args *args, 2497 int error 2498 ), 2499 2500 TP_ARGS(inode, args, error), 2501 2502 TP_STRUCT__entry( 2503 __field(unsigned long, error) 2504 __field(loff_t, offset) 2505 __field(loff_t, len) 2506 __field(dev_t, dev) 2507 __field(u32, fhandle) 2508 __field(u64, fileid) 2509 __field(int, stateid_seq) 2510 __field(u32, stateid_hash) 2511 ), 2512 2513 TP_fast_assign( 2514 __entry->error = error < 0 ? -error : 0; 2515 __entry->offset = args->falloc_offset; 2516 __entry->len = args->falloc_length; 2517 __entry->dev = inode->i_sb->s_dev; 2518 __entry->fileid = NFS_FILEID(inode); 2519 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 2520 __entry->stateid_seq = 2521 be32_to_cpu(args->falloc_stateid.seqid); 2522 __entry->stateid_hash = 2523 nfs_stateid_hash(&args->falloc_stateid); 2524 ), 2525 2526 TP_printk( 2527 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2528 "stateid=%d:0x%08x offset=%llu len=%llu", 2529 -__entry->error, 2530 show_nfs4_status(__entry->error), 2531 MAJOR(__entry->dev), MINOR(__entry->dev), 2532 (unsigned long long)__entry->fileid, 2533 __entry->fhandle, 2534 __entry->stateid_seq, __entry->stateid_hash, 2535 (long long)__entry->offset, 2536 (long long)__entry->len 2537 ) 2538 ); 2539 #define DEFINE_NFS4_SPARSE_EVENT(name) \ 2540 DEFINE_EVENT(nfs4_sparse_event, name, \ 2541 TP_PROTO( \ 2542 const struct inode *inode, \ 2543 const struct nfs42_falloc_args *args, \ 2544 int error \ 2545 ), \ 2546 TP_ARGS(inode, args, error)) 2547 DEFINE_NFS4_SPARSE_EVENT(nfs4_fallocate); 2548 DEFINE_NFS4_SPARSE_EVENT(nfs4_deallocate); 2549 2550 TRACE_EVENT(nfs4_copy, 2551 TP_PROTO( 2552 const struct inode *src_inode, 2553 const struct inode *dst_inode, 2554 const struct nfs42_copy_args *args, 2555 const struct nfs42_copy_res *res, 2556 const struct nl4_server *nss, 2557 int error 2558 ), 2559 2560 TP_ARGS(src_inode, dst_inode, args, res, nss, error), 2561 2562 TP_STRUCT__entry( 2563 __field(unsigned long, error) 2564 __field(u32, src_fhandle) 2565 __field(u32, src_fileid) 2566 __field(u32, dst_fhandle) 2567 __field(u32, dst_fileid) 2568 __field(dev_t, src_dev) 2569 __field(dev_t, dst_dev) 2570 __field(int, src_stateid_seq) 2571 __field(u32, src_stateid_hash) 2572 __field(int, dst_stateid_seq) 2573 __field(u32, dst_stateid_hash) 2574 __field(loff_t, src_offset) 2575 __field(loff_t, dst_offset) 2576 __field(bool, sync) 2577 __field(loff_t, len) 2578 __field(int, res_stateid_seq) 2579 __field(u32, res_stateid_hash) 2580 __field(loff_t, res_count) 2581 __field(bool, res_sync) 2582 __field(bool, res_cons) 2583 __field(bool, intra) 2584 ), 2585 2586 TP_fast_assign( 2587 const struct nfs_inode *src_nfsi = NFS_I(src_inode); 2588 const struct nfs_inode *dst_nfsi = NFS_I(dst_inode); 2589 2590 __entry->src_fileid = src_nfsi->fileid; 2591 __entry->src_dev = src_inode->i_sb->s_dev; 2592 __entry->src_fhandle = nfs_fhandle_hash(args->src_fh); 2593 __entry->src_offset = args->src_pos; 2594 __entry->dst_fileid = dst_nfsi->fileid; 2595 __entry->dst_dev = dst_inode->i_sb->s_dev; 2596 __entry->dst_fhandle = nfs_fhandle_hash(args->dst_fh); 2597 __entry->dst_offset = args->dst_pos; 2598 __entry->len = args->count; 2599 __entry->sync = args->sync; 2600 __entry->src_stateid_seq = 2601 be32_to_cpu(args->src_stateid.seqid); 2602 __entry->src_stateid_hash = 2603 nfs_stateid_hash(&args->src_stateid); 2604 __entry->dst_stateid_seq = 2605 be32_to_cpu(args->dst_stateid.seqid); 2606 __entry->dst_stateid_hash = 2607 nfs_stateid_hash(&args->dst_stateid); 2608 __entry->intra = nss ? 0 : 1; 2609 if (error) { 2610 __entry->error = -error; 2611 __entry->res_stateid_seq = 0; 2612 __entry->res_stateid_hash = 0; 2613 __entry->res_count = 0; 2614 __entry->res_sync = 0; 2615 __entry->res_cons = 0; 2616 } else { 2617 __entry->error = 0; 2618 __entry->res_stateid_seq = 2619 be32_to_cpu(res->write_res.stateid.seqid); 2620 __entry->res_stateid_hash = 2621 nfs_stateid_hash(&res->write_res.stateid); 2622 __entry->res_count = res->write_res.count; 2623 __entry->res_sync = res->synchronous; 2624 __entry->res_cons = res->consecutive; 2625 } 2626 ), 2627 2628 TP_printk( 2629 "error=%ld (%s) intra=%d src_fileid=%02x:%02x:%llu " 2630 "src_fhandle=0x%08x dst_fileid=%02x:%02x:%llu " 2631 "dst_fhandle=0x%08x src_stateid=%d:0x%08x " 2632 "dst_stateid=%d:0x%08x src_offset=%llu dst_offset=%llu " 2633 "len=%llu sync=%d cb_stateid=%d:0x%08x res_sync=%d " 2634 "res_cons=%d res_count=%llu", 2635 -__entry->error, 2636 show_nfs4_status(__entry->error), 2637 __entry->intra, 2638 MAJOR(__entry->src_dev), MINOR(__entry->src_dev), 2639 (unsigned long long)__entry->src_fileid, 2640 __entry->src_fhandle, 2641 MAJOR(__entry->dst_dev), MINOR(__entry->dst_dev), 2642 (unsigned long long)__entry->dst_fileid, 2643 __entry->dst_fhandle, 2644 __entry->src_stateid_seq, __entry->src_stateid_hash, 2645 __entry->dst_stateid_seq, __entry->dst_stateid_hash, 2646 __entry->src_offset, 2647 __entry->dst_offset, 2648 __entry->len, 2649 __entry->sync, 2650 __entry->res_stateid_seq, __entry->res_stateid_hash, 2651 __entry->res_sync, 2652 __entry->res_cons, 2653 __entry->res_count 2654 ) 2655 ); 2656 2657 TRACE_EVENT(nfs4_clone, 2658 TP_PROTO( 2659 const struct inode *src_inode, 2660 const struct inode *dst_inode, 2661 const struct nfs42_clone_args *args, 2662 int error 2663 ), 2664 2665 TP_ARGS(src_inode, dst_inode, args, error), 2666 2667 TP_STRUCT__entry( 2668 __field(unsigned long, error) 2669 __field(u32, src_fhandle) 2670 __field(u32, src_fileid) 2671 __field(u32, dst_fhandle) 2672 __field(u32, dst_fileid) 2673 __field(dev_t, src_dev) 2674 __field(dev_t, dst_dev) 2675 __field(loff_t, src_offset) 2676 __field(loff_t, dst_offset) 2677 __field(int, src_stateid_seq) 2678 __field(u32, src_stateid_hash) 2679 __field(int, dst_stateid_seq) 2680 __field(u32, dst_stateid_hash) 2681 __field(loff_t, len) 2682 ), 2683 2684 TP_fast_assign( 2685 const struct nfs_inode *src_nfsi = NFS_I(src_inode); 2686 const struct nfs_inode *dst_nfsi = NFS_I(dst_inode); 2687 2688 __entry->src_fileid = src_nfsi->fileid; 2689 __entry->src_dev = src_inode->i_sb->s_dev; 2690 __entry->src_fhandle = nfs_fhandle_hash(args->src_fh); 2691 __entry->src_offset = args->src_offset; 2692 __entry->dst_fileid = dst_nfsi->fileid; 2693 __entry->dst_dev = dst_inode->i_sb->s_dev; 2694 __entry->dst_fhandle = nfs_fhandle_hash(args->dst_fh); 2695 __entry->dst_offset = args->dst_offset; 2696 __entry->len = args->count; 2697 __entry->error = error < 0 ? -error : 0; 2698 __entry->src_stateid_seq = 2699 be32_to_cpu(args->src_stateid.seqid); 2700 __entry->src_stateid_hash = 2701 nfs_stateid_hash(&args->src_stateid); 2702 __entry->dst_stateid_seq = 2703 be32_to_cpu(args->dst_stateid.seqid); 2704 __entry->dst_stateid_hash = 2705 nfs_stateid_hash(&args->dst_stateid); 2706 ), 2707 2708 TP_printk( 2709 "error=%ld (%s) src_fileid=%02x:%02x:%llu " 2710 "src_fhandle=0x%08x dst_fileid=%02x:%02x:%llu " 2711 "dst_fhandle=0x%08x src_stateid=%d:0x%08x " 2712 "dst_stateid=%d:0x%08x src_offset=%llu " 2713 "dst_offset=%llu len=%llu", 2714 -__entry->error, 2715 show_nfs4_status(__entry->error), 2716 MAJOR(__entry->src_dev), MINOR(__entry->src_dev), 2717 (unsigned long long)__entry->src_fileid, 2718 __entry->src_fhandle, 2719 MAJOR(__entry->dst_dev), MINOR(__entry->dst_dev), 2720 (unsigned long long)__entry->dst_fileid, 2721 __entry->dst_fhandle, 2722 __entry->src_stateid_seq, __entry->src_stateid_hash, 2723 __entry->dst_stateid_seq, __entry->dst_stateid_hash, 2724 __entry->src_offset, 2725 __entry->dst_offset, 2726 __entry->len 2727 ) 2728 ); 2729 2730 TRACE_EVENT(nfs4_copy_notify, 2731 TP_PROTO( 2732 const struct inode *inode, 2733 const struct nfs42_copy_notify_args *args, 2734 const struct nfs42_copy_notify_res *res, 2735 int error 2736 ), 2737 2738 TP_ARGS(inode, args, res, error), 2739 2740 TP_STRUCT__entry( 2741 __field(unsigned long, error) 2742 __field(u32, fhandle) 2743 __field(u32, fileid) 2744 __field(dev_t, dev) 2745 __field(int, stateid_seq) 2746 __field(u32, stateid_hash) 2747 __field(int, res_stateid_seq) 2748 __field(u32, res_stateid_hash) 2749 ), 2750 2751 TP_fast_assign( 2752 const struct nfs_inode *nfsi = NFS_I(inode); 2753 2754 __entry->fileid = nfsi->fileid; 2755 __entry->dev = inode->i_sb->s_dev; 2756 __entry->fhandle = nfs_fhandle_hash(args->cna_src_fh); 2757 __entry->stateid_seq = 2758 be32_to_cpu(args->cna_src_stateid.seqid); 2759 __entry->stateid_hash = 2760 nfs_stateid_hash(&args->cna_src_stateid); 2761 if (error) { 2762 __entry->error = -error; 2763 __entry->res_stateid_seq = 0; 2764 __entry->res_stateid_hash = 0; 2765 } else { 2766 __entry->error = 0; 2767 __entry->res_stateid_seq = 2768 be32_to_cpu(res->cnr_stateid.seqid); 2769 __entry->res_stateid_hash = 2770 nfs_stateid_hash(&res->cnr_stateid); 2771 } 2772 ), 2773 2774 TP_printk( 2775 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2776 "stateid=%d:0x%08x res_stateid=%d:0x%08x", 2777 -__entry->error, 2778 show_nfs4_status(__entry->error), 2779 MAJOR(__entry->dev), MINOR(__entry->dev), 2780 (unsigned long long)__entry->fileid, 2781 __entry->fhandle, 2782 __entry->stateid_seq, __entry->stateid_hash, 2783 __entry->res_stateid_seq, __entry->res_stateid_hash 2784 ) 2785 ); 2786 2787 DECLARE_EVENT_CLASS(nfs4_offload_class, 2788 TP_PROTO( 2789 const struct nfs42_offload_status_args *args, 2790 int error 2791 ), 2792 2793 TP_ARGS(args, error), 2794 2795 TP_STRUCT__entry( 2796 __field(unsigned long, error) 2797 __field(u32, fhandle) 2798 __field(int, stateid_seq) 2799 __field(u32, stateid_hash) 2800 ), 2801 2802 TP_fast_assign( 2803 __entry->fhandle = nfs_fhandle_hash(args->osa_src_fh); 2804 __entry->error = error < 0 ? -error : 0; 2805 __entry->stateid_seq = 2806 be32_to_cpu(args->osa_stateid.seqid); 2807 __entry->stateid_hash = 2808 nfs_stateid_hash(&args->osa_stateid); 2809 ), 2810 2811 TP_printk( 2812 "error=%ld (%s) fhandle=0x%08x stateid=%d:0x%08x", 2813 -__entry->error, 2814 show_nfs4_status(__entry->error), 2815 __entry->fhandle, 2816 __entry->stateid_seq, __entry->stateid_hash 2817 ) 2818 ); 2819 #define DEFINE_NFS4_OFFLOAD_EVENT(name) \ 2820 DEFINE_EVENT(nfs4_offload_class, name, \ 2821 TP_PROTO( \ 2822 const struct nfs42_offload_status_args *args, \ 2823 int error \ 2824 ), \ 2825 TP_ARGS(args, error)) 2826 DEFINE_NFS4_OFFLOAD_EVENT(nfs4_offload_cancel); 2827 DEFINE_NFS4_OFFLOAD_EVENT(nfs4_offload_status); 2828 2829 DECLARE_EVENT_CLASS(nfs4_xattr_event, 2830 TP_PROTO( 2831 const struct inode *inode, 2832 const char *name, 2833 int error 2834 ), 2835 2836 TP_ARGS(inode, name, error), 2837 2838 TP_STRUCT__entry( 2839 __field(unsigned long, error) 2840 __field(dev_t, dev) 2841 __field(u32, fhandle) 2842 __field(u64, fileid) 2843 __string(name, name) 2844 ), 2845 2846 TP_fast_assign( 2847 __entry->error = error < 0 ? -error : 0; 2848 __entry->dev = inode->i_sb->s_dev; 2849 __entry->fileid = NFS_FILEID(inode); 2850 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode)); 2851 __assign_str(name); 2852 ), 2853 2854 TP_printk( 2855 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 2856 "name=%s", 2857 -__entry->error, show_nfs4_status(__entry->error), 2858 MAJOR(__entry->dev), MINOR(__entry->dev), 2859 (unsigned long long)__entry->fileid, 2860 __entry->fhandle, __get_str(name) 2861 ) 2862 ); 2863 #define DEFINE_NFS4_XATTR_EVENT(name) \ 2864 DEFINE_EVENT(nfs4_xattr_event, name, \ 2865 TP_PROTO( \ 2866 const struct inode *inode, \ 2867 const char *name, \ 2868 int error \ 2869 ), \ 2870 TP_ARGS(inode, name, error)) 2871 DEFINE_NFS4_XATTR_EVENT(nfs4_getxattr); 2872 DEFINE_NFS4_XATTR_EVENT(nfs4_setxattr); 2873 DEFINE_NFS4_XATTR_EVENT(nfs4_removexattr); 2874 2875 DEFINE_NFS4_INODE_EVENT(nfs4_listxattr); 2876 #endif /* CONFIG_NFS_V4_2 */ 2877 2878 #endif /* CONFIG_NFS_V4_1 */ 2879 2880 #endif /* _TRACE_NFS4_H */ 2881 2882 #undef TRACE_INCLUDE_PATH 2883 #define TRACE_INCLUDE_PATH . 2884 #define TRACE_INCLUDE_FILE nfs4trace 2885 /* This part must be outside protection */ 2886 #include <trace/define_trace.h> 2887