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