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