[thirdparty/mdadm.git] / Create.c

/*
 * mdadm - manage Linux "md" devices aka RAID arrays.
 *
 * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
 *
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Author: Neil Brown
 *    Email: <neilb@cse.unsw.edu.au>
 *    Paper: Neil Brown
 *           School of Computer Science and Engineering
 *           The University of New South Wales
 *           Sydney, 2052
 *           Australia
 */

#include "mdadm.h"
#include	"md_u.h"
#include	"md_p.h"
#include	<ctype.h>

int Create(struct supertype *st, char *mddev, int mdfd,
	   int chunk, int level, int layout, unsigned long long size, int raiddisks, int sparedisks,
	   char *name, char *homehost, int *uuid,
	   int subdevs, mddev_dev_t devlist,
	   int runstop, int verbose, int force, int assume_clean,
	   char *bitmap_file, int bitmap_chunk, int write_behind, int delay)
{
	/*
	 * Create a new raid array.
	 *
	 * First check that necessary details are available
	 * (i.e. level, raid-disks)
	 *
	 * Then check each disk to see what might be on it
	 * and report anything interesting.
	 *
	 * If anything looks odd, and runstop not set,
	 * abort.
	 *
	 * SET_ARRAY_INFO and ADD_NEW_DISK, and
	 * if runstop==run, or raiddisks disks were used,
	 * RUN_ARRAY
	 */
	unsigned long long minsize=0, maxsize=0;
	char *mindisc = NULL;
	char *maxdisc = NULL;
	int dnum;
	mddev_dev_t dv;
	int fail=0, warn=0;
	struct stat stb;
	int first_missing = subdevs * 2;
	int missing_disks = 0;
	int insert_point = subdevs * 2; /* where to insert a missing drive */
	void *super;
	int pass;
	int vers;
	int rv;
	int bitmap_fd;
	unsigned long long bitmapsize;

	mdu_array_info_t array;
	int major_num = BITMAP_MAJOR_HI;

	memset(&array, 0, sizeof(array));

	vers = md_get_version(mdfd);
	if (vers < 9000) {
		fprintf(stderr, Name ": Create requires md driver version 0.90.0 or later\n");
		return 1;
	} else {
		mdu_array_info_t inf;
		memset(&inf, 0, sizeof(inf));
		ioctl(mdfd, GET_ARRAY_INFO, &inf);
		if (inf.working_disks != 0) {
			fprintf(stderr, Name ": another array by this name"
				" is already running.\n");
			return 1;
		}
	}
	if (level == UnSet) {
		fprintf(stderr,
			Name ": a RAID level is needed to create an array.\n");
		return 1;
	}
	if (raiddisks < 4 && level == 6) {
		fprintf(stderr,
			Name ": at least 4 raid-devices needed for level 6\n");
		return 1;
	}
	if (raiddisks > 256 && level == 6) {
		fprintf(stderr,
			Name ": no more than 256 raid-devices supported for level 6\n");
		return 1;
	}
	if (raiddisks < 2 && level >= 4) {
		fprintf(stderr,
			Name ": at least 2 raid-devices needed for level 4 or 5\n");
		return 1;
	}
	if (subdevs > raiddisks+sparedisks) {
		fprintf(stderr, Name ": You have listed more devices (%d) than are in the array(%d)!\n", subdevs, raiddisks+sparedisks);
		return 1;
	}
	if (subdevs < raiddisks+sparedisks) {
		fprintf(stderr, Name ": You haven't given enough devices (real or missing) to create this array\n");
		return 1;
	}
	if (bitmap_file && level <= 0) {
		fprintf(stderr, Name ": bitmaps not meaningful with level %s\n",
			map_num(pers, level)?:"given");
		return 1;
	}

	/* now set some defaults */
	if (layout == UnSet)
		switch(level) {
		default: /* no layout */
			layout = 0;
			break;
		case 10:
			layout = 0x102; /* near=2, far=1 */
			if (verbose > 0)
				fprintf(stderr,
					Name ": layout defaults to n1\n");
			break;
		case 5:
		case 6:
			layout = map_name(r5layout, "default");
			if (verbose > 0)
				fprintf(stderr,
					Name ": layout defaults to %s\n", map_num(r5layout, layout));
			break;
		case LEVEL_FAULTY:
			layout = map_name(faultylayout, "default");

			if (verbose > 0)
				fprintf(stderr,
					Name ": layout defaults to %s\n", map_num(faultylayout, layout));
			break;
		}

	if (level == 10)
		/* check layout fits in array*/
		if ((layout&255) * ((layout>>8)&255) > raiddisks) {
			fprintf(stderr, Name ": that layout requires at least %d devices\n",
				(layout&255) * ((layout>>8)&255));
			return 1;
		}

	switch(level) {
	case 4:
	case 5:
	case 10:
	case 6:
	case 0:
	case -1: /* linear */
		if (chunk == 0) {
			chunk = 64;
			if (verbose > 0)
				fprintf(stderr, Name ": chunk size defaults to 64K\n");
		}
		break;
	default: /* raid1, multipath */
		if (chunk) {
			chunk = 0;
			if (verbose > 0)
				fprintf(stderr, Name ": chunk size ignored for this level\n");
		}
		break;
	}

	/* now look at the subdevs */
	array.active_disks = 0;
	array.working_disks = 0;
	dnum = 0;
	for (dv=devlist; dv; dv=dv->next, dnum++) {
		char *dname = dv->devname;
		unsigned long long ldsize, freesize;
		int fd;
		if (strcasecmp(dname, "missing")==0) {
			if (first_missing > dnum)
				first_missing = dnum;
			missing_disks ++;
			continue;
		}
		array.working_disks++;
		if (dnum < raiddisks)
			array.active_disks++;
		fd = open(dname, O_RDONLY|O_EXCL, 0);
		if (fd <0 ) {
			fprintf(stderr, Name ": Cannot open %s: %s\n",
				dname, strerror(errno));
			fail=1;
			continue;
		}
		if (!get_dev_size(fd, dname, &ldsize)) {
			fail = 1;
			close(fd);
			continue;
		}
		if (st == NULL) {
			struct createinfo *ci = conf_get_create_info();
			if (ci)
				st = ci->supertype;
		}
		if (st == NULL) {
			/* Need to choose a default metadata, which is different
			 * depending on the sizes of devices
			 */
			int i;
			char *name = "default";
			if (level >= 1 && ldsize > (0x7fffffffULL<<10))
				name = "default/large";
			for(i=0; !st && superlist[i]; i++)
				st = superlist[i]->match_metadata_desc(name);

			if (!st) {
				fprintf(stderr, Name ": internal error - no default metadata style\n");
				exit(2);
			}
			if (st->ss->major != 0 ||
			    st->minor_version != 90)
				fprintf(stderr, Name ": Defaulting to version"
					" %d.%d metadata\n",
					st->ss->major,
					st->minor_version);
		}
		freesize = st->ss->avail_size(st, ldsize >> 9);
		if (freesize == 0) {
			fprintf(stderr, Name ": %s is too small: %luK\n",
				dname, (unsigned long)(ldsize>>10));
			fail = 1;
			close(fd);
			continue;
		}

		freesize /= 2; /* convert to K */
		if (chunk) {
			/* round to chunk size */
			freesize = freesize & ~(chunk-1);
		}

		if (size && freesize < size) {
			fprintf(stderr, Name ": %s is smaller that given size."
				" %lluK < %lluK + superblock\n", dname, freesize, size);
			fail = 1;
			close(fd);
			continue;
		}
		if (maxdisc == NULL || (maxdisc && freesize > maxsize)) {
			maxdisc = dname;
			maxsize = freesize;
		}
		if (mindisc ==NULL || (mindisc && freesize < minsize)) {
			mindisc = dname;
			minsize = freesize;
		}
		if (runstop != 1 || verbose >= 0) {
			warn |= check_ext2(fd, dname);
			warn |= check_reiser(fd, dname);
			warn |= check_raid(fd, dname);
		}
		close(fd);
	}
	if (fail) {
		fprintf(stderr, Name ": create aborted\n");
		return 1;
	}
	if (size == 0) {
		if (mindisc == NULL) {
			fprintf(stderr, Name ": no size and no drives given - aborting create.\n");
			return 1;
		}
		if (level > 0 || level == LEVEL_MULTIPATH || level == LEVEL_FAULTY) {
			/* size is meaningful */
			if (minsize > 0x100000000ULL && st->ss->major == 0) {
				fprintf(stderr, Name ": devices too large for RAID level %d\n", level);	
				return 1;
			}
			size = minsize;
			if (verbose > 0)
				fprintf(stderr, Name ": size set to %lluK\n", size);
		}
	}
	if (level > 0 && ((maxsize-size)*100 > maxsize)) {
		if (runstop != 1 || verbose >= 0)
			fprintf(stderr, Name ": largest drive (%s) exceed size (%lluK) by more than 1%%\n",
				maxdisc, size);
		warn = 1;
	}

	if (warn) {
		if (runstop!= 1) {
			if (!ask("Continue creating array? ")) {
				fprintf(stderr, Name ": create aborted.\n");
				return 1;
			}
		} else {
			if (verbose > 0)
				fprintf(stderr, Name ": creation continuing despite oddities due to --run\n");
		}
	}

	/* If this is raid4/5, we want to configure the last active slot
	 * as missing, so that a reconstruct happens (faster than re-parity)
	 * FIX: Can we do this for raid6 as well?
	 */
	if (assume_clean==0 && force == 0 && first_missing >= raiddisks) {
		switch ( level ) {
		case 4:
		case 5:
			insert_point = raiddisks-1;
			sparedisks++;
			array.active_disks--;
			missing_disks++;
			break;
		default:
			break;
		}
	}
	
	/* Ok, lets try some ioctls */

	array.level = level;
	array.size = size;
	array.raid_disks = raiddisks;
	/* The kernel should *know* what md_minor we are dealing
	 * with, but it chooses to trust me instead. Sigh
	 */
	array.md_minor = 0;
	if (fstat(mdfd, &stb)==0)
		array.md_minor = minor(stb.st_rdev);
	array.not_persistent = 0;
	/*** FIX: Need to do something about RAID-6 here ***/
	if ( ( (level == 4 || level == 5) &&
	       (insert_point < raiddisks || first_missing < raiddisks) )
	     ||
	     ( level == 6 && missing_disks == 2)
	     ||
	     assume_clean
		)
		array.state = 1; /* clean, but one+ drive will be missing */
	else
		array.state = 0; /* not clean, but no errors */

	if (level == 10) {
		/* for raid10, the bitmap size is the capacity of the array,
		 * which is array.size * raid_disks / ncopies;
		 * .. but convert to sectors.
		 */
		int ncopies = ((layout>>8) & 255) * (layout & 255);
		bitmapsize = (unsigned long long)size * raiddisks / ncopies * 2;
/*		printf("bms=%llu as=%d rd=%d nc=%d\n", bitmapsize, size, raiddisks, ncopies);*/
	} else
		bitmapsize = (unsigned long long)size * 2;

	/* There is lots of redundancy in these disk counts,
	 * raid_disks is the most meaningful value
	 *          it describes the geometry of the array
	 *          it is constant
	 * nr_disks is total number of used slots.
	 *          it should be raid_disks+spare_disks
	 * spare_disks is the number of extra disks present
	 *          see above
	 * active_disks is the number of working disks in
	 *          active slots. (With raid_disks)
	 * working_disks is the total number of working disks,
	 *          including spares
	 * failed_disks is the number of disks marked failed
	 *
         * Ideally, the kernel would keep these (except raid_disks)
	 * up-to-date as we ADD_NEW_DISK, but it doesn't (yet).
	 * So for now, we assume that all raid and spare
	 * devices will be given.
	 */
	array.spare_disks=sparedisks;
	array.failed_disks=missing_disks;
	array.nr_disks = array.working_disks + array.failed_disks;
	array.layout = layout;
	array.chunk_size = chunk*1024;
	array.major_version = st->ss->major;

	if (name == NULL || *name == 0) {
		/* base name on mddev */
		/*  /dev/md0 -> 0
		 *  /dev/md_d0 -> d0
		 *  /dev/md/1 -> 1
		 *  /dev/md/d1 -> d1
		 *  /dev/md/home -> home
		 *  /dev/mdhome -> home
		 */
		name = strrchr(mddev, '/');
		if (name) {
			name++;
			if (strncmp(name, "md_d", 4)==0 &&
			    strlen(name) > 4 &&
			    isdigit(name[4]) &&
			    (name-mddev) == 5 /* /dev/ */)
				name += 3;
			else if (strncmp(name, "md", 2)==0 &&
				 strlen(name) > 2 &&
				 isdigit(name[2]) &&
				 (name-mddev) == 5 /* /dev/ */)
				name += 2;
		}
	}
	if (!st->ss->init_super(st, &super, &array, size, name, homehost, uuid))
		return 1;

	if (bitmap_file && vers < 9003) {
		major_num = BITMAP_MAJOR_HOSTENDIAN;
#ifdef __BIG_ENDIAN
		fprintf(stderr, Name ": Warning - bitmaps created on this kernel are not portable\n"
			"  between different architectured.  Consider upgrading the Linux kernel.\n");
#endif
	}

	if (bitmap_file && strcmp(bitmap_file, "internal")==0) {
		if ((vers%100) < 2) {
			fprintf(stderr, Name ": internal bitmaps not supported by this kernel.\n");
			return 1;
		}
		if (!st->ss->add_internal_bitmap(st, super, &bitmap_chunk,
						 delay, write_behind,
						 bitmapsize, 1, major_num)) {
			fprintf(stderr, Name ": Given bitmap chunk size not supported.\n");
			return 1;
		}
		bitmap_file = NULL;
	}


	if ((vers % 100) >= 1) { /* can use different versions */
		mdu_array_info_t inf;
		memset(&inf, 0, sizeof(inf));
		inf.major_version = st->ss->major;
		inf.minor_version = st->minor_version;
		rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
	} else 
		rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
	if (rv) {
		fprintf(stderr, Name ": SET_ARRAY_INFO failed for %s: %s\n",
			mddev, strerror(errno));
		return 1;
	}

	if (bitmap_file) {
		int uuid[4];

		st->ss->uuid_from_super(uuid, super);
		if (CreateBitmap(bitmap_file, force, (char*)uuid, bitmap_chunk,
				 delay, write_behind,
				 bitmapsize,
				 major_num)) {
			return 1;
		}
		bitmap_fd = open(bitmap_file, O_RDWR);
		if (bitmap_fd < 0) {
			fprintf(stderr, Name ": weird: %s cannot be openned\n",
				bitmap_file);
			return 1;
		}
		if (ioctl(mdfd, SET_BITMAP_FILE, bitmap_fd) < 0) {
			fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
				mddev, strerror(errno));
			return 1;
		}
	}


	for (pass=1; pass <=2 ; pass++) {
		mddev_dev_t moved_disk = NULL; /* the disk that was moved out of the insert point */

		for (dnum=0, dv = devlist ; dv ;
		     dv=(dv->next)?(dv->next):moved_disk, dnum++) {
			int fd;
			struct stat stb;
			mdu_disk_info_t disk;

			disk.number = dnum;
			if (dnum == insert_point) {
				moved_disk = dv;
			}
			disk.raid_disk = disk.number;
			if (disk.raid_disk < raiddisks)
				disk.state = (1<<MD_DISK_ACTIVE) |
						(1<<MD_DISK_SYNC);
			else
				disk.state = 0;
			if (dv->writemostly)
				disk.state |= (1<<MD_DISK_WRITEMOSTLY);

			if (dnum == insert_point ||
			    strcasecmp(dv->devname, "missing")==0) {
				disk.major = 0;
				disk.minor = 0;
				disk.state = (1<<MD_DISK_FAULTY);
			} else {
				fd = open(dv->devname, O_RDONLY|O_EXCL, 0);
				if (fd < 0) {
					fprintf(stderr, Name ": failed to open %s after earlier success - aborting\n",
						dv->devname);
					return 1;
				}
				fstat(fd, &stb);
				disk.major = major(stb.st_rdev);
				disk.minor = minor(stb.st_rdev);
				remove_partitions(fd);
				close(fd);
			}
			switch(pass){
			case 1:
				st->ss->add_to_super(super, &disk);
				break;
			case 2:
				if (disk.state == 1) break;
				Kill(dv->devname, 0, 1); /* Just be sure it is clean */
				Kill(dv->devname, 0, 1); /* and again, there could be two superblocks */
				st->ss->write_init_super(st, super, &disk, dv->devname);

				if (ioctl(mdfd, ADD_NEW_DISK, &disk)) {
					fprintf(stderr, Name ": ADD_NEW_DISK for %s failed: %s\n",
						dv->devname, strerror(errno));
					free(super);
					return 1;
				}

				break;
			}
			if (dv == moved_disk && dnum != insert_point) break;
		}
	}
	free(super);

	/* param is not actually used */
	if (runstop == 1 || subdevs >= raiddisks) {
		mdu_param_t param;
		if (ioctl(mdfd, RUN_ARRAY, &param)) {
			fprintf(stderr, Name ": RUN_ARRAY failed: %s\n",
				strerror(errno));
			Manage_runstop(mddev, mdfd, -1, 0);
			return 1;
		}
		if (verbose >= 0)
			fprintf(stderr, Name ": array %s started.\n", mddev);
	} else {
		fprintf(stderr, Name ": not starting array - not enough devices.\n");
	}
	return 0;
}
Commit	Line	Data
64c4757e	1	/*
9a9dab36	2	* mdadm - manage Linux "md" devices aka RAID arrays.
64c4757e	3	*
4f589ad0	4	* Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
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"
682c7051 NB	31	#include "md_u.h"
682c7051 NB	32	#include "md_p.h"
60248f74	33	#include <ctype.h>
64c4757e	34
82d9eba6	35	int Create(struct supertype st, char mddev, int mdfd,
5dd497ee	36	int chunk, int level, int layout, unsigned long long size, int raiddisks, int sparedisks,
3d3dd91e	37	char name, char homehost, int *uuid,
cd29a5c8	38	int subdevs, mddev_dev_t devlist,
47d79ef8	39	int runstop, int verbose, int force, int assume_clean,
dfd4d8ee	40	char *bitmap_file, int bitmap_chunk, int write_behind, int delay)
64c4757e	41	{
682c7051 NB	42	/*
	43	* Create a new raid array.
	44	*
	45	* First check that necessary details are available
	46	* (i.e. level, raid-disks)
	47	*
	48	* Then check each disk to see what might be on it
	49	* and report anything interesting.
	50	*
	51	* If anything looks odd, and runstop not set,
	52	* abort.
	53	*
	54	* SET_ARRAY_INFO and ADD_NEW_DISK, and
82d9eba6	55	* if runstop==run, or raiddisks disks were used,
682c7051 NB	56	* RUN_ARRAY
682c7051 NB	57	*/
b5e64645	58	unsigned long long minsize=0, maxsize=0;
cd29a5c8 NB	59	char *mindisc = NULL;
cd29a5c8 NB	60	char *maxdisc = NULL;
c913b90e	61	int dnum;
cd29a5c8	62	mddev_dev_t dv;
682c7051	63	int fail=0, warn=0;
82b27616	64	struct stat stb;
82d9eba6	65	int first_missing = subdevs * 2;
52826846	66	int missing_disks = 0;
82d9eba6	67	int insert_point = subdevs * 2; /* where to insert a missing drive */
4b1ac34b NB	68	void *super;
4b1ac34b NB	69	int pass;
82d9eba6 NB	70	int vers;
82d9eba6 NB	71	int rv;
c82f047c	72	int bitmap_fd;
f9c25f1d	73	unsigned long long bitmapsize;
682c7051 NB	74
682c7051 NB	75	mdu_array_info_t array;
943eafef	76	int major_num = BITMAP_MAJOR_HI;
dcec9ee5	77
5dd497ee	78	memset(&array, 0, sizeof(array));
29e766a5	79
82d9eba6 NB	80	vers = md_get_version(mdfd);
82d9eba6 NB	81	if (vers < 9000) {
dd0781e5	82	fprintf(stderr, Name ": Create requires md driver version 0.90.0 or later\n");
52826846	83	return 1;
32e5a4ee DL	84	} else {
	85	mdu_array_info_t inf;
	86	memset(&inf, 0, sizeof(inf));
	87	ioctl(mdfd, GET_ARRAY_INFO, &inf);
	88	if (inf.working_disks != 0) {
	89	fprintf(stderr, Name ": another array by this name"
	90	" is already running.\n");
	91	return 1;
	92	}
682c7051	93	}
98c6faba	94	if (level == UnSet) {
682c7051 NB	95	fprintf(stderr,
	96	Name ": a RAID level is needed to create an array.\n");
	97	return 1;
	98	}
98c6faba NB	99	if (raiddisks < 4 && level == 6) {
	100	fprintf(stderr,
	101	Name ": at least 4 raid-devices needed for level 6\n");
	102	return 1;
	103	}
	104	if (raiddisks > 256 && level == 6) {
	105	fprintf(stderr,
	106	Name ": no more than 256 raid-devices supported for level 6\n");
	107	return 1;
	108	}
52826846 NB	109	if (raiddisks < 2 && level >= 4) {
52826846 NB	110	fprintf(stderr,
98c6faba	111	Name ": at least 2 raid-devices needed for level 4 or 5\n");
52826846 NB	112	return 1;
52826846 NB	113	}
682c7051	114	if (subdevs > raiddisks+sparedisks) {
b83d95f3	115	fprintf(stderr, Name ": You have listed more devices (%d) than are in the array(%d)!\n", subdevs, raiddisks+sparedisks);
52826846	116	return 1;
682c7051	117	}
cd29a5c8	118	if (subdevs < raiddisks+sparedisks) {
52826846 NB	119	fprintf(stderr, Name ": You haven't given enough devices (real or missing) to create this array\n");
	120	return 1;
	121	}
5b28bd56 NB	122	if (bitmap_file && level <= 0) {
	123	fprintf(stderr, Name ": bitmaps not meaningful with level %s\n",
	124	map_num(pers, level)?:"given");
	125	return 1;
	126	}
52826846	127
682c7051	128	/* now set some defaults */
98c6faba	129	if (layout == UnSet)
682c7051 NB	130	switch(level) {
	131	default: /* no layout */
	132	layout = 0;
	133	break;
e5329c37 NB	134	case 10:
e5329c37 NB	135	layout = 0x102; /* near=2, far=1 */
dab6685f	136	if (verbose > 0)
e5329c37 NB	137	fprintf(stderr,
	138	Name ": layout defaults to n1\n");
	139	break;
682c7051	140	case 5:
98c6faba	141	case 6:
682c7051	142	layout = map_name(r5layout, "default");
dab6685f	143	if (verbose > 0)
682c7051 NB	144	fprintf(stderr,
	145	Name ": layout defaults to %s\n", map_num(r5layout, layout));
	146	break;
b5e64645 NB	147	case LEVEL_FAULTY:
	148	layout = map_name(faultylayout, "default");
	149
dab6685f	150	if (verbose > 0)
b5e64645 NB	151	fprintf(stderr,
	152	Name ": layout defaults to %s\n", map_num(faultylayout, layout));
	153	break;
682c7051 NB	154	}
682c7051 NB	155
e5329c37 NB	156	if (level == 10)
	157	/* check layout fits in array*/
	158	if ((layout&255) * ((layout>>8)&255) > raiddisks) {
	159	fprintf(stderr, Name ": that layout requires at least %d devices\n",
	160	(layout&255) * ((layout>>8)&255));
	161	return 1;
	162	}
	163
aa88f531 NB	164	switch(level) {
	165	case 4:
	166	case 5:
e5329c37	167	case 10:
98c6faba	168	case 6:
aa88f531 NB	169	case 0:
	170	case -1: /* linear */
	171	if (chunk == 0) {
	172	chunk = 64;
dab6685f	173	if (verbose > 0)
aa88f531 NB	174	fprintf(stderr, Name ": chunk size defaults to 64K\n");
	175	}
	176	break;
	177	default: /* raid1, multipath */
	178	if (chunk) {
	179	chunk = 0;
dab6685f	180	if (verbose > 0)
aa88f531 NB	181	fprintf(stderr, Name ": chunk size ignored for this level\n");
	182	}
	183	break;
682c7051 NB	184	}
	185
	186	/* now look at the subdevs */
52826846 NB	187	array.active_disks = 0;
52826846 NB	188	array.working_disks = 0;
c913b90e NB	189	dnum = 0;
c913b90e NB	190	for (dv=devlist; dv; dv=dv->next, dnum++) {
cd29a5c8	191	char *dname = dv->devname;
b5e64645	192	unsigned long long ldsize, freesize;
52826846	193	int fd;
cd29a5c8	194	if (strcasecmp(dname, "missing")==0) {
c913b90e NB	195	if (first_missing > dnum)
c913b90e NB	196	first_missing = dnum;
52826846 NB	197	missing_disks ++;
	198	continue;
	199	}
	200	array.working_disks++;
c913b90e	201	if (dnum < raiddisks)
52826846	202	array.active_disks++;
d7eaf49f	203	fd = open(dname, O_RDONLY\|O_EXCL, 0);
682c7051 NB	204	if (fd <0 ) {
	205	fprintf(stderr, Name ": Cannot open %s: %s\n",
	206	dname, strerror(errno));
	207	fail=1;
	208	continue;
	209	}
beae1dfe	210	if (!get_dev_size(fd, dname, &ldsize)) {
682c7051 NB	211	fail = 1;
	212	close(fd);
	213	continue;
	214	}
058574b1	215	if (st == NULL) {
8aec876d	216	struct createinfo *ci = conf_get_create_info();
058574b1 NB	217	if (ci)
	218	st = ci->supertype;
	219	}
576d6d83 NB	220	if (st == NULL) {
	221	/* Need to choose a default metadata, which is different
	222	* depending on the sizes of devices
	223	*/
	224	int i;
	225	char *name = "default";
	226	if (level >= 1 && ldsize > (0x7fffffffULL<<10))
	227	name = "default/large";
	228	for(i=0; !st && superlist[i]; i++)
	229	st = superlist[i]->match_metadata_desc(name);
	230
	231	if (!st) {
	232	fprintf(stderr, Name ": internal error - no default metadata style\n");
	233	exit(2);
	234	}
	235	if (st->ss->major != 0 \|\|
	236	st->minor_version != 90)
32e5a4ee DL	237	fprintf(stderr, Name ": Defaulting to version"
32e5a4ee DL	238	" %d.%d metadata\n",
576d6d83 NB	239	st->ss->major,
	240	st->minor_version);
	241	}
1bf4e2d9	242	freesize = st->ss->avail_size(st, ldsize >> 9);
82d9eba6	243	if (freesize == 0) {
aa88f531	244	fprintf(stderr, Name ": %s is too small: %luK\n",
b5e64645	245	dname, (unsigned long)(ldsize>>10));
52826846 NB	246	fail = 1;
	247	close(fd);
	248	continue;
682c7051	249	}
82d9eba6 NB	250
82d9eba6 NB	251	freesize /= 2; /* convert to K */
d2cd3ffc NB	252	if (chunk) {
	253	/* round to chunk size */
	254	freesize = freesize & ~(chunk-1);
	255	}
682c7051 NB	256
682c7051 NB	257	if (size && freesize < size) {
52826846	258	fprintf(stderr, Name ": %s is smaller that given size."
5dd497ee	259	" %lluK < %lluK + superblock\n", dname, freesize, size);
52826846 NB	260	fail = 1;
	261	close(fd);
	262	continue;
682c7051	263	}
cd29a5c8 NB	264	if (maxdisc == NULL \|\| (maxdisc && freesize > maxsize)) {
cd29a5c8 NB	265	maxdisc = dname;
52826846	266	maxsize = freesize;
682c7051	267	}
cd29a5c8 NB	268	if (mindisc ==NULL \|\| (mindisc && freesize < minsize)) {
cd29a5c8 NB	269	mindisc = dname;
52826846	270	minsize = freesize;
682c7051	271	}
dab6685f NB	272	if (runstop != 1 \|\| verbose >= 0) {
	273	warn \|= check_ext2(fd, dname);
	274	warn \|= check_reiser(fd, dname);
	275	warn \|= check_raid(fd, dname);
	276	}
682c7051 NB	277	close(fd);
	278	}
	279	if (fail) {
52826846 NB	280	fprintf(stderr, Name ": create aborted\n");
52826846 NB	281	return 1;
682c7051 NB	282	}
682c7051 NB	283	if (size == 0) {
cd29a5c8	284	if (mindisc == NULL) {
52826846 NB	285	fprintf(stderr, Name ": no size and no drives given - aborting create.\n");
	286	return 1;
	287	}
c13c45e9	288	if (level > 0 \|\| level == LEVEL_MULTIPATH \|\| level == LEVEL_FAULTY) {
b5e64645	289	/* size is meaningful */
5dd497ee	290	if (minsize > 0x100000000ULL && st->ss->major == 0) {
b5e64645 NB	291	fprintf(stderr, Name ": devices too large for RAID level %d\n", level);
	292	return 1;
	293	}
	294	size = minsize;
dab6685f	295	if (verbose > 0)
5dd497ee	296	fprintf(stderr, Name ": size set to %lluK\n", size);
b5e64645	297	}
682c7051	298	}
b5e64645	299	if (level > 0 && ((maxsize-size)*100 > maxsize)) {
dab6685f	300	if (runstop != 1 \|\| verbose >= 0)
5dd497ee	301	fprintf(stderr, Name ": largest drive (%s) exceed size (%lluK) by more than 1%%\n",
dab6685f	302	maxdisc, size);
52826846	303	warn = 1;
682c7051 NB	304	}
	305
	306	if (warn) {
52826846 NB	307	if (runstop!= 1) {
	308	if (!ask("Continue creating array? ")) {
	309	fprintf(stderr, Name ": create aborted.\n");
	310	return 1;
	311	}
	312	} else {
dab6685f	313	if (verbose > 0)
52826846	314	fprintf(stderr, Name ": creation continuing despite oddities due to --run\n");
682c7051	315	}
682c7051 NB	316	}
682c7051 NB	317
66f8bbbe	318	/* If this is raid4/5, we want to configure the last active slot
52826846	319	* as missing, so that a reconstruct happens (faster than re-parity)
98c6faba	320	* FIX: Can we do this for raid6 as well?
52826846	321	*/
47d79ef8	322	if (assume_clean==0 && force == 0 && first_missing >= raiddisks) {
98c6faba	323	switch ( level ) {
66f8bbbe	324	case 4:
98c6faba NB	325	case 5:
	326	insert_point = raiddisks-1;
	327	sparedisks++;
	328	array.active_disks--;
	329	missing_disks++;
	330	break;
	331	default:
	332	break;
	333	}
52826846 NB	334	}
52826846 NB	335
682c7051 NB	336	/* Ok, lets try some ioctls */
	337
	338	array.level = level;
	339	array.size = size;
682c7051	340	array.raid_disks = raiddisks;
82b27616 NB	341	/* The kernel should know what md_minor we are dealing
	342	* with, but it chooses to trust me instead. Sigh
	343	*/
682c7051	344	array.md_minor = 0;
82b27616	345	if (fstat(mdfd, &stb)==0)
0df46c2a	346	array.md_minor = minor(stb.st_rdev);
682c7051	347	array.not_persistent = 0;
98c6faba	348	/* FIX: Need to do something about RAID-6 here */
66f8bbbe	349	if ( ( (level == 4 \|\| level == 5) &&
b5e64645 NB	350	(insert_point < raiddisks \|\| first_missing < raiddisks) )
	351	\|\|
	352	( level == 6 && missing_disks == 2)
47d79ef8 NB	353	\|\|
47d79ef8 NB	354	assume_clean
b5e64645	355	)
98c6faba	356	array.state = 1; /* clean, but one+ drive will be missing */
82b27616	357	else
52826846	358	array.state = 0; /* not clean, but no errors */
82b27616	359
f9c25f1d NB	360	if (level == 10) {
	361	/* for raid10, the bitmap size is the capacity of the array,
	362	* which is array.size * raid_disks / ncopies;
	363	* .. but convert to sectors.
	364	*/
702b557b	365	int ncopies = ((layout>>8) & 255) * (layout & 255);
5dd497ee NB	366	bitmapsize = (unsigned long long)size * raiddisks / ncopies * 2;
5dd497ee NB	367	/* printf("bms=%llu as=%d rd=%d nc=%d\n", bitmapsize, size, raiddisks, ncopies);*/
f9c25f1d	368	} else
5dd497ee	369	bitmapsize = (unsigned long long)size * 2;
f9c25f1d	370
82b27616 NB	371	/* There is lots of redundancy in these disk counts,
	372	* raid_disks is the most meaningful value
	373	* it describes the geometry of the array
	374	* it is constant
	375	* nr_disks is total number of used slots.
	376	* it should be raid_disks+spare_disks
	377	* spare_disks is the number of extra disks present
	378	* see above
	379	* active_disks is the number of working disks in
	380	* active slots. (With raid_disks)
	381	* working_disks is the total number of working disks,
	382	* including spares
	383	* failed_disks is the number of disks marked failed
	384	*
	385	* Ideally, the kernel would keep these (except raid_disks)
	386	* up-to-date as we ADD_NEW_DISK, but it doesn't (yet).
	387	* So for now, we assume that all raid and spare
	388	* devices will be given.
	389	*/
52826846 NB	390	array.spare_disks=sparedisks;
	391	array.failed_disks=missing_disks;
	392	array.nr_disks = array.working_disks + array.failed_disks;
682c7051 NB	393	array.layout = layout;
682c7051 NB	394	array.chunk_size = chunk*1024;
838acbc2	395	array.major_version = st->ss->major;
82d9eba6	396
b3b33eb5 NB	397	if (name == NULL \|\| *name == 0) {
b3b33eb5 NB	398	/* base name on mddev */
d1e80164 NB	399	/* /dev/md0 -> 0
	400	* /dev/md_d0 -> d0
	401	* /dev/md/1 -> 1
	402	* /dev/md/d1 -> d1
	403	* /dev/md/home -> home
	404	* /dev/mdhome -> home
	405	*/
b3b33eb5 NB	406	name = strrchr(mddev, '/');
	407	if (name) {
	408	name++;
60248f74 NB	409	if (strncmp(name, "md_d", 4)==0 &&
	410	strlen(name) > 4 &&
	411	isdigit(name[4]) &&
b3b33eb5	412	(name-mddev) == 5 /* /dev/ */)
d1e80164	413	name += 3;
60248f74 NB	414	else if (strncmp(name, "md", 2)==0 &&
	415	strlen(name) > 2 &&
	416	isdigit(name[2]) &&
	417	(name-mddev) == 5 /* /dev/ */)
b3b33eb5 NB	418	name += 2;
	419	}
	420	}
3d3dd91e	421	if (!st->ss->init_super(st, &super, &array, size, name, homehost, uuid))
82d9eba6	422	return 1;
682c7051	423
dcec9ee5	424	if (bitmap_file && vers < 9003) {
943eafef	425	major_num = BITMAP_MAJOR_HOSTENDIAN;
dcec9ee5 NB	426	#ifdef __BIG_ENDIAN
	427	fprintf(stderr, Name ": Warning - bitmaps created on this kernel are not portable\n"
	428	" between different architectured. Consider upgrading the Linux kernel.\n");
	429	#endif
	430	}
	431
55935d51 NB	432	if (bitmap_file && strcmp(bitmap_file, "internal")==0) {
	433	if ((vers%100) < 2) {
	434	fprintf(stderr, Name ": internal bitmaps not supported by this kernel.\n");
	435	return 1;
	436	}
199171a2 NB	437	if (!st->ss->add_internal_bitmap(st, super, &bitmap_chunk,
199171a2 NB	438	delay, write_behind,
943eafef	439	bitmapsize, 1, major_num)) {
55935d51 NB	440	fprintf(stderr, Name ": Given bitmap chunk size not supported.\n");
	441	return 1;
	442	}
	443	bitmap_file = NULL;
	444	}
	445
	446
	447
82d9eba6 NB	448	if ((vers % 100) >= 1) { /* can use different versions */
	449	mdu_array_info_t inf;
	450	memset(&inf, 0, sizeof(inf));
	451	inf.major_version = st->ss->major;
	452	inf.minor_version = st->minor_version;
	453	rv = ioctl(mdfd, SET_ARRAY_INFO, &inf);
	454	} else
	455	rv = ioctl(mdfd, SET_ARRAY_INFO, NULL);
	456	if (rv) {
52826846 NB	457	fprintf(stderr, Name ": SET_ARRAY_INFO failed for %s: %s\n",
	458	mddev, strerror(errno));
	459	return 1;
682c7051	460	}
52826846	461
c82f047c NB	462	if (bitmap_file) {
c82f047c NB	463	int uuid[4];
55935d51	464
c82f047c	465	st->ss->uuid_from_super(uuid, super);
dfd4d8ee	466	if (CreateBitmap(bitmap_file, force, (char*)uuid, bitmap_chunk,
dcec9ee5	467	delay, write_behind,
f9c25f1d	468	bitmapsize,
943eafef	469	major_num)) {
c82f047c NB	470	return 1;
	471	}
	472	bitmap_fd = open(bitmap_file, O_RDWR);
	473	if (bitmap_fd < 0) {
	474	fprintf(stderr, Name ": weird: %s cannot be openned\n",
dcec9ee5	475	bitmap_file);
c82f047c NB	476	return 1;
	477	}
	478	if (ioctl(mdfd, SET_BITMAP_FILE, bitmap_fd) < 0) {
	479	fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
	480	mddev, strerror(errno));
	481	return 1;
	482	}
	483	}
	484
4b1ac34b NB	485
	486
	487	for (pass=1; pass <=2 ; pass++) {
	488	mddev_dev_t moved_disk = NULL; /* the disk that was moved out of the insert point */
	489
	490	for (dnum=0, dv = devlist ; dv ;
	491	dv=(dv->next)?(dv->next):moved_disk, dnum++) {
	492	int fd;
	493	struct stat stb;
	494	mdu_disk_info_t disk;
	495
	496	disk.number = dnum;
	497	if (dnum == insert_point) {
	498	moved_disk = dv;
52826846	499	}
4b1ac34b NB	500	disk.raid_disk = disk.number;
4b1ac34b NB	501	if (disk.raid_disk < raiddisks)
dfd4d8ee NB	502	disk.state = (1<<MD_DISK_ACTIVE) \|
dfd4d8ee NB	503	(1<<MD_DISK_SYNC);
4b1ac34b NB	504	else
4b1ac34b NB	505	disk.state = 0;
dfd4d8ee NB	506	if (dv->writemostly)
	507	disk.state \|= (1<<MD_DISK_WRITEMOSTLY);
	508
4b1ac34b NB	509	if (dnum == insert_point \|\|
	510	strcasecmp(dv->devname, "missing")==0) {
	511	disk.major = 0;
	512	disk.minor = 0;
dfd4d8ee	513	disk.state = (1<<MD_DISK_FAULTY);
4b1ac34b NB	514	} else {
	515	fd = open(dv->devname, O_RDONLY\|O_EXCL, 0);
	516	if (fd < 0) {
	517	fprintf(stderr, Name ": failed to open %s after earlier success - aborting\n",
	518	dv->devname);
	519	return 1;
	520	}
	521	fstat(fd, &stb);
	522	disk.major = major(stb.st_rdev);
	523	disk.minor = minor(stb.st_rdev);
0430ed48	524	remove_partitions(fd);
4b1ac34b NB	525	close(fd);
	526	}
	527	switch(pass){
	528	case 1:
82d9eba6	529	st->ss->add_to_super(super, &disk);
4b1ac34b NB	530	break;
4b1ac34b NB	531	case 2:
eaac7dde	532	if (disk.state == 1) break;
6409687b NB	533	Kill(dv->devname, 0, 1); /* Just be sure it is clean */
6409687b NB	534	Kill(dv->devname, 0, 1); /* and again, there could be two superblocks */
1bf4e2d9	535	st->ss->write_init_super(st, super, &disk, dv->devname);
4b1ac34b NB	536
	537	if (ioctl(mdfd, ADD_NEW_DISK, &disk)) {
	538	fprintf(stderr, Name ": ADD_NEW_DISK for %s failed: %s\n",
	539	dv->devname, strerror(errno));
	540	free(super);
	541	return 1;
	542	}
	543
	544	break;
	545	}
	546	if (dv == moved_disk && dnum != insert_point) break;
52826846	547	}
5e52ae9e	548	}
4b1ac34b	549	free(super);
5e52ae9e	550
682c7051 NB	551	/* param is not actually used */
682c7051 NB	552	if (runstop == 1 \|\| subdevs >= raiddisks) {
82b27616	553	mdu_param_t param;
682c7051 NB	554	if (ioctl(mdfd, RUN_ARRAY, &param)) {
	555	fprintf(stderr, Name ": RUN_ARRAY failed: %s\n",
	556	strerror(errno));
91f068bf	557	Manage_runstop(mddev, mdfd, -1, 0);
682c7051 NB	558	return 1;
682c7051 NB	559	}
dab6685f NB	560	if (verbose >= 0)
dab6685f NB	561	fprintf(stderr, Name ": array %s started.\n", mddev);
682c7051	562	} else {
b83d95f3	563	fprintf(stderr, Name ": not starting array - not enough devices.\n");
682c7051 NB	564	}
682c7051 NB	565	return 0;
64c4757e	566	}