[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>
#include	<ctype.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;
	char *mdname = devnum2devname(devnum);

	if (!mdname)
		return -1;

	sprintf(fname, "/sys/block/%s/md/", mdname);
	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);
	free(mdname);
	return fd;
}

void sysfs_init(struct mdinfo *mdi, int fd, int devnum)
{
	mdi->sys_name[0] = 0;
	if (fd >= 0) {
		mdu_version_t vers;
		if (ioctl(fd, RAID_VERSION, &vers) != 0)
			return;
		devnum = fd2devnum(fd);
	}
	if (devnum == NoMdDev)
		return;
	if (devnum >= 0)
		sprintf(mdi->sys_name, "md%d", devnum);
	else
		sprintf(mdi->sys_name, "md_d%d",
			-1-devnum);
}


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;
	memset(sra, 0, sizeof(*sra));
	sysfs_init(sra, fd, devnum);
	if (sra->sys_name[0] == 0) {
		free(sra);
		return NULL;
	}

	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_SAFEMODE) {
		int scale = 1;
		int dot = 0;
		int i;
		unsigned long msec;
		size_t len;

		strcpy(base, "safe_mode_delay");
		if (load_sys(fname, buf))
			goto abort;

		/* remove a period, and count digits after it */
		len = strlen(buf);
		for (i = 0; i < len; i++) {
			if (dot) {
				if (isdigit(buf[i])) {
					buf[i-1] = buf[i];
					scale *= 10;
				}
				buf[i] = 0;
			} else if (buf[i] == '.') {
				dot=1;
				buf[i] = 0;
			}
		}
		msec = strtoul(buf, NULL, 10);
		msec = (msec * 1000) / scale;
		sra->safe_mode_delay = msec;
	}

	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;

		/* Always get slot, major, minor */
		strcpy(dbase, "slot");
		if (load_sys(fname, buf)) {
			/* hmm... unable to read 'slot' maybe the device
			 * is going away?
			 */
			strcpy(dbase, "block");
			if (readlink(fname, buf, sizeof(buf)) < 0 &&
			    errno != ENAMETOOLONG) {
				/* ...yup device is gone */
				free(dev);
				continue;
			} else {
				/* slot is unreadable but 'block' link
				 * still intact... something bad is happening
				 * so abort
				 */
				free(dev);
				goto abort;
			}
			
		}
		strcpy(dev->sys_name, de->d_name);
		dev->disk.raid_disk = strtoul(buf, &ep, 10);
		if (*ep) dev->disk.raid_disk = -1;

		strcpy(dbase, "block/dev");
		if (load_sys(fname, buf)) {
			free(dev);
			if (options & SKIP_GONE_DEVS)
				continue;
			else
				goto abort;
		}
		sscanf(buf, "%d:%d", &dev->disk.major, &dev->disk.minor);

		/* special case check for block devices that can go 'offline' */
		if (options & SKIP_GONE_DEVS) {
			strcpy(dbase, "block/device/state");
			if (load_sys(fname, buf) == 0 &&
			    strncmp(buf, "offline", 7) == 0) {
				free(dev);
				continue;
			}
		}

		/* finally add this disk to the array */
		dev->next = sra->devs;
		sra->devs = dev;

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

int sysfs_attr_match(const char *attr, const char *str)
{
	/* See if attr, read from a sysfs file, matches
	 * str.  They must either be the same, or attr can
	 * have a trailing newline or comma
	 */
	while (*attr && *str && *attr == *str) {
		attr++;
		str++;
	}

	if (*str || (*attr && *attr != ',' && *attr != '\n'))
		return 0;
	return 1;
}

int sysfs_match_word(const char *word, char **list)
{
	int n;
	for (n=0; list[n]; n++)
		if (sysfs_attr_match(word, list[n]))
			break;
	return n;
}

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) != get_mdp_major())
		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)) {
		dprintf(Name ": failed to write '%s' to '%s' (%s)\n",
			val, fname, strerror(errno));
		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_uevent(struct mdinfo *sra, char *event)
{
	char fname[50];
	int n;
	int fd;

	sprintf(fname, "/sys/block/%s/uevent",
		sra->sys_name);
	fd = open(fname, O_WRONLY);
	if (fd < 0)
		return -1;
	n = write(fd, event, strlen(event));
	close(fd);
	return 0;
}	

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 % 1000;

	sprintf(delay, "%ld.%03ld\n", sec, msec);
	/*             this '\n' ^ needed for kernels older than 2.6.28 */
	return sysfs_set_str(sra, NULL, "safe_mode_delay", delay);
}

int sysfs_set_array(struct mdinfo *info, int vers)
{
	int rv = 0;
	char ver[100];

	ver[0] = 0;
	if (info->array.major_version == -1 &&
	    info->array.minor_version == -2) {
		strcat(strcpy(ver, "external:"), info->text_version);

		if ((vers % 100) < 2 ||
		    sysfs_set_str(info, NULL, "metadata_version",
				  ver) < 0) {
			fprintf(stderr, Name ": This kernel does not "
				"support external metadata.\n");
			return 1;
		}
	}
	if (info->array.level < 0)
		return 0; /* FIXME */
	rv |= sysfs_set_str(info, NULL, "level",
			    map_num(pers, info->array.level));
	rv |= sysfs_set_num(info, NULL, "raid_disks", info->array.raid_disks);
	rv |= sysfs_set_num(info, NULL, "chunk_size", info->array.chunk_size);
	rv |= sysfs_set_num(info, NULL, "layout", info->array.layout);
	rv |= sysfs_set_num(info, NULL, "component_size", info->component_size/2);
	if (info->custom_array_size) {
		int rc;

		rc = sysfs_set_num(info, NULL, "array_size",
				   info->custom_array_size/2);
		if (rc && errno == ENOENT) {
			fprintf(stderr, Name ": This kernel does not "
				"have the md/array_size attribute, "
				"the array may be larger than expected\n");
			rc = 0;
		}
		rv |= rc;
	}

	if (info->array.level > 0)
		rv |= sysfs_set_num(info, NULL, "resync_start", info->resync_start);
	return rv;
}

int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd)
{
	char dv[100];
	char nm[100];
	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");
	}
	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>
1770662b	28	#include <ctype.h>
e86c9dd6 NB	29
	30	int load_sys(char path, char buf)
	31	{
	32	int fd = open(path, O_RDONLY);
	33	int n;
	34	if (fd < 0)
	35	return -1;
	36	n = read(fd, buf, 1024);
	37	close(fd);
2f6079dc	38	if (n <0 \|\| n >= 1024)
e86c9dd6 NB	39	return -1;
e86c9dd6 NB	40	buf[n] = 0;
8dfb8619	41	if (n && buf[n-1] == '\n')
e86c9dd6 NB	42	buf[n-1] = 0;
	43	return 0;
	44	}
	45
7e0f6979	46	void sysfs_free(struct mdinfo *sra)
8382f19b	47	{
7e0f6979 NB	48	while (sra) {
	49	struct mdinfo *sra2 = sra->next;
	50	while (sra->devs) {
	51	struct mdinfo *d = sra->devs;
	52	sra->devs = d->next;
	53	free(d);
	54	}
	55	free(sra);
	56	sra = sra2;
8382f19b	57	}
8382f19b NB	58	}
8382f19b NB	59
549e9569 NB	60	int sysfs_open(int devnum, char devname, char attr)
	61	{
	62	char fname[50];
549e9569	63	int fd;
1e4bc070	64	char *mdname = devnum2devname(devnum);
549e9569	65
1e4bc070 DW	66	if (!mdname)
	67	return -1;
	68
	69	sprintf(fname, "/sys/block/%s/md/", mdname);
549e9569 NB	70	if (devname) {
	71	strcat(fname, devname);
	72	strcat(fname, "/");
	73	}
	74	strcat(fname, attr);
	75	fd = open(fname, O_RDWR);
ea6d09b0	76	if (fd < 0 && errno == EACCES)
549e9569	77	fd = open(fname, O_RDONLY);
1e4bc070	78	free(mdname);
549e9569 NB	79	return fd;
	80	}
	81
f35f2525 N	82	void sysfs_init(struct mdinfo *mdi, int fd, int devnum)
f35f2525 N	83	{
678a4a36	84	mdi->sys_name[0] = 0;
f35f2525	85	if (fd >= 0) {
f35f2525	86	mdu_version_t vers;
f35f2525 N	87	if (ioctl(fd, RAID_VERSION, &vers) != 0)
f35f2525 N	88	return;
d7ab966b	89	devnum = fd2devnum(fd);
f35f2525	90	}
d7ab966b N	91	if (devnum == NoMdDev)
	92	return;
	93	if (devnum >= 0)
	94	sprintf(mdi->sys_name, "md%d", devnum);
	95	else
	96	sprintf(mdi->sys_name, "md_d%d",
	97	-1-devnum);
f35f2525 N	98	}
f35f2525 N	99
d7ab966b	100
7e0f6979	101	struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options)
e86c9dd6 NB	102	{
	103	/* Longest possible name in sysfs, mounted at /sys, is
	104	* /sys/block/md_dXXX/md/dev-XXXXX/block/dev
	105	* /sys/block/md_dXXX/md/metadata_version
	106	* which is about 41 characters. 50 should do for now
	107	*/
	108	char fname[50];
	109	char buf[1024];
	110	char *base;
	111	char *dbase;
7e0f6979	112	struct mdinfo *sra;
06c7f68e	113	struct mdinfo *dev;
355726fa	114	DIR *dir = NULL;
e86c9dd6 NB	115	struct dirent *de;
	116
	117	sra = malloc(sizeof(*sra));
	118	if (sra == NULL)
	119	return sra;
f35f2525 N	120	memset(sra, 0, sizeof(*sra));
f35f2525 N	121	sysfs_init(sra, fd, devnum);
678a4a36 N	122	if (sra->sys_name[0] == 0) {
	123	free(sra);
	124	return NULL;
	125	}
e86c9dd6	126
7e0f6979	127	sprintf(fname, "/sys/block/%s/md/", sra->sys_name);
e86c9dd6 NB	128	base = fname + strlen(fname);
	129
	130	sra->devs = NULL;
8382f19b NB	131	if (options & GET_VERSION) {
	132	strcpy(base, "metadata_version");
	133	if (load_sys(fname, buf))
	134	goto abort;
294d6f45	135	if (strncmp(buf, "none", 4) == 0) {
7e0f6979 NB	136	sra->array.major_version =
7e0f6979 NB	137	sra->array.minor_version = -1;
294d6f45 NB	138	strcpy(sra->text_version, "");
294d6f45 NB	139	} else if (strncmp(buf, "external:", 9) == 0) {
142cb9e1 NB	140	sra->array.major_version = -1;
	141	sra->array.minor_version = -2;
	142	strcpy(sra->text_version, buf+9);
b8ac1967	143	} else {
8382f19b	144	sscanf(buf, "%d.%d",
7e0f6979 NB	145	&sra->array.major_version,
7e0f6979 NB	146	&sra->array.minor_version);
b8ac1967 NB	147	strcpy(sra->text_version, buf);
b8ac1967 NB	148	}
8382f19b	149	}
e86c9dd6 NB	150	if (options & GET_LEVEL) {
	151	strcpy(base, "level");
	152	if (load_sys(fname, buf))
	153	goto abort;
7e0f6979	154	sra->array.level = map_name(pers, buf);
e86c9dd6 NB	155	}
	156	if (options & GET_LAYOUT) {
	157	strcpy(base, "layout");
	158	if (load_sys(fname, buf))
	159	goto abort;
7e0f6979	160	sra->array.layout = strtoul(buf, NULL, 0);
e86c9dd6	161	}
549e9569 NB	162	if (options & GET_DISKS) {
	163	strcpy(base, "raid_disks");
	164	if (load_sys(fname, buf))
	165	goto abort;
	166	sra->array.raid_disks = strtoul(buf, NULL, 0);
f1d26766 DW	167	}
	168	if (options & GET_DEGRADED) {
	169	strcpy(base, "degraded");
	170	if (load_sys(fname, buf))
	171	goto abort;
	172	sra->array.failed_disks = strtoul(buf, NULL, 0);
549e9569	173	}
e86c9dd6 NB	174	if (options & GET_COMPONENT) {
	175	strcpy(base, "component_size");
	176	if (load_sys(fname, buf))
	177	goto abort;
	178	sra->component_size = strtoull(buf, NULL, 0);
353632d9 NB	179	/* sysfs reports "K", but we want sectors */
353632d9 NB	180	sra->component_size *= 2;
e86c9dd6 NB	181	}
	182	if (options & GET_CHUNK) {
	183	strcpy(base, "chunk_size");
	184	if (load_sys(fname, buf))
	185	goto abort;
7e0f6979	186	sra->array.chunk_size = strtoul(buf, NULL, 0);
e86c9dd6	187	}
758d3a8e NB	188	if (options & GET_CACHE) {
	189	strcpy(base, "stripe_cache_size");
	190	if (load_sys(fname, buf))
	191	goto abort;
	192	sra->cache_size = strtoul(buf, NULL, 0);
	193	}
37dfc3d6 NB	194	if (options & GET_MISMATCH) {
	195	strcpy(base, "mismatch_cnt");
	196	if (load_sys(fname, buf))
	197	goto abort;
	198	sra->mismatch_cnt = strtoul(buf, NULL, 0);
	199	}
1770662b DW	200	if (options & GET_SAFEMODE) {
	201	int scale = 1;
	202	int dot = 0;
	203	int i;
	204	unsigned long msec;
	205	size_t len;
	206
	207	strcpy(base, "safe_mode_delay");
	208	if (load_sys(fname, buf))
	209	goto abort;
	210
	211	/* remove a period, and count digits after it */
	212	len = strlen(buf);
	213	for (i = 0; i < len; i++) {
	214	if (dot) {
	215	if (isdigit(buf[i])) {
	216	buf[i-1] = buf[i];
	217	scale *= 10;
	218	}
	219	buf[i] = 0;
	220	} else if (buf[i] == '.') {
	221	dot=1;
	222	buf[i] = 0;
	223	}
	224	}
	225	msec = strtoul(buf, NULL, 10);
	226	msec = (msec * 1000) / scale;
	227	sra->safe_mode_delay = msec;
	228	}
e86c9dd6 NB	229
	230	if (! (options & GET_DEVS))
	231	return sra;
	232
	233	/* Get all the devices as well */
	234	*base = 0;
	235	dir = opendir(fname);
	236	if (!dir)
	237	goto abort;
7e0f6979	238	sra->array.spare_disks = 0;
e86c9dd6 NB	239
	240	while ((de = readdir(dir)) != NULL) {
	241	char *ep;
	242	if (de->d_ino == 0 \|\|
	243	strncmp(de->d_name, "dev-", 4) != 0)
	244	continue;
	245	strcpy(base, de->d_name);
	246	dbase = base + strlen(base);
	247	*dbase++ = '/';
	248
	249	dev = malloc(sizeof(*dev));
	250	if (!dev)
	251	goto abort;
e86c9dd6 NB	252
	253	/* Always get slot, major, minor */
	254	strcpy(dbase, "slot");
4795982e DW	255	if (load_sys(fname, buf)) {
	256	/* hmm... unable to read 'slot' maybe the device
	257	* is going away?
	258	*/
	259	strcpy(dbase, "block");
	260	if (readlink(fname, buf, sizeof(buf)) < 0 &&
	261	errno != ENAMETOOLONG) {
	262	/* ...yup device is gone */
	263	free(dev);
	264	continue;
	265	} else {
	266	/* slot is unreadable but 'block' link
	267	* still intact... something bad is happening
	268	* so abort
	269	*/
	270	free(dev);
	271	goto abort;
	272	}
	273
	274	}
4795982e	275	strcpy(dev->sys_name, de->d_name);
06c7f68e NB	276	dev->disk.raid_disk = strtoul(buf, &ep, 10);
06c7f68e NB	277	if (*ep) dev->disk.raid_disk = -1;
e86c9dd6 NB	278
e86c9dd6 NB	279	strcpy(dbase, "block/dev");
dab4a513 DW	280	if (load_sys(fname, buf)) {
	281	free(dev);
	282	if (options & SKIP_GONE_DEVS)
	283	continue;
	284	else
	285	goto abort;
	286	}
06c7f68e	287	sscanf(buf, "%d:%d", &dev->disk.major, &dev->disk.minor);
e86c9dd6	288
dab4a513 DW	289	/* special case check for block devices that can go 'offline' */
	290	if (options & SKIP_GONE_DEVS) {
	291	strcpy(dbase, "block/device/state");
	292	if (load_sys(fname, buf) == 0 &&
	293	strncmp(buf, "offline", 7) == 0) {
	294	free(dev);
	295	continue;
	296	}
	297	}
	298
	299	/* finally add this disk to the array */
	300	dev->next = sra->devs;
	301	sra->devs = dev;
	302
e86c9dd6 NB	303	if (options & GET_OFFSET) {
	304	strcpy(dbase, "offset");
	305	if (load_sys(fname, buf))
	306	goto abort;
06c7f68e	307	dev->data_offset = strtoull(buf, NULL, 0);
e86c9dd6 NB	308	}
	309	if (options & GET_SIZE) {
	310	strcpy(dbase, "size");
	311	if (load_sys(fname, buf))
	312	goto abort;
047d2e49	313	dev->component_size = strtoull(buf, NULL, 0) * 2;
e86c9dd6 NB	314	}
e86c9dd6 NB	315	if (options & GET_STATE) {
06c7f68e	316	dev->disk.state = 0;
e86c9dd6 NB	317	strcpy(dbase, "state");
	318	if (load_sys(fname, buf))
	319	goto abort;
	320	if (strstr(buf, "in_sync"))
06c7f68e	321	dev->disk.state \|= (1<<MD_DISK_SYNC);
e86c9dd6	322	if (strstr(buf, "faulty"))
06c7f68e NB	323	dev->disk.state \|= (1<<MD_DISK_FAULTY);
06c7f68e NB	324	if (dev->disk.state == 0)
7e0f6979	325	sra->array.spare_disks++;
e86c9dd6 NB	326	}
	327	if (options & GET_ERROR) {
	328	strcpy(buf, "errors");
	329	if (load_sys(fname, buf))
	330	goto abort;
	331	dev->errors = strtoul(buf, NULL, 0);
	332	}
	333	}
355726fa	334	closedir(dir);
e86c9dd6 NB	335	return sra;
	336
	337	abort:
355726fa NB	338	if (dir)
355726fa NB	339	closedir(dir);
8382f19b	340	sysfs_free(sra);
e86c9dd6 NB	341	return NULL;
	342	}
	343
1770662b DW	344	int sysfs_attr_match(const char attr, const char str)
	345	{
	346	/* See if attr, read from a sysfs file, matches
	347	* str. They must either be the same, or attr can
	348	* have a trailing newline or comma
	349	*/
	350	while (attr && str && attr == str) {
	351	attr++;
	352	str++;
	353	}
	354
	355	if (str \|\| (attr && attr != ',' && attr != '\n'))
	356	return 0;
	357	return 1;
	358	}
	359
	360	int sysfs_match_word(const char word, char *list)
	361	{
	362	int n;
	363	for (n=0; list[n]; n++)
	364	if (sysfs_attr_match(word, list[n]))
	365	break;
	366	return n;
	367	}
	368
e86c9dd6 NB	369	unsigned long long get_component_size(int fd)
	370	{
	371	/* Find out the component size of the array.
	372	* We cannot trust GET_ARRAY_INFO ioctl as it's
	373	* size field is only 32bits.
	374	* So look in /sys/block/mdXXX/md/component_size
353632d9	375	*
8686f3ed	376	* This returns in units of sectors.
e86c9dd6 NB	377	*/
	378	struct stat stb;
	379	char fname[50];
	380	int n;
	381	if (fstat(fd, &stb)) return 0;
4ebd3237	382	if (major(stb.st_rdev) != get_mdp_major())
e86c9dd6	383	sprintf(fname, "/sys/block/md%d/md/component_size",
ea24acd0	384	(int)minor(stb.st_rdev));
e86c9dd6 NB	385	else
e86c9dd6 NB	386	sprintf(fname, "/sys/block/md_d%d/md/component_size",
ea24acd0	387	(int)minor(stb.st_rdev)>>MdpMinorShift);
e86c9dd6 NB	388	fd = open(fname, O_RDONLY);
	389	if (fd < 0)
	390	return 0;
	391	n = read(fd, fname, sizeof(fname));
	392	close(fd);
	393	if (n == sizeof(fname))
	394	return 0;
	395	fname[n] = 0;
8686f3ed	396	return strtoull(fname, NULL, 10) * 2;
e86c9dd6 NB	397	}
e86c9dd6 NB	398
7e0f6979	399	int sysfs_set_str(struct mdinfo sra, struct mdinfo dev,
e86c9dd6 NB	400	char name, char val)
	401	{
	402	char fname[50];
	403	int n;
	404	int fd;
7e1432fb	405
e86c9dd6	406	sprintf(fname, "/sys/block/%s/md/%s/%s",
7e0f6979	407	sra->sys_name, dev?dev->sys_name:"", name);
e86c9dd6 NB	408	fd = open(fname, O_WRONLY);
	409	if (fd < 0)
	410	return -1;
	411	n = write(fd, val, strlen(val));
	412	close(fd);
2a24d7b6 DW	413	if (n != strlen(val)) {
	414	dprintf(Name ": failed to write '%s' to '%s' (%s)\n",
	415	val, fname, strerror(errno));
e86c9dd6	416	return -1;
2a24d7b6	417	}
e86c9dd6 NB	418	return 0;
	419	}
	420
7e0f6979	421	int sysfs_set_num(struct mdinfo sra, struct mdinfo dev,
e86c9dd6 NB	422	char *name, unsigned long long val)
	423	{
	424	char valstr[50];
	425	sprintf(valstr, "%llu", val);
	426	return sysfs_set_str(sra, dev, name, valstr);
	427	}
	428
97590376 N	429	int sysfs_uevent(struct mdinfo sra, char event)
	430	{
	431	char fname[50];
	432	int n;
	433	int fd;
	434
	435	sprintf(fname, "/sys/block/%s/uevent",
	436	sra->sys_name);
	437	fd = open(fname, O_WRONLY);
	438	if (fd < 0)
	439	return -1;
	440	n = write(fd, event, strlen(event));
	441	close(fd);
	442	return 0;
	443	}
	444
7e0f6979	445	int sysfs_get_ll(struct mdinfo sra, struct mdinfo dev,
e86c9dd6 NB	446	char name, unsigned long long val)
	447	{
	448	char fname[50];
	449	char buf[50];
	450	int n;
	451	int fd;
	452	char *ep;
	453	sprintf(fname, "/sys/block/%s/md/%s/%s",
7e0f6979	454	sra->sys_name, dev?dev->sys_name:"", name);
e86c9dd6 NB	455	fd = open(fname, O_RDONLY);
	456	if (fd < 0)
	457	return -1;
	458	n = read(fd, buf, sizeof(buf));
	459	close(fd);
	460	if (n <= 0)
	461	return -1;
	462	buf[n] = 0;
	463	*val = strtoull(buf, &ep, 0);
	464	if (ep == buf \|\| (ep != 0 && ep != '\n' && *ep != ' '))
	465	return -1;
	466	return 0;
	467	}
2503d23b	468
8ed3e5e1 DW	469	int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms)
	470	{
	471	unsigned long sec;
	472	unsigned long msec;
	473	char delay[30];
	474
	475	sec = ms / 1000;
0dd3ba30	476	msec = ms % 1000;
8ed3e5e1	477
0dd3ba30 DW	478	sprintf(delay, "%ld.%03ld\n", sec, msec);
0dd3ba30 DW	479	/* this '\n' ^ needed for kernels older than 2.6.28 */
8ed3e5e1 DW	480	return sysfs_set_str(sra, NULL, "safe_mode_delay", delay);
	481	}
	482
f35f2525	483	int sysfs_set_array(struct mdinfo *info, int vers)
2503d23b NB	484	{
2503d23b NB	485	int rv = 0;
f35f2525 N	486	char ver[100];
	487
	488	ver[0] = 0;
	489	if (info->array.major_version == -1 &&
	490	info->array.minor_version == -2) {
	491	strcat(strcpy(ver, "external:"), info->text_version);
	492
	493	if ((vers % 100) < 2 \|\|
	494	sysfs_set_str(info, NULL, "metadata_version",
	495	ver) < 0) {
	496	fprintf(stderr, Name ": This kernel does not "
	497	"support external metadata.\n");
	498	return 1;
	499	}
	500	}
2503d23b NB	501	if (info->array.level < 0)
2503d23b NB	502	return 0; /* FIXME */
f35f2525	503	rv \|= sysfs_set_str(info, NULL, "level",
2503d23b	504	map_num(pers, info->array.level));
f35f2525 N	505	rv \|= sysfs_set_num(info, NULL, "raid_disks", info->array.raid_disks);
	506	rv \|= sysfs_set_num(info, NULL, "chunk_size", info->array.chunk_size);
	507	rv \|= sysfs_set_num(info, NULL, "layout", info->array.layout);
	508	rv \|= sysfs_set_num(info, NULL, "component_size", info->component_size/2);
da9b4a62 DW	509	if (info->custom_array_size) {
	510	int rc;
	511
	512	rc = sysfs_set_num(info, NULL, "array_size",
	513	info->custom_array_size/2);
	514	if (rc && errno == ENOENT) {
	515	fprintf(stderr, Name ": This kernel does not "
	516	"have the md/array_size attribute, "
	517	"the array may be larger than expected\n");
	518	rc = 0;
	519	}
	520	rv \|= rc;
	521	}
	522
f35f2525 N	523	if (info->array.level > 0)
f35f2525 N	524	rv \|= sysfs_set_num(info, NULL, "resync_start", info->resync_start);
2503d23b NB	525	return rv;
	526	}
	527
2318b9f0	528	int sysfs_add_disk(struct mdinfo sra, struct mdinfo sd)
2503d23b NB	529	{
	530	char dv[100];
	531	char nm[100];
2503d23b NB	532	char *dname;
	533	int rv;
	534
	535	sprintf(dv, "%d:%d", sd->disk.major, sd->disk.minor);
	536	rv = sysfs_set_str(sra, NULL, "new_dev", dv);
	537	if (rv)
	538	return rv;
	539
	540	memset(nm, 0, sizeof(nm));
	541	sprintf(dv, "/sys/dev/block/%d:%d", sd->disk.major, sd->disk.minor);
73649188 N	542	rv = readlink(dv, nm, sizeof(nm));
73649188 N	543	if (rv <= 0)
2503d23b	544	return -1;
73649188	545	nm[rv] = '\0';
2503d23b NB	546	dname = strrchr(nm, '/');
	547	if (dname) dname++;
	548	strcpy(sd->sys_name, "dev-");
	549	strcpy(sd->sys_name+4, dname);
	550
73649188	551	rv = sysfs_set_num(sra, sd, "offset", sd->data_offset);
2503d23b NB	552	rv \|= sysfs_set_num(sra, sd, "size", (sd->component_size+1) / 2);
	553	if (sra->array.level != LEVEL_CONTAINER) {
	554	rv \|= sysfs_set_num(sra, sd, "slot", sd->disk.raid_disk);
	555	// rv \|= sysfs_set_str(sra, sd, "state", "in_sync");
	556	}
2503d23b NB	557	return rv;
2503d23b NB	558	}
90c8b707	559
755c99fa	560	#if 0
90c8b707 DW	561	int sysfs_disk_to_sg(int fd)
	562	{
	563	/* from an open block device, try find and open its corresponding
	564	* scsi_generic interface
	565	*/
	566	struct stat st;
	567	char path[256];
	568	char sg_path[256];
	569	char sg_major_minor[8];
	570	char *c;
	571	DIR *dir;
	572	struct dirent *de;
	573	int major, minor, rv;
	574
	575	if (fstat(fd, &st))
	576	return -1;
	577
	578	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
	579	major(st.st_rdev), minor(st.st_rdev));
	580
	581	dir = opendir(path);
	582	if (!dir)
	583	return -1;
	584
	585	de = readdir(dir);
	586	while (de) {
	587	if (strncmp("scsi_generic:", de->d_name,
	588	strlen("scsi_generic:")) == 0)
	589	break;
	590	de = readdir(dir);
	591	}
	592	closedir(dir);
	593
	594	if (!de)
	595	return -1;
	596
	597	snprintf(sg_path, sizeof(sg_path), "%s/%s/dev", path, de->d_name);
	598	fd = open(sg_path, O_RDONLY);
	599	if (fd < 0)
	600	return fd;
	601
	602	rv = read(fd, sg_major_minor, sizeof(sg_major_minor));
	603	close(fd);
	604	if (rv < 0)
	605	return -1;
	606	else
	607	sg_major_minor[rv - 1] = '\0';
	608
	609	c = strchr(sg_major_minor, ':');
	610	*c = '\0';
	611	c++;
	612	major = strtol(sg_major_minor, NULL, 10);
	613	minor = strtol(c, NULL, 10);
	614	snprintf(path, sizeof(path), "/dev/.tmp.md.%d:%d:%d",
	615	(int) getpid(), major, minor);
	616	if (mknod(path, S_IFCHR\|0600, makedev(major, minor))==0) {
	617	fd = open(path, O_RDONLY);
	618	unlink(path);
	619	return fd;
	620	}
	621
	622	return -1;
	623	}
755c99fa	624	#endif
90c8b707	625
f1665f72 DW	626	int sysfs_disk_to_scsi_id(int fd, __u32 *id)
	627	{
	628	/* from an open block device, try to retrieve it scsi_id */
	629	struct stat st;
	630	char path[256];
	631	char c1, c2;
	632	DIR *dir;
	633	struct dirent *de;
	634
	635	if (fstat(fd, &st))
	636	return 1;
	637
	638	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
	639	major(st.st_rdev), minor(st.st_rdev));
	640
	641	dir = opendir(path);
	642	if (!dir)
	643	return 1;
	644
	645	de = readdir(dir);
	646	while (de) {
	647	if (strncmp("scsi_disk:", de->d_name,
	648	strlen("scsi_disk:")) == 0)
	649	break;
	650	de = readdir(dir);
	651	}
	652	closedir(dir);
	653
	654	if (!de)
	655	return 1;
	656
	657	c1 = strchr(de->d_name, ':');
	658	c1++;
	659	c2 = strchr(c1, ':');
	660	*c2 = '\0';
	661	id = strtol(c1, NULL, 10) << 24; / host */
	662	c1 = c2 + 1;
	663	c2 = strchr(c1, ':');
	664	*c2 = '\0';
	665	id \|= strtol(c1, NULL, 10) << 16; / channel */
	666	c1 = c2 + 1;
	667	c2 = strchr(c1, ':');
	668	*c2 = '\0';
	669	id \|= strtol(c1, NULL, 10) << 8; / lun */
	670	c1 = c2 + 1;
	671	id \|= strtol(c1, NULL, 10); / id */
	672
	673	return 0;
	674	}
f94d52f4 NB	675
	676
	677	int sysfs_unique_holder(int devnum, long rdev)
	678	{
	679	/* Check that devnum is a holder of rdev,
	680	* and is the only holder.
	681	* we should be locked against races by
	682	* an O_EXCL on devnum
	683	*/
	684	DIR *dir;
	685	struct dirent *de;
	686	char dirname[100];
	687	char l;
	688	int found = 0;
	689	sprintf(dirname, "/sys/dev/block/%d:%d/holders",
	690	major(rdev), minor(rdev));
	691	dir = opendir(dirname);
	692	errno = ENOENT;
	693	if (!dir)
	694	return 0;
	695	l = strlen(dirname);
	696	while ((de = readdir(dir)) != NULL) {
	697	char buf[10];
	698	int n;
	699	int mj, mn;
	700	char c;
	701	int fd;
	702
	703	if (de->d_ino == 0)
	704	continue;
	705	if (de->d_name[0] == '.')
	706	continue;
	707	strcpy(dirname+l, "/");
	708	strcat(dirname+l, de->d_name);
	709	strcat(dirname+l, "/dev");
	710	fd = open(dirname, O_RDONLY);
	711	if (fd < 0) {
	712	errno = ENOENT;
	713	break;
	714	}
	715	n = read(fd, buf, sizeof(buf)-1);
	716	close(fd);
	717	buf[n] = 0;
	718	if (sscanf(buf, "%d:%d%c", &mj, &mn, &c) != 3 \|\|
	719	c != '\n') {
	720	errno = ENOENT;
	721	break;
	722	}
	723	if (mj != MD_MAJOR)
	724	mn = -1-(mn>>6);
	725
	726	if (devnum != mn) {
	727	errno = EEXIST;
	728	break;
	729	}
	730	found = 1;
	731	}
	732	closedir(dir);
	733	if (de)
	734	return 0;
	735	else
	736	return found;
	737	}