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 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_cache_fill_done); 164 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_uncached_done); 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_readdir_event, 277 TP_PROTO( 278 const struct file *file, 279 const __be32 *verifier, 280 u64 cookie, 281 pgoff_t page_index, 282 unsigned int dtsize 283 ), 284 285 TP_ARGS(file, verifier, cookie, page_index, dtsize), 286 287 TP_STRUCT__entry( 288 __field(dev_t, dev) 289 __field(u32, fhandle) 290 __field(u64, fileid) 291 __field(u64, version) 292 __array(char, verifier, NFS4_VERIFIER_SIZE) 293 __field(u64, cookie) 294 __field(pgoff_t, index) 295 __field(unsigned int, dtsize) 296 ), 297 298 TP_fast_assign( 299 const struct inode *dir = file_inode(file); 300 const struct nfs_inode *nfsi = NFS_I(dir); 301 302 __entry->dev = dir->i_sb->s_dev; 303 __entry->fileid = nfsi->fileid; 304 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 305 __entry->version = inode_peek_iversion_raw(dir); 306 if (cookie != 0) 307 memcpy(__entry->verifier, verifier, 308 NFS4_VERIFIER_SIZE); 309 else 310 memset(__entry->verifier, 0, 311 NFS4_VERIFIER_SIZE); 312 __entry->cookie = cookie; 313 __entry->index = page_index; 314 __entry->dtsize = dtsize; 315 ), 316 317 TP_printk( 318 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu " 319 "cookie=%s:0x%llx cache_index=%lu dtsize=%u", 320 MAJOR(__entry->dev), MINOR(__entry->dev), 321 (unsigned long long)__entry->fileid, __entry->fhandle, 322 __entry->version, show_nfs4_verifier(__entry->verifier), 323 (unsigned long long)__entry->cookie, __entry->index, 324 __entry->dtsize 325 ) 326 ); 327 328 #define DEFINE_NFS_READDIR_EVENT(name) \ 329 DEFINE_EVENT(nfs_readdir_event, name, \ 330 TP_PROTO( \ 331 const struct file *file, \ 332 const __be32 *verifier, \ 333 u64 cookie, \ 334 pgoff_t page_index, \ 335 unsigned int dtsize \ 336 ), \ 337 TP_ARGS(file, verifier, cookie, page_index, dtsize)) 338 339 DEFINE_NFS_READDIR_EVENT(nfs_readdir_cache_fill); 340 DEFINE_NFS_READDIR_EVENT(nfs_readdir_uncached); 341 342 DECLARE_EVENT_CLASS(nfs_lookup_event, 343 TP_PROTO( 344 const struct inode *dir, 345 const struct dentry *dentry, 346 unsigned int flags 347 ), 348 349 TP_ARGS(dir, dentry, flags), 350 351 TP_STRUCT__entry( 352 __field(unsigned long, flags) 353 __field(dev_t, dev) 354 __field(u64, dir) 355 __string(name, dentry->d_name.name) 356 ), 357 358 TP_fast_assign( 359 __entry->dev = dir->i_sb->s_dev; 360 __entry->dir = NFS_FILEID(dir); 361 __entry->flags = flags; 362 __assign_str(name, dentry->d_name.name); 363 ), 364 365 TP_printk( 366 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 367 __entry->flags, 368 show_fs_lookup_flags(__entry->flags), 369 MAJOR(__entry->dev), MINOR(__entry->dev), 370 (unsigned long long)__entry->dir, 371 __get_str(name) 372 ) 373 ); 374 375 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 376 DEFINE_EVENT(nfs_lookup_event, name, \ 377 TP_PROTO( \ 378 const struct inode *dir, \ 379 const struct dentry *dentry, \ 380 unsigned int flags \ 381 ), \ 382 TP_ARGS(dir, dentry, flags)) 383 384 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 385 TP_PROTO( 386 const struct inode *dir, 387 const struct dentry *dentry, 388 unsigned int flags, 389 int error 390 ), 391 392 TP_ARGS(dir, dentry, flags, error), 393 394 TP_STRUCT__entry( 395 __field(unsigned long, error) 396 __field(unsigned long, flags) 397 __field(dev_t, dev) 398 __field(u64, dir) 399 __string(name, dentry->d_name.name) 400 ), 401 402 TP_fast_assign( 403 __entry->dev = dir->i_sb->s_dev; 404 __entry->dir = NFS_FILEID(dir); 405 __entry->error = error < 0 ? -error : 0; 406 __entry->flags = flags; 407 __assign_str(name, dentry->d_name.name); 408 ), 409 410 TP_printk( 411 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 412 -__entry->error, show_nfs_status(__entry->error), 413 __entry->flags, 414 show_fs_lookup_flags(__entry->flags), 415 MAJOR(__entry->dev), MINOR(__entry->dev), 416 (unsigned long long)__entry->dir, 417 __get_str(name) 418 ) 419 ); 420 421 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 422 DEFINE_EVENT(nfs_lookup_event_done, name, \ 423 TP_PROTO( \ 424 const struct inode *dir, \ 425 const struct dentry *dentry, \ 426 unsigned int flags, \ 427 int error \ 428 ), \ 429 TP_ARGS(dir, dentry, flags, error)) 430 431 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 432 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 433 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter); 434 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit); 435 436 TRACE_EVENT(nfs_atomic_open_enter, 437 TP_PROTO( 438 const struct inode *dir, 439 const struct nfs_open_context *ctx, 440 unsigned int flags 441 ), 442 443 TP_ARGS(dir, ctx, flags), 444 445 TP_STRUCT__entry( 446 __field(unsigned long, flags) 447 __field(unsigned long, fmode) 448 __field(dev_t, dev) 449 __field(u64, dir) 450 __string(name, ctx->dentry->d_name.name) 451 ), 452 453 TP_fast_assign( 454 __entry->dev = dir->i_sb->s_dev; 455 __entry->dir = NFS_FILEID(dir); 456 __entry->flags = flags; 457 __entry->fmode = (__force unsigned long)ctx->mode; 458 __assign_str(name, ctx->dentry->d_name.name); 459 ), 460 461 TP_printk( 462 "flags=0x%lx (%s) fmode=%s name=%02x:%02x:%llu/%s", 463 __entry->flags, 464 show_fs_fcntl_open_flags(__entry->flags), 465 show_fs_fmode_flags(__entry->fmode), 466 MAJOR(__entry->dev), MINOR(__entry->dev), 467 (unsigned long long)__entry->dir, 468 __get_str(name) 469 ) 470 ); 471 472 TRACE_EVENT(nfs_atomic_open_exit, 473 TP_PROTO( 474 const struct inode *dir, 475 const struct nfs_open_context *ctx, 476 unsigned int flags, 477 int error 478 ), 479 480 TP_ARGS(dir, ctx, flags, error), 481 482 TP_STRUCT__entry( 483 __field(unsigned long, error) 484 __field(unsigned long, flags) 485 __field(unsigned long, fmode) 486 __field(dev_t, dev) 487 __field(u64, dir) 488 __string(name, ctx->dentry->d_name.name) 489 ), 490 491 TP_fast_assign( 492 __entry->error = -error; 493 __entry->dev = dir->i_sb->s_dev; 494 __entry->dir = NFS_FILEID(dir); 495 __entry->flags = flags; 496 __entry->fmode = (__force unsigned long)ctx->mode; 497 __assign_str(name, ctx->dentry->d_name.name); 498 ), 499 500 TP_printk( 501 "error=%ld (%s) flags=0x%lx (%s) fmode=%s " 502 "name=%02x:%02x:%llu/%s", 503 -__entry->error, show_nfs_status(__entry->error), 504 __entry->flags, 505 show_fs_fcntl_open_flags(__entry->flags), 506 show_fs_fmode_flags(__entry->fmode), 507 MAJOR(__entry->dev), MINOR(__entry->dev), 508 (unsigned long long)__entry->dir, 509 __get_str(name) 510 ) 511 ); 512 513 TRACE_EVENT(nfs_create_enter, 514 TP_PROTO( 515 const struct inode *dir, 516 const struct dentry *dentry, 517 unsigned int flags 518 ), 519 520 TP_ARGS(dir, dentry, flags), 521 522 TP_STRUCT__entry( 523 __field(unsigned long, flags) 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 __entry->flags = flags; 533 __assign_str(name, dentry->d_name.name); 534 ), 535 536 TP_printk( 537 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 538 __entry->flags, 539 show_fs_fcntl_open_flags(__entry->flags), 540 MAJOR(__entry->dev), MINOR(__entry->dev), 541 (unsigned long long)__entry->dir, 542 __get_str(name) 543 ) 544 ); 545 546 TRACE_EVENT(nfs_create_exit, 547 TP_PROTO( 548 const struct inode *dir, 549 const struct dentry *dentry, 550 unsigned int flags, 551 int error 552 ), 553 554 TP_ARGS(dir, dentry, flags, error), 555 556 TP_STRUCT__entry( 557 __field(unsigned long, error) 558 __field(unsigned long, flags) 559 __field(dev_t, dev) 560 __field(u64, dir) 561 __string(name, dentry->d_name.name) 562 ), 563 564 TP_fast_assign( 565 __entry->error = -error; 566 __entry->dev = dir->i_sb->s_dev; 567 __entry->dir = NFS_FILEID(dir); 568 __entry->flags = flags; 569 __assign_str(name, dentry->d_name.name); 570 ), 571 572 TP_printk( 573 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 574 -__entry->error, show_nfs_status(__entry->error), 575 __entry->flags, 576 show_fs_fcntl_open_flags(__entry->flags), 577 MAJOR(__entry->dev), MINOR(__entry->dev), 578 (unsigned long long)__entry->dir, 579 __get_str(name) 580 ) 581 ); 582 583 DECLARE_EVENT_CLASS(nfs_directory_event, 584 TP_PROTO( 585 const struct inode *dir, 586 const struct dentry *dentry 587 ), 588 589 TP_ARGS(dir, dentry), 590 591 TP_STRUCT__entry( 592 __field(dev_t, dev) 593 __field(u64, dir) 594 __string(name, dentry->d_name.name) 595 ), 596 597 TP_fast_assign( 598 __entry->dev = dir->i_sb->s_dev; 599 __entry->dir = NFS_FILEID(dir); 600 __assign_str(name, dentry->d_name.name); 601 ), 602 603 TP_printk( 604 "name=%02x:%02x:%llu/%s", 605 MAJOR(__entry->dev), MINOR(__entry->dev), 606 (unsigned long long)__entry->dir, 607 __get_str(name) 608 ) 609 ); 610 611 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 612 DEFINE_EVENT(nfs_directory_event, name, \ 613 TP_PROTO( \ 614 const struct inode *dir, \ 615 const struct dentry *dentry \ 616 ), \ 617 TP_ARGS(dir, dentry)) 618 619 DECLARE_EVENT_CLASS(nfs_directory_event_done, 620 TP_PROTO( 621 const struct inode *dir, 622 const struct dentry *dentry, 623 int error 624 ), 625 626 TP_ARGS(dir, dentry, error), 627 628 TP_STRUCT__entry( 629 __field(unsigned long, error) 630 __field(dev_t, dev) 631 __field(u64, dir) 632 __string(name, dentry->d_name.name) 633 ), 634 635 TP_fast_assign( 636 __entry->dev = dir->i_sb->s_dev; 637 __entry->dir = NFS_FILEID(dir); 638 __entry->error = error < 0 ? -error : 0; 639 __assign_str(name, dentry->d_name.name); 640 ), 641 642 TP_printk( 643 "error=%ld (%s) name=%02x:%02x:%llu/%s", 644 -__entry->error, show_nfs_status(__entry->error), 645 MAJOR(__entry->dev), MINOR(__entry->dev), 646 (unsigned long long)__entry->dir, 647 __get_str(name) 648 ) 649 ); 650 651 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \ 652 DEFINE_EVENT(nfs_directory_event_done, name, \ 653 TP_PROTO( \ 654 const struct inode *dir, \ 655 const struct dentry *dentry, \ 656 int error \ 657 ), \ 658 TP_ARGS(dir, dentry, error)) 659 660 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 661 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit); 662 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 663 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit); 664 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 665 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit); 666 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 667 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit); 668 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 669 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit); 670 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 671 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit); 672 673 TRACE_EVENT(nfs_link_enter, 674 TP_PROTO( 675 const struct inode *inode, 676 const struct inode *dir, 677 const struct dentry *dentry 678 ), 679 680 TP_ARGS(inode, dir, dentry), 681 682 TP_STRUCT__entry( 683 __field(dev_t, dev) 684 __field(u64, fileid) 685 __field(u64, dir) 686 __string(name, dentry->d_name.name) 687 ), 688 689 TP_fast_assign( 690 __entry->dev = inode->i_sb->s_dev; 691 __entry->fileid = NFS_FILEID(inode); 692 __entry->dir = NFS_FILEID(dir); 693 __assign_str(name, dentry->d_name.name); 694 ), 695 696 TP_printk( 697 "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 698 MAJOR(__entry->dev), MINOR(__entry->dev), 699 __entry->fileid, 700 MAJOR(__entry->dev), MINOR(__entry->dev), 701 (unsigned long long)__entry->dir, 702 __get_str(name) 703 ) 704 ); 705 706 TRACE_EVENT(nfs_link_exit, 707 TP_PROTO( 708 const struct inode *inode, 709 const struct inode *dir, 710 const struct dentry *dentry, 711 int error 712 ), 713 714 TP_ARGS(inode, dir, dentry, error), 715 716 TP_STRUCT__entry( 717 __field(unsigned long, error) 718 __field(dev_t, dev) 719 __field(u64, fileid) 720 __field(u64, dir) 721 __string(name, dentry->d_name.name) 722 ), 723 724 TP_fast_assign( 725 __entry->dev = inode->i_sb->s_dev; 726 __entry->fileid = NFS_FILEID(inode); 727 __entry->dir = NFS_FILEID(dir); 728 __entry->error = error < 0 ? -error : 0; 729 __assign_str(name, dentry->d_name.name); 730 ), 731 732 TP_printk( 733 "error=%ld (%s) fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 734 -__entry->error, show_nfs_status(__entry->error), 735 MAJOR(__entry->dev), MINOR(__entry->dev), 736 __entry->fileid, 737 MAJOR(__entry->dev), MINOR(__entry->dev), 738 (unsigned long long)__entry->dir, 739 __get_str(name) 740 ) 741 ); 742 743 DECLARE_EVENT_CLASS(nfs_rename_event, 744 TP_PROTO( 745 const struct inode *old_dir, 746 const struct dentry *old_dentry, 747 const struct inode *new_dir, 748 const struct dentry *new_dentry 749 ), 750 751 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry), 752 753 TP_STRUCT__entry( 754 __field(dev_t, dev) 755 __field(u64, old_dir) 756 __field(u64, new_dir) 757 __string(old_name, old_dentry->d_name.name) 758 __string(new_name, new_dentry->d_name.name) 759 ), 760 761 TP_fast_assign( 762 __entry->dev = old_dir->i_sb->s_dev; 763 __entry->old_dir = NFS_FILEID(old_dir); 764 __entry->new_dir = NFS_FILEID(new_dir); 765 __assign_str(old_name, old_dentry->d_name.name); 766 __assign_str(new_name, new_dentry->d_name.name); 767 ), 768 769 TP_printk( 770 "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s", 771 MAJOR(__entry->dev), MINOR(__entry->dev), 772 (unsigned long long)__entry->old_dir, 773 __get_str(old_name), 774 MAJOR(__entry->dev), MINOR(__entry->dev), 775 (unsigned long long)__entry->new_dir, 776 __get_str(new_name) 777 ) 778 ); 779 #define DEFINE_NFS_RENAME_EVENT(name) \ 780 DEFINE_EVENT(nfs_rename_event, name, \ 781 TP_PROTO( \ 782 const struct inode *old_dir, \ 783 const struct dentry *old_dentry, \ 784 const struct inode *new_dir, \ 785 const struct dentry *new_dentry \ 786 ), \ 787 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry)) 788 789 DECLARE_EVENT_CLASS(nfs_rename_event_done, 790 TP_PROTO( 791 const struct inode *old_dir, 792 const struct dentry *old_dentry, 793 const struct inode *new_dir, 794 const struct dentry *new_dentry, 795 int error 796 ), 797 798 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error), 799 800 TP_STRUCT__entry( 801 __field(dev_t, dev) 802 __field(unsigned long, error) 803 __field(u64, old_dir) 804 __string(old_name, old_dentry->d_name.name) 805 __field(u64, new_dir) 806 __string(new_name, new_dentry->d_name.name) 807 ), 808 809 TP_fast_assign( 810 __entry->dev = old_dir->i_sb->s_dev; 811 __entry->error = -error; 812 __entry->old_dir = NFS_FILEID(old_dir); 813 __entry->new_dir = NFS_FILEID(new_dir); 814 __assign_str(old_name, old_dentry->d_name.name); 815 __assign_str(new_name, new_dentry->d_name.name); 816 ), 817 818 TP_printk( 819 "error=%ld (%s) old_name=%02x:%02x:%llu/%s " 820 "new_name=%02x:%02x:%llu/%s", 821 -__entry->error, show_nfs_status(__entry->error), 822 MAJOR(__entry->dev), MINOR(__entry->dev), 823 (unsigned long long)__entry->old_dir, 824 __get_str(old_name), 825 MAJOR(__entry->dev), MINOR(__entry->dev), 826 (unsigned long long)__entry->new_dir, 827 __get_str(new_name) 828 ) 829 ); 830 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 831 DEFINE_EVENT(nfs_rename_event_done, name, \ 832 TP_PROTO( \ 833 const struct inode *old_dir, \ 834 const struct dentry *old_dentry, \ 835 const struct inode *new_dir, \ 836 const struct dentry *new_dentry, \ 837 int error \ 838 ), \ 839 TP_ARGS(old_dir, old_dentry, new_dir, \ 840 new_dentry, error)) 841 842 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 843 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 844 845 DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename); 846 847 TRACE_EVENT(nfs_sillyrename_unlink, 848 TP_PROTO( 849 const struct nfs_unlinkdata *data, 850 int error 851 ), 852 853 TP_ARGS(data, error), 854 855 TP_STRUCT__entry( 856 __field(dev_t, dev) 857 __field(unsigned long, error) 858 __field(u64, dir) 859 __dynamic_array(char, name, data->args.name.len + 1) 860 ), 861 862 TP_fast_assign( 863 struct inode *dir = d_inode(data->dentry->d_parent); 864 size_t len = data->args.name.len; 865 __entry->dev = dir->i_sb->s_dev; 866 __entry->dir = NFS_FILEID(dir); 867 __entry->error = -error; 868 memcpy(__get_str(name), 869 data->args.name.name, len); 870 __get_str(name)[len] = 0; 871 ), 872 873 TP_printk( 874 "error=%ld (%s) name=%02x:%02x:%llu/%s", 875 -__entry->error, show_nfs_status(__entry->error), 876 MAJOR(__entry->dev), MINOR(__entry->dev), 877 (unsigned long long)__entry->dir, 878 __get_str(name) 879 ) 880 ); 881 882 TRACE_EVENT(nfs_aop_readpage, 883 TP_PROTO( 884 const struct inode *inode, 885 struct page *page 886 ), 887 888 TP_ARGS(inode, page), 889 890 TP_STRUCT__entry( 891 __field(dev_t, dev) 892 __field(u32, fhandle) 893 __field(u64, fileid) 894 __field(u64, version) 895 __field(loff_t, offset) 896 ), 897 898 TP_fast_assign( 899 const struct nfs_inode *nfsi = NFS_I(inode); 900 901 __entry->dev = inode->i_sb->s_dev; 902 __entry->fileid = nfsi->fileid; 903 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 904 __entry->version = inode_peek_iversion_raw(inode); 905 __entry->offset = page_index(page) << PAGE_SHIFT; 906 ), 907 908 TP_printk( 909 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld", 910 MAJOR(__entry->dev), MINOR(__entry->dev), 911 (unsigned long long)__entry->fileid, 912 __entry->fhandle, __entry->version, 913 __entry->offset 914 ) 915 ); 916 917 TRACE_EVENT(nfs_aop_readpage_done, 918 TP_PROTO( 919 const struct inode *inode, 920 struct page *page, 921 int ret 922 ), 923 924 TP_ARGS(inode, page, ret), 925 926 TP_STRUCT__entry( 927 __field(dev_t, dev) 928 __field(u32, fhandle) 929 __field(int, ret) 930 __field(u64, fileid) 931 __field(u64, version) 932 __field(loff_t, offset) 933 ), 934 935 TP_fast_assign( 936 const struct nfs_inode *nfsi = NFS_I(inode); 937 938 __entry->dev = inode->i_sb->s_dev; 939 __entry->fileid = nfsi->fileid; 940 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 941 __entry->version = inode_peek_iversion_raw(inode); 942 __entry->offset = page_index(page) << PAGE_SHIFT; 943 __entry->ret = ret; 944 ), 945 946 TP_printk( 947 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld ret=%d", 948 MAJOR(__entry->dev), MINOR(__entry->dev), 949 (unsigned long long)__entry->fileid, 950 __entry->fhandle, __entry->version, 951 __entry->offset, __entry->ret 952 ) 953 ); 954 955 TRACE_EVENT(nfs_aop_readahead, 956 TP_PROTO( 957 const struct inode *inode, 958 loff_t pos, 959 unsigned int nr_pages 960 ), 961 962 TP_ARGS(inode, pos, nr_pages), 963 964 TP_STRUCT__entry( 965 __field(dev_t, dev) 966 __field(u32, fhandle) 967 __field(u64, fileid) 968 __field(u64, version) 969 __field(loff_t, offset) 970 __field(unsigned int, nr_pages) 971 ), 972 973 TP_fast_assign( 974 const struct nfs_inode *nfsi = NFS_I(inode); 975 976 __entry->dev = inode->i_sb->s_dev; 977 __entry->fileid = nfsi->fileid; 978 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 979 __entry->version = inode_peek_iversion_raw(inode); 980 __entry->offset = pos; 981 __entry->nr_pages = nr_pages; 982 ), 983 984 TP_printk( 985 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld nr_pages=%u", 986 MAJOR(__entry->dev), MINOR(__entry->dev), 987 (unsigned long long)__entry->fileid, 988 __entry->fhandle, __entry->version, 989 __entry->offset, __entry->nr_pages 990 ) 991 ); 992 993 TRACE_EVENT(nfs_aop_readahead_done, 994 TP_PROTO( 995 const struct inode *inode, 996 unsigned int nr_pages, 997 int ret 998 ), 999 1000 TP_ARGS(inode, nr_pages, ret), 1001 1002 TP_STRUCT__entry( 1003 __field(dev_t, dev) 1004 __field(u32, fhandle) 1005 __field(int, ret) 1006 __field(u64, fileid) 1007 __field(u64, version) 1008 __field(loff_t, offset) 1009 __field(unsigned int, nr_pages) 1010 ), 1011 1012 TP_fast_assign( 1013 const struct nfs_inode *nfsi = NFS_I(inode); 1014 1015 __entry->dev = inode->i_sb->s_dev; 1016 __entry->fileid = nfsi->fileid; 1017 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1018 __entry->version = inode_peek_iversion_raw(inode); 1019 __entry->nr_pages = nr_pages; 1020 __entry->ret = ret; 1021 ), 1022 1023 TP_printk( 1024 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d", 1025 MAJOR(__entry->dev), MINOR(__entry->dev), 1026 (unsigned long long)__entry->fileid, 1027 __entry->fhandle, __entry->version, 1028 __entry->nr_pages, __entry->ret 1029 ) 1030 ); 1031 1032 TRACE_EVENT(nfs_initiate_read, 1033 TP_PROTO( 1034 const struct nfs_pgio_header *hdr 1035 ), 1036 1037 TP_ARGS(hdr), 1038 1039 TP_STRUCT__entry( 1040 __field(dev_t, dev) 1041 __field(u32, fhandle) 1042 __field(u64, fileid) 1043 __field(loff_t, offset) 1044 __field(u32, count) 1045 ), 1046 1047 TP_fast_assign( 1048 const struct inode *inode = hdr->inode; 1049 const struct nfs_inode *nfsi = NFS_I(inode); 1050 const struct nfs_fh *fh = hdr->args.fh ? 1051 hdr->args.fh : &nfsi->fh; 1052 1053 __entry->offset = hdr->args.offset; 1054 __entry->count = hdr->args.count; 1055 __entry->dev = inode->i_sb->s_dev; 1056 __entry->fileid = nfsi->fileid; 1057 __entry->fhandle = nfs_fhandle_hash(fh); 1058 ), 1059 1060 TP_printk( 1061 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1062 "offset=%lld count=%u", 1063 MAJOR(__entry->dev), MINOR(__entry->dev), 1064 (unsigned long long)__entry->fileid, 1065 __entry->fhandle, 1066 (long long)__entry->offset, __entry->count 1067 ) 1068 ); 1069 1070 TRACE_EVENT(nfs_readpage_done, 1071 TP_PROTO( 1072 const struct rpc_task *task, 1073 const struct nfs_pgio_header *hdr 1074 ), 1075 1076 TP_ARGS(task, hdr), 1077 1078 TP_STRUCT__entry( 1079 __field(dev_t, dev) 1080 __field(u32, fhandle) 1081 __field(u64, fileid) 1082 __field(loff_t, offset) 1083 __field(u32, arg_count) 1084 __field(u32, res_count) 1085 __field(bool, eof) 1086 __field(int, status) 1087 ), 1088 1089 TP_fast_assign( 1090 const struct inode *inode = hdr->inode; 1091 const struct nfs_inode *nfsi = NFS_I(inode); 1092 const struct nfs_fh *fh = hdr->args.fh ? 1093 hdr->args.fh : &nfsi->fh; 1094 1095 __entry->status = task->tk_status; 1096 __entry->offset = hdr->args.offset; 1097 __entry->arg_count = hdr->args.count; 1098 __entry->res_count = hdr->res.count; 1099 __entry->eof = hdr->res.eof; 1100 __entry->dev = inode->i_sb->s_dev; 1101 __entry->fileid = nfsi->fileid; 1102 __entry->fhandle = nfs_fhandle_hash(fh); 1103 ), 1104 1105 TP_printk( 1106 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1107 "offset=%lld count=%u res=%u status=%d%s", 1108 MAJOR(__entry->dev), MINOR(__entry->dev), 1109 (unsigned long long)__entry->fileid, 1110 __entry->fhandle, 1111 (long long)__entry->offset, __entry->arg_count, 1112 __entry->res_count, __entry->status, 1113 __entry->eof ? " eof" : "" 1114 ) 1115 ); 1116 1117 TRACE_EVENT(nfs_readpage_short, 1118 TP_PROTO( 1119 const struct rpc_task *task, 1120 const struct nfs_pgio_header *hdr 1121 ), 1122 1123 TP_ARGS(task, hdr), 1124 1125 TP_STRUCT__entry( 1126 __field(dev_t, dev) 1127 __field(u32, fhandle) 1128 __field(u64, fileid) 1129 __field(loff_t, offset) 1130 __field(u32, arg_count) 1131 __field(u32, res_count) 1132 __field(bool, eof) 1133 __field(int, status) 1134 ), 1135 1136 TP_fast_assign( 1137 const struct inode *inode = hdr->inode; 1138 const struct nfs_inode *nfsi = NFS_I(inode); 1139 const struct nfs_fh *fh = hdr->args.fh ? 1140 hdr->args.fh : &nfsi->fh; 1141 1142 __entry->status = task->tk_status; 1143 __entry->offset = hdr->args.offset; 1144 __entry->arg_count = hdr->args.count; 1145 __entry->res_count = hdr->res.count; 1146 __entry->eof = hdr->res.eof; 1147 __entry->dev = inode->i_sb->s_dev; 1148 __entry->fileid = nfsi->fileid; 1149 __entry->fhandle = nfs_fhandle_hash(fh); 1150 ), 1151 1152 TP_printk( 1153 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1154 "offset=%lld count=%u res=%u status=%d%s", 1155 MAJOR(__entry->dev), MINOR(__entry->dev), 1156 (unsigned long long)__entry->fileid, 1157 __entry->fhandle, 1158 (long long)__entry->offset, __entry->arg_count, 1159 __entry->res_count, __entry->status, 1160 __entry->eof ? " eof" : "" 1161 ) 1162 ); 1163 1164 TRACE_EVENT(nfs_pgio_error, 1165 TP_PROTO( 1166 const struct nfs_pgio_header *hdr, 1167 int error, 1168 loff_t pos 1169 ), 1170 1171 TP_ARGS(hdr, error, pos), 1172 1173 TP_STRUCT__entry( 1174 __field(dev_t, dev) 1175 __field(u32, fhandle) 1176 __field(u64, fileid) 1177 __field(loff_t, offset) 1178 __field(u32, arg_count) 1179 __field(u32, res_count) 1180 __field(loff_t, pos) 1181 __field(int, status) 1182 ), 1183 1184 TP_fast_assign( 1185 const struct inode *inode = hdr->inode; 1186 const struct nfs_inode *nfsi = NFS_I(inode); 1187 const struct nfs_fh *fh = hdr->args.fh ? 1188 hdr->args.fh : &nfsi->fh; 1189 1190 __entry->status = error; 1191 __entry->offset = hdr->args.offset; 1192 __entry->arg_count = hdr->args.count; 1193 __entry->res_count = hdr->res.count; 1194 __entry->dev = inode->i_sb->s_dev; 1195 __entry->fileid = nfsi->fileid; 1196 __entry->fhandle = nfs_fhandle_hash(fh); 1197 ), 1198 1199 TP_printk("fileid=%02x:%02x:%llu fhandle=0x%08x " 1200 "offset=%lld count=%u res=%u pos=%llu status=%d", 1201 MAJOR(__entry->dev), MINOR(__entry->dev), 1202 (unsigned long long)__entry->fileid, __entry->fhandle, 1203 (long long)__entry->offset, __entry->arg_count, __entry->res_count, 1204 __entry->pos, __entry->status 1205 ) 1206 ); 1207 1208 TRACE_EVENT(nfs_initiate_write, 1209 TP_PROTO( 1210 const struct nfs_pgio_header *hdr 1211 ), 1212 1213 TP_ARGS(hdr), 1214 1215 TP_STRUCT__entry( 1216 __field(dev_t, dev) 1217 __field(u32, fhandle) 1218 __field(u64, fileid) 1219 __field(loff_t, offset) 1220 __field(u32, count) 1221 __field(unsigned long, stable) 1222 ), 1223 1224 TP_fast_assign( 1225 const struct inode *inode = hdr->inode; 1226 const struct nfs_inode *nfsi = NFS_I(inode); 1227 const struct nfs_fh *fh = hdr->args.fh ? 1228 hdr->args.fh : &nfsi->fh; 1229 1230 __entry->offset = hdr->args.offset; 1231 __entry->count = hdr->args.count; 1232 __entry->stable = hdr->args.stable; 1233 __entry->dev = inode->i_sb->s_dev; 1234 __entry->fileid = nfsi->fileid; 1235 __entry->fhandle = nfs_fhandle_hash(fh); 1236 ), 1237 1238 TP_printk( 1239 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1240 "offset=%lld count=%u stable=%s", 1241 MAJOR(__entry->dev), MINOR(__entry->dev), 1242 (unsigned long long)__entry->fileid, 1243 __entry->fhandle, 1244 (long long)__entry->offset, __entry->count, 1245 show_nfs_stable_how(__entry->stable) 1246 ) 1247 ); 1248 1249 TRACE_EVENT(nfs_writeback_done, 1250 TP_PROTO( 1251 const struct rpc_task *task, 1252 const struct nfs_pgio_header *hdr 1253 ), 1254 1255 TP_ARGS(task, hdr), 1256 1257 TP_STRUCT__entry( 1258 __field(dev_t, dev) 1259 __field(u32, fhandle) 1260 __field(u64, fileid) 1261 __field(loff_t, offset) 1262 __field(u32, arg_count) 1263 __field(u32, res_count) 1264 __field(int, status) 1265 __field(unsigned long, stable) 1266 __array(char, verifier, NFS4_VERIFIER_SIZE) 1267 ), 1268 1269 TP_fast_assign( 1270 const struct inode *inode = hdr->inode; 1271 const struct nfs_inode *nfsi = NFS_I(inode); 1272 const struct nfs_fh *fh = hdr->args.fh ? 1273 hdr->args.fh : &nfsi->fh; 1274 const struct nfs_writeverf *verf = hdr->res.verf; 1275 1276 __entry->status = task->tk_status; 1277 __entry->offset = hdr->args.offset; 1278 __entry->arg_count = hdr->args.count; 1279 __entry->res_count = hdr->res.count; 1280 __entry->stable = verf->committed; 1281 memcpy(__entry->verifier, 1282 &verf->verifier, 1283 NFS4_VERIFIER_SIZE); 1284 __entry->dev = inode->i_sb->s_dev; 1285 __entry->fileid = nfsi->fileid; 1286 __entry->fhandle = nfs_fhandle_hash(fh); 1287 ), 1288 1289 TP_printk( 1290 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1291 "offset=%lld count=%u res=%u status=%d stable=%s " 1292 "verifier=%s", 1293 MAJOR(__entry->dev), MINOR(__entry->dev), 1294 (unsigned long long)__entry->fileid, 1295 __entry->fhandle, 1296 (long long)__entry->offset, __entry->arg_count, 1297 __entry->res_count, __entry->status, 1298 show_nfs_stable_how(__entry->stable), 1299 show_nfs4_verifier(__entry->verifier) 1300 ) 1301 ); 1302 1303 DECLARE_EVENT_CLASS(nfs_page_error_class, 1304 TP_PROTO( 1305 const struct nfs_page *req, 1306 int error 1307 ), 1308 1309 TP_ARGS(req, error), 1310 1311 TP_STRUCT__entry( 1312 __field(const void *, req) 1313 __field(pgoff_t, index) 1314 __field(unsigned int, offset) 1315 __field(unsigned int, pgbase) 1316 __field(unsigned int, bytes) 1317 __field(int, error) 1318 ), 1319 1320 TP_fast_assign( 1321 __entry->req = req; 1322 __entry->index = req->wb_index; 1323 __entry->offset = req->wb_offset; 1324 __entry->pgbase = req->wb_pgbase; 1325 __entry->bytes = req->wb_bytes; 1326 __entry->error = error; 1327 ), 1328 1329 TP_printk( 1330 "req=%p index=%lu offset=%u pgbase=%u bytes=%u error=%d", 1331 __entry->req, __entry->index, __entry->offset, 1332 __entry->pgbase, __entry->bytes, __entry->error 1333 ) 1334 ); 1335 1336 #define DEFINE_NFS_PAGEERR_EVENT(name) \ 1337 DEFINE_EVENT(nfs_page_error_class, name, \ 1338 TP_PROTO( \ 1339 const struct nfs_page *req, \ 1340 int error \ 1341 ), \ 1342 TP_ARGS(req, error)) 1343 1344 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); 1345 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); 1346 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); 1347 1348 TRACE_EVENT(nfs_initiate_commit, 1349 TP_PROTO( 1350 const struct nfs_commit_data *data 1351 ), 1352 1353 TP_ARGS(data), 1354 1355 TP_STRUCT__entry( 1356 __field(dev_t, dev) 1357 __field(u32, fhandle) 1358 __field(u64, fileid) 1359 __field(loff_t, offset) 1360 __field(u32, count) 1361 ), 1362 1363 TP_fast_assign( 1364 const struct inode *inode = data->inode; 1365 const struct nfs_inode *nfsi = NFS_I(inode); 1366 const struct nfs_fh *fh = data->args.fh ? 1367 data->args.fh : &nfsi->fh; 1368 1369 __entry->offset = data->args.offset; 1370 __entry->count = data->args.count; 1371 __entry->dev = inode->i_sb->s_dev; 1372 __entry->fileid = nfsi->fileid; 1373 __entry->fhandle = nfs_fhandle_hash(fh); 1374 ), 1375 1376 TP_printk( 1377 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1378 "offset=%lld count=%u", 1379 MAJOR(__entry->dev), MINOR(__entry->dev), 1380 (unsigned long long)__entry->fileid, 1381 __entry->fhandle, 1382 (long long)__entry->offset, __entry->count 1383 ) 1384 ); 1385 1386 TRACE_EVENT(nfs_commit_done, 1387 TP_PROTO( 1388 const struct rpc_task *task, 1389 const struct nfs_commit_data *data 1390 ), 1391 1392 TP_ARGS(task, data), 1393 1394 TP_STRUCT__entry( 1395 __field(dev_t, dev) 1396 __field(u32, fhandle) 1397 __field(u64, fileid) 1398 __field(loff_t, offset) 1399 __field(int, status) 1400 __field(unsigned long, stable) 1401 __array(char, verifier, NFS4_VERIFIER_SIZE) 1402 ), 1403 1404 TP_fast_assign( 1405 const struct inode *inode = data->inode; 1406 const struct nfs_inode *nfsi = NFS_I(inode); 1407 const struct nfs_fh *fh = data->args.fh ? 1408 data->args.fh : &nfsi->fh; 1409 const struct nfs_writeverf *verf = data->res.verf; 1410 1411 __entry->status = task->tk_status; 1412 __entry->offset = data->args.offset; 1413 __entry->stable = verf->committed; 1414 memcpy(__entry->verifier, 1415 &verf->verifier, 1416 NFS4_VERIFIER_SIZE); 1417 __entry->dev = inode->i_sb->s_dev; 1418 __entry->fileid = nfsi->fileid; 1419 __entry->fhandle = nfs_fhandle_hash(fh); 1420 ), 1421 1422 TP_printk( 1423 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1424 "offset=%lld status=%d stable=%s verifier=%s", 1425 MAJOR(__entry->dev), MINOR(__entry->dev), 1426 (unsigned long long)__entry->fileid, 1427 __entry->fhandle, 1428 (long long)__entry->offset, __entry->status, 1429 show_nfs_stable_how(__entry->stable), 1430 show_nfs4_verifier(__entry->verifier) 1431 ) 1432 ); 1433 1434 TRACE_EVENT(nfs_fh_to_dentry, 1435 TP_PROTO( 1436 const struct super_block *sb, 1437 const struct nfs_fh *fh, 1438 u64 fileid, 1439 int error 1440 ), 1441 1442 TP_ARGS(sb, fh, fileid, error), 1443 1444 TP_STRUCT__entry( 1445 __field(int, error) 1446 __field(dev_t, dev) 1447 __field(u32, fhandle) 1448 __field(u64, fileid) 1449 ), 1450 1451 TP_fast_assign( 1452 __entry->error = error; 1453 __entry->dev = sb->s_dev; 1454 __entry->fileid = fileid; 1455 __entry->fhandle = nfs_fhandle_hash(fh); 1456 ), 1457 1458 TP_printk( 1459 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ", 1460 __entry->error, 1461 MAJOR(__entry->dev), MINOR(__entry->dev), 1462 (unsigned long long)__entry->fileid, 1463 __entry->fhandle 1464 ) 1465 ); 1466 1467 DECLARE_EVENT_CLASS(nfs_xdr_event, 1468 TP_PROTO( 1469 const struct xdr_stream *xdr, 1470 int error 1471 ), 1472 1473 TP_ARGS(xdr, error), 1474 1475 TP_STRUCT__entry( 1476 __field(unsigned int, task_id) 1477 __field(unsigned int, client_id) 1478 __field(u32, xid) 1479 __field(int, version) 1480 __field(unsigned long, error) 1481 __string(program, 1482 xdr->rqst->rq_task->tk_client->cl_program->name) 1483 __string(procedure, 1484 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 1485 ), 1486 1487 TP_fast_assign( 1488 const struct rpc_rqst *rqstp = xdr->rqst; 1489 const struct rpc_task *task = rqstp->rq_task; 1490 1491 __entry->task_id = task->tk_pid; 1492 __entry->client_id = task->tk_client->cl_clid; 1493 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1494 __entry->version = task->tk_client->cl_vers; 1495 __entry->error = error; 1496 __assign_str(program, 1497 task->tk_client->cl_program->name); 1498 __assign_str(procedure, task->tk_msg.rpc_proc->p_name); 1499 ), 1500 1501 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1502 " xid=0x%08x %sv%d %s error=%ld (%s)", 1503 __entry->task_id, __entry->client_id, __entry->xid, 1504 __get_str(program), __entry->version, 1505 __get_str(procedure), -__entry->error, 1506 show_nfs_status(__entry->error) 1507 ) 1508 ); 1509 #define DEFINE_NFS_XDR_EVENT(name) \ 1510 DEFINE_EVENT(nfs_xdr_event, name, \ 1511 TP_PROTO( \ 1512 const struct xdr_stream *xdr, \ 1513 int error \ 1514 ), \ 1515 TP_ARGS(xdr, error)) 1516 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); 1517 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); 1518 1519 #endif /* _TRACE_NFS_H */ 1520 1521 #undef TRACE_INCLUDE_PATH 1522 #define TRACE_INCLUDE_PATH . 1523 #define TRACE_INCLUDE_FILE nfstrace 1524 /* This part must be outside protection */ 1525 #include <trace/define_trace.h> 1526