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