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