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/sunrpc_base.h> 16 17 #define nfs_show_cache_validity(v) \ 18 __print_flags(v, "|", \ 19 { NFS_INO_INVALID_DATA, "INVALID_DATA" }, \ 20 { NFS_INO_INVALID_ATIME, "INVALID_ATIME" }, \ 21 { NFS_INO_INVALID_ACCESS, "INVALID_ACCESS" }, \ 22 { NFS_INO_INVALID_ACL, "INVALID_ACL" }, \ 23 { NFS_INO_REVAL_PAGECACHE, "REVAL_PAGECACHE" }, \ 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_FSCACHE_LOCK), "FSCACHE_LOCK" }, \ 45 { BIT(NFS_INO_LAYOUTCOMMIT), "NEED_LAYOUTCOMMIT" }, \ 46 { BIT(NFS_INO_LAYOUTCOMMITTING), "LAYOUTCOMMIT" }, \ 47 { BIT(NFS_INO_LAYOUTSTATS), "LAYOUTSTATS" }, \ 48 { BIT(NFS_INO_ODIRECT), "ODIRECT" }) 49 50 DECLARE_EVENT_CLASS(nfs_inode_event, 51 TP_PROTO( 52 const struct inode *inode 53 ), 54 55 TP_ARGS(inode), 56 57 TP_STRUCT__entry( 58 __field(dev_t, dev) 59 __field(u32, fhandle) 60 __field(u64, fileid) 61 __field(u64, version) 62 ), 63 64 TP_fast_assign( 65 const struct nfs_inode *nfsi = NFS_I(inode); 66 __entry->dev = inode->i_sb->s_dev; 67 __entry->fileid = nfsi->fileid; 68 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 69 __entry->version = inode_peek_iversion_raw(inode); 70 ), 71 72 TP_printk( 73 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu ", 74 MAJOR(__entry->dev), MINOR(__entry->dev), 75 (unsigned long long)__entry->fileid, 76 __entry->fhandle, 77 (unsigned long long)__entry->version 78 ) 79 ); 80 81 DECLARE_EVENT_CLASS(nfs_inode_event_done, 82 TP_PROTO( 83 const struct inode *inode, 84 int error 85 ), 86 87 TP_ARGS(inode, error), 88 89 TP_STRUCT__entry( 90 __field(unsigned long, error) 91 __field(dev_t, dev) 92 __field(u32, fhandle) 93 __field(unsigned char, type) 94 __field(u64, fileid) 95 __field(u64, version) 96 __field(loff_t, size) 97 __field(unsigned long, nfsi_flags) 98 __field(unsigned long, cache_validity) 99 ), 100 101 TP_fast_assign( 102 const struct nfs_inode *nfsi = NFS_I(inode); 103 __entry->error = error < 0 ? -error : 0; 104 __entry->dev = inode->i_sb->s_dev; 105 __entry->fileid = nfsi->fileid; 106 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 107 __entry->type = nfs_umode_to_dtype(inode->i_mode); 108 __entry->version = inode_peek_iversion_raw(inode); 109 __entry->size = i_size_read(inode); 110 __entry->nfsi_flags = nfsi->flags; 111 __entry->cache_validity = nfsi->cache_validity; 112 ), 113 114 TP_printk( 115 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 116 "type=%u (%s) version=%llu size=%lld " 117 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s)", 118 -__entry->error, nfs_show_status(__entry->error), 119 MAJOR(__entry->dev), MINOR(__entry->dev), 120 (unsigned long long)__entry->fileid, 121 __entry->fhandle, 122 __entry->type, 123 show_fs_dirent_type(__entry->type), 124 (unsigned long long)__entry->version, 125 (long long)__entry->size, 126 __entry->cache_validity, 127 nfs_show_cache_validity(__entry->cache_validity), 128 __entry->nfsi_flags, 129 nfs_show_nfsi_flags(__entry->nfsi_flags) 130 ) 131 ); 132 133 #define DEFINE_NFS_INODE_EVENT(name) \ 134 DEFINE_EVENT(nfs_inode_event, name, \ 135 TP_PROTO( \ 136 const struct inode *inode \ 137 ), \ 138 TP_ARGS(inode)) 139 #define DEFINE_NFS_INODE_EVENT_DONE(name) \ 140 DEFINE_EVENT(nfs_inode_event_done, name, \ 141 TP_PROTO( \ 142 const struct inode *inode, \ 143 int error \ 144 ), \ 145 TP_ARGS(inode, error)) 146 DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale); 147 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter); 148 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit); 149 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter); 150 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit); 151 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter); 152 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit); 153 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 154 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 155 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 156 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); 157 DEFINE_NFS_INODE_EVENT(nfs_writeback_page_enter); 158 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_page_exit); 159 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter); 160 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit); 161 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 162 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 163 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 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, nfs_show_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, nfs_show_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, nfs_show_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, nfs_show_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, nfs_show_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, nfs_show_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, nfs_show_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, nfs_show_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 unsigned int nr_pages 892 ), 893 894 TP_ARGS(inode, 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(unsigned int, nr_pages) 902 ), 903 904 TP_fast_assign( 905 const struct nfs_inode *nfsi = NFS_I(inode); 906 907 __entry->dev = inode->i_sb->s_dev; 908 __entry->fileid = nfsi->fileid; 909 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 910 __entry->version = inode_peek_iversion_raw(inode); 911 __entry->nr_pages = nr_pages; 912 ), 913 914 TP_printk( 915 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u", 916 MAJOR(__entry->dev), MINOR(__entry->dev), 917 (unsigned long long)__entry->fileid, 918 __entry->fhandle, __entry->version, 919 __entry->nr_pages 920 ) 921 ); 922 923 TRACE_EVENT(nfs_aop_readahead_done, 924 TP_PROTO( 925 const struct inode *inode, 926 unsigned int nr_pages, 927 int ret 928 ), 929 930 TP_ARGS(inode, nr_pages, ret), 931 932 TP_STRUCT__entry( 933 __field(dev_t, dev) 934 __field(u32, fhandle) 935 __field(int, ret) 936 __field(u64, fileid) 937 __field(u64, version) 938 __field(unsigned int, nr_pages) 939 ), 940 941 TP_fast_assign( 942 const struct nfs_inode *nfsi = NFS_I(inode); 943 944 __entry->dev = inode->i_sb->s_dev; 945 __entry->fileid = nfsi->fileid; 946 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 947 __entry->version = inode_peek_iversion_raw(inode); 948 __entry->nr_pages = nr_pages; 949 __entry->ret = ret; 950 ), 951 952 TP_printk( 953 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d", 954 MAJOR(__entry->dev), MINOR(__entry->dev), 955 (unsigned long long)__entry->fileid, 956 __entry->fhandle, __entry->version, 957 __entry->nr_pages, __entry->ret 958 ) 959 ); 960 961 TRACE_EVENT(nfs_initiate_read, 962 TP_PROTO( 963 const struct nfs_pgio_header *hdr 964 ), 965 966 TP_ARGS(hdr), 967 968 TP_STRUCT__entry( 969 __field(dev_t, dev) 970 __field(u32, fhandle) 971 __field(u64, fileid) 972 __field(loff_t, offset) 973 __field(u32, count) 974 ), 975 976 TP_fast_assign( 977 const struct inode *inode = hdr->inode; 978 const struct nfs_inode *nfsi = NFS_I(inode); 979 const struct nfs_fh *fh = hdr->args.fh ? 980 hdr->args.fh : &nfsi->fh; 981 982 __entry->offset = hdr->args.offset; 983 __entry->count = hdr->args.count; 984 __entry->dev = inode->i_sb->s_dev; 985 __entry->fileid = nfsi->fileid; 986 __entry->fhandle = nfs_fhandle_hash(fh); 987 ), 988 989 TP_printk( 990 "fileid=%02x:%02x:%llu fhandle=0x%08x " 991 "offset=%lld count=%u", 992 MAJOR(__entry->dev), MINOR(__entry->dev), 993 (unsigned long long)__entry->fileid, 994 __entry->fhandle, 995 (long long)__entry->offset, __entry->count 996 ) 997 ); 998 999 TRACE_EVENT(nfs_readpage_done, 1000 TP_PROTO( 1001 const struct rpc_task *task, 1002 const struct nfs_pgio_header *hdr 1003 ), 1004 1005 TP_ARGS(task, hdr), 1006 1007 TP_STRUCT__entry( 1008 __field(dev_t, dev) 1009 __field(u32, fhandle) 1010 __field(u64, fileid) 1011 __field(loff_t, offset) 1012 __field(u32, arg_count) 1013 __field(u32, res_count) 1014 __field(bool, eof) 1015 __field(int, status) 1016 ), 1017 1018 TP_fast_assign( 1019 const struct inode *inode = hdr->inode; 1020 const struct nfs_inode *nfsi = NFS_I(inode); 1021 const struct nfs_fh *fh = hdr->args.fh ? 1022 hdr->args.fh : &nfsi->fh; 1023 1024 __entry->status = task->tk_status; 1025 __entry->offset = hdr->args.offset; 1026 __entry->arg_count = hdr->args.count; 1027 __entry->res_count = hdr->res.count; 1028 __entry->eof = hdr->res.eof; 1029 __entry->dev = inode->i_sb->s_dev; 1030 __entry->fileid = nfsi->fileid; 1031 __entry->fhandle = nfs_fhandle_hash(fh); 1032 ), 1033 1034 TP_printk( 1035 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1036 "offset=%lld count=%u res=%u status=%d%s", 1037 MAJOR(__entry->dev), MINOR(__entry->dev), 1038 (unsigned long long)__entry->fileid, 1039 __entry->fhandle, 1040 (long long)__entry->offset, __entry->arg_count, 1041 __entry->res_count, __entry->status, 1042 __entry->eof ? " eof" : "" 1043 ) 1044 ); 1045 1046 TRACE_EVENT(nfs_readpage_short, 1047 TP_PROTO( 1048 const struct rpc_task *task, 1049 const struct nfs_pgio_header *hdr 1050 ), 1051 1052 TP_ARGS(task, hdr), 1053 1054 TP_STRUCT__entry( 1055 __field(dev_t, dev) 1056 __field(u32, fhandle) 1057 __field(u64, fileid) 1058 __field(loff_t, offset) 1059 __field(u32, arg_count) 1060 __field(u32, res_count) 1061 __field(bool, eof) 1062 __field(int, status) 1063 ), 1064 1065 TP_fast_assign( 1066 const struct inode *inode = hdr->inode; 1067 const struct nfs_inode *nfsi = NFS_I(inode); 1068 const struct nfs_fh *fh = hdr->args.fh ? 1069 hdr->args.fh : &nfsi->fh; 1070 1071 __entry->status = task->tk_status; 1072 __entry->offset = hdr->args.offset; 1073 __entry->arg_count = hdr->args.count; 1074 __entry->res_count = hdr->res.count; 1075 __entry->eof = hdr->res.eof; 1076 __entry->dev = inode->i_sb->s_dev; 1077 __entry->fileid = nfsi->fileid; 1078 __entry->fhandle = nfs_fhandle_hash(fh); 1079 ), 1080 1081 TP_printk( 1082 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1083 "offset=%lld count=%u res=%u status=%d%s", 1084 MAJOR(__entry->dev), MINOR(__entry->dev), 1085 (unsigned long long)__entry->fileid, 1086 __entry->fhandle, 1087 (long long)__entry->offset, __entry->arg_count, 1088 __entry->res_count, __entry->status, 1089 __entry->eof ? " eof" : "" 1090 ) 1091 ); 1092 1093 TRACE_EVENT(nfs_pgio_error, 1094 TP_PROTO( 1095 const struct nfs_pgio_header *hdr, 1096 int error, 1097 loff_t pos 1098 ), 1099 1100 TP_ARGS(hdr, error, pos), 1101 1102 TP_STRUCT__entry( 1103 __field(dev_t, dev) 1104 __field(u32, fhandle) 1105 __field(u64, fileid) 1106 __field(loff_t, offset) 1107 __field(u32, arg_count) 1108 __field(u32, res_count) 1109 __field(loff_t, pos) 1110 __field(int, status) 1111 ), 1112 1113 TP_fast_assign( 1114 const struct inode *inode = hdr->inode; 1115 const struct nfs_inode *nfsi = NFS_I(inode); 1116 const struct nfs_fh *fh = hdr->args.fh ? 1117 hdr->args.fh : &nfsi->fh; 1118 1119 __entry->status = error; 1120 __entry->offset = hdr->args.offset; 1121 __entry->arg_count = hdr->args.count; 1122 __entry->res_count = hdr->res.count; 1123 __entry->dev = inode->i_sb->s_dev; 1124 __entry->fileid = nfsi->fileid; 1125 __entry->fhandle = nfs_fhandle_hash(fh); 1126 ), 1127 1128 TP_printk("fileid=%02x:%02x:%llu fhandle=0x%08x " 1129 "offset=%lld count=%u res=%u pos=%llu status=%d", 1130 MAJOR(__entry->dev), MINOR(__entry->dev), 1131 (unsigned long long)__entry->fileid, __entry->fhandle, 1132 (long long)__entry->offset, __entry->arg_count, __entry->res_count, 1133 __entry->pos, __entry->status 1134 ) 1135 ); 1136 1137 TRACE_DEFINE_ENUM(NFS_UNSTABLE); 1138 TRACE_DEFINE_ENUM(NFS_DATA_SYNC); 1139 TRACE_DEFINE_ENUM(NFS_FILE_SYNC); 1140 1141 #define nfs_show_stable(stable) \ 1142 __print_symbolic(stable, \ 1143 { NFS_UNSTABLE, "UNSTABLE" }, \ 1144 { NFS_DATA_SYNC, "DATA_SYNC" }, \ 1145 { NFS_FILE_SYNC, "FILE_SYNC" }) 1146 1147 TRACE_EVENT(nfs_initiate_write, 1148 TP_PROTO( 1149 const struct nfs_pgio_header *hdr 1150 ), 1151 1152 TP_ARGS(hdr), 1153 1154 TP_STRUCT__entry( 1155 __field(dev_t, dev) 1156 __field(u32, fhandle) 1157 __field(u64, fileid) 1158 __field(loff_t, offset) 1159 __field(u32, count) 1160 __field(enum nfs3_stable_how, stable) 1161 ), 1162 1163 TP_fast_assign( 1164 const struct inode *inode = hdr->inode; 1165 const struct nfs_inode *nfsi = NFS_I(inode); 1166 const struct nfs_fh *fh = hdr->args.fh ? 1167 hdr->args.fh : &nfsi->fh; 1168 1169 __entry->offset = hdr->args.offset; 1170 __entry->count = hdr->args.count; 1171 __entry->stable = hdr->args.stable; 1172 __entry->dev = inode->i_sb->s_dev; 1173 __entry->fileid = nfsi->fileid; 1174 __entry->fhandle = nfs_fhandle_hash(fh); 1175 ), 1176 1177 TP_printk( 1178 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1179 "offset=%lld count=%u stable=%s", 1180 MAJOR(__entry->dev), MINOR(__entry->dev), 1181 (unsigned long long)__entry->fileid, 1182 __entry->fhandle, 1183 (long long)__entry->offset, __entry->count, 1184 nfs_show_stable(__entry->stable) 1185 ) 1186 ); 1187 1188 TRACE_EVENT(nfs_writeback_done, 1189 TP_PROTO( 1190 const struct rpc_task *task, 1191 const struct nfs_pgio_header *hdr 1192 ), 1193 1194 TP_ARGS(task, hdr), 1195 1196 TP_STRUCT__entry( 1197 __field(dev_t, dev) 1198 __field(u32, fhandle) 1199 __field(u64, fileid) 1200 __field(loff_t, offset) 1201 __field(u32, arg_count) 1202 __field(u32, res_count) 1203 __field(int, status) 1204 __field(enum nfs3_stable_how, stable) 1205 __array(char, verifier, NFS4_VERIFIER_SIZE) 1206 ), 1207 1208 TP_fast_assign( 1209 const struct inode *inode = hdr->inode; 1210 const struct nfs_inode *nfsi = NFS_I(inode); 1211 const struct nfs_fh *fh = hdr->args.fh ? 1212 hdr->args.fh : &nfsi->fh; 1213 const struct nfs_writeverf *verf = hdr->res.verf; 1214 1215 __entry->status = task->tk_status; 1216 __entry->offset = hdr->args.offset; 1217 __entry->arg_count = hdr->args.count; 1218 __entry->res_count = hdr->res.count; 1219 __entry->stable = verf->committed; 1220 memcpy(__entry->verifier, 1221 &verf->verifier, 1222 NFS4_VERIFIER_SIZE); 1223 __entry->dev = inode->i_sb->s_dev; 1224 __entry->fileid = nfsi->fileid; 1225 __entry->fhandle = nfs_fhandle_hash(fh); 1226 ), 1227 1228 TP_printk( 1229 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1230 "offset=%lld count=%u res=%u status=%d stable=%s " 1231 "verifier=%s", 1232 MAJOR(__entry->dev), MINOR(__entry->dev), 1233 (unsigned long long)__entry->fileid, 1234 __entry->fhandle, 1235 (long long)__entry->offset, __entry->arg_count, 1236 __entry->res_count, __entry->status, 1237 nfs_show_stable(__entry->stable), 1238 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 1239 ) 1240 ); 1241 1242 DECLARE_EVENT_CLASS(nfs_page_error_class, 1243 TP_PROTO( 1244 const struct nfs_page *req, 1245 int error 1246 ), 1247 1248 TP_ARGS(req, error), 1249 1250 TP_STRUCT__entry( 1251 __field(const void *, req) 1252 __field(pgoff_t, index) 1253 __field(unsigned int, offset) 1254 __field(unsigned int, pgbase) 1255 __field(unsigned int, bytes) 1256 __field(int, error) 1257 ), 1258 1259 TP_fast_assign( 1260 __entry->req = req; 1261 __entry->index = req->wb_index; 1262 __entry->offset = req->wb_offset; 1263 __entry->pgbase = req->wb_pgbase; 1264 __entry->bytes = req->wb_bytes; 1265 __entry->error = error; 1266 ), 1267 1268 TP_printk( 1269 "req=%p index=%lu offset=%u pgbase=%u bytes=%u error=%d", 1270 __entry->req, __entry->index, __entry->offset, 1271 __entry->pgbase, __entry->bytes, __entry->error 1272 ) 1273 ); 1274 1275 #define DEFINE_NFS_PAGEERR_EVENT(name) \ 1276 DEFINE_EVENT(nfs_page_error_class, name, \ 1277 TP_PROTO( \ 1278 const struct nfs_page *req, \ 1279 int error \ 1280 ), \ 1281 TP_ARGS(req, error)) 1282 1283 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); 1284 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); 1285 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); 1286 1287 TRACE_EVENT(nfs_initiate_commit, 1288 TP_PROTO( 1289 const struct nfs_commit_data *data 1290 ), 1291 1292 TP_ARGS(data), 1293 1294 TP_STRUCT__entry( 1295 __field(dev_t, dev) 1296 __field(u32, fhandle) 1297 __field(u64, fileid) 1298 __field(loff_t, offset) 1299 __field(u32, count) 1300 ), 1301 1302 TP_fast_assign( 1303 const struct inode *inode = data->inode; 1304 const struct nfs_inode *nfsi = NFS_I(inode); 1305 const struct nfs_fh *fh = data->args.fh ? 1306 data->args.fh : &nfsi->fh; 1307 1308 __entry->offset = data->args.offset; 1309 __entry->count = data->args.count; 1310 __entry->dev = inode->i_sb->s_dev; 1311 __entry->fileid = nfsi->fileid; 1312 __entry->fhandle = nfs_fhandle_hash(fh); 1313 ), 1314 1315 TP_printk( 1316 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1317 "offset=%lld count=%u", 1318 MAJOR(__entry->dev), MINOR(__entry->dev), 1319 (unsigned long long)__entry->fileid, 1320 __entry->fhandle, 1321 (long long)__entry->offset, __entry->count 1322 ) 1323 ); 1324 1325 TRACE_EVENT(nfs_commit_done, 1326 TP_PROTO( 1327 const struct rpc_task *task, 1328 const struct nfs_commit_data *data 1329 ), 1330 1331 TP_ARGS(task, data), 1332 1333 TP_STRUCT__entry( 1334 __field(dev_t, dev) 1335 __field(u32, fhandle) 1336 __field(u64, fileid) 1337 __field(loff_t, offset) 1338 __field(int, status) 1339 __field(enum nfs3_stable_how, stable) 1340 __array(char, verifier, NFS4_VERIFIER_SIZE) 1341 ), 1342 1343 TP_fast_assign( 1344 const struct inode *inode = data->inode; 1345 const struct nfs_inode *nfsi = NFS_I(inode); 1346 const struct nfs_fh *fh = data->args.fh ? 1347 data->args.fh : &nfsi->fh; 1348 const struct nfs_writeverf *verf = data->res.verf; 1349 1350 __entry->status = task->tk_status; 1351 __entry->offset = data->args.offset; 1352 __entry->stable = verf->committed; 1353 memcpy(__entry->verifier, 1354 &verf->verifier, 1355 NFS4_VERIFIER_SIZE); 1356 __entry->dev = inode->i_sb->s_dev; 1357 __entry->fileid = nfsi->fileid; 1358 __entry->fhandle = nfs_fhandle_hash(fh); 1359 ), 1360 1361 TP_printk( 1362 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1363 "offset=%lld status=%d stable=%s verifier=%s", 1364 MAJOR(__entry->dev), MINOR(__entry->dev), 1365 (unsigned long long)__entry->fileid, 1366 __entry->fhandle, 1367 (long long)__entry->offset, __entry->status, 1368 nfs_show_stable(__entry->stable), 1369 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 1370 ) 1371 ); 1372 1373 TRACE_EVENT(nfs_fh_to_dentry, 1374 TP_PROTO( 1375 const struct super_block *sb, 1376 const struct nfs_fh *fh, 1377 u64 fileid, 1378 int error 1379 ), 1380 1381 TP_ARGS(sb, fh, fileid, error), 1382 1383 TP_STRUCT__entry( 1384 __field(int, error) 1385 __field(dev_t, dev) 1386 __field(u32, fhandle) 1387 __field(u64, fileid) 1388 ), 1389 1390 TP_fast_assign( 1391 __entry->error = error; 1392 __entry->dev = sb->s_dev; 1393 __entry->fileid = fileid; 1394 __entry->fhandle = nfs_fhandle_hash(fh); 1395 ), 1396 1397 TP_printk( 1398 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ", 1399 __entry->error, 1400 MAJOR(__entry->dev), MINOR(__entry->dev), 1401 (unsigned long long)__entry->fileid, 1402 __entry->fhandle 1403 ) 1404 ); 1405 1406 TRACE_DEFINE_ENUM(NFS_OK); 1407 TRACE_DEFINE_ENUM(NFSERR_PERM); 1408 TRACE_DEFINE_ENUM(NFSERR_NOENT); 1409 TRACE_DEFINE_ENUM(NFSERR_IO); 1410 TRACE_DEFINE_ENUM(NFSERR_NXIO); 1411 TRACE_DEFINE_ENUM(ECHILD); 1412 TRACE_DEFINE_ENUM(NFSERR_EAGAIN); 1413 TRACE_DEFINE_ENUM(NFSERR_ACCES); 1414 TRACE_DEFINE_ENUM(NFSERR_EXIST); 1415 TRACE_DEFINE_ENUM(NFSERR_XDEV); 1416 TRACE_DEFINE_ENUM(NFSERR_NODEV); 1417 TRACE_DEFINE_ENUM(NFSERR_NOTDIR); 1418 TRACE_DEFINE_ENUM(NFSERR_ISDIR); 1419 TRACE_DEFINE_ENUM(NFSERR_INVAL); 1420 TRACE_DEFINE_ENUM(NFSERR_FBIG); 1421 TRACE_DEFINE_ENUM(NFSERR_NOSPC); 1422 TRACE_DEFINE_ENUM(NFSERR_ROFS); 1423 TRACE_DEFINE_ENUM(NFSERR_MLINK); 1424 TRACE_DEFINE_ENUM(NFSERR_OPNOTSUPP); 1425 TRACE_DEFINE_ENUM(NFSERR_NAMETOOLONG); 1426 TRACE_DEFINE_ENUM(NFSERR_NOTEMPTY); 1427 TRACE_DEFINE_ENUM(NFSERR_DQUOT); 1428 TRACE_DEFINE_ENUM(NFSERR_STALE); 1429 TRACE_DEFINE_ENUM(NFSERR_REMOTE); 1430 TRACE_DEFINE_ENUM(NFSERR_WFLUSH); 1431 TRACE_DEFINE_ENUM(NFSERR_BADHANDLE); 1432 TRACE_DEFINE_ENUM(NFSERR_NOT_SYNC); 1433 TRACE_DEFINE_ENUM(NFSERR_BAD_COOKIE); 1434 TRACE_DEFINE_ENUM(NFSERR_NOTSUPP); 1435 TRACE_DEFINE_ENUM(NFSERR_TOOSMALL); 1436 TRACE_DEFINE_ENUM(NFSERR_SERVERFAULT); 1437 TRACE_DEFINE_ENUM(NFSERR_BADTYPE); 1438 TRACE_DEFINE_ENUM(NFSERR_JUKEBOX); 1439 1440 #define nfs_show_status(x) \ 1441 __print_symbolic(x, \ 1442 { NFS_OK, "OK" }, \ 1443 { NFSERR_PERM, "PERM" }, \ 1444 { NFSERR_NOENT, "NOENT" }, \ 1445 { NFSERR_IO, "IO" }, \ 1446 { NFSERR_NXIO, "NXIO" }, \ 1447 { ECHILD, "CHILD" }, \ 1448 { NFSERR_EAGAIN, "AGAIN" }, \ 1449 { NFSERR_ACCES, "ACCES" }, \ 1450 { NFSERR_EXIST, "EXIST" }, \ 1451 { NFSERR_XDEV, "XDEV" }, \ 1452 { NFSERR_NODEV, "NODEV" }, \ 1453 { NFSERR_NOTDIR, "NOTDIR" }, \ 1454 { NFSERR_ISDIR, "ISDIR" }, \ 1455 { NFSERR_INVAL, "INVAL" }, \ 1456 { NFSERR_FBIG, "FBIG" }, \ 1457 { NFSERR_NOSPC, "NOSPC" }, \ 1458 { NFSERR_ROFS, "ROFS" }, \ 1459 { NFSERR_MLINK, "MLINK" }, \ 1460 { NFSERR_OPNOTSUPP, "OPNOTSUPP" }, \ 1461 { NFSERR_NAMETOOLONG, "NAMETOOLONG" }, \ 1462 { NFSERR_NOTEMPTY, "NOTEMPTY" }, \ 1463 { NFSERR_DQUOT, "DQUOT" }, \ 1464 { NFSERR_STALE, "STALE" }, \ 1465 { NFSERR_REMOTE, "REMOTE" }, \ 1466 { NFSERR_WFLUSH, "WFLUSH" }, \ 1467 { NFSERR_BADHANDLE, "BADHANDLE" }, \ 1468 { NFSERR_NOT_SYNC, "NOTSYNC" }, \ 1469 { NFSERR_BAD_COOKIE, "BADCOOKIE" }, \ 1470 { NFSERR_NOTSUPP, "NOTSUPP" }, \ 1471 { NFSERR_TOOSMALL, "TOOSMALL" }, \ 1472 { NFSERR_SERVERFAULT, "REMOTEIO" }, \ 1473 { NFSERR_BADTYPE, "BADTYPE" }, \ 1474 { NFSERR_JUKEBOX, "JUKEBOX" }) 1475 1476 DECLARE_EVENT_CLASS(nfs_xdr_event, 1477 TP_PROTO( 1478 const struct xdr_stream *xdr, 1479 int error 1480 ), 1481 1482 TP_ARGS(xdr, error), 1483 1484 TP_STRUCT__entry( 1485 __field(unsigned int, task_id) 1486 __field(unsigned int, client_id) 1487 __field(u32, xid) 1488 __field(int, version) 1489 __field(unsigned long, error) 1490 __string(program, 1491 xdr->rqst->rq_task->tk_client->cl_program->name) 1492 __string(procedure, 1493 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 1494 ), 1495 1496 TP_fast_assign( 1497 const struct rpc_rqst *rqstp = xdr->rqst; 1498 const struct rpc_task *task = rqstp->rq_task; 1499 1500 __entry->task_id = task->tk_pid; 1501 __entry->client_id = task->tk_client->cl_clid; 1502 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1503 __entry->version = task->tk_client->cl_vers; 1504 __entry->error = error; 1505 __assign_str(program, 1506 task->tk_client->cl_program->name); 1507 __assign_str(procedure, task->tk_msg.rpc_proc->p_name); 1508 ), 1509 1510 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1511 " xid=0x%08x %sv%d %s error=%ld (%s)", 1512 __entry->task_id, __entry->client_id, __entry->xid, 1513 __get_str(program), __entry->version, 1514 __get_str(procedure), -__entry->error, 1515 nfs_show_status(__entry->error) 1516 ) 1517 ); 1518 #define DEFINE_NFS_XDR_EVENT(name) \ 1519 DEFINE_EVENT(nfs_xdr_event, name, \ 1520 TP_PROTO( \ 1521 const struct xdr_stream *xdr, \ 1522 int error \ 1523 ), \ 1524 TP_ARGS(xdr, error)) 1525 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); 1526 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); 1527 1528 #endif /* _TRACE_NFS_H */ 1529 1530 #undef TRACE_INCLUDE_PATH 1531 #define TRACE_INCLUDE_PATH . 1532 #define TRACE_INCLUDE_FILE nfstrace 1533 /* This part must be outside protection */ 1534 #include <trace/define_trace.h> 1535