+/*
+ * mdmon - monitor external metadata arrays
+ *
+ * Copyright (C) 2007-2008 Neil Brown <neilb@suse.de>
+ * Copyright (C) 2007-2008 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
/*
* The management thread for monitoring active md arrays.
*qp = mu;
}
+static void add_disk_to_container(struct supertype *st, struct mdinfo *sd)
+{
+ int dfd;
+ char nm[20];
+ struct metadata_update *update = NULL;
+ mdu_disk_info_t dk = {
+ .number = -1,
+ .major = sd->disk.major,
+ .minor = sd->disk.minor,
+ .raid_disk = -1,
+ .state = 0,
+ };
+
+ dprintf("%s: add %d:%d to container\n",
+ __func__, sd->disk.major, sd->disk.minor);
+
+ sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
+ dfd = dev_open(nm, O_RDWR);
+ if (dfd < 0)
+ return;
+
+ st->update_tail = &update;
+ st->ss->add_to_super(st, &dk, dfd, NULL);
+ st->ss->write_init_super(st);
+ queue_metadata_update(update);
+ st->update_tail = NULL;
+}
+
static void manage_container(struct mdstat_ent *mdstat,
struct supertype *container)
{
* about spare assignment.... probably not.
*/
if (mdstat->devcnt != container->devcnt) {
+ struct mdinfo **cdp, *cd, *di, *mdi;
+ int found;
+
/* read /sys/block/NAME/md/dev-??/block/dev to find out
* what is there, and compare with container->info.devs
* To see what is removed and what is added.
* These need to be remove from, or added to, the array
*/
- // FIXME
+ mdi = sysfs_read(-1, mdstat->devnum, GET_DEVS);
+ if (!mdi) {
+ /* invalidate the current count so we can try again */
+ container->devcnt = -1;
+ return;
+ }
+
+ /* check for removals */
+ for (cdp = &container->devs; *cdp; ) {
+ found = 0;
+ for (di = mdi->devs; di; di = di->next)
+ if (di->disk.major == (*cdp)->disk.major &&
+ di->disk.minor == (*cdp)->disk.minor) {
+ found = 1;
+ break;
+ }
+ if (!found) {
+ cd = *cdp;
+ *cdp = (*cdp)->next;
+ free(cd);
+ } else
+ cdp = &(*cdp)->next;
+ }
+
+ /* check for additions */
+ for (di = mdi->devs; di; di = di->next) {
+ for (cd = container->devs; cd; cd = cd->next)
+ if (di->disk.major == cd->disk.major &&
+ di->disk.minor == cd->disk.minor)
+ break;
+ if (!cd)
+ add_disk_to_container(container, di);
+ }
+ sysfs_free(mdi);
container->devcnt = mdstat->devcnt;
}
}
struct mdinfo *newd;
if (sysfs_add_disk(&newa->info, d) < 0)
continue;
- newd = newa->info.devs;
+ newd = malloc(sizeof(*newd));
+ *newd = *d;
+ newd->next = newa->info.devs;
+ newa->info.devs = newd;
+
newd->state_fd = sysfs_open(a->devnum,
newd->sys_name,
"state");
new->action_fd = sysfs_open(new->devnum, NULL, "sync_action");
new->info.state_fd = sysfs_open(new->devnum, NULL, "array_state");
new->resync_start_fd = sysfs_open(new->devnum, NULL, "resync_start");
+ new->metadata_fd = sysfs_open(new->devnum, NULL, "metadata_version");
get_resync_start(new);
dprintf("%s: inst: %d action: %d state: %d\n", __func__, atoi(inst),
new->action_fd, new->info.state_fd);
mdstat->metadata_version);
new->container = NULL;
free_aa(new);
- } else
+ } else {
replace_array(container, victim, new);
+ if (failed) {
+ new->check_degraded = 1;
+ manage_member(mdstat, new);
+ }
+ }
}
void manage(struct mdstat_ent *mdstat, struct supertype *container)
manage_container(mdstat, container);
continue;
}
- if (mdstat->metadata_version == NULL ||
- strncmp(mdstat->metadata_version, "external:/", 10) != 0 ||
- strncmp(mdstat->metadata_version+10, container->devname,
- strlen(container->devname)) != 0 ||
- mdstat->metadata_version[10+strlen(container->devname)]
- != '/')
+ if (!is_container_member(mdstat, container->devname))
/* Not for this array */
continue;
/* Looks like a member of this container */
struct metadata_update *mu;
- if (msg->len == 0) {
- int cnt;
-
+ if (msg->len <= 0)
while (update_queue_pending || update_queue) {
check_update_queue(container);
usleep(15*1000);
}
+ if (msg->len == 0) { /* ping_monitor */
+ int cnt;
+
cnt = monitor_loop_cnt;
if (cnt & 1)
cnt += 2; /* wait until next pselect */
while (monitor_loop_cnt - cnt < 0)
usleep(10 * 1000);
- } else {
+ } else if (msg->len == -1) { /* ping_manager */
+ struct mdstat_ent *mdstat = mdstat_read(1, 0);
+
+ manage(mdstat, container);
+ free_mdstat(mdstat);
+ } else if (!sigterm) {
mu = malloc(sizeof(*mu));
mu->len = msg->len;
mu->buf = msg->buf;
{
struct mdstat_ent *mdstat;
sigset_t set;
+ int proc_fd;
sigprocmask(SIG_UNBLOCK, NULL, &set);
sigdelset(&set, SIGUSR1);
+ sigdelset(&set, SIGHUP);
+ sigdelset(&set, SIGALRM);
+ sigdelset(&set, SIGTERM);
+ proc_fd = open("/proc/mounts", O_RDONLY);
do {
read_sock(container);
+ if (container->sock < 0 || socket_hup_requested) {
+ close(container->sock);
+ container->sock = make_control_sock(container->devname);
+ make_pidfile(container->devname, 0);
+ socket_hup_requested = 0;
+ }
+ if (container->sock < 0)
+ alarm(30);
+
free_mdstat(mdstat);
}
remove_old();
manager_ready = 1;
- if (update_queue == NULL)
- mdstat_wait_fd(container->sock, &set);
- else
+ if (sigterm)
+ wakeup_monitor();
+
+ if (update_queue == NULL) {
+ if (container->sock < 0)
+ mdstat_wait_fd(proc_fd, &set);
+ else
+ mdstat_wait_fd(container->sock, &set);
+ } else
/* If an update is happening, just wait for signal */
pselect(0, NULL, NULL, NULL, NULL, &set);
} while(1);