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