floppy: use a separate gendisk for each media format

The floppy driver usually autodetects the media when used with the
normal /dev/fd? devices, which also are the only nodes created by udev.
But it also supports various aliases that force a given media format.
That is currently supported using the blk_register_region framework
which finds the floppy gendisk even for a 'mismatched' dev_t.  The
problem with this (besides the code complexity) is that it creates
multiple struct block_device instances for the whole device of a
single gendisk, which can lead to interesting issues in code not
aware of that fact.

To fix this just create a separate gendisk for each of the aliases
if they are accessed.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 7df79ae..dfe1dfc 100644 (file)
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -402,7 +402,6 @@ static struct floppy_drive_params drive_params[N_DRIVE];
 static struct floppy_drive_struct drive_state[N_DRIVE];
 static struct floppy_write_errors write_errors[N_DRIVE];
 static struct timer_list motor_off_timer[N_DRIVE];
-static struct gendisk *disks[N_DRIVE];
 static struct blk_mq_tag_set tag_sets[N_DRIVE];
 static struct block_device *opened_bdev[N_DRIVE];
 static DEFINE_MUTEX(open_lock);
@@ -477,6 +476,8 @@ static struct floppy_struct floppy_type[32] = {
        { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" }, /* 31 1.6MB 3.5"    */
 };
 
+static struct gendisk *disks[N_DRIVE][ARRAY_SIZE(floppy_type)];
+
 #define SECTSIZE (_FD_SECTSIZE(*floppy))
 
 /* Auto-detection: Disk type used until the next media change occurs. */
@@ -4111,7 +4112,7 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
 
        new_dev = MINOR(bdev->bd_dev);
        drive_state[drive].fd_device = new_dev;
-       set_capacity(disks[drive], floppy_sizes[new_dev]);
+       set_capacity(disks[drive][ITYPE(new_dev)], floppy_sizes[new_dev]);
        if (old_dev != -1 && old_dev != new_dev) {
                if (buffer_drive == drive)
                        buffer_track = -1;
@@ -4579,15 +4580,58 @@ static bool floppy_available(int drive)
        return true;
 }
 
-static struct kobject *floppy_find(dev_t dev, int *part, void *data)
+static int floppy_alloc_disk(unsigned int drive, unsigned int type)
 {
-       int drive = (*part & 3) | ((*part & 0x80) >> 5);
-       if (drive >= N_DRIVE || !floppy_available(drive))
-               return NULL;
-       if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
-               return NULL;
-       *part = 0;
-       return get_disk_and_module(disks[drive]);
+       struct gendisk *disk;
+       int err;
+
+       disk = alloc_disk(1);
+       if (!disk)
+               return -ENOMEM;
+
+       disk->queue = blk_mq_init_queue(&tag_sets[drive]);
+       if (IS_ERR(disk->queue)) {
+               err = PTR_ERR(disk->queue);
+               disk->queue = NULL;
+               put_disk(disk);
+               return err;
+       }
+
+       blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
+       blk_queue_max_hw_sectors(disk->queue, 64);
+       disk->major = FLOPPY_MAJOR;
+       disk->first_minor = TOMINOR(drive) | (type << 2);
+       disk->fops = &floppy_fops;
+       disk->events = DISK_EVENT_MEDIA_CHANGE;
+       if (type)
+               sprintf(disk->disk_name, "fd%d_type%d", drive, type);
+       else
+               sprintf(disk->disk_name, "fd%d", drive);
+       /* to be cleaned up... */
+       disk->private_data = (void *)(long)drive;
+       disk->flags |= GENHD_FL_REMOVABLE;
+
+       disks[drive][type] = disk;
+       return 0;
+}
+
+static DEFINE_MUTEX(floppy_probe_lock);
+
+static void floppy_probe(dev_t dev)
+{
+       unsigned int drive = (MINOR(dev) & 3) | ((MINOR(dev) & 0x80) >> 5);
+       unsigned int type = (MINOR(dev) >> 2) & 0x1f;
+
+       if (drive >= N_DRIVE || !floppy_available(drive) ||
+           type >= ARRAY_SIZE(floppy_type))
+               return;
+
+       mutex_lock(&floppy_probe_lock);
+       if (!disks[drive][type]) {
+               if (floppy_alloc_disk(drive, type) == 0)
+                       add_disk(disks[drive][type]);
+       }
+       mutex_unlock(&floppy_probe_lock);
 }
 
 static int __init do_floppy_init(void)
@@ -4609,33 +4653,25 @@ static int __init do_floppy_init(void)
                return -ENOMEM;
 
        for (drive = 0; drive < N_DRIVE; drive++) {
-               disks[drive] = alloc_disk(1);
-               if (!disks[drive]) {
-                       err = -ENOMEM;
+               memset(&tag_sets[drive], 0, sizeof(tag_sets[drive]));
+               tag_sets[drive].ops = &floppy_mq_ops;
+               tag_sets[drive].nr_hw_queues = 1;
+               tag_sets[drive].nr_maps = 1;
+               tag_sets[drive].queue_depth = 2;
+               tag_sets[drive].numa_node = NUMA_NO_NODE;
+               tag_sets[drive].flags = BLK_MQ_F_SHOULD_MERGE;
+               err = blk_mq_alloc_tag_set(&tag_sets[drive]);
+               if (err)
                        goto out_put_disk;
-               }
 
-               disks[drive]->queue = blk_mq_init_sq_queue(&tag_sets[drive],
-                                                          &floppy_mq_ops, 2,
-                                                          BLK_MQ_F_SHOULD_MERGE);
-               if (IS_ERR(disks[drive]->queue)) {
-                       err = PTR_ERR(disks[drive]->queue);
-                       disks[drive]->queue = NULL;
+               err = floppy_alloc_disk(drive, 0);
+               if (err)
                        goto out_put_disk;
-               }
-
-               blk_queue_bounce_limit(disks[drive]->queue, BLK_BOUNCE_HIGH);
-               blk_queue_max_hw_sectors(disks[drive]->queue, 64);
-               disks[drive]->major = FLOPPY_MAJOR;
-               disks[drive]->first_minor = TOMINOR(drive);
-               disks[drive]->fops = &floppy_fops;
-               disks[drive]->events = DISK_EVENT_MEDIA_CHANGE;
-               sprintf(disks[drive]->disk_name, "fd%d", drive);
 
                timer_setup(&motor_off_timer[drive], motor_off_callback, 0);
        }
 
-       err = register_blkdev(FLOPPY_MAJOR, "fd");
+       err = __register_blkdev(FLOPPY_MAJOR, "fd", floppy_probe);
        if (err)
                goto out_put_disk;
 
@@ -4643,9 +4679,6 @@ static int __init do_floppy_init(void)
        if (err)
                goto out_unreg_blkdev;
 
-       blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
-                           floppy_find, NULL, NULL);
-
        for (i = 0; i < 256; i++)
                if (ITYPE(i))
                        floppy_sizes[i] = floppy_type[ITYPE(i)].size;
@@ -4673,7 +4706,7 @@ static int __init do_floppy_init(void)
        if (fdc_state[0].address == -1) {
                cancel_delayed_work(&fd_timeout);
                err = -ENODEV;
-               goto out_unreg_region;
+               goto out_unreg_driver;
        }
 #if N_FDC > 1
        fdc_state[1].address = FDC2;
@@ -4684,7 +4717,7 @@ static int __init do_floppy_init(void)
        if (err) {
                cancel_delayed_work(&fd_timeout);
                err = -EBUSY;
-               goto out_unreg_region;
+               goto out_unreg_driver;
        }
 
        /* initialise drive state */
@@ -4761,10 +4794,8 @@ static int __init do_floppy_init(void)
                if (err)
                        goto out_remove_drives;
 
-               /* to be cleaned up... */
-               disks[drive]->private_data = (void *)(long)drive;
-               disks[drive]->flags |= GENHD_FL_REMOVABLE;
-               device_add_disk(&floppy_device[drive].dev, disks[drive], NULL);
+               device_add_disk(&floppy_device[drive].dev, disks[drive][0],
+                               NULL);
        }
 
        return 0;
@@ -4772,30 +4803,27 @@ static int __init do_floppy_init(void)
 out_remove_drives:
        while (drive--) {
                if (floppy_available(drive)) {
-                       del_gendisk(disks[drive]);
+                       del_gendisk(disks[drive][0]);
                        platform_device_unregister(&floppy_device[drive]);
                }
        }
 out_release_dma:
        if (atomic_read(&usage_count))
                floppy_release_irq_and_dma();
-out_unreg_region:
-       blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
+out_unreg_driver:
        platform_driver_unregister(&floppy_driver);
 out_unreg_blkdev:
        unregister_blkdev(FLOPPY_MAJOR, "fd");
 out_put_disk:
        destroy_workqueue(floppy_wq);
        for (drive = 0; drive < N_DRIVE; drive++) {
-               if (!disks[drive])
+               if (!disks[drive][0])
                        break;
-               if (disks[drive]->queue) {
-                       del_timer_sync(&motor_off_timer[drive]);
-                       blk_cleanup_queue(disks[drive]->queue);
-                       disks[drive]->queue = NULL;
-                       blk_mq_free_tag_set(&tag_sets[drive]);
-               }
-               put_disk(disks[drive]);
+               del_timer_sync(&motor_off_timer[drive]);
+               blk_cleanup_queue(disks[drive][0]->queue);
+               disks[drive][0]->queue = NULL;
+               blk_mq_free_tag_set(&tag_sets[drive]);
+               put_disk(disks[drive][0]);
        }
        return err;
 }
@@ -5006,9 +5034,8 @@ module_init(floppy_module_init);
 
 static void __exit floppy_module_exit(void)
 {
-       int drive;
+       int drive, i;
 
-       blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
        unregister_blkdev(FLOPPY_MAJOR, "fd");
        platform_driver_unregister(&floppy_driver);
 
@@ -5018,10 +5045,16 @@ static void __exit floppy_module_exit(void)
                del_timer_sync(&motor_off_timer[drive]);
 
                if (floppy_available(drive)) {
-                       del_gendisk(disks[drive]);
+                       for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
+                               if (disks[drive][i])
+                                       del_gendisk(disks[drive][i]);
+                       }
                        platform_device_unregister(&floppy_device[drive]);
                }
-               blk_cleanup_queue(disks[drive]->queue);
+               for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
+                       if (disks[drive][i])
+                               blk_cleanup_queue(disks[drive][i]->queue);
+               }
                blk_mq_free_tag_set(&tag_sets[drive]);
 
                /*
@@ -5029,10 +5062,17 @@ static void __exit floppy_module_exit(void)
                 * queue reference in put_disk().
                 */
                if (!(allowed_drive_mask & (1 << drive)) ||
-                   fdc_state[FDC(drive)].version == FDC_NONE)
-                       disks[drive]->queue = NULL;
+                   fdc_state[FDC(drive)].version == FDC_NONE) {
+                       for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
+                               if (disks[drive][i])
+                                       disks[drive][i]->queue = NULL;
+                       }
+               }
 
-               put_disk(disks[drive]);
+               for (i = 0; i < ARRAY_SIZE(floppy_type); i++) {
+                       if (disks[drive][i])
+                               put_disk(disks[drive][i]);
+               }
        }
 
        cancel_delayed_work_sync(&fd_timeout);