2 * Copyright (C) 2007 Oracle. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include <linux/err.h>
20 #include <linux/uuid.h>
22 #include "transaction.h"
24 #include "print-tree.h"
27 * Read a root item from the tree. In case we detect a root item smaller then
28 * sizeof(root_item), we know it's an old version of the root structure and
29 * initialize all new fields to zero. The same happens if we detect mismatching
30 * generation numbers as then we know the root was once mounted with an older
31 * kernel that was not aware of the root item structure change.
33 static void btrfs_read_root_item(struct extent_buffer
*eb
, int slot
,
34 struct btrfs_root_item
*item
)
40 len
= btrfs_item_size_nr(eb
, slot
);
41 read_extent_buffer(eb
, item
, btrfs_item_ptr_offset(eb
, slot
),
42 min_t(int, len
, (int)sizeof(*item
)));
43 if (len
< sizeof(*item
))
45 if (!need_reset
&& btrfs_root_generation(item
)
46 != btrfs_root_generation_v2(item
)) {
47 if (btrfs_root_generation_v2(item
) != 0) {
48 btrfs_warn(eb
->fs_info
,
50 "generation and generation_v2 "
51 "found in root item. This root "
52 "was probably mounted with an "
53 "older kernel. Resetting all "
59 memset(&item
->generation_v2
, 0,
60 sizeof(*item
) - offsetof(struct btrfs_root_item
,
64 memcpy(item
->uuid
, uuid
.b
, BTRFS_UUID_SIZE
);
69 * btrfs_find_root - lookup the root by the key.
70 * root: the root of the root tree
71 * search_key: the key to search
72 * path: the path we search
73 * root_item: the root item of the tree we look for
74 * root_key: the reak key of the tree we look for
76 * If ->offset of 'seach_key' is -1ULL, it means we are not sure the offset
77 * of the search key, just lookup the root with the highest offset for a
80 * If we find something return 0, otherwise > 0, < 0 on error.
82 int btrfs_find_root(struct btrfs_root
*root
, struct btrfs_key
*search_key
,
83 struct btrfs_path
*path
, struct btrfs_root_item
*root_item
,
84 struct btrfs_key
*root_key
)
86 struct btrfs_key found_key
;
87 struct extent_buffer
*l
;
91 ret
= btrfs_search_slot(NULL
, root
, search_key
, path
, 0, 0);
95 if (search_key
->offset
!= -1ULL) { /* the search key is exact */
99 BUG_ON(ret
== 0); /* Logical error */
100 if (path
->slots
[0] == 0)
107 slot
= path
->slots
[0];
109 btrfs_item_key_to_cpu(l
, &found_key
, slot
);
110 if (found_key
.objectid
!= search_key
->objectid
||
111 found_key
.type
!= BTRFS_ROOT_ITEM_KEY
) {
117 btrfs_read_root_item(l
, slot
, root_item
);
119 memcpy(root_key
, &found_key
, sizeof(found_key
));
121 btrfs_release_path(path
);
125 void btrfs_set_root_node(struct btrfs_root_item
*item
,
126 struct extent_buffer
*node
)
128 btrfs_set_root_bytenr(item
, node
->start
);
129 btrfs_set_root_level(item
, btrfs_header_level(node
));
130 btrfs_set_root_generation(item
, btrfs_header_generation(node
));
134 * copy the data in 'item' into the btree
136 int btrfs_update_root(struct btrfs_trans_handle
*trans
, struct btrfs_root
137 *root
, struct btrfs_key
*key
, struct btrfs_root_item
140 struct btrfs_path
*path
;
141 struct extent_buffer
*l
;
147 path
= btrfs_alloc_path();
151 ret
= btrfs_search_slot(trans
, root
, key
, path
, 0, 1);
153 btrfs_abort_transaction(trans
, root
, ret
);
158 btrfs_print_leaf(root
, path
->nodes
[0]);
159 btrfs_crit(root
->fs_info
, "unable to update root key %llu %u %llu",
160 key
->objectid
, key
->type
, key
->offset
);
165 slot
= path
->slots
[0];
166 ptr
= btrfs_item_ptr_offset(l
, slot
);
167 old_len
= btrfs_item_size_nr(l
, slot
);
170 * If this is the first time we update the root item which originated
171 * from an older kernel, we need to enlarge the item size to make room
172 * for the added fields.
174 if (old_len
< sizeof(*item
)) {
175 btrfs_release_path(path
);
176 ret
= btrfs_search_slot(trans
, root
, key
, path
,
179 btrfs_abort_transaction(trans
, root
, ret
);
183 ret
= btrfs_del_item(trans
, root
, path
);
185 btrfs_abort_transaction(trans
, root
, ret
);
188 btrfs_release_path(path
);
189 ret
= btrfs_insert_empty_item(trans
, root
, path
,
192 btrfs_abort_transaction(trans
, root
, ret
);
196 slot
= path
->slots
[0];
197 ptr
= btrfs_item_ptr_offset(l
, slot
);
201 * Update generation_v2 so at the next mount we know the new root
204 btrfs_set_root_generation_v2(item
, btrfs_root_generation(item
));
206 write_extent_buffer(l
, item
, ptr
, sizeof(*item
));
207 btrfs_mark_buffer_dirty(path
->nodes
[0]);
209 btrfs_free_path(path
);
213 int btrfs_insert_root(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
214 struct btrfs_key
*key
, struct btrfs_root_item
*item
)
217 * Make sure generation v1 and v2 match. See update_root for details.
219 btrfs_set_root_generation_v2(item
, btrfs_root_generation(item
));
220 return btrfs_insert_item(trans
, root
, key
, item
, sizeof(*item
));
223 int btrfs_find_orphan_roots(struct btrfs_root
*tree_root
)
225 struct extent_buffer
*leaf
;
226 struct btrfs_path
*path
;
227 struct btrfs_key key
;
228 struct btrfs_key root_key
;
229 struct btrfs_root
*root
;
232 bool can_recover
= true;
234 if (tree_root
->fs_info
->sb
->s_flags
& MS_RDONLY
)
237 path
= btrfs_alloc_path();
241 key
.objectid
= BTRFS_ORPHAN_OBJECTID
;
242 key
.type
= BTRFS_ORPHAN_ITEM_KEY
;
245 root_key
.type
= BTRFS_ROOT_ITEM_KEY
;
246 root_key
.offset
= (u64
)-1;
249 ret
= btrfs_search_slot(NULL
, tree_root
, &key
, path
, 0, 0);
255 leaf
= path
->nodes
[0];
256 if (path
->slots
[0] >= btrfs_header_nritems(leaf
)) {
257 ret
= btrfs_next_leaf(tree_root
, path
);
262 leaf
= path
->nodes
[0];
265 btrfs_item_key_to_cpu(leaf
, &key
, path
->slots
[0]);
266 btrfs_release_path(path
);
268 if (key
.objectid
!= BTRFS_ORPHAN_OBJECTID
||
269 key
.type
!= BTRFS_ORPHAN_ITEM_KEY
)
272 root_key
.objectid
= key
.offset
;
275 root
= btrfs_read_fs_root(tree_root
, &root_key
);
276 err
= PTR_ERR_OR_ZERO(root
);
277 if (err
&& err
!= -ENOENT
) {
279 } else if (err
== -ENOENT
) {
280 struct btrfs_trans_handle
*trans
;
282 btrfs_release_path(path
);
284 trans
= btrfs_join_transaction(tree_root
);
286 err
= PTR_ERR(trans
);
287 btrfs_std_error(tree_root
->fs_info
, err
,
288 "Failed to start trans to delete "
292 err
= btrfs_del_orphan_item(trans
, tree_root
,
294 btrfs_end_transaction(trans
, tree_root
);
296 btrfs_std_error(tree_root
->fs_info
, err
,
297 "Failed to delete root orphan "
304 err
= btrfs_init_fs_root(root
);
306 btrfs_free_fs_root(root
);
310 set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED
, &root
->state
);
312 err
= btrfs_insert_fs_root(root
->fs_info
, root
);
314 * The root might have been inserted already, as before we look
315 * for orphan roots, log replay might have happened, which
316 * triggers a transaction commit and qgroup accounting, which
317 * in turn reads and inserts fs roots while doing backref
323 btrfs_free_fs_root(root
);
327 if (btrfs_root_refs(&root
->root_item
) == 0)
328 btrfs_add_dead_root(root
);
331 btrfs_free_path(path
);
335 /* drop the root item for 'key' from 'root' */
336 int btrfs_del_root(struct btrfs_trans_handle
*trans
, struct btrfs_root
*root
,
337 struct btrfs_key
*key
)
339 struct btrfs_path
*path
;
342 path
= btrfs_alloc_path();
345 ret
= btrfs_search_slot(trans
, root
, key
, path
, -1, 1);
351 ret
= btrfs_del_item(trans
, root
, path
);
353 btrfs_free_path(path
);
357 int btrfs_del_root_ref(struct btrfs_trans_handle
*trans
,
358 struct btrfs_root
*tree_root
,
359 u64 root_id
, u64 ref_id
, u64 dirid
, u64
*sequence
,
360 const char *name
, int name_len
)
363 struct btrfs_path
*path
;
364 struct btrfs_root_ref
*ref
;
365 struct extent_buffer
*leaf
;
366 struct btrfs_key key
;
371 path
= btrfs_alloc_path();
375 key
.objectid
= root_id
;
376 key
.type
= BTRFS_ROOT_BACKREF_KEY
;
379 ret
= btrfs_search_slot(trans
, tree_root
, &key
, path
, -1, 1);
382 leaf
= path
->nodes
[0];
383 ref
= btrfs_item_ptr(leaf
, path
->slots
[0],
384 struct btrfs_root_ref
);
386 WARN_ON(btrfs_root_ref_dirid(leaf
, ref
) != dirid
);
387 WARN_ON(btrfs_root_ref_name_len(leaf
, ref
) != name_len
);
388 ptr
= (unsigned long)(ref
+ 1);
389 WARN_ON(memcmp_extent_buffer(leaf
, name
, ptr
, name_len
));
390 *sequence
= btrfs_root_ref_sequence(leaf
, ref
);
392 ret
= btrfs_del_item(trans
, tree_root
, path
);
400 if (key
.type
== BTRFS_ROOT_BACKREF_KEY
) {
401 btrfs_release_path(path
);
402 key
.objectid
= ref_id
;
403 key
.type
= BTRFS_ROOT_REF_KEY
;
404 key
.offset
= root_id
;
409 btrfs_free_path(path
);
414 * add a btrfs_root_ref item. type is either BTRFS_ROOT_REF_KEY
415 * or BTRFS_ROOT_BACKREF_KEY.
417 * The dirid, sequence, name and name_len refer to the directory entry
418 * that is referencing the root.
420 * For a forward ref, the root_id is the id of the tree referencing
421 * the root and ref_id is the id of the subvol or snapshot.
423 * For a back ref the root_id is the id of the subvol or snapshot and
424 * ref_id is the id of the tree referencing it.
426 * Will return 0, -ENOMEM, or anything from the CoW path
428 int btrfs_add_root_ref(struct btrfs_trans_handle
*trans
,
429 struct btrfs_root
*tree_root
,
430 u64 root_id
, u64 ref_id
, u64 dirid
, u64 sequence
,
431 const char *name
, int name_len
)
433 struct btrfs_key key
;
435 struct btrfs_path
*path
;
436 struct btrfs_root_ref
*ref
;
437 struct extent_buffer
*leaf
;
440 path
= btrfs_alloc_path();
444 key
.objectid
= root_id
;
445 key
.type
= BTRFS_ROOT_BACKREF_KEY
;
448 ret
= btrfs_insert_empty_item(trans
, tree_root
, path
, &key
,
449 sizeof(*ref
) + name_len
);
451 btrfs_abort_transaction(trans
, tree_root
, ret
);
452 btrfs_free_path(path
);
456 leaf
= path
->nodes
[0];
457 ref
= btrfs_item_ptr(leaf
, path
->slots
[0], struct btrfs_root_ref
);
458 btrfs_set_root_ref_dirid(leaf
, ref
, dirid
);
459 btrfs_set_root_ref_sequence(leaf
, ref
, sequence
);
460 btrfs_set_root_ref_name_len(leaf
, ref
, name_len
);
461 ptr
= (unsigned long)(ref
+ 1);
462 write_extent_buffer(leaf
, name
, ptr
, name_len
);
463 btrfs_mark_buffer_dirty(leaf
);
465 if (key
.type
== BTRFS_ROOT_BACKREF_KEY
) {
466 btrfs_release_path(path
);
467 key
.objectid
= ref_id
;
468 key
.type
= BTRFS_ROOT_REF_KEY
;
469 key
.offset
= root_id
;
473 btrfs_free_path(path
);
478 * Old btrfs forgets to init root_item->flags and root_item->byte_limit
479 * for subvolumes. To work around this problem, we steal a bit from
480 * root_item->inode_item->flags, and use it to indicate if those fields
481 * have been properly initialized.
483 void btrfs_check_and_init_root_item(struct btrfs_root_item
*root_item
)
485 u64 inode_flags
= btrfs_stack_inode_flags(&root_item
->inode
);
487 if (!(inode_flags
& BTRFS_INODE_ROOT_ITEM_INIT
)) {
488 inode_flags
|= BTRFS_INODE_ROOT_ITEM_INIT
;
489 btrfs_set_stack_inode_flags(&root_item
->inode
, inode_flags
);
490 btrfs_set_root_flags(root_item
, 0);
491 btrfs_set_root_limit(root_item
, 0);
495 void btrfs_update_root_times(struct btrfs_trans_handle
*trans
,
496 struct btrfs_root
*root
)
498 struct btrfs_root_item
*item
= &root
->root_item
;
499 struct timespec ct
= CURRENT_TIME
;
501 spin_lock(&root
->root_item_lock
);
502 btrfs_set_root_ctransid(item
, trans
->transid
);
503 btrfs_set_stack_timespec_sec(&item
->ctime
, ct
.tv_sec
);
504 btrfs_set_stack_timespec_nsec(&item
->ctime
, ct
.tv_nsec
);
505 spin_unlock(&root
->root_item_lock
);