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