*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
- */
- while (update_queue)
- usleep(100 * 1000);
+ 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,
* 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)
+ 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 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
}
queue_metadata_update(updates);
replace_array(a->container, a, newa);
- sysfs_set_str(&a->info, NULL, "sync_action", "repair");
+ sysfs_set_str(&a->info, NULL, "sync_action", "recover");
}
}
}
struct mdinfo *mdi, *di;
char *inst;
int i;
+ int failed = 0;
/* check if array is ready to be monitored */
if (!mdstat->active)
mdi = sysfs_read(-1, mdstat->devnum,
GET_LEVEL|GET_CHUNK|GET_DISKS|GET_COMPONENT|
- GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
+ GET_DEGRADED|GET_DEVS|GET_OFFSET|GET_SIZE|GET_STATE);
new = malloc(sizeof(*new));
newd->prev_state = read_dev_state(newd->state_fd);
newd->curr_state = newd->prev_state;
- } else {
- /* we cannot properly monitor without all raid_disks */
+ } else if (failed + 1 > new->info.array.failed_disks) {
+ /* we cannot properly monitor without all working disks */
new->container = NULL;
break;
+ } else {
+ failed++;
+ free(newd);
+ continue;
}
sprintf(newd->sys_name, "rd%d", i);
newd->next = new->info.devs;
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);
continue;
}
if (mdstat->metadata_version == NULL ||
- strncmp(mdstat->metadata_version, "external:/", 10) != 0 ||
+ strncmp(mdstat->metadata_version, "external:", 9) != 0 ||
+ !is_subarray(mdstat->metadata_version+9) ||
strncmp(mdstat->metadata_version+10, container->devname,
strlen(container->devname)) != 0 ||
mdstat->metadata_version[10+strlen(container->devname)]
struct metadata_update *mu;
if (msg->len == 0) {
- int cnt = monitor_loop_cnt;
+ int cnt;
+
+ while (update_queue_pending || update_queue) {
+ check_update_queue(container);
+ usleep(15*1000);
+ }
+
+ 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 {
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;
- mdstat_wait_fd(container->sock, &set);
+ 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);
}
projects / thirdparty / mdadm.git / blobdiff