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