New upstream release.

1 files changed, 547 insertions, 345 deletions

diff --git a/Grow.c b/Grow.c
index 455c5f90..87229692 100755..100644
--- a/Grow.c
+++ b/Grow.c
@@ -58,9 +58,8 @@ int restore_backup(struct supertype *st,
 	for (dev = content->devs; dev; dev = dev->next) {
 		char buf[22];
 		int fd;
-		sprintf(buf, "%d:%d",
-			dev->disk.major,
-			dev->disk.minor);
+
+		sprintf(buf, "%d:%d", dev->disk.major, dev->disk.minor);
 		fd = dev_open(buf, O_RDWR);
 
 		if (dev->disk.raid_disk >= 0)
@@ -109,13 +108,13 @@ int Grow_Add_device(char *devname, int fd, char *newdev)
 	 */
 	struct mdinfo info;
 
-	struct stat stb;
+	dev_t rdev;
 	int nfd, fd2;
 	int d, nd;
 	struct supertype *st = NULL;
 	char *subarray = NULL;
 
-	if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
+	if (md_get_array_info(fd, &info.array) < 0) {
 		pr_err("cannot get array info for %s\n", devname);
 		return 1;
 	}
@@ -145,9 +144,7 @@ int Grow_Add_device(char *devname, int fd, char *newdev)
 		free(st);
 		return 1;
 	}
-	fstat(nfd, &stb);
-	if ((stb.st_mode & S_IFMT) != S_IFBLK) {
-		pr_err("%s is not a block device!\n", newdev);
+	if (!fstat_is_blkdev(nfd, newdev, &rdev)) {
 		close(nfd);
 		free(st);
 		return 1;
@@ -161,17 +158,15 @@ int Grow_Add_device(char *devname, int fd, char *newdev)
 		st->ss->free_super(st);
 
 		disk.number = d;
-		if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
-			pr_err("cannot get device detail for device %d\n",
-				d);
+		if (md_get_disk_info(fd, &disk) < 0) {
+			pr_err("cannot get device detail for device %d\n", d);
 			close(nfd);
 			free(st);
 			return 1;
 		}
 		dv = map_dev(disk.major, disk.minor, 1);
 		if (!dv) {
-			pr_err("cannot find device file for device %d\n",
-				d);
+			pr_err("cannot find device file for device %d\n", d);
 			close(nfd);
 			free(st);
 			return 1;
@@ -198,16 +193,14 @@ int Grow_Add_device(char *devname, int fd, char *newdev)
 	 */
 
 	info.disk.number = d;
-	info.disk.major = major(stb.st_rdev);
-	info.disk.minor = minor(stb.st_rdev);
+	info.disk.major = major(rdev);
+	info.disk.minor = minor(rdev);
 	info.disk.raid_disk = d;
 	info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
-	st->ss->update_super(st, &info, "linear-grow-new", newdev,
-			     0, 0, NULL);
+	st->ss->update_super(st, &info, "linear-grow-new", newdev, 0, 0, NULL);
 
 	if (st->ss->store_super(st, nfd)) {
-		pr_err("Cannot store new superblock on %s\n",
-			newdev);
+		pr_err("Cannot store new superblock on %s\n", newdev);
 		close(nfd);
 		return 1;
 	}
@@ -221,7 +214,7 @@ int Grow_Add_device(char *devname, int fd, char *newdev)
 	 * Now go through and update all superblocks
 	 */
 
-	if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
+	if (md_get_array_info(fd, &info.array) < 0) {
 		pr_err("cannot get array info for %s\n", devname);
 		return 1;
 	}
@@ -232,15 +225,13 @@ int Grow_Add_device(char *devname, int fd, char *newdev)
 		char *dv;
 
 		disk.number = d;
-		if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
-			pr_err("cannot get device detail for device %d\n",
-				d);
+		if (md_get_disk_info(fd, &disk) < 0) {
+			pr_err("cannot get device detail for device %d\n", d);
 			return 1;
 		}
 		dv = map_dev(disk.major, disk.minor, 1);
 		if (!dv) {
-			pr_err("cannot find device file for device %d\n",
-				d);
+			pr_err("cannot find device file for device %d\n", d);
 			return 1;
 		}
 		fd2 = dev_open(dv, O_RDWR);
@@ -288,14 +279,8 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 	struct supertype *st;
 	char *subarray = NULL;
 	int major = BITMAP_MAJOR_HI;
-	int vers = md_get_version(fd);
 	unsigned long long bitmapsize, array_size;
-
-	if (vers < 9003) {
-		major = BITMAP_MAJOR_HOSTENDIAN;
-		pr_err("Warning - bitmaps created on this kernel are not portable\n"
-			"  between different architectures.  Consider upgrading the Linux kernel.\n");
-	}
+	struct mdinfo *mdi;
 
 	/*
 	 * We only ever get called if s->bitmap_file is != NULL, so this check
@@ -323,18 +308,17 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 			}
 			return 0;
 		}
-		pr_err("%s already has a bitmap (%s)\n",
-			devname, bmf.pathname);
+		pr_err("%s already has a bitmap (%s)\n", devname, bmf.pathname);
 		return 1;
 	}
-	if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
+	if (md_get_array_info(fd, &array) != 0) {
 		pr_err("cannot get array status for %s\n", devname);
 		return 1;
 	}
 	if (array.state & (1 << MD_SB_BITMAP_PRESENT)) {
 		if (strcmp(s->bitmap_file, "none")==0) {
 			array.state &= ~(1 << MD_SB_BITMAP_PRESENT);
-			if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+			if (md_set_array_info(fd, &array) != 0) {
 				if (array.state & (1 << MD_SB_CLUSTERED))
 					pr_err("failed to remove clustered bitmap.\n");
 				else
@@ -375,6 +359,12 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 
 		ncopies = (array.layout & 255) * ((array.layout >> 8) & 255);
 		bitmapsize = bitmapsize * array.raid_disks / ncopies;
+
+		if (strcmp(s->bitmap_file, "clustered") == 0 &&
+		    !is_near_layout_10(array.layout)) {
+			pr_err("only near layout is supported with clustered raid10\n");
+			return 1;
+		}
 	}
 
 	st = super_by_fd(fd, &subarray);
@@ -389,12 +379,23 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 		free(st);
 		return 1;
 	}
+
+	mdi = sysfs_read(fd, NULL, GET_CONSISTENCY_POLICY);
+	if (mdi) {
+		if (mdi->consistency_policy == CONSISTENCY_POLICY_PPL) {
+			pr_err("Cannot add bitmap to array with PPL\n");
+			free(mdi);
+			free(st);
+			return 1;
+		}
+		free(mdi);
+	}
+
 	if (strcmp(s->bitmap_file, "internal") == 0 ||
 	    strcmp(s->bitmap_file, "clustered") == 0) {
 		int rv;
 		int d;
 		int offset_setable = 0;
-		struct mdinfo *mdi;
 		if (st->ss->add_internal_bitmap == NULL) {
 			pr_err("Internal bitmaps not supported with %s metadata\n", st->ss->name);
 			return 1;
@@ -410,7 +411,7 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 			int fd2;
 
 			disk.number = d;
-			if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
+			if (md_get_disk_info(fd, &disk) < 0)
 				continue;
 			if (disk.major == 0 && disk.minor == 0)
 				continue;
@@ -443,14 +444,18 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 		}
 		if (offset_setable) {
 			st->ss->getinfo_super(st, mdi, NULL);
-			sysfs_init(mdi, fd, NULL);
+			if (sysfs_init(mdi, fd, NULL)) {
+				pr_err("failed to intialize sysfs.\n");
+				free(mdi);
+			}
 			rv = sysfs_set_num_signed(mdi, NULL, "bitmap/location",
 						  mdi->bitmap_offset);
+			free(mdi);
 		} else {
 			if (strcmp(s->bitmap_file, "clustered") == 0)
 				array.state |= (1 << MD_SB_CLUSTERED);
 			array.state |= (1 << MD_SB_BITMAP_PRESENT);
-			rv = ioctl(fd, SET_ARRAY_INFO, &array);
+			rv = md_set_array_info(fd, &array);
 		}
 		if (rv < 0) {
 			if (errno == EBUSY)
@@ -470,7 +475,7 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 			char *dv;
 			int fd2;
 			disk.number = d;
-			if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
+			if (md_get_disk_info(fd, &disk) < 0)
 				continue;
 			if ((disk.major==0 && disk.minor == 0) ||
 			    (disk.state & (1 << MD_DISK_REMOVED)))
@@ -515,6 +520,190 @@ int Grow_addbitmap(char *devname, int fd, struct context *c, struct shape *s)
 	return 0;
 }
 
+int Grow_consistency_policy(char *devname, int fd, struct context *c, struct shape *s)
+{
+	struct supertype *st;
+	struct mdinfo *sra;
+	struct mdinfo *sd;
+	char *subarray = NULL;
+	int ret = 0;
+	char container_dev[PATH_MAX];
+	char buf[20];
+
+	if (s->consistency_policy != CONSISTENCY_POLICY_RESYNC &&
+	    s->consistency_policy != CONSISTENCY_POLICY_PPL) {
+		pr_err("Operation not supported for consistency policy %s\n",
+		       map_num(consistency_policies, s->consistency_policy));
+		return 1;
+	}
+
+	st = super_by_fd(fd, &subarray);
+	if (!st)
+		return 1;
+
+	sra = sysfs_read(fd, NULL, GET_CONSISTENCY_POLICY|GET_LEVEL|
+				   GET_DEVS|GET_STATE);
+	if (!sra) {
+		ret = 1;
+		goto free_st;
+	}
+
+	if (s->consistency_policy == CONSISTENCY_POLICY_PPL &&
+	    !st->ss->write_init_ppl) {
+		pr_err("%s metadata does not support PPL\n", st->ss->name);
+		ret = 1;
+		goto free_info;
+	}
+
+	if (sra->array.level != 5) {
+		pr_err("Operation not supported for array level %d\n",
+				sra->array.level);
+		ret = 1;
+		goto free_info;
+	}
+
+	if (sra->consistency_policy == (unsigned)s->consistency_policy) {
+		pr_err("Consistency policy is already %s\n",
+		       map_num(consistency_policies, s->consistency_policy));
+		ret = 1;
+		goto free_info;
+	} else if (sra->consistency_policy != CONSISTENCY_POLICY_RESYNC &&
+		   sra->consistency_policy != CONSISTENCY_POLICY_PPL) {
+		pr_err("Current consistency policy is %s, cannot change to %s\n",
+		       map_num(consistency_policies, sra->consistency_policy),
+		       map_num(consistency_policies, s->consistency_policy));
+		ret = 1;
+		goto free_info;
+	}
+
+	if (s->consistency_policy == CONSISTENCY_POLICY_PPL) {
+		if (sysfs_get_str(sra, NULL, "sync_action", buf, 20) <= 0) {
+			ret = 1;
+			goto free_info;
+		} else if (strcmp(buf, "reshape\n") == 0) {
+			pr_err("PPL cannot be enabled when reshape is in progress\n");
+			ret = 1;
+			goto free_info;
+		}
+	}
+
+	if (subarray) {
+		char *update;
+
+		if (s->consistency_policy == CONSISTENCY_POLICY_PPL)
+			update = "ppl";
+		else
+			update = "no-ppl";
+
+		sprintf(container_dev, "/dev/%s", st->container_devnm);
+
+		ret = Update_subarray(container_dev, subarray, update, NULL,
+				      c->verbose);
+		if (ret)
+			goto free_info;
+	}
+
+	if (s->consistency_policy == CONSISTENCY_POLICY_PPL) {
+		struct mdinfo info;
+
+		if (subarray) {
+			struct mdinfo *mdi;
+			int cfd;
+
+			cfd = open(container_dev, O_RDWR|O_EXCL);
+			if (cfd < 0) {
+				pr_err("Failed to open %s\n", container_dev);
+				ret = 1;
+				goto free_info;
+			}
+
+			ret = st->ss->load_container(st, cfd, st->container_devnm);
+			close(cfd);
+
+			if (ret) {
+				pr_err("Cannot read superblock for %s\n",
+				       container_dev);
+				goto free_info;
+			}
+
+			mdi = st->ss->container_content(st, subarray);
+			info = *mdi;
+			free(mdi);
+		}
+
+		for (sd = sra->devs; sd; sd = sd->next) {
+			int dfd;
+			char *devpath;
+
+			devpath = map_dev(sd->disk.major, sd->disk.minor, 0);
+			dfd = dev_open(devpath, O_RDWR);
+			if (dfd < 0) {
+				pr_err("Failed to open %s\n", devpath);
+				ret = 1;
+				goto free_info;
+			}
+
+			if (!subarray) {
+				ret = st->ss->load_super(st, dfd, NULL);
+				if (ret) {
+					pr_err("Failed to load super-block.\n");
+					close(dfd);
+					goto free_info;
+				}
+
+				ret = st->ss->update_super(st, sra, "ppl",
+							   devname,
+							   c->verbose, 0, NULL);
+				if (ret) {
+					close(dfd);
+					st->ss->free_super(st);
+					goto free_info;
+				}
+				st->ss->getinfo_super(st, &info, NULL);
+			}
+
+			ret |= sysfs_set_num(sra, sd, "ppl_sector",
+					     info.ppl_sector);
+			ret |= sysfs_set_num(sra, sd, "ppl_size",
+					     info.ppl_size);
+
+			if (ret) {
+				pr_err("Failed to set PPL attributes for %s\n",
+				       sd->sys_name);
+				close(dfd);
+				st->ss->free_super(st);
+				goto free_info;
+			}
+
+			ret = st->ss->write_init_ppl(st, &info, dfd);
+			if (ret)
+				pr_err("Failed to write PPL\n");
+
+			close(dfd);
+
+			if (!subarray)
+				st->ss->free_super(st);
+
+			if (ret)
+				goto free_info;
+		}
+	}
+
+	ret = sysfs_set_str(sra, NULL, "consistency_policy",
+			    map_num(consistency_policies,
+				    s->consistency_policy));
+	if (ret)
+		pr_err("Failed to change array consistency policy\n");
+
+free_info:
+	sysfs_free(sra);
+free_st:
+	free(st);
+	free(subarray);
+
+	return ret;
+}
+
 /*
  * When reshaping an array we might need to backup some data.
  * This is written to all spares with a 'super_block' describing it.
@@ -634,8 +823,8 @@ static void unfreeze(struct supertype *st)
 		char buf[20];
 
 		if (sra &&
-		    sysfs_get_str(sra, NULL, "sync_action", buf, 20) > 0
-		    && strcmp(buf, "frozen\n") == 0)
+		    sysfs_get_str(sra, NULL, "sync_action", buf, 20) > 0 &&
+		    strcmp(buf, "frozen\n") == 0)
 			sysfs_set_str(sra, NULL, "sync_action", "idle");
 		sysfs_free(sra);
 	}
@@ -663,8 +852,7 @@ static int reshape_super(struct supertype *st, unsigned long long size,
 	/* nothing extra to check in the native case */
 	if (!st->ss->external)
 		return 0;
-	if (!st->ss->reshape_super ||
-	    !st->ss->manage_reshape) {
+	if (!st->ss->reshape_super || !st->ss->manage_reshape) {
 		pr_err("%s metadata does not support reshape\n",
 			st->ss->name);
 		return 1;
@@ -742,7 +930,8 @@ int start_reshape(struct mdinfo *sra, int already_running,
 	if (!already_running && err == 0) {
 		int cnt = 5;
 		do {
-			err = sysfs_set_str(sra, NULL, "sync_action", "reshape");
+			err = sysfs_set_str(sra, NULL, "sync_action",
+					    "reshape");
 			if (err)
 				sleep(1);
 		} while (err && errno == EBUSY && cnt-- > 0);
@@ -901,10 +1090,8 @@ int reshape_prepare_fdlist(char *devname,
 			continue;
 		if (sd->disk.state & (1<<MD_DISK_SYNC) &&
 		    sd->disk.raid_disk < raid_disks) {
-			char *dn = map_dev(sd->disk.major,
-					   sd->disk.minor, 1);
-			fdlist[sd->disk.raid_disk]
-				= dev_open(dn, O_RDONLY);
+			char *dn = map_dev(sd->disk.major, sd->disk.minor, 1);
+			fdlist[sd->disk.raid_disk] = dev_open(dn, O_RDONLY);
 			offsets[sd->disk.raid_disk] = sd->data_offset*512;
 			if (fdlist[sd->disk.raid_disk] < 0) {
 				pr_err("%s: cannot open component %s\n",
@@ -914,8 +1101,7 @@ int reshape_prepare_fdlist(char *devname,
 			}
 		} else if (backup_file == NULL) {
 			/* spare */
-			char *dn = map_dev(sd->disk.major,
-					   sd->disk.minor, 1);
+			char *dn = map_dev(sd->disk.major, sd->disk.minor, 1);
 				fdlist[d] = dev_open(dn, O_RDWR);
 				offsets[d] = (sd->data_offset + sra->component_size - blocks - 8)*512;
 				if (fdlist[d] < 0) {
@@ -1084,8 +1270,7 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 		 * raid5 with 2 disks, or
 		 * raid0 with 1 disk
 		 */
-		if (info->new_level > 1 &&
-		    (info->component_size & 7))
+		if (info->new_level > 1 && (info->component_size & 7))
 			return "Cannot convert RAID1 of this size - reduce size to multiple of 4K first.";
 		if (info->new_level == 0) {
 			if (info->delta_disks != UnSet &&
@@ -1103,12 +1288,9 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 			re->level = 1;
 			return NULL;
 		}
-		if (info->array.raid_disks != 2 &&
-		    info->new_level == 5)
+		if (info->array.raid_disks != 2 && info->new_level == 5)
 			return "Can only convert a 2-device array to RAID5";
-		if (info->array.raid_disks == 2 &&
-		    info->new_level == 5) {
-
+		if (info->array.raid_disks == 2 && info->new_level == 5) {
 			re->level = 5;
 			re->before.data_disks = 1;
 			if (info->delta_disks != UnSet &&
@@ -1138,17 +1320,22 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 		case 0:
 			if ((info->array.layout & ~0xff) != 0x100)
 				return "Cannot Grow RAID10 with far/offset layout";
-			/* number of devices must be multiple of number of copies */
-			if (info->array.raid_disks % (info->array.layout & 0xff))
+			/*
+			 * number of devices must be multiple of
+			 * number of copies
+			 */
+			if (info->array.raid_disks %
+			    (info->array.layout & 0xff))
 				return "RAID10 layout too complex for Grow operation";
 
-			new_disks = (info->array.raid_disks
-				     / (info->array.layout & 0xff));
+			new_disks = (info->array.raid_disks /
+				     (info->array.layout & 0xff));
 			if (info->delta_disks == UnSet)
 				info->delta_disks = (new_disks
 						     - info->array.raid_disks);
 
-			if (info->delta_disks != new_disks - info->array.raid_disks)
+			if (info->delta_disks !=
+			    new_disks - info->array.raid_disks)
 				return "New number of raid-devices impossible for RAID10";
 			if (info->new_chunk &&
 			    info->new_chunk != info->array.chunk_size)
@@ -1219,7 +1406,8 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 	case 0:
 		/* RAID0 can be converted to RAID10, or to RAID456 */
 		if (info->new_level == 10) {
-			if (info->new_layout == UnSet && info->delta_disks == UnSet) {
+			if (info->new_layout == UnSet &&
+			    info->delta_disks == UnSet) {
 				/* Assume near=2 layout */
 				info->new_layout = 0x102;
 				info->delta_disks = info->array.raid_disks;
@@ -1227,8 +1415,8 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 			if (info->new_layout == UnSet) {
 				int copies = 1 + (info->delta_disks
 						  / info->array.raid_disks);
-				if (info->array.raid_disks * (copies-1)
-				    != info->delta_disks)
+				if (info->array.raid_disks * (copies-1) !=
+				    info->delta_disks)
 					return "Impossible number of devices for RAID0->RAID10";
 				info->new_layout = 0x100 + copies;
 			}
@@ -1432,7 +1620,8 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 					 * can leave it unchanged, else we must
 					 * fail
 					 */
-					ls = map_num(r6layout, info->new_layout);
+					ls = map_num(r6layout,
+						     info->new_layout);
 					if (!ls ||
 					    strcmp(ls+strlen(ls)-2, "-6") != 0)
 						return "Please specify new layout";
@@ -1458,16 +1647,19 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 	if (info->delta_disks == UnSet)
 		info->delta_disks = delta_parity;
 
-	re->after.data_disks = (re->before.data_disks
-				+ info->delta_disks
-				- delta_parity);
+	re->after.data_disks =
+		(re->before.data_disks + info->delta_disks - delta_parity);
+
 	switch (re->level) {
-	case 6: re->parity = 2;
+	case 6:
+		re->parity = 2;
 		break;
 	case 4:
-	case 5: re->parity = 1;
+	case 5:
+		re->parity = 1;
 		break;
-	default: re->parity = 0;
+	default:
+		re->parity = 0;
 		break;
 	}
 	/* So we have a restripe operation, we need to calculate the number
@@ -1501,8 +1693,7 @@ char *analyse_change(char *devname, struct mdinfo *info, struct reshape *re)
 
 	re->backup_blocks = compute_backup_blocks(
 		info->new_chunk, info->array.chunk_size,
-		re->after.data_disks,
-		re->before.data_disks);
+		re->after.data_disks, re->before.data_disks);
 	re->min_offset_change = re->backup_blocks / re->before.data_disks;
 
 	re->new_size = info->component_size * re->after.data_disks;
@@ -1521,12 +1712,11 @@ static int set_array_size(struct supertype *st, struct mdinfo *sra,
 
 	if (text_version == NULL)
 		text_version = sra->text_version;
-	subarray = strchr(text_version+1, '/')+1;
+	subarray = strchr(text_version + 1, '/')+1;
 	info = st->ss->container_content(st, subarray);
 	if (info) {
 		unsigned long long current_size = 0;
-		unsigned long long new_size =
-			info->custom_array_size/2;
+		unsigned long long new_size = info->custom_array_size/2;
 
 		if (sysfs_get_ll(sra, NULL, "array_size", &current_size) == 0 &&
 		    new_size > current_size) {
@@ -1599,13 +1789,18 @@ int Grow_reshape(char *devname, int fd,
 	struct mdinfo info;
 	struct mdinfo *sra;
 
-	if (ioctl(fd, GET_ARRAY_INFO, &array) < 0) {
+	if (md_get_array_info(fd, &array) < 0) {
 		pr_err("%s is not an active md array - aborting\n",
 			devname);
 		return 1;
 	}
-	if (data_offset != INVALID_SECTORS && array.level != 10
-	    && (array.level < 4 || array.level > 6)) {
+	if (s->level != UnSet && s->chunk) {
+		pr_err("Cannot change array level in the same operation as changing chunk size.\n");
+		return 1;
+	}
+
+	if (data_offset != INVALID_SECTORS && array.level != 10 &&
+	    (array.level < 4 || array.level > 6)) {
 		pr_err("--grow --data-offset not yet supported\n");
 		return 1;
 	}
@@ -1617,14 +1812,20 @@ int Grow_reshape(char *devname, int fd,
 		return 1;
 	}
 
-	if (s->raiddisks && s->raiddisks < array.raid_disks && array.level > 1 &&
-	    get_linux_version() < 2006032 &&
+	if (s->raiddisks && s->raiddisks < array.raid_disks &&
+	    array.level > 1 && get_linux_version() < 2006032 &&
 	    !check_env("MDADM_FORCE_FEWER")) {
 		pr_err("reducing the number of devices is not safe before Linux 2.6.32\n"
 			"       Please use a newer kernel\n");
 		return 1;
 	}
 
+	if (array.level > 1 && s->size > 1 &&
+	    (array.chunk_size / 1024) > (int)s->size) {
+		pr_err("component size must be larger than chunk size.\n");
+		return 1;
+	}
+
 	st = super_by_fd(fd, &subarray);
 	if (!st) {
 		pr_err("Unable to determine metadata format for %s\n", devname);
@@ -1638,7 +1839,7 @@ int Grow_reshape(char *devname, int fd,
 	    (array.state & (1<<MD_SB_BITMAP_PRESENT)) &&
 	    !(array.state & (1<<MD_SB_CLUSTERED))) {
                 array.state &= ~(1<<MD_SB_BITMAP_PRESENT);
-                if (ioctl(fd, SET_ARRAY_INFO, &array)!= 0) {
+                if (md_set_array_info(fd, &array)!= 0) {
                         pr_err("failed to remove internal bitmap.\n");
                         return 1;
                 }
@@ -1649,7 +1850,7 @@ int Grow_reshape(char *devname, int fd,
 	 * pre-requisite spare devices (mdmon owns final validation)
 	 */
 	if (st->ss->external) {
-		int rv;
+		int retval;
 
 		if (subarray) {
 			container = st->container_devnm;
@@ -1661,17 +1862,15 @@ int Grow_reshape(char *devname, int fd,
 			fd = cfd;
 		}
 		if (cfd < 0) {
-			pr_err("Unable to open container for %s\n",
-				devname);
+			pr_err("Unable to open container for %s\n", devname);
 			free(subarray);
 			return 1;
 		}
 
-		rv = st->ss->load_container(st, cfd, NULL);
+		retval = st->ss->load_container(st, cfd, NULL);
 
-		if (rv) {
-			pr_err("Cannot read superblock for %s\n",
-				devname);
+		if (retval) {
+			pr_err("Cannot read superblock for %s\n", devname);
 			free(subarray);
 			return 1;
 		}
@@ -1688,10 +1887,11 @@ int Grow_reshape(char *devname, int fd,
 				/* check if reshape is allowed based on metadata
 				 * indications stored in content.array.status
 				 */
-				if (content->array.state & (1<<MD_SB_BLOCK_VOLUME))
+				if (content->array.state &
+				    (1 << MD_SB_BLOCK_VOLUME))
 					allow_reshape = 0;
-				if (content->array.state
-				    & (1<<MD_SB_BLOCK_CONTAINER_RESHAPE))
+				if (content->array.state &
+				    (1 << MD_SB_BLOCK_CONTAINER_RESHAPE))
 					allow_reshape = 0;
 				if (!allow_reshape) {
 					pr_err("cannot reshape arrays in container with unsupported metadata: %s(%s)\n",
@@ -1700,6 +1900,13 @@ int Grow_reshape(char *devname, int fd,
 					free(subarray);
 					return 1;
 				}
+				if (content->consistency_policy ==
+				    CONSISTENCY_POLICY_PPL) {
+					pr_err("Operation not supported when ppl consistency policy is enabled\n");
+					sysfs_free(cc);
+					free(subarray);
+					return 1;
+				}
 			}
 			sysfs_free(cc);
 		}
@@ -1711,7 +1918,8 @@ int Grow_reshape(char *devname, int fd,
 	for (dv = devlist; dv; dv = dv->next)
 		added_disks++;
 	if (s->raiddisks > array.raid_disks &&
-	    array.spare_disks +added_disks < (s->raiddisks - array.raid_disks) &&
+	    array.spare_disks + added_disks <
+	    (s->raiddisks - array.raid_disks) &&
 	    !c->force) {
 		pr_err("Need %d spare%s to avoid degraded array, and only have %d.\n"
 		       "       Use --force to over-ride this check.\n",
@@ -1721,8 +1929,8 @@ int Grow_reshape(char *devname, int fd,
 		return 1;
 	}
 
-	sra = sysfs_read(fd, NULL, GET_LEVEL | GET_DISKS | GET_DEVS
-			 | GET_STATE | GET_VERSION);
+	sra = sysfs_read(fd, NULL, GET_LEVEL | GET_DISKS | GET_DEVS |
+			 GET_STATE | GET_VERSION);
 	if (sra) {
 		if (st->ss->external && subarray == NULL) {
 			array.level = LEVEL_CONTAINER;
@@ -1745,7 +1953,8 @@ int Grow_reshape(char *devname, int fd,
 	}
 
 	/* ========= set size =============== */
-	if (s->size > 0 && (s->size == MAX_SIZE || s->size != (unsigned)array.size)) {
+	if (s->size > 0 &&
+	    (s->size == MAX_SIZE || s->size != (unsigned)array.size)) {
 		unsigned long long orig_size = get_component_size(fd)/2;
 		unsigned long long min_csize;
 		struct mdinfo *mdi;
@@ -1761,7 +1970,8 @@ int Grow_reshape(char *devname, int fd,
 		}
 
 		if (reshape_super(st, s->size, UnSet, UnSet, 0, 0, UnSet, NULL,
-				  devname, APPLY_METADATA_CHANGES, c->verbose > 0)) {
+				  devname, APPLY_METADATA_CHANGES,
+				  c->verbose > 0)) {
 			rv = 1;
 			goto release;
 		}
@@ -1780,7 +1990,8 @@ int Grow_reshape(char *devname, int fd,
 						sizeinfo->array.layout,
 						sizeinfo->array.raid_disks);
 				new_size /= data_disks;
-				dprintf("Metadata size correction from %llu to %llu (%llu)\n", orig_size, new_size,
+				dprintf("Metadata size correction from %llu to %llu (%llu)\n",
+					orig_size, new_size,
 					new_size * data_disks);
 				s->size = new_size;
 				sysfs_free(sizeinfo);
@@ -1793,33 +2004,24 @@ int Grow_reshape(char *devname, int fd,
 		 * understands '0' to mean 'max'.
 		 */
 		min_csize = 0;
-		rv = 0;
 		for (mdi = sra->devs; mdi; mdi = mdi->next) {
-			if (sysfs_set_num(sra, mdi, "size",
-					  s->size == MAX_SIZE ? 0 : s->size) < 0) {
-				/* Probably kernel refusing to let us
-				 * reduce the size - not an error.
-				 */
-				break;
-			}
+			sysfs_set_num(sra, mdi, "size",
+				      s->size == MAX_SIZE ? 0 : s->size);
 			if (array.not_persistent == 0 &&
 			    array.major_version == 0 &&
 			    get_linux_version() < 3001000) {
 				/* Dangerous to allow size to exceed 2TB */
 				unsigned long long csize;
-				if (sysfs_get_ll(sra, mdi, "size", &csize) == 0) {
+				if (sysfs_get_ll(sra, mdi, "size",
+						 &csize) == 0) {
 					if (csize >= 2ULL*1024*1024*1024)
 						csize = 2ULL*1024*1024*1024;
-					if ((min_csize == 0 || (min_csize
-								> csize)))
+					if ((min_csize == 0 ||
+					     (min_csize > csize)))
 						min_csize = csize;
 				}
 			}
 		}
-		if (rv) {
-			pr_err("Cannot set size on array members.\n");
-			goto size_change_error;
-		}
 		if (min_csize && s->size > min_csize) {
 			pr_err("Cannot safely make this array use more than 2TB per device on this kernel.\n");
 			rv = 1;
@@ -1834,14 +2036,13 @@ int Grow_reshape(char *devname, int fd,
 		}
 		if (st->ss->external) {
 			if (sra->array.level == 0) {
-				rv = sysfs_set_str(sra, NULL, "level",
-						   "raid5");
+				rv = sysfs_set_str(sra, NULL, "level", "raid5");
 				if (!rv) {
 					raid0_takeover = 1;
 					/* get array parameters after takeover
 					 * to change one parameter at time only
 					 */
-					rv = ioctl(fd, GET_ARRAY_INFO, &array);
+					rv = md_get_array_info(fd, &array);
 				}
 			}
 			/* make sure mdmon is
@@ -1867,7 +2068,7 @@ int Grow_reshape(char *devname, int fd,
 			else
 				rv = -1;
 		} else {
-			rv = ioctl(fd, SET_ARRAY_INFO, &array);
+			rv = md_set_array_info(fd, &array);
 
 			/* manage array size when it is managed externally
 			 */
@@ -1883,7 +2084,7 @@ int Grow_reshape(char *devname, int fd,
 			/* go back to raid0, drop parity disk
 			 */
 			sysfs_set_str(sra, NULL, "level", "raid0");
-			ioctl(fd, GET_ARRAY_INFO, &array);
+			md_get_array_info(fd, &array);
 		}
 
 size_change_error:
@@ -1909,10 +2110,11 @@ size_change_error:
 			 * a backport has been arranged.
 			 */
 			if (sra == NULL ||
-			    sysfs_set_str(sra, NULL, "resync_start", "none") < 0)
+			    sysfs_set_str(sra, NULL, "resync_start",
+					  "none") < 0)
 				pr_err("--assume-clean not supported with --grow on this kernel\n");
 		}
-		ioctl(fd, GET_ARRAY_INFO, &array);
+		md_get_array_info(fd, &array);
 		s->size = get_component_size(fd)/2;
 		if (s->size == 0)
 			s->size = array.size;
@@ -1939,8 +2141,7 @@ size_change_error:
 	    (s->raiddisks == 0 || s->raiddisks == array.raid_disks)) {
 		/* Nothing more to do */
 		if (!changed && c->verbose >= 0)
-			pr_err("%s: no change requested\n",
-				devname);
+			pr_err("%s: no change requested\n", devname);
 		goto release;
 	}
 
@@ -1954,6 +2155,7 @@ size_change_error:
 	     array.layout == ((1 << 8) + 2) && !(array.raid_disks & 1)) ||
 	    (s->level == 0 && array.level == 1 && sra)) {
 		int err;
+
 		err = remove_disks_for_takeover(st, sra, array.layout);
 		if (err) {
 			dprintf("Array cannot be reshaped\n");
@@ -1972,7 +2174,11 @@ size_change_error:
 
 	memset(&info, 0, sizeof(info));
 	info.array = array;
-	sysfs_init(&info, fd, NULL);
+	if (sysfs_init(&info, fd, NULL)) {
+		pr_err("failed to intialize sysfs.\n");
+		rv = 1;
+		goto release;
+	}
 	strcpy(info.text_version, sra->text_version);
 	info.component_size = s->size*2;
 	info.new_level = s->level;
@@ -2078,12 +2284,12 @@ size_change_error:
 			rv =1 ;
 		}
 		if (s->layout_str) {
-			if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
+			if (md_get_array_info(fd, &array) != 0) {
 				dprintf("Cannot get array information.\n");
 				goto release;
 			}
 			array.layout = info.new_layout;
-			if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+			if (md_set_array_info(fd, &array) != 0) {
 				pr_err("failed to set new layout\n");
 				rv = 1;
 			} else if (c->verbose >= 0)
@@ -2104,7 +2310,8 @@ size_change_error:
 			fd = -1;
 		}
 		rv = reshape_container(container, devname, -1, st, &info,
-				       c->force, c->backup_file, c->verbose, 0, 0, 0);
+				       c->force, c->backup_file, c->verbose,
+				       0, 0, 0);
 		frozen = 0;
 	} else {
 		/* get spare devices from external metadata
@@ -2126,15 +2333,15 @@ size_change_error:
 		if (reshape_super(st, 0, info.new_level,
 				  info.new_layout, info.new_chunk,
 				  info.array.raid_disks, info.delta_disks,
-				  c->backup_file, devname, APPLY_METADATA_CHANGES,
-				  c->verbose)) {
+				  c->backup_file, devname,
+				  APPLY_METADATA_CHANGES, c->verbose)) {
 			rv = 1;
 			goto release;
 		}
 		sync_metadata(st);
 		rv = reshape_array(container, fd, devname, st, &info, c->force,
-				   devlist, data_offset, c->backup_file, c->verbose,
-				   0, 0, 0);
+				   devlist, data_offset, c->backup_file,
+				   c->verbose, 0, 0, 0);
 		frozen = 0;
 	}
 release:
@@ -2305,8 +2512,10 @@ static int set_new_data_offset(struct mdinfo *sra, struct supertype *st,
 					dir = -1;
 				else
 					dir = 1;
-			} else if ((data_offset <= info2.data_offset && dir == 1) ||
-				   (data_offset >= info2.data_offset && dir == -1)) {
+			} else if ((data_offset <= info2.data_offset &&
+				    dir == 1) ||
+				   (data_offset >= info2.data_offset &&
+				    dir == -1)) {
 				pr_err("%s: differing data offsets on devices make this --data-offset setting impossible\n",
 					dn);
 				goto release;
@@ -2431,8 +2640,7 @@ static int set_new_data_offset(struct mdinfo *sra, struct supertype *st,
 		}
 		if (err < 0) {
 			if (errno == E2BIG && data_offset != INVALID_SECTORS) {
-				pr_err("data-offset is too big for %s\n",
-				       dn);
+				pr_err("data-offset is too big for %s\n", dn);
 				goto release;
 			}
 			if (sd == sra->devs &&
@@ -2442,8 +2650,7 @@ static int set_new_data_offset(struct mdinfo *sra, struct supertype *st,
 				 * For RAID5/6 this is not fatal
 				 */
 				return 1;
-			pr_err("Cannot set new_offset for %s\n",
-				dn);
+			pr_err("Cannot set new_offset for %s\n", dn);
 			break;
 		}
 	}
@@ -2489,8 +2696,7 @@ static int raid10_reshape(char *container, int fd, char *devname,
 			 GET_COMPONENT|GET_DEVS|GET_OFFSET|GET_STATE|GET_CHUNK
 		);
 	if (!sra) {
-		pr_err("%s: Cannot get array details from sysfs\n",
-			devname);
+		pr_err("%s: Cannot get array details from sysfs\n", devname);
 		goto release;
 	}
 	min = reshape->min_offset_change;
@@ -2498,18 +2704,16 @@ static int raid10_reshape(char *container, int fd, char *devname,
 	if (info->delta_disks)
 		sysfs_set_str(sra, NULL, "reshape_direction",
 			      info->delta_disks < 0 ? "backwards" : "forwards");
-	if (info->delta_disks < 0 &&
-	    info->space_after < min) {
+	if (info->delta_disks < 0 && info->space_after < min) {
 		int rv = sysfs_set_num(sra, NULL, "component_size",
-				       (sra->component_size -
-					min)/2);
+				       (sra->component_size - min)/2);
 		if (rv) {
 			pr_err("cannot reduce component size\n");
 			goto release;
 		}
 	}
-	err = set_new_data_offset(sra, st, devname, info->delta_disks, data_offset,
-				  min, 0);
+	err = set_new_data_offset(sra, st, devname, info->delta_disks,
+				  data_offset, min, 0);
 	if (err == 1) {
 		pr_err("Cannot set new_data_offset: RAID10 reshape not\n");
 		cont_err("supported on this kernel\n");
@@ -2520,10 +2724,12 @@ static int raid10_reshape(char *container, int fd, char *devname,
 
 	if (!err && sysfs_set_num(sra, NULL, "chunk_size", info->new_chunk) < 0)
 		err = errno;
-	if (!err && sysfs_set_num(sra, NULL, "layout", reshape->after.layout) < 0)
+	if (!err && sysfs_set_num(sra, NULL, "layout",
+				  reshape->after.layout) < 0)
 		err = errno;
-	if (!err && sysfs_set_num(sra, NULL, "raid_disks",
-				  info->array.raid_disks + info->delta_disks) < 0)
+	if (!err &&
+	    sysfs_set_num(sra, NULL, "raid_disks",
+			  info->array.raid_disks + info->delta_disks) < 0)
 		err = errno;
 	if (!err && sysfs_set_str(sra, NULL, "sync_action", "reshape") < 0)
 		err = errno;
@@ -2641,14 +2847,13 @@ static int impose_reshape(struct mdinfo *sra,
 						 * reshape->after.data_disks);
 	}
 
-	ioctl(fd, GET_ARRAY_INFO, &array);
+	md_get_array_info(fd, &array);
 	if (info->array.chunk_size == info->new_chunk &&
 	    reshape->before.layout == reshape->after.layout &&
 	    st->ss->external == 0) {
 		/* use SET_ARRAY_INFO but only if reshape hasn't started */
 		array.raid_disks = reshape->after.data_disks + reshape->parity;
-		if (!restart &&
-		    ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+		if (!restart && md_set_array_info(fd, &array) != 0) {
 			int err = errno;
 
 			pr_err("Cannot set device shape for %s: %s\n",
@@ -2675,8 +2880,7 @@ static int impose_reshape(struct mdinfo *sra,
 					     reshape->parity) < 0)
 			err = errno;
 		if (err) {
-			pr_err("Cannot set device shape for %s\n",
-				devname);
+			pr_err("Cannot set device shape for %s\n", devname);
 
 			if (err == EBUSY &&
 			    (array.state & (1<<MD_SB_BITMAP_PRESENT)))
@@ -2694,11 +2898,14 @@ static int impose_level(int fd, int level, char *devname, int verbose)
 	char *c;
 	struct mdu_array_info_s array;
 	struct mdinfo info;
-	sysfs_init(&info, fd, NULL);
 
-	ioctl(fd, GET_ARRAY_INFO, &array);
-	if (level == 0 &&
-	    (array.level >= 4 && array.level <= 6)) {
+	if (sysfs_init(&info, fd, NULL)) {
+		pr_err("failed to intialize sysfs.\n");
+		return  1;
+	}
+
+	md_get_array_info(fd, &array);
+	if (level == 0 && (array.level >= 4 && array.level <= 6)) {
 		/* To convert to RAID0 we need to fail and
 		 * remove any non-data devices. */
 		int found = 0;
@@ -2706,57 +2913,46 @@ static int impose_level(int fd, int level, char *devname, int verbose)
 		int data_disks = array.raid_disks - 1;
 		if (array.level == 6)
 			data_disks -= 1;
-		if (array.level == 5 &&
-		    array.layout != ALGORITHM_PARITY_N)
+		if (array.level == 5 && array.layout != ALGORITHM_PARITY_N)
 			return -1;
-		if (array.level == 6 &&
-		    array.layout != ALGORITHM_PARITY_N_6)
+		if (array.level == 6 && array.layout != ALGORITHM_PARITY_N_6)
 			return -1;
 		sysfs_set_str(&info, NULL,"sync_action", "idle");
 		/* First remove any spares so no recovery starts */
 		for (d = 0, found = 0;
-		     d < MAX_DISKS && found < array.nr_disks;
-		     d++) {
+		     d < MAX_DISKS && found < array.nr_disks; d++) {
 			mdu_disk_info_t disk;
 			disk.number = d;
-			if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
+			if (md_get_disk_info(fd, &disk) < 0)
 				continue;
 			if (disk.major == 0 && disk.minor == 0)
 				continue;
 			found++;
-			if ((disk.state & (1 << MD_DISK_ACTIVE))
-			    && disk.raid_disk < data_disks)
+			if ((disk.state & (1 << MD_DISK_ACTIVE)) &&
+			    disk.raid_disk < data_disks)
 				/* keep this */
 				continue;
 			ioctl(fd, HOT_REMOVE_DISK,
 			      makedev(disk.major, disk.minor));
 		}
 		/* Now fail anything left */
-		ioctl(fd, GET_ARRAY_INFO, &array);
+		md_get_array_info(fd, &array);
 		for (d = 0, found = 0;
-		     d < MAX_DISKS && found < array.nr_disks;
-		     d++) {
-			int cnt;
+		     d < MAX_DISKS && found < array.nr_disks; d++) {
 			mdu_disk_info_t disk;
 			disk.number = d;
-			if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
+			if (md_get_disk_info(fd, &disk) < 0)
 				continue;
 			if (disk.major == 0 && disk.minor == 0)
 				continue;
 			found++;
-			if ((disk.state & (1 << MD_DISK_ACTIVE))
-			    && disk.raid_disk < data_disks)
+			if ((disk.state & (1 << MD_DISK_ACTIVE)) &&
+			    disk.raid_disk < data_disks)
 				/* keep this */
 				continue;
 			ioctl(fd, SET_DISK_FAULTY,
 			      makedev(disk.major, disk.minor));
-			cnt = 5;
-			while (ioctl(fd, HOT_REMOVE_DISK,
-				     makedev(disk.major, disk.minor)) < 0
-			       && errno == EBUSY
-			       && cnt--) {
-				usleep(10000);
-			}
+			hot_remove_disk(fd, makedev(disk.major, disk.minor), 1);
 		}
 	}
 	c = map_num(pers, level);
@@ -2772,8 +2968,7 @@ static int impose_level(int fd, int level, char *devname, int verbose)
 			return err;
 		}
 		if (verbose >= 0)
-			pr_err("level of %s changed to %s\n",
-				devname, c);
+			pr_err("level of %s changed to %s\n", devname, c);
 	}
 	return 0;
 }
@@ -2808,12 +3003,11 @@ static int continue_via_systemd(char *devnm)
 		 */
 		close(2);
 		open("/dev/null", O_WRONLY);
-		snprintf(pathbuf, sizeof(pathbuf), "mdadm-grow-continue@%s.service",
-			 devnm);
-		status = execl("/usr/bin/systemctl", "systemctl",
-			       "start",
+		snprintf(pathbuf, sizeof(pathbuf),
+			 "mdadm-grow-continue@%s.service", devnm);
+		status = execl("/usr/bin/systemctl", "systemctl", "restart",
 			       pathbuf, NULL);
-		status = execl("/bin/systemctl", "systemctl", "start",
+		status = execl("/bin/systemctl", "systemctl", "restart",
 			       pathbuf, NULL);
 		exit(1);
 	case -1: /* Just do it ourselves. */
@@ -2860,7 +3054,7 @@ static int reshape_array(char *container, int fd, char *devname,
 	/* when reshaping a RAID0, the component_size might be zero.
 	 * So try to fix that up.
 	 */
-	if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
+	if (md_get_array_info(fd, &array) != 0) {
 		dprintf("Cannot get array information.\n");
 		goto release;
 	}
@@ -2893,17 +3087,17 @@ static int reshape_array(char *container, int fd, char *devname,
 			pr_err("%s\n", msg);
 		goto release;
 	}
-	if (restart &&
-	    (reshape.level != info->array.level ||
-	     reshape.before.layout != info->array.layout ||
-	     reshape.before.data_disks + reshape.parity
-	     != info->array.raid_disks - max(0, info->delta_disks))) {
+	if (restart && (reshape.level != info->array.level ||
+			reshape.before.layout != info->array.layout ||
+			reshape.before.data_disks + reshape.parity !=
+			info->array.raid_disks - max(0, info->delta_disks))) {
 		pr_err("reshape info is not in native format - cannot continue.\n");
 		goto release;
 	}
 
 	if (st->ss->external && restart && (info->reshape_progress == 0) &&
-	    !((sysfs_get_str(info, NULL, "sync_action", buf, sizeof(buf)) > 0) &&
+	    !((sysfs_get_str(info, NULL, "sync_action",
+			     buf, sizeof(buf)) > 0) &&
 	      (strncmp(buf, "reshape", 7) == 0))) {
 		/* When reshape is restarted from '0', very begin of array
 		 * it is possible that for external metadata reshape and array
@@ -2917,7 +3111,10 @@ static int reshape_array(char *container, int fd, char *devname,
 			restart = 0;
 	}
 	if (restart) {
-		/* reshape already started. just skip to monitoring the reshape */
+		/*
+		 * reshape already started. just skip to monitoring
+		 * the reshape
+		 */
 		if (reshape.backup_blocks == 0)
 			return 0;
 		if (restart & RESHAPE_NO_BACKUP)
@@ -2925,8 +3122,8 @@ static int reshape_array(char *container, int fd, char *devname,
 
 		/* Need 'sra' down at 'started:' */
 		sra = sysfs_read(fd, NULL,
-				 GET_COMPONENT|GET_DEVS|GET_OFFSET|GET_STATE|GET_CHUNK|
-				 GET_CACHE);
+				 GET_COMPONENT|GET_DEVS|GET_OFFSET|GET_STATE|
+				 GET_CHUNK|GET_CACHE);
 		if (!sra) {
 			pr_err("%s: Cannot get array details from sysfs\n",
 			       devname);
@@ -2949,11 +3146,10 @@ static int reshape_array(char *container, int fd, char *devname,
 	for (dv = devlist; dv ; dv=dv->next)
 		added_disks++;
 	spares_needed = max(reshape.before.data_disks,
-			    reshape.after.data_disks)
-		+ reshape.parity - array.raid_disks;
+			    reshape.after.data_disks) +
+		reshape.parity - array.raid_disks;
 
-	if (!force &&
-	    info->new_level > 1 && info->array.level > 1 &&
+	if (!force && info->new_level > 1 && info->array.level > 1 &&
 	    spares_needed > info->array.spare_disks + added_disks) {
 		pr_err("Need %d spare%s to avoid degraded array, and only have %d.\n"
 		       "       Use --force to over-ride this check.\n",
@@ -2969,8 +3165,7 @@ static int reshape_array(char *container, int fd, char *devname,
 	if ((info->new_level > 1 || info->new_level == 0) &&
 	    spares_needed > info->array.spare_disks +added_disks) {
 		pr_err("Need %d spare%s to create working array, and only have %d.\n",
-		       spares_needed,
-		       spares_needed == 1 ? "" : "s",
+		       spares_needed, spares_needed == 1 ? "" : "s",
 		       info->array.spare_disks + added_disks);
 		goto release;
 	}
@@ -2992,8 +3187,7 @@ static int reshape_array(char *container, int fd, char *devname,
 			if (!mdmon_running(container))
 				start_mdmon(container);
 			ping_monitor(container);
-			if (mdmon_running(container) &&
-			    st->update_tail == NULL)
+			if (mdmon_running(container) && st->update_tail == NULL)
 				st->update_tail = &st->updates;
 		}
 	}
@@ -3009,13 +3203,19 @@ static int reshape_array(char *container, int fd, char *devname,
 		struct mdinfo *d;
 
 		if (info2) {
-			sysfs_init(info2, fd, st->devnm);
+			if (sysfs_init(info2, fd, st->devnm)) {
+				pr_err("unable to initialize sysfs for %s\n",
+				       st->devnm);
+				free(info2);
+				goto release;
+			}
 			/* When increasing number of devices, we need to set
 			 * new raid_disks before adding these, or they might
 			 * be rejected.
 			 */
 			if (reshape.backup_blocks &&
-			    reshape.after.data_disks > reshape.before.data_disks)
+			    reshape.after.data_disks >
+			    reshape.before.data_disks)
 				subarray_set_num(container, info2, "raid_disks",
 						 reshape.after.data_disks +
 						 reshape.parity);
@@ -3036,8 +3236,7 @@ static int reshape_array(char *container, int fd, char *devname,
 	 * level and frozen, we can safely add them.
 	 */
 	if (devlist) {
-		if (Manage_subdevs(devname, fd, devlist, verbose,
-				   0, NULL, 0))
+		if (Manage_subdevs(devname, fd, devlist, verbose, 0, NULL, 0))
 			goto release;
 	}
 
@@ -3048,7 +3247,7 @@ static int reshape_array(char *container, int fd, char *devname,
 		 * some more changes: layout, raid_disks, chunk_size
 		 */
 		/* read current array info */
-		if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
+		if (md_get_array_info(fd, &array) != 0) {
 			dprintf("Cannot get array information.\n");
 			goto release;
 		}
@@ -3057,18 +3256,18 @@ static int reshape_array(char *container, int fd, char *devname,
 		if (info->new_layout != UnSet &&
 		    info->new_layout != array.layout) {
 			array.layout = info->new_layout;
-			if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+			if (md_set_array_info(fd, &array) != 0) {
 				pr_err("failed to set new layout\n");
 				goto release;
 			} else if (verbose >= 0)
 				printf("layout for %s set to %d\n",
 				       devname, array.layout);
 		}
-		if (info->delta_disks != UnSet &&
-		    info->delta_disks != 0 &&
-		    array.raid_disks != (info->array.raid_disks + info->delta_disks)) {
+		if (info->delta_disks != UnSet && info->delta_disks != 0 &&
+		    array.raid_disks !=
+		    (info->array.raid_disks + info->delta_disks)) {
 			array.raid_disks += info->delta_disks;
-			if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+			if (md_set_array_info(fd, &array) != 0) {
 				pr_err("failed to set raid disks\n");
 				goto release;
 			} else if (verbose >= 0) {
@@ -3143,8 +3342,7 @@ static int reshape_array(char *container, int fd, char *devname,
 			/* Nothing to do. */
 			return 0;
 		return raid10_reshape(container, fd, devname, st, info,
-				      &reshape, data_offset,
-				      force, verbose);
+				      &reshape, data_offset, force, verbose);
 	}
 	sra = sysfs_read(fd, NULL,
 			 GET_COMPONENT|GET_DEVS|GET_OFFSET|GET_STATE|GET_CHUNK|
@@ -3228,15 +3426,13 @@ started:
 		 * not so big that we reject it below.
 		 * Try for 16 megabytes
 		 */
-		while (blocks * 32 < sra->component_size &&
-		       blocks < 16*1024*2)
+		while (blocks * 32 < sra->component_size && blocks < 16*1024*2)
 			blocks *= 2;
 	} else
 		pr_err("Need to backup %luK of critical section..\n", blocks/2);
 
 	if (blocks >= sra->component_size/2) {
-		pr_err("%s: Something wrong - reshape aborted\n",
-			devname);
+		pr_err("%s: Something wrong - reshape aborted\n", devname);
 		goto release;
 	}
 
@@ -3249,9 +3445,8 @@ started:
 	offsets = xcalloc((1+nrdisks), sizeof(offsets[0]));
 
 	odisks = reshape.before.data_disks + reshape.parity;
-	d = reshape_prepare_fdlist(devname, sra, odisks,
-				   nrdisks, blocks, backup_file,
-				   fdlist, offsets);
+	d = reshape_prepare_fdlist(devname, sra, odisks, nrdisks, blocks,
+				   backup_file, fdlist, offsets);
 	if (d < odisks) {
 		goto release;
 	}
@@ -3272,8 +3467,7 @@ started:
 			if (!reshape_open_backup_file(backup_file, fd, devname,
 						      (signed)blocks,
 						      fdlist+d, offsets+d,
-						      sra->sys_name,
-						      restart)) {
+						      sra->sys_name, restart)) {
 				goto release;
 			}
 			d++;
@@ -3281,8 +3475,8 @@ started:
 	}
 
 	update_cache_size(container, sra, info,
-			  min(reshape.before.data_disks, reshape.after.data_disks),
-			  blocks);
+			  min(reshape.before.data_disks,
+			      reshape.after.data_disks), blocks);
 
 	/* Right, everything seems fine. Let's kick things off.
 	 * If only changing raid_disks, use ioctl, else use
@@ -3298,8 +3492,7 @@ started:
 			    reshape.after.data_disks);
 	if (err) {
 		pr_err("Cannot %s reshape for %s\n",
-		       restart ? "continue" : "start",
-		       devname);
+		       restart ? "continue" : "start", devname);
 		goto release;
 	}
 	if (restart)
@@ -3354,8 +3547,7 @@ started:
 		mds = mdstat_read(1, 0);
 		for (m = mds; m; m = m->next)
 			if (strcmp(m->devnm, sra->sys_name) == 0) {
-				if (m->resync &&
-				    m->percent == RESYNC_DELAYED)
+				if (m->resync && m->percent == RESYNC_DELAYED)
 					delayed = 1;
 				if (m->resync == 0)
 					/* Haven't started the reshape thread
@@ -3387,15 +3579,12 @@ started:
 		/* metadata handler takes it from here */
 		done = st->ss->manage_reshape(
 			fd, sra, &reshape, st, blocks,
-			fdlist, offsets,
-			d - odisks, fdlist+odisks,
-			offsets+odisks);
+			fdlist, offsets, d - odisks, fdlist + odisks,
+			offsets + odisks);
 	} else
 		done = child_monitor(
-			fd, sra, &reshape, st, blocks,
-			fdlist, offsets,
-			d - odisks, fdlist+odisks,
-			offsets+odisks);
+			fd, sra, &reshape, st, blocks, fdlist, offsets,
+			d - odisks, fdlist + odisks, offsets + odisks);
 
 	free(fdlist);
 	free(offsets);
@@ -3421,9 +3610,8 @@ started:
 	}
 
 	if (!st->ss->external &&
-	    !(reshape.before.data_disks != reshape.after.data_disks
-	      && info->custom_array_size) &&
-	    info->new_level == reshape.level &&
+	    !(reshape.before.data_disks != reshape.after.data_disks &&
+	      info->custom_array_size) && info->new_level == reshape.level &&
 	    !forked) {
 		/* no need to wait for the reshape to finish as
 		 * there is nothing more to do.
@@ -3447,8 +3635,7 @@ started:
 	/* set new array size if required customer_array_size is used
 	 * by this metadata.
 	 */
-	if (reshape.before.data_disks !=
-	    reshape.after.data_disks &&
+	if (reshape.before.data_disks != reshape.after.data_disks &&
 	    info->custom_array_size)
 		set_array_size(st, info, info->text_version);
 
@@ -3587,7 +3774,8 @@ int reshape_container(char *container, char *devname,
 
 		fd = open_dev(mdstat->devnm);
 		if (fd < 0) {
-			pr_err("Device %s cannot be opened for reshape.\n", adev);
+			pr_err("Device %s cannot be opened for reshape.\n",
+			       adev);
 			break;
 		}
 
@@ -3608,7 +3796,12 @@ int reshape_container(char *container, char *devname,
 		}
 		strcpy(last_devnm, mdstat->devnm);
 
-		sysfs_init(content, fd, mdstat->devnm);
+		if (sysfs_init(content, fd, mdstat->devnm)) {
+			pr_err("Unable to initialize sysfs for %s\n",
+			       mdstat->devnm);
+			rv = 1;
+			break;
+		}
 
 		if (mdmon_running(container))
 			flush_mdmon(container);
@@ -3769,8 +3962,7 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 			max_progress = backup_point;
 		else
 			max_progress =
-				read_offset *
-				reshape->after.data_disks;
+				read_offset * reshape->after.data_disks;
 	} else {
 		if (read_offset > write_offset - write_range)
 			/* Can only progress as far as has been backed up,
@@ -3785,8 +3977,7 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 			else {
 				/* Can progress until metadata update is required */
 				max_progress =
-					read_offset *
-					reshape->after.data_disks;
+					read_offset * reshape->after.data_disks;
 				/* but data must be suspended */
 				if (max_progress < *suspend_point)
 					max_progress = *suspend_point;
@@ -3815,8 +4006,8 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 	 * a backup.
 	 */
 	if (advancing) {
-		if ((need_backup > info->reshape_progress
-		     || info->array.major_version < 0) &&
+		if ((need_backup > info->reshape_progress ||
+		     info->array.major_version < 0) &&
 		    *suspend_point < info->reshape_progress + target) {
 			if (need_backup < *suspend_point + 2 * target)
 				*suspend_point = need_backup;
@@ -3835,7 +4026,8 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 			    *suspend_point > 0) {
 				*suspend_point = 0;
 				sysfs_set_num(info, NULL, "suspend_lo", 0);
-				sysfs_set_num(info, NULL, "suspend_hi", need_backup);
+				sysfs_set_num(info, NULL, "suspend_hi",
+					      need_backup);
 			}
 		} else {
 			/* Need to suspend continually */
@@ -3866,7 +4058,10 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 	 */
 	/* scale down max_progress to per_disk */
 	max_progress /= reshape->after.data_disks;
-	/* Round to chunk size as some kernels give an erroneously high number */
+	/*
+	 * Round to chunk size as some kernels give an erroneously
+	 * high number
+	 */
 	max_progress /= info->new_chunk/512;
 	max_progress *= info->new_chunk/512;
 	/* And round to old chunk size as the kernel wants that */
@@ -3903,22 +4098,21 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 		 * waiting forever on a dead array
 		 */
 		char action[20];
-		if (sysfs_get_str(info, NULL, "sync_action",
-				  action, 20) <= 0 ||
+		if (sysfs_get_str(info, NULL, "sync_action", action, 20) <= 0 ||
 		    strncmp(action, "reshape", 7) != 0)
 			break;
 		/* Some kernels reset 'sync_completed' to zero
 		 * before setting 'sync_action' to 'idle'.
 		 * So we need these extra tests.
 		 */
-		if (completed == 0 && advancing
-		    && strncmp(action, "idle", 4) == 0
-		    && info->reshape_progress > 0)
+		if (completed == 0 && advancing &&
+		    strncmp(action, "idle", 4) == 0 &&
+		    info->reshape_progress > 0)
 			break;
-		if (completed == 0 && !advancing
-		    && strncmp(action, "idle", 4) == 0
-		    && info->reshape_progress < (info->component_size
-						 * reshape->after.data_disks))
+		if (completed == 0 && !advancing &&
+		    strncmp(action, "idle", 4) == 0 &&
+		    info->reshape_progress <
+		    (info->component_size * reshape->after.data_disks))
 			break;
 		sysfs_wait(fd, NULL);
 		if (sysfs_fd_get_ll(fd, &completed) < 0)
@@ -3931,8 +4125,7 @@ int progress_reshape(struct mdinfo *info, struct reshape *reshape,
 	if (completed == 0) {
 		unsigned long long reshapep;
 		char action[20];
-		if (sysfs_get_str(info, NULL, "sync_action",
-				  action, 20) > 0 &&
+		if (sysfs_get_str(info, NULL, "sync_action", action, 20) > 0 &&
 		    strncmp(action, "idle", 4) == 0 &&
 		    sysfs_get_ll(info, NULL,
 				 "reshape_position", &reshapep) == 0)
@@ -3969,8 +4162,8 @@ check_progress:
 	 * it was just a device failure that leaves us degraded but
 	 * functioning.
 	 */
-	if (sysfs_get_str(info, NULL, "reshape_position", buf, sizeof(buf)) < 0
-	    || strncmp(buf, "none", 4) != 0) {
+	if (sysfs_get_str(info, NULL, "reshape_position", buf,
+			  sizeof(buf)) < 0 || strncmp(buf, "none", 4) != 0) {
 		/* The abort might only be temporary.  Wait up to 10
 		 * seconds for fd to contain a valid number again.
 		 */
@@ -3987,7 +4180,8 @@ check_progress:
 				/* If "sync_max" is no longer max_progress
 				 * we need to freeze things
 				 */
-				sysfs_get_ll(info, NULL, "sync_max", &new_sync_max);
+				sysfs_get_ll(info, NULL, "sync_max",
+					     &new_sync_max);
 				*frozen = (new_sync_max != max_progress);
 				break;
 			case -2: /* read error - abort */
@@ -4002,9 +4196,10 @@ check_progress:
 		/* Maybe racing with array shutdown - check state */
 		if (fd >= 0)
 			close(fd);
-		if (sysfs_get_str(info, NULL, "array_state", buf, sizeof(buf)) < 0
-		    || strncmp(buf, "inactive", 8) == 0
-		    || strncmp(buf, "clear",5) == 0)
+		if (sysfs_get_str(info, NULL, "array_state", buf,
+				  sizeof(buf)) < 0 ||
+		    strncmp(buf, "inactive", 8) == 0 ||
+		    strncmp(buf, "clear",5) == 0)
 			return -2; /* abort */
 		return -1; /* complete */
 	}
@@ -4077,15 +4272,14 @@ static int grow_backup(struct mdinfo *sra,
 		bsb.magic[15] = '2';
 	for (i = 0; i < dests; i++)
 		if (part)
-			lseek64(destfd[i], destoffsets[i] + __le64_to_cpu(bsb.devstart2)*512, 0);
+			lseek64(destfd[i], destoffsets[i] +
+				__le64_to_cpu(bsb.devstart2)*512, 0);
 		else
 			lseek64(destfd[i], destoffsets[i], 0);
 
-	rv = save_stripes(sources, offsets,
-			  disks, chunk, level, layout,
-			  dests, destfd,
-			  offset*512*odata, stripes * chunk * odata,
-			  buf);
+	rv = save_stripes(sources, offsets, disks, chunk, level, layout,
+			  dests, destfd, offset * 512 * odata,
+			  stripes * chunk * odata, buf);
 
 	if (rv)
 		return rv;
@@ -4093,14 +4287,16 @@ static int grow_backup(struct mdinfo *sra,
 	for (i = 0; i < dests; i++) {
 		bsb.devstart = __cpu_to_le64(destoffsets[i]/512);
 
-		bsb.sb_csum = bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb));
+		bsb.sb_csum = bsb_csum((char*)&bsb,
+				       ((char*)&bsb.sb_csum)-((char*)&bsb));
 		if (memcmp(bsb.magic, "md_backup_data-2", 16) == 0)
 			bsb.sb_csum2 = bsb_csum((char*)&bsb,
 						((char*)&bsb.sb_csum2)-((char*)&bsb));
 
 		rv = -1;
-		if ((unsigned long long)lseek64(destfd[i], destoffsets[i] - 4096, 0)
-		    != destoffsets[i] - 4096)
+		if ((unsigned long long)lseek64(destfd[i],
+						destoffsets[i] - 4096, 0) !=
+		    destoffsets[i] - 4096)
 			break;
 		if (write(destfd[i], &bsb, 512) != 512)
 			break;
@@ -4150,15 +4346,15 @@ static int forget_backup(int dests, int *destfd,
 	rv = 0;
 	for (i = 0; i < dests; i++) {
 		bsb.devstart = __cpu_to_le64(destoffsets[i]/512);
-		bsb.sb_csum = bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb));
+		bsb.sb_csum = bsb_csum((char*)&bsb,
+				       ((char*)&bsb.sb_csum)-((char*)&bsb));
 		if (memcmp(bsb.magic, "md_backup_data-2", 16) == 0)
 			bsb.sb_csum2 = bsb_csum((char*)&bsb,
 						((char*)&bsb.sb_csum2)-((char*)&bsb));
 		if ((unsigned long long)lseek64(destfd[i], destoffsets[i]-4096, 0) !=
 		    destoffsets[i]-4096)
 			rv = -1;
-		if (rv == 0 &&
-		    write(destfd[i], &bsb, 512) != 512)
+		if (rv == 0 && write(destfd[i], &bsb, 512) != 512)
 			rv = -1;
 		fsync(destfd[i]);
 	}
@@ -4274,9 +4470,10 @@ int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
 	unsigned long long backup_point, wait_point;
 	unsigned long long reshape_completed;
 	int done = 0;
-	int increasing = reshape->after.data_disks >= reshape->before.data_disks;
-	int part = 0; /* The next part of the backup area to fill.  It may already
-		       * be full, so we need to check */
+	int increasing = reshape->after.data_disks >=
+		reshape->before.data_disks;
+	int part = 0; /* The next part of the backup area to fill.  It
+		       * may already be full, so we need to check */
 	int level = reshape->level;
 	int layout = reshape->before.layout;
 	int data = reshape->before.data_disks;
@@ -4440,11 +4637,9 @@ int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
 			}
 			if (actual_stripes == 0)
 				break;
-			grow_backup(sra, offset, actual_stripes,
-				    fds, offsets,
-				    disks, chunk, level, layout,
-				    dests, destfd, destoffsets,
-				    part, &degraded, buf);
+			grow_backup(sra, offset, actual_stripes, fds, offsets,
+				    disks, chunk, level, layout, dests, destfd,
+				    destoffsets, part, &degraded, buf);
 			validate(afd, destfd[0], destoffsets[0]);
 			/* record where 'part' is up to */
 			part = !part;
@@ -4473,8 +4668,8 @@ int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
  * write that data into the array and update the super blocks with
  * the new reshape_progress
  */
-int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt,
-		 char *backup_file, int verbose)
+int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist,
+		 int cnt, char *backup_file, int verbose)
 {
 	int i, j;
 	int old_disks;
@@ -4483,9 +4678,11 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 	int ndata, odata;
 
 	odata = info->array.raid_disks - info->delta_disks - 1;
-	if (info->array.level == 6) odata--; /* number of data disks */
+	if (info->array.level == 6)
+		odata--; /* number of data disks */
 	ndata = info->array.raid_disks - 1;
-	if (info->new_level == 6) ndata--;
+	if (info->new_level == 6)
+		ndata--;
 
 	old_disks = info->array.raid_disks - info->delta_disks;
 
@@ -4548,24 +4745,30 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 		}
 		if (bsb.sb_csum != bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb))) {
 			if (verbose)
-				pr_err("Bad backup-metadata checksum on %s\n", devname);
+				pr_err("Bad backup-metadata checksum on %s\n",
+				       devname);
 			continue; /* bad checksum */
 		}
 		if (memcmp(bsb.magic, "md_backup_data-2", 16) == 0 &&
 		    bsb.sb_csum2 != bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum2)-((char*)&bsb))) {
 			if (verbose)
-				pr_err("Bad backup-metadata checksum2 on %s\n", devname);
+				pr_err("Bad backup-metadata checksum2 on %s\n",
+				       devname);
 			continue; /* Bad second checksum */
 		}
 		if (memcmp(bsb.set_uuid,info->uuid, 16) != 0) {
 			if (verbose)
-				pr_err("Wrong uuid on backup-metadata on %s\n", devname);
+				pr_err("Wrong uuid on backup-metadata on %s\n",
+				       devname);
 			continue; /* Wrong uuid */
 		}
 
-		/* array utime and backup-mtime should be updated at much the same time, but it seems that
-		 * sometimes they aren't... So allow considerable flexability in matching, and allow
-		 * this test to be overridden by an environment variable.
+		/*
+		 * array utime and backup-mtime should be updated at
+		 * much the same time, but it seems that sometimes
+		 * they aren't... So allow considerable flexability in
+		 * matching, and allow this test to be overridden by
+		 * an environment variable.
 		 */
 		if(time_after(info->array.utime, (unsigned int)__le64_to_cpu(bsb.mtime) + 2*60*60) ||
 		   time_before(info->array.utime, (unsigned int)__le64_to_cpu(bsb.mtime) - 10*60)) {
@@ -4606,8 +4809,7 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 				/* reshape_progress is increasing */
 				if ((__le64_to_cpu(bsb.arraystart)
 				     + __le64_to_cpu(bsb.length)
-				     < info->reshape_progress)
-				    &&
+				     < info->reshape_progress) &&
 				    (__le64_to_cpu(bsb.arraystart2)
 				     + __le64_to_cpu(bsb.length2)
 				     < info->reshape_progress))
@@ -4653,12 +4855,10 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 		}
 		printf("%s: restoring critical section\n", Name);
 
-		if (restore_stripes(fdlist, offsets,
-				    info->array.raid_disks,
-				    info->new_chunk,
-				    info->new_level,
-				    info->new_layout,
-				    fd, __le64_to_cpu(bsb.devstart)*512,
+		if (restore_stripes(fdlist, offsets, info->array.raid_disks,
+				    info->new_chunk, info->new_level,
+				    info->new_layout, fd,
+				    __le64_to_cpu(bsb.devstart)*512,
 				    __le64_to_cpu(bsb.arraystart)*512,
 				    __le64_to_cpu(bsb.length)*512, NULL)) {
 			/* didn't succeed, so giveup */
@@ -4670,12 +4870,10 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 		}
 
 		if (bsb.magic[15] == '2' &&
-		    restore_stripes(fdlist, offsets,
-				    info->array.raid_disks,
-				    info->new_chunk,
-				    info->new_level,
-				    info->new_layout,
-				    fd, __le64_to_cpu(bsb.devstart)*512 +
+		    restore_stripes(fdlist, offsets, info->array.raid_disks,
+				    info->new_chunk, info->new_level,
+				    info->new_layout, fd,
+				    __le64_to_cpu(bsb.devstart)*512 +
 				    __le64_to_cpu(bsb.devstart2)*512,
 				    __le64_to_cpu(bsb.arraystart2)*512,
 				    __le64_to_cpu(bsb.length2)*512, NULL)) {
@@ -4708,15 +4906,16 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 			else
 				lo = lo1;
 		}
-		if (lo < hi &&
-		    (info->reshape_progress < lo ||
-		     info->reshape_progress > hi))
+		if (lo < hi && (info->reshape_progress < lo ||
+				info->reshape_progress > hi))
 			/* backup does not affect reshape_progress*/ ;
 		else if (info->delta_disks >= 0) {
 			info->reshape_progress = __le64_to_cpu(bsb.arraystart) +
 				__le64_to_cpu(bsb.length);
 			if (bsb.magic[15] == '2') {
-				unsigned long long p2 = __le64_to_cpu(bsb.arraystart2) +
+				unsigned long long p2;
+
+				p2 = __le64_to_cpu(bsb.arraystart2) +
 					__le64_to_cpu(bsb.length2);
 				if (p2 > info->reshape_progress)
 					info->reshape_progress = p2;
@@ -4724,7 +4923,9 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 		} else {
 			info->reshape_progress = __le64_to_cpu(bsb.arraystart);
 			if (bsb.magic[15] == '2') {
-				unsigned long long p2 = __le64_to_cpu(bsb.arraystart2);
+				unsigned long long p2;
+
+				p2 = __le64_to_cpu(bsb.arraystart2);
 				if (p2 < info->reshape_progress)
 					info->reshape_progress = p2;
 			}
@@ -4736,8 +4937,7 @@ int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt
 				continue;
 			st->ss->getinfo_super(st, &dinfo, NULL);
 			dinfo.reshape_progress = info->reshape_progress;
-			st->ss->update_super(st, &dinfo,
-					     "_reshape_progress",
+			st->ss->update_super(st, &dinfo, "_reshape_progress",
 					     NULL,0, 0, NULL);
 			st->ss->store_super(st, fdlist[j]);
 			st->ss->free_super(st);
@@ -4798,13 +4998,11 @@ int Grow_continue_command(char *devname, int fd,
 	int cfd = -1;
 	int fd2;
 
-	dprintf("Grow continue from command line called for %s\n",
-		devname);
+	dprintf("Grow continue from command line called for %s\n", devname);
 
 	st = super_by_fd(fd, &subarray);
 	if (!st || !st->ss) {
-		pr_err("Unable to determine metadata format for %s\n",
-		       devname);
+		pr_err("Unable to determine metadata format for %s\n", devname);
 		return 1;
 	}
 	dprintf("Grow continue is run for ");
@@ -4812,12 +5010,14 @@ int Grow_continue_command(char *devname, int fd,
 		int d;
 		int cnt = 5;
 		dprintf_cont("native array (%s)\n", devname);
-		if (ioctl(fd, GET_ARRAY_INFO, &array.array) < 0) {
-			pr_err("%s is not an active md array - aborting\n", devname);
+		if (md_get_array_info(fd, &array.array) < 0) {
+			pr_err("%s is not an active md array - aborting\n",
+			       devname);
 			ret_val = 1;
 			goto Grow_continue_command_exit;
 		}
 		content = &array;
+		sysfs_init(content, fd, NULL);
 		/* Need to load a superblock.
 		 * FIXME we should really get what we need from
 		 * sysfs
@@ -4828,7 +5028,7 @@ int Grow_continue_command(char *devname, int fd,
 				char *dv;
 				int err;
 				disk.number = d;
-				if (ioctl(fd, GET_DISK_INFO, &disk) < 0)
+				if (md_get_disk_info(fd, &disk) < 0)
 					continue;
 				if (disk.major == 0 && disk.minor == 0)
 					continue;
@@ -4882,15 +5082,14 @@ int Grow_continue_command(char *devname, int fd,
 		 */
 		ret_val = st->ss->load_container(st, cfd, NULL);
 		if (ret_val) {
-			pr_err("Cannot read superblock for %s\n",
-			       devname);
+			pr_err("Cannot read superblock for %s\n", devname);
 			ret_val = 1;
 			goto Grow_continue_command_exit;
 		}
 
 		cc = st->ss->container_content(st, subarray);
 		for (content = cc; content ; content = content->next) {
-			char *array;
+			char *array_name;
 			int allow_reshape = 1;
 
 			if (content->reshape_active == 0)
@@ -4915,8 +5114,8 @@ int Grow_continue_command(char *devname, int fd,
 				goto Grow_continue_command_exit;
 			}
 
-			array = strchr(content->text_version+1, '/')+1;
-			mdstat = mdstat_by_subdev(array, container);
+			array_name = strchr(content->text_version+1, '/')+1;
+			mdstat = mdstat_by_subdev(array_name, container);
 			if (!mdstat)
 				continue;
 			if (mdstat->active == 0) {
@@ -4940,7 +5139,13 @@ int Grow_continue_command(char *devname, int fd,
 			goto Grow_continue_command_exit;
 		}
 
-		sysfs_init(content, fd2, mdstat->devnm);
+		if (sysfs_init(content, fd2, mdstat->devnm)) {
+			pr_err("Unable to initialize sysfs for %s, Grow cannot continue.\n",
+			       mdstat->devnm);
+			ret_val = 1;
+			close(fd2);
+			goto Grow_continue_command_exit;
+		}
 
 		close(fd2);
 
@@ -4999,15 +5204,13 @@ int Grow_continue(int mdfd, struct supertype *st, struct mdinfo *info,
 		st->ss->load_container(st, cfd, st->container_devnm);
 		close(cfd);
 		ret_val = reshape_container(st->container_devnm, NULL, mdfd,
-					    st, info, 0, backup_file,
-					    0, forked,
-					    1 | info->reshape_active,
+					    st, info, 0, backup_file, 0,
+					    forked, 1 | info->reshape_active,
 					    freeze_reshape);
 	} else
 		ret_val = reshape_array(NULL, mdfd, "array", st, info, 1,
-					NULL, INVALID_SECTORS,
-					backup_file, 0, forked,
-					1 | info->reshape_active,
+					NULL, INVALID_SECTORS, backup_file,
+					0, forked, 1 | info->reshape_active,
 					freeze_reshape);
 
 	return ret_val;
@@ -5030,8 +5233,7 @@ char *locate_backup(char *name)
 	char *fl = make_backup(name);
 	struct stat stb;
 
-	if (stat(fl, &stb) == 0 &&
-	    S_ISREG(stb.st_mode))
+	if (stat(fl, &stb) == 0 && S_ISREG(stb.st_mode))
 		return fl;
 
 	free(fl);