projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix: btrfs: support 3.11 Linux kernel
[lttng-modules.git] / instrumentation / events / lttng-module / 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/gfpflags.h>
10 #include <linux/version.h>
11
12 #ifndef _TRACE_BTRFS_DEF_
13 #define _TRACE_BTRFS_DEF_
14 struct btrfs_root;
15 struct btrfs_fs_info;
16 struct btrfs_inode;
17 struct extent_map;
18 struct btrfs_ordered_extent;
19 struct btrfs_delayed_ref_node;
20 struct btrfs_delayed_tree_ref;
21 struct btrfs_delayed_data_ref;
22 struct btrfs_delayed_ref_head;
23 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
24 struct btrfs_block_group_cache;
25 struct btrfs_free_cluster;
26 #endif
27 struct map_lookup;
28 struct extent_buffer;
29 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
30 struct extent_state;
31 #endif
32 #endif
33
34 #define show_ref_type(type) \
35 __print_symbolic(type, \
36 { BTRFS_TREE_BLOCK_REF_KEY, "TREE_BLOCK_REF" }, \
37 { BTRFS_EXTENT_DATA_REF_KEY, "EXTENT_DATA_REF" }, \
38 { BTRFS_EXTENT_REF_V0_KEY, "EXTENT_REF_V0" }, \
39 { BTRFS_SHARED_BLOCK_REF_KEY, "SHARED_BLOCK_REF" }, \
40 { BTRFS_SHARED_DATA_REF_KEY, "SHARED_DATA_REF" })
41
42
43 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
44 #define __show_root_type(obj) \
45 __print_symbolic_u64(obj, \
46 { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
47 { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
48 { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
49 { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
50 { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
51 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
52 { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
53 { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
54 { BTRFS_QUOTA_TREE_OBJECTID, "QUOTA_TREE" }, \
55 { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
56 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
57 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
58 #define __show_root_type(obj) \
59 __print_symbolic_u64(obj, \
60 { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
61 { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
62 { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
63 { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
64 { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
65 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
66 { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
67 { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
68 { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
69 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
70 #else
71 #define __show_root_type(obj) \
72 __print_symbolic(obj, \
73 { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, \
74 { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, \
75 { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, \
76 { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, \
77 { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, \
78 { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" }, \
79 { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, \
80 { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, \
81 { BTRFS_TREE_RELOC_OBJECTID, "TREE_RELOC" }, \
82 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
83 #endif
84
85 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
86 #define show_root_type(obj) \
87 obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
88 (obj >= BTRFS_ROOT_TREE_OBJECTID && \
89 obj <= BTRFS_QUOTA_TREE_OBJECTID)) ? __show_root_type(obj) : "-"
90 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0))
91 #define show_root_type(obj) \
92 obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
93 (obj >= BTRFS_ROOT_TREE_OBJECTID && \
94 obj <= BTRFS_CSUM_TREE_OBJECTID)) ? __show_root_type(obj) : "-"
95 #else /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
96 #define show_root_type(obj) \
97 obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) || \
98 (obj <= BTRFS_CSUM_TREE_OBJECTID )) ? __show_root_type(obj) : "-"
99 #endif /* #else #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,8,0)) */
100
101 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
102
103 #define BTRFS_GROUP_FLAGS \
104 { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
105 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
106 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
107 { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
108 { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
109 { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
110 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
111 { BTRFS_BLOCK_GROUP_RAID5, "RAID5"}, \
112 { BTRFS_BLOCK_GROUP_RAID6, "RAID6"}
113
114 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
115
116 #define BTRFS_GROUP_FLAGS \
117 { BTRFS_BLOCK_GROUP_DATA, "DATA"}, \
118 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
119 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
120 { BTRFS_BLOCK_GROUP_RAID0, "RAID0"}, \
121 { BTRFS_BLOCK_GROUP_RAID1, "RAID1"}, \
122 { BTRFS_BLOCK_GROUP_DUP, "DUP"}, \
123 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}
124
125 #define BTRFS_UUID_SIZE 16
126
127 #endif
128
129 TRACE_EVENT(btrfs_transaction_commit,
130
131 TP_PROTO(struct btrfs_root *root),
132
133 TP_ARGS(root),
134
135 TP_STRUCT__entry(
136 __field( u64, generation )
137 __field( u64, root_objectid )
138 ),
139
140 TP_fast_assign(
141 tp_assign(generation, root->fs_info->generation)
142 tp_assign(root_objectid, root->root_key.objectid)
143 ),
144
145 TP_printk("root = %llu(%s), gen = %llu",
146 show_root_type(__entry->root_objectid),
147 (unsigned long long)__entry->generation)
148 )
149
150 DECLARE_EVENT_CLASS(btrfs__inode,
151
152 TP_PROTO(struct inode *inode),
153
154 TP_ARGS(inode),
155
156 TP_STRUCT__entry(
157 __field( ino_t, ino )
158 __field( blkcnt_t, blocks )
159 __field( u64, disk_i_size )
160 __field( u64, generation )
161 __field( u64, last_trans )
162 __field( u64, logged_trans )
163 __field( u64, root_objectid )
164 ),
165
166 TP_fast_assign(
167 tp_assign(ino, inode->i_ino)
168 tp_assign(blocks, inode->i_blocks)
169 tp_assign(disk_i_size, BTRFS_I(inode)->disk_i_size)
170 tp_assign(generation, BTRFS_I(inode)->generation)
171 tp_assign(last_trans, BTRFS_I(inode)->last_trans)
172 tp_assign(logged_trans, BTRFS_I(inode)->logged_trans)
173 tp_assign(root_objectid,
174 BTRFS_I(inode)->root->root_key.objectid)
175 ),
176
177 TP_printk("root = %llu(%s), gen = %llu, ino = %lu, blocks = %llu, "
178 "disk_i_size = %llu, last_trans = %llu, logged_trans = %llu",
179 show_root_type(__entry->root_objectid),
180 (unsigned long long)__entry->generation,
181 (unsigned long)__entry->ino,
182 (unsigned long long)__entry->blocks,
183 (unsigned long long)__entry->disk_i_size,
184 (unsigned long long)__entry->last_trans,
185 (unsigned long long)__entry->logged_trans)
186 )
187
188 DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
189
190 TP_PROTO(struct inode *inode),
191
192 TP_ARGS(inode)
193 )
194
195 DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
196
197 TP_PROTO(struct inode *inode),
198
199 TP_ARGS(inode)
200 )
201
202 DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
203
204 TP_PROTO(struct inode *inode),
205
206 TP_ARGS(inode)
207 )
208
209 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,40))
210 #define __show_map_type(type) \
211 __print_symbolic_u64(type, \
212 { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
213 { EXTENT_MAP_HOLE, "HOLE" }, \
214 { EXTENT_MAP_INLINE, "INLINE" }, \
215 { EXTENT_MAP_DELALLOC, "DELALLOC" })
216 #else
217 #define __show_map_type(type) \
218 __print_symbolic(type, \
219 { EXTENT_MAP_LAST_BYTE, "LAST_BYTE" }, \
220 { EXTENT_MAP_HOLE, "HOLE" }, \
221 { EXTENT_MAP_INLINE, "INLINE" }, \
222 { EXTENT_MAP_DELALLOC, "DELALLOC" })
223 #endif
224
225 #define show_map_type(type) \
226 type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" : __show_map_type(type)
227
228 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
229
230 #define show_map_flags(flag) \
231 __print_flags(flag, "|", \
232 { EXTENT_FLAG_PINNED, "PINNED" }, \
233 { EXTENT_FLAG_COMPRESSED, "COMPRESSED" }, \
234 { EXTENT_FLAG_VACANCY, "VACANCY" }, \
235 { EXTENT_FLAG_PREALLOC, "PREALLOC" }, \
236 { EXTENT_FLAG_LOGGING, "LOGGING" }, \
237 { EXTENT_FLAG_FILLING, "FILLING" })
238
239 #else
240
241 #define show_map_flags(flag) \
242 __print_flags(flag, "|", \
243 { EXTENT_FLAG_PINNED, "PINNED" }, \
244 { EXTENT_FLAG_COMPRESSED, "COMPRESSED" }, \
245 { EXTENT_FLAG_VACANCY, "VACANCY" }, \
246 { EXTENT_FLAG_PREALLOC, "PREALLOC" })
247
248 #endif
249
250 TRACE_EVENT(btrfs_get_extent,
251
252 TP_PROTO(struct btrfs_root *root, struct extent_map *map),
253
254 TP_ARGS(root, map),
255
256 TP_STRUCT__entry(
257 __field( u64, root_objectid )
258 __field( u64, start )
259 __field( u64, len )
260 __field( u64, orig_start )
261 __field( u64, block_start )
262 __field( u64, block_len )
263 __field( unsigned long, flags )
264 __field( int, refs )
265 __field( unsigned int, compress_type )
266 ),
267
268 TP_fast_assign(
269 tp_assign(root_objectid, root->root_key.objectid)
270 tp_assign(start, map->start)
271 tp_assign(len, map->len)
272 tp_assign(orig_start, map->orig_start)
273 tp_assign(block_start, map->block_start)
274 tp_assign(block_len, map->block_len)
275 tp_assign(flags, map->flags)
276 tp_assign(refs, atomic_read(&map->refs))
277 tp_assign(compress_type, map->compress_type)
278 ),
279
280 TP_printk("root = %llu(%s), start = %llu, len = %llu, "
281 "orig_start = %llu, block_start = %llu(%s), "
282 "block_len = %llu, flags = %s, refs = %u, "
283 "compress_type = %u",
284 show_root_type(__entry->root_objectid),
285 (unsigned long long)__entry->start,
286 (unsigned long long)__entry->len,
287 (unsigned long long)__entry->orig_start,
288 show_map_type(__entry->block_start),
289 (unsigned long long)__entry->block_len,
290 show_map_flags(__entry->flags),
291 __entry->refs, __entry->compress_type)
292 )
293
294 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
295
296 #define show_ordered_flags(flags) \
297 __print_symbolic(flags, \
298 { BTRFS_ORDERED_IO_DONE, "IO_DONE" }, \
299 { BTRFS_ORDERED_COMPLETE, "COMPLETE" }, \
300 { BTRFS_ORDERED_NOCOW, "NOCOW" }, \
301 { BTRFS_ORDERED_COMPRESSED, "COMPRESSED" }, \
302 { BTRFS_ORDERED_PREALLOC, "PREALLOC" }, \
303 { BTRFS_ORDERED_DIRECT, "DIRECT" }, \
304 { BTRFS_ORDERED_IOERR, "IOERR" }, \
305 { BTRFS_ORDERED_UPDATED_ISIZE, "UPDATED_ISIZE" }, \
306 { BTRFS_ORDERED_LOGGED_CSUM, "LOGGED_CSUM" })
307
308 #else
309
310 #define show_ordered_flags(flags) \
311 __print_symbolic(flags, \
312 { BTRFS_ORDERED_IO_DONE, "IO_DONE" }, \
313 { BTRFS_ORDERED_COMPLETE, "COMPLETE" }, \
314 { BTRFS_ORDERED_NOCOW, "NOCOW" }, \
315 { BTRFS_ORDERED_COMPRESSED, "COMPRESSED" }, \
316 { BTRFS_ORDERED_PREALLOC, "PREALLOC" }, \
317 { BTRFS_ORDERED_DIRECT, "DIRECT" })
318
319 #endif
320
321 DECLARE_EVENT_CLASS(btrfs__ordered_extent,
322
323 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
324
325 TP_ARGS(inode, ordered),
326
327 TP_STRUCT__entry(
328 __field( ino_t, ino )
329 __field( u64, file_offset )
330 __field( u64, start )
331 __field( u64, len )
332 __field( u64, disk_len )
333 __field( u64, bytes_left )
334 __field( unsigned long, flags )
335 __field( int, compress_type )
336 __field( int, refs )
337 __field( u64, root_objectid )
338 ),
339
340 TP_fast_assign(
341 tp_assign(ino, inode->i_ino)
342 tp_assign(file_offset, ordered->file_offset)
343 tp_assign(start, ordered->start)
344 tp_assign(len, ordered->len)
345 tp_assign(disk_len, ordered->disk_len)
346 tp_assign(bytes_left, ordered->bytes_left)
347 tp_assign(flags, ordered->flags)
348 tp_assign(compress_type, ordered->compress_type)
349 tp_assign(refs, atomic_read(&ordered->refs))
350 tp_assign(root_objectid,
351 BTRFS_I(inode)->root->root_key.objectid)
352 ),
353
354 TP_printk("root = %llu(%s), ino = %llu, file_offset = %llu, "
355 "start = %llu, len = %llu, disk_len = %llu, "
356 "bytes_left = %llu, flags = %s, compress_type = %d, "
357 "refs = %d",
358 show_root_type(__entry->root_objectid),
359 (unsigned long long)__entry->ino,
360 (unsigned long long)__entry->file_offset,
361 (unsigned long long)__entry->start,
362 (unsigned long long)__entry->len,
363 (unsigned long long)__entry->disk_len,
364 (unsigned long long)__entry->bytes_left,
365 show_ordered_flags(__entry->flags),
366 __entry->compress_type, __entry->refs)
367 )
368
369 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
370
371 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
372
373 TP_ARGS(inode, ordered)
374 )
375
376 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
377
378 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
379
380 TP_ARGS(inode, ordered)
381 )
382
383 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
384
385 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
386
387 TP_ARGS(inode, ordered)
388 )
389
390 DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
391
392 TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
393
394 TP_ARGS(inode, ordered)
395 )
396
397 DECLARE_EVENT_CLASS(btrfs__writepage,
398
399 TP_PROTO(struct page *page, struct inode *inode,
400 struct writeback_control *wbc),
401
402 TP_ARGS(page, inode, wbc),
403
404 TP_STRUCT__entry(
405 __field( ino_t, ino )
406 __field( pgoff_t, index )
407 __field( long, nr_to_write )
408 __field( long, pages_skipped )
409 __field( loff_t, range_start )
410 __field( loff_t, range_end )
411 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
412 __field( char, nonblocking )
413 #endif
414 __field( char, for_kupdate )
415 __field( char, for_reclaim )
416 __field( char, range_cyclic )
417 __field( pgoff_t, writeback_index )
418 __field( u64, root_objectid )
419 ),
420
421 TP_fast_assign(
422 tp_assign(ino, inode->i_ino)
423 tp_assign(index, page->index)
424 tp_assign(nr_to_write, wbc->nr_to_write)
425 tp_assign(pages_skipped, wbc->pages_skipped)
426 tp_assign(range_start, wbc->range_start)
427 tp_assign(range_end, wbc->range_end)
428 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
429 tp_assign(nonblocking, wbc->nonblocking)
430 #endif
431 tp_assign(for_kupdate, wbc->for_kupdate)
432 tp_assign(for_reclaim, wbc->for_reclaim)
433 tp_assign(range_cyclic, wbc->range_cyclic)
434 tp_assign(writeback_index, inode->i_mapping->writeback_index)
435 tp_assign(root_objectid,
436 BTRFS_I(inode)->root->root_key.objectid)
437 ),
438
439 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))
440 TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
441 "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
442 "range_end = %llu, nonblocking = %d, for_kupdate = %d, "
443 "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
444 show_root_type(__entry->root_objectid),
445 (unsigned long)__entry->ino, __entry->index,
446 __entry->nr_to_write, __entry->pages_skipped,
447 __entry->range_start, __entry->range_end,
448 __entry->nonblocking, __entry->for_kupdate,
449 __entry->for_reclaim, __entry->range_cyclic,
450 (unsigned long)__entry->writeback_index)
451 #else
452 TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
453 "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
454 "range_end = %llu, for_kupdate = %d, "
455 "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
456 show_root_type(__entry->root_objectid),
457 (unsigned long)__entry->ino, __entry->index,
458 __entry->nr_to_write, __entry->pages_skipped,
459 __entry->range_start, __entry->range_end,
460 __entry->for_kupdate,
461 __entry->for_reclaim, __entry->range_cyclic,
462 (unsigned long)__entry->writeback_index)
463 #endif
464 )
465
466 DEFINE_EVENT(btrfs__writepage, __extent_writepage,
467
468 TP_PROTO(struct page *page, struct inode *inode,
469 struct writeback_control *wbc),
470
471 TP_ARGS(page, inode, wbc)
472 )
473
474 TRACE_EVENT(btrfs_writepage_end_io_hook,
475
476 TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
477
478 TP_ARGS(page, start, end, uptodate),
479
480 TP_STRUCT__entry(
481 __field( ino_t, ino )
482 __field( pgoff_t, index )
483 __field( u64, start )
484 __field( u64, end )
485 __field( int, uptodate )
486 __field( u64, root_objectid )
487 ),
488
489 TP_fast_assign(
490 tp_assign(ino, page->mapping->host->i_ino)
491 tp_assign(index, page->index)
492 tp_assign(start, start)
493 tp_assign(end, end)
494 tp_assign(uptodate, uptodate)
495 tp_assign(root_objectid,
496 BTRFS_I(page->mapping->host)->root->root_key.objectid)
497 ),
498
499 TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, start = %llu, "
500 "end = %llu, uptodate = %d",
501 show_root_type(__entry->root_objectid),
502 (unsigned long)__entry->ino, (unsigned long)__entry->index,
503 (unsigned long long)__entry->start,
504 (unsigned long long)__entry->end, __entry->uptodate)
505 )
506
507 TRACE_EVENT(btrfs_sync_file,
508
509 TP_PROTO(struct file *file, int datasync),
510
511 TP_ARGS(file, datasync),
512
513 TP_STRUCT__entry(
514 __field( ino_t, ino )
515 __field( ino_t, parent )
516 __field( int, datasync )
517 __field( u64, root_objectid )
518 ),
519
520 TP_fast_assign(
521 tp_assign(ino, file->f_path.dentry->d_inode->i_ino)
522 tp_assign(parent, file->f_path.dentry->d_parent->d_inode->i_ino)
523 tp_assign(datasync, datasync)
524 tp_assign(root_objectid,
525 BTRFS_I(file->f_path.dentry->d_inode)->root->root_key.objectid)
526 ),
527
528 TP_printk("root = %llu(%s), ino = %ld, parent = %ld, datasync = %d",
529 show_root_type(__entry->root_objectid),
530 (unsigned long)__entry->ino, (unsigned long)__entry->parent,
531 __entry->datasync)
532 )
533
534 TRACE_EVENT(btrfs_sync_fs,
535
536 TP_PROTO(int wait),
537
538 TP_ARGS(wait),
539
540 TP_STRUCT__entry(
541 __field( int, wait )
542 ),
543
544 TP_fast_assign(
545 tp_assign(wait, wait)
546 ),
547
548 TP_printk("wait = %d", __entry->wait)
549 )
550
551 #define show_ref_action(action) \
552 __print_symbolic(action, \
553 { BTRFS_ADD_DELAYED_REF, "ADD_DELAYED_REF" }, \
554 { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \
555 { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \
556 { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
557
558
559 TRACE_EVENT(btrfs_delayed_tree_ref,
560
561 TP_PROTO(struct btrfs_delayed_ref_node *ref,
562 struct btrfs_delayed_tree_ref *full_ref,
563 int action),
564
565 TP_ARGS(ref, full_ref, action),
566
567 TP_STRUCT__entry(
568 __field( u64, bytenr )
569 __field( u64, num_bytes )
570 __field( int, action )
571 __field( u64, parent )
572 __field( u64, ref_root )
573 __field( int, level )
574 __field( int, type )
575 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
576 __field( u64, seq )
577 #endif
578 ),
579
580 TP_fast_assign(
581 tp_assign(bytenr, ref->bytenr)
582 tp_assign(num_bytes, ref->num_bytes)
583 tp_assign(action, action)
584 tp_assign(parent, full_ref->parent)
585 tp_assign(ref_root, full_ref->root)
586 tp_assign(level, full_ref->level)
587 tp_assign(type, ref->type)
588 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
589 tp_assign(seq, ref->seq)
590 #endif
591 ),
592
593 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
594 TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
595 "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
596 "type = %s, seq = %llu",
597 #else
598 TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
599 "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
600 "type = %s",
601 #endif
602 (unsigned long long)__entry->bytenr,
603 (unsigned long long)__entry->num_bytes,
604 show_ref_action(__entry->action),
605 show_root_type(__entry->parent),
606 show_root_type(__entry->ref_root),
607 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
608 __entry->level, show_ref_type(__entry->type),
609 (unsigned long long)__entry->seq)
610 #else
611 __entry->level, show_ref_type(__entry->type))
612 #endif
613 )
614
615 TRACE_EVENT(btrfs_delayed_data_ref,
616
617 TP_PROTO(struct btrfs_delayed_ref_node *ref,
618 struct btrfs_delayed_data_ref *full_ref,
619 int action),
620
621 TP_ARGS(ref, full_ref, action),
622
623 TP_STRUCT__entry(
624 __field( u64, bytenr )
625 __field( u64, num_bytes )
626 __field( int, action )
627 __field( u64, parent )
628 __field( u64, ref_root )
629 __field( u64, owner )
630 __field( u64, offset )
631 __field( int, type )
632 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
633 __field( u64, seq )
634 #endif
635 ),
636
637 TP_fast_assign(
638 tp_assign(bytenr, ref->bytenr)
639 tp_assign(num_bytes, ref->num_bytes)
640 tp_assign(action, action)
641 tp_assign(parent, full_ref->parent)
642 tp_assign(ref_root, full_ref->root)
643 tp_assign(owner, full_ref->objectid)
644 tp_assign(offset, full_ref->offset)
645 tp_assign(type, ref->type)
646 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
647 tp_assign(seq, ref->seq)
648 #endif
649 ),
650
651 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
652 TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
653 "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
654 "offset = %llu, type = %s, seq = %llu",
655 #else
656 TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
657 "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
658 "offset = %llu, type = %s",
659 #endif
660 (unsigned long long)__entry->bytenr,
661 (unsigned long long)__entry->num_bytes,
662 show_ref_action(__entry->action),
663 show_root_type(__entry->parent),
664 show_root_type(__entry->ref_root),
665 (unsigned long long)__entry->owner,
666 (unsigned long long)__entry->offset,
667 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
668 show_ref_type(__entry->type),
669 (unsigned long long)__entry->seq)
670 #else
671 show_ref_type(__entry->type))
672 #endif
673 )
674
675 TRACE_EVENT(btrfs_delayed_ref_head,
676
677 TP_PROTO(struct btrfs_delayed_ref_node *ref,
678 struct btrfs_delayed_ref_head *head_ref,
679 int action),
680
681 TP_ARGS(ref, head_ref, action),
682
683 TP_STRUCT__entry(
684 __field( u64, bytenr )
685 __field( u64, num_bytes )
686 __field( int, action )
687 __field( int, is_data )
688 ),
689
690 TP_fast_assign(
691 tp_assign(bytenr, ref->bytenr)
692 tp_assign(num_bytes, ref->num_bytes)
693 tp_assign(action, action)
694 tp_assign(is_data, head_ref->is_data)
695 ),
696
697 TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, is_data = %d",
698 (unsigned long long)__entry->bytenr,
699 (unsigned long long)__entry->num_bytes,
700 show_ref_action(__entry->action),
701 __entry->is_data)
702 )
703
704 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,11,0))
705
706 #define show_chunk_type(type) \
707 __print_flags(type, "|", \
708 { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
709 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
710 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
711 { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
712 { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
713 { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
714 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"}, \
715 { BTRFS_BLOCK_GROUP_RAID5, "RAID5" }, \
716 { BTRFS_BLOCK_GROUP_RAID6, "RAID6" })
717
718 #else
719
720 #define show_chunk_type(type) \
721 __print_flags(type, "|", \
722 { BTRFS_BLOCK_GROUP_DATA, "DATA" }, \
723 { BTRFS_BLOCK_GROUP_SYSTEM, "SYSTEM"}, \
724 { BTRFS_BLOCK_GROUP_METADATA, "METADATA"}, \
725 { BTRFS_BLOCK_GROUP_RAID0, "RAID0" }, \
726 { BTRFS_BLOCK_GROUP_RAID1, "RAID1" }, \
727 { BTRFS_BLOCK_GROUP_DUP, "DUP" }, \
728 { BTRFS_BLOCK_GROUP_RAID10, "RAID10"})
729
730 #endif
731
732 DECLARE_EVENT_CLASS(btrfs__chunk,
733
734 TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
735 u64 offset, u64 size),
736
737 TP_ARGS(root, map, offset, size),
738
739 TP_STRUCT__entry(
740 __field( int, num_stripes )
741 __field( u64, type )
742 __field( int, sub_stripes )
743 __field( u64, offset )
744 __field( u64, size )
745 __field( u64, root_objectid )
746 ),
747
748 TP_fast_assign(
749 tp_assign(num_stripes, map->num_stripes)
750 tp_assign(type, map->type)
751 tp_assign(sub_stripes, map->sub_stripes)
752 tp_assign(offset, offset)
753 tp_assign(size, size)
754 tp_assign(root_objectid, root->root_key.objectid)
755 ),
756
757 TP_printk("root = %llu(%s), offset = %llu, size = %llu, "
758 "num_stripes = %d, sub_stripes = %d, type = %s",
759 show_root_type(__entry->root_objectid),
760 (unsigned long long)__entry->offset,
761 (unsigned long long)__entry->size,
762 __entry->num_stripes, __entry->sub_stripes,
763 show_chunk_type(__entry->type))
764 )
765
766 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_alloc,
767
768 TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
769 u64 offset, u64 size),
770
771 TP_ARGS(root, map, offset, size)
772 )
773
774 DEFINE_EVENT(btrfs__chunk, btrfs_chunk_free,
775
776 TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
777 u64 offset, u64 size),
778
779 TP_ARGS(root, map, offset, size)
780 )
781
782 TRACE_EVENT(btrfs_cow_block,
783
784 TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
785 struct extent_buffer *cow),
786
787 TP_ARGS(root, buf, cow),
788
789 TP_STRUCT__entry(
790 __field( u64, root_objectid )
791 __field( u64, buf_start )
792 __field( int, refs )
793 __field( u64, cow_start )
794 __field( int, buf_level )
795 __field( int, cow_level )
796 ),
797
798 TP_fast_assign(
799 tp_assign(root_objectid, root->root_key.objectid)
800 tp_assign(buf_start, buf->start)
801 tp_assign(refs, atomic_read(&buf->refs))
802 tp_assign(cow_start, cow->start)
803 tp_assign(buf_level, btrfs_header_level(buf))
804 tp_assign(cow_level, btrfs_header_level(cow))
805 ),
806
807 TP_printk("root = %llu(%s), refs = %d, orig_buf = %llu "
808 "(orig_level = %d), cow_buf = %llu (cow_level = %d)",
809 show_root_type(__entry->root_objectid),
810 __entry->refs,
811 (unsigned long long)__entry->buf_start,
812 __entry->buf_level,
813 (unsigned long long)__entry->cow_start,
814 __entry->cow_level)
815 )
816
817 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
818 TRACE_EVENT(btrfs_space_reservation,
819
820 TP_PROTO(struct btrfs_fs_info *fs_info, char *type, u64 val,
821 u64 bytes, int reserve),
822
823 TP_ARGS(fs_info, type, val, bytes, reserve),
824
825 TP_STRUCT__entry(
826 __array( u8, fsid, BTRFS_UUID_SIZE )
827 __string( type, type )
828 __field( u64, val )
829 __field( u64, bytes )
830 __field( int, reserve )
831 ),
832
833 TP_fast_assign(
834 tp_memcpy(fsid, fs_info->fsid, BTRFS_UUID_SIZE)
835 tp_strcpy(type, type)
836 tp_assign(val, val)
837 tp_assign(bytes, bytes)
838 tp_assign(reserve, reserve)
839 ),
840
841 TP_printk("%pU: %s: %Lu %s %Lu", __entry->fsid, __get_str(type),
842 __entry->val, __entry->reserve ? "reserve" : "release",
843 __entry->bytes)
844 )
845 #endif
846
847 DECLARE_EVENT_CLASS(btrfs__reserved_extent,
848
849 TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
850
851 TP_ARGS(root, start, len),
852
853 TP_STRUCT__entry(
854 __field( u64, root_objectid )
855 __field( u64, start )
856 __field( u64, len )
857 ),
858
859 TP_fast_assign(
860 tp_assign(root_objectid, root->root_key.objectid)
861 tp_assign(start, start)
862 tp_assign(len, len)
863 ),
864
865 TP_printk("root = %llu(%s), start = %llu, len = %llu",
866 show_root_type(__entry->root_objectid),
867 (unsigned long long)__entry->start,
868 (unsigned long long)__entry->len)
869 )
870
871 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_alloc,
872
873 TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
874
875 TP_ARGS(root, start, len)
876 )
877
878 DEFINE_EVENT(btrfs__reserved_extent, btrfs_reserved_extent_free,
879
880 TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
881
882 TP_ARGS(root, start, len)
883 )
884
885 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0))
886 TRACE_EVENT_MAP(find_free_extent,
887
888 btrfs_find_free_extent,
889
890 TP_PROTO(struct btrfs_root *root, u64 num_bytes, u64 empty_size,
891 u64 data),
892
893 TP_ARGS(root, num_bytes, empty_size, data),
894
895 TP_STRUCT__entry(
896 __field( u64, root_objectid )
897 __field( u64, num_bytes )
898 __field( u64, empty_size )
899 __field( u64, data )
900 ),
901
902 TP_fast_assign(
903 tp_assign(root_objectid, root->root_key.objectid)
904 tp_assign(num_bytes, num_bytes)
905 tp_assign(empty_size, empty_size)
906 tp_assign(data, data)
907 ),
908
909 TP_printk("root = %Lu(%s), len = %Lu, empty_size = %Lu, "
910 "flags = %Lu(%s)", show_root_type(__entry->root_objectid),
911 __entry->num_bytes, __entry->empty_size, __entry->data,
912 __print_flags((unsigned long)__entry->data, "|",
913 BTRFS_GROUP_FLAGS))
914 )
915
916 DECLARE_EVENT_CLASS(btrfs__reserve_extent,
917
918 TP_PROTO(struct btrfs_root *root,
919 struct btrfs_block_group_cache *block_group, u64 start,
920 u64 len),
921
922 TP_ARGS(root, block_group, start, len),
923
924 TP_STRUCT__entry(
925 __field( u64, root_objectid )
926 __field( u64, bg_objectid )
927 __field( u64, flags )
928 __field( u64, start )
929 __field( u64, len )
930 ),
931
932 TP_fast_assign(
933 tp_assign(root_objectid, root->root_key.objectid)
934 tp_assign(bg_objectid, block_group->key.objectid)
935 tp_assign(flags, block_group->flags)
936 tp_assign(start, start)
937 tp_assign(len, len)
938 ),
939
940 TP_printk("root = %Lu(%s), block_group = %Lu, flags = %Lu(%s), "
941 "start = %Lu, len = %Lu",
942 show_root_type(__entry->root_objectid), __entry->bg_objectid,
943 __entry->flags, __print_flags((unsigned long)__entry->flags,
944 "|", BTRFS_GROUP_FLAGS),
945 __entry->start, __entry->len)
946 )
947
948 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent,
949
950 TP_PROTO(struct btrfs_root *root,
951 struct btrfs_block_group_cache *block_group, u64 start,
952 u64 len),
953
954 TP_ARGS(root, block_group, start, len)
955 )
956
957 DEFINE_EVENT(btrfs__reserve_extent, btrfs_reserve_extent_cluster,
958
959 TP_PROTO(struct btrfs_root *root,
960 struct btrfs_block_group_cache *block_group, u64 start,
961 u64 len),
962
963 TP_ARGS(root, block_group, start, len)
964 )
965
966 TRACE_EVENT(btrfs_find_cluster,
967
968 TP_PROTO(struct btrfs_block_group_cache *block_group, u64 start,
969 u64 bytes, u64 empty_size, u64 min_bytes),
970
971 TP_ARGS(block_group, start, bytes, empty_size, min_bytes),
972
973 TP_STRUCT__entry(
974 __field( u64, bg_objectid )
975 __field( u64, flags )
976 __field( u64, start )
977 __field( u64, bytes )
978 __field( u64, empty_size )
979 __field( u64, min_bytes )
980 ),
981
982 TP_fast_assign(
983 tp_assign(bg_objectid, block_group->key.objectid)
984 tp_assign(flags, block_group->flags)
985 tp_assign(start, start)
986 tp_assign(bytes, bytes)
987 tp_assign(empty_size, empty_size)
988 tp_assign(min_bytes, min_bytes)
989 ),
990
991 TP_printk("block_group = %Lu, flags = %Lu(%s), start = %Lu, len = %Lu,"
992 " empty_size = %Lu, min_bytes = %Lu", __entry->bg_objectid,
993 __entry->flags,
994 __print_flags((unsigned long)__entry->flags, "|",
995 BTRFS_GROUP_FLAGS), __entry->start,
996 __entry->bytes, __entry->empty_size, __entry->min_bytes)
997 )
998
999 TRACE_EVENT(btrfs_failed_cluster_setup,
1000
1001 TP_PROTO(struct btrfs_block_group_cache *block_group),
1002
1003 TP_ARGS(block_group),
1004
1005 TP_STRUCT__entry(
1006 __field( u64, bg_objectid )
1007 ),
1008
1009 TP_fast_assign(
1010 tp_assign(bg_objectid, block_group->key.objectid)
1011 ),
1012
1013 TP_printk("block_group = %Lu", __entry->bg_objectid)
1014 )
1015
1016 TRACE_EVENT(btrfs_setup_cluster,
1017
1018 TP_PROTO(struct btrfs_block_group_cache *block_group,
1019 struct btrfs_free_cluster *cluster, u64 size, int bitmap),
1020
1021 TP_ARGS(block_group, cluster, size, bitmap),
1022
1023 TP_STRUCT__entry(
1024 __field( u64, bg_objectid )
1025 __field( u64, flags )
1026 __field( u64, start )
1027 __field( u64, max_size )
1028 __field( u64, size )
1029 __field( int, bitmap )
1030 ),
1031
1032 TP_fast_assign(
1033 tp_assign(bg_objectid, block_group->key.objectid)
1034 tp_assign(flags, block_group->flags)
1035 tp_assign(start, cluster->window_start)
1036 tp_assign(max_size, cluster->max_size)
1037 tp_assign(size, size)
1038 tp_assign(bitmap, bitmap)
1039 ),
1040
1041 TP_printk("block_group = %Lu, flags = %Lu(%s), window_start = %Lu, "
1042 "size = %Lu, max_size = %Lu, bitmap = %d",
1043 __entry->bg_objectid,
1044 __entry->flags,
1045 __print_flags((unsigned long)__entry->flags, "|",
1046 BTRFS_GROUP_FLAGS), __entry->start,
1047 __entry->size, __entry->max_size, __entry->bitmap)
1048 )
1049 #endif
1050
1051 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
1052 TRACE_EVENT_MAP(alloc_extent_state,
1053
1054 btrfs_alloc_extent_state,
1055
1056 TP_PROTO(struct extent_state *state, gfp_t mask, unsigned long IP),
1057
1058 TP_ARGS(state, mask, IP),
1059
1060 TP_STRUCT__entry(
1061 __field(struct extent_state *, state)
1062 __field(gfp_t, mask)
1063 __field(unsigned long, ip)
1064 ),
1065
1066 TP_fast_assign(
1067 tp_assign(state, state)
1068 tp_assign(mask, mask)
1069 tp_assign(ip, IP)
1070 ),
1071
1072 TP_printk("state=%p; mask = %s; caller = %pF", __entry->state,
1073 show_gfp_flags(__entry->mask), (void *)__entry->ip)
1074 )
1075
1076 TRACE_EVENT_MAP(free_extent_state,
1077
1078 btrfs_free_extent_state,
1079
1080 TP_PROTO(struct extent_state *state, unsigned long IP),
1081
1082 TP_ARGS(state, IP),
1083
1084 TP_STRUCT__entry(
1085 __field(struct extent_state *, state)
1086 __field(unsigned long, ip)
1087 ),
1088
1089 TP_fast_assign(
1090 tp_assign(state, state)
1091 tp_assign(ip, IP)
1092 ),
1093
1094 TP_printk(" state=%p; caller = %pF", __entry->state,
1095 (void *)__entry->ip)
1096 )
1097 #endif
1098
1099 #endif /* _TRACE_BTRFS_H */
1100
1101 /* This part must be outside protection */
1102 #include "../../../probes/define_trace.h"
LTTng 2.0/0.x modules
This page took 0.05124 seconds and 5 git commands to generate.