[thirdparty/mdadm.git] / Grow.c

/*
 * mdadm - manage Linux "md" devices aka RAID arrays.
 *
 * Copyright (C) 2001-2004 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	"dlink.h"

#if ! defined(__BIG_ENDIAN) && ! defined(__LITTLE_ENDIAN)
#error no endian defined
#endif
#include	"md_u.h"
#include	"md_p.h"

int Grow_Add_device(char *devname, int fd, char *newdev)
{
	/* Add a device to an active array.
	 * Currently, just extend a linear array.
	 * This requires writing a new superblock on the
	 * new device, calling the kernel to add the device,
	 * and if that succeeds, update the superblock on
	 * all other devices.
	 * This means that we need to *find* all other devices.
	 */
	struct mdinfo info;

	void *super = NULL;
	struct stat stb;
	int nfd, fd2;
	int d, nd;
	struct supertype *st = NULL;
	

	if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
		fprintf(stderr, Name ": cannot get array info for %s\n", devname);
		return 1;
	}

	st = super_by_version(info.array.major_version, info.array.minor_version);
	if (!st) {
		fprintf(stderr, Name ": cannot handle arrays with superblock version %d\n", info.array.major_version);
		return 1;
	}

	if (info.array.level != -1) {
		fprintf(stderr, Name ": can only add devices to linear arrays\n");
		return 1;
	}

	nfd = open(newdev, O_RDWR|O_EXCL);
	if (nfd < 0) {
		fprintf(stderr, Name ": cannot open %s\n", newdev);
		return 1;
	}
	fstat(nfd, &stb);
	if ((stb.st_mode & S_IFMT) != S_IFBLK) {
		fprintf(stderr, Name ": %s is not a block device!\n", newdev);
		close(nfd);
		return 1;
	}
	/* now check out all the devices and make sure we can read the superblock */
	for (d=0 ; d < info.array.raid_disks ; d++) {
		mdu_disk_info_t disk;
		char *dv;

		disk.number = d;
		if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
			fprintf(stderr, Name ": cannot get device detail for device %d\n",
				d);
			return 1;
		}
		dv = map_dev(disk.major, disk.minor);
		if (!dv) {
			fprintf(stderr, Name ": cannot find device file for device %d\n",
				d);
			return 1;
		}
		fd2 = open(dv, O_RDWR);
		if (!fd2) {
			fprintf(stderr, Name ": cannot open device file %s\n", dv);
			return 1;
		}
		if (super) free(super);
		super= NULL;
		if (st->ss->load_super(st, fd2, &super, NULL)) {
			fprintf(stderr, Name ": cannot find super block on %s\n", dv);
			close(fd2);
			return 1;
		}
		close(fd2);
	}
	/* Ok, looks good. Lets update the superblock and write it out to
	 * newdev.
	 */
	
	info.disk.number = d;
	info.disk.major = major(stb.st_rdev);
	info.disk.minor = minor(stb.st_rdev);
	info.disk.raid_disk = d;
	info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
	st->ss->update_super(&info, super, "grow", newdev, 0);

	if (st->ss->store_super(st, nfd, super)) {
		fprintf(stderr, Name ": Cannot store new superblock on %s\n", newdev);
		close(nfd);
		return 1;
	}
	close(nfd);

	if (ioctl(fd, ADD_NEW_DISK, &info.disk) != 0) {
		fprintf(stderr, Name ": Cannot add new disk to this array\n");
		return 1;
	}
	/* Well, that seems to have worked.
	 * Now go through and update all superblocks
	 */

	if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
		fprintf(stderr, Name ": cannot get array info for %s\n", devname);
		return 1;
	}

	nd = d;
	for (d=0 ; d < info.array.raid_disks ; d++) {
		mdu_disk_info_t disk;
		char *dv;

		disk.number = d;
		if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
			fprintf(stderr, Name ": cannot get device detail for device %d\n",
				d);
			return 1;
		}
		dv = map_dev(disk.major, disk.minor);
		if (!dv) {
			fprintf(stderr, Name ": cannot find device file for device %d\n",
				d);
			return 1;
		}
		fd2 = open(dv, O_RDWR);
		if (fd2 < 0) {
			fprintf(stderr, Name ": cannot open device file %s\n", dv);
			return 1;
		}
		if (st->ss->load_super(st, fd2, &super, NULL)) {
			fprintf(stderr, Name ": cannot find super block on %s\n", dv);
			close(fd);
			return 1;
		}
		info.array.raid_disks = nd+1;
		info.array.nr_disks = nd+1;
		info.array.active_disks = nd+1;
		info.array.working_disks = nd+1;
		info.disk.number = nd;
		info.disk.major = major(stb.st_rdev);
		info.disk.minor = minor(stb.st_rdev);
		info.disk.raid_disk = nd;
		info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
		st->ss->update_super(&info, super, "grow", dv, 0);
		
		if (st->ss->store_super(st, fd2, super)) {
			fprintf(stderr, Name ": Cannot store new superblock on %s\n", dv);
			close(fd2);
			return 1;
		}
		close(fd2);
	}

	return 0;
}

int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force)
{
	/*
	 * First check that array doesn't have a bitmap
	 * Then create the bitmap
	 * Then add it
	 *
	 * For internal bitmaps, we need to check the version,
	 * find all the active devices, and write the bitmap block
	 * to all devices
	 */
	mdu_bitmap_file_t bmf;
	mdu_array_info_t array;
	struct supertype *st;
	int major = BITMAP_MAJOR_HI;
	int vers = md_get_version(fd);
	unsigned long long bitmapsize, array_size;

	if (vers < 9003) {
		major = 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 (ioctl(fd, GET_BITMAP_FILE, &bmf) != 0) {
		if (errno == ENOMEM) 
			fprintf(stderr, Name ": Memory allocation failure.\n");
		else
			fprintf(stderr, Name ": bitmaps not supported by this kernel.\n");
		return 1;
	}
	if (bmf.pathname[0]) {
		if (strcmp(file,"none")==0) {
			if (ioctl(fd, SET_BITMAP_FILE, -1)!= 0) {
				fprintf(stderr, Name ": failed to remove bitmap %s\n",
					bmf.pathname);
				return 1;
			}
			return 0;
		}
		fprintf(stderr, Name ": %s already has a bitmap (%s)\n",
			devname, bmf.pathname);
		return 1;
	}
	if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
		fprintf(stderr, Name ": cannot get array status for %s\n", devname);
		return 1;
	}
	if (array.state & (1<<MD_SB_BITMAP_PRESENT)) {
		if (strcmp(file, "none")==0) {
			array.state &= ~(1<<MD_SB_BITMAP_PRESENT);
			if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
				fprintf(stderr, Name ": failed to remove internal bitmap.\n");
				return 1;
			}
			return 0;
		}
		fprintf(stderr, Name ": Internal bitmap already present on %s\n",
			devname);
		return 1;
	}
	bitmapsize = array.size;
	bitmapsize <<= 1;
#ifdef BLKGETSIZE64
	if (ioctl(fd, BLKGETSIZE64, &array_size) == 0 &&
	    array_size > (0x7fffffffULL<<9)) {
		/* Array is big enough that we cannot trust array.size
		 * try other approaches
		 */
		bitmapsize = get_component_size(fd);
	}
#endif
	if (bitmapsize == 0) {
		fprintf(stderr, Name ": Cannot reliably determine size of array to create bitmap - sorry.\n");
		return 1;
	}

	if (array.level == 10) {
		int ncopies = (array.layout&255)*(array.layout>>8);
		bitmapsize = bitmapsize * array.raid_disks / ncopies;
	}

	st = super_by_version(array.major_version, array.minor_version);
	if (!st) {
		fprintf(stderr, Name ": Cannot understand version %d.%d\n",
			array.major_version, array.minor_version);
		return 1;
	}
	if (strcmp(file, "none") == 0) {
		fprintf(stderr, Name ": no bitmap found on %s\n", devname);
		return 1;
	} else if (strcmp(file, "internal") == 0) {
		int d;
		for (d=0; d< st->max_devs; d++) {
			mdu_disk_info_t disk;
			char *dv;
			disk.number = d;
			if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
				continue;
			if (disk.major == 0 &&
			    disk.minor == 0)
				continue;
			if ((disk.state & (1<<MD_DISK_SYNC))==0)
				continue;
			dv = map_dev(disk.major, disk.minor);
			if (dv) {
				void *super;
				int fd2 = open(dv, O_RDWR);
				if (fd2 < 0)
					continue;
				if (st->ss->load_super(st, fd2, &super, NULL)==0) {
					if (st->ss->add_internal_bitmap(st, super,
								    chunk, delay, write_behind,
									bitmapsize, 0, major))
						st->ss->write_bitmap(st, fd2, super);
					else {
						fprintf(stderr, Name ": failed to create internal bitmap - chunksize problem.\n");
						close(fd2);
						return 1;
					}
				}
				close(fd2);
			}
		}
		array.state |= (1<<MD_SB_BITMAP_PRESENT);
		if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
			fprintf(stderr, Name ": failed to set internal bitmap.\n");
			return 1;
		}
	} else {
		int uuid[4];
		int bitmap_fd;
		int d;
		int max_devs = st->max_devs;
		void *super = NULL;
		if (chunk == UnSet)
			chunk = DEFAULT_BITMAP_CHUNK;

		/* try to load a superblock */
		for (d=0; d<max_devs; d++) {
			mdu_disk_info_t disk;
			char *dv;
			int fd2;
			disk.number = d;
			if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
				continue;
			if ((disk.major==0 && disk.minor==0) ||
			    (disk.state & (1<<MD_DISK_REMOVED)))
				continue;
			dv = map_dev(disk.major, disk.minor);
			if (!dv) continue;
			fd2 = open(dv, O_RDONLY);
			if (fd2 >= 0 &&
			    st->ss->load_super(st, fd2, &super, NULL) == 0) {
				close(fd2);
				st->ss->uuid_from_super(uuid, super);
				break;
			}
			close(fd2);
		}
		if (d == max_devs) {
			fprintf(stderr, Name ": cannot find UUID for array!\n");
			return 1;
		}
		if (CreateBitmap(file, force, (char*)uuid, chunk,
				 delay, write_behind, bitmapsize, major)) {
			return 1;
		}
		bitmap_fd = open(file, O_RDWR);
		if (bitmap_fd < 0) {
			fprintf(stderr, Name ": weird: %s cannot be opened\n",
				file);
			return 1;
		}
		if (ioctl(fd, SET_BITMAP_FILE, bitmap_fd) < 0) {
			fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
				devname, strerror(errno));
			return 1;
		}
	}

	return 0;
}
Commit	Line	Data
e5329c37 NB	1	/*
	2	* mdadm - manage Linux "md" devices aka RAID arrays.
	3	*
	4	* Copyright (C) 2001-2004 Neil Brown <neilb@cse.unsw.edu.au>
	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	#include "mdadm.h"
	30	#include "dlink.h"
	31
	32	#if ! defined(__BIG_ENDIAN) && ! defined(__LITTLE_ENDIAN)
	33	#error no endian defined
	34	#endif
	35	#include "md_u.h"
	36	#include "md_p.h"
	37
	38	int Grow_Add_device(char devname, int fd, char newdev)
	39	{
	40	/* Add a device to an active array.
	41	* Currently, just extend a linear array.
	42	* This requires writing a new superblock on the
	43	* new device, calling the kernel to add the device,
	44	* and if that succeeds, update the superblock on
	45	* all other devices.
	46	* This means that we need to find all other devices.
	47	*/
4b1ac34b NB	48	struct mdinfo info;
	49
	50	void *super = NULL;
e5329c37 NB	51	struct stat stb;
	52	int nfd, fd2;
	53	int d, nd;
82d9eba6	54	struct supertype *st = NULL;
e5329c37 NB	55
e5329c37 NB	56
4b1ac34b	57	if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
e5329c37 NB	58	fprintf(stderr, Name ": cannot get array info for %s\n", devname);
	59	return 1;
	60	}
	61
82d9eba6 NB	62	st = super_by_version(info.array.major_version, info.array.minor_version);
82d9eba6 NB	63	if (!st) {
f9ce90ba NB	64	fprintf(stderr, Name ": cannot handle arrays with superblock version %d\n", info.array.major_version);
	65	return 1;
	66	}
	67
4b1ac34b	68	if (info.array.level != -1) {
e5329c37 NB	69	fprintf(stderr, Name ": can only add devices to linear arrays\n");
	70	return 1;
	71	}
	72
	73	nfd = open(newdev, O_RDWR\|O_EXCL);
	74	if (nfd < 0) {
	75	fprintf(stderr, Name ": cannot open %s\n", newdev);
	76	return 1;
	77	}
	78	fstat(nfd, &stb);
	79	if ((stb.st_mode & S_IFMT) != S_IFBLK) {
	80	fprintf(stderr, Name ": %s is not a block device!\n", newdev);
	81	close(nfd);
	82	return 1;
	83	}
	84	/* now check out all the devices and make sure we can read the superblock */
4b1ac34b	85	for (d=0 ; d < info.array.raid_disks ; d++) {
e5329c37 NB	86	mdu_disk_info_t disk;
	87	char *dv;
	88
	89	disk.number = d;
	90	if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
	91	fprintf(stderr, Name ": cannot get device detail for device %d\n",
	92	d);
	93	return 1;
	94	}
	95	dv = map_dev(disk.major, disk.minor);
	96	if (!dv) {
	97	fprintf(stderr, Name ": cannot find device file for device %d\n",
	98	d);
	99	return 1;
	100	}
	101	fd2 = open(dv, O_RDWR);
	102	if (!fd2) {
	103	fprintf(stderr, Name ": cannot open device file %s\n", dv);
	104	return 1;
	105	}
4b1ac34b NB	106	if (super) free(super);
4b1ac34b NB	107	super= NULL;
82d9eba6	108	if (st->ss->load_super(st, fd2, &super, NULL)) {
e5329c37 NB	109	fprintf(stderr, Name ": cannot find super block on %s\n", dv);
	110	close(fd2);
	111	return 1;
	112	}
	113	close(fd2);
	114	}
	115	/* Ok, looks good. Lets update the superblock and write it out to
	116	* newdev.
	117	*/
	118
4b1ac34b NB	119	info.disk.number = d;
	120	info.disk.major = major(stb.st_rdev);
	121	info.disk.minor = minor(stb.st_rdev);
	122	info.disk.raid_disk = d;
	123	info.disk.state = (1 << MD_DISK_SYNC) \| (1 << MD_DISK_ACTIVE);
82d9eba6	124	st->ss->update_super(&info, super, "grow", newdev, 0);
e5329c37	125
96395475	126	if (st->ss->store_super(st, nfd, super)) {
e5329c37 NB	127	fprintf(stderr, Name ": Cannot store new superblock on %s\n", newdev);
	128	close(nfd);
	129	return 1;
	130	}
e5329c37	131	close(nfd);
4b1ac34b NB	132
4b1ac34b NB	133	if (ioctl(fd, ADD_NEW_DISK, &info.disk) != 0) {
e5329c37 NB	134	fprintf(stderr, Name ": Cannot add new disk to this array\n");
	135	return 1;
	136	}
	137	/* Well, that seems to have worked.
	138	* Now go through and update all superblocks
	139	*/
	140
4b1ac34b	141	if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
e5329c37 NB	142	fprintf(stderr, Name ": cannot get array info for %s\n", devname);
	143	return 1;
	144	}
	145
	146	nd = d;
4b1ac34b	147	for (d=0 ; d < info.array.raid_disks ; d++) {
e5329c37 NB	148	mdu_disk_info_t disk;
	149	char *dv;
	150
	151	disk.number = d;
	152	if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
	153	fprintf(stderr, Name ": cannot get device detail for device %d\n",
	154	d);
	155	return 1;
	156	}
	157	dv = map_dev(disk.major, disk.minor);
	158	if (!dv) {
	159	fprintf(stderr, Name ": cannot find device file for device %d\n",
	160	d);
	161	return 1;
	162	}
	163	fd2 = open(dv, O_RDWR);
	164	if (fd2 < 0) {
	165	fprintf(stderr, Name ": cannot open device file %s\n", dv);
	166	return 1;
	167	}
82d9eba6	168	if (st->ss->load_super(st, fd2, &super, NULL)) {
e5329c37 NB	169	fprintf(stderr, Name ": cannot find super block on %s\n", dv);
	170	close(fd);
	171	return 1;
	172	}
4b1ac34b NB	173	info.array.raid_disks = nd+1;
	174	info.array.nr_disks = nd+1;
	175	info.array.active_disks = nd+1;
	176	info.array.working_disks = nd+1;
	177	info.disk.number = nd;
	178	info.disk.major = major(stb.st_rdev);
	179	info.disk.minor = minor(stb.st_rdev);
	180	info.disk.raid_disk = nd;
	181	info.disk.state = (1 << MD_DISK_SYNC) \| (1 << MD_DISK_ACTIVE);
82d9eba6	182	st->ss->update_super(&info, super, "grow", dv, 0);
4b1ac34b	183
96395475	184	if (st->ss->store_super(st, fd2, super)) {
e5329c37 NB	185	fprintf(stderr, Name ": Cannot store new superblock on %s\n", dv);
	186	close(fd2);
	187	return 1;
	188	}
	189	close(fd2);
	190	}
	191
	192	return 0;
	193	}
f5e166fe	194
8fac0577	195	int Grow_addbitmap(char devname, int fd, char file, int chunk, int delay, int write_behind, int force)
f5e166fe NB	196	{
	197	/*
	198	* First check that array doesn't have a bitmap
	199	* Then create the bitmap
	200	* Then add it
	201	*
	202	* For internal bitmaps, we need to check the version,
	203	* find all the active devices, and write the bitmap block
	204	* to all devices
	205	*/
	206	mdu_bitmap_file_t bmf;
	207	mdu_array_info_t array;
	208	struct supertype *st;
dcec9ee5 NB	209	int major = BITMAP_MAJOR_HI;
dcec9ee5 NB	210	int vers = md_get_version(fd);
8fac0577	211	unsigned long long bitmapsize, array_size;
dcec9ee5 NB	212
	213	if (vers < 9003) {
	214	major = BITMAP_MAJOR_HOSTENDIAN;
	215	#ifdef __BIG_ENDIAN
	216	fprintf(stderr, Name ": Warning - bitmaps created on this kernel are not portable\n"
	217	" between different architectured. Consider upgrading the Linux kernel.\n");
	218	#endif
	219	}
f5e166fe NB	220
	221	if (ioctl(fd, GET_BITMAP_FILE, &bmf) != 0) {
	222	if (errno == ENOMEM)
	223	fprintf(stderr, Name ": Memory allocation failure.\n");
	224	else
	225	fprintf(stderr, Name ": bitmaps not supported by this kernel.\n");
	226	return 1;
	227	}
	228	if (bmf.pathname[0]) {
fe80f49b NB	229	if (strcmp(file,"none")==0) {
	230	if (ioctl(fd, SET_BITMAP_FILE, -1)!= 0) {
	231	fprintf(stderr, Name ": failed to remove bitmap %s\n",
	232	bmf.pathname);
	233	return 1;
	234	}
	235	return 0;
	236	}
f5e166fe NB	237	fprintf(stderr, Name ": %s already has a bitmap (%s)\n",
	238	devname, bmf.pathname);
	239	return 1;
	240	}
	241	if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
	242	fprintf(stderr, Name ": cannot get array status for %s\n", devname);
	243	return 1;
	244	}
	245	if (array.state & (1<<MD_SB_BITMAP_PRESENT)) {
fe80f49b NB	246	if (strcmp(file, "none")==0) {
	247	array.state &= ~(1<<MD_SB_BITMAP_PRESENT);
	248	if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
	249	fprintf(stderr, Name ": failed to remove internal bitmap.\n");
	250	return 1;
	251	}
	252	return 0;
	253	}
f5e166fe NB	254	fprintf(stderr, Name ": Internal bitmap already present on %s\n",
	255	devname);
	256	return 1;
	257	}
8fac0577 NB	258	bitmapsize = array.size;
	259	bitmapsize <<= 1;
	260	#ifdef BLKGETSIZE64
	261	if (ioctl(fd, BLKGETSIZE64, &array_size) == 0 &&
	262	array_size > (0x7fffffffULL<<9)) {
	263	/* Array is big enough that we cannot trust array.size
	264	* try other approaches
	265	*/
	266	bitmapsize = get_component_size(fd);
	267	}
	268	#endif
	269	if (bitmapsize == 0) {
	270	fprintf(stderr, Name ": Cannot reliably determine size of array to create bitmap - sorry.\n");
	271	return 1;
	272	}
	273
f9c25f1d NB	274	if (array.level == 10) {
	275	int ncopies = (array.layout&255)*(array.layout>>8);
	276	bitmapsize = bitmapsize * array.raid_disks / ncopies;
	277	}
	278
f5e166fe NB	279	st = super_by_version(array.major_version, array.minor_version);
	280	if (!st) {
	281	fprintf(stderr, Name ": Cannot understand version %d.%d\n",
	282	array.major_version, array.minor_version);
	283	return 1;
	284	}
fe80f49b NB	285	if (strcmp(file, "none") == 0) {
	286	fprintf(stderr, Name ": no bitmap found on %s\n", devname);
	287	return 1;
	288	} else if (strcmp(file, "internal") == 0) {
f5e166fe	289	int d;
ea329559	290	for (d=0; d< st->max_devs; d++) {
f5e166fe NB	291	mdu_disk_info_t disk;
	292	char *dv;
	293	disk.number = d;
	294	if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
	295	continue;
	296	if (disk.major == 0 &&
	297	disk.minor == 0)
	298	continue;
	299	if ((disk.state & (1<<MD_DISK_SYNC))==0)
	300	continue;
	301	dv = map_dev(disk.major, disk.minor);
	302	if (dv) {
	303	void *super;
	304	int fd2 = open(dv, O_RDWR);
	305	if (fd2 < 0)
	306	continue;
	307	if (st->ss->load_super(st, fd2, &super, NULL)==0) {
21e92547	308	if (st->ss->add_internal_bitmap(st, super,
dfd4d8ee	309	chunk, delay, write_behind,
21e92547 NB	310	bitmapsize, 0, major))
	311	st->ss->write_bitmap(st, fd2, super);
	312	else {
	313	fprintf(stderr, Name ": failed to create internal bitmap - chunksize problem.\n");
	314	close(fd2);
	315	return 1;
	316	}
f5e166fe NB	317	}
	318	close(fd2);
	319	}
	320	}
	321	array.state \|= (1<<MD_SB_BITMAP_PRESENT);
	322	if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
	323	fprintf(stderr, Name ": failed to set internal bitmap.\n");
	324	return 1;
	325	}
fe80f49b NB	326	} else {
	327	int uuid[4];
	328	int bitmap_fd;
	329	int d;
	330	int max_devs = st->max_devs;
	331	void *super = NULL;
	332	if (chunk == UnSet)
	333	chunk = DEFAULT_BITMAP_CHUNK;
	334
	335	/* try to load a superblock */
	336	for (d=0; d<max_devs; d++) {
	337	mdu_disk_info_t disk;
	338	char *dv;
	339	int fd2;
	340	disk.number = d;
	341	if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
	342	continue;
	343	if ((disk.major==0 && disk.minor==0) \|\|
	344	(disk.state & (1<<MD_DISK_REMOVED)))
	345	continue;
	346	dv = map_dev(disk.major, disk.minor);
	347	if (!dv) continue;
	348	fd2 = open(dv, O_RDONLY);
	349	if (fd2 >= 0 &&
	350	st->ss->load_super(st, fd2, &super, NULL) == 0) {
	351	close(fd2);
	352	st->ss->uuid_from_super(uuid, super);
	353	break;
	354	}
	355	close(fd2);
	356	}
	357	if (d == max_devs) {
	358	fprintf(stderr, Name ": cannot find UUID for array!\n");
	359	return 1;
	360	}
8fac0577	361	if (CreateBitmap(file, force, (char*)uuid, chunk,
f9c25f1d	362	delay, write_behind, bitmapsize, major)) {
fe80f49b NB	363	return 1;
	364	}
	365	bitmap_fd = open(file, O_RDWR);
	366	if (bitmap_fd < 0) {
8fac0577	367	fprintf(stderr, Name ": weird: %s cannot be opened\n",
fe80f49b NB	368	file);
	369	return 1;
	370	}
	371	if (ioctl(fd, SET_BITMAP_FILE, bitmap_fd) < 0) {
	372	fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
	373	devname, strerror(errno));
	374	return 1;
	375	}
	376	}
f5e166fe NB	377
	378	return 0;
	379	}
	380
	381