Unverified Commit 05fb1dbc authored by Christian Brauner's avatar Christian Brauner
Browse files

pktcdvd: port block device access to file 

Link: https://lore.kernel.org/r/20240123-vfs-bdev-file-v2-9-adbd023e19cc@kernel.org


Reviewed-by: default avatarJan Kara <jack@suse.cz>
Signed-off-by: default avatarChristian Brauner <brauner@kernel.org>
parent 20e6a8d0

drivers/block/pktcdvd.c

+34 −34
Original line number Diff line number Diff line
@@ -340,8 +340,8 @@ static ssize_t device_map_show(const struct class *c, const struct class_attribu 
		n += sysfs_emit_at(data, n, "%s %u:%u %u:%u\n",

			pd->disk->disk_name,

			MAJOR(pd->pkt_dev), MINOR(pd->pkt_dev),

			MAJOR(pd->bdev_handle->bdev->bd_dev),

			MINOR(pd->bdev_handle->bdev->bd_dev));

			MAJOR(file_bdev(pd->bdev_file)->bd_dev),

			MINOR(file_bdev(pd->bdev_file)->bd_dev));

	}

	mutex_unlock(&ctl_mutex);

	return n;
@@ -438,7 +438,7 @@ static int pkt_seq_show(struct seq_file *m, void *p) 
	int states[PACKET_NUM_STATES];



	seq_printf(m, "Writer %s mapped to %pg:\n", pd->disk->disk_name,

		   pd->bdev_handle->bdev);

		   file_bdev(pd->bdev_file));



	seq_printf(m, "\nSettings:\n");

	seq_printf(m, "\tpacket size:\t\t%dkB\n", pd->settings.size / 2);
@@ -715,7 +715,7 @@ static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *nod 
 */

static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *cgc)

{

	struct request_queue *q = bdev_get_queue(pd->bdev_handle->bdev);

	struct request_queue *q = bdev_get_queue(file_bdev(pd->bdev_file));

	struct scsi_cmnd *scmd;

	struct request *rq;

	int ret = 0;
@@ -1048,7 +1048,7 @@ static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt) 
			continue;



		bio = pkt->r_bios[f];

		bio_init(bio, pd->bdev_handle->bdev, bio->bi_inline_vecs, 1,

		bio_init(bio, file_bdev(pd->bdev_file), bio->bi_inline_vecs, 1,

			 REQ_OP_READ);

		bio->bi_iter.bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);

		bio->bi_end_io = pkt_end_io_read;
@@ -1264,7 +1264,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt) 
	struct device *ddev = disk_to_dev(pd->disk);

	int f;



	bio_init(pkt->w_bio, pd->bdev_handle->bdev, pkt->w_bio->bi_inline_vecs,

	bio_init(pkt->w_bio, file_bdev(pd->bdev_file), pkt->w_bio->bi_inline_vecs,

		 pkt->frames, REQ_OP_WRITE);

	pkt->w_bio->bi_iter.bi_sector = pkt->sector;

	pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
@@ -2162,20 +2162,20 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write) 
	int ret;

	long lba;

	struct request_queue *q;

	struct bdev_handle *bdev_handle;

	struct file *bdev_file;



	/*

	 * We need to re-open the cdrom device without O_NONBLOCK to be able

	 * to read/write from/to it. It is already opened in O_NONBLOCK mode

	 * so open should not fail.

	 */

	bdev_handle = bdev_open_by_dev(pd->bdev_handle->bdev->bd_dev,

	bdev_file = bdev_file_open_by_dev(file_bdev(pd->bdev_file)->bd_dev,

				       BLK_OPEN_READ, pd, NULL);

	if (IS_ERR(bdev_handle)) {

		ret = PTR_ERR(bdev_handle);

	if (IS_ERR(bdev_file)) {

		ret = PTR_ERR(bdev_file);

		goto out;

	}

	pd->open_bdev_handle = bdev_handle;

	pd->f_open_bdev = bdev_file;



	ret = pkt_get_last_written(pd, &lba);

	if (ret) {
@@ -2184,9 +2184,9 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write) 
	}



	set_capacity(pd->disk, lba << 2);

	set_capacity_and_notify(pd->bdev_handle->bdev->bd_disk, lba << 2);

	set_capacity_and_notify(file_bdev(pd->bdev_file)->bd_disk, lba << 2);



	q = bdev_get_queue(pd->bdev_handle->bdev);

	q = bdev_get_queue(file_bdev(pd->bdev_file));

	if (write) {

		ret = pkt_open_write(pd);

		if (ret)
@@ -2218,7 +2218,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, bool write) 
	return 0;



out_putdev:

	bdev_release(bdev_handle);

	fput(bdev_file);

out:

	return ret;

}
@@ -2237,8 +2237,8 @@ static void pkt_release_dev(struct pktcdvd_device *pd, int flush) 
	pkt_lock_door(pd, 0);



	pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);

	bdev_release(pd->open_bdev_handle);

	pd->open_bdev_handle = NULL;

	fput(pd->f_open_bdev);

	pd->f_open_bdev = NULL;



	pkt_shrink_pktlist(pd);

}
@@ -2326,7 +2326,7 @@ static void pkt_end_io_read_cloned(struct bio *bio) 


static void pkt_make_request_read(struct pktcdvd_device *pd, struct bio *bio)

{

	struct bio *cloned_bio = bio_alloc_clone(pd->bdev_handle->bdev, bio,

	struct bio *cloned_bio = bio_alloc_clone(file_bdev(pd->bdev_file), bio,

		GFP_NOIO, &pkt_bio_set);

	struct packet_stacked_data *psd = mempool_alloc(&psd_pool, GFP_NOIO);
@@ -2497,7 +2497,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) 
{

	struct device *ddev = disk_to_dev(pd->disk);

	int i;

	struct bdev_handle *bdev_handle;

	struct file *bdev_file;

	struct scsi_device *sdev;



	if (pd->pkt_dev == dev) {
@@ -2508,9 +2508,9 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) 
		struct pktcdvd_device *pd2 = pkt_devs[i];

		if (!pd2)

			continue;

		if (pd2->bdev_handle->bdev->bd_dev == dev) {

		if (file_bdev(pd2->bdev_file)->bd_dev == dev) {

			dev_err(ddev, "%pg already setup\n",

				pd2->bdev_handle->bdev);

				file_bdev(pd2->bdev_file));

			return -EBUSY;

		}

		if (pd2->pkt_dev == dev) {
@@ -2519,13 +2519,13 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) 
		}

	}



	bdev_handle = bdev_open_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_NDELAY,

	bdev_file = bdev_file_open_by_dev(dev, BLK_OPEN_READ | BLK_OPEN_NDELAY,

				       NULL, NULL);

	if (IS_ERR(bdev_handle))

		return PTR_ERR(bdev_handle);

	sdev = scsi_device_from_queue(bdev_handle->bdev->bd_disk->queue);

	if (IS_ERR(bdev_file))

		return PTR_ERR(bdev_file);

	sdev = scsi_device_from_queue(file_bdev(bdev_file)->bd_disk->queue);

	if (!sdev) {

		bdev_release(bdev_handle);

		fput(bdev_file);

		return -EINVAL;

	}

	put_device(&sdev->sdev_gendev);
@@ -2533,8 +2533,8 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) 
	/* This is safe, since we have a reference from open(). */

	__module_get(THIS_MODULE);



	pd->bdev_handle = bdev_handle;

	set_blocksize(bdev_handle->bdev, CD_FRAMESIZE);

	pd->bdev_file = bdev_file;

	set_blocksize(file_bdev(bdev_file), CD_FRAMESIZE);



	pkt_init_queue(pd);
@@ -2546,11 +2546,11 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev) 
	}



	proc_create_single_data(pd->disk->disk_name, 0, pkt_proc, pkt_seq_show, pd);

	dev_notice(ddev, "writer mapped to %pg\n", bdev_handle->bdev);

	dev_notice(ddev, "writer mapped to %pg\n", file_bdev(bdev_file));

	return 0;



out_mem:

	bdev_release(bdev_handle);

	fput(bdev_file);

	/* This is safe: open() is still holding a reference. */

	module_put(THIS_MODULE);

	return -ENOMEM;
@@ -2605,9 +2605,9 @@ static unsigned int pkt_check_events(struct gendisk *disk, 


	if (!pd)

		return 0;

	if (!pd->bdev_handle)

	if (!pd->bdev_file)

		return 0;

	attached_disk = pd->bdev_handle->bdev->bd_disk;

	attached_disk = file_bdev(pd->bdev_file)->bd_disk;

	if (!attached_disk || !attached_disk->fops->check_events)

		return 0;

	return attached_disk->fops->check_events(attached_disk, clearing);
@@ -2692,7 +2692,7 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev) 
		goto out_mem2;



	/* inherit events of the host device */

	disk->events = pd->bdev_handle->bdev->bd_disk->events;

	disk->events = file_bdev(pd->bdev_file)->bd_disk->events;



	ret = add_disk(disk);

	if (ret)
@@ -2757,7 +2757,7 @@ static int pkt_remove_dev(dev_t pkt_dev) 
	pkt_debugfs_dev_remove(pd);

	pkt_sysfs_dev_remove(pd);



	bdev_release(pd->bdev_handle);

	fput(pd->bdev_file);



	remove_proc_entry(pd->disk->disk_name, pkt_proc);

	dev_notice(ddev, "writer unmapped\n");
@@ -2784,7 +2784,7 @@ static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd) 


	pd = pkt_find_dev_from_minor(ctrl_cmd->dev_index);

	if (pd) {

		ctrl_cmd->dev = new_encode_dev(pd->bdev_handle->bdev->bd_dev);

		ctrl_cmd->dev = new_encode_dev(file_bdev(pd->bdev_file)->bd_dev);

		ctrl_cmd->pkt_dev = new_encode_dev(pd->pkt_dev);

	} else {

		ctrl_cmd->dev = 0;

include/linux/pktcdvd.h

+2 −2
Original line number Diff line number Diff line
@@ -154,9 +154,9 @@ struct packet_stacked_data 


struct pktcdvd_device

{

	struct bdev_handle	*bdev_handle;	/* dev attached */

	struct file		*bdev_file;	/* dev attached */

	/* handle acquired for bdev during pkt_open_dev() */

	struct bdev_handle	*open_bdev_handle;

	struct file		*f_open_bdev;

	dev_t			pkt_dev;	/* our dev */

	struct packet_settings	settings;

	struct packet_stats	stats;