[thirdparty/mdadm.git] / managemon.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.
 *
 * - 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.
 *
 *   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/syscall.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
	 */
	dprintf("%s: devnum: %d\n", __func__, aa->devnum);
	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 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)
{
	/* 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,
			  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) {
		while (discard_this == NULL)
			sleep(1);
		remove_old();
	}
	pending_discard = old;
	new->replaces = old;
	new->next = container->arrays;
	container->arrays = new;
	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;
}

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)
{
	/* 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) {
		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
		 */
		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;
	}
}

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.
	 *
	 * 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;

		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 = 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");
				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", "recover");
		}
	}
}

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)
{
	/* 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 *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;
	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;

	inst = &mdstat->metadata_version[10+strlen(container->devname)+1];

	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));

		for (di = mdi->devs; di; di = di->next)
			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");

			newd->prev_state = read_dev_state(newd->state_fd);
			newd->curr_state = newd->prev_state;
		} 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->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->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);

	sysfs_free(mdi);

	/* 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);
		if (failed) {
			new->check_degraded = 1;
			manage_member(mdstat, new);
		}
	}
}

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 (!is_container_member(mdstat, 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 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)
		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 */
		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);

		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 metadata_update 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 {
		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;
	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 {

		if (exit_now)
			exit(0);

		/* 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);

			manage(mdstat, container);

			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();

		check_update_queue(container);

		manager_ready = 1;

		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);
}
Commit	Line	Data
549e9569 NB	1
	2	/*
	3	* The management thread for monitoring active md arrays.
	4	* This thread does things which might block such as memory
	5	* allocation.
	6	* In particular:
	7	*
	8	* - Find out about new arrays in this container.
	9	* Allocate the data structures and open the files.
	10	*
	11	* For this we watch /proc/mdstat and find new arrays with
	12	* metadata type that confirms sharing. e.g. "md4"
	13	* When we find a new array we slip it into the list of
	14	* arrays and signal 'monitor' by writing to a pipe.
	15	*
	16	* - Respond to reshape requests by allocating new data structures
	17	* and opening new files.
	18	*
	19	* These come as a change to raid_disks. We allocate a new
	20	* version of the data structures and slip it into the list.
	21	* 'monitor' will notice and release the old version.
	22	* Changes to level, chunksize, layout.. do not need re-allocation.
	23	* Reductions in raid_disks don't really either, but we handle
	24	* them the same way for consistency.
	25	*
	26	* - When a device is added to the container, we add it to the metadata
	27	* as a spare.
	28	*
6c3fb95c NB	29	* - Deal with degraded array
	30	* We only do this when first noticing the array is degraded.
	31	* This can be when we first see the array, when sync completes or
	32	* when recovery completes.
	33	*
	34	* Check if number of failed devices suggests recovery is needed, and
	35	* skip if not.
	36	* Ask metadata to allocate a spare device
	37	* Add device as not in_sync and give a role
	38	* Update metadata.
	39	* Open sysfs files and pass to monitor.
	40	* Make sure that monitor Starts recovery....
549e9569 NB	41	*
	42	* - Pass on metadata updates from external programs such as
	43	* mdadm creating a new array.
	44	*
	45	* This is most-messy.
	46	* It might involve adding a new array or changing the status of
	47	* a spare, or any reconfig that the kernel doesn't get involved in.
	48	*
	49	* The required updates are received via a named pipe. There will
	50	* be one named pipe for each container. Each message contains a
	51	* sync marker: 0x5a5aa5a5, A byte count, and the message. This is
	52	* passed to the metadata handler which will interpret and process it.
	53	* For 'DDF' messages are internal data blocks with the leading
	54	* 'magic number' signifying what sort of data it is.
	55	*
	56	*/
	57
	58	/*
	59	* We select on /proc/mdstat and the named pipe.
	60	* We create new arrays or updated version of arrays and slip
	61	* them into the head of the list, then signal 'monitor' via a pipe write.
	62	* 'monitor' will notice and place the old array on a return list.
	63	* Metadata updates are placed on a queue just like they arrive
	64	* from the named pipe.
	65	*
	66	* When new arrays are found based on correct metadata string, we
	67	* need to identify them with an entry in the metadata. Maybe we require
	68	* the metadata to be mdX/NN when NN is the index into an appropriate table.
	69	*
	70	*/
	71
	72	/*
	73	* List of tasks:
	74	* - Watch for spares to be added to the container, and write updated
	75	* metadata to them.
	76	* - Watch for new arrays using this container, confirm they match metadata
	77	* and if so, start monitoring them
	78	* - Watch for spares being added to monitored arrays. This shouldn't
	79	* happen, as we should do all the adding. Just remove them.
	80	* - Watch for change in raid-disks, chunk-size, etc. Update metadata and
	81	* start a reshape.
	82	*/
	83	#ifndef _GNU_SOURCE
	84	#define _GNU_SOURCE
	85	#endif
	86	#include "mdadm.h"
	87	#include "mdmon.h"
4d43913c	88	#include <sys/syscall.h>
549e9569	89	#include <sys/socket.h>
1ed3f387	90	#include <signal.h>
549e9569	91
2a0bb19e DW	92	static void close_aa(struct active_array *aa)
	93	{
	94	struct mdinfo *d;
	95
	96	for (d = aa->info.devs; d; d = d->next)
	97	close(d->state_fd);
	98
	99	close(aa->action_fd);
	100	close(aa->info.state_fd);
	101	close(aa->resync_start_fd);
2a0bb19e DW	102	}
2a0bb19e DW	103
549e9569 NB	104	static void free_aa(struct active_array *aa)
549e9569 NB	105	{
2a0bb19e DW	106	/* Note that this doesn't close fds if they are being used
2a0bb19e DW	107	* by a clone. ->container will be set for a clone
549e9569	108	*/
4e6e574a	109	dprintf("%s: devnum: %d\n", __func__, aa->devnum);
2a0bb19e DW	110	if (!aa->container)
2a0bb19e DW	111	close_aa(aa);
549e9569 NB	112	while (aa->info.devs) {
	113	struct mdinfo *d = aa->info.devs;
	114	aa->info.devs = d->next;
	115	free(d);
	116	}
	117	free(aa);
	118	}
	119
6c3fb95c NB	120	static struct active_array duplicate_aa(struct active_array aa)
	121	{
	122	struct active_array newa = malloc(sizeof(newa));
	123	struct mdinfo dp1, dp2;
	124
	125	newa = aa;
	126	newa->next = NULL;
	127	newa->replaces = NULL;
	128	newa->info.next = NULL;
	129
	130	dp2 = &newa->info.devs;
	131
	132	for (dp1 = &aa->info.devs; dp1; dp1 = &(dp1)->next) {
	133	struct mdinfo *d;
	134	if ((*dp1)->state_fd < 0)
	135	continue;
	136
	137	d = malloc(sizeof(*d));
	138	d = *dp1;
	139	*dp2 = d;
	140	dp2 = & d->next;
	141	}
7e1432fb	142	*dp2 = NULL;
6c3fb95c NB	143
	144	return newa;
	145	}
	146
4d43913c	147	static void wakeup_monitor(void)
2a0bb19e	148	{
4d43913c NB	149	/* tgkill(getpid(), mon_tid, SIGUSR1); */
	150	int pid = getpid();
	151	syscall(SYS_tgkill, pid, mon_tid, SIGUSR1);
2a0bb19e DW	152	}
2a0bb19e DW	153
1ed3f387 NB	154	static void remove_old(void)
	155	{
	156	if (discard_this) {
	157	discard_this->next = NULL;
	158	free_aa(discard_this);
	159	if (pending_discard == discard_this)
	160	pending_discard = NULL;
	161	discard_this = NULL;
48561b01	162	wakeup_monitor();
1ed3f387 NB	163	}
	164	}
	165
549e9569 NB	166	static void replace_array(struct supertype *container,
	167	struct active_array *old,
	168	struct active_array *new)
	169	{
	170	/* To replace an array, we add it to the top of the list
	171	* marked with ->replaces to point to the original.
	172	* 'monitor' will take the original out of the list
	173	* and put it on 'discard_this'. We take it from there
	174	* and discard it.
	175	*/
1ed3f387	176	remove_old();
549e9569 NB	177	while (pending_discard) {
	178	while (discard_this == NULL)
	179	sleep(1);
1ed3f387	180	remove_old();
549e9569 NB	181	}
	182	pending_discard = old;
	183	new->replaces = old;
	184	new->next = container->arrays;
	185	container->arrays = new;
4d43913c	186	wakeup_monitor();
549e9569 NB	187	}
549e9569 NB	188
2e735d19 NB	189	struct metadata_update *update_queue = NULL;
	190	struct metadata_update *update_queue_handled = NULL;
	191	struct metadata_update *update_queue_pending = NULL;
	192
	193	void check_update_queue(struct supertype *container)
	194	{
	195	while (update_queue_handled) {
	196	struct metadata_update *this = update_queue_handled;
	197	update_queue_handled = this->next;
904c1ef7 NB	198	free(this->buf);
	199	if (this->space)
	200	free(this->space);
2e735d19 NB	201	free(this);
	202	}
	203	if (update_queue == NULL &&
	204	update_queue_pending) {
	205	update_queue = update_queue_pending;
	206	update_queue_pending = NULL;
4d43913c	207	wakeup_monitor();
2e735d19 NB	208	}
	209	}
	210
6c3fb95c	211	static void queue_metadata_update(struct metadata_update *mu)
2e735d19 NB	212	{
	213	struct metadata_update **qp;
	214
	215	qp = &update_queue_pending;
	216	while (*qp)
	217	qp = & ((*qp)->next);
	218	*qp = mu;
	219	}
	220
43dad3d6 DW	221	static void add_disk_to_container(struct supertype st, struct mdinfo sd)
	222	{
	223	int dfd;
	224	char nm[20];
	225	struct metadata_update *update = NULL;
	226	mdu_disk_info_t dk = {
	227	.number = -1,
	228	.major = sd->disk.major,
	229	.minor = sd->disk.minor,
	230	.raid_disk = -1,
	231	.state = 0,
	232	};
	233
	234	dprintf("%s: add %d:%d to container\n",
	235	__func__, sd->disk.major, sd->disk.minor);
	236
	237	sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
	238	dfd = dev_open(nm, O_RDWR);
	239	if (dfd < 0)
	240	return;
	241
	242	st->update_tail = &update;
	243	st->ss->add_to_super(st, &dk, dfd, NULL);
	244	st->ss->write_init_super(st);
	245	queue_metadata_update(update);
	246	st->update_tail = NULL;
	247	}
	248
549e9569 NB	249	static void manage_container(struct mdstat_ent *mdstat,
	250	struct supertype *container)
	251	{
	252	/* The only thing of interest here is if a new device
	253	* has been added to the container. We add it to the
	254	* array ignoring any metadata on it.
	255	* FIXME should we look for compatible metadata and take hints
	256	* about spare assignment.... probably not.
549e9569 NB	257	*/
549e9569 NB	258	if (mdstat->devcnt != container->devcnt) {
7bc1962f DW	259	struct mdinfo *cdp, cd, di, mdi;
	260	int found;
	261
549e9569 NB	262	/* read /sys/block/NAME/md/dev-??/block/dev to find out
	263	* what is there, and compare with container->info.devs
	264	* To see what is removed and what is added.
	265	* These need to be remove from, or added to, the array
	266	*/
7bc1962f	267	mdi = sysfs_read(-1, mdstat->devnum, GET_DEVS);
313a4a82 DW	268	if (!mdi) {
	269	/* invalidate the current count so we can try again */
	270	container->devcnt = -1;
7bc1962f	271	return;
313a4a82	272	}
7bc1962f DW	273
	274	/* check for removals */
	275	for (cdp = &container->devs; *cdp; ) {
	276	found = 0;
	277	for (di = mdi->devs; di; di = di->next)
	278	if (di->disk.major == (*cdp)->disk.major &&
	279	di->disk.minor == (*cdp)->disk.minor) {
	280	found = 1;
	281	break;
	282	}
	283	if (!found) {
	284	cd = *cdp;
	285	cdp = (cdp)->next;
	286	free(cd);
	287	} else
	288	cdp = &(*cdp)->next;
	289	}
43dad3d6 DW	290
	291	/* check for additions */
	292	for (di = mdi->devs; di; di = di->next) {
	293	for (cd = container->devs; cd; cd = cd->next)
	294	if (di->disk.major == cd->disk.major &&
	295	di->disk.minor == cd->disk.minor)
	296	break;
	297	if (!cd)
	298	add_disk_to_container(container, di);
	299	}
7bc1962f	300	sysfs_free(mdi);
549e9569 NB	301	container->devcnt = mdstat->devcnt;
	302	}
	303	}
	304
	305	static void manage_member(struct mdstat_ent *mdstat,
	306	struct active_array *a)
	307	{
	308	/* Compare mdstat info with known state of member array.
	309	* We do not need to look for device state changes here, that
	310	* is dealt with by the monitor.
	311	*
	312	* We just look for changes which suggest that a reshape is
	313	* being requested.
	314	* Unfortunately decreases in raid_disks don't show up in
	315	* mdstat until the reshape completes FIXME.
6c3fb95c NB	316	*
	317	* Actually, we also want to handle degraded arrays here by
	318	* trying to find and assign a spare.
	319	* We do that whenever the monitor tells us too.
549e9569 NB	320	*/
	321	// FIXME
	322	a->info.array.raid_disks = mdstat->raid_disks;
	323	a->info.array.chunk_size = mdstat->chunk_size;
	324	// MORE
	325
6c3fb95c NB	326	if (a->check_degraded) {
	327	struct metadata_update *updates = NULL;
	328	struct mdinfo *newdev;
	329	struct active_array *newa;
3c00ffbe	330
6c3fb95c NB	331	a->check_degraded = 0;
	332
	333	/* The array may not be degraded, this is just a good time
	334	* to check.
	335	*/
	336	newdev = a->container->ss->activate_spare(a, &updates);
	337	if (newdev) {
	338	struct mdinfo *d;
	339	/* Cool, we can add a device or several. */
	340	newa = duplicate_aa(a);
	341	/* suspend recovery - maybe not needed */
	342
	343	/* Add device to array and set offset/size/slot.
	344	* and open files for each newdev */
	345	for (d = newdev; d ; d = d->next) {
	346	struct mdinfo *newd;
00451d98	347	if (sysfs_add_disk(&newa->info, d) < 0)
6c3fb95c	348	continue;
7801ac20 N	349	newd = malloc(sizeof(*newd));
	350	newd = d;
	351	newd->next = newa->info.devs;
	352	newa->info.devs = newd;
	353
6c3fb95c NB	354	newd->state_fd = sysfs_open(a->devnum,
	355	newd->sys_name,
	356	"state");
	357	newd->prev_state
	358	= read_dev_state(newd->state_fd);
	359	newd->curr_state = newd->prev_state;
	360	}
	361	queue_metadata_update(updates);
	362	replace_array(a->container, a, newa);
63d7cc78	363	sysfs_set_str(&a->info, NULL, "sync_action", "recover");
6c3fb95c NB	364	}
6c3fb95c NB	365	}
549e9569 NB	366	}
549e9569 NB	367
836759d5 DW	368	static int aa_ready(struct active_array *aa)
	369	{
	370	struct mdinfo *d;
	371	int level = aa->info.array.level;
	372
	373	for (d = aa->info.devs; d; d = d->next)
	374	if (d->state_fd < 0)
	375	return 0;
	376
	377	if (aa->info.state_fd < 0)
	378	return 0;
	379
	380	if (level > 0 && (aa->action_fd < 0 \|\| aa->resync_start_fd < 0))
	381	return 0;
	382
	383	if (!aa->container)
	384	return 0;
	385
	386	return 1;
	387	}
	388
549e9569	389	static void manage_new(struct mdstat_ent *mdstat,
2a0bb19e DW	390	struct supertype *container,
2a0bb19e DW	391	struct active_array *victim)
549e9569 NB	392	{
	393	/* A new array has appeared in this container.
	394	* Hopefully it is already recorded in the metadata.
	395	* Check, then create the new array to report it to
	396	* the monitor.
	397	*/
	398
	399	struct active_array *new;
	400	struct mdinfo mdi, di;
cba0191b	401	char *inst;
549e9569	402	int i;
f1d26766	403	int failed = 0;
549e9569	404
836759d5 DW	405	/* check if array is ready to be monitored */
	406	if (!mdstat->active)
	407	return;
	408
	409	mdi = sysfs_read(-1, mdstat->devnum,
	410	GET_LEVEL\|GET_CHUNK\|GET_DISKS\|GET_COMPONENT\|
f1d26766	411	GET_DEGRADED\|GET_DEVS\|GET_OFFSET\|GET_SIZE\|GET_STATE);
836759d5	412
549e9569 NB	413	new = malloc(sizeof(*new));
549e9569 NB	414
836759d5 DW	415	if (!new \|\| !mdi) {
	416	if (mdi)
	417	sysfs_free(mdi);
	418	if (new)
	419	free(new);
	420	return;
	421	}
d52690ac NB	422	memset(new, 0, sizeof(*new));
d52690ac NB	423
549e9569	424	new->devnum = mdstat->devnum;
7e1432fb	425	strcpy(new->info.sys_name, devnum2devname(new->devnum));
549e9569 NB	426
	427	new->prev_state = new->curr_state = new->next_state = inactive;
	428	new->prev_action= new->curr_action= new->next_action= idle;
	429
	430	new->container = container;
	431
cba0191b	432	inst = &mdstat->metadata_version[10+strlen(container->devname)+1];
549e9569	433
549e9569	434	new->info.array = mdi->array;
272bcc48	435	new->info.component_size = mdi->component_size;
549e9569 NB	436
	437	for (i = 0; i < new->info.array.raid_disks; i++) {
	438	struct mdinfo newd = malloc(sizeof(newd));
	439
	440	for (di = mdi->devs; di; di = di->next)
	441	if (i == di->disk.raid_disk)
	442	break;
	443
	444	if (di) {
	445	memcpy(newd, di, sizeof(*newd));
	446
549e9569 NB	447	newd->state_fd = sysfs_open(new->devnum,
	448	newd->sys_name,
	449	"state");
	450
	451	newd->prev_state = read_dev_state(newd->state_fd);
6c3fb95c	452	newd->curr_state = newd->prev_state;
f1d26766 DW	453	} else if (failed + 1 > new->info.array.failed_disks) {
f1d26766 DW	454	/* we cannot properly monitor without all working disks */
836759d5 DW	455	new->container = NULL;
836759d5 DW	456	break;
f1d26766 DW	457	} else {
	458	failed++;
	459	free(newd);
	460	continue;
549e9569	461	}
7e1432fb	462	sprintf(newd->sys_name, "rd%d", i);
549e9569 NB	463	newd->next = new->info.devs;
	464	new->info.devs = newd;
	465	}
836759d5	466
549e9569 NB	467	new->action_fd = sysfs_open(new->devnum, NULL, "sync_action");
549e9569 NB	468	new->info.state_fd = sysfs_open(new->devnum, NULL, "array_state");
c052ba30	469	new->resync_start_fd = sysfs_open(new->devnum, NULL, "resync_start");
e9dd1598	470	new->metadata_fd = sysfs_open(new->devnum, NULL, "metadata_version");
103f2410	471	get_resync_start(new);
4e6e574a DW	472	dprintf("%s: inst: %d action: %d state: %d\n", __func__, atoi(inst),
4e6e574a DW	473	new->action_fd, new->info.state_fd);
549e9569	474
4fa5aef9	475	sysfs_free(mdi);
836759d5 DW	476
	477	/* if everything checks out tell the metadata handler we want to
	478	* manage this instance
	479	*/
	480	if (!aa_ready(new) \|\| container->ss->open_new(container, new, inst) < 0) {
	481	fprintf(stderr, "mdmon: failed to monitor %s\n",
	482	mdstat->metadata_version);
549e9569	483	new->container = NULL;
836759d5	484	free_aa(new);
93f7caca	485	} else {
2a0bb19e	486	replace_array(container, victim, new);
93f7caca DW	487	if (failed) {
	488	new->check_degraded = 1;
	489	manage_member(mdstat, new);
	490	}
	491	}
549e9569 NB	492	}
549e9569 NB	493
5d19760d	494	void manage(struct mdstat_ent mdstat, struct supertype container)
549e9569 NB	495	{
	496	/* We have just read mdstat and need to compare it with
	497	* the known active arrays.
	498	* Arrays with the wrong metadata are ignored.
	499	*/
	500
	501	for ( ; mdstat ; mdstat = mdstat->next) {
	502	struct active_array *a;
	503	if (mdstat->devnum == container->devnum) {
	504	manage_container(mdstat, container);
	505	continue;
	506	}
883a6142	507	if (!is_container_member(mdstat, container->devname))
549e9569 NB	508	/* Not for this array */
	509	continue;
	510	/* Looks like a member of this container */
5d19760d	511	for (a = container->arrays; a; a = a->next) {
549e9569 NB	512	if (mdstat->devnum == a->devnum) {
	513	if (a->container)
	514	manage_member(mdstat, a);
	515	break;
	516	}
	517	}
2a0bb19e DW	518	if (a == NULL \|\| !a->container)
2a0bb19e DW	519	manage_new(mdstat, container, a);
549e9569 NB	520	}
	521	}
	522
edd8d13c	523	static void handle_message(struct supertype container, struct metadata_update msg)
3e70c845	524	{
edd8d13c NB	525	/* queue this metadata update through to the monitor */
	526
	527	struct metadata_update *mu;
	528
313a4a82	529	if (msg->len <= 0)
3c00ffbe N	530	while (update_queue_pending \|\| update_queue) {
	531	check_update_queue(container);
	532	usleep(15*1000);
	533	}
	534
313a4a82 DW	535	if (msg->len == 0) { /* ping_monitor */
	536	int cnt;
	537
3c00ffbe	538	cnt = monitor_loop_cnt;
1eb252b8 N	539	if (cnt & 1)
	540	cnt += 2; /* wait until next pselect */
	541	else
	542	cnt += 3; /* wait for 2 pselects */
	543	wakeup_monitor();
3c00ffbe	544
1eb252b8 N	545	while (monitor_loop_cnt - cnt < 0)
1eb252b8 N	546	usleep(10 * 1000);
313a4a82 DW	547	} else if (msg->len == -1) { /* ping_manager */
	548	struct mdstat_ent *mdstat = mdstat_read(1, 0);
	549
	550	manage(mdstat, container);
	551	free_mdstat(mdstat);
6144ed44	552	} else if (!sigterm) {
edd8d13c NB	553	mu = malloc(sizeof(*mu));
	554	mu->len = msg->len;
	555	mu->buf = msg->buf;
	556	msg->buf = NULL;
	557	mu->space = NULL;
	558	mu->next = NULL;
	559	if (container->ss->prepare_update)
	560	container->ss->prepare_update(container, mu);
	561	queue_metadata_update(mu);
	562	}
3e70c845 DW	563	}
	564
	565	void read_sock(struct supertype *container)
549e9569 NB	566	{
549e9569 NB	567	int fd;
bfa44e2e	568	struct metadata_update msg;
b109d928 DW	569	int terminate = 0;
	570	long fl;
	571	int tmo = 3; /* 3 second timeout before hanging up the socket */
549e9569	572
3e70c845	573	fd = accept(container->sock, NULL, NULL);
549e9569 NB	574	if (fd < 0)
549e9569 NB	575	return;
b109d928 DW	576
	577	fl = fcntl(fd, F_GETFL, 0);
	578	fl \|= O_NONBLOCK;
	579	fcntl(fd, F_SETFL, fl);
	580
	581	do {
	582	msg.buf = NULL;
	583
	584	/* read and validate the message */
	585	if (receive_message(fd, &msg, tmo) == 0) {
bfa44e2e NB	586	handle_message(container, &msg);
	587	if (ack(fd, tmo) < 0)
	588	terminate = 1;
	589	} else
b109d928	590	terminate = 1;
b109d928	591
b109d928 DW	592	} while (!terminate);
b109d928 DW	593
549e9569 NB	594	close(fd);
549e9569 NB	595	}
1ed3f387	596
e0d6609f NB	597	int exit_now = 0;
e0d6609f NB	598	int manager_ready = 0;
549e9569 NB	599	void do_manager(struct supertype *container)
	600	{
	601	struct mdstat_ent *mdstat;
4d43913c	602	sigset_t set;
695154b2	603	int proc_fd;
1ed3f387	604
4d43913c NB	605	sigprocmask(SIG_UNBLOCK, NULL, &set);
4d43913c NB	606	sigdelset(&set, SIGUSR1);
295646b3	607	sigdelset(&set, SIGHUP);
695154b2	608	sigdelset(&set, SIGALRM);
6144ed44	609	sigdelset(&set, SIGTERM);
695154b2	610	proc_fd = open("/proc/mounts", O_RDONLY);
549e9569 NB	611
549e9569 NB	612	do {
1ed3f387	613
e0d6609f NB	614	if (exit_now)
	615	exit(0);
	616
3c00ffbe N	617	/* Can only 'manage' things if 'monitor' is not making
	618	* structural changes to metadata, so need to check
	619	* update_queue
	620	*/
	621	if (update_queue == NULL) {
	622	mdstat = mdstat_read(1, 0);
549e9569	623
3c00ffbe	624	manage(mdstat, container);
549e9569	625
3c00ffbe	626	read_sock(container);
4fa5aef9	627
695154b2	628	if (container->sock < 0 \|\| socket_hup_requested) {
295646b3 DW	629	close(container->sock);
	630	container->sock = make_control_sock(container->devname);
	631	make_pidfile(container->devname, 0);
	632	socket_hup_requested = 0;
	633	}
695154b2 DW	634	if (container->sock < 0)
695154b2 DW	635	alarm(30);
295646b3	636
3c00ffbe N	637	free_mdstat(mdstat);
3c00ffbe N	638	}
1ed3f387 NB	639	remove_old();
1ed3f387 NB	640
2e735d19 NB	641	check_update_queue(container);
2e735d19 NB	642
e0d6609f	643	manager_ready = 1;
4d43913c	644
6144ed44 DW	645	if (sigterm)
	646	wakeup_monitor();
	647
695154b2 DW	648	if (update_queue == NULL) {
	649	if (container->sock < 0)
	650	mdstat_wait_fd(proc_fd, &set);
	651	else
	652	mdstat_wait_fd(container->sock, &set);
	653	} else
3c00ffbe N	654	/* If an update is happening, just wait for signal */
3c00ffbe N	655	pselect(0, NULL, NULL, NULL, NULL, &set);
549e9569 NB	656	} while(1);
549e9569 NB	657	}