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