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