path: root/mdstat.c

/*
 * mdstat - parse /proc/mdstat file. Part of:
 * mdadm - manage Linux "md" devices aka RAID arrays.
 *
 * Copyright (C) 2002-2009 Neil Brown <neilb@suse.de>
 *
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Author: Neil Brown
 *    Email: <neilb@suse.de>
 */

/*
 * The /proc/mdstat file comes in at least 3 flavours:
 * In an unpatched 2.2 kernel (md 0.36.6):
 *  Personalities : [n raidx] ...
 *  read_ahead {not set|%d sectors}
 *  md0 : {in}active{ raidX /dev/hda...  %d blocks{ maxfault=%d}}
 *  md1 : .....
 *
 * Normally only 4 md lines, but all are listed.
 *
 * In a patched 2.2 kernel (md 0.90.0)
 *  Personalities : [raidx] ...
 *  read_ahead {not set|%d sectors}
 *  mdN : {in}active {(readonly)} raidX dev[%d]{(F)} ... %d blocks STATUS RESYNC
 *  ... Only initialised arrays listed
 *  unused devices: {dev dev ... | <none>}
 *
 * STATUS is personality dependant:
 *    linear:  %dk rounding
 *    raid0:   %dk chunks
 *    raid1:   [%d/%d] [U_U]   ( raid/working.  operational or not)
 *    raid5:   level 4/5, %dk chunk, algorithm %d [%d/%d] [U_U]
 *
 * RESYNC is  empty or:
 *    {resync|recovery}=%u%% finish=%u.%umin
 *  or
 *    resync=DELAYED
 *
 * In a 2.4 kernel (md 0.90.0/2.4)
 *  Personalities : [raidX] ...
 *  read_ahead {not set|%d sectors}
 *  mdN : {in}active {(read-only)} raidX dev[%d]{(F)} ...
 *       %d blocks STATUS
 *       RESYNC
 *  unused devices: {dev dev .. | <none>}
 *
 *  STATUS matches 0.90.0/2.2
 *  RESYNC includes [===>....],
 *          adds a space after {resync|recovery} and before and after '='
 *          adds a decimal to the recovery percent.
 *	    adds (%d/%d) resync amount  and max_blocks, before finish.
 *	    adds speed=%dK/sec after finish
 *
 *
 *
 * Out of this we want to extract:
 *   list of devices, active or not
 *   pattern of failed drives (so need number of drives)
 *   percent resync complete
 *
 * As continuation is indicated by leading space, we use
 *  conf_line from config.c to read logical lines
 *
 */

#include	"mdadm.h"
#include	"dlink.h"
#include	<sys/select.h>
#include	<ctype.h>

static void free_member_devnames(struct dev_member *m)
{
	while(m) {
		struct dev_member *t = m;

		m = m->next;
		free(t->name);
		free(t);
	}
}

static int add_member_devname(struct dev_member **m, char *name)
{
	struct dev_member *new;
	char *t;

	if ((t = strchr(name, '[')) == NULL)
		/* not a device */
		return 0;

	new = xmalloc(sizeof(*new));
	new->name = strndup(name, t - name);
	new->next = *m;
	*m = new;
	return 1;
}

/* Detach element from the list, it may modify list_head */
static void mdstat_ent_list_detach_element(struct mdstat_ent **list_head, struct mdstat_ent *el)
{
	struct mdstat_ent *ent = *list_head;

	if (ent == el) {
		*list_head = ent->next;
	} else {
		while (ent) {
			if (ent->next == el) {
				ent->next = el->next;
				break;
			}
		}

		ent = ent->next;
	}

	assert(ent);
	ent->next = NULL;
}

void free_mdstat(struct mdstat_ent *ms)
{
	while (ms) {
		struct mdstat_ent *t;
		free(ms->level);
		free(ms->pattern);
		free(ms->metadata_version);
		free_member_devnames(ms->members);
		t = ms;
		ms = ms->next;
		free(t);
	}
}

bool is_mdstat_ent_external(struct mdstat_ent *ent)
{
	if (!ent->metadata_version)
		return false;

	if (strncmp(ent->metadata_version, "external:", 9) == 0)
		return true;
	return false;
}

bool is_mdstat_ent_subarray(struct mdstat_ent *ent)
{
	if (is_mdstat_ent_external(ent) && is_subarray(ent->metadata_version + 9))
		return true;
	return false;
}

bool is_container_member(struct mdstat_ent *mdstat, char *container)
{
	if (is_mdstat_ent_external(mdstat) &&
	    metadata_container_matches(mdstat->metadata_version + 9, container))
		return true;

	return false;
}

static int mdstat_fd = -1;
struct mdstat_ent *mdstat_read(int hold, int start)
{
	FILE *f;
	struct mdstat_ent *all, *rv, **end, **insert_here;
	char *line;
	int fd;

	if (hold && mdstat_fd != -1) {
		off_t offset = lseek(mdstat_fd, 0L, 0);
		if (offset == (off_t)-1) {
			return NULL;
		}
		fd = dup(mdstat_fd);
		if (fd >= 0)
			f = fdopen(fd, "r");
		else
			return NULL;
	} else
		f = fopen("/proc/mdstat", "r");
	if (f == NULL)
		return NULL;

	if (fcntl(fileno(f), F_SETFD, FD_CLOEXEC) < 0) {
		fclose(f);
		return NULL;
	}

	all = NULL;
	end = &all;
	for (; (line = conf_line(f)) ; free_line(line)) {
		struct mdstat_ent *ent;
		char *w;
		char devnm[32];
		int in_devs = 0;

		if (strcmp(line, "Personalities") == 0)
			continue;
		if (strcmp(line, "read_ahead") == 0)
			continue;
		if (strcmp(line, "unused") == 0)
			continue;
		insert_here = NULL;
		/* Better be an md line.. */
		if (strncmp(line, "md", 2)!= 0 || strlen(line) >= 32 ||
		    (line[2] != '_' && !isdigit(line[2])))
			continue;
		strcpy(devnm, line);

		ent = xmalloc(sizeof(*ent));
		ent->level = ent->pattern= NULL;
		ent->next = NULL;
		ent->percent = RESYNC_NONE;
		ent->active = -1;
		ent->resync = 0;
		ent->metadata_version = NULL;
		ent->raid_disks = 0;
		ent->devcnt = 0;
		ent->members = NULL;

		strcpy(ent->devnm, devnm);

		for (w=dl_next(line); w!= line ; w=dl_next(w)) {
			int l = strlen(w);
			char *eq;
			if (strcmp(w, "active") == 0)
				ent->active = 1;
			else if (strcmp(w, "inactive") == 0) {
				ent->active = 0;
				in_devs = 1;
			} else if (strcmp(w, "bitmap:") == 0) {
				/* We need to stop parsing here;
				 * otherwise, ent->raid_disks will be
				 * overwritten by the wrong value.
				 */
				break;
			} else if (ent->active > 0 &&
				 ent->level == NULL &&
				 w[0] != '(' /*readonly*/) {
				ent->level = xstrdup(w);
				in_devs = 1;
			} else if (in_devs && strcmp(w, "blocks") == 0)
				in_devs = 0;
			else if (in_devs) {
				char *ep = strchr(w, '[');
				ent->devcnt +=
					add_member_devname(&ent->members, w);
				if (ep && strncmp(w, "md", 2) == 0) {
					/* This has an md device as a component.
					 * If that device is already in the
					 * list, make sure we insert before
					 * there.
					 */
					struct mdstat_ent **ih;
					ih = &all;
					while (ih != insert_here && *ih &&
					       ((int)strlen((*ih)->devnm) !=
						ep-w ||
						strncmp((*ih)->devnm, w,
							ep-w) != 0))
						ih = & (*ih)->next;
					insert_here = ih;
				}
			} else if (strcmp(w, "super") == 0 &&
				   dl_next(w) != line) {
				w = dl_next(w);
				ent->metadata_version = xstrdup(w);
			} else if (w[0] == '[' && isdigit(w[1])) {
				ent->raid_disks = atoi(w+1);
			} else if (!ent->pattern &&
				   w[0] == '[' &&
				   (w[1] == 'U' || w[1] == '_')) {
				ent->pattern = xstrdup(w+1);
				if (ent->pattern[l-2] == ']')
					ent->pattern[l-2] = '\0';
			} else if (ent->percent == RESYNC_NONE &&
				   strncmp(w, "re", 2) == 0 &&
				   w[l-1] == '%' &&
				   (eq = strchr(w, '=')) != NULL ) {
				ent->percent = atoi(eq+1);
				if (strncmp(w,"resync", 6) == 0)
					ent->resync = 1;
				else if (strncmp(w, "reshape", 7) == 0)
					ent->resync = 2;
				else
					ent->resync = 0;
			} else if (ent->percent == RESYNC_NONE &&
				   (w[0] == 'r' || w[0] == 'c')) {
				if (strncmp(w, "resync", 6) == 0)
					ent->resync = 1;
				if (strncmp(w, "reshape", 7) == 0)
					ent->resync = 2;
				if (strncmp(w, "recovery", 8) == 0)
					ent->resync = 0;
				if (strncmp(w, "check", 5) == 0)
					ent->resync = 3;

				if (l > 8 && strcmp(w+l-8, "=DELAYED") == 0)
					ent->percent = RESYNC_DELAYED;
				if (l > 8 && strcmp(w+l-8, "=PENDING") == 0)
					ent->percent = RESYNC_PENDING;
				if (l > 7 && strcmp(w+l-7, "=REMOTE") == 0)
					ent->percent = RESYNC_REMOTE;
			} else if (ent->percent == RESYNC_NONE &&
				   w[0] >= '0' &&
				   w[0] <= '9' &&
				   w[l-1] == '%') {
				ent->percent = atoi(w);
			}
		}
		if (insert_here && (*insert_here)) {
			ent->next = *insert_here;
			*insert_here = ent;
		} else {
			*end = ent;
			end = &ent->next;
		}
	}
	if (hold && mdstat_fd == -1) {
		mdstat_fd = dup(fileno(f));
		if (fcntl(mdstat_fd, F_SETFD, FD_CLOEXEC) < 0) {
			fclose(f);
			return NULL;
		}
	}
	fclose(f);

	/* If we might want to start array,
	 * reverse the order, so that components comes before composites
	 */
	if (start) {
		rv = NULL;
		while (all) {
			struct mdstat_ent *e = all;
			all = all->next;
			e->next = rv;
			rv = e;
		}
	} else
		rv = all;
	return rv;
}

void mdstat_close(void)
{
	if (mdstat_fd >= 0)
		close(mdstat_fd);
	mdstat_fd = -1;
}

/*
 * function: mdstat_wait
 * Description: Function waits for event on mdstat.
 * Parameters:
 *		seconds - timeout for waiting
 * Returns:
 *		> 0 - detected event
 *		0 - timeout
 *		< 0 - detected error
 */
int mdstat_wait(int seconds)
{
	fd_set fds;
	struct timeval tm;
	int maxfd = 0;
	FD_ZERO(&fds);
	if (mdstat_fd >= 0) {
		FD_SET(mdstat_fd, &fds);
		maxfd = mdstat_fd;
	} else
		return -1;

	tm.tv_sec = seconds;
	tm.tv_usec = 0;

	return select(maxfd + 1, NULL, NULL, &fds, &tm);
}

void mdstat_wait_fd(int fd, const sigset_t *sigmask)
{
	fd_set fds, rfds;
	int maxfd = 0;

	FD_ZERO(&fds);
	FD_ZERO(&rfds);
	if (mdstat_fd >= 0)
		FD_SET(mdstat_fd, &fds);

	if (fd >= 0) {
		struct stat stb;
		if (fstat(fd, &stb) != 0)
			return;
		if ((stb.st_mode & S_IFMT) == S_IFREG)
			/* Must be a /proc or /sys fd, so expect
			 * POLLPRI
			 * i.e. an 'exceptional' event.
			 */
			FD_SET(fd, &fds);
		else
			FD_SET(fd, &rfds);

		if (fd > maxfd)
			maxfd = fd;

	}
	if (mdstat_fd > maxfd)
		maxfd = mdstat_fd;

	pselect(maxfd + 1, &rfds, NULL, &fds,
		NULL, sigmask);
}

int mddev_busy(char *devnm)
{
	struct mdstat_ent *mdstat = mdstat_read(0, 0);
	struct mdstat_ent *me;

	for (me = mdstat ; me ; me = me->next)
		if (strcmp(me->devnm, devnm) == 0)
			break;
	free_mdstat(mdstat);
	return me != NULL;
}

/**
 * mdstat_find_by_member_devnm()- Return first array or external container with member device.
 * @mdstat: Preloaded mdstat to iterate over.
 * @member_devnm: devnm of the device to find.
 *
 * External subarrays are skipped.
 */
struct mdstat_ent *mdstat_find_by_member_name(struct mdstat_ent *mdstat, char *member_devnm)
{
	struct mdstat_ent *ent;

	for (ent = mdstat; ent; ent = ent->next) {
		struct dev_member *member;

		if (is_mdstat_ent_subarray(ent))
			continue;

		for (member = ent->members; member; member = member->next)
			if (strcmp(member->name, member_devnm) == 0)
				return ent;
	}

	return NULL;
}


struct mdstat_ent *mdstat_by_component(char *name)
{
	struct mdstat_ent *mdstat = mdstat_read(0, 0);
	struct mdstat_ent *ent = mdstat_find_by_member_name(mdstat, name);

	if (ent)
		mdstat_ent_list_detach_element(&mdstat, ent);

	free_mdstat(mdstat);

	return ent;
}

struct mdstat_ent *mdstat_by_subdev(char *subdev, char *container)
{
	struct mdstat_ent *mdstat = mdstat_read(0, 0);
	struct mdstat_ent *ent = NULL;

	for (ent = mdstat; ent; ent = ent->next) {
		/* metadata version must match:
		 *   external:[/-]%s/%s
		 * where first %s is 'container' and second %s is 'subdev'
		 */

		if (!is_mdstat_ent_external(ent))
			continue;

		if (!metadata_container_matches(ent->metadata_version + 9, container))
			continue;
		if (!metadata_subdev_matches(ent->metadata_version + 9, subdev))
			continue;

		break;
	}

	if (ent)
		mdstat_ent_list_detach_element(&mdstat, ent);

	free_mdstat(mdstat);
	return ent;
}