xref: /openbmc/linux/fs/btrfs/root-tree.c (revision 82003e04)
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
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.
7  *
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.
12  *
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.
17  */
18 
19 #include <linux/err.h>
20 #include <linux/uuid.h>
21 #include "ctree.h"
22 #include "transaction.h"
23 #include "disk-io.h"
24 #include "print-tree.h"
25 
26 /*
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.
32  */
33 static void btrfs_read_root_item(struct extent_buffer *eb, int slot,
34 				struct btrfs_root_item *item)
35 {
36 	uuid_le uuid;
37 	int len;
38 	int need_reset = 0;
39 
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))
44 		need_reset = 1;
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,
49 					"mismatching generation and generation_v2 found in root item. This root was probably mounted with an older kernel. Resetting all new fields.");
50 		}
51 		need_reset = 1;
52 	}
53 	if (need_reset) {
54 		memset(&item->generation_v2, 0,
55 			sizeof(*item) - offsetof(struct btrfs_root_item,
56 					generation_v2));
57 
58 		uuid_le_gen(&uuid);
59 		memcpy(item->uuid, uuid.b, BTRFS_UUID_SIZE);
60 	}
61 }
62 
63 /*
64  * btrfs_find_root - lookup the root by the key.
65  * root: the root of the root tree
66  * search_key: the key to search
67  * path: the path we search
68  * root_item: the root item of the tree we look for
69  * root_key: the root key of the tree we look for
70  *
71  * If ->offset of 'search_key' is -1ULL, it means we are not sure the offset
72  * of the search key, just lookup the root with the highest offset for a
73  * given objectid.
74  *
75  * If we find something return 0, otherwise > 0, < 0 on error.
76  */
77 int btrfs_find_root(struct btrfs_root *root, struct btrfs_key *search_key,
78 		    struct btrfs_path *path, struct btrfs_root_item *root_item,
79 		    struct btrfs_key *root_key)
80 {
81 	struct btrfs_key found_key;
82 	struct extent_buffer *l;
83 	int ret;
84 	int slot;
85 
86 	ret = btrfs_search_slot(NULL, root, search_key, path, 0, 0);
87 	if (ret < 0)
88 		return ret;
89 
90 	if (search_key->offset != -1ULL) {	/* the search key is exact */
91 		if (ret > 0)
92 			goto out;
93 	} else {
94 		BUG_ON(ret == 0);		/* Logical error */
95 		if (path->slots[0] == 0)
96 			goto out;
97 		path->slots[0]--;
98 		ret = 0;
99 	}
100 
101 	l = path->nodes[0];
102 	slot = path->slots[0];
103 
104 	btrfs_item_key_to_cpu(l, &found_key, slot);
105 	if (found_key.objectid != search_key->objectid ||
106 	    found_key.type != BTRFS_ROOT_ITEM_KEY) {
107 		ret = 1;
108 		goto out;
109 	}
110 
111 	if (root_item)
112 		btrfs_read_root_item(l, slot, root_item);
113 	if (root_key)
114 		memcpy(root_key, &found_key, sizeof(found_key));
115 out:
116 	btrfs_release_path(path);
117 	return ret;
118 }
119 
120 void btrfs_set_root_node(struct btrfs_root_item *item,
121 			 struct extent_buffer *node)
122 {
123 	btrfs_set_root_bytenr(item, node->start);
124 	btrfs_set_root_level(item, btrfs_header_level(node));
125 	btrfs_set_root_generation(item, btrfs_header_generation(node));
126 }
127 
128 /*
129  * copy the data in 'item' into the btree
130  */
131 int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
132 		      *root, struct btrfs_key *key, struct btrfs_root_item
133 		      *item)
134 {
135 	struct btrfs_path *path;
136 	struct extent_buffer *l;
137 	int ret;
138 	int slot;
139 	unsigned long ptr;
140 	u32 old_len;
141 
142 	path = btrfs_alloc_path();
143 	if (!path)
144 		return -ENOMEM;
145 
146 	ret = btrfs_search_slot(trans, root, key, path, 0, 1);
147 	if (ret < 0) {
148 		btrfs_abort_transaction(trans, ret);
149 		goto out;
150 	}
151 
152 	if (ret != 0) {
153 		btrfs_print_leaf(root, path->nodes[0]);
154 		btrfs_crit(root->fs_info,
155 			   "unable to update root key %llu %u %llu",
156 			   key->objectid, key->type, key->offset);
157 		BUG_ON(1);
158 	}
159 
160 	l = path->nodes[0];
161 	slot = path->slots[0];
162 	ptr = btrfs_item_ptr_offset(l, slot);
163 	old_len = btrfs_item_size_nr(l, slot);
164 
165 	/*
166 	 * If this is the first time we update the root item which originated
167 	 * from an older kernel, we need to enlarge the item size to make room
168 	 * for the added fields.
169 	 */
170 	if (old_len < sizeof(*item)) {
171 		btrfs_release_path(path);
172 		ret = btrfs_search_slot(trans, root, key, path,
173 				-1, 1);
174 		if (ret < 0) {
175 			btrfs_abort_transaction(trans, ret);
176 			goto out;
177 		}
178 
179 		ret = btrfs_del_item(trans, root, path);
180 		if (ret < 0) {
181 			btrfs_abort_transaction(trans, ret);
182 			goto out;
183 		}
184 		btrfs_release_path(path);
185 		ret = btrfs_insert_empty_item(trans, root, path,
186 				key, sizeof(*item));
187 		if (ret < 0) {
188 			btrfs_abort_transaction(trans, ret);
189 			goto out;
190 		}
191 		l = path->nodes[0];
192 		slot = path->slots[0];
193 		ptr = btrfs_item_ptr_offset(l, slot);
194 	}
195 
196 	/*
197 	 * Update generation_v2 so at the next mount we know the new root
198 	 * fields are valid.
199 	 */
200 	btrfs_set_root_generation_v2(item, btrfs_root_generation(item));
201 
202 	write_extent_buffer(l, item, ptr, sizeof(*item));
203 	btrfs_mark_buffer_dirty(path->nodes[0]);
204 out:
205 	btrfs_free_path(path);
206 	return ret;
207 }
208 
209 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
210 		      struct btrfs_key *key, struct btrfs_root_item *item)
211 {
212 	/*
213 	 * Make sure generation v1 and v2 match. See update_root for details.
214 	 */
215 	btrfs_set_root_generation_v2(item, btrfs_root_generation(item));
216 	return btrfs_insert_item(trans, root, key, item, sizeof(*item));
217 }
218 
219 int btrfs_find_orphan_roots(struct btrfs_root *tree_root)
220 {
221 	struct extent_buffer *leaf;
222 	struct btrfs_path *path;
223 	struct btrfs_key key;
224 	struct btrfs_key root_key;
225 	struct btrfs_root *root;
226 	int err = 0;
227 	int ret;
228 	bool can_recover = true;
229 
230 	if (tree_root->fs_info->sb->s_flags & MS_RDONLY)
231 		can_recover = false;
232 
233 	path = btrfs_alloc_path();
234 	if (!path)
235 		return -ENOMEM;
236 
237 	key.objectid = BTRFS_ORPHAN_OBJECTID;
238 	key.type = BTRFS_ORPHAN_ITEM_KEY;
239 	key.offset = 0;
240 
241 	root_key.type = BTRFS_ROOT_ITEM_KEY;
242 	root_key.offset = (u64)-1;
243 
244 	while (1) {
245 		ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
246 		if (ret < 0) {
247 			err = ret;
248 			break;
249 		}
250 
251 		leaf = path->nodes[0];
252 		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
253 			ret = btrfs_next_leaf(tree_root, path);
254 			if (ret < 0)
255 				err = ret;
256 			if (ret != 0)
257 				break;
258 			leaf = path->nodes[0];
259 		}
260 
261 		btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
262 		btrfs_release_path(path);
263 
264 		if (key.objectid != BTRFS_ORPHAN_OBJECTID ||
265 		    key.type != BTRFS_ORPHAN_ITEM_KEY)
266 			break;
267 
268 		root_key.objectid = key.offset;
269 		key.offset++;
270 
271 		/*
272 		 * The root might have been inserted already, as before we look
273 		 * for orphan roots, log replay might have happened, which
274 		 * triggers a transaction commit and qgroup accounting, which
275 		 * in turn reads and inserts fs roots while doing backref
276 		 * walking.
277 		 */
278 		root = btrfs_lookup_fs_root(tree_root->fs_info,
279 					    root_key.objectid);
280 		if (root) {
281 			WARN_ON(!test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED,
282 					  &root->state));
283 			if (btrfs_root_refs(&root->root_item) == 0)
284 				btrfs_add_dead_root(root);
285 			continue;
286 		}
287 
288 		root = btrfs_read_fs_root(tree_root, &root_key);
289 		err = PTR_ERR_OR_ZERO(root);
290 		if (err && err != -ENOENT) {
291 			break;
292 		} else if (err == -ENOENT) {
293 			struct btrfs_trans_handle *trans;
294 
295 			btrfs_release_path(path);
296 
297 			trans = btrfs_join_transaction(tree_root);
298 			if (IS_ERR(trans)) {
299 				err = PTR_ERR(trans);
300 				btrfs_handle_fs_error(tree_root->fs_info, err,
301 					    "Failed to start trans to delete orphan item");
302 				break;
303 			}
304 			err = btrfs_del_orphan_item(trans, tree_root,
305 						    root_key.objectid);
306 			btrfs_end_transaction(trans, tree_root);
307 			if (err) {
308 				btrfs_handle_fs_error(tree_root->fs_info, err,
309 					    "Failed to delete root orphan item");
310 				break;
311 			}
312 			continue;
313 		}
314 
315 		err = btrfs_init_fs_root(root);
316 		if (err) {
317 			btrfs_free_fs_root(root);
318 			break;
319 		}
320 
321 		set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
322 
323 		err = btrfs_insert_fs_root(root->fs_info, root);
324 		if (err) {
325 			BUG_ON(err == -EEXIST);
326 			btrfs_free_fs_root(root);
327 			break;
328 		}
329 
330 		if (btrfs_root_refs(&root->root_item) == 0)
331 			btrfs_add_dead_root(root);
332 	}
333 
334 	btrfs_free_path(path);
335 	return err;
336 }
337 
338 /* drop the root item for 'key' from 'root' */
339 int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
340 		   struct btrfs_key *key)
341 {
342 	struct btrfs_path *path;
343 	int ret;
344 
345 	path = btrfs_alloc_path();
346 	if (!path)
347 		return -ENOMEM;
348 	ret = btrfs_search_slot(trans, root, key, path, -1, 1);
349 	if (ret < 0)
350 		goto out;
351 
352 	BUG_ON(ret != 0);
353 
354 	ret = btrfs_del_item(trans, root, path);
355 out:
356 	btrfs_free_path(path);
357 	return ret;
358 }
359 
360 int btrfs_del_root_ref(struct btrfs_trans_handle *trans,
361 		       struct btrfs_root *tree_root,
362 		       u64 root_id, u64 ref_id, u64 dirid, u64 *sequence,
363 		       const char *name, int name_len)
364 
365 {
366 	struct btrfs_path *path;
367 	struct btrfs_root_ref *ref;
368 	struct extent_buffer *leaf;
369 	struct btrfs_key key;
370 	unsigned long ptr;
371 	int err = 0;
372 	int ret;
373 
374 	path = btrfs_alloc_path();
375 	if (!path)
376 		return -ENOMEM;
377 
378 	key.objectid = root_id;
379 	key.type = BTRFS_ROOT_BACKREF_KEY;
380 	key.offset = ref_id;
381 again:
382 	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
383 	BUG_ON(ret < 0);
384 	if (ret == 0) {
385 		leaf = path->nodes[0];
386 		ref = btrfs_item_ptr(leaf, path->slots[0],
387 				     struct btrfs_root_ref);
388 
389 		WARN_ON(btrfs_root_ref_dirid(leaf, ref) != dirid);
390 		WARN_ON(btrfs_root_ref_name_len(leaf, ref) != name_len);
391 		ptr = (unsigned long)(ref + 1);
392 		WARN_ON(memcmp_extent_buffer(leaf, name, ptr, name_len));
393 		*sequence = btrfs_root_ref_sequence(leaf, ref);
394 
395 		ret = btrfs_del_item(trans, tree_root, path);
396 		if (ret) {
397 			err = ret;
398 			goto out;
399 		}
400 	} else
401 		err = -ENOENT;
402 
403 	if (key.type == BTRFS_ROOT_BACKREF_KEY) {
404 		btrfs_release_path(path);
405 		key.objectid = ref_id;
406 		key.type = BTRFS_ROOT_REF_KEY;
407 		key.offset = root_id;
408 		goto again;
409 	}
410 
411 out:
412 	btrfs_free_path(path);
413 	return err;
414 }
415 
416 /*
417  * add a btrfs_root_ref item.  type is either BTRFS_ROOT_REF_KEY
418  * or BTRFS_ROOT_BACKREF_KEY.
419  *
420  * The dirid, sequence, name and name_len refer to the directory entry
421  * that is referencing the root.
422  *
423  * For a forward ref, the root_id is the id of the tree referencing
424  * the root and ref_id is the id of the subvol  or snapshot.
425  *
426  * For a back ref the root_id is the id of the subvol or snapshot and
427  * ref_id is the id of the tree referencing it.
428  *
429  * Will return 0, -ENOMEM, or anything from the CoW path
430  */
431 int btrfs_add_root_ref(struct btrfs_trans_handle *trans,
432 		       struct btrfs_root *tree_root,
433 		       u64 root_id, u64 ref_id, u64 dirid, u64 sequence,
434 		       const char *name, int name_len)
435 {
436 	struct btrfs_key key;
437 	int ret;
438 	struct btrfs_path *path;
439 	struct btrfs_root_ref *ref;
440 	struct extent_buffer *leaf;
441 	unsigned long ptr;
442 
443 	path = btrfs_alloc_path();
444 	if (!path)
445 		return -ENOMEM;
446 
447 	key.objectid = root_id;
448 	key.type = BTRFS_ROOT_BACKREF_KEY;
449 	key.offset = ref_id;
450 again:
451 	ret = btrfs_insert_empty_item(trans, tree_root, path, &key,
452 				      sizeof(*ref) + name_len);
453 	if (ret) {
454 		btrfs_abort_transaction(trans, ret);
455 		btrfs_free_path(path);
456 		return ret;
457 	}
458 
459 	leaf = path->nodes[0];
460 	ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
461 	btrfs_set_root_ref_dirid(leaf, ref, dirid);
462 	btrfs_set_root_ref_sequence(leaf, ref, sequence);
463 	btrfs_set_root_ref_name_len(leaf, ref, name_len);
464 	ptr = (unsigned long)(ref + 1);
465 	write_extent_buffer(leaf, name, ptr, name_len);
466 	btrfs_mark_buffer_dirty(leaf);
467 
468 	if (key.type == BTRFS_ROOT_BACKREF_KEY) {
469 		btrfs_release_path(path);
470 		key.objectid = ref_id;
471 		key.type = BTRFS_ROOT_REF_KEY;
472 		key.offset = root_id;
473 		goto again;
474 	}
475 
476 	btrfs_free_path(path);
477 	return 0;
478 }
479 
480 /*
481  * Old btrfs forgets to init root_item->flags and root_item->byte_limit
482  * for subvolumes. To work around this problem, we steal a bit from
483  * root_item->inode_item->flags, and use it to indicate if those fields
484  * have been properly initialized.
485  */
486 void btrfs_check_and_init_root_item(struct btrfs_root_item *root_item)
487 {
488 	u64 inode_flags = btrfs_stack_inode_flags(&root_item->inode);
489 
490 	if (!(inode_flags & BTRFS_INODE_ROOT_ITEM_INIT)) {
491 		inode_flags |= BTRFS_INODE_ROOT_ITEM_INIT;
492 		btrfs_set_stack_inode_flags(&root_item->inode, inode_flags);
493 		btrfs_set_root_flags(root_item, 0);
494 		btrfs_set_root_limit(root_item, 0);
495 	}
496 }
497 
498 void btrfs_update_root_times(struct btrfs_trans_handle *trans,
499 			     struct btrfs_root *root)
500 {
501 	struct btrfs_root_item *item = &root->root_item;
502 	struct timespec ct = current_fs_time(root->fs_info->sb);
503 
504 	spin_lock(&root->root_item_lock);
505 	btrfs_set_root_ctransid(item, trans->transid);
506 	btrfs_set_stack_timespec_sec(&item->ctime, ct.tv_sec);
507 	btrfs_set_stack_timespec_nsec(&item->ctime, ct.tv_nsec);
508 	spin_unlock(&root->root_item_lock);
509 }
510