6 files changed, 14 insertions, 11 deletions

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;