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_prealloc_space;
  13 struct ext4_inode_info;
  14 struct mpage_da_data;
  15
  16 #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
  17
  18 TRACE_EVENT(ext4_free_inode,
  19         TP_PROTO(struct inode *inode),
  20
  21         TP_ARGS(inode),
  22
  23         TP_STRUCT__entry(
  24                 __field(        dev_t,  dev                     )
  25                 __field(        ino_t,  ino                     )
  26                 __field(        umode_t, mode                   )
  27                 __field(        uid_t,  uid                     )
  28                 __field(        gid_t,  gid                     )
  29                 __field(        blkcnt_t, blocks                )
  30         ),
  31
  32         TP_fast_assign(
  33                 __entry->dev    = inode->i_sb->s_dev;
  34                 __entry->ino    = inode->i_ino;
  35                 __entry->mode   = inode->i_mode;
  36                 __entry->uid    = inode->i_uid;
  37                 __entry->gid    = inode->i_gid;
  38                 __entry->blocks = inode->i_blocks;
  39         ),
  40
  41         TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
  42                   MAJOR(__entry->dev), MINOR(__entry->dev),
  43                   (unsigned long) __entry->ino,
  44                   __entry->mode, __entry->uid, __entry->gid,
  45                   (unsigned long long) __entry->blocks)
  46 );
  47
  48 TRACE_EVENT(ext4_request_inode,
  49         TP_PROTO(struct inode *dir, int mode),
  50
  51         TP_ARGS(dir, mode),
  52
  53         TP_STRUCT__entry(
  54                 __field(        dev_t,  dev                     )
  55                 __field(        ino_t,  dir                     )
  56                 __field(        umode_t, mode                   )
  57         ),
  58
  59         TP_fast_assign(
  60                 __entry->dev    = dir->i_sb->s_dev;
  61                 __entry->dir    = dir->i_ino;
  62                 __entry->mode   = mode;
  63         ),
  64
  65         TP_printk("dev %d,%d dir %lu mode 0%o",
  66                   MAJOR(__entry->dev), MINOR(__entry->dev),
  67                   (unsigned long) __entry->dir, __entry->mode)
  68 );
  69
  70 TRACE_EVENT(ext4_allocate_inode,
  71         TP_PROTO(struct inode *inode, struct inode *dir, int mode),
  72
  73         TP_ARGS(inode, dir, mode),
  74
  75         TP_STRUCT__entry(
  76                 __field(        dev_t,  dev                     )
  77                 __field(        ino_t,  ino                     )
  78                 __field(        ino_t,  dir                     )
  79                 __field(        umode_t, mode                   )
  80         ),
  81
  82         TP_fast_assign(
  83                 __entry->dev    = inode->i_sb->s_dev;
  84                 __entry->ino    = inode->i_ino;
  85                 __entry->dir    = dir->i_ino;
  86                 __entry->mode   = mode;
  87         ),
  88
  89         TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
  90                   MAJOR(__entry->dev), MINOR(__entry->dev),
  91                   (unsigned long) __entry->ino,
  92                   (unsigned long) __entry->dir, __entry->mode)
  93 );
  94
  95 TRACE_EVENT(ext4_evict_inode,
  96         TP_PROTO(struct inode *inode),
  97
  98         TP_ARGS(inode),
  99
 100         TP_STRUCT__entry(
 101                 __field(        dev_t,  dev                     )
 102                 __field(        ino_t,  ino                     )
 103                 __field(        int,    nlink                   )
 104         ),
 105
 106         TP_fast_assign(
 107                 __entry->dev    = inode->i_sb->s_dev;
 108                 __entry->ino    = inode->i_ino;
 109                 __entry->nlink  = inode->i_nlink;
 110         ),
 111
 112         TP_printk("dev %d,%d ino %lu nlink %d",
 113                   MAJOR(__entry->dev), MINOR(__entry->dev),
 114                   (unsigned long) __entry->ino, __entry->nlink)
 115 );
 116
 117 TRACE_EVENT(ext4_drop_inode,
 118         TP_PROTO(struct inode *inode, int drop),
 119
 120         TP_ARGS(inode, drop),
 121
 122         TP_STRUCT__entry(
 123                 __field(        dev_t,  dev                     )
 124                 __field(        ino_t,  ino                     )
 125                 __field(        int,    drop                    )
 126         ),
 127
 128         TP_fast_assign(
 129                 __entry->dev    = inode->i_sb->s_dev;
 130                 __entry->ino    = inode->i_ino;
 131                 __entry->drop   = drop;
 132         ),
 133
 134         TP_printk("dev %d,%d ino %lu drop %d",
 135                   MAJOR(__entry->dev), MINOR(__entry->dev),
 136                   (unsigned long) __entry->ino, __entry->drop)
 137 );
 138
 139 TRACE_EVENT(ext4_mark_inode_dirty,
 140         TP_PROTO(struct inode *inode, unsigned long IP),
 141
 142         TP_ARGS(inode, IP),
 143
 144         TP_STRUCT__entry(
 145                 __field(        dev_t,  dev                     )
 146                 __field(        ino_t,  ino                     )
 147                 __field(unsigned long,  ip                      )
 148         ),
 149
 150         TP_fast_assign(
 151                 __entry->dev    = inode->i_sb->s_dev;
 152                 __entry->ino    = inode->i_ino;
 153                 __entry->ip     = IP;
 154         ),
 155
 156         TP_printk("dev %d,%d ino %lu caller %pF",
 157                   MAJOR(__entry->dev), MINOR(__entry->dev),
 158                   (unsigned long) __entry->ino, (void *)__entry->ip)
 159 );
 160
 161 TRACE_EVENT(ext4_begin_ordered_truncate,
 162         TP_PROTO(struct inode *inode, loff_t new_size),
 163
 164         TP_ARGS(inode, new_size),
 165
 166         TP_STRUCT__entry(
 167                 __field(        dev_t,  dev                     )
 168                 __field(        ino_t,  ino                     )
 169                 __field(        loff_t, new_size                )
 170         ),
 171
 172         TP_fast_assign(
 173                 __entry->dev            = inode->i_sb->s_dev;
 174                 __entry->ino            = inode->i_ino;
 175                 __entry->new_size       = new_size;
 176         ),
 177
 178         TP_printk("dev %d,%d ino %lu new_size %lld",
 179                   MAJOR(__entry->dev), MINOR(__entry->dev),
 180                   (unsigned long) __entry->ino,
 181                   (long long) __entry->new_size)
 182 );
 183
 184 DECLARE_EVENT_CLASS(ext4__write_begin,
 185
 186         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 187                  unsigned int flags),
 188
 189         TP_ARGS(inode, pos, len, flags),
 190
 191         TP_STRUCT__entry(
 192                 __field(        dev_t,  dev                     )
 193                 __field(        ino_t,  ino                     )
 194                 __field(        loff_t, pos                     )
 195                 __field(        unsigned int, len               )
 196                 __field(        unsigned int, flags             )
 197         ),
 198
 199         TP_fast_assign(
 200                 __entry->dev    = inode->i_sb->s_dev;
 201                 __entry->ino    = inode->i_ino;
 202                 __entry->pos    = pos;
 203                 __entry->len    = len;
 204                 __entry->flags  = flags;
 205         ),
 206
 207         TP_printk("dev %d,%d ino %lu pos %llu len %u flags %u",
 208                   MAJOR(__entry->dev), MINOR(__entry->dev),
 209                   (unsigned long) __entry->ino,
 210                   __entry->pos, __entry->len, __entry->flags)
 211 );
 212
 213 DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
 214
 215         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 216                  unsigned int flags),
 217
 218         TP_ARGS(inode, pos, len, flags)
 219 );
 220
 221 DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
 222
 223         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 224                  unsigned int flags),
 225
 226         TP_ARGS(inode, pos, len, flags)
 227 );
 228
 229 DECLARE_EVENT_CLASS(ext4__write_end,
 230         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 231                         unsigned int copied),
 232
 233         TP_ARGS(inode, pos, len, copied),
 234
 235         TP_STRUCT__entry(
 236                 __field(        dev_t,  dev                     )
 237                 __field(        ino_t,  ino                     )
 238                 __field(        loff_t, pos                     )
 239                 __field(        unsigned int, len               )
 240                 __field(        unsigned int, copied            )
 241         ),
 242
 243         TP_fast_assign(
 244                 __entry->dev    = inode->i_sb->s_dev;
 245                 __entry->ino    = inode->i_ino;
 246                 __entry->pos    = pos;
 247                 __entry->len    = len;
 248                 __entry->copied = copied;
 249         ),
 250
 251         TP_printk("dev %d,%d ino %lu pos %llu len %u copied %u",
 252                   MAJOR(__entry->dev), MINOR(__entry->dev),
 253                   (unsigned long) __entry->ino,
 254                   __entry->pos, __entry->len, __entry->copied)
 255 );
 256
 257 DEFINE_EVENT(ext4__write_end, ext4_ordered_write_end,
 258
 259         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 260                  unsigned int copied),
 261
 262         TP_ARGS(inode, pos, len, copied)
 263 );
 264
 265 DEFINE_EVENT(ext4__write_end, ext4_writeback_write_end,
 266
 267         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 268                  unsigned int copied),
 269
 270         TP_ARGS(inode, pos, len, copied)
 271 );
 272
 273 DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
 274
 275         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 276                  unsigned int copied),
 277
 278         TP_ARGS(inode, pos, len, copied)
 279 );
 280
 281 DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
 282
 283         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 284                  unsigned int copied),
 285
 286         TP_ARGS(inode, pos, len, copied)
 287 );
 288
 289 TRACE_EVENT(ext4_writepage,
 290         TP_PROTO(struct inode *inode, struct page *page),
 291
 292         TP_ARGS(inode, page),
 293
 294         TP_STRUCT__entry(
 295                 __field(        dev_t,  dev                     )
 296                 __field(        ino_t,  ino                     )
 297                 __field(        pgoff_t, index                  )
 298
 299         ),
 300
 301         TP_fast_assign(
 302                 __entry->dev    = inode->i_sb->s_dev;
 303                 __entry->ino    = inode->i_ino;
 304                 __entry->index  = page->index;
 305         ),
 306
 307         TP_printk("dev %d,%d ino %lu page_index %lu",
 308                   MAJOR(__entry->dev), MINOR(__entry->dev),
 309                   (unsigned long) __entry->ino, __entry->index)
 310 );
 311
 312 TRACE_EVENT(ext4_da_writepages,
 313         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 314
 315         TP_ARGS(inode, wbc),
 316
 317         TP_STRUCT__entry(
 318                 __field(        dev_t,  dev                     )
 319                 __field(        ino_t,  ino                     )
 320                 __field(        long,   nr_to_write             )
 321                 __field(        long,   pages_skipped           )
 322                 __field(        loff_t, range_start             )
 323                 __field(        loff_t, range_end               )
 324                 __field(        int,    sync_mode               )
 325                 __field(        char,   for_kupdate             )
 326                 __field(        char,   range_cyclic            )
 327                 __field(       pgoff_t, writeback_index         )
 328         ),
 329
 330         TP_fast_assign(
 331                 __entry->dev            = inode->i_sb->s_dev;
 332                 __entry->ino            = inode->i_ino;
 333                 __entry->nr_to_write    = wbc->nr_to_write;
 334                 __entry->pages_skipped  = wbc->pages_skipped;
 335                 __entry->range_start    = wbc->range_start;
 336                 __entry->range_end      = wbc->range_end;
 337                 __entry->sync_mode      = wbc->sync_mode;
 338                 __entry->for_kupdate    = wbc->for_kupdate;
 339                 __entry->range_cyclic   = wbc->range_cyclic;
 340                 __entry->writeback_index = inode->i_mapping->writeback_index;
 341         ),
 342
 343         TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
 344                   "range_start %llu range_end %llu sync_mode %d"
 345                   "for_kupdate %d range_cyclic %d writeback_index %lu",
 346                   MAJOR(__entry->dev), MINOR(__entry->dev),
 347                   (unsigned long) __entry->ino, __entry->nr_to_write,
 348                   __entry->pages_skipped, __entry->range_start,
 349                   __entry->range_end, __entry->sync_mode,
 350                   __entry->for_kupdate, __entry->range_cyclic,
 351                   (unsigned long) __entry->writeback_index)
 352 );
 353
 354 TRACE_EVENT(ext4_da_write_pages,
 355         TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
 356
 357         TP_ARGS(inode, mpd),
 358
 359         TP_STRUCT__entry(
 360                 __field(        dev_t,  dev                     )
 361                 __field(        ino_t,  ino                     )
 362                 __field(        __u64,  b_blocknr               )
 363                 __field(        __u32,  b_size                  )
 364                 __field(        __u32,  b_state                 )
 365                 __field(        unsigned long,  first_page      )
 366                 __field(        int,    io_done                 )
 367                 __field(        int,    pages_written           )
 368                 __field(        int,    sync_mode               )
 369         ),
 370
 371         TP_fast_assign(
 372                 __entry->dev            = inode->i_sb->s_dev;
 373                 __entry->ino            = inode->i_ino;
 374                 __entry->b_blocknr      = mpd->b_blocknr;
 375                 __entry->b_size         = mpd->b_size;
 376                 __entry->b_state        = mpd->b_state;
 377                 __entry->first_page     = mpd->first_page;
 378                 __entry->io_done        = mpd->io_done;
 379                 __entry->pages_written  = mpd->pages_written;
 380                 __entry->sync_mode      = mpd->wbc->sync_mode;
 381         ),
 382
 383         TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
 384                   "first_page %lu io_done %d pages_written %d sync_mode %d",
 385                   MAJOR(__entry->dev), MINOR(__entry->dev),
 386                   (unsigned long) __entry->ino,
 387                   __entry->b_blocknr, __entry->b_size,
 388                   __entry->b_state, __entry->first_page,
 389                   __entry->io_done, __entry->pages_written,
 390                   __entry->sync_mode
 391                   )
 392 );
 393
 394 TRACE_EVENT(ext4_da_writepages_result,
 395         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
 396                         int ret, int pages_written),
 397
 398         TP_ARGS(inode, wbc, ret, pages_written),
 399
 400         TP_STRUCT__entry(
 401                 __field(        dev_t,  dev                     )
 402                 __field(        ino_t,  ino                     )
 403                 __field(        int,    ret                     )
 404                 __field(        int,    pages_written           )
 405                 __field(        long,   pages_skipped           )
 406                 __field(        int,    sync_mode               )
 407                 __field(        char,   more_io                 )
 408                 __field(       pgoff_t, writeback_index         )
 409         ),
 410
 411         TP_fast_assign(
 412                 __entry->dev            = inode->i_sb->s_dev;
 413                 __entry->ino            = inode->i_ino;
 414                 __entry->ret            = ret;
 415                 __entry->pages_written  = pages_written;
 416                 __entry->pages_skipped  = wbc->pages_skipped;
 417                 __entry->sync_mode      = wbc->sync_mode;
 418                 __entry->more_io        = wbc->more_io;
 419                 __entry->writeback_index = inode->i_mapping->writeback_index;
 420         ),
 421
 422         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 423                   " more_io %d sync_mode %d writeback_index %lu",
 424                   MAJOR(__entry->dev), MINOR(__entry->dev),
 425                   (unsigned long) __entry->ino, __entry->ret,
 426                   __entry->pages_written, __entry->pages_skipped,
 427                   __entry->more_io, __entry->sync_mode,
 428                   (unsigned long) __entry->writeback_index)
 429 );
 430
 431 DECLARE_EVENT_CLASS(ext4__page_op,
 432         TP_PROTO(struct page *page),
 433
 434         TP_ARGS(page),
 435
 436         TP_STRUCT__entry(
 437                 __field(        pgoff_t, index                  )
 438                 __field(        ino_t,  ino                     )
 439                 __field(        dev_t,  dev                     )
 440
 441         ),
 442
 443         TP_fast_assign(
 444                 __entry->index  = page->index;
 445                 __entry->ino    = page->mapping->host->i_ino;
 446                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 447         ),
 448
 449         TP_printk("dev %d,%d ino %lu page_index %lu",
 450                   MAJOR(__entry->dev), MINOR(__entry->dev),
 451                   (unsigned long) __entry->ino,
 452                   __entry->index)
 453 );
 454
 455 DEFINE_EVENT(ext4__page_op, ext4_readpage,
 456
 457         TP_PROTO(struct page *page),
 458
 459         TP_ARGS(page)
 460 );
 461
 462 DEFINE_EVENT(ext4__page_op, ext4_releasepage,
 463
 464         TP_PROTO(struct page *page),
 465
 466         TP_ARGS(page)
 467 );
 468
 469 TRACE_EVENT(ext4_invalidatepage,
 470         TP_PROTO(struct page *page, unsigned long offset),
 471
 472         TP_ARGS(page, offset),
 473
 474         TP_STRUCT__entry(
 475                 __field(        pgoff_t, index                  )
 476                 __field(        unsigned long, offset           )
 477                 __field(        ino_t,  ino                     )
 478                 __field(        dev_t,  dev                     )
 479
 480         ),
 481
 482         TP_fast_assign(
 483                 __entry->index  = page->index;
 484                 __entry->offset = offset;
 485                 __entry->ino    = page->mapping->host->i_ino;
 486                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 487         ),
 488
 489         TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
 490                   MAJOR(__entry->dev), MINOR(__entry->dev),
 491                   (unsigned long) __entry->ino,
 492                   __entry->index, __entry->offset)
 493 );
 494
 495 TRACE_EVENT(ext4_discard_blocks,
 496         TP_PROTO(struct super_block *sb, unsigned long long blk,
 497                         unsigned long long count),
 498
 499         TP_ARGS(sb, blk, count),
 500
 501         TP_STRUCT__entry(
 502                 __field(        dev_t,  dev                     )
 503                 __field(        __u64,  blk                     )
 504                 __field(        __u64,  count                   )
 505
 506         ),
 507
 508         TP_fast_assign(
 509                 __entry->dev    = sb->s_dev;
 510                 __entry->blk    = blk;
 511                 __entry->count  = count;
 512         ),
 513
 514         TP_printk("dev %d,%d blk %llu count %llu",
 515                   MAJOR(__entry->dev), MINOR(__entry->dev),
 516                   __entry->blk, __entry->count)
 517 );
 518
 519 DECLARE_EVENT_CLASS(ext4__mb_new_pa,
 520         TP_PROTO(struct ext4_allocation_context *ac,
 521                  struct ext4_prealloc_space *pa),
 522
 523         TP_ARGS(ac, pa),
 524
 525         TP_STRUCT__entry(
 526                 __field(        dev_t,  dev                     )
 527                 __field(        ino_t,  ino                     )
 528                 __field(        __u64,  pa_pstart               )
 529                 __field(        __u32,  pa_len                  )
 530                 __field(        __u64,  pa_lstart               )
 531
 532         ),
 533
 534         TP_fast_assign(
 535                 __entry->dev            = ac->ac_sb->s_dev;
 536                 __entry->ino            = ac->ac_inode->i_ino;
 537                 __entry->pa_pstart      = pa->pa_pstart;
 538                 __entry->pa_len         = pa->pa_len;
 539                 __entry->pa_lstart      = pa->pa_lstart;
 540         ),
 541
 542         TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
 543                   MAJOR(__entry->dev), MINOR(__entry->dev),
 544                   (unsigned long) __entry->ino,
 545                   __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 546 );
 547
 548 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
 549
 550         TP_PROTO(struct ext4_allocation_context *ac,
 551                  struct ext4_prealloc_space *pa),
 552
 553         TP_ARGS(ac, pa)
 554 );
 555
 556 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
 557
 558         TP_PROTO(struct ext4_allocation_context *ac,
 559                  struct ext4_prealloc_space *pa),
 560
 561         TP_ARGS(ac, pa)
 562 );
 563
 564 TRACE_EVENT(ext4_mb_release_inode_pa,
 565         TP_PROTO(struct super_block *sb,
 566                  struct inode *inode,
 567                  struct ext4_prealloc_space *pa,
 568                  unsigned long long block, unsigned int count),
 569
 570         TP_ARGS(sb, inode, pa, block, count),
 571
 572         TP_STRUCT__entry(
 573                 __field(        dev_t,  dev                     )
 574                 __field(        ino_t,  ino                     )
 575                 __field(        __u64,  block                   )
 576                 __field(        __u32,  count                   )
 577
 578         ),
 579
 580         TP_fast_assign(
 581                 __entry->dev            = sb->s_dev;
 582                 __entry->ino            = inode->i_ino;
 583                 __entry->block          = block;
 584                 __entry->count          = count;
 585         ),
 586
 587         TP_printk("dev %d,%d ino %lu block %llu count %u",
 588                   MAJOR(__entry->dev), MINOR(__entry->dev),
 589                   (unsigned long) __entry->ino,
 590                   __entry->block, __entry->count)
 591 );
 592
 593 TRACE_EVENT(ext4_mb_release_group_pa,
 594         TP_PROTO(struct super_block *sb,
 595                  struct ext4_prealloc_space *pa),
 596
 597         TP_ARGS(sb, pa),
 598
 599         TP_STRUCT__entry(
 600                 __field(        dev_t,  dev                     )
 601                 __field(        __u64,  pa_pstart               )
 602                 __field(        __u32,  pa_len                  )
 603
 604         ),
 605
 606         TP_fast_assign(
 607                 __entry->dev            = sb->s_dev;
 608                 __entry->pa_pstart      = pa->pa_pstart;
 609                 __entry->pa_len         = pa->pa_len;
 610         ),
 611
 612         TP_printk("dev %d,%d pstart %llu len %u",
 613                   MAJOR(__entry->dev), MINOR(__entry->dev),
 614                   __entry->pa_pstart, __entry->pa_len)
 615 );
 616
 617 TRACE_EVENT(ext4_discard_preallocations,
 618         TP_PROTO(struct inode *inode),
 619
 620         TP_ARGS(inode),
 621
 622         TP_STRUCT__entry(
 623                 __field(        dev_t,  dev                     )
 624                 __field(        ino_t,  ino                     )
 625
 626         ),
 627
 628         TP_fast_assign(
 629                 __entry->dev    = inode->i_sb->s_dev;
 630                 __entry->ino    = inode->i_ino;
 631         ),
 632
 633         TP_printk("dev %d,%d ino %lu",
 634                   MAJOR(__entry->dev), MINOR(__entry->dev),
 635                   (unsigned long) __entry->ino)
 636 );
 637
 638 TRACE_EVENT(ext4_mb_discard_preallocations,
 639         TP_PROTO(struct super_block *sb, int needed),
 640
 641         TP_ARGS(sb, needed),
 642
 643         TP_STRUCT__entry(
 644                 __field(        dev_t,  dev                     )
 645                 __field(        int,    needed                  )
 646
 647         ),
 648
 649         TP_fast_assign(
 650                 __entry->dev    = sb->s_dev;
 651                 __entry->needed = needed;
 652         ),
 653
 654         TP_printk("dev %d,%d needed %d",
 655                   MAJOR(__entry->dev), MINOR(__entry->dev),
 656                   __entry->needed)
 657 );
 658
 659 TRACE_EVENT(ext4_request_blocks,
 660         TP_PROTO(struct ext4_allocation_request *ar),
 661
 662         TP_ARGS(ar),
 663
 664         TP_STRUCT__entry(
 665                 __field(        dev_t,  dev                     )
 666                 __field(        ino_t,  ino                     )
 667                 __field(        unsigned int, flags             )
 668                 __field(        unsigned int, len               )
 669                 __field(        __u64,  logical                 )
 670                 __field(        __u64,  goal                    )
 671                 __field(        __u64,  lleft                   )
 672                 __field(        __u64,  lright                  )
 673                 __field(        __u64,  pleft                   )
 674                 __field(        __u64,  pright                  )
 675         ),
 676
 677         TP_fast_assign(
 678                 __entry->dev    = ar->inode->i_sb->s_dev;
 679                 __entry->ino    = ar->inode->i_ino;
 680                 __entry->flags  = ar->flags;
 681                 __entry->len    = ar->len;
 682                 __entry->logical = ar->logical;
 683                 __entry->goal   = ar->goal;
 684                 __entry->lleft  = ar->lleft;
 685                 __entry->lright = ar->lright;
 686                 __entry->pleft  = ar->pleft;
 687                 __entry->pright = ar->pright;
 688         ),
 689
 690         TP_printk("dev %d,%d ino %lu flags %u len %u lblk %llu goal %llu "
 691                   "lleft %llu lright %llu pleft %llu pright %llu ",
 692                   MAJOR(__entry->dev), MINOR(__entry->dev),
 693                   (unsigned long) __entry->ino,
 694                   __entry->flags, __entry->len,
 695                   (unsigned long long) __entry->logical,
 696                   (unsigned long long) __entry->goal,
 697                   (unsigned long long) __entry->lleft,
 698                   (unsigned long long) __entry->lright,
 699                   (unsigned long long) __entry->pleft,
 700                   (unsigned long long) __entry->pright)
 701 );
 702
 703 TRACE_EVENT(ext4_allocate_blocks,
 704         TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
 705
 706         TP_ARGS(ar, block),
 707
 708         TP_STRUCT__entry(
 709                 __field(        dev_t,  dev                     )
 710                 __field(        ino_t,  ino                     )
 711                 __field(        __u64,  block                   )
 712                 __field(        unsigned int, flags             )
 713                 __field(        unsigned int, len               )
 714                 __field(        __u64,  logical                 )
 715                 __field(        __u64,  goal                    )
 716                 __field(        __u64,  lleft                   )
 717                 __field(        __u64,  lright                  )
 718                 __field(        __u64,  pleft                   )
 719                 __field(        __u64,  pright                  )
 720         ),
 721
 722         TP_fast_assign(
 723                 __entry->dev    = ar->inode->i_sb->s_dev;
 724                 __entry->ino    = ar->inode->i_ino;
 725                 __entry->block  = block;
 726                 __entry->flags  = ar->flags;
 727                 __entry->len    = ar->len;
 728                 __entry->logical = ar->logical;
 729                 __entry->goal   = ar->goal;
 730                 __entry->lleft  = ar->lleft;
 731                 __entry->lright = ar->lright;
 732                 __entry->pleft  = ar->pleft;
 733                 __entry->pright = ar->pright;
 734         ),
 735
 736         TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %llu "
 737                   "goal %llu lleft %llu lright %llu pleft %llu pright %llu",
 738                   MAJOR(__entry->dev), MINOR(__entry->dev),
 739                   (unsigned long) __entry->ino,
 740                   __entry->flags, __entry->len, __entry->block,
 741                   (unsigned long long) __entry->logical,
 742                   (unsigned long long) __entry->goal,
 743                   (unsigned long long) __entry->lleft,
 744                   (unsigned long long) __entry->lright,
 745                   (unsigned long long) __entry->pleft,
 746                   (unsigned long long) __entry->pright)
 747 );
 748
 749 TRACE_EVENT(ext4_free_blocks,
 750         TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
 751                  int flags),
 752
 753         TP_ARGS(inode, block, count, flags),
 754
 755         TP_STRUCT__entry(
 756                 __field(        dev_t,  dev                     )
 757                 __field(        ino_t,  ino                     )
 758                 __field(      umode_t, mode                     )
 759                 __field(        __u64,  block                   )
 760                 __field(        unsigned long,  count           )
 761                 __field(         int,   flags                   )
 762         ),
 763
 764         TP_fast_assign(
 765                 __entry->dev            = inode->i_sb->s_dev;
 766                 __entry->ino            = inode->i_ino;
 767                 __entry->mode           = inode->i_mode;
 768                 __entry->block          = block;
 769                 __entry->count          = count;
 770                 __entry->flags          = flags;
 771         ),
 772
 773         TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
 774                   MAJOR(__entry->dev), MINOR(__entry->dev),
 775                   (unsigned long) __entry->ino,
 776                   __entry->mode, __entry->block, __entry->count,
 777                   __entry->flags)
 778 );
 779
 780 TRACE_EVENT(ext4_sync_file_enter,
 781         TP_PROTO(struct file *file, int datasync),
 782
 783         TP_ARGS(file, datasync),
 784
 785         TP_STRUCT__entry(
 786                 __field(        dev_t,  dev                     )
 787                 __field(        ino_t,  ino                     )
 788                 __field(        ino_t,  parent                  )
 789                 __field(        int,    datasync                )
 790         ),
 791
 792         TP_fast_assign(
 793                 struct dentry *dentry = file->f_path.dentry;
 794
 795                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
 796                 __entry->ino            = dentry->d_inode->i_ino;
 797                 __entry->datasync       = datasync;
 798                 __entry->parent         = dentry->d_parent->d_inode->i_ino;
 799         ),
 800
 801         TP_printk("dev %d,%d ino %ld parent %ld datasync %d ",
 802                   MAJOR(__entry->dev), MINOR(__entry->dev),
 803                   (unsigned long) __entry->ino,
 804                   (unsigned long) __entry->parent, __entry->datasync)
 805 );
 806
 807 TRACE_EVENT(ext4_sync_file_exit,
 808         TP_PROTO(struct inode *inode, int ret),
 809
 810         TP_ARGS(inode, ret),
 811
 812         TP_STRUCT__entry(
 813                 __field(        int,    ret                     )
 814                 __field(        ino_t,  ino                     )
 815                 __field(        dev_t,  dev                     )
 816         ),
 817
 818         TP_fast_assign(
 819                 __entry->ret            = ret;
 820                 __entry->ino            = inode->i_ino;
 821                 __entry->dev            = inode->i_sb->s_dev;
 822         ),
 823
 824         TP_printk("dev %d,%d ino %ld ret %d",
 825                   MAJOR(__entry->dev), MINOR(__entry->dev),
 826                   (unsigned long) __entry->ino,
 827                   __entry->ret)
 828 );
 829
 830 TRACE_EVENT(ext4_sync_fs,
 831         TP_PROTO(struct super_block *sb, int wait),
 832
 833         TP_ARGS(sb, wait),
 834
 835         TP_STRUCT__entry(
 836                 __field(        dev_t,  dev                     )
 837                 __field(        int,    wait                    )
 838
 839         ),
 840
 841         TP_fast_assign(
 842                 __entry->dev    = sb->s_dev;
 843                 __entry->wait   = wait;
 844         ),
 845
 846         TP_printk("dev %d,%d wait %d",
 847                   MAJOR(__entry->dev), MINOR(__entry->dev),
 848                   __entry->wait)
 849 );
 850
 851 TRACE_EVENT(ext4_alloc_da_blocks,
 852         TP_PROTO(struct inode *inode),
 853
 854         TP_ARGS(inode),
 855
 856         TP_STRUCT__entry(
 857                 __field(        dev_t,  dev                     )
 858                 __field(        ino_t,  ino                     )
 859                 __field( unsigned int,  data_blocks     )
 860                 __field( unsigned int,  meta_blocks     )
 861         ),
 862
 863         TP_fast_assign(
 864                 __entry->dev    = inode->i_sb->s_dev;
 865                 __entry->ino    = inode->i_ino;
 866                 __entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
 867                 __entry->meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
 868         ),
 869
 870         TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
 871                   MAJOR(__entry->dev), MINOR(__entry->dev),
 872                   (unsigned long) __entry->ino,
 873                   __entry->data_blocks, __entry->meta_blocks)
 874 );
 875
 876 TRACE_EVENT(ext4_mballoc_alloc,
 877         TP_PROTO(struct ext4_allocation_context *ac),
 878
 879         TP_ARGS(ac),
 880
 881         TP_STRUCT__entry(
 882                 __field(        dev_t,  dev                     )
 883                 __field(        ino_t,  ino                     )
 884                 __field(        __u16,  found                   )
 885                 __field(        __u16,  groups                  )
 886                 __field(        __u16,  buddy                   )
 887                 __field(        __u16,  flags                   )
 888                 __field(        __u16,  tail                    )
 889                 __field(        __u8,   cr                      )
 890                 __field(        __u32,  orig_logical            )
 891                 __field(          int,  orig_start              )
 892                 __field(        __u32,  orig_group              )
 893                 __field(          int,  orig_len                )
 894                 __field(        __u32,  goal_logical            )
 895                 __field(          int,  goal_start              )
 896                 __field(        __u32,  goal_group              )
 897                 __field(          int,  goal_len                )
 898                 __field(        __u32,  result_logical          )
 899                 __field(          int,  result_start            )
 900                 __field(        __u32,  result_group            )
 901                 __field(          int,  result_len              )
 902         ),
 903
 904         TP_fast_assign(
 905                 __entry->dev            = ac->ac_inode->i_sb->s_dev;
 906                 __entry->ino            = ac->ac_inode->i_ino;
 907                 __entry->found          = ac->ac_found;
 908                 __entry->flags          = ac->ac_flags;
 909                 __entry->groups         = ac->ac_groups_scanned;
 910                 __entry->buddy          = ac->ac_buddy;
 911                 __entry->tail           = ac->ac_tail;
 912                 __entry->cr             = ac->ac_criteria;
 913                 __entry->orig_logical   = ac->ac_o_ex.fe_logical;
 914                 __entry->orig_start     = ac->ac_o_ex.fe_start;
 915                 __entry->orig_group     = ac->ac_o_ex.fe_group;
 916                 __entry->orig_len       = ac->ac_o_ex.fe_len;
 917                 __entry->goal_logical   = ac->ac_g_ex.fe_logical;
 918                 __entry->goal_start     = ac->ac_g_ex.fe_start;
 919                 __entry->goal_group     = ac->ac_g_ex.fe_group;
 920                 __entry->goal_len       = ac->ac_g_ex.fe_len;
 921                 __entry->result_logical = ac->ac_f_ex.fe_logical;
 922                 __entry->result_start   = ac->ac_f_ex.fe_start;
 923                 __entry->result_group   = ac->ac_f_ex.fe_group;
 924                 __entry->result_len     = ac->ac_f_ex.fe_len;
 925         ),
 926
 927         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
 928                   "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
 929                   "tail %u broken %u",
 930                   MAJOR(__entry->dev), MINOR(__entry->dev),
 931                   (unsigned long) __entry->ino,
 932                   __entry->orig_group, __entry->orig_start,
 933                   __entry->orig_len, __entry->orig_logical,
 934                   __entry->goal_group, __entry->goal_start,
 935                   __entry->goal_len, __entry->goal_logical,
 936                   __entry->result_group, __entry->result_start,
 937                   __entry->result_len, __entry->result_logical,
 938                   __entry->found, __entry->groups, __entry->cr,
 939                   __entry->flags, __entry->tail,
 940                   __entry->buddy ? 1 << __entry->buddy : 0)
 941 );
 942
 943 TRACE_EVENT(ext4_mballoc_prealloc,
 944         TP_PROTO(struct ext4_allocation_context *ac),
 945
 946         TP_ARGS(ac),
 947
 948         TP_STRUCT__entry(
 949                 __field(        dev_t,  dev                     )
 950                 __field(        ino_t,  ino                     )
 951                 __field(        __u32,  orig_logical            )
 952                 __field(          int,  orig_start              )
 953                 __field(        __u32,  orig_group              )
 954                 __field(          int,  orig_len                )
 955                 __field(        __u32,  result_logical          )
 956                 __field(          int,  result_start            )
 957                 __field(        __u32,  result_group            )
 958                 __field(          int,  result_len              )
 959         ),
 960
 961         TP_fast_assign(
 962                 __entry->dev            = ac->ac_inode->i_sb->s_dev;
 963                 __entry->ino            = ac->ac_inode->i_ino;
 964                 __entry->orig_logical   = ac->ac_o_ex.fe_logical;
 965                 __entry->orig_start     = ac->ac_o_ex.fe_start;
 966                 __entry->orig_group     = ac->ac_o_ex.fe_group;
 967                 __entry->orig_len       = ac->ac_o_ex.fe_len;
 968                 __entry->result_logical = ac->ac_b_ex.fe_logical;
 969                 __entry->result_start   = ac->ac_b_ex.fe_start;
 970                 __entry->result_group   = ac->ac_b_ex.fe_group;
 971                 __entry->result_len     = ac->ac_b_ex.fe_len;
 972         ),
 973
 974         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
 975                   MAJOR(__entry->dev), MINOR(__entry->dev),
 976                   (unsigned long) __entry->ino,
 977                   __entry->orig_group, __entry->orig_start,
 978                   __entry->orig_len, __entry->orig_logical,
 979                   __entry->result_group, __entry->result_start,
 980                   __entry->result_len, __entry->result_logical)
 981 );
 982
 983 DECLARE_EVENT_CLASS(ext4__mballoc,
 984         TP_PROTO(struct super_block *sb,
 985                  struct inode *inode,
 986                  ext4_group_t group,
 987                  ext4_grpblk_t start,
 988                  ext4_grpblk_t len),
 989
 990         TP_ARGS(sb, inode, group, start, len),
 991
 992         TP_STRUCT__entry(
 993                 __field(        dev_t,  dev                     )
 994                 __field(        ino_t,  ino                     )
 995                 __field(          int,  result_start            )
 996                 __field(        __u32,  result_group            )
 997                 __field(          int,  result_len              )
 998         ),
 999
1000         TP_fast_assign(
1001                 __entry->dev            = sb->s_dev;
1002                 __entry->ino            = inode ? inode->i_ino : 0;
1003                 __entry->result_start   = start;
1004                 __entry->result_group   = group;
1005                 __entry->result_len     = len;
1006         ),
1007
1008         TP_printk("dev %d,%d inode %lu extent %u/%d/%u ",
1009                   MAJOR(__entry->dev), MINOR(__entry->dev),
1010                   (unsigned long) __entry->ino,
1011                   __entry->result_group, __entry->result_start,
1012                   __entry->result_len)
1013 );
1014
1015 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
1016
1017         TP_PROTO(struct super_block *sb,
1018                  struct inode *inode,
1019                  ext4_group_t group,
1020                  ext4_grpblk_t start,
1021                  ext4_grpblk_t len),
1022
1023         TP_ARGS(sb, inode, group, start, len)
1024 );
1025
1026 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
1027
1028         TP_PROTO(struct super_block *sb,
1029                  struct inode *inode,
1030                  ext4_group_t group,
1031                  ext4_grpblk_t start,
1032                  ext4_grpblk_t len),
1033
1034         TP_ARGS(sb, inode, group, start, len)
1035 );
1036
1037 TRACE_EVENT(ext4_forget,
1038         TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
1039
1040         TP_ARGS(inode, is_metadata, block),
1041
1042         TP_STRUCT__entry(
1043                 __field(        dev_t,  dev                     )
1044                 __field(        ino_t,  ino                     )
1045                 __field(        umode_t, mode                   )
1046                 __field(        int,    is_metadata             )
1047                 __field(        __u64,  block                   )
1048         ),
1049
1050         TP_fast_assign(
1051                 __entry->dev    = inode->i_sb->s_dev;
1052                 __entry->ino    = inode->i_ino;
1053                 __entry->mode   = inode->i_mode;
1054                 __entry->is_metadata = is_metadata;
1055                 __entry->block  = block;
1056         ),
1057
1058         TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1059                   MAJOR(__entry->dev), MINOR(__entry->dev),
1060                   (unsigned long) __entry->ino,
1061                   __entry->mode, __entry->is_metadata, __entry->block)
1062 );
1063
1064 TRACE_EVENT(ext4_da_update_reserve_space,
1065         TP_PROTO(struct inode *inode, int used_blocks),
1066
1067         TP_ARGS(inode, used_blocks),
1068
1069         TP_STRUCT__entry(
1070                 __field(        dev_t,  dev                     )
1071                 __field(        ino_t,  ino                     )
1072                 __field(        umode_t, mode                   )
1073                 __field(        __u64,  i_blocks                )
1074                 __field(        int,    used_blocks             )
1075                 __field(        int,    reserved_data_blocks    )
1076                 __field(        int,    reserved_meta_blocks    )
1077                 __field(        int,    allocated_meta_blocks   )
1078         ),
1079
1080         TP_fast_assign(
1081                 __entry->dev    = inode->i_sb->s_dev;
1082                 __entry->ino    = inode->i_ino;
1083                 __entry->mode   = inode->i_mode;
1084                 __entry->i_blocks = inode->i_blocks;
1085                 __entry->used_blocks = used_blocks;
1086                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1087                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1088                 __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
1089         ),
1090
1091         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1092                   "reserved_data_blocks %d reserved_meta_blocks %d "
1093                   "allocated_meta_blocks %d",
1094                   MAJOR(__entry->dev), MINOR(__entry->dev),
1095                   (unsigned long) __entry->ino,
1096                   __entry->mode,  (unsigned long long) __entry->i_blocks,
1097                   __entry->used_blocks, __entry->reserved_data_blocks,
1098                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1099 );
1100
1101 TRACE_EVENT(ext4_da_reserve_space,
1102         TP_PROTO(struct inode *inode, int md_needed),
1103
1104         TP_ARGS(inode, md_needed),
1105
1106         TP_STRUCT__entry(
1107                 __field(        dev_t,  dev                     )
1108                 __field(        ino_t,  ino                     )
1109                 __field(        umode_t, mode                   )
1110                 __field(        __u64,  i_blocks                )
1111                 __field(        int,    md_needed               )
1112                 __field(        int,    reserved_data_blocks    )
1113                 __field(        int,    reserved_meta_blocks    )
1114         ),
1115
1116         TP_fast_assign(
1117                 __entry->dev    = inode->i_sb->s_dev;
1118                 __entry->ino    = inode->i_ino;
1119                 __entry->mode   = inode->i_mode;
1120                 __entry->i_blocks = inode->i_blocks;
1121                 __entry->md_needed = md_needed;
1122                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1123                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1124         ),
1125
1126         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
1127                   "reserved_data_blocks %d reserved_meta_blocks %d",
1128                   MAJOR(__entry->dev), MINOR(__entry->dev),
1129                   (unsigned long) __entry->ino,
1130                   __entry->mode, (unsigned long long) __entry->i_blocks,
1131                   __entry->md_needed, __entry->reserved_data_blocks,
1132                   __entry->reserved_meta_blocks)
1133 );
1134
1135 TRACE_EVENT(ext4_da_release_space,
1136         TP_PROTO(struct inode *inode, int freed_blocks),
1137
1138         TP_ARGS(inode, freed_blocks),
1139
1140         TP_STRUCT__entry(
1141                 __field(        dev_t,  dev                     )
1142                 __field(        ino_t,  ino                     )
1143                 __field(        umode_t, mode                   )
1144                 __field(        __u64,  i_blocks                )
1145                 __field(        int,    freed_blocks            )
1146                 __field(        int,    reserved_data_blocks    )
1147                 __field(        int,    reserved_meta_blocks    )
1148                 __field(        int,    allocated_meta_blocks   )
1149         ),
1150
1151         TP_fast_assign(
1152                 __entry->dev    = inode->i_sb->s_dev;
1153                 __entry->ino    = inode->i_ino;
1154                 __entry->mode   = inode->i_mode;
1155                 __entry->i_blocks = inode->i_blocks;
1156                 __entry->freed_blocks = freed_blocks;
1157                 __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1158                 __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
1159                 __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
1160         ),
1161
1162         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
1163                   "reserved_data_blocks %d reserved_meta_blocks %d "
1164                   "allocated_meta_blocks %d",
1165                   MAJOR(__entry->dev), MINOR(__entry->dev),
1166                   (unsigned long) __entry->ino,
1167                   __entry->mode, (unsigned long long) __entry->i_blocks,
1168                   __entry->freed_blocks, __entry->reserved_data_blocks,
1169                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1170 );
1171
1172 DECLARE_EVENT_CLASS(ext4__bitmap_load,
1173         TP_PROTO(struct super_block *sb, unsigned long group),
1174
1175         TP_ARGS(sb, group),
1176
1177         TP_STRUCT__entry(
1178                 __field(        dev_t,  dev                     )
1179                 __field(        __u32,  group                   )
1180
1181         ),
1182
1183         TP_fast_assign(
1184                 __entry->dev    = sb->s_dev;
1185                 __entry->group  = group;
1186         ),
1187
1188         TP_printk("dev %d,%d group %u",
1189                   MAJOR(__entry->dev), MINOR(__entry->dev),
1190                   __entry->group)
1191 );
1192
1193 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_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_mb_buddy_bitmap_load,
1201
1202         TP_PROTO(struct super_block *sb, unsigned long group),
1203
1204         TP_ARGS(sb, group)
1205 );
1206
1207 DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
1208
1209         TP_PROTO(struct super_block *sb, unsigned long group),
1210
1211         TP_ARGS(sb, group)
1212 );
1213
1214 DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
1215
1216         TP_PROTO(struct super_block *sb, unsigned long group),
1217
1218         TP_ARGS(sb, group)
1219 );
1220
1221 TRACE_EVENT(ext4_direct_IO_enter,
1222         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
1223
1224         TP_ARGS(inode, offset, len, rw),
1225
1226         TP_STRUCT__entry(
1227                 __field(        ino_t,  ino                     )
1228                 __field(        dev_t,  dev                     )
1229                 __field(        loff_t, pos                     )
1230                 __field(        unsigned long,  len             )
1231                 __field(        int,    rw                      )
1232         ),
1233
1234         TP_fast_assign(
1235                 __entry->ino    = inode->i_ino;
1236                 __entry->dev    = inode->i_sb->s_dev;
1237                 __entry->pos    = offset;
1238                 __entry->len    = len;
1239                 __entry->rw     = rw;
1240         ),
1241
1242         TP_printk("dev %d,%d ino %lu pos %llu len %lu rw %d",
1243                   MAJOR(__entry->dev), MINOR(__entry->dev),
1244                   (unsigned long) __entry->ino,
1245                   (unsigned long long) __entry->pos, __entry->len, __entry->rw)
1246 );
1247
1248 TRACE_EVENT(ext4_direct_IO_exit,
1249         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw, int ret),
1250
1251         TP_ARGS(inode, offset, len, rw, ret),
1252
1253         TP_STRUCT__entry(
1254                 __field(        ino_t,  ino                     )
1255                 __field(        dev_t,  dev                     )
1256                 __field(        loff_t, pos                     )
1257                 __field(        unsigned long,  len             )
1258                 __field(        int,    rw                      )
1259                 __field(        int,    ret                     )
1260         ),
1261
1262         TP_fast_assign(
1263                 __entry->ino    = inode->i_ino;
1264                 __entry->dev    = inode->i_sb->s_dev;
1265                 __entry->pos    = offset;
1266                 __entry->len    = len;
1267                 __entry->rw     = rw;
1268                 __entry->ret    = ret;
1269         ),
1270
1271         TP_printk("dev %d,%d ino %lu pos %llu len %lu rw %d ret %d",
1272                   MAJOR(__entry->dev), MINOR(__entry->dev),
1273                   (unsigned long) __entry->ino,
1274                   (unsigned long long) __entry->pos, __entry->len,
1275                   __entry->rw, __entry->ret)
1276 );
1277
1278 TRACE_EVENT(ext4_fallocate_enter,
1279         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1280
1281         TP_ARGS(inode, offset, len, mode),
1282
1283         TP_STRUCT__entry(
1284                 __field(        ino_t,  ino                     )
1285                 __field(        dev_t,  dev                     )
1286                 __field(        loff_t, pos                     )
1287                 __field(        loff_t, len                     )
1288                 __field(        int,    mode                    )
1289         ),
1290
1291         TP_fast_assign(
1292                 __entry->ino    = inode->i_ino;
1293                 __entry->dev    = inode->i_sb->s_dev;
1294                 __entry->pos    = offset;
1295                 __entry->len    = len;
1296                 __entry->mode   = mode;
1297         ),
1298
1299         TP_printk("dev %d,%d ino %ld pos %llu len %llu mode %d",
1300                   MAJOR(__entry->dev), MINOR(__entry->dev),
1301                   (unsigned long) __entry->ino,
1302                   (unsigned long long) __entry->pos,
1303                   (unsigned long long) __entry->len, __entry->mode)
1304 );
1305
1306 TRACE_EVENT(ext4_fallocate_exit,
1307         TP_PROTO(struct inode *inode, loff_t offset, unsigned int max_blocks, int ret),
1308
1309         TP_ARGS(inode, offset, max_blocks, ret),
1310
1311         TP_STRUCT__entry(
1312                 __field(        ino_t,  ino                     )
1313                 __field(        dev_t,  dev                     )
1314                 __field(        loff_t, pos                     )
1315                 __field(        unsigned,       blocks          )
1316                 __field(        int,    ret                     )
1317         ),
1318
1319         TP_fast_assign(
1320                 __entry->ino    = inode->i_ino;
1321                 __entry->dev    = inode->i_sb->s_dev;
1322                 __entry->pos    = offset;
1323                 __entry->blocks = max_blocks;
1324                 __entry->ret    = ret;
1325         ),
1326
1327         TP_printk("dev %d,%d ino %ld pos %llu blocks %d ret %d",
1328                   MAJOR(__entry->dev), MINOR(__entry->dev),
1329                   (unsigned long) __entry->ino,
1330                   (unsigned long long) __entry->pos, __entry->blocks,
1331                   __entry->ret)
1332 );
1333
1334 TRACE_EVENT(ext4_unlink_enter,
1335         TP_PROTO(struct inode *parent, struct dentry *dentry),
1336
1337         TP_ARGS(parent, dentry),
1338
1339         TP_STRUCT__entry(
1340                 __field(        ino_t,  parent                  )
1341                 __field(        ino_t,  ino                     )
1342                 __field(        loff_t, size                    )
1343                 __field(        dev_t,  dev                     )
1344         ),
1345
1346         TP_fast_assign(
1347                 __entry->parent         = parent->i_ino;
1348                 __entry->ino            = dentry->d_inode->i_ino;
1349                 __entry->size           = dentry->d_inode->i_size;
1350                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
1351         ),
1352
1353         TP_printk("dev %d,%d ino %ld size %lld parent %ld",
1354                   MAJOR(__entry->dev), MINOR(__entry->dev),
1355                   (unsigned long) __entry->ino, __entry->size,
1356                   (unsigned long) __entry->parent)
1357 );
1358
1359 TRACE_EVENT(ext4_unlink_exit,
1360         TP_PROTO(struct dentry *dentry, int ret),
1361
1362         TP_ARGS(dentry, ret),
1363
1364         TP_STRUCT__entry(
1365                 __field(        ino_t,  ino                     )
1366                 __field(        dev_t,  dev                     )
1367                 __field(        int,    ret                     )
1368         ),
1369
1370         TP_fast_assign(
1371                 __entry->ino            = dentry->d_inode->i_ino;
1372                 __entry->dev            = dentry->d_inode->i_sb->s_dev;
1373                 __entry->ret            = ret;
1374         ),
1375
1376         TP_printk("dev %d,%d ino %ld ret %d",
1377                   MAJOR(__entry->dev), MINOR(__entry->dev),
1378                   (unsigned long) __entry->ino,
1379                   __entry->ret)
1380 );
1381
1382 DECLARE_EVENT_CLASS(ext4__truncate,
1383         TP_PROTO(struct inode *inode),
1384
1385         TP_ARGS(inode),
1386
1387         TP_STRUCT__entry(
1388                 __field(        ino_t,          ino             )
1389                 __field(        dev_t,          dev             )
1390                 __field(        blkcnt_t,       blocks          )
1391         ),
1392
1393         TP_fast_assign(
1394                 __entry->ino    = inode->i_ino;
1395                 __entry->dev    = inode->i_sb->s_dev;
1396                 __entry->blocks = inode->i_blocks;
1397         ),
1398
1399         TP_printk("dev %d,%d ino %lu blocks %lu",
1400                   MAJOR(__entry->dev), MINOR(__entry->dev),
1401                   (unsigned long) __entry->ino, (unsigned long) __entry->blocks)
1402 );
1403
1404 DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
1405
1406         TP_PROTO(struct inode *inode),
1407
1408         TP_ARGS(inode)
1409 );
1410
1411 DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
1412
1413         TP_PROTO(struct inode *inode),
1414
1415         TP_ARGS(inode)
1416 );
1417
1418 DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
1419         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1420                  unsigned len, unsigned flags),
1421
1422         TP_ARGS(inode, lblk, len, flags),
1423
1424         TP_STRUCT__entry(
1425                 __field(        ino_t,          ino             )
1426                 __field(        dev_t,          dev             )
1427                 __field(        ext4_lblk_t,    lblk            )
1428                 __field(        unsigned,       len             )
1429                 __field(        unsigned,       flags           )
1430         ),
1431
1432         TP_fast_assign(
1433                 __entry->ino    = inode->i_ino;
1434                 __entry->dev    = inode->i_sb->s_dev;
1435                 __entry->lblk   = lblk;
1436                 __entry->len    = len;
1437                 __entry->flags  = flags;
1438         ),
1439
1440         TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
1441                   MAJOR(__entry->dev), MINOR(__entry->dev),
1442                   (unsigned long) __entry->ino,
1443                   (unsigned) __entry->lblk, __entry->len, __entry->flags)
1444 );
1445
1446 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
1447         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1448                  unsigned len, unsigned flags),
1449
1450         TP_ARGS(inode, lblk, len, flags)
1451 );
1452
1453 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
1454         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1455                  unsigned len, unsigned flags),
1456
1457         TP_ARGS(inode, lblk, len, flags)
1458 );
1459
1460 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
1461         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1462                  ext4_fsblk_t pblk, unsigned len, int ret),
1463
1464         TP_ARGS(inode, lblk, pblk, len, ret),
1465
1466         TP_STRUCT__entry(
1467                 __field(        ino_t,          ino             )
1468                 __field(        dev_t,          dev             )
1469                 __field(        ext4_lblk_t,    lblk            )
1470                 __field(        ext4_fsblk_t,   pblk            )
1471                 __field(        unsigned,       len             )
1472                 __field(        int,            ret             )
1473         ),
1474
1475         TP_fast_assign(
1476                 __entry->ino    = inode->i_ino;
1477                 __entry->dev    = inode->i_sb->s_dev;
1478                 __entry->lblk   = lblk;
1479                 __entry->pblk   = pblk;
1480                 __entry->len    = len;
1481                 __entry->ret    = ret;
1482         ),
1483
1484         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u ret %d",
1485                   MAJOR(__entry->dev), MINOR(__entry->dev),
1486                   (unsigned long) __entry->ino,
1487                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
1488                   __entry->len, __entry->ret)
1489 );
1490
1491 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
1492         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1493                  ext4_fsblk_t pblk, unsigned len, int ret),
1494
1495         TP_ARGS(inode, lblk, pblk, len, ret)
1496 );
1497
1498 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
1499         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1500                  ext4_fsblk_t pblk, unsigned len, int ret),
1501
1502         TP_ARGS(inode, lblk, pblk, len, ret)
1503 );
1504
1505 TRACE_EVENT(ext4_ext_load_extent,
1506         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
1507
1508         TP_ARGS(inode, lblk, pblk),
1509
1510         TP_STRUCT__entry(
1511                 __field(        ino_t,          ino             )
1512                 __field(        dev_t,          dev             )
1513                 __field(        ext4_lblk_t,    lblk            )
1514                 __field(        ext4_fsblk_t,   pblk            )
1515         ),
1516
1517         TP_fast_assign(
1518                 __entry->ino    = inode->i_ino;
1519                 __entry->dev    = inode->i_sb->s_dev;
1520                 __entry->lblk   = lblk;
1521                 __entry->pblk   = pblk;
1522         ),
1523
1524         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
1525                   MAJOR(__entry->dev), MINOR(__entry->dev),
1526                   (unsigned long) __entry->ino,
1527                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk)
1528 );
1529
1530 TRACE_EVENT(ext4_load_inode,
1531         TP_PROTO(struct inode *inode),
1532
1533         TP_ARGS(inode),
1534
1535         TP_STRUCT__entry(
1536                 __field(        ino_t,  ino             )
1537                 __field(        dev_t,  dev             )
1538         ),
1539
1540         TP_fast_assign(
1541                 __entry->ino            = inode->i_ino;
1542                 __entry->dev            = inode->i_sb->s_dev;
1543         ),
1544
1545         TP_printk("dev %d,%d ino %ld",
1546                   MAJOR(__entry->dev), MINOR(__entry->dev),
1547                   (unsigned long) __entry->ino)
1548 );
1549
1550 #endif /* _TRACE_EXT4_H */
1551
1552 /* This part must be outside protection */
1553 #include <trace/define_trace.h>