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