dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

dm table: replace struct io_restrictions with struct queue_limits 

Use blk_stack_limits() to stack block limits (including topology) rather
than duplicate the equivalent within Device Mapper.

Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
This commit is contained in:
Mike Snitzer 2009-06-22 10:12:32 +01:00 committed by Alasdair G Kergon
parent be6d4305db
commit 5ab97588fb
2 changed files with 45 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
drivers/md/dm-table.c
View File

@ -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 *);
@ -88,43 +88,6 @@ static unsigned int int_log(unsigned int n, unsigned int base)
return result;
}
/*
* 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.
*/
@ -511,10 +474,14 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
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)) {
@ -523,15 +490,9 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
return;
}
/*
* 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.
@ -540,33 +501,9 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
*/
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);
@ -704,24 +641,32 @@ int dm_split_args(int *argc, char ***argvp, char *input)
return 0;
}
static void check_for_valid_limits(struct io_restrictions *rs)
static void init_valid_queue_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->io_min)
limits->io_min = 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;
/*
* The other fields (alignment_offset, io_opt, misaligned)
* hold 0 from the kzalloc().
*/
}
/*
@ -841,9 +786,12 @@ int dm_table_add_target(struct dm_table *t, const char *type,
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:
@ -886,7 +834,7 @@ int dm_table_complete(struct dm_table *t)
int r = 0;
unsigned int leaf_nodes;
check_for_valid_limits(&t->limits);
init_valid_queue_limits(&t->limits);
r = validate_hardware_logical_block_alignment(t);
if (r)

16
include/linux/device-mapper.h
View File

@ -144,18 +144,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;
@ -164,7 +152,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;
@ -182,7 +170,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;