[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 (n && buf[n-1] == '\n')
		buf[n-1] = 0;
	return 0;
}

void sysfs_free(struct mdinfo *sra)
{
	while (sra) {
		struct mdinfo *sra2 = sra->next;
		while (sra->devs) {
			struct mdinfo *d = sra->devs;
			sra->devs = d->next;
			free(d);
		}
		free(sra);
		sra = sra2;
	}
}

int sysfs_open(int devnum, char *devname, char *attr)
{
	char fname[50];
	int fd;

	sprintf(fname, "/sys/block/%s/md/", devnum2devname(devnum));
	if (devname) {
		strcat(fname, devname);
		strcat(fname, "/");
	}
	strcat(fname, attr);
	fd = open(fname, O_RDWR);
	if (fd < 0 && errno == EACCES)
		fd = open(fname, O_RDONLY);
	return fd;
}

struct mdinfo *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 mdinfo *sra;
	struct mdinfo *dev;
	DIR *dir = NULL;
	struct dirent *de;

	sra = malloc(sizeof(*sra));
	if (sra == NULL)
		return sra;
	sra->next = NULL;

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

	sra->devs = NULL;
	if (options & GET_VERSION) {
		strcpy(base, "metadata_version");
		if (load_sys(fname, buf))
			goto abort;
		if (strncmp(buf, "none", 4) == 0) {
			sra->array.major_version =
				sra->array.minor_version = -1;
			strcpy(sra->text_version, "");
		} else if (strncmp(buf, "external:", 9) == 0) {
			sra->array.major_version = -1;
			sra->array.minor_version = -2;
			strcpy(sra->text_version, buf+9);
		} else {
			sscanf(buf, "%d.%d",
			       &sra->array.major_version,
			       &sra->array.minor_version);
			strcpy(sra->text_version, buf);
		}
	}
	if (options & GET_LEVEL) {
		strcpy(base, "level");
		if (load_sys(fname, buf))
			goto abort;
		sra->array.level = map_name(pers, buf);
	}
	if (options & GET_LAYOUT) {
		strcpy(base, "layout");
		if (load_sys(fname, buf))
			goto abort;
		sra->array.layout = strtoul(buf, NULL, 0);
	}
	if (options & GET_DISKS) {
		strcpy(base, "raid_disks");
		if (load_sys(fname, buf))
			goto abort;
		sra->array.raid_disks = strtoul(buf, NULL, 0);
	}
	if (options & GET_DEGRADED) {
		strcpy(base, "degraded");
		if (load_sys(fname, buf))
			goto abort;
		sra->array.failed_disks = 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->array.chunk_size = strtoul(buf, NULL, 0);
	}
	if (options & GET_CACHE) {
		strcpy(base, "stripe_cache_size");
		if (load_sys(fname, buf))
			goto abort;
		sra->cache_size = strtoul(buf, NULL, 0);
	}
	if (options & GET_MISMATCH) {
		strcpy(base, "mismatch_cnt");
		if (load_sys(fname, buf))
			goto abort;
		sra->mismatch_cnt = 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->array.spare_disks = 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;
		strcpy(dev->sys_name, de->d_name);

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

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

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

 abort:
	if (dir)
		closedir(dir);
	sysfs_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
	 *
	 * This returns in units of sectors.
	 */
	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",
			(int)minor(stb.st_rdev));
	else
		sprintf(fname, "/sys/block/md_d%d/md/component_size",
			(int)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) * 2;
}

int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
		  char *name, char *val)
{
	char fname[50];
	int n;
	int fd;

	sprintf(fname, "/sys/block/%s/md/%s/%s",
		sra->sys_name, dev?dev->sys_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 mdinfo *sra, struct mdinfo *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 mdinfo *sra, struct mdinfo *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->sys_name, dev?dev->sys_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;
}

int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms)
{
	unsigned long sec;
	unsigned long msec;
	char delay[30];

	sec = ms / 1000;
	msec = ms - (sec * 1000);

	sprintf(delay, "%ld.%ld", sec, msec);
	return sysfs_set_str(sra, NULL, "safe_mode_delay", delay);
}

int sysfs_set_array(struct mdinfo *sra,
		    struct mdinfo *info)
{
	int rv = 0;
	sra->array = info->array;

	if (info->array.level < 0)
		return 0; /* FIXME */
	rv |= sysfs_set_str(sra, NULL, "level",
			    map_num(pers, info->array.level));
	rv |= sysfs_set_num(sra, NULL, "raid_disks", info->array.raid_disks);
	rv |= sysfs_set_num(sra, NULL, "chunk_size", info->array.chunk_size);
	rv |= sysfs_set_num(sra, NULL, "layout", info->array.layout);
	rv |= sysfs_set_num(sra, NULL, "component_size", info->component_size/2);
	rv |= sysfs_set_num(sra, NULL, "resync_start", info->resync_start);
	sra->array = info->array;
	return rv;
}

int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd)
{
	char dv[100];
	char nm[100];
	struct mdinfo *sd2;
	char *dname;
	int rv;

	sprintf(dv, "%d:%d", sd->disk.major, sd->disk.minor);
	rv = sysfs_set_str(sra, NULL, "new_dev", dv);
	if (rv)
		return rv;

	memset(nm, 0, sizeof(nm));
	sprintf(dv, "/sys/dev/block/%d:%d", sd->disk.major, sd->disk.minor);
	rv = readlink(dv, nm, sizeof(nm));
	if (rv <= 0)
		return -1;
	nm[rv] = '\0';
	dname = strrchr(nm, '/');
	if (dname) dname++;
	strcpy(sd->sys_name, "dev-");
	strcpy(sd->sys_name+4, dname);

	rv = sysfs_set_num(sra, sd, "offset", sd->data_offset);
	rv |= sysfs_set_num(sra, sd, "size", (sd->component_size+1) / 2);
	if (sra->array.level != LEVEL_CONTAINER) {
		rv |= sysfs_set_num(sra, sd, "slot", sd->disk.raid_disk);
//		rv |= sysfs_set_str(sra, sd, "state", "in_sync");
	}
	if (! rv) {
		sd2 = malloc(sizeof(*sd2));
		*sd2 = *sd;
		sd2->next = sra->devs;
		sra->devs = sd2;
	}
	return rv;
}

#if 0
int sysfs_disk_to_sg(int fd)
{
	/* from an open block device, try find and open its corresponding
	 * scsi_generic interface
	 */
	struct stat st;
	char path[256];
	char sg_path[256];
	char sg_major_minor[8];
	char *c;
	DIR *dir;
	struct dirent *de;
	int major, minor, rv;

	if (fstat(fd, &st))
		return -1;

	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
		 major(st.st_rdev), minor(st.st_rdev));

	dir = opendir(path);
	if (!dir)
		return -1;

	de = readdir(dir);
	while (de) {
		if (strncmp("scsi_generic:", de->d_name,
			    strlen("scsi_generic:")) == 0)
			break;
		de = readdir(dir);
	}
	closedir(dir);

	if (!de)
		return -1;

	snprintf(sg_path, sizeof(sg_path), "%s/%s/dev", path, de->d_name);
	fd = open(sg_path, O_RDONLY);
	if (fd < 0)
		return fd;

	rv = read(fd, sg_major_minor, sizeof(sg_major_minor));
	close(fd);
	if (rv < 0)
		return -1;
	else
		sg_major_minor[rv - 1] = '\0';

	c = strchr(sg_major_minor, ':');
	*c = '\0';
	c++;
	major = strtol(sg_major_minor, NULL, 10);
	minor = strtol(c, NULL, 10);
	snprintf(path, sizeof(path), "/dev/.tmp.md.%d:%d:%d",
		 (int) getpid(), major, minor);
	if (mknod(path, S_IFCHR|0600, makedev(major, minor))==0) {
			fd = open(path, O_RDONLY);
			unlink(path);
			return fd;
	}

	return -1;
}
#endif

int sysfs_disk_to_scsi_id(int fd, __u32 *id)
{
	/* from an open block device, try to retrieve it scsi_id */
	struct stat st;
	char path[256];
	char *c1, *c2;
	DIR *dir;
	struct dirent *de;

	if (fstat(fd, &st))
		return 1;

	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
		 major(st.st_rdev), minor(st.st_rdev));

	dir = opendir(path);
	if (!dir)
		return 1;

	de = readdir(dir);
	while (de) {
		if (strncmp("scsi_disk:", de->d_name,
			    strlen("scsi_disk:")) == 0)
			break;
		de = readdir(dir);
	}
	closedir(dir);

	if (!de)
		return 1;

	c1 = strchr(de->d_name, ':');
	c1++;
	c2 = strchr(c1, ':');
	*c2 = '\0';
	*id = strtol(c1, NULL, 10) << 24; /* host */
	c1 = c2 + 1;
	c2 = strchr(c1, ':');
	*c2 = '\0';
	*id |= strtol(c1, NULL, 10) << 16; /* channel */
	c1 = c2 + 1;
	c2 = strchr(c1, ':');
	*c2 = '\0';
	*id |= strtol(c1, NULL, 10) << 8; /* lun */
	c1 = c2 + 1;
	*id |= strtol(c1, NULL, 10); /* id */

	return 0;
}


int sysfs_unique_holder(int devnum, long rdev)
{
	/* Check that devnum is a holder of rdev,
	 * and is the only holder.
	 * we should be locked against races by
	 * an O_EXCL on devnum
	 */
	DIR *dir;
	struct dirent *de;
	char dirname[100];
	char l;
	int found = 0;
	sprintf(dirname, "/sys/dev/block/%d:%d/holders",
		major(rdev), minor(rdev));
	dir = opendir(dirname);
	errno = ENOENT;
	if (!dir)
		return 0;
	l = strlen(dirname);
	while ((de = readdir(dir)) != NULL) {
		char buf[10];
		int n;
		int mj, mn;
		char c;
		int fd;

		if (de->d_ino == 0)
			continue;
		if (de->d_name[0] == '.')
			continue;
		strcpy(dirname+l, "/");
		strcat(dirname+l, de->d_name);
		strcat(dirname+l, "/dev");
		fd = open(dirname, O_RDONLY);
		if (fd < 0) {
			errno = ENOENT;
			break;
		}
		n = read(fd, buf, sizeof(buf)-1);
		close(fd);
		buf[n] = 0;
		if (sscanf(buf, "%d:%d%c", &mj, &mn, &c) != 3 ||
		    c != '\n') {
			errno = ENOENT;
			break;
		}
		if (mj != MD_MAJOR)
			mn = -1-(mn>>6);

		if (devnum != mn) {
			errno = EEXIST;
			break;
		}
		found = 1;
	}
	closedir(dir);
	if (de)
		return 0;
	else
		return found;
}
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);
2f6079dc	37	if (n <0 \|\| n >= 1024)
e86c9dd6 NB	38	return -1;
e86c9dd6 NB	39	buf[n] = 0;
8dfb8619	40	if (n && buf[n-1] == '\n')
e86c9dd6 NB	41	buf[n-1] = 0;
	42	return 0;
	43	}
	44
7e0f6979	45	void sysfs_free(struct mdinfo *sra)
8382f19b	46	{
7e0f6979 NB	47	while (sra) {
	48	struct mdinfo *sra2 = sra->next;
	49	while (sra->devs) {
	50	struct mdinfo *d = sra->devs;
	51	sra->devs = d->next;
	52	free(d);
	53	}
	54	free(sra);
	55	sra = sra2;
8382f19b	56	}
8382f19b NB	57	}
8382f19b NB	58
549e9569 NB	59	int sysfs_open(int devnum, char devname, char attr)
	60	{
	61	char fname[50];
549e9569	62	int fd;
549e9569	63
77472ff8	64	sprintf(fname, "/sys/block/%s/md/", devnum2devname(devnum));
549e9569 NB	65	if (devname) {
	66	strcat(fname, devname);
	67	strcat(fname, "/");
	68	}
	69	strcat(fname, attr);
	70	fd = open(fname, O_RDWR);
ea6d09b0	71	if (fd < 0 && errno == EACCES)
549e9569 NB	72	fd = open(fname, O_RDONLY);
	73	return fd;
	74	}
	75
7e0f6979	76	struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options)
e86c9dd6 NB	77	{
	78	/* Longest possible name in sysfs, mounted at /sys, is
	79	* /sys/block/md_dXXX/md/dev-XXXXX/block/dev
	80	* /sys/block/md_dXXX/md/metadata_version
	81	* which is about 41 characters. 50 should do for now
	82	*/
	83	char fname[50];
	84	char buf[1024];
	85	char *base;
	86	char *dbase;
7e0f6979	87	struct mdinfo *sra;
06c7f68e	88	struct mdinfo *dev;
355726fa	89	DIR *dir = NULL;
e86c9dd6 NB	90	struct dirent *de;
	91
	92	sra = malloc(sizeof(*sra));
	93	if (sra == NULL)
	94	return sra;
7e0f6979	95	sra->next = NULL;
e86c9dd6 NB	96
	97	if (fd >= 0) {
	98	struct stat stb;
2faf1f5f NB	99	mdu_version_t vers;
	100	if (fstat(fd, &stb)) return NULL;
	101	if (ioctl(fd, RAID_VERSION, &vers) != 0)
	102	return NULL;
e86c9dd6	103	if (major(stb.st_rdev)==9)
ea24acd0	104	sprintf(sra->sys_name, "md%d", (int)minor(stb.st_rdev));
e86c9dd6	105	else
7e0f6979	106	sprintf(sra->sys_name, "md_d%d",
ea24acd0	107	(int)minor(stb.st_rdev)>>MdpMinorShift);
e86c9dd6 NB	108	} else {
e86c9dd6 NB	109	if (devnum >= 0)
7e0f6979	110	sprintf(sra->sys_name, "md%d", devnum);
e86c9dd6	111	else
7e0f6979	112	sprintf(sra->sys_name, "md_d%d",
e86c9dd6 NB	113	-1-devnum);
e86c9dd6 NB	114	}
7e0f6979	115	sprintf(fname, "/sys/block/%s/md/", sra->sys_name);
e86c9dd6 NB	116	base = fname + strlen(fname);
	117
	118	sra->devs = NULL;
8382f19b NB	119	if (options & GET_VERSION) {
	120	strcpy(base, "metadata_version");
	121	if (load_sys(fname, buf))
	122	goto abort;
294d6f45	123	if (strncmp(buf, "none", 4) == 0) {
7e0f6979 NB	124	sra->array.major_version =
7e0f6979 NB	125	sra->array.minor_version = -1;
294d6f45 NB	126	strcpy(sra->text_version, "");
294d6f45 NB	127	} else if (strncmp(buf, "external:", 9) == 0) {
142cb9e1 NB	128	sra->array.major_version = -1;
	129	sra->array.minor_version = -2;
	130	strcpy(sra->text_version, buf+9);
b8ac1967	131	} else {
8382f19b	132	sscanf(buf, "%d.%d",
7e0f6979 NB	133	&sra->array.major_version,
7e0f6979 NB	134	&sra->array.minor_version);
b8ac1967 NB	135	strcpy(sra->text_version, buf);
b8ac1967 NB	136	}
8382f19b	137	}
e86c9dd6 NB	138	if (options & GET_LEVEL) {
	139	strcpy(base, "level");
	140	if (load_sys(fname, buf))
	141	goto abort;
7e0f6979	142	sra->array.level = map_name(pers, buf);
e86c9dd6 NB	143	}
	144	if (options & GET_LAYOUT) {
	145	strcpy(base, "layout");
	146	if (load_sys(fname, buf))
	147	goto abort;
7e0f6979	148	sra->array.layout = strtoul(buf, NULL, 0);
e86c9dd6	149	}
549e9569 NB	150	if (options & GET_DISKS) {
	151	strcpy(base, "raid_disks");
	152	if (load_sys(fname, buf))
	153	goto abort;
	154	sra->array.raid_disks = strtoul(buf, NULL, 0);
f1d26766 DW	155	}
	156	if (options & GET_DEGRADED) {
	157	strcpy(base, "degraded");
	158	if (load_sys(fname, buf))
	159	goto abort;
	160	sra->array.failed_disks = strtoul(buf, NULL, 0);
549e9569	161	}
e86c9dd6 NB	162	if (options & GET_COMPONENT) {
	163	strcpy(base, "component_size");
	164	if (load_sys(fname, buf))
	165	goto abort;
	166	sra->component_size = strtoull(buf, NULL, 0);
353632d9 NB	167	/* sysfs reports "K", but we want sectors */
353632d9 NB	168	sra->component_size *= 2;
e86c9dd6 NB	169	}
	170	if (options & GET_CHUNK) {
	171	strcpy(base, "chunk_size");
	172	if (load_sys(fname, buf))
	173	goto abort;
7e0f6979	174	sra->array.chunk_size = strtoul(buf, NULL, 0);
e86c9dd6	175	}
758d3a8e NB	176	if (options & GET_CACHE) {
	177	strcpy(base, "stripe_cache_size");
	178	if (load_sys(fname, buf))
	179	goto abort;
	180	sra->cache_size = strtoul(buf, NULL, 0);
	181	}
37dfc3d6 NB	182	if (options & GET_MISMATCH) {
	183	strcpy(base, "mismatch_cnt");
	184	if (load_sys(fname, buf))
	185	goto abort;
	186	sra->mismatch_cnt = strtoul(buf, NULL, 0);
	187	}
e86c9dd6 NB	188
	189	if (! (options & GET_DEVS))
	190	return sra;
	191
	192	/* Get all the devices as well */
	193	*base = 0;
	194	dir = opendir(fname);
	195	if (!dir)
	196	goto abort;
7e0f6979	197	sra->array.spare_disks = 0;
e86c9dd6 NB	198
	199	while ((de = readdir(dir)) != NULL) {
	200	char *ep;
	201	if (de->d_ino == 0 \|\|
	202	strncmp(de->d_name, "dev-", 4) != 0)
	203	continue;
	204	strcpy(base, de->d_name);
	205	dbase = base + strlen(base);
	206	*dbase++ = '/';
	207
	208	dev = malloc(sizeof(*dev));
	209	if (!dev)
	210	goto abort;
	211	dev->next = sra->devs;
	212	sra->devs = dev;
06c7f68e	213	strcpy(dev->sys_name, de->d_name);
e86c9dd6 NB	214
	215	/* Always get slot, major, minor */
	216	strcpy(dbase, "slot");
	217	if (load_sys(fname, buf))
	218	goto abort;
06c7f68e NB	219	dev->disk.raid_disk = strtoul(buf, &ep, 10);
06c7f68e NB	220	if (*ep) dev->disk.raid_disk = -1;
e86c9dd6 NB	221
	222	strcpy(dbase, "block/dev");
	223	if (load_sys(fname, buf))
	224	goto abort;
06c7f68e	225	sscanf(buf, "%d:%d", &dev->disk.major, &dev->disk.minor);
e86c9dd6 NB	226
	227	if (options & GET_OFFSET) {
	228	strcpy(dbase, "offset");
	229	if (load_sys(fname, buf))
	230	goto abort;
06c7f68e	231	dev->data_offset = strtoull(buf, NULL, 0);
e86c9dd6 NB	232	}
	233	if (options & GET_SIZE) {
	234	strcpy(dbase, "size");
	235	if (load_sys(fname, buf))
	236	goto abort;
047d2e49	237	dev->component_size = strtoull(buf, NULL, 0) * 2;
e86c9dd6 NB	238	}
e86c9dd6 NB	239	if (options & GET_STATE) {
06c7f68e	240	dev->disk.state = 0;
e86c9dd6 NB	241	strcpy(dbase, "state");
	242	if (load_sys(fname, buf))
	243	goto abort;
	244	if (strstr(buf, "in_sync"))
06c7f68e	245	dev->disk.state \|= (1<<MD_DISK_SYNC);
e86c9dd6	246	if (strstr(buf, "faulty"))
06c7f68e NB	247	dev->disk.state \|= (1<<MD_DISK_FAULTY);
06c7f68e NB	248	if (dev->disk.state == 0)
7e0f6979	249	sra->array.spare_disks++;
e86c9dd6 NB	250	}
	251	if (options & GET_ERROR) {
	252	strcpy(buf, "errors");
	253	if (load_sys(fname, buf))
	254	goto abort;
	255	dev->errors = strtoul(buf, NULL, 0);
	256	}
	257	}
355726fa	258	closedir(dir);
e86c9dd6 NB	259	return sra;
	260
	261	abort:
355726fa NB	262	if (dir)
355726fa NB	263	closedir(dir);
8382f19b	264	sysfs_free(sra);
e86c9dd6 NB	265	return NULL;
	266	}
	267
	268	unsigned long long get_component_size(int fd)
	269	{
	270	/* Find out the component size of the array.
	271	* We cannot trust GET_ARRAY_INFO ioctl as it's
	272	* size field is only 32bits.
	273	* So look in /sys/block/mdXXX/md/component_size
353632d9	274	*
8686f3ed	275	* This returns in units of sectors.
e86c9dd6 NB	276	*/
	277	struct stat stb;
	278	char fname[50];
	279	int n;
	280	if (fstat(fd, &stb)) return 0;
	281	if (major(stb.st_rdev) == 9)
	282	sprintf(fname, "/sys/block/md%d/md/component_size",
ea24acd0	283	(int)minor(stb.st_rdev));
e86c9dd6 NB	284	else
e86c9dd6 NB	285	sprintf(fname, "/sys/block/md_d%d/md/component_size",
ea24acd0	286	(int)minor(stb.st_rdev)>>MdpMinorShift);
e86c9dd6 NB	287	fd = open(fname, O_RDONLY);
	288	if (fd < 0)
	289	return 0;
	290	n = read(fd, fname, sizeof(fname));
	291	close(fd);
	292	if (n == sizeof(fname))
	293	return 0;
	294	fname[n] = 0;
8686f3ed	295	return strtoull(fname, NULL, 10) * 2;
e86c9dd6 NB	296	}
e86c9dd6 NB	297
7e0f6979	298	int sysfs_set_str(struct mdinfo sra, struct mdinfo dev,
e86c9dd6 NB	299	char name, char val)
	300	{
	301	char fname[50];
	302	int n;
	303	int fd;
7e1432fb	304
e86c9dd6	305	sprintf(fname, "/sys/block/%s/md/%s/%s",
7e0f6979	306	sra->sys_name, dev?dev->sys_name:"", name);
e86c9dd6 NB	307	fd = open(fname, O_WRONLY);
	308	if (fd < 0)
	309	return -1;
	310	n = write(fd, val, strlen(val));
	311	close(fd);
	312	if (n != strlen(val))
	313	return -1;
	314	return 0;
	315	}
	316
7e0f6979	317	int sysfs_set_num(struct mdinfo sra, struct mdinfo dev,
e86c9dd6 NB	318	char *name, unsigned long long val)
	319	{
	320	char valstr[50];
	321	sprintf(valstr, "%llu", val);
	322	return sysfs_set_str(sra, dev, name, valstr);
	323	}
	324
7e0f6979	325	int sysfs_get_ll(struct mdinfo sra, struct mdinfo dev,
e86c9dd6 NB	326	char name, unsigned long long val)
	327	{
	328	char fname[50];
	329	char buf[50];
	330	int n;
	331	int fd;
	332	char *ep;
	333	sprintf(fname, "/sys/block/%s/md/%s/%s",
7e0f6979	334	sra->sys_name, dev?dev->sys_name:"", name);
e86c9dd6 NB	335	fd = open(fname, O_RDONLY);
	336	if (fd < 0)
	337	return -1;
	338	n = read(fd, buf, sizeof(buf));
	339	close(fd);
	340	if (n <= 0)
	341	return -1;
	342	buf[n] = 0;
	343	*val = strtoull(buf, &ep, 0);
	344	if (ep == buf \|\| (ep != 0 && ep != '\n' && *ep != ' '))
	345	return -1;
	346	return 0;
	347	}
2503d23b	348
8ed3e5e1 DW	349	int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms)
	350	{
	351	unsigned long sec;
	352	unsigned long msec;
	353	char delay[30];
	354
	355	sec = ms / 1000;
	356	msec = ms - (sec * 1000);
	357
	358	sprintf(delay, "%ld.%ld", sec, msec);
	359	return sysfs_set_str(sra, NULL, "safe_mode_delay", delay);
	360	}
	361
2503d23b NB	362	int sysfs_set_array(struct mdinfo *sra,
	363	struct mdinfo *info)
	364	{
	365	int rv = 0;
	366	sra->array = info->array;
2f6079dc	367
2503d23b NB	368	if (info->array.level < 0)
	369	return 0; /* FIXME */
	370	rv \|= sysfs_set_str(sra, NULL, "level",
	371	map_num(pers, info->array.level));
	372	rv \|= sysfs_set_num(sra, NULL, "raid_disks", info->array.raid_disks);
	373	rv \|= sysfs_set_num(sra, NULL, "chunk_size", info->array.chunk_size);
	374	rv \|= sysfs_set_num(sra, NULL, "layout", info->array.layout);
047d2e49	375	rv \|= sysfs_set_num(sra, NULL, "component_size", info->component_size/2);
0fd5c350	376	rv \|= sysfs_set_num(sra, NULL, "resync_start", info->resync_start);
2503d23b NB	377	sra->array = info->array;
	378	return rv;
	379	}
	380
2318b9f0	381	int sysfs_add_disk(struct mdinfo sra, struct mdinfo sd)
2503d23b NB	382	{
	383	char dv[100];
	384	char nm[100];
	385	struct mdinfo *sd2;
	386	char *dname;
	387	int rv;
	388
	389	sprintf(dv, "%d:%d", sd->disk.major, sd->disk.minor);
	390	rv = sysfs_set_str(sra, NULL, "new_dev", dv);
	391	if (rv)
	392	return rv;
	393
	394	memset(nm, 0, sizeof(nm));
	395	sprintf(dv, "/sys/dev/block/%d:%d", sd->disk.major, sd->disk.minor);
73649188 N	396	rv = readlink(dv, nm, sizeof(nm));
73649188 N	397	if (rv <= 0)
2503d23b	398	return -1;
73649188	399	nm[rv] = '\0';
2503d23b NB	400	dname = strrchr(nm, '/');
	401	if (dname) dname++;
	402	strcpy(sd->sys_name, "dev-");
	403	strcpy(sd->sys_name+4, dname);
	404
73649188	405	rv = sysfs_set_num(sra, sd, "offset", sd->data_offset);
2503d23b NB	406	rv \|= sysfs_set_num(sra, sd, "size", (sd->component_size+1) / 2);
	407	if (sra->array.level != LEVEL_CONTAINER) {
	408	rv \|= sysfs_set_num(sra, sd, "slot", sd->disk.raid_disk);
	409	// rv \|= sysfs_set_str(sra, sd, "state", "in_sync");
	410	}
3cb07116 NB	411	if (! rv) {
	412	sd2 = malloc(sizeof(*sd2));
	413	sd2 = sd;
	414	sd2->next = sra->devs;
	415	sra->devs = sd2;
	416	}
2503d23b NB	417	return rv;
2503d23b NB	418	}
90c8b707	419
755c99fa	420	#if 0
90c8b707 DW	421	int sysfs_disk_to_sg(int fd)
	422	{
	423	/* from an open block device, try find and open its corresponding
	424	* scsi_generic interface
	425	*/
	426	struct stat st;
	427	char path[256];
	428	char sg_path[256];
	429	char sg_major_minor[8];
	430	char *c;
	431	DIR *dir;
	432	struct dirent *de;
	433	int major, minor, rv;
	434
	435	if (fstat(fd, &st))
	436	return -1;
	437
	438	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
	439	major(st.st_rdev), minor(st.st_rdev));
	440
	441	dir = opendir(path);
	442	if (!dir)
	443	return -1;
	444
	445	de = readdir(dir);
	446	while (de) {
	447	if (strncmp("scsi_generic:", de->d_name,
	448	strlen("scsi_generic:")) == 0)
	449	break;
	450	de = readdir(dir);
	451	}
	452	closedir(dir);
	453
	454	if (!de)
	455	return -1;
	456
	457	snprintf(sg_path, sizeof(sg_path), "%s/%s/dev", path, de->d_name);
	458	fd = open(sg_path, O_RDONLY);
	459	if (fd < 0)
	460	return fd;
	461
	462	rv = read(fd, sg_major_minor, sizeof(sg_major_minor));
	463	close(fd);
	464	if (rv < 0)
	465	return -1;
	466	else
	467	sg_major_minor[rv - 1] = '\0';
	468
	469	c = strchr(sg_major_minor, ':');
	470	*c = '\0';
	471	c++;
	472	major = strtol(sg_major_minor, NULL, 10);
	473	minor = strtol(c, NULL, 10);
	474	snprintf(path, sizeof(path), "/dev/.tmp.md.%d:%d:%d",
	475	(int) getpid(), major, minor);
	476	if (mknod(path, S_IFCHR\|0600, makedev(major, minor))==0) {
	477	fd = open(path, O_RDONLY);
	478	unlink(path);
	479	return fd;
	480	}
	481
	482	return -1;
	483	}
755c99fa	484	#endif
90c8b707	485
f1665f72 DW	486	int sysfs_disk_to_scsi_id(int fd, __u32 *id)
	487	{
	488	/* from an open block device, try to retrieve it scsi_id */
	489	struct stat st;
	490	char path[256];
	491	char c1, c2;
	492	DIR *dir;
	493	struct dirent *de;
	494
	495	if (fstat(fd, &st))
	496	return 1;
	497
	498	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
	499	major(st.st_rdev), minor(st.st_rdev));
	500
	501	dir = opendir(path);
	502	if (!dir)
	503	return 1;
	504
	505	de = readdir(dir);
	506	while (de) {
	507	if (strncmp("scsi_disk:", de->d_name,
	508	strlen("scsi_disk:")) == 0)
	509	break;
	510	de = readdir(dir);
	511	}
	512	closedir(dir);
	513
	514	if (!de)
	515	return 1;
	516
	517	c1 = strchr(de->d_name, ':');
	518	c1++;
	519	c2 = strchr(c1, ':');
	520	*c2 = '\0';
	521	id = strtol(c1, NULL, 10) << 24; / host */
	522	c1 = c2 + 1;
	523	c2 = strchr(c1, ':');
	524	*c2 = '\0';
	525	id \|= strtol(c1, NULL, 10) << 16; / channel */
	526	c1 = c2 + 1;
	527	c2 = strchr(c1, ':');
	528	*c2 = '\0';
	529	id \|= strtol(c1, NULL, 10) << 8; / lun */
	530	c1 = c2 + 1;
	531	id \|= strtol(c1, NULL, 10); / id */
	532
	533	return 0;
	534	}
f94d52f4 NB	535
	536
	537	int sysfs_unique_holder(int devnum, long rdev)
	538	{
	539	/* Check that devnum is a holder of rdev,
	540	* and is the only holder.
	541	* we should be locked against races by
	542	* an O_EXCL on devnum
	543	*/
	544	DIR *dir;
	545	struct dirent *de;
	546	char dirname[100];
	547	char l;
	548	int found = 0;
	549	sprintf(dirname, "/sys/dev/block/%d:%d/holders",
	550	major(rdev), minor(rdev));
	551	dir = opendir(dirname);
	552	errno = ENOENT;
	553	if (!dir)
	554	return 0;
	555	l = strlen(dirname);
	556	while ((de = readdir(dir)) != NULL) {
	557	char buf[10];
	558	int n;
	559	int mj, mn;
	560	char c;
	561	int fd;
	562
	563	if (de->d_ino == 0)
	564	continue;
	565	if (de->d_name[0] == '.')
	566	continue;
	567	strcpy(dirname+l, "/");
	568	strcat(dirname+l, de->d_name);
	569	strcat(dirname+l, "/dev");
	570	fd = open(dirname, O_RDONLY);
	571	if (fd < 0) {
	572	errno = ENOENT;
	573	break;
	574	}
	575	n = read(fd, buf, sizeof(buf)-1);
	576	close(fd);
	577	buf[n] = 0;
	578	if (sscanf(buf, "%d:%d%c", &mj, &mn, &c) != 3 \|\|
	579	c != '\n') {
	580	errno = ENOENT;
	581	break;
	582	}
	583	if (mj != MD_MAJOR)
	584	mn = -1-(mn>>6);
	585
	586	if (devnum != mn) {
	587	errno = EEXIST;
	588	break;
	589	}
	590	found = 1;
	591	}
	592	closedir(dir);
	593	if (de)
	594	return 0;
	595	else
	596	return found;
	597	}