main: factor out code to parse layout for raid10 and faulty.

[thirdparty/mdadm.git] / util.c

diff --git a/util.c b/util.c
index b2fbec7a91c7f3f2059c66b6ed0488d156b73ca7..c0c3f0c97c4147c541ffbce3c0398cb7cba69262 100644 (file)
--- a/util.c
+++ b/util.c
@@ -154,6 +154,71 @@ int get_linux_version()
        return (a*1000000)+(b*1000)+c;
 }
 
+long long parse_size(char *size)
+{
+       /* parse 'size' which should be a number optionally
+        * followed by 'K', 'M', or 'G'.
+        * Without a suffix, K is assumed.
+        * Number returned is in sectors (half-K)
+        */
+       char *c;
+       long long s = strtoll(size, &c, 10);
+       if (s > 0) {
+               switch (*c) {
+               case 'K':
+                       c++;
+               default:
+                       s *= 2;
+                       break;
+               case 'M':
+                       c++;
+                       s *= 1024 * 2;
+                       break;
+               case 'G':
+                       c++;
+                       s *= 1024 * 1024 * 2;
+                       break;
+               }
+       }
+       if (*c)
+               s = 0;
+       return s;
+}
+
+int parse_layout_10(char *layout)
+{
+       int copies, rv;
+       char *cp;
+       /* Parse the layout string for raid10 */
+       /* 'f', 'o' or 'n' followed by a number <= raid_disks */
+       if ((layout[0] !=  'n' && layout[0] != 'f' && layout[0] != 'o') ||
+           (copies = strtoul(layout+1, &cp, 10)) < 1 ||
+           copies > 200 ||
+           *cp)
+               return -1;
+       if (layout[0] == 'n')
+               rv = 256 + copies;
+       else if (layout[0] == 'o')
+               rv = 0x10000 + (copies<<8) + 1;
+       else
+               rv = 1 + (copies<<8);
+       return rv;
+}
+
+int parse_layout_faulty(char *layout)
+{
+       /* Parse the layout string for 'faulty' */
+       int ln = strcspn(layout, "0123456789");
+       char *m = strdup(layout);
+       int mode;
+       m[ln] = 0;
+       mode = map_name(faultylayout, m);
+       if (mode == UnSet)
+               return -1;
+
+       return mode | (atoi(layout+ln)<< ModeShift);
+}
+
 void remove_partitions(int fd)
 {
        /* remove partitions from this block devices.
@@ -511,14 +576,13 @@ int nftw(const char *path, int (*han)(const char *name, const struct stat *stb,
 /*
  * Find a block device with the right major/minor number.
  * If we find multiple names, choose the shortest.
- * If we find a non-standard name, it is probably there
- * deliberately so prefer it over a standard name.
+ * If we find a name in /dev/md/, we prefer that.
  * This applies only to names for MD devices.
  */
 char *map_dev(int major, int minor, int create)
 {
        struct devmap *p;
-       char *std = NULL, *nonstd=NULL;
+       char *regular = NULL, *preferred=NULL;
        int did_check = 0;
 
        if (major == 0 && minor == 0)
@@ -545,27 +609,27 @@ char *map_dev(int major, int minor, int create)
        for (p=devlist; p; p=p->next)
                if (p->major == major &&
                    p->minor == minor) {
-                       if (is_standard(p->name, NULL)) {
-                               if (std == NULL ||
-                                   strlen(p->name) < strlen(std))
-                                       std = p->name;
+                       if (strncmp(p->name, "/dev/md/",8) == 0) {
+                               if (preferred == NULL ||
+                                   strlen(p->name) < strlen(preferred))
+                                       preferred = p->name;
                        } else {
-                               if (nonstd == NULL ||
-                                   strlen(p->name) < strlen(nonstd))
-                                       nonstd = p->name;
+                               if (regular == NULL ||
+                                   strlen(p->name) < strlen(regular))
+                                       regular = p->name;
                        }
                }
-       if (!std && !nonstd && !did_check) {
+       if (!regular && !preferred && !did_check) {
                devlist_ready = 0;
                goto retry;
        }
-       if (create && !std && !nonstd) {
+       if (create && !regular && !preferred) {
                static char buf[30];
                snprintf(buf, sizeof(buf), "%d:%d", major, minor);
-               nonstd = buf;
+               regular = buf;
        }
 
-       return nonstd ? nonstd : std;
+       return preferred ? preferred : regular;
 }
 
 unsigned long calc_csum(void *super, int bytes)
@@ -765,7 +829,7 @@ int find_free_devnum(int use_partitions)
 {
        int devnum;
        for (devnum = 127; devnum != 128;
-            devnum = devnum ? devnum-1 : (1<<22)-1) {
+            devnum = devnum ? devnum-1 : (1<<20)-1) {
                char *dn;
                int _devnum;
 
@@ -813,6 +877,14 @@ int dev_open(char *dev, int flags)
        return fd;
 }
 
+int open_dev(int devnum)
+{
+       char buf[20];
+
+       sprintf(buf, "%d:%d", dev2major(devnum), dev2minor(devnum));
+       return dev_open(buf, O_RDWR);
+}
+
 int open_dev_excl(int devnum)
 {
        char buf[20];
@@ -844,13 +916,20 @@ int same_dev(char *one, char *two)
        return st1.st_rdev == st2.st_rdev;
 }
 
-void wait_for(char *dev)
+void wait_for(char *dev, int fd)
 {
        int i;
+       struct stat stb_want;
+
+       if (fstat(fd, &stb_want) != 0 ||
+           (stb_want.st_mode & S_IFMT) != S_IFBLK)
+               return;
 
        for (i=0 ; i<25 ; i++) {
                struct stat stb;
-               if (stat(dev, &stb) == 0)
+               if (stat(dev, &stb) == 0 &&
+                   (stb.st_mode & S_IFMT) == S_IFBLK &&
+                   (stb.st_rdev == stb_want.st_rdev))
                        return;
                usleep(200000);
        }
@@ -901,7 +980,10 @@ struct supertype *super_by_fd(int fd)
                if (sra)
                        sysfs_free(sra);
                sra = sysfs_read(-1, devnum, GET_VERSION);
-               verstr = sra->text_version ? : "-no-metadata-";
+               if (sra && sra->text_version[0])
+                       verstr = sra->text_version;
+               else
+                       verstr = "-no-metadata-";
        }
 
        for (i = 0; st == NULL && superlist[i] ; i++)
@@ -1077,7 +1159,8 @@ int add_disk(int mdfd, struct supertype *st,
        int rv;
 #ifndef MDASSEMBLE
        if (st->ss->external) {
-               rv = sysfs_add_disk(sra, info);
+               rv = sysfs_add_disk(sra, info,
+                                   info->disk.state & (1<<MD_DISK_SYNC));
                if (! rv) {
                        struct mdinfo *sd2;
                        for (sd2 = sra->devs; sd2; sd2=sd2->next)
@@ -1261,9 +1344,8 @@ int start_mdmon(int devnum)
                for (i=0; paths[i]; i++)
                        if (paths[i][0])
                                execl(paths[i], "mdmon",
-                                     map_dev(dev2major(devnum),
-                                             dev2minor(devnum),
-                                             1), NULL);
+                                     devnum2devname(devnum),
+                                     NULL);
                exit(1);
        case -1: fprintf(stderr, Name ": cannot run mdmon. "
                         "Array remains readonly\n");