1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Assorted bcache debug code |
4 | * |
5 | * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com> |
6 | * Copyright 2012 Google, Inc. |
7 | */ |
8 | |
9 | #include "bcache.h" |
10 | #include "btree.h" |
11 | #include "debug.h" |
12 | #include "extents.h" |
13 | |
14 | #include <linux/console.h> |
15 | #include <linux/debugfs.h> |
16 | #include <linux/module.h> |
17 | #include <linux/random.h> |
18 | #include <linux/seq_file.h> |
19 | |
20 | struct dentry *bcache_debug; |
21 | |
22 | #ifdef CONFIG_BCACHE_DEBUG |
23 | |
24 | #define for_each_written_bset(b, start, i) \ |
25 | for (i = (start); \ |
26 | (void *) i < (void *) (start) + (KEY_SIZE(&b->key) << 9) &&\ |
27 | i->seq == (start)->seq; \ |
28 | i = (void *) i + set_blocks(i, block_bytes(b->c->cache)) * \ |
29 | block_bytes(b->c->cache)) |
30 | |
31 | void bch_btree_verify(struct btree *b) |
32 | { |
33 | struct btree *v = b->c->verify_data; |
34 | struct bset *ondisk, *sorted, *inmemory; |
35 | struct bio *bio; |
36 | |
37 | if (!b->c->verify || !b->c->verify_ondisk) |
38 | return; |
39 | |
40 | down(sem: &b->io_mutex); |
41 | mutex_lock(&b->c->verify_lock); |
42 | |
43 | ondisk = b->c->verify_ondisk; |
44 | sorted = b->c->verify_data->keys.set->data; |
45 | inmemory = b->keys.set->data; |
46 | |
47 | bkey_copy(&v->key, &b->key); |
48 | v->written = 0; |
49 | v->level = b->level; |
50 | v->keys.ops = b->keys.ops; |
51 | |
52 | bio = bch_bbio_alloc(c: b->c); |
53 | bio_set_dev(bio, bdev: b->c->cache->bdev); |
54 | bio->bi_iter.bi_sector = PTR_OFFSET(k: &b->key, i: 0); |
55 | bio->bi_iter.bi_size = KEY_SIZE(k: &v->key) << 9; |
56 | bio->bi_opf = REQ_OP_READ | REQ_META; |
57 | bch_bio_map(bio, base: sorted); |
58 | |
59 | submit_bio_wait(bio); |
60 | bch_bbio_free(bio, c: b->c); |
61 | |
62 | memcpy(ondisk, sorted, KEY_SIZE(&v->key) << 9); |
63 | |
64 | bch_btree_node_read_done(b: v); |
65 | sorted = v->keys.set->data; |
66 | |
67 | if (inmemory->keys != sorted->keys || |
68 | memcmp(p: inmemory->start, |
69 | q: sorted->start, |
70 | size: (void *) bset_bkey_last(inmemory) - |
71 | (void *) inmemory->start)) { |
72 | struct bset *i; |
73 | unsigned int j; |
74 | |
75 | console_lock(); |
76 | |
77 | pr_err("*** in memory:\n" ); |
78 | bch_dump_bset(b: &b->keys, i: inmemory, set: 0); |
79 | |
80 | pr_err("*** read back in:\n" ); |
81 | bch_dump_bset(b: &v->keys, i: sorted, set: 0); |
82 | |
83 | for_each_written_bset(b, ondisk, i) { |
84 | unsigned int block = ((void *) i - (void *) ondisk) / |
85 | block_bytes(b->c->cache); |
86 | |
87 | pr_err("*** on disk block %u:\n" , block); |
88 | bch_dump_bset(b: &b->keys, i, set: block); |
89 | } |
90 | |
91 | pr_err("*** block %zu not written\n" , |
92 | ((void *) i - (void *) ondisk) / block_bytes(b->c->cache)); |
93 | |
94 | for (j = 0; j < inmemory->keys; j++) |
95 | if (inmemory->d[j] != sorted->d[j]) |
96 | break; |
97 | |
98 | pr_err("b->written %u\n" , b->written); |
99 | |
100 | console_unlock(); |
101 | panic(fmt: "verify failed at %u\n" , j); |
102 | } |
103 | |
104 | mutex_unlock(lock: &b->c->verify_lock); |
105 | up(sem: &b->io_mutex); |
106 | } |
107 | |
108 | void bch_data_verify(struct cached_dev *dc, struct bio *bio) |
109 | { |
110 | unsigned int nr_segs = bio_segments(bio); |
111 | struct bio *check; |
112 | struct bio_vec bv, cbv; |
113 | struct bvec_iter iter, citer = { 0 }; |
114 | |
115 | check = bio_kmalloc(nr_vecs: nr_segs, GFP_NOIO); |
116 | if (!check) |
117 | return; |
118 | bio_init(bio: check, bdev: bio->bi_bdev, table: check->bi_inline_vecs, max_vecs: nr_segs, |
119 | opf: REQ_OP_READ); |
120 | check->bi_iter.bi_sector = bio->bi_iter.bi_sector; |
121 | check->bi_iter.bi_size = bio->bi_iter.bi_size; |
122 | |
123 | bch_bio_map(bio: check, NULL); |
124 | if (bch_bio_alloc_pages(bio: check, GFP_NOIO)) |
125 | goto out_put; |
126 | |
127 | submit_bio_wait(bio: check); |
128 | |
129 | citer.bi_size = UINT_MAX; |
130 | bio_for_each_segment(bv, bio, iter) { |
131 | void *p1 = bvec_kmap_local(bvec: &bv); |
132 | void *p2; |
133 | |
134 | cbv = bio_iter_iovec(check, citer); |
135 | p2 = bvec_kmap_local(bvec: &cbv); |
136 | |
137 | cache_set_err_on(memcmp(p1, p2, bv.bv_len), |
138 | dc->disk.c, |
139 | "verify failed at dev %pg sector %llu" , |
140 | dc->bdev, |
141 | (uint64_t) bio->bi_iter.bi_sector); |
142 | |
143 | kunmap_local(p2); |
144 | kunmap_local(p1); |
145 | bio_advance_iter(bio: check, iter: &citer, bytes: bv.bv_len); |
146 | } |
147 | |
148 | bio_free_pages(bio: check); |
149 | out_put: |
150 | bio_uninit(check); |
151 | kfree(objp: check); |
152 | } |
153 | |
154 | #endif |
155 | |
156 | #ifdef CONFIG_DEBUG_FS |
157 | |
158 | /* XXX: cache set refcounting */ |
159 | |
160 | struct dump_iterator { |
161 | char buf[PAGE_SIZE]; |
162 | size_t bytes; |
163 | struct cache_set *c; |
164 | struct keybuf keys; |
165 | }; |
166 | |
167 | static bool dump_pred(struct keybuf *buf, struct bkey *k) |
168 | { |
169 | return true; |
170 | } |
171 | |
172 | static ssize_t bch_dump_read(struct file *file, char __user *buf, |
173 | size_t size, loff_t *ppos) |
174 | { |
175 | struct dump_iterator *i = file->private_data; |
176 | ssize_t ret = 0; |
177 | char kbuf[80]; |
178 | |
179 | while (size) { |
180 | struct keybuf_key *w; |
181 | unsigned int bytes = min(i->bytes, size); |
182 | |
183 | if (copy_to_user(to: buf, from: i->buf, n: bytes)) |
184 | return -EFAULT; |
185 | |
186 | ret += bytes; |
187 | buf += bytes; |
188 | size -= bytes; |
189 | i->bytes -= bytes; |
190 | memmove(i->buf, i->buf + bytes, i->bytes); |
191 | |
192 | if (i->bytes) |
193 | break; |
194 | |
195 | w = bch_keybuf_next_rescan(c: i->c, buf: &i->keys, end: &MAX_KEY, pred: dump_pred); |
196 | if (!w) |
197 | break; |
198 | |
199 | bch_extent_to_text(buf: kbuf, size: sizeof(kbuf), k: &w->key); |
200 | i->bytes = snprintf(buf: i->buf, PAGE_SIZE, fmt: "%s\n" , kbuf); |
201 | bch_keybuf_del(buf: &i->keys, w); |
202 | } |
203 | |
204 | return ret; |
205 | } |
206 | |
207 | static int bch_dump_open(struct inode *inode, struct file *file) |
208 | { |
209 | struct cache_set *c = inode->i_private; |
210 | struct dump_iterator *i; |
211 | |
212 | i = kzalloc(size: sizeof(struct dump_iterator), GFP_KERNEL); |
213 | if (!i) |
214 | return -ENOMEM; |
215 | |
216 | file->private_data = i; |
217 | i->c = c; |
218 | bch_keybuf_init(buf: &i->keys); |
219 | i->keys.last_scanned = KEY(0, 0, 0); |
220 | |
221 | return 0; |
222 | } |
223 | |
224 | static int bch_dump_release(struct inode *inode, struct file *file) |
225 | { |
226 | kfree(objp: file->private_data); |
227 | return 0; |
228 | } |
229 | |
230 | static const struct file_operations cache_set_debug_ops = { |
231 | .owner = THIS_MODULE, |
232 | .open = bch_dump_open, |
233 | .read = bch_dump_read, |
234 | .release = bch_dump_release |
235 | }; |
236 | |
237 | void bch_debug_init_cache_set(struct cache_set *c) |
238 | { |
239 | if (!IS_ERR_OR_NULL(ptr: bcache_debug)) { |
240 | char name[50]; |
241 | |
242 | snprintf(buf: name, size: 50, fmt: "bcache-%pU" , c->set_uuid); |
243 | c->debug = debugfs_create_file(name, mode: 0400, parent: bcache_debug, data: c, |
244 | fops: &cache_set_debug_ops); |
245 | } |
246 | } |
247 | |
248 | #endif |
249 | |
250 | void bch_debug_exit(void) |
251 | { |
252 | debugfs_remove_recursive(dentry: bcache_debug); |
253 | } |
254 | |
255 | void __init bch_debug_init(void) |
256 | { |
257 | /* |
258 | * it is unnecessary to check return value of |
259 | * debugfs_create_file(), we should not care |
260 | * about this. |
261 | */ |
262 | bcache_debug = debugfs_create_dir(name: "bcache" , NULL); |
263 | } |
264 | |