linux - include/trace/events/btrfs.h

3536 lines · 96.0 KiB

1	/* SPDX-License-Identifier: GPL-2.0 */
2	#undef TRACE_SYSTEM
3	#define TRACE_SYSTEM btrfs
4
5	#if !defined(_TRACE_BTRFS_H) \|\| defined(TRACE_HEADER_MULTI_READ)
6	#define _TRACE_BTRFS_H
7
8	#include <linux/writeback.h>
9	#include <linux/tracepoint.h>
10	#include <trace/events/mmflags.h>
11
12	struct btrfs_root;
13	struct btrfs_fs_info;
14	struct btrfs_inode;
15	struct extent_map;
16	struct btrfs_file_extent_item;
17	struct btrfs_ordered_extent;
18	struct btrfs_delayed_ref_node;
19	struct btrfs_delayed_ref_head;
20	struct btrfs_block_group;
21	struct btrfs_free_cluster;
22	struct btrfs_chunk_map;
23	struct extent_buffer;
24	struct btrfs_work;
25	struct btrfs_workqueue;
26	struct btrfs_qgroup_extent_record;
27	struct btrfs_qgroup;
28	struct extent_io_tree;
29	struct prelim_ref;
30	struct btrfs_space_info;
31	struct btrfs_raid_bio;
32	struct raid56_bio_trace_info;
33	struct find_free_extent_ctl;
34	struct btrfs_trans_handle;
35	struct btrfs_transaction;
36	struct btrfs_log_ctx;
37
38	#define show_inode_type(mode) \
39	__print_symbolic((mode) & S_IFMT, \
40	{ S_IFDIR, "DIR" }, \
41	{ S_IFREG, "REG" }, \
42	{ S_IFLNK, "LNK" }, \
43	{ S_IFIFO, "FIFO" }, \
44	{ S_IFCHR, "CHR" }, \
45	{ S_IFBLK, "BLK" }, \
46	{ S_IFSOCK, "SOCK" })
47
48	#define show_ref_type(type) \
49	__print_symbolic(type, \
50	{ BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \
51	{ BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \
52	{ BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \
53	{ BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" })
54
55	#define __show_root_type(obj) \
56	__print_symbolic_u64(obj, \
57	{ BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
58	{ BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
59	{ BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
60	{ BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
61	{ BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
62	{ BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
63	{ BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
64	{ BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
65	{ BTRFS_QUOTA_TREE_OBJECTID, "QUOTA_TREE" }, \
66	{ BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
67	{ BTRFS_UUID_TREE_OBJECTID, "UUID_TREE" }, \
68	{ BTRFS_FREE_SPACE_TREE_OBJECTID, "FREE_SPACE_TREE" }, \
69	{ BTRFS_BLOCK_GROUP_TREE_OBJECTID, "BLOCK_GROUP_TREE" },\
70	{ BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
71
72	#define show_root_type(obj) \
73	obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) \|\| \
74	(obj >= BTRFS_ROOT_TREE_OBJECTID && \
75	obj <= BTRFS_QUOTA_TREE_OBJECTID)) ? __show_root_type(obj) : "-"
76
77	#define FLUSH_ACTIONS \
78	EM( BTRFS_RESERVE_NO_FLUSH, "BTRFS_RESERVE_NO_FLUSH") \
79	EM( BTRFS_RESERVE_FLUSH_LIMIT, "BTRFS_RESERVE_FLUSH_LIMIT") \
80	EM( BTRFS_RESERVE_FLUSH_ALL, "BTRFS_RESERVE_FLUSH_ALL") \
81	EMe(BTRFS_RESERVE_FLUSH_ALL_STEAL, "BTRFS_RESERVE_FLUSH_ALL_STEAL")
82
83	#define FI_TYPES \
84	EM( BTRFS_FILE_EXTENT_INLINE, "INLINE") \
85	EM( BTRFS_FILE_EXTENT_REG, "REG") \
86	EMe(BTRFS_FILE_EXTENT_PREALLOC, "PREALLOC")
87
88	#define QGROUP_RSV_TYPES \
89	EM( BTRFS_QGROUP_RSV_DATA, "DATA") \
90	EM( BTRFS_QGROUP_RSV_META_PERTRANS, "META_PERTRANS") \
91	EMe(BTRFS_QGROUP_RSV_META_PREALLOC, "META_PREALLOC")
92
93	#define IO_TREE_OWNER \
94	EM( IO_TREE_FS_PINNED_EXTENTS, "PINNED_EXTENTS") \
95	EM( IO_TREE_FS_EXCLUDED_EXTENTS, "EXCLUDED_EXTENTS") \
96	EM( IO_TREE_BTREE_INODE_IO, "BTREE_INODE_IO") \
97	EM( IO_TREE_INODE_IO, "INODE_IO") \
98	EM( IO_TREE_RELOC_BLOCKS, "RELOC_BLOCKS") \
99	EM( IO_TREE_TRANS_DIRTY_PAGES, "TRANS_DIRTY_PAGES") \
100	EM( IO_TREE_ROOT_DIRTY_LOG_PAGES, "ROOT_DIRTY_LOG_PAGES") \
101	EM( IO_TREE_INODE_FILE_EXTENT, "INODE_FILE_EXTENT") \
102	EM( IO_TREE_LOG_CSUM_RANGE, "LOG_CSUM_RANGE") \
103	EMe(IO_TREE_SELFTEST, "SELFTEST")
104
105	#define FLUSH_STATES \
106	EM( FLUSH_DELAYED_ITEMS_NR, "FLUSH_DELAYED_ITEMS_NR") \
107	EM( FLUSH_DELAYED_ITEMS, "FLUSH_DELAYED_ITEMS") \
108	EM( FLUSH_DELALLOC, "FLUSH_DELALLOC") \
109	EM( FLUSH_DELALLOC_WAIT, "FLUSH_DELALLOC_WAIT") \
110	EM( FLUSH_DELALLOC_FULL, "FLUSH_DELALLOC_FULL") \
111	EM( FLUSH_DELAYED_REFS_NR, "FLUSH_DELAYED_REFS_NR") \
112	EM( FLUSH_DELAYED_REFS, "FLUSH_DELAYED_REFS") \
113	EM( ALLOC_CHUNK, "ALLOC_CHUNK") \
114	EM( ALLOC_CHUNK_FORCE, "ALLOC_CHUNK_FORCE") \
115	EM( RUN_DELAYED_IPUTS, "RUN_DELAYED_IPUTS") \
116	EM( COMMIT_TRANS, "COMMIT_TRANS") \
117	EM( RECLAIM_ZONES, "RECLAIM_ZONES") \
118	EMe(RESET_ZONES, "RESET_ZONES")
119
120	#define TRANSACTION_STATES \
121	EM( TRANS_STATE_RUNNING, "TRANS_STATE_RUNNING") \
122	EM( TRANS_STATE_COMMIT_PREP, "TRANS_STATE_COMMIT_PREP") \
123	EM( TRANS_STATE_COMMIT_START, "TRANS_STATE_COMMIT_START") \
124	EM( TRANS_STATE_COMMIT_DOING, "TRANS_STATE_COMMIT_DOING") \
125	EM( TRANS_STATE_UNBLOCKED, "TRANS_STATE_UNBLOCKED") \
126	EM( TRANS_STATE_SUPER_COMMITTED, "TRANS_STATE_SUPER_COMMITTED") \
127	EMe(TRANS_STATE_COMPLETED, "TRANS_STATE_COMPLETED")
128
129	#define LOG_MODES \
130	EM( LOG_INODE_ALL, "LOG_INODE_ALL") \
131	EMe(LOG_INODE_EXISTS, "LOG_INODE_EXISTS")
132	/*
133	* First define the enums in the above macros to be exported to userspace via
134	* TRACE_DEFINE_ENUM().
135	*/
136
137	#undef EM
138	#undef EMe
139	#define EM(a, b) TRACE_DEFINE_ENUM(a);
140	#define EMe(a, b) TRACE_DEFINE_ENUM(a);
141
142	FLUSH_ACTIONS
143	FI_TYPES
144	QGROUP_RSV_TYPES
145	IO_TREE_OWNER
146	FLUSH_STATES
147	TRANSACTION_STATES
148	LOG_MODES
149
150	/*
151	* Now redefine the EM and EMe macros to map the enums to the strings that will
152	* be printed in the output
153	*/
154
155	#undef EM
156	#undef EMe
157	#define EM(a, b) {a, b},
158	#define EMe(a, b) {a, b}
159
160
161	#define BTRFS_GROUP_FLAGS \
162	{ BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
163	{ BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
164	{ BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
165	{ BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
166	{ BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
167	{ BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
168	{ BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
169	{ BTRFS_BLOCK_GROUP_RAID5, "RAID5"}, \
170	{ BTRFS_BLOCK_GROUP_RAID6, "RAID6"}
171
172	#define EXTENT_FLAGS \
173	{ EXTENT_DIRTY, "DIRTY"}, \
174	{ EXTENT_LOCKED, "LOCKED"}, \
175	{ EXTENT_DIRTY_LOG1, "DIRTY_LOG1"}, \
176	{ EXTENT_DIRTY_LOG2, "DIRTY_LOG2"}, \
177	{ EXTENT_DELALLOC, "DELALLOC"}, \
178	{ EXTENT_DEFRAG, "DEFRAG"}, \
179	{ EXTENT_BOUNDARY, "BOUNDARY"}, \
180	{ EXTENT_NODATASUM, "NODATASUM"}, \
181	{ EXTENT_CLEAR_META_RESV, "CLEAR_META_RESV"}, \
182	{ EXTENT_NEED_WAIT, "NEED_WAIT"}, \
183	{ EXTENT_NORESERVE, "NORESERVE"}, \
184	{ EXTENT_QGROUP_RESERVED, "QGROUP_RESERVED"}, \
185	{ EXTENT_CLEAR_DATA_RESV, "CLEAR_DATA_RESV"}, \
186	{ EXTENT_DELALLOC_NEW, "DELALLOC_NEW"}
187
188	#define BTRFS_FSID_SIZE 16
189	#define TP_STRUCT__entry_fsid __array(u8, fsid, BTRFS_FSID_SIZE)
190
191	#define TP_fast_assign_fsid(fs_info) \
192	({ \
193	if (fs_info) \
194	memcpy(__entry->fsid, fs_info->fs_devices->fsid, \
195	BTRFS_FSID_SIZE); \
196	else \
197	memset(__entry->fsid, 0, BTRFS_FSID_SIZE); \
198	})
199
200	#define TP_STRUCT__entry_btrfs(args...) \
201	TP_STRUCT__entry( \
202	TP_STRUCT__entry_fsid \
203	args)
204	#define TP_fast_assign_btrfs(fs_info, args...) \
205	TP_fast_assign( \
206	TP_fast_assign_fsid(fs_info); \
207	args)
208	#define TP_printk_btrfs(fmt, args...) \
209	TP_printk("%pU: " fmt, __entry->fsid, args)
210
211	TRACE_EVENT(btrfs_transaction_start,
212
213	TP_PROTO(const struct btrfs_transaction *trans),
214
215	TP_ARGS(trans),
216
217	TP_STRUCT__entry_btrfs(
218	__field( u64, generation )
219	),
220
221	TP_fast_assign_btrfs(trans->fs_info,
222	__entry->generation = trans->transid;
223	),
224
225	TP_printk_btrfs("gen=%llu", __entry->generation)
226	);
227
228	TRACE_EVENT(btrfs_transaction_commit,
229
230	TP_PROTO(const struct btrfs_trans_handle *trans),
231
232	TP_ARGS(trans),
233
234	TP_STRUCT__entry_btrfs(
235	__field( u64, generation )
236	__field( bool, in_fsync )
237	__field( int, state )
238	),
239
240	TP_fast_assign_btrfs(trans->fs_info,
241	__entry->generation = trans->transid;
242	__entry->in_fsync = trans->in_fsync;
243	__entry->state = trans->transaction->state;
244	),
245
246	TP_printk_btrfs("gen=%llu in_fsync=%d state=%d(%s)", __entry->generation,
247	__entry->in_fsync, __entry->state,
248	__print_symbolic(__entry->state, TRANSACTION_STATES))
249	);
250
251	TRACE_EVENT(btrfs_transaction_abort,
252
253	TP_PROTO(const struct btrfs_trans_handle *trans),
254
255	TP_ARGS(trans),
256
257	TP_STRUCT__entry_btrfs(
258	__field( u64, generation )
259	__field( bool, in_fsync )
260	__field( int, error )
261	),
262
263	TP_fast_assign_btrfs(trans->fs_info,
264	__entry->generation = trans->transid;
265	__entry->in_fsync = trans->in_fsync;
266	__entry->error = trans->aborted;
267	),
268
269	TP_printk_btrfs("gen=%llu in_fsync=%d error=%d", __entry->generation,
270	__entry->in_fsync, __entry->error)
271	);
272
273	DECLARE_EVENT_CLASS(btrfs__inode,
274
275	TP_PROTO(const struct inode *inode),
276
277	TP_ARGS(inode),
278
279	TP_STRUCT__entry_btrfs(
280	__field( u64, ino )
281	__field( u64, blocks )
282	__field( u64, disk_i_size )
283	__field( u64, generation )
284	__field( u64, last_trans )
285	__field( u64, logged_trans )
286	__field( u64, root_objectid )
287	),
288
289	TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
290	__entry->ino = btrfs_ino(BTRFS_I(inode));
291	__entry->blocks = inode->i_blocks;
292	__entry->disk_i_size = BTRFS_I(inode)->disk_i_size;
293	__entry->generation = BTRFS_I(inode)->generation;
294	__entry->last_trans = BTRFS_I(inode)->last_trans;
295	__entry->logged_trans = BTRFS_I(inode)->logged_trans;
296	__entry->root_objectid = BTRFS_I(inode)->root ?
297	btrfs_root_id(BTRFS_I(inode)->root) : 0;
298	),
299
300	TP_printk_btrfs("root=%llu(%s) gen=%llu ino=%llu blocks=%llu "
301	"disk_i_size=%llu last_trans=%llu logged_trans=%llu",
302	show_root_type(__entry->root_objectid),
303	__entry->generation,
304	__entry->ino,
305	__entry->blocks,
306	__entry->disk_i_size,
307	__entry->last_trans,
308	__entry->logged_trans)
309	);
310
311	DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
312
313	TP_PROTO(const struct inode *inode),
314
315	TP_ARGS(inode)
316	);
317
318	DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
319
320	TP_PROTO(const struct inode *inode),
321
322	TP_ARGS(inode)
323	);
324
325	DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
326
327	TP_PROTO(const struct inode *inode),
328
329	TP_ARGS(inode)
330	);
331
332	#define __show_map_type(type) \
333	__print_symbolic_u64(type, \
334	{ EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
335	{ EXTENT_MAP_HOLE, "HOLE" }, \
336	{ EXTENT_MAP_INLINE, "INLINE" })
337
338	#define show_map_type(type) \
339	type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type)
340
341	#define show_map_flags(flag) \
342	__print_flags(flag, "\|", \
343	{ EXTENT_FLAG_PINNED, "PINNED" },\
344	{ EXTENT_FLAG_COMPRESS_ZLIB, "COMPRESS_ZLIB" },\
345	{ EXTENT_FLAG_COMPRESS_LZO, "COMPRESS_LZO" },\
346	{ EXTENT_FLAG_COMPRESS_ZSTD, "COMPRESS_ZSTD" },\
347	{ EXTENT_FLAG_PREALLOC, "PREALLOC" },\
348	{ EXTENT_FLAG_LOGGING, "LOGGING" })
349
350	TRACE_EVENT_CONDITION(btrfs_get_extent,
351
352	TP_PROTO(const struct btrfs_root root, const struct btrfs_inode inode,
353	const struct extent_map *map),
354
355	TP_ARGS(root, inode, map),
356
357	TP_CONDITION(map),
358
359	TP_STRUCT__entry_btrfs(
360	__field( u64, root_objectid )
361	__field( u64, ino )
362	__field( u64, start )
363	__field( u64, len )
364	__field( u32, flags )
365	__field( int, refs )
366	),
367
368	TP_fast_assign_btrfs(root->fs_info,
369	__entry->root_objectid = btrfs_root_id(root);
370	__entry->ino = btrfs_ino(inode);
371	__entry->start = map->start;
372	__entry->len = map->len;
373	__entry->flags = map->flags;
374	__entry->refs = refcount_read(&map->refs);
375	),
376
377	TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu flags=%s refs=%u",
378	show_root_type(__entry->root_objectid),
379	__entry->ino,
380	__entry->start,
381	__entry->len,
382	show_map_flags(__entry->flags),
383	__entry->refs)
384	);
385
386	TRACE_EVENT(btrfs_handle_em_exist,
387
388	TP_PROTO(const struct btrfs_fs_info *fs_info,
389	const struct extent_map existing, const struct extent_map map,
390	u64 start, u64 len),
391
392	TP_ARGS(fs_info, existing, map, start, len),
393
394	TP_STRUCT__entry_btrfs(
395	__field( u64, e_start )
396	__field( u64, e_len )
397	__field( u64, map_start )
398	__field( u64, map_len )
399	__field( u64, start )
400	__field( u64, len )
401	),
402
403	TP_fast_assign_btrfs(fs_info,
404	__entry->e_start = existing->start;
405	__entry->e_len = existing->len;
406	__entry->map_start = map->start;
407	__entry->map_len = map->len;
408	__entry->start = start;
409	__entry->len = len;
410	),
411
412	TP_printk_btrfs("start=%llu len=%llu "
413	"existing(start=%llu len=%llu) "
414	"em(start=%llu len=%llu)",
415	__entry->start,
416	__entry->len,
417	__entry->e_start,
418	__entry->e_len,
419	__entry->map_start,
420	__entry->map_len)
421	);
422
423	/* file extent item */
424	DECLARE_EVENT_CLASS(btrfs__file_extent_item_regular,
425
426	TP_PROTO(const struct btrfs_inode bi, const struct extent_buffer l,
427	const struct btrfs_file_extent_item *fi, u64 start),
428
429	TP_ARGS(bi, l, fi, start),
430
431	TP_STRUCT__entry_btrfs(
432	__field( u64, root_obj )
433	__field( u64, ino )
434	__field( loff_t, isize )
435	__field( u64, disk_isize )
436	__field( u64, num_bytes )
437	__field( u64, ram_bytes )
438	__field( u64, disk_bytenr )
439	__field( u64, disk_num_bytes )
440	__field( u64, extent_offset )
441	__field( u8, extent_type )
442	__field( u8, compression )
443	__field( u64, extent_start )
444	__field( u64, extent_end )
445	),
446
447	TP_fast_assign_btrfs(bi->root->fs_info,
448	__entry->root_obj = btrfs_root_id(bi->root);
449	__entry->ino = btrfs_ino(bi);
450	__entry->isize = bi->vfs_inode.i_size;
451	__entry->disk_isize = bi->disk_i_size;
452	__entry->num_bytes = btrfs_file_extent_num_bytes(l, fi);
453	__entry->ram_bytes = btrfs_file_extent_ram_bytes(l, fi);
454	__entry->disk_bytenr = btrfs_file_extent_disk_bytenr(l, fi);
455	__entry->disk_num_bytes = btrfs_file_extent_disk_num_bytes(l, fi);
456	__entry->extent_offset = btrfs_file_extent_offset(l, fi);
457	__entry->extent_type = btrfs_file_extent_type(l, fi);
458	__entry->compression = btrfs_file_extent_compression(l, fi);
459	__entry->extent_start = start;
460	__entry->extent_end = (start + __entry->num_bytes);
461	),
462
463	TP_printk_btrfs(
464	"root=%llu(%s) inode=%llu size=%llu disk_isize=%llu "
465	"file extent range=[%llu %llu] "
466	"(num_bytes=%llu ram_bytes=%llu disk_bytenr=%llu "
467	"disk_num_bytes=%llu extent_offset=%llu type=%s "
468	"compression=%u",
469	show_root_type(__entry->root_obj), __entry->ino,
470	__entry->isize,
471	__entry->disk_isize, __entry->extent_start,
472	__entry->extent_end, __entry->num_bytes, __entry->ram_bytes,
473	__entry->disk_bytenr, __entry->disk_num_bytes,
474	__entry->extent_offset, __print_symbolic(__entry->extent_type, FI_TYPES),
475	__entry->compression)
476	);
477
478	DECLARE_EVENT_CLASS(
479	btrfs__file_extent_item_inline,
480
481	TP_PROTO(const struct btrfs_inode bi, const struct extent_buffer l,
482	const struct btrfs_file_extent_item *fi, int slot, u64 start),
483
484	TP_ARGS(bi, l, fi, slot, start),
485
486	TP_STRUCT__entry_btrfs(
487	__field( u64, root_obj )
488	__field( u64, ino )
489	__field( loff_t, isize )
490	__field( u64, disk_isize )
491	__field( u8, extent_type )
492	__field( u8, compression )
493	__field( u64, extent_start )
494	__field( u64, extent_end )
495	),
496
497	TP_fast_assign_btrfs(
498	bi->root->fs_info,
499	__entry->root_obj = btrfs_root_id(bi->root);
500	__entry->ino = btrfs_ino(bi);
501	__entry->isize = bi->vfs_inode.i_size;
502	__entry->disk_isize = bi->disk_i_size;
503	__entry->extent_type = btrfs_file_extent_type(l, fi);
504	__entry->compression = btrfs_file_extent_compression(l, fi);
505	__entry->extent_start = start;
506	__entry->extent_end = (start + btrfs_file_extent_ram_bytes(l, fi));
507	),
508
509	TP_printk_btrfs(
510	"root=%llu(%s) inode=%llu size=%llu disk_isize=%llu "
511	"file extent range=[%llu %llu] "
512	"extent_type=%s compression=%u",
513	show_root_type(__entry->root_obj), __entry->ino, __entry->isize,
514	__entry->disk_isize, __entry->extent_start,
515	__entry->extent_end, __print_symbolic(__entry->extent_type, FI_TYPES),
516	__entry->compression)
517	);
518
519	DEFINE_EVENT(
520	btrfs__file_extent_item_regular, btrfs_get_extent_show_fi_regular,
521
522	TP_PROTO(const struct btrfs_inode bi, const struct extent_buffer l,
523	const struct btrfs_file_extent_item *fi, u64 start),
524
525	TP_ARGS(bi, l, fi, start)
526	);
527
528	DEFINE_EVENT(
529	btrfs__file_extent_item_regular, btrfs_truncate_show_fi_regular,
530
531	TP_PROTO(const struct btrfs_inode bi, const struct extent_buffer l,
532	const struct btrfs_file_extent_item *fi, u64 start),
533
534	TP_ARGS(bi, l, fi, start)
535	);
536
537	DEFINE_EVENT(
538	btrfs__file_extent_item_inline, btrfs_get_extent_show_fi_inline,
539
540	TP_PROTO(const struct btrfs_inode bi, const struct extent_buffer l,
541	const struct btrfs_file_extent_item *fi, int slot, u64 start),
542
543	TP_ARGS(bi, l, fi, slot, start)
544	);
545
546	DEFINE_EVENT(
547	btrfs__file_extent_item_inline, btrfs_truncate_show_fi_inline,
548
549	TP_PROTO(const struct btrfs_inode bi, const struct extent_buffer l,
550	const struct btrfs_file_extent_item *fi, int slot, u64 start),
551
552	TP_ARGS(bi, l, fi, slot, start)
553	);
554
555	#define show_ordered_flags(flags) \
556	__print_flags(flags, "\|", \
557	{ (1 << BTRFS_ORDERED_REGULAR), "REGULAR" }, \
558	{ (1 << BTRFS_ORDERED_NOCOW), "NOCOW" }, \
559	{ (1 << BTRFS_ORDERED_PREALLOC), "PREALLOC" }, \
560	{ (1 << BTRFS_ORDERED_COMPRESSED), "COMPRESSED" }, \
561	{ (1 << BTRFS_ORDERED_DIRECT), "DIRECT" }, \
562	{ (1 << BTRFS_ORDERED_IO_DONE), "IO_DONE" }, \
563	{ (1 << BTRFS_ORDERED_COMPLETE), "COMPLETE" }, \
564	{ (1 << BTRFS_ORDERED_IOERR), "IOERR" }, \
565	{ (1 << BTRFS_ORDERED_TRUNCATED), "TRUNCATED" })
566
567
568	DECLARE_EVENT_CLASS(btrfs__ordered_extent,
569
570	TP_PROTO(const struct btrfs_inode *inode,
571	const struct btrfs_ordered_extent *ordered),
572
573	TP_ARGS(inode, ordered),
574
575	TP_STRUCT__entry_btrfs(
576	__field( u64, ino )
577	__field( u64, file_offset )
578	__field( u64, start )
579	__field( u64, len )
580	__field( u64, disk_len )
581	__field( u64, bytes_left )
582	__field( unsigned long, flags )
583	__field( int, compress_type )
584	__field( int, refs )
585	__field( u64, root_objectid )
586	__field( u64, truncated_len )
587	),
588
589	TP_fast_assign_btrfs(inode->root->fs_info,
590	__entry->ino = btrfs_ino(inode);
591	__entry->file_offset = ordered->file_offset;
592	__entry->start = ordered->disk_bytenr;
593	__entry->len = ordered->num_bytes;
594	__entry->disk_len = ordered->disk_num_bytes;
595	__entry->bytes_left = ordered->bytes_left;
596	__entry->flags = ordered->flags;
597	__entry->compress_type = ordered->compress_type;
598	__entry->refs = refcount_read(&ordered->refs);
599	__entry->root_objectid = btrfs_root_id(inode->root);
600	__entry->truncated_len = ordered->truncated_len;
601	),
602
603	TP_printk_btrfs("root=%llu(%s) ino=%llu file_offset=%llu "
604	"start=%llu len=%llu disk_len=%llu "
605	"truncated_len=%llu "
606	"bytes_left=%llu flags=%s compress_type=%d "
607	"refs=%d",
608	show_root_type(__entry->root_objectid),
609	__entry->ino,
610	__entry->file_offset,
611	__entry->start,
612	__entry->len,
613	__entry->disk_len,
614	__entry->truncated_len,
615	__entry->bytes_left,
616	show_ordered_flags(__entry->flags),
617	__entry->compress_type, __entry->refs)
618	);
619
620	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
621
622	TP_PROTO(const struct btrfs_inode *inode,
623	const struct btrfs_ordered_extent *ordered),
624
625	TP_ARGS(inode, ordered)
626	);
627
628	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
629
630	TP_PROTO(const struct btrfs_inode *inode,
631	const struct btrfs_ordered_extent *ordered),
632
633	TP_ARGS(inode, ordered)
634	);
635
636	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
637
638	TP_PROTO(const struct btrfs_inode *inode,
639	const struct btrfs_ordered_extent *ordered),
640
641	TP_ARGS(inode, ordered)
642	);
643
644	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
645
646	TP_PROTO(const struct btrfs_inode *inode,
647	const struct btrfs_ordered_extent *ordered),
648
649	TP_ARGS(inode, ordered)
650	);
651
652	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup,
653
654	TP_PROTO(const struct btrfs_inode *inode,
655	const struct btrfs_ordered_extent *ordered),
656
657	TP_ARGS(inode, ordered)
658	);
659
660	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_range,
661
662	TP_PROTO(const struct btrfs_inode *inode,
663	const struct btrfs_ordered_extent *ordered),
664
665	TP_ARGS(inode, ordered)
666	);
667
668	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_first_range,
669
670	TP_PROTO(const struct btrfs_inode *inode,
671	const struct btrfs_ordered_extent *ordered),
672
673	TP_ARGS(inode, ordered)
674	);
675
676	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_for_logging,
677
678	TP_PROTO(const struct btrfs_inode *inode,
679	const struct btrfs_ordered_extent *ordered),
680
681	TP_ARGS(inode, ordered)
682	);
683
684	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_lookup_first,
685
686	TP_PROTO(const struct btrfs_inode *inode,
687	const struct btrfs_ordered_extent *ordered),
688
689	TP_ARGS(inode, ordered)
690	);
691
692	/*
693	* The writepage fixup worker deferred a block because this still-running
694	* ordered extent covers it.
695	*/
696	DEFINE_EVENT(btrfs__ordered_extent, btrfs_writepage_fixup_defer,
697
698	TP_PROTO(const struct btrfs_inode *inode,
699	const struct btrfs_ordered_extent *ordered),
700
701	TP_ARGS(inode, ordered)
702	);
703
704	/* The writepage fixup worker reserved space for a block and set delalloc. */
705	TRACE_EVENT(btrfs_writepage_fixup_reserve,
706
707	TP_PROTO(const struct btrfs_inode *inode, u64 start, u32 len),
708
709	TP_ARGS(inode, start, len),
710
711	TP_STRUCT__entry_btrfs(
712	__field( u64, ino )
713	__field( u64, start )
714	__field( u32, len )
715	),
716
717	TP_fast_assign_btrfs(inode->root->fs_info,
718	__entry->ino = btrfs_ino(inode);
719	__entry->start = start;
720	__entry->len = len;
721	),
722
723	TP_printk_btrfs("ino=%llu start=%llu len=%u",
724	__entry->ino, __entry->start, __entry->len)
725	);
726
727	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_split,
728
729	TP_PROTO(const struct btrfs_inode *inode,
730	const struct btrfs_ordered_extent *ordered),
731
732	TP_ARGS(inode, ordered)
733	);
734
735	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_dec_test_pending,
736
737	TP_PROTO(const struct btrfs_inode *inode,
738	const struct btrfs_ordered_extent *ordered),
739
740	TP_ARGS(inode, ordered)
741	);
742
743	DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_mark_finished,
744
745	TP_PROTO(const struct btrfs_inode *inode,
746	const struct btrfs_ordered_extent *ordered),
747
748	TP_ARGS(inode, ordered)
749	);
750
751	TRACE_EVENT(btrfs_finish_ordered_extent,
752
753	TP_PROTO(const struct btrfs_inode *inode, u64 start, u64 len,
754	bool uptodate),
755
756	TP_ARGS(inode, start, len, uptodate),
757
758	TP_STRUCT__entry_btrfs(
759	__field( u64, ino )
760	__field( u64, start )
761	__field( u64, len )
762	__field( bool, uptodate )
763	__field( u64, root_objectid )
764	),
765
766	TP_fast_assign_btrfs(inode->root->fs_info,
767	__entry->ino = btrfs_ino(inode);
768	__entry->start = start;
769	__entry->len = len;
770	__entry->uptodate = uptodate;
771	__entry->root_objectid = btrfs_root_id(inode->root);
772	),
773
774	TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu uptodate=%d",
775	show_root_type(__entry->root_objectid),
776	__entry->ino, __entry->start,
777	__entry->len, __entry->uptodate)
778	);
779
780	DECLARE_EVENT_CLASS(btrfs__writepage,
781
782	TP_PROTO(const struct folio folio, const struct inode inode,
783	const struct writeback_control *wbc),
784
785	TP_ARGS(folio, inode, wbc),
786
787	TP_STRUCT__entry_btrfs(
788	__field( u64, ino )
789	__field( pgoff_t, index )
790	__field( long, nr_to_write )
791	__field( long, pages_skipped )
792	__field( loff_t, range_start )
793	__field( loff_t, range_end )
794	__field( char, for_kupdate )
795	__field( char, range_cyclic )
796	__field( unsigned long, writeback_index )
797	__field( u64, root_objectid )
798	),
799
800	TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
801	__entry->ino = btrfs_ino(BTRFS_I(inode));
802	__entry->index = folio->index;
803	__entry->nr_to_write = wbc->nr_to_write;
804	__entry->pages_skipped = wbc->pages_skipped;
805	__entry->range_start = wbc->range_start;
806	__entry->range_end = wbc->range_end;
807	__entry->for_kupdate = wbc->for_kupdate;
808	__entry->range_cyclic = wbc->range_cyclic;
809	__entry->writeback_index = inode->i_mapping->writeback_index;
810	__entry->root_objectid = btrfs_root_id(BTRFS_I(inode)->root);
811	),
812
813	TP_printk_btrfs("root=%llu(%s) ino=%llu page_index=%lu "
814	"nr_to_write=%ld pages_skipped=%ld range_start=%llu "
815	"range_end=%llu for_kupdate=%d "
816	"range_cyclic=%d writeback_index=%lu",
817	show_root_type(__entry->root_objectid),
818	__entry->ino, __entry->index,
819	__entry->nr_to_write, __entry->pages_skipped,
820	__entry->range_start, __entry->range_end,
821	__entry->for_kupdate, __entry->range_cyclic,
822	__entry->writeback_index)
823	);
824
825	DEFINE_EVENT(btrfs__writepage, extent_writepage,
826
827	TP_PROTO(const struct folio folio, const struct inode inode,
828	const struct writeback_control *wbc),
829
830	TP_ARGS(folio, inode, wbc)
831	);
832
833	TRACE_EVENT(btrfs_writepage_end_io_hook,
834
835	TP_PROTO(const struct btrfs_inode *inode, u64 start, u64 end,
836	int uptodate),
837
838	TP_ARGS(inode, start, end, uptodate),
839
840	TP_STRUCT__entry_btrfs(
841	__field( u64, ino )
842	__field( u64, start )
843	__field( u64, end )
844	__field( int, uptodate )
845	__field( u64, root_objectid )
846	),
847
848	TP_fast_assign_btrfs(inode->root->fs_info,
849	__entry->ino = btrfs_ino(inode);
850	__entry->start = start;
851	__entry->end = end;
852	__entry->uptodate = uptodate;
853	__entry->root_objectid = btrfs_root_id(inode->root);
854	),
855
856	TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu end=%llu uptodate=%d",
857	show_root_type(__entry->root_objectid),
858	__entry->ino, __entry->start,
859	__entry->end, __entry->uptodate)
860	);
861
862	TRACE_EVENT(btrfs_sync_file_enter,
863
864	TP_PROTO(const struct file *file, int datasync),
865
866	TP_ARGS(file, datasync),
867
868	TP_STRUCT__entry_btrfs(
869	__field( u64, ino )
870	__field( umode_t, mode )
871	__field( u64, parent )
872	__field( int, datasync )
873	__field( u64, root_objectid )
874	),
875
876	TP_fast_assign(
877	struct dentry *dentry = file_dentry(file);
878	struct inode *inode = file_inode(file);
879	struct inode *parent_inode = d_inode(dentry->d_parent);
880
881	TP_fast_assign_fsid(btrfs_sb(inode->i_sb));
882	__entry->ino = btrfs_ino(BTRFS_I(inode));
883	__entry->parent = btrfs_ino(BTRFS_I(parent_inode));
884	__entry->datasync = datasync;
885	__entry->root_objectid = btrfs_root_id(BTRFS_I(inode)->root);
886	__entry->mode = inode->i_mode;
887	),
888
889	TP_printk_btrfs("root=%llu(%s) ino=%llu type=%s parent=%llu datasync=%d",
890	show_root_type(__entry->root_objectid), __entry->ino,
891	show_inode_type(__entry->mode), __entry->parent,
892	__entry->datasync)
893	);
894
895	TRACE_EVENT(btrfs_sync_file_exit,
896
897	TP_PROTO(const struct file *file, int ret),
898
899	TP_ARGS(file, ret),
900
901	TP_STRUCT__entry_btrfs(
902	__field( u64, ino )
903	__field( int, ret )
904	__field( u64, root_objectid )
905	),
906
907	TP_fast_assign(
908	struct btrfs_inode *inode = BTRFS_I(file_inode(file));
909
910	TP_fast_assign_fsid(inode->root->fs_info);
911	__entry->root_objectid = btrfs_root_id(inode->root);
912	__entry->ino = btrfs_ino(inode);
913	__entry->ret = ret;
914	),
915
916	TP_printk_btrfs("root=%llu(%s) ino=%llu ret=%d",
917	show_root_type(__entry->root_objectid),
918	__entry->ino, __entry->ret)
919	);
920
921	TRACE_EVENT(btrfs_log_inode_parent_enter,
922
923	TP_PROTO(const struct btrfs_trans_handle trans, struct btrfs_inode inode),
924
925	TP_ARGS(trans, inode),
926
927	TP_STRUCT__entry_btrfs(
928	__field( u64, root_objectid )
929	__field( u64, ino )
930	__field( umode_t, mode )
931	__field( u64, transid )
932	__field( u64, generation )
933	__field( u64, logged_trans )
934	__field( u64, last_unlink_trans )
935	__field( int, last_sub_trans )
936	__field( int, inode_last_log_commit )
937	__field( int, root_last_log_commit )
938	),
939
940	TP_fast_assign(
941	struct btrfs_root *root = inode->root;
942
943	TP_fast_assign_fsid(root->fs_info);
944	__entry->root_objectid = btrfs_root_id(root);
945	__entry->ino = btrfs_ino(inode);
946	__entry->mode = inode->vfs_inode.i_mode;
947	__entry->transid = trans->transid;
948	__entry->generation = inode->generation;
949	spin_lock(&inode->lock);
950	__entry->logged_trans = inode->logged_trans;
951	__entry->last_unlink_trans = inode->last_unlink_trans;
952	__entry->last_sub_trans = inode->last_sub_trans;
953	__entry->inode_last_log_commit = inode->last_log_commit;
954	spin_unlock(&inode->lock);
955	__entry->root_last_log_commit = btrfs_get_root_last_log_commit(root);
956	),
957
958	TP_printk_btrfs("root=%llu(%s) ino=%llu type=%s transid=%llu gen=%llu"
959	" logged_trans=%llu last_unlink_trans=%llu last_sub_trans=%d"
960	" inode_last_log_commit=%d root_last_log_commit=%d",
961	show_root_type(__entry->root_objectid), __entry->ino,
962	show_inode_type(__entry->mode), __entry->transid,
963	__entry->generation, __entry->logged_trans,
964	__entry->last_unlink_trans, __entry->last_sub_trans,
965	__entry->inode_last_log_commit, __entry->root_last_log_commit)
966	);
967
968	TRACE_EVENT(btrfs_log_inode_parent_exit,
969
970	TP_PROTO(const struct btrfs_trans_handle *trans,
971	const struct btrfs_inode *inode,
972	int ret),
973
974	TP_ARGS(trans, inode, ret),
975
976	TP_STRUCT__entry_btrfs(
977	__field( u64, root_objectid )
978	__field( u64, ino )
979	__field( u64, transid )
980	__field( int, ret )
981	),
982
983	TP_fast_assign(
984	TP_fast_assign_fsid(inode->root->fs_info);
985	__entry->root_objectid = btrfs_root_id(inode->root);
986	__entry->ino = btrfs_ino(inode);
987	__entry->transid = trans->transid;
988	__entry->ret = ret;
989	),
990
991	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d",
992	show_root_type(__entry->root_objectid), __entry->ino,
993	__entry->transid, __entry->ret)
994	);
995
996	TRACE_EVENT(btrfs_log_inode_enter,
997
998	TP_PROTO(const struct btrfs_trans_handle trans, struct btrfs_inode inode,
999	const struct btrfs_log_ctx *ctx, int log_mode),
1000
1001	TP_ARGS(trans, inode, ctx, log_mode),
1002
1003	TP_STRUCT__entry_btrfs(
1004	__field( u64, root_objectid )
1005	__field( u64, ino )
1006	__field( umode_t, mode )
1007	__field( u64, transid )
1008	__field( u64, generation )
1009	__field( u64, logged_trans )
1010	__field( u64, last_unlink_trans )
1011	__field( u64, last_reflink_trans )
1012	__field( int, last_sub_trans )
1013	__field( int, last_log_commit )
1014	__field( bool, logging_new_name )
1015	__field( bool, logging_new_delayed_dentries )
1016	__field( bool, is_conflict_inode )
1017	__field( bool, full_sync )
1018	__field( bool, copy_everything )
1019	__field( bool, no_xattrs )
1020	__field( int, log_mode )
1021	),
1022
1023	TP_fast_assign(
1024	TP_fast_assign_fsid(inode->root->fs_info);
1025	__entry->root_objectid = btrfs_root_id(inode->root);
1026	__entry->ino = btrfs_ino(inode);
1027	__entry->mode = inode->vfs_inode.i_mode;
1028	__entry->transid = trans->transid;
1029	__entry->generation = inode->generation;
1030	spin_lock(&inode->lock);
1031	__entry->logged_trans = inode->logged_trans;
1032	__entry->last_unlink_trans = inode->last_unlink_trans;
1033	__entry->last_reflink_trans = inode->last_reflink_trans;
1034	__entry->last_sub_trans = inode->last_sub_trans;
1035	__entry->last_log_commit = inode->last_log_commit;
1036	spin_unlock(&inode->lock);
1037	__entry->logging_new_name = ctx->logging_new_name;
1038	__entry->logging_new_delayed_dentries = ctx->logging_new_delayed_dentries;
1039	__entry->is_conflict_inode = ctx->logging_conflict_inodes;
1040	__entry->full_sync =
1041	test_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);
1042	__entry->copy_everything =
1043	test_bit(BTRFS_INODE_COPY_EVERYTHING, &inode->runtime_flags);
1044	__entry->no_xattrs =
1045	test_bit(BTRFS_INODE_NO_XATTRS, &inode->runtime_flags);
1046	__entry->log_mode = log_mode;
1047	),
1048
1049	TP_printk_btrfs("root=%llu(%s) ino=%llu type=%s transid=%llu gen=%llu"
1050	" logged_trans=%llu last_unlink_trans=%llu"
1051	" last_reflink_trans=%llu last_sub_trans=%d last_log_commit=%d"
1052	" logging_new_name=%d logging_new_delayed_dentries=%d"
1053	" is_conflict_inode=%d full_sync=%d copy_everything=%d"
1054	" no_xattrs=%d log_mode=%d(%s)",
1055	show_root_type(__entry->root_objectid), __entry->ino,
1056	show_inode_type(__entry->mode), __entry->transid,
1057	__entry->generation, __entry->logged_trans,
1058	__entry->last_unlink_trans, __entry->last_reflink_trans,
1059	__entry->last_sub_trans, __entry->last_log_commit,
1060	__entry->logging_new_name, __entry->logging_new_delayed_dentries,
1061	__entry->is_conflict_inode, __entry->log_mode,
1062	__entry->full_sync, __entry->copy_everything, __entry->no_xattrs,
1063	__print_symbolic(__entry->log_mode, LOG_MODES))
1064	);
1065
1066	TRACE_EVENT(btrfs_log_inode_exit,
1067
1068	TP_PROTO(const struct btrfs_trans_handle trans, struct btrfs_inode inode,
1069	int ret),
1070
1071	TP_ARGS(trans, inode, ret),
1072
1073	TP_STRUCT__entry_btrfs(
1074	__field( u64, root_objectid )
1075	__field( u64, ino )
1076	__field( u64, transid )
1077	__field( u64, logged_trans )
1078	__field( u64, last_reflink_trans )
1079	__field( int, last_sub_trans )
1080	__field( int, last_log_commit )
1081	__field( int, ret )
1082	),
1083
1084	TP_fast_assign(
1085	TP_fast_assign_fsid(inode->root->fs_info);
1086	__entry->root_objectid = btrfs_root_id(inode->root);
1087	__entry->ino = btrfs_ino(inode);
1088	__entry->transid = trans->transid;
1089	spin_lock(&inode->lock);
1090	__entry->logged_trans = inode->logged_trans;
1091	__entry->last_reflink_trans = inode->last_reflink_trans;
1092	__entry->last_sub_trans = inode->last_sub_trans;
1093	__entry->last_log_commit = inode->last_log_commit;
1094	spin_unlock(&inode->lock);
1095	__entry->ret = ret;
1096	),
1097
1098	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu logged_trans=%llu"
1099	" last_reflink_trans=%llu last_sub_trans=%d"
1100	" last_log_commit=%d ret=%d",
1101	show_root_type(__entry->root_objectid), __entry->ino,
1102	__entry->transid, __entry->logged_trans,
1103	__entry->last_reflink_trans, __entry->last_sub_trans,
1104	__entry->last_log_commit, __entry->ret)
1105	);
1106
1107	TRACE_EVENT(btrfs_log_all_parents_enter,
1108
1109	TP_PROTO(const struct btrfs_trans_handle *trans,
1110	const struct btrfs_inode *inode),
1111
1112	TP_ARGS(trans, inode),
1113
1114	TP_STRUCT__entry_btrfs(
1115	__field( u64, root_objectid )
1116	__field( u64, ino )
1117	__field( u64, transid )
1118	),
1119
1120	TP_fast_assign(
1121	TP_fast_assign_fsid(inode->root->fs_info);
1122	__entry->root_objectid = btrfs_root_id(inode->root);
1123	__entry->ino = btrfs_ino(inode);
1124	__entry->transid = trans->transid;
1125	),
1126
1127	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu",
1128	show_root_type(__entry->root_objectid), __entry->ino,
1129	__entry->transid)
1130	);
1131
1132	TRACE_EVENT(btrfs_log_all_parents_exit,
1133
1134	TP_PROTO(const struct btrfs_trans_handle *trans,
1135	const struct btrfs_inode *inode,
1136	int ret),
1137
1138	TP_ARGS(trans, inode, ret),
1139
1140	TP_STRUCT__entry_btrfs(
1141	__field( u64, root_objectid )
1142	__field( u64, ino )
1143	__field( u64, transid )
1144	__field( int, ret )
1145	),
1146
1147	TP_fast_assign(
1148	TP_fast_assign_fsid(inode->root->fs_info);
1149	__entry->root_objectid = btrfs_root_id(inode->root);
1150	__entry->ino = btrfs_ino(inode);
1151	__entry->transid = trans->transid;
1152	__entry->ret = ret;
1153	),
1154
1155	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d",
1156	show_root_type(__entry->root_objectid), __entry->ino,
1157	__entry->transid, __entry->ret)
1158	);
1159
1160	TRACE_EVENT(btrfs_log_all_new_ancestors_enter,
1161
1162	TP_PROTO(const struct btrfs_trans_handle *trans,
1163	const struct btrfs_inode *inode),
1164
1165	TP_ARGS(trans, inode),
1166
1167	TP_STRUCT__entry_btrfs(
1168	__field( u64, root_objectid )
1169	__field( u64, ino )
1170	__field( u64, transid )
1171	__field( unsigned int, nlink )
1172	),
1173
1174	TP_fast_assign(
1175	TP_fast_assign_fsid(inode->root->fs_info);
1176	__entry->root_objectid = btrfs_root_id(inode->root);
1177	__entry->ino = btrfs_ino(inode);
1178	__entry->transid = trans->transid;
1179	__entry->nlink = inode->vfs_inode.i_nlink;
1180	),
1181
1182	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu nlink=%u",
1183	show_root_type(__entry->root_objectid), __entry->ino,
1184	__entry->transid, __entry->nlink)
1185	);
1186
1187	TRACE_EVENT(btrfs_log_all_new_ancestors_exit,
1188
1189	TP_PROTO(const struct btrfs_trans_handle *trans,
1190	const struct btrfs_inode *inode,
1191	int ret),
1192
1193	TP_ARGS(trans, inode, ret),
1194
1195	TP_STRUCT__entry_btrfs(
1196	__field( u64, root_objectid )
1197	__field( u64, ino )
1198	__field( u64, transid )
1199	__field( int, ret )
1200	),
1201
1202	TP_fast_assign(
1203	TP_fast_assign_fsid(inode->root->fs_info);
1204	__entry->root_objectid = btrfs_root_id(inode->root);
1205	__entry->ino = btrfs_ino(inode);
1206	__entry->transid = trans->transid;
1207	__entry->ret = ret;
1208	),
1209
1210	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d",
1211	show_root_type(__entry->root_objectid), __entry->ino,
1212	__entry->transid, __entry->ret)
1213	);
1214
1215	TRACE_EVENT(btrfs_log_new_dir_dentries_enter,
1216
1217	TP_PROTO(const struct btrfs_trans_handle *trans,
1218	const struct btrfs_inode *inode),
1219
1220	TP_ARGS(trans, inode),
1221
1222	TP_STRUCT__entry_btrfs(
1223	__field( u64, root_objectid )
1224	__field( u64, ino )
1225	__field( u64, transid )
1226	),
1227
1228	TP_fast_assign(
1229	TP_fast_assign_fsid(inode->root->fs_info);
1230	__entry->root_objectid = btrfs_root_id(inode->root);
1231	__entry->ino = btrfs_ino(inode);
1232	__entry->transid = trans->transid;
1233	),
1234
1235	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu",
1236	show_root_type(__entry->root_objectid), __entry->ino,
1237	__entry->transid)
1238	);
1239
1240	TRACE_EVENT(btrfs_log_new_dir_dentries_exit,
1241
1242	TP_PROTO(const struct btrfs_trans_handle *trans,
1243	const struct btrfs_inode *inode,
1244	int ret),
1245
1246	TP_ARGS(trans, inode, ret),
1247
1248	TP_STRUCT__entry_btrfs(
1249	__field( u64, root_objectid )
1250	__field( u64, ino )
1251	__field( u64, transid )
1252	__field( int, ret )
1253	),
1254
1255	TP_fast_assign(
1256	TP_fast_assign_fsid(inode->root->fs_info);
1257	__entry->root_objectid = btrfs_root_id(inode->root);
1258	__entry->ino = btrfs_ino(inode);
1259	__entry->transid = trans->transid;
1260	__entry->ret = ret;
1261	),
1262
1263	TP_printk_btrfs("root=%llu(%s) ino=%llu transid=%llu ret=%d",
1264	show_root_type(__entry->root_objectid), __entry->ino,
1265	__entry->transid, __entry->ret)
1266	);
1267
1268	TRACE_EVENT(btrfs_add_conflicting_inode_enter,
1269
1270	TP_PROTO(const struct btrfs_trans_handle *trans,
1271	const struct btrfs_log_ctx *ctx,
1272	u64 ino, u64 parent),
1273
1274	TP_ARGS(trans, ctx, ino, parent),
1275
1276	TP_STRUCT__entry_btrfs(
1277	__field( u64, root_objectid )
1278	__field( u64, transid )
1279	__field( u64, ctx_ino )
1280	__field( u64, conflict_ino )
1281	__field( u64, conflict_ino_parent )
1282	),
1283
1284	TP_fast_assign(
1285	TP_fast_assign_fsid(trans->fs_info);
1286	__entry->root_objectid = btrfs_root_id(ctx->inode->root);
1287	__entry->transid = trans->transid;
1288	__entry->ctx_ino = btrfs_ino(ctx->inode);
1289	__entry->conflict_ino = ino;
1290	__entry->conflict_ino_parent = parent;
1291	),
1292
1293	TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu conflict_ino=%llu"
1294	" conflict_ino_parent=%llu",
1295	show_root_type(__entry->root_objectid), __entry->transid,
1296	__entry->ctx_ino, __entry->conflict_ino,
1297	__entry->conflict_ino_parent)
1298	);
1299
1300	TRACE_EVENT(btrfs_add_conflicting_inode_exit,
1301
1302	TP_PROTO(const struct btrfs_trans_handle *trans,
1303	const struct btrfs_log_ctx *ctx,
1304	u64 ino, u64 parent, int ret),
1305
1306	TP_ARGS(trans, ctx, ino, parent, ret),
1307
1308	TP_STRUCT__entry_btrfs(
1309	__field( u64, root_objectid )
1310	__field( u64, transid )
1311	__field( u64, ctx_ino )
1312	__field( u64, conflict_ino )
1313	__field( u64, conflict_ino_parent )
1314	__field( int, ret )
1315	),
1316
1317	TP_fast_assign(
1318	TP_fast_assign_fsid(trans->fs_info);
1319	__entry->root_objectid = btrfs_root_id(ctx->inode->root);
1320	__entry->transid = trans->transid;
1321	__entry->ctx_ino = btrfs_ino(ctx->inode);
1322	__entry->conflict_ino = ino;
1323	__entry->conflict_ino_parent = parent;
1324	__entry->ret = ret;
1325	),
1326
1327	TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu conflict_ino=%llu"
1328	" conflict_ino_parent=%llu ret=%d",
1329	show_root_type(__entry->root_objectid), __entry->transid,
1330	__entry->ctx_ino, __entry->conflict_ino,
1331	__entry->conflict_ino_parent, __entry->ret)
1332	);
1333
1334	TRACE_EVENT(btrfs_log_conflicting_inodes_enter,
1335
1336	TP_PROTO(const struct btrfs_trans_handle *trans,
1337	const struct btrfs_log_ctx *ctx),
1338
1339	TP_ARGS(trans, ctx),
1340
1341	TP_STRUCT__entry_btrfs(
1342	__field( u64, root_objectid )
1343	__field( u64, transid )
1344	__field( u64, ctx_ino )
1345	),
1346
1347	TP_fast_assign(
1348	TP_fast_assign_fsid(trans->fs_info);
1349	__entry->root_objectid = btrfs_root_id(ctx->inode->root);
1350	__entry->transid = trans->transid;
1351	__entry->ctx_ino = btrfs_ino(ctx->inode);
1352	),
1353
1354	TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu",
1355	show_root_type(__entry->root_objectid), __entry->transid,
1356	__entry->ctx_ino)
1357	);
1358
1359	TRACE_EVENT(btrfs_log_conflicting_inodes_exit,
1360
1361	TP_PROTO(const struct btrfs_trans_handle *trans,
1362	const struct btrfs_log_ctx *ctx,
1363	int ret),
1364
1365	TP_ARGS(trans, ctx, ret),
1366
1367	TP_STRUCT__entry_btrfs(
1368	__field( u64, root_objectid )
1369	__field( u64, transid )
1370	__field( u64, ctx_ino )
1371	__field( int, ret )
1372	),
1373
1374	TP_fast_assign(
1375	TP_fast_assign_fsid(trans->fs_info);
1376	__entry->root_objectid = btrfs_root_id(ctx->inode->root);
1377	__entry->transid = trans->transid;
1378	__entry->ctx_ino = btrfs_ino(ctx->inode);
1379	__entry->ret = ret;
1380	),
1381
1382	TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_ino=%llu ret=%d",
1383	show_root_type(__entry->root_objectid), __entry->transid,
1384	__entry->ctx_ino, __entry->ret)
1385	);
1386
1387	TRACE_EVENT(btrfs_log_new_delayed_dentries_enter,
1388
1389	TP_PROTO(const struct btrfs_trans_handle *trans,
1390	const struct btrfs_inode *inode),
1391
1392	TP_ARGS(trans, inode),
1393
1394	TP_STRUCT__entry_btrfs(
1395	__field( u64, root_objectid )
1396	__field( u64, transid )
1397	__field( u64, ino )
1398	),
1399
1400	TP_fast_assign(
1401	TP_fast_assign_fsid(trans->fs_info);
1402	__entry->root_objectid = btrfs_root_id(inode->root);
1403	__entry->transid = trans->transid;
1404	__entry->ino = btrfs_ino(inode);
1405	),
1406
1407	TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu",
1408	show_root_type(__entry->root_objectid), __entry->transid,
1409	__entry->ino)
1410	);
1411
1412	TRACE_EVENT(btrfs_log_new_delayed_dentries_exit,
1413
1414	TP_PROTO(const struct btrfs_trans_handle *trans,
1415	const struct btrfs_inode *inode,
1416	int ret),
1417
1418	TP_ARGS(trans, inode, ret),
1419
1420	TP_STRUCT__entry_btrfs(
1421	__field( u64, root_objectid )
1422	__field( u64, transid )
1423	__field( u64, ino )
1424	__field( int, ret )
1425	),
1426
1427	TP_fast_assign(
1428	TP_fast_assign_fsid(trans->fs_info);
1429	__entry->root_objectid = btrfs_root_id(inode->root);
1430	__entry->transid = trans->transid;
1431	__entry->ino = btrfs_ino(inode);
1432	__entry->ret = ret;
1433	),
1434
1435	TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu ret=%d",
1436	show_root_type(__entry->root_objectid), __entry->transid,
1437	__entry->ino, __entry->ret)
1438	);
1439
1440	TRACE_EVENT(btrfs_record_unlink_dir,
1441
1442	TP_PROTO(const struct btrfs_trans_handle *trans,
1443	const struct btrfs_inode *dir,
1444	const struct btrfs_inode *inode,
1445	bool for_rename),
1446
1447	TP_ARGS(trans, dir, inode, for_rename),
1448
1449	TP_STRUCT__entry_btrfs(
1450	__field( u64, root_objectid )
1451	__field( u64, transid )
1452	__field( u64, ino )
1453	__field( u64, dir )
1454	__field( bool, for_rename )
1455	),
1456
1457	TP_fast_assign(
1458	TP_fast_assign_fsid(trans->fs_info);
1459	__entry->root_objectid = btrfs_root_id(inode->root);
1460	__entry->transid = trans->transid;
1461	__entry->ino = btrfs_ino(inode);
1462	__entry->dir = btrfs_ino(dir);
1463	__entry->for_rename = for_rename;
1464	),
1465
1466	TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu dir=%llu for_rename=%d",
1467	show_root_type(__entry->root_objectid), __entry->transid,
1468	__entry->ino, __entry->dir, __entry->for_rename)
1469	);
1470
1471	TRACE_EVENT(btrfs_record_snapshot_destroy,
1472
1473	TP_PROTO(const struct btrfs_trans_handle *trans,
1474	const struct btrfs_inode *dir),
1475
1476	TP_ARGS(trans, dir),
1477
1478	TP_STRUCT__entry_btrfs(
1479	__field( u64, root_objectid )
1480	__field( u64, transid )
1481	__field( u64, dir )
1482	),
1483
1484	TP_fast_assign(
1485	TP_fast_assign_fsid(trans->fs_info);
1486	__entry->root_objectid = btrfs_root_id(dir->root);
1487	__entry->transid = trans->transid;
1488	__entry->dir = btrfs_ino(dir);
1489	),
1490
1491	TP_printk_btrfs("root=%llu(%s) transid=%llu dir=%llu",
1492	show_root_type(__entry->root_objectid), __entry->transid,
1493	__entry->dir)
1494	);
1495
1496	TRACE_EVENT(btrfs_record_new_subvolume,
1497
1498	TP_PROTO(const struct btrfs_trans_handle *trans,
1499	const struct btrfs_inode *dir),
1500
1501	TP_ARGS(trans, dir),
1502
1503	TP_STRUCT__entry_btrfs(
1504	__field( u64, root_objectid )
1505	__field( u64, transid )
1506	__field( u64, dir )
1507	),
1508
1509	TP_fast_assign(
1510	TP_fast_assign_fsid(trans->fs_info);
1511	__entry->root_objectid = btrfs_root_id(dir->root);
1512	__entry->transid = trans->transid;
1513	__entry->dir = btrfs_ino(dir);
1514	),
1515
1516	TP_printk_btrfs("root=%llu(%s) transid=%llu dir=%llu",
1517	show_root_type(__entry->root_objectid), __entry->transid,
1518	__entry->dir)
1519	);
1520
1521	TRACE_EVENT(btrfs_log_new_name_enter,
1522
1523	TP_PROTO(const struct btrfs_trans_handle *trans,
1524	const struct btrfs_inode *inode,
1525	const struct btrfs_inode *old_dir,
1526	u64 old_dir_index),
1527
1528	TP_ARGS(trans, inode, old_dir, old_dir_index),
1529
1530	TP_STRUCT__entry_btrfs(
1531	__field( u64, root_objectid )
1532	__field( u64, transid )
1533	__field( u64, ino )
1534	__field( umode_t, mode )
1535	__field( u64, old_dir_ino )
1536	__field( u64, old_dir_index )
1537	),
1538
1539	TP_fast_assign(
1540	TP_fast_assign_fsid(trans->fs_info);
1541	__entry->root_objectid = btrfs_root_id(inode->root);
1542	__entry->transid = trans->transid;
1543	__entry->ino = btrfs_ino(inode);
1544	__entry->mode = inode->vfs_inode.i_mode;
1545	__entry->old_dir_ino = old_dir ? btrfs_ino(old_dir) : 0;
1546	__entry->old_dir_index = old_dir_index;
1547	),
1548
1549	TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu type=%s"
1550	" old_dir=%llu old_dir_index=%llu",
1551	show_root_type(__entry->root_objectid), __entry->transid,
1552	__entry->ino, show_inode_type(__entry->mode),
1553	__entry->old_dir_ino, __entry->old_dir_index)
1554	);
1555
1556	TRACE_EVENT(btrfs_log_new_name_exit,
1557
1558	TP_PROTO(const struct btrfs_trans_handle *trans,
1559	const struct btrfs_inode *inode,
1560	const struct btrfs_inode *old_dir,
1561	int ret),
1562
1563	TP_ARGS(trans, inode, old_dir, ret),
1564
1565	TP_STRUCT__entry_btrfs(
1566	__field( u64, root_objectid )
1567	__field( u64, transid )
1568	__field( u64, ino )
1569	__field( u64, old_dir_ino )
1570	__field( int, ret )
1571	),
1572
1573	TP_fast_assign(
1574	TP_fast_assign_fsid(trans->fs_info);
1575	__entry->root_objectid = btrfs_root_id(inode->root);
1576	__entry->transid = trans->transid;
1577	__entry->ino = btrfs_ino(inode);
1578	__entry->old_dir_ino = old_dir ? btrfs_ino(old_dir) : 0;
1579	__entry->ret = ret;
1580	),
1581
1582	TP_printk_btrfs("root=%llu(%s) transid=%llu ino=%llu old_dir=%llu ret=%d",
1583	show_root_type(__entry->root_objectid), __entry->transid,
1584	__entry->ino, __entry->old_dir_ino, __entry->ret)
1585	);
1586
1587	/* Ideally call this while under root->log_mutex (but not always possible). */
1588	TRACE_EVENT(btrfs_sync_log_enter,
1589
1590	TP_PROTO(const struct btrfs_trans_handle *trans,
1591	const struct btrfs_root *root,
1592	const struct btrfs_log_ctx *ctx),
1593
1594	TP_ARGS(trans, root, ctx),
1595
1596	TP_STRUCT__entry_btrfs(
1597	__field( u64, root_objectid )
1598	__field( u64, transid )
1599	__field( int, ctx_log_transid )
1600	__field( int, root_log_transid )
1601	__field( int, log_transid_committed )
1602	__field( bool, log_committing )
1603	__field( bool, log_committing_prev )
1604	__field( int, log_writers )
1605	),
1606
1607	TP_fast_assign(
1608	TP_fast_assign_fsid(trans->fs_info);
1609	__entry->root_objectid = btrfs_root_id(root);
1610	__entry->transid = trans->transid;
1611	__entry->ctx_log_transid = ctx->log_transid;
1612	__entry->root_log_transid = btrfs_get_root_log_transid(root);
1613	__entry->log_transid_committed =
1614	data_race(root->log_transid_committed);
1615	__entry->log_committing =
1616	data_race(root->log_commit[ctx->log_transid % 2]);
1617	__entry->log_committing_prev =
1618	data_race(root->log_commit[(ctx->log_transid + 1) % 2]);
1619	__entry->log_writers = atomic_read(&root->log_writers);
1620	),
1621
1622	TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_log_transid=%d"
1623	" root_log_transid=%d log_transid_committed=%d"
1624	" log_committing=%d log_committing_prev=%d log_writers=%d",
1625	show_root_type(__entry->root_objectid), __entry->transid,
1626	__entry->ctx_log_transid, __entry->root_log_transid,
1627	__entry->log_transid_committed, __entry->log_committing,
1628	__entry->log_committing_prev, __entry->log_writers)
1629	);
1630
1631	/*
1632	* Ideally call this while under root->log_mutex and in the same critical
1633	* section that calls the btrfs_sync_log_enter() trace event (though it's not
1634	* always possible).
1635	*/
1636	TRACE_EVENT(btrfs_sync_log_exit,
1637
1638	TP_PROTO(const struct btrfs_trans_handle *trans,
1639	const struct btrfs_root *root,
1640	const struct btrfs_log_ctx *ctx,
1641	int ret),
1642
1643	TP_ARGS(trans, root, ctx, ret),
1644
1645	TP_STRUCT__entry_btrfs(
1646	__field( u64, root_objectid )
1647	__field( u64, transid )
1648	__field( int, ctx_log_transid )
1649	__field( int, root_log_transid )
1650	__field( int, log_transid_committed )
1651	__field( int, ret )
1652	),
1653
1654	TP_fast_assign(
1655	TP_fast_assign_fsid(trans->fs_info);
1656	__entry->root_objectid = btrfs_root_id(root);
1657	__entry->transid = trans->transid;
1658	__entry->ctx_log_transid = ctx->log_transid;
1659	__entry->root_log_transid = btrfs_get_root_log_transid(root);
1660	__entry->log_transid_committed =
1661	data_race(root->log_transid_committed);
1662	__entry->ret = ret;
1663	),
1664
1665	TP_printk_btrfs("root=%llu(%s) transid=%llu ctx_log_transid=%d"
1666	" root_log_transid=%d log_transid_committed=%d ret=%d",
1667	show_root_type(__entry->root_objectid), __entry->transid,
1668	__entry->ctx_log_transid, __entry->root_log_transid,
1669	__entry->log_transid_committed, __entry->ret)
1670	);
1671
1672	TRACE_EVENT(btrfs_sync_fs,
1673
1674	TP_PROTO(const struct btrfs_fs_info *fs_info, int wait),
1675
1676	TP_ARGS(fs_info, wait),
1677
1678	TP_STRUCT__entry_btrfs(
1679	__field( int, wait )
1680	),
1681
1682	TP_fast_assign_btrfs(fs_info,
1683	__entry->wait = wait;
1684	),
1685
1686	TP_printk_btrfs("wait=%d", __entry->wait)
1687	);
1688
1689	TRACE_EVENT(btrfs_add_block_group,
1690
1691	TP_PROTO(const struct btrfs_fs_info *fs_info,
1692	const struct btrfs_block_group *block_group, int create),
1693
1694	TP_ARGS(fs_info, block_group, create),
1695
1696	TP_STRUCT__entry_btrfs(
1697	__field( u64, offset )
1698	__field( u64, size )
1699	__field( u64, flags )
1700	__field( u64, bytes_used )
1701	__field( u64, bytes_super )
1702	__field( int, create )
1703	),
1704
1705	TP_fast_assign_btrfs(fs_info,
1706	__entry->offset = block_group->start;
1707	__entry->size = block_group->length;
1708	__entry->flags = block_group->flags;
1709	__entry->bytes_used = block_group->used;
1710	__entry->bytes_super = block_group->bytes_super;
1711	__entry->create = create;
1712	),
1713
1714	TP_printk_btrfs("block_group offset=%llu size=%llu "
1715	"flags=%llu(%s) bytes_used=%llu bytes_super=%llu "
1716	"create=%d",
1717	__entry->offset,
1718	__entry->size,
1719	__entry->flags,
1720	__print_flags((unsigned long)__entry->flags, "\|",
1721	BTRFS_GROUP_FLAGS),
1722	__entry->bytes_used,
1723	__entry->bytes_super, __entry->create)
1724	);
1725
1726	#define show_ref_action(action) \
1727	__print_symbolic(action, \
1728	{ BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \
1729	{ BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \
1730	{ BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \
1731	{ BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
1732
1733
1734	DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,
1735
1736	TP_PROTO(const struct btrfs_fs_info *fs_info,
1737	const struct btrfs_delayed_ref_node *ref),
1738
1739	TP_ARGS(fs_info, ref),
1740
1741	TP_STRUCT__entry_btrfs(
1742	__field( u64, bytenr )
1743	__field( u64, num_bytes )
1744	__field( int, action )
1745	__field( u64, parent )
1746	__field( u64, ref_root )
1747	__field( int, level )
1748	__field( int, type )
1749	__field( u64, seq )
1750	),
1751
1752	TP_fast_assign_btrfs(fs_info,
1753	__entry->bytenr = ref->bytenr;
1754	__entry->num_bytes = ref->num_bytes;
1755	__entry->action = ref->action;
1756	__entry->parent = ref->parent;
1757	__entry->ref_root = ref->ref_root;
1758	__entry->level = ref->tree_ref.level;
1759	__entry->type = ref->type;
1760	__entry->seq = ref->seq;
1761	),
1762
1763	TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s "
1764	"parent=%llu(%s) ref_root=%llu(%s) level=%d "
1765	"type=%s seq=%llu",
1766	__entry->bytenr,
1767	__entry->num_bytes,
1768	show_ref_action(__entry->action),
1769	show_root_type(__entry->parent),
1770	show_root_type(__entry->ref_root),
1771	__entry->level, show_ref_type(__entry->type),
1772	__entry->seq)
1773	);
1774
1775	DEFINE_EVENT(btrfs_delayed_tree_ref, add_delayed_tree_ref,
1776
1777	TP_PROTO(const struct btrfs_fs_info *fs_info,
1778	const struct btrfs_delayed_ref_node *ref),
1779
1780	TP_ARGS(fs_info, ref)
1781	);
1782
1783	DEFINE_EVENT(btrfs_delayed_tree_ref, run_delayed_tree_ref,
1784
1785	TP_PROTO(const struct btrfs_fs_info *fs_info,
1786	const struct btrfs_delayed_ref_node *ref),
1787
1788	TP_ARGS(fs_info, ref)
1789	);
1790
1791	DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,
1792
1793	TP_PROTO(const struct btrfs_fs_info *fs_info,
1794	const struct btrfs_delayed_ref_node *ref),
1795
1796	TP_ARGS(fs_info, ref),
1797
1798	TP_STRUCT__entry_btrfs(
1799	__field( u64, bytenr )
1800	__field( u64, num_bytes )
1801	__field( int, action )
1802	__field( u64, parent )
1803	__field( u64, ref_root )
1804	__field( u64, owner )
1805	__field( u64, offset )
1806	__field( int, type )
1807	__field( u64, seq )
1808	),
1809
1810	TP_fast_assign_btrfs(fs_info,
1811	__entry->bytenr = ref->bytenr;
1812	__entry->num_bytes = ref->num_bytes;
1813	__entry->action = ref->action;
1814	__entry->parent = ref->parent;
1815	__entry->ref_root = ref->ref_root;
1816	__entry->owner = ref->data_ref.objectid;
1817	__entry->offset = ref->data_ref.offset;
1818	__entry->type = ref->type;
1819	__entry->seq = ref->seq;
1820	),
1821
1822	TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s "
1823	"parent=%llu(%s) ref_root=%llu(%s) owner=%llu "
1824	"offset=%llu type=%s seq=%llu",
1825	__entry->bytenr,
1826	__entry->num_bytes,
1827	show_ref_action(__entry->action),
1828	show_root_type(__entry->parent),
1829	show_root_type(__entry->ref_root),
1830	__entry->owner,
1831	__entry->offset,
1832	show_ref_type(__entry->type),
1833	__entry->seq)
1834	);
1835
1836	DEFINE_EVENT(btrfs_delayed_data_ref, add_delayed_data_ref,
1837
1838	TP_PROTO(const struct btrfs_fs_info *fs_info,
1839	const struct btrfs_delayed_ref_node *ref),
1840
1841	TP_ARGS(fs_info, ref)
1842	);
1843
1844	DEFINE_EVENT(btrfs_delayed_data_ref, run_delayed_data_ref,
1845
1846	TP_PROTO(const struct btrfs_fs_info *fs_info,
1847	const struct btrfs_delayed_ref_node *ref),
1848
1849	TP_ARGS(fs_info, ref)
1850	);
1851
1852	DECLARE_EVENT_CLASS(btrfs_delayed_ref_head,
1853
1854	TP_PROTO(const struct btrfs_fs_info *fs_info,
1855	const struct btrfs_delayed_ref_head *head_ref,
1856	int action),
1857
1858	TP_ARGS(fs_info, head_ref, action),
1859
1860	TP_STRUCT__entry_btrfs(
1861	__field( u64, bytenr )
1862	__field( u64, num_bytes )
1863	__field( int, action )
1864	__field( int, is_data )
1865	),
1866
1867	TP_fast_assign_btrfs(fs_info,
1868	__entry->bytenr = head_ref->bytenr;
1869	__entry->num_bytes = head_ref->num_bytes;
1870	__entry->action = action;
1871	__entry->is_data = head_ref->is_data;
1872	),
1873
1874	TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s is_data=%d",
1875	__entry->bytenr,
1876	__entry->num_bytes,
1877	show_ref_action(__entry->action),
1878	__entry->is_data)
1879	);
1880
1881	DEFINE_EVENT(btrfs_delayed_ref_head, add_delayed_ref_head,
1882
1883	TP_PROTO(const struct btrfs_fs_info *fs_info,
1884	const struct btrfs_delayed_ref_head *head_ref,
1885	int action),
1886
1887	TP_ARGS(fs_info, head_ref, action)
1888	);
1889
1890	DEFINE_EVENT(btrfs_delayed_ref_head, run_delayed_ref_head,
1891
1892	TP_PROTO(const struct btrfs_fs_info *fs_info,
1893	const struct btrfs_delayed_ref_head *head_ref,
1894	int action),
1895
1896	TP_ARGS(fs_info, head_ref, action)
1897	);
1898
1899	#define show_chunk_type(type) \
1900	__print_flags(type, "\|", \
1901	{ BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
1902	{ BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
1903	{ BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
1904	{ BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
1905	{ BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
1906	{ BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
1907	{ BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
1908	{ BTRFS_BLOCK_GROUP_RAID5, "RAID5" }, \
1909	{ BTRFS_BLOCK_GROUP_RAID6, "RAID6" })
1910
1911	DECLARE_EVENT_CLASS(btrfs__chunk,
1912
1913	TP_PROTO(const struct btrfs_fs_info *fs_info,
1914	const struct btrfs_chunk_map *map, u64 offset, u64 size),
1915
1916	TP_ARGS(fs_info, map, offset, size),
1917
1918	TP_STRUCT__entry_btrfs(
1919	__field( int, num_stripes )
1920	__field( u64, type )
1921	__field( int, sub_stripes )
1922	__field( u64, offset )
1923	__field( u64, size )
1924	__field( u64, root_objectid )
1925	),
1926
1927	TP_fast_assign_btrfs(fs_info,
1928	__entry->num_stripes = map->num_stripes;
1929	__entry->type = map->type;
1930	__entry->sub_stripes = map->sub_stripes;
1931	__entry->offset = offset;
1932	__entry->size = size;
1933	__entry->root_objectid = btrfs_root_id(fs_info->chunk_root);
1934	),
1935
1936	TP_printk_btrfs("root=%llu(%s) offset=%llu size=%llu "
1937	"num_stripes=%d sub_stripes=%d type=%s",
1938	show_root_type(__entry->root_objectid),
1939	__entry->offset,
1940	__entry->size,
1941	__entry->num_stripes, __entry->sub_stripes,
1942	show_chunk_type(__entry->type))
1943	);
1944
1945	DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
1946
1947	TP_PROTO(const struct btrfs_fs_info *fs_info,
1948	const struct btrfs_chunk_map *map, u64 offset, u64 size),
1949
1950	TP_ARGS(fs_info, map, offset, size)
1951	);
1952
1953	DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
1954
1955	TP_PROTO(const struct btrfs_fs_info *fs_info,
1956	const struct btrfs_chunk_map *map, u64 offset, u64 size),
1957
1958	TP_ARGS(fs_info, map, offset, size)
1959	);
1960
1961	TRACE_EVENT(btrfs_cow_block,
1962
1963	TP_PROTO(const struct btrfs_root root, const struct extent_buffer buf,
1964	const struct extent_buffer *cow),
1965
1966	TP_ARGS(root, buf, cow),
1967
1968	TP_STRUCT__entry_btrfs(
1969	__field( u64, root_objectid )
1970	__field( u64, buf_start )
1971	__field( int, refs )
1972	__field( u64, cow_start )
1973	__field( int, buf_level )
1974	__field( int, cow_level )
1975	),
1976
1977	TP_fast_assign_btrfs(root->fs_info,
1978	__entry->root_objectid = btrfs_root_id(root);
1979	__entry->buf_start = buf->start;
1980	__entry->refs = refcount_read(&buf->refs);
1981	__entry->cow_start = cow->start;
1982	__entry->buf_level = btrfs_header_level(buf);
1983	__entry->cow_level = btrfs_header_level(cow);
1984	),
1985
1986	TP_printk_btrfs("root=%llu(%s) refs=%d orig_buf=%llu "
1987	"(orig_level=%d) cow_buf=%llu (cow_level=%d)",
1988	show_root_type(__entry->root_objectid),
1989	__entry->refs,
1990	__entry->buf_start,
1991	__entry->buf_level,
1992	__entry->cow_start,
1993	__entry->cow_level)
1994	);
1995
1996	TRACE_EVENT(btrfs_search_slot_restart,
1997
1998	TP_PROTO(const struct btrfs_root *root, int level,
1999	const char *reason),
2000
2001	TP_ARGS(root, level, reason),
2002
2003	TP_STRUCT__entry_btrfs(
2004	__field( u64, root_objectid )
2005	__field( int, level )
2006	__string( reason, reason )
2007	),
2008
2009	TP_fast_assign_btrfs(root->fs_info,
2010	__entry->root_objectid = btrfs_root_id(root);
2011	__entry->level = level;
2012	__assign_str(reason);
2013	),
2014
2015	TP_printk_btrfs("root=%llu(%s) level=%d reason=%s",
2016	show_root_type(__entry->root_objectid),
2017	__entry->level, __get_str(reason))
2018	);
2019
2020	TRACE_EVENT(btrfs_space_reservation,
2021
2022	TP_PROTO(const struct btrfs_fs_info fs_info, const char type, u64 val,
2023	u64 bytes, int reserve),
2024
2025	TP_ARGS(fs_info, type, val, bytes, reserve),
2026
2027	TP_STRUCT__entry_btrfs(
2028	__string( type, type )
2029	__field( u64, val )
2030	__field( u64, bytes )
2031	__field( int, reserve )
2032	),
2033
2034	TP_fast_assign_btrfs(fs_info,
2035	__assign_str(type);
2036	__entry->val = val;
2037	__entry->bytes = bytes;
2038	__entry->reserve = reserve;
2039	),
2040
2041	TP_printk_btrfs("%s: %llu %s %llu", __get_str(type), __entry->val,
2042	__entry->reserve ? "reserve" : "release",
2043	__entry->bytes)
2044	);
2045
2046	TRACE_EVENT(btrfs_trigger_flush,
2047
2048	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,
2049	int flush, const char *reason),
2050
2051	TP_ARGS(fs_info, flags, bytes, flush, reason),
2052
2053	TP_STRUCT__entry_btrfs(
2054	__field( u64, flags )
2055	__field( u64, bytes )
2056	__field( int, flush )
2057	__string( reason, reason )
2058	),
2059
2060	TP_fast_assign_btrfs(fs_info,
2061	__entry->flags = flags;
2062	__entry->bytes = bytes;
2063	__entry->flush = flush;
2064	__assign_str(reason);
2065	),
2066
2067	TP_printk_btrfs("%s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
2068	__get_str(reason), __entry->flush,
2069	__print_symbolic(__entry->flush, FLUSH_ACTIONS),
2070	__entry->flags,
2071	__print_flags((unsigned long)__entry->flags, "\|",
2072	BTRFS_GROUP_FLAGS),
2073	__entry->bytes)
2074	);
2075
2076
2077	TRACE_EVENT(btrfs_flush_space,
2078
2079	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,
2080	int state, int ret, bool for_preempt),
2081
2082	TP_ARGS(fs_info, flags, num_bytes, state, ret, for_preempt),
2083
2084	TP_STRUCT__entry_btrfs(
2085	__field( u64, flags )
2086	__field( u64, num_bytes )
2087	__field( int, state )
2088	__field( int, ret )
2089	__field( bool, for_preempt )
2090	),
2091
2092	TP_fast_assign_btrfs(fs_info,
2093	__entry->flags = flags;
2094	__entry->num_bytes = num_bytes;
2095	__entry->state = state;
2096	__entry->ret = ret;
2097	__entry->for_preempt = for_preempt;
2098	),
2099
2100	TP_printk_btrfs("state=%d(%s) flags=%llu(%s) num_bytes=%llu ret=%d for_preempt=%d",
2101	__entry->state,
2102	__print_symbolic(__entry->state, FLUSH_STATES),
2103	__entry->flags,
2104	__print_flags((unsigned long)__entry->flags, "\|",
2105	BTRFS_GROUP_FLAGS),
2106	__entry->num_bytes, __entry->ret, __entry->for_preempt)
2107	);
2108
2109	DECLARE_EVENT_CLASS(btrfs__reserved_extent,
2110
2111	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
2112
2113	TP_ARGS(fs_info, start, len),
2114
2115	TP_STRUCT__entry_btrfs(
2116	__field( u64, start )
2117	__field( u64, len )
2118	),
2119
2120	TP_fast_assign_btrfs(fs_info,
2121	__entry->start = start;
2122	__entry->len = len;
2123	),
2124
2125	TP_printk_btrfs("root=%llu(%s) start=%llu len=%llu",
2126	show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
2127	__entry->start,
2128	__entry->len)
2129	);
2130
2131	DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
2132
2133	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
2134
2135	TP_ARGS(fs_info, start, len)
2136	);
2137
2138	DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
2139
2140	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
2141
2142	TP_ARGS(fs_info, start, len)
2143	);
2144
2145	TRACE_EVENT(btrfs_find_free_extent,
2146
2147	TP_PROTO(const struct btrfs_root *root,
2148	const struct find_free_extent_ctl *ffe_ctl),
2149
2150	TP_ARGS(root, ffe_ctl),
2151
2152	TP_STRUCT__entry_btrfs(
2153	__field( u64, root_objectid )
2154	__field( u64, num_bytes )
2155	__field( u64, empty_size )
2156	__field( u64, flags )
2157	),
2158
2159	TP_fast_assign_btrfs(root->fs_info,
2160	__entry->root_objectid = btrfs_root_id(root);
2161	__entry->num_bytes = ffe_ctl->num_bytes;
2162	__entry->empty_size = ffe_ctl->empty_size;
2163	__entry->flags = ffe_ctl->flags;
2164	),
2165
2166	TP_printk_btrfs("root=%llu(%s) len=%llu empty_size=%llu flags=%llu(%s)",
2167	show_root_type(__entry->root_objectid),
2168	__entry->num_bytes, __entry->empty_size, __entry->flags,
2169	__print_flags((unsigned long)__entry->flags, "\|",
2170	BTRFS_GROUP_FLAGS))
2171	);
2172
2173	TRACE_EVENT(btrfs_find_free_extent_search_loop,
2174
2175	TP_PROTO(const struct btrfs_root *root,
2176	const struct find_free_extent_ctl *ffe_ctl),
2177
2178	TP_ARGS(root, ffe_ctl),
2179
2180	TP_STRUCT__entry_btrfs(
2181	__field( u64, root_objectid )
2182	__field( u64, num_bytes )
2183	__field( u64, empty_size )
2184	__field( u64, flags )
2185	__field( u64, loop )
2186	),
2187
2188	TP_fast_assign_btrfs(root->fs_info,
2189	__entry->root_objectid = btrfs_root_id(root);
2190	__entry->num_bytes = ffe_ctl->num_bytes;
2191	__entry->empty_size = ffe_ctl->empty_size;
2192	__entry->flags = ffe_ctl->flags;
2193	__entry->loop = ffe_ctl->loop;
2194	),
2195
2196	TP_printk_btrfs("root=%llu(%s) len=%llu empty_size=%llu flags=%llu(%s) loop=%llu",
2197	show_root_type(__entry->root_objectid),
2198	__entry->num_bytes, __entry->empty_size, __entry->flags,
2199	__print_flags((unsigned long)__entry->flags, "\|", BTRFS_GROUP_FLAGS),
2200	__entry->loop)
2201	);
2202
2203	TRACE_EVENT(btrfs_find_free_extent_have_block_group,
2204
2205	TP_PROTO(const struct btrfs_root *root,
2206	const struct find_free_extent_ctl *ffe_ctl,
2207	const struct btrfs_block_group *block_group),
2208
2209	TP_ARGS(root, ffe_ctl, block_group),
2210
2211	TP_STRUCT__entry_btrfs(
2212	__field( u64, root_objectid )
2213	__field( u64, num_bytes )
2214	__field( u64, empty_size )
2215	__field( u64, flags )
2216	__field( u64, loop )
2217	__field( bool, hinted )
2218	__field( u64, bg_start )
2219	__field( u64, bg_flags )
2220	),
2221
2222	TP_fast_assign_btrfs(root->fs_info,
2223	__entry->root_objectid = btrfs_root_id(root);
2224	__entry->num_bytes = ffe_ctl->num_bytes;
2225	__entry->empty_size = ffe_ctl->empty_size;
2226	__entry->flags = ffe_ctl->flags;
2227	__entry->loop = ffe_ctl->loop;
2228	__entry->hinted = ffe_ctl->hinted;
2229	__entry->bg_start = block_group->start;
2230	__entry->bg_flags = block_group->flags;
2231	),
2232
2233	TP_printk_btrfs(
2234	"root=%llu(%s) len=%llu empty_size=%llu flags=%llu(%s) loop=%llu hinted=%d block_group=%llu bg_flags=%llu(%s)",
2235	show_root_type(__entry->root_objectid),
2236	__entry->num_bytes, __entry->empty_size, __entry->flags,
2237	__print_flags((unsigned long)__entry->flags, "\|", BTRFS_GROUP_FLAGS),
2238	__entry->loop, __entry->hinted,
2239	__entry->bg_start, __entry->bg_flags,
2240	__print_flags((unsigned long)__entry->bg_flags, "\|",
2241	BTRFS_GROUP_FLAGS))
2242	);
2243
2244	DECLARE_EVENT_CLASS(btrfs__reserve_extent,
2245
2246	TP_PROTO(const struct btrfs_block_group *block_group,
2247	const struct find_free_extent_ctl *ffe_ctl),
2248
2249	TP_ARGS(block_group, ffe_ctl),
2250
2251	TP_STRUCT__entry_btrfs(
2252	__field( u64, bg_objectid )
2253	__field( u64, flags )
2254	__field( int, bg_size_class )
2255	__field( u64, start )
2256	__field( u64, len )
2257	__field( u64, loop )
2258	__field( bool, hinted )
2259	__field( int, size_class )
2260	),
2261
2262	TP_fast_assign_btrfs(block_group->fs_info,
2263	__entry->bg_objectid = block_group->start;
2264	__entry->flags = block_group->flags;
2265	__entry->bg_size_class = block_group->size_class;
2266	__entry->start = ffe_ctl->search_start;
2267	__entry->len = ffe_ctl->num_bytes;
2268	__entry->loop = ffe_ctl->loop;
2269	__entry->hinted = ffe_ctl->hinted;
2270	__entry->size_class = ffe_ctl->size_class;
2271	),
2272
2273	TP_printk_btrfs(
2274	"root=%llu(%s) block_group=%llu flags=%llu(%s) bg_size_class=%d start=%llu len=%llu loop=%llu hinted=%d size_class=%d",
2275	show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
2276	__entry->bg_objectid,
2277	__entry->flags, __print_flags((unsigned long)__entry->flags,
2278	"\|", BTRFS_GROUP_FLAGS),
2279	__entry->bg_size_class, __entry->start, __entry->len,
2280	__entry->loop, __entry->hinted, __entry->size_class)
2281	);
2282
2283	DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
2284
2285	TP_PROTO(const struct btrfs_block_group *block_group,
2286	const struct find_free_extent_ctl *ffe_ctl),
2287
2288	TP_ARGS(block_group, ffe_ctl)
2289	);
2290
2291	DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
2292
2293	TP_PROTO(const struct btrfs_block_group *block_group,
2294	const struct find_free_extent_ctl *ffe_ctl),
2295
2296	TP_ARGS(block_group, ffe_ctl)
2297	);
2298
2299	TRACE_EVENT(btrfs_find_cluster,
2300
2301	TP_PROTO(const struct btrfs_block_group *block_group, u64 start,
2302	u64 bytes, u64 empty_size, u64 min_bytes),
2303
2304	TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
2305
2306	TP_STRUCT__entry_btrfs(
2307	__field( u64, bg_objectid )
2308	__field( u64, flags )
2309	__field( u64, start )
2310	__field( u64, bytes )
2311	__field( u64, empty_size )
2312	__field( u64, min_bytes )
2313	),
2314
2315	TP_fast_assign_btrfs(block_group->fs_info,
2316	__entry->bg_objectid = block_group->start;
2317	__entry->flags = block_group->flags;
2318	__entry->start = start;
2319	__entry->bytes = bytes;
2320	__entry->empty_size = empty_size;
2321	__entry->min_bytes = min_bytes;
2322	),
2323
2324	TP_printk_btrfs("block_group=%llu flags=%llu(%s) start=%llu len=%llu "
2325	"empty_size=%llu min_bytes=%llu", __entry->bg_objectid,
2326	__entry->flags,
2327	__print_flags((unsigned long)__entry->flags, "\|",
2328	BTRFS_GROUP_FLAGS), __entry->start,
2329	__entry->bytes, __entry->empty_size, __entry->min_bytes)
2330	);
2331
2332	TRACE_EVENT(btrfs_failed_cluster_setup,
2333
2334	TP_PROTO(const struct btrfs_block_group *block_group),
2335
2336	TP_ARGS(block_group),
2337
2338	TP_STRUCT__entry_btrfs(
2339	__field( u64, bg_objectid )
2340	),
2341
2342	TP_fast_assign_btrfs(block_group->fs_info,
2343	__entry->bg_objectid = block_group->start;
2344	),
2345
2346	TP_printk_btrfs("block_group=%llu", __entry->bg_objectid)
2347	);
2348
2349	TRACE_EVENT(btrfs_setup_cluster,
2350
2351	TP_PROTO(const struct btrfs_block_group *block_group,
2352	const struct btrfs_free_cluster *cluster,
2353	u64 size, int bitmap),
2354
2355	TP_ARGS(block_group, cluster, size, bitmap),
2356
2357	TP_STRUCT__entry_btrfs(
2358	__field( u64, bg_objectid )
2359	__field( u64, flags )
2360	__field( u64, start )
2361	__field( u64, max_size )
2362	__field( u64, size )
2363	__field( int, bitmap )
2364	),
2365
2366	TP_fast_assign_btrfs(block_group->fs_info,
2367	__entry->bg_objectid = block_group->start;
2368	__entry->flags = block_group->flags;
2369	__entry->start = cluster->window_start;
2370	__entry->max_size = cluster->max_size;
2371	__entry->size = size;
2372	__entry->bitmap = bitmap;
2373	),
2374
2375	TP_printk_btrfs("block_group=%llu flags=%llu(%s) window_start=%llu "
2376	"size=%llu max_size=%llu bitmap=%d",
2377	__entry->bg_objectid,
2378	__entry->flags,
2379	__print_flags((unsigned long)__entry->flags, "\|",
2380	BTRFS_GROUP_FLAGS), __entry->start,
2381	__entry->size, __entry->max_size, __entry->bitmap)
2382	);
2383
2384	struct extent_state;
2385	TRACE_EVENT(btrfs_alloc_extent_state,
2386
2387	TP_PROTO(const struct extent_state *state,
2388	gfp_t mask, unsigned long IP),
2389
2390	TP_ARGS(state, mask, IP),
2391
2392	TP_STRUCT__entry(
2393	__field(const struct extent_state *, state)
2394	__field(unsigned long, mask)
2395	__field(const void*, ip)
2396	),
2397
2398	TP_fast_assign(
2399	__entry->state = state,
2400	__entry->mask = (__force unsigned long)mask,
2401	__entry->ip = (const void *)IP
2402	),
2403
2404	TP_printk("state=%p mask=%s caller=%pS", __entry->state,
2405	show_gfp_flags(__entry->mask), __entry->ip)
2406	);
2407
2408	TRACE_EVENT(btrfs_free_extent_state,
2409
2410	TP_PROTO(const struct extent_state *state, unsigned long IP),
2411
2412	TP_ARGS(state, IP),
2413
2414	TP_STRUCT__entry(
2415	__field(const struct extent_state *, state)
2416	__field(const void*, ip)
2417	),
2418
2419	TP_fast_assign(
2420	__entry->state = state,
2421	__entry->ip = (const void *)IP
2422	),
2423
2424	TP_printk("state=%p caller=%pS", __entry->state, __entry->ip)
2425	);
2426
2427	DECLARE_EVENT_CLASS(btrfs__work,
2428
2429	TP_PROTO(const struct btrfs_work *work),
2430
2431	TP_ARGS(work),
2432
2433	TP_STRUCT__entry_btrfs(
2434	__field( const void *, work )
2435	__field( const void *, wq )
2436	__field( const void *, func )
2437	__field( const void *, ordered_func )
2438	__field( const void *, normal_work )
2439	),
2440
2441	TP_fast_assign_btrfs(btrfs_work_owner(work),
2442	__entry->work = work;
2443	__entry->wq = work->wq;
2444	__entry->func = work->func;
2445	__entry->ordered_func = work->ordered_func;
2446	__entry->normal_work = &work->normal_work;
2447	),
2448
2449	TP_printk_btrfs("work=%p (normal_work=%p) wq=%p func=%ps ordered_func=%p",
2450	__entry->work, __entry->normal_work, __entry->wq,
2451	__entry->func, __entry->ordered_func)
2452	);
2453
2454	/*
2455	* For situations when the work is freed, we pass fs_info and a tag that matches
2456	* the address of the work structure so it can be paired with the scheduling
2457	* event. DO NOT add anything here that dereferences wtag.
2458	*/
2459	DECLARE_EVENT_CLASS(btrfs__work__done,
2460
2461	TP_PROTO(const struct btrfs_fs_info fs_info, const void wtag),
2462
2463	TP_ARGS(fs_info, wtag),
2464
2465	TP_STRUCT__entry_btrfs(
2466	__field( const void *, wtag )
2467	),
2468
2469	TP_fast_assign_btrfs(fs_info,
2470	__entry->wtag = wtag;
2471	),
2472
2473	TP_printk_btrfs("work->%p", __entry->wtag)
2474	);
2475
2476	DEFINE_EVENT(btrfs__work, btrfs_work_queued,
2477
2478	TP_PROTO(const struct btrfs_work *work),
2479
2480	TP_ARGS(work)
2481	);
2482
2483	DEFINE_EVENT(btrfs__work, btrfs_work_sched,
2484
2485	TP_PROTO(const struct btrfs_work *work),
2486
2487	TP_ARGS(work)
2488	);
2489
2490	DEFINE_EVENT(btrfs__work__done, btrfs_all_work_done,
2491
2492	TP_PROTO(const struct btrfs_fs_info fs_info, const void wtag),
2493
2494	TP_ARGS(fs_info, wtag)
2495	);
2496
2497	DEFINE_EVENT(btrfs__work, btrfs_ordered_sched,
2498
2499	TP_PROTO(const struct btrfs_work *work),
2500
2501	TP_ARGS(work)
2502	);
2503
2504	DECLARE_EVENT_CLASS(btrfs_workqueue,
2505
2506	TP_PROTO(const struct btrfs_workqueue wq, const char name),
2507
2508	TP_ARGS(wq, name),
2509
2510	TP_STRUCT__entry_btrfs(
2511	__field( const void *, wq )
2512	__string( name, name )
2513	),
2514
2515	TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
2516	__entry->wq = wq;
2517	__assign_str(name);
2518	),
2519
2520	TP_printk_btrfs("name=%s wq=%p", __get_str(name),
2521	__entry->wq)
2522	);
2523
2524	DEFINE_EVENT(btrfs_workqueue, btrfs_workqueue_alloc,
2525
2526	TP_PROTO(const struct btrfs_workqueue wq, const char name),
2527
2528	TP_ARGS(wq, name)
2529	);
2530
2531	DECLARE_EVENT_CLASS(btrfs_workqueue_done,
2532
2533	TP_PROTO(const struct btrfs_workqueue *wq),
2534
2535	TP_ARGS(wq),
2536
2537	TP_STRUCT__entry_btrfs(
2538	__field( const void *, wq )
2539	),
2540
2541	TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
2542	__entry->wq = wq;
2543	),
2544
2545	TP_printk_btrfs("wq=%p", __entry->wq)
2546	);
2547
2548	DEFINE_EVENT(btrfs_workqueue_done, btrfs_workqueue_destroy,
2549
2550	TP_PROTO(const struct btrfs_workqueue *wq),
2551
2552	TP_ARGS(wq)
2553	);
2554
2555	#define BTRFS_QGROUP_OPERATIONS \
2556	{ QGROUP_RESERVE, "reserve" }, \
2557	{ QGROUP_RELEASE, "release" }, \
2558	{ QGROUP_FREE, "free" }
2559
2560	DECLARE_EVENT_CLASS(btrfs__qgroup_rsv_data,
2561
2562	TP_PROTO(const struct inode *inode, u64 start, u64 len,
2563	u64 reserved, int op),
2564
2565	TP_ARGS(inode, start, len, reserved, op),
2566
2567	TP_STRUCT__entry_btrfs(
2568	__field( u64, rootid )
2569	__field( u64, ino )
2570	__field( u64, start )
2571	__field( u64, len )
2572	__field( u64, reserved )
2573	__field( int, op )
2574	),
2575
2576	TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
2577	__entry->rootid = btrfs_root_id(BTRFS_I(inode)->root);
2578	__entry->ino = btrfs_ino(BTRFS_I(inode));
2579	__entry->start = start;
2580	__entry->len = len;
2581	__entry->reserved = reserved;
2582	__entry->op = op;
2583	),
2584
2585	TP_printk_btrfs("root=%llu ino=%llu start=%llu len=%llu reserved=%llu op=%s",
2586	__entry->rootid, __entry->ino, __entry->start, __entry->len,
2587	__entry->reserved,
2588	__print_flags((unsigned long)__entry->op, "",
2589	BTRFS_QGROUP_OPERATIONS)
2590	)
2591	);
2592
2593	DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_reserve_data,
2594
2595	TP_PROTO(const struct inode *inode, u64 start, u64 len,
2596	u64 reserved, int op),
2597
2598	TP_ARGS(inode, start, len, reserved, op)
2599	);
2600
2601	DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_release_data,
2602
2603	TP_PROTO(const struct inode *inode, u64 start, u64 len,
2604	u64 reserved, int op),
2605
2606	TP_ARGS(inode, start, len, reserved, op)
2607	);
2608
2609	DECLARE_EVENT_CLASS(btrfs_qgroup_extent,
2610	TP_PROTO(const struct btrfs_fs_info *fs_info,
2611	const struct btrfs_qgroup_extent_record *rec,
2612	u64 bytenr),
2613
2614	TP_ARGS(fs_info, rec, bytenr),
2615
2616	TP_STRUCT__entry_btrfs(
2617	__field( u64, bytenr )
2618	__field( u64, num_bytes )
2619	),
2620
2621	TP_fast_assign_btrfs(fs_info,
2622	__entry->bytenr = bytenr;
2623	__entry->num_bytes = rec->num_bytes;
2624	),
2625
2626	TP_printk_btrfs("bytenr=%llu num_bytes=%llu",
2627	__entry->bytenr, __entry->num_bytes)
2628	);
2629
2630	DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_account_extents,
2631
2632	TP_PROTO(const struct btrfs_fs_info *fs_info,
2633	const struct btrfs_qgroup_extent_record *rec,
2634	u64 bytenr),
2635
2636	TP_ARGS(fs_info, rec, bytenr)
2637	);
2638
2639	DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_trace_extent,
2640
2641	TP_PROTO(const struct btrfs_fs_info *fs_info,
2642	const struct btrfs_qgroup_extent_record *rec,
2643	u64 bytenr),
2644
2645	TP_ARGS(fs_info, rec, bytenr)
2646	);
2647
2648	TRACE_EVENT(btrfs_qgroup_num_dirty_extents,
2649
2650	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid,
2651	u64 num_dirty_extents),
2652
2653	TP_ARGS(fs_info, transid, num_dirty_extents),
2654
2655	TP_STRUCT__entry_btrfs(
2656	__field( u64, transid )
2657	__field( u64, num_dirty_extents )
2658	),
2659
2660	TP_fast_assign_btrfs(fs_info,
2661	__entry->transid = transid;
2662	__entry->num_dirty_extents = num_dirty_extents;
2663	),
2664
2665	TP_printk_btrfs("transid=%llu num_dirty_extents=%llu",
2666	__entry->transid, __entry->num_dirty_extents)
2667	);
2668
2669	TRACE_EVENT(btrfs_qgroup_account_extent,
2670
2671	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 transid, u64 bytenr,
2672	u64 num_bytes, u64 nr_old_roots, u64 nr_new_roots),
2673
2674	TP_ARGS(fs_info, transid, bytenr, num_bytes, nr_old_roots,
2675	nr_new_roots),
2676
2677	TP_STRUCT__entry_btrfs(
2678	__field( u64, transid )
2679	__field( u64, bytenr )
2680	__field( u64, num_bytes )
2681	__field( u64, nr_old_roots )
2682	__field( u64, nr_new_roots )
2683	),
2684
2685	TP_fast_assign_btrfs(fs_info,
2686	__entry->transid = transid;
2687	__entry->bytenr = bytenr;
2688	__entry->num_bytes = num_bytes;
2689	__entry->nr_old_roots = nr_old_roots;
2690	__entry->nr_new_roots = nr_new_roots;
2691	),
2692
2693	TP_printk_btrfs(
2694	"transid=%llu bytenr=%llu num_bytes=%llu nr_old_roots=%llu nr_new_roots=%llu",
2695	__entry->transid,
2696	__entry->bytenr,
2697	__entry->num_bytes,
2698	__entry->nr_old_roots,
2699	__entry->nr_new_roots)
2700	);
2701
2702	TRACE_EVENT(btrfs_qgroup_update_counters,
2703
2704	TP_PROTO(const struct btrfs_fs_info *fs_info,
2705	const struct btrfs_qgroup *qgroup,
2706	u64 cur_old_count, u64 cur_new_count),
2707
2708	TP_ARGS(fs_info, qgroup, cur_old_count, cur_new_count),
2709
2710	TP_STRUCT__entry_btrfs(
2711	__field( u64, qgid )
2712	__field( u64, old_rfer )
2713	__field( u64, old_excl )
2714	__field( u64, cur_old_count )
2715	__field( u64, cur_new_count )
2716	),
2717
2718	TP_fast_assign_btrfs(fs_info,
2719	__entry->qgid = qgroup->qgroupid;
2720	__entry->old_rfer = qgroup->rfer;
2721	__entry->old_excl = qgroup->excl;
2722	__entry->cur_old_count = cur_old_count;
2723	__entry->cur_new_count = cur_new_count;
2724	),
2725
2726	TP_printk_btrfs("qgid=%llu old_rfer=%llu old_excl=%llu cur_old_count=%llu cur_new_count=%llu",
2727	__entry->qgid, __entry->old_rfer, __entry->old_excl,
2728	__entry->cur_old_count, __entry->cur_new_count)
2729	);
2730
2731	TRACE_EVENT(btrfs_qgroup_update_reserve,
2732
2733	TP_PROTO(const struct btrfs_fs_info fs_info, const struct btrfs_qgroup qgroup,
2734	s64 diff, int type),
2735
2736	TP_ARGS(fs_info, qgroup, diff, type),
2737
2738	TP_STRUCT__entry_btrfs(
2739	__field( u64, qgid )
2740	__field( u64, cur_reserved )
2741	__field( s64, diff )
2742	__field( int, type )
2743	),
2744
2745	TP_fast_assign_btrfs(fs_info,
2746	__entry->qgid = qgroup->qgroupid;
2747	__entry->cur_reserved = qgroup->rsv.values[type];
2748	__entry->diff = diff;
2749	__entry->type = type;
2750	),
2751
2752	TP_printk_btrfs("qgid=%llu type=%s cur_reserved=%llu diff=%lld",
2753	__entry->qgid, __print_symbolic(__entry->type, QGROUP_RSV_TYPES),
2754	__entry->cur_reserved, __entry->diff)
2755	);
2756
2757	TRACE_EVENT(btrfs_qgroup_meta_reserve,
2758
2759	TP_PROTO(const struct btrfs_root *root, s64 diff, int type),
2760
2761	TP_ARGS(root, diff, type),
2762
2763	TP_STRUCT__entry_btrfs(
2764	__field( u64, refroot )
2765	__field( s64, diff )
2766	__field( int, type )
2767	),
2768
2769	TP_fast_assign_btrfs(root->fs_info,
2770	__entry->refroot = btrfs_root_id(root);
2771	__entry->diff = diff;
2772	__entry->type = type;
2773	),
2774
2775	TP_printk_btrfs("refroot=%llu(%s) type=%s diff=%lld",
2776	show_root_type(__entry->refroot),
2777	__print_symbolic(__entry->type, QGROUP_RSV_TYPES), __entry->diff)
2778	);
2779
2780	TRACE_EVENT(btrfs_qgroup_meta_convert,
2781
2782	TP_PROTO(const struct btrfs_root *root, s64 diff),
2783
2784	TP_ARGS(root, diff),
2785
2786	TP_STRUCT__entry_btrfs(
2787	__field( u64, refroot )
2788	__field( s64, diff )
2789	),
2790
2791	TP_fast_assign_btrfs(root->fs_info,
2792	__entry->refroot = btrfs_root_id(root);
2793	__entry->diff = diff;
2794	),
2795
2796	TP_printk_btrfs("refroot=%llu(%s) type=%s->%s diff=%lld",
2797	show_root_type(__entry->refroot),
2798	__print_symbolic(BTRFS_QGROUP_RSV_META_PREALLOC, QGROUP_RSV_TYPES),
2799	__print_symbolic(BTRFS_QGROUP_RSV_META_PERTRANS, QGROUP_RSV_TYPES),
2800	__entry->diff)
2801	);
2802
2803	TRACE_EVENT(btrfs_qgroup_meta_free_all_pertrans,
2804
2805	TP_PROTO(struct btrfs_root *root),
2806
2807	TP_ARGS(root),
2808
2809	TP_STRUCT__entry_btrfs(
2810	__field( u64, refroot )
2811	__field( s64, diff )
2812	__field( int, type )
2813	),
2814
2815	TP_fast_assign_btrfs(root->fs_info,
2816	__entry->refroot = btrfs_root_id(root);
2817	spin_lock(&root->qgroup_meta_rsv_lock);
2818	__entry->diff = -(s64)root->qgroup_meta_rsv_pertrans;
2819	spin_unlock(&root->qgroup_meta_rsv_lock);
2820	__entry->type = BTRFS_QGROUP_RSV_META_PERTRANS;
2821	),
2822
2823	TP_printk_btrfs("refroot=%llu(%s) type=%s diff=%lld",
2824	show_root_type(__entry->refroot),
2825	__print_symbolic(__entry->type, QGROUP_RSV_TYPES), __entry->diff)
2826	);
2827
2828	DECLARE_EVENT_CLASS(btrfs__prelim_ref,
2829	TP_PROTO(const struct btrfs_fs_info *fs_info,
2830	const struct prelim_ref *oldref,
2831	const struct prelim_ref *newref, u64 tree_size),
2832	TP_ARGS(fs_info, oldref, newref, tree_size),
2833
2834	TP_STRUCT__entry_btrfs(
2835	__field( u64, root_id )
2836	__field( u64, objectid )
2837	__field( u8, type )
2838	__field( u64, offset )
2839	__field( int, level )
2840	__field( int, old_count )
2841	__field( u64, parent )
2842	__field( u64, bytenr )
2843	__field( int, mod_count )
2844	__field( u64, tree_size )
2845	),
2846
2847	TP_fast_assign_btrfs(fs_info,
2848	__entry->root_id = oldref->root_id;
2849	__entry->objectid = oldref->key_for_search.objectid;
2850	__entry->type = oldref->key_for_search.type;
2851	__entry->offset = oldref->key_for_search.offset;
2852	__entry->level = oldref->level;
2853	__entry->old_count = oldref->count;
2854	__entry->parent = oldref->parent;
2855	__entry->bytenr = oldref->wanted_disk_byte;
2856	__entry->mod_count = newref ? newref->count : 0;
2857	__entry->tree_size = tree_size;
2858	),
2859
2860	TP_printk_btrfs("root_id=%llu key=[%llu,%u,%llu] level=%d count=[%d+%d=%d] parent=%llu wanted_disk_byte=%llu nodes=%llu",
2861	__entry->root_id,
2862	__entry->objectid, __entry->type,
2863	__entry->offset, __entry->level,
2864	__entry->old_count, __entry->mod_count,
2865	__entry->old_count + __entry->mod_count,
2866	__entry->parent,
2867	__entry->bytenr,
2868	__entry->tree_size)
2869	);
2870
2871	DEFINE_EVENT(btrfs__prelim_ref, btrfs_prelim_ref_merge,
2872	TP_PROTO(const struct btrfs_fs_info *fs_info,
2873	const struct prelim_ref *oldref,
2874	const struct prelim_ref *newref, u64 tree_size),
2875	TP_ARGS(fs_info, oldref, newref, tree_size)
2876	);
2877
2878	DEFINE_EVENT(btrfs__prelim_ref, btrfs_prelim_ref_insert,
2879	TP_PROTO(const struct btrfs_fs_info *fs_info,
2880	const struct prelim_ref *oldref,
2881	const struct prelim_ref *newref, u64 tree_size),
2882	TP_ARGS(fs_info, oldref, newref, tree_size)
2883	);
2884
2885	TRACE_EVENT(btrfs_inode_mod_outstanding_extents,
2886	TP_PROTO(const struct btrfs_root *root, u64 ino, int mod, unsigned outstanding),
2887
2888	TP_ARGS(root, ino, mod, outstanding),
2889
2890	TP_STRUCT__entry_btrfs(
2891	__field( u64, root_objectid )
2892	__field( u64, ino )
2893	__field( int, mod )
2894	__field( unsigned, outstanding )
2895	),
2896
2897	TP_fast_assign_btrfs(root->fs_info,
2898	__entry->root_objectid = btrfs_root_id(root);
2899	__entry->ino = ino;
2900	__entry->mod = mod;
2901	__entry->outstanding = outstanding;
2902	),
2903
2904	TP_printk_btrfs("root=%llu(%s) ino=%llu mod=%d outstanding=%u",
2905	show_root_type(__entry->root_objectid),
2906	__entry->ino, __entry->mod, __entry->outstanding)
2907	);
2908
2909	DECLARE_EVENT_CLASS(btrfs__block_group,
2910	TP_PROTO(const struct btrfs_block_group *bg_cache),
2911
2912	TP_ARGS(bg_cache),
2913
2914	TP_STRUCT__entry_btrfs(
2915	__field( u64, bytenr )
2916	__field( u64, len )
2917	__field( u64, used )
2918	__field( u64, flags )
2919	),
2920
2921	TP_fast_assign_btrfs(bg_cache->fs_info,
2922	__entry->bytenr = bg_cache->start,
2923	__entry->len = bg_cache->length,
2924	__entry->used = bg_cache->used;
2925	__entry->flags = bg_cache->flags;
2926	),
2927
2928	TP_printk_btrfs("bg bytenr=%llu len=%llu used=%llu flags=%llu(%s)",
2929	__entry->bytenr, __entry->len, __entry->used, __entry->flags,
2930	__print_flags(__entry->flags, "\|", BTRFS_GROUP_FLAGS))
2931	);
2932
2933	DEFINE_EVENT(btrfs__block_group, btrfs_remove_block_group,
2934	TP_PROTO(const struct btrfs_block_group *bg_cache),
2935
2936	TP_ARGS(bg_cache)
2937	);
2938
2939	DEFINE_EVENT(btrfs__block_group, btrfs_add_unused_block_group,
2940	TP_PROTO(const struct btrfs_block_group *bg_cache),
2941
2942	TP_ARGS(bg_cache)
2943	);
2944
2945	DEFINE_EVENT(btrfs__block_group, btrfs_add_reclaim_block_group,
2946	TP_PROTO(const struct btrfs_block_group *bg_cache),
2947
2948	TP_ARGS(bg_cache)
2949	);
2950
2951	DEFINE_EVENT(btrfs__block_group, btrfs_reclaim_block_group,
2952	TP_PROTO(const struct btrfs_block_group *bg_cache),
2953
2954	TP_ARGS(bg_cache)
2955	);
2956
2957	DEFINE_EVENT(btrfs__block_group, btrfs_skip_unused_block_group,
2958	TP_PROTO(const struct btrfs_block_group *bg_cache),
2959
2960	TP_ARGS(bg_cache)
2961	);
2962
2963	TRACE_EVENT(btrfs_set_extent_bit,
2964	TP_PROTO(const struct extent_io_tree *tree,
2965	u64 start, u64 len, unsigned set_bits),
2966
2967	TP_ARGS(tree, start, len, set_bits),
2968
2969	TP_STRUCT__entry_btrfs(
2970	__field( unsigned, owner )
2971	__field( u64, ino )
2972	__field( u64, rootid )
2973	__field( u64, start )
2974	__field( u64, len )
2975	__field( unsigned, set_bits)
2976	),
2977
2978	TP_fast_assign_btrfs(btrfs_extent_io_tree_to_fs_info(tree),
2979	const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree);
2980
2981	__entry->owner = tree->owner;
2982	__entry->ino = inode ? btrfs_ino(inode) : 0;
2983	__entry->rootid = inode ? btrfs_root_id(inode->root) : 0;
2984	__entry->start = start;
2985	__entry->len = len;
2986	__entry->set_bits = set_bits;
2987	),
2988
2989	TP_printk_btrfs(
2990	"io_tree=%s ino=%llu root=%llu start=%llu len=%llu set_bits=%s",
2991	__print_symbolic(__entry->owner, IO_TREE_OWNER), __entry->ino,
2992	__entry->rootid, __entry->start, __entry->len,
2993	__print_flags(__entry->set_bits, "\|", EXTENT_FLAGS))
2994	);
2995
2996	TRACE_EVENT(btrfs_clear_extent_bit,
2997	TP_PROTO(const struct extent_io_tree *tree,
2998	u64 start, u64 len, unsigned clear_bits),
2999
3000	TP_ARGS(tree, start, len, clear_bits),
3001
3002	TP_STRUCT__entry_btrfs(
3003	__field( unsigned, owner )
3004	__field( u64, ino )
3005	__field( u64, rootid )
3006	__field( u64, start )
3007	__field( u64, len )
3008	__field( unsigned, clear_bits)
3009	),
3010
3011	TP_fast_assign_btrfs(btrfs_extent_io_tree_to_fs_info(tree),
3012	const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree);
3013
3014	__entry->owner = tree->owner;
3015	__entry->ino = inode ? btrfs_ino(inode) : 0;
3016	__entry->rootid = inode ? btrfs_root_id(inode->root) : 0;
3017	__entry->start = start;
3018	__entry->len = len;
3019	__entry->clear_bits = clear_bits;
3020	),
3021
3022	TP_printk_btrfs(
3023	"io_tree=%s ino=%llu root=%llu start=%llu len=%llu clear_bits=%s",
3024	__print_symbolic(__entry->owner, IO_TREE_OWNER), __entry->ino,
3025	__entry->rootid, __entry->start, __entry->len,
3026	__print_flags(__entry->clear_bits, "\|", EXTENT_FLAGS))
3027	);
3028
3029	TRACE_EVENT(btrfs_convert_extent_bit,
3030	TP_PROTO(const struct extent_io_tree *tree,
3031	u64 start, u64 len, unsigned set_bits, unsigned clear_bits),
3032
3033	TP_ARGS(tree, start, len, set_bits, clear_bits),
3034
3035	TP_STRUCT__entry_btrfs(
3036	__field( unsigned, owner )
3037	__field( u64, ino )
3038	__field( u64, rootid )
3039	__field( u64, start )
3040	__field( u64, len )
3041	__field( unsigned, set_bits)
3042	__field( unsigned, clear_bits)
3043	),
3044
3045	TP_fast_assign_btrfs(btrfs_extent_io_tree_to_fs_info(tree),
3046	const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree);
3047
3048	__entry->owner = tree->owner;
3049	__entry->ino = inode ? btrfs_ino(inode) : 0;
3050	__entry->rootid = inode ? btrfs_root_id(inode->root) : 0;
3051	__entry->start = start;
3052	__entry->len = len;
3053	__entry->set_bits = set_bits;
3054	__entry->clear_bits = clear_bits;
3055	),
3056
3057	TP_printk_btrfs(
3058	"io_tree=%s ino=%llu root=%llu start=%llu len=%llu set_bits=%s clear_bits=%s",
3059	__print_symbolic(__entry->owner, IO_TREE_OWNER), __entry->ino,
3060	__entry->rootid, __entry->start, __entry->len,
3061	__print_flags(__entry->set_bits , "\|", EXTENT_FLAGS),
3062	__print_flags(__entry->clear_bits, "\|", EXTENT_FLAGS))
3063	);
3064
3065	DECLARE_EVENT_CLASS(btrfs_dump_space_info,
3066	TP_PROTO(struct btrfs_fs_info *fs_info,
3067	const struct btrfs_space_info *sinfo),
3068
3069	TP_ARGS(fs_info, sinfo),
3070
3071	TP_STRUCT__entry_btrfs(
3072	__field( u64, flags )
3073	__field( u64, total_bytes )
3074	__field( u64, bytes_used )
3075	__field( u64, bytes_pinned )
3076	__field( u64, bytes_reserved )
3077	__field( u64, bytes_may_use )
3078	__field( u64, bytes_readonly )
3079	__field( u64, reclaim_size )
3080	__field( int, clamp )
3081	__field( u64, global_reserved )
3082	__field( u64, trans_reserved )
3083	__field( u64, delayed_refs_reserved )
3084	__field( u64, delayed_reserved )
3085	__field( u64, free_chunk_space )
3086	__field( u64, delalloc_bytes )
3087	__field( u64, ordered_bytes )
3088	),
3089
3090	TP_fast_assign_btrfs(fs_info,
3091	__entry->flags = sinfo->flags;
3092	__entry->total_bytes = sinfo->total_bytes;
3093	__entry->bytes_used = sinfo->bytes_used;
3094	__entry->bytes_pinned = sinfo->bytes_pinned;
3095	__entry->bytes_reserved = sinfo->bytes_reserved;
3096	__entry->bytes_may_use = sinfo->bytes_may_use;
3097	__entry->bytes_readonly = sinfo->bytes_readonly;
3098	__entry->reclaim_size = sinfo->reclaim_size;
3099	__entry->clamp = sinfo->clamp;
3100	__entry->global_reserved = fs_info->global_block_rsv.reserved;
3101	__entry->trans_reserved = fs_info->trans_block_rsv.reserved;
3102	__entry->delayed_refs_reserved = fs_info->delayed_refs_rsv.reserved;
3103	__entry->delayed_reserved = fs_info->delayed_block_rsv.reserved;
3104	__entry->free_chunk_space = atomic64_read(&fs_info->free_chunk_space);
3105	__entry->delalloc_bytes = percpu_counter_sum_positive(&fs_info->delalloc_bytes);
3106	__entry->ordered_bytes = percpu_counter_sum_positive(&fs_info->ordered_bytes);
3107	),
3108
3109	TP_printk_btrfs("flags=%s total_bytes=%llu bytes_used=%llu "
3110	"bytes_pinned=%llu bytes_reserved=%llu "
3111	"bytes_may_use=%llu bytes_readonly=%llu "
3112	"reclaim_size=%llu clamp=%d global_reserved=%llu "
3113	"trans_reserved=%llu delayed_refs_reserved=%llu "
3114	"delayed_reserved=%llu chunk_free_space=%llu "
3115	"delalloc_bytes=%llu ordered_bytes=%llu",
3116	__print_flags(__entry->flags, "\|", BTRFS_GROUP_FLAGS),
3117	__entry->total_bytes, __entry->bytes_used,
3118	__entry->bytes_pinned, __entry->bytes_reserved,
3119	__entry->bytes_may_use, __entry->bytes_readonly,
3120	__entry->reclaim_size, __entry->clamp,
3121	__entry->global_reserved, __entry->trans_reserved,
3122	__entry->delayed_refs_reserved,
3123	__entry->delayed_reserved, __entry->free_chunk_space,
3124	__entry->delalloc_bytes, __entry->ordered_bytes)
3125	);
3126
3127	DEFINE_EVENT(btrfs_dump_space_info, btrfs_done_preemptive_reclaim,
3128	TP_PROTO(struct btrfs_fs_info *fs_info,
3129	const struct btrfs_space_info *sinfo),
3130	TP_ARGS(fs_info, sinfo)
3131	);
3132
3133	DEFINE_EVENT(btrfs_dump_space_info, btrfs_fail_all_tickets,
3134	TP_PROTO(struct btrfs_fs_info *fs_info,
3135	const struct btrfs_space_info *sinfo),
3136	TP_ARGS(fs_info, sinfo)
3137	);
3138
3139	TRACE_EVENT(btrfs_reserve_ticket,
3140	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,
3141	u64 start_ns, int flush, int error),
3142
3143	TP_ARGS(fs_info, flags, bytes, start_ns, flush, error),
3144
3145	TP_STRUCT__entry_btrfs(
3146	__field( u64, flags )
3147	__field( u64, bytes )
3148	__field( u64, start_ns )
3149	__field( int, flush )
3150	__field( int, error )
3151	),
3152
3153	TP_fast_assign_btrfs(fs_info,
3154	__entry->flags = flags;
3155	__entry->bytes = bytes;
3156	__entry->start_ns = start_ns;
3157	__entry->flush = flush;
3158	__entry->error = error;
3159	),
3160
3161	TP_printk_btrfs("flags=%s bytes=%llu start_ns=%llu flush=%s error=%d",
3162	__print_flags(__entry->flags, "\|", BTRFS_GROUP_FLAGS),
3163	__entry->bytes, __entry->start_ns,
3164	__print_symbolic(__entry->flush, FLUSH_ACTIONS),
3165	__entry->error)
3166	);
3167
3168	DECLARE_EVENT_CLASS(btrfs_sleep_tree_lock,
3169	TP_PROTO(const struct extent_buffer *eb, u64 start_ns),
3170
3171	TP_ARGS(eb, start_ns),
3172
3173	TP_STRUCT__entry_btrfs(
3174	__field( u64, block )
3175	__field( u64, generation )
3176	__field( u64, start_ns )
3177	__field( u64, end_ns )
3178	__field( u64, diff_ns )
3179	__field( u64, owner )
3180	__field( int, is_log_tree )
3181	),
3182
3183	TP_fast_assign_btrfs(eb->fs_info,
3184	__entry->block = eb->start;
3185	__entry->generation = btrfs_header_generation(eb);
3186	__entry->start_ns = start_ns;
3187	__entry->end_ns = ktime_get_ns();
3188	__entry->diff_ns = __entry->end_ns - start_ns;
3189	__entry->owner = btrfs_header_owner(eb);
3190	__entry->is_log_tree = (eb->log_index >= 0);
3191	),
3192
3193	TP_printk_btrfs(
3194	"block=%llu generation=%llu start_ns=%llu end_ns=%llu diff_ns=%llu owner=%llu is_log_tree=%d",
3195	__entry->block, __entry->generation,
3196	__entry->start_ns, __entry->end_ns, __entry->diff_ns,
3197	__entry->owner, __entry->is_log_tree)
3198	);
3199
3200	DEFINE_EVENT(btrfs_sleep_tree_lock, btrfs_tree_read_lock,
3201	TP_PROTO(const struct extent_buffer *eb, u64 start_ns),
3202
3203	TP_ARGS(eb, start_ns)
3204	);
3205
3206	DEFINE_EVENT(btrfs_sleep_tree_lock, btrfs_tree_lock,
3207	TP_PROTO(const struct extent_buffer *eb, u64 start_ns),
3208
3209	TP_ARGS(eb, start_ns)
3210	);
3211
3212	DECLARE_EVENT_CLASS(btrfs_locking_events,
3213	TP_PROTO(const struct extent_buffer *eb),
3214
3215	TP_ARGS(eb),
3216
3217	TP_STRUCT__entry_btrfs(
3218	__field( u64, block )
3219	__field( u64, generation )
3220	__field( u64, owner )
3221	__field( int, is_log_tree )
3222	),
3223
3224	TP_fast_assign_btrfs(eb->fs_info,
3225	__entry->block = eb->start;
3226	__entry->generation = btrfs_header_generation(eb);
3227	__entry->owner = btrfs_header_owner(eb);
3228	__entry->is_log_tree = (eb->log_index >= 0);
3229	),
3230
3231	TP_printk_btrfs("block=%llu generation=%llu owner=%llu is_log_tree=%d",
3232	__entry->block, __entry->generation,
3233	__entry->owner, __entry->is_log_tree)
3234	);
3235
3236	#define DEFINE_BTRFS_LOCK_EVENT(name) \
3237	DEFINE_EVENT(btrfs_locking_events, name, \
3238	TP_PROTO(const struct extent_buffer *eb), \
3239	\
3240	TP_ARGS(eb) \
3241	)
3242
3243	DEFINE_BTRFS_LOCK_EVENT(btrfs_tree_unlock);
3244	DEFINE_BTRFS_LOCK_EVENT(btrfs_tree_read_unlock);
3245	DEFINE_BTRFS_LOCK_EVENT(btrfs_try_tree_read_lock);
3246
3247	DECLARE_EVENT_CLASS(btrfs__space_info_update,
3248
3249	TP_PROTO(const struct btrfs_fs_info *fs_info,
3250	const struct btrfs_space_info *sinfo, u64 old, s64 diff),
3251
3252	TP_ARGS(fs_info, sinfo, old, diff),
3253
3254	TP_STRUCT__entry_btrfs(
3255	__field( u64, type )
3256	__field( u64, old )
3257	__field( s64, diff )
3258	),
3259
3260	TP_fast_assign_btrfs(fs_info,
3261	__entry->type = sinfo->flags;
3262	__entry->old = old;
3263	__entry->diff = diff;
3264	),
3265	TP_printk_btrfs("type=%s old=%llu diff=%lld",
3266	__print_flags(__entry->type, "\|", BTRFS_GROUP_FLAGS),
3267	__entry->old, __entry->diff)
3268	);
3269
3270	DEFINE_EVENT(btrfs__space_info_update, update_bytes_may_use,
3271
3272	TP_PROTO(const struct btrfs_fs_info *fs_info,
3273	const struct btrfs_space_info *sinfo, u64 old, s64 diff),
3274
3275	TP_ARGS(fs_info, sinfo, old, diff)
3276	);
3277
3278	DEFINE_EVENT(btrfs__space_info_update, update_bytes_pinned,
3279
3280	TP_PROTO(const struct btrfs_fs_info *fs_info,
3281	const struct btrfs_space_info *sinfo, u64 old, s64 diff),
3282
3283	TP_ARGS(fs_info, sinfo, old, diff)
3284	);
3285
3286	DEFINE_EVENT(btrfs__space_info_update, update_bytes_zone_unusable,
3287
3288	TP_PROTO(const struct btrfs_fs_info *fs_info,
3289	const struct btrfs_space_info *sinfo, u64 old, s64 diff),
3290
3291	TP_ARGS(fs_info, sinfo, old, diff)
3292	);
3293
3294	DECLARE_EVENT_CLASS(btrfs_raid56_bio,
3295
3296	TP_PROTO(const struct btrfs_raid_bio *rbio,
3297	const struct bio *bio,
3298	const struct raid56_bio_trace_info *trace_info),
3299
3300	TP_ARGS(rbio, bio, trace_info),
3301
3302	TP_STRUCT__entry_btrfs(
3303	__field( u64, full_stripe )
3304	__field( u64, physical )
3305	__field( u64, devid )
3306	__field( u32, offset )
3307	__field( u32, len )
3308	__field( u8, opf )
3309	__field( u8, total_stripes )
3310	__field( u8, real_stripes )
3311	__field( u8, nr_data )
3312	__field( u8, stripe_nr )
3313	),
3314
3315	TP_fast_assign_btrfs(rbio->bioc->fs_info,
3316	__entry->full_stripe = rbio->bioc->full_stripe_logical;
3317	__entry->physical = bio->bi_iter.bi_sector << SECTOR_SHIFT;
3318	__entry->len = bio->bi_iter.bi_size;
3319	__entry->opf = bio_op(bio);
3320	__entry->devid = trace_info->devid;
3321	__entry->offset = trace_info->offset;
3322	__entry->stripe_nr = trace_info->stripe_nr;
3323	__entry->total_stripes = rbio->bioc->num_stripes;
3324	__entry->real_stripes = rbio->real_stripes;
3325	__entry->nr_data = rbio->nr_data;
3326	),
3327	/*
3328	* For type output, we need to output things like "DATA1"
3329	* (the first data stripe), "DATA2" (the second data stripe),
3330	* "PQ1" (P stripe),"PQ2" (Q stripe), "REPLACE0" (replace target device).
3331	*/
3332	TP_printk_btrfs(
3333	"full_stripe=%llu devid=%lld type=%s%d offset=%d opf=0x%x physical=%llu len=%u",
3334	__entry->full_stripe, __entry->devid,
3335	(__entry->stripe_nr < __entry->nr_data) ? "DATA" :
3336	((__entry->stripe_nr < __entry->real_stripes) ? "PQ" :
3337	"REPLACE"),
3338	(__entry->stripe_nr < __entry->nr_data) ?
3339	(__entry->stripe_nr + 1) :
3340	((__entry->stripe_nr < __entry->real_stripes) ?
3341	(__entry->stripe_nr - __entry->nr_data + 1) : 0),
3342	__entry->offset, __entry->opf, __entry->physical, __entry->len)
3343	);
3344
3345	DEFINE_EVENT(btrfs_raid56_bio, raid56_read,
3346	TP_PROTO(const struct btrfs_raid_bio *rbio,
3347	const struct bio *bio,
3348	const struct raid56_bio_trace_info *trace_info),
3349
3350	TP_ARGS(rbio, bio, trace_info)
3351	);
3352
3353	DEFINE_EVENT(btrfs_raid56_bio, raid56_write,
3354	TP_PROTO(const struct btrfs_raid_bio *rbio,
3355	const struct bio *bio,
3356	const struct raid56_bio_trace_info *trace_info),
3357
3358	TP_ARGS(rbio, bio, trace_info)
3359	);
3360
3361	TRACE_EVENT(btrfs_insert_one_raid_extent,
3362
3363	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length,
3364	int num_stripes),
3365
3366	TP_ARGS(fs_info, logical, length, num_stripes),
3367
3368	TP_STRUCT__entry_btrfs(
3369	__field( u64, logical )
3370	__field( u64, length )
3371	__field( int, num_stripes )
3372	),
3373
3374	TP_fast_assign_btrfs(fs_info,
3375	__entry->logical = logical;
3376	__entry->length = length;
3377	__entry->num_stripes = num_stripes;
3378	),
3379
3380	TP_printk_btrfs("logical=%llu length=%llu num_stripes=%d",
3381	__entry->logical, __entry->length,
3382	__entry->num_stripes)
3383	);
3384
3385	TRACE_EVENT(btrfs_raid_extent_delete,
3386
3387	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 end,
3388	u64 found_start, u64 found_end),
3389
3390	TP_ARGS(fs_info, start, end, found_start, found_end),
3391
3392	TP_STRUCT__entry_btrfs(
3393	__field( u64, start )
3394	__field( u64, end )
3395	__field( u64, found_start )
3396	__field( u64, found_end )
3397	),
3398
3399	TP_fast_assign_btrfs(fs_info,
3400	__entry->start = start;
3401	__entry->end = end;
3402	__entry->found_start = found_start;
3403	__entry->found_end = found_end;
3404	),
3405
3406	TP_printk_btrfs("start=%llu end=%llu found_start=%llu found_end=%llu",
3407	__entry->start, __entry->end, __entry->found_start,
3408	__entry->found_end)
3409	);
3410
3411	TRACE_EVENT(btrfs_get_raid_extent_offset,
3412
3413	TP_PROTO(const struct btrfs_fs_info *fs_info, u64 logical, u64 length,
3414	u64 physical, u64 devid),
3415
3416	TP_ARGS(fs_info, logical, length, physical, devid),
3417
3418	TP_STRUCT__entry_btrfs(
3419	__field( u64, logical )
3420	__field( u64, length )
3421	__field( u64, physical )
3422	__field( u64, devid )
3423	),
3424
3425	TP_fast_assign_btrfs(fs_info,
3426	__entry->logical = logical;
3427	__entry->length = length;
3428	__entry->physical = physical;
3429	__entry->devid = devid;
3430	),
3431
3432	TP_printk_btrfs("logical=%llu length=%llu physical=%llu devid=%llu",
3433	__entry->logical, __entry->length, __entry->physical,
3434	__entry->devid)
3435	);
3436
3437	TRACE_EVENT(btrfs_extent_map_shrinker_count,
3438
3439	TP_PROTO(const struct btrfs_fs_info *fs_info, long nr),
3440
3441	TP_ARGS(fs_info, nr),
3442
3443	TP_STRUCT__entry_btrfs(
3444	__field( long, nr )
3445	),
3446
3447	TP_fast_assign_btrfs(fs_info,
3448	__entry->nr = nr;
3449	),
3450
3451	TP_printk_btrfs("nr=%ld", __entry->nr)
3452	);
3453
3454	TRACE_EVENT(btrfs_extent_map_shrinker_scan_enter,
3455
3456	TP_PROTO(const struct btrfs_fs_info *fs_info, long nr),
3457
3458	TP_ARGS(fs_info, nr),
3459
3460	TP_STRUCT__entry_btrfs(
3461	__field( long, nr_to_scan )
3462	__field( long, nr )
3463	__field( u64, last_root_id )
3464	__field( u64, last_ino )
3465	),
3466
3467	TP_fast_assign_btrfs(fs_info,
3468	__entry->nr_to_scan = \
3469	atomic64_read(&fs_info->em_shrinker_nr_to_scan);
3470	__entry->nr = nr;
3471	__entry->last_root_id = fs_info->em_shrinker_last_root;
3472	__entry->last_ino = fs_info->em_shrinker_last_ino;
3473	),
3474
3475	TP_printk_btrfs("nr_to_scan=%ld nr=%ld last_root=%llu(%s) last_ino=%llu",
3476	__entry->nr_to_scan, __entry->nr,
3477	show_root_type(__entry->last_root_id), __entry->last_ino)
3478	);
3479
3480	TRACE_EVENT(btrfs_extent_map_shrinker_scan_exit,
3481
3482	TP_PROTO(const struct btrfs_fs_info *fs_info, long nr_dropped, long nr),
3483
3484	TP_ARGS(fs_info, nr_dropped, nr),
3485
3486	TP_STRUCT__entry_btrfs(
3487	__field( long, nr_dropped )
3488	__field( long, nr )
3489	__field( u64, last_root_id )
3490	__field( u64, last_ino )
3491	),
3492
3493	TP_fast_assign_btrfs(fs_info,
3494	__entry->nr_dropped = nr_dropped;
3495	__entry->nr = nr;
3496	__entry->last_root_id = fs_info->em_shrinker_last_root;
3497	__entry->last_ino = fs_info->em_shrinker_last_ino;
3498	),
3499
3500	TP_printk_btrfs("nr_dropped=%ld nr=%ld last_root=%llu(%s) last_ino=%llu",
3501	__entry->nr_dropped, __entry->nr,
3502	show_root_type(__entry->last_root_id), __entry->last_ino)
3503	);
3504
3505	TRACE_EVENT(btrfs_extent_map_shrinker_remove_em,
3506
3507	TP_PROTO(const struct btrfs_inode inode, const struct extent_map em),
3508
3509	TP_ARGS(inode, em),
3510
3511	TP_STRUCT__entry_btrfs(
3512	__field( u64, ino )
3513	__field( u64, root_id )
3514	__field( u64, start )
3515	__field( u64, len )
3516	__field( u32, flags )
3517	),
3518
3519	TP_fast_assign_btrfs(inode->root->fs_info,
3520	__entry->ino = btrfs_ino(inode);
3521	__entry->root_id = btrfs_root_id(inode->root);
3522	__entry->start = em->start;
3523	__entry->len = em->len;
3524	__entry->flags = em->flags;
3525	),
3526
3527	TP_printk_btrfs("ino=%llu root=%llu(%s) start=%llu len=%llu flags=%s",
3528	__entry->ino, show_root_type(__entry->root_id),
3529	__entry->start, __entry->len,
3530	show_map_flags(__entry->flags))
3531	);
3532
3533	#endif /* _TRACE_BTRFS_H */
3534
3535	/* This part must be outside protection */
3536	#include <trace/define_trace.h>