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