imsm: fixup examine_brief to be more descriptive in the container only case

[thirdparty/mdadm.git] / mapfile.c

diff --git a/mapfile.c b/mapfile.c
index 112d3854c225181bafec17a619161d00b6f7ba54..a3038be55bdd3264fb8589cee9a05ad73dc53b5f 100644 (file)
--- a/mapfile.c
+++ b/mapfile.c
@@ -47,7 +47,8 @@
  * We read from the first one that exists and write to the first
  * one that we can.
  */
-#include "mdadm.h"
+#include       "mdadm.h"
+#include       <ctype.h>
 
 #define mapnames(base) { #base, #base ".new", #base ".lock"}
 char *mapname[3][3] = {
@@ -296,12 +297,50 @@ struct map_ent *map_by_name(struct map_ent **map, char *name)
        return NULL;
 }
 
+/* sets the proper subarray and container_dev according to the metadata
+ * version super_by_fd does this automatically, this routine is meant as
+ * a supplement for guess_super()
+ */
+static void set_member_info(struct supertype *st, struct mdstat_ent *ent)
+{
+       char version[strlen(ent->metadata_version)+1];
+
+       st->subarray[0] = '\0';
+
+       if (strncmp(ent->metadata_version, "external:", 9) != 0)
+               return;
+
+       strcpy(version, ent->metadata_version);
+
+       if (is_subarray(&version[9])) {
+               char *subarray = strrchr(version, '/');
+               char *name = &version[10];
+
+               if (!subarray)
+                       return;
+               *subarray++ = '\0';
+
+               st->container_dev = devname2devnum(name);
+               strncpy(st->subarray, subarray, sizeof(st->subarray));
+       }
+}
+
 void RebuildMap(void)
 {
        struct mdstat_ent *mdstat = mdstat_read(0, 0);
        struct mdstat_ent *md;
        struct map_ent *map = NULL;
        int mdp = get_mdp_major();
+       int require_homehost;
+       char sys_hostname[256];
+       char *homehost = conf_get_homehost(&require_homehost);
+
+       if (homehost == NULL || strcmp(homehost, "<system>")==0) {
+               if (gethostname(sys_hostname, sizeof(sys_hostname)) == 0) {
+                       sys_hostname[sizeof(sys_hostname)-1] = 0;
+                       homehost = sys_hostname;
+               }
+       }
 
        for (md = mdstat ; md ; md = md->next) {
                struct mdinfo *sra = sysfs_read(-1, md->devnum, GET_DEVS|SKIP_GONE_DEVS);
@@ -311,6 +350,7 @@ void RebuildMap(void)
                        continue;
 
                for (sd = sra->devs ; sd ; sd = sd->next) {
+                       char namebuf[100];
                        char dn[30];
                        int dfd;
                        int ok;
@@ -325,8 +365,10 @@ void RebuildMap(void)
                        st = guess_super(dfd);
                        if ( st == NULL)
                                ok = -1;
-                       else
+                       else {
+                               set_member_info(st, md);
                                ok = st->ss->load_super(st, dfd, NULL);
+                       }
                        close(dfd);
                        if (ok != 0)
                                continue;
@@ -335,6 +377,77 @@ void RebuildMap(void)
                                path = map_dev(MD_MAJOR, md->devnum, 0);
                        else
                                path = map_dev(mdp, (-1-md->devnum)<< 6, 0);
+                       if (path == NULL ||
+                           strncmp(path, "/dev/md/", 8) != 0) {
+                               /* We would really like a name that provides
+                                * an MD_DEVNAME for udev.
+                                * The name needs to be unique both in /dev/md/
+                                * and in this mapfile.
+                                * It needs to match watch -I or -As would come
+                                * up with.
+                                * That means:
+                                *   Check if array is in mdadm.conf 
+                                *        - if so use that.
+                                *   determine trustworthy from homehost etc
+                                *   find a unique name based on metadata name.
+                                *   
+                                */
+                               struct mddev_ident_s *match = conf_match(&info, st);
+                               struct stat stb;
+                               if (match && match->devname && match->devname[0] == '/') {
+                                       path = match->devname;
+                                       if (path[0] != '/') {
+                                               strcpy(namebuf, "/dev/md/");
+                                               strcat(namebuf, path);
+                                               path = namebuf;
+                                       }
+                               } else {
+                                       int unum = 0;
+                                       char *sep = "_";
+                                       const char *name;
+                                       int conflict = 1;
+                                       if ((homehost == NULL ||
+                                            st->ss->match_home(st, homehost) != 1) &&
+                                           st->ss->match_home(st, "any") != 1 &&
+                                           (require_homehost
+                                            || ! conf_name_is_free(info.name)))
+                                               /* require a numeric suffix */
+                                               unum = 0;
+                                       else
+                                               /* allow name to be used as-is if no conflict */
+                                               unum = -1;
+                                       name = info.name;
+                                       if (!*name) {
+                                               name = st->ss->name;
+                                               if (!isdigit(name[strlen(name)-1]) &&
+                                                   unum == -1) {
+                                                       unum = 0;
+                                                       sep = "";
+                                               }
+                                       }
+                                       if (strchr(name, ':'))
+                                               /* probably a uniquifying
+                                                * hostname prefix.  Allow
+                                                * without a suffix
+                                                */
+                                               unum = -1;
+
+                                       while (conflict) {
+                                               if (unum >= 0)
+                                                       sprintf(namebuf, "/dev/md/%s%s%d",
+                                                               name, sep, unum);
+                                               else
+                                                       sprintf(namebuf, "/dev/md/%s",
+                                                               name);
+                                               unum++;
+                                               if (lstat(namebuf, &stb) != 0 &&
+                                                   (map == NULL ||
+                                                    !map_by_name(&map, namebuf+8)))
+                                                       conflict = 0;
+                                       }
+                                       path = namebuf;
+                               }
+                       }
                        map_add(&map, md->devnum,
                                info.text_version,
                                info.uuid, path);