struct bio *bio = NULL;
        struct compressed_bio *cb;
        unsigned long bytes_left;
-       struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
        int pg_index = 0;
        struct page *page;
        u64 first_byte = disk_start;
                page = compressed_pages[pg_index];
                page->mapping = inode->i_mapping;
                if (bio->bi_iter.bi_size)
-                       submit = io_tree->ops->merge_bio_hook(page, 0,
-                                                          PAGE_SIZE,
-                                                          bio, 0);
+                       submit = btrfs_merge_bio_hook(page, 0, PAGE_SIZE, bio, 0);
 
                page->mapping = NULL;
                if (submit || bio_add_page(bio, page, PAGE_SIZE, 0) <
                page->index = em_start >> PAGE_SHIFT;
 
                if (comp_bio->bi_iter.bi_size)
-                       submit = tree->ops->merge_bio_hook(page, 0,
-                                                       PAGE_SIZE,
-                                                       comp_bio, 0);
+                       submit = btrfs_merge_bio_hook(page, 0, PAGE_SIZE,
+                                       comp_bio, 0);
 
                page->mapping = NULL;
                if (submit || bio_add_page(comp_bio, page, PAGE_SIZE, 0) <
 
        /* mandatory callbacks */
        .submit_bio_hook = btree_submit_bio_hook,
        .readpage_end_io_hook = btree_readpage_end_io_hook,
-       /* note we're sharing with inode.c for the merge bio hook */
-       .merge_bio_hook = btrfs_merge_bio_hook,
        .readpage_io_failed_hook = btree_io_failed_hook,
        .set_range_writeback = btrfs_set_range_writeback,
 
 
                else
                        contig = bio_end_sector(bio) == sector;
 
-               if (tree->ops && tree->ops->merge_bio_hook(page, offset,
-                                       page_size, bio, bio_flags))
+               if (tree->ops && btrfs_merge_bio_hook(page, offset, page_size,
+                                                     bio, bio_flags))
                        can_merge = false;
 
                if (prev_bio_flags != bio_flags || !contig || !can_merge ||
 
        int (*readpage_end_io_hook)(struct btrfs_io_bio *io_bio, u64 phy_offset,
                                    struct page *page, u64 start, u64 end,
                                    int mirror);
-       int (*merge_bio_hook)(struct page *page, unsigned long offset,
-                             size_t size, struct bio *bio,
-                             unsigned long bio_flags);
        int (*readpage_io_failed_hook)(struct page *page, int failed_mirror);
        void (*set_range_writeback)(void *private_data, u64 start, u64 end);
 
 
 }
 
 /*
- * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
- * we don't create bios that span stripes or chunks
+ * Merge bio hook, this must check the chunk tree to make sure we don't create
+ * bios that span stripes or chunks
  *
  * return 1 if page cannot be merged to bio
  * return 0 if page can be merged to bio
        /* mandatory callbacks */
        .submit_bio_hook = btrfs_submit_bio_hook,
        .readpage_end_io_hook = btrfs_readpage_end_io_hook,
-       .merge_bio_hook = btrfs_merge_bio_hook,
        .readpage_io_failed_hook = btrfs_readpage_io_failed_hook,
        .set_range_writeback = btrfs_set_range_writeback,