?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[linux/fpc-iii.git] / include / trace / events / bcache.h
blob981acf74b14f1fdbf00fc2c7bd915c82a9b37c3c
1 #undef TRACE_SYSTEM
2 #define TRACE_SYSTEM bcache
3
4 #if !defined(_TRACE_BCACHE_H) || defined(TRACE_HEADER_MULTI_READ)
5 #define _TRACE_BCACHE_H
6
7 #include <linux/tracepoint.h>
8
9 DECLARE_EVENT_CLASS(bcache_request,
10 TP_PROTO(struct bcache_device *d, struct bio *bio),
11 TP_ARGS(d, bio),
12
13 TP_STRUCT__entry(
14 __field(dev_t, dev )
15 __field(unsigned int, orig_major )
16 __field(unsigned int, orig_minor )
17 __field(sector_t, sector )
18 __field(dev_t, orig_sector )
19 __field(unsigned int, nr_sector )
20 __array(char, rwbs, 6 )
21 ),
22
23 TP_fast_assign(
24 __entry->dev = bio->bi_bdev->bd_dev;
25 __entry->orig_major = d->disk->major;
26 __entry->orig_minor = d->disk->first_minor;
27 __entry->sector = bio->bi_iter.bi_sector;
28 __entry->orig_sector = bio->bi_iter.bi_sector - 16;
29 __entry->nr_sector = bio->bi_iter.bi_size >> 9;
30 blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
31 ),
32
33 TP_printk("%d,%d %s %llu + %u (from %d,%d @ %llu)",
34 MAJOR(__entry->dev), MINOR(__entry->dev),
35 __entry->rwbs, (unsigned long long)__entry->sector,
36 __entry->nr_sector, __entry->orig_major, __entry->orig_minor,
37 (unsigned long long)__entry->orig_sector)
38 );
39
40 DECLARE_EVENT_CLASS(bkey,
41 TP_PROTO(struct bkey *k),
42 TP_ARGS(k),
43
44 TP_STRUCT__entry(
45 __field(u32, size )
46 __field(u32, inode )
47 __field(u64, offset )
48 __field(bool, dirty )
49 ),
50
51 TP_fast_assign(
52 __entry->inode = KEY_INODE(k);
53 __entry->offset = KEY_OFFSET(k);
54 __entry->size = KEY_SIZE(k);
55 __entry->dirty = KEY_DIRTY(k);
56 ),
57
58 TP_printk("%u:%llu len %u dirty %u", __entry->inode,
59 __entry->offset, __entry->size, __entry->dirty)
60 );
61
62 DECLARE_EVENT_CLASS(btree_node,
63 TP_PROTO(struct btree *b),
64 TP_ARGS(b),
65
66 TP_STRUCT__entry(
67 __field(size_t, bucket )
68 ),
69
70 TP_fast_assign(
71 __entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);
72 ),
73
74 TP_printk("bucket %zu", __entry->bucket)
75 );
76
77 /* request.c */
78
79 DEFINE_EVENT(bcache_request, bcache_request_start,
80 TP_PROTO(struct bcache_device *d, struct bio *bio),
81 TP_ARGS(d, bio)
82 );
83
84 DEFINE_EVENT(bcache_request, bcache_request_end,
85 TP_PROTO(struct bcache_device *d, struct bio *bio),
86 TP_ARGS(d, bio)
87 );
88
89 DECLARE_EVENT_CLASS(bcache_bio,
90 TP_PROTO(struct bio *bio),
91 TP_ARGS(bio),
92
93 TP_STRUCT__entry(
94 __field(dev_t, dev )
95 __field(sector_t, sector )
96 __field(unsigned int, nr_sector )
97 __array(char, rwbs, 6 )
98 ),
99
100 TP_fast_assign(
101 __entry->dev = bio->bi_bdev->bd_dev;
102 __entry->sector = bio->bi_iter.bi_sector;
103 __entry->nr_sector = bio->bi_iter.bi_size >> 9;
104 blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
105 ),
106
107 TP_printk("%d,%d %s %llu + %u",
108 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
109 (unsigned long long)__entry->sector, __entry->nr_sector)
110 );
111
112 DEFINE_EVENT(bcache_bio, bcache_bypass_sequential,
113 TP_PROTO(struct bio *bio),
114 TP_ARGS(bio)
115 );
116
117 DEFINE_EVENT(bcache_bio, bcache_bypass_congested,
118 TP_PROTO(struct bio *bio),
119 TP_ARGS(bio)
120 );
121
122 TRACE_EVENT(bcache_read,
123 TP_PROTO(struct bio *bio, bool hit, bool bypass),
124 TP_ARGS(bio, hit, bypass),
125
126 TP_STRUCT__entry(
127 __field(dev_t, dev )
128 __field(sector_t, sector )
129 __field(unsigned int, nr_sector )
130 __array(char, rwbs, 6 )
131 __field(bool, cache_hit )
132 __field(bool, bypass )
133 ),
134
135 TP_fast_assign(
136 __entry->dev = bio->bi_bdev->bd_dev;
137 __entry->sector = bio->bi_iter.bi_sector;
138 __entry->nr_sector = bio->bi_iter.bi_size >> 9;
139 blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
140 __entry->cache_hit = hit;
141 __entry->bypass = bypass;
142 ),
143
144 TP_printk("%d,%d %s %llu + %u hit %u bypass %u",
145 MAJOR(__entry->dev), MINOR(__entry->dev),
146 __entry->rwbs, (unsigned long long)__entry->sector,
147 __entry->nr_sector, __entry->cache_hit, __entry->bypass)
148 );
149
150 TRACE_EVENT(bcache_write,
151 TP_PROTO(struct cache_set *c, u64 inode, struct bio *bio,
152 bool writeback, bool bypass),
153 TP_ARGS(c, inode, bio, writeback, bypass),
154
155 TP_STRUCT__entry(
156 __array(char, uuid, 16 )
157 __field(u64, inode )
158 __field(sector_t, sector )
159 __field(unsigned int, nr_sector )
160 __array(char, rwbs, 6 )
161 __field(bool, writeback )
162 __field(bool, bypass )
163 ),
164
165 TP_fast_assign(
166 memcpy(__entry->uuid, c->sb.set_uuid, 16);
167 __entry->inode = inode;
168 __entry->sector = bio->bi_iter.bi_sector;
169 __entry->nr_sector = bio->bi_iter.bi_size >> 9;
170 blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_iter.bi_size);
171 __entry->writeback = writeback;
172 __entry->bypass = bypass;
173 ),
174
175 TP_printk("%pU inode %llu %s %llu + %u hit %u bypass %u",
176 __entry->uuid, __entry->inode,
177 __entry->rwbs, (unsigned long long)__entry->sector,
178 __entry->nr_sector, __entry->writeback, __entry->bypass)
179 );
180
181 DEFINE_EVENT(bcache_bio, bcache_read_retry,
182 TP_PROTO(struct bio *bio),
183 TP_ARGS(bio)
184 );
185
186 DEFINE_EVENT(bkey, bcache_cache_insert,
187 TP_PROTO(struct bkey *k),
188 TP_ARGS(k)
189 );
190
191 /* Journal */
192
193 DECLARE_EVENT_CLASS(cache_set,
194 TP_PROTO(struct cache_set *c),
195 TP_ARGS(c),
196
197 TP_STRUCT__entry(
198 __array(char, uuid, 16 )
199 ),
200
201 TP_fast_assign(
202 memcpy(__entry->uuid, c->sb.set_uuid, 16);
203 ),
204
205 TP_printk("%pU", __entry->uuid)
206 );
207
208 DEFINE_EVENT(bkey, bcache_journal_replay_key,
209 TP_PROTO(struct bkey *k),
210 TP_ARGS(k)
211 );
212
213 DEFINE_EVENT(cache_set, bcache_journal_full,
214 TP_PROTO(struct cache_set *c),
215 TP_ARGS(c)
216 );
217
218 DEFINE_EVENT(cache_set, bcache_journal_entry_full,
219 TP_PROTO(struct cache_set *c),
220 TP_ARGS(c)
221 );
222
223 DEFINE_EVENT(bcache_bio, bcache_journal_write,
224 TP_PROTO(struct bio *bio),
225 TP_ARGS(bio)
226 );
227
228 /* Btree */
229
230 DEFINE_EVENT(cache_set, bcache_btree_cache_cannibalize,
231 TP_PROTO(struct cache_set *c),
232 TP_ARGS(c)
233 );
234
235 DEFINE_EVENT(btree_node, bcache_btree_read,
236 TP_PROTO(struct btree *b),
237 TP_ARGS(b)
238 );
239
240 TRACE_EVENT(bcache_btree_write,
241 TP_PROTO(struct btree *b),
242 TP_ARGS(b),
243
244 TP_STRUCT__entry(
245 __field(size_t, bucket )
246 __field(unsigned, block )
247 __field(unsigned, keys )
248 ),
249
250 TP_fast_assign(
251 __entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);
252 __entry->block = b->written;
253 __entry->keys = b->keys.set[b->keys.nsets].data->keys;
254 ),
255
256 TP_printk("bucket %zu", __entry->bucket)
257 );
258
259 DEFINE_EVENT(btree_node, bcache_btree_node_alloc,
260 TP_PROTO(struct btree *b),
261 TP_ARGS(b)
262 );
263
264 DEFINE_EVENT(cache_set, bcache_btree_node_alloc_fail,
265 TP_PROTO(struct cache_set *c),
266 TP_ARGS(c)
267 );
268
269 DEFINE_EVENT(btree_node, bcache_btree_node_free,
270 TP_PROTO(struct btree *b),
271 TP_ARGS(b)
272 );
273
274 TRACE_EVENT(bcache_btree_gc_coalesce,
275 TP_PROTO(unsigned nodes),
276 TP_ARGS(nodes),
277
278 TP_STRUCT__entry(
279 __field(unsigned, nodes )
280 ),
281
282 TP_fast_assign(
283 __entry->nodes = nodes;
284 ),
285
286 TP_printk("coalesced %u nodes", __entry->nodes)
287 );
288
289 DEFINE_EVENT(cache_set, bcache_gc_start,
290 TP_PROTO(struct cache_set *c),
291 TP_ARGS(c)
292 );
293
294 DEFINE_EVENT(cache_set, bcache_gc_end,
295 TP_PROTO(struct cache_set *c),
296 TP_ARGS(c)
297 );
298
299 DEFINE_EVENT(bkey, bcache_gc_copy,
300 TP_PROTO(struct bkey *k),
301 TP_ARGS(k)
302 );
303
304 DEFINE_EVENT(bkey, bcache_gc_copy_collision,
305 TP_PROTO(struct bkey *k),
306 TP_ARGS(k)
307 );
308
309 TRACE_EVENT(bcache_btree_insert_key,
310 TP_PROTO(struct btree *b, struct bkey *k, unsigned op, unsigned status),
311 TP_ARGS(b, k, op, status),
312
313 TP_STRUCT__entry(
314 __field(u64, btree_node )
315 __field(u32, btree_level )
316 __field(u32, inode )
317 __field(u64, offset )
318 __field(u32, size )
319 __field(u8, dirty )
320 __field(u8, op )
321 __field(u8, status )
322 ),
323
324 TP_fast_assign(
325 __entry->btree_node = PTR_BUCKET_NR(b->c, &b->key, 0);
326 __entry->btree_level = b->level;
327 __entry->inode = KEY_INODE(k);
328 __entry->offset = KEY_OFFSET(k);
329 __entry->size = KEY_SIZE(k);
330 __entry->dirty = KEY_DIRTY(k);
331 __entry->op = op;
332 __entry->status = status;
333 ),
334
335 TP_printk("%u for %u at %llu(%u): %u:%llu len %u dirty %u",
336 __entry->status, __entry->op,
337 __entry->btree_node, __entry->btree_level,
338 __entry->inode, __entry->offset,
339 __entry->size, __entry->dirty)
340 );
341
342 DECLARE_EVENT_CLASS(btree_split,
343 TP_PROTO(struct btree *b, unsigned keys),
344 TP_ARGS(b, keys),
345
346 TP_STRUCT__entry(
347 __field(size_t, bucket )
348 __field(unsigned, keys )
349 ),
350
351 TP_fast_assign(
352 __entry->bucket = PTR_BUCKET_NR(b->c, &b->key, 0);
353 __entry->keys = keys;
354 ),
355
356 TP_printk("bucket %zu keys %u", __entry->bucket, __entry->keys)
357 );
358
359 DEFINE_EVENT(btree_split, bcache_btree_node_split,
360 TP_PROTO(struct btree *b, unsigned keys),
361 TP_ARGS(b, keys)
362 );
363
364 DEFINE_EVENT(btree_split, bcache_btree_node_compact,
365 TP_PROTO(struct btree *b, unsigned keys),
366 TP_ARGS(b, keys)
367 );
368
369 DEFINE_EVENT(btree_node, bcache_btree_set_root,
370 TP_PROTO(struct btree *b),
371 TP_ARGS(b)
372 );
373
374 TRACE_EVENT(bcache_keyscan,
375 TP_PROTO(unsigned nr_found,
376 unsigned start_inode, uint64_t start_offset,
377 unsigned end_inode, uint64_t end_offset),
378 TP_ARGS(nr_found,
379 start_inode, start_offset,
380 end_inode, end_offset),
381
382 TP_STRUCT__entry(
383 __field(__u32, nr_found )
384 __field(__u32, start_inode )
385 __field(__u64, start_offset )
386 __field(__u32, end_inode )
387 __field(__u64, end_offset )
388 ),
389
390 TP_fast_assign(
391 __entry->nr_found = nr_found;
392 __entry->start_inode = start_inode;
393 __entry->start_offset = start_offset;
394 __entry->end_inode = end_inode;
395 __entry->end_offset = end_offset;
396 ),
397
398 TP_printk("found %u keys from %u:%llu to %u:%llu", __entry->nr_found,
399 __entry->start_inode, __entry->start_offset,
400 __entry->end_inode, __entry->end_offset)
401 );
402
403 /* Allocator */
404
405 TRACE_EVENT(bcache_invalidate,
406 TP_PROTO(struct cache *ca, size_t bucket),
407 TP_ARGS(ca, bucket),
408
409 TP_STRUCT__entry(
410 __field(unsigned, sectors )
411 __field(dev_t, dev )
412 __field(__u64, offset )
413 ),
414
415 TP_fast_assign(
416 __entry->dev = ca->bdev->bd_dev;
417 __entry->offset = bucket << ca->set->bucket_bits;
418 __entry->sectors = GC_SECTORS_USED(&ca->buckets[bucket]);
419 ),
420
421 TP_printk("invalidated %u sectors at %d,%d sector=%llu",
422 __entry->sectors, MAJOR(__entry->dev),
423 MINOR(__entry->dev), __entry->offset)
424 );
425
426 TRACE_EVENT(bcache_alloc,
427 TP_PROTO(struct cache *ca, size_t bucket),
428 TP_ARGS(ca, bucket),
429
430 TP_STRUCT__entry(
431 __field(dev_t, dev )
432 __field(__u64, offset )
433 ),
434
435 TP_fast_assign(
436 __entry->dev = ca->bdev->bd_dev;
437 __entry->offset = bucket << ca->set->bucket_bits;
438 ),
439
440 TP_printk("allocated %d,%d sector=%llu", MAJOR(__entry->dev),
441 MINOR(__entry->dev), __entry->offset)
442 );
443
444 TRACE_EVENT(bcache_alloc_fail,
445 TP_PROTO(struct cache *ca, unsigned reserve),
446 TP_ARGS(ca, reserve),
447
448 TP_STRUCT__entry(
449 __field(dev_t, dev )
450 __field(unsigned, free )
451 __field(unsigned, free_inc )
452 __field(unsigned, blocked )
453 ),
454
455 TP_fast_assign(
456 __entry->dev = ca->bdev->bd_dev;
457 __entry->free = fifo_used(&ca->free[reserve]);
458 __entry->free_inc = fifo_used(&ca->free_inc);
459 __entry->blocked = atomic_read(&ca->set->prio_blocked);
460 ),
461
462 TP_printk("alloc fail %d,%d free %u free_inc %u blocked %u",
463 MAJOR(__entry->dev), MINOR(__entry->dev), __entry->free,
464 __entry->free_inc, __entry->blocked)
465 );
466
467 /* Background writeback */
468
469 DEFINE_EVENT(bkey, bcache_writeback,
470 TP_PROTO(struct bkey *k),
471 TP_ARGS(k)
472 );
473
474 DEFINE_EVENT(bkey, bcache_writeback_collision,
475 TP_PROTO(struct bkey *k),
476 TP_ARGS(k)
477 );
478
479 #endif /* _TRACE_BCACHE_H */
480
481 /* This part must be outside protection */
482 #include <trace/define_trace.h>
Linux with added FPC-III support