Subject: [001/001 ] raid0 remove hashing, variable chunk size
1. Beautify raid0 code
2. Remove hashing
3. Chunk size of 4K*n instead of 4K*2^n ( must apply a patch to mdadm ). patch was tested with backward compatibility to 2.6.18. i did not test 32bit, i do have a 32bit compiler for 2.6.30-rc2.
md.c | 24 ++- raid0.c | 428 ++++++++++++++++++++++++++++++---------------------------------- raid0.h | 3 3 files changed, 221 insertions(+), 234 deletions(-)
---
drivers/md/md.c +17 -7
@@ -444,8 +444,10 @@ static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size) {sector_t num_sectors = rdev->sb_start; -if (chunk_size) - num_sectors &= ~((sector_t )chunk_size/512 -1 ); +if (chunk_size) { +int chunk_sects = chunk_size>>9 ; + num_sectors = (num_sectors/chunk_sects)*chunk_sects; + }return num_sectors; }
@@ -3512,7 +3514,7 @@ min_sync_store(mddev_t *mddev, const char *buf, size_t len)/* Must be a multiple of chunk_size */ if (mddev->chunk_size) { -if (min & (sector_t)((mddev->chunk_size>>9 )-1 )) +if (min % (sector_t)(mddev->chunk_size>>9 ))return -EINVAL ; } mddev->resync_min = min;
@@ -3549,7 +3551,7 @@ max_sync_store(mddev_t *mddev, const char *buf, size_t len)/* Must be a multiple of chunk_size */ if (mddev->chunk_size) { -if (max & (sector_t)((mddev->chunk_size>>9 )-1 )) +if (max % (sector_t)(mddev->chunk_size>>9 ))return -EINVAL ; } mddev->resync_max = max;
@@ -3992,12 +3994,20 @@ static int do_md_run(mddev_t * mddev) }/* * chunk-size has to be a power of 2 -*/ -if ( (1 <<ffz (~chunk_size)) != chunk_size) { +*/ +if ((1 <<ffz (~chunk_size)) != chunk_size + && mddev->level !=0 ) {printk (KERN_ERR "chunk_size of %d not valid\n" , chunk_size);return -EINVAL ; } - +/* +* raid0 chunk size has to divide by a page +*/ +if (mddev->level ==0 && (chunk_size %4096 )) { +printk (KERN_ERR "chunk_size of %d not valid\n" , + chunk_size); +return -EINVAL ; + }/* devices must have minimum size of one chunk */ list_for_each_entry (rdev, &mddev->disks, same_set) {if (test_bit (Faulty, &rdev->flags))
drivers/md/raid0.c +204 -224
583 lines not on this page · raw message
drivers/md/raid0.h +0 -3
@@ -16,9 +16,6 @@ struct raid0_private_datastruct strip_zone *strip_zone;mdk_rdev_t **devlist;/* lists of rdevs, pointed to by strip_zone->dev */ int nr_strip_zones; - -sector_t spacing; -int sector_shift;/* shift this before divide by spacing */ };typedef struct raid0_private_data raid0_conf_t ;
Quoted 11 lines · raz ben yehuda
1. Beautify raid0 code
2. Remove hashing
3. Chunk size of 4K*n instead of 4K*2^n ( must apply a patch to mdadm ). patch was tested with backward compatibility to 2.6.18. i did not test 32bit, i do have
a 32bit compiler for 2.6.30-rc2.md.c | 24 ++- raid0.c | 428 ++++++++++++++++++++++++++++++---------------------------------- raid0.h | 3 3 files changed, 221 insertions(+), 234 deletions(-)
That is a very small description for a very big patch.
As it does 3 different things, can you make it into three different patches? That tends to make it a lot easier to review.
Quoted 1 line
Signed-of-By Neil Brown [email protected]
You are meant to put your own email address here, not mine.
NeilBrown
Quoted 430 lines · raz ben yehuda
1. Beautify raid0 code
2. Remove hashing
3. Chunk size of 4K*n instead of 4K*2^n ( must apply a patch to mdadm ). patch was tested with backward compatibility to 2.6.18. i did not test 32bit, i do have a 32bit compiler for 2.6.30-rc2.
md.c | 24 ++-
raid0.c | 428 ++++++++++++++++++++++++++++++----------------------------------raid0.h| 33 files changed, 221 insertions(+), 234 deletions(-)Signed-of-By Neil Brown [email protected]---
drivers/md/md.c +17
-7@@ -444,8 +444,10 @@ static sector_t calc_num_sectors(mdk_rdev_t *rdev, unsigned chunk_size) { sector_t num_sectors = rdev->sb_start; - if (chunk_size) - num_sectors &= ~((sector_t)chunk_size/512 - 1); + if (chunk_size) { + int chunk_sects = chunk_size>>9; + num_sectors = (num_sectors/chunk_sects)*chunk_sects; + } return num_sectors; }@@ -3512,7 +3514,7 @@ min_sync_store(mddev_t *mddev, const char *buf, size_t len) /* Must be a multiple of chunk_size */ if (mddev->chunk_size) { - if (min & (sector_t)((mddev->chunk_size>>9)-1)) + if (min % (sector_t)(mddev->chunk_size>>9)) return -EINVAL; } mddev->resync_min = min;@@ -3549,7 +3551,7 @@ max_sync_store(mddev_t *mddev, const char *buf, size_t len) /* Must be a multiple of chunk_size */ if (mddev->chunk_size) { - if (max & (sector_t)((mddev->chunk_size>>9)-1)) + if (max % (sector_t)(mddev->chunk_size>>9)) return -EINVAL; } mddev->resync_max = max;@@ -3992,12 +3994,20 @@ static int do_md_run(mddev_t * mddev) } /* * chunk-size has to be a power of 2 - */ - if ( (1 << ffz(~chunk_size)) != chunk_size) { + */ + if ((1 << ffz(~chunk_size)) != chunk_size + && mddev->level != 0) { printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size); return -EINVAL; } - + /* + * raid0 chunk size has to divide by a page + */ + if (mddev->level == 0 && (chunk_size % 4096)) { + printk(KERN_ERR "chunk_size of %d not valid\n", + chunk_size); + return -EINVAL; + } /* devices must have minimum size of one chunk */ list_for_each_entry(rdev, &mddev->disks, same_set) { if (test_bit(Faulty, &rdev->flags))drivers/md/raid0.c +46
-32@@ -53,32 +53,49 @@ static int raid0_congested(void *data, int bits) } -static int create_strip_zones (mddev_t *mddev) +static void raid0_dump_zones (mddev_t *mddev) { - int i, c, j; - sector_t current_start, curr_zone_start; - sector_t min_spacing; + int j, k, h; + char b[BDEVNAME_SIZE]; raid0_conf_t *conf = mddev_to_conf(mddev); - mdk_rdev_t *smallest, *rdev1, *rdev2, *rdev; - struct strip_zone *zone; - int cnt; + printk(KERN_INFO "***** %s configuration ******", + mdname(mddev)); + h = 0; + for (j = 0; j < conf->nr_strip_zones; j++) { + printk("\nzone%d", j); + printk("=["); + for (k = 0; k < conf->strip_zone[j].nb_dev; k++) + printk("%s/", bdevname( + conf->strip_zone[j].dev[k]->bdev, b)); + printk("]\n\t zone offset=%llu device offset=%llu size=%llukb\n", + (unsigned long long)conf->strip_zone[j].zone_start, + (unsigned long long)conf->strip_zone[j].dev_start, + (unsigned long long)conf->strip_zone[j].sectors>>1); + } + printk(KERN_INFO "**********************************\n\n"); +} + + +static void raid0_count_zones (mddev_t *mddev,struct list_head *disks) +{ + int c = 0; char b[BDEVNAME_SIZE]; - + mdk_rdev_t *rdev1, *rdev2; + raid0_conf_t *conf = mddev_to_conf(mddev); /* * The number of 'same size groups' */ conf->nr_strip_zones = 0; - - list_for_each_entry(rdev1, &mddev->disks, same_set) { + list_for_each_entry(rdev1, disks, same_set) { printk(KERN_INFO "raid0: looking at %s\n", bdevname(rdev1->bdev,b)); c = 0; - list_for_each_entry(rdev2, &mddev->disks, same_set) { + list_for_each_entry(rdev2, disks, same_set) { printk(KERN_INFO "raid0: comparing %s(%llu)", - bdevname(rdev1->bdev,b), + bdevname(rdev1->bdev, b), (unsigned long long)rdev1->sectors); - printk(KERN_INFO " with %s(%llu)\n", - bdevname(rdev2->bdev,b), + printk(KERN_INFO "with %s(%llu)\n", + bdevname(rdev2->bdev, b), (unsigned long long)rdev2->sectors); if (rdev2 == rdev1) { printk(KERN_INFO "raid0: END\n");@@ -103,81 +120,75 @@ static int create_strip_zones (mddev_t *mddev) } } printk(KERN_INFO "raid0: FINAL %d zones\n", conf->nr_strip_zones); +} - conf->strip_zone = kzalloc(sizeof(struct strip_zone)* - conf->nr_strip_zones, GFP_KERNEL); - if (!conf->strip_zone) - return 1; - conf->devlist = kzalloc(sizeof(mdk_rdev_t*)* - conf->nr_strip_zones*mddev->raid_disks, - GFP_KERNEL); - if (!conf->devlist) - return 1; - /* The first zone must contain all devices, so here we check that - * there is a proper alignment of slots to devices and find them all - */ - zone = &conf->strip_zone[0]; - cnt = 0; - smallest = NULL; - zone->dev = conf->devlist; - list_for_each_entry(rdev1, &mddev->disks, same_set) { - int j = rdev1->raid_disk; +/* +* The first zone must contain all devices, so here we check that +* there is a proper alignment of slots to devices and find them all +*/ +static int raid0_create_first_zone (mddev_t *mddev,struct list_head *disks) +{ + mdk_rdev_t *smallest = NULL; + mdk_rdev_t *rdev; + int cnt = 0; + raid0_conf_t *conf = mddev_to_conf(mddev); + struct strip_zone *zone0 = &conf->strip_zone[0]; + zone0->dev = conf->devlist; + list_for_each_entry(rdev, disks, same_set) { + int j = rdev->raid_disk; if (j < 0 || j >= mddev->raid_disks) {printk(KERN_ERR "raid0: bad disk number %d - " "aborting!\n", j);
- goto abort;
+ return -1;
}
- if (zone->dev[j]) {
+ if (zone0->dev[j]) {
printk(KERN_ERR "raid0: multiple devices for %d - " "aborting!\n", j);
- goto abort;
+ return -1;
}
- zone->dev[j] = rdev1;drivers/md/raid0.c +3
-14- - blk_queue_stack_limits(mddev->queue, - rdev1->bdev->bd_disk->queue); - /* as we don't honour merge_bvec_fn, we must never risk - * violating it, so limit ->max_sector to one PAGE, as - * a one page request is never in violation. - */ - - if (rdev1->bdev->bd_disk->queue->merge_bvec_fn && - mddev->queue->max_sectors > (PAGE_SIZE>>9)) - blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); - - if (!smallest || (rdev1->sectors < smallest->sectors)) - smallest = rdev1; + zone0->dev[j] = rdev; + if (!smallest || (rdev->sectors < smallest->sectors)) + smallest = rdev;cnt++;
}
if (cnt !=mddev->raid_disks) {
printk(KERN_ERR "raid0: too few disks (%d of %d) - " "aborting!\n", cnt,mddev->raid_disks);
- goto abort;
+ return -1;
}
-zone->nb_dev= cnt;
-zone->sectors=smallest->sectors* cnt;
-zone->zone_start= 0;
+zone0->nb_dev= cnt;
+zone0->sectors=smallest->sectors* cnt;
+zone0->zone_start= 0;
+ return 0;drivers/md/raid0.c +13
-2+} + - current_start = smallest->sectors; - curr_zone_start = zone->sectors; + +static void raid0_set_higher_zones (mddev_t *mddev) +{ + int i, j, c; + mdk_rdev_t *rdev; + struct strip_zone *zone; + raid0_conf_t *conf = mddev_to_conf(mddev); + mdk_rdev_t *smallest; + sector_t current_start = + conf->strip_zone[0].sectors/conf->strip_zone[0].nb_dev; + sector_t curr_zone_start = conf->strip_zone[0].sectors;/* now do the other zones */
- for (i = 1; i <conf->nr_strip_zones; i++)
- {
+ for (i = 1; i <conf->nr_strip_zones; i++) {
zone =conf->strip_zone+ i;
zone->dev = conf->strip_zone[i-1].dev +mddev->raid_disks; -
printk(KERN_INFO "raid0: zone %d\n", i);zone->dev_start=current_start;
smallest = NULL;
c = 0;
-
- for (j=0; j<cnt; j++) {
+ for (j = 0; j < conf->strip_zone[0].nb_dev; j++) { char b[BDEVNAME_SIZE];
rdev = conf->strip_zone[0].dev[j];
- printk(KERN_INFO "raid0: checking %s ...",
+printk("raid0: checking %s ...", bdevname(rdev->bdev, b));
if (rdev->sectors<=current_start) {printk(KERN_INFO " nope.\n");drivers/md/raid0.c +20
-36@@ -197,54 +208,38 @@ static int create_strip_zones (mddev_t *mddev) zone->sectors = (smallest->sectors - current_start) * c; printk(KERN_INFO "raid0: zone->nb_dev: %d, sectors: %llu\n", zone->nb_dev, (unsigned long long)zone->sectors); - zone->zone_start = curr_zone_start; curr_zone_start += zone->sectors; - current_start = smallest->sectors; printk(KERN_INFO "raid0: current zone start: %llu\n", (unsigned long long)current_start); } +} - /* Now find appropriate hash spacing. - * We want a number which causes most hash entries to cover - * at most two strips, but the hash table must be at most - * 1 PAGE. We choose the smallest strip, or contiguous collection - * of strips, that has big enough size. We never consider the last - * strip though as it's size has no bearing on the efficacy of the hash - * table. - */ - conf->spacing = curr_zone_start; - min_spacing = curr_zone_start; - sector_div(min_spacing, PAGE_SIZE/sizeof(struct strip_zone*)); - for (i=0; i < conf->nr_strip_zones-1; i++) { - sector_t s = 0; - for (j = i; j < conf->nr_strip_zones - 1 && - s < min_spacing; j++) - s += conf->strip_zone[j].sectors; - if (s >= min_spacing && s < conf->spacing) - conf->spacing = s; - } +static int raid0_create_strip_zones (mddev_t *mddev,struct list_head *disks) +{ + raid0_conf_t *conf = mddev_to_conf(mddev); + raid0_count_zones(mddev, disks); + conf->strip_zone = kzalloc(sizeof(struct strip_zone)* + conf->nr_strip_zones, GFP_KERNEL); + if (!conf->strip_zone) + return 1; + conf->devlist = kzalloc(sizeof(mdk_rdev_t *)* + conf->nr_strip_zones*mddev->raid_disks, + GFP_KERNEL); + if (!conf->devlist) + return 1; + if (raid0_create_first_zone(mddev, disks)) + return 1; + raid0_set_higher_zones(mddev); mddev->queue->unplug_fn = raid0_unplug; - mddev->queue->backing_dev_info.congested_fn = raid0_congested; mddev->queue->backing_dev_info.congested_data = mddev; - printk(KERN_INFO "raid0: done.\n"); return 0; - abort: - return 1; } -/** -* raid0_mergeable_bvec -- tell bio layer if a two requests can be merged -* @q: request queue -* @bvm: properties of new bio -* @biovec: the request that could be merged to it. -* -* Return amount of bytes we can accept at this offset -*/ static int raid0_mergeable_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *biovec)@@ -254,124 +249,119 @@ static int raid0_mergeable_bvec(struct request_queue *q, int max; unsigned int chunk_sectors = mddev->chunk_size >> 9; unsigned int bio_sectors = bvm->bi_size >> 9; - - max = (chunk_sectors - ((sector & (chunk_sectors - 1)) + bio_sectors)) << 9; - if (max < 0) max = 0; /* bio_add cannot handle a negative return */ + max = (chunk_sectors - ((sector % chunk_sectors) + bio_sectors)) << 9; + if (max < 0) + max = 0;/* bio_add cannot handle a negative return */ if (max <= biovec->bv_len && bio_sectors == 0) return biovec->bv_len;else
return max;
+ return 0;
}+
staticsector_traid0_size(mddev_t *mddev, sector_t sectors, int raid_disks){
-sector_tarray_sectors= 0;
+ int i;
mdk_rdev_t *rdev;
+sector_tarray_sectors= 0;
+raid0_conf_t*conf =mddev_to_conf(mddev);
+mdk_rdev_t**devlist = conf->strip_zone[0].dev;
+ for (i = 0; i <mddev->raid_disks; i++) {
+ rdev = devlist[i];
+ if (test_bit(In_sync, &rdev->flags))
+array_sectors+=rdev->sectors;
+ }
+ returnarray_sectors;drivers/md/raid0.c +39
-5+} - WARN_ONCE(sectors || raid_disks, - "%s does not support generic reshape\n", __func__); +static void raid0_set_queue_limits (mddev_t *mddev) +{ + mdk_rdev_t *rdev; - list_for_each_entry(rdev, &mddev->disks, same_set) - array_sectors += rdev->sectors; + list_for_each_entry(rdev, &mddev->disks, same_set) { + blk_queue_stack_limits(mddev->queue, + rdev->bdev->bd_disk->queue); + /* as we don't honour merge_bvec_fn, we must never risk + * violating it, so limit ->max_sector to one PAGE, as + * a one page request is never in violation. + */ + if (rdev->bdev->bd_disk->queue->merge_bvec_fn && + mddev->queue->max_sectors > (PAGE_SIZE>>9)) + blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9); + } + printk(KERN_INFO "raid0:%s queue limits: hardware" + " segments=%d physical segments=%d\n" + " max hardware sectors = %d max sectors %d\n", + mdname(mddev), + mddev->queue->max_hw_segments, + mddev->queue->max_phys_segments, + mddev->queue->max_hw_sectors, + mddev->queue->max_sectors); +} + +/* calculate the max read-ahead size. +* For read-ahead of large files to be effective, we need to +* readahead at least twice a whole stripe. i.e. number of devices +* multiplied by chunk size times 2. +* If an individual device has an ra_pages greater than the +* chunk size, then we will not drive that device as hard as it +* wants. We consider this a configuration error: a larger +* chunksize should be used in that case. +*/ +static void raid0_set_max_ra (mddev_t *mddev) +{ + int stripe = mddev->raid_disks * mddev->chunk_size / PAGE_SIZE; + if (mddev->queue->backing_dev_info.ra_pages < 2*stripe) + mddev->queue->backing_dev_info.ra_pages = 2*stripe; - return array_sectors;}
drivers/md/raid0.c +1
-1-static int raid0_run (mddev_t *mddev) +static int raid0_is_power2_chunk (mddev_t *mddev){
- unsigned cur=0, i=0,nb_zone;
- s64 sectors;
-raid0_conf_t*conf;
+ if ((1 <<ffz(~mddev->chunk_size)) ==mddev->chunk_size)
+ return 1;
+ return 0;drivers/md/raid0.c +5
-0+} +static int raid0_run (mddev_t *mddev) +{ + raid0_conf_t *conf; + int segment_boundary;
Quoted 4 lines
if (
mddev->chunk_size== 0) {
printk(KERN_ERR "md/raid0: non-zero chunk size required.\n"); return-EINVAL;
}
Are we not handling this in mdadm itself, I think so ?
[09:03:40 sinhas]$ sudo mdadm -C /dev/md0 -n2 -l0 -c0 /dev/sda5 /dev/sda6 -f
mdadm: invalid chunk/rounding value: 0
I think we also make sure that chunk size > 4K. I tested it.
Quoted 9 lines
- printk(KERN_INFO "%s: setting
max_sectorsto %d, segment boundary to %d\n",
+blk_queue_max_sectors(mddev->queue, mddev->chunk_size>>9);
+ if (!raid0_is_power2_chunk(mddev)) {
+printk(KERN_INFO "raid0: not power 2 chunk size\n");
+segment_boundary= ~(ffz(~mddev->chunk_size))>>1;
+ } else{
+printk(KERN_INFO "raid0: is power 2 chunk size\n");
+segment_boundary= (mddev->chunk_size>>1)-1;
+ }
I hope this piece of code gets executed someday,
[09:03:22 sinhas]$ sudo mdadm -C /dev/md0 -n2 -l0 -c62 /dev/sda5 /dev/sda6 -f [sudo] password for sinhas:
mdadm: invalid chunk/rounding value: 62
Quoted 246 lines
+
blk_queue_segment_boundary(mddev->queue, segment_boundary);
+ printk(KERN_INFO "%s: settingmax_sectors"
+ " to %d, segment boundary to %d\n", mdname(mddev),
mddev->chunk_size>> 9,
- (mddev->chunk_size>>1)-1);
-blk_queue_max_sectors(mddev->queue, mddev->chunk_size >> 9);
-blk_queue_segment_boundary(mddev->queue, (mddev->chunk_size>>1) - 1);
+ segment_boundary);
mddev->queue->queue_lock =&mddev->queue->__queue_lock;- conf =
kmalloc(sizeof (raid0_conf_t), GFP_KERNEL);
+ conf =kmalloc(sizeof(raid0_conf_t), GFP_KERNEL); if (!conf)
goto out;
mddev->private = (void *)conf;
-
conf->strip_zone = NULL;
conf->devlist = NULL;
- if (create_strip_zones(mddev))
+ if (raid0_create_strip_zones(mddev, &mddev->disks)) gotoout_free_conf;
-
/* calculate array device size */
-md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));drivers/md/raid0.c +3
-64- - printk(KERN_INFO "raid0 : md_size is %llu sectors.\n", - (unsigned long long)mddev->array_sectors); - printk(KERN_INFO "raid0 : conf->spacing is %llu sectors.\n", - (unsigned long long)conf->spacing); - { - sector_t s = raid0_size(mddev, 0, 0); - sector_t space = conf->spacing; - int round; - conf->sector_shift = 0; - if (sizeof(sector_t) > sizeof(u32)) { - /*shift down space and s so that sector_div will work */ - while (space > (sector_t) (~(u32)0)) { - s >>= 1; - space >>= 1; - s += 1; /* force round-up */ - conf->sector_shift++; - } - } - round = sector_div(s, (u32)space) ? 1 : 0; - nb_zone = s + round; - } - printk(KERN_INFO "raid0 : nb_zone is %d.\n", nb_zone); - - printk(KERN_INFO "raid0 : Allocating %zu bytes for hash.\n", - nb_zone*sizeof(struct strip_zone*)); - conf->hash_table = kmalloc (sizeof (struct strip_zone *)*nb_zone, GFP_KERNEL); - if (!conf->hash_table) - goto out_free_conf; - sectors = conf->strip_zone[cur].sectors; - - conf->hash_table[0] = conf->strip_zone + cur; - for (i=1; i< nb_zone; i++) { - while (sectors <= conf->spacing) { - cur++; - sectors += conf->strip_zone[cur].sectors; - } - sectors -= conf->spacing; - conf->hash_table[i] = conf->strip_zone + cur; - } - if (conf->sector_shift) { - conf->spacing >>= conf->sector_shift; - /* round spacing up so when we divide by it, we - * err on the side of too-low, which is safest - */ - conf->spacing++; - } - - /* calculate the max read-ahead size. - * For read-ahead of large files to be effective, we need to - * readahead at least twice a whole stripe. i.e. number of devices - * multiplied by chunk size times 2. - * If an individual device has an ra_pages greater than the - * chunk size, then we will not drive that device as hard as it - * wants. We consider this a configuration error: a larger - * chunksize should be used in that case. - */ - { - int stripe = mddev->raid_disks * mddev->chunk_size / PAGE_SIZE; - if (mddev->queue->backing_dev_info.ra_pages < 2* stripe) - mddev->queue->backing_dev_info.ra_pages = 2* stripe; - } - - + md_set_array_sectors(mddev, raid0_size(mddev, 0, mddev->raid_disks)); + raid0_set_queue_limits(mddev); + raid0_set_max_ra(mddev);blk_queue_merge_bvec(mddev->queue,
raid0_mergeable_bvec);
+raid0_dump_zones(mddev);
return 0;out_free_conf:
drivers/md/raid0.c +0
-0@@ -388,8 +378,6 @@ static int raid0_stop (mddev_t *mddev) raid0_conf_t *conf = mddev_to_conf(mddev);blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
-kfree(conf->hash_table);
-conf->hash_table= NULL;
kfree(conf->strip_zone);
conf->strip_zone = NULL;
kfree(conf);drivers/md/raid0.c +29
-12@@ -398,15 +386,36 @@ static int raid0_stop (mddev_t *mddev) return 0; } + +static void raid0_position_bio (mddev_t *mddev,struct bio *bio,sector_t sector) +{ + sector_t sect_in_chunk; + mdk_rdev_t *tmp_dev; + sector_t chunk_in_dev; + sector_t rsect; + sector_t x; + raid0_conf_t *conf = mddev_to_conf(mddev); + sector_t chunk_sects = mddev->chunk_size >> 9; + struct strip_zone *zone = &conf->strip_zone[0]; + + while (sector >= zone->zone_start + zone->sectors) + zone++; + sect_in_chunk = sector % chunk_sects; + x = (sector - zone->zone_start) / chunk_sects; + sector_div(x, zone->nb_dev); + chunk_in_dev = x; + x = sector / chunk_sects; + tmp_dev = zone->dev[sector_div(x, zone->nb_dev)]; + rsect = (chunk_in_dev * chunk_sects) + zone->dev_start + sect_in_chunk; + bio->bi_bdev = tmp_dev->bdev; + bio->bi_sector = rsect + tmp_dev->data_offset; +} + + static int raid0_make_request (struct request_queue *q, struct bio *bio) { mddev_t *mddev = q->queuedata; - unsigned int sect_in_chunk, chunksect_bits, chunk_sects; - raid0_conf_t *conf = mddev_to_conf(mddev); - struct strip_zone *zone; - mdk_rdev_t *tmp_dev; - sector_t chunk; - sector_t sector, rsect; + unsigned int chunk_sects = mddev->chunk_size >> 9; const int rw = bio_data_dir(bio); int cpu;@@ -414,18 +423,14 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio) bio_endio(bio, -EOPNOTSUPP); return 0; } - cpu = part_stat_lock(); part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], bio_sectors(bio)); part_stat_unlock(); - chunk_sects = mddev->chunk_size >> 9; - chunksect_bits = ffz(~chunk_sects); - sector = bio->bi_sector; - - if (unlikely(chunk_sects < (bio->bi_sector & (chunk_sects - 1)) + (bio->bi_size >> 9))) { + if (unlikely(chunk_sects < ((bio->bi_sector % chunk_sects) + + (bio->bi_size >> 9)))) { struct bio_pair *bp; /* Sanity check -- queue functions should prevent this happening */if (
bio->bi_vcnt!= 1 ||drivers/md/raid0.c +4
-29@@ -434,7 +439,8 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio) /* This is a one page bio that upper layers * refuse to split for us, so we need to split it. */ - bp = bio_split(bio, chunk_sects - (bio->bi_sector & (chunk_sects - 1))); + bp = bio_split(bio, chunk_sects - + (bio->bi_sector % chunk_sects)); if (raid0_make_request(q, &bp->bio1)) generic_make_request(&bp->bio1); if (raid0_make_request(q, &bp->bio2))@@ -443,34 +449,7 @@ static int raid0_make_request (struct request_queue *q, struct bio *bio) bio_pair_release(bp); return 0; } - - - { - sector_t x = sector >> conf->sector_shift; - sector_div(x, (u32)conf->spacing); - zone = conf->hash_table[x]; - } - - while (sector >= zone->zone_start + zone->sectors) - zone++; - - sect_in_chunk = bio->bi_sector & (chunk_sects - 1); - - - { - sector_t x = (sector - zone->zone_start) >> chunksect_bits; - - sector_div(x, zone->nb_dev); - chunk = x; - - x = sector >> chunksect_bits; - tmp_dev = zone->dev[sector_div(x, zone->nb_dev)]; - } - rsect = (chunk << chunksect_bits) + zone->dev_start + sect_in_chunk; - - bio->bi_bdev = tmp_dev->bdev; - bio->bi_sector = rsect + tmp_dev->data_offset; - + raid0_position_bio(mddev, bio, bio->bi_sector); /** Let the main block layer submit the IO and resolve recursion: */ @@ -485,6 +464,7 @@ bad_map: return 0; } + static void raid0_status (struct seq_file *seq, mddev_t *mddev) { #undef MD_DEBUGdrivers/md/raid0.h +0
-0@@ -16,9 +16,6 @@ struct raid0_private_data struct strip_zone *strip_zone;mdk_rdev_t **devlist; /* lists of rdevs, pointed to by
strip_zone->dev*/ intnr_strip_zones;
-
-sector_tspacing;
- intsector_shift; /* shift this before divide by spacing */ };typedef struct
raid0_private_dataraid0_conf_t;--
To unsubscribe from this list: send the line "unsubscribe linux-raid" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Signature · 13 lines
Regards, Sandeep. “To learn is to change. Education is a process that changes the learner.” -- To unsubscribe from this list: send the line "unsubscribe linux-raid" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html