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 nfs 7 8 #if !defined(_TRACE_NFS_H) || defined(TRACE_HEADER_MULTI_READ) 9 #define _TRACE_NFS_H 10 11 #include <linux/tracepoint.h> 12 #include <linux/iversion.h> 13 14 #include <trace/events/fs.h> 15 #include <trace/events/nfs.h> 16 #include <trace/events/sunrpc_base.h> 17 18 #define nfs_show_cache_validity(v) \ 19 __print_flags(v, "|", \ 20 { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \ 21 { NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \ 22 { NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \ 23 { NFS_INO_INVALID_ACL, "INVALID_ACL" }, \ 24 { NFS_INO_REVAL_FORCED, "REVAL_FORCED" }, \ 25 { NFS_INO_INVALID_LABEL, "INVALID_LABEL" }, \ 26 { NFS_INO_INVALID_CHANGE, "INVALID_CHANGE" }, \ 27 { NFS_INO_INVALID_CTIME, "INVALID_CTIME" }, \ 28 { NFS_INO_INVALID_MTIME, "INVALID_MTIME" }, \ 29 { NFS_INO_INVALID_SIZE, "INVALID_SIZE" }, \ 30 { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }, \ 31 { NFS_INO_DATA_INVAL_DEFER, "DATA_INVAL_DEFER" }, \ 32 { NFS_INO_INVALID_BLOCKS, "INVALID_BLOCKS" }, \ 33 { NFS_INO_INVALID_XATTR, "INVALID_XATTR" }, \ 34 { NFS_INO_INVALID_NLINK, "INVALID_NLINK" }, \ 35 { NFS_INO_INVALID_MODE, "INVALID_MODE" }) 36 37 #define nfs_show_nfsi_flags(v) \ 38 __print_flags(v, "|", \ 39 { BIT(NFS_INO_ADVISE_RDPLUS), "ADVISE_RDPLUS" }, \ 40 { BIT(NFS_INO_STALE), "STALE" }, \ 41 { BIT(NFS_INO_ACL_LRU_SET), "ACL_LRU_SET" }, \ 42 { BIT(NFS_INO_INVALIDATING), "INVALIDATING" }, \ 43 { BIT(NFS_INO_FSCACHE), "FSCACHE" }, \ 44 { BIT(NFS_INO_LAYOUTCOMMIT), "NEED_LAYOUTCOMMIT" }, \ 45 { BIT(NFS_INO_LAYOUTCOMMITTING), "LAYOUTCOMMIT" }, \ 46 { BIT(NFS_INO_LAYOUTSTATS), "LAYOUTSTATS" }, \ 47 { BIT(NFS_INO_ODIRECT), "ODIRECT" }) 48 49 DECLARE_EVENT_CLASS(nfs_inode_event, 50 TP_PROTO( 51 const struct inode *inode 52 ), 53 54 TP_ARGS(inode), 55 56 TP_STRUCT__entry( 57 __field(dev_t, dev) 58 __field(u32, fhandle) 59 __field(u64, fileid) 60 __field(u64, version) 61 ), 62 63 TP_fast_assign( 64 const struct nfs_inode *nfsi = NFS_I(inode); 65 __entry->dev = inode->i_sb->s_dev; 66 __entry->fileid = nfsi->fileid; 67 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 68 __entry->version = inode_peek_iversion_raw(inode); 69 ), 70 71 TP_printk( 72 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ", 73 MAJOR(__entry->dev), MINOR(__entry->dev), 74 (unsigned long long)__entry->fileid, 75 __entry->fhandle, 76 (unsigned long long)__entry->version 77 ) 78 ); 79 80 DECLARE_EVENT_CLASS(nfs_inode_event_done, 81 TP_PROTO( 82 const struct inode *inode, 83 int error 84 ), 85 86 TP_ARGS(inode, error), 87 88 TP_STRUCT__entry( 89 __field(unsigned long, error) 90 __field(dev_t, dev) 91 __field(u32, fhandle) 92 __field(unsigned char, type) 93 __field(u64, fileid) 94 __field(u64, version) 95 __field(loff_t, size) 96 __field(unsigned long, nfsi_flags) 97 __field(unsigned long, cache_validity) 98 ), 99 100 TP_fast_assign( 101 const struct nfs_inode *nfsi = NFS_I(inode); 102 __entry->error = error < 0 ? -error : 0; 103 __entry->dev = inode->i_sb->s_dev; 104 __entry->fileid = nfsi->fileid; 105 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 106 __entry->type = nfs_umode_to_dtype(inode->i_mode); 107 __entry->version = inode_peek_iversion_raw(inode); 108 __entry->size = i_size_read(inode); 109 __entry->nfsi_flags = nfsi->flags; 110 __entry->cache_validity = nfsi->cache_validity; 111 ), 112 113 TP_printk( 114 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 115 "type=%u (%s) version=%llu size=%lld " 116 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s)", 117 -__entry->error, show_nfs_status(__entry->error), 118 MAJOR(__entry->dev), MINOR(__entry->dev), 119 (unsigned long long)__entry->fileid, 120 __entry->fhandle, 121 __entry->type, 122 show_fs_dirent_type(__entry->type), 123 (unsigned long long)__entry->version, 124 (long long)__entry->size, 125 __entry->cache_validity, 126 nfs_show_cache_validity(__entry->cache_validity), 127 __entry->nfsi_flags, 128 nfs_show_nfsi_flags(__entry->nfsi_flags) 129 ) 130 ); 131 132 #define DEFINE_NFS_INODE_EVENT(name) \ 133 DEFINE_EVENT(nfs_inode_event, name, \ 134 TP_PROTO( \ 135 const struct inode *inode \ 136 ), \ 137 TP_ARGS(inode)) 138 #define DEFINE_NFS_INODE_EVENT_DONE(name) \ 139 DEFINE_EVENT(nfs_inode_event_done, name, \ 140 TP_PROTO( \ 141 const struct inode *inode, \ 142 int error \ 143 ), \ 144 TP_ARGS(inode, error)) 145 DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale); 146 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter); 147 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit); 148 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter); 149 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit); 150 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter); 151 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit); 152 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 153 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 154 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 155 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); 156 DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter); 157 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit); 158 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter); 159 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit); 160 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 161 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 162 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 163 DEFINE_NFS_INODE_EVENT_DONE(nfs_set_cache_invalid); 164 165 TRACE_EVENT(nfs_access_exit, 166 TP_PROTO( 167 const struct inode *inode, 168 unsigned int mask, 169 unsigned int permitted, 170 int error 171 ), 172 173 TP_ARGS(inode, mask, permitted, error), 174 175 TP_STRUCT__entry( 176 __field(unsigned long, error) 177 __field(dev_t, dev) 178 __field(u32, fhandle) 179 __field(unsigned char, type) 180 __field(u64, fileid) 181 __field(u64, version) 182 __field(loff_t, size) 183 __field(unsigned long, nfsi_flags) 184 __field(unsigned long, cache_validity) 185 __field(unsigned int, mask) 186 __field(unsigned int, permitted) 187 ), 188 189 TP_fast_assign( 190 const struct nfs_inode *nfsi = NFS_I(inode); 191 __entry->error = error < 0 ? -error : 0; 192 __entry->dev = inode->i_sb->s_dev; 193 __entry->fileid = nfsi->fileid; 194 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 195 __entry->type = nfs_umode_to_dtype(inode->i_mode); 196 __entry->version = inode_peek_iversion_raw(inode); 197 __entry->size = i_size_read(inode); 198 __entry->nfsi_flags = nfsi->flags; 199 __entry->cache_validity = nfsi->cache_validity; 200 __entry->mask = mask; 201 __entry->permitted = permitted; 202 ), 203 204 TP_printk( 205 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 206 "type=%u (%s) version=%llu size=%lld " 207 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s) " 208 "mask=0x%x permitted=0x%x", 209 -__entry->error, show_nfs_status(__entry->error), 210 MAJOR(__entry->dev), MINOR(__entry->dev), 211 (unsigned long long)__entry->fileid, 212 __entry->fhandle, 213 __entry->type, 214 show_fs_dirent_type(__entry->type), 215 (unsigned long long)__entry->version, 216 (long long)__entry->size, 217 __entry->cache_validity, 218 nfs_show_cache_validity(__entry->cache_validity), 219 __entry->nfsi_flags, 220 nfs_show_nfsi_flags(__entry->nfsi_flags), 221 __entry->mask, __entry->permitted 222 ) 223 ); 224 225 DECLARE_EVENT_CLASS(nfs_update_size_class, 226 TP_PROTO( 227 const struct inode *inode, 228 loff_t new_size 229 ), 230 231 TP_ARGS(inode, new_size), 232 233 TP_STRUCT__entry( 234 __field(dev_t, dev) 235 __field(u32, fhandle) 236 __field(u64, fileid) 237 __field(u64, version) 238 __field(loff_t, cur_size) 239 __field(loff_t, new_size) 240 ), 241 242 TP_fast_assign( 243 const struct nfs_inode *nfsi = NFS_I(inode); 244 245 __entry->dev = inode->i_sb->s_dev; 246 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 247 __entry->fileid = nfsi->fileid; 248 __entry->version = inode_peek_iversion_raw(inode); 249 __entry->cur_size = i_size_read(inode); 250 __entry->new_size = new_size; 251 ), 252 253 TP_printk( 254 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu cursize=%lld newsize=%lld", 255 MAJOR(__entry->dev), MINOR(__entry->dev), 256 (unsigned long long)__entry->fileid, 257 __entry->fhandle, __entry->version, 258 __entry->cur_size, __entry->new_size 259 ) 260 ); 261 262 #define DEFINE_NFS_UPDATE_SIZE_EVENT(name) \ 263 DEFINE_EVENT(nfs_update_size_class, nfs_size_##name, \ 264 TP_PROTO( \ 265 const struct inode *inode, \ 266 loff_t new_size \ 267 ), \ 268 TP_ARGS(inode, new_size)) 269 270 DEFINE_NFS_UPDATE_SIZE_EVENT(truncate); 271 DEFINE_NFS_UPDATE_SIZE_EVENT(wcc); 272 DEFINE_NFS_UPDATE_SIZE_EVENT(update); 273 DEFINE_NFS_UPDATE_SIZE_EVENT(grow); 274 275 DECLARE_EVENT_CLASS(nfs_lookup_event, 276 TP_PROTO( 277 const struct inode *dir, 278 const struct dentry *dentry, 279 unsigned int flags 280 ), 281 282 TP_ARGS(dir, dentry, flags), 283 284 TP_STRUCT__entry( 285 __field(unsigned long, flags) 286 __field(dev_t, dev) 287 __field(u64, dir) 288 __string(name, dentry->d_name.name) 289 ), 290 291 TP_fast_assign( 292 __entry->dev = dir->i_sb->s_dev; 293 __entry->dir = NFS_FILEID(dir); 294 __entry->flags = flags; 295 __assign_str(name, dentry->d_name.name); 296 ), 297 298 TP_printk( 299 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 300 __entry->flags, 301 show_fs_lookup_flags(__entry->flags), 302 MAJOR(__entry->dev), MINOR(__entry->dev), 303 (unsigned long long)__entry->dir, 304 __get_str(name) 305 ) 306 ); 307 308 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 309 DEFINE_EVENT(nfs_lookup_event, name, \ 310 TP_PROTO( \ 311 const struct inode *dir, \ 312 const struct dentry *dentry, \ 313 unsigned int flags \ 314 ), \ 315 TP_ARGS(dir, dentry, flags)) 316 317 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 318 TP_PROTO( 319 const struct inode *dir, 320 const struct dentry *dentry, 321 unsigned int flags, 322 int error 323 ), 324 325 TP_ARGS(dir, dentry, flags, error), 326 327 TP_STRUCT__entry( 328 __field(unsigned long, error) 329 __field(unsigned long, flags) 330 __field(dev_t, dev) 331 __field(u64, dir) 332 __string(name, dentry->d_name.name) 333 ), 334 335 TP_fast_assign( 336 __entry->dev = dir->i_sb->s_dev; 337 __entry->dir = NFS_FILEID(dir); 338 __entry->error = error < 0 ? -error : 0; 339 __entry->flags = flags; 340 __assign_str(name, dentry->d_name.name); 341 ), 342 343 TP_printk( 344 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 345 -__entry->error, show_nfs_status(__entry->error), 346 __entry->flags, 347 show_fs_lookup_flags(__entry->flags), 348 MAJOR(__entry->dev), MINOR(__entry->dev), 349 (unsigned long long)__entry->dir, 350 __get_str(name) 351 ) 352 ); 353 354 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 355 DEFINE_EVENT(nfs_lookup_event_done, name, \ 356 TP_PROTO( \ 357 const struct inode *dir, \ 358 const struct dentry *dentry, \ 359 unsigned int flags, \ 360 int error \ 361 ), \ 362 TP_ARGS(dir, dentry, flags, error)) 363 364 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 365 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 366 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter); 367 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit); 368 369 TRACE_EVENT(nfs_atomic_open_enter, 370 TP_PROTO( 371 const struct inode *dir, 372 const struct nfs_open_context *ctx, 373 unsigned int flags 374 ), 375 376 TP_ARGS(dir, ctx, flags), 377 378 TP_STRUCT__entry( 379 __field(unsigned long, flags) 380 __field(unsigned long, fmode) 381 __field(dev_t, dev) 382 __field(u64, dir) 383 __string(name, ctx->dentry->d_name.name) 384 ), 385 386 TP_fast_assign( 387 __entry->dev = dir->i_sb->s_dev; 388 __entry->dir = NFS_FILEID(dir); 389 __entry->flags = flags; 390 __entry->fmode = (__force unsigned long)ctx->mode; 391 __assign_str(name, ctx->dentry->d_name.name); 392 ), 393 394 TP_printk( 395 "flags=0x%lx (%s) fmode=%s name=%02x:%02x:%llu/%s", 396 __entry->flags, 397 show_fs_fcntl_open_flags(__entry->flags), 398 show_fs_fmode_flags(__entry->fmode), 399 MAJOR(__entry->dev), MINOR(__entry->dev), 400 (unsigned long long)__entry->dir, 401 __get_str(name) 402 ) 403 ); 404 405 TRACE_EVENT(nfs_atomic_open_exit, 406 TP_PROTO( 407 const struct inode *dir, 408 const struct nfs_open_context *ctx, 409 unsigned int flags, 410 int error 411 ), 412 413 TP_ARGS(dir, ctx, flags, error), 414 415 TP_STRUCT__entry( 416 __field(unsigned long, error) 417 __field(unsigned long, flags) 418 __field(unsigned long, fmode) 419 __field(dev_t, dev) 420 __field(u64, dir) 421 __string(name, ctx->dentry->d_name.name) 422 ), 423 424 TP_fast_assign( 425 __entry->error = -error; 426 __entry->dev = dir->i_sb->s_dev; 427 __entry->dir = NFS_FILEID(dir); 428 __entry->flags = flags; 429 __entry->fmode = (__force unsigned long)ctx->mode; 430 __assign_str(name, ctx->dentry->d_name.name); 431 ), 432 433 TP_printk( 434 "error=%ld (%s) flags=0x%lx (%s) fmode=%s " 435 "name=%02x:%02x:%llu/%s", 436 -__entry->error, show_nfs_status(__entry->error), 437 __entry->flags, 438 show_fs_fcntl_open_flags(__entry->flags), 439 show_fs_fmode_flags(__entry->fmode), 440 MAJOR(__entry->dev), MINOR(__entry->dev), 441 (unsigned long long)__entry->dir, 442 __get_str(name) 443 ) 444 ); 445 446 TRACE_EVENT(nfs_create_enter, 447 TP_PROTO( 448 const struct inode *dir, 449 const struct dentry *dentry, 450 unsigned int flags 451 ), 452 453 TP_ARGS(dir, dentry, flags), 454 455 TP_STRUCT__entry( 456 __field(unsigned long, flags) 457 __field(dev_t, dev) 458 __field(u64, dir) 459 __string(name, dentry->d_name.name) 460 ), 461 462 TP_fast_assign( 463 __entry->dev = dir->i_sb->s_dev; 464 __entry->dir = NFS_FILEID(dir); 465 __entry->flags = flags; 466 __assign_str(name, dentry->d_name.name); 467 ), 468 469 TP_printk( 470 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 471 __entry->flags, 472 show_fs_fcntl_open_flags(__entry->flags), 473 MAJOR(__entry->dev), MINOR(__entry->dev), 474 (unsigned long long)__entry->dir, 475 __get_str(name) 476 ) 477 ); 478 479 TRACE_EVENT(nfs_create_exit, 480 TP_PROTO( 481 const struct inode *dir, 482 const struct dentry *dentry, 483 unsigned int flags, 484 int error 485 ), 486 487 TP_ARGS(dir, dentry, flags, error), 488 489 TP_STRUCT__entry( 490 __field(unsigned long, error) 491 __field(unsigned long, flags) 492 __field(dev_t, dev) 493 __field(u64, dir) 494 __string(name, dentry->d_name.name) 495 ), 496 497 TP_fast_assign( 498 __entry->error = -error; 499 __entry->dev = dir->i_sb->s_dev; 500 __entry->dir = NFS_FILEID(dir); 501 __entry->flags = flags; 502 __assign_str(name, dentry->d_name.name); 503 ), 504 505 TP_printk( 506 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 507 -__entry->error, show_nfs_status(__entry->error), 508 __entry->flags, 509 show_fs_fcntl_open_flags(__entry->flags), 510 MAJOR(__entry->dev), MINOR(__entry->dev), 511 (unsigned long long)__entry->dir, 512 __get_str(name) 513 ) 514 ); 515 516 DECLARE_EVENT_CLASS(nfs_directory_event, 517 TP_PROTO( 518 const struct inode *dir, 519 const struct dentry *dentry 520 ), 521 522 TP_ARGS(dir, dentry), 523 524 TP_STRUCT__entry( 525 __field(dev_t, dev) 526 __field(u64, dir) 527 __string(name, dentry->d_name.name) 528 ), 529 530 TP_fast_assign( 531 __entry->dev = dir->i_sb->s_dev; 532 __entry->dir = NFS_FILEID(dir); 533 __assign_str(name, dentry->d_name.name); 534 ), 535 536 TP_printk( 537 "name=%02x:%02x:%llu/%s", 538 MAJOR(__entry->dev), MINOR(__entry->dev), 539 (unsigned long long)__entry->dir, 540 __get_str(name) 541 ) 542 ); 543 544 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 545 DEFINE_EVENT(nfs_directory_event, name, \ 546 TP_PROTO( \ 547 const struct inode *dir, \ 548 const struct dentry *dentry \ 549 ), \ 550 TP_ARGS(dir, dentry)) 551 552 DECLARE_EVENT_CLASS(nfs_directory_event_done, 553 TP_PROTO( 554 const struct inode *dir, 555 const struct dentry *dentry, 556 int error 557 ), 558 559 TP_ARGS(dir, dentry, error), 560 561 TP_STRUCT__entry( 562 __field(unsigned long, error) 563 __field(dev_t, dev) 564 __field(u64, dir) 565 __string(name, dentry->d_name.name) 566 ), 567 568 TP_fast_assign( 569 __entry->dev = dir->i_sb->s_dev; 570 __entry->dir = NFS_FILEID(dir); 571 __entry->error = error < 0 ? -error : 0; 572 __assign_str(name, dentry->d_name.name); 573 ), 574 575 TP_printk( 576 "error=%ld (%s) name=%02x:%02x:%llu/%s", 577 -__entry->error, show_nfs_status(__entry->error), 578 MAJOR(__entry->dev), MINOR(__entry->dev), 579 (unsigned long long)__entry->dir, 580 __get_str(name) 581 ) 582 ); 583 584 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \ 585 DEFINE_EVENT(nfs_directory_event_done, name, \ 586 TP_PROTO( \ 587 const struct inode *dir, \ 588 const struct dentry *dentry, \ 589 int error \ 590 ), \ 591 TP_ARGS(dir, dentry, error)) 592 593 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 594 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit); 595 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 596 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit); 597 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 598 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit); 599 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 600 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit); 601 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 602 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit); 603 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 604 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit); 605 606 TRACE_EVENT(nfs_link_enter, 607 TP_PROTO( 608 const struct inode *inode, 609 const struct inode *dir, 610 const struct dentry *dentry 611 ), 612 613 TP_ARGS(inode, dir, dentry), 614 615 TP_STRUCT__entry( 616 __field(dev_t, dev) 617 __field(u64, fileid) 618 __field(u64, dir) 619 __string(name, dentry->d_name.name) 620 ), 621 622 TP_fast_assign( 623 __entry->dev = inode->i_sb->s_dev; 624 __entry->fileid = NFS_FILEID(inode); 625 __entry->dir = NFS_FILEID(dir); 626 __assign_str(name, dentry->d_name.name); 627 ), 628 629 TP_printk( 630 "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 631 MAJOR(__entry->dev), MINOR(__entry->dev), 632 __entry->fileid, 633 MAJOR(__entry->dev), MINOR(__entry->dev), 634 (unsigned long long)__entry->dir, 635 __get_str(name) 636 ) 637 ); 638 639 TRACE_EVENT(nfs_link_exit, 640 TP_PROTO( 641 const struct inode *inode, 642 const struct inode *dir, 643 const struct dentry *dentry, 644 int error 645 ), 646 647 TP_ARGS(inode, dir, dentry, error), 648 649 TP_STRUCT__entry( 650 __field(unsigned long, error) 651 __field(dev_t, dev) 652 __field(u64, fileid) 653 __field(u64, dir) 654 __string(name, dentry->d_name.name) 655 ), 656 657 TP_fast_assign( 658 __entry->dev = inode->i_sb->s_dev; 659 __entry->fileid = NFS_FILEID(inode); 660 __entry->dir = NFS_FILEID(dir); 661 __entry->error = error < 0 ? -error : 0; 662 __assign_str(name, dentry->d_name.name); 663 ), 664 665 TP_printk( 666 "error=%ld (%s) fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 667 -__entry->error, show_nfs_status(__entry->error), 668 MAJOR(__entry->dev), MINOR(__entry->dev), 669 __entry->fileid, 670 MAJOR(__entry->dev), MINOR(__entry->dev), 671 (unsigned long long)__entry->dir, 672 __get_str(name) 673 ) 674 ); 675 676 DECLARE_EVENT_CLASS(nfs_rename_event, 677 TP_PROTO( 678 const struct inode *old_dir, 679 const struct dentry *old_dentry, 680 const struct inode *new_dir, 681 const struct dentry *new_dentry 682 ), 683 684 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry), 685 686 TP_STRUCT__entry( 687 __field(dev_t, dev) 688 __field(u64, old_dir) 689 __field(u64, new_dir) 690 __string(old_name, old_dentry->d_name.name) 691 __string(new_name, new_dentry->d_name.name) 692 ), 693 694 TP_fast_assign( 695 __entry->dev = old_dir->i_sb->s_dev; 696 __entry->old_dir = NFS_FILEID(old_dir); 697 __entry->new_dir = NFS_FILEID(new_dir); 698 __assign_str(old_name, old_dentry->d_name.name); 699 __assign_str(new_name, new_dentry->d_name.name); 700 ), 701 702 TP_printk( 703 "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s", 704 MAJOR(__entry->dev), MINOR(__entry->dev), 705 (unsigned long long)__entry->old_dir, 706 __get_str(old_name), 707 MAJOR(__entry->dev), MINOR(__entry->dev), 708 (unsigned long long)__entry->new_dir, 709 __get_str(new_name) 710 ) 711 ); 712 #define DEFINE_NFS_RENAME_EVENT(name) \ 713 DEFINE_EVENT(nfs_rename_event, name, \ 714 TP_PROTO( \ 715 const struct inode *old_dir, \ 716 const struct dentry *old_dentry, \ 717 const struct inode *new_dir, \ 718 const struct dentry *new_dentry \ 719 ), \ 720 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry)) 721 722 DECLARE_EVENT_CLASS(nfs_rename_event_done, 723 TP_PROTO( 724 const struct inode *old_dir, 725 const struct dentry *old_dentry, 726 const struct inode *new_dir, 727 const struct dentry *new_dentry, 728 int error 729 ), 730 731 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error), 732 733 TP_STRUCT__entry( 734 __field(dev_t, dev) 735 __field(unsigned long, error) 736 __field(u64, old_dir) 737 __string(old_name, old_dentry->d_name.name) 738 __field(u64, new_dir) 739 __string(new_name, new_dentry->d_name.name) 740 ), 741 742 TP_fast_assign( 743 __entry->dev = old_dir->i_sb->s_dev; 744 __entry->error = -error; 745 __entry->old_dir = NFS_FILEID(old_dir); 746 __entry->new_dir = NFS_FILEID(new_dir); 747 __assign_str(old_name, old_dentry->d_name.name); 748 __assign_str(new_name, new_dentry->d_name.name); 749 ), 750 751 TP_printk( 752 "error=%ld (%s) old_name=%02x:%02x:%llu/%s " 753 "new_name=%02x:%02x:%llu/%s", 754 -__entry->error, show_nfs_status(__entry->error), 755 MAJOR(__entry->dev), MINOR(__entry->dev), 756 (unsigned long long)__entry->old_dir, 757 __get_str(old_name), 758 MAJOR(__entry->dev), MINOR(__entry->dev), 759 (unsigned long long)__entry->new_dir, 760 __get_str(new_name) 761 ) 762 ); 763 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 764 DEFINE_EVENT(nfs_rename_event_done, name, \ 765 TP_PROTO( \ 766 const struct inode *old_dir, \ 767 const struct dentry *old_dentry, \ 768 const struct inode *new_dir, \ 769 const struct dentry *new_dentry, \ 770 int error \ 771 ), \ 772 TP_ARGS(old_dir, old_dentry, new_dir, \ 773 new_dentry, error)) 774 775 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 776 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 777 778 DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename); 779 780 TRACE_EVENT(nfs_sillyrename_unlink, 781 TP_PROTO( 782 const struct nfs_unlinkdata *data, 783 int error 784 ), 785 786 TP_ARGS(data, error), 787 788 TP_STRUCT__entry( 789 __field(dev_t, dev) 790 __field(unsigned long, error) 791 __field(u64, dir) 792 __dynamic_array(char, name, data->args.name.len + 1) 793 ), 794 795 TP_fast_assign( 796 struct inode *dir = d_inode(data->dentry->d_parent); 797 size_t len = data->args.name.len; 798 __entry->dev = dir->i_sb->s_dev; 799 __entry->dir = NFS_FILEID(dir); 800 __entry->error = -error; 801 memcpy(__get_str(name), 802 data->args.name.name, len); 803 __get_str(name)[len] = 0; 804 ), 805 806 TP_printk( 807 "error=%ld (%s) name=%02x:%02x:%llu/%s", 808 -__entry->error, show_nfs_status(__entry->error), 809 MAJOR(__entry->dev), MINOR(__entry->dev), 810 (unsigned long long)__entry->dir, 811 __get_str(name) 812 ) 813 ); 814 815 TRACE_EVENT(nfs_aop_readpage, 816 TP_PROTO( 817 const struct inode *inode, 818 struct page *page 819 ), 820 821 TP_ARGS(inode, page), 822 823 TP_STRUCT__entry( 824 __field(dev_t, dev) 825 __field(u32, fhandle) 826 __field(u64, fileid) 827 __field(u64, version) 828 __field(loff_t, offset) 829 ), 830 831 TP_fast_assign( 832 const struct nfs_inode *nfsi = NFS_I(inode); 833 834 __entry->dev = inode->i_sb->s_dev; 835 __entry->fileid = nfsi->fileid; 836 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 837 __entry->version = inode_peek_iversion_raw(inode); 838 __entry->offset = page_index(page) << PAGE_SHIFT; 839 ), 840 841 TP_printk( 842 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld", 843 MAJOR(__entry->dev), MINOR(__entry->dev), 844 (unsigned long long)__entry->fileid, 845 __entry->fhandle, __entry->version, 846 __entry->offset 847 ) 848 ); 849 850 TRACE_EVENT(nfs_aop_readpage_done, 851 TP_PROTO( 852 const struct inode *inode, 853 struct page *page, 854 int ret 855 ), 856 857 TP_ARGS(inode, page, ret), 858 859 TP_STRUCT__entry( 860 __field(dev_t, dev) 861 __field(u32, fhandle) 862 __field(int, ret) 863 __field(u64, fileid) 864 __field(u64, version) 865 __field(loff_t, offset) 866 ), 867 868 TP_fast_assign( 869 const struct nfs_inode *nfsi = NFS_I(inode); 870 871 __entry->dev = inode->i_sb->s_dev; 872 __entry->fileid = nfsi->fileid; 873 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 874 __entry->version = inode_peek_iversion_raw(inode); 875 __entry->offset = page_index(page) << PAGE_SHIFT; 876 __entry->ret = ret; 877 ), 878 879 TP_printk( 880 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld ret=%d", 881 MAJOR(__entry->dev), MINOR(__entry->dev), 882 (unsigned long long)__entry->fileid, 883 __entry->fhandle, __entry->version, 884 __entry->offset, __entry->ret 885 ) 886 ); 887 888 TRACE_EVENT(nfs_aop_readahead, 889 TP_PROTO( 890 const struct inode *inode, 891 loff_t pos, 892 unsigned int nr_pages 893 ), 894 895 TP_ARGS(inode, pos, nr_pages), 896 897 TP_STRUCT__entry( 898 __field(dev_t, dev) 899 __field(u32, fhandle) 900 __field(u64, fileid) 901 __field(u64, version) 902 __field(loff_t, offset) 903 __field(unsigned int, nr_pages) 904 ), 905 906 TP_fast_assign( 907 const struct nfs_inode *nfsi = NFS_I(inode); 908 909 __entry->dev = inode->i_sb->s_dev; 910 __entry->fileid = nfsi->fileid; 911 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 912 __entry->version = inode_peek_iversion_raw(inode); 913 __entry->offset = pos; 914 __entry->nr_pages = nr_pages; 915 ), 916 917 TP_printk( 918 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld nr_pages=%u", 919 MAJOR(__entry->dev), MINOR(__entry->dev), 920 (unsigned long long)__entry->fileid, 921 __entry->fhandle, __entry->version, 922 __entry->offset, __entry->nr_pages 923 ) 924 ); 925 926 TRACE_EVENT(nfs_aop_readahead_done, 927 TP_PROTO( 928 const struct inode *inode, 929 unsigned int nr_pages, 930 int ret 931 ), 932 933 TP_ARGS(inode, nr_pages, ret), 934 935 TP_STRUCT__entry( 936 __field(dev_t, dev) 937 __field(u32, fhandle) 938 __field(int, ret) 939 __field(u64, fileid) 940 __field(u64, version) 941 __field(loff_t, offset) 942 __field(unsigned int, nr_pages) 943 ), 944 945 TP_fast_assign( 946 const struct nfs_inode *nfsi = NFS_I(inode); 947 948 __entry->dev = inode->i_sb->s_dev; 949 __entry->fileid = nfsi->fileid; 950 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 951 __entry->version = inode_peek_iversion_raw(inode); 952 __entry->nr_pages = nr_pages; 953 __entry->ret = ret; 954 ), 955 956 TP_printk( 957 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d", 958 MAJOR(__entry->dev), MINOR(__entry->dev), 959 (unsigned long long)__entry->fileid, 960 __entry->fhandle, __entry->version, 961 __entry->nr_pages, __entry->ret 962 ) 963 ); 964 965 TRACE_EVENT(nfs_initiate_read, 966 TP_PROTO( 967 const struct nfs_pgio_header *hdr 968 ), 969 970 TP_ARGS(hdr), 971 972 TP_STRUCT__entry( 973 __field(dev_t, dev) 974 __field(u32, fhandle) 975 __field(u64, fileid) 976 __field(loff_t, offset) 977 __field(u32, count) 978 ), 979 980 TP_fast_assign( 981 const struct inode *inode = hdr->inode; 982 const struct nfs_inode *nfsi = NFS_I(inode); 983 const struct nfs_fh *fh = hdr->args.fh ? 984 hdr->args.fh : &nfsi->fh; 985 986 __entry->offset = hdr->args.offset; 987 __entry->count = hdr->args.count; 988 __entry->dev = inode->i_sb->s_dev; 989 __entry->fileid = nfsi->fileid; 990 __entry->fhandle = nfs_fhandle_hash(fh); 991 ), 992 993 TP_printk( 994 "fileid=%02x:%02x:%llu fhandle=0x%08x " 995 "offset=%lld count=%u", 996 MAJOR(__entry->dev), MINOR(__entry->dev), 997 (unsigned long long)__entry->fileid, 998 __entry->fhandle, 999 (long long)__entry->offset, __entry->count 1000 ) 1001 ); 1002 1003 TRACE_EVENT(nfs_readpage_done, 1004 TP_PROTO( 1005 const struct rpc_task *task, 1006 const struct nfs_pgio_header *hdr 1007 ), 1008 1009 TP_ARGS(task, hdr), 1010 1011 TP_STRUCT__entry( 1012 __field(dev_t, dev) 1013 __field(u32, fhandle) 1014 __field(u64, fileid) 1015 __field(loff_t, offset) 1016 __field(u32, arg_count) 1017 __field(u32, res_count) 1018 __field(bool, eof) 1019 __field(int, status) 1020 ), 1021 1022 TP_fast_assign( 1023 const struct inode *inode = hdr->inode; 1024 const struct nfs_inode *nfsi = NFS_I(inode); 1025 const struct nfs_fh *fh = hdr->args.fh ? 1026 hdr->args.fh : &nfsi->fh; 1027 1028 __entry->status = task->tk_status; 1029 __entry->offset = hdr->args.offset; 1030 __entry->arg_count = hdr->args.count; 1031 __entry->res_count = hdr->res.count; 1032 __entry->eof = hdr->res.eof; 1033 __entry->dev = inode->i_sb->s_dev; 1034 __entry->fileid = nfsi->fileid; 1035 __entry->fhandle = nfs_fhandle_hash(fh); 1036 ), 1037 1038 TP_printk( 1039 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1040 "offset=%lld count=%u res=%u status=%d%s", 1041 MAJOR(__entry->dev), MINOR(__entry->dev), 1042 (unsigned long long)__entry->fileid, 1043 __entry->fhandle, 1044 (long long)__entry->offset, __entry->arg_count, 1045 __entry->res_count, __entry->status, 1046 __entry->eof ? " eof" : "" 1047 ) 1048 ); 1049 1050 TRACE_EVENT(nfs_readpage_short, 1051 TP_PROTO( 1052 const struct rpc_task *task, 1053 const struct nfs_pgio_header *hdr 1054 ), 1055 1056 TP_ARGS(task, hdr), 1057 1058 TP_STRUCT__entry( 1059 __field(dev_t, dev) 1060 __field(u32, fhandle) 1061 __field(u64, fileid) 1062 __field(loff_t, offset) 1063 __field(u32, arg_count) 1064 __field(u32, res_count) 1065 __field(bool, eof) 1066 __field(int, status) 1067 ), 1068 1069 TP_fast_assign( 1070 const struct inode *inode = hdr->inode; 1071 const struct nfs_inode *nfsi = NFS_I(inode); 1072 const struct nfs_fh *fh = hdr->args.fh ? 1073 hdr->args.fh : &nfsi->fh; 1074 1075 __entry->status = task->tk_status; 1076 __entry->offset = hdr->args.offset; 1077 __entry->arg_count = hdr->args.count; 1078 __entry->res_count = hdr->res.count; 1079 __entry->eof = hdr->res.eof; 1080 __entry->dev = inode->i_sb->s_dev; 1081 __entry->fileid = nfsi->fileid; 1082 __entry->fhandle = nfs_fhandle_hash(fh); 1083 ), 1084 1085 TP_printk( 1086 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1087 "offset=%lld count=%u res=%u status=%d%s", 1088 MAJOR(__entry->dev), MINOR(__entry->dev), 1089 (unsigned long long)__entry->fileid, 1090 __entry->fhandle, 1091 (long long)__entry->offset, __entry->arg_count, 1092 __entry->res_count, __entry->status, 1093 __entry->eof ? " eof" : "" 1094 ) 1095 ); 1096 1097 TRACE_EVENT(nfs_pgio_error, 1098 TP_PROTO( 1099 const struct nfs_pgio_header *hdr, 1100 int error, 1101 loff_t pos 1102 ), 1103 1104 TP_ARGS(hdr, error, pos), 1105 1106 TP_STRUCT__entry( 1107 __field(dev_t, dev) 1108 __field(u32, fhandle) 1109 __field(u64, fileid) 1110 __field(loff_t, offset) 1111 __field(u32, arg_count) 1112 __field(u32, res_count) 1113 __field(loff_t, pos) 1114 __field(int, status) 1115 ), 1116 1117 TP_fast_assign( 1118 const struct inode *inode = hdr->inode; 1119 const struct nfs_inode *nfsi = NFS_I(inode); 1120 const struct nfs_fh *fh = hdr->args.fh ? 1121 hdr->args.fh : &nfsi->fh; 1122 1123 __entry->status = error; 1124 __entry->offset = hdr->args.offset; 1125 __entry->arg_count = hdr->args.count; 1126 __entry->res_count = hdr->res.count; 1127 __entry->dev = inode->i_sb->s_dev; 1128 __entry->fileid = nfsi->fileid; 1129 __entry->fhandle = nfs_fhandle_hash(fh); 1130 ), 1131 1132 TP_printk("fileid=%02x:%02x:%llu fhandle=0x%08x " 1133 "offset=%lld count=%u res=%u pos=%llu status=%d", 1134 MAJOR(__entry->dev), MINOR(__entry->dev), 1135 (unsigned long long)__entry->fileid, __entry->fhandle, 1136 (long long)__entry->offset, __entry->arg_count, __entry->res_count, 1137 __entry->pos, __entry->status 1138 ) 1139 ); 1140 1141 TRACE_EVENT(nfs_initiate_write, 1142 TP_PROTO( 1143 const struct nfs_pgio_header *hdr 1144 ), 1145 1146 TP_ARGS(hdr), 1147 1148 TP_STRUCT__entry( 1149 __field(dev_t, dev) 1150 __field(u32, fhandle) 1151 __field(u64, fileid) 1152 __field(loff_t, offset) 1153 __field(u32, count) 1154 __field(unsigned long, stable) 1155 ), 1156 1157 TP_fast_assign( 1158 const struct inode *inode = hdr->inode; 1159 const struct nfs_inode *nfsi = NFS_I(inode); 1160 const struct nfs_fh *fh = hdr->args.fh ? 1161 hdr->args.fh : &nfsi->fh; 1162 1163 __entry->offset = hdr->args.offset; 1164 __entry->count = hdr->args.count; 1165 __entry->stable = hdr->args.stable; 1166 __entry->dev = inode->i_sb->s_dev; 1167 __entry->fileid = nfsi->fileid; 1168 __entry->fhandle = nfs_fhandle_hash(fh); 1169 ), 1170 1171 TP_printk( 1172 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1173 "offset=%lld count=%u stable=%s", 1174 MAJOR(__entry->dev), MINOR(__entry->dev), 1175 (unsigned long long)__entry->fileid, 1176 __entry->fhandle, 1177 (long long)__entry->offset, __entry->count, 1178 show_nfs_stable_how(__entry->stable) 1179 ) 1180 ); 1181 1182 TRACE_EVENT(nfs_writeback_done, 1183 TP_PROTO( 1184 const struct rpc_task *task, 1185 const struct nfs_pgio_header *hdr 1186 ), 1187 1188 TP_ARGS(task, hdr), 1189 1190 TP_STRUCT__entry( 1191 __field(dev_t, dev) 1192 __field(u32, fhandle) 1193 __field(u64, fileid) 1194 __field(loff_t, offset) 1195 __field(u32, arg_count) 1196 __field(u32, res_count) 1197 __field(int, status) 1198 __field(unsigned long, stable) 1199 __array(char, verifier, NFS4_VERIFIER_SIZE) 1200 ), 1201 1202 TP_fast_assign( 1203 const struct inode *inode = hdr->inode; 1204 const struct nfs_inode *nfsi = NFS_I(inode); 1205 const struct nfs_fh *fh = hdr->args.fh ? 1206 hdr->args.fh : &nfsi->fh; 1207 const struct nfs_writeverf *verf = hdr->res.verf; 1208 1209 __entry->status = task->tk_status; 1210 __entry->offset = hdr->args.offset; 1211 __entry->arg_count = hdr->args.count; 1212 __entry->res_count = hdr->res.count; 1213 __entry->stable = verf->committed; 1214 memcpy(__entry->verifier, 1215 &verf->verifier, 1216 NFS4_VERIFIER_SIZE); 1217 __entry->dev = inode->i_sb->s_dev; 1218 __entry->fileid = nfsi->fileid; 1219 __entry->fhandle = nfs_fhandle_hash(fh); 1220 ), 1221 1222 TP_printk( 1223 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1224 "offset=%lld count=%u res=%u status=%d stable=%s " 1225 "verifier=%s", 1226 MAJOR(__entry->dev), MINOR(__entry->dev), 1227 (unsigned long long)__entry->fileid, 1228 __entry->fhandle, 1229 (long long)__entry->offset, __entry->arg_count, 1230 __entry->res_count, __entry->status, 1231 show_nfs_stable_how(__entry->stable), 1232 show_nfs4_verifier(__entry->verifier) 1233 ) 1234 ); 1235 1236 DECLARE_EVENT_CLASS(nfs_page_error_class, 1237 TP_PROTO( 1238 const struct nfs_page *req, 1239 int error 1240 ), 1241 1242 TP_ARGS(req, error), 1243 1244 TP_STRUCT__entry( 1245 __field(const void *, req) 1246 __field(pgoff_t, index) 1247 __field(unsigned int, offset) 1248 __field(unsigned int, pgbase) 1249 __field(unsigned int, bytes) 1250 __field(int, error) 1251 ), 1252 1253 TP_fast_assign( 1254 __entry->req = req; 1255 __entry->index = req->wb_index; 1256 __entry->offset = req->wb_offset; 1257 __entry->pgbase = req->wb_pgbase; 1258 __entry->bytes = req->wb_bytes; 1259 __entry->error = error; 1260 ), 1261 1262 TP_printk( 1263 "req=%p index=%lu offset=%u pgbase=%u bytes=%u error=%d", 1264 __entry->req, __entry->index, __entry->offset, 1265 __entry->pgbase, __entry->bytes, __entry->error 1266 ) 1267 ); 1268 1269 #define DEFINE_NFS_PAGEERR_EVENT(name) \ 1270 DEFINE_EVENT(nfs_page_error_class, name, \ 1271 TP_PROTO( \ 1272 const struct nfs_page *req, \ 1273 int error \ 1274 ), \ 1275 TP_ARGS(req, error)) 1276 1277 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); 1278 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); 1279 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); 1280 1281 TRACE_EVENT(nfs_initiate_commit, 1282 TP_PROTO( 1283 const struct nfs_commit_data *data 1284 ), 1285 1286 TP_ARGS(data), 1287 1288 TP_STRUCT__entry( 1289 __field(dev_t, dev) 1290 __field(u32, fhandle) 1291 __field(u64, fileid) 1292 __field(loff_t, offset) 1293 __field(u32, count) 1294 ), 1295 1296 TP_fast_assign( 1297 const struct inode *inode = data->inode; 1298 const struct nfs_inode *nfsi = NFS_I(inode); 1299 const struct nfs_fh *fh = data->args.fh ? 1300 data->args.fh : &nfsi->fh; 1301 1302 __entry->offset = data->args.offset; 1303 __entry->count = data->args.count; 1304 __entry->dev = inode->i_sb->s_dev; 1305 __entry->fileid = nfsi->fileid; 1306 __entry->fhandle = nfs_fhandle_hash(fh); 1307 ), 1308 1309 TP_printk( 1310 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1311 "offset=%lld count=%u", 1312 MAJOR(__entry->dev), MINOR(__entry->dev), 1313 (unsigned long long)__entry->fileid, 1314 __entry->fhandle, 1315 (long long)__entry->offset, __entry->count 1316 ) 1317 ); 1318 1319 TRACE_EVENT(nfs_commit_done, 1320 TP_PROTO( 1321 const struct rpc_task *task, 1322 const struct nfs_commit_data *data 1323 ), 1324 1325 TP_ARGS(task, data), 1326 1327 TP_STRUCT__entry( 1328 __field(dev_t, dev) 1329 __field(u32, fhandle) 1330 __field(u64, fileid) 1331 __field(loff_t, offset) 1332 __field(int, status) 1333 __field(unsigned long, stable) 1334 __array(char, verifier, NFS4_VERIFIER_SIZE) 1335 ), 1336 1337 TP_fast_assign( 1338 const struct inode *inode = data->inode; 1339 const struct nfs_inode *nfsi = NFS_I(inode); 1340 const struct nfs_fh *fh = data->args.fh ? 1341 data->args.fh : &nfsi->fh; 1342 const struct nfs_writeverf *verf = data->res.verf; 1343 1344 __entry->status = task->tk_status; 1345 __entry->offset = data->args.offset; 1346 __entry->stable = verf->committed; 1347 memcpy(__entry->verifier, 1348 &verf->verifier, 1349 NFS4_VERIFIER_SIZE); 1350 __entry->dev = inode->i_sb->s_dev; 1351 __entry->fileid = nfsi->fileid; 1352 __entry->fhandle = nfs_fhandle_hash(fh); 1353 ), 1354 1355 TP_printk( 1356 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1357 "offset=%lld status=%d stable=%s verifier=%s", 1358 MAJOR(__entry->dev), MINOR(__entry->dev), 1359 (unsigned long long)__entry->fileid, 1360 __entry->fhandle, 1361 (long long)__entry->offset, __entry->status, 1362 show_nfs_stable_how(__entry->stable), 1363 show_nfs4_verifier(__entry->verifier) 1364 ) 1365 ); 1366 1367 TRACE_EVENT(nfs_fh_to_dentry, 1368 TP_PROTO( 1369 const struct super_block *sb, 1370 const struct nfs_fh *fh, 1371 u64 fileid, 1372 int error 1373 ), 1374 1375 TP_ARGS(sb, fh, fileid, error), 1376 1377 TP_STRUCT__entry( 1378 __field(int, error) 1379 __field(dev_t, dev) 1380 __field(u32, fhandle) 1381 __field(u64, fileid) 1382 ), 1383 1384 TP_fast_assign( 1385 __entry->error = error; 1386 __entry->dev = sb->s_dev; 1387 __entry->fileid = fileid; 1388 __entry->fhandle = nfs_fhandle_hash(fh); 1389 ), 1390 1391 TP_printk( 1392 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ", 1393 __entry->error, 1394 MAJOR(__entry->dev), MINOR(__entry->dev), 1395 (unsigned long long)__entry->fileid, 1396 __entry->fhandle 1397 ) 1398 ); 1399 1400 DECLARE_EVENT_CLASS(nfs_xdr_event, 1401 TP_PROTO( 1402 const struct xdr_stream *xdr, 1403 int error 1404 ), 1405 1406 TP_ARGS(xdr, error), 1407 1408 TP_STRUCT__entry( 1409 __field(unsigned int, task_id) 1410 __field(unsigned int, client_id) 1411 __field(u32, xid) 1412 __field(int, version) 1413 __field(unsigned long, error) 1414 __string(program, 1415 xdr->rqst->rq_task->tk_client->cl_program->name) 1416 __string(procedure, 1417 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 1418 ), 1419 1420 TP_fast_assign( 1421 const struct rpc_rqst *rqstp = xdr->rqst; 1422 const struct rpc_task *task = rqstp->rq_task; 1423 1424 __entry->task_id = task->tk_pid; 1425 __entry->client_id = task->tk_client->cl_clid; 1426 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1427 __entry->version = task->tk_client->cl_vers; 1428 __entry->error = error; 1429 __assign_str(program, 1430 task->tk_client->cl_program->name); 1431 __assign_str(procedure, task->tk_msg.rpc_proc->p_name); 1432 ), 1433 1434 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1435 " xid=0x%08x %sv%d %s error=%ld (%s)", 1436 __entry->task_id, __entry->client_id, __entry->xid, 1437 __get_str(program), __entry->version, 1438 __get_str(procedure), -__entry->error, 1439 show_nfs_status(__entry->error) 1440 ) 1441 ); 1442 #define DEFINE_NFS_XDR_EVENT(name) \ 1443 DEFINE_EVENT(nfs_xdr_event, name, \ 1444 TP_PROTO( \ 1445 const struct xdr_stream *xdr, \ 1446 int error \ 1447 ), \ 1448 TP_ARGS(xdr, error)) 1449 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); 1450 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); 1451 1452 #endif /* _TRACE_NFS_H */ 1453 1454 #undef TRACE_INCLUDE_PATH 1455 #define TRACE_INCLUDE_PATH . 1456 #define TRACE_INCLUDE_FILE nfstrace 1457 /* This part must be outside protection */ 1458 #include <trace/define_trace.h> 1459