77402e5105
"sync_complete" just tracks the current resync/recover/check/whatever pass. "resync_start" tracks which parts of the array are known to be in-sync (modulo active writes). So it is what we need to use to update the metadata. Also we cannot call it when the array has stopped, as the value is no longer available then. We must call it when the resync completes. Possibly also call it preiodically if the array is quiescent.
418 lines
10 KiB
C
418 lines
10 KiB
C
|
|
/*
|
|
* The management thread for monitoring active md arrays.
|
|
* This thread does things which might block such as memory
|
|
* allocation.
|
|
* In particular:
|
|
*
|
|
* - Find out about new arrays in this container.
|
|
* Allocate the data structures and open the files.
|
|
*
|
|
* For this we watch /proc/mdstat and find new arrays with
|
|
* metadata type that confirms sharing. e.g. "md4"
|
|
* When we find a new array we slip it into the list of
|
|
* arrays and signal 'monitor' by writing to a pipe.
|
|
*
|
|
* - Respond to reshape requests by allocating new data structures
|
|
* and opening new files.
|
|
*
|
|
* These come as a change to raid_disks. We allocate a new
|
|
* version of the data structures and slip it into the list.
|
|
* 'monitor' will notice and release the old version.
|
|
* Changes to level, chunksize, layout.. do not need re-allocation.
|
|
* Reductions in raid_disks don't really either, but we handle
|
|
* them the same way for consistency.
|
|
*
|
|
* - 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.
|
|
*
|
|
* - Pass on metadata updates from external programs such as
|
|
* mdadm creating a new array.
|
|
*
|
|
* This is most-messy.
|
|
* It might involve adding a new array or changing the status of
|
|
* a spare, or any reconfig that the kernel doesn't get involved in.
|
|
*
|
|
* The required updates are received via a named pipe. There will
|
|
* be one named pipe for each container. Each message contains a
|
|
* sync marker: 0x5a5aa5a5, A byte count, and the message. This is
|
|
* passed to the metadata handler which will interpret and process it.
|
|
* For 'DDF' messages are internal data blocks with the leading
|
|
* 'magic number' signifying what sort of data it is.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* We select on /proc/mdstat and the named pipe.
|
|
* We create new arrays or updated version of arrays and slip
|
|
* them into the head of the list, then signal 'monitor' via a pipe write.
|
|
* 'monitor' will notice and place the old array on a return list.
|
|
* Metadata updates are placed on a queue just like they arrive
|
|
* from the named pipe.
|
|
*
|
|
* When new arrays are found based on correct metadata string, we
|
|
* need to identify them with an entry in the metadata. Maybe we require
|
|
* the metadata to be mdX/NN when NN is the index into an appropriate table.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* List of tasks:
|
|
* - Watch for spares to be added to the container, and write updated
|
|
* metadata to them.
|
|
* - Watch for new arrays using this container, confirm they match metadata
|
|
* and if so, start monitoring them
|
|
* - Watch for spares being added to monitored arrays. This shouldn't
|
|
* happen, as we should do all the adding. Just remove them.
|
|
* - Watch for change in raid-disks, chunk-size, etc. Update metadata and
|
|
* start a reshape.
|
|
*/
|
|
#ifndef _GNU_SOURCE
|
|
#define _GNU_SOURCE
|
|
#endif
|
|
#include "mdadm.h"
|
|
#include "mdmon.h"
|
|
#include <sys/socket.h>
|
|
#include <signal.h>
|
|
|
|
static void close_aa(struct active_array *aa)
|
|
{
|
|
struct mdinfo *d;
|
|
|
|
for (d = aa->info.devs; d; d = d->next)
|
|
close(d->state_fd);
|
|
|
|
close(aa->action_fd);
|
|
close(aa->info.state_fd);
|
|
close(aa->resync_start_fd);
|
|
}
|
|
|
|
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
|
|
*/
|
|
if (!aa->container)
|
|
close_aa(aa);
|
|
while (aa->info.devs) {
|
|
struct mdinfo *d = aa->info.devs;
|
|
aa->info.devs = d->next;
|
|
free(d);
|
|
}
|
|
free(aa);
|
|
}
|
|
|
|
static void write_wakeup(struct supertype *c)
|
|
{
|
|
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);
|
|
read(c->mon_pipe[0], &err, 1);
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
static void replace_array(struct supertype *container,
|
|
struct active_array *old,
|
|
struct active_array *new)
|
|
{
|
|
/* To replace an array, we add it to the top of the list
|
|
* marked with ->replaces to point to the original.
|
|
* 'monitor' will take the original out of the list
|
|
* and put it on 'discard_this'. We take it from there
|
|
* and discard it.
|
|
*/
|
|
remove_old();
|
|
while (pending_discard) {
|
|
write_wakeup(container);
|
|
while (discard_this == NULL)
|
|
sleep(1);
|
|
remove_old();
|
|
}
|
|
pending_discard = old;
|
|
new->replaces = old;
|
|
new->next = container->arrays;
|
|
container->arrays = new;
|
|
write_wakeup(container);
|
|
}
|
|
|
|
static void manage_container(struct mdstat_ent *mdstat,
|
|
struct supertype *container)
|
|
{
|
|
/* The only thing of interest here is if a new device
|
|
* has been added to the container. We add it to the
|
|
* 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
|
|
* 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
|
|
container->devcnt = mdstat->devcnt;
|
|
}
|
|
}
|
|
|
|
static void manage_member(struct mdstat_ent *mdstat,
|
|
struct active_array *a)
|
|
{
|
|
/* Compare mdstat info with known state of member array.
|
|
* We do not need to look for device state changes here, that
|
|
* is dealt with by the monitor.
|
|
*
|
|
* We just look for changes which suggest that a reshape is
|
|
* being requested.
|
|
* Unfortunately decreases in raid_disks don't show up in
|
|
* mdstat until the reshape completes FIXME.
|
|
*/
|
|
// FIXME
|
|
a->info.array.raid_disks = mdstat->raid_disks;
|
|
a->info.array.chunk_size = mdstat->chunk_size;
|
|
// MORE
|
|
|
|
}
|
|
|
|
static void manage_new(struct mdstat_ent *mdstat,
|
|
struct supertype *container,
|
|
struct active_array *victim)
|
|
{
|
|
/* A new array has appeared in this container.
|
|
* Hopefully it is already recorded in the metadata.
|
|
* Check, then create the new array to report it to
|
|
* the monitor.
|
|
*/
|
|
|
|
struct active_array *new;
|
|
struct mdinfo *mdi, *di;
|
|
char *n;
|
|
int inst;
|
|
int i;
|
|
|
|
new = malloc(sizeof(*new));
|
|
|
|
memset(new, 0, sizeof(*new));
|
|
|
|
new->devnum = mdstat->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
|
|
|
|
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;
|
|
}
|
|
|
|
new->info.array = mdi->array;
|
|
|
|
for (i = 0; i < new->info.array.raid_disks; i++) {
|
|
struct mdinfo *newd = malloc(sizeof(*newd));
|
|
|
|
for (di = mdi->devs; di; di = di->next)
|
|
if (i == di->disk.raid_disk)
|
|
break;
|
|
|
|
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;
|
|
} else {
|
|
newd->state_fd = -1;
|
|
}
|
|
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;
|
|
|
|
sysfs_free(mdi);
|
|
// finds and compares.
|
|
if (container->ss->open_new(container, new, inst) < 0) {
|
|
// FIXME close all those files
|
|
new->container = NULL;
|
|
replace_array(container, victim, new);
|
|
return;
|
|
}
|
|
replace_array(container, victim, new);
|
|
return;
|
|
}
|
|
|
|
void manage(struct mdstat_ent *mdstat, struct supertype *container)
|
|
{
|
|
/* We have just read mdstat and need to compare it with
|
|
* the known active arrays.
|
|
* Arrays with the wrong metadata are ignored.
|
|
*/
|
|
|
|
for ( ; mdstat ; mdstat = mdstat->next) {
|
|
struct active_array *a;
|
|
if (mdstat->devnum == container->devnum) {
|
|
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)]
|
|
!= '/')
|
|
/* Not for this array */
|
|
continue;
|
|
/* Looks like a member of this container */
|
|
for (a = container->arrays; a; a = a->next) {
|
|
if (mdstat->devnum == a->devnum) {
|
|
if (a->container)
|
|
manage_member(mdstat, a);
|
|
break;
|
|
}
|
|
}
|
|
if (a == NULL || !a->container)
|
|
manage_new(mdstat, container, a);
|
|
}
|
|
}
|
|
|
|
static int handle_message(struct supertype *container, struct md_message *msg)
|
|
{
|
|
int err;
|
|
struct md_generic_cmd *cmd = msg->buf;
|
|
|
|
if (!cmd)
|
|
return 0;
|
|
|
|
switch (cmd->action) {
|
|
case md_action_remove_device:
|
|
|
|
/* forward to the monitor */
|
|
active_cmd = cmd;
|
|
write(container->mgr_pipe[1], &err, 1);
|
|
read(container->mon_pipe[0], &err, 1);
|
|
return err;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void read_sock(struct supertype *container)
|
|
{
|
|
int fd;
|
|
struct md_message msg;
|
|
int terminate = 0;
|
|
long fl;
|
|
int tmo = 3; /* 3 second timeout before hanging up the socket */
|
|
|
|
fd = accept(container->sock, NULL, NULL);
|
|
if (fd < 0)
|
|
return;
|
|
|
|
fl = fcntl(fd, F_GETFL, 0);
|
|
fl |= O_NONBLOCK;
|
|
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 {
|
|
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;
|
|
|
|
sigemptyset(&block);
|
|
sigaddset(&block, SIGUSR1);
|
|
|
|
signal(SIGUSR1, wake_me);
|
|
|
|
do {
|
|
woke = 0;
|
|
|
|
if (exit_now)
|
|
exit(0);
|
|
|
|
mdstat = mdstat_read(1, 0);
|
|
|
|
manage(mdstat, container);
|
|
|
|
read_sock(container);
|
|
|
|
free_mdstat(mdstat);
|
|
|
|
remove_old();
|
|
|
|
manager_ready = 1;
|
|
sigprocmask(SIG_SETMASK, &block, &orig);
|
|
if (woke == 0)
|
|
mdstat_wait_fd(container->sock, &orig);
|
|
sigprocmask(SIG_SETMASK, &orig, NULL);
|
|
} while(1);
|
|
}
|