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_aop_readpage, 866 TP_PROTO( 867 const struct inode *inode, 868 struct page *page 869 ), 870 871 TP_ARGS(inode, page), 872 873 TP_STRUCT__entry( 874 __field(dev_t, dev) 875 __field(u32, fhandle) 876 __field(u64, fileid) 877 __field(u64, version) 878 __field(loff_t, offset) 879 ), 880 881 TP_fast_assign( 882 const struct nfs_inode *nfsi = NFS_I(inode); 883 884 __entry->dev = inode->i_sb->s_dev; 885 __entry->fileid = nfsi->fileid; 886 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 887 __entry->version = inode_peek_iversion_raw(inode); 888 __entry->offset = page_index(page) << PAGE_SHIFT; 889 ), 890 891 TP_printk( 892 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld", 893 MAJOR(__entry->dev), MINOR(__entry->dev), 894 (unsigned long long)__entry->fileid, 895 __entry->fhandle, __entry->version, 896 __entry->offset 897 ) 898 ); 899 900 TRACE_EVENT(nfs_aop_readpage_done, 901 TP_PROTO( 902 const struct inode *inode, 903 struct page *page, 904 int ret 905 ), 906 907 TP_ARGS(inode, page, ret), 908 909 TP_STRUCT__entry( 910 __field(dev_t, dev) 911 __field(u32, fhandle) 912 __field(int, ret) 913 __field(u64, fileid) 914 __field(u64, version) 915 __field(loff_t, offset) 916 ), 917 918 TP_fast_assign( 919 const struct nfs_inode *nfsi = NFS_I(inode); 920 921 __entry->dev = inode->i_sb->s_dev; 922 __entry->fileid = nfsi->fileid; 923 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 924 __entry->version = inode_peek_iversion_raw(inode); 925 __entry->offset = page_index(page) << PAGE_SHIFT; 926 __entry->ret = ret; 927 ), 928 929 TP_printk( 930 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu offset=%lld ret=%d", 931 MAJOR(__entry->dev), MINOR(__entry->dev), 932 (unsigned long long)__entry->fileid, 933 __entry->fhandle, __entry->version, 934 __entry->offset, __entry->ret 935 ) 936 ); 937 938 TRACE_EVENT(nfs_aop_readahead, 939 TP_PROTO( 940 const struct inode *inode, 941 unsigned int nr_pages 942 ), 943 944 TP_ARGS(inode, nr_pages), 945 946 TP_STRUCT__entry( 947 __field(dev_t, dev) 948 __field(u32, fhandle) 949 __field(u64, fileid) 950 __field(u64, version) 951 __field(unsigned int, nr_pages) 952 ), 953 954 TP_fast_assign( 955 const struct nfs_inode *nfsi = NFS_I(inode); 956 957 __entry->dev = inode->i_sb->s_dev; 958 __entry->fileid = nfsi->fileid; 959 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 960 __entry->version = inode_peek_iversion_raw(inode); 961 __entry->nr_pages = nr_pages; 962 ), 963 964 TP_printk( 965 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u", 966 MAJOR(__entry->dev), MINOR(__entry->dev), 967 (unsigned long long)__entry->fileid, 968 __entry->fhandle, __entry->version, 969 __entry->nr_pages 970 ) 971 ); 972 973 TRACE_EVENT(nfs_aop_readahead_done, 974 TP_PROTO( 975 const struct inode *inode, 976 unsigned int nr_pages, 977 int ret 978 ), 979 980 TP_ARGS(inode, nr_pages, ret), 981 982 TP_STRUCT__entry( 983 __field(dev_t, dev) 984 __field(u32, fhandle) 985 __field(int, ret) 986 __field(u64, fileid) 987 __field(u64, version) 988 __field(unsigned int, nr_pages) 989 ), 990 991 TP_fast_assign( 992 const struct nfs_inode *nfsi = NFS_I(inode); 993 994 __entry->dev = inode->i_sb->s_dev; 995 __entry->fileid = nfsi->fileid; 996 __entry->fhandle = nfs_fhandle_hash(&nfsi->fh); 997 __entry->version = inode_peek_iversion_raw(inode); 998 __entry->nr_pages = nr_pages; 999 __entry->ret = ret; 1000 ), 1001 1002 TP_printk( 1003 "fileid=%02x:%02x:%llu fhandle=0x%08x version=%llu nr_pages=%u ret=%d", 1004 MAJOR(__entry->dev), MINOR(__entry->dev), 1005 (unsigned long long)__entry->fileid, 1006 __entry->fhandle, __entry->version, 1007 __entry->nr_pages, __entry->ret 1008 ) 1009 ); 1010 1011 TRACE_EVENT(nfs_initiate_read, 1012 TP_PROTO( 1013 const struct nfs_pgio_header *hdr 1014 ), 1015 1016 TP_ARGS(hdr), 1017 1018 TP_STRUCT__entry( 1019 __field(dev_t, dev) 1020 __field(u32, fhandle) 1021 __field(u64, fileid) 1022 __field(loff_t, offset) 1023 __field(u32, count) 1024 ), 1025 1026 TP_fast_assign( 1027 const struct inode *inode = hdr->inode; 1028 const struct nfs_inode *nfsi = NFS_I(inode); 1029 const struct nfs_fh *fh = hdr->args.fh ? 1030 hdr->args.fh : &nfsi->fh; 1031 1032 __entry->offset = hdr->args.offset; 1033 __entry->count = hdr->args.count; 1034 __entry->dev = inode->i_sb->s_dev; 1035 __entry->fileid = nfsi->fileid; 1036 __entry->fhandle = nfs_fhandle_hash(fh); 1037 ), 1038 1039 TP_printk( 1040 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1041 "offset=%lld count=%u", 1042 MAJOR(__entry->dev), MINOR(__entry->dev), 1043 (unsigned long long)__entry->fileid, 1044 __entry->fhandle, 1045 (long long)__entry->offset, __entry->count 1046 ) 1047 ); 1048 1049 TRACE_EVENT(nfs_readpage_done, 1050 TP_PROTO( 1051 const struct rpc_task *task, 1052 const struct nfs_pgio_header *hdr 1053 ), 1054 1055 TP_ARGS(task, hdr), 1056 1057 TP_STRUCT__entry( 1058 __field(dev_t, dev) 1059 __field(u32, fhandle) 1060 __field(u64, fileid) 1061 __field(loff_t, offset) 1062 __field(u32, arg_count) 1063 __field(u32, res_count) 1064 __field(bool, eof) 1065 __field(int, status) 1066 ), 1067 1068 TP_fast_assign( 1069 const struct inode *inode = hdr->inode; 1070 const struct nfs_inode *nfsi = NFS_I(inode); 1071 const struct nfs_fh *fh = hdr->args.fh ? 1072 hdr->args.fh : &nfsi->fh; 1073 1074 __entry->status = task->tk_status; 1075 __entry->offset = hdr->args.offset; 1076 __entry->arg_count = hdr->args.count; 1077 __entry->res_count = hdr->res.count; 1078 __entry->eof = hdr->res.eof; 1079 __entry->dev = inode->i_sb->s_dev; 1080 __entry->fileid = nfsi->fileid; 1081 __entry->fhandle = nfs_fhandle_hash(fh); 1082 ), 1083 1084 TP_printk( 1085 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1086 "offset=%lld count=%u res=%u status=%d%s", 1087 MAJOR(__entry->dev), MINOR(__entry->dev), 1088 (unsigned long long)__entry->fileid, 1089 __entry->fhandle, 1090 (long long)__entry->offset, __entry->arg_count, 1091 __entry->res_count, __entry->status, 1092 __entry->eof ? " eof" : "" 1093 ) 1094 ); 1095 1096 TRACE_EVENT(nfs_readpage_short, 1097 TP_PROTO( 1098 const struct rpc_task *task, 1099 const struct nfs_pgio_header *hdr 1100 ), 1101 1102 TP_ARGS(task, hdr), 1103 1104 TP_STRUCT__entry( 1105 __field(dev_t, dev) 1106 __field(u32, fhandle) 1107 __field(u64, fileid) 1108 __field(loff_t, offset) 1109 __field(u32, arg_count) 1110 __field(u32, res_count) 1111 __field(bool, eof) 1112 __field(int, status) 1113 ), 1114 1115 TP_fast_assign( 1116 const struct inode *inode = hdr->inode; 1117 const struct nfs_inode *nfsi = NFS_I(inode); 1118 const struct nfs_fh *fh = hdr->args.fh ? 1119 hdr->args.fh : &nfsi->fh; 1120 1121 __entry->status = task->tk_status; 1122 __entry->offset = hdr->args.offset; 1123 __entry->arg_count = hdr->args.count; 1124 __entry->res_count = hdr->res.count; 1125 __entry->eof = hdr->res.eof; 1126 __entry->dev = inode->i_sb->s_dev; 1127 __entry->fileid = nfsi->fileid; 1128 __entry->fhandle = nfs_fhandle_hash(fh); 1129 ), 1130 1131 TP_printk( 1132 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1133 "offset=%lld count=%u res=%u status=%d%s", 1134 MAJOR(__entry->dev), MINOR(__entry->dev), 1135 (unsigned long long)__entry->fileid, 1136 __entry->fhandle, 1137 (long long)__entry->offset, __entry->arg_count, 1138 __entry->res_count, __entry->status, 1139 __entry->eof ? " eof" : "" 1140 ) 1141 ); 1142 1143 TRACE_EVENT(nfs_pgio_error, 1144 TP_PROTO( 1145 const struct nfs_pgio_header *hdr, 1146 int error, 1147 loff_t pos 1148 ), 1149 1150 TP_ARGS(hdr, error, pos), 1151 1152 TP_STRUCT__entry( 1153 __field(dev_t, dev) 1154 __field(u32, fhandle) 1155 __field(u64, fileid) 1156 __field(loff_t, offset) 1157 __field(u32, arg_count) 1158 __field(u32, res_count) 1159 __field(loff_t, pos) 1160 __field(int, status) 1161 ), 1162 1163 TP_fast_assign( 1164 const struct inode *inode = hdr->inode; 1165 const struct nfs_inode *nfsi = NFS_I(inode); 1166 const struct nfs_fh *fh = hdr->args.fh ? 1167 hdr->args.fh : &nfsi->fh; 1168 1169 __entry->status = error; 1170 __entry->offset = hdr->args.offset; 1171 __entry->arg_count = hdr->args.count; 1172 __entry->res_count = hdr->res.count; 1173 __entry->dev = inode->i_sb->s_dev; 1174 __entry->fileid = nfsi->fileid; 1175 __entry->fhandle = nfs_fhandle_hash(fh); 1176 ), 1177 1178 TP_printk("fileid=%02x:%02x:%llu fhandle=0x%08x " 1179 "offset=%lld count=%u res=%u pos=%llu status=%d", 1180 MAJOR(__entry->dev), MINOR(__entry->dev), 1181 (unsigned long long)__entry->fileid, __entry->fhandle, 1182 (long long)__entry->offset, __entry->arg_count, __entry->res_count, 1183 __entry->pos, __entry->status 1184 ) 1185 ); 1186 1187 TRACE_DEFINE_ENUM(NFS_UNSTABLE); 1188 TRACE_DEFINE_ENUM(NFS_DATA_SYNC); 1189 TRACE_DEFINE_ENUM(NFS_FILE_SYNC); 1190 1191 #define nfs_show_stable(stable) \ 1192 __print_symbolic(stable, \ 1193 { NFS_UNSTABLE, "UNSTABLE" }, \ 1194 { NFS_DATA_SYNC, "DATA_SYNC" }, \ 1195 { NFS_FILE_SYNC, "FILE_SYNC" }) 1196 1197 TRACE_EVENT(nfs_initiate_write, 1198 TP_PROTO( 1199 const struct nfs_pgio_header *hdr 1200 ), 1201 1202 TP_ARGS(hdr), 1203 1204 TP_STRUCT__entry( 1205 __field(dev_t, dev) 1206 __field(u32, fhandle) 1207 __field(u64, fileid) 1208 __field(loff_t, offset) 1209 __field(u32, count) 1210 __field(enum nfs3_stable_how, stable) 1211 ), 1212 1213 TP_fast_assign( 1214 const struct inode *inode = hdr->inode; 1215 const struct nfs_inode *nfsi = NFS_I(inode); 1216 const struct nfs_fh *fh = hdr->args.fh ? 1217 hdr->args.fh : &nfsi->fh; 1218 1219 __entry->offset = hdr->args.offset; 1220 __entry->count = hdr->args.count; 1221 __entry->stable = hdr->args.stable; 1222 __entry->dev = inode->i_sb->s_dev; 1223 __entry->fileid = nfsi->fileid; 1224 __entry->fhandle = nfs_fhandle_hash(fh); 1225 ), 1226 1227 TP_printk( 1228 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1229 "offset=%lld count=%u stable=%s", 1230 MAJOR(__entry->dev), MINOR(__entry->dev), 1231 (unsigned long long)__entry->fileid, 1232 __entry->fhandle, 1233 (long long)__entry->offset, __entry->count, 1234 nfs_show_stable(__entry->stable) 1235 ) 1236 ); 1237 1238 TRACE_EVENT(nfs_writeback_done, 1239 TP_PROTO( 1240 const struct rpc_task *task, 1241 const struct nfs_pgio_header *hdr 1242 ), 1243 1244 TP_ARGS(task, hdr), 1245 1246 TP_STRUCT__entry( 1247 __field(dev_t, dev) 1248 __field(u32, fhandle) 1249 __field(u64, fileid) 1250 __field(loff_t, offset) 1251 __field(u32, arg_count) 1252 __field(u32, res_count) 1253 __field(int, status) 1254 __field(enum nfs3_stable_how, stable) 1255 __array(char, verifier, NFS4_VERIFIER_SIZE) 1256 ), 1257 1258 TP_fast_assign( 1259 const struct inode *inode = hdr->inode; 1260 const struct nfs_inode *nfsi = NFS_I(inode); 1261 const struct nfs_fh *fh = hdr->args.fh ? 1262 hdr->args.fh : &nfsi->fh; 1263 const struct nfs_writeverf *verf = hdr->res.verf; 1264 1265 __entry->status = task->tk_status; 1266 __entry->offset = hdr->args.offset; 1267 __entry->arg_count = hdr->args.count; 1268 __entry->res_count = hdr->res.count; 1269 __entry->stable = verf->committed; 1270 memcpy(__entry->verifier, 1271 &verf->verifier, 1272 NFS4_VERIFIER_SIZE); 1273 __entry->dev = inode->i_sb->s_dev; 1274 __entry->fileid = nfsi->fileid; 1275 __entry->fhandle = nfs_fhandle_hash(fh); 1276 ), 1277 1278 TP_printk( 1279 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1280 "offset=%lld count=%u res=%u status=%d stable=%s " 1281 "verifier=%s", 1282 MAJOR(__entry->dev), MINOR(__entry->dev), 1283 (unsigned long long)__entry->fileid, 1284 __entry->fhandle, 1285 (long long)__entry->offset, __entry->arg_count, 1286 __entry->res_count, __entry->status, 1287 nfs_show_stable(__entry->stable), 1288 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 1289 ) 1290 ); 1291 1292 DECLARE_EVENT_CLASS(nfs_page_error_class, 1293 TP_PROTO( 1294 const struct nfs_page *req, 1295 int error 1296 ), 1297 1298 TP_ARGS(req, error), 1299 1300 TP_STRUCT__entry( 1301 __field(const void *, req) 1302 __field(pgoff_t, index) 1303 __field(unsigned int, offset) 1304 __field(unsigned int, pgbase) 1305 __field(unsigned int, bytes) 1306 __field(int, error) 1307 ), 1308 1309 TP_fast_assign( 1310 __entry->req = req; 1311 __entry->index = req->wb_index; 1312 __entry->offset = req->wb_offset; 1313 __entry->pgbase = req->wb_pgbase; 1314 __entry->bytes = req->wb_bytes; 1315 __entry->error = error; 1316 ), 1317 1318 TP_printk( 1319 "req=%p index=%lu offset=%u pgbase=%u bytes=%u error=%d", 1320 __entry->req, __entry->index, __entry->offset, 1321 __entry->pgbase, __entry->bytes, __entry->error 1322 ) 1323 ); 1324 1325 #define DEFINE_NFS_PAGEERR_EVENT(name) \ 1326 DEFINE_EVENT(nfs_page_error_class, name, \ 1327 TP_PROTO( \ 1328 const struct nfs_page *req, \ 1329 int error \ 1330 ), \ 1331 TP_ARGS(req, error)) 1332 1333 DEFINE_NFS_PAGEERR_EVENT(nfs_write_error); 1334 DEFINE_NFS_PAGEERR_EVENT(nfs_comp_error); 1335 DEFINE_NFS_PAGEERR_EVENT(nfs_commit_error); 1336 1337 TRACE_EVENT(nfs_initiate_commit, 1338 TP_PROTO( 1339 const struct nfs_commit_data *data 1340 ), 1341 1342 TP_ARGS(data), 1343 1344 TP_STRUCT__entry( 1345 __field(dev_t, dev) 1346 __field(u32, fhandle) 1347 __field(u64, fileid) 1348 __field(loff_t, offset) 1349 __field(u32, count) 1350 ), 1351 1352 TP_fast_assign( 1353 const struct inode *inode = data->inode; 1354 const struct nfs_inode *nfsi = NFS_I(inode); 1355 const struct nfs_fh *fh = data->args.fh ? 1356 data->args.fh : &nfsi->fh; 1357 1358 __entry->offset = data->args.offset; 1359 __entry->count = data->args.count; 1360 __entry->dev = inode->i_sb->s_dev; 1361 __entry->fileid = nfsi->fileid; 1362 __entry->fhandle = nfs_fhandle_hash(fh); 1363 ), 1364 1365 TP_printk( 1366 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1367 "offset=%lld count=%u", 1368 MAJOR(__entry->dev), MINOR(__entry->dev), 1369 (unsigned long long)__entry->fileid, 1370 __entry->fhandle, 1371 (long long)__entry->offset, __entry->count 1372 ) 1373 ); 1374 1375 TRACE_EVENT(nfs_commit_done, 1376 TP_PROTO( 1377 const struct rpc_task *task, 1378 const struct nfs_commit_data *data 1379 ), 1380 1381 TP_ARGS(task, data), 1382 1383 TP_STRUCT__entry( 1384 __field(dev_t, dev) 1385 __field(u32, fhandle) 1386 __field(u64, fileid) 1387 __field(loff_t, offset) 1388 __field(int, status) 1389 __field(enum nfs3_stable_how, stable) 1390 __array(char, verifier, NFS4_VERIFIER_SIZE) 1391 ), 1392 1393 TP_fast_assign( 1394 const struct inode *inode = data->inode; 1395 const struct nfs_inode *nfsi = NFS_I(inode); 1396 const struct nfs_fh *fh = data->args.fh ? 1397 data->args.fh : &nfsi->fh; 1398 const struct nfs_writeverf *verf = data->res.verf; 1399 1400 __entry->status = task->tk_status; 1401 __entry->offset = data->args.offset; 1402 __entry->stable = verf->committed; 1403 memcpy(__entry->verifier, 1404 &verf->verifier, 1405 NFS4_VERIFIER_SIZE); 1406 __entry->dev = inode->i_sb->s_dev; 1407 __entry->fileid = nfsi->fileid; 1408 __entry->fhandle = nfs_fhandle_hash(fh); 1409 ), 1410 1411 TP_printk( 1412 "fileid=%02x:%02x:%llu fhandle=0x%08x " 1413 "offset=%lld status=%d stable=%s verifier=%s", 1414 MAJOR(__entry->dev), MINOR(__entry->dev), 1415 (unsigned long long)__entry->fileid, 1416 __entry->fhandle, 1417 (long long)__entry->offset, __entry->status, 1418 nfs_show_stable(__entry->stable), 1419 __print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE) 1420 ) 1421 ); 1422 1423 TRACE_EVENT(nfs_fh_to_dentry, 1424 TP_PROTO( 1425 const struct super_block *sb, 1426 const struct nfs_fh *fh, 1427 u64 fileid, 1428 int error 1429 ), 1430 1431 TP_ARGS(sb, fh, fileid, error), 1432 1433 TP_STRUCT__entry( 1434 __field(int, error) 1435 __field(dev_t, dev) 1436 __field(u32, fhandle) 1437 __field(u64, fileid) 1438 ), 1439 1440 TP_fast_assign( 1441 __entry->error = error; 1442 __entry->dev = sb->s_dev; 1443 __entry->fileid = fileid; 1444 __entry->fhandle = nfs_fhandle_hash(fh); 1445 ), 1446 1447 TP_printk( 1448 "error=%d fileid=%02x:%02x:%llu fhandle=0x%08x ", 1449 __entry->error, 1450 MAJOR(__entry->dev), MINOR(__entry->dev), 1451 (unsigned long long)__entry->fileid, 1452 __entry->fhandle 1453 ) 1454 ); 1455 1456 TRACE_DEFINE_ENUM(NFS_OK); 1457 TRACE_DEFINE_ENUM(NFSERR_PERM); 1458 TRACE_DEFINE_ENUM(NFSERR_NOENT); 1459 TRACE_DEFINE_ENUM(NFSERR_IO); 1460 TRACE_DEFINE_ENUM(NFSERR_NXIO); 1461 TRACE_DEFINE_ENUM(ECHILD); 1462 TRACE_DEFINE_ENUM(NFSERR_EAGAIN); 1463 TRACE_DEFINE_ENUM(NFSERR_ACCES); 1464 TRACE_DEFINE_ENUM(NFSERR_EXIST); 1465 TRACE_DEFINE_ENUM(NFSERR_XDEV); 1466 TRACE_DEFINE_ENUM(NFSERR_NODEV); 1467 TRACE_DEFINE_ENUM(NFSERR_NOTDIR); 1468 TRACE_DEFINE_ENUM(NFSERR_ISDIR); 1469 TRACE_DEFINE_ENUM(NFSERR_INVAL); 1470 TRACE_DEFINE_ENUM(NFSERR_FBIG); 1471 TRACE_DEFINE_ENUM(NFSERR_NOSPC); 1472 TRACE_DEFINE_ENUM(NFSERR_ROFS); 1473 TRACE_DEFINE_ENUM(NFSERR_MLINK); 1474 TRACE_DEFINE_ENUM(NFSERR_OPNOTSUPP); 1475 TRACE_DEFINE_ENUM(NFSERR_NAMETOOLONG); 1476 TRACE_DEFINE_ENUM(NFSERR_NOTEMPTY); 1477 TRACE_DEFINE_ENUM(NFSERR_DQUOT); 1478 TRACE_DEFINE_ENUM(NFSERR_STALE); 1479 TRACE_DEFINE_ENUM(NFSERR_REMOTE); 1480 TRACE_DEFINE_ENUM(NFSERR_WFLUSH); 1481 TRACE_DEFINE_ENUM(NFSERR_BADHANDLE); 1482 TRACE_DEFINE_ENUM(NFSERR_NOT_SYNC); 1483 TRACE_DEFINE_ENUM(NFSERR_BAD_COOKIE); 1484 TRACE_DEFINE_ENUM(NFSERR_NOTSUPP); 1485 TRACE_DEFINE_ENUM(NFSERR_TOOSMALL); 1486 TRACE_DEFINE_ENUM(NFSERR_SERVERFAULT); 1487 TRACE_DEFINE_ENUM(NFSERR_BADTYPE); 1488 TRACE_DEFINE_ENUM(NFSERR_JUKEBOX); 1489 1490 #define nfs_show_status(x) \ 1491 __print_symbolic(x, \ 1492 { NFS_OK, "OK" }, \ 1493 { NFSERR_PERM, "PERM" }, \ 1494 { NFSERR_NOENT, "NOENT" }, \ 1495 { NFSERR_IO, "IO" }, \ 1496 { NFSERR_NXIO, "NXIO" }, \ 1497 { ECHILD, "CHILD" }, \ 1498 { NFSERR_EAGAIN, "AGAIN" }, \ 1499 { NFSERR_ACCES, "ACCES" }, \ 1500 { NFSERR_EXIST, "EXIST" }, \ 1501 { NFSERR_XDEV, "XDEV" }, \ 1502 { NFSERR_NODEV, "NODEV" }, \ 1503 { NFSERR_NOTDIR, "NOTDIR" }, \ 1504 { NFSERR_ISDIR, "ISDIR" }, \ 1505 { NFSERR_INVAL, "INVAL" }, \ 1506 { NFSERR_FBIG, "FBIG" }, \ 1507 { NFSERR_NOSPC, "NOSPC" }, \ 1508 { NFSERR_ROFS, "ROFS" }, \ 1509 { NFSERR_MLINK, "MLINK" }, \ 1510 { NFSERR_OPNOTSUPP, "OPNOTSUPP" }, \ 1511 { NFSERR_NAMETOOLONG, "NAMETOOLONG" }, \ 1512 { NFSERR_NOTEMPTY, "NOTEMPTY" }, \ 1513 { NFSERR_DQUOT, "DQUOT" }, \ 1514 { NFSERR_STALE, "STALE" }, \ 1515 { NFSERR_REMOTE, "REMOTE" }, \ 1516 { NFSERR_WFLUSH, "WFLUSH" }, \ 1517 { NFSERR_BADHANDLE, "BADHANDLE" }, \ 1518 { NFSERR_NOT_SYNC, "NOTSYNC" }, \ 1519 { NFSERR_BAD_COOKIE, "BADCOOKIE" }, \ 1520 { NFSERR_NOTSUPP, "NOTSUPP" }, \ 1521 { NFSERR_TOOSMALL, "TOOSMALL" }, \ 1522 { NFSERR_SERVERFAULT, "REMOTEIO" }, \ 1523 { NFSERR_BADTYPE, "BADTYPE" }, \ 1524 { NFSERR_JUKEBOX, "JUKEBOX" }) 1525 1526 DECLARE_EVENT_CLASS(nfs_xdr_event, 1527 TP_PROTO( 1528 const struct xdr_stream *xdr, 1529 int error 1530 ), 1531 1532 TP_ARGS(xdr, error), 1533 1534 TP_STRUCT__entry( 1535 __field(unsigned int, task_id) 1536 __field(unsigned int, client_id) 1537 __field(u32, xid) 1538 __field(int, version) 1539 __field(unsigned long, error) 1540 __string(program, 1541 xdr->rqst->rq_task->tk_client->cl_program->name) 1542 __string(procedure, 1543 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name) 1544 ), 1545 1546 TP_fast_assign( 1547 const struct rpc_rqst *rqstp = xdr->rqst; 1548 const struct rpc_task *task = rqstp->rq_task; 1549 1550 __entry->task_id = task->tk_pid; 1551 __entry->client_id = task->tk_client->cl_clid; 1552 __entry->xid = be32_to_cpu(rqstp->rq_xid); 1553 __entry->version = task->tk_client->cl_vers; 1554 __entry->error = error; 1555 __assign_str(program, 1556 task->tk_client->cl_program->name); 1557 __assign_str(procedure, task->tk_msg.rpc_proc->p_name); 1558 ), 1559 1560 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 1561 " xid=0x%08x %sv%d %s error=%ld (%s)", 1562 __entry->task_id, __entry->client_id, __entry->xid, 1563 __get_str(program), __entry->version, 1564 __get_str(procedure), -__entry->error, 1565 nfs_show_status(__entry->error) 1566 ) 1567 ); 1568 #define DEFINE_NFS_XDR_EVENT(name) \ 1569 DEFINE_EVENT(nfs_xdr_event, name, \ 1570 TP_PROTO( \ 1571 const struct xdr_stream *xdr, \ 1572 int error \ 1573 ), \ 1574 TP_ARGS(xdr, error)) 1575 DEFINE_NFS_XDR_EVENT(nfs_xdr_status); 1576 DEFINE_NFS_XDR_EVENT(nfs_xdr_bad_filehandle); 1577 1578 #endif /* _TRACE_NFS_H */ 1579 1580 #undef TRACE_INCLUDE_PATH 1581 #define TRACE_INCLUDE_PATH . 1582 #define TRACE_INCLUDE_FILE nfstrace 1583 /* This part must be outside protection */ 1584 #include <trace/define_trace.h> 1585