5 files changed, 48 insertions, 26 deletions

diff --git a/block/blk-core.c b/block/blk-core.c
index c8303e9d919d..d2f8f4049abd 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -345,6 +345,7 @@ void blk_put_queue(struct request_queue *q)
 {
         kobject_put(&q->kobj);
 }
+EXPORT_SYMBOL(blk_put_queue);
 
 /*
  * Note: If a driver supplied the queue lock, it should not zap that lock
@@ -566,6 +567,7 @@ int blk_get_queue(struct request_queue *q)
 
         return 1;
 }
+EXPORT_SYMBOL(blk_get_queue);
 
 static inline void blk_free_request(struct request_queue *q, struct request *rq)
 {
@@ -1130,7 +1132,6 @@ static bool bio_attempt_front_merge(struct request_queue *q,
                                     struct request *req, struct bio *bio)
 {
         const int ff = bio->bi_rw & REQ_FAILFAST_MASK;
-        sector_t sector;
 
         if (!ll_front_merge_fn(q, req, bio))
                 return false;
@@ -1140,8 +1141,6 @@ static bool bio_attempt_front_merge(struct request_queue *q,
         if ((req->cmd_flags & REQ_FAILFAST_MASK) != ff)
                 blk_rq_set_mixed_merge(req);
 
-        sector = bio->bi_sector;
-
         bio->bi_next = req->bio;
         req->bio = bio;
 
diff --git a/block/genhd.c b/block/genhd.c
index 2dd988723d73..95822ae25cfe 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -1728,7 +1728,7 @@ static void disk_add_events(struct gendisk *disk)
 {
         struct disk_events *ev;
 
-        if (!disk->fops->check_events || !(disk->events | disk->async_events))
+        if (!disk->fops->check_events)
                 return;
 
         ev = kzalloc(sizeof(*ev), GFP_KERNEL);
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index b7f51e4594f8..dba1c32e1ddf 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -35,10 +35,6 @@
  */
 struct brd_device {
         int             brd_number;
-        int             brd_refcnt;
-        loff_t          brd_offset;
-        loff_t          brd_sizelimit;
-        unsigned        brd_blocksize;
 
         struct request_queue    *brd_queue;
         struct gendisk          *brd_disk;
@@ -440,11 +436,11 @@ static int rd_nr;
 int rd_size = CONFIG_BLK_DEV_RAM_SIZE;
 static int max_part;
 static int part_shift;
-module_param(rd_nr, int, 0);
+module_param(rd_nr, int, S_IRUGO);
 MODULE_PARM_DESC(rd_nr, "Maximum number of brd devices");
-module_param(rd_size, int, 0);
+module_param(rd_size, int, S_IRUGO);
 MODULE_PARM_DESC(rd_size, "Size of each RAM disk in kbytes.");
-module_param(max_part, int, 0);
+module_param(max_part, int, S_IRUGO);
 MODULE_PARM_DESC(max_part, "Maximum number of partitions per RAM disk");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_BLOCKDEV_MAJOR(RAMDISK_MAJOR);
@@ -552,7 +548,7 @@ static struct kobject *brd_probe(dev_t dev, int *part, void *data)
         struct kobject *kobj;
 
         mutex_lock(&brd_devices_mutex);
-        brd = brd_init_one(dev & MINORMASK);
+        brd = brd_init_one(MINOR(dev) >> part_shift);
         kobj = brd ? get_disk(brd->brd_disk) : ERR_PTR(-ENOMEM);
         mutex_unlock(&brd_devices_mutex);
 
@@ -575,25 +571,39 @@ static int __init brd_init(void)
          *
          * (1) if rd_nr is specified, create that many upfront, and this
          *     also becomes a hard limit.
-         * (2) if rd_nr is not specified, create 1 rd device on module
-         *     load, user can further extend brd device by create dev node
-         *     themselves and have kernel automatically instantiate actual
-         *     device on-demand.
+         * (2) if rd_nr is not specified, create CONFIG_BLK_DEV_RAM_COUNT
+         *     (default 16) rd device on module load, user can further
+         *     extend brd device by create dev node themselves and have
+         *     kernel automatically instantiate actual device on-demand.
          */
 
         part_shift = 0;
-        if (max_part > 0)
+        if (max_part > 0) {
                 part_shift = fls(max_part);
 
+                /*
+                 * Adjust max_part according to part_shift as it is exported
+                 * to user space so that user can decide correct minor number
+                 * if [s]he want to create more devices.
+                 *
+                 * Note that -1 is required because partition 0 is reserved
+                 * for the whole disk.
+                 */
+                max_part = (1UL << part_shift) - 1;
+        }
+
+        if ((1UL << part_shift) > DISK_MAX_PARTS)
+                return -EINVAL;
+
         if (rd_nr > 1UL << (MINORBITS - part_shift))
                 return -EINVAL;
 
         if (rd_nr) {
                 nr = rd_nr;
-                range = rd_nr;
+                range = rd_nr << part_shift;
         } else {
                 nr = CONFIG_BLK_DEV_RAM_COUNT;
-                range = 1UL << (MINORBITS - part_shift);
+                range = 1UL << MINORBITS;
         }
 
         if (register_blkdev(RAMDISK_MAJOR, "ramdisk"))
@@ -632,7 +642,7 @@ static void __exit brd_exit(void)
         unsigned long range;
         struct brd_device *brd, *next;
 
-        range = rd_nr ? rd_nr :  1UL << (MINORBITS - part_shift);
+        range = rd_nr ? rd_nr << part_shift : 1UL << MINORBITS;
 
         list_for_each_entry_safe(brd, next, &brd_devices, brd_list)
                 brd_del_one(brd);
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index c59a672a3de0..76c8da78212b 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1540,9 +1540,9 @@ static const struct block_device_operations lo_fops = {
  * And now the modules code and kernel interface.
  */
 static int max_loop;
-module_param(max_loop, int, 0);
+module_param(max_loop, int, S_IRUGO);
 MODULE_PARM_DESC(max_loop, "Maximum number of loop devices");
-module_param(max_part, int, 0);
+module_param(max_part, int, S_IRUGO);
 MODULE_PARM_DESC(max_part, "Maximum number of partitions per loop device");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
@@ -1688,9 +1688,20 @@ static int __init loop_init(void)
          */
 
         part_shift = 0;
-        if (max_part > 0)
+        if (max_part > 0) {
                 part_shift = fls(max_part);
 
+                /*
+                 * Adjust max_part according to part_shift as it is exported
+                 * to user space so that user can decide correct minor number
+                 * if [s]he want to create more devices.
+                 *
+                 * Note that -1 is required because partition 0 is reserved
+                 * for the whole disk.
+                 */
+                max_part = (1UL << part_shift) - 1;
+        }
+
         if ((1UL << part_shift) > DISK_MAX_PARTS)
                 return -EINVAL;
 
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 8ed4d3433199..f82e762eeca2 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -256,10 +256,12 @@ ssize_t part_discard_alignment_show(struct device *dev,
 {
         struct hd_struct *p = dev_to_part(dev);
         struct gendisk *disk = dev_to_disk(dev);
+        unsigned int alignment = 0;
 
-        return sprintf(buf, "%u\n",
-                        queue_limit_discard_alignment(&disk->queue->limits,
-                                                        p->start_sect));
+        if (disk->queue)
+                alignment = queue_limit_discard_alignment(&disk->queue->limits,
+                                                                p->start_sect);
+        return sprintf(buf, "%u\n", alignment);
 }
 
 ssize_t part_stat_show(struct device *dev,