include/trace/events/f2fs.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM f2fs
   4
   5 #if !defined(_TRACE_F2FS_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_F2FS_H
   7
   8 #include <linux/tracepoint.h>
   9 #include <uapi/linux/f2fs.h>
  10
  11 #define show_dev(dev)           MAJOR(dev), MINOR(dev)
  12 #define show_dev_ino(entry)     show_dev(entry->dev), (unsigned long)entry->ino
  13
  14 TRACE_DEFINE_ENUM(NODE);
  15 TRACE_DEFINE_ENUM(DATA);
  16 TRACE_DEFINE_ENUM(META);
  17 TRACE_DEFINE_ENUM(META_FLUSH);
  18 TRACE_DEFINE_ENUM(INMEM);
  19 TRACE_DEFINE_ENUM(INMEM_DROP);
  20 TRACE_DEFINE_ENUM(INMEM_INVALIDATE);
  21 TRACE_DEFINE_ENUM(INMEM_REVOKE);
  22 TRACE_DEFINE_ENUM(IPU);
  23 TRACE_DEFINE_ENUM(OPU);
  24 TRACE_DEFINE_ENUM(HOT);
  25 TRACE_DEFINE_ENUM(WARM);
  26 TRACE_DEFINE_ENUM(COLD);
  27 TRACE_DEFINE_ENUM(CURSEG_HOT_DATA);
  28 TRACE_DEFINE_ENUM(CURSEG_WARM_DATA);
  29 TRACE_DEFINE_ENUM(CURSEG_COLD_DATA);
  30 TRACE_DEFINE_ENUM(CURSEG_HOT_NODE);
  31 TRACE_DEFINE_ENUM(CURSEG_WARM_NODE);
  32 TRACE_DEFINE_ENUM(CURSEG_COLD_NODE);
  33 TRACE_DEFINE_ENUM(NO_CHECK_TYPE);
  34 TRACE_DEFINE_ENUM(GC_GREEDY);
  35 TRACE_DEFINE_ENUM(GC_CB);
  36 TRACE_DEFINE_ENUM(FG_GC);
  37 TRACE_DEFINE_ENUM(BG_GC);
  38 TRACE_DEFINE_ENUM(LFS);
  39 TRACE_DEFINE_ENUM(SSR);
  40 TRACE_DEFINE_ENUM(__REQ_RAHEAD);
  41 TRACE_DEFINE_ENUM(__REQ_SYNC);
  42 TRACE_DEFINE_ENUM(__REQ_IDLE);
  43 TRACE_DEFINE_ENUM(__REQ_PREFLUSH);
  44 TRACE_DEFINE_ENUM(__REQ_FUA);
  45 TRACE_DEFINE_ENUM(__REQ_PRIO);
  46 TRACE_DEFINE_ENUM(__REQ_META);
  47 TRACE_DEFINE_ENUM(CP_UMOUNT);
  48 TRACE_DEFINE_ENUM(CP_FASTBOOT);
  49 TRACE_DEFINE_ENUM(CP_SYNC);
  50 TRACE_DEFINE_ENUM(CP_RECOVERY);
  51 TRACE_DEFINE_ENUM(CP_DISCARD);
  52 TRACE_DEFINE_ENUM(CP_TRIMMED);
  53 TRACE_DEFINE_ENUM(CP_PAUSE);
  54 TRACE_DEFINE_ENUM(CP_RESIZE);
  55
  56 #define show_block_type(type)                                           \
  57         __print_symbolic(type,                                          \
  58                 { NODE,         "NODE" },                               \
  59                 { DATA,         "DATA" },                               \
  60                 { META,         "META" },                               \
  61                 { META_FLUSH,   "META_FLUSH" },                         \
  62                 { INMEM,        "INMEM" },                              \
  63                 { INMEM_DROP,   "INMEM_DROP" },                         \
  64                 { INMEM_INVALIDATE,     "INMEM_INVALIDATE" },           \
  65                 { INMEM_REVOKE, "INMEM_REVOKE" },                       \
  66                 { IPU,          "IN-PLACE" },                           \
  67                 { OPU,          "OUT-OF-PLACE" })
  68
  69 #define show_block_temp(temp)                                           \
  70         __print_symbolic(temp,                                          \
  71                 { HOT,          "HOT" },                                \
  72                 { WARM,         "WARM" },                               \
  73                 { COLD,         "COLD" })
  74
  75 #define F2FS_OP_FLAGS (REQ_RAHEAD | REQ_SYNC | REQ_META | REQ_PRIO |    \
  76                         REQ_PREFLUSH | REQ_FUA)
  77 #define F2FS_BIO_FLAG_MASK(t)   (t & F2FS_OP_FLAGS)
  78
  79 #define show_bio_type(op,op_flags)      show_bio_op(op),                \
  80                                                 show_bio_op_flags(op_flags)
  81
  82 #define show_bio_op(op)         blk_op_str(op)
  83
  84 #define show_bio_op_flags(flags)                                        \
  85         __print_flags(F2FS_BIO_FLAG_MASK(flags), "|",                   \
  86                 { REQ_RAHEAD,           "R" },                          \
  87                 { REQ_SYNC,             "S" },                          \
  88                 { REQ_META,             "M" },                          \
  89                 { REQ_PRIO,             "P" },                          \
  90                 { REQ_PREFLUSH,         "PF" },                         \
  91                 { REQ_FUA,              "FUA" })
  92
  93 #define show_data_type(type)                                            \
  94         __print_symbolic(type,                                          \
  95                 { CURSEG_HOT_DATA,      "Hot DATA" },                   \
  96                 { CURSEG_WARM_DATA,     "Warm DATA" },                  \
  97                 { CURSEG_COLD_DATA,     "Cold DATA" },                  \
  98                 { CURSEG_HOT_NODE,      "Hot NODE" },                   \
  99                 { CURSEG_WARM_NODE,     "Warm NODE" },                  \
 100                 { CURSEG_COLD_NODE,     "Cold NODE" },                  \
 101                 { NO_CHECK_TYPE,        "No TYPE" })
 102
 103 #define show_file_type(type)                                            \
 104         __print_symbolic(type,                                          \
 105                 { 0,            "FILE" },                               \
 106                 { 1,            "DIR" })
 107
 108 #define show_gc_type(type)                                              \
 109         __print_symbolic(type,                                          \
 110                 { FG_GC,        "Foreground GC" },                      \
 111                 { BG_GC,        "Background GC" })
 112
 113 #define show_alloc_mode(type)                                           \
 114         __print_symbolic(type,                                          \
 115                 { LFS,          "LFS-mode" },                           \
 116                 { SSR,          "SSR-mode" },                           \
 117                 { AT_SSR,       "AT_SSR-mode" })
 118
 119 #define show_victim_policy(type)                                        \
 120         __print_symbolic(type,                                          \
 121                 { GC_GREEDY,    "Greedy" },                             \
 122                 { GC_CB,        "Cost-Benefit" },                       \
 123                 { GC_AT,        "Age-threshold" })
 124
 125 #define show_cpreason(type)                                             \
 126         __print_flags(type, "|",                                        \
 127                 { CP_UMOUNT,    "Umount" },                             \
 128                 { CP_FASTBOOT,  "Fastboot" },                           \
 129                 { CP_SYNC,      "Sync" },                               \
 130                 { CP_RECOVERY,  "Recovery" },                           \
 131                 { CP_DISCARD,   "Discard" },                            \
 132                 { CP_PAUSE,     "Pause" },                              \
 133                 { CP_TRIMMED,   "Trimmed" },                            \
 134                 { CP_RESIZE,    "Resize" })
 135
 136 #define show_fsync_cpreason(type)                                       \
 137         __print_symbolic(type,                                          \
 138                 { CP_NO_NEEDED,         "no needed" },                  \
 139                 { CP_NON_REGULAR,       "non regular" },                \
 140                 { CP_COMPRESSED,        "compressed" },                 \
 141                 { CP_HARDLINK,          "hardlink" },                   \
 142                 { CP_SB_NEED_CP,        "sb needs cp" },                \
 143                 { CP_WRONG_PINO,        "wrong pino" },                 \
 144                 { CP_NO_SPC_ROLL,       "no space roll forward" },      \
 145                 { CP_NODE_NEED_CP,      "node needs cp" },              \
 146                 { CP_FASTBOOT_MODE,     "fastboot mode" },              \
 147                 { CP_SPEC_LOG_NUM,      "log type is 2" },              \
 148                 { CP_RECOVER_DIR,       "dir needs recovery" })
 149
 150 #define show_shutdown_mode(type)                                        \
 151         __print_symbolic(type,                                          \
 152                 { F2FS_GOING_DOWN_FULLSYNC,     "full sync" },          \
 153                 { F2FS_GOING_DOWN_METASYNC,     "meta sync" },          \
 154                 { F2FS_GOING_DOWN_NOSYNC,       "no sync" },            \
 155                 { F2FS_GOING_DOWN_METAFLUSH,    "meta flush" },         \
 156                 { F2FS_GOING_DOWN_NEED_FSCK,    "need fsck" })
 157
 158 #define show_compress_algorithm(type)                                   \
 159         __print_symbolic(type,                                          \
 160                 { COMPRESS_LZO,         "LZO" },                        \
 161                 { COMPRESS_LZ4,         "LZ4" },                        \
 162                 { COMPRESS_ZSTD,        "ZSTD" },                       \
 163                 { COMPRESS_LZORLE,      "LZO-RLE" })
 164
 165 struct f2fs_sb_info;
 166 struct f2fs_io_info;
 167 struct extent_info;
 168 struct victim_sel_policy;
 169 struct f2fs_map_blocks;
 170
 171 DECLARE_EVENT_CLASS(f2fs__inode,
 172
 173         TP_PROTO(struct inode *inode),
 174
 175         TP_ARGS(inode),
 176
 177         TP_STRUCT__entry(
 178                 __field(dev_t,  dev)
 179                 __field(ino_t,  ino)
 180                 __field(ino_t,  pino)
 181                 __field(umode_t, mode)
 182                 __field(loff_t, size)
 183                 __field(unsigned int, nlink)
 184                 __field(blkcnt_t, blocks)
 185                 __field(__u8,   advise)
 186         ),
 187
 188         TP_fast_assign(
 189                 __entry->dev    = inode->i_sb->s_dev;
 190                 __entry->ino    = inode->i_ino;
 191                 __entry->pino   = F2FS_I(inode)->i_pino;
 192                 __entry->mode   = inode->i_mode;
 193                 __entry->nlink  = inode->i_nlink;
 194                 __entry->size   = inode->i_size;
 195                 __entry->blocks = inode->i_blocks;
 196                 __entry->advise = F2FS_I(inode)->i_advise;
 197         ),
 198
 199         TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
 200                 "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
 201                 show_dev_ino(__entry),
 202                 (unsigned long)__entry->pino,
 203                 __entry->mode,
 204                 __entry->size,
 205                 (unsigned int)__entry->nlink,
 206                 (unsigned long long)__entry->blocks,
 207                 (unsigned char)__entry->advise)
 208 );
 209
 210 DECLARE_EVENT_CLASS(f2fs__inode_exit,
 211
 212         TP_PROTO(struct inode *inode, int ret),
 213
 214         TP_ARGS(inode, ret),
 215
 216         TP_STRUCT__entry(
 217                 __field(dev_t,  dev)
 218                 __field(ino_t,  ino)
 219                 __field(int,    ret)
 220         ),
 221
 222         TP_fast_assign(
 223                 __entry->dev    = inode->i_sb->s_dev;
 224                 __entry->ino    = inode->i_ino;
 225                 __entry->ret    = ret;
 226         ),
 227
 228         TP_printk("dev = (%d,%d), ino = %lu, ret = %d",
 229                 show_dev_ino(__entry),
 230                 __entry->ret)
 231 );
 232
 233 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter,
 234
 235         TP_PROTO(struct inode *inode),
 236
 237         TP_ARGS(inode)
 238 );
 239
 240 TRACE_EVENT(f2fs_sync_file_exit,
 241
 242         TP_PROTO(struct inode *inode, int cp_reason, int datasync, int ret),
 243
 244         TP_ARGS(inode, cp_reason, datasync, ret),
 245
 246         TP_STRUCT__entry(
 247                 __field(dev_t,  dev)
 248                 __field(ino_t,  ino)
 249                 __field(int,    cp_reason)
 250                 __field(int,    datasync)
 251                 __field(int,    ret)
 252         ),
 253
 254         TP_fast_assign(
 255                 __entry->dev            = inode->i_sb->s_dev;
 256                 __entry->ino            = inode->i_ino;
 257                 __entry->cp_reason      = cp_reason;
 258                 __entry->datasync       = datasync;
 259                 __entry->ret            = ret;
 260         ),
 261
 262         TP_printk("dev = (%d,%d), ino = %lu, cp_reason: %s, "
 263                 "datasync = %d, ret = %d",
 264                 show_dev_ino(__entry),
 265                 show_fsync_cpreason(__entry->cp_reason),
 266                 __entry->datasync,
 267                 __entry->ret)
 268 );
 269
 270 TRACE_EVENT(f2fs_sync_fs,
 271
 272         TP_PROTO(struct super_block *sb, int wait),
 273
 274         TP_ARGS(sb, wait),
 275
 276         TP_STRUCT__entry(
 277                 __field(dev_t,  dev)
 278                 __field(int,    dirty)
 279                 __field(int,    wait)
 280         ),
 281
 282         TP_fast_assign(
 283                 __entry->dev    = sb->s_dev;
 284                 __entry->dirty  = is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY);
 285                 __entry->wait   = wait;
 286         ),
 287
 288         TP_printk("dev = (%d,%d), superblock is %s, wait = %d",
 289                 show_dev(__entry->dev),
 290                 __entry->dirty ? "dirty" : "not dirty",
 291                 __entry->wait)
 292 );
 293
 294 DEFINE_EVENT(f2fs__inode, f2fs_iget,
 295
 296         TP_PROTO(struct inode *inode),
 297
 298         TP_ARGS(inode)
 299 );
 300
 301 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit,
 302
 303         TP_PROTO(struct inode *inode, int ret),
 304
 305         TP_ARGS(inode, ret)
 306 );
 307
 308 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode,
 309
 310         TP_PROTO(struct inode *inode),
 311
 312         TP_ARGS(inode)
 313 );
 314
 315 DEFINE_EVENT(f2fs__inode_exit, f2fs_new_inode,
 316
 317         TP_PROTO(struct inode *inode, int ret),
 318
 319         TP_ARGS(inode, ret)
 320 );
 321
 322 TRACE_EVENT(f2fs_unlink_enter,
 323
 324         TP_PROTO(struct inode *dir, struct dentry *dentry),
 325
 326         TP_ARGS(dir, dentry),
 327
 328         TP_STRUCT__entry(
 329                 __field(dev_t,  dev)
 330                 __field(ino_t,  ino)
 331                 __field(loff_t, size)
 332                 __field(blkcnt_t, blocks)
 333                 __field(const char *,   name)
 334         ),
 335
 336         TP_fast_assign(
 337                 __entry->dev    = dir->i_sb->s_dev;
 338                 __entry->ino    = dir->i_ino;
 339                 __entry->size   = dir->i_size;
 340                 __entry->blocks = dir->i_blocks;
 341                 __entry->name   = dentry->d_name.name;
 342         ),
 343
 344         TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
 345                 "i_blocks = %llu, name = %s",
 346                 show_dev_ino(__entry),
 347                 __entry->size,
 348                 (unsigned long long)__entry->blocks,
 349                 __entry->name)
 350 );
 351
 352 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit,
 353
 354         TP_PROTO(struct inode *inode, int ret),
 355
 356         TP_ARGS(inode, ret)
 357 );
 358
 359 DEFINE_EVENT(f2fs__inode_exit, f2fs_drop_inode,
 360
 361         TP_PROTO(struct inode *inode, int ret),
 362
 363         TP_ARGS(inode, ret)
 364 );
 365
 366 DEFINE_EVENT(f2fs__inode, f2fs_truncate,
 367
 368         TP_PROTO(struct inode *inode),
 369
 370         TP_ARGS(inode)
 371 );
 372
 373 TRACE_EVENT(f2fs_truncate_data_blocks_range,
 374
 375         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free),
 376
 377         TP_ARGS(inode, nid,  ofs, free),
 378
 379         TP_STRUCT__entry(
 380                 __field(dev_t,  dev)
 381                 __field(ino_t,  ino)
 382                 __field(nid_t,  nid)
 383                 __field(unsigned int,   ofs)
 384                 __field(int,    free)
 385         ),
 386
 387         TP_fast_assign(
 388                 __entry->dev    = inode->i_sb->s_dev;
 389                 __entry->ino    = inode->i_ino;
 390                 __entry->nid    = nid;
 391                 __entry->ofs    = ofs;
 392                 __entry->free   = free;
 393         ),
 394
 395         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
 396                 show_dev_ino(__entry),
 397                 (unsigned int)__entry->nid,
 398                 __entry->ofs,
 399                 __entry->free)
 400 );
 401
 402 DECLARE_EVENT_CLASS(f2fs__truncate_op,
 403
 404         TP_PROTO(struct inode *inode, u64 from),
 405
 406         TP_ARGS(inode, from),
 407
 408         TP_STRUCT__entry(
 409                 __field(dev_t,  dev)
 410                 __field(ino_t,  ino)
 411                 __field(loff_t, size)
 412                 __field(blkcnt_t, blocks)
 413                 __field(u64,    from)
 414         ),
 415
 416         TP_fast_assign(
 417                 __entry->dev    = inode->i_sb->s_dev;
 418                 __entry->ino    = inode->i_ino;
 419                 __entry->size   = inode->i_size;
 420                 __entry->blocks = inode->i_blocks;
 421                 __entry->from   = from;
 422         ),
 423
 424         TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
 425                 "start file offset = %llu",
 426                 show_dev_ino(__entry),
 427                 __entry->size,
 428                 (unsigned long long)__entry->blocks,
 429                 (unsigned long long)__entry->from)
 430 );
 431
 432 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter,
 433
 434         TP_PROTO(struct inode *inode, u64 from),
 435
 436         TP_ARGS(inode, from)
 437 );
 438
 439 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit,
 440
 441         TP_PROTO(struct inode *inode, int ret),
 442
 443         TP_ARGS(inode, ret)
 444 );
 445
 446 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter,
 447
 448         TP_PROTO(struct inode *inode, u64 from),
 449
 450         TP_ARGS(inode, from)
 451 );
 452
 453 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit,
 454
 455         TP_PROTO(struct inode *inode, int ret),
 456
 457         TP_ARGS(inode, ret)
 458 );
 459
 460 DECLARE_EVENT_CLASS(f2fs__truncate_node,
 461
 462         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 463
 464         TP_ARGS(inode, nid, blk_addr),
 465
 466         TP_STRUCT__entry(
 467                 __field(dev_t,  dev)
 468                 __field(ino_t,  ino)
 469                 __field(nid_t,  nid)
 470                 __field(block_t,        blk_addr)
 471         ),
 472
 473         TP_fast_assign(
 474                 __entry->dev            = inode->i_sb->s_dev;
 475                 __entry->ino            = inode->i_ino;
 476                 __entry->nid            = nid;
 477                 __entry->blk_addr       = blk_addr;
 478         ),
 479
 480         TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
 481                 show_dev_ino(__entry),
 482                 (unsigned int)__entry->nid,
 483                 (unsigned long long)__entry->blk_addr)
 484 );
 485
 486 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter,
 487
 488         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 489
 490         TP_ARGS(inode, nid, blk_addr)
 491 );
 492
 493 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit,
 494
 495         TP_PROTO(struct inode *inode, int ret),
 496
 497         TP_ARGS(inode, ret)
 498 );
 499
 500 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node,
 501
 502         TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
 503
 504         TP_ARGS(inode, nid, blk_addr)
 505 );
 506
 507 TRACE_EVENT(f2fs_truncate_partial_nodes,
 508
 509         TP_PROTO(struct inode *inode, nid_t *nid, int depth, int err),
 510
 511         TP_ARGS(inode, nid, depth, err),
 512
 513         TP_STRUCT__entry(
 514                 __field(dev_t,  dev)
 515                 __field(ino_t,  ino)
 516                 __field(nid_t,  nid[3])
 517                 __field(int,    depth)
 518                 __field(int,    err)
 519         ),
 520
 521         TP_fast_assign(
 522                 __entry->dev    = inode->i_sb->s_dev;
 523                 __entry->ino    = inode->i_ino;
 524                 __entry->nid[0] = nid[0];
 525                 __entry->nid[1] = nid[1];
 526                 __entry->nid[2] = nid[2];
 527                 __entry->depth  = depth;
 528                 __entry->err    = err;
 529         ),
 530
 531         TP_printk("dev = (%d,%d), ino = %lu, "
 532                 "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
 533                 show_dev_ino(__entry),
 534                 (unsigned int)__entry->nid[0],
 535                 (unsigned int)__entry->nid[1],
 536                 (unsigned int)__entry->nid[2],
 537                 __entry->depth,
 538                 __entry->err)
 539 );
 540
 541 TRACE_EVENT(f2fs_file_write_iter,
 542
 543         TP_PROTO(struct inode *inode, loff_t offset, size_t length,
 544                  ssize_t ret),
 545
 546         TP_ARGS(inode, offset, length, ret),
 547
 548         TP_STRUCT__entry(
 549                 __field(dev_t,  dev)
 550                 __field(ino_t,  ino)
 551                 __field(loff_t, offset)
 552                 __field(size_t, length)
 553                 __field(ssize_t, ret)
 554         ),
 555
 556         TP_fast_assign(
 557                 __entry->dev    = inode->i_sb->s_dev;
 558                 __entry->ino    = inode->i_ino;
 559                 __entry->offset = offset;
 560                 __entry->length = length;
 561                 __entry->ret    = ret;
 562         ),
 563
 564         TP_printk("dev = (%d,%d), ino = %lu, "
 565                 "offset = %lld, length = %zu, written(err) = %zd",
 566                 show_dev_ino(__entry),
 567                 __entry->offset,
 568                 __entry->length,
 569                 __entry->ret)
 570 );
 571
 572 TRACE_EVENT(f2fs_map_blocks,
 573         TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map,
 574                                 int create, int flag, int ret),
 575
 576         TP_ARGS(inode, map, create, flag, ret),
 577
 578         TP_STRUCT__entry(
 579                 __field(dev_t,  dev)
 580                 __field(ino_t,  ino)
 581                 __field(block_t,        m_lblk)
 582                 __field(block_t,        m_pblk)
 583                 __field(unsigned int,   m_len)
 584                 __field(unsigned int,   m_flags)
 585                 __field(int,    m_seg_type)
 586                 __field(bool,   m_may_create)
 587                 __field(bool,   m_multidev_dio)
 588                 __field(int,    create)
 589                 __field(int,    flag)
 590                 __field(int,    ret)
 591         ),
 592
 593         TP_fast_assign(
 594                 __entry->dev            = map->m_bdev->bd_dev;
 595                 __entry->ino            = inode->i_ino;
 596                 __entry->m_lblk         = map->m_lblk;
 597                 __entry->m_pblk         = map->m_pblk;
 598                 __entry->m_len          = map->m_len;
 599                 __entry->m_flags        = map->m_flags;
 600                 __entry->m_seg_type     = map->m_seg_type;
 601                 __entry->m_may_create   = map->m_may_create;
 602                 __entry->m_multidev_dio = map->m_multidev_dio;
 603                 __entry->create         = create;
 604                 __entry->flag           = flag;
 605                 __entry->ret            = ret;
 606         ),
 607
 608         TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
 609                 "start blkaddr = 0x%llx, len = 0x%llx, flags = %u, "
 610                 "seg_type = %d, may_create = %d, multidevice = %d, "
 611                 "create = %d, flag = %d, err = %d",
 612                 show_dev_ino(__entry),
 613                 (unsigned long long)__entry->m_lblk,
 614                 (unsigned long long)__entry->m_pblk,
 615                 (unsigned long long)__entry->m_len,
 616                 __entry->m_flags,
 617                 __entry->m_seg_type,
 618                 __entry->m_may_create,
 619                 __entry->m_multidev_dio,
 620                 __entry->create,
 621                 __entry->flag,
 622                 __entry->ret)
 623 );
 624
 625 TRACE_EVENT(f2fs_background_gc,
 626
 627         TP_PROTO(struct super_block *sb, unsigned int wait_ms,
 628                         unsigned int prefree, unsigned int free),
 629
 630         TP_ARGS(sb, wait_ms, prefree, free),
 631
 632         TP_STRUCT__entry(
 633                 __field(dev_t,  dev)
 634                 __field(unsigned int,   wait_ms)
 635                 __field(unsigned int,   prefree)
 636                 __field(unsigned int,   free)
 637         ),
 638
 639         TP_fast_assign(
 640                 __entry->dev            = sb->s_dev;
 641                 __entry->wait_ms        = wait_ms;
 642                 __entry->prefree        = prefree;
 643                 __entry->free           = free;
 644         ),
 645
 646         TP_printk("dev = (%d,%d), wait_ms = %u, prefree = %u, free = %u",
 647                 show_dev(__entry->dev),
 648                 __entry->wait_ms,
 649                 __entry->prefree,
 650                 __entry->free)
 651 );
 652
 653 TRACE_EVENT(f2fs_gc_begin,
 654
 655         TP_PROTO(struct super_block *sb, bool sync, bool background,
 656                         long long dirty_nodes, long long dirty_dents,
 657                         long long dirty_imeta, unsigned int free_sec,
 658                         unsigned int free_seg, int reserved_seg,
 659                         unsigned int prefree_seg),
 660
 661         TP_ARGS(sb, sync, background, dirty_nodes, dirty_dents, dirty_imeta,
 662                 free_sec, free_seg, reserved_seg, prefree_seg),
 663
 664         TP_STRUCT__entry(
 665                 __field(dev_t,          dev)
 666                 __field(bool,           sync)
 667                 __field(bool,           background)
 668                 __field(long long,      dirty_nodes)
 669                 __field(long long,      dirty_dents)
 670                 __field(long long,      dirty_imeta)
 671                 __field(unsigned int,   free_sec)
 672                 __field(unsigned int,   free_seg)
 673                 __field(int,            reserved_seg)
 674                 __field(unsigned int,   prefree_seg)
 675         ),
 676
 677         TP_fast_assign(
 678                 __entry->dev            = sb->s_dev;
 679                 __entry->sync           = sync;
 680                 __entry->background     = background;
 681                 __entry->dirty_nodes    = dirty_nodes;
 682                 __entry->dirty_dents    = dirty_dents;
 683                 __entry->dirty_imeta    = dirty_imeta;
 684                 __entry->free_sec       = free_sec;
 685                 __entry->free_seg       = free_seg;
 686                 __entry->reserved_seg   = reserved_seg;
 687                 __entry->prefree_seg    = prefree_seg;
 688         ),
 689
 690         TP_printk("dev = (%d,%d), sync = %d, background = %d, nodes = %lld, "
 691                 "dents = %lld, imeta = %lld, free_sec:%u, free_seg:%u, "
 692                 "rsv_seg:%d, prefree_seg:%u",
 693                 show_dev(__entry->dev),
 694                 __entry->sync,
 695                 __entry->background,
 696                 __entry->dirty_nodes,
 697                 __entry->dirty_dents,
 698                 __entry->dirty_imeta,
 699                 __entry->free_sec,
 700                 __entry->free_seg,
 701                 __entry->reserved_seg,
 702                 __entry->prefree_seg)
 703 );
 704
 705 TRACE_EVENT(f2fs_gc_end,
 706
 707         TP_PROTO(struct super_block *sb, int ret, int seg_freed,
 708                         int sec_freed, long long dirty_nodes,
 709                         long long dirty_dents, long long dirty_imeta,
 710                         unsigned int free_sec, unsigned int free_seg,
 711                         int reserved_seg, unsigned int prefree_seg),
 712
 713         TP_ARGS(sb, ret, seg_freed, sec_freed, dirty_nodes, dirty_dents,
 714                 dirty_imeta, free_sec, free_seg, reserved_seg, prefree_seg),
 715
 716         TP_STRUCT__entry(
 717                 __field(dev_t,          dev)
 718                 __field(int,            ret)
 719                 __field(int,            seg_freed)
 720                 __field(int,            sec_freed)
 721                 __field(long long,      dirty_nodes)
 722                 __field(long long,      dirty_dents)
 723                 __field(long long,      dirty_imeta)
 724                 __field(unsigned int,   free_sec)
 725                 __field(unsigned int,   free_seg)
 726                 __field(int,            reserved_seg)
 727                 __field(unsigned int,   prefree_seg)
 728         ),
 729
 730         TP_fast_assign(
 731                 __entry->dev            = sb->s_dev;
 732                 __entry->ret            = ret;
 733                 __entry->seg_freed      = seg_freed;
 734                 __entry->sec_freed      = sec_freed;
 735                 __entry->dirty_nodes    = dirty_nodes;
 736                 __entry->dirty_dents    = dirty_dents;
 737                 __entry->dirty_imeta    = dirty_imeta;
 738                 __entry->free_sec       = free_sec;
 739                 __entry->free_seg       = free_seg;
 740                 __entry->reserved_seg   = reserved_seg;
 741                 __entry->prefree_seg    = prefree_seg;
 742         ),
 743
 744         TP_printk("dev = (%d,%d), ret = %d, seg_freed = %d, sec_freed = %d, "
 745                 "nodes = %lld, dents = %lld, imeta = %lld, free_sec:%u, "
 746                 "free_seg:%u, rsv_seg:%d, prefree_seg:%u",
 747                 show_dev(__entry->dev),
 748                 __entry->ret,
 749                 __entry->seg_freed,
 750                 __entry->sec_freed,
 751                 __entry->dirty_nodes,
 752                 __entry->dirty_dents,
 753                 __entry->dirty_imeta,
 754                 __entry->free_sec,
 755                 __entry->free_seg,
 756                 __entry->reserved_seg,
 757                 __entry->prefree_seg)
 758 );
 759
 760 TRACE_EVENT(f2fs_get_victim,
 761
 762         TP_PROTO(struct super_block *sb, int type, int gc_type,
 763                         struct victim_sel_policy *p, unsigned int pre_victim,
 764                         unsigned int prefree, unsigned int free),
 765
 766         TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free),
 767
 768         TP_STRUCT__entry(
 769                 __field(dev_t,  dev)
 770                 __field(int,    type)
 771                 __field(int,    gc_type)
 772                 __field(int,    alloc_mode)
 773                 __field(int,    gc_mode)
 774                 __field(unsigned int,   victim)
 775                 __field(unsigned int,   cost)
 776                 __field(unsigned int,   ofs_unit)
 777                 __field(unsigned int,   pre_victim)
 778                 __field(unsigned int,   prefree)
 779                 __field(unsigned int,   free)
 780         ),
 781
 782         TP_fast_assign(
 783                 __entry->dev            = sb->s_dev;
 784                 __entry->type           = type;
 785                 __entry->gc_type        = gc_type;
 786                 __entry->alloc_mode     = p->alloc_mode;
 787                 __entry->gc_mode        = p->gc_mode;
 788                 __entry->victim         = p->min_segno;
 789                 __entry->cost           = p->min_cost;
 790                 __entry->ofs_unit       = p->ofs_unit;
 791                 __entry->pre_victim     = pre_victim;
 792                 __entry->prefree        = prefree;
 793                 __entry->free           = free;
 794         ),
 795
 796         TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), "
 797                 "victim = %u, cost = %u, ofs_unit = %u, "
 798                 "pre_victim_secno = %d, prefree = %u, free = %u",
 799                 show_dev(__entry->dev),
 800                 show_data_type(__entry->type),
 801                 show_gc_type(__entry->gc_type),
 802                 show_alloc_mode(__entry->alloc_mode),
 803                 show_victim_policy(__entry->gc_mode),
 804                 __entry->victim,
 805                 __entry->cost,
 806                 __entry->ofs_unit,
 807                 (int)__entry->pre_victim,
 808                 __entry->prefree,
 809                 __entry->free)
 810 );
 811
 812 TRACE_EVENT(f2fs_lookup_start,
 813
 814         TP_PROTO(struct inode *dir, struct dentry *dentry, unsigned int flags),
 815
 816         TP_ARGS(dir, dentry, flags),
 817
 818         TP_STRUCT__entry(
 819                 __field(dev_t,  dev)
 820                 __field(ino_t,  ino)
 821                 __string(name,  dentry->d_name.name)
 822                 __field(unsigned int, flags)
 823         ),
 824
 825         TP_fast_assign(
 826                 __entry->dev    = dir->i_sb->s_dev;
 827                 __entry->ino    = dir->i_ino;
 828                 __assign_str(name, dentry->d_name.name);
 829                 __entry->flags  = flags;
 830         ),
 831
 832         TP_printk("dev = (%d,%d), pino = %lu, name:%s, flags:%u",
 833                 show_dev_ino(__entry),
 834                 __get_str(name),
 835                 __entry->flags)
 836 );
 837
 838 TRACE_EVENT(f2fs_lookup_end,
 839
 840         TP_PROTO(struct inode *dir, struct dentry *dentry, nid_t ino,
 841                 int err),
 842
 843         TP_ARGS(dir, dentry, ino, err),
 844
 845         TP_STRUCT__entry(
 846                 __field(dev_t,  dev)
 847                 __field(ino_t,  ino)
 848                 __string(name,  dentry->d_name.name)
 849                 __field(nid_t,  cino)
 850                 __field(int,    err)
 851         ),
 852
 853         TP_fast_assign(
 854                 __entry->dev    = dir->i_sb->s_dev;
 855                 __entry->ino    = dir->i_ino;
 856                 __assign_str(name, dentry->d_name.name);
 857                 __entry->cino   = ino;
 858                 __entry->err    = err;
 859         ),
 860
 861         TP_printk("dev = (%d,%d), pino = %lu, name:%s, ino:%u, err:%d",
 862                 show_dev_ino(__entry),
 863                 __get_str(name),
 864                 __entry->cino,
 865                 __entry->err)
 866 );
 867
 868 TRACE_EVENT(f2fs_readdir,
 869
 870         TP_PROTO(struct inode *dir, loff_t start_pos, loff_t end_pos, int err),
 871
 872         TP_ARGS(dir, start_pos, end_pos, err),
 873
 874         TP_STRUCT__entry(
 875                 __field(dev_t,  dev)
 876                 __field(ino_t,  ino)
 877                 __field(loff_t, start)
 878                 __field(loff_t, end)
 879                 __field(int,    err)
 880         ),
 881
 882         TP_fast_assign(
 883                 __entry->dev    = dir->i_sb->s_dev;
 884                 __entry->ino    = dir->i_ino;
 885                 __entry->start  = start_pos;
 886                 __entry->end    = end_pos;
 887                 __entry->err    = err;
 888         ),
 889
 890         TP_printk("dev = (%d,%d), ino = %lu, start_pos:%llu, end_pos:%llu, err:%d",
 891                 show_dev_ino(__entry),
 892                 __entry->start,
 893                 __entry->end,
 894                 __entry->err)
 895 );
 896
 897 TRACE_EVENT(f2fs_fallocate,
 898
 899         TP_PROTO(struct inode *inode, int mode,
 900                                 loff_t offset, loff_t len, int ret),
 901
 902         TP_ARGS(inode, mode, offset, len, ret),
 903
 904         TP_STRUCT__entry(
 905                 __field(dev_t,  dev)
 906                 __field(ino_t,  ino)
 907                 __field(int,    mode)
 908                 __field(loff_t, offset)
 909                 __field(loff_t, len)
 910                 __field(loff_t, size)
 911                 __field(blkcnt_t, blocks)
 912                 __field(int,    ret)
 913         ),
 914
 915         TP_fast_assign(
 916                 __entry->dev    = inode->i_sb->s_dev;
 917                 __entry->ino    = inode->i_ino;
 918                 __entry->mode   = mode;
 919                 __entry->offset = offset;
 920                 __entry->len    = len;
 921                 __entry->size   = inode->i_size;
 922                 __entry->blocks = inode->i_blocks;
 923                 __entry->ret    = ret;
 924         ),
 925
 926         TP_printk("dev = (%d,%d), ino = %lu, mode = %x, offset = %lld, "
 927                 "len = %lld,  i_size = %lld, i_blocks = %llu, ret = %d",
 928                 show_dev_ino(__entry),
 929                 __entry->mode,
 930                 (unsigned long long)__entry->offset,
 931                 (unsigned long long)__entry->len,
 932                 (unsigned long long)__entry->size,
 933                 (unsigned long long)__entry->blocks,
 934                 __entry->ret)
 935 );
 936
 937 TRACE_EVENT(f2fs_direct_IO_enter,
 938
 939         TP_PROTO(struct inode *inode, struct kiocb *iocb, long len, int rw),
 940
 941         TP_ARGS(inode, iocb, len, rw),
 942
 943         TP_STRUCT__entry(
 944                 __field(dev_t,  dev)
 945                 __field(ino_t,  ino)
 946                 __field(struct kiocb *, iocb)
 947                 __field(unsigned long,  len)
 948                 __field(int,    rw)
 949         ),
 950
 951         TP_fast_assign(
 952                 __entry->dev    = inode->i_sb->s_dev;
 953                 __entry->ino    = inode->i_ino;
 954                 __entry->iocb   = iocb;
 955                 __entry->len    = len;
 956                 __entry->rw     = rw;
 957         ),
 958
 959         TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu ki_flags = %x ki_hint = %x ki_ioprio = %x rw = %d",
 960                 show_dev_ino(__entry),
 961                 __entry->iocb->ki_pos,
 962                 __entry->len,
 963                 __entry->iocb->ki_flags,
 964                 __entry->iocb->ki_hint,
 965                 __entry->iocb->ki_ioprio,
 966                 __entry->rw)
 967 );
 968
 969 TRACE_EVENT(f2fs_direct_IO_exit,
 970
 971         TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
 972                  int rw, int ret),
 973
 974         TP_ARGS(inode, offset, len, rw, ret),
 975
 976         TP_STRUCT__entry(
 977                 __field(dev_t,  dev)
 978                 __field(ino_t,  ino)
 979                 __field(loff_t, pos)
 980                 __field(unsigned long,  len)
 981                 __field(int,    rw)
 982                 __field(int,    ret)
 983         ),
 984
 985         TP_fast_assign(
 986                 __entry->dev    = inode->i_sb->s_dev;
 987                 __entry->ino    = inode->i_ino;
 988                 __entry->pos    = offset;
 989                 __entry->len    = len;
 990                 __entry->rw     = rw;
 991                 __entry->ret    = ret;
 992         ),
 993
 994         TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu "
 995                 "rw = %d ret = %d",
 996                 show_dev_ino(__entry),
 997                 __entry->pos,
 998                 __entry->len,
 999                 __entry->rw,
1000                 __entry->ret)
1001 );
1002
1003 TRACE_EVENT(f2fs_reserve_new_blocks,
1004
1005         TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs_in_node,
1006                                                         blkcnt_t count),
1007
1008         TP_ARGS(inode, nid, ofs_in_node, count),
1009
1010         TP_STRUCT__entry(
1011                 __field(dev_t,  dev)
1012                 __field(nid_t, nid)
1013                 __field(unsigned int, ofs_in_node)
1014                 __field(blkcnt_t, count)
1015         ),
1016
1017         TP_fast_assign(
1018                 __entry->dev    = inode->i_sb->s_dev;
1019                 __entry->nid    = nid;
1020                 __entry->ofs_in_node = ofs_in_node;
1021                 __entry->count = count;
1022         ),
1023
1024         TP_printk("dev = (%d,%d), nid = %u, ofs_in_node = %u, count = %llu",
1025                 show_dev(__entry->dev),
1026                 (unsigned int)__entry->nid,
1027                 __entry->ofs_in_node,
1028                 (unsigned long long)__entry->count)
1029 );
1030
1031 DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
1032
1033         TP_PROTO(struct page *page, struct f2fs_io_info *fio),
1034
1035         TP_ARGS(page, fio),
1036
1037         TP_STRUCT__entry(
1038                 __field(dev_t, dev)
1039                 __field(ino_t, ino)
1040                 __field(pgoff_t, index)
1041                 __field(block_t, old_blkaddr)
1042                 __field(block_t, new_blkaddr)
1043                 __field(int, op)
1044                 __field(int, op_flags)
1045                 __field(int, temp)
1046                 __field(int, type)
1047         ),
1048
1049         TP_fast_assign(
1050                 __entry->dev            = page_file_mapping(page)->host->i_sb->s_dev;
1051                 __entry->ino            = page_file_mapping(page)->host->i_ino;
1052                 __entry->index          = page->index;
1053                 __entry->old_blkaddr    = fio->old_blkaddr;
1054                 __entry->new_blkaddr    = fio->new_blkaddr;
1055                 __entry->op             = fio->op;
1056                 __entry->op_flags       = fio->op_flags;
1057                 __entry->temp           = fio->temp;
1058                 __entry->type           = fio->type;
1059         ),
1060
1061         TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
1062                 "oldaddr = 0x%llx, newaddr = 0x%llx, rw = %s(%s), type = %s_%s",
1063                 show_dev_ino(__entry),
1064                 (unsigned long)__entry->index,
1065                 (unsigned long long)__entry->old_blkaddr,
1066                 (unsigned long long)__entry->new_blkaddr,
1067                 show_bio_type(__entry->op, __entry->op_flags),
1068                 show_block_temp(__entry->temp),
1069                 show_block_type(__entry->type))
1070 );
1071
1072 DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_bio,
1073
1074         TP_PROTO(struct page *page, struct f2fs_io_info *fio),
1075
1076         TP_ARGS(page, fio),
1077
1078         TP_CONDITION(page->mapping)
1079 );
1080
1081 DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_write,
1082
1083         TP_PROTO(struct page *page, struct f2fs_io_info *fio),
1084
1085         TP_ARGS(page, fio),
1086
1087         TP_CONDITION(page->mapping)
1088 );
1089
1090 DECLARE_EVENT_CLASS(f2fs__bio,
1091
1092         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1093
1094         TP_ARGS(sb, type, bio),
1095
1096         TP_STRUCT__entry(
1097                 __field(dev_t,  dev)
1098                 __field(dev_t,  target)
1099                 __field(int,    op)
1100                 __field(int,    op_flags)
1101                 __field(int,    type)
1102                 __field(sector_t,       sector)
1103                 __field(unsigned int,   size)
1104         ),
1105
1106         TP_fast_assign(
1107                 __entry->dev            = sb->s_dev;
1108                 __entry->target         = bio_dev(bio);
1109                 __entry->op             = bio_op(bio);
1110                 __entry->op_flags       = bio->bi_opf;
1111                 __entry->type           = type;
1112                 __entry->sector         = bio->bi_iter.bi_sector;
1113                 __entry->size           = bio->bi_iter.bi_size;
1114         ),
1115
1116         TP_printk("dev = (%d,%d)/(%d,%d), rw = %s(%s), %s, sector = %lld, size = %u",
1117                 show_dev(__entry->target),
1118                 show_dev(__entry->dev),
1119                 show_bio_type(__entry->op, __entry->op_flags),
1120                 show_block_type(__entry->type),
1121                 (unsigned long long)__entry->sector,
1122                 __entry->size)
1123 );
1124
1125 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_write_bio,
1126
1127         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1128
1129         TP_ARGS(sb, type, bio),
1130
1131         TP_CONDITION(bio)
1132 );
1133
1134 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_read_bio,
1135
1136         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1137
1138         TP_ARGS(sb, type, bio),
1139
1140         TP_CONDITION(bio)
1141 );
1142
1143 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_read_bio,
1144
1145         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1146
1147         TP_ARGS(sb, type, bio),
1148
1149         TP_CONDITION(bio)
1150 );
1151
1152 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_write_bio,
1153
1154         TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1155
1156         TP_ARGS(sb, type, bio),
1157
1158         TP_CONDITION(bio)
1159 );
1160
1161 TRACE_EVENT(f2fs_write_begin,
1162
1163         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
1164                                 unsigned int flags),
1165
1166         TP_ARGS(inode, pos, len, flags),
1167
1168         TP_STRUCT__entry(
1169                 __field(dev_t,  dev)
1170                 __field(ino_t,  ino)
1171                 __field(loff_t, pos)
1172                 __field(unsigned int, len)
1173                 __field(unsigned int, flags)
1174         ),
1175
1176         TP_fast_assign(
1177                 __entry->dev    = inode->i_sb->s_dev;
1178                 __entry->ino    = inode->i_ino;
1179                 __entry->pos    = pos;
1180                 __entry->len    = len;
1181                 __entry->flags  = flags;
1182         ),
1183
1184         TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, flags = %u",
1185                 show_dev_ino(__entry),
1186                 (unsigned long long)__entry->pos,
1187                 __entry->len,
1188                 __entry->flags)
1189 );
1190
1191 TRACE_EVENT(f2fs_write_end,
1192
1193         TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
1194                                 unsigned int copied),
1195
1196         TP_ARGS(inode, pos, len, copied),
1197
1198         TP_STRUCT__entry(
1199                 __field(dev_t,  dev)
1200                 __field(ino_t,  ino)
1201                 __field(loff_t, pos)
1202                 __field(unsigned int, len)
1203                 __field(unsigned int, copied)
1204         ),
1205
1206         TP_fast_assign(
1207                 __entry->dev    = inode->i_sb->s_dev;
1208                 __entry->ino    = inode->i_ino;
1209                 __entry->pos    = pos;
1210                 __entry->len    = len;
1211                 __entry->copied = copied;
1212         ),
1213
1214         TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, copied = %u",
1215                 show_dev_ino(__entry),
1216                 (unsigned long long)__entry->pos,
1217                 __entry->len,
1218                 __entry->copied)
1219 );
1220
1221 DECLARE_EVENT_CLASS(f2fs__page,
1222
1223         TP_PROTO(struct page *page, int type),
1224
1225         TP_ARGS(page, type),
1226
1227         TP_STRUCT__entry(
1228                 __field(dev_t,  dev)
1229                 __field(ino_t,  ino)
1230                 __field(int, type)
1231                 __field(int, dir)
1232                 __field(pgoff_t, index)
1233                 __field(int, dirty)
1234                 __field(int, uptodate)
1235         ),
1236
1237         TP_fast_assign(
1238                 __entry->dev    = page_file_mapping(page)->host->i_sb->s_dev;
1239                 __entry->ino    = page_file_mapping(page)->host->i_ino;
1240                 __entry->type   = type;
1241                 __entry->dir    =
1242                         S_ISDIR(page_file_mapping(page)->host->i_mode);
1243                 __entry->index  = page->index;
1244                 __entry->dirty  = PageDirty(page);
1245                 __entry->uptodate = PageUptodate(page);
1246         ),
1247
1248         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, index = %lu, "
1249                 "dirty = %d, uptodate = %d",
1250                 show_dev_ino(__entry),
1251                 show_block_type(__entry->type),
1252                 show_file_type(__entry->dir),
1253                 (unsigned long)__entry->index,
1254                 __entry->dirty,
1255                 __entry->uptodate)
1256 );
1257
1258 DEFINE_EVENT(f2fs__page, f2fs_writepage,
1259
1260         TP_PROTO(struct page *page, int type),
1261
1262         TP_ARGS(page, type)
1263 );
1264
1265 DEFINE_EVENT(f2fs__page, f2fs_do_write_data_page,
1266
1267         TP_PROTO(struct page *page, int type),
1268
1269         TP_ARGS(page, type)
1270 );
1271
1272 DEFINE_EVENT(f2fs__page, f2fs_readpage,
1273
1274         TP_PROTO(struct page *page, int type),
1275
1276         TP_ARGS(page, type)
1277 );
1278
1279 DEFINE_EVENT(f2fs__page, f2fs_set_page_dirty,
1280
1281         TP_PROTO(struct page *page, int type),
1282
1283         TP_ARGS(page, type)
1284 );
1285
1286 DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite,
1287
1288         TP_PROTO(struct page *page, int type),
1289
1290         TP_ARGS(page, type)
1291 );
1292
1293 DEFINE_EVENT(f2fs__page, f2fs_register_inmem_page,
1294
1295         TP_PROTO(struct page *page, int type),
1296
1297         TP_ARGS(page, type)
1298 );
1299
1300 DEFINE_EVENT(f2fs__page, f2fs_commit_inmem_page,
1301
1302         TP_PROTO(struct page *page, int type),
1303
1304         TP_ARGS(page, type)
1305 );
1306
1307 TRACE_EVENT(f2fs_filemap_fault,
1308
1309         TP_PROTO(struct inode *inode, pgoff_t index, unsigned long ret),
1310
1311         TP_ARGS(inode, index, ret),
1312
1313         TP_STRUCT__entry(
1314                 __field(dev_t,  dev)
1315                 __field(ino_t,  ino)
1316                 __field(pgoff_t, index)
1317                 __field(unsigned long, ret)
1318         ),
1319
1320         TP_fast_assign(
1321                 __entry->dev    = inode->i_sb->s_dev;
1322                 __entry->ino    = inode->i_ino;
1323                 __entry->index  = index;
1324                 __entry->ret    = ret;
1325         ),
1326
1327         TP_printk("dev = (%d,%d), ino = %lu, index = %lu, ret = %lx",
1328                 show_dev_ino(__entry),
1329                 (unsigned long)__entry->index,
1330                 __entry->ret)
1331 );
1332
1333 TRACE_EVENT(f2fs_writepages,
1334
1335         TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type),
1336
1337         TP_ARGS(inode, wbc, type),
1338
1339         TP_STRUCT__entry(
1340                 __field(dev_t,  dev)
1341                 __field(ino_t,  ino)
1342                 __field(int,    type)
1343                 __field(int,    dir)
1344                 __field(long,   nr_to_write)
1345                 __field(long,   pages_skipped)
1346                 __field(loff_t, range_start)
1347                 __field(loff_t, range_end)
1348                 __field(pgoff_t, writeback_index)
1349                 __field(int,    sync_mode)
1350                 __field(char,   for_kupdate)
1351                 __field(char,   for_background)
1352                 __field(char,   tagged_writepages)
1353                 __field(char,   for_reclaim)
1354                 __field(char,   range_cyclic)
1355                 __field(char,   for_sync)
1356         ),
1357
1358         TP_fast_assign(
1359                 __entry->dev            = inode->i_sb->s_dev;
1360                 __entry->ino            = inode->i_ino;
1361                 __entry->type           = type;
1362                 __entry->dir            = S_ISDIR(inode->i_mode);
1363                 __entry->nr_to_write    = wbc->nr_to_write;
1364                 __entry->pages_skipped  = wbc->pages_skipped;
1365                 __entry->range_start    = wbc->range_start;
1366                 __entry->range_end      = wbc->range_end;
1367                 __entry->writeback_index = inode->i_mapping->writeback_index;
1368                 __entry->sync_mode      = wbc->sync_mode;
1369                 __entry->for_kupdate    = wbc->for_kupdate;
1370                 __entry->for_background = wbc->for_background;
1371                 __entry->tagged_writepages      = wbc->tagged_writepages;
1372                 __entry->for_reclaim    = wbc->for_reclaim;
1373                 __entry->range_cyclic   = wbc->range_cyclic;
1374                 __entry->for_sync       = wbc->for_sync;
1375         ),
1376
1377         TP_printk("dev = (%d,%d), ino = %lu, %s, %s, nr_to_write %ld, "
1378                 "skipped %ld, start %lld, end %lld, wb_idx %lu, sync_mode %d, "
1379                 "kupdate %u background %u tagged %u reclaim %u cyclic %u sync %u",
1380                 show_dev_ino(__entry),
1381                 show_block_type(__entry->type),
1382                 show_file_type(__entry->dir),
1383                 __entry->nr_to_write,
1384                 __entry->pages_skipped,
1385                 __entry->range_start,
1386                 __entry->range_end,
1387                 (unsigned long)__entry->writeback_index,
1388                 __entry->sync_mode,
1389                 __entry->for_kupdate,
1390                 __entry->for_background,
1391                 __entry->tagged_writepages,
1392                 __entry->for_reclaim,
1393                 __entry->range_cyclic,
1394                 __entry->for_sync)
1395 );
1396
1397 TRACE_EVENT(f2fs_readpages,
1398
1399         TP_PROTO(struct inode *inode, pgoff_t start, unsigned int nrpage),
1400
1401         TP_ARGS(inode, start, nrpage),
1402
1403         TP_STRUCT__entry(
1404                 __field(dev_t,  dev)
1405                 __field(ino_t,  ino)
1406                 __field(pgoff_t,        start)
1407                 __field(unsigned int,   nrpage)
1408         ),
1409
1410         TP_fast_assign(
1411                 __entry->dev    = inode->i_sb->s_dev;
1412                 __entry->ino    = inode->i_ino;
1413                 __entry->start  = start;
1414                 __entry->nrpage = nrpage;
1415         ),
1416
1417         TP_printk("dev = (%d,%d), ino = %lu, start = %lu nrpage = %u",
1418                 show_dev_ino(__entry),
1419                 (unsigned long)__entry->start,
1420                 __entry->nrpage)
1421 );
1422
1423 TRACE_EVENT(f2fs_write_checkpoint,
1424
1425         TP_PROTO(struct super_block *sb, int reason, char *msg),
1426
1427         TP_ARGS(sb, reason, msg),
1428
1429         TP_STRUCT__entry(
1430                 __field(dev_t,  dev)
1431                 __field(int,    reason)
1432                 __field(char *, msg)
1433         ),
1434
1435         TP_fast_assign(
1436                 __entry->dev            = sb->s_dev;
1437                 __entry->reason         = reason;
1438                 __entry->msg            = msg;
1439         ),
1440
1441         TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
1442                 show_dev(__entry->dev),
1443                 show_cpreason(__entry->reason),
1444                 __entry->msg)
1445 );
1446
1447 DECLARE_EVENT_CLASS(f2fs_discard,
1448
1449         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1450
1451         TP_ARGS(dev, blkstart, blklen),
1452
1453         TP_STRUCT__entry(
1454                 __field(dev_t,  dev)
1455                 __field(block_t, blkstart)
1456                 __field(block_t, blklen)
1457         ),
1458
1459         TP_fast_assign(
1460                 __entry->dev    = dev->bd_dev;
1461                 __entry->blkstart = blkstart;
1462                 __entry->blklen = blklen;
1463         ),
1464
1465         TP_printk("dev = (%d,%d), blkstart = 0x%llx, blklen = 0x%llx",
1466                 show_dev(__entry->dev),
1467                 (unsigned long long)__entry->blkstart,
1468                 (unsigned long long)__entry->blklen)
1469 );
1470
1471 DEFINE_EVENT(f2fs_discard, f2fs_queue_discard,
1472
1473         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1474
1475         TP_ARGS(dev, blkstart, blklen)
1476 );
1477
1478 DEFINE_EVENT(f2fs_discard, f2fs_issue_discard,
1479
1480         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1481
1482         TP_ARGS(dev, blkstart, blklen)
1483 );
1484
1485 DEFINE_EVENT(f2fs_discard, f2fs_remove_discard,
1486
1487         TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1488
1489         TP_ARGS(dev, blkstart, blklen)
1490 );
1491
1492 TRACE_EVENT(f2fs_issue_reset_zone,
1493
1494         TP_PROTO(struct block_device *dev, block_t blkstart),
1495
1496         TP_ARGS(dev, blkstart),
1497
1498         TP_STRUCT__entry(
1499                 __field(dev_t,  dev)
1500                 __field(block_t, blkstart)
1501         ),
1502
1503         TP_fast_assign(
1504                 __entry->dev    = dev->bd_dev;
1505                 __entry->blkstart = blkstart;
1506         ),
1507
1508         TP_printk("dev = (%d,%d), reset zone at block = 0x%llx",
1509                 show_dev(__entry->dev),
1510                 (unsigned long long)__entry->blkstart)
1511 );
1512
1513 TRACE_EVENT(f2fs_issue_flush,
1514
1515         TP_PROTO(struct block_device *dev, unsigned int nobarrier,
1516                                 unsigned int flush_merge, int ret),
1517
1518         TP_ARGS(dev, nobarrier, flush_merge, ret),
1519
1520         TP_STRUCT__entry(
1521                 __field(dev_t,  dev)
1522                 __field(unsigned int, nobarrier)
1523                 __field(unsigned int, flush_merge)
1524                 __field(int,  ret)
1525         ),
1526
1527         TP_fast_assign(
1528                 __entry->dev    = dev->bd_dev;
1529                 __entry->nobarrier = nobarrier;
1530                 __entry->flush_merge = flush_merge;
1531                 __entry->ret = ret;
1532         ),
1533
1534         TP_printk("dev = (%d,%d), %s %s, ret = %d",
1535                 show_dev(__entry->dev),
1536                 __entry->nobarrier ? "skip (nobarrier)" : "issue",
1537                 __entry->flush_merge ? " with flush_merge" : "",
1538                 __entry->ret)
1539 );
1540
1541 TRACE_EVENT(f2fs_lookup_extent_tree_start,
1542
1543         TP_PROTO(struct inode *inode, unsigned int pgofs),
1544
1545         TP_ARGS(inode, pgofs),
1546
1547         TP_STRUCT__entry(
1548                 __field(dev_t,  dev)
1549                 __field(ino_t,  ino)
1550                 __field(unsigned int, pgofs)
1551         ),
1552
1553         TP_fast_assign(
1554                 __entry->dev = inode->i_sb->s_dev;
1555                 __entry->ino = inode->i_ino;
1556                 __entry->pgofs = pgofs;
1557         ),
1558
1559         TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u",
1560                 show_dev_ino(__entry),
1561                 __entry->pgofs)
1562 );
1563
1564 TRACE_EVENT_CONDITION(f2fs_lookup_extent_tree_end,
1565
1566         TP_PROTO(struct inode *inode, unsigned int pgofs,
1567                                                 struct extent_info *ei),
1568
1569         TP_ARGS(inode, pgofs, ei),
1570
1571         TP_CONDITION(ei),
1572
1573         TP_STRUCT__entry(
1574                 __field(dev_t,  dev)
1575                 __field(ino_t,  ino)
1576                 __field(unsigned int, pgofs)
1577                 __field(unsigned int, fofs)
1578                 __field(u32, blk)
1579                 __field(unsigned int, len)
1580         ),
1581
1582         TP_fast_assign(
1583                 __entry->dev = inode->i_sb->s_dev;
1584                 __entry->ino = inode->i_ino;
1585                 __entry->pgofs = pgofs;
1586                 __entry->fofs = ei->fofs;
1587                 __entry->blk = ei->blk;
1588                 __entry->len = ei->len;
1589         ),
1590
1591         TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1592                 "ext_info(fofs: %u, blk: %u, len: %u)",
1593                 show_dev_ino(__entry),
1594                 __entry->pgofs,
1595                 __entry->fofs,
1596                 __entry->blk,
1597                 __entry->len)
1598 );
1599
1600 TRACE_EVENT(f2fs_update_extent_tree_range,
1601
1602         TP_PROTO(struct inode *inode, unsigned int pgofs, block_t blkaddr,
1603                                                 unsigned int len),
1604
1605         TP_ARGS(inode, pgofs, blkaddr, len),
1606
1607         TP_STRUCT__entry(
1608                 __field(dev_t,  dev)
1609                 __field(ino_t,  ino)
1610                 __field(unsigned int, pgofs)
1611                 __field(u32, blk)
1612                 __field(unsigned int, len)
1613         ),
1614
1615         TP_fast_assign(
1616                 __entry->dev = inode->i_sb->s_dev;
1617                 __entry->ino = inode->i_ino;
1618                 __entry->pgofs = pgofs;
1619                 __entry->blk = blkaddr;
1620                 __entry->len = len;
1621         ),
1622
1623         TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1624                                         "blkaddr = %u, len = %u",
1625                 show_dev_ino(__entry),
1626                 __entry->pgofs,
1627                 __entry->blk,
1628                 __entry->len)
1629 );
1630
1631 TRACE_EVENT(f2fs_shrink_extent_tree,
1632
1633         TP_PROTO(struct f2fs_sb_info *sbi, unsigned int node_cnt,
1634                                                 unsigned int tree_cnt),
1635
1636         TP_ARGS(sbi, node_cnt, tree_cnt),
1637
1638         TP_STRUCT__entry(
1639                 __field(dev_t,  dev)
1640                 __field(unsigned int, node_cnt)
1641                 __field(unsigned int, tree_cnt)
1642         ),
1643
1644         TP_fast_assign(
1645                 __entry->dev = sbi->sb->s_dev;
1646                 __entry->node_cnt = node_cnt;
1647                 __entry->tree_cnt = tree_cnt;
1648         ),
1649
1650         TP_printk("dev = (%d,%d), shrunk: node_cnt = %u, tree_cnt = %u",
1651                 show_dev(__entry->dev),
1652                 __entry->node_cnt,
1653                 __entry->tree_cnt)
1654 );
1655
1656 TRACE_EVENT(f2fs_destroy_extent_tree,
1657
1658         TP_PROTO(struct inode *inode, unsigned int node_cnt),
1659
1660         TP_ARGS(inode, node_cnt),
1661
1662         TP_STRUCT__entry(
1663                 __field(dev_t,  dev)
1664                 __field(ino_t,  ino)
1665                 __field(unsigned int, node_cnt)
1666         ),
1667
1668         TP_fast_assign(
1669                 __entry->dev = inode->i_sb->s_dev;
1670                 __entry->ino = inode->i_ino;
1671                 __entry->node_cnt = node_cnt;
1672         ),
1673
1674         TP_printk("dev = (%d,%d), ino = %lu, destroyed: node_cnt = %u",
1675                 show_dev_ino(__entry),
1676                 __entry->node_cnt)
1677 );
1678
1679 DECLARE_EVENT_CLASS(f2fs_sync_dirty_inodes,
1680
1681         TP_PROTO(struct super_block *sb, int type, s64 count),
1682
1683         TP_ARGS(sb, type, count),
1684
1685         TP_STRUCT__entry(
1686                 __field(dev_t, dev)
1687                 __field(int, type)
1688                 __field(s64, count)
1689         ),
1690
1691         TP_fast_assign(
1692                 __entry->dev    = sb->s_dev;
1693                 __entry->type   = type;
1694                 __entry->count  = count;
1695         ),
1696
1697         TP_printk("dev = (%d,%d), %s, dirty count = %lld",
1698                 show_dev(__entry->dev),
1699                 show_file_type(__entry->type),
1700                 __entry->count)
1701 );
1702
1703 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_enter,
1704
1705         TP_PROTO(struct super_block *sb, int type, s64 count),
1706
1707         TP_ARGS(sb, type, count)
1708 );
1709
1710 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_exit,
1711
1712         TP_PROTO(struct super_block *sb, int type, s64 count),
1713
1714         TP_ARGS(sb, type, count)
1715 );
1716
1717 TRACE_EVENT(f2fs_shutdown,
1718
1719         TP_PROTO(struct f2fs_sb_info *sbi, unsigned int mode, int ret),
1720
1721         TP_ARGS(sbi, mode, ret),
1722
1723         TP_STRUCT__entry(
1724                 __field(dev_t,  dev)
1725                 __field(unsigned int, mode)
1726                 __field(int, ret)
1727         ),
1728
1729         TP_fast_assign(
1730                 __entry->dev = sbi->sb->s_dev;
1731                 __entry->mode = mode;
1732                 __entry->ret = ret;
1733         ),
1734
1735         TP_printk("dev = (%d,%d), mode: %s, ret:%d",
1736                 show_dev(__entry->dev),
1737                 show_shutdown_mode(__entry->mode),
1738                 __entry->ret)
1739 );
1740
1741 DECLARE_EVENT_CLASS(f2fs_zip_start,
1742
1743         TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1744                         unsigned int cluster_size, unsigned char algtype),
1745
1746         TP_ARGS(inode, cluster_idx, cluster_size, algtype),
1747
1748         TP_STRUCT__entry(
1749                 __field(dev_t,  dev)
1750                 __field(ino_t,  ino)
1751                 __field(pgoff_t, idx)
1752                 __field(unsigned int, size)
1753                 __field(unsigned int, algtype)
1754         ),
1755
1756         TP_fast_assign(
1757                 __entry->dev = inode->i_sb->s_dev;
1758                 __entry->ino = inode->i_ino;
1759                 __entry->idx = cluster_idx;
1760                 __entry->size = cluster_size;
1761                 __entry->algtype = algtype;
1762         ),
1763
1764         TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%lu, "
1765                 "cluster_size = %u, algorithm = %s",
1766                 show_dev_ino(__entry),
1767                 __entry->idx,
1768                 __entry->size,
1769                 show_compress_algorithm(__entry->algtype))
1770 );
1771
1772 DECLARE_EVENT_CLASS(f2fs_zip_end,
1773
1774         TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1775                         unsigned int compressed_size, int ret),
1776
1777         TP_ARGS(inode, cluster_idx, compressed_size, ret),
1778
1779         TP_STRUCT__entry(
1780                 __field(dev_t,  dev)
1781                 __field(ino_t,  ino)
1782                 __field(pgoff_t, idx)
1783                 __field(unsigned int, size)
1784                 __field(unsigned int, ret)
1785         ),
1786
1787         TP_fast_assign(
1788                 __entry->dev = inode->i_sb->s_dev;
1789                 __entry->ino = inode->i_ino;
1790                 __entry->idx = cluster_idx;
1791                 __entry->size = compressed_size;
1792                 __entry->ret = ret;
1793         ),
1794
1795         TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%lu, "
1796                 "compressed_size = %u, ret = %d",
1797                 show_dev_ino(__entry),
1798                 __entry->idx,
1799                 __entry->size,
1800                 __entry->ret)
1801 );
1802
1803 DEFINE_EVENT(f2fs_zip_start, f2fs_compress_pages_start,
1804
1805         TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1806                 unsigned int cluster_size, unsigned char algtype),
1807
1808         TP_ARGS(inode, cluster_idx, cluster_size, algtype)
1809 );
1810
1811 DEFINE_EVENT(f2fs_zip_start, f2fs_decompress_pages_start,
1812
1813         TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1814                 unsigned int cluster_size, unsigned char algtype),
1815
1816         TP_ARGS(inode, cluster_idx, cluster_size, algtype)
1817 );
1818
1819 DEFINE_EVENT(f2fs_zip_end, f2fs_compress_pages_end,
1820
1821         TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1822                         unsigned int compressed_size, int ret),
1823
1824         TP_ARGS(inode, cluster_idx, compressed_size, ret)
1825 );
1826
1827 DEFINE_EVENT(f2fs_zip_end, f2fs_decompress_pages_end,
1828
1829         TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1830                         unsigned int compressed_size, int ret),
1831
1832         TP_ARGS(inode, cluster_idx, compressed_size, ret)
1833 );
1834
1835 #ifdef CONFIG_F2FS_IOSTAT
1836 TRACE_EVENT(f2fs_iostat,
1837
1838         TP_PROTO(struct f2fs_sb_info *sbi, unsigned long long *iostat),
1839
1840         TP_ARGS(sbi, iostat),
1841
1842         TP_STRUCT__entry(
1843                 __field(dev_t,  dev)
1844                 __field(unsigned long long,     app_dio)
1845                 __field(unsigned long long,     app_bio)
1846                 __field(unsigned long long,     app_wio)
1847                 __field(unsigned long long,     app_mio)
1848                 __field(unsigned long long,     fs_dio)
1849                 __field(unsigned long long,     fs_nio)
1850                 __field(unsigned long long,     fs_mio)
1851                 __field(unsigned long long,     fs_gc_dio)
1852                 __field(unsigned long long,     fs_gc_nio)
1853                 __field(unsigned long long,     fs_cp_dio)
1854                 __field(unsigned long long,     fs_cp_nio)
1855                 __field(unsigned long long,     fs_cp_mio)
1856                 __field(unsigned long long,     app_drio)
1857                 __field(unsigned long long,     app_brio)
1858                 __field(unsigned long long,     app_rio)
1859                 __field(unsigned long long,     app_mrio)
1860                 __field(unsigned long long,     fs_drio)
1861                 __field(unsigned long long,     fs_gdrio)
1862                 __field(unsigned long long,     fs_cdrio)
1863                 __field(unsigned long long,     fs_nrio)
1864                 __field(unsigned long long,     fs_mrio)
1865                 __field(unsigned long long,     fs_discard)
1866         ),
1867
1868         TP_fast_assign(
1869                 __entry->dev            = sbi->sb->s_dev;
1870                 __entry->app_dio        = iostat[APP_DIRECT_IO];
1871                 __entry->app_bio        = iostat[APP_BUFFERED_IO];
1872                 __entry->app_wio        = iostat[APP_WRITE_IO];
1873                 __entry->app_mio        = iostat[APP_MAPPED_IO];
1874                 __entry->fs_dio         = iostat[FS_DATA_IO];
1875                 __entry->fs_nio         = iostat[FS_NODE_IO];
1876                 __entry->fs_mio         = iostat[FS_META_IO];
1877                 __entry->fs_gc_dio      = iostat[FS_GC_DATA_IO];
1878                 __entry->fs_gc_nio      = iostat[FS_GC_NODE_IO];
1879                 __entry->fs_cp_dio      = iostat[FS_CP_DATA_IO];
1880                 __entry->fs_cp_nio      = iostat[FS_CP_NODE_IO];
1881                 __entry->fs_cp_mio      = iostat[FS_CP_META_IO];
1882                 __entry->app_drio       = iostat[APP_DIRECT_READ_IO];
1883                 __entry->app_brio       = iostat[APP_BUFFERED_READ_IO];
1884                 __entry->app_rio        = iostat[APP_READ_IO];
1885                 __entry->app_mrio       = iostat[APP_MAPPED_READ_IO];
1886                 __entry->fs_drio        = iostat[FS_DATA_READ_IO];
1887                 __entry->fs_gdrio       = iostat[FS_GDATA_READ_IO];
1888                 __entry->fs_cdrio       = iostat[FS_CDATA_READ_IO];
1889                 __entry->fs_nrio        = iostat[FS_NODE_READ_IO];
1890                 __entry->fs_mrio        = iostat[FS_META_READ_IO];
1891                 __entry->fs_discard     = iostat[FS_DISCARD];
1892         ),
1893
1894         TP_printk("dev = (%d,%d), "
1895                 "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu], "
1896                 "fs [data=%llu, node=%llu, meta=%llu, discard=%llu], "
1897                 "gc [data=%llu, node=%llu], "
1898                 "cp [data=%llu, node=%llu, meta=%llu], "
1899                 "app [read=%llu (direct=%llu, buffered=%llu), mapped=%llu], "
1900                 "fs [data=%llu, (gc_data=%llu, compr_data=%llu), "
1901                 "node=%llu, meta=%llu]",
1902                 show_dev(__entry->dev), __entry->app_wio, __entry->app_dio,
1903                 __entry->app_bio, __entry->app_mio, __entry->fs_dio,
1904                 __entry->fs_nio, __entry->fs_mio, __entry->fs_discard,
1905                 __entry->fs_gc_dio, __entry->fs_gc_nio, __entry->fs_cp_dio,
1906                 __entry->fs_cp_nio, __entry->fs_cp_mio,
1907                 __entry->app_rio, __entry->app_drio, __entry->app_brio,
1908                 __entry->app_mrio, __entry->fs_drio, __entry->fs_gdrio,
1909                 __entry->fs_cdrio, __entry->fs_nrio, __entry->fs_mrio)
1910 );
1911
1912 #ifndef __F2FS_IOSTAT_LATENCY_TYPE
1913 #define __F2FS_IOSTAT_LATENCY_TYPE
1914 struct f2fs_iostat_latency {
1915         unsigned int peak_lat;
1916         unsigned int avg_lat;
1917         unsigned int cnt;
1918 };
1919 #endif /* __F2FS_IOSTAT_LATENCY_TYPE */
1920
1921 TRACE_EVENT(f2fs_iostat_latency,
1922
1923         TP_PROTO(struct f2fs_sb_info *sbi, struct f2fs_iostat_latency (*iostat_lat)[NR_PAGE_TYPE]),
1924
1925         TP_ARGS(sbi, iostat_lat),
1926
1927         TP_STRUCT__entry(
1928                 __field(dev_t,  dev)
1929                 __field(unsigned int,   d_rd_peak)
1930                 __field(unsigned int,   d_rd_avg)
1931                 __field(unsigned int,   d_rd_cnt)
1932                 __field(unsigned int,   n_rd_peak)
1933                 __field(unsigned int,   n_rd_avg)
1934                 __field(unsigned int,   n_rd_cnt)
1935                 __field(unsigned int,   m_rd_peak)
1936                 __field(unsigned int,   m_rd_avg)
1937                 __field(unsigned int,   m_rd_cnt)
1938                 __field(unsigned int,   d_wr_s_peak)
1939                 __field(unsigned int,   d_wr_s_avg)
1940                 __field(unsigned int,   d_wr_s_cnt)
1941                 __field(unsigned int,   n_wr_s_peak)
1942                 __field(unsigned int,   n_wr_s_avg)
1943                 __field(unsigned int,   n_wr_s_cnt)
1944                 __field(unsigned int,   m_wr_s_peak)
1945                 __field(unsigned int,   m_wr_s_avg)
1946                 __field(unsigned int,   m_wr_s_cnt)
1947                 __field(unsigned int,   d_wr_as_peak)
1948                 __field(unsigned int,   d_wr_as_avg)
1949                 __field(unsigned int,   d_wr_as_cnt)
1950                 __field(unsigned int,   n_wr_as_peak)
1951                 __field(unsigned int,   n_wr_as_avg)
1952                 __field(unsigned int,   n_wr_as_cnt)
1953                 __field(unsigned int,   m_wr_as_peak)
1954                 __field(unsigned int,   m_wr_as_avg)
1955                 __field(unsigned int,   m_wr_as_cnt)
1956         ),
1957
1958         TP_fast_assign(
1959                 __entry->dev            = sbi->sb->s_dev;
1960                 __entry->d_rd_peak      = iostat_lat[0][DATA].peak_lat;
1961                 __entry->d_rd_avg       = iostat_lat[0][DATA].avg_lat;
1962                 __entry->d_rd_cnt       = iostat_lat[0][DATA].cnt;
1963                 __entry->n_rd_peak      = iostat_lat[0][NODE].peak_lat;
1964                 __entry->n_rd_avg       = iostat_lat[0][NODE].avg_lat;
1965                 __entry->n_rd_cnt       = iostat_lat[0][NODE].cnt;
1966                 __entry->m_rd_peak      = iostat_lat[0][META].peak_lat;
1967                 __entry->m_rd_avg       = iostat_lat[0][META].avg_lat;
1968                 __entry->m_rd_cnt       = iostat_lat[0][META].cnt;
1969                 __entry->d_wr_s_peak    = iostat_lat[1][DATA].peak_lat;
1970                 __entry->d_wr_s_avg     = iostat_lat[1][DATA].avg_lat;
1971                 __entry->d_wr_s_cnt     = iostat_lat[1][DATA].cnt;
1972                 __entry->n_wr_s_peak    = iostat_lat[1][NODE].peak_lat;
1973                 __entry->n_wr_s_avg     = iostat_lat[1][NODE].avg_lat;
1974                 __entry->n_wr_s_cnt     = iostat_lat[1][NODE].cnt;
1975                 __entry->m_wr_s_peak    = iostat_lat[1][META].peak_lat;
1976                 __entry->m_wr_s_avg     = iostat_lat[1][META].avg_lat;
1977                 __entry->m_wr_s_cnt     = iostat_lat[1][META].cnt;
1978                 __entry->d_wr_as_peak   = iostat_lat[2][DATA].peak_lat;
1979                 __entry->d_wr_as_avg    = iostat_lat[2][DATA].avg_lat;
1980                 __entry->d_wr_as_cnt    = iostat_lat[2][DATA].cnt;
1981                 __entry->n_wr_as_peak   = iostat_lat[2][NODE].peak_lat;
1982                 __entry->n_wr_as_avg    = iostat_lat[2][NODE].avg_lat;
1983                 __entry->n_wr_as_cnt    = iostat_lat[2][NODE].cnt;
1984                 __entry->m_wr_as_peak   = iostat_lat[2][META].peak_lat;
1985                 __entry->m_wr_as_avg    = iostat_lat[2][META].avg_lat;
1986                 __entry->m_wr_as_cnt    = iostat_lat[2][META].cnt;
1987         ),
1988
1989         TP_printk("dev = (%d,%d), "
1990                 "iotype [peak lat.(ms)/avg lat.(ms)/count], "
1991                 "rd_data [%u/%u/%u], rd_node [%u/%u/%u], rd_meta [%u/%u/%u], "
1992                 "wr_sync_data [%u/%u/%u], wr_sync_node [%u/%u/%u], "
1993                 "wr_sync_meta [%u/%u/%u], wr_async_data [%u/%u/%u], "
1994                 "wr_async_node [%u/%u/%u], wr_async_meta [%u/%u/%u]",
1995                 show_dev(__entry->dev),
1996                 __entry->d_rd_peak, __entry->d_rd_avg, __entry->d_rd_cnt,
1997                 __entry->n_rd_peak, __entry->n_rd_avg, __entry->n_rd_cnt,
1998                 __entry->m_rd_peak, __entry->m_rd_avg, __entry->m_rd_cnt,
1999                 __entry->d_wr_s_peak, __entry->d_wr_s_avg, __entry->d_wr_s_cnt,
2000                 __entry->n_wr_s_peak, __entry->n_wr_s_avg, __entry->n_wr_s_cnt,
2001                 __entry->m_wr_s_peak, __entry->m_wr_s_avg, __entry->m_wr_s_cnt,
2002                 __entry->d_wr_as_peak, __entry->d_wr_as_avg, __entry->d_wr_as_cnt,
2003                 __entry->n_wr_as_peak, __entry->n_wr_as_avg, __entry->n_wr_as_cnt,
2004                 __entry->m_wr_as_peak, __entry->m_wr_as_avg, __entry->m_wr_as_cnt)
2005 );
2006 #endif
2007
2008 TRACE_EVENT(f2fs_bmap,
2009
2010         TP_PROTO(struct inode *inode, sector_t lblock, sector_t pblock),
2011
2012         TP_ARGS(inode, lblock, pblock),
2013
2014         TP_STRUCT__entry(
2015                 __field(dev_t, dev)
2016                 __field(ino_t, ino)
2017                 __field(sector_t, lblock)
2018                 __field(sector_t, pblock)
2019         ),
2020
2021         TP_fast_assign(
2022                 __entry->dev            = inode->i_sb->s_dev;
2023                 __entry->ino            = inode->i_ino;
2024                 __entry->lblock         = lblock;
2025                 __entry->pblock         = pblock;
2026         ),
2027
2028         TP_printk("dev = (%d,%d), ino = %lu, lblock:%lld, pblock:%lld",
2029                 show_dev_ino(__entry),
2030                 (unsigned long long)__entry->lblock,
2031                 (unsigned long long)__entry->pblock)
2032 );
2033
2034 TRACE_EVENT(f2fs_fiemap,
2035
2036         TP_PROTO(struct inode *inode, sector_t lblock, sector_t pblock,
2037                 unsigned long long len, unsigned int flags, int ret),
2038
2039         TP_ARGS(inode, lblock, pblock, len, flags, ret),
2040
2041         TP_STRUCT__entry(
2042                 __field(dev_t, dev)
2043                 __field(ino_t, ino)
2044                 __field(sector_t, lblock)
2045                 __field(sector_t, pblock)
2046                 __field(unsigned long long, len)
2047                 __field(unsigned int, flags)
2048                 __field(int, ret)
2049         ),
2050
2051         TP_fast_assign(
2052                 __entry->dev            = inode->i_sb->s_dev;
2053                 __entry->ino            = inode->i_ino;
2054                 __entry->lblock         = lblock;
2055                 __entry->pblock         = pblock;
2056                 __entry->len            = len;
2057                 __entry->flags          = flags;
2058                 __entry->ret            = ret;
2059         ),
2060
2061         TP_printk("dev = (%d,%d), ino = %lu, lblock:%lld, pblock:%lld, "
2062                 "len:%llu, flags:%u, ret:%d",
2063                 show_dev_ino(__entry),
2064                 (unsigned long long)__entry->lblock,
2065                 (unsigned long long)__entry->pblock,
2066                 __entry->len,
2067                 __entry->flags,
2068                 __entry->ret)
2069 );
2070
2071 #endif /* _TRACE_F2FS_H */
2072
2073  /* This part must be outside protection */
2074 #include <trace/define_trace.h>