Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (C) 2007 Oracle. All rights reserved.
4 : */
5 :
6 : #include <linux/fs.h>
7 : #include <linux/blkdev.h>
8 : #include <linux/radix-tree.h>
9 : #include <linux/writeback.h>
10 : #include <linux/workqueue.h>
11 : #include <linux/kthread.h>
12 : #include <linux/slab.h>
13 : #include <linux/migrate.h>
14 : #include <linux/ratelimit.h>
15 : #include <linux/uuid.h>
16 : #include <linux/semaphore.h>
17 : #include <linux/error-injection.h>
18 : #include <linux/crc32c.h>
19 : #include <linux/sched/mm.h>
20 : #include <asm/unaligned.h>
21 : #include <crypto/hash.h>
22 : #include "ctree.h"
23 : #include "disk-io.h"
24 : #include "transaction.h"
25 : #include "btrfs_inode.h"
26 : #include "bio.h"
27 : #include "print-tree.h"
28 : #include "locking.h"
29 : #include "tree-log.h"
30 : #include "free-space-cache.h"
31 : #include "free-space-tree.h"
32 : #include "check-integrity.h"
33 : #include "rcu-string.h"
34 : #include "dev-replace.h"
35 : #include "raid56.h"
36 : #include "sysfs.h"
37 : #include "qgroup.h"
38 : #include "compression.h"
39 : #include "tree-checker.h"
40 : #include "ref-verify.h"
41 : #include "block-group.h"
42 : #include "discard.h"
43 : #include "space-info.h"
44 : #include "zoned.h"
45 : #include "subpage.h"
46 : #include "fs.h"
47 : #include "accessors.h"
48 : #include "extent-tree.h"
49 : #include "root-tree.h"
50 : #include "defrag.h"
51 : #include "uuid-tree.h"
52 : #include "relocation.h"
53 : #include "scrub.h"
54 : #include "super.h"
55 :
56 : #define BTRFS_SUPER_FLAG_SUPP (BTRFS_HEADER_FLAG_WRITTEN |\
57 : BTRFS_HEADER_FLAG_RELOC |\
58 : BTRFS_SUPER_FLAG_ERROR |\
59 : BTRFS_SUPER_FLAG_SEEDING |\
60 : BTRFS_SUPER_FLAG_METADUMP |\
61 : BTRFS_SUPER_FLAG_METADUMP_V2)
62 :
63 : static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);
64 : static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);
65 :
66 0 : static void btrfs_free_csum_hash(struct btrfs_fs_info *fs_info)
67 : {
68 0 : if (fs_info->csum_shash)
69 0 : crypto_free_shash(fs_info->csum_shash);
70 0 : }
71 :
72 : /*
73 : * Compute the csum of a btree block and store the result to provided buffer.
74 : */
75 0 : static void csum_tree_block(struct extent_buffer *buf, u8 *result)
76 : {
77 0 : struct btrfs_fs_info *fs_info = buf->fs_info;
78 0 : const int num_pages = num_extent_pages(buf);
79 0 : const int first_page_part = min_t(u32, PAGE_SIZE, fs_info->nodesize);
80 0 : SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
81 0 : char *kaddr;
82 0 : int i;
83 :
84 0 : shash->tfm = fs_info->csum_shash;
85 0 : crypto_shash_init(shash);
86 0 : kaddr = page_address(buf->pages[0]) + offset_in_page(buf->start);
87 0 : crypto_shash_update(shash, kaddr + BTRFS_CSUM_SIZE,
88 0 : first_page_part - BTRFS_CSUM_SIZE);
89 :
90 0 : for (i = 1; i < num_pages && INLINE_EXTENT_BUFFER_PAGES > 1; i++) {
91 : kaddr = page_address(buf->pages[i]);
92 : crypto_shash_update(shash, kaddr, PAGE_SIZE);
93 : }
94 0 : memset(result, 0, BTRFS_CSUM_SIZE);
95 0 : crypto_shash_final(shash, result);
96 0 : }
97 :
98 : /*
99 : * we can't consider a given block up to date unless the transid of the
100 : * block matches the transid in the parent node's pointer. This is how we
101 : * detect blocks that either didn't get written at all or got written
102 : * in the wrong place.
103 : */
104 0 : int btrfs_buffer_uptodate(struct extent_buffer *eb, u64 parent_transid, int atomic)
105 : {
106 0 : if (!extent_buffer_uptodate(eb))
107 : return 0;
108 :
109 0 : if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
110 : return 1;
111 :
112 0 : if (atomic)
113 : return -EAGAIN;
114 :
115 0 : if (!extent_buffer_uptodate(eb) ||
116 : btrfs_header_generation(eb) != parent_transid) {
117 0 : btrfs_err_rl(eb->fs_info,
118 : "parent transid verify failed on logical %llu mirror %u wanted %llu found %llu",
119 : eb->start, eb->read_mirror,
120 : parent_transid, btrfs_header_generation(eb));
121 0 : clear_extent_buffer_uptodate(eb);
122 0 : return 0;
123 : }
124 : return 1;
125 : }
126 :
127 : static bool btrfs_supported_super_csum(u16 csum_type)
128 : {
129 0 : switch (csum_type) {
130 : case BTRFS_CSUM_TYPE_CRC32:
131 : case BTRFS_CSUM_TYPE_XXHASH:
132 : case BTRFS_CSUM_TYPE_SHA256:
133 : case BTRFS_CSUM_TYPE_BLAKE2:
134 : return true;
135 : default:
136 0 : return false;
137 : }
138 : }
139 :
140 : /*
141 : * Return 0 if the superblock checksum type matches the checksum value of that
142 : * algorithm. Pass the raw disk superblock data.
143 : */
144 0 : int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
145 : const struct btrfs_super_block *disk_sb)
146 : {
147 0 : char result[BTRFS_CSUM_SIZE];
148 0 : SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
149 :
150 0 : shash->tfm = fs_info->csum_shash;
151 :
152 : /*
153 : * The super_block structure does not span the whole
154 : * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space is
155 : * filled with zeros and is included in the checksum.
156 : */
157 0 : crypto_shash_digest(shash, (const u8 *)disk_sb + BTRFS_CSUM_SIZE,
158 : BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE, result);
159 :
160 0 : if (memcmp(disk_sb->csum, result, fs_info->csum_size))
161 0 : return 1;
162 :
163 : return 0;
164 : }
165 :
166 0 : static int btrfs_repair_eb_io_failure(const struct extent_buffer *eb,
167 : int mirror_num)
168 : {
169 0 : struct btrfs_fs_info *fs_info = eb->fs_info;
170 0 : int i, num_pages = num_extent_pages(eb);
171 0 : int ret = 0;
172 :
173 0 : if (sb_rdonly(fs_info->sb))
174 : return -EROFS;
175 :
176 0 : for (i = 0; i < num_pages; i++) {
177 0 : struct page *p = eb->pages[i];
178 0 : u64 start = max_t(u64, eb->start, page_offset(p));
179 0 : u64 end = min_t(u64, eb->start + eb->len, page_offset(p) + PAGE_SIZE);
180 0 : u32 len = end - start;
181 :
182 0 : ret = btrfs_repair_io_failure(fs_info, 0, start, len,
183 : start, p, offset_in_page(start), mirror_num);
184 0 : if (ret)
185 : break;
186 : }
187 :
188 : return ret;
189 : }
190 :
191 : /*
192 : * helper to read a given tree block, doing retries as required when
193 : * the checksums don't match and we have alternate mirrors to try.
194 : *
195 : * @check: expected tree parentness check, see the comments of the
196 : * structure for details.
197 : */
198 0 : int btrfs_read_extent_buffer(struct extent_buffer *eb,
199 : struct btrfs_tree_parent_check *check)
200 : {
201 0 : struct btrfs_fs_info *fs_info = eb->fs_info;
202 0 : int failed = 0;
203 0 : int ret;
204 0 : int num_copies = 0;
205 0 : int mirror_num = 0;
206 0 : int failed_mirror = 0;
207 :
208 0 : ASSERT(check);
209 :
210 0 : while (1) {
211 0 : clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
212 0 : ret = read_extent_buffer_pages(eb, WAIT_COMPLETE, mirror_num, check);
213 0 : if (!ret)
214 : break;
215 :
216 0 : num_copies = btrfs_num_copies(fs_info,
217 0 : eb->start, eb->len);
218 0 : if (num_copies == 1)
219 : break;
220 :
221 0 : if (!failed_mirror) {
222 0 : failed = 1;
223 0 : failed_mirror = eb->read_mirror;
224 : }
225 :
226 0 : mirror_num++;
227 0 : if (mirror_num == failed_mirror)
228 0 : mirror_num++;
229 :
230 0 : if (mirror_num > num_copies)
231 : break;
232 : }
233 :
234 0 : if (failed && !ret && failed_mirror)
235 0 : btrfs_repair_eb_io_failure(eb, failed_mirror);
236 :
237 0 : return ret;
238 : }
239 :
240 : /*
241 : * Checksum a dirty tree block before IO.
242 : */
243 0 : blk_status_t btree_csum_one_bio(struct btrfs_bio *bbio)
244 : {
245 0 : struct extent_buffer *eb = bbio->private;
246 0 : struct btrfs_fs_info *fs_info = eb->fs_info;
247 0 : u64 found_start = btrfs_header_bytenr(eb);
248 0 : u8 result[BTRFS_CSUM_SIZE];
249 0 : int ret;
250 :
251 : /* Btree blocks are always contiguous on disk. */
252 0 : if (WARN_ON_ONCE(bbio->file_offset != eb->start))
253 : return BLK_STS_IOERR;
254 0 : if (WARN_ON_ONCE(bbio->bio.bi_iter.bi_size != eb->len))
255 : return BLK_STS_IOERR;
256 :
257 0 : if (test_bit(EXTENT_BUFFER_NO_CHECK, &eb->bflags)) {
258 0 : WARN_ON_ONCE(found_start != 0);
259 0 : return BLK_STS_OK;
260 : }
261 :
262 0 : if (WARN_ON_ONCE(found_start != eb->start))
263 : return BLK_STS_IOERR;
264 0 : if (WARN_ON(!btrfs_page_test_uptodate(fs_info, eb->pages[0], eb->start,
265 : eb->len)))
266 : return BLK_STS_IOERR;
267 :
268 0 : ASSERT(memcmp_extent_buffer(eb, fs_info->fs_devices->metadata_uuid,
269 : offsetof(struct btrfs_header, fsid),
270 : BTRFS_FSID_SIZE) == 0);
271 0 : csum_tree_block(eb, result);
272 :
273 0 : if (btrfs_header_level(eb))
274 0 : ret = btrfs_check_node(eb);
275 : else
276 0 : ret = btrfs_check_leaf(eb);
277 :
278 0 : if (ret < 0)
279 0 : goto error;
280 :
281 : /*
282 : * Also check the generation, the eb reached here must be newer than
283 : * last committed. Or something seriously wrong happened.
284 : */
285 0 : if (unlikely(btrfs_header_generation(eb) <= fs_info->last_trans_committed)) {
286 0 : ret = -EUCLEAN;
287 0 : btrfs_err(fs_info,
288 : "block=%llu bad generation, have %llu expect > %llu",
289 : eb->start, btrfs_header_generation(eb),
290 : fs_info->last_trans_committed);
291 0 : goto error;
292 : }
293 0 : write_extent_buffer(eb, result, 0, fs_info->csum_size);
294 0 : return BLK_STS_OK;
295 :
296 0 : error:
297 0 : btrfs_print_tree(eb, 0);
298 0 : btrfs_err(fs_info, "block=%llu write time tree block corruption detected",
299 : eb->start);
300 : /*
301 : * Be noisy if this is an extent buffer from a log tree. We don't abort
302 : * a transaction in case there's a bad log tree extent buffer, we just
303 : * fallback to a transaction commit. Still we want to know when there is
304 : * a bad log tree extent buffer, as that may signal a bug somewhere.
305 : */
306 0 : WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG) ||
307 : btrfs_header_owner(eb) == BTRFS_TREE_LOG_OBJECTID);
308 0 : return errno_to_blk_status(ret);
309 : }
310 :
311 0 : static bool check_tree_block_fsid(struct extent_buffer *eb)
312 : {
313 0 : struct btrfs_fs_info *fs_info = eb->fs_info;
314 0 : struct btrfs_fs_devices *fs_devices = fs_info->fs_devices, *seed_devs;
315 0 : u8 fsid[BTRFS_FSID_SIZE];
316 0 : u8 *metadata_uuid;
317 :
318 0 : read_extent_buffer(eb, fsid, offsetof(struct btrfs_header, fsid),
319 : BTRFS_FSID_SIZE);
320 : /*
321 : * Checking the incompat flag is only valid for the current fs. For
322 : * seed devices it's forbidden to have their uuid changed so reading
323 : * ->fsid in this case is fine
324 : */
325 0 : if (btrfs_fs_incompat(fs_info, METADATA_UUID))
326 0 : metadata_uuid = fs_devices->metadata_uuid;
327 : else
328 0 : metadata_uuid = fs_devices->fsid;
329 :
330 0 : if (!memcmp(fsid, metadata_uuid, BTRFS_FSID_SIZE))
331 : return false;
332 :
333 0 : list_for_each_entry(seed_devs, &fs_devices->seed_list, seed_list)
334 0 : if (!memcmp(fsid, seed_devs->fsid, BTRFS_FSID_SIZE))
335 : return false;
336 :
337 : return true;
338 : }
339 :
340 : /* Do basic extent buffer checks at read time */
341 0 : int btrfs_validate_extent_buffer(struct extent_buffer *eb,
342 : struct btrfs_tree_parent_check *check)
343 : {
344 0 : struct btrfs_fs_info *fs_info = eb->fs_info;
345 0 : u64 found_start;
346 0 : const u32 csum_size = fs_info->csum_size;
347 0 : u8 found_level;
348 0 : u8 result[BTRFS_CSUM_SIZE];
349 0 : const u8 *header_csum;
350 0 : int ret = 0;
351 :
352 0 : ASSERT(check);
353 :
354 0 : found_start = btrfs_header_bytenr(eb);
355 0 : if (found_start != eb->start) {
356 0 : btrfs_err_rl(fs_info,
357 : "bad tree block start, mirror %u want %llu have %llu",
358 : eb->read_mirror, eb->start, found_start);
359 0 : ret = -EIO;
360 0 : goto out;
361 : }
362 0 : if (check_tree_block_fsid(eb)) {
363 0 : btrfs_err_rl(fs_info, "bad fsid on logical %llu mirror %u",
364 : eb->start, eb->read_mirror);
365 0 : ret = -EIO;
366 0 : goto out;
367 : }
368 0 : found_level = btrfs_header_level(eb);
369 0 : if (found_level >= BTRFS_MAX_LEVEL) {
370 0 : btrfs_err(fs_info,
371 : "bad tree block level, mirror %u level %d on logical %llu",
372 : eb->read_mirror, btrfs_header_level(eb), eb->start);
373 0 : ret = -EIO;
374 0 : goto out;
375 : }
376 :
377 0 : csum_tree_block(eb, result);
378 0 : header_csum = page_address(eb->pages[0]) +
379 : get_eb_offset_in_page(eb, offsetof(struct btrfs_header, csum));
380 :
381 0 : if (memcmp(result, header_csum, csum_size) != 0) {
382 0 : btrfs_warn_rl(fs_info,
383 : "checksum verify failed on logical %llu mirror %u wanted " CSUM_FMT " found " CSUM_FMT " level %d",
384 : eb->start, eb->read_mirror,
385 : CSUM_FMT_VALUE(csum_size, header_csum),
386 : CSUM_FMT_VALUE(csum_size, result),
387 : btrfs_header_level(eb));
388 0 : ret = -EUCLEAN;
389 0 : goto out;
390 : }
391 :
392 0 : if (found_level != check->level) {
393 0 : btrfs_err(fs_info,
394 : "level verify failed on logical %llu mirror %u wanted %u found %u",
395 : eb->start, eb->read_mirror, check->level, found_level);
396 0 : ret = -EIO;
397 0 : goto out;
398 : }
399 0 : if (unlikely(check->transid &&
400 : btrfs_header_generation(eb) != check->transid)) {
401 0 : btrfs_err_rl(eb->fs_info,
402 : "parent transid verify failed on logical %llu mirror %u wanted %llu found %llu",
403 : eb->start, eb->read_mirror, check->transid,
404 : btrfs_header_generation(eb));
405 0 : ret = -EIO;
406 0 : goto out;
407 : }
408 0 : if (check->has_first_key) {
409 0 : struct btrfs_key *expect_key = &check->first_key;
410 0 : struct btrfs_key found_key;
411 :
412 0 : if (found_level)
413 0 : btrfs_node_key_to_cpu(eb, &found_key, 0);
414 : else
415 0 : btrfs_item_key_to_cpu(eb, &found_key, 0);
416 0 : if (unlikely(btrfs_comp_cpu_keys(expect_key, &found_key))) {
417 0 : btrfs_err(fs_info,
418 : "tree first key mismatch detected, bytenr=%llu parent_transid=%llu key expected=(%llu,%u,%llu) has=(%llu,%u,%llu)",
419 : eb->start, check->transid,
420 : expect_key->objectid,
421 : expect_key->type, expect_key->offset,
422 : found_key.objectid, found_key.type,
423 : found_key.offset);
424 0 : ret = -EUCLEAN;
425 0 : goto out;
426 : }
427 : }
428 0 : if (check->owner_root) {
429 0 : ret = btrfs_check_eb_owner(eb, check->owner_root);
430 0 : if (ret < 0)
431 0 : goto out;
432 : }
433 :
434 : /*
435 : * If this is a leaf block and it is corrupt, set the corrupt bit so
436 : * that we don't try and read the other copies of this block, just
437 : * return -EIO.
438 : */
439 0 : if (found_level == 0 && btrfs_check_leaf(eb)) {
440 0 : set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
441 : ret = -EIO;
442 : }
443 :
444 0 : if (found_level > 0 && btrfs_check_node(eb))
445 : ret = -EIO;
446 :
447 0 : if (ret)
448 0 : btrfs_err(fs_info,
449 : "read time tree block corruption detected on logical %llu mirror %u",
450 : eb->start, eb->read_mirror);
451 0 : out:
452 0 : return ret;
453 : }
454 :
455 : #ifdef CONFIG_MIGRATION
456 0 : static int btree_migrate_folio(struct address_space *mapping,
457 : struct folio *dst, struct folio *src, enum migrate_mode mode)
458 : {
459 : /*
460 : * we can't safely write a btree page from here,
461 : * we haven't done the locking hook
462 : */
463 0 : if (folio_test_dirty(src))
464 : return -EAGAIN;
465 : /*
466 : * Buffers may be managed in a filesystem specific way.
467 : * We must have no buffers or drop them.
468 : */
469 0 : if (folio_get_private(src) &&
470 0 : !filemap_release_folio(src, GFP_KERNEL))
471 : return -EAGAIN;
472 0 : return migrate_folio(mapping, dst, src, mode);
473 : }
474 : #else
475 : #define btree_migrate_folio NULL
476 : #endif
477 :
478 0 : static int btree_writepages(struct address_space *mapping,
479 : struct writeback_control *wbc)
480 : {
481 0 : struct btrfs_fs_info *fs_info;
482 0 : int ret;
483 :
484 0 : if (wbc->sync_mode == WB_SYNC_NONE) {
485 :
486 0 : if (wbc->for_kupdate)
487 : return 0;
488 :
489 0 : fs_info = BTRFS_I(mapping->host)->root->fs_info;
490 : /* this is a bit racy, but that's ok */
491 0 : ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
492 : BTRFS_DIRTY_METADATA_THRESH,
493 : fs_info->dirty_metadata_batch);
494 0 : if (ret < 0)
495 : return 0;
496 : }
497 0 : return btree_write_cache_pages(mapping, wbc);
498 : }
499 :
500 0 : static bool btree_release_folio(struct folio *folio, gfp_t gfp_flags)
501 : {
502 0 : if (folio_test_writeback(folio) || folio_test_dirty(folio))
503 : return false;
504 :
505 0 : return try_release_extent_buffer(&folio->page);
506 : }
507 :
508 0 : static void btree_invalidate_folio(struct folio *folio, size_t offset,
509 : size_t length)
510 : {
511 0 : struct extent_io_tree *tree;
512 0 : tree = &BTRFS_I(folio->mapping->host)->io_tree;
513 0 : extent_invalidate_folio(tree, folio, offset);
514 0 : btree_release_folio(folio, GFP_NOFS);
515 0 : if (folio_get_private(folio)) {
516 0 : btrfs_warn(BTRFS_I(folio->mapping->host)->root->fs_info,
517 : "folio private not zero on folio %llu",
518 : (unsigned long long)folio_pos(folio));
519 0 : folio_detach_private(folio);
520 : }
521 0 : }
522 :
523 : #ifdef DEBUG
524 : static bool btree_dirty_folio(struct address_space *mapping,
525 : struct folio *folio)
526 : {
527 : struct btrfs_fs_info *fs_info = btrfs_sb(mapping->host->i_sb);
528 : struct btrfs_subpage *subpage;
529 : struct extent_buffer *eb;
530 : int cur_bit = 0;
531 : u64 page_start = folio_pos(folio);
532 :
533 : if (fs_info->sectorsize == PAGE_SIZE) {
534 : eb = folio_get_private(folio);
535 : BUG_ON(!eb);
536 : BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
537 : BUG_ON(!atomic_read(&eb->refs));
538 : btrfs_assert_tree_write_locked(eb);
539 : return filemap_dirty_folio(mapping, folio);
540 : }
541 : subpage = folio_get_private(folio);
542 :
543 : ASSERT(subpage->dirty_bitmap);
544 : while (cur_bit < BTRFS_SUBPAGE_BITMAP_SIZE) {
545 : unsigned long flags;
546 : u64 cur;
547 : u16 tmp = (1 << cur_bit);
548 :
549 : spin_lock_irqsave(&subpage->lock, flags);
550 : if (!(tmp & subpage->dirty_bitmap)) {
551 : spin_unlock_irqrestore(&subpage->lock, flags);
552 : cur_bit++;
553 : continue;
554 : }
555 : spin_unlock_irqrestore(&subpage->lock, flags);
556 : cur = page_start + cur_bit * fs_info->sectorsize;
557 :
558 : eb = find_extent_buffer(fs_info, cur);
559 : ASSERT(eb);
560 : ASSERT(test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
561 : ASSERT(atomic_read(&eb->refs));
562 : btrfs_assert_tree_write_locked(eb);
563 : free_extent_buffer(eb);
564 :
565 : cur_bit += (fs_info->nodesize >> fs_info->sectorsize_bits);
566 : }
567 : return filemap_dirty_folio(mapping, folio);
568 : }
569 : #else
570 : #define btree_dirty_folio filemap_dirty_folio
571 : #endif
572 :
573 : static const struct address_space_operations btree_aops = {
574 : .writepages = btree_writepages,
575 : .release_folio = btree_release_folio,
576 : .invalidate_folio = btree_invalidate_folio,
577 : .migrate_folio = btree_migrate_folio,
578 : .dirty_folio = btree_dirty_folio,
579 : };
580 :
581 0 : struct extent_buffer *btrfs_find_create_tree_block(
582 : struct btrfs_fs_info *fs_info,
583 : u64 bytenr, u64 owner_root,
584 : int level)
585 : {
586 0 : if (btrfs_is_testing(fs_info))
587 : return alloc_test_extent_buffer(fs_info, bytenr);
588 0 : return alloc_extent_buffer(fs_info, bytenr, owner_root, level);
589 : }
590 :
591 : /*
592 : * Read tree block at logical address @bytenr and do variant basic but critical
593 : * verification.
594 : *
595 : * @check: expected tree parentness check, see comments of the
596 : * structure for details.
597 : */
598 0 : struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
599 : struct btrfs_tree_parent_check *check)
600 : {
601 0 : struct extent_buffer *buf = NULL;
602 0 : int ret;
603 :
604 0 : ASSERT(check);
605 :
606 0 : buf = btrfs_find_create_tree_block(fs_info, bytenr, check->owner_root,
607 0 : check->level);
608 0 : if (IS_ERR(buf))
609 : return buf;
610 :
611 0 : ret = btrfs_read_extent_buffer(buf, check);
612 0 : if (ret) {
613 0 : free_extent_buffer_stale(buf);
614 0 : return ERR_PTR(ret);
615 : }
616 0 : if (btrfs_check_eb_owner(buf, check->owner_root)) {
617 0 : free_extent_buffer_stale(buf);
618 0 : return ERR_PTR(-EUCLEAN);
619 : }
620 : return buf;
621 :
622 : }
623 :
624 0 : static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
625 : u64 objectid)
626 : {
627 0 : bool dummy = test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
628 :
629 0 : memset(&root->root_key, 0, sizeof(root->root_key));
630 0 : memset(&root->root_item, 0, sizeof(root->root_item));
631 0 : memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
632 0 : root->fs_info = fs_info;
633 0 : root->root_key.objectid = objectid;
634 0 : root->node = NULL;
635 0 : root->commit_root = NULL;
636 0 : root->state = 0;
637 0 : RB_CLEAR_NODE(&root->rb_node);
638 :
639 0 : root->last_trans = 0;
640 0 : root->free_objectid = 0;
641 0 : root->nr_delalloc_inodes = 0;
642 0 : root->nr_ordered_extents = 0;
643 0 : root->inode_tree = RB_ROOT;
644 0 : INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
645 :
646 0 : btrfs_init_root_block_rsv(root);
647 :
648 0 : INIT_LIST_HEAD(&root->dirty_list);
649 0 : INIT_LIST_HEAD(&root->root_list);
650 0 : INIT_LIST_HEAD(&root->delalloc_inodes);
651 0 : INIT_LIST_HEAD(&root->delalloc_root);
652 0 : INIT_LIST_HEAD(&root->ordered_extents);
653 0 : INIT_LIST_HEAD(&root->ordered_root);
654 0 : INIT_LIST_HEAD(&root->reloc_dirty_list);
655 0 : INIT_LIST_HEAD(&root->logged_list[0]);
656 0 : INIT_LIST_HEAD(&root->logged_list[1]);
657 0 : spin_lock_init(&root->inode_lock);
658 0 : spin_lock_init(&root->delalloc_lock);
659 0 : spin_lock_init(&root->ordered_extent_lock);
660 0 : spin_lock_init(&root->accounting_lock);
661 0 : spin_lock_init(&root->log_extents_lock[0]);
662 0 : spin_lock_init(&root->log_extents_lock[1]);
663 0 : spin_lock_init(&root->qgroup_meta_rsv_lock);
664 0 : mutex_init(&root->objectid_mutex);
665 0 : mutex_init(&root->log_mutex);
666 0 : mutex_init(&root->ordered_extent_mutex);
667 0 : mutex_init(&root->delalloc_mutex);
668 0 : init_waitqueue_head(&root->qgroup_flush_wait);
669 0 : init_waitqueue_head(&root->log_writer_wait);
670 0 : init_waitqueue_head(&root->log_commit_wait[0]);
671 0 : init_waitqueue_head(&root->log_commit_wait[1]);
672 0 : INIT_LIST_HEAD(&root->log_ctxs[0]);
673 0 : INIT_LIST_HEAD(&root->log_ctxs[1]);
674 0 : atomic_set(&root->log_commit[0], 0);
675 0 : atomic_set(&root->log_commit[1], 0);
676 0 : atomic_set(&root->log_writers, 0);
677 0 : atomic_set(&root->log_batch, 0);
678 0 : refcount_set(&root->refs, 1);
679 0 : atomic_set(&root->snapshot_force_cow, 0);
680 0 : atomic_set(&root->nr_swapfiles, 0);
681 0 : root->log_transid = 0;
682 0 : root->log_transid_committed = -1;
683 0 : root->last_log_commit = 0;
684 0 : root->anon_dev = 0;
685 0 : if (!dummy) {
686 0 : extent_io_tree_init(fs_info, &root->dirty_log_pages,
687 : IO_TREE_ROOT_DIRTY_LOG_PAGES);
688 0 : extent_io_tree_init(fs_info, &root->log_csum_range,
689 : IO_TREE_LOG_CSUM_RANGE);
690 : }
691 :
692 0 : spin_lock_init(&root->root_item_lock);
693 0 : btrfs_qgroup_init_swapped_blocks(&root->swapped_blocks);
694 : #ifdef CONFIG_BTRFS_DEBUG
695 : INIT_LIST_HEAD(&root->leak_list);
696 : spin_lock(&fs_info->fs_roots_radix_lock);
697 : list_add_tail(&root->leak_list, &fs_info->allocated_roots);
698 : spin_unlock(&fs_info->fs_roots_radix_lock);
699 : #endif
700 0 : }
701 :
702 0 : static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
703 : u64 objectid, gfp_t flags)
704 : {
705 0 : struct btrfs_root *root = kzalloc(sizeof(*root), flags);
706 0 : if (root)
707 0 : __setup_root(root, fs_info, objectid);
708 0 : return root;
709 : }
710 :
711 : #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
712 : /* Should only be used by the testing infrastructure */
713 : struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)
714 : {
715 : struct btrfs_root *root;
716 :
717 : if (!fs_info)
718 : return ERR_PTR(-EINVAL);
719 :
720 : root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);
721 : if (!root)
722 : return ERR_PTR(-ENOMEM);
723 :
724 : /* We don't use the stripesize in selftest, set it as sectorsize */
725 : root->alloc_bytenr = 0;
726 :
727 : return root;
728 : }
729 : #endif
730 :
731 : static int global_root_cmp(struct rb_node *a_node, const struct rb_node *b_node)
732 : {
733 0 : const struct btrfs_root *a = rb_entry(a_node, struct btrfs_root, rb_node);
734 0 : const struct btrfs_root *b = rb_entry(b_node, struct btrfs_root, rb_node);
735 :
736 0 : return btrfs_comp_cpu_keys(&a->root_key, &b->root_key);
737 : }
738 :
739 : static int global_root_key_cmp(const void *k, const struct rb_node *node)
740 : {
741 0 : const struct btrfs_key *key = k;
742 0 : const struct btrfs_root *root = rb_entry(node, struct btrfs_root, rb_node);
743 :
744 0 : return btrfs_comp_cpu_keys(key, &root->root_key);
745 : }
746 :
747 0 : int btrfs_global_root_insert(struct btrfs_root *root)
748 : {
749 0 : struct btrfs_fs_info *fs_info = root->fs_info;
750 0 : struct rb_node *tmp;
751 0 : int ret = 0;
752 :
753 0 : write_lock(&fs_info->global_root_lock);
754 0 : tmp = rb_find_add(&root->rb_node, &fs_info->global_root_tree, global_root_cmp);
755 0 : write_unlock(&fs_info->global_root_lock);
756 :
757 0 : if (tmp) {
758 0 : ret = -EEXIST;
759 0 : btrfs_warn(fs_info, "global root %llu %llu already exists",
760 : root->root_key.objectid, root->root_key.offset);
761 : }
762 0 : return ret;
763 : }
764 :
765 0 : void btrfs_global_root_delete(struct btrfs_root *root)
766 : {
767 0 : struct btrfs_fs_info *fs_info = root->fs_info;
768 :
769 0 : write_lock(&fs_info->global_root_lock);
770 0 : rb_erase(&root->rb_node, &fs_info->global_root_tree);
771 0 : write_unlock(&fs_info->global_root_lock);
772 0 : }
773 :
774 0 : struct btrfs_root *btrfs_global_root(struct btrfs_fs_info *fs_info,
775 : struct btrfs_key *key)
776 : {
777 0 : struct rb_node *node;
778 0 : struct btrfs_root *root = NULL;
779 :
780 0 : read_lock(&fs_info->global_root_lock);
781 0 : node = rb_find(key, &fs_info->global_root_tree, global_root_key_cmp);
782 0 : if (node)
783 0 : root = container_of(node, struct btrfs_root, rb_node);
784 0 : read_unlock(&fs_info->global_root_lock);
785 :
786 0 : return root;
787 : }
788 :
789 0 : static u64 btrfs_global_root_id(struct btrfs_fs_info *fs_info, u64 bytenr)
790 : {
791 0 : struct btrfs_block_group *block_group;
792 0 : u64 ret;
793 :
794 0 : if (!btrfs_fs_incompat(fs_info, EXTENT_TREE_V2))
795 : return 0;
796 :
797 0 : if (bytenr)
798 0 : block_group = btrfs_lookup_block_group(fs_info, bytenr);
799 : else
800 0 : block_group = btrfs_lookup_first_block_group(fs_info, bytenr);
801 0 : ASSERT(block_group);
802 0 : if (!block_group)
803 : return 0;
804 0 : ret = block_group->global_root_id;
805 0 : btrfs_put_block_group(block_group);
806 :
807 0 : return ret;
808 : }
809 :
810 0 : struct btrfs_root *btrfs_csum_root(struct btrfs_fs_info *fs_info, u64 bytenr)
811 : {
812 0 : struct btrfs_key key = {
813 : .objectid = BTRFS_CSUM_TREE_OBJECTID,
814 : .type = BTRFS_ROOT_ITEM_KEY,
815 0 : .offset = btrfs_global_root_id(fs_info, bytenr),
816 : };
817 :
818 0 : return btrfs_global_root(fs_info, &key);
819 : }
820 :
821 0 : struct btrfs_root *btrfs_extent_root(struct btrfs_fs_info *fs_info, u64 bytenr)
822 : {
823 0 : struct btrfs_key key = {
824 : .objectid = BTRFS_EXTENT_TREE_OBJECTID,
825 : .type = BTRFS_ROOT_ITEM_KEY,
826 0 : .offset = btrfs_global_root_id(fs_info, bytenr),
827 : };
828 :
829 0 : return btrfs_global_root(fs_info, &key);
830 : }
831 :
832 0 : struct btrfs_root *btrfs_block_group_root(struct btrfs_fs_info *fs_info)
833 : {
834 0 : if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE))
835 0 : return fs_info->block_group_root;
836 0 : return btrfs_extent_root(fs_info, 0);
837 : }
838 :
839 0 : struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
840 : u64 objectid)
841 : {
842 0 : struct btrfs_fs_info *fs_info = trans->fs_info;
843 0 : struct extent_buffer *leaf;
844 0 : struct btrfs_root *tree_root = fs_info->tree_root;
845 0 : struct btrfs_root *root;
846 0 : struct btrfs_key key;
847 0 : unsigned int nofs_flag;
848 0 : int ret = 0;
849 :
850 : /*
851 : * We're holding a transaction handle, so use a NOFS memory allocation
852 : * context to avoid deadlock if reclaim happens.
853 : */
854 0 : nofs_flag = memalloc_nofs_save();
855 0 : root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);
856 0 : memalloc_nofs_restore(nofs_flag);
857 0 : if (!root)
858 : return ERR_PTR(-ENOMEM);
859 :
860 0 : root->root_key.objectid = objectid;
861 0 : root->root_key.type = BTRFS_ROOT_ITEM_KEY;
862 0 : root->root_key.offset = 0;
863 :
864 0 : leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0,
865 : BTRFS_NESTING_NORMAL);
866 0 : if (IS_ERR(leaf)) {
867 0 : ret = PTR_ERR(leaf);
868 0 : leaf = NULL;
869 0 : goto fail;
870 : }
871 :
872 0 : root->node = leaf;
873 0 : btrfs_mark_buffer_dirty(leaf);
874 :
875 0 : root->commit_root = btrfs_root_node(root);
876 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
877 :
878 0 : btrfs_set_root_flags(&root->root_item, 0);
879 0 : btrfs_set_root_limit(&root->root_item, 0);
880 0 : btrfs_set_root_bytenr(&root->root_item, leaf->start);
881 0 : btrfs_set_root_generation(&root->root_item, trans->transid);
882 0 : btrfs_set_root_level(&root->root_item, 0);
883 0 : btrfs_set_root_refs(&root->root_item, 1);
884 0 : btrfs_set_root_used(&root->root_item, leaf->len);
885 0 : btrfs_set_root_last_snapshot(&root->root_item, 0);
886 0 : btrfs_set_root_dirid(&root->root_item, 0);
887 0 : if (is_fstree(objectid))
888 0 : generate_random_guid(root->root_item.uuid);
889 : else
890 0 : export_guid(root->root_item.uuid, &guid_null);
891 0 : btrfs_set_root_drop_level(&root->root_item, 0);
892 :
893 0 : btrfs_tree_unlock(leaf);
894 :
895 0 : key.objectid = objectid;
896 0 : key.type = BTRFS_ROOT_ITEM_KEY;
897 0 : key.offset = 0;
898 0 : ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
899 0 : if (ret)
900 0 : goto fail;
901 :
902 : return root;
903 :
904 0 : fail:
905 0 : btrfs_put_root(root);
906 :
907 0 : return ERR_PTR(ret);
908 : }
909 :
910 0 : static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
911 : struct btrfs_fs_info *fs_info)
912 : {
913 0 : struct btrfs_root *root;
914 :
915 0 : root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);
916 0 : if (!root)
917 : return ERR_PTR(-ENOMEM);
918 :
919 0 : root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
920 0 : root->root_key.type = BTRFS_ROOT_ITEM_KEY;
921 0 : root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
922 :
923 0 : return root;
924 : }
925 :
926 0 : int btrfs_alloc_log_tree_node(struct btrfs_trans_handle *trans,
927 : struct btrfs_root *root)
928 : {
929 0 : struct extent_buffer *leaf;
930 :
931 : /*
932 : * DON'T set SHAREABLE bit for log trees.
933 : *
934 : * Log trees are not exposed to user space thus can't be snapshotted,
935 : * and they go away before a real commit is actually done.
936 : *
937 : * They do store pointers to file data extents, and those reference
938 : * counts still get updated (along with back refs to the log tree).
939 : */
940 :
941 0 : leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
942 : NULL, 0, 0, 0, BTRFS_NESTING_NORMAL);
943 0 : if (IS_ERR(leaf))
944 0 : return PTR_ERR(leaf);
945 :
946 0 : root->node = leaf;
947 :
948 0 : btrfs_mark_buffer_dirty(root->node);
949 0 : btrfs_tree_unlock(root->node);
950 :
951 0 : return 0;
952 : }
953 :
954 0 : int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
955 : struct btrfs_fs_info *fs_info)
956 : {
957 0 : struct btrfs_root *log_root;
958 :
959 0 : log_root = alloc_log_tree(trans, fs_info);
960 0 : if (IS_ERR(log_root))
961 0 : return PTR_ERR(log_root);
962 :
963 0 : if (!btrfs_is_zoned(fs_info)) {
964 0 : int ret = btrfs_alloc_log_tree_node(trans, log_root);
965 :
966 0 : if (ret) {
967 0 : btrfs_put_root(log_root);
968 0 : return ret;
969 : }
970 : }
971 :
972 0 : WARN_ON(fs_info->log_root_tree);
973 0 : fs_info->log_root_tree = log_root;
974 0 : return 0;
975 : }
976 :
977 0 : int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
978 : struct btrfs_root *root)
979 : {
980 0 : struct btrfs_fs_info *fs_info = root->fs_info;
981 0 : struct btrfs_root *log_root;
982 0 : struct btrfs_inode_item *inode_item;
983 0 : int ret;
984 :
985 0 : log_root = alloc_log_tree(trans, fs_info);
986 0 : if (IS_ERR(log_root))
987 0 : return PTR_ERR(log_root);
988 :
989 0 : ret = btrfs_alloc_log_tree_node(trans, log_root);
990 0 : if (ret) {
991 0 : btrfs_put_root(log_root);
992 0 : return ret;
993 : }
994 :
995 0 : log_root->last_trans = trans->transid;
996 0 : log_root->root_key.offset = root->root_key.objectid;
997 :
998 0 : inode_item = &log_root->root_item.inode;
999 0 : btrfs_set_stack_inode_generation(inode_item, 1);
1000 0 : btrfs_set_stack_inode_size(inode_item, 3);
1001 0 : btrfs_set_stack_inode_nlink(inode_item, 1);
1002 0 : btrfs_set_stack_inode_nbytes(inode_item,
1003 0 : fs_info->nodesize);
1004 0 : btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
1005 :
1006 0 : btrfs_set_root_node(&log_root->root_item, log_root->node);
1007 :
1008 0 : WARN_ON(root->log_root);
1009 0 : root->log_root = log_root;
1010 0 : root->log_transid = 0;
1011 0 : root->log_transid_committed = -1;
1012 0 : root->last_log_commit = 0;
1013 0 : return 0;
1014 : }
1015 :
1016 0 : static struct btrfs_root *read_tree_root_path(struct btrfs_root *tree_root,
1017 : struct btrfs_path *path,
1018 : struct btrfs_key *key)
1019 : {
1020 0 : struct btrfs_root *root;
1021 0 : struct btrfs_tree_parent_check check = { 0 };
1022 0 : struct btrfs_fs_info *fs_info = tree_root->fs_info;
1023 0 : u64 generation;
1024 0 : int ret;
1025 0 : int level;
1026 :
1027 0 : root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);
1028 0 : if (!root)
1029 : return ERR_PTR(-ENOMEM);
1030 :
1031 0 : ret = btrfs_find_root(tree_root, key, path,
1032 : &root->root_item, &root->root_key);
1033 0 : if (ret) {
1034 0 : if (ret > 0)
1035 0 : ret = -ENOENT;
1036 0 : goto fail;
1037 : }
1038 :
1039 0 : generation = btrfs_root_generation(&root->root_item);
1040 0 : level = btrfs_root_level(&root->root_item);
1041 0 : check.level = level;
1042 0 : check.transid = generation;
1043 0 : check.owner_root = key->objectid;
1044 0 : root->node = read_tree_block(fs_info, btrfs_root_bytenr(&root->root_item),
1045 : &check);
1046 0 : if (IS_ERR(root->node)) {
1047 0 : ret = PTR_ERR(root->node);
1048 0 : root->node = NULL;
1049 0 : goto fail;
1050 : }
1051 0 : if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
1052 0 : ret = -EIO;
1053 0 : goto fail;
1054 : }
1055 :
1056 : /*
1057 : * For real fs, and not log/reloc trees, root owner must
1058 : * match its root node owner
1059 : */
1060 0 : if (!test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state) &&
1061 0 : root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
1062 0 : root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID &&
1063 0 : root->root_key.objectid != btrfs_header_owner(root->node)) {
1064 0 : btrfs_crit(fs_info,
1065 : "root=%llu block=%llu, tree root owner mismatch, have %llu expect %llu",
1066 : root->root_key.objectid, root->node->start,
1067 : btrfs_header_owner(root->node),
1068 : root->root_key.objectid);
1069 0 : ret = -EUCLEAN;
1070 0 : goto fail;
1071 : }
1072 0 : root->commit_root = btrfs_root_node(root);
1073 0 : return root;
1074 0 : fail:
1075 0 : btrfs_put_root(root);
1076 0 : return ERR_PTR(ret);
1077 : }
1078 :
1079 0 : struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
1080 : struct btrfs_key *key)
1081 : {
1082 0 : struct btrfs_root *root;
1083 0 : struct btrfs_path *path;
1084 :
1085 0 : path = btrfs_alloc_path();
1086 0 : if (!path)
1087 : return ERR_PTR(-ENOMEM);
1088 0 : root = read_tree_root_path(tree_root, path, key);
1089 0 : btrfs_free_path(path);
1090 :
1091 0 : return root;
1092 : }
1093 :
1094 : /*
1095 : * Initialize subvolume root in-memory structure
1096 : *
1097 : * @anon_dev: anonymous device to attach to the root, if zero, allocate new
1098 : */
1099 0 : static int btrfs_init_fs_root(struct btrfs_root *root, dev_t anon_dev)
1100 : {
1101 0 : int ret;
1102 :
1103 0 : btrfs_drew_lock_init(&root->snapshot_lock);
1104 :
1105 0 : if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID &&
1106 : !btrfs_is_data_reloc_root(root)) {
1107 0 : set_bit(BTRFS_ROOT_SHAREABLE, &root->state);
1108 0 : btrfs_check_and_init_root_item(&root->root_item);
1109 : }
1110 :
1111 : /*
1112 : * Don't assign anonymous block device to roots that are not exposed to
1113 : * userspace, the id pool is limited to 1M
1114 : */
1115 0 : if (is_fstree(root->root_key.objectid) &&
1116 : btrfs_root_refs(&root->root_item) > 0) {
1117 0 : if (!anon_dev) {
1118 0 : ret = get_anon_bdev(&root->anon_dev);
1119 0 : if (ret)
1120 0 : goto fail;
1121 : } else {
1122 0 : root->anon_dev = anon_dev;
1123 : }
1124 : }
1125 :
1126 0 : mutex_lock(&root->objectid_mutex);
1127 0 : ret = btrfs_init_root_free_objectid(root);
1128 0 : if (ret) {
1129 0 : mutex_unlock(&root->objectid_mutex);
1130 0 : goto fail;
1131 : }
1132 :
1133 0 : ASSERT(root->free_objectid <= BTRFS_LAST_FREE_OBJECTID);
1134 :
1135 0 : mutex_unlock(&root->objectid_mutex);
1136 :
1137 0 : return 0;
1138 : fail:
1139 : /* The caller is responsible to call btrfs_free_fs_root */
1140 : return ret;
1141 : }
1142 :
1143 0 : static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
1144 : u64 root_id)
1145 : {
1146 0 : struct btrfs_root *root;
1147 :
1148 0 : spin_lock(&fs_info->fs_roots_radix_lock);
1149 0 : root = radix_tree_lookup(&fs_info->fs_roots_radix,
1150 : (unsigned long)root_id);
1151 0 : root = btrfs_grab_root(root);
1152 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
1153 0 : return root;
1154 : }
1155 :
1156 0 : static struct btrfs_root *btrfs_get_global_root(struct btrfs_fs_info *fs_info,
1157 : u64 objectid)
1158 : {
1159 0 : struct btrfs_key key = {
1160 : .objectid = objectid,
1161 : .type = BTRFS_ROOT_ITEM_KEY,
1162 : .offset = 0,
1163 : };
1164 :
1165 0 : switch (objectid) {
1166 0 : case BTRFS_ROOT_TREE_OBJECTID:
1167 0 : return btrfs_grab_root(fs_info->tree_root);
1168 0 : case BTRFS_EXTENT_TREE_OBJECTID:
1169 0 : return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1170 0 : case BTRFS_CHUNK_TREE_OBJECTID:
1171 0 : return btrfs_grab_root(fs_info->chunk_root);
1172 0 : case BTRFS_DEV_TREE_OBJECTID:
1173 0 : return btrfs_grab_root(fs_info->dev_root);
1174 0 : case BTRFS_CSUM_TREE_OBJECTID:
1175 0 : return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1176 0 : case BTRFS_QUOTA_TREE_OBJECTID:
1177 0 : return btrfs_grab_root(fs_info->quota_root);
1178 0 : case BTRFS_UUID_TREE_OBJECTID:
1179 0 : return btrfs_grab_root(fs_info->uuid_root);
1180 0 : case BTRFS_BLOCK_GROUP_TREE_OBJECTID:
1181 0 : return btrfs_grab_root(fs_info->block_group_root);
1182 0 : case BTRFS_FREE_SPACE_TREE_OBJECTID:
1183 0 : return btrfs_grab_root(btrfs_global_root(fs_info, &key));
1184 : default:
1185 : return NULL;
1186 : }
1187 : }
1188 :
1189 0 : int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
1190 : struct btrfs_root *root)
1191 : {
1192 0 : int ret;
1193 :
1194 0 : ret = radix_tree_preload(GFP_NOFS);
1195 0 : if (ret)
1196 : return ret;
1197 :
1198 0 : spin_lock(&fs_info->fs_roots_radix_lock);
1199 0 : ret = radix_tree_insert(&fs_info->fs_roots_radix,
1200 0 : (unsigned long)root->root_key.objectid,
1201 : root);
1202 0 : if (ret == 0) {
1203 0 : btrfs_grab_root(root);
1204 0 : set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1205 : }
1206 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
1207 0 : radix_tree_preload_end();
1208 :
1209 0 : return ret;
1210 : }
1211 :
1212 0 : void btrfs_check_leaked_roots(struct btrfs_fs_info *fs_info)
1213 : {
1214 : #ifdef CONFIG_BTRFS_DEBUG
1215 : struct btrfs_root *root;
1216 :
1217 : while (!list_empty(&fs_info->allocated_roots)) {
1218 : char buf[BTRFS_ROOT_NAME_BUF_LEN];
1219 :
1220 : root = list_first_entry(&fs_info->allocated_roots,
1221 : struct btrfs_root, leak_list);
1222 : btrfs_err(fs_info, "leaked root %s refcount %d",
1223 : btrfs_root_name(&root->root_key, buf),
1224 : refcount_read(&root->refs));
1225 : while (refcount_read(&root->refs) > 1)
1226 : btrfs_put_root(root);
1227 : btrfs_put_root(root);
1228 : }
1229 : #endif
1230 0 : }
1231 :
1232 0 : static void free_global_roots(struct btrfs_fs_info *fs_info)
1233 : {
1234 0 : struct btrfs_root *root;
1235 0 : struct rb_node *node;
1236 :
1237 0 : while ((node = rb_first_postorder(&fs_info->global_root_tree)) != NULL) {
1238 0 : root = rb_entry(node, struct btrfs_root, rb_node);
1239 0 : rb_erase(&root->rb_node, &fs_info->global_root_tree);
1240 0 : btrfs_put_root(root);
1241 : }
1242 0 : }
1243 :
1244 0 : void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
1245 : {
1246 0 : percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
1247 0 : percpu_counter_destroy(&fs_info->delalloc_bytes);
1248 0 : percpu_counter_destroy(&fs_info->ordered_bytes);
1249 0 : percpu_counter_destroy(&fs_info->dev_replace.bio_counter);
1250 0 : btrfs_free_csum_hash(fs_info);
1251 0 : btrfs_free_stripe_hash_table(fs_info);
1252 0 : btrfs_free_ref_cache(fs_info);
1253 0 : kfree(fs_info->balance_ctl);
1254 0 : kfree(fs_info->delayed_root);
1255 0 : free_global_roots(fs_info);
1256 0 : btrfs_put_root(fs_info->tree_root);
1257 0 : btrfs_put_root(fs_info->chunk_root);
1258 0 : btrfs_put_root(fs_info->dev_root);
1259 0 : btrfs_put_root(fs_info->quota_root);
1260 0 : btrfs_put_root(fs_info->uuid_root);
1261 0 : btrfs_put_root(fs_info->fs_root);
1262 0 : btrfs_put_root(fs_info->data_reloc_root);
1263 0 : btrfs_put_root(fs_info->block_group_root);
1264 0 : btrfs_check_leaked_roots(fs_info);
1265 0 : btrfs_extent_buffer_leak_debug_check(fs_info);
1266 0 : kfree(fs_info->super_copy);
1267 0 : kfree(fs_info->super_for_commit);
1268 0 : kfree(fs_info->subpage_info);
1269 0 : kvfree(fs_info);
1270 0 : }
1271 :
1272 :
1273 : /*
1274 : * Get an in-memory reference of a root structure.
1275 : *
1276 : * For essential trees like root/extent tree, we grab it from fs_info directly.
1277 : * For subvolume trees, we check the cached filesystem roots first. If not
1278 : * found, then read it from disk and add it to cached fs roots.
1279 : *
1280 : * Caller should release the root by calling btrfs_put_root() after the usage.
1281 : *
1282 : * NOTE: Reloc and log trees can't be read by this function as they share the
1283 : * same root objectid.
1284 : *
1285 : * @objectid: root id
1286 : * @anon_dev: preallocated anonymous block device number for new roots,
1287 : * pass 0 for new allocation.
1288 : * @check_ref: whether to check root item references, If true, return -ENOENT
1289 : * for orphan roots
1290 : */
1291 0 : static struct btrfs_root *btrfs_get_root_ref(struct btrfs_fs_info *fs_info,
1292 : u64 objectid, dev_t anon_dev,
1293 : bool check_ref)
1294 : {
1295 0 : struct btrfs_root *root;
1296 0 : struct btrfs_path *path;
1297 0 : struct btrfs_key key;
1298 0 : int ret;
1299 :
1300 0 : root = btrfs_get_global_root(fs_info, objectid);
1301 0 : if (root)
1302 : return root;
1303 0 : again:
1304 0 : root = btrfs_lookup_fs_root(fs_info, objectid);
1305 0 : if (root) {
1306 : /* Shouldn't get preallocated anon_dev for cached roots */
1307 0 : ASSERT(!anon_dev);
1308 0 : if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1309 0 : btrfs_put_root(root);
1310 0 : return ERR_PTR(-ENOENT);
1311 : }
1312 : return root;
1313 : }
1314 :
1315 0 : key.objectid = objectid;
1316 0 : key.type = BTRFS_ROOT_ITEM_KEY;
1317 0 : key.offset = (u64)-1;
1318 0 : root = btrfs_read_tree_root(fs_info->tree_root, &key);
1319 0 : if (IS_ERR(root))
1320 0 : return root;
1321 :
1322 0 : if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1323 0 : ret = -ENOENT;
1324 0 : goto fail;
1325 : }
1326 :
1327 0 : ret = btrfs_init_fs_root(root, anon_dev);
1328 0 : if (ret)
1329 0 : goto fail;
1330 :
1331 0 : path = btrfs_alloc_path();
1332 0 : if (!path) {
1333 0 : ret = -ENOMEM;
1334 0 : goto fail;
1335 : }
1336 0 : key.objectid = BTRFS_ORPHAN_OBJECTID;
1337 0 : key.type = BTRFS_ORPHAN_ITEM_KEY;
1338 0 : key.offset = objectid;
1339 :
1340 0 : ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
1341 0 : btrfs_free_path(path);
1342 0 : if (ret < 0)
1343 0 : goto fail;
1344 0 : if (ret == 0)
1345 0 : set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1346 :
1347 0 : ret = btrfs_insert_fs_root(fs_info, root);
1348 0 : if (ret) {
1349 0 : if (ret == -EEXIST) {
1350 0 : btrfs_put_root(root);
1351 0 : goto again;
1352 : }
1353 0 : goto fail;
1354 : }
1355 : return root;
1356 0 : fail:
1357 : /*
1358 : * If our caller provided us an anonymous device, then it's his
1359 : * responsibility to free it in case we fail. So we have to set our
1360 : * root's anon_dev to 0 to avoid a double free, once by btrfs_put_root()
1361 : * and once again by our caller.
1362 : */
1363 0 : if (anon_dev)
1364 0 : root->anon_dev = 0;
1365 0 : btrfs_put_root(root);
1366 0 : return ERR_PTR(ret);
1367 : }
1368 :
1369 : /*
1370 : * Get in-memory reference of a root structure
1371 : *
1372 : * @objectid: tree objectid
1373 : * @check_ref: if set, verify that the tree exists and the item has at least
1374 : * one reference
1375 : */
1376 0 : struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
1377 : u64 objectid, bool check_ref)
1378 : {
1379 0 : return btrfs_get_root_ref(fs_info, objectid, 0, check_ref);
1380 : }
1381 :
1382 : /*
1383 : * Get in-memory reference of a root structure, created as new, optionally pass
1384 : * the anonymous block device id
1385 : *
1386 : * @objectid: tree objectid
1387 : * @anon_dev: if zero, allocate a new anonymous block device or use the
1388 : * parameter value
1389 : */
1390 0 : struct btrfs_root *btrfs_get_new_fs_root(struct btrfs_fs_info *fs_info,
1391 : u64 objectid, dev_t anon_dev)
1392 : {
1393 0 : return btrfs_get_root_ref(fs_info, objectid, anon_dev, true);
1394 : }
1395 :
1396 : /*
1397 : * btrfs_get_fs_root_commit_root - return a root for the given objectid
1398 : * @fs_info: the fs_info
1399 : * @objectid: the objectid we need to lookup
1400 : *
1401 : * This is exclusively used for backref walking, and exists specifically because
1402 : * of how qgroups does lookups. Qgroups will do a backref lookup at delayed ref
1403 : * creation time, which means we may have to read the tree_root in order to look
1404 : * up a fs root that is not in memory. If the root is not in memory we will
1405 : * read the tree root commit root and look up the fs root from there. This is a
1406 : * temporary root, it will not be inserted into the radix tree as it doesn't
1407 : * have the most uptodate information, it'll simply be discarded once the
1408 : * backref code is finished using the root.
1409 : */
1410 0 : struct btrfs_root *btrfs_get_fs_root_commit_root(struct btrfs_fs_info *fs_info,
1411 : struct btrfs_path *path,
1412 : u64 objectid)
1413 : {
1414 0 : struct btrfs_root *root;
1415 0 : struct btrfs_key key;
1416 :
1417 0 : ASSERT(path->search_commit_root && path->skip_locking);
1418 :
1419 : /*
1420 : * This can return -ENOENT if we ask for a root that doesn't exist, but
1421 : * since this is called via the backref walking code we won't be looking
1422 : * up a root that doesn't exist, unless there's corruption. So if root
1423 : * != NULL just return it.
1424 : */
1425 0 : root = btrfs_get_global_root(fs_info, objectid);
1426 0 : if (root)
1427 : return root;
1428 :
1429 0 : root = btrfs_lookup_fs_root(fs_info, objectid);
1430 0 : if (root)
1431 : return root;
1432 :
1433 0 : key.objectid = objectid;
1434 0 : key.type = BTRFS_ROOT_ITEM_KEY;
1435 0 : key.offset = (u64)-1;
1436 0 : root = read_tree_root_path(fs_info->tree_root, path, &key);
1437 0 : btrfs_release_path(path);
1438 :
1439 0 : return root;
1440 : }
1441 :
1442 0 : static int cleaner_kthread(void *arg)
1443 : {
1444 0 : struct btrfs_fs_info *fs_info = arg;
1445 0 : int again;
1446 :
1447 0 : while (1) {
1448 0 : again = 0;
1449 :
1450 0 : set_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1451 :
1452 : /* Make the cleaner go to sleep early. */
1453 0 : if (btrfs_need_cleaner_sleep(fs_info))
1454 0 : goto sleep;
1455 :
1456 : /*
1457 : * Do not do anything if we might cause open_ctree() to block
1458 : * before we have finished mounting the filesystem.
1459 : */
1460 0 : if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1461 0 : goto sleep;
1462 :
1463 0 : if (!mutex_trylock(&fs_info->cleaner_mutex))
1464 0 : goto sleep;
1465 :
1466 : /*
1467 : * Avoid the problem that we change the status of the fs
1468 : * during the above check and trylock.
1469 : */
1470 0 : if (btrfs_need_cleaner_sleep(fs_info)) {
1471 0 : mutex_unlock(&fs_info->cleaner_mutex);
1472 0 : goto sleep;
1473 : }
1474 :
1475 0 : if (test_and_clear_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags))
1476 0 : btrfs_sysfs_feature_update(fs_info);
1477 :
1478 0 : btrfs_run_delayed_iputs(fs_info);
1479 :
1480 0 : again = btrfs_clean_one_deleted_snapshot(fs_info);
1481 0 : mutex_unlock(&fs_info->cleaner_mutex);
1482 :
1483 : /*
1484 : * The defragger has dealt with the R/O remount and umount,
1485 : * needn't do anything special here.
1486 : */
1487 0 : btrfs_run_defrag_inodes(fs_info);
1488 :
1489 : /*
1490 : * Acquires fs_info->reclaim_bgs_lock to avoid racing
1491 : * with relocation (btrfs_relocate_chunk) and relocation
1492 : * acquires fs_info->cleaner_mutex (btrfs_relocate_block_group)
1493 : * after acquiring fs_info->reclaim_bgs_lock. So we
1494 : * can't hold, nor need to, fs_info->cleaner_mutex when deleting
1495 : * unused block groups.
1496 : */
1497 0 : btrfs_delete_unused_bgs(fs_info);
1498 :
1499 : /*
1500 : * Reclaim block groups in the reclaim_bgs list after we deleted
1501 : * all unused block_groups. This possibly gives us some more free
1502 : * space.
1503 : */
1504 0 : btrfs_reclaim_bgs(fs_info);
1505 0 : sleep:
1506 0 : clear_and_wake_up_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1507 0 : if (kthread_should_park())
1508 0 : kthread_parkme();
1509 0 : if (kthread_should_stop())
1510 0 : return 0;
1511 0 : if (!again) {
1512 0 : set_current_state(TASK_INTERRUPTIBLE);
1513 0 : schedule();
1514 0 : __set_current_state(TASK_RUNNING);
1515 : }
1516 : }
1517 : }
1518 :
1519 0 : static int transaction_kthread(void *arg)
1520 : {
1521 0 : struct btrfs_root *root = arg;
1522 0 : struct btrfs_fs_info *fs_info = root->fs_info;
1523 0 : struct btrfs_trans_handle *trans;
1524 0 : struct btrfs_transaction *cur;
1525 0 : u64 transid;
1526 0 : time64_t delta;
1527 0 : unsigned long delay;
1528 0 : bool cannot_commit;
1529 :
1530 0 : do {
1531 0 : cannot_commit = false;
1532 0 : delay = msecs_to_jiffies(fs_info->commit_interval * 1000);
1533 0 : mutex_lock(&fs_info->transaction_kthread_mutex);
1534 :
1535 0 : spin_lock(&fs_info->trans_lock);
1536 0 : cur = fs_info->running_transaction;
1537 0 : if (!cur) {
1538 0 : spin_unlock(&fs_info->trans_lock);
1539 0 : goto sleep;
1540 : }
1541 :
1542 0 : delta = ktime_get_seconds() - cur->start_time;
1543 0 : if (!test_and_clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags) &&
1544 0 : cur->state < TRANS_STATE_COMMIT_START &&
1545 0 : delta < fs_info->commit_interval) {
1546 0 : spin_unlock(&fs_info->trans_lock);
1547 0 : delay -= msecs_to_jiffies((delta - 1) * 1000);
1548 0 : delay = min(delay,
1549 : msecs_to_jiffies(fs_info->commit_interval * 1000));
1550 0 : goto sleep;
1551 : }
1552 0 : transid = cur->transid;
1553 0 : spin_unlock(&fs_info->trans_lock);
1554 :
1555 : /* If the file system is aborted, this will always fail. */
1556 0 : trans = btrfs_attach_transaction(root);
1557 0 : if (IS_ERR(trans)) {
1558 0 : if (PTR_ERR(trans) != -ENOENT)
1559 0 : cannot_commit = true;
1560 0 : goto sleep;
1561 : }
1562 0 : if (transid == trans->transid) {
1563 0 : btrfs_commit_transaction(trans);
1564 : } else {
1565 0 : btrfs_end_transaction(trans);
1566 : }
1567 0 : sleep:
1568 0 : wake_up_process(fs_info->cleaner_kthread);
1569 0 : mutex_unlock(&fs_info->transaction_kthread_mutex);
1570 :
1571 0 : if (BTRFS_FS_ERROR(fs_info))
1572 0 : btrfs_cleanup_transaction(fs_info);
1573 0 : if (!kthread_should_stop() &&
1574 0 : (!btrfs_transaction_blocked(fs_info) ||
1575 : cannot_commit))
1576 0 : schedule_timeout_interruptible(delay);
1577 0 : } while (!kthread_should_stop());
1578 0 : return 0;
1579 : }
1580 :
1581 : /*
1582 : * This will find the highest generation in the array of root backups. The
1583 : * index of the highest array is returned, or -EINVAL if we can't find
1584 : * anything.
1585 : *
1586 : * We check to make sure the array is valid by comparing the
1587 : * generation of the latest root in the array with the generation
1588 : * in the super block. If they don't match we pitch it.
1589 : */
1590 0 : static int find_newest_super_backup(struct btrfs_fs_info *info)
1591 : {
1592 0 : const u64 newest_gen = btrfs_super_generation(info->super_copy);
1593 0 : u64 cur;
1594 0 : struct btrfs_root_backup *root_backup;
1595 0 : int i;
1596 :
1597 0 : for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1598 0 : root_backup = info->super_copy->super_roots + i;
1599 0 : cur = btrfs_backup_tree_root_gen(root_backup);
1600 0 : if (cur == newest_gen)
1601 0 : return i;
1602 : }
1603 :
1604 : return -EINVAL;
1605 : }
1606 :
1607 : /*
1608 : * copy all the root pointers into the super backup array.
1609 : * this will bump the backup pointer by one when it is
1610 : * done
1611 : */
1612 0 : static void backup_super_roots(struct btrfs_fs_info *info)
1613 : {
1614 0 : const int next_backup = info->backup_root_index;
1615 0 : struct btrfs_root_backup *root_backup;
1616 :
1617 0 : root_backup = info->super_for_commit->super_roots + next_backup;
1618 :
1619 : /*
1620 : * make sure all of our padding and empty slots get zero filled
1621 : * regardless of which ones we use today
1622 : */
1623 0 : memset(root_backup, 0, sizeof(*root_backup));
1624 :
1625 0 : info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1626 :
1627 0 : btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1628 0 : btrfs_set_backup_tree_root_gen(root_backup,
1629 0 : btrfs_header_generation(info->tree_root->node));
1630 :
1631 0 : btrfs_set_backup_tree_root_level(root_backup,
1632 0 : btrfs_header_level(info->tree_root->node));
1633 :
1634 0 : btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1635 0 : btrfs_set_backup_chunk_root_gen(root_backup,
1636 0 : btrfs_header_generation(info->chunk_root->node));
1637 0 : btrfs_set_backup_chunk_root_level(root_backup,
1638 0 : btrfs_header_level(info->chunk_root->node));
1639 :
1640 0 : if (!btrfs_fs_compat_ro(info, BLOCK_GROUP_TREE)) {
1641 0 : struct btrfs_root *extent_root = btrfs_extent_root(info, 0);
1642 0 : struct btrfs_root *csum_root = btrfs_csum_root(info, 0);
1643 :
1644 0 : btrfs_set_backup_extent_root(root_backup,
1645 0 : extent_root->node->start);
1646 0 : btrfs_set_backup_extent_root_gen(root_backup,
1647 0 : btrfs_header_generation(extent_root->node));
1648 0 : btrfs_set_backup_extent_root_level(root_backup,
1649 0 : btrfs_header_level(extent_root->node));
1650 :
1651 0 : btrfs_set_backup_csum_root(root_backup, csum_root->node->start);
1652 0 : btrfs_set_backup_csum_root_gen(root_backup,
1653 0 : btrfs_header_generation(csum_root->node));
1654 0 : btrfs_set_backup_csum_root_level(root_backup,
1655 0 : btrfs_header_level(csum_root->node));
1656 : }
1657 :
1658 : /*
1659 : * we might commit during log recovery, which happens before we set
1660 : * the fs_root. Make sure it is valid before we fill it in.
1661 : */
1662 0 : if (info->fs_root && info->fs_root->node) {
1663 0 : btrfs_set_backup_fs_root(root_backup,
1664 : info->fs_root->node->start);
1665 0 : btrfs_set_backup_fs_root_gen(root_backup,
1666 0 : btrfs_header_generation(info->fs_root->node));
1667 0 : btrfs_set_backup_fs_root_level(root_backup,
1668 0 : btrfs_header_level(info->fs_root->node));
1669 : }
1670 :
1671 0 : btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
1672 0 : btrfs_set_backup_dev_root_gen(root_backup,
1673 0 : btrfs_header_generation(info->dev_root->node));
1674 0 : btrfs_set_backup_dev_root_level(root_backup,
1675 0 : btrfs_header_level(info->dev_root->node));
1676 :
1677 0 : btrfs_set_backup_total_bytes(root_backup,
1678 0 : btrfs_super_total_bytes(info->super_copy));
1679 0 : btrfs_set_backup_bytes_used(root_backup,
1680 0 : btrfs_super_bytes_used(info->super_copy));
1681 0 : btrfs_set_backup_num_devices(root_backup,
1682 0 : btrfs_super_num_devices(info->super_copy));
1683 :
1684 : /*
1685 : * if we don't copy this out to the super_copy, it won't get remembered
1686 : * for the next commit
1687 : */
1688 0 : memcpy(&info->super_copy->super_roots,
1689 : &info->super_for_commit->super_roots,
1690 : sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
1691 0 : }
1692 :
1693 : /*
1694 : * read_backup_root - Reads a backup root based on the passed priority. Prio 0
1695 : * is the newest, prio 1/2/3 are 2nd newest/3rd newest/4th (oldest) backup roots
1696 : *
1697 : * fs_info - filesystem whose backup roots need to be read
1698 : * priority - priority of backup root required
1699 : *
1700 : * Returns backup root index on success and -EINVAL otherwise.
1701 : */
1702 0 : static int read_backup_root(struct btrfs_fs_info *fs_info, u8 priority)
1703 : {
1704 0 : int backup_index = find_newest_super_backup(fs_info);
1705 0 : struct btrfs_super_block *super = fs_info->super_copy;
1706 0 : struct btrfs_root_backup *root_backup;
1707 :
1708 0 : if (priority < BTRFS_NUM_BACKUP_ROOTS && backup_index >= 0) {
1709 0 : if (priority == 0)
1710 : return backup_index;
1711 :
1712 0 : backup_index = backup_index + BTRFS_NUM_BACKUP_ROOTS - priority;
1713 0 : backup_index %= BTRFS_NUM_BACKUP_ROOTS;
1714 : } else {
1715 : return -EINVAL;
1716 : }
1717 :
1718 0 : root_backup = super->super_roots + backup_index;
1719 :
1720 0 : btrfs_set_super_generation(super,
1721 : btrfs_backup_tree_root_gen(root_backup));
1722 0 : btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
1723 0 : btrfs_set_super_root_level(super,
1724 : btrfs_backup_tree_root_level(root_backup));
1725 0 : btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
1726 :
1727 : /*
1728 : * Fixme: the total bytes and num_devices need to match or we should
1729 : * need a fsck
1730 : */
1731 0 : btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
1732 0 : btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
1733 :
1734 0 : return backup_index;
1735 : }
1736 :
1737 : /* helper to cleanup workers */
1738 0 : static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
1739 : {
1740 0 : btrfs_destroy_workqueue(fs_info->fixup_workers);
1741 0 : btrfs_destroy_workqueue(fs_info->delalloc_workers);
1742 0 : btrfs_destroy_workqueue(fs_info->workers);
1743 0 : if (fs_info->endio_workers)
1744 0 : destroy_workqueue(fs_info->endio_workers);
1745 0 : if (fs_info->rmw_workers)
1746 0 : destroy_workqueue(fs_info->rmw_workers);
1747 0 : if (fs_info->compressed_write_workers)
1748 0 : destroy_workqueue(fs_info->compressed_write_workers);
1749 0 : btrfs_destroy_workqueue(fs_info->endio_write_workers);
1750 0 : btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
1751 0 : btrfs_destroy_workqueue(fs_info->delayed_workers);
1752 0 : btrfs_destroy_workqueue(fs_info->caching_workers);
1753 0 : btrfs_destroy_workqueue(fs_info->flush_workers);
1754 0 : btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
1755 0 : if (fs_info->discard_ctl.discard_workers)
1756 0 : destroy_workqueue(fs_info->discard_ctl.discard_workers);
1757 : /*
1758 : * Now that all other work queues are destroyed, we can safely destroy
1759 : * the queues used for metadata I/O, since tasks from those other work
1760 : * queues can do metadata I/O operations.
1761 : */
1762 0 : if (fs_info->endio_meta_workers)
1763 0 : destroy_workqueue(fs_info->endio_meta_workers);
1764 0 : }
1765 :
1766 0 : static void free_root_extent_buffers(struct btrfs_root *root)
1767 : {
1768 0 : if (root) {
1769 0 : free_extent_buffer(root->node);
1770 0 : free_extent_buffer(root->commit_root);
1771 0 : root->node = NULL;
1772 0 : root->commit_root = NULL;
1773 : }
1774 0 : }
1775 :
1776 0 : static void free_global_root_pointers(struct btrfs_fs_info *fs_info)
1777 : {
1778 0 : struct btrfs_root *root, *tmp;
1779 :
1780 0 : rbtree_postorder_for_each_entry_safe(root, tmp,
1781 : &fs_info->global_root_tree,
1782 : rb_node)
1783 0 : free_root_extent_buffers(root);
1784 0 : }
1785 :
1786 : /* helper to cleanup tree roots */
1787 0 : static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)
1788 : {
1789 0 : free_root_extent_buffers(info->tree_root);
1790 :
1791 0 : free_global_root_pointers(info);
1792 0 : free_root_extent_buffers(info->dev_root);
1793 0 : free_root_extent_buffers(info->quota_root);
1794 0 : free_root_extent_buffers(info->uuid_root);
1795 0 : free_root_extent_buffers(info->fs_root);
1796 0 : free_root_extent_buffers(info->data_reloc_root);
1797 0 : free_root_extent_buffers(info->block_group_root);
1798 0 : if (free_chunk_root)
1799 0 : free_root_extent_buffers(info->chunk_root);
1800 0 : }
1801 :
1802 0 : void btrfs_put_root(struct btrfs_root *root)
1803 : {
1804 0 : if (!root)
1805 : return;
1806 :
1807 0 : if (refcount_dec_and_test(&root->refs)) {
1808 0 : WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
1809 0 : WARN_ON(test_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state));
1810 0 : if (root->anon_dev)
1811 0 : free_anon_bdev(root->anon_dev);
1812 0 : free_root_extent_buffers(root);
1813 : #ifdef CONFIG_BTRFS_DEBUG
1814 : spin_lock(&root->fs_info->fs_roots_radix_lock);
1815 : list_del_init(&root->leak_list);
1816 : spin_unlock(&root->fs_info->fs_roots_radix_lock);
1817 : #endif
1818 0 : kfree(root);
1819 : }
1820 : }
1821 :
1822 0 : void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
1823 : {
1824 0 : int ret;
1825 0 : struct btrfs_root *gang[8];
1826 0 : int i;
1827 :
1828 0 : while (!list_empty(&fs_info->dead_roots)) {
1829 0 : gang[0] = list_entry(fs_info->dead_roots.next,
1830 : struct btrfs_root, root_list);
1831 0 : list_del(&gang[0]->root_list);
1832 :
1833 0 : if (test_bit(BTRFS_ROOT_IN_RADIX, &gang[0]->state))
1834 0 : btrfs_drop_and_free_fs_root(fs_info, gang[0]);
1835 0 : btrfs_put_root(gang[0]);
1836 : }
1837 :
1838 0 : while (1) {
1839 0 : ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
1840 : (void **)gang, 0,
1841 : ARRAY_SIZE(gang));
1842 0 : if (!ret)
1843 : break;
1844 0 : for (i = 0; i < ret; i++)
1845 0 : btrfs_drop_and_free_fs_root(fs_info, gang[i]);
1846 : }
1847 0 : }
1848 :
1849 0 : static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
1850 : {
1851 0 : mutex_init(&fs_info->scrub_lock);
1852 0 : atomic_set(&fs_info->scrubs_running, 0);
1853 0 : atomic_set(&fs_info->scrub_pause_req, 0);
1854 0 : atomic_set(&fs_info->scrubs_paused, 0);
1855 0 : atomic_set(&fs_info->scrub_cancel_req, 0);
1856 0 : init_waitqueue_head(&fs_info->scrub_pause_wait);
1857 0 : refcount_set(&fs_info->scrub_workers_refcnt, 0);
1858 0 : }
1859 :
1860 0 : static void btrfs_init_balance(struct btrfs_fs_info *fs_info)
1861 : {
1862 0 : spin_lock_init(&fs_info->balance_lock);
1863 0 : mutex_init(&fs_info->balance_mutex);
1864 0 : atomic_set(&fs_info->balance_pause_req, 0);
1865 0 : atomic_set(&fs_info->balance_cancel_req, 0);
1866 0 : fs_info->balance_ctl = NULL;
1867 0 : init_waitqueue_head(&fs_info->balance_wait_q);
1868 0 : atomic_set(&fs_info->reloc_cancel_req, 0);
1869 0 : }
1870 :
1871 0 : static int btrfs_init_btree_inode(struct super_block *sb)
1872 : {
1873 0 : struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1874 0 : unsigned long hash = btrfs_inode_hash(BTRFS_BTREE_INODE_OBJECTID,
1875 0 : fs_info->tree_root);
1876 0 : struct inode *inode;
1877 :
1878 0 : inode = new_inode(sb);
1879 0 : if (!inode)
1880 : return -ENOMEM;
1881 :
1882 0 : inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
1883 0 : set_nlink(inode, 1);
1884 : /*
1885 : * we set the i_size on the btree inode to the max possible int.
1886 : * the real end of the address space is determined by all of
1887 : * the devices in the system
1888 : */
1889 0 : inode->i_size = OFFSET_MAX;
1890 0 : inode->i_mapping->a_ops = &btree_aops;
1891 0 : mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
1892 :
1893 0 : RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
1894 0 : extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,
1895 : IO_TREE_BTREE_INODE_IO);
1896 0 : extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
1897 :
1898 0 : BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);
1899 0 : BTRFS_I(inode)->location.objectid = BTRFS_BTREE_INODE_OBJECTID;
1900 0 : BTRFS_I(inode)->location.type = 0;
1901 0 : BTRFS_I(inode)->location.offset = 0;
1902 0 : set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
1903 0 : __insert_inode_hash(inode, hash);
1904 0 : fs_info->btree_inode = inode;
1905 :
1906 0 : return 0;
1907 : }
1908 :
1909 0 : static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
1910 : {
1911 0 : mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
1912 0 : init_rwsem(&fs_info->dev_replace.rwsem);
1913 0 : init_waitqueue_head(&fs_info->dev_replace.replace_wait);
1914 0 : }
1915 :
1916 0 : static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
1917 : {
1918 0 : spin_lock_init(&fs_info->qgroup_lock);
1919 0 : mutex_init(&fs_info->qgroup_ioctl_lock);
1920 0 : fs_info->qgroup_tree = RB_ROOT;
1921 0 : INIT_LIST_HEAD(&fs_info->dirty_qgroups);
1922 0 : fs_info->qgroup_seq = 1;
1923 0 : fs_info->qgroup_ulist = NULL;
1924 0 : fs_info->qgroup_rescan_running = false;
1925 0 : fs_info->qgroup_drop_subtree_thres = BTRFS_MAX_LEVEL;
1926 0 : mutex_init(&fs_info->qgroup_rescan_lock);
1927 0 : }
1928 :
1929 0 : static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info)
1930 : {
1931 0 : u32 max_active = fs_info->thread_pool_size;
1932 0 : unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
1933 0 : unsigned int ordered_flags = WQ_MEM_RECLAIM | WQ_FREEZABLE;
1934 :
1935 0 : fs_info->workers =
1936 0 : btrfs_alloc_workqueue(fs_info, "worker", flags, max_active, 16);
1937 :
1938 0 : fs_info->delalloc_workers =
1939 0 : btrfs_alloc_workqueue(fs_info, "delalloc",
1940 : flags, max_active, 2);
1941 :
1942 0 : fs_info->flush_workers =
1943 0 : btrfs_alloc_workqueue(fs_info, "flush_delalloc",
1944 : flags, max_active, 0);
1945 :
1946 0 : fs_info->caching_workers =
1947 0 : btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);
1948 :
1949 0 : fs_info->fixup_workers =
1950 0 : btrfs_alloc_ordered_workqueue(fs_info, "fixup", ordered_flags);
1951 :
1952 0 : fs_info->endio_workers =
1953 0 : alloc_workqueue("btrfs-endio", flags, max_active);
1954 0 : fs_info->endio_meta_workers =
1955 0 : alloc_workqueue("btrfs-endio-meta", flags, max_active);
1956 0 : fs_info->rmw_workers = alloc_workqueue("btrfs-rmw", flags, max_active);
1957 0 : fs_info->endio_write_workers =
1958 0 : btrfs_alloc_workqueue(fs_info, "endio-write", flags,
1959 : max_active, 2);
1960 0 : fs_info->compressed_write_workers =
1961 0 : alloc_workqueue("btrfs-compressed-write", flags, max_active);
1962 0 : fs_info->endio_freespace_worker =
1963 0 : btrfs_alloc_workqueue(fs_info, "freespace-write", flags,
1964 : max_active, 0);
1965 0 : fs_info->delayed_workers =
1966 0 : btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,
1967 : max_active, 0);
1968 0 : fs_info->qgroup_rescan_workers =
1969 0 : btrfs_alloc_ordered_workqueue(fs_info, "qgroup-rescan",
1970 : ordered_flags);
1971 0 : fs_info->discard_ctl.discard_workers =
1972 0 : alloc_ordered_workqueue("btrfs_discard", WQ_FREEZABLE);
1973 :
1974 0 : if (!(fs_info->workers &&
1975 0 : fs_info->delalloc_workers && fs_info->flush_workers &&
1976 0 : fs_info->endio_workers && fs_info->endio_meta_workers &&
1977 0 : fs_info->compressed_write_workers &&
1978 0 : fs_info->endio_write_workers &&
1979 0 : fs_info->endio_freespace_worker && fs_info->rmw_workers &&
1980 0 : fs_info->caching_workers && fs_info->fixup_workers &&
1981 0 : fs_info->delayed_workers && fs_info->qgroup_rescan_workers &&
1982 : fs_info->discard_ctl.discard_workers)) {
1983 0 : return -ENOMEM;
1984 : }
1985 :
1986 : return 0;
1987 : }
1988 :
1989 0 : static int btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)
1990 : {
1991 0 : struct crypto_shash *csum_shash;
1992 0 : const char *csum_driver = btrfs_super_csum_driver(csum_type);
1993 :
1994 0 : csum_shash = crypto_alloc_shash(csum_driver, 0, 0);
1995 :
1996 0 : if (IS_ERR(csum_shash)) {
1997 0 : btrfs_err(fs_info, "error allocating %s hash for checksum",
1998 : csum_driver);
1999 0 : return PTR_ERR(csum_shash);
2000 : }
2001 :
2002 0 : fs_info->csum_shash = csum_shash;
2003 :
2004 : /*
2005 : * Check if the checksum implementation is a fast accelerated one.
2006 : * As-is this is a bit of a hack and should be replaced once the csum
2007 : * implementations provide that information themselves.
2008 : */
2009 0 : switch (csum_type) {
2010 : case BTRFS_CSUM_TYPE_CRC32:
2011 0 : if (!strstr(crypto_shash_driver_name(csum_shash), "generic"))
2012 0 : set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
2013 : break;
2014 0 : case BTRFS_CSUM_TYPE_XXHASH:
2015 0 : set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
2016 : break;
2017 : default:
2018 : break;
2019 : }
2020 :
2021 0 : btrfs_info(fs_info, "using %s (%s) checksum algorithm",
2022 : btrfs_super_csum_name(csum_type),
2023 : crypto_shash_driver_name(csum_shash));
2024 0 : return 0;
2025 : }
2026 :
2027 0 : static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
2028 : struct btrfs_fs_devices *fs_devices)
2029 : {
2030 0 : int ret;
2031 0 : struct btrfs_tree_parent_check check = { 0 };
2032 0 : struct btrfs_root *log_tree_root;
2033 0 : struct btrfs_super_block *disk_super = fs_info->super_copy;
2034 0 : u64 bytenr = btrfs_super_log_root(disk_super);
2035 0 : int level = btrfs_super_log_root_level(disk_super);
2036 :
2037 0 : if (fs_devices->rw_devices == 0) {
2038 0 : btrfs_warn(fs_info, "log replay required on RO media");
2039 0 : return -EIO;
2040 : }
2041 :
2042 0 : log_tree_root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID,
2043 : GFP_KERNEL);
2044 0 : if (!log_tree_root)
2045 : return -ENOMEM;
2046 :
2047 0 : check.level = level;
2048 0 : check.transid = fs_info->generation + 1;
2049 0 : check.owner_root = BTRFS_TREE_LOG_OBJECTID;
2050 0 : log_tree_root->node = read_tree_block(fs_info, bytenr, &check);
2051 0 : if (IS_ERR(log_tree_root->node)) {
2052 0 : btrfs_warn(fs_info, "failed to read log tree");
2053 0 : ret = PTR_ERR(log_tree_root->node);
2054 0 : log_tree_root->node = NULL;
2055 0 : btrfs_put_root(log_tree_root);
2056 0 : return ret;
2057 : }
2058 0 : if (!extent_buffer_uptodate(log_tree_root->node)) {
2059 0 : btrfs_err(fs_info, "failed to read log tree");
2060 0 : btrfs_put_root(log_tree_root);
2061 0 : return -EIO;
2062 : }
2063 :
2064 : /* returns with log_tree_root freed on success */
2065 0 : ret = btrfs_recover_log_trees(log_tree_root);
2066 0 : if (ret) {
2067 0 : btrfs_handle_fs_error(fs_info, ret,
2068 : "Failed to recover log tree");
2069 0 : btrfs_put_root(log_tree_root);
2070 0 : return ret;
2071 : }
2072 :
2073 0 : if (sb_rdonly(fs_info->sb)) {
2074 0 : ret = btrfs_commit_super(fs_info);
2075 0 : if (ret)
2076 0 : return ret;
2077 : }
2078 :
2079 : return 0;
2080 : }
2081 :
2082 0 : static int load_global_roots_objectid(struct btrfs_root *tree_root,
2083 : struct btrfs_path *path, u64 objectid,
2084 : const char *name)
2085 : {
2086 0 : struct btrfs_fs_info *fs_info = tree_root->fs_info;
2087 0 : struct btrfs_root *root;
2088 0 : u64 max_global_id = 0;
2089 0 : int ret;
2090 0 : struct btrfs_key key = {
2091 : .objectid = objectid,
2092 : .type = BTRFS_ROOT_ITEM_KEY,
2093 : .offset = 0,
2094 : };
2095 0 : bool found = false;
2096 :
2097 : /* If we have IGNOREDATACSUMS skip loading these roots. */
2098 0 : if (objectid == BTRFS_CSUM_TREE_OBJECTID &&
2099 0 : btrfs_test_opt(fs_info, IGNOREDATACSUMS)) {
2100 0 : set_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state);
2101 0 : return 0;
2102 : }
2103 :
2104 0 : while (1) {
2105 0 : ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
2106 0 : if (ret < 0)
2107 : break;
2108 :
2109 0 : if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2110 0 : ret = btrfs_next_leaf(tree_root, path);
2111 0 : if (ret) {
2112 0 : if (ret > 0)
2113 : ret = 0;
2114 : break;
2115 : }
2116 : }
2117 0 : ret = 0;
2118 :
2119 0 : btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2120 0 : if (key.objectid != objectid)
2121 : break;
2122 0 : btrfs_release_path(path);
2123 :
2124 : /*
2125 : * Just worry about this for extent tree, it'll be the same for
2126 : * everybody.
2127 : */
2128 0 : if (objectid == BTRFS_EXTENT_TREE_OBJECTID)
2129 0 : max_global_id = max(max_global_id, key.offset);
2130 :
2131 0 : found = true;
2132 0 : root = read_tree_root_path(tree_root, path, &key);
2133 0 : if (IS_ERR(root)) {
2134 0 : if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))
2135 0 : ret = PTR_ERR(root);
2136 : break;
2137 : }
2138 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2139 0 : ret = btrfs_global_root_insert(root);
2140 0 : if (ret) {
2141 0 : btrfs_put_root(root);
2142 0 : break;
2143 : }
2144 0 : key.offset++;
2145 : }
2146 0 : btrfs_release_path(path);
2147 :
2148 0 : if (objectid == BTRFS_EXTENT_TREE_OBJECTID)
2149 0 : fs_info->nr_global_roots = max_global_id + 1;
2150 :
2151 0 : if (!found || ret) {
2152 0 : if (objectid == BTRFS_CSUM_TREE_OBJECTID)
2153 0 : set_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state);
2154 :
2155 0 : if (!btrfs_test_opt(fs_info, IGNOREBADROOTS))
2156 0 : ret = ret ? ret : -ENOENT;
2157 : else
2158 : ret = 0;
2159 0 : btrfs_err(fs_info, "failed to load root %s", name);
2160 : }
2161 : return ret;
2162 : }
2163 :
2164 0 : static int load_global_roots(struct btrfs_root *tree_root)
2165 : {
2166 0 : struct btrfs_path *path;
2167 0 : int ret = 0;
2168 :
2169 0 : path = btrfs_alloc_path();
2170 0 : if (!path)
2171 : return -ENOMEM;
2172 :
2173 0 : ret = load_global_roots_objectid(tree_root, path,
2174 : BTRFS_EXTENT_TREE_OBJECTID, "extent");
2175 0 : if (ret)
2176 0 : goto out;
2177 0 : ret = load_global_roots_objectid(tree_root, path,
2178 : BTRFS_CSUM_TREE_OBJECTID, "csum");
2179 0 : if (ret)
2180 0 : goto out;
2181 0 : if (!btrfs_fs_compat_ro(tree_root->fs_info, FREE_SPACE_TREE))
2182 0 : goto out;
2183 0 : ret = load_global_roots_objectid(tree_root, path,
2184 : BTRFS_FREE_SPACE_TREE_OBJECTID,
2185 : "free space");
2186 0 : out:
2187 0 : btrfs_free_path(path);
2188 0 : return ret;
2189 : }
2190 :
2191 0 : static int btrfs_read_roots(struct btrfs_fs_info *fs_info)
2192 : {
2193 0 : struct btrfs_root *tree_root = fs_info->tree_root;
2194 0 : struct btrfs_root *root;
2195 0 : struct btrfs_key location;
2196 0 : int ret;
2197 :
2198 0 : BUG_ON(!fs_info->tree_root);
2199 :
2200 0 : ret = load_global_roots(tree_root);
2201 0 : if (ret)
2202 : return ret;
2203 :
2204 0 : location.type = BTRFS_ROOT_ITEM_KEY;
2205 0 : location.offset = 0;
2206 :
2207 0 : if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE)) {
2208 0 : location.objectid = BTRFS_BLOCK_GROUP_TREE_OBJECTID;
2209 0 : root = btrfs_read_tree_root(tree_root, &location);
2210 0 : if (IS_ERR(root)) {
2211 0 : if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2212 0 : ret = PTR_ERR(root);
2213 0 : goto out;
2214 : }
2215 : } else {
2216 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2217 0 : fs_info->block_group_root = root;
2218 : }
2219 : }
2220 :
2221 0 : location.objectid = BTRFS_DEV_TREE_OBJECTID;
2222 0 : root = btrfs_read_tree_root(tree_root, &location);
2223 0 : if (IS_ERR(root)) {
2224 0 : if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2225 0 : ret = PTR_ERR(root);
2226 0 : goto out;
2227 : }
2228 : } else {
2229 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2230 0 : fs_info->dev_root = root;
2231 : }
2232 : /* Initialize fs_info for all devices in any case */
2233 0 : ret = btrfs_init_devices_late(fs_info);
2234 0 : if (ret)
2235 0 : goto out;
2236 :
2237 : /*
2238 : * This tree can share blocks with some other fs tree during relocation
2239 : * and we need a proper setup by btrfs_get_fs_root
2240 : */
2241 0 : root = btrfs_get_fs_root(tree_root->fs_info,
2242 : BTRFS_DATA_RELOC_TREE_OBJECTID, true);
2243 0 : if (IS_ERR(root)) {
2244 0 : if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2245 0 : ret = PTR_ERR(root);
2246 0 : goto out;
2247 : }
2248 : } else {
2249 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2250 0 : fs_info->data_reloc_root = root;
2251 : }
2252 :
2253 0 : location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
2254 0 : root = btrfs_read_tree_root(tree_root, &location);
2255 0 : if (!IS_ERR(root)) {
2256 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2257 0 : set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
2258 0 : fs_info->quota_root = root;
2259 : }
2260 :
2261 0 : location.objectid = BTRFS_UUID_TREE_OBJECTID;
2262 0 : root = btrfs_read_tree_root(tree_root, &location);
2263 0 : if (IS_ERR(root)) {
2264 0 : if (!btrfs_test_opt(fs_info, IGNOREBADROOTS)) {
2265 0 : ret = PTR_ERR(root);
2266 0 : if (ret != -ENOENT)
2267 0 : goto out;
2268 : }
2269 : } else {
2270 0 : set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2271 0 : fs_info->uuid_root = root;
2272 : }
2273 :
2274 : return 0;
2275 0 : out:
2276 0 : btrfs_warn(fs_info, "failed to read root (objectid=%llu): %d",
2277 : location.objectid, ret);
2278 0 : return ret;
2279 : }
2280 :
2281 : /*
2282 : * Real super block validation
2283 : * NOTE: super csum type and incompat features will not be checked here.
2284 : *
2285 : * @sb: super block to check
2286 : * @mirror_num: the super block number to check its bytenr:
2287 : * 0 the primary (1st) sb
2288 : * 1, 2 2nd and 3rd backup copy
2289 : * -1 skip bytenr check
2290 : */
2291 0 : int btrfs_validate_super(struct btrfs_fs_info *fs_info,
2292 : struct btrfs_super_block *sb, int mirror_num)
2293 : {
2294 0 : u64 nodesize = btrfs_super_nodesize(sb);
2295 0 : u64 sectorsize = btrfs_super_sectorsize(sb);
2296 0 : int ret = 0;
2297 :
2298 0 : if (btrfs_super_magic(sb) != BTRFS_MAGIC) {
2299 0 : btrfs_err(fs_info, "no valid FS found");
2300 0 : ret = -EINVAL;
2301 : }
2302 0 : if (btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP) {
2303 0 : btrfs_err(fs_info, "unrecognized or unsupported super flag: %llu",
2304 : btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP);
2305 0 : ret = -EINVAL;
2306 : }
2307 0 : if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
2308 0 : btrfs_err(fs_info, "tree_root level too big: %d >= %d",
2309 : btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
2310 0 : ret = -EINVAL;
2311 : }
2312 0 : if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
2313 0 : btrfs_err(fs_info, "chunk_root level too big: %d >= %d",
2314 : btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
2315 0 : ret = -EINVAL;
2316 : }
2317 0 : if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
2318 0 : btrfs_err(fs_info, "log_root level too big: %d >= %d",
2319 : btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
2320 0 : ret = -EINVAL;
2321 : }
2322 :
2323 : /*
2324 : * Check sectorsize and nodesize first, other check will need it.
2325 : * Check all possible sectorsize(4K, 8K, 16K, 32K, 64K) here.
2326 : */
2327 0 : if (!is_power_of_2(sectorsize) || sectorsize < 4096 ||
2328 : sectorsize > BTRFS_MAX_METADATA_BLOCKSIZE) {
2329 0 : btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
2330 0 : ret = -EINVAL;
2331 : }
2332 :
2333 : /*
2334 : * We only support at most two sectorsizes: 4K and PAGE_SIZE.
2335 : *
2336 : * We can support 16K sectorsize with 64K page size without problem,
2337 : * but such sectorsize/pagesize combination doesn't make much sense.
2338 : * 4K will be our future standard, PAGE_SIZE is supported from the very
2339 : * beginning.
2340 : */
2341 0 : if (sectorsize > PAGE_SIZE || (sectorsize != SZ_4K && sectorsize != PAGE_SIZE)) {
2342 0 : btrfs_err(fs_info,
2343 : "sectorsize %llu not yet supported for page size %lu",
2344 : sectorsize, PAGE_SIZE);
2345 0 : ret = -EINVAL;
2346 : }
2347 :
2348 0 : if (!is_power_of_2(nodesize) || nodesize < sectorsize ||
2349 0 : nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
2350 0 : btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
2351 0 : ret = -EINVAL;
2352 : }
2353 0 : if (nodesize != le32_to_cpu(sb->__unused_leafsize)) {
2354 0 : btrfs_err(fs_info, "invalid leafsize %u, should be %llu",
2355 : le32_to_cpu(sb->__unused_leafsize), nodesize);
2356 0 : ret = -EINVAL;
2357 : }
2358 :
2359 : /* Root alignment check */
2360 0 : if (!IS_ALIGNED(btrfs_super_root(sb), sectorsize)) {
2361 0 : btrfs_warn(fs_info, "tree_root block unaligned: %llu",
2362 : btrfs_super_root(sb));
2363 0 : ret = -EINVAL;
2364 : }
2365 0 : if (!IS_ALIGNED(btrfs_super_chunk_root(sb), sectorsize)) {
2366 0 : btrfs_warn(fs_info, "chunk_root block unaligned: %llu",
2367 : btrfs_super_chunk_root(sb));
2368 0 : ret = -EINVAL;
2369 : }
2370 0 : if (!IS_ALIGNED(btrfs_super_log_root(sb), sectorsize)) {
2371 0 : btrfs_warn(fs_info, "log_root block unaligned: %llu",
2372 : btrfs_super_log_root(sb));
2373 0 : ret = -EINVAL;
2374 : }
2375 :
2376 0 : if (memcmp(fs_info->fs_devices->fsid, fs_info->super_copy->fsid,
2377 : BTRFS_FSID_SIZE)) {
2378 0 : btrfs_err(fs_info,
2379 : "superblock fsid doesn't match fsid of fs_devices: %pU != %pU",
2380 : fs_info->super_copy->fsid, fs_info->fs_devices->fsid);
2381 0 : ret = -EINVAL;
2382 : }
2383 :
2384 0 : if (btrfs_fs_incompat(fs_info, METADATA_UUID) &&
2385 0 : memcmp(fs_info->fs_devices->metadata_uuid,
2386 0 : fs_info->super_copy->metadata_uuid, BTRFS_FSID_SIZE)) {
2387 0 : btrfs_err(fs_info,
2388 : "superblock metadata_uuid doesn't match metadata uuid of fs_devices: %pU != %pU",
2389 : fs_info->super_copy->metadata_uuid,
2390 : fs_info->fs_devices->metadata_uuid);
2391 0 : ret = -EINVAL;
2392 : }
2393 :
2394 0 : if (memcmp(fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid,
2395 : BTRFS_FSID_SIZE) != 0) {
2396 0 : btrfs_err(fs_info,
2397 : "dev_item UUID does not match metadata fsid: %pU != %pU",
2398 : fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid);
2399 0 : ret = -EINVAL;
2400 : }
2401 :
2402 : /*
2403 : * Artificial requirement for block-group-tree to force newer features
2404 : * (free-space-tree, no-holes) so the test matrix is smaller.
2405 : */
2406 0 : if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&
2407 0 : (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID) ||
2408 0 : !btrfs_fs_incompat(fs_info, NO_HOLES))) {
2409 0 : btrfs_err(fs_info,
2410 : "block-group-tree feature requires fres-space-tree and no-holes");
2411 0 : ret = -EINVAL;
2412 : }
2413 :
2414 : /*
2415 : * Hint to catch really bogus numbers, bitflips or so, more exact checks are
2416 : * done later
2417 : */
2418 0 : if (btrfs_super_bytes_used(sb) < 6 * btrfs_super_nodesize(sb)) {
2419 0 : btrfs_err(fs_info, "bytes_used is too small %llu",
2420 : btrfs_super_bytes_used(sb));
2421 0 : ret = -EINVAL;
2422 : }
2423 0 : if (!is_power_of_2(btrfs_super_stripesize(sb))) {
2424 0 : btrfs_err(fs_info, "invalid stripesize %u",
2425 : btrfs_super_stripesize(sb));
2426 0 : ret = -EINVAL;
2427 : }
2428 0 : if (btrfs_super_num_devices(sb) > (1UL << 31))
2429 0 : btrfs_warn(fs_info, "suspicious number of devices: %llu",
2430 : btrfs_super_num_devices(sb));
2431 0 : if (btrfs_super_num_devices(sb) == 0) {
2432 0 : btrfs_err(fs_info, "number of devices is 0");
2433 0 : ret = -EINVAL;
2434 : }
2435 :
2436 0 : if (mirror_num >= 0 &&
2437 : btrfs_super_bytenr(sb) != btrfs_sb_offset(mirror_num)) {
2438 0 : btrfs_err(fs_info, "super offset mismatch %llu != %u",
2439 : btrfs_super_bytenr(sb), BTRFS_SUPER_INFO_OFFSET);
2440 0 : ret = -EINVAL;
2441 : }
2442 :
2443 : /*
2444 : * Obvious sys_chunk_array corruptions, it must hold at least one key
2445 : * and one chunk
2446 : */
2447 0 : if (btrfs_super_sys_array_size(sb) > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
2448 0 : btrfs_err(fs_info, "system chunk array too big %u > %u",
2449 : btrfs_super_sys_array_size(sb),
2450 : BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
2451 0 : ret = -EINVAL;
2452 : }
2453 0 : if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
2454 : + sizeof(struct btrfs_chunk)) {
2455 0 : btrfs_err(fs_info, "system chunk array too small %u < %zu",
2456 : btrfs_super_sys_array_size(sb),
2457 : sizeof(struct btrfs_disk_key)
2458 : + sizeof(struct btrfs_chunk));
2459 0 : ret = -EINVAL;
2460 : }
2461 :
2462 : /*
2463 : * The generation is a global counter, we'll trust it more than the others
2464 : * but it's still possible that it's the one that's wrong.
2465 : */
2466 0 : if (btrfs_super_generation(sb) < btrfs_super_chunk_root_generation(sb))
2467 0 : btrfs_warn(fs_info,
2468 : "suspicious: generation < chunk_root_generation: %llu < %llu",
2469 : btrfs_super_generation(sb),
2470 : btrfs_super_chunk_root_generation(sb));
2471 0 : if (btrfs_super_generation(sb) < btrfs_super_cache_generation(sb)
2472 0 : && btrfs_super_cache_generation(sb) != (u64)-1)
2473 0 : btrfs_warn(fs_info,
2474 : "suspicious: generation < cache_generation: %llu < %llu",
2475 : btrfs_super_generation(sb),
2476 : btrfs_super_cache_generation(sb));
2477 :
2478 0 : return ret;
2479 : }
2480 :
2481 : /*
2482 : * Validation of super block at mount time.
2483 : * Some checks already done early at mount time, like csum type and incompat
2484 : * flags will be skipped.
2485 : */
2486 : static int btrfs_validate_mount_super(struct btrfs_fs_info *fs_info)
2487 : {
2488 0 : return btrfs_validate_super(fs_info, fs_info->super_copy, 0);
2489 : }
2490 :
2491 : /*
2492 : * Validation of super block at write time.
2493 : * Some checks like bytenr check will be skipped as their values will be
2494 : * overwritten soon.
2495 : * Extra checks like csum type and incompat flags will be done here.
2496 : */
2497 0 : static int btrfs_validate_write_super(struct btrfs_fs_info *fs_info,
2498 : struct btrfs_super_block *sb)
2499 : {
2500 0 : int ret;
2501 :
2502 0 : ret = btrfs_validate_super(fs_info, sb, -1);
2503 0 : if (ret < 0)
2504 0 : goto out;
2505 0 : if (!btrfs_supported_super_csum(btrfs_super_csum_type(sb))) {
2506 0 : ret = -EUCLEAN;
2507 0 : btrfs_err(fs_info, "invalid csum type, has %u want %u",
2508 : btrfs_super_csum_type(sb), BTRFS_CSUM_TYPE_CRC32);
2509 0 : goto out;
2510 : }
2511 0 : if (btrfs_super_incompat_flags(sb) & ~BTRFS_FEATURE_INCOMPAT_SUPP) {
2512 0 : ret = -EUCLEAN;
2513 0 : btrfs_err(fs_info,
2514 : "invalid incompat flags, has 0x%llx valid mask 0x%llx",
2515 : btrfs_super_incompat_flags(sb),
2516 : (unsigned long long)BTRFS_FEATURE_INCOMPAT_SUPP);
2517 0 : goto out;
2518 : }
2519 0 : out:
2520 0 : if (ret < 0)
2521 0 : btrfs_err(fs_info,
2522 : "super block corruption detected before writing it to disk");
2523 0 : return ret;
2524 : }
2525 :
2526 0 : static int load_super_root(struct btrfs_root *root, u64 bytenr, u64 gen, int level)
2527 : {
2528 0 : struct btrfs_tree_parent_check check = {
2529 : .level = level,
2530 : .transid = gen,
2531 0 : .owner_root = root->root_key.objectid
2532 : };
2533 0 : int ret = 0;
2534 :
2535 0 : root->node = read_tree_block(root->fs_info, bytenr, &check);
2536 0 : if (IS_ERR(root->node)) {
2537 0 : ret = PTR_ERR(root->node);
2538 0 : root->node = NULL;
2539 0 : return ret;
2540 : }
2541 0 : if (!extent_buffer_uptodate(root->node)) {
2542 0 : free_extent_buffer(root->node);
2543 0 : root->node = NULL;
2544 0 : return -EIO;
2545 : }
2546 :
2547 0 : btrfs_set_root_node(&root->root_item, root->node);
2548 0 : root->commit_root = btrfs_root_node(root);
2549 0 : btrfs_set_root_refs(&root->root_item, 1);
2550 0 : return ret;
2551 : }
2552 :
2553 0 : static int load_important_roots(struct btrfs_fs_info *fs_info)
2554 : {
2555 0 : struct btrfs_super_block *sb = fs_info->super_copy;
2556 0 : u64 gen, bytenr;
2557 0 : int level, ret;
2558 :
2559 0 : bytenr = btrfs_super_root(sb);
2560 0 : gen = btrfs_super_generation(sb);
2561 0 : level = btrfs_super_root_level(sb);
2562 0 : ret = load_super_root(fs_info->tree_root, bytenr, gen, level);
2563 0 : if (ret) {
2564 0 : btrfs_warn(fs_info, "couldn't read tree root");
2565 0 : return ret;
2566 : }
2567 : return 0;
2568 : }
2569 :
2570 0 : static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)
2571 : {
2572 0 : int backup_index = find_newest_super_backup(fs_info);
2573 0 : struct btrfs_super_block *sb = fs_info->super_copy;
2574 0 : struct btrfs_root *tree_root = fs_info->tree_root;
2575 0 : bool handle_error = false;
2576 0 : int ret = 0;
2577 0 : int i;
2578 :
2579 0 : for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
2580 0 : if (handle_error) {
2581 0 : if (!IS_ERR(tree_root->node))
2582 0 : free_extent_buffer(tree_root->node);
2583 0 : tree_root->node = NULL;
2584 :
2585 0 : if (!btrfs_test_opt(fs_info, USEBACKUPROOT))
2586 : break;
2587 :
2588 0 : free_root_pointers(fs_info, 0);
2589 :
2590 : /*
2591 : * Don't use the log in recovery mode, it won't be
2592 : * valid
2593 : */
2594 0 : btrfs_set_super_log_root(sb, 0);
2595 :
2596 : /* We can't trust the free space cache either */
2597 0 : btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2598 :
2599 0 : btrfs_warn(fs_info, "try to load backup roots slot %d", i);
2600 0 : ret = read_backup_root(fs_info, i);
2601 0 : backup_index = ret;
2602 0 : if (ret < 0)
2603 0 : return ret;
2604 : }
2605 :
2606 0 : ret = load_important_roots(fs_info);
2607 0 : if (ret) {
2608 0 : handle_error = true;
2609 0 : continue;
2610 : }
2611 :
2612 : /*
2613 : * No need to hold btrfs_root::objectid_mutex since the fs
2614 : * hasn't been fully initialised and we are the only user
2615 : */
2616 0 : ret = btrfs_init_root_free_objectid(tree_root);
2617 0 : if (ret < 0) {
2618 0 : handle_error = true;
2619 0 : continue;
2620 : }
2621 :
2622 0 : ASSERT(tree_root->free_objectid <= BTRFS_LAST_FREE_OBJECTID);
2623 :
2624 0 : ret = btrfs_read_roots(fs_info);
2625 0 : if (ret < 0) {
2626 0 : handle_error = true;
2627 0 : continue;
2628 : }
2629 :
2630 : /* All successful */
2631 0 : fs_info->generation = btrfs_header_generation(tree_root->node);
2632 0 : fs_info->last_trans_committed = fs_info->generation;
2633 0 : fs_info->last_reloc_trans = 0;
2634 :
2635 : /* Always begin writing backup roots after the one being used */
2636 0 : if (backup_index < 0) {
2637 0 : fs_info->backup_root_index = 0;
2638 : } else {
2639 0 : fs_info->backup_root_index = backup_index + 1;
2640 0 : fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS;
2641 : }
2642 : break;
2643 : }
2644 :
2645 : return ret;
2646 : }
2647 :
2648 0 : void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
2649 : {
2650 0 : INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2651 0 : INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
2652 0 : INIT_LIST_HEAD(&fs_info->trans_list);
2653 0 : INIT_LIST_HEAD(&fs_info->dead_roots);
2654 0 : INIT_LIST_HEAD(&fs_info->delayed_iputs);
2655 0 : INIT_LIST_HEAD(&fs_info->delalloc_roots);
2656 0 : INIT_LIST_HEAD(&fs_info->caching_block_groups);
2657 0 : spin_lock_init(&fs_info->delalloc_root_lock);
2658 0 : spin_lock_init(&fs_info->trans_lock);
2659 0 : spin_lock_init(&fs_info->fs_roots_radix_lock);
2660 0 : spin_lock_init(&fs_info->delayed_iput_lock);
2661 0 : spin_lock_init(&fs_info->defrag_inodes_lock);
2662 0 : spin_lock_init(&fs_info->super_lock);
2663 0 : spin_lock_init(&fs_info->buffer_lock);
2664 0 : spin_lock_init(&fs_info->unused_bgs_lock);
2665 0 : spin_lock_init(&fs_info->treelog_bg_lock);
2666 0 : spin_lock_init(&fs_info->zone_active_bgs_lock);
2667 0 : spin_lock_init(&fs_info->relocation_bg_lock);
2668 0 : rwlock_init(&fs_info->tree_mod_log_lock);
2669 0 : rwlock_init(&fs_info->global_root_lock);
2670 0 : mutex_init(&fs_info->unused_bg_unpin_mutex);
2671 0 : mutex_init(&fs_info->reclaim_bgs_lock);
2672 0 : mutex_init(&fs_info->reloc_mutex);
2673 0 : mutex_init(&fs_info->delalloc_root_mutex);
2674 0 : mutex_init(&fs_info->zoned_meta_io_lock);
2675 0 : mutex_init(&fs_info->zoned_data_reloc_io_lock);
2676 0 : seqlock_init(&fs_info->profiles_lock);
2677 :
2678 0 : btrfs_lockdep_init_map(fs_info, btrfs_trans_num_writers);
2679 0 : btrfs_lockdep_init_map(fs_info, btrfs_trans_num_extwriters);
2680 0 : btrfs_lockdep_init_map(fs_info, btrfs_trans_pending_ordered);
2681 0 : btrfs_lockdep_init_map(fs_info, btrfs_ordered_extent);
2682 0 : btrfs_state_lockdep_init_map(fs_info, btrfs_trans_commit_start,
2683 : BTRFS_LOCKDEP_TRANS_COMMIT_START);
2684 0 : btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,
2685 : BTRFS_LOCKDEP_TRANS_UNBLOCKED);
2686 0 : btrfs_state_lockdep_init_map(fs_info, btrfs_trans_super_committed,
2687 : BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED);
2688 0 : btrfs_state_lockdep_init_map(fs_info, btrfs_trans_completed,
2689 : BTRFS_LOCKDEP_TRANS_COMPLETED);
2690 :
2691 0 : INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2692 0 : INIT_LIST_HEAD(&fs_info->space_info);
2693 0 : INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2694 0 : INIT_LIST_HEAD(&fs_info->unused_bgs);
2695 0 : INIT_LIST_HEAD(&fs_info->reclaim_bgs);
2696 0 : INIT_LIST_HEAD(&fs_info->zone_active_bgs);
2697 : #ifdef CONFIG_BTRFS_DEBUG
2698 : INIT_LIST_HEAD(&fs_info->allocated_roots);
2699 : INIT_LIST_HEAD(&fs_info->allocated_ebs);
2700 : spin_lock_init(&fs_info->eb_leak_lock);
2701 : #endif
2702 0 : extent_map_tree_init(&fs_info->mapping_tree);
2703 0 : btrfs_init_block_rsv(&fs_info->global_block_rsv,
2704 : BTRFS_BLOCK_RSV_GLOBAL);
2705 0 : btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
2706 0 : btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
2707 0 : btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
2708 0 : btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
2709 : BTRFS_BLOCK_RSV_DELOPS);
2710 0 : btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,
2711 : BTRFS_BLOCK_RSV_DELREFS);
2712 :
2713 0 : atomic_set(&fs_info->async_delalloc_pages, 0);
2714 0 : atomic_set(&fs_info->defrag_running, 0);
2715 0 : atomic_set(&fs_info->nr_delayed_iputs, 0);
2716 0 : atomic64_set(&fs_info->tree_mod_seq, 0);
2717 0 : fs_info->global_root_tree = RB_ROOT;
2718 0 : fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
2719 0 : fs_info->metadata_ratio = 0;
2720 0 : fs_info->defrag_inodes = RB_ROOT;
2721 0 : atomic64_set(&fs_info->free_chunk_space, 0);
2722 0 : fs_info->tree_mod_log = RB_ROOT;
2723 0 : fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2724 0 : btrfs_init_ref_verify(fs_info);
2725 :
2726 0 : fs_info->thread_pool_size = min_t(unsigned long,
2727 : num_online_cpus() + 2, 8);
2728 :
2729 0 : INIT_LIST_HEAD(&fs_info->ordered_roots);
2730 0 : spin_lock_init(&fs_info->ordered_root_lock);
2731 :
2732 0 : btrfs_init_scrub(fs_info);
2733 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2734 : fs_info->check_integrity_print_mask = 0;
2735 : #endif
2736 0 : btrfs_init_balance(fs_info);
2737 0 : btrfs_init_async_reclaim_work(fs_info);
2738 :
2739 0 : rwlock_init(&fs_info->block_group_cache_lock);
2740 0 : fs_info->block_group_cache_tree = RB_ROOT_CACHED;
2741 :
2742 0 : extent_io_tree_init(fs_info, &fs_info->excluded_extents,
2743 : IO_TREE_FS_EXCLUDED_EXTENTS);
2744 :
2745 0 : mutex_init(&fs_info->ordered_operations_mutex);
2746 0 : mutex_init(&fs_info->tree_log_mutex);
2747 0 : mutex_init(&fs_info->chunk_mutex);
2748 0 : mutex_init(&fs_info->transaction_kthread_mutex);
2749 0 : mutex_init(&fs_info->cleaner_mutex);
2750 0 : mutex_init(&fs_info->ro_block_group_mutex);
2751 0 : init_rwsem(&fs_info->commit_root_sem);
2752 0 : init_rwsem(&fs_info->cleanup_work_sem);
2753 0 : init_rwsem(&fs_info->subvol_sem);
2754 0 : sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2755 :
2756 0 : btrfs_init_dev_replace_locks(fs_info);
2757 0 : btrfs_init_qgroup(fs_info);
2758 0 : btrfs_discard_init(fs_info);
2759 :
2760 0 : btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2761 0 : btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2762 :
2763 0 : init_waitqueue_head(&fs_info->transaction_throttle);
2764 0 : init_waitqueue_head(&fs_info->transaction_wait);
2765 0 : init_waitqueue_head(&fs_info->transaction_blocked_wait);
2766 0 : init_waitqueue_head(&fs_info->async_submit_wait);
2767 0 : init_waitqueue_head(&fs_info->delayed_iputs_wait);
2768 :
2769 : /* Usable values until the real ones are cached from the superblock */
2770 0 : fs_info->nodesize = 4096;
2771 0 : fs_info->sectorsize = 4096;
2772 0 : fs_info->sectorsize_bits = ilog2(4096);
2773 0 : fs_info->stripesize = 4096;
2774 :
2775 0 : fs_info->max_extent_size = BTRFS_MAX_EXTENT_SIZE;
2776 :
2777 0 : spin_lock_init(&fs_info->swapfile_pins_lock);
2778 0 : fs_info->swapfile_pins = RB_ROOT;
2779 :
2780 0 : fs_info->bg_reclaim_threshold = BTRFS_DEFAULT_RECLAIM_THRESH;
2781 0 : INIT_WORK(&fs_info->reclaim_bgs_work, btrfs_reclaim_bgs_work);
2782 0 : }
2783 :
2784 0 : static int init_mount_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)
2785 : {
2786 0 : int ret;
2787 :
2788 0 : fs_info->sb = sb;
2789 0 : sb->s_blocksize = BTRFS_BDEV_BLOCKSIZE;
2790 0 : sb->s_blocksize_bits = blksize_bits(BTRFS_BDEV_BLOCKSIZE);
2791 :
2792 0 : ret = percpu_counter_init(&fs_info->ordered_bytes, 0, GFP_KERNEL);
2793 0 : if (ret)
2794 : return ret;
2795 :
2796 0 : ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
2797 0 : if (ret)
2798 : return ret;
2799 :
2800 0 : fs_info->dirty_metadata_batch = PAGE_SIZE *
2801 0 : (1 + ilog2(nr_cpu_ids));
2802 :
2803 0 : ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
2804 0 : if (ret)
2805 : return ret;
2806 :
2807 0 : ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,
2808 : GFP_KERNEL);
2809 0 : if (ret)
2810 : return ret;
2811 :
2812 0 : fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2813 : GFP_KERNEL);
2814 0 : if (!fs_info->delayed_root)
2815 : return -ENOMEM;
2816 0 : btrfs_init_delayed_root(fs_info->delayed_root);
2817 :
2818 0 : if (sb_rdonly(sb))
2819 0 : set_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state);
2820 :
2821 0 : return btrfs_alloc_stripe_hash_table(fs_info);
2822 : }
2823 :
2824 0 : static int btrfs_uuid_rescan_kthread(void *data)
2825 : {
2826 0 : struct btrfs_fs_info *fs_info = data;
2827 0 : int ret;
2828 :
2829 : /*
2830 : * 1st step is to iterate through the existing UUID tree and
2831 : * to delete all entries that contain outdated data.
2832 : * 2nd step is to add all missing entries to the UUID tree.
2833 : */
2834 0 : ret = btrfs_uuid_tree_iterate(fs_info);
2835 0 : if (ret < 0) {
2836 0 : if (ret != -EINTR)
2837 0 : btrfs_warn(fs_info, "iterating uuid_tree failed %d",
2838 : ret);
2839 0 : up(&fs_info->uuid_tree_rescan_sem);
2840 0 : return ret;
2841 : }
2842 0 : return btrfs_uuid_scan_kthread(data);
2843 : }
2844 :
2845 0 : static int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
2846 : {
2847 0 : struct task_struct *task;
2848 :
2849 0 : down(&fs_info->uuid_tree_rescan_sem);
2850 0 : task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
2851 0 : if (IS_ERR(task)) {
2852 : /* fs_info->update_uuid_tree_gen remains 0 in all error case */
2853 0 : btrfs_warn(fs_info, "failed to start uuid_rescan task");
2854 0 : up(&fs_info->uuid_tree_rescan_sem);
2855 0 : return PTR_ERR(task);
2856 : }
2857 :
2858 : return 0;
2859 : }
2860 :
2861 : /*
2862 : * Some options only have meaning at mount time and shouldn't persist across
2863 : * remounts, or be displayed. Clear these at the end of mount and remount
2864 : * code paths.
2865 : */
2866 0 : void btrfs_clear_oneshot_options(struct btrfs_fs_info *fs_info)
2867 : {
2868 0 : btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);
2869 0 : btrfs_clear_opt(fs_info->mount_opt, CLEAR_CACHE);
2870 0 : }
2871 :
2872 : /*
2873 : * Mounting logic specific to read-write file systems. Shared by open_ctree
2874 : * and btrfs_remount when remounting from read-only to read-write.
2875 : */
2876 0 : int btrfs_start_pre_rw_mount(struct btrfs_fs_info *fs_info)
2877 : {
2878 0 : int ret;
2879 0 : const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);
2880 0 : bool rebuild_free_space_tree = false;
2881 :
2882 0 : if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
2883 0 : btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2884 : rebuild_free_space_tree = true;
2885 0 : } else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
2886 0 : !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
2887 0 : btrfs_warn(fs_info, "free space tree is invalid");
2888 0 : rebuild_free_space_tree = true;
2889 : }
2890 :
2891 0 : if (rebuild_free_space_tree) {
2892 0 : btrfs_info(fs_info, "rebuilding free space tree");
2893 0 : ret = btrfs_rebuild_free_space_tree(fs_info);
2894 0 : if (ret) {
2895 0 : btrfs_warn(fs_info,
2896 : "failed to rebuild free space tree: %d", ret);
2897 0 : goto out;
2898 : }
2899 : }
2900 :
2901 0 : if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
2902 0 : !btrfs_test_opt(fs_info, FREE_SPACE_TREE)) {
2903 0 : btrfs_info(fs_info, "disabling free space tree");
2904 0 : ret = btrfs_delete_free_space_tree(fs_info);
2905 0 : if (ret) {
2906 0 : btrfs_warn(fs_info,
2907 : "failed to disable free space tree: %d", ret);
2908 0 : goto out;
2909 : }
2910 : }
2911 :
2912 : /*
2913 : * btrfs_find_orphan_roots() is responsible for finding all the dead
2914 : * roots (with 0 refs), flag them with BTRFS_ROOT_DEAD_TREE and load
2915 : * them into the fs_info->fs_roots_radix tree. This must be done before
2916 : * calling btrfs_orphan_cleanup() on the tree root. If we don't do it
2917 : * first, then btrfs_orphan_cleanup() will delete a dead root's orphan
2918 : * item before the root's tree is deleted - this means that if we unmount
2919 : * or crash before the deletion completes, on the next mount we will not
2920 : * delete what remains of the tree because the orphan item does not
2921 : * exists anymore, which is what tells us we have a pending deletion.
2922 : */
2923 0 : ret = btrfs_find_orphan_roots(fs_info);
2924 0 : if (ret)
2925 0 : goto out;
2926 :
2927 0 : ret = btrfs_cleanup_fs_roots(fs_info);
2928 0 : if (ret)
2929 0 : goto out;
2930 :
2931 0 : down_read(&fs_info->cleanup_work_sem);
2932 0 : if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2933 0 : (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2934 0 : up_read(&fs_info->cleanup_work_sem);
2935 0 : goto out;
2936 : }
2937 0 : up_read(&fs_info->cleanup_work_sem);
2938 :
2939 0 : mutex_lock(&fs_info->cleaner_mutex);
2940 0 : ret = btrfs_recover_relocation(fs_info);
2941 0 : mutex_unlock(&fs_info->cleaner_mutex);
2942 0 : if (ret < 0) {
2943 0 : btrfs_warn(fs_info, "failed to recover relocation: %d", ret);
2944 0 : goto out;
2945 : }
2946 :
2947 0 : if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&
2948 0 : !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2949 0 : btrfs_info(fs_info, "creating free space tree");
2950 0 : ret = btrfs_create_free_space_tree(fs_info);
2951 0 : if (ret) {
2952 0 : btrfs_warn(fs_info,
2953 : "failed to create free space tree: %d", ret);
2954 0 : goto out;
2955 : }
2956 : }
2957 :
2958 0 : if (cache_opt != btrfs_free_space_cache_v1_active(fs_info)) {
2959 0 : ret = btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);
2960 0 : if (ret)
2961 0 : goto out;
2962 : }
2963 :
2964 0 : ret = btrfs_resume_balance_async(fs_info);
2965 0 : if (ret)
2966 0 : goto out;
2967 :
2968 0 : ret = btrfs_resume_dev_replace_async(fs_info);
2969 0 : if (ret) {
2970 0 : btrfs_warn(fs_info, "failed to resume dev_replace");
2971 0 : goto out;
2972 : }
2973 :
2974 0 : btrfs_qgroup_rescan_resume(fs_info);
2975 :
2976 0 : if (!fs_info->uuid_root) {
2977 0 : btrfs_info(fs_info, "creating UUID tree");
2978 0 : ret = btrfs_create_uuid_tree(fs_info);
2979 0 : if (ret) {
2980 0 : btrfs_warn(fs_info,
2981 : "failed to create the UUID tree %d", ret);
2982 0 : goto out;
2983 : }
2984 : }
2985 :
2986 0 : out:
2987 0 : return ret;
2988 : }
2989 :
2990 : /*
2991 : * Do various sanity and dependency checks of different features.
2992 : *
2993 : * @is_rw_mount: If the mount is read-write.
2994 : *
2995 : * This is the place for less strict checks (like for subpage or artificial
2996 : * feature dependencies).
2997 : *
2998 : * For strict checks or possible corruption detection, see
2999 : * btrfs_validate_super().
3000 : *
3001 : * This should be called after btrfs_parse_options(), as some mount options
3002 : * (space cache related) can modify on-disk format like free space tree and
3003 : * screw up certain feature dependencies.
3004 : */
3005 0 : int btrfs_check_features(struct btrfs_fs_info *fs_info, bool is_rw_mount)
3006 : {
3007 0 : struct btrfs_super_block *disk_super = fs_info->super_copy;
3008 0 : u64 incompat = btrfs_super_incompat_flags(disk_super);
3009 0 : const u64 compat_ro = btrfs_super_compat_ro_flags(disk_super);
3010 0 : const u64 compat_ro_unsupp = (compat_ro & ~BTRFS_FEATURE_COMPAT_RO_SUPP);
3011 :
3012 0 : if (incompat & ~BTRFS_FEATURE_INCOMPAT_SUPP) {
3013 0 : btrfs_err(fs_info,
3014 : "cannot mount because of unknown incompat features (0x%llx)",
3015 : incompat);
3016 0 : return -EINVAL;
3017 : }
3018 :
3019 : /* Runtime limitation for mixed block groups. */
3020 0 : if ((incompat & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
3021 0 : (fs_info->sectorsize != fs_info->nodesize)) {
3022 0 : btrfs_err(fs_info,
3023 : "unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups",
3024 : fs_info->nodesize, fs_info->sectorsize);
3025 0 : return -EINVAL;
3026 : }
3027 :
3028 : /* Mixed backref is an always-enabled feature. */
3029 0 : incompat |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
3030 :
3031 : /* Set compression related flags just in case. */
3032 0 : if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
3033 0 : incompat |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
3034 0 : else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
3035 0 : incompat |= BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD;
3036 :
3037 : /*
3038 : * An ancient flag, which should really be marked deprecated.
3039 : * Such runtime limitation doesn't really need a incompat flag.
3040 : */
3041 0 : if (btrfs_super_nodesize(disk_super) > PAGE_SIZE)
3042 0 : incompat |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
3043 :
3044 0 : if (compat_ro_unsupp && is_rw_mount) {
3045 0 : btrfs_err(fs_info,
3046 : "cannot mount read-write because of unknown compat_ro features (0x%llx)",
3047 : compat_ro);
3048 0 : return -EINVAL;
3049 : }
3050 :
3051 : /*
3052 : * We have unsupported RO compat features, although RO mounted, we
3053 : * should not cause any metadata writes, including log replay.
3054 : * Or we could screw up whatever the new feature requires.
3055 : */
3056 0 : if (compat_ro_unsupp && btrfs_super_log_root(disk_super) &&
3057 0 : !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3058 0 : btrfs_err(fs_info,
3059 : "cannot replay dirty log with unsupported compat_ro features (0x%llx), try rescue=nologreplay",
3060 : compat_ro);
3061 0 : return -EINVAL;
3062 : }
3063 :
3064 : /*
3065 : * Artificial limitations for block group tree, to force
3066 : * block-group-tree to rely on no-holes and free-space-tree.
3067 : */
3068 0 : if (btrfs_fs_compat_ro(fs_info, BLOCK_GROUP_TREE) &&
3069 0 : (!btrfs_fs_incompat(fs_info, NO_HOLES) ||
3070 0 : !btrfs_test_opt(fs_info, FREE_SPACE_TREE))) {
3071 0 : btrfs_err(fs_info,
3072 : "block-group-tree feature requires no-holes and free-space-tree features");
3073 0 : return -EINVAL;
3074 : }
3075 :
3076 : /*
3077 : * Subpage runtime limitation on v1 cache.
3078 : *
3079 : * V1 space cache still has some hard codeed PAGE_SIZE usage, while
3080 : * we're already defaulting to v2 cache, no need to bother v1 as it's
3081 : * going to be deprecated anyway.
3082 : */
3083 0 : if (fs_info->sectorsize < PAGE_SIZE && btrfs_test_opt(fs_info, SPACE_CACHE)) {
3084 0 : btrfs_warn(fs_info,
3085 : "v1 space cache is not supported for page size %lu with sectorsize %u",
3086 : PAGE_SIZE, fs_info->sectorsize);
3087 0 : return -EINVAL;
3088 : }
3089 :
3090 : /* This can be called by remount, we need to protect the super block. */
3091 0 : spin_lock(&fs_info->super_lock);
3092 0 : btrfs_set_super_incompat_flags(disk_super, incompat);
3093 0 : spin_unlock(&fs_info->super_lock);
3094 :
3095 0 : return 0;
3096 : }
3097 :
3098 0 : int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devices,
3099 : char *options)
3100 : {
3101 0 : u32 sectorsize;
3102 0 : u32 nodesize;
3103 0 : u32 stripesize;
3104 0 : u64 generation;
3105 0 : u64 features;
3106 0 : u16 csum_type;
3107 0 : struct btrfs_super_block *disk_super;
3108 0 : struct btrfs_fs_info *fs_info = btrfs_sb(sb);
3109 0 : struct btrfs_root *tree_root;
3110 0 : struct btrfs_root *chunk_root;
3111 0 : int ret;
3112 0 : int level;
3113 :
3114 0 : ret = init_mount_fs_info(fs_info, sb);
3115 0 : if (ret)
3116 0 : goto fail;
3117 :
3118 : /* These need to be init'ed before we start creating inodes and such. */
3119 0 : tree_root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID,
3120 : GFP_KERNEL);
3121 0 : fs_info->tree_root = tree_root;
3122 0 : chunk_root = btrfs_alloc_root(fs_info, BTRFS_CHUNK_TREE_OBJECTID,
3123 : GFP_KERNEL);
3124 0 : fs_info->chunk_root = chunk_root;
3125 0 : if (!tree_root || !chunk_root) {
3126 0 : ret = -ENOMEM;
3127 0 : goto fail;
3128 : }
3129 :
3130 0 : ret = btrfs_init_btree_inode(sb);
3131 0 : if (ret)
3132 0 : goto fail;
3133 :
3134 0 : invalidate_bdev(fs_devices->latest_dev->bdev);
3135 :
3136 : /*
3137 : * Read super block and check the signature bytes only
3138 : */
3139 0 : disk_super = btrfs_read_dev_super(fs_devices->latest_dev->bdev);
3140 0 : if (IS_ERR(disk_super)) {
3141 0 : ret = PTR_ERR(disk_super);
3142 0 : goto fail_alloc;
3143 : }
3144 :
3145 : /*
3146 : * Verify the type first, if that or the checksum value are
3147 : * corrupted, we'll find out
3148 : */
3149 0 : csum_type = btrfs_super_csum_type(disk_super);
3150 0 : if (!btrfs_supported_super_csum(csum_type)) {
3151 0 : btrfs_err(fs_info, "unsupported checksum algorithm: %u",
3152 : csum_type);
3153 0 : ret = -EINVAL;
3154 0 : btrfs_release_disk_super(disk_super);
3155 0 : goto fail_alloc;
3156 : }
3157 :
3158 0 : fs_info->csum_size = btrfs_super_csum_size(disk_super);
3159 :
3160 0 : ret = btrfs_init_csum_hash(fs_info, csum_type);
3161 0 : if (ret) {
3162 0 : btrfs_release_disk_super(disk_super);
3163 0 : goto fail_alloc;
3164 : }
3165 :
3166 : /*
3167 : * We want to check superblock checksum, the type is stored inside.
3168 : * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
3169 : */
3170 0 : if (btrfs_check_super_csum(fs_info, disk_super)) {
3171 0 : btrfs_err(fs_info, "superblock checksum mismatch");
3172 0 : ret = -EINVAL;
3173 0 : btrfs_release_disk_super(disk_super);
3174 0 : goto fail_alloc;
3175 : }
3176 :
3177 : /*
3178 : * super_copy is zeroed at allocation time and we never touch the
3179 : * following bytes up to INFO_SIZE, the checksum is calculated from
3180 : * the whole block of INFO_SIZE
3181 : */
3182 0 : memcpy(fs_info->super_copy, disk_super, sizeof(*fs_info->super_copy));
3183 0 : btrfs_release_disk_super(disk_super);
3184 :
3185 0 : disk_super = fs_info->super_copy;
3186 :
3187 :
3188 0 : features = btrfs_super_flags(disk_super);
3189 0 : if (features & BTRFS_SUPER_FLAG_CHANGING_FSID_V2) {
3190 0 : features &= ~BTRFS_SUPER_FLAG_CHANGING_FSID_V2;
3191 0 : btrfs_set_super_flags(disk_super, features);
3192 0 : btrfs_info(fs_info,
3193 : "found metadata UUID change in progress flag, clearing");
3194 : }
3195 :
3196 0 : memcpy(fs_info->super_for_commit, fs_info->super_copy,
3197 : sizeof(*fs_info->super_for_commit));
3198 :
3199 0 : ret = btrfs_validate_mount_super(fs_info);
3200 0 : if (ret) {
3201 0 : btrfs_err(fs_info, "superblock contains fatal errors");
3202 0 : ret = -EINVAL;
3203 0 : goto fail_alloc;
3204 : }
3205 :
3206 0 : if (!btrfs_super_root(disk_super)) {
3207 0 : btrfs_err(fs_info, "invalid superblock tree root bytenr");
3208 0 : ret = -EINVAL;
3209 0 : goto fail_alloc;
3210 : }
3211 :
3212 : /* check FS state, whether FS is broken. */
3213 0 : if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
3214 0 : set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
3215 :
3216 : /*
3217 : * In the long term, we'll store the compression type in the super
3218 : * block, and it'll be used for per file compression control.
3219 : */
3220 0 : fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
3221 :
3222 :
3223 : /* Set up fs_info before parsing mount options */
3224 0 : nodesize = btrfs_super_nodesize(disk_super);
3225 0 : sectorsize = btrfs_super_sectorsize(disk_super);
3226 0 : stripesize = sectorsize;
3227 0 : fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
3228 0 : fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
3229 :
3230 0 : fs_info->nodesize = nodesize;
3231 0 : fs_info->sectorsize = sectorsize;
3232 0 : fs_info->sectorsize_bits = ilog2(sectorsize);
3233 0 : fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) / fs_info->csum_size;
3234 0 : fs_info->stripesize = stripesize;
3235 :
3236 0 : ret = btrfs_parse_options(fs_info, options, sb->s_flags);
3237 0 : if (ret)
3238 0 : goto fail_alloc;
3239 :
3240 0 : ret = btrfs_check_features(fs_info, !sb_rdonly(sb));
3241 0 : if (ret < 0)
3242 0 : goto fail_alloc;
3243 :
3244 0 : if (sectorsize < PAGE_SIZE) {
3245 0 : struct btrfs_subpage_info *subpage_info;
3246 :
3247 : /*
3248 : * V1 space cache has some hardcoded PAGE_SIZE usage, and is
3249 : * going to be deprecated.
3250 : *
3251 : * Force to use v2 cache for subpage case.
3252 : */
3253 0 : btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);
3254 0 : btrfs_set_and_info(fs_info, FREE_SPACE_TREE,
3255 : "forcing free space tree for sector size %u with page size %lu",
3256 : sectorsize, PAGE_SIZE);
3257 :
3258 0 : btrfs_warn(fs_info,
3259 : "read-write for sector size %u with page size %lu is experimental",
3260 : sectorsize, PAGE_SIZE);
3261 0 : subpage_info = kzalloc(sizeof(*subpage_info), GFP_KERNEL);
3262 0 : if (!subpage_info) {
3263 0 : ret = -ENOMEM;
3264 0 : goto fail_alloc;
3265 : }
3266 0 : btrfs_init_subpage_info(subpage_info, sectorsize);
3267 0 : fs_info->subpage_info = subpage_info;
3268 : }
3269 :
3270 0 : ret = btrfs_init_workqueues(fs_info);
3271 0 : if (ret)
3272 0 : goto fail_sb_buffer;
3273 :
3274 0 : sb->s_bdi->ra_pages *= btrfs_super_num_devices(disk_super);
3275 0 : sb->s_bdi->ra_pages = max(sb->s_bdi->ra_pages, SZ_4M / PAGE_SIZE);
3276 :
3277 0 : sb->s_blocksize = sectorsize;
3278 0 : sb->s_blocksize_bits = blksize_bits(sectorsize);
3279 0 : memcpy(&sb->s_uuid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE);
3280 :
3281 0 : mutex_lock(&fs_info->chunk_mutex);
3282 0 : ret = btrfs_read_sys_array(fs_info);
3283 0 : mutex_unlock(&fs_info->chunk_mutex);
3284 0 : if (ret) {
3285 0 : btrfs_err(fs_info, "failed to read the system array: %d", ret);
3286 0 : goto fail_sb_buffer;
3287 : }
3288 :
3289 0 : generation = btrfs_super_chunk_root_generation(disk_super);
3290 0 : level = btrfs_super_chunk_root_level(disk_super);
3291 0 : ret = load_super_root(chunk_root, btrfs_super_chunk_root(disk_super),
3292 : generation, level);
3293 0 : if (ret) {
3294 0 : btrfs_err(fs_info, "failed to read chunk root");
3295 0 : goto fail_tree_roots;
3296 : }
3297 :
3298 0 : read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
3299 : offsetof(struct btrfs_header, chunk_tree_uuid),
3300 : BTRFS_UUID_SIZE);
3301 :
3302 0 : ret = btrfs_read_chunk_tree(fs_info);
3303 0 : if (ret) {
3304 0 : btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
3305 0 : goto fail_tree_roots;
3306 : }
3307 :
3308 : /*
3309 : * At this point we know all the devices that make this filesystem,
3310 : * including the seed devices but we don't know yet if the replace
3311 : * target is required. So free devices that are not part of this
3312 : * filesystem but skip the replace target device which is checked
3313 : * below in btrfs_init_dev_replace().
3314 : */
3315 0 : btrfs_free_extra_devids(fs_devices);
3316 0 : if (!fs_devices->latest_dev->bdev) {
3317 0 : btrfs_err(fs_info, "failed to read devices");
3318 0 : ret = -EIO;
3319 0 : goto fail_tree_roots;
3320 : }
3321 :
3322 0 : ret = init_tree_roots(fs_info);
3323 0 : if (ret)
3324 0 : goto fail_tree_roots;
3325 :
3326 : /*
3327 : * Get zone type information of zoned block devices. This will also
3328 : * handle emulation of a zoned filesystem if a regular device has the
3329 : * zoned incompat feature flag set.
3330 : */
3331 0 : ret = btrfs_get_dev_zone_info_all_devices(fs_info);
3332 0 : if (ret) {
3333 0 : btrfs_err(fs_info,
3334 : "zoned: failed to read device zone info: %d", ret);
3335 0 : goto fail_block_groups;
3336 : }
3337 :
3338 : /*
3339 : * If we have a uuid root and we're not being told to rescan we need to
3340 : * check the generation here so we can set the
3341 : * BTRFS_FS_UPDATE_UUID_TREE_GEN bit. Otherwise we could commit the
3342 : * transaction during a balance or the log replay without updating the
3343 : * uuid generation, and then if we crash we would rescan the uuid tree,
3344 : * even though it was perfectly fine.
3345 : */
3346 0 : if (fs_info->uuid_root && !btrfs_test_opt(fs_info, RESCAN_UUID_TREE) &&
3347 0 : fs_info->generation == btrfs_super_uuid_tree_generation(disk_super))
3348 0 : set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
3349 :
3350 0 : ret = btrfs_verify_dev_extents(fs_info);
3351 0 : if (ret) {
3352 0 : btrfs_err(fs_info,
3353 : "failed to verify dev extents against chunks: %d",
3354 : ret);
3355 0 : goto fail_block_groups;
3356 : }
3357 0 : ret = btrfs_recover_balance(fs_info);
3358 0 : if (ret) {
3359 0 : btrfs_err(fs_info, "failed to recover balance: %d", ret);
3360 0 : goto fail_block_groups;
3361 : }
3362 :
3363 0 : ret = btrfs_init_dev_stats(fs_info);
3364 0 : if (ret) {
3365 0 : btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
3366 0 : goto fail_block_groups;
3367 : }
3368 :
3369 0 : ret = btrfs_init_dev_replace(fs_info);
3370 0 : if (ret) {
3371 0 : btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
3372 0 : goto fail_block_groups;
3373 : }
3374 :
3375 0 : ret = btrfs_check_zoned_mode(fs_info);
3376 0 : if (ret) {
3377 0 : btrfs_err(fs_info, "failed to initialize zoned mode: %d",
3378 : ret);
3379 0 : goto fail_block_groups;
3380 : }
3381 :
3382 0 : ret = btrfs_sysfs_add_fsid(fs_devices);
3383 0 : if (ret) {
3384 0 : btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
3385 : ret);
3386 0 : goto fail_block_groups;
3387 : }
3388 :
3389 0 : ret = btrfs_sysfs_add_mounted(fs_info);
3390 0 : if (ret) {
3391 0 : btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
3392 0 : goto fail_fsdev_sysfs;
3393 : }
3394 :
3395 0 : ret = btrfs_init_space_info(fs_info);
3396 0 : if (ret) {
3397 0 : btrfs_err(fs_info, "failed to initialize space info: %d", ret);
3398 0 : goto fail_sysfs;
3399 : }
3400 :
3401 0 : ret = btrfs_read_block_groups(fs_info);
3402 0 : if (ret) {
3403 0 : btrfs_err(fs_info, "failed to read block groups: %d", ret);
3404 0 : goto fail_sysfs;
3405 : }
3406 :
3407 0 : btrfs_free_zone_cache(fs_info);
3408 :
3409 0 : if (!sb_rdonly(sb) && fs_info->fs_devices->missing_devices &&
3410 0 : !btrfs_check_rw_degradable(fs_info, NULL)) {
3411 0 : btrfs_warn(fs_info,
3412 : "writable mount is not allowed due to too many missing devices");
3413 0 : ret = -EINVAL;
3414 0 : goto fail_sysfs;
3415 : }
3416 :
3417 0 : fs_info->cleaner_kthread = kthread_run(cleaner_kthread, fs_info,
3418 : "btrfs-cleaner");
3419 0 : if (IS_ERR(fs_info->cleaner_kthread)) {
3420 0 : ret = PTR_ERR(fs_info->cleaner_kthread);
3421 0 : goto fail_sysfs;
3422 : }
3423 :
3424 0 : fs_info->transaction_kthread = kthread_run(transaction_kthread,
3425 : tree_root,
3426 : "btrfs-transaction");
3427 0 : if (IS_ERR(fs_info->transaction_kthread)) {
3428 0 : ret = PTR_ERR(fs_info->transaction_kthread);
3429 0 : goto fail_cleaner;
3430 : }
3431 :
3432 0 : if (!btrfs_test_opt(fs_info, NOSSD) &&
3433 0 : !fs_info->fs_devices->rotating) {
3434 0 : btrfs_set_and_info(fs_info, SSD, "enabling ssd optimizations");
3435 : }
3436 :
3437 : /*
3438 : * For devices supporting discard turn on discard=async automatically,
3439 : * unless it's already set or disabled. This could be turned off by
3440 : * nodiscard for the same mount.
3441 : */
3442 0 : if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) ||
3443 : btrfs_test_opt(fs_info, DISCARD_ASYNC) ||
3444 0 : btrfs_test_opt(fs_info, NODISCARD)) &&
3445 0 : fs_info->fs_devices->discardable) {
3446 0 : btrfs_set_and_info(fs_info, DISCARD_ASYNC,
3447 : "auto enabling async discard");
3448 : }
3449 :
3450 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3451 : if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
3452 : ret = btrfsic_mount(fs_info, fs_devices,
3453 : btrfs_test_opt(fs_info,
3454 : CHECK_INTEGRITY_DATA) ? 1 : 0,
3455 : fs_info->check_integrity_print_mask);
3456 : if (ret)
3457 : btrfs_warn(fs_info,
3458 : "failed to initialize integrity check module: %d",
3459 : ret);
3460 : }
3461 : #endif
3462 0 : ret = btrfs_read_qgroup_config(fs_info);
3463 0 : if (ret)
3464 0 : goto fail_trans_kthread;
3465 :
3466 0 : if (btrfs_build_ref_tree(fs_info))
3467 : btrfs_err(fs_info, "couldn't build ref tree");
3468 :
3469 : /* do not make disk changes in broken FS or nologreplay is given */
3470 0 : if (btrfs_super_log_root(disk_super) != 0 &&
3471 0 : !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3472 0 : btrfs_info(fs_info, "start tree-log replay");
3473 0 : ret = btrfs_replay_log(fs_info, fs_devices);
3474 0 : if (ret)
3475 0 : goto fail_qgroup;
3476 : }
3477 :
3478 0 : fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);
3479 0 : if (IS_ERR(fs_info->fs_root)) {
3480 0 : ret = PTR_ERR(fs_info->fs_root);
3481 0 : btrfs_warn(fs_info, "failed to read fs tree: %d", ret);
3482 0 : fs_info->fs_root = NULL;
3483 0 : goto fail_qgroup;
3484 : }
3485 :
3486 0 : if (sb_rdonly(sb))
3487 0 : goto clear_oneshot;
3488 :
3489 0 : ret = btrfs_start_pre_rw_mount(fs_info);
3490 0 : if (ret) {
3491 0 : close_ctree(fs_info);
3492 0 : return ret;
3493 : }
3494 0 : btrfs_discard_resume(fs_info);
3495 :
3496 0 : if (fs_info->uuid_root &&
3497 0 : (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
3498 0 : fs_info->generation != btrfs_super_uuid_tree_generation(disk_super))) {
3499 0 : btrfs_info(fs_info, "checking UUID tree");
3500 0 : ret = btrfs_check_uuid_tree(fs_info);
3501 0 : if (ret) {
3502 0 : btrfs_warn(fs_info,
3503 : "failed to check the UUID tree: %d", ret);
3504 0 : close_ctree(fs_info);
3505 0 : return ret;
3506 : }
3507 : }
3508 :
3509 0 : set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3510 :
3511 : /* Kick the cleaner thread so it'll start deleting snapshots. */
3512 0 : if (test_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags))
3513 0 : wake_up_process(fs_info->cleaner_kthread);
3514 :
3515 0 : clear_oneshot:
3516 0 : btrfs_clear_oneshot_options(fs_info);
3517 0 : return 0;
3518 :
3519 0 : fail_qgroup:
3520 0 : btrfs_free_qgroup_config(fs_info);
3521 0 : fail_trans_kthread:
3522 0 : kthread_stop(fs_info->transaction_kthread);
3523 0 : btrfs_cleanup_transaction(fs_info);
3524 0 : btrfs_free_fs_roots(fs_info);
3525 0 : fail_cleaner:
3526 0 : kthread_stop(fs_info->cleaner_kthread);
3527 :
3528 : /*
3529 : * make sure we're done with the btree inode before we stop our
3530 : * kthreads
3531 : */
3532 0 : filemap_write_and_wait(fs_info->btree_inode->i_mapping);
3533 :
3534 0 : fail_sysfs:
3535 0 : btrfs_sysfs_remove_mounted(fs_info);
3536 :
3537 0 : fail_fsdev_sysfs:
3538 0 : btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3539 :
3540 0 : fail_block_groups:
3541 0 : btrfs_put_block_group_cache(fs_info);
3542 :
3543 0 : fail_tree_roots:
3544 0 : if (fs_info->data_reloc_root)
3545 0 : btrfs_drop_and_free_fs_root(fs_info, fs_info->data_reloc_root);
3546 0 : free_root_pointers(fs_info, true);
3547 0 : invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3548 :
3549 0 : fail_sb_buffer:
3550 0 : btrfs_stop_all_workers(fs_info);
3551 0 : btrfs_free_block_groups(fs_info);
3552 0 : fail_alloc:
3553 0 : btrfs_mapping_tree_free(&fs_info->mapping_tree);
3554 :
3555 0 : iput(fs_info->btree_inode);
3556 0 : fail:
3557 0 : btrfs_close_devices(fs_info->fs_devices);
3558 0 : ASSERT(ret < 0);
3559 0 : return ret;
3560 : }
3561 : ALLOW_ERROR_INJECTION(open_ctree, ERRNO);
3562 :
3563 0 : static void btrfs_end_super_write(struct bio *bio)
3564 : {
3565 0 : struct btrfs_device *device = bio->bi_private;
3566 0 : struct bio_vec *bvec;
3567 0 : struct bvec_iter_all iter_all;
3568 0 : struct page *page;
3569 :
3570 0 : bio_for_each_segment_all(bvec, bio, iter_all) {
3571 0 : page = bvec->bv_page;
3572 :
3573 0 : if (bio->bi_status) {
3574 0 : btrfs_warn_rl_in_rcu(device->fs_info,
3575 : "lost page write due to IO error on %s (%d)",
3576 : btrfs_dev_name(device),
3577 : blk_status_to_errno(bio->bi_status));
3578 0 : ClearPageUptodate(page);
3579 0 : SetPageError(page);
3580 0 : btrfs_dev_stat_inc_and_print(device,
3581 : BTRFS_DEV_STAT_WRITE_ERRS);
3582 : } else {
3583 0 : SetPageUptodate(page);
3584 : }
3585 :
3586 0 : put_page(page);
3587 0 : unlock_page(page);
3588 : }
3589 :
3590 0 : bio_put(bio);
3591 0 : }
3592 :
3593 0 : struct btrfs_super_block *btrfs_read_dev_one_super(struct block_device *bdev,
3594 : int copy_num, bool drop_cache)
3595 : {
3596 0 : struct btrfs_super_block *super;
3597 0 : struct page *page;
3598 0 : u64 bytenr, bytenr_orig;
3599 0 : struct address_space *mapping = bdev->bd_inode->i_mapping;
3600 0 : int ret;
3601 :
3602 0 : bytenr_orig = btrfs_sb_offset(copy_num);
3603 0 : ret = btrfs_sb_log_location_bdev(bdev, copy_num, READ, &bytenr);
3604 0 : if (ret == -ENOENT)
3605 : return ERR_PTR(-EINVAL);
3606 0 : else if (ret)
3607 0 : return ERR_PTR(ret);
3608 :
3609 0 : if (bytenr + BTRFS_SUPER_INFO_SIZE >= bdev_nr_bytes(bdev))
3610 : return ERR_PTR(-EINVAL);
3611 :
3612 0 : if (drop_cache) {
3613 : /* This should only be called with the primary sb. */
3614 0 : ASSERT(copy_num == 0);
3615 :
3616 : /*
3617 : * Drop the page of the primary superblock, so later read will
3618 : * always read from the device.
3619 : */
3620 0 : invalidate_inode_pages2_range(mapping,
3621 0 : bytenr >> PAGE_SHIFT,
3622 0 : (bytenr + BTRFS_SUPER_INFO_SIZE) >> PAGE_SHIFT);
3623 : }
3624 :
3625 0 : page = read_cache_page_gfp(mapping, bytenr >> PAGE_SHIFT, GFP_NOFS);
3626 0 : if (IS_ERR(page))
3627 : return ERR_CAST(page);
3628 :
3629 0 : super = page_address(page);
3630 0 : if (btrfs_super_magic(super) != BTRFS_MAGIC) {
3631 0 : btrfs_release_disk_super(super);
3632 0 : return ERR_PTR(-ENODATA);
3633 : }
3634 :
3635 0 : if (btrfs_super_bytenr(super) != bytenr_orig) {
3636 0 : btrfs_release_disk_super(super);
3637 0 : return ERR_PTR(-EINVAL);
3638 : }
3639 :
3640 : return super;
3641 : }
3642 :
3643 :
3644 0 : struct btrfs_super_block *btrfs_read_dev_super(struct block_device *bdev)
3645 : {
3646 0 : struct btrfs_super_block *super, *latest = NULL;
3647 0 : int i;
3648 0 : u64 transid = 0;
3649 :
3650 : /* we would like to check all the supers, but that would make
3651 : * a btrfs mount succeed after a mkfs from a different FS.
3652 : * So, we need to add a special mount option to scan for
3653 : * later supers, using BTRFS_SUPER_MIRROR_MAX instead
3654 : */
3655 0 : for (i = 0; i < 1; i++) {
3656 0 : super = btrfs_read_dev_one_super(bdev, i, false);
3657 0 : if (IS_ERR(super))
3658 0 : continue;
3659 :
3660 0 : if (!latest || btrfs_super_generation(super) > transid) {
3661 0 : if (latest)
3662 0 : btrfs_release_disk_super(super);
3663 :
3664 0 : latest = super;
3665 0 : transid = btrfs_super_generation(super);
3666 : }
3667 : }
3668 :
3669 0 : return super;
3670 : }
3671 :
3672 : /*
3673 : * Write superblock @sb to the @device. Do not wait for completion, all the
3674 : * pages we use for writing are locked.
3675 : *
3676 : * Write @max_mirrors copies of the superblock, where 0 means default that fit
3677 : * the expected device size at commit time. Note that max_mirrors must be
3678 : * same for write and wait phases.
3679 : *
3680 : * Return number of errors when page is not found or submission fails.
3681 : */
3682 0 : static int write_dev_supers(struct btrfs_device *device,
3683 : struct btrfs_super_block *sb, int max_mirrors)
3684 : {
3685 0 : struct btrfs_fs_info *fs_info = device->fs_info;
3686 0 : struct address_space *mapping = device->bdev->bd_inode->i_mapping;
3687 0 : SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
3688 0 : int i;
3689 0 : int errors = 0;
3690 0 : int ret;
3691 0 : u64 bytenr, bytenr_orig;
3692 :
3693 0 : if (max_mirrors == 0)
3694 0 : max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3695 :
3696 0 : shash->tfm = fs_info->csum_shash;
3697 :
3698 0 : for (i = 0; i < max_mirrors; i++) {
3699 0 : struct page *page;
3700 0 : struct bio *bio;
3701 0 : struct btrfs_super_block *disk_super;
3702 :
3703 0 : bytenr_orig = btrfs_sb_offset(i);
3704 0 : ret = btrfs_sb_log_location(device, i, WRITE, &bytenr);
3705 0 : if (ret == -ENOENT) {
3706 0 : continue;
3707 0 : } else if (ret < 0) {
3708 0 : btrfs_err(device->fs_info,
3709 : "couldn't get super block location for mirror %d",
3710 : i);
3711 0 : errors++;
3712 0 : continue;
3713 : }
3714 0 : if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3715 0 : device->commit_total_bytes)
3716 : break;
3717 :
3718 0 : btrfs_set_super_bytenr(sb, bytenr_orig);
3719 :
3720 0 : crypto_shash_digest(shash, (const char *)sb + BTRFS_CSUM_SIZE,
3721 : BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE,
3722 0 : sb->csum);
3723 :
3724 0 : page = find_or_create_page(mapping, bytenr >> PAGE_SHIFT,
3725 : GFP_NOFS);
3726 0 : if (!page) {
3727 0 : btrfs_err(device->fs_info,
3728 : "couldn't get super block page for bytenr %llu",
3729 : bytenr);
3730 0 : errors++;
3731 0 : continue;
3732 : }
3733 :
3734 : /* Bump the refcount for wait_dev_supers() */
3735 0 : get_page(page);
3736 :
3737 0 : disk_super = page_address(page);
3738 0 : memcpy(disk_super, sb, BTRFS_SUPER_INFO_SIZE);
3739 :
3740 : /*
3741 : * Directly use bios here instead of relying on the page cache
3742 : * to do I/O, so we don't lose the ability to do integrity
3743 : * checking.
3744 : */
3745 0 : bio = bio_alloc(device->bdev, 1,
3746 : REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO,
3747 : GFP_NOFS);
3748 0 : bio->bi_iter.bi_sector = bytenr >> SECTOR_SHIFT;
3749 0 : bio->bi_private = device;
3750 0 : bio->bi_end_io = btrfs_end_super_write;
3751 0 : __bio_add_page(bio, page, BTRFS_SUPER_INFO_SIZE,
3752 : offset_in_page(bytenr));
3753 :
3754 : /*
3755 : * We FUA only the first super block. The others we allow to
3756 : * go down lazy and there's a short window where the on-disk
3757 : * copies might still contain the older version.
3758 : */
3759 0 : if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))
3760 0 : bio->bi_opf |= REQ_FUA;
3761 :
3762 0 : btrfsic_check_bio(bio);
3763 0 : submit_bio(bio);
3764 :
3765 0 : if (btrfs_advance_sb_log(device, i))
3766 0 : errors++;
3767 : }
3768 0 : return errors < i ? 0 : -1;
3769 : }
3770 :
3771 : /*
3772 : * Wait for write completion of superblocks done by write_dev_supers,
3773 : * @max_mirrors same for write and wait phases.
3774 : *
3775 : * Return number of errors when page is not found or not marked up to
3776 : * date.
3777 : */
3778 0 : static int wait_dev_supers(struct btrfs_device *device, int max_mirrors)
3779 : {
3780 0 : int i;
3781 0 : int errors = 0;
3782 0 : bool primary_failed = false;
3783 0 : int ret;
3784 0 : u64 bytenr;
3785 :
3786 0 : if (max_mirrors == 0)
3787 0 : max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3788 :
3789 0 : for (i = 0; i < max_mirrors; i++) {
3790 0 : struct page *page;
3791 :
3792 0 : ret = btrfs_sb_log_location(device, i, READ, &bytenr);
3793 0 : if (ret == -ENOENT) {
3794 : break;
3795 0 : } else if (ret < 0) {
3796 0 : errors++;
3797 0 : if (i == 0)
3798 0 : primary_failed = true;
3799 0 : continue;
3800 : }
3801 0 : if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3802 0 : device->commit_total_bytes)
3803 : break;
3804 :
3805 0 : page = find_get_page(device->bdev->bd_inode->i_mapping,
3806 0 : bytenr >> PAGE_SHIFT);
3807 0 : if (!page) {
3808 0 : errors++;
3809 0 : if (i == 0)
3810 0 : primary_failed = true;
3811 0 : continue;
3812 : }
3813 : /* Page is submitted locked and unlocked once the IO completes */
3814 0 : wait_on_page_locked(page);
3815 0 : if (PageError(page)) {
3816 0 : errors++;
3817 0 : if (i == 0)
3818 0 : primary_failed = true;
3819 : }
3820 :
3821 : /* Drop our reference */
3822 0 : put_page(page);
3823 :
3824 : /* Drop the reference from the writing run */
3825 0 : put_page(page);
3826 : }
3827 :
3828 : /* log error, force error return */
3829 0 : if (primary_failed) {
3830 0 : btrfs_err(device->fs_info, "error writing primary super block to device %llu",
3831 : device->devid);
3832 0 : return -1;
3833 : }
3834 :
3835 0 : return errors < i ? 0 : -1;
3836 : }
3837 :
3838 : /*
3839 : * endio for the write_dev_flush, this will wake anyone waiting
3840 : * for the barrier when it is done
3841 : */
3842 0 : static void btrfs_end_empty_barrier(struct bio *bio)
3843 : {
3844 0 : bio_uninit(bio);
3845 0 : complete(bio->bi_private);
3846 0 : }
3847 :
3848 : /*
3849 : * Submit a flush request to the device if it supports it. Error handling is
3850 : * done in the waiting counterpart.
3851 : */
3852 0 : static void write_dev_flush(struct btrfs_device *device)
3853 : {
3854 0 : struct bio *bio = &device->flush_bio;
3855 :
3856 0 : device->last_flush_error = BLK_STS_OK;
3857 :
3858 : #ifndef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3859 : /*
3860 : * When a disk has write caching disabled, we skip submission of a bio
3861 : * with flush and sync requests before writing the superblock, since
3862 : * it's not needed. However when the integrity checker is enabled, this
3863 : * results in reports that there are metadata blocks referred by a
3864 : * superblock that were not properly flushed. So don't skip the bio
3865 : * submission only when the integrity checker is enabled for the sake
3866 : * of simplicity, since this is a debug tool and not meant for use in
3867 : * non-debug builds.
3868 : */
3869 0 : if (!bdev_write_cache(device->bdev))
3870 : return;
3871 : #endif
3872 :
3873 0 : bio_init(bio, device->bdev, NULL, 0,
3874 : REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH);
3875 0 : bio->bi_end_io = btrfs_end_empty_barrier;
3876 0 : init_completion(&device->flush_wait);
3877 0 : bio->bi_private = &device->flush_wait;
3878 :
3879 0 : btrfsic_check_bio(bio);
3880 0 : submit_bio(bio);
3881 0 : set_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3882 : }
3883 :
3884 : /*
3885 : * If the flush bio has been submitted by write_dev_flush, wait for it.
3886 : * Return true for any error, and false otherwise.
3887 : */
3888 0 : static bool wait_dev_flush(struct btrfs_device *device)
3889 : {
3890 0 : struct bio *bio = &device->flush_bio;
3891 :
3892 0 : if (!test_and_clear_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state))
3893 : return false;
3894 :
3895 0 : wait_for_completion_io(&device->flush_wait);
3896 :
3897 0 : if (bio->bi_status) {
3898 0 : device->last_flush_error = bio->bi_status;
3899 0 : btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_FLUSH_ERRS);
3900 0 : return true;
3901 : }
3902 :
3903 : return false;
3904 : }
3905 :
3906 : /*
3907 : * send an empty flush down to each device in parallel,
3908 : * then wait for them
3909 : */
3910 0 : static int barrier_all_devices(struct btrfs_fs_info *info)
3911 : {
3912 0 : struct list_head *head;
3913 0 : struct btrfs_device *dev;
3914 0 : int errors_wait = 0;
3915 :
3916 0 : lockdep_assert_held(&info->fs_devices->device_list_mutex);
3917 : /* send down all the barriers */
3918 0 : head = &info->fs_devices->devices;
3919 0 : list_for_each_entry(dev, head, dev_list) {
3920 0 : if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3921 0 : continue;
3922 0 : if (!dev->bdev)
3923 0 : continue;
3924 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3925 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3926 0 : continue;
3927 :
3928 0 : write_dev_flush(dev);
3929 : }
3930 :
3931 : /* wait for all the barriers */
3932 0 : list_for_each_entry(dev, head, dev_list) {
3933 0 : if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3934 0 : continue;
3935 0 : if (!dev->bdev) {
3936 0 : errors_wait++;
3937 0 : continue;
3938 : }
3939 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3940 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3941 0 : continue;
3942 :
3943 0 : if (wait_dev_flush(dev))
3944 0 : errors_wait++;
3945 : }
3946 :
3947 : /*
3948 : * Checks last_flush_error of disks in order to determine the device
3949 : * state.
3950 : */
3951 0 : if (errors_wait && !btrfs_check_rw_degradable(info, NULL))
3952 0 : return -EIO;
3953 :
3954 : return 0;
3955 : }
3956 :
3957 0 : int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags)
3958 : {
3959 0 : int raid_type;
3960 0 : int min_tolerated = INT_MAX;
3961 :
3962 0 : if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 ||
3963 0 : (flags & BTRFS_AVAIL_ALLOC_BIT_SINGLE))
3964 0 : min_tolerated = min_t(int, min_tolerated,
3965 : btrfs_raid_array[BTRFS_RAID_SINGLE].
3966 : tolerated_failures);
3967 :
3968 0 : for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
3969 0 : if (raid_type == BTRFS_RAID_SINGLE)
3970 0 : continue;
3971 0 : if (!(flags & btrfs_raid_array[raid_type].bg_flag))
3972 0 : continue;
3973 0 : min_tolerated = min_t(int, min_tolerated,
3974 : btrfs_raid_array[raid_type].
3975 : tolerated_failures);
3976 : }
3977 :
3978 0 : if (min_tolerated == INT_MAX) {
3979 0 : pr_warn("BTRFS: unknown raid flag: %llu", flags);
3980 0 : min_tolerated = 0;
3981 : }
3982 :
3983 0 : return min_tolerated;
3984 : }
3985 :
3986 0 : int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)
3987 : {
3988 0 : struct list_head *head;
3989 0 : struct btrfs_device *dev;
3990 0 : struct btrfs_super_block *sb;
3991 0 : struct btrfs_dev_item *dev_item;
3992 0 : int ret;
3993 0 : int do_barriers;
3994 0 : int max_errors;
3995 0 : int total_errors = 0;
3996 0 : u64 flags;
3997 :
3998 0 : do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);
3999 :
4000 : /*
4001 : * max_mirrors == 0 indicates we're from commit_transaction,
4002 : * not from fsync where the tree roots in fs_info have not
4003 : * been consistent on disk.
4004 : */
4005 0 : if (max_mirrors == 0)
4006 0 : backup_super_roots(fs_info);
4007 :
4008 0 : sb = fs_info->super_for_commit;
4009 0 : dev_item = &sb->dev_item;
4010 :
4011 0 : mutex_lock(&fs_info->fs_devices->device_list_mutex);
4012 0 : head = &fs_info->fs_devices->devices;
4013 0 : max_errors = btrfs_super_num_devices(fs_info->super_copy) - 1;
4014 :
4015 0 : if (do_barriers) {
4016 0 : ret = barrier_all_devices(fs_info);
4017 0 : if (ret) {
4018 0 : mutex_unlock(
4019 0 : &fs_info->fs_devices->device_list_mutex);
4020 0 : btrfs_handle_fs_error(fs_info, ret,
4021 : "errors while submitting device barriers.");
4022 0 : return ret;
4023 : }
4024 : }
4025 :
4026 0 : list_for_each_entry(dev, head, dev_list) {
4027 0 : if (!dev->bdev) {
4028 0 : total_errors++;
4029 0 : continue;
4030 : }
4031 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4032 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4033 0 : continue;
4034 :
4035 0 : btrfs_set_stack_device_generation(dev_item, 0);
4036 0 : btrfs_set_stack_device_type(dev_item, dev->type);
4037 0 : btrfs_set_stack_device_id(dev_item, dev->devid);
4038 0 : btrfs_set_stack_device_total_bytes(dev_item,
4039 : dev->commit_total_bytes);
4040 0 : btrfs_set_stack_device_bytes_used(dev_item,
4041 : dev->commit_bytes_used);
4042 0 : btrfs_set_stack_device_io_align(dev_item, dev->io_align);
4043 0 : btrfs_set_stack_device_io_width(dev_item, dev->io_width);
4044 0 : btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
4045 0 : memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
4046 0 : memcpy(dev_item->fsid, dev->fs_devices->metadata_uuid,
4047 : BTRFS_FSID_SIZE);
4048 :
4049 0 : flags = btrfs_super_flags(sb);
4050 0 : btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
4051 :
4052 0 : ret = btrfs_validate_write_super(fs_info, sb);
4053 0 : if (ret < 0) {
4054 0 : mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4055 0 : btrfs_handle_fs_error(fs_info, -EUCLEAN,
4056 : "unexpected superblock corruption detected");
4057 0 : return -EUCLEAN;
4058 : }
4059 :
4060 0 : ret = write_dev_supers(dev, sb, max_mirrors);
4061 0 : if (ret)
4062 0 : total_errors++;
4063 : }
4064 0 : if (total_errors > max_errors) {
4065 0 : btrfs_err(fs_info, "%d errors while writing supers",
4066 : total_errors);
4067 0 : mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4068 :
4069 : /* FUA is masked off if unsupported and can't be the reason */
4070 0 : btrfs_handle_fs_error(fs_info, -EIO,
4071 : "%d errors while writing supers",
4072 : total_errors);
4073 0 : return -EIO;
4074 : }
4075 :
4076 0 : total_errors = 0;
4077 0 : list_for_each_entry(dev, head, dev_list) {
4078 0 : if (!dev->bdev)
4079 0 : continue;
4080 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4081 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4082 0 : continue;
4083 :
4084 0 : ret = wait_dev_supers(dev, max_mirrors);
4085 0 : if (ret)
4086 0 : total_errors++;
4087 : }
4088 0 : mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4089 0 : if (total_errors > max_errors) {
4090 0 : btrfs_handle_fs_error(fs_info, -EIO,
4091 : "%d errors while writing supers",
4092 : total_errors);
4093 0 : return -EIO;
4094 : }
4095 : return 0;
4096 : }
4097 :
4098 : /* Drop a fs root from the radix tree and free it. */
4099 0 : void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
4100 : struct btrfs_root *root)
4101 : {
4102 0 : bool drop_ref = false;
4103 :
4104 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4105 0 : radix_tree_delete(&fs_info->fs_roots_radix,
4106 0 : (unsigned long)root->root_key.objectid);
4107 0 : if (test_and_clear_bit(BTRFS_ROOT_IN_RADIX, &root->state))
4108 0 : drop_ref = true;
4109 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4110 :
4111 0 : if (BTRFS_FS_ERROR(fs_info)) {
4112 0 : ASSERT(root->log_root == NULL);
4113 0 : if (root->reloc_root) {
4114 0 : btrfs_put_root(root->reloc_root);
4115 0 : root->reloc_root = NULL;
4116 : }
4117 : }
4118 :
4119 0 : if (drop_ref)
4120 0 : btrfs_put_root(root);
4121 0 : }
4122 :
4123 0 : int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
4124 : {
4125 0 : u64 root_objectid = 0;
4126 0 : struct btrfs_root *gang[8];
4127 0 : int i = 0;
4128 0 : int err = 0;
4129 0 : unsigned int ret = 0;
4130 :
4131 0 : while (1) {
4132 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4133 0 : ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
4134 : (void **)gang, root_objectid,
4135 : ARRAY_SIZE(gang));
4136 0 : if (!ret) {
4137 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4138 : break;
4139 : }
4140 0 : root_objectid = gang[ret - 1]->root_key.objectid + 1;
4141 :
4142 0 : for (i = 0; i < ret; i++) {
4143 : /* Avoid to grab roots in dead_roots */
4144 0 : if (btrfs_root_refs(&gang[i]->root_item) == 0) {
4145 0 : gang[i] = NULL;
4146 0 : continue;
4147 : }
4148 : /* grab all the search result for later use */
4149 0 : gang[i] = btrfs_grab_root(gang[i]);
4150 : }
4151 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4152 :
4153 0 : for (i = 0; i < ret; i++) {
4154 0 : if (!gang[i])
4155 0 : continue;
4156 0 : root_objectid = gang[i]->root_key.objectid;
4157 0 : err = btrfs_orphan_cleanup(gang[i]);
4158 0 : if (err)
4159 0 : goto out;
4160 0 : btrfs_put_root(gang[i]);
4161 : }
4162 0 : root_objectid++;
4163 : }
4164 0 : out:
4165 : /* release the uncleaned roots due to error */
4166 0 : for (; i < ret; i++) {
4167 0 : if (gang[i])
4168 0 : btrfs_put_root(gang[i]);
4169 : }
4170 0 : return err;
4171 : }
4172 :
4173 0 : int btrfs_commit_super(struct btrfs_fs_info *fs_info)
4174 : {
4175 0 : struct btrfs_root *root = fs_info->tree_root;
4176 0 : struct btrfs_trans_handle *trans;
4177 :
4178 0 : mutex_lock(&fs_info->cleaner_mutex);
4179 0 : btrfs_run_delayed_iputs(fs_info);
4180 0 : mutex_unlock(&fs_info->cleaner_mutex);
4181 0 : wake_up_process(fs_info->cleaner_kthread);
4182 :
4183 : /* wait until ongoing cleanup work done */
4184 0 : down_write(&fs_info->cleanup_work_sem);
4185 0 : up_write(&fs_info->cleanup_work_sem);
4186 :
4187 0 : trans = btrfs_join_transaction(root);
4188 0 : if (IS_ERR(trans))
4189 0 : return PTR_ERR(trans);
4190 0 : return btrfs_commit_transaction(trans);
4191 : }
4192 :
4193 0 : static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)
4194 : {
4195 0 : struct btrfs_transaction *trans;
4196 0 : struct btrfs_transaction *tmp;
4197 0 : bool found = false;
4198 :
4199 0 : if (list_empty(&fs_info->trans_list))
4200 : return;
4201 :
4202 : /*
4203 : * This function is only called at the very end of close_ctree(),
4204 : * thus no other running transaction, no need to take trans_lock.
4205 : */
4206 0 : ASSERT(test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags));
4207 0 : list_for_each_entry_safe(trans, tmp, &fs_info->trans_list, list) {
4208 0 : struct extent_state *cached = NULL;
4209 0 : u64 dirty_bytes = 0;
4210 0 : u64 cur = 0;
4211 0 : u64 found_start;
4212 0 : u64 found_end;
4213 :
4214 0 : found = true;
4215 0 : while (!find_first_extent_bit(&trans->dirty_pages, cur,
4216 : &found_start, &found_end, EXTENT_DIRTY, &cached)) {
4217 0 : dirty_bytes += found_end + 1 - found_start;
4218 0 : cur = found_end + 1;
4219 : }
4220 0 : btrfs_warn(fs_info,
4221 : "transaction %llu (with %llu dirty metadata bytes) is not committed",
4222 : trans->transid, dirty_bytes);
4223 0 : btrfs_cleanup_one_transaction(trans, fs_info);
4224 :
4225 0 : if (trans == fs_info->running_transaction)
4226 0 : fs_info->running_transaction = NULL;
4227 0 : list_del_init(&trans->list);
4228 :
4229 0 : btrfs_put_transaction(trans);
4230 0 : trace_btrfs_transaction_commit(fs_info);
4231 : }
4232 0 : ASSERT(!found);
4233 : }
4234 :
4235 0 : void __cold close_ctree(struct btrfs_fs_info *fs_info)
4236 : {
4237 0 : int ret;
4238 :
4239 0 : set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
4240 :
4241 : /*
4242 : * If we had UNFINISHED_DROPS we could still be processing them, so
4243 : * clear that bit and wake up relocation so it can stop.
4244 : * We must do this before stopping the block group reclaim task, because
4245 : * at btrfs_relocate_block_group() we wait for this bit, and after the
4246 : * wait we stop with -EINTR if btrfs_fs_closing() returns non-zero - we
4247 : * have just set BTRFS_FS_CLOSING_START, so btrfs_fs_closing() will
4248 : * return 1.
4249 : */
4250 0 : btrfs_wake_unfinished_drop(fs_info);
4251 :
4252 : /*
4253 : * We may have the reclaim task running and relocating a data block group,
4254 : * in which case it may create delayed iputs. So stop it before we park
4255 : * the cleaner kthread otherwise we can get new delayed iputs after
4256 : * parking the cleaner, and that can make the async reclaim task to hang
4257 : * if it's waiting for delayed iputs to complete, since the cleaner is
4258 : * parked and can not run delayed iputs - this will make us hang when
4259 : * trying to stop the async reclaim task.
4260 : */
4261 0 : cancel_work_sync(&fs_info->reclaim_bgs_work);
4262 : /*
4263 : * We don't want the cleaner to start new transactions, add more delayed
4264 : * iputs, etc. while we're closing. We can't use kthread_stop() yet
4265 : * because that frees the task_struct, and the transaction kthread might
4266 : * still try to wake up the cleaner.
4267 : */
4268 0 : kthread_park(fs_info->cleaner_kthread);
4269 :
4270 : /* wait for the qgroup rescan worker to stop */
4271 0 : btrfs_qgroup_wait_for_completion(fs_info, false);
4272 :
4273 : /* wait for the uuid_scan task to finish */
4274 0 : down(&fs_info->uuid_tree_rescan_sem);
4275 : /* avoid complains from lockdep et al., set sem back to initial state */
4276 0 : up(&fs_info->uuid_tree_rescan_sem);
4277 :
4278 : /* pause restriper - we want to resume on mount */
4279 0 : btrfs_pause_balance(fs_info);
4280 :
4281 0 : btrfs_dev_replace_suspend_for_unmount(fs_info);
4282 :
4283 0 : btrfs_scrub_cancel(fs_info);
4284 :
4285 : /* wait for any defraggers to finish */
4286 0 : wait_event(fs_info->transaction_wait,
4287 : (atomic_read(&fs_info->defrag_running) == 0));
4288 :
4289 : /* clear out the rbtree of defraggable inodes */
4290 0 : btrfs_cleanup_defrag_inodes(fs_info);
4291 :
4292 : /*
4293 : * After we parked the cleaner kthread, ordered extents may have
4294 : * completed and created new delayed iputs. If one of the async reclaim
4295 : * tasks is running and in the RUN_DELAYED_IPUTS flush state, then we
4296 : * can hang forever trying to stop it, because if a delayed iput is
4297 : * added after it ran btrfs_run_delayed_iputs() and before it called
4298 : * btrfs_wait_on_delayed_iputs(), it will hang forever since there is
4299 : * no one else to run iputs.
4300 : *
4301 : * So wait for all ongoing ordered extents to complete and then run
4302 : * delayed iputs. This works because once we reach this point no one
4303 : * can either create new ordered extents nor create delayed iputs
4304 : * through some other means.
4305 : *
4306 : * Also note that btrfs_wait_ordered_roots() is not safe here, because
4307 : * it waits for BTRFS_ORDERED_COMPLETE to be set on an ordered extent,
4308 : * but the delayed iput for the respective inode is made only when doing
4309 : * the final btrfs_put_ordered_extent() (which must happen at
4310 : * btrfs_finish_ordered_io() when we are unmounting).
4311 : */
4312 0 : btrfs_flush_workqueue(fs_info->endio_write_workers);
4313 : /* Ordered extents for free space inodes. */
4314 0 : btrfs_flush_workqueue(fs_info->endio_freespace_worker);
4315 0 : btrfs_run_delayed_iputs(fs_info);
4316 :
4317 0 : cancel_work_sync(&fs_info->async_reclaim_work);
4318 0 : cancel_work_sync(&fs_info->async_data_reclaim_work);
4319 0 : cancel_work_sync(&fs_info->preempt_reclaim_work);
4320 :
4321 : /* Cancel or finish ongoing discard work */
4322 0 : btrfs_discard_cleanup(fs_info);
4323 :
4324 0 : if (!sb_rdonly(fs_info->sb)) {
4325 : /*
4326 : * The cleaner kthread is stopped, so do one final pass over
4327 : * unused block groups.
4328 : */
4329 0 : btrfs_delete_unused_bgs(fs_info);
4330 :
4331 : /*
4332 : * There might be existing delayed inode workers still running
4333 : * and holding an empty delayed inode item. We must wait for
4334 : * them to complete first because they can create a transaction.
4335 : * This happens when someone calls btrfs_balance_delayed_items()
4336 : * and then a transaction commit runs the same delayed nodes
4337 : * before any delayed worker has done something with the nodes.
4338 : * We must wait for any worker here and not at transaction
4339 : * commit time since that could cause a deadlock.
4340 : * This is a very rare case.
4341 : */
4342 0 : btrfs_flush_workqueue(fs_info->delayed_workers);
4343 :
4344 0 : ret = btrfs_commit_super(fs_info);
4345 0 : if (ret)
4346 0 : btrfs_err(fs_info, "commit super ret %d", ret);
4347 : }
4348 :
4349 0 : if (BTRFS_FS_ERROR(fs_info))
4350 0 : btrfs_error_commit_super(fs_info);
4351 :
4352 0 : kthread_stop(fs_info->transaction_kthread);
4353 0 : kthread_stop(fs_info->cleaner_kthread);
4354 :
4355 0 : ASSERT(list_empty(&fs_info->delayed_iputs));
4356 0 : set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
4357 :
4358 0 : if (btrfs_check_quota_leak(fs_info)) {
4359 0 : WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
4360 0 : btrfs_err(fs_info, "qgroup reserved space leaked");
4361 : }
4362 :
4363 0 : btrfs_free_qgroup_config(fs_info);
4364 0 : ASSERT(list_empty(&fs_info->delalloc_roots));
4365 :
4366 0 : if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
4367 0 : btrfs_info(fs_info, "at unmount delalloc count %lld",
4368 : percpu_counter_sum(&fs_info->delalloc_bytes));
4369 : }
4370 :
4371 0 : if (percpu_counter_sum(&fs_info->ordered_bytes))
4372 0 : btrfs_info(fs_info, "at unmount dio bytes count %lld",
4373 : percpu_counter_sum(&fs_info->ordered_bytes));
4374 :
4375 0 : btrfs_sysfs_remove_mounted(fs_info);
4376 0 : btrfs_sysfs_remove_fsid(fs_info->fs_devices);
4377 :
4378 0 : btrfs_put_block_group_cache(fs_info);
4379 :
4380 : /*
4381 : * we must make sure there is not any read request to
4382 : * submit after we stopping all workers.
4383 : */
4384 0 : invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
4385 0 : btrfs_stop_all_workers(fs_info);
4386 :
4387 : /* We shouldn't have any transaction open at this point */
4388 0 : warn_about_uncommitted_trans(fs_info);
4389 :
4390 0 : clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
4391 0 : free_root_pointers(fs_info, true);
4392 0 : btrfs_free_fs_roots(fs_info);
4393 :
4394 : /*
4395 : * We must free the block groups after dropping the fs_roots as we could
4396 : * have had an IO error and have left over tree log blocks that aren't
4397 : * cleaned up until the fs roots are freed. This makes the block group
4398 : * accounting appear to be wrong because there's pending reserved bytes,
4399 : * so make sure we do the block group cleanup afterwards.
4400 : */
4401 0 : btrfs_free_block_groups(fs_info);
4402 :
4403 0 : iput(fs_info->btree_inode);
4404 :
4405 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4406 : if (btrfs_test_opt(fs_info, CHECK_INTEGRITY))
4407 : btrfsic_unmount(fs_info->fs_devices);
4408 : #endif
4409 :
4410 0 : btrfs_mapping_tree_free(&fs_info->mapping_tree);
4411 0 : btrfs_close_devices(fs_info->fs_devices);
4412 0 : }
4413 :
4414 0 : void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
4415 : {
4416 0 : struct btrfs_fs_info *fs_info = buf->fs_info;
4417 0 : u64 transid = btrfs_header_generation(buf);
4418 :
4419 : #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
4420 : /*
4421 : * This is a fast path so only do this check if we have sanity tests
4422 : * enabled. Normal people shouldn't be using unmapped buffers as dirty
4423 : * outside of the sanity tests.
4424 : */
4425 : if (unlikely(test_bit(EXTENT_BUFFER_UNMAPPED, &buf->bflags)))
4426 : return;
4427 : #endif
4428 0 : btrfs_assert_tree_write_locked(buf);
4429 0 : if (transid != fs_info->generation)
4430 0 : WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, found %llu running %llu\n",
4431 : buf->start, transid, fs_info->generation);
4432 0 : set_extent_buffer_dirty(buf);
4433 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4434 : /*
4435 : * btrfs_check_leaf() won't check item data if we don't have WRITTEN
4436 : * set, so this will only validate the basic structure of the items.
4437 : */
4438 : if (btrfs_header_level(buf) == 0 && btrfs_check_leaf(buf)) {
4439 : btrfs_print_leaf(buf);
4440 : ASSERT(0);
4441 : }
4442 : #endif
4443 0 : }
4444 :
4445 0 : static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,
4446 : int flush_delayed)
4447 : {
4448 : /*
4449 : * looks as though older kernels can get into trouble with
4450 : * this code, they end up stuck in balance_dirty_pages forever
4451 : */
4452 0 : int ret;
4453 :
4454 0 : if (current->flags & PF_MEMALLOC)
4455 : return;
4456 :
4457 0 : if (flush_delayed)
4458 0 : btrfs_balance_delayed_items(fs_info);
4459 :
4460 0 : ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
4461 : BTRFS_DIRTY_METADATA_THRESH,
4462 : fs_info->dirty_metadata_batch);
4463 0 : if (ret > 0) {
4464 0 : balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);
4465 : }
4466 : }
4467 :
4468 0 : void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)
4469 : {
4470 0 : __btrfs_btree_balance_dirty(fs_info, 1);
4471 0 : }
4472 :
4473 0 : void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
4474 : {
4475 0 : __btrfs_btree_balance_dirty(fs_info, 0);
4476 0 : }
4477 :
4478 0 : static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)
4479 : {
4480 : /* cleanup FS via transaction */
4481 0 : btrfs_cleanup_transaction(fs_info);
4482 :
4483 0 : mutex_lock(&fs_info->cleaner_mutex);
4484 0 : btrfs_run_delayed_iputs(fs_info);
4485 0 : mutex_unlock(&fs_info->cleaner_mutex);
4486 :
4487 0 : down_write(&fs_info->cleanup_work_sem);
4488 0 : up_write(&fs_info->cleanup_work_sem);
4489 0 : }
4490 :
4491 0 : static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)
4492 : {
4493 0 : struct btrfs_root *gang[8];
4494 0 : u64 root_objectid = 0;
4495 0 : int ret;
4496 :
4497 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4498 0 : while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
4499 : (void **)gang, root_objectid,
4500 0 : ARRAY_SIZE(gang))) != 0) {
4501 : int i;
4502 :
4503 0 : for (i = 0; i < ret; i++)
4504 0 : gang[i] = btrfs_grab_root(gang[i]);
4505 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4506 :
4507 0 : for (i = 0; i < ret; i++) {
4508 0 : if (!gang[i])
4509 0 : continue;
4510 0 : root_objectid = gang[i]->root_key.objectid;
4511 0 : btrfs_free_log(NULL, gang[i]);
4512 0 : btrfs_put_root(gang[i]);
4513 : }
4514 0 : root_objectid++;
4515 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4516 : }
4517 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4518 0 : btrfs_free_log_root_tree(NULL, fs_info);
4519 0 : }
4520 :
4521 0 : static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4522 : {
4523 0 : struct btrfs_ordered_extent *ordered;
4524 :
4525 0 : spin_lock(&root->ordered_extent_lock);
4526 : /*
4527 : * This will just short circuit the ordered completion stuff which will
4528 : * make sure the ordered extent gets properly cleaned up.
4529 : */
4530 0 : list_for_each_entry(ordered, &root->ordered_extents,
4531 : root_extent_list)
4532 0 : set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
4533 0 : spin_unlock(&root->ordered_extent_lock);
4534 0 : }
4535 :
4536 0 : static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
4537 : {
4538 0 : struct btrfs_root *root;
4539 0 : struct list_head splice;
4540 :
4541 0 : INIT_LIST_HEAD(&splice);
4542 :
4543 0 : spin_lock(&fs_info->ordered_root_lock);
4544 0 : list_splice_init(&fs_info->ordered_roots, &splice);
4545 0 : while (!list_empty(&splice)) {
4546 0 : root = list_first_entry(&splice, struct btrfs_root,
4547 : ordered_root);
4548 0 : list_move_tail(&root->ordered_root,
4549 : &fs_info->ordered_roots);
4550 :
4551 0 : spin_unlock(&fs_info->ordered_root_lock);
4552 0 : btrfs_destroy_ordered_extents(root);
4553 :
4554 0 : cond_resched();
4555 0 : spin_lock(&fs_info->ordered_root_lock);
4556 : }
4557 0 : spin_unlock(&fs_info->ordered_root_lock);
4558 :
4559 : /*
4560 : * We need this here because if we've been flipped read-only we won't
4561 : * get sync() from the umount, so we need to make sure any ordered
4562 : * extents that haven't had their dirty pages IO start writeout yet
4563 : * actually get run and error out properly.
4564 : */
4565 0 : btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
4566 0 : }
4567 :
4568 0 : static void btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
4569 : struct btrfs_fs_info *fs_info)
4570 : {
4571 0 : struct rb_node *node;
4572 0 : struct btrfs_delayed_ref_root *delayed_refs;
4573 0 : struct btrfs_delayed_ref_node *ref;
4574 :
4575 0 : delayed_refs = &trans->delayed_refs;
4576 :
4577 0 : spin_lock(&delayed_refs->lock);
4578 0 : if (atomic_read(&delayed_refs->num_entries) == 0) {
4579 0 : spin_unlock(&delayed_refs->lock);
4580 0 : btrfs_debug(fs_info, "delayed_refs has NO entry");
4581 0 : return;
4582 : }
4583 :
4584 0 : while ((node = rb_first_cached(&delayed_refs->href_root)) != NULL) {
4585 0 : struct btrfs_delayed_ref_head *head;
4586 0 : struct rb_node *n;
4587 0 : bool pin_bytes = false;
4588 :
4589 0 : head = rb_entry(node, struct btrfs_delayed_ref_head,
4590 : href_node);
4591 0 : if (btrfs_delayed_ref_lock(delayed_refs, head))
4592 0 : continue;
4593 :
4594 0 : spin_lock(&head->lock);
4595 0 : while ((n = rb_first_cached(&head->ref_tree)) != NULL) {
4596 0 : ref = rb_entry(n, struct btrfs_delayed_ref_node,
4597 : ref_node);
4598 0 : rb_erase_cached(&ref->ref_node, &head->ref_tree);
4599 0 : RB_CLEAR_NODE(&ref->ref_node);
4600 0 : if (!list_empty(&ref->add_list))
4601 0 : list_del(&ref->add_list);
4602 0 : atomic_dec(&delayed_refs->num_entries);
4603 0 : btrfs_put_delayed_ref(ref);
4604 : }
4605 0 : if (head->must_insert_reserved)
4606 0 : pin_bytes = true;
4607 0 : btrfs_free_delayed_extent_op(head->extent_op);
4608 0 : btrfs_delete_ref_head(delayed_refs, head);
4609 0 : spin_unlock(&head->lock);
4610 0 : spin_unlock(&delayed_refs->lock);
4611 0 : mutex_unlock(&head->mutex);
4612 :
4613 0 : if (pin_bytes) {
4614 0 : struct btrfs_block_group *cache;
4615 :
4616 0 : cache = btrfs_lookup_block_group(fs_info, head->bytenr);
4617 0 : BUG_ON(!cache);
4618 :
4619 0 : spin_lock(&cache->space_info->lock);
4620 0 : spin_lock(&cache->lock);
4621 0 : cache->pinned += head->num_bytes;
4622 0 : btrfs_space_info_update_bytes_pinned(fs_info,
4623 0 : cache->space_info, head->num_bytes);
4624 0 : cache->reserved -= head->num_bytes;
4625 0 : cache->space_info->bytes_reserved -= head->num_bytes;
4626 0 : spin_unlock(&cache->lock);
4627 0 : spin_unlock(&cache->space_info->lock);
4628 :
4629 0 : btrfs_put_block_group(cache);
4630 :
4631 0 : btrfs_error_unpin_extent_range(fs_info, head->bytenr,
4632 0 : head->bytenr + head->num_bytes - 1);
4633 : }
4634 0 : btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);
4635 0 : btrfs_put_delayed_ref_head(head);
4636 0 : cond_resched();
4637 0 : spin_lock(&delayed_refs->lock);
4638 : }
4639 0 : btrfs_qgroup_destroy_extent_records(trans);
4640 :
4641 0 : spin_unlock(&delayed_refs->lock);
4642 : }
4643 :
4644 0 : static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
4645 : {
4646 0 : struct btrfs_inode *btrfs_inode;
4647 0 : struct list_head splice;
4648 :
4649 0 : INIT_LIST_HEAD(&splice);
4650 :
4651 0 : spin_lock(&root->delalloc_lock);
4652 0 : list_splice_init(&root->delalloc_inodes, &splice);
4653 :
4654 0 : while (!list_empty(&splice)) {
4655 0 : struct inode *inode = NULL;
4656 0 : btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
4657 : delalloc_inodes);
4658 0 : __btrfs_del_delalloc_inode(root, btrfs_inode);
4659 0 : spin_unlock(&root->delalloc_lock);
4660 :
4661 : /*
4662 : * Make sure we get a live inode and that it'll not disappear
4663 : * meanwhile.
4664 : */
4665 0 : inode = igrab(&btrfs_inode->vfs_inode);
4666 0 : if (inode) {
4667 0 : unsigned int nofs_flag;
4668 :
4669 0 : nofs_flag = memalloc_nofs_save();
4670 0 : invalidate_inode_pages2(inode->i_mapping);
4671 0 : memalloc_nofs_restore(nofs_flag);
4672 0 : iput(inode);
4673 : }
4674 0 : spin_lock(&root->delalloc_lock);
4675 : }
4676 0 : spin_unlock(&root->delalloc_lock);
4677 0 : }
4678 :
4679 0 : static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
4680 : {
4681 0 : struct btrfs_root *root;
4682 0 : struct list_head splice;
4683 :
4684 0 : INIT_LIST_HEAD(&splice);
4685 :
4686 0 : spin_lock(&fs_info->delalloc_root_lock);
4687 0 : list_splice_init(&fs_info->delalloc_roots, &splice);
4688 0 : while (!list_empty(&splice)) {
4689 0 : root = list_first_entry(&splice, struct btrfs_root,
4690 : delalloc_root);
4691 0 : root = btrfs_grab_root(root);
4692 0 : BUG_ON(!root);
4693 0 : spin_unlock(&fs_info->delalloc_root_lock);
4694 :
4695 0 : btrfs_destroy_delalloc_inodes(root);
4696 0 : btrfs_put_root(root);
4697 :
4698 0 : spin_lock(&fs_info->delalloc_root_lock);
4699 : }
4700 0 : spin_unlock(&fs_info->delalloc_root_lock);
4701 0 : }
4702 :
4703 0 : static int btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
4704 : struct extent_io_tree *dirty_pages,
4705 : int mark)
4706 : {
4707 0 : int ret;
4708 0 : struct extent_buffer *eb;
4709 0 : u64 start = 0;
4710 0 : u64 end;
4711 :
4712 0 : while (1) {
4713 0 : ret = find_first_extent_bit(dirty_pages, start, &start, &end,
4714 : mark, NULL);
4715 0 : if (ret)
4716 : break;
4717 :
4718 0 : clear_extent_bits(dirty_pages, start, end, mark);
4719 0 : while (start <= end) {
4720 0 : eb = find_extent_buffer(fs_info, start);
4721 0 : start += fs_info->nodesize;
4722 0 : if (!eb)
4723 0 : continue;
4724 :
4725 0 : btrfs_tree_lock(eb);
4726 0 : wait_on_extent_buffer_writeback(eb);
4727 0 : btrfs_clear_buffer_dirty(NULL, eb);
4728 0 : btrfs_tree_unlock(eb);
4729 :
4730 0 : free_extent_buffer_stale(eb);
4731 : }
4732 : }
4733 :
4734 0 : return ret;
4735 : }
4736 :
4737 0 : static int btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
4738 : struct extent_io_tree *unpin)
4739 : {
4740 0 : u64 start;
4741 0 : u64 end;
4742 0 : int ret;
4743 :
4744 0 : while (1) {
4745 0 : struct extent_state *cached_state = NULL;
4746 :
4747 : /*
4748 : * The btrfs_finish_extent_commit() may get the same range as
4749 : * ours between find_first_extent_bit and clear_extent_dirty.
4750 : * Hence, hold the unused_bg_unpin_mutex to avoid double unpin
4751 : * the same extent range.
4752 : */
4753 0 : mutex_lock(&fs_info->unused_bg_unpin_mutex);
4754 0 : ret = find_first_extent_bit(unpin, 0, &start, &end,
4755 : EXTENT_DIRTY, &cached_state);
4756 0 : if (ret) {
4757 0 : mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4758 0 : break;
4759 : }
4760 :
4761 0 : clear_extent_dirty(unpin, start, end, &cached_state);
4762 0 : free_extent_state(cached_state);
4763 0 : btrfs_error_unpin_extent_range(fs_info, start, end);
4764 0 : mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4765 0 : cond_resched();
4766 : }
4767 :
4768 0 : return 0;
4769 : }
4770 :
4771 0 : static void btrfs_cleanup_bg_io(struct btrfs_block_group *cache)
4772 : {
4773 0 : struct inode *inode;
4774 :
4775 0 : inode = cache->io_ctl.inode;
4776 0 : if (inode) {
4777 0 : unsigned int nofs_flag;
4778 :
4779 0 : nofs_flag = memalloc_nofs_save();
4780 0 : invalidate_inode_pages2(inode->i_mapping);
4781 0 : memalloc_nofs_restore(nofs_flag);
4782 :
4783 0 : BTRFS_I(inode)->generation = 0;
4784 0 : cache->io_ctl.inode = NULL;
4785 0 : iput(inode);
4786 : }
4787 0 : ASSERT(cache->io_ctl.pages == NULL);
4788 0 : btrfs_put_block_group(cache);
4789 0 : }
4790 :
4791 0 : void btrfs_cleanup_dirty_bgs(struct btrfs_transaction *cur_trans,
4792 : struct btrfs_fs_info *fs_info)
4793 : {
4794 0 : struct btrfs_block_group *cache;
4795 :
4796 0 : spin_lock(&cur_trans->dirty_bgs_lock);
4797 0 : while (!list_empty(&cur_trans->dirty_bgs)) {
4798 0 : cache = list_first_entry(&cur_trans->dirty_bgs,
4799 : struct btrfs_block_group,
4800 : dirty_list);
4801 :
4802 0 : if (!list_empty(&cache->io_list)) {
4803 0 : spin_unlock(&cur_trans->dirty_bgs_lock);
4804 0 : list_del_init(&cache->io_list);
4805 0 : btrfs_cleanup_bg_io(cache);
4806 0 : spin_lock(&cur_trans->dirty_bgs_lock);
4807 : }
4808 :
4809 0 : list_del_init(&cache->dirty_list);
4810 0 : spin_lock(&cache->lock);
4811 0 : cache->disk_cache_state = BTRFS_DC_ERROR;
4812 0 : spin_unlock(&cache->lock);
4813 :
4814 0 : spin_unlock(&cur_trans->dirty_bgs_lock);
4815 0 : btrfs_put_block_group(cache);
4816 0 : btrfs_delayed_refs_rsv_release(fs_info, 1);
4817 0 : spin_lock(&cur_trans->dirty_bgs_lock);
4818 : }
4819 0 : spin_unlock(&cur_trans->dirty_bgs_lock);
4820 :
4821 : /*
4822 : * Refer to the definition of io_bgs member for details why it's safe
4823 : * to use it without any locking
4824 : */
4825 0 : while (!list_empty(&cur_trans->io_bgs)) {
4826 0 : cache = list_first_entry(&cur_trans->io_bgs,
4827 : struct btrfs_block_group,
4828 : io_list);
4829 :
4830 0 : list_del_init(&cache->io_list);
4831 0 : spin_lock(&cache->lock);
4832 0 : cache->disk_cache_state = BTRFS_DC_ERROR;
4833 0 : spin_unlock(&cache->lock);
4834 0 : btrfs_cleanup_bg_io(cache);
4835 : }
4836 0 : }
4837 :
4838 0 : void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4839 : struct btrfs_fs_info *fs_info)
4840 : {
4841 0 : struct btrfs_device *dev, *tmp;
4842 :
4843 0 : btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
4844 0 : ASSERT(list_empty(&cur_trans->dirty_bgs));
4845 0 : ASSERT(list_empty(&cur_trans->io_bgs));
4846 :
4847 0 : list_for_each_entry_safe(dev, tmp, &cur_trans->dev_update_list,
4848 : post_commit_list) {
4849 0 : list_del_init(&dev->post_commit_list);
4850 : }
4851 :
4852 0 : btrfs_destroy_delayed_refs(cur_trans, fs_info);
4853 :
4854 0 : cur_trans->state = TRANS_STATE_COMMIT_START;
4855 0 : wake_up(&fs_info->transaction_blocked_wait);
4856 :
4857 0 : cur_trans->state = TRANS_STATE_UNBLOCKED;
4858 0 : wake_up(&fs_info->transaction_wait);
4859 :
4860 0 : btrfs_destroy_delayed_inodes(fs_info);
4861 :
4862 0 : btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,
4863 : EXTENT_DIRTY);
4864 0 : btrfs_destroy_pinned_extent(fs_info, &cur_trans->pinned_extents);
4865 :
4866 0 : cur_trans->state =TRANS_STATE_COMPLETED;
4867 0 : wake_up(&cur_trans->commit_wait);
4868 0 : }
4869 :
4870 0 : static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
4871 : {
4872 0 : struct btrfs_transaction *t;
4873 :
4874 0 : mutex_lock(&fs_info->transaction_kthread_mutex);
4875 :
4876 0 : spin_lock(&fs_info->trans_lock);
4877 0 : while (!list_empty(&fs_info->trans_list)) {
4878 0 : t = list_first_entry(&fs_info->trans_list,
4879 : struct btrfs_transaction, list);
4880 0 : if (t->state >= TRANS_STATE_COMMIT_START) {
4881 0 : refcount_inc(&t->use_count);
4882 0 : spin_unlock(&fs_info->trans_lock);
4883 0 : btrfs_wait_for_commit(fs_info, t->transid);
4884 0 : btrfs_put_transaction(t);
4885 0 : spin_lock(&fs_info->trans_lock);
4886 0 : continue;
4887 : }
4888 0 : if (t == fs_info->running_transaction) {
4889 0 : t->state = TRANS_STATE_COMMIT_DOING;
4890 0 : spin_unlock(&fs_info->trans_lock);
4891 : /*
4892 : * We wait for 0 num_writers since we don't hold a trans
4893 : * handle open currently for this transaction.
4894 : */
4895 0 : wait_event(t->writer_wait,
4896 : atomic_read(&t->num_writers) == 0);
4897 : } else {
4898 0 : spin_unlock(&fs_info->trans_lock);
4899 : }
4900 0 : btrfs_cleanup_one_transaction(t, fs_info);
4901 :
4902 0 : spin_lock(&fs_info->trans_lock);
4903 0 : if (t == fs_info->running_transaction)
4904 0 : fs_info->running_transaction = NULL;
4905 0 : list_del_init(&t->list);
4906 0 : spin_unlock(&fs_info->trans_lock);
4907 :
4908 0 : btrfs_put_transaction(t);
4909 0 : trace_btrfs_transaction_commit(fs_info);
4910 0 : spin_lock(&fs_info->trans_lock);
4911 : }
4912 0 : spin_unlock(&fs_info->trans_lock);
4913 0 : btrfs_destroy_all_ordered_extents(fs_info);
4914 0 : btrfs_destroy_delayed_inodes(fs_info);
4915 0 : btrfs_assert_delayed_root_empty(fs_info);
4916 0 : btrfs_destroy_all_delalloc_inodes(fs_info);
4917 0 : btrfs_drop_all_logs(fs_info);
4918 0 : mutex_unlock(&fs_info->transaction_kthread_mutex);
4919 :
4920 0 : return 0;
4921 : }
4922 :
4923 0 : int btrfs_init_root_free_objectid(struct btrfs_root *root)
4924 : {
4925 0 : struct btrfs_path *path;
4926 0 : int ret;
4927 0 : struct extent_buffer *l;
4928 0 : struct btrfs_key search_key;
4929 0 : struct btrfs_key found_key;
4930 0 : int slot;
4931 :
4932 0 : path = btrfs_alloc_path();
4933 0 : if (!path)
4934 : return -ENOMEM;
4935 :
4936 0 : search_key.objectid = BTRFS_LAST_FREE_OBJECTID;
4937 0 : search_key.type = -1;
4938 0 : search_key.offset = (u64)-1;
4939 0 : ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
4940 0 : if (ret < 0)
4941 0 : goto error;
4942 0 : BUG_ON(ret == 0); /* Corruption */
4943 0 : if (path->slots[0] > 0) {
4944 0 : slot = path->slots[0] - 1;
4945 0 : l = path->nodes[0];
4946 0 : btrfs_item_key_to_cpu(l, &found_key, slot);
4947 0 : root->free_objectid = max_t(u64, found_key.objectid + 1,
4948 : BTRFS_FIRST_FREE_OBJECTID);
4949 : } else {
4950 0 : root->free_objectid = BTRFS_FIRST_FREE_OBJECTID;
4951 : }
4952 : ret = 0;
4953 0 : error:
4954 0 : btrfs_free_path(path);
4955 0 : return ret;
4956 : }
4957 :
4958 0 : int btrfs_get_free_objectid(struct btrfs_root *root, u64 *objectid)
4959 : {
4960 0 : int ret;
4961 0 : mutex_lock(&root->objectid_mutex);
4962 :
4963 0 : if (unlikely(root->free_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
4964 0 : btrfs_warn(root->fs_info,
4965 : "the objectid of root %llu reaches its highest value",
4966 : root->root_key.objectid);
4967 0 : ret = -ENOSPC;
4968 0 : goto out;
4969 : }
4970 :
4971 0 : *objectid = root->free_objectid++;
4972 0 : ret = 0;
4973 0 : out:
4974 0 : mutex_unlock(&root->objectid_mutex);
4975 0 : return ret;
4976 : }
|
