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