include/trace/events/ext4.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM ext4
   3
   4 #if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_EXT4_H
   6
   7 #include <linux/writeback.h>
   8 #include <linux/tracepoint.h>
   9
  10 struct ext4_allocation_context;
  11 struct ext4_allocation_request;
  12 struct ext4_extent;
  13 struct ext4_prealloc_space;
  14 struct ext4_inode_info;
  15 struct mpage_da_data;
  16 struct ext4_map_blocks;
  17 struct extent_status;
  18
  19 /* shim until we merge in the xfs_collapse_range branch */
  20 #ifndef FALLOC_FL_COLLAPSE_RANGE
  21 #define FALLOC_FL_COLLAPSE_RANGE        0x08
  22 #endif
  23
  24 #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
  25
  26 #define show_mballoc_flags(flags) __print_flags(flags, "|",     \
  27         { EXT4_MB_HINT_MERGE,           "HINT_MERGE" },         \
  28         { EXT4_MB_HINT_RESERVED,        "HINT_RESV" },          \
  29         { EXT4_MB_HINT_METADATA,        "HINT_MDATA" },         \
  30         { EXT4_MB_HINT_FIRST,           "HINT_FIRST" },         \
  31         { EXT4_MB_HINT_BEST,            "HINT_BEST" },          \
  32         { EXT4_MB_HINT_DATA,            "HINT_DATA" },          \
  33         { EXT4_MB_HINT_NOPREALLOC,      "HINT_NOPREALLOC" },    \
  34         { EXT4_MB_HINT_GROUP_ALLOC,     "HINT_GRP_ALLOC" },     \
  35         { EXT4_MB_HINT_GOAL_ONLY,       "HINT_GOAL_ONLY" },     \
  36         { EXT4_MB_HINT_TRY_GOAL,        "HINT_TRY_GOAL" },      \
  37         { EXT4_MB_DELALLOC_RESERVED,    "DELALLOC_RESV" },      \
  38         { EXT4_MB_STREAM_ALLOC,         "STREAM_ALLOC" },       \
  39         { EXT4_MB_USE_ROOT_BLOCKS,      "USE_ROOT_BLKS" },      \
  40         { EXT4_MB_USE_RESERVED,         "USE_RESV" })
  41
  42 #define show_map_flags(flags) __print_flags(flags, "|",                 \
  43         { EXT4_GET_BLOCKS_CREATE,               "CREATE" },             \
  44         { EXT4_GET_BLOCKS_UNINIT_EXT,           "UNINIT" },             \
  45         { EXT4_GET_BLOCKS_DELALLOC_RESERVE,     "DELALLOC" },           \
  46         { EXT4_GET_BLOCKS_PRE_IO,               "PRE_IO" },             \
  47         { EXT4_GET_BLOCKS_CONVERT,              "CONVERT" },            \
  48         { EXT4_GET_BLOCKS_METADATA_NOFAIL,      "METADATA_NOFAIL" },    \
  49         { EXT4_GET_BLOCKS_NO_NORMALIZE,         "NO_NORMALIZE" },       \
  50         { EXT4_GET_BLOCKS_KEEP_SIZE,            "KEEP_SIZE" },          \
  51         { EXT4_GET_BLOCKS_NO_LOCK,              "NO_LOCK" },            \
  52         { EXT4_GET_BLOCKS_NO_PUT_HOLE,          "NO_PUT_HOLE" })
  53
  54 #define show_mflags(flags) __print_flags(flags, "",     \
  55         { EXT4_MAP_NEW,         "N" },                  \
  56         { EXT4_MAP_MAPPED,      "M" },                  \
  57         { EXT4_MAP_UNWRITTEN,   "U" },                  \
  58         { EXT4_MAP_BOUNDARY,    "B" },                  \
  59         { EXT4_MAP_UNINIT,      "u" },                  \
  60         { EXT4_MAP_FROM_CLUSTER, "C" })
  61
  62 #define show_free_flags(flags) __print_flags(flags, "|",        \
  63         { EXT4_FREE_BLOCKS_METADATA,            "METADATA" },   \
  64         { EXT4_FREE_BLOCKS_FORGET,              "FORGET" },     \
  65         { EXT4_FREE_BLOCKS_VALIDATED,           "VALIDATED" },  \
  66         { EXT4_FREE_BLOCKS_NO_QUOT_UPDATE,      "NO_QUOTA" },   \
  67         { EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER,"1ST_CLUSTER" },\
  68         { EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER, "LAST_CLUSTER" })
  69
  70 #define show_extent_status(status) __print_flags(status, "",    \
  71         { EXTENT_STATUS_WRITTEN,        "W" },                  \
  72         { EXTENT_STATUS_UNWRITTEN,      "U" },                  \
  73         { EXTENT_STATUS_DELAYED,        "D" },                  \
  74         { EXTENT_STATUS_HOLE,           "H" })
  75
  76 #define show_falloc_mode(mode) __print_flags(mode, "|",         \
  77         { FALLOC_FL_KEEP_SIZE,          "KEEP_SIZE"},           \
  78         { FALLOC_FL_PUNCH_HOLE,         "PUNCH_HOLE"},          \
  79         { FALLOC_FL_NO_HIDE_STALE,      "NO_HIDE_STALE"},       \
  80         { FALLOC_FL_COLLAPSE_RANGE,     "COLLAPSE_RANGE"})
  81
  82
  83 TRACE_EVENT(ext4_free_inode,
  84         TP_PROTO(struct inode *inode),
  85
  86         TP_ARGS(inode),
  87
  88         TP_STRUCT__entry(
  89                 __field(        dev_t,  dev                     )
  90                 __field(        ino_t,  ino                     )
  91                 __field(        uid_t,  uid                     )
  92                 __field(        gid_t,  gid                     )
  93                 __field(        __u64, blocks                   )
  94                 __field(        __u16, mode                     )
  95         ),
  96
  97         TP_fast_assign(
  98                 __entry->dev    = inode->i_sb->s_dev;
  99                 __entry->ino    = inode->i_ino;
 100                 __entry->uid    = i_uid_read(inode);
 101                 __entry->gid    = i_gid_read(inode);
 102                 __entry->blocks = inode->i_blocks;
 103                 __entry->mode   = inode->i_mode;
 104         ),
 105
 106         TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
 107                   MAJOR(__entry->dev), MINOR(__entry->dev),
 108                   (unsigned long) __entry->ino, __entry->mode,
 109                   __entry->uid, __entry->gid, __entry->blocks)
 110 );
 111
 112 TRACE_EVENT(ext4_request_inode,
 113         TP_PROTO(struct inode *dir, int mode),
 114
 115         TP_ARGS(dir, mode),
 116
 117         TP_STRUCT__entry(
 118                 __field(        dev_t,  dev                     )
 119                 __field(        ino_t,  dir                     )
 120                 __field(        __u16, mode                     )
 121         ),
 122
 123         TP_fast_assign(
 124                 __entry->dev    = dir->i_sb->s_dev;
 125                 __entry->dir    = dir->i_ino;
 126                 __entry->mode   = mode;
 127         ),
 128
 129         TP_printk("dev %d,%d dir %lu mode 0%o",
 130                   MAJOR(__entry->dev), MINOR(__entry->dev),
 131                   (unsigned long) __entry->dir, __entry->mode)
 132 );
 133
 134 TRACE_EVENT(ext4_allocate_inode,
 135         TP_PROTO(struct inode *inode, struct inode *dir, int mode),
 136
 137         TP_ARGS(inode, dir, mode),
 138
 139         TP_STRUCT__entry(
 140                 __field(        dev_t,  dev                     )
 141                 __field(        ino_t,  ino                     )
 142                 __field(        ino_t,  dir                     )
 143                 __field(        __u16,  mode                    )
 144         ),
 145
 146         TP_fast_assign(
 147                 __entry->dev    = inode->i_sb->s_dev;
 148                 __entry->ino    = inode->i_ino;
 149                 __entry->dir    = dir->i_ino;
 150                 __entry->mode   = mode;
 151         ),
 152
 153         TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
 154                   MAJOR(__entry->dev), MINOR(__entry->dev),
 155                   (unsigned long) __entry->ino,
 156                   (unsigned long) __entry->dir, __entry->mode)
 157 );
 158
 159 TRACE_EVENT(ext4_evict_inode,
 160         TP_PROTO(struct inode *inode),
 161
 162         TP_ARGS(inode),
 163
 164         TP_STRUCT__entry(
 165                 __field(        dev_t,  dev                     )
 166                 __field(        ino_t,  ino                     )
 167                 __field(        int,    nlink                   )
 168         ),
 169
 170         TP_fast_assign(
 171                 __entry->dev    = inode->i_sb->s_dev;
 172                 __entry->ino    = inode->i_ino;
 173                 __entry->nlink  = inode->i_nlink;
 174         ),
 175
 176         TP_printk("dev %d,%d ino %lu nlink %d",
 177                   MAJOR(__entry->dev), MINOR(__entry->dev),
 178                   (unsigned long) __entry->ino, __entry->nlink)
 179 );
 180
 181 TRACE_EVENT(ext4_drop_inode,
 182         TP_PROTO(struct inode *inode, int drop),
 183
 184         TP_ARGS(inode, drop),
 185
 186         TP_STRUCT__entry(
 187                 __field(        dev_t,  dev                     )
 188                 __field(        ino_t,  ino                     )
 189                 __field(        int,    drop                    )
 190         ),
 191
 192         TP_fast_assign(
 193                 __entry->dev    = inode->i_sb->s_dev;
 194                 __entry->ino    = inode->i_ino;
 195                 __entry->drop   = drop;
 196         ),
 197
 198         TP_printk("dev %d,%d ino %lu drop %d",
 199                   MAJOR(__entry->dev), MINOR(__entry->dev),
 200                   (unsigned long) __entry->ino, __entry->drop)
 201 );
 202
 203 TRACE_EVENT(ext4_mark_inode_dirty,
 204         TP_PROTO(struct inode *inode, unsigned long IP),
 205
 206         TP_ARGS(inode, IP),
 207
 208         TP_STRUCT__entry(
 209                 __field(        dev_t,  dev                     )
 210                 __field(        ino_t,  ino                     )
 211                 __field(unsigned long,  ip                      )
 212         ),
 213
 214         TP_fast_assign(
 215                 __entry->dev    = inode->i_sb->s_dev;
 216                 __entry->ino    = inode->i_ino;
 217                 __entry->ip     = IP;
 218         ),
 219
 220         TP_printk("dev %d,%d ino %lu caller %pF",
 221                   MAJOR(__entry->dev), MINOR(__entry->dev),
 222                   (unsigned long) __entry->ino, (void *)__entry->ip)
 223 );
 224
 225 TRACE_EVENT(ext4_begin_ordered_truncate,
 226         TP_PROTO(struct inode *inode, loff_t new_size),
 227
 228         TP_ARGS(inode, new_size),
 229
 230         TP_STRUCT__entry(
 231                 __field(        dev_t,  dev                     )
 232                 __field(        ino_t,  ino                     )
 233                 __field(        loff_t, new_size                )
 234         ),
 235
 236         TP_fast_assign(
 237                 __entry->dev            = inode->i_sb->s_dev;
 238                 __entry->ino            = inode->i_ino;
 239                 __entry->new_size       = new_size;
 240         ),
 241
 242         TP_printk("dev %d,%d ino %lu new_size %lld",
 243                   MAJOR(__entry->dev), MINOR(__entry->dev),
 244                   (unsigned long) __entry->ino,
 245                   __entry->new_size)
 246 );
 247
 248 DECLARE_EVENT_CLASS(ext4__write_begin,
 249
 250         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 251                  unsigned int flags),
 252
 253         TP_ARGS(inode, pos, len, flags),
 254
 255         TP_STRUCT__entry(
 256                 __field(        dev_t,  dev                     )
 257                 __field(        ino_t,  ino                     )
 258                 __field(        loff_t, pos                     )
 259                 __field(        unsigned int, len               )
 260                 __field(        unsigned int, flags             )
 261         ),
 262
 263         TP_fast_assign(
 264                 __entry->dev    = inode->i_sb->s_dev;
 265                 __entry->ino    = inode->i_ino;
 266                 __entry->pos    = pos;
 267                 __entry->len    = len;
 268                 __entry->flags  = flags;
 269         ),
 270
 271         TP_printk("dev %d,%d ino %lu pos %lld len %u flags %u",
 272                   MAJOR(__entry->dev), MINOR(__entry->dev),
 273                   (unsigned long) __entry->ino,
 274                   __entry->pos, __entry->len, __entry->flags)
 275 );
 276
 277 DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
 278
 279         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 280                  unsigned int flags),
 281
 282         TP_ARGS(inode, pos, len, flags)
 283 );
 284
 285 DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
 286
 287         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 288                  unsigned int flags),
 289
 290         TP_ARGS(inode, pos, len, flags)
 291 );
 292
 293 DECLARE_EVENT_CLASS(ext4__write_end,
 294         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 295                         unsigned int copied),
 296
 297         TP_ARGS(inode, pos, len, copied),
 298
 299         TP_STRUCT__entry(
 300                 __field(        dev_t,  dev                     )
 301                 __field(        ino_t,  ino                     )
 302                 __field(        loff_t, pos                     )
 303                 __field(        unsigned int, len               )
 304                 __field(        unsigned int, copied            )
 305         ),
 306
 307         TP_fast_assign(
 308                 __entry->dev    = inode->i_sb->s_dev;
 309                 __entry->ino    = inode->i_ino;
 310                 __entry->pos    = pos;
 311                 __entry->len    = len;
 312                 __entry->copied = copied;
 313         ),
 314
 315         TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
 316                   MAJOR(__entry->dev), MINOR(__entry->dev),
 317                   (unsigned long) __entry->ino,
 318                   __entry->pos, __entry->len, __entry->copied)
 319 );
 320
 321 DEFINE_EVENT(ext4__write_end, ext4_write_end,
 322
 323         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 324                  unsigned int copied),
 325
 326         TP_ARGS(inode, pos, len, copied)
 327 );
 328
 329 DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
 330
 331         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 332                  unsigned int copied),
 333
 334         TP_ARGS(inode, pos, len, copied)
 335 );
 336
 337 DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
 338
 339         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 340                  unsigned int copied),
 341
 342         TP_ARGS(inode, pos, len, copied)
 343 );
 344
 345 TRACE_EVENT(ext4_writepages,
 346         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 347
 348         TP_ARGS(inode, wbc),
 349
 350         TP_STRUCT__entry(
 351                 __field(        dev_t,  dev                     )
 352                 __field(        ino_t,  ino                     )
 353                 __field(        long,   nr_to_write             )
 354                 __field(        long,   pages_skipped           )
 355                 __field(        loff_t, range_start             )
 356                 __field(        loff_t, range_end               )
 357                 __field(       pgoff_t, writeback_index         )
 358                 __field(        int,    sync_mode               )
 359                 __field(        char,   for_kupdate             )
 360                 __field(        char,   range_cyclic            )
 361         ),
 362
 363         TP_fast_assign(
 364                 __entry->dev            = inode->i_sb->s_dev;
 365                 __entry->ino            = inode->i_ino;
 366                 __entry->nr_to_write    = wbc->nr_to_write;
 367                 __entry->pages_skipped  = wbc->pages_skipped;
 368                 __entry->range_start    = wbc->range_start;
 369                 __entry->range_end      = wbc->range_end;
 370                 __entry->writeback_index = inode->i_mapping->writeback_index;
 371                 __entry->sync_mode      = wbc->sync_mode;
 372                 __entry->for_kupdate    = wbc->for_kupdate;
 373                 __entry->range_cyclic   = wbc->range_cyclic;
 374         ),
 375
 376         TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
 377                   "range_start %lld range_end %lld sync_mode %d "
 378                   "for_kupdate %d range_cyclic %d writeback_index %lu",
 379                   MAJOR(__entry->dev), MINOR(__entry->dev),
 380                   (unsigned long) __entry->ino, __entry->nr_to_write,
 381                   __entry->pages_skipped, __entry->range_start,
 382                   __entry->range_end, __entry->sync_mode,
 383                   __entry->for_kupdate, __entry->range_cyclic,
 384                   (unsigned long) __entry->writeback_index)
 385 );
 386
 387 TRACE_EVENT(ext4_da_write_pages,
 388         TP_PROTO(struct inode *inode, pgoff_t first_page,
 389                  struct writeback_control *wbc),
 390
 391         TP_ARGS(inode, first_page, wbc),
 392
 393         TP_STRUCT__entry(
 394                 __field(        dev_t,  dev                     )
 395                 __field(        ino_t,  ino                     )
 396                 __field(      pgoff_t,  first_page              )
 397                 __field(         long,  nr_to_write             )
 398                 __field(          int,  sync_mode               )
 399         ),
 400
 401         TP_fast_assign(
 402                 __entry->dev            = inode->i_sb->s_dev;
 403                 __entry->ino            = inode->i_ino;
 404                 __entry->first_page     = first_page;
 405                 __entry->nr_to_write    = wbc->nr_to_write;
 406                 __entry->sync_mode      = wbc->sync_mode;
 407         ),
 408
 409         TP_printk("dev %d,%d ino %lu first_page %lu nr_to_write %ld "
 410                   "sync_mode %d",
 411                   MAJOR(__entry->dev), MINOR(__entry->dev),
 412                   (unsigned long) __entry->ino, __entry->first_page,
 413                   __entry->nr_to_write, __entry->sync_mode)
 414 );
 415
 416 TRACE_EVENT(ext4_da_write_pages_extent,
 417         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map),
 418
 419         TP_ARGS(inode, map),
 420
 421         TP_STRUCT__entry(
 422                 __field(        dev_t,  dev                     )
 423                 __field(        ino_t,  ino                     )
 424                 __field(        __u64,  lblk                    )
 425                 __field(        __u32,  len                     )
 426                 __field(        __u32,  flags                   )
 427         ),
 428
 429         TP_fast_assign(
 430                 __entry->dev            = inode->i_sb->s_dev;
 431                 __entry->ino            = inode->i_ino;
 432                 __entry->lblk           = map->m_lblk;
 433                 __entry->len            = map->m_len;
 434                 __entry->flags          = map->m_flags;
 435         ),
 436
 437         TP_printk("dev %d,%d ino %lu lblk %llu len %u flags %s",
 438                   MAJOR(__entry->dev), MINOR(__entry->dev),
 439                   (unsigned long) __entry->ino, __entry->lblk, __entry->len,
 440                   show_mflags(__entry->flags))
 441 );
 442
 443 TRACE_EVENT(ext4_writepages_result,
 444         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
 445                         int ret, int pages_written),
 446
 447         TP_ARGS(inode, wbc, ret, pages_written),
 448
 449         TP_STRUCT__entry(
 450                 __field(        dev_t,  dev                     )
 451                 __field(        ino_t,  ino                     )
 452                 __field(        int,    ret                     )
 453                 __field(        int,    pages_written           )
 454                 __field(        long,   pages_skipped           )
 455                 __field(       pgoff_t, writeback_index         )
 456                 __field(        int,    sync_mode               )
 457         ),
 458
 459         TP_fast_assign(
 460                 __entry->dev            = inode->i_sb->s_dev;
 461                 __entry->ino            = inode->i_ino;
 462                 __entry->ret            = ret;
 463                 __entry->pages_written  = pages_written;
 464                 __entry->pages_skipped  = wbc->pages_skipped;
 465                 __entry->writeback_index = inode->i_mapping->writeback_index;
 466                 __entry->sync_mode      = wbc->sync_mode;
 467         ),
 468
 469         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 470                   "sync_mode %d writeback_index %lu",
 471                   MAJOR(__entry->dev), MINOR(__entry->dev),
 472                   (unsigned long) __entry->ino, __entry->ret,
 473                   __entry->pages_written, __entry->pages_skipped,
 474                   __entry->sync_mode,
 475                   (unsigned long) __entry->writeback_index)
 476 );
 477
 478 DECLARE_EVENT_CLASS(ext4__page_op,
 479         TP_PROTO(struct page *page),
 480
 481         TP_ARGS(page),
 482
 483         TP_STRUCT__entry(
 484                 __field(        dev_t,  dev                     )
 485                 __field(        ino_t,  ino                     )
 486                 __field(        pgoff_t, index                  )
 487
 488         ),
 489
 490         TP_fast_assign(
 491                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 492                 __entry->ino    = page->mapping->host->i_ino;
 493                 __entry->index  = page->index;
 494         ),
 495
 496         TP_printk("dev %d,%d ino %lu page_index %lu",
 497                   MAJOR(__entry->dev), MINOR(__entry->dev),
 498                   (unsigned long) __entry->ino,
 499                   (unsigned long) __entry->index)
 500 );
 501
 502 DEFINE_EVENT(ext4__page_op, ext4_writepage,
 503
 504         TP_PROTO(struct page *page),
 505
 506         TP_ARGS(page)
 507 );
 508
 509 DEFINE_EVENT(ext4__page_op, ext4_readpage,
 510
 511         TP_PROTO(struct page *page),
 512
 513         TP_ARGS(page)
 514 );
 515
 516 DEFINE_EVENT(ext4__page_op, ext4_releasepage,
 517
 518         TP_PROTO(struct page *page),
 519
 520         TP_ARGS(page)
 521 );
 522
 523 DECLARE_EVENT_CLASS(ext4_invalidatepage_op,
 524         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 525
 526         TP_ARGS(page, offset, length),
 527
 528         TP_STRUCT__entry(
 529                 __field(        dev_t,  dev                     )
 530                 __field(        ino_t,  ino                     )
 531                 __field(        pgoff_t, index                  )
 532                 __field(        unsigned int, offset            )
 533                 __field(        unsigned int, length            )
 534         ),
 535
 536         TP_fast_assign(
 537                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 538                 __entry->ino    = page->mapping->host->i_ino;
 539                 __entry->index  = page->index;
 540                 __entry->offset = offset;
 541                 __entry->length = length;
 542         ),
 543
 544         TP_printk("dev %d,%d ino %lu page_index %lu offset %u length %u",
 545                   MAJOR(__entry->dev), MINOR(__entry->dev),
 546                   (unsigned long) __entry->ino,
 547                   (unsigned long) __entry->index,
 548                   __entry->offset, __entry->length)
 549 );
 550
 551 DEFINE_EVENT(ext4_invalidatepage_op, ext4_invalidatepage,
 552         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 553
 554         TP_ARGS(page, offset, length)
 555 );
 556
 557 DEFINE_EVENT(ext4_invalidatepage_op, ext4_journalled_invalidatepage,
 558         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 559
 560         TP_ARGS(page, offset, length)
 561 );
 562
 563 TRACE_EVENT(ext4_discard_blocks,
 564         TP_PROTO(struct super_block *sb, unsigned long long blk,
 565                         unsigned long long count),
 566
 567         TP_ARGS(sb, blk, count),
 568
 569         TP_STRUCT__entry(
 570                 __field(        dev_t,  dev                     )
 571                 __field(        __u64,  blk                     )
 572                 __field(        __u64,  count                   )
 573
 574         ),
 575
 576         TP_fast_assign(
 577                 __entry->dev    = sb->s_dev;
 578                 __entry->blk    = blk;
 579                 __entry->count  = count;
 580         ),
 581
 582         TP_printk("dev %d,%d blk %llu count %llu",
 583                   MAJOR(__entry->dev), MINOR(__entry->dev),
 584                   __entry->blk, __entry->count)
 585 );
 586
 587 DECLARE_EVENT_CLASS(ext4__mb_new_pa,
 588         TP_PROTO(struct ext4_allocation_context *ac,
 589                  struct ext4_prealloc_space *pa),
 590
 591         TP_ARGS(ac, pa),
 592
 593         TP_STRUCT__entry(
 594                 __field(        dev_t,  dev                     )
 595                 __field(        ino_t,  ino                     )
 596                 __field(        __u64,  pa_pstart               )
 597                 __field(        __u64,  pa_lstart               )
 598                 __field(        __u32,  pa_len                  )
 599
 600         ),
 601
 602         TP_fast_assign(
 603                 __entry->dev            = ac->ac_sb->s_dev;
 604                 __entry->ino            = ac->ac_inode->i_ino;
 605                 __entry->pa_pstart      = pa->pa_pstart;
 606                 __entry->pa_lstart      = pa->pa_lstart;
 607                 __entry->pa_len         = pa->pa_len;
 608         ),
 609
 610         TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
 611                   MAJOR(__entry->dev), MINOR(__entry->dev),
 612                   (unsigned long) __entry->ino,
 613                   __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 614 );
 615
 616 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
 617
 618         TP_PROTO(struct ext4_allocation_context *ac,
 619                  struct ext4_prealloc_space *pa),
 620
 621         TP_ARGS(ac, pa)
 622 );
 623
 624 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
 625
 626         TP_PROTO(struct ext4_allocation_context *ac,
 627                  struct ext4_prealloc_space *pa),
 628
 629         TP_ARGS(ac, pa)
 630 );
 631
 632 TRACE_EVENT(ext4_mb_release_inode_pa,
 633         TP_PROTO(struct ext4_prealloc_space *pa,
 634                  unsigned long long block, unsigned int count),
 635
 636         TP_ARGS(pa, block, count),
 637
 638         TP_STRUCT__entry(
 639                 __field(        dev_t,  dev                     )
 640                 __field(        ino_t,  ino                     )
 641                 __field(        __u64,  block                   )
 642                 __field(        __u32,  count                   )
 643
 644         ),
 645
 646         TP_fast_assign(
 647                 __entry->dev            = pa->pa_inode->i_sb->s_dev;
 648                 __entry->ino            = pa->pa_inode->i_ino;
 649                 __entry->block          = block;
 650                 __entry->count          = count;
 651         ),
 652
 653         TP_printk("dev %d,%d ino %lu block %llu count %u",
 654                   MAJOR(__entry->dev), MINOR(__entry->dev),
 655                   (unsigned long) __entry->ino,
 656                   __entry->block, __entry->count)
 657 );
 658
 659 TRACE_EVENT(ext4_mb_release_group_pa,
 660         TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
 661
 662         TP_ARGS(sb, pa),
 663
 664         TP_STRUCT__entry(
 665                 __field(        dev_t,  dev                     )
 666                 __field(        __u64,  pa_pstart               )
 667                 __field(        __u32,  pa_len                  )
 668
 669         ),
 670
 671         TP_fast_assign(
 672                 __entry->dev            = sb->s_dev;
 673                 __entry->pa_pstart      = pa->pa_pstart;
 674                 __entry->pa_len         = pa->pa_len;
 675         ),
 676
 677         TP_printk("dev %d,%d pstart %llu len %u",
 678                   MAJOR(__entry->dev), MINOR(__entry->dev),
 679                   __entry->pa_pstart, __entry->pa_len)
 680 );
 681
 682 TRACE_EVENT(ext4_discard_preallocations,
 683         TP_PROTO(struct inode *inode),
 684
 685         TP_ARGS(inode),
 686
 687         TP_STRUCT__entry(
 688                 __field(        dev_t,  dev                     )
 689                 __field(        ino_t,  ino                     )
 690
 691         ),
 692
 693         TP_fast_assign(
 694                 __entry->dev    = inode->i_sb->s_dev;
 695                 __entry->ino    = inode->i_ino;
 696         ),
 697
 698         TP_printk("dev %d,%d ino %lu",
 699                   MAJOR(__entry->dev), MINOR(__entry->dev),
 700                   (unsigned long) __entry->ino)
 701 );
 702
 703 TRACE_EVENT(ext4_mb_discard_preallocations,
 704         TP_PROTO(struct super_block *sb, int needed),
 705
 706         TP_ARGS(sb, needed),
 707
 708         TP_STRUCT__entry(
 709                 __field(        dev_t,  dev                     )
 710                 __field(        int,    needed                  )
 711
 712         ),
 713
 714         TP_fast_assign(
 715                 __entry->dev    = sb->s_dev;
 716                 __entry->needed = needed;
 717         ),
 718
 719         TP_printk("dev %d,%d needed %d",
 720                   MAJOR(__entry->dev), MINOR(__entry->dev),
 721                   __entry->needed)
 722 );
 723
 724 TRACE_EVENT(ext4_request_blocks,
 725         TP_PROTO(struct ext4_allocation_request *ar),
 726
 727         TP_ARGS(ar),
 728
 729         TP_STRUCT__entry(
 730                 __field(        dev_t,  dev                     )
 731                 __field(        ino_t,  ino                     )
 732                 __field(        unsigned int, len               )
 733                 __field(        __u32,  logical                 )
 734                 __field(        __u32,  lleft                   )
 735                 __field(        __u32,  lright                  )
 736                 __field(        __u64,  goal                    )
 737                 __field(        __u64,  pleft                   )
 738                 __field(        __u64,  pright                  )
 739                 __field(        unsigned int, flags             )
 740         ),
 741
 742         TP_fast_assign(
 743                 __entry->dev    = ar->inode->i_sb->s_dev;
 744                 __entry->ino    = ar->inode->i_ino;
 745                 __entry->len    = ar->len;
 746                 __entry->logical = ar->logical;
 747                 __entry->goal   = ar->goal;
 748                 __entry->lleft  = ar->lleft;
 749                 __entry->lright = ar->lright;
 750                 __entry->pleft  = ar->pleft;
 751                 __entry->pright = ar->pright;
 752                 __entry->flags  = ar->flags;
 753         ),
 754
 755         TP_printk("dev %d,%d ino %lu flags %s len %u lblk %u goal %llu "
 756                   "lleft %u lright %u pleft %llu pright %llu ",
 757                   MAJOR(__entry->dev), MINOR(__entry->dev),
 758                   (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
 759                   __entry->len, __entry->logical, __entry->goal,
 760                   __entry->lleft, __entry->lright, __entry->pleft,
 761                   __entry->pright)
 762 );
 763
 764 TRACE_EVENT(ext4_allocate_blocks,
 765         TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
 766
 767         TP_ARGS(ar, block),
 768
 769         TP_STRUCT__entry(
 770                 __field(        dev_t,  dev                     )
 771                 __field(        ino_t,  ino                     )
 772                 __field(        __u64,  block                   )
 773                 __field(        unsigned int, len               )
 774                 __field(        __u32,  logical                 )
 775                 __field(        __u32,  lleft                   )
 776                 __field(        __u32,  lright                  )
 777                 __field(        __u64,  goal                    )
 778                 __field(        __u64,  pleft                   )
 779                 __field(        __u64,  pright                  )
 780                 __field(        unsigned int, flags             )
 781         ),
 782
 783         TP_fast_assign(
 784                 __entry->dev    = ar->inode->i_sb->s_dev;
 785                 __entry->ino    = ar->inode->i_ino;
 786                 __entry->block  = block;
 787                 __entry->len    = ar->len;
 788                 __entry->logical = ar->logical;
 789                 __entry->goal   = ar->goal;
 790                 __entry->lleft  = ar->lleft;
 791                 __entry->lright = ar->lright;
 792                 __entry->pleft  = ar->pleft;
 793                 __entry->pright = ar->pright;
 794                 __entry->flags  = ar->flags;
 795         ),
 796
 797         TP_printk("dev %d,%d ino %lu flags %s len %u block %llu lblk %u "
 798                   "goal %llu lleft %u lright %u pleft %llu pright %llu",
 799                   MAJOR(__entry->dev), MINOR(__entry->dev),
 800                   (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
 801                   __entry->len, __entry->block, __entry->logical,
 802                   __entry->goal,  __entry->lleft, __entry->lright,
 803                   __entry->pleft, __entry->pright)
 804 );
 805
 806 TRACE_EVENT(ext4_free_blocks,
 807         TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
 808                  int flags),
 809
 810         TP_ARGS(inode, block, count, flags),
 811
 812         TP_STRUCT__entry(
 813                 __field(        dev_t,  dev                     )
 814                 __field(        ino_t,  ino                     )
 815                 __field(        __u64,  block                   )
 816                 __field(        unsigned long,  count           )
 817                 __field(        int,    flags                   )
 818                 __field(        __u16,  mode                    )
 819         ),
 820
 821         TP_fast_assign(
 822                 __entry->dev            = inode->i_sb->s_dev;
 823                 __entry->ino            = inode->i_ino;
 824                 __entry->block          = block;
 825                 __entry->count          = count;
 826                 __entry->flags          = flags;
 827                 __entry->mode           = inode->i_mode;
 828         ),
 829
 830         TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %s",
 831                   MAJOR(__entry->dev), MINOR(__entry->dev),
 832                   (unsigned long) __entry->ino,
 833                   __entry->mode, __entry->block, __entry->count,
 834                   show_free_flags(__entry->flags))
 835 );
 836
 837 TRACE_EVENT(ext4_sync_file_enter,
 838         TP_PROTO(struct file *file, int datasync),
 839
 840         TP_ARGS(file, datasync),
 841
 842         TP_STRUCT__entry(
 843                 __field(        dev_t,  dev                     )
 844                 __field(        ino_t,  ino                     )
 845                 __field(        ino_t,  parent                  )
 846                 __field(        int,    datasync                )
 847         ),
 848
 849         TP_fast_assign(
 850                 struct dentry *dentry = file->f_path.dentry;
 851
 852                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
 853                 __entry->ino            = dentry->d_inode->i_ino;
 854                 __entry->datasync       = datasync;
 855                 __entry->parent         = dentry->d_parent->d_inode->i_ino;
 856         ),
 857
 858         TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
 859                   MAJOR(__entry->dev), MINOR(__entry->dev),
 860                   (unsigned long) __entry->ino,
 861                   (unsigned long) __entry->parent, __entry->datasync)
 862 );
 863
 864 TRACE_EVENT(ext4_sync_file_exit,
 865         TP_PROTO(struct inode *inode, int ret),
 866
 867         TP_ARGS(inode, ret),
 868
 869         TP_STRUCT__entry(
 870                 __field(        dev_t,  dev                     )
 871                 __field(        ino_t,  ino                     )
 872                 __field(        int,    ret                     )
 873         ),
 874
 875         TP_fast_assign(
 876                 __entry->dev            = inode->i_sb->s_dev;
 877                 __entry->ino            = inode->i_ino;
 878                 __entry->ret            = ret;
 879         ),
 880
 881         TP_printk("dev %d,%d ino %lu ret %d",
 882                   MAJOR(__entry->dev), MINOR(__entry->dev),
 883                   (unsigned long) __entry->ino,
 884                   __entry->ret)
 885 );
 886
 887 TRACE_EVENT(ext4_sync_fs,
 888         TP_PROTO(struct super_block *sb, int wait),
 889
 890         TP_ARGS(sb, wait),
 891
 892         TP_STRUCT__entry(
 893                 __field(        dev_t,  dev                     )
 894                 __field(        int,    wait                    )
 895
 896         ),
 897
 898         TP_fast_assign(
 899                 __entry->dev    = sb->s_dev;
 900                 __entry->wait   = wait;
 901         ),
 902
 903         TP_printk("dev %d,%d wait %d",
 904                   MAJOR(__entry->dev), MINOR(__entry->dev),
 905                   __entry->wait)
 906 );
 907
 908 TRACE_EVENT(ext4_alloc_da_blocks,
 909         TP_PROTO(struct inode *inode),
 910
 911         TP_ARGS(inode),
 912
 913         TP_STRUCT__entry(
 914                 __field(        dev_t,  dev                     )
 915                 __field(        ino_t,  ino                     )
 916                 __field( unsigned int,  data_blocks     )
 917                 __field( unsigned int,  meta_blocks     )
 918         ),
 919
 920         TP_fast_assign(
 921                 __entry->dev    = inode->i_sb->s_dev;
 922                 __entry->ino    = inode->i_ino;
 923                 __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
 924                 __entry->meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
 925         ),
 926
 927         TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
 928                   MAJOR(__entry->dev), MINOR(__entry->dev),
 929                   (unsigned long) __entry->ino,
 930                   __entry->data_blocks, __entry->meta_blocks)
 931 );
 932
 933 TRACE_EVENT(ext4_mballoc_alloc,
 934         TP_PROTO(struct ext4_allocation_context *ac),
 935
 936         TP_ARGS(ac),
 937
 938         TP_STRUCT__entry(
 939                 __field(        dev_t,  dev                     )
 940                 __field(        ino_t,  ino                     )
 941                 __field(        __u32,  orig_logical            )
 942                 __field(          int,  orig_start              )
 943                 __field(        __u32,  orig_group              )
 944                 __field(          int,  orig_len                )
 945                 __field(        __u32,  goal_logical            )
 946                 __field(          int,  goal_start              )
 947                 __field(        __u32,  goal_group              )
 948                 __field(          int,  goal_len                )
 949                 __field(        __u32,  result_logical          )
 950                 __field(          int,  result_start            )
 951                 __field(        __u32,  result_group            )
 952                 __field(          int,  result_len              )
 953                 __field(        __u16,  found                   )
 954                 __field(        __u16,  groups                  )
 955                 __field(        __u16,  buddy                   )
 956                 __field(        __u16,  flags                   )
 957                 __field(        __u16,  tail                    )
 958                 __field(        __u8,   cr                      )
 959         ),
 960
 961         TP_fast_assign(
 962                 __entry->dev            = ac->ac_inode->i_sb->s_dev;
 963                 __entry->ino            = ac->ac_inode->i_ino;
 964                 __entry->orig_logical   = ac->ac_o_ex.fe_logical;
 965                 __entry->orig_start     = ac->ac_o_ex.fe_start;
 966                 __entry->orig_group     = ac->ac_o_ex.fe_group;
 967                 __entry->orig_len       = ac->ac_o_ex.fe_len;
 968                 __entry->goal_logical   = ac->ac_g_ex.fe_logical;
 969                 __entry->goal_start     = ac->ac_g_ex.fe_start;
 970                 __entry->goal_group     = ac->ac_g_ex.fe_group;
 971                 __entry->goal_len       = ac->ac_g_ex.fe_len;
 972                 __entry->result_logical = ac->ac_f_ex.fe_logical;
 973                 __entry->result_start   = ac->ac_f_ex.fe_start;
 974                 __entry->result_group   = ac->ac_f_ex.fe_group;
 975                 __entry->result_len     = ac->ac_f_ex.fe_len;
 976                 __entry->found          = ac->ac_found;
 977                 __entry->flags          = ac->ac_flags;
 978                 __entry->groups         = ac->ac_groups_scanned;
 979                 __entry->buddy          = ac->ac_buddy;
 980                 __entry->tail           = ac->ac_tail;
 981                 __entry->cr             = ac->ac_criteria;
 982         ),
 983
 984         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
 985                   "result %u/%d/%u@%u blks %u grps %u cr %u flags %s "
 986                   "tail %u broken %u",
 987                   MAJOR(__entry->dev), MINOR(__entry->dev),
 988                   (unsigned long) __entry->ino,
 989                   __entry->orig_group, __entry->orig_start,
 990                   __entry->orig_len, __entry->orig_logical,
 991                   __entry->goal_group, __entry->goal_start,
 992                   __entry->goal_len, __entry->goal_logical,
 993                   __entry->result_group, __entry->result_start,
 994                   __entry->result_len, __entry->result_logical,
 995                   __entry->found, __entry->groups, __entry->cr,
 996                   show_mballoc_flags(__entry->flags), __entry->tail,
 997                   __entry->buddy ? 1 << __entry->buddy : 0)
 998 );
 999
1000 TRACE_EVENT(ext4_mballoc_prealloc,
1001         TP_PROTO(struct ext4_allocation_context *ac),
1002
1003         TP_ARGS(ac),
1004
1005         TP_STRUCT__entry(
1006                 __field(        dev_t,  dev                     )
1007                 __field(        ino_t,  ino                     )
1008                 __field(        __u32,  orig_logical            )
1009                 __field(          int,  orig_start              )
1010                 __field(        __u32,  orig_group              )
1011                 __field(          int,  orig_len                )
1012                 __field(        __u32,  result_logical          )
1013                 __field(          int,  result_start            )
1014                 __field(        __u32,  result_group            )
1015                 __field(          int,  result_len              )
1016         ),
1017
1018         TP_fast_assign(
1019                 __entry->dev            = ac->ac_inode->i_sb->s_dev;
1020                 __entry->ino            = ac->ac_inode->i_ino;
1021                 __entry->orig_logical   = ac->ac_o_ex.fe_logical;
1022                 __entry->orig_start     = ac->ac_o_ex.fe_start;
1023                 __entry->orig_group     = ac->ac_o_ex.fe_group;
1024                 __entry->orig_len       = ac->ac_o_ex.fe_len;
1025                 __entry->result_logical = ac->ac_b_ex.fe_logical;
1026                 __entry->result_start   = ac->ac_b_ex.fe_start;
1027                 __entry->result_group   = ac->ac_b_ex.fe_group;
1028                 __entry->result_len     = ac->ac_b_ex.fe_len;
1029         ),
1030
1031         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
1032                   MAJOR(__entry->dev), MINOR(__entry->dev),
1033                   (unsigned long) __entry->ino,
1034                   __entry->orig_group, __entry->orig_start,
1035                   __entry->orig_len, __entry->orig_logical,
1036                   __entry->result_group, __entry->result_start,
1037                   __entry->result_len, __entry->result_logical)
1038 );
1039
1040 DECLARE_EVENT_CLASS(ext4__mballoc,
1041         TP_PROTO(struct super_block *sb,
1042                  struct inode *inode,
1043                  ext4_group_t group,
1044                  ext4_grpblk_t start,
1045                  ext4_grpblk_t len),
1046
1047         TP_ARGS(sb, inode, group, start, len),
1048
1049         TP_STRUCT__entry(
1050                 __field(        dev_t,  dev                     )
1051                 __field(        ino_t,  ino                     )
1052                 __field(          int,  result_start            )
1053                 __field(        __u32,  result_group            )
1054                 __field(          int,  result_len              )
1055         ),
1056
1057         TP_fast_assign(
1058                 __entry->dev            = sb->s_dev;
1059                 __entry->ino            = inode ? inode->i_ino : 0;
1060                 __entry->result_start   = start;
1061                 __entry->result_group   = group;
1062                 __entry->result_len     = len;
1063         ),
1064
1065         TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
1066                   MAJOR(__entry->dev), MINOR(__entry->dev),
1067                   (unsigned long) __entry->ino,
1068                   __entry->result_group, __entry->result_start,
1069                   __entry->result_len)
1070 );
1071
1072 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
1073
1074         TP_PROTO(struct super_block *sb,
1075                  struct inode *inode,
1076                  ext4_group_t group,
1077                  ext4_grpblk_t start,
1078                  ext4_grpblk_t len),
1079
1080         TP_ARGS(sb, inode, group, start, len)
1081 );
1082
1083 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
1084
1085         TP_PROTO(struct super_block *sb,
1086                  struct inode *inode,
1087                  ext4_group_t group,
1088                  ext4_grpblk_t start,
1089                  ext4_grpblk_t len),
1090
1091         TP_ARGS(sb, inode, group, start, len)
1092 );
1093
1094 TRACE_EVENT(ext4_forget,
1095         TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
1096
1097         TP_ARGS(inode, is_metadata, block),
1098
1099         TP_STRUCT__entry(
1100                 __field(        dev_t,  dev                     )
1101                 __field(        ino_t,  ino                     )
1102                 __field(        __u64,  block                   )
1103                 __field(        int,    is_metadata             )
1104                 __field(        __u16,  mode                    )
1105         ),
1106
1107         TP_fast_assign(
1108                 __entry->dev    = inode->i_sb->s_dev;
1109                 __entry->ino    = inode->i_ino;
1110                 __entry->block  = block;
1111                 __entry->is_metadata = is_metadata;
1112                 __entry->mode   = inode->i_mode;
1113         ),
1114
1115         TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1116                   MAJOR(__entry->dev), MINOR(__entry->dev),
1117                   (unsigned long) __entry->ino,
1118                   __entry->mode, __entry->is_metadata, __entry->block)
1119 );
1120
1121 TRACE_EVENT(ext4_da_update_reserve_space,
1122         TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
1123
1124         TP_ARGS(inode, used_blocks, quota_claim),
1125
1126         TP_STRUCT__entry(
1127                 __field(        dev_t,  dev                     )
1128                 __field(        ino_t,  ino                     )
1129                 __field(        __u64,  i_blocks                )
1130                 __field(        int,    used_blocks             )
1131                 __field(        int,    reserved_data_blocks    )
1132                 __field(        int,    reserved_meta_blocks    )
1133                 __field(        int,    allocated_meta_blocks   )
1134                 __field(        int,    quota_claim             )
1135                 __field(        __u16,  mode                    )
1136         ),
1137
1138         TP_fast_assign(
1139                 __entry->dev    = inode->i_sb->s_dev;
1140                 __entry->ino    = inode->i_ino;
1141                 __entry->i_blocks = inode->i_blocks;
1142                 __entry->used_blocks = used_blocks;
1143                 __entry->reserved_data_blocks =
1144                                 EXT4_I(inode)->i_reserved_data_blocks;
1145                 __entry->reserved_meta_blocks =
1146                                 EXT4_I(inode)->i_reserved_meta_blocks;
1147                 __entry->allocated_meta_blocks =
1148                                 EXT4_I(inode)->i_allocated_meta_blocks;
1149                 __entry->quota_claim = quota_claim;
1150                 __entry->mode   = inode->i_mode;
1151         ),
1152
1153         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1154                   "reserved_data_blocks %d reserved_meta_blocks %d "
1155                   "allocated_meta_blocks %d quota_claim %d",
1156                   MAJOR(__entry->dev), MINOR(__entry->dev),
1157                   (unsigned long) __entry->ino,
1158                   __entry->mode, __entry->i_blocks,
1159                   __entry->used_blocks, __entry->reserved_data_blocks,
1160                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks,
1161                   __entry->quota_claim)
1162 );
1163
1164 TRACE_EVENT(ext4_da_reserve_space,
1165         TP_PROTO(struct inode *inode, int md_needed),
1166
1167         TP_ARGS(inode, md_needed),
1168
1169         TP_STRUCT__entry(
1170                 __field(        dev_t,  dev                     )
1171                 __field(        ino_t,  ino                     )
1172                 __field(        __u64,  i_blocks                )
1173                 __field(        int,    md_needed               )
1174                 __field(        int,    reserved_data_blocks    )
1175                 __field(        int,    reserved_meta_blocks    )
1176                 __field(        __u16,  mode                    )
1177         ),
1178
1179         TP_fast_assign(
1180                 __entry->dev    = inode->i_sb->s_dev;
1181                 __entry->ino    = inode->i_ino;
1182                 __entry->i_blocks = inode->i_blocks;
1183                 __entry->md_needed = md_needed;
1184                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1185                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1186                 __entry->mode   = inode->i_mode;
1187         ),
1188
1189         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
1190                   "reserved_data_blocks %d reserved_meta_blocks %d",
1191                   MAJOR(__entry->dev), MINOR(__entry->dev),
1192                   (unsigned long) __entry->ino,
1193                   __entry->mode, __entry->i_blocks,
1194                   __entry->md_needed, __entry->reserved_data_blocks,
1195                   __entry->reserved_meta_blocks)
1196 );
1197
1198 TRACE_EVENT(ext4_da_release_space,
1199         TP_PROTO(struct inode *inode, int freed_blocks),
1200
1201         TP_ARGS(inode, freed_blocks),
1202
1203         TP_STRUCT__entry(
1204                 __field(        dev_t,  dev                     )
1205                 __field(        ino_t,  ino                     )
1206                 __field(        __u64,  i_blocks                )
1207                 __field(        int,    freed_blocks            )
1208                 __field(        int,    reserved_data_blocks    )
1209                 __field(        int,    reserved_meta_blocks    )
1210                 __field(        int,    allocated_meta_blocks   )
1211                 __field(        __u16,  mode                    )
1212         ),
1213
1214         TP_fast_assign(
1215                 __entry->dev    = inode->i_sb->s_dev;
1216                 __entry->ino    = inode->i_ino;
1217                 __entry->i_blocks = inode->i_blocks;
1218                 __entry->freed_blocks = freed_blocks;
1219                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1220                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1221                 __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
1222                 __entry->mode   = inode->i_mode;
1223         ),
1224
1225         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
1226                   "reserved_data_blocks %d reserved_meta_blocks %d "
1227                   "allocated_meta_blocks %d",
1228                   MAJOR(__entry->dev), MINOR(__entry->dev),
1229                   (unsigned long) __entry->ino,
1230                   __entry->mode, __entry->i_blocks,
1231                   __entry->freed_blocks, __entry->reserved_data_blocks,
1232                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1233 );
1234
1235 DECLARE_EVENT_CLASS(ext4__bitmap_load,
1236         TP_PROTO(struct super_block *sb, unsigned long group),
1237
1238         TP_ARGS(sb, group),
1239
1240         TP_STRUCT__entry(
1241                 __field(        dev_t,  dev                     )
1242                 __field(        __u32,  group                   )
1243
1244         ),
1245
1246         TP_fast_assign(
1247                 __entry->dev    = sb->s_dev;
1248                 __entry->group  = group;
1249         ),
1250
1251         TP_printk("dev %d,%d group %u",
1252                   MAJOR(__entry->dev), MINOR(__entry->dev),
1253                   __entry->group)
1254 );
1255
1256 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
1257
1258         TP_PROTO(struct super_block *sb, unsigned long group),
1259
1260         TP_ARGS(sb, group)
1261 );
1262
1263 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
1264
1265         TP_PROTO(struct super_block *sb, unsigned long group),
1266
1267         TP_ARGS(sb, group)
1268 );
1269
1270 DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
1271
1272         TP_PROTO(struct super_block *sb, unsigned long group),
1273
1274         TP_ARGS(sb, group)
1275 );
1276
1277 DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
1278
1279         TP_PROTO(struct super_block *sb, unsigned long group),
1280
1281         TP_ARGS(sb, group)
1282 );
1283
1284 TRACE_EVENT(ext4_direct_IO_enter,
1285         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
1286
1287         TP_ARGS(inode, offset, len, rw),
1288
1289         TP_STRUCT__entry(
1290                 __field(        dev_t,  dev                     )
1291                 __field(        ino_t,  ino                     )
1292                 __field(        loff_t, pos                     )
1293                 __field(        unsigned long,  len             )
1294                 __field(        int,    rw                      )
1295         ),
1296
1297         TP_fast_assign(
1298                 __entry->dev    = inode->i_sb->s_dev;
1299                 __entry->ino    = inode->i_ino;
1300                 __entry->pos    = offset;
1301                 __entry->len    = len;
1302                 __entry->rw     = rw;
1303         ),
1304
1305         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d",
1306                   MAJOR(__entry->dev), MINOR(__entry->dev),
1307                   (unsigned long) __entry->ino,
1308                   __entry->pos, __entry->len, __entry->rw)
1309 );
1310
1311 TRACE_EVENT(ext4_direct_IO_exit,
1312         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
1313                  int rw, int ret),
1314
1315         TP_ARGS(inode, offset, len, rw, ret),
1316
1317         TP_STRUCT__entry(
1318                 __field(        dev_t,  dev                     )
1319                 __field(        ino_t,  ino                     )
1320                 __field(        loff_t, pos                     )
1321                 __field(        unsigned long,  len             )
1322                 __field(        int,    rw                      )
1323                 __field(        int,    ret                     )
1324         ),
1325
1326         TP_fast_assign(
1327                 __entry->dev    = inode->i_sb->s_dev;
1328                 __entry->ino    = inode->i_ino;
1329                 __entry->pos    = offset;
1330                 __entry->len    = len;
1331                 __entry->rw     = rw;
1332                 __entry->ret    = ret;
1333         ),
1334
1335         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d ret %d",
1336                   MAJOR(__entry->dev), MINOR(__entry->dev),
1337                   (unsigned long) __entry->ino,
1338                   __entry->pos, __entry->len,
1339                   __entry->rw, __entry->ret)
1340 );
1341
1342 TRACE_EVENT(ext4_fallocate_enter,
1343         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1344
1345         TP_ARGS(inode, offset, len, mode),
1346
1347         TP_STRUCT__entry(
1348                 __field(        dev_t,  dev                     )
1349                 __field(        ino_t,  ino                     )
1350                 __field(        loff_t, pos                     )
1351                 __field(        loff_t, len                     )
1352                 __field(        int,    mode                    )
1353         ),
1354
1355         TP_fast_assign(
1356                 __entry->dev    = inode->i_sb->s_dev;
1357                 __entry->ino    = inode->i_ino;
1358                 __entry->pos    = offset;
1359                 __entry->len    = len;
1360                 __entry->mode   = mode;
1361         ),
1362
1363         TP_printk("dev %d,%d ino %lu pos %lld len %lld mode %s",
1364                   MAJOR(__entry->dev), MINOR(__entry->dev),
1365                   (unsigned long) __entry->ino, __entry->pos,
1366                   __entry->len, show_falloc_mode(__entry->mode))
1367 );
1368
1369 TRACE_EVENT(ext4_fallocate_exit,
1370         TP_PROTO(struct inode *inode, loff_t offset,
1371                  unsigned int max_blocks, int ret),
1372
1373         TP_ARGS(inode, offset, max_blocks, ret),
1374
1375         TP_STRUCT__entry(
1376                 __field(        dev_t,  dev                     )
1377                 __field(        ino_t,  ino                     )
1378                 __field(        loff_t, pos                     )
1379                 __field(        unsigned int,   blocks          )
1380                 __field(        int,    ret                     )
1381         ),
1382
1383         TP_fast_assign(
1384                 __entry->dev    = inode->i_sb->s_dev;
1385                 __entry->ino    = inode->i_ino;
1386                 __entry->pos    = offset;
1387                 __entry->blocks = max_blocks;
1388                 __entry->ret    = ret;
1389         ),
1390
1391         TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
1392                   MAJOR(__entry->dev), MINOR(__entry->dev),
1393                   (unsigned long) __entry->ino,
1394                   __entry->pos, __entry->blocks,
1395                   __entry->ret)
1396 );
1397
1398 TRACE_EVENT(ext4_punch_hole,
1399         TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
1400
1401         TP_ARGS(inode, offset, len),
1402
1403         TP_STRUCT__entry(
1404                 __field(        dev_t,  dev                     )
1405                 __field(        ino_t,  ino                     )
1406                 __field(        loff_t, offset                  )
1407                 __field(        loff_t, len                     )
1408         ),
1409
1410         TP_fast_assign(
1411                 __entry->dev    = inode->i_sb->s_dev;
1412                 __entry->ino    = inode->i_ino;
1413                 __entry->offset = offset;
1414                 __entry->len    = len;
1415         ),
1416
1417         TP_printk("dev %d,%d ino %lu offset %lld len %lld",
1418                   MAJOR(__entry->dev), MINOR(__entry->dev),
1419                   (unsigned long) __entry->ino,
1420                   __entry->offset, __entry->len)
1421 );
1422
1423 TRACE_EVENT(ext4_unlink_enter,
1424         TP_PROTO(struct inode *parent, struct dentry *dentry),
1425
1426         TP_ARGS(parent, dentry),
1427
1428         TP_STRUCT__entry(
1429                 __field(        dev_t,  dev                     )
1430                 __field(        ino_t,  ino                     )
1431                 __field(        ino_t,  parent                  )
1432                 __field(        loff_t, size                    )
1433         ),
1434
1435         TP_fast_assign(
1436                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
1437                 __entry->ino            = dentry->d_inode->i_ino;
1438                 __entry->parent         = parent->i_ino;
1439                 __entry->size           = dentry->d_inode->i_size;
1440         ),
1441
1442         TP_printk("dev %d,%d ino %lu size %lld parent %lu",
1443                   MAJOR(__entry->dev), MINOR(__entry->dev),
1444                   (unsigned long) __entry->ino, __entry->size,
1445                   (unsigned long) __entry->parent)
1446 );
1447
1448 TRACE_EVENT(ext4_unlink_exit,
1449         TP_PROTO(struct dentry *dentry, int ret),
1450
1451         TP_ARGS(dentry, ret),
1452
1453         TP_STRUCT__entry(
1454                 __field(        dev_t,  dev                     )
1455                 __field(        ino_t,  ino                     )
1456                 __field(        int,    ret                     )
1457         ),
1458
1459         TP_fast_assign(
1460                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
1461                 __entry->ino            = dentry->d_inode->i_ino;
1462                 __entry->ret            = ret;
1463         ),
1464
1465         TP_printk("dev %d,%d ino %lu ret %d",
1466                   MAJOR(__entry->dev), MINOR(__entry->dev),
1467                   (unsigned long) __entry->ino,
1468                   __entry->ret)
1469 );
1470
1471 DECLARE_EVENT_CLASS(ext4__truncate,
1472         TP_PROTO(struct inode *inode),
1473
1474         TP_ARGS(inode),
1475
1476         TP_STRUCT__entry(
1477                 __field(        dev_t,          dev             )
1478                 __field(        ino_t,          ino             )
1479                 __field(        __u64,          blocks          )
1480         ),
1481
1482         TP_fast_assign(
1483                 __entry->dev    = inode->i_sb->s_dev;
1484                 __entry->ino    = inode->i_ino;
1485                 __entry->blocks = inode->i_blocks;
1486         ),
1487
1488         TP_printk("dev %d,%d ino %lu blocks %llu",
1489                   MAJOR(__entry->dev), MINOR(__entry->dev),
1490                   (unsigned long) __entry->ino, __entry->blocks)
1491 );
1492
1493 DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
1494
1495         TP_PROTO(struct inode *inode),
1496
1497         TP_ARGS(inode)
1498 );
1499
1500 DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
1501
1502         TP_PROTO(struct inode *inode),
1503
1504         TP_ARGS(inode)
1505 );
1506
1507 /* 'ux' is the uninitialized extent. */
1508 TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
1509         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1510                  struct ext4_extent *ux),
1511
1512         TP_ARGS(inode, map, ux),
1513
1514         TP_STRUCT__entry(
1515                 __field(        dev_t,          dev     )
1516                 __field(        ino_t,          ino     )
1517                 __field(        ext4_lblk_t,    m_lblk  )
1518                 __field(        unsigned,       m_len   )
1519                 __field(        ext4_lblk_t,    u_lblk  )
1520                 __field(        unsigned,       u_len   )
1521                 __field(        ext4_fsblk_t,   u_pblk  )
1522         ),
1523
1524         TP_fast_assign(
1525                 __entry->dev            = inode->i_sb->s_dev;
1526                 __entry->ino            = inode->i_ino;
1527                 __entry->m_lblk         = map->m_lblk;
1528                 __entry->m_len          = map->m_len;
1529                 __entry->u_lblk         = le32_to_cpu(ux->ee_block);
1530                 __entry->u_len          = ext4_ext_get_actual_len(ux);
1531                 __entry->u_pblk         = ext4_ext_pblock(ux);
1532         ),
1533
1534         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
1535                   "u_pblk %llu",
1536                   MAJOR(__entry->dev), MINOR(__entry->dev),
1537                   (unsigned long) __entry->ino,
1538                   __entry->m_lblk, __entry->m_len,
1539                   __entry->u_lblk, __entry->u_len, __entry->u_pblk)
1540 );
1541
1542 /*
1543  * 'ux' is the uninitialized extent.
1544  * 'ix' is the initialized extent to which blocks are transferred.
1545  */
1546 TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
1547         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1548                  struct ext4_extent *ux, struct ext4_extent *ix),
1549
1550         TP_ARGS(inode, map, ux, ix),
1551
1552         TP_STRUCT__entry(
1553                 __field(        dev_t,          dev     )
1554                 __field(        ino_t,          ino     )
1555                 __field(        ext4_lblk_t,    m_lblk  )
1556                 __field(        unsigned,       m_len   )
1557                 __field(        ext4_lblk_t,    u_lblk  )
1558                 __field(        unsigned,       u_len   )
1559                 __field(        ext4_fsblk_t,   u_pblk  )
1560                 __field(        ext4_lblk_t,    i_lblk  )
1561                 __field(        unsigned,       i_len   )
1562                 __field(        ext4_fsblk_t,   i_pblk  )
1563         ),
1564
1565         TP_fast_assign(
1566                 __entry->dev            = inode->i_sb->s_dev;
1567                 __entry->ino            = inode->i_ino;
1568                 __entry->m_lblk         = map->m_lblk;
1569                 __entry->m_len          = map->m_len;
1570                 __entry->u_lblk         = le32_to_cpu(ux->ee_block);
1571                 __entry->u_len          = ext4_ext_get_actual_len(ux);
1572                 __entry->u_pblk         = ext4_ext_pblock(ux);
1573                 __entry->i_lblk         = le32_to_cpu(ix->ee_block);
1574                 __entry->i_len          = ext4_ext_get_actual_len(ix);
1575                 __entry->i_pblk         = ext4_ext_pblock(ix);
1576         ),
1577
1578         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
1579                   "u_lblk %u u_len %u u_pblk %llu "
1580                   "i_lblk %u i_len %u i_pblk %llu ",
1581                   MAJOR(__entry->dev), MINOR(__entry->dev),
1582                   (unsigned long) __entry->ino,
1583                   __entry->m_lblk, __entry->m_len,
1584                   __entry->u_lblk, __entry->u_len, __entry->u_pblk,
1585                   __entry->i_lblk, __entry->i_len, __entry->i_pblk)
1586 );
1587
1588 DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
1589         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1590                  unsigned int len, unsigned int flags),
1591
1592         TP_ARGS(inode, lblk, len, flags),
1593
1594         TP_STRUCT__entry(
1595                 __field(        dev_t,          dev             )
1596                 __field(        ino_t,          ino             )
1597                 __field(        ext4_lblk_t,    lblk            )
1598                 __field(        unsigned int,   len             )
1599                 __field(        unsigned int,   flags           )
1600         ),
1601
1602         TP_fast_assign(
1603                 __entry->dev    = inode->i_sb->s_dev;
1604                 __entry->ino    = inode->i_ino;
1605                 __entry->lblk   = lblk;
1606                 __entry->len    = len;
1607                 __entry->flags  = flags;
1608         ),
1609
1610         TP_printk("dev %d,%d ino %lu lblk %u len %u flags %s",
1611                   MAJOR(__entry->dev), MINOR(__entry->dev),
1612                   (unsigned long) __entry->ino,
1613                   __entry->lblk, __entry->len, show_map_flags(__entry->flags))
1614 );
1615
1616 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
1617         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1618                  unsigned len, unsigned flags),
1619
1620         TP_ARGS(inode, lblk, len, flags)
1621 );
1622
1623 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
1624         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1625                  unsigned len, unsigned flags),
1626
1627         TP_ARGS(inode, lblk, len, flags)
1628 );
1629
1630 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
1631         TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map,
1632                  int ret),
1633
1634         TP_ARGS(inode, flags, map, ret),
1635
1636         TP_STRUCT__entry(
1637                 __field(        dev_t,          dev             )
1638                 __field(        ino_t,          ino             )
1639                 __field(        unsigned int,   flags           )
1640                 __field(        ext4_fsblk_t,   pblk            )
1641                 __field(        ext4_lblk_t,    lblk            )
1642                 __field(        unsigned int,   len             )
1643                 __field(        unsigned int,   mflags          )
1644                 __field(        int,            ret             )
1645         ),
1646
1647         TP_fast_assign(
1648                 __entry->dev    = inode->i_sb->s_dev;
1649                 __entry->ino    = inode->i_ino;
1650                 __entry->flags  = flags;
1651                 __entry->pblk   = map->m_pblk;
1652                 __entry->lblk   = map->m_lblk;
1653                 __entry->len    = map->m_len;
1654                 __entry->mflags = map->m_flags;
1655                 __entry->ret    = ret;
1656         ),
1657
1658         TP_printk("dev %d,%d ino %lu flags %s lblk %u pblk %llu len %u "
1659                   "mflags %s ret %d",
1660                   MAJOR(__entry->dev), MINOR(__entry->dev),
1661                   (unsigned long) __entry->ino,
1662                   show_map_flags(__entry->flags), __entry->lblk, __entry->pblk,
1663                   __entry->len, show_mflags(__entry->mflags), __entry->ret)
1664 );
1665
1666 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
1667         TP_PROTO(struct inode *inode, unsigned flags,
1668                  struct ext4_map_blocks *map, int ret),
1669
1670         TP_ARGS(inode, flags, map, ret)
1671 );
1672
1673 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
1674         TP_PROTO(struct inode *inode, unsigned flags,
1675                  struct ext4_map_blocks *map, int ret),
1676
1677         TP_ARGS(inode, flags, map, ret)
1678 );
1679
1680 TRACE_EVENT(ext4_ext_load_extent,
1681         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
1682
1683         TP_ARGS(inode, lblk, pblk),
1684
1685         TP_STRUCT__entry(
1686                 __field(        dev_t,          dev             )
1687                 __field(        ino_t,          ino             )
1688                 __field(        ext4_fsblk_t,   pblk            )
1689                 __field(        ext4_lblk_t,    lblk            )
1690         ),
1691
1692         TP_fast_assign(
1693                 __entry->dev    = inode->i_sb->s_dev;
1694                 __entry->ino    = inode->i_ino;
1695                 __entry->pblk   = pblk;
1696                 __entry->lblk   = lblk;
1697         ),
1698
1699         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
1700                   MAJOR(__entry->dev), MINOR(__entry->dev),
1701                   (unsigned long) __entry->ino,
1702                   __entry->lblk, __entry->pblk)
1703 );
1704
1705 TRACE_EVENT(ext4_load_inode,
1706         TP_PROTO(struct inode *inode),
1707
1708         TP_ARGS(inode),
1709
1710         TP_STRUCT__entry(
1711                 __field(        dev_t,  dev             )
1712                 __field(        ino_t,  ino             )
1713         ),
1714
1715         TP_fast_assign(
1716                 __entry->dev            = inode->i_sb->s_dev;
1717                 __entry->ino            = inode->i_ino;
1718         ),
1719
1720         TP_printk("dev %d,%d ino %ld",
1721                   MAJOR(__entry->dev), MINOR(__entry->dev),
1722                   (unsigned long) __entry->ino)
1723 );
1724
1725 TRACE_EVENT(ext4_journal_start,
1726         TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
1727                  unsigned long IP),
1728
1729         TP_ARGS(sb, blocks, rsv_blocks, IP),
1730
1731         TP_STRUCT__entry(
1732                 __field(        dev_t,  dev                     )
1733                 __field(unsigned long,  ip                      )
1734                 __field(          int,  blocks                  )
1735                 __field(          int,  rsv_blocks              )
1736         ),
1737
1738         TP_fast_assign(
1739                 __entry->dev             = sb->s_dev;
1740                 __entry->ip              = IP;
1741                 __entry->blocks          = blocks;
1742                 __entry->rsv_blocks      = rsv_blocks;
1743         ),
1744
1745         TP_printk("dev %d,%d blocks, %d rsv_blocks, %d caller %pF",
1746                   MAJOR(__entry->dev), MINOR(__entry->dev),
1747                   __entry->blocks, __entry->rsv_blocks, (void *)__entry->ip)
1748 );
1749
1750 TRACE_EVENT(ext4_journal_start_reserved,
1751         TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
1752
1753         TP_ARGS(sb, blocks, IP),
1754
1755         TP_STRUCT__entry(
1756                 __field(        dev_t,  dev                     )
1757                 __field(unsigned long,  ip                      )
1758                 __field(          int,  blocks                  )
1759         ),
1760
1761         TP_fast_assign(
1762                 __entry->dev             = sb->s_dev;
1763                 __entry->ip              = IP;
1764                 __entry->blocks          = blocks;
1765         ),
1766
1767         TP_printk("dev %d,%d blocks, %d caller %pF",
1768                   MAJOR(__entry->dev), MINOR(__entry->dev),
1769                   __entry->blocks, (void *)__entry->ip)
1770 );
1771
1772 DECLARE_EVENT_CLASS(ext4__trim,
1773         TP_PROTO(struct super_block *sb,
1774                  ext4_group_t group,
1775                  ext4_grpblk_t start,
1776                  ext4_grpblk_t len),
1777
1778         TP_ARGS(sb, group, start, len),
1779
1780         TP_STRUCT__entry(
1781                 __field(        int,    dev_major               )
1782                 __field(        int,    dev_minor               )
1783                 __field(        __u32,  group                   )
1784                 __field(        int,    start                   )
1785                 __field(        int,    len                     )
1786         ),
1787
1788         TP_fast_assign(
1789                 __entry->dev_major      = MAJOR(sb->s_dev);
1790                 __entry->dev_minor      = MINOR(sb->s_dev);
1791                 __entry->group          = group;
1792                 __entry->start          = start;
1793                 __entry->len            = len;
1794         ),
1795
1796         TP_printk("dev %d,%d group %u, start %d, len %d",
1797                   __entry->dev_major, __entry->dev_minor,
1798                   __entry->group, __entry->start, __entry->len)
1799 );
1800
1801 DEFINE_EVENT(ext4__trim, ext4_trim_extent,
1802
1803         TP_PROTO(struct super_block *sb,
1804                  ext4_group_t group,
1805                  ext4_grpblk_t start,
1806                  ext4_grpblk_t len),
1807
1808         TP_ARGS(sb, group, start, len)
1809 );
1810
1811 DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
1812
1813         TP_PROTO(struct super_block *sb,
1814                  ext4_group_t group,
1815                  ext4_grpblk_t start,
1816                  ext4_grpblk_t len),
1817
1818         TP_ARGS(sb, group, start, len)
1819 );
1820
1821 TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
1822         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags,
1823                  unsigned int allocated, ext4_fsblk_t newblock),
1824
1825         TP_ARGS(inode, map, flags, allocated, newblock),
1826
1827         TP_STRUCT__entry(
1828                 __field(        dev_t,          dev             )
1829                 __field(        ino_t,          ino             )
1830                 __field(        int,            flags           )
1831                 __field(        ext4_lblk_t,    lblk            )
1832                 __field(        ext4_fsblk_t,   pblk            )
1833                 __field(        unsigned int,   len             )
1834                 __field(        unsigned int,   allocated       )
1835                 __field(        ext4_fsblk_t,   newblk          )
1836         ),
1837
1838         TP_fast_assign(
1839                 __entry->dev            = inode->i_sb->s_dev;
1840                 __entry->ino            = inode->i_ino;
1841                 __entry->flags          = flags;
1842                 __entry->lblk           = map->m_lblk;
1843                 __entry->pblk           = map->m_pblk;
1844                 __entry->len            = map->m_len;
1845                 __entry->allocated      = allocated;
1846                 __entry->newblk         = newblock;
1847         ),
1848
1849         TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %s "
1850                   "allocated %d newblock %llu",
1851                   MAJOR(__entry->dev), MINOR(__entry->dev),
1852                   (unsigned long) __entry->ino,
1853                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
1854                   __entry->len, show_map_flags(__entry->flags),
1855                   (unsigned int) __entry->allocated,
1856                   (unsigned long long) __entry->newblk)
1857 );
1858
1859 TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
1860         TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
1861
1862         TP_ARGS(sb, map, ret),
1863
1864         TP_STRUCT__entry(
1865                 __field(        dev_t,          dev     )
1866                 __field(        unsigned int,   flags   )
1867                 __field(        ext4_lblk_t,    lblk    )
1868                 __field(        ext4_fsblk_t,   pblk    )
1869                 __field(        unsigned int,   len     )
1870                 __field(        int,            ret     )
1871         ),
1872
1873         TP_fast_assign(
1874                 __entry->dev    = sb->s_dev;
1875                 __entry->flags  = map->m_flags;
1876                 __entry->lblk   = map->m_lblk;
1877                 __entry->pblk   = map->m_pblk;
1878                 __entry->len    = map->m_len;
1879                 __entry->ret    = ret;
1880         ),
1881
1882         TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %s ret %d",
1883                   MAJOR(__entry->dev), MINOR(__entry->dev),
1884                   __entry->lblk, (unsigned long long) __entry->pblk,
1885                   __entry->len, show_mflags(__entry->flags), __entry->ret)
1886 );
1887
1888 TRACE_EVENT(ext4_ext_put_in_cache,
1889         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
1890                  ext4_fsblk_t start),
1891
1892         TP_ARGS(inode, lblk, len, start),
1893
1894         TP_STRUCT__entry(
1895                 __field(        dev_t,          dev     )
1896                 __field(        ino_t,          ino     )
1897                 __field(        ext4_lblk_t,    lblk    )
1898                 __field(        unsigned int,   len     )
1899                 __field(        ext4_fsblk_t,   start   )
1900         ),
1901
1902         TP_fast_assign(
1903                 __entry->dev    = inode->i_sb->s_dev;
1904                 __entry->ino    = inode->i_ino;
1905                 __entry->lblk   = lblk;
1906                 __entry->len    = len;
1907                 __entry->start  = start;
1908         ),
1909
1910         TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
1911                   MAJOR(__entry->dev), MINOR(__entry->dev),
1912                   (unsigned long) __entry->ino,
1913                   (unsigned) __entry->lblk,
1914                   __entry->len,
1915                   (unsigned long long) __entry->start)
1916 );
1917
1918 TRACE_EVENT(ext4_ext_in_cache,
1919         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
1920
1921         TP_ARGS(inode, lblk, ret),
1922
1923         TP_STRUCT__entry(
1924                 __field(        dev_t,          dev     )
1925                 __field(        ino_t,          ino     )
1926                 __field(        ext4_lblk_t,    lblk    )
1927                 __field(        int,            ret     )
1928         ),
1929
1930         TP_fast_assign(
1931                 __entry->dev    = inode->i_sb->s_dev;
1932                 __entry->ino    = inode->i_ino;
1933                 __entry->lblk   = lblk;
1934                 __entry->ret    = ret;
1935         ),
1936
1937         TP_printk("dev %d,%d ino %lu lblk %u ret %d",
1938                   MAJOR(__entry->dev), MINOR(__entry->dev),
1939                   (unsigned long) __entry->ino,
1940                   (unsigned) __entry->lblk,
1941                   __entry->ret)
1942
1943 );
1944
1945 TRACE_EVENT(ext4_find_delalloc_range,
1946         TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
1947                 int reverse, int found, ext4_lblk_t found_blk),
1948
1949         TP_ARGS(inode, from, to, reverse, found, found_blk),
1950
1951         TP_STRUCT__entry(
1952                 __field(        dev_t,          dev             )
1953                 __field(        ino_t,          ino             )
1954                 __field(        ext4_lblk_t,    from            )
1955                 __field(        ext4_lblk_t,    to              )
1956                 __field(        int,            reverse         )
1957                 __field(        int,            found           )
1958                 __field(        ext4_lblk_t,    found_blk       )
1959         ),
1960
1961         TP_fast_assign(
1962                 __entry->dev            = inode->i_sb->s_dev;
1963                 __entry->ino            = inode->i_ino;
1964                 __entry->from           = from;
1965                 __entry->to             = to;
1966                 __entry->reverse        = reverse;
1967                 __entry->found          = found;
1968                 __entry->found_blk      = found_blk;
1969         ),
1970
1971         TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
1972                   "(blk = %u)",
1973                   MAJOR(__entry->dev), MINOR(__entry->dev),
1974                   (unsigned long) __entry->ino,
1975                   (unsigned) __entry->from, (unsigned) __entry->to,
1976                   __entry->reverse, __entry->found,
1977                   (unsigned) __entry->found_blk)
1978 );
1979
1980 TRACE_EVENT(ext4_get_reserved_cluster_alloc,
1981         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
1982
1983         TP_ARGS(inode, lblk, len),
1984
1985         TP_STRUCT__entry(
1986                 __field(        dev_t,          dev     )
1987                 __field(        ino_t,          ino     )
1988                 __field(        ext4_lblk_t,    lblk    )
1989                 __field(        unsigned int,   len     )
1990         ),
1991
1992         TP_fast_assign(
1993                 __entry->dev    = inode->i_sb->s_dev;
1994                 __entry->ino    = inode->i_ino;
1995                 __entry->lblk   = lblk;
1996                 __entry->len    = len;
1997         ),
1998
1999         TP_printk("dev %d,%d ino %lu lblk %u len %u",
2000                   MAJOR(__entry->dev), MINOR(__entry->dev),
2001                   (unsigned long) __entry->ino,
2002                   (unsigned) __entry->lblk,
2003                   __entry->len)
2004 );
2005
2006 TRACE_EVENT(ext4_ext_show_extent,
2007         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
2008                  unsigned short len),
2009
2010         TP_ARGS(inode, lblk, pblk, len),
2011
2012         TP_STRUCT__entry(
2013                 __field(        dev_t,          dev     )
2014                 __field(        ino_t,          ino     )
2015                 __field(        ext4_fsblk_t,   pblk    )
2016                 __field(        ext4_lblk_t,    lblk    )
2017                 __field(        unsigned short, len     )
2018         ),
2019
2020         TP_fast_assign(
2021                 __entry->dev    = inode->i_sb->s_dev;
2022                 __entry->ino    = inode->i_ino;
2023                 __entry->pblk   = pblk;
2024                 __entry->lblk   = lblk;
2025                 __entry->len    = len;
2026         ),
2027
2028         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
2029                   MAJOR(__entry->dev), MINOR(__entry->dev),
2030                   (unsigned long) __entry->ino,
2031                   (unsigned) __entry->lblk,
2032                   (unsigned long long) __entry->pblk,
2033                   (unsigned short) __entry->len)
2034 );
2035
2036 TRACE_EVENT(ext4_remove_blocks,
2037             TP_PROTO(struct inode *inode, struct ext4_extent *ex,
2038                 ext4_lblk_t from, ext4_fsblk_t to,
2039                 long long partial_cluster),
2040
2041         TP_ARGS(inode, ex, from, to, partial_cluster),
2042
2043         TP_STRUCT__entry(
2044                 __field(        dev_t,          dev     )
2045                 __field(        ino_t,          ino     )
2046                 __field(        ext4_lblk_t,    from    )
2047                 __field(        ext4_lblk_t,    to      )
2048                 __field(        long long,      partial )
2049                 __field(        ext4_fsblk_t,   ee_pblk )
2050                 __field(        ext4_lblk_t,    ee_lblk )
2051                 __field(        unsigned short, ee_len  )
2052         ),
2053
2054         TP_fast_assign(
2055                 __entry->dev            = inode->i_sb->s_dev;
2056                 __entry->ino            = inode->i_ino;
2057                 __entry->from           = from;
2058                 __entry->to             = to;
2059                 __entry->partial        = partial_cluster;
2060                 __entry->ee_pblk        = ext4_ext_pblock(ex);
2061                 __entry->ee_lblk        = le32_to_cpu(ex->ee_block);
2062                 __entry->ee_len         = ext4_ext_get_actual_len(ex);
2063         ),
2064
2065         TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
2066                   "from %u to %u partial_cluster %lld",
2067                   MAJOR(__entry->dev), MINOR(__entry->dev),
2068                   (unsigned long) __entry->ino,
2069                   (unsigned) __entry->ee_lblk,
2070                   (unsigned long long) __entry->ee_pblk,
2071                   (unsigned short) __entry->ee_len,
2072                   (unsigned) __entry->from,
2073                   (unsigned) __entry->to,
2074                   (long long) __entry->partial)
2075 );
2076
2077 TRACE_EVENT(ext4_ext_rm_leaf,
2078         TP_PROTO(struct inode *inode, ext4_lblk_t start,
2079                  struct ext4_extent *ex,
2080                  long long partial_cluster),
2081
2082         TP_ARGS(inode, start, ex, partial_cluster),
2083
2084         TP_STRUCT__entry(
2085                 __field(        dev_t,          dev     )
2086                 __field(        ino_t,          ino     )
2087                 __field(        long long,      partial )
2088                 __field(        ext4_lblk_t,    start   )
2089                 __field(        ext4_lblk_t,    ee_lblk )
2090                 __field(        ext4_fsblk_t,   ee_pblk )
2091                 __field(        short,          ee_len  )
2092         ),
2093
2094         TP_fast_assign(
2095                 __entry->dev            = inode->i_sb->s_dev;
2096                 __entry->ino            = inode->i_ino;
2097                 __entry->partial        = partial_cluster;
2098                 __entry->start          = start;
2099                 __entry->ee_lblk        = le32_to_cpu(ex->ee_block);
2100                 __entry->ee_pblk        = ext4_ext_pblock(ex);
2101                 __entry->ee_len         = ext4_ext_get_actual_len(ex);
2102         ),
2103
2104         TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
2105                   "partial_cluster %lld",
2106                   MAJOR(__entry->dev), MINOR(__entry->dev),
2107                   (unsigned long) __entry->ino,
2108                   (unsigned) __entry->start,
2109                   (unsigned) __entry->ee_lblk,
2110                   (unsigned long long) __entry->ee_pblk,
2111                   (unsigned short) __entry->ee_len,
2112                   (long long) __entry->partial)
2113 );
2114
2115 TRACE_EVENT(ext4_ext_rm_idx,
2116         TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
2117
2118         TP_ARGS(inode, pblk),
2119
2120         TP_STRUCT__entry(
2121                 __field(        dev_t,          dev     )
2122                 __field(        ino_t,          ino     )
2123                 __field(        ext4_fsblk_t,   pblk    )
2124         ),
2125
2126         TP_fast_assign(
2127                 __entry->dev    = inode->i_sb->s_dev;
2128                 __entry->ino    = inode->i_ino;
2129                 __entry->pblk   = pblk;
2130         ),
2131
2132         TP_printk("dev %d,%d ino %lu index_pblk %llu",
2133                   MAJOR(__entry->dev), MINOR(__entry->dev),
2134                   (unsigned long) __entry->ino,
2135                   (unsigned long long) __entry->pblk)
2136 );
2137
2138 TRACE_EVENT(ext4_ext_remove_space,
2139         TP_PROTO(struct inode *inode, ext4_lblk_t start,
2140                  ext4_lblk_t end, int depth),
2141
2142         TP_ARGS(inode, start, end, depth),
2143
2144         TP_STRUCT__entry(
2145                 __field(        dev_t,          dev     )
2146                 __field(        ino_t,          ino     )
2147                 __field(        ext4_lblk_t,    start   )
2148                 __field(        ext4_lblk_t,    end     )
2149                 __field(        int,            depth   )
2150         ),
2151
2152         TP_fast_assign(
2153                 __entry->dev    = inode->i_sb->s_dev;
2154                 __entry->ino    = inode->i_ino;
2155                 __entry->start  = start;
2156                 __entry->end    = end;
2157                 __entry->depth  = depth;
2158         ),
2159
2160         TP_printk("dev %d,%d ino %lu since %u end %u depth %d",
2161                   MAJOR(__entry->dev), MINOR(__entry->dev),
2162                   (unsigned long) __entry->ino,
2163                   (unsigned) __entry->start,
2164                   (unsigned) __entry->end,
2165                   __entry->depth)
2166 );
2167
2168 TRACE_EVENT(ext4_ext_remove_space_done,
2169         TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end,
2170                  int depth, long long partial, __le16 eh_entries),
2171
2172         TP_ARGS(inode, start, end, depth, partial, eh_entries),
2173
2174         TP_STRUCT__entry(
2175                 __field(        dev_t,          dev             )
2176                 __field(        ino_t,          ino             )
2177                 __field(        ext4_lblk_t,    start           )
2178                 __field(        ext4_lblk_t,    end             )
2179                 __field(        int,            depth           )
2180                 __field(        long long,      partial         )
2181                 __field(        unsigned short, eh_entries      )
2182         ),
2183
2184         TP_fast_assign(
2185                 __entry->dev            = inode->i_sb->s_dev;
2186                 __entry->ino            = inode->i_ino;
2187                 __entry->start          = start;
2188                 __entry->end            = end;
2189                 __entry->depth          = depth;
2190                 __entry->partial        = partial;
2191                 __entry->eh_entries     = le16_to_cpu(eh_entries);
2192         ),
2193
2194         TP_printk("dev %d,%d ino %lu since %u end %u depth %d partial %lld "
2195                   "remaining_entries %u",
2196                   MAJOR(__entry->dev), MINOR(__entry->dev),
2197                   (unsigned long) __entry->ino,
2198                   (unsigned) __entry->start,
2199                   (unsigned) __entry->end,
2200                   __entry->depth,
2201                   (long long) __entry->partial,
2202                   (unsigned short) __entry->eh_entries)
2203 );
2204
2205 DECLARE_EVENT_CLASS(ext4__es_extent,
2206         TP_PROTO(struct inode *inode, struct extent_status *es),
2207
2208         TP_ARGS(inode, es),
2209
2210         TP_STRUCT__entry(
2211                 __field(        dev_t,          dev             )
2212                 __field(        ino_t,          ino             )
2213                 __field(        ext4_lblk_t,    lblk            )
2214                 __field(        ext4_lblk_t,    len             )
2215                 __field(        ext4_fsblk_t,   pblk            )
2216                 __field(        char, status    )
2217         ),
2218
2219         TP_fast_assign(
2220                 __entry->dev    = inode->i_sb->s_dev;
2221                 __entry->ino    = inode->i_ino;
2222                 __entry->lblk   = es->es_lblk;
2223                 __entry->len    = es->es_len;
2224                 __entry->pblk   = ext4_es_pblock(es);
2225                 __entry->status = ext4_es_status(es);
2226         ),
2227
2228         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
2229                   MAJOR(__entry->dev), MINOR(__entry->dev),
2230                   (unsigned long) __entry->ino,
2231                   __entry->lblk, __entry->len,
2232                   __entry->pblk, show_extent_status(__entry->status))
2233 );
2234
2235 DEFINE_EVENT(ext4__es_extent, ext4_es_insert_extent,
2236         TP_PROTO(struct inode *inode, struct extent_status *es),
2237
2238         TP_ARGS(inode, es)
2239 );
2240
2241 DEFINE_EVENT(ext4__es_extent, ext4_es_cache_extent,
2242         TP_PROTO(struct inode *inode, struct extent_status *es),
2243
2244         TP_ARGS(inode, es)
2245 );
2246
2247 TRACE_EVENT(ext4_es_remove_extent,
2248         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
2249
2250         TP_ARGS(inode, lblk, len),
2251
2252         TP_STRUCT__entry(
2253                 __field(        dev_t,  dev                     )
2254                 __field(        ino_t,  ino                     )
2255                 __field(        loff_t, lblk                    )
2256                 __field(        loff_t, len                     )
2257         ),
2258
2259         TP_fast_assign(
2260                 __entry->dev    = inode->i_sb->s_dev;
2261                 __entry->ino    = inode->i_ino;
2262                 __entry->lblk   = lblk;
2263                 __entry->len    = len;
2264         ),
2265
2266         TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
2267                   MAJOR(__entry->dev), MINOR(__entry->dev),
2268                   (unsigned long) __entry->ino,
2269                   __entry->lblk, __entry->len)
2270 );
2271
2272 TRACE_EVENT(ext4_es_find_delayed_extent_range_enter,
2273         TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
2274
2275         TP_ARGS(inode, lblk),
2276
2277         TP_STRUCT__entry(
2278                 __field(        dev_t,          dev             )
2279                 __field(        ino_t,          ino             )
2280                 __field(        ext4_lblk_t,    lblk            )
2281         ),
2282
2283         TP_fast_assign(
2284                 __entry->dev    = inode->i_sb->s_dev;
2285                 __entry->ino    = inode->i_ino;
2286                 __entry->lblk   = lblk;
2287         ),
2288
2289         TP_printk("dev %d,%d ino %lu lblk %u",
2290                   MAJOR(__entry->dev), MINOR(__entry->dev),
2291                   (unsigned long) __entry->ino, __entry->lblk)
2292 );
2293
2294 TRACE_EVENT(ext4_es_find_delayed_extent_range_exit,
2295         TP_PROTO(struct inode *inode, struct extent_status *es),
2296
2297         TP_ARGS(inode, es),
2298
2299         TP_STRUCT__entry(
2300                 __field(        dev_t,          dev             )
2301                 __field(        ino_t,          ino             )
2302                 __field(        ext4_lblk_t,    lblk            )
2303                 __field(        ext4_lblk_t,    len             )
2304                 __field(        ext4_fsblk_t,   pblk            )
2305                 __field(        char, status    )
2306         ),
2307
2308         TP_fast_assign(
2309                 __entry->dev    = inode->i_sb->s_dev;
2310                 __entry->ino    = inode->i_ino;
2311                 __entry->lblk   = es->es_lblk;
2312                 __entry->len    = es->es_len;
2313                 __entry->pblk   = ext4_es_pblock(es);
2314                 __entry->status = ext4_es_status(es);
2315         ),
2316
2317         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
2318                   MAJOR(__entry->dev), MINOR(__entry->dev),
2319                   (unsigned long) __entry->ino,
2320                   __entry->lblk, __entry->len,
2321                   __entry->pblk, show_extent_status(__entry->status))
2322 );
2323
2324 TRACE_EVENT(ext4_es_lookup_extent_enter,
2325         TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
2326
2327         TP_ARGS(inode, lblk),
2328
2329         TP_STRUCT__entry(
2330                 __field(        dev_t,          dev             )
2331                 __field(        ino_t,          ino             )
2332                 __field(        ext4_lblk_t,    lblk            )
2333         ),
2334
2335         TP_fast_assign(
2336                 __entry->dev    = inode->i_sb->s_dev;
2337                 __entry->ino    = inode->i_ino;
2338                 __entry->lblk   = lblk;
2339         ),
2340
2341         TP_printk("dev %d,%d ino %lu lblk %u",
2342                   MAJOR(__entry->dev), MINOR(__entry->dev),
2343                   (unsigned long) __entry->ino, __entry->lblk)
2344 );
2345
2346 TRACE_EVENT(ext4_es_lookup_extent_exit,
2347         TP_PROTO(struct inode *inode, struct extent_status *es,
2348                  int found),
2349
2350         TP_ARGS(inode, es, found),
2351
2352         TP_STRUCT__entry(
2353                 __field(        dev_t,          dev             )
2354                 __field(        ino_t,          ino             )
2355                 __field(        ext4_lblk_t,    lblk            )
2356                 __field(        ext4_lblk_t,    len             )
2357                 __field(        ext4_fsblk_t,   pblk            )
2358                 __field(        char,           status          )
2359                 __field(        int,            found           )
2360         ),
2361
2362         TP_fast_assign(
2363                 __entry->dev    = inode->i_sb->s_dev;
2364                 __entry->ino    = inode->i_ino;
2365                 __entry->lblk   = es->es_lblk;
2366                 __entry->len    = es->es_len;
2367                 __entry->pblk   = ext4_es_pblock(es);
2368                 __entry->status = ext4_es_status(es);
2369                 __entry->found  = found;
2370         ),
2371
2372         TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %s",
2373                   MAJOR(__entry->dev), MINOR(__entry->dev),
2374                   (unsigned long) __entry->ino, __entry->found,
2375                   __entry->lblk, __entry->len,
2376                   __entry->found ? __entry->pblk : 0,
2377                   show_extent_status(__entry->found ? __entry->status : 0))
2378 );
2379
2380 TRACE_EVENT(ext4_es_shrink_enter,
2381         TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
2382
2383         TP_ARGS(sb, nr_to_scan, cache_cnt),
2384
2385         TP_STRUCT__entry(
2386                 __field(        dev_t,  dev                     )
2387                 __field(        int,    nr_to_scan              )
2388                 __field(        int,    cache_cnt               )
2389         ),
2390
2391         TP_fast_assign(
2392                 __entry->dev            = sb->s_dev;
2393                 __entry->nr_to_scan     = nr_to_scan;
2394                 __entry->cache_cnt      = cache_cnt;
2395         ),
2396
2397         TP_printk("dev %d,%d nr_to_scan %d cache_cnt %d",
2398                   MAJOR(__entry->dev), MINOR(__entry->dev),
2399                   __entry->nr_to_scan, __entry->cache_cnt)
2400 );
2401
2402 TRACE_EVENT(ext4_es_shrink_exit,
2403         TP_PROTO(struct super_block *sb, int shrunk_nr, int cache_cnt),
2404
2405         TP_ARGS(sb, shrunk_nr, cache_cnt),
2406
2407         TP_STRUCT__entry(
2408                 __field(        dev_t,  dev                     )
2409                 __field(        int,    shrunk_nr               )
2410                 __field(        int,    cache_cnt               )
2411         ),
2412
2413         TP_fast_assign(
2414                 __entry->dev            = sb->s_dev;
2415                 __entry->shrunk_nr      = shrunk_nr;
2416                 __entry->cache_cnt      = cache_cnt;
2417         ),
2418
2419         TP_printk("dev %d,%d shrunk_nr %d cache_cnt %d",
2420                   MAJOR(__entry->dev), MINOR(__entry->dev),
2421                   __entry->shrunk_nr, __entry->cache_cnt)
2422 );
2423
2424 TRACE_EVENT(ext4_collapse_range,
2425         TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
2426
2427         TP_ARGS(inode, offset, len),
2428
2429         TP_STRUCT__entry(
2430                 __field(dev_t,  dev)
2431                 __field(ino_t,  ino)
2432                 __field(loff_t, offset)
2433                 __field(loff_t, len)
2434         ),
2435
2436         TP_fast_assign(
2437                 __entry->dev    = inode->i_sb->s_dev;
2438                 __entry->ino    = inode->i_ino;
2439                 __entry->offset = offset;
2440                 __entry->len    = len;
2441         ),
2442
2443         TP_printk("dev %d,%d ino %lu offset %lld len %lld",
2444                   MAJOR(__entry->dev), MINOR(__entry->dev),
2445                   (unsigned long) __entry->ino,
2446                   __entry->offset, __entry->len)
2447 );
2448
2449 #endif /* _TRACE_EXT4_H */
2450
2451 /* This part must be outside protection */
2452 #include <trace/define_trace.h>