struct page *page, size_t pg_offset, u64 start, u64 len,
                int create)
 {
-       struct btrfs_fs_info *fs_info = inode->root->fs_info;
        struct extent_map_tree *em_tree = &inode->extent_tree;
        struct extent_map *em;
        int ret;
        read_lock(&em_tree->lock);
        em = lookup_extent_mapping(em_tree, start, len);
        if (em) {
-               em->bdev = fs_info->fs_devices->latest_bdev;
                read_unlock(&em_tree->lock);
                goto out;
        }
        em->len = (u64)-1;
        em->block_len = (u64)-1;
        em->block_start = 0;
-       em->bdev = fs_info->fs_devices->latest_bdev;
 
        write_lock(&em_tree->lock);
        ret = add_extent_mapping(em_tree, em, 0);
 
                        offset = em->block_start + extent_offset;
                        disk_io_size = iosize;
                }
-               bdev = em->bdev;
                block_start = em->block_start;
                if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
                        block_start = EXTENT_MAP_HOLE;
                iosize = min(em_end - cur, end - cur + 1);
                iosize = ALIGN(iosize, blocksize);
                offset = em->block_start + extent_offset;
-               bdev = em->bdev;
                block_start = em->block_start;
                compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                free_extent_map(em);
 
                ASSERT(test_bit(EXTENT_FLAG_FS_MAPPING, &prev->flags) &&
                       test_bit(EXTENT_FLAG_FS_MAPPING, &next->flags));
 
-       if (prev->bdev || next->bdev)
-               ASSERT(prev->bdev == next->bdev);
-
        if (extent_map_end(prev) == next->start &&
            prev->flags == next->flags &&
            prev->map_lookup == next->map_lookup &&
 
        u64 block_len;
        u64 generation;
        unsigned long flags;
-       struct {
-               struct block_device *bdev;
-
-               /*
-                * used for chunk mappings
-                * flags & EXTENT_FLAG_FS_MAPPING must be set
-                */
-               struct map_lookup *map_lookup;
-       };
+       /* Used for chunk mappings, flag EXTENT_FLAG_FS_MAPPING must be set */
+       struct map_lookup *map_lookup;
        refcount_t refs;
        unsigned int compress_type;
        struct list_head list;
 
        u8 type = btrfs_file_extent_type(leaf, fi);
        int compress_type = btrfs_file_extent_compression(leaf, fi);
 
-       em->bdev = fs_info->fs_devices->latest_bdev;
        btrfs_item_key_to_cpu(leaf, &key, slot);
        extent_start = key.offset;
 
 
                        }
 
                        split->generation = gen;
-                       split->bdev = em->bdev;
                        split->flags = flags;
                        split->compress_type = em->compress_type;
                        replace_extent_mapping(em_tree, em, split, modified);
 
                        split->start = start + len;
                        split->len = em->start + em->len - (start + len);
-                       split->bdev = em->bdev;
                        split->flags = flags;
                        split->compress_type = em->compress_type;
                        split->generation = gen;
                hole_em->block_start = EXTENT_MAP_HOLE;
                hole_em->block_len = 0;
                hole_em->orig_block_len = 0;
-               hole_em->bdev = fs_info->fs_devices->latest_bdev;
                hole_em->compress_type = BTRFS_COMPRESS_NONE;
                hole_em->generation = trans->transid;
 
 
                        hole_em->block_len = 0;
                        hole_em->orig_block_len = 0;
                        hole_em->ram_bytes = hole_size;
-                       hole_em->bdev = fs_info->fs_devices->latest_bdev;
                        hole_em->compress_type = BTRFS_COMPRESS_NONE;
                        hole_em->generation = fs_info->generation;
 
 
        read_lock(&em_tree->lock);
        em = lookup_extent_mapping(em_tree, start, len);
-       if (em)
-               em->bdev = fs_info->fs_devices->latest_bdev;
        read_unlock(&em_tree->lock);
 
        if (em) {
                err = -ENOMEM;
                goto out;
        }
-       em->bdev = fs_info->fs_devices->latest_bdev;
        em->start = EXTENT_MAP_HOLE;
        em->orig_start = EXTENT_MAP_HOLE;
        em->len = (u64)-1;
                        err = -ENOMEM;
                        goto out;
                }
-               em->bdev = NULL;
 
                ASSERT(hole_em);
                /*
 {
        struct extent_map_tree *em_tree;
        struct extent_map *em;
-       struct btrfs_root *root = BTRFS_I(inode)->root;
        int ret;
 
        ASSERT(type == BTRFS_ORDERED_PREALLOC ||
        em->len = len;
        em->block_len = block_len;
        em->block_start = block_start;
-       em->bdev = root->fs_info->fs_devices->latest_bdev;
        em->orig_block_len = orig_block_len;
        em->ram_bytes = ram_bytes;
        em->generation = -1;
                em->block_len = ins.offset;
                em->orig_block_len = ins.offset;
                em->ram_bytes = ins.offset;
-               em->bdev = fs_info->fs_devices->latest_bdev;
                set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
                em->generation = trans->transid;
 
 
 int setup_extent_mapping(struct inode *inode, u64 start, u64 end,
                         u64 block_start)
 {
-       struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
        struct extent_map *em;
        int ret = 0;
        em->len = end + 1 - start;
        em->block_len = em->len;
        em->block_start = block_start;
-       em->bdev = fs_info->fs_devices->latest_bdev;
        set_bit(EXTENT_FLAG_PINNED, &em->flags);
 
        lock_extent(&BTRFS_I(inode)->io_tree, start, end);