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 : * The zoned mode piggy backs on the discard functionality for
3443 : * resetting a zone. There is no reason to delay the zone reset as it is
3444 : * fast enough. So, do not enable async discard for zoned mode.
3445 : */
3446 0 : if (!(btrfs_test_opt(fs_info, DISCARD_SYNC) ||
3447 : btrfs_test_opt(fs_info, DISCARD_ASYNC) ||
3448 0 : btrfs_test_opt(fs_info, NODISCARD)) &&
3449 0 : fs_info->fs_devices->discardable &&
3450 : !btrfs_is_zoned(fs_info)) {
3451 0 : btrfs_set_and_info(fs_info, DISCARD_ASYNC,
3452 : "auto enabling async discard");
3453 : }
3454 :
3455 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3456 : if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
3457 : ret = btrfsic_mount(fs_info, fs_devices,
3458 : btrfs_test_opt(fs_info,
3459 : CHECK_INTEGRITY_DATA) ? 1 : 0,
3460 : fs_info->check_integrity_print_mask);
3461 : if (ret)
3462 : btrfs_warn(fs_info,
3463 : "failed to initialize integrity check module: %d",
3464 : ret);
3465 : }
3466 : #endif
3467 0 : ret = btrfs_read_qgroup_config(fs_info);
3468 0 : if (ret)
3469 0 : goto fail_trans_kthread;
3470 :
3471 0 : if (btrfs_build_ref_tree(fs_info))
3472 : btrfs_err(fs_info, "couldn't build ref tree");
3473 :
3474 : /* do not make disk changes in broken FS or nologreplay is given */
3475 0 : if (btrfs_super_log_root(disk_super) != 0 &&
3476 0 : !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3477 0 : btrfs_info(fs_info, "start tree-log replay");
3478 0 : ret = btrfs_replay_log(fs_info, fs_devices);
3479 0 : if (ret)
3480 0 : goto fail_qgroup;
3481 : }
3482 :
3483 0 : fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);
3484 0 : if (IS_ERR(fs_info->fs_root)) {
3485 0 : ret = PTR_ERR(fs_info->fs_root);
3486 0 : btrfs_warn(fs_info, "failed to read fs tree: %d", ret);
3487 0 : fs_info->fs_root = NULL;
3488 0 : goto fail_qgroup;
3489 : }
3490 :
3491 0 : if (sb_rdonly(sb))
3492 0 : goto clear_oneshot;
3493 :
3494 0 : ret = btrfs_start_pre_rw_mount(fs_info);
3495 0 : if (ret) {
3496 0 : close_ctree(fs_info);
3497 0 : return ret;
3498 : }
3499 0 : btrfs_discard_resume(fs_info);
3500 :
3501 0 : if (fs_info->uuid_root &&
3502 0 : (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
3503 0 : fs_info->generation != btrfs_super_uuid_tree_generation(disk_super))) {
3504 0 : btrfs_info(fs_info, "checking UUID tree");
3505 0 : ret = btrfs_check_uuid_tree(fs_info);
3506 0 : if (ret) {
3507 0 : btrfs_warn(fs_info,
3508 : "failed to check the UUID tree: %d", ret);
3509 0 : close_ctree(fs_info);
3510 0 : return ret;
3511 : }
3512 : }
3513 :
3514 0 : set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3515 :
3516 : /* Kick the cleaner thread so it'll start deleting snapshots. */
3517 0 : if (test_bit(BTRFS_FS_UNFINISHED_DROPS, &fs_info->flags))
3518 0 : wake_up_process(fs_info->cleaner_kthread);
3519 :
3520 0 : clear_oneshot:
3521 0 : btrfs_clear_oneshot_options(fs_info);
3522 0 : return 0;
3523 :
3524 0 : fail_qgroup:
3525 0 : btrfs_free_qgroup_config(fs_info);
3526 0 : fail_trans_kthread:
3527 0 : kthread_stop(fs_info->transaction_kthread);
3528 0 : btrfs_cleanup_transaction(fs_info);
3529 0 : btrfs_free_fs_roots(fs_info);
3530 0 : fail_cleaner:
3531 0 : kthread_stop(fs_info->cleaner_kthread);
3532 :
3533 : /*
3534 : * make sure we're done with the btree inode before we stop our
3535 : * kthreads
3536 : */
3537 0 : filemap_write_and_wait(fs_info->btree_inode->i_mapping);
3538 :
3539 0 : fail_sysfs:
3540 0 : btrfs_sysfs_remove_mounted(fs_info);
3541 :
3542 0 : fail_fsdev_sysfs:
3543 0 : btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3544 :
3545 0 : fail_block_groups:
3546 0 : btrfs_put_block_group_cache(fs_info);
3547 :
3548 0 : fail_tree_roots:
3549 0 : if (fs_info->data_reloc_root)
3550 0 : btrfs_drop_and_free_fs_root(fs_info, fs_info->data_reloc_root);
3551 0 : free_root_pointers(fs_info, true);
3552 0 : invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3553 :
3554 0 : fail_sb_buffer:
3555 0 : btrfs_stop_all_workers(fs_info);
3556 0 : btrfs_free_block_groups(fs_info);
3557 0 : fail_alloc:
3558 0 : btrfs_mapping_tree_free(&fs_info->mapping_tree);
3559 :
3560 0 : iput(fs_info->btree_inode);
3561 0 : fail:
3562 0 : btrfs_close_devices(fs_info->fs_devices);
3563 0 : ASSERT(ret < 0);
3564 0 : return ret;
3565 : }
3566 : ALLOW_ERROR_INJECTION(open_ctree, ERRNO);
3567 :
3568 0 : static void btrfs_end_super_write(struct bio *bio)
3569 : {
3570 0 : struct btrfs_device *device = bio->bi_private;
3571 0 : struct bio_vec *bvec;
3572 0 : struct bvec_iter_all iter_all;
3573 0 : struct page *page;
3574 :
3575 0 : bio_for_each_segment_all(bvec, bio, iter_all) {
3576 0 : page = bvec->bv_page;
3577 :
3578 0 : if (bio->bi_status) {
3579 0 : btrfs_warn_rl_in_rcu(device->fs_info,
3580 : "lost page write due to IO error on %s (%d)",
3581 : btrfs_dev_name(device),
3582 : blk_status_to_errno(bio->bi_status));
3583 0 : ClearPageUptodate(page);
3584 0 : SetPageError(page);
3585 0 : btrfs_dev_stat_inc_and_print(device,
3586 : BTRFS_DEV_STAT_WRITE_ERRS);
3587 : } else {
3588 0 : SetPageUptodate(page);
3589 : }
3590 :
3591 0 : put_page(page);
3592 0 : unlock_page(page);
3593 : }
3594 :
3595 0 : bio_put(bio);
3596 0 : }
3597 :
3598 0 : struct btrfs_super_block *btrfs_read_dev_one_super(struct block_device *bdev,
3599 : int copy_num, bool drop_cache)
3600 : {
3601 0 : struct btrfs_super_block *super;
3602 0 : struct page *page;
3603 0 : u64 bytenr, bytenr_orig;
3604 0 : struct address_space *mapping = bdev->bd_inode->i_mapping;
3605 0 : int ret;
3606 :
3607 0 : bytenr_orig = btrfs_sb_offset(copy_num);
3608 0 : ret = btrfs_sb_log_location_bdev(bdev, copy_num, READ, &bytenr);
3609 0 : if (ret == -ENOENT)
3610 : return ERR_PTR(-EINVAL);
3611 0 : else if (ret)
3612 0 : return ERR_PTR(ret);
3613 :
3614 0 : if (bytenr + BTRFS_SUPER_INFO_SIZE >= bdev_nr_bytes(bdev))
3615 : return ERR_PTR(-EINVAL);
3616 :
3617 0 : if (drop_cache) {
3618 : /* This should only be called with the primary sb. */
3619 0 : ASSERT(copy_num == 0);
3620 :
3621 : /*
3622 : * Drop the page of the primary superblock, so later read will
3623 : * always read from the device.
3624 : */
3625 0 : invalidate_inode_pages2_range(mapping,
3626 0 : bytenr >> PAGE_SHIFT,
3627 0 : (bytenr + BTRFS_SUPER_INFO_SIZE) >> PAGE_SHIFT);
3628 : }
3629 :
3630 0 : page = read_cache_page_gfp(mapping, bytenr >> PAGE_SHIFT, GFP_NOFS);
3631 0 : if (IS_ERR(page))
3632 : return ERR_CAST(page);
3633 :
3634 0 : super = page_address(page);
3635 0 : if (btrfs_super_magic(super) != BTRFS_MAGIC) {
3636 0 : btrfs_release_disk_super(super);
3637 0 : return ERR_PTR(-ENODATA);
3638 : }
3639 :
3640 0 : if (btrfs_super_bytenr(super) != bytenr_orig) {
3641 0 : btrfs_release_disk_super(super);
3642 0 : return ERR_PTR(-EINVAL);
3643 : }
3644 :
3645 : return super;
3646 : }
3647 :
3648 :
3649 0 : struct btrfs_super_block *btrfs_read_dev_super(struct block_device *bdev)
3650 : {
3651 0 : struct btrfs_super_block *super, *latest = NULL;
3652 0 : int i;
3653 0 : u64 transid = 0;
3654 :
3655 : /* we would like to check all the supers, but that would make
3656 : * a btrfs mount succeed after a mkfs from a different FS.
3657 : * So, we need to add a special mount option to scan for
3658 : * later supers, using BTRFS_SUPER_MIRROR_MAX instead
3659 : */
3660 0 : for (i = 0; i < 1; i++) {
3661 0 : super = btrfs_read_dev_one_super(bdev, i, false);
3662 0 : if (IS_ERR(super))
3663 0 : continue;
3664 :
3665 0 : if (!latest || btrfs_super_generation(super) > transid) {
3666 0 : if (latest)
3667 0 : btrfs_release_disk_super(super);
3668 :
3669 0 : latest = super;
3670 0 : transid = btrfs_super_generation(super);
3671 : }
3672 : }
3673 :
3674 0 : return super;
3675 : }
3676 :
3677 : /*
3678 : * Write superblock @sb to the @device. Do not wait for completion, all the
3679 : * pages we use for writing are locked.
3680 : *
3681 : * Write @max_mirrors copies of the superblock, where 0 means default that fit
3682 : * the expected device size at commit time. Note that max_mirrors must be
3683 : * same for write and wait phases.
3684 : *
3685 : * Return number of errors when page is not found or submission fails.
3686 : */
3687 0 : static int write_dev_supers(struct btrfs_device *device,
3688 : struct btrfs_super_block *sb, int max_mirrors)
3689 : {
3690 0 : struct btrfs_fs_info *fs_info = device->fs_info;
3691 0 : struct address_space *mapping = device->bdev->bd_inode->i_mapping;
3692 0 : SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
3693 0 : int i;
3694 0 : int errors = 0;
3695 0 : int ret;
3696 0 : u64 bytenr, bytenr_orig;
3697 :
3698 0 : if (max_mirrors == 0)
3699 0 : max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3700 :
3701 0 : shash->tfm = fs_info->csum_shash;
3702 :
3703 0 : for (i = 0; i < max_mirrors; i++) {
3704 0 : struct page *page;
3705 0 : struct bio *bio;
3706 0 : struct btrfs_super_block *disk_super;
3707 :
3708 0 : bytenr_orig = btrfs_sb_offset(i);
3709 0 : ret = btrfs_sb_log_location(device, i, WRITE, &bytenr);
3710 0 : if (ret == -ENOENT) {
3711 0 : continue;
3712 0 : } else if (ret < 0) {
3713 0 : btrfs_err(device->fs_info,
3714 : "couldn't get super block location for mirror %d",
3715 : i);
3716 0 : errors++;
3717 0 : continue;
3718 : }
3719 0 : if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3720 0 : device->commit_total_bytes)
3721 : break;
3722 :
3723 0 : btrfs_set_super_bytenr(sb, bytenr_orig);
3724 :
3725 0 : crypto_shash_digest(shash, (const char *)sb + BTRFS_CSUM_SIZE,
3726 : BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE,
3727 0 : sb->csum);
3728 :
3729 0 : page = find_or_create_page(mapping, bytenr >> PAGE_SHIFT,
3730 : GFP_NOFS);
3731 0 : if (!page) {
3732 0 : btrfs_err(device->fs_info,
3733 : "couldn't get super block page for bytenr %llu",
3734 : bytenr);
3735 0 : errors++;
3736 0 : continue;
3737 : }
3738 :
3739 : /* Bump the refcount for wait_dev_supers() */
3740 0 : get_page(page);
3741 :
3742 0 : disk_super = page_address(page);
3743 0 : memcpy(disk_super, sb, BTRFS_SUPER_INFO_SIZE);
3744 :
3745 : /*
3746 : * Directly use bios here instead of relying on the page cache
3747 : * to do I/O, so we don't lose the ability to do integrity
3748 : * checking.
3749 : */
3750 0 : bio = bio_alloc(device->bdev, 1,
3751 : REQ_OP_WRITE | REQ_SYNC | REQ_META | REQ_PRIO,
3752 : GFP_NOFS);
3753 0 : bio->bi_iter.bi_sector = bytenr >> SECTOR_SHIFT;
3754 0 : bio->bi_private = device;
3755 0 : bio->bi_end_io = btrfs_end_super_write;
3756 0 : __bio_add_page(bio, page, BTRFS_SUPER_INFO_SIZE,
3757 : offset_in_page(bytenr));
3758 :
3759 : /*
3760 : * We FUA only the first super block. The others we allow to
3761 : * go down lazy and there's a short window where the on-disk
3762 : * copies might still contain the older version.
3763 : */
3764 0 : if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))
3765 0 : bio->bi_opf |= REQ_FUA;
3766 :
3767 0 : btrfsic_check_bio(bio);
3768 0 : submit_bio(bio);
3769 :
3770 0 : if (btrfs_advance_sb_log(device, i))
3771 0 : errors++;
3772 : }
3773 0 : return errors < i ? 0 : -1;
3774 : }
3775 :
3776 : /*
3777 : * Wait for write completion of superblocks done by write_dev_supers,
3778 : * @max_mirrors same for write and wait phases.
3779 : *
3780 : * Return number of errors when page is not found or not marked up to
3781 : * date.
3782 : */
3783 0 : static int wait_dev_supers(struct btrfs_device *device, int max_mirrors)
3784 : {
3785 0 : int i;
3786 0 : int errors = 0;
3787 0 : bool primary_failed = false;
3788 0 : int ret;
3789 0 : u64 bytenr;
3790 :
3791 0 : if (max_mirrors == 0)
3792 0 : max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3793 :
3794 0 : for (i = 0; i < max_mirrors; i++) {
3795 0 : struct page *page;
3796 :
3797 0 : ret = btrfs_sb_log_location(device, i, READ, &bytenr);
3798 0 : if (ret == -ENOENT) {
3799 : break;
3800 0 : } else if (ret < 0) {
3801 0 : errors++;
3802 0 : if (i == 0)
3803 0 : primary_failed = true;
3804 0 : continue;
3805 : }
3806 0 : if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3807 0 : device->commit_total_bytes)
3808 : break;
3809 :
3810 0 : page = find_get_page(device->bdev->bd_inode->i_mapping,
3811 0 : bytenr >> PAGE_SHIFT);
3812 0 : if (!page) {
3813 0 : errors++;
3814 0 : if (i == 0)
3815 0 : primary_failed = true;
3816 0 : continue;
3817 : }
3818 : /* Page is submitted locked and unlocked once the IO completes */
3819 0 : wait_on_page_locked(page);
3820 0 : if (PageError(page)) {
3821 0 : errors++;
3822 0 : if (i == 0)
3823 0 : primary_failed = true;
3824 : }
3825 :
3826 : /* Drop our reference */
3827 0 : put_page(page);
3828 :
3829 : /* Drop the reference from the writing run */
3830 0 : put_page(page);
3831 : }
3832 :
3833 : /* log error, force error return */
3834 0 : if (primary_failed) {
3835 0 : btrfs_err(device->fs_info, "error writing primary super block to device %llu",
3836 : device->devid);
3837 0 : return -1;
3838 : }
3839 :
3840 0 : return errors < i ? 0 : -1;
3841 : }
3842 :
3843 : /*
3844 : * endio for the write_dev_flush, this will wake anyone waiting
3845 : * for the barrier when it is done
3846 : */
3847 0 : static void btrfs_end_empty_barrier(struct bio *bio)
3848 : {
3849 0 : bio_uninit(bio);
3850 0 : complete(bio->bi_private);
3851 0 : }
3852 :
3853 : /*
3854 : * Submit a flush request to the device if it supports it. Error handling is
3855 : * done in the waiting counterpart.
3856 : */
3857 0 : static void write_dev_flush(struct btrfs_device *device)
3858 : {
3859 0 : struct bio *bio = &device->flush_bio;
3860 :
3861 0 : device->last_flush_error = BLK_STS_OK;
3862 :
3863 : #ifndef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3864 : /*
3865 : * When a disk has write caching disabled, we skip submission of a bio
3866 : * with flush and sync requests before writing the superblock, since
3867 : * it's not needed. However when the integrity checker is enabled, this
3868 : * results in reports that there are metadata blocks referred by a
3869 : * superblock that were not properly flushed. So don't skip the bio
3870 : * submission only when the integrity checker is enabled for the sake
3871 : * of simplicity, since this is a debug tool and not meant for use in
3872 : * non-debug builds.
3873 : */
3874 0 : if (!bdev_write_cache(device->bdev))
3875 : return;
3876 : #endif
3877 :
3878 0 : bio_init(bio, device->bdev, NULL, 0,
3879 : REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH);
3880 0 : bio->bi_end_io = btrfs_end_empty_barrier;
3881 0 : init_completion(&device->flush_wait);
3882 0 : bio->bi_private = &device->flush_wait;
3883 :
3884 0 : btrfsic_check_bio(bio);
3885 0 : submit_bio(bio);
3886 0 : set_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3887 : }
3888 :
3889 : /*
3890 : * If the flush bio has been submitted by write_dev_flush, wait for it.
3891 : * Return true for any error, and false otherwise.
3892 : */
3893 0 : static bool wait_dev_flush(struct btrfs_device *device)
3894 : {
3895 0 : struct bio *bio = &device->flush_bio;
3896 :
3897 0 : if (!test_and_clear_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state))
3898 : return false;
3899 :
3900 0 : wait_for_completion_io(&device->flush_wait);
3901 :
3902 0 : if (bio->bi_status) {
3903 0 : device->last_flush_error = bio->bi_status;
3904 0 : btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_FLUSH_ERRS);
3905 0 : return true;
3906 : }
3907 :
3908 : return false;
3909 : }
3910 :
3911 : /*
3912 : * send an empty flush down to each device in parallel,
3913 : * then wait for them
3914 : */
3915 0 : static int barrier_all_devices(struct btrfs_fs_info *info)
3916 : {
3917 0 : struct list_head *head;
3918 0 : struct btrfs_device *dev;
3919 0 : int errors_wait = 0;
3920 :
3921 0 : lockdep_assert_held(&info->fs_devices->device_list_mutex);
3922 : /* send down all the barriers */
3923 0 : head = &info->fs_devices->devices;
3924 0 : list_for_each_entry(dev, head, dev_list) {
3925 0 : if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3926 0 : continue;
3927 0 : if (!dev->bdev)
3928 0 : continue;
3929 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3930 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3931 0 : continue;
3932 :
3933 0 : write_dev_flush(dev);
3934 : }
3935 :
3936 : /* wait for all the barriers */
3937 0 : list_for_each_entry(dev, head, dev_list) {
3938 0 : if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3939 0 : continue;
3940 0 : if (!dev->bdev) {
3941 0 : errors_wait++;
3942 0 : continue;
3943 : }
3944 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3945 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3946 0 : continue;
3947 :
3948 0 : if (wait_dev_flush(dev))
3949 0 : errors_wait++;
3950 : }
3951 :
3952 : /*
3953 : * Checks last_flush_error of disks in order to determine the device
3954 : * state.
3955 : */
3956 0 : if (errors_wait && !btrfs_check_rw_degradable(info, NULL))
3957 0 : return -EIO;
3958 :
3959 : return 0;
3960 : }
3961 :
3962 0 : int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags)
3963 : {
3964 0 : int raid_type;
3965 0 : int min_tolerated = INT_MAX;
3966 :
3967 0 : if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 ||
3968 0 : (flags & BTRFS_AVAIL_ALLOC_BIT_SINGLE))
3969 0 : min_tolerated = min_t(int, min_tolerated,
3970 : btrfs_raid_array[BTRFS_RAID_SINGLE].
3971 : tolerated_failures);
3972 :
3973 0 : for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
3974 0 : if (raid_type == BTRFS_RAID_SINGLE)
3975 0 : continue;
3976 0 : if (!(flags & btrfs_raid_array[raid_type].bg_flag))
3977 0 : continue;
3978 0 : min_tolerated = min_t(int, min_tolerated,
3979 : btrfs_raid_array[raid_type].
3980 : tolerated_failures);
3981 : }
3982 :
3983 0 : if (min_tolerated == INT_MAX) {
3984 0 : pr_warn("BTRFS: unknown raid flag: %llu", flags);
3985 0 : min_tolerated = 0;
3986 : }
3987 :
3988 0 : return min_tolerated;
3989 : }
3990 :
3991 0 : int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)
3992 : {
3993 0 : struct list_head *head;
3994 0 : struct btrfs_device *dev;
3995 0 : struct btrfs_super_block *sb;
3996 0 : struct btrfs_dev_item *dev_item;
3997 0 : int ret;
3998 0 : int do_barriers;
3999 0 : int max_errors;
4000 0 : int total_errors = 0;
4001 0 : u64 flags;
4002 :
4003 0 : do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);
4004 :
4005 : /*
4006 : * max_mirrors == 0 indicates we're from commit_transaction,
4007 : * not from fsync where the tree roots in fs_info have not
4008 : * been consistent on disk.
4009 : */
4010 0 : if (max_mirrors == 0)
4011 0 : backup_super_roots(fs_info);
4012 :
4013 0 : sb = fs_info->super_for_commit;
4014 0 : dev_item = &sb->dev_item;
4015 :
4016 0 : mutex_lock(&fs_info->fs_devices->device_list_mutex);
4017 0 : head = &fs_info->fs_devices->devices;
4018 0 : max_errors = btrfs_super_num_devices(fs_info->super_copy) - 1;
4019 :
4020 0 : if (do_barriers) {
4021 0 : ret = barrier_all_devices(fs_info);
4022 0 : if (ret) {
4023 0 : mutex_unlock(
4024 0 : &fs_info->fs_devices->device_list_mutex);
4025 0 : btrfs_handle_fs_error(fs_info, ret,
4026 : "errors while submitting device barriers.");
4027 0 : return ret;
4028 : }
4029 : }
4030 :
4031 0 : list_for_each_entry(dev, head, dev_list) {
4032 0 : if (!dev->bdev) {
4033 0 : total_errors++;
4034 0 : continue;
4035 : }
4036 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4037 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4038 0 : continue;
4039 :
4040 0 : btrfs_set_stack_device_generation(dev_item, 0);
4041 0 : btrfs_set_stack_device_type(dev_item, dev->type);
4042 0 : btrfs_set_stack_device_id(dev_item, dev->devid);
4043 0 : btrfs_set_stack_device_total_bytes(dev_item,
4044 : dev->commit_total_bytes);
4045 0 : btrfs_set_stack_device_bytes_used(dev_item,
4046 : dev->commit_bytes_used);
4047 0 : btrfs_set_stack_device_io_align(dev_item, dev->io_align);
4048 0 : btrfs_set_stack_device_io_width(dev_item, dev->io_width);
4049 0 : btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
4050 0 : memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
4051 0 : memcpy(dev_item->fsid, dev->fs_devices->metadata_uuid,
4052 : BTRFS_FSID_SIZE);
4053 :
4054 0 : flags = btrfs_super_flags(sb);
4055 0 : btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
4056 :
4057 0 : ret = btrfs_validate_write_super(fs_info, sb);
4058 0 : if (ret < 0) {
4059 0 : mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4060 0 : btrfs_handle_fs_error(fs_info, -EUCLEAN,
4061 : "unexpected superblock corruption detected");
4062 0 : return -EUCLEAN;
4063 : }
4064 :
4065 0 : ret = write_dev_supers(dev, sb, max_mirrors);
4066 0 : if (ret)
4067 0 : total_errors++;
4068 : }
4069 0 : if (total_errors > max_errors) {
4070 0 : btrfs_err(fs_info, "%d errors while writing supers",
4071 : total_errors);
4072 0 : mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4073 :
4074 : /* FUA is masked off if unsupported and can't be the reason */
4075 0 : btrfs_handle_fs_error(fs_info, -EIO,
4076 : "%d errors while writing supers",
4077 : total_errors);
4078 0 : return -EIO;
4079 : }
4080 :
4081 0 : total_errors = 0;
4082 0 : list_for_each_entry(dev, head, dev_list) {
4083 0 : if (!dev->bdev)
4084 0 : continue;
4085 0 : if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
4086 0 : !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
4087 0 : continue;
4088 :
4089 0 : ret = wait_dev_supers(dev, max_mirrors);
4090 0 : if (ret)
4091 0 : total_errors++;
4092 : }
4093 0 : mutex_unlock(&fs_info->fs_devices->device_list_mutex);
4094 0 : if (total_errors > max_errors) {
4095 0 : btrfs_handle_fs_error(fs_info, -EIO,
4096 : "%d errors while writing supers",
4097 : total_errors);
4098 0 : return -EIO;
4099 : }
4100 : return 0;
4101 : }
4102 :
4103 : /* Drop a fs root from the radix tree and free it. */
4104 0 : void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
4105 : struct btrfs_root *root)
4106 : {
4107 0 : bool drop_ref = false;
4108 :
4109 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4110 0 : radix_tree_delete(&fs_info->fs_roots_radix,
4111 0 : (unsigned long)root->root_key.objectid);
4112 0 : if (test_and_clear_bit(BTRFS_ROOT_IN_RADIX, &root->state))
4113 0 : drop_ref = true;
4114 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4115 :
4116 0 : if (BTRFS_FS_ERROR(fs_info)) {
4117 0 : ASSERT(root->log_root == NULL);
4118 0 : if (root->reloc_root) {
4119 0 : btrfs_put_root(root->reloc_root);
4120 0 : root->reloc_root = NULL;
4121 : }
4122 : }
4123 :
4124 0 : if (drop_ref)
4125 0 : btrfs_put_root(root);
4126 0 : }
4127 :
4128 0 : int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
4129 : {
4130 0 : u64 root_objectid = 0;
4131 0 : struct btrfs_root *gang[8];
4132 0 : int i = 0;
4133 0 : int err = 0;
4134 0 : unsigned int ret = 0;
4135 :
4136 0 : while (1) {
4137 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4138 0 : ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
4139 : (void **)gang, root_objectid,
4140 : ARRAY_SIZE(gang));
4141 0 : if (!ret) {
4142 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4143 : break;
4144 : }
4145 0 : root_objectid = gang[ret - 1]->root_key.objectid + 1;
4146 :
4147 0 : for (i = 0; i < ret; i++) {
4148 : /* Avoid to grab roots in dead_roots */
4149 0 : if (btrfs_root_refs(&gang[i]->root_item) == 0) {
4150 0 : gang[i] = NULL;
4151 0 : continue;
4152 : }
4153 : /* grab all the search result for later use */
4154 0 : gang[i] = btrfs_grab_root(gang[i]);
4155 : }
4156 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4157 :
4158 0 : for (i = 0; i < ret; i++) {
4159 0 : if (!gang[i])
4160 0 : continue;
4161 0 : root_objectid = gang[i]->root_key.objectid;
4162 0 : err = btrfs_orphan_cleanup(gang[i]);
4163 0 : if (err)
4164 0 : goto out;
4165 0 : btrfs_put_root(gang[i]);
4166 : }
4167 0 : root_objectid++;
4168 : }
4169 0 : out:
4170 : /* release the uncleaned roots due to error */
4171 0 : for (; i < ret; i++) {
4172 0 : if (gang[i])
4173 0 : btrfs_put_root(gang[i]);
4174 : }
4175 0 : return err;
4176 : }
4177 :
4178 0 : int btrfs_commit_super(struct btrfs_fs_info *fs_info)
4179 : {
4180 0 : struct btrfs_root *root = fs_info->tree_root;
4181 0 : struct btrfs_trans_handle *trans;
4182 :
4183 0 : mutex_lock(&fs_info->cleaner_mutex);
4184 0 : btrfs_run_delayed_iputs(fs_info);
4185 0 : mutex_unlock(&fs_info->cleaner_mutex);
4186 0 : wake_up_process(fs_info->cleaner_kthread);
4187 :
4188 : /* wait until ongoing cleanup work done */
4189 0 : down_write(&fs_info->cleanup_work_sem);
4190 0 : up_write(&fs_info->cleanup_work_sem);
4191 :
4192 0 : trans = btrfs_join_transaction(root);
4193 0 : if (IS_ERR(trans))
4194 0 : return PTR_ERR(trans);
4195 0 : return btrfs_commit_transaction(trans);
4196 : }
4197 :
4198 0 : static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)
4199 : {
4200 0 : struct btrfs_transaction *trans;
4201 0 : struct btrfs_transaction *tmp;
4202 0 : bool found = false;
4203 :
4204 0 : if (list_empty(&fs_info->trans_list))
4205 : return;
4206 :
4207 : /*
4208 : * This function is only called at the very end of close_ctree(),
4209 : * thus no other running transaction, no need to take trans_lock.
4210 : */
4211 0 : ASSERT(test_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags));
4212 0 : list_for_each_entry_safe(trans, tmp, &fs_info->trans_list, list) {
4213 0 : struct extent_state *cached = NULL;
4214 0 : u64 dirty_bytes = 0;
4215 0 : u64 cur = 0;
4216 0 : u64 found_start;
4217 0 : u64 found_end;
4218 :
4219 0 : found = true;
4220 0 : while (!find_first_extent_bit(&trans->dirty_pages, cur,
4221 : &found_start, &found_end, EXTENT_DIRTY, &cached)) {
4222 0 : dirty_bytes += found_end + 1 - found_start;
4223 0 : cur = found_end + 1;
4224 : }
4225 0 : btrfs_warn(fs_info,
4226 : "transaction %llu (with %llu dirty metadata bytes) is not committed",
4227 : trans->transid, dirty_bytes);
4228 0 : btrfs_cleanup_one_transaction(trans, fs_info);
4229 :
4230 0 : if (trans == fs_info->running_transaction)
4231 0 : fs_info->running_transaction = NULL;
4232 0 : list_del_init(&trans->list);
4233 :
4234 0 : btrfs_put_transaction(trans);
4235 0 : trace_btrfs_transaction_commit(fs_info);
4236 : }
4237 0 : ASSERT(!found);
4238 : }
4239 :
4240 0 : void __cold close_ctree(struct btrfs_fs_info *fs_info)
4241 : {
4242 0 : int ret;
4243 :
4244 0 : set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
4245 :
4246 : /*
4247 : * If we had UNFINISHED_DROPS we could still be processing them, so
4248 : * clear that bit and wake up relocation so it can stop.
4249 : * We must do this before stopping the block group reclaim task, because
4250 : * at btrfs_relocate_block_group() we wait for this bit, and after the
4251 : * wait we stop with -EINTR if btrfs_fs_closing() returns non-zero - we
4252 : * have just set BTRFS_FS_CLOSING_START, so btrfs_fs_closing() will
4253 : * return 1.
4254 : */
4255 0 : btrfs_wake_unfinished_drop(fs_info);
4256 :
4257 : /*
4258 : * We may have the reclaim task running and relocating a data block group,
4259 : * in which case it may create delayed iputs. So stop it before we park
4260 : * the cleaner kthread otherwise we can get new delayed iputs after
4261 : * parking the cleaner, and that can make the async reclaim task to hang
4262 : * if it's waiting for delayed iputs to complete, since the cleaner is
4263 : * parked and can not run delayed iputs - this will make us hang when
4264 : * trying to stop the async reclaim task.
4265 : */
4266 0 : cancel_work_sync(&fs_info->reclaim_bgs_work);
4267 : /*
4268 : * We don't want the cleaner to start new transactions, add more delayed
4269 : * iputs, etc. while we're closing. We can't use kthread_stop() yet
4270 : * because that frees the task_struct, and the transaction kthread might
4271 : * still try to wake up the cleaner.
4272 : */
4273 0 : kthread_park(fs_info->cleaner_kthread);
4274 :
4275 : /* wait for the qgroup rescan worker to stop */
4276 0 : btrfs_qgroup_wait_for_completion(fs_info, false);
4277 :
4278 : /* wait for the uuid_scan task to finish */
4279 0 : down(&fs_info->uuid_tree_rescan_sem);
4280 : /* avoid complains from lockdep et al., set sem back to initial state */
4281 0 : up(&fs_info->uuid_tree_rescan_sem);
4282 :
4283 : /* pause restriper - we want to resume on mount */
4284 0 : btrfs_pause_balance(fs_info);
4285 :
4286 0 : btrfs_dev_replace_suspend_for_unmount(fs_info);
4287 :
4288 0 : btrfs_scrub_cancel(fs_info);
4289 :
4290 : /* wait for any defraggers to finish */
4291 0 : wait_event(fs_info->transaction_wait,
4292 : (atomic_read(&fs_info->defrag_running) == 0));
4293 :
4294 : /* clear out the rbtree of defraggable inodes */
4295 0 : btrfs_cleanup_defrag_inodes(fs_info);
4296 :
4297 : /*
4298 : * After we parked the cleaner kthread, ordered extents may have
4299 : * completed and created new delayed iputs. If one of the async reclaim
4300 : * tasks is running and in the RUN_DELAYED_IPUTS flush state, then we
4301 : * can hang forever trying to stop it, because if a delayed iput is
4302 : * added after it ran btrfs_run_delayed_iputs() and before it called
4303 : * btrfs_wait_on_delayed_iputs(), it will hang forever since there is
4304 : * no one else to run iputs.
4305 : *
4306 : * So wait for all ongoing ordered extents to complete and then run
4307 : * delayed iputs. This works because once we reach this point no one
4308 : * can either create new ordered extents nor create delayed iputs
4309 : * through some other means.
4310 : *
4311 : * Also note that btrfs_wait_ordered_roots() is not safe here, because
4312 : * it waits for BTRFS_ORDERED_COMPLETE to be set on an ordered extent,
4313 : * but the delayed iput for the respective inode is made only when doing
4314 : * the final btrfs_put_ordered_extent() (which must happen at
4315 : * btrfs_finish_ordered_io() when we are unmounting).
4316 : */
4317 0 : btrfs_flush_workqueue(fs_info->endio_write_workers);
4318 : /* Ordered extents for free space inodes. */
4319 0 : btrfs_flush_workqueue(fs_info->endio_freespace_worker);
4320 0 : btrfs_run_delayed_iputs(fs_info);
4321 :
4322 0 : cancel_work_sync(&fs_info->async_reclaim_work);
4323 0 : cancel_work_sync(&fs_info->async_data_reclaim_work);
4324 0 : cancel_work_sync(&fs_info->preempt_reclaim_work);
4325 :
4326 : /* Cancel or finish ongoing discard work */
4327 0 : btrfs_discard_cleanup(fs_info);
4328 :
4329 0 : if (!sb_rdonly(fs_info->sb)) {
4330 : /*
4331 : * The cleaner kthread is stopped, so do one final pass over
4332 : * unused block groups.
4333 : */
4334 0 : btrfs_delete_unused_bgs(fs_info);
4335 :
4336 : /*
4337 : * There might be existing delayed inode workers still running
4338 : * and holding an empty delayed inode item. We must wait for
4339 : * them to complete first because they can create a transaction.
4340 : * This happens when someone calls btrfs_balance_delayed_items()
4341 : * and then a transaction commit runs the same delayed nodes
4342 : * before any delayed worker has done something with the nodes.
4343 : * We must wait for any worker here and not at transaction
4344 : * commit time since that could cause a deadlock.
4345 : * This is a very rare case.
4346 : */
4347 0 : btrfs_flush_workqueue(fs_info->delayed_workers);
4348 :
4349 0 : ret = btrfs_commit_super(fs_info);
4350 0 : if (ret)
4351 0 : btrfs_err(fs_info, "commit super ret %d", ret);
4352 : }
4353 :
4354 0 : if (BTRFS_FS_ERROR(fs_info))
4355 0 : btrfs_error_commit_super(fs_info);
4356 :
4357 0 : kthread_stop(fs_info->transaction_kthread);
4358 0 : kthread_stop(fs_info->cleaner_kthread);
4359 :
4360 0 : ASSERT(list_empty(&fs_info->delayed_iputs));
4361 0 : set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
4362 :
4363 0 : if (btrfs_check_quota_leak(fs_info)) {
4364 0 : WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
4365 0 : btrfs_err(fs_info, "qgroup reserved space leaked");
4366 : }
4367 :
4368 0 : btrfs_free_qgroup_config(fs_info);
4369 0 : ASSERT(list_empty(&fs_info->delalloc_roots));
4370 :
4371 0 : if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
4372 0 : btrfs_info(fs_info, "at unmount delalloc count %lld",
4373 : percpu_counter_sum(&fs_info->delalloc_bytes));
4374 : }
4375 :
4376 0 : if (percpu_counter_sum(&fs_info->ordered_bytes))
4377 0 : btrfs_info(fs_info, "at unmount dio bytes count %lld",
4378 : percpu_counter_sum(&fs_info->ordered_bytes));
4379 :
4380 0 : btrfs_sysfs_remove_mounted(fs_info);
4381 0 : btrfs_sysfs_remove_fsid(fs_info->fs_devices);
4382 :
4383 0 : btrfs_put_block_group_cache(fs_info);
4384 :
4385 : /*
4386 : * we must make sure there is not any read request to
4387 : * submit after we stopping all workers.
4388 : */
4389 0 : invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
4390 0 : btrfs_stop_all_workers(fs_info);
4391 :
4392 : /* We shouldn't have any transaction open at this point */
4393 0 : warn_about_uncommitted_trans(fs_info);
4394 :
4395 0 : clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
4396 0 : free_root_pointers(fs_info, true);
4397 0 : btrfs_free_fs_roots(fs_info);
4398 :
4399 : /*
4400 : * We must free the block groups after dropping the fs_roots as we could
4401 : * have had an IO error and have left over tree log blocks that aren't
4402 : * cleaned up until the fs roots are freed. This makes the block group
4403 : * accounting appear to be wrong because there's pending reserved bytes,
4404 : * so make sure we do the block group cleanup afterwards.
4405 : */
4406 0 : btrfs_free_block_groups(fs_info);
4407 :
4408 0 : iput(fs_info->btree_inode);
4409 :
4410 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4411 : if (btrfs_test_opt(fs_info, CHECK_INTEGRITY))
4412 : btrfsic_unmount(fs_info->fs_devices);
4413 : #endif
4414 :
4415 0 : btrfs_mapping_tree_free(&fs_info->mapping_tree);
4416 0 : btrfs_close_devices(fs_info->fs_devices);
4417 0 : }
4418 :
4419 0 : void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
4420 : {
4421 0 : struct btrfs_fs_info *fs_info = buf->fs_info;
4422 0 : u64 transid = btrfs_header_generation(buf);
4423 :
4424 : #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
4425 : /*
4426 : * This is a fast path so only do this check if we have sanity tests
4427 : * enabled. Normal people shouldn't be using unmapped buffers as dirty
4428 : * outside of the sanity tests.
4429 : */
4430 : if (unlikely(test_bit(EXTENT_BUFFER_UNMAPPED, &buf->bflags)))
4431 : return;
4432 : #endif
4433 0 : btrfs_assert_tree_write_locked(buf);
4434 0 : if (transid != fs_info->generation)
4435 0 : WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, found %llu running %llu\n",
4436 : buf->start, transid, fs_info->generation);
4437 0 : set_extent_buffer_dirty(buf);
4438 : #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4439 : /*
4440 : * btrfs_check_leaf() won't check item data if we don't have WRITTEN
4441 : * set, so this will only validate the basic structure of the items.
4442 : */
4443 : if (btrfs_header_level(buf) == 0 && btrfs_check_leaf(buf)) {
4444 : btrfs_print_leaf(buf);
4445 : ASSERT(0);
4446 : }
4447 : #endif
4448 0 : }
4449 :
4450 0 : static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,
4451 : int flush_delayed)
4452 : {
4453 : /*
4454 : * looks as though older kernels can get into trouble with
4455 : * this code, they end up stuck in balance_dirty_pages forever
4456 : */
4457 0 : int ret;
4458 :
4459 0 : if (current->flags & PF_MEMALLOC)
4460 : return;
4461 :
4462 0 : if (flush_delayed)
4463 0 : btrfs_balance_delayed_items(fs_info);
4464 :
4465 0 : ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
4466 : BTRFS_DIRTY_METADATA_THRESH,
4467 : fs_info->dirty_metadata_batch);
4468 0 : if (ret > 0) {
4469 0 : balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);
4470 : }
4471 : }
4472 :
4473 0 : void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)
4474 : {
4475 0 : __btrfs_btree_balance_dirty(fs_info, 1);
4476 0 : }
4477 :
4478 0 : void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
4479 : {
4480 0 : __btrfs_btree_balance_dirty(fs_info, 0);
4481 0 : }
4482 :
4483 0 : static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)
4484 : {
4485 : /* cleanup FS via transaction */
4486 0 : btrfs_cleanup_transaction(fs_info);
4487 :
4488 0 : mutex_lock(&fs_info->cleaner_mutex);
4489 0 : btrfs_run_delayed_iputs(fs_info);
4490 0 : mutex_unlock(&fs_info->cleaner_mutex);
4491 :
4492 0 : down_write(&fs_info->cleanup_work_sem);
4493 0 : up_write(&fs_info->cleanup_work_sem);
4494 0 : }
4495 :
4496 0 : static void btrfs_drop_all_logs(struct btrfs_fs_info *fs_info)
4497 : {
4498 0 : struct btrfs_root *gang[8];
4499 0 : u64 root_objectid = 0;
4500 0 : int ret;
4501 :
4502 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4503 0 : while ((ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
4504 : (void **)gang, root_objectid,
4505 0 : ARRAY_SIZE(gang))) != 0) {
4506 : int i;
4507 :
4508 0 : for (i = 0; i < ret; i++)
4509 0 : gang[i] = btrfs_grab_root(gang[i]);
4510 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4511 :
4512 0 : for (i = 0; i < ret; i++) {
4513 0 : if (!gang[i])
4514 0 : continue;
4515 0 : root_objectid = gang[i]->root_key.objectid;
4516 0 : btrfs_free_log(NULL, gang[i]);
4517 0 : btrfs_put_root(gang[i]);
4518 : }
4519 0 : root_objectid++;
4520 0 : spin_lock(&fs_info->fs_roots_radix_lock);
4521 : }
4522 0 : spin_unlock(&fs_info->fs_roots_radix_lock);
4523 0 : btrfs_free_log_root_tree(NULL, fs_info);
4524 0 : }
4525 :
4526 0 : static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4527 : {
4528 0 : struct btrfs_ordered_extent *ordered;
4529 :
4530 0 : spin_lock(&root->ordered_extent_lock);
4531 : /*
4532 : * This will just short circuit the ordered completion stuff which will
4533 : * make sure the ordered extent gets properly cleaned up.
4534 : */
4535 0 : list_for_each_entry(ordered, &root->ordered_extents,
4536 : root_extent_list)
4537 0 : set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
4538 0 : spin_unlock(&root->ordered_extent_lock);
4539 0 : }
4540 :
4541 0 : static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
4542 : {
4543 0 : struct btrfs_root *root;
4544 0 : struct list_head splice;
4545 :
4546 0 : INIT_LIST_HEAD(&splice);
4547 :
4548 0 : spin_lock(&fs_info->ordered_root_lock);
4549 0 : list_splice_init(&fs_info->ordered_roots, &splice);
4550 0 : while (!list_empty(&splice)) {
4551 0 : root = list_first_entry(&splice, struct btrfs_root,
4552 : ordered_root);
4553 0 : list_move_tail(&root->ordered_root,
4554 : &fs_info->ordered_roots);
4555 :
4556 0 : spin_unlock(&fs_info->ordered_root_lock);
4557 0 : btrfs_destroy_ordered_extents(root);
4558 :
4559 0 : cond_resched();
4560 0 : spin_lock(&fs_info->ordered_root_lock);
4561 : }
4562 0 : spin_unlock(&fs_info->ordered_root_lock);
4563 :
4564 : /*
4565 : * We need this here because if we've been flipped read-only we won't
4566 : * get sync() from the umount, so we need to make sure any ordered
4567 : * extents that haven't had their dirty pages IO start writeout yet
4568 : * actually get run and error out properly.
4569 : */
4570 0 : btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
4571 0 : }
4572 :
4573 0 : static void btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
4574 : struct btrfs_fs_info *fs_info)
4575 : {
4576 0 : struct rb_node *node;
4577 0 : struct btrfs_delayed_ref_root *delayed_refs;
4578 0 : struct btrfs_delayed_ref_node *ref;
4579 :
4580 0 : delayed_refs = &trans->delayed_refs;
4581 :
4582 0 : spin_lock(&delayed_refs->lock);
4583 0 : if (atomic_read(&delayed_refs->num_entries) == 0) {
4584 0 : spin_unlock(&delayed_refs->lock);
4585 0 : btrfs_debug(fs_info, "delayed_refs has NO entry");
4586 0 : return;
4587 : }
4588 :
4589 0 : while ((node = rb_first_cached(&delayed_refs->href_root)) != NULL) {
4590 0 : struct btrfs_delayed_ref_head *head;
4591 0 : struct rb_node *n;
4592 0 : bool pin_bytes = false;
4593 :
4594 0 : head = rb_entry(node, struct btrfs_delayed_ref_head,
4595 : href_node);
4596 0 : if (btrfs_delayed_ref_lock(delayed_refs, head))
4597 0 : continue;
4598 :
4599 0 : spin_lock(&head->lock);
4600 0 : while ((n = rb_first_cached(&head->ref_tree)) != NULL) {
4601 0 : ref = rb_entry(n, struct btrfs_delayed_ref_node,
4602 : ref_node);
4603 0 : rb_erase_cached(&ref->ref_node, &head->ref_tree);
4604 0 : RB_CLEAR_NODE(&ref->ref_node);
4605 0 : if (!list_empty(&ref->add_list))
4606 0 : list_del(&ref->add_list);
4607 0 : atomic_dec(&delayed_refs->num_entries);
4608 0 : btrfs_put_delayed_ref(ref);
4609 : }
4610 0 : if (head->must_insert_reserved)
4611 0 : pin_bytes = true;
4612 0 : btrfs_free_delayed_extent_op(head->extent_op);
4613 0 : btrfs_delete_ref_head(delayed_refs, head);
4614 0 : spin_unlock(&head->lock);
4615 0 : spin_unlock(&delayed_refs->lock);
4616 0 : mutex_unlock(&head->mutex);
4617 :
4618 0 : if (pin_bytes) {
4619 0 : struct btrfs_block_group *cache;
4620 :
4621 0 : cache = btrfs_lookup_block_group(fs_info, head->bytenr);
4622 0 : BUG_ON(!cache);
4623 :
4624 0 : spin_lock(&cache->space_info->lock);
4625 0 : spin_lock(&cache->lock);
4626 0 : cache->pinned += head->num_bytes;
4627 0 : btrfs_space_info_update_bytes_pinned(fs_info,
4628 0 : cache->space_info, head->num_bytes);
4629 0 : cache->reserved -= head->num_bytes;
4630 0 : cache->space_info->bytes_reserved -= head->num_bytes;
4631 0 : spin_unlock(&cache->lock);
4632 0 : spin_unlock(&cache->space_info->lock);
4633 :
4634 0 : btrfs_put_block_group(cache);
4635 :
4636 0 : btrfs_error_unpin_extent_range(fs_info, head->bytenr,
4637 0 : head->bytenr + head->num_bytes - 1);
4638 : }
4639 0 : btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);
4640 0 : btrfs_put_delayed_ref_head(head);
4641 0 : cond_resched();
4642 0 : spin_lock(&delayed_refs->lock);
4643 : }
4644 0 : btrfs_qgroup_destroy_extent_records(trans);
4645 :
4646 0 : spin_unlock(&delayed_refs->lock);
4647 : }
4648 :
4649 0 : static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
4650 : {
4651 0 : struct btrfs_inode *btrfs_inode;
4652 0 : struct list_head splice;
4653 :
4654 0 : INIT_LIST_HEAD(&splice);
4655 :
4656 0 : spin_lock(&root->delalloc_lock);
4657 0 : list_splice_init(&root->delalloc_inodes, &splice);
4658 :
4659 0 : while (!list_empty(&splice)) {
4660 0 : struct inode *inode = NULL;
4661 0 : btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
4662 : delalloc_inodes);
4663 0 : __btrfs_del_delalloc_inode(root, btrfs_inode);
4664 0 : spin_unlock(&root->delalloc_lock);
4665 :
4666 : /*
4667 : * Make sure we get a live inode and that it'll not disappear
4668 : * meanwhile.
4669 : */
4670 0 : inode = igrab(&btrfs_inode->vfs_inode);
4671 0 : if (inode) {
4672 0 : unsigned int nofs_flag;
4673 :
4674 0 : nofs_flag = memalloc_nofs_save();
4675 0 : invalidate_inode_pages2(inode->i_mapping);
4676 0 : memalloc_nofs_restore(nofs_flag);
4677 0 : iput(inode);
4678 : }
4679 0 : spin_lock(&root->delalloc_lock);
4680 : }
4681 0 : spin_unlock(&root->delalloc_lock);
4682 0 : }
4683 :
4684 0 : static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
4685 : {
4686 0 : struct btrfs_root *root;
4687 0 : struct list_head splice;
4688 :
4689 0 : INIT_LIST_HEAD(&splice);
4690 :
4691 0 : spin_lock(&fs_info->delalloc_root_lock);
4692 0 : list_splice_init(&fs_info->delalloc_roots, &splice);
4693 0 : while (!list_empty(&splice)) {
4694 0 : root = list_first_entry(&splice, struct btrfs_root,
4695 : delalloc_root);
4696 0 : root = btrfs_grab_root(root);
4697 0 : BUG_ON(!root);
4698 0 : spin_unlock(&fs_info->delalloc_root_lock);
4699 :
4700 0 : btrfs_destroy_delalloc_inodes(root);
4701 0 : btrfs_put_root(root);
4702 :
4703 0 : spin_lock(&fs_info->delalloc_root_lock);
4704 : }
4705 0 : spin_unlock(&fs_info->delalloc_root_lock);
4706 0 : }
4707 :
4708 0 : static int btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
4709 : struct extent_io_tree *dirty_pages,
4710 : int mark)
4711 : {
4712 0 : int ret;
4713 0 : struct extent_buffer *eb;
4714 0 : u64 start = 0;
4715 0 : u64 end;
4716 :
4717 0 : while (1) {
4718 0 : ret = find_first_extent_bit(dirty_pages, start, &start, &end,
4719 : mark, NULL);
4720 0 : if (ret)
4721 : break;
4722 :
4723 0 : clear_extent_bits(dirty_pages, start, end, mark);
4724 0 : while (start <= end) {
4725 0 : eb = find_extent_buffer(fs_info, start);
4726 0 : start += fs_info->nodesize;
4727 0 : if (!eb)
4728 0 : continue;
4729 :
4730 0 : btrfs_tree_lock(eb);
4731 0 : wait_on_extent_buffer_writeback(eb);
4732 0 : btrfs_clear_buffer_dirty(NULL, eb);
4733 0 : btrfs_tree_unlock(eb);
4734 :
4735 0 : free_extent_buffer_stale(eb);
4736 : }
4737 : }
4738 :
4739 0 : return ret;
4740 : }
4741 :
4742 0 : static int btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
4743 : struct extent_io_tree *unpin)
4744 : {
4745 0 : u64 start;
4746 0 : u64 end;
4747 0 : int ret;
4748 :
4749 0 : while (1) {
4750 0 : struct extent_state *cached_state = NULL;
4751 :
4752 : /*
4753 : * The btrfs_finish_extent_commit() may get the same range as
4754 : * ours between find_first_extent_bit and clear_extent_dirty.
4755 : * Hence, hold the unused_bg_unpin_mutex to avoid double unpin
4756 : * the same extent range.
4757 : */
4758 0 : mutex_lock(&fs_info->unused_bg_unpin_mutex);
4759 0 : ret = find_first_extent_bit(unpin, 0, &start, &end,
4760 : EXTENT_DIRTY, &cached_state);
4761 0 : if (ret) {
4762 0 : mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4763 0 : break;
4764 : }
4765 :
4766 0 : clear_extent_dirty(unpin, start, end, &cached_state);
4767 0 : free_extent_state(cached_state);
4768 0 : btrfs_error_unpin_extent_range(fs_info, start, end);
4769 0 : mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4770 0 : cond_resched();
4771 : }
4772 :
4773 0 : return 0;
4774 : }
4775 :
4776 0 : static void btrfs_cleanup_bg_io(struct btrfs_block_group *cache)
4777 : {
4778 0 : struct inode *inode;
4779 :
4780 0 : inode = cache->io_ctl.inode;
4781 0 : if (inode) {
4782 0 : unsigned int nofs_flag;
4783 :
4784 0 : nofs_flag = memalloc_nofs_save();
4785 0 : invalidate_inode_pages2(inode->i_mapping);
4786 0 : memalloc_nofs_restore(nofs_flag);
4787 :
4788 0 : BTRFS_I(inode)->generation = 0;
4789 0 : cache->io_ctl.inode = NULL;
4790 0 : iput(inode);
4791 : }
4792 0 : ASSERT(cache->io_ctl.pages == NULL);
4793 0 : btrfs_put_block_group(cache);
4794 0 : }
4795 :
4796 0 : void btrfs_cleanup_dirty_bgs(struct btrfs_transaction *cur_trans,
4797 : struct btrfs_fs_info *fs_info)
4798 : {
4799 0 : struct btrfs_block_group *cache;
4800 :
4801 0 : spin_lock(&cur_trans->dirty_bgs_lock);
4802 0 : while (!list_empty(&cur_trans->dirty_bgs)) {
4803 0 : cache = list_first_entry(&cur_trans->dirty_bgs,
4804 : struct btrfs_block_group,
4805 : dirty_list);
4806 :
4807 0 : if (!list_empty(&cache->io_list)) {
4808 0 : spin_unlock(&cur_trans->dirty_bgs_lock);
4809 0 : list_del_init(&cache->io_list);
4810 0 : btrfs_cleanup_bg_io(cache);
4811 0 : spin_lock(&cur_trans->dirty_bgs_lock);
4812 : }
4813 :
4814 0 : list_del_init(&cache->dirty_list);
4815 0 : spin_lock(&cache->lock);
4816 0 : cache->disk_cache_state = BTRFS_DC_ERROR;
4817 0 : spin_unlock(&cache->lock);
4818 :
4819 0 : spin_unlock(&cur_trans->dirty_bgs_lock);
4820 0 : btrfs_put_block_group(cache);
4821 0 : btrfs_delayed_refs_rsv_release(fs_info, 1);
4822 0 : spin_lock(&cur_trans->dirty_bgs_lock);
4823 : }
4824 0 : spin_unlock(&cur_trans->dirty_bgs_lock);
4825 :
4826 : /*
4827 : * Refer to the definition of io_bgs member for details why it's safe
4828 : * to use it without any locking
4829 : */
4830 0 : while (!list_empty(&cur_trans->io_bgs)) {
4831 0 : cache = list_first_entry(&cur_trans->io_bgs,
4832 : struct btrfs_block_group,
4833 : io_list);
4834 :
4835 0 : list_del_init(&cache->io_list);
4836 0 : spin_lock(&cache->lock);
4837 0 : cache->disk_cache_state = BTRFS_DC_ERROR;
4838 0 : spin_unlock(&cache->lock);
4839 0 : btrfs_cleanup_bg_io(cache);
4840 : }
4841 0 : }
4842 :
4843 0 : void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4844 : struct btrfs_fs_info *fs_info)
4845 : {
4846 0 : struct btrfs_device *dev, *tmp;
4847 :
4848 0 : btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
4849 0 : ASSERT(list_empty(&cur_trans->dirty_bgs));
4850 0 : ASSERT(list_empty(&cur_trans->io_bgs));
4851 :
4852 0 : list_for_each_entry_safe(dev, tmp, &cur_trans->dev_update_list,
4853 : post_commit_list) {
4854 0 : list_del_init(&dev->post_commit_list);
4855 : }
4856 :
4857 0 : btrfs_destroy_delayed_refs(cur_trans, fs_info);
4858 :
4859 0 : cur_trans->state = TRANS_STATE_COMMIT_START;
4860 0 : wake_up(&fs_info->transaction_blocked_wait);
4861 :
4862 0 : cur_trans->state = TRANS_STATE_UNBLOCKED;
4863 0 : wake_up(&fs_info->transaction_wait);
4864 :
4865 0 : btrfs_destroy_delayed_inodes(fs_info);
4866 :
4867 0 : btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,
4868 : EXTENT_DIRTY);
4869 0 : btrfs_destroy_pinned_extent(fs_info, &cur_trans->pinned_extents);
4870 :
4871 0 : cur_trans->state =TRANS_STATE_COMPLETED;
4872 0 : wake_up(&cur_trans->commit_wait);
4873 0 : }
4874 :
4875 0 : static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
4876 : {
4877 0 : struct btrfs_transaction *t;
4878 :
4879 0 : mutex_lock(&fs_info->transaction_kthread_mutex);
4880 :
4881 0 : spin_lock(&fs_info->trans_lock);
4882 0 : while (!list_empty(&fs_info->trans_list)) {
4883 0 : t = list_first_entry(&fs_info->trans_list,
4884 : struct btrfs_transaction, list);
4885 0 : if (t->state >= TRANS_STATE_COMMIT_START) {
4886 0 : refcount_inc(&t->use_count);
4887 0 : spin_unlock(&fs_info->trans_lock);
4888 0 : btrfs_wait_for_commit(fs_info, t->transid);
4889 0 : btrfs_put_transaction(t);
4890 0 : spin_lock(&fs_info->trans_lock);
4891 0 : continue;
4892 : }
4893 0 : if (t == fs_info->running_transaction) {
4894 0 : t->state = TRANS_STATE_COMMIT_DOING;
4895 0 : spin_unlock(&fs_info->trans_lock);
4896 : /*
4897 : * We wait for 0 num_writers since we don't hold a trans
4898 : * handle open currently for this transaction.
4899 : */
4900 0 : wait_event(t->writer_wait,
4901 : atomic_read(&t->num_writers) == 0);
4902 : } else {
4903 0 : spin_unlock(&fs_info->trans_lock);
4904 : }
4905 0 : btrfs_cleanup_one_transaction(t, fs_info);
4906 :
4907 0 : spin_lock(&fs_info->trans_lock);
4908 0 : if (t == fs_info->running_transaction)
4909 0 : fs_info->running_transaction = NULL;
4910 0 : list_del_init(&t->list);
4911 0 : spin_unlock(&fs_info->trans_lock);
4912 :
4913 0 : btrfs_put_transaction(t);
4914 0 : trace_btrfs_transaction_commit(fs_info);
4915 0 : spin_lock(&fs_info->trans_lock);
4916 : }
4917 0 : spin_unlock(&fs_info->trans_lock);
4918 0 : btrfs_destroy_all_ordered_extents(fs_info);
4919 0 : btrfs_destroy_delayed_inodes(fs_info);
4920 0 : btrfs_assert_delayed_root_empty(fs_info);
4921 0 : btrfs_destroy_all_delalloc_inodes(fs_info);
4922 0 : btrfs_drop_all_logs(fs_info);
4923 0 : mutex_unlock(&fs_info->transaction_kthread_mutex);
4924 :
4925 0 : return 0;
4926 : }
4927 :
4928 0 : int btrfs_init_root_free_objectid(struct btrfs_root *root)
4929 : {
4930 0 : struct btrfs_path *path;
4931 0 : int ret;
4932 0 : struct extent_buffer *l;
4933 0 : struct btrfs_key search_key;
4934 0 : struct btrfs_key found_key;
4935 0 : int slot;
4936 :
4937 0 : path = btrfs_alloc_path();
4938 0 : if (!path)
4939 : return -ENOMEM;
4940 :
4941 0 : search_key.objectid = BTRFS_LAST_FREE_OBJECTID;
4942 0 : search_key.type = -1;
4943 0 : search_key.offset = (u64)-1;
4944 0 : ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
4945 0 : if (ret < 0)
4946 0 : goto error;
4947 0 : BUG_ON(ret == 0); /* Corruption */
4948 0 : if (path->slots[0] > 0) {
4949 0 : slot = path->slots[0] - 1;
4950 0 : l = path->nodes[0];
4951 0 : btrfs_item_key_to_cpu(l, &found_key, slot);
4952 0 : root->free_objectid = max_t(u64, found_key.objectid + 1,
4953 : BTRFS_FIRST_FREE_OBJECTID);
4954 : } else {
4955 0 : root->free_objectid = BTRFS_FIRST_FREE_OBJECTID;
4956 : }
4957 : ret = 0;
4958 0 : error:
4959 0 : btrfs_free_path(path);
4960 0 : return ret;
4961 : }
4962 :
4963 0 : int btrfs_get_free_objectid(struct btrfs_root *root, u64 *objectid)
4964 : {
4965 0 : int ret;
4966 0 : mutex_lock(&root->objectid_mutex);
4967 :
4968 0 : if (unlikely(root->free_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
4969 0 : btrfs_warn(root->fs_info,
4970 : "the objectid of root %llu reaches its highest value",
4971 : root->root_key.objectid);
4972 0 : ret = -ENOSPC;
4973 0 : goto out;
4974 : }
4975 :
4976 0 : *objectid = root->free_objectid++;
4977 0 : ret = 0;
4978 0 : out:
4979 0 : mutex_unlock(&root->objectid_mutex);
4980 0 : return ret;
4981 : }
|
