X-Git-Url: http://git.ipfire.org/?p=thirdparty%2Fmdadm.git;a=blobdiff_plain;f=managemon.c;h=c947552eb7161d69a7aa7f358962ed46d3c84097;hp=43c731fa819fe7054759d79ee0d72f93e0b9f893;hb=1eb252b8488bbdd62ad602561fe8a90ef9079271;hpb=2a0bb19e0089aef4fcc65513c40a54cb00e53a7b diff --git a/managemon.c b/managemon.c index 43c731fa..c947552e 100644 --- a/managemon.c +++ b/managemon.c @@ -26,7 +26,18 @@ * - When a device is added to the container, we add it to the metadata * as a spare. * - * - assist with activating spares by opening relevant sysfs file. + * - Deal with degraded array + * We only do this when first noticing the array is degraded. + * This can be when we first see the array, when sync completes or + * when recovery completes. + * + * Check if number of failed devices suggests recovery is needed, and + * skip if not. + * Ask metadata to allocate a spare device + * Add device as not in_sync and give a role + * Update metadata. + * Open sysfs files and pass to monitor. + * Make sure that monitor Starts recovery.... * * - Pass on metadata updates from external programs such as * mdadm creating a new array. @@ -74,8 +85,9 @@ #endif #include "mdadm.h" #include "mdmon.h" +#include #include - +#include static void close_aa(struct active_array *aa) { @@ -87,7 +99,6 @@ static void close_aa(struct active_array *aa) close(aa->action_fd); close(aa->info.state_fd); close(aa->resync_start_fd); - close(aa->sync_pos_fd); } static void free_aa(struct active_array *aa) @@ -95,6 +106,7 @@ static void free_aa(struct active_array *aa) /* Note that this doesn't close fds if they are being used * by a clone. ->container will be set for a clone */ + dprintf("%s: devnum: %d\n", __func__, aa->devnum); if (!aa->container) close_aa(aa); while (aa->info.devs) { @@ -105,9 +117,50 @@ static void free_aa(struct active_array *aa) free(aa); } -static void write_wakeup(struct supertype *c) +static struct active_array *duplicate_aa(struct active_array *aa) +{ + struct active_array *newa = malloc(sizeof(*newa)); + struct mdinfo **dp1, **dp2; + + *newa = *aa; + newa->next = NULL; + newa->replaces = NULL; + newa->info.next = NULL; + + dp2 = &newa->info.devs; + + for (dp1 = &aa->info.devs; *dp1; dp1 = &(*dp1)->next) { + struct mdinfo *d; + if ((*dp1)->state_fd < 0) + continue; + + d = malloc(sizeof(*d)); + *d = **dp1; + *dp2 = d; + dp2 = & d->next; + } + *dp2 = NULL; + + return newa; +} + +static void wakeup_monitor(void) { - write(c->pipe[1], "PING", 4); + /* tgkill(getpid(), mon_tid, SIGUSR1); */ + int pid = getpid(); + syscall(SYS_tgkill, pid, mon_tid, SIGUSR1); +} + +static void remove_old(void) +{ + if (discard_this) { + discard_this->next = NULL; + free_aa(discard_this); + if (pending_discard == discard_this) + pending_discard = NULL; + discard_this = NULL; + wakeup_monitor(); + } } static void replace_array(struct supertype *container, @@ -120,24 +173,59 @@ static void replace_array(struct supertype *container, * and put it on 'discard_this'. We take it from there * and discard it. */ - + remove_old(); while (pending_discard) { while (discard_this == NULL) sleep(1); - if (discard_this != pending_discard) - abort(); - discard_this->next = NULL; - free_aa(discard_this); - discard_this = NULL; - pending_discard = NULL; + remove_old(); } pending_discard = old; 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) +{ + while (update_queue_handled) { + struct metadata_update *this = update_queue_handled; + update_queue_handled = this->next; + free(this->buf); + if (this->space) + free(this->space); + free(this); + } + if (update_queue == NULL && + update_queue_pending) { + update_queue = update_queue_pending; + update_queue_pending = NULL; + wakeup_monitor(); + } } +static void queue_metadata_update(struct metadata_update *mu) +{ + struct metadata_update **qp; + + qp = &update_queue_pending; + while (*qp) + qp = & ((*qp)->next); + *qp = mu; +} + +void wait_update_handled(void) +{ + /* Wait for any pending update to be handled by monitor. + * i.e. wait until update_queue is NULL + */ + while (update_queue) + usleep(100 * 1000); +} static void manage_container(struct mdstat_ent *mdstat, struct supertype *container) @@ -147,7 +235,6 @@ static void manage_container(struct mdstat_ent *mdstat, * array ignoring any metadata on it. * FIXME should we look for compatible metadata and take hints * about spare assignment.... probably not. - * */ if (mdstat->devcnt != container->devcnt) { /* read /sys/block/NAME/md/dev-??/block/dev to find out @@ -171,12 +258,52 @@ static void manage_member(struct mdstat_ent *mdstat, * being requested. * Unfortunately decreases in raid_disks don't show up in * mdstat until the reshape completes FIXME. + * + * Actually, we also want to handle degraded arrays here by + * trying to find and assign a spare. + * We do that whenever the monitor tells us too. */ // FIXME a->info.array.raid_disks = mdstat->raid_disks; a->info.array.chunk_size = mdstat->chunk_size; // MORE + if (a->check_degraded) { + struct metadata_update *updates = NULL; + struct mdinfo *newdev; + struct active_array *newa; + wait_update_handled(); + 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) < 0) + 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; + } + queue_metadata_update(updates); + replace_array(a->container, a, newa); + sysfs_set_str(&a->info, NULL, "sync_action", "repair"); + } + } } static void manage_new(struct mdstat_ent *mdstat, @@ -191,26 +318,25 @@ static void manage_new(struct mdstat_ent *mdstat, struct active_array *new; struct mdinfo *mdi, *di; - char *n; - int inst; + char *inst; int i; new = malloc(sizeof(*new)); + memset(new, 0, sizeof(*new)); + new->devnum = mdstat->devnum; + strcpy(new->info.sys_name, devnum2devname(new->devnum)); new->prev_state = new->curr_state = new->next_state = inactive; new->prev_action= new->curr_action= new->next_action= idle; new->container = container; - n = &mdstat->metadata_version[10+strlen(container->devname)+1]; - inst = atoi(n); - if (inst < 0) - abort();//FIXME + inst = &mdstat->metadata_version[10+strlen(container->devname)+1]; mdi = sysfs_read(-1, new->devnum, - GET_LEVEL|GET_CHUNK|GET_DISKS| + GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT| GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE); if (!mdi) { /* Eeek. Cannot monitor this array. @@ -222,6 +348,7 @@ static void manage_new(struct mdstat_ent *mdstat, } 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)); @@ -233,26 +360,30 @@ static void manage_new(struct mdstat_ent *mdstat, if (di) { memcpy(newd, di, sizeof(*newd)); - sprintf(newd->sys_name, "rd%d", i); - newd->state_fd = sysfs_open(new->devnum, newd->sys_name, "state"); newd->prev_state = read_dev_state(newd->state_fd); - newd->curr_state = newd->curr_state; + 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; } + 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->sync_pos_fd = sysfs_open(new->devnum, NULL, "sync_completed"); - new->sync_pos = 0; + get_resync_start(new); + 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 @@ -264,8 +395,7 @@ static void manage_new(struct mdstat_ent *mdstat, return; } -void manage(struct mdstat_ent *mdstat, struct active_array *aa, - struct supertype *container) +void manage(struct mdstat_ent *mdstat, struct supertype *container) { /* We have just read mdstat and need to compare it with * the known active arrays. @@ -287,7 +417,7 @@ void manage(struct mdstat_ent *mdstat, struct active_array *aa, /* Not for this array */ continue; /* Looks like a member of this container */ - for (a = aa; a; a = a->next) { + for (a = container->arrays; a; a = a->next) { if (mdstat->devnum == a->devnum) { if (a->container) manage_member(mdstat, a); @@ -299,28 +429,96 @@ void manage(struct mdstat_ent *mdstat, struct active_array *aa, } } -void read_sock(int pfd) +static void handle_message(struct supertype *container, struct metadata_update *msg) +{ + /* queue this metadata update through to the monitor */ + + struct metadata_update *mu; + + if (msg->len == 0) { + int cnt = monitor_loop_cnt; + if (cnt & 1) + cnt += 2; /* wait until next pselect */ + else + cnt += 3; /* wait for 2 pselects */ + wakeup_monitor(); + wait_update_handled(); + while (monitor_loop_cnt - cnt < 0) + usleep(10 * 1000); + } else { + 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 metadata_update msg; + int terminate = 0; + long fl; + int tmo = 3; /* 3 second timeout before hanging up the socket */ - // FIXME set non-blocking - fd = accept(pfd, NULL, NULL); + fd = accept(container->sock, NULL, NULL); if (fd < 0) return; - // FIXME do something useful + + fl = fcntl(fd, F_GETFL, 0); + fl |= O_NONBLOCK; + fcntl(fd, F_SETFL, fl); + + do { + msg.buf = NULL; + + /* read and validate the message */ + if (receive_message(fd, &msg, tmo) == 0) { + handle_message(container, &msg); + if (ack(fd, tmo) < 0) + terminate = 1; + } else + terminate = 1; + + } while (!terminate); + close(fd); } + +int exit_now = 0; +int manager_ready = 0; void do_manager(struct supertype *container) { struct mdstat_ent *mdstat; + sigset_t set; + + sigprocmask(SIG_UNBLOCK, NULL, &set); + sigdelset(&set, SIGUSR1); do { + + if (exit_now) + exit(0); + mdstat = mdstat_read(1, 0); - manage(mdstat, array_list, container); + manage(mdstat, container); + + read_sock(container); + + free_mdstat(mdstat); + + remove_old(); + + check_update_queue(container); - read_sock(container->sock); + manager_ready = 1; - mdstat_wait_fd(container->sock); + mdstat_wait_fd(container->sock, &set); } while(1); }