writeback: remove nr_pages_dirtied arg from balance_dirty_pages_ratelimited_nr()
[~shefty/rdma-dev.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/freezer.h>
29 #include <linux/crc32c.h>
30 #include <linux/slab.h>
31 #include <linux/migrate.h>
32 #include <linux/ratelimit.h>
33 #include <asm/unaligned.h>
34 #include "compat.h"
35 #include "ctree.h"
36 #include "disk-io.h"
37 #include "transaction.h"
38 #include "btrfs_inode.h"
39 #include "volumes.h"
40 #include "print-tree.h"
41 #include "async-thread.h"
42 #include "locking.h"
43 #include "tree-log.h"
44 #include "free-space-cache.h"
45 #include "inode-map.h"
46 #include "check-integrity.h"
47 #include "rcu-string.h"
48
49 #ifdef CONFIG_X86
50 #include <asm/cpufeature.h>
51 #endif
52
53 static struct extent_io_ops btree_extent_io_ops;
54 static void end_workqueue_fn(struct btrfs_work *work);
55 static void free_fs_root(struct btrfs_root *root);
56 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
57                                     int read_only);
58 static void btrfs_destroy_ordered_operations(struct btrfs_root *root);
59 static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
60 static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
61                                       struct btrfs_root *root);
62 static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
63 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
64 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
65                                         struct extent_io_tree *dirty_pages,
66                                         int mark);
67 static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
68                                        struct extent_io_tree *pinned_extents);
69
70 /*
71  * end_io_wq structs are used to do processing in task context when an IO is
72  * complete.  This is used during reads to verify checksums, and it is used
73  * by writes to insert metadata for new file extents after IO is complete.
74  */
75 struct end_io_wq {
76         struct bio *bio;
77         bio_end_io_t *end_io;
78         void *private;
79         struct btrfs_fs_info *info;
80         int error;
81         int metadata;
82         struct list_head list;
83         struct btrfs_work work;
84 };
85
86 /*
87  * async submit bios are used to offload expensive checksumming
88  * onto the worker threads.  They checksum file and metadata bios
89  * just before they are sent down the IO stack.
90  */
91 struct async_submit_bio {
92         struct inode *inode;
93         struct bio *bio;
94         struct list_head list;
95         extent_submit_bio_hook_t *submit_bio_start;
96         extent_submit_bio_hook_t *submit_bio_done;
97         int rw;
98         int mirror_num;
99         unsigned long bio_flags;
100         /*
101          * bio_offset is optional, can be used if the pages in the bio
102          * can't tell us where in the file the bio should go
103          */
104         u64 bio_offset;
105         struct btrfs_work work;
106         int error;
107 };
108
109 /*
110  * Lockdep class keys for extent_buffer->lock's in this root.  For a given
111  * eb, the lockdep key is determined by the btrfs_root it belongs to and
112  * the level the eb occupies in the tree.
113  *
114  * Different roots are used for different purposes and may nest inside each
115  * other and they require separate keysets.  As lockdep keys should be
116  * static, assign keysets according to the purpose of the root as indicated
117  * by btrfs_root->objectid.  This ensures that all special purpose roots
118  * have separate keysets.
119  *
120  * Lock-nesting across peer nodes is always done with the immediate parent
121  * node locked thus preventing deadlock.  As lockdep doesn't know this, use
122  * subclass to avoid triggering lockdep warning in such cases.
123  *
124  * The key is set by the readpage_end_io_hook after the buffer has passed
125  * csum validation but before the pages are unlocked.  It is also set by
126  * btrfs_init_new_buffer on freshly allocated blocks.
127  *
128  * We also add a check to make sure the highest level of the tree is the
129  * same as our lockdep setup here.  If BTRFS_MAX_LEVEL changes, this code
130  * needs update as well.
131  */
132 #ifdef CONFIG_DEBUG_LOCK_ALLOC
133 # if BTRFS_MAX_LEVEL != 8
134 #  error
135 # endif
136
137 static struct btrfs_lockdep_keyset {
138         u64                     id;             /* root objectid */
139         const char              *name_stem;     /* lock name stem */
140         char                    names[BTRFS_MAX_LEVEL + 1][20];
141         struct lock_class_key   keys[BTRFS_MAX_LEVEL + 1];
142 } btrfs_lockdep_keysets[] = {
143         { .id = BTRFS_ROOT_TREE_OBJECTID,       .name_stem = "root"     },
144         { .id = BTRFS_EXTENT_TREE_OBJECTID,     .name_stem = "extent"   },
145         { .id = BTRFS_CHUNK_TREE_OBJECTID,      .name_stem = "chunk"    },
146         { .id = BTRFS_DEV_TREE_OBJECTID,        .name_stem = "dev"      },
147         { .id = BTRFS_FS_TREE_OBJECTID,         .name_stem = "fs"       },
148         { .id = BTRFS_CSUM_TREE_OBJECTID,       .name_stem = "csum"     },
149         { .id = BTRFS_ORPHAN_OBJECTID,          .name_stem = "orphan"   },
150         { .id = BTRFS_TREE_LOG_OBJECTID,        .name_stem = "log"      },
151         { .id = BTRFS_TREE_RELOC_OBJECTID,      .name_stem = "treloc"   },
152         { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc"   },
153         { .id = 0,                              .name_stem = "tree"     },
154 };
155
156 void __init btrfs_init_lockdep(void)
157 {
158         int i, j;
159
160         /* initialize lockdep class names */
161         for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
162                 struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];
163
164                 for (j = 0; j < ARRAY_SIZE(ks->names); j++)
165                         snprintf(ks->names[j], sizeof(ks->names[j]),
166                                  "btrfs-%s-%02d", ks->name_stem, j);
167         }
168 }
169
170 void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
171                                     int level)
172 {
173         struct btrfs_lockdep_keyset *ks;
174
175         BUG_ON(level >= ARRAY_SIZE(ks->keys));
176
177         /* find the matching keyset, id 0 is the default entry */
178         for (ks = btrfs_lockdep_keysets; ks->id; ks++)
179                 if (ks->id == objectid)
180                         break;
181
182         lockdep_set_class_and_name(&eb->lock,
183                                    &ks->keys[level], ks->names[level]);
184 }
185
186 #endif
187
188 /*
189  * extents on the btree inode are pretty simple, there's one extent
190  * that covers the entire device
191  */
192 static struct extent_map *btree_get_extent(struct inode *inode,
193                 struct page *page, size_t pg_offset, u64 start, u64 len,
194                 int create)
195 {
196         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
197         struct extent_map *em;
198         int ret;
199
200         read_lock(&em_tree->lock);
201         em = lookup_extent_mapping(em_tree, start, len);
202         if (em) {
203                 em->bdev =
204                         BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
205                 read_unlock(&em_tree->lock);
206                 goto out;
207         }
208         read_unlock(&em_tree->lock);
209
210         em = alloc_extent_map();
211         if (!em) {
212                 em = ERR_PTR(-ENOMEM);
213                 goto out;
214         }
215         em->start = 0;
216         em->len = (u64)-1;
217         em->block_len = (u64)-1;
218         em->block_start = 0;
219         em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
220
221         write_lock(&em_tree->lock);
222         ret = add_extent_mapping(em_tree, em);
223         if (ret == -EEXIST) {
224                 free_extent_map(em);
225                 em = lookup_extent_mapping(em_tree, start, len);
226                 if (!em)
227                         em = ERR_PTR(-EIO);
228         } else if (ret) {
229                 free_extent_map(em);
230                 em = ERR_PTR(ret);
231         }
232         write_unlock(&em_tree->lock);
233
234 out:
235         return em;
236 }
237
238 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
239 {
240         return crc32c(seed, data, len);
241 }
242
243 void btrfs_csum_final(u32 crc, char *result)
244 {
245         put_unaligned_le32(~crc, result);
246 }
247
248 /*
249  * compute the csum for a btree block, and either verify it or write it
250  * into the csum field of the block.
251  */
252 static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
253                            int verify)
254 {
255         u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
256         char *result = NULL;
257         unsigned long len;
258         unsigned long cur_len;
259         unsigned long offset = BTRFS_CSUM_SIZE;
260         char *kaddr;
261         unsigned long map_start;
262         unsigned long map_len;
263         int err;
264         u32 crc = ~(u32)0;
265         unsigned long inline_result;
266
267         len = buf->len - offset;
268         while (len > 0) {
269                 err = map_private_extent_buffer(buf, offset, 32,
270                                         &kaddr, &map_start, &map_len);
271                 if (err)
272                         return 1;
273                 cur_len = min(len, map_len - (offset - map_start));
274                 crc = btrfs_csum_data(root, kaddr + offset - map_start,
275                                       crc, cur_len);
276                 len -= cur_len;
277                 offset += cur_len;
278         }
279         if (csum_size > sizeof(inline_result)) {
280                 result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
281                 if (!result)
282                         return 1;
283         } else {
284                 result = (char *)&inline_result;
285         }
286
287         btrfs_csum_final(crc, result);
288
289         if (verify) {
290                 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
291                         u32 val;
292                         u32 found = 0;
293                         memcpy(&found, result, csum_size);
294
295                         read_extent_buffer(buf, &val, 0, csum_size);
296                         printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
297                                        "failed on %llu wanted %X found %X "
298                                        "level %d\n",
299                                        root->fs_info->sb->s_id,
300                                        (unsigned long long)buf->start, val, found,
301                                        btrfs_header_level(buf));
302                         if (result != (char *)&inline_result)
303                                 kfree(result);
304                         return 1;
305                 }
306         } else {
307                 write_extent_buffer(buf, result, 0, csum_size);
308         }
309         if (result != (char *)&inline_result)
310                 kfree(result);
311         return 0;
312 }
313
314 /*
315  * we can't consider a given block up to date unless the transid of the
316  * block matches the transid in the parent node's pointer.  This is how we
317  * detect blocks that either didn't get written at all or got written
318  * in the wrong place.
319  */
320 static int verify_parent_transid(struct extent_io_tree *io_tree,
321                                  struct extent_buffer *eb, u64 parent_transid,
322                                  int atomic)
323 {
324         struct extent_state *cached_state = NULL;
325         int ret;
326
327         if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
328                 return 0;
329
330         if (atomic)
331                 return -EAGAIN;
332
333         lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
334                          0, &cached_state);
335         if (extent_buffer_uptodate(eb) &&
336             btrfs_header_generation(eb) == parent_transid) {
337                 ret = 0;
338                 goto out;
339         }
340         printk_ratelimited("parent transid verify failed on %llu wanted %llu "
341                        "found %llu\n",
342                        (unsigned long long)eb->start,
343                        (unsigned long long)parent_transid,
344                        (unsigned long long)btrfs_header_generation(eb));
345         ret = 1;
346         clear_extent_buffer_uptodate(eb);
347 out:
348         unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
349                              &cached_state, GFP_NOFS);
350         return ret;
351 }
352
353 /*
354  * helper to read a given tree block, doing retries as required when
355  * the checksums don't match and we have alternate mirrors to try.
356  */
357 static int btree_read_extent_buffer_pages(struct btrfs_root *root,
358                                           struct extent_buffer *eb,
359                                           u64 start, u64 parent_transid)
360 {
361         struct extent_io_tree *io_tree;
362         int failed = 0;
363         int ret;
364         int num_copies = 0;
365         int mirror_num = 0;
366         int failed_mirror = 0;
367
368         clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
369         io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
370         while (1) {
371                 ret = read_extent_buffer_pages(io_tree, eb, start,
372                                                WAIT_COMPLETE,
373                                                btree_get_extent, mirror_num);
374                 if (!ret) {
375                         if (!verify_parent_transid(io_tree, eb,
376                                                    parent_transid, 0))
377                                 break;
378                         else
379                                 ret = -EIO;
380                 }
381
382                 /*
383                  * This buffer's crc is fine, but its contents are corrupted, so
384                  * there is no reason to read the other copies, they won't be
385                  * any less wrong.
386                  */
387                 if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
388                         break;
389
390                 num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
391                                               eb->start, eb->len);
392                 if (num_copies == 1)
393                         break;
394
395                 if (!failed_mirror) {
396                         failed = 1;
397                         failed_mirror = eb->read_mirror;
398                 }
399
400                 mirror_num++;
401                 if (mirror_num == failed_mirror)
402                         mirror_num++;
403
404                 if (mirror_num > num_copies)
405                         break;
406         }
407
408         if (failed && !ret && failed_mirror)
409                 repair_eb_io_failure(root, eb, failed_mirror);
410
411         return ret;
412 }
413
414 /*
415  * checksum a dirty tree block before IO.  This has extra checks to make sure
416  * we only fill in the checksum field in the first page of a multi-page block
417  */
418
419 static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
420 {
421         struct extent_io_tree *tree;
422         u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
423         u64 found_start;
424         struct extent_buffer *eb;
425
426         tree = &BTRFS_I(page->mapping->host)->io_tree;
427
428         eb = (struct extent_buffer *)page->private;
429         if (page != eb->pages[0])
430                 return 0;
431         found_start = btrfs_header_bytenr(eb);
432         if (found_start != start) {
433                 WARN_ON(1);
434                 return 0;
435         }
436         if (!PageUptodate(page)) {
437                 WARN_ON(1);
438                 return 0;
439         }
440         csum_tree_block(root, eb, 0);
441         return 0;
442 }
443
444 static int check_tree_block_fsid(struct btrfs_root *root,
445                                  struct extent_buffer *eb)
446 {
447         struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
448         u8 fsid[BTRFS_UUID_SIZE];
449         int ret = 1;
450
451         read_extent_buffer(eb, fsid, (unsigned long)btrfs_header_fsid(eb),
452                            BTRFS_FSID_SIZE);
453         while (fs_devices) {
454                 if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
455                         ret = 0;
456                         break;
457                 }
458                 fs_devices = fs_devices->seed;
459         }
460         return ret;
461 }
462
463 #define CORRUPT(reason, eb, root, slot)                         \
464         printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu," \
465                "root=%llu, slot=%d\n", reason,                  \
466                (unsigned long long)btrfs_header_bytenr(eb),     \
467                (unsigned long long)root->objectid, slot)
468
469 static noinline int check_leaf(struct btrfs_root *root,
470                                struct extent_buffer *leaf)
471 {
472         struct btrfs_key key;
473         struct btrfs_key leaf_key;
474         u32 nritems = btrfs_header_nritems(leaf);
475         int slot;
476
477         if (nritems == 0)
478                 return 0;
479
480         /* Check the 0 item */
481         if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
482             BTRFS_LEAF_DATA_SIZE(root)) {
483                 CORRUPT("invalid item offset size pair", leaf, root, 0);
484                 return -EIO;
485         }
486
487         /*
488          * Check to make sure each items keys are in the correct order and their
489          * offsets make sense.  We only have to loop through nritems-1 because
490          * we check the current slot against the next slot, which verifies the
491          * next slot's offset+size makes sense and that the current's slot
492          * offset is correct.
493          */
494         for (slot = 0; slot < nritems - 1; slot++) {
495                 btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
496                 btrfs_item_key_to_cpu(leaf, &key, slot + 1);
497
498                 /* Make sure the keys are in the right order */
499                 if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
500                         CORRUPT("bad key order", leaf, root, slot);
501                         return -EIO;
502                 }
503
504                 /*
505                  * Make sure the offset and ends are right, remember that the
506                  * item data starts at the end of the leaf and grows towards the
507                  * front.
508                  */
509                 if (btrfs_item_offset_nr(leaf, slot) !=
510                         btrfs_item_end_nr(leaf, slot + 1)) {
511                         CORRUPT("slot offset bad", leaf, root, slot);
512                         return -EIO;
513                 }
514
515                 /*
516                  * Check to make sure that we don't point outside of the leaf,
517                  * just incase all the items are consistent to eachother, but
518                  * all point outside of the leaf.
519                  */
520                 if (btrfs_item_end_nr(leaf, slot) >
521                     BTRFS_LEAF_DATA_SIZE(root)) {
522                         CORRUPT("slot end outside of leaf", leaf, root, slot);
523                         return -EIO;
524                 }
525         }
526
527         return 0;
528 }
529
530 struct extent_buffer *find_eb_for_page(struct extent_io_tree *tree,
531                                        struct page *page, int max_walk)
532 {
533         struct extent_buffer *eb;
534         u64 start = page_offset(page);
535         u64 target = start;
536         u64 min_start;
537
538         if (start < max_walk)
539                 min_start = 0;
540         else
541                 min_start = start - max_walk;
542
543         while (start >= min_start) {
544                 eb = find_extent_buffer(tree, start, 0);
545                 if (eb) {
546                         /*
547                          * we found an extent buffer and it contains our page
548                          * horray!
549                          */
550                         if (eb->start <= target &&
551                             eb->start + eb->len > target)
552                                 return eb;
553
554                         /* we found an extent buffer that wasn't for us */
555                         free_extent_buffer(eb);
556                         return NULL;
557                 }
558                 if (start == 0)
559                         break;
560                 start -= PAGE_CACHE_SIZE;
561         }
562         return NULL;
563 }
564
565 static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
566                                struct extent_state *state, int mirror)
567 {
568         struct extent_io_tree *tree;
569         u64 found_start;
570         int found_level;
571         struct extent_buffer *eb;
572         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
573         int ret = 0;
574         int reads_done;
575
576         if (!page->private)
577                 goto out;
578
579         tree = &BTRFS_I(page->mapping->host)->io_tree;
580         eb = (struct extent_buffer *)page->private;
581
582         /* the pending IO might have been the only thing that kept this buffer
583          * in memory.  Make sure we have a ref for all this other checks
584          */
585         extent_buffer_get(eb);
586
587         reads_done = atomic_dec_and_test(&eb->io_pages);
588         if (!reads_done)
589                 goto err;
590
591         eb->read_mirror = mirror;
592         if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
593                 ret = -EIO;
594                 goto err;
595         }
596
597         found_start = btrfs_header_bytenr(eb);
598         if (found_start != eb->start) {
599                 printk_ratelimited(KERN_INFO "btrfs bad tree block start "
600                                "%llu %llu\n",
601                                (unsigned long long)found_start,
602                                (unsigned long long)eb->start);
603                 ret = -EIO;
604                 goto err;
605         }
606         if (check_tree_block_fsid(root, eb)) {
607                 printk_ratelimited(KERN_INFO "btrfs bad fsid on block %llu\n",
608                                (unsigned long long)eb->start);
609                 ret = -EIO;
610                 goto err;
611         }
612         found_level = btrfs_header_level(eb);
613
614         btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
615                                        eb, found_level);
616
617         ret = csum_tree_block(root, eb, 1);
618         if (ret) {
619                 ret = -EIO;
620                 goto err;
621         }
622
623         /*
624          * If this is a leaf block and it is corrupt, set the corrupt bit so
625          * that we don't try and read the other copies of this block, just
626          * return -EIO.
627          */
628         if (found_level == 0 && check_leaf(root, eb)) {
629                 set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
630                 ret = -EIO;
631         }
632
633         if (!ret)
634                 set_extent_buffer_uptodate(eb);
635 err:
636         if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
637                 clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
638                 btree_readahead_hook(root, eb, eb->start, ret);
639         }
640
641         if (ret)
642                 clear_extent_buffer_uptodate(eb);
643         free_extent_buffer(eb);
644 out:
645         return ret;
646 }
647
648 static int btree_io_failed_hook(struct page *page, int failed_mirror)
649 {
650         struct extent_buffer *eb;
651         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
652
653         eb = (struct extent_buffer *)page->private;
654         set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
655         eb->read_mirror = failed_mirror;
656         if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
657                 btree_readahead_hook(root, eb, eb->start, -EIO);
658         return -EIO;    /* we fixed nothing */
659 }
660
661 static void end_workqueue_bio(struct bio *bio, int err)
662 {
663         struct end_io_wq *end_io_wq = bio->bi_private;
664         struct btrfs_fs_info *fs_info;
665
666         fs_info = end_io_wq->info;
667         end_io_wq->error = err;
668         end_io_wq->work.func = end_workqueue_fn;
669         end_io_wq->work.flags = 0;
670
671         if (bio->bi_rw & REQ_WRITE) {
672                 if (end_io_wq->metadata == 1)
673                         btrfs_queue_worker(&fs_info->endio_meta_write_workers,
674                                            &end_io_wq->work);
675                 else if (end_io_wq->metadata == 2)
676                         btrfs_queue_worker(&fs_info->endio_freespace_worker,
677                                            &end_io_wq->work);
678                 else
679                         btrfs_queue_worker(&fs_info->endio_write_workers,
680                                            &end_io_wq->work);
681         } else {
682                 if (end_io_wq->metadata)
683                         btrfs_queue_worker(&fs_info->endio_meta_workers,
684                                            &end_io_wq->work);
685                 else
686                         btrfs_queue_worker(&fs_info->endio_workers,
687                                            &end_io_wq->work);
688         }
689 }
690
691 /*
692  * For the metadata arg you want
693  *
694  * 0 - if data
695  * 1 - if normal metadta
696  * 2 - if writing to the free space cache area
697  */
698 int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
699                         int metadata)
700 {
701         struct end_io_wq *end_io_wq;
702         end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
703         if (!end_io_wq)
704                 return -ENOMEM;
705
706         end_io_wq->private = bio->bi_private;
707         end_io_wq->end_io = bio->bi_end_io;
708         end_io_wq->info = info;
709         end_io_wq->error = 0;
710         end_io_wq->bio = bio;
711         end_io_wq->metadata = metadata;
712
713         bio->bi_private = end_io_wq;
714         bio->bi_end_io = end_workqueue_bio;
715         return 0;
716 }
717
718 unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
719 {
720         unsigned long limit = min_t(unsigned long,
721                                     info->workers.max_workers,
722                                     info->fs_devices->open_devices);
723         return 256 * limit;
724 }
725
726 static void run_one_async_start(struct btrfs_work *work)
727 {
728         struct async_submit_bio *async;
729         int ret;
730
731         async = container_of(work, struct  async_submit_bio, work);
732         ret = async->submit_bio_start(async->inode, async->rw, async->bio,
733                                       async->mirror_num, async->bio_flags,
734                                       async->bio_offset);
735         if (ret)
736                 async->error = ret;
737 }
738
739 static void run_one_async_done(struct btrfs_work *work)
740 {
741         struct btrfs_fs_info *fs_info;
742         struct async_submit_bio *async;
743         int limit;
744
745         async = container_of(work, struct  async_submit_bio, work);
746         fs_info = BTRFS_I(async->inode)->root->fs_info;
747
748         limit = btrfs_async_submit_limit(fs_info);
749         limit = limit * 2 / 3;
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 occured we just want to clean up the bio and move on */
756         if (async->error) {
757                 bio_endio(async->bio, async->error);
758                 return;
759         }
760
761         async->submit_bio_done(async->inode, async->rw, async->bio,
762                                async->mirror_num, async->bio_flags,
763                                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                         int rw, 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->rw = rw;
789         async->bio = bio;
790         async->mirror_num = mirror_num;
791         async->submit_bio_start = submit_bio_start;
792         async->submit_bio_done = submit_bio_done;
793
794         async->work.func = run_one_async_start;
795         async->work.ordered_func = run_one_async_done;
796         async->work.ordered_free = run_one_async_free;
797
798         async->work.flags = 0;
799         async->bio_flags = bio_flags;
800         async->bio_offset = bio_offset;
801
802         async->error = 0;
803
804         atomic_inc(&fs_info->nr_async_submits);
805
806         if (rw & REQ_SYNC)
807                 btrfs_set_work_high_prio(&async->work);
808
809         btrfs_queue_worker(&fs_info->workers, &async->work);
810
811         while (atomic_read(&fs_info->async_submit_draining) &&
812               atomic_read(&fs_info->nr_async_submits)) {
813                 wait_event(fs_info->async_submit_wait,
814                            (atomic_read(&fs_info->nr_async_submits) == 0));
815         }
816
817         return 0;
818 }
819
820 static int btree_csum_one_bio(struct bio *bio)
821 {
822         struct bio_vec *bvec = bio->bi_io_vec;
823         int bio_index = 0;
824         struct btrfs_root *root;
825         int ret = 0;
826
827         WARN_ON(bio->bi_vcnt <= 0);
828         while (bio_index < bio->bi_vcnt) {
829                 root = BTRFS_I(bvec->bv_page->mapping->host)->root;
830                 ret = csum_dirty_buffer(root, bvec->bv_page);
831                 if (ret)
832                         break;
833                 bio_index++;
834                 bvec++;
835         }
836         return ret;
837 }
838
839 static int __btree_submit_bio_start(struct inode *inode, int rw,
840                                     struct bio *bio, int mirror_num,
841                                     unsigned long bio_flags,
842                                     u64 bio_offset)
843 {
844         /*
845          * when we're called for a write, we're already in the async
846          * submission context.  Just jump into btrfs_map_bio
847          */
848         return btree_csum_one_bio(bio);
849 }
850
851 static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
852                                  int mirror_num, unsigned long bio_flags,
853                                  u64 bio_offset)
854 {
855         /*
856          * when we're called for a write, we're already in the async
857          * submission context.  Just jump into btrfs_map_bio
858          */
859         return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
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 (cpu_has_xmm4_2)
868                 return 0;
869 #endif
870         return 1;
871 }
872
873 static int btree_submit_bio_hook(struct inode *inode, int rw, 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 (!(rw & REQ_WRITE)) {
881
882                 /*
883                  * called for a read, do the setup so that checksum validation
884                  * can happen in the async kernel threads
885                  */
886                 ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
887                                           bio, 1);
888                 if (ret)
889                         return ret;
890                 return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
891                                      mirror_num, 0);
892         } else if (!async) {
893                 ret = btree_csum_one_bio(bio);
894                 if (ret)
895                         return ret;
896                 return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
897                                      mirror_num, 0);
898         }
899
900         /*
901          * kthread helpers are used to submit writes so that checksumming
902          * can happen in parallel across all CPUs
903          */
904         return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
905                                    inode, rw, bio, mirror_num, 0,
906                                    bio_offset,
907                                    __btree_submit_bio_start,
908                                    __btree_submit_bio_done);
909 }
910
911 #ifdef CONFIG_MIGRATION
912 static int btree_migratepage(struct address_space *mapping,
913                         struct page *newpage, struct page *page,
914                         enum migrate_mode mode)
915 {
916         /*
917          * we can't safely write a btree page from here,
918          * we haven't done the locking hook
919          */
920         if (PageDirty(page))
921                 return -EAGAIN;
922         /*
923          * Buffers may be managed in a filesystem specific way.
924          * We must have no buffers or drop them.
925          */
926         if (page_has_private(page) &&
927             !try_to_release_page(page, GFP_KERNEL))
928                 return -EAGAIN;
929         return migrate_page(mapping, newpage, page, mode);
930 }
931 #endif
932
933
934 static int btree_writepages(struct address_space *mapping,
935                             struct writeback_control *wbc)
936 {
937         struct extent_io_tree *tree;
938         tree = &BTRFS_I(mapping->host)->io_tree;
939         if (wbc->sync_mode == WB_SYNC_NONE) {
940                 struct btrfs_root *root = BTRFS_I(mapping->host)->root;
941                 u64 num_dirty;
942                 unsigned long thresh = 32 * 1024 * 1024;
943
944                 if (wbc->for_kupdate)
945                         return 0;
946
947                 /* this is a bit racy, but that's ok */
948                 num_dirty = root->fs_info->dirty_metadata_bytes;
949                 if (num_dirty < thresh)
950                         return 0;
951         }
952         return btree_write_cache_pages(mapping, wbc);
953 }
954
955 static int btree_readpage(struct file *file, struct page *page)
956 {
957         struct extent_io_tree *tree;
958         tree = &BTRFS_I(page->mapping->host)->io_tree;
959         return extent_read_full_page(tree, page, btree_get_extent, 0);
960 }
961
962 static int btree_releasepage(struct page *page, gfp_t gfp_flags)
963 {
964         if (PageWriteback(page) || PageDirty(page))
965                 return 0;
966         /*
967          * We need to mask out eg. __GFP_HIGHMEM and __GFP_DMA32 as we're doing
968          * slab allocation from alloc_extent_state down the callchain where
969          * it'd hit a BUG_ON as those flags are not allowed.
970          */
971         gfp_flags &= ~GFP_SLAB_BUG_MASK;
972
973         return try_release_extent_buffer(page, gfp_flags);
974 }
975
976 static void btree_invalidatepage(struct page *page, unsigned long offset)
977 {
978         struct extent_io_tree *tree;
979         tree = &BTRFS_I(page->mapping->host)->io_tree;
980         extent_invalidatepage(tree, page, offset);
981         btree_releasepage(page, GFP_NOFS);
982         if (PagePrivate(page)) {
983                 printk(KERN_WARNING "btrfs warning page private not zero "
984                        "on page %llu\n", (unsigned long long)page_offset(page));
985                 ClearPagePrivate(page);
986                 set_page_private(page, 0);
987                 page_cache_release(page);
988         }
989 }
990
991 static int btree_set_page_dirty(struct page *page)
992 {
993         struct extent_buffer *eb;
994
995         BUG_ON(!PagePrivate(page));
996         eb = (struct extent_buffer *)page->private;
997         BUG_ON(!eb);
998         BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
999         BUG_ON(!atomic_read(&eb->refs));
1000         btrfs_assert_tree_locked(eb);
1001         return __set_page_dirty_nobuffers(page);
1002 }
1003
1004 static const struct address_space_operations btree_aops = {
1005         .readpage       = btree_readpage,
1006         .writepages     = btree_writepages,
1007         .releasepage    = btree_releasepage,
1008         .invalidatepage = btree_invalidatepage,
1009 #ifdef CONFIG_MIGRATION
1010         .migratepage    = btree_migratepage,
1011 #endif
1012         .set_page_dirty = btree_set_page_dirty,
1013 };
1014
1015 int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1016                          u64 parent_transid)
1017 {
1018         struct extent_buffer *buf = NULL;
1019         struct inode *btree_inode = root->fs_info->btree_inode;
1020         int ret = 0;
1021
1022         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1023         if (!buf)
1024                 return 0;
1025         read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1026                                  buf, 0, WAIT_NONE, btree_get_extent, 0);
1027         free_extent_buffer(buf);
1028         return ret;
1029 }
1030
1031 int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1032                          int mirror_num, struct extent_buffer **eb)
1033 {
1034         struct extent_buffer *buf = NULL;
1035         struct inode *btree_inode = root->fs_info->btree_inode;
1036         struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
1037         int ret;
1038
1039         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1040         if (!buf)
1041                 return 0;
1042
1043         set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);
1044
1045         ret = read_extent_buffer_pages(io_tree, buf, 0, WAIT_PAGE_LOCK,
1046                                        btree_get_extent, mirror_num);
1047         if (ret) {
1048                 free_extent_buffer(buf);
1049                 return ret;
1050         }
1051
1052         if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
1053                 free_extent_buffer(buf);
1054                 return -EIO;
1055         } else if (extent_buffer_uptodate(buf)) {
1056                 *eb = buf;
1057         } else {
1058                 free_extent_buffer(buf);
1059         }
1060         return 0;
1061 }
1062
1063 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
1064                                             u64 bytenr, u32 blocksize)
1065 {
1066         struct inode *btree_inode = root->fs_info->btree_inode;
1067         struct extent_buffer *eb;
1068         eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1069                                 bytenr, blocksize);
1070         return eb;
1071 }
1072
1073 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
1074                                                  u64 bytenr, u32 blocksize)
1075 {
1076         struct inode *btree_inode = root->fs_info->btree_inode;
1077         struct extent_buffer *eb;
1078
1079         eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1080                                  bytenr, blocksize);
1081         return eb;
1082 }
1083
1084
1085 int btrfs_write_tree_block(struct extent_buffer *buf)
1086 {
1087         return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1088                                         buf->start + buf->len - 1);
1089 }
1090
1091 int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
1092 {
1093         return filemap_fdatawait_range(buf->pages[0]->mapping,
1094                                        buf->start, buf->start + buf->len - 1);
1095 }
1096
1097 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1098                                       u32 blocksize, u64 parent_transid)
1099 {
1100         struct extent_buffer *buf = NULL;
1101         int ret;
1102
1103         buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1104         if (!buf)
1105                 return NULL;
1106
1107         ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1108         return buf;
1109
1110 }
1111
1112 void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1113                       struct extent_buffer *buf)
1114 {
1115         if (btrfs_header_generation(buf) ==
1116             root->fs_info->running_transaction->transid) {
1117                 btrfs_assert_tree_locked(buf);
1118
1119                 if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1120                         spin_lock(&root->fs_info->delalloc_lock);
1121                         if (root->fs_info->dirty_metadata_bytes >= buf->len)
1122                                 root->fs_info->dirty_metadata_bytes -= buf->len;
1123                         else {
1124                                 spin_unlock(&root->fs_info->delalloc_lock);
1125                                 btrfs_panic(root->fs_info, -EOVERFLOW,
1126                                           "Can't clear %lu bytes from "
1127                                           " dirty_mdatadata_bytes (%llu)",
1128                                           buf->len,
1129                                           root->fs_info->dirty_metadata_bytes);
1130                         }
1131                         spin_unlock(&root->fs_info->delalloc_lock);
1132                 }
1133
1134                 /* ugh, clear_extent_buffer_dirty needs to lock the page */
1135                 btrfs_set_lock_blocking(buf);
1136                 clear_extent_buffer_dirty(buf);
1137         }
1138 }
1139
1140 static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
1141                          u32 stripesize, struct btrfs_root *root,
1142                          struct btrfs_fs_info *fs_info,
1143                          u64 objectid)
1144 {
1145         root->node = NULL;
1146         root->commit_root = NULL;
1147         root->sectorsize = sectorsize;
1148         root->nodesize = nodesize;
1149         root->leafsize = leafsize;
1150         root->stripesize = stripesize;
1151         root->ref_cows = 0;
1152         root->track_dirty = 0;
1153         root->in_radix = 0;
1154         root->orphan_item_inserted = 0;
1155         root->orphan_cleanup_state = 0;
1156
1157         root->objectid = objectid;
1158         root->last_trans = 0;
1159         root->highest_objectid = 0;
1160         root->name = NULL;
1161         root->inode_tree = RB_ROOT;
1162         INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1163         root->block_rsv = NULL;
1164         root->orphan_block_rsv = NULL;
1165
1166         INIT_LIST_HEAD(&root->dirty_list);
1167         INIT_LIST_HEAD(&root->root_list);
1168         spin_lock_init(&root->orphan_lock);
1169         spin_lock_init(&root->inode_lock);
1170         spin_lock_init(&root->accounting_lock);
1171         mutex_init(&root->objectid_mutex);
1172         mutex_init(&root->log_mutex);
1173         init_waitqueue_head(&root->log_writer_wait);
1174         init_waitqueue_head(&root->log_commit_wait[0]);
1175         init_waitqueue_head(&root->log_commit_wait[1]);
1176         atomic_set(&root->log_commit[0], 0);
1177         atomic_set(&root->log_commit[1], 0);
1178         atomic_set(&root->log_writers, 0);
1179         atomic_set(&root->log_batch, 0);
1180         atomic_set(&root->orphan_inodes, 0);
1181         root->log_transid = 0;
1182         root->last_log_commit = 0;
1183         extent_io_tree_init(&root->dirty_log_pages,
1184                              fs_info->btree_inode->i_mapping);
1185
1186         memset(&root->root_key, 0, sizeof(root->root_key));
1187         memset(&root->root_item, 0, sizeof(root->root_item));
1188         memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1189         memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1190         root->defrag_trans_start = fs_info->generation;
1191         init_completion(&root->kobj_unregister);
1192         root->defrag_running = 0;
1193         root->root_key.objectid = objectid;
1194         root->anon_dev = 0;
1195
1196         spin_lock_init(&root->root_times_lock);
1197 }
1198
1199 static int __must_check find_and_setup_root(struct btrfs_root *tree_root,
1200                                             struct btrfs_fs_info *fs_info,
1201                                             u64 objectid,
1202                                             struct btrfs_root *root)
1203 {
1204         int ret;
1205         u32 blocksize;
1206         u64 generation;
1207
1208         __setup_root(tree_root->nodesize, tree_root->leafsize,
1209                      tree_root->sectorsize, tree_root->stripesize,
1210                      root, fs_info, objectid);
1211         ret = btrfs_find_last_root(tree_root, objectid,
1212                                    &root->root_item, &root->root_key);
1213         if (ret > 0)
1214                 return -ENOENT;
1215         else if (ret < 0)
1216                 return ret;
1217
1218         generation = btrfs_root_generation(&root->root_item);
1219         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1220         root->commit_root = NULL;
1221         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1222                                      blocksize, generation);
1223         if (!root->node || !btrfs_buffer_uptodate(root->node, generation, 0)) {
1224                 free_extent_buffer(root->node);
1225                 root->node = NULL;
1226                 return -EIO;
1227         }
1228         root->commit_root = btrfs_root_node(root);
1229         return 0;
1230 }
1231
1232 static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
1233 {
1234         struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
1235         if (root)
1236                 root->fs_info = fs_info;
1237         return root;
1238 }
1239
1240 struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
1241                                      struct btrfs_fs_info *fs_info,
1242                                      u64 objectid)
1243 {
1244         struct extent_buffer *leaf;
1245         struct btrfs_root *tree_root = fs_info->tree_root;
1246         struct btrfs_root *root;
1247         struct btrfs_key key;
1248         int ret = 0;
1249         u64 bytenr;
1250
1251         root = btrfs_alloc_root(fs_info);
1252         if (!root)
1253                 return ERR_PTR(-ENOMEM);
1254
1255         __setup_root(tree_root->nodesize, tree_root->leafsize,
1256                      tree_root->sectorsize, tree_root->stripesize,
1257                      root, fs_info, objectid);
1258         root->root_key.objectid = objectid;
1259         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1260         root->root_key.offset = 0;
1261
1262         leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
1263                                       0, objectid, NULL, 0, 0, 0);
1264         if (IS_ERR(leaf)) {
1265                 ret = PTR_ERR(leaf);
1266                 goto fail;
1267         }
1268
1269         bytenr = leaf->start;
1270         memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1271         btrfs_set_header_bytenr(leaf, leaf->start);
1272         btrfs_set_header_generation(leaf, trans->transid);
1273         btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1274         btrfs_set_header_owner(leaf, objectid);
1275         root->node = leaf;
1276
1277         write_extent_buffer(leaf, fs_info->fsid,
1278                             (unsigned long)btrfs_header_fsid(leaf),
1279                             BTRFS_FSID_SIZE);
1280         write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
1281                             (unsigned long)btrfs_header_chunk_tree_uuid(leaf),
1282                             BTRFS_UUID_SIZE);
1283         btrfs_mark_buffer_dirty(leaf);
1284
1285         root->commit_root = btrfs_root_node(root);
1286         root->track_dirty = 1;
1287
1288
1289         root->root_item.flags = 0;
1290         root->root_item.byte_limit = 0;
1291         btrfs_set_root_bytenr(&root->root_item, leaf->start);
1292         btrfs_set_root_generation(&root->root_item, trans->transid);
1293         btrfs_set_root_level(&root->root_item, 0);
1294         btrfs_set_root_refs(&root->root_item, 1);
1295         btrfs_set_root_used(&root->root_item, leaf->len);
1296         btrfs_set_root_last_snapshot(&root->root_item, 0);
1297         btrfs_set_root_dirid(&root->root_item, 0);
1298         root->root_item.drop_level = 0;
1299
1300         key.objectid = objectid;
1301         key.type = BTRFS_ROOT_ITEM_KEY;
1302         key.offset = 0;
1303         ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
1304         if (ret)
1305                 goto fail;
1306
1307         btrfs_tree_unlock(leaf);
1308
1309 fail:
1310         if (ret)
1311                 return ERR_PTR(ret);
1312
1313         return root;
1314 }
1315
1316 static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
1317                                          struct btrfs_fs_info *fs_info)
1318 {
1319         struct btrfs_root *root;
1320         struct btrfs_root *tree_root = fs_info->tree_root;
1321         struct extent_buffer *leaf;
1322
1323         root = btrfs_alloc_root(fs_info);
1324         if (!root)
1325                 return ERR_PTR(-ENOMEM);
1326
1327         __setup_root(tree_root->nodesize, tree_root->leafsize,
1328                      tree_root->sectorsize, tree_root->stripesize,
1329                      root, fs_info, BTRFS_TREE_LOG_OBJECTID);
1330
1331         root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
1332         root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1333         root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
1334         /*
1335          * log trees do not get reference counted because they go away
1336          * before a real commit is actually done.  They do store pointers
1337          * to file data extents, and those reference counts still get
1338          * updated (along with back refs to the log tree).
1339          */
1340         root->ref_cows = 0;
1341
1342         leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
1343                                       BTRFS_TREE_LOG_OBJECTID, NULL,
1344                                       0, 0, 0);
1345         if (IS_ERR(leaf)) {
1346                 kfree(root);
1347                 return ERR_CAST(leaf);
1348         }
1349
1350         memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1351         btrfs_set_header_bytenr(leaf, leaf->start);
1352         btrfs_set_header_generation(leaf, trans->transid);
1353         btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1354         btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
1355         root->node = leaf;
1356
1357         write_extent_buffer(root->node, root->fs_info->fsid,
1358                             (unsigned long)btrfs_header_fsid(root->node),
1359                             BTRFS_FSID_SIZE);
1360         btrfs_mark_buffer_dirty(root->node);
1361         btrfs_tree_unlock(root->node);
1362         return root;
1363 }
1364
1365 int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
1366                              struct btrfs_fs_info *fs_info)
1367 {
1368         struct btrfs_root *log_root;
1369
1370         log_root = alloc_log_tree(trans, fs_info);
1371         if (IS_ERR(log_root))
1372                 return PTR_ERR(log_root);
1373         WARN_ON(fs_info->log_root_tree);
1374         fs_info->log_root_tree = log_root;
1375         return 0;
1376 }
1377
1378 int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
1379                        struct btrfs_root *root)
1380 {
1381         struct btrfs_root *log_root;
1382         struct btrfs_inode_item *inode_item;
1383
1384         log_root = alloc_log_tree(trans, root->fs_info);
1385         if (IS_ERR(log_root))
1386                 return PTR_ERR(log_root);
1387
1388         log_root->last_trans = trans->transid;
1389         log_root->root_key.offset = root->root_key.objectid;
1390
1391         inode_item = &log_root->root_item.inode;
1392         inode_item->generation = cpu_to_le64(1);
1393         inode_item->size = cpu_to_le64(3);
1394         inode_item->nlink = cpu_to_le32(1);
1395         inode_item->nbytes = cpu_to_le64(root->leafsize);
1396         inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
1397
1398         btrfs_set_root_node(&log_root->root_item, log_root->node);
1399
1400         WARN_ON(root->log_root);
1401         root->log_root = log_root;
1402         root->log_transid = 0;
1403         root->last_log_commit = 0;
1404         return 0;
1405 }
1406
1407 struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
1408                                                struct btrfs_key *location)
1409 {
1410         struct btrfs_root *root;
1411         struct btrfs_fs_info *fs_info = tree_root->fs_info;
1412         struct btrfs_path *path;
1413         struct extent_buffer *l;
1414         u64 generation;
1415         u32 blocksize;
1416         int ret = 0;
1417         int slot;
1418
1419         root = btrfs_alloc_root(fs_info);
1420         if (!root)
1421                 return ERR_PTR(-ENOMEM);
1422         if (location->offset == (u64)-1) {
1423                 ret = find_and_setup_root(tree_root, fs_info,
1424                                           location->objectid, root);
1425                 if (ret) {
1426                         kfree(root);
1427                         return ERR_PTR(ret);
1428                 }
1429                 goto out;
1430         }
1431
1432         __setup_root(tree_root->nodesize, tree_root->leafsize,
1433                      tree_root->sectorsize, tree_root->stripesize,
1434                      root, fs_info, location->objectid);
1435
1436         path = btrfs_alloc_path();
1437         if (!path) {
1438                 kfree(root);
1439                 return ERR_PTR(-ENOMEM);
1440         }
1441         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1442         if (ret == 0) {
1443                 l = path->nodes[0];
1444                 slot = path->slots[0];
1445                 btrfs_read_root_item(tree_root, l, slot, &root->root_item);
1446                 memcpy(&root->root_key, location, sizeof(*location));
1447         }
1448         btrfs_free_path(path);
1449         if (ret) {
1450                 kfree(root);
1451                 if (ret > 0)
1452                         ret = -ENOENT;
1453                 return ERR_PTR(ret);
1454         }
1455
1456         generation = btrfs_root_generation(&root->root_item);
1457         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1458         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1459                                      blocksize, generation);
1460         root->commit_root = btrfs_root_node(root);
1461         BUG_ON(!root->node); /* -ENOMEM */
1462 out:
1463         if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1464                 root->ref_cows = 1;
1465                 btrfs_check_and_init_root_item(&root->root_item);
1466         }
1467
1468         return root;
1469 }
1470
1471 struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
1472                                               struct btrfs_key *location)
1473 {
1474         struct btrfs_root *root;
1475         int ret;
1476
1477         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1478                 return fs_info->tree_root;
1479         if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
1480                 return fs_info->extent_root;
1481         if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
1482                 return fs_info->chunk_root;
1483         if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
1484                 return fs_info->dev_root;
1485         if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
1486                 return fs_info->csum_root;
1487         if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
1488                 return fs_info->quota_root ? fs_info->quota_root :
1489                                              ERR_PTR(-ENOENT);
1490 again:
1491         spin_lock(&fs_info->fs_roots_radix_lock);
1492         root = radix_tree_lookup(&fs_info->fs_roots_radix,
1493                                  (unsigned long)location->objectid);
1494         spin_unlock(&fs_info->fs_roots_radix_lock);
1495         if (root)
1496                 return root;
1497
1498         root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1499         if (IS_ERR(root))
1500                 return root;
1501
1502         root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
1503         root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
1504                                         GFP_NOFS);
1505         if (!root->free_ino_pinned || !root->free_ino_ctl) {
1506                 ret = -ENOMEM;
1507                 goto fail;
1508         }
1509
1510         btrfs_init_free_ino_ctl(root);
1511         mutex_init(&root->fs_commit_mutex);
1512         spin_lock_init(&root->cache_lock);
1513         init_waitqueue_head(&root->cache_wait);
1514
1515         ret = get_anon_bdev(&root->anon_dev);
1516         if (ret)
1517                 goto fail;
1518
1519         if (btrfs_root_refs(&root->root_item) == 0) {
1520                 ret = -ENOENT;
1521                 goto fail;
1522         }
1523
1524         ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
1525         if (ret < 0)
1526                 goto fail;
1527         if (ret == 0)
1528                 root->orphan_item_inserted = 1;
1529
1530         ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
1531         if (ret)
1532                 goto fail;
1533
1534         spin_lock(&fs_info->fs_roots_radix_lock);
1535         ret = radix_tree_insert(&fs_info->fs_roots_radix,
1536                                 (unsigned long)root->root_key.objectid,
1537                                 root);
1538         if (ret == 0)
1539                 root->in_radix = 1;
1540
1541         spin_unlock(&fs_info->fs_roots_radix_lock);
1542         radix_tree_preload_end();
1543         if (ret) {
1544                 if (ret == -EEXIST) {
1545                         free_fs_root(root);
1546                         goto again;
1547                 }
1548                 goto fail;
1549         }
1550
1551         ret = btrfs_find_dead_roots(fs_info->tree_root,
1552                                     root->root_key.objectid);
1553         WARN_ON(ret);
1554         return root;
1555 fail:
1556         free_fs_root(root);
1557         return ERR_PTR(ret);
1558 }
1559
1560 static int btrfs_congested_fn(void *congested_data, int bdi_bits)
1561 {
1562         struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
1563         int ret = 0;
1564         struct btrfs_device *device;
1565         struct backing_dev_info *bdi;
1566
1567         rcu_read_lock();
1568         list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1569                 if (!device->bdev)
1570                         continue;
1571                 bdi = blk_get_backing_dev_info(device->bdev);
1572                 if (bdi && bdi_congested(bdi, bdi_bits)) {
1573                         ret = 1;
1574                         break;
1575                 }
1576         }
1577         rcu_read_unlock();
1578         return ret;
1579 }
1580
1581 /*
1582  * If this fails, caller must call bdi_destroy() to get rid of the
1583  * bdi again.
1584  */
1585 static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
1586 {
1587         int err;
1588
1589         bdi->capabilities = BDI_CAP_MAP_COPY;
1590         err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1591         if (err)
1592                 return err;
1593
1594         bdi->ra_pages   = default_backing_dev_info.ra_pages;
1595         bdi->congested_fn       = btrfs_congested_fn;
1596         bdi->congested_data     = info;
1597         return 0;
1598 }
1599
1600 /*
1601  * called by the kthread helper functions to finally call the bio end_io
1602  * functions.  This is where read checksum verification actually happens
1603  */
1604 static void end_workqueue_fn(struct btrfs_work *work)
1605 {
1606         struct bio *bio;
1607         struct end_io_wq *end_io_wq;
1608         struct btrfs_fs_info *fs_info;
1609         int error;
1610
1611         end_io_wq = container_of(work, struct end_io_wq, work);
1612         bio = end_io_wq->bio;
1613         fs_info = end_io_wq->info;
1614
1615         error = end_io_wq->error;
1616         bio->bi_private = end_io_wq->private;
1617         bio->bi_end_io = end_io_wq->end_io;
1618         kfree(end_io_wq);
1619         bio_endio(bio, error);
1620 }
1621
1622 static int cleaner_kthread(void *arg)
1623 {
1624         struct btrfs_root *root = arg;
1625
1626         do {
1627                 if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
1628                     mutex_trylock(&root->fs_info->cleaner_mutex)) {
1629                         btrfs_run_delayed_iputs(root);
1630                         btrfs_clean_old_snapshots(root);
1631                         mutex_unlock(&root->fs_info->cleaner_mutex);
1632                         btrfs_run_defrag_inodes(root->fs_info);
1633                 }
1634
1635                 if (!try_to_freeze()) {
1636                         set_current_state(TASK_INTERRUPTIBLE);
1637                         if (!kthread_should_stop())
1638                                 schedule();
1639                         __set_current_state(TASK_RUNNING);
1640                 }
1641         } while (!kthread_should_stop());
1642         return 0;
1643 }
1644
1645 static int transaction_kthread(void *arg)
1646 {
1647         struct btrfs_root *root = arg;
1648         struct btrfs_trans_handle *trans;
1649         struct btrfs_transaction *cur;
1650         u64 transid;
1651         unsigned long now;
1652         unsigned long delay;
1653         bool cannot_commit;
1654
1655         do {
1656                 cannot_commit = false;
1657                 delay = HZ * 30;
1658                 mutex_lock(&root->fs_info->transaction_kthread_mutex);
1659
1660                 spin_lock(&root->fs_info->trans_lock);
1661                 cur = root->fs_info->running_transaction;
1662                 if (!cur) {
1663                         spin_unlock(&root->fs_info->trans_lock);
1664                         goto sleep;
1665                 }
1666
1667                 now = get_seconds();
1668                 if (!cur->blocked &&
1669                     (now < cur->start_time || now - cur->start_time < 30)) {
1670                         spin_unlock(&root->fs_info->trans_lock);
1671                         delay = HZ * 5;
1672                         goto sleep;
1673                 }
1674                 transid = cur->transid;
1675                 spin_unlock(&root->fs_info->trans_lock);
1676
1677                 /* If the file system is aborted, this will always fail. */
1678                 trans = btrfs_attach_transaction(root);
1679                 if (IS_ERR(trans)) {
1680                         if (PTR_ERR(trans) != -ENOENT)
1681                                 cannot_commit = true;
1682                         goto sleep;
1683                 }
1684                 if (transid == trans->transid) {
1685                         btrfs_commit_transaction(trans, root);
1686                 } else {
1687                         btrfs_end_transaction(trans, root);
1688                 }
1689 sleep:
1690                 wake_up_process(root->fs_info->cleaner_kthread);
1691                 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1692
1693                 if (!try_to_freeze()) {
1694                         set_current_state(TASK_INTERRUPTIBLE);
1695                         if (!kthread_should_stop() &&
1696                             (!btrfs_transaction_blocked(root->fs_info) ||
1697                              cannot_commit))
1698                                 schedule_timeout(delay);
1699                         __set_current_state(TASK_RUNNING);
1700                 }
1701         } while (!kthread_should_stop());
1702         return 0;
1703 }
1704
1705 /*
1706  * this will find the highest generation in the array of
1707  * root backups.  The index of the highest array is returned,
1708  * or -1 if we can't find anything.
1709  *
1710  * We check to make sure the array is valid by comparing the
1711  * generation of the latest  root in the array with the generation
1712  * in the super block.  If they don't match we pitch it.
1713  */
1714 static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
1715 {
1716         u64 cur;
1717         int newest_index = -1;
1718         struct btrfs_root_backup *root_backup;
1719         int i;
1720
1721         for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1722                 root_backup = info->super_copy->super_roots + i;
1723                 cur = btrfs_backup_tree_root_gen(root_backup);
1724                 if (cur == newest_gen)
1725                         newest_index = i;
1726         }
1727
1728         /* check to see if we actually wrapped around */
1729         if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
1730                 root_backup = info->super_copy->super_roots;
1731                 cur = btrfs_backup_tree_root_gen(root_backup);
1732                 if (cur == newest_gen)
1733                         newest_index = 0;
1734         }
1735         return newest_index;
1736 }
1737
1738
1739 /*
1740  * find the oldest backup so we know where to store new entries
1741  * in the backup array.  This will set the backup_root_index
1742  * field in the fs_info struct
1743  */
1744 static void find_oldest_super_backup(struct btrfs_fs_info *info,
1745                                      u64 newest_gen)
1746 {
1747         int newest_index = -1;
1748
1749         newest_index = find_newest_super_backup(info, newest_gen);
1750         /* if there was garbage in there, just move along */
1751         if (newest_index == -1) {
1752                 info->backup_root_index = 0;
1753         } else {
1754                 info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
1755         }
1756 }
1757
1758 /*
1759  * copy all the root pointers into the super backup array.
1760  * this will bump the backup pointer by one when it is
1761  * done
1762  */
1763 static void backup_super_roots(struct btrfs_fs_info *info)
1764 {
1765         int next_backup;
1766         struct btrfs_root_backup *root_backup;
1767         int last_backup;
1768
1769         next_backup = info->backup_root_index;
1770         last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
1771                 BTRFS_NUM_BACKUP_ROOTS;
1772
1773         /*
1774          * just overwrite the last backup if we're at the same generation
1775          * this happens only at umount
1776          */
1777         root_backup = info->super_for_commit->super_roots + last_backup;
1778         if (btrfs_backup_tree_root_gen(root_backup) ==
1779             btrfs_header_generation(info->tree_root->node))
1780                 next_backup = last_backup;
1781
1782         root_backup = info->super_for_commit->super_roots + next_backup;
1783
1784         /*
1785          * make sure all of our padding and empty slots get zero filled
1786          * regardless of which ones we use today
1787          */
1788         memset(root_backup, 0, sizeof(*root_backup));
1789
1790         info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1791
1792         btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1793         btrfs_set_backup_tree_root_gen(root_backup,
1794                                btrfs_header_generation(info->tree_root->node));
1795
1796         btrfs_set_backup_tree_root_level(root_backup,
1797                                btrfs_header_level(info->tree_root->node));
1798
1799         btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1800         btrfs_set_backup_chunk_root_gen(root_backup,
1801                                btrfs_header_generation(info->chunk_root->node));
1802         btrfs_set_backup_chunk_root_level(root_backup,
1803                                btrfs_header_level(info->chunk_root->node));
1804
1805         btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
1806         btrfs_set_backup_extent_root_gen(root_backup,
1807                                btrfs_header_generation(info->extent_root->node));
1808         btrfs_set_backup_extent_root_level(root_backup,
1809                                btrfs_header_level(info->extent_root->node));
1810
1811         /*
1812          * we might commit during log recovery, which happens before we set
1813          * the fs_root.  Make sure it is valid before we fill it in.
1814          */
1815         if (info->fs_root && info->fs_root->node) {
1816                 btrfs_set_backup_fs_root(root_backup,
1817                                          info->fs_root->node->start);
1818                 btrfs_set_backup_fs_root_gen(root_backup,
1819                                btrfs_header_generation(info->fs_root->node));
1820                 btrfs_set_backup_fs_root_level(root_backup,
1821                                btrfs_header_level(info->fs_root->node));
1822         }
1823
1824         btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
1825         btrfs_set_backup_dev_root_gen(root_backup,
1826                                btrfs_header_generation(info->dev_root->node));
1827         btrfs_set_backup_dev_root_level(root_backup,
1828                                        btrfs_header_level(info->dev_root->node));
1829
1830         btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
1831         btrfs_set_backup_csum_root_gen(root_backup,
1832                                btrfs_header_generation(info->csum_root->node));
1833         btrfs_set_backup_csum_root_level(root_backup,
1834                                btrfs_header_level(info->csum_root->node));
1835
1836         btrfs_set_backup_total_bytes(root_backup,
1837                              btrfs_super_total_bytes(info->super_copy));
1838         btrfs_set_backup_bytes_used(root_backup,
1839                              btrfs_super_bytes_used(info->super_copy));
1840         btrfs_set_backup_num_devices(root_backup,
1841                              btrfs_super_num_devices(info->super_copy));
1842
1843         /*
1844          * if we don't copy this out to the super_copy, it won't get remembered
1845          * for the next commit
1846          */
1847         memcpy(&info->super_copy->super_roots,
1848                &info->super_for_commit->super_roots,
1849                sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
1850 }
1851
1852 /*
1853  * this copies info out of the root backup array and back into
1854  * the in-memory super block.  It is meant to help iterate through
1855  * the array, so you send it the number of backups you've already
1856  * tried and the last backup index you used.
1857  *
1858  * this returns -1 when it has tried all the backups
1859  */
1860 static noinline int next_root_backup(struct btrfs_fs_info *info,
1861                                      struct btrfs_super_block *super,
1862                                      int *num_backups_tried, int *backup_index)
1863 {
1864         struct btrfs_root_backup *root_backup;
1865         int newest = *backup_index;
1866
1867         if (*num_backups_tried == 0) {
1868                 u64 gen = btrfs_super_generation(super);
1869
1870                 newest = find_newest_super_backup(info, gen);
1871                 if (newest == -1)
1872                         return -1;
1873
1874                 *backup_index = newest;
1875                 *num_backups_tried = 1;
1876         } else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
1877                 /* we've tried all the backups, all done */
1878                 return -1;
1879         } else {
1880                 /* jump to the next oldest backup */
1881                 newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
1882                         BTRFS_NUM_BACKUP_ROOTS;
1883                 *backup_index = newest;
1884                 *num_backups_tried += 1;
1885         }
1886         root_backup = super->super_roots + newest;
1887
1888         btrfs_set_super_generation(super,
1889                                    btrfs_backup_tree_root_gen(root_backup));
1890         btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
1891         btrfs_set_super_root_level(super,
1892                                    btrfs_backup_tree_root_level(root_backup));
1893         btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
1894
1895         /*
1896          * fixme: the total bytes and num_devices need to match or we should
1897          * need a fsck
1898          */
1899         btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
1900         btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
1901         return 0;
1902 }
1903
1904 /* helper to cleanup tree roots */
1905 static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
1906 {
1907         free_extent_buffer(info->tree_root->node);
1908         free_extent_buffer(info->tree_root->commit_root);
1909         free_extent_buffer(info->dev_root->node);
1910         free_extent_buffer(info->dev_root->commit_root);
1911         free_extent_buffer(info->extent_root->node);
1912         free_extent_buffer(info->extent_root->commit_root);
1913         free_extent_buffer(info->csum_root->node);
1914         free_extent_buffer(info->csum_root->commit_root);
1915         if (info->quota_root) {
1916                 free_extent_buffer(info->quota_root->node);
1917                 free_extent_buffer(info->quota_root->commit_root);
1918         }
1919
1920         info->tree_root->node = NULL;
1921         info->tree_root->commit_root = NULL;
1922         info->dev_root->node = NULL;
1923         info->dev_root->commit_root = NULL;
1924         info->extent_root->node = NULL;
1925         info->extent_root->commit_root = NULL;
1926         info->csum_root->node = NULL;
1927         info->csum_root->commit_root = NULL;
1928         if (info->quota_root) {
1929                 info->quota_root->node = NULL;
1930                 info->quota_root->commit_root = NULL;
1931         }
1932
1933         if (chunk_root) {
1934                 free_extent_buffer(info->chunk_root->node);
1935                 free_extent_buffer(info->chunk_root->commit_root);
1936                 info->chunk_root->node = NULL;
1937                 info->chunk_root->commit_root = NULL;
1938         }
1939 }
1940
1941
1942 int open_ctree(struct super_block *sb,
1943                struct btrfs_fs_devices *fs_devices,
1944                char *options)
1945 {
1946         u32 sectorsize;
1947         u32 nodesize;
1948         u32 leafsize;
1949         u32 blocksize;
1950         u32 stripesize;
1951         u64 generation;
1952         u64 features;
1953         struct btrfs_key location;
1954         struct buffer_head *bh;
1955         struct btrfs_super_block *disk_super;
1956         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1957         struct btrfs_root *tree_root;
1958         struct btrfs_root *extent_root;
1959         struct btrfs_root *csum_root;
1960         struct btrfs_root *chunk_root;
1961         struct btrfs_root *dev_root;
1962         struct btrfs_root *quota_root;
1963         struct btrfs_root *log_tree_root;
1964         int ret;
1965         int err = -EINVAL;
1966         int num_backups_tried = 0;
1967         int backup_index = 0;
1968
1969         tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
1970         extent_root = fs_info->extent_root = btrfs_alloc_root(fs_info);
1971         csum_root = fs_info->csum_root = btrfs_alloc_root(fs_info);
1972         chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
1973         dev_root = fs_info->dev_root = btrfs_alloc_root(fs_info);
1974         quota_root = fs_info->quota_root = btrfs_alloc_root(fs_info);
1975
1976         if (!tree_root || !extent_root || !csum_root ||
1977             !chunk_root || !dev_root || !quota_root) {
1978                 err = -ENOMEM;
1979                 goto fail;
1980         }
1981
1982         ret = init_srcu_struct(&fs_info->subvol_srcu);
1983         if (ret) {
1984                 err = ret;
1985                 goto fail;
1986         }
1987
1988         ret = setup_bdi(fs_info, &fs_info->bdi);
1989         if (ret) {
1990                 err = ret;
1991                 goto fail_srcu;
1992         }
1993
1994         fs_info->btree_inode = new_inode(sb);
1995         if (!fs_info->btree_inode) {
1996                 err = -ENOMEM;
1997                 goto fail_bdi;
1998         }
1999
2000         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
2001
2002         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2003         INIT_LIST_HEAD(&fs_info->trans_list);
2004         INIT_LIST_HEAD(&fs_info->dead_roots);
2005         INIT_LIST_HEAD(&fs_info->delayed_iputs);
2006         INIT_LIST_HEAD(&fs_info->delalloc_inodes);
2007         INIT_LIST_HEAD(&fs_info->ordered_operations);
2008         INIT_LIST_HEAD(&fs_info->caching_block_groups);
2009         spin_lock_init(&fs_info->delalloc_lock);
2010         spin_lock_init(&fs_info->trans_lock);
2011         spin_lock_init(&fs_info->fs_roots_radix_lock);
2012         spin_lock_init(&fs_info->delayed_iput_lock);
2013         spin_lock_init(&fs_info->defrag_inodes_lock);
2014         spin_lock_init(&fs_info->free_chunk_lock);
2015         spin_lock_init(&fs_info->tree_mod_seq_lock);
2016         rwlock_init(&fs_info->tree_mod_log_lock);
2017         mutex_init(&fs_info->reloc_mutex);
2018
2019         init_completion(&fs_info->kobj_unregister);
2020         INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2021         INIT_LIST_HEAD(&fs_info->space_info);
2022         INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2023         btrfs_mapping_init(&fs_info->mapping_tree);
2024         btrfs_init_block_rsv(&fs_info->global_block_rsv,
2025                              BTRFS_BLOCK_RSV_GLOBAL);
2026         btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
2027                              BTRFS_BLOCK_RSV_DELALLOC);
2028         btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
2029         btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
2030         btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
2031         btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
2032                              BTRFS_BLOCK_RSV_DELOPS);
2033         atomic_set(&fs_info->nr_async_submits, 0);
2034         atomic_set(&fs_info->async_delalloc_pages, 0);
2035         atomic_set(&fs_info->async_submit_draining, 0);
2036         atomic_set(&fs_info->nr_async_bios, 0);
2037         atomic_set(&fs_info->defrag_running, 0);
2038         atomic_set(&fs_info->tree_mod_seq, 0);
2039         fs_info->sb = sb;
2040         fs_info->max_inline = 8192 * 1024;
2041         fs_info->metadata_ratio = 0;
2042         fs_info->defrag_inodes = RB_ROOT;
2043         fs_info->trans_no_join = 0;
2044         fs_info->free_chunk_space = 0;
2045         fs_info->tree_mod_log = RB_ROOT;
2046
2047         /* readahead state */
2048         INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
2049         spin_lock_init(&fs_info->reada_lock);
2050
2051         fs_info->thread_pool_size = min_t(unsigned long,
2052                                           num_online_cpus() + 2, 8);
2053
2054         INIT_LIST_HEAD(&fs_info->ordered_extents);
2055         spin_lock_init(&fs_info->ordered_extent_lock);
2056         fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2057                                         GFP_NOFS);
2058         if (!fs_info->delayed_root) {
2059                 err = -ENOMEM;
2060                 goto fail_iput;
2061         }
2062         btrfs_init_delayed_root(fs_info->delayed_root);
2063
2064         mutex_init(&fs_info->scrub_lock);
2065         atomic_set(&fs_info->scrubs_running, 0);
2066         atomic_set(&fs_info->scrub_pause_req, 0);
2067         atomic_set(&fs_info->scrubs_paused, 0);
2068         atomic_set(&fs_info->scrub_cancel_req, 0);
2069         init_waitqueue_head(&fs_info->scrub_pause_wait);
2070         init_rwsem(&fs_info->scrub_super_lock);
2071         fs_info->scrub_workers_refcnt = 0;
2072 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2073         fs_info->check_integrity_print_mask = 0;
2074 #endif
2075
2076         spin_lock_init(&fs_info->balance_lock);
2077         mutex_init(&fs_info->balance_mutex);
2078         atomic_set(&fs_info->balance_running, 0);
2079         atomic_set(&fs_info->balance_pause_req, 0);
2080         atomic_set(&fs_info->balance_cancel_req, 0);
2081         fs_info->balance_ctl = NULL;
2082         init_waitqueue_head(&fs_info->balance_wait_q);
2083
2084         sb->s_blocksize = 4096;
2085         sb->s_blocksize_bits = blksize_bits(4096);
2086         sb->s_bdi = &fs_info->bdi;
2087
2088         fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
2089         set_nlink(fs_info->btree_inode, 1);
2090         /*
2091          * we set the i_size on the btree inode to the max possible int.
2092          * the real end of the address space is determined by all of
2093          * the devices in the system
2094          */
2095         fs_info->btree_inode->i_size = OFFSET_MAX;
2096         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
2097         fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;
2098
2099         RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2100         extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2101                              fs_info->btree_inode->i_mapping);
2102         BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2103         extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2104
2105         BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
2106
2107         BTRFS_I(fs_info->btree_inode)->root = tree_root;
2108         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
2109                sizeof(struct btrfs_key));
2110         set_bit(BTRFS_INODE_DUMMY,
2111                 &BTRFS_I(fs_info->btree_inode)->runtime_flags);
2112         insert_inode_hash(fs_info->btree_inode);
2113
2114         spin_lock_init(&fs_info->block_group_cache_lock);
2115         fs_info->block_group_cache_tree = RB_ROOT;
2116
2117         extent_io_tree_init(&fs_info->freed_extents[0],
2118                              fs_info->btree_inode->i_mapping);
2119         extent_io_tree_init(&fs_info->freed_extents[1],
2120                              fs_info->btree_inode->i_mapping);
2121         fs_info->pinned_extents = &fs_info->freed_extents[0];
2122         fs_info->do_barriers = 1;
2123
2124
2125         mutex_init(&fs_info->ordered_operations_mutex);
2126         mutex_init(&fs_info->tree_log_mutex);
2127         mutex_init(&fs_info->chunk_mutex);
2128         mutex_init(&fs_info->transaction_kthread_mutex);
2129         mutex_init(&fs_info->cleaner_mutex);
2130         mutex_init(&fs_info->volume_mutex);
2131         init_rwsem(&fs_info->extent_commit_sem);
2132         init_rwsem(&fs_info->cleanup_work_sem);
2133         init_rwsem(&fs_info->subvol_sem);
2134
2135         spin_lock_init(&fs_info->qgroup_lock);
2136         fs_info->qgroup_tree = RB_ROOT;
2137         INIT_LIST_HEAD(&fs_info->dirty_qgroups);
2138         fs_info->qgroup_seq = 1;
2139         fs_info->quota_enabled = 0;
2140         fs_info->pending_quota_state = 0;
2141
2142         btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2143         btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2144
2145         init_waitqueue_head(&fs_info->transaction_throttle);
2146         init_waitqueue_head(&fs_info->transaction_wait);
2147         init_waitqueue_head(&fs_info->transaction_blocked_wait);
2148         init_waitqueue_head(&fs_info->async_submit_wait);
2149
2150         __setup_root(4096, 4096, 4096, 4096, tree_root,
2151                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
2152
2153         invalidate_bdev(fs_devices->latest_bdev);
2154         bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2155         if (!bh) {
2156                 err = -EINVAL;
2157                 goto fail_alloc;
2158         }
2159
2160         memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
2161         memcpy(fs_info->super_for_commit, fs_info->super_copy,
2162                sizeof(*fs_info->super_for_commit));
2163         brelse(bh);
2164
2165         memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2166
2167         disk_super = fs_info->super_copy;
2168         if (!btrfs_super_root(disk_super))
2169                 goto fail_alloc;
2170
2171         /* check FS state, whether FS is broken. */
2172         fs_info->fs_state |= btrfs_super_flags(disk_super);
2173
2174         ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
2175         if (ret) {
2176                 printk(KERN_ERR "btrfs: superblock contains fatal errors\n");
2177                 err = ret;
2178                 goto fail_alloc;
2179         }
2180
2181         /*
2182          * run through our array of backup supers and setup
2183          * our ring pointer to the oldest one
2184          */
2185         generation = btrfs_super_generation(disk_super);
2186         find_oldest_super_backup(fs_info, generation);
2187
2188         /*
2189          * In the long term, we'll store the compression type in the super
2190          * block, and it'll be used for per file compression control.
2191          */
2192         fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
2193
2194         ret = btrfs_parse_options(tree_root, options);
2195         if (ret) {
2196                 err = ret;
2197                 goto fail_alloc;
2198         }
2199
2200         features = btrfs_super_incompat_flags(disk_super) &
2201                 ~BTRFS_FEATURE_INCOMPAT_SUPP;
2202         if (features) {
2203                 printk(KERN_ERR "BTRFS: couldn't mount because of "
2204                        "unsupported optional features (%Lx).\n",
2205                        (unsigned long long)features);
2206                 err = -EINVAL;
2207                 goto fail_alloc;
2208         }
2209
2210         if (btrfs_super_leafsize(disk_super) !=
2211             btrfs_super_nodesize(disk_super)) {
2212                 printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2213                        "blocksizes don't match.  node %d leaf %d\n",
2214                        btrfs_super_nodesize(disk_super),
2215                        btrfs_super_leafsize(disk_super));
2216                 err = -EINVAL;
2217                 goto fail_alloc;
2218         }
2219         if (btrfs_super_leafsize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {
2220                 printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2221                        "blocksize (%d) was too large\n",
2222                        btrfs_super_leafsize(disk_super));
2223                 err = -EINVAL;
2224                 goto fail_alloc;
2225         }
2226
2227         features = btrfs_super_incompat_flags(disk_super);
2228         features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
2229         if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
2230                 features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2231
2232         /*
2233          * flag our filesystem as having big metadata blocks if
2234          * they are bigger than the page size
2235          */
2236         if (btrfs_super_leafsize(disk_super) > PAGE_CACHE_SIZE) {
2237                 if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2238                         printk(KERN_INFO "btrfs flagging fs with big metadata feature\n");
2239                 features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
2240         }
2241
2242         nodesize = btrfs_super_nodesize(disk_super);
2243         leafsize = btrfs_super_leafsize(disk_super);
2244         sectorsize = btrfs_super_sectorsize(disk_super);
2245         stripesize = btrfs_super_stripesize(disk_super);
2246
2247         /*
2248          * mixed block groups end up with duplicate but slightly offset
2249          * extent buffers for the same range.  It leads to corruptions
2250          */
2251         if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
2252             (sectorsize != leafsize)) {
2253                 printk(KERN_WARNING "btrfs: unequal leaf/node/sector sizes "
2254                                 "are not allowed for mixed block groups on %s\n",
2255                                 sb->s_id);
2256                 goto fail_alloc;
2257         }
2258
2259         btrfs_set_super_incompat_flags(disk_super, features);
2260
2261         features = btrfs_super_compat_ro_flags(disk_super) &
2262                 ~BTRFS_FEATURE_COMPAT_RO_SUPP;
2263         if (!(sb->s_flags & MS_RDONLY) && features) {
2264                 printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
2265                        "unsupported option features (%Lx).\n",
2266                        (unsigned long long)features);
2267                 err = -EINVAL;
2268                 goto fail_alloc;
2269         }
2270
2271         btrfs_init_workers(&fs_info->generic_worker,
2272                            "genwork", 1, NULL);
2273
2274         btrfs_init_workers(&fs_info->workers, "worker",
2275                            fs_info->thread_pool_size,
2276                            &fs_info->generic_worker);
2277
2278         btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
2279                            fs_info->thread_pool_size,
2280                            &fs_info->generic_worker);
2281
2282         btrfs_init_workers(&fs_info->submit_workers, "submit",
2283                            min_t(u64, fs_devices->num_devices,
2284                            fs_info->thread_pool_size),
2285                            &fs_info->generic_worker);
2286
2287         btrfs_init_workers(&fs_info->caching_workers, "cache",
2288                            2, &fs_info->generic_worker);
2289
2290         /* a higher idle thresh on the submit workers makes it much more
2291          * likely that bios will be send down in a sane order to the
2292          * devices
2293          */
2294         fs_info->submit_workers.idle_thresh = 64;
2295
2296         fs_info->workers.idle_thresh = 16;
2297         fs_info->workers.ordered = 1;
2298
2299         fs_info->delalloc_workers.idle_thresh = 2;
2300         fs_info->delalloc_workers.ordered = 1;
2301
2302         btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
2303                            &fs_info->generic_worker);
2304         btrfs_init_workers(&fs_info->endio_workers, "endio",
2305                            fs_info->thread_pool_size,
2306                            &fs_info->generic_worker);
2307         btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
2308                            fs_info->thread_pool_size,
2309                            &fs_info->generic_worker);
2310         btrfs_init_workers(&fs_info->endio_meta_write_workers,
2311                            "endio-meta-write", fs_info->thread_pool_size,
2312                            &fs_info->generic_worker);
2313         btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
2314                            fs_info->thread_pool_size,
2315                            &fs_info->generic_worker);
2316         btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
2317                            1, &fs_info->generic_worker);
2318         btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
2319                            fs_info->thread_pool_size,
2320                            &fs_info->generic_worker);
2321         btrfs_init_workers(&fs_info->readahead_workers, "readahead",
2322                            fs_info->thread_pool_size,
2323                            &fs_info->generic_worker);
2324
2325         /*
2326          * endios are largely parallel and should have a very
2327          * low idle thresh
2328          */
2329         fs_info->endio_workers.idle_thresh = 4;
2330         fs_info->endio_meta_workers.idle_thresh = 4;
2331
2332         fs_info->endio_write_workers.idle_thresh = 2;
2333         fs_info->endio_meta_write_workers.idle_thresh = 2;
2334         fs_info->readahead_workers.idle_thresh = 2;
2335
2336         /*
2337          * btrfs_start_workers can really only fail because of ENOMEM so just
2338          * return -ENOMEM if any of these fail.
2339          */
2340         ret = btrfs_start_workers(&fs_info->workers);
2341         ret |= btrfs_start_workers(&fs_info->generic_worker);
2342         ret |= btrfs_start_workers(&fs_info->submit_workers);
2343         ret |= btrfs_start_workers(&fs_info->delalloc_workers);
2344         ret |= btrfs_start_workers(&fs_info->fixup_workers);
2345         ret |= btrfs_start_workers(&fs_info->endio_workers);
2346         ret |= btrfs_start_workers(&fs_info->endio_meta_workers);
2347         ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);
2348         ret |= btrfs_start_workers(&fs_info->endio_write_workers);
2349         ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);
2350         ret |= btrfs_start_workers(&fs_info->delayed_workers);
2351         ret |= btrfs_start_workers(&fs_info->caching_workers);
2352         ret |= btrfs_start_workers(&fs_info->readahead_workers);
2353         if (ret) {
2354                 err = -ENOMEM;
2355                 goto fail_sb_buffer;
2356         }
2357
2358         fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
2359         fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
2360                                     4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2361
2362         tree_root->nodesize = nodesize;
2363         tree_root->leafsize = leafsize;
2364         tree_root->sectorsize = sectorsize;
2365         tree_root->stripesize = stripesize;
2366
2367         sb->s_blocksize = sectorsize;
2368         sb->s_blocksize_bits = blksize_bits(sectorsize);
2369
2370         if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
2371                     sizeof(disk_super->magic))) {
2372                 printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
2373                 goto fail_sb_buffer;
2374         }
2375
2376         if (sectorsize != PAGE_SIZE) {
2377                 printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
2378                        "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2379                 goto fail_sb_buffer;
2380         }
2381
2382         mutex_lock(&fs_info->chunk_mutex);
2383         ret = btrfs_read_sys_array(tree_root);
2384         mutex_unlock(&fs_info->chunk_mutex);
2385         if (ret) {
2386                 printk(KERN_WARNING "btrfs: failed to read the system "
2387                        "array on %s\n", sb->s_id);
2388                 goto fail_sb_buffer;
2389         }
2390
2391         blocksize = btrfs_level_size(tree_root,
2392                                      btrfs_super_chunk_root_level(disk_super));
2393         generation = btrfs_super_chunk_root_generation(disk_super);
2394
2395         __setup_root(nodesize, leafsize, sectorsize, stripesize,
2396                      chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
2397
2398         chunk_root->node = read_tree_block(chunk_root,
2399                                            btrfs_super_chunk_root(disk_super),
2400                                            blocksize, generation);
2401         BUG_ON(!chunk_root->node); /* -ENOMEM */
2402         if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
2403                 printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
2404                        sb->s_id);
2405                 goto fail_tree_roots;
2406         }
2407         btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
2408         chunk_root->commit_root = btrfs_root_node(chunk_root);
2409
2410         read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2411            (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
2412            BTRFS_UUID_SIZE);
2413
2414         ret = btrfs_read_chunk_tree(chunk_root);
2415         if (ret) {
2416                 printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
2417                        sb->s_id);
2418                 goto fail_tree_roots;
2419         }
2420
2421         btrfs_close_extra_devices(fs_devices);
2422
2423         if (!fs_devices->latest_bdev) {
2424                 printk(KERN_CRIT "btrfs: failed to read devices on %s\n",
2425                        sb->s_id);
2426                 goto fail_tree_roots;
2427         }
2428
2429 retry_root_backup:
2430         blocksize = btrfs_level_size(tree_root,
2431                                      btrfs_super_root_level(disk_super));
2432         generation = btrfs_super_generation(disk_super);
2433
2434         tree_root->node = read_tree_block(tree_root,
2435                                           btrfs_super_root(disk_super),
2436                                           blocksize, generation);
2437         if (!tree_root->node ||
2438             !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2439                 printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
2440                        sb->s_id);
2441
2442                 goto recovery_tree_root;
2443         }
2444
2445         btrfs_set_root_node(&tree_root->root_item, tree_root->node);
2446         tree_root->commit_root = btrfs_root_node(tree_root);
2447
2448         ret = find_and_setup_root(tree_root, fs_info,
2449                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
2450         if (ret)
2451                 goto recovery_tree_root;
2452         extent_root->track_dirty = 1;
2453
2454         ret = find_and_setup_root(tree_root, fs_info,
2455                                   BTRFS_DEV_TREE_OBJECTID, dev_root);
2456         if (ret)
2457                 goto recovery_tree_root;
2458         dev_root->track_dirty = 1;
2459
2460         ret = find_and_setup_root(tree_root, fs_info,
2461                                   BTRFS_CSUM_TREE_OBJECTID, csum_root);
2462         if (ret)
2463                 goto recovery_tree_root;
2464         csum_root->track_dirty = 1;
2465
2466         ret = find_and_setup_root(tree_root, fs_info,
2467                                   BTRFS_QUOTA_TREE_OBJECTID, quota_root);
2468         if (ret) {
2469                 kfree(quota_root);
2470                 quota_root = fs_info->quota_root = NULL;
2471         } else {
2472                 quota_root->track_dirty = 1;
2473                 fs_info->quota_enabled = 1;
2474                 fs_info->pending_quota_state = 1;
2475         }
2476
2477         fs_info->generation = generation;
2478         fs_info->last_trans_committed = generation;
2479
2480         ret = btrfs_recover_balance(fs_info);
2481         if (ret) {
2482                 printk(KERN_WARNING "btrfs: failed to recover balance\n");
2483                 goto fail_block_groups;
2484         }
2485
2486         ret = btrfs_init_dev_stats(fs_info);
2487         if (ret) {
2488                 printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
2489                        ret);
2490                 goto fail_block_groups;
2491         }
2492
2493         ret = btrfs_init_space_info(fs_info);
2494         if (ret) {
2495                 printk(KERN_ERR "Failed to initial space info: %d\n", ret);
2496                 goto fail_block_groups;
2497         }
2498
2499         ret = btrfs_read_block_groups(extent_root);
2500         if (ret) {
2501                 printk(KERN_ERR "Failed to read block groups: %d\n", ret);
2502                 goto fail_block_groups;
2503         }
2504         fs_info->num_tolerated_disk_barrier_failures =
2505                 btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
2506
2507         fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
2508                                                "btrfs-cleaner");
2509         if (IS_ERR(fs_info->cleaner_kthread))
2510                 goto fail_block_groups;
2511
2512         fs_info->transaction_kthread = kthread_run(transaction_kthread,
2513                                                    tree_root,
2514                                                    "btrfs-transaction");
2515         if (IS_ERR(fs_info->transaction_kthread))
2516                 goto fail_cleaner;
2517
2518         if (!btrfs_test_opt(tree_root, SSD) &&
2519             !btrfs_test_opt(tree_root, NOSSD) &&
2520             !fs_info->fs_devices->rotating) {
2521                 printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
2522                        "mode\n");
2523                 btrfs_set_opt(fs_info->mount_opt, SSD);
2524         }
2525
2526 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2527         if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) {
2528                 ret = btrfsic_mount(tree_root, fs_devices,
2529                                     btrfs_test_opt(tree_root,
2530                                         CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
2531                                     1 : 0,
2532                                     fs_info->check_integrity_print_mask);
2533                 if (ret)
2534                         printk(KERN_WARNING "btrfs: failed to initialize"
2535                                " integrity check module %s\n", sb->s_id);
2536         }
2537 #endif
2538         ret = btrfs_read_qgroup_config(fs_info);
2539         if (ret)
2540                 goto fail_trans_kthread;
2541
2542         /* do not make disk changes in broken FS */
2543         if (btrfs_super_log_root(disk_super) != 0) {
2544                 u64 bytenr = btrfs_super_log_root(disk_super);
2545
2546                 if (fs_devices->rw_devices == 0) {
2547                         printk(KERN_WARNING "Btrfs log replay required "
2548                                "on RO media\n");
2549                         err = -EIO;
2550                         goto fail_qgroup;
2551                 }
2552                 blocksize =
2553                      btrfs_level_size(tree_root,
2554                                       btrfs_super_log_root_level(disk_super));
2555
2556                 log_tree_root = btrfs_alloc_root(fs_info);
2557                 if (!log_tree_root) {
2558                         err = -ENOMEM;
2559                         goto fail_qgroup;
2560                 }
2561
2562                 __setup_root(nodesize, leafsize, sectorsize, stripesize,
2563                              log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
2564
2565                 log_tree_root->node = read_tree_block(tree_root, bytenr,
2566                                                       blocksize,
2567                                                       generation + 1);
2568                 /* returns with log_tree_root freed on success */
2569                 ret = btrfs_recover_log_trees(log_tree_root);
2570                 if (ret) {
2571                         btrfs_error(tree_root->fs_info, ret,
2572                                     "Failed to recover log tree");
2573                         free_extent_buffer(log_tree_root->node);
2574                         kfree(log_tree_root);
2575                         goto fail_trans_kthread;
2576                 }
2577
2578                 if (sb->s_flags & MS_RDONLY) {
2579                         ret = btrfs_commit_super(tree_root);
2580                         if (ret)
2581                                 goto fail_trans_kthread;
2582                 }
2583         }
2584
2585         ret = btrfs_find_orphan_roots(tree_root);
2586         if (ret)
2587                 goto fail_trans_kthread;
2588
2589         if (!(sb->s_flags & MS_RDONLY)) {
2590                 ret = btrfs_cleanup_fs_roots(fs_info);
2591                 if (ret)
2592                         goto fail_trans_kthread;
2593
2594                 ret = btrfs_recover_relocation(tree_root);
2595                 if (ret < 0) {
2596                         printk(KERN_WARNING
2597                                "btrfs: failed to recover relocation\n");
2598                         err = -EINVAL;
2599                         goto fail_qgroup;
2600                 }
2601         }
2602
2603         location.objectid = BTRFS_FS_TREE_OBJECTID;
2604         location.type = BTRFS_ROOT_ITEM_KEY;
2605         location.offset = (u64)-1;
2606
2607         fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
2608         if (!fs_info->fs_root)
2609                 goto fail_qgroup;
2610         if (IS_ERR(fs_info->fs_root)) {
2611                 err = PTR_ERR(fs_info->fs_root);
2612                 goto fail_qgroup;
2613         }
2614
2615         if (sb->s_flags & MS_RDONLY)
2616                 return 0;
2617
2618         down_read(&fs_info->cleanup_work_sem);
2619         if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2620             (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2621                 up_read(&fs_info->cleanup_work_sem);
2622                 close_ctree(tree_root);
2623                 return ret;
2624         }
2625         up_read(&fs_info->cleanup_work_sem);
2626
2627         ret = btrfs_resume_balance_async(fs_info);
2628         if (ret) {
2629                 printk(KERN_WARNING "btrfs: failed to resume balance\n");
2630                 close_ctree(tree_root);
2631                 return ret;
2632         }
2633
2634         return 0;
2635
2636 fail_qgroup:
2637         btrfs_free_qgroup_config(fs_info);
2638 fail_trans_kthread:
2639         kthread_stop(fs_info->transaction_kthread);
2640 fail_cleaner:
2641         kthread_stop(fs_info->cleaner_kthread);
2642
2643         /*
2644          * make sure we're done with the btree inode before we stop our
2645          * kthreads
2646          */
2647         filemap_write_and_wait(fs_info->btree_inode->i_mapping);
2648         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2649
2650 fail_block_groups:
2651         btrfs_free_block_groups(fs_info);
2652
2653 fail_tree_roots:
2654         free_root_pointers(fs_info, 1);
2655
2656 fail_sb_buffer:
2657         btrfs_stop_workers(&fs_info->generic_worker);
2658         btrfs_stop_workers(&fs_info->readahead_workers);
2659         btrfs_stop_workers(&fs_info->fixup_workers);
2660         btrfs_stop_workers(&fs_info->delalloc_workers);
2661         btrfs_stop_workers(&fs_info->workers);
2662         btrfs_stop_workers(&fs_info->endio_workers);
2663         btrfs_stop_workers(&fs_info->endio_meta_workers);
2664         btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2665         btrfs_stop_workers(&fs_info->endio_write_workers);
2666         btrfs_stop_workers(&fs_info->endio_freespace_worker);
2667         btrfs_stop_workers(&fs_info->submit_workers);
2668         btrfs_stop_workers(&fs_info->delayed_workers);
2669         btrfs_stop_workers(&fs_info->caching_workers);
2670 fail_alloc:
2671 fail_iput:
2672         btrfs_mapping_tree_free(&fs_info->mapping_tree);
2673
2674         invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2675         iput(fs_info->btree_inode);
2676 fail_bdi:
2677         bdi_destroy(&fs_info->bdi);
2678 fail_srcu:
2679         cleanup_srcu_struct(&fs_info->subvol_srcu);
2680 fail:
2681         btrfs_close_devices(fs_info->fs_devices);
2682         return err;
2683
2684 recovery_tree_root:
2685         if (!btrfs_test_opt(tree_root, RECOVERY))
2686                 goto fail_tree_roots;
2687
2688         free_root_pointers(fs_info, 0);
2689
2690         /* don't use the log in recovery mode, it won't be valid */
2691         btrfs_set_super_log_root(disk_super, 0);
2692
2693         /* we can't trust the free space cache either */
2694         btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2695
2696         ret = next_root_backup(fs_info, fs_info->super_copy,
2697                                &num_backups_tried, &backup_index);
2698         if (ret == -1)
2699                 goto fail_block_groups;
2700         goto retry_root_backup;
2701 }
2702
2703 static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
2704 {
2705         if (uptodate) {
2706                 set_buffer_uptodate(bh);
2707         } else {
2708                 struct btrfs_device *device = (struct btrfs_device *)
2709                         bh->b_private;
2710
2711                 printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
2712                                           "I/O error on %s\n",
2713                                           rcu_str_deref(device->name));
2714                 /* note, we dont' set_buffer_write_io_error because we have
2715                  * our own ways of dealing with the IO errors
2716                  */
2717                 clear_buffer_uptodate(bh);
2718                 btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
2719         }
2720         unlock_buffer(bh);
2721         put_bh(bh);
2722 }
2723
2724 struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
2725 {
2726         struct buffer_head *bh;
2727         struct buffer_head *latest = NULL;
2728         struct btrfs_super_block *super;
2729         int i;
2730         u64 transid = 0;
2731         u64 bytenr;
2732
2733         /* we would like to check all the supers, but that would make
2734          * a btrfs mount succeed after a mkfs from a different FS.
2735          * So, we need to add a special mount option to scan for
2736          * later supers, using BTRFS_SUPER_MIRROR_MAX instead
2737          */
2738         for (i = 0; i < 1; i++) {
2739                 bytenr = btrfs_sb_offset(i);
2740                 if (bytenr + 4096 >= i_size_read(bdev->bd_inode))
2741                         break;
2742                 bh = __bread(bdev, bytenr / 4096, 4096);
2743                 if (!bh)
2744                         continue;
2745
2746                 super = (struct btrfs_super_block *)bh->b_data;
2747                 if (btrfs_super_bytenr(super) != bytenr ||
2748                     strncmp((char *)(&super->magic), BTRFS_MAGIC,
2749                             sizeof(super->magic))) {
2750                         brelse(bh);
2751                         continue;
2752                 }
2753
2754                 if (!latest || btrfs_super_generation(super) > transid) {
2755                         brelse(latest);
2756                         latest = bh;
2757                         transid = btrfs_super_generation(super);
2758                 } else {
2759                         brelse(bh);
2760                 }
2761         }
2762         return latest;
2763 }
2764
2765 /*
2766  * this should be called twice, once with wait == 0 and
2767  * once with wait == 1.  When wait == 0 is done, all the buffer heads
2768  * we write are pinned.
2769  *
2770  * They are released when wait == 1 is done.
2771  * max_mirrors must be the same for both runs, and it indicates how
2772  * many supers on this one device should be written.
2773  *
2774  * max_mirrors == 0 means to write them all.
2775  */
2776 static int write_dev_supers(struct btrfs_device *device,
2777                             struct btrfs_super_block *sb,
2778                             int do_barriers, int wait, int max_mirrors)
2779 {
2780         struct buffer_head *bh;
2781         int i;
2782         int ret;
2783         int errors = 0;
2784         u32 crc;
2785         u64 bytenr;
2786
2787         if (max_mirrors == 0)
2788                 max_mirrors = BTRFS_SUPER_MIRROR_MAX;
2789
2790         for (i = 0; i < max_mirrors; i++) {
2791                 bytenr = btrfs_sb_offset(i);
2792                 if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
2793                         break;
2794
2795                 if (wait) {
2796                         bh = __find_get_block(device->bdev, bytenr / 4096,
2797                                               BTRFS_SUPER_INFO_SIZE);
2798                         BUG_ON(!bh);
2799                         wait_on_buffer(bh);
2800                         if (!buffer_uptodate(bh))
2801                                 errors++;
2802
2803                         /* drop our reference */
2804                         brelse(bh);
2805
2806                         /* drop the reference from the wait == 0 run */
2807                         brelse(bh);
2808                         continue;
2809                 } else {
2810                         btrfs_set_super_bytenr(sb, bytenr);
2811
2812                         crc = ~(u32)0;
2813                         crc = btrfs_csum_data(NULL, (char *)sb +
2814                                               BTRFS_CSUM_SIZE, crc,
2815                                               BTRFS_SUPER_INFO_SIZE -
2816                                               BTRFS_CSUM_SIZE);
2817                         btrfs_csum_final(crc, sb->csum);
2818
2819                         /*
2820                          * one reference for us, and we leave it for the
2821                          * caller
2822                          */
2823                         bh = __getblk(device->bdev, bytenr / 4096,
2824                                       BTRFS_SUPER_INFO_SIZE);
2825                         memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
2826
2827                         /* one reference for submit_bh */
2828                         get_bh(bh);
2829
2830                         set_buffer_uptodate(bh);
2831                         lock_buffer(bh);
2832                         bh->b_end_io = btrfs_end_buffer_write_sync;
2833                         bh->b_private = device;
2834                 }
2835
2836                 /*
2837                  * we fua the first super.  The others we allow
2838                  * to go down lazy.
2839                  */
2840                 ret = btrfsic_submit_bh(WRITE_FUA, bh);
2841                 if (ret)
2842                         errors++;
2843         }
2844         return errors < i ? 0 : -1;
2845 }
2846
2847 /*
2848  * endio for the write_dev_flush, this will wake anyone waiting
2849  * for the barrier when it is done
2850  */
2851 static void btrfs_end_empty_barrier(struct bio *bio, int err)
2852 {
2853         if (err) {
2854                 if (err == -EOPNOTSUPP)
2855                         set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
2856                 clear_bit(BIO_UPTODATE, &bio->bi_flags);
2857         }
2858         if (bio->bi_private)
2859                 complete(bio->bi_private);
2860         bio_put(bio);
2861 }
2862
2863 /*
2864  * trigger flushes for one the devices.  If you pass wait == 0, the flushes are
2865  * sent down.  With wait == 1, it waits for the previous flush.
2866  *
2867  * any device where the flush fails with eopnotsupp are flagged as not-barrier
2868  * capable
2869  */
2870 static int write_dev_flush(struct btrfs_device *device, int wait)
2871 {
2872         struct bio *bio;
2873         int ret = 0;
2874
2875         if (device->nobarriers)
2876                 return 0;
2877
2878         if (wait) {
2879                 bio = device->flush_bio;
2880                 if (!bio)
2881                         return 0;
2882
2883                 wait_for_completion(&device->flush_wait);
2884
2885                 if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
2886                         printk_in_rcu("btrfs: disabling barriers on dev %s\n",
2887                                       rcu_str_deref(device->name));
2888                         device->nobarriers = 1;
2889                 } else if (!bio_flagged(bio, BIO_UPTODATE)) {
2890                         ret = -EIO;
2891                         btrfs_dev_stat_inc_and_print(device,
2892                                 BTRFS_DEV_STAT_FLUSH_ERRS);
2893                 }
2894
2895                 /* drop the reference from the wait == 0 run */
2896                 bio_put(bio);
2897                 device->flush_bio = NULL;
2898
2899                 return ret;
2900         }
2901
2902         /*
2903          * one reference for us, and we leave it for the
2904          * caller
2905          */
2906         device->flush_bio = NULL;
2907         bio = bio_alloc(GFP_NOFS, 0);
2908         if (!bio)
2909                 return -ENOMEM;
2910
2911         bio->bi_end_io = btrfs_end_empty_barrier;
2912         bio->bi_bdev = device->bdev;
2913         init_completion(&device->flush_wait);
2914         bio->bi_private = &device->flush_wait;
2915         device->flush_bio = bio;
2916
2917         bio_get(bio);
2918         btrfsic_submit_bio(WRITE_FLUSH, bio);
2919
2920         return 0;
2921 }
2922
2923 /*
2924  * send an empty flush down to each device in parallel,
2925  * then wait for them
2926  */
2927 static int barrier_all_devices(struct btrfs_fs_info *info)
2928 {
2929         struct list_head *head;
2930         struct btrfs_device *dev;
2931         int errors_send = 0;
2932         int errors_wait = 0;
2933         int ret;
2934
2935         /* send down all the barriers */
2936         head = &info->fs_devices->devices;
2937         list_for_each_entry_rcu(dev, head, dev_list) {
2938                 if (!dev->bdev) {
2939                         errors_send++;
2940                         continue;
2941                 }
2942                 if (!dev->in_fs_metadata || !dev->writeable)
2943                         continue;
2944
2945                 ret = write_dev_flush(dev, 0);
2946                 if (ret)
2947                         errors_send++;
2948         }
2949
2950         /* wait for all the barriers */
2951         list_for_each_entry_rcu(dev, head, dev_list) {
2952                 if (!dev->bdev) {
2953                         errors_wait++;
2954                         continue;
2955                 }
2956                 if (!dev->in_fs_metadata || !dev->writeable)
2957                         continue;
2958
2959                 ret = write_dev_flush(dev, 1);
2960                 if (ret)
2961                         errors_wait++;
2962         }
2963         if (errors_send > info->num_tolerated_disk_barrier_failures ||
2964             errors_wait > info->num_tolerated_disk_barrier_failures)
2965                 return -EIO;
2966         return 0;
2967 }
2968
2969 int btrfs_calc_num_tolerated_disk_barrier_failures(
2970         struct btrfs_fs_info *fs_info)
2971 {
2972         struct btrfs_ioctl_space_info space;
2973         struct btrfs_space_info *sinfo;
2974         u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
2975                        BTRFS_BLOCK_GROUP_SYSTEM,
2976                        BTRFS_BLOCK_GROUP_METADATA,
2977                        BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
2978         int num_types = 4;
2979         int i;
2980         int c;
2981         int num_tolerated_disk_barrier_failures =
2982                 (int)fs_info->fs_devices->num_devices;
2983
2984         for (i = 0; i < num_types; i++) {
2985                 struct btrfs_space_info *tmp;
2986
2987                 sinfo = NULL;
2988                 rcu_read_lock();
2989                 list_for_each_entry_rcu(tmp, &fs_info->space_info, list) {
2990                         if (tmp->flags == types[i]) {
2991                                 sinfo = tmp;
2992                                 break;
2993                         }
2994                 }
2995                 rcu_read_unlock();
2996
2997                 if (!sinfo)
2998                         continue;
2999
3000                 down_read(&sinfo->groups_sem);
3001                 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
3002                         if (!list_empty(&sinfo->block_groups[c])) {
3003                                 u64 flags;
3004
3005                                 btrfs_get_block_group_info(
3006                                         &sinfo->block_groups[c], &space);
3007                                 if (space.total_bytes == 0 ||
3008                                     space.used_bytes == 0)
3009                                         continue;
3010                                 flags = space.flags;
3011                                 /*
3012                                  * return
3013                                  * 0: if dup, single or RAID0 is configured for
3014                                  *    any of metadata, system or data, else
3015                                  * 1: if RAID5 is configured, or if RAID1 or
3016                                  *    RAID10 is configured and only two mirrors
3017                                  *    are used, else
3018                                  * 2: if RAID6 is configured, else
3019                                  * num_mirrors - 1: if RAID1 or RAID10 is
3020                                  *                  configured and more than
3021                                  *                  2 mirrors are used.
3022                                  */
3023                                 if (num_tolerated_disk_barrier_failures > 0 &&
3024                                     ((flags & (BTRFS_BLOCK_GROUP_DUP |
3025                                                BTRFS_BLOCK_GROUP_RAID0)) ||
3026                                      ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)
3027                                       == 0)))
3028                                         num_tolerated_disk_barrier_failures = 0;
3029                                 else if (num_tolerated_disk_barrier_failures > 1
3030                                          &&
3031                                          (flags & (BTRFS_BLOCK_GROUP_RAID1 |
3032                                                    BTRFS_BLOCK_GROUP_RAID10)))
3033                                         num_tolerated_disk_barrier_failures = 1;
3034                         }
3035                 }
3036                 up_read(&sinfo->groups_sem);
3037         }
3038
3039         return num_tolerated_disk_barrier_failures;
3040 }
3041
3042 int write_all_supers(struct btrfs_root *root, int max_mirrors)
3043 {
3044         struct list_head *head;
3045         struct btrfs_device *dev;
3046         struct btrfs_super_block *sb;
3047         struct btrfs_dev_item *dev_item;
3048         int ret;
3049         int do_barriers;
3050         int max_errors;
3051         int total_errors = 0;
3052         u64 flags;
3053
3054         max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
3055         do_barriers = !btrfs_test_opt(root, NOBARRIER);
3056         backup_super_roots(root->fs_info);
3057
3058         sb = root->fs_info->super_for_commit;
3059         dev_item = &sb->dev_item;
3060
3061         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
3062         head = &root->fs_info->fs_devices->devices;
3063
3064         if (do_barriers) {
3065                 ret = barrier_all_devices(root->fs_info);
3066                 if (ret) {
3067                         mutex_unlock(
3068                                 &root->fs_info->fs_devices->device_list_mutex);
3069                         btrfs_error(root->fs_info, ret,
3070                                     "errors while submitting device barriers.");
3071                         return ret;
3072                 }
3073         }
3074
3075         list_for_each_entry_rcu(dev, head, dev_list) {
3076                 if (!dev->bdev) {
3077                         total_errors++;
3078                         continue;
3079                 }
3080                 if (!dev->in_fs_metadata || !dev->writeable)
3081                         continue;
3082
3083                 btrfs_set_stack_device_generation(dev_item, 0);
3084                 btrfs_set_stack_device_type(dev_item, dev->type);
3085                 btrfs_set_stack_device_id(dev_item, dev->devid);
3086                 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
3087                 btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
3088                 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
3089                 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
3090                 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
3091                 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
3092                 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
3093
3094                 flags = btrfs_super_flags(sb);
3095                 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
3096
3097                 ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3098                 if (ret)
3099                         total_errors++;
3100         }
3101         if (total_errors > max_errors) {
3102                 printk(KERN_ERR "btrfs: %d errors while writing supers\n",
3103                        total_errors);
3104
3105                 /* This shouldn't happen. FUA is masked off if unsupported */
3106                 BUG();
3107         }
3108
3109         total_errors = 0;
3110         list_for_each_entry_rcu(dev, head, dev_list) {
3111                 if (!dev->bdev)
3112                         continue;
3113                 if (!dev->in_fs_metadata || !dev->writeable)
3114                         continue;
3115
3116                 ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
3117                 if (ret)
3118                         total_errors++;
3119         }
3120         mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3121         if (total_errors > max_errors) {
3122                 btrfs_error(root->fs_info, -EIO,
3123                             "%d errors while writing supers", total_errors);
3124                 return -EIO;
3125         }
3126         return 0;
3127 }
3128
3129 int write_ctree_super(struct btrfs_trans_handle *trans,
3130                       struct btrfs_root *root, int max_mirrors)
3131 {
3132         int ret;
3133
3134         ret = write_all_supers(root, max_mirrors);
3135         return ret;
3136 }
3137
3138 void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
3139 {
3140         spin_lock(&fs_info->fs_roots_radix_lock);
3141         radix_tree_delete(&fs_info->fs_roots_radix,
3142                           (unsigned long)root->root_key.objectid);
3143         spin_unlock(&fs_info->fs_roots_radix_lock);
3144
3145         if (btrfs_root_refs(&root->root_item) == 0)
3146                 synchronize_srcu(&fs_info->subvol_srcu);
3147
3148         __btrfs_remove_free_space_cache(root->free_ino_pinned);
3149         __btrfs_remove_free_space_cache(root->free_ino_ctl);
3150         free_fs_root(root);
3151 }
3152
3153 static void free_fs_root(struct btrfs_root *root)
3154 {
3155         iput(root->cache_inode);
3156         WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3157         if (root->anon_dev)
3158                 free_anon_bdev(root->anon_dev);
3159         free_extent_buffer(root->node);
3160         free_extent_buffer(root->commit_root);
3161         kfree(root->free_ino_ctl);
3162         kfree(root->free_ino_pinned);
3163         kfree(root->name);
3164         kfree(root);
3165 }
3166
3167 static void del_fs_roots(struct btrfs_fs_info *fs_info)
3168 {
3169         int ret;
3170         struct btrfs_root *gang[8];
3171         int i;
3172
3173         while (!list_empty(&fs_info->dead_roots)) {
3174                 gang[0] = list_entry(fs_info->dead_roots.next,
3175                                      struct btrfs_root, root_list);
3176                 list_del(&gang[0]->root_list);
3177
3178                 if (gang[0]->in_radix) {
3179                         btrfs_free_fs_root(fs_info, gang[0]);
3180                 } else {
3181                         free_extent_buffer(gang[0]->node);
3182                         free_extent_buffer(gang[0]->commit_root);
3183                         kfree(gang[0]);
3184                 }
3185         }
3186
3187         while (1) {
3188                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3189                                              (void **)gang, 0,
3190                                              ARRAY_SIZE(gang));
3191                 if (!ret)
3192                         break;
3193                 for (i = 0; i < ret; i++)
3194                         btrfs_free_fs_root(fs_info, gang[i]);
3195         }
3196 }
3197
3198 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
3199 {
3200         u64 root_objectid = 0;
3201         struct btrfs_root *gang[8];
3202         int i;
3203         int ret;
3204
3205         while (1) {
3206                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3207                                              (void **)gang, root_objectid,
3208                                              ARRAY_SIZE(gang));
3209                 if (!ret)
3210                         break;
3211
3212                 root_objectid = gang[ret - 1]->root_key.objectid + 1;
3213                 for (i = 0; i < ret; i++) {
3214                         int err;
3215
3216                         root_objectid = gang[i]->root_key.objectid;
3217                         err = btrfs_orphan_cleanup(gang[i]);
3218                         if (err)
3219                                 return err;
3220                 }
3221                 root_objectid++;
3222         }
3223         return 0;
3224 }
3225
3226 int btrfs_commit_super(struct btrfs_root *root)
3227 {
3228         struct btrfs_trans_handle *trans;
3229         int ret;
3230
3231         mutex_lock(&root->fs_info->cleaner_mutex);
3232         btrfs_run_delayed_iputs(root);
3233         btrfs_clean_old_snapshots(root);
3234         mutex_unlock(&root->fs_info->cleaner_mutex);
3235
3236         /* wait until ongoing cleanup work done */
3237         down_write(&root->fs_info->cleanup_work_sem);
3238         up_write(&root->fs_info->cleanup_work_sem);
3239
3240         trans = btrfs_join_transaction(root);
3241         if (IS_ERR(trans))
3242                 return PTR_ERR(trans);
3243         ret = btrfs_commit_transaction(trans, root);
3244         if (ret)
3245                 return ret;
3246         /* run commit again to drop the original snapshot */
3247         trans = btrfs_join_transaction(root);
3248         if (IS_ERR(trans))
3249                 return PTR_ERR(trans);
3250         ret = btrfs_commit_transaction(trans, root);
3251         if (ret)
3252                 return ret;
3253         ret = btrfs_write_and_wait_transaction(NULL, root);
3254         if (ret) {
3255                 btrfs_error(root->fs_info, ret,
3256                             "Failed to sync btree inode to disk.");
3257                 return ret;
3258         }
3259
3260         ret = write_ctree_super(NULL, root, 0);
3261         return ret;
3262 }
3263
3264 int close_ctree(struct btrfs_root *root)
3265 {
3266         struct btrfs_fs_info *fs_info = root->fs_info;
3267         int ret;
3268
3269         fs_info->closing = 1;
3270         smp_mb();
3271
3272         /* pause restriper - we want to resume on mount */
3273         btrfs_pause_balance(root->fs_info);
3274
3275         btrfs_scrub_cancel(root);
3276
3277         /* wait for any defraggers to finish */
3278         wait_event(fs_info->transaction_wait,
3279                    (atomic_read(&fs_info->defrag_running) == 0));
3280
3281         /* clear out the rbtree of defraggable inodes */
3282         btrfs_run_defrag_inodes(fs_info);
3283
3284         if (!(fs_info->sb->s_flags & MS_RDONLY)) {
3285                 ret = btrfs_commit_super(root);
3286                 if (ret)
3287                         printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
3288         }
3289
3290         if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
3291                 btrfs_error_commit_super(root);
3292
3293         btrfs_put_block_group_cache(fs_info);
3294
3295         kthread_stop(fs_info->transaction_kthread);
3296         kthread_stop(fs_info->cleaner_kthread);
3297
3298         fs_info->closing = 2;
3299         smp_mb();
3300
3301         btrfs_free_qgroup_config(root->fs_info);
3302
3303         if (fs_info->delalloc_bytes) {
3304                 printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
3305                        (unsigned long long)fs_info->delalloc_bytes);
3306         }
3307
3308         free_extent_buffer(fs_info->extent_root->node);
3309         free_extent_buffer(fs_info->extent_root->commit_root);
3310         free_extent_buffer(fs_info->tree_root->node);
3311         free_extent_buffer(fs_info->tree_root->commit_root);
3312         free_extent_buffer(fs_info->chunk_root->node);
3313         free_extent_buffer(fs_info->chunk_root->commit_root);
3314         free_extent_buffer(fs_info->dev_root->node);
3315         free_extent_buffer(fs_info->dev_root->commit_root);
3316         free_extent_buffer(fs_info->csum_root->node);
3317         free_extent_buffer(fs_info->csum_root->commit_root);
3318         if (fs_info->quota_root) {
3319                 free_extent_buffer(fs_info->quota_root->node);
3320                 free_extent_buffer(fs_info->quota_root->commit_root);
3321         }
3322
3323         btrfs_free_block_groups(fs_info);
3324
3325         del_fs_roots(fs_info);
3326
3327         iput(fs_info->btree_inode);
3328
3329         btrfs_stop_workers(&fs_info->generic_worker);