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