2 #define TRACE_SYSTEM btrfs
4 #if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
7 #include <linux/writeback.h>
8 #include <linux/tracepoint.h>
9 #include <trace/events/mmflags.h>
15 struct btrfs_file_extent_item;
16 struct btrfs_ordered_extent;
17 struct btrfs_delayed_ref_node;
18 struct btrfs_delayed_tree_ref;
19 struct btrfs_delayed_data_ref;
20 struct btrfs_delayed_ref_head;
21 struct btrfs_block_group_cache;
22 struct btrfs_free_cluster;
26 struct __btrfs_workqueue;
27 struct btrfs_qgroup_extent_record;
31 #define show_ref_type(type) \
32 __print_symbolic(type, \
33 { BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \
34 { BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \
35 { BTRFS_EXTENT_REF_V0_KEY, "EXTENT_REF_V0" }, \
36 { BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \
37 { BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" })
39 #define __show_root_type(obj) \
40 __print_symbolic_u64(obj, \
41 { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
42 { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
43 { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
44 { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
45 { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
46 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
47 { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
48 { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
49 { BTRFS_QUOTA_TREE_OBJECTID, "QUOTA_TREE" }, \
50 { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
51 { BTRFS_UUID_TREE_OBJECTID, "UUID_TREE" }, \
52 { BTRFS_FREE_SPACE_TREE_OBJECTID, "FREE_SPACE_TREE" }, \
53 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
55 #define show_root_type(obj) \
56 obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
57 (obj >= BTRFS_ROOT_TREE_OBJECTID && \
58 obj <= BTRFS_QUOTA_TREE_OBJECTID)) ? __show_root_type(obj) : "-"
60 #define show_fi_type(type) \
61 __print_symbolic(type, \
62 { BTRFS_FILE_EXTENT_INLINE, "INLINE" }, \
63 { BTRFS_FILE_EXTENT_REG, "REG" }, \
64 { BTRFS_FILE_EXTENT_PREALLOC, "PREALLOC"})
66 #define BTRFS_GROUP_FLAGS \
67 { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
68 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
69 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
70 { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
71 { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
72 { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
73 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
74 { BTRFS_BLOCK_GROUP_RAID5, "RAID5"}, \
75 { BTRFS_BLOCK_GROUP_RAID6, "RAID6"}
77 #define BTRFS_FSID_SIZE 16
78 #define TP_STRUCT__entry_fsid __array(u8, fsid, BTRFS_FSID_SIZE)
80 #define TP_fast_assign_fsid(fs_info) \
81 memcpy(__entry->fsid, fs_info->fsid, BTRFS_FSID_SIZE)
83 #define TP_STRUCT__entry_btrfs(args...) \
85 TP_STRUCT__entry_fsid \
87 #define TP_fast_assign_btrfs(fs_info, args...) \
89 TP_fast_assign_fsid(fs_info); \
91 #define TP_printk_btrfs(fmt, args...) \
92 TP_printk("%pU: " fmt, __entry->fsid, args)
94 TRACE_EVENT(btrfs_transaction_commit,
96 TP_PROTO(const struct btrfs_root *root),
100 TP_STRUCT__entry_btrfs(
101 __field( u64, generation )
102 __field( u64, root_objectid )
105 TP_fast_assign_btrfs(root->fs_info,
106 __entry->generation = root->fs_info->generation;
107 __entry->root_objectid = root->root_key.objectid;
110 TP_printk_btrfs("root = %llu(%s), gen = %llu",
111 show_root_type(__entry->root_objectid),
112 (unsigned long long)__entry->generation)
115 DECLARE_EVENT_CLASS(btrfs__inode,
117 TP_PROTO(const struct inode *inode),
121 TP_STRUCT__entry_btrfs(
122 __field( ino_t, ino )
123 __field( blkcnt_t, blocks )
124 __field( u64, disk_i_size )
125 __field( u64, generation )
126 __field( u64, last_trans )
127 __field( u64, logged_trans )
128 __field( u64, root_objectid )
131 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
132 __entry->ino = inode->i_ino;
133 __entry->blocks = inode->i_blocks;
134 __entry->disk_i_size = BTRFS_I(inode)->disk_i_size;
135 __entry->generation = BTRFS_I(inode)->generation;
136 __entry->last_trans = BTRFS_I(inode)->last_trans;
137 __entry->logged_trans = BTRFS_I(inode)->logged_trans;
138 __entry->root_objectid =
139 BTRFS_I(inode)->root->root_key.objectid;
142 TP_printk_btrfs("root=%llu(%s) gen=%llu ino=%lu blocks=%llu "
143 "disk_i_size=%llu last_trans=%llu logged_trans=%llu",
144 show_root_type(__entry->root_objectid),
145 (unsigned long long)__entry->generation,
146 (unsigned long)__entry->ino,
147 (unsigned long long)__entry->blocks,
148 (unsigned long long)__entry->disk_i_size,
149 (unsigned long long)__entry->last_trans,
150 (unsigned long long)__entry->logged_trans)
153 DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
155 TP_PROTO(const struct inode *inode),
160 DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
162 TP_PROTO(const struct inode *inode),
167 DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
169 TP_PROTO(const struct inode *inode),
174 #define __show_map_type(type) \
175 __print_symbolic_u64(type, \
176 { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
177 { EXTENT_MAP_HOLE, "HOLE" }, \
178 { EXTENT_MAP_INLINE, "INLINE" }, \
179 { EXTENT_MAP_DELALLOC, "DELALLOC" })
181 #define show_map_type(type) \
182 type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type)
184 #define show_map_flags(flag) \
185 __print_flags(flag, "|", \
186 { (1 << EXTENT_FLAG_PINNED), "PINNED" },\
187 { (1 << EXTENT_FLAG_COMPRESSED), "COMPRESSED" },\
188 { (1 << EXTENT_FLAG_VACANCY), "VACANCY" },\
189 { (1 << EXTENT_FLAG_PREALLOC), "PREALLOC" },\
190 { (1 << EXTENT_FLAG_LOGGING), "LOGGING" },\
191 { (1 << EXTENT_FLAG_FILLING), "FILLING" },\
192 { (1 << EXTENT_FLAG_FS_MAPPING), "FS_MAPPING" })
194 TRACE_EVENT_CONDITION(btrfs_get_extent,
196 TP_PROTO(const struct btrfs_root *root, const struct btrfs_inode *inode,
197 const struct extent_map *map),
199 TP_ARGS(root, inode, map),
203 TP_STRUCT__entry_btrfs(
204 __field( u64, root_objectid )
206 __field( u64, start )
208 __field( u64, orig_start )
209 __field( u64, block_start )
210 __field( u64, block_len )
211 __field( unsigned long, flags )
213 __field( unsigned int, compress_type )
216 TP_fast_assign_btrfs(root->fs_info,
217 __entry->root_objectid = root->root_key.objectid;
218 __entry->ino = btrfs_ino(inode);
219 __entry->start = map->start;
220 __entry->len = map->len;
221 __entry->orig_start = map->orig_start;
222 __entry->block_start = map->block_start;
223 __entry->block_len = map->block_len;
224 __entry->flags = map->flags;
225 __entry->refs = refcount_read(&map->refs);
226 __entry->compress_type = map->compress_type;
229 TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu "
230 "orig_start=%llu block_start=%llu(%s) "
231 "block_len=%llu flags=%s refs=%u "
233 show_root_type(__entry->root_objectid),
234 (unsigned long long)__entry->ino,
235 (unsigned long long)__entry->start,
236 (unsigned long long)__entry->len,
237 (unsigned long long)__entry->orig_start,
238 show_map_type(__entry->block_start),
239 (unsigned long long)__entry->block_len,
240 show_map_flags(__entry->flags),
241 __entry->refs, __entry->compress_type)
244 /* file extent item */
245 DECLARE_EVENT_CLASS(btrfs__file_extent_item_regular,
247 TP_PROTO(struct btrfs_inode *bi, struct extent_buffer *l,
248 struct btrfs_file_extent_item *fi, u64 start),
250 TP_ARGS(bi, l, fi, start),
252 TP_STRUCT__entry_btrfs(
253 __field( u64, root_obj )
255 __field( loff_t, isize )
256 __field( u64, disk_isize )
257 __field( u64, num_bytes )
258 __field( u64, ram_bytes )
259 __field( u64, disk_bytenr )
260 __field( u64, disk_num_bytes )
261 __field( u64, extent_offset )
262 __field( u8, extent_type )
263 __field( u8, compression )
264 __field( u64, extent_start )
265 __field( u64, extent_end )
268 TP_fast_assign_btrfs(bi->root->fs_info,
269 __entry->root_obj = bi->root->objectid;
270 __entry->ino = btrfs_ino(bi);
271 __entry->isize = bi->vfs_inode.i_size;
272 __entry->disk_isize = bi->disk_i_size;
273 __entry->num_bytes = btrfs_file_extent_num_bytes(l, fi);
274 __entry->ram_bytes = btrfs_file_extent_ram_bytes(l, fi);
275 __entry->disk_bytenr = btrfs_file_extent_disk_bytenr(l, fi);
276 __entry->disk_num_bytes = btrfs_file_extent_disk_num_bytes(l, fi);
277 __entry->extent_offset = btrfs_file_extent_offset(l, fi);
278 __entry->extent_type = btrfs_file_extent_type(l, fi);
279 __entry->compression = btrfs_file_extent_compression(l, fi);
280 __entry->extent_start = start;
281 __entry->extent_end = (start + __entry->num_bytes);
285 "root=%llu(%s) inode=%llu size=%llu disk_isize=%llu "
286 "file extent range=[%llu %llu] "
287 "(num_bytes=%llu ram_bytes=%llu disk_bytenr=%llu "
288 "disk_num_bytes=%llu extent_offset=%llu type=%s "
290 show_root_type(__entry->root_obj), __entry->ino,
292 __entry->disk_isize, __entry->extent_start,
293 __entry->extent_end, __entry->num_bytes, __entry->ram_bytes,
294 __entry->disk_bytenr, __entry->disk_num_bytes,
295 __entry->extent_offset, show_fi_type(__entry->extent_type),
296 __entry->compression)
300 btrfs__file_extent_item_inline,
302 TP_PROTO(struct btrfs_inode *bi, struct extent_buffer *l,
303 struct btrfs_file_extent_item *fi, int slot, u64 start),
305 TP_ARGS(bi, l, fi, slot, start),
307 TP_STRUCT__entry_btrfs(
308 __field( u64, root_obj )
310 __field( loff_t, isize )
311 __field( u64, disk_isize )
312 __field( u8, extent_type )
313 __field( u8, compression )
314 __field( u64, extent_start )
315 __field( u64, extent_end )
318 TP_fast_assign_btrfs(
320 __entry->root_obj = bi->root->objectid;
321 __entry->ino = btrfs_ino(bi);
322 __entry->isize = bi->vfs_inode.i_size;
323 __entry->disk_isize = bi->disk_i_size;
324 __entry->extent_type = btrfs_file_extent_type(l, fi);
325 __entry->compression = btrfs_file_extent_compression(l, fi);
326 __entry->extent_start = start;
327 __entry->extent_end = (start + btrfs_file_extent_inline_len(l, slot, fi));
331 "root=%llu(%s) inode=%llu size=%llu disk_isize=%llu "
332 "file extent range=[%llu %llu] "
333 "extent_type=%s compression=%u",
334 show_root_type(__entry->root_obj), __entry->ino, __entry->isize,
335 __entry->disk_isize, __entry->extent_start,
336 __entry->extent_end, show_fi_type(__entry->extent_type),
337 __entry->compression)
341 btrfs__file_extent_item_regular, btrfs_get_extent_show_fi_regular,
343 TP_PROTO(struct btrfs_inode *bi, struct extent_buffer *l,
344 struct btrfs_file_extent_item *fi, u64 start),
346 TP_ARGS(bi, l, fi, start)
350 btrfs__file_extent_item_regular, btrfs_truncate_show_fi_regular,
352 TP_PROTO(struct btrfs_inode *bi, struct extent_buffer *l,
353 struct btrfs_file_extent_item *fi, u64 start),
355 TP_ARGS(bi, l, fi, start)
359 btrfs__file_extent_item_inline, btrfs_get_extent_show_fi_inline,
361 TP_PROTO(struct btrfs_inode *bi, struct extent_buffer *l,
362 struct btrfs_file_extent_item *fi, int slot, u64 start),
364 TP_ARGS(bi, l, fi, slot, start)
368 btrfs__file_extent_item_inline, btrfs_truncate_show_fi_inline,
370 TP_PROTO(struct btrfs_inode *bi, struct extent_buffer *l,
371 struct btrfs_file_extent_item *fi, int slot, u64 start),
373 TP_ARGS(bi, l, fi, slot, start)
376 #define show_ordered_flags(flags) \
377 __print_flags(flags, "|", \
378 { (1 << BTRFS_ORDERED_IO_DONE), "IO_DONE" }, \
379 { (1 << BTRFS_ORDERED_COMPLETE), "COMPLETE" }, \
380 { (1 << BTRFS_ORDERED_NOCOW), "NOCOW" }, \
381 { (1 << BTRFS_ORDERED_COMPRESSED), "COMPRESSED" }, \
382 { (1 << BTRFS_ORDERED_PREALLOC), "PREALLOC" }, \
383 { (1 << BTRFS_ORDERED_DIRECT), "DIRECT" }, \
384 { (1 << BTRFS_ORDERED_IOERR), "IOERR" }, \
385 { (1 << BTRFS_ORDERED_UPDATED_ISIZE), "UPDATED_ISIZE" }, \
386 { (1 << BTRFS_ORDERED_LOGGED_CSUM), "LOGGED_CSUM" }, \
387 { (1 << BTRFS_ORDERED_TRUNCATED), "TRUNCATED" })
390 DECLARE_EVENT_CLASS(btrfs__ordered_extent,
392 TP_PROTO(const struct inode *inode,
393 const struct btrfs_ordered_extent *ordered),
395 TP_ARGS(inode, ordered),
397 TP_STRUCT__entry_btrfs(
398 __field( ino_t, ino )
399 __field( u64, file_offset )
400 __field( u64, start )
402 __field( u64, disk_len )
403 __field( u64, bytes_left )
404 __field( unsigned long, flags )
405 __field( int, compress_type )
407 __field( u64, root_objectid )
408 __field( u64, truncated_len )
411 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
412 __entry->ino = inode->i_ino;
413 __entry->file_offset = ordered->file_offset;
414 __entry->start = ordered->start;
415 __entry->len = ordered->len;
416 __entry->disk_len = ordered->disk_len;
417 __entry->bytes_left = ordered->bytes_left;
418 __entry->flags = ordered->flags;
419 __entry->compress_type = ordered->compress_type;
420 __entry->refs = refcount_read(&ordered->refs);
421 __entry->root_objectid =
422 BTRFS_I(inode)->root->root_key.objectid;
423 __entry->truncated_len = ordered->truncated_len;
426 TP_printk_btrfs("root=%llu(%s) ino=%llu file_offset=%llu "
427 "start=%llu len=%llu disk_len=%llu "
428 "truncated_len=%llu "
429 "bytes_left=%llu flags=%s compress_type=%d "
431 show_root_type(__entry->root_objectid),
432 (unsigned long long)__entry->ino,
433 (unsigned long long)__entry->file_offset,
434 (unsigned long long)__entry->start,
435 (unsigned long long)__entry->len,
436 (unsigned long long)__entry->disk_len,
437 (unsigned long long)__entry->truncated_len,
438 (unsigned long long)__entry->bytes_left,
439 show_ordered_flags(__entry->flags),
440 __entry->compress_type, __entry->refs)
443 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
445 TP_PROTO(const struct inode *inode,
446 const struct btrfs_ordered_extent *ordered),
448 TP_ARGS(inode, ordered)
451 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
453 TP_PROTO(const struct inode *inode,
454 const struct btrfs_ordered_extent *ordered),
456 TP_ARGS(inode, ordered)
459 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
461 TP_PROTO(const struct inode *inode,
462 const struct btrfs_ordered_extent *ordered),
464 TP_ARGS(inode, ordered)
467 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
469 TP_PROTO(const struct inode *inode,
470 const struct btrfs_ordered_extent *ordered),
472 TP_ARGS(inode, ordered)
475 DECLARE_EVENT_CLASS(btrfs__writepage,
477 TP_PROTO(const struct page *page, const struct inode *inode,
478 const struct writeback_control *wbc),
480 TP_ARGS(page, inode, wbc),
482 TP_STRUCT__entry_btrfs(
483 __field( ino_t, ino )
484 __field( pgoff_t, index )
485 __field( long, nr_to_write )
486 __field( long, pages_skipped )
487 __field( loff_t, range_start )
488 __field( loff_t, range_end )
489 __field( char, for_kupdate )
490 __field( char, for_reclaim )
491 __field( char, range_cyclic )
492 __field( pgoff_t, writeback_index )
493 __field( u64, root_objectid )
496 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
497 __entry->ino = inode->i_ino;
498 __entry->index = page->index;
499 __entry->nr_to_write = wbc->nr_to_write;
500 __entry->pages_skipped = wbc->pages_skipped;
501 __entry->range_start = wbc->range_start;
502 __entry->range_end = wbc->range_end;
503 __entry->for_kupdate = wbc->for_kupdate;
504 __entry->for_reclaim = wbc->for_reclaim;
505 __entry->range_cyclic = wbc->range_cyclic;
506 __entry->writeback_index = inode->i_mapping->writeback_index;
507 __entry->root_objectid =
508 BTRFS_I(inode)->root->root_key.objectid;
511 TP_printk_btrfs("root=%llu(%s) ino=%lu page_index=%lu "
512 "nr_to_write=%ld pages_skipped=%ld range_start=%llu "
513 "range_end=%llu for_kupdate=%d "
514 "for_reclaim=%d range_cyclic=%d writeback_index=%lu",
515 show_root_type(__entry->root_objectid),
516 (unsigned long)__entry->ino, __entry->index,
517 __entry->nr_to_write, __entry->pages_skipped,
518 __entry->range_start, __entry->range_end,
519 __entry->for_kupdate,
520 __entry->for_reclaim, __entry->range_cyclic,
521 (unsigned long)__entry->writeback_index)
524 DEFINE_EVENT(btrfs__writepage, __extent_writepage,
526 TP_PROTO(const struct page *page, const struct inode *inode,
527 const struct writeback_control *wbc),
529 TP_ARGS(page, inode, wbc)
532 TRACE_EVENT(btrfs_writepage_end_io_hook,
534 TP_PROTO(const struct page *page, u64 start, u64 end, int uptodate),
536 TP_ARGS(page, start, end, uptodate),
538 TP_STRUCT__entry_btrfs(
539 __field( ino_t, ino )
540 __field( pgoff_t, index )
541 __field( u64, start )
543 __field( int, uptodate )
544 __field( u64, root_objectid )
547 TP_fast_assign_btrfs(btrfs_sb(page->mapping->host->i_sb),
548 __entry->ino = page->mapping->host->i_ino;
549 __entry->index = page->index;
550 __entry->start = start;
552 __entry->uptodate = uptodate;
553 __entry->root_objectid =
554 BTRFS_I(page->mapping->host)->root->root_key.objectid;
557 TP_printk_btrfs("root=%llu(%s) ino=%lu page_index=%lu start=%llu "
558 "end=%llu uptodate=%d",
559 show_root_type(__entry->root_objectid),
560 (unsigned long)__entry->ino, (unsigned long)__entry->index,
561 (unsigned long long)__entry->start,
562 (unsigned long long)__entry->end, __entry->uptodate)
565 TRACE_EVENT(btrfs_sync_file,
567 TP_PROTO(const struct file *file, int datasync),
569 TP_ARGS(file, datasync),
571 TP_STRUCT__entry_btrfs(
572 __field( ino_t, ino )
573 __field( ino_t, parent )
574 __field( int, datasync )
575 __field( u64, root_objectid )
579 const struct dentry *dentry = file->f_path.dentry;
580 const struct inode *inode = d_inode(dentry);
582 TP_fast_assign_fsid(btrfs_sb(file->f_path.dentry->d_sb));
583 __entry->ino = inode->i_ino;
584 __entry->parent = d_inode(dentry->d_parent)->i_ino;
585 __entry->datasync = datasync;
586 __entry->root_objectid =
587 BTRFS_I(inode)->root->root_key.objectid;
590 TP_printk_btrfs("root=%llu(%s) ino=%ld parent=%ld datasync=%d",
591 show_root_type(__entry->root_objectid),
592 (unsigned long)__entry->ino, (unsigned long)__entry->parent,
596 TRACE_EVENT(btrfs_sync_fs,
598 TP_PROTO(const struct btrfs_fs_info *fs_info, int wait),
600 TP_ARGS(fs_info, wait),
602 TP_STRUCT__entry_btrfs(
606 TP_fast_assign_btrfs(fs_info,
607 __entry->wait = wait;
610 TP_printk_btrfs("wait = %d", __entry->wait)
613 TRACE_EVENT(btrfs_add_block_group,
615 TP_PROTO(const struct btrfs_fs_info *fs_info,
616 const struct btrfs_block_group_cache *block_group, int create),
618 TP_ARGS(fs_info, block_group, create),
621 __array( u8, fsid, BTRFS_FSID_SIZE )
622 __field( u64, offset )
624 __field( u64, flags )
625 __field( u64, bytes_used )
626 __field( u64, bytes_super )
627 __field( int, create )
631 memcpy(__entry->fsid, fs_info->fsid, BTRFS_FSID_SIZE);
632 __entry->offset = block_group->key.objectid;
633 __entry->size = block_group->key.offset;
634 __entry->flags = block_group->flags;
635 __entry->bytes_used =
636 btrfs_block_group_used(&block_group->item);
637 __entry->bytes_super = block_group->bytes_super;
638 __entry->create = create;
641 TP_printk("%pU: block_group offset=%llu size=%llu "
642 "flags=%llu(%s) bytes_used=%llu bytes_super=%llu "
643 "create=%d", __entry->fsid,
644 (unsigned long long)__entry->offset,
645 (unsigned long long)__entry->size,
646 (unsigned long long)__entry->flags,
647 __print_flags((unsigned long)__entry->flags, "|",
649 (unsigned long long)__entry->bytes_used,
650 (unsigned long long)__entry->bytes_super, __entry->create)
653 #define show_ref_action(action) \
654 __print_symbolic(action, \
655 { BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \
656 { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \
657 { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \
658 { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
661 DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,
663 TP_PROTO(const struct btrfs_fs_info *fs_info,
664 const struct btrfs_delayed_ref_node *ref,
665 const struct btrfs_delayed_tree_ref *full_ref,
668 TP_ARGS(fs_info, ref, full_ref, action),
670 TP_STRUCT__entry_btrfs(
671 __field( u64, bytenr )
672 __field( u64, num_bytes )
673 __field( int, action )
674 __field( u64, parent )
675 __field( u64, ref_root )
676 __field( int, level )
681 TP_fast_assign_btrfs(fs_info,
682 __entry->bytenr = ref->bytenr;
683 __entry->num_bytes = ref->num_bytes;
684 __entry->action = action;
685 __entry->parent = full_ref->parent;
686 __entry->ref_root = full_ref->root;
687 __entry->level = full_ref->level;
688 __entry->type = ref->type;
689 __entry->seq = ref->seq;
692 TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s "
693 "parent=%llu(%s) ref_root=%llu(%s) level=%d "
695 (unsigned long long)__entry->bytenr,
696 (unsigned long long)__entry->num_bytes,
697 show_ref_action(__entry->action),
698 show_root_type(__entry->parent),
699 show_root_type(__entry->ref_root),
700 __entry->level, show_ref_type(__entry->type),
701 (unsigned long long)__entry->seq)
704 DEFINE_EVENT(btrfs_delayed_tree_ref, add_delayed_tree_ref,
706 TP_PROTO(const struct btrfs_fs_info *fs_info,
707 const struct btrfs_delayed_ref_node *ref,
708 const struct btrfs_delayed_tree_ref *full_ref,
711 TP_ARGS(fs_info, ref, full_ref, action)
714 DEFINE_EVENT(btrfs_delayed_tree_ref, run_delayed_tree_ref,
716 TP_PROTO(const struct btrfs_fs_info *fs_info,
717 const struct btrfs_delayed_ref_node *ref,
718 const struct btrfs_delayed_tree_ref *full_ref,
721 TP_ARGS(fs_info, ref, full_ref, action)
724 DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,
726 TP_PROTO(const struct btrfs_fs_info *fs_info,
727 const struct btrfs_delayed_ref_node *ref,
728 const struct btrfs_delayed_data_ref *full_ref,
731 TP_ARGS(fs_info, ref, full_ref, action),
733 TP_STRUCT__entry_btrfs(
734 __field( u64, bytenr )
735 __field( u64, num_bytes )
736 __field( int, action )
737 __field( u64, parent )
738 __field( u64, ref_root )
739 __field( u64, owner )
740 __field( u64, offset )
745 TP_fast_assign_btrfs(fs_info,
746 __entry->bytenr = ref->bytenr;
747 __entry->num_bytes = ref->num_bytes;
748 __entry->action = action;
749 __entry->parent = full_ref->parent;
750 __entry->ref_root = full_ref->root;
751 __entry->owner = full_ref->objectid;
752 __entry->offset = full_ref->offset;
753 __entry->type = ref->type;
754 __entry->seq = ref->seq;
757 TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s "
758 "parent=%llu(%s) ref_root=%llu(%s) owner=%llu "
759 "offset=%llu type=%s seq=%llu",
760 (unsigned long long)__entry->bytenr,
761 (unsigned long long)__entry->num_bytes,
762 show_ref_action(__entry->action),
763 show_root_type(__entry->parent),
764 show_root_type(__entry->ref_root),
765 (unsigned long long)__entry->owner,
766 (unsigned long long)__entry->offset,
767 show_ref_type(__entry->type),
768 (unsigned long long)__entry->seq)
771 DEFINE_EVENT(btrfs_delayed_data_ref, add_delayed_data_ref,
773 TP_PROTO(const struct btrfs_fs_info *fs_info,
774 const struct btrfs_delayed_ref_node *ref,
775 const struct btrfs_delayed_data_ref *full_ref,
778 TP_ARGS(fs_info, ref, full_ref, action)
781 DEFINE_EVENT(btrfs_delayed_data_ref, run_delayed_data_ref,
783 TP_PROTO(const struct btrfs_fs_info *fs_info,
784 const struct btrfs_delayed_ref_node *ref,
785 const struct btrfs_delayed_data_ref *full_ref,
788 TP_ARGS(fs_info, ref, full_ref, action)
791 DECLARE_EVENT_CLASS(btrfs_delayed_ref_head,
793 TP_PROTO(const struct btrfs_fs_info *fs_info,
794 const struct btrfs_delayed_ref_node *ref,
795 const struct btrfs_delayed_ref_head *head_ref,
798 TP_ARGS(fs_info, ref, head_ref, action),
800 TP_STRUCT__entry_btrfs(
801 __field( u64, bytenr )
802 __field( u64, num_bytes )
803 __field( int, action )
804 __field( int, is_data )
807 TP_fast_assign_btrfs(fs_info,
808 __entry->bytenr = ref->bytenr;
809 __entry->num_bytes = ref->num_bytes;
810 __entry->action = action;
811 __entry->is_data = head_ref->is_data;
814 TP_printk_btrfs("bytenr=%llu num_bytes=%llu action=%s is_data=%d",
815 (unsigned long long)__entry->bytenr,
816 (unsigned long long)__entry->num_bytes,
817 show_ref_action(__entry->action),
821 DEFINE_EVENT(btrfs_delayed_ref_head, add_delayed_ref_head,
823 TP_PROTO(const struct btrfs_fs_info *fs_info,
824 const struct btrfs_delayed_ref_node *ref,
825 const struct btrfs_delayed_ref_head *head_ref,
828 TP_ARGS(fs_info, ref, head_ref, action)
831 DEFINE_EVENT(btrfs_delayed_ref_head, run_delayed_ref_head,
833 TP_PROTO(const struct btrfs_fs_info *fs_info,
834 const struct btrfs_delayed_ref_node *ref,
835 const struct btrfs_delayed_ref_head *head_ref,
838 TP_ARGS(fs_info, ref, head_ref, action)
841 #define show_chunk_type(type) \
842 __print_flags(type, "|", \
843 { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
844 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
845 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
846 { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
847 { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
848 { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
849 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
850 { BTRFS_BLOCK_GROUP_RAID5, "RAID5" }, \
851 { BTRFS_BLOCK_GROUP_RAID6, "RAID6" })
853 DECLARE_EVENT_CLASS(btrfs__chunk,
855 TP_PROTO(const struct btrfs_fs_info *fs_info,
856 const struct map_lookup *map, u64 offset, u64 size),
858 TP_ARGS(fs_info, map, offset, size),
860 TP_STRUCT__entry_btrfs(
861 __field( int, num_stripes )
863 __field( int, sub_stripes )
864 __field( u64, offset )
866 __field( u64, root_objectid )
869 TP_fast_assign_btrfs(fs_info,
870 __entry->num_stripes = map->num_stripes;
871 __entry->type = map->type;
872 __entry->sub_stripes = map->sub_stripes;
873 __entry->offset = offset;
874 __entry->size = size;
875 __entry->root_objectid = fs_info->chunk_root->root_key.objectid;
878 TP_printk_btrfs("root=%llu(%s) offset=%llu size=%llu "
879 "num_stripes=%d sub_stripes=%d type=%s",
880 show_root_type(__entry->root_objectid),
881 (unsigned long long)__entry->offset,
882 (unsigned long long)__entry->size,
883 __entry->num_stripes, __entry->sub_stripes,
884 show_chunk_type(__entry->type))
887 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
889 TP_PROTO(const struct btrfs_fs_info *fs_info,
890 const struct map_lookup *map, u64 offset, u64 size),
892 TP_ARGS(fs_info, map, offset, size)
895 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
897 TP_PROTO(const struct btrfs_fs_info *fs_info,
898 const struct map_lookup *map, u64 offset, u64 size),
900 TP_ARGS(fs_info, map, offset, size)
903 TRACE_EVENT(btrfs_cow_block,
905 TP_PROTO(const struct btrfs_root *root, const struct extent_buffer *buf,
906 const struct extent_buffer *cow),
908 TP_ARGS(root, buf, cow),
910 TP_STRUCT__entry_btrfs(
911 __field( u64, root_objectid )
912 __field( u64, buf_start )
914 __field( u64, cow_start )
915 __field( int, buf_level )
916 __field( int, cow_level )
919 TP_fast_assign_btrfs(root->fs_info,
920 __entry->root_objectid = root->root_key.objectid;
921 __entry->buf_start = buf->start;
922 __entry->refs = atomic_read(&buf->refs);
923 __entry->cow_start = cow->start;
924 __entry->buf_level = btrfs_header_level(buf);
925 __entry->cow_level = btrfs_header_level(cow);
928 TP_printk_btrfs("root=%llu(%s) refs=%d orig_buf=%llu "
929 "(orig_level=%d) cow_buf=%llu (cow_level=%d)",
930 show_root_type(__entry->root_objectid),
932 (unsigned long long)__entry->buf_start,
934 (unsigned long long)__entry->cow_start,
938 TRACE_EVENT(btrfs_space_reservation,
940 TP_PROTO(const struct btrfs_fs_info *fs_info, char *type, u64 val,
941 u64 bytes, int reserve),
943 TP_ARGS(fs_info, type, val, bytes, reserve),
945 TP_STRUCT__entry_btrfs(
946 __string( type, type )
948 __field( u64, bytes )
949 __field( int, reserve )
952 TP_fast_assign_btrfs(fs_info,
953 __assign_str(type, type);
955 __entry->bytes = bytes;
956 __entry->reserve = reserve;
959 TP_printk_btrfs("%s: %Lu %s %Lu", __get_str(type), __entry->val,
960 __entry->reserve ? "reserve" : "release",
964 #define show_flush_action(action) \
965 __print_symbolic(action, \
966 { BTRFS_RESERVE_NO_FLUSH, "BTRFS_RESERVE_NO_FLUSH"}, \
967 { BTRFS_RESERVE_FLUSH_LIMIT, "BTRFS_RESERVE_FLUSH_LIMIT"}, \
968 { BTRFS_RESERVE_FLUSH_ALL, "BTRFS_RESERVE_FLUSH_ALL"})
970 TRACE_EVENT(btrfs_trigger_flush,
972 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,
973 int flush, char *reason),
975 TP_ARGS(fs_info, flags, bytes, flush, reason),
978 __array( u8, fsid, BTRFS_FSID_SIZE )
979 __field( u64, flags )
980 __field( u64, bytes )
981 __field( int, flush )
982 __string( reason, reason )
986 memcpy(__entry->fsid, fs_info->fsid, BTRFS_FSID_SIZE);
987 __entry->flags = flags;
988 __entry->bytes = bytes;
989 __entry->flush = flush;
990 __assign_str(reason, reason)
993 TP_printk("%pU: %s: flush=%d(%s) flags=%llu(%s) bytes=%llu",
994 __entry->fsid, __get_str(reason), __entry->flush,
995 show_flush_action(__entry->flush),
996 (unsigned long long)__entry->flags,
997 __print_flags((unsigned long)__entry->flags, "|",
999 (unsigned long long)__entry->bytes)
1002 #define show_flush_state(state) \
1003 __print_symbolic(state, \
1004 { FLUSH_DELAYED_ITEMS_NR, "FLUSH_DELAYED_ITEMS_NR"}, \
1005 { FLUSH_DELAYED_ITEMS, "FLUSH_DELAYED_ITEMS"}, \
1006 { FLUSH_DELALLOC, "FLUSH_DELALLOC"}, \
1007 { FLUSH_DELALLOC_WAIT, "FLUSH_DELALLOC_WAIT"}, \
1008 { ALLOC_CHUNK, "ALLOC_CHUNK"}, \
1009 { COMMIT_TRANS, "COMMIT_TRANS"})
1011 TRACE_EVENT(btrfs_flush_space,
1013 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,
1014 int state, int ret),
1016 TP_ARGS(fs_info, flags, num_bytes, state, ret),
1019 __array( u8, fsid, BTRFS_FSID_SIZE )
1020 __field( u64, flags )
1021 __field( u64, num_bytes )
1022 __field( int, state )
1027 memcpy(__entry->fsid, fs_info->fsid, BTRFS_FSID_SIZE);
1028 __entry->flags = flags;
1029 __entry->num_bytes = num_bytes;
1030 __entry->state = state;
1034 TP_printk("%pU: state=%d(%s) flags=%llu(%s) num_bytes=%llu ret=%d",
1035 __entry->fsid, __entry->state,
1036 show_flush_state(__entry->state),
1037 (unsigned long long)__entry->flags,
1038 __print_flags((unsigned long)__entry->flags, "|",
1040 (unsigned long long)__entry->num_bytes, __entry->ret)
1043 DECLARE_EVENT_CLASS(btrfs__reserved_extent,
1045 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
1047 TP_ARGS(fs_info, start, len),
1049 TP_STRUCT__entry_btrfs(
1050 __field( u64, start )
1054 TP_fast_assign_btrfs(fs_info,
1055 __entry->start = start;
1059 TP_printk_btrfs("root=%llu(%s) start=%llu len=%llu",
1060 show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
1061 (unsigned long long)__entry->start,
1062 (unsigned long long)__entry->len)
1065 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
1067 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
1069 TP_ARGS(fs_info, start, len)
1072 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
1074 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 start, u64 len),
1076 TP_ARGS(fs_info, start, len)
1079 TRACE_EVENT(find_free_extent,
1081 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 num_bytes,
1082 u64 empty_size, u64 data),
1084 TP_ARGS(fs_info, num_bytes, empty_size, data),
1086 TP_STRUCT__entry_btrfs(
1087 __field( u64, num_bytes )
1088 __field( u64, empty_size )
1089 __field( u64, data )
1092 TP_fast_assign_btrfs(fs_info,
1093 __entry->num_bytes = num_bytes;
1094 __entry->empty_size = empty_size;
1095 __entry->data = data;
1098 TP_printk_btrfs("root=%Lu(%s) len=%Lu empty_size=%Lu flags=%Lu(%s)",
1099 show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
1100 __entry->num_bytes, __entry->empty_size, __entry->data,
1101 __print_flags((unsigned long)__entry->data, "|",
1105 DECLARE_EVENT_CLASS(btrfs__reserve_extent,
1107 TP_PROTO(const struct btrfs_fs_info *fs_info,
1108 const struct btrfs_block_group_cache *block_group, u64 start,
1111 TP_ARGS(fs_info, block_group, start, len),
1113 TP_STRUCT__entry_btrfs(
1114 __field( u64, bg_objectid )
1115 __field( u64, flags )
1116 __field( u64, start )
1120 TP_fast_assign_btrfs(fs_info,
1121 __entry->bg_objectid = block_group->key.objectid;
1122 __entry->flags = block_group->flags;
1123 __entry->start = start;
1127 TP_printk_btrfs("root=%Lu(%s) block_group=%Lu flags=%Lu(%s) "
1128 "start=%Lu len=%Lu",
1129 show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
1130 __entry->bg_objectid,
1131 __entry->flags, __print_flags((unsigned long)__entry->flags,
1132 "|", BTRFS_GROUP_FLAGS),
1133 __entry->start, __entry->len)
1136 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
1138 TP_PROTO(const struct btrfs_fs_info *fs_info,
1139 const struct btrfs_block_group_cache *block_group, u64 start,
1142 TP_ARGS(fs_info, block_group, start, len)
1145 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
1147 TP_PROTO(const struct btrfs_fs_info *fs_info,
1148 const struct btrfs_block_group_cache *block_group, u64 start,
1151 TP_ARGS(fs_info, block_group, start, len)
1154 TRACE_EVENT(btrfs_find_cluster,
1156 TP_PROTO(const struct btrfs_block_group_cache *block_group, u64 start,
1157 u64 bytes, u64 empty_size, u64 min_bytes),
1159 TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
1161 TP_STRUCT__entry_btrfs(
1162 __field( u64, bg_objectid )
1163 __field( u64, flags )
1164 __field( u64, start )
1165 __field( u64, bytes )
1166 __field( u64, empty_size )
1167 __field( u64, min_bytes )
1170 TP_fast_assign_btrfs(block_group->fs_info,
1171 __entry->bg_objectid = block_group->key.objectid;
1172 __entry->flags = block_group->flags;
1173 __entry->start = start;
1174 __entry->bytes = bytes;
1175 __entry->empty_size = empty_size;
1176 __entry->min_bytes = min_bytes;
1179 TP_printk_btrfs("block_group=%Lu flags=%Lu(%s) start=%Lu len=%Lu "
1180 "empty_size=%Lu min_bytes=%Lu", __entry->bg_objectid,
1182 __print_flags((unsigned long)__entry->flags, "|",
1183 BTRFS_GROUP_FLAGS), __entry->start,
1184 __entry->bytes, __entry->empty_size, __entry->min_bytes)
1187 TRACE_EVENT(btrfs_failed_cluster_setup,
1189 TP_PROTO(const struct btrfs_block_group_cache *block_group),
1191 TP_ARGS(block_group),
1193 TP_STRUCT__entry_btrfs(
1194 __field( u64, bg_objectid )
1197 TP_fast_assign_btrfs(block_group->fs_info,
1198 __entry->bg_objectid = block_group->key.objectid;
1201 TP_printk_btrfs("block_group=%Lu", __entry->bg_objectid)
1204 TRACE_EVENT(btrfs_setup_cluster,
1206 TP_PROTO(const struct btrfs_block_group_cache *block_group,
1207 const struct btrfs_free_cluster *cluster,
1208 u64 size, int bitmap),
1210 TP_ARGS(block_group, cluster, size, bitmap),
1212 TP_STRUCT__entry_btrfs(
1213 __field( u64, bg_objectid )
1214 __field( u64, flags )
1215 __field( u64, start )
1216 __field( u64, max_size )
1217 __field( u64, size )
1218 __field( int, bitmap )
1221 TP_fast_assign_btrfs(block_group->fs_info,
1222 __entry->bg_objectid = block_group->key.objectid;
1223 __entry->flags = block_group->flags;
1224 __entry->start = cluster->window_start;
1225 __entry->max_size = cluster->max_size;
1226 __entry->size = size;
1227 __entry->bitmap = bitmap;
1230 TP_printk_btrfs("block_group=%Lu flags=%Lu(%s) window_start=%Lu "
1231 "size=%Lu max_size=%Lu bitmap=%d",
1232 __entry->bg_objectid,
1234 __print_flags((unsigned long)__entry->flags, "|",
1235 BTRFS_GROUP_FLAGS), __entry->start,
1236 __entry->size, __entry->max_size, __entry->bitmap)
1239 struct extent_state;
1240 TRACE_EVENT(alloc_extent_state,
1242 TP_PROTO(const struct extent_state *state,
1243 gfp_t mask, unsigned long IP),
1245 TP_ARGS(state, mask, IP),
1248 __field(const struct extent_state *, state)
1249 __field(gfp_t, mask)
1250 __field(unsigned long, ip)
1254 __entry->state = state,
1255 __entry->mask = mask,
1259 TP_printk("state=%p mask=%s caller=%pS", __entry->state,
1260 show_gfp_flags(__entry->mask), (const void *)__entry->ip)
1263 TRACE_EVENT(free_extent_state,
1265 TP_PROTO(const struct extent_state *state, unsigned long IP),
1270 __field(const struct extent_state *, state)
1271 __field(unsigned long, ip)
1275 __entry->state = state,
1279 TP_printk("state=%p caller=%pS", __entry->state,
1280 (const void *)__entry->ip)
1283 DECLARE_EVENT_CLASS(btrfs__work,
1285 TP_PROTO(const struct btrfs_work *work),
1289 TP_STRUCT__entry_btrfs(
1290 __field( const void *, work )
1291 __field( const void *, wq )
1292 __field( const void *, func )
1293 __field( const void *, ordered_func )
1294 __field( const void *, ordered_free )
1295 __field( const void *, normal_work )
1298 TP_fast_assign_btrfs(btrfs_work_owner(work),
1299 __entry->work = work;
1300 __entry->wq = work->wq;
1301 __entry->func = work->func;
1302 __entry->ordered_func = work->ordered_func;
1303 __entry->ordered_free = work->ordered_free;
1304 __entry->normal_work = &work->normal_work;
1307 TP_printk_btrfs("work=%p (normal_work=%p) wq=%p func=%pf ordered_func=%p "
1309 __entry->work, __entry->normal_work, __entry->wq,
1310 __entry->func, __entry->ordered_func, __entry->ordered_free)
1314 * For situiations when the work is freed, we pass fs_info and a tag that that
1315 * matches address of the work structure so it can be paired with the
1318 DECLARE_EVENT_CLASS(btrfs__work__done,
1320 TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag),
1322 TP_ARGS(fs_info, wtag),
1324 TP_STRUCT__entry_btrfs(
1325 __field( const void *, wtag )
1328 TP_fast_assign_btrfs(fs_info,
1329 __entry->wtag = wtag;
1332 TP_printk_btrfs("work->%p", __entry->wtag)
1335 DEFINE_EVENT(btrfs__work, btrfs_work_queued,
1337 TP_PROTO(const struct btrfs_work *work),
1342 DEFINE_EVENT(btrfs__work, btrfs_work_sched,
1344 TP_PROTO(const struct btrfs_work *work),
1349 DEFINE_EVENT(btrfs__work__done, btrfs_all_work_done,
1351 TP_PROTO(const struct btrfs_fs_info *fs_info, const void *wtag),
1353 TP_ARGS(fs_info, wtag)
1356 DEFINE_EVENT(btrfs__work, btrfs_ordered_sched,
1358 TP_PROTO(const struct btrfs_work *work),
1363 DECLARE_EVENT_CLASS(btrfs__workqueue,
1365 TP_PROTO(const struct __btrfs_workqueue *wq,
1366 const char *name, int high),
1368 TP_ARGS(wq, name, high),
1370 TP_STRUCT__entry_btrfs(
1371 __field( const void *, wq )
1372 __string( name, name )
1373 __field( int , high )
1376 TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
1378 __assign_str(name, name);
1379 __entry->high = high;
1382 TP_printk_btrfs("name=%s%s wq=%p", __get_str(name),
1383 __print_flags(__entry->high, "",
1384 {(WQ_HIGHPRI), "-high"}),
1388 DEFINE_EVENT(btrfs__workqueue, btrfs_workqueue_alloc,
1390 TP_PROTO(const struct __btrfs_workqueue *wq,
1391 const char *name, int high),
1393 TP_ARGS(wq, name, high)
1396 DECLARE_EVENT_CLASS(btrfs__workqueue_done,
1398 TP_PROTO(const struct __btrfs_workqueue *wq),
1402 TP_STRUCT__entry_btrfs(
1403 __field( const void *, wq )
1406 TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
1410 TP_printk_btrfs("wq=%p", __entry->wq)
1413 DEFINE_EVENT(btrfs__workqueue_done, btrfs_workqueue_destroy,
1415 TP_PROTO(const struct __btrfs_workqueue *wq),
1420 #define BTRFS_QGROUP_OPERATIONS \
1421 { QGROUP_RESERVE, "reserve" }, \
1422 { QGROUP_RELEASE, "release" }, \
1423 { QGROUP_FREE, "free" }
1425 DECLARE_EVENT_CLASS(btrfs__qgroup_rsv_data,
1427 TP_PROTO(const struct inode *inode, u64 start, u64 len,
1428 u64 reserved, int op),
1430 TP_ARGS(inode, start, len, reserved, op),
1432 TP_STRUCT__entry_btrfs(
1433 __field( u64, rootid )
1434 __field( unsigned long, ino )
1435 __field( u64, start )
1437 __field( u64, reserved )
1441 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
1442 __entry->rootid = BTRFS_I(inode)->root->objectid;
1443 __entry->ino = inode->i_ino;
1444 __entry->start = start;
1446 __entry->reserved = reserved;
1450 TP_printk_btrfs("root=%llu ino=%lu start=%llu len=%llu reserved=%llu op=%s",
1451 __entry->rootid, __entry->ino, __entry->start, __entry->len,
1453 __print_flags((unsigned long)__entry->op, "",
1454 BTRFS_QGROUP_OPERATIONS)
1458 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_reserve_data,
1460 TP_PROTO(const struct inode *inode, u64 start, u64 len,
1461 u64 reserved, int op),
1463 TP_ARGS(inode, start, len, reserved, op)
1466 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_release_data,
1468 TP_PROTO(const struct inode *inode, u64 start, u64 len,
1469 u64 reserved, int op),
1471 TP_ARGS(inode, start, len, reserved, op)
1474 DECLARE_EVENT_CLASS(btrfs__qgroup_delayed_ref,
1476 TP_PROTO(const struct btrfs_fs_info *fs_info,
1477 u64 ref_root, u64 reserved),
1479 TP_ARGS(fs_info, ref_root, reserved),
1481 TP_STRUCT__entry_btrfs(
1482 __field( u64, ref_root )
1483 __field( u64, reserved )
1486 TP_fast_assign_btrfs(fs_info,
1487 __entry->ref_root = ref_root;
1488 __entry->reserved = reserved;
1491 TP_printk_btrfs("root=%llu reserved=%llu op=free",
1492 __entry->ref_root, __entry->reserved)
1495 DEFINE_EVENT(btrfs__qgroup_delayed_ref, btrfs_qgroup_free_delayed_ref,
1497 TP_PROTO(const struct btrfs_fs_info *fs_info,
1498 u64 ref_root, u64 reserved),
1500 TP_ARGS(fs_info, ref_root, reserved)
1503 DECLARE_EVENT_CLASS(btrfs_qgroup_extent,
1504 TP_PROTO(const struct btrfs_fs_info *fs_info,
1505 const struct btrfs_qgroup_extent_record *rec),
1507 TP_ARGS(fs_info, rec),
1509 TP_STRUCT__entry_btrfs(
1510 __field( u64, bytenr )
1511 __field( u64, num_bytes )
1514 TP_fast_assign_btrfs(fs_info,
1515 __entry->bytenr = rec->bytenr,
1516 __entry->num_bytes = rec->num_bytes;
1519 TP_printk_btrfs("bytenr=%llu num_bytes=%llu",
1520 (unsigned long long)__entry->bytenr,
1521 (unsigned long long)__entry->num_bytes)
1524 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_account_extents,
1526 TP_PROTO(const struct btrfs_fs_info *fs_info,
1527 const struct btrfs_qgroup_extent_record *rec),
1529 TP_ARGS(fs_info, rec)
1532 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_trace_extent,
1534 TP_PROTO(const struct btrfs_fs_info *fs_info,
1535 const struct btrfs_qgroup_extent_record *rec),
1537 TP_ARGS(fs_info, rec)
1540 TRACE_EVENT(btrfs_qgroup_account_extent,
1542 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 bytenr,
1543 u64 num_bytes, u64 nr_old_roots, u64 nr_new_roots),
1545 TP_ARGS(fs_info, bytenr, num_bytes, nr_old_roots, nr_new_roots),
1547 TP_STRUCT__entry_btrfs(
1548 __field( u64, bytenr )
1549 __field( u64, num_bytes )
1550 __field( u64, nr_old_roots )
1551 __field( u64, nr_new_roots )
1554 TP_fast_assign_btrfs(fs_info,
1555 __entry->bytenr = bytenr;
1556 __entry->num_bytes = num_bytes;
1557 __entry->nr_old_roots = nr_old_roots;
1558 __entry->nr_new_roots = nr_new_roots;
1561 TP_printk_btrfs("bytenr=%llu num_bytes=%llu nr_old_roots=%llu "
1562 "nr_new_roots=%llu",
1565 __entry->nr_old_roots,
1566 __entry->nr_new_roots)
1569 TRACE_EVENT(qgroup_update_counters,
1571 TP_PROTO(const struct btrfs_fs_info *fs_info, u64 qgid,
1572 u64 cur_old_count, u64 cur_new_count),
1574 TP_ARGS(fs_info, qgid, cur_old_count, cur_new_count),
1576 TP_STRUCT__entry_btrfs(
1577 __field( u64, qgid )
1578 __field( u64, cur_old_count )
1579 __field( u64, cur_new_count )
1582 TP_fast_assign_btrfs(fs_info,
1583 __entry->qgid = qgid;
1584 __entry->cur_old_count = cur_old_count;
1585 __entry->cur_new_count = cur_new_count;
1588 TP_printk_btrfs("qgid=%llu cur_old_count=%llu cur_new_count=%llu",
1590 __entry->cur_old_count,
1591 __entry->cur_new_count)
1594 TRACE_EVENT(qgroup_update_reserve,
1596 TP_PROTO(struct btrfs_fs_info *fs_info, struct btrfs_qgroup *qgroup,
1599 TP_ARGS(fs_info, qgroup, diff),
1601 TP_STRUCT__entry_btrfs(
1602 __field( u64, qgid )
1603 __field( u64, cur_reserved )
1604 __field( s64, diff )
1607 TP_fast_assign_btrfs(fs_info,
1608 __entry->qgid = qgroup->qgroupid;
1609 __entry->cur_reserved = qgroup->reserved;
1610 __entry->diff = diff;
1613 TP_printk_btrfs("qgid=%llu cur_reserved=%llu diff=%lld",
1614 __entry->qgid, __entry->cur_reserved, __entry->diff)
1617 TRACE_EVENT(qgroup_meta_reserve,
1619 TP_PROTO(struct btrfs_root *root, s64 diff),
1621 TP_ARGS(root, diff),
1623 TP_STRUCT__entry_btrfs(
1624 __field( u64, refroot )
1625 __field( s64, diff )
1628 TP_fast_assign_btrfs(root->fs_info,
1629 __entry->refroot = root->objectid;
1630 __entry->diff = diff;
1633 TP_printk_btrfs("refroot=%llu(%s) diff=%lld",
1634 show_root_type(__entry->refroot), __entry->diff)
1637 DECLARE_EVENT_CLASS(btrfs__prelim_ref,
1638 TP_PROTO(const struct btrfs_fs_info *fs_info,
1639 const struct prelim_ref *oldref,
1640 const struct prelim_ref *newref, u64 tree_size),
1641 TP_ARGS(fs_info, newref, oldref, tree_size),
1643 TP_STRUCT__entry_btrfs(
1644 __field( u64, root_id )
1645 __field( u64, objectid )
1647 __field( u64, offset )
1648 __field( int, level )
1649 __field( int, old_count )
1650 __field( u64, parent )
1651 __field( u64, bytenr )
1652 __field( int, mod_count )
1653 __field( u64, tree_size )
1656 TP_fast_assign_btrfs(fs_info,
1657 __entry->root_id = oldref->root_id;
1658 __entry->objectid = oldref->key_for_search.objectid;
1659 __entry->type = oldref->key_for_search.type;
1660 __entry->offset = oldref->key_for_search.offset;
1661 __entry->level = oldref->level;
1662 __entry->old_count = oldref->count;
1663 __entry->parent = oldref->parent;
1664 __entry->bytenr = oldref->wanted_disk_byte;
1665 __entry->mod_count = newref ? newref->count : 0;
1666 __entry->tree_size = tree_size;
1669 TP_printk_btrfs("root_id=%llu key=[%llu,%u,%llu] level=%d count=[%d+%d=%d] parent=%llu wanted_disk_byte=%llu nodes=%llu",
1670 (unsigned long long)__entry->root_id,
1671 (unsigned long long)__entry->objectid, __entry->type,
1672 (unsigned long long)__entry->offset, __entry->level,
1673 __entry->old_count, __entry->mod_count,
1674 __entry->old_count + __entry->mod_count,
1675 (unsigned long long)__entry->parent,
1676 (unsigned long long)__entry->bytenr,
1677 (unsigned long long)__entry->tree_size)
1680 DEFINE_EVENT(btrfs__prelim_ref, btrfs_prelim_ref_merge,
1681 TP_PROTO(const struct btrfs_fs_info *fs_info,
1682 const struct prelim_ref *oldref,
1683 const struct prelim_ref *newref, u64 tree_size),
1684 TP_ARGS(fs_info, oldref, newref, tree_size)
1687 DEFINE_EVENT(btrfs__prelim_ref, btrfs_prelim_ref_insert,
1688 TP_PROTO(const struct btrfs_fs_info *fs_info,
1689 const struct prelim_ref *oldref,
1690 const struct prelim_ref *newref, u64 tree_size),
1691 TP_ARGS(fs_info, oldref, newref, tree_size)
1694 #endif /* _TRACE_BTRFS_H */
1696 /* This part must be outside protection */
1697 #include <trace/define_trace.h>