[thirdparty/mdadm.git] / util.c

/*
 * mdadm - manage Linux "md" devices aka RAID arrays.
 *
 * Copyright (C) 2001-2002 Neil Brown <neilb@cse.unsw.edu.au>
 *
 *
 *    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
 */

#include	"mdadm.h"
#include	"md_p.h"
#include	<sys/utsname.h>
#include	<ctype.h>

/*
 * Parse a 128 bit uuid in 4 integers
 * format is 32 hexx nibbles with options :.<space> separator
 * If not exactly 32 hex digits are found, return 0
 * else return 1
 */
int parse_uuid(char *str, int uuid[4])
{
    int hit = 0; /* number of Hex digIT */
    int i;
    char c;
    for (i=0; i<4; i++) uuid[i]=0;

    while ((c= *str++)) {
	int n;
	if (c>='0' && c<='9')
	    n = c-'0';
	else if (c>='a' && c <= 'f')
	    n = 10 + c - 'a';
	else if (c>='A' && c <= 'F')
	    n = 10 + c - 'A';
	else if (strchr(":. -", c))
	    continue;
	else return 0;

	if (hit<32) {
	    uuid[hit/8] <<= 4;
	    uuid[hit/8] += n;
	}
	hit++;
    }
    if (hit == 32)
	return 1;
    return 0;
    
}


/*
 * Get the md version number.
 * We use the RAID_VERSION ioctl if it is supported
 * If not, but we have a block device with major '9', we assume
 * 0.36.0
 *
 * Return version number as 24 but number - assume version parts
 * always < 255
 */

int md_get_version(int fd)
{
    struct stat stb;
    mdu_version_t vers;

    if (fstat(fd, &stb)<0)
	return -1;
    if ((S_IFMT&stb.st_mode) != S_IFBLK)
	return -1;

    if (ioctl(fd, RAID_VERSION, &vers) == 0)
	return  (vers.major*10000) + (vers.minor*100) + vers.patchlevel;
    if (errno == EACCES)
	    return -1;
    if (major(stb.st_rdev) == MD_MAJOR)
	return (3600);
    return -1;
}

    
int get_linux_version()
{
	struct utsname name;
	char *cp;
	int a,b,c;
	if (uname(&name) <0)
		return -1;

	cp = name.release;
	a = strtoul(cp, &cp, 10);
	if (*cp != '.') return -1;
	b = strtoul(cp+1, &cp, 10);
	if (*cp != '.') return -1;
	c = strtoul(cp+1, NULL, 10);

	return (a*1000000)+(b*1000)+c;
}

int enough(int level, int raid_disks, int avail_disks)
{
	switch (level) {
	case 10: return 1; /* a lie, but it is hard to tell */

	case -4:
		return avail_disks>= 1;
	case -1:
	case 0:
		return avail_disks == raid_disks;
	case 1:
		return avail_disks >= 1;
	case 4:
	case 5:
		return avail_disks >= raid_disks-1;
	case 6:
		return avail_disks >= raid_disks-2;
	default:
		return 0;
	}
}

int same_uuid(int a[4], int b[4], int swapuuid)
{
	if (swapuuid) {
		/* parse uuids are hostendian.
		 * uuid's from some superblocks are big-ending
		 * if there is a difference, we need to swap.. 
		 */
		unsigned char *ac = (unsigned char *)a;
		unsigned char *bc = (unsigned char *)b;
		int i;
		for (i=0; i<16; i+= 4) {
			if (ac[i+0] != bc[i+3] ||
			    ac[i+1] != bc[i+2] ||
			    ac[i+2] != bc[i+1] ||
			    ac[i+3] != bc[i+0])
				return 0;
		}
		return 1;
	} else {
		if (a[0]==b[0] &&
		    a[1]==b[1] &&
		    a[2]==b[2] &&
		    a[3]==b[3])
			return 1;
		return 0;
	}
}

int check_ext2(int fd, char *name)
{
	/*
	 * Check for an ext2fs file system.
	 * Superblock is always 1K at 1K offset
	 *
	 * s_magic is le16 at 56 == 0xEF53
	 * report mtime - le32 at 44
	 * blocks - le32 at 4
	 * logblksize - le32 at 24
	 */
	unsigned char sb[1024];
	time_t mtime;
	int size, bsize;
	if (lseek(fd, 1024,0)!= 1024)
		return 0;
	if (read(fd, sb, 1024)!= 1024)
		return 0;
	if (sb[56] != 0x53 || sb[57] != 0xef)
		return 0;

	mtime = sb[44]|(sb[45]|(sb[46]|sb[47]<<8)<<8)<<8;
	bsize = sb[24]|(sb[25]|(sb[26]|sb[27]<<8)<<8)<<8;
	size = sb[4]|(sb[5]|(sb[6]|sb[7]<<8)<<8)<<8;
	fprintf(stderr, Name ": %s appears to contain an ext2fs file system\n",
		name);
	fprintf(stderr,"    size=%dK  mtime=%s",
		size*(1<<bsize), ctime(&mtime));
	return 1;
}

int check_reiser(int fd, char *name)
{
	/*
	 * superblock is at 64K
	 * size is 1024;
	 * Magic string "ReIsErFs" or "ReIsEr2Fs" at 52
	 *
	 */
	unsigned char sb[1024];
	int size;
	if (lseek(fd, 64*1024, 0) != 64*1024)
		return 0;
	if (read(fd, sb, 1024) != 1024)
		return 0;
	if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
	    strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
		return 0;
	fprintf(stderr, Name ": %s appears to contain a reiserfs file system\n",name);
	size = sb[0]|(sb[1]|(sb[2]|sb[3]<<8)<<8)<<8;
	fprintf(stderr, "    size = %dK\n", size*4);
		
	return 1;
}

int check_raid(int fd, char *name)
{
	void *super;
	struct mdinfo info;
	struct mddev_ident_s ident;
	time_t crtime;
	struct supertype *st = guess_super(fd);

	if (!st) return 0;
	st->ss->load_super(st, fd, &super, name);
	/* Looks like a raid array .. */
	fprintf(stderr, Name ": %s appears to be part of a raid array:\n",
		name);
	st->ss->getinfo_super(&info, &ident, super);
	free(super);
	crtime = info.array.ctime;
	fprintf(stderr, "    level=%d devices=%d ctime=%s",
		info.array.level, info.array.raid_disks, ctime(&crtime));
	return 1;
}

int ask(char *mesg)
{
	char *add = "";
	int i;
	for (i=0; i<5; i++) {
		char buf[100];
		fprintf(stderr, "%s%s", mesg, add);
		fflush(stderr);
		if (fgets(buf, 100, stdin)==NULL)
			return 0;
		if (buf[0]=='y' || buf[0]=='Y')
			return 1;
		if (buf[0]=='n' || buf[0]=='N')
			return 0;
		add = "(y/n) ";
	}
	fprintf(stderr, Name ": assuming 'no'\n");
	return 0;
}

char *map_num(mapping_t *map, int num)
{
	while (map->name) {
		if (map->num == num)
			return map->name;
		map++;
	}
	return NULL;
}

int map_name(mapping_t *map, char *name)
{
	while (map->name) {
		if (strcmp(map->name, name)==0)
			return map->num;
		map++;
	}
	return UnSet;
}


int is_standard(char *dev, int *nump)
{
	/* tests if dev is a "standard" md dev name.
	 * i.e if the last component is "/dNN" or "/mdNN",
	 * where NN is a string of digits 
	 */
	char *d = strrchr(dev, '/');
	int type=0;
	int num;
	if (!d)
		return 0;
	if (strncmp(d, "/d",2)==0)
		d += 2, type=1; /* /dev/md/dN{pM} */
	else if (strncmp(d, "/md_d", 5)==0)
		d += 5, type=1; /* /dev/md_dNpM */
	else if (strncmp(d, "/md", 3)==0)
		d += 3, type=-1; /* /dev/mdN */
	else if (d-dev > 3 && strncmp(d-2, "md/", 3)==0)
		d += 1, type=-1; /* /dev/md/N */
	else
		return 0;
	if (!*d)
		return 0;
	num = atoi(d);
	while (isdigit(*d))
		d++;
	if (*d)
		return 0;
	if (nump) *nump = num;

	return type;
}


/*
 * convert a major/minor pair for a block device into a name in /dev, if possible.
 * On the first call, walk /dev collecting name.
 * Put them in a simple linked listfor now.
 */
struct devmap {
    int major, minor;
    char *name;
    struct devmap *next;
} *devlist = NULL;
int devlist_ready = 0;

#ifdef UCLIBC
int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
{
}
char *map_dev(int major, int minor)
{
#if 0
	fprintf(stderr, "Warning - fail to map %d,%d to a device name\n",
		major, minor);
#endif
	return NULL;
}
#else

#ifdef __dietlibc__
int add_dev_1(const char *name, const struct stat *stb, int flag)
{
	return add_dev(name, stb, flag, NULL);
}
int nftw(const char *path, int (*han)(const char *name, const struct stat *stb, int flag, struct FTW *s), int nopenfd, int flags)
{
	ftw(path, add_dev_1, nopenfd);
}
#endif

int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
{
    if ((stb->st_mode&S_IFMT)== S_IFBLK) {
	char *n = strdup(name);
	struct devmap *dm = malloc(sizeof(*dm));
	if (dm) {
	    dm->major = major(stb->st_rdev);
	    dm->minor = minor(stb->st_rdev);
	    dm->name = n;
	    dm->next = devlist;
	    devlist = dm;
	}
    }
    return 0;
}

/*
 * Find a block device with the right major/minor number.
 * If we find multiple names, choose the shortest.
 * If we find a non-standard name, it is probably there
 * deliberately so prefer it over a standard name.
 * This applies only to names for MD devices.
 */
char *map_dev(int major, int minor)
{
	struct devmap *p;
	char *std = NULL, *nonstd=NULL;
	if (!devlist_ready) {
		nftw("/dev", add_dev, 10, FTW_PHYS);
		devlist_ready=1;
	}

	for (p=devlist; p; p=p->next)
		if (p->major == major &&
		    p->minor == minor) {
			if (is_standard(p->name, NULL)) {
				if (std == NULL ||
				    strlen(p->name) < strlen(std))
					std = p->name;
			} else {
				if (nonstd == NULL ||
				    strlen(p->name) < strlen(nonstd))
					nonstd = p->name;
			}
		}
	return nonstd ? nonstd : std;
}

#endif

unsigned long calc_csum(void *super, int bytes)
{
	unsigned long long newcsum = 0;
	int i;
	unsigned int csum;
	unsigned int *superc = (unsigned int*) super;

	for(i=0; i<bytes/4; i++)
		newcsum+= superc[i];
	csum = (newcsum& 0xffffffff) + (newcsum>>32);
#ifdef __alpha__
/* The in-kernel checksum calculation is always 16bit on 
 * the alpha, though it is 32 bit on i386...
 * I wonder what it is elsewhere... (it uses and API in
 * a way that it shouldn't).
 */
	csum = (csum & 0xffff) + (csum >> 16);
	csum = (csum & 0xffff) + (csum >> 16);
#endif
	return csum;
}

char *human_size(long long bytes)
{
	static char buf[30];

	/* We convert bytes to either centi-M{ega,ibi}bytes or
	 * centi-G{igi,ibi}bytes, with appropriate rounding,
	 * and then print 1/100th of those as a decimal.
	 * We allow upto 2048Megabytes before converting to
	 * gigabytes, as that shows more precision and isn't
	 * too large a number.
	 * Terrabytes are not yet handled.
	 */

	if (bytes < 5000*1024)
		buf[0]=0;
	else if (bytes < 2*1024LL*1024LL*1024LL) {
		long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2;
		long cMB  = (bytes / ( 1000000LL / 200LL ) +1) /2;
		snprintf(buf, sizeof(buf), " (%ld.%02ld MiB %ld.%02ld MB)",
			cMiB/100 , cMiB % 100,
			cMB/100, cMB % 100);
	} else {
		long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2;
		long cGB  = (bytes / (1000000000LL/200LL ) +1) /2;
		snprintf(buf, sizeof(buf), " (%ld.%02ld GiB %ld.%02ld GB)",
			cGiB/100 , cGiB % 100,
			cGB/100, cGB % 100);
	}
	return buf;
}

char *human_size_brief(long long bytes)
{
	static char buf[30];
	

	if (bytes < 5000*1024)
		snprintf(buf, sizeof(buf), "%ld.%02ldKiB",
			(long)(bytes>>10), (long)(((bytes&1023)*100+512)/1024)
			);
	else if (bytes < 2*1024LL*1024LL*1024LL)
		snprintf(buf, sizeof(buf), "%ld.%02ldMiB",
			(long)(bytes>>20),
			(long)((bytes&0xfffff)+0x100000/200)/(0x100000/100)
			);
	else
		snprintf(buf, sizeof(buf), "%ld.%02ldGiB",
			(long)(bytes>>30),
			(long)(((bytes>>10)&0xfffff)+0x100000/200)/(0x100000/100)
			);
	return buf;
}

int get_mdp_major(void)
{
static int mdp_major = -1;
	FILE *fl;
	char *w;
	int have_block = 0;
	int have_devices = 0;
	int last_num = -1;

	if (mdp_major != -1)
		return mdp_major;
	fl = fopen("/proc/devices", "r");
	if (!fl)
		return -1;
	while ((w = conf_word(fl, 1))) {
		if (have_block && strcmp(w, "devices:")==0)
			have_devices = 1;
		have_block =  (strcmp(w, "Block")==0);
		if (isdigit(w[0]))
			last_num = atoi(w);
		if (have_devices && strcmp(w, "mdp")==0)
			mdp_major = last_num;
		free(w);
	}
	fclose(fl);
	return mdp_major;
}


char *get_md_name(int dev)
{
	/* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
	/* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
	static char devname[50];
	struct stat stb;
	dev_t rdev;
	char *dn;

	if (dev < 0) {
		int mdp =  get_mdp_major();
		if (mdp < 0) return NULL;
		rdev = makedev(mdp, (-1-dev)<<6);
		snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev);
		if (stat(devname, &stb) == 0
		    && (S_IFMT&stb.st_mode) == S_IFBLK
		    && (stb.st_rdev == rdev))
			return devname;
	} else {
		rdev = makedev(MD_MAJOR, dev);
		snprintf(devname, sizeof(devname), "/dev/md%d", dev);
		if (stat(devname, &stb) == 0
		    && (S_IFMT&stb.st_mode) == S_IFBLK
		    && (stb.st_rdev == rdev))
			return devname;

		snprintf(devname, sizeof(devname), "/dev/md/%d", dev);
		if (stat(devname, &stb) == 0
		    && (S_IFMT&stb.st_mode) == S_IFBLK
		    && (stb.st_rdev == rdev))
			return devname;
	}
	dn = map_dev(major(rdev), minor(rdev));
	if (dn)
		return dn;
	snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev);
	if (mknod(devname, S_IFBLK | 0600, rdev) == -1)
		if (errno != EEXIST)
			return NULL;

	if (stat(devname, &stb) == 0
	    && (S_IFMT&stb.st_mode) == S_IFBLK
	    && (stb.st_rdev == rdev))
		return devname;
	unlink(devname);
	return NULL;
}

void put_md_name(char *name)
{
	if (strncmp(name, "/dev/.tmp.md", 12)==0)
		unlink(name);
}


struct superswitch *superlist[] = { &super0, &super1, NULL };

struct supertype *super_by_version(int vers, int minor)
{
	struct supertype *st = malloc(sizeof(*st));
	if (!st) return st;
	if (vers == 0) {
		st->ss = &super0;
		st->max_devs = MD_SB_DISKS;
	}

	if (vers == 1) {
		st->ss = &super1;
		st->max_devs = 384;
	}
	st->minor_version = minor;
	return st;
}

struct supertype *guess_super(int fd)
{
	/* try each load_super to find the best match,
	 * and return the best superswitch
	 */
	struct superswitch  *ss;
	struct supertype *st;
	unsigned long besttime = 0;
	int bestsuper = -1;
	
	void *sbp = NULL;
	int i;

	st = malloc(sizeof(*st));
	memset(st, 0, sizeof(*st));
	for (i=0 ; superlist[i]; i++) {
		int rv;
		ss = superlist[i];
		st->ss = NULL;
		rv = ss->load_super(st, fd, &sbp, NULL);
		if (rv == 0) {
			struct mdinfo info;
			struct mddev_ident_s ident;
			ss->getinfo_super(&info, &ident, sbp);
			if (bestsuper == -1 ||
			    besttime < info.array.ctime) {
				bestsuper = i;
				besttime = info.array.ctime;
			}
			free(sbp);
		}
	}
	if (bestsuper != -1) {
		int rv;
		st->ss = NULL;
		rv = superlist[bestsuper]->load_super(st, fd, &sbp, NULL);
		if (rv == 0) {
			free(sbp);
			return st;
		}
	}
	free(st);
	return NULL;
}

#ifdef __TINYC__
/* tinyc doesn't optimize this check in ioctl.h out ... */
unsigned int __invalid_size_argument_for_IOC = 0;
#endif
Commit	Line	Data
64c4757e	1	/*
9a9dab36	2	* mdadm - manage Linux "md" devices aka RAID arrays.
64c4757e	3	*
cd29a5c8	4	* Copyright (C) 2001-2002 Neil Brown <neilb@cse.unsw.edu.au>
64c4757e NB	5	*
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*
	21	* Author: Neil Brown
	22	* Email: <neilb@cse.unsw.edu.au>
	23	* Paper: Neil Brown
	24	* School of Computer Science and Engineering
	25	* The University of New South Wales
	26	* Sydney, 2052
	27	* Australia
	28	*/
	29
9a9dab36	30	#include "mdadm.h"
64c4757e NB	31	#include "md_p.h"
64c4757e NB	32	#include <sys/utsname.h>
98c6faba	33	#include <ctype.h>
64c4757e NB	34
	35	/*
	36	* Parse a 128 bit uuid in 4 integers
	37	* format is 32 hexx nibbles with options :.<space> separator
	38	* If not exactly 32 hex digits are found, return 0
	39	* else return 1
	40	*/
	41	int parse_uuid(char *str, int uuid[4])
	42	{
	43	int hit = 0; /* number of Hex digIT */
	44	int i;
	45	char c;
	46	for (i=0; i<4; i++) uuid[i]=0;
	47
	48	while ((c= *str++)) {
	49	int n;
	50	if (c>='0' && c<='9')
	51	n = c-'0';
	52	else if (c>='a' && c <= 'f')
	53	n = 10 + c - 'a';
	54	else if (c>='A' && c <= 'F')
	55	n = 10 + c - 'A';
	56	else if (strchr(":. -", c))
	57	continue;
	58	else return 0;
	59
82b27616 NB	60	if (hit<32) {
	61	uuid[hit/8] <<= 4;
	62	uuid[hit/8] += n;
	63	}
64c4757e NB	64	hit++;
	65	}
	66	if (hit == 32)
	67	return 1;
	68	return 0;
	69
	70	}
	71
	72
	73	/*
	74	* Get the md version number.
	75	* We use the RAID_VERSION ioctl if it is supported
	76	* If not, but we have a block device with major '9', we assume
	77	* 0.36.0
	78	*
	79	* Return version number as 24 but number - assume version parts
	80	* always < 255
	81	*/
	82
	83	int md_get_version(int fd)
	84	{
	85	struct stat stb;
	86	mdu_version_t vers;
	87
	88	if (fstat(fd, &stb)<0)
	89	return -1;
	90	if ((S_IFMT&stb.st_mode) != S_IFBLK)
	91	return -1;
	92
	93	if (ioctl(fd, RAID_VERSION, &vers) == 0)
682c7051	94	return (vers.major10000) + (vers.minor100) + vers.patchlevel;
5787fa49 NB	95	if (errno == EACCES)
5787fa49 NB	96	return -1;
0df46c2a	97	if (major(stb.st_rdev) == MD_MAJOR)
682c7051	98	return (3600);
64c4757e NB	99	return -1;
	100	}
	101
	102
	103	int get_linux_version()
	104	{
	105	struct utsname name;
98c6faba	106	char *cp;
64c4757e NB	107	int a,b,c;
	108	if (uname(&name) <0)
	109	return -1;
	110
98c6faba NB	111	cp = name.release;
	112	a = strtoul(cp, &cp, 10);
	113	if (*cp != '.') return -1;
	114	b = strtoul(cp+1, &cp, 10);
	115	if (*cp != '.') return -1;
	116	c = strtoul(cp+1, NULL, 10);
	117
682c7051	118	return (a1000000)+(b1000)+c;
64c4757e NB	119	}
	120
	121	int enough(int level, int raid_disks, int avail_disks)
	122	{
	123	switch (level) {
e5329c37 NB	124	case 10: return 1; /* a lie, but it is hard to tell */
e5329c37 NB	125
e0d19036 NB	126	case -4:
e0d19036 NB	127	return avail_disks>= 1;
64c4757e NB	128	case -1:
	129	case 0:
	130	return avail_disks == raid_disks;
	131	case 1:
	132	return avail_disks >= 1;
	133	case 4:
	134	case 5:
	135	return avail_disks >= raid_disks-1;
98c6faba NB	136	case 6:
98c6faba NB	137	return avail_disks >= raid_disks-2;
64c4757e NB	138	default:
	139	return 0;
	140	}
	141	}
	142
f277ce36	143	int same_uuid(int a[4], int b[4], int swapuuid)
64c4757e	144	{
f277ce36 NB	145	if (swapuuid) {
	146	/* parse uuids are hostendian.
	147	* uuid's from some superblocks are big-ending
	148	* if there is a difference, we need to swap..
	149	*/
	150	unsigned char ac = (unsigned char )a;
	151	unsigned char bc = (unsigned char )b;
	152	int i;
	153	for (i=0; i<16; i+= 4) {
	154	if (ac[i+0] != bc[i+3] \|\|
	155	ac[i+1] != bc[i+2] \|\|
	156	ac[i+2] != bc[i+1] \|\|
	157	ac[i+3] != bc[i+0])
	158	return 0;
	159	}
	160	return 1;
	161	} else {
	162	if (a[0]==b[0] &&
	163	a[1]==b[1] &&
	164	a[2]==b[2] &&
	165	a[3]==b[3])
	166	return 1;
	167	return 0;
	168	}
64c4757e NB	169	}
64c4757e NB	170
682c7051 NB	171	int check_ext2(int fd, char *name)
	172	{
	173	/*
	174	* Check for an ext2fs file system.
	175	* Superblock is always 1K at 1K offset
	176	*
	177	* s_magic is le16 at 56 == 0xEF53
	178	* report mtime - le32 at 44
	179	* blocks - le32 at 4
	180	* logblksize - le32 at 24
	181	*/
	182	unsigned char sb[1024];
	183	time_t mtime;
	184	int size, bsize;
	185	if (lseek(fd, 1024,0)!= 1024)
	186	return 0;
	187	if (read(fd, sb, 1024)!= 1024)
	188	return 0;
	189	if (sb[56] != 0x53 \|\| sb[57] != 0xef)
	190	return 0;
	191
	192	mtime = sb[44]\|(sb[45]\|(sb[46]\|sb[47]<<8)<<8)<<8;
	193	bsize = sb[24]\|(sb[25]\|(sb[26]\|sb[27]<<8)<<8)<<8;
	194	size = sb[4]\|(sb[5]\|(sb[6]\|sb[7]<<8)<<8)<<8;
	195	fprintf(stderr, Name ": %s appears to contain an ext2fs file system\n",
	196	name);
	197	fprintf(stderr," size=%dK mtime=%s",
	198	size*(1<<bsize), ctime(&mtime));
	199	return 1;
	200	}
	201
	202	int check_reiser(int fd, char *name)
	203	{
	204	/*
	205	* superblock is at 64K
	206	* size is 1024;
	207	* Magic string "ReIsErFs" or "ReIsEr2Fs" at 52
	208	*
	209	*/
	210	unsigned char sb[1024];
	211	int size;
	212	if (lseek(fd, 641024, 0) != 641024)
	213	return 0;
	214	if (read(fd, sb, 1024) != 1024)
	215	return 0;
a46f4061 NB	216	if (strncmp((char*)sb+52, "ReIsErFs",8)!=0 &&
a46f4061 NB	217	strncmp((char*)sb+52, "ReIsEr2Fs",9)!=0)
682c7051 NB	218	return 0;
	219	fprintf(stderr, Name ": %s appears to contain a reiserfs file system\n",name);
	220	size = sb[0]\|(sb[1]\|(sb[2]\|sb[3]<<8)<<8)<<8;
	221	fprintf(stderr, " size = %dK\n", size*4);
	222
	223	return 1;
	224	}
	225
	226	int check_raid(int fd, char *name)
	227	{
4b1ac34b NB	228	void *super;
4b1ac34b NB	229	struct mdinfo info;
947fd4dd	230	struct mddev_ident_s ident;
682c7051	231	time_t crtime;
82d9eba6	232	struct supertype *st = guess_super(fd);
f9ce90ba	233
82d9eba6 NB	234	if (!st) return 0;
	235	st->ss->load_super(st, fd, &super, name);
	236	/* Looks like a raid array .. */
	237	fprintf(stderr, Name ": %s appears to be part of a raid array:\n",
	238	name);
947fd4dd	239	st->ss->getinfo_super(&info, &ident, super);
82d9eba6 NB	240	free(super);
	241	crtime = info.array.ctime;
	242	fprintf(stderr, " level=%d devices=%d ctime=%s",
	243	info.array.level, info.array.raid_disks, ctime(&crtime));
	244	return 1;
682c7051 NB	245	}
682c7051 NB	246
682c7051 NB	247	int ask(char *mesg)
	248	{
	249	char *add = "";
	250	int i;
	251	for (i=0; i<5; i++) {
	252	char buf[100];
	253	fprintf(stderr, "%s%s", mesg, add);
	254	fflush(stderr);
	255	if (fgets(buf, 100, stdin)==NULL)
	256	return 0;
	257	if (buf[0]=='y' \|\| buf[0]=='Y')
	258	return 1;
	259	if (buf[0]=='n' \|\| buf[0]=='N')
	260	return 0;
	261	add = "(y/n) ";
	262	}
	263	fprintf(stderr, Name ": assuming 'no'\n");
	264	return 0;
	265	}
	266
	267	char map_num(mapping_t map, int num)
	268	{
	269	while (map->name) {
	270	if (map->num == num)
	271	return map->name;
	272	map++;
	273	}
	274	return NULL;
	275	}
	276
	277	int map_name(mapping_t map, char name)
	278	{
	279	while (map->name) {
	280	if (strcmp(map->name, name)==0)
	281	return map->num;
	282	map++;
	283	}
98c6faba	284	return UnSet;
682c7051	285	}
82b27616	286
e5329c37	287
8d80900b	288	int is_standard(char dev, int nump)
e5329c37 NB	289	{
	290	/* tests if dev is a "standard" md dev name.
	291	* i.e if the last component is "/dNN" or "/mdNN",
	292	* where NN is a string of digits
	293	*/
8d80900b NB	294	char *d = strrchr(dev, '/');
	295	int type=0;
	296	int num;
	297	if (!d)
e5329c37	298	return 0;
8d80900b NB	299	if (strncmp(d, "/d",2)==0)
	300	d += 2, type=1; /* /dev/md/dN{pM} */
	301	else if (strncmp(d, "/md_d", 5)==0)
	302	d += 5, type=1; /* /dev/md_dNpM */
	303	else if (strncmp(d, "/md", 3)==0)
	304	d += 3, type=-1; /* /dev/mdN */
	305	else if (d-dev > 3 && strncmp(d-2, "md/", 3)==0)
5a6d1148	306	d += 1, type=-1; /* /dev/md/N */
e5329c37 NB	307	else
e5329c37 NB	308	return 0;
8d80900b	309	if (!*d)
e5329c37	310	return 0;
8d80900b NB	311	num = atoi(d);
	312	while (isdigit(*d))
	313	d++;
	314	if (*d)
e5329c37	315	return 0;
8d80900b NB	316	if (nump) *nump = num;
	317
	318	return type;
e5329c37 NB	319	}
	320
	321
82b27616 NB	322	/*
	323	* convert a major/minor pair for a block device into a name in /dev, if possible.
	324	* On the first call, walk /dev collecting name.
	325	* Put them in a simple linked listfor now.
	326	*/
	327	struct devmap {
	328	int major, minor;
	329	char *name;
	330	struct devmap *next;
	331	} *devlist = NULL;
	332	int devlist_ready = 0;
	333
5787fa49	334	#ifdef UCLIBC
173fc515 NB	335	int add_dev(const char name, const struct stat stb, int flag, struct FTW *s)
	336	{
	337	}
5787fa49 NB	338	char *map_dev(int major, int minor)
	339	{
	340	#if 0
	341	fprintf(stderr, "Warning - fail to map %d,%d to a device name\n",
	342	major, minor);
	343	#endif
	344	return NULL;
	345	}
	346	#else
82b27616	347
173fc515 NB	348	#ifdef __dietlibc__
	349	int add_dev_1(const char name, const struct stat stb, int flag)
	350	{
	351	return add_dev(name, stb, flag, NULL);
	352	}
	353	int nftw(const char path, int (han)(const char name, const struct stat stb, int flag, struct FTW *s), int nopenfd, int flags)
	354	{
	355	ftw(path, add_dev_1, nopenfd);
	356	}
	357	#endif
82b27616 NB	358
	359	int add_dev(const char name, const struct stat stb, int flag, struct FTW *s)
	360	{
	361	if ((stb->st_mode&S_IFMT)== S_IFBLK) {
	362	char *n = strdup(name);
	363	struct devmap dm = malloc(sizeof(dm));
	364	if (dm) {
0df46c2a NB	365	dm->major = major(stb->st_rdev);
0df46c2a NB	366	dm->minor = minor(stb->st_rdev);
82b27616 NB	367	dm->name = n;
	368	dm->next = devlist;
	369	devlist = dm;
	370	}
	371	}
	372	return 0;
	373	}
	374
dd0781e5 NB	375	/*
dd0781e5 NB	376	* Find a block device with the right major/minor number.
b79713f8 NB	377	* If we find multiple names, choose the shortest.
	378	* If we find a non-standard name, it is probably there
	379	* deliberately so prefer it over a standard name.
	380	* This applies only to names for MD devices.
dd0781e5	381	*/
82b27616 NB	382	char *map_dev(int major, int minor)
82b27616 NB	383	{
dd0781e5	384	struct devmap *p;
b79713f8	385	char std = NULL, nonstd=NULL;
dd0781e5	386	if (!devlist_ready) {
dd0781e5	387	nftw("/dev", add_dev, 10, FTW_PHYS);
dd0781e5 NB	388	devlist_ready=1;
dd0781e5 NB	389	}
82b27616	390
dd0781e5 NB	391	for (p=devlist; p; p=p->next)
	392	if (p->major == major &&
	393	p->minor == minor) {
b79713f8 NB	394	if (is_standard(p->name, NULL)) {
	395	if (std == NULL \|\|
	396	strlen(p->name) < strlen(std))
	397	std = p->name;
	398	} else {
	399	if (nonstd == NULL \|\|
	400	strlen(p->name) < strlen(nonstd))
	401	nonstd = p->name;
	402	}
dd0781e5	403	}
b79713f8	404	return nonstd ? nonstd : std;
82b27616 NB	405	}
82b27616 NB	406
5787fa49	407	#endif
82b27616	408
4b1ac34b	409	unsigned long calc_csum(void *super, int bytes)
82b27616	410	{
56eb10c0	411	unsigned long long newcsum = 0;
82b27616	412	int i;
4b1ac34b NB	413	unsigned int csum;
4b1ac34b NB	414	unsigned int superc = (unsigned int) super;
82b27616	415
4b1ac34b	416	for(i=0; i<bytes/4; i++)
82b27616 NB	417	newcsum+= superc[i];
82b27616 NB	418	csum = (newcsum& 0xffffffff) + (newcsum>>32);
570c0542 NB	419	#ifdef __alpha__
	420	/* The in-kernel checksum calculation is always 16bit on
	421	* the alpha, though it is 32 bit on i386...
	422	* I wonder what it is elsewhere... (it uses and API in
	423	* a way that it shouldn't).
	424	*/
	425	csum = (csum & 0xffff) + (csum >> 16);
	426	csum = (csum & 0xffff) + (csum >> 16);
	427	#endif
82b27616 NB	428	return csum;
82b27616 NB	429	}
cd29a5c8	430
56eb10c0	431	char *human_size(long long bytes)
cd29a5c8 NB	432	{
cd29a5c8 NB	433	static char buf[30];
d5d3721e NB	434
	435	/* We convert bytes to either centi-M{ega,ibi}bytes or
	436	* centi-G{igi,ibi}bytes, with appropriate rounding,
	437	* and then print 1/100th of those as a decimal.
	438	* We allow upto 2048Megabytes before converting to
	439	* gigabytes, as that shows more precision and isn't
	440	* too large a number.
	441	* Terrabytes are not yet handled.
	442	*/
cd29a5c8	443
56eb10c0	444	if (bytes < 5000*1024)
cd29a5c8	445	buf[0]=0;
d5d3721e NB	446	else if (bytes < 21024LL1024LL*1024LL) {
	447	long cMiB = (bytes / ( (1LL<<20) / 200LL ) +1) /2;
	448	long cMB = (bytes / ( 1000000LL / 200LL ) +1) /2;
8f23b0b3	449	snprintf(buf, sizeof(buf), " (%ld.%02ld MiB %ld.%02ld MB)",
d5d3721e NB	450	cMiB/100 , cMiB % 100,
	451	cMB/100, cMB % 100);
	452	} else {
	453	long cGiB = (bytes / ( (1LL<<30) / 200LL ) +1) /2;
	454	long cGB = (bytes / (1000000000LL/200LL ) +1) /2;
8f23b0b3	455	snprintf(buf, sizeof(buf), " (%ld.%02ld GiB %ld.%02ld GB)",
d5d3721e NB	456	cGiB/100 , cGiB % 100,
	457	cGB/100, cGB % 100);
	458	}
cd29a5c8 NB	459	return buf;
cd29a5c8 NB	460	}
e0d19036 NB	461
	462	char *human_size_brief(long long bytes)
	463	{
	464	static char buf[30];
	465
	466
	467	if (bytes < 5000*1024)
8f23b0b3	468	snprintf(buf, sizeof(buf), "%ld.%02ldKiB",
bd526cee	469	(long)(bytes>>10), (long)(((bytes&1023)*100+512)/1024)
e0d19036 NB	470	);
e0d19036 NB	471	else if (bytes < 21024LL1024LL*1024LL)
8f23b0b3	472	snprintf(buf, sizeof(buf), "%ld.%02ldMiB",
e0d19036	473	(long)(bytes>>20),
bd526cee	474	(long)((bytes&0xfffff)+0x100000/200)/(0x100000/100)
e0d19036 NB	475	);
e0d19036 NB	476	else
8f23b0b3	477	snprintf(buf, sizeof(buf), "%ld.%02ldGiB",
e0d19036	478	(long)(bytes>>30),
bd526cee	479	(long)(((bytes>>10)&0xfffff)+0x100000/200)/(0x100000/100)
e0d19036 NB	480	);
	481	return buf;
	482	}
	483
dd0781e5	484	int get_mdp_major(void)
98c6faba	485	{
dd0781e5 NB	486	static int mdp_major = -1;
dd0781e5 NB	487	FILE *fl;
98c6faba NB	488	char *w;
	489	int have_block = 0;
	490	int have_devices = 0;
	491	int last_num = -1;
dd0781e5 NB	492
	493	if (mdp_major != -1)
	494	return mdp_major;
	495	fl = fopen("/proc/devices", "r");
98c6faba	496	if (!fl)
dd0781e5	497	return -1;
98c6faba NB	498	while ((w = conf_word(fl, 1))) {
	499	if (have_block && strcmp(w, "devices:")==0)
	500	have_devices = 1;
	501	have_block = (strcmp(w, "Block")==0);
	502	if (isdigit(w[0]))
	503	last_num = atoi(w);
	504	if (have_devices && strcmp(w, "mdp")==0)
	505	mdp_major = last_num;
	506	free(w);
	507	}
	508	fclose(fl);
dd0781e5	509	return mdp_major;
98c6faba NB	510	}
	511
	512
e0d19036	513
e0d19036 NB	514	char *get_md_name(int dev)
	515	{
	516	/* find /dev/md%d or /dev/md/%d or make a device /dev/.tmp.md%d */
98c6faba	517	/* if dev < 0, want /dev/md/d%d or find mdp in /proc/devices ... */
e0d19036 NB	518	static char devname[50];
e0d19036 NB	519	struct stat stb;
98c6faba	520	dev_t rdev;
dd0781e5	521	char *dn;
98c6faba NB	522
98c6faba NB	523	if (dev < 0) {
dd0781e5 NB	524	int mdp = get_mdp_major();
dd0781e5 NB	525	if (mdp < 0) return NULL;
0df46c2a	526	rdev = makedev(mdp, (-1-dev)<<6);
8f23b0b3	527	snprintf(devname, sizeof(devname), "/dev/md/d%d", -1-dev);
98c6faba NB	528	if (stat(devname, &stb) == 0
	529	&& (S_IFMT&stb.st_mode) == S_IFBLK
	530	&& (stb.st_rdev == rdev))
	531	return devname;
	532	} else {
0df46c2a	533	rdev = makedev(MD_MAJOR, dev);
8f23b0b3	534	snprintf(devname, sizeof(devname), "/dev/md%d", dev);
98c6faba NB	535	if (stat(devname, &stb) == 0
	536	&& (S_IFMT&stb.st_mode) == S_IFBLK
	537	&& (stb.st_rdev == rdev))
	538	return devname;
	539
8f23b0b3	540	snprintf(devname, sizeof(devname), "/dev/md/%d", dev);
98c6faba NB	541	if (stat(devname, &stb) == 0
	542	&& (S_IFMT&stb.st_mode) == S_IFBLK
	543	&& (stb.st_rdev == rdev))
	544	return devname;
	545	}
8d80900b	546	dn = map_dev(major(rdev), minor(rdev));
dd0781e5 NB	547	if (dn)
dd0781e5 NB	548	return dn;
8f23b0b3	549	snprintf(devname, sizeof(devname), "/dev/.tmp.md%d", dev);
e0d19036	550	if (mknod(devname, S_IFBLK \| 0600, rdev) == -1)
dd0781e5 NB	551	if (errno != EEXIST)
dd0781e5 NB	552	return NULL;
e0d19036 NB	553
	554	if (stat(devname, &stb) == 0
	555	&& (S_IFMT&stb.st_mode) == S_IFBLK
	556	&& (stb.st_rdev == rdev))
	557	return devname;
	558	unlink(devname);
	559	return NULL;
	560	}
	561
	562	void put_md_name(char *name)
	563	{
	564	if (strncmp(name, "/dev/.tmp.md", 12)==0)
	565	unlink(name);
	566	}
f9ce90ba NB	567
	568
	569
82d9eba6	570	struct superswitch *superlist[] = { &super0, &super1, NULL };
f9ce90ba	571
82d9eba6	572	struct supertype *super_by_version(int vers, int minor)
f9ce90ba	573	{
82d9eba6 NB	574	struct supertype st = malloc(sizeof(st));
82d9eba6 NB	575	if (!st) return st;
6fbba4c9	576	if (vers == 0) {
82d9eba6	577	st->ss = &super0;
6fbba4c9 NB	578	st->max_devs = MD_SB_DISKS;
6fbba4c9 NB	579	}
82d9eba6	580
6fbba4c9	581	if (vers == 1) {
82d9eba6	582	st->ss = &super1;
6fbba4c9 NB	583	st->max_devs = 384;
6fbba4c9 NB	584	}
82d9eba6 NB	585	st->minor_version = minor;
82d9eba6 NB	586	return st;
f9ce90ba NB	587	}
f9ce90ba NB	588
82d9eba6	589	struct supertype *guess_super(int fd)
f9ce90ba NB	590	{
	591	/* try each load_super to find the best match,
	592	* and return the best superswitch
	593	*/
82d9eba6 NB	594	struct superswitch *ss;
82d9eba6 NB	595	struct supertype *st;
570c0542 NB	596	unsigned long besttime = 0;
570c0542 NB	597	int bestsuper = -1;
82d9eba6	598
f9ce90ba NB	599	void *sbp = NULL;
	600	int i;
	601
82d9eba6 NB	602	st = malloc(sizeof(*st));
82d9eba6 NB	603	memset(st, 0, sizeof(*st));
f9ce90ba NB	604	for (i=0 ; superlist[i]; i++) {
	605	int rv;
	606	ss = superlist[i];
f277ce36	607	st->ss = NULL;
82d9eba6	608	rv = ss->load_super(st, fd, &sbp, NULL);
570c0542 NB	609	if (rv == 0) {
570c0542 NB	610	struct mdinfo info;
947fd4dd NB	611	struct mddev_ident_s ident;
947fd4dd NB	612	ss->getinfo_super(&info, &ident, sbp);
570c0542 NB	613	if (bestsuper == -1 \|\|
	614	besttime < info.array.ctime) {
	615	bestsuper = i;
	616	besttime = info.array.ctime;
570c0542 NB	617	}
	618	free(sbp);
	619	}
	620	}
	621	if (bestsuper != -1) {
	622	int rv;
f277ce36	623	st->ss = NULL;
570c0542	624	rv = superlist[bestsuper]->load_super(st, fd, &sbp, NULL);
f9ce90ba NB	625	if (rv == 0) {
f9ce90ba NB	626	free(sbp);
82d9eba6	627	return st;
f9ce90ba NB	628	}
f9ce90ba NB	629	}
570c0542	630	free(st);
f9ce90ba NB	631	return NULL;
f9ce90ba NB	632	}
fe6729fa NB	633
	634	#ifdef __TINYC__
	635	/* tinyc doesn't optimize this check in ioctl.h out ... */
	636	unsigned int __invalid_size_argument_for_IOC = 0;
	637	#endif
	638