dm table: alignment and topology support
cover dm table: alignment and topology support
The first 2 patches refresh what has already been in linux-next (from Alasdair's DM quilt tree). The last patch builds on Martin Peterson's topology work that has been added to Jens' linux-2.6-block.git for-next tree.
I have published a quilt tree that builds on 2.6.30-rc7 here:
http://people.redhat.com/msnitzer/patches/dm-topology/
Mike Snitzer (3):
dm-table-ensure-targets-are-aligned-to-logical_block_size dm-table-validate-device-logical_block_size dm-topology-support
drivers/md/dm-table.c | 261 ++++++++++++++++++++++++----------------- include/linux/device-mapper.h | 16 +--- 2 files changed, 156 insertions(+), 121 deletions(-)
PATCH 1/3 dm table: ensure targets are aligned to logical_block_size
Ensure I/O is aligned to the logical_block_size of target devices.
Rename check_device_area() to device_area_is_valid() for clarity and establish the device limits including the logical block size prior to calling it.
--- drivers/md/dm-table.c | 57 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 44 insertions(+), 13 deletions(-)
drivers/md/dm-table.c +44 -13
@@ -385,15 +385,45 @@ static void close_dev(struct dm_dev_inte/* * If possible, this checks an area of a destination device is valid. */ -static int check_device_area (struct dm_dev_internal *dd,sector_t start, -sector_t len) +static int device_area_is_valid (struct dm_target *ti,struct block_device *bdev, +sector_t start,sector_t len) { -sector_t dev_size = dd->dm_dev.bdev->bd_inode->i_size >>SECTOR_SHIFT ; +sector_t dev_size = bdev->bd_inode->i_size >>SECTOR_SHIFT ; +unsigned short logical_block_size_sectors = + ti->limits.logical_block_size >>SECTOR_SHIFT ; +char b[BDEVNAME_SIZE ];if (!dev_size)return 1 ; -return ((start < dev_size) && (len <= (dev_size - start))); +if ((start >= dev_size) || (start + len > dev_size)) { +DMWARN ("%s: %s too small for target" , +dm_device_name (ti->table->md),bdevname (bdev, b)); +return 0 ; + } + +if (logical_block_size_sectors <=1 ) +return 1 ; + +if (start & (logical_block_size_sectors -1 )) { +DMWARN ("%s: start=%llu not aligned to h/w " +"logical_block_size %hu of %s" , +dm_device_name (ti->table->md), + (unsigned long long )start, + ti->limits.logical_block_size,bdevname (bdev, b)); +return 0 ; + } + +if (len & (logical_block_size_sectors -1 )) { +DMWARN ("%s: len=%llu not aligned to h/w " +"logical_block_size %hu of %s" , +dm_device_name (ti->table->md), + (unsigned long long )len, + ti->limits.logical_block_size,bdevname (bdev, b)); +return 0 ; + } + +return 1 ; }/*
@@ -479,14 +509,7 @@ static int __table_get_device(struct dm_ }atomic_inc (&dd->count); -if (!check_device_area (dd, start, len)) { -DMWARN ("device %s too small for target" , path); -dm_put_device (ti, &dd->dm_dev); -return -EINVAL ; - } - *result = &dd->dm_dev; -return 0 ; }
@@ -555,8 +578,16 @@ int dm_get_device(struct dm_target *ti,int r =__table_get_device (ti->table, ti, path, start, len, mode, result); -if (!r) -dm_set_device_limits (ti, (*result)->bdev); +if (r) +return r; + +dm_set_device_limits (ti, (*result)->bdev); + +if (!device_area_is_valid (ti, (*result)->bdev, start, len)) { +dm_put_device (ti, *result); + *result =NULL ; +return -EINVAL ; + }return r; }
PATCH 2/3 dm table: validate device logical_block_size
In reply to Mike SnitzerImpose necessary and sufficient conditions on a devices's table such that any incoming bio which respects its logical_block_size can be processed successfully.
--- drivers/md/dm-table.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+)
drivers/md/dm-table.c +69 -0
@@ -726,6 +726,71 @@ static void check_for_valid_limits(struc rs->bounce_pfn =-1 ; } +/* +* Impose necessary and sufficient conditions on a devices's table such +* that any incoming bio which respects its logical_block_size can be +* processed successfully. If it falls across the boundary between +* two or more targets, the size of each piece it gets split into must +* be compatible with the logical_block_size of the target processing it. +*/ +static int validate_hardware_logical_block_alignment (struct dm_table *table) +{ +/* +* This function uses arithmetic modulo the logical_block_size +* (in units of 512-byte sectors). +*/ +unsigned short device_logical_block_size_sects = + table->limits.logical_block_size >>SECTOR_SHIFT ; + +/* +* Offset of the start of the next table entry, mod logical_block_size. +*/ +unsigned short next_target_start =0 ; + +/* +* Given an aligned bio that extends beyond the end of a +* target, how many sectors must the next target handle? +*/ +unsigned short remaining =0 ; + +struct dm_target *uninitialized_var (ti ); +unsigned i =0 ; + +/* +* Check each entry in the table in turn. +*/ +while (i <dm_table_get_num_targets (table)) { + ti =dm_table_get_target (table, i++); + +/* +* If the remaining sectors fall entirely within this +* table entry are they compatible with its logical_block_size? +*/ +if (remaining < ti->len && + remaining & ((ti->limits.logical_block_size >> +SECTOR_SHIFT ) -1 )) +break ;/* Error */ + + next_target_start = + (unsigned short ) ((next_target_start + ti->len) & + (device_logical_block_size_sects -1 )); + remaining = next_target_start ? + device_logical_block_size_sects - next_target_start :0 ; + } + +if (remaining) { +DMWARN ("%s: table line %u (start sect %llu len %llu) " +"not aligned to h/w logical_block_size %hu" , +dm_device_name (table->md), i, + (unsigned long long ) ti->begin, + (unsigned long long ) ti->len, + table->limits.logical_block_size); +return -EINVAL ; + } + +return 0 ; +} +int dm_table_add_target (struct dm_table *t,const char *type,sector_t start,sector_t len,char *params) {
@@ -825,6 +890,10 @@ int dm_table_complete(struct dm_table *tcheck_for_valid_limits (&t->limits); + r =validate_hardware_logical_block_alignment (t); +if (r) +return r; +/* how many indexes will the btree have ? */ leaf_nodes =dm_div_up (t->num_targets,KEYS_PER_NODE ); t->depth =1 +int_log (leaf_nodes,CHILDREN_PER_NODE );
PATCH 3/3 dm: add topology support
In reply to Mike SnitzerUse blk_stack_limits() to stack block limits (including topology) rather than duplicate the equivalent within Device Mapper.
dm_table_set_restrictions() and check_for_valid_limits() must still track the queue_limits structure's members. To that end, physical_block_size and other topology limit changes were added.
--- drivers/md/dm-table.c | 134 ++++++++++++------------------------------ include/linux/device-mapper.h | 16 ----- 2 files changed, 42 insertions(+), 108 deletions(-)
drivers/md/dm-table.c +40 -94
@@ -66,7 +66,7 @@ struct dm_table {* These are optimistic limits taken from all the * targets, some targets will need smaller limits. */ -struct io_restrictions limits; +struct queue_limits limits;/* events get handed up using this callback */ void (*event_fn)(void *);
@@ -89,43 +89,6 @@ static unsigned int int_log(unsigned int }/* -* 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)) - -/* -* Combine two io_restrictions, always taking the lower value. -*/ -static void combine_restrictions_low (struct io_restrictions *lhs, -struct io_restrictions *rhs) -{ - lhs->max_sectors = -min_not_zero (lhs->max_sectors, rhs->max_sectors); - - lhs->max_phys_segments = -min_not_zero (lhs->max_phys_segments, rhs->max_phys_segments); - - lhs->max_hw_segments = -min_not_zero (lhs->max_hw_segments, rhs->max_hw_segments); - - 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); - - lhs->max_hw_sectors = -min_not_zero (lhs->max_hw_sectors, rhs->max_hw_sectors); - - lhs->seg_boundary_mask = -min_not_zero (lhs->seg_boundary_mask, rhs->seg_boundary_mask); - - lhs->bounce_pfn =min_not_zero (lhs->bounce_pfn, rhs->bounce_pfn); - - lhs->no_cluster |= rhs->no_cluster; -} - -/* * Calculate the index of the child node of the n'th node k'th key. */ static inline unsigned int get_child (unsigned int n,unsigned int k)
@@ -513,10 +476,14 @@ static int __table_get_device(struct dm_return 0 ; } +/* +* 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)) +void dm_set_device_limits (struct dm_target *ti,struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev); -struct io_restrictions *rs = &ti->limits;char b[BDEVNAME_SIZE ];if (unlikely (!q)) {
@@ -525,15 +492,9 @@ void dm_set_device_limits(struct dm_targreturn ; } -/* -* Combine the device limits low. -* -* FIXME: if we move an io_restriction struct -* into q this would just be a call to -* combine_restrictions_low() -*/ - rs->max_sectors = -min_not_zero (rs->max_sectors,queue_max_sectors (q)); +if (blk_stack_limits (&ti->limits, &q->limits,0 ) <0 ) +DMWARN ("%s: target device %s is misaligned" , +dm_device_name (ti->table->md),bdevname (bdev, b));/* * Check if merge fn is supported.
@@ -542,33 +503,9 @@ void dm_set_device_limits(struct dm_targ*/ if (q->merge_bvec_fn && !ti->type->merge) - rs->max_sectors = -min_not_zero (rs->max_sectors, + ti->limits.max_sectors = +min_not_zero (ti->limits.max_sectors, (unsigned int ) (PAGE_SIZE >>9 )); - - rs->max_phys_segments = -min_not_zero (rs->max_phys_segments, -queue_max_phys_segments (q)); - - rs->max_hw_segments = -min_not_zero (rs->max_hw_segments,queue_max_hw_segments (q)); - - 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,queue_max_segment_size (q)); - - rs->max_hw_sectors = -min_not_zero (rs->max_hw_sectors,queue_max_hw_sectors (q)); - - rs->seg_boundary_mask = -min_not_zero (rs->seg_boundary_mask, -queue_segment_boundary (q)); - - rs->bounce_pfn =min_not_zero (rs->bounce_pfn,queue_bounce_pfn (q)); - - rs->no_cluster |= !test_bit (QUEUE_FLAG_CLUSTER , &q->queue_flags); }EXPORT_SYMBOL_GPL (dm_set_device_limits);
@@ -706,24 +643,26 @@ int dm_split_args(int *argc, char ***argreturn 0 ; } -static void check_for_valid_limits (struct io_restrictions *rs) +static void check_for_valid_limits (struct queue_limits *limits) { -if (!rs->max_sectors) - rs->max_sectors =SAFE_MAX_SECTORS ; -if (!rs->max_hw_sectors) - rs->max_hw_sectors =SAFE_MAX_SECTORS ; -if (!rs->max_phys_segments) - rs->max_phys_segments =MAX_PHYS_SEGMENTS ; -if (!rs->max_hw_segments) - rs->max_hw_segments =MAX_HW_SEGMENTS ; -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) - rs->seg_boundary_mask =BLK_SEG_BOUNDARY_MASK ; -if (!rs->bounce_pfn) - rs->bounce_pfn =-1 ; +if (!limits->max_sectors) + limits->max_sectors =SAFE_MAX_SECTORS ; +if (!limits->max_hw_sectors) + limits->max_hw_sectors =SAFE_MAX_SECTORS ; +if (!limits->max_phys_segments) + limits->max_phys_segments =MAX_PHYS_SEGMENTS ; +if (!limits->max_hw_segments) + limits->max_hw_segments =MAX_HW_SEGMENTS ; +if (!limits->logical_block_size) + limits->logical_block_size =1 <<SECTOR_SHIFT ; +if (!limits->physical_block_size) + limits->physical_block_size =1 <<SECTOR_SHIFT ; +if (!limits->max_segment_size) + limits->max_segment_size =MAX_SEGMENT_SIZE ; +if (!limits->seg_boundary_mask) + limits->seg_boundary_mask =BLK_SEG_BOUNDARY_MASK ; +if (!limits->bounce_pfn) + limits->bounce_pfn =-1 ; }/*
@@ -843,9 +782,12 @@ int dm_table_add_target(struct dm_table t->highs[t->num_targets++] = tgt->begin + tgt->len -1 ; -/* FIXME: the plan is to combine high here and then have -* the merge fn apply the target level restrictions. */ -combine_restrictions_low (&t->limits, &tgt->limits); +if (blk_stack_limits (&t->limits, &tgt->limits,0 ) <0 ) +DMWARN ("%s: target device (start sect %llu len %llu) " +"is misaligned" , +dm_device_name (t->md), + (unsigned long long ) tgt->begin, + (unsigned long long ) tgt->len);return 0 ; bad:
@@ -1017,10 +959,14 @@ void dm_table_set_restrictions(struct dmblk_queue_max_phys_segments (q, t->limits.max_phys_segments);blk_queue_max_hw_segments (q, t->limits.max_hw_segments);blk_queue_logical_block_size (q, t->limits.logical_block_size); +blk_queue_physical_block_size (q, t->limits.physical_block_size);blk_queue_max_segment_size (q, t->limits.max_segment_size);blk_queue_max_hw_sectors (q, t->limits.max_hw_sectors);blk_queue_segment_boundary (q, t->limits.seg_boundary_mask);blk_queue_bounce_limit (q, t->limits.bounce_pfn); +blk_queue_io_min (q, t->limits.io_min); +blk_queue_io_opt (q, t->limits.io_opt); +blk_queue_alignment_offset (q, t->limits.alignment_offset);if (t->limits.no_cluster)queue_flag_clear_unlocked (QUEUE_FLAG_CLUSTER , q);
include/linux/device-mapper.h +2 -14
@@ -143,18 +143,6 @@ struct target_type {struct list_head list; }; -struct io_restrictions { -unsigned long bounce_pfn; -unsigned long seg_boundary_mask; -unsigned max_hw_sectors; -unsigned max_sectors; -unsigned max_segment_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 */ -}; -struct dm_target {struct dm_table *table;struct target_type *type;
@@ -163,7 +151,7 @@ struct dm_target {sector_t begin;sector_t len; -/* FIXME: turn this into a mask, and merge with io_restrictions */ +/* FIXME: turn this into a mask, and merge with queue_limits */ /* Always a power of 2 */ sector_t split_io;
@@ -171,7 +159,7 @@ struct dm_target {* These are automatically filled in by * dm_table_get_device. */ -struct io_restrictions limits; +struct queue_limits limits;/* target specific data */ void *private;