X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=managemon.c;h=8915522df0102ce0225b9596c974dcec1b0890ff;hb=1c7a808c4d696f6ba30c92941661a7f62eb3ff3a;hp=e7c60aa9b28fe6deea6aa7f16c9891f1a8712595;hpb=2f64e61a507ee4c1a8e2fcdbc2ce0ec89fcb7902;p=thirdparty%2Fmdadm.git diff --git a/managemon.c b/managemon.c index e7c60aa9..8915522d 100644 --- a/managemon.c +++ b/managemon.c @@ -1,3 +1,22 @@ +/* + * mdmon - monitor external metadata arrays + * + * Copyright (C) 2007-2009 Neil Brown + * Copyright (C) 2007-2009 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. @@ -85,6 +104,7 @@ #endif #include "mdadm.h" #include "mdmon.h" +#include #include #include @@ -92,8 +112,10 @@ static void close_aa(struct active_array *aa) { struct mdinfo *d; - for (d = aa->info.devs; d; d = d->next) + for (d = aa->info.devs; d; d = d->next) { + close(d->recovery_fd); close(d->state_fd); + } close(aa->action_fd); close(aa->info.state_fd); @@ -143,15 +165,11 @@ static struct active_array *duplicate_aa(struct active_array *aa) return newa; } -static void write_wakeup(struct supertype *c) +static void wakeup_monitor(void) { - static struct md_generic_cmd cmd = { .action = md_action_ping_monitor }; - int err; - - active_cmd = &cmd; - - /* send the monitor thread a pointer to the ping action */ - write(c->mgr_pipe[1], &err, 1); + /* tgkill(getpid(), mon_tid, SIGUSR1); */ + int pid = getpid(); + syscall(SYS_tgkill, pid, mon_tid, SIGUSR1); } static void remove_old(void) @@ -162,6 +180,7 @@ static void remove_old(void) if (pending_discard == discard_this) pending_discard = NULL; discard_this = NULL; + wakeup_monitor(); } } @@ -177,7 +196,6 @@ static void replace_array(struct supertype *container, */ remove_old(); while (pending_discard) { - write_wakeup(container); while (discard_this == NULL) sleep(1); remove_old(); @@ -186,28 +204,34 @@ static void replace_array(struct supertype *container, new->replaces = old; new->next = container->arrays; container->arrays = new; - write_wakeup(container); + wakeup_monitor(); } struct metadata_update *update_queue = NULL; struct metadata_update *update_queue_handled = NULL; struct metadata_update *update_queue_pending = NULL; -void check_update_queue(struct supertype *container) +static void free_updates(struct metadata_update **update) { - while (update_queue_handled) { - struct metadata_update *this = update_queue_handled; - update_queue_handled = this->next; + while (*update) { + struct metadata_update *this = *update; + + *update = this->next; free(this->buf); - if (this->space) - free(this->space); + free(this->space); free(this); } +} + +void check_update_queue(struct supertype *container) +{ + free_updates(&update_queue_handled); + if (update_queue == NULL && update_queue_pending) { update_queue = update_queue_pending; update_queue_pending = NULL; - write_wakeup(container); + wakeup_monitor(); } } @@ -221,13 +245,56 @@ static void queue_metadata_update(struct metadata_update *mu) *qp = mu; } -void wait_update_handled(void) +static void add_disk_to_container(struct supertype *st, struct mdinfo *sd) { - /* Wait for any pending update to be handled by monitor. - * i.e. wait until update_queue is NULL + int dfd; + char nm[20]; + struct supertype *st2; + struct metadata_update *update = NULL; + struct mdinfo info; + 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); + + sd->next = st->devs; + st->devs = sd; + + sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor); + dfd = dev_open(nm, O_RDWR); + if (dfd < 0) + return; + + /* Check the metadata and see if it is already part of this + * array */ - while (update_queue) - usleep(100 * 1000); + st2 = dup_super(st); + if (st2->ss->load_super(st2, dfd, NULL) == 0) { + st2->ss->getinfo_super(st, &info, NULL); + if (st->ss->compare_super(st, st2) == 0 && + info.disk.raid_disk >= 0) { + /* Looks like a good member of array. + * Just accept it. + * mdadm will incorporate any parts into + * active arrays. + */ + st2->ss->free_super(st2); + return; + } + } + st2->ss->free_super(st2); + + 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, @@ -240,16 +307,77 @@ static void manage_container(struct mdstat_ent *mdstat, * 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) { + struct mdinfo *newd = malloc(sizeof(*newd)); + + if (!newd) { + container->devcnt = -1; + continue; + } + *newd = *di; + add_disk_to_container(container, newd); + } + } + sysfs_free(mdi); container->devcnt = mdstat->devcnt; } } +static int disk_init_and_add(struct mdinfo *disk, struct mdinfo *clone, + struct active_array *aa) +{ + if (!disk || !clone) + return -1; + + *disk = *clone; + disk->recovery_fd = sysfs_open(aa->devnum, disk->sys_name, "recovery_start"); + disk->state_fd = sysfs_open(aa->devnum, disk->sys_name, "state"); + disk->prev_state = read_dev_state(disk->state_fd); + disk->curr_state = disk->prev_state; + disk->next = aa->info.devs; + aa->info.devs = disk; + + return 0; +} + static void manage_member(struct mdstat_ent *mdstat, struct active_array *a) { @@ -266,49 +394,89 @@ static void manage_member(struct mdstat_ent *mdstat, * trying to find and assign a spare. * We do that whenever the monitor tells us too. */ + char buf[64]; + int frozen; + // FIXME a->info.array.raid_disks = mdstat->raid_disks; a->info.array.chunk_size = mdstat->chunk_size; // MORE - if (a->check_degraded) { + /* honor 'frozen' */ + if (sysfs_get_str(&a->info, NULL, "metadata_version", buf, sizeof(buf)) > 0) + frozen = buf[9] == '-'; + else + frozen = 1; /* can't read metadata_version assume the worst */ + + if (a->check_degraded && !frozen) { struct metadata_update *updates = NULL; - struct mdinfo *newdev; + struct mdinfo *newdev = NULL; struct active_array *newa; - wait_update_handled(); + struct mdinfo *d; + a->check_degraded = 0; /* The array may not be degraded, this is just a good time * to check. */ newdev = a->container->ss->activate_spare(a, &updates); - if (newdev) { - struct mdinfo *d; - /* Cool, we can add a device or several. */ - newa = duplicate_aa(a); - /* suspend recovery - maybe not needed */ - - /* Add device to array and set offset/size/slot. - * and open files for each newdev */ - for (d = newdev; d ; d = d->next) { - struct mdinfo *newd; - if (sysfs_add_disk(&newa->info, d)) - continue; - newd = newa->info.devs; - newd->state_fd = sysfs_open(a->devnum, - newd->sys_name, - "state"); - newd->prev_state - = read_dev_state(newd->state_fd); - newd->curr_state = newd->prev_state; + if (!newdev) + return; + + newa = duplicate_aa(a); + if (!newa) + goto out; + /* Cool, we can add a device or several. */ + + /* Add device to array and set offset/size/slot. + * and open files for each newdev */ + for (d = newdev; d ; d = d->next) { + struct mdinfo *newd; + + newd = malloc(sizeof(*newd)); + if (!newd) + continue; + if (sysfs_add_disk(&newa->info, d, 0) < 0) { + free(newd); + continue; } - queue_metadata_update(updates); - replace_array(a->container, a, newa); - sysfs_set_str(&a->info, NULL, "sync_action", "repair"); + disk_init_and_add(newd, d, newa); + } + queue_metadata_update(updates); + updates = NULL; + replace_array(a->container, a, newa); + sysfs_set_str(&a->info, NULL, "sync_action", "recover"); + out: + while (newdev) { + d = newdev->next; + free(newdev); + newdev = d; } + free_updates(&updates); } } +static int aa_ready(struct active_array *aa) +{ + struct mdinfo *d; + int level = aa->info.array.level; + + for (d = aa->info.devs; d; d = d->next) + if (d->state_fd < 0) + return 0; + + if (aa->info.state_fd < 0) + return 0; + + if (level > 0 && (aa->action_fd < 0 || aa->resync_start_fd < 0)) + return 0; + + if (!aa->container) + return 0; + + return 1; +} + static void manage_new(struct mdstat_ent *mdstat, struct supertype *container, struct active_array *victim) @@ -323,9 +491,25 @@ static void manage_new(struct mdstat_ent *mdstat, struct mdinfo *mdi, *di; char *inst; int i; + int failed = 0; + + /* check if array is ready to be monitored */ + if (!mdstat->active) + return; + + mdi = sysfs_read(-1, mdstat->devnum, + GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT| + GET_DEGRADED|GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE); new = malloc(sizeof(*new)); + if (!new || !mdi) { + if (mdi) + sysfs_free(mdi); + if (new) + free(new); + return; + } memset(new, 0, sizeof(*new)); new->devnum = mdstat->devnum; @@ -336,21 +520,10 @@ static void manage_new(struct mdstat_ent *mdstat, new->container = container; - inst = &mdstat->metadata_version[10+strlen(container->devname)+1]; - - mdi = sysfs_read(-1, new->devnum, - GET_LEVEL|GET_CHUNK|GET_DISKS| - GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE); - if (!mdi) { - /* Eeek. Cannot monitor this array. - * Mark it to be ignored by setting container to NULL - */ - new->container = NULL; - replace_array(container, victim, new); - return; - } + inst = to_subarray(mdstat, container->devname); new->info.array = mdi->array; + new->info.component_size = mdi->component_size; for (i = 0; i < new->info.array.raid_disks; i++) { struct mdinfo *newd = malloc(sizeof(*newd)); @@ -359,42 +532,44 @@ static void manage_new(struct mdstat_ent *mdstat, if (i == di->disk.raid_disk) break; - if (di) { - memcpy(newd, di, sizeof(*newd)); - - newd->state_fd = sysfs_open(new->devnum, - newd->sys_name, - "state"); + if (disk_init_and_add(newd, di, new) != 0) { + if (newd) + free(newd); - newd->prev_state = read_dev_state(newd->state_fd); - newd->curr_state = newd->prev_state; - } else { - newd->state_fd = -1; - newd->disk.raid_disk = i; - newd->prev_state = DS_REMOVE; - newd->curr_state = DS_REMOVE; + failed++; + if (failed > new->info.array.failed_disks) { + /* we cannot properly monitor without all working disks */ + new->container = NULL; + break; + } } - sprintf(newd->sys_name, "rd%d", i); - newd->next = new->info.devs; - new->info.devs = newd; } + 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->resync_start = 0; + new->metadata_fd = sysfs_open(new->devnum, NULL, "metadata_version"); + new->sync_completed_fd = sysfs_open(new->devnum, NULL, "sync_completed"); dprintf("%s: inst: %d action: %d state: %d\n", __func__, atoi(inst), new->action_fd, new->info.state_fd); sysfs_free(mdi); - // finds and compares. - if (container->ss->open_new(container, new, inst) < 0) { - // FIXME close all those files + + /* if everything checks out tell the metadata handler we want to + * manage this instance + */ + if (!aa_ready(new) || container->ss->open_new(container, new, inst) < 0) { + fprintf(stderr, "mdmon: failed to monitor %s\n", + mdstat->metadata_version); new->container = NULL; + free_aa(new); + } else { replace_array(container, victim, new); - return; + if (failed) { + new->check_degraded = 1; + manage_member(mdstat, new); + } } - replace_array(container, victim, new); - return; } void manage(struct mdstat_ent *mdstat, struct supertype *container) @@ -410,12 +585,7 @@ 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 */ @@ -431,24 +601,52 @@ void manage(struct mdstat_ent *mdstat, struct supertype *container) } } -static int handle_message(struct supertype *container, struct md_message *msg) +static void handle_message(struct supertype *container, struct metadata_update *msg) { - struct md_generic_cmd *cmd = msg->buf; + /* queue this metadata update through to the monitor */ - if (!cmd) - return 0; + struct metadata_update *mu; + + if (msg->len <= 0) + while (update_queue_pending || update_queue) { + check_update_queue(container); + usleep(15*1000); + } - switch (cmd->action) { + if (msg->len == 0) { /* ping_monitor */ + int cnt; + + cnt = monitor_loop_cnt; + if (cnt & 1) + cnt += 2; /* wait until next pselect */ + else + cnt += 3; /* wait for 2 pselects */ + wakeup_monitor(); + + while (monitor_loop_cnt - cnt < 0) + usleep(10 * 1000); + } else if (msg->len == -1) { /* ping_manager */ + struct mdstat_ent *mdstat = mdstat_read(1, 0); - default: - return -1; + manage(mdstat, container); + free_mdstat(mdstat); + } else if (!sigterm) { + mu = malloc(sizeof(*mu)); + mu->len = msg->len; + mu->buf = msg->buf; + msg->buf = NULL; + mu->space = NULL; + mu->next = NULL; + if (container->ss->prepare_update) + container->ss->prepare_update(container, mu); + queue_metadata_update(mu); } } void read_sock(struct supertype *container) { int fd; - struct md_message msg; + struct metadata_update msg; int terminate = 0; long fl; int tmo = 3; /* 3 second timeout before hanging up the socket */ @@ -462,69 +660,69 @@ void read_sock(struct supertype *container) fcntl(fd, F_SETFL, fl); do { - int err; - msg.buf = NULL; /* read and validate the message */ if (receive_message(fd, &msg, tmo) == 0) { - err = handle_message(container, &msg); - if (!err) - ack(fd, msg.seq, tmo); - else - nack(fd, err, tmo); - } else { + handle_message(container, &msg); + if (msg.len == 0) { + /* ping reply with version */ + msg.buf = Version; + msg.len = strlen(Version) + 1; + if (send_message(fd, &msg, tmo) < 0) + terminate = 1; + } else if (ack(fd, tmo) < 0) + terminate = 1; + } else terminate = 1; - nack(fd, -1, tmo); - } - if (msg.buf) - free(msg.buf); } while (!terminate); close(fd); } -static int woke = 0; -void wake_me(int sig) -{ - woke = 1; -} - int exit_now = 0; int manager_ready = 0; void do_manager(struct supertype *container) { struct mdstat_ent *mdstat; - sigset_t block, orig; + sigset_t set; - sigemptyset(&block); - sigaddset(&block, SIGUSR1); - - signal(SIGUSR1, wake_me); + sigprocmask(SIG_UNBLOCK, NULL, &set); + sigdelset(&set, SIGUSR1); + sigdelset(&set, SIGTERM); do { - woke = 0; if (exit_now) exit(0); - mdstat = mdstat_read(1, 0); - - manage(mdstat, container); + /* Can only 'manage' things if 'monitor' is not making + * structural changes to metadata, so need to check + * update_queue + */ + if (update_queue == NULL) { + mdstat = mdstat_read(1, 0); - read_sock(container); + manage(mdstat, container); - free_mdstat(mdstat); + read_sock(container); + free_mdstat(mdstat); + } remove_old(); check_update_queue(container); manager_ready = 1; - sigprocmask(SIG_SETMASK, &block, &orig); - if (woke == 0) - mdstat_wait_fd(container->sock, &orig); - sigprocmask(SIG_SETMASK, &orig, NULL); + + if (sigterm) + wakeup_monitor(); + + if (update_queue == NULL) + 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); }