9 files changed, 149 insertions, 61 deletions

diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index 6593ab39cfe9..8873b9b439ff 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -350,6 +350,7 @@ static void blkdev_discard_end_io(struct bio *bio, int err)
 
         if (bio->bi_private)
                 complete(bio->bi_private);
+        __free_page(bio_page(bio));
 
         bio_put(bio);
 }
@@ -372,30 +373,50 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
         struct request_queue *q = bdev_get_queue(bdev);
         int type = flags & DISCARD_FL_BARRIER ?
                 DISCARD_BARRIER : DISCARD_NOBARRIER;
+        struct bio *bio;
+        struct page *page;
         int ret = 0;
 
         if (!q)
                 return -ENXIO;
 
-        if (!q->prepare_discard_fn)
+        if (!blk_queue_discard(q))
                 return -EOPNOTSUPP;
 
         while (nr_sects && !ret) {
-                struct bio *bio = bio_alloc(gfp_mask, 0);
-                if (!bio)
-                        return -ENOMEM;
+                unsigned int sector_size = q->limits.logical_block_size;
+                unsigned int max_discard_sectors =
+                        min(q->limits.max_discard_sectors, UINT_MAX >> 9);
 
+                bio = bio_alloc(gfp_mask, 1);
+                if (!bio)
+                        goto out;
+                bio->bi_sector = sector;
                 bio->bi_end_io = blkdev_discard_end_io;
                 bio->bi_bdev = bdev;
                 if (flags & DISCARD_FL_WAIT)
                         bio->bi_private = &wait;
 
-                bio->bi_sector = sector;
+                /*
+                 * Add a zeroed one-sector payload as that's what
+                 * our current implementations need.  If we'll ever need
+                 * more the interface will need revisiting.
+                 */
+                page = alloc_page(GFP_KERNEL | __GFP_ZERO);
+                if (!page)
+                        goto out_free_bio;
+                if (bio_add_pc_page(q, bio, page, sector_size, 0) < sector_size)
+                        goto out_free_page;
 
-                if (nr_sects > queue_max_hw_sectors(q)) {
-                        bio->bi_size = queue_max_hw_sectors(q) << 9;
-                        nr_sects -= queue_max_hw_sectors(q);
-                        sector += queue_max_hw_sectors(q);
+                /*
+                 * And override the bio size - the way discard works we
+                 * touch many more blocks on disk than the actual payload
+                 * length.
+                 */
+                if (nr_sects > max_discard_sectors) {
+                        bio->bi_size = max_discard_sectors << 9;
+                        nr_sects -= max_discard_sectors;
+                        sector += max_discard_sectors;
                 } else {
                         bio->bi_size = nr_sects << 9;
                         nr_sects = 0;
@@ -414,5 +435,11 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                 bio_put(bio);
         }
         return ret;
+out_free_page:
+        __free_page(page);
+out_free_bio:
+        bio_put(bio);
+out:
+        return -ENOMEM;
 }
 EXPORT_SYMBOL(blkdev_issue_discard);
diff --git a/block/blk-core.c b/block/blk-core.c
index 8135228e4b29..81f34311659a 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -34,6 +34,7 @@
 #include "blk.h"
 
 EXPORT_TRACEPOINT_SYMBOL_GPL(block_remap);
+EXPORT_TRACEPOINT_SYMBOL_GPL(block_rq_remap);
 EXPORT_TRACEPOINT_SYMBOL_GPL(block_bio_complete);
 
 static int __make_request(struct request_queue *q, struct bio *bio);
@@ -69,7 +70,7 @@ static void drive_stat_acct(struct request *rq, int new_io)
                 part_stat_inc(cpu, part, merges[rw]);
         else {
                 part_round_stats(cpu, part);
-                part_inc_in_flight(part, rw);
+                part_inc_in_flight(part);
         }
 
         part_stat_unlock();
@@ -1031,7 +1032,7 @@ static void part_round_stats_single(int cpu, struct hd_struct *part,
 
         if (part->in_flight) {
                 __part_stat_add(cpu, part, time_in_queue,
-                                part_in_flight(part) * (now - part->stamp));
+                                part->in_flight * (now - part->stamp));
                 __part_stat_add(cpu, part, io_ticks, (now - part->stamp));
         }
         part->stamp = now;
@@ -1124,7 +1125,6 @@ void init_request_from_bio(struct request *req, struct bio *bio)
                 req->cmd_flags |= REQ_DISCARD;
                 if (bio_rw_flagged(bio, BIO_RW_BARRIER))
                         req->cmd_flags |= REQ_SOFTBARRIER;
-                req->q->prepare_discard_fn(req->q, req);
         } else if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER)))
                 req->cmd_flags |= REQ_HARDBARRIER;
 
@@ -1437,7 +1437,8 @@ static inline void __generic_make_request(struct bio *bio)
                         goto end_io;
                 }
 
-                if (unlikely(nr_sectors > queue_max_hw_sectors(q))) {
+                if (unlikely(!bio_rw_flagged(bio, BIO_RW_DISCARD) &&
+                             nr_sectors > queue_max_hw_sectors(q))) {
                         printk(KERN_ERR "bio too big device %s (%u > %u)\n",
                                bdevname(bio->bi_bdev, b),
                                bio_sectors(bio),
@@ -1470,7 +1471,7 @@ static inline void __generic_make_request(struct bio *bio)
                         goto end_io;
 
                 if (bio_rw_flagged(bio, BIO_RW_DISCARD) &&
-                    !q->prepare_discard_fn) {
+                    !blk_queue_discard(q)) {
                         err = -EOPNOTSUPP;
                         goto end_io;
                 }
@@ -1738,7 +1739,7 @@ static void blk_account_io_done(struct request *req)
                 part_stat_inc(cpu, part, ios[rw]);
                 part_stat_add(cpu, part, ticks[rw], duration);
                 part_round_stats(cpu, part);
-                part_dec_in_flight(part, rw);
+                part_dec_in_flight(part);
 
                 part_stat_unlock();
         }
@@ -2491,6 +2492,14 @@ int kblockd_schedule_work(struct request_queue *q, struct work_struct *work)
 }
 EXPORT_SYMBOL(kblockd_schedule_work);
 
+int kblockd_schedule_delayed_work(struct request_queue *q,
+                                  struct delayed_work *work,
+                                  unsigned long delay)
+{
+        return queue_delayed_work(kblockd_workqueue, work, delay);
+}
+EXPORT_SYMBOL(kblockd_schedule_delayed_work);
+
 int __init blk_dev_init(void)
 {
         BUILD_BUG_ON(__REQ_NR_BITS > 8 *
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 99cb5cf1f447..b0de8574fdc8 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -351,7 +351,7 @@ static void blk_account_io_merge(struct request *req)
                 part = disk_map_sector_rcu(req->rq_disk, blk_rq_pos(req));
 
                 part_round_stats(cpu, part);
-                part_dec_in_flight(part, rq_data_dir(req));
+                part_dec_in_flight(part);
 
                 part_stat_unlock();
         }
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 83413ff83739..e0695bca7027 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -34,23 +34,6 @@ void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
 EXPORT_SYMBOL(blk_queue_prep_rq);
 
 /**
- * blk_queue_set_discard - set a discard_sectors function for queue
- * @q:          queue
- * @dfn:        prepare_discard function
- *
- * It's possible for a queue to register a discard callback which is used
- * to transform a discard request into the appropriate type for the
- * hardware. If none is registered, then discard requests are failed
- * with %EOPNOTSUPP.
- *
- */
-void blk_queue_set_discard(struct request_queue *q, prepare_discard_fn *dfn)
-{
-        q->prepare_discard_fn = dfn;
-}
-EXPORT_SYMBOL(blk_queue_set_discard);
-
-/**
  * blk_queue_merge_bvec - set a merge_bvec function for queue
  * @q:          queue
  * @mbfn:       merge_bvec_fn
@@ -111,7 +94,9 @@ void blk_set_default_limits(struct queue_limits *lim)
         lim->max_hw_segments = MAX_HW_SEGMENTS;
         lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
         lim->max_segment_size = MAX_SEGMENT_SIZE;
-        lim->max_sectors = lim->max_hw_sectors = SAFE_MAX_SECTORS;
+        lim->max_sectors = BLK_DEF_MAX_SECTORS;
+        lim->max_hw_sectors = INT_MAX;
+        lim->max_discard_sectors = SAFE_MAX_SECTORS;
         lim->logical_block_size = lim->physical_block_size = lim->io_min = 512;
         lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT);
         lim->alignment_offset = 0;
@@ -164,6 +149,7 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
         q->unplug_timer.data = (unsigned long)q;
 
         blk_set_default_limits(&q->limits);
+        blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
 
         /*
          * If the caller didn't supply a lock, fall back to our embedded
@@ -254,6 +240,18 @@ void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors)
 EXPORT_SYMBOL(blk_queue_max_hw_sectors);
 
 /**
+ * blk_queue_max_discard_sectors - set max sectors for a single discard
+ * @q:  the request queue for the device
+ * @max_discard: maximum number of sectors to discard
+ **/
+void blk_queue_max_discard_sectors(struct request_queue *q,
+                unsigned int max_discard_sectors)
+{
+        q->limits.max_discard_sectors = max_discard_sectors;
+}
+EXPORT_SYMBOL(blk_queue_max_discard_sectors);
+
+/**
  * blk_queue_max_phys_segments - set max phys segments for a request for this queue
  * @q:  the request queue for the device
  * @max_segments:  max number of segments
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index b78c9c3e2670..8a6d81afb284 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -452,6 +452,7 @@ int blk_register_queue(struct gendisk *disk)
         if (ret) {
                 kobject_uevent(&q->kobj, KOBJ_REMOVE);
                 kobject_del(&q->kobj);
+                blk_trace_remove_sysfs(disk_to_dev(disk));
                 return ret;
         }
 
@@ -465,11 +466,11 @@ void blk_unregister_queue(struct gendisk *disk)
         if (WARN_ON(!q))
                 return;
 
-        if (q->request_fn) {
+        if (q->request_fn)
                 elv_unregister_queue(q);
 
-                kobject_uevent(&q->kobj, KOBJ_REMOVE);
-                kobject_del(&q->kobj);
-                kobject_put(&disk_to_dev(disk)->kobj);
-        }
+        kobject_uevent(&q->kobj, KOBJ_REMOVE);
+        kobject_del(&q->kobj);
+        blk_trace_remove_sysfs(disk_to_dev(disk));
+        kobject_put(&disk_to_dev(disk)->kobj);
 }
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index 1ca813b16e78..9c4b679908f4 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -150,7 +150,7 @@ struct cfq_data {
          * idle window management
          */
         struct timer_list idle_slice_timer;
-        struct work_struct unplug_work;
+        struct delayed_work unplug_work;
 
         struct cfq_queue *active_queue;
         struct cfq_io_context *active_cic;
@@ -173,6 +173,7 @@ struct cfq_data {
         unsigned int cfq_slice[2];
         unsigned int cfq_slice_async_rq;
         unsigned int cfq_slice_idle;
+        unsigned int cfq_latency;
 
         struct list_head cic_list;
 
@@ -180,6 +181,8 @@ struct cfq_data {
          * Fallback dummy cfqq for extreme OOM conditions
          */
         struct cfq_queue oom_cfqq;
+
+        unsigned long last_end_sync_rq;
 };
 
 enum cfqq_state_flags {
@@ -265,11 +268,13 @@ static inline int cfq_bio_sync(struct bio *bio)
  * scheduler run of queue, if there are requests pending and no one in the
  * driver that will restart queueing
  */
-static inline void cfq_schedule_dispatch(struct cfq_data *cfqd)
+static inline void cfq_schedule_dispatch(struct cfq_data *cfqd,
+                                         unsigned long delay)
 {
         if (cfqd->busy_queues) {
                 cfq_log(cfqd, "schedule dispatch");
-                kblockd_schedule_work(cfqd->queue, &cfqd->unplug_work);
+                kblockd_schedule_delayed_work(cfqd->queue, &cfqd->unplug_work,
+                                                delay);
         }
 }
 
@@ -1326,12 +1331,30 @@ static int cfq_dispatch_requests(struct request_queue *q, int force)
                         return 0;
 
                 /*
-                 * we are the only queue, allow up to 4 times of 'quantum'
+                 * Sole queue user, allow bigger slice
                  */
-                if (cfqq->dispatched >= 4 * max_dispatch)
-                        return 0;
+                max_dispatch *= 4;
+        }
+
+        /*
+         * Async queues must wait a bit before being allowed dispatch.
+         * We also ramp up the dispatch depth gradually for async IO,
+         * based on the last sync IO we serviced
+         */
+        if (!cfq_cfqq_sync(cfqq) && cfqd->cfq_latency) {
+                unsigned long last_sync = jiffies - cfqd->last_end_sync_rq;
+                unsigned int depth;
+
+                depth = last_sync / cfqd->cfq_slice[1];
+                if (!depth && !cfqq->dispatched)
+                        depth = 1;
+                if (depth < max_dispatch)
+                        max_dispatch = depth;
         }
 
+        if (cfqq->dispatched >= max_dispatch)
+                return 0;
+
         /*
          * Dispatch a request from this cfqq
          */
@@ -1376,7 +1399,7 @@ static void cfq_put_queue(struct cfq_queue *cfqq)
 
         if (unlikely(cfqd->active_queue == cfqq)) {
                 __cfq_slice_expired(cfqd, cfqq, 0);
-                cfq_schedule_dispatch(cfqd);
+                cfq_schedule_dispatch(cfqd, 0);
         }
 
         kmem_cache_free(cfq_pool, cfqq);
@@ -1471,7 +1494,7 @@ static void cfq_exit_cfqq(struct cfq_data *cfqd, struct cfq_queue *cfqq)
 {
         if (unlikely(cfqq == cfqd->active_queue)) {
                 __cfq_slice_expired(cfqd, cfqq, 0);
-                cfq_schedule_dispatch(cfqd);
+                cfq_schedule_dispatch(cfqd, 0);
         }
 
         cfq_put_queue(cfqq);
@@ -1951,7 +1974,7 @@ cfq_update_idle_window(struct cfq_data *cfqd, struct cfq_queue *cfqq,
         enable_idle = old_idle = cfq_cfqq_idle_window(cfqq);
 
         if (!atomic_read(&cic->ioc->nr_tasks) || !cfqd->cfq_slice_idle ||
-            (cfqd->hw_tag && CIC_SEEKY(cic)))
+            (!cfqd->cfq_latency && cfqd->hw_tag && CIC_SEEKY(cic)))
                 enable_idle = 0;
         else if (sample_valid(cic->ttime_samples)) {
                 if (cic->ttime_mean > cfqd->cfq_slice_idle)
@@ -2157,8 +2180,10 @@ static void cfq_completed_request(struct request_queue *q, struct request *rq)
         if (cfq_cfqq_sync(cfqq))
                 cfqd->sync_flight--;
 
-        if (sync)
+        if (sync) {
                 RQ_CIC(rq)->last_end_request = now;
+                cfqd->last_end_sync_rq = now;
+        }
 
         /*
          * If this is the active queue, check if it needs to be expired,
@@ -2186,7 +2211,7 @@ static void cfq_completed_request(struct request_queue *q, struct request *rq)
         }
 
         if (!rq_in_driver(cfqd))
-                cfq_schedule_dispatch(cfqd);
+                cfq_schedule_dispatch(cfqd, 0);
 }
 
 /*
@@ -2316,7 +2341,7 @@ queue_fail:
         if (cic)
                 put_io_context(cic->ioc);
 
-        cfq_schedule_dispatch(cfqd);
+        cfq_schedule_dispatch(cfqd, 0);
         spin_unlock_irqrestore(q->queue_lock, flags);
         cfq_log(cfqd, "set_request fail");
         return 1;
@@ -2325,7 +2350,7 @@ queue_fail:
 static void cfq_kick_queue(struct work_struct *work)
 {
         struct cfq_data *cfqd =
-                container_of(work, struct cfq_data, unplug_work);
+                container_of(work, struct cfq_data, unplug_work.work);
         struct request_queue *q = cfqd->queue;
 
         spin_lock_irq(q->queue_lock);
@@ -2379,7 +2404,7 @@ static void cfq_idle_slice_timer(unsigned long data)
 expire:
         cfq_slice_expired(cfqd, timed_out);
 out_kick:
-        cfq_schedule_dispatch(cfqd);
+        cfq_schedule_dispatch(cfqd, 0);
 out_cont:
         spin_unlock_irqrestore(cfqd->queue->queue_lock, flags);
 }
@@ -2387,7 +2412,7 @@ out_cont:
 static void cfq_shutdown_timer_wq(struct cfq_data *cfqd)
 {
         del_timer_sync(&cfqd->idle_slice_timer);
-        cancel_work_sync(&cfqd->unplug_work);
+        cancel_delayed_work_sync(&cfqd->unplug_work);
 }
 
 static void cfq_put_async_queues(struct cfq_data *cfqd)
@@ -2469,7 +2494,7 @@ static void *cfq_init_queue(struct request_queue *q)
         cfqd->idle_slice_timer.function = cfq_idle_slice_timer;
         cfqd->idle_slice_timer.data = (unsigned long) cfqd;
 
-        INIT_WORK(&cfqd->unplug_work, cfq_kick_queue);
+        INIT_DELAYED_WORK(&cfqd->unplug_work, cfq_kick_queue);
 
         cfqd->cfq_quantum = cfq_quantum;
         cfqd->cfq_fifo_expire[0] = cfq_fifo_expire[0];
@@ -2480,8 +2505,9 @@ static void *cfq_init_queue(struct request_queue *q)
         cfqd->cfq_slice[1] = cfq_slice_sync;
         cfqd->cfq_slice_async_rq = cfq_slice_async_rq;
         cfqd->cfq_slice_idle = cfq_slice_idle;
+        cfqd->cfq_latency = 1;
         cfqd->hw_tag = 1;
-
+        cfqd->last_end_sync_rq = jiffies;
         return cfqd;
 }
 
@@ -2549,6 +2575,7 @@ SHOW_FUNCTION(cfq_slice_idle_show, cfqd->cfq_slice_idle, 1);
 SHOW_FUNCTION(cfq_slice_sync_show, cfqd->cfq_slice[1], 1);
 SHOW_FUNCTION(cfq_slice_async_show, cfqd->cfq_slice[0], 1);
 SHOW_FUNCTION(cfq_slice_async_rq_show, cfqd->cfq_slice_async_rq, 0);
+SHOW_FUNCTION(cfq_low_latency_show, cfqd->cfq_latency, 0);
 #undef SHOW_FUNCTION
 
 #define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV)                 \
@@ -2580,6 +2607,7 @@ STORE_FUNCTION(cfq_slice_sync_store, &cfqd->cfq_slice[1], 1, UINT_MAX, 1);
 STORE_FUNCTION(cfq_slice_async_store, &cfqd->cfq_slice[0], 1, UINT_MAX, 1);
 STORE_FUNCTION(cfq_slice_async_rq_store, &cfqd->cfq_slice_async_rq, 1,
                 UINT_MAX, 0);
+STORE_FUNCTION(cfq_low_latency_store, &cfqd->cfq_latency, 0, 1, 0);
 #undef STORE_FUNCTION
 
 #define CFQ_ATTR(name) \
@@ -2595,6 +2623,7 @@ static struct elv_fs_entry cfq_attrs[] = {
         CFQ_ATTR(slice_async),
         CFQ_ATTR(slice_async_rq),
         CFQ_ATTR(slice_idle),
+        CFQ_ATTR(low_latency),
         __ATTR_NULL
 };
 
diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index 7865a34e0faa..9bd086c1a4d5 100644
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -21,6 +21,11 @@ static int compat_put_int(unsigned long arg, int val)
         return put_user(val, (compat_int_t __user *)compat_ptr(arg));
 }
 
+static int compat_put_uint(unsigned long arg, unsigned int val)
+{
+        return put_user(val, (compat_uint_t __user *)compat_ptr(arg));
+}
+
 static int compat_put_long(unsigned long arg, long val)
 {
         return put_user(val, (compat_long_t __user *)compat_ptr(arg));
@@ -734,6 +739,14 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
         switch (cmd) {
         case HDIO_GETGEO:
                 return compat_hdio_getgeo(disk, bdev, compat_ptr(arg));
+        case BLKPBSZGET:
+                return compat_put_uint(arg, bdev_physical_block_size(bdev));
+        case BLKIOMIN:
+                return compat_put_uint(arg, bdev_io_min(bdev));
+        case BLKIOOPT:
+                return compat_put_uint(arg, bdev_io_opt(bdev));
+        case BLKALIGNOFF:
+                return compat_put_int(arg, bdev_alignment_offset(bdev));
         case BLKFLSBUF:
         case BLKROSET:
         case BLKDISCARD:
diff --git a/block/genhd.c b/block/genhd.c
index 517e4332cb37..5a0861da324d 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -869,7 +869,6 @@ static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
 static DEVICE_ATTR(alignment_offset, S_IRUGO, disk_alignment_offset_show, NULL);
 static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
 static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
-static DEVICE_ATTR(inflight, S_IRUGO, part_inflight_show, NULL);
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 static struct device_attribute dev_attr_fail =
         __ATTR(make-it-fail, S_IRUGO|S_IWUSR, part_fail_show, part_fail_store);
@@ -889,7 +888,6 @@ static struct attribute *disk_attrs[] = {
         &dev_attr_alignment_offset.attr,
         &dev_attr_capability.attr,
         &dev_attr_stat.attr,
-        &dev_attr_inflight.attr,
 #ifdef CONFIG_FAIL_MAKE_REQUEST
         &dev_attr_fail.attr,
 #endif
@@ -1055,7 +1053,7 @@ static int diskstats_show(struct seq_file *seqf, void *v)
                            part_stat_read(hd, merges[1]),
                            (unsigned long long)part_stat_read(hd, sectors[1]),
                            jiffies_to_msecs(part_stat_read(hd, ticks[1])),
-                           part_in_flight(hd),
+                           hd->in_flight,
                            jiffies_to_msecs(part_stat_read(hd, io_ticks)),
                            jiffies_to_msecs(part_stat_read(hd, time_in_queue))
                         );
diff --git a/block/ioctl.c b/block/ioctl.c
index d3e6b5827a34..1f4d1de12b09 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -138,6 +138,11 @@ static int put_int(unsigned long arg, int val)
         return put_user(val, (int __user *)arg);
 }
 
+static int put_uint(unsigned long arg, unsigned int val)
+{
+        return put_user(val, (unsigned int __user *)arg);
+}
+
 static int put_long(unsigned long arg, long val)
 {
         return put_user(val, (long __user *)arg);
@@ -263,10 +268,18 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                 return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
         case BLKROGET:
                 return put_int(arg, bdev_read_only(bdev) != 0);
-        case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
+        case BLKBSZGET: /* get block device soft block size (cf. BLKSSZGET) */
                 return put_int(arg, block_size(bdev));
-        case BLKSSZGET: /* get block device hardware sector size */
+        case BLKSSZGET: /* get block device logical block size */
                 return put_int(arg, bdev_logical_block_size(bdev));
+        case BLKPBSZGET: /* get block device physical block size */
+                return put_uint(arg, bdev_physical_block_size(bdev));
+        case BLKIOMIN:
+                return put_uint(arg, bdev_io_min(bdev));
+        case BLKIOOPT:
+                return put_uint(arg, bdev_io_opt(bdev));
+        case BLKALIGNOFF:
+                return put_int(arg, bdev_alignment_offset(bdev));
         case BLKSECTGET:
                 return put_ushort(arg, queue_max_sectors(bdev_get_queue(bdev)));
         case BLKRASET: