[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)
{
	/*
	 * 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);

	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;
	}
	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) {
					st->ss->add_internal_bitmap(st, super,
								    chunk, delay, write_behind,
								    &array.size, 0, major);
					st->ss->write_bitmap(st, fd2, super);
				}
				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, 0, (char*)uuid, chunk,
				 delay, write_behind, array.size*2ULL, major)) {
			return 1;
		}
		bitmap_fd = open(file, O_RDWR);
		if (bitmap_fd < 0) {
			fprintf(stderr, Name ": weird: %s cannot be openned\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
dfd4d8ee	195	int Grow_addbitmap(char devname, int fd, char file, int chunk, int delay, int write_behind)
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;
	210	int vers = md_get_version(fd);
	211
	212	if (vers < 9003) {
	213	major = BITMAP_MAJOR_HOSTENDIAN;
	214	#ifdef __BIG_ENDIAN
	215	fprintf(stderr, Name ": Warning - bitmaps created on this kernel are not portable\n"
	216	" between different architectured. Consider upgrading the Linux kernel.\n");
	217	#endif
	218	}
f5e166fe NB	219
	220	if (ioctl(fd, GET_BITMAP_FILE, &bmf) != 0) {
	221	if (errno == ENOMEM)
	222	fprintf(stderr, Name ": Memory allocation failure.\n");
	223	else
	224	fprintf(stderr, Name ": bitmaps not supported by this kernel.\n");
	225	return 1;
	226	}
	227	if (bmf.pathname[0]) {
fe80f49b NB	228	if (strcmp(file,"none")==0) {
	229	if (ioctl(fd, SET_BITMAP_FILE, -1)!= 0) {
	230	fprintf(stderr, Name ": failed to remove bitmap %s\n",
	231	bmf.pathname);
	232	return 1;
	233	}
	234	return 0;
	235	}
f5e166fe NB	236	fprintf(stderr, Name ": %s already has a bitmap (%s)\n",
	237	devname, bmf.pathname);
	238	return 1;
	239	}
	240	if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
	241	fprintf(stderr, Name ": cannot get array status for %s\n", devname);
	242	return 1;
	243	}
	244	if (array.state & (1<<MD_SB_BITMAP_PRESENT)) {
fe80f49b NB	245	if (strcmp(file, "none")==0) {
	246	array.state &= ~(1<<MD_SB_BITMAP_PRESENT);
	247	if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
	248	fprintf(stderr, Name ": failed to remove internal bitmap.\n");
	249	return 1;
	250	}
	251	return 0;
	252	}
f5e166fe NB	253	fprintf(stderr, Name ": Internal bitmap already present on %s\n",
	254	devname);
	255	return 1;
	256	}
	257	st = super_by_version(array.major_version, array.minor_version);
	258	if (!st) {
	259	fprintf(stderr, Name ": Cannot understand version %d.%d\n",
	260	array.major_version, array.minor_version);
	261	return 1;
	262	}
fe80f49b NB	263	if (strcmp(file, "none") == 0) {
	264	fprintf(stderr, Name ": no bitmap found on %s\n", devname);
	265	return 1;
	266	} else if (strcmp(file, "internal") == 0) {
f5e166fe	267	int d;
ea329559	268	for (d=0; d< st->max_devs; d++) {
f5e166fe NB	269	mdu_disk_info_t disk;
	270	char *dv;
	271	disk.number = d;
	272	if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
	273	continue;
	274	if (disk.major == 0 &&
	275	disk.minor == 0)
	276	continue;
	277	if ((disk.state & (1<<MD_DISK_SYNC))==0)
	278	continue;
	279	dv = map_dev(disk.major, disk.minor);
	280	if (dv) {
	281	void *super;
	282	int fd2 = open(dv, O_RDWR);
	283	if (fd2 < 0)
	284	continue;
	285	if (st->ss->load_super(st, fd2, &super, NULL)==0) {
34163fc7	286	st->ss->add_internal_bitmap(st, super,
dfd4d8ee	287	chunk, delay, write_behind,
dcec9ee5	288	&array.size, 0, major);
f5e166fe NB	289	st->ss->write_bitmap(st, fd2, super);
	290	}
	291	close(fd2);
	292	}
	293	}
	294	array.state \|= (1<<MD_SB_BITMAP_PRESENT);
	295	if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
	296	fprintf(stderr, Name ": failed to set internal bitmap.\n");
	297	return 1;
	298	}
fe80f49b NB	299	} else {
	300	int uuid[4];
	301	int bitmap_fd;
	302	int d;
	303	int max_devs = st->max_devs;
	304	void *super = NULL;
	305	if (chunk == UnSet)
	306	chunk = DEFAULT_BITMAP_CHUNK;
	307
	308	/* try to load a superblock */
	309	for (d=0; d<max_devs; d++) {
	310	mdu_disk_info_t disk;
	311	char *dv;
	312	int fd2;
	313	disk.number = d;
	314	if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
	315	continue;
	316	if ((disk.major==0 && disk.minor==0) \|\|
	317	(disk.state & (1<<MD_DISK_REMOVED)))
	318	continue;
	319	dv = map_dev(disk.major, disk.minor);
	320	if (!dv) continue;
	321	fd2 = open(dv, O_RDONLY);
	322	if (fd2 >= 0 &&
	323	st->ss->load_super(st, fd2, &super, NULL) == 0) {
	324	close(fd2);
	325	st->ss->uuid_from_super(uuid, super);
	326	break;
	327	}
	328	close(fd2);
	329	}
	330	if (d == max_devs) {
	331	fprintf(stderr, Name ": cannot find UUID for array!\n");
	332	return 1;
	333	}
	334	if (CreateBitmap(file, 0, (char*)uuid, chunk,
dcec9ee5	335	delay, write_behind, array.size*2ULL, major)) {
fe80f49b NB	336	return 1;
	337	}
	338	bitmap_fd = open(file, O_RDWR);
	339	if (bitmap_fd < 0) {
	340	fprintf(stderr, Name ": weird: %s cannot be openned\n",
	341	file);
	342	return 1;
	343	}
	344	if (ioctl(fd, SET_BITMAP_FILE, bitmap_fd) < 0) {
	345	fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
	346	devname, strerror(errno));
	347	return 1;
	348	}
	349	}
f5e166fe NB	350
	351	return 0;
	352	}
	353
	354