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 65 DECLARE_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 100 DECLARE_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)) 165 DEFINE_NFS_INODE_EVENT(nfs_set_inode_stale); 166 DEFINE_NFS_INODE_EVENT(nfs_refresh_inode_enter); 167 DEFINE_NFS_INODE_EVENT_DONE(nfs_refresh_inode_exit); 168 DEFINE_NFS_INODE_EVENT(nfs_revalidate_inode_enter); 169 DEFINE_NFS_INODE_EVENT_DONE(nfs_revalidate_inode_exit); 170 DEFINE_NFS_INODE_EVENT(nfs_invalidate_mapping_enter); 171 DEFINE_NFS_INODE_EVENT_DONE(nfs_invalidate_mapping_exit); 172 DEFINE_NFS_INODE_EVENT(nfs_getattr_enter); 173 DEFINE_NFS_INODE_EVENT_DONE(nfs_getattr_exit); 174 DEFINE_NFS_INODE_EVENT(nfs_setattr_enter); 175 DEFINE_NFS_INODE_EVENT_DONE(nfs_setattr_exit); 176 DEFINE_NFS_INODE_EVENT(nfs_writeback_inode_enter); 177 DEFINE_NFS_INODE_EVENT_DONE(nfs_writeback_inode_exit); 178 DEFINE_NFS_INODE_EVENT(nfs_fsync_enter); 179 DEFINE_NFS_INODE_EVENT_DONE(nfs_fsync_exit); 180 DEFINE_NFS_INODE_EVENT(nfs_access_enter); 181 DEFINE_NFS_INODE_EVENT_DONE(nfs_set_cache_invalid); 182 DEFINE_NFS_INODE_EVENT(nfs_readdir_force_readdirplus); 183 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_cache_fill_done); 184 DEFINE_NFS_INODE_EVENT_DONE(nfs_readdir_uncached_done); 185 186 TRACE_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 246 DECLARE_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 291 DEFINE_NFS_UPDATE_SIZE_EVENT(truncate); 292 DEFINE_NFS_UPDATE_SIZE_EVENT(truncate_folio); 293 DEFINE_NFS_UPDATE_SIZE_EVENT(wcc); 294 DEFINE_NFS_UPDATE_SIZE_EVENT(update); 295 DEFINE_NFS_UPDATE_SIZE_EVENT(grow); 296 297 DECLARE_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 345 DEFINE_NFS_INODE_RANGE_EVENT(nfs_readdir_invalidate_cache_range); 346 347 DECLARE_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 410 DEFINE_NFS_READDIR_EVENT(nfs_readdir_cache_fill); 411 DEFINE_NFS_READDIR_EVENT(nfs_readdir_uncached); 412 413 DECLARE_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 458 DECLARE_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 508 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_enter); 509 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_exit); 510 DEFINE_NFS_LOOKUP_EVENT(nfs_lookup_revalidate_enter); 511 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_lookup_revalidate_exit); 512 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup); 513 DEFINE_NFS_LOOKUP_EVENT(nfs_readdir_lookup_revalidate_failed); 514 DEFINE_NFS_LOOKUP_EVENT_DONE(nfs_readdir_lookup_revalidate); 515 516 TRACE_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 552 TRACE_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 593 TRACE_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 626 TRACE_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 663 DECLARE_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 699 DECLARE_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 740 DEFINE_NFS_DIRECTORY_EVENT(nfs_mknod_enter); 741 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mknod_exit); 742 DEFINE_NFS_DIRECTORY_EVENT(nfs_mkdir_enter); 743 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_mkdir_exit); 744 DEFINE_NFS_DIRECTORY_EVENT(nfs_rmdir_enter); 745 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_rmdir_exit); 746 DEFINE_NFS_DIRECTORY_EVENT(nfs_remove_enter); 747 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_remove_exit); 748 DEFINE_NFS_DIRECTORY_EVENT(nfs_unlink_enter); 749 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_unlink_exit); 750 DEFINE_NFS_DIRECTORY_EVENT(nfs_symlink_enter); 751 DEFINE_NFS_DIRECTORY_EVENT_DONE(nfs_symlink_exit); 752 753 TRACE_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 786 TRACE_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 823 DECLARE_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 869 DECLARE_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 922 DEFINE_NFS_RENAME_EVENT(nfs_rename_enter); 923 DEFINE_NFS_RENAME_EVENT_DONE(nfs_rename_exit); 924 925 DEFINE_NFS_RENAME_EVENT_DONE(nfs_async_rename_done); 926 927 TRACE_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 962 DECLARE_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 1010 DECLARE_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 1062 DEFINE_NFS_FOLIO_EVENT(nfs_aop_readpage); 1063 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_aop_readpage_done); 1064 1065 DEFINE_NFS_FOLIO_EVENT(nfs_writeback_folio); 1066 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_writeback_folio_done); 1067 1068 DEFINE_NFS_FOLIO_EVENT(nfs_invalidate_folio); 1069 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_launder_folio_done); 1070 1071 DEFINE_NFS_FOLIO_EVENT(nfs_try_to_update_request); 1072 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_try_to_update_request_done); 1073 1074 DEFINE_NFS_FOLIO_EVENT(nfs_update_folio); 1075 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_update_folio_done); 1076 1077 DEFINE_NFS_FOLIO_EVENT(nfs_write_begin); 1078 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_write_begin_done); 1079 1080 DEFINE_NFS_FOLIO_EVENT(nfs_write_end); 1081 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_write_end_done); 1082 1083 DEFINE_NFS_FOLIO_EVENT(nfs_writepages); 1084 DEFINE_NFS_FOLIO_EVENT_DONE(nfs_writepages_done); 1085 1086 DECLARE_EVENT_CLASS(nfs_kiocb_event, 1087 TP_PROTO( 1088 const struct kiocb *iocb, 1089 const struct iov_iter *iter 1090 ), 1091 1092 TP_ARGS(iocb, iter), 1093 1094 TP_STRUCT__entry( 1095 __field(dev_t, dev) 1096 __field(u32, fhandle) 1097 __field(u64, fileid) 1098 __field(u64, version) 1099 __field(loff_t, offset) 1100 __field(size_t, count) 1101 __field(int, flags) 1102 ), 1103 1104 TP_fast_assign( 1105 const struct inode *inode = file_inode(iocb->ki_filp); 1106 const struct nfs_inode *nfsi = NFS_I(inode); 1107 1108 __entry->dev = inode->i_sb->s_dev; 1109 __entry->fileid = nfsi->fileid; 1110 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1111 __entry->version = inode_peek_iversion_raw(inode); 1112 __entry->offset = iocb->ki_pos; 1113 __entry->count = iov_iter_count(iter); 1114 __entry->flags = iocb->ki_flags; 1115 ), 1116 1117 TP_printk( 1118 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld count=%zu ki_flags=%s", 1119 MAJOR(__entry->dev), MINOR(__entry->dev), 1120 (unsigned long long)__entry->fileid, 1121 __entry->fhandle, __entry->version, 1122 __entry->offset, __entry->count, 1123 __print_flags(__entry->flags, "|", TRACE_IOCB_STRINGS) 1124 ) 1125 ); 1126 1127 #define DEFINE_NFS_KIOCB_EVENT(name) \ 1128 DEFINE_EVENT(nfs_kiocb_event, name, \ 1129 TP_PROTO( \ 1130 const struct kiocb *iocb, \ 1131 const struct iov_iter *iter \ 1132 ), \ 1133 TP_ARGS(iocb, iter)) 1134 1135 DEFINE_NFS_KIOCB_EVENT(nfs_file_read); 1136 DEFINE_NFS_KIOCB_EVENT(nfs_file_write); 1137 1138 TRACE_EVENT(nfs_aop_readahead, 1139 TP_PROTO( 1140 const struct inode *inode, 1141 loff_t pos, 1142 unsigned int nr_pages 1143 ), 1144 1145 TP_ARGS(inode, pos, nr_pages), 1146 1147 TP_STRUCT__entry( 1148 __field(dev_t, dev) 1149 __field(u32, fhandle) 1150 __field(u64, fileid) 1151 __field(u64, version) 1152 __field(loff_t, offset) 1153 __field(unsigned int, nr_pages) 1154 ), 1155 1156 TP_fast_assign( 1157 const struct nfs_inode *nfsi = NFS_I(inode); 1158 1159 __entry->dev = inode->i_sb->s_dev; 1160 __entry->fileid = nfsi->fileid; 1161 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1162 __entry->version = inode_peek_iversion_raw(inode); 1163 __entry->offset = pos; 1164 __entry->nr_pages = nr_pages; 1165 ), 1166 1167 TP_printk( 1168 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld nr_pages=%u", 1169 MAJOR(__entry->dev), MINOR(__entry->dev), 1170 (unsigned long long)__entry->fileid, 1171 __entry->fhandle, __entry->version, 1172 __entry->offset, __entry->nr_pages 1173 ) 1174 ); 1175 1176 TRACE_EVENT(nfs_aop_readahead_done, 1177 TP_PROTO( 1178 const struct inode *inode, 1179 unsigned int nr_pages, 1180 int ret 1181 ), 1182 1183 TP_ARGS(inode, nr_pages, ret), 1184 1185 TP_STRUCT__entry( 1186 __field(dev_t, dev) 1187 __field(u32, fhandle) 1188 __field(int, ret) 1189 __field(u64, fileid) 1190 __field(u64, version) 1191 __field(loff_t, offset) 1192 __field(unsigned int, nr_pages) 1193 ), 1194 1195 TP_fast_assign( 1196 const struct nfs_inode *nfsi = NFS_I(inode); 1197 1198 __entry->dev = inode->i_sb->s_dev; 1199 __entry->fileid = nfsi->fileid; 1200 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1201 __entry->version = inode_peek_iversion_raw(inode); 1202 __entry->nr_pages = nr_pages; 1203 __entry->ret = ret; 1204 ), 1205 1206 TP_printk( 1207 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d", 1208 MAJOR(__entry->dev), MINOR(__entry->dev), 1209 (unsigned long long)__entry->fileid, 1210 __entry->fhandle, __entry->version, 1211 __entry->nr_pages, __entry->ret 1212 ) 1213 ); 1214 1215 TRACE_EVENT(nfs_initiate_read, 1216 TP_PROTO( 1217 const struct nfs_pgio_header *hdr 1218 ), 1219 1220 TP_ARGS(hdr), 1221 1222 TP_STRUCT__entry( 1223 __field(dev_t, dev) 1224 __field(u32, fhandle) 1225 __field(u64, fileid) 1226 __field(loff_t, offset) 1227 __field(u32, count) 1228 ), 1229 1230 TP_fast_assign( 1231 const struct inode *inode = hdr->inode; 1232 const struct nfs_inode *nfsi = NFS_I(inode); 1233 const struct nfs_fh *fh = hdr->args.fh ? 1234 hdr->args.fh : &nfsi->fh; 1235 1236 __entry->offset = hdr->args.offset; 1237 __entry->count = hdr->args.count; 1238 __entry->dev = inode->i_sb->s_dev; 1239 __entry->fileid = nfsi->fileid; 1240 __entry->fhandle = nfs_fhandle_hash(fh); 1241 ), 1242 1243 TP_printk( 1244 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1245 "offset=%lld count=%u", 1246 MAJOR(__entry->dev), MINOR(__entry->dev), 1247 (unsigned long long)__entry->fileid, 1248 __entry->fhandle, 1249 (long long)__entry->offset, __entry->count 1250 ) 1251 ); 1252 1253 TRACE_EVENT(nfs_readpage_done, 1254 TP_PROTO( 1255 const struct rpc_task *task, 1256 const struct nfs_pgio_header *hdr 1257 ), 1258 1259 TP_ARGS(task, hdr), 1260 1261 TP_STRUCT__entry( 1262 __field(dev_t, dev) 1263 __field(u32, fhandle) 1264 __field(u64, fileid) 1265 __field(loff_t, offset) 1266 __field(u32, arg_count) 1267 __field(u32, res_count) 1268 __field(bool, eof) 1269 __field(int, error) 1270 ), 1271 1272 TP_fast_assign( 1273 const struct inode *inode = hdr->inode; 1274 const struct nfs_inode *nfsi = NFS_I(inode); 1275 const struct nfs_fh *fh = hdr->args.fh ? 1276 hdr->args.fh : &nfsi->fh; 1277 1278 __entry->error = task->tk_status; 1279 __entry->offset = hdr->args.offset; 1280 __entry->arg_count = hdr->args.count; 1281 __entry->res_count = hdr->res.count; 1282 __entry->eof = hdr->res.eof; 1283 __entry->dev = inode->i_sb->s_dev; 1284 __entry->fileid = nfsi->fileid; 1285 __entry->fhandle = nfs_fhandle_hash(fh); 1286 ), 1287 1288 TP_printk( 1289 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1290 "offset=%lld count=%u res=%u%s", __entry->error, 1291 MAJOR(__entry->dev), MINOR(__entry->dev), 1292 (unsigned long long)__entry->fileid, 1293 __entry->fhandle, 1294 (long long)__entry->offset, __entry->arg_count, 1295 __entry->res_count, __entry->eof ? " eof" : "" 1296 ) 1297 ); 1298 1299 TRACE_EVENT(nfs_readpage_short, 1300 TP_PROTO( 1301 const struct rpc_task *task, 1302 const struct nfs_pgio_header *hdr 1303 ), 1304 1305 TP_ARGS(task, hdr), 1306 1307 TP_STRUCT__entry( 1308 __field(dev_t, dev) 1309 __field(u32, fhandle) 1310 __field(u64, fileid) 1311 __field(loff_t, offset) 1312 __field(u32, arg_count) 1313 __field(u32, res_count) 1314 __field(bool, eof) 1315 __field(int, error) 1316 ), 1317 1318 TP_fast_assign( 1319 const struct inode *inode = hdr->inode; 1320 const struct nfs_inode *nfsi = NFS_I(inode); 1321 const struct nfs_fh *fh = hdr->args.fh ? 1322 hdr->args.fh : &nfsi->fh; 1323 1324 __entry->error = task->tk_status; 1325 __entry->offset = hdr->args.offset; 1326 __entry->arg_count = hdr->args.count; 1327 __entry->res_count = hdr->res.count; 1328 __entry->eof = hdr->res.eof; 1329 __entry->dev = inode->i_sb->s_dev; 1330 __entry->fileid = nfsi->fileid; 1331 __entry->fhandle = nfs_fhandle_hash(fh); 1332 ), 1333 1334 TP_printk( 1335 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1336 "offset=%lld count=%u res=%u%s", __entry->error, 1337 MAJOR(__entry->dev), MINOR(__entry->dev), 1338 (unsigned long long)__entry->fileid, 1339 __entry->fhandle, 1340 (long long)__entry->offset, __entry->arg_count, 1341 __entry->res_count, __entry->eof ? " eof" : "" 1342 ) 1343 ); 1344 1345 1346 TRACE_EVENT(nfs_pgio_error, 1347 TP_PROTO( 1348 const struct nfs_pgio_header *hdr, 1349 int error, 1350 loff_t pos 1351 ), 1352 1353 TP_ARGS(hdr, error, pos), 1354 1355 TP_STRUCT__entry( 1356 __field(dev_t, dev) 1357 __field(u32, fhandle) 1358 __field(u64, fileid) 1359 __field(loff_t, offset) 1360 __field(u32, arg_count) 1361 __field(u32, res_count) 1362 __field(loff_t, pos) 1363 __field(int, error) 1364 ), 1365 1366 TP_fast_assign( 1367 const struct inode *inode = hdr->inode; 1368 const struct nfs_inode *nfsi = NFS_I(inode); 1369 const struct nfs_fh *fh = hdr->args.fh ? 1370 hdr->args.fh : &nfsi->fh; 1371 1372 __entry->error = error; 1373 __entry->offset = hdr->args.offset; 1374 __entry->arg_count = hdr->args.count; 1375 __entry->res_count = hdr->res.count; 1376 __entry->dev = inode->i_sb->s_dev; 1377 __entry->fileid = nfsi->fileid; 1378 __entry->fhandle = nfs_fhandle_hash(fh); 1379 ), 1380 1381 TP_printk("error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1382 "offset=%lld count=%u res=%u pos=%llu", __entry->error, 1383 MAJOR(__entry->dev), MINOR(__entry->dev), 1384 (unsigned long long)__entry->fileid, __entry->fhandle, 1385 (long long)__entry->offset, __entry->arg_count, __entry->res_count, 1386 __entry->pos 1387 ) 1388 ); 1389 1390 TRACE_EVENT(nfs_initiate_write, 1391 TP_PROTO( 1392 const struct nfs_pgio_header *hdr 1393 ), 1394 1395 TP_ARGS(hdr), 1396 1397 TP_STRUCT__entry( 1398 __field(dev_t, dev) 1399 __field(u32, fhandle) 1400 __field(u64, fileid) 1401 __field(loff_t, offset) 1402 __field(u32, count) 1403 __field(unsigned long, stable) 1404 ), 1405 1406 TP_fast_assign( 1407 const struct inode *inode = hdr->inode; 1408 const struct nfs_inode *nfsi = NFS_I(inode); 1409 const struct nfs_fh *fh = hdr->args.fh ? 1410 hdr->args.fh : &nfsi->fh; 1411 1412 __entry->offset = hdr->args.offset; 1413 __entry->count = hdr->args.count; 1414 __entry->stable = hdr->args.stable; 1415 __entry->dev = inode->i_sb->s_dev; 1416 __entry->fileid = nfsi->fileid; 1417 __entry->fhandle = nfs_fhandle_hash(fh); 1418 ), 1419 1420 TP_printk( 1421 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1422 "offset=%lld count=%u stable=%s", 1423 MAJOR(__entry->dev), MINOR(__entry->dev), 1424 (unsigned long long)__entry->fileid, 1425 __entry->fhandle, 1426 (long long)__entry->offset, __entry->count, 1427 show_nfs_stable_how(__entry->stable) 1428 ) 1429 ); 1430 1431 TRACE_EVENT(nfs_writeback_done, 1432 TP_PROTO( 1433 const struct rpc_task *task, 1434 const struct nfs_pgio_header *hdr 1435 ), 1436 1437 TP_ARGS(task, hdr), 1438 1439 TP_STRUCT__entry( 1440 __field(dev_t, dev) 1441 __field(u32, fhandle) 1442 __field(u64, fileid) 1443 __field(loff_t, offset) 1444 __field(u32, arg_count) 1445 __field(u32, res_count) 1446 __field(int, error) 1447 __field(unsigned long, stable) 1448 __array(char, verifier, NFS4_VERIFIER_SIZE) 1449 ), 1450 1451 TP_fast_assign( 1452 const struct inode *inode = hdr->inode; 1453 const struct nfs_inode *nfsi = NFS_I(inode); 1454 const struct nfs_fh *fh = hdr->args.fh ? 1455 hdr->args.fh : &nfsi->fh; 1456 const struct nfs_writeverf *verf = hdr->res.verf; 1457 1458 __entry->error = task->tk_status; 1459 __entry->offset = hdr->args.offset; 1460 __entry->arg_count = hdr->args.count; 1461 __entry->res_count = hdr->res.count; 1462 __entry->stable = verf->committed; 1463 memcpy(__entry->verifier, 1464 &verf->verifier, 1465 NFS4_VERIFIER_SIZE); 1466 __entry->dev = inode->i_sb->s_dev; 1467 __entry->fileid = nfsi->fileid; 1468 __entry->fhandle = nfs_fhandle_hash(fh); 1469 ), 1470 1471 TP_printk( 1472 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1473 "offset=%lld count=%u res=%u stable=%s " 1474 "verifier=%s", __entry->error, 1475 MAJOR(__entry->dev), MINOR(__entry->dev), 1476 (unsigned long long)__entry->fileid, 1477 __entry->fhandle, 1478 (long long)__entry->offset, __entry->arg_count, 1479 __entry->res_count, 1480 show_nfs_stable_how(__entry->stable), 1481 show_nfs4_verifier(__entry->verifier) 1482 ) 1483 ); 1484 1485 DECLARE_EVENT_CLASS(nfs_page_class, 1486 TP_PROTO( 1487 const struct nfs_page *req 1488 ), 1489 1490 TP_ARGS(req), 1491 1492 TP_STRUCT__entry( 1493 __field(dev_t, dev) 1494 __field(u32, fhandle) 1495 __field(u64, fileid) 1496 __field(const struct nfs_page *__private, req) 1497 __field(loff_t, offset) 1498 __field(unsigned int, count) 1499 __field(unsigned long, flags) 1500 ), 1501 1502 TP_fast_assign( 1503 const struct inode *inode = folio_inode(req->wb_folio); 1504 const struct nfs_inode *nfsi = NFS_I(inode); 1505 1506 __entry->dev = inode->i_sb->s_dev; 1507 __entry->fileid = nfsi->fileid; 1508 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1509 __entry->req = req; 1510 __entry->offset = req_offset(req); 1511 __entry->count = req->wb_bytes; 1512 __entry->flags = req->wb_flags; 1513 ), 1514 1515 TP_printk( 1516 "fileid=%02x:%02x:%llu fhandle=0x%08x req=%p offset=%lld count=%u flags=%s", 1517 MAJOR(__entry->dev), MINOR(__entry->dev), 1518 (unsigned long long)__entry->fileid, __entry->fhandle, 1519 __entry->req, __entry->offset, __entry->count, 1520 nfs_show_wb_flags(__entry->flags) 1521 ) 1522 ); 1523 1524 #define DEFINE_NFS_PAGE_EVENT(name) \ 1525 DEFINE_EVENT(nfs_page_class, name, \ 1526 TP_PROTO( \ 1527 const struct nfs_page *req \ 1528 ), \ 1529 TP_ARGS(req)) 1530 1531 DEFINE_NFS_PAGE_EVENT(nfs_writepage_setup); 1532 DEFINE_NFS_PAGE_EVENT(nfs_do_writepage); 1533 1534 DECLARE_EVENT_CLASS(nfs_page_error_class, 1535 TP_PROTO( 1536 const struct inode *inode, 1537 const struct nfs_page *req, 1538 int error 1539 ), 1540 1541 TP_ARGS(inode, req, error), 1542 1543 TP_STRUCT__entry( 1544 __field(dev_t, dev) 1545 __field(u32, fhandle) 1546 __field(u64, fileid) 1547 __field(loff_t, offset) 1548 __field(unsigned int, count) 1549 __field(int, error) 1550 ), 1551 1552 TP_fast_assign( 1553 const struct nfs_inode *nfsi = NFS_I(inode); 1554 __entry->dev = inode->i_sb->s_dev; 1555 __entry->fileid = nfsi->fileid; 1556 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 1557 __entry->offset = req_offset(req); 1558 __entry->count = req->wb_bytes; 1559 __entry->error = error; 1560 ), 1561 1562 TP_printk( 1563 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1564 "offset=%lld count=%u", __entry->error, 1565 MAJOR(__entry->dev), MINOR(__entry->dev), 1566 (unsigned long long)__entry->fileid, 1567 __entry->fhandle, __entry->offset, 1568 __entry->count 1569 ) 1570 ); 1571 1572 #define DEFINE_NFS_PAGEERR_EVENT(name) \ 1573 DEFINE_EVENT(nfs_page_error_class, name, \ 1574 TP_PROTO( \ 1575 const struct inode *inode, \ 1576 const struct nfs_page *req, \ 1577 int error \ 1578 ), \ 1579 TP_ARGS(inode, req, error)) 1580 1581 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); 1582 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); 1583 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); 1584 1585 TRACE_EVENT(nfs_initiate_commit, 1586 TP_PROTO( 1587 const struct nfs_commit_data *data 1588 ), 1589 1590 TP_ARGS(data), 1591 1592 TP_STRUCT__entry( 1593 __field(dev_t, dev) 1594 __field(u32, fhandle) 1595 __field(u64, fileid) 1596 __field(loff_t, offset) 1597 __field(u32, count) 1598 ), 1599 1600 TP_fast_assign( 1601 const struct inode *inode = data->inode; 1602 const struct nfs_inode *nfsi = NFS_I(inode); 1603 const struct nfs_fh *fh = data->args.fh ? 1604 data->args.fh : &nfsi->fh; 1605 1606 __entry->offset = data->args.offset; 1607 __entry->count = data->args.count; 1608 __entry->dev = inode->i_sb->s_dev; 1609 __entry->fileid = nfsi->fileid; 1610 __entry->fhandle = nfs_fhandle_hash(fh); 1611 ), 1612 1613 TP_printk( 1614 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1615 "offset=%lld count=%u", 1616 MAJOR(__entry->dev), MINOR(__entry->dev), 1617 (unsigned long long)__entry->fileid, 1618 __entry->fhandle, 1619 (long long)__entry->offset, __entry->count 1620 ) 1621 ); 1622 1623 TRACE_EVENT(nfs_commit_done, 1624 TP_PROTO( 1625 const struct rpc_task *task, 1626 const struct nfs_commit_data *data 1627 ), 1628 1629 TP_ARGS(task, data), 1630 1631 TP_STRUCT__entry( 1632 __field(dev_t, dev) 1633 __field(u32, fhandle) 1634 __field(u64, fileid) 1635 __field(loff_t, offset) 1636 __field(int, error) 1637 __field(unsigned long, stable) 1638 __array(char, verifier, NFS4_VERIFIER_SIZE) 1639 ), 1640 1641 TP_fast_assign( 1642 const struct inode *inode = data->inode; 1643 const struct nfs_inode *nfsi = NFS_I(inode); 1644 const struct nfs_fh *fh = data->args.fh ? 1645 data->args.fh : &nfsi->fh; 1646 const struct nfs_writeverf *verf = data->res.verf; 1647 1648 __entry->error = task->tk_status; 1649 __entry->offset = data->args.offset; 1650 __entry->stable = verf->committed; 1651 memcpy(__entry->verifier, 1652 &verf->verifier, 1653 NFS4_VERIFIER_SIZE); 1654 __entry->dev = inode->i_sb->s_dev; 1655 __entry->fileid = nfsi->fileid; 1656 __entry->fhandle = nfs_fhandle_hash(fh); 1657 ), 1658 1659 TP_printk( 1660 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x " 1661 "offset=%lld stable=%s verifier=%s", __entry->error, 1662 MAJOR(__entry->dev), MINOR(__entry->dev), 1663 (unsigned long long)__entry->fileid, 1664 __entry->fhandle, 1665 (long long)__entry->offset, 1666 show_nfs_stable_how(__entry->stable), 1667 show_nfs4_verifier(__entry->verifier) 1668 ) 1669 ); 1670 1671 #define nfs_show_direct_req_flags(v) \ 1672 __print_flags(v, "|", \ 1673 { NFS_ODIRECT_DO_COMMIT, "DO_COMMIT" }, \ 1674 { NFS_ODIRECT_RESCHED_WRITES, "RESCHED_WRITES" }, \ 1675 { NFS_ODIRECT_SHOULD_DIRTY, "SHOULD DIRTY" }, \ 1676 { NFS_ODIRECT_DONE, "DONE" } ) 1677 1678 DECLARE_EVENT_CLASS(nfs_direct_req_class, 1679 TP_PROTO( 1680 const struct nfs_direct_req *dreq 1681 ), 1682 1683 TP_ARGS(dreq), 1684 1685 TP_STRUCT__entry( 1686 __field(dev_t, dev) 1687 __field(u64, fileid) 1688 __field(u32, fhandle) 1689 __field(loff_t, offset) 1690 __field(ssize_t, count) 1691 __field(ssize_t, error) 1692 __field(int, flags) 1693 ), 1694 1695 TP_fast_assign( 1696 const struct inode *inode = dreq->inode; 1697 const struct nfs_inode *nfsi = NFS_I(inode); 1698 const struct nfs_fh *fh = &nfsi->fh; 1699 1700 __entry->dev = inode->i_sb->s_dev; 1701 __entry->fileid = nfsi->fileid; 1702 __entry->fhandle = nfs_fhandle_hash(fh); 1703 __entry->offset = dreq->io_start; 1704 __entry->count = dreq->count; 1705 __entry->error = dreq->error; 1706 __entry->flags = dreq->flags; 1707 ), 1708 1709 TP_printk( 1710 "error=%zd fileid=%02x:%02x:%llu fhandle=0x%08x " 1711 "offset=%lld count=%zd flags=%s", 1712 __entry->error, MAJOR(__entry->dev), 1713 MINOR(__entry->dev), 1714 (unsigned long long)__entry->fileid, 1715 __entry->fhandle, __entry->offset, 1716 __entry->count, 1717 nfs_show_direct_req_flags(__entry->flags) 1718 ) 1719 ); 1720 1721 #define DEFINE_NFS_DIRECT_REQ_EVENT(name) \ 1722 DEFINE_EVENT(nfs_direct_req_class, name, \ 1723 TP_PROTO( \ 1724 const struct nfs_direct_req *dreq \ 1725 ), \ 1726 TP_ARGS(dreq)) 1727 1728 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_commit_complete); 1729 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_resched_write); 1730 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_complete); 1731 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_completion); 1732 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_schedule_iovec); 1733 DEFINE_NFS_DIRECT_REQ_EVENT(nfs_direct_write_reschedule_io); 1734 1735 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 1736 1737 DECLARE_EVENT_CLASS(nfs_local_dio_class, 1738 TP_PROTO( 1739 const struct inode *inode, 1740 loff_t offset, 1741 ssize_t count, 1742 const struct nfs_local_dio *local_dio 1743 ), 1744 TP_ARGS(inode, offset, count, local_dio), 1745 TP_STRUCT__entry( 1746 __field(dev_t, dev) 1747 __field(u64, fileid) 1748 __field(u32, fhandle) 1749 __field(loff_t, offset) 1750 __field(ssize_t, count) 1751 __field(u32, mem_align) 1752 __field(u32, offset_align) 1753 __field(loff_t, start) 1754 __field(ssize_t, start_len) 1755 __field(loff_t, middle) 1756 __field(ssize_t, middle_len) 1757 __field(loff_t, end) 1758 __field(ssize_t, end_len) 1759 ), 1760 TP_fast_assign( 1761 const struct nfs_inode *nfsi = NFS_I(inode); 1762 const struct nfs_fh *fh = &nfsi->fh; 1763 1764 __entry->dev = inode->i_sb->s_dev; 1765 __entry->fileid = nfsi->fileid; 1766 __entry->fhandle = nfs_fhandle_hash(fh); 1767 __entry->offset = offset; 1768 __entry->count = count; 1769 __entry->mem_align = local_dio->mem_align; 1770 __entry->offset_align = local_dio->offset_align; 1771 __entry->start = offset; 1772 __entry->start_len = local_dio->start_len; 1773 __entry->middle = local_dio->middle_offset; 1774 __entry->middle_len = local_dio->middle_len; 1775 __entry->end = local_dio->end_offset; 1776 __entry->end_len = local_dio->end_len; 1777 ), 1778 TP_printk("fileid=%02x:%02x:%llu fhandle=0x%08x " 1779 "offset=%lld count=%zd " 1780 "mem_align=%u offset_align=%u " 1781 "start=%llu+%zd middle=%llu+%zd end=%llu+%zd", 1782 MAJOR(__entry->dev), MINOR(__entry->dev), 1783 (unsigned long long)__entry->fileid, 1784 __entry->fhandle, __entry->offset, __entry->count, 1785 __entry->mem_align, __entry->offset_align, 1786 __entry->start, __entry->start_len, 1787 __entry->middle, __entry->middle_len, 1788 __entry->end, __entry->end_len) 1789 ) 1790 1791 #define DEFINE_NFS_LOCAL_DIO_EVENT(name) \ 1792 DEFINE_EVENT(nfs_local_dio_class, nfs_local_dio_##name, \ 1793 TP_PROTO(const struct inode *inode, \ 1794 loff_t offset, \ 1795 ssize_t count, \ 1796 const struct nfs_local_dio *local_dio),\ 1797 TP_ARGS(inode, offset, count, local_dio)) 1798 1799 DEFINE_NFS_LOCAL_DIO_EVENT(read); 1800 DEFINE_NFS_LOCAL_DIO_EVENT(write); 1801 DEFINE_NFS_LOCAL_DIO_EVENT(misaligned); 1802 1803 #endif /* CONFIG_NFS_LOCALIO */ 1804 1805 TRACE_EVENT(nfs_fh_to_dentry, 1806 TP_PROTO( 1807 const struct super_block *sb, 1808 const struct nfs_fh *fh, 1809 u64 fileid, 1810 int error 1811 ), 1812 1813 TP_ARGS(sb, fh, fileid, error), 1814 1815 TP_STRUCT__entry( 1816 __field(int, error) 1817 __field(dev_t, dev) 1818 __field(u32, fhandle) 1819 __field(u64, fileid) 1820 ), 1821 1822 TP_fast_assign( 1823 __entry->error = error; 1824 __entry->dev = sb->s_dev; 1825 __entry->fileid = fileid; 1826 __entry->fhandle = nfs_fhandle_hash(fh); 1827 ), 1828 1829 TP_printk( 1830 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ", 1831 __entry->error, 1832 MAJOR(__entry->dev), MINOR(__entry->dev), 1833 (unsigned long long)__entry->fileid, 1834 __entry->fhandle 1835 ) 1836 ); 1837 1838 TRACE_EVENT(nfs_mount_assign, 1839 TP_PROTO( 1840 const char *option, 1841 const char *value 1842 ), 1843 1844 TP_ARGS(option, value), 1845 1846 TP_STRUCT__entry( 1847 __string(option, option) 1848 __string(value, value) 1849 ), 1850 1851 TP_fast_assign( 1852 __assign_str(option); 1853 __assign_str(value); 1854 ), 1855 1856 TP_printk("option %s=%s", 1857 __get_str(option), __get_str(value) 1858 ) 1859 ); 1860 1861 TRACE_EVENT(nfs_mount_option, 1862 TP_PROTO( 1863 const struct fs_parameter *param 1864 ), 1865 1866 TP_ARGS(param), 1867 1868 TP_STRUCT__entry( 1869 __string(option, param->key) 1870 ), 1871 1872 TP_fast_assign( 1873 __assign_str(option); 1874 ), 1875 1876 TP_printk("option %s", __get_str(option)) 1877 ); 1878 1879 TRACE_EVENT(nfs_mount_path, 1880 TP_PROTO( 1881 const char *path 1882 ), 1883 1884 TP_ARGS(path), 1885 1886 TP_STRUCT__entry( 1887 __string(path, path) 1888 ), 1889 1890 TP_fast_assign( 1891 __assign_str(path); 1892 ), 1893 1894 TP_printk("path='%s'", __get_str(path)) 1895 ); 1896 1897 TRACE_EVENT(nfs_local_open_fh, 1898 TP_PROTO( 1899 const struct nfs_fh *fh, 1900 fmode_t fmode, 1901 int error 1902 ), 1903 1904 TP_ARGS(fh, fmode, error), 1905 1906 TP_STRUCT__entry( 1907 __field(int, error) 1908 __field(u32, fhandle) 1909 __field(unsigned int, fmode) 1910 ), 1911 1912 TP_fast_assign( 1913 __entry->error = error; 1914 __entry->fhandle = nfs_fhandle_hash(fh); 1915 __entry->fmode = (__force unsigned int)fmode; 1916 ), 1917 1918 TP_printk( 1919 "fhandle=0x%08x mode=%s result=%d", 1920 __entry->fhandle, 1921 show_fs_fmode_flags(__entry->fmode), 1922 __entry->error 1923 ) 1924 ); 1925 1926 DECLARE_EVENT_CLASS(nfs_xdr_event, 1927 TP_PROTO( 1928 const struct xdr_stream *xdr, 1929 int error 1930 ), 1931 1932 TP_ARGS(xdr, error), 1933 1934 TP_STRUCT__entry( 1935 __field(unsigned int, task_id) 1936 __field(unsigned int, client_id) 1937 __field(u32, xid) 1938 __field(int, version) 1939 __field(unsigned long, error) 1940 __string(program, 1941 xdr->rqst->rq_task->tk_client->cl_program->name) 1942 __string(procedure, 1943 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 1944 ), 1945 1946 TP_fast_assign( 1947 const struct rpc_rqst *rqstp = xdr->rqst; 1948 const struct rpc_task *task = rqstp->rq_task; 1949 1950 __entry->task_id = task->tk_pid; 1951 __entry->client_id = task->tk_client->cl_clid; 1952 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1953 __entry->version = task->tk_client->cl_vers; 1954 __entry->error = error; 1955 __assign_str(program); 1956 __assign_str(procedure); 1957 ), 1958 1959 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1960 " xid=0x%08x %sv%d %s error=%ld (%s)", 1961 __entry->task_id, __entry->client_id, __entry->xid, 1962 __get_str(program), __entry->version, 1963 __get_str(procedure), -__entry->error, 1964 show_nfs_status(__entry->error) 1965 ) 1966 ); 1967 #define DEFINE_NFS_XDR_EVENT(name) \ 1968 DEFINE_EVENT(nfs_xdr_event, name, \ 1969 TP_PROTO( \ 1970 const struct xdr_stream *xdr, \ 1971 int error \ 1972 ), \ 1973 TP_ARGS(xdr, error)) 1974 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); 1975 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); 1976 1977 #endif /* _TRACE_NFS_H */ 1978 1979 #undef TRACE_INCLUDE_PATH 1980 #define TRACE_INCLUDE_PATH . 1981 #define TRACE_INCLUDE_FILE nfstrace 1982 /* This part must be outside protection */ 1983 #include <trace/define_trace.h> 1984