]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - include/trace/events/btrfs.h
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
btrfs: fix crash when tracepoint arguments are freed by wq callbacks
[mirror_ubuntu-bionic-kernel.git] / include / trace / events / btrfs.h
1 #undef TRACE_SYSTEM
2 #define TRACE_SYSTEM btrfs
3
4 #if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_BTRFS_H
6
7 #include <linux/writeback.h>
8 #include <linux/tracepoint.h>
9 #include <trace/events/mmflags.h>
10
11 struct btrfs_root;
12 struct btrfs_fs_info;
13 struct btrfs_inode;
14 struct extent_map;
15 struct btrfs_ordered_extent;
16 struct btrfs_delayed_ref_node;
17 struct btrfs_delayed_tree_ref;
18 struct btrfs_delayed_data_ref;
19 struct btrfs_delayed_ref_head;
20 struct btrfs_block_group_cache;
21 struct btrfs_free_cluster;
22 struct map_lookup;
23 struct extent_buffer;
24 struct btrfs_work;
25 struct __btrfs_workqueue;
26 struct btrfs_qgroup_extent_record;
27
28 #define show_ref_type(type) \
29 __print_symbolic(type, \
30 { BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \
31 { BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \
32 { BTRFS_EXTENT_REF_V0_KEY, "EXTENT_REF_V0" }, \
33 { BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \
34 { BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" })
35
36 #define __show_root_type(obj) \
37 __print_symbolic_u64(obj, \
38 { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
39 { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
40 { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
41 { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
42 { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
43 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
44 { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
45 { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
46 { BTRFS_QUOTA_TREE_OBJECTID, "QUOTA_TREE" }, \
47 { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
48 { BTRFS_UUID_TREE_OBJECTID, "UUID_TREE" }, \
49 { BTRFS_FREE_SPACE_TREE_OBJECTID, "FREE_SPACE_TREE" }, \
50 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
51
52 #define show_root_type(obj) \
53 obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
54 (obj >= BTRFS_ROOT_TREE_OBJECTID && \
55 obj <= BTRFS_QUOTA_TREE_OBJECTID)) ? __show_root_type(obj) : "-"
56
57 #define BTRFS_GROUP_FLAGS \
58 { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
59 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
60 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
61 { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
62 { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
63 { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
64 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
65 { BTRFS_BLOCK_GROUP_RAID5, "RAID5"}, \
66 { BTRFS_BLOCK_GROUP_RAID6, "RAID6"}
67
68 #define BTRFS_UUID_SIZE 16
69 #define TP_STRUCT__entry_fsid __array(u8, fsid, BTRFS_UUID_SIZE)
70
71 #define TP_fast_assign_fsid(fs_info) \
72 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE)
73
74 #define TP_STRUCT__entry_btrfs(args...) \
75 TP_STRUCT__entry( \
76 TP_STRUCT__entry_fsid \
77 args)
78 #define TP_fast_assign_btrfs(fs_info, args...) \
79 TP_fast_assign( \
80 TP_fast_assign_fsid(fs_info); \
81 args)
82 #define TP_printk_btrfs(fmt, args...) \
83 TP_printk("%pU: " fmt, __entry->fsid, args)
84
85 TRACE_EVENT(btrfs_transaction_commit,
86
87 TP_PROTO(struct btrfs_root *root),
88
89 TP_ARGS(root),
90
91 TP_STRUCT__entry_btrfs(
92 __field( u64, generation )
93 __field( u64, root_objectid )
94 ),
95
96 TP_fast_assign_btrfs(root->fs_info,
97 __entry->generation = root->fs_info->generation;
98 __entry->root_objectid = root->root_key.objectid;
99 ),
100
101 TP_printk_btrfs("root = %llu(%s), gen = %llu",
102 show_root_type(__entry->root_objectid),
103 (unsigned long long)__entry->generation)
104 );
105
106 DECLARE_EVENT_CLASS(btrfs__inode,
107
108 TP_PROTO(struct inode *inode),
109
110 TP_ARGS(inode),
111
112 TP_STRUCT__entry_btrfs(
113 __field( ino_t, ino )
114 __field( blkcnt_t, blocks )
115 __field( u64, disk_i_size )
116 __field( u64, generation )
117 __field( u64, last_trans )
118 __field( u64, logged_trans )
119 __field( u64, root_objectid )
120 ),
121
122 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
123 __entry->ino = inode->i_ino;
124 __entry->blocks = inode->i_blocks;
125 __entry->disk_i_size = BTRFS_I(inode)->disk_i_size;
126 __entry->generation = BTRFS_I(inode)->generation;
127 __entry->last_trans = BTRFS_I(inode)->last_trans;
128 __entry->logged_trans = BTRFS_I(inode)->logged_trans;
129 __entry->root_objectid =
130 BTRFS_I(inode)->root->root_key.objectid;
131 ),
132
133 TP_printk_btrfs("root = %llu(%s), gen = %llu, ino = %lu, blocks = %llu, "
134 "disk_i_size = %llu, last_trans = %llu, logged_trans = %llu",
135 show_root_type(__entry->root_objectid),
136 (unsigned long long)__entry->generation,
137 (unsigned long)__entry->ino,
138 (unsigned long long)__entry->blocks,
139 (unsigned long long)__entry->disk_i_size,
140 (unsigned long long)__entry->last_trans,
141 (unsigned long long)__entry->logged_trans)
142 );
143
144 DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
145
146 TP_PROTO(struct inode *inode),
147
148 TP_ARGS(inode)
149 );
150
151 DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
152
153 TP_PROTO(struct inode *inode),
154
155 TP_ARGS(inode)
156 );
157
158 DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
159
160 TP_PROTO(struct inode *inode),
161
162 TP_ARGS(inode)
163 );
164
165 #define __show_map_type(type) \
166 __print_symbolic_u64(type, \
167 { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
168 { EXTENT_MAP_HOLE, "HOLE" }, \
169 { EXTENT_MAP_INLINE, "INLINE" }, \
170 { EXTENT_MAP_DELALLOC, "DELALLOC" })
171
172 #define show_map_type(type) \
173 type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type)
174
175 #define show_map_flags(flag) \
176 __print_flags(flag, "|", \
177 { (1 << EXTENT_FLAG_PINNED), "PINNED" },\
178 { (1 << EXTENT_FLAG_COMPRESSED), "COMPRESSED" },\
179 { (1 << EXTENT_FLAG_VACANCY), "VACANCY" },\
180 { (1 << EXTENT_FLAG_PREALLOC), "PREALLOC" },\
181 { (1 << EXTENT_FLAG_LOGGING), "LOGGING" },\
182 { (1 << EXTENT_FLAG_FILLING), "FILLING" },\
183 { (1 << EXTENT_FLAG_FS_MAPPING), "FS_MAPPING" })
184
185 TRACE_EVENT_CONDITION(btrfs_get_extent,
186
187 TP_PROTO(struct btrfs_root *root, struct extent_map *map),
188
189 TP_ARGS(root, map),
190
191 TP_CONDITION(map),
192
193 TP_STRUCT__entry_btrfs(
194 __field( u64, root_objectid )
195 __field( u64, start )
196 __field( u64, len )
197 __field( u64, orig_start )
198 __field( u64, block_start )
199 __field( u64, block_len )
200 __field( unsigned long, flags )
201 __field( int, refs )
202 __field( unsigned int, compress_type )
203 ),
204
205 TP_fast_assign_btrfs(root->fs_info,
206 __entry->root_objectid = root->root_key.objectid;
207 __entry->start = map->start;
208 __entry->len = map->len;
209 __entry->orig_start = map->orig_start;
210 __entry->block_start = map->block_start;
211 __entry->block_len = map->block_len;
212 __entry->flags = map->flags;
213 __entry->refs = atomic_read(&map->refs);
214 __entry->compress_type = map->compress_type;
215 ),
216
217 TP_printk_btrfs("root = %llu(%s), start = %llu, len = %llu, "
218 "orig_start = %llu, block_start = %llu(%s), "
219 "block_len = %llu, flags = %s, refs = %u, "
220 "compress_type = %u",
221 show_root_type(__entry->root_objectid),
222 (unsigned long long)__entry->start,
223 (unsigned long long)__entry->len,
224 (unsigned long long)__entry->orig_start,
225 show_map_type(__entry->block_start),
226 (unsigned long long)__entry->block_len,
227 show_map_flags(__entry->flags),
228 __entry->refs, __entry->compress_type)
229 );
230
231 #define show_ordered_flags(flags) \
232 __print_flags(flags, "|", \
233 { (1 << BTRFS_ORDERED_IO_DONE), "IO_DONE" }, \
234 { (1 << BTRFS_ORDERED_COMPLETE), "COMPLETE" }, \
235 { (1 << BTRFS_ORDERED_NOCOW), "NOCOW" }, \
236 { (1 << BTRFS_ORDERED_COMPRESSED), "COMPRESSED" }, \
237 { (1 << BTRFS_ORDERED_PREALLOC), "PREALLOC" }, \
238 { (1 << BTRFS_ORDERED_DIRECT), "DIRECT" }, \
239 { (1 << BTRFS_ORDERED_IOERR), "IOERR" }, \
240 { (1 << BTRFS_ORDERED_UPDATED_ISIZE), "UPDATED_ISIZE" }, \
241 { (1 << BTRFS_ORDERED_LOGGED_CSUM), "LOGGED_CSUM" }, \
242 { (1 << BTRFS_ORDERED_TRUNCATED), "TRUNCATED" })
243
244
245 DECLARE_EVENT_CLASS(btrfs__ordered_extent,
246
247 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
248
249 TP_ARGS(inode, ordered),
250
251 TP_STRUCT__entry_btrfs(
252 __field( ino_t, ino )
253 __field( u64, file_offset )
254 __field( u64, start )
255 __field( u64, len )
256 __field( u64, disk_len )
257 __field( u64, bytes_left )
258 __field( unsigned long, flags )
259 __field( int, compress_type )
260 __field( int, refs )
261 __field( u64, root_objectid )
262 ),
263
264 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
265 __entry->ino = inode->i_ino;
266 __entry->file_offset = ordered->file_offset;
267 __entry->start = ordered->start;
268 __entry->len = ordered->len;
269 __entry->disk_len = ordered->disk_len;
270 __entry->bytes_left = ordered->bytes_left;
271 __entry->flags = ordered->flags;
272 __entry->compress_type = ordered->compress_type;
273 __entry->refs = atomic_read(&ordered->refs);
274 __entry->root_objectid =
275 BTRFS_I(inode)->root->root_key.objectid;
276 ),
277
278 TP_printk_btrfs("root = %llu(%s), ino = %llu, file_offset = %llu, "
279 "start = %llu, len = %llu, disk_len = %llu, "
280 "bytes_left = %llu, flags = %s, compress_type = %d, "
281 "refs = %d",
282 show_root_type(__entry->root_objectid),
283 (unsigned long long)__entry->ino,
284 (unsigned long long)__entry->file_offset,
285 (unsigned long long)__entry->start,
286 (unsigned long long)__entry->len,
287 (unsigned long long)__entry->disk_len,
288 (unsigned long long)__entry->bytes_left,
289 show_ordered_flags(__entry->flags),
290 __entry->compress_type, __entry->refs)
291 );
292
293 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
294
295 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
296
297 TP_ARGS(inode, ordered)
298 );
299
300 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
301
302 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
303
304 TP_ARGS(inode, ordered)
305 );
306
307 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
308
309 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
310
311 TP_ARGS(inode, ordered)
312 );
313
314 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
315
316 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
317
318 TP_ARGS(inode, ordered)
319 );
320
321 DECLARE_EVENT_CLASS(btrfs__writepage,
322
323 TP_PROTO(struct page *page, struct inode *inode,
324 struct writeback_control *wbc),
325
326 TP_ARGS(page, inode, wbc),
327
328 TP_STRUCT__entry_btrfs(
329 __field( ino_t, ino )
330 __field( pgoff_t, index )
331 __field( long, nr_to_write )
332 __field( long, pages_skipped )
333 __field( loff_t, range_start )
334 __field( loff_t, range_end )
335 __field( char, for_kupdate )
336 __field( char, for_reclaim )
337 __field( char, range_cyclic )
338 __field( pgoff_t, writeback_index )
339 __field( u64, root_objectid )
340 ),
341
342 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
343 __entry->ino = inode->i_ino;
344 __entry->index = page->index;
345 __entry->nr_to_write = wbc->nr_to_write;
346 __entry->pages_skipped = wbc->pages_skipped;
347 __entry->range_start = wbc->range_start;
348 __entry->range_end = wbc->range_end;
349 __entry->for_kupdate = wbc->for_kupdate;
350 __entry->for_reclaim = wbc->for_reclaim;
351 __entry->range_cyclic = wbc->range_cyclic;
352 __entry->writeback_index = inode->i_mapping->writeback_index;
353 __entry->root_objectid =
354 BTRFS_I(inode)->root->root_key.objectid;
355 ),
356
357 TP_printk_btrfs("root = %llu(%s), ino = %lu, page_index = %lu, "
358 "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
359 "range_end = %llu, for_kupdate = %d, "
360 "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
361 show_root_type(__entry->root_objectid),
362 (unsigned long)__entry->ino, __entry->index,
363 __entry->nr_to_write, __entry->pages_skipped,
364 __entry->range_start, __entry->range_end,
365 __entry->for_kupdate,
366 __entry->for_reclaim, __entry->range_cyclic,
367 (unsigned long)__entry->writeback_index)
368 );
369
370 DEFINE_EVENT(btrfs__writepage, __extent_writepage,
371
372 TP_PROTO(struct page *page, struct inode *inode,
373 struct writeback_control *wbc),
374
375 TP_ARGS(page, inode, wbc)
376 );
377
378 TRACE_EVENT(btrfs_writepage_end_io_hook,
379
380 TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
381
382 TP_ARGS(page, start, end, uptodate),
383
384 TP_STRUCT__entry_btrfs(
385 __field( ino_t, ino )
386 __field( pgoff_t, index )
387 __field( u64, start )
388 __field( u64, end )
389 __field( int, uptodate )
390 __field( u64, root_objectid )
391 ),
392
393 TP_fast_assign_btrfs(btrfs_sb(page->mapping->host->i_sb),
394 __entry->ino = page->mapping->host->i_ino;
395 __entry->index = page->index;
396 __entry->start = start;
397 __entry->end = end;
398 __entry->uptodate = uptodate;
399 __entry->root_objectid =
400 BTRFS_I(page->mapping->host)->root->root_key.objectid;
401 ),
402
403 TP_printk_btrfs("root = %llu(%s), ino = %lu, page_index = %lu, start = %llu, "
404 "end = %llu, uptodate = %d",
405 show_root_type(__entry->root_objectid),
406 (unsigned long)__entry->ino, (unsigned long)__entry->index,
407 (unsigned long long)__entry->start,
408 (unsigned long long)__entry->end, __entry->uptodate)
409 );
410
411 TRACE_EVENT(btrfs_sync_file,
412
413 TP_PROTO(struct file *file, int datasync),
414
415 TP_ARGS(file, datasync),
416
417 TP_STRUCT__entry_btrfs(
418 __field( ino_t, ino )
419 __field( ino_t, parent )
420 __field( int, datasync )
421 __field( u64, root_objectid )
422 ),
423
424 TP_fast_assign(
425 struct dentry *dentry = file->f_path.dentry;
426 struct inode *inode = d_inode(dentry);
427
428 TP_fast_assign_fsid(btrfs_sb(file->f_path.dentry->d_sb));
429 __entry->ino = inode->i_ino;
430 __entry->parent = d_inode(dentry->d_parent)->i_ino;
431 __entry->datasync = datasync;
432 __entry->root_objectid =
433 BTRFS_I(inode)->root->root_key.objectid;
434 ),
435
436 TP_printk_btrfs("root = %llu(%s), ino = %ld, parent = %ld, datasync = %d",
437 show_root_type(__entry->root_objectid),
438 (unsigned long)__entry->ino, (unsigned long)__entry->parent,
439 __entry->datasync)
440 );
441
442 TRACE_EVENT(btrfs_sync_fs,
443
444 TP_PROTO(struct btrfs_fs_info *fs_info, int wait),
445
446 TP_ARGS(fs_info, wait),
447
448 TP_STRUCT__entry_btrfs(
449 __field( int, wait )
450 ),
451
452 TP_fast_assign_btrfs(fs_info,
453 __entry->wait = wait;
454 ),
455
456 TP_printk_btrfs("wait = %d", __entry->wait)
457 );
458
459 TRACE_EVENT(btrfs_add_block_group,
460
461 TP_PROTO(struct btrfs_fs_info *fs_info,
462 struct btrfs_block_group_cache *block_group, int create),
463
464 TP_ARGS(fs_info, block_group, create),
465
466 TP_STRUCT__entry(
467 __array( u8, fsid, BTRFS_UUID_SIZE )
468 __field( u64, offset )
469 __field( u64, size )
470 __field( u64, flags )
471 __field( u64, bytes_used )
472 __field( u64, bytes_super )
473 __field( int, create )
474 ),
475
476 TP_fast_assign(
477 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
478 __entry->offset = block_group->key.objectid;
479 __entry->size = block_group->key.offset;
480 __entry->flags = block_group->flags;
481 __entry->bytes_used =
482 btrfs_block_group_used(&block_group->item);
483 __entry->bytes_super = block_group->bytes_super;
484 __entry->create = create;
485 ),
486
487 TP_printk("%pU: block_group offset = %llu, size = %llu, "
488 "flags = %llu(%s), bytes_used = %llu, bytes_super = %llu, "
489 "create = %d", __entry->fsid,
490 (unsigned long long)__entry->offset,
491 (unsigned long long)__entry->size,
492 (unsigned long long)__entry->flags,
493 __print_flags((unsigned long)__entry->flags, "|",
494 BTRFS_GROUP_FLAGS),
495 (unsigned long long)__entry->bytes_used,
496 (unsigned long long)__entry->bytes_super, __entry->create)
497 );
498
499 #define show_ref_action(action) \
500 __print_symbolic(action, \
501 { BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \
502 { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \
503 { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \
504 { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
505
506
507 DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,
508
509 TP_PROTO(struct btrfs_fs_info *fs_info,
510 struct btrfs_delayed_ref_node *ref,
511 struct btrfs_delayed_tree_ref *full_ref,
512 int action),
513
514 TP_ARGS(fs_info, ref, full_ref, action),
515
516 TP_STRUCT__entry_btrfs(
517 __field( u64, bytenr )
518 __field( u64, num_bytes )
519 __field( int, action )
520 __field( u64, parent )
521 __field( u64, ref_root )
522 __field( int, level )
523 __field( int, type )
524 __field( u64, seq )
525 ),
526
527 TP_fast_assign_btrfs(fs_info,
528 __entry->bytenr = ref->bytenr;
529 __entry->num_bytes = ref->num_bytes;
530 __entry->action = action;
531 __entry->parent = full_ref->parent;
532 __entry->ref_root = full_ref->root;
533 __entry->level = full_ref->level;
534 __entry->type = ref->type;
535 __entry->seq = ref->seq;
536 ),
537
538 TP_printk_btrfs("bytenr = %llu, num_bytes = %llu, action = %s, "
539 "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
540 "type = %s, seq = %llu",
541 (unsigned long long)__entry->bytenr,
542 (unsigned long long)__entry->num_bytes,
543 show_ref_action(__entry->action),
544 show_root_type(__entry->parent),
545 show_root_type(__entry->ref_root),
546 __entry->level, show_ref_type(__entry->type),
547 (unsigned long long)__entry->seq)
548 );
549
550 DEFINE_EVENT(btrfs_delayed_tree_ref, add_delayed_tree_ref,
551
552 TP_PROTO(struct btrfs_fs_info *fs_info,
553 struct btrfs_delayed_ref_node *ref,
554 struct btrfs_delayed_tree_ref *full_ref,
555 int action),
556
557 TP_ARGS(fs_info, ref, full_ref, action)
558 );
559
560 DEFINE_EVENT(btrfs_delayed_tree_ref, run_delayed_tree_ref,
561
562 TP_PROTO(struct btrfs_fs_info *fs_info,
563 struct btrfs_delayed_ref_node *ref,
564 struct btrfs_delayed_tree_ref *full_ref,
565 int action),
566
567 TP_ARGS(fs_info, ref, full_ref, action)
568 );
569
570 DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,
571
572 TP_PROTO(struct btrfs_fs_info *fs_info,
573 struct btrfs_delayed_ref_node *ref,
574 struct btrfs_delayed_data_ref *full_ref,
575 int action),
576
577 TP_ARGS(fs_info, ref, full_ref, action),
578
579 TP_STRUCT__entry_btrfs(
580 __field( u64, bytenr )
581 __field( u64, num_bytes )
582 __field( int, action )
583 __field( u64, parent )
584 __field( u64, ref_root )
585 __field( u64, owner )
586 __field( u64, offset )
587 __field( int, type )
588 __field( u64, seq )
589 ),
590
591 TP_fast_assign_btrfs(fs_info,
592 __entry->bytenr = ref->bytenr;
593 __entry->num_bytes = ref->num_bytes;
594 __entry->action = action;
595 __entry->parent = full_ref->parent;
596 __entry->ref_root = full_ref->root;
597 __entry->owner = full_ref->objectid;
598 __entry->offset = full_ref->offset;
599 __entry->type = ref->type;
600 __entry->seq = ref->seq;
601 ),
602
603 TP_printk_btrfs("bytenr = %llu, num_bytes = %llu, action = %s, "
604 "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
605 "offset = %llu, type = %s, seq = %llu",
606 (unsigned long long)__entry->bytenr,
607 (unsigned long long)__entry->num_bytes,
608 show_ref_action(__entry->action),
609 show_root_type(__entry->parent),
610 show_root_type(__entry->ref_root),
611 (unsigned long long)__entry->owner,
612 (unsigned long long)__entry->offset,
613 show_ref_type(__entry->type),
614 (unsigned long long)__entry->seq)
615 );
616
617 DEFINE_EVENT(btrfs_delayed_data_ref, add_delayed_data_ref,
618
619 TP_PROTO(struct btrfs_fs_info *fs_info,
620 struct btrfs_delayed_ref_node *ref,
621 struct btrfs_delayed_data_ref *full_ref,
622 int action),
623
624 TP_ARGS(fs_info, ref, full_ref, action)
625 );
626
627 DEFINE_EVENT(btrfs_delayed_data_ref, run_delayed_data_ref,
628
629 TP_PROTO(struct btrfs_fs_info *fs_info,
630 struct btrfs_delayed_ref_node *ref,
631 struct btrfs_delayed_data_ref *full_ref,
632 int action),
633
634 TP_ARGS(fs_info, ref, full_ref, action)
635 );
636
637 DECLARE_EVENT_CLASS(btrfs_delayed_ref_head,
638
639 TP_PROTO(struct btrfs_fs_info *fs_info,
640 struct btrfs_delayed_ref_node *ref,
641 struct btrfs_delayed_ref_head *head_ref,
642 int action),
643
644 TP_ARGS(fs_info, ref, head_ref, action),
645
646 TP_STRUCT__entry_btrfs(
647 __field( u64, bytenr )
648 __field( u64, num_bytes )
649 __field( int, action )
650 __field( int, is_data )
651 ),
652
653 TP_fast_assign_btrfs(fs_info,
654 __entry->bytenr = ref->bytenr;
655 __entry->num_bytes = ref->num_bytes;
656 __entry->action = action;
657 __entry->is_data = head_ref->is_data;
658 ),
659
660 TP_printk_btrfs("bytenr = %llu, num_bytes = %llu, action = %s, is_data = %d",
661 (unsigned long long)__entry->bytenr,
662 (unsigned long long)__entry->num_bytes,
663 show_ref_action(__entry->action),
664 __entry->is_data)
665 );
666
667 DEFINE_EVENT(btrfs_delayed_ref_head, add_delayed_ref_head,
668
669 TP_PROTO(struct btrfs_fs_info *fs_info,
670 struct btrfs_delayed_ref_node *ref,
671 struct btrfs_delayed_ref_head *head_ref,
672 int action),
673
674 TP_ARGS(fs_info, ref, head_ref, action)
675 );
676
677 DEFINE_EVENT(btrfs_delayed_ref_head, run_delayed_ref_head,
678
679 TP_PROTO(struct btrfs_fs_info *fs_info,
680 struct btrfs_delayed_ref_node *ref,
681 struct btrfs_delayed_ref_head *head_ref,
682 int action),
683
684 TP_ARGS(fs_info, ref, head_ref, action)
685 );
686
687 #define show_chunk_type(type) \
688 __print_flags(type, "|", \
689 { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
690 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
691 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
692 { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
693 { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
694 { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
695 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
696 { BTRFS_BLOCK_GROUP_RAID5, "RAID5" }, \
697 { BTRFS_BLOCK_GROUP_RAID6, "RAID6" })
698
699 DECLARE_EVENT_CLASS(btrfs__chunk,
700
701 TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
702 u64 offset, u64 size),
703
704 TP_ARGS(fs_info, map, offset, size),
705
706 TP_STRUCT__entry_btrfs(
707 __field( int, num_stripes )
708 __field( u64, type )
709 __field( int, sub_stripes )
710 __field( u64, offset )
711 __field( u64, size )
712 __field( u64, root_objectid )
713 ),
714
715 TP_fast_assign_btrfs(fs_info,
716 __entry->num_stripes = map->num_stripes;
717 __entry->type = map->type;
718 __entry->sub_stripes = map->sub_stripes;
719 __entry->offset = offset;
720 __entry->size = size;
721 __entry->root_objectid = fs_info->chunk_root->root_key.objectid;
722 ),
723
724 TP_printk_btrfs("root = %llu(%s), offset = %llu, size = %llu, "
725 "num_stripes = %d, sub_stripes = %d, type = %s",
726 show_root_type(__entry->root_objectid),
727 (unsigned long long)__entry->offset,
728 (unsigned long long)__entry->size,
729 __entry->num_stripes, __entry->sub_stripes,
730 show_chunk_type(__entry->type))
731 );
732
733 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
734
735 TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
736 u64 offset, u64 size),
737
738 TP_ARGS(fs_info, map, offset, size)
739 );
740
741 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
742
743 TP_PROTO(struct btrfs_fs_info *fs_info, struct map_lookup *map,
744 u64 offset, u64 size),
745
746 TP_ARGS(fs_info, map, offset, size)
747 );
748
749 TRACE_EVENT(btrfs_cow_block,
750
751 TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
752 struct extent_buffer *cow),
753
754 TP_ARGS(root, buf, cow),
755
756 TP_STRUCT__entry_btrfs(
757 __field( u64, root_objectid )
758 __field( u64, buf_start )
759 __field( int, refs )
760 __field( u64, cow_start )
761 __field( int, buf_level )
762 __field( int, cow_level )
763 ),
764
765 TP_fast_assign_btrfs(root->fs_info,
766 __entry->root_objectid = root->root_key.objectid;
767 __entry->buf_start = buf->start;
768 __entry->refs = atomic_read(&buf->refs);
769 __entry->cow_start = cow->start;
770 __entry->buf_level = btrfs_header_level(buf);
771 __entry->cow_level = btrfs_header_level(cow);
772 ),
773
774 TP_printk_btrfs("root = %llu(%s), refs = %d, orig_buf = %llu "
775 "(orig_level = %d), cow_buf = %llu (cow_level = %d)",
776 show_root_type(__entry->root_objectid),
777 __entry->refs,
778 (unsigned long long)__entry->buf_start,
779 __entry->buf_level,
780 (unsigned long long)__entry->cow_start,
781 __entry->cow_level)
782 );
783
784 TRACE_EVENT(btrfs_space_reservation,
785
786 TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
787 u64 bytes, int reserve),
788
789 TP_ARGS(fs_info, type, val, bytes, reserve),
790
791 TP_STRUCT__entry_btrfs(
792 __string( type, type )
793 __field( u64, val )
794 __field( u64, bytes )
795 __field( int, reserve )
796 ),
797
798 TP_fast_assign_btrfs(fs_info,
799 __assign_str(type, type);
800 __entry->val = val;
801 __entry->bytes = bytes;
802 __entry->reserve = reserve;
803 ),
804
805 TP_printk_btrfs("%s: %Lu %s %Lu", __get_str(type), __entry->val,
806 __entry->reserve ? "reserve" : "release",
807 __entry->bytes)
808 );
809
810 #define show_flush_action(action) \
811 __print_symbolic(action, \
812 { BTRFS_RESERVE_NO_FLUSH, "BTRFS_RESERVE_NO_FLUSH"}, \
813 { BTRFS_RESERVE_FLUSH_LIMIT, "BTRFS_RESERVE_FLUSH_LIMIT"}, \
814 { BTRFS_RESERVE_FLUSH_ALL, "BTRFS_RESERVE_FLUSH_ALL"})
815
816 TRACE_EVENT(btrfs_trigger_flush,
817
818 TP_PROTO(struct btrfs_fs_info *fs_info, u64 flags, u64 bytes,
819 int flush, char *reason),
820
821 TP_ARGS(fs_info, flags, bytes, flush, reason),
822
823 TP_STRUCT__entry(
824 __array( u8, fsid, BTRFS_UUID_SIZE )
825 __field( u64, flags )
826 __field( u64, bytes )
827 __field( int, flush )
828 __string( reason, reason )
829 ),
830
831 TP_fast_assign(
832 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
833 __entry->flags = flags;
834 __entry->bytes = bytes;
835 __entry->flush = flush;
836 __assign_str(reason, reason)
837 ),
838
839 TP_printk("%pU: %s: flush = %d(%s), flags = %llu(%s), bytes = %llu",
840 __entry->fsid, __get_str(reason), __entry->flush,
841 show_flush_action(__entry->flush),
842 (unsigned long long)__entry->flags,
843 __print_flags((unsigned long)__entry->flags, "|",
844 BTRFS_GROUP_FLAGS),
845 (unsigned long long)__entry->bytes)
846 );
847
848 #define show_flush_state(state) \
849 __print_symbolic(state, \
850 { FLUSH_DELAYED_ITEMS_NR, "FLUSH_DELAYED_ITEMS_NR"}, \
851 { FLUSH_DELAYED_ITEMS, "FLUSH_DELAYED_ITEMS"}, \
852 { FLUSH_DELALLOC, "FLUSH_DELALLOC"}, \
853 { FLUSH_DELALLOC_WAIT, "FLUSH_DELALLOC_WAIT"}, \
854 { ALLOC_CHUNK, "ALLOC_CHUNK"}, \
855 { COMMIT_TRANS, "COMMIT_TRANS"})
856
857 TRACE_EVENT(btrfs_flush_space,
858
859 TP_PROTO(struct btrfs_fs_info *fs_info, u64 flags, u64 num_bytes,
860 u64 orig_bytes, int state, int ret),
861
862 TP_ARGS(fs_info, flags, num_bytes, orig_bytes, state, ret),
863
864 TP_STRUCT__entry(
865 __array( u8, fsid, BTRFS_UUID_SIZE )
866 __field( u64, flags )
867 __field( u64, num_bytes )
868 __field( u64, orig_bytes )
869 __field( int, state )
870 __field( int, ret )
871 ),
872
873 TP_fast_assign(
874 memcpy(__entry->fsid, fs_info->fsid, BTRFS_UUID_SIZE);
875 __entry->flags = flags;
876 __entry->num_bytes = num_bytes;
877 __entry->orig_bytes = orig_bytes;
878 __entry->state = state;
879 __entry->ret = ret;
880 ),
881
882 TP_printk("%pU: state = %d(%s), flags = %llu(%s), num_bytes = %llu, "
883 "orig_bytes = %llu, ret = %d", __entry->fsid, __entry->state,
884 show_flush_state(__entry->state),
885 (unsigned long long)__entry->flags,
886 __print_flags((unsigned long)__entry->flags, "|",
887 BTRFS_GROUP_FLAGS),
888 (unsigned long long)__entry->num_bytes,
889 (unsigned long long)__entry->orig_bytes, __entry->ret)
890 );
891
892 DECLARE_EVENT_CLASS(btrfs__reserved_extent,
893
894 TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
895
896 TP_ARGS(fs_info, start, len),
897
898 TP_STRUCT__entry_btrfs(
899 __field( u64, start )
900 __field( u64, len )
901 ),
902
903 TP_fast_assign_btrfs(fs_info,
904 __entry->start = start;
905 __entry->len = len;
906 ),
907
908 TP_printk_btrfs("root = %llu(%s), start = %llu, len = %llu",
909 show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
910 (unsigned long long)__entry->start,
911 (unsigned long long)__entry->len)
912 );
913
914 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
915
916 TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
917
918 TP_ARGS(fs_info, start, len)
919 );
920
921 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
922
923 TP_PROTO(struct btrfs_fs_info *fs_info, u64 start, u64 len),
924
925 TP_ARGS(fs_info, start, len)
926 );
927
928 TRACE_EVENT(find_free_extent,
929
930 TP_PROTO(struct btrfs_fs_info *fs_info, u64 num_bytes, u64 empty_size,
931 u64 data),
932
933 TP_ARGS(fs_info, num_bytes, empty_size, data),
934
935 TP_STRUCT__entry_btrfs(
936 __field( u64, num_bytes )
937 __field( u64, empty_size )
938 __field( u64, data )
939 ),
940
941 TP_fast_assign_btrfs(fs_info,
942 __entry->num_bytes = num_bytes;
943 __entry->empty_size = empty_size;
944 __entry->data = data;
945 ),
946
947 TP_printk_btrfs("root = %Lu(%s), len = %Lu, empty_size = %Lu, flags = %Lu(%s)",
948 show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
949 __entry->num_bytes, __entry->empty_size, __entry->data,
950 __print_flags((unsigned long)__entry->data, "|",
951 BTRFS_GROUP_FLAGS))
952 );
953
954 DECLARE_EVENT_CLASS(btrfs__reserve_extent,
955
956 TP_PROTO(struct btrfs_fs_info *fs_info,
957 struct btrfs_block_group_cache *block_group, u64 start,
958 u64 len),
959
960 TP_ARGS(fs_info, block_group, start, len),
961
962 TP_STRUCT__entry_btrfs(
963 __field( u64, bg_objectid )
964 __field( u64, flags )
965 __field( u64, start )
966 __field( u64, len )
967 ),
968
969 TP_fast_assign_btrfs(fs_info,
970 __entry->bg_objectid = block_group->key.objectid;
971 __entry->flags = block_group->flags;
972 __entry->start = start;
973 __entry->len = len;
974 ),
975
976 TP_printk_btrfs("root = %Lu(%s), block_group = %Lu, flags = %Lu(%s), "
977 "start = %Lu, len = %Lu",
978 show_root_type(BTRFS_EXTENT_TREE_OBJECTID),
979 __entry->bg_objectid,
980 __entry->flags, __print_flags((unsigned long)__entry->flags,
981 "|", BTRFS_GROUP_FLAGS),
982 __entry->start, __entry->len)
983 );
984
985 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
986
987 TP_PROTO(struct btrfs_fs_info *fs_info,
988 struct btrfs_block_group_cache *block_group, u64 start,
989 u64 len),
990
991 TP_ARGS(fs_info, block_group, start, len)
992 );
993
994 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
995
996 TP_PROTO(struct btrfs_fs_info *fs_info,
997 struct btrfs_block_group_cache *block_group, u64 start,
998 u64 len),
999
1000 TP_ARGS(fs_info, block_group, start, len)
1001 );
1002
1003 TRACE_EVENT(btrfs_find_cluster,
1004
1005 TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
1006 u64 bytes, u64 empty_size, u64 min_bytes),
1007
1008 TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
1009
1010 TP_STRUCT__entry_btrfs(
1011 __field( u64, bg_objectid )
1012 __field( u64, flags )
1013 __field( u64, start )
1014 __field( u64, bytes )
1015 __field( u64, empty_size )
1016 __field( u64, min_bytes )
1017 ),
1018
1019 TP_fast_assign_btrfs(block_group->fs_info,
1020 __entry->bg_objectid = block_group->key.objectid;
1021 __entry->flags = block_group->flags;
1022 __entry->start = start;
1023 __entry->bytes = bytes;
1024 __entry->empty_size = empty_size;
1025 __entry->min_bytes = min_bytes;
1026 ),
1027
1028 TP_printk_btrfs("block_group = %Lu, flags = %Lu(%s), start = %Lu, len = %Lu,"
1029 " empty_size = %Lu, min_bytes = %Lu", __entry->bg_objectid,
1030 __entry->flags,
1031 __print_flags((unsigned long)__entry->flags, "|",
1032 BTRFS_GROUP_FLAGS), __entry->start,
1033 __entry->bytes, __entry->empty_size, __entry->min_bytes)
1034 );
1035
1036 TRACE_EVENT(btrfs_failed_cluster_setup,
1037
1038 TP_PROTO(struct btrfs_block_group_cache *block_group),
1039
1040 TP_ARGS(block_group),
1041
1042 TP_STRUCT__entry_btrfs(
1043 __field( u64, bg_objectid )
1044 ),
1045
1046 TP_fast_assign_btrfs(block_group->fs_info,
1047 __entry->bg_objectid = block_group->key.objectid;
1048 ),
1049
1050 TP_printk_btrfs("block_group = %Lu", __entry->bg_objectid)
1051 );
1052
1053 TRACE_EVENT(btrfs_setup_cluster,
1054
1055 TP_PROTO(struct btrfs_block_group_cache *block_group,
1056 struct btrfs_free_cluster *cluster, u64 size, int bitmap),
1057
1058 TP_ARGS(block_group, cluster, size, bitmap),
1059
1060 TP_STRUCT__entry_btrfs(
1061 __field( u64, bg_objectid )
1062 __field( u64, flags )
1063 __field( u64, start )
1064 __field( u64, max_size )
1065 __field( u64, size )
1066 __field( int, bitmap )
1067 ),
1068
1069 TP_fast_assign_btrfs(block_group->fs_info,
1070 __entry->bg_objectid = block_group->key.objectid;
1071 __entry->flags = block_group->flags;
1072 __entry->start = cluster->window_start;
1073 __entry->max_size = cluster->max_size;
1074 __entry->size = size;
1075 __entry->bitmap = bitmap;
1076 ),
1077
1078 TP_printk_btrfs("block_group = %Lu, flags = %Lu(%s), window_start = %Lu, "
1079 "size = %Lu, max_size = %Lu, bitmap = %d",
1080 __entry->bg_objectid,
1081 __entry->flags,
1082 __print_flags((unsigned long)__entry->flags, "|",
1083 BTRFS_GROUP_FLAGS), __entry->start,
1084 __entry->size, __entry->max_size, __entry->bitmap)
1085 );
1086
1087 struct extent_state;
1088 TRACE_EVENT(alloc_extent_state,
1089
1090 TP_PROTO(struct extent_state *state, gfp_t mask, unsigned long IP),
1091
1092 TP_ARGS(state, mask, IP),
1093
1094 TP_STRUCT__entry(
1095 __field(struct extent_state *, state)
1096 __field(gfp_t, mask)
1097 __field(unsigned long, ip)
1098 ),
1099
1100 TP_fast_assign(
1101 __entry->state = state,
1102 __entry->mask = mask,
1103 __entry->ip = IP
1104 ),
1105
1106 TP_printk("state=%p; mask = %s; caller = %pS", __entry->state,
1107 show_gfp_flags(__entry->mask), (void *)__entry->ip)
1108 );
1109
1110 TRACE_EVENT(free_extent_state,
1111
1112 TP_PROTO(struct extent_state *state, unsigned long IP),
1113
1114 TP_ARGS(state, IP),
1115
1116 TP_STRUCT__entry(
1117 __field(struct extent_state *, state)
1118 __field(unsigned long, ip)
1119 ),
1120
1121 TP_fast_assign(
1122 __entry->state = state,
1123 __entry->ip = IP
1124 ),
1125
1126 TP_printk(" state=%p; caller = %pS", __entry->state,
1127 (void *)__entry->ip)
1128 );
1129
1130 DECLARE_EVENT_CLASS(btrfs__work,
1131
1132 TP_PROTO(struct btrfs_work *work),
1133
1134 TP_ARGS(work),
1135
1136 TP_STRUCT__entry_btrfs(
1137 __field( void *, work )
1138 __field( void *, wq )
1139 __field( void *, func )
1140 __field( void *, ordered_func )
1141 __field( void *, ordered_free )
1142 __field( void *, normal_work )
1143 ),
1144
1145 TP_fast_assign_btrfs(btrfs_work_owner(work),
1146 __entry->work = work;
1147 __entry->wq = work->wq;
1148 __entry->func = work->func;
1149 __entry->ordered_func = work->ordered_func;
1150 __entry->ordered_free = work->ordered_free;
1151 __entry->normal_work = &work->normal_work;
1152 ),
1153
1154 TP_printk_btrfs("work=%p (normal_work=%p), wq=%p, func=%pf, ordered_func=%p,"
1155 " ordered_free=%p",
1156 __entry->work, __entry->normal_work, __entry->wq,
1157 __entry->func, __entry->ordered_func, __entry->ordered_free)
1158 );
1159
1160 /*
1161 * For situiations when the work is freed, we pass fs_info and a tag that that
1162 * matches address of the work structure so it can be paired with the
1163 * scheduling event.
1164 */
1165 DECLARE_EVENT_CLASS(btrfs__work__done,
1166
1167 TP_PROTO(struct btrfs_fs_info *fs_info, void *wtag),
1168
1169 TP_ARGS(fs_info, wtag),
1170
1171 TP_STRUCT__entry_btrfs(
1172 __field( void *, wtag )
1173 ),
1174
1175 TP_fast_assign_btrfs(fs_info,
1176 __entry->wtag = wtag;
1177 ),
1178
1179 TP_printk_btrfs("work->%p", __entry->wtag)
1180 );
1181
1182 DEFINE_EVENT(btrfs__work, btrfs_work_queued,
1183
1184 TP_PROTO(struct btrfs_work *work),
1185
1186 TP_ARGS(work)
1187 );
1188
1189 DEFINE_EVENT(btrfs__work, btrfs_work_sched,
1190
1191 TP_PROTO(struct btrfs_work *work),
1192
1193 TP_ARGS(work)
1194 );
1195
1196 DEFINE_EVENT(btrfs__work__done, btrfs_all_work_done,
1197
1198 TP_PROTO(struct btrfs_fs_info *fs_info, void *wtag),
1199
1200 TP_ARGS(fs_info, wtag)
1201 );
1202
1203 DEFINE_EVENT(btrfs__work, btrfs_ordered_sched,
1204
1205 TP_PROTO(struct btrfs_work *work),
1206
1207 TP_ARGS(work)
1208 );
1209
1210 DECLARE_EVENT_CLASS(btrfs__workqueue,
1211
1212 TP_PROTO(struct __btrfs_workqueue *wq, const char *name, int high),
1213
1214 TP_ARGS(wq, name, high),
1215
1216 TP_STRUCT__entry_btrfs(
1217 __field( void *, wq )
1218 __string( name, name )
1219 __field( int , high )
1220 ),
1221
1222 TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
1223 __entry->wq = wq;
1224 __assign_str(name, name);
1225 __entry->high = high;
1226 ),
1227
1228 TP_printk_btrfs("name=%s%s, wq=%p", __get_str(name),
1229 __print_flags(__entry->high, "",
1230 {(WQ_HIGHPRI), "-high"}),
1231 __entry->wq)
1232 );
1233
1234 DEFINE_EVENT(btrfs__workqueue, btrfs_workqueue_alloc,
1235
1236 TP_PROTO(struct __btrfs_workqueue *wq, const char *name, int high),
1237
1238 TP_ARGS(wq, name, high)
1239 );
1240
1241 DECLARE_EVENT_CLASS(btrfs__workqueue_done,
1242
1243 TP_PROTO(struct __btrfs_workqueue *wq),
1244
1245 TP_ARGS(wq),
1246
1247 TP_STRUCT__entry_btrfs(
1248 __field( void *, wq )
1249 ),
1250
1251 TP_fast_assign_btrfs(btrfs_workqueue_owner(wq),
1252 __entry->wq = wq;
1253 ),
1254
1255 TP_printk_btrfs("wq=%p", __entry->wq)
1256 );
1257
1258 DEFINE_EVENT(btrfs__workqueue_done, btrfs_workqueue_destroy,
1259
1260 TP_PROTO(struct __btrfs_workqueue *wq),
1261
1262 TP_ARGS(wq)
1263 );
1264
1265 DECLARE_EVENT_CLASS(btrfs__qgroup_data_map,
1266
1267 TP_PROTO(struct inode *inode, u64 free_reserved),
1268
1269 TP_ARGS(inode, free_reserved),
1270
1271 TP_STRUCT__entry_btrfs(
1272 __field( u64, rootid )
1273 __field( unsigned long, ino )
1274 __field( u64, free_reserved )
1275 ),
1276
1277 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
1278 __entry->rootid = BTRFS_I(inode)->root->objectid;
1279 __entry->ino = inode->i_ino;
1280 __entry->free_reserved = free_reserved;
1281 ),
1282
1283 TP_printk_btrfs("rootid=%llu, ino=%lu, free_reserved=%llu",
1284 __entry->rootid, __entry->ino, __entry->free_reserved)
1285 );
1286
1287 DEFINE_EVENT(btrfs__qgroup_data_map, btrfs_qgroup_init_data_rsv_map,
1288
1289 TP_PROTO(struct inode *inode, u64 free_reserved),
1290
1291 TP_ARGS(inode, free_reserved)
1292 );
1293
1294 DEFINE_EVENT(btrfs__qgroup_data_map, btrfs_qgroup_free_data_rsv_map,
1295
1296 TP_PROTO(struct inode *inode, u64 free_reserved),
1297
1298 TP_ARGS(inode, free_reserved)
1299 );
1300
1301 #define BTRFS_QGROUP_OPERATIONS \
1302 { QGROUP_RESERVE, "reserve" }, \
1303 { QGROUP_RELEASE, "release" }, \
1304 { QGROUP_FREE, "free" }
1305
1306 DECLARE_EVENT_CLASS(btrfs__qgroup_rsv_data,
1307
1308 TP_PROTO(struct inode *inode, u64 start, u64 len, u64 reserved, int op),
1309
1310 TP_ARGS(inode, start, len, reserved, op),
1311
1312 TP_STRUCT__entry_btrfs(
1313 __field( u64, rootid )
1314 __field( unsigned long, ino )
1315 __field( u64, start )
1316 __field( u64, len )
1317 __field( u64, reserved )
1318 __field( int, op )
1319 ),
1320
1321 TP_fast_assign_btrfs(btrfs_sb(inode->i_sb),
1322 __entry->rootid = BTRFS_I(inode)->root->objectid;
1323 __entry->ino = inode->i_ino;
1324 __entry->start = start;
1325 __entry->len = len;
1326 __entry->reserved = reserved;
1327 __entry->op = op;
1328 ),
1329
1330 TP_printk_btrfs("root=%llu, ino=%lu, start=%llu, len=%llu, reserved=%llu, op=%s",
1331 __entry->rootid, __entry->ino, __entry->start, __entry->len,
1332 __entry->reserved,
1333 __print_flags((unsigned long)__entry->op, "",
1334 BTRFS_QGROUP_OPERATIONS)
1335 )
1336 );
1337
1338 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_reserve_data,
1339
1340 TP_PROTO(struct inode *inode, u64 start, u64 len, u64 reserved, int op),
1341
1342 TP_ARGS(inode, start, len, reserved, op)
1343 );
1344
1345 DEFINE_EVENT(btrfs__qgroup_rsv_data, btrfs_qgroup_release_data,
1346
1347 TP_PROTO(struct inode *inode, u64 start, u64 len, u64 reserved, int op),
1348
1349 TP_ARGS(inode, start, len, reserved, op)
1350 );
1351
1352 DECLARE_EVENT_CLASS(btrfs__qgroup_delayed_ref,
1353
1354 TP_PROTO(struct btrfs_fs_info *fs_info, u64 ref_root, u64 reserved),
1355
1356 TP_ARGS(fs_info, ref_root, reserved),
1357
1358 TP_STRUCT__entry_btrfs(
1359 __field( u64, ref_root )
1360 __field( u64, reserved )
1361 ),
1362
1363 TP_fast_assign_btrfs(fs_info,
1364 __entry->ref_root = ref_root;
1365 __entry->reserved = reserved;
1366 ),
1367
1368 TP_printk_btrfs("root=%llu, reserved=%llu, op=free",
1369 __entry->ref_root, __entry->reserved)
1370 );
1371
1372 DEFINE_EVENT(btrfs__qgroup_delayed_ref, btrfs_qgroup_free_delayed_ref,
1373
1374 TP_PROTO(struct btrfs_fs_info *fs_info, u64 ref_root, u64 reserved),
1375
1376 TP_ARGS(fs_info, ref_root, reserved)
1377 );
1378
1379 DECLARE_EVENT_CLASS(btrfs_qgroup_extent,
1380 TP_PROTO(struct btrfs_fs_info *fs_info,
1381 struct btrfs_qgroup_extent_record *rec),
1382
1383 TP_ARGS(fs_info, rec),
1384
1385 TP_STRUCT__entry_btrfs(
1386 __field( u64, bytenr )
1387 __field( u64, num_bytes )
1388 ),
1389
1390 TP_fast_assign_btrfs(fs_info,
1391 __entry->bytenr = rec->bytenr,
1392 __entry->num_bytes = rec->num_bytes;
1393 ),
1394
1395 TP_printk_btrfs("bytenr = %llu, num_bytes = %llu",
1396 (unsigned long long)__entry->bytenr,
1397 (unsigned long long)__entry->num_bytes)
1398 );
1399
1400 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_account_extents,
1401
1402 TP_PROTO(struct btrfs_fs_info *fs_info,
1403 struct btrfs_qgroup_extent_record *rec),
1404
1405 TP_ARGS(fs_info, rec)
1406 );
1407
1408 DEFINE_EVENT(btrfs_qgroup_extent, btrfs_qgroup_trace_extent,
1409
1410 TP_PROTO(struct btrfs_fs_info *fs_info,
1411 struct btrfs_qgroup_extent_record *rec),
1412
1413 TP_ARGS(fs_info, rec)
1414 );
1415
1416 TRACE_EVENT(btrfs_qgroup_account_extent,
1417
1418 TP_PROTO(struct btrfs_fs_info *fs_info, u64 bytenr,
1419 u64 num_bytes, u64 nr_old_roots, u64 nr_new_roots),
1420
1421 TP_ARGS(fs_info, bytenr, num_bytes, nr_old_roots, nr_new_roots),
1422
1423 TP_STRUCT__entry_btrfs(
1424 __field( u64, bytenr )
1425 __field( u64, num_bytes )
1426 __field( u64, nr_old_roots )
1427 __field( u64, nr_new_roots )
1428 ),
1429
1430 TP_fast_assign_btrfs(fs_info,
1431 __entry->bytenr = bytenr;
1432 __entry->num_bytes = num_bytes;
1433 __entry->nr_old_roots = nr_old_roots;
1434 __entry->nr_new_roots = nr_new_roots;
1435 ),
1436
1437 TP_printk_btrfs("bytenr = %llu, num_bytes = %llu, nr_old_roots = %llu, "
1438 "nr_new_roots = %llu",
1439 __entry->bytenr,
1440 __entry->num_bytes,
1441 __entry->nr_old_roots,
1442 __entry->nr_new_roots)
1443 );
1444
1445 TRACE_EVENT(qgroup_update_counters,
1446
1447 TP_PROTO(struct btrfs_fs_info *fs_info, u64 qgid,
1448 u64 cur_old_count, u64 cur_new_count),
1449
1450 TP_ARGS(fs_info, qgid, cur_old_count, cur_new_count),
1451
1452 TP_STRUCT__entry_btrfs(
1453 __field( u64, qgid )
1454 __field( u64, cur_old_count )
1455 __field( u64, cur_new_count )
1456 ),
1457
1458 TP_fast_assign_btrfs(fs_info,
1459 __entry->qgid = qgid;
1460 __entry->cur_old_count = cur_old_count;
1461 __entry->cur_new_count = cur_new_count;
1462 ),
1463
1464 TP_printk_btrfs("qgid = %llu, cur_old_count = %llu, cur_new_count = %llu",
1465 __entry->qgid,
1466 __entry->cur_old_count,
1467 __entry->cur_new_count)
1468 );
1469
1470 #endif /* _TRACE_BTRFS_H */
1471
1472 /* This part must be outside protection */
1473 #include <trace/define_trace.h>
ubuntu-bionic-kernel mirror