/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Neil Brown
- * Email: <neilb@cse.unsw.edu.au>
- * Paper: Neil Brown
- * School of Computer Science and Engineering
- * The University of New South Wales
- * Sydney, 2052
- * Australia
+ * Email: <neilb@suse.de>
*/
#include "mdadm.h"
static void alert(char *event, char *dev, char *disc, char *mailaddr, char *mailfrom,
char *cmd, int dosyslog);
-static char *percentalerts[] = {
- "RebuildStarted",
- "Rebuild20",
- "Rebuild40",
- "Rebuild60",
- "Rebuild80",
-};
-
/* 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
-int Monitor(mddev_dev_t devlist,
+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 dosyslog, int test, char* pidfile, int increments)
{
/*
* Every few seconds, scan every md device looking for changes
* An active device had a reverse transition
* RebuildStarted
* percent went from -1 to +ve
- * Rebuild20 Rebuild40 Rebuild60 Rebuild80
- * percent went from below to not-below that number
+ * RebuildNN
+ * percent went from below to not-below NN%
* DeviceDisappeared
* Couldn't access a device which was previously visible
*
int active, working, failed, spare, raid;
int expected_spares;
int devstate[MaxDisks];
- int devid[MaxDisks];
+ unsigned devid[MaxDisks];
int percent;
struct state *next;
} *statelist = NULL;
}
if (devlist == NULL) {
- mddev_ident_t mdlist = conf_get_ident(NULL);
+ struct mddev_ident *mdlist = conf_get_ident(NULL);
for (; mdlist; mdlist=mdlist->next) {
- struct state *st = malloc(sizeof *st);
+ struct state *st;
+ if (mdlist->devname == NULL)
+ continue;
+ if (strcasecmp(mdlist->devname, "<ignore>") == 0)
+ continue;
+ st = malloc(sizeof *st);
if (st == NULL)
continue;
- st->devname = strdup(mdlist->devname);
+ if (mdlist->devname[0] == '/')
+ st->devname = strdup(mdlist->devname);
+ else {
+ st->devname = malloc(8+strlen(mdlist->devname)+1);
+ strcpy(strcpy(st->devname, "/dev/md/"),
+ mdlist->devname);
+ }
st->utime = 0;
st->next = statelist;
st->err = 0;
statelist = st;
}
} else {
- mddev_dev_t dv;
+ struct mddev_dev *dv;
for (dv=devlist ; dv; dv=dv->next) {
- mddev_ident_t mdlist = conf_get_ident(dv->devname);
+ struct mddev_ident *mdlist = conf_get_ident(dv->devname);
struct state *st = malloc(sizeof *st);
if (st == NULL)
continue;
struct mdstat_ent *mse = NULL, *mse2;
char *dev = st->devname;
int fd;
- unsigned int i;
+ int i;
if (test)
alert("TestMessage", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
mse = mse2;
}
+ if (!mse) {
+ /* duplicated array in statelist
+ * or re-created after reading mdstat*/
+ st->err = 1;
+ close(fd);
+ continue;
+ }
+ /* this array is in /proc/mdstat */
+ if (array.utime == 0)
+ /* external arrays don't update utime */
+ array.utime = time(0);
+
if (st->utime == array.utime &&
st->failed == array.failed_disks &&
st->working == array.working_disks &&
continue;
}
if (st->utime == 0 && /* new array */
- mse && /* is in /proc/mdstat */
mse->pattern && strchr(mse->pattern, '_') /* degraded */
)
alert("DegradedArray", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
st->expected_spares > 0 &&
array.spare_disks < st->expected_spares)
alert("SparesMissing", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
- if (mse &&
- st->percent == -1 &&
+ if (st->percent == -1 &&
mse->percent >= 0)
alert("RebuildStarted", dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
- if (mse &&
- st->percent >= 0 &&
+ if (st->percent >= 0 &&
mse->percent >= 0 &&
- (mse->percent / 20) > (st->percent / 20))
- alert(percentalerts[mse->percent/20],
+ (mse->percent / increments) > (st->percent / increments)) {
+ char percentalert[15]; // "RebuildNN" (10 chars) or "RebuildStarted" (15 chars)
+
+ if((mse->percent / increments) == 0)
+ snprintf(percentalert, sizeof(percentalert), "RebuildStarted");
+ else
+ snprintf(percentalert, sizeof(percentalert), "Rebuild%02d", mse->percent);
+
+ alert(percentalert,
dev, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
+ }
- if (mse &&
- mse->percent == -1 &&
+ if (mse->percent == -1 &&
st->percent >= 0) {
/* Rebuild/sync/whatever just finished.
* If there is a number in /mismatch_cnt,
if (sra)
free(sra);
}
-
- if (mse)
- st->percent = mse->percent;
-
+ st->percent = mse->percent;
for (i=0; i<MaxDisks && i <= array.raid_disks + array.nr_disks;
i++) {
close(fd);
for (i=0; i<MaxDisks; i++) {
- mdu_disk_info_t disc = {0};
+ mdu_disk_info_t disc = {0,0,0,0,0};
int newstate=0;
int change;
char *dv = NULL;
disc.state = newstate;
disc.major = info[i].major;
disc.minor = info[i].minor;
- } else if (mse && mse->pattern && i < strlen(mse->pattern)) {
+ } 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;
minor(st->devid[i]), 1);
change = newstate ^ st->devstate[i];
if (st->utime && change && !st->err) {
- if (i < (unsigned)array.raid_disks &&
+ if (i < array.raid_disks &&
(((newstate&change)&(1<<MD_DISK_FAULTY)) ||
((st->devstate[i]&change)&(1<<MD_DISK_ACTIVE)) ||
((st->devstate[i]&change)&(1<<MD_DISK_SYNC)))
)
alert("Fail", dev, dv, mailaddr, mailfrom, alert_cmd, dosyslog);
- else if (i >= (unsigned)array.raid_disks &&
+ else if (i >= array.raid_disks &&
(disc.major || disc.minor) &&
st->devid[i] == makedev(disc.major, disc.minor) &&
((newstate&change)&(1<<MD_DISK_FAULTY))
)
alert("FailSpare", dev, dv, mailaddr, mailfrom, alert_cmd, dosyslog);
- else if (i < (unsigned)array.raid_disks &&
+ else if (i < array.raid_disks &&
+ ! (newstate & (1<<MD_DISK_REMOVED)) &&
(((st->devstate[i]&change)&(1<<MD_DISK_FAULTY)) ||
((newstate&change)&(1<<MD_DISK_ACTIVE)) ||
((newstate&change)&(1<<MD_DISK_SYNC)))
st->spare_group = NULL;
st->expected_spares = -1;
statelist = st;
+ if (test)
+ alert("TestMessage", st->devname, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
alert("NewArray", st->devname, NULL, mailaddr, mailfrom, alert_cmd, dosyslog);
new_found = 1;
}
}
}
if (dev > 0) {
- if (ioctl(fd2, HOT_REMOVE_DISK,
- (unsigned long)dev) == 0) {
- if (ioctl(fd1, HOT_ADD_DISK,
- (unsigned long)dev) == 0) {
+ struct mddev_dev devlist;
+ char devname[20];
+ devlist.next = NULL;
+ devlist.used = 0;
+ devlist.re_add = 0;
+ devlist.writemostly = 0;
+ devlist.devname = devname;
+ sprintf(devname, "%d:%d", major(dev), minor(dev));
+
+ devlist.disposition = 'r';
+ if (Manage_subdevs(st2->devname, fd2, &devlist, -1, 0) == 0) {
+ devlist.disposition = 'a';
+ if (Manage_subdevs(st->devname, fd1, &devlist, -1, 0) == 0) {
alert("MoveSpare", st->devname, st2->devname, mailaddr, mailfrom, alert_cmd, dosyslog);
close(fd1);
close(fd2);
break;
}
- else ioctl(fd2, HOT_ADD_DISK, (unsigned long) dev);
+ else Manage_subdevs(st2->devname, fd2, &devlist, -1, 0);
}
}
close(fd1);
n=fwrite(buf, 1, n, mp); /* yes, i don't care about the result */
fclose(mdstat);
}
- fclose(mp);
+ pclose(mp);
}
}
break;
if (!e || e->percent < 0) {
- if (e &&
+ 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]);
free_mdstat(ms);
return rv;
}
- free(ms);
+ free_mdstat(ms);
rv = 0;
mdstat_wait(5);
}
}
-
-static char *clean_states[] = {
- "clear", "inactive", "readonly", "read-auto", "clean", NULL };
-
-int WaitClean(char *dev, int verbose)
-{
- int fd;
- struct mdinfo *mdi;
- int rv = 1;
- int devnum;
-
- fd = open(dev, O_RDONLY);
- if (fd < 0) {
- if (verbose)
- fprintf(stderr, Name ": Couldn't open %s: %s\n", dev, strerror(errno));
- return 1;
- }
-
- devnum = fd2devnum(fd);
- mdi = sysfs_read(fd, devnum, GET_VERSION|GET_LEVEL|GET_SAFEMODE);
- if (!mdi) {
- if (verbose)
- fprintf(stderr, Name ": 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(fd2devnum(fd), NULL, "array_state");
- char buf[20];
- fd_set fds;
- struct timeval tm;
-
- /* minimize the safe_mode_delay and prepare to wait up to 5s
- * for writes to quiesce
- */
- sysfs_set_safemode(mdi, 1);
- tm.tv_sec = 5;
- tm.tv_usec = 0;
-
- /* give mdmon a chance to checkpoint resync */
- sysfs_set_str(mdi, NULL, "sync_action", "idle");
-
- FD_ZERO(&fds);
-
- /* 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;
- FD_SET(state_fd, &fds);
- rv = select(state_fd + 1, &fds, NULL, NULL, &tm);
- if (rv < 0 && errno != EINTR)
- break;
- lseek(state_fd, 0, SEEK_SET);
- }
- if (rv < 0)
- rv = 1;
- else if (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)
- fprintf(stderr, Name ": 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;
-}
-
-