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