[thirdparty/mdadm.git] / sysfs.c

/*
 * sysfs - extract md related information from sysfs.  Part of:
 * mdadm - manage Linux "md" devices aka RAID arrays.
 *
 * Copyright (C) 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@suse.de>
 */

#include	"mdadm.h"
#include	<dirent.h>

int load_sys(char *path, char *buf)
{
	int fd = open(path, O_RDONLY);
	int n;
	if (fd < 0)
		return -1;
	n = read(fd, buf, 1024);
	close(fd);
	if (n <=0 || n >= 1024)
		return -1;
	buf[n] = 0;
	if (buf[n-1] == '\n')
		buf[n-1] = 0;
	return 0;
}

struct sysarray *sysfs_read(int fd, int devnum, unsigned long options)
{
	/* Longest possible name in sysfs, mounted at /sys, is
	 *  /sys/block/md_dXXX/md/dev-XXXXX/block/dev
	 *  /sys/block/md_dXXX/md/metadata_version
	 * which is about 41 characters.  50 should do for now
	 */
	char fname[50];
	char buf[1024];
	char *base;
	char *dbase;
	struct sysarray *sra;
	struct sysdev *dev;
	DIR *dir;
	struct dirent *de;

	sra = malloc(sizeof(*sra));
	if (sra == NULL)
		return sra;

	if (fd >= 0) {
		struct stat stb;
		if (fstat(fd, &stb)) return NULL;
		if (major(stb.st_rdev)==9)
			sprintf(sra->name, "md%d", minor(stb.st_rdev));
		else
			sprintf(sra->name, "md_d%d",
				minor(stb.st_rdev)>>MdpMinorShift);
	} else {
		if (devnum >= 0)
			sprintf(sra->name, "md%d", devnum);
		else
			sprintf(sra->name, "md_d%d",
				-1-devnum);
	}
	sprintf(fname, "/sys/block/%s/md/", sra->name);
	base = fname + strlen(fname);

	sra->devs = NULL;
	if (options & GET_LEVEL) {
		strcpy(base, "level");
		if (load_sys(fname, buf))
			goto abort;
		sra->level = map_name(pers, buf);
	}
	if (options & GET_LAYOUT) {
		strcpy(base, "layout");
		if (load_sys(fname, buf))
			goto abort;
		sra->layout = strtoul(buf, NULL, 0);
	}
	if (options & GET_COMPONENT) {
		strcpy(base, "component_size");
		if (load_sys(fname, buf))
			goto abort;
		sra->component_size = strtoull(buf, NULL, 0);
		/* sysfs reports "K", but we want sectors */
		sra->component_size *= 2;
	}
	if (options & GET_CHUNK) {
		strcpy(base, "chunk_size");
		if (load_sys(fname, buf))
			goto abort;
		sra->chunk = strtoul(buf, NULL, 0);
	}

	if (! (options & GET_DEVS))
		return sra;

	/* Get all the devices as well */
	*base = 0;
	dir = opendir(fname);
	if (!dir)
		goto abort;
	sra->spares = 0;

	while ((de = readdir(dir)) != NULL) {
		char *ep;
		if (de->d_ino == 0 ||
		    strncmp(de->d_name, "dev-", 4) != 0)
			continue;
		strcpy(base, de->d_name);
		dbase = base + strlen(base);
		*dbase++ = '/';

		dev = malloc(sizeof(*dev));
		if (!dev)
			goto abort;
		dev->next = sra->devs;
		sra->devs = dev;

		/* Always get slot, major, minor */
		strcpy(dbase, "slot");
		if (load_sys(fname, buf))
			goto abort;
		dev->role = strtoul(buf, &ep, 10);
		if (*ep) dev->role = -1;

		strcpy(dbase, "block/dev");
		if (load_sys(fname, buf))
			goto abort;
		sscanf(buf, "%d:%d", &dev->major, &dev->minor);

		if (options & GET_OFFSET) {
			strcpy(dbase, "offset");
			if (load_sys(fname, buf))
				goto abort;
			dev->offset = strtoull(buf, NULL, 0);
		}
		if (options & GET_SIZE) {
			strcpy(dbase, "size");
			if (load_sys(fname, buf))
				goto abort;
			dev->size = strtoull(buf, NULL, 0);
		}
		if (options & GET_STATE) {
			dev->state = 0;
			strcpy(dbase, "state");
			if (load_sys(fname, buf))
				goto abort;
			if (strstr(buf, "in_sync"))
				dev->state |= (1<<MD_DISK_SYNC);
			if (strstr(buf, "faulty"))
				dev->state |= (1<<MD_DISK_FAULTY);
			if (dev->state == 0)
				sra->spares++;
		}
		if (options & GET_ERROR) {
			strcpy(buf, "errors");
			if (load_sys(fname, buf))
				goto abort;
			dev->errors = strtoul(buf, NULL, 0);
		}
	}
	return sra;

 abort:
	while (sra && sra->devs) {
		dev = sra->devs;
		sra->devs = dev->next;
		free(dev);
	}
	if(sra) free(sra);
	return NULL;
}

unsigned long long get_component_size(int fd)
{
	/* Find out the component size of the array.
	 * We cannot trust GET_ARRAY_INFO ioctl as it's
	 * size field is only 32bits.
	 * So look in /sys/block/mdXXX/md/component_size
	 *
	 * WARNING: this returns in units of Kilobytes.
	 */
	struct stat stb;
	char fname[50];
	int n;
	if (fstat(fd, &stb)) return 0;
	if (major(stb.st_rdev) == 9)
		sprintf(fname, "/sys/block/md%d/md/component_size",
			minor(stb.st_rdev));
	else
		sprintf(fname, "/sys/block/md_d%d/md/component_size",
			minor(stb.st_rdev)>>MdpMinorShift);
	fd = open(fname, O_RDONLY);
	if (fd < 0)
		return 0;
	n = read(fd, fname, sizeof(fname));
	close(fd);
	if (n == sizeof(fname))
		return 0;
	fname[n] = 0;
	return strtoull(fname, NULL, 10);
}

int sysfs_set_str(struct sysarray *sra, struct sysdev *dev,
		  char *name, char *val)
{
	char fname[50];
	int n;
	int fd;
	sprintf(fname, "/sys/block/%s/md/%s/%s",
		sra->name, dev?dev->name:"", name);
	fd = open(fname, O_WRONLY);
	if (fd < 0)
		return -1;
	n = write(fd, val, strlen(val));
	close(fd);
	if (n != strlen(val))
		return -1;
	return 0;
}

int sysfs_set_num(struct sysarray *sra, struct sysdev *dev,
		  char *name, unsigned long long val)
{
	char valstr[50];
	sprintf(valstr, "%llu", val);
	return sysfs_set_str(sra, dev, name, valstr);
}

int sysfs_get_ll(struct sysarray *sra, struct sysdev *dev,
		       char *name, unsigned long long *val)
{
	char fname[50];
	char buf[50];
	int n;
	int fd;
	char *ep;
	sprintf(fname, "/sys/block/%s/md/%s/%s",
		sra->name, dev?dev->name:"", name);
	fd = open(fname, O_RDONLY);
	if (fd < 0)
		return -1;
	n = read(fd, buf, sizeof(buf));
	close(fd);
	if (n <= 0)
		return -1;
	buf[n] = 0;
	*val = strtoull(buf, &ep, 0);
	if (ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))
		return -1;
	return 0;
}
Commit	Line	Data
e86c9dd6 NB	1	/*
	2	* sysfs - extract md related information from sysfs. Part of:
	3	* mdadm - manage Linux "md" devices aka RAID arrays.
	4	*
	5	* Copyright (C) 2006 Neil Brown <neilb@suse.de>
	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@suse.de>
	24	*/
	25
	26	#include "mdadm.h"
	27	#include <dirent.h>
	28
	29	int load_sys(char path, char buf)
	30	{
	31	int fd = open(path, O_RDONLY);
	32	int n;
	33	if (fd < 0)
	34	return -1;
	35	n = read(fd, buf, 1024);
	36	close(fd);
	37	if (n <=0 \|\| n >= 1024)
	38	return -1;
	39	buf[n] = 0;
	40	if (buf[n-1] == '\n')
	41	buf[n-1] = 0;
	42	return 0;
	43	}
	44
	45	struct sysarray *sysfs_read(int fd, int devnum, unsigned long options)
	46	{
	47	/* Longest possible name in sysfs, mounted at /sys, is
	48	* /sys/block/md_dXXX/md/dev-XXXXX/block/dev
	49	* /sys/block/md_dXXX/md/metadata_version
	50	* which is about 41 characters. 50 should do for now
	51	*/
	52	char fname[50];
	53	char buf[1024];
	54	char *base;
	55	char *dbase;
	56	struct sysarray *sra;
	57	struct sysdev *dev;
	58	DIR *dir;
	59	struct dirent *de;
	60
	61	sra = malloc(sizeof(*sra));
	62	if (sra == NULL)
	63	return sra;
	64
65	if (fd >= 0) {
66	struct stat stb;
67	if (fstat(fd, &stb)) return NULL;
68	if (major(stb.st_rdev)==9)
69	sprintf(sra->name, "md%d", minor(stb.st_rdev));
70	else
71	sprintf(sra->name, "md_d%d",
7fa42a0b	72	minor(stb.st_rdev)>>MdpMinorShift);
e86c9dd6 NB	73	} else {
	74	if (devnum >= 0)
	75	sprintf(sra->name, "md%d", devnum);
	76	else
	77	sprintf(sra->name, "md_d%d",
	78	-1-devnum);
	79	}
	80	sprintf(fname, "/sys/block/%s/md/", sra->name);
	81	base = fname + strlen(fname);
	82
	83	sra->devs = NULL;
	84	if (options & GET_LEVEL) {
	85	strcpy(base, "level");
	86	if (load_sys(fname, buf))
	87	goto abort;
	88	sra->level = map_name(pers, buf);
	89	}
	90	if (options & GET_LAYOUT) {
	91	strcpy(base, "layout");
	92	if (load_sys(fname, buf))
	93	goto abort;
	94	sra->layout = strtoul(buf, NULL, 0);
	95	}
	96	if (options & GET_COMPONENT) {
	97	strcpy(base, "component_size");
	98	if (load_sys(fname, buf))
	99	goto abort;
	100	sra->component_size = strtoull(buf, NULL, 0);
353632d9 NB	101	/* sysfs reports "K", but we want sectors */
353632d9 NB	102	sra->component_size *= 2;
e86c9dd6 NB	103	}
	104	if (options & GET_CHUNK) {
	105	strcpy(base, "chunk_size");
	106	if (load_sys(fname, buf))
	107	goto abort;
	108	sra->chunk = strtoul(buf, NULL, 0);
	109	}
	110
	111	if (! (options & GET_DEVS))
	112	return sra;
	113
	114	/* Get all the devices as well */
	115	*base = 0;
	116	dir = opendir(fname);
	117	if (!dir)
	118	goto abort;
	119	sra->spares = 0;
	120
	121	while ((de = readdir(dir)) != NULL) {
	122	char *ep;
	123	if (de->d_ino == 0 \|\|
	124	strncmp(de->d_name, "dev-", 4) != 0)
	125	continue;
	126	strcpy(base, de->d_name);
	127	dbase = base + strlen(base);
	128	*dbase++ = '/';
	129
	130	dev = malloc(sizeof(*dev));
	131	if (!dev)
	132	goto abort;
	133	dev->next = sra->devs;
	134	sra->devs = dev;
	135
	136	/* Always get slot, major, minor */
	137	strcpy(dbase, "slot");
	138	if (load_sys(fname, buf))
	139	goto abort;
	140	dev->role = strtoul(buf, &ep, 10);
	141	if (*ep) dev->role = -1;
	142
	143	strcpy(dbase, "block/dev");
	144	if (load_sys(fname, buf))
	145	goto abort;
	146	sscanf(buf, "%d:%d", &dev->major, &dev->minor);
	147
	148	if (options & GET_OFFSET) {
	149	strcpy(dbase, "offset");
	150	if (load_sys(fname, buf))
	151	goto abort;
	152	dev->offset = strtoull(buf, NULL, 0);
	153	}
	154	if (options & GET_SIZE) {
	155	strcpy(dbase, "size");
	156	if (load_sys(fname, buf))
	157	goto abort;
	158	dev->size = strtoull(buf, NULL, 0);
	159	}
	160	if (options & GET_STATE) {
	161	dev->state = 0;
	162	strcpy(dbase, "state");
	163	if (load_sys(fname, buf))
	164	goto abort;
	165	if (strstr(buf, "in_sync"))
	166	dev->state \|= (1<<MD_DISK_SYNC);
167	if (strstr(buf, "faulty"))
168	dev->state \|= (1<<MD_DISK_FAULTY);
169	if (dev->state == 0)
170	sra->spares++;
171	}
172	if (options & GET_ERROR) {
173	strcpy(buf, "errors");
174	if (load_sys(fname, buf))
175	goto abort;
176	dev->errors = strtoul(buf, NULL, 0);
177	}
178	}
179	return sra;
180
181	abort:
182	while (sra && sra->devs) {
183	dev = sra->devs;
184	sra->devs = dev->next;
185	free(dev);
186	}
187	if(sra) free(sra);
188	return NULL;
189	}
190
191	unsigned long long get_component_size(int fd)
192	{
193	/* Find out the component size of the array.
194	* We cannot trust GET_ARRAY_INFO ioctl as it's
195	* size field is only 32bits.
196	* So look in /sys/block/mdXXX/md/component_size
353632d9 NB	197	*
353632d9 NB	198	* WARNING: this returns in units of Kilobytes.
e86c9dd6 NB	199	*/
	200	struct stat stb;
	201	char fname[50];
	202	int n;
	203	if (fstat(fd, &stb)) return 0;
	204	if (major(stb.st_rdev) == 9)
	205	sprintf(fname, "/sys/block/md%d/md/component_size",
	206	minor(stb.st_rdev));
	207	else
	208	sprintf(fname, "/sys/block/md_d%d/md/component_size",
7fa42a0b	209	minor(stb.st_rdev)>>MdpMinorShift);
e86c9dd6 NB	210	fd = open(fname, O_RDONLY);
	211	if (fd < 0)
	212	return 0;
	213	n = read(fd, fname, sizeof(fname));
	214	close(fd);
	215	if (n == sizeof(fname))
	216	return 0;
	217	fname[n] = 0;
	218	return strtoull(fname, NULL, 10);
	219	}
	220
	221	int sysfs_set_str(struct sysarray sra, struct sysdev dev,
	222	char name, char val)
	223	{
	224	char fname[50];
	225	int n;
	226	int fd;
	227	sprintf(fname, "/sys/block/%s/md/%s/%s",
	228	sra->name, dev?dev->name:"", name);
	229	fd = open(fname, O_WRONLY);
	230	if (fd < 0)
	231	return -1;
	232	n = write(fd, val, strlen(val));
	233	close(fd);
	234	if (n != strlen(val))
	235	return -1;
	236	return 0;
	237	}
	238
	239	int sysfs_set_num(struct sysarray sra, struct sysdev dev,
	240	char *name, unsigned long long val)
	241	{
	242	char valstr[50];
	243	sprintf(valstr, "%llu", val);
	244	return sysfs_set_str(sra, dev, name, valstr);
	245	}
	246
	247	int sysfs_get_ll(struct sysarray sra, struct sysdev dev,
	248	char name, unsigned long long val)
	249	{
	250	char fname[50];
	251	char buf[50];
	252	int n;
	253	int fd;
	254	char *ep;
	255	sprintf(fname, "/sys/block/%s/md/%s/%s",
	256	sra->name, dev?dev->name:"", name);
	257	fd = open(fname, O_RDONLY);
	258	if (fd < 0)
	259	return -1;
	260	n = read(fd, buf, sizeof(buf));
	261	close(fd);
	262	if (n <= 0)
	263	return -1;
	264	buf[n] = 0;
	265	*val = strtoull(buf, &ep, 0);
	266	if (ep == buf \|\| (ep != 0 && ep != '\n' && *ep != ' '))
	267	return -1;
	268	return 0;
	269	}