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