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