block: Do away with the notion of hardsect_size
authorMartin K. Petersen <martin.petersen@oracle.com>
Fri, 22 May 2009 21:17:49 +0000 (17:17 -0400)
committerJens Axboe <jens.axboe@oracle.com>
Fri, 22 May 2009 21:22:54 +0000 (23:22 +0200)
Until now we have had a 1:1 mapping between storage device physical
block size and the logical block sized used when addressing the device.
With SATA 4KB drives coming out that will no longer be the case.  The
sector size will be 4KB but the logical block size will remain
512-bytes.  Hence we need to distinguish between the physical block size
and the logical ditto.

This patch renames hardsect_size to logical_block_size.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
54 files changed:
arch/powerpc/sysdev/axonram.c
block/blk-integrity.c
block/blk-settings.c
block/blk-sysfs.c
block/compat_ioctl.c
block/ioctl.c
drivers/block/cciss.c
drivers/block/cpqarray.c
drivers/block/hd.c
drivers/block/mg_disk.c
drivers/block/pktcdvd.c
drivers/block/ps3disk.c
drivers/block/ub.c
drivers/block/virtio_blk.c
drivers/block/xen-blkfront.c
drivers/block/xsysace.c
drivers/cdrom/gdrom.c
drivers/cdrom/viocd.c
drivers/char/raw.c
drivers/ide/ide-cd.c
drivers/md/bitmap.c
drivers/md/dm-exception-store.c
drivers/md/dm-log.c
drivers/md/dm-snap-persistent.c
drivers/md/dm-table.c
drivers/md/md.c
drivers/memstick/core/mspro_block.c
drivers/message/i2o/i2o_block.c
drivers/mmc/card/block.c
drivers/mtd/mtd_blkdevs.c
drivers/s390/block/dasd.c
drivers/s390/block/dcssblk.c
drivers/s390/block/xpram.c
drivers/s390/char/tape_block.c
drivers/scsi/sd.c
drivers/scsi/sr.c
fs/bio.c
fs/block_dev.c
fs/buffer.c
fs/direct-io.c
fs/ext3/super.c
fs/ext4/super.c
fs/gfs2/ops_fstype.c
fs/gfs2/rgrp.c
fs/nilfs2/the_nilfs.c
fs/ntfs/super.c
fs/ocfs2/cluster/heartbeat.c
fs/ocfs2/super.c
fs/partitions/ibm.c
fs/partitions/msdos.c
fs/udf/super.c
fs/xfs/linux-2.6/xfs_buf.c
include/linux/blkdev.h
include/linux/device-mapper.h

index 9e105cbc5e5f4c3fb3f10654485d009cb37bb111..a4779912a5caa4d45eacedd3b584d33a2537fafd 100644 (file)
@@ -250,7 +250,7 @@ axon_ram_probe(struct of_device *device, const struct of_device_id *device_id)
 
        set_capacity(bank->disk, bank->size >> AXON_RAM_SECTOR_SHIFT);
        blk_queue_make_request(bank->disk->queue, axon_ram_make_request);
-       blk_queue_hardsect_size(bank->disk->queue, AXON_RAM_SECTOR_SIZE);
+       blk_queue_logical_block_size(bank->disk->queue, AXON_RAM_SECTOR_SIZE);
        add_disk(bank->disk);
 
        bank->irq_id = irq_of_parse_and_map(device->node, 0);
index 91fa8e06b6a57712d716f1c3e9becd2c5118fc1a..73e28d35568841e5caebd9b8b0648c5b21bee0b4 100644 (file)
@@ -340,7 +340,7 @@ int blk_integrity_register(struct gendisk *disk, struct blk_integrity *template)
                kobject_uevent(&bi->kobj, KOBJ_ADD);
 
                bi->flags |= INTEGRITY_FLAG_READ | INTEGRITY_FLAG_WRITE;
-               bi->sector_size = disk->queue->hardsect_size;
+               bi->sector_size = queue_logical_block_size(disk->queue);
                disk->integrity = bi;
        } else
                bi = disk->integrity;
index 57af728d94bb08732e9d217a94dafe9bae9ef992..15c3164537b8fbd75bcfb306167ca7d6dbd0a675 100644 (file)
@@ -134,7 +134,7 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
        q->backing_dev_info.state = 0;
        q->backing_dev_info.capabilities = BDI_CAP_MAP_COPY;
        blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
-       blk_queue_hardsect_size(q, 512);
+       blk_queue_logical_block_size(q, 512);
        blk_queue_dma_alignment(q, 511);
        blk_queue_congestion_threshold(q);
        q->nr_batching = BLK_BATCH_REQ;
@@ -288,21 +288,20 @@ void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
 EXPORT_SYMBOL(blk_queue_max_segment_size);
 
 /**
- * blk_queue_hardsect_size - set hardware sector size for the queue
+ * blk_queue_logical_block_size - set logical block size for the queue
  * @q:  the request queue for the device
- * @size:  the hardware sector size, in bytes
+ * @size:  the logical block size, in bytes
  *
  * Description:
- *   This should typically be set to the lowest possible sector size
- *   that the hardware can operate on (possible without reverting to
- *   even internal read-modify-write operations). Usually the default
- *   of 512 covers most hardware.
+ *   This should be set to the lowest possible block size that the
+ *   storage device can address.  The default of 512 covers most
+ *   hardware.
  **/
-void blk_queue_hardsect_size(struct request_queue *q, unsigned short size)
+void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
 {
-       q->hardsect_size = size;
+       q->logical_block_size = size;
 }
-EXPORT_SYMBOL(blk_queue_hardsect_size);
+EXPORT_SYMBOL(blk_queue_logical_block_size);
 
 /*
  * Returns the minimum that is _not_ zero, unless both are zero.
@@ -324,7 +323,7 @@ void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
        t->max_phys_segments = min_not_zero(t->max_phys_segments, b->max_phys_segments);
        t->max_hw_segments = min_not_zero(t->max_hw_segments, b->max_hw_segments);
        t->max_segment_size = min_not_zero(t->max_segment_size, b->max_segment_size);
-       t->hardsect_size = max(t->hardsect_size, b->hardsect_size);
+       t->logical_block_size = max(t->logical_block_size, b->logical_block_size);
        if (!t->queue_lock)
                WARN_ON_ONCE(1);
        else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
index 3ff9bba3379a84891ddbc97450fcdbddf6e42a1a..13d38b7e4d0fa524fcedf30f6865872205a45a7b 100644 (file)
@@ -100,9 +100,9 @@ static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
        return queue_var_show(max_sectors_kb, (page));
 }
 
-static ssize_t queue_hw_sector_size_show(struct request_queue *q, char *page)
+static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
 {
-       return queue_var_show(q->hardsect_size, page);
+       return queue_var_show(queue_logical_block_size(q), page);
 }
 
 static ssize_t
@@ -249,7 +249,12 @@ static struct queue_sysfs_entry queue_iosched_entry = {
 
 static struct queue_sysfs_entry queue_hw_sector_size_entry = {
        .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
-       .show = queue_hw_sector_size_show,
+       .show = queue_logical_block_size_show,
+};
+
+static struct queue_sysfs_entry queue_logical_block_size_entry = {
+       .attr = {.name = "logical_block_size", .mode = S_IRUGO },
+       .show = queue_logical_block_size_show,
 };
 
 static struct queue_sysfs_entry queue_nonrot_entry = {
@@ -283,6 +288,7 @@ static struct attribute *default_attrs[] = {
        &queue_max_sectors_entry.attr,
        &queue_iosched_entry.attr,
        &queue_hw_sector_size_entry.attr,
+       &queue_logical_block_size_entry.attr,
        &queue_nonrot_entry.attr,
        &queue_nomerges_entry.attr,
        &queue_rq_affinity_entry.attr,
index f87615dea46bbd9dfcdf0789f170c2b9b8512f6a..9eaa1940273a903b6fff90e1557327d92b369c57 100644 (file)
@@ -763,7 +763,7 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
        case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
                return compat_put_int(arg, block_size(bdev));
        case BLKSSZGET: /* get block device hardware sector size */
-               return compat_put_int(arg, bdev_hardsect_size(bdev));
+               return compat_put_int(arg, bdev_logical_block_size(bdev));
        case BLKSECTGET:
                return compat_put_ushort(arg,
                                         bdev_get_queue(bdev)->max_sectors);
index ad474d4bbccee0232303c24ae381ade156ae44aa..7aa97f65da82e5a46c10c0876f9da7d16c8cbafc 100644 (file)
@@ -311,7 +311,7 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
        case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
                return put_int(arg, block_size(bdev));
        case BLKSSZGET: /* get block device hardware sector size */
-               return put_int(arg, bdev_hardsect_size(bdev));
+               return put_int(arg, bdev_logical_block_size(bdev));
        case BLKSECTGET:
                return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);
        case BLKRASET:
index e714e7cce6f27b2a3ede8e0cccf5c2c569723acc..94474f5f8bcee2d69409a8d8bcff4e1e74c099e9 100644 (file)
@@ -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);
index a02dcfc00f134e548cf15b0fbca1f515962d500f..44fa2018f6b027b8b5bb77504bef118a813168e3 100644 (file)
@@ -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;
index 961de56d00a946946a785a7f3508ac35d0633ff9..f65b3f369eb0ce795936045484cfdf9bb7367ac3 100644 (file)
@@ -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) {
                /*
index c0cd0a03f698590083759952b33a84bb3bba2c66..60de5a01e71e6ecd67b15eee29fef7d567265872 100644 (file)
@@ -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;
index dc7a8c352da2e7c5b44a3d9a4e7a02bfd029d0c2..293f5858921d483e6198385d661aae93fa41efa8 100644 (file)
@@ -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;
index 338cee4cc0ba4cf4c9222203a6cc52fe85e228cd..aaeeb544228a322efc790482f206f48afdf829a8 100644 (file)
@@ -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);
index e67bbae9547d1b3ac42cbbd1a243911789dbb94b..cc54473b8e77fa857d37eff69a053ff16b20c89c 100644 (file)
@@ -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;
index 511d4ae2d1764cb6816bd07cbc014e6bc55802cd..c4845b169464025b9f2207d3a8c6534ad1bf5452 100644 (file)
@@ -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;
index 132120ae4bde5958beb2de21c181d70559635869..c1996829d5ecb92231042afd0cdc90ee7b4ad186 100644 (file)
@@ -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. */
index 3a4397edab71a25b2de8216a17ce9cbc7232add8..f08491a3a813b84e83df249196636c8829466cf7 100644 (file)
@@ -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
index 1e366ad8f68069b8c15fc2d0c66fee2d09074bf7..b5621f27c4be8052192a56b29f83bd95820594e9 100644 (file)
@@ -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 */
index f177c2d4017f445711cb2422c1bb4d5d66f0d490..0fff646cc2f0904bc5539d052628420e899a0957 100644 (file)
@@ -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);
index 20d90e6a6e50fb41dfdd2601b1ae6617c40a6070..db32f0e4c7dd48aaef0f1022627a4bebaded6f39 100644 (file)
@@ -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;
index 1799328decfb1c79ccf86cf1eb136a6194d410d7..424140c6c400e6f524c91f72758cb7fb59816b4f 100644 (file)
@@ -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"
index 47c68bc75a1780be7e1b6679e64d8ee8b6e860e9..06b0ded1ce23071d12c89dd3d379f9925f968c92 100644 (file)
@@ -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
                         */
index a2e26c24214150cac23e92acf1391a212d60271b..75d8081a904175bcff7d3199c2deba4140fc6086 100644 (file)
@@ -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;
        }
index be233bc4d91787a2729ef8ca740a946ddc782332..6fa8ccf91c70e70174d578e10b8793b884a86406 100644 (file)
@@ -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",
index e75c6dd76a9adfb3b374aa9cc6d48a2db14596be..2662a41337e7813b370df2d61dbfc70e964e066a 100644 (file)
@@ -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;
index 429b50b975d5a14af8c8e97412425ae9169784d3..65e2d9759857d9b0ef06332b0412b836aee54d9c 100644 (file)
@@ -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;
index fccc8343a2501dbb8db452ea9e5469df11ef53e1..4cbc19f5c3047f93578d655ef426f69e04bcb1fb 100644 (file)
@@ -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;
 
index c0bebc6a2f2ccbb1cab1298f0fdfd396316928b0..7847bbc1440d6edd912e918821c248c6e20d0ee7 100644 (file)
@@ -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);
index 6573ef4408f1dc66141acbc4c6038fd84b08acbd..335d4c78a775122ea0e6738aed84a31d7dd4d47b 100644 (file)
@@ -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);
 
index c5df86546458d1da54f9a0bd778e7957d2357e2e..98ffc41eaf2c631bebdfed37a9847b17f28b97cd 100644 (file)
@@ -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)) {
                /*
index 502622f628bc0dfb8e988a86833bc10dc5710c58..aaac3b6800b7358dd1597df13c0ea781d3215031 100644 (file)
@@ -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);
index e64f62d5e0fc503f2fe7533c741778be1a5092d1..27a1be0cd4d467a1b3c4ba1d6ab501d3b4ea2fdf 100644 (file)
@@ -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);
index cfdcf1aed33c282115e50cf2d6dddd0b96ff5b42..a4c7ffcd9987adb6dcec33687181597c84662ec9 100644 (file)
@@ -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
index 76814f3e898a9c444dca70b4ddfc0cd7d885847c..0ae0c83ef87903e9121b76e14ae372dd2e40b8d1 100644 (file)
@@ -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);
        }
 
        /*
index 1e796767598056616ed6b3265ed27855fd77d40a..47ff695255ea649f1f0296ed7f6f602ee1d4f9ac 100644 (file)
@@ -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);
index 40d2860f235a3d2d85bed42b95a24ddc2a180f68..bcf3bd40bbd5fc3bfbecb29f0d7b21b5e393c8b3 100644 (file)
@@ -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];
index fddba53c7fe51480399d354089d5ba3d485f28f4..cd350dfc1216f290554ec0cd5c732e866492644b 100644 (file)
@@ -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;
 }
index 81dc93e72535f299b8df7687a2cfa818fcbe4d00..4445c38217304b5eaf934c0c96c1defc92a67e98 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -1490,11 +1490,12 @@ struct bio_pair *bio_split(struct bio *bi, int first_sectors)
 sector_t bio_sector_offset(struct bio *bio, unsigned short index,
                           unsigned int offset)
 {
-       unsigned int sector_sz = queue_hardsect_size(bio->bi_bdev->bd_disk->queue);
+       unsigned int sector_sz;
        struct bio_vec *bv;
        sector_t sectors;
        int i;
 
+       sector_sz = queue_logical_block_size(bio->bi_bdev->bd_disk->queue);
        sectors = 0;
 
        if (index >= bio->bi_idx)
index a85fe310fc6feb20a86fcc758d7673fce6b82ef4..a29b4dcc1bca2e3b8f56252261624e3c1fafacf4 100644 (file)
@@ -76,7 +76,7 @@ int set_blocksize(struct block_device *bdev, int size)
                return -EINVAL;
 
        /* Size cannot be smaller than the size supported by the device */
-       if (size < bdev_hardsect_size(bdev))
+       if (size < bdev_logical_block_size(bdev))
                return -EINVAL;
 
        /* Don't change the size if it is same as current */
@@ -106,7 +106,7 @@ EXPORT_SYMBOL(sb_set_blocksize);
 
 int sb_min_blocksize(struct super_block *sb, int size)
 {
-       int minsize = bdev_hardsect_size(sb->s_bdev);
+       int minsize = bdev_logical_block_size(sb->s_bdev);
        if (size < minsize)
                size = minsize;
        return sb_set_blocksize(sb, size);
@@ -1117,7 +1117,7 @@ EXPORT_SYMBOL(check_disk_change);
 
 void bd_set_size(struct block_device *bdev, loff_t size)
 {
-       unsigned bsize = bdev_hardsect_size(bdev);
+       unsigned bsize = bdev_logical_block_size(bdev);
 
        bdev->bd_inode->i_size = size;
        while (bsize < PAGE_CACHE_SIZE) {
index aed297739eb0796d8c6212842003fb2976c5fba0..36e2bbc60ec75332cd0417aedc42f52b6e8c53f4 100644 (file)
@@ -1085,12 +1085,12 @@ static struct buffer_head *
 __getblk_slow(struct block_device *bdev, sector_t block, int size)
 {
        /* Size must be multiple of hard sectorsize */
-       if (unlikely(size & (bdev_hardsect_size(bdev)-1) ||
+       if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
                        (size < 512 || size > PAGE_SIZE))) {
                printk(KERN_ERR "getblk(): invalid block size %d requested\n",
                                        size);
-               printk(KERN_ERR "hardsect size: %d\n",
-                                       bdev_hardsect_size(bdev));
+               printk(KERN_ERR "logical block size: %d\n",
+                                       bdev_logical_block_size(bdev));
 
                dump_stack();
                return NULL;
index 05763bbc2050b8ed917d593275b6ba37d1e8282b..8b10b87dc01a294845aac2afd1a2d22ae5a269b2 100644 (file)
@@ -1127,7 +1127,7 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
                rw = WRITE_ODIRECT;
 
        if (bdev)
-               bdev_blkbits = blksize_bits(bdev_hardsect_size(bdev));
+               bdev_blkbits = blksize_bits(bdev_logical_block_size(bdev));
 
        if (offset & blocksize_mask) {
                if (bdev)
index 599dbfe504c39ef8370dd28a4c65aa05346499b4..acbb94fdf90378cf9b6cc0ea07564a60cc81a1c8 100644 (file)
@@ -1696,7 +1696,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                goto failed_mount;
        }
 
-       hblock = bdev_hardsect_size(sb->s_bdev);
+       hblock = bdev_logical_block_size(sb->s_bdev);
        if (sb->s_blocksize != blocksize) {
                /*
                 * Make sure the blocksize for the filesystem is larger
@@ -2119,7 +2119,7 @@ static journal_t *ext3_get_dev_journal(struct super_block *sb,
        }
 
        blocksize = sb->s_blocksize;
-       hblock = bdev_hardsect_size(bdev);
+       hblock = bdev_logical_block_size(bdev);
        if (blocksize < hblock) {
                printk(KERN_ERR
                        "EXT3-fs: blocksize too small for journal device.\n");
index 2958f4e6f222a8956f595145b1fe31e16e4eec9d..a30549f7a3053eade6cc042abe5d9c2bef726ddc 100644 (file)
@@ -2962,7 +2962,7 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
        }
 
        blocksize = sb->s_blocksize;
-       hblock = bdev_hardsect_size(bdev);
+       hblock = bdev_logical_block_size(bdev);
        if (blocksize < hblock) {
                printk(KERN_ERR
                        "EXT4-fs: blocksize too small for journal device.\n");
index 1ff9473ea7531999436b20d618ce142853abef3e..a3b2ac989fc35e9f87e3a0c48b9dad729c5cfec8 100644 (file)
@@ -526,11 +526,11 @@ static int init_sb(struct gfs2_sbd *sdp, int silent)
        }
 
        /* Set up the buffer cache and SB for real */
-       if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
+       if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
                ret = -EINVAL;
                fs_err(sdp, "FS block size (%u) is too small for device "
                       "block size (%u)\n",
-                      sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
+                      sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
                goto out;
        }
        if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
index 565038243fa2bcc6139ceb5b2bcfeeb107df6c73..a971d24e10ce5c5ffb2a5445f8c4442cffcd97e1 100644 (file)
@@ -845,7 +845,7 @@ static void gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
        struct super_block *sb = sdp->sd_vfs;
        struct block_device *bdev = sb->s_bdev;
        const unsigned int sects_per_blk = sdp->sd_sb.sb_bsize /
-                                          bdev_hardsect_size(sb->s_bdev);
+                                          bdev_logical_block_size(sb->s_bdev);
        u64 blk;
        sector_t start = 0;
        sector_t nr_sects = 0;
index 7f65b3be4aa91dba3b923b3fd47e25ee3f7db68a..a91f15b8673c3c1ed8728ab5db8bd479e1ea6a70 100644 (file)
@@ -515,7 +515,7 @@ int init_nilfs(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi, char *data)
 
        blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);
        if (sb->s_blocksize != blocksize) {
-               int hw_blocksize = bdev_hardsect_size(sb->s_bdev);
+               int hw_blocksize = bdev_logical_block_size(sb->s_bdev);
 
                if (blocksize < hw_blocksize) {
                        printk(KERN_ERR
index f76951dcd4a6e984f2469b06df80dd0aa9e96891..6aa7c4713536636b08df670c9efb030640730489 100644 (file)
@@ -25,7 +25,7 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/spinlock.h>
-#include <linux/blkdev.h>      /* For bdev_hardsect_size(). */
+#include <linux/blkdev.h>      /* For bdev_logical_block_size(). */
 #include <linux/backing-dev.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
@@ -2785,13 +2785,13 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                goto err_out_now;
 
        /* We support sector sizes up to the PAGE_CACHE_SIZE. */
-       if (bdev_hardsect_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
+       if (bdev_logical_block_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
                if (!silent)
                        ntfs_error(sb, "Device has unsupported sector size "
                                        "(%i).  The maximum supported sector "
                                        "size on this architecture is %lu "
                                        "bytes.",
-                                       bdev_hardsect_size(sb->s_bdev),
+                                       bdev_logical_block_size(sb->s_bdev),
                                        PAGE_CACHE_SIZE);
                goto err_out_now;
        }
index 4f85eceab376015596adbafae5b9eb774211e2b1..09cc25d04611bfac57adfd422ba519a1c7a5664b 100644 (file)
@@ -1371,7 +1371,7 @@ static ssize_t o2hb_region_dev_write(struct o2hb_region *reg,
 
        bdevname(reg->hr_bdev, reg->hr_dev_name);
 
-       sectsize = bdev_hardsect_size(reg->hr_bdev);
+       sectsize = bdev_logical_block_size(reg->hr_bdev);
        if (sectsize != reg->hr_block_bytes) {
                mlog(ML_ERROR,
                     "blocksize %u incorrect for device, expected %d",
index 79ff8d9d37e0844252130272309cd5853b04445e..5c6163f550393a1e0a50f9f513d1ad3f185a6ab2 100644 (file)
@@ -713,7 +713,7 @@ static int ocfs2_sb_probe(struct super_block *sb,
        *bh = NULL;
 
        /* may be > 512 */
-       *sector_size = bdev_hardsect_size(sb->s_bdev);
+       *sector_size = bdev_logical_block_size(sb->s_bdev);
        if (*sector_size > OCFS2_MAX_BLOCKSIZE) {
                mlog(ML_ERROR, "Hardware sector size too large: %d (max=%d)\n",
                     *sector_size, OCFS2_MAX_BLOCKSIZE);
index 46297683cd34bbaf4b0396172159ab21cd575baa..fc71aab084603749abc8138ee860c2f17faa05fa 100644 (file)
@@ -76,7 +76,7 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
        Sector sect;
 
        res = 0;
-       blocksize = bdev_hardsect_size(bdev);
+       blocksize = bdev_logical_block_size(bdev);
        if (blocksize <= 0)
                goto out_exit;
        i_size = i_size_read(bdev->bd_inode);
index 796511886f285804060ddd62390012751da14685..0028d2ef0662b0f01fd21b7685754d9939ebbd51 100644 (file)
@@ -110,7 +110,7 @@ parse_extended(struct parsed_partitions *state, struct block_device *bdev,
        Sector sect;
        unsigned char *data;
        u32 this_sector, this_size;
-       int sector_size = bdev_hardsect_size(bdev) / 512;
+       int sector_size = bdev_logical_block_size(bdev) / 512;
        int loopct = 0;         /* number of links followed
                                   without finding a data partition */
        int i;
@@ -415,7 +415,7 @@ static struct {
  
 int msdos_partition(struct parsed_partitions *state, struct block_device *bdev)
 {
-       int sector_size = bdev_hardsect_size(bdev) / 512;
+       int sector_size = bdev_logical_block_size(bdev) / 512;
        Sector sect;
        unsigned char *data;
        struct partition *p;
index 72348cc855a45dd25126aaba8557772e0d4b491d..0ba44107d8f109af092106d6663e0a06df9de219 100644 (file)
@@ -1915,7 +1915,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
        if (uopt.flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) {
                ret = udf_load_vrs(sb, &uopt, silent, &fileset);
        } else {
-               uopt.blocksize = bdev_hardsect_size(sb->s_bdev);
+               uopt.blocksize = bdev_logical_block_size(sb->s_bdev);
                ret = udf_load_vrs(sb, &uopt, silent, &fileset);
                if (!ret && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
                        if (!silent)
index e28800a9f2b53890a1357a5db5d44da4943337f9..1418b916fc2755306cca61e60c734154d543c82f 100644 (file)
@@ -1501,7 +1501,7 @@ xfs_setsize_buftarg_early(
        struct block_device     *bdev)
 {
        return xfs_setsize_buftarg_flags(btp,
-                       PAGE_CACHE_SIZE, bdev_hardsect_size(bdev), 0);
+                       PAGE_CACHE_SIZE, bdev_logical_block_size(bdev), 0);
 }
 
 int
index 56ce53fce72eeabd7452b696c9fc024f12f4a423..872b78b7a1014dc3038f3ecd567328f98e7624f8 100644 (file)
@@ -391,7 +391,7 @@ struct request_queue
        unsigned int            max_hw_sectors;
        unsigned short          max_phys_segments;
        unsigned short          max_hw_segments;
-       unsigned short          hardsect_size;
+       unsigned short          logical_block_size;
        unsigned int            max_segment_size;
 
        unsigned long           seg_boundary_mask;
@@ -901,7 +901,7 @@ extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
-extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
+extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
 extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
@@ -988,19 +988,19 @@ extern void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter);
 
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
 
-static inline int queue_hardsect_size(struct request_queue *q)
+static inline unsigned short queue_logical_block_size(struct request_queue *q)
 {
        int retval = 512;
 
-       if (q && q->hardsect_size)
-               retval = q->hardsect_size;
+       if (q && q->logical_block_size)
+               retval = q->logical_block_size;
 
        return retval;
 }
 
-static inline int bdev_hardsect_size(struct block_device *bdev)
+static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
 {
-       return queue_hardsect_size(bdev_get_queue(bdev));
+       return queue_logical_block_size(bdev_get_queue(bdev));
 }
 
 static inline int queue_dma_alignment(struct request_queue *q)
index ded2d7c42668ccc396f193ae3c157cf0ea024133..49c2362977fde10457c72d00e3672ba71142cd42 100644 (file)
@@ -149,7 +149,7 @@ struct io_restrictions {
        unsigned max_hw_sectors;
        unsigned max_sectors;
        unsigned max_segment_size;
-       unsigned short hardsect_size;
+       unsigned short logical_block_size;
        unsigned short max_hw_segments;
        unsigned short max_phys_segments;
        unsigned char no_cluster; /* inverted so that 0 is default */