On Thu, Apr 23 2009, Martin K. Petersen wrote:
> To support devices with physical block sizes bigger than 512 bytes we
> need to ensure proper alignment. This patch adds support for exposing
> I/O topology characteristics as devices are stacked.
>
> hardsect_size remains unchanged. It is the smallest atomic unit the
> device can address (i.e. logical block size).
>
> granularity indicates the smallest I/O the device can access without
> incurring a read-modify-write penalty. The granularity is set by
> low-level drivers from then on it is purely internal to the stacking
> logic.
>
> The min_io parameter is the smallest preferred I/O size reported by
> the device. In many cases this is the same as granularity. However,
> the min_io parameter can be scaled up when stacking (RAID5 chunk
> size > physical sector size). min_io is available in sysfs.
>
> The opt_io characteristic indicates the preferred I/O size reported by
> the device. This is usually the stripe width for arrays. The value
> is in sysfs.
>
> The alignment parameter indicates the number of bytes the start of the
> device/partition is offset from the device granularity. Partition
> tools and MD/DM tools can use this to align filesystems to the proper
> boundaries.
>
> Signed-off-by: Martin K. Petersen <martin.petersen@xxxxxxxxxx>
>
> ---
> 6 files changed, 204 insertions(+), 4 deletions(-)
> block/blk-settings.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++--
> block/blk-sysfs.c | 22 +++++++
> block/genhd.c | 10 +++
> fs/partitions/check.c | 10 +++
> include/linux/blkdev.h | 30 ++++++++++
> include/linux/genhd.h | 1
>
>
>
> diff --git a/block/blk-settings.c b/block/blk-settings.c
> --- a/block/blk-settings.c
> +++ b/block/blk-settings.c
> @@ -292,22 +292,87 @@ EXPORT_SYMBOL(blk_queue_max_segment_size
> *
> * 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.
> + * (logical block size) that the hardware can operate on. Usually the
> + * default of 512 covers most hardware.
> **/
> void blk_queue_hardsect_size(struct request_queue *q, unsigned short size)
> {
> - q->hardsect_size = size;
> + q->hardsect_size = q->granularity = size;
> }
> EXPORT_SYMBOL(blk_queue_hardsect_size);
>
> +/**
> + * blk_queue_granularity - set I/O granularity for the queue
> + * @q: the request queue for the device
> + * @size: the I/O granularity, in bytes
> + *
> + * Description:
> + * This should typically be set to the lowest possible sector size
> + * that the hardware can operate on without reverting to
> + * read-modify-write operations.
> + **/
> +void blk_queue_granularity(struct request_queue *q, unsigned short size)
> +{
> + q->granularity = size;
> +}
> +EXPORT_SYMBOL(blk_queue_granularity);
> +
> +/**
> + * blk_queue_alignment - set alignment for the queue
> + * @q: the request queue for the device
> + * @alignment: alignment offset in bytes
> + *
> + * Description:
> + * Some devices are naturally misaligned to compensate for things like
> + * the legacy DOS partition table 63-sector offset. Low-level drivers
> + * should call this function for devices whose first sector is not
> + * naturally aligned.
> + */
> +void blk_queue_alignment(struct request_queue *q, unsigned int alignment)
> +{
> + q->alignment = alignment & (q->granularity - 1);
> + clear_bit(QUEUE_FLAG_MISALIGNED, &q->queue_flags);
> +}
> +EXPORT_SYMBOL(blk_queue_alignment);
How would low-level drivers know?
> +
> /*
> * Returns the minimum that is _not_ zero, unless both are zero.
> */
> #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
>
> /**
> + * blk_queue_min_io - set minimum request size for the queue
> + * @q: the request queue for the device
> + * @min_io: smallest I/O size in bytes
> + *
> + * Description:
> + * Some devices have an internal block size bigger than the reported
> + * hardware sector size. This function can be used to signal the
> + * smallest I/O the device can perform without incurring a performance
> + * penalty.
> + */
> +void blk_queue_min_io(struct request_queue *q, unsigned int min_io)
> +{
> + q->min_io = min_io;
> +}
> +EXPORT_SYMBOL(blk_queue_min_io);
> +
> +/**
> + * blk_queue_opt_io - set optimal request size for the queue
> + * @q: the request queue for the device
> + * @opt_io: optimal request size in bytes
> + *
> + * Description:
> + * Drivers can call this function to set the preferred I/O request
> + * size for devices that report such a value.
> + */
> +void blk_queue_opt_io(struct request_queue *q, unsigned int opt_io)
> +{
> + q->opt_io = opt_io;
> +}
> +EXPORT_SYMBOL(blk_queue_opt_io);
> +
> +/**
> * blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
> * @t: the stacking driver (top)
> * @b: the underlying device (bottom)
> @@ -335,6 +400,68 @@ void blk_queue_stack_limits(struct reque
> EXPORT_SYMBOL(blk_queue_stack_limits);
>
> /**
> + * blk_queue_stack_topology - adjust queue limits for stacked drivers
> + * @t: the stacking driver (top)
> + * @bdev: the underlying block device (bottom)
> + * @offset: offset to beginning of data within component device
> + **/
> +void blk_queue_stack_topology(struct request_queue *t, struct block_device *bdev,
> + sector_t offset)
> +{
> + struct request_queue *b = bdev_get_queue(bdev);
> + int misaligned;
> +
> + /* zero is "infinity" */
> + t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
> + t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
> + t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, b->seg_boundary_mask);
> +
> + 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->min_io = max(t->min_io, b->min_io);
> + t->granularity = max(t->granularity, b->granularity);
> +
> + misaligned = 0;
> + offset += get_start_sect(bdev) << 9;
> +
> + /* Bottom device offset aligned? */
> + if (offset && (offset & (b->granularity - 1)) != b->alignment) {
> + misaligned = 1;
> + goto out;
> + }
> +
> + /* If top has no alignment, inherit from bottom */
> + if (!t->alignment)
> + t->alignment = b->alignment & (b->granularity - 1);
> +
> + /* Top alignment on logical block boundary? */
> + if (t->alignment & (t->hardsect_size - 1)) {
> + misaligned = 1;
> + goto out;
> + }
> +
> +out:
> + if (!t->queue_lock)
> + WARN_ON_ONCE(1);
> + else if (misaligned || !test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
> + unsigned long flags;
> +
> + spin_lock_irqsave(t->queue_lock, flags);
> +
> + if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
> + queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
> +
> + if (misaligned)
> + queue_flag_set(QUEUE_FLAG_MISALIGNED, t);
> +
> + spin_unlock_irqrestore(t->queue_lock, flags);
> + }
> +}
> +EXPORT_SYMBOL(blk_queue_stack_topology);
> +
> +/**
> * blk_queue_dma_pad - set pad mask
> * @q: the request queue for the device
> * @mask: pad mask
> diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
> --- a/block/blk-sysfs.c
> +++ b/block/blk-sysfs.c
> @@ -105,6 +105,16 @@ static ssize_t queue_hw_sector_size_show
> return queue_var_show(q->hardsect_size, page);
> }
>
> +static ssize_t queue_min_io_show(struct request_queue *q, char *page)
> +{
> + return queue_var_show(q->min_io, page);
> +}
> +
> +static ssize_t queue_opt_io_show(struct request_queue *q, char *page)
> +{
> + return queue_var_show(q->opt_io, page);
> +}
> +
> static ssize_t
> queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
> {
> @@ -256,6 +266,16 @@ static struct queue_sysfs_entry queue_hw
> .show = queue_hw_sector_size_show,
> };
>
> +static struct queue_sysfs_entry queue_min_io_entry = {
> + .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
> + .show = queue_min_io_show,
> +};
> +
> +static struct queue_sysfs_entry queue_opt_io_entry = {
> + .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
> + .show = queue_opt_io_show,
> +};
> +
> static struct queue_sysfs_entry queue_nonrot_entry = {
> .attr = {.name = "rotational", .mode = S_IRUGO | S_IWUSR },
> .show = queue_nonrot_show,
> @@ -287,6 +307,8 @@ static struct attribute *default_attrs[]
> &queue_max_sectors_entry.attr,
> &queue_iosched_entry.attr,
> &queue_hw_sector_size_entry.attr,
> + &queue_min_io_entry.attr,
> + &queue_opt_io_entry.attr,
> &queue_nonrot_entry.attr,
> &queue_nomerges_entry.attr,
> &queue_rq_affinity_entry.attr,
> diff --git a/block/genhd.c b/block/genhd.c
> --- a/block/genhd.c
> +++ b/block/genhd.c
> @@ -848,11 +848,20 @@ static ssize_t disk_capability_show(stru
> return sprintf(buf, "%x\n", disk->flags);
> }
>
> +static ssize_t disk_alignment_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct gendisk *disk = dev_to_disk(dev);
> +
> + return sprintf(buf, "%d\n", queue_alignment(disk->queue));
> +}
> +
> static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
> static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
> static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
> static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
> static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
> +static DEVICE_ATTR(alignment, S_IRUGO, disk_alignment_show, NULL);
> static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
> static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
> #ifdef CONFIG_FAIL_MAKE_REQUEST
> @@ -871,6 +880,7 @@ static struct attribute *disk_attrs[] =
> &dev_attr_removable.attr,
> &dev_attr_ro.attr,
> &dev_attr_size.attr,
> + &dev_attr_alignment.attr,
> &dev_attr_capability.attr,
> &dev_attr_stat.attr,
> #ifdef CONFIG_FAIL_MAKE_REQUEST
> diff --git a/fs/partitions/check.c b/fs/partitions/check.c
> --- a/fs/partitions/check.c
> +++ b/fs/partitions/check.c
> @@ -219,6 +219,13 @@ ssize_t part_size_show(struct device *de
> return sprintf(buf, "%llu\n",(unsigned long long)p->nr_sects);
> }
>
> +ssize_t part_alignment_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct hd_struct *p = dev_to_part(dev);
> + return sprintf(buf, "%llu\n", (unsigned long long)p->alignment);
> +}
> +
> ssize_t part_stat_show(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> @@ -272,6 +279,7 @@ ssize_t part_fail_store(struct device *d
> static DEVICE_ATTR(partition, S_IRUGO, part_partition_show, NULL);
> static DEVICE_ATTR(start, S_IRUGO, part_start_show, NULL);
> static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
> +static DEVICE_ATTR(alignment, S_IRUGO, part_alignment_show, NULL);
> static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
> #ifdef CONFIG_FAIL_MAKE_REQUEST
> static struct device_attribute dev_attr_fail =
> @@ -282,6 +290,7 @@ static struct attribute *part_attrs[] =
> &dev_attr_partition.attr,
> &dev_attr_start.attr,
> &dev_attr_size.attr,
> + &dev_attr_alignment.attr,
> &dev_attr_stat.attr,
> #ifdef CONFIG_FAIL_MAKE_REQUEST
> &dev_attr_fail.attr,
> @@ -383,6 +392,7 @@ struct hd_struct *add_partition(struct g
> pdev = part_to_dev(p);
>
> p->start_sect = start;
> + p->alignment = queue_sector_alignment(disk->queue, start);
> p->nr_sects = len;
> p->partno = partno;
> p->policy = get_disk_ro(disk);
> diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
> --- a/include/linux/blkdev.h
> +++ b/include/linux/blkdev.h
> @@ -402,6 +402,10 @@ struct request_queue
> unsigned short max_hw_segments;
> unsigned short hardsect_size;
> unsigned int max_segment_size;
> + unsigned int alignment;
> + unsigned int granularity;
> + unsigned int min_io;
> + unsigned int opt_io;
>
> unsigned long seg_boundary_mask;
> void *dma_drain_buffer;
Patch looks fine, but can we group these by name please? alignment could
be anything.
+ unsigned int io_alignment;
+ unsigned int io_granularity;
+ unsigned int io_min;
+ unsigned int io_opt;
>
> @@ -461,6 +465,7 @@ struct request_queue
> #define QUEUE_FLAG_NONROT 14 /* non-rotational device (SSD) */
> #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */
> #define QUEUE_FLAG_IO_STAT 15 /* do IO stats */
> +#define QUEUE_FLAG_MISALIGNED 16 /* bdev not aligned to disk */
>
> #define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
> (1 << QUEUE_FLAG_CLUSTER) | \
> @@ -877,7 +882,15 @@ extern void blk_queue_max_phys_segments(
> 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_granularity(struct request_queue *, unsigned short);
> +extern void blk_queue_alignment(struct request_queue *q,
> + unsigned int alignment);
> +extern void blk_queue_min_io(struct request_queue *q, unsigned int min_io);
> +extern void blk_queue_opt_io(struct request_queue *q, unsigned int opt_io);
> extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
> +extern void blk_queue_stack_topology(struct request_queue *t,
> + struct block_device *bdev,
> + sector_t offset);
> extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
> extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
> extern int blk_queue_dma_drain(struct request_queue *q,
> @@ -978,6 +991,23 @@ static inline int bdev_hardsect_size(str
> return queue_hardsect_size(bdev_get_queue(bdev));
> }
>
> +static inline int queue_alignment(struct request_queue *q)
> +{
> + if (q && test_bit(QUEUE_FLAG_MISALIGNED, &q->queue_flags))
> + return -1;
> +
> + if (q && q->alignment)
> + return q->alignment;
> +
> + return 0;
> +}
> +
> +static inline int queue_sector_alignment(struct request_queue *q,
> + sector_t sector)
> +{
> + return ((sector << 9) - q->alignment) & (q->min_io - 1);
> +}
> +
> static inline int queue_dma_alignment(struct request_queue *q)
> {
> return q ? q->dma_alignment : 511;
> diff --git a/include/linux/genhd.h b/include/linux/genhd.h
> --- a/include/linux/genhd.h
> +++ b/include/linux/genhd.h
> @@ -90,6 +90,7 @@ struct disk_stats {
> struct hd_struct {
> sector_t start_sect;
> sector_t nr_sects;
> + sector_t alignment;
> struct device __dev;
> struct kobject *holder_dir;
> int policy, partno;
>
>
--
Jens Axboe
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
