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