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