File Index
Files and directories
Sign in
FILE

ext4.h

File preview with syntax highlighting.

linux-6.19.14/include/trace/events/ext4.h C
   1/* SPDX-License-Identifier: GPL-2.0 */
   2#undef TRACE_SYSTEM
   3#define TRACE_SYSTEM ext4
   4
   5#if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
   6#define _TRACE_EXT4_H
   7
   8#include <linux/writeback.h>
   9#include <linux/tracepoint.h>
  10
  11struct ext4_allocation_context;
  12struct ext4_allocation_request;
  13struct ext4_extent;
  14struct ext4_prealloc_space;
  15struct ext4_inode_info;
  16struct mpage_da_data;
  17struct ext4_map_blocks;
  18struct extent_status;
  19struct ext4_fsmap;
  20struct partial_cluster;
  21
  22#define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
  23
  24#define show_mballoc_flags(flags) __print_flags(flags, "|",	\
  25	{ EXT4_MB_HINT_MERGE,		"HINT_MERGE" },		\
  26	{ EXT4_MB_HINT_FIRST,		"HINT_FIRST" },		\
  27	{ EXT4_MB_HINT_DATA,		"HINT_DATA" },		\
  28	{ EXT4_MB_HINT_NOPREALLOC,	"HINT_NOPREALLOC" },	\
  29	{ EXT4_MB_HINT_GROUP_ALLOC,	"HINT_GRP_ALLOC" },	\
  30	{ EXT4_MB_HINT_GOAL_ONLY,	"HINT_GOAL_ONLY" },	\
  31	{ EXT4_MB_HINT_TRY_GOAL,	"HINT_TRY_GOAL" },	\
  32	{ EXT4_MB_DELALLOC_RESERVED,	"DELALLOC_RESV" },	\
  33	{ EXT4_MB_STREAM_ALLOC,		"STREAM_ALLOC" },	\
  34	{ EXT4_MB_USE_ROOT_BLOCKS,	"USE_ROOT_BLKS" },	\
  35	{ EXT4_MB_USE_RESERVED,		"USE_RESV" },		\
  36	{ EXT4_MB_STRICT_CHECK,		"STRICT_CHECK" })
  37
  38#define show_map_flags(flags) __print_flags(flags, "|",			\
  39	{ EXT4_GET_BLOCKS_CREATE,		"CREATE" },		\
  40	{ EXT4_GET_BLOCKS_UNWRIT_EXT,		"UNWRIT" },		\
  41	{ EXT4_GET_BLOCKS_DELALLOC_RESERVE,	"DELALLOC" },		\
  42	{ EXT4_GET_BLOCKS_SPLIT_NOMERGE,	"SPLIT_NOMERGE" },	\
  43	{ EXT4_GET_BLOCKS_CONVERT,		"CONVERT" },		\
  44	{ EXT4_GET_BLOCKS_METADATA_NOFAIL,	"METADATA_NOFAIL" },	\
  45	{ EXT4_GET_BLOCKS_NO_NORMALIZE,		"NO_NORMALIZE" },	\
  46	{ EXT4_GET_BLOCKS_CONVERT_UNWRITTEN,	"CONVERT_UNWRITTEN" },  \
  47	{ EXT4_GET_BLOCKS_ZERO,			"ZERO" },		\
  48	{ EXT4_GET_BLOCKS_IO_SUBMIT,		"IO_SUBMIT" },		\
  49	{ EXT4_EX_NOCACHE,			"EX_NOCACHE" })
  50
  51/*
  52 * __print_flags() requires that all enum values be wrapped in the
  53 * TRACE_DEFINE_ENUM macro so that the enum value can be encoded in the ftrace
  54 * ring buffer.
  55 */
  56TRACE_DEFINE_ENUM(BH_New);
  57TRACE_DEFINE_ENUM(BH_Mapped);
  58TRACE_DEFINE_ENUM(BH_Unwritten);
  59TRACE_DEFINE_ENUM(BH_Boundary);
  60
  61#define show_mflags(flags) __print_flags(flags, "",	\
  62	{ EXT4_MAP_NEW,		"N" },			\
  63	{ EXT4_MAP_MAPPED,	"M" },			\
  64	{ EXT4_MAP_UNWRITTEN,	"U" },			\
  65	{ EXT4_MAP_BOUNDARY,	"B" })
  66
  67#define show_free_flags(flags) __print_flags(flags, "|",	\
  68	{ EXT4_FREE_BLOCKS_METADATA,		"METADATA" },	\
  69	{ EXT4_FREE_BLOCKS_FORGET,		"FORGET" },	\
  70	{ EXT4_FREE_BLOCKS_VALIDATED,		"VALIDATED" },	\
  71	{ EXT4_FREE_BLOCKS_NO_QUOT_UPDATE,	"NO_QUOTA" },	\
  72	{ EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER,"1ST_CLUSTER" },\
  73	{ EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER,	"LAST_CLUSTER" })
  74
  75TRACE_DEFINE_ENUM(ES_WRITTEN_B);
  76TRACE_DEFINE_ENUM(ES_UNWRITTEN_B);
  77TRACE_DEFINE_ENUM(ES_DELAYED_B);
  78TRACE_DEFINE_ENUM(ES_HOLE_B);
  79TRACE_DEFINE_ENUM(ES_REFERENCED_B);
  80
  81#define show_extent_status(status) __print_flags(status, "",	\
  82	{ EXTENT_STATUS_WRITTEN,	"W" },			\
  83	{ EXTENT_STATUS_UNWRITTEN,	"U" },			\
  84	{ EXTENT_STATUS_DELAYED,	"D" },			\
  85	{ EXTENT_STATUS_HOLE,		"H" },			\
  86	{ EXTENT_STATUS_REFERENCED,	"R" })
  87
  88#define show_falloc_mode(mode) __print_flags(mode, "|",		\
  89	{ FALLOC_FL_KEEP_SIZE,		"KEEP_SIZE"},		\
  90	{ FALLOC_FL_PUNCH_HOLE,		"PUNCH_HOLE"},		\
  91	{ FALLOC_FL_COLLAPSE_RANGE,	"COLLAPSE_RANGE"},	\
  92	{ FALLOC_FL_ZERO_RANGE,		"ZERO_RANGE"},		\
  93	{ FALLOC_FL_WRITE_ZEROES,	"WRITE_ZEROES"})
  94
  95TRACE_DEFINE_ENUM(EXT4_FC_REASON_XATTR);
  96TRACE_DEFINE_ENUM(EXT4_FC_REASON_CROSS_RENAME);
  97TRACE_DEFINE_ENUM(EXT4_FC_REASON_JOURNAL_FLAG_CHANGE);
  98TRACE_DEFINE_ENUM(EXT4_FC_REASON_NOMEM);
  99TRACE_DEFINE_ENUM(EXT4_FC_REASON_SWAP_BOOT);
 100TRACE_DEFINE_ENUM(EXT4_FC_REASON_RESIZE);
 101TRACE_DEFINE_ENUM(EXT4_FC_REASON_RENAME_DIR);
 102TRACE_DEFINE_ENUM(EXT4_FC_REASON_FALLOC_RANGE);
 103TRACE_DEFINE_ENUM(EXT4_FC_REASON_INODE_JOURNAL_DATA);
 104TRACE_DEFINE_ENUM(EXT4_FC_REASON_ENCRYPTED_FILENAME);
 105TRACE_DEFINE_ENUM(EXT4_FC_REASON_MAX);
 106
 107#define show_fc_reason(reason)						\
 108	__print_symbolic(reason,					\
 109		{ EXT4_FC_REASON_XATTR,		"XATTR"},		\
 110		{ EXT4_FC_REASON_CROSS_RENAME,	"CROSS_RENAME"},	\
 111		{ EXT4_FC_REASON_JOURNAL_FLAG_CHANGE, "JOURNAL_FLAG_CHANGE"}, \
 112		{ EXT4_FC_REASON_NOMEM,	"NO_MEM"},			\
 113		{ EXT4_FC_REASON_SWAP_BOOT,	"SWAP_BOOT"},		\
 114		{ EXT4_FC_REASON_RESIZE,	"RESIZE"},		\
 115		{ EXT4_FC_REASON_RENAME_DIR,	"RENAME_DIR"},		\
 116		{ EXT4_FC_REASON_FALLOC_RANGE,	"FALLOC_RANGE"},	\
 117		{ EXT4_FC_REASON_INODE_JOURNAL_DATA,	"INODE_JOURNAL_DATA"}, \
 118		{ EXT4_FC_REASON_ENCRYPTED_FILENAME,	"ENCRYPTED_FILENAME"})
 119
 120TRACE_DEFINE_ENUM(CR_POWER2_ALIGNED);
 121TRACE_DEFINE_ENUM(CR_GOAL_LEN_FAST);
 122TRACE_DEFINE_ENUM(CR_BEST_AVAIL_LEN);
 123TRACE_DEFINE_ENUM(CR_GOAL_LEN_SLOW);
 124TRACE_DEFINE_ENUM(CR_ANY_FREE);
 125
 126#define show_criteria(cr)                                               \
 127	__print_symbolic(cr,                                            \
 128			 { CR_POWER2_ALIGNED, "CR_POWER2_ALIGNED" },	\
 129			 { CR_GOAL_LEN_FAST, "CR_GOAL_LEN_FAST" },      \
 130			 { CR_BEST_AVAIL_LEN, "CR_BEST_AVAIL_LEN" },    \
 131			 { CR_GOAL_LEN_SLOW, "CR_GOAL_LEN_SLOW" },      \
 132			 { CR_ANY_FREE, "CR_ANY_FREE" })
 133
 134TRACE_EVENT(ext4_other_inode_update_time,
 135	TP_PROTO(struct inode *inode, ino_t orig_ino),
 136
 137	TP_ARGS(inode, orig_ino),
 138
 139	TP_STRUCT__entry(
 140		__field(	dev_t,	dev			)
 141		__field(	ino_t,	ino			)
 142		__field(	ino_t,	orig_ino		)
 143		__field(	uid_t,	uid			)
 144		__field(	gid_t,	gid			)
 145		__field(	__u16, mode			)
 146	),
 147
 148	TP_fast_assign(
 149		__entry->orig_ino = orig_ino;
 150		__entry->dev	= inode->i_sb->s_dev;
 151		__entry->ino	= inode->i_ino;
 152		__entry->uid	= i_uid_read(inode);
 153		__entry->gid	= i_gid_read(inode);
 154		__entry->mode	= inode->i_mode;
 155	),
 156
 157	TP_printk("dev %d,%d orig_ino %lu ino %lu mode 0%o uid %u gid %u",
 158		  MAJOR(__entry->dev), MINOR(__entry->dev),
 159		  (unsigned long) __entry->orig_ino,
 160		  (unsigned long) __entry->ino, __entry->mode,
 161		  __entry->uid, __entry->gid)
 162);
 163
 164TRACE_EVENT(ext4_free_inode,
 165	TP_PROTO(struct inode *inode),
 166
 167	TP_ARGS(inode),
 168
 169	TP_STRUCT__entry(
 170		__field(	dev_t,	dev			)
 171		__field(	ino_t,	ino			)
 172		__field(	uid_t,	uid			)
 173		__field(	gid_t,	gid			)
 174		__field(	__u64, blocks			)
 175		__field(	__u16, mode			)
 176	),
 177
 178	TP_fast_assign(
 179		__entry->dev	= inode->i_sb->s_dev;
 180		__entry->ino	= inode->i_ino;
 181		__entry->uid	= i_uid_read(inode);
 182		__entry->gid	= i_gid_read(inode);
 183		__entry->blocks	= inode->i_blocks;
 184		__entry->mode	= inode->i_mode;
 185	),
 186
 187	TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
 188		  MAJOR(__entry->dev), MINOR(__entry->dev),
 189		  (unsigned long) __entry->ino, __entry->mode,
 190		  __entry->uid, __entry->gid, __entry->blocks)
 191);
 192
 193TRACE_EVENT(ext4_request_inode,
 194	TP_PROTO(struct inode *dir, int mode),
 195
 196	TP_ARGS(dir, mode),
 197
 198	TP_STRUCT__entry(
 199		__field(	dev_t,	dev			)
 200		__field(	ino_t,	dir			)
 201		__field(	__u16, mode			)
 202	),
 203
 204	TP_fast_assign(
 205		__entry->dev	= dir->i_sb->s_dev;
 206		__entry->dir	= dir->i_ino;
 207		__entry->mode	= mode;
 208	),
 209
 210	TP_printk("dev %d,%d dir %lu mode 0%o",
 211		  MAJOR(__entry->dev), MINOR(__entry->dev),
 212		  (unsigned long) __entry->dir, __entry->mode)
 213);
 214
 215TRACE_EVENT(ext4_allocate_inode,
 216	TP_PROTO(struct inode *inode, struct inode *dir, int mode),
 217
 218	TP_ARGS(inode, dir, mode),
 219
 220	TP_STRUCT__entry(
 221		__field(	dev_t,	dev			)
 222		__field(	ino_t,	ino			)
 223		__field(	ino_t,	dir			)
 224		__field(	__u16,	mode			)
 225	),
 226
 227	TP_fast_assign(
 228		__entry->dev	= inode->i_sb->s_dev;
 229		__entry->ino	= inode->i_ino;
 230		__entry->dir	= dir->i_ino;
 231		__entry->mode	= mode;
 232	),
 233
 234	TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
 235		  MAJOR(__entry->dev), MINOR(__entry->dev),
 236		  (unsigned long) __entry->ino,
 237		  (unsigned long) __entry->dir, __entry->mode)
 238);
 239
 240TRACE_EVENT(ext4_evict_inode,
 241	TP_PROTO(struct inode *inode),
 242
 243	TP_ARGS(inode),
 244
 245	TP_STRUCT__entry(
 246		__field(	dev_t,	dev			)
 247		__field(	ino_t,	ino			)
 248		__field(	int,	nlink			)
 249	),
 250
 251	TP_fast_assign(
 252		__entry->dev	= inode->i_sb->s_dev;
 253		__entry->ino	= inode->i_ino;
 254		__entry->nlink	= inode->i_nlink;
 255	),
 256
 257	TP_printk("dev %d,%d ino %lu nlink %d",
 258		  MAJOR(__entry->dev), MINOR(__entry->dev),
 259		  (unsigned long) __entry->ino, __entry->nlink)
 260);
 261
 262TRACE_EVENT(ext4_drop_inode,
 263	TP_PROTO(struct inode *inode, int drop),
 264
 265	TP_ARGS(inode, drop),
 266
 267	TP_STRUCT__entry(
 268		__field(	dev_t,	dev			)
 269		__field(	ino_t,	ino			)
 270		__field(	int,	drop			)
 271	),
 272
 273	TP_fast_assign(
 274		__entry->dev	= inode->i_sb->s_dev;
 275		__entry->ino	= inode->i_ino;
 276		__entry->drop	= drop;
 277	),
 278
 279	TP_printk("dev %d,%d ino %lu drop %d",
 280		  MAJOR(__entry->dev), MINOR(__entry->dev),
 281		  (unsigned long) __entry->ino, __entry->drop)
 282);
 283
 284TRACE_EVENT(ext4_nfs_commit_metadata,
 285	TP_PROTO(struct inode *inode),
 286
 287	TP_ARGS(inode),
 288
 289	TP_STRUCT__entry(
 290		__field(	dev_t,	dev			)
 291		__field(	ino_t,	ino			)
 292	),
 293
 294	TP_fast_assign(
 295		__entry->dev	= inode->i_sb->s_dev;
 296		__entry->ino	= inode->i_ino;
 297	),
 298
 299	TP_printk("dev %d,%d ino %lu",
 300		  MAJOR(__entry->dev), MINOR(__entry->dev),
 301		  (unsigned long) __entry->ino)
 302);
 303
 304TRACE_EVENT(ext4_mark_inode_dirty,
 305	TP_PROTO(struct inode *inode, unsigned long IP),
 306
 307	TP_ARGS(inode, IP),
 308
 309	TP_STRUCT__entry(
 310		__field(	dev_t,	dev			)
 311		__field(	ino_t,	ino			)
 312		__field(unsigned long,	ip			)
 313	),
 314
 315	TP_fast_assign(
 316		__entry->dev	= inode->i_sb->s_dev;
 317		__entry->ino	= inode->i_ino;
 318		__entry->ip	= IP;
 319	),
 320
 321	TP_printk("dev %d,%d ino %lu caller %pS",
 322		  MAJOR(__entry->dev), MINOR(__entry->dev),
 323		  (unsigned long) __entry->ino, (void *)__entry->ip)
 324);
 325
 326TRACE_EVENT(ext4_begin_ordered_truncate,
 327	TP_PROTO(struct inode *inode, loff_t new_size),
 328
 329	TP_ARGS(inode, new_size),
 330
 331	TP_STRUCT__entry(
 332		__field(	dev_t,	dev			)
 333		__field(	ino_t,	ino			)
 334		__field(	loff_t,	new_size		)
 335	),
 336
 337	TP_fast_assign(
 338		__entry->dev		= inode->i_sb->s_dev;
 339		__entry->ino		= inode->i_ino;
 340		__entry->new_size	= new_size;
 341	),
 342
 343	TP_printk("dev %d,%d ino %lu new_size %lld",
 344		  MAJOR(__entry->dev), MINOR(__entry->dev),
 345		  (unsigned long) __entry->ino,
 346		  __entry->new_size)
 347);
 348
 349DECLARE_EVENT_CLASS(ext4__write_begin,
 350
 351	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len),
 352
 353	TP_ARGS(inode, pos, len),
 354
 355	TP_STRUCT__entry(
 356		__field(	dev_t,	dev			)
 357		__field(	ino_t,	ino			)
 358		__field(	loff_t,	pos			)
 359		__field(	unsigned int, len		)
 360	),
 361
 362	TP_fast_assign(
 363		__entry->dev	= inode->i_sb->s_dev;
 364		__entry->ino	= inode->i_ino;
 365		__entry->pos	= pos;
 366		__entry->len	= len;
 367	),
 368
 369	TP_printk("dev %d,%d ino %lu pos %lld len %u",
 370		  MAJOR(__entry->dev), MINOR(__entry->dev),
 371		  (unsigned long) __entry->ino,
 372		  __entry->pos, __entry->len)
 373);
 374
 375DEFINE_EVENT(ext4__write_begin, ext4_write_begin,
 376
 377	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len),
 378
 379	TP_ARGS(inode, pos, len)
 380);
 381
 382DEFINE_EVENT(ext4__write_begin, ext4_da_write_begin,
 383
 384	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len),
 385
 386	TP_ARGS(inode, pos, len)
 387);
 388
 389DECLARE_EVENT_CLASS(ext4__write_end,
 390	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 391			unsigned int copied),
 392
 393	TP_ARGS(inode, pos, len, copied),
 394
 395	TP_STRUCT__entry(
 396		__field(	dev_t,	dev			)
 397		__field(	ino_t,	ino			)
 398		__field(	loff_t,	pos			)
 399		__field(	unsigned int, len		)
 400		__field(	unsigned int, copied		)
 401	),
 402
 403	TP_fast_assign(
 404		__entry->dev	= inode->i_sb->s_dev;
 405		__entry->ino	= inode->i_ino;
 406		__entry->pos	= pos;
 407		__entry->len	= len;
 408		__entry->copied	= copied;
 409	),
 410
 411	TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
 412		  MAJOR(__entry->dev), MINOR(__entry->dev),
 413		  (unsigned long) __entry->ino,
 414		  __entry->pos, __entry->len, __entry->copied)
 415);
 416
 417DEFINE_EVENT(ext4__write_end, ext4_write_end,
 418
 419	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 420		 unsigned int copied),
 421
 422	TP_ARGS(inode, pos, len, copied)
 423);
 424
 425DEFINE_EVENT(ext4__write_end, ext4_journalled_write_end,
 426
 427	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 428		 unsigned int copied),
 429
 430	TP_ARGS(inode, pos, len, copied)
 431);
 432
 433DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
 434
 435	TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
 436		 unsigned int copied),
 437
 438	TP_ARGS(inode, pos, len, copied)
 439);
 440
 441TRACE_EVENT(ext4_writepages,
 442	TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 443
 444	TP_ARGS(inode, wbc),
 445
 446	TP_STRUCT__entry(
 447		__field(	dev_t,	dev			)
 448		__field(	ino_t,	ino			)
 449		__field(	long,	nr_to_write		)
 450		__field(	long,	pages_skipped		)
 451		__field(	loff_t,	range_start		)
 452		__field(	loff_t,	range_end		)
 453		__field(       pgoff_t,	writeback_index		)
 454		__field(	int,	sync_mode		)
 455		__field(	char,	for_kupdate		)
 456		__field(	char,	range_cyclic		)
 457	),
 458
 459	TP_fast_assign(
 460		__entry->dev		= inode->i_sb->s_dev;
 461		__entry->ino		= inode->i_ino;
 462		__entry->nr_to_write	= wbc->nr_to_write;
 463		__entry->pages_skipped	= wbc->pages_skipped;
 464		__entry->range_start	= wbc->range_start;
 465		__entry->range_end	= wbc->range_end;
 466		__entry->writeback_index = inode->i_mapping->writeback_index;
 467		__entry->sync_mode	= wbc->sync_mode;
 468		__entry->for_kupdate	= wbc->for_kupdate;
 469		__entry->range_cyclic	= wbc->range_cyclic;
 470	),
 471
 472	TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
 473		  "range_start %lld range_end %lld sync_mode %d "
 474		  "for_kupdate %d range_cyclic %d writeback_index %lu",
 475		  MAJOR(__entry->dev), MINOR(__entry->dev),
 476		  (unsigned long) __entry->ino, __entry->nr_to_write,
 477		  __entry->pages_skipped, __entry->range_start,
 478		  __entry->range_end, __entry->sync_mode,
 479		  __entry->for_kupdate, __entry->range_cyclic,
 480		  (unsigned long) __entry->writeback_index)
 481);
 482
 483TRACE_EVENT(ext4_da_write_folios_start,
 484	TP_PROTO(struct inode *inode, loff_t start_pos, loff_t next_pos,
 485		 struct writeback_control *wbc),
 486
 487	TP_ARGS(inode, start_pos, next_pos, wbc),
 488
 489	TP_STRUCT__entry(
 490		__field(	dev_t,	dev			)
 491		__field(	ino_t,	ino			)
 492		__field(       loff_t,	start_pos		)
 493		__field(       loff_t,	next_pos		)
 494		__field(	 long,	nr_to_write		)
 495		__field(	  int,	sync_mode		)
 496	),
 497
 498	TP_fast_assign(
 499		__entry->dev		= inode->i_sb->s_dev;
 500		__entry->ino		= inode->i_ino;
 501		__entry->start_pos	= start_pos;
 502		__entry->next_pos	= next_pos;
 503		__entry->nr_to_write	= wbc->nr_to_write;
 504		__entry->sync_mode	= wbc->sync_mode;
 505	),
 506
 507	TP_printk("dev %d,%d ino %lu start_pos 0x%llx next_pos 0x%llx nr_to_write %ld sync_mode %d",
 508		  MAJOR(__entry->dev), MINOR(__entry->dev),
 509		  (unsigned long) __entry->ino, __entry->start_pos, __entry->next_pos,
 510		  __entry->nr_to_write, __entry->sync_mode)
 511);
 512
 513TRACE_EVENT(ext4_da_write_folios_end,
 514	TP_PROTO(struct inode *inode, loff_t start_pos, loff_t next_pos,
 515		 struct writeback_control *wbc, int ret),
 516
 517	TP_ARGS(inode, start_pos, next_pos, wbc, ret),
 518
 519	TP_STRUCT__entry(
 520		__field(	dev_t,	dev			)
 521		__field(	ino_t,	ino			)
 522		__field(       loff_t,	start_pos		)
 523		__field(       loff_t,	next_pos		)
 524		__field(	 long,	nr_to_write		)
 525		__field(	  int,	ret			)
 526	),
 527
 528	TP_fast_assign(
 529		__entry->dev		= inode->i_sb->s_dev;
 530		__entry->ino		= inode->i_ino;
 531		__entry->start_pos	= start_pos;
 532		__entry->next_pos	= next_pos;
 533		__entry->nr_to_write	= wbc->nr_to_write;
 534		__entry->ret		= ret;
 535	),
 536
 537	TP_printk("dev %d,%d ino %lu start_pos 0x%llx next_pos 0x%llx nr_to_write %ld ret %d",
 538		  MAJOR(__entry->dev), MINOR(__entry->dev),
 539		  (unsigned long) __entry->ino, __entry->start_pos, __entry->next_pos,
 540		  __entry->nr_to_write, __entry->ret)
 541);
 542
 543TRACE_EVENT(ext4_da_write_pages_extent,
 544	TP_PROTO(struct inode *inode, struct ext4_map_blocks *map),
 545
 546	TP_ARGS(inode, map),
 547
 548	TP_STRUCT__entry(
 549		__field(	dev_t,	dev			)
 550		__field(	ino_t,	ino			)
 551		__field(	__u64,	lblk			)
 552		__field(	__u32,	len			)
 553		__field(	__u32,	flags			)
 554	),
 555
 556	TP_fast_assign(
 557		__entry->dev		= inode->i_sb->s_dev;
 558		__entry->ino		= inode->i_ino;
 559		__entry->lblk		= map->m_lblk;
 560		__entry->len		= map->m_len;
 561		__entry->flags		= map->m_flags;
 562	),
 563
 564	TP_printk("dev %d,%d ino %lu lblk %llu len %u flags %s",
 565		  MAJOR(__entry->dev), MINOR(__entry->dev),
 566		  (unsigned long) __entry->ino, __entry->lblk, __entry->len,
 567		  show_mflags(__entry->flags))
 568);
 569
 570TRACE_EVENT(ext4_writepages_result,
 571	TP_PROTO(struct inode *inode, struct writeback_control *wbc,
 572			int ret, int pages_written),
 573
 574	TP_ARGS(inode, wbc, ret, pages_written),
 575
 576	TP_STRUCT__entry(
 577		__field(	dev_t,	dev			)
 578		__field(	ino_t,	ino			)
 579		__field(	int,	ret			)
 580		__field(	int,	pages_written		)
 581		__field(	long,	pages_skipped		)
 582		__field(       pgoff_t,	writeback_index		)
 583		__field(	int,	sync_mode		)
 584	),
 585
 586	TP_fast_assign(
 587		__entry->dev		= inode->i_sb->s_dev;
 588		__entry->ino		= inode->i_ino;
 589		__entry->ret		= ret;
 590		__entry->pages_written	= pages_written;
 591		__entry->pages_skipped	= wbc->pages_skipped;
 592		__entry->writeback_index = inode->i_mapping->writeback_index;
 593		__entry->sync_mode	= wbc->sync_mode;
 594	),
 595
 596	TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
 597		  "sync_mode %d writeback_index %lu",
 598		  MAJOR(__entry->dev), MINOR(__entry->dev),
 599		  (unsigned long) __entry->ino, __entry->ret,
 600		  __entry->pages_written, __entry->pages_skipped,
 601		  __entry->sync_mode,
 602		  (unsigned long) __entry->writeback_index)
 603);
 604
 605DECLARE_EVENT_CLASS(ext4__folio_op,
 606	TP_PROTO(struct inode *inode, struct folio *folio),
 607
 608	TP_ARGS(inode, folio),
 609
 610	TP_STRUCT__entry(
 611		__field(	dev_t,	dev			)
 612		__field(	ino_t,	ino			)
 613		__field(	pgoff_t, index			)
 614
 615	),
 616
 617	TP_fast_assign(
 618		__entry->dev	= inode->i_sb->s_dev;
 619		__entry->ino	= inode->i_ino;
 620		__entry->index	= folio->index;
 621	),
 622
 623	TP_printk("dev %d,%d ino %lu folio_index %lu",
 624		  MAJOR(__entry->dev), MINOR(__entry->dev),
 625		  (unsigned long) __entry->ino,
 626		  (unsigned long) __entry->index)
 627);
 628
 629DEFINE_EVENT(ext4__folio_op, ext4_read_folio,
 630
 631	TP_PROTO(struct inode *inode, struct folio *folio),
 632
 633	TP_ARGS(inode, folio)
 634);
 635
 636DEFINE_EVENT(ext4__folio_op, ext4_release_folio,
 637
 638	TP_PROTO(struct inode *inode, struct folio *folio),
 639
 640	TP_ARGS(inode, folio)
 641);
 642
 643DECLARE_EVENT_CLASS(ext4_invalidate_folio_op,
 644	TP_PROTO(struct folio *folio, size_t offset, size_t length),
 645
 646	TP_ARGS(folio, offset, length),
 647
 648	TP_STRUCT__entry(
 649		__field(	dev_t,	dev			)
 650		__field(	ino_t,	ino			)
 651		__field(	pgoff_t, index			)
 652		__field(	size_t, offset			)
 653		__field(	size_t, length			)
 654	),
 655
 656	TP_fast_assign(
 657		__entry->dev	= folio->mapping->host->i_sb->s_dev;
 658		__entry->ino	= folio->mapping->host->i_ino;
 659		__entry->index	= folio->index;
 660		__entry->offset	= offset;
 661		__entry->length	= length;
 662	),
 663
 664	TP_printk("dev %d,%d ino %lu folio_index %lu offset %zu length %zu",
 665		  MAJOR(__entry->dev), MINOR(__entry->dev),
 666		  (unsigned long) __entry->ino,
 667		  (unsigned long) __entry->index,
 668		  __entry->offset, __entry->length)
 669);
 670
 671DEFINE_EVENT(ext4_invalidate_folio_op, ext4_invalidate_folio,
 672	TP_PROTO(struct folio *folio, size_t offset, size_t length),
 673
 674	TP_ARGS(folio, offset, length)
 675);
 676
 677DEFINE_EVENT(ext4_invalidate_folio_op, ext4_journalled_invalidate_folio,
 678	TP_PROTO(struct folio *folio, size_t offset, size_t length),
 679
 680	TP_ARGS(folio, offset, length)
 681);
 682
 683TRACE_EVENT(ext4_discard_blocks,
 684	TP_PROTO(struct super_block *sb, unsigned long long blk,
 685			unsigned long long count),
 686
 687	TP_ARGS(sb, blk, count),
 688
 689	TP_STRUCT__entry(
 690		__field(	dev_t,	dev			)
 691		__field(	__u64,	blk			)
 692		__field(	__u64,	count			)
 693
 694	),
 695
 696	TP_fast_assign(
 697		__entry->dev	= sb->s_dev;
 698		__entry->blk	= blk;
 699		__entry->count	= count;
 700	),
 701
 702	TP_printk("dev %d,%d blk %llu count %llu",
 703		  MAJOR(__entry->dev), MINOR(__entry->dev),
 704		  __entry->blk, __entry->count)
 705);
 706
 707DECLARE_EVENT_CLASS(ext4__mb_new_pa,
 708	TP_PROTO(struct ext4_allocation_context *ac,
 709		 struct ext4_prealloc_space *pa),
 710
 711	TP_ARGS(ac, pa),
 712
 713	TP_STRUCT__entry(
 714		__field(	dev_t,	dev			)
 715		__field(	ino_t,	ino			)
 716		__field(	__u64,	pa_pstart		)
 717		__field(	__u64,	pa_lstart		)
 718		__field(	__u32,	pa_len			)
 719
 720	),
 721
 722	TP_fast_assign(
 723		__entry->dev		= ac->ac_sb->s_dev;
 724		__entry->ino		= ac->ac_inode->i_ino;
 725		__entry->pa_pstart	= pa->pa_pstart;
 726		__entry->pa_lstart	= pa->pa_lstart;
 727		__entry->pa_len		= pa->pa_len;
 728	),
 729
 730	TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
 731		  MAJOR(__entry->dev), MINOR(__entry->dev),
 732		  (unsigned long) __entry->ino,
 733		  __entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
 734);
 735
 736DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_inode_pa,
 737
 738	TP_PROTO(struct ext4_allocation_context *ac,
 739		 struct ext4_prealloc_space *pa),
 740
 741	TP_ARGS(ac, pa)
 742);
 743
 744DEFINE_EVENT(ext4__mb_new_pa, ext4_mb_new_group_pa,
 745
 746	TP_PROTO(struct ext4_allocation_context *ac,
 747		 struct ext4_prealloc_space *pa),
 748
 749	TP_ARGS(ac, pa)
 750);
 751
 752TRACE_EVENT(ext4_mb_release_inode_pa,
 753	TP_PROTO(struct ext4_prealloc_space *pa,
 754		 unsigned long long block, unsigned int count),
 755
 756	TP_ARGS(pa, block, count),
 757
 758	TP_STRUCT__entry(
 759		__field(	dev_t,	dev			)
 760		__field(	ino_t,	ino			)
 761		__field(	__u64,	block			)
 762		__field(	__u32,	count			)
 763
 764	),
 765
 766	TP_fast_assign(
 767		__entry->dev		= pa->pa_inode->i_sb->s_dev;
 768		__entry->ino		= pa->pa_inode->i_ino;
 769		__entry->block		= block;
 770		__entry->count		= count;
 771	),
 772
 773	TP_printk("dev %d,%d ino %lu block %llu count %u",
 774		  MAJOR(__entry->dev), MINOR(__entry->dev),
 775		  (unsigned long) __entry->ino,
 776		  __entry->block, __entry->count)
 777);
 778
 779TRACE_EVENT(ext4_mb_release_group_pa,
 780	TP_PROTO(struct super_block *sb, struct ext4_prealloc_space *pa),
 781
 782	TP_ARGS(sb, pa),
 783
 784	TP_STRUCT__entry(
 785		__field(	dev_t,	dev			)
 786		__field(	__u64,	pa_pstart		)
 787		__field(	__u32,	pa_len			)
 788
 789	),
 790
 791	TP_fast_assign(
 792		__entry->dev		= sb->s_dev;
 793		__entry->pa_pstart	= pa->pa_pstart;
 794		__entry->pa_len		= pa->pa_len;
 795	),
 796
 797	TP_printk("dev %d,%d pstart %llu len %u",
 798		  MAJOR(__entry->dev), MINOR(__entry->dev),
 799		  __entry->pa_pstart, __entry->pa_len)
 800);
 801
 802TRACE_EVENT(ext4_discard_preallocations,
 803	TP_PROTO(struct inode *inode, unsigned int len),
 804
 805	TP_ARGS(inode, len),
 806
 807	TP_STRUCT__entry(
 808		__field(	dev_t,		dev		)
 809		__field(	ino_t,		ino		)
 810		__field(	unsigned int,	len		)
 811
 812	),
 813
 814	TP_fast_assign(
 815		__entry->dev	= inode->i_sb->s_dev;
 816		__entry->ino	= inode->i_ino;
 817		__entry->len	= len;
 818	),
 819
 820	TP_printk("dev %d,%d ino %lu len: %u",
 821		  MAJOR(__entry->dev), MINOR(__entry->dev),
 822		  (unsigned long) __entry->ino, __entry->len)
 823);
 824
 825TRACE_EVENT(ext4_mb_discard_preallocations,
 826	TP_PROTO(struct super_block *sb, int needed),
 827
 828	TP_ARGS(sb, needed),
 829
 830	TP_STRUCT__entry(
 831		__field(	dev_t,	dev			)
 832		__field(	int,	needed			)
 833
 834	),
 835
 836	TP_fast_assign(
 837		__entry->dev	= sb->s_dev;
 838		__entry->needed	= needed;
 839	),
 840
 841	TP_printk("dev %d,%d needed %d",
 842		  MAJOR(__entry->dev), MINOR(__entry->dev),
 843		  __entry->needed)
 844);
 845
 846TRACE_EVENT(ext4_request_blocks,
 847	TP_PROTO(struct ext4_allocation_request *ar),
 848
 849	TP_ARGS(ar),
 850
 851	TP_STRUCT__entry(
 852		__field(	dev_t,	dev			)
 853		__field(	ino_t,	ino			)
 854		__field(	unsigned int, len		)
 855		__field(	__u32,  logical			)
 856		__field(	__u32,	lleft			)
 857		__field(	__u32,	lright			)
 858		__field(	__u64,	goal			)
 859		__field(	__u64,	pleft			)
 860		__field(	__u64,	pright			)
 861		__field(	unsigned int, flags		)
 862	),
 863
 864	TP_fast_assign(
 865		__entry->dev	= ar->inode->i_sb->s_dev;
 866		__entry->ino	= ar->inode->i_ino;
 867		__entry->len	= ar->len;
 868		__entry->logical = ar->logical;
 869		__entry->goal	= ar->goal;
 870		__entry->lleft	= ar->lleft;
 871		__entry->lright	= ar->lright;
 872		__entry->pleft	= ar->pleft;
 873		__entry->pright	= ar->pright;
 874		__entry->flags	= ar->flags;
 875	),
 876
 877	TP_printk("dev %d,%d ino %lu flags %s len %u lblk %u goal %llu "
 878		  "lleft %u lright %u pleft %llu pright %llu ",
 879		  MAJOR(__entry->dev), MINOR(__entry->dev),
 880		  (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
 881		  __entry->len, __entry->logical, __entry->goal,
 882		  __entry->lleft, __entry->lright, __entry->pleft,
 883		  __entry->pright)
 884);
 885
 886TRACE_EVENT(ext4_allocate_blocks,
 887	TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
 888
 889	TP_ARGS(ar, block),
 890
 891	TP_STRUCT__entry(
 892		__field(	dev_t,	dev			)
 893		__field(	ino_t,	ino			)
 894		__field(	__u64,	block			)
 895		__field(	unsigned int, len		)
 896		__field(	__u32,  logical			)
 897		__field(	__u32,	lleft			)
 898		__field(	__u32,	lright			)
 899		__field(	__u64,	goal			)
 900		__field(	__u64,	pleft			)
 901		__field(	__u64,	pright			)
 902		__field(	unsigned int, flags		)
 903	),
 904
 905	TP_fast_assign(
 906		__entry->dev	= ar->inode->i_sb->s_dev;
 907		__entry->ino	= ar->inode->i_ino;
 908		__entry->block	= block;
 909		__entry->len	= ar->len;
 910		__entry->logical = ar->logical;
 911		__entry->goal	= ar->goal;
 912		__entry->lleft	= ar->lleft;
 913		__entry->lright	= ar->lright;
 914		__entry->pleft	= ar->pleft;
 915		__entry->pright	= ar->pright;
 916		__entry->flags	= ar->flags;
 917	),
 918
 919	TP_printk("dev %d,%d ino %lu flags %s len %u block %llu lblk %u "
 920		  "goal %llu lleft %u lright %u pleft %llu pright %llu",
 921		  MAJOR(__entry->dev), MINOR(__entry->dev),
 922		  (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
 923		  __entry->len, __entry->block, __entry->logical,
 924		  __entry->goal,  __entry->lleft, __entry->lright,
 925		  __entry->pleft, __entry->pright)
 926);
 927
 928TRACE_EVENT(ext4_free_blocks,
 929	TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
 930		 int flags),
 931
 932	TP_ARGS(inode, block, count, flags),
 933
 934	TP_STRUCT__entry(
 935		__field(	dev_t,	dev			)
 936		__field(	ino_t,	ino			)
 937		__field(	__u64,	block			)
 938		__field(	unsigned long,	count		)
 939		__field(	int,	flags			)
 940		__field(	__u16,	mode			)
 941	),
 942
 943	TP_fast_assign(
 944		__entry->dev		= inode->i_sb->s_dev;
 945		__entry->ino		= inode->i_ino;
 946		__entry->block		= block;
 947		__entry->count		= count;
 948		__entry->flags		= flags;
 949		__entry->mode		= inode->i_mode;
 950	),
 951
 952	TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %s",
 953		  MAJOR(__entry->dev), MINOR(__entry->dev),
 954		  (unsigned long) __entry->ino,
 955		  __entry->mode, __entry->block, __entry->count,
 956		  show_free_flags(__entry->flags))
 957);
 958
 959TRACE_EVENT(ext4_sync_file_enter,
 960	TP_PROTO(struct file *file, int datasync),
 961
 962	TP_ARGS(file, datasync),
 963
 964	TP_STRUCT__entry(
 965		__field(	dev_t,	dev			)
 966		__field(	ino_t,	ino			)
 967		__field(	ino_t,	parent			)
 968		__field(	int,	datasync		)
 969	),
 970
 971	TP_fast_assign(
 972		struct dentry *dentry = file->f_path.dentry;
 973
 974		__entry->dev		= dentry->d_sb->s_dev;
 975		__entry->ino		= d_inode(dentry)->i_ino;
 976		__entry->datasync	= datasync;
 977		__entry->parent		= d_inode(dentry->d_parent)->i_ino;
 978	),
 979
 980	TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
 981		  MAJOR(__entry->dev), MINOR(__entry->dev),
 982		  (unsigned long) __entry->ino,
 983		  (unsigned long) __entry->parent, __entry->datasync)
 984);
 985
 986TRACE_EVENT(ext4_sync_file_exit,
 987	TP_PROTO(struct inode *inode, int ret),
 988
 989	TP_ARGS(inode, ret),
 990
 991	TP_STRUCT__entry(
 992		__field(	dev_t,	dev			)
 993		__field(	ino_t,	ino			)
 994		__field(	int,	ret			)
 995	),
 996
 997	TP_fast_assign(
 998		__entry->dev		= inode->i_sb->s_dev;
 999		__entry->ino		= inode->i_ino;
1000		__entry->ret		= ret;
1001	),
1002
1003	TP_printk("dev %d,%d ino %lu ret %d",
1004		  MAJOR(__entry->dev), MINOR(__entry->dev),
1005		  (unsigned long) __entry->ino,
1006		  __entry->ret)
1007);
1008
1009TRACE_EVENT(ext4_sync_fs,
1010	TP_PROTO(struct super_block *sb, int wait),
1011
1012	TP_ARGS(sb, wait),
1013
1014	TP_STRUCT__entry(
1015		__field(	dev_t,	dev			)
1016		__field(	int,	wait			)
1017
1018	),
1019
1020	TP_fast_assign(
1021		__entry->dev	= sb->s_dev;
1022		__entry->wait	= wait;
1023	),
1024
1025	TP_printk("dev %d,%d wait %d",
1026		  MAJOR(__entry->dev), MINOR(__entry->dev),
1027		  __entry->wait)
1028);
1029
1030TRACE_EVENT(ext4_alloc_da_blocks,
1031	TP_PROTO(struct inode *inode),
1032
1033	TP_ARGS(inode),
1034
1035	TP_STRUCT__entry(
1036		__field(	dev_t,	dev			)
1037		__field(	ino_t,	ino			)
1038		__field( unsigned int,	data_blocks		)
1039	),
1040
1041	TP_fast_assign(
1042		__entry->dev	= inode->i_sb->s_dev;
1043		__entry->ino	= inode->i_ino;
1044		__entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1045	),
1046
1047	TP_printk("dev %d,%d ino %lu reserved_data_blocks %u",
1048		  MAJOR(__entry->dev), MINOR(__entry->dev),
1049		  (unsigned long) __entry->ino,
1050		  __entry->data_blocks)
1051);
1052
1053TRACE_EVENT(ext4_mballoc_alloc,
1054	TP_PROTO(struct ext4_allocation_context *ac),
1055
1056	TP_ARGS(ac),
1057
1058	TP_STRUCT__entry(
1059		__field(	dev_t,	dev			)
1060		__field(	ino_t,	ino			)
1061		__field(	__u32, 	orig_logical		)
1062		__field(	  int,	orig_start		)
1063		__field(	__u32, 	orig_group		)
1064		__field(	  int,	orig_len		)
1065		__field(	__u32, 	goal_logical		)
1066		__field(	  int,	goal_start		)
1067		__field(	__u32, 	goal_group		)
1068		__field(	  int,	goal_len		)
1069		__field(	__u32, 	result_logical		)
1070		__field(	  int,	result_start		)
1071		__field(	__u32, 	result_group		)
1072		__field(	  int,	result_len		)
1073		__field(	__u16,	found			)
1074		__field(	__u16,	groups			)
1075		__field(	__u16,	buddy			)
1076		__field(	__u16,	flags			)
1077		__field(	__u16,	tail			)
1078		__field(	__u8,	cr			)
1079	),
1080
1081	TP_fast_assign(
1082		__entry->dev		= ac->ac_inode->i_sb->s_dev;
1083		__entry->ino		= ac->ac_inode->i_ino;
1084		__entry->orig_logical	= ac->ac_o_ex.fe_logical;
1085		__entry->orig_start	= ac->ac_o_ex.fe_start;
1086		__entry->orig_group	= ac->ac_o_ex.fe_group;
1087		__entry->orig_len	= ac->ac_o_ex.fe_len;
1088		__entry->goal_logical	= ac->ac_g_ex.fe_logical;
1089		__entry->goal_start	= ac->ac_g_ex.fe_start;
1090		__entry->goal_group	= ac->ac_g_ex.fe_group;
1091		__entry->goal_len	= ac->ac_g_ex.fe_len;
1092		__entry->result_logical	= ac->ac_f_ex.fe_logical;
1093		__entry->result_start	= ac->ac_f_ex.fe_start;
1094		__entry->result_group	= ac->ac_f_ex.fe_group;
1095		__entry->result_len	= ac->ac_f_ex.fe_len;
1096		__entry->found		= ac->ac_found;
1097		__entry->flags		= ac->ac_flags;
1098		__entry->groups		= ac->ac_groups_scanned;
1099		__entry->buddy		= ac->ac_buddy;
1100		__entry->tail		= ac->ac_tail;
1101		__entry->cr		= ac->ac_criteria;
1102	),
1103
1104	TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
1105		  "result %u/%d/%u@%u blks %u grps %u cr %s flags %s "
1106		  "tail %u broken %u",
1107		  MAJOR(__entry->dev), MINOR(__entry->dev),
1108		  (unsigned long) __entry->ino,
1109		  __entry->orig_group, __entry->orig_start,
1110		  __entry->orig_len, __entry->orig_logical,
1111		  __entry->goal_group, __entry->goal_start,
1112		  __entry->goal_len, __entry->goal_logical,
1113		  __entry->result_group, __entry->result_start,
1114		  __entry->result_len, __entry->result_logical,
1115		  __entry->found, __entry->groups, show_criteria(__entry->cr),
1116		  show_mballoc_flags(__entry->flags), __entry->tail,
1117		  __entry->buddy ? 1 << __entry->buddy : 0)
1118);
1119
1120TRACE_EVENT(ext4_mballoc_prealloc,
1121	TP_PROTO(struct ext4_allocation_context *ac),
1122
1123	TP_ARGS(ac),
1124
1125	TP_STRUCT__entry(
1126		__field(	dev_t,	dev			)
1127		__field(	ino_t,	ino			)
1128		__field(	__u32, 	orig_logical		)
1129		__field(	  int,	orig_start		)
1130		__field(	__u32, 	orig_group		)
1131		__field(	  int,	orig_len		)
1132		__field(	__u32, 	result_logical		)
1133		__field(	  int,	result_start		)
1134		__field(	__u32, 	result_group		)
1135		__field(	  int,	result_len		)
1136	),
1137
1138	TP_fast_assign(
1139		__entry->dev		= ac->ac_inode->i_sb->s_dev;
1140		__entry->ino		= ac->ac_inode->i_ino;
1141		__entry->orig_logical	= ac->ac_o_ex.fe_logical;
1142		__entry->orig_start	= ac->ac_o_ex.fe_start;
1143		__entry->orig_group	= ac->ac_o_ex.fe_group;
1144		__entry->orig_len	= ac->ac_o_ex.fe_len;
1145		__entry->result_logical	= ac->ac_b_ex.fe_logical;
1146		__entry->result_start	= ac->ac_b_ex.fe_start;
1147		__entry->result_group	= ac->ac_b_ex.fe_group;
1148		__entry->result_len	= ac->ac_b_ex.fe_len;
1149	),
1150
1151	TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
1152		  MAJOR(__entry->dev), MINOR(__entry->dev),
1153		  (unsigned long) __entry->ino,
1154		  __entry->orig_group, __entry->orig_start,
1155		  __entry->orig_len, __entry->orig_logical,
1156		  __entry->result_group, __entry->result_start,
1157		  __entry->result_len, __entry->result_logical)
1158);
1159
1160DECLARE_EVENT_CLASS(ext4__mballoc,
1161	TP_PROTO(struct super_block *sb,
1162		 struct inode *inode,
1163		 ext4_group_t group,
1164		 ext4_grpblk_t start,
1165		 ext4_grpblk_t len),
1166
1167	TP_ARGS(sb, inode, group, start, len),
1168
1169	TP_STRUCT__entry(
1170		__field(	dev_t,	dev			)
1171		__field(	ino_t,	ino			)
1172		__field(	  int,	result_start		)
1173		__field(	__u32, 	result_group		)
1174		__field(	  int,	result_len		)
1175	),
1176
1177	TP_fast_assign(
1178		__entry->dev		= sb->s_dev;
1179		__entry->ino		= inode ? inode->i_ino : 0;
1180		__entry->result_start	= start;
1181		__entry->result_group	= group;
1182		__entry->result_len	= len;
1183	),
1184
1185	TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
1186		  MAJOR(__entry->dev), MINOR(__entry->dev),
1187		  (unsigned long) __entry->ino,
1188		  __entry->result_group, __entry->result_start,
1189		  __entry->result_len)
1190);
1191
1192DEFINE_EVENT(ext4__mballoc, ext4_mballoc_discard,
1193
1194	TP_PROTO(struct super_block *sb,
1195		 struct inode *inode,
1196		 ext4_group_t group,
1197		 ext4_grpblk_t start,
1198		 ext4_grpblk_t len),
1199
1200	TP_ARGS(sb, inode, group, start, len)
1201);
1202
1203DEFINE_EVENT(ext4__mballoc, ext4_mballoc_free,
1204
1205	TP_PROTO(struct super_block *sb,
1206		 struct inode *inode,
1207		 ext4_group_t group,
1208		 ext4_grpblk_t start,
1209		 ext4_grpblk_t len),
1210
1211	TP_ARGS(sb, inode, group, start, len)
1212);
1213
1214TRACE_EVENT(ext4_forget,
1215	TP_PROTO(struct inode *inode, int is_metadata, __u64 block),
1216
1217	TP_ARGS(inode, is_metadata, block),
1218
1219	TP_STRUCT__entry(
1220		__field(	dev_t,	dev			)
1221		__field(	ino_t,	ino			)
1222		__field(	__u64,	block			)
1223		__field(	int,	is_metadata		)
1224		__field(	__u16,	mode			)
1225	),
1226
1227	TP_fast_assign(
1228		__entry->dev	= inode->i_sb->s_dev;
1229		__entry->ino	= inode->i_ino;
1230		__entry->block	= block;
1231		__entry->is_metadata = is_metadata;
1232		__entry->mode	= inode->i_mode;
1233	),
1234
1235	TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1236		  MAJOR(__entry->dev), MINOR(__entry->dev),
1237		  (unsigned long) __entry->ino,
1238		  __entry->mode, __entry->is_metadata, __entry->block)
1239);
1240
1241TRACE_EVENT(ext4_da_update_reserve_space,
1242	TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
1243
1244	TP_ARGS(inode, used_blocks, quota_claim),
1245
1246	TP_STRUCT__entry(
1247		__field(	dev_t,	dev			)
1248		__field(	ino_t,	ino			)
1249		__field(	__u64,	i_blocks		)
1250		__field(	int,	used_blocks		)
1251		__field(	int,	reserved_data_blocks	)
1252		__field(	int,	quota_claim		)
1253		__field(	__u16,	mode			)
1254	),
1255
1256	TP_fast_assign(
1257		__entry->dev	= inode->i_sb->s_dev;
1258		__entry->ino	= inode->i_ino;
1259		__entry->i_blocks = inode->i_blocks;
1260		__entry->used_blocks = used_blocks;
1261		__entry->reserved_data_blocks =
1262				EXT4_I(inode)->i_reserved_data_blocks;
1263		__entry->quota_claim = quota_claim;
1264		__entry->mode	= inode->i_mode;
1265	),
1266
1267	TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1268		  "reserved_data_blocks %d quota_claim %d",
1269		  MAJOR(__entry->dev), MINOR(__entry->dev),
1270		  (unsigned long) __entry->ino,
1271		  __entry->mode, __entry->i_blocks,
1272		  __entry->used_blocks, __entry->reserved_data_blocks,
1273		  __entry->quota_claim)
1274);
1275
1276TRACE_EVENT(ext4_da_reserve_space,
1277	TP_PROTO(struct inode *inode, int nr_resv),
1278
1279	TP_ARGS(inode, nr_resv),
1280
1281	TP_STRUCT__entry(
1282		__field(	dev_t,	dev			)
1283		__field(	ino_t,	ino			)
1284		__field(	__u64,	i_blocks		)
1285		__field(	int,	reserve_blocks		)
1286		__field(	int,	reserved_data_blocks	)
1287		__field(	__u16,  mode			)
1288	),
1289
1290	TP_fast_assign(
1291		__entry->dev	= inode->i_sb->s_dev;
1292		__entry->ino	= inode->i_ino;
1293		__entry->i_blocks = inode->i_blocks;
1294		__entry->reserve_blocks = nr_resv;
1295		__entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1296		__entry->mode	= inode->i_mode;
1297	),
1298
1299	TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu reserve_blocks %d"
1300		  "reserved_data_blocks %d",
1301		  MAJOR(__entry->dev), MINOR(__entry->dev),
1302		  (unsigned long) __entry->ino,
1303		  __entry->mode, __entry->i_blocks,
1304		  __entry->reserve_blocks, __entry->reserved_data_blocks)
1305);
1306
1307TRACE_EVENT(ext4_da_release_space,
1308	TP_PROTO(struct inode *inode, int freed_blocks),
1309
1310	TP_ARGS(inode, freed_blocks),
1311
1312	TP_STRUCT__entry(
1313		__field(	dev_t,	dev			)
1314		__field(	ino_t,	ino			)
1315		__field(	__u64,	i_blocks		)
1316		__field(	int,	freed_blocks		)
1317		__field(	int,	reserved_data_blocks	)
1318		__field(	__u16,  mode			)
1319	),
1320
1321	TP_fast_assign(
1322		__entry->dev	= inode->i_sb->s_dev;
1323		__entry->ino	= inode->i_ino;
1324		__entry->i_blocks = inode->i_blocks;
1325		__entry->freed_blocks = freed_blocks;
1326		__entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1327		__entry->mode	= inode->i_mode;
1328	),
1329
1330	TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
1331		  "reserved_data_blocks %d",
1332		  MAJOR(__entry->dev), MINOR(__entry->dev),
1333		  (unsigned long) __entry->ino,
1334		  __entry->mode, __entry->i_blocks,
1335		  __entry->freed_blocks, __entry->reserved_data_blocks)
1336);
1337
1338DECLARE_EVENT_CLASS(ext4__bitmap_load,
1339	TP_PROTO(struct super_block *sb, unsigned long group),
1340
1341	TP_ARGS(sb, group),
1342
1343	TP_STRUCT__entry(
1344		__field(	dev_t,	dev			)
1345		__field(	__u32,	group			)
1346
1347	),
1348
1349	TP_fast_assign(
1350		__entry->dev	= sb->s_dev;
1351		__entry->group	= group;
1352	),
1353
1354	TP_printk("dev %d,%d group %u",
1355		  MAJOR(__entry->dev), MINOR(__entry->dev),
1356		  __entry->group)
1357);
1358
1359DEFINE_EVENT(ext4__bitmap_load, ext4_mb_bitmap_load,
1360
1361	TP_PROTO(struct super_block *sb, unsigned long group),
1362
1363	TP_ARGS(sb, group)
1364);
1365
1366DEFINE_EVENT(ext4__bitmap_load, ext4_mb_buddy_bitmap_load,
1367
1368	TP_PROTO(struct super_block *sb, unsigned long group),
1369
1370	TP_ARGS(sb, group)
1371);
1372
1373DEFINE_EVENT(ext4__bitmap_load, ext4_load_inode_bitmap,
1374
1375	TP_PROTO(struct super_block *sb, unsigned long group),
1376
1377	TP_ARGS(sb, group)
1378);
1379
1380TRACE_EVENT(ext4_read_block_bitmap_load,
1381	TP_PROTO(struct super_block *sb, unsigned long group, bool prefetch),
1382
1383	TP_ARGS(sb, group, prefetch),
1384
1385	TP_STRUCT__entry(
1386		__field(	dev_t,	dev			)
1387		__field(	__u32,	group			)
1388		__field(	bool,	prefetch		)
1389
1390	),
1391
1392	TP_fast_assign(
1393		__entry->dev	= sb->s_dev;
1394		__entry->group	= group;
1395		__entry->prefetch = prefetch;
1396	),
1397
1398	TP_printk("dev %d,%d group %u prefetch %d",
1399		  MAJOR(__entry->dev), MINOR(__entry->dev),
1400		  __entry->group, __entry->prefetch)
1401);
1402
1403DECLARE_EVENT_CLASS(ext4__fallocate_mode,
1404	TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1405
1406	TP_ARGS(inode, offset, len, mode),
1407
1408	TP_STRUCT__entry(
1409		__field(	dev_t,	dev			)
1410		__field(	ino_t,	ino			)
1411		__field(	loff_t,	offset			)
1412		__field(	loff_t, len			)
1413		__field(	int,	mode			)
1414	),
1415
1416	TP_fast_assign(
1417		__entry->dev	= inode->i_sb->s_dev;
1418		__entry->ino	= inode->i_ino;
1419		__entry->offset	= offset;
1420		__entry->len	= len;
1421		__entry->mode	= mode;
1422	),
1423
1424	TP_printk("dev %d,%d ino %lu offset %lld len %lld mode %s",
1425		  MAJOR(__entry->dev), MINOR(__entry->dev),
1426		  (unsigned long) __entry->ino,
1427		  __entry->offset, __entry->len,
1428		  show_falloc_mode(__entry->mode))
1429);
1430
1431DEFINE_EVENT(ext4__fallocate_mode, ext4_fallocate_enter,
1432
1433	TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1434
1435	TP_ARGS(inode, offset, len, mode)
1436);
1437
1438DEFINE_EVENT(ext4__fallocate_mode, ext4_punch_hole,
1439
1440	TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1441
1442	TP_ARGS(inode, offset, len, mode)
1443);
1444
1445DEFINE_EVENT(ext4__fallocate_mode, ext4_zero_range,
1446
1447	TP_PROTO(struct inode *inode, loff_t offset, loff_t len, int mode),
1448
1449	TP_ARGS(inode, offset, len, mode)
1450);
1451
1452TRACE_EVENT(ext4_fallocate_exit,
1453	TP_PROTO(struct inode *inode, loff_t offset,
1454		 unsigned int max_blocks, int ret),
1455
1456	TP_ARGS(inode, offset, max_blocks, ret),
1457
1458	TP_STRUCT__entry(
1459		__field(	dev_t,	dev			)
1460		__field(	ino_t,	ino			)
1461		__field(	loff_t,	pos			)
1462		__field(	unsigned int,	blocks		)
1463		__field(	int, 	ret			)
1464	),
1465
1466	TP_fast_assign(
1467		__entry->dev	= inode->i_sb->s_dev;
1468		__entry->ino	= inode->i_ino;
1469		__entry->pos	= offset;
1470		__entry->blocks	= max_blocks;
1471		__entry->ret	= ret;
1472	),
1473
1474	TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
1475		  MAJOR(__entry->dev), MINOR(__entry->dev),
1476		  (unsigned long) __entry->ino,
1477		  __entry->pos, __entry->blocks,
1478		  __entry->ret)
1479);
1480
1481TRACE_EVENT(ext4_unlink_enter,
1482	TP_PROTO(struct inode *parent, struct dentry *dentry),
1483
1484	TP_ARGS(parent, dentry),
1485
1486	TP_STRUCT__entry(
1487		__field(	dev_t,	dev			)
1488		__field(	ino_t,	ino			)
1489		__field(	ino_t,	parent			)
1490		__field(	loff_t,	size			)
1491	),
1492
1493	TP_fast_assign(
1494		__entry->dev		= dentry->d_sb->s_dev;
1495		__entry->ino		= d_inode(dentry)->i_ino;
1496		__entry->parent		= parent->i_ino;
1497		__entry->size		= d_inode(dentry)->i_size;
1498	),
1499
1500	TP_printk("dev %d,%d ino %lu size %lld parent %lu",
1501		  MAJOR(__entry->dev), MINOR(__entry->dev),
1502		  (unsigned long) __entry->ino, __entry->size,
1503		  (unsigned long) __entry->parent)
1504);
1505
1506TRACE_EVENT(ext4_unlink_exit,
1507	TP_PROTO(struct dentry *dentry, int ret),
1508
1509	TP_ARGS(dentry, ret),
1510
1511	TP_STRUCT__entry(
1512		__field(	dev_t,	dev			)
1513		__field(	ino_t,	ino			)
1514		__field(	int,	ret			)
1515	),
1516
1517	TP_fast_assign(
1518		__entry->dev		= dentry->d_sb->s_dev;
1519		__entry->ino		= d_inode(dentry)->i_ino;
1520		__entry->ret		= ret;
1521	),
1522
1523	TP_printk("dev %d,%d ino %lu ret %d",
1524		  MAJOR(__entry->dev), MINOR(__entry->dev),
1525		  (unsigned long) __entry->ino,
1526		  __entry->ret)
1527);
1528
1529DECLARE_EVENT_CLASS(ext4__truncate,
1530	TP_PROTO(struct inode *inode),
1531
1532	TP_ARGS(inode),
1533
1534	TP_STRUCT__entry(
1535		__field(	dev_t,		dev		)
1536		__field(	ino_t,		ino		)
1537		__field(	__u64,		blocks		)
1538	),
1539
1540	TP_fast_assign(
1541		__entry->dev    = inode->i_sb->s_dev;
1542		__entry->ino    = inode->i_ino;
1543		__entry->blocks	= inode->i_blocks;
1544	),
1545
1546	TP_printk("dev %d,%d ino %lu blocks %llu",
1547		  MAJOR(__entry->dev), MINOR(__entry->dev),
1548		  (unsigned long) __entry->ino, __entry->blocks)
1549);
1550
1551DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
1552
1553	TP_PROTO(struct inode *inode),
1554
1555	TP_ARGS(inode)
1556);
1557
1558DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
1559
1560	TP_PROTO(struct inode *inode),
1561
1562	TP_ARGS(inode)
1563);
1564
1565/* 'ux' is the unwritten extent. */
1566TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
1567	TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1568		 struct ext4_extent *ux),
1569
1570	TP_ARGS(inode, map, ux),
1571
1572	TP_STRUCT__entry(
1573		__field(	dev_t,		dev	)
1574		__field(	ino_t,		ino	)
1575		__field(	ext4_lblk_t,	m_lblk	)
1576		__field(	unsigned,	m_len	)
1577		__field(	ext4_lblk_t,	u_lblk	)
1578		__field(	unsigned,	u_len	)
1579		__field(	ext4_fsblk_t,	u_pblk	)
1580	),
1581
1582	TP_fast_assign(
1583		__entry->dev		= inode->i_sb->s_dev;
1584		__entry->ino		= inode->i_ino;
1585		__entry->m_lblk		= map->m_lblk;
1586		__entry->m_len		= map->m_len;
1587		__entry->u_lblk		= le32_to_cpu(ux->ee_block);
1588		__entry->u_len		= ext4_ext_get_actual_len(ux);
1589		__entry->u_pblk		= ext4_ext_pblock(ux);
1590	),
1591
1592	TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
1593		  "u_pblk %llu",
1594		  MAJOR(__entry->dev), MINOR(__entry->dev),
1595		  (unsigned long) __entry->ino,
1596		  __entry->m_lblk, __entry->m_len,
1597		  __entry->u_lblk, __entry->u_len, __entry->u_pblk)
1598);
1599
1600/*
1601 * 'ux' is the unwritten extent.
1602 * 'ix' is the initialized extent to which blocks are transferred.
1603 */
1604TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
1605	TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
1606		 struct ext4_extent *ux, struct ext4_extent *ix),
1607
1608	TP_ARGS(inode, map, ux, ix),
1609
1610	TP_STRUCT__entry(
1611		__field(	dev_t,		dev	)
1612		__field(	ino_t,		ino	)
1613		__field(	ext4_lblk_t,	m_lblk	)
1614		__field(	unsigned,	m_len	)
1615		__field(	ext4_lblk_t,	u_lblk	)
1616		__field(	unsigned,	u_len	)
1617		__field(	ext4_fsblk_t,	u_pblk	)
1618		__field(	ext4_lblk_t,	i_lblk	)
1619		__field(	unsigned,	i_len	)
1620		__field(	ext4_fsblk_t,	i_pblk	)
1621	),
1622
1623	TP_fast_assign(
1624		__entry->dev		= inode->i_sb->s_dev;
1625		__entry->ino		= inode->i_ino;
1626		__entry->m_lblk		= map->m_lblk;
1627		__entry->m_len		= map->m_len;
1628		__entry->u_lblk		= le32_to_cpu(ux->ee_block);
1629		__entry->u_len		= ext4_ext_get_actual_len(ux);
1630		__entry->u_pblk		= ext4_ext_pblock(ux);
1631		__entry->i_lblk		= le32_to_cpu(ix->ee_block);
1632		__entry->i_len		= ext4_ext_get_actual_len(ix);
1633		__entry->i_pblk		= ext4_ext_pblock(ix);
1634	),
1635
1636	TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
1637		  "u_lblk %u u_len %u u_pblk %llu "
1638		  "i_lblk %u i_len %u i_pblk %llu ",
1639		  MAJOR(__entry->dev), MINOR(__entry->dev),
1640		  (unsigned long) __entry->ino,
1641		  __entry->m_lblk, __entry->m_len,
1642		  __entry->u_lblk, __entry->u_len, __entry->u_pblk,
1643		  __entry->i_lblk, __entry->i_len, __entry->i_pblk)
1644);
1645
1646DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
1647	TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1648		 unsigned int len, unsigned int flags),
1649
1650	TP_ARGS(inode, lblk, len, flags),
1651
1652	TP_STRUCT__entry(
1653		__field(	dev_t,		dev		)
1654		__field(	ino_t,		ino		)
1655		__field(	ext4_lblk_t,	lblk		)
1656		__field(	unsigned int,	len		)
1657		__field(	unsigned int,	flags		)
1658	),
1659
1660	TP_fast_assign(
1661		__entry->dev    = inode->i_sb->s_dev;
1662		__entry->ino    = inode->i_ino;
1663		__entry->lblk	= lblk;
1664		__entry->len	= len;
1665		__entry->flags	= flags;
1666	),
1667
1668	TP_printk("dev %d,%d ino %lu lblk %u len %u flags %s",
1669		  MAJOR(__entry->dev), MINOR(__entry->dev),
1670		  (unsigned long) __entry->ino,
1671		  __entry->lblk, __entry->len, show_map_flags(__entry->flags))
1672);
1673
1674DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
1675	TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1676		 unsigned len, unsigned flags),
1677
1678	TP_ARGS(inode, lblk, len, flags)
1679);
1680
1681DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
1682	TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
1683		 unsigned len, unsigned flags),
1684
1685	TP_ARGS(inode, lblk, len, flags)
1686);
1687
1688DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
1689	TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map,
1690		 int ret),
1691
1692	TP_ARGS(inode, flags, map, ret),
1693
1694	TP_STRUCT__entry(
1695		__field(	dev_t,		dev		)
1696		__field(	ino_t,		ino		)
1697		__field(	unsigned int,	flags		)
1698		__field(	ext4_fsblk_t,	pblk		)
1699		__field(	ext4_lblk_t,	lblk		)
1700		__field(	unsigned int,	len		)
1701		__field(	unsigned int,	mflags		)
1702		__field(	int,		ret		)
1703	),
1704
1705	TP_fast_assign(
1706		__entry->dev    = inode->i_sb->s_dev;
1707		__entry->ino    = inode->i_ino;
1708		__entry->flags	= flags;
1709		__entry->pblk	= map->m_pblk;
1710		__entry->lblk	= map->m_lblk;
1711		__entry->len	= map->m_len;
1712		__entry->mflags	= map->m_flags;
1713		__entry->ret	= ret;
1714	),
1715
1716	TP_printk("dev %d,%d ino %lu flags %s lblk %u pblk %llu len %u "
1717		  "mflags %s ret %d",
1718		  MAJOR(__entry->dev), MINOR(__entry->dev),
1719		  (unsigned long) __entry->ino,
1720		  show_map_flags(__entry->flags), __entry->lblk, __entry->pblk,
1721		  __entry->len, show_mflags(__entry->mflags), __entry->ret)
1722);
1723
1724DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
1725	TP_PROTO(struct inode *inode, unsigned flags,
1726		 struct ext4_map_blocks *map, int ret),
1727
1728	TP_ARGS(inode, flags, map, ret)
1729);
1730
1731DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
1732	TP_PROTO(struct inode *inode, unsigned flags,
1733		 struct ext4_map_blocks *map, int ret),
1734
1735	TP_ARGS(inode, flags, map, ret)
1736);
1737
1738TRACE_EVENT(ext4_ext_load_extent,
1739	TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk),
1740
1741	TP_ARGS(inode, lblk, pblk),
1742
1743	TP_STRUCT__entry(
1744		__field(	dev_t,		dev		)
1745		__field(	ino_t,		ino		)
1746		__field(	ext4_fsblk_t,	pblk		)
1747		__field(	ext4_lblk_t,	lblk		)
1748	),
1749
1750	TP_fast_assign(
1751		__entry->dev    = inode->i_sb->s_dev;
1752		__entry->ino    = inode->i_ino;
1753		__entry->pblk	= pblk;
1754		__entry->lblk	= lblk;
1755	),
1756
1757	TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
1758		  MAJOR(__entry->dev), MINOR(__entry->dev),
1759		  (unsigned long) __entry->ino,
1760		  __entry->lblk, __entry->pblk)
1761);
1762
1763TRACE_EVENT(ext4_load_inode,
1764	TP_PROTO(struct super_block *sb, unsigned long ino),
1765
1766	TP_ARGS(sb, ino),
1767
1768	TP_STRUCT__entry(
1769		__field(	dev_t,	dev		)
1770		__field(	ino_t,	ino		)
1771	),
1772
1773	TP_fast_assign(
1774		__entry->dev		= sb->s_dev;
1775		__entry->ino		= ino;
1776	),
1777
1778	TP_printk("dev %d,%d ino %ld",
1779		  MAJOR(__entry->dev), MINOR(__entry->dev),
1780		  (unsigned long) __entry->ino)
1781);
1782
1783TRACE_EVENT(ext4_journal_start_sb,
1784	TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
1785		 int revoke_creds, int type, unsigned long IP),
1786
1787	TP_ARGS(sb, blocks, rsv_blocks, revoke_creds, type, IP),
1788
1789	TP_STRUCT__entry(
1790		__field(	dev_t,		dev		)
1791		__field(	unsigned long,	ip		)
1792		__field(	int,		blocks		)
1793		__field(	int,		rsv_blocks	)
1794		__field(	int,		revoke_creds	)
1795		__field(	int,		type		)
1796	),
1797
1798	TP_fast_assign(
1799		__entry->dev		 = sb->s_dev;
1800		__entry->ip		 = IP;
1801		__entry->blocks		 = blocks;
1802		__entry->rsv_blocks	 = rsv_blocks;
1803		__entry->revoke_creds	 = revoke_creds;
1804		__entry->type		 = type;
1805	),
1806
1807	TP_printk("dev %d,%d blocks %d, rsv_blocks %d, revoke_creds %d,"
1808		  " type %d, caller %pS", MAJOR(__entry->dev),
1809		  MINOR(__entry->dev), __entry->blocks, __entry->rsv_blocks,
1810		  __entry->revoke_creds, __entry->type, (void *)__entry->ip)
1811);
1812
1813TRACE_EVENT(ext4_journal_start_inode,
1814	TP_PROTO(struct inode *inode, int blocks, int rsv_blocks,
1815		 int revoke_creds, int type, unsigned long IP),
1816
1817	TP_ARGS(inode, blocks, rsv_blocks, revoke_creds, type, IP),
1818
1819	TP_STRUCT__entry(
1820		__field(	unsigned long,	ino		)
1821		__field(	dev_t,		dev		)
1822		__field(	unsigned long,	ip		)
1823		__field(	int,		blocks		)
1824		__field(	int,		rsv_blocks	)
1825		__field(	int,		revoke_creds	)
1826		__field(	int,		type		)
1827	),
1828
1829	TP_fast_assign(
1830		__entry->dev		 = inode->i_sb->s_dev;
1831		__entry->ip		 = IP;
1832		__entry->blocks		 = blocks;
1833		__entry->rsv_blocks	 = rsv_blocks;
1834		__entry->revoke_creds	 = revoke_creds;
1835		__entry->type		 = type;
1836		__entry->ino		 = inode->i_ino;
1837	),
1838
1839	TP_printk("dev %d,%d blocks %d, rsv_blocks %d, revoke_creds %d,"
1840		  " type %d, ino %lu, caller %pS", MAJOR(__entry->dev),
1841		  MINOR(__entry->dev), __entry->blocks, __entry->rsv_blocks,
1842		  __entry->revoke_creds, __entry->type, __entry->ino,
1843		  (void *)__entry->ip)
1844);
1845
1846TRACE_EVENT(ext4_journal_start_reserved,
1847	TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
1848
1849	TP_ARGS(sb, blocks, IP),
1850
1851	TP_STRUCT__entry(
1852		__field(	dev_t,	dev			)
1853		__field(unsigned long,	ip			)
1854		__field(	  int,	blocks			)
1855	),
1856
1857	TP_fast_assign(
1858		__entry->dev		 = sb->s_dev;
1859		__entry->ip		 = IP;
1860		__entry->blocks		 = blocks;
1861	),
1862
1863	TP_printk("dev %d,%d blocks, %d caller %pS",
1864		  MAJOR(__entry->dev), MINOR(__entry->dev),
1865		  __entry->blocks, (void *)__entry->ip)
1866);
1867
1868DECLARE_EVENT_CLASS(ext4__trim,
1869	TP_PROTO(struct super_block *sb,
1870		 ext4_group_t group,
1871		 ext4_grpblk_t start,
1872		 ext4_grpblk_t len),
1873
1874	TP_ARGS(sb, group, start, len),
1875
1876	TP_STRUCT__entry(
1877		__field(	int,	dev_major		)
1878		__field(	int,	dev_minor		)
1879		__field(	__u32, 	group			)
1880		__field(	int,	start			)
1881		__field(	int,	len			)
1882	),
1883
1884	TP_fast_assign(
1885		__entry->dev_major	= MAJOR(sb->s_dev);
1886		__entry->dev_minor	= MINOR(sb->s_dev);
1887		__entry->group		= group;
1888		__entry->start		= start;
1889		__entry->len		= len;
1890	),
1891
1892	TP_printk("dev %d,%d group %u, start %d, len %d",
1893		  __entry->dev_major, __entry->dev_minor,
1894		  __entry->group, __entry->start, __entry->len)
1895);
1896
1897DEFINE_EVENT(ext4__trim, ext4_trim_extent,
1898
1899	TP_PROTO(struct super_block *sb,
1900		 ext4_group_t group,
1901		 ext4_grpblk_t start,
1902		 ext4_grpblk_t len),
1903
1904	TP_ARGS(sb, group, start, len)
1905);
1906
1907DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
1908
1909	TP_PROTO(struct super_block *sb,
1910		 ext4_group_t group,
1911		 ext4_grpblk_t start,
1912		 ext4_grpblk_t len),
1913
1914	TP_ARGS(sb, group, start, len)
1915);
1916
1917TRACE_EVENT(ext4_ext_handle_unwritten_extents,
1918	TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int flags,
1919		 unsigned int allocated, ext4_fsblk_t newblock),
1920
1921	TP_ARGS(inode, map, flags, allocated, newblock),
1922
1923	TP_STRUCT__entry(
1924		__field(	dev_t,		dev		)
1925		__field(	ino_t,		ino		)
1926		__field(	int,		flags		)
1927		__field(	ext4_lblk_t,	lblk		)
1928		__field(	ext4_fsblk_t,	pblk		)
1929		__field(	unsigned int,	len		)
1930		__field(	unsigned int,	allocated	)
1931		__field(	ext4_fsblk_t,	newblk		)
1932	),
1933
1934	TP_fast_assign(
1935		__entry->dev		= inode->i_sb->s_dev;
1936		__entry->ino		= inode->i_ino;
1937		__entry->flags		= flags;
1938		__entry->lblk		= map->m_lblk;
1939		__entry->pblk		= map->m_pblk;
1940		__entry->len		= map->m_len;
1941		__entry->allocated	= allocated;
1942		__entry->newblk		= newblock;
1943	),
1944
1945	TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %s "
1946		  "allocated %d newblock %llu",
1947		  MAJOR(__entry->dev), MINOR(__entry->dev),
1948		  (unsigned long) __entry->ino,
1949		  (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
1950		  __entry->len, show_map_flags(__entry->flags),
1951		  (unsigned int) __entry->allocated,
1952		  (unsigned long long) __entry->newblk)
1953);
1954
1955TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
1956	TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
1957
1958	TP_ARGS(sb, map, ret),
1959
1960	TP_STRUCT__entry(
1961		__field(	dev_t,		dev	)
1962		__field(	unsigned int,	flags	)
1963		__field(	ext4_lblk_t,	lblk	)
1964		__field(	ext4_fsblk_t,	pblk	)
1965		__field(	unsigned int,	len	)
1966		__field(	int,		ret	)
1967	),
1968
1969	TP_fast_assign(
1970		__entry->dev	= sb->s_dev;
1971		__entry->flags	= map->m_flags;
1972		__entry->lblk	= map->m_lblk;
1973		__entry->pblk	= map->m_pblk;
1974		__entry->len	= map->m_len;
1975		__entry->ret	= ret;
1976	),
1977
1978	TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %s ret %d",
1979		  MAJOR(__entry->dev), MINOR(__entry->dev),
1980		  __entry->lblk, (unsigned long long) __entry->pblk,
1981		  __entry->len, show_mflags(__entry->flags), __entry->ret)
1982);
1983
1984TRACE_EVENT(ext4_ext_show_extent,
1985	TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
1986		 unsigned short len),
1987
1988	TP_ARGS(inode, lblk, pblk, len),
1989
1990	TP_STRUCT__entry(
1991		__field(	dev_t,		dev	)
1992		__field(	ino_t,		ino	)
1993		__field(	ext4_fsblk_t,	pblk	)
1994		__field(	ext4_lblk_t,	lblk	)
1995		__field(	unsigned short,	len	)
1996	),
1997
1998	TP_fast_assign(
1999		__entry->dev	= inode->i_sb->s_dev;
2000		__entry->ino	= inode->i_ino;
2001		__entry->pblk	= pblk;
2002		__entry->lblk	= lblk;
2003		__entry->len	= len;
2004	),
2005
2006	TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
2007		  MAJOR(__entry->dev), MINOR(__entry->dev),
2008		  (unsigned long) __entry->ino,
2009		  (unsigned) __entry->lblk,
2010		  (unsigned long long) __entry->pblk,
2011		  (unsigned short) __entry->len)
2012);
2013
2014TRACE_EVENT(ext4_remove_blocks,
2015	TP_PROTO(struct inode *inode, struct ext4_extent *ex,
2016		 ext4_lblk_t from, ext4_fsblk_t to,
2017		 struct partial_cluster *pc),
2018
2019	TP_ARGS(inode, ex, from, to, pc),
2020
2021	TP_STRUCT__entry(
2022		__field(	dev_t,		dev	)
2023		__field(	ino_t,		ino	)
2024		__field(	ext4_lblk_t,	from	)
2025		__field(	ext4_lblk_t,	to	)
2026		__field(	ext4_fsblk_t,	ee_pblk	)
2027		__field(	ext4_lblk_t,	ee_lblk	)
2028		__field(	unsigned short,	ee_len	)
2029		__field(	ext4_fsblk_t,	pc_pclu	)
2030		__field(	ext4_lblk_t,	pc_lblk	)
2031		__field(	int,		pc_state)
2032	),
2033
2034	TP_fast_assign(
2035		__entry->dev		= inode->i_sb->s_dev;
2036		__entry->ino		= inode->i_ino;
2037		__entry->from		= from;
2038		__entry->to		= to;
2039		__entry->ee_pblk	= ext4_ext_pblock(ex);
2040		__entry->ee_lblk	= le32_to_cpu(ex->ee_block);
2041		__entry->ee_len		= ext4_ext_get_actual_len(ex);
2042		__entry->pc_pclu	= pc->pclu;
2043		__entry->pc_lblk	= pc->lblk;
2044		__entry->pc_state	= pc->state;
2045	),
2046
2047	TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
2048		  "from %u to %u partial [pclu %lld lblk %u state %d]",
2049		  MAJOR(__entry->dev), MINOR(__entry->dev),
2050		  (unsigned long) __entry->ino,
2051		  (unsigned) __entry->ee_lblk,
2052		  (unsigned long long) __entry->ee_pblk,
2053		  (unsigned short) __entry->ee_len,
2054		  (unsigned) __entry->from,
2055		  (unsigned) __entry->to,
2056		  (long long) __entry->pc_pclu,
2057		  (unsigned int) __entry->pc_lblk,
2058		  (int) __entry->pc_state)
2059);
2060
2061TRACE_EVENT(ext4_ext_rm_leaf,
2062	TP_PROTO(struct inode *inode, ext4_lblk_t start,
2063		 struct ext4_extent *ex,
2064		 struct partial_cluster *pc),
2065
2066	TP_ARGS(inode, start, ex, pc),
2067
2068	TP_STRUCT__entry(
2069		__field(	dev_t,		dev	)
2070		__field(	ino_t,		ino	)
2071		__field(	ext4_lblk_t,	start	)
2072		__field(	ext4_lblk_t,	ee_lblk	)
2073		__field(	ext4_fsblk_t,	ee_pblk	)
2074		__field(	short,		ee_len	)
2075		__field(	ext4_fsblk_t,	pc_pclu	)
2076		__field(	ext4_lblk_t,	pc_lblk	)
2077		__field(	int,		pc_state)
2078	),
2079
2080	TP_fast_assign(
2081		__entry->dev		= inode->i_sb->s_dev;
2082		__entry->ino		= inode->i_ino;
2083		__entry->start		= start;
2084		__entry->ee_lblk	= le32_to_cpu(ex->ee_block);
2085		__entry->ee_pblk	= ext4_ext_pblock(ex);
2086		__entry->ee_len		= ext4_ext_get_actual_len(ex);
2087		__entry->pc_pclu	= pc->pclu;
2088		__entry->pc_lblk	= pc->lblk;
2089		__entry->pc_state	= pc->state;
2090	),
2091
2092	TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
2093		  "partial [pclu %lld lblk %u state %d]",
2094		  MAJOR(__entry->dev), MINOR(__entry->dev),
2095		  (unsigned long) __entry->ino,
2096		  (unsigned) __entry->start,
2097		  (unsigned) __entry->ee_lblk,
2098		  (unsigned long long) __entry->ee_pblk,
2099		  (unsigned short) __entry->ee_len,
2100		  (long long) __entry->pc_pclu,
2101		  (unsigned int) __entry->pc_lblk,
2102		  (int) __entry->pc_state)
2103);
2104
2105TRACE_EVENT(ext4_ext_rm_idx,
2106	TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
2107
2108	TP_ARGS(inode, pblk),
2109
2110	TP_STRUCT__entry(
2111		__field(	dev_t,		dev	)
2112		__field(	ino_t,		ino	)
2113		__field(	ext4_fsblk_t,	pblk	)
2114	),
2115
2116	TP_fast_assign(
2117		__entry->dev	= inode->i_sb->s_dev;
2118		__entry->ino	= inode->i_ino;
2119		__entry->pblk	= pblk;
2120	),
2121
2122	TP_printk("dev %d,%d ino %lu index_pblk %llu",
2123		  MAJOR(__entry->dev), MINOR(__entry->dev),
2124		  (unsigned long) __entry->ino,
2125		  (unsigned long long) __entry->pblk)
2126);
2127
2128TRACE_EVENT(ext4_ext_remove_space,
2129	TP_PROTO(struct inode *inode, ext4_lblk_t start,
2130		 ext4_lblk_t end, int depth),
2131
2132	TP_ARGS(inode, start, end, depth),
2133
2134	TP_STRUCT__entry(
2135		__field(	dev_t,		dev	)
2136		__field(	ino_t,		ino	)
2137		__field(	ext4_lblk_t,	start	)
2138		__field(	ext4_lblk_t,	end	)
2139		__field(	int,		depth	)
2140	),
2141
2142	TP_fast_assign(
2143		__entry->dev	= inode->i_sb->s_dev;
2144		__entry->ino	= inode->i_ino;
2145		__entry->start	= start;
2146		__entry->end	= end;
2147		__entry->depth	= depth;
2148	),
2149
2150	TP_printk("dev %d,%d ino %lu since %u end %u depth %d",
2151		  MAJOR(__entry->dev), MINOR(__entry->dev),
2152		  (unsigned long) __entry->ino,
2153		  (unsigned) __entry->start,
2154		  (unsigned) __entry->end,
2155		  __entry->depth)
2156);
2157
2158TRACE_EVENT(ext4_ext_remove_space_done,
2159	TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end,
2160		 int depth, struct partial_cluster *pc, __le16 eh_entries),
2161
2162	TP_ARGS(inode, start, end, depth, pc, eh_entries),
2163
2164	TP_STRUCT__entry(
2165		__field(	dev_t,		dev		)
2166		__field(	ino_t,		ino		)
2167		__field(	ext4_lblk_t,	start		)
2168		__field(	ext4_lblk_t,	end		)
2169		__field(	int,		depth		)
2170		__field(	ext4_fsblk_t,	pc_pclu		)
2171		__field(	ext4_lblk_t,	pc_lblk		)
2172		__field(	int,		pc_state	)
2173		__field(	unsigned short,	eh_entries	)
2174	),
2175
2176	TP_fast_assign(
2177		__entry->dev		= inode->i_sb->s_dev;
2178		__entry->ino		= inode->i_ino;
2179		__entry->start		= start;
2180		__entry->end		= end;
2181		__entry->depth		= depth;
2182		__entry->pc_pclu	= pc->pclu;
2183		__entry->pc_lblk	= pc->lblk;
2184		__entry->pc_state	= pc->state;
2185		__entry->eh_entries	= le16_to_cpu(eh_entries);
2186	),
2187
2188	TP_printk("dev %d,%d ino %lu since %u end %u depth %d "
2189		  "partial [pclu %lld lblk %u state %d] "
2190		  "remaining_entries %u",
2191		  MAJOR(__entry->dev), MINOR(__entry->dev),
2192		  (unsigned long) __entry->ino,
2193		  (unsigned) __entry->start,
2194		  (unsigned) __entry->end,
2195		  __entry->depth,
2196		  (long long) __entry->pc_pclu,
2197		  (unsigned int) __entry->pc_lblk,
2198		  (int) __entry->pc_state,
2199		  (unsigned short) __entry->eh_entries)
2200);
2201
2202DECLARE_EVENT_CLASS(ext4__es_extent,
2203	TP_PROTO(struct inode *inode, struct extent_status *es),
2204
2205	TP_ARGS(inode, es),
2206
2207	TP_STRUCT__entry(
2208		__field(	dev_t,		dev		)
2209		__field(	ino_t,		ino		)
2210		__field(	ext4_lblk_t,	lblk		)
2211		__field(	ext4_lblk_t,	len		)
2212		__field(	ext4_fsblk_t,	pblk		)
2213		__field(	char,		status		)
2214		__field(	u64,		seq		)
2215	),
2216
2217	TP_fast_assign(
2218		__entry->dev	= inode->i_sb->s_dev;
2219		__entry->ino	= inode->i_ino;
2220		__entry->lblk	= es->es_lblk;
2221		__entry->len	= es->es_len;
2222		__entry->pblk	= ext4_es_show_pblock(es);
2223		__entry->status	= ext4_es_status(es);
2224		__entry->seq	= EXT4_I(inode)->i_es_seq;
2225	),
2226
2227	TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s seq %llu",
2228		  MAJOR(__entry->dev), MINOR(__entry->dev),
2229		  (unsigned long) __entry->ino,
2230		  __entry->lblk, __entry->len,
2231		  __entry->pblk, show_extent_status(__entry->status),
2232		  __entry->seq)
2233);
2234
2235DEFINE_EVENT(ext4__es_extent, ext4_es_insert_extent,
2236	TP_PROTO(struct inode *inode, struct extent_status *es),
2237
2238	TP_ARGS(inode, es)
2239);
2240
2241DEFINE_EVENT(ext4__es_extent, ext4_es_cache_extent,
2242	TP_PROTO(struct inode *inode, struct extent_status *es),
2243
2244	TP_ARGS(inode, es)
2245);
2246
2247TRACE_EVENT(ext4_es_remove_extent,
2248	TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
2249
2250	TP_ARGS(inode, lblk, len),
2251
2252	TP_STRUCT__entry(
2253		__field(	dev_t,	dev			)
2254		__field(	ino_t,	ino			)
2255		__field(	loff_t,	lblk			)
2256		__field(	loff_t,	len			)
2257		__field(	u64,	seq			)
2258	),
2259
2260	TP_fast_assign(
2261		__entry->dev	= inode->i_sb->s_dev;
2262		__entry->ino	= inode->i_ino;
2263		__entry->lblk	= lblk;
2264		__entry->len	= len;
2265		__entry->seq	= EXT4_I(inode)->i_es_seq;
2266	),
2267
2268	TP_printk("dev %d,%d ino %lu es [%lld/%lld) seq %llu",
2269		  MAJOR(__entry->dev), MINOR(__entry->dev),
2270		  (unsigned long) __entry->ino,
2271		  __entry->lblk, __entry->len, __entry->seq)
2272);
2273
2274TRACE_EVENT(ext4_es_find_extent_range_enter,
2275	TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
2276
2277	TP_ARGS(inode, lblk),
2278
2279	TP_STRUCT__entry(
2280		__field(	dev_t,		dev		)
2281		__field(	ino_t,		ino		)
2282		__field(	ext4_lblk_t,	lblk		)
2283	),
2284
2285	TP_fast_assign(
2286		__entry->dev	= inode->i_sb->s_dev;
2287		__entry->ino	= inode->i_ino;
2288		__entry->lblk	= lblk;
2289	),
2290
2291	TP_printk("dev %d,%d ino %lu lblk %u",
2292		  MAJOR(__entry->dev), MINOR(__entry->dev),
2293		  (unsigned long) __entry->ino, __entry->lblk)
2294);
2295
2296TRACE_EVENT(ext4_es_find_extent_range_exit,
2297	TP_PROTO(struct inode *inode, struct extent_status *es),
2298
2299	TP_ARGS(inode, es),
2300
2301	TP_STRUCT__entry(
2302		__field(	dev_t,		dev		)
2303		__field(	ino_t,		ino		)
2304		__field(	ext4_lblk_t,	lblk		)
2305		__field(	ext4_lblk_t,	len		)
2306		__field(	ext4_fsblk_t,	pblk		)
2307		__field(	char, status	)
2308	),
2309
2310	TP_fast_assign(
2311		__entry->dev	= inode->i_sb->s_dev;
2312		__entry->ino	= inode->i_ino;
2313		__entry->lblk	= es->es_lblk;
2314		__entry->len	= es->es_len;
2315		__entry->pblk	= ext4_es_show_pblock(es);
2316		__entry->status	= ext4_es_status(es);
2317	),
2318
2319	TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
2320		  MAJOR(__entry->dev), MINOR(__entry->dev),
2321		  (unsigned long) __entry->ino,
2322		  __entry->lblk, __entry->len,
2323		  __entry->pblk, show_extent_status(__entry->status))
2324);
2325
2326TRACE_EVENT(ext4_es_lookup_extent_enter,
2327	TP_PROTO(struct inode *inode, ext4_lblk_t lblk),
2328
2329	TP_ARGS(inode, lblk),
2330
2331	TP_STRUCT__entry(
2332		__field(	dev_t,		dev		)
2333		__field(	ino_t,		ino		)
2334		__field(	ext4_lblk_t,	lblk		)
2335	),
2336
2337	TP_fast_assign(
2338		__entry->dev	= inode->i_sb->s_dev;
2339		__entry->ino	= inode->i_ino;
2340		__entry->lblk	= lblk;
2341	),
2342
2343	TP_printk("dev %d,%d ino %lu lblk %u",
2344		  MAJOR(__entry->dev), MINOR(__entry->dev),
2345		  (unsigned long) __entry->ino, __entry->lblk)
2346);
2347
2348TRACE_EVENT(ext4_es_lookup_extent_exit,
2349	TP_PROTO(struct inode *inode, struct extent_status *es,
2350		 int found),
2351
2352	TP_ARGS(inode, es, found),
2353
2354	TP_STRUCT__entry(
2355		__field(	dev_t,		dev		)
2356		__field(	ino_t,		ino		)
2357		__field(	ext4_lblk_t,	lblk		)
2358		__field(	ext4_lblk_t,	len		)
2359		__field(	ext4_fsblk_t,	pblk		)
2360		__field(	char,		status		)
2361		__field(	int,		found		)
2362	),
2363
2364	TP_fast_assign(
2365		__entry->dev	= inode->i_sb->s_dev;
2366		__entry->ino	= inode->i_ino;
2367		__entry->lblk	= es->es_lblk;
2368		__entry->len	= es->es_len;
2369		__entry->pblk	= ext4_es_show_pblock(es);
2370		__entry->status	= ext4_es_status(es);
2371		__entry->found	= found;
2372	),
2373
2374	TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %s",
2375		  MAJOR(__entry->dev), MINOR(__entry->dev),
2376		  (unsigned long) __entry->ino, __entry->found,
2377		  __entry->lblk, __entry->len,
2378		  __entry->found ? __entry->pblk : 0,
2379		  show_extent_status(__entry->found ? __entry->status : 0))
2380);
2381
2382DECLARE_EVENT_CLASS(ext4__es_shrink_enter,
2383	TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
2384
2385	TP_ARGS(sb, nr_to_scan, cache_cnt),
2386
2387	TP_STRUCT__entry(
2388		__field(	dev_t,	dev			)
2389		__field(	int,	nr_to_scan		)
2390		__field(	int,	cache_cnt		)
2391	),
2392
2393	TP_fast_assign(
2394		__entry->dev		= sb->s_dev;
2395		__entry->nr_to_scan	= nr_to_scan;
2396		__entry->cache_cnt	= cache_cnt;
2397	),
2398
2399	TP_printk("dev %d,%d nr_to_scan %d cache_cnt %d",
2400		  MAJOR(__entry->dev), MINOR(__entry->dev),
2401		  __entry->nr_to_scan, __entry->cache_cnt)
2402);
2403
2404DEFINE_EVENT(ext4__es_shrink_enter, ext4_es_shrink_count,
2405	TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
2406
2407	TP_ARGS(sb, nr_to_scan, cache_cnt)
2408);
2409
2410DEFINE_EVENT(ext4__es_shrink_enter, ext4_es_shrink_scan_enter,
2411	TP_PROTO(struct super_block *sb, int nr_to_scan, int cache_cnt),
2412
2413	TP_ARGS(sb, nr_to_scan, cache_cnt)
2414);
2415
2416TRACE_EVENT(ext4_es_shrink_scan_exit,
2417	TP_PROTO(struct super_block *sb, int nr_shrunk, int cache_cnt),
2418
2419	TP_ARGS(sb, nr_shrunk, cache_cnt),
2420
2421	TP_STRUCT__entry(
2422		__field(	dev_t,	dev			)
2423		__field(	int,	nr_shrunk		)
2424		__field(	int,	cache_cnt		)
2425	),
2426
2427	TP_fast_assign(
2428		__entry->dev		= sb->s_dev;
2429		__entry->nr_shrunk	= nr_shrunk;
2430		__entry->cache_cnt	= cache_cnt;
2431	),
2432
2433	TP_printk("dev %d,%d nr_shrunk %d cache_cnt %d",
2434		  MAJOR(__entry->dev), MINOR(__entry->dev),
2435		  __entry->nr_shrunk, __entry->cache_cnt)
2436);
2437
2438TRACE_EVENT(ext4_collapse_range,
2439	TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
2440
2441	TP_ARGS(inode, offset, len),
2442
2443	TP_STRUCT__entry(
2444		__field(dev_t,	dev)
2445		__field(ino_t,	ino)
2446		__field(loff_t,	offset)
2447		__field(loff_t, len)
2448	),
2449
2450	TP_fast_assign(
2451		__entry->dev	= inode->i_sb->s_dev;
2452		__entry->ino	= inode->i_ino;
2453		__entry->offset	= offset;
2454		__entry->len	= len;
2455	),
2456
2457	TP_printk("dev %d,%d ino %lu offset %lld len %lld",
2458		  MAJOR(__entry->dev), MINOR(__entry->dev),
2459		  (unsigned long) __entry->ino,
2460		  __entry->offset, __entry->len)
2461);
2462
2463TRACE_EVENT(ext4_insert_range,
2464	TP_PROTO(struct inode *inode, loff_t offset, loff_t len),
2465
2466	TP_ARGS(inode, offset, len),
2467
2468	TP_STRUCT__entry(
2469		__field(dev_t,	dev)
2470		__field(ino_t,	ino)
2471		__field(loff_t,	offset)
2472		__field(loff_t, len)
2473	),
2474
2475	TP_fast_assign(
2476		__entry->dev	= inode->i_sb->s_dev;
2477		__entry->ino	= inode->i_ino;
2478		__entry->offset	= offset;
2479		__entry->len	= len;
2480	),
2481
2482	TP_printk("dev %d,%d ino %lu offset %lld len %lld",
2483		  MAJOR(__entry->dev), MINOR(__entry->dev),
2484		  (unsigned long) __entry->ino,
2485		  __entry->offset, __entry->len)
2486);
2487
2488TRACE_EVENT(ext4_es_shrink,
2489	TP_PROTO(struct super_block *sb, int nr_shrunk, u64 scan_time,
2490		 int nr_skipped, int retried),
2491
2492	TP_ARGS(sb, nr_shrunk, scan_time, nr_skipped, retried),
2493
2494	TP_STRUCT__entry(
2495		__field(	dev_t,		dev		)
2496		__field(	int,		nr_shrunk	)
2497		__field(	unsigned long long, scan_time	)
2498		__field(	int,		nr_skipped	)
2499		__field(	int,		retried		)
2500	),
2501
2502	TP_fast_assign(
2503		__entry->dev		= sb->s_dev;
2504		__entry->nr_shrunk	= nr_shrunk;
2505		__entry->scan_time	= div_u64(scan_time, 1000);
2506		__entry->nr_skipped	= nr_skipped;
2507		__entry->retried	= retried;
2508	),
2509
2510	TP_printk("dev %d,%d nr_shrunk %d, scan_time %llu "
2511		  "nr_skipped %d retried %d",
2512		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->nr_shrunk,
2513		  __entry->scan_time, __entry->nr_skipped, __entry->retried)
2514);
2515
2516TRACE_EVENT(ext4_es_insert_delayed_extent,
2517	TP_PROTO(struct inode *inode, struct extent_status *es,
2518		 bool lclu_allocated, bool end_allocated),
2519
2520	TP_ARGS(inode, es, lclu_allocated, end_allocated),
2521
2522	TP_STRUCT__entry(
2523		__field(	dev_t,		dev		)
2524		__field(	ino_t,		ino		)
2525		__field(	ext4_lblk_t,	lblk		)
2526		__field(	ext4_lblk_t,	len		)
2527		__field(	ext4_fsblk_t,	pblk		)
2528		__field(	char,		status		)
2529		__field(	bool,		lclu_allocated	)
2530		__field(	bool,		end_allocated	)
2531		__field(	u64,		seq		)
2532	),
2533
2534	TP_fast_assign(
2535		__entry->dev		= inode->i_sb->s_dev;
2536		__entry->ino		= inode->i_ino;
2537		__entry->lblk		= es->es_lblk;
2538		__entry->len		= es->es_len;
2539		__entry->pblk		= ext4_es_show_pblock(es);
2540		__entry->status		= ext4_es_status(es);
2541		__entry->lclu_allocated	= lclu_allocated;
2542		__entry->end_allocated	= end_allocated;
2543		__entry->seq		= EXT4_I(inode)->i_es_seq;
2544	),
2545
2546	TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s allocated %d %d seq %llu",
2547		  MAJOR(__entry->dev), MINOR(__entry->dev),
2548		  (unsigned long) __entry->ino,
2549		  __entry->lblk, __entry->len,
2550		  __entry->pblk, show_extent_status(__entry->status),
2551		  __entry->lclu_allocated, __entry->end_allocated,
2552		  __entry->seq)
2553);
2554
2555/* fsmap traces */
2556DECLARE_EVENT_CLASS(ext4_fsmap_class,
2557	TP_PROTO(struct super_block *sb, u32 keydev, u32 agno, u64 bno, u64 len,
2558		 u64 owner),
2559	TP_ARGS(sb, keydev, agno, bno, len, owner),
2560	TP_STRUCT__entry(
2561		__field(dev_t, dev)
2562		__field(dev_t, keydev)
2563		__field(u32, agno)
2564		__field(u64, bno)
2565		__field(u64, len)
2566		__field(u64, owner)
2567	),
2568	TP_fast_assign(
2569		__entry->dev = sb->s_bdev->bd_dev;
2570		__entry->keydev = new_decode_dev(keydev);
2571		__entry->agno = agno;
2572		__entry->bno = bno;
2573		__entry->len = len;
2574		__entry->owner = owner;
2575	),
2576	TP_printk("dev %d:%d keydev %d:%d agno %u bno %llu len %llu owner %lld\n",
2577		  MAJOR(__entry->dev), MINOR(__entry->dev),
2578		  MAJOR(__entry->keydev), MINOR(__entry->keydev),
2579		  __entry->agno,
2580		  __entry->bno,
2581		  __entry->len,
2582		  __entry->owner)
2583)
2584#define DEFINE_FSMAP_EVENT(name) \
2585DEFINE_EVENT(ext4_fsmap_class, name, \
2586	TP_PROTO(struct super_block *sb, u32 keydev, u32 agno, u64 bno, u64 len, \
2587		 u64 owner), \
2588	TP_ARGS(sb, keydev, agno, bno, len, owner))
2589DEFINE_FSMAP_EVENT(ext4_fsmap_low_key);
2590DEFINE_FSMAP_EVENT(ext4_fsmap_high_key);
2591DEFINE_FSMAP_EVENT(ext4_fsmap_mapping);
2592
2593DECLARE_EVENT_CLASS(ext4_getfsmap_class,
2594	TP_PROTO(struct super_block *sb, struct ext4_fsmap *fsmap),
2595	TP_ARGS(sb, fsmap),
2596	TP_STRUCT__entry(
2597		__field(dev_t, dev)
2598		__field(dev_t, keydev)
2599		__field(u64, block)
2600		__field(u64, len)
2601		__field(u64, owner)
2602		__field(u64, flags)
2603	),
2604	TP_fast_assign(
2605		__entry->dev = sb->s_bdev->bd_dev;
2606		__entry->keydev = new_decode_dev(fsmap->fmr_device);
2607		__entry->block = fsmap->fmr_physical;
2608		__entry->len = fsmap->fmr_length;
2609		__entry->owner = fsmap->fmr_owner;
2610		__entry->flags = fsmap->fmr_flags;
2611	),
2612	TP_printk("dev %d:%d keydev %d:%d block %llu len %llu owner %lld flags 0x%llx\n",
2613		  MAJOR(__entry->dev), MINOR(__entry->dev),
2614		  MAJOR(__entry->keydev), MINOR(__entry->keydev),
2615		  __entry->block,
2616		  __entry->len,
2617		  __entry->owner,
2618		  __entry->flags)
2619)
2620#define DEFINE_GETFSMAP_EVENT(name) \
2621DEFINE_EVENT(ext4_getfsmap_class, name, \
2622	TP_PROTO(struct super_block *sb, struct ext4_fsmap *fsmap), \
2623	TP_ARGS(sb, fsmap))
2624DEFINE_GETFSMAP_EVENT(ext4_getfsmap_low_key);
2625DEFINE_GETFSMAP_EVENT(ext4_getfsmap_high_key);
2626DEFINE_GETFSMAP_EVENT(ext4_getfsmap_mapping);
2627
2628TRACE_EVENT(ext4_shutdown,
2629	TP_PROTO(struct super_block *sb, unsigned long flags),
2630
2631	TP_ARGS(sb, flags),
2632
2633	TP_STRUCT__entry(
2634		__field(	dev_t,	dev			)
2635		__field(     unsigned,	flags			)
2636	),
2637
2638	TP_fast_assign(
2639		__entry->dev	= sb->s_dev;
2640		__entry->flags	= flags;
2641	),
2642
2643	TP_printk("dev %d,%d flags %u",
2644		  MAJOR(__entry->dev), MINOR(__entry->dev),
2645		  __entry->flags)
2646);
2647
2648TRACE_EVENT(ext4_error,
2649	TP_PROTO(struct super_block *sb, const char *function,
2650		 unsigned int line),
2651
2652	TP_ARGS(sb, function, line),
2653
2654	TP_STRUCT__entry(
2655		__field(	dev_t,	dev			)
2656		__field( const char *,	function		)
2657		__field(     unsigned,	line			)
2658	),
2659
2660	TP_fast_assign(
2661		__entry->dev	= sb->s_dev;
2662		__entry->function = function;
2663		__entry->line	= line;
2664	),
2665
2666	TP_printk("dev %d,%d function %s line %u",
2667		  MAJOR(__entry->dev), MINOR(__entry->dev),
2668		  __entry->function, __entry->line)
2669);
2670
2671TRACE_EVENT(ext4_prefetch_bitmaps,
2672	    TP_PROTO(struct super_block *sb, ext4_group_t group,
2673		     ext4_group_t next, unsigned int prefetch_ios),
2674
2675	TP_ARGS(sb, group, next, prefetch_ios),
2676
2677	TP_STRUCT__entry(
2678		__field(	dev_t,	dev			)
2679		__field(	__u32,	group			)
2680		__field(	__u32,	next			)
2681		__field(	__u32,	ios			)
2682	),
2683
2684	TP_fast_assign(
2685		__entry->dev	= sb->s_dev;
2686		__entry->group	= group;
2687		__entry->next	= next;
2688		__entry->ios	= prefetch_ios;
2689	),
2690
2691	TP_printk("dev %d,%d group %u next %u ios %u",
2692		  MAJOR(__entry->dev), MINOR(__entry->dev),
2693		  __entry->group, __entry->next, __entry->ios)
2694);
2695
2696TRACE_EVENT(ext4_lazy_itable_init,
2697	    TP_PROTO(struct super_block *sb, ext4_group_t group),
2698
2699	TP_ARGS(sb, group),
2700
2701	TP_STRUCT__entry(
2702		__field(	dev_t,	dev			)
2703		__field(	__u32,	group			)
2704	),
2705
2706	TP_fast_assign(
2707		__entry->dev	= sb->s_dev;
2708		__entry->group	= group;
2709	),
2710
2711	TP_printk("dev %d,%d group %u",
2712		  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->group)
2713);
2714
2715TRACE_EVENT(ext4_fc_replay_scan,
2716	TP_PROTO(struct super_block *sb, int error, int off),
2717
2718	TP_ARGS(sb, error, off),
2719
2720	TP_STRUCT__entry(
2721		__field(dev_t, dev)
2722		__field(int, error)
2723		__field(int, off)
2724	),
2725
2726	TP_fast_assign(
2727		__entry->dev = sb->s_dev;
2728		__entry->error = error;
2729		__entry->off = off;
2730	),
2731
2732	TP_printk("dev %d,%d error %d, off %d",
2733		  MAJOR(__entry->dev), MINOR(__entry->dev),
2734		  __entry->error, __entry->off)
2735);
2736
2737TRACE_EVENT(ext4_fc_replay,
2738	TP_PROTO(struct super_block *sb, int tag, int ino, int priv1, int priv2),
2739
2740	TP_ARGS(sb, tag, ino, priv1, priv2),
2741
2742	TP_STRUCT__entry(
2743		__field(dev_t, dev)
2744		__field(int, tag)
2745		__field(int, ino)
2746		__field(int, priv1)
2747		__field(int, priv2)
2748	),
2749
2750	TP_fast_assign(
2751		__entry->dev = sb->s_dev;
2752		__entry->tag = tag;
2753		__entry->ino = ino;
2754		__entry->priv1 = priv1;
2755		__entry->priv2 = priv2;
2756	),
2757
2758	TP_printk("dev %d,%d: tag %d, ino %d, data1 %d, data2 %d",
2759		  MAJOR(__entry->dev), MINOR(__entry->dev),
2760		  __entry->tag, __entry->ino, __entry->priv1, __entry->priv2)
2761);
2762
2763TRACE_EVENT(ext4_fc_commit_start,
2764	TP_PROTO(struct super_block *sb, tid_t commit_tid),
2765
2766	TP_ARGS(sb, commit_tid),
2767
2768	TP_STRUCT__entry(
2769		__field(dev_t, dev)
2770		__field(tid_t, tid)
2771	),
2772
2773	TP_fast_assign(
2774		__entry->dev = sb->s_dev;
2775		__entry->tid = commit_tid;
2776	),
2777
2778	TP_printk("dev %d,%d tid %u", MAJOR(__entry->dev), MINOR(__entry->dev),
2779		  __entry->tid)
2780);
2781
2782TRACE_EVENT(ext4_fc_commit_stop,
2783	    TP_PROTO(struct super_block *sb, int nblks, int reason,
2784		     tid_t commit_tid),
2785
2786	TP_ARGS(sb, nblks, reason, commit_tid),
2787
2788	TP_STRUCT__entry(
2789		__field(dev_t, dev)
2790		__field(int, nblks)
2791		__field(int, reason)
2792		__field(int, num_fc)
2793		__field(int, num_fc_ineligible)
2794		__field(int, nblks_agg)
2795		__field(tid_t, tid)
2796	),
2797
2798	TP_fast_assign(
2799		__entry->dev = sb->s_dev;
2800		__entry->nblks = nblks;
2801		__entry->reason = reason;
2802		__entry->num_fc = EXT4_SB(sb)->s_fc_stats.fc_num_commits;
2803		__entry->num_fc_ineligible =
2804			EXT4_SB(sb)->s_fc_stats.fc_ineligible_commits;
2805		__entry->nblks_agg = EXT4_SB(sb)->s_fc_stats.fc_numblks;
2806		__entry->tid = commit_tid;
2807	),
2808
2809	TP_printk("dev %d,%d nblks %d, reason %d, fc = %d, ineligible = %d, agg_nblks %d, tid %u",
2810		  MAJOR(__entry->dev), MINOR(__entry->dev),
2811		  __entry->nblks, __entry->reason, __entry->num_fc,
2812		  __entry->num_fc_ineligible, __entry->nblks_agg, __entry->tid)
2813);
2814
2815#define FC_REASON_NAME_STAT(reason)					\
2816	show_fc_reason(reason),						\
2817	__entry->fc_ineligible_rc[reason]
2818
2819TRACE_EVENT(ext4_fc_stats,
2820	TP_PROTO(struct super_block *sb),
2821
2822	TP_ARGS(sb),
2823
2824	TP_STRUCT__entry(
2825		__field(dev_t, dev)
2826		__array(unsigned int, fc_ineligible_rc, EXT4_FC_REASON_MAX)
2827		__field(unsigned long, fc_commits)
2828		__field(unsigned long, fc_ineligible_commits)
2829		__field(unsigned long, fc_numblks)
2830	),
2831
2832	TP_fast_assign(
2833		int i;
2834
2835		__entry->dev = sb->s_dev;
2836		for (i = 0; i < EXT4_FC_REASON_MAX; i++) {
2837			__entry->fc_ineligible_rc[i] =
2838				EXT4_SB(sb)->s_fc_stats.fc_ineligible_reason_count[i];
2839		}
2840		__entry->fc_commits = EXT4_SB(sb)->s_fc_stats.fc_num_commits;
2841		__entry->fc_ineligible_commits =
2842			EXT4_SB(sb)->s_fc_stats.fc_ineligible_commits;
2843		__entry->fc_numblks = EXT4_SB(sb)->s_fc_stats.fc_numblks;
2844	),
2845
2846	TP_printk("dev %d,%d fc ineligible reasons:\n"
2847		  "%s:%u, %s:%u, %s:%u, %s:%u, %s:%u, %s:%u, %s:%u, %s:%u, %s:%u, %s:%u"
2848		  "num_commits:%lu, ineligible: %lu, numblks: %lu",
2849		  MAJOR(__entry->dev), MINOR(__entry->dev),
2850		  FC_REASON_NAME_STAT(EXT4_FC_REASON_XATTR),
2851		  FC_REASON_NAME_STAT(EXT4_FC_REASON_CROSS_RENAME),
2852		  FC_REASON_NAME_STAT(EXT4_FC_REASON_JOURNAL_FLAG_CHANGE),
2853		  FC_REASON_NAME_STAT(EXT4_FC_REASON_NOMEM),
2854		  FC_REASON_NAME_STAT(EXT4_FC_REASON_SWAP_BOOT),
2855		  FC_REASON_NAME_STAT(EXT4_FC_REASON_RESIZE),
2856		  FC_REASON_NAME_STAT(EXT4_FC_REASON_RENAME_DIR),
2857		  FC_REASON_NAME_STAT(EXT4_FC_REASON_FALLOC_RANGE),
2858		  FC_REASON_NAME_STAT(EXT4_FC_REASON_INODE_JOURNAL_DATA),
2859		  FC_REASON_NAME_STAT(EXT4_FC_REASON_ENCRYPTED_FILENAME),
2860		  __entry->fc_commits, __entry->fc_ineligible_commits,
2861		  __entry->fc_numblks)
2862);
2863
2864DECLARE_EVENT_CLASS(ext4_fc_track_dentry,
2865
2866	TP_PROTO(handle_t *handle, struct inode *inode,
2867		 struct dentry *dentry, int ret),
2868
2869	TP_ARGS(handle, inode, dentry, ret),
2870
2871	TP_STRUCT__entry(
2872		__field(dev_t, dev)
2873		__field(tid_t, t_tid)
2874		__field(ino_t, i_ino)
2875		__field(tid_t, i_sync_tid)
2876		__field(int, error)
2877	),
2878
2879	TP_fast_assign(
2880		struct ext4_inode_info *ei = EXT4_I(inode);
2881
2882		__entry->dev = inode->i_sb->s_dev;
2883		__entry->t_tid = handle->h_transaction->t_tid;
2884		__entry->i_ino = inode->i_ino;
2885		__entry->i_sync_tid = ei->i_sync_tid;
2886		__entry->error = ret;
2887	),
2888
2889	TP_printk("dev %d,%d, t_tid %u, ino %lu, i_sync_tid %u, error %d",
2890		  MAJOR(__entry->dev), MINOR(__entry->dev),
2891		  __entry->t_tid, __entry->i_ino, __entry->i_sync_tid,
2892		  __entry->error
2893	)
2894);
2895
2896#define DEFINE_EVENT_CLASS_DENTRY(__type)				\
2897DEFINE_EVENT(ext4_fc_track_dentry, ext4_fc_track_##__type,		\
2898	TP_PROTO(handle_t *handle, struct inode *inode,			\
2899		 struct dentry *dentry, int ret),			\
2900	TP_ARGS(handle, inode, dentry, ret)				\
2901)
2902
2903DEFINE_EVENT_CLASS_DENTRY(create);
2904DEFINE_EVENT_CLASS_DENTRY(link);
2905DEFINE_EVENT_CLASS_DENTRY(unlink);
2906
2907TRACE_EVENT(ext4_fc_track_inode,
2908	TP_PROTO(handle_t *handle, struct inode *inode, int ret),
2909
2910	TP_ARGS(handle, inode, ret),
2911
2912	TP_STRUCT__entry(
2913		__field(dev_t, dev)
2914		__field(tid_t, t_tid)
2915		__field(ino_t, i_ino)
2916		__field(tid_t, i_sync_tid)
2917		__field(int, error)
2918	),
2919
2920	TP_fast_assign(
2921		struct ext4_inode_info *ei = EXT4_I(inode);
2922
2923		__entry->dev = inode->i_sb->s_dev;
2924		__entry->t_tid = handle->h_transaction->t_tid;
2925		__entry->i_ino = inode->i_ino;
2926		__entry->i_sync_tid = ei->i_sync_tid;
2927		__entry->error = ret;
2928	),
2929
2930	TP_printk("dev %d:%d, t_tid %u, inode %lu, i_sync_tid %u, error %d",
2931		  MAJOR(__entry->dev), MINOR(__entry->dev),
2932		  __entry->t_tid, __entry->i_ino, __entry->i_sync_tid,
2933		  __entry->error)
2934	);
2935
2936TRACE_EVENT(ext4_fc_track_range,
2937	TP_PROTO(handle_t *handle, struct inode *inode,
2938		 long start, long end, int ret),
2939
2940	TP_ARGS(handle, inode, start, end, ret),
2941
2942	TP_STRUCT__entry(
2943		__field(dev_t, dev)
2944		__field(tid_t, t_tid)
2945		__field(ino_t, i_ino)
2946		__field(tid_t, i_sync_tid)
2947		__field(long, start)
2948		__field(long, end)
2949		__field(int, error)
2950	),
2951
2952	TP_fast_assign(
2953		struct ext4_inode_info *ei = EXT4_I(inode);
2954
2955		__entry->dev = inode->i_sb->s_dev;
2956		__entry->t_tid = handle->h_transaction->t_tid;
2957		__entry->i_ino = inode->i_ino;
2958		__entry->i_sync_tid = ei->i_sync_tid;
2959		__entry->start = start;
2960		__entry->end = end;
2961		__entry->error = ret;
2962	),
2963
2964	TP_printk("dev %d:%d, t_tid %u, inode %lu, i_sync_tid %u, error %d, start %ld, end %ld",
2965		  MAJOR(__entry->dev), MINOR(__entry->dev),
2966		  __entry->t_tid, __entry->i_ino, __entry->i_sync_tid,
2967		  __entry->error, __entry->start, __entry->end)
2968	);
2969
2970TRACE_EVENT(ext4_fc_cleanup,
2971	TP_PROTO(journal_t *journal, int full, tid_t tid),
2972
2973	TP_ARGS(journal, full, tid),
2974
2975	TP_STRUCT__entry(
2976		__field(dev_t, dev)
2977		__field(int, j_fc_off)
2978		__field(int, full)
2979		__field(tid_t, tid)
2980	),
2981
2982	TP_fast_assign(
2983		struct super_block *sb = journal->j_private;
2984
2985		__entry->dev = sb->s_dev;
2986		__entry->j_fc_off = journal->j_fc_off;
2987		__entry->full = full;
2988		__entry->tid = tid;
2989	),
2990
2991	TP_printk("dev %d,%d, j_fc_off %d, full %d, tid %u",
2992		  MAJOR(__entry->dev), MINOR(__entry->dev),
2993		  __entry->j_fc_off, __entry->full, __entry->tid)
2994	);
2995
2996TRACE_EVENT(ext4_update_sb,
2997	TP_PROTO(struct super_block *sb, ext4_fsblk_t fsblk,
2998		 unsigned int flags),
2999
3000	TP_ARGS(sb, fsblk, flags),
3001
3002	TP_STRUCT__entry(
3003		__field(dev_t,		dev)
3004		__field(ext4_fsblk_t,	fsblk)
3005		__field(unsigned int,	flags)
3006	),
3007
3008	TP_fast_assign(
3009		__entry->dev	= sb->s_dev;
3010		__entry->fsblk	= fsblk;
3011		__entry->flags	= flags;
3012	),
3013
3014	TP_printk("dev %d,%d fsblk %llu flags %u",
3015		  MAJOR(__entry->dev), MINOR(__entry->dev),
3016		  __entry->fsblk, __entry->flags)
3017);
3018
3019TRACE_EVENT(ext4_move_extent_enter,
3020	TP_PROTO(struct inode *orig_inode, struct ext4_map_blocks *orig_map,
3021		 struct inode *donor_inode, ext4_lblk_t donor_lblk),
3022
3023	TP_ARGS(orig_inode, orig_map, donor_inode, donor_lblk),
3024
3025	TP_STRUCT__entry(
3026		__field(dev_t, dev)
3027		__field(ino_t, orig_ino)
3028		__field(ext4_lblk_t, orig_lblk)
3029		__field(unsigned int, orig_flags)
3030		__field(ino_t, donor_ino)
3031		__field(ext4_lblk_t, donor_lblk)
3032		__field(unsigned int, len)
3033	),
3034
3035	TP_fast_assign(
3036		__entry->dev		= orig_inode->i_sb->s_dev;
3037		__entry->orig_ino	= orig_inode->i_ino;
3038		__entry->orig_lblk	= orig_map->m_lblk;
3039		__entry->orig_flags	= orig_map->m_flags;
3040		__entry->donor_ino	= donor_inode->i_ino;
3041		__entry->donor_lblk	= donor_lblk;
3042		__entry->len		= orig_map->m_len;
3043	),
3044
3045	TP_printk("dev %d,%d origin ino %lu lblk %u flags %s donor ino %lu lblk %u len %u",
3046		  MAJOR(__entry->dev), MINOR(__entry->dev),
3047		  (unsigned long) __entry->orig_ino,  __entry->orig_lblk,
3048		  show_mflags(__entry->orig_flags),
3049		  (unsigned long) __entry->donor_ino,  __entry->donor_lblk,
3050		  __entry->len)
3051);
3052
3053TRACE_EVENT(ext4_move_extent_exit,
3054	TP_PROTO(struct inode *orig_inode, ext4_lblk_t orig_lblk,
3055		 struct inode *donor_inode, ext4_lblk_t donor_lblk,
3056		 unsigned int m_len, u64 move_len, int move_type, int ret),
3057
3058	TP_ARGS(orig_inode, orig_lblk, donor_inode, donor_lblk, m_len,
3059		move_len, move_type, ret),
3060
3061	TP_STRUCT__entry(
3062		__field(dev_t, dev)
3063		__field(ino_t, orig_ino)
3064		__field(ext4_lblk_t, orig_lblk)
3065		__field(ino_t, donor_ino)
3066		__field(ext4_lblk_t, donor_lblk)
3067		__field(unsigned int, m_len)
3068		__field(u64, move_len)
3069		__field(int, move_type)
3070		__field(int, ret)
3071	),
3072
3073	TP_fast_assign(
3074		__entry->dev		= orig_inode->i_sb->s_dev;
3075		__entry->orig_ino	= orig_inode->i_ino;
3076		__entry->orig_lblk	= orig_lblk;
3077		__entry->donor_ino	= donor_inode->i_ino;
3078		__entry->donor_lblk	= donor_lblk;
3079		__entry->m_len		= m_len;
3080		__entry->move_len	= move_len;
3081		__entry->move_type	= move_type;
3082		__entry->ret		= ret;
3083	),
3084
3085	TP_printk("dev %d,%d origin ino %lu lblk %u donor ino %lu lblk %u m_len %u, move_len %llu type %d ret %d",
3086		  MAJOR(__entry->dev), MINOR(__entry->dev),
3087		  (unsigned long) __entry->orig_ino,  __entry->orig_lblk,
3088		  (unsigned long) __entry->donor_ino,  __entry->donor_lblk,
3089		  __entry->m_len, __entry->move_len, __entry->move_type,
3090		  __entry->ret)
3091);
3092
3093#endif /* _TRACE_EXT4_H */
3094
3095/* This part must be outside protection */
3096#include <trace/define_trace.h>
~/ Read-only file preview.