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 TRACE_EVENT(ext4_invalidatepage,
 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 TRACE_EVENT(ext4_discard_blocks,
 481         TP_PROTO(struct super_block *sb, unsigned long long blk,
 482                         unsigned long long count),
 483
 484         TP_ARGS(sb, blk, count),
 485
 486         TP_STRUCT__entry(
 487                 __field(        dev_t,  dev                     )
 488                 __field(        __u64,  blk                     )
 489                 __field(        __u64,  count                   )
 490
 491         ),
 492
 493         TP_fast_assign(
 494                 __entry->dev    = sb->s_dev;
 495                 __entry->blk    = blk;
 496                 __entry->count  = count;
 497         ),
 498
 499         TP_printk("dev %d,%d blk %llu count %llu",
 500                   MAJOR(__entry->dev), MINOR(__entry->dev),
 501                   __entry->blk, __entry->count)
 502 );
 503
 504 DECLARE_EVENT_CLASS(ext4__mb_new_pa,
 505         TP_PROTO(struct ext4_allocation_context *ac,
 506                  struct ext4_prealloc_space *pa),
 507
 508         TP_ARGS(ac, pa),
 509
 510         TP_STRUCT__entry(
 511                 __field(        dev_t,  dev                     )
 512                 __field(        ino_t,  ino                     )
 513                 __field(        __u64,  pa_pstart               )
 514                 __field(        __u64,  pa_lstart               )
 515                 __field(        __u32,  pa_len                  )
 516
 517         ),
 518
 519         TP_fast_assign(
 520                 __entry->dev            = ac->ac_sb->s_dev;
 521                 __entry->ino            = ac->ac_inode->i_ino;
 522                 __entry->pa_pstart      = pa->pa_pstart;
 523                 __entry->pa_lstart      = pa->pa_lstart;
 524                 __entry->pa_len         = pa->pa_len;
 525         ),
 526
 527         TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
 528                   MAJOR(__entry->dev), MINOR(__entry->dev),
 529                   (unsigned long) __entry->ino,
 530                   __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 531 );
 532
 533 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
 534
 535         TP_PROTO(struct ext4_allocation_context *ac,
 536                  struct ext4_prealloc_space *pa),
 537
 538         TP_ARGS(ac, pa)
 539 );
 540
 541 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
 542
 543         TP_PROTO(struct ext4_allocation_context *ac,
 544                  struct ext4_prealloc_space *pa),
 545
 546         TP_ARGS(ac, pa)
 547 );
 548
 549 TRACE_EVENT(ext4_mb_release_inode_pa,
 550         TP_PROTO(struct ext4_prealloc_space *pa,
 551                  unsigned long long block, unsigned int count),
 552
 553         TP_ARGS(pa, block, count),
 554
 555         TP_STRUCT__entry(
 556                 __field(        dev_t,  dev                     )
 557                 __field(        ino_t,  ino                     )
 558                 __field(        __u64,  block                   )
 559                 __field(        __u32,  count                   )
 560
 561         ),
 562
 563         TP_fast_assign(
 564                 __entry->dev            = pa->pa_inode->i_sb->s_dev;
 565                 __entry->ino            = pa->pa_inode->i_ino;
 566                 __entry->block          = block;
 567                 __entry->count          = count;
 568         ),
 569
 570         TP_printk("dev %d,%d ino %lu block %llu count %u",
 571                   MAJOR(__entry->dev), MINOR(__entry->dev),
 572                   (unsigned long) __entry->ino,
 573                   __entry->block, __entry->count)
 574 );
 575
 576 TRACE_EVENT(ext4_mb_release_group_pa,
 577         TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
 578
 579         TP_ARGS(sb, pa),
 580
 581         TP_STRUCT__entry(
 582                 __field(        dev_t,  dev                     )
 583                 __field(        __u64,  pa_pstart               )
 584                 __field(        __u32,  pa_len                  )
 585
 586         ),
 587
 588         TP_fast_assign(
 589                 __entry->dev            = sb->s_dev;
 590                 __entry->pa_pstart      = pa->pa_pstart;
 591                 __entry->pa_len         = pa->pa_len;
 592         ),
 593
 594         TP_printk("dev %d,%d pstart %llu len %u",
 595                   MAJOR(__entry->dev), MINOR(__entry->dev),
 596                   __entry->pa_pstart, __entry->pa_len)
 597 );
 598
 599 TRACE_EVENT(ext4_discard_preallocations,
 600         TP_PROTO(struct inode *inode),
 601
 602         TP_ARGS(inode),
 603
 604         TP_STRUCT__entry(
 605                 __field(        dev_t,  dev                     )
 606                 __field(        ino_t,  ino                     )
 607
 608         ),
 609
 610         TP_fast_assign(
 611                 __entry->dev    = inode->i_sb->s_dev;
 612                 __entry->ino    = inode->i_ino;
 613         ),
 614
 615         TP_printk("dev %d,%d ino %lu",
 616                   MAJOR(__entry->dev), MINOR(__entry->dev),
 617                   (unsigned long) __entry->ino)
 618 );
 619
 620 TRACE_EVENT(ext4_mb_discard_preallocations,
 621         TP_PROTO(struct super_block *sb, int needed),
 622
 623         TP_ARGS(sb, needed),
 624
 625         TP_STRUCT__entry(
 626                 __field(        dev_t,  dev                     )
 627                 __field(        int,    needed                  )
 628
 629         ),
 630
 631         TP_fast_assign(
 632                 __entry->dev    = sb->s_dev;
 633                 __entry->needed = needed;
 634         ),
 635
 636         TP_printk("dev %d,%d needed %d",
 637                   MAJOR(__entry->dev), MINOR(__entry->dev),
 638                   __entry->needed)
 639 );
 640
 641 TRACE_EVENT(ext4_request_blocks,
 642         TP_PROTO(struct ext4_allocation_request *ar),
 643
 644         TP_ARGS(ar),
 645
 646         TP_STRUCT__entry(
 647                 __field(        dev_t,  dev                     )
 648                 __field(        ino_t,  ino                     )
 649                 __field(        unsigned int, len               )
 650                 __field(        __u32,  logical                 )
 651                 __field(        __u32,  lleft                   )
 652                 __field(        __u32,  lright                  )
 653                 __field(        __u64,  goal                    )
 654                 __field(        __u64,  pleft                   )
 655                 __field(        __u64,  pright                  )
 656                 __field(        unsigned int, flags             )
 657         ),
 658
 659         TP_fast_assign(
 660                 __entry->dev    = ar->inode->i_sb->s_dev;
 661                 __entry->ino    = ar->inode->i_ino;
 662                 __entry->len    = ar->len;
 663                 __entry->logical = ar->logical;
 664                 __entry->goal   = ar->goal;
 665                 __entry->lleft  = ar->lleft;
 666                 __entry->lright = ar->lright;
 667                 __entry->pleft  = ar->pleft;
 668                 __entry->pright = ar->pright;
 669                 __entry->flags  = ar->flags;
 670         ),
 671
 672         TP_printk("dev %d,%d ino %lu flags %u len %u lblk %u goal %llu "
 673                   "lleft %u lright %u pleft %llu pright %llu ",
 674                   MAJOR(__entry->dev), MINOR(__entry->dev),
 675                   (unsigned long) __entry->ino, __entry->flags,
 676                   __entry->len, __entry->logical, __entry->goal,
 677                   __entry->lleft, __entry->lright, __entry->pleft,
 678                   __entry->pright)
 679 );
 680
 681 TRACE_EVENT(ext4_allocate_blocks,
 682         TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
 683
 684         TP_ARGS(ar, block),
 685
 686         TP_STRUCT__entry(
 687                 __field(        dev_t,  dev                     )
 688                 __field(        ino_t,  ino                     )
 689                 __field(        __u64,  block                   )
 690                 __field(        unsigned int, len               )
 691                 __field(        __u32,  logical                 )
 692                 __field(        __u32,  lleft                   )
 693                 __field(        __u32,  lright                  )
 694                 __field(        __u64,  goal                    )
 695                 __field(        __u64,  pleft                   )
 696                 __field(        __u64,  pright                  )
 697                 __field(        unsigned int, flags             )
 698         ),
 699
 700         TP_fast_assign(
 701                 __entry->dev    = ar->inode->i_sb->s_dev;
 702                 __entry->ino    = ar->inode->i_ino;
 703                 __entry->block  = block;
 704                 __entry->len    = ar->len;
 705                 __entry->logical = ar->logical;
 706                 __entry->goal   = ar->goal;
 707                 __entry->lleft  = ar->lleft;
 708                 __entry->lright = ar->lright;
 709                 __entry->pleft  = ar->pleft;
 710                 __entry->pright = ar->pright;
 711                 __entry->flags  = ar->flags;
 712         ),
 713
 714         TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %u "
 715                   "goal %llu lleft %u lright %u pleft %llu pright %llu",
 716                   MAJOR(__entry->dev), MINOR(__entry->dev),
 717                   (unsigned long) __entry->ino, __entry->flags,
 718                   __entry->len, __entry->block, __entry->logical,
 719                   __entry->goal,  __entry->lleft, __entry->lright,
 720                   __entry->pleft, __entry->pright)
 721 );
 722
 723 TRACE_EVENT(ext4_free_blocks,
 724         TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
 725                  int flags),
 726
 727         TP_ARGS(inode, block, count, flags),
 728
 729         TP_STRUCT__entry(
 730                 __field(        dev_t,  dev                     )
 731                 __field(        ino_t,  ino                     )
 732                 __field(        __u64,  block                   )
 733                 __field(        unsigned long,  count           )
 734                 __field(        int,    flags                   )
 735                 __field(        __u16,  mode                    )
 736         ),
 737
 738         TP_fast_assign(
 739                 __entry->dev            = inode->i_sb->s_dev;
 740                 __entry->ino            = inode->i_ino;
 741                 __entry->block          = block;
 742                 __entry->count          = count;
 743                 __entry->flags          = flags;
 744                 __entry->mode           = inode->i_mode;
 745         ),
 746
 747         TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
 748                   MAJOR(__entry->dev), MINOR(__entry->dev),
 749                   (unsigned long) __entry->ino,
 750                   __entry->mode, __entry->block, __entry->count,
 751                   __entry->flags)
 752 );
 753
 754 TRACE_EVENT(ext4_sync_file_enter,
 755         TP_PROTO(struct file *file, int datasync),
 756
 757         TP_ARGS(file, datasync),
 758
 759         TP_STRUCT__entry(
 760                 __field(        dev_t,  dev                     )
 761                 __field(        ino_t,  ino                     )
 762                 __field(        ino_t,  parent                  )
 763                 __field(        int,    datasync                )
 764         ),
 765
 766         TP_fast_assign(
 767                 struct dentry *dentry = file->f_path.dentry;
 768
 769                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
 770                 __entry->ino            = dentry->d_inode->i_ino;
 771                 __entry->datasync       = datasync;
 772                 __entry->parent         = dentry->d_parent->d_inode->i_ino;
 773         ),
 774
 775         TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
 776                   MAJOR(__entry->dev), MINOR(__entry->dev),
 777                   (unsigned long) __entry->ino,
 778                   (unsigned long) __entry->parent, __entry->datasync)
 779 );
 780
 781 TRACE_EVENT(ext4_sync_file_exit,
 782         TP_PROTO(struct inode *inode, int ret),
 783
 784         TP_ARGS(inode, ret),
 785
 786         TP_STRUCT__entry(
 787                 __field(        dev_t,  dev                     )
 788                 __field(        ino_t,  ino                     )
 789                 __field(        int,    ret                     )
 790         ),
 791
 792         TP_fast_assign(
 793                 __entry->dev            = inode->i_sb->s_dev;
 794                 __entry->ino            = inode->i_ino;
 795                 __entry->ret            = ret;
 796         ),
 797
 798         TP_printk("dev %d,%d ino %lu ret %d",
 799                   MAJOR(__entry->dev), MINOR(__entry->dev),
 800                   (unsigned long) __entry->ino,
 801                   __entry->ret)
 802 );
 803
 804 TRACE_EVENT(ext4_sync_fs,
 805         TP_PROTO(struct super_block *sb, int wait),
 806
 807         TP_ARGS(sb, wait),
 808
 809         TP_STRUCT__entry(
 810                 __field(        dev_t,  dev                     )
 811                 __field(        int,    wait                    )
 812
 813         ),
 814
 815         TP_fast_assign(
 816                 __entry->dev    = sb->s_dev;
 817                 __entry->wait   = wait;
 818         ),
 819
 820         TP_printk("dev %d,%d wait %d",
 821                   MAJOR(__entry->dev), MINOR(__entry->dev),
 822                   __entry->wait)
 823 );
 824
 825 TRACE_EVENT(ext4_alloc_da_blocks,
 826         TP_PROTO(struct inode *inode),
 827
 828         TP_ARGS(inode),
 829
 830         TP_STRUCT__entry(
 831                 __field(        dev_t,  dev                     )
 832                 __field(        ino_t,  ino                     )
 833                 __field( unsigned int,  data_blocks     )
 834                 __field( unsigned int,  meta_blocks     )
 835         ),
 836
 837         TP_fast_assign(
 838                 __entry->dev    = inode->i_sb->s_dev;
 839                 __entry->ino    = inode->i_ino;
 840                 __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
 841                 __entry->meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
 842         ),
 843
 844         TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
 845                   MAJOR(__entry->dev), MINOR(__entry->dev),
 846                   (unsigned long) __entry->ino,
 847                   __entry->data_blocks, __entry->meta_blocks)
 848 );
 849
 850 TRACE_EVENT(ext4_mballoc_alloc,
 851         TP_PROTO(struct ext4_allocation_context *ac),
 852
 853         TP_ARGS(ac),
 854
 855         TP_STRUCT__entry(
 856                 __field(        dev_t,  dev                     )
 857                 __field(        ino_t,  ino                     )
 858                 __field(        __u32,  orig_logical            )
 859                 __field(          int,  orig_start              )
 860                 __field(        __u32,  orig_group              )
 861                 __field(          int,  orig_len                )
 862                 __field(        __u32,  goal_logical            )
 863                 __field(          int,  goal_start              )
 864                 __field(        __u32,  goal_group              )
 865                 __field(          int,  goal_len                )
 866                 __field(        __u32,  result_logical          )
 867                 __field(          int,  result_start            )
 868                 __field(        __u32,  result_group            )
 869                 __field(          int,  result_len              )
 870                 __field(        __u16,  found                   )
 871                 __field(        __u16,  groups                  )
 872                 __field(        __u16,  buddy                   )
 873                 __field(        __u16,  flags                   )
 874                 __field(        __u16,  tail                    )
 875                 __field(        __u8,   cr                      )
 876         ),
 877
 878         TP_fast_assign(
 879                 __entry->dev            = ac->ac_inode->i_sb->s_dev;
 880                 __entry->ino            = ac->ac_inode->i_ino;
 881                 __entry->orig_logical   = ac->ac_o_ex.fe_logical;
 882                 __entry->orig_start     = ac->ac_o_ex.fe_start;
 883                 __entry->orig_group     = ac->ac_o_ex.fe_group;
 884                 __entry->orig_len       = ac->ac_o_ex.fe_len;
 885                 __entry->goal_logical   = ac->ac_g_ex.fe_logical;
 886                 __entry->goal_start     = ac->ac_g_ex.fe_start;
 887                 __entry->goal_group     = ac->ac_g_ex.fe_group;
 888                 __entry->goal_len       = ac->ac_g_ex.fe_len;
 889                 __entry->result_logical = ac->ac_f_ex.fe_logical;
 890                 __entry->result_start   = ac->ac_f_ex.fe_start;
 891                 __entry->result_group   = ac->ac_f_ex.fe_group;
 892                 __entry->result_len     = ac->ac_f_ex.fe_len;
 893                 __entry->found          = ac->ac_found;
 894                 __entry->flags          = ac->ac_flags;
 895                 __entry->groups         = ac->ac_groups_scanned;
 896                 __entry->buddy          = ac->ac_buddy;
 897                 __entry->tail           = ac->ac_tail;
 898                 __entry->cr             = ac->ac_criteria;
 899         ),
 900
 901         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
 902                   "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
 903                   "tail %u broken %u",
 904                   MAJOR(__entry->dev), MINOR(__entry->dev),
 905                   (unsigned long) __entry->ino,
 906                   __entry->orig_group, __entry->orig_start,
 907                   __entry->orig_len, __entry->orig_logical,
 908                   __entry->goal_group, __entry->goal_start,
 909                   __entry->goal_len, __entry->goal_logical,
 910                   __entry->result_group, __entry->result_start,
 911                   __entry->result_len, __entry->result_logical,
 912                   __entry->found, __entry->groups, __entry->cr,
 913                   __entry->flags, __entry->tail,
 914                   __entry->buddy ? 1 << __entry->buddy : 0)
 915 );
 916
 917 TRACE_EVENT(ext4_mballoc_prealloc,
 918         TP_PROTO(struct ext4_allocation_context *ac),
 919
 920         TP_ARGS(ac),
 921
 922         TP_STRUCT__entry(
 923                 __field(        dev_t,  dev                     )
 924                 __field(        ino_t,  ino                     )
 925                 __field(        __u32,  orig_logical            )
 926                 __field(          int,  orig_start              )
 927                 __field(        __u32,  orig_group              )
 928                 __field(          int,  orig_len                )
 929                 __field(        __u32,  result_logical          )
 930                 __field(          int,  result_start            )
 931                 __field(        __u32,  result_group            )
 932                 __field(          int,  result_len              )
 933         ),
 934
 935         TP_fast_assign(
 936                 __entry->dev            = ac->ac_inode->i_sb->s_dev;
 937                 __entry->ino            = ac->ac_inode->i_ino;
 938                 __entry->orig_logical   = ac->ac_o_ex.fe_logical;
 939                 __entry->orig_start     = ac->ac_o_ex.fe_start;
 940                 __entry->orig_group     = ac->ac_o_ex.fe_group;
 941                 __entry->orig_len       = ac->ac_o_ex.fe_len;
 942                 __entry->result_logical = ac->ac_b_ex.fe_logical;
 943                 __entry->result_start   = ac->ac_b_ex.fe_start;
 944                 __entry->result_group   = ac->ac_b_ex.fe_group;
 945                 __entry->result_len     = ac->ac_b_ex.fe_len;
 946         ),
 947
 948         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
 949                   MAJOR(__entry->dev), MINOR(__entry->dev),
 950                   (unsigned long) __entry->ino,
 951                   __entry->orig_group, __entry->orig_start,
 952                   __entry->orig_len, __entry->orig_logical,
 953                   __entry->result_group, __entry->result_start,
 954                   __entry->result_len, __entry->result_logical)
 955 );
 956
 957 DECLARE_EVENT_CLASS(ext4__mballoc,
 958         TP_PROTO(struct super_block *sb,
 959                  struct inode *inode,
 960                  ext4_group_t group,
 961                  ext4_grpblk_t start,
 962                  ext4_grpblk_t len),
 963
 964         TP_ARGS(sb, inode, group, start, len),
 965
 966         TP_STRUCT__entry(
 967                 __field(        dev_t,  dev                     )
 968                 __field(        ino_t,  ino                     )
 969                 __field(          int,  result_start            )
 970                 __field(        __u32,  result_group            )
 971                 __field(          int,  result_len              )
 972         ),
 973
 974         TP_fast_assign(
 975                 __entry->dev            = sb->s_dev;
 976                 __entry->ino            = inode ? inode->i_ino : 0;
 977                 __entry->result_start   = start;
 978                 __entry->result_group   = group;
 979                 __entry->result_len     = len;
 980         ),
 981
 982         TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
 983                   MAJOR(__entry->dev), MINOR(__entry->dev),
 984                   (unsigned long) __entry->ino,
 985                   __entry->result_group, __entry->result_start,
 986                   __entry->result_len)
 987 );
 988
 989 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
 990
 991         TP_PROTO(struct super_block *sb,
 992                  struct inode *inode,
 993                  ext4_group_t group,
 994                  ext4_grpblk_t start,
 995                  ext4_grpblk_t len),
 996
 997         TP_ARGS(sb, inode, group, start, len)
 998 );
 999
1000 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
1001
1002         TP_PROTO(struct super_block *sb,
1003                  struct inode *inode,
1004                  ext4_group_t group,
1005                  ext4_grpblk_t start,
1006                  ext4_grpblk_t len),
1007
1008         TP_ARGS(sb, inode, group, start, len)
1009 );
1010
1011 TRACE_EVENT(ext4_forget,
1012         TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
1013
1014         TP_ARGS(inode, is_metadata, block),
1015
1016         TP_STRUCT__entry(
1017                 __field(        dev_t,  dev                     )
1018                 __field(        ino_t,  ino                     )
1019                 __field(        __u64,  block                   )
1020                 __field(        int,    is_metadata             )
1021                 __field(        __u16,  mode                    )
1022         ),
1023
1024         TP_fast_assign(
1025                 __entry->dev    = inode->i_sb->s_dev;
1026                 __entry->ino    = inode->i_ino;
1027                 __entry->block  = block;
1028                 __entry->is_metadata = is_metadata;
1029                 __entry->mode   = inode->i_mode;
1030         ),
1031
1032         TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1033                   MAJOR(__entry->dev), MINOR(__entry->dev),
1034                   (unsigned long) __entry->ino,
1035                   __entry->mode, __entry->is_metadata, __entry->block)
1036 );
1037
1038 TRACE_EVENT(ext4_da_update_reserve_space,
1039         TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
1040
1041         TP_ARGS(inode, used_blocks, quota_claim),
1042
1043         TP_STRUCT__entry(
1044                 __field(        dev_t,  dev                     )
1045                 __field(        ino_t,  ino                     )
1046                 __field(        __u64,  i_blocks                )
1047                 __field(        int,    used_blocks             )
1048                 __field(        int,    reserved_data_blocks    )
1049                 __field(        int,    reserved_meta_blocks    )
1050                 __field(        int,    allocated_meta_blocks   )
1051                 __field(        int,    quota_claim             )
1052                 __field(        __u16,  mode                    )
1053         ),
1054
1055         TP_fast_assign(
1056                 __entry->dev    = inode->i_sb->s_dev;
1057                 __entry->ino    = inode->i_ino;
1058                 __entry->i_blocks = inode->i_blocks;
1059                 __entry->used_blocks = used_blocks;
1060                 __entry->reserved_data_blocks =
1061                                 EXT4_I(inode)->i_reserved_data_blocks;
1062                 __entry->reserved_meta_blocks =
1063                                 EXT4_I(inode)->i_reserved_meta_blocks;
1064                 __entry->allocated_meta_blocks =
1065                                 EXT4_I(inode)->i_allocated_meta_blocks;
1066                 __entry->quota_claim = quota_claim;
1067                 __entry->mode   = inode->i_mode;
1068         ),
1069
1070         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1071                   "reserved_data_blocks %d reserved_meta_blocks %d "
1072                   "allocated_meta_blocks %d quota_claim %d",
1073                   MAJOR(__entry->dev), MINOR(__entry->dev),
1074                   (unsigned long) __entry->ino,
1075                   __entry->mode, __entry->i_blocks,
1076                   __entry->used_blocks, __entry->reserved_data_blocks,
1077                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks,
1078                   __entry->quota_claim)
1079 );
1080
1081 TRACE_EVENT(ext4_da_reserve_space,
1082         TP_PROTO(struct inode *inode, int md_needed),
1083
1084         TP_ARGS(inode, md_needed),
1085
1086         TP_STRUCT__entry(
1087                 __field(        dev_t,  dev                     )
1088                 __field(        ino_t,  ino                     )
1089                 __field(        __u64,  i_blocks                )
1090                 __field(        int,    md_needed               )
1091                 __field(        int,    reserved_data_blocks    )
1092                 __field(        int,    reserved_meta_blocks    )
1093                 __field(        __u16,  mode                    )
1094         ),
1095
1096         TP_fast_assign(
1097                 __entry->dev    = inode->i_sb->s_dev;
1098                 __entry->ino    = inode->i_ino;
1099                 __entry->i_blocks = inode->i_blocks;
1100                 __entry->md_needed = md_needed;
1101                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1102                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1103                 __entry->mode   = inode->i_mode;
1104         ),
1105
1106         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
1107                   "reserved_data_blocks %d reserved_meta_blocks %d",
1108                   MAJOR(__entry->dev), MINOR(__entry->dev),
1109                   (unsigned long) __entry->ino,
1110                   __entry->mode, __entry->i_blocks,
1111                   __entry->md_needed, __entry->reserved_data_blocks,
1112                   __entry->reserved_meta_blocks)
1113 );
1114
1115 TRACE_EVENT(ext4_da_release_space,
1116         TP_PROTO(struct inode *inode, int freed_blocks),
1117
1118         TP_ARGS(inode, freed_blocks),
1119
1120         TP_STRUCT__entry(
1121                 __field(        dev_t,  dev                     )
1122                 __field(        ino_t,  ino                     )
1123                 __field(        __u64,  i_blocks                )
1124                 __field(        int,    freed_blocks            )
1125                 __field(        int,    reserved_data_blocks    )
1126                 __field(        int,    reserved_meta_blocks    )
1127                 __field(        int,    allocated_meta_blocks   )
1128                 __field(        __u16,  mode                    )
1129         ),
1130
1131         TP_fast_assign(
1132                 __entry->dev    = inode->i_sb->s_dev;
1133                 __entry->ino    = inode->i_ino;
1134                 __entry->i_blocks = inode->i_blocks;
1135                 __entry->freed_blocks = freed_blocks;
1136                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1137                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1138                 __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
1139                 __entry->mode   = inode->i_mode;
1140         ),
1141
1142         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
1143                   "reserved_data_blocks %d reserved_meta_blocks %d "
1144                   "allocated_meta_blocks %d",
1145                   MAJOR(__entry->dev), MINOR(__entry->dev),
1146                   (unsigned long) __entry->ino,
1147                   __entry->mode, __entry->i_blocks,
1148                   __entry->freed_blocks, __entry->reserved_data_blocks,
1149                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1150 );
1151
1152 DECLARE_EVENT_CLASS(ext4__bitmap_load,
1153         TP_PROTO(struct super_block *sb, unsigned long group),
1154
1155         TP_ARGS(sb, group),
1156
1157         TP_STRUCT__entry(
1158                 __field(        dev_t,  dev                     )
1159                 __field(        __u32,  group                   )
1160
1161         ),
1162
1163         TP_fast_assign(
1164                 __entry->dev    = sb->s_dev;
1165                 __entry->group  = group;
1166         ),
1167
1168         TP_printk("dev %d,%d group %u",
1169                   MAJOR(__entry->dev), MINOR(__entry->dev),
1170                   __entry->group)
1171 );
1172
1173 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
1174
1175         TP_PROTO(struct super_block *sb, unsigned long group),
1176
1177         TP_ARGS(sb, group)
1178 );
1179
1180 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
1181
1182         TP_PROTO(struct super_block *sb, unsigned long group),
1183
1184         TP_ARGS(sb, group)
1185 );
1186
1187 DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
1188
1189         TP_PROTO(struct super_block *sb, unsigned long group),
1190
1191         TP_ARGS(sb, group)
1192 );
1193
1194 DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
1195
1196         TP_PROTO(struct super_block *sb, unsigned long group),
1197
1198         TP_ARGS(sb, group)
1199 );
1200
1201 TRACE_EVENT(ext4_direct_IO_enter,
1202         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
1203
1204         TP_ARGS(inode, offset, len, rw),
1205
1206         TP_STRUCT__entry(
1207                 __field(        dev_t,  dev                     )
1208                 __field(        ino_t,  ino                     )
1209                 __field(        loff_t, pos                     )
1210                 __field(        unsigned long,  len             )
1211                 __field(        int,    rw                      )
1212         ),
1213
1214         TP_fast_assign(
1215                 __entry->dev    = inode->i_sb->s_dev;
1216                 __entry->ino    = inode->i_ino;
1217                 __entry->pos    = offset;
1218                 __entry->len    = len;
1219                 __entry->rw     = rw;
1220         ),
1221
1222         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d",
1223                   MAJOR(__entry->dev), MINOR(__entry->dev),
1224                   (unsigned long) __entry->ino,
1225                   __entry->pos, __entry->len, __entry->rw)
1226 );
1227
1228 TRACE_EVENT(ext4_direct_IO_exit,
1229         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
1230                  int rw, int ret),
1231
1232         TP_ARGS(inode, offset, len, rw, ret),
1233
1234         TP_STRUCT__entry(
1235                 __field(        dev_t,  dev                     )
1236                 __field(        ino_t,  ino                     )
1237                 __field(        loff_t, pos                     )
1238                 __field(        unsigned long,  len             )
1239                 __field(        int,    rw                      )
1240                 __field(        int,    ret                     )
1241         ),
1242
1243         TP_fast_assign(
1244                 __entry->dev    = inode->i_sb->s_dev;
1245                 __entry->ino    = inode->i_ino;
1246                 __entry->pos    = offset;
1247                 __entry->len    = len;
1248                 __entry->rw     = rw;
1249                 __entry->ret    = ret;
1250         ),
1251
1252         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d ret %d",
1253                   MAJOR(__entry->dev), MINOR(__entry->dev),
1254                   (unsigned long) __entry->ino,
1255                   __entry->pos, __entry->len,
1256                   __entry->rw, __entry->ret)
1257 );
1258
1259 TRACE_EVENT(ext4_fallocate_enter,
1260         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1261
1262         TP_ARGS(inode, offset, len, mode),
1263
1264         TP_STRUCT__entry(
1265                 __field(        dev_t,  dev                     )
1266                 __field(        ino_t,  ino                     )
1267                 __field(        loff_t, pos                     )
1268                 __field(        loff_t, len                     )
1269                 __field(        int,    mode                    )
1270         ),
1271
1272         TP_fast_assign(
1273                 __entry->dev    = inode->i_sb->s_dev;
1274                 __entry->ino    = inode->i_ino;
1275                 __entry->pos    = offset;
1276                 __entry->len    = len;
1277                 __entry->mode   = mode;
1278         ),
1279
1280         TP_printk("dev %d,%d ino %lu pos %lld len %lld mode %d",
1281                   MAJOR(__entry->dev), MINOR(__entry->dev),
1282                   (unsigned long) __entry->ino, __entry->pos,
1283                   __entry->len, __entry->mode)
1284 );
1285
1286 TRACE_EVENT(ext4_fallocate_exit,
1287         TP_PROTO(struct inode *inode, loff_t offset,
1288                  unsigned int max_blocks, int ret),
1289
1290         TP_ARGS(inode, offset, max_blocks, ret),
1291
1292         TP_STRUCT__entry(
1293                 __field(        dev_t,  dev                     )
1294                 __field(        ino_t,  ino                     )
1295                 __field(        loff_t, pos                     )
1296                 __field(        unsigned int,   blocks          )
1297                 __field(        int,    ret                     )
1298         ),
1299
1300         TP_fast_assign(
1301                 __entry->dev    = inode->i_sb->s_dev;
1302                 __entry->ino    = inode->i_ino;
1303                 __entry->pos    = offset;
1304                 __entry->blocks = max_blocks;
1305                 __entry->ret    = ret;
1306         ),
1307
1308         TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
1309                   MAJOR(__entry->dev), MINOR(__entry->dev),
1310                   (unsigned long) __entry->ino,
1311                   __entry->pos, __entry->blocks,
1312                   __entry->ret)
1313 );
1314
1315 TRACE_EVENT(ext4_unlink_enter,
1316         TP_PROTO(struct inode *parent, struct dentry *dentry),
1317
1318         TP_ARGS(parent, dentry),
1319
1320         TP_STRUCT__entry(
1321                 __field(        dev_t,  dev                     )
1322                 __field(        ino_t,  ino                     )
1323                 __field(        ino_t,  parent                  )
1324                 __field(        loff_t, size                    )
1325         ),
1326
1327         TP_fast_assign(
1328                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
1329                 __entry->ino            = dentry->d_inode->i_ino;
1330                 __entry->parent         = parent->i_ino;
1331                 __entry->size           = dentry->d_inode->i_size;
1332         ),
1333
1334         TP_printk("dev %d,%d ino %lu size %lld parent %lu",
1335                   MAJOR(__entry->dev), MINOR(__entry->dev),
1336                   (unsigned long) __entry->ino, __entry->size,
1337                   (unsigned long) __entry->parent)
1338 );
1339
1340 TRACE_EVENT(ext4_unlink_exit,
1341         TP_PROTO(struct dentry *dentry, int ret),
1342
1343         TP_ARGS(dentry, ret),
1344
1345         TP_STRUCT__entry(
1346                 __field(        dev_t,  dev                     )
1347                 __field(        ino_t,  ino                     )
1348                 __field(        int,    ret                     )
1349         ),
1350
1351         TP_fast_assign(
1352                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
1353                 __entry->ino            = dentry->d_inode->i_ino;
1354                 __entry->ret            = ret;
1355         ),
1356
1357         TP_printk("dev %d,%d ino %lu ret %d",
1358                   MAJOR(__entry->dev), MINOR(__entry->dev),
1359                   (unsigned long) __entry->ino,
1360                   __entry->ret)
1361 );
1362
1363 DECLARE_EVENT_CLASS(ext4__truncate,
1364         TP_PROTO(struct inode *inode),
1365
1366         TP_ARGS(inode),
1367
1368         TP_STRUCT__entry(
1369                 __field(        dev_t,          dev             )
1370                 __field(        ino_t,          ino             )
1371                 __field(        __u64,          blocks          )
1372         ),
1373
1374         TP_fast_assign(
1375                 __entry->dev    = inode->i_sb->s_dev;
1376                 __entry->ino    = inode->i_ino;
1377                 __entry->blocks = inode->i_blocks;
1378         ),
1379
1380         TP_printk("dev %d,%d ino %lu blocks %llu",
1381                   MAJOR(__entry->dev), MINOR(__entry->dev),
1382                   (unsigned long) __entry->ino, __entry->blocks)
1383 );
1384
1385 DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
1386
1387         TP_PROTO(struct inode *inode),
1388
1389         TP_ARGS(inode)
1390 );
1391
1392 DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
1393
1394         TP_PROTO(struct inode *inode),
1395
1396         TP_ARGS(inode)
1397 );
1398
1399 /* 'ux' is the uninitialized extent. */
1400 TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
1401         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1402                  struct ext4_extent *ux),
1403
1404         TP_ARGS(inode, map, ux),
1405
1406         TP_STRUCT__entry(
1407                 __field(        dev_t,          dev     )
1408                 __field(        ino_t,          ino     )
1409                 __field(        ext4_lblk_t,    m_lblk  )
1410                 __field(        unsigned,       m_len   )
1411                 __field(        ext4_lblk_t,    u_lblk  )
1412                 __field(        unsigned,       u_len   )
1413                 __field(        ext4_fsblk_t,   u_pblk  )
1414         ),
1415
1416         TP_fast_assign(
1417                 __entry->dev            = inode->i_sb->s_dev;
1418                 __entry->ino            = inode->i_ino;
1419                 __entry->m_lblk         = map->m_lblk;
1420                 __entry->m_len          = map->m_len;
1421                 __entry->u_lblk         = le32_to_cpu(ux->ee_block);
1422                 __entry->u_len          = ext4_ext_get_actual_len(ux);
1423                 __entry->u_pblk         = ext4_ext_pblock(ux);
1424         ),
1425
1426         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
1427                   "u_pblk %llu",
1428                   MAJOR(__entry->dev), MINOR(__entry->dev),
1429                   (unsigned long) __entry->ino,
1430                   __entry->m_lblk, __entry->m_len,
1431                   __entry->u_lblk, __entry->u_len, __entry->u_pblk)
1432 );
1433
1434 /*
1435  * 'ux' is the uninitialized extent.
1436  * 'ix' is the initialized extent to which blocks are transferred.
1437  */
1438 TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
1439         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1440                  struct ext4_extent *ux, struct ext4_extent *ix),
1441
1442         TP_ARGS(inode, map, ux, ix),
1443
1444         TP_STRUCT__entry(
1445                 __field(        dev_t,          dev     )
1446                 __field(        ino_t,          ino     )
1447                 __field(        ext4_lblk_t,    m_lblk  )
1448                 __field(        unsigned,       m_len   )
1449                 __field(        ext4_lblk_t,    u_lblk  )
1450                 __field(        unsigned,       u_len   )
1451                 __field(        ext4_fsblk_t,   u_pblk  )
1452                 __field(        ext4_lblk_t,    i_lblk  )
1453                 __field(        unsigned,       i_len   )
1454                 __field(        ext4_fsblk_t,   i_pblk  )
1455         ),
1456
1457         TP_fast_assign(
1458                 __entry->dev            = inode->i_sb->s_dev;
1459                 __entry->ino            = inode->i_ino;
1460                 __entry->m_lblk         = map->m_lblk;
1461                 __entry->m_len          = map->m_len;
1462                 __entry->u_lblk         = le32_to_cpu(ux->ee_block);
1463                 __entry->u_len          = ext4_ext_get_actual_len(ux);
1464                 __entry->u_pblk         = ext4_ext_pblock(ux);
1465                 __entry->i_lblk         = le32_to_cpu(ix->ee_block);
1466                 __entry->i_len          = ext4_ext_get_actual_len(ix);
1467                 __entry->i_pblk         = ext4_ext_pblock(ix);
1468         ),
1469
1470         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
1471                   "u_lblk %u u_len %u u_pblk %llu "
1472                   "i_lblk %u i_len %u i_pblk %llu ",
1473                   MAJOR(__entry->dev), MINOR(__entry->dev),
1474                   (unsigned long) __entry->ino,
1475                   __entry->m_lblk, __entry->m_len,
1476                   __entry->u_lblk, __entry->u_len, __entry->u_pblk,
1477                   __entry->i_lblk, __entry->i_len, __entry->i_pblk)
1478 );
1479
1480 DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
1481         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1482                  unsigned int len, unsigned int flags),
1483
1484         TP_ARGS(inode, lblk, len, flags),
1485
1486         TP_STRUCT__entry(
1487                 __field(        dev_t,          dev             )
1488                 __field(        ino_t,          ino             )
1489                 __field(        ext4_lblk_t,    lblk            )
1490                 __field(        unsigned int,   len             )
1491                 __field(        unsigned int,   flags           )
1492         ),
1493
1494         TP_fast_assign(
1495                 __entry->dev    = inode->i_sb->s_dev;
1496                 __entry->ino    = inode->i_ino;
1497                 __entry->lblk   = lblk;
1498                 __entry->len    = len;
1499                 __entry->flags  = flags;
1500         ),
1501
1502         TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
1503                   MAJOR(__entry->dev), MINOR(__entry->dev),
1504                   (unsigned long) __entry->ino,
1505                   __entry->lblk, __entry->len, __entry->flags)
1506 );
1507
1508 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
1509         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1510                  unsigned len, unsigned flags),
1511
1512         TP_ARGS(inode, lblk, len, flags)
1513 );
1514
1515 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
1516         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1517                  unsigned len, unsigned flags),
1518
1519         TP_ARGS(inode, lblk, len, flags)
1520 );
1521
1522 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
1523         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
1524
1525         TP_ARGS(inode, map, ret),
1526
1527         TP_STRUCT__entry(
1528                 __field(        dev_t,          dev             )
1529                 __field(        ino_t,          ino             )
1530                 __field(        ext4_fsblk_t,   pblk            )
1531                 __field(        ext4_lblk_t,    lblk            )
1532                 __field(        unsigned int,   len             )
1533                 __field(        unsigned int,   flags           )
1534                 __field(        int,            ret             )
1535         ),
1536
1537         TP_fast_assign(
1538                 __entry->dev    = inode->i_sb->s_dev;
1539                 __entry->ino    = inode->i_ino;
1540                 __entry->pblk   = map->m_pblk;
1541                 __entry->lblk   = map->m_lblk;
1542                 __entry->len    = map->m_len;
1543                 __entry->flags  = map->m_flags;
1544                 __entry->ret    = ret;
1545         ),
1546
1547         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u flags %x ret %d",
1548                   MAJOR(__entry->dev), MINOR(__entry->dev),
1549                   (unsigned long) __entry->ino,
1550                   __entry->lblk, __entry->pblk,
1551                   __entry->len, __entry->flags, __entry->ret)
1552 );
1553
1554 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
1555         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
1556
1557         TP_ARGS(inode, map, ret)
1558 );
1559
1560 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
1561         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
1562
1563         TP_ARGS(inode, map, ret)
1564 );
1565
1566 TRACE_EVENT(ext4_ext_load_extent,
1567         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
1568
1569         TP_ARGS(inode, lblk, pblk),
1570
1571         TP_STRUCT__entry(
1572                 __field(        dev_t,          dev             )
1573                 __field(        ino_t,          ino             )
1574                 __field(        ext4_fsblk_t,   pblk            )
1575                 __field(        ext4_lblk_t,    lblk            )
1576         ),
1577
1578         TP_fast_assign(
1579                 __entry->dev    = inode->i_sb->s_dev;
1580                 __entry->ino    = inode->i_ino;
1581                 __entry->pblk   = pblk;
1582                 __entry->lblk   = lblk;
1583         ),
1584
1585         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
1586                   MAJOR(__entry->dev), MINOR(__entry->dev),
1587                   (unsigned long) __entry->ino,
1588                   __entry->lblk, __entry->pblk)
1589 );
1590
1591 TRACE_EVENT(ext4_load_inode,
1592         TP_PROTO(struct inode *inode),
1593
1594         TP_ARGS(inode),
1595
1596         TP_STRUCT__entry(
1597                 __field(        dev_t,  dev             )
1598                 __field(        ino_t,  ino             )
1599         ),
1600
1601         TP_fast_assign(
1602                 __entry->dev            = inode->i_sb->s_dev;
1603                 __entry->ino            = inode->i_ino;
1604         ),
1605
1606         TP_printk("dev %d,%d ino %ld",
1607                   MAJOR(__entry->dev), MINOR(__entry->dev),
1608                   (unsigned long) __entry->ino)
1609 );
1610
1611 TRACE_EVENT(ext4_journal_start,
1612         TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
1613
1614         TP_ARGS(sb, nblocks, IP),
1615
1616         TP_STRUCT__entry(
1617                 __field(        dev_t,  dev                     )
1618                 __field(unsigned long,  ip                      )
1619                 __field(        int,    nblocks                 )
1620         ),
1621
1622         TP_fast_assign(
1623                 __entry->dev     = sb->s_dev;
1624                 __entry->ip      = IP;
1625                 __entry->nblocks = nblocks;
1626         ),
1627
1628         TP_printk("dev %d,%d nblocks %d caller %pF",
1629                   MAJOR(__entry->dev), MINOR(__entry->dev),
1630                   __entry->nblocks, (void *)__entry->ip)
1631 );
1632
1633 DECLARE_EVENT_CLASS(ext4__trim,
1634         TP_PROTO(struct super_block *sb,
1635                  ext4_group_t group,
1636                  ext4_grpblk_t start,
1637                  ext4_grpblk_t len),
1638
1639         TP_ARGS(sb, group, start, len),
1640
1641         TP_STRUCT__entry(
1642                 __field(        int,    dev_major               )
1643                 __field(        int,    dev_minor               )
1644                 __field(        __u32,  group                   )
1645                 __field(        int,    start                   )
1646                 __field(        int,    len                     )
1647         ),
1648
1649         TP_fast_assign(
1650                 __entry->dev_major      = MAJOR(sb->s_dev);
1651                 __entry->dev_minor      = MINOR(sb->s_dev);
1652                 __entry->group          = group;
1653                 __entry->start          = start;
1654                 __entry->len            = len;
1655         ),
1656
1657         TP_printk("dev %d,%d group %u, start %d, len %d",
1658                   __entry->dev_major, __entry->dev_minor,
1659                   __entry->group, __entry->start, __entry->len)
1660 );
1661
1662 DEFINE_EVENT(ext4__trim, ext4_trim_extent,
1663
1664         TP_PROTO(struct super_block *sb,
1665                  ext4_group_t group,
1666                  ext4_grpblk_t start,
1667                  ext4_grpblk_t len),
1668
1669         TP_ARGS(sb, group, start, len)
1670 );
1671
1672 DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
1673
1674         TP_PROTO(struct super_block *sb,
1675                  ext4_group_t group,
1676                  ext4_grpblk_t start,
1677                  ext4_grpblk_t len),
1678
1679         TP_ARGS(sb, group, start, len)
1680 );
1681
1682 TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
1683         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags,
1684                  unsigned int allocated, ext4_fsblk_t newblock),
1685
1686         TP_ARGS(inode, map, flags, allocated, newblock),
1687
1688         TP_STRUCT__entry(
1689                 __field(        dev_t,          dev             )
1690                 __field(        ino_t,          ino             )
1691                 __field(        int,            flags           )
1692                 __field(        ext4_lblk_t,    lblk            )
1693                 __field(        ext4_fsblk_t,   pblk            )
1694                 __field(        unsigned int,   len             )
1695                 __field(        unsigned int,   allocated       )
1696                 __field(        ext4_fsblk_t,   newblk          )
1697         ),
1698
1699         TP_fast_assign(
1700                 __entry->dev            = inode->i_sb->s_dev;
1701                 __entry->ino            = inode->i_ino;
1702                 __entry->flags          = flags;
1703                 __entry->lblk           = map->m_lblk;
1704                 __entry->pblk           = map->m_pblk;
1705                 __entry->len            = map->m_len;
1706                 __entry->allocated      = allocated;
1707                 __entry->newblk         = newblock;
1708         ),
1709
1710         TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %x "
1711                   "allocated %d newblock %llu",
1712                   MAJOR(__entry->dev), MINOR(__entry->dev),
1713                   (unsigned long) __entry->ino,
1714                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
1715                   __entry->len, __entry->flags,
1716                   (unsigned int) __entry->allocated,
1717                   (unsigned long long) __entry->newblk)
1718 );
1719
1720 TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
1721         TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
1722
1723         TP_ARGS(sb, map, ret),
1724
1725         TP_STRUCT__entry(
1726                 __field(        dev_t,          dev     )
1727                 __field(        unsigned int,   flags   )
1728                 __field(        ext4_lblk_t,    lblk    )
1729                 __field(        ext4_fsblk_t,   pblk    )
1730                 __field(        unsigned int,   len     )
1731                 __field(        int,            ret     )
1732         ),
1733
1734         TP_fast_assign(
1735                 __entry->dev    = sb->s_dev;
1736                 __entry->flags  = map->m_flags;
1737                 __entry->lblk   = map->m_lblk;
1738                 __entry->pblk   = map->m_pblk;
1739                 __entry->len    = map->m_len;
1740                 __entry->ret    = ret;
1741         ),
1742
1743         TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %u ret %d",
1744                   MAJOR(__entry->dev), MINOR(__entry->dev),
1745                   __entry->lblk, (unsigned long long) __entry->pblk,
1746                   __entry->len, __entry->flags, __entry->ret)
1747 );
1748
1749 TRACE_EVENT(ext4_ext_put_in_cache,
1750         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
1751                  ext4_fsblk_t start),
1752
1753         TP_ARGS(inode, lblk, len, start),
1754
1755         TP_STRUCT__entry(
1756                 __field(        dev_t,          dev     )
1757                 __field(        ino_t,          ino     )
1758                 __field(        ext4_lblk_t,    lblk    )
1759                 __field(        unsigned int,   len     )
1760                 __field(        ext4_fsblk_t,   start   )
1761         ),
1762
1763         TP_fast_assign(
1764                 __entry->dev    = inode->i_sb->s_dev;
1765                 __entry->ino    = inode->i_ino;
1766                 __entry->lblk   = lblk;
1767                 __entry->len    = len;
1768                 __entry->start  = start;
1769         ),
1770
1771         TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
1772                   MAJOR(__entry->dev), MINOR(__entry->dev),
1773                   (unsigned long) __entry->ino,
1774                   (unsigned) __entry->lblk,
1775                   __entry->len,
1776                   (unsigned long long) __entry->start)
1777 );
1778
1779 TRACE_EVENT(ext4_ext_in_cache,
1780         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
1781
1782         TP_ARGS(inode, lblk, ret),
1783
1784         TP_STRUCT__entry(
1785                 __field(        dev_t,          dev     )
1786                 __field(        ino_t,          ino     )
1787                 __field(        ext4_lblk_t,    lblk    )
1788                 __field(        int,            ret     )
1789         ),
1790
1791         TP_fast_assign(
1792                 __entry->dev    = inode->i_sb->s_dev;
1793                 __entry->ino    = inode->i_ino;
1794                 __entry->lblk   = lblk;
1795                 __entry->ret    = ret;
1796         ),
1797
1798         TP_printk("dev %d,%d ino %lu lblk %u ret %d",
1799                   MAJOR(__entry->dev), MINOR(__entry->dev),
1800                   (unsigned long) __entry->ino,
1801                   (unsigned) __entry->lblk,
1802                   __entry->ret)
1803
1804 );
1805
1806 TRACE_EVENT(ext4_find_delalloc_range,
1807         TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
1808                 int reverse, int found, ext4_lblk_t found_blk),
1809
1810         TP_ARGS(inode, from, to, reverse, found, found_blk),
1811
1812         TP_STRUCT__entry(
1813                 __field(        dev_t,          dev             )
1814                 __field(        ino_t,          ino             )
1815                 __field(        ext4_lblk_t,    from            )
1816                 __field(        ext4_lblk_t,    to              )
1817                 __field(        int,            reverse         )
1818                 __field(        int,            found           )
1819                 __field(        ext4_lblk_t,    found_blk       )
1820         ),
1821
1822         TP_fast_assign(
1823                 __entry->dev            = inode->i_sb->s_dev;
1824                 __entry->ino            = inode->i_ino;
1825                 __entry->from           = from;
1826                 __entry->to             = to;
1827                 __entry->reverse        = reverse;
1828                 __entry->found          = found;
1829                 __entry->found_blk      = found_blk;
1830         ),
1831
1832         TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
1833                   "(blk = %u)",
1834                   MAJOR(__entry->dev), MINOR(__entry->dev),
1835                   (unsigned long) __entry->ino,
1836                   (unsigned) __entry->from, (unsigned) __entry->to,
1837                   __entry->reverse, __entry->found,
1838                   (unsigned) __entry->found_blk)
1839 );
1840
1841 TRACE_EVENT(ext4_get_reserved_cluster_alloc,
1842         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
1843
1844         TP_ARGS(inode, lblk, len),
1845
1846         TP_STRUCT__entry(
1847                 __field(        dev_t,          dev     )
1848                 __field(        ino_t,          ino     )
1849                 __field(        ext4_lblk_t,    lblk    )
1850                 __field(        unsigned int,   len     )
1851         ),
1852
1853         TP_fast_assign(
1854                 __entry->dev    = inode->i_sb->s_dev;
1855                 __entry->ino    = inode->i_ino;
1856                 __entry->lblk   = lblk;
1857                 __entry->len    = len;
1858         ),
1859
1860         TP_printk("dev %d,%d ino %lu lblk %u len %u",
1861                   MAJOR(__entry->dev), MINOR(__entry->dev),
1862                   (unsigned long) __entry->ino,
1863                   (unsigned) __entry->lblk,
1864                   __entry->len)
1865 );
1866
1867 TRACE_EVENT(ext4_ext_show_extent,
1868         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
1869                  unsigned short len),
1870
1871         TP_ARGS(inode, lblk, pblk, len),
1872
1873         TP_STRUCT__entry(
1874                 __field(        dev_t,          dev     )
1875                 __field(        ino_t,          ino     )
1876                 __field(        ext4_fsblk_t,   pblk    )
1877                 __field(        ext4_lblk_t,    lblk    )
1878                 __field(        unsigned short, len     )
1879         ),
1880
1881         TP_fast_assign(
1882                 __entry->dev    = inode->i_sb->s_dev;
1883                 __entry->ino    = inode->i_ino;
1884                 __entry->pblk   = pblk;
1885                 __entry->lblk   = lblk;
1886                 __entry->len    = len;
1887         ),
1888
1889         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
1890                   MAJOR(__entry->dev), MINOR(__entry->dev),
1891                   (unsigned long) __entry->ino,
1892                   (unsigned) __entry->lblk,
1893                   (unsigned long long) __entry->pblk,
1894                   (unsigned short) __entry->len)
1895 );
1896
1897 TRACE_EVENT(ext4_remove_blocks,
1898             TP_PROTO(struct inode *inode, struct ext4_extent *ex,
1899                 ext4_lblk_t from, ext4_fsblk_t to,
1900                 ext4_fsblk_t partial_cluster),
1901
1902         TP_ARGS(inode, ex, from, to, partial_cluster),
1903
1904         TP_STRUCT__entry(
1905                 __field(        dev_t,          dev     )
1906                 __field(        ino_t,          ino     )
1907                 __field(        ext4_lblk_t,    from    )
1908                 __field(        ext4_lblk_t,    to      )
1909                 __field(        ext4_fsblk_t,   partial )
1910                 __field(        ext4_fsblk_t,   ee_pblk )
1911                 __field(        ext4_lblk_t,    ee_lblk )
1912                 __field(        unsigned short, ee_len  )
1913         ),
1914
1915         TP_fast_assign(
1916                 __entry->dev            = inode->i_sb->s_dev;
1917                 __entry->ino            = inode->i_ino;
1918                 __entry->from           = from;
1919                 __entry->to             = to;
1920                 __entry->partial        = partial_cluster;
1921                 __entry->ee_pblk        = ext4_ext_pblock(ex);
1922                 __entry->ee_lblk        = cpu_to_le32(ex->ee_block);
1923                 __entry->ee_len         = ext4_ext_get_actual_len(ex);
1924         ),
1925
1926         TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
1927                   "from %u to %u partial_cluster %u",
1928                   MAJOR(__entry->dev), MINOR(__entry->dev),
1929                   (unsigned long) __entry->ino,
1930                   (unsigned) __entry->ee_lblk,
1931                   (unsigned long long) __entry->ee_pblk,
1932                   (unsigned short) __entry->ee_len,
1933                   (unsigned) __entry->from,
1934                   (unsigned) __entry->to,
1935                   (unsigned) __entry->partial)
1936 );
1937
1938 TRACE_EVENT(ext4_ext_rm_leaf,
1939         TP_PROTO(struct inode *inode, ext4_lblk_t start,
1940                  struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
1941
1942         TP_ARGS(inode, start, ex, partial_cluster),
1943
1944         TP_STRUCT__entry(
1945                 __field(        dev_t,          dev     )
1946                 __field(        ino_t,          ino     )
1947                 __field(        ext4_fsblk_t,   partial )
1948                 __field(        ext4_lblk_t,    start   )
1949                 __field(        ext4_lblk_t,    ee_lblk )
1950                 __field(        ext4_fsblk_t,   ee_pblk )
1951                 __field(        short,          ee_len  )
1952         ),
1953
1954         TP_fast_assign(
1955                 __entry->dev            = inode->i_sb->s_dev;
1956                 __entry->ino            = inode->i_ino;
1957                 __entry->partial        = partial_cluster;
1958                 __entry->start          = start;
1959                 __entry->ee_lblk        = le32_to_cpu(ex->ee_block);
1960                 __entry->ee_pblk        = ext4_ext_pblock(ex);
1961                 __entry->ee_len         = ext4_ext_get_actual_len(ex);
1962         ),
1963
1964         TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
1965                   "partial_cluster %u",
1966                   MAJOR(__entry->dev), MINOR(__entry->dev),
1967                   (unsigned long) __entry->ino,
1968                   (unsigned) __entry->start,
1969                   (unsigned) __entry->ee_lblk,
1970                   (unsigned long long) __entry->ee_pblk,
1971                   (unsigned short) __entry->ee_len,
1972                   (unsigned) __entry->partial)
1973 );
1974
1975 TRACE_EVENT(ext4_ext_rm_idx,
1976         TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
1977
1978         TP_ARGS(inode, pblk),
1979
1980         TP_STRUCT__entry(
1981                 __field(        dev_t,          dev     )
1982                 __field(        ino_t,          ino     )
1983                 __field(        ext4_fsblk_t,   pblk    )
1984         ),
1985
1986         TP_fast_assign(
1987                 __entry->dev    = inode->i_sb->s_dev;
1988                 __entry->ino    = inode->i_ino;
1989                 __entry->pblk   = pblk;
1990         ),
1991
1992         TP_printk("dev %d,%d ino %lu index_pblk %llu",
1993                   MAJOR(__entry->dev), MINOR(__entry->dev),
1994                   (unsigned long) __entry->ino,
1995                   (unsigned long long) __entry->pblk)
1996 );
1997
1998 TRACE_EVENT(ext4_ext_remove_space,
1999         TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
2000
2001         TP_ARGS(inode, start, depth),
2002
2003         TP_STRUCT__entry(
2004                 __field(        dev_t,          dev     )
2005                 __field(        ino_t,          ino     )
2006                 __field(        ext4_lblk_t,    start   )
2007                 __field(        int,            depth   )
2008         ),
2009
2010         TP_fast_assign(
2011                 __entry->dev    = inode->i_sb->s_dev;
2012                 __entry->ino    = inode->i_ino;
2013                 __entry->start  = start;
2014                 __entry->depth  = depth;
2015         ),
2016
2017         TP_printk("dev %d,%d ino %lu since %u depth %d",
2018                   MAJOR(__entry->dev), MINOR(__entry->dev),
2019                   (unsigned long) __entry->ino,
2020                   (unsigned) __entry->start,
2021                   __entry->depth)
2022 );
2023
2024 TRACE_EVENT(ext4_ext_remove_space_done,
2025         TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
2026                 ext4_lblk_t partial, unsigned short eh_entries),
2027
2028         TP_ARGS(inode, start, depth, partial, eh_entries),
2029
2030         TP_STRUCT__entry(
2031                 __field(        dev_t,          dev             )
2032                 __field(        ino_t,          ino             )
2033                 __field(        ext4_lblk_t,    start           )
2034                 __field(        int,            depth           )
2035                 __field(        ext4_lblk_t,    partial         )
2036                 __field(        unsigned short, eh_entries      )
2037         ),
2038
2039         TP_fast_assign(
2040                 __entry->dev            = inode->i_sb->s_dev;
2041                 __entry->ino            = inode->i_ino;
2042                 __entry->start          = start;
2043                 __entry->depth          = depth;
2044                 __entry->partial        = partial;
2045                 __entry->eh_entries     = eh_entries;
2046         ),
2047
2048         TP_printk("dev %d,%d ino %lu since %u depth %d partial %u "
2049                   "remaining_entries %u",
2050                   MAJOR(__entry->dev), MINOR(__entry->dev),
2051                   (unsigned long) __entry->ino,
2052                   (unsigned) __entry->start,
2053                   __entry->depth,
2054                   (unsigned) __entry->partial,
2055                   (unsigned short) __entry->eh_entries)
2056 );
2057
2058 TRACE_EVENT(ext4_es_insert_extent,
2059         TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t len),
2060
2061         TP_ARGS(inode, start, len),
2062
2063         TP_STRUCT__entry(
2064                 __field(        dev_t,  dev                     )
2065                 __field(        ino_t,  ino                     )
2066                 __field(        loff_t, start                   )
2067                 __field(        loff_t, len                     )
2068         ),
2069
2070         TP_fast_assign(
2071                 __entry->dev    = inode->i_sb->s_dev;
2072                 __entry->ino    = inode->i_ino;
2073                 __entry->start  = start;
2074                 __entry->len    = len;
2075         ),
2076
2077         TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
2078                   MAJOR(__entry->dev), MINOR(__entry->dev),
2079                   (unsigned long) __entry->ino,
2080                   __entry->start, __entry->len)
2081 );
2082
2083 TRACE_EVENT(ext4_es_remove_extent,
2084         TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t len),
2085
2086         TP_ARGS(inode, start, len),
2087
2088         TP_STRUCT__entry(
2089                 __field(        dev_t,  dev                     )
2090                 __field(        ino_t,  ino                     )
2091                 __field(        loff_t, start                   )
2092                 __field(        loff_t, len                     )
2093         ),
2094
2095         TP_fast_assign(
2096                 __entry->dev    = inode->i_sb->s_dev;
2097                 __entry->ino    = inode->i_ino;
2098                 __entry->start  = start;
2099                 __entry->len    = len;
2100         ),
2101
2102         TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
2103                   MAJOR(__entry->dev), MINOR(__entry->dev),
2104                   (unsigned long) __entry->ino,
2105                   __entry->start, __entry->len)
2106 );
2107
2108 TRACE_EVENT(ext4_es_find_extent_enter,
2109         TP_PROTO(struct inode *inode, ext4_lblk_t start),
2110
2111         TP_ARGS(inode, start),
2112
2113         TP_STRUCT__entry(
2114                 __field(        dev_t,          dev             )
2115                 __field(        ino_t,          ino             )
2116                 __field(        ext4_lblk_t,    start           )
2117         ),
2118
2119         TP_fast_assign(
2120                 __entry->dev    = inode->i_sb->s_dev;
2121                 __entry->ino    = inode->i_ino;
2122                 __entry->start  = start;
2123         ),
2124
2125         TP_printk("dev %d,%d ino %lu start %u",
2126                   MAJOR(__entry->dev), MINOR(__entry->dev),
2127                   (unsigned long) __entry->ino, __entry->start)
2128 );
2129
2130 TRACE_EVENT(ext4_es_find_extent_exit,
2131         TP_PROTO(struct inode *inode, struct extent_status *es,
2132                  ext4_lblk_t ret),
2133
2134         TP_ARGS(inode, es, ret),
2135
2136         TP_STRUCT__entry(
2137                 __field(        dev_t,          dev             )
2138                 __field(        ino_t,          ino             )
2139                 __field(        ext4_lblk_t,    start           )
2140                 __field(        ext4_lblk_t,    len             )
2141                 __field(        ext4_lblk_t,    ret             )
2142         ),
2143
2144         TP_fast_assign(
2145                 __entry->dev    = inode->i_sb->s_dev;
2146                 __entry->ino    = inode->i_ino;
2147                 __entry->start  = es->start;
2148                 __entry->len    = es->len;
2149                 __entry->ret    = ret;
2150         ),
2151
2152         TP_printk("dev %d,%d ino %lu es [%u/%u) ret %u",
2153                   MAJOR(__entry->dev), MINOR(__entry->dev),
2154                   (unsigned long) __entry->ino,
2155                   __entry->start, __entry->len, __entry->ret)
2156 );
2157
2158 #endif /* _TRACE_EXT4_H */
2159
2160 /* This part must be outside protection */
2161 #include <trace/define_trace.h>