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/misc/fs.h> 15 #include <trace/misc/nfs.h> 16 #include <trace/misc/sunrpc.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(nfs_readdir_force_readdirplus); 164 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_cache_fill_done); 165 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_uncached_done); 166 167 TRACE_EVENT(nfs_access_exit, 168 TP_PROTO( 169 const struct inode *inode, 170 unsigned int mask, 171 unsigned int permitted, 172 int error 173 ), 174 175 TP_ARGS(inode, mask, permitted, error), 176 177 TP_STRUCT__entry( 178 __field(unsigned long, error) 179 __field(dev_t, dev) 180 __field(u32, fhandle) 181 __field(unsigned char, type) 182 __field(u64, fileid) 183 __field(u64, version) 184 __field(loff_t, size) 185 __field(unsigned long, nfsi_flags) 186 __field(unsigned long, cache_validity) 187 __field(unsigned int, mask) 188 __field(unsigned int, permitted) 189 ), 190 191 TP_fast_assign( 192 const struct nfs_inode *nfsi = NFS_I(inode); 193 __entry->error = error < 0 ? -error : 0; 194 __entry->dev = inode->i_sb->s_dev; 195 __entry->fileid = nfsi->fileid; 196 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 197 __entry->type = nfs_umode_to_dtype(inode->i_mode); 198 __entry->version = inode_peek_iversion_raw(inode); 199 __entry->size = i_size_read(inode); 200 __entry->nfsi_flags = nfsi->flags; 201 __entry->cache_validity = nfsi->cache_validity; 202 __entry->mask = mask; 203 __entry->permitted = permitted; 204 ), 205 206 TP_printk( 207 "error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x " 208 "type=%u (%s) version=%llu size=%lld " 209 "cache_validity=0x%lx (%s) nfs_flags=0x%lx (%s) " 210 "mask=0x%x permitted=0x%x", 211 -__entry->error, show_nfs_status(__entry->error), 212 MAJOR(__entry->dev), MINOR(__entry->dev), 213 (unsigned long long)__entry->fileid, 214 __entry->fhandle, 215 __entry->type, 216 show_fs_dirent_type(__entry->type), 217 (unsigned long long)__entry->version, 218 (long long)__entry->size, 219 __entry->cache_validity, 220 nfs_show_cache_validity(__entry->cache_validity), 221 __entry->nfsi_flags, 222 nfs_show_nfsi_flags(__entry->nfsi_flags), 223 __entry->mask, __entry->permitted 224 ) 225 ); 226 227 DECLARE_EVENT_CLASS(nfs_update_size_class, 228 TP_PROTO( 229 const struct inode *inode, 230 loff_t new_size 231 ), 232 233 TP_ARGS(inode, new_size), 234 235 TP_STRUCT__entry( 236 __field(dev_t, dev) 237 __field(u32, fhandle) 238 __field(u64, fileid) 239 __field(u64, version) 240 __field(loff_t, cur_size) 241 __field(loff_t, new_size) 242 ), 243 244 TP_fast_assign( 245 const struct nfs_inode *nfsi = NFS_I(inode); 246 247 __entry->dev = inode->i_sb->s_dev; 248 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 249 __entry->fileid = nfsi->fileid; 250 __entry->version = inode_peek_iversion_raw(inode); 251 __entry->cur_size = i_size_read(inode); 252 __entry->new_size = new_size; 253 ), 254 255 TP_printk( 256 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu cursize=%lld newsize=%lld", 257 MAJOR(__entry->dev), MINOR(__entry->dev), 258 (unsigned long long)__entry->fileid, 259 __entry->fhandle, __entry->version, 260 __entry->cur_size, __entry->new_size 261 ) 262 ); 263 264 #define DEFINE_NFS_UPDATE_SIZE_EVENT(name) \ 265 DEFINE_EVENT(nfs_update_size_class, nfs_size_##name, \ 266 TP_PROTO( \ 267 const struct inode *inode, \ 268 loff_t new_size \ 269 ), \ 270 TP_ARGS(inode, new_size)) 271 272 DEFINE_NFS_UPDATE_SIZE_EVENT(truncate); 273 DEFINE_NFS_UPDATE_SIZE_EVENT(wcc); 274 DEFINE_NFS_UPDATE_SIZE_EVENT(update); 275 DEFINE_NFS_UPDATE_SIZE_EVENT(grow); 276 277 DECLARE_EVENT_CLASS(nfs_inode_range_event, 278 TP_PROTO( 279 const struct inode *inode, 280 loff_t range_start, 281 loff_t range_end 282 ), 283 284 TP_ARGS(inode, range_start, range_end), 285 286 TP_STRUCT__entry( 287 __field(dev_t, dev) 288 __field(u32, fhandle) 289 __field(u64, fileid) 290 __field(u64, version) 291 __field(loff_t, range_start) 292 __field(loff_t, range_end) 293 ), 294 295 TP_fast_assign( 296 const struct nfs_inode *nfsi = NFS_I(inode); 297 298 __entry->dev = inode->i_sb->s_dev; 299 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 300 __entry->fileid = nfsi->fileid; 301 __entry->version = inode_peek_iversion_raw(inode); 302 __entry->range_start = range_start; 303 __entry->range_end = range_end; 304 ), 305 306 TP_printk( 307 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu " 308 "range=[%lld, %lld]", 309 MAJOR(__entry->dev), MINOR(__entry->dev), 310 (unsigned long long)__entry->fileid, 311 __entry->fhandle, __entry->version, 312 __entry->range_start, __entry->range_end 313 ) 314 ); 315 316 #define DEFINE_NFS_INODE_RANGE_EVENT(name) \ 317 DEFINE_EVENT(nfs_inode_range_event, name, \ 318 TP_PROTO( \ 319 const struct inode *inode, \ 320 loff_t range_start, \ 321 loff_t range_end \ 322 ), \ 323 TP_ARGS(inode, range_start, range_end)) 324 325 DEFINE_NFS_INODE_RANGE_EVENT(nfs_readdir_invalidate_cache_range); 326 327 DECLARE_EVENT_CLASS(nfs_readdir_event, 328 TP_PROTO( 329 const struct file *file, 330 const __be32 *verifier, 331 u64 cookie, 332 pgoff_t page_index, 333 unsigned int dtsize 334 ), 335 336 TP_ARGS(file, verifier, cookie, page_index, dtsize), 337 338 TP_STRUCT__entry( 339 __field(dev_t, dev) 340 __field(u32, fhandle) 341 __field(u64, fileid) 342 __field(u64, version) 343 __array(char, verifier, NFS4_VERIFIER_SIZE) 344 __field(u64, cookie) 345 __field(pgoff_t, index) 346 __field(unsigned int, dtsize) 347 ), 348 349 TP_fast_assign( 350 const struct inode *dir = file_inode(file); 351 const struct nfs_inode *nfsi = NFS_I(dir); 352 353 __entry->dev = dir->i_sb->s_dev; 354 __entry->fileid = nfsi->fileid; 355 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 356 __entry->version = inode_peek_iversion_raw(dir); 357 if (cookie != 0) 358 memcpy(__entry->verifier, verifier, 359 NFS4_VERIFIER_SIZE); 360 else 361 memset(__entry->verifier, 0, 362 NFS4_VERIFIER_SIZE); 363 __entry->cookie = cookie; 364 __entry->index = page_index; 365 __entry->dtsize = dtsize; 366 ), 367 368 TP_printk( 369 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu " 370 "cookie=%s:0x%llx cache_index=%lu dtsize=%u", 371 MAJOR(__entry->dev), MINOR(__entry->dev), 372 (unsigned long long)__entry->fileid, __entry->fhandle, 373 __entry->version, show_nfs4_verifier(__entry->verifier), 374 (unsigned long long)__entry->cookie, __entry->index, 375 __entry->dtsize 376 ) 377 ); 378 379 #define DEFINE_NFS_READDIR_EVENT(name) \ 380 DEFINE_EVENT(nfs_readdir_event, name, \ 381 TP_PROTO( \ 382 const struct file *file, \ 383 const __be32 *verifier, \ 384 u64 cookie, \ 385 pgoff_t page_index, \ 386 unsigned int dtsize \ 387 ), \ 388 TP_ARGS(file, verifier, cookie, page_index, dtsize)) 389 390 DEFINE_NFS_READDIR_EVENT(nfs_readdir_cache_fill); 391 DEFINE_NFS_READDIR_EVENT(nfs_readdir_uncached); 392 393 DECLARE_EVENT_CLASS(nfs_lookup_event, 394 TP_PROTO( 395 const struct inode *dir, 396 const struct dentry *dentry, 397 unsigned int flags 398 ), 399 400 TP_ARGS(dir, dentry, flags), 401 402 TP_STRUCT__entry( 403 __field(unsigned long, flags) 404 __field(dev_t, dev) 405 __field(u64, dir) 406 __string(name, dentry->d_name.name) 407 ), 408 409 TP_fast_assign( 410 __entry->dev = dir->i_sb->s_dev; 411 __entry->dir = NFS_FILEID(dir); 412 __entry->flags = flags; 413 __assign_str(name, dentry->d_name.name); 414 ), 415 416 TP_printk( 417 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 418 __entry->flags, 419 show_fs_lookup_flags(__entry->flags), 420 MAJOR(__entry->dev), MINOR(__entry->dev), 421 (unsigned long long)__entry->dir, 422 __get_str(name) 423 ) 424 ); 425 426 #define DEFINE_NFS_LOOKUP_EVENT(name) \ 427 DEFINE_EVENT(nfs_lookup_event, name, \ 428 TP_PROTO( \ 429 const struct inode *dir, \ 430 const struct dentry *dentry, \ 431 unsigned int flags \ 432 ), \ 433 TP_ARGS(dir, dentry, flags)) 434 435 DECLARE_EVENT_CLASS(nfs_lookup_event_done, 436 TP_PROTO( 437 const struct inode *dir, 438 const struct dentry *dentry, 439 unsigned int flags, 440 int error 441 ), 442 443 TP_ARGS(dir, dentry, flags, error), 444 445 TP_STRUCT__entry( 446 __field(unsigned long, error) 447 __field(unsigned long, flags) 448 __field(dev_t, dev) 449 __field(u64, dir) 450 __string(name, 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->error = error < 0 ? -error : 0; 457 __entry->flags = flags; 458 __assign_str(name, dentry->d_name.name); 459 ), 460 461 TP_printk( 462 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 463 -__entry->error, show_nfs_status(__entry->error), 464 __entry->flags, 465 show_fs_lookup_flags(__entry->flags), 466 MAJOR(__entry->dev), MINOR(__entry->dev), 467 (unsigned long long)__entry->dir, 468 __get_str(name) 469 ) 470 ); 471 472 #define DEFINE_NFS_LOOKUP_EVENT_DONE(name) \ 473 DEFINE_EVENT(nfs_lookup_event_done, name, \ 474 TP_PROTO( \ 475 const struct inode *dir, \ 476 const struct dentry *dentry, \ 477 unsigned int flags, \ 478 int error \ 479 ), \ 480 TP_ARGS(dir, dentry, flags, error)) 481 482 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 483 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 484 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter); 485 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit); 486 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup); 487 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup_revalidate_failed); 488 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_readdir_lookup_revalidate); 489 490 TRACE_EVENT(nfs_atomic_open_enter, 491 TP_PROTO( 492 const struct inode *dir, 493 const struct nfs_open_context *ctx, 494 unsigned int flags 495 ), 496 497 TP_ARGS(dir, ctx, flags), 498 499 TP_STRUCT__entry( 500 __field(unsigned long, flags) 501 __field(unsigned long, fmode) 502 __field(dev_t, dev) 503 __field(u64, dir) 504 __string(name, ctx->dentry->d_name.name) 505 ), 506 507 TP_fast_assign( 508 __entry->dev = dir->i_sb->s_dev; 509 __entry->dir = NFS_FILEID(dir); 510 __entry->flags = flags; 511 __entry->fmode = (__force unsigned long)ctx->mode; 512 __assign_str(name, ctx->dentry->d_name.name); 513 ), 514 515 TP_printk( 516 "flags=0x%lx (%s) fmode=%s name=%02x:%02x:%llu/%s", 517 __entry->flags, 518 show_fs_fcntl_open_flags(__entry->flags), 519 show_fs_fmode_flags(__entry->fmode), 520 MAJOR(__entry->dev), MINOR(__entry->dev), 521 (unsigned long long)__entry->dir, 522 __get_str(name) 523 ) 524 ); 525 526 TRACE_EVENT(nfs_atomic_open_exit, 527 TP_PROTO( 528 const struct inode *dir, 529 const struct nfs_open_context *ctx, 530 unsigned int flags, 531 int error 532 ), 533 534 TP_ARGS(dir, ctx, flags, error), 535 536 TP_STRUCT__entry( 537 __field(unsigned long, error) 538 __field(unsigned long, flags) 539 __field(unsigned long, fmode) 540 __field(dev_t, dev) 541 __field(u64, dir) 542 __string(name, ctx->dentry->d_name.name) 543 ), 544 545 TP_fast_assign( 546 __entry->error = -error; 547 __entry->dev = dir->i_sb->s_dev; 548 __entry->dir = NFS_FILEID(dir); 549 __entry->flags = flags; 550 __entry->fmode = (__force unsigned long)ctx->mode; 551 __assign_str(name, ctx->dentry->d_name.name); 552 ), 553 554 TP_printk( 555 "error=%ld (%s) flags=0x%lx (%s) fmode=%s " 556 "name=%02x:%02x:%llu/%s", 557 -__entry->error, show_nfs_status(__entry->error), 558 __entry->flags, 559 show_fs_fcntl_open_flags(__entry->flags), 560 show_fs_fmode_flags(__entry->fmode), 561 MAJOR(__entry->dev), MINOR(__entry->dev), 562 (unsigned long long)__entry->dir, 563 __get_str(name) 564 ) 565 ); 566 567 TRACE_EVENT(nfs_create_enter, 568 TP_PROTO( 569 const struct inode *dir, 570 const struct dentry *dentry, 571 unsigned int flags 572 ), 573 574 TP_ARGS(dir, dentry, flags), 575 576 TP_STRUCT__entry( 577 __field(unsigned long, flags) 578 __field(dev_t, dev) 579 __field(u64, dir) 580 __string(name, dentry->d_name.name) 581 ), 582 583 TP_fast_assign( 584 __entry->dev = dir->i_sb->s_dev; 585 __entry->dir = NFS_FILEID(dir); 586 __entry->flags = flags; 587 __assign_str(name, dentry->d_name.name); 588 ), 589 590 TP_printk( 591 "flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 592 __entry->flags, 593 show_fs_fcntl_open_flags(__entry->flags), 594 MAJOR(__entry->dev), MINOR(__entry->dev), 595 (unsigned long long)__entry->dir, 596 __get_str(name) 597 ) 598 ); 599 600 TRACE_EVENT(nfs_create_exit, 601 TP_PROTO( 602 const struct inode *dir, 603 const struct dentry *dentry, 604 unsigned int flags, 605 int error 606 ), 607 608 TP_ARGS(dir, dentry, flags, error), 609 610 TP_STRUCT__entry( 611 __field(unsigned long, error) 612 __field(unsigned long, flags) 613 __field(dev_t, dev) 614 __field(u64, dir) 615 __string(name, dentry->d_name.name) 616 ), 617 618 TP_fast_assign( 619 __entry->error = -error; 620 __entry->dev = dir->i_sb->s_dev; 621 __entry->dir = NFS_FILEID(dir); 622 __entry->flags = flags; 623 __assign_str(name, dentry->d_name.name); 624 ), 625 626 TP_printk( 627 "error=%ld (%s) flags=0x%lx (%s) name=%02x:%02x:%llu/%s", 628 -__entry->error, show_nfs_status(__entry->error), 629 __entry->flags, 630 show_fs_fcntl_open_flags(__entry->flags), 631 MAJOR(__entry->dev), MINOR(__entry->dev), 632 (unsigned long long)__entry->dir, 633 __get_str(name) 634 ) 635 ); 636 637 DECLARE_EVENT_CLASS(nfs_directory_event, 638 TP_PROTO( 639 const struct inode *dir, 640 const struct dentry *dentry 641 ), 642 643 TP_ARGS(dir, dentry), 644 645 TP_STRUCT__entry( 646 __field(dev_t, dev) 647 __field(u64, dir) 648 __string(name, dentry->d_name.name) 649 ), 650 651 TP_fast_assign( 652 __entry->dev = dir->i_sb->s_dev; 653 __entry->dir = NFS_FILEID(dir); 654 __assign_str(name, dentry->d_name.name); 655 ), 656 657 TP_printk( 658 "name=%02x:%02x:%llu/%s", 659 MAJOR(__entry->dev), MINOR(__entry->dev), 660 (unsigned long long)__entry->dir, 661 __get_str(name) 662 ) 663 ); 664 665 #define DEFINE_NFS_DIRECTORY_EVENT(name) \ 666 DEFINE_EVENT(nfs_directory_event, name, \ 667 TP_PROTO( \ 668 const struct inode *dir, \ 669 const struct dentry *dentry \ 670 ), \ 671 TP_ARGS(dir, dentry)) 672 673 DECLARE_EVENT_CLASS(nfs_directory_event_done, 674 TP_PROTO( 675 const struct inode *dir, 676 const struct dentry *dentry, 677 int error 678 ), 679 680 TP_ARGS(dir, dentry, error), 681 682 TP_STRUCT__entry( 683 __field(unsigned long, error) 684 __field(dev_t, dev) 685 __field(u64, dir) 686 __string(name, dentry->d_name.name) 687 ), 688 689 TP_fast_assign( 690 __entry->dev = dir->i_sb->s_dev; 691 __entry->dir = NFS_FILEID(dir); 692 __entry->error = error < 0 ? -error : 0; 693 __assign_str(name, dentry->d_name.name); 694 ), 695 696 TP_printk( 697 "error=%ld (%s) name=%02x:%02x:%llu/%s", 698 -__entry->error, show_nfs_status(__entry->error), 699 MAJOR(__entry->dev), MINOR(__entry->dev), 700 (unsigned long long)__entry->dir, 701 __get_str(name) 702 ) 703 ); 704 705 #define DEFINE_NFS_DIRECTORY_EVENT_DONE(name) \ 706 DEFINE_EVENT(nfs_directory_event_done, name, \ 707 TP_PROTO( \ 708 const struct inode *dir, \ 709 const struct dentry *dentry, \ 710 int error \ 711 ), \ 712 TP_ARGS(dir, dentry, error)) 713 714 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 715 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit); 716 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 717 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit); 718 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 719 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit); 720 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 721 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit); 722 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 723 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit); 724 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 725 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit); 726 727 TRACE_EVENT(nfs_link_enter, 728 TP_PROTO( 729 const struct inode *inode, 730 const struct inode *dir, 731 const struct dentry *dentry 732 ), 733 734 TP_ARGS(inode, dir, dentry), 735 736 TP_STRUCT__entry( 737 __field(dev_t, dev) 738 __field(u64, fileid) 739 __field(u64, dir) 740 __string(name, dentry->d_name.name) 741 ), 742 743 TP_fast_assign( 744 __entry->dev = inode->i_sb->s_dev; 745 __entry->fileid = NFS_FILEID(inode); 746 __entry->dir = NFS_FILEID(dir); 747 __assign_str(name, dentry->d_name.name); 748 ), 749 750 TP_printk( 751 "fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 752 MAJOR(__entry->dev), MINOR(__entry->dev), 753 __entry->fileid, 754 MAJOR(__entry->dev), MINOR(__entry->dev), 755 (unsigned long long)__entry->dir, 756 __get_str(name) 757 ) 758 ); 759 760 TRACE_EVENT(nfs_link_exit, 761 TP_PROTO( 762 const struct inode *inode, 763 const struct inode *dir, 764 const struct dentry *dentry, 765 int error 766 ), 767 768 TP_ARGS(inode, dir, dentry, error), 769 770 TP_STRUCT__entry( 771 __field(unsigned long, error) 772 __field(dev_t, dev) 773 __field(u64, fileid) 774 __field(u64, dir) 775 __string(name, dentry->d_name.name) 776 ), 777 778 TP_fast_assign( 779 __entry->dev = inode->i_sb->s_dev; 780 __entry->fileid = NFS_FILEID(inode); 781 __entry->dir = NFS_FILEID(dir); 782 __entry->error = error < 0 ? -error : 0; 783 __assign_str(name, dentry->d_name.name); 784 ), 785 786 TP_printk( 787 "error=%ld (%s) fileid=%02x:%02x:%llu name=%02x:%02x:%llu/%s", 788 -__entry->error, show_nfs_status(__entry->error), 789 MAJOR(__entry->dev), MINOR(__entry->dev), 790 __entry->fileid, 791 MAJOR(__entry->dev), MINOR(__entry->dev), 792 (unsigned long long)__entry->dir, 793 __get_str(name) 794 ) 795 ); 796 797 DECLARE_EVENT_CLASS(nfs_rename_event, 798 TP_PROTO( 799 const struct inode *old_dir, 800 const struct dentry *old_dentry, 801 const struct inode *new_dir, 802 const struct dentry *new_dentry 803 ), 804 805 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry), 806 807 TP_STRUCT__entry( 808 __field(dev_t, dev) 809 __field(u64, old_dir) 810 __field(u64, new_dir) 811 __string(old_name, old_dentry->d_name.name) 812 __string(new_name, new_dentry->d_name.name) 813 ), 814 815 TP_fast_assign( 816 __entry->dev = old_dir->i_sb->s_dev; 817 __entry->old_dir = NFS_FILEID(old_dir); 818 __entry->new_dir = NFS_FILEID(new_dir); 819 __assign_str(old_name, old_dentry->d_name.name); 820 __assign_str(new_name, new_dentry->d_name.name); 821 ), 822 823 TP_printk( 824 "old_name=%02x:%02x:%llu/%s new_name=%02x:%02x:%llu/%s", 825 MAJOR(__entry->dev), MINOR(__entry->dev), 826 (unsigned long long)__entry->old_dir, 827 __get_str(old_name), 828 MAJOR(__entry->dev), MINOR(__entry->dev), 829 (unsigned long long)__entry->new_dir, 830 __get_str(new_name) 831 ) 832 ); 833 #define DEFINE_NFS_RENAME_EVENT(name) \ 834 DEFINE_EVENT(nfs_rename_event, name, \ 835 TP_PROTO( \ 836 const struct inode *old_dir, \ 837 const struct dentry *old_dentry, \ 838 const struct inode *new_dir, \ 839 const struct dentry *new_dentry \ 840 ), \ 841 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry)) 842 843 DECLARE_EVENT_CLASS(nfs_rename_event_done, 844 TP_PROTO( 845 const struct inode *old_dir, 846 const struct dentry *old_dentry, 847 const struct inode *new_dir, 848 const struct dentry *new_dentry, 849 int error 850 ), 851 852 TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, error), 853 854 TP_STRUCT__entry( 855 __field(dev_t, dev) 856 __field(unsigned long, error) 857 __field(u64, old_dir) 858 __string(old_name, old_dentry->d_name.name) 859 __field(u64, new_dir) 860 __string(new_name, new_dentry->d_name.name) 861 ), 862 863 TP_fast_assign( 864 __entry->dev = old_dir->i_sb->s_dev; 865 __entry->error = -error; 866 __entry->old_dir = NFS_FILEID(old_dir); 867 __entry->new_dir = NFS_FILEID(new_dir); 868 __assign_str(old_name, old_dentry->d_name.name); 869 __assign_str(new_name, new_dentry->d_name.name); 870 ), 871 872 TP_printk( 873 "error=%ld (%s) old_name=%02x:%02x:%llu/%s " 874 "new_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->old_dir, 878 __get_str(old_name), 879 MAJOR(__entry->dev), MINOR(__entry->dev), 880 (unsigned long long)__entry->new_dir, 881 __get_str(new_name) 882 ) 883 ); 884 #define DEFINE_NFS_RENAME_EVENT_DONE(name) \ 885 DEFINE_EVENT(nfs_rename_event_done, name, \ 886 TP_PROTO( \ 887 const struct inode *old_dir, \ 888 const struct dentry *old_dentry, \ 889 const struct inode *new_dir, \ 890 const struct dentry *new_dentry, \ 891 int error \ 892 ), \ 893 TP_ARGS(old_dir, old_dentry, new_dir, \ 894 new_dentry, error)) 895 896 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 897 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 898 899 DEFINE_NFS_RENAME_EVENT_DONE(nfs_sillyrename_rename); 900 901 TRACE_EVENT(nfs_sillyrename_unlink, 902 TP_PROTO( 903 const struct nfs_unlinkdata *data, 904 int error 905 ), 906 907 TP_ARGS(data, error), 908 909 TP_STRUCT__entry( 910 __field(dev_t, dev) 911 __field(unsigned long, error) 912 __field(u64, dir) 913 __dynamic_array(char, name, data->args.name.len + 1) 914 ), 915 916 TP_fast_assign( 917 struct inode *dir = d_inode(data->dentry->d_parent); 918 size_t len = data->args.name.len; 919 __entry->dev = dir->i_sb->s_dev; 920 __entry->dir = NFS_FILEID(dir); 921 __entry->error = -error; 922 memcpy(__get_str(name), 923 data->args.name.name, len); 924 __get_str(name)[len] = 0; 925 ), 926 927 TP_printk( 928 "error=%ld (%s) name=%02x:%02x:%llu/%s", 929 -__entry->error, show_nfs_status(__entry->error), 930 MAJOR(__entry->dev), MINOR(__entry->dev), 931 (unsigned long long)__entry->dir, 932 __get_str(name) 933 ) 934 ); 935 936 DECLARE_EVENT_CLASS(nfs_folio_event, 937 TP_PROTO( 938 const struct inode *inode, 939 struct folio *folio 940 ), 941 942 TP_ARGS(inode, folio), 943 944 TP_STRUCT__entry( 945 __field(dev_t, dev) 946 __field(u32, fhandle) 947 __field(u64, fileid) 948 __field(u64, version) 949 __field(loff_t, offset) 950 __field(u32, count) 951 ), 952 953 TP_fast_assign( 954 const struct nfs_inode *nfsi = NFS_I(inode); 955 956 __entry->dev = inode->i_sb->s_dev; 957 __entry->fileid = nfsi->fileid; 958 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 959 __entry->version = inode_peek_iversion_raw(inode); 960 __entry->offset = folio_file_pos(folio); 961 __entry->count = nfs_folio_length(folio); 962 ), 963 964 TP_printk( 965 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu " 966 "offset=%lld count=%u", 967 MAJOR(__entry->dev), MINOR(__entry->dev), 968 (unsigned long long)__entry->fileid, 969 __entry->fhandle, __entry->version, 970 __entry->offset, __entry->count 971 ) 972 ); 973 974 #define DEFINE_NFS_FOLIO_EVENT(name) \ 975 DEFINE_EVENT(nfs_folio_event, name, \ 976 TP_PROTO( \ 977 const struct inode *inode, \ 978 struct folio *folio \ 979 ), \ 980 TP_ARGS(inode, folio)) 981 982 DECLARE_EVENT_CLASS(nfs_folio_event_done, 983 TP_PROTO( 984 const struct inode *inode, 985 struct folio *folio, 986 int ret 987 ), 988 989 TP_ARGS(inode, folio, ret), 990 991 TP_STRUCT__entry( 992 __field(dev_t, dev) 993 __field(u32, fhandle) 994 __field(int, ret) 995 __field(u64, fileid) 996 __field(u64, version) 997 __field(loff_t, offset) 998 __field(u32, count) 999 ), 1000 1001 TP_fast_assign( 1002 const struct nfs_inode *nfsi = NFS_I(inode); 1003 1004 __entry->dev = inode->i_sb->s_dev; 1005 __entry->fileid = nfsi->fileid; 1006 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1007 __entry->version = inode_peek_iversion_raw(inode); 1008 __entry->offset = folio_file_pos(folio); 1009 __entry->count = nfs_folio_length(folio); 1010 __entry->ret = ret; 1011 ), 1012 1013 TP_printk( 1014 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu " 1015 "offset=%lld count=%u ret=%d", 1016 MAJOR(__entry->dev), MINOR(__entry->dev), 1017 (unsigned long long)__entry->fileid, 1018 __entry->fhandle, __entry->version, 1019 __entry->offset, __entry->count, __entry->ret 1020 ) 1021 ); 1022 1023 #define DEFINE_NFS_FOLIO_EVENT_DONE(name) \ 1024 DEFINE_EVENT(nfs_folio_event_done, name, \ 1025 TP_PROTO( \ 1026 const struct inode *inode, \ 1027 struct folio *folio, \ 1028 int ret \ 1029 ), \ 1030 TP_ARGS(inode, folio, ret)) 1031 1032 DEFINE_NFS_FOLIO_EVENT(nfs_aop_readpage); 1033 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_aop_readpage_done); 1034 1035 DEFINE_NFS_FOLIO_EVENT(nfs_invalidate_folio); 1036 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_launder_folio_done); 1037 1038 TRACE_EVENT(nfs_aop_readahead, 1039 TP_PROTO( 1040 const struct inode *inode, 1041 loff_t pos, 1042 unsigned int nr_pages 1043 ), 1044 1045 TP_ARGS(inode, pos, nr_pages), 1046 1047 TP_STRUCT__entry( 1048 __field(dev_t, dev) 1049 __field(u32, fhandle) 1050 __field(u64, fileid) 1051 __field(u64, version) 1052 __field(loff_t, offset) 1053 __field(unsigned int, nr_pages) 1054 ), 1055 1056 TP_fast_assign( 1057 const struct nfs_inode *nfsi = NFS_I(inode); 1058 1059 __entry->dev = inode->i_sb->s_dev; 1060 __entry->fileid = nfsi->fileid; 1061 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1062 __entry->version = inode_peek_iversion_raw(inode); 1063 __entry->offset = pos; 1064 __entry->nr_pages = nr_pages; 1065 ), 1066 1067 TP_printk( 1068 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld nr_pages=%u", 1069 MAJOR(__entry->dev), MINOR(__entry->dev), 1070 (unsigned long long)__entry->fileid, 1071 __entry->fhandle, __entry->version, 1072 __entry->offset, __entry->nr_pages 1073 ) 1074 ); 1075 1076 TRACE_EVENT(nfs_aop_readahead_done, 1077 TP_PROTO( 1078 const struct inode *inode, 1079 unsigned int nr_pages, 1080 int ret 1081 ), 1082 1083 TP_ARGS(inode, nr_pages, ret), 1084 1085 TP_STRUCT__entry( 1086 __field(dev_t, dev) 1087 __field(u32, fhandle) 1088 __field(int, ret) 1089 __field(u64, fileid) 1090 __field(u64, version) 1091 __field(loff_t, offset) 1092 __field(unsigned int, nr_pages) 1093 ), 1094 1095 TP_fast_assign( 1096 const struct nfs_inode *nfsi = NFS_I(inode); 1097 1098 __entry->dev = inode->i_sb->s_dev; 1099 __entry->fileid = nfsi->fileid; 1100 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1101 __entry->version = inode_peek_iversion_raw(inode); 1102 __entry->nr_pages = nr_pages; 1103 __entry->ret = ret; 1104 ), 1105 1106 TP_printk( 1107 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d", 1108 MAJOR(__entry->dev), MINOR(__entry->dev), 1109 (unsigned long long)__entry->fileid, 1110 __entry->fhandle, __entry->version, 1111 __entry->nr_pages, __entry->ret 1112 ) 1113 ); 1114 1115 TRACE_EVENT(nfs_initiate_read, 1116 TP_PROTO( 1117 const struct nfs_pgio_header *hdr 1118 ), 1119 1120 TP_ARGS(hdr), 1121 1122 TP_STRUCT__entry( 1123 __field(dev_t, dev) 1124 __field(u32, fhandle) 1125 __field(u64, fileid) 1126 __field(loff_t, offset) 1127 __field(u32, count) 1128 ), 1129 1130 TP_fast_assign( 1131 const struct inode *inode = hdr->inode; 1132 const struct nfs_inode *nfsi = NFS_I(inode); 1133 const struct nfs_fh *fh = hdr->args.fh ? 1134 hdr->args.fh : &nfsi->fh; 1135 1136 __entry->offset = hdr->args.offset; 1137 __entry->count = hdr->args.count; 1138 __entry->dev = inode->i_sb->s_dev; 1139 __entry->fileid = nfsi->fileid; 1140 __entry->fhandle = nfs_fhandle_hash(fh); 1141 ), 1142 1143 TP_printk( 1144 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1145 "offset=%lld count=%u", 1146 MAJOR(__entry->dev), MINOR(__entry->dev), 1147 (unsigned long long)__entry->fileid, 1148 __entry->fhandle, 1149 (long long)__entry->offset, __entry->count 1150 ) 1151 ); 1152 1153 TRACE_EVENT(nfs_readpage_done, 1154 TP_PROTO( 1155 const struct rpc_task *task, 1156 const struct nfs_pgio_header *hdr 1157 ), 1158 1159 TP_ARGS(task, hdr), 1160 1161 TP_STRUCT__entry( 1162 __field(dev_t, dev) 1163 __field(u32, fhandle) 1164 __field(u64, fileid) 1165 __field(loff_t, offset) 1166 __field(u32, arg_count) 1167 __field(u32, res_count) 1168 __field(bool, eof) 1169 __field(int, error) 1170 ), 1171 1172 TP_fast_assign( 1173 const struct inode *inode = hdr->inode; 1174 const struct nfs_inode *nfsi = NFS_I(inode); 1175 const struct nfs_fh *fh = hdr->args.fh ? 1176 hdr->args.fh : &nfsi->fh; 1177 1178 __entry->error = task->tk_status; 1179 __entry->offset = hdr->args.offset; 1180 __entry->arg_count = hdr->args.count; 1181 __entry->res_count = hdr->res.count; 1182 __entry->eof = hdr->res.eof; 1183 __entry->dev = inode->i_sb->s_dev; 1184 __entry->fileid = nfsi->fileid; 1185 __entry->fhandle = nfs_fhandle_hash(fh); 1186 ), 1187 1188 TP_printk( 1189 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1190 "offset=%lld count=%u res=%u%s", __entry->error, 1191 MAJOR(__entry->dev), MINOR(__entry->dev), 1192 (unsigned long long)__entry->fileid, 1193 __entry->fhandle, 1194 (long long)__entry->offset, __entry->arg_count, 1195 __entry->res_count, __entry->eof ? " eof" : "" 1196 ) 1197 ); 1198 1199 TRACE_EVENT(nfs_readpage_short, 1200 TP_PROTO( 1201 const struct rpc_task *task, 1202 const struct nfs_pgio_header *hdr 1203 ), 1204 1205 TP_ARGS(task, hdr), 1206 1207 TP_STRUCT__entry( 1208 __field(dev_t, dev) 1209 __field(u32, fhandle) 1210 __field(u64, fileid) 1211 __field(loff_t, offset) 1212 __field(u32, arg_count) 1213 __field(u32, res_count) 1214 __field(bool, eof) 1215 __field(int, error) 1216 ), 1217 1218 TP_fast_assign( 1219 const struct inode *inode = hdr->inode; 1220 const struct nfs_inode *nfsi = NFS_I(inode); 1221 const struct nfs_fh *fh = hdr->args.fh ? 1222 hdr->args.fh : &nfsi->fh; 1223 1224 __entry->error = task->tk_status; 1225 __entry->offset = hdr->args.offset; 1226 __entry->arg_count = hdr->args.count; 1227 __entry->res_count = hdr->res.count; 1228 __entry->eof = hdr->res.eof; 1229 __entry->dev = inode->i_sb->s_dev; 1230 __entry->fileid = nfsi->fileid; 1231 __entry->fhandle = nfs_fhandle_hash(fh); 1232 ), 1233 1234 TP_printk( 1235 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1236 "offset=%lld count=%u res=%u%s", __entry->error, 1237 MAJOR(__entry->dev), MINOR(__entry->dev), 1238 (unsigned long long)__entry->fileid, 1239 __entry->fhandle, 1240 (long long)__entry->offset, __entry->arg_count, 1241 __entry->res_count, __entry->eof ? " eof" : "" 1242 ) 1243 ); 1244 1245 DECLARE_EVENT_CLASS(nfs_fscache_page_event, 1246 TP_PROTO( 1247 const struct inode *inode, 1248 struct page *page 1249 ), 1250 1251 TP_ARGS(inode, page), 1252 1253 TP_STRUCT__entry( 1254 __field(dev_t, dev) 1255 __field(u32, fhandle) 1256 __field(u64, fileid) 1257 __field(loff_t, offset) 1258 ), 1259 1260 TP_fast_assign( 1261 const struct nfs_inode *nfsi = NFS_I(inode); 1262 const struct nfs_fh *fh = &nfsi->fh; 1263 1264 __entry->offset = page_index(page) << PAGE_SHIFT; 1265 __entry->dev = inode->i_sb->s_dev; 1266 __entry->fileid = nfsi->fileid; 1267 __entry->fhandle = nfs_fhandle_hash(fh); 1268 ), 1269 1270 TP_printk( 1271 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1272 "offset=%lld", 1273 MAJOR(__entry->dev), MINOR(__entry->dev), 1274 (unsigned long long)__entry->fileid, 1275 __entry->fhandle, 1276 (long long)__entry->offset 1277 ) 1278 ); 1279 DECLARE_EVENT_CLASS(nfs_fscache_page_event_done, 1280 TP_PROTO( 1281 const struct inode *inode, 1282 struct page *page, 1283 int error 1284 ), 1285 1286 TP_ARGS(inode, page, error), 1287 1288 TP_STRUCT__entry( 1289 __field(int, error) 1290 __field(dev_t, dev) 1291 __field(u32, fhandle) 1292 __field(u64, fileid) 1293 __field(loff_t, offset) 1294 ), 1295 1296 TP_fast_assign( 1297 const struct nfs_inode *nfsi = NFS_I(inode); 1298 const struct nfs_fh *fh = &nfsi->fh; 1299 1300 __entry->offset = page_index(page) << PAGE_SHIFT; 1301 __entry->dev = inode->i_sb->s_dev; 1302 __entry->fileid = nfsi->fileid; 1303 __entry->fhandle = nfs_fhandle_hash(fh); 1304 __entry->error = error; 1305 ), 1306 1307 TP_printk( 1308 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1309 "offset=%lld error=%d", 1310 MAJOR(__entry->dev), MINOR(__entry->dev), 1311 (unsigned long long)__entry->fileid, 1312 __entry->fhandle, 1313 (long long)__entry->offset, __entry->error 1314 ) 1315 ); 1316 #define DEFINE_NFS_FSCACHE_PAGE_EVENT(name) \ 1317 DEFINE_EVENT(nfs_fscache_page_event, name, \ 1318 TP_PROTO( \ 1319 const struct inode *inode, \ 1320 struct page *page \ 1321 ), \ 1322 TP_ARGS(inode, page)) 1323 #define DEFINE_NFS_FSCACHE_PAGE_EVENT_DONE(name) \ 1324 DEFINE_EVENT(nfs_fscache_page_event_done, name, \ 1325 TP_PROTO( \ 1326 const struct inode *inode, \ 1327 struct page *page, \ 1328 int error \ 1329 ), \ 1330 TP_ARGS(inode, page, error)) 1331 DEFINE_NFS_FSCACHE_PAGE_EVENT(nfs_fscache_read_page); 1332 DEFINE_NFS_FSCACHE_PAGE_EVENT_DONE(nfs_fscache_read_page_exit); 1333 DEFINE_NFS_FSCACHE_PAGE_EVENT(nfs_fscache_write_page); 1334 DEFINE_NFS_FSCACHE_PAGE_EVENT_DONE(nfs_fscache_write_page_exit); 1335 1336 TRACE_EVENT(nfs_pgio_error, 1337 TP_PROTO( 1338 const struct nfs_pgio_header *hdr, 1339 int error, 1340 loff_t pos 1341 ), 1342 1343 TP_ARGS(hdr, error, pos), 1344 1345 TP_STRUCT__entry( 1346 __field(dev_t, dev) 1347 __field(u32, fhandle) 1348 __field(u64, fileid) 1349 __field(loff_t, offset) 1350 __field(u32, arg_count) 1351 __field(u32, res_count) 1352 __field(loff_t, pos) 1353 __field(int, error) 1354 ), 1355 1356 TP_fast_assign( 1357 const struct inode *inode = hdr->inode; 1358 const struct nfs_inode *nfsi = NFS_I(inode); 1359 const struct nfs_fh *fh = hdr->args.fh ? 1360 hdr->args.fh : &nfsi->fh; 1361 1362 __entry->error = error; 1363 __entry->offset = hdr->args.offset; 1364 __entry->arg_count = hdr->args.count; 1365 __entry->res_count = hdr->res.count; 1366 __entry->dev = inode->i_sb->s_dev; 1367 __entry->fileid = nfsi->fileid; 1368 __entry->fhandle = nfs_fhandle_hash(fh); 1369 ), 1370 1371 TP_printk("error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1372 "offset=%lld count=%u res=%u pos=%llu", __entry->error, 1373 MAJOR(__entry->dev), MINOR(__entry->dev), 1374 (unsigned long long)__entry->fileid, __entry->fhandle, 1375 (long long)__entry->offset, __entry->arg_count, __entry->res_count, 1376 __entry->pos 1377 ) 1378 ); 1379 1380 TRACE_EVENT(nfs_initiate_write, 1381 TP_PROTO( 1382 const struct nfs_pgio_header *hdr 1383 ), 1384 1385 TP_ARGS(hdr), 1386 1387 TP_STRUCT__entry( 1388 __field(dev_t, dev) 1389 __field(u32, fhandle) 1390 __field(u64, fileid) 1391 __field(loff_t, offset) 1392 __field(u32, count) 1393 __field(unsigned long, stable) 1394 ), 1395 1396 TP_fast_assign( 1397 const struct inode *inode = hdr->inode; 1398 const struct nfs_inode *nfsi = NFS_I(inode); 1399 const struct nfs_fh *fh = hdr->args.fh ? 1400 hdr->args.fh : &nfsi->fh; 1401 1402 __entry->offset = hdr->args.offset; 1403 __entry->count = hdr->args.count; 1404 __entry->stable = hdr->args.stable; 1405 __entry->dev = inode->i_sb->s_dev; 1406 __entry->fileid = nfsi->fileid; 1407 __entry->fhandle = nfs_fhandle_hash(fh); 1408 ), 1409 1410 TP_printk( 1411 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1412 "offset=%lld count=%u stable=%s", 1413 MAJOR(__entry->dev), MINOR(__entry->dev), 1414 (unsigned long long)__entry->fileid, 1415 __entry->fhandle, 1416 (long long)__entry->offset, __entry->count, 1417 show_nfs_stable_how(__entry->stable) 1418 ) 1419 ); 1420 1421 TRACE_EVENT(nfs_writeback_done, 1422 TP_PROTO( 1423 const struct rpc_task *task, 1424 const struct nfs_pgio_header *hdr 1425 ), 1426 1427 TP_ARGS(task, hdr), 1428 1429 TP_STRUCT__entry( 1430 __field(dev_t, dev) 1431 __field(u32, fhandle) 1432 __field(u64, fileid) 1433 __field(loff_t, offset) 1434 __field(u32, arg_count) 1435 __field(u32, res_count) 1436 __field(int, error) 1437 __field(unsigned long, stable) 1438 __array(char, verifier, NFS4_VERIFIER_SIZE) 1439 ), 1440 1441 TP_fast_assign( 1442 const struct inode *inode = hdr->inode; 1443 const struct nfs_inode *nfsi = NFS_I(inode); 1444 const struct nfs_fh *fh = hdr->args.fh ? 1445 hdr->args.fh : &nfsi->fh; 1446 const struct nfs_writeverf *verf = hdr->res.verf; 1447 1448 __entry->error = task->tk_status; 1449 __entry->offset = hdr->args.offset; 1450 __entry->arg_count = hdr->args.count; 1451 __entry->res_count = hdr->res.count; 1452 __entry->stable = verf->committed; 1453 memcpy(__entry->verifier, 1454 &verf->verifier, 1455 NFS4_VERIFIER_SIZE); 1456 __entry->dev = inode->i_sb->s_dev; 1457 __entry->fileid = nfsi->fileid; 1458 __entry->fhandle = nfs_fhandle_hash(fh); 1459 ), 1460 1461 TP_printk( 1462 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1463 "offset=%lld count=%u res=%u stable=%s " 1464 "verifier=%s", __entry->error, 1465 MAJOR(__entry->dev), MINOR(__entry->dev), 1466 (unsigned long long)__entry->fileid, 1467 __entry->fhandle, 1468 (long long)__entry->offset, __entry->arg_count, 1469 __entry->res_count, 1470 show_nfs_stable_how(__entry->stable), 1471 show_nfs4_verifier(__entry->verifier) 1472 ) 1473 ); 1474 1475 DECLARE_EVENT_CLASS(nfs_page_error_class, 1476 TP_PROTO( 1477 const struct inode *inode, 1478 const struct nfs_page *req, 1479 int error 1480 ), 1481 1482 TP_ARGS(inode, req, error), 1483 1484 TP_STRUCT__entry( 1485 __field(dev_t, dev) 1486 __field(u32, fhandle) 1487 __field(u64, fileid) 1488 __field(loff_t, offset) 1489 __field(unsigned int, count) 1490 __field(int, error) 1491 ), 1492 1493 TP_fast_assign( 1494 const struct nfs_inode *nfsi = NFS_I(inode); 1495 __entry->dev = inode->i_sb->s_dev; 1496 __entry->fileid = nfsi->fileid; 1497 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1498 __entry->offset = req_offset(req); 1499 __entry->count = req->wb_bytes; 1500 __entry->error = error; 1501 ), 1502 1503 TP_printk( 1504 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1505 "offset=%lld count=%u", __entry->error, 1506 MAJOR(__entry->dev), MINOR(__entry->dev), 1507 (unsigned long long)__entry->fileid, 1508 __entry->fhandle, __entry->offset, 1509 __entry->count 1510 ) 1511 ); 1512 1513 #define DEFINE_NFS_PAGEERR_EVENT(name) \ 1514 DEFINE_EVENT(nfs_page_error_class, name, \ 1515 TP_PROTO( \ 1516 const struct inode *inode, \ 1517 const struct nfs_page *req, \ 1518 int error \ 1519 ), \ 1520 TP_ARGS(inode, req, error)) 1521 1522 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); 1523 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); 1524 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); 1525 1526 TRACE_EVENT(nfs_initiate_commit, 1527 TP_PROTO( 1528 const struct nfs_commit_data *data 1529 ), 1530 1531 TP_ARGS(data), 1532 1533 TP_STRUCT__entry( 1534 __field(dev_t, dev) 1535 __field(u32, fhandle) 1536 __field(u64, fileid) 1537 __field(loff_t, offset) 1538 __field(u32, count) 1539 ), 1540 1541 TP_fast_assign( 1542 const struct inode *inode = data->inode; 1543 const struct nfs_inode *nfsi = NFS_I(inode); 1544 const struct nfs_fh *fh = data->args.fh ? 1545 data->args.fh : &nfsi->fh; 1546 1547 __entry->offset = data->args.offset; 1548 __entry->count = data->args.count; 1549 __entry->dev = inode->i_sb->s_dev; 1550 __entry->fileid = nfsi->fileid; 1551 __entry->fhandle = nfs_fhandle_hash(fh); 1552 ), 1553 1554 TP_printk( 1555 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1556 "offset=%lld count=%u", 1557 MAJOR(__entry->dev), MINOR(__entry->dev), 1558 (unsigned long long)__entry->fileid, 1559 __entry->fhandle, 1560 (long long)__entry->offset, __entry->count 1561 ) 1562 ); 1563 1564 TRACE_EVENT(nfs_commit_done, 1565 TP_PROTO( 1566 const struct rpc_task *task, 1567 const struct nfs_commit_data *data 1568 ), 1569 1570 TP_ARGS(task, data), 1571 1572 TP_STRUCT__entry( 1573 __field(dev_t, dev) 1574 __field(u32, fhandle) 1575 __field(u64, fileid) 1576 __field(loff_t, offset) 1577 __field(int, error) 1578 __field(unsigned long, stable) 1579 __array(char, verifier, NFS4_VERIFIER_SIZE) 1580 ), 1581 1582 TP_fast_assign( 1583 const struct inode *inode = data->inode; 1584 const struct nfs_inode *nfsi = NFS_I(inode); 1585 const struct nfs_fh *fh = data->args.fh ? 1586 data->args.fh : &nfsi->fh; 1587 const struct nfs_writeverf *verf = data->res.verf; 1588 1589 __entry->error = task->tk_status; 1590 __entry->offset = data->args.offset; 1591 __entry->stable = verf->committed; 1592 memcpy(__entry->verifier, 1593 &verf->verifier, 1594 NFS4_VERIFIER_SIZE); 1595 __entry->dev = inode->i_sb->s_dev; 1596 __entry->fileid = nfsi->fileid; 1597 __entry->fhandle = nfs_fhandle_hash(fh); 1598 ), 1599 1600 TP_printk( 1601 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1602 "offset=%lld stable=%s verifier=%s", __entry->error, 1603 MAJOR(__entry->dev), MINOR(__entry->dev), 1604 (unsigned long long)__entry->fileid, 1605 __entry->fhandle, 1606 (long long)__entry->offset, 1607 show_nfs_stable_how(__entry->stable), 1608 show_nfs4_verifier(__entry->verifier) 1609 ) 1610 ); 1611 1612 #define nfs_show_direct_req_flags(v) \ 1613 __print_flags(v, "|", \ 1614 { NFS_ODIRECT_DO_COMMIT, "DO_COMMIT" }, \ 1615 { NFS_ODIRECT_RESCHED_WRITES, "RESCHED_WRITES" }, \ 1616 { NFS_ODIRECT_SHOULD_DIRTY, "SHOULD DIRTY" }, \ 1617 { NFS_ODIRECT_DONE, "DONE" } ) 1618 1619 DECLARE_EVENT_CLASS(nfs_direct_req_class, 1620 TP_PROTO( 1621 const struct nfs_direct_req *dreq 1622 ), 1623 1624 TP_ARGS(dreq), 1625 1626 TP_STRUCT__entry( 1627 __field(dev_t, dev) 1628 __field(u64, fileid) 1629 __field(u32, fhandle) 1630 __field(loff_t, offset) 1631 __field(ssize_t, count) 1632 __field(ssize_t, bytes_left) 1633 __field(ssize_t, error) 1634 __field(int, flags) 1635 ), 1636 1637 TP_fast_assign( 1638 const struct inode *inode = dreq->inode; 1639 const struct nfs_inode *nfsi = NFS_I(inode); 1640 const struct nfs_fh *fh = &nfsi->fh; 1641 1642 __entry->dev = inode->i_sb->s_dev; 1643 __entry->fileid = nfsi->fileid; 1644 __entry->fhandle = nfs_fhandle_hash(fh); 1645 __entry->offset = dreq->io_start; 1646 __entry->count = dreq->count; 1647 __entry->bytes_left = dreq->bytes_left; 1648 __entry->error = dreq->error; 1649 __entry->flags = dreq->flags; 1650 ), 1651 1652 TP_printk( 1653 "error=%zd fileid=%02x:%02x:%llu fhandle=0x%08x " 1654 "offset=%lld count=%zd bytes_left=%zd flags=%s", 1655 __entry->error, MAJOR(__entry->dev), 1656 MINOR(__entry->dev), 1657 (unsigned long long)__entry->fileid, 1658 __entry->fhandle, __entry->offset, 1659 __entry->count, __entry->bytes_left, 1660 nfs_show_direct_req_flags(__entry->flags) 1661 ) 1662 ); 1663 1664 #define DEFINE_NFS_DIRECT_REQ_EVENT(name) \ 1665 DEFINE_EVENT(nfs_direct_req_class, name, \ 1666 TP_PROTO( \ 1667 const struct nfs_direct_req *dreq \ 1668 ), \ 1669 TP_ARGS(dreq)) 1670 1671 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_commit_complete); 1672 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_resched_write); 1673 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_complete); 1674 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_completion); 1675 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_schedule_iovec); 1676 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_reschedule_io); 1677 1678 TRACE_EVENT(nfs_fh_to_dentry, 1679 TP_PROTO( 1680 const struct super_block *sb, 1681 const struct nfs_fh *fh, 1682 u64 fileid, 1683 int error 1684 ), 1685 1686 TP_ARGS(sb, fh, fileid, error), 1687 1688 TP_STRUCT__entry( 1689 __field(int, error) 1690 __field(dev_t, dev) 1691 __field(u32, fhandle) 1692 __field(u64, fileid) 1693 ), 1694 1695 TP_fast_assign( 1696 __entry->error = error; 1697 __entry->dev = sb->s_dev; 1698 __entry->fileid = fileid; 1699 __entry->fhandle = nfs_fhandle_hash(fh); 1700 ), 1701 1702 TP_printk( 1703 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ", 1704 __entry->error, 1705 MAJOR(__entry->dev), MINOR(__entry->dev), 1706 (unsigned long long)__entry->fileid, 1707 __entry->fhandle 1708 ) 1709 ); 1710 1711 TRACE_EVENT(nfs_mount_assign, 1712 TP_PROTO( 1713 const char *option, 1714 const char *value 1715 ), 1716 1717 TP_ARGS(option, value), 1718 1719 TP_STRUCT__entry( 1720 __string(option, option) 1721 __string(value, value) 1722 ), 1723 1724 TP_fast_assign( 1725 __assign_str(option, option); 1726 __assign_str(value, value); 1727 ), 1728 1729 TP_printk("option %s=%s", 1730 __get_str(option), __get_str(value) 1731 ) 1732 ); 1733 1734 TRACE_EVENT(nfs_mount_option, 1735 TP_PROTO( 1736 const struct fs_parameter *param 1737 ), 1738 1739 TP_ARGS(param), 1740 1741 TP_STRUCT__entry( 1742 __string(option, param->key) 1743 ), 1744 1745 TP_fast_assign( 1746 __assign_str(option, param->key); 1747 ), 1748 1749 TP_printk("option %s", __get_str(option)) 1750 ); 1751 1752 TRACE_EVENT(nfs_mount_path, 1753 TP_PROTO( 1754 const char *path 1755 ), 1756 1757 TP_ARGS(path), 1758 1759 TP_STRUCT__entry( 1760 __string(path, path) 1761 ), 1762 1763 TP_fast_assign( 1764 __assign_str(path, path); 1765 ), 1766 1767 TP_printk("path='%s'", __get_str(path)) 1768 ); 1769 1770 DECLARE_EVENT_CLASS(nfs_xdr_event, 1771 TP_PROTO( 1772 const struct xdr_stream *xdr, 1773 int error 1774 ), 1775 1776 TP_ARGS(xdr, error), 1777 1778 TP_STRUCT__entry( 1779 __field(unsigned int, task_id) 1780 __field(unsigned int, client_id) 1781 __field(u32, xid) 1782 __field(int, version) 1783 __field(unsigned long, error) 1784 __string(program, 1785 xdr->rqst->rq_task->tk_client->cl_program->name) 1786 __string(procedure, 1787 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 1788 ), 1789 1790 TP_fast_assign( 1791 const struct rpc_rqst *rqstp = xdr->rqst; 1792 const struct rpc_task *task = rqstp->rq_task; 1793 1794 __entry->task_id = task->tk_pid; 1795 __entry->client_id = task->tk_client->cl_clid; 1796 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1797 __entry->version = task->tk_client->cl_vers; 1798 __entry->error = error; 1799 __assign_str(program, 1800 task->tk_client->cl_program->name); 1801 __assign_str(procedure, task->tk_msg.rpc_proc->p_name); 1802 ), 1803 1804 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1805 " xid=0x%08x %sv%d %s error=%ld (%s)", 1806 __entry->task_id, __entry->client_id, __entry->xid, 1807 __get_str(program), __entry->version, 1808 __get_str(procedure), -__entry->error, 1809 show_nfs_status(__entry->error) 1810 ) 1811 ); 1812 #define DEFINE_NFS_XDR_EVENT(name) \ 1813 DEFINE_EVENT(nfs_xdr_event, name, \ 1814 TP_PROTO( \ 1815 const struct xdr_stream *xdr, \ 1816 int error \ 1817 ), \ 1818 TP_ARGS(xdr, error)) 1819 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); 1820 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); 1821 1822 #endif /* _TRACE_NFS_H */ 1823 1824 #undef TRACE_INCLUDE_PATH 1825 #define TRACE_INCLUDE_PATH . 1826 #define TRACE_INCLUDE_FILE nfstrace 1827 /* This part must be outside protection */ 1828 #include <trace/define_trace.h> 1829