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