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