sysfs: Avoid if and return on the same line

[thirdparty/mdadm.git] / restripe.c

diff --git a/restripe.c b/restripe.c
index 93ef056e12ceaf3ac13746d34829a8219db0862d..359ae86ed5845d109336639629bc737f3895e39a 100644 (file)
--- a/restripe.c
+++ b/restripe.c
@@ -58,26 +58,30 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                return block;
        case 500 + ALGORITHM_LEFT_ASYMMETRIC:
                pd = (raid_disks-1) - stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                if (block >= pd)
                        block++;
                return block;
 
        case 500 + ALGORITHM_RIGHT_ASYMMETRIC:
                pd = stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                if (block >= pd)
                        block++;
                return block;
 
        case 500 + ALGORITHM_LEFT_SYMMETRIC:
                pd = (raid_disks - 1) - stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                return (pd + 1 + block) % raid_disks;
 
        case 500 + ALGORITHM_RIGHT_SYMMETRIC:
                pd = stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                return (pd + 1 + block) % raid_disks;
 
        case 500 + ALGORITHM_PARITY_0:
@@ -94,7 +98,8 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                        return raid_disks - 1;
                raid_disks--;
                pd = (raid_disks-1) - stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                if (block >= pd)
                        block++;
                return block;
@@ -104,7 +109,8 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                        return raid_disks - 1;
                raid_disks--;
                pd = stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                if (block >= pd)
                        block++;
                return block;
@@ -114,7 +120,8 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                        return raid_disks - 1;
                raid_disks--;
                pd = (raid_disks - 1) - stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                return (pd + 1 + block) % raid_disks;
 
        case 600 + ALGORITHM_RIGHT_SYMMETRIC_6:
@@ -122,7 +129,8 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                        return raid_disks - 1;
                raid_disks--;
                pd = stripe % raid_disks;
-               if (block == -1) return pd;
+               if (block == -1)
+                       return pd;
                return (pd + 1 + block) % raid_disks;
 
        case 600 + ALGORITHM_PARITY_0_6:
@@ -139,8 +147,10 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
 
        case 600 + ALGORITHM_LEFT_ASYMMETRIC:
                pd = raid_disks - 1 - (stripe % raid_disks);
-               if (block == -1) return pd;
-               if (block == -2) return (pd+1) % raid_disks;
+               if (block == -1)
+                       return pd;
+               if (block == -2)
+                       return (pd+1) % raid_disks;
                if (pd == raid_disks - 1)
                        return block+1;
                if (block >= pd)
@@ -151,8 +161,10 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                /* Different order for calculating Q, otherwize same as ... */
        case 600 + ALGORITHM_RIGHT_ASYMMETRIC:
                pd = stripe % raid_disks;
-               if (block == -1) return pd;
-               if (block == -2) return (pd+1) % raid_disks;
+               if (block == -1)
+                       return pd;
+               if (block == -2)
+                       return (pd+1) % raid_disks;
                if (pd == raid_disks - 1)
                        return block+1;
                if (block >= pd)
@@ -161,14 +173,18 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
 
        case 600 + ALGORITHM_LEFT_SYMMETRIC:
                pd = raid_disks - 1 - (stripe % raid_disks);
-               if (block == -1) return pd;
-               if (block == -2) return (pd+1) % raid_disks;
+               if (block == -1)
+                       return pd;
+               if (block == -2)
+                       return (pd+1) % raid_disks;
                return (pd + 2 + block) % raid_disks;
 
        case 600 + ALGORITHM_RIGHT_SYMMETRIC:
                pd = stripe % raid_disks;
-               if (block == -1) return pd;
-               if (block == -2) return (pd+1) % raid_disks;
+               if (block == -1)
+                       return pd;
+               if (block == -2)
+                       return (pd+1) % raid_disks;
                return (pd + 2 + block) % raid_disks;
 
        case 600 + ALGORITHM_ROTATING_N_RESTART:
@@ -177,8 +193,10 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
                 * Q D D D P
                 */
                pd = raid_disks - 1 - ((stripe + 1) % raid_disks);
-               if (block == -1) return pd;
-               if (block == -2) return (pd+1) % raid_disks;
+               if (block == -1)
+                       return pd;
+               if (block == -2)
+                       return (pd+1) % raid_disks;
                if (pd == raid_disks - 1)
                        return block+1;
                if (block >= pd)
@@ -188,13 +206,16 @@ int geo_map(int block, unsigned long long stripe, int raid_disks,
        case 600 + ALGORITHM_ROTATING_N_CONTINUE:
                /* Same as left_symmetric but Q is before P */
                pd = raid_disks - 1 - (stripe % raid_disks);
-               if (block == -1) return pd;
-               if (block == -2) return (pd+raid_disks-1) % raid_disks;
+               if (block == -1)
+                       return pd;
+               if (block == -2)
+                       return (pd+raid_disks-1) % raid_disks;
                return (pd + 1 + block) % raid_disks;
        }
        return -1;
 }
-static int is_ddf(int layout)
+
+int is_ddf(int layout)
 {
        switch (layout)
        {
@@ -344,16 +365,28 @@ void ensure_zero_has_size(int chunk_size)
 /* Following was taken from linux/drivers/md/raid6recov.c */
 
 /* Recover two failed data blocks. */
+
 void raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
-                      uint8_t **ptrs)
+                      uint8_t **ptrs, int neg_offset)
 {
        uint8_t *p, *q, *dp, *dq;
        uint8_t px, qx, db;
        const uint8_t *pbmul;   /* P multiplier table for B data */
        const uint8_t *qmul;            /* Q multiplier table (for both) */
 
-       p = ptrs[disks-2];
-       q = ptrs[disks-1];
+       if (faila > failb) {
+               int t = faila;
+               faila = failb;
+               failb = t;
+       }
+
+       if (neg_offset) {
+               p = ptrs[-1];
+               q = ptrs[-2];
+       } else {
+               p = ptrs[disks-2];
+               q = ptrs[disks-1];
+       }
 
        /* Compute syndrome with zero for the missing data pages
           Use the dead data pages as temporary storage for
@@ -384,13 +417,19 @@ void raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
 }
 
 /* Recover failure of one data block plus the P block */
-void raid6_datap_recov(int disks, size_t bytes, int faila, uint8_t **ptrs)
+void raid6_datap_recov(int disks, size_t bytes, int faila, uint8_t **ptrs,
+                      int neg_offset)
 {
        uint8_t *p, *q, *dq;
        const uint8_t *qmul;            /* Q multiplier table */
 
-       p = ptrs[disks-2];
-       q = ptrs[disks-1];
+       if (neg_offset) {
+               p = ptrs[-1];
+               q = ptrs[-2];
+       } else {
+               p = ptrs[disks-2];
+               q = ptrs[disks-1];
+       }
 
        /* Compute syndrome with zero for the missing data page
           Use the dead data page as temporary storage for delta q */
@@ -415,7 +454,7 @@ void raid6_datap_recov(int disks, size_t bytes, int faila, uint8_t **ptrs)
 /* Try to find out if a specific disk has a problem */
 int raid6_check_disks(int data_disks, int start, int chunk_size,
                      int level, int layout, int diskP, int diskQ,
-                     char *p, char *q, char **stripes)
+                     uint8_t *p, uint8_t *q, char **stripes)
 {
        int i;
        int data_id, diskD;
@@ -636,16 +675,11 @@ int save_stripes(int *source, unsigned long long *offsets,
                        if (fblock[1] == data_disks)
                                /* One data failed, and parity failed */
                                raid6_datap_recov(syndrome_disks+2, chunk_size,
-                                                 fdisk[0], bufs);
+                                                 fdisk[0], bufs, 0);
                        else {
-                               if (fdisk[0] > fdisk[1]) {
-                                       int t = fdisk[0];
-                                       fdisk[0] = fdisk[1];
-                                       fdisk[1] = t;
-                               }
                                /* Two data blocks failed, P,Q OK */
                                raid6_2data_recov(syndrome_disks+2, chunk_size,
-                                                 fdisk[0], fdisk[1], bufs);
+                                                 fdisk[0], fdisk[1], bufs, 0);
                        }
                }
                if (dest) {
@@ -813,8 +847,8 @@ int test_stripes(int *source, unsigned long long *offsets,
        char *stripe_buf = xmalloc(raid_disks * chunk_size);
        char **stripes = xmalloc(raid_disks * sizeof(char*));
        char **blocks = xmalloc(raid_disks * sizeof(char*));
-       char *p = xmalloc(chunk_size);
-       char *q = xmalloc(chunk_size);
+       uint8_t *p = xmalloc(chunk_size);
+       uint8_t *q = xmalloc(chunk_size);
 
        int i;
        int diskP, diskQ;
@@ -882,7 +916,8 @@ unsigned long long getnum(char *str, char **err)
        return rv;
 }
 
-main(int argc, char *argv[])
+char const Name[] = "test_restripe";
+int main(int argc, char *argv[])
 {
        /* save/restore file raid_disks chunk_size level layout start length devices...
         */
@@ -898,8 +933,7 @@ main(int argc, char *argv[])
 
        char *err = NULL;
        if (argc < 10) {
-               fprintf(stderr, "Usage: test_stripe save/restore file raid_disks"
-                       " chunk_size level layout start length devices...\n");
+               fprintf(stderr, "Usage: test_stripe save/restore file raid_disks chunk_size level layout start length devices...\n");
                exit(1);
        }
        if (strcmp(argv[1], "save")==0)