Unverified Commit 86ec15d0 authored by Jan Kara's avatar Jan Kara Committed by Christian Brauner
Browse files

btrfs: Convert to bdev_open_by_path() 



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: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarChristian Brauner <brauner@kernel.org>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
Link: https://lore.kernel.org/r/20230927093442.25915-20-jack@suse.cz


Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent f4a48bc3

fs/btrfs/dev-replace.c

+8 −6
Original line number Diff line number Diff line
@@ -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_device *device;

	struct bdev_handle *bdev_handle;

	struct block_device *bdev;

	u64 devid = BTRFS_DEV_REPLACE_DEVID;

	int ret = 0;
@@ -257,12 +258,13 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, 
		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);

	if (IS_ERR(bdev)) {

	if (IS_ERR(bdev_handle)) {

		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)) {

		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->fs_info = fs_info;

	device->bdev = bdev;

	device->bdev_handle = bdev_handle;

	set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);

	set_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);

	device->holder = fs_info->bdev_holder;

	device->dev_stats_valid = 1;

	set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);

	device->fs_devices = fs_devices;
@@ -334,7 +336,7 @@ static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info, 
	return 0;



error:

	blkdev_put(bdev, fs_info->bdev_holder);

	bdev_release(bdev_handle);

	return ret;

}

fs/btrfs/ioctl.c

+8 −10
Original line number Diff line number Diff line
@@ -2676,8 +2676,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) 
	struct inode *inode = file_inode(file);

	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);

	struct btrfs_ioctl_vol_args_v2 *vol_args;

	struct block_device *bdev = NULL;

	void *holder;

	struct bdev_handle *bdev_handle = NULL;

	int ret;

	bool cancel = false;
@@ -2714,7 +2713,7 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) 
		goto err_drop;



	/* 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);
@@ -2728,8 +2727,8 @@ static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) 
	}

err_drop:

	mnt_drop_write_file(file);

	if (bdev)

		blkdev_put(bdev, holder);

	if (bdev_handle)

		bdev_release(bdev_handle);

out:

	btrfs_put_dev_args_from_path(&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 btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);

	struct btrfs_ioctl_vol_args *vol_args;

	struct block_device *bdev = NULL;

	void *holder;

	struct bdev_handle *bdev_handle = NULL;

	int ret;

	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,

					   cancel);

	if (ret == 0) {

		ret = btrfs_rm_device(fs_info, &args, &bdev, &holder);

		ret = btrfs_rm_device(fs_info, &args, &bdev_handle);

		if (!ret)

			btrfs_info(fs_info, "disk deleted %s", vol_args->name);

		btrfs_exclop_finish(fs_info);

	}



	mnt_drop_write_file(file);

	if (bdev)

		blkdev_put(bdev, holder);

	if (bdev_handle)

		bdev_release(bdev_handle);

out:

	btrfs_put_dev_args_from_path(&args);

	kfree(vol_args);

fs/btrfs/volumes.c

+55 −52
Original line number Diff line number Diff line
@@ -511,37 +511,39 @@ static struct btrfs_fs_devices *find_fsid_with_metadata_uuid( 


static int

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 block_device *bdev;

	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)) {

		ret = PTR_ERR(*bdev);

	if (IS_ERR(*bdev_handle)) {

		ret = PTR_ERR(*bdev_handle);

		goto error;

	}

	bdev = (*bdev_handle)->bdev;



	if (flush)

		sync_blockdev(*bdev);

	ret = set_blocksize(*bdev, BTRFS_BDEV_BLOCKSIZE);

		sync_blockdev(bdev);

	ret = set_blocksize(bdev, BTRFS_BDEV_BLOCKSIZE);

	if (ret) {

		blkdev_put(*bdev, holder);

		bdev_release(*bdev_handle);

		goto error;

	}

	invalidate_bdev(*bdev);

	*disk_super = btrfs_read_dev_super(*bdev);

	invalidate_bdev(bdev);

	*disk_super = btrfs_read_dev_super(bdev);

	if (IS_ERR(*disk_super)) {

		ret = PTR_ERR(*disk_super);

		blkdev_put(*bdev, holder);

		bdev_release(*bdev_handle);

		goto error;

	}



	return 0;



error:

	*bdev = NULL;

	*bdev_handle = NULL;

	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,

			void *holder)

{

	struct block_device *bdev;

	struct bdev_handle *bdev_handle;

	struct btrfs_super_block *disk_super;

	u64 devid;

	int ret;
@@ -624,7 +626,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices, 
		return -EINVAL;



	ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,

				    &bdev, &disk_super);

				    &bdev_handle, &disk_super);

	if (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);

		fs_devices->seeding = true;

	} else {

		if (bdev_read_only(bdev))

		if (bdev_read_only(bdev_handle->bdev))

			clear_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);

		else

			set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);

	}



	if (!bdev_nonrot(bdev))

	if (!bdev_nonrot(bdev_handle->bdev))

		fs_devices->rotating = true;



	if (bdev_max_discard_sectors(bdev))

	if (bdev_max_discard_sectors(bdev_handle->bdev))

		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);

	device->holder = holder;



	fs_devices->open_devices++;

	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:

	btrfs_release_disk_super(disk_super);

	blkdev_put(bdev, holder);

	bdev_release(bdev_handle);



	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)

			continue;



		if (device->bdev) {

			blkdev_put(device->bdev, device->holder);

		if (device->bdev_handle) {

			bdev_release(device->bdev_handle);

			device->bdev = NULL;

			device->bdev_handle = NULL;

			fs_devices->open_devices--;

		}

		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);

	}



	blkdev_put(device->bdev, device->holder);

	bdev_release(device->bdev_handle);

}



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;

	bool new_device_added = false;

	struct btrfs_device *device = NULL;

	struct block_device *bdev;

	struct bdev_handle *bdev_handle;

	u64 bytenr, bytenr_orig;

	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

	 * required information for assembling the volume.

	 */

	bdev = blkdev_get_by_path(path, flags, NULL, NULL);

	if (IS_ERR(bdev))

		return ERR_CAST(bdev);

	bdev_handle = bdev_open_by_path(path, flags, NULL, NULL);

	if (IS_ERR(bdev_handle))

		return ERR_CAST(bdev_handle);



	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) {

		device = ERR_PTR(ret);

		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)) {

		device = ERR_CAST(disk_super);

		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);



error_bdev_put:

	blkdev_put(bdev, NULL);

	bdev_release(bdev_handle);



	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,

		    struct btrfs_dev_lookup_args *args,

		    struct block_device **bdev, void **holder)

		    struct bdev_handle **bdev_handle)

{

	struct btrfs_trans_handle *trans;

	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);



	if (device->bdev) {

	if (device->bdev_handle) {

		cur_devices->open_devices--;

		/* remove sysfs entry */

		btrfs_sysfs_remove_device(device);
@@ -2212,9 +2216,9 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info, 
	 * free the device.

	 *

	 * 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

	 * block device and it's dependencies.  Instead just flush the device

	 * and let the caller do the final blkdev_put.

	 * write lock, and bdev_release() will pull in the ->open_mutex on

	 * the block device and it's dependencies.  Instead just flush the

	 * device and let the caller do the final bdev_release.

	 */

	if (test_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state)) {

		btrfs_scratch_superblocks(fs_info, device->bdev,
@@ -2225,8 +2229,7 @@ int btrfs_rm_device(struct btrfs_fs_info *fs_info, 
		}

	}



	*bdev = device->bdev;

	*holder = device->holder;

	*bdev_handle = device->bdev_handle;

	synchronize_rcu();

	btrfs_free_device(device);
@@ -2363,7 +2366,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, 
				 const char *path)

{

	struct btrfs_super_block *disk_super;

	struct block_device *bdev;

	struct bdev_handle *bdev_handle;

	int ret;



	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,

				    &bdev, &disk_super);

				    &bdev_handle, &disk_super);

	if (ret) {

		btrfs_put_dev_args_from_path(args);

		return ret;
@@ -2394,7 +2397,7 @@ int btrfs_get_dev_args_from_path(struct btrfs_fs_info *fs_info, 
	else

		memcpy(args->fsid, disk_super->fsid, BTRFS_FSID_SIZE);

	btrfs_release_disk_super(disk_super);

	blkdev_put(bdev, NULL);

	bdev_release(bdev_handle);

	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_trans_handle *trans;

	struct btrfs_device *device;

	struct block_device *bdev;

	struct bdev_handle *bdev_handle;

	struct super_block *sb = fs_info->sb;

	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;

	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)

		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);

	if (IS_ERR(bdev))

		return PTR_ERR(bdev);

	if (IS_ERR(bdev_handle))

		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;

		goto error;

	}
@@ -2644,11 +2647,11 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path 
		locked = true;

	}



	sync_blockdev(bdev);

	sync_blockdev(bdev_handle->bdev);



	rcu_read_lock();

	list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {

		if (device->bdev == bdev) {

		if (device->bdev == bdev_handle->bdev) {

			ret = -EEXIST;

			rcu_read_unlock();

			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->bdev = bdev;

	device->bdev_handle = bdev_handle;

	device->bdev = bdev_handle->bdev;

	ret = lookup_bdev(device_path, &device->devt);

	if (ret)

		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->sector_size = fs_info->sectorsize;

	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->commit_total_bytes = device->total_bytes;

	set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);

	clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);

	device->holder = fs_info->bdev_holder;

	device->dev_stats_valid = 1;

	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);



	if (!bdev_nonrot(bdev))

	if (!bdev_nonrot(device->bdev))

		fs_devices->rotating = true;



	orig_super_total_bytes = btrfs_super_total_bytes(fs_info->super_copy);
@@ -2848,7 +2851,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path 
error_free_device:

	btrfs_free_device(device);

error:

	blkdev_put(bdev, fs_info->bdev_holder);

	bdev_release(bdev_handle);

	if (locked) {

		mutex_unlock(&uuid_mutex);

		up_write(&sb->s_umount);

fs/btrfs/volumes.h

+2 −4
Original line number Diff line number Diff line
@@ -90,13 +90,11 @@ struct btrfs_device { 


	u64 generation;



	struct bdev_handle *bdev_handle;

	struct block_device *bdev;



	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

	 * 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);

int btrfs_rm_device(struct btrfs_fs_info *fs_info,

		    struct btrfs_dev_lookup_args *args,

		    struct block_device **bdev, void **holder);

		    struct bdev_handle **bdev_handle);

void __exit btrfs_cleanup_fs_uuids(void);

int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);

int btrfs_grow_device(struct btrfs_trans_handle *trans,