include/trace/events/f2fs.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM f2fs
   3
   4 #if !defined(_TRACE_F2FS_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_F2FS_H
   6
   7 #include <linux/tracepoint.h>
   8
   9 #define show_dev(dev)           MAJOR(dev), MINOR(dev)
  10 #define show_dev_ino(entry)     show_dev(entry->dev), (unsigned long)entry->ino
  11
  12 TRACE_DEFINE_ENUM(NODE);
  13 TRACE_DEFINE_ENUM(DATA);
  14 TRACE_DEFINE_ENUM(META);
  15 TRACE_DEFINE_ENUM(META_FLUSH);
  16 TRACE_DEFINE_ENUM(INMEM);
  17 TRACE_DEFINE_ENUM(INMEM_DROP);
  18 TRACE_DEFINE_ENUM(INMEM_INVALIDATE);
  19 TRACE_DEFINE_ENUM(INMEM_REVOKE);
  20 TRACE_DEFINE_ENUM(IPU);
  21 TRACE_DEFINE_ENUM(OPU);
  22 TRACE_DEFINE_ENUM(CURSEG_HOT_DATA);
  23 TRACE_DEFINE_ENUM(CURSEG_WARM_DATA);
  24 TRACE_DEFINE_ENUM(CURSEG_COLD_DATA);
  25 TRACE_DEFINE_ENUM(CURSEG_HOT_NODE);
  26 TRACE_DEFINE_ENUM(CURSEG_WARM_NODE);
  27 TRACE_DEFINE_ENUM(CURSEG_COLD_NODE);
  28 TRACE_DEFINE_ENUM(NO_CHECK_TYPE);
  29 TRACE_DEFINE_ENUM(GC_GREEDY);
  30 TRACE_DEFINE_ENUM(GC_CB);
  31 TRACE_DEFINE_ENUM(FG_GC);
  32 TRACE_DEFINE_ENUM(BG_GC);
  33 TRACE_DEFINE_ENUM(LFS);
  34 TRACE_DEFINE_ENUM(SSR);
  35 TRACE_DEFINE_ENUM(__REQ_RAHEAD);
  36 TRACE_DEFINE_ENUM(__REQ_SYNC);
  37 TRACE_DEFINE_ENUM(__REQ_IDLE);
  38 TRACE_DEFINE_ENUM(__REQ_PREFLUSH);
  39 TRACE_DEFINE_ENUM(__REQ_FUA);
  40 TRACE_DEFINE_ENUM(__REQ_PRIO);
  41 TRACE_DEFINE_ENUM(__REQ_META);
  42 TRACE_DEFINE_ENUM(CP_UMOUNT);
  43 TRACE_DEFINE_ENUM(CP_FASTBOOT);
  44 TRACE_DEFINE_ENUM(CP_SYNC);
  45 TRACE_DEFINE_ENUM(CP_RECOVERY);
  46 TRACE_DEFINE_ENUM(CP_DISCARD);
  47 TRACE_DEFINE_ENUM(CP_TRIMMED);
  48
  49 #define show_block_type(type)                                           \
  50         __print_symbolic(type,                                          \
  51                 { NODE,         "NODE" },                               \
  52                 { DATA,         "DATA" },                               \
  53                 { META,         "META" },                               \
  54                 { META_FLUSH,   "META_FLUSH" },                         \
  55                 { INMEM,        "INMEM" },                              \
  56                 { INMEM_DROP,   "INMEM_DROP" },                         \
  57                 { INMEM_INVALIDATE,     "INMEM_INVALIDATE" },           \
  58                 { INMEM_REVOKE, "INMEM_REVOKE" },                       \
  59                 { IPU,          "IN-PLACE" },                           \
  60                 { OPU,          "OUT-OF-PLACE" })
  61
  62 #define F2FS_OP_FLAGS (REQ_RAHEAD | REQ_SYNC | REQ_META | REQ_PRIO |    \
  63                         REQ_PREFLUSH | REQ_FUA)
  64 #define F2FS_BIO_FLAG_MASK(t)   (t & F2FS_OP_FLAGS)
  65
  66 #define show_bio_type(op,op_flags)      show_bio_op(op),                \
  67                                                 show_bio_op_flags(op_flags)
  68
  69 #define show_bio_op(op)                                                 \
  70         __print_symbolic(op,                                            \
  71                 { REQ_OP_READ,                  "READ" },               \
  72                 { REQ_OP_WRITE,                 "WRITE" },              \
  73                 { REQ_OP_FLUSH,                 "FLUSH" },              \
  74                 { REQ_OP_DISCARD,               "DISCARD" },            \
  75                 { REQ_OP_ZONE_REPORT,           "ZONE_REPORT" },        \
  76                 { REQ_OP_SECURE_ERASE,          "SECURE_ERASE" },       \
  77                 { REQ_OP_ZONE_RESET,            "ZONE_RESET" },         \
  78                 { REQ_OP_WRITE_SAME,            "WRITE_SAME" },         \
  79                 { REQ_OP_WRITE_ZEROES,          "WRITE_ZEROES" })
  80
  81 #define show_bio_op_flags(flags)                                        \
  82         __print_flags(F2FS_BIO_FLAG_MASK(flags), "|",                   \
  83                 { REQ_RAHEAD,           "R" },                          \
  84                 { REQ_SYNC,             "S" },                          \
  85                 { REQ_META,             "M" },                          \
  86                 { REQ_PRIO,             "P" },                          \
  87                 { REQ_PREFLUSH,         "PF" },                         \
  88                 { REQ_FUA,              "FUA" })
  89
  90 #define show_data_type(type)                                            \
  91         __print_symbolic(type,                                          \
  92                 { CURSEG_HOT_DATA,      "Hot DATA" },                   \
  93                 { CURSEG_WARM_DATA,     "Warm DATA" },                  \
  94                 { CURSEG_COLD_DATA,     "Cold DATA" },                  \
  95                 { CURSEG_HOT_NODE,      "Hot NODE" },                   \
  96                 { CURSEG_WARM_NODE,     "Warm NODE" },                  \
  97                 { CURSEG_COLD_NODE,     "Cold NODE" },                  \
  98                 { NO_CHECK_TYPE,        "No TYPE" })
  99
 100 #define show_file_type(type)                                            \
 101         __print_symbolic(type,                                          \
 102                 { 0,            "FILE" },                               \
 103                 { 1,            "DIR" })
 104
 105 #define show_gc_type(type)                                              \
 106         __print_symbolic(type,                                          \
 107                 { FG_GC,        "Foreground GC" },                      \
 108                 { BG_GC,        "Background GC" })
 109
 110 #define show_alloc_mode(type)                                           \
 111         __print_symbolic(type,                                          \
 112                 { LFS,  "LFS-mode" },                                   \
 113                 { SSR,  "SSR-mode" })
 114
 115 #define show_victim_policy(type)                                        \
 116         __print_symbolic(type,                                          \
 117                 { GC_GREEDY,    "Greedy" },                             \
 118                 { GC_CB,        "Cost-Benefit" })
 119
 120 #define show_cpreason(type)                                             \
 121         __print_flags(type, "|",                                        \
 122                 { CP_UMOUNT,    "Umount" },                             \
 123                 { CP_FASTBOOT,  "Fastboot" },                           \
 124                 { CP_SYNC,      "Sync" },                               \
 125                 { CP_RECOVERY,  "Recovery" },                           \
 126                 { CP_DISCARD,   "Discard" },                            \
 127                 { CP_UMOUNT,    "Umount" },                             \
 128                 { CP_TRIMMED,   "Trimmed" })
 129
 130 struct victim_sel_policy;
 131 struct f2fs_map_blocks;
 132
 133 DECLARE_EVENT_CLASS(f2fs__inode,
 134
 135         TP_PROTO(struct inode *inode),
 136
 137         TP_ARGS(inode),
 138
 139         TP_STRUCT__entry(
 140                 __field(dev_t,  dev)
 141                 __field(ino_t,  ino)
 142                 __field(ino_t,  pino)
 143                 __field(umode_t, mode)
 144                 __field(loff_t, size)
 145                 __field(unsigned int, nlink)
 146                 __field(blkcnt_t, blocks)
 147                 __field(__u8,   advise)
 148         ),
 149
 150         TP_fast_assign(
 151                 __entry->dev    = inode->i_sb->s_dev;
 152                 __entry->ino    = inode->i_ino;
 153                 __entry->pino   = F2FS_I(inode)->i_pino;
 154                 __entry->mode   = inode->i_mode;
 155                 __entry->nlink  = inode->i_nlink;
 156                 __entry->size   = inode->i_size;
 157                 __entry->blocks = inode->i_blocks;
 158                 __entry->advise = F2FS_I(inode)->i_advise;
 159         ),
 160
 161         TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
 162                 "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
 163                 show_dev_ino(__entry),
 164                 (unsigned long)__entry->pino,
 165                 __entry->mode,
 166                 __entry->size,
 167                 (unsigned int)__entry->nlink,
 168                 (unsigned long long)__entry->blocks,
 169                 (unsigned char)__entry->advise)
 170 );
 171
 172 DECLARE_EVENT_CLASS(f2fs__inode_exit,
 173
 174         TP_PROTO(struct inode *inode, int ret),
 175
 176         TP_ARGS(inode, ret),
 177
 178         TP_STRUCT__entry(
 179                 __field(dev_t,  dev)
 180                 __field(ino_t,  ino)
 181                 __field(int,    ret)
 182         ),
 183
 184         TP_fast_assign(
 185                 __entry->dev    = inode->i_sb->s_dev;
 186                 __entry->ino    = inode->i_ino;
 187                 __entry->ret    = ret;
 188         ),
 189
 190         TP_printk("dev = (%d,%d), ino = %lu, ret = %d",
 191                 show_dev_ino(__entry),
 192                 __entry->ret)
 193 );
 194
 195 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter,
 196
 197         TP_PROTO(struct inode *inode),
 198
 199         TP_ARGS(inode)
 200 );
 201
 202 TRACE_EVENT(f2fs_sync_file_exit,
 203
 204         TP_PROTO(struct inode *inode, int need_cp, int datasync, int ret),
 205
 206         TP_ARGS(inode, need_cp, datasync, ret),
 207
 208         TP_STRUCT__entry(
 209                 __field(dev_t,  dev)
 210                 __field(ino_t,  ino)
 211                 __field(int,    need_cp)
 212                 __field(int,    datasync)
 213                 __field(int,    ret)
 214         ),
 215
 216         TP_fast_assign(
 217                 __entry->dev            = inode->i_sb->s_dev;
 218                 __entry->ino            = inode->i_ino;
 219                 __entry->need_cp        = need_cp;
 220                 __entry->datasync       = datasync;
 221                 __entry->ret            = ret;
 222         ),
 223
 224         TP_printk("dev = (%d,%d), ino = %lu, checkpoint is %s, "
 225                 "datasync = %d, ret = %d",
 226                 show_dev_ino(__entry),
 227                 __entry->need_cp ? "needed" : "not needed",
 228                 __entry->datasync,
 229                 __entry->ret)
 230 );
 231
 232 TRACE_EVENT(f2fs_sync_fs,
 233
 234         TP_PROTO(struct super_block *sb, int wait),
 235
 236         TP_ARGS(sb, wait),
 237
 238         TP_STRUCT__entry(
 239                 __field(dev_t,  dev)
 240                 __field(int,    dirty)
 241                 __field(int,    wait)
 242         ),
 243
 244         TP_fast_assign(
 245                 __entry->dev    = sb->s_dev;
 246                 __entry->dirty  = is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY);
 247                 __entry->wait   = wait;
 248         ),
 249
 250         TP_printk("dev = (%d,%d), superblock is %s, wait = %d",
 251                 show_dev(__entry->dev),
 252                 __entry->dirty ? "dirty" : "not dirty",
 253                 __entry->wait)
 254 );
 255
 256 DEFINE_EVENT(f2fs__inode, f2fs_iget,
 257
 258         TP_PROTO(struct inode *inode),
 259
 260         TP_ARGS(inode)
 261 );
 262
 263 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit,
 264
 265         TP_PROTO(struct inode *inode, int ret),
 266
 267         TP_ARGS(inode, ret)
 268 );
 269
 270 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode,
 271
 272         TP_PROTO(struct inode *inode),
 273
 274         TP_ARGS(inode)
 275 );
 276
 277 DEFINE_EVENT(f2fs__inode_exit, f2fs_new_inode,
 278
 279         TP_PROTO(struct inode *inode, int ret),
 280
 281         TP_ARGS(inode, ret)
 282 );
 283
 284 TRACE_EVENT(f2fs_unlink_enter,
 285
 286         TP_PROTO(struct inode *dir, struct dentry *dentry),
 287
 288         TP_ARGS(dir, dentry),
 289
 290         TP_STRUCT__entry(
 291                 __field(dev_t,  dev)
 292                 __field(ino_t,  ino)
 293                 __field(loff_t, size)
 294                 __field(blkcnt_t, blocks)
 295                 __field(const char *,   name)
 296         ),
 297
 298         TP_fast_assign(
 299                 __entry->dev    = dir->i_sb->s_dev;
 300                 __entry->ino    = dir->i_ino;
 301                 __entry->size   = dir->i_size;
 302                 __entry->blocks = dir->i_blocks;
 303                 __entry->name   = dentry->d_name.name;
 304         ),
 305
 306         TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
 307                 "i_blocks = %llu, name = %s",
 308                 show_dev_ino(__entry),
 309                 __entry->size,
 310                 (unsigned long long)__entry->blocks,
 311                 __entry->name)
 312 );
 313
 314 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit,
 315
 316         TP_PROTO(struct inode *inode, int ret),
 317
 318         TP_ARGS(inode, ret)
 319 );
 320
 321 DEFINE_EVENT(f2fs__inode_exit, f2fs_drop_inode,
 322
 323         TP_PROTO(struct inode *inode, int ret),
 324
 325         TP_ARGS(inode, ret)
 326 );
 327
 328 DEFINE_EVENT(f2fs__inode, f2fs_truncate,
 329
 330         TP_PROTO(struct inode *inode),
 331
 332         TP_ARGS(inode)
 333 );
 334
 335 TRACE_EVENT(f2fs_truncate_data_blocks_range,
 336
 337         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free),
 338
 339         TP_ARGS(inode, nid,  ofs, free),
 340
 341         TP_STRUCT__entry(
 342                 __field(dev_t,  dev)
 343                 __field(ino_t,  ino)
 344                 __field(nid_t,  nid)
 345                 __field(unsigned int,   ofs)
 346                 __field(int,    free)
 347         ),
 348
 349         TP_fast_assign(
 350                 __entry->dev    = inode->i_sb->s_dev;
 351                 __entry->ino    = inode->i_ino;
 352                 __entry->nid    = nid;
 353                 __entry->ofs    = ofs;
 354                 __entry->free   = free;
 355         ),
 356
 357         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
 358                 show_dev_ino(__entry),
 359                 (unsigned int)__entry->nid,
 360                 __entry->ofs,
 361                 __entry->free)
 362 );
 363
 364 DECLARE_EVENT_CLASS(f2fs__truncate_op,
 365
 366         TP_PROTO(struct inode *inode, u64 from),
 367
 368         TP_ARGS(inode, from),
 369
 370         TP_STRUCT__entry(
 371                 __field(dev_t,  dev)
 372                 __field(ino_t,  ino)
 373                 __field(loff_t, size)
 374                 __field(blkcnt_t, blocks)
 375                 __field(u64,    from)
 376         ),
 377
 378         TP_fast_assign(
 379                 __entry->dev    = inode->i_sb->s_dev;
 380                 __entry->ino    = inode->i_ino;
 381                 __entry->size   = inode->i_size;
 382                 __entry->blocks = inode->i_blocks;
 383                 __entry->from   = from;
 384         ),
 385
 386         TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
 387                 "start file offset = %llu",
 388                 show_dev_ino(__entry),
 389                 __entry->size,
 390                 (unsigned long long)__entry->blocks,
 391                 (unsigned long long)__entry->from)
 392 );
 393
 394 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter,
 395
 396         TP_PROTO(struct inode *inode, u64 from),
 397
 398         TP_ARGS(inode, from)
 399 );
 400
 401 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit,
 402
 403         TP_PROTO(struct inode *inode, int ret),
 404
 405         TP_ARGS(inode, ret)
 406 );
 407
 408 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter,
 409
 410         TP_PROTO(struct inode *inode, u64 from),
 411
 412         TP_ARGS(inode, from)
 413 );
 414
 415 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit,
 416
 417         TP_PROTO(struct inode *inode, int ret),
 418
 419         TP_ARGS(inode, ret)
 420 );
 421
 422 DECLARE_EVENT_CLASS(f2fs__truncate_node,
 423
 424         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 425
 426         TP_ARGS(inode, nid, blk_addr),
 427
 428         TP_STRUCT__entry(
 429                 __field(dev_t,  dev)
 430                 __field(ino_t,  ino)
 431                 __field(nid_t,  nid)
 432                 __field(block_t,        blk_addr)
 433         ),
 434
 435         TP_fast_assign(
 436                 __entry->dev            = inode->i_sb->s_dev;
 437                 __entry->ino            = inode->i_ino;
 438                 __entry->nid            = nid;
 439                 __entry->blk_addr       = blk_addr;
 440         ),
 441
 442         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
 443                 show_dev_ino(__entry),
 444                 (unsigned int)__entry->nid,
 445                 (unsigned long long)__entry->blk_addr)
 446 );
 447
 448 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter,
 449
 450         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 451
 452         TP_ARGS(inode, nid, blk_addr)
 453 );
 454
 455 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit,
 456
 457         TP_PROTO(struct inode *inode, int ret),
 458
 459         TP_ARGS(inode, ret)
 460 );
 461
 462 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node,
 463
 464         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 465
 466         TP_ARGS(inode, nid, blk_addr)
 467 );
 468
 469 TRACE_EVENT(f2fs_truncate_partial_nodes,
 470
 471         TP_PROTO(struct inode *inode, nid_t nid[], int depth, int err),
 472
 473         TP_ARGS(inode, nid, depth, err),
 474
 475         TP_STRUCT__entry(
 476                 __field(dev_t,  dev)
 477                 __field(ino_t,  ino)
 478                 __field(nid_t,  nid[3])
 479                 __field(int,    depth)
 480                 __field(int,    err)
 481         ),
 482
 483         TP_fast_assign(
 484                 __entry->dev    = inode->i_sb->s_dev;
 485                 __entry->ino    = inode->i_ino;
 486                 __entry->nid[0] = nid[0];
 487                 __entry->nid[1] = nid[1];
 488                 __entry->nid[2] = nid[2];
 489                 __entry->depth  = depth;
 490                 __entry->err    = err;
 491         ),
 492
 493         TP_printk("dev = (%d,%d), ino = %lu, "
 494                 "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
 495                 show_dev_ino(__entry),
 496                 (unsigned int)__entry->nid[0],
 497                 (unsigned int)__entry->nid[1],
 498                 (unsigned int)__entry->nid[2],
 499                 __entry->depth,
 500                 __entry->err)
 501 );
 502
 503 TRACE_EVENT(f2fs_map_blocks,
 504         TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map, int ret),
 505
 506         TP_ARGS(inode, map, ret),
 507
 508         TP_STRUCT__entry(
 509                 __field(dev_t,  dev)
 510                 __field(ino_t,  ino)
 511                 __field(block_t,        m_lblk)
 512                 __field(block_t,        m_pblk)
 513                 __field(unsigned int,   m_len)
 514                 __field(int,    ret)
 515         ),
 516
 517         TP_fast_assign(
 518                 __entry->dev            = inode->i_sb->s_dev;
 519                 __entry->ino            = inode->i_ino;
 520                 __entry->m_lblk         = map->m_lblk;
 521                 __entry->m_pblk         = map->m_pblk;
 522                 __entry->m_len          = map->m_len;
 523                 __entry->ret            = ret;
 524         ),
 525
 526         TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
 527                 "start blkaddr = 0x%llx, len = 0x%llx, err = %d",
 528                 show_dev_ino(__entry),
 529                 (unsigned long long)__entry->m_lblk,
 530                 (unsigned long long)__entry->m_pblk,
 531                 (unsigned long long)__entry->m_len,
 532                 __entry->ret)
 533 );
 534
 535 TRACE_EVENT(f2fs_background_gc,
 536
 537         TP_PROTO(struct super_block *sb, long wait_ms,
 538                         unsigned int prefree, unsigned int free),
 539
 540         TP_ARGS(sb, wait_ms, prefree, free),
 541
 542         TP_STRUCT__entry(
 543                 __field(dev_t,  dev)
 544                 __field(long,   wait_ms)
 545                 __field(unsigned int,   prefree)
 546                 __field(unsigned int,   free)
 547         ),
 548
 549         TP_fast_assign(
 550                 __entry->dev            = sb->s_dev;
 551                 __entry->wait_ms        = wait_ms;
 552                 __entry->prefree        = prefree;
 553                 __entry->free           = free;
 554         ),
 555
 556         TP_printk("dev = (%d,%d), wait_ms = %ld, prefree = %u, free = %u",
 557                 show_dev(__entry->dev),
 558                 __entry->wait_ms,
 559                 __entry->prefree,
 560                 __entry->free)
 561 );
 562
 563 TRACE_EVENT(f2fs_get_victim,
 564
 565         TP_PROTO(struct super_block *sb, int type, int gc_type,
 566                         struct victim_sel_policy *p, unsigned int pre_victim,
 567                         unsigned int prefree, unsigned int free),
 568
 569         TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free),
 570
 571         TP_STRUCT__entry(
 572                 __field(dev_t,  dev)
 573                 __field(int,    type)
 574                 __field(int,    gc_type)
 575                 __field(int,    alloc_mode)
 576                 __field(int,    gc_mode)
 577                 __field(unsigned int,   victim)
 578                 __field(unsigned int,   cost)
 579                 __field(unsigned int,   ofs_unit)
 580                 __field(unsigned int,   pre_victim)
 581                 __field(unsigned int,   prefree)
 582                 __field(unsigned int,   free)
 583         ),
 584
 585         TP_fast_assign(
 586                 __entry->dev            = sb->s_dev;
 587                 __entry->type           = type;
 588                 __entry->gc_type        = gc_type;
 589                 __entry->alloc_mode     = p->alloc_mode;
 590                 __entry->gc_mode        = p->gc_mode;
 591                 __entry->victim         = p->min_segno;
 592                 __entry->cost           = p->min_cost;
 593                 __entry->ofs_unit       = p->ofs_unit;
 594                 __entry->pre_victim     = pre_victim;
 595                 __entry->prefree        = prefree;
 596                 __entry->free           = free;
 597         ),
 598
 599         TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), "
 600                 "victim = %u, cost = %u, ofs_unit = %u, "
 601                 "pre_victim_secno = %d, prefree = %u, free = %u",
 602                 show_dev(__entry->dev),
 603                 show_data_type(__entry->type),
 604                 show_gc_type(__entry->gc_type),
 605                 show_alloc_mode(__entry->alloc_mode),
 606                 show_victim_policy(__entry->gc_mode),
 607                 __entry->victim,
 608                 __entry->cost,
 609                 __entry->ofs_unit,
 610                 (int)__entry->pre_victim,
 611                 __entry->prefree,
 612                 __entry->free)
 613 );
 614
 615 TRACE_EVENT(f2fs_fallocate,
 616
 617         TP_PROTO(struct inode *inode, int mode,
 618                                 loff_t offset, loff_t len, int ret),
 619
 620         TP_ARGS(inode, mode, offset, len, ret),
 621
 622         TP_STRUCT__entry(
 623                 __field(dev_t,  dev)
 624                 __field(ino_t,  ino)
 625                 __field(int,    mode)
 626                 __field(loff_t, offset)
 627                 __field(loff_t, len)
 628                 __field(loff_t, size)
 629                 __field(blkcnt_t, blocks)
 630                 __field(int,    ret)
 631         ),
 632
 633         TP_fast_assign(
 634                 __entry->dev    = inode->i_sb->s_dev;
 635                 __entry->ino    = inode->i_ino;
 636                 __entry->mode   = mode;
 637                 __entry->offset = offset;
 638                 __entry->len    = len;
 639                 __entry->size   = inode->i_size;
 640                 __entry->blocks = inode->i_blocks;
 641                 __entry->ret    = ret;
 642         ),
 643
 644         TP_printk("dev = (%d,%d), ino = %lu, mode = %x, offset = %lld, "
 645                 "len = %lld,  i_size = %lld, i_blocks = %llu, ret = %d",
 646                 show_dev_ino(__entry),
 647                 __entry->mode,
 648                 (unsigned long long)__entry->offset,
 649                 (unsigned long long)__entry->len,
 650                 (unsigned long long)__entry->size,
 651                 (unsigned long long)__entry->blocks,
 652                 __entry->ret)
 653 );
 654
 655 TRACE_EVENT(f2fs_direct_IO_enter,
 656
 657         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len, int rw),
 658
 659         TP_ARGS(inode, offset, len, rw),
 660
 661         TP_STRUCT__entry(
 662                 __field(dev_t,  dev)
 663                 __field(ino_t,  ino)
 664                 __field(loff_t, pos)
 665                 __field(unsigned long,  len)
 666                 __field(int,    rw)
 667         ),
 668
 669         TP_fast_assign(
 670                 __entry->dev    = inode->i_sb->s_dev;
 671                 __entry->ino    = inode->i_ino;
 672                 __entry->pos    = offset;
 673                 __entry->len    = len;
 674                 __entry->rw     = rw;
 675         ),
 676
 677         TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu rw = %d",
 678                 show_dev_ino(__entry),
 679                 __entry->pos,
 680                 __entry->len,
 681                 __entry->rw)
 682 );
 683
 684 TRACE_EVENT(f2fs_direct_IO_exit,
 685
 686         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
 687                  int rw, int ret),
 688
 689         TP_ARGS(inode, offset, len, rw, ret),
 690
 691         TP_STRUCT__entry(
 692                 __field(dev_t,  dev)
 693                 __field(ino_t,  ino)
 694                 __field(loff_t, pos)
 695                 __field(unsigned long,  len)
 696                 __field(int,    rw)
 697                 __field(int,    ret)
 698         ),
 699
 700         TP_fast_assign(
 701                 __entry->dev    = inode->i_sb->s_dev;
 702                 __entry->ino    = inode->i_ino;
 703                 __entry->pos    = offset;
 704                 __entry->len    = len;
 705                 __entry->rw     = rw;
 706                 __entry->ret    = ret;
 707         ),
 708
 709         TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu "
 710                 "rw = %d ret = %d",
 711                 show_dev_ino(__entry),
 712                 __entry->pos,
 713                 __entry->len,
 714                 __entry->rw,
 715                 __entry->ret)
 716 );
 717
 718 TRACE_EVENT(f2fs_reserve_new_blocks,
 719
 720         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs_in_node,
 721                                                         blkcnt_t count),
 722
 723         TP_ARGS(inode, nid, ofs_in_node, count),
 724
 725         TP_STRUCT__entry(
 726                 __field(dev_t,  dev)
 727                 __field(nid_t, nid)
 728                 __field(unsigned int, ofs_in_node)
 729                 __field(blkcnt_t, count)
 730         ),
 731
 732         TP_fast_assign(
 733                 __entry->dev    = inode->i_sb->s_dev;
 734                 __entry->nid    = nid;
 735                 __entry->ofs_in_node = ofs_in_node;
 736                 __entry->count = count;
 737         ),
 738
 739         TP_printk("dev = (%d,%d), nid = %u, ofs_in_node = %u, count = %llu",
 740                 show_dev(__entry->dev),
 741                 (unsigned int)__entry->nid,
 742                 __entry->ofs_in_node,
 743                 (unsigned long long)__entry->count)
 744 );
 745
 746 DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
 747
 748         TP_PROTO(struct page *page, struct f2fs_io_info *fio),
 749
 750         TP_ARGS(page, fio),
 751
 752         TP_STRUCT__entry(
 753                 __field(dev_t, dev)
 754                 __field(ino_t, ino)
 755                 __field(pgoff_t, index)
 756                 __field(block_t, old_blkaddr)
 757                 __field(block_t, new_blkaddr)
 758                 __field(int, op)
 759                 __field(int, op_flags)
 760                 __field(int, type)
 761         ),
 762
 763         TP_fast_assign(
 764                 __entry->dev            = page->mapping->host->i_sb->s_dev;
 765                 __entry->ino            = page->mapping->host->i_ino;
 766                 __entry->index          = page->index;
 767                 __entry->old_blkaddr    = fio->old_blkaddr;
 768                 __entry->new_blkaddr    = fio->new_blkaddr;
 769                 __entry->op             = fio->op;
 770                 __entry->op_flags       = fio->op_flags;
 771                 __entry->type           = fio->type;
 772         ),
 773
 774         TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
 775                 "oldaddr = 0x%llx, newaddr = 0x%llx, rw = %s(%s), type = %s",
 776                 show_dev_ino(__entry),
 777                 (unsigned long)__entry->index,
 778                 (unsigned long long)__entry->old_blkaddr,
 779                 (unsigned long long)__entry->new_blkaddr,
 780                 show_bio_type(__entry->op, __entry->op_flags),
 781                 show_block_type(__entry->type))
 782 );
 783
 784 DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_bio,
 785
 786         TP_PROTO(struct page *page, struct f2fs_io_info *fio),
 787
 788         TP_ARGS(page, fio),
 789
 790         TP_CONDITION(page->mapping)
 791 );
 792
 793 DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_write,
 794
 795         TP_PROTO(struct page *page, struct f2fs_io_info *fio),
 796
 797         TP_ARGS(page, fio),
 798
 799         TP_CONDITION(page->mapping)
 800 );
 801
 802 DECLARE_EVENT_CLASS(f2fs__bio,
 803
 804         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
 805
 806         TP_ARGS(sb, type, bio),
 807
 808         TP_STRUCT__entry(
 809                 __field(dev_t,  dev)
 810                 __field(dev_t,  target)
 811                 __field(int,    op)
 812                 __field(int,    op_flags)
 813                 __field(int,    type)
 814                 __field(sector_t,       sector)
 815                 __field(unsigned int,   size)
 816         ),
 817
 818         TP_fast_assign(
 819                 __entry->dev            = sb->s_dev;
 820                 __entry->target         = bio->bi_bdev->bd_dev;
 821                 __entry->op             = bio_op(bio);
 822                 __entry->op_flags       = bio->bi_opf;
 823                 __entry->type           = type;
 824                 __entry->sector         = bio->bi_iter.bi_sector;
 825                 __entry->size           = bio->bi_iter.bi_size;
 826         ),
 827
 828         TP_printk("dev = (%d,%d)/(%d,%d), rw = %s(%s), %s, sector = %lld, size = %u",
 829                 show_dev(__entry->target),
 830                 show_dev(__entry->dev),
 831                 show_bio_type(__entry->op, __entry->op_flags),
 832                 show_block_type(__entry->type),
 833                 (unsigned long long)__entry->sector,
 834                 __entry->size)
 835 );
 836
 837 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_write_bio,
 838
 839         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
 840
 841         TP_ARGS(sb, type, bio),
 842
 843         TP_CONDITION(bio)
 844 );
 845
 846 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_read_bio,
 847
 848         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
 849
 850         TP_ARGS(sb, type, bio),
 851
 852         TP_CONDITION(bio)
 853 );
 854
 855 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_read_bio,
 856
 857         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
 858
 859         TP_ARGS(sb, type, bio),
 860
 861         TP_CONDITION(bio)
 862 );
 863
 864 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_write_bio,
 865
 866         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
 867
 868         TP_ARGS(sb, type, bio),
 869
 870         TP_CONDITION(bio)
 871 );
 872
 873 TRACE_EVENT(f2fs_write_begin,
 874
 875         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 876                                 unsigned int flags),
 877
 878         TP_ARGS(inode, pos, len, flags),
 879
 880         TP_STRUCT__entry(
 881                 __field(dev_t,  dev)
 882                 __field(ino_t,  ino)
 883                 __field(loff_t, pos)
 884                 __field(unsigned int, len)
 885                 __field(unsigned int, flags)
 886         ),
 887
 888         TP_fast_assign(
 889                 __entry->dev    = inode->i_sb->s_dev;
 890                 __entry->ino    = inode->i_ino;
 891                 __entry->pos    = pos;
 892                 __entry->len    = len;
 893                 __entry->flags  = flags;
 894         ),
 895
 896         TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, flags = %u",
 897                 show_dev_ino(__entry),
 898                 (unsigned long long)__entry->pos,
 899                 __entry->len,
 900                 __entry->flags)
 901 );
 902
 903 TRACE_EVENT(f2fs_write_end,
 904
 905         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 906                                 unsigned int copied),
 907
 908         TP_ARGS(inode, pos, len, copied),
 909
 910         TP_STRUCT__entry(
 911                 __field(dev_t,  dev)
 912                 __field(ino_t,  ino)
 913                 __field(loff_t, pos)
 914                 __field(unsigned int, len)
 915                 __field(unsigned int, copied)
 916         ),
 917
 918         TP_fast_assign(
 919                 __entry->dev    = inode->i_sb->s_dev;
 920                 __entry->ino    = inode->i_ino;
 921                 __entry->pos    = pos;
 922                 __entry->len    = len;
 923                 __entry->copied = copied;
 924         ),
 925
 926         TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, copied = %u",
 927                 show_dev_ino(__entry),
 928                 (unsigned long long)__entry->pos,
 929                 __entry->len,
 930                 __entry->copied)
 931 );
 932
 933 DECLARE_EVENT_CLASS(f2fs__page,
 934
 935         TP_PROTO(struct page *page, int type),
 936
 937         TP_ARGS(page, type),
 938
 939         TP_STRUCT__entry(
 940                 __field(dev_t,  dev)
 941                 __field(ino_t,  ino)
 942                 __field(int, type)
 943                 __field(int, dir)
 944                 __field(pgoff_t, index)
 945                 __field(int, dirty)
 946                 __field(int, uptodate)
 947         ),
 948
 949         TP_fast_assign(
 950                 __entry->dev    = page->mapping->host->i_sb->s_dev;
 951                 __entry->ino    = page->mapping->host->i_ino;
 952                 __entry->type   = type;
 953                 __entry->dir    = S_ISDIR(page->mapping->host->i_mode);
 954                 __entry->index  = page->index;
 955                 __entry->dirty  = PageDirty(page);
 956                 __entry->uptodate = PageUptodate(page);
 957         ),
 958
 959         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, index = %lu, "
 960                 "dirty = %d, uptodate = %d",
 961                 show_dev_ino(__entry),
 962                 show_block_type(__entry->type),
 963                 show_file_type(__entry->dir),
 964                 (unsigned long)__entry->index,
 965                 __entry->dirty,
 966                 __entry->uptodate)
 967 );
 968
 969 DEFINE_EVENT(f2fs__page, f2fs_writepage,
 970
 971         TP_PROTO(struct page *page, int type),
 972
 973         TP_ARGS(page, type)
 974 );
 975
 976 DEFINE_EVENT(f2fs__page, f2fs_do_write_data_page,
 977
 978         TP_PROTO(struct page *page, int type),
 979
 980         TP_ARGS(page, type)
 981 );
 982
 983 DEFINE_EVENT(f2fs__page, f2fs_readpage,
 984
 985         TP_PROTO(struct page *page, int type),
 986
 987         TP_ARGS(page, type)
 988 );
 989
 990 DEFINE_EVENT(f2fs__page, f2fs_set_page_dirty,
 991
 992         TP_PROTO(struct page *page, int type),
 993
 994         TP_ARGS(page, type)
 995 );
 996
 997 DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite,
 998
 999         TP_PROTO(struct page *page, int type),
1000
1001         TP_ARGS(page, type)
1002 );
1003
1004 DEFINE_EVENT(f2fs__page, f2fs_register_inmem_page,
1005
1006         TP_PROTO(struct page *page, int type),
1007
1008         TP_ARGS(page, type)
1009 );
1010
1011 DEFINE_EVENT(f2fs__page, f2fs_commit_inmem_page,
1012
1013         TP_PROTO(struct page *page, int type),
1014
1015         TP_ARGS(page, type)
1016 );
1017
1018 TRACE_EVENT(f2fs_writepages,
1019
1020         TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type),
1021
1022         TP_ARGS(inode, wbc, type),
1023
1024         TP_STRUCT__entry(
1025                 __field(dev_t,  dev)
1026                 __field(ino_t,  ino)
1027                 __field(int,    type)
1028                 __field(int,    dir)
1029                 __field(long,   nr_to_write)
1030                 __field(long,   pages_skipped)
1031                 __field(loff_t, range_start)
1032                 __field(loff_t, range_end)
1033                 __field(pgoff_t, writeback_index)
1034                 __field(int,    sync_mode)
1035                 __field(char,   for_kupdate)
1036                 __field(char,   for_background)
1037                 __field(char,   tagged_writepages)
1038                 __field(char,   for_reclaim)
1039                 __field(char,   range_cyclic)
1040                 __field(char,   for_sync)
1041         ),
1042
1043         TP_fast_assign(
1044                 __entry->dev            = inode->i_sb->s_dev;
1045                 __entry->ino            = inode->i_ino;
1046                 __entry->type           = type;
1047                 __entry->dir            = S_ISDIR(inode->i_mode);
1048                 __entry->nr_to_write    = wbc->nr_to_write;
1049                 __entry->pages_skipped  = wbc->pages_skipped;
1050                 __entry->range_start    = wbc->range_start;
1051                 __entry->range_end      = wbc->range_end;
1052                 __entry->writeback_index = inode->i_mapping->writeback_index;
1053                 __entry->sync_mode      = wbc->sync_mode;
1054                 __entry->for_kupdate    = wbc->for_kupdate;
1055                 __entry->for_background = wbc->for_background;
1056                 __entry->tagged_writepages      = wbc->tagged_writepages;
1057                 __entry->for_reclaim    = wbc->for_reclaim;
1058                 __entry->range_cyclic   = wbc->range_cyclic;
1059                 __entry->for_sync       = wbc->for_sync;
1060         ),
1061
1062         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, nr_to_write %ld, "
1063                 "skipped %ld, start %lld, end %lld, wb_idx %lu, sync_mode %d, "
1064                 "kupdate %u background %u tagged %u reclaim %u cyclic %u sync %u",
1065                 show_dev_ino(__entry),
1066                 show_block_type(__entry->type),
1067                 show_file_type(__entry->dir),
1068                 __entry->nr_to_write,
1069                 __entry->pages_skipped,
1070                 __entry->range_start,
1071                 __entry->range_end,
1072                 (unsigned long)__entry->writeback_index,
1073                 __entry->sync_mode,
1074                 __entry->for_kupdate,
1075                 __entry->for_background,
1076                 __entry->tagged_writepages,
1077                 __entry->for_reclaim,
1078                 __entry->range_cyclic,
1079                 __entry->for_sync)
1080 );
1081
1082 TRACE_EVENT(f2fs_readpages,
1083
1084         TP_PROTO(struct inode *inode, struct page *page, unsigned int nrpage),
1085
1086         TP_ARGS(inode, page, nrpage),
1087
1088         TP_STRUCT__entry(
1089                 __field(dev_t,  dev)
1090                 __field(ino_t,  ino)
1091                 __field(pgoff_t,        start)
1092                 __field(unsigned int,   nrpage)
1093         ),
1094
1095         TP_fast_assign(
1096                 __entry->dev    = inode->i_sb->s_dev;
1097                 __entry->ino    = inode->i_ino;
1098                 __entry->start  = page->index;
1099                 __entry->nrpage = nrpage;
1100         ),
1101
1102         TP_printk("dev = (%d,%d), ino = %lu, start = %lu nrpage = %u",
1103                 show_dev_ino(__entry),
1104                 (unsigned long)__entry->start,
1105                 __entry->nrpage)
1106 );
1107
1108 TRACE_EVENT(f2fs_write_checkpoint,
1109
1110         TP_PROTO(struct super_block *sb, int reason, char *msg),
1111
1112         TP_ARGS(sb, reason, msg),
1113
1114         TP_STRUCT__entry(
1115                 __field(dev_t,  dev)
1116                 __field(int,    reason)
1117                 __field(char *, msg)
1118         ),
1119
1120         TP_fast_assign(
1121                 __entry->dev            = sb->s_dev;
1122                 __entry->reason         = reason;
1123                 __entry->msg            = msg;
1124         ),
1125
1126         TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
1127                 show_dev(__entry->dev),
1128                 show_cpreason(__entry->reason),
1129                 __entry->msg)
1130 );
1131
1132 DECLARE_EVENT_CLASS(f2fs_discard,
1133
1134         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1135
1136         TP_ARGS(dev, blkstart, blklen),
1137
1138         TP_STRUCT__entry(
1139                 __field(dev_t,  dev)
1140                 __field(block_t, blkstart)
1141                 __field(block_t, blklen)
1142         ),
1143
1144         TP_fast_assign(
1145                 __entry->dev    = dev->bd_dev;
1146                 __entry->blkstart = blkstart;
1147                 __entry->blklen = blklen;
1148         ),
1149
1150         TP_printk("dev = (%d,%d), blkstart = 0x%llx, blklen = 0x%llx",
1151                 show_dev(__entry->dev),
1152                 (unsigned long long)__entry->blkstart,
1153                 (unsigned long long)__entry->blklen)
1154 );
1155
1156 DEFINE_EVENT(f2fs_discard, f2fs_queue_discard,
1157
1158         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1159
1160         TP_ARGS(dev, blkstart, blklen)
1161 );
1162
1163 DEFINE_EVENT(f2fs_discard, f2fs_issue_discard,
1164
1165         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1166
1167         TP_ARGS(dev, blkstart, blklen)
1168 );
1169
1170 TRACE_EVENT(f2fs_issue_reset_zone,
1171
1172         TP_PROTO(struct block_device *dev, block_t blkstart),
1173
1174         TP_ARGS(dev, blkstart),
1175
1176         TP_STRUCT__entry(
1177                 __field(dev_t,  dev)
1178                 __field(block_t, blkstart)
1179         ),
1180
1181         TP_fast_assign(
1182                 __entry->dev    = dev->bd_dev;
1183                 __entry->blkstart = blkstart;
1184         ),
1185
1186         TP_printk("dev = (%d,%d), reset zone at block = 0x%llx",
1187                 show_dev(__entry->dev),
1188                 (unsigned long long)__entry->blkstart)
1189 );
1190
1191 TRACE_EVENT(f2fs_issue_flush,
1192
1193         TP_PROTO(struct block_device *dev, unsigned int nobarrier,
1194                                 unsigned int flush_merge, int ret),
1195
1196         TP_ARGS(dev, nobarrier, flush_merge, ret),
1197
1198         TP_STRUCT__entry(
1199                 __field(dev_t,  dev)
1200                 __field(unsigned int, nobarrier)
1201                 __field(unsigned int, flush_merge)
1202                 __field(int,  ret)
1203         ),
1204
1205         TP_fast_assign(
1206                 __entry->dev    = dev->bd_dev;
1207                 __entry->nobarrier = nobarrier;
1208                 __entry->flush_merge = flush_merge;
1209                 __entry->ret = ret;
1210         ),
1211
1212         TP_printk("dev = (%d,%d), %s %s, ret = %d",
1213                 show_dev(__entry->dev),
1214                 __entry->nobarrier ? "skip (nobarrier)" : "issue",
1215                 __entry->flush_merge ? " with flush_merge" : "",
1216                 __entry->ret)
1217 );
1218
1219 TRACE_EVENT(f2fs_lookup_extent_tree_start,
1220
1221         TP_PROTO(struct inode *inode, unsigned int pgofs),
1222
1223         TP_ARGS(inode, pgofs),
1224
1225         TP_STRUCT__entry(
1226                 __field(dev_t,  dev)
1227                 __field(ino_t,  ino)
1228                 __field(unsigned int, pgofs)
1229         ),
1230
1231         TP_fast_assign(
1232                 __entry->dev = inode->i_sb->s_dev;
1233                 __entry->ino = inode->i_ino;
1234                 __entry->pgofs = pgofs;
1235         ),
1236
1237         TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u",
1238                 show_dev_ino(__entry),
1239                 __entry->pgofs)
1240 );
1241
1242 TRACE_EVENT_CONDITION(f2fs_lookup_extent_tree_end,
1243
1244         TP_PROTO(struct inode *inode, unsigned int pgofs,
1245                                                 struct extent_info *ei),
1246
1247         TP_ARGS(inode, pgofs, ei),
1248
1249         TP_CONDITION(ei),
1250
1251         TP_STRUCT__entry(
1252                 __field(dev_t,  dev)
1253                 __field(ino_t,  ino)
1254                 __field(unsigned int, pgofs)
1255                 __field(unsigned int, fofs)
1256                 __field(u32, blk)
1257                 __field(unsigned int, len)
1258         ),
1259
1260         TP_fast_assign(
1261                 __entry->dev = inode->i_sb->s_dev;
1262                 __entry->ino = inode->i_ino;
1263                 __entry->pgofs = pgofs;
1264                 __entry->fofs = ei->fofs;
1265                 __entry->blk = ei->blk;
1266                 __entry->len = ei->len;
1267         ),
1268
1269         TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1270                 "ext_info(fofs: %u, blk: %u, len: %u)",
1271                 show_dev_ino(__entry),
1272                 __entry->pgofs,
1273                 __entry->fofs,
1274                 __entry->blk,
1275                 __entry->len)
1276 );
1277
1278 TRACE_EVENT(f2fs_update_extent_tree_range,
1279
1280         TP_PROTO(struct inode *inode, unsigned int pgofs, block_t blkaddr,
1281                                                 unsigned int len),
1282
1283         TP_ARGS(inode, pgofs, blkaddr, len),
1284
1285         TP_STRUCT__entry(
1286                 __field(dev_t,  dev)
1287                 __field(ino_t,  ino)
1288                 __field(unsigned int, pgofs)
1289                 __field(u32, blk)
1290                 __field(unsigned int, len)
1291         ),
1292
1293         TP_fast_assign(
1294                 __entry->dev = inode->i_sb->s_dev;
1295                 __entry->ino = inode->i_ino;
1296                 __entry->pgofs = pgofs;
1297                 __entry->blk = blkaddr;
1298                 __entry->len = len;
1299         ),
1300
1301         TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1302                                         "blkaddr = %u, len = %u",
1303                 show_dev_ino(__entry),
1304                 __entry->pgofs,
1305                 __entry->blk,
1306                 __entry->len)
1307 );
1308
1309 TRACE_EVENT(f2fs_shrink_extent_tree,
1310
1311         TP_PROTO(struct f2fs_sb_info *sbi, unsigned int node_cnt,
1312                                                 unsigned int tree_cnt),
1313
1314         TP_ARGS(sbi, node_cnt, tree_cnt),
1315
1316         TP_STRUCT__entry(
1317                 __field(dev_t,  dev)
1318                 __field(unsigned int, node_cnt)
1319                 __field(unsigned int, tree_cnt)
1320         ),
1321
1322         TP_fast_assign(
1323                 __entry->dev = sbi->sb->s_dev;
1324                 __entry->node_cnt = node_cnt;
1325                 __entry->tree_cnt = tree_cnt;
1326         ),
1327
1328         TP_printk("dev = (%d,%d), shrunk: node_cnt = %u, tree_cnt = %u",
1329                 show_dev(__entry->dev),
1330                 __entry->node_cnt,
1331                 __entry->tree_cnt)
1332 );
1333
1334 TRACE_EVENT(f2fs_destroy_extent_tree,
1335
1336         TP_PROTO(struct inode *inode, unsigned int node_cnt),
1337
1338         TP_ARGS(inode, node_cnt),
1339
1340         TP_STRUCT__entry(
1341                 __field(dev_t,  dev)
1342                 __field(ino_t,  ino)
1343                 __field(unsigned int, node_cnt)
1344         ),
1345
1346         TP_fast_assign(
1347                 __entry->dev = inode->i_sb->s_dev;
1348                 __entry->ino = inode->i_ino;
1349                 __entry->node_cnt = node_cnt;
1350         ),
1351
1352         TP_printk("dev = (%d,%d), ino = %lu, destroyed: node_cnt = %u",
1353                 show_dev_ino(__entry),
1354                 __entry->node_cnt)
1355 );
1356
1357 DECLARE_EVENT_CLASS(f2fs_sync_dirty_inodes,
1358
1359         TP_PROTO(struct super_block *sb, int type, s64 count),
1360
1361         TP_ARGS(sb, type, count),
1362
1363         TP_STRUCT__entry(
1364                 __field(dev_t, dev)
1365                 __field(int, type)
1366                 __field(s64, count)
1367         ),
1368
1369         TP_fast_assign(
1370                 __entry->dev    = sb->s_dev;
1371                 __entry->type   = type;
1372                 __entry->count  = count;
1373         ),
1374
1375         TP_printk("dev = (%d,%d), %s, dirty count = %lld",
1376                 show_dev(__entry->dev),
1377                 show_file_type(__entry->type),
1378                 __entry->count)
1379 );
1380
1381 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_enter,
1382
1383         TP_PROTO(struct super_block *sb, int type, s64 count),
1384
1385         TP_ARGS(sb, type, count)
1386 );
1387
1388 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_exit,
1389
1390         TP_PROTO(struct super_block *sb, int type, s64 count),
1391
1392         TP_ARGS(sb, type, count)
1393 );
1394
1395 #endif /* _TRACE_F2FS_H */
1396
1397  /* This part must be outside protection */
1398 #include <trace/define_trace.h>