X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=Monitor.c;h=802a9d9864b9cbec68ec8d2214642970070160a7;hb=a8cb6604b606deaaa66979e84a6f1c6d2c044b3b;hp=8d397bc072d9fa61b8130e4ff76e5deb0b9a8ee3;hpb=24baa548c4e66487b30a0c83349886dee5ecc76f;p=thirdparty%2Fmdadm.git diff --git a/Monitor.c b/Monitor.c index 8d397bc0..802a9d98 100644 --- a/Monitor.c +++ b/Monitor.c @@ -30,25 +30,22 @@ #include #include -/* The largest number of disks current arrays can manage is 384 - * This really should be dynamically, but that will have to wait - * At least it isn't MD_SB_DISKS. - */ -#define MaxDisks 384 struct state { char *devname; - int devnum; /* to sync with mdstat info */ - long utime; + char devnm[32]; /* to sync with mdstat info */ + unsigned int utime; int err; char *spare_group; int active, working, failed, spare, raid; + int from_config; + int from_auto; int expected_spares; - int devstate[MaxDisks]; - dev_t devid[MaxDisks]; + int devstate[MAX_DISKS]; + dev_t devid[MAX_DISKS]; int percent; - int parent_dev; /* For subarray, devnum of parent. - * For others, NoMdDev - */ + char parent_devnm[32]; /* For subarray, devnm of parent. + * For others, "" + */ struct supertype *metadata; struct state *subarray;/* for a container it is a link to first subarray * for a subarray it is a link to next subarray @@ -69,16 +66,17 @@ static int check_one_sharer(int scan); static void alert(char *event, char *dev, char *disc, struct alert_info *info); static int check_array(struct state *st, struct mdstat_ent *mdstat, int test, struct alert_info *info, - int increments); -static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist, + int increments, char *prefer); +static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist, int test, struct alert_info *info); static void try_spare_migration(struct state *statelist, struct alert_info *info); static void link_containers_with_subarrays(struct state *list); int Monitor(struct mddev_dev *devlist, char *mailaddr, char *alert_cmd, - int period, int daemonise, int scan, int oneshot, - int dosyslog, int test, char *pidfile, int increments, + struct context *c, + int daemonise, int oneshot, + int dosyslog, char *pidfile, int increments, int share) { /* @@ -124,6 +122,7 @@ int Monitor(struct mddev_dev *devlist, */ struct state *statelist = NULL; + struct state *st2; int finished = 0; struct mdstat_ent *mdstat = NULL; char *mailfrom = NULL; @@ -131,20 +130,20 @@ int Monitor(struct mddev_dev *devlist, if (!mailaddr) { mailaddr = conf_get_mailaddr(); - if (mailaddr && ! scan) - fprintf(stderr, Name ": Monitor using email address \"%s\" from config file\n", + if (mailaddr && ! c->scan) + pr_err("Monitor using email address \"%s\" from config file\n", mailaddr); } mailfrom = conf_get_mailfrom(); if (!alert_cmd) { alert_cmd = conf_get_program(); - if (alert_cmd && ! scan) - fprintf(stderr, Name ": Monitor using program \"%s\" from config file\n", + if (alert_cmd && ! c->scan) + pr_err("Monitor using program \"%s\" from config file\n", alert_cmd); } - if (scan && !mailaddr && !alert_cmd) { - fprintf(stderr, Name ": No mail address or alert command - not monitoring.\n"); + if (c->scan && !mailaddr && !alert_cmd && !dosyslog) { + pr_err("No mail address or alert command - not monitoring.\n"); return 1; } info.alert_cmd = alert_cmd; @@ -152,12 +151,14 @@ int Monitor(struct mddev_dev *devlist, info.mailfrom = mailfrom; info.dosyslog = dosyslog; - if (daemonise) - if (make_daemon(pidfile)) - return 1; + if (daemonise) { + int rv = make_daemon(pidfile); + if (rv >= 0) + return rv; + } - if (share) - if (check_one_sharer(scan)) + if (share) + if (check_one_sharer(c->scan)) return 1; if (devlist == NULL) { @@ -168,62 +169,61 @@ int Monitor(struct mddev_dev *devlist, continue; if (strcasecmp(mdlist->devname, "") == 0) continue; - st = calloc(1, sizeof *st); - if (st == NULL) - continue; + st = xcalloc(1, sizeof *st); if (mdlist->devname[0] == '/') - st->devname = strdup(mdlist->devname); + st->devname = xstrdup(mdlist->devname); else { - st->devname = malloc(8+strlen(mdlist->devname)+1); + st->devname = xmalloc(8+strlen(mdlist->devname)+1); strcpy(strcpy(st->devname, "/dev/md/"), mdlist->devname); } st->next = statelist; - st->devnum = INT_MAX; - st->percent = -2; + st->devnm[0] = 0; + st->percent = RESYNC_UNKNOWN; + st->from_config = 1; st->expected_spares = mdlist->spare_disks; if (mdlist->spare_group) - st->spare_group = strdup(mdlist->spare_group); + st->spare_group = xstrdup(mdlist->spare_group); statelist = st; } } else { struct mddev_dev *dv; for (dv=devlist ; dv; dv=dv->next) { struct mddev_ident *mdlist = conf_get_ident(dv->devname); - struct state *st = calloc(1, sizeof *st); - if (st == NULL) - continue; - st->devname = strdup(dv->devname); + struct state *st = xcalloc(1, sizeof *st); + st->devname = xstrdup(dv->devname); st->next = statelist; - st->devnum = INT_MAX; - st->percent = -2; + st->devnm[0] = 0; + st->percent = RESYNC_UNKNOWN; st->expected_spares = -1; if (mdlist) { st->expected_spares = mdlist->spare_disks; if (mdlist->spare_group) - st->spare_group = strdup(mdlist->spare_group); + st->spare_group = xstrdup(mdlist->spare_group); } statelist = st; } } - while (! finished) { int new_found = 0; - struct state *st; + struct state *st, **stp; int anydegraded = 0; if (mdstat) free_mdstat(mdstat); mdstat = mdstat_read(oneshot?0:1, 0); + if (!mdstat) + mdstat_close(); for (st=statelist; st; st=st->next) - if (check_array(st, mdstat, test, &info, increments)) + if (check_array(st, mdstat, c->test, &info, + increments, c->prefer)) anydegraded = 1; - + /* now check if there are any new devices found in mdstat */ - if (scan) - new_found = add_new_arrays(mdstat, statelist, test, + if (c->scan) + new_found = add_new_arrays(mdstat, &statelist, c->test, &info); /* If an array has active < raid && spare == 0 && spare_group != NULL @@ -236,10 +236,25 @@ int Monitor(struct mddev_dev *devlist, if (oneshot) break; else - mdstat_wait(period); + mdstat_wait(c->delay); } - test = 0; + c->test = 0; + + for (stp = &statelist; (st = *stp) != NULL; ) { + if (st->from_auto && st->err > 5) { + *stp = st->next; + free(st->devname); + free(st->spare_group); + free(st); + } else + stp = &st->next; + } + } + for (st2 = statelist; st2; st2 = statelist) { + statelist = st2->next; + free(st2); } + if (pidfile) unlink(pidfile); return 0; @@ -247,6 +262,12 @@ int Monitor(struct mddev_dev *devlist, static int make_daemon(char *pidfile) { + /* Return: + * -1 in the forked daemon + * 0 in the parent + * 1 on error + * so a none-negative becomes the exit code. + */ int pid = fork(); if (pid > 0) { if (!pidfile) @@ -272,7 +293,7 @@ static int make_daemon(char *pidfile) dup2(0,1); dup2(0,2); setsid(); - return 0; + return -1; } static int check_one_sharer(int scan) @@ -280,37 +301,39 @@ static int check_one_sharer(int scan) int pid, rv; FILE *fp; char dir[20]; + char path[100]; struct stat buf; - fp = fopen("/var/run/mdadm/autorebuild.pid", "r"); + sprintf(path, "%s/autorebuild.pid", MDMON_DIR); + fp = fopen(path, "r"); if (fp) { - fscanf(fp, "%d", &pid); + if (fscanf(fp, "%d", &pid) != 1) + pid = -1; sprintf(dir, "/proc/%d", pid); rv = stat(dir, &buf); if (rv != -1) { if (scan) { - fprintf(stderr, Name ": Only one " - "autorebuild process allowed" - " in scan mode, aborting\n"); + pr_err("Only one autorebuild process allowed in scan mode, aborting\n"); fclose(fp); return 1; } else { - fprintf(stderr, Name ": Warning: One" - " autorebuild process already" - " running."); + pr_err("Warning: One autorebuild process already running.\n"); } } fclose(fp); } if (scan) { - fp = fopen("/var/run/mdadm/autorebuild.pid", "w"); - if (!fp) - fprintf(stderr, Name ": Cannot create" - " autorebuild.pid " - "file\n"); - else { - pid = getpid(); - fprintf(fp, "%d\n", pid); - fclose(fp); + if (mkdir(MDMON_DIR, S_IRWXU) < 0 && + errno != EEXIST) { + pr_err("Can't create autorebuild.pid file\n"); + } else { + fp = fopen(path, "w"); + if (!fp) + pr_err("Cannot create autorebuild.pidfile\n"); + else { + pid = getpid(); + fprintf(fp, "%d\n", pid); + fclose(fp); + } } } return 0; @@ -320,7 +343,7 @@ static void alert(char *event, char *dev, char *disc, struct alert_info *info) { int priority; - if (!info->alert_cmd && !info->mailaddr) { + if (!info->alert_cmd && !info->mailaddr && !info->dosyslog) { time_t now = time(0); printf("%1.15s: %s on %s %s\n", ctime(&now)+4, event, dev, disc?disc:"unknown device"); @@ -353,24 +376,21 @@ static void alert(char *event, char *dev, char *disc, struct alert_info *info) if (info->mailfrom) fprintf(mp, "From: %s\n", info->mailfrom); else - fprintf(mp, "From: " Name " monitoring \n"); + fprintf(mp, "From: %s monitoring \n", Name); fprintf(mp, "To: %s\n", info->mailaddr); fprintf(mp, "Subject: %s event on %s:%s\n\n", event, dev, hname); fprintf(mp, - "This is an automatically generated" - " mail message from " Name "\n"); + "This is an automatically generated mail message from %s\n", Name); fprintf(mp, "running on %s\n\n", hname); fprintf(mp, - "A %s event had been detected on" - " md device %s.\n\n", event, dev); + "A %s event had been detected on md device %s.\n\n", event, dev); if (disc && disc[0] != ' ') fprintf(mp, - "It could be related to" - " component device %s.\n\n", disc); + "It could be related to component device %s.\n\n", disc); if (disc && disc[0] == ' ') fprintf(mp, "Extra information:%s.\n\n", disc); @@ -381,8 +401,7 @@ static void alert(char *event, char *dev, char *disc, struct alert_info *info) char buf[8192]; int n; fprintf(mp, - "\nP.S. The /proc/mdstat file" - " currently contains the following:\n\n"); + "\nP.S. The /proc/mdstat file currently contains the following:\n\n"); while ( (n=fread(buf, 1, sizeof(buf), mdstat)) > 0) n=fwrite(buf, 1, n, mp); fclose(mdstat); @@ -409,10 +428,13 @@ static void alert(char *event, char *dev, char *disc, struct alert_info *info) else priority = LOG_INFO; - if (disc) + if (disc && disc[0] != ' ') syslog(priority, - "%s event detected on md device %s," - " component device %s", event, dev, disc); + "%s event detected on md device %s, component device %s", event, dev, disc); + else if (disc) + syslog(priority, + "%s event detected on md device %s: %s", + event, dev, disc); else syslog(priority, "%s event detected on md device %s", @@ -422,33 +444,63 @@ static void alert(char *event, char *dev, char *disc, struct alert_info *info) static int check_array(struct state *st, struct mdstat_ent *mdstat, int test, struct alert_info *ainfo, - int increments) + int increments, char *prefer) { /* Update the state 'st' to reflect any changes shown in mdstat, * or found by directly examining the array, and return * '1' if the array is degraded, or '0' if it is optimal (or dead). */ - struct { int state, major, minor; } info[MaxDisks]; + struct { int state, major, minor; } info[MAX_DISKS]; mdu_array_info_t array; struct mdstat_ent *mse = NULL, *mse2; char *dev = st->devname; - int fd; + int fd = -1; int i; + int remaining_disks; + int last_disk; + int new_array = 0; if (test) alert("TestMessage", dev, NULL, ainfo); + if (st->devnm[0]) + fd = open("/sys/block", O_RDONLY|O_DIRECTORY); + if (fd >= 0) { + /* Don't open the device unless it is present and + * active in sysfs. + */ + char buf[10]; + close(fd); + fd = sysfs_open(st->devnm, NULL, "array_state"); + if (fd < 0 || + read(fd, buf, 10) < 5 || + strncmp(buf,"clear",5) == 0 || + strncmp(buf,"inact",5) == 0) { + if (fd >= 0) + close(fd); + fd = sysfs_open(st->devnm, NULL, "level"); + if (fd < 0 || read(fd, buf, 10) != 0) { + if (fd >= 0) + close(fd); + if (!st->err) + alert("DeviceDisappeared", dev, NULL, ainfo); + st->err++; + return 0; + } + } + close(fd); + } fd = open(dev, O_RDONLY); if (fd < 0) { if (!st->err) alert("DeviceDisappeared", dev, NULL, ainfo); - st->err=1; + st->err++; return 0; } fcntl(fd, F_SETFD, FD_CLOEXEC); if (ioctl(fd, GET_ARRAY_INFO, &array)<0) { if (!st->err) alert("DeviceDisappeared", dev, NULL, ainfo); - st->err=1; + st->err++; close(fd); return 0; } @@ -456,33 +508,25 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, * have a device disappear than all of them that can */ if (array.level == 0 || array.level == -1) { - if (!st->err) - alert("DeviceDisappeared", dev, "Wrong-Level", ainfo); - st->err = 1; + if (!st->err && !st->from_config) + alert("DeviceDisappeared", dev, " Wrong-Level", ainfo); + st->err++; close(fd); return 0; } - if (st->devnum == INT_MAX) { - struct stat stb; - if (fstat(fd, &stb) == 0 && - (S_IFMT&stb.st_mode)==S_IFBLK) { - if (major(stb.st_rdev) == MD_MAJOR) - st->devnum = minor(stb.st_rdev); - else - st->devnum = -1- (minor(stb.st_rdev)>>6); - } - } + if (st->devnm[0] == 0) + strcpy(st->devnm, fd2devnm(fd)); for (mse2 = mdstat ; mse2 ; mse2=mse2->next) - if (mse2->devnum == st->devnum) { - mse2->devnum = INT_MAX; /* flag it as "used" */ + if (strcmp(mse2->devnm, st->devnm) == 0) { + mse2->devnm[0] = 0; /* flag it as "used" */ mse = mse2; } if (!mse) { /* duplicated array in statelist * or re-created after reading mdstat*/ - st->err = 1; + st->err++; close(fd); return 0; } @@ -492,6 +536,14 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, * just make sure it is always different. */ array.utime = st->utime + 1;; + if (st->err) { + /* New array appeared where previously had an error */ + st->err = 0; + st->percent = RESYNC_NONE; + new_array = 1; + alert("NewArray", st->devname, NULL, ainfo); + } + if (st->utime == array.utime && st->failed == array.failed_disks && st->working == array.working_disks && @@ -500,7 +552,6 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, mse->percent == st->percent ))) { close(fd); - st->err = 0; if ((st->active < st->raid) && st->spare == 0) return 1; else @@ -515,7 +566,7 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, st->expected_spares > 0 && array.spare_disks < st->expected_spares) alert("SparesMissing", dev, NULL, ainfo); - if (st->percent == -1 && + if (st->percent < 0 && st->percent != RESYNC_UNKNOWN && mse->percent >= 0) alert("RebuildStarted", dev, NULL, ainfo); if (st->percent >= 0 && @@ -531,26 +582,29 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, alert(percentalert, dev, NULL, ainfo); } - if (mse->percent == -1 && + if (mse->percent == RESYNC_NONE && st->percent >= 0) { /* Rebuild/sync/whatever just finished. * If there is a number in /mismatch_cnt, * we should report that. */ struct mdinfo *sra = - sysfs_read(-1, st->devnum, GET_MISMATCH); + sysfs_read(-1, st->devnm, GET_MISMATCH); if (sra && sra->mismatch_cnt > 0) { - char cnt[40]; - sprintf(cnt, " mismatches found: %d", sra->mismatch_cnt); + char cnt[80]; + snprintf(cnt, sizeof(cnt), + " mismatches found: %d (on raid level %d)", + sra->mismatch_cnt, array.level); alert("RebuildFinished", dev, cnt, ainfo); } else alert("RebuildFinished", dev, NULL, ainfo); if (sra) - free(sra); + sysfs_free(sra); } st->percent = mse->percent; - for (i=0; i 0; i++) { mdu_disk_info_t disc; disc.number = i; @@ -558,67 +612,61 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, info[i].state = disc.state; info[i].major = disc.major; info[i].minor = disc.minor; + if (disc.major || disc.minor) + remaining_disks --; } else info[i].major = info[i].minor = 0; } - - if (strncmp(mse->metadata_version, "external:", 9) == 0 && - is_subarray(mse->metadata_version+9)) - st->parent_dev = - devname2devnum(mse->metadata_version+10); - else - st->parent_dev = NoMdDev; + last_disk = i; + + if (mse->metadata_version && + strncmp(mse->metadata_version, "external:", 9) == 0 && + is_subarray(mse->metadata_version+9)) { + char *sl; + strcpy(st->parent_devnm, + mse->metadata_version+10); + sl = strchr(st->parent_devnm, '/'); + if (sl) + *sl = 0; + } else + st->parent_devnm[0] = 0; if (st->metadata == NULL && - st->parent_dev == NoMdDev) + st->parent_devnm[0] == 0) st->metadata = super_by_fd(fd, NULL); close(fd); - for (i=0; i array.raid_disks + array.nr_disks) { - newstate = 0; - disc.major = disc.minor = 0; - } else if (info[i].major || info[i].minor) { + if (i < last_disk && + (info[i].major || info[i].minor)) { newstate = info[i].state; - dv = map_dev(info[i].major, info[i].minor, 1); + dv = map_dev_preferred( + info[i].major, info[i].minor, 1, + prefer); disc.state = newstate; disc.major = info[i].major; disc.minor = info[i].minor; - } else if (mse && mse->pattern && i < (int)strlen(mse->pattern)) { - switch(mse->pattern[i]) { - case 'U': newstate = 6 /* ACTIVE/SYNC */; break; - case '_': newstate = 0; break; - } - disc.major = disc.minor = 0; - } + } else + newstate = (1 << MD_DISK_REMOVED); + if (dv == NULL && st->devid[i]) - dv = map_dev(major(st->devid[i]), - minor(st->devid[i]), 1); + dv = map_dev_preferred( + major(st->devid[i]), + minor(st->devid[i]), 1, prefer); change = newstate ^ st->devstate[i]; - if (st->utime && change && !st->err) { - if (i < array.raid_disks && - (((newstate&change)&(1<devstate[i]&change)&(1<devstate[i]&change)&(1<utime && change && !st->err && !new_array) { + if ((st->devstate[i]&change)&(1<= array.raid_disks && + else if ((newstate & (1<devid[i] == makedev(disc.major, disc.minor) && - ((newstate&change)&(1<devid[i] == makedev(disc.major, disc.minor)) alert("FailSpare", dev, dv, ainfo); - else if (i < array.raid_disks && - ! (newstate & (1<devstate[i]&change)&(1<devstate[i] = newstate; @@ -636,24 +684,30 @@ static int check_array(struct state *st, struct mdstat_ent *mdstat, return 0; } -static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist, +static int add_new_arrays(struct mdstat_ent *mdstat, struct state **statelist, int test, struct alert_info *info) { struct mdstat_ent *mse; int new_found = 0; + char *name; for (mse=mdstat; mse; mse=mse->next) - if (mse->devnum != INT_MAX && + if (mse->devnm[0] && (!mse->level || /* retrieve containers */ (strcmp(mse->level, "raid0") != 0 && strcmp(mse->level, "linear") != 0)) ) { - struct state *st = calloc(1, sizeof *st); + struct state *st = xcalloc(1, sizeof *st); mdu_array_info_t array; int fd; - if (st == NULL) + + name = get_md_name(mse->devnm); + if (!name) { + free(st); continue; - st->devname = strdup(get_md_name(mse->devnum)); + } + + st->devname = xstrdup(name); if ((fd = open(st->devname, O_RDONLY)) < 0 || ioctl(fd, GET_ARRAY_INFO, &array)< 0) { /* no such array */ @@ -668,88 +722,57 @@ static int add_new_arrays(struct mdstat_ent *mdstat, struct state *statelist, continue; } close(fd); - st->next = statelist; + st->next = *statelist; st->err = 1; - st->devnum = mse->devnum; - st->percent = -2; + st->from_auto = 1; + strcpy(st->devnm, mse->devnm); + st->percent = RESYNC_UNKNOWN; st->expected_spares = -1; - if (strncmp(mse->metadata_version, "external:", 9) == 0 && - is_subarray(mse->metadata_version+9)) - st->parent_dev = - devname2devnum(mse->metadata_version+10); - else - st->parent_dev = NoMdDev; - statelist = st; + if (mse->metadata_version && + strncmp(mse->metadata_version, "external:", 9) == 0 && + is_subarray(mse->metadata_version+9)) { + char *sl; + strcpy(st->parent_devnm, + mse->metadata_version+10); + sl = strchr(st->parent_devnm, '/'); + *sl = 0; + } else + st->parent_devnm[0] = 0; + *statelist = st; if (test) alert("TestMessage", st->devname, NULL, info); - alert("NewArray", st->devname, NULL, info); new_found = 1; } return new_found; } -unsigned long long min_spare_size_required(struct state *st) +static int get_min_spare_size_required(struct state *st, unsigned long long *sizep) { int fd; - unsigned long long rv = 0; if (!st->metadata || - !st->metadata->ss->min_acceptable_spare_size) - return rv; + !st->metadata->ss->min_acceptable_spare_size) { + *sizep = 0; + return 0; + } fd = open(st->devname, O_RDONLY); if (fd < 0) - return 0; - st->metadata->ss->load_super(st->metadata, fd, st->devname); + return 1; + if (st->metadata->ss->external) + st->metadata->ss->load_container(st->metadata, fd, st->devname); + else + st->metadata->ss->load_super(st->metadata, fd, st->devname); close(fd); - rv = st->metadata->ss->min_acceptable_spare_size(st->metadata); + if (!st->metadata->sb) + return 1; + *sizep = st->metadata->ss->min_acceptable_spare_size(st->metadata); st->metadata->ss->free_super(st->metadata); - return rv; -} - -static int move_spare(struct state *from, struct state *to, - dev_t devid, - struct alert_info *info) -{ - struct mddev_dev devlist; - char devname[20]; - - /* try to remove and add */ - int fd1 = open(to->devname, O_RDONLY); - int fd2 = open(from->devname, O_RDONLY); - - if (fd1 < 0 || fd2 < 0) { - if (fd1>=0) close(fd1); - if (fd2>=0) close(fd2); - return 0; - } - - devlist.next = NULL; - devlist.used = 0; - devlist.re_add = 0; - devlist.writemostly = 0; - devlist.devname = devname; - sprintf(devname, "%d:%d", major(devid), minor(devid)); - - devlist.disposition = 'r'; - if (Manage_subdevs(from->devname, fd2, &devlist, -1, 0) == 0) { - devlist.disposition = 'a'; - if (Manage_subdevs(to->devname, fd1, &devlist, -1, 0) == 0) { - alert("MoveSpare", to->devname, from->devname, info); - close(fd1); - close(fd2); - return 1; - } - else Manage_subdevs(from->devname, fd2, &devlist, -1, 0); - } - close(fd1); - close(fd2); return 0; } -static int check_donor(struct state *from, struct state *to, - struct domainlist *domlist) +static int check_donor(struct state *from, struct state *to) { struct state *sub; @@ -771,35 +794,35 @@ static int check_donor(struct state *from, struct state *to, return 0; if (from->spare <= 0) return 0; - if (domlist == NULL) - return 0; return 1; } static dev_t choose_spare(struct state *from, struct state *to, - struct domainlist *domlist) + struct domainlist *domlist, unsigned long long min_size) { int d; dev_t dev = 0; - unsigned long long min_size - = min_spare_size_required(to); - for (d = from->raid; !dev && d < MaxDisks; d++) { + for (d = from->raid; !dev && d < MAX_DISKS; d++) { if (from->devid[d] > 0 && from->devstate[d] == 0) { struct dev_policy *pol; unsigned long long dev_size; + if (to->metadata->ss->external && + test_partition_from_id(from->devid[d])) + continue; + if (min_size && dev_size_from_id(from->devid[d], &dev_size) && dev_size < min_size) continue; - pol = devnum_policy(from->devid[d]); + pol = devid_policy(from->devid[d]); if (from->spare_group) pol_add(&pol, pol_domain, from->spare_group, NULL); - if (domain_test(domlist, pol, to->metadata->ss->name)) + if (domain_test(domlist, pol, to->metadata->ss->name) == 1) dev = from->devid[d]; dev_policy_free(pol); } @@ -808,63 +831,70 @@ static dev_t choose_spare(struct state *from, struct state *to, } static dev_t container_choose_spare(struct state *from, struct state *to, - struct domainlist *domlist) + struct domainlist *domlist, + unsigned long long min_size, int active) { /* This is similar to choose_spare, but we cannot trust devstate, * so we need to read the metadata instead */ - + struct mdinfo *list; struct supertype *st = from->metadata; int fd = open(from->devname, O_RDONLY); int err; - struct mdinfo *disks, *d; - unsigned long long min_size - = min_spare_size_required(to); dev_t dev = 0; if (fd < 0) return 0; - if (!st->ss->getinfo_super_disks) + if (!st->ss->getinfo_super_disks) { + close(fd); return 0; - + } + err = st->ss->load_container(st, fd, NULL); close(fd); if (err) return 0; - disks = st->ss->getinfo_super_disks(st); - st->ss->free_super(st); - - if (!disks) - return 0; - - for (d = disks->devs ; d && !dev ; d = d->next) { - if (d->disk.state == 0) { - struct dev_policy *pol; - unsigned long long dev_size; - dev = makedev(d->disk.major,d->disk.minor); - - if (min_size && - dev_size_from_id(dev, &dev_size) && - dev_size < min_size) { - dev = 0; - continue; - } - pol = devnum_policy(dev); - if (from->spare_group) - pol_add(&pol, pol_domain, - from->spare_group, NULL); - if (!domain_test(domlist, pol, to->metadata->ss->name)) - dev = 0; - - dev_policy_free(pol); + if (from == to) { + /* We must check if number of active disks has not increased + * since ioctl in main loop. mdmon may have added spare + * to subarray. If so we do not need to look for more spares + * so return non zero value */ + int active_cnt = 0; + struct mdinfo *dp; + list = st->ss->getinfo_super_disks(st); + if (!list) { + st->ss->free_super(st); + return 1; + } + dp = list->devs; + while (dp) { + if (dp->disk.state & (1<disk.state & (1<next; } + sysfs_free(list); + if (active < active_cnt) { + /* Spare just activated.*/ + st->ss->free_super(st); + return 1; + } + } + + /* We only need one spare so full list not needed */ + list = container_choose_spares(st, min_size, domlist, from->spare_group, + to->metadata->ss->name, 1); + if (list) { + struct mdinfo *disks = list->devs; + if (disks) + dev = makedev(disks->disk.major, disks->disk.minor); + sysfs_free(list); } - sysfs_free(disks); + st->ss->free_super(st); return dev; } - static void try_spare_migration(struct state *statelist, struct alert_info *info) { struct state *from; @@ -873,35 +903,60 @@ static void try_spare_migration(struct state *statelist, struct alert_info *info link_containers_with_subarrays(statelist); for (st = statelist; st; st = st->next) if (st->active < st->raid && - st->spare == 0) { + st->spare == 0 && !st->err) { struct domainlist *domlist = NULL; int d; struct state *to = st; + unsigned long long min_size; + + if (to->parent_devnm[0] && !to->parent) + /* subarray monitored without parent container + * we can't move spares here */ + continue; if (to->parent) /* member of a container */ to = to->parent; - for (d = 0; d < MaxDisks; d++) + if (get_min_spare_size_required(to, &min_size)) + continue; + if (to->metadata->ss->external) { + /* We must make sure there is + * no suitable spare in container already. + * If there is we don't add more */ + dev_t devid = container_choose_spare( + to, to, NULL, min_size, st->active); + if (devid > 0) + continue; + } + for (d = 0; d < MAX_DISKS; d++) if (to->devid[d]) domainlist_add_dev(&domlist, to->devid[d], to->metadata->ss->name); if (to->spare_group) domain_add(&domlist, to->spare_group); - + /* + * No spare migration if the destination + * has no domain. Skip this array. + */ + if (!domlist) + continue; for (from=statelist ; from ; from=from->next) { dev_t devid; - if (!check_donor(from, to, domlist)) + if (!check_donor(from, to)) continue; if (from->metadata->ss->external) devid = container_choose_spare( - from, to, domlist); + from, to, domlist, min_size, 0); else - devid = choose_spare(from, to, domlist); + devid = choose_spare(from, to, domlist, + min_size); if (devid > 0 - && move_spare(from, to, devid, info)) - break; + && move_spare(from->devname, to->devname, devid)) { + alert("MoveSpare", to->devname, from->devname, info); + break; + } } domain_free(domlist); } @@ -922,11 +977,11 @@ static void link_containers_with_subarrays(struct state *list) st->subarray = NULL; } for (st = list; st; st = st->next) - if (st->parent_dev != NoMdDev) + if (st->parent_devnm[0]) for (cont = list; cont; cont = cont->next) if (!cont->err && - cont->parent_dev == NoMdDev && - cont->devnum == st->parent_dev) { + cont->parent_devnm[0] == 0 && + strcmp(cont->devnm, st->parent_devnm) == 0) { st->parent = cont; st->subarray = cont->subarray; cont->subarray = st; @@ -938,31 +993,52 @@ static void link_containers_with_subarrays(struct state *list) int Wait(char *dev) { struct stat stb; - int devnum; + char devnm[32]; int rv = 1; + int frozen_remaining = 3; if (stat(dev, &stb) != 0) { - fprintf(stderr, Name ": Cannot find %s: %s\n", dev, + pr_err("Cannot find %s: %s\n", dev, strerror(errno)); return 2; } - devnum = stat2devnum(&stb); + strcpy(devnm, stat2devnm(&stb)); while(1) { struct mdstat_ent *ms = mdstat_read(1, 0); struct mdstat_ent *e; for (e=ms ; e; e=e->next) - if (e->devnum == devnum) + if (strcmp(e->devnm, devnm) == 0) break; - if (!e || e->percent < 0) { + if (e && e->percent == RESYNC_NONE) { + /* We could be in the brief pause before something + * starts. /proc/mdstat doesn't show that, but + * sync_action does. + */ + struct mdinfo mdi; + char buf[21]; + sysfs_init(&mdi, -1, devnm); + if (sysfs_get_str(&mdi, NULL, "sync_action", + buf, 20) > 0 && + strcmp(buf,"idle\n") != 0) { + e->percent = RESYNC_UNKNOWN; + if (strcmp(buf, "frozen\n") == 0) { + if (frozen_remaining == 0) + e->percent = RESYNC_NONE; + else + frozen_remaining -= 1; + } + } + } + if (!e || e->percent == RESYNC_NONE) { if (e && e->metadata_version && strncmp(e->metadata_version, "external:", 9) == 0) { if (is_subarray(&e->metadata_version[9])) ping_monitor(&e->metadata_version[9]); else - ping_monitor(devnum2devname(devnum)); + ping_monitor(devnm); } free_mdstat(ms); return rv; @@ -972,3 +1048,98 @@ int Wait(char *dev) mdstat_wait(5); } } + +#ifndef MDASSEMBLE + +static char *clean_states[] = { + "clear", "inactive", "readonly", "read-auto", "clean", NULL }; + +int WaitClean(char *dev, int sock, int verbose) +{ + int fd; + struct mdinfo *mdi; + int rv = 1; + char devnm[32]; + + fd = open(dev, O_RDONLY); + if (fd < 0) { + if (verbose) + pr_err("Couldn't open %s: %s\n", dev, strerror(errno)); + return 1; + } + + strcpy(devnm, fd2devnm(fd)); + mdi = sysfs_read(fd, devnm, GET_VERSION|GET_LEVEL|GET_SAFEMODE); + if (!mdi) { + if (verbose) + pr_err("Failed to read sysfs attributes for %s\n", dev); + close(fd); + return 0; + } + + switch(mdi->array.level) { + case LEVEL_LINEAR: + case LEVEL_MULTIPATH: + case 0: + /* safemode delay is irrelevant for these levels */ + rv = 0; + } + + /* for internal metadata the kernel handles the final clean + * transition, containers can never be dirty + */ + if (!is_subarray(mdi->text_version)) + rv = 0; + + /* safemode disabled ? */ + if (mdi->safe_mode_delay == 0) + rv = 0; + + if (rv) { + int state_fd = sysfs_open(fd2devnm(fd), NULL, "array_state"); + char buf[20]; + int delay = 5000; + + /* minimize the safe_mode_delay and prepare to wait up to 5s + * for writes to quiesce + */ + sysfs_set_safemode(mdi, 1); + + /* wait for array_state to be clean */ + while (1) { + rv = read(state_fd, buf, sizeof(buf)); + if (rv < 0) + break; + if (sysfs_match_word(buf, clean_states) <= 4) + break; + rv = sysfs_wait(state_fd, &delay); + if (rv < 0 && errno != EINTR) + break; + lseek(state_fd, 0, SEEK_SET); + } + if (rv < 0) + rv = 1; + else if (fping_monitor(sock) == 0 || + ping_monitor(mdi->text_version) == 0) { + /* we need to ping to close the window between array + * state transitioning to clean and the metadata being + * marked clean + */ + rv = 0; + } else + rv = 1; + if (rv && verbose) + pr_err("Error waiting for %s to be clean\n", + dev); + + /* restore the original safe_mode_delay */ + sysfs_set_safemode(mdi, mdi->safe_mode_delay); + close(state_fd); + } + + sysfs_free(mdi); + close(fd); + + return rv; +} +#endif /* MDASSEMBLE */