[thirdparty/mdadm.git] / mdstat.c

/*
 * mdstat - parse /proc/mdstat file. Part of:
 * mdadm - manage Linux "md" devices aka RAID arrays.
 *
 * Copyright (C) 2002-2006 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@cse.unsw.edu.au>
 *    Paper: Neil Brown
 *           School of Computer Science and Engineering
 *           The University of New South Wales
 *           Sydney, 2052
 *           Australia
 */

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

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

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;

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

	all = NULL;
	end = &all;
	for (; (line = conf_line(f)) ; free_line(line)) {
		struct mdstat_ent *ent;
		char *w;
		int devnum;
		int in_devs = 0;
		char *ep;

		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)
			continue;
		if (strncmp(line, "md_d", 4) == 0)
			devnum = -1-strtoul(line+4, &ep, 10);
		else if (strncmp(line, "md", 2) == 0)
			devnum = strtoul(line+2, &ep, 10);
		else
			continue;
		if (ep == NULL || *ep ) {
			/* fprintf(stderr, Name ": bad /proc/mdstat line starts: %s\n", line); */
			continue;
		}

		ent = malloc(sizeof(*ent));
		if (!ent) {
			fprintf(stderr, Name ": malloc failed reading /proc/mdstat.\n");
			free_line(line);
			break;
		}
		ent->dev = ent->level = ent->pattern= NULL;
		ent->next = NULL;
		ent->percent = -1;
		ent->active = -1;
		ent->resync = 0;

		ent->dev = strdup(line);
		ent->devnum = devnum;
		
		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;
			else if (ent->active >=0 &&
				 ent->level == NULL &&
				 w[0] != '(' /*readonly*/) {
				ent->level = strdup(w);
				in_devs = 1;
			} else if (in_devs && strcmp(w, "blocks")==0)
				in_devs = 0;
			else if (in_devs && 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;
				int dn2;
				if (strncmp(w, "md_d", 4)==0)
					dn2 = -1-strtoul(w+4, &ep, 10);
				else
					dn2 = strtoul(w+2, &ep, 10);
				ih = &all;
				while (ih != insert_here && *ih &&
				       (*ih)->devnum != dn2)
					ih = & (*ih)->next;
				insert_here = ih;
			} else if (!ent->pattern &&
				 w[0] == '[' &&
				 (w[1] == 'U' || w[1] == '_')) {
				ent->pattern = strdup(w+1);
				if (ent->pattern[l-2]==']')
					ent->pattern[l-2] = '\0';
			} else if (ent->percent == -1 &&
				   strncmp(w, "re", 2)== 0 &&
				   w[l-1] == '%' &&
				   (eq=strchr(w, '=')) != NULL ) {
				ent->percent = atoi(eq+1);
				if (strncmp(w,"resync", 4)==0)
					ent->resync = 1;
			} else if (ent->percent == -1 &&
				   strncmp(w, "resync", 4)==0) {
				ent->resync = 1;
			} else if (ent->percent == -1 &&
				   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));
	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_wait(int seconds)
{
	fd_set fds;
	struct timeval tm;
	FD_ZERO(&fds);
	if (mdstat_fd >= 0)
		FD_SET(mdstat_fd, &fds);
	tm.tv_sec = seconds;
	tm.tv_usec = 0;
	select(mdstat_fd >2 ? mdstat_fd+1:3, NULL, NULL, &fds, &tm);
}
Commit	Line	Data
e0d19036 NB	1	/*
	2	* mdstat - parse /proc/mdstat file. Part of:
	3	* mdadm - manage Linux "md" devices aka RAID arrays.
	4	*
4f589ad0	5	* Copyright (C) 2002-2006 Neil Brown <neilb@suse.de>
e0d19036 NB	6	*
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*
	22	* Author: Neil Brown
	23	* Email: <neilb@cse.unsw.edu.au>
	24	* Paper: Neil Brown
	25	* School of Computer Science and Engineering
	26	* The University of New South Wales
	27	* Sydney, 2052
	28	* Australia
	29	*/
	30
	31	/*
	32	* The /proc/mdstat file comes in at least 3 flavours:
	33	* In an unpatched 2.2 kernel (md 0.36.6):
	34	* Personalities : [n raidx] ...
	35	* read_ahead {not set\|%d sectors}
	36	* md0 : {in}active{ raidX /dev/hda... %d blocks{ maxfault=%d}}
	37	* md1 : .....
	38	*
	39	* Normally only 4 md lines, but all are listed.
	40	*
	41	* In a patched 2.2 kernel (md 0.90.0)
	42	* Personalities : [raidx] ...
	43	* read_ahead {not set\|%d sectors}
	44	* mdN : {in}active {(readonly)} raidX dev[%d]{(F)} ... %d blocks STATUS RESYNC
	45	* ... Only initialised arrays listed
8f21823f	46	* unused devices: {dev dev ... \| <none>}
e0d19036 NB	47	*
	48	* STATUS is personality dependant:
	49	* linear: %dk rounding
	50	* raid0: %dk chunks
	51	* raid1: [%d/%d] [U_U] ( raid/working. operational or not)
	52	* raid5: level 4/5, %dk chunk, algorithm %d [%d/%d] [U_U]
	53	*
	54	* RESYNC is empty or:
	55	* {resync\|recovery}=%u%% finish=%u.%umin
	56	* or
	57	* resync=DELAYED
	58	*
	59	* In a 2.4 kernel (md 0.90.0/2.4)
	60	* Personalities : [raidX] ...
	61	* read_ahead {not set\|%d sectors}
	62	* mdN : {in}active {(read-only)} raidX dev[%d]{(F)} ...
	63	* %d blocks STATUS
	64	* RESYNC
8f21823f	65	* unused devices: {dev dev .. \| <none>}
e0d19036 NB	66	*
	67	* STATUS matches 0.90.0/2.2
	68	* RESYNC includes [===>....],
	69	* adds a space after {resync\|recovery} and before and after '='
	70	* adds a decimal to the recovery percent.
	71	* adds (%d/%d) resync amount and max_blocks, before finish.
	72	* adds speed=%dK/sec after finish
	73	*
	74	*
	75	*
	76	* Out of this we want to extract:
	77	* list of devices, active or not
	78	* pattern of failed drives (so need number of drives)
	79	* percent resync complete
	80	*
	81	* As continuation is indicated by leading space, we use
	82	* conf_line from config.c to read logical lines
	83	*
	84	*/
	85
	86	#include "mdadm.h"
	87	#include "dlink.h"
dd0781e5	88	#include <sys/select.h>
e0d19036 NB	89
	90	void free_mdstat(struct mdstat_ent *ms)
	91	{
	92	while (ms) {
	93	struct mdstat_ent *t;
	94	if (ms->dev) free(ms->dev);
	95	if (ms->level) free(ms->level);
	96	if (ms->pattern) free(ms->pattern);
	97	t = ms;
	98	ms = ms->next;
	99	free(t);
	100	}
	101	}
	102
dd0781e5	103	static int mdstat_fd = -1;
22a88995	104	struct mdstat_ent *mdstat_read(int hold, int start)
e0d19036 NB	105	{
e0d19036 NB	106	FILE *f;
22a88995	107	struct mdstat_ent all, rv, end, insert_here;
e0d19036 NB	108	char *line;
e0d19036 NB	109
dd0781e5 NB	110	if (hold && mdstat_fd != -1) {
	111	lseek(mdstat_fd, 0L, 0);
	112	f = fdopen(dup(mdstat_fd), "r");
	113	} else
	114	f = fopen("/proc/mdstat", "r");
e0d19036 NB	115	if (f == NULL)
	116	return NULL;
	117
	118	all = NULL;
	119	end = &all;
	120	for (; (line = conf_line(f)) ; free_line(line)) {
	121	struct mdstat_ent *ent;
	122	char *w;
98c6faba	123	int devnum;
22a88995	124	int in_devs = 0;
98c6faba	125	char *ep;
e0d19036 NB	126
	127	if (strcmp(line, "Personalities")==0)
	128	continue;
	129	if (strcmp(line, "read_ahead")==0)
	130	continue;
	131	if (strcmp(line, "unused")==0)
	132	continue;
22a88995	133	insert_here = NULL;
e0d19036	134	/* Better be an md line.. */
98c6faba NB	135	if (strncmp(line, "md", 2)!= 0)
	136	continue;
	137	if (strncmp(line, "md_d", 4) == 0)
	138	devnum = -1-strtoul(line+4, &ep, 10);
	139	else if (strncmp(line, "md", 2) == 0)
	140	devnum = strtoul(line+2, &ep, 10);
	141	else
	142	continue;
	143	if (ep == NULL \|\| *ep ) {
	144	/* fprintf(stderr, Name ": bad /proc/mdstat line starts: %s\n", line); */
e0d19036 NB	145	continue;
	146	}
	147
	148	ent = malloc(sizeof(*ent));
	149	if (!ent) {
	150	fprintf(stderr, Name ": malloc failed reading /proc/mdstat.\n");
	151	free_line(line);
dd0781e5	152	break;
e0d19036 NB	153	}
	154	ent->dev = ent->level = ent->pattern= NULL;
	155	ent->next = NULL;
	156	ent->percent = -1;
	157	ent->active = -1;
e5329c37	158	ent->resync = 0;
e0d19036 NB	159
e0d19036 NB	160	ent->dev = strdup(line);
98c6faba	161	ent->devnum = devnum;
e0d19036 NB	162
	163	for (w=dl_next(line); w!= line ; w=dl_next(w)) {
	164	int l = strlen(w);
	165	char *eq;
	166	if (strcmp(w, "active")==0)
	167	ent->active = 1;
	168	else if (strcmp(w, "inactive")==0)
	169	ent->active = 0;
	170	else if (ent->active >=0 &&
	171	ent->level == NULL &&
22a88995	172	w[0] != '(' /readonly/) {
e0d19036	173	ent->level = strdup(w);
22a88995 NB	174	in_devs = 1;
	175	} else if (in_devs && strcmp(w, "blocks")==0)
	176	in_devs = 0;
	177	else if (in_devs && strncmp(w, "md", 2)==0) {
	178	/* This has an md device as a component.
	179	* If that device is already in the list,
	180	* make sure we insert before there.
	181	*/
	182	struct mdstat_ent **ih;
	183	int dn2;
	184	if (strncmp(w, "md_d", 4)==0)
	185	dn2 = -1-strtoul(w+4, &ep, 10);
	186	else
	187	dn2 = strtoul(w+2, &ep, 10);
	188	ih = &all;
	189	while (ih != insert_here && *ih &&
	190	(*ih)->devnum != dn2)
	191	ih = & (*ih)->next;
	192	insert_here = ih;
	193	} else if (!ent->pattern &&
e0d19036 NB	194	w[0] == '[' &&
	195	(w[1] == 'U' \|\| w[1] == '_')) {
	196	ent->pattern = strdup(w+1);
	197	if (ent->pattern[l-2]==']')
	198	ent->pattern[l-2] = '\0';
	199	} else if (ent->percent == -1 &&
	200	strncmp(w, "re", 2)== 0 &&
	201	w[l-1] == '%' &&
	202	(eq=strchr(w, '=')) != NULL ) {
	203	ent->percent = atoi(eq+1);
e5329c37 NB	204	if (strncmp(w,"resync", 4)==0)
	205	ent->resync = 1;
	206	} else if (ent->percent == -1 &&
	207	strncmp(w, "resync", 4)==0) {
	208	ent->resync = 1;
e0d19036 NB	209	} else if (ent->percent == -1 &&
	210	w[0] >= '0' &&
	211	w[0] <= '9' &&
	212	w[l-1] == '%') {
	213	ent->percent = atoi(w);
	214	}
	215	}
22a88995 NB	216	if (insert_here && (*insert_here)) {
	217	ent->next = *insert_here;
	218	*insert_here = ent;
	219	} else {
	220	*end = ent;
	221	end = &ent->next;
	222	}
e0d19036	223	}
dd0781e5 NB	224	if (hold && mdstat_fd == -1)
dd0781e5 NB	225	mdstat_fd = dup(fileno(f));
e0d19036	226	fclose(f);
22a88995 NB	227
	228	/* If we might want to start array,
	229	* reverse the order, so that components comes before composites
	230	*/
	231	if (start) {
	232	rv = NULL;
	233	while (all) {
	234	struct mdstat_ent *e = all;
	235	all = all->next;
	236	e->next = rv;
	237	rv = e;
	238	}
	239	} else rv = all;
	240	return rv;
e0d19036	241	}
dd0781e5 NB	242
	243	void mdstat_wait(int seconds)
	244	{
	245	fd_set fds;
	246	struct timeval tm;
	247	FD_ZERO(&fds);
	248	if (mdstat_fd >= 0)
	249	FD_SET(mdstat_fd, &fds);
	250	tm.tv_sec = seconds;
	251	tm.tv_usec = 0;
	252	select(mdstat_fd >2 ? mdstat_fd+1:3, NULL, NULL, &fds, &tm);
	253	}