drivers/staging/lttng/instrumentation/events/lttng-module/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 #include <linux/version.h>
  10
  11 #ifndef _TRACE_EXT4_DEF_
  12 #define _TRACE_EXT4_DEF_
  13 struct ext4_allocation_context;
  14 struct ext4_allocation_request;
  15 struct ext4_prealloc_space;
  16 struct ext4_inode_info;
  17 struct mpage_da_data;
  18 struct ext4_map_blocks;
  19 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
  20 struct ext4_extent;
  21 #endif
  22 #endif
  23
  24 #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
  25 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
  26 #define TP_MODE_T       __u16
  27 #else
  28 #define TP_MODE_T       umode_t
  29 #endif
  30
  31 TRACE_EVENT(ext4_free_inode,
  32         TP_PROTO(struct inode *inode),
  33
  34         TP_ARGS(inode),
  35
  36         TP_STRUCT__entry(
  37                 __field(        dev_t,  dev                     )
  38                 __field(        ino_t,  ino                     )
  39                 __field(        uid_t,  uid                     )
  40                 __field(        gid_t,  gid                     )
  41                 __field(        __u64, blocks                   )
  42                 __field(        TP_MODE_T, mode                 )
  43         ),
  44
  45         TP_fast_assign(
  46                 tp_assign(dev, inode->i_sb->s_dev)
  47                 tp_assign(ino, inode->i_ino)
  48 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0))
  49                 tp_assign(uid, i_uid_read(inode))
  50                 tp_assign(gid, i_gid_read(inode))
  51 #else
  52                 tp_assign(uid, inode->i_uid)
  53                 tp_assign(gid, inode->i_gid)
  54 #endif
  55                 tp_assign(blocks, inode->i_blocks)
  56                 tp_assign(mode, inode->i_mode)
  57         ),
  58
  59         TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
  60                   MAJOR(__entry->dev), MINOR(__entry->dev),
  61                   (unsigned long) __entry->ino, __entry->mode,
  62                   __entry->uid, __entry->gid, __entry->blocks)
  63 )
  64
  65 TRACE_EVENT(ext4_request_inode,
  66         TP_PROTO(struct inode *dir, int mode),
  67
  68         TP_ARGS(dir, mode),
  69
  70         TP_STRUCT__entry(
  71                 __field(        dev_t,  dev                     )
  72                 __field(        ino_t,  dir                     )
  73                 __field(        TP_MODE_T, mode                 )
  74         ),
  75
  76         TP_fast_assign(
  77                 tp_assign(dev, dir->i_sb->s_dev)
  78                 tp_assign(dir, dir->i_ino)
  79                 tp_assign(mode, mode)
  80         ),
  81
  82         TP_printk("dev %d,%d dir %lu mode 0%o",
  83                   MAJOR(__entry->dev), MINOR(__entry->dev),
  84                   (unsigned long) __entry->dir, __entry->mode)
  85 )
  86
  87 TRACE_EVENT(ext4_allocate_inode,
  88         TP_PROTO(struct inode *inode, struct inode *dir, int mode),
  89
  90         TP_ARGS(inode, dir, mode),
  91
  92         TP_STRUCT__entry(
  93                 __field(        dev_t,  dev                     )
  94                 __field(        ino_t,  ino                     )
  95                 __field(        ino_t,  dir                     )
  96                 __field(        TP_MODE_T, mode                 )
  97         ),
  98
  99         TP_fast_assign(
 100                 tp_assign(dev, inode->i_sb->s_dev)
 101                 tp_assign(ino, inode->i_ino)
 102                 tp_assign(dir, dir->i_ino)
 103                 tp_assign(mode, mode)
 104         ),
 105
 106         TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
 107                   MAJOR(__entry->dev), MINOR(__entry->dev),
 108                   (unsigned long) __entry->ino,
 109                   (unsigned long) __entry->dir, __entry->mode)
 110 )
 111
 112 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 113 TRACE_EVENT(ext4_evict_inode,
 114         TP_PROTO(struct inode *inode),
 115
 116         TP_ARGS(inode),
 117
 118         TP_STRUCT__entry(
 119                 __field(        dev_t,  dev                     )
 120                 __field(        ino_t,  ino                     )
 121                 __field(        int,    nlink                   )
 122         ),
 123
 124         TP_fast_assign(
 125                 tp_assign(dev, inode->i_sb->s_dev)
 126                 tp_assign(ino, inode->i_ino)
 127                 tp_assign(nlink, inode->i_nlink)
 128         ),
 129
 130         TP_printk("dev %d,%d ino %lu nlink %d",
 131                   MAJOR(__entry->dev), MINOR(__entry->dev),
 132                   (unsigned long) __entry->ino, __entry->nlink)
 133 )
 134
 135 TRACE_EVENT(ext4_drop_inode,
 136         TP_PROTO(struct inode *inode, int drop),
 137
 138         TP_ARGS(inode, drop),
 139
 140         TP_STRUCT__entry(
 141                 __field(        dev_t,  dev                     )
 142                 __field(        ino_t,  ino                     )
 143                 __field(        int,    drop                    )
 144         ),
 145
 146         TP_fast_assign(
 147                 tp_assign(dev, inode->i_sb->s_dev)
 148                 tp_assign(ino, inode->i_ino)
 149                 tp_assign(drop, drop)
 150         ),
 151
 152         TP_printk("dev %d,%d ino %lu drop %d",
 153                   MAJOR(__entry->dev), MINOR(__entry->dev),
 154                   (unsigned long) __entry->ino, __entry->drop)
 155 )
 156
 157 TRACE_EVENT(ext4_mark_inode_dirty,
 158         TP_PROTO(struct inode *inode, unsigned long IP),
 159
 160         TP_ARGS(inode, IP),
 161
 162         TP_STRUCT__entry(
 163                 __field(        dev_t,  dev                     )
 164                 __field(        ino_t,  ino                     )
 165                 __field(unsigned long,  ip                      )
 166         ),
 167
 168         TP_fast_assign(
 169                 tp_assign(dev, inode->i_sb->s_dev)
 170                 tp_assign(ino, inode->i_ino)
 171                 tp_assign(ip, IP)
 172         ),
 173
 174         TP_printk("dev %d,%d ino %lu caller %pF",
 175                   MAJOR(__entry->dev), MINOR(__entry->dev),
 176                   (unsigned long) __entry->ino, (void *)__entry->ip)
 177 )
 178
 179 TRACE_EVENT(ext4_begin_ordered_truncate,
 180         TP_PROTO(struct inode *inode, loff_t new_size),
 181
 182         TP_ARGS(inode, new_size),
 183
 184         TP_STRUCT__entry(
 185                 __field(        dev_t,  dev                     )
 186                 __field(        ino_t,  ino                     )
 187                 __field(        loff_t, new_size                )
 188         ),
 189
 190         TP_fast_assign(
 191                 tp_assign(dev, inode->i_sb->s_dev)
 192                 tp_assign(ino, inode->i_ino)
 193                 tp_assign(new_size, new_size)
 194         ),
 195
 196         TP_printk("dev %d,%d ino %lu new_size %lld",
 197                   MAJOR(__entry->dev), MINOR(__entry->dev),
 198                   (unsigned long) __entry->ino,
 199                   __entry->new_size)
 200 )
 201 #endif
 202
 203 DECLARE_EVENT_CLASS(ext4__write_begin,
 204
 205         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 206                  unsigned int flags),
 207
 208         TP_ARGS(inode, pos, len, flags),
 209
 210         TP_STRUCT__entry(
 211                 __field(        dev_t,  dev                     )
 212                 __field(        ino_t,  ino                     )
 213                 __field(        loff_t, pos                     )
 214                 __field(        unsigned int, len               )
 215                 __field(        unsigned int, flags             )
 216         ),
 217
 218         TP_fast_assign(
 219                 tp_assign(dev, inode->i_sb->s_dev)
 220                 tp_assign(ino, inode->i_ino)
 221                 tp_assign(pos, pos)
 222                 tp_assign(len, len)
 223                 tp_assign(flags, flags)
 224         ),
 225
 226         TP_printk("dev %d,%d ino %lu pos %lld len %u flags %u",
 227                   MAJOR(__entry->dev), MINOR(__entry->dev),
 228                   (unsigned long) __entry->ino,
 229                   __entry->pos, __entry->len, __entry->flags)
 230 )
 231
 232 DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
 233
 234         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 235                  unsigned int flags),
 236
 237         TP_ARGS(inode, pos, len, flags)
 238 )
 239
 240 DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
 241
 242         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 243                  unsigned int flags),
 244
 245         TP_ARGS(inode, pos, len, flags)
 246 )
 247
 248 DECLARE_EVENT_CLASS(ext4__write_end,
 249         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 250                         unsigned int copied),
 251
 252         TP_ARGS(inode, pos, len, copied),
 253
 254         TP_STRUCT__entry(
 255                 __field(        dev_t,  dev                     )
 256                 __field(        ino_t,  ino                     )
 257                 __field(        loff_t, pos                     )
 258                 __field(        unsigned int, len               )
 259                 __field(        unsigned int, copied            )
 260         ),
 261
 262         TP_fast_assign(
 263                 tp_assign(dev, inode->i_sb->s_dev)
 264                 tp_assign(ino, inode->i_ino)
 265                 tp_assign(pos, pos)
 266                 tp_assign(len, len)
 267                 tp_assign(copied, copied)
 268         ),
 269
 270         TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
 271                   MAJOR(__entry->dev), MINOR(__entry->dev),
 272                   (unsigned long) __entry->ino,
 273                   __entry->pos, __entry->len, __entry->copied)
 274 )
 275
 276 DEFINE_EVENT(ext4__write_end, ext4_ordered_write_end,
 277
 278         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 279                  unsigned int copied),
 280
 281         TP_ARGS(inode, pos, len, copied)
 282 )
 283
 284 DEFINE_EVENT(ext4__write_end, ext4_writeback_write_end,
 285
 286         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 287                  unsigned int copied),
 288
 289         TP_ARGS(inode, pos, len, copied)
 290 )
 291
 292 DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
 293
 294         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 295                  unsigned int copied),
 296
 297         TP_ARGS(inode, pos, len, copied)
 298 )
 299
 300 DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
 301
 302         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 303                  unsigned int copied),
 304
 305         TP_ARGS(inode, pos, len, copied)
 306 )
 307
 308 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,40))
 309 TRACE_EVENT(ext4_writepage,
 310         TP_PROTO(struct inode *inode, struct page *page),
 311
 312         TP_ARGS(inode, page),
 313
 314         TP_STRUCT__entry(
 315                 __field(        dev_t,  dev                     )
 316                 __field(        ino_t,  ino                     )
 317                 __field(        pgoff_t, index                  )
 318
 319         ),
 320
 321         TP_fast_assign(
 322                 tp_assign(dev, inode->i_sb->s_dev)
 323                 tp_assign(ino, inode->i_ino)
 324                 tp_assign(index, page->index)
 325         ),
 326
 327         TP_printk("dev %d,%d ino %lu page_index %lu",
 328                   MAJOR(__entry->dev), MINOR(__entry->dev),
 329                   (unsigned long) __entry->ino, __entry->index)
 330 )
 331 #endif
 332
 333 TRACE_EVENT(ext4_da_writepages,
 334         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 335
 336         TP_ARGS(inode, wbc),
 337
 338         TP_STRUCT__entry(
 339                 __field(        dev_t,  dev                     )
 340                 __field(        ino_t,  ino                     )
 341                 __field(        long,   nr_to_write             )
 342                 __field(        long,   pages_skipped           )
 343                 __field(        loff_t, range_start             )
 344                 __field(        loff_t, range_end               )
 345                 __field(       pgoff_t, writeback_index         )
 346 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 347                 __field(        int,    sync_mode               )
 348 #endif
 349 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
 350                 __field(        char,   nonblocking             )
 351 #endif
 352                 __field(        char,   for_kupdate             )
 353 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 354                 __field(        char,   for_reclaim             )
 355 #endif
 356                 __field(        char,   range_cyclic            )
 357         ),
 358
 359         TP_fast_assign(
 360                 tp_assign(dev, inode->i_sb->s_dev)
 361                 tp_assign(ino, inode->i_ino)
 362                 tp_assign(nr_to_write, wbc->nr_to_write)
 363                 tp_assign(pages_skipped, wbc->pages_skipped)
 364                 tp_assign(range_start, wbc->range_start)
 365                 tp_assign(range_end, wbc->range_end)
 366                 tp_assign(writeback_index, inode->i_mapping->writeback_index)
 367 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 368                 tp_assign(sync_mode, wbc->sync_mode)
 369 #endif
 370 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
 371                 tp_assign(nonblocking, wbc->nonblocking)
 372 #endif
 373                 tp_assign(for_kupdate, wbc->for_kupdate)
 374 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 375                 tp_assign(for_reclaim, wbc->for_reclaim)
 376 #endif
 377                 tp_assign(range_cyclic, wbc->range_cyclic)
 378         ),
 379
 380 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 381         TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
 382                   "range_start %lld range_end %lld sync_mode %d "
 383                   "for_kupdate %d range_cyclic %d writeback_index %lu",
 384 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 385         TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
 386                   "range_start %llu range_end %llu "
 387                   "for_kupdate %d for_reclaim %d "
 388                   "range_cyclic %d writeback_index %lu",
 389 #else
 390         TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
 391                   "range_start %llu range_end %llu "
 392                   "nonblocking %d for_kupdate %d for_reclaim %d "
 393                   "range_cyclic %d writeback_index %lu",
 394 #endif
 395                   MAJOR(__entry->dev), MINOR(__entry->dev),
 396                   (unsigned long) __entry->ino, __entry->nr_to_write,
 397                   __entry->pages_skipped, __entry->range_start,
 398 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 399                   __entry->range_end, __entry->sync_mode,
 400                   __entry->for_kupdate, __entry->range_cyclic,
 401 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 402                   __entry->range_end,
 403                   __entry->for_kupdate, __entry->for_reclaim,
 404                   __entry->range_cyclic,
 405 #else
 406                   __entry->range_end, __entry->nonblocking,
 407                   __entry->for_kupdate, __entry->for_reclaim,
 408                   __entry->range_cyclic,
 409 #endif
 410                   (unsigned long) __entry->writeback_index)
 411 )
 412
 413 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
 414
 415 TRACE_EVENT(ext4_da_write_pages,
 416         TP_PROTO(struct inode *inode, pgoff_t first_page,
 417                  struct writeback_control *wbc),
 418
 419         TP_ARGS(inode, first_page, wbc),
 420
 421         TP_STRUCT__entry(
 422                 __field(        dev_t,  dev                     )
 423                 __field(        ino_t,  ino                     )
 424                 __field(      pgoff_t,  first_page              )
 425                 __field(         long,  nr_to_write             )
 426                 __field(          int,  sync_mode               )
 427         ),
 428
 429         TP_fast_assign(
 430                 tp_assign(dev, inode->i_sb->s_dev)
 431                 tp_assign(ino, inode->i_ino)
 432                 tp_assign(first_page, first_page)
 433                 tp_assign(nr_to_write, wbc->nr_to_write)
 434                 tp_assign(sync_mode, wbc->sync_mode)
 435         ),
 436
 437         TP_printk("dev %d,%d ino %lu first_page %lu nr_to_write %ld "
 438                   "sync_mode %d",
 439                   MAJOR(__entry->dev), MINOR(__entry->dev),
 440                   (unsigned long) __entry->ino, __entry->first_page,
 441                   __entry->nr_to_write, __entry->sync_mode)
 442 )
 443
 444 #else
 445
 446 TRACE_EVENT(ext4_da_write_pages,
 447         TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
 448
 449         TP_ARGS(inode, mpd),
 450
 451         TP_STRUCT__entry(
 452                 __field(        dev_t,  dev                     )
 453                 __field(        ino_t,  ino                     )
 454                 __field(        __u64,  b_blocknr               )
 455                 __field(        __u32,  b_size                  )
 456                 __field(        __u32,  b_state                 )
 457                 __field(        unsigned long,  first_page      )
 458                 __field(        int,    io_done                 )
 459                 __field(        int,    pages_written           )
 460 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 461                 __field(        int,    sync_mode               )
 462 #endif
 463         ),
 464
 465         TP_fast_assign(
 466                 tp_assign(dev, inode->i_sb->s_dev)
 467                 tp_assign(ino, inode->i_ino)
 468                 tp_assign(b_blocknr, mpd->b_blocknr)
 469                 tp_assign(b_size, mpd->b_size)
 470                 tp_assign(b_state, mpd->b_state)
 471                 tp_assign(first_page, mpd->first_page)
 472                 tp_assign(io_done, mpd->io_done)
 473                 tp_assign(pages_written, mpd->pages_written)
 474 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 475                 tp_assign(sync_mode, mpd->wbc->sync_mode)
 476 #endif
 477         ),
 478
 479 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 480         TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
 481                   "first_page %lu io_done %d pages_written %d sync_mode %d",
 482 #else
 483         TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
 484                   "first_page %lu io_done %d pages_written %d",
 485 #endif
 486                   MAJOR(__entry->dev), MINOR(__entry->dev),
 487                   (unsigned long) __entry->ino,
 488                   __entry->b_blocknr, __entry->b_size,
 489                   __entry->b_state, __entry->first_page,
 490 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 491                   __entry->io_done, __entry->pages_written,
 492                   __entry->sync_mode
 493 #else
 494                   __entry->io_done, __entry->pages_written
 495 #endif
 496                   )
 497 )
 498
 499 #endif
 500
 501 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
 502
 503 TRACE_EVENT(ext4_da_write_pages_extent,
 504         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map),
 505
 506         TP_ARGS(inode, map),
 507
 508         TP_STRUCT__entry(
 509                 __field(        dev_t,  dev                     )
 510                 __field(        ino_t,  ino                     )
 511                 __field(        __u64,  lblk                    )
 512                 __field(        __u32,  len                     )
 513                 __field(        __u32,  flags                   )
 514         ),
 515
 516         TP_fast_assign(
 517                 tp_assign(dev, inode->i_sb->s_dev)
 518                 tp_assign(ino, inode->i_ino)
 519                 tp_assign(lblk, map->m_lblk)
 520                 tp_assign(len, map->m_len)
 521                 tp_assign(flags, map->m_flags)
 522         ),
 523
 524         TP_printk("dev %d,%d ino %lu lblk %llu len %u flags %s",
 525                   MAJOR(__entry->dev), MINOR(__entry->dev),
 526                   (unsigned long) __entry->ino, __entry->lblk, __entry->len,
 527                   show_mflags(__entry->flags))
 528 )
 529
 530 #endif
 531
 532 TRACE_EVENT(ext4_da_writepages_result,
 533         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
 534                         int ret, int pages_written),
 535
 536         TP_ARGS(inode, wbc, ret, pages_written),
 537
 538         TP_STRUCT__entry(
 539                 __field(        dev_t,  dev                     )
 540                 __field(        ino_t,  ino                     )
 541                 __field(        int,    ret                     )
 542                 __field(        int,    pages_written           )
 543                 __field(        long,   pages_skipped           )
 544                 __field(       pgoff_t, writeback_index         )
 545 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 546                 __field(        int,    sync_mode               )
 547 #endif
 548 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33))
 549                 __field(        char,   encountered_congestion  )
 550 #endif
 551 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
 552                 __field(        char,   more_io                 )
 553 #endif
 554 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
 555                 __field(        char,   no_nrwrite_index_update )
 556 #endif
 557         ),
 558
 559         TP_fast_assign(
 560                 tp_assign(dev, inode->i_sb->s_dev)
 561                 tp_assign(ino, inode->i_ino)
 562                 tp_assign(ret, ret)
 563                 tp_assign(pages_written, pages_written)
 564                 tp_assign(pages_skipped, wbc->pages_skipped)
 565                 tp_assign(writeback_index, inode->i_mapping->writeback_index)
 566 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 567                 tp_assign(sync_mode, wbc->sync_mode)
 568 #endif
 569 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33))
 570                 tp_assign(encountered_congestion, wbc->encountered_congestion)
 571 #endif
 572 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
 573                 tp_assign(more_io, wbc->more_io)
 574 #endif
 575 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
 576                 tp_assign(no_nrwrite_index_update, wbc->no_nrwrite_index_update)
 577 #endif
 578         ),
 579
 580 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
 581         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 582                   "sync_mode %d writeback_index %lu",
 583                   MAJOR(__entry->dev), MINOR(__entry->dev),
 584                   (unsigned long) __entry->ino, __entry->ret,
 585                   __entry->pages_written, __entry->pages_skipped,
 586                   __entry->sync_mode,
 587                   (unsigned long) __entry->writeback_index)
 588 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 589         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 590                   " more_io %d sync_mode %d writeback_index %lu",
 591                   MAJOR(__entry->dev), MINOR(__entry->dev),
 592                   (unsigned long) __entry->ino, __entry->ret,
 593                   __entry->pages_written, __entry->pages_skipped,
 594                   __entry->more_io, __entry->sync_mode,
 595                   (unsigned long) __entry->writeback_index)
 596 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
 597         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 598                   " more_io %d writeback_index %lu",
 599                   MAJOR(__entry->dev), MINOR(__entry->dev),
 600                   (unsigned long) __entry->ino, __entry->ret,
 601                   __entry->pages_written, __entry->pages_skipped,
 602                   __entry->more_io,
 603                   (unsigned long) __entry->writeback_index)
 604 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
 605         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 606                   " more_io %d no_nrwrite_index_update %d writeback_index %lu",
 607                   MAJOR(__entry->dev), MINOR(__entry->dev),
 608                   (unsigned long) __entry->ino, __entry->ret,
 609                   __entry->pages_written, __entry->pages_skipped,
 610                   __entry->more_io, __entry->no_nrwrite_index_update,
 611                   (unsigned long) __entry->writeback_index)
 612 #else
 613         TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 614                   " congestion %d"
 615                   " more_io %d no_nrwrite_index_update %d writeback_index %lu",
 616                   MAJOR(__entry->dev), MINOR(__entry->dev),
 617                   (unsigned long) __entry->ino, __entry->ret,
 618                   __entry->pages_written, __entry->pages_skipped,
 619                   __entry->encountered_congestion,
 620                   __entry->more_io, __entry->no_nrwrite_index_update,
 621                   (unsigned long) __entry->writeback_index)
 622 #endif
 623 )
 624
 625 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
 626 DECLARE_EVENT_CLASS(ext4__page_op,
 627         TP_PROTO(struct page *page),
 628
 629         TP_ARGS(page),
 630
 631         TP_STRUCT__entry(
 632                 __field(        dev_t,  dev                     )
 633                 __field(        ino_t,  ino                     )
 634                 __field(        pgoff_t, index                  )
 635
 636         ),
 637
 638         TP_fast_assign(
 639                 tp_assign(dev, page->mapping->host->i_sb->s_dev)
 640                 tp_assign(ino, page->mapping->host->i_ino)
 641                 tp_assign(index, page->index)
 642         ),
 643
 644         TP_printk("dev %d,%d ino %lu page_index %lu",
 645                   MAJOR(__entry->dev), MINOR(__entry->dev),
 646                   (unsigned long) __entry->ino,
 647                   (unsigned long) __entry->index)
 648 )
 649
 650 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
 651 DEFINE_EVENT(ext4__page_op, ext4_writepage,
 652
 653         TP_PROTO(struct page *page),
 654
 655         TP_ARGS(page)
 656 )
 657 #endif
 658
 659 DEFINE_EVENT(ext4__page_op, ext4_readpage,
 660
 661         TP_PROTO(struct page *page),
 662
 663         TP_ARGS(page)
 664 )
 665
 666 DEFINE_EVENT(ext4__page_op, ext4_releasepage,
 667
 668         TP_PROTO(struct page *page),
 669
 670         TP_ARGS(page)
 671 )
 672
 673 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
 674
 675 DECLARE_EVENT_CLASS(ext4_invalidatepage_op,
 676         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 677
 678         TP_ARGS(page, offset, length),
 679
 680         TP_STRUCT__entry(
 681                 __field(        dev_t,  dev                     )
 682                 __field(        ino_t,  ino                     )
 683                 __field(        pgoff_t, index                  )
 684                 __field(        unsigned int, offset            )
 685                 __field(        unsigned int, length            )
 686         ),
 687
 688         TP_fast_assign(
 689                 tp_assign(dev, page->mapping->host->i_sb->s_dev)
 690                 tp_assign(ino, page->mapping->host->i_ino)
 691                 tp_assign(index, page->index)
 692                 tp_assign(offset, offset)
 693                 tp_assign(length, length)
 694         ),
 695
 696         TP_printk("dev %d,%d ino %lu page_index %lu offset %u length %u",
 697                   MAJOR(__entry->dev), MINOR(__entry->dev),
 698                   (unsigned long) __entry->ino,
 699                   (unsigned long) __entry->index,
 700                   __entry->offset, __entry->length)
 701 )
 702
 703 DEFINE_EVENT(ext4_invalidatepage_op, ext4_invalidatepage,
 704         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 705
 706         TP_ARGS(page, offset, length)
 707 )
 708
 709 DEFINE_EVENT(ext4_invalidatepage_op, ext4_journalled_invalidatepage,
 710         TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 711
 712         TP_ARGS(page, offset, length)
 713 )
 714
 715 #else
 716
 717 TRACE_EVENT(ext4_invalidatepage,
 718         TP_PROTO(struct page *page, unsigned long offset),
 719
 720         TP_ARGS(page, offset),
 721
 722         TP_STRUCT__entry(
 723                 __field(        dev_t,  dev                     )
 724                 __field(        ino_t,  ino                     )
 725                 __field(        pgoff_t, index                  )
 726                 __field(        unsigned long, offset           )
 727
 728         ),
 729
 730         TP_fast_assign(
 731                 tp_assign(dev, page->mapping->host->i_sb->s_dev)
 732                 tp_assign(ino, page->mapping->host->i_ino)
 733                 tp_assign(index, page->index)
 734                 tp_assign(offset, offset)
 735         ),
 736
 737         TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
 738                   MAJOR(__entry->dev), MINOR(__entry->dev),
 739                   (unsigned long) __entry->ino,
 740                   (unsigned long) __entry->index, __entry->offset)
 741 )
 742
 743 #endif
 744
 745 #endif
 746
 747 TRACE_EVENT(ext4_discard_blocks,
 748         TP_PROTO(struct super_block *sb, unsigned long long blk,
 749                         unsigned long long count),
 750
 751         TP_ARGS(sb, blk, count),
 752
 753         TP_STRUCT__entry(
 754                 __field(        dev_t,  dev                     )
 755                 __field(        __u64,  blk                     )
 756                 __field(        __u64,  count                   )
 757
 758         ),
 759
 760         TP_fast_assign(
 761                 tp_assign(dev, sb->s_dev)
 762                 tp_assign(blk, blk)
 763                 tp_assign(count, count)
 764         ),
 765
 766         TP_printk("dev %d,%d blk %llu count %llu",
 767                   MAJOR(__entry->dev), MINOR(__entry->dev),
 768                   __entry->blk, __entry->count)
 769 )
 770
 771 DECLARE_EVENT_CLASS(ext4__mb_new_pa,
 772         TP_PROTO(struct ext4_allocation_context *ac,
 773                  struct ext4_prealloc_space *pa),
 774
 775         TP_ARGS(ac, pa),
 776
 777         TP_STRUCT__entry(
 778                 __field(        dev_t,  dev                     )
 779                 __field(        ino_t,  ino                     )
 780                 __field(        __u64,  pa_pstart               )
 781                 __field(        __u64,  pa_lstart               )
 782                 __field(        __u32,  pa_len                  )
 783
 784         ),
 785
 786         TP_fast_assign(
 787                 tp_assign(dev, ac->ac_sb->s_dev)
 788                 tp_assign(ino, ac->ac_inode->i_ino)
 789                 tp_assign(pa_pstart, pa->pa_pstart)
 790                 tp_assign(pa_lstart, pa->pa_lstart)
 791                 tp_assign(pa_len, pa->pa_len)
 792         ),
 793
 794         TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
 795                   MAJOR(__entry->dev), MINOR(__entry->dev),
 796                   (unsigned long) __entry->ino,
 797                   __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 798 )
 799
 800 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
 801
 802         TP_PROTO(struct ext4_allocation_context *ac,
 803                  struct ext4_prealloc_space *pa),
 804
 805         TP_ARGS(ac, pa)
 806 )
 807
 808 DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
 809
 810         TP_PROTO(struct ext4_allocation_context *ac,
 811                  struct ext4_prealloc_space *pa),
 812
 813         TP_ARGS(ac, pa)
 814 )
 815
 816 TRACE_EVENT(ext4_mb_release_inode_pa,
 817         TP_PROTO(
 818 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,40))
 819 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 820                  struct super_block *sb,
 821                  struct inode *inode,
 822 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
 823                  struct super_block *sb,
 824                  struct ext4_allocation_context *ac,
 825 #else
 826                  struct ext4_allocation_context *ac,
 827 #endif
 828 #endif
 829                  struct ext4_prealloc_space *pa,
 830                  unsigned long long block, unsigned int count),
 831
 832 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
 833         TP_ARGS(pa, block, count),
 834 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 835         TP_ARGS(sb, inode, pa, block, count),
 836 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
 837         TP_ARGS(sb, ac, pa, block, count),
 838 #else
 839         TP_ARGS(ac, pa, block, count),
 840 #endif
 841
 842         TP_STRUCT__entry(
 843                 __field(        dev_t,  dev                     )
 844                 __field(        ino_t,  ino                     )
 845                 __field(        __u64,  block                   )
 846                 __field(        __u32,  count                   )
 847
 848         ),
 849
 850         TP_fast_assign(
 851 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
 852                 tp_assign(dev, pa->pa_inode->i_sb->s_dev)
 853                 tp_assign(ino, pa->pa_inode->i_ino)
 854 #else
 855 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
 856                 tp_assign(dev, sb->s_dev)
 857 #else
 858                 tp_assign(dev, ac->ac_sb->s_dev)
 859 #endif
 860 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 861                 tp_assign(ino, inode->i_ino)
 862 #else
 863                 tp_assign(ino, (ac && ac->ac_inode) ? ac->ac_inode->i_ino : 0)
 864 #endif
 865 #endif
 866                 tp_assign(block, block)
 867                 tp_assign(count, count)
 868         ),
 869
 870         TP_printk("dev %d,%d ino %lu block %llu count %u",
 871                   MAJOR(__entry->dev), MINOR(__entry->dev),
 872                   (unsigned long) __entry->ino,
 873                   __entry->block, __entry->count)
 874 )
 875
 876 TRACE_EVENT(ext4_mb_release_group_pa,
 877
 878 #if (LTTNG_KERNEL_RANGE(2,6,40, 3,3,0))
 879         TP_PROTO(struct ext4_prealloc_space *pa),
 880
 881         TP_ARGS(pa),
 882 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
 883         TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
 884
 885         TP_ARGS(sb, pa),
 886 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
 887         TP_PROTO(struct super_block *sb,
 888                  struct ext4_allocation_context *ac,
 889                  struct ext4_prealloc_space *pa),
 890
 891         TP_ARGS(sb, ac, pa),
 892 #else
 893         TP_PROTO(struct ext4_allocation_context *ac,
 894                  struct ext4_prealloc_space *pa),
 895
 896         TP_ARGS(ac, pa),
 897 #endif
 898
 899         TP_STRUCT__entry(
 900                 __field(        dev_t,  dev                     )
 901 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
 902                 __field(        ino_t,  ino                     )
 903 #endif
 904                 __field(        __u64,  pa_pstart               )
 905                 __field(        __u32,  pa_len                  )
 906
 907         ),
 908
 909         TP_fast_assign(
 910 #if (LTTNG_KERNEL_RANGE(2,6,40, 3,3,0))
 911                 tp_assign(dev, pa->pa_inode->i_sb->s_dev)
 912 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36))
 913                 tp_assign(dev, sb->s_dev)
 914 #else
 915                 tp_assign(dev, ac->ac_sb->s_dev)
 916 #endif
 917 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
 918                 tp_assign(ino, (ac && ac->ac_inode) ? ac->ac_inode->i_ino : 0)
 919 #endif
 920                 tp_assign(pa_pstart, pa->pa_pstart)
 921                 tp_assign(pa_len, pa->pa_len)
 922         ),
 923
 924         TP_printk("dev %d,%d pstart %llu len %u",
 925                   MAJOR(__entry->dev), MINOR(__entry->dev),
 926                   __entry->pa_pstart, __entry->pa_len)
 927 )
 928
 929 TRACE_EVENT(ext4_discard_preallocations,
 930         TP_PROTO(struct inode *inode),
 931
 932         TP_ARGS(inode),
 933
 934         TP_STRUCT__entry(
 935                 __field(        dev_t,  dev                     )
 936                 __field(        ino_t,  ino                     )
 937
 938         ),
 939
 940         TP_fast_assign(
 941                 tp_assign(dev, inode->i_sb->s_dev)
 942                 tp_assign(ino, inode->i_ino)
 943         ),
 944
 945         TP_printk("dev %d,%d ino %lu",
 946                   MAJOR(__entry->dev), MINOR(__entry->dev),
 947                   (unsigned long) __entry->ino)
 948 )
 949
 950 TRACE_EVENT(ext4_mb_discard_preallocations,
 951         TP_PROTO(struct super_block *sb, int needed),
 952
 953         TP_ARGS(sb, needed),
 954
 955         TP_STRUCT__entry(
 956                 __field(        dev_t,  dev                     )
 957                 __field(        int,    needed                  )
 958
 959         ),
 960
 961         TP_fast_assign(
 962                 tp_assign(dev, sb->s_dev)
 963                 tp_assign(needed, needed)
 964         ),
 965
 966         TP_printk("dev %d,%d needed %d",
 967                   MAJOR(__entry->dev), MINOR(__entry->dev),
 968                   __entry->needed)
 969 )
 970
 971 TRACE_EVENT(ext4_request_blocks,
 972         TP_PROTO(struct ext4_allocation_request *ar),
 973
 974         TP_ARGS(ar),
 975
 976         TP_STRUCT__entry(
 977                 __field(        dev_t,  dev                     )
 978                 __field(        ino_t,  ino                     )
 979                 __field(        unsigned int, len               )
 980                 __field(        __u32,  logical                 )
 981                 __field(        __u32,  lleft                   )
 982                 __field(        __u32,  lright                  )
 983                 __field(        __u64,  goal                    )
 984                 __field(        __u64,  pleft                   )
 985                 __field(        __u64,  pright                  )
 986                 __field(        unsigned int, flags             )
 987         ),
 988
 989         TP_fast_assign(
 990                 tp_assign(dev, ar->inode->i_sb->s_dev)
 991                 tp_assign(ino, ar->inode->i_ino)
 992                 tp_assign(len, ar->len)
 993                 tp_assign(logical, ar->logical)
 994                 tp_assign(goal, ar->goal)
 995                 tp_assign(lleft, ar->lleft)
 996                 tp_assign(lright, ar->lright)
 997                 tp_assign(pleft, ar->pleft)
 998                 tp_assign(pright, ar->pright)
 999                 tp_assign(flags, ar->flags)
1000         ),
1001
1002         TP_printk("dev %d,%d ino %lu flags %u len %u lblk %u goal %llu "
1003                   "lleft %u lright %u pleft %llu pright %llu ",
1004                   MAJOR(__entry->dev), MINOR(__entry->dev),
1005                   (unsigned long) __entry->ino, __entry->flags,
1006                   __entry->len, __entry->logical, __entry->goal,
1007                   __entry->lleft, __entry->lright, __entry->pleft,
1008                   __entry->pright)
1009 )
1010
1011 TRACE_EVENT(ext4_allocate_blocks,
1012         TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
1013
1014         TP_ARGS(ar, block),
1015
1016         TP_STRUCT__entry(
1017                 __field(        dev_t,  dev                     )
1018                 __field(        ino_t,  ino                     )
1019                 __field(        __u64,  block                   )
1020                 __field(        unsigned int, len               )
1021                 __field(        __u32,  logical                 )
1022                 __field(        __u32,  lleft                   )
1023                 __field(        __u32,  lright                  )
1024                 __field(        __u64,  goal                    )
1025                 __field(        __u64,  pleft                   )
1026                 __field(        __u64,  pright                  )
1027                 __field(        unsigned int, flags             )
1028         ),
1029
1030         TP_fast_assign(
1031                 tp_assign(dev, ar->inode->i_sb->s_dev)
1032                 tp_assign(ino, ar->inode->i_ino)
1033                 tp_assign(block, block)
1034                 tp_assign(len, ar->len)
1035                 tp_assign(logical, ar->logical)
1036                 tp_assign(goal, ar->goal)
1037                 tp_assign(lleft, ar->lleft)
1038                 tp_assign(lright, ar->lright)
1039                 tp_assign(pleft, ar->pleft)
1040                 tp_assign(pright, ar->pright)
1041                 tp_assign(flags, ar->flags)
1042         ),
1043
1044         TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %u "
1045                   "goal %llu lleft %u lright %u pleft %llu pright %llu",
1046                   MAJOR(__entry->dev), MINOR(__entry->dev),
1047                   (unsigned long) __entry->ino, __entry->flags,
1048                   __entry->len, __entry->block, __entry->logical,
1049                   __entry->goal,  __entry->lleft, __entry->lright,
1050                   __entry->pleft, __entry->pright)
1051 )
1052
1053 TRACE_EVENT(ext4_free_blocks,
1054 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1055         TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
1056                  int flags),
1057
1058         TP_ARGS(inode, block, count, flags),
1059 #else
1060         TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
1061                  int metadata),
1062
1063         TP_ARGS(inode, block, count, metadata),
1064 #endif
1065
1066         TP_STRUCT__entry(
1067                 __field(        dev_t,  dev                     )
1068                 __field(        ino_t,  ino                     )
1069                 __field(        __u64,  block                   )
1070                 __field(        unsigned long,  count           )
1071 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1072                 __field(        int,    flags                   )
1073                 __field(        TP_MODE_T, mode                 )
1074 #else
1075                 __field(        int,    metadata                )
1076 #endif
1077         ),
1078
1079         TP_fast_assign(
1080                 tp_assign(dev, inode->i_sb->s_dev)
1081                 tp_assign(ino, inode->i_ino)
1082                 tp_assign(block, block)
1083                 tp_assign(count, count)
1084 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1085                 tp_assign(flags, flags)
1086                 tp_assign(mode, inode->i_mode)
1087 #else
1088                 tp_assign(metadata, metadata)
1089 #endif
1090         ),
1091
1092 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1093         TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
1094 #else
1095         TP_printk("dev %d,%d ino %lu block %llu count %lu metadata %d",
1096 #endif
1097                   MAJOR(__entry->dev), MINOR(__entry->dev),
1098                   (unsigned long) __entry->ino,
1099 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1100                   __entry->mode, __entry->block, __entry->count,
1101                   __entry->flags)
1102 #else
1103                   __entry->block, __entry->count, __entry->metadata)
1104 #endif
1105 )
1106
1107 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1108 TRACE_EVENT(ext4_sync_file_enter,
1109 #else
1110 TRACE_EVENT(ext4_sync_file,
1111 #endif
1112 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
1113         TP_PROTO(struct file *file, int datasync),
1114
1115         TP_ARGS(file, datasync),
1116 #else
1117         TP_PROTO(struct file *file, struct dentry *dentry, int datasync),
1118
1119         TP_ARGS(file, dentry, datasync),
1120 #endif
1121
1122         TP_STRUCT__entry(
1123                 __field(        dev_t,  dev                     )
1124                 __field(        ino_t,  ino                     )
1125                 __field(        ino_t,  parent                  )
1126                 __field(        int,    datasync                )
1127         ),
1128
1129         TP_fast_assign(
1130 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
1131                 tp_assign(dev, file->f_path.dentry->d_inode->i_sb->s_dev)
1132                 tp_assign(ino, file->f_path.dentry->d_inode->i_ino)
1133                 tp_assign(datasync, datasync)
1134                 tp_assign(parent, file->f_path.dentry->d_parent->d_inode->i_ino)
1135 #else
1136                 tp_assign(dev, dentry->d_inode->i_sb->s_dev)
1137                 tp_assign(ino, dentry->d_inode->i_ino)
1138                 tp_assign(datasync, datasync)
1139                 tp_assign(parent, dentry->d_parent->d_inode->i_ino)
1140 #endif
1141         ),
1142
1143         TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
1144                   MAJOR(__entry->dev), MINOR(__entry->dev),
1145                   (unsigned long) __entry->ino,
1146                   (unsigned long) __entry->parent, __entry->datasync)
1147 )
1148
1149 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1150 TRACE_EVENT(ext4_sync_file_exit,
1151         TP_PROTO(struct inode *inode, int ret),
1152
1153         TP_ARGS(inode, ret),
1154
1155         TP_STRUCT__entry(
1156                 __field(        dev_t,  dev                     )
1157                 __field(        ino_t,  ino                     )
1158                 __field(        int,    ret                     )
1159         ),
1160
1161         TP_fast_assign(
1162                 tp_assign(dev, inode->i_sb->s_dev)
1163                 tp_assign(ino, inode->i_ino)
1164                 tp_assign(ret, ret)
1165         ),
1166
1167         TP_printk("dev %d,%d ino %lu ret %d",
1168                   MAJOR(__entry->dev), MINOR(__entry->dev),
1169                   (unsigned long) __entry->ino,
1170                   __entry->ret)
1171 )
1172 #endif
1173
1174 TRACE_EVENT(ext4_sync_fs,
1175         TP_PROTO(struct super_block *sb, int wait),
1176
1177         TP_ARGS(sb, wait),
1178
1179         TP_STRUCT__entry(
1180                 __field(        dev_t,  dev                     )
1181                 __field(        int,    wait                    )
1182
1183         ),
1184
1185         TP_fast_assign(
1186                 tp_assign(dev, sb->s_dev)
1187                 tp_assign(wait, wait)
1188         ),
1189
1190         TP_printk("dev %d,%d wait %d",
1191                   MAJOR(__entry->dev), MINOR(__entry->dev),
1192                   __entry->wait)
1193 )
1194
1195 TRACE_EVENT(ext4_alloc_da_blocks,
1196         TP_PROTO(struct inode *inode),
1197
1198         TP_ARGS(inode),
1199
1200         TP_STRUCT__entry(
1201                 __field(        dev_t,  dev                     )
1202                 __field(        ino_t,  ino                     )
1203                 __field( unsigned int,  data_blocks     )
1204                 __field( unsigned int,  meta_blocks     )
1205         ),
1206
1207         TP_fast_assign(
1208                 tp_assign(dev, inode->i_sb->s_dev)
1209                 tp_assign(ino, inode->i_ino)
1210                 tp_assign(data_blocks, EXT4_I(inode)->i_reserved_data_blocks)
1211                 tp_assign(meta_blocks, EXT4_I(inode)->i_reserved_meta_blocks)
1212         ),
1213
1214         TP_printk("dev %d,%d ino %lu data_blocks %u meta_blocks %u",
1215                   MAJOR(__entry->dev), MINOR(__entry->dev),
1216                   (unsigned long) __entry->ino,
1217                   __entry->data_blocks, __entry->meta_blocks)
1218 )
1219
1220 TRACE_EVENT(ext4_mballoc_alloc,
1221         TP_PROTO(struct ext4_allocation_context *ac),
1222
1223         TP_ARGS(ac),
1224
1225         TP_STRUCT__entry(
1226                 __field(        dev_t,  dev                     )
1227                 __field(        ino_t,  ino                     )
1228                 __field(        __u32,  orig_logical            )
1229                 __field(          int,  orig_start              )
1230                 __field(        __u32,  orig_group              )
1231                 __field(          int,  orig_len                )
1232                 __field(        __u32,  goal_logical            )
1233                 __field(          int,  goal_start              )
1234                 __field(        __u32,  goal_group              )
1235                 __field(          int,  goal_len                )
1236                 __field(        __u32,  result_logical          )
1237                 __field(          int,  result_start            )
1238                 __field(        __u32,  result_group            )
1239                 __field(          int,  result_len              )
1240                 __field(        __u16,  found                   )
1241                 __field(        __u16,  groups                  )
1242                 __field(        __u16,  buddy                   )
1243                 __field(        __u16,  flags                   )
1244                 __field(        __u16,  tail                    )
1245                 __field(        __u8,   cr                      )
1246         ),
1247
1248         TP_fast_assign(
1249                 tp_assign(dev, ac->ac_inode->i_sb->s_dev)
1250                 tp_assign(ino, ac->ac_inode->i_ino)
1251                 tp_assign(orig_logical, ac->ac_o_ex.fe_logical)
1252                 tp_assign(orig_start, ac->ac_o_ex.fe_start)
1253                 tp_assign(orig_group, ac->ac_o_ex.fe_group)
1254                 tp_assign(orig_len, ac->ac_o_ex.fe_len)
1255                 tp_assign(goal_logical, ac->ac_g_ex.fe_logical)
1256                 tp_assign(goal_start, ac->ac_g_ex.fe_start)
1257                 tp_assign(goal_group, ac->ac_g_ex.fe_group)
1258                 tp_assign(goal_len, ac->ac_g_ex.fe_len)
1259                 tp_assign(result_logical, ac->ac_f_ex.fe_logical)
1260                 tp_assign(result_start, ac->ac_f_ex.fe_start)
1261                 tp_assign(result_group, ac->ac_f_ex.fe_group)
1262                 tp_assign(result_len, ac->ac_f_ex.fe_len)
1263                 tp_assign(found, ac->ac_found)
1264                 tp_assign(flags, ac->ac_flags)
1265                 tp_assign(groups, ac->ac_groups_scanned)
1266                 tp_assign(buddy, ac->ac_buddy)
1267                 tp_assign(tail, ac->ac_tail)
1268                 tp_assign(cr, ac->ac_criteria)
1269         ),
1270
1271         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
1272                   "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
1273                   "tail %u broken %u",
1274                   MAJOR(__entry->dev), MINOR(__entry->dev),
1275                   (unsigned long) __entry->ino,
1276                   __entry->orig_group, __entry->orig_start,
1277                   __entry->orig_len, __entry->orig_logical,
1278                   __entry->goal_group, __entry->goal_start,
1279                   __entry->goal_len, __entry->goal_logical,
1280                   __entry->result_group, __entry->result_start,
1281                   __entry->result_len, __entry->result_logical,
1282                   __entry->found, __entry->groups, __entry->cr,
1283                   __entry->flags, __entry->tail,
1284                   __entry->buddy ? 1 << __entry->buddy : 0)
1285 )
1286
1287 TRACE_EVENT(ext4_mballoc_prealloc,
1288         TP_PROTO(struct ext4_allocation_context *ac),
1289
1290         TP_ARGS(ac),
1291
1292         TP_STRUCT__entry(
1293                 __field(        dev_t,  dev                     )
1294                 __field(        ino_t,  ino                     )
1295                 __field(        __u32,  orig_logical            )
1296                 __field(          int,  orig_start              )
1297                 __field(        __u32,  orig_group              )
1298                 __field(          int,  orig_len                )
1299                 __field(        __u32,  result_logical          )
1300                 __field(          int,  result_start            )
1301                 __field(        __u32,  result_group            )
1302                 __field(          int,  result_len              )
1303         ),
1304
1305         TP_fast_assign(
1306                 tp_assign(dev, ac->ac_inode->i_sb->s_dev)
1307                 tp_assign(ino, ac->ac_inode->i_ino)
1308                 tp_assign(orig_logical, ac->ac_o_ex.fe_logical)
1309                 tp_assign(orig_start, ac->ac_o_ex.fe_start)
1310                 tp_assign(orig_group, ac->ac_o_ex.fe_group)
1311                 tp_assign(orig_len, ac->ac_o_ex.fe_len)
1312                 tp_assign(result_logical, ac->ac_b_ex.fe_logical)
1313                 tp_assign(result_start, ac->ac_b_ex.fe_start)
1314                 tp_assign(result_group, ac->ac_b_ex.fe_group)
1315                 tp_assign(result_len, ac->ac_b_ex.fe_len)
1316         ),
1317
1318         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
1319                   MAJOR(__entry->dev), MINOR(__entry->dev),
1320                   (unsigned long) __entry->ino,
1321                   __entry->orig_group, __entry->orig_start,
1322                   __entry->orig_len, __entry->orig_logical,
1323                   __entry->result_group, __entry->result_start,
1324                   __entry->result_len, __entry->result_logical)
1325 )
1326
1327 DECLARE_EVENT_CLASS(ext4__mballoc,
1328 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
1329         TP_PROTO(struct super_block *sb,
1330                  struct inode *inode,
1331                  ext4_group_t group,
1332                  ext4_grpblk_t start,
1333                  ext4_grpblk_t len),
1334
1335         TP_ARGS(sb, inode, group, start, len),
1336 #else
1337         TP_PROTO(struct ext4_allocation_context *ac),
1338
1339         TP_ARGS(ac),
1340 #endif
1341
1342         TP_STRUCT__entry(
1343                 __field(        dev_t,  dev                     )
1344                 __field(        ino_t,  ino                     )
1345 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37))
1346                 __field(        __u32,  result_logical          )
1347 #endif
1348                 __field(          int,  result_start            )
1349                 __field(        __u32,  result_group            )
1350                 __field(          int,  result_len              )
1351         ),
1352
1353         TP_fast_assign(
1354 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
1355                 tp_assign(dev, sb->s_dev)
1356                 tp_assign(ino, inode ? inode->i_ino : 0)
1357                 tp_assign(result_start, start)
1358                 tp_assign(result_group, group)
1359                 tp_assign(result_len, len)
1360 #else
1361                 tp_assign(dev, ac->ac_sb->s_dev)
1362                 tp_assign(ino, ac->ac_inode ? ac->ac_inode->i_ino : 0)
1363                 tp_assign(result_logical, ac->ac_b_ex.fe_logical)
1364                 tp_assign(result_start, ac->ac_b_ex.fe_start)
1365                 tp_assign(result_group, ac->ac_b_ex.fe_group)
1366                 tp_assign(result_len, ac->ac_b_ex.fe_len)
1367 #endif
1368         ),
1369
1370 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
1371         TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
1372 #else
1373         TP_printk("dev %d,%d inode %lu extent %u/%d/%u@%u ",
1374 #endif
1375                   MAJOR(__entry->dev), MINOR(__entry->dev),
1376                   (unsigned long) __entry->ino,
1377                   __entry->result_group, __entry->result_start,
1378 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
1379                   __entry->result_len
1380 #else
1381                   __entry->result_len, __entry->result_logical
1382 #endif
1383         )
1384 )
1385
1386 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
1387
1388 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
1389         TP_PROTO(struct super_block *sb,
1390                  struct inode *inode,
1391                  ext4_group_t group,
1392                  ext4_grpblk_t start,
1393                  ext4_grpblk_t len),
1394
1395         TP_ARGS(sb, inode, group, start, len)
1396 #else
1397         TP_PROTO(struct ext4_allocation_context *ac),
1398
1399         TP_ARGS(ac)
1400 #endif
1401 )
1402
1403 DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
1404
1405 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
1406         TP_PROTO(struct super_block *sb,
1407                  struct inode *inode,
1408                  ext4_group_t group,
1409                  ext4_grpblk_t start,
1410                  ext4_grpblk_t len),
1411
1412         TP_ARGS(sb, inode, group, start, len)
1413 #else
1414         TP_PROTO(struct ext4_allocation_context *ac),
1415
1416         TP_ARGS(ac)
1417 #endif
1418 )
1419
1420 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33))
1421 TRACE_EVENT(ext4_forget,
1422         TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
1423
1424         TP_ARGS(inode, is_metadata, block),
1425
1426         TP_STRUCT__entry(
1427                 __field(        dev_t,  dev                     )
1428                 __field(        ino_t,  ino                     )
1429                 __field(        __u64,  block                   )
1430                 __field(        int,    is_metadata             )
1431                 __field(        TP_MODE_T, mode                 )
1432         ),
1433
1434         TP_fast_assign(
1435                 tp_assign(dev, inode->i_sb->s_dev)
1436                 tp_assign(ino, inode->i_ino)
1437                 tp_assign(block, block)
1438                 tp_assign(is_metadata, is_metadata)
1439                 tp_assign(mode, inode->i_mode)
1440         ),
1441
1442         TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1443                   MAJOR(__entry->dev), MINOR(__entry->dev),
1444                   (unsigned long) __entry->ino,
1445                   __entry->mode, __entry->is_metadata, __entry->block)
1446 )
1447 #endif
1448
1449 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
1450 TRACE_EVENT(ext4_da_update_reserve_space,
1451 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
1452         TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
1453
1454         TP_ARGS(inode, used_blocks, quota_claim),
1455 #else
1456         TP_PROTO(struct inode *inode, int used_blocks),
1457
1458         TP_ARGS(inode, used_blocks),
1459 #endif
1460
1461         TP_STRUCT__entry(
1462                 __field(        dev_t,  dev                     )
1463                 __field(        ino_t,  ino                     )
1464                 __field(        __u64,  i_blocks                )
1465                 __field(        int,    used_blocks             )
1466                 __field(        int,    reserved_data_blocks    )
1467                 __field(        int,    reserved_meta_blocks    )
1468                 __field(        int,    allocated_meta_blocks   )
1469 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
1470                 __field(        int,    quota_claim             )
1471 #endif
1472                 __field(        TP_MODE_T, mode                 )
1473         ),
1474
1475         TP_fast_assign(
1476                 tp_assign(dev, inode->i_sb->s_dev)
1477                 tp_assign(ino, inode->i_ino)
1478                 tp_assign(i_blocks, inode->i_blocks)
1479                 tp_assign(used_blocks, used_blocks)
1480                 tp_assign(reserved_data_blocks,
1481                                 EXT4_I(inode)->i_reserved_data_blocks)
1482                 tp_assign(reserved_meta_blocks,
1483                                 EXT4_I(inode)->i_reserved_meta_blocks)
1484                 tp_assign(allocated_meta_blocks,
1485                                 EXT4_I(inode)->i_allocated_meta_blocks)
1486 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
1487                 tp_assign(quota_claim, quota_claim)
1488 #endif
1489                 tp_assign(mode, inode->i_mode)
1490         ),
1491
1492 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
1493         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1494                   "reserved_data_blocks %d reserved_meta_blocks %d "
1495                   "allocated_meta_blocks %d quota_claim %d",
1496                   MAJOR(__entry->dev), MINOR(__entry->dev),
1497                   (unsigned long) __entry->ino,
1498                   __entry->mode, __entry->i_blocks,
1499                   __entry->used_blocks, __entry->reserved_data_blocks,
1500                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks,
1501                   __entry->quota_claim)
1502 #else
1503         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1504                   "reserved_data_blocks %d reserved_meta_blocks %d "
1505                   "allocated_meta_blocks %d",
1506                   MAJOR(__entry->dev), MINOR(__entry->dev),
1507                   (unsigned long) __entry->ino,
1508                   __entry->mode, __entry->i_blocks,
1509                   __entry->used_blocks, __entry->reserved_data_blocks,
1510                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1511 #endif
1512 )
1513
1514 TRACE_EVENT(ext4_da_reserve_space,
1515         TP_PROTO(struct inode *inode, int md_needed),
1516
1517         TP_ARGS(inode, md_needed),
1518
1519         TP_STRUCT__entry(
1520                 __field(        dev_t,  dev                     )
1521                 __field(        ino_t,  ino                     )
1522                 __field(        __u64,  i_blocks                )
1523                 __field(        int,    md_needed               )
1524                 __field(        int,    reserved_data_blocks    )
1525                 __field(        int,    reserved_meta_blocks    )
1526                 __field(        TP_MODE_T, mode                 )
1527         ),
1528
1529         TP_fast_assign(
1530                 tp_assign(dev, inode->i_sb->s_dev)
1531                 tp_assign(ino, inode->i_ino)
1532                 tp_assign(i_blocks, inode->i_blocks)
1533                 tp_assign(md_needed, md_needed)
1534                 tp_assign(reserved_data_blocks,
1535                                 EXT4_I(inode)->i_reserved_data_blocks)
1536                 tp_assign(reserved_meta_blocks,
1537                                 EXT4_I(inode)->i_reserved_meta_blocks)
1538                 tp_assign(mode, inode->i_mode)
1539         ),
1540
1541         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu md_needed %d "
1542                   "reserved_data_blocks %d reserved_meta_blocks %d",
1543                   MAJOR(__entry->dev), MINOR(__entry->dev),
1544                   (unsigned long) __entry->ino,
1545                   __entry->mode, __entry->i_blocks,
1546                   __entry->md_needed, __entry->reserved_data_blocks,
1547                   __entry->reserved_meta_blocks)
1548 )
1549
1550 TRACE_EVENT(ext4_da_release_space,
1551         TP_PROTO(struct inode *inode, int freed_blocks),
1552
1553         TP_ARGS(inode, freed_blocks),
1554
1555         TP_STRUCT__entry(
1556                 __field(        dev_t,  dev                     )
1557                 __field(        ino_t,  ino                     )
1558                 __field(        __u64,  i_blocks                )
1559                 __field(        int,    freed_blocks            )
1560                 __field(        int,    reserved_data_blocks    )
1561                 __field(        int,    reserved_meta_blocks    )
1562                 __field(        int,    allocated_meta_blocks   )
1563                 __field(        TP_MODE_T, mode                 )
1564         ),
1565
1566         TP_fast_assign(
1567                 tp_assign(dev, inode->i_sb->s_dev)
1568                 tp_assign(ino, inode->i_ino)
1569                 tp_assign(i_blocks, inode->i_blocks)
1570                 tp_assign(freed_blocks, freed_blocks)
1571                 tp_assign(reserved_data_blocks,
1572                                 EXT4_I(inode)->i_reserved_data_blocks)
1573                 tp_assign(reserved_meta_blocks,
1574                                 EXT4_I(inode)->i_reserved_meta_blocks)
1575                 tp_assign(allocated_meta_blocks,
1576                                 EXT4_I(inode)->i_allocated_meta_blocks)
1577                 tp_assign(mode, inode->i_mode)
1578         ),
1579
1580         TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
1581                   "reserved_data_blocks %d reserved_meta_blocks %d "
1582                   "allocated_meta_blocks %d",
1583                   MAJOR(__entry->dev), MINOR(__entry->dev),
1584                   (unsigned long) __entry->ino,
1585                   __entry->mode, __entry->i_blocks,
1586                   __entry->freed_blocks, __entry->reserved_data_blocks,
1587                   __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
1588 )
1589 #endif
1590
1591 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35))
1592 DECLARE_EVENT_CLASS(ext4__bitmap_load,
1593         TP_PROTO(struct super_block *sb, unsigned long group),
1594
1595         TP_ARGS(sb, group),
1596
1597         TP_STRUCT__entry(
1598                 __field(        dev_t,  dev                     )
1599                 __field(        __u32,  group                   )
1600
1601         ),
1602
1603         TP_fast_assign(
1604                 tp_assign(dev, sb->s_dev)
1605                 tp_assign(group, group)
1606         ),
1607
1608         TP_printk("dev %d,%d group %u",
1609                   MAJOR(__entry->dev), MINOR(__entry->dev),
1610                   __entry->group)
1611 )
1612
1613 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
1614
1615         TP_PROTO(struct super_block *sb, unsigned long group),
1616
1617         TP_ARGS(sb, group)
1618 )
1619
1620 DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
1621
1622         TP_PROTO(struct super_block *sb, unsigned long group),
1623
1624         TP_ARGS(sb, group)
1625 )
1626 #endif
1627
1628 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
1629 DEFINE_EVENT(ext4__bitmap_load, ext4_read_block_bitmap_load,
1630
1631         TP_PROTO(struct super_block *sb, unsigned long group),
1632
1633         TP_ARGS(sb, group)
1634 )
1635
1636 DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
1637
1638         TP_PROTO(struct super_block *sb, unsigned long group),
1639
1640         TP_ARGS(sb, group)
1641 )
1642
1643 TRACE_EVENT(ext4_direct_IO_enter,
1644         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
1645
1646         TP_ARGS(inode, offset, len, rw),
1647
1648         TP_STRUCT__entry(
1649                 __field(        dev_t,  dev                     )
1650                 __field(        ino_t,  ino                     )
1651                 __field(        loff_t, pos                     )
1652                 __field(        unsigned long,  len             )
1653                 __field(        int,    rw                      )
1654         ),
1655
1656         TP_fast_assign(
1657                 tp_assign(dev, inode->i_sb->s_dev)
1658                 tp_assign(ino, inode->i_ino)
1659                 tp_assign(pos, offset)
1660                 tp_assign(len, len)
1661                 tp_assign(rw, rw)
1662         ),
1663
1664         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d",
1665                   MAJOR(__entry->dev), MINOR(__entry->dev),
1666                   (unsigned long) __entry->ino,
1667                   __entry->pos, __entry->len, __entry->rw)
1668 )
1669
1670 TRACE_EVENT(ext4_direct_IO_exit,
1671         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
1672                  int rw, int ret),
1673
1674         TP_ARGS(inode, offset, len, rw, ret),
1675
1676         TP_STRUCT__entry(
1677                 __field(        dev_t,  dev                     )
1678                 __field(        ino_t,  ino                     )
1679                 __field(        loff_t, pos                     )
1680                 __field(        unsigned long,  len             )
1681                 __field(        int,    rw                      )
1682                 __field(        int,    ret                     )
1683         ),
1684
1685         TP_fast_assign(
1686                 tp_assign(dev, inode->i_sb->s_dev)
1687                 tp_assign(ino, inode->i_ino)
1688                 tp_assign(pos, offset)
1689                 tp_assign(len, len)
1690                 tp_assign(rw, rw)
1691                 tp_assign(ret, ret)
1692         ),
1693
1694         TP_printk("dev %d,%d ino %lu pos %lld len %lu rw %d ret %d",
1695                   MAJOR(__entry->dev), MINOR(__entry->dev),
1696                   (unsigned long) __entry->ino,
1697                   __entry->pos, __entry->len,
1698                   __entry->rw, __entry->ret)
1699 )
1700
1701 TRACE_EVENT(ext4_fallocate_enter,
1702         TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1703
1704         TP_ARGS(inode, offset, len, mode),
1705
1706         TP_STRUCT__entry(
1707                 __field(        dev_t,  dev                     )
1708                 __field(        ino_t,  ino                     )
1709                 __field(        loff_t, pos                     )
1710                 __field(        loff_t, len                     )
1711                 __field(        int,    mode                    )
1712         ),
1713
1714         TP_fast_assign(
1715                 tp_assign(dev, inode->i_sb->s_dev)
1716                 tp_assign(ino, inode->i_ino)
1717                 tp_assign(pos, offset)
1718                 tp_assign(len, len)
1719                 tp_assign(mode, mode)
1720         ),
1721
1722         TP_printk("dev %d,%d ino %lu pos %lld len %lld mode %d",
1723                   MAJOR(__entry->dev), MINOR(__entry->dev),
1724                   (unsigned long) __entry->ino, __entry->pos,
1725                   __entry->len, __entry->mode)
1726 )
1727
1728 TRACE_EVENT(ext4_fallocate_exit,
1729         TP_PROTO(struct inode *inode, loff_t offset,
1730                  unsigned int max_blocks, int ret),
1731
1732         TP_ARGS(inode, offset, max_blocks, ret),
1733
1734         TP_STRUCT__entry(
1735                 __field(        dev_t,  dev                     )
1736                 __field(        ino_t,  ino                     )
1737                 __field(        loff_t, pos                     )
1738                 __field(        unsigned int,   blocks          )
1739                 __field(        int,    ret                     )
1740         ),
1741
1742         TP_fast_assign(
1743                 tp_assign(dev, inode->i_sb->s_dev)
1744                 tp_assign(ino, inode->i_ino)
1745                 tp_assign(pos, offset)
1746                 tp_assign(blocks, max_blocks)
1747                 tp_assign(ret, ret)
1748         ),
1749
1750         TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
1751                   MAJOR(__entry->dev), MINOR(__entry->dev),
1752                   (unsigned long) __entry->ino,
1753                   __entry->pos, __entry->blocks,
1754                   __entry->ret)
1755 )
1756
1757 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
1758
1759 TRACE_EVENT(ext4_punch_hole,
1760         TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
1761
1762         TP_ARGS(inode, offset, len),
1763
1764         TP_STRUCT__entry(
1765                 __field(        dev_t,  dev                     )
1766                 __field(        ino_t,  ino                     )
1767                 __field(        loff_t, offset                  )
1768                 __field(        loff_t, len                     )
1769         ),
1770
1771         TP_fast_assign(
1772                 tp_assign(dev, inode->i_sb->s_dev)
1773                 tp_assign(ino, inode->i_ino)
1774                 tp_assign(offset, offset)
1775                 tp_assign(len, len)
1776         ),
1777
1778         TP_printk("dev %d,%d ino %lu offset %lld len %lld",
1779                   MAJOR(__entry->dev), MINOR(__entry->dev),
1780                   (unsigned long) __entry->ino,
1781                   __entry->offset, __entry->len)
1782 )
1783
1784 #endif
1785
1786 TRACE_EVENT(ext4_unlink_enter,
1787         TP_PROTO(struct inode *parent, struct dentry *dentry),
1788
1789         TP_ARGS(parent, dentry),
1790
1791         TP_STRUCT__entry(
1792                 __field(        dev_t,  dev                     )
1793                 __field(        ino_t,  ino                     )
1794                 __field(        ino_t,  parent                  )
1795                 __field(        loff_t, size                    )
1796         ),
1797
1798         TP_fast_assign(
1799                 tp_assign(dev, dentry->d_inode->i_sb->s_dev)
1800                 tp_assign(ino, dentry->d_inode->i_ino)
1801                 tp_assign(parent, parent->i_ino)
1802                 tp_assign(size, dentry->d_inode->i_size)
1803         ),
1804
1805         TP_printk("dev %d,%d ino %lu size %lld parent %lu",
1806                   MAJOR(__entry->dev), MINOR(__entry->dev),
1807                   (unsigned long) __entry->ino, __entry->size,
1808                   (unsigned long) __entry->parent)
1809 )
1810
1811 TRACE_EVENT(ext4_unlink_exit,
1812         TP_PROTO(struct dentry *dentry, int ret),
1813
1814         TP_ARGS(dentry, ret),
1815
1816         TP_STRUCT__entry(
1817                 __field(        dev_t,  dev                     )
1818                 __field(        ino_t,  ino                     )
1819                 __field(        int,    ret                     )
1820         ),
1821
1822         TP_fast_assign(
1823                 tp_assign(dev, dentry->d_inode->i_sb->s_dev)
1824                 tp_assign(ino, dentry->d_inode->i_ino)
1825                 tp_assign(ret, ret)
1826         ),
1827
1828         TP_printk("dev %d,%d ino %lu ret %d",
1829                   MAJOR(__entry->dev), MINOR(__entry->dev),
1830                   (unsigned long) __entry->ino,
1831                   __entry->ret)
1832 )
1833
1834 DECLARE_EVENT_CLASS(ext4__truncate,
1835         TP_PROTO(struct inode *inode),
1836
1837         TP_ARGS(inode),
1838
1839         TP_STRUCT__entry(
1840                 __field(        dev_t,          dev             )
1841                 __field(        ino_t,          ino             )
1842                 __field(        __u64,          blocks          )
1843         ),
1844
1845         TP_fast_assign(
1846                 tp_assign(dev, inode->i_sb->s_dev)
1847                 tp_assign(ino, inode->i_ino)
1848                 tp_assign(blocks, inode->i_blocks)
1849         ),
1850
1851         TP_printk("dev %d,%d ino %lu blocks %llu",
1852                   MAJOR(__entry->dev), MINOR(__entry->dev),
1853                   (unsigned long) __entry->ino, __entry->blocks)
1854 )
1855
1856 DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
1857
1858         TP_PROTO(struct inode *inode),
1859
1860         TP_ARGS(inode)
1861 )
1862
1863 DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
1864
1865         TP_PROTO(struct inode *inode),
1866
1867         TP_ARGS(inode)
1868 )
1869
1870 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
1871 /* 'ux' is the uninitialized extent. */
1872 TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
1873         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1874                  struct ext4_extent *ux),
1875
1876         TP_ARGS(inode, map, ux),
1877
1878         TP_STRUCT__entry(
1879                 __field(        dev_t,          dev     )
1880                 __field(        ino_t,          ino     )
1881                 __field(        ext4_lblk_t,    m_lblk  )
1882                 __field(        unsigned,       m_len   )
1883                 __field(        ext4_lblk_t,    u_lblk  )
1884                 __field(        unsigned,       u_len   )
1885                 __field(        ext4_fsblk_t,   u_pblk  )
1886         ),
1887
1888         TP_fast_assign(
1889                 tp_assign(dev, inode->i_sb->s_dev)
1890                 tp_assign(ino, inode->i_ino)
1891                 tp_assign(m_lblk, map->m_lblk)
1892                 tp_assign(m_len, map->m_len)
1893                 tp_assign(u_lblk, le32_to_cpu(ux->ee_block))
1894                 tp_assign(u_len, ext4_ext_get_actual_len(ux))
1895                 tp_assign(u_pblk, ext4_ext_pblock(ux))
1896         ),
1897
1898         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
1899                   "u_pblk %llu",
1900                   MAJOR(__entry->dev), MINOR(__entry->dev),
1901                   (unsigned long) __entry->ino,
1902                   __entry->m_lblk, __entry->m_len,
1903                   __entry->u_lblk, __entry->u_len, __entry->u_pblk)
1904 )
1905
1906 /*
1907  * 'ux' is the uninitialized extent.
1908  * 'ix' is the initialized extent to which blocks are transferred.
1909  */
1910 TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
1911         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1912                  struct ext4_extent *ux, struct ext4_extent *ix),
1913
1914         TP_ARGS(inode, map, ux, ix),
1915
1916         TP_STRUCT__entry(
1917                 __field(        dev_t,          dev     )
1918                 __field(        ino_t,          ino     )
1919                 __field(        ext4_lblk_t,    m_lblk  )
1920                 __field(        unsigned,       m_len   )
1921                 __field(        ext4_lblk_t,    u_lblk  )
1922                 __field(        unsigned,       u_len   )
1923                 __field(        ext4_fsblk_t,   u_pblk  )
1924                 __field(        ext4_lblk_t,    i_lblk  )
1925                 __field(        unsigned,       i_len   )
1926                 __field(        ext4_fsblk_t,   i_pblk  )
1927         ),
1928
1929         TP_fast_assign(
1930                 tp_assign(dev, inode->i_sb->s_dev)
1931                 tp_assign(ino, inode->i_ino)
1932                 tp_assign(m_lblk, map->m_lblk)
1933                 tp_assign(m_len, map->m_len)
1934                 tp_assign(u_lblk, le32_to_cpu(ux->ee_block))
1935                 tp_assign(u_len, ext4_ext_get_actual_len(ux))
1936                 tp_assign(u_pblk, ext4_ext_pblock(ux))
1937                 tp_assign(i_lblk, le32_to_cpu(ix->ee_block))
1938                 tp_assign(i_len, ext4_ext_get_actual_len(ix))
1939                 tp_assign(i_pblk, ext4_ext_pblock(ix))
1940         ),
1941
1942         TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
1943                   "u_lblk %u u_len %u u_pblk %llu "
1944                   "i_lblk %u i_len %u i_pblk %llu ",
1945                   MAJOR(__entry->dev), MINOR(__entry->dev),
1946                   (unsigned long) __entry->ino,
1947                   __entry->m_lblk, __entry->m_len,
1948                   __entry->u_lblk, __entry->u_len, __entry->u_pblk,
1949                   __entry->i_lblk, __entry->i_len, __entry->i_pblk)
1950 )
1951 #endif
1952
1953 DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
1954         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1955                  unsigned int len, unsigned int flags),
1956
1957         TP_ARGS(inode, lblk, len, flags),
1958
1959         TP_STRUCT__entry(
1960                 __field(        dev_t,          dev             )
1961                 __field(        ino_t,          ino             )
1962                 __field(        ext4_lblk_t,    lblk            )
1963                 __field(        unsigned int,   len             )
1964                 __field(        unsigned int,   flags           )
1965         ),
1966
1967         TP_fast_assign(
1968                 tp_assign(dev, inode->i_sb->s_dev)
1969                 tp_assign(ino, inode->i_ino)
1970                 tp_assign(lblk, lblk)
1971                 tp_assign(len, len)
1972                 tp_assign(flags, flags)
1973         ),
1974
1975         TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
1976                   MAJOR(__entry->dev), MINOR(__entry->dev),
1977                   (unsigned long) __entry->ino,
1978                   __entry->lblk, __entry->len, __entry->flags)
1979 )
1980
1981 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
1982         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1983                  unsigned len, unsigned flags),
1984
1985         TP_ARGS(inode, lblk, len, flags)
1986 )
1987
1988 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
1989         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1990                  unsigned len, unsigned flags),
1991
1992         TP_ARGS(inode, lblk, len, flags)
1993 )
1994
1995 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
1996
1997 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
1998         TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map,
1999                  int ret),
2000
2001         TP_ARGS(inode, flags, map, ret),
2002
2003         TP_STRUCT__entry(
2004                 __field(        dev_t,          dev             )
2005                 __field(        ino_t,          ino             )
2006                 __field(        unsigned int,   flags           )
2007                 __field(        ext4_fsblk_t,   pblk            )
2008                 __field(        ext4_lblk_t,    lblk            )
2009                 __field(        unsigned int,   len             )
2010                 __field(        unsigned int,   mflags          )
2011                 __field(        int,            ret             )
2012         ),
2013
2014         TP_fast_assign(
2015                 tp_assign(dev, inode->i_sb->s_dev)
2016                 tp_assign(ino, inode->i_ino)
2017                 tp_assign(flags, flags)
2018                 tp_assign(pblk, map->m_pblk)
2019                 tp_assign(lblk, map->m_lblk)
2020                 tp_assign(len, map->m_len)
2021                 tp_assign(mflags, map->m_flags)
2022                 tp_assign(ret, ret)
2023         ),
2024
2025         TP_printk("dev %d,%d ino %lu flags %s lblk %u pblk %llu len %u "
2026                   "mflags %s ret %d",
2027                   MAJOR(__entry->dev), MINOR(__entry->dev),
2028                   (unsigned long) __entry->ino,
2029                   show_map_flags(__entry->flags), __entry->lblk, __entry->pblk,
2030                   __entry->len, show_mflags(__entry->mflags), __entry->ret)
2031 )
2032
2033 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
2034         TP_PROTO(struct inode *inode, unsigned flags,
2035                  struct ext4_map_blocks *map, int ret),
2036
2037         TP_ARGS(inode, flags, map, ret)
2038 )
2039
2040 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
2041         TP_PROTO(struct inode *inode, unsigned flags,
2042                  struct ext4_map_blocks *map, int ret),
2043
2044         TP_ARGS(inode, flags, map, ret)
2045 )
2046
2047 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
2048
2049 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
2050         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
2051
2052         TP_ARGS(inode, map, ret),
2053
2054         TP_STRUCT__entry(
2055                 __field(        dev_t,          dev             )
2056                 __field(        ino_t,          ino             )
2057                 __field(        ext4_fsblk_t,   pblk            )
2058                 __field(        ext4_lblk_t,    lblk            )
2059                 __field(        unsigned int,   len             )
2060                 __field(        unsigned int,   flags           )
2061                 __field(        int,            ret             )
2062         ),
2063
2064         TP_fast_assign(
2065                 tp_assign(dev, inode->i_sb->s_dev)
2066                 tp_assign(ino, inode->i_ino)
2067                 tp_assign(pblk, map->m_pblk)
2068                 tp_assign(lblk, map->m_lblk)
2069                 tp_assign(len, map->m_len)
2070                 tp_assign(flags, map->m_flags)
2071                 tp_assign(ret, ret)
2072         ),
2073
2074         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u flags %x ret %d",
2075                   MAJOR(__entry->dev), MINOR(__entry->dev),
2076                   (unsigned long) __entry->ino,
2077                   __entry->lblk, __entry->pblk,
2078                   __entry->len, __entry->flags, __entry->ret)
2079 )
2080
2081 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
2082         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
2083
2084         TP_ARGS(inode, map, ret)
2085 )
2086
2087 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
2088         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
2089
2090         TP_ARGS(inode, map, ret)
2091 )
2092
2093 #else   /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
2094
2095 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
2096         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
2097                  ext4_fsblk_t pblk, unsigned int len, int ret),
2098
2099         TP_ARGS(inode, lblk, pblk, len, ret),
2100
2101         TP_STRUCT__entry(
2102                 __field(        dev_t,          dev             )
2103                 __field(        ino_t,          ino             )
2104                 __field(        ext4_fsblk_t,   pblk            )
2105                 __field(        ext4_lblk_t,    lblk            )
2106                 __field(        unsigned int,   len             )
2107                 __field(        int,            ret             )
2108         ),
2109
2110         TP_fast_assign(
2111                 tp_assign(dev, inode->i_sb->s_dev)
2112                 tp_assign(ino, inode->i_ino)
2113                 tp_assign(pblk, pblk)
2114                 tp_assign(lblk, lblk)
2115                 tp_assign(len, len)
2116                 tp_assign(ret, ret)
2117         ),
2118
2119         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u ret %d",
2120                   MAJOR(__entry->dev), MINOR(__entry->dev),
2121                   (unsigned long) __entry->ino,
2122                   __entry->lblk, __entry->pblk,
2123                   __entry->len, __entry->ret)
2124 )
2125
2126 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
2127         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
2128                  ext4_fsblk_t pblk, unsigned len, int ret),
2129
2130         TP_ARGS(inode, lblk, pblk, len, ret)
2131 )
2132
2133 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
2134         TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
2135                  ext4_fsblk_t pblk, unsigned len, int ret),
2136
2137         TP_ARGS(inode, lblk, pblk, len, ret)
2138 )
2139
2140 #endif  /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
2141
2142 TRACE_EVENT(ext4_ext_load_extent,
2143         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
2144
2145         TP_ARGS(inode, lblk, pblk),
2146
2147         TP_STRUCT__entry(
2148                 __field(        dev_t,          dev             )
2149                 __field(        ino_t,          ino             )
2150                 __field(        ext4_fsblk_t,   pblk            )
2151                 __field(        ext4_lblk_t,    lblk            )
2152         ),
2153
2154         TP_fast_assign(
2155                 tp_assign(dev, inode->i_sb->s_dev)
2156                 tp_assign(ino, inode->i_ino)
2157                 tp_assign(pblk, pblk)
2158                 tp_assign(lblk, lblk)
2159         ),
2160
2161         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
2162                   MAJOR(__entry->dev), MINOR(__entry->dev),
2163                   (unsigned long) __entry->ino,
2164                   __entry->lblk, __entry->pblk)
2165 )
2166
2167 TRACE_EVENT(ext4_load_inode,
2168         TP_PROTO(struct inode *inode),
2169
2170         TP_ARGS(inode),
2171
2172         TP_STRUCT__entry(
2173                 __field(        dev_t,  dev             )
2174                 __field(        ino_t,  ino             )
2175         ),
2176
2177         TP_fast_assign(
2178                 tp_assign(dev, inode->i_sb->s_dev)
2179                 tp_assign(ino, inode->i_ino)
2180         ),
2181
2182         TP_printk("dev %d,%d ino %ld",
2183                   MAJOR(__entry->dev), MINOR(__entry->dev),
2184                   (unsigned long) __entry->ino)
2185 )
2186 #endif
2187
2188 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
2189
2190 TRACE_EVENT(ext4_journal_start,
2191         TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
2192                  unsigned long IP),
2193
2194         TP_ARGS(sb, blocks, rsv_blocks, IP),
2195
2196         TP_STRUCT__entry(
2197                 __field(        dev_t,  dev                     )
2198                 __field(unsigned long,  ip                      )
2199                 __field(          int,  blocks                  )
2200                 __field(          int,  rsv_blocks              )
2201         ),
2202
2203         TP_fast_assign(
2204                 tp_assign(dev, sb->s_dev)
2205                 tp_assign(ip, IP)
2206                 tp_assign(blocks, blocks)
2207                 tp_assign(rsv_blocks, rsv_blocks)
2208         ),
2209
2210         TP_printk("dev %d,%d blocks, %d rsv_blocks, %d caller %pF",
2211                   MAJOR(__entry->dev), MINOR(__entry->dev),
2212                   __entry->blocks, __entry->rsv_blocks, (void *)__entry->ip)
2213 )
2214
2215 TRACE_EVENT(ext4_journal_start_reserved,
2216         TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
2217
2218         TP_ARGS(sb, blocks, IP),
2219
2220         TP_STRUCT__entry(
2221                 __field(        dev_t,  dev                     )
2222                 __field(unsigned long,  ip                      )
2223                 __field(          int,  blocks                  )
2224         ),
2225
2226         TP_fast_assign(
2227                 tp_assign(dev, sb->s_dev)
2228                 tp_assign(ip, IP)
2229                 tp_assign(blocks, blocks)
2230         ),
2231
2232         TP_printk("dev %d,%d blocks, %d caller %pF",
2233                   MAJOR(__entry->dev), MINOR(__entry->dev),
2234                   __entry->blocks, (void *)__entry->ip)
2235 )
2236
2237 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0))
2238
2239 TRACE_EVENT(ext4_journal_start,
2240         TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
2241
2242         TP_ARGS(sb, nblocks, IP),
2243
2244         TP_STRUCT__entry(
2245                 __field(        dev_t,  dev                     )
2246                 __field(unsigned long,  ip                      )
2247                 __field(          int,  nblocks                 )
2248         ),
2249
2250         TP_fast_assign(
2251                 tp_assign(dev, sb->s_dev)
2252                 tp_assign(ip, IP)
2253                 tp_assign(nblocks, nblocks)
2254         ),
2255
2256         TP_printk("dev %d,%d nblocks %d caller %pF",
2257                   MAJOR(__entry->dev), MINOR(__entry->dev),
2258                   __entry->nblocks, (void *)__entry->ip)
2259 )
2260
2261 DECLARE_EVENT_CLASS(ext4__trim,
2262         TP_PROTO(struct super_block *sb,
2263                  ext4_group_t group,
2264                  ext4_grpblk_t start,
2265                  ext4_grpblk_t len),
2266
2267         TP_ARGS(sb, group, start, len),
2268
2269         TP_STRUCT__entry(
2270                 __field(        int,    dev_major               )
2271                 __field(        int,    dev_minor               )
2272                 __field(        __u32,  group                   )
2273                 __field(        int,    start                   )
2274                 __field(        int,    len                     )
2275         ),
2276
2277         TP_fast_assign(
2278                 tp_assign(dev_major, MAJOR(sb->s_dev))
2279                 tp_assign(dev_minor, MINOR(sb->s_dev))
2280                 tp_assign(group, group)
2281                 tp_assign(start, start)
2282                 tp_assign(len, len)
2283         ),
2284
2285         TP_printk("dev %d,%d group %u, start %d, len %d",
2286                   __entry->dev_major, __entry->dev_minor,
2287                   __entry->group, __entry->start, __entry->len)
2288 )
2289
2290 DEFINE_EVENT(ext4__trim, ext4_trim_extent,
2291
2292         TP_PROTO(struct super_block *sb,
2293                  ext4_group_t group,
2294                  ext4_grpblk_t start,
2295                  ext4_grpblk_t len),
2296
2297         TP_ARGS(sb, group, start, len)
2298 )
2299
2300 DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
2301
2302         TP_PROTO(struct super_block *sb,
2303                  ext4_group_t group,
2304                  ext4_grpblk_t start,
2305                  ext4_grpblk_t len),
2306
2307         TP_ARGS(sb, group, start, len)
2308 )
2309 #endif
2310
2311 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0))
2312
2313 TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
2314 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
2315         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags,
2316                  unsigned int allocated, ext4_fsblk_t newblock),
2317
2318         TP_ARGS(inode, map, flags, allocated, newblock),
2319 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
2320         TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
2321                  unsigned int allocated, ext4_fsblk_t newblock),
2322
2323         TP_ARGS(inode, map, allocated, newblock),
2324 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
2325
2326         TP_STRUCT__entry(
2327                 __field(        dev_t,          dev             )
2328                 __field(        ino_t,          ino             )
2329                 __field(        int,            flags           )
2330                 __field(        ext4_lblk_t,    lblk            )
2331                 __field(        ext4_fsblk_t,   pblk            )
2332                 __field(        unsigned int,   len             )
2333                 __field(        unsigned int,   allocated       )
2334                 __field(        ext4_fsblk_t,   newblk          )
2335         ),
2336
2337         TP_fast_assign(
2338                 tp_assign(dev, inode->i_sb->s_dev)
2339                 tp_assign(ino, inode->i_ino)
2340 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
2341                 tp_assign(flags, flags)
2342 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
2343                 tp_assign(flags, map->m_flags)
2344 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
2345                 tp_assign(lblk, map->m_lblk)
2346                 tp_assign(pblk, map->m_pblk)
2347                 tp_assign(len, map->m_len)
2348                 tp_assign(allocated, allocated)
2349                 tp_assign(newblk, newblock)
2350         ),
2351
2352         TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %d"
2353                   "allocated %d newblock %llu",
2354                   MAJOR(__entry->dev), MINOR(__entry->dev),
2355                   (unsigned long) __entry->ino,
2356                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
2357                   __entry->len, __entry->flags,
2358                   (unsigned int) __entry->allocated,
2359                   (unsigned long long) __entry->newblk)
2360 )
2361
2362 TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
2363         TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
2364
2365         TP_ARGS(sb, map, ret),
2366
2367         TP_STRUCT__entry(
2368                 __field(        dev_t,          dev     )
2369                 __field(        unsigned int,   flags   )
2370                 __field(        ext4_lblk_t,    lblk    )
2371                 __field(        ext4_fsblk_t,   pblk    )
2372                 __field(        unsigned int,   len     )
2373                 __field(        int,            ret     )
2374         ),
2375
2376         TP_fast_assign(
2377                 tp_assign(dev, sb->s_dev)
2378                 tp_assign(flags, map->m_flags)
2379                 tp_assign(lblk, map->m_lblk)
2380                 tp_assign(pblk, map->m_pblk)
2381                 tp_assign(len, map->m_len)
2382                 tp_assign(ret, ret)
2383         ),
2384
2385         TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %u ret %d",
2386                   MAJOR(__entry->dev), MINOR(__entry->dev),
2387                   __entry->lblk, (unsigned long long) __entry->pblk,
2388                   __entry->len, __entry->flags, __entry->ret)
2389 )
2390
2391 TRACE_EVENT(ext4_ext_put_in_cache,
2392         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
2393                  ext4_fsblk_t start),
2394
2395         TP_ARGS(inode, lblk, len, start),
2396
2397         TP_STRUCT__entry(
2398                 __field(        dev_t,          dev     )
2399                 __field(        ino_t,          ino     )
2400                 __field(        ext4_lblk_t,    lblk    )
2401                 __field(        unsigned int,   len     )
2402                 __field(        ext4_fsblk_t,   start   )
2403         ),
2404
2405         TP_fast_assign(
2406                 tp_assign(dev, inode->i_sb->s_dev)
2407                 tp_assign(ino, inode->i_ino)
2408                 tp_assign(lblk, lblk)
2409                 tp_assign(len, len)
2410                 tp_assign(start, start)
2411         ),
2412
2413         TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
2414                   MAJOR(__entry->dev), MINOR(__entry->dev),
2415                   (unsigned long) __entry->ino,
2416                   (unsigned) __entry->lblk,
2417                   __entry->len,
2418                   (unsigned long long) __entry->start)
2419 )
2420
2421 TRACE_EVENT(ext4_ext_in_cache,
2422         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
2423
2424         TP_ARGS(inode, lblk, ret),
2425
2426         TP_STRUCT__entry(
2427                 __field(        dev_t,          dev     )
2428                 __field(        ino_t,          ino     )
2429                 __field(        ext4_lblk_t,    lblk    )
2430                 __field(        int,            ret     )
2431         ),
2432
2433         TP_fast_assign(
2434                 tp_assign(dev, inode->i_sb->s_dev)
2435                 tp_assign(ino, inode->i_ino)
2436                 tp_assign(lblk, lblk)
2437                 tp_assign(ret, ret)
2438         ),
2439
2440         TP_printk("dev %d,%d ino %lu lblk %u ret %d",
2441                   MAJOR(__entry->dev), MINOR(__entry->dev),
2442                   (unsigned long) __entry->ino,
2443                   (unsigned) __entry->lblk,
2444                   __entry->ret)
2445
2446 )
2447
2448 TRACE_EVENT(ext4_find_delalloc_range,
2449         TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
2450                 int reverse, int found, ext4_lblk_t found_blk),
2451
2452         TP_ARGS(inode, from, to, reverse, found, found_blk),
2453
2454         TP_STRUCT__entry(
2455                 __field(        dev_t,          dev             )
2456                 __field(        ino_t,          ino             )
2457                 __field(        ext4_lblk_t,    from            )
2458                 __field(        ext4_lblk_t,    to              )
2459                 __field(        int,            reverse         )
2460                 __field(        int,            found           )
2461                 __field(        ext4_lblk_t,    found_blk       )
2462         ),
2463
2464         TP_fast_assign(
2465                 tp_assign(dev, inode->i_sb->s_dev)
2466                 tp_assign(ino, inode->i_ino)
2467                 tp_assign(from, from)
2468                 tp_assign(to, to)
2469                 tp_assign(reverse, reverse)
2470                 tp_assign(found, found)
2471                 tp_assign(found_blk, found_blk)
2472         ),
2473
2474         TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
2475                   "(blk = %u)",
2476                   MAJOR(__entry->dev), MINOR(__entry->dev),
2477                   (unsigned long) __entry->ino,
2478                   (unsigned) __entry->from, (unsigned) __entry->to,
2479                   __entry->reverse, __entry->found,
2480                   (unsigned) __entry->found_blk)
2481 )
2482
2483 TRACE_EVENT(ext4_get_reserved_cluster_alloc,
2484         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
2485
2486         TP_ARGS(inode, lblk, len),
2487
2488         TP_STRUCT__entry(
2489                 __field(        dev_t,          dev     )
2490                 __field(        ino_t,          ino     )
2491                 __field(        ext4_lblk_t,    lblk    )
2492                 __field(        unsigned int,   len     )
2493         ),
2494
2495         TP_fast_assign(
2496                 tp_assign(dev, inode->i_sb->s_dev)
2497                 tp_assign(ino, inode->i_ino)
2498                 tp_assign(lblk, lblk)
2499                 tp_assign(len, len)
2500         ),
2501
2502         TP_printk("dev %d,%d ino %lu lblk %u len %u",
2503                   MAJOR(__entry->dev), MINOR(__entry->dev),
2504                   (unsigned long) __entry->ino,
2505                   (unsigned) __entry->lblk,
2506                   __entry->len)
2507 )
2508
2509 TRACE_EVENT(ext4_ext_show_extent,
2510         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
2511                  unsigned short len),
2512
2513         TP_ARGS(inode, lblk, pblk, len),
2514
2515         TP_STRUCT__entry(
2516                 __field(        dev_t,          dev     )
2517                 __field(        ino_t,          ino     )
2518                 __field(        ext4_fsblk_t,   pblk    )
2519                 __field(        ext4_lblk_t,    lblk    )
2520                 __field(        unsigned short, len     )
2521         ),
2522
2523         TP_fast_assign(
2524                 tp_assign(dev, inode->i_sb->s_dev)
2525                 tp_assign(ino, inode->i_ino)
2526                 tp_assign(pblk, pblk)
2527                 tp_assign(lblk, lblk)
2528                 tp_assign(len, len)
2529         ),
2530
2531         TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
2532                   MAJOR(__entry->dev), MINOR(__entry->dev),
2533                   (unsigned long) __entry->ino,
2534                   (unsigned) __entry->lblk,
2535                   (unsigned long long) __entry->pblk,
2536                   (unsigned short) __entry->len)
2537 )
2538
2539 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
2540
2541 TRACE_EVENT(ext4_remove_blocks,
2542             TP_PROTO(struct inode *inode, struct ext4_extent *ex,
2543                 ext4_lblk_t from, ext4_fsblk_t to,
2544                 long long partial_cluster),
2545
2546         TP_ARGS(inode, ex, from, to, partial_cluster),
2547
2548         TP_STRUCT__entry(
2549                 __field(        dev_t,          dev     )
2550                 __field(        ino_t,          ino     )
2551                 __field(        ext4_lblk_t,    from    )
2552                 __field(        ext4_lblk_t,    to      )
2553                 __field(        long long,      partial )
2554                 __field(        ext4_fsblk_t,   ee_pblk )
2555                 __field(        ext4_lblk_t,    ee_lblk )
2556                 __field(        unsigned short, ee_len  )
2557         ),
2558
2559         TP_fast_assign(
2560                 tp_assign(dev, inode->i_sb->s_dev)
2561                 tp_assign(ino, inode->i_ino)
2562                 tp_assign(from, from)
2563                 tp_assign(to, to)
2564                 tp_assign(partial, partial_cluster)
2565                 tp_assign(ee_pblk, ext4_ext_pblock(ex))
2566                 tp_assign(ee_lblk, le32_to_cpu(ex->ee_block))
2567                 tp_assign(ee_len, ext4_ext_get_actual_len(ex))
2568         ),
2569
2570         TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
2571                   "from %u to %u partial_cluster %lld",
2572                   MAJOR(__entry->dev), MINOR(__entry->dev),
2573                   (unsigned long) __entry->ino,
2574                   (unsigned) __entry->ee_lblk,
2575                   (unsigned long long) __entry->ee_pblk,
2576                   (unsigned short) __entry->ee_len,
2577                   (unsigned) __entry->from,
2578                   (unsigned) __entry->to,
2579                   (long long) __entry->partial)
2580 )
2581
2582 #else
2583
2584 TRACE_EVENT(ext4_remove_blocks,
2585             TP_PROTO(struct inode *inode, struct ext4_extent *ex,
2586                 ext4_lblk_t from, ext4_fsblk_t to,
2587                 ext4_fsblk_t partial_cluster),
2588
2589         TP_ARGS(inode, ex, from, to, partial_cluster),
2590
2591         TP_STRUCT__entry(
2592                 __field(        dev_t,          dev     )
2593                 __field(        ino_t,          ino     )
2594                 __field(        ext4_lblk_t,    from    )
2595                 __field(        ext4_lblk_t,    to      )
2596                 __field(        ext4_fsblk_t,   partial )
2597                 __field(        ext4_fsblk_t,   ee_pblk )
2598                 __field(        ext4_lblk_t,    ee_lblk )
2599                 __field(        unsigned short, ee_len  )
2600         ),
2601
2602         TP_fast_assign(
2603                 tp_assign(dev, inode->i_sb->s_dev)
2604                 tp_assign(ino, inode->i_ino)
2605                 tp_assign(from, from)
2606                 tp_assign(to, to)
2607                 tp_assign(partial, partial_cluster)
2608                 tp_assign(ee_pblk, ext4_ext_pblock(ex))
2609                 tp_assign(ee_lblk, cpu_to_le32(ex->ee_block))
2610                 tp_assign(ee_len, ext4_ext_get_actual_len(ex))
2611         ),
2612
2613         TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
2614                   "from %u to %u partial_cluster %u",
2615                   MAJOR(__entry->dev), MINOR(__entry->dev),
2616                   (unsigned long) __entry->ino,
2617                   (unsigned) __entry->ee_lblk,
2618                   (unsigned long long) __entry->ee_pblk,
2619                   (unsigned short) __entry->ee_len,
2620                   (unsigned) __entry->from,
2621                   (unsigned) __entry->to,
2622                   (unsigned) __entry->partial)
2623 )
2624
2625 #endif
2626
2627 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
2628
2629 TRACE_EVENT(ext4_ext_rm_leaf,
2630         TP_PROTO(struct inode *inode, ext4_lblk_t start,
2631                  struct ext4_extent *ex,
2632                  long long partial_cluster),
2633
2634         TP_ARGS(inode, start, ex, partial_cluster),
2635
2636         TP_STRUCT__entry(
2637                 __field(        dev_t,          dev     )
2638                 __field(        ino_t,          ino     )
2639                 __field(        long long,      partial )
2640                 __field(        ext4_lblk_t,    start   )
2641                 __field(        ext4_lblk_t,    ee_lblk )
2642                 __field(        ext4_fsblk_t,   ee_pblk )
2643                 __field(        short,          ee_len  )
2644         ),
2645
2646         TP_fast_assign(
2647                 tp_assign(dev, inode->i_sb->s_dev)
2648                 tp_assign(ino, inode->i_ino)
2649                 tp_assign(partial, partial_cluster)
2650                 tp_assign(start, start)
2651                 tp_assign(ee_lblk, le32_to_cpu(ex->ee_block))
2652                 tp_assign(ee_pblk, ext4_ext_pblock(ex))
2653                 tp_assign(ee_len, ext4_ext_get_actual_len(ex))
2654         ),
2655
2656         TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
2657                   "partial_cluster %lld",
2658                   MAJOR(__entry->dev), MINOR(__entry->dev),
2659                   (unsigned long) __entry->ino,
2660                   (unsigned) __entry->start,
2661                   (unsigned) __entry->ee_lblk,
2662                   (unsigned long long) __entry->ee_pblk,
2663                   (unsigned short) __entry->ee_len,
2664                   (long long) __entry->partial)
2665 )
2666
2667 #else
2668
2669 TRACE_EVENT(ext4_ext_rm_leaf,
2670         TP_PROTO(struct inode *inode, ext4_lblk_t start,
2671                  struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
2672
2673         TP_ARGS(inode, start, ex, partial_cluster),
2674
2675         TP_STRUCT__entry(
2676                 __field(        dev_t,          dev     )
2677                 __field(        ino_t,          ino     )
2678                 __field(        ext4_fsblk_t,   partial )
2679                 __field(        ext4_lblk_t,    start   )
2680                 __field(        ext4_lblk_t,    ee_lblk )
2681                 __field(        ext4_fsblk_t,   ee_pblk )
2682                 __field(        short,          ee_len  )
2683         ),
2684
2685         TP_fast_assign(
2686                 tp_assign(dev, inode->i_sb->s_dev)
2687                 tp_assign(ino, inode->i_ino)
2688                 tp_assign(partial, partial_cluster)
2689                 tp_assign(start, start)
2690                 tp_assign(ee_lblk, le32_to_cpu(ex->ee_block))
2691                 tp_assign(ee_pblk, ext4_ext_pblock(ex))
2692                 tp_assign(ee_len, ext4_ext_get_actual_len(ex))
2693         ),
2694
2695         TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
2696                   "partial_cluster %u",
2697                   MAJOR(__entry->dev), MINOR(__entry->dev),
2698                   (unsigned long) __entry->ino,
2699                   (unsigned) __entry->start,
2700                   (unsigned) __entry->ee_lblk,
2701                   (unsigned long long) __entry->ee_pblk,
2702                   (unsigned short) __entry->ee_len,
2703                   (unsigned) __entry->partial)
2704 )
2705
2706 #endif
2707
2708 TRACE_EVENT(ext4_ext_rm_idx,
2709         TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
2710
2711         TP_ARGS(inode, pblk),
2712
2713         TP_STRUCT__entry(
2714                 __field(        dev_t,          dev     )
2715                 __field(        ino_t,          ino     )
2716                 __field(        ext4_fsblk_t,   pblk    )
2717         ),
2718
2719         TP_fast_assign(
2720                 tp_assign(dev, inode->i_sb->s_dev)
2721                 tp_assign(ino, inode->i_ino)
2722                 tp_assign(pblk, pblk)
2723         ),
2724
2725         TP_printk("dev %d,%d ino %lu index_pblk %llu",
2726                   MAJOR(__entry->dev), MINOR(__entry->dev),
2727                   (unsigned long) __entry->ino,
2728                   (unsigned long long) __entry->pblk)
2729 )
2730
2731 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
2732
2733 TRACE_EVENT(ext4_ext_remove_space,
2734         TP_PROTO(struct inode *inode, ext4_lblk_t start,
2735                  ext4_lblk_t end, int depth),
2736
2737         TP_ARGS(inode, start, end, depth),
2738
2739         TP_STRUCT__entry(
2740                 __field(        dev_t,          dev     )
2741                 __field(        ino_t,          ino     )
2742                 __field(        ext4_lblk_t,    start   )
2743                 __field(        ext4_lblk_t,    end     )
2744                 __field(        int,            depth   )
2745         ),
2746
2747         TP_fast_assign(
2748                 tp_assign(dev, inode->i_sb->s_dev)
2749                 tp_assign(ino, inode->i_ino)
2750                 tp_assign(start, start)
2751                 tp_assign(end, end)
2752                 tp_assign(depth, depth)
2753         ),
2754
2755         TP_printk("dev %d,%d ino %lu since %u end %u depth %d",
2756                   MAJOR(__entry->dev), MINOR(__entry->dev),
2757                   (unsigned long) __entry->ino,
2758                   (unsigned) __entry->start,
2759                   (unsigned) __entry->end,
2760                   __entry->depth)
2761 )
2762
2763 #else
2764
2765 TRACE_EVENT(ext4_ext_remove_space,
2766         TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
2767
2768         TP_ARGS(inode, start, depth),
2769
2770         TP_STRUCT__entry(
2771                 __field(        dev_t,          dev     )
2772                 __field(        ino_t,          ino     )
2773                 __field(        ext4_lblk_t,    start   )
2774                 __field(        int,            depth   )
2775         ),
2776
2777         TP_fast_assign(
2778                 tp_assign(dev, inode->i_sb->s_dev)
2779                 tp_assign(ino, inode->i_ino)
2780                 tp_assign(start, start)
2781                 tp_assign(depth, depth)
2782         ),
2783
2784         TP_printk("dev %d,%d ino %lu since %u depth %d",
2785                   MAJOR(__entry->dev), MINOR(__entry->dev),
2786                   (unsigned long) __entry->ino,
2787                   (unsigned) __entry->start,
2788                   __entry->depth)
2789 )
2790
2791 #endif
2792
2793 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
2794
2795 TRACE_EVENT(ext4_ext_remove_space_done,
2796         TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end,
2797                  int depth, long long partial, __le16 eh_entries),
2798
2799         TP_ARGS(inode, start, end, depth, partial, eh_entries),
2800
2801         TP_STRUCT__entry(
2802                 __field(        dev_t,          dev             )
2803                 __field(        ino_t,          ino             )
2804                 __field(        ext4_lblk_t,    start           )
2805                 __field(        ext4_lblk_t,    end             )
2806                 __field(        int,            depth           )
2807                 __field(        long long,      partial         )
2808                 __field(        unsigned short, eh_entries      )
2809         ),
2810
2811         TP_fast_assign(
2812                 tp_assign(dev, inode->i_sb->s_dev)
2813                 tp_assign(ino, inode->i_ino)
2814                 tp_assign(start, start)
2815                 tp_assign(end, end)
2816                 tp_assign(depth, depth)
2817                 tp_assign(partial, partial)
2818                 tp_assign(eh_entries, le16_to_cpu(eh_entries))
2819         ),
2820
2821         TP_printk("dev %d,%d ino %lu since %u end %u depth %d partial %lld "
2822                   "remaining_entries %u",
2823                   MAJOR(__entry->dev), MINOR(__entry->dev),
2824                   (unsigned long) __entry->ino,
2825                   (unsigned) __entry->start,
2826                   (unsigned) __entry->end,
2827                   __entry->depth,
2828                   (long long) __entry->partial,
2829                   (unsigned short) __entry->eh_entries)
2830 )
2831
2832 #else
2833
2834 TRACE_EVENT(ext4_ext_remove_space_done,
2835         TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
2836                 ext4_lblk_t partial, unsigned short eh_entries),
2837
2838         TP_ARGS(inode, start, depth, partial, eh_entries),
2839
2840         TP_STRUCT__entry(
2841                 __field(        dev_t,          dev             )
2842                 __field(        ino_t,          ino             )
2843                 __field(        ext4_lblk_t,    start           )
2844                 __field(        int,            depth           )
2845                 __field(        ext4_lblk_t,    partial         )
2846                 __field(        unsigned short, eh_entries      )
2847         ),
2848
2849         TP_fast_assign(
2850                 tp_assign(dev, inode->i_sb->s_dev)
2851                 tp_assign(ino, inode->i_ino)
2852                 tp_assign(start, start)
2853                 tp_assign(depth, depth)
2854                 tp_assign(partial, partial)
2855                 tp_assign(eh_entries, eh_entries)
2856         ),
2857
2858         TP_printk("dev %d,%d ino %lu since %u depth %d partial %u "
2859                   "remaining_entries %u",
2860                   MAJOR(__entry->dev), MINOR(__entry->dev),
2861                   (unsigned long) __entry->ino,
2862                   (unsigned) __entry->start,
2863                   __entry->depth,
2864                   (unsigned) __entry->partial,
2865                   (unsigned short) __entry->eh_entries)
2866 )
2867
2868 #endif
2869
2870 #endif
2871
2872 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,0))
2873
2874 DECLARE_EVENT_CLASS(ext4__es_extent,
2875         TP_PROTO(struct inode *inode, struct extent_status *es),
2876
2877         TP_ARGS(inode, es),
2878
2879         TP_STRUCT__entry(
2880                 __field(        dev_t,          dev             )
2881                 __field(        ino_t,          ino             )
2882                 __field(        ext4_lblk_t,    lblk            )
2883                 __field(        ext4_lblk_t,    len             )
2884                 __field(        ext4_fsblk_t,   pblk            )
2885                 __field(        char, status    )
2886         ),
2887
2888         TP_fast_assign(
2889                 tp_assign(dev, inode->i_sb->s_dev)
2890                 tp_assign(ino, inode->i_ino)
2891                 tp_assign(lblk, es->es_lblk)
2892                 tp_assign(len, es->es_len)
2893                 tp_assign(pblk, ext4_es_pblock(es))
2894                 tp_assign(status, ext4_es_status(es))
2895         ),
2896
2897         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
2898                   MAJOR(__entry->dev), MINOR(__entry->dev),
2899                   (unsigned long) __entry->ino,
2900                   __entry->lblk, __entry->len,
2901                   __entry->pblk, show_extent_status(__entry->status))
2902 )
2903
2904 DEFINE_EVENT(ext4__es_extent, ext4_es_insert_extent,
2905         TP_PROTO(struct inode *inode, struct extent_status *es),
2906
2907         TP_ARGS(inode, es)
2908 )
2909
2910 DEFINE_EVENT(ext4__es_extent, ext4_es_cache_extent,
2911         TP_PROTO(struct inode *inode, struct extent_status *es),
2912
2913         TP_ARGS(inode, es)
2914 )
2915
2916 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
2917
2918 TRACE_EVENT(ext4_es_insert_extent,
2919         TP_PROTO(struct inode *inode, struct extent_status *es),
2920
2921         TP_ARGS(inode, es),
2922
2923         TP_STRUCT__entry(
2924                 __field(        dev_t,          dev             )
2925                 __field(        ino_t,          ino             )
2926                 __field(        ext4_lblk_t,    lblk            )
2927                 __field(        ext4_lblk_t,    len             )
2928                 __field(        ext4_fsblk_t,   pblk            )
2929                 __field(        char, status    )
2930         ),
2931
2932         TP_fast_assign(
2933                 tp_assign(dev, inode->i_sb->s_dev)
2934                 tp_assign(ino, inode->i_ino)
2935                 tp_assign(lblk, es->es_lblk)
2936                 tp_assign(len, es->es_len)
2937                 tp_assign(pblk, ext4_es_pblock(es))
2938                 tp_assign(status, ext4_es_status(es) >> 60)
2939         ),
2940
2941         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
2942                   MAJOR(__entry->dev), MINOR(__entry->dev),
2943                   (unsigned long) __entry->ino,
2944                   __entry->lblk, __entry->len,
2945                   __entry->pblk, show_extent_status(__entry->status))
2946 )
2947
2948 TRACE_EVENT(ext4_es_remove_extent,
2949         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
2950
2951         TP_ARGS(inode, lblk, len),
2952
2953         TP_STRUCT__entry(
2954                 __field(        dev_t,  dev                     )
2955                 __field(        ino_t,  ino                     )
2956                 __field(        loff_t, lblk                    )
2957                 __field(        loff_t, len                     )
2958         ),
2959
2960         TP_fast_assign(
2961                 tp_assign(dev, inode->i_sb->s_dev)
2962                 tp_assign(ino, inode->i_ino)
2963                 tp_assign(lblk, lblk)
2964                 tp_assign(len, len)
2965         ),
2966
2967         TP_printk("dev %d,%d ino %lu es [%lld/%lld)",
2968                   MAJOR(__entry->dev), MINOR(__entry->dev),
2969                   (unsigned long) __entry->ino,
2970                   __entry->lblk, __entry->len)
2971 )
2972
2973 TRACE_EVENT(ext4_es_find_delayed_extent_range_enter,
2974         TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
2975
2976         TP_ARGS(inode, lblk),
2977
2978         TP_STRUCT__entry(
2979                 __field(        dev_t,          dev             )
2980                 __field(        ino_t,          ino             )
2981                 __field(        ext4_lblk_t,    lblk            )
2982         ),
2983
2984         TP_fast_assign(
2985                 tp_assign(dev, inode->i_sb->s_dev)
2986                 tp_assign(ino, inode->i_ino)
2987                 tp_assign(lblk, lblk)
2988         ),
2989
2990         TP_printk("dev %d,%d ino %lu lblk %u",
2991                   MAJOR(__entry->dev), MINOR(__entry->dev),
2992                   (unsigned long) __entry->ino, __entry->lblk)
2993 )
2994
2995 TRACE_EVENT(ext4_es_find_delayed_extent_range_exit,
2996         TP_PROTO(struct inode *inode, struct extent_status *es),
2997
2998         TP_ARGS(inode, es),
2999
3000         TP_STRUCT__entry(
3001                 __field(        dev_t,          dev             )
3002                 __field(        ino_t,          ino             )
3003                 __field(        ext4_lblk_t,    lblk            )
3004                 __field(        ext4_lblk_t,    len             )
3005                 __field(        ext4_fsblk_t,   pblk            )
3006                 __field(        char, status    )
3007         ),
3008
3009         TP_fast_assign(
3010                 tp_assign(dev, inode->i_sb->s_dev)
3011                 tp_assign(ino, inode->i_ino)
3012                 tp_assign(lblk, es->es_lblk)
3013                 tp_assign(len, es->es_len)
3014                 tp_assign(pblk, ext4_es_pblock(es))
3015                 tp_assign(status, ext4_es_status(es) >> 60)
3016         ),
3017
3018         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
3019                   MAJOR(__entry->dev), MINOR(__entry->dev),
3020                   (unsigned long) __entry->ino,
3021                   __entry->lblk, __entry->len,
3022                   __entry->pblk, show_extent_status(__entry->status))
3023 )
3024
3025 TRACE_EVENT(ext4_es_lookup_extent_enter,
3026         TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
3027
3028         TP_ARGS(inode, lblk),
3029
3030         TP_STRUCT__entry(
3031                 __field(        dev_t,          dev             )
3032                 __field(        ino_t,          ino             )
3033                 __field(        ext4_lblk_t,    lblk            )
3034         ),
3035
3036         TP_fast_assign(
3037                 tp_assign(dev, inode->i_sb->s_dev)
3038                 tp_assign(ino, inode->i_ino)
3039                 tp_assign(lblk, lblk)
3040         ),
3041
3042         TP_printk("dev %d,%d ino %lu lblk %u",
3043                   MAJOR(__entry->dev), MINOR(__entry->dev),
3044                   (unsigned long) __entry->ino, __entry->lblk)
3045 )
3046
3047 TRACE_EVENT(ext4_es_lookup_extent_exit,
3048         TP_PROTO(struct inode *inode, struct extent_status *es,
3049                  int found),
3050
3051         TP_ARGS(inode, es, found),
3052
3053         TP_STRUCT__entry(
3054                 __field(        dev_t,          dev             )
3055                 __field(        ino_t,          ino             )
3056                 __field(        ext4_lblk_t,    lblk            )
3057                 __field(        ext4_lblk_t,    len             )
3058                 __field(        ext4_fsblk_t,   pblk            )
3059                 __field(        char,           status          )
3060                 __field(        int,            found           )
3061         ),
3062
3063         TP_fast_assign(
3064                 tp_assign(dev, inode->i_sb->s_dev)
3065                 tp_assign(ino, inode->i_ino)
3066                 tp_assign(lblk, es->es_lblk)
3067                 tp_assign(len, es->es_len)
3068                 tp_assign(pblk, ext4_es_pblock(es))
3069                 tp_assign(status, ext4_es_status(es) >> 60)
3070                 tp_assign(found, found)
3071         ),
3072
3073         TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %s",
3074                   MAJOR(__entry->dev), MINOR(__entry->dev),
3075                   (unsigned long) __entry->ino, __entry->found,
3076                   __entry->lblk, __entry->len,
3077                   __entry->found ? __entry->pblk : 0,
3078                   show_extent_status(__entry->found ? __entry->status : 0))
3079 )
3080
3081 TRACE_EVENT(ext4_es_shrink_enter,
3082         TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
3083
3084         TP_ARGS(sb, nr_to_scan, cache_cnt),
3085
3086         TP_STRUCT__entry(
3087                 __field(        dev_t,  dev                     )
3088                 __field(        int,    nr_to_scan              )
3089                 __field(        int,    cache_cnt               )
3090         ),
3091
3092         TP_fast_assign(
3093                 tp_assign(dev, sb->s_dev)
3094                 tp_assign(nr_to_scan, nr_to_scan)
3095                 tp_assign(cache_cnt, cache_cnt)
3096         ),
3097
3098         TP_printk("dev %d,%d nr_to_scan %d cache_cnt %d",
3099                   MAJOR(__entry->dev), MINOR(__entry->dev),
3100                   __entry->nr_to_scan, __entry->cache_cnt)
3101 )
3102
3103 TRACE_EVENT(ext4_es_shrink_exit,
3104         TP_PROTO(struct super_block *sb, int shrunk_nr, int cache_cnt),
3105
3106         TP_ARGS(sb, shrunk_nr, cache_cnt),
3107
3108         TP_STRUCT__entry(
3109                 __field(        dev_t,  dev                     )
3110                 __field(        int,    shrunk_nr               )
3111                 __field(        int,    cache_cnt               )
3112         ),
3113
3114         TP_fast_assign(
3115                 tp_assign(dev, sb->s_dev)
3116                 tp_assign(shrunk_nr, shrunk_nr)
3117                 tp_assign(cache_cnt, cache_cnt)
3118         ),
3119
3120         TP_printk("dev %d,%d shrunk_nr %d cache_cnt %d",
3121                   MAJOR(__entry->dev), MINOR(__entry->dev),
3122                   __entry->shrunk_nr, __entry->cache_cnt)
3123 )
3124
3125 #endif
3126
3127 #endif /* _TRACE_EXT4_H */
3128
3129 /* This part must be outside protection */
3130 #include "../../../probes/define_trace.h"