pktcdvd: port block device access to file

Link: https://lore.kernel.org/r/20240123-vfs-bdev-file-v2-9-adbd023e19cc@kernel.org
Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index d56d972aadb36fa2a3b85282eef1ea058a9bf73e..c21444716e438214096406679fee043690f3c591 100644 (file)
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -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;

diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
index 79594aeb160dafa2e04ff47390d37316025a5588..2f1b952d596aa4661ee20e2450d8ab4feac4c86f 100644 (file)
--- a/include/linux/pktcdvd.h
+++ b/include/linux/pktcdvd.h
@@ -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;