Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM f2fs
0004 
0005 #if !defined(_TRACE_F2FS_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_F2FS_H
0007 
0008 #include <linux/tracepoint.h>
0009 #include <uapi/linux/f2fs.h>
0010 
0011 #define show_dev(dev)       MAJOR(dev), MINOR(dev)
0012 #define show_dev_ino(entry) show_dev(entry->dev), (unsigned long)entry->ino
0013 
0014 TRACE_DEFINE_ENUM(NODE);
0015 TRACE_DEFINE_ENUM(DATA);
0016 TRACE_DEFINE_ENUM(META);
0017 TRACE_DEFINE_ENUM(META_FLUSH);
0018 TRACE_DEFINE_ENUM(IPU);
0019 TRACE_DEFINE_ENUM(OPU);
0020 TRACE_DEFINE_ENUM(HOT);
0021 TRACE_DEFINE_ENUM(WARM);
0022 TRACE_DEFINE_ENUM(COLD);
0023 TRACE_DEFINE_ENUM(CURSEG_HOT_DATA);
0024 TRACE_DEFINE_ENUM(CURSEG_WARM_DATA);
0025 TRACE_DEFINE_ENUM(CURSEG_COLD_DATA);
0026 TRACE_DEFINE_ENUM(CURSEG_HOT_NODE);
0027 TRACE_DEFINE_ENUM(CURSEG_WARM_NODE);
0028 TRACE_DEFINE_ENUM(CURSEG_COLD_NODE);
0029 TRACE_DEFINE_ENUM(NO_CHECK_TYPE);
0030 TRACE_DEFINE_ENUM(GC_GREEDY);
0031 TRACE_DEFINE_ENUM(GC_CB);
0032 TRACE_DEFINE_ENUM(FG_GC);
0033 TRACE_DEFINE_ENUM(BG_GC);
0034 TRACE_DEFINE_ENUM(LFS);
0035 TRACE_DEFINE_ENUM(SSR);
0036 TRACE_DEFINE_ENUM(__REQ_RAHEAD);
0037 TRACE_DEFINE_ENUM(__REQ_SYNC);
0038 TRACE_DEFINE_ENUM(__REQ_IDLE);
0039 TRACE_DEFINE_ENUM(__REQ_PREFLUSH);
0040 TRACE_DEFINE_ENUM(__REQ_FUA);
0041 TRACE_DEFINE_ENUM(__REQ_PRIO);
0042 TRACE_DEFINE_ENUM(__REQ_META);
0043 TRACE_DEFINE_ENUM(CP_UMOUNT);
0044 TRACE_DEFINE_ENUM(CP_FASTBOOT);
0045 TRACE_DEFINE_ENUM(CP_SYNC);
0046 TRACE_DEFINE_ENUM(CP_RECOVERY);
0047 TRACE_DEFINE_ENUM(CP_DISCARD);
0048 TRACE_DEFINE_ENUM(CP_TRIMMED);
0049 TRACE_DEFINE_ENUM(CP_PAUSE);
0050 TRACE_DEFINE_ENUM(CP_RESIZE);
0051 
0052 #define show_block_type(type)                       \
0053     __print_symbolic(type,                      \
0054         { NODE,     "NODE" },               \
0055         { DATA,     "DATA" },               \
0056         { META,     "META" },               \
0057         { META_FLUSH,   "META_FLUSH" },             \
0058         { IPU,      "IN-PLACE" },               \
0059         { OPU,      "OUT-OF-PLACE" })
0060 
0061 #define show_block_temp(temp)                       \
0062     __print_symbolic(temp,                      \
0063         { HOT,      "HOT" },                \
0064         { WARM,     "WARM" },               \
0065         { COLD,     "COLD" })
0066 
0067 #define F2FS_OP_FLAGS (REQ_RAHEAD | REQ_SYNC | REQ_META | REQ_PRIO |    \
0068             REQ_PREFLUSH | REQ_FUA)
0069 #define F2FS_BIO_FLAG_MASK(t) (__force u32)((t) & F2FS_OP_FLAGS)
0070 
0071 #define show_bio_type(op,op_flags)  show_bio_op(op),        \
0072                         show_bio_op_flags(op_flags)
0073 
0074 #define show_bio_op(op)     blk_op_str(op)
0075 
0076 #define show_bio_op_flags(flags)                    \
0077     __print_flags(F2FS_BIO_FLAG_MASK(flags), "|",           \
0078         { (__force u32)REQ_RAHEAD,  "R" },          \
0079         { (__force u32)REQ_SYNC,    "S" },          \
0080         { (__force u32)REQ_META,    "M" },          \
0081         { (__force u32)REQ_PRIO,    "P" },          \
0082         { (__force u32)REQ_PREFLUSH,    "PF" },         \
0083         { (__force u32)REQ_FUA,     "FUA" })
0084 
0085 #define show_data_type(type)                        \
0086     __print_symbolic(type,                      \
0087         { CURSEG_HOT_DATA,  "Hot DATA" },           \
0088         { CURSEG_WARM_DATA,     "Warm DATA" },          \
0089         { CURSEG_COLD_DATA,     "Cold DATA" },          \
0090         { CURSEG_HOT_NODE,  "Hot NODE" },           \
0091         { CURSEG_WARM_NODE,     "Warm NODE" },          \
0092         { CURSEG_COLD_NODE,     "Cold NODE" },          \
0093         { NO_CHECK_TYPE,    "No TYPE" })
0094 
0095 #define show_file_type(type)                        \
0096     __print_symbolic(type,                      \
0097         { 0,        "FILE" },               \
0098         { 1,        "DIR" })
0099 
0100 #define show_gc_type(type)                      \
0101     __print_symbolic(type,                      \
0102         { FG_GC,    "Foreground GC" },          \
0103         { BG_GC,    "Background GC" })
0104 
0105 #define show_alloc_mode(type)                       \
0106     __print_symbolic(type,                      \
0107         { LFS,      "LFS-mode" },               \
0108         { SSR,      "SSR-mode" },               \
0109         { AT_SSR,   "AT_SSR-mode" })
0110 
0111 #define show_victim_policy(type)                    \
0112     __print_symbolic(type,                      \
0113         { GC_GREEDY,    "Greedy" },             \
0114         { GC_CB,    "Cost-Benefit" },           \
0115         { GC_AT,    "Age-threshold" })
0116 
0117 #define show_cpreason(type)                     \
0118     __print_flags(type, "|",                    \
0119         { CP_UMOUNT,    "Umount" },             \
0120         { CP_FASTBOOT,  "Fastboot" },               \
0121         { CP_SYNC,  "Sync" },               \
0122         { CP_RECOVERY,  "Recovery" },               \
0123         { CP_DISCARD,   "Discard" },                \
0124         { CP_PAUSE, "Pause" },              \
0125         { CP_TRIMMED,   "Trimmed" },                \
0126         { CP_RESIZE,    "Resize" })
0127 
0128 #define show_fsync_cpreason(type)                   \
0129     __print_symbolic(type,                      \
0130         { CP_NO_NEEDED,     "no needed" },          \
0131         { CP_NON_REGULAR,   "non regular" },        \
0132         { CP_COMPRESSED,    "compressed" },         \
0133         { CP_HARDLINK,      "hardlink" },           \
0134         { CP_SB_NEED_CP,    "sb needs cp" },        \
0135         { CP_WRONG_PINO,    "wrong pino" },         \
0136         { CP_NO_SPC_ROLL,   "no space roll forward" },  \
0137         { CP_NODE_NEED_CP,  "node needs cp" },      \
0138         { CP_FASTBOOT_MODE, "fastboot mode" },      \
0139         { CP_SPEC_LOG_NUM,  "log type is 2" },      \
0140         { CP_RECOVER_DIR,   "dir needs recovery" })
0141 
0142 #define show_shutdown_mode(type)                    \
0143     __print_symbolic(type,                      \
0144         { F2FS_GOING_DOWN_FULLSYNC, "full sync" },      \
0145         { F2FS_GOING_DOWN_METASYNC, "meta sync" },      \
0146         { F2FS_GOING_DOWN_NOSYNC,   "no sync" },        \
0147         { F2FS_GOING_DOWN_METAFLUSH,    "meta flush" },     \
0148         { F2FS_GOING_DOWN_NEED_FSCK,    "need fsck" })
0149 
0150 #define show_compress_algorithm(type)                   \
0151     __print_symbolic(type,                      \
0152         { COMPRESS_LZO,     "LZO" },            \
0153         { COMPRESS_LZ4,     "LZ4" },            \
0154         { COMPRESS_ZSTD,    "ZSTD" },           \
0155         { COMPRESS_LZORLE,  "LZO-RLE" })
0156 
0157 struct f2fs_sb_info;
0158 struct f2fs_io_info;
0159 struct extent_info;
0160 struct victim_sel_policy;
0161 struct f2fs_map_blocks;
0162 
0163 DECLARE_EVENT_CLASS(f2fs__inode,
0164 
0165     TP_PROTO(struct inode *inode),
0166 
0167     TP_ARGS(inode),
0168 
0169     TP_STRUCT__entry(
0170         __field(dev_t,  dev)
0171         __field(ino_t,  ino)
0172         __field(ino_t,  pino)
0173         __field(umode_t, mode)
0174         __field(loff_t, size)
0175         __field(unsigned int, nlink)
0176         __field(blkcnt_t, blocks)
0177         __field(__u8,   advise)
0178     ),
0179 
0180     TP_fast_assign(
0181         __entry->dev    = inode->i_sb->s_dev;
0182         __entry->ino    = inode->i_ino;
0183         __entry->pino   = F2FS_I(inode)->i_pino;
0184         __entry->mode   = inode->i_mode;
0185         __entry->nlink  = inode->i_nlink;
0186         __entry->size   = inode->i_size;
0187         __entry->blocks = inode->i_blocks;
0188         __entry->advise = F2FS_I(inode)->i_advise;
0189     ),
0190 
0191     TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
0192         "i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
0193         show_dev_ino(__entry),
0194         (unsigned long)__entry->pino,
0195         __entry->mode,
0196         __entry->size,
0197         (unsigned int)__entry->nlink,
0198         (unsigned long long)__entry->blocks,
0199         (unsigned char)__entry->advise)
0200 );
0201 
0202 DECLARE_EVENT_CLASS(f2fs__inode_exit,
0203 
0204     TP_PROTO(struct inode *inode, int ret),
0205 
0206     TP_ARGS(inode, ret),
0207 
0208     TP_STRUCT__entry(
0209         __field(dev_t,  dev)
0210         __field(ino_t,  ino)
0211         __field(int,    ret)
0212     ),
0213 
0214     TP_fast_assign(
0215         __entry->dev    = inode->i_sb->s_dev;
0216         __entry->ino    = inode->i_ino;
0217         __entry->ret    = ret;
0218     ),
0219 
0220     TP_printk("dev = (%d,%d), ino = %lu, ret = %d",
0221         show_dev_ino(__entry),
0222         __entry->ret)
0223 );
0224 
0225 DEFINE_EVENT(f2fs__inode, f2fs_sync_file_enter,
0226 
0227     TP_PROTO(struct inode *inode),
0228 
0229     TP_ARGS(inode)
0230 );
0231 
0232 TRACE_EVENT(f2fs_sync_file_exit,
0233 
0234     TP_PROTO(struct inode *inode, int cp_reason, int datasync, int ret),
0235 
0236     TP_ARGS(inode, cp_reason, datasync, ret),
0237 
0238     TP_STRUCT__entry(
0239         __field(dev_t,  dev)
0240         __field(ino_t,  ino)
0241         __field(int,    cp_reason)
0242         __field(int,    datasync)
0243         __field(int,    ret)
0244     ),
0245 
0246     TP_fast_assign(
0247         __entry->dev        = inode->i_sb->s_dev;
0248         __entry->ino        = inode->i_ino;
0249         __entry->cp_reason  = cp_reason;
0250         __entry->datasync   = datasync;
0251         __entry->ret        = ret;
0252     ),
0253 
0254     TP_printk("dev = (%d,%d), ino = %lu, cp_reason: %s, "
0255         "datasync = %d, ret = %d",
0256         show_dev_ino(__entry),
0257         show_fsync_cpreason(__entry->cp_reason),
0258         __entry->datasync,
0259         __entry->ret)
0260 );
0261 
0262 TRACE_EVENT(f2fs_sync_fs,
0263 
0264     TP_PROTO(struct super_block *sb, int wait),
0265 
0266     TP_ARGS(sb, wait),
0267 
0268     TP_STRUCT__entry(
0269         __field(dev_t,  dev)
0270         __field(int,    dirty)
0271         __field(int,    wait)
0272     ),
0273 
0274     TP_fast_assign(
0275         __entry->dev    = sb->s_dev;
0276         __entry->dirty  = is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY);
0277         __entry->wait   = wait;
0278     ),
0279 
0280     TP_printk("dev = (%d,%d), superblock is %s, wait = %d",
0281         show_dev(__entry->dev),
0282         __entry->dirty ? "dirty" : "not dirty",
0283         __entry->wait)
0284 );
0285 
0286 DEFINE_EVENT(f2fs__inode, f2fs_iget,
0287 
0288     TP_PROTO(struct inode *inode),
0289 
0290     TP_ARGS(inode)
0291 );
0292 
0293 DEFINE_EVENT(f2fs__inode_exit, f2fs_iget_exit,
0294 
0295     TP_PROTO(struct inode *inode, int ret),
0296 
0297     TP_ARGS(inode, ret)
0298 );
0299 
0300 DEFINE_EVENT(f2fs__inode, f2fs_evict_inode,
0301 
0302     TP_PROTO(struct inode *inode),
0303 
0304     TP_ARGS(inode)
0305 );
0306 
0307 DEFINE_EVENT(f2fs__inode_exit, f2fs_new_inode,
0308 
0309     TP_PROTO(struct inode *inode, int ret),
0310 
0311     TP_ARGS(inode, ret)
0312 );
0313 
0314 TRACE_EVENT(f2fs_unlink_enter,
0315 
0316     TP_PROTO(struct inode *dir, struct dentry *dentry),
0317 
0318     TP_ARGS(dir, dentry),
0319 
0320     TP_STRUCT__entry(
0321         __field(dev_t,  dev)
0322         __field(ino_t,  ino)
0323         __field(loff_t, size)
0324         __field(blkcnt_t, blocks)
0325         __field(const char *,   name)
0326     ),
0327 
0328     TP_fast_assign(
0329         __entry->dev    = dir->i_sb->s_dev;
0330         __entry->ino    = dir->i_ino;
0331         __entry->size   = dir->i_size;
0332         __entry->blocks = dir->i_blocks;
0333         __entry->name   = dentry->d_name.name;
0334     ),
0335 
0336     TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
0337         "i_blocks = %llu, name = %s",
0338         show_dev_ino(__entry),
0339         __entry->size,
0340         (unsigned long long)__entry->blocks,
0341         __entry->name)
0342 );
0343 
0344 DEFINE_EVENT(f2fs__inode_exit, f2fs_unlink_exit,
0345 
0346     TP_PROTO(struct inode *inode, int ret),
0347 
0348     TP_ARGS(inode, ret)
0349 );
0350 
0351 DEFINE_EVENT(f2fs__inode_exit, f2fs_drop_inode,
0352 
0353     TP_PROTO(struct inode *inode, int ret),
0354 
0355     TP_ARGS(inode, ret)
0356 );
0357 
0358 DEFINE_EVENT(f2fs__inode, f2fs_truncate,
0359 
0360     TP_PROTO(struct inode *inode),
0361 
0362     TP_ARGS(inode)
0363 );
0364 
0365 TRACE_EVENT(f2fs_truncate_data_blocks_range,
0366 
0367     TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs, int free),
0368 
0369     TP_ARGS(inode, nid,  ofs, free),
0370 
0371     TP_STRUCT__entry(
0372         __field(dev_t,  dev)
0373         __field(ino_t,  ino)
0374         __field(nid_t,  nid)
0375         __field(unsigned int,   ofs)
0376         __field(int,    free)
0377     ),
0378 
0379     TP_fast_assign(
0380         __entry->dev    = inode->i_sb->s_dev;
0381         __entry->ino    = inode->i_ino;
0382         __entry->nid    = nid;
0383         __entry->ofs    = ofs;
0384         __entry->free   = free;
0385     ),
0386 
0387     TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
0388         show_dev_ino(__entry),
0389         (unsigned int)__entry->nid,
0390         __entry->ofs,
0391         __entry->free)
0392 );
0393 
0394 DECLARE_EVENT_CLASS(f2fs__truncate_op,
0395 
0396     TP_PROTO(struct inode *inode, u64 from),
0397 
0398     TP_ARGS(inode, from),
0399 
0400     TP_STRUCT__entry(
0401         __field(dev_t,  dev)
0402         __field(ino_t,  ino)
0403         __field(loff_t, size)
0404         __field(blkcnt_t, blocks)
0405         __field(u64,    from)
0406     ),
0407 
0408     TP_fast_assign(
0409         __entry->dev    = inode->i_sb->s_dev;
0410         __entry->ino    = inode->i_ino;
0411         __entry->size   = inode->i_size;
0412         __entry->blocks = inode->i_blocks;
0413         __entry->from   = from;
0414     ),
0415 
0416     TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
0417         "start file offset = %llu",
0418         show_dev_ino(__entry),
0419         __entry->size,
0420         (unsigned long long)__entry->blocks,
0421         (unsigned long long)__entry->from)
0422 );
0423 
0424 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_blocks_enter,
0425 
0426     TP_PROTO(struct inode *inode, u64 from),
0427 
0428     TP_ARGS(inode, from)
0429 );
0430 
0431 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_blocks_exit,
0432 
0433     TP_PROTO(struct inode *inode, int ret),
0434 
0435     TP_ARGS(inode, ret)
0436 );
0437 
0438 DEFINE_EVENT(f2fs__truncate_op, f2fs_truncate_inode_blocks_enter,
0439 
0440     TP_PROTO(struct inode *inode, u64 from),
0441 
0442     TP_ARGS(inode, from)
0443 );
0444 
0445 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_inode_blocks_exit,
0446 
0447     TP_PROTO(struct inode *inode, int ret),
0448 
0449     TP_ARGS(inode, ret)
0450 );
0451 
0452 DECLARE_EVENT_CLASS(f2fs__truncate_node,
0453 
0454     TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
0455 
0456     TP_ARGS(inode, nid, blk_addr),
0457 
0458     TP_STRUCT__entry(
0459         __field(dev_t,  dev)
0460         __field(ino_t,  ino)
0461         __field(nid_t,  nid)
0462         __field(block_t,    blk_addr)
0463     ),
0464 
0465     TP_fast_assign(
0466         __entry->dev        = inode->i_sb->s_dev;
0467         __entry->ino        = inode->i_ino;
0468         __entry->nid        = nid;
0469         __entry->blk_addr   = blk_addr;
0470     ),
0471 
0472     TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
0473         show_dev_ino(__entry),
0474         (unsigned int)__entry->nid,
0475         (unsigned long long)__entry->blk_addr)
0476 );
0477 
0478 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_nodes_enter,
0479 
0480     TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
0481 
0482     TP_ARGS(inode, nid, blk_addr)
0483 );
0484 
0485 DEFINE_EVENT(f2fs__inode_exit, f2fs_truncate_nodes_exit,
0486 
0487     TP_PROTO(struct inode *inode, int ret),
0488 
0489     TP_ARGS(inode, ret)
0490 );
0491 
0492 DEFINE_EVENT(f2fs__truncate_node, f2fs_truncate_node,
0493 
0494     TP_PROTO(struct inode *inode, nid_t nid, block_t blk_addr),
0495 
0496     TP_ARGS(inode, nid, blk_addr)
0497 );
0498 
0499 TRACE_EVENT(f2fs_truncate_partial_nodes,
0500 
0501     TP_PROTO(struct inode *inode, nid_t *nid, int depth, int err),
0502 
0503     TP_ARGS(inode, nid, depth, err),
0504 
0505     TP_STRUCT__entry(
0506         __field(dev_t,  dev)
0507         __field(ino_t,  ino)
0508         __field(nid_t,  nid[3])
0509         __field(int,    depth)
0510         __field(int,    err)
0511     ),
0512 
0513     TP_fast_assign(
0514         __entry->dev    = inode->i_sb->s_dev;
0515         __entry->ino    = inode->i_ino;
0516         __entry->nid[0] = nid[0];
0517         __entry->nid[1] = nid[1];
0518         __entry->nid[2] = nid[2];
0519         __entry->depth  = depth;
0520         __entry->err    = err;
0521     ),
0522 
0523     TP_printk("dev = (%d,%d), ino = %lu, "
0524         "nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
0525         show_dev_ino(__entry),
0526         (unsigned int)__entry->nid[0],
0527         (unsigned int)__entry->nid[1],
0528         (unsigned int)__entry->nid[2],
0529         __entry->depth,
0530         __entry->err)
0531 );
0532 
0533 TRACE_EVENT(f2fs_file_write_iter,
0534 
0535     TP_PROTO(struct inode *inode, loff_t offset, size_t length,
0536          ssize_t ret),
0537 
0538     TP_ARGS(inode, offset, length, ret),
0539 
0540     TP_STRUCT__entry(
0541         __field(dev_t,  dev)
0542         __field(ino_t,  ino)
0543         __field(loff_t, offset)
0544         __field(size_t, length)
0545         __field(ssize_t, ret)
0546     ),
0547 
0548     TP_fast_assign(
0549         __entry->dev    = inode->i_sb->s_dev;
0550         __entry->ino    = inode->i_ino;
0551         __entry->offset = offset;
0552         __entry->length = length;
0553         __entry->ret    = ret;
0554     ),
0555 
0556     TP_printk("dev = (%d,%d), ino = %lu, "
0557         "offset = %lld, length = %zu, written(err) = %zd",
0558         show_dev_ino(__entry),
0559         __entry->offset,
0560         __entry->length,
0561         __entry->ret)
0562 );
0563 
0564 TRACE_EVENT(f2fs_map_blocks,
0565     TP_PROTO(struct inode *inode, struct f2fs_map_blocks *map,
0566                 int create, int flag, int ret),
0567 
0568     TP_ARGS(inode, map, create, flag, ret),
0569 
0570     TP_STRUCT__entry(
0571         __field(dev_t,  dev)
0572         __field(ino_t,  ino)
0573         __field(block_t,    m_lblk)
0574         __field(block_t,    m_pblk)
0575         __field(unsigned int,   m_len)
0576         __field(unsigned int,   m_flags)
0577         __field(int,    m_seg_type)
0578         __field(bool,   m_may_create)
0579         __field(bool,   m_multidev_dio)
0580         __field(int,    create)
0581         __field(int,    flag)
0582         __field(int,    ret)
0583     ),
0584 
0585     TP_fast_assign(
0586         __entry->dev        = map->m_bdev->bd_dev;
0587         __entry->ino        = inode->i_ino;
0588         __entry->m_lblk     = map->m_lblk;
0589         __entry->m_pblk     = map->m_pblk;
0590         __entry->m_len      = map->m_len;
0591         __entry->m_flags    = map->m_flags;
0592         __entry->m_seg_type = map->m_seg_type;
0593         __entry->m_may_create   = map->m_may_create;
0594         __entry->m_multidev_dio = map->m_multidev_dio;
0595         __entry->create     = create;
0596         __entry->flag       = flag;
0597         __entry->ret        = ret;
0598     ),
0599 
0600     TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
0601         "start blkaddr = 0x%llx, len = 0x%llx, flags = %u, "
0602         "seg_type = %d, may_create = %d, multidevice = %d, "
0603         "create = %d, flag = %d, err = %d",
0604         show_dev_ino(__entry),
0605         (unsigned long long)__entry->m_lblk,
0606         (unsigned long long)__entry->m_pblk,
0607         (unsigned long long)__entry->m_len,
0608         __entry->m_flags,
0609         __entry->m_seg_type,
0610         __entry->m_may_create,
0611         __entry->m_multidev_dio,
0612         __entry->create,
0613         __entry->flag,
0614         __entry->ret)
0615 );
0616 
0617 TRACE_EVENT(f2fs_background_gc,
0618 
0619     TP_PROTO(struct super_block *sb, unsigned int wait_ms,
0620             unsigned int prefree, unsigned int free),
0621 
0622     TP_ARGS(sb, wait_ms, prefree, free),
0623 
0624     TP_STRUCT__entry(
0625         __field(dev_t,  dev)
0626         __field(unsigned int,   wait_ms)
0627         __field(unsigned int,   prefree)
0628         __field(unsigned int,   free)
0629     ),
0630 
0631     TP_fast_assign(
0632         __entry->dev        = sb->s_dev;
0633         __entry->wait_ms    = wait_ms;
0634         __entry->prefree    = prefree;
0635         __entry->free       = free;
0636     ),
0637 
0638     TP_printk("dev = (%d,%d), wait_ms = %u, prefree = %u, free = %u",
0639         show_dev(__entry->dev),
0640         __entry->wait_ms,
0641         __entry->prefree,
0642         __entry->free)
0643 );
0644 
0645 TRACE_EVENT(f2fs_gc_begin,
0646 
0647     TP_PROTO(struct super_block *sb, int gc_type, bool no_bg_gc,
0648             unsigned int nr_free_secs,
0649             long long dirty_nodes, long long dirty_dents,
0650             long long dirty_imeta, unsigned int free_sec,
0651             unsigned int free_seg, int reserved_seg,
0652             unsigned int prefree_seg),
0653 
0654     TP_ARGS(sb, gc_type, no_bg_gc, nr_free_secs, dirty_nodes,
0655         dirty_dents, dirty_imeta,
0656         free_sec, free_seg, reserved_seg, prefree_seg),
0657 
0658     TP_STRUCT__entry(
0659         __field(dev_t,      dev)
0660         __field(int,        gc_type)
0661         __field(bool,       no_bg_gc)
0662         __field(unsigned int,   nr_free_secs)
0663         __field(long long,  dirty_nodes)
0664         __field(long long,  dirty_dents)
0665         __field(long long,  dirty_imeta)
0666         __field(unsigned int,   free_sec)
0667         __field(unsigned int,   free_seg)
0668         __field(int,        reserved_seg)
0669         __field(unsigned int,   prefree_seg)
0670     ),
0671 
0672     TP_fast_assign(
0673         __entry->dev        = sb->s_dev;
0674         __entry->gc_type    = gc_type;
0675         __entry->no_bg_gc   = no_bg_gc;
0676         __entry->nr_free_secs   = nr_free_secs;
0677         __entry->dirty_nodes    = dirty_nodes;
0678         __entry->dirty_dents    = dirty_dents;
0679         __entry->dirty_imeta    = dirty_imeta;
0680         __entry->free_sec   = free_sec;
0681         __entry->free_seg   = free_seg;
0682         __entry->reserved_seg   = reserved_seg;
0683         __entry->prefree_seg    = prefree_seg;
0684     ),
0685 
0686     TP_printk("dev = (%d,%d), gc_type = %s, no_background_GC = %d, nr_free_secs = %u, "
0687         "nodes = %lld, dents = %lld, imeta = %lld, free_sec:%u, free_seg:%u, "
0688         "rsv_seg:%d, prefree_seg:%u",
0689         show_dev(__entry->dev),
0690         show_gc_type(__entry->gc_type),
0691         (__entry->gc_type == BG_GC) ? __entry->no_bg_gc : -1,
0692         __entry->nr_free_secs,
0693         __entry->dirty_nodes,
0694         __entry->dirty_dents,
0695         __entry->dirty_imeta,
0696         __entry->free_sec,
0697         __entry->free_seg,
0698         __entry->reserved_seg,
0699         __entry->prefree_seg)
0700 );
0701 
0702 TRACE_EVENT(f2fs_gc_end,
0703 
0704     TP_PROTO(struct super_block *sb, int ret, int seg_freed,
0705             int sec_freed, long long dirty_nodes,
0706             long long dirty_dents, long long dirty_imeta,
0707             unsigned int free_sec, unsigned int free_seg,
0708             int reserved_seg, unsigned int prefree_seg),
0709 
0710     TP_ARGS(sb, ret, seg_freed, sec_freed, dirty_nodes, dirty_dents,
0711         dirty_imeta, free_sec, free_seg, reserved_seg, prefree_seg),
0712 
0713     TP_STRUCT__entry(
0714         __field(dev_t,      dev)
0715         __field(int,        ret)
0716         __field(int,        seg_freed)
0717         __field(int,        sec_freed)
0718         __field(long long,  dirty_nodes)
0719         __field(long long,  dirty_dents)
0720         __field(long long,  dirty_imeta)
0721         __field(unsigned int,   free_sec)
0722         __field(unsigned int,   free_seg)
0723         __field(int,        reserved_seg)
0724         __field(unsigned int,   prefree_seg)
0725     ),
0726 
0727     TP_fast_assign(
0728         __entry->dev        = sb->s_dev;
0729         __entry->ret        = ret;
0730         __entry->seg_freed  = seg_freed;
0731         __entry->sec_freed  = sec_freed;
0732         __entry->dirty_nodes    = dirty_nodes;
0733         __entry->dirty_dents    = dirty_dents;
0734         __entry->dirty_imeta    = dirty_imeta;
0735         __entry->free_sec   = free_sec;
0736         __entry->free_seg   = free_seg;
0737         __entry->reserved_seg   = reserved_seg;
0738         __entry->prefree_seg    = prefree_seg;
0739     ),
0740 
0741     TP_printk("dev = (%d,%d), ret = %d, seg_freed = %d, sec_freed = %d, "
0742         "nodes = %lld, dents = %lld, imeta = %lld, free_sec:%u, "
0743         "free_seg:%u, rsv_seg:%d, prefree_seg:%u",
0744         show_dev(__entry->dev),
0745         __entry->ret,
0746         __entry->seg_freed,
0747         __entry->sec_freed,
0748         __entry->dirty_nodes,
0749         __entry->dirty_dents,
0750         __entry->dirty_imeta,
0751         __entry->free_sec,
0752         __entry->free_seg,
0753         __entry->reserved_seg,
0754         __entry->prefree_seg)
0755 );
0756 
0757 TRACE_EVENT(f2fs_get_victim,
0758 
0759     TP_PROTO(struct super_block *sb, int type, int gc_type,
0760             struct victim_sel_policy *p, unsigned int pre_victim,
0761             unsigned int prefree, unsigned int free),
0762 
0763     TP_ARGS(sb, type, gc_type, p, pre_victim, prefree, free),
0764 
0765     TP_STRUCT__entry(
0766         __field(dev_t,  dev)
0767         __field(int,    type)
0768         __field(int,    gc_type)
0769         __field(int,    alloc_mode)
0770         __field(int,    gc_mode)
0771         __field(unsigned int,   victim)
0772         __field(unsigned int,   cost)
0773         __field(unsigned int,   ofs_unit)
0774         __field(unsigned int,   pre_victim)
0775         __field(unsigned int,   prefree)
0776         __field(unsigned int,   free)
0777     ),
0778 
0779     TP_fast_assign(
0780         __entry->dev        = sb->s_dev;
0781         __entry->type       = type;
0782         __entry->gc_type    = gc_type;
0783         __entry->alloc_mode = p->alloc_mode;
0784         __entry->gc_mode    = p->gc_mode;
0785         __entry->victim     = p->min_segno;
0786         __entry->cost       = p->min_cost;
0787         __entry->ofs_unit   = p->ofs_unit;
0788         __entry->pre_victim = pre_victim;
0789         __entry->prefree    = prefree;
0790         __entry->free       = free;
0791     ),
0792 
0793     TP_printk("dev = (%d,%d), type = %s, policy = (%s, %s, %s), "
0794         "victim = %u, cost = %u, ofs_unit = %u, "
0795         "pre_victim_secno = %d, prefree = %u, free = %u",
0796         show_dev(__entry->dev),
0797         show_data_type(__entry->type),
0798         show_gc_type(__entry->gc_type),
0799         show_alloc_mode(__entry->alloc_mode),
0800         show_victim_policy(__entry->gc_mode),
0801         __entry->victim,
0802         __entry->cost,
0803         __entry->ofs_unit,
0804         (int)__entry->pre_victim,
0805         __entry->prefree,
0806         __entry->free)
0807 );
0808 
0809 TRACE_EVENT(f2fs_lookup_start,
0810 
0811     TP_PROTO(struct inode *dir, struct dentry *dentry, unsigned int flags),
0812 
0813     TP_ARGS(dir, dentry, flags),
0814 
0815     TP_STRUCT__entry(
0816         __field(dev_t,  dev)
0817         __field(ino_t,  ino)
0818         __string(name,  dentry->d_name.name)
0819         __field(unsigned int, flags)
0820     ),
0821 
0822     TP_fast_assign(
0823         __entry->dev    = dir->i_sb->s_dev;
0824         __entry->ino    = dir->i_ino;
0825         __assign_str(name, dentry->d_name.name);
0826         __entry->flags  = flags;
0827     ),
0828 
0829     TP_printk("dev = (%d,%d), pino = %lu, name:%s, flags:%u",
0830         show_dev_ino(__entry),
0831         __get_str(name),
0832         __entry->flags)
0833 );
0834 
0835 TRACE_EVENT(f2fs_lookup_end,
0836 
0837     TP_PROTO(struct inode *dir, struct dentry *dentry, nid_t ino,
0838         int err),
0839 
0840     TP_ARGS(dir, dentry, ino, err),
0841 
0842     TP_STRUCT__entry(
0843         __field(dev_t,  dev)
0844         __field(ino_t,  ino)
0845         __string(name,  dentry->d_name.name)
0846         __field(nid_t,  cino)
0847         __field(int,    err)
0848     ),
0849 
0850     TP_fast_assign(
0851         __entry->dev    = dir->i_sb->s_dev;
0852         __entry->ino    = dir->i_ino;
0853         __assign_str(name, dentry->d_name.name);
0854         __entry->cino   = ino;
0855         __entry->err    = err;
0856     ),
0857 
0858     TP_printk("dev = (%d,%d), pino = %lu, name:%s, ino:%u, err:%d",
0859         show_dev_ino(__entry),
0860         __get_str(name),
0861         __entry->cino,
0862         __entry->err)
0863 );
0864 
0865 TRACE_EVENT(f2fs_readdir,
0866 
0867     TP_PROTO(struct inode *dir, loff_t start_pos, loff_t end_pos, int err),
0868 
0869     TP_ARGS(dir, start_pos, end_pos, err),
0870 
0871     TP_STRUCT__entry(
0872         __field(dev_t,  dev)
0873         __field(ino_t,  ino)
0874         __field(loff_t, start)
0875         __field(loff_t, end)
0876         __field(int,    err)
0877     ),
0878 
0879     TP_fast_assign(
0880         __entry->dev    = dir->i_sb->s_dev;
0881         __entry->ino    = dir->i_ino;
0882         __entry->start  = start_pos;
0883         __entry->end    = end_pos;
0884         __entry->err    = err;
0885     ),
0886 
0887     TP_printk("dev = (%d,%d), ino = %lu, start_pos:%llu, end_pos:%llu, err:%d",
0888         show_dev_ino(__entry),
0889         __entry->start,
0890         __entry->end,
0891         __entry->err)
0892 );
0893 
0894 TRACE_EVENT(f2fs_fallocate,
0895 
0896     TP_PROTO(struct inode *inode, int mode,
0897                 loff_t offset, loff_t len, int ret),
0898 
0899     TP_ARGS(inode, mode, offset, len, ret),
0900 
0901     TP_STRUCT__entry(
0902         __field(dev_t,  dev)
0903         __field(ino_t,  ino)
0904         __field(int,    mode)
0905         __field(loff_t, offset)
0906         __field(loff_t, len)
0907         __field(loff_t, size)
0908         __field(blkcnt_t, blocks)
0909         __field(int,    ret)
0910     ),
0911 
0912     TP_fast_assign(
0913         __entry->dev    = inode->i_sb->s_dev;
0914         __entry->ino    = inode->i_ino;
0915         __entry->mode   = mode;
0916         __entry->offset = offset;
0917         __entry->len    = len;
0918         __entry->size   = inode->i_size;
0919         __entry->blocks = inode->i_blocks;
0920         __entry->ret    = ret;
0921     ),
0922 
0923     TP_printk("dev = (%d,%d), ino = %lu, mode = %x, offset = %lld, "
0924         "len = %lld,  i_size = %lld, i_blocks = %llu, ret = %d",
0925         show_dev_ino(__entry),
0926         __entry->mode,
0927         (unsigned long long)__entry->offset,
0928         (unsigned long long)__entry->len,
0929         (unsigned long long)__entry->size,
0930         (unsigned long long)__entry->blocks,
0931         __entry->ret)
0932 );
0933 
0934 TRACE_EVENT(f2fs_direct_IO_enter,
0935 
0936     TP_PROTO(struct inode *inode, struct kiocb *iocb, long len, int rw),
0937 
0938     TP_ARGS(inode, iocb, len, rw),
0939 
0940     TP_STRUCT__entry(
0941         __field(dev_t,  dev)
0942         __field(ino_t,  ino)
0943         __field(struct kiocb *, iocb)
0944         __field(unsigned long,  len)
0945         __field(int,    rw)
0946     ),
0947 
0948     TP_fast_assign(
0949         __entry->dev    = inode->i_sb->s_dev;
0950         __entry->ino    = inode->i_ino;
0951         __entry->iocb   = iocb;
0952         __entry->len    = len;
0953         __entry->rw = rw;
0954     ),
0955 
0956     TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu ki_flags = %x ki_ioprio = %x rw = %d",
0957         show_dev_ino(__entry),
0958         __entry->iocb->ki_pos,
0959         __entry->len,
0960         __entry->iocb->ki_flags,
0961         __entry->iocb->ki_ioprio,
0962         __entry->rw)
0963 );
0964 
0965 TRACE_EVENT(f2fs_direct_IO_exit,
0966 
0967     TP_PROTO(struct inode *inode, loff_t offset, unsigned long len,
0968          int rw, int ret),
0969 
0970     TP_ARGS(inode, offset, len, rw, ret),
0971 
0972     TP_STRUCT__entry(
0973         __field(dev_t,  dev)
0974         __field(ino_t,  ino)
0975         __field(loff_t, pos)
0976         __field(unsigned long,  len)
0977         __field(int,    rw)
0978         __field(int,    ret)
0979     ),
0980 
0981     TP_fast_assign(
0982         __entry->dev    = inode->i_sb->s_dev;
0983         __entry->ino    = inode->i_ino;
0984         __entry->pos    = offset;
0985         __entry->len    = len;
0986         __entry->rw = rw;
0987         __entry->ret    = ret;
0988     ),
0989 
0990     TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu "
0991         "rw = %d ret = %d",
0992         show_dev_ino(__entry),
0993         __entry->pos,
0994         __entry->len,
0995         __entry->rw,
0996         __entry->ret)
0997 );
0998 
0999 TRACE_EVENT(f2fs_reserve_new_blocks,
1000 
1001     TP_PROTO(struct inode *inode, nid_t nid, unsigned int ofs_in_node,
1002                             blkcnt_t count),
1003 
1004     TP_ARGS(inode, nid, ofs_in_node, count),
1005 
1006     TP_STRUCT__entry(
1007         __field(dev_t,  dev)
1008         __field(nid_t, nid)
1009         __field(unsigned int, ofs_in_node)
1010         __field(blkcnt_t, count)
1011     ),
1012 
1013     TP_fast_assign(
1014         __entry->dev    = inode->i_sb->s_dev;
1015         __entry->nid    = nid;
1016         __entry->ofs_in_node = ofs_in_node;
1017         __entry->count = count;
1018     ),
1019 
1020     TP_printk("dev = (%d,%d), nid = %u, ofs_in_node = %u, count = %llu",
1021         show_dev(__entry->dev),
1022         (unsigned int)__entry->nid,
1023         __entry->ofs_in_node,
1024         (unsigned long long)__entry->count)
1025 );
1026 
1027 DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
1028 
1029     TP_PROTO(struct page *page, struct f2fs_io_info *fio),
1030 
1031     TP_ARGS(page, fio),
1032 
1033     TP_STRUCT__entry(
1034         __field(dev_t, dev)
1035         __field(ino_t, ino)
1036         __field(pgoff_t, index)
1037         __field(block_t, old_blkaddr)
1038         __field(block_t, new_blkaddr)
1039         __field(enum req_op, op)
1040         __field(blk_opf_t, op_flags)
1041         __field(int, temp)
1042         __field(int, type)
1043     ),
1044 
1045     TP_fast_assign(
1046         __entry->dev        = page_file_mapping(page)->host->i_sb->s_dev;
1047         __entry->ino        = page_file_mapping(page)->host->i_ino;
1048         __entry->index      = page->index;
1049         __entry->old_blkaddr    = fio->old_blkaddr;
1050         __entry->new_blkaddr    = fio->new_blkaddr;
1051         __entry->op     = fio->op;
1052         __entry->op_flags   = fio->op_flags;
1053         __entry->temp       = fio->temp;
1054         __entry->type       = fio->type;
1055     ),
1056 
1057     TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
1058         "oldaddr = 0x%llx, newaddr = 0x%llx, rw = %s(%s), type = %s_%s",
1059         show_dev_ino(__entry),
1060         (unsigned long)__entry->index,
1061         (unsigned long long)__entry->old_blkaddr,
1062         (unsigned long long)__entry->new_blkaddr,
1063         show_bio_type(__entry->op, __entry->op_flags),
1064         show_block_temp(__entry->temp),
1065         show_block_type(__entry->type))
1066 );
1067 
1068 DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_bio,
1069 
1070     TP_PROTO(struct page *page, struct f2fs_io_info *fio),
1071 
1072     TP_ARGS(page, fio),
1073 
1074     TP_CONDITION(page->mapping)
1075 );
1076 
1077 DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_write,
1078 
1079     TP_PROTO(struct page *page, struct f2fs_io_info *fio),
1080 
1081     TP_ARGS(page, fio),
1082 
1083     TP_CONDITION(page->mapping)
1084 );
1085 
1086 DECLARE_EVENT_CLASS(f2fs__bio,
1087 
1088     TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1089 
1090     TP_ARGS(sb, type, bio),
1091 
1092     TP_STRUCT__entry(
1093         __field(dev_t,  dev)
1094         __field(dev_t,  target)
1095         __field(enum req_op,    op)
1096         __field(blk_opf_t,  op_flags)
1097         __field(int,    type)
1098         __field(sector_t,   sector)
1099         __field(unsigned int,   size)
1100     ),
1101 
1102     TP_fast_assign(
1103         __entry->dev        = sb->s_dev;
1104         __entry->target     = bio_dev(bio);
1105         __entry->op     = bio_op(bio);
1106         __entry->op_flags   = bio->bi_opf;
1107         __entry->type       = type;
1108         __entry->sector     = bio->bi_iter.bi_sector;
1109         __entry->size       = bio->bi_iter.bi_size;
1110     ),
1111 
1112     TP_printk("dev = (%d,%d)/(%d,%d), rw = %s(%s), %s, sector = %lld, size = %u",
1113         show_dev(__entry->target),
1114         show_dev(__entry->dev),
1115         show_bio_type(__entry->op, __entry->op_flags),
1116         show_block_type(__entry->type),
1117         (unsigned long long)__entry->sector,
1118         __entry->size)
1119 );
1120 
1121 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_write_bio,
1122 
1123     TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1124 
1125     TP_ARGS(sb, type, bio),
1126 
1127     TP_CONDITION(bio)
1128 );
1129 
1130 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_prepare_read_bio,
1131 
1132     TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1133 
1134     TP_ARGS(sb, type, bio),
1135 
1136     TP_CONDITION(bio)
1137 );
1138 
1139 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_read_bio,
1140 
1141     TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1142 
1143     TP_ARGS(sb, type, bio),
1144 
1145     TP_CONDITION(bio)
1146 );
1147 
1148 DEFINE_EVENT_CONDITION(f2fs__bio, f2fs_submit_write_bio,
1149 
1150     TP_PROTO(struct super_block *sb, int type, struct bio *bio),
1151 
1152     TP_ARGS(sb, type, bio),
1153 
1154     TP_CONDITION(bio)
1155 );
1156 
1157 TRACE_EVENT(f2fs_write_begin,
1158 
1159     TP_PROTO(struct inode *inode, loff_t pos, unsigned int len),
1160 
1161     TP_ARGS(inode, pos, len),
1162 
1163     TP_STRUCT__entry(
1164         __field(dev_t,  dev)
1165         __field(ino_t,  ino)
1166         __field(loff_t, pos)
1167         __field(unsigned int, len)
1168     ),
1169 
1170     TP_fast_assign(
1171         __entry->dev    = inode->i_sb->s_dev;
1172         __entry->ino    = inode->i_ino;
1173         __entry->pos    = pos;
1174         __entry->len    = len;
1175     ),
1176 
1177     TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u",
1178         show_dev_ino(__entry),
1179         (unsigned long long)__entry->pos,
1180         __entry->len)
1181 );
1182 
1183 TRACE_EVENT(f2fs_write_end,
1184 
1185     TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
1186                 unsigned int copied),
1187 
1188     TP_ARGS(inode, pos, len, copied),
1189 
1190     TP_STRUCT__entry(
1191         __field(dev_t,  dev)
1192         __field(ino_t,  ino)
1193         __field(loff_t, pos)
1194         __field(unsigned int, len)
1195         __field(unsigned int, copied)
1196     ),
1197 
1198     TP_fast_assign(
1199         __entry->dev    = inode->i_sb->s_dev;
1200         __entry->ino    = inode->i_ino;
1201         __entry->pos    = pos;
1202         __entry->len    = len;
1203         __entry->copied = copied;
1204     ),
1205 
1206     TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, copied = %u",
1207         show_dev_ino(__entry),
1208         (unsigned long long)__entry->pos,
1209         __entry->len,
1210         __entry->copied)
1211 );
1212 
1213 DECLARE_EVENT_CLASS(f2fs__page,
1214 
1215     TP_PROTO(struct page *page, int type),
1216 
1217     TP_ARGS(page, type),
1218 
1219     TP_STRUCT__entry(
1220         __field(dev_t,  dev)
1221         __field(ino_t,  ino)
1222         __field(int, type)
1223         __field(int, dir)
1224         __field(pgoff_t, index)
1225         __field(int, dirty)
1226         __field(int, uptodate)
1227     ),
1228 
1229     TP_fast_assign(
1230         __entry->dev    = page_file_mapping(page)->host->i_sb->s_dev;
1231         __entry->ino    = page_file_mapping(page)->host->i_ino;
1232         __entry->type   = type;
1233         __entry->dir    =
1234             S_ISDIR(page_file_mapping(page)->host->i_mode);
1235         __entry->index  = page->index;
1236         __entry->dirty  = PageDirty(page);
1237         __entry->uptodate = PageUptodate(page);
1238     ),
1239 
1240     TP_printk("dev = (%d,%d), ino = %lu, %s, %s, index = %lu, "
1241         "dirty = %d, uptodate = %d",
1242         show_dev_ino(__entry),
1243         show_block_type(__entry->type),
1244         show_file_type(__entry->dir),
1245         (unsigned long)__entry->index,
1246         __entry->dirty,
1247         __entry->uptodate)
1248 );
1249 
1250 DEFINE_EVENT(f2fs__page, f2fs_writepage,
1251 
1252     TP_PROTO(struct page *page, int type),
1253 
1254     TP_ARGS(page, type)
1255 );
1256 
1257 DEFINE_EVENT(f2fs__page, f2fs_do_write_data_page,
1258 
1259     TP_PROTO(struct page *page, int type),
1260 
1261     TP_ARGS(page, type)
1262 );
1263 
1264 DEFINE_EVENT(f2fs__page, f2fs_readpage,
1265 
1266     TP_PROTO(struct page *page, int type),
1267 
1268     TP_ARGS(page, type)
1269 );
1270 
1271 DEFINE_EVENT(f2fs__page, f2fs_set_page_dirty,
1272 
1273     TP_PROTO(struct page *page, int type),
1274 
1275     TP_ARGS(page, type)
1276 );
1277 
1278 DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite,
1279 
1280     TP_PROTO(struct page *page, int type),
1281 
1282     TP_ARGS(page, type)
1283 );
1284 
1285 TRACE_EVENT(f2fs_filemap_fault,
1286 
1287     TP_PROTO(struct inode *inode, pgoff_t index, unsigned long ret),
1288 
1289     TP_ARGS(inode, index, ret),
1290 
1291     TP_STRUCT__entry(
1292         __field(dev_t,  dev)
1293         __field(ino_t,  ino)
1294         __field(pgoff_t, index)
1295         __field(unsigned long, ret)
1296     ),
1297 
1298     TP_fast_assign(
1299         __entry->dev    = inode->i_sb->s_dev;
1300         __entry->ino    = inode->i_ino;
1301         __entry->index  = index;
1302         __entry->ret    = ret;
1303     ),
1304 
1305     TP_printk("dev = (%d,%d), ino = %lu, index = %lu, ret = %lx",
1306         show_dev_ino(__entry),
1307         (unsigned long)__entry->index,
1308         __entry->ret)
1309 );
1310 
1311 TRACE_EVENT(f2fs_writepages,
1312 
1313     TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type),
1314 
1315     TP_ARGS(inode, wbc, type),
1316 
1317     TP_STRUCT__entry(
1318         __field(dev_t,  dev)
1319         __field(ino_t,  ino)
1320         __field(int,    type)
1321         __field(int,    dir)
1322         __field(long,   nr_to_write)
1323         __field(long,   pages_skipped)
1324         __field(loff_t, range_start)
1325         __field(loff_t, range_end)
1326         __field(pgoff_t, writeback_index)
1327         __field(int,    sync_mode)
1328         __field(char,   for_kupdate)
1329         __field(char,   for_background)
1330         __field(char,   tagged_writepages)
1331         __field(char,   for_reclaim)
1332         __field(char,   range_cyclic)
1333         __field(char,   for_sync)
1334     ),
1335 
1336     TP_fast_assign(
1337         __entry->dev        = inode->i_sb->s_dev;
1338         __entry->ino        = inode->i_ino;
1339         __entry->type       = type;
1340         __entry->dir        = S_ISDIR(inode->i_mode);
1341         __entry->nr_to_write    = wbc->nr_to_write;
1342         __entry->pages_skipped  = wbc->pages_skipped;
1343         __entry->range_start    = wbc->range_start;
1344         __entry->range_end  = wbc->range_end;
1345         __entry->writeback_index = inode->i_mapping->writeback_index;
1346         __entry->sync_mode  = wbc->sync_mode;
1347         __entry->for_kupdate    = wbc->for_kupdate;
1348         __entry->for_background = wbc->for_background;
1349         __entry->tagged_writepages  = wbc->tagged_writepages;
1350         __entry->for_reclaim    = wbc->for_reclaim;
1351         __entry->range_cyclic   = wbc->range_cyclic;
1352         __entry->for_sync   = wbc->for_sync;
1353     ),
1354 
1355     TP_printk("dev = (%d,%d), ino = %lu, %s, %s, nr_to_write %ld, "
1356         "skipped %ld, start %lld, end %lld, wb_idx %lu, sync_mode %d, "
1357         "kupdate %u background %u tagged %u reclaim %u cyclic %u sync %u",
1358         show_dev_ino(__entry),
1359         show_block_type(__entry->type),
1360         show_file_type(__entry->dir),
1361         __entry->nr_to_write,
1362         __entry->pages_skipped,
1363         __entry->range_start,
1364         __entry->range_end,
1365         (unsigned long)__entry->writeback_index,
1366         __entry->sync_mode,
1367         __entry->for_kupdate,
1368         __entry->for_background,
1369         __entry->tagged_writepages,
1370         __entry->for_reclaim,
1371         __entry->range_cyclic,
1372         __entry->for_sync)
1373 );
1374 
1375 TRACE_EVENT(f2fs_readpages,
1376 
1377     TP_PROTO(struct inode *inode, pgoff_t start, unsigned int nrpage),
1378 
1379     TP_ARGS(inode, start, nrpage),
1380 
1381     TP_STRUCT__entry(
1382         __field(dev_t,  dev)
1383         __field(ino_t,  ino)
1384         __field(pgoff_t,    start)
1385         __field(unsigned int,   nrpage)
1386     ),
1387 
1388     TP_fast_assign(
1389         __entry->dev    = inode->i_sb->s_dev;
1390         __entry->ino    = inode->i_ino;
1391         __entry->start  = start;
1392         __entry->nrpage = nrpage;
1393     ),
1394 
1395     TP_printk("dev = (%d,%d), ino = %lu, start = %lu nrpage = %u",
1396         show_dev_ino(__entry),
1397         (unsigned long)__entry->start,
1398         __entry->nrpage)
1399 );
1400 
1401 TRACE_EVENT(f2fs_write_checkpoint,
1402 
1403     TP_PROTO(struct super_block *sb, int reason, char *msg),
1404 
1405     TP_ARGS(sb, reason, msg),
1406 
1407     TP_STRUCT__entry(
1408         __field(dev_t,  dev)
1409         __field(int,    reason)
1410         __field(char *, msg)
1411     ),
1412 
1413     TP_fast_assign(
1414         __entry->dev        = sb->s_dev;
1415         __entry->reason     = reason;
1416         __entry->msg        = msg;
1417     ),
1418 
1419     TP_printk("dev = (%d,%d), checkpoint for %s, state = %s",
1420         show_dev(__entry->dev),
1421         show_cpreason(__entry->reason),
1422         __entry->msg)
1423 );
1424 
1425 DECLARE_EVENT_CLASS(f2fs_discard,
1426 
1427     TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1428 
1429     TP_ARGS(dev, blkstart, blklen),
1430 
1431     TP_STRUCT__entry(
1432         __field(dev_t,  dev)
1433         __field(block_t, blkstart)
1434         __field(block_t, blklen)
1435     ),
1436 
1437     TP_fast_assign(
1438         __entry->dev    = dev->bd_dev;
1439         __entry->blkstart = blkstart;
1440         __entry->blklen = blklen;
1441     ),
1442 
1443     TP_printk("dev = (%d,%d), blkstart = 0x%llx, blklen = 0x%llx",
1444         show_dev(__entry->dev),
1445         (unsigned long long)__entry->blkstart,
1446         (unsigned long long)__entry->blklen)
1447 );
1448 
1449 DEFINE_EVENT(f2fs_discard, f2fs_queue_discard,
1450 
1451     TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1452 
1453     TP_ARGS(dev, blkstart, blklen)
1454 );
1455 
1456 DEFINE_EVENT(f2fs_discard, f2fs_issue_discard,
1457 
1458     TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1459 
1460     TP_ARGS(dev, blkstart, blklen)
1461 );
1462 
1463 DEFINE_EVENT(f2fs_discard, f2fs_remove_discard,
1464 
1465     TP_PROTO(struct block_device *dev, block_t blkstart, block_t blklen),
1466 
1467     TP_ARGS(dev, blkstart, blklen)
1468 );
1469 
1470 TRACE_EVENT(f2fs_issue_reset_zone,
1471 
1472     TP_PROTO(struct block_device *dev, block_t blkstart),
1473 
1474     TP_ARGS(dev, blkstart),
1475 
1476     TP_STRUCT__entry(
1477         __field(dev_t,  dev)
1478         __field(block_t, blkstart)
1479     ),
1480 
1481     TP_fast_assign(
1482         __entry->dev    = dev->bd_dev;
1483         __entry->blkstart = blkstart;
1484     ),
1485 
1486     TP_printk("dev = (%d,%d), reset zone at block = 0x%llx",
1487         show_dev(__entry->dev),
1488         (unsigned long long)__entry->blkstart)
1489 );
1490 
1491 TRACE_EVENT(f2fs_issue_flush,
1492 
1493     TP_PROTO(struct block_device *dev, unsigned int nobarrier,
1494                 unsigned int flush_merge, int ret),
1495 
1496     TP_ARGS(dev, nobarrier, flush_merge, ret),
1497 
1498     TP_STRUCT__entry(
1499         __field(dev_t,  dev)
1500         __field(unsigned int, nobarrier)
1501         __field(unsigned int, flush_merge)
1502         __field(int,  ret)
1503     ),
1504 
1505     TP_fast_assign(
1506         __entry->dev    = dev->bd_dev;
1507         __entry->nobarrier = nobarrier;
1508         __entry->flush_merge = flush_merge;
1509         __entry->ret = ret;
1510     ),
1511 
1512     TP_printk("dev = (%d,%d), %s %s, ret = %d",
1513         show_dev(__entry->dev),
1514         __entry->nobarrier ? "skip (nobarrier)" : "issue",
1515         __entry->flush_merge ? " with flush_merge" : "",
1516         __entry->ret)
1517 );
1518 
1519 TRACE_EVENT(f2fs_lookup_extent_tree_start,
1520 
1521     TP_PROTO(struct inode *inode, unsigned int pgofs),
1522 
1523     TP_ARGS(inode, pgofs),
1524 
1525     TP_STRUCT__entry(
1526         __field(dev_t,  dev)
1527         __field(ino_t,  ino)
1528         __field(unsigned int, pgofs)
1529     ),
1530 
1531     TP_fast_assign(
1532         __entry->dev = inode->i_sb->s_dev;
1533         __entry->ino = inode->i_ino;
1534         __entry->pgofs = pgofs;
1535     ),
1536 
1537     TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u",
1538         show_dev_ino(__entry),
1539         __entry->pgofs)
1540 );
1541 
1542 TRACE_EVENT_CONDITION(f2fs_lookup_extent_tree_end,
1543 
1544     TP_PROTO(struct inode *inode, unsigned int pgofs,
1545                         struct extent_info *ei),
1546 
1547     TP_ARGS(inode, pgofs, ei),
1548 
1549     TP_CONDITION(ei),
1550 
1551     TP_STRUCT__entry(
1552         __field(dev_t,  dev)
1553         __field(ino_t,  ino)
1554         __field(unsigned int, pgofs)
1555         __field(unsigned int, fofs)
1556         __field(u32, blk)
1557         __field(unsigned int, len)
1558     ),
1559 
1560     TP_fast_assign(
1561         __entry->dev = inode->i_sb->s_dev;
1562         __entry->ino = inode->i_ino;
1563         __entry->pgofs = pgofs;
1564         __entry->fofs = ei->fofs;
1565         __entry->blk = ei->blk;
1566         __entry->len = ei->len;
1567     ),
1568 
1569     TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1570         "ext_info(fofs: %u, blk: %u, len: %u)",
1571         show_dev_ino(__entry),
1572         __entry->pgofs,
1573         __entry->fofs,
1574         __entry->blk,
1575         __entry->len)
1576 );
1577 
1578 TRACE_EVENT(f2fs_update_extent_tree_range,
1579 
1580     TP_PROTO(struct inode *inode, unsigned int pgofs, block_t blkaddr,
1581                         unsigned int len),
1582 
1583     TP_ARGS(inode, pgofs, blkaddr, len),
1584 
1585     TP_STRUCT__entry(
1586         __field(dev_t,  dev)
1587         __field(ino_t,  ino)
1588         __field(unsigned int, pgofs)
1589         __field(u32, blk)
1590         __field(unsigned int, len)
1591     ),
1592 
1593     TP_fast_assign(
1594         __entry->dev = inode->i_sb->s_dev;
1595         __entry->ino = inode->i_ino;
1596         __entry->pgofs = pgofs;
1597         __entry->blk = blkaddr;
1598         __entry->len = len;
1599     ),
1600 
1601     TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1602                     "blkaddr = %u, len = %u",
1603         show_dev_ino(__entry),
1604         __entry->pgofs,
1605         __entry->blk,
1606         __entry->len)
1607 );
1608 
1609 TRACE_EVENT(f2fs_shrink_extent_tree,
1610 
1611     TP_PROTO(struct f2fs_sb_info *sbi, unsigned int node_cnt,
1612                         unsigned int tree_cnt),
1613 
1614     TP_ARGS(sbi, node_cnt, tree_cnt),
1615 
1616     TP_STRUCT__entry(
1617         __field(dev_t,  dev)
1618         __field(unsigned int, node_cnt)
1619         __field(unsigned int, tree_cnt)
1620     ),
1621 
1622     TP_fast_assign(
1623         __entry->dev = sbi->sb->s_dev;
1624         __entry->node_cnt = node_cnt;
1625         __entry->tree_cnt = tree_cnt;
1626     ),
1627 
1628     TP_printk("dev = (%d,%d), shrunk: node_cnt = %u, tree_cnt = %u",
1629         show_dev(__entry->dev),
1630         __entry->node_cnt,
1631         __entry->tree_cnt)
1632 );
1633 
1634 TRACE_EVENT(f2fs_destroy_extent_tree,
1635 
1636     TP_PROTO(struct inode *inode, unsigned int node_cnt),
1637 
1638     TP_ARGS(inode, node_cnt),
1639 
1640     TP_STRUCT__entry(
1641         __field(dev_t,  dev)
1642         __field(ino_t,  ino)
1643         __field(unsigned int, node_cnt)
1644     ),
1645 
1646     TP_fast_assign(
1647         __entry->dev = inode->i_sb->s_dev;
1648         __entry->ino = inode->i_ino;
1649         __entry->node_cnt = node_cnt;
1650     ),
1651 
1652     TP_printk("dev = (%d,%d), ino = %lu, destroyed: node_cnt = %u",
1653         show_dev_ino(__entry),
1654         __entry->node_cnt)
1655 );
1656 
1657 DECLARE_EVENT_CLASS(f2fs_sync_dirty_inodes,
1658 
1659     TP_PROTO(struct super_block *sb, int type, s64 count),
1660 
1661     TP_ARGS(sb, type, count),
1662 
1663     TP_STRUCT__entry(
1664         __field(dev_t, dev)
1665         __field(int, type)
1666         __field(s64, count)
1667     ),
1668 
1669     TP_fast_assign(
1670         __entry->dev    = sb->s_dev;
1671         __entry->type   = type;
1672         __entry->count  = count;
1673     ),
1674 
1675     TP_printk("dev = (%d,%d), %s, dirty count = %lld",
1676         show_dev(__entry->dev),
1677         show_file_type(__entry->type),
1678         __entry->count)
1679 );
1680 
1681 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_enter,
1682 
1683     TP_PROTO(struct super_block *sb, int type, s64 count),
1684 
1685     TP_ARGS(sb, type, count)
1686 );
1687 
1688 DEFINE_EVENT(f2fs_sync_dirty_inodes, f2fs_sync_dirty_inodes_exit,
1689 
1690     TP_PROTO(struct super_block *sb, int type, s64 count),
1691 
1692     TP_ARGS(sb, type, count)
1693 );
1694 
1695 TRACE_EVENT(f2fs_shutdown,
1696 
1697     TP_PROTO(struct f2fs_sb_info *sbi, unsigned int mode, int ret),
1698 
1699     TP_ARGS(sbi, mode, ret),
1700 
1701     TP_STRUCT__entry(
1702         __field(dev_t,  dev)
1703         __field(unsigned int, mode)
1704         __field(int, ret)
1705     ),
1706 
1707     TP_fast_assign(
1708         __entry->dev = sbi->sb->s_dev;
1709         __entry->mode = mode;
1710         __entry->ret = ret;
1711     ),
1712 
1713     TP_printk("dev = (%d,%d), mode: %s, ret:%d",
1714         show_dev(__entry->dev),
1715         show_shutdown_mode(__entry->mode),
1716         __entry->ret)
1717 );
1718 
1719 DECLARE_EVENT_CLASS(f2fs_zip_start,
1720 
1721     TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1722             unsigned int cluster_size, unsigned char algtype),
1723 
1724     TP_ARGS(inode, cluster_idx, cluster_size, algtype),
1725 
1726     TP_STRUCT__entry(
1727         __field(dev_t,  dev)
1728         __field(ino_t,  ino)
1729         __field(pgoff_t, idx)
1730         __field(unsigned int, size)
1731         __field(unsigned int, algtype)
1732     ),
1733 
1734     TP_fast_assign(
1735         __entry->dev = inode->i_sb->s_dev;
1736         __entry->ino = inode->i_ino;
1737         __entry->idx = cluster_idx;
1738         __entry->size = cluster_size;
1739         __entry->algtype = algtype;
1740     ),
1741 
1742     TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%lu, "
1743         "cluster_size = %u, algorithm = %s",
1744         show_dev_ino(__entry),
1745         __entry->idx,
1746         __entry->size,
1747         show_compress_algorithm(__entry->algtype))
1748 );
1749 
1750 DECLARE_EVENT_CLASS(f2fs_zip_end,
1751 
1752     TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1753             unsigned int compressed_size, int ret),
1754 
1755     TP_ARGS(inode, cluster_idx, compressed_size, ret),
1756 
1757     TP_STRUCT__entry(
1758         __field(dev_t,  dev)
1759         __field(ino_t,  ino)
1760         __field(pgoff_t, idx)
1761         __field(unsigned int, size)
1762         __field(unsigned int, ret)
1763     ),
1764 
1765     TP_fast_assign(
1766         __entry->dev = inode->i_sb->s_dev;
1767         __entry->ino = inode->i_ino;
1768         __entry->idx = cluster_idx;
1769         __entry->size = compressed_size;
1770         __entry->ret = ret;
1771     ),
1772 
1773     TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%lu, "
1774         "compressed_size = %u, ret = %d",
1775         show_dev_ino(__entry),
1776         __entry->idx,
1777         __entry->size,
1778         __entry->ret)
1779 );
1780 
1781 DEFINE_EVENT(f2fs_zip_start, f2fs_compress_pages_start,
1782 
1783     TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1784         unsigned int cluster_size, unsigned char algtype),
1785 
1786     TP_ARGS(inode, cluster_idx, cluster_size, algtype)
1787 );
1788 
1789 DEFINE_EVENT(f2fs_zip_start, f2fs_decompress_pages_start,
1790 
1791     TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1792         unsigned int cluster_size, unsigned char algtype),
1793 
1794     TP_ARGS(inode, cluster_idx, cluster_size, algtype)
1795 );
1796 
1797 DEFINE_EVENT(f2fs_zip_end, f2fs_compress_pages_end,
1798 
1799     TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1800             unsigned int compressed_size, int ret),
1801 
1802     TP_ARGS(inode, cluster_idx, compressed_size, ret)
1803 );
1804 
1805 DEFINE_EVENT(f2fs_zip_end, f2fs_decompress_pages_end,
1806 
1807     TP_PROTO(struct inode *inode, pgoff_t cluster_idx,
1808             unsigned int compressed_size, int ret),
1809 
1810     TP_ARGS(inode, cluster_idx, compressed_size, ret)
1811 );
1812 
1813 #ifdef CONFIG_F2FS_IOSTAT
1814 TRACE_EVENT(f2fs_iostat,
1815 
1816     TP_PROTO(struct f2fs_sb_info *sbi, unsigned long long *iostat),
1817 
1818     TP_ARGS(sbi, iostat),
1819 
1820     TP_STRUCT__entry(
1821         __field(dev_t,  dev)
1822         __field(unsigned long long, app_dio)
1823         __field(unsigned long long, app_bio)
1824         __field(unsigned long long, app_wio)
1825         __field(unsigned long long, app_mio)
1826         __field(unsigned long long, fs_dio)
1827         __field(unsigned long long, fs_nio)
1828         __field(unsigned long long, fs_mio)
1829         __field(unsigned long long, fs_gc_dio)
1830         __field(unsigned long long, fs_gc_nio)
1831         __field(unsigned long long, fs_cp_dio)
1832         __field(unsigned long long, fs_cp_nio)
1833         __field(unsigned long long, fs_cp_mio)
1834         __field(unsigned long long, app_drio)
1835         __field(unsigned long long, app_brio)
1836         __field(unsigned long long, app_rio)
1837         __field(unsigned long long, app_mrio)
1838         __field(unsigned long long, fs_drio)
1839         __field(unsigned long long, fs_gdrio)
1840         __field(unsigned long long, fs_cdrio)
1841         __field(unsigned long long, fs_nrio)
1842         __field(unsigned long long, fs_mrio)
1843         __field(unsigned long long, fs_discard)
1844     ),
1845 
1846     TP_fast_assign(
1847         __entry->dev        = sbi->sb->s_dev;
1848         __entry->app_dio    = iostat[APP_DIRECT_IO];
1849         __entry->app_bio    = iostat[APP_BUFFERED_IO];
1850         __entry->app_wio    = iostat[APP_WRITE_IO];
1851         __entry->app_mio    = iostat[APP_MAPPED_IO];
1852         __entry->fs_dio     = iostat[FS_DATA_IO];
1853         __entry->fs_nio     = iostat[FS_NODE_IO];
1854         __entry->fs_mio     = iostat[FS_META_IO];
1855         __entry->fs_gc_dio  = iostat[FS_GC_DATA_IO];
1856         __entry->fs_gc_nio  = iostat[FS_GC_NODE_IO];
1857         __entry->fs_cp_dio  = iostat[FS_CP_DATA_IO];
1858         __entry->fs_cp_nio  = iostat[FS_CP_NODE_IO];
1859         __entry->fs_cp_mio  = iostat[FS_CP_META_IO];
1860         __entry->app_drio   = iostat[APP_DIRECT_READ_IO];
1861         __entry->app_brio   = iostat[APP_BUFFERED_READ_IO];
1862         __entry->app_rio    = iostat[APP_READ_IO];
1863         __entry->app_mrio   = iostat[APP_MAPPED_READ_IO];
1864         __entry->fs_drio    = iostat[FS_DATA_READ_IO];
1865         __entry->fs_gdrio   = iostat[FS_GDATA_READ_IO];
1866         __entry->fs_cdrio   = iostat[FS_CDATA_READ_IO];
1867         __entry->fs_nrio    = iostat[FS_NODE_READ_IO];
1868         __entry->fs_mrio    = iostat[FS_META_READ_IO];
1869         __entry->fs_discard = iostat[FS_DISCARD];
1870     ),
1871 
1872     TP_printk("dev = (%d,%d), "
1873         "app [write=%llu (direct=%llu, buffered=%llu), mapped=%llu], "
1874         "fs [data=%llu, node=%llu, meta=%llu, discard=%llu], "
1875         "gc [data=%llu, node=%llu], "
1876         "cp [data=%llu, node=%llu, meta=%llu], "
1877         "app [read=%llu (direct=%llu, buffered=%llu), mapped=%llu], "
1878         "fs [data=%llu, (gc_data=%llu, compr_data=%llu), "
1879         "node=%llu, meta=%llu]",
1880         show_dev(__entry->dev), __entry->app_wio, __entry->app_dio,
1881         __entry->app_bio, __entry->app_mio, __entry->fs_dio,
1882         __entry->fs_nio, __entry->fs_mio, __entry->fs_discard,
1883         __entry->fs_gc_dio, __entry->fs_gc_nio, __entry->fs_cp_dio,
1884         __entry->fs_cp_nio, __entry->fs_cp_mio,
1885         __entry->app_rio, __entry->app_drio, __entry->app_brio,
1886         __entry->app_mrio, __entry->fs_drio, __entry->fs_gdrio,
1887         __entry->fs_cdrio, __entry->fs_nrio, __entry->fs_mrio)
1888 );
1889 
1890 #ifndef __F2FS_IOSTAT_LATENCY_TYPE
1891 #define __F2FS_IOSTAT_LATENCY_TYPE
1892 struct f2fs_iostat_latency {
1893     unsigned int peak_lat;
1894     unsigned int avg_lat;
1895     unsigned int cnt;
1896 };
1897 #endif /* __F2FS_IOSTAT_LATENCY_TYPE */
1898 
1899 TRACE_EVENT(f2fs_iostat_latency,
1900 
1901     TP_PROTO(struct f2fs_sb_info *sbi, struct f2fs_iostat_latency (*iostat_lat)[NR_PAGE_TYPE]),
1902 
1903     TP_ARGS(sbi, iostat_lat),
1904 
1905     TP_STRUCT__entry(
1906         __field(dev_t,  dev)
1907         __field(unsigned int,   d_rd_peak)
1908         __field(unsigned int,   d_rd_avg)
1909         __field(unsigned int,   d_rd_cnt)
1910         __field(unsigned int,   n_rd_peak)
1911         __field(unsigned int,   n_rd_avg)
1912         __field(unsigned int,   n_rd_cnt)
1913         __field(unsigned int,   m_rd_peak)
1914         __field(unsigned int,   m_rd_avg)
1915         __field(unsigned int,   m_rd_cnt)
1916         __field(unsigned int,   d_wr_s_peak)
1917         __field(unsigned int,   d_wr_s_avg)
1918         __field(unsigned int,   d_wr_s_cnt)
1919         __field(unsigned int,   n_wr_s_peak)
1920         __field(unsigned int,   n_wr_s_avg)
1921         __field(unsigned int,   n_wr_s_cnt)
1922         __field(unsigned int,   m_wr_s_peak)
1923         __field(unsigned int,   m_wr_s_avg)
1924         __field(unsigned int,   m_wr_s_cnt)
1925         __field(unsigned int,   d_wr_as_peak)
1926         __field(unsigned int,   d_wr_as_avg)
1927         __field(unsigned int,   d_wr_as_cnt)
1928         __field(unsigned int,   n_wr_as_peak)
1929         __field(unsigned int,   n_wr_as_avg)
1930         __field(unsigned int,   n_wr_as_cnt)
1931         __field(unsigned int,   m_wr_as_peak)
1932         __field(unsigned int,   m_wr_as_avg)
1933         __field(unsigned int,   m_wr_as_cnt)
1934     ),
1935 
1936     TP_fast_assign(
1937         __entry->dev        = sbi->sb->s_dev;
1938         __entry->d_rd_peak  = iostat_lat[0][DATA].peak_lat;
1939         __entry->d_rd_avg   = iostat_lat[0][DATA].avg_lat;
1940         __entry->d_rd_cnt   = iostat_lat[0][DATA].cnt;
1941         __entry->n_rd_peak  = iostat_lat[0][NODE].peak_lat;
1942         __entry->n_rd_avg   = iostat_lat[0][NODE].avg_lat;
1943         __entry->n_rd_cnt   = iostat_lat[0][NODE].cnt;
1944         __entry->m_rd_peak  = iostat_lat[0][META].peak_lat;
1945         __entry->m_rd_avg   = iostat_lat[0][META].avg_lat;
1946         __entry->m_rd_cnt   = iostat_lat[0][META].cnt;
1947         __entry->d_wr_s_peak    = iostat_lat[1][DATA].peak_lat;
1948         __entry->d_wr_s_avg = iostat_lat[1][DATA].avg_lat;
1949         __entry->d_wr_s_cnt = iostat_lat[1][DATA].cnt;
1950         __entry->n_wr_s_peak    = iostat_lat[1][NODE].peak_lat;
1951         __entry->n_wr_s_avg = iostat_lat[1][NODE].avg_lat;
1952         __entry->n_wr_s_cnt = iostat_lat[1][NODE].cnt;
1953         __entry->m_wr_s_peak    = iostat_lat[1][META].peak_lat;
1954         __entry->m_wr_s_avg = iostat_lat[1][META].avg_lat;
1955         __entry->m_wr_s_cnt = iostat_lat[1][META].cnt;
1956         __entry->d_wr_as_peak   = iostat_lat[2][DATA].peak_lat;
1957         __entry->d_wr_as_avg    = iostat_lat[2][DATA].avg_lat;
1958         __entry->d_wr_as_cnt    = iostat_lat[2][DATA].cnt;
1959         __entry->n_wr_as_peak   = iostat_lat[2][NODE].peak_lat;
1960         __entry->n_wr_as_avg    = iostat_lat[2][NODE].avg_lat;
1961         __entry->n_wr_as_cnt    = iostat_lat[2][NODE].cnt;
1962         __entry->m_wr_as_peak   = iostat_lat[2][META].peak_lat;
1963         __entry->m_wr_as_avg    = iostat_lat[2][META].avg_lat;
1964         __entry->m_wr_as_cnt    = iostat_lat[2][META].cnt;
1965     ),
1966 
1967     TP_printk("dev = (%d,%d), "
1968         "iotype [peak lat.(ms)/avg lat.(ms)/count], "
1969         "rd_data [%u/%u/%u], rd_node [%u/%u/%u], rd_meta [%u/%u/%u], "
1970         "wr_sync_data [%u/%u/%u], wr_sync_node [%u/%u/%u], "
1971         "wr_sync_meta [%u/%u/%u], wr_async_data [%u/%u/%u], "
1972         "wr_async_node [%u/%u/%u], wr_async_meta [%u/%u/%u]",
1973         show_dev(__entry->dev),
1974         __entry->d_rd_peak, __entry->d_rd_avg, __entry->d_rd_cnt,
1975         __entry->n_rd_peak, __entry->n_rd_avg, __entry->n_rd_cnt,
1976         __entry->m_rd_peak, __entry->m_rd_avg, __entry->m_rd_cnt,
1977         __entry->d_wr_s_peak, __entry->d_wr_s_avg, __entry->d_wr_s_cnt,
1978         __entry->n_wr_s_peak, __entry->n_wr_s_avg, __entry->n_wr_s_cnt,
1979         __entry->m_wr_s_peak, __entry->m_wr_s_avg, __entry->m_wr_s_cnt,
1980         __entry->d_wr_as_peak, __entry->d_wr_as_avg, __entry->d_wr_as_cnt,
1981         __entry->n_wr_as_peak, __entry->n_wr_as_avg, __entry->n_wr_as_cnt,
1982         __entry->m_wr_as_peak, __entry->m_wr_as_avg, __entry->m_wr_as_cnt)
1983 );
1984 #endif
1985 
1986 TRACE_EVENT(f2fs_bmap,
1987 
1988     TP_PROTO(struct inode *inode, sector_t lblock, sector_t pblock),
1989 
1990     TP_ARGS(inode, lblock, pblock),
1991 
1992     TP_STRUCT__entry(
1993         __field(dev_t, dev)
1994         __field(ino_t, ino)
1995         __field(sector_t, lblock)
1996         __field(sector_t, pblock)
1997     ),
1998 
1999     TP_fast_assign(
2000         __entry->dev        = inode->i_sb->s_dev;
2001         __entry->ino        = inode->i_ino;
2002         __entry->lblock     = lblock;
2003         __entry->pblock     = pblock;
2004     ),
2005 
2006     TP_printk("dev = (%d,%d), ino = %lu, lblock:%lld, pblock:%lld",
2007         show_dev_ino(__entry),
2008         (unsigned long long)__entry->lblock,
2009         (unsigned long long)__entry->pblock)
2010 );
2011 
2012 TRACE_EVENT(f2fs_fiemap,
2013 
2014     TP_PROTO(struct inode *inode, sector_t lblock, sector_t pblock,
2015         unsigned long long len, unsigned int flags, int ret),
2016 
2017     TP_ARGS(inode, lblock, pblock, len, flags, ret),
2018 
2019     TP_STRUCT__entry(
2020         __field(dev_t, dev)
2021         __field(ino_t, ino)
2022         __field(sector_t, lblock)
2023         __field(sector_t, pblock)
2024         __field(unsigned long long, len)
2025         __field(unsigned int, flags)
2026         __field(int, ret)
2027     ),
2028 
2029     TP_fast_assign(
2030         __entry->dev        = inode->i_sb->s_dev;
2031         __entry->ino        = inode->i_ino;
2032         __entry->lblock     = lblock;
2033         __entry->pblock     = pblock;
2034         __entry->len        = len;
2035         __entry->flags      = flags;
2036         __entry->ret        = ret;
2037     ),
2038 
2039     TP_printk("dev = (%d,%d), ino = %lu, lblock:%lld, pblock:%lld, "
2040         "len:%llu, flags:%u, ret:%d",
2041         show_dev_ino(__entry),
2042         (unsigned long long)__entry->lblock,
2043         (unsigned long long)__entry->pblock,
2044         __entry->len,
2045         __entry->flags,
2046         __entry->ret)
2047 );
2048 
2049 DECLARE_EVENT_CLASS(f2fs__rw_start,
2050 
2051     TP_PROTO(struct inode *inode, loff_t offset, int bytes,
2052             pid_t pid, char *pathname, char *command),
2053 
2054     TP_ARGS(inode, offset, bytes, pid, pathname, command),
2055 
2056     TP_STRUCT__entry(
2057         __string(pathbuf, pathname)
2058         __field(loff_t, offset)
2059         __field(int, bytes)
2060         __field(loff_t, i_size)
2061         __string(cmdline, command)
2062         __field(pid_t, pid)
2063         __field(ino_t, ino)
2064     ),
2065 
2066     TP_fast_assign(
2067         /*
2068          * Replace the spaces in filenames and cmdlines
2069          * because this screws up the tooling that parses
2070          * the traces.
2071          */
2072         __assign_str(pathbuf, pathname);
2073         (void)strreplace(__get_str(pathbuf), ' ', '_');
2074         __entry->offset = offset;
2075         __entry->bytes = bytes;
2076         __entry->i_size = i_size_read(inode);
2077         __assign_str(cmdline, command);
2078         (void)strreplace(__get_str(cmdline), ' ', '_');
2079         __entry->pid = pid;
2080         __entry->ino = inode->i_ino;
2081     ),
2082 
2083     TP_printk("entry_name %s, offset %llu, bytes %d, cmdline %s,"
2084         " pid %d, i_size %llu, ino %lu",
2085         __get_str(pathbuf), __entry->offset, __entry->bytes,
2086         __get_str(cmdline), __entry->pid, __entry->i_size,
2087         (unsigned long) __entry->ino)
2088 );
2089 
2090 DECLARE_EVENT_CLASS(f2fs__rw_end,
2091 
2092     TP_PROTO(struct inode *inode, loff_t offset, int bytes),
2093 
2094     TP_ARGS(inode, offset, bytes),
2095 
2096     TP_STRUCT__entry(
2097         __field(ino_t,  ino)
2098         __field(loff_t, offset)
2099         __field(int,    bytes)
2100     ),
2101 
2102     TP_fast_assign(
2103         __entry->ino        = inode->i_ino;
2104         __entry->offset     = offset;
2105         __entry->bytes      = bytes;
2106     ),
2107 
2108     TP_printk("ino %lu, offset %llu, bytes %d",
2109         (unsigned long) __entry->ino,
2110         __entry->offset, __entry->bytes)
2111 );
2112 
2113 DEFINE_EVENT(f2fs__rw_start, f2fs_dataread_start,
2114 
2115     TP_PROTO(struct inode *inode, loff_t offset, int bytes,
2116         pid_t pid, char *pathname, char *command),
2117 
2118     TP_ARGS(inode, offset, bytes, pid, pathname, command)
2119 );
2120 
2121 DEFINE_EVENT(f2fs__rw_end, f2fs_dataread_end,
2122 
2123     TP_PROTO(struct inode *inode, loff_t offset, int bytes),
2124 
2125     TP_ARGS(inode, offset, bytes)
2126 );
2127 
2128 DEFINE_EVENT(f2fs__rw_start, f2fs_datawrite_start,
2129 
2130     TP_PROTO(struct inode *inode, loff_t offset, int bytes,
2131         pid_t pid, char *pathname, char *command),
2132 
2133     TP_ARGS(inode, offset, bytes, pid, pathname, command)
2134 );
2135 
2136 DEFINE_EVENT(f2fs__rw_end, f2fs_datawrite_end,
2137 
2138     TP_PROTO(struct inode *inode, loff_t offset, int bytes),
2139 
2140     TP_ARGS(inode, offset, bytes)
2141 );
2142 
2143 #endif /* _TRACE_F2FS_H */
2144 
2145  /* This part must be outside protection */
2146 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!