Btrfs: pass fs_info to btrfs_map_block() instead of mapping_tree

This is required for the device replace procedure in a later step.
Two calling functions also had to be changed to have the fs_info
pointer: repair_io_failure() and scrub_setup_recheck_block().

Signed-off-by: Stefan Behrens <sbehrens@giantdisaster.de>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 58dfac1359a32e29fdad40f7286166e4fa51c592..8f9abedae2c3cd6940ca7f6b3508365187773149 100644 (file)
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -1582,7 +1582,7 @@ static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len,
        struct btrfs_device *device;
 
        length = len;
-       ret = btrfs_map_block(&state->root->fs_info->mapping_tree, READ,
+       ret = btrfs_map_block(state->root->fs_info, READ,
                              bytenr, &length, &multi, mirror_num);
 
        device = multi->stripes[0].dev;

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index f8a358aee060e8591a779baa2eba44a406ebe3ff..b4d438f6c2b3d4aac698fa61a3ea9b093e4e21fd 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -1818,7 +1818,7 @@ static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
 
 
        /* Tell the block device(s) that the sectors can be discarded */
-       ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD,
+       ret = btrfs_map_block(root->fs_info, REQ_DISCARD,
                              bytenr, &num_bytes, &bbio, 0);
        /* Error condition is -ENOMEM */
        if (!ret) {

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index e0b7138909f0ac980ee18d760da20d5892fda0df..62ec6e45f705a73d72e04ccc3759dd9b34f1eed7 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1917,12 +1917,12 @@ static void repair_io_failure_callback(struct bio *bio, int err)
  * the standard behavior is to write all copies in a raid setup. here we only
  * want to write the one bad copy. so we do the mapping for ourselves and issue
  * submit_bio directly.
- * to avoid any synchonization issues, wait for the data after writing, which
+ * to avoid any synchronization issues, wait for the data after writing, which
  * actually prevents the read that triggered the error from finishing.
  * currently, there can be no more than two copies of every data bit. thus,
  * exactly one rewrite is required.
  */
-int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
+int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
                        u64 length, u64 logical, struct page *page,
                        int mirror_num)
 {
@@ -1944,7 +1944,7 @@ int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
        bio->bi_size = 0;
        map_length = length;
 
-       ret = btrfs_map_block(map_tree, WRITE, logical,
+       ret = btrfs_map_block(fs_info, WRITE, logical,
                              &map_length, &bbio, mirror_num);
        if (ret) {
                bio_put(bio);
@@ -1982,14 +1982,13 @@ int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
 int repair_eb_io_failure(struct btrfs_root *root, struct extent_buffer *eb,
                         int mirror_num)
 {
-       struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
        u64 start = eb->start;
        unsigned long i, num_pages = num_extent_pages(eb->start, eb->len);
        int ret = 0;
 
        for (i = 0; i < num_pages; i++) {
                struct page *p = extent_buffer_page(eb, i);
-               ret = repair_io_failure(map_tree, start, PAGE_CACHE_SIZE,
+               ret = repair_io_failure(root->fs_info, start, PAGE_CACHE_SIZE,
                                        start, p, mirror_num);
                if (ret)
                        break;
@@ -2008,7 +2007,7 @@ static int clean_io_failure(u64 start, struct page *page)
        u64 private;
        u64 private_failure;
        struct io_failure_record *failrec;
-       struct btrfs_mapping_tree *map_tree;
+       struct btrfs_fs_info *fs_info;
        struct extent_state *state;
        int num_copies;
        int did_repair = 0;
@@ -2044,11 +2043,11 @@ static int clean_io_failure(u64 start, struct page *page)
        spin_unlock(&BTRFS_I(inode)->io_tree.lock);
 
        if (state && state->start == failrec->start) {
-               num_copies = btrfs_num_copies(BTRFS_I(inode)->root->fs_info,
-                                             failrec->logical, failrec->len);
+               fs_info = BTRFS_I(inode)->root->fs_info;
+               num_copies = btrfs_num_copies(fs_info, failrec->logical,
+                                             failrec->len);
                if (num_copies > 1)  {
-                       map_tree = &BTRFS_I(inode)->root->fs_info->mapping_tree;
-                       ret = repair_io_failure(map_tree, start, failrec->len,
+                       ret = repair_io_failure(fs_info, start, failrec->len,
                                                failrec->logical, page,
                                                failrec->failed_mirror);
                        did_repair = !ret;

diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 711d12b80028b701033d7a326b28ed18b43e37ff..2eacfabd32632e90056e76cc5a678ecce6c6504a 100644 (file)
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -337,9 +337,9 @@ struct bio *
 btrfs_bio_alloc(struct block_device *bdev, u64 first_sector, int nr_vecs,
                gfp_t gfp_flags);
 
-struct btrfs_mapping_tree;
+struct btrfs_fs_info;
 
-int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
+int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
                        u64 length, u64 logical, struct page *page,
                        int mirror_num);
 int end_extent_writepage(struct page *page, int err, u64 start, u64 end);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index aabf747d056e1bd6bf7ff3919ee338b6bf27354c..5d1675a8c9e2afb7db7b3cf9457106a15231d441 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1549,7 +1549,6 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
                         unsigned long bio_flags)
 {
        struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
-       struct btrfs_mapping_tree *map_tree;
        u64 logical = (u64)bio->bi_sector << 9;
        u64 length = 0;
        u64 map_length;
@@ -1559,11 +1558,10 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
                return 0;
 
        length = bio->bi_size;
-       map_tree = &root->fs_info->mapping_tree;
        map_length = length;
-       ret = btrfs_map_block(map_tree, READ, logical,
+       ret = btrfs_map_block(root->fs_info, READ, logical,
                              &map_length, NULL, 0);
-       /* Will always return 0 or 1 with map_multi == NULL */
+       /* Will always return 0 with map_multi == NULL */
        BUG_ON(ret < 0);
        if (map_length < length + size)
                return 1;
@@ -6364,7 +6362,6 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
 {
        struct inode *inode = dip->inode;
        struct btrfs_root *root = BTRFS_I(inode)->root;
-       struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
        struct bio *bio;
        struct bio *orig_bio = dip->orig_bio;
        struct bio_vec *bvec = orig_bio->bi_io_vec;
@@ -6377,7 +6374,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
        int async_submit = 0;
 
        map_length = orig_bio->bi_size;
-       ret = btrfs_map_block(map_tree, READ, start_sector << 9,
+       ret = btrfs_map_block(root->fs_info, READ, start_sector << 9,
                              &map_length, NULL, 0);
        if (ret) {
                bio_put(orig_bio);
@@ -6431,7 +6428,8 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                        bio->bi_end_io = btrfs_end_dio_bio;
 
                        map_length = orig_bio->bi_size;
-                       ret = btrfs_map_block(map_tree, READ, start_sector << 9,
+                       ret = btrfs_map_block(root->fs_info, READ,
+                                             start_sector << 9,
                                              &map_length, NULL, 0);
                        if (ret) {
                                bio_put(bio);

diff --git a/fs/btrfs/reada.c b/fs/btrfs/reada.c
index a955669519a265bbfb5f13de4723c87932f8047e..0ddc5659f9461b96ce7f365de87abb4e4836e723 100644 (file)
--- a/fs/btrfs/reada.c
+++ b/fs/btrfs/reada.c
@@ -323,7 +323,6 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
        struct reada_extent *re = NULL;
        struct reada_extent *re_exist = NULL;
        struct btrfs_fs_info *fs_info = root->fs_info;
-       struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
        struct btrfs_bio *bbio = NULL;
        struct btrfs_device *dev;
        struct btrfs_device *prev_dev;
@@ -358,7 +357,7 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
         * map block
         */
        length = blocksize;
-       ret = btrfs_map_block(map_tree, REQ_WRITE, logical, &length, &bbio, 0);
+       ret = btrfs_map_block(fs_info, REQ_WRITE, logical, &length, &bbio, 0);
        if (ret || !bbio || length < blocksize)
                goto error;
 

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index a67b1a17a0092b9a049fbb9de72dffbc0a1ef04e..894bb2732fcc55ab192d732045ee79033a76afda 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -152,7 +152,7 @@ static void scrub_pending_trans_workers_inc(struct scrub_ctx *sctx);
 static void scrub_pending_trans_workers_dec(struct scrub_ctx *sctx);
 static int scrub_handle_errored_block(struct scrub_block *sblock_to_check);
 static int scrub_setup_recheck_block(struct scrub_ctx *sctx,
-                                    struct btrfs_mapping_tree *map_tree,
+                                    struct btrfs_fs_info *fs_info,
                                     u64 length, u64 logical,
                                     struct scrub_block *sblock);
 static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
@@ -523,7 +523,7 @@ static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *ctx)
        }
 
        if (PageUptodate(page)) {
-               struct btrfs_mapping_tree *map_tree;
+               struct btrfs_fs_info *fs_info;
                if (PageDirty(page)) {
                        /*
                         * we need to write the data to the defect sector. the
@@ -544,8 +544,8 @@ static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *ctx)
                        ret = -EIO;
                        goto out;
                }
-               map_tree = &BTRFS_I(inode)->root->fs_info->mapping_tree;
-               ret = repair_io_failure(map_tree, offset, PAGE_SIZE,
+               fs_info = BTRFS_I(inode)->root->fs_info;
+               ret = repair_io_failure(fs_info, offset, PAGE_SIZE,
                                        fixup->logical, page,
                                        fixup->mirror_num);
                unlock_page(page);
@@ -754,7 +754,7 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
        }
 
        /* setup the context, map the logical blocks and alloc the pages */
-       ret = scrub_setup_recheck_block(sctx, &fs_info->mapping_tree, length,
+       ret = scrub_setup_recheck_block(sctx, fs_info, length,
                                        logical, sblocks_for_recheck);
        if (ret) {
                spin_lock(&sctx->stat_lock);
@@ -1012,7 +1012,7 @@ out:
 }
 
 static int scrub_setup_recheck_block(struct scrub_ctx *sctx,
-                                    struct btrfs_mapping_tree *map_tree,
+                                    struct btrfs_fs_info *fs_info,
                                     u64 length, u64 logical,
                                     struct scrub_block *sblocks_for_recheck)
 {
@@ -1036,7 +1036,7 @@ static int scrub_setup_recheck_block(struct scrub_ctx *sctx,
                 * with a length of PAGE_SIZE, each returned stripe
                 * represents one mirror
                 */
-               ret = btrfs_map_block(map_tree, WRITE, logical, &mapped_length,
+               ret = btrfs_map_block(fs_info, WRITE, logical, &mapped_length,
                                      &bbio, 0);
                if (ret || !bbio || mapped_length < sublen) {
                        kfree(bbio);

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 5612767b910e5bf6f1013d76e9c28d0bd5d73772..96bb2e4446aaf4dc493ddf5c6eea925f8a3c24b7 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -3826,13 +3826,14 @@ static int find_live_mirror(struct map_lookup *map, int first, int num,
        return optimal;
 }
 
-static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
+static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                             u64 logical, u64 *length,
                             struct btrfs_bio **bbio_ret,
                             int mirror_num)
 {
        struct extent_map *em;
        struct map_lookup *map;
+       struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
        struct extent_map_tree *em_tree = &map_tree->map_tree;
        u64 offset;
        u64 stripe_offset;
@@ -4061,11 +4062,11 @@ out:
        return ret;
 }
 
-int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
+int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                      u64 logical, u64 *length,
                      struct btrfs_bio **bbio_ret, int mirror_num)
 {
-       return __btrfs_map_block(map_tree, rw, logical, length, bbio_ret,
+       return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
                                 mirror_num);
 }
 
@@ -4394,7 +4395,6 @@ static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
 int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
                  int mirror_num, int async_submit)
 {
-       struct btrfs_mapping_tree *map_tree;
        struct btrfs_device *dev;
        struct bio *first_bio = bio;
        u64 logical = (u64)bio->bi_sector << 9;
@@ -4406,10 +4406,9 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
        struct btrfs_bio *bbio = NULL;
 
        length = bio->bi_size;
-       map_tree = &root->fs_info->mapping_tree;
        map_length = length;
 
-       ret = btrfs_map_block(map_tree, rw, logical, &map_length, &bbio,
+       ret = btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
                              mirror_num);
        if (ret) /* -ENOMEM */
                return ret;

diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 35ea4424963b6d8ca5e77e975570410eb3e0aeda..ad5566d4f2c867796f2d26aa0e101c940d520172 100644 (file)
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -248,7 +248,7 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
                           struct btrfs_device *device,
                           u64 chunk_tree, u64 chunk_objectid,
                           u64 chunk_offset, u64 start, u64 num_bytes);
-int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
+int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                    u64 logical, u64 *length,
                    struct btrfs_bio **bbio_ret, int mirror_num);
 int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,