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