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