[PATCH] md: support stripe/offset mode in raid10

The "industry standard" DDF format allows for a stripe/offset layout where
data is duplicated on different stripes.  e.g.

  A  B  C  D
  D  A  B  C
  E  F  G  H
  H  E  F  G

(columns are drives, rows are stripes, LETTERS are chunks of data).

This is similar to raid10's 'far' mode, but not quite the same.  So enhance
'far' mode with a 'far/offset' option which follows the layout of DDFs
stripe/offset.

Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 2ca18770575fdc6df1327b8b9b2a1abccc960413..4db34edfd87f833589f21c6f774f1bd8209893cf 100644 (file)
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -29,6 +29,7 @@
  *    raid_disks
  *    near_copies (stored in low byte of layout)
  *    far_copies (stored in second byte of layout)
+ *    far_offset (stored in bit 16 of layout )
  *
  * The data to be stored is divided into chunks using chunksize.
  * Each device is divided into far_copies sections.
@@ -36,10 +37,14 @@
  * near_copies copies of each chunk is stored (each on a different drive).
  * The starting device for each section is offset near_copies from the starting
  * device of the previous section.
- * Thus there are (near_copies*far_copies) of each chunk, and each is on a different
+ * Thus they are (near_copies*far_copies) of each chunk, and each is on a different
  * drive.
  * near_copies and far_copies must be at least one, and their product is at most
  * raid_disks.
+ *
+ * If far_offset is true, then the far_copies are handled a bit differently.
+ * The copies are still in different stripes, but instead of be very far apart
+ * on disk, there are adjacent stripes.
  */
 
 /*
@@ -357,8 +362,7 @@ static int raid10_end_write_request(struct bio *bio, unsigned int bytes_done, in
  * With this layout, and block is never stored twice on the one device.
  *
  * raid10_find_phys finds the sector offset of a given virtual sector
- * on each device that it is on. If a block isn't on a device,
- * that entry in the array is set to MaxSector.
+ * on each device that it is on.
  *
  * raid10_find_virt does the reverse mapping, from a device and a
  * sector offset to a virtual address
@@ -381,6 +385,8 @@ static void raid10_find_phys(conf_t *conf, r10bio_t *r10bio)
        chunk *= conf->near_copies;
        stripe = chunk;
        dev = sector_div(stripe, conf->raid_disks);
+       if (conf->far_offset)
+               stripe *= conf->far_copies;
 
        sector += stripe << conf->chunk_shift;
 
@@ -414,16 +420,24 @@ static sector_t raid10_find_virt(conf_t *conf, sector_t sector, int dev)
 {
        sector_t offset, chunk, vchunk;
 
-       while (sector > conf->stride) {
-               sector -= conf->stride;
-               if (dev < conf->near_copies)
-                       dev += conf->raid_disks - conf->near_copies;
-               else
-                       dev -= conf->near_copies;
-       }
-
        offset = sector & conf->chunk_mask;
-       chunk = sector >> conf->chunk_shift;
+       if (conf->far_offset) {
+               int fc;
+               chunk = sector >> conf->chunk_shift;
+               fc = sector_div(chunk, conf->far_copies);
+               dev -= fc * conf->near_copies;
+               if (dev < 0)
+                       dev += conf->raid_disks;
+       } else {
+               while (sector > conf->stride) {
+                       sector -= conf->stride;
+                       if (dev < conf->near_copies)
+                               dev += conf->raid_disks - conf->near_copies;
+                       else
+                               dev -= conf->near_copies;
+               }
+               chunk = sector >> conf->chunk_shift;
+       }
        vchunk = chunk * conf->raid_disks + dev;
        sector_div(vchunk, conf->near_copies);
        return (vchunk << conf->chunk_shift) + offset;
@@ -900,9 +914,12 @@ static void status(struct seq_file *seq, mddev_t *mddev)
                seq_printf(seq, " %dK chunks", mddev->chunk_size/1024);
        if (conf->near_copies > 1)
                seq_printf(seq, " %d near-copies", conf->near_copies);
-       if (conf->far_copies > 1)
-               seq_printf(seq, " %d far-copies", conf->far_copies);
-
+       if (conf->far_copies > 1) {
+               if (conf->far_offset)
+                       seq_printf(seq, " %d offset-copies", conf->far_copies);
+               else
+                       seq_printf(seq, " %d far-copies", conf->far_copies);
+       }
        seq_printf(seq, " [%d/%d] [", conf->raid_disks,
                                                conf->working_disks);
        for (i = 0; i < conf->raid_disks; i++)
@@ -1915,7 +1932,7 @@ static int run(mddev_t *mddev)
        mirror_info_t *disk;
        mdk_rdev_t *rdev;
        struct list_head *tmp;
-       int nc, fc;
+       int nc, fc, fo;
        sector_t stride, size;
 
        if (mddev->chunk_size == 0) {
@@ -1925,8 +1942,9 @@ static int run(mddev_t *mddev)
 
        nc = mddev->layout & 255;
        fc = (mddev->layout >> 8) & 255;
+       fo = mddev->layout & (1<<16);
        if ((nc*fc) <2 || (nc*fc) > mddev->raid_disks ||
-           (mddev->layout >> 16)) {
+           (mddev->layout >> 17)) {
                printk(KERN_ERR "raid10: %s: unsupported raid10 layout: 0x%8x\n",
                       mdname(mddev), mddev->layout);
                goto out;
@@ -1958,12 +1976,16 @@ static int run(mddev_t *mddev)
        conf->near_copies = nc;
        conf->far_copies = fc;
        conf->copies = nc*fc;
+       conf->far_offset = fo;
        conf->chunk_mask = (sector_t)(mddev->chunk_size>>9)-1;
        conf->chunk_shift = ffz(~mddev->chunk_size) - 9;
-       stride = mddev->size >> (conf->chunk_shift-1);
-       sector_div(stride, fc);
-       conf->stride = stride << conf->chunk_shift;
-
+       if (fo)
+               conf->stride = 1 << conf->chunk_shift;
+       else {
+               stride = mddev->size >> (conf->chunk_shift-1);
+               sector_div(stride, fc);
+               conf->stride = stride << conf->chunk_shift;
+       }
        conf->r10bio_pool = mempool_create(NR_RAID10_BIOS, r10bio_pool_alloc,
                                                r10bio_pool_free, conf);
        if (!conf->r10bio_pool) {

diff --git a/include/linux/raid/raid10.h b/include/linux/raid/raid10.h
index b1103298a8c2cb043cd7c56d4a32b694463379e7..c41e56a7c090801f401f97e116986204a5fb728d 100644 (file)
--- a/include/linux/raid/raid10.h
+++ b/include/linux/raid/raid10.h
@@ -24,11 +24,16 @@ struct r10_private_data_s {
        int                     far_copies;   /* number of copies layed out
                                               * at large strides across drives
                                               */
+       int                     far_offset;   /* far_copies are offset by 1 stripe
+                                              * instead of many
+                                              */
        int                     copies;       /* near_copies * far_copies.
                                               * must be <= raid_disks
                                               */
        sector_t                stride;       /* distance between far copies.
-                                              * This is size / far_copies
+                                              * This is size / far_copies unless
+                                              * far_offset, in which case it is
+                                              * 1 stripe.
                                               */
 
        int chunk_shift; /* shift from chunks to sectors */