1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) STRATO AG 2013. All rights reserved. |
4 | */ |
5 | |
6 | #include <linux/uuid.h> |
7 | #include <asm/unaligned.h> |
8 | #include "messages.h" |
9 | #include "ctree.h" |
10 | #include "transaction.h" |
11 | #include "disk-io.h" |
12 | #include "print-tree.h" |
13 | #include "fs.h" |
14 | #include "accessors.h" |
15 | #include "uuid-tree.h" |
16 | |
17 | static void btrfs_uuid_to_key(u8 *uuid, u8 type, struct btrfs_key *key) |
18 | { |
19 | key->type = type; |
20 | key->objectid = get_unaligned_le64(p: uuid); |
21 | key->offset = get_unaligned_le64(p: uuid + sizeof(u64)); |
22 | } |
23 | |
24 | /* return -ENOENT for !found, < 0 for errors, or 0 if an item was found */ |
25 | static int btrfs_uuid_tree_lookup(struct btrfs_root *uuid_root, u8 *uuid, |
26 | u8 type, u64 subid) |
27 | { |
28 | int ret; |
29 | struct btrfs_path *path = NULL; |
30 | struct extent_buffer *eb; |
31 | int slot; |
32 | u32 item_size; |
33 | unsigned long offset; |
34 | struct btrfs_key key; |
35 | |
36 | if (WARN_ON_ONCE(!uuid_root)) { |
37 | ret = -ENOENT; |
38 | goto out; |
39 | } |
40 | |
41 | path = btrfs_alloc_path(); |
42 | if (!path) { |
43 | ret = -ENOMEM; |
44 | goto out; |
45 | } |
46 | |
47 | btrfs_uuid_to_key(uuid, type, key: &key); |
48 | ret = btrfs_search_slot(NULL, root: uuid_root, key: &key, p: path, ins_len: 0, cow: 0); |
49 | if (ret < 0) { |
50 | goto out; |
51 | } else if (ret > 0) { |
52 | ret = -ENOENT; |
53 | goto out; |
54 | } |
55 | |
56 | eb = path->nodes[0]; |
57 | slot = path->slots[0]; |
58 | item_size = btrfs_item_size(eb, slot); |
59 | offset = btrfs_item_ptr_offset(eb, slot); |
60 | ret = -ENOENT; |
61 | |
62 | if (!IS_ALIGNED(item_size, sizeof(u64))) { |
63 | btrfs_warn(uuid_root->fs_info, |
64 | "uuid item with illegal size %lu!" , |
65 | (unsigned long)item_size); |
66 | goto out; |
67 | } |
68 | while (item_size) { |
69 | __le64 data; |
70 | |
71 | read_extent_buffer(eb, dst: &data, start: offset, len: sizeof(data)); |
72 | if (le64_to_cpu(data) == subid) { |
73 | ret = 0; |
74 | break; |
75 | } |
76 | offset += sizeof(data); |
77 | item_size -= sizeof(data); |
78 | } |
79 | |
80 | out: |
81 | btrfs_free_path(p: path); |
82 | return ret; |
83 | } |
84 | |
85 | int btrfs_uuid_tree_add(struct btrfs_trans_handle *trans, u8 *uuid, u8 type, |
86 | u64 subid_cpu) |
87 | { |
88 | struct btrfs_fs_info *fs_info = trans->fs_info; |
89 | struct btrfs_root *uuid_root = fs_info->uuid_root; |
90 | int ret; |
91 | struct btrfs_path *path = NULL; |
92 | struct btrfs_key key; |
93 | struct extent_buffer *eb; |
94 | int slot; |
95 | unsigned long offset; |
96 | __le64 subid_le; |
97 | |
98 | ret = btrfs_uuid_tree_lookup(uuid_root, uuid, type, subid: subid_cpu); |
99 | if (ret != -ENOENT) |
100 | return ret; |
101 | |
102 | if (WARN_ON_ONCE(!uuid_root)) { |
103 | ret = -EINVAL; |
104 | goto out; |
105 | } |
106 | |
107 | btrfs_uuid_to_key(uuid, type, key: &key); |
108 | |
109 | path = btrfs_alloc_path(); |
110 | if (!path) { |
111 | ret = -ENOMEM; |
112 | goto out; |
113 | } |
114 | |
115 | ret = btrfs_insert_empty_item(trans, root: uuid_root, path, key: &key, |
116 | data_size: sizeof(subid_le)); |
117 | if (ret >= 0) { |
118 | /* Add an item for the type for the first time */ |
119 | eb = path->nodes[0]; |
120 | slot = path->slots[0]; |
121 | offset = btrfs_item_ptr_offset(eb, slot); |
122 | } else if (ret == -EEXIST) { |
123 | /* |
124 | * An item with that type already exists. |
125 | * Extend the item and store the new subid at the end. |
126 | */ |
127 | btrfs_extend_item(trans, path, data_size: sizeof(subid_le)); |
128 | eb = path->nodes[0]; |
129 | slot = path->slots[0]; |
130 | offset = btrfs_item_ptr_offset(eb, slot); |
131 | offset += btrfs_item_size(eb, slot) - sizeof(subid_le); |
132 | } else { |
133 | btrfs_warn(fs_info, |
134 | "insert uuid item failed %d (0x%016llx, 0x%016llx) type %u!" , |
135 | ret, key.objectid, key.offset, type); |
136 | goto out; |
137 | } |
138 | |
139 | ret = 0; |
140 | subid_le = cpu_to_le64(subid_cpu); |
141 | write_extent_buffer(eb, src: &subid_le, start: offset, len: sizeof(subid_le)); |
142 | btrfs_mark_buffer_dirty(trans, buf: eb); |
143 | |
144 | out: |
145 | btrfs_free_path(p: path); |
146 | return ret; |
147 | } |
148 | |
149 | int btrfs_uuid_tree_remove(struct btrfs_trans_handle *trans, u8 *uuid, u8 type, |
150 | u64 subid) |
151 | { |
152 | struct btrfs_fs_info *fs_info = trans->fs_info; |
153 | struct btrfs_root *uuid_root = fs_info->uuid_root; |
154 | int ret; |
155 | struct btrfs_path *path = NULL; |
156 | struct btrfs_key key; |
157 | struct extent_buffer *eb; |
158 | int slot; |
159 | unsigned long offset; |
160 | u32 item_size; |
161 | unsigned long move_dst; |
162 | unsigned long move_src; |
163 | unsigned long move_len; |
164 | |
165 | if (WARN_ON_ONCE(!uuid_root)) { |
166 | ret = -EINVAL; |
167 | goto out; |
168 | } |
169 | |
170 | btrfs_uuid_to_key(uuid, type, key: &key); |
171 | |
172 | path = btrfs_alloc_path(); |
173 | if (!path) { |
174 | ret = -ENOMEM; |
175 | goto out; |
176 | } |
177 | |
178 | ret = btrfs_search_slot(trans, root: uuid_root, key: &key, p: path, ins_len: -1, cow: 1); |
179 | if (ret < 0) { |
180 | btrfs_warn(fs_info, "error %d while searching for uuid item!" , |
181 | ret); |
182 | goto out; |
183 | } |
184 | if (ret > 0) { |
185 | ret = -ENOENT; |
186 | goto out; |
187 | } |
188 | |
189 | eb = path->nodes[0]; |
190 | slot = path->slots[0]; |
191 | offset = btrfs_item_ptr_offset(eb, slot); |
192 | item_size = btrfs_item_size(eb, slot); |
193 | if (!IS_ALIGNED(item_size, sizeof(u64))) { |
194 | btrfs_warn(fs_info, "uuid item with illegal size %lu!" , |
195 | (unsigned long)item_size); |
196 | ret = -ENOENT; |
197 | goto out; |
198 | } |
199 | while (item_size) { |
200 | __le64 read_subid; |
201 | |
202 | read_extent_buffer(eb, dst: &read_subid, start: offset, len: sizeof(read_subid)); |
203 | if (le64_to_cpu(read_subid) == subid) |
204 | break; |
205 | offset += sizeof(read_subid); |
206 | item_size -= sizeof(read_subid); |
207 | } |
208 | |
209 | if (!item_size) { |
210 | ret = -ENOENT; |
211 | goto out; |
212 | } |
213 | |
214 | item_size = btrfs_item_size(eb, slot); |
215 | if (item_size == sizeof(subid)) { |
216 | ret = btrfs_del_item(trans, root: uuid_root, path); |
217 | goto out; |
218 | } |
219 | |
220 | move_dst = offset; |
221 | move_src = offset + sizeof(subid); |
222 | move_len = item_size - (move_src - btrfs_item_ptr_offset(eb, slot)); |
223 | memmove_extent_buffer(dst: eb, dst_offset: move_dst, src_offset: move_src, len: move_len); |
224 | btrfs_truncate_item(trans, path, new_size: item_size - sizeof(subid), from_end: 1); |
225 | |
226 | out: |
227 | btrfs_free_path(p: path); |
228 | return ret; |
229 | } |
230 | |
231 | static int btrfs_uuid_iter_rem(struct btrfs_root *uuid_root, u8 *uuid, u8 type, |
232 | u64 subid) |
233 | { |
234 | struct btrfs_trans_handle *trans; |
235 | int ret; |
236 | |
237 | /* 1 - for the uuid item */ |
238 | trans = btrfs_start_transaction(root: uuid_root, num_items: 1); |
239 | if (IS_ERR(ptr: trans)) { |
240 | ret = PTR_ERR(ptr: trans); |
241 | goto out; |
242 | } |
243 | |
244 | ret = btrfs_uuid_tree_remove(trans, uuid, type, subid); |
245 | btrfs_end_transaction(trans); |
246 | |
247 | out: |
248 | return ret; |
249 | } |
250 | |
251 | /* |
252 | * Check if there's an matching subvolume for given UUID |
253 | * |
254 | * Return: |
255 | * 0 check succeeded, the entry is not outdated |
256 | * > 0 if the check failed, the caller should remove the entry |
257 | * < 0 if an error occurred |
258 | */ |
259 | static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, |
260 | u8 *uuid, u8 type, u64 subvolid) |
261 | { |
262 | int ret = 0; |
263 | struct btrfs_root *subvol_root; |
264 | |
265 | if (type != BTRFS_UUID_KEY_SUBVOL && |
266 | type != BTRFS_UUID_KEY_RECEIVED_SUBVOL) |
267 | goto out; |
268 | |
269 | subvol_root = btrfs_get_fs_root(fs_info, objectid: subvolid, check_ref: true); |
270 | if (IS_ERR(ptr: subvol_root)) { |
271 | ret = PTR_ERR(ptr: subvol_root); |
272 | if (ret == -ENOENT) |
273 | ret = 1; |
274 | goto out; |
275 | } |
276 | |
277 | switch (type) { |
278 | case BTRFS_UUID_KEY_SUBVOL: |
279 | if (memcmp(p: uuid, q: subvol_root->root_item.uuid, BTRFS_UUID_SIZE)) |
280 | ret = 1; |
281 | break; |
282 | case BTRFS_UUID_KEY_RECEIVED_SUBVOL: |
283 | if (memcmp(p: uuid, q: subvol_root->root_item.received_uuid, |
284 | BTRFS_UUID_SIZE)) |
285 | ret = 1; |
286 | break; |
287 | } |
288 | btrfs_put_root(root: subvol_root); |
289 | out: |
290 | return ret; |
291 | } |
292 | |
293 | int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info) |
294 | { |
295 | struct btrfs_root *root = fs_info->uuid_root; |
296 | struct btrfs_key key; |
297 | struct btrfs_path *path; |
298 | int ret = 0; |
299 | struct extent_buffer *leaf; |
300 | int slot; |
301 | u32 item_size; |
302 | unsigned long offset; |
303 | |
304 | path = btrfs_alloc_path(); |
305 | if (!path) { |
306 | ret = -ENOMEM; |
307 | goto out; |
308 | } |
309 | |
310 | key.objectid = 0; |
311 | key.type = 0; |
312 | key.offset = 0; |
313 | |
314 | again_search_slot: |
315 | ret = btrfs_search_forward(root, min_key: &key, path, BTRFS_OLDEST_GENERATION); |
316 | if (ret) { |
317 | if (ret > 0) |
318 | ret = 0; |
319 | goto out; |
320 | } |
321 | |
322 | while (1) { |
323 | if (btrfs_fs_closing(fs_info)) { |
324 | ret = -EINTR; |
325 | goto out; |
326 | } |
327 | cond_resched(); |
328 | leaf = path->nodes[0]; |
329 | slot = path->slots[0]; |
330 | btrfs_item_key_to_cpu(eb: leaf, cpu_key: &key, nr: slot); |
331 | |
332 | if (key.type != BTRFS_UUID_KEY_SUBVOL && |
333 | key.type != BTRFS_UUID_KEY_RECEIVED_SUBVOL) |
334 | goto skip; |
335 | |
336 | offset = btrfs_item_ptr_offset(leaf, slot); |
337 | item_size = btrfs_item_size(eb: leaf, slot); |
338 | if (!IS_ALIGNED(item_size, sizeof(u64))) { |
339 | btrfs_warn(fs_info, |
340 | "uuid item with illegal size %lu!" , |
341 | (unsigned long)item_size); |
342 | goto skip; |
343 | } |
344 | while (item_size) { |
345 | u8 uuid[BTRFS_UUID_SIZE]; |
346 | __le64 subid_le; |
347 | u64 subid_cpu; |
348 | |
349 | put_unaligned_le64(val: key.objectid, p: uuid); |
350 | put_unaligned_le64(val: key.offset, p: uuid + sizeof(u64)); |
351 | read_extent_buffer(eb: leaf, dst: &subid_le, start: offset, |
352 | len: sizeof(subid_le)); |
353 | subid_cpu = le64_to_cpu(subid_le); |
354 | ret = btrfs_check_uuid_tree_entry(fs_info, uuid, |
355 | type: key.type, subvolid: subid_cpu); |
356 | if (ret < 0) |
357 | goto out; |
358 | if (ret > 0) { |
359 | btrfs_release_path(p: path); |
360 | ret = btrfs_uuid_iter_rem(uuid_root: root, uuid, type: key.type, |
361 | subid: subid_cpu); |
362 | if (ret == 0) { |
363 | /* |
364 | * this might look inefficient, but the |
365 | * justification is that it is an |
366 | * exception that check_func returns 1, |
367 | * and that in the regular case only one |
368 | * entry per UUID exists. |
369 | */ |
370 | goto again_search_slot; |
371 | } |
372 | if (ret < 0 && ret != -ENOENT) |
373 | goto out; |
374 | key.offset++; |
375 | goto again_search_slot; |
376 | } |
377 | item_size -= sizeof(subid_le); |
378 | offset += sizeof(subid_le); |
379 | } |
380 | |
381 | skip: |
382 | ret = btrfs_next_item(root, p: path); |
383 | if (ret == 0) |
384 | continue; |
385 | else if (ret > 0) |
386 | ret = 0; |
387 | break; |
388 | } |
389 | |
390 | out: |
391 | btrfs_free_path(p: path); |
392 | return ret; |
393 | } |
394 | |