dm snapshot: consolidate insert exception functions

[safe/jmp/linux-2.6] / drivers / md / raid0.c

diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 7cd2671..d3a4ce0 100644 (file)
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -44,6 +44,9 @@ static int raid0_congested(void *data, int bits)
        mdk_rdev_t **devlist = conf->devlist;
        int i, ret = 0;
 
+       if (mddev_congested(mddev, bits))
+               return 1;
+
        for (i = 0; i < mddev->raid_disks && !ret ; i++) {
                struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
 
@@ -86,7 +89,7 @@ static void dump_zones(mddev_t *mddev)
 
 static int create_strip_zones(mddev_t *mddev)
 {
-       int i, c, j, err;
+       int i, c, err;
        sector_t curr_zone_end, sectors;
        mdk_rdev_t *smallest, *rdev1, *rdev2, *rdev, **dev;
        struct strip_zone *zone;
@@ -100,6 +103,12 @@ static int create_strip_zones(mddev_t *mddev)
                printk(KERN_INFO "raid0: looking at %s\n",
                        bdevname(rdev1->bdev,b));
                c = 0;
+
+               /* round size to chunk_size */
+               sectors = rdev1->sectors;
+               sector_div(sectors, mddev->chunk_sectors);
+               rdev1->sectors = sectors * mddev->chunk_sectors;
+
                list_for_each_entry(rdev2, &mddev->disks, same_set) {
                        printk(KERN_INFO "raid0:   comparing %s(%llu)",
                               bdevname(rdev1->bdev,b),
@@ -164,8 +173,8 @@ static int create_strip_zones(mddev_t *mddev)
                }
                dev[j] = rdev1;
 
-               blk_queue_stack_limits(mddev->queue,
-                                      rdev1->bdev->bd_disk->queue);
+               disk_stack_limits(mddev->gendisk, rdev1->bdev,
+                                 rdev1->data_offset << 9);
                /* 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.
@@ -192,6 +201,8 @@ static int create_strip_zones(mddev_t *mddev)
        /* now do the other zones */
        for (i = 1; i < conf->nr_strip_zones; i++)
        {
+               int j;
+
                zone = conf->strip_zone + i;
                dev = conf->devlist + i * mddev->raid_disks;
 
@@ -201,7 +212,6 @@ static int create_strip_zones(mddev_t *mddev)
                c = 0;
 
                for (j=0; j<cnt; j++) {
-                       char b[BDEVNAME_SIZE];
                        rdev = conf->devlist[j];
                        printk(KERN_INFO "raid0: checking %s ...",
                                bdevname(rdev->bdev, b));
@@ -238,12 +248,17 @@ static int create_strip_zones(mddev_t *mddev)
         * now since we have the hard sector sizes, we can make sure
         * chunk size is a multiple of that sector size
         */
-       if (mddev->chunk_size % queue_logical_block_size(mddev->queue)) {
+       if ((mddev->chunk_sectors << 9) % queue_logical_block_size(mddev->queue)) {
                printk(KERN_ERR "%s chunk_size of %d not valid\n",
                       mdname(mddev),
-                      mddev->chunk_size);
+                      mddev->chunk_sectors << 9);
                goto abort;
        }
+
+       blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
+       blk_queue_io_opt(mddev->queue,
+                        (mddev->chunk_sectors << 9) * mddev->raid_disks);
+
        printk(KERN_INFO "raid0: done.\n");
        mddev->private = conf;
        return 0;
@@ -270,10 +285,10 @@ static int raid0_mergeable_bvec(struct request_queue *q,
        mddev_t *mddev = q->queuedata;
        sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
        int max;
-       unsigned int chunk_sectors = mddev->chunk_size >> 9;
+       unsigned int chunk_sectors = mddev->chunk_sectors;
        unsigned int bio_sectors = bvm->bi_size >> 9;
 
-       if (is_power_of_2(mddev->chunk_size))
+       if (is_power_of_2(chunk_sectors))
                max =  (chunk_sectors - ((sector & (chunk_sectors-1))
                                                + bio_sectors)) << 9;
        else
@@ -304,11 +319,13 @@ static int raid0_run(mddev_t *mddev)
 {
        int ret;
 
-       if (mddev->chunk_size == 0) {
+       if (mddev->chunk_sectors == 0) {
                printk(KERN_ERR "md/raid0: chunk size must be set.\n");
                return -EINVAL;
        }
-       blk_queue_max_sectors(mddev->queue, mddev->chunk_size >> 9);
+       if (md_check_no_bitmap(mddev))
+               return -EINVAL;
+       blk_queue_max_sectors(mddev->queue, mddev->chunk_sectors);
        mddev->queue->queue_lock = &mddev->queue->__queue_lock;
 
        ret = create_strip_zones(mddev);
@@ -330,13 +347,15 @@ static int raid0_run(mddev_t *mddev)
         * chunksize should be used in that case.
         */
        {
-               int stripe = mddev->raid_disks * mddev->chunk_size / PAGE_SIZE;
+               int stripe = mddev->raid_disks *
+                       (mddev->chunk_sectors << 9) / PAGE_SIZE;
                if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
                        mddev->queue->backing_dev_info.ra_pages = 2* stripe;
        }
 
        blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
        dump_zones(mddev);
+       md_integrity_register(mddev);
        return 0;
 }
 
@@ -381,9 +400,9 @@ static mdk_rdev_t *map_sector(mddev_t *mddev, struct strip_zone *zone,
        unsigned int sect_in_chunk;
        sector_t chunk;
        raid0_conf_t *conf = mddev->private;
-       unsigned int chunk_sects = mddev->chunk_size >> 9;
+       unsigned int chunk_sects = mddev->chunk_sectors;
 
-       if (is_power_of_2(mddev->chunk_size)) {
+       if (is_power_of_2(chunk_sects)) {
                int chunksect_bits = ffz(~chunk_sects);
                /* find the sector offset inside the chunk */
                sect_in_chunk  = sector & (chunk_sects - 1);
@@ -413,7 +432,7 @@ static mdk_rdev_t *map_sector(mddev_t *mddev, struct strip_zone *zone,
 static inline int is_io_in_chunk_boundary(mddev_t *mddev,
                        unsigned int chunk_sects, struct bio *bio)
 {
-       if (likely(is_power_of_2(mddev->chunk_size))) {
+       if (likely(is_power_of_2(chunk_sects))) {
                return chunk_sects >= ((bio->bi_sector & (chunk_sects-1))
                                        + (bio->bi_size >> 9));
        } else{
@@ -433,7 +452,7 @@ static int raid0_make_request(struct request_queue *q, struct bio *bio)
        const int rw = bio_data_dir(bio);
        int cpu;
 
-       if (unlikely(bio_barrier(bio))) {
+       if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER))) {
                bio_endio(bio, -EOPNOTSUPP);
                return 0;
        }
@@ -444,7 +463,7 @@ static int raid0_make_request(struct request_queue *q, struct bio *bio)
                      bio_sectors(bio));
        part_stat_unlock();
 
-       chunk_sects = mddev->chunk_size >> 9;
+       chunk_sects = mddev->chunk_sectors;
        if (unlikely(!is_io_in_chunk_boundary(mddev, chunk_sects, bio))) {
                sector_t sector = bio->bi_sector;
                struct bio_pair *bp;
@@ -455,7 +474,7 @@ 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.
                 */
-               if (likely(is_power_of_2(mddev->chunk_size)))
+               if (likely(is_power_of_2(chunk_sects)))
                        bp = bio_split(bio, chunk_sects - (sector &
                                                           (chunk_sects-1)));
                else
@@ -519,7 +538,7 @@ static void raid0_status(struct seq_file *seq, mddev_t *mddev)
                zone_start = conf->strip_zone[j].zone_end;
        }
 #endif
-       seq_printf(seq, " %dk chunks", mddev->chunk_size/1024);
+       seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
        return;
 }