fs/nfs/nfstrace.h

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