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