iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

btrfs: Convert to bdev_open_by_path()

Browse Source 
Convert btrfs to use bdev_open_by_path() and pass the handle around.  We
also drop the holder from struct btrfs_device as it is now not needed
anymore.

CC: David Sterba <dsterba@suse.com>
CC: linux-btrfs@vger.kernel.org
Acked-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Christian Brauner <brauner@kernel.org>
Signed-off-by: Jan Kara <jack@suse.cz>
Link: https://lore.kernel.org/r/20230927093442.25915-20-jack@suse.cz
Signed-off-by: Christian Brauner <brauner@kernel.org>
This commit is contained in:
Jan Kara 2023-09-27 11:34:26 +02:00 committed by Christian Brauner
parent f4a48bc36c
commit 86ec15d00b
No known key found for this signature in database
GPG Key ID: 91C61BC06578DCA2
4 changed files with 73 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
fs/btrfs/dev-replace.c
View File

@ -247,6 +247,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
{ {
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
struct btrfs_device *device; struct btrfs_device *device;
struct bdev_handle *bdev_handle;
struct block_device *bdev; struct block_device *bdev;
u64 devid = BTRFS_DEV_REPLACE_DEVID; u64 devid = BTRFS_DEV_REPLACE_DEVID;
int ret = 0; int ret = 0;
@ -257,12 +258,13 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
return -EINVAL; return -EINVAL;
} }
bdev = blkdev_get_by_path(device_path, BLK_OPEN_WRITE, bdev_handle = bdev_open_by_path(device_path, BLK_OPEN_WRITE,
fs_info->bdev_holder, NULL); fs_info->bdev_holder, NULL);
if (IS_ERR(bdev)) { if (IS_ERR(bdev_handle)) {
btrfs_err(fs_info, "target device %s is invalid!", device_path); btrfs_err(fs_info, "target device %s is invalid!", device_path);
return PTR_ERR(bdev); return PTR_ERR(bdev_handle);
} }
bdev = bdev_handle->bdev;
if (!btrfs_check_device_zone_type(fs_info, bdev)) { if (!btrfs_check_device_zone_type(fs_info, bdev)) {
btrfs_err(fs_info, btrfs_err(fs_info,
@ -313,9 +315,9 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
device->commit_bytes_used = device->bytes_used; device->commit_bytes_used = device->bytes_used;
device->fs_info = fs_info; device->fs_info = fs_info;
device->bdev = bdev; device->bdev = bdev;
device->bdev_handle = bdev_handle;
set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
set_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); set_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
device->holder = fs_info->bdev_holder;
device->dev_stats_valid = 1; device->dev_stats_valid = 1;
set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
device->fs_devices = fs_devices; device->fs_devices = fs_devices;
@ -334,7 +336,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
return 0; return 0;
error: error:
blkdev_put(bdev, fs_info->bdev_holder); bdev_release(bdev_handle);
return ret; return ret;
} }

18
fs/btrfs/ioctl.c
View File

@ -2676,8 +2676,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
struct btrfs_ioctl_vol_args_v2 *vol_args; struct btrfs_ioctl_vol_args_v2 *vol_args;
struct block_device *bdev = NULL; struct bdev_handle *bdev_handle = NULL;
void *holder;
int ret; int ret;
bool cancel = false; bool cancel = false;
@ -2714,7 +2713,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)
goto err_drop; goto err_drop;
/* Exclusive operation is now claimed */ /* Exclusive operation is now claimed */
ret = btrfs_rm_device(fs_info, &args, &bdev, &holder); ret = btrfs_rm_device(fs_info, &args, &bdev_handle);
btrfs_exclop_finish(fs_info); btrfs_exclop_finish(fs_info);
@ -2728,8 +2727,8 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg)
} }
err_drop: err_drop:
mnt_drop_write_file(file); mnt_drop_write_file(file);
if (bdev) if (bdev_handle)
blkdev_put(bdev, holder); bdev_release(bdev_handle);
out: out:
btrfs_put_dev_args_from_path(&args); btrfs_put_dev_args_from_path(&args);
kfree(vol_args); kfree(vol_args);
@ -2742,8 +2741,7 @@ static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
struct btrfs_ioctl_vol_args *vol_args; struct btrfs_ioctl_vol_args *vol_args;
struct block_device *bdev = NULL; struct bdev_handle *bdev_handle = NULL;
void *holder;
int ret; int ret;
bool cancel = false; bool cancel = false;
@ -2770,15 +2768,15 @@ static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE, ret = exclop_start_or_cancel_reloc(fs_info, BTRFS_EXCLOP_DEV_REMOVE,
cancel); cancel);
if (ret == 0) { if (ret == 0) {
ret = btrfs_rm_device(fs_info, &args, &bdev, &holder); ret = btrfs_rm_device(fs_info, &args, &bdev_handle);
if (!ret) if (!ret)
btrfs_info(fs_info, "disk deleted %s", vol_args->name); btrfs_info(fs_info, "disk deleted %s", vol_args->name);
btrfs_exclop_finish(fs_info); btrfs_exclop_finish(fs_info);
} }
mnt_drop_write_file(file); mnt_drop_write_file(file);
if (bdev) if (bdev_handle)
blkdev_put(bdev, holder); bdev_release(bdev_handle);
out: out:
btrfs_put_dev_args_from_path(&args); btrfs_put_dev_args_from_path(&args);
kfree(vol_args); kfree(vol_args);

107
fs/btrfs/volumes.c
View File

@ -511,37 +511,39 @@ static struct btrfs_fs_devices *find_fsid_with_metadata_uuid(
static int static int
btrfs_get_bdev_and_sb(const char *device_path, blk_mode_t flags, void *holder, btrfs_get_bdev_and_sb(const char *device_path, blk_mode_t flags, void *holder,
int flush, struct block_device **bdev, int flush, struct bdev_handle **bdev_handle,
struct btrfs_super_block **disk_super) struct btrfs_super_block **disk_super)
{ {
struct block_device *bdev;
int ret; int ret;
*bdev = blkdev_get_by_path(device_path, flags, holder, NULL); *bdev_handle = bdev_open_by_path(device_path, flags, holder, NULL);
if (IS_ERR(*bdev)) { if (IS_ERR(*bdev_handle)) {
ret = PTR_ERR(*bdev); ret = PTR_ERR(*bdev_handle);
goto error; goto error;
} }
bdev = (*bdev_handle)->bdev;
if (flush) if (flush)
sync_blockdev(*bdev); sync_blockdev(bdev);
ret = set_blocksize(*bdev, BTRFS_BDEV_BLOCKSIZE); ret = set_blocksize(bdev, BTRFS_BDEV_BLOCKSIZE);
if (ret) { if (ret) {
blkdev_put(*bdev, holder); bdev_release(*bdev_handle);
goto error; goto error;
} }
invalidate_bdev(*bdev); invalidate_bdev(bdev);
*disk_super = btrfs_read_dev_super(*bdev); *disk_super = btrfs_read_dev_super(bdev);
if (IS_ERR(*disk_super)) { if (IS_ERR(*disk_super)) {
ret = PTR_ERR(*disk_super); ret = PTR_ERR(*disk_super);
blkdev_put(*bdev, holder); bdev_release(*bdev_handle);
goto error; goto error;
} }
return 0; return 0;
error: error:
*bdev = NULL; *bdev_handle = NULL;
return ret; return ret;
} }
@ -613,7 +615,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
struct btrfs_device *device, blk_mode_t flags, struct btrfs_device *device, blk_mode_t flags,
void *holder) void *holder)
{ {
struct block_device *bdev; struct bdev_handle *bdev_handle;
struct btrfs_super_block *disk_super; struct btrfs_super_block *disk_super;
u64 devid; u64 devid;
int ret; int ret;
@ -624,7 +626,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
return -EINVAL; return -EINVAL;
ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1, ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
&bdev, &disk_super); &bdev_handle, &disk_super);
if (ret) if (ret)
return ret; return ret;
@ -648,21 +650,21 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);
fs_devices->seeding = true; fs_devices->seeding = true;
} else { } else {
if (bdev_read_only(bdev)) if (bdev_read_only(bdev_handle->bdev))
clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);
else else
set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state); set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);
} }
if (!bdev_nonrot(bdev)) if (!bdev_nonrot(bdev_handle->bdev))
fs_devices->rotating = true; fs_devices->rotating = true;
if (bdev_max_discard_sectors(bdev)) if (bdev_max_discard_sectors(bdev_handle->bdev))
fs_devices->discardable = true; fs_devices->discardable = true;
device->bdev = bdev; device->bdev_handle = bdev_handle;
device->bdev = bdev_handle->bdev;
clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); clear_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
device->holder = holder;
fs_devices->open_devices++; fs_devices->open_devices++;
if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) && if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state) &&
@ -676,7 +678,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,
error_free_page: error_free_page:
btrfs_release_disk_super(disk_super); btrfs_release_disk_super(disk_super);
blkdev_put(bdev, holder); bdev_release(bdev_handle);
return -EINVAL; return -EINVAL;
} }
@ -1068,9 +1070,10 @@ static void __btrfs_free_extra_devids(struct btrfs_fs_devices *fs_devices,
if (device->devid == BTRFS_DEV_REPLACE_DEVID) if (device->devid == BTRFS_DEV_REPLACE_DEVID)
continue; continue;
if (device->bdev) { if (device->bdev_handle) {
blkdev_put(device->bdev, device->holder); bdev_release(device->bdev_handle);
device->bdev = NULL; device->bdev = NULL;
device->bdev_handle = NULL;
fs_devices->open_devices--; fs_devices->open_devices--;
} }
if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) {
@ -1115,7 +1118,7 @@ static void btrfs_close_bdev(struct btrfs_device *device)
invalidate_bdev(device->bdev); invalidate_bdev(device->bdev);
} }
blkdev_put(device->bdev, device->holder); bdev_release(device->bdev_handle);
} }
static void btrfs_close_one_device(struct btrfs_device *device) static void btrfs_close_one_device(struct btrfs_device *device)
@ -1363,7 +1366,7 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags)
struct btrfs_super_block *disk_super; struct btrfs_super_block *disk_super;
bool new_device_added = false; bool new_device_added = false;
struct btrfs_device *device = NULL; struct btrfs_device *device = NULL;
struct block_device *bdev; struct bdev_handle *bdev_handle;
u64 bytenr, bytenr_orig; u64 bytenr, bytenr_orig;
int ret; int ret;
@ -1386,18 +1389,19 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags)
* values temporarily, as the device paths of the fsid are the only * values temporarily, as the device paths of the fsid are the only
* required information for assembling the volume. * required information for assembling the volume.
*/ */
bdev = blkdev_get_by_path(path, flags, NULL, NULL); bdev_handle = bdev_open_by_path(path, flags, NULL, NULL);
if (IS_ERR(bdev)) if (IS_ERR(bdev_handle))
return ERR_CAST(bdev); return ERR_CAST(bdev_handle);
bytenr_orig = btrfs_sb_offset(0); bytenr_orig = btrfs_sb_offset(0);
ret = btrfs_sb_log_location_bdev(bdev, 0, READ, &bytenr); ret = btrfs_sb_log_location_bdev(bdev_handle->bdev, 0, READ, &bytenr);
if (ret) { if (ret) {
device = ERR_PTR(ret); device = ERR_PTR(ret);
goto error_bdev_put; goto error_bdev_put;
} }
disk_super = btrfs_read_disk_super(bdev, bytenr, bytenr_orig); disk_super = btrfs_read_disk_super(bdev_handle->bdev, bytenr,
bytenr_orig);
if (IS_ERR(disk_super)) { if (IS_ERR(disk_super)) {
device = ERR_CAST(disk_super); device = ERR_CAST(disk_super);
goto error_bdev_put; goto error_bdev_put;
@ -1410,7 +1414,7 @@ struct btrfs_device *btrfs_scan_one_device(const char *path, blk_mode_t flags)
btrfs_release_disk_super(disk_super); btrfs_release_disk_super(disk_super);
error_bdev_put: error_bdev_put:
blkdev_put(bdev, NULL); bdev_release(bdev_handle);
return device; return device;
} }
@ -2087,7 +2091,7 @@ void btrfs_scratch_superblocks(struct btrfs_fs_info *fs_info,
int btrfs_rm_device(struct btrfs_fs_info *fs_info, int btrfs_rm_device(struct btrfs_fs_info *fs_info,
struct btrfs_dev_lookup_args *args, struct btrfs_dev_lookup_args *args,
struct block_device **bdev, void **holder) struct bdev_handle **bdev_handle)
{ {
struct btrfs_trans_handle *trans; struct btrfs_trans_handle *trans;
struct btrfs_device *device; struct btrfs_device *device;
@ -2196,7 +2200,7 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info,
btrfs_assign_next_active_device(device, NULL); btrfs_assign_next_active_device(device, NULL);
if (device->bdev) { if (device->bdev_handle) {
cur_devices->open_devices--; cur_devices->open_devices--;
/* remove sysfs entry */ /* remove sysfs entry */
btrfs_sysfs_remove_device(device); btrfs_sysfs_remove_device(device);
@ -2212,9 +2216,9 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info,
* free the device. * free the device.
* *
* We cannot call btrfs_close_bdev() here because we're holding the sb * We cannot call btrfs_close_bdev() here because we're holding the sb
* write lock, and blkdev_put() will pull in the ->open_mutex on the * write lock, and bdev_release() will pull in the ->open_mutex on
* block device and it's dependencies. Instead just flush the device * the block device and it's dependencies. Instead just flush the
* and let the caller do the final blkdev_put. * device and let the caller do the final bdev_release.
*/ */
if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) { if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) {
btrfs_scratch_superblocks(fs_info, device->bdev, btrfs_scratch_superblocks(fs_info, device->bdev,
@ -2225,8 +2229,7 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info,
} }
} }
*bdev = device->bdev; *bdev_handle = device->bdev_handle;
*holder = device->holder;
synchronize_rcu(); synchronize_rcu();
btrfs_free_device(device); btrfs_free_device(device);
@ -2363,7 +2366,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,
const char *path) const char *path)
{ {
struct btrfs_super_block *disk_super; struct btrfs_super_block *disk_super;
struct block_device *bdev; struct bdev_handle *bdev_handle;
int ret; int ret;
if (!path || !path[0]) if (!path || !path[0])
@ -2381,7 +2384,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,
} }
ret = btrfs_get_bdev_and_sb(path, BLK_OPEN_READ, NULL, 0, ret = btrfs_get_bdev_and_sb(path, BLK_OPEN_READ, NULL, 0,
&bdev, &disk_super); &bdev_handle, &disk_super);
if (ret) { if (ret) {
btrfs_put_dev_args_from_path(args); btrfs_put_dev_args_from_path(args);
return ret; return ret;
@ -2394,7 +2397,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info,
else else
memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE); memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE);
btrfs_release_disk_super(disk_super); btrfs_release_disk_super(disk_super);
blkdev_put(bdev, NULL); bdev_release(bdev_handle);
return 0; return 0;
} }
@ -2614,7 +2617,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
struct btrfs_root *root = fs_info->dev_root; struct btrfs_root *root = fs_info->dev_root;
struct btrfs_trans_handle *trans; struct btrfs_trans_handle *trans;
struct btrfs_device *device; struct btrfs_device *device;
struct block_device *bdev; struct bdev_handle *bdev_handle;
struct super_block *sb = fs_info->sb; struct super_block *sb = fs_info->sb;
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices; struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
struct btrfs_fs_devices *seed_devices = NULL; struct btrfs_fs_devices *seed_devices = NULL;
@ -2627,12 +2630,12 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
if (sb_rdonly(sb) && !fs_devices->seeding) if (sb_rdonly(sb) && !fs_devices->seeding)
return -EROFS; return -EROFS;
bdev = blkdev_get_by_path(device_path, BLK_OPEN_WRITE, bdev_handle = bdev_open_by_path(device_path, BLK_OPEN_WRITE,
fs_info->bdev_holder, NULL); fs_info->bdev_holder, NULL);
if (IS_ERR(bdev)) if (IS_ERR(bdev_handle))
return PTR_ERR(bdev); return PTR_ERR(bdev_handle);
if (!btrfs_check_device_zone_type(fs_info, bdev)) { if (!btrfs_check_device_zone_type(fs_info, bdev_handle->bdev)) {
ret = -EINVAL; ret = -EINVAL;
goto error; goto error;
} }
@ -2644,11 +2647,11 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
locked = true; locked = true;
} }
sync_blockdev(bdev); sync_blockdev(bdev_handle->bdev);
rcu_read_lock(); rcu_read_lock();
list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) { list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
if (device->bdev == bdev) { if (device->bdev == bdev_handle->bdev) {
ret = -EEXIST; ret = -EEXIST;
rcu_read_unlock(); rcu_read_unlock();
goto error; goto error;
@ -2664,7 +2667,8 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
} }
device->fs_info = fs_info; device->fs_info = fs_info;
device->bdev = bdev; device->bdev_handle = bdev_handle;
device->bdev = bdev_handle->bdev;
ret = lookup_bdev(device_path, &device->devt); ret = lookup_bdev(device_path, &device->devt);
if (ret) if (ret)
goto error_free_device; goto error_free_device;
@ -2685,12 +2689,11 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
device->io_align = fs_info->sectorsize; device->io_align = fs_info->sectorsize;
device->sector_size = fs_info->sectorsize; device->sector_size = fs_info->sectorsize;
device->total_bytes = device->total_bytes =
round_down(bdev_nr_bytes(bdev), fs_info->sectorsize); round_down(bdev_nr_bytes(device->bdev), fs_info->sectorsize);
device->disk_total_bytes = device->total_bytes; device->disk_total_bytes = device->total_bytes;
device->commit_total_bytes = device->total_bytes; device->commit_total_bytes = device->total_bytes;
set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state); set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state); clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
device->holder = fs_info->bdev_holder;
device->dev_stats_valid = 1; device->dev_stats_valid = 1;
set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE); set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
@ -2726,7 +2729,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
atomic64_add(device->total_bytes, &fs_info->free_chunk_space); atomic64_add(device->total_bytes, &fs_info->free_chunk_space);
if (!bdev_nonrot(bdev)) if (!bdev_nonrot(device->bdev))
fs_devices->rotating = true; fs_devices->rotating = true;
orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy); orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
@ -2848,7 +2851,7 @@ error_free_zone:
error_free_device: error_free_device:
btrfs_free_device(device); btrfs_free_device(device);
error: error:
blkdev_put(bdev, fs_info->bdev_holder); bdev_release(bdev_handle);
if (locked) { if (locked) {
mutex_unlock(&uuid_mutex); mutex_unlock(&uuid_mutex);
up_write(&sb->s_umount); up_write(&sb->s_umount);

6
fs/btrfs/volumes.h
View File

@ -90,13 +90,11 @@ struct btrfs_device {
u64 generation; u64 generation;
struct bdev_handle *bdev_handle;
struct block_device *bdev; struct block_device *bdev;
struct btrfs_zoned_device_info *zone_info; struct btrfs_zoned_device_info *zone_info;
/* block device holder for blkdev_get/put */
void *holder;
/* /*
* Device's major-minor number. Must be set even if the device is not * Device's major-minor number. Must be set even if the device is not
* opened (bdev == NULL), unless the device is missing. * opened (bdev == NULL), unless the device is missing.
@ -629,7 +627,7 @@ struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args); void btrfs_put_dev_args_from_path(struct btrfs_dev_lookup_args *args);
int btrfs_rm_device(struct btrfs_fs_info *fs_info, int btrfs_rm_device(struct btrfs_fs_info *fs_info,
struct btrfs_dev_lookup_args *args, struct btrfs_dev_lookup_args *args,
struct block_device **bdev, void **holder); struct bdev_handle **bdev_handle);
void __exit btrfs_cleanup_fs_uuids(void); void __exit btrfs_cleanup_fs_uuids(void);
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len); int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
int btrfs_grow_device(struct btrfs_trans_handle *trans, int btrfs_grow_device(struct btrfs_trans_handle *trans,