1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright (c) 2022-2024 Oracle. All Rights Reserved. |
4 | * Author: Darrick J. Wong <djwong@kernel.org> |
5 | */ |
6 | #include "xfs.h" |
7 | #include "xfs_fs.h" |
8 | #include "xfs_shared.h" |
9 | #include "xfs_format.h" |
10 | #include "xfs_log_format.h" |
11 | #include "xfs_trans.h" |
12 | #include "xfs_trans_resv.h" |
13 | #include "xfs_mount.h" |
14 | #include "xfs_defer.h" |
15 | #include "xfs_btree.h" |
16 | #include "xfs_buf_mem.h" |
17 | #include "xfs_btree_mem.h" |
18 | #include "xfs_error.h" |
19 | #include "scrub/scrub.h" |
20 | #include "scrub/rcbag_btree.h" |
21 | #include "scrub/rcbag.h" |
22 | #include "scrub/trace.h" |
23 | |
24 | struct rcbag { |
25 | struct xfs_mount *mp; |
26 | struct xfbtree xfbtree; |
27 | uint64_t nr_items; |
28 | }; |
29 | |
30 | int |
31 | rcbag_init( |
32 | struct xfs_mount *mp, |
33 | struct xfs_buftarg *btp, |
34 | struct rcbag **bagp) |
35 | { |
36 | struct rcbag *bag; |
37 | int error; |
38 | |
39 | bag = kzalloc(sizeof(struct rcbag), XCHK_GFP_FLAGS); |
40 | if (!bag) |
41 | return -ENOMEM; |
42 | |
43 | bag->nr_items = 0; |
44 | bag->mp = mp; |
45 | |
46 | error = rcbagbt_mem_init(mp, &bag->xfbtree, btp); |
47 | if (error) |
48 | goto out_bag; |
49 | |
50 | *bagp = bag; |
51 | return 0; |
52 | |
53 | out_bag: |
54 | kfree(bag); |
55 | return error; |
56 | } |
57 | |
58 | void |
59 | rcbag_free( |
60 | struct rcbag **bagp) |
61 | { |
62 | struct rcbag *bag = *bagp; |
63 | |
64 | xfbtree_destroy(&bag->xfbtree); |
65 | kfree(bag); |
66 | *bagp = NULL; |
67 | } |
68 | |
69 | /* Track an rmap in the refcount bag. */ |
70 | int |
71 | rcbag_add( |
72 | struct rcbag *bag, |
73 | struct xfs_trans *tp, |
74 | const struct xfs_rmap_irec *rmap) |
75 | { |
76 | struct rcbag_rec bagrec; |
77 | struct xfs_mount *mp = bag->mp; |
78 | struct xfs_btree_cur *cur; |
79 | int has; |
80 | int error; |
81 | |
82 | cur = rcbagbt_mem_cursor(mp, tp, &bag->xfbtree); |
83 | error = rcbagbt_lookup_eq(cur, rmap, &has); |
84 | if (error) |
85 | goto out_cur; |
86 | |
87 | if (has) { |
88 | error = rcbagbt_get_rec(cur, &bagrec, &has); |
89 | if (error) |
90 | goto out_cur; |
91 | if (!has) { |
92 | error = -EFSCORRUPTED; |
93 | goto out_cur; |
94 | } |
95 | |
96 | bagrec.rbg_refcount++; |
97 | error = rcbagbt_update(cur, &bagrec); |
98 | if (error) |
99 | goto out_cur; |
100 | } else { |
101 | bagrec.rbg_startblock = rmap->rm_startblock; |
102 | bagrec.rbg_blockcount = rmap->rm_blockcount; |
103 | bagrec.rbg_refcount = 1; |
104 | |
105 | error = rcbagbt_insert(cur, &bagrec, &has); |
106 | if (error) |
107 | goto out_cur; |
108 | if (!has) { |
109 | error = -EFSCORRUPTED; |
110 | goto out_cur; |
111 | } |
112 | } |
113 | |
114 | xfs_btree_del_cursor(cur, 0); |
115 | |
116 | error = xfbtree_trans_commit(&bag->xfbtree, tp); |
117 | if (error) |
118 | return error; |
119 | |
120 | bag->nr_items++; |
121 | return 0; |
122 | |
123 | out_cur: |
124 | xfs_btree_del_cursor(cur, error); |
125 | xfbtree_trans_cancel(&bag->xfbtree, tp); |
126 | return error; |
127 | } |
128 | |
129 | /* Return the number of records in the bag. */ |
130 | uint64_t |
131 | rcbag_count( |
132 | const struct rcbag *rcbag) |
133 | { |
134 | return rcbag->nr_items; |
135 | } |
136 | |
137 | static inline uint32_t rcbag_rec_next_bno(const struct rcbag_rec *r) |
138 | { |
139 | return r->rbg_startblock + r->rbg_blockcount; |
140 | } |
141 | |
142 | /* |
143 | * Find the next block where the refcount changes, given the next rmap we |
144 | * looked at and the ones we're already tracking. |
145 | */ |
146 | int |
147 | rcbag_next_edge( |
148 | struct rcbag *bag, |
149 | struct xfs_trans *tp, |
150 | const struct xfs_rmap_irec *next_rmap, |
151 | bool next_valid, |
152 | uint32_t *next_bnop) |
153 | { |
154 | struct rcbag_rec bagrec; |
155 | struct xfs_mount *mp = bag->mp; |
156 | struct xfs_btree_cur *cur; |
157 | uint32_t next_bno = NULLAGBLOCK; |
158 | int has; |
159 | int error; |
160 | |
161 | if (next_valid) |
162 | next_bno = next_rmap->rm_startblock; |
163 | |
164 | cur = rcbagbt_mem_cursor(mp, tp, &bag->xfbtree); |
165 | error = xfs_btree_goto_left_edge(cur); |
166 | if (error) |
167 | goto out_cur; |
168 | |
169 | while (true) { |
170 | error = xfs_btree_increment(cur, 0, &has); |
171 | if (error) |
172 | goto out_cur; |
173 | if (!has) |
174 | break; |
175 | |
176 | error = rcbagbt_get_rec(cur, &bagrec, &has); |
177 | if (error) |
178 | goto out_cur; |
179 | if (!has) { |
180 | error = -EFSCORRUPTED; |
181 | goto out_cur; |
182 | } |
183 | |
184 | next_bno = min(next_bno, rcbag_rec_next_bno(&bagrec)); |
185 | } |
186 | |
187 | /* |
188 | * We should have found /something/ because either next_rrm is the next |
189 | * interesting rmap to look at after emitting this refcount extent, or |
190 | * there are other rmaps in rmap_bag contributing to the current |
191 | * sharing count. But if something is seriously wrong, bail out. |
192 | */ |
193 | if (next_bno == NULLAGBLOCK) { |
194 | error = -EFSCORRUPTED; |
195 | goto out_cur; |
196 | } |
197 | |
198 | xfs_btree_del_cursor(cur, 0); |
199 | |
200 | *next_bnop = next_bno; |
201 | return 0; |
202 | |
203 | out_cur: |
204 | xfs_btree_del_cursor(cur, error); |
205 | return error; |
206 | } |
207 | |
208 | /* Pop all refcount bag records that end at next_bno */ |
209 | int |
210 | rcbag_remove_ending_at( |
211 | struct rcbag *bag, |
212 | struct xfs_trans *tp, |
213 | uint32_t next_bno) |
214 | { |
215 | struct rcbag_rec bagrec; |
216 | struct xfs_mount *mp = bag->mp; |
217 | struct xfs_btree_cur *cur; |
218 | int has; |
219 | int error; |
220 | |
221 | /* go to the right edge of the tree */ |
222 | cur = rcbagbt_mem_cursor(mp, tp, &bag->xfbtree); |
223 | memset(&cur->bc_rec, 0xFF, sizeof(cur->bc_rec)); |
224 | error = xfs_btree_lookup(cur, XFS_LOOKUP_GE, &has); |
225 | if (error) |
226 | goto out_cur; |
227 | |
228 | while (true) { |
229 | error = xfs_btree_decrement(cur, 0, &has); |
230 | if (error) |
231 | goto out_cur; |
232 | if (!has) |
233 | break; |
234 | |
235 | error = rcbagbt_get_rec(cur, &bagrec, &has); |
236 | if (error) |
237 | goto out_cur; |
238 | if (!has) { |
239 | error = -EFSCORRUPTED; |
240 | goto out_cur; |
241 | } |
242 | |
243 | if (rcbag_rec_next_bno(&bagrec) != next_bno) |
244 | continue; |
245 | |
246 | error = xfs_btree_delete(cur, &has); |
247 | if (error) |
248 | goto out_cur; |
249 | if (!has) { |
250 | error = -EFSCORRUPTED; |
251 | goto out_cur; |
252 | } |
253 | |
254 | bag->nr_items -= bagrec.rbg_refcount; |
255 | } |
256 | |
257 | xfs_btree_del_cursor(cur, 0); |
258 | return xfbtree_trans_commit(&bag->xfbtree, tp); |
259 | out_cur: |
260 | xfs_btree_del_cursor(cur, error); |
261 | xfbtree_trans_cancel(&bag->xfbtree, tp); |
262 | return error; |
263 | } |
264 | |
265 | /* Dump the rcbag. */ |
266 | void |
267 | rcbag_dump( |
268 | struct rcbag *bag, |
269 | struct xfs_trans *tp) |
270 | { |
271 | struct rcbag_rec bagrec; |
272 | struct xfs_mount *mp = bag->mp; |
273 | struct xfs_btree_cur *cur; |
274 | unsigned long long nr = 0; |
275 | int has; |
276 | int error; |
277 | |
278 | cur = rcbagbt_mem_cursor(mp, tp, &bag->xfbtree); |
279 | error = xfs_btree_goto_left_edge(cur); |
280 | if (error) |
281 | goto out_cur; |
282 | |
283 | while (true) { |
284 | error = xfs_btree_increment(cur, 0, &has); |
285 | if (error) |
286 | goto out_cur; |
287 | if (!has) |
288 | break; |
289 | |
290 | error = rcbagbt_get_rec(cur, &bagrec, &has); |
291 | if (error) |
292 | goto out_cur; |
293 | if (!has) { |
294 | error = -EFSCORRUPTED; |
295 | goto out_cur; |
296 | } |
297 | |
298 | xfs_err(bag->mp, "[%llu]: bno 0x%x fsbcount 0x%x refcount 0x%llx\n" , |
299 | nr++, |
300 | (unsigned int)bagrec.rbg_startblock, |
301 | (unsigned int)bagrec.rbg_blockcount, |
302 | (unsigned long long)bagrec.rbg_refcount); |
303 | } |
304 | |
305 | out_cur: |
306 | xfs_btree_del_cursor(cur, error); |
307 | } |
308 | |