GNU Linux-libre 4.9.284-gnu1
[releases.git] / fs / btrfs / disk-io.c
1 /*
2  * Copyright (C) 2007 Oracle.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18
19 #include <linux/fs.h>
20 #include <linux/blkdev.h>
21 #include <linux/scatterlist.h>
22 #include <linux/swap.h>
23 #include <linux/radix-tree.h>
24 #include <linux/writeback.h>
25 #include <linux/buffer_head.h>
26 #include <linux/workqueue.h>
27 #include <linux/kthread.h>
28 #include <linux/slab.h>
29 #include <linux/migrate.h>
30 #include <linux/ratelimit.h>
31 #include <linux/uuid.h>
32 #include <linux/semaphore.h>
33 #include <asm/unaligned.h>
34 #include "ctree.h"
35 #include "disk-io.h"
36 #include "hash.h"
37 #include "transaction.h"
38 #include "btrfs_inode.h"
39 #include "volumes.h"
40 #include "print-tree.h"
41 #include "locking.h"
42 #include "tree-log.h"
43 #include "free-space-cache.h"
44 #include "free-space-tree.h"
45 #include "inode-map.h"
46 #include "check-integrity.h"
47 #include "rcu-string.h"
48 #include "dev-replace.h"
49 #include "raid56.h"
50 #include "sysfs.h"
51 #include "qgroup.h"
52 #include "compression.h"
53 #include "tree-checker.h"
54
55 #ifdef CONFIG_X86
56 #include <asm/cpufeature.h>
57 #endif
58
59 #define BTRFS_SUPER_FLAG_SUPP   (BTRFS_HEADER_FLAG_WRITTEN |\
60                                  BTRFS_HEADER_FLAG_RELOC |\
61                                  BTRFS_SUPER_FLAG_ERROR |\
62                                  BTRFS_SUPER_FLAG_SEEDING |\
63                                  BTRFS_SUPER_FLAG_METADUMP |\
64                                  BTRFS_SUPER_FLAG_METADUMP_V2)
65
66 static const struct extent_io_ops btree_extent_io_ops;
67 static void end_workqueue_fn(struct btrfs_work *work);
68 static void free_fs_root(struct btrfs_root *root);
69 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
70                                     int read_only);
71 static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
72 static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
73                                       struct btrfs_root *root);
74 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
75 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
76                                         struct extent_io_tree *dirty_pages,
77                                         int mark);
78 static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
79                                        struct extent_io_tree *pinned_extents);
80 static int btrfs_cleanup_transaction(struct btrfs_root *root);
81 static void btrfs_error_commit_super(struct btrfs_root *root);
82
83 /*
84  * btrfs_end_io_wq structs are used to do processing in task context when an IO
85  * is complete.  This is used during reads to verify checksums, and it is used
86  * by writes to insert metadata for new file extents after IO is complete.
87  */
88 struct btrfs_end_io_wq {
89         struct bio *bio;
90         bio_end_io_t *end_io;
91         void *private;
92         struct btrfs_fs_info *info;
93         int error;
94         enum btrfs_wq_endio_type metadata;
95         struct list_head list;
96         struct btrfs_work work;
97 };
98
99 static struct kmem_cache *btrfs_end_io_wq_cache;
100
101 int __init btrfs_end_io_wq_init(void)
102 {
103         btrfs_end_io_wq_cache = kmem_cache_create("btrfs_end_io_wq",
104                                         sizeof(struct btrfs_end_io_wq),
105                                         0,
106                                         SLAB_MEM_SPREAD,
107                                         NULL);
108         if (!btrfs_end_io_wq_cache)
109                 return -ENOMEM;
110         return 0;
111 }
112
113 void btrfs_end_io_wq_exit(void)
114 {
115         kmem_cache_destroy(btrfs_end_io_wq_cache);
116 }
117
118 /*
119  * async submit bios are used to offload expensive checksumming
120  * onto the worker threads.  They checksum file and metadata bios
121  * just before they are sent down the IO stack.
122  */
123 struct async_submit_bio {
124         struct inode *inode;
125         struct bio *bio;
126         struct list_head list;
127         extent_submit_bio_hook_t *submit_bio_start;
128         extent_submit_bio_hook_t *submit_bio_done;
129         int mirror_num;
130         unsigned long bio_flags;
131         /*
132          * bio_offset is optional, can be used if the pages in the bio
133          * can't tell us where in the file the bio should go
134          */
135         u64 bio_offset;
136         struct btrfs_work work;
137         int error;
138 };
139
140 /*
141  * Lockdep class keys for extent_buffer->lock's in this root.  For a given
142  * eb, the lockdep key is determined by the btrfs_root it belongs to and
143  * the level the eb occupies in the tree.
144  *
145  * Different roots are used for different purposes and may nest inside each
146  * other and they require separate keysets.  As lockdep keys should be
147  * static, assign keysets according to the purpose of the root as indicated
148  * by btrfs_root->objectid.  This ensures that all special purpose roots
149  * have separate keysets.
150  *
151  * Lock-nesting across peer nodes is always done with the immediate parent
152  * node locked thus preventing deadlock.  As lockdep doesn't know this, use
153  * subclass to avoid triggering lockdep warning in such cases.
154  *
155  * The key is set by the readpage_end_io_hook after the buffer has passed
156  * csum validation but before the pages are unlocked.  It is also set by
157  * btrfs_init_new_buffer on freshly allocated blocks.
158  *
159  * We also add a check to make sure the highest level of the tree is the
160  * same as our lockdep setup here.  If BTRFS_MAX_LEVEL changes, this code
161  * needs update as well.
162  */
163 #ifdef CONFIG_DEBUG_LOCK_ALLOC
164 # if BTRFS_MAX_LEVEL != 8
165 #  error
166 # endif
167
168 static struct btrfs_lockdep_keyset {
169         u64                     id;             /* root objectid */
170         const char              *name_stem;     /* lock name stem */
171         char                    names[BTRFS_MAX_LEVEL + 1][20];
172         struct lock_class_key   keys[BTRFS_MAX_LEVEL + 1];
173 } btrfs_lockdep_keysets[] = {
174         { .id = BTRFS_ROOT_TREE_OBJECTID,       .name_stem = "root"     },
175         { .id = BTRFS_EXTENT_TREE_OBJECTID,     .name_stem = "extent"   },
176         { .id = BTRFS_CHUNK_TREE_OBJECTID,      .name_stem = "chunk"    },
177         { .id = BTRFS_DEV_TREE_OBJECTID,        .name_stem = "dev"      },
178         { .id = BTRFS_FS_TREE_OBJECTID,         .name_stem = "fs"       },
179         { .id = BTRFS_CSUM_TREE_OBJECTID,       .name_stem = "csum"     },
180         { .id = BTRFS_QUOTA_TREE_OBJECTID,      .name_stem = "quota"    },
181         { .id = BTRFS_TREE_LOG_OBJECTID,        .name_stem = "log"      },
182         { .id = BTRFS_TREE_RELOC_OBJECTID,      .name_stem = "treloc"   },
183         { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc"   },
184         { .id = BTRFS_UUID_TREE_OBJECTID,       .name_stem = "uuid"     },
185         { .id = BTRFS_FREE_SPACE_TREE_OBJECTID, .name_stem = "free-space" },
186         { .id = 0,                              .name_stem = "tree"     },
187 };
188
189 void __init btrfs_init_lockdep(void)
190 {
191         int i, j;
192
193         /* initialize lockdep class names */
194         for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
195                 struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];
196
197                 for (j = 0; j < ARRAY_SIZE(ks->names); j++)
198                         snprintf(ks->names[j], sizeof(ks->names[j]),
199                                  "btrfs-%s-%02d", ks->name_stem, j);
200         }
201 }
202
203 void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
204                                     int level)
205 {
206         struct btrfs_lockdep_keyset *ks;
207
208         BUG_ON(level >= ARRAY_SIZE(ks->keys));
209
210         /* find the matching keyset, id 0 is the default entry */
211         for (ks = btrfs_lockdep_keysets; ks->id; ks++)
212                 if (ks->id == objectid)
213                         break;
214
215         lockdep_set_class_and_name(&eb->lock,
216                                    &ks->keys[level], ks->names[level]);
217 }
218
219 #endif
220
221 /*
222  * extents on the btree inode are pretty simple, there's one extent
223  * that covers the entire device
224  */
225 static struct extent_map *btree_get_extent(struct inode *inode,
226                 struct page *page, size_t pg_offset, u64 start, u64 len,
227                 int create)
228 {
229         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
230         struct extent_map *em;
231         int ret;
232
233         read_lock(&em_tree->lock);
234         em = lookup_extent_mapping(em_tree, start, len);
235         if (em) {
236                 em->bdev =
237                         BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
238                 read_unlock(&em_tree->lock);
239                 goto out;
240         }
241         read_unlock(&em_tree->lock);
242
243         em = alloc_extent_map();
244         if (!em) {
245                 em = ERR_PTR(-ENOMEM);
246                 goto out;
247         }
248         em->start = 0;
249         em->len = (u64)-1;
250         em->block_len = (u64)-1;
251         em->block_start = 0;
252         em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
253
254         write_lock(&em_tree->lock);
255         ret = add_extent_mapping(em_tree, em, 0);
256         if (ret == -EEXIST) {
257                 free_extent_map(em);
258                 em = lookup_extent_mapping(em_tree, start, len);
259                 if (!em)
260                         em = ERR_PTR(-EIO);
261         } else if (ret) {
262                 free_extent_map(em);
263                 em = ERR_PTR(ret);
264         }
265         write_unlock(&em_tree->lock);
266
267 out:
268         return em;
269 }
270
271 u32 btrfs_csum_data(char *data, u32 seed, size_t len)
272 {
273         return btrfs_crc32c(seed, data, len);
274 }
275
276 void btrfs_csum_final(u32 crc, char *result)
277 {
278         put_unaligned_le32(~crc, result);
279 }
280
281 /*
282  * compute the csum for a btree block, and either verify it or write it
283  * into the csum field of the block.
284  */
285 static int csum_tree_block(struct btrfs_fs_info *fs_info,
286                            struct extent_buffer *buf,
287                            int verify)
288 {
289         u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
290         char *result = NULL;
291         unsigned long len;
292         unsigned long cur_len;
293         unsigned long offset = BTRFS_CSUM_SIZE;
294         char *kaddr;
295         unsigned long map_start;
296         unsigned long map_len;
297         int err;
298         u32 crc = ~(u32)0;
299         unsigned long inline_result;
300
301         len = buf->len - offset;
302         while (len > 0) {
303                 err = map_private_extent_buffer(buf, offset, 32,
304                                         &kaddr, &map_start, &map_len);
305                 if (err)
306                         return err;
307                 cur_len = min(len, map_len - (offset - map_start));
308                 crc = btrfs_csum_data(kaddr + offset - map_start,
309                                       crc, cur_len);
310                 len -= cur_len;
311                 offset += cur_len;
312         }
313         if (csum_size > sizeof(inline_result)) {
314                 result = kzalloc(csum_size, GFP_NOFS);
315                 if (!result)
316                         return -ENOMEM;
317         } else {
318                 result = (char *)&inline_result;
319         }
320
321         btrfs_csum_final(crc, result);
322
323         if (verify) {
324                 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
325                         u32 val;
326                         u32 found = 0;
327                         memcpy(&found, result, csum_size);
328
329                         read_extent_buffer(buf, &val, 0, csum_size);
330                         btrfs_warn_rl(fs_info,
331                                 "%s checksum verify failed on %llu wanted %X found %X level %d",
332                                 fs_info->sb->s_id, buf->start,
333                                 val, found, btrfs_header_level(buf));
334                         if (result != (char *)&inline_result)
335                                 kfree(result);
336                         return -EUCLEAN;
337                 }
338         } else {
339                 write_extent_buffer(buf, result, 0, csum_size);
340         }
341         if (result != (char *)&inline_result)
342                 kfree(result);
343         return 0;
344 }
345
346 /*
347  * we can't consider a given block up to date unless the transid of the
348  * block matches the transid in the parent node's pointer.  This is how we
349  * detect blocks that either didn't get written at all or got written
350  * in the wrong place.
351  */
352 static int verify_parent_transid(struct extent_io_tree *io_tree,
353                                  struct extent_buffer *eb, u64 parent_transid,
354                                  int atomic)
355 {
356         struct extent_state *cached_state = NULL;
357         int ret;
358         bool need_lock = (current->journal_info == BTRFS_SEND_TRANS_STUB);
359
360         if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
361                 return 0;
362
363         if (atomic)
364                 return -EAGAIN;
365
366         if (need_lock) {
367                 btrfs_tree_read_lock(eb);
368                 btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
369         }
370
371         lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
372                          &cached_state);
373         if (extent_buffer_uptodate(eb) &&
374             btrfs_header_generation(eb) == parent_transid) {
375                 ret = 0;
376                 goto out;
377         }
378         btrfs_err_rl(eb->fs_info,
379                 "parent transid verify failed on %llu wanted %llu found %llu",
380                         eb->start,
381                         parent_transid, btrfs_header_generation(eb));
382         ret = 1;
383
384         /*
385          * Things reading via commit roots that don't have normal protection,
386          * like send, can have a really old block in cache that may point at a
387          * block that has been freed and re-allocated.  So don't clear uptodate
388          * if we find an eb that is under IO (dirty/writeback) because we could
389          * end up reading in the stale data and then writing it back out and
390          * making everybody very sad.
391          */
392         if (!extent_buffer_under_io(eb))
393                 clear_extent_buffer_uptodate(eb);
394 out:
395         unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
396                              &cached_state, GFP_NOFS);
397         if (need_lock)
398                 btrfs_tree_read_unlock_blocking(eb);
399         return ret;
400 }
401
402 /*
403  * Return 0 if the superblock checksum type matches the checksum value of that
404  * algorithm. Pass the raw disk superblock data.
405  */
406 static int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
407                                   char *raw_disk_sb)
408 {
409         struct btrfs_super_block *disk_sb =
410                 (struct btrfs_super_block *)raw_disk_sb;
411         u16 csum_type = btrfs_super_csum_type(disk_sb);
412         int ret = 0;
413
414         if (csum_type == BTRFS_CSUM_TYPE_CRC32) {
415                 u32 crc = ~(u32)0;
416                 const int csum_size = sizeof(crc);
417                 char result[csum_size];
418
419                 /*
420                  * The super_block structure does not span the whole
421                  * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space
422                  * is filled with zeros and is included in the checksum.
423                  */
424                 crc = btrfs_csum_data(raw_disk_sb + BTRFS_CSUM_SIZE,
425                                 crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
426                 btrfs_csum_final(crc, result);
427
428                 if (memcmp(raw_disk_sb, result, csum_size))
429                         ret = 1;
430         }
431
432         if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
433                 btrfs_err(fs_info, "unsupported checksum algorithm %u",
434                                 csum_type);
435                 ret = 1;
436         }
437
438         return ret;
439 }
440
441 /*
442  * helper to read a given tree block, doing retries as required when
443  * the checksums don't match and we have alternate mirrors to try.
444  */
445 static int btree_read_extent_buffer_pages(struct btrfs_root *root,
446                                           struct extent_buffer *eb,
447                                           u64 parent_transid)
448 {
449         struct extent_io_tree *io_tree;
450         int failed = 0;
451         int ret;
452         int num_copies = 0;
453         int mirror_num = 0;
454         int failed_mirror = 0;
455
456         io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
457         while (1) {
458                 clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
459                 ret = read_extent_buffer_pages(io_tree, eb, WAIT_COMPLETE,
460                                                btree_get_extent, mirror_num);
461                 if (!ret) {
462                         if (!verify_parent_transid(io_tree, eb,
463                                                    parent_transid, 0))
464                                 break;
465                         else
466                                 ret = -EIO;
467                 }
468
469                 num_copies = btrfs_num_copies(root->fs_info,
470                                               eb->start, eb->len);
471                 if (num_copies == 1)
472                         break;
473
474                 if (!failed_mirror) {
475                         failed = 1;
476                         failed_mirror = eb->read_mirror;
477                 }
478
479                 mirror_num++;
480                 if (mirror_num == failed_mirror)
481                         mirror_num++;
482
483                 if (mirror_num > num_copies)
484                         break;
485         }
486
487         if (failed && !ret && failed_mirror)
488                 repair_eb_io_failure(root, eb, failed_mirror);
489
490         return ret;
491 }
492
493 /*
494  * checksum a dirty tree block before IO.  This has extra checks to make sure
495  * we only fill in the checksum field in the first page of a multi-page block
496  */
497
498 static int csum_dirty_buffer(struct btrfs_fs_info *fs_info, struct page *page)
499 {
500         u64 start = page_offset(page);
501         u64 found_start;
502         struct extent_buffer *eb;
503
504         eb = (struct extent_buffer *)page->private;
505         if (page != eb->pages[0])
506                 return 0;
507
508         found_start = btrfs_header_bytenr(eb);
509         /*
510          * Please do not consolidate these warnings into a single if.
511          * It is useful to know what went wrong.
512          */
513         if (WARN_ON(found_start != start))
514                 return -EUCLEAN;
515         if (WARN_ON(!PageUptodate(page)))
516                 return -EUCLEAN;
517
518         ASSERT(memcmp_extent_buffer(eb, fs_info->fsid,
519                         btrfs_header_fsid(), BTRFS_FSID_SIZE) == 0);
520
521         return csum_tree_block(fs_info, eb, 0);
522 }
523
524 static int check_tree_block_fsid(struct btrfs_fs_info *fs_info,
525                                  struct extent_buffer *eb)
526 {
527         struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
528         u8 fsid[BTRFS_UUID_SIZE];
529         int ret = 1;
530
531         read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
532         while (fs_devices) {
533                 if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
534                         ret = 0;
535                         break;
536                 }
537                 fs_devices = fs_devices->seed;
538         }
539         return ret;
540 }
541
542 static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
543                                       u64 phy_offset, struct page *page,
544                                       u64 start, u64 end, int mirror)
545 {
546         u64 found_start;
547         int found_level;
548         struct extent_buffer *eb;
549         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
550         struct btrfs_fs_info *fs_info = root->fs_info;
551         int ret = 0;
552         int reads_done;
553
554         if (!page->private)
555                 goto out;
556
557         eb = (struct extent_buffer *)page->private;
558
559         /* the pending IO might have been the only thing that kept this buffer
560          * in memory.  Make sure we have a ref for all this other checks
561          */
562         extent_buffer_get(eb);
563
564         reads_done = atomic_dec_and_test(&eb->io_pages);
565         if (!reads_done)
566                 goto err;
567
568         eb->read_mirror = mirror;
569         if (test_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags)) {
570                 ret = -EIO;
571                 goto err;
572         }
573
574         found_start = btrfs_header_bytenr(eb);
575         if (found_start != eb->start) {
576                 btrfs_err_rl(fs_info, "bad tree block start %llu %llu",
577                              found_start, eb->start);
578                 ret = -EIO;
579                 goto err;
580         }
581         if (check_tree_block_fsid(fs_info, eb)) {
582                 btrfs_err_rl(fs_info, "bad fsid on block %llu",
583                              eb->start);
584                 ret = -EIO;
585                 goto err;
586         }
587         found_level = btrfs_header_level(eb);
588         if (found_level >= BTRFS_MAX_LEVEL) {
589                 btrfs_err(fs_info, "bad tree block level %d",
590                           (int)btrfs_header_level(eb));
591                 ret = -EIO;
592                 goto err;
593         }
594
595         btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
596                                        eb, found_level);
597
598         ret = csum_tree_block(fs_info, eb, 1);
599         if (ret)
600                 goto err;
601
602         /*
603          * If this is a leaf block and it is corrupt, set the corrupt bit so
604          * that we don't try and read the other copies of this block, just
605          * return -EIO.
606          */
607         if (found_level == 0 && btrfs_check_leaf_full(root, eb)) {
608                 set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
609                 ret = -EIO;
610         }
611
612         if (found_level > 0 && btrfs_check_node(root, eb))
613                 ret = -EIO;
614
615         if (!ret)
616                 set_extent_buffer_uptodate(eb);
617 err:
618         if (reads_done &&
619             test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
620                 btree_readahead_hook(fs_info, eb, eb->start, ret);
621
622         if (ret) {
623                 /*
624                  * our io error hook is going to dec the io pages
625                  * again, we have to make sure it has something
626                  * to decrement
627                  */
628                 atomic_inc(&eb->io_pages);
629                 clear_extent_buffer_uptodate(eb);
630         }
631         free_extent_buffer(eb);
632 out:
633         return ret;
634 }
635
636 static int btree_io_failed_hook(struct page *page, int failed_mirror)
637 {
638         struct extent_buffer *eb;
639
640         eb = (struct extent_buffer *)page->private;
641         set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
642         eb->read_mirror = failed_mirror;
643         atomic_dec(&eb->io_pages);
644         if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
645                 btree_readahead_hook(eb->fs_info, eb, eb->start, -EIO);
646         return -EIO;    /* we fixed nothing */
647 }
648
649 static void end_workqueue_bio(struct bio *bio)
650 {
651         struct btrfs_end_io_wq *end_io_wq = bio->bi_private;
652         struct btrfs_fs_info *fs_info;
653         struct btrfs_workqueue *wq;
654         btrfs_work_func_t func;
655
656         fs_info = end_io_wq->info;
657         end_io_wq->error = bio->bi_error;
658
659         if (bio_op(bio) == REQ_OP_WRITE) {
660                 if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
661                         wq = fs_info->endio_meta_write_workers;
662                         func = btrfs_endio_meta_write_helper;
663                 } else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE) {
664                         wq = fs_info->endio_freespace_worker;
665                         func = btrfs_freespace_write_helper;
666                 } else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56) {
667                         wq = fs_info->endio_raid56_workers;
668                         func = btrfs_endio_raid56_helper;
669                 } else {
670                         wq = fs_info->endio_write_workers;
671                         func = btrfs_endio_write_helper;
672                 }
673         } else {
674                 if (unlikely(end_io_wq->metadata ==
675                              BTRFS_WQ_ENDIO_DIO_REPAIR)) {
676                         wq = fs_info->endio_repair_workers;
677                         func = btrfs_endio_repair_helper;
678                 } else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56) {
679                         wq = fs_info->endio_raid56_workers;
680                         func = btrfs_endio_raid56_helper;
681                 } else if (end_io_wq->metadata) {
682                         wq = fs_info->endio_meta_workers;
683                         func = btrfs_endio_meta_helper;
684                 } else {
685                         wq = fs_info->endio_workers;
686                         func = btrfs_endio_helper;
687                 }
688         }
689
690         btrfs_init_work(&end_io_wq->work, func, end_workqueue_fn, NULL, NULL);
691         btrfs_queue_work(wq, &end_io_wq->work);
692 }
693
694 int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
695                         enum btrfs_wq_endio_type metadata)
696 {
697         struct btrfs_end_io_wq *end_io_wq;
698
699         end_io_wq = kmem_cache_alloc(btrfs_end_io_wq_cache, GFP_NOFS);
700         if (!end_io_wq)
701                 return -ENOMEM;
702
703         end_io_wq->private = bio->bi_private;
704         end_io_wq->end_io = bio->bi_end_io;
705         end_io_wq->info = info;
706         end_io_wq->error = 0;
707         end_io_wq->bio = bio;
708         end_io_wq->metadata = metadata;
709
710         bio->bi_private = end_io_wq;
711         bio->bi_end_io = end_workqueue_bio;
712         return 0;
713 }
714
715 unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
716 {
717         unsigned long limit = min_t(unsigned long,
718                                     info->thread_pool_size,
719                                     info->fs_devices->open_devices);
720         return 256 * limit;
721 }
722
723 static void run_one_async_start(struct btrfs_work *work)
724 {
725         struct async_submit_bio *async;
726         int ret;
727
728         async = container_of(work, struct  async_submit_bio, work);
729         ret = async->submit_bio_start(async->inode, async->bio,
730                                       async->mirror_num, async->bio_flags,
731                                       async->bio_offset);
732         if (ret)
733                 async->error = ret;
734 }
735
736 static void run_one_async_done(struct btrfs_work *work)
737 {
738         struct btrfs_fs_info *fs_info;
739         struct async_submit_bio *async;
740         int limit;
741
742         async = container_of(work, struct  async_submit_bio, work);
743         fs_info = BTRFS_I(async->inode)->root->fs_info;
744
745         limit = btrfs_async_submit_limit(fs_info);
746         limit = limit * 2 / 3;
747
748         /*
749          * atomic_dec_return implies a barrier for waitqueue_active
750          */
751         if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
752             waitqueue_active(&fs_info->async_submit_wait))
753                 wake_up(&fs_info->async_submit_wait);
754
755         /* If an error occurred we just want to clean up the bio and move on */
756         if (async->error) {
757                 async->bio->bi_error = async->error;
758                 bio_endio(async->bio);
759                 return;
760         }
761
762         async->submit_bio_done(async->inode, async->bio, async->mirror_num,
763                                async->bio_flags, async->bio_offset);
764 }
765
766 static void run_one_async_free(struct btrfs_work *work)
767 {
768         struct async_submit_bio *async;
769
770         async = container_of(work, struct  async_submit_bio, work);
771         kfree(async);
772 }
773
774 int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
775                         struct bio *bio, int mirror_num,
776                         unsigned long bio_flags,
777                         u64 bio_offset,
778                         extent_submit_bio_hook_t *submit_bio_start,
779                         extent_submit_bio_hook_t *submit_bio_done)
780 {
781         struct async_submit_bio *async;
782
783         async = kmalloc(sizeof(*async), GFP_NOFS);
784         if (!async)
785                 return -ENOMEM;
786
787         async->inode = inode;
788         async->bio = bio;
789         async->mirror_num = mirror_num;
790         async->submit_bio_start = submit_bio_start;
791         async->submit_bio_done = submit_bio_done;
792
793         btrfs_init_work(&async->work, btrfs_worker_helper, run_one_async_start,
794                         run_one_async_done, run_one_async_free);
795
796         async->bio_flags = bio_flags;
797         async->bio_offset = bio_offset;
798
799         async->error = 0;
800
801         atomic_inc(&fs_info->nr_async_submits);
802
803         if (bio->bi_opf & REQ_SYNC)
804                 btrfs_set_work_high_priority(&async->work);
805
806         btrfs_queue_work(fs_info->workers, &async->work);
807
808         while (atomic_read(&fs_info->async_submit_draining) &&
809               atomic_read(&fs_info->nr_async_submits)) {
810                 wait_event(fs_info->async_submit_wait,
811                            (atomic_read(&fs_info->nr_async_submits) == 0));
812         }
813
814         return 0;
815 }
816
817 static int btree_csum_one_bio(struct bio *bio)
818 {
819         struct bio_vec *bvec;
820         struct btrfs_root *root;
821         int i, ret = 0;
822
823         bio_for_each_segment_all(bvec, bio, i) {
824                 root = BTRFS_I(bvec->bv_page->mapping->host)->root;
825                 ret = csum_dirty_buffer(root->fs_info, bvec->bv_page);
826                 if (ret)
827                         break;
828         }
829
830         return ret;
831 }
832
833 static int __btree_submit_bio_start(struct inode *inode, struct bio *bio,
834                                     int mirror_num, unsigned long bio_flags,
835                                     u64 bio_offset)
836 {
837         /*
838          * when we're called for a write, we're already in the async
839          * submission context.  Just jump into btrfs_map_bio
840          */
841         return btree_csum_one_bio(bio);
842 }
843
844 static int __btree_submit_bio_done(struct inode *inode, struct bio *bio,
845                                  int mirror_num, unsigned long bio_flags,
846                                  u64 bio_offset)
847 {
848         int ret;
849
850         /*
851          * when we're called for a write, we're already in the async
852          * submission context.  Just jump into btrfs_map_bio
853          */
854         ret = btrfs_map_bio(BTRFS_I(inode)->root, bio, mirror_num, 1);
855         if (ret) {
856                 bio->bi_error = ret;
857                 bio_endio(bio);
858         }
859         return ret;
860 }
861
862 static int check_async_write(struct inode *inode, unsigned long bio_flags)
863 {
864         if (bio_flags & EXTENT_BIO_TREE_LOG)
865                 return 0;
866 #ifdef CONFIG_X86
867         if (static_cpu_has(X86_FEATURE_XMM4_2))
868                 return 0;
869 #endif
870         return 1;
871 }
872
873 static int btree_submit_bio_hook(struct inode *inode, struct bio *bio,
874                                  int mirror_num, unsigned long bio_flags,
875                                  u64 bio_offset)
876 {
877         int async = check_async_write(inode, bio_flags);
878         int ret;
879
880         if (bio_op(bio) != REQ_OP_WRITE) {
881                 /*
882                  * called for a read, do the setup so that checksum validation
883                  * can happen in the async kernel threads
884                  */
885                 ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
886                                           bio, BTRFS_WQ_ENDIO_METADATA);
887                 if (ret)
888                         goto out_w_error;
889                 ret = btrfs_map_bio(BTRFS_I(inode)->root, bio, mirror_num, 0);
890         } else if (!async) {
891                 ret = btree_csum_one_bio(bio);
892                 if (ret)
893                         goto out_w_error;
894                 ret = btrfs_map_bio(BTRFS_I(inode)->root, bio, mirror_num, 0);
895         } else {
896                 /*
897                  * kthread helpers are used to submit writes so that
898                  * checksumming can happen in parallel across all CPUs
899                  */
900                 ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
901                                           inode, bio, mirror_num, 0,
902                                           bio_offset,
903                                           __btree_submit_bio_start,
904                                           __btree_submit_bio_done);
905         }
906
907         if (ret)
908                 goto out_w_error;
909         return 0;
910
911 out_w_error:
912         bio->bi_error = ret;
913         bio_endio(bio);
914         return ret;
915 }
916
917 #ifdef CONFIG_MIGRATION
918 static int btree_migratepage(struct address_space *mapping,
919                         struct page *newpage, struct page *page,
920                         enum migrate_mode mode)
921 {
922         /*
923          * we can't safely write a btree page from here,
924          * we haven't done the locking hook
925          */
926         if (PageDirty(page))
927                 return -EAGAIN;
928         /*
929          * Buffers may be managed in a filesystem specific way.
930          * We must have no buffers or drop them.
931          */
932         if (page_has_private(page) &&
933             !try_to_release_page(page, GFP_KERNEL))
934                 return -EAGAIN;
935         return migrate_page(mapping, newpage, page, mode);
936 }
937 #endif
938
939
940 static int btree_writepages(struct address_space *mapping,
941                             struct writeback_control *wbc)
942 {
943         struct btrfs_fs_info *fs_info;
944         int ret;
945
946         if (wbc->sync_mode == WB_SYNC_NONE) {
947
948                 if (wbc->for_kupdate)
949                         return 0;
950
951                 fs_info = BTRFS_I(mapping->host)->root->fs_info;
952                 /* this is a bit racy, but that's ok */
953                 ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
954                                              BTRFS_DIRTY_METADATA_THRESH,
955                                              fs_info->dirty_metadata_batch);
956                 if (ret < 0)
957                         return 0;
958         }
959         return btree_write_cache_pages(mapping, wbc);
960 }
961
962 static int btree_readpage(struct file *file, struct page *page)
963 {
964         struct extent_io_tree *tree;
965         tree = &BTRFS_I(page->mapping->host)->io_tree;
966         return extent_read_full_page(tree, page, btree_get_extent, 0);
967 }
968
969 static int btree_releasepage(struct page *page, gfp_t gfp_flags)
970 {
971         if (PageWriteback(page) || PageDirty(page))
972                 return 0;
973
974         return try_release_extent_buffer(page);
975 }
976
977 static void btree_invalidatepage(struct page *page, unsigned int offset,
978                                  unsigned int length)
979 {
980         struct extent_io_tree *tree;
981         tree = &BTRFS_I(page->mapping->host)->io_tree;
982         extent_invalidatepage(tree, page, offset);
983         btree_releasepage(page, GFP_NOFS);
984         if (PagePrivate(page)) {
985                 btrfs_warn(BTRFS_I(page->mapping->host)->root->fs_info,
986                            "page private not zero on page %llu",
987                            (unsigned long long)page_offset(page));
988                 ClearPagePrivate(page);
989                 set_page_private(page, 0);
990                 put_page(page);
991         }
992 }
993
994 static int btree_set_page_dirty(struct page *page)
995 {
996 #ifdef DEBUG
997         struct extent_buffer *eb;
998
999         BUG_ON(!PagePrivate(page));
1000         eb = (struct extent_buffer *)page->private;
1001         BUG_ON(!eb);
1002         BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
1003         BUG_ON(!atomic_read(&eb->refs));
1004         btrfs_assert_tree_locked(eb);
1005 #endif
1006         return __set_page_dirty_nobuffers(page);
1007 }
1008
1009 static const struct address_space_operations btree_aops = {
1010         .readpage       = btree_readpage,
1011         .writepages     = btree_writepages,
1012         .releasepage    = btree_releasepage,
1013         .invalidatepage = btree_invalidatepage,
1014 #ifdef CONFIG_MIGRATION
1015         .migratepage    = btree_migratepage,
1016 #endif
1017         .set_page_dirty = btree_set_page_dirty,
1018 };
1019
1020 void readahead_tree_block(struct btrfs_root *root, u64 bytenr)
1021 {
1022         struct extent_buffer *buf = NULL;
1023         struct inode *btree_inode = root->fs_info->btree_inode;
1024
1025         buf = btrfs_find_create_tree_block(root, bytenr);
1026         if (IS_ERR(buf))
1027                 return;
1028         read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1029                                  buf, WAIT_NONE, btree_get_extent, 0);
1030         free_extent_buffer(buf);
1031 }
1032
1033 int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr,
1034                          int mirror_num, struct extent_buffer **eb)
1035 {
1036         struct extent_buffer *buf = NULL;
1037         struct inode *btree_inode = root->fs_info->btree_inode;
1038         struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
1039         int ret;
1040
1041         buf = btrfs_find_create_tree_block(root, bytenr);
1042         if (IS_ERR(buf))
1043                 return 0;
1044
1045         set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);
1046
1047         ret = read_extent_buffer_pages(io_tree, buf, WAIT_PAGE_LOCK,
1048                                        btree_get_extent, mirror_num);
1049         if (ret) {
1050                 free_extent_buffer(buf);
1051                 return ret;
1052         }
1053
1054         if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
1055                 free_extent_buffer(buf);
1056                 return -EIO;
1057         } else if (extent_buffer_uptodate(buf)) {
1058                 *eb = buf;
1059         } else {
1060                 free_extent_buffer(buf);
1061         }
1062         return 0;
1063 }
1064
1065 struct extent_buffer *btrfs_find_tree_block(struct btrfs_fs_info *fs_info,
1066                                             u64 bytenr)
1067 {
1068         return find_extent_buffer(fs_info, bytenr);
1069 }
1070
1071 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
1072                                                  u64 bytenr)
1073 {
1074         if (btrfs_is_testing(root->fs_info))
1075                 return alloc_test_extent_buffer(root->fs_info, bytenr,
1076                                 root->nodesize);
1077         return alloc_extent_buffer(root->fs_info, bytenr);
1078 }
1079
1080
1081 int btrfs_write_tree_block(struct extent_buffer *buf)
1082 {
1083         return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1084                                         buf->start + buf->len - 1);
1085 }
1086
1087 int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
1088 {
1089         return filemap_fdatawait_range(buf->pages[0]->mapping,
1090                                        buf->start, buf->start + buf->len - 1);
1091 }
1092
1093 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1094                                       u64 parent_transid)
1095 {
1096         struct extent_buffer *buf = NULL;
1097         int ret;
1098
1099         buf = btrfs_find_create_tree_block(root, bytenr);
1100         if (IS_ERR(buf))
1101                 return buf;
1102
1103         ret = btree_read_extent_buffer_pages(root, buf, parent_transid);
1104         if (ret) {
1105                 free_extent_buffer(buf);
1106                 return ERR_PTR(ret);
1107         }
1108         return buf;
1109
1110 }
1111
1112 void clean_tree_block(struct btrfs_trans_handle *trans,
1113                       struct btrfs_fs_info *fs_info,
1114                       struct extent_buffer *buf)
1115 {
1116         if (btrfs_header_generation(buf) ==
1117             fs_info->running_transaction->transid) {
1118                 btrfs_assert_tree_locked(buf);
1119
1120                 if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1121                         __percpu_counter_add(&fs_info->dirty_metadata_bytes,
1122                                              -buf->len,
1123                                              fs_info->dirty_metadata_batch);
1124                         /* ugh, clear_extent_buffer_dirty needs to lock the page */
1125                         btrfs_set_lock_blocking(buf);
1126                         clear_extent_buffer_dirty(buf);
1127                 }
1128         }
1129 }
1130
1131 static struct btrfs_subvolume_writers *btrfs_alloc_subvolume_writers(void)
1132 {
1133         struct btrfs_subvolume_writers *writers;
1134         int ret;
1135
1136         writers = kmalloc(sizeof(*writers), GFP_NOFS);
1137         if (!writers)
1138                 return ERR_PTR(-ENOMEM);
1139
1140         ret = percpu_counter_init(&writers->counter, 0, GFP_NOFS);
1141         if (ret < 0) {
1142                 kfree(writers);
1143                 return ERR_PTR(ret);
1144         }
1145
1146         init_waitqueue_head(&writers->wait);
1147         return writers;
1148 }
1149
1150 static void
1151 btrfs_free_subvolume_writers(struct btrfs_subvolume_writers *writers)
1152 {
1153         percpu_counter_destroy(&writers->counter);
1154         kfree(writers);
1155 }
1156
1157 static void __setup_root(u32 nodesize, u32 sectorsize, u32 stripesize,
1158                          struct btrfs_root *root, struct btrfs_fs_info *fs_info,
1159                          u64 objectid)
1160 {
1161         bool dummy = test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
1162         root->node = NULL;
1163         root->commit_root = NULL;
1164         root->sectorsize = sectorsize;
1165         root->nodesize = nodesize;
1166         root->stripesize = stripesize;
1167         root->state = 0;
1168         root->orphan_cleanup_state = 0;
1169
1170         root->objectid = objectid;
1171         root->last_trans = 0;
1172         root->highest_objectid = 0;
1173         root->nr_delalloc_inodes = 0;
1174         root->nr_ordered_extents = 0;
1175         root->name = NULL;
1176         root->inode_tree = RB_ROOT;
1177         INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1178         root->block_rsv = NULL;
1179         root->orphan_block_rsv = NULL;
1180
1181         INIT_LIST_HEAD(&root->dirty_list);
1182         INIT_LIST_HEAD(&root->root_list);
1183         INIT_LIST_HEAD(&root->delalloc_inodes);
1184         INIT_LIST_HEAD(&root->delalloc_root);
1185         INIT_LIST_HEAD(&root->ordered_extents);
1186         INIT_LIST_HEAD(&root->ordered_root);
1187         INIT_LIST_HEAD(&root->logged_list[0]);
1188         INIT_LIST_HEAD(&root->logged_list[1]);
1189         spin_lock_init(&root->orphan_lock);
1190         spin_lock_init(&root->inode_lock);
1191         spin_lock_init(&root->delalloc_lock);
1192         spin_lock_init(&root->ordered_extent_lock);
1193         spin_lock_init(&root->accounting_lock);
1194         spin_lock_init(&root->log_extents_lock[0]);
1195         spin_lock_init(&root->log_extents_lock[1]);
1196         mutex_init(&root->objectid_mutex);
1197         mutex_init(&root->log_mutex);
1198         mutex_init(&root->ordered_extent_mutex);
1199         mutex_init(&root->delalloc_mutex);
1200         init_waitqueue_head(&root->log_writer_wait);
1201         init_waitqueue_head(&root->log_commit_wait[0]);
1202         init_waitqueue_head(&root->log_commit_wait[1]);
1203         INIT_LIST_HEAD(&root->log_ctxs[0]);
1204         INIT_LIST_HEAD(&root->log_ctxs[1]);
1205         atomic_set(&root->log_commit[0], 0);
1206         atomic_set(&root->log_commit[1], 0);
1207         atomic_set(&root->log_writers, 0);
1208         atomic_set(&root->log_batch, 0);
1209         atomic_set(&root->orphan_inodes, 0);
1210         atomic_set(&root->refs, 1);
1211         atomic_set(&root->will_be_snapshoted, 0);
1212         atomic_set(&root->qgroup_meta_rsv, 0);
1213         root->log_transid = 0;
1214         root->log_transid_committed = -1;
1215         root->last_log_commit = 0;
1216         if (!dummy)
1217                 extent_io_tree_init(&root->dirty_log_pages,
1218                                      fs_info->btree_inode->i_mapping);
1219
1220         memset(&root->root_key, 0, sizeof(root->root_key));
1221         memset(&root->root_item, 0, sizeof(root->root_item));
1222         memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1223         if (!dummy)
1224                 root->defrag_trans_start = fs_info->generation;
1225         else
1226                 root->defrag_trans_start = 0;
1227         root->root_key.objectid = objectid;
1228         root->anon_dev = 0;
1229
1230         spin_lock_init(&root->root_item_lock);
1231 }
1232
1233 static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
1234                 gfp_t flags)
1235 {
1236         struct btrfs_root *root = kzalloc(sizeof(*root), flags);
1237         if (root)
1238                 root->fs_info = fs_info;
1239         return root;
1240 }
1241
1242 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
1243 /* Should only be used by the testing infrastructure */
1244 struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info,
1245                                           u32 sectorsize, u32 nodesize)
1246 {
1247         struct btrfs_root *root;
1248
1249         if (!fs_info)
1250                 return ERR_PTR(-EINVAL);
1251
1252         root = btrfs_alloc_root(fs_info, GFP_KERNEL);
1253         if (!root)
1254                 return ERR_PTR(-ENOMEM);
1255         /* We don't use the stripesize in selftest, set it as sectorsize */
1256         __setup_root(nodesize, sectorsize, sectorsize, root, fs_info,
1257                         BTRFS_ROOT_TREE_OBJECTID);
1258         root->alloc_bytenr = 0;
1259
1260         return root;
1261 }
1262 #endif
1263
1264 struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
1265                                      struct btrfs_fs_info *fs_info,
1266                                      u64 objectid)
1267 {
1268         struct extent_buffer *leaf;
1269         struct btrfs_root *tree_root = fs_info->tree_root;
1270         struct btrfs_root *root;
1271         struct btrfs_key key;
1272         int ret = 0;
1273         uuid_le uuid;
1274
1275         root = btrfs_alloc_root(fs_info, GFP_KERNEL);
1276         if (!root)
1277                 return ERR_PTR(-ENOMEM);
1278
1279         __setup_root(tree_root->nodesize, tree_root->sectorsize,
1280                 tree_root->stripesize, root, fs_info, objectid);
1281         root->root_key.objectid = objectid;
1282         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1283         root->root_key.offset = 0;
1284
1285         leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0);
1286         if (IS_ERR(leaf)) {
1287                 ret = PTR_ERR(leaf);
1288                 leaf = NULL;
1289                 goto fail;
1290         }
1291
1292         memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1293         btrfs_set_header_bytenr(leaf, leaf->start);
1294         btrfs_set_header_generation(leaf, trans->transid);
1295         btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1296         btrfs_set_header_owner(leaf, objectid);
1297         root->node = leaf;
1298
1299         write_extent_buffer(leaf, fs_info->fsid, btrfs_header_fsid(),
1300                             BTRFS_FSID_SIZE);
1301         write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
1302                             btrfs_header_chunk_tree_uuid(leaf),
1303                             BTRFS_UUID_SIZE);
1304         btrfs_mark_buffer_dirty(leaf);
1305
1306         root->commit_root = btrfs_root_node(root);
1307         set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
1308
1309         root->root_item.flags = 0;
1310         root->root_item.byte_limit = 0;
1311         btrfs_set_root_bytenr(&root->root_item, leaf->start);
1312         btrfs_set_root_generation(&root->root_item, trans->transid);
1313         btrfs_set_root_level(&root->root_item, 0);
1314         btrfs_set_root_refs(&root->root_item, 1);
1315         btrfs_set_root_used(&root->root_item, leaf->len);
1316         btrfs_set_root_last_snapshot(&root->root_item, 0);
1317         btrfs_set_root_dirid(&root->root_item, 0);
1318         uuid_le_gen(&uuid);
1319         memcpy(root->root_item.uuid, uuid.b, BTRFS_UUID_SIZE);
1320         root->root_item.drop_level = 0;
1321
1322         key.objectid = objectid;
1323         key.type = BTRFS_ROOT_ITEM_KEY;
1324         key.offset = 0;
1325         ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
1326         if (ret)
1327                 goto fail;
1328
1329         btrfs_tree_unlock(leaf);
1330
1331         return root;
1332
1333 fail:
1334         if (leaf) {
1335                 btrfs_tree_unlock(leaf);
1336                 free_extent_buffer(root->commit_root);
1337                 free_extent_buffer(leaf);
1338         }
1339         kfree(root);
1340
1341         return ERR_PTR(ret);
1342 }
1343
1344 static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
1345                                          struct btrfs_fs_info *fs_info)
1346 {
1347         struct btrfs_root *root;
1348         struct btrfs_root *tree_root = fs_info->tree_root;
1349         struct extent_buffer *leaf;
1350
1351         root = btrfs_alloc_root(fs_info, GFP_NOFS);
1352         if (!root)
1353                 return ERR_PTR(-ENOMEM);
1354
1355         __setup_root(tree_root->nodesize, tree_root->sectorsize,
1356                      tree_root->stripesize, root, fs_info,
1357                      BTRFS_TREE_LOG_OBJECTID);
1358
1359         root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
1360         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1361         root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
1362
1363         /*
1364          * DON'T set REF_COWS for log trees
1365          *
1366          * log trees do not get reference counted because they go away
1367          * before a real commit is actually done.  They do store pointers
1368          * to file data extents, and those reference counts still get
1369          * updated (along with back refs to the log tree).
1370          */
1371
1372         leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
1373                         NULL, 0, 0, 0);
1374         if (IS_ERR(leaf)) {
1375                 kfree(root);
1376                 return ERR_CAST(leaf);
1377         }
1378
1379         memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1380         btrfs_set_header_bytenr(leaf, leaf->start);
1381         btrfs_set_header_generation(leaf, trans->transid);
1382         btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1383         btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
1384         root->node = leaf;
1385
1386         write_extent_buffer(root->node, root->fs_info->fsid,
1387                             btrfs_header_fsid(), BTRFS_FSID_SIZE);
1388         btrfs_mark_buffer_dirty(root->node);
1389         btrfs_tree_unlock(root->node);
1390         return root;
1391 }
1392
1393 int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
1394                              struct btrfs_fs_info *fs_info)
1395 {
1396         struct btrfs_root *log_root;
1397
1398         log_root = alloc_log_tree(trans, fs_info);
1399         if (IS_ERR(log_root))
1400                 return PTR_ERR(log_root);
1401         WARN_ON(fs_info->log_root_tree);
1402         fs_info->log_root_tree = log_root;
1403         return 0;
1404 }
1405
1406 int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
1407                        struct btrfs_root *root)
1408 {
1409         struct btrfs_root *log_root;
1410         struct btrfs_inode_item *inode_item;
1411
1412         log_root = alloc_log_tree(trans, root->fs_info);
1413         if (IS_ERR(log_root))
1414                 return PTR_ERR(log_root);
1415
1416         log_root->last_trans = trans->transid;
1417         log_root->root_key.offset = root->root_key.objectid;
1418
1419         inode_item = &log_root->root_item.inode;
1420         btrfs_set_stack_inode_generation(inode_item, 1);
1421         btrfs_set_stack_inode_size(inode_item, 3);
1422         btrfs_set_stack_inode_nlink(inode_item, 1);
1423         btrfs_set_stack_inode_nbytes(inode_item, root->nodesize);
1424         btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
1425
1426         btrfs_set_root_node(&log_root->root_item, log_root->node);
1427
1428         WARN_ON(root->log_root);
1429         root->log_root = log_root;
1430         root->log_transid = 0;
1431         root->log_transid_committed = -1;
1432         root->last_log_commit = 0;
1433         return 0;
1434 }
1435
1436 static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
1437                                                struct btrfs_key *key)
1438 {
1439         struct btrfs_root *root;
1440         struct btrfs_fs_info *fs_info = tree_root->fs_info;
1441         struct btrfs_path *path;
1442         u64 generation;
1443         int ret;
1444
1445         path = btrfs_alloc_path();
1446         if (!path)
1447                 return ERR_PTR(-ENOMEM);
1448
1449         root = btrfs_alloc_root(fs_info, GFP_NOFS);
1450         if (!root) {
1451                 ret = -ENOMEM;
1452                 goto alloc_fail;
1453         }
1454
1455         __setup_root(tree_root->nodesize, tree_root->sectorsize,
1456                 tree_root->stripesize, root, fs_info, key->objectid);
1457
1458         ret = btrfs_find_root(tree_root, key, path,
1459                               &root->root_item, &root->root_key);
1460         if (ret) {
1461                 if (ret > 0)
1462                         ret = -ENOENT;
1463                 goto find_fail;
1464         }
1465
1466         generation = btrfs_root_generation(&root->root_item);
1467         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1468                                      generation);
1469         if (IS_ERR(root->node)) {
1470                 ret = PTR_ERR(root->node);
1471                 goto find_fail;
1472         } else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
1473                 ret = -EIO;
1474                 free_extent_buffer(root->node);
1475                 goto find_fail;
1476         }
1477         root->commit_root = btrfs_root_node(root);
1478 out:
1479         btrfs_free_path(path);
1480         return root;
1481
1482 find_fail:
1483         kfree(root);
1484 alloc_fail:
1485         root = ERR_PTR(ret);
1486         goto out;
1487 }
1488
1489 struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
1490                                       struct btrfs_key *location)
1491 {
1492         struct btrfs_root *root;
1493
1494         root = btrfs_read_tree_root(tree_root, location);
1495         if (IS_ERR(root))
1496                 return root;
1497
1498         if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
1499                 set_bit(BTRFS_ROOT_REF_COWS, &root->state);
1500                 btrfs_check_and_init_root_item(&root->root_item);
1501         }
1502
1503         return root;
1504 }
1505
1506 int btrfs_init_fs_root(struct btrfs_root *root)
1507 {
1508         int ret;
1509         struct btrfs_subvolume_writers *writers;
1510
1511         root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
1512         root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
1513                                         GFP_NOFS);
1514         if (!root->free_ino_pinned || !root->free_ino_ctl) {
1515                 ret = -ENOMEM;
1516                 goto fail;
1517         }
1518
1519         writers = btrfs_alloc_subvolume_writers();
1520         if (IS_ERR(writers)) {
1521                 ret = PTR_ERR(writers);
1522                 goto fail;
1523         }
1524         root->subv_writers = writers;
1525
1526         btrfs_init_free_ino_ctl(root);
1527         spin_lock_init(&root->ino_cache_lock);
1528         init_waitqueue_head(&root->ino_cache_wait);
1529
1530         /*
1531          * Don't assign anonymous block device to roots that are not exposed to
1532          * userspace, the id pool is limited to 1M
1533          */
1534         if (is_fstree(root->root_key.objectid) &&
1535             btrfs_root_refs(&root->root_item) > 0) {
1536                 ret = get_anon_bdev(&root->anon_dev);
1537                 if (ret)
1538                         goto fail;
1539         }
1540
1541         mutex_lock(&root->objectid_mutex);
1542         ret = btrfs_find_highest_objectid(root,
1543                                         &root->highest_objectid);
1544         if (ret) {
1545                 mutex_unlock(&root->objectid_mutex);
1546                 goto fail;
1547         }
1548
1549         ASSERT(root->highest_objectid <= BTRFS_LAST_FREE_OBJECTID);
1550
1551         mutex_unlock(&root->objectid_mutex);
1552
1553         return 0;
1554 fail:
1555         /* the caller is responsible to call free_fs_root */
1556         return ret;
1557 }
1558
1559 struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
1560                                         u64 root_id)
1561 {
1562         struct btrfs_root *root;
1563
1564         spin_lock(&fs_info->fs_roots_radix_lock);
1565         root = radix_tree_lookup(&fs_info->fs_roots_radix,
1566                                  (unsigned long)root_id);
1567         spin_unlock(&fs_info->fs_roots_radix_lock);
1568         return root;
1569 }
1570
1571 int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
1572                          struct btrfs_root *root)
1573 {
1574         int ret;
1575
1576         ret = radix_tree_preload(GFP_NOFS);
1577         if (ret)
1578                 return ret;
1579
1580         spin_lock(&fs_info->fs_roots_radix_lock);
1581         ret = radix_tree_insert(&fs_info->fs_roots_radix,
1582                                 (unsigned long)root->root_key.objectid,
1583                                 root);
1584         if (ret == 0)
1585                 set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1586         spin_unlock(&fs_info->fs_roots_radix_lock);
1587         radix_tree_preload_end();
1588
1589         return ret;
1590 }
1591
1592 struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
1593                                      struct btrfs_key *location,
1594                                      bool check_ref)
1595 {
1596         struct btrfs_root *root;
1597         struct btrfs_path *path;
1598         struct btrfs_key key;
1599         int ret;
1600
1601         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1602                 return fs_info->tree_root;
1603         if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
1604                 return fs_info->extent_root;
1605         if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
1606                 return fs_info->chunk_root;
1607         if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
1608                 return fs_info->dev_root;
1609         if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
1610                 return fs_info->csum_root;
1611         if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
1612                 return fs_info->quota_root ? fs_info->quota_root :
1613                                              ERR_PTR(-ENOENT);
1614         if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
1615                 return fs_info->uuid_root ? fs_info->uuid_root :
1616                                             ERR_PTR(-ENOENT);
1617         if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
1618                 return fs_info->free_space_root ? fs_info->free_space_root :
1619                                                   ERR_PTR(-ENOENT);
1620 again:
1621         root = btrfs_lookup_fs_root(fs_info, location->objectid);
1622         if (root) {
1623                 if (check_ref && btrfs_root_refs(&root->root_item) == 0)
1624                         return ERR_PTR(-ENOENT);
1625                 return root;
1626         }
1627
1628         root = btrfs_read_fs_root(fs_info->tree_root, location);
1629         if (IS_ERR(root))
1630                 return root;
1631
1632         if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1633                 ret = -ENOENT;
1634                 goto fail;
1635         }
1636
1637         ret = btrfs_init_fs_root(root);
1638         if (ret)
1639                 goto fail;
1640
1641         path = btrfs_alloc_path();
1642         if (!path) {
1643                 ret = -ENOMEM;
1644                 goto fail;
1645         }
1646         key.objectid = BTRFS_ORPHAN_OBJECTID;
1647         key.type = BTRFS_ORPHAN_ITEM_KEY;
1648         key.offset = location->objectid;
1649
1650         ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
1651         btrfs_free_path(path);
1652         if (ret < 0)
1653                 goto fail;
1654         if (ret == 0)
1655                 set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1656
1657         ret = btrfs_insert_fs_root(fs_info, root);
1658         if (ret) {
1659                 if (ret == -EEXIST) {
1660                         free_fs_root(root);
1661                         goto again;
1662                 }
1663                 goto fail;
1664         }
1665         return root;
1666 fail:
1667         free_fs_root(root);
1668         return ERR_PTR(ret);
1669 }
1670
1671 static int btrfs_congested_fn(void *congested_data, int bdi_bits)
1672 {
1673         struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
1674         int ret = 0;
1675         struct btrfs_device *device;
1676         struct backing_dev_info *bdi;
1677
1678         rcu_read_lock();
1679         list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1680                 if (!device->bdev)
1681                         continue;
1682                 bdi = blk_get_backing_dev_info(device->bdev);
1683                 if (bdi_congested(bdi, bdi_bits)) {
1684                         ret = 1;
1685                         break;
1686                 }
1687         }
1688         rcu_read_unlock();
1689         return ret;
1690 }
1691
1692 static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
1693 {
1694         int err;
1695
1696         err = bdi_setup_and_register(bdi, "btrfs");
1697         if (err)
1698                 return err;
1699
1700         bdi->ra_pages = VM_MAX_READAHEAD * 1024 / PAGE_SIZE;
1701         bdi->congested_fn       = btrfs_congested_fn;
1702         bdi->congested_data     = info;
1703         bdi->capabilities |= BDI_CAP_CGROUP_WRITEBACK;
1704         return 0;
1705 }
1706
1707 /*
1708  * called by the kthread helper functions to finally call the bio end_io
1709  * functions.  This is where read checksum verification actually happens
1710  */
1711 static void end_workqueue_fn(struct btrfs_work *work)
1712 {
1713         struct bio *bio;
1714         struct btrfs_end_io_wq *end_io_wq;
1715
1716         end_io_wq = container_of(work, struct btrfs_end_io_wq, work);
1717         bio = end_io_wq->bio;
1718
1719         bio->bi_error = end_io_wq->error;
1720         bio->bi_private = end_io_wq->private;
1721         bio->bi_end_io = end_io_wq->end_io;
1722         bio_endio(bio);
1723         kmem_cache_free(btrfs_end_io_wq_cache, end_io_wq);
1724 }
1725
1726 static int cleaner_kthread(void *arg)
1727 {
1728         struct btrfs_root *root = arg;
1729         int again;
1730         struct btrfs_trans_handle *trans;
1731
1732         do {
1733                 again = 0;
1734
1735                 /* Make the cleaner go to sleep early. */
1736                 if (btrfs_need_cleaner_sleep(root))
1737                         goto sleep;
1738
1739                 /*
1740                  * Do not do anything if we might cause open_ctree() to block
1741                  * before we have finished mounting the filesystem.
1742                  */
1743                 if (!test_bit(BTRFS_FS_OPEN, &root->fs_info->flags))
1744                         goto sleep;
1745
1746                 if (!mutex_trylock(&root->fs_info->cleaner_mutex))
1747                         goto sleep;
1748
1749                 /*
1750                  * Avoid the problem that we change the status of the fs
1751                  * during the above check and trylock.
1752                  */
1753                 if (btrfs_need_cleaner_sleep(root)) {
1754                         mutex_unlock(&root->fs_info->cleaner_mutex);
1755                         goto sleep;
1756                 }
1757
1758                 mutex_lock(&root->fs_info->cleaner_delayed_iput_mutex);
1759                 btrfs_run_delayed_iputs(root);
1760                 mutex_unlock(&root->fs_info->cleaner_delayed_iput_mutex);
1761
1762                 again = btrfs_clean_one_deleted_snapshot(root);
1763                 mutex_unlock(&root->fs_info->cleaner_mutex);
1764
1765                 /*
1766                  * The defragger has dealt with the R/O remount and umount,
1767                  * needn't do anything special here.
1768                  */
1769                 btrfs_run_defrag_inodes(root->fs_info);
1770
1771                 /*
1772                  * Acquires fs_info->delete_unused_bgs_mutex to avoid racing
1773                  * with relocation (btrfs_relocate_chunk) and relocation
1774                  * acquires fs_info->cleaner_mutex (btrfs_relocate_block_group)
1775                  * after acquiring fs_info->delete_unused_bgs_mutex. So we
1776                  * can't hold, nor need to, fs_info->cleaner_mutex when deleting
1777                  * unused block groups.
1778                  */
1779                 btrfs_delete_unused_bgs(root->fs_info);
1780 sleep:
1781                 if (!again) {
1782                         set_current_state(TASK_INTERRUPTIBLE);
1783                         if (!kthread_should_stop())
1784                                 schedule();
1785                         __set_current_state(TASK_RUNNING);
1786                 }
1787         } while (!kthread_should_stop());
1788
1789         /*
1790          * Transaction kthread is stopped before us and wakes us up.
1791          * However we might have started a new transaction and COWed some
1792          * tree blocks when deleting unused block groups for example. So
1793          * make sure we commit the transaction we started to have a clean
1794          * shutdown when evicting the btree inode - if it has dirty pages
1795          * when we do the final iput() on it, eviction will trigger a
1796          * writeback for it which will fail with null pointer dereferences
1797          * since work queues and other resources were already released and
1798          * destroyed by the time the iput/eviction/writeback is made.
1799          */
1800         trans = btrfs_attach_transaction(root);
1801         if (IS_ERR(trans)) {
1802                 if (PTR_ERR(trans) != -ENOENT)
1803                         btrfs_err(root->fs_info,
1804                                   "cleaner transaction attach returned %ld",
1805                                   PTR_ERR(trans));
1806         } else {
1807                 int ret;
1808
1809                 ret = btrfs_commit_transaction(trans, root);
1810                 if (ret)
1811                         btrfs_err(root->fs_info,
1812                                   "cleaner open transaction commit returned %d",
1813                                   ret);
1814         }
1815
1816         return 0;
1817 }
1818
1819 static int transaction_kthread(void *arg)
1820 {
1821         struct btrfs_root *root = arg;
1822         struct btrfs_trans_handle *trans;
1823         struct btrfs_transaction *cur;
1824         u64 transid;
1825         unsigned long now;
1826         unsigned long delay;
1827         bool cannot_commit;
1828
1829         do {
1830                 cannot_commit = false;
1831                 delay = HZ * root->fs_info->commit_interval;
1832                 mutex_lock(&root->fs_info->transaction_kthread_mutex);
1833
1834                 spin_lock(&root->fs_info->trans_lock);
1835                 cur = root->fs_info->running_transaction;
1836                 if (!cur) {
1837                         spin_unlock(&root->fs_info->trans_lock);
1838                         goto sleep;
1839                 }
1840
1841                 now = get_seconds();
1842                 if (cur->state < TRANS_STATE_BLOCKED &&
1843                     (now < cur->start_time ||
1844                      now - cur->start_time < root->fs_info->commit_interval)) {
1845                         spin_unlock(&root->fs_info->trans_lock);
1846                         delay = HZ * 5;
1847                         goto sleep;
1848                 }
1849                 transid = cur->transid;
1850                 spin_unlock(&root->fs_info->trans_lock);
1851
1852                 /* If the file system is aborted, this will always fail. */
1853                 trans = btrfs_attach_transaction(root);
1854                 if (IS_ERR(trans)) {
1855                         if (PTR_ERR(trans) != -ENOENT)
1856                                 cannot_commit = true;
1857                         goto sleep;
1858                 }
1859                 if (transid == trans->transid) {
1860                         btrfs_commit_transaction(trans, root);
1861                 } else {
1862                         btrfs_end_transaction(trans, root);
1863                 }
1864 sleep:
1865                 wake_up_process(root->fs_info->cleaner_kthread);
1866                 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1867
1868                 if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
1869                                       &root->fs_info->fs_state)))
1870                         btrfs_cleanup_transaction(root);
1871                 set_current_state(TASK_INTERRUPTIBLE);
1872                 if (!kthread_should_stop() &&
1873                                 (!btrfs_transaction_blocked(root->fs_info) ||
1874                                  cannot_commit))
1875                         schedule_timeout(delay);
1876                 __set_current_state(TASK_RUNNING);
1877         } while (!kthread_should_stop());
1878         return 0;
1879 }
1880
1881 /*
1882  * this will find the highest generation in the array of
1883  * root backups.  The index of the highest array is returned,
1884  * or -1 if we can't find anything.
1885  *
1886  * We check to make sure the array is valid by comparing the
1887  * generation of the latest  root in the array with the generation
1888  * in the super block.  If they don't match we pitch it.
1889  */
1890 static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
1891 {
1892         u64 cur;
1893         int newest_index = -1;
1894         struct btrfs_root_backup *root_backup;
1895         int i;
1896
1897         for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1898                 root_backup = info->super_copy->super_roots + i;
1899                 cur = btrfs_backup_tree_root_gen(root_backup);
1900                 if (cur == newest_gen)
1901                         newest_index = i;
1902         }
1903
1904         /* check to see if we actually wrapped around */
1905         if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
1906                 root_backup = info->super_copy->super_roots;
1907                 cur = btrfs_backup_tree_root_gen(root_backup);
1908                 if (cur == newest_gen)
1909                         newest_index = 0;
1910         }
1911         return newest_index;
1912 }
1913
1914
1915 /*
1916  * find the oldest backup so we know where to store new entries
1917  * in the backup array.  This will set the backup_root_index
1918  * field in the fs_info struct
1919  */
1920 static void find_oldest_super_backup(struct btrfs_fs_info *info,
1921                                      u64 newest_gen)
1922 {
1923         int newest_index = -1;
1924
1925         newest_index = find_newest_super_backup(info, newest_gen);
1926         /* if there was garbage in there, just move along */
1927         if (newest_index == -1) {
1928                 info->backup_root_index = 0;
1929         } else {
1930                 info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
1931         }
1932 }
1933
1934 /*
1935  * copy all the root pointers into the super backup array.
1936  * this will bump the backup pointer by one when it is
1937  * done
1938  */
1939 static void backup_super_roots(struct btrfs_fs_info *info)
1940 {
1941         int next_backup;
1942         struct btrfs_root_backup *root_backup;
1943         int last_backup;
1944
1945         next_backup = info->backup_root_index;
1946         last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
1947                 BTRFS_NUM_BACKUP_ROOTS;
1948
1949         /*
1950          * just overwrite the last backup if we're at the same generation
1951          * this happens only at umount
1952          */
1953         root_backup = info->super_for_commit->super_roots + last_backup;
1954         if (btrfs_backup_tree_root_gen(root_backup) ==
1955             btrfs_header_generation(info->tree_root->node))
1956                 next_backup = last_backup;
1957
1958         root_backup = info->super_for_commit->super_roots + next_backup;
1959
1960         /*
1961          * make sure all of our padding and empty slots get zero filled
1962          * regardless of which ones we use today
1963          */
1964         memset(root_backup, 0, sizeof(*root_backup));
1965
1966         info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1967
1968         btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1969         btrfs_set_backup_tree_root_gen(root_backup,
1970                                btrfs_header_generation(info->tree_root->node));
1971
1972         btrfs_set_backup_tree_root_level(root_backup,
1973                                btrfs_header_level(info->tree_root->node));
1974
1975         btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1976         btrfs_set_backup_chunk_root_gen(root_backup,
1977                                btrfs_header_generation(info->chunk_root->node));
1978         btrfs_set_backup_chunk_root_level(root_backup,
1979                                btrfs_header_level(info->chunk_root->node));
1980
1981         btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
1982         btrfs_set_backup_extent_root_gen(root_backup,
1983                                btrfs_header_generation(info->extent_root->node));
1984         btrfs_set_backup_extent_root_level(root_backup,
1985                                btrfs_header_level(info->extent_root->node));
1986
1987         /*
1988          * we might commit during log recovery, which happens before we set
1989          * the fs_root.  Make sure it is valid before we fill it in.
1990          */
1991         if (info->fs_root && info->fs_root->node) {
1992                 btrfs_set_backup_fs_root(root_backup,
1993                                          info->fs_root->node->start);
1994                 btrfs_set_backup_fs_root_gen(root_backup,
1995                                btrfs_header_generation(info->fs_root->node));
1996                 btrfs_set_backup_fs_root_level(root_backup,
1997                                btrfs_header_level(info->fs_root->node));
1998         }
1999
2000         btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
2001         btrfs_set_backup_dev_root_gen(root_backup,
2002                                btrfs_header_generation(info->dev_root->node));
2003         btrfs_set_backup_dev_root_level(root_backup,
2004                                        btrfs_header_level(info->dev_root->node));
2005
2006         btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
2007         btrfs_set_backup_csum_root_gen(root_backup,
2008                                btrfs_header_generation(info->csum_root->node));
2009         btrfs_set_backup_csum_root_level(root_backup,
2010                                btrfs_header_level(info->csum_root->node));
2011
2012         btrfs_set_backup_total_bytes(root_backup,
2013                              btrfs_super_total_bytes(info->super_copy));
2014         btrfs_set_backup_bytes_used(root_backup,
2015                              btrfs_super_bytes_used(info->super_copy));
2016         btrfs_set_backup_num_devices(root_backup,
2017                              btrfs_super_num_devices(info->super_copy));
2018
2019         /*
2020          * if we don't copy this out to the super_copy, it won't get remembered
2021          * for the next commit
2022          */
2023         memcpy(&info->super_copy->super_roots,
2024                &info->super_for_commit->super_roots,
2025                sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
2026 }
2027
2028 /*
2029  * this copies info out of the root backup array and back into
2030  * the in-memory super block.  It is meant to help iterate through
2031  * the array, so you send it the number of backups you've already
2032  * tried and the last backup index you used.
2033  *
2034  * this returns -1 when it has tried all the backups
2035  */
2036 static noinline int next_root_backup(struct btrfs_fs_info *info,
2037                                      struct btrfs_super_block *super,
2038                                      int *num_backups_tried, int *backup_index)
2039 {
2040         struct btrfs_root_backup *root_backup;
2041         int newest = *backup_index;
2042
2043         if (*num_backups_tried == 0) {
2044                 u64 gen = btrfs_super_generation(super);
2045
2046                 newest = find_newest_super_backup(info, gen);
2047                 if (newest == -1)
2048                         return -1;
2049
2050                 *backup_index = newest;
2051                 *num_backups_tried = 1;
2052         } else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
2053                 /* we've tried all the backups, all done */
2054                 return -1;
2055         } else {
2056                 /* jump to the next oldest backup */
2057                 newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
2058                         BTRFS_NUM_BACKUP_ROOTS;
2059                 *backup_index = newest;
2060                 *num_backups_tried += 1;
2061         }
2062         root_backup = super->super_roots + newest;
2063
2064         btrfs_set_super_generation(super,
2065                                    btrfs_backup_tree_root_gen(root_backup));
2066         btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
2067         btrfs_set_super_root_level(super,
2068                                    btrfs_backup_tree_root_level(root_backup));
2069         btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
2070
2071         /*
2072          * fixme: the total bytes and num_devices need to match or we should
2073          * need a fsck
2074          */
2075         btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
2076         btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
2077         return 0;
2078 }
2079
2080 /* helper to cleanup workers */
2081 static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
2082 {
2083         btrfs_destroy_workqueue(fs_info->fixup_workers);
2084         btrfs_destroy_workqueue(fs_info->delalloc_workers);
2085         btrfs_destroy_workqueue(fs_info->workers);
2086         btrfs_destroy_workqueue(fs_info->endio_workers);
2087         btrfs_destroy_workqueue(fs_info->endio_meta_workers);
2088         btrfs_destroy_workqueue(fs_info->endio_raid56_workers);
2089         btrfs_destroy_workqueue(fs_info->endio_repair_workers);
2090         btrfs_destroy_workqueue(fs_info->rmw_workers);
2091         btrfs_destroy_workqueue(fs_info->endio_meta_write_workers);
2092         btrfs_destroy_workqueue(fs_info->endio_write_workers);
2093         btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
2094         btrfs_destroy_workqueue(fs_info->submit_workers);
2095         btrfs_destroy_workqueue(fs_info->delayed_workers);
2096         btrfs_destroy_workqueue(fs_info->caching_workers);
2097         btrfs_destroy_workqueue(fs_info->readahead_workers);
2098         btrfs_destroy_workqueue(fs_info->flush_workers);
2099         btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
2100         btrfs_destroy_workqueue(fs_info->extent_workers);
2101 }
2102
2103 static void free_root_extent_buffers(struct btrfs_root *root)
2104 {
2105         if (root) {
2106                 free_extent_buffer(root->node);
2107                 free_extent_buffer(root->commit_root);
2108                 root->node = NULL;
2109                 root->commit_root = NULL;
2110         }
2111 }
2112
2113 /* helper to cleanup tree roots */
2114 static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)
2115 {
2116         free_root_extent_buffers(info->tree_root);
2117
2118         free_root_extent_buffers(info->dev_root);
2119         free_root_extent_buffers(info->extent_root);
2120         free_root_extent_buffers(info->csum_root);
2121         free_root_extent_buffers(info->quota_root);
2122         free_root_extent_buffers(info->uuid_root);
2123         if (free_chunk_root)
2124                 free_root_extent_buffers(info->chunk_root);
2125         free_root_extent_buffers(info->free_space_root);
2126 }
2127
2128 void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
2129 {
2130         int ret;
2131         struct btrfs_root *gang[8];
2132         int i;
2133
2134         while (!list_empty(&fs_info->dead_roots)) {
2135                 gang[0] = list_entry(fs_info->dead_roots.next,
2136                                      struct btrfs_root, root_list);
2137                 list_del(&gang[0]->root_list);
2138
2139                 if (test_bit(BTRFS_ROOT_IN_RADIX, &gang[0]->state)) {
2140                         btrfs_drop_and_free_fs_root(fs_info, gang[0]);
2141                 } else {
2142                         free_extent_buffer(gang[0]->node);
2143                         free_extent_buffer(gang[0]->commit_root);
2144                         btrfs_put_fs_root(gang[0]);
2145                 }
2146         }
2147
2148         while (1) {
2149                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
2150                                              (void **)gang, 0,
2151                                              ARRAY_SIZE(gang));
2152                 if (!ret)
2153                         break;
2154                 for (i = 0; i < ret; i++)
2155                         btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2156         }
2157
2158         if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
2159                 btrfs_free_log_root_tree(NULL, fs_info);
2160                 btrfs_destroy_pinned_extent(fs_info->tree_root,
2161                                             fs_info->pinned_extents);
2162         }
2163 }
2164
2165 static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
2166 {
2167         mutex_init(&fs_info->scrub_lock);
2168         atomic_set(&fs_info->scrubs_running, 0);
2169         atomic_set(&fs_info->scrub_pause_req, 0);
2170         atomic_set(&fs_info->scrubs_paused, 0);
2171         atomic_set(&fs_info->scrub_cancel_req, 0);
2172         init_waitqueue_head(&fs_info->scrub_pause_wait);
2173         fs_info->scrub_workers_refcnt = 0;
2174 }
2175
2176 static void btrfs_init_balance(struct btrfs_fs_info *fs_info)
2177 {
2178         spin_lock_init(&fs_info->balance_lock);
2179         mutex_init(&fs_info->balance_mutex);
2180         atomic_set(&fs_info->balance_running, 0);
2181         atomic_set(&fs_info->balance_pause_req, 0);
2182         atomic_set(&fs_info->balance_cancel_req, 0);
2183         fs_info->balance_ctl = NULL;
2184         init_waitqueue_head(&fs_info->balance_wait_q);
2185 }
2186
2187 static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info,
2188                                    struct btrfs_root *tree_root)
2189 {
2190         fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
2191         set_nlink(fs_info->btree_inode, 1);
2192         /*
2193          * we set the i_size on the btree inode to the max possible int.
2194          * the real end of the address space is determined by all of
2195          * the devices in the system
2196          */
2197         fs_info->btree_inode->i_size = OFFSET_MAX;
2198         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
2199
2200         RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2201         extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2202                              fs_info->btree_inode->i_mapping);
2203         BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2204         extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2205
2206         BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
2207
2208         BTRFS_I(fs_info->btree_inode)->root = tree_root;
2209         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
2210                sizeof(struct btrfs_key));
2211         set_bit(BTRFS_INODE_DUMMY,
2212                 &BTRFS_I(fs_info->btree_inode)->runtime_flags);
2213         btrfs_insert_inode_hash(fs_info->btree_inode);
2214 }
2215
2216 static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
2217 {
2218         fs_info->dev_replace.lock_owner = 0;
2219         atomic_set(&fs_info->dev_replace.nesting_level, 0);
2220         mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
2221         rwlock_init(&fs_info->dev_replace.lock);
2222         atomic_set(&fs_info->dev_replace.read_locks, 0);
2223         atomic_set(&fs_info->dev_replace.blocking_readers, 0);
2224         init_waitqueue_head(&fs_info->replace_wait);
2225         init_waitqueue_head(&fs_info->dev_replace.read_lock_wq);
2226 }
2227
2228 static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
2229 {
2230         spin_lock_init(&fs_info->qgroup_lock);
2231         mutex_init(&fs_info->qgroup_ioctl_lock);
2232         fs_info->qgroup_tree = RB_ROOT;
2233         fs_info->qgroup_op_tree = RB_ROOT;
2234         INIT_LIST_HEAD(&fs_info->dirty_qgroups);
2235         fs_info->qgroup_seq = 1;
2236         fs_info->qgroup_ulist = NULL;
2237         fs_info->qgroup_rescan_running = false;
2238         mutex_init(&fs_info->qgroup_rescan_lock);
2239 }
2240
2241 static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info,
2242                 struct btrfs_fs_devices *fs_devices)
2243 {
2244         int max_active = fs_info->thread_pool_size;
2245         unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
2246
2247         fs_info->workers =
2248                 btrfs_alloc_workqueue(fs_info, "worker",
2249                                       flags | WQ_HIGHPRI, max_active, 16);
2250
2251         fs_info->delalloc_workers =
2252                 btrfs_alloc_workqueue(fs_info, "delalloc",
2253                                       flags, max_active, 2);
2254
2255         fs_info->flush_workers =
2256                 btrfs_alloc_workqueue(fs_info, "flush_delalloc",
2257                                       flags, max_active, 0);
2258
2259         fs_info->caching_workers =
2260                 btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);
2261
2262         /*
2263          * a higher idle thresh on the submit workers makes it much more
2264          * likely that bios will be send down in a sane order to the
2265          * devices
2266          */
2267         fs_info->submit_workers =
2268                 btrfs_alloc_workqueue(fs_info, "submit", flags,
2269                                       min_t(u64, fs_devices->num_devices,
2270                                             max_active), 64);
2271
2272         fs_info->fixup_workers =
2273                 btrfs_alloc_workqueue(fs_info, "fixup", flags, 1, 0);
2274
2275         /*
2276          * endios are largely parallel and should have a very
2277          * low idle thresh
2278          */
2279         fs_info->endio_workers =
2280                 btrfs_alloc_workqueue(fs_info, "endio", flags, max_active, 4);
2281         fs_info->endio_meta_workers =
2282                 btrfs_alloc_workqueue(fs_info, "endio-meta", flags,
2283                                       max_active, 4);
2284         fs_info->endio_meta_write_workers =
2285                 btrfs_alloc_workqueue(fs_info, "endio-meta-write", flags,
2286                                       max_active, 2);
2287         fs_info->endio_raid56_workers =
2288                 btrfs_alloc_workqueue(fs_info, "endio-raid56", flags,
2289                                       max_active, 4);
2290         fs_info->endio_repair_workers =
2291                 btrfs_alloc_workqueue(fs_info, "endio-repair", flags, 1, 0);
2292         fs_info->rmw_workers =
2293                 btrfs_alloc_workqueue(fs_info, "rmw", flags, max_active, 2);
2294         fs_info->endio_write_workers =
2295                 btrfs_alloc_workqueue(fs_info, "endio-write", flags,
2296                                       max_active, 2);
2297         fs_info->endio_freespace_worker =
2298                 btrfs_alloc_workqueue(fs_info, "freespace-write", flags,
2299                                       max_active, 0);
2300         fs_info->delayed_workers =
2301                 btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,
2302                                       max_active, 0);
2303         fs_info->readahead_workers =
2304                 btrfs_alloc_workqueue(fs_info, "readahead", flags,
2305                                       max_active, 2);
2306         fs_info->qgroup_rescan_workers =
2307                 btrfs_alloc_workqueue(fs_info, "qgroup-rescan", flags, 1, 0);
2308         fs_info->extent_workers =
2309                 btrfs_alloc_workqueue(fs_info, "extent-refs", flags,
2310                                       min_t(u64, fs_devices->num_devices,
2311                                             max_active), 8);
2312
2313         if (!(fs_info->workers && fs_info->delalloc_workers &&
2314               fs_info->submit_workers && fs_info->flush_workers &&
2315               fs_info->endio_workers && fs_info->endio_meta_workers &&
2316               fs_info->endio_meta_write_workers &&
2317               fs_info->endio_repair_workers &&
2318               fs_info->endio_write_workers && fs_info->endio_raid56_workers &&
2319               fs_info->endio_freespace_worker && fs_info->rmw_workers &&
2320               fs_info->caching_workers && fs_info->readahead_workers &&
2321               fs_info->fixup_workers && fs_info->delayed_workers &&
2322               fs_info->extent_workers &&
2323               fs_info->qgroup_rescan_workers)) {
2324                 return -ENOMEM;
2325         }
2326
2327         return 0;
2328 }
2329
2330 static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
2331                             struct btrfs_fs_devices *fs_devices)
2332 {
2333         int ret;
2334         struct btrfs_root *tree_root = fs_info->tree_root;
2335         struct btrfs_root *log_tree_root;
2336         struct btrfs_super_block *disk_super = fs_info->super_copy;
2337         u64 bytenr = btrfs_super_log_root(disk_super);
2338
2339         if (fs_devices->rw_devices == 0) {
2340                 btrfs_warn(fs_info, "log replay required on RO media");
2341                 return -EIO;
2342         }
2343
2344         log_tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
2345         if (!log_tree_root)
2346                 return -ENOMEM;
2347
2348         __setup_root(tree_root->nodesize, tree_root->sectorsize,
2349                         tree_root->stripesize, log_tree_root, fs_info,
2350                         BTRFS_TREE_LOG_OBJECTID);
2351
2352         log_tree_root->node = read_tree_block(tree_root, bytenr,
2353                         fs_info->generation + 1);
2354         if (IS_ERR(log_tree_root->node)) {
2355                 btrfs_warn(fs_info, "failed to read log tree");
2356                 ret = PTR_ERR(log_tree_root->node);
2357                 kfree(log_tree_root);
2358                 return ret;
2359         } else if (!extent_buffer_uptodate(log_tree_root->node)) {
2360                 btrfs_err(fs_info, "failed to read log tree");
2361                 free_extent_buffer(log_tree_root->node);
2362                 kfree(log_tree_root);
2363                 return -EIO;
2364         }
2365         /* returns with log_tree_root freed on success */
2366         ret = btrfs_recover_log_trees(log_tree_root);
2367         if (ret) {
2368                 btrfs_handle_fs_error(tree_root->fs_info, ret,
2369                             "Failed to recover log tree");
2370                 free_extent_buffer(log_tree_root->node);
2371                 kfree(log_tree_root);
2372                 return ret;
2373         }
2374
2375         if (fs_info->sb->s_flags & MS_RDONLY) {
2376                 ret = btrfs_commit_super(tree_root);
2377                 if (ret)
2378                         return ret;
2379         }
2380
2381         return 0;
2382 }
2383
2384 static int btrfs_read_roots(struct btrfs_fs_info *fs_info,
2385                             struct btrfs_root *tree_root)
2386 {
2387         struct btrfs_root *root;
2388         struct btrfs_key location;
2389         int ret;
2390
2391         location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
2392         location.type = BTRFS_ROOT_ITEM_KEY;
2393         location.offset = 0;
2394
2395         root = btrfs_read_tree_root(tree_root, &location);
2396         if (IS_ERR(root))
2397                 return PTR_ERR(root);
2398         set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2399         fs_info->extent_root = root;
2400
2401         location.objectid = BTRFS_DEV_TREE_OBJECTID;
2402         root = btrfs_read_tree_root(tree_root, &location);
2403         if (IS_ERR(root))
2404                 return PTR_ERR(root);
2405         set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2406         fs_info->dev_root = root;
2407         btrfs_init_devices_late(fs_info);
2408
2409         location.objectid = BTRFS_CSUM_TREE_OBJECTID;
2410         root = btrfs_read_tree_root(tree_root, &location);
2411         if (IS_ERR(root))
2412                 return PTR_ERR(root);
2413         set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2414         fs_info->csum_root = root;
2415
2416         location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
2417         root = btrfs_read_tree_root(tree_root, &location);
2418         if (!IS_ERR(root)) {
2419                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2420                 set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
2421                 fs_info->quota_root = root;
2422         }
2423
2424         location.objectid = BTRFS_UUID_TREE_OBJECTID;
2425         root = btrfs_read_tree_root(tree_root, &location);
2426         if (IS_ERR(root)) {
2427                 ret = PTR_ERR(root);
2428                 if (ret != -ENOENT)
2429                         return ret;
2430         } else {
2431                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2432                 fs_info->uuid_root = root;
2433         }
2434
2435         if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2436                 location.objectid = BTRFS_FREE_SPACE_TREE_OBJECTID;
2437                 root = btrfs_read_tree_root(tree_root, &location);
2438                 if (IS_ERR(root))
2439                         return PTR_ERR(root);
2440                 set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2441                 fs_info->free_space_root = root;
2442         }
2443
2444         return 0;
2445 }
2446
2447 int open_ctree(struct super_block *sb,
2448                struct btrfs_fs_devices *fs_devices,
2449                char *options)
2450 {
2451         u32 sectorsize;
2452         u32 nodesize;
2453         u32 stripesize;
2454         u64 generation;
2455         u64 features;
2456         struct btrfs_key location;
2457         struct buffer_head *bh;
2458         struct btrfs_super_block *disk_super;
2459         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2460         struct btrfs_root *tree_root;
2461         struct btrfs_root *chunk_root;
2462         int ret;
2463         int err = -EINVAL;
2464         int num_backups_tried = 0;
2465         int backup_index = 0;
2466         int max_active;
2467         int clear_free_space_tree = 0;
2468
2469         tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
2470         chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
2471         if (!tree_root || !chunk_root) {
2472                 err = -ENOMEM;
2473                 goto fail;
2474         }
2475
2476         ret = init_srcu_struct(&fs_info->subvol_srcu);
2477         if (ret) {
2478                 err = ret;
2479                 goto fail;
2480         }
2481
2482         ret = setup_bdi(fs_info, &fs_info->bdi);
2483         if (ret) {
2484                 err = ret;
2485                 goto fail_srcu;
2486         }
2487
2488         ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
2489         if (ret) {
2490                 err = ret;
2491                 goto fail_bdi;
2492         }
2493         fs_info->dirty_metadata_batch = PAGE_SIZE *
2494                                         (1 + ilog2(nr_cpu_ids));
2495
2496         ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
2497         if (ret) {
2498                 err = ret;
2499                 goto fail_dirty_metadata_bytes;
2500         }
2501
2502         ret = percpu_counter_init(&fs_info->bio_counter, 0, GFP_KERNEL);
2503         if (ret) {
2504                 err = ret;
2505                 goto fail_delalloc_bytes;
2506         }
2507
2508         fs_info->btree_inode = new_inode(sb);
2509         if (!fs_info->btree_inode) {
2510                 err = -ENOMEM;
2511                 goto fail_bio_counter;
2512         }
2513
2514         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
2515
2516         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2517         INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
2518         INIT_LIST_HEAD(&fs_info->trans_list);
2519         INIT_LIST_HEAD(&fs_info->dead_roots);
2520         INIT_LIST_HEAD(&fs_info->delayed_iputs);
2521         INIT_LIST_HEAD(&fs_info->delalloc_roots);
2522         INIT_LIST_HEAD(&fs_info->caching_block_groups);
2523         spin_lock_init(&fs_info->delalloc_root_lock);
2524         spin_lock_init(&fs_info->trans_lock);
2525         spin_lock_init(&fs_info->fs_roots_radix_lock);
2526         spin_lock_init(&fs_info->delayed_iput_lock);
2527         spin_lock_init(&fs_info->defrag_inodes_lock);
2528         spin_lock_init(&fs_info->free_chunk_lock);
2529         spin_lock_init(&fs_info->super_lock);
2530         spin_lock_init(&fs_info->qgroup_op_lock);
2531         spin_lock_init(&fs_info->buffer_lock);
2532         spin_lock_init(&fs_info->unused_bgs_lock);
2533         rwlock_init(&fs_info->tree_mod_log_lock);
2534         mutex_init(&fs_info->unused_bg_unpin_mutex);
2535         mutex_init(&fs_info->delete_unused_bgs_mutex);
2536         mutex_init(&fs_info->reloc_mutex);
2537         mutex_init(&fs_info->delalloc_root_mutex);
2538         mutex_init(&fs_info->cleaner_delayed_iput_mutex);
2539         seqlock_init(&fs_info->profiles_lock);
2540
2541         INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2542         INIT_LIST_HEAD(&fs_info->space_info);
2543         INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2544         INIT_LIST_HEAD(&fs_info->unused_bgs);
2545         btrfs_mapping_init(&fs_info->mapping_tree);
2546         btrfs_init_block_rsv(&fs_info->global_block_rsv,
2547                              BTRFS_BLOCK_RSV_GLOBAL);
2548         btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
2549                              BTRFS_BLOCK_RSV_DELALLOC);
2550         btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
2551         btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
2552         btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
2553         btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
2554                              BTRFS_BLOCK_RSV_DELOPS);
2555         atomic_set(&fs_info->nr_async_submits, 0);
2556         atomic_set(&fs_info->async_delalloc_pages, 0);
2557         atomic_set(&fs_info->async_submit_draining, 0);
2558         atomic_set(&fs_info->nr_async_bios, 0);
2559         atomic_set(&fs_info->defrag_running, 0);
2560         atomic_set(&fs_info->qgroup_op_seq, 0);
2561         atomic_set(&fs_info->reada_works_cnt, 0);
2562         atomic64_set(&fs_info->tree_mod_seq, 0);
2563         fs_info->fs_frozen = 0;
2564         fs_info->sb = sb;
2565         fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
2566         fs_info->metadata_ratio = 0;
2567         fs_info->defrag_inodes = RB_ROOT;
2568         fs_info->free_chunk_space = 0;
2569         fs_info->tree_mod_log = RB_ROOT;
2570         fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2571         fs_info->avg_delayed_ref_runtime = NSEC_PER_SEC >> 6; /* div by 64 */
2572         /* readahead state */
2573         INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
2574         spin_lock_init(&fs_info->reada_lock);
2575
2576         fs_info->thread_pool_size = min_t(unsigned long,
2577                                           num_online_cpus() + 2, 8);
2578
2579         INIT_LIST_HEAD(&fs_info->ordered_roots);
2580         spin_lock_init(&fs_info->ordered_root_lock);
2581         fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2582                                         GFP_KERNEL);
2583         if (!fs_info->delayed_root) {
2584                 err = -ENOMEM;
2585                 goto fail_iput;
2586         }
2587         btrfs_init_delayed_root(fs_info->delayed_root);
2588
2589         btrfs_init_scrub(fs_info);
2590 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2591         fs_info->check_integrity_print_mask = 0;
2592 #endif
2593         btrfs_init_balance(fs_info);
2594         btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work);
2595
2596         sb->s_blocksize = 4096;
2597         sb->s_blocksize_bits = blksize_bits(4096);
2598         sb->s_bdi = &fs_info->bdi;
2599
2600         btrfs_init_btree_inode(fs_info, tree_root);
2601
2602         spin_lock_init(&fs_info->block_group_cache_lock);
2603         fs_info->block_group_cache_tree = RB_ROOT;
2604         fs_info->first_logical_byte = (u64)-1;
2605
2606         extent_io_tree_init(&fs_info->freed_extents[0],
2607                              fs_info->btree_inode->i_mapping);
2608         extent_io_tree_init(&fs_info->freed_extents[1],
2609                              fs_info->btree_inode->i_mapping);
2610         fs_info->pinned_extents = &fs_info->freed_extents[0];
2611         set_bit(BTRFS_FS_BARRIER, &fs_info->flags);
2612
2613         mutex_init(&fs_info->ordered_operations_mutex);
2614         mutex_init(&fs_info->tree_log_mutex);
2615         mutex_init(&fs_info->chunk_mutex);
2616         mutex_init(&fs_info->transaction_kthread_mutex);
2617         mutex_init(&fs_info->cleaner_mutex);
2618         mutex_init(&fs_info->volume_mutex);
2619         mutex_init(&fs_info->ro_block_group_mutex);
2620         init_rwsem(&fs_info->commit_root_sem);
2621         init_rwsem(&fs_info->cleanup_work_sem);
2622         init_rwsem(&fs_info->subvol_sem);
2623         sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2624
2625         btrfs_init_dev_replace_locks(fs_info);
2626         btrfs_init_qgroup(fs_info);
2627
2628         btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2629         btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2630
2631         init_waitqueue_head(&fs_info->transaction_throttle);
2632         init_waitqueue_head(&fs_info->transaction_wait);
2633         init_waitqueue_head(&fs_info->transaction_blocked_wait);
2634         init_waitqueue_head(&fs_info->async_submit_wait);
2635
2636         INIT_LIST_HEAD(&fs_info->pinned_chunks);
2637
2638         ret = btrfs_alloc_stripe_hash_table(fs_info);
2639         if (ret) {
2640                 err = ret;
2641                 goto fail_alloc;
2642         }
2643
2644         __setup_root(4096, 4096, 4096, tree_root,
2645                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
2646
2647         invalidate_bdev(fs_devices->latest_bdev);
2648
2649         /*
2650          * Read super block and check the signature bytes only
2651          */
2652         bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2653         if (IS_ERR(bh)) {
2654                 err = PTR_ERR(bh);
2655                 goto fail_alloc;
2656         }
2657
2658         /*
2659          * We want to check superblock checksum, the type is stored inside.
2660          * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
2661          */
2662         if (btrfs_check_super_csum(fs_info, bh->b_data)) {
2663                 btrfs_err(fs_info, "superblock checksum mismatch");
2664                 err = -EINVAL;
2665                 brelse(bh);
2666                 goto fail_alloc;
2667         }
2668
2669         /*
2670          * super_copy is zeroed at allocation time and we never touch the
2671          * following bytes up to INFO_SIZE, the checksum is calculated from
2672          * the whole block of INFO_SIZE
2673          */
2674         memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
2675         memcpy(fs_info->super_for_commit, fs_info->super_copy,
2676                sizeof(*fs_info->super_for_commit));
2677         brelse(bh);
2678
2679         memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2680
2681         ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
2682         if (ret) {
2683                 btrfs_err(fs_info, "superblock contains fatal errors");
2684                 err = -EINVAL;
2685                 goto fail_alloc;
2686         }
2687
2688         disk_super = fs_info->super_copy;
2689         if (!btrfs_super_root(disk_super))
2690                 goto fail_alloc;
2691
2692         /* check FS state, whether FS is broken. */
2693         if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
2694                 set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
2695
2696         /*
2697          * run through our array of backup supers and setup
2698          * our ring pointer to the oldest one
2699          */
2700         generation = btrfs_super_generation(disk_super);
2701         find_oldest_super_backup(fs_info, generation);
2702
2703         /*
2704          * In the long term, we'll store the compression type in the super
2705          * block, and it'll be used for per file compression control.
2706          */
2707         fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
2708
2709         ret = btrfs_parse_options(tree_root, options, sb->s_flags);
2710         if (ret) {
2711                 err = ret;
2712                 goto fail_alloc;
2713         }
2714
2715         features = btrfs_super_incompat_flags(disk_super) &
2716                 ~BTRFS_FEATURE_INCOMPAT_SUPP;
2717         if (features) {
2718                 btrfs_err(fs_info,
2719                     "cannot mount because of unsupported optional features (%llx)",
2720                     features);
2721                 err = -EINVAL;
2722                 goto fail_alloc;
2723         }
2724
2725         features = btrfs_super_incompat_flags(disk_super);
2726         features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
2727         if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
2728                 features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2729
2730         if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
2731                 btrfs_info(fs_info, "has skinny extents");
2732
2733         /*
2734          * flag our filesystem as having big metadata blocks if
2735          * they are bigger than the page size
2736          */
2737         if (btrfs_super_nodesize(disk_super) > PAGE_SIZE) {
2738                 if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2739                         btrfs_info(fs_info,
2740                                 "flagging fs with big metadata feature");
2741                 features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
2742         }
2743
2744         nodesize = btrfs_super_nodesize(disk_super);
2745         sectorsize = btrfs_super_sectorsize(disk_super);
2746         stripesize = sectorsize;
2747         fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
2748         fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
2749
2750         /*
2751          * mixed block groups end up with duplicate but slightly offset
2752          * extent buffers for the same range.  It leads to corruptions
2753          */
2754         if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
2755             (sectorsize != nodesize)) {
2756                 btrfs_err(fs_info,
2757 "unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups",
2758                         nodesize, sectorsize);
2759                 goto fail_alloc;
2760         }
2761
2762         /*
2763          * Needn't use the lock because there is no other task which will
2764          * update the flag.
2765          */
2766         btrfs_set_super_incompat_flags(disk_super, features);
2767
2768         features = btrfs_super_compat_ro_flags(disk_super) &
2769                 ~BTRFS_FEATURE_COMPAT_RO_SUPP;
2770         if (!(sb->s_flags & MS_RDONLY) && features) {
2771                 btrfs_err(fs_info,
2772         "cannot mount read-write because of unsupported optional features (%llx)",
2773                        features);
2774                 err = -EINVAL;
2775                 goto fail_alloc;
2776         }
2777
2778         max_active = fs_info->thread_pool_size;
2779
2780         ret = btrfs_init_workqueues(fs_info, fs_devices);
2781         if (ret) {
2782                 err = ret;
2783                 goto fail_sb_buffer;
2784         }
2785
2786         fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
2787         fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
2788                                     SZ_4M / PAGE_SIZE);
2789
2790         tree_root->nodesize = nodesize;
2791         tree_root->sectorsize = sectorsize;
2792         tree_root->stripesize = stripesize;
2793
2794         sb->s_blocksize = sectorsize;
2795         sb->s_blocksize_bits = blksize_bits(sectorsize);
2796
2797         mutex_lock(&fs_info->chunk_mutex);
2798         ret = btrfs_read_sys_array(tree_root);
2799         mutex_unlock(&fs_info->chunk_mutex);
2800         if (ret) {
2801                 btrfs_err(fs_info, "failed to read the system array: %d", ret);
2802                 goto fail_sb_buffer;
2803         }
2804
2805         generation = btrfs_super_chunk_root_generation(disk_super);
2806
2807         __setup_root(nodesize, sectorsize, stripesize, chunk_root,
2808                      fs_info, BTRFS_CHUNK_TREE_OBJECTID);
2809
2810         chunk_root->node = read_tree_block(chunk_root,
2811                                            btrfs_super_chunk_root(disk_super),
2812                                            generation);
2813         if (IS_ERR(chunk_root->node) ||
2814             !extent_buffer_uptodate(chunk_root->node)) {
2815                 btrfs_err(fs_info, "failed to read chunk root");
2816                 if (!IS_ERR(chunk_root->node))
2817                         free_extent_buffer(chunk_root->node);
2818                 chunk_root->node = NULL;
2819                 goto fail_tree_roots;
2820         }
2821         btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
2822         chunk_root->commit_root = btrfs_root_node(chunk_root);
2823
2824         read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2825            btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
2826
2827         ret = btrfs_read_chunk_tree(chunk_root);
2828         if (ret) {
2829                 btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
2830                 goto fail_tree_roots;
2831         }
2832
2833         /*
2834          * keep the device that is marked to be the target device for the
2835          * dev_replace procedure
2836          */
2837         btrfs_close_extra_devices(fs_devices, 0);
2838
2839         if (!fs_devices->latest_bdev) {
2840                 btrfs_err(fs_info, "failed to read devices");
2841                 goto fail_tree_roots;
2842         }
2843
2844 retry_root_backup:
2845         generation = btrfs_super_generation(disk_super);
2846
2847         tree_root->node = read_tree_block(tree_root,
2848                                           btrfs_super_root(disk_super),
2849                                           generation);
2850         if (IS_ERR(tree_root->node) ||
2851             !extent_buffer_uptodate(tree_root->node)) {
2852                 btrfs_warn(fs_info, "failed to read tree root");
2853                 if (!IS_ERR(tree_root->node))
2854                         free_extent_buffer(tree_root->node);
2855                 tree_root->node = NULL;
2856                 goto recovery_tree_root;
2857         }
2858
2859         btrfs_set_root_node(&tree_root->root_item, tree_root->node);
2860         tree_root->commit_root = btrfs_root_node(tree_root);
2861         btrfs_set_root_refs(&tree_root->root_item, 1);
2862
2863         mutex_lock(&tree_root->objectid_mutex);
2864         ret = btrfs_find_highest_objectid(tree_root,
2865                                         &tree_root->highest_objectid);
2866         if (ret) {
2867                 mutex_unlock(&tree_root->objectid_mutex);
2868                 goto recovery_tree_root;
2869         }
2870
2871         ASSERT(tree_root->highest_objectid <= BTRFS_LAST_FREE_OBJECTID);
2872
2873         mutex_unlock(&tree_root->objectid_mutex);
2874
2875         ret = btrfs_read_roots(fs_info, tree_root);
2876         if (ret)
2877                 goto recovery_tree_root;
2878
2879         fs_info->generation = generation;
2880         fs_info->last_trans_committed = generation;
2881
2882         ret = btrfs_recover_balance(fs_info);
2883         if (ret) {
2884                 btrfs_err(fs_info, "failed to recover balance: %d", ret);
2885                 goto fail_block_groups;
2886         }
2887
2888         ret = btrfs_init_dev_stats(fs_info);
2889         if (ret) {
2890                 btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
2891                 goto fail_block_groups;
2892         }
2893
2894         ret = btrfs_init_dev_replace(fs_info);
2895         if (ret) {
2896                 btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
2897                 goto fail_block_groups;
2898         }
2899
2900         btrfs_close_extra_devices(fs_devices, 1);
2901
2902         ret = btrfs_sysfs_add_fsid(fs_devices, NULL);
2903         if (ret) {
2904                 btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
2905                                 ret);
2906                 goto fail_block_groups;
2907         }
2908
2909         ret = btrfs_sysfs_add_device(fs_devices);
2910         if (ret) {
2911                 btrfs_err(fs_info, "failed to init sysfs device interface: %d",
2912                                 ret);
2913                 goto fail_fsdev_sysfs;
2914         }
2915
2916         ret = btrfs_sysfs_add_mounted(fs_info);
2917         if (ret) {
2918                 btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
2919                 goto fail_fsdev_sysfs;
2920         }
2921
2922         ret = btrfs_init_space_info(fs_info);
2923         if (ret) {
2924                 btrfs_err(fs_info, "failed to initialize space info: %d", ret);
2925                 goto fail_sysfs;
2926         }
2927
2928         ret = btrfs_read_block_groups(fs_info->extent_root);
2929         if (ret) {
2930                 btrfs_err(fs_info, "failed to read block groups: %d", ret);
2931                 goto fail_sysfs;
2932         }
2933         fs_info->num_tolerated_disk_barrier_failures =
2934                 btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
2935         if (fs_info->fs_devices->missing_devices >
2936              fs_info->num_tolerated_disk_barrier_failures &&
2937             !(sb->s_flags & MS_RDONLY)) {
2938                 btrfs_warn(fs_info,
2939 "missing devices (%llu) exceeds the limit (%d), writeable mount is not allowed",
2940                         fs_info->fs_devices->missing_devices,
2941                         fs_info->num_tolerated_disk_barrier_failures);
2942                 goto fail_sysfs;
2943         }
2944
2945         fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
2946                                                "btrfs-cleaner");
2947         if (IS_ERR(fs_info->cleaner_kthread))
2948                 goto fail_sysfs;
2949
2950         fs_info->transaction_kthread = kthread_run(transaction_kthread,
2951                                                    tree_root,
2952                                                    "btrfs-transaction");
2953         if (IS_ERR(fs_info->transaction_kthread))
2954                 goto fail_cleaner;
2955
2956         if (!btrfs_test_opt(tree_root->fs_info, SSD) &&
2957             !btrfs_test_opt(tree_root->fs_info, NOSSD) &&
2958             !fs_info->fs_devices->rotating) {
2959                 btrfs_info(fs_info, "detected SSD devices, enabling SSD mode");
2960                 btrfs_set_opt(fs_info->mount_opt, SSD);
2961         }
2962
2963         /*
2964          * Mount does not set all options immediately, we can do it now and do
2965          * not have to wait for transaction commit
2966          */
2967         btrfs_apply_pending_changes(fs_info);
2968
2969 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2970         if (btrfs_test_opt(tree_root->fs_info, CHECK_INTEGRITY)) {
2971                 ret = btrfsic_mount(tree_root, fs_devices,
2972                                     btrfs_test_opt(tree_root->fs_info,
2973                                         CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
2974                                     1 : 0,
2975                                     fs_info->check_integrity_print_mask);
2976                 if (ret)
2977                         btrfs_warn(fs_info,
2978                                 "failed to initialize integrity check module: %d",
2979                                 ret);
2980         }
2981 #endif
2982         ret = btrfs_read_qgroup_config(fs_info);
2983         if (ret)
2984                 goto fail_trans_kthread;
2985
2986         /* do not make disk changes in broken FS or nologreplay is given */
2987         if (btrfs_super_log_root(disk_super) != 0 &&
2988             !btrfs_test_opt(tree_root->fs_info, NOLOGREPLAY)) {
2989                 btrfs_info(fs_info, "start tree-log replay");
2990                 ret = btrfs_replay_log(fs_info, fs_devices);
2991                 if (ret) {
2992                         err = ret;
2993                         goto fail_qgroup;
2994                 }
2995         }
2996
2997         ret = btrfs_find_orphan_roots(tree_root);
2998         if (ret)
2999                 goto fail_qgroup;
3000
3001         if (!(sb->s_flags & MS_RDONLY)) {
3002                 ret = btrfs_cleanup_fs_roots(fs_info);
3003                 if (ret)
3004                         goto fail_qgroup;
3005
3006                 mutex_lock(&fs_info->cleaner_mutex);
3007                 ret = btrfs_recover_relocation(tree_root);
3008                 mutex_unlock(&fs_info->cleaner_mutex);
3009                 if (ret < 0) {
3010                         btrfs_warn(fs_info, "failed to recover relocation: %d",
3011                                         ret);
3012                         err = -EINVAL;
3013                         goto fail_qgroup;
3014                 }
3015         }
3016
3017         location.objectid = BTRFS_FS_TREE_OBJECTID;
3018         location.type = BTRFS_ROOT_ITEM_KEY;
3019         location.offset = 0;
3020
3021         fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
3022         if (IS_ERR(fs_info->fs_root)) {
3023                 err = PTR_ERR(fs_info->fs_root);
3024                 goto fail_qgroup;
3025         }
3026
3027         if (sb->s_flags & MS_RDONLY)
3028                 return 0;
3029
3030         if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
3031             btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
3032                 clear_free_space_tree = 1;
3033         } else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
3034                    !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
3035                 btrfs_warn(fs_info, "free space tree is invalid");
3036                 clear_free_space_tree = 1;
3037         }
3038
3039         if (clear_free_space_tree) {
3040                 btrfs_info(fs_info, "clearing free space tree");
3041                 ret = btrfs_clear_free_space_tree(fs_info);
3042                 if (ret) {
3043                         btrfs_warn(fs_info,
3044                                    "failed to clear free space tree: %d", ret);
3045                         close_ctree(tree_root);
3046                         return ret;
3047                 }
3048         }
3049
3050         if (btrfs_test_opt(tree_root->fs_info, FREE_SPACE_TREE) &&
3051             !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
3052                 btrfs_info(fs_info, "creating free space tree");
3053                 ret = btrfs_create_free_space_tree(fs_info);
3054                 if (ret) {
3055                         btrfs_warn(fs_info,
3056                                 "failed to create free space tree: %d", ret);
3057                         close_ctree(tree_root);
3058                         return ret;
3059                 }
3060         }
3061
3062         down_read(&fs_info->cleanup_work_sem);
3063         if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
3064             (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
3065                 up_read(&fs_info->cleanup_work_sem);
3066                 close_ctree(tree_root);
3067                 return ret;
3068         }
3069         up_read(&fs_info->cleanup_work_sem);
3070
3071         ret = btrfs_resume_balance_async(fs_info);
3072         if (ret) {
3073                 btrfs_warn(fs_info, "failed to resume balance: %d", ret);
3074                 close_ctree(tree_root);
3075                 return ret;
3076         }
3077
3078         ret = btrfs_resume_dev_replace_async(fs_info);
3079         if (ret) {
3080                 btrfs_warn(fs_info, "failed to resume device replace: %d", ret);
3081                 close_ctree(tree_root);
3082                 return ret;
3083         }
3084
3085         btrfs_qgroup_rescan_resume(fs_info);
3086
3087         if (!fs_info->uuid_root) {
3088                 btrfs_info(fs_info, "creating UUID tree");
3089                 ret = btrfs_create_uuid_tree(fs_info);
3090                 if (ret) {
3091                         btrfs_warn(fs_info,
3092                                 "failed to create the UUID tree: %d", ret);
3093                         close_ctree(tree_root);
3094                         return ret;
3095                 }
3096         } else if (btrfs_test_opt(tree_root->fs_info, RESCAN_UUID_TREE) ||
3097                    fs_info->generation !=
3098                                 btrfs_super_uuid_tree_generation(disk_super)) {
3099                 btrfs_info(fs_info, "checking UUID tree");
3100                 ret = btrfs_check_uuid_tree(fs_info);
3101                 if (ret) {
3102                         btrfs_warn(fs_info,
3103                                 "failed to check the UUID tree: %d", ret);
3104                         close_ctree(tree_root);
3105                         return ret;
3106                 }
3107         } else {
3108                 set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
3109         }
3110         set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3111
3112         /*
3113          * backuproot only affect mount behavior, and if open_ctree succeeded,
3114          * no need to keep the flag
3115          */
3116         btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);
3117
3118         return 0;
3119
3120 fail_qgroup:
3121         btrfs_free_qgroup_config(fs_info);
3122 fail_trans_kthread:
3123         kthread_stop(fs_info->transaction_kthread);
3124         btrfs_cleanup_transaction(fs_info->tree_root);
3125         btrfs_free_fs_roots(fs_info);
3126 fail_cleaner:
3127         kthread_stop(fs_info->cleaner_kthread);
3128
3129         /*
3130          * make sure we're done with the btree inode before we stop our
3131          * kthreads
3132          */
3133         filemap_write_and_wait(fs_info->btree_inode->i_mapping);
3134
3135 fail_sysfs:
3136         btrfs_sysfs_remove_mounted(fs_info);
3137
3138 fail_fsdev_sysfs:
3139         btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3140
3141 fail_block_groups:
3142         btrfs_put_block_group_cache(fs_info);
3143         btrfs_free_block_groups(fs_info);
3144
3145 fail_tree_roots:
3146         free_root_pointers(fs_info, true);
3147         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3148
3149 fail_sb_buffer:
3150         btrfs_stop_all_workers(fs_info);
3151 fail_alloc:
3152 fail_iput:
3153         btrfs_mapping_tree_free(&fs_info->mapping_tree);
3154
3155         iput(fs_info->btree_inode);
3156 fail_bio_counter:
3157         percpu_counter_destroy(&fs_info->bio_counter);
3158 fail_delalloc_bytes:
3159         percpu_counter_destroy(&fs_info->delalloc_bytes);
3160 fail_dirty_metadata_bytes:
3161         percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3162 fail_bdi:
3163         bdi_destroy(&fs_info->bdi);
3164 fail_srcu:
3165         cleanup_srcu_struct(&fs_info->subvol_srcu);
3166 fail:
3167         btrfs_free_stripe_hash_table(fs_info);
3168         btrfs_close_devices(fs_info->fs_devices);
3169         return err;
3170
3171 recovery_tree_root:
3172         if (!btrfs_test_opt(tree_root->fs_info, USEBACKUPROOT))
3173                 goto fail_tree_roots;
3174
3175         free_root_pointers(fs_info, false);
3176
3177         /* don't use the log in recovery mode, it won't be valid */
3178         btrfs_set_super_log_root(disk_super, 0);
3179
3180         /* we can't trust the free space cache either */
3181         btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
3182
3183         ret = next_root_backup(fs_info, fs_info->super_copy,
3184                                &num_backups_tried, &backup_index);
3185         if (ret == -1)
3186                 goto fail_block_groups;
3187         goto retry_root_backup;
3188 }
3189
3190 static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
3191 {
3192         if (uptodate) {
3193                 set_buffer_uptodate(bh);
3194         } else {
3195                 struct btrfs_device *device = (struct btrfs_device *)
3196                         bh->b_private;
3197
3198                 btrfs_warn_rl_in_rcu(device->dev_root->fs_info,
3199                                 "lost page write due to IO error on %s",
3200                                           rcu_str_deref(device->name));
3201                 /* note, we don't set_buffer_write_io_error because we have
3202                  * our own ways of dealing with the IO errors
3203                  */
3204                 clear_buffer_uptodate(bh);
3205                 btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
3206         }
3207         unlock_buffer(bh);
3208         put_bh(bh);
3209 }
3210
3211 int btrfs_read_dev_one_super(struct block_device *bdev, int copy_num,
3212                         struct buffer_head **bh_ret)
3213 {
3214         struct buffer_head *bh;
3215         struct btrfs_super_block *super;
3216         u64 bytenr;
3217
3218         bytenr = btrfs_sb_offset(copy_num);
3219         if (bytenr + BTRFS_SUPER_INFO_SIZE >= i_size_read(bdev->bd_inode))
3220                 return -EINVAL;
3221
3222         bh = __bread(bdev, bytenr / 4096, BTRFS_SUPER_INFO_SIZE);
3223         /*
3224          * If we fail to read from the underlying devices, as of now
3225          * the best option we have is to mark it EIO.
3226          */
3227         if (!bh)
3228                 return -EIO;
3229
3230         super = (struct btrfs_super_block *)bh->b_data;
3231         if (btrfs_super_bytenr(super) != bytenr ||
3232                     btrfs_super_magic(super) != BTRFS_MAGIC) {
3233                 brelse(bh);
3234                 return -EINVAL;
3235         }
3236
3237         *bh_ret = bh;
3238         return 0;
3239 }
3240
3241
3242 struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
3243 {
3244         struct buffer_head *bh;
3245         struct buffer_head *latest = NULL;
3246         struct btrfs_super_block *super;
3247         int i;
3248         u64 transid = 0;
3249         int ret = -EINVAL;
3250
3251         /* we would like to check all the supers, but that would make
3252          * a btrfs mount succeed after a mkfs from a different FS.
3253          * So, we need to add a special mount option to scan for
3254          * later supers, using BTRFS_SUPER_MIRROR_MAX instead
3255          */
3256         for (i = 0; i < 1; i++) {
3257                 ret = btrfs_read_dev_one_super(bdev, i, &bh);
3258                 if (ret)
3259                         continue;
3260
3261                 super = (struct btrfs_super_block *)bh->b_data;
3262
3263                 if (!latest || btrfs_super_generation(super) > transid) {
3264                         brelse(latest);
3265                         latest = bh;
3266                         transid = btrfs_super_generation(super);
3267                 } else {
3268                         brelse(bh);
3269                 }
3270         }
3271
3272         if (!latest)
3273                 return ERR_PTR(ret);
3274
3275         return latest;
3276 }
3277
3278 /*
3279  * this should be called twice, once with wait == 0 and
3280  * once with wait == 1.  When wait == 0 is done, all the buffer heads
3281  * we write are pinned.
3282  *
3283  * They are released when wait == 1 is done.
3284  * max_mirrors must be the same for both runs, and it indicates how
3285  * many supers on this one device should be written.
3286  *
3287  * max_mirrors == 0 means to write them all.
3288  */
3289 static int write_dev_supers(struct btrfs_device *device,
3290                             struct btrfs_super_block *sb,
3291                             int do_barriers, int wait, int max_mirrors)
3292 {
3293         struct buffer_head *bh;
3294         int i;
3295         int ret;
3296         int errors = 0;
3297         u32 crc;
3298         u64 bytenr;
3299
3300         if (max_mirrors == 0)
3301                 max_mirrors = BTRFS_SUPER_MIRROR_MAX;
3302
3303         for (i = 0; i < max_mirrors; i++) {
3304                 bytenr = btrfs_sb_offset(i);
3305                 if (bytenr + BTRFS_SUPER_INFO_SIZE >=
3306                     device->commit_total_bytes)
3307                         break;
3308
3309                 if (wait) {
3310                         bh = __find_get_block(device->bdev, bytenr / 4096,
3311                                               BTRFS_SUPER_INFO_SIZE);
3312                         if (!bh) {
3313                                 errors++;
3314                                 continue;
3315                         }
3316                         wait_on_buffer(bh);
3317                         if (!buffer_uptodate(bh))
3318                                 errors++;
3319
3320                         /* drop our reference */
3321                         brelse(bh);
3322
3323                         /* drop the reference from the wait == 0 run */
3324                         brelse(bh);
3325                         continue;
3326                 } else {
3327                         btrfs_set_super_bytenr(sb, bytenr);
3328
3329                         crc = ~(u32)0;
3330                         crc = btrfs_csum_data((char *)sb +
3331                                               BTRFS_CSUM_SIZE, crc,
3332                                               BTRFS_SUPER_INFO_SIZE -
3333                                               BTRFS_CSUM_SIZE);
3334                         btrfs_csum_final(crc, sb->csum);
3335
3336                         /*
3337                          * one reference for us, and we leave it for the
3338                          * caller
3339                          */
3340                         bh = __getblk(device->bdev, bytenr / 4096,
3341                                       BTRFS_SUPER_INFO_SIZE);
3342                         if (!bh) {
3343                                 btrfs_err(device->dev_root->fs_info,
3344                                     "couldn't get super buffer head for bytenr %llu",
3345                                     bytenr);
3346                                 errors++;
3347                                 continue;
3348                         }
3349
3350                         memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
3351
3352                         /* one reference for submit_bh */
3353                         get_bh(bh);
3354
3355                         set_buffer_uptodate(bh);
3356                         lock_buffer(bh);
3357                         bh->b_end_io = btrfs_end_buffer_write_sync;
3358                         bh->b_private = device;
3359                 }
3360
3361                 /*
3362                  * we fua the first super.  The others we allow
3363                  * to go down lazy.
3364                  */
3365                 if (i == 0)
3366                         ret = btrfsic_submit_bh(REQ_OP_WRITE, WRITE_FUA, bh);
3367                 else
3368                         ret = btrfsic_submit_bh(REQ_OP_WRITE, WRITE_SYNC, bh);
3369                 if (ret)
3370                         errors++;
3371         }
3372         return errors < i ? 0 : -1;
3373 }
3374
3375 /*
3376  * endio for the write_dev_flush, this will wake anyone waiting
3377  * for the barrier when it is done
3378  */
3379 static void btrfs_end_empty_barrier(struct bio *bio)
3380 {
3381         if (bio->bi_private)
3382                 complete(bio->bi_private);
3383         bio_put(bio);
3384 }
3385
3386 /*
3387  * trigger flushes for one the devices.  If you pass wait == 0, the flushes are
3388  * sent down.  With wait == 1, it waits for the previous flush.
3389  *
3390  * any device where the flush fails with eopnotsupp are flagged as not-barrier
3391  * capable
3392  */
3393 static int write_dev_flush(struct btrfs_device *device, int wait)
3394 {
3395         struct bio *bio;
3396         int ret = 0;
3397
3398         if (device->nobarriers)
3399                 return 0;
3400
3401         if (wait) {
3402                 bio = device->flush_bio;
3403                 if (!bio)
3404                         return 0;
3405
3406                 wait_for_completion(&device->flush_wait);
3407
3408                 if (bio->bi_error) {
3409                         ret = bio->bi_error;
3410                         btrfs_dev_stat_inc_and_print(device,
3411                                 BTRFS_DEV_STAT_FLUSH_ERRS);
3412                 }
3413
3414                 /* drop the reference from the wait == 0 run */
3415                 bio_put(bio);
3416                 device->flush_bio = NULL;
3417
3418                 return ret;
3419         }
3420
3421         /*
3422          * one reference for us, and we leave it for the
3423          * caller
3424          */
3425         device->flush_bio = NULL;
3426         bio = btrfs_io_bio_alloc(GFP_NOFS, 0);
3427         if (!bio)
3428                 return -ENOMEM;
3429
3430         bio->bi_end_io = btrfs_end_empty_barrier;
3431         bio->bi_bdev = device->bdev;
3432         bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_FLUSH);
3433         init_completion(&device->flush_wait);
3434         bio->bi_private = &device->flush_wait;
3435         device->flush_bio = bio;
3436
3437         bio_get(bio);
3438         btrfsic_submit_bio(bio);
3439
3440         return 0;
3441 }
3442
3443 /*
3444  * send an empty flush down to each device in parallel,
3445  * then wait for them
3446  */
3447 static int barrier_all_devices(struct btrfs_fs_info *info)
3448 {
3449         struct list_head *head;
3450         struct btrfs_device *dev;
3451         int errors_send = 0;
3452         int errors_wait = 0;
3453         int ret;
3454
3455         /* send down all the barriers */
3456         head = &info->fs_devices->devices;
3457         list_for_each_entry_rcu(dev, head, dev_list) {
3458                 if (dev->missing)
3459                         continue;
3460                 if (!dev->bdev) {
3461                         errors_send++;
3462                         continue;
3463                 }
3464                 if (!dev->in_fs_metadata || !dev->writeable)
3465                         continue;
3466
3467                 ret = write_dev_flush(dev, 0);
3468                 if (ret)
3469                         errors_send++;
3470         }
3471
3472         /* wait for all the barriers */
3473         list_for_each_entry_rcu(dev, head, dev_list) {
3474                 if (dev->missing)
3475                         continue;
3476                 if (!dev->bdev) {
3477                         errors_wait++;
3478                         continue;
3479                 }
3480                 if (!dev->in_fs_metadata || !dev->writeable)
3481                         continue;
3482
3483                 ret = write_dev_flush(dev, 1);
3484                 if (ret)
3485                         errors_wait++;
3486         }
3487         if (errors_send > info->num_tolerated_disk_barrier_failures ||
3488             errors_wait > info->num_tolerated_disk_barrier_failures)
3489                 return -EIO;
3490         return 0;
3491 }
3492
3493 int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags)
3494 {
3495         int raid_type;
3496         int min_tolerated = INT_MAX;
3497
3498         if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 ||
3499             (flags & BTRFS_AVAIL_ALLOC_BIT_SINGLE))
3500                 min_tolerated = min(min_tolerated,
3501                                     btrfs_raid_array[BTRFS_RAID_SINGLE].
3502                                     tolerated_failures);
3503
3504         for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
3505                 if (raid_type == BTRFS_RAID_SINGLE)
3506                         continue;
3507                 if (!(flags & btrfs_raid_group[raid_type]))
3508                         continue;
3509                 min_tolerated = min(min_tolerated,
3510                                     btrfs_raid_array[raid_type].
3511                                     tolerated_failures);
3512         }
3513
3514         if (min_tolerated == INT_MAX) {
3515                 pr_warn("BTRFS: unknown raid flag: %llu", flags);
3516                 min_tolerated = 0;
3517         }
3518
3519         return min_tolerated;
3520 }
3521
3522 int btrfs_calc_num_tolerated_disk_barrier_failures(
3523         struct btrfs_fs_info *fs_info)
3524 {
3525         struct btrfs_ioctl_space_info space;
3526         struct btrfs_space_info *sinfo;
3527         u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
3528                        BTRFS_BLOCK_GROUP_SYSTEM,
3529                        BTRFS_BLOCK_GROUP_METADATA,
3530                        BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
3531         int i;
3532         int c;
3533         int num_tolerated_disk_barrier_failures =
3534                 (int)fs_info->fs_devices->num_devices;
3535
3536         for (i = 0; i < ARRAY_SIZE(types); i++) {
3537                 struct btrfs_space_info *tmp;
3538
3539                 sinfo = NULL;
3540                 rcu_read_lock();
3541                 list_for_each_entry_rcu(tmp, &fs_info->space_info, list) {
3542                         if (tmp->flags == types[i]) {
3543                                 sinfo = tmp;
3544                                 break;
3545                         }
3546                 }
3547                 rcu_read_unlock();
3548
3549                 if (!sinfo)
3550                         continue;
3551
3552                 down_read(&sinfo->groups_sem);
3553                 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3554                         u64 flags;
3555
3556                         if (list_empty(&sinfo->block_groups[c]))
3557                                 continue;
3558
3559                         btrfs_get_block_group_info(&sinfo->block_groups[c],
3560                                                    &space);
3561                         if (space.total_bytes == 0 || space.used_bytes == 0)
3562                                 continue;
3563                         flags = space.flags;
3564
3565                         num_tolerated_disk_barrier_failures = min(
3566                                 num_tolerated_disk_barrier_failures,
3567                                 btrfs_get_num_tolerated_disk_barrier_failures(
3568                                         flags));
3569                 }
3570                 up_read(&sinfo->groups_sem);
3571         }
3572
3573         return num_tolerated_disk_barrier_failures;
3574 }
3575
3576 static int write_all_supers(struct btrfs_root *root, int max_mirrors)
3577 {
3578         struct list_head *head;
3579         struct btrfs_device *dev;
3580         struct btrfs_super_block *sb;
3581         struct btrfs_dev_item *dev_item;
3582         int ret;
3583         int do_barriers;
3584         int max_errors;
3585         int total_errors = 0;
3586         u64 flags;
3587
3588         do_barriers = !btrfs_test_opt(root->fs_info, NOBARRIER);
3589         backup_super_roots(root->fs_info);
3590
3591         sb = root->fs_info->super_for_commit;
3592         dev_item = &sb->dev_item;
3593
3594         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
3595         head = &root->fs_info->fs_devices->devices;
3596         max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
3597
3598         if (do_barriers) {
3599                 ret = barrier_all_devices(root->fs_info);
3600                 if (ret) {
3601                         mutex_unlock(
3602                                 &root->fs_info->fs_devices->device_list_mutex);
3603                         btrfs_handle_fs_error(root->fs_info, ret,
3604                                     "errors while submitting device barriers.");
3605                         return ret;
3606                 }
3607         }
3608
3609         list_for_each_entry_rcu(dev, head, dev_list) {
3610                 if (!dev->bdev) {
3611                         total_errors++;
3612                         continue;
3613                 }
3614                 if (!dev->in_fs_metadata || !dev->writeable)
3615                         continue;
3616
3617                 btrfs_set_stack_device_generation(dev_item, 0);
3618                 btrfs_set_stack_device_type(dev_item, dev->type);
3619                 btrfs_set_stack_device_id(dev_item, dev->devid);
3620                 btrfs_set_stack_device_total_bytes(dev_item,
3621                                                    dev->commit_total_bytes);
3622                 btrfs_set_stack_device_bytes_used(dev_item,
3623                                                   dev->commit_bytes_used);
3624                 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
3625                 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
3626                 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
3627                 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
3628                 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
3629
3630                 flags = btrfs_super_flags(sb);
3631                 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
3632
3633                 ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3634                 if (ret)
3635                         total_errors++;
3636         }
3637         if (total_errors > max_errors) {
3638                 btrfs_err(root->fs_info, "%d errors while writing supers",
3639                        total_errors);
3640                 mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3641
3642                 /* FUA is masked off if unsupported and can't be the reason */
3643                 btrfs_handle_fs_error(root->fs_info, -EIO,
3644                             "%d errors while writing supers", total_errors);
3645                 return -EIO;
3646         }
3647
3648         total_errors = 0;
3649         list_for_each_entry_rcu(dev, head, dev_list) {
3650                 if (!dev->bdev)
3651                         continue;
3652                 if (!dev->in_fs_metadata || !dev->writeable)
3653                         continue;
3654
3655                 ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
3656                 if (ret)
3657                         total_errors++;
3658         }
3659         mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3660         if (total_errors > max_errors) {
3661                 btrfs_handle_fs_error(root->fs_info, -EIO,
3662                             "%d errors while writing supers", total_errors);
3663                 return -EIO;
3664         }
3665         return 0;
3666 }
3667
3668 int write_ctree_super(struct btrfs_trans_handle *trans,
3669                       struct btrfs_root *root, int max_mirrors)
3670 {
3671         return write_all_supers(root, max_mirrors);
3672 }
3673
3674 /* Drop a fs root from the radix tree and free it. */
3675 void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
3676                                   struct btrfs_root *root)
3677 {
3678         spin_lock(&fs_info->fs_roots_radix_lock);
3679         radix_tree_delete(&fs_info->fs_roots_radix,
3680                           (unsigned long)root->root_key.objectid);
3681         spin_unlock(&fs_info->fs_roots_radix_lock);
3682
3683         if (btrfs_root_refs(&root->root_item) == 0)
3684                 synchronize_srcu(&fs_info->subvol_srcu);
3685
3686         if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
3687                 btrfs_free_log(NULL, root);
3688                 if (root->reloc_root) {
3689                         free_extent_buffer(root->reloc_root->node);
3690                         free_extent_buffer(root->reloc_root->commit_root);
3691                         btrfs_put_fs_root(root->reloc_root);
3692                         root->reloc_root = NULL;
3693                 }
3694         }
3695
3696         if (root->free_ino_pinned)
3697                 __btrfs_remove_free_space_cache(root->free_ino_pinned);
3698         if (root->free_ino_ctl)
3699                 __btrfs_remove_free_space_cache(root->free_ino_ctl);
3700         free_fs_root(root);
3701 }
3702
3703 static void free_fs_root(struct btrfs_root *root)
3704 {
3705         iput(root->ino_cache_inode);
3706         WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3707         btrfs_free_block_rsv(root, root->orphan_block_rsv);
3708         root->orphan_block_rsv = NULL;
3709         if (root->anon_dev)
3710                 free_anon_bdev(root->anon_dev);
3711         if (root->subv_writers)
3712                 btrfs_free_subvolume_writers(root->subv_writers);
3713         free_extent_buffer(root->node);
3714         free_extent_buffer(root->commit_root);
3715         kfree(root->free_ino_ctl);
3716         kfree(root->free_ino_pinned);
3717         kfree(root->name);
3718         btrfs_put_fs_root(root);
3719 }
3720
3721 void btrfs_free_fs_root(struct btrfs_root *root)
3722 {
3723         free_fs_root(root);
3724 }
3725
3726 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
3727 {
3728         u64 root_objectid = 0;
3729         struct btrfs_root *gang[8];
3730         int i = 0;
3731         int err = 0;
3732         unsigned int ret = 0;
3733         int index;
3734
3735         while (1) {
3736                 index = srcu_read_lock(&fs_info->subvol_srcu);
3737                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3738                                              (void **)gang, root_objectid,
3739                                              ARRAY_SIZE(gang));
3740                 if (!ret) {
3741                         srcu_read_unlock(&fs_info->subvol_srcu, index);
3742                         break;
3743                 }
3744                 root_objectid = gang[ret - 1]->root_key.objectid + 1;
3745
3746                 for (i = 0; i < ret; i++) {
3747                         /* Avoid to grab roots in dead_roots */
3748                         if (btrfs_root_refs(&gang[i]->root_item) == 0) {
3749                                 gang[i] = NULL;
3750                                 continue;
3751                         }
3752                         /* grab all the search result for later use */
3753                         gang[i] = btrfs_grab_fs_root(gang[i]);
3754                 }
3755                 srcu_read_unlock(&fs_info->subvol_srcu, index);
3756
3757                 for (i = 0; i < ret; i++) {
3758                         if (!gang[i])
3759                                 continue;
3760                         root_objectid = gang[i]->root_key.objectid;
3761                         err = btrfs_orphan_cleanup(gang[i]);
3762                         if (err)
3763                                 break;
3764                         btrfs_put_fs_root(gang[i]);
3765                 }
3766                 root_objectid++;
3767         }
3768
3769         /* release the uncleaned roots due to error */
3770         for (; i < ret; i++) {
3771                 if (gang[i])
3772                         btrfs_put_fs_root(gang[i]);
3773         }
3774         return err;
3775 }
3776
3777 int btrfs_commit_super(struct btrfs_root *root)
3778 {
3779         struct btrfs_trans_handle *trans;
3780
3781         mutex_lock(&root->fs_info->cleaner_mutex);
3782         btrfs_run_delayed_iputs(root);
3783         mutex_unlock(&root->fs_info->cleaner_mutex);
3784         wake_up_process(root->fs_info->cleaner_kthread);
3785
3786         /* wait until ongoing cleanup work done */
3787         down_write(&root->fs_info->cleanup_work_sem);
3788         up_write(&root->fs_info->cleanup_work_sem);
3789
3790         trans = btrfs_join_transaction(root);
3791         if (IS_ERR(trans))
3792                 return PTR_ERR(trans);
3793         return btrfs_commit_transaction(trans, root);
3794 }
3795
3796 void close_ctree(struct btrfs_root *root)
3797 {
3798         struct btrfs_fs_info *fs_info = root->fs_info;
3799         int ret;
3800
3801         set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
3802
3803         /* wait for the qgroup rescan worker to stop */
3804         btrfs_qgroup_wait_for_completion(fs_info, false);
3805
3806         /* wait for the uuid_scan task to finish */
3807         down(&fs_info->uuid_tree_rescan_sem);
3808         /* avoid complains from lockdep et al., set sem back to initial state */
3809         up(&fs_info->uuid_tree_rescan_sem);
3810
3811         /* pause restriper - we want to resume on mount */
3812         btrfs_pause_balance(fs_info);
3813
3814         btrfs_dev_replace_suspend_for_unmount(fs_info);
3815
3816         btrfs_scrub_cancel(fs_info);
3817
3818         /* wait for any defraggers to finish */
3819         wait_event(fs_info->transaction_wait,
3820                    (atomic_read(&fs_info->defrag_running) == 0));
3821
3822         /* clear out the rbtree of defraggable inodes */
3823         btrfs_cleanup_defrag_inodes(fs_info);
3824
3825         cancel_work_sync(&fs_info->async_reclaim_work);
3826
3827         if (!(fs_info->sb->s_flags & MS_RDONLY)) {
3828                 /*
3829                  * If the cleaner thread is stopped and there are
3830                  * block groups queued for removal, the deletion will be
3831                  * skipped when we quit the cleaner thread.
3832                  */
3833                 btrfs_delete_unused_bgs(root->fs_info);
3834
3835                 /*
3836                  * There might be existing delayed inode workers still running
3837                  * and holding an empty delayed inode item. We must wait for
3838                  * them to complete first because they can create a transaction.
3839                  * This happens when someone calls btrfs_balance_delayed_items()
3840                  * and then a transaction commit runs the same delayed nodes
3841                  * before any delayed worker has done something with the nodes.
3842                  * We must wait for any worker here and not at transaction
3843                  * commit time since that could cause a deadlock.
3844                  * This is a very rare case.
3845                  */
3846                 btrfs_flush_workqueue(fs_info->delayed_workers);
3847
3848                 ret = btrfs_commit_super(root);
3849                 if (ret)
3850                         btrfs_err(fs_info, "commit super ret %d", ret);
3851         }
3852
3853         if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
3854                 btrfs_error_commit_super(root);
3855
3856         kthread_stop(fs_info->transaction_kthread);
3857         kthread_stop(fs_info->cleaner_kthread);
3858
3859         set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
3860
3861         btrfs_free_qgroup_config(fs_info);
3862
3863         if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
3864                 btrfs_info(fs_info, "at unmount delalloc count %lld",
3865                        percpu_counter_sum(&fs_info->delalloc_bytes));
3866         }
3867
3868         btrfs_sysfs_remove_mounted(fs_info);
3869         btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3870
3871         btrfs_free_fs_roots(fs_info);
3872
3873         btrfs_put_block_group_cache(fs_info);
3874
3875         btrfs_free_block_groups(fs_info);
3876
3877         /*
3878          * we must make sure there is not any read request to
3879          * submit after we stopping all workers.
3880          */
3881         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3882         btrfs_stop_all_workers(fs_info);
3883
3884         clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
3885         free_root_pointers(fs_info, true);
3886
3887         iput(fs_info->btree_inode);
3888
3889 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3890         if (btrfs_test_opt(root->fs_info, CHECK_INTEGRITY))
3891                 btrfsic_unmount(root, fs_info->fs_devices);
3892 #endif
3893
3894         btrfs_close_devices(fs_info->fs_devices);
3895         btrfs_mapping_tree_free(&fs_info->mapping_tree);
3896
3897         percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3898         percpu_counter_destroy(&fs_info->delalloc_bytes);
3899         percpu_counter_destroy(&fs_info->bio_counter);
3900         bdi_destroy(&fs_info->bdi);
3901         cleanup_srcu_struct(&fs_info->subvol_srcu);
3902
3903         btrfs_free_stripe_hash_table(fs_info);
3904
3905         __btrfs_free_block_rsv(root->orphan_block_rsv);
3906         root->orphan_block_rsv = NULL;
3907
3908         lock_chunks(root);
3909         while (!list_empty(&fs_info->pinned_chunks)) {
3910                 struct extent_map *em;
3911
3912                 em = list_first_entry(&fs_info->pinned_chunks,
3913                                       struct extent_map, list);
3914                 list_del_init(&em->list);
3915                 free_extent_map(em);
3916         }
3917         unlock_chunks(root);
3918 }
3919
3920 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
3921                           int atomic)
3922 {
3923         int ret;
3924         struct inode *btree_inode = buf->pages[0]->mapping->host;
3925
3926         ret = extent_buffer_uptodate(buf);
3927         if (!ret)
3928                 return ret;
3929
3930         ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3931                                     parent_transid, atomic);
3932         if (ret == -EAGAIN)
3933                 return ret;
3934         return !ret;
3935 }
3936
3937 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
3938 {
3939         struct btrfs_root *root;
3940         u64 transid = btrfs_header_generation(buf);
3941         int was_dirty;
3942
3943 #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
3944         /*
3945          * This is a fast path so only do this check if we have sanity tests
3946          * enabled.  Normal people shouldn't be marking dummy buffers as dirty
3947          * outside of the sanity tests.
3948          */
3949         if (unlikely(test_bit(EXTENT_BUFFER_DUMMY, &buf->bflags)))
3950                 return;
3951 #endif
3952         root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3953         btrfs_assert_tree_locked(buf);
3954         if (transid != root->fs_info->generation)
3955                 WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, found %llu running %llu\n",
3956                         buf->start, transid, root->fs_info->generation);
3957         was_dirty = set_extent_buffer_dirty(buf);
3958         if (!was_dirty)
3959                 __percpu_counter_add(&root->fs_info->dirty_metadata_bytes,
3960                                      buf->len,
3961                                      root->fs_info->dirty_metadata_batch);
3962 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3963         /*
3964          * Since btrfs_mark_buffer_dirty() can be called with item pointer set
3965          * but item data not updated.
3966          * So here we should only check item pointers, not item data.
3967          */
3968         if (btrfs_header_level(buf) == 0 &&
3969             btrfs_check_leaf_relaxed(root, buf)) {
3970                 btrfs_print_leaf(root, buf);
3971                 ASSERT(0);
3972         }
3973 #endif
3974 }
3975
3976 static void __btrfs_btree_balance_dirty(struct btrfs_root *root,
3977                                         int flush_delayed)
3978 {
3979         /*
3980          * looks as though older kernels can get into trouble with
3981          * this code, they end up stuck in balance_dirty_pages forever
3982          */
3983         int ret;
3984
3985         if (current->flags & PF_MEMALLOC)
3986                 return;
3987
3988         if (flush_delayed)
3989                 btrfs_balance_delayed_items(root);
3990
3991         ret = __percpu_counter_compare(&root->fs_info->dirty_metadata_bytes,
3992                                      BTRFS_DIRTY_METADATA_THRESH,
3993                                      root->fs_info->dirty_metadata_batch);
3994         if (ret > 0) {
3995                 balance_dirty_pages_ratelimited(
3996                                    root->fs_info->btree_inode->i_mapping);
3997         }
3998 }
3999
4000 void btrfs_btree_balance_dirty(struct btrfs_root *root)
4001 {
4002         __btrfs_btree_balance_dirty(root, 1);
4003 }
4004
4005 void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root)
4006 {
4007         __btrfs_btree_balance_dirty(root, 0);
4008 }
4009
4010 int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
4011 {
4012         struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
4013         return btree_read_extent_buffer_pages(root, buf, parent_transid);
4014 }
4015
4016 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
4017                               int read_only)
4018 {
4019         struct btrfs_super_block *sb = fs_info->super_copy;
4020         u64 nodesize = btrfs_super_nodesize(sb);
4021         u64 sectorsize = btrfs_super_sectorsize(sb);
4022         int ret = 0;
4023
4024         if (btrfs_super_magic(sb) != BTRFS_MAGIC) {
4025                 btrfs_err(fs_info, "no valid FS found");
4026                 ret = -EINVAL;
4027         }
4028         if (btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP) {
4029                 btrfs_err(fs_info, "unrecognized or unsupported super flag: %llu",
4030                                 btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP);
4031                 ret = -EINVAL;
4032         }
4033         if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
4034                 btrfs_err(fs_info, "tree_root level too big: %d >= %d",
4035                                 btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
4036                 ret = -EINVAL;
4037         }
4038         if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
4039                 btrfs_err(fs_info, "chunk_root level too big: %d >= %d",
4040                                 btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
4041                 ret = -EINVAL;
4042         }
4043         if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
4044                 btrfs_err(fs_info, "log_root level too big: %d >= %d",
4045                                 btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
4046                 ret = -EINVAL;
4047         }
4048
4049         /*
4050          * Check sectorsize and nodesize first, other check will need it.
4051          * Check all possible sectorsize(4K, 8K, 16K, 32K, 64K) here.
4052          */
4053         if (!is_power_of_2(sectorsize) || sectorsize < 4096 ||
4054             sectorsize > BTRFS_MAX_METADATA_BLOCKSIZE) {
4055                 btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
4056                 ret = -EINVAL;
4057         }
4058         /* Only PAGE SIZE is supported yet */
4059         if (sectorsize != PAGE_SIZE) {
4060                 btrfs_err(fs_info,
4061                         "sectorsize %llu not supported yet, only support %lu",
4062                         sectorsize, PAGE_SIZE);
4063                 ret = -EINVAL;
4064         }
4065         if (!is_power_of_2(nodesize) || nodesize < sectorsize ||
4066             nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
4067                 btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
4068                 ret = -EINVAL;
4069         }
4070         if (nodesize != le32_to_cpu(sb->__unused_leafsize)) {
4071                 btrfs_err(fs_info, "invalid leafsize %u, should be %llu",
4072                           le32_to_cpu(sb->__unused_leafsize), nodesize);
4073                 ret = -EINVAL;
4074         }
4075
4076         /* Root alignment check */
4077         if (!IS_ALIGNED(btrfs_super_root(sb), sectorsize)) {
4078                 btrfs_warn(fs_info, "tree_root block unaligned: %llu",
4079                            btrfs_super_root(sb));
4080                 ret = -EINVAL;
4081         }
4082         if (!IS_ALIGNED(btrfs_super_chunk_root(sb), sectorsize)) {
4083                 btrfs_warn(fs_info, "chunk_root block unaligned: %llu",
4084                            btrfs_super_chunk_root(sb));
4085                 ret = -EINVAL;
4086         }
4087         if (!IS_ALIGNED(btrfs_super_log_root(sb), sectorsize)) {
4088                 btrfs_warn(fs_info, "log_root block unaligned: %llu",
4089                            btrfs_super_log_root(sb));
4090                 ret = -EINVAL;
4091         }
4092
4093         if (memcmp(fs_info->fsid, sb->dev_item.fsid, BTRFS_UUID_SIZE) != 0) {
4094                 btrfs_err(fs_info,
4095                            "dev_item UUID does not match fsid: %pU != %pU",
4096                            fs_info->fsid, sb->dev_item.fsid);
4097                 ret = -EINVAL;
4098         }
4099
4100         /*
4101          * Hint to catch really bogus numbers, bitflips or so, more exact checks are
4102          * done later
4103          */
4104         if (btrfs_super_bytes_used(sb) < 6 * btrfs_super_nodesize(sb)) {
4105                 btrfs_err(fs_info, "bytes_used is too small %llu",
4106                           btrfs_super_bytes_used(sb));
4107                 ret = -EINVAL;
4108         }
4109         if (!is_power_of_2(btrfs_super_stripesize(sb))) {
4110                 btrfs_err(fs_info, "invalid stripesize %u",
4111                           btrfs_super_stripesize(sb));
4112                 ret = -EINVAL;
4113         }
4114         if (btrfs_super_num_devices(sb) > (1UL << 31))
4115                 btrfs_warn(fs_info, "suspicious number of devices: %llu",
4116                            btrfs_super_num_devices(sb));
4117         if (btrfs_super_num_devices(sb) == 0) {
4118                 btrfs_err(fs_info, "number of devices is 0");
4119                 ret = -EINVAL;
4120         }
4121
4122         if (btrfs_super_bytenr(sb) != BTRFS_SUPER_INFO_OFFSET) {
4123                 btrfs_err(fs_info, "super offset mismatch %llu != %u",
4124                           btrfs_super_bytenr(sb), BTRFS_SUPER_INFO_OFFSET);
4125                 ret = -EINVAL;
4126         }
4127
4128         /*
4129          * Obvious sys_chunk_array corruptions, it must hold at least one key
4130          * and one chunk
4131          */
4132         if (btrfs_super_sys_array_size(sb) > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
4133                 btrfs_err(fs_info, "system chunk array too big %u > %u",
4134                           btrfs_super_sys_array_size(sb),
4135                           BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
4136                 ret = -EINVAL;
4137         }
4138         if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
4139                         + sizeof(struct btrfs_chunk)) {
4140                 btrfs_err(fs_info, "system chunk array too small %u < %zu",
4141                           btrfs_super_sys_array_size(sb),
4142                           sizeof(struct btrfs_disk_key)
4143                           + sizeof(struct btrfs_chunk));
4144                 ret = -EINVAL;
4145         }
4146
4147         /*
4148          * The generation is a global counter, we'll trust it more than the others
4149          * but it's still possible that it's the one that's wrong.
4150          */
4151         if (btrfs_super_generation(sb) < btrfs_super_chunk_root_generation(sb))
4152                 btrfs_warn(fs_info,
4153                         "suspicious: generation < chunk_root_generation: %llu < %llu",
4154                         btrfs_super_generation(sb),
4155                         btrfs_super_chunk_root_generation(sb));
4156         if (btrfs_super_generation(sb) < btrfs_super_cache_generation(sb)
4157             && btrfs_super_cache_generation(sb) != (u64)-1)
4158                 btrfs_warn(fs_info,
4159                         "suspicious: generation < cache_generation: %llu < %llu",
4160                         btrfs_super_generation(sb),
4161                         btrfs_super_cache_generation(sb));
4162
4163         return ret;
4164 }
4165
4166 static void btrfs_error_commit_super(struct btrfs_root *root)
4167 {
4168         mutex_lock(&root->fs_info->cleaner_mutex);
4169         btrfs_run_delayed_iputs(root);
4170         mutex_unlock(&root->fs_info->cleaner_mutex);
4171
4172         down_write(&root->fs_info->cleanup_work_sem);
4173         up_write(&root->fs_info->cleanup_work_sem);
4174
4175         /* cleanup FS via transaction */
4176         btrfs_cleanup_transaction(root);
4177 }
4178
4179 static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
4180 {
4181         struct btrfs_ordered_extent *ordered;
4182
4183         spin_lock(&root->ordered_extent_lock);
4184         /*
4185          * This will just short circuit the ordered completion stuff which will
4186          * make sure the ordered extent gets properly cleaned up.
4187          */
4188         list_for_each_entry(ordered, &root->ordered_extents,
4189                             root_extent_list)
4190                 set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
4191         spin_unlock(&root->ordered_extent_lock);
4192 }
4193
4194 static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
4195 {
4196         struct btrfs_root *root;
4197         struct list_head splice;
4198
4199         INIT_LIST_HEAD(&splice);
4200
4201         spin_lock(&fs_info->ordered_root_lock);
4202         list_splice_init(&fs_info->ordered_roots, &splice);
4203         while (!list_empty(&splice)) {
4204                 root = list_first_entry(&splice, struct btrfs_root,
4205                                         ordered_root);
4206                 list_move_tail(&root->ordered_root,
4207                                &fs_info->ordered_roots);
4208
4209                 spin_unlock(&fs_info->ordered_root_lock);
4210                 btrfs_destroy_ordered_extents(root);
4211
4212                 cond_resched();
4213                 spin_lock(&fs_info->ordered_root_lock);
4214         }
4215         spin_unlock(&fs_info->ordered_root_lock);
4216
4217         /*
4218          * We need this here because if we've been flipped read-only we won't
4219          * get sync() from the umount, so we need to make sure any ordered
4220          * extents that haven't had their dirty pages IO start writeout yet
4221          * actually get run and error out properly.
4222          */
4223         btrfs_wait_ordered_roots(fs_info, -1, 0, (u64)-1);
4224 }
4225
4226 static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
4227                                       struct btrfs_root *root)
4228 {
4229         struct rb_node *node;
4230         struct btrfs_delayed_ref_root *delayed_refs;
4231         struct btrfs_delayed_ref_node *ref;
4232         int ret = 0;
4233
4234         delayed_refs = &trans->delayed_refs;
4235
4236         spin_lock(&delayed_refs->lock);
4237         if (atomic_read(&delayed_refs->num_entries) == 0) {
4238                 spin_unlock(&delayed_refs->lock);
4239                 btrfs_info(root->fs_info, "delayed_refs has NO entry");
4240                 return ret;
4241         }
4242
4243         while ((node = rb_first(&delayed_refs->href_root)) != NULL) {
4244                 struct btrfs_delayed_ref_head *head;
4245                 struct btrfs_delayed_ref_node *tmp;
4246                 bool pin_bytes = false;
4247
4248                 head = rb_entry(node, struct btrfs_delayed_ref_head,
4249                                 href_node);
4250                 if (!mutex_trylock(&head->mutex)) {
4251                         atomic_inc(&head->node.refs);
4252                         spin_unlock(&delayed_refs->lock);
4253
4254                         mutex_lock(&head->mutex);
4255                         mutex_unlock(&head->mutex);
4256                         btrfs_put_delayed_ref(&head->node);
4257                         spin_lock(&delayed_refs->lock);
4258                         continue;
4259                 }
4260                 spin_lock(&head->lock);
4261                 list_for_each_entry_safe_reverse(ref, tmp, &head->ref_list,
4262                                                  list) {
4263                         ref->in_tree = 0;
4264                         list_del(&ref->list);
4265                         atomic_dec(&delayed_refs->num_entries);
4266                         btrfs_put_delayed_ref(ref);
4267                 }
4268                 if (head->must_insert_reserved)
4269                         pin_bytes = true;
4270                 btrfs_free_delayed_extent_op(head->extent_op);
4271                 delayed_refs->num_heads--;
4272                 if (head->processing == 0)
4273                         delayed_refs->num_heads_ready--;
4274                 atomic_dec(&delayed_refs->num_entries);
4275                 head->node.in_tree = 0;
4276                 rb_erase(&head->href_node, &delayed_refs->href_root);
4277                 spin_unlock(&head->lock);
4278                 spin_unlock(&delayed_refs->lock);
4279                 mutex_unlock(&head->mutex);
4280
4281                 if (pin_bytes)
4282                         btrfs_pin_extent(root, head->node.bytenr,
4283                                          head->node.num_bytes, 1);
4284                 btrfs_put_delayed_ref(&head->node);
4285                 cond_resched();
4286                 spin_lock(&delayed_refs->lock);
4287         }
4288
4289         spin_unlock(&delayed_refs->lock);
4290
4291         return ret;
4292 }
4293
4294 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
4295 {
4296         struct btrfs_inode *btrfs_inode;
4297         struct list_head splice;
4298
4299         INIT_LIST_HEAD(&splice);
4300
4301         spin_lock(&root->delalloc_lock);
4302         list_splice_init(&root->delalloc_inodes, &splice);
4303
4304         while (!list_empty(&splice)) {
4305                 btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
4306                                                delalloc_inodes);
4307
4308                 list_del_init(&btrfs_inode->delalloc_inodes);
4309                 clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
4310                           &btrfs_inode->runtime_flags);
4311                 spin_unlock(&root->delalloc_lock);
4312
4313                 btrfs_invalidate_inodes(btrfs_inode->root);
4314
4315                 spin_lock(&root->delalloc_lock);
4316         }
4317
4318         spin_unlock(&root->delalloc_lock);
4319 }
4320
4321 static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
4322 {
4323         struct btrfs_root *root;
4324         struct list_head splice;
4325
4326         INIT_LIST_HEAD(&splice);
4327
4328         spin_lock(&fs_info->delalloc_root_lock);
4329         list_splice_init(&fs_info->delalloc_roots, &splice);
4330         while (!list_empty(&splice)) {
4331                 root = list_first_entry(&splice, struct btrfs_root,
4332                                          delalloc_root);
4333                 list_del_init(&root->delalloc_root);
4334                 root = btrfs_grab_fs_root(root);
4335                 BUG_ON(!root);
4336                 spin_unlock(&fs_info->delalloc_root_lock);
4337
4338                 btrfs_destroy_delalloc_inodes(root);
4339                 btrfs_put_fs_root(root);
4340
4341                 spin_lock(&fs_info->delalloc_root_lock);
4342         }
4343         spin_unlock(&fs_info->delalloc_root_lock);
4344 }
4345
4346 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
4347                                         struct extent_io_tree *dirty_pages,
4348                                         int mark)
4349 {
4350         int ret;
4351         struct extent_buffer *eb;
4352         u64 start = 0;
4353         u64 end;
4354
4355         while (1) {
4356                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
4357                                             mark, NULL);
4358                 if (ret)
4359                         break;
4360
4361                 clear_extent_bits(dirty_pages, start, end, mark);
4362                 while (start <= end) {
4363                         eb = btrfs_find_tree_block(root->fs_info, start);
4364                         start += root->nodesize;
4365                         if (!eb)
4366                                 continue;
4367                         wait_on_extent_buffer_writeback(eb);
4368
4369                         if (test_and_clear_bit(EXTENT_BUFFER_DIRTY,
4370                                                &eb->bflags))
4371                                 clear_extent_buffer_dirty(eb);
4372                         free_extent_buffer_stale(eb);
4373                 }
4374         }
4375
4376         return ret;
4377 }
4378
4379 static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
4380                                        struct extent_io_tree *pinned_extents)
4381 {
4382         struct btrfs_fs_info *fs_info = root->fs_info;
4383         struct extent_io_tree *unpin;
4384         u64 start;
4385         u64 end;
4386         int ret;
4387         bool loop = true;
4388
4389         unpin = pinned_extents;
4390 again:
4391         while (1) {
4392                 /*
4393                  * The btrfs_finish_extent_commit() may get the same range as
4394                  * ours between find_first_extent_bit and clear_extent_dirty.
4395                  * Hence, hold the unused_bg_unpin_mutex to avoid double unpin
4396                  * the same extent range.
4397                  */
4398                 mutex_lock(&fs_info->unused_bg_unpin_mutex);
4399                 ret = find_first_extent_bit(unpin, 0, &start, &end,
4400                                             EXTENT_DIRTY, NULL);
4401                 if (ret) {
4402                         mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4403                         break;
4404                 }
4405
4406                 clear_extent_dirty(unpin, start, end);
4407                 btrfs_error_unpin_extent_range(root, start, end);
4408                 mutex_unlock(&fs_info->unused_bg_unpin_mutex);
4409                 cond_resched();
4410         }
4411
4412         if (loop) {
4413                 if (unpin == &fs_info->freed_extents[0])
4414                         unpin = &fs_info->freed_extents[1];
4415                 else
4416                         unpin = &fs_info->freed_extents[0];
4417                 loop = false;
4418                 goto again;
4419         }
4420
4421         return 0;
4422 }
4423
4424 static void btrfs_cleanup_bg_io(struct btrfs_block_group_cache *cache)
4425 {
4426         struct inode *inode;
4427
4428         inode = cache->io_ctl.inode;
4429         if (inode) {
4430                 invalidate_inode_pages2(inode->i_mapping);
4431                 BTRFS_I(inode)->generation = 0;
4432                 cache->io_ctl.inode = NULL;
4433                 iput(inode);
4434         }
4435         ASSERT(cache->io_ctl.pages == NULL);
4436         btrfs_put_block_group(cache);
4437 }
4438
4439 void btrfs_cleanup_dirty_bgs(struct btrfs_transaction *cur_trans,
4440                              struct btrfs_root *root)
4441 {
4442         struct btrfs_block_group_cache *cache;
4443
4444         spin_lock(&cur_trans->dirty_bgs_lock);
4445         while (!list_empty(&cur_trans->dirty_bgs)) {
4446                 cache = list_first_entry(&cur_trans->dirty_bgs,
4447                                          struct btrfs_block_group_cache,
4448                                          dirty_list);
4449                 if (!cache) {
4450                         btrfs_err(root->fs_info,
4451                                   "orphan block group dirty_bgs list");
4452                         spin_unlock(&cur_trans->dirty_bgs_lock);
4453                         return;
4454                 }
4455
4456                 if (!list_empty(&cache->io_list)) {
4457                         spin_unlock(&cur_trans->dirty_bgs_lock);
4458                         list_del_init(&cache->io_list);
4459                         btrfs_cleanup_bg_io(cache);
4460                         spin_lock(&cur_trans->dirty_bgs_lock);
4461                 }
4462
4463                 list_del_init(&cache->dirty_list);
4464                 spin_lock(&cache->lock);
4465                 cache->disk_cache_state = BTRFS_DC_ERROR;
4466                 spin_unlock(&cache->lock);
4467
4468                 spin_unlock(&cur_trans->dirty_bgs_lock);
4469                 btrfs_put_block_group(cache);
4470                 spin_lock(&cur_trans->dirty_bgs_lock);
4471         }
4472         spin_unlock(&cur_trans->dirty_bgs_lock);
4473
4474         while (!list_empty(&cur_trans->io_bgs)) {
4475                 cache = list_first_entry(&cur_trans->io_bgs,
4476                                          struct btrfs_block_group_cache,
4477                                          io_list);
4478                 if (!cache) {
4479                         btrfs_err(root->fs_info,
4480                                   "orphan block group on io_bgs list");
4481                         return;
4482                 }
4483
4484                 list_del_init(&cache->io_list);
4485                 spin_lock(&cache->lock);
4486                 cache->disk_cache_state = BTRFS_DC_ERROR;
4487                 spin_unlock(&cache->lock);
4488                 btrfs_cleanup_bg_io(cache);
4489         }
4490 }
4491
4492 void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4493                                    struct btrfs_root *root)
4494 {
4495         btrfs_cleanup_dirty_bgs(cur_trans, root);
4496         ASSERT(list_empty(&cur_trans->dirty_bgs));
4497         ASSERT(list_empty(&cur_trans->io_bgs));
4498
4499         btrfs_destroy_delayed_refs(cur_trans, root);
4500
4501         cur_trans->state = TRANS_STATE_COMMIT_START;
4502         wake_up(&root->fs_info->transaction_blocked_wait);
4503
4504         cur_trans->state = TRANS_STATE_UNBLOCKED;
4505         wake_up(&root->fs_info->transaction_wait);
4506
4507         btrfs_destroy_delayed_inodes(root);
4508         btrfs_assert_delayed_root_empty(root);
4509
4510         btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
4511                                      EXTENT_DIRTY);
4512         btrfs_destroy_pinned_extent(root,
4513                                     root->fs_info->pinned_extents);
4514
4515         cur_trans->state =TRANS_STATE_COMPLETED;
4516         wake_up(&cur_trans->commit_wait);
4517
4518         /*
4519         memset(cur_trans, 0, sizeof(*cur_trans));
4520         kmem_cache_free(btrfs_transaction_cachep, cur_trans);
4521         */
4522 }
4523
4524 static int btrfs_cleanup_transaction(struct btrfs_root *root)
4525 {
4526         struct btrfs_transaction *t;
4527
4528         mutex_lock(&root->fs_info->transaction_kthread_mutex);
4529
4530         spin_lock(&root->fs_info->trans_lock);
4531         while (!list_empty(&root->fs_info->trans_list)) {
4532                 t = list_first_entry(&root->fs_info->trans_list,
4533                                      struct btrfs_transaction, list);
4534                 if (t->state >= TRANS_STATE_COMMIT_START) {
4535                         atomic_inc(&t->use_count);
4536                         spin_unlock(&root->fs_info->trans_lock);
4537                         btrfs_wait_for_commit(root, t->transid);
4538                         btrfs_put_transaction(t);
4539                         spin_lock(&root->fs_info->trans_lock);
4540                         continue;
4541                 }
4542                 if (t == root->fs_info->running_transaction) {
4543                         t->state = TRANS_STATE_COMMIT_DOING;
4544                         spin_unlock(&root->fs_info->trans_lock);
4545                         /*
4546                          * We wait for 0 num_writers since we don't hold a trans
4547                          * handle open currently for this transaction.
4548                          */
4549                         wait_event(t->writer_wait,
4550                                    atomic_read(&t->num_writers) == 0);
4551                 } else {
4552                         spin_unlock(&root->fs_info->trans_lock);
4553                 }
4554                 btrfs_cleanup_one_transaction(t, root);
4555
4556                 spin_lock(&root->fs_info->trans_lock);
4557                 if (t == root->fs_info->running_transaction)
4558                         root->fs_info->running_transaction = NULL;
4559                 list_del_init(&t->list);
4560                 spin_unlock(&root->fs_info->trans_lock);
4561
4562                 btrfs_put_transaction(t);
4563                 trace_btrfs_transaction_commit(root);
4564                 spin_lock(&root->fs_info->trans_lock);
4565         }
4566         spin_unlock(&root->fs_info->trans_lock);
4567         btrfs_destroy_all_ordered_extents(root->fs_info);
4568         btrfs_destroy_delayed_inodes(root);
4569         btrfs_assert_delayed_root_empty(root);
4570         btrfs_destroy_pinned_extent(root, root->fs_info->pinned_extents);
4571         btrfs_destroy_all_delalloc_inodes(root->fs_info);
4572         mutex_unlock(&root->fs_info->transaction_kthread_mutex);
4573
4574         return 0;
4575 }
4576
4577 static const struct extent_io_ops btree_extent_io_ops = {
4578         .readpage_end_io_hook = btree_readpage_end_io_hook,
4579         .readpage_io_failed_hook = btree_io_failed_hook,
4580         .submit_bio_hook = btree_submit_bio_hook,
4581         /* note we're sharing with inode.c for the merge bio hook */
4582         .merge_bio_hook = btrfs_merge_bio_hook,
4583 };