30 files changed, 51 insertions, 47 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index e714e7cce6f2..94474f5f8bce 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -1389,8 +1389,8 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
 
         disk->queue->queuedata = h;
 
-        blk_queue_hardsect_size(disk->queue,
-                                h->drv[drv_index].block_size);
+        blk_queue_logical_block_size(disk->queue,
+                                     h->drv[drv_index].block_size);
 
         /* Make sure all queue data is written out before */
         /* setting h->drv[drv_index].queue, as setting this */
@@ -2298,7 +2298,7 @@ static int cciss_revalidate(struct gendisk *disk)
         cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
                                inq_buff, drv);
 
-        blk_queue_hardsect_size(drv->queue, drv->block_size);
+        blk_queue_logical_block_size(drv->queue, drv->block_size);
         set_capacity(disk, drv->nr_blocks);
 
         kfree(inq_buff);
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index a02dcfc00f13..44fa2018f6b0 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -474,7 +474,7 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
                 disk->fops = &ida_fops;
                 if (j && !drv->nr_blks)
                         continue;
-                blk_queue_hardsect_size(hba[i]->queue, drv->blk_size);
+                blk_queue_logical_block_size(hba[i]->queue, drv->blk_size);
                 set_capacity(disk, drv->nr_blks);
                 disk->queue = hba[i]->queue;
                 disk->private_data = drv;
@@ -1546,7 +1546,7 @@ static int revalidate_allvol(ctlr_info_t *host)
                 drv_info_t *drv = &host->drv[i];
                 if (i && !drv->nr_blks)
                         continue;
-                blk_queue_hardsect_size(host->queue, drv->blk_size);
+                blk_queue_logical_block_size(host->queue, drv->blk_size);
                 set_capacity(disk, drv->nr_blks);
                 disk->queue = host->queue;
                 disk->private_data = drv;
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index 961de56d00a9..f65b3f369eb0 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -724,7 +724,7 @@ static int __init hd_init(void)
         blk_queue_max_sectors(hd_queue, 255);
         init_timer(&device_timer);
         device_timer.function = hd_times_out;
-        blk_queue_hardsect_size(hd_queue, 512);
+        blk_queue_logical_block_size(hd_queue, 512);
 
         if (!NR_HD) {
                 /*
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index c0cd0a03f698..60de5a01e71e 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -996,7 +996,7 @@ static int mg_probe(struct platform_device *plat_dev)
                 goto probe_err_6;
         }
         blk_queue_max_sectors(host->breq, MG_MAX_SECTS);
-        blk_queue_hardsect_size(host->breq, MG_SECTOR_SIZE);
+        blk_queue_logical_block_size(host->breq, MG_SECTOR_SIZE);
 
         init_timer(&host->timer);
         host->timer.function = mg_times_out;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index dc7a8c352da2..293f5858921d 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2657,7 +2657,7 @@ static void pkt_init_queue(struct pktcdvd_device *pd)
         struct request_queue *q = pd->disk->queue;
 
         blk_queue_make_request(q, pkt_make_request);
-        blk_queue_hardsect_size(q, CD_FRAMESIZE);
+        blk_queue_logical_block_size(q, CD_FRAMESIZE);
         blk_queue_max_sectors(q, PACKET_MAX_SECTORS);
         blk_queue_merge_bvec(q, pkt_merge_bvec);
         q->queuedata = pd;
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 338cee4cc0ba..aaeeb544228a 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -477,7 +477,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
         blk_queue_max_sectors(queue, dev->bounce_size >> 9);
         blk_queue_segment_boundary(queue, -1UL);
         blk_queue_dma_alignment(queue, dev->blk_size-1);
-        blk_queue_hardsect_size(queue, dev->blk_size);
+        blk_queue_logical_block_size(queue, dev->blk_size);
 
         blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
                           ps3disk_prepare_flush);
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index e67bbae9547d..cc54473b8e77 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -722,7 +722,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
         /*
          * build the command
          *
-         * The call to blk_queue_hardsect_size() guarantees that request
+         * The call to blk_queue_logical_block_size() guarantees that request
          * is aligned, but it is given in terms of 512 byte units, always.
          */
         block = blk_rq_pos(rq) >> lun->capacity.bshift;
@@ -1749,7 +1749,7 @@ static int ub_bd_revalidate(struct gendisk *disk)
         ub_revalidate(lun->udev, lun);
 
         /* XXX Support sector size switching like in sr.c */
-        blk_queue_hardsect_size(disk->queue, lun->capacity.bsize);
+        blk_queue_logical_block_size(disk->queue, lun->capacity.bsize);
         set_capacity(disk, lun->capacity.nsec);
         // set_disk_ro(sdkp->disk, lun->readonly);
 
@@ -2324,7 +2324,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
         blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
         blk_queue_segment_boundary(q, 0xffffffff);      /* Dubious. */
         blk_queue_max_sectors(q, UB_MAX_SECTORS);
-        blk_queue_hardsect_size(q, lun->capacity.bsize);
+        blk_queue_logical_block_size(q, lun->capacity.bsize);
 
         lun->disk = disk;
         q->queuedata = lun;
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 511d4ae2d176..c4845b169464 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -347,7 +347,7 @@ static int virtblk_probe(struct virtio_device *vdev)
                                 offsetof(struct virtio_blk_config, blk_size),
                                 &blk_size);
         if (!err)
-                blk_queue_hardsect_size(vblk->disk->queue, blk_size);
+                blk_queue_logical_block_size(vblk->disk->queue, blk_size);
 
         add_disk(vblk->disk);
         return 0;
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 132120ae4bde..c1996829d5ec 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -344,7 +344,7 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
         queue_flag_set_unlocked(QUEUE_FLAG_VIRT, rq);
 
         /* Hard sector size and max sectors impersonate the equiv. hardware. */
-        blk_queue_hardsect_size(rq, sector_size);
+        blk_queue_logical_block_size(rq, sector_size);
         blk_queue_max_sectors(rq, 512);
 
         /* Each segment in a request is up to an aligned page in size. */
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 3a4397edab71..f08491a3a813 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -984,7 +984,7 @@ static int __devinit ace_setup(struct ace_device *ace)
         ace->queue = blk_init_queue(ace_request, &ace->lock);
         if (ace->queue == NULL)
                 goto err_blk_initq;
-        blk_queue_hardsect_size(ace->queue, 512);
+        blk_queue_logical_block_size(ace->queue, 512);
 
         /*
          * Allocate and initialize GD structure
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index 1e366ad8f680..b5621f27c4be 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -739,7 +739,7 @@ static void __devinit probe_gdrom_setupdisk(void)
 
 static int __devinit probe_gdrom_setupqueue(void)
 {
-        blk_queue_hardsect_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
+        blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
         /* using DMA so memory will need to be contiguous */
         blk_queue_max_hw_segments(gd.gdrom_rq, 1);
         /* set a large max size to get most from DMA */
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index f177c2d4017f..0fff646cc2f0 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -469,8 +469,8 @@ static void vio_handle_cd_event(struct HvLpEvent *event)
         case viocdopen:
                 if (event->xRc == 0) {
                         di = &viocd_diskinfo[bevent->disk];
-                        blk_queue_hardsect_size(di->viocd_disk->queue,
-                                        bevent->block_size);
+                        blk_queue_logical_block_size(di->viocd_disk->queue,
+                                                     bevent->block_size);
                         set_capacity(di->viocd_disk,
                                         bevent->media_size *
                                         bevent->block_size / 512);
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 20d90e6a6e50..db32f0e4c7dd 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -71,7 +71,7 @@ static int raw_open(struct inode *inode, struct file *filp)
         err = bd_claim(bdev, raw_open);
         if (err)
                 goto out1;
-        err = set_blocksize(bdev, bdev_hardsect_size(bdev));
+        err = set_blocksize(bdev, bdev_logical_block_size(bdev));
         if (err)
                 goto out2;
         filp->f_flags |= O_DIRECT;
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 1799328decfb..424140c6c400 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -182,7 +182,7 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
                                  (sense->information[2] <<  8) |
                                  (sense->information[3]);
 
-                        if (drive->queue->hardsect_size == 2048)
+                        if (queue_logical_block_size(drive->queue) == 2048)
                                 /* device sector size is 2K */
                                 sector <<= 2;
 
@@ -737,7 +737,7 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         struct request_queue *q = drive->queue;
         int write = rq_data_dir(rq) == WRITE;
         unsigned short sectors_per_frame =
-                queue_hardsect_size(q) >> SECTOR_BITS;
+                queue_logical_block_size(q) >> SECTOR_BITS;
 
         ide_debug_log(IDE_DBG_RQ, "rq->cmd[0]: 0x%x, rq->cmd_flags: 0x%x, "
                                   "secs_per_frame: %u",
@@ -1021,8 +1021,8 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
         /* save a private copy of the TOC capacity for error handling */
         drive->probed_capacity = toc->capacity * sectors_per_frame;
 
-        blk_queue_hardsect_size(drive->queue,
-                                sectors_per_frame << SECTOR_BITS);
+        blk_queue_logical_block_size(drive->queue,
+                                     sectors_per_frame << SECTOR_BITS);
 
         /* first read just the header, so we know how long the TOC is */
         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
@@ -1338,7 +1338,7 @@ static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
 /* standard prep_rq_fn that builds 10 byte cmds */
 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
 {
-        int hard_sect = queue_hardsect_size(q);
+        int hard_sect = queue_logical_block_size(q);
         long block = (long)blk_rq_pos(rq) / (hard_sect >> 9);
         unsigned long blocks = blk_rq_sectors(rq) / (hard_sect >> 9);
 
@@ -1543,7 +1543,7 @@ static int ide_cdrom_setup(ide_drive_t *drive)
 
         nslots = ide_cdrom_probe_capabilities(drive);
 
-        blk_queue_hardsect_size(q, CD_FRAMESIZE);
+        blk_queue_logical_block_size(q, CD_FRAMESIZE);
 
         if (ide_cdrom_register(drive, nslots)) {
                 printk(KERN_ERR PFX "%s: %s failed to register device with the"
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 47c68bc75a17..06b0ded1ce23 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -232,7 +232,7 @@ static struct page *read_sb_page(mddev_t *mddev, long offset,
                 target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
 
                 if (sync_page_io(rdev->bdev, target,
-                                 roundup(size, bdev_hardsect_size(rdev->bdev)),
+                                 roundup(size, bdev_logical_block_size(rdev->bdev)),
                                  page, READ)) {
                         page->index = index;
                         attach_page_buffers(page, NULL); /* so that free_buffer will
@@ -287,7 +287,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                         int size = PAGE_SIZE;
                         if (page->index == bitmap->file_pages-1)
                                 size = roundup(bitmap->last_page_size,
-                                               bdev_hardsect_size(rdev->bdev));
+                                               bdev_logical_block_size(rdev->bdev));
                         /* Just make sure we aren't corrupting data or
                          * metadata
                          */
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index a2e26c242141..75d8081a9041 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -178,7 +178,7 @@ static int set_chunk_size(struct dm_exception_store *store,
         }
 
         /* Validate the chunk size against the device block size */
-        if (chunk_size_ulong % (bdev_hardsect_size(store->cow->bdev) >> 9)) {
+        if (chunk_size_ulong % (bdev_logical_block_size(store->cow->bdev) >> 9)) {
                 *error = "Chunk size is not a multiple of device blocksize";
                 return -EINVAL;
         }
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index be233bc4d917..6fa8ccf91c70 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -413,7 +413,8 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
                  * Buffer holds both header and bitset.
                  */
                 buf_size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) +
-                                       bitset_size, ti->limits.hardsect_size);
+                                       bitset_size,
+                                       ti->limits.logical_block_size);
 
                 if (buf_size > dev->bdev->bd_inode->i_size) {
                         DMWARN("log device %s too small: need %llu bytes",
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index e75c6dd76a9a..2662a41337e7 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -282,7 +282,7 @@ static int read_header(struct pstore *ps, int *new_snapshot)
          */
         if (!ps->store->chunk_size) {
                 ps->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
-                    bdev_hardsect_size(ps->store->cow->bdev) >> 9);
+                    bdev_logical_block_size(ps->store->cow->bdev) >> 9);
                 ps->store->chunk_mask = ps->store->chunk_size - 1;
                 ps->store->chunk_shift = ffs(ps->store->chunk_size) - 1;
                 chunk_size_supplied = 0;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 429b50b975d5..65e2d9759857 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -108,7 +108,8 @@ static void combine_restrictions_low(struct io_restrictions *lhs,
         lhs->max_hw_segments =
                 min_not_zero(lhs->max_hw_segments, rhs->max_hw_segments);
 
-        lhs->hardsect_size = max(lhs->hardsect_size, rhs->hardsect_size);
+        lhs->logical_block_size = max(lhs->logical_block_size,
+                                      rhs->logical_block_size);
 
         lhs->max_segment_size =
                 min_not_zero(lhs->max_segment_size, rhs->max_segment_size);
@@ -529,7 +530,8 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
         rs->max_hw_segments =
                 min_not_zero(rs->max_hw_segments, q->max_hw_segments);
 
-        rs->hardsect_size = max(rs->hardsect_size, q->hardsect_size);
+        rs->logical_block_size = max(rs->logical_block_size,
+                                     queue_logical_block_size(q));
 
         rs->max_segment_size =
                 min_not_zero(rs->max_segment_size, q->max_segment_size);
@@ -683,8 +685,8 @@ static void check_for_valid_limits(struct io_restrictions *rs)
                 rs->max_phys_segments = MAX_PHYS_SEGMENTS;
         if (!rs->max_hw_segments)
                 rs->max_hw_segments = MAX_HW_SEGMENTS;
-        if (!rs->hardsect_size)
-                rs->hardsect_size = 1 << SECTOR_SHIFT;
+        if (!rs->logical_block_size)
+                rs->logical_block_size = 1 << SECTOR_SHIFT;
         if (!rs->max_segment_size)
                 rs->max_segment_size = MAX_SEGMENT_SIZE;
         if (!rs->seg_boundary_mask)
@@ -914,7 +916,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
         blk_queue_max_sectors(q, t->limits.max_sectors);
         q->max_phys_segments = t->limits.max_phys_segments;
         q->max_hw_segments = t->limits.max_hw_segments;
-        q->hardsect_size = t->limits.hardsect_size;
+        q->logical_block_size = t->limits.logical_block_size;
         q->max_segment_size = t->limits.max_segment_size;
         q->max_hw_sectors = t->limits.max_hw_sectors;
         q->seg_boundary_mask = t->limits.seg_boundary_mask;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index fccc8343a250..4cbc19f5c304 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1202,7 +1202,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
         atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
 
         rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
-        bmask = queue_hardsect_size(rdev->bdev->bd_disk->queue)-1;
+        bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
         if (rdev->sb_size & bmask)
                 rdev->sb_size = (rdev->sb_size | bmask) + 1;
 
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index c0bebc6a2f2c..7847bbc1440d 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -1242,7 +1242,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 
         sprintf(msb->disk->disk_name, "mspblk%d", disk_id);
 
-        blk_queue_hardsect_size(msb->queue, msb->page_size);
+        blk_queue_logical_block_size(msb->queue, msb->page_size);
 
         capacity = be16_to_cpu(sys_info->user_block_count);
         capacity *= be16_to_cpu(sys_info->block_size);
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 6573ef4408f1..335d4c78a775 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -794,8 +794,9 @@ static int i2o_block_transfer(struct request *req)
         if (c->adaptec) {
                 u8 cmd[10];
                 u32 scsi_flags;
-                u16 hwsec = queue_hardsect_size(req->q) >> KERNEL_SECTOR_SHIFT;
+                u16 hwsec;
 
+                hwsec = queue_logical_block_size(req->q) >> KERNEL_SECTOR_SHIFT;
                 memset(cmd, 0, 10);
 
                 sgl_offset = SGL_OFFSET_12;
@@ -1078,7 +1079,7 @@ static int i2o_block_probe(struct device *dev)
          */
         if (!i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) ||
             !i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4)) {
-                blk_queue_hardsect_size(queue, le32_to_cpu(blocksize));
+                blk_queue_logical_block_size(queue, le32_to_cpu(blocksize));
         } else
                 osm_warn("unable to get blocksize of %s\n", gd->disk_name);
 
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index c5df86546458..98ffc41eaf2c 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -521,7 +521,7 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
 
         sprintf(md->disk->disk_name, "mmcblk%d", devidx);
 
-        blk_queue_hardsect_size(md->queue.queue, 512);
+        blk_queue_logical_block_size(md->queue.queue, 512);
 
         if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
                 /*
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 502622f628bc..aaac3b6800b7 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -378,7 +378,7 @@ int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
         }
 
         tr->blkcore_priv->rq->queuedata = tr;
-        blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
+        blk_queue_logical_block_size(tr->blkcore_priv->rq, tr->blksize);
         if (tr->discard)
                 blk_queue_set_discard(tr->blkcore_priv->rq,
                                       blktrans_discard_request);
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index e64f62d5e0fc..27a1be0cd4d4 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1990,7 +1990,7 @@ static void dasd_setup_queue(struct dasd_block *block)
 {
         int max;
 
-        blk_queue_hardsect_size(block->request_queue, block->bp_block);
+        blk_queue_logical_block_size(block->request_queue, block->bp_block);
         max = block->base->discipline->max_blocks << block->s2b_shift;
         blk_queue_max_sectors(block->request_queue, max);
         blk_queue_max_phys_segments(block->request_queue, -1L);
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index cfdcf1aed33c..a4c7ffcd9987 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -602,7 +602,7 @@ dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char
         dev_info->gd->private_data = dev_info;
         dev_info->gd->driverfs_dev = &dev_info->dev;
         blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
-        blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096);
+        blk_queue_logical_block_size(dev_info->dcssblk_queue, 4096);
 
         seg_byte_size = (dev_info->end - dev_info->start + 1);
         set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 76814f3e898a..0ae0c83ef879 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -343,7 +343,7 @@ static int __init xpram_setup_blkdev(void)
                         goto out;
                 }
                 blk_queue_make_request(xpram_queues[i], xpram_make_request);
-                blk_queue_hardsect_size(xpram_queues[i], 4096);
+                blk_queue_logical_block_size(xpram_queues[i], 4096);
         }
 
         /*
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 1e7967675980..47ff695255ea 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -222,7 +222,7 @@ tapeblock_setup_device(struct tape_device * device)
         if (rc)
                 goto cleanup_queue;
 
-        blk_queue_hardsect_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
+        blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
         blk_queue_max_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
         blk_queue_max_phys_segments(blkdat->request_queue, -1L);
         blk_queue_max_hw_segments(blkdat->request_queue, -1L);
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 40d2860f235a..bcf3bd40bbd5 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1510,7 +1510,7 @@ got_data:
                  */
                 sector_size = 512;
         }
-        blk_queue_hardsect_size(sdp->request_queue, sector_size);
+        blk_queue_logical_block_size(sdp->request_queue, sector_size);
 
         {
                 char cap_str_2[10], cap_str_10[10];
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index fddba53c7fe5..cd350dfc1216 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -727,7 +727,7 @@ static void get_sectorsize(struct scsi_cd *cd)
         }
 
         queue = cd->device->request_queue;
-        blk_queue_hardsect_size(queue, sector_size);
+        blk_queue_logical_block_size(queue, sector_size);
 
         return;
 }