1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2007 Oracle. All rights reserved.
7 #include <linux/uuid.h>
9 #include "transaction.h"
11 #include "print-tree.h"
14 * Read a root item from the tree. In case we detect a root item smaller then
15 * sizeof(root_item), we know it's an old version of the root structure and
16 * initialize all new fields to zero. The same happens if we detect mismatching
17 * generation numbers as then we know the root was once mounted with an older
18 * kernel that was not aware of the root item structure change.
20 static void btrfs_read_root_item(struct extent_buffer
*eb
, int slot
,
21 struct btrfs_root_item
*item
)
27 len
= btrfs_item_size_nr(eb
, slot
);
28 read_extent_buffer(eb
, item
, btrfs_item_ptr_offset(eb
, slot
),
29 min_t(u32
, len
, sizeof(*item
)));
30 if (len
< sizeof(*item
))
32 if (!need_reset
&& btrfs_root_generation(item
)
33 != btrfs_root_generation_v2(item
)) {
34 if (btrfs_root_generation_v2(item
) != 0) {
35 btrfs_warn(eb
->fs_info
,
36 "mismatching generation and generation_v2 found in root item. This root was probably mounted with an older kernel. Resetting all new fields.");
41 memset(&item
->generation_v2
, 0,
42 sizeof(*item
) - offsetof(struct btrfs_root_item
,
46 memcpy(item
->uuid
, uuid
.b
, BTRFS_UUID_SIZE
);
51 * btrfs_find_root - lookup the root by the key.
52 * root: the root of the root tree
53 * search_key: the key to search
54 * path: the path we search
55 * root_item: the root item of the tree we look for
56 * root_key: the root key of the tree we look for
58 * If ->offset of 'search_key' is -1ULL, it means we are not sure the offset
59 * of the search key, just lookup the root with the highest offset for a
62 * If we find something return 0, otherwise > 0, < 0 on error.
64 int btrfs_find_root(struct btrfs_root
*root
, const struct btrfs_key
*search_key
,
65 struct btrfs_path
*path
, struct btrfs_root_item
*root_item
,
66 struct btrfs_key
*root_key
)
68 struct btrfs_key found_key
;
69 struct extent_buffer
*l
;
73 ret
= btrfs_search_slot(NULL
, root
, search_key
, path
, 0, 0);
77 if (search_key
->offset
!= -1ULL) { /* the search key is exact */
81 BUG_ON(ret
== 0); /* Logical error */
82 if (path
->slots
[0] == 0)
89 slot
= path
->slots
[0];
91 btrfs_item_key_to_cpu(l
, &found_key
, slot
);
92 if (found_key
.objectid
!= search_key
->objectid
||
93 found_key
.type
!= BTRFS_ROOT_ITEM_KEY
) {
99 btrfs_read_root_item(l
, slot
, root_item
);
101 memcpy(root_key
, &found_key
, sizeof(found_key
));
103 btrfs_release_path(path
);
107 void btrfs_set_root_node(struct btrfs_root_item
*item
,
108 struct extent_buffer
*node
)
110 btrfs_set_root_bytenr(item
, node
->start
);
111 btrfs_set_root_level(item
, btrfs_header_level(node
));
112 btrfs_set_root_generation(item
, btrfs_header_generation(node
));
116 * copy the data in 'item' into the btree
118 int btrfs_update_root(struct btrfs_trans_handle
*trans
, struct btrfs_root
119 *root
, struct btrfs_key
*key
, struct btrfs_root_item
122 struct btrfs_fs_info
*fs_info
= root
->fs_info
;
123 struct btrfs_path
*path
;
124 struct extent_buffer
*l
;
130 path
= btrfs_alloc_path();
134 ret
= btrfs_search_slot(trans
, root
, key
, path
, 0, 1);
140 "unable to find root key (%llu %u %llu) in tree %llu",
141 key
->objectid
, key
->type
, key
->offset
,
142 root
->root_key
.objectid
);
144 btrfs_abort_transaction(trans
, ret
);
149 slot
= path
->slots
[0];
150 ptr
= btrfs_item_ptr_offset(l
, slot
);
151 old_len
= btrfs_item_size_nr(l
, slot
);
154 * If this is the first time we update the root item which originated
155 * from an older kernel, we need to enlarge the item size to make room
156 * for the added fields.
158 if (old_len
< sizeof(*item
)) {
159 btrfs_release_path(path
);
160 ret
= btrfs_search_slot(trans
, root
, key
, path
,
163 btrfs_abort_transaction(trans
, ret
);
167 ret
= btrfs_del_item(trans
, root
, path
);
169 btrfs_abort_transaction(trans
, ret
);
172 btrfs_release_path(path
);
173 ret
= btrfs_insert_empty_item(trans
, root
, path
,
176 btrfs_abort_transaction(trans
, ret
);
180 slot
= path
->slots
[0];
181 ptr
= btrfs_item_ptr_offset(l
, slot
);
185 * Update generation_v2 so at the next mount we know the new root
188 btrfs_set_root_generation_v2(item
, btrfs_root_generation(item
));
190 write_extent_buffer(l
, item
, ptr
, sizeof(*item
));
191 btrfs_mark_buffer_dirty(path
->nodes
[0]);
193 btrfs_free_path(path
);
197 int btrfs_insert_root(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
198 const struct btrfs_key
*key
, struct btrfs_root_item
*item
)
201 * Make sure generation v1 and v2 match. See update_root for details.
203 btrfs_set_root_generation_v2(item
, btrfs_root_generation(item
));
204 return btrfs_insert_item(trans
, root
, key
, item
, sizeof(*item
));
207 int btrfs_find_orphan_roots(struct btrfs_fs_info
*fs_info
)
209 struct btrfs_root
*tree_root
= fs_info
->tree_root
;
210 struct extent_buffer
*leaf
;
211 struct btrfs_path
*path
;
212 struct btrfs_key key
;
213 struct btrfs_key root_key
;
214 struct btrfs_root
*root
;
218 path
= btrfs_alloc_path();
222 key
.objectid
= BTRFS_ORPHAN_OBJECTID
;
223 key
.type
= BTRFS_ORPHAN_ITEM_KEY
;
226 root_key
.type
= BTRFS_ROOT_ITEM_KEY
;
227 root_key
.offset
= (u64
)-1;
230 ret
= btrfs_search_slot(NULL
, tree_root
, &key
, path
, 0, 0);
236 leaf
= path
->nodes
[0];
237 if (path
->slots
[0] >= btrfs_header_nritems(leaf
)) {
238 ret
= btrfs_next_leaf(tree_root
, path
);
243 leaf
= path
->nodes
[0];
246 btrfs_item_key_to_cpu(leaf
, &key
, path
->slots
[0]);
247 btrfs_release_path(path
);
249 if (key
.objectid
!= BTRFS_ORPHAN_OBJECTID
||
250 key
.type
!= BTRFS_ORPHAN_ITEM_KEY
)
253 root_key
.objectid
= key
.offset
;
257 * The root might have been inserted already, as before we look
258 * for orphan roots, log replay might have happened, which
259 * triggers a transaction commit and qgroup accounting, which
260 * in turn reads and inserts fs roots while doing backref
263 root
= btrfs_lookup_fs_root(fs_info
, root_key
.objectid
);
265 WARN_ON(!test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED
,
267 if (btrfs_root_refs(&root
->root_item
) == 0) {
268 set_bit(BTRFS_ROOT_DEAD_TREE
, &root
->state
);
269 btrfs_add_dead_root(root
);
274 root
= btrfs_read_fs_root(tree_root
, &root_key
);
275 err
= PTR_ERR_OR_ZERO(root
);
276 if (err
&& err
!= -ENOENT
) {
278 } else if (err
== -ENOENT
) {
279 struct btrfs_trans_handle
*trans
;
281 btrfs_release_path(path
);
283 trans
= btrfs_join_transaction(tree_root
);
285 err
= PTR_ERR(trans
);
286 btrfs_handle_fs_error(fs_info
, err
,
287 "Failed to start trans to delete orphan item");
290 err
= btrfs_del_orphan_item(trans
, tree_root
,
292 btrfs_end_transaction(trans
);
294 btrfs_handle_fs_error(fs_info
, err
,
295 "Failed to delete root orphan item");
301 err
= btrfs_init_fs_root(root
);
303 btrfs_free_fs_root(root
);
307 set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED
, &root
->state
);
309 err
= btrfs_insert_fs_root(fs_info
, root
);
311 BUG_ON(err
== -EEXIST
);
312 btrfs_free_fs_root(root
);
316 if (btrfs_root_refs(&root
->root_item
) == 0) {
317 set_bit(BTRFS_ROOT_DEAD_TREE
, &root
->state
);
318 btrfs_add_dead_root(root
);
322 btrfs_free_path(path
);
326 /* drop the root item for 'key' from the tree root */
327 int btrfs_del_root(struct btrfs_trans_handle
*trans
,
328 const struct btrfs_key
*key
)
330 struct btrfs_root
*root
= trans
->fs_info
->tree_root
;
331 struct btrfs_path
*path
;
334 path
= btrfs_alloc_path();
337 ret
= btrfs_search_slot(trans
, root
, key
, path
, -1, 1);
343 ret
= btrfs_del_item(trans
, root
, path
);
345 btrfs_free_path(path
);
349 int btrfs_del_root_ref(struct btrfs_trans_handle
*trans
, u64 root_id
,
350 u64 ref_id
, u64 dirid
, u64
*sequence
, const char *name
,
354 struct btrfs_root
*tree_root
= trans
->fs_info
->tree_root
;
355 struct btrfs_path
*path
;
356 struct btrfs_root_ref
*ref
;
357 struct extent_buffer
*leaf
;
358 struct btrfs_key key
;
363 path
= btrfs_alloc_path();
367 key
.objectid
= root_id
;
368 key
.type
= BTRFS_ROOT_BACKREF_KEY
;
371 ret
= btrfs_search_slot(trans
, tree_root
, &key
, path
, -1, 1);
374 leaf
= path
->nodes
[0];
375 ref
= btrfs_item_ptr(leaf
, path
->slots
[0],
376 struct btrfs_root_ref
);
378 WARN_ON(btrfs_root_ref_dirid(leaf
, ref
) != dirid
);
379 WARN_ON(btrfs_root_ref_name_len(leaf
, ref
) != name_len
);
380 ptr
= (unsigned long)(ref
+ 1);
381 WARN_ON(memcmp_extent_buffer(leaf
, name
, ptr
, name_len
));
382 *sequence
= btrfs_root_ref_sequence(leaf
, ref
);
384 ret
= btrfs_del_item(trans
, tree_root
, path
);
392 if (key
.type
== BTRFS_ROOT_BACKREF_KEY
) {
393 btrfs_release_path(path
);
394 key
.objectid
= ref_id
;
395 key
.type
= BTRFS_ROOT_REF_KEY
;
396 key
.offset
= root_id
;
401 btrfs_free_path(path
);
406 * add a btrfs_root_ref item. type is either BTRFS_ROOT_REF_KEY
407 * or BTRFS_ROOT_BACKREF_KEY.
409 * The dirid, sequence, name and name_len refer to the directory entry
410 * that is referencing the root.
412 * For a forward ref, the root_id is the id of the tree referencing
413 * the root and ref_id is the id of the subvol or snapshot.
415 * For a back ref the root_id is the id of the subvol or snapshot and
416 * ref_id is the id of the tree referencing it.
418 * Will return 0, -ENOMEM, or anything from the CoW path
420 int btrfs_add_root_ref(struct btrfs_trans_handle
*trans
, u64 root_id
,
421 u64 ref_id
, u64 dirid
, u64 sequence
, const char *name
,
424 struct btrfs_root
*tree_root
= trans
->fs_info
->tree_root
;
425 struct btrfs_key key
;
427 struct btrfs_path
*path
;
428 struct btrfs_root_ref
*ref
;
429 struct extent_buffer
*leaf
;
432 path
= btrfs_alloc_path();
436 key
.objectid
= root_id
;
437 key
.type
= BTRFS_ROOT_BACKREF_KEY
;
440 ret
= btrfs_insert_empty_item(trans
, tree_root
, path
, &key
,
441 sizeof(*ref
) + name_len
);
443 btrfs_abort_transaction(trans
, ret
);
444 btrfs_free_path(path
);
448 leaf
= path
->nodes
[0];
449 ref
= btrfs_item_ptr(leaf
, path
->slots
[0], struct btrfs_root_ref
);
450 btrfs_set_root_ref_dirid(leaf
, ref
, dirid
);
451 btrfs_set_root_ref_sequence(leaf
, ref
, sequence
);
452 btrfs_set_root_ref_name_len(leaf
, ref
, name_len
);
453 ptr
= (unsigned long)(ref
+ 1);
454 write_extent_buffer(leaf
, name
, ptr
, name_len
);
455 btrfs_mark_buffer_dirty(leaf
);
457 if (key
.type
== BTRFS_ROOT_BACKREF_KEY
) {
458 btrfs_release_path(path
);
459 key
.objectid
= ref_id
;
460 key
.type
= BTRFS_ROOT_REF_KEY
;
461 key
.offset
= root_id
;
465 btrfs_free_path(path
);
470 * Old btrfs forgets to init root_item->flags and root_item->byte_limit
471 * for subvolumes. To work around this problem, we steal a bit from
472 * root_item->inode_item->flags, and use it to indicate if those fields
473 * have been properly initialized.
475 void btrfs_check_and_init_root_item(struct btrfs_root_item
*root_item
)
477 u64 inode_flags
= btrfs_stack_inode_flags(&root_item
->inode
);
479 if (!(inode_flags
& BTRFS_INODE_ROOT_ITEM_INIT
)) {
480 inode_flags
|= BTRFS_INODE_ROOT_ITEM_INIT
;
481 btrfs_set_stack_inode_flags(&root_item
->inode
, inode_flags
);
482 btrfs_set_root_flags(root_item
, 0);
483 btrfs_set_root_limit(root_item
, 0);
487 void btrfs_update_root_times(struct btrfs_trans_handle
*trans
,
488 struct btrfs_root
*root
)
490 struct btrfs_root_item
*item
= &root
->root_item
;
491 struct timespec64 ct
;
493 ktime_get_real_ts64(&ct
);
494 spin_lock(&root
->root_item_lock
);
495 btrfs_set_root_ctransid(item
, trans
->transid
);
496 btrfs_set_stack_timespec_sec(&item
->ctime
, ct
.tv_sec
);
497 btrfs_set_stack_timespec_nsec(&item
->ctime
, ct
.tv_nsec
);
498 spin_unlock(&root
->root_item_lock
);