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