Merge branch 'upstream' of git://git.infradead.org/users/pcmoore/audit
[firefly-linux-kernel-4.4.55.git] / include / trace / events / bcache.h
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>