#define offsetof(t,f) ((size_t)&(((t*)0)->f))
#endif
+int restore_backup(struct supertype *st,
+ struct mdinfo *content,
+ int working_disks,
+ int next_spare,
+ char *backup_file,
+ int verbose)
+{
+ int i;
+ int *fdlist;
+ struct mdinfo *dev;
+ int err;
+ int disk_count = next_spare + working_disks;
+
+ dprintf("Called restore_backup()\n");
+ fdlist = xmalloc(sizeof(int) * disk_count);
+
+ for (i = 0; i < next_spare; i++)
+ fdlist[i] = -1;
+ for (dev = content->devs; dev; dev = dev->next) {
+ char buf[22];
+ int fd;
+ sprintf(buf, "%d:%d",
+ dev->disk.major,
+ dev->disk.minor);
+ fd = dev_open(buf, O_RDWR);
+
+ if (dev->disk.raid_disk >= 0)
+ fdlist[dev->disk.raid_disk] = fd;
+ else
+ fdlist[next_spare++] = fd;
+ }
+
+ if (st->ss->external && st->ss->recover_backup)
+ err = st->ss->recover_backup(st, content);
+ else
+ err = Grow_restart(st, content, fdlist, next_spare,
+ backup_file, verbose > 0);
+
+ while (next_spare > 0) {
+ next_spare--;
+ if (fdlist[next_spare] >= 0)
+ close(fdlist[next_spare]);
+ }
+ free(fdlist);
+ if (err) {
+ pr_err("Failed to restore critical"
+ " section for reshape - sorry.\n");
+ if (!backup_file)
+ pr_err("Possibly you need"
+ " to specify a --backup-file\n");
+ return 1;
+ }
+
+ dprintf("restore_backup() returns status OK.\n");
+ return 0;
+}
+
int Grow_Add_device(char *devname, int fd, char *newdev)
{
/* Add a device to an active array.
char *subarray = NULL;
if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
- fprintf(stderr, Name ": cannot get array info for %s\n", devname);
+ pr_err("cannot get array info for %s\n", devname);
return 1;
}
if (info.array.level != -1) {
- fprintf(stderr, Name ": can only add devices to linear arrays\n");
+ pr_err("can only add devices to linear arrays\n");
return 1;
}
st = super_by_fd(fd, &subarray);
if (!st) {
- fprintf(stderr, Name ": cannot handle arrays with superblock version %d\n", info.array.major_version);
+ pr_err("cannot handle arrays with superblock version %d\n", info.array.major_version);
return 1;
}
if (subarray) {
- fprintf(stderr, Name ": Cannot grow linear sub-arrays yet\n");
+ pr_err("Cannot grow linear sub-arrays yet\n");
free(subarray);
free(st);
+ return 1;
}
nfd = open(newdev, O_RDWR|O_EXCL|O_DIRECT);
if (nfd < 0) {
- fprintf(stderr, Name ": cannot open %s\n", newdev);
+ pr_err("cannot open %s\n", newdev);
free(st);
return 1;
}
fstat(nfd, &stb);
if ((stb.st_mode & S_IFMT) != S_IFBLK) {
- fprintf(stderr, Name ": %s is not a block device!\n", newdev);
+ pr_err("%s is not a block device!\n", newdev);
close(nfd);
free(st);
return 1;
disk.number = d;
if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
- fprintf(stderr, Name ": cannot get device detail for device %d\n",
+ pr_err("cannot get device detail for device %d\n",
d);
close(nfd);
free(st);
}
dv = map_dev(disk.major, disk.minor, 1);
if (!dv) {
- fprintf(stderr, Name ": cannot find device file for device %d\n",
+ pr_err("cannot find device file for device %d\n",
d);
close(nfd);
free(st);
return 1;
}
fd2 = dev_open(dv, O_RDWR);
- if (!fd2) {
- fprintf(stderr, Name ": cannot open device file %s\n", dv);
+ if (fd2 < 0) {
+ pr_err("cannot open device file %s\n", dv);
close(nfd);
free(st);
return 1;
}
if (st->ss->load_super(st, fd2, NULL)) {
- fprintf(stderr, Name ": cannot find super block on %s\n", dv);
+ pr_err("cannot find super block on %s\n", dv);
close(nfd);
close(fd2);
free(st);
0, 0, NULL);
if (st->ss->store_super(st, nfd)) {
- fprintf(stderr, Name ": Cannot store new superblock on %s\n",
+ pr_err("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");
+ pr_err("Cannot add new disk to this array\n");
return 1;
}
/* Well, that seems to have worked.
*/
if (ioctl(fd, GET_ARRAY_INFO, &info.array) < 0) {
- fprintf(stderr, Name ": cannot get array info for %s\n", devname);
+ pr_err("cannot get array info for %s\n", devname);
return 1;
}
disk.number = d;
if (ioctl(fd, GET_DISK_INFO, &disk) < 0) {
- fprintf(stderr, Name ": cannot get device detail for device %d\n",
+ pr_err("cannot get device detail for device %d\n",
d);
return 1;
}
dv = map_dev(disk.major, disk.minor, 1);
if (!dv) {
- fprintf(stderr, Name ": cannot find device file for device %d\n",
+ pr_err("cannot find device file for device %d\n",
d);
return 1;
}
fd2 = dev_open(dv, O_RDWR);
if (fd2 < 0) {
- fprintf(stderr, Name ": cannot open device file %s\n", dv);
+ pr_err("cannot open device file %s\n", dv);
return 1;
}
if (st->ss->load_super(st, fd2, NULL)) {
- fprintf(stderr, Name ": cannot find super block on %s\n", dv);
+ pr_err("cannot find super block on %s\n", dv);
close(fd);
return 1;
}
0, 0, NULL);
if (st->ss->store_super(st, fd2)) {
- fprintf(stderr, Name ": Cannot store new superblock on %s\n", dv);
+ pr_err("Cannot store new superblock on %s\n", dv);
close(fd2);
return 1;
}
if (vers < 9003) {
major = BITMAP_MAJOR_HOSTENDIAN;
- fprintf(stderr, Name ": Warning - bitmaps created on this kernel"
+ pr_err("Warning - bitmaps created on this kernel"
" are not portable\n"
" between different architectures. Consider upgrading"
" the Linux kernel.\n");
if (ioctl(fd, GET_BITMAP_FILE, &bmf) != 0) {
if (errno == ENOMEM)
- fprintf(stderr, Name ": Memory allocation failure.\n");
+ pr_err("Memory allocation failure.\n");
else
- fprintf(stderr, Name ": bitmaps not supported by this kernel.\n");
+ pr_err("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",
+ pr_err("failed to remove bitmap %s\n",
bmf.pathname);
return 1;
}
return 0;
}
- fprintf(stderr, Name ": %s already has a bitmap (%s)\n",
+ pr_err("%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);
+ pr_err("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");
+ pr_err("failed to remove internal bitmap.\n");
return 1;
}
return 0;
}
- fprintf(stderr, Name ": Internal bitmap already present on %s\n",
+ pr_err("Internal bitmap already present on %s\n",
devname);
return 1;
}
if (strcmp(file, "none") == 0) {
- fprintf(stderr, Name ": no bitmap found on %s\n", devname);
+ pr_err("no bitmap found on %s\n", devname);
return 1;
}
if (array.level <= 0) {
- fprintf(stderr, Name ": Bitmaps not meaningful with level %s\n",
+ pr_err("Bitmaps not meaningful with level %s\n",
map_num(pers, array.level)?:"of this array");
return 1;
}
bitmapsize = get_component_size(fd);
}
if (bitmapsize == 0) {
- fprintf(stderr, Name ": Cannot reliably determine size of array to create bitmap - sorry.\n");
+ pr_err("Cannot reliably determine size of array to create bitmap - sorry.\n");
return 1;
}
st = super_by_fd(fd, &subarray);
if (!st) {
- fprintf(stderr, Name ": Cannot understand version %d.%d\n",
+ pr_err("Cannot understand version %d.%d\n",
array.major_version, array.minor_version);
return 1;
}
if (subarray) {
- fprintf(stderr, Name ": Cannot add bitmaps to sub-arrays yet\n");
+ pr_err("Cannot add bitmaps to sub-arrays yet\n");
free(subarray);
free(st);
return 1;
}
if (strcmp(file, "internal") == 0) {
+ int rv;
int d;
+ int offset_setable = 0;
+ struct mdinfo *mdi;
if (st->ss->add_internal_bitmap == NULL) {
- fprintf(stderr, Name ": Internal bitmaps not supported "
+ pr_err("Internal bitmaps not supported "
"with %s metadata\n", st->ss->name);
return 1;
}
+ mdi = sysfs_read(fd, -1, GET_BITMAP_LOCATION);
+ if (mdi)
+ offset_setable = 1;
for (d=0; d< st->max_devs; d++) {
mdu_disk_info_t disk;
char *dv;
if (st->ss->add_internal_bitmap(
st,
&chunk, delay, write_behind,
- bitmapsize, 0, major)
+ bitmapsize, offset_setable,
+ major)
)
st->ss->write_bitmap(st, fd2);
else {
- fprintf(stderr, Name ": failed to create internal bitmap - chunksize problem.\n");
+ pr_err("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) {
+ if (offset_setable) {
+ st->ss->getinfo_super(st, mdi, NULL);
+ sysfs_init(mdi, fd, -1);
+ rv = sysfs_set_num_signed(mdi, NULL, "bitmap/location",
+ mdi->bitmap_offset);
+ } else {
+ array.state |= (1<<MD_SB_BITMAP_PRESENT);
+ rv = ioctl(fd, SET_ARRAY_INFO, &array);
+ }
+ if (rv < 0) {
if (errno == EBUSY)
- fprintf(stderr, Name
- ": Cannot add bitmap while array is"
- " resyncing or reshaping etc.\n");
- fprintf(stderr, Name ": failed to set internal bitmap.\n");
+ pr_err("Cannot add bitmap while array is"
+ " resyncing or reshaping etc.\n");
+ pr_err("failed to set internal bitmap.\n");
return 1;
}
} else {
dv = map_dev(disk.major, disk.minor, 1);
if (!dv) continue;
fd2 = dev_open(dv, O_RDONLY);
- if (fd2 >= 0 &&
- st->ss->load_super(st, fd2, NULL) == 0) {
+ if (fd2 >= 0) {
+ if (st->ss->load_super(st, fd2, NULL) == 0) {
+ close(fd2);
+ st->ss->uuid_from_super(st, uuid);
+ break;
+ }
close(fd2);
- st->ss->uuid_from_super(st, uuid);
- break;
}
- close(fd2);
}
if (d == max_devs) {
- fprintf(stderr, Name ": cannot find UUID for array!\n");
+ pr_err("cannot find UUID for array!\n");
return 1;
}
if (CreateBitmap(file, force, (char*)uuid, chunk,
}
bitmap_fd = open(file, O_RDWR);
if (bitmap_fd < 0) {
- fprintf(stderr, Name ": weird: %s cannot be opened\n",
+ pr_err("weird: %s cannot be opened\n",
file);
return 1;
}
if (ioctl(fd, SET_BITMAP_FILE, bitmap_fd) < 0) {
int err = errno;
if (errno == EBUSY)
- fprintf(stderr, Name
- ": Cannot add bitmap while array is"
- " resyncing or reshaping etc.\n");
- fprintf(stderr, Name ": Cannot set bitmap file for %s: %s\n",
+ pr_err("Cannot add bitmap while array is"
+ " resyncing or reshaping etc.\n");
+ pr_err("Cannot set bitmap file for %s: %s\n",
devname, strerror(err));
return 1;
}
return 0;
}
-
/*
* When reshaping an array we might need to backup some data.
* This is written to all spares with a 'super_block' describing it.
char container[40];
struct mdstat_ent *ent, *e;
int is_idle = 1;
-
+
fmt_devname(container, container_dev);
ent = mdstat_read(0, 0);
for (e = ent ; e; e = e->next) {
if (!check_idle(st))
return -1;
-
+
fmt_devname(container, container_dev);
if (block_monitor(container, 1)) {
- fprintf(stderr, Name ": failed to freeze container\n");
+ pr_err("failed to freeze container\n");
return -2;
}
int container_dev = (st->container_dev != NoMdDev
? st->container_dev : st->devnum);
char container[40];
-
+
fmt_devname(container, container_dev);
unblock_monitor(container, 1);
else {
struct mdinfo *sra = sysfs_read(-1, st->devnum, GET_VERSION);
int err;
+ char buf[20];
if (!sra)
return -1;
+ /* Need to clear any 'read-auto' status */
+ if (sysfs_get_str(sra, NULL, "array_state", buf, 20) > 0 &&
+ strncmp(buf, "read-auto", 9) == 0)
+ sysfs_set_str(sra, NULL, "array_state", "clean");
+
err = sysfs_freeze_array(sra);
sysfs_free(sra);
return err;
if (sra)
sysfs_set_str(sra, NULL, "sync_action", "idle");
- else
- fprintf(stderr, Name ": failed to unfreeze array\n");
sysfs_free(sra);
}
}
static int reshape_super(struct supertype *st, long long size, int level,
int layout, int chunksize, int raid_disks,
int delta_disks, char *backup_file, char *dev,
- int verbose)
+ int direction, int verbose)
{
/* nothing extra to check in the native case */
if (!st->ss->external)
return 0;
if (!st->ss->reshape_super ||
!st->ss->manage_reshape) {
- fprintf(stderr, Name ": %s metadata does not support reshape\n",
+ pr_err("%s metadata does not support reshape\n",
st->ss->name);
return 1;
}
return st->ss->reshape_super(st, size, level, layout, chunksize,
raid_disks, delta_disks, backup_file, dev,
- verbose);
+ direction, verbose);
}
static void sync_metadata(struct supertype *st)
return rc;
}
-int start_reshape(struct mdinfo *sra, int already_running)
+int start_reshape(struct mdinfo *sra, int already_running,
+ int before_data_disks, int data_disks)
{
int err;
+ unsigned long long sync_max_to_set;
+
sysfs_set_num(sra, NULL, "suspend_lo", 0x7FFFFFFFFFFFFFFFULL);
- err = sysfs_set_num(sra, NULL, "suspend_hi", 0);
- err = err ?: sysfs_set_num(sra, NULL, "suspend_lo", 0);
+ err = sysfs_set_num(sra, NULL, "suspend_hi", sra->reshape_progress);
+ err = err ?: sysfs_set_num(sra, NULL, "suspend_lo",
+ sra->reshape_progress);
+ if (before_data_disks <= data_disks)
+ sync_max_to_set = sra->reshape_progress / data_disks;
+ else
+ sync_max_to_set = (sra->component_size * data_disks
+ - sra->reshape_progress) / data_disks;
if (!already_running)
- sysfs_set_num(sra, NULL, "sync_min", 0);
- err = err ?: sysfs_set_num(sra, NULL, "sync_max", 0);
+ sysfs_set_num(sra, NULL, "sync_min", sync_max_to_set);
+ err = err ?: sysfs_set_num(sra, NULL, "sync_max", sync_max_to_set);
if (!already_running)
err = err ?: sysfs_set_str(sra, NULL, "sync_action", "reshape");
= dev_open(dn, O_RDONLY);
offsets[sd->disk.raid_disk] = sd->data_offset*512;
if (fdlist[sd->disk.raid_disk] < 0) {
- fprintf(stderr,
- Name ": %s: cannot open component %s\n",
- devname, dn ? dn : "-unknown-");
+ pr_err("%s: cannot open component %s\n",
+ devname, dn ? dn : "-unknown-");
d = -1;
goto release;
}
fdlist[d] = dev_open(dn, O_RDWR);
offsets[d] = (sd->data_offset + sra->component_size - blocks - 8)*512;
if (fdlist[d] < 0) {
- fprintf(stderr, Name ": %s: cannot open component %s\n",
+ pr_err("%s: cannot open component %s\n",
devname, dn ? dn : "-unknown-");
d = -1;
goto release;
S_IRUSR | S_IWUSR);
*offsets = 8 * 512;
if (*fdlist < 0) {
- fprintf(stderr, Name ": %s: cannot create backup file %s: %s\n",
+ pr_err("%s: cannot create backup file %s: %s\n",
devname, backup_file, strerror(errno));
return 0;
}
dev = stb.st_dev;
fstat(fd, &stb);
if (stb.st_rdev == dev) {
- fprintf(stderr, Name ": backup file must NOT be"
+ pr_err("backup file must NOT be"
" on the array being reshaped.\n");
close(*fdlist);
return 0;
memset(buf, 0, 512);
for (i=0; i < blocks + 8 ; i++) {
if (write(*fdlist, buf, 512) != 512) {
- fprintf(stderr, Name ": %s: cannot create"
+ pr_err("%s: cannot create"
" backup file %s: %s\n",
devname, backup_file, strerror(errno));
return 0;
}
}
if (fsync(*fdlist) != 0) {
- fprintf(stderr, Name ": %s: cannot create backup file %s: %s\n",
+ pr_err("%s: cannot create backup file %s: %s\n",
devname, backup_file, strerror(errno));
return 0;
}
info->new_chunk = info->array.chunk_size;
switch (info->array.level) {
+ default:
+ return "Cannot understand this RAID level";
case 1:
/* RAID1 can convert to RAID1 with different disks, or
* raid5 with 2 disks, or
* raid0 with 1 disk
*/
+ 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 &&
info->delta_disks != 0)
break;
case 5:
- /* We get to RAID5 for RAID5 or RAID6 */
+ /* We get to RAID5 from RAID5 or RAID6 */
if (re->level != 5 && re->level != 6)
return "Cannot convert to RAID5 from this level";
char layout[40];
char *ls = map_num(r5layout, info->new_layout);
int l;
- strcat(strcpy(layout, ls), "-6");
- l = map_name(r6layout, layout);
- if (l == UnSet)
- return "Cannot find RAID6 layout"
- " to convert to";
+ if (ls) {
+ /* Current RAID6 layout has a RAID5
+ * equivalent - good
+ */
+ strcat(strcpy(layout, ls), "-6");
+ l = map_name(r6layout, layout);
+ if (l == UnSet)
+ return "Cannot find RAID6 layout"
+ " to convert to";
+ } else {
+ /* Current RAID6 has no equivalent.
+ * If it is already a '-6' layout we
+ * can leave it unchanged, else we must
+ * fail
+ */
+ ls = map_num(r6layout, info->new_layout);
+ if (!ls ||
+ strcmp(ls+strlen(ls)-2, "-6") != 0)
+ return "Please specify new layout";
+ l = info->new_layout;
+ }
re->after.layout = l;
}
}
if (re->after.data_disks < re->before.data_disks &&
get_linux_version() < 2006030)
- return "reshape to fewer devices is not supported before 2.6.32 - sorry.";
+ return "reshape to fewer devices is not supported before 2.6.30 - sorry.";
re->backup_blocks = compute_backup_blocks(
info->new_chunk, info->array.chunk_size,
return NULL;
}
+static int set_array_size(struct supertype *st, struct mdinfo *sra,
+ char *text_version)
+{
+ struct mdinfo *info;
+ char *subarray;
+ int ret_val = -1;
+
+ if ((st == NULL) || (sra == NULL))
+ return ret_val;
+
+ if (text_version == NULL)
+ text_version = sra->text_version;
+ 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;
+
+ if (sysfs_get_ll(sra, NULL, "array_size", ¤t_size) == 0 &&
+ new_size > current_size) {
+ if (sysfs_set_num(sra, NULL, "array_size", new_size)
+ < 0)
+ dprintf("Error: Cannot set array size");
+ else {
+ ret_val = 0;
+ dprintf("Array size changed");
+ }
+ dprintf(" from %llu to %llu.\n",
+ current_size, new_size);
+ }
+ sysfs_free(info);
+ } else
+ dprintf("Error: set_array_size(): info pointer in NULL\n");
+
+ return ret_val;
+}
+
static int reshape_array(char *container, int fd, char *devname,
struct supertype *st, struct mdinfo *info,
- int force, char *backup_file, int quiet, int forked,
- int restart);
+ int force, struct mddev_dev *devlist,
+ char *backup_file, int quiet, int forked,
+ int restart, int freeze_reshape);
static int reshape_container(char *container, char *devname,
- struct supertype *st,
+ int mdfd,
+ struct supertype *st,
struct mdinfo *info,
int force,
char *backup_file,
- int quiet, int restart);
+ int quiet, int restart, int freeze_reshape);
int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
long long size,
int level, char *layout_str, int chunksize, int raid_disks,
- int force)
+ struct mddev_dev *devlist,
+ int assume_clean, int force)
{
/* Make some changes in the shape of an array.
* The kernel must support the change.
char container_buf[20];
int cfd = -1;
+ struct mddev_dev *dv;
+ int added_disks;
+
struct mdinfo info;
struct mdinfo *sra;
if (ioctl(fd, GET_ARRAY_INFO, &array) < 0) {
- fprintf(stderr, Name ": %s is not an active md array - aborting\n",
+ pr_err("%s is not an active md array - aborting\n",
devname);
return 1;
}
if (size >= 0 &&
(chunksize || level!= UnSet || layout_str || raid_disks)) {
- fprintf(stderr, Name ": cannot change component size at the same time "
+ pr_err("cannot change component size at the same time "
"as other changes.\n"
" Change size first, then check data is intact before "
"making other changes.\n");
if (raid_disks && raid_disks < array.raid_disks && array.level > 1 &&
get_linux_version() < 2006032 &&
!check_env("MDADM_FORCE_FEWER")) {
- fprintf(stderr, Name ": reducing the number of devices is not safe before Linux 2.6.32\n"
+ pr_err("reducing the number of devices is not safe before Linux 2.6.32\n"
" Please use a newer kernel\n");
return 1;
}
st = super_by_fd(fd, &subarray);
if (!st) {
- fprintf(stderr, Name ": Unable to determine metadata format for %s\n", devname);
+ pr_err("Unable to determine metadata format for %s\n", devname);
return 1;
}
if (raid_disks > st->max_devs) {
- fprintf(stderr, Name ": Cannot increase raid-disks on this array"
+ pr_err("Cannot increase raid-disks on this array"
" beyond %d\n", st->max_devs);
return 1;
}
fd = cfd;
}
if (cfd < 0) {
- fprintf(stderr, Name ": Unable to open container for %s\n",
+ pr_err("Unable to open container for %s\n",
devname);
free(subarray);
return 1;
rv = st->ss->load_container(st, cfd, NULL);
if (rv) {
- fprintf(stderr, Name ": Cannot read superblock for %s\n",
+ pr_err("Cannot read superblock for %s\n",
devname);
free(subarray);
return 1;
}
+ /* check if operation is supported for metadata handler */
+ if (st->ss->container_content) {
+ struct mdinfo *cc = NULL;
+ struct mdinfo *content = NULL;
+
+ cc = st->ss->container_content(st, subarray);
+ for (content = cc; content ; content = content->next) {
+ int allow_reshape = 1;
+
+ /* check if reshape is allowed based on metadata
+ * indications stored in content.array.status
+ */
+ if (content->array.state & (1<<MD_SB_BLOCK_VOLUME))
+ allow_reshape = 0;
+ 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",
+ devname, container_buf);
+ sysfs_free(cc);
+ free(subarray);
+ return 1;
+ }
+ }
+ sysfs_free(cc);
+ }
if (mdmon_running(container_dev))
st->update_tail = &st->updates;
- }
+ }
+ added_disks = 0;
+ for (dv = devlist; dv; dv = dv->next)
+ added_disks++;
if (raid_disks > array.raid_disks &&
- array.spare_disks < (raid_disks - array.raid_disks) &&
+ array.spare_disks +added_disks < (raid_disks - array.raid_disks) &&
!force) {
- fprintf(stderr,
- Name ": Need %d spare%s to avoid degraded array,"
- " and only have %d.\n"
- " Use --force to over-ride this check.\n",
- raid_disks - array.raid_disks,
- raid_disks - array.raid_disks == 1 ? "" : "s",
- array.spare_disks);
+ pr_err("Need %d spare%s to avoid degraded array,"
+ " and only have %d.\n"
+ " Use --force to over-ride this check.\n",
+ raid_disks - array.raid_disks,
+ raid_disks - array.raid_disks == 1 ? "" : "s",
+ array.spare_disks + added_disks);
return 1;
}
sra = sysfs_read(fd, 0, GET_LEVEL | GET_DISKS | GET_DEVS
| GET_STATE | GET_VERSION);
- if (sra) {
+ if (sra) {
if (st->ss->external && subarray == NULL) {
array.level = LEVEL_CONTAINER;
sra->array.level = LEVEL_CONTAINER;
}
} else {
- fprintf(stderr, Name ": failed to read sysfs parameters for %s\n",
+ pr_err("failed to read sysfs parameters for %s\n",
devname);
return 1;
}
frozen = freeze(st);
if (frozen < -1) {
/* freeze() already spewed the reason */
+ sysfs_free(sra);
return 1;
} else if (frozen < 0) {
- fprintf(stderr, Name ": %s is performing resync/recovery and cannot"
+ pr_err("%s is performing resync/recovery and cannot"
" be reshaped\n", devname);
+ sysfs_free(sra);
return 1;
}
/* ========= set size =============== */
if (size >= 0 && (size == 0 || size != array.size)) {
- long long orig_size = array.size;
+ long long orig_size = get_component_size(fd)/2;
+ long long min_csize;
+ struct mdinfo *mdi;
+ int raid0_takeover = 0;
+
+ if (orig_size == 0)
+ orig_size = array.size;
if (reshape_super(st, size, UnSet, UnSet, 0, 0, UnSet, NULL,
- devname, !quiet)) {
+ devname, APPLY_METADATA_CHANGES, !quiet)) {
rv = 1;
goto release;
}
sync_metadata(st);
+ if (st->ss->external) {
+ /* metadata can have size limitation
+ * update size value according to metadata information
+ */
+ struct mdinfo *sizeinfo =
+ st->ss->container_content(st, subarray);
+ if (sizeinfo) {
+ unsigned long long new_size =
+ sizeinfo->custom_array_size/2;
+ int data_disks = get_data_disks(
+ sizeinfo->array.level,
+ 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,
+ new_size * data_disks);
+ size = new_size;
+ sysfs_free(sizeinfo);
+ }
+ }
+
+ /* Update the size of each member device in case
+ * they have been resized. This will never reduce
+ * below the current used-size. The "size" attribute
+ * 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", size) < 0) {
+ /* Probably kernel refusing to let us
+ * reduce the size - not an error.
+ */
+ break;
+ }
+ 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 (csize >= 2ULL*1024*1024*1024)
+ csize = 2ULL*1024*1024*1024;
+ if ((min_csize == 0 || (min_csize
+ > (long long)csize)))
+ min_csize = csize;
+ }
+ }
+ }
+ if (rv) {
+ pr_err("Cannot set size on "
+ "array members.\n");
+ goto size_change_error;
+ }
+ if (min_csize && size > min_csize) {
+ pr_err("Cannot safely make this array "
+ "use more than 2TB per device on this kernel.\n");
+ rv = 1;
+ goto size_change_error;
+ }
+ if (min_csize && size == 0) {
+ /* Don't let the kernel choose a size - it will get
+ * it wrong
+ */
+ pr_err("Limited v0.90 array to "
+ "2TB per device\n");
+ size = min_csize;
+ }
+ if (st->ss->external) {
+ if (sra->array.level == 0) {
+ rv = sysfs_set_str(sra, NULL, "level",
+ "raid5");
+ if (!rv) {
+ raid0_takeover = 1;
+ /* get array parametes after takeover
+ * to chane one parameter at time only
+ */
+ rv = ioctl(fd, GET_ARRAY_INFO, &array);
+ }
+ }
+ /* make sure mdmon is
+ * aware of the new level */
+ if (!mdmon_running(st->container_dev))
+ start_mdmon(st->container_dev);
+ ping_monitor(container);
+ if (mdmon_running(st->container_dev) &&
+ st->update_tail == NULL)
+ st->update_tail = &st->updates;
+ }
+
array.size = size;
if (array.size != size) {
/* got truncated to 32bit, write to
"component_size", size);
else
rv = -1;
- } else
+ } else {
rv = ioctl(fd, SET_ARRAY_INFO, &array);
+
+ /* manage array size when it is managed externally
+ */
+ if ((rv == 0) && st->ss->external)
+ rv = set_array_size(st, sra, sra->text_version);
+ }
+
+ if (raid0_takeover) {
+ /* do not recync non-existing parity,
+ * we will drop it anyway
+ */
+ sysfs_set_str(sra, NULL, "sync_action", "frozen");
+ /* go back to raid0, drop parity disk
+ */
+ sysfs_set_str(sra, NULL, "level", "raid0");
+ ioctl(fd, GET_ARRAY_INFO, &array);
+ }
+
+size_change_error:
if (rv != 0) {
int err = errno;
/* restore metadata */
if (reshape_super(st, orig_size, UnSet, UnSet, 0, 0,
- UnSet, NULL, devname, !quiet) == 0)
+ UnSet, NULL, devname,
+ ROLLBACK_METADATA_CHANGES,
+ !quiet) == 0)
sync_metadata(st);
- fprintf(stderr, Name ": Cannot set device size for %s: %s\n",
+ pr_err("Cannot set device size for %s: %s\n",
devname, strerror(err));
- if (err == EBUSY &&
+ if (err == EBUSY &&
(array.state & (1<<MD_SB_BITMAP_PRESENT)))
- fprintf(stderr, " Bitmap must be removed before size can be changed\n");
+ cont_err("Bitmap must be removed before size can be changed\n");
rv = 1;
goto release;
}
+ if (assume_clean) {
+ /* This will fail on kernels newer than 3.0 unless
+ * a backport has been arranged.
+ */
+ if (sra == NULL ||
+ sysfs_set_str(sra, NULL, "resync_start", "none") < 0)
+ pr_err("--assume-clean not support with --grow on this kernel\n");
+ }
ioctl(fd, GET_ARRAY_INFO, &array);
size = get_component_size(fd)/2;
if (size == 0)
size = array.size;
- if (!quiet)
- fprintf(stderr, Name ": component size of %s has been set to %lluK\n",
- devname, size);
+ if (!quiet) {
+ if (size == orig_size)
+ pr_err("component size of %s "
+ "unchanged at %lluK\n",
+ devname, size);
+ else
+ pr_err("component size of %s "
+ "has been set to %lluK\n",
+ devname, size);
+ }
changed = 1;
} else if (array.level != LEVEL_CONTAINER) {
size = get_component_size(fd)/2;
size = array.size;
}
+ /* See if there is anything else to do */
+ if ((level == UnSet || level == array.level) &&
+ (layout_str == NULL) &&
+ (chunksize == 0 || chunksize == array.chunk_size) &&
+ (raid_disks == 0 || raid_disks == array.raid_disks)) {
+ /* Nothing more to do */
+ if (!changed && !quiet)
+ pr_err("%s: no change requested\n",
+ devname);
+ goto release;
+ }
+
/* ========= check for Raid10/Raid1 -> Raid0 conversion ===============
* current implementation assumes that following conditions must be met:
* - RAID10:
- * - far_copies == 1
- * - near_copies == 2
+ * - far_copies == 1
+ * - near_copies == 2
*/
if ((level == 0 && array.level == 10 && sra &&
- array.layout == ((1 << 8) + 2) && !(array.raid_disks & 1)) ||
+ array.layout == ((1 << 8) + 2) && !(array.raid_disks & 1)) ||
(level == 0 && array.level == 1 && sra)) {
int err;
err = remove_disks_for_takeover(st, sra, array.layout);
rv = 1;
goto release;
}
- /* FIXME this is added with no justification - why is it here */
- ping_monitor(container);
+ /* Make sure mdmon has seen the device removal
+ * and updated metadata before we continue with
+ * level change
+ */
+ if (container)
+ ping_monitor(container);
}
+ memset(&info, 0, sizeof(info));
info.array = array;
sysfs_init(&info, fd, NoMdDev);
strcpy(info.text_version, sra->text_version);
info.component_size = size*2;
info.new_level = level;
info.new_chunk = chunksize * 1024;
- if (raid_disks)
+ if (info.array.level == LEVEL_CONTAINER) {
+ info.delta_disks = UnSet;
+ info.array.raid_disks = raid_disks;
+ } else if (raid_disks)
info.delta_disks = raid_disks - info.array.raid_disks;
else
info.delta_disks = UnSet;
if (info.array.level == 6 &&
(info.new_level == 6 || info.new_level == UnSet) &&
info.array.layout >= 16) {
- fprintf(stderr, Name
- ": %s has a non-standard layout. If you"
- " wish to preserve this\n"
- " during the reshape, please specify"
- " --layout=preserve\n"
- " If you want to change it, specify a"
- " layout or use --layout=normalise\n",
- devname);
+ pr_err("%s has a non-standard layout. If you"
+ " wish to preserve this\n", devname);
+ cont_err("during the reshape, please specify"
+ " --layout=preserve\n");
+ cont_err("If you want to change it, specify a"
+ " layout or use --layout=normalise\n");
rv = 1;
goto release;
}
} else if (strcmp(layout_str, "normalise") == 0 ||
- strcmp(layout_str, "normalize") == 0) {
+ strcmp(layout_str, "normalize") == 0) {
/* If we have a -6 RAID6 layout, remove the '-6'. */
info.new_layout = UnSet;
if (info.array.level == 6 && info.new_level == UnSet) {
*h = 0;
info.new_layout = map_name(r6layout, l);
}
+ } else {
+ pr_err("%s is only meaningful when reshaping"
+ " a RAID6 array.\n", layout_str);
+ rv = 1;
+ goto release;
}
} else if (strcmp(layout_str, "preserve") == 0) {
- info.new_layout = UnSet;
+ /* This means that a non-standard RAID6 layout
+ * is OK.
+ * In particular:
+ * - When reshape a RAID6 (e.g. adding a device)
+ * which is in a non-standard layout, it is OK
+ * to preserve that layout.
+ * - When converting a RAID5 to RAID6, leave it in
+ * the XXX-6 layout, don't re-layout.
+ */
+ if (info.array.level == 6 && info.new_level == UnSet)
+ info.new_layout = info.array.layout;
+ else if (info.array.level == 5 && info.new_level == 6) {
+ char l[40];
+ strcpy(l, map_num(r5layout, info.array.layout));
+ strcat(l, "-6");
+ info.new_layout = map_name(r6layout, l);
+ } else {
+ pr_err("%s in only meaningful when reshaping"
+ " to RAID6\n", layout_str);
+ rv = 1;
+ goto release;
+ }
} else {
int l = info.new_level;
if (l == UnSet)
info.new_layout = parse_layout_faulty(layout_str);
break;
default:
- fprintf(stderr, Name ": layout not meaningful"
+ pr_err("layout not meaningful"
" with this level\n");
rv = 1;
goto release;
}
if (info.new_layout == UnSet) {
- fprintf(stderr, Name ": layout %s not understood"
+ pr_err("layout %s not understood"
" for this level\n",
layout_str);
rv = 1;
}
}
- if (array.level == LEVEL_CONTAINER) {
+ if (array.level == LEVEL_FAULTY) {
+ if (level != UnSet && level != array.level) {
+ pr_err("cannot change level of Faulty device\n");
+ rv =1 ;
+ }
+ if (chunksize) {
+ pr_err("cannot set chunksize of Faulty device\n");
+ rv =1 ;
+ }
+ if (raid_disks && raid_disks != 1) {
+ pr_err("cannot set raid_disks of Faulty device\n");
+ rv =1 ;
+ }
+ if (layout_str) {
+ if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
+ dprintf("Cannot get array information.\n");
+ goto release;
+ }
+ array.layout = info.new_layout;
+ if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+ pr_err("failed to set new layout\n");
+ rv = 1;
+ } else if (!quiet)
+ printf("layout for %s set to %d\n",
+ devname, array.layout);
+ }
+ } else if (array.level == LEVEL_CONTAINER) {
/* This change is to be applied to every array in the
* container. This is only needed when the metadata imposes
* restraints of the various arrays in the container.
* number of devices (On-Line Capacity Expansion) must be
* performed at the level of the container
*/
- rv = reshape_container(container, devname, st, &info,
- force, backup_file, quiet, 0);
+ rv = reshape_container(container, devname, -1, st, &info,
+ force, backup_file, quiet, 0, 0);
frozen = 0;
} else {
/* get spare devices from external metadata
/* Impose these changes on a single array. First
* check that the metadata is OK with the change. */
- if (reshape_super(st, info.component_size, info.new_level,
+ if (reshape_super(st, -1, info.new_level,
info.new_layout, info.new_chunk,
info.array.raid_disks, info.delta_disks,
- backup_file, devname, quiet)) {
+ backup_file, devname, APPLY_METADATA_CHANGES,
+ quiet)) {
rv = 1;
goto release;
}
sync_metadata(st);
rv = reshape_array(container, fd, devname, st, &info, force,
- backup_file, quiet, 0, 0);
+ devlist, backup_file, quiet, 0, 0, 0);
frozen = 0;
}
release:
+ sysfs_free(sra);
if (frozen > 0)
unfreeze(st);
return rv;
}
+/* verify_reshape_position()
+ * Function checks if reshape position in metadata is not farther
+ * than position in md.
+ * Return value:
+ * 0 : not valid sysfs entry
+ * it can be caused by not started reshape, it should be started
+ * by reshape array or raid0 array is before takeover
+ * -1 : error, reshape position is obviously wrong
+ * 1 : success, reshape progress correct or updated
+*/
+static int verify_reshape_position(struct mdinfo *info, int level)
+{
+ int ret_val = 0;
+ char buf[40];
+ int rv;
+
+ /* read sync_max, failure can mean raid0 array */
+ rv = sysfs_get_str(info, NULL, "sync_max", buf, 40);
+
+ if (rv > 0) {
+ char *ep;
+ unsigned long long position = strtoull(buf, &ep, 0);
+
+ dprintf(Name": Read sync_max sysfs entry is: %s\n", buf);
+ if (!(ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))) {
+ position *= get_data_disks(level,
+ info->new_layout,
+ info->array.raid_disks);
+ if (info->reshape_progress < position) {
+ dprintf("Corrected reshape progress (%llu) to "
+ "md position (%llu)\n",
+ info->reshape_progress, position);
+ info->reshape_progress = position;
+ ret_val = 1;
+ } else if (info->reshape_progress > position) {
+ pr_err("Fatal error: array "
+ "reshape was not properly frozen "
+ "(expected reshape position is %llu, "
+ "but reshape progress is %llu.\n",
+ position, info->reshape_progress);
+ ret_val = -1;
+ } else {
+ dprintf("Reshape position in md and metadata "
+ "are the same;");
+ ret_val = 1;
+ }
+ }
+ } else if (rv == 0) {
+ /* for valid sysfs entry, 0-length content
+ * should be indicated as error
+ */
+ ret_val = -1;
+ }
+
+ return ret_val;
+}
+
static int reshape_array(char *container, int fd, char *devname,
struct supertype *st, struct mdinfo *info,
- int force,
+ int force, struct mddev_dev *devlist,
char *backup_file, int quiet, int forked,
- int restart)
+ int restart, int freeze_reshape)
{
struct reshape reshape;
int spares_needed;
struct mdu_array_info_s array;
char *c;
- int *fdlist;
- unsigned long long *offsets;
+ struct mddev_dev *dv;
+ int added_disks;
+
+ int *fdlist = NULL;
+ unsigned long long *offsets = NULL;
int d;
int nrdisks;
int err;
int done;
struct mdinfo *sra = NULL;
- msg = analyse_change(info, &reshape);
+ /* when reshaping a RAID0, the component_size might be zero.
+ * So try to fix that up.
+ */
+ if (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
+ dprintf("Cannot get array information.\n");
+ goto release;
+ }
+ if (array.level == 0 && info->component_size == 0) {
+ get_dev_size(fd, NULL, &array_size);
+ info->component_size = array_size / array.raid_disks;
+ }
+
+ if (info->reshape_active) {
+ int new_level = info->new_level;
+ info->new_level = UnSet;
+ if (info->delta_disks > 0)
+ info->array.raid_disks -= info->delta_disks;
+ msg = analyse_change(info, &reshape);
+ info->new_level = new_level;
+ if (info->delta_disks > 0)
+ info->array.raid_disks += info->delta_disks;
+ if (!restart)
+ /* Make sure the array isn't read-only */
+ ioctl(fd, RESTART_ARRAY_RW, 0);
+ } else
+ msg = analyse_change(info, &reshape);
if (msg) {
- fprintf(stderr, Name ": %s\n", msg);
+ 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)) {
- fprintf(stderr, Name ": reshape info is not in native format -"
+ 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 (ioctl(fd, GET_ARRAY_INFO, &array) != 0) {
- dprintf("Cannot get array information.\n");
- goto release;
- }
+ if (st->ss->external && restart && (info->reshape_progress == 0)) {
+ /* When reshape is restarted from '0', very begin of array
+ * it is possible that for external metadata reshape and array
+ * configuration doesn't happen.
+ * Check if md has the same opinion, and reshape is restarted
+ * from 0. If so, this is regular reshape start after reshape
+ * switch in metadata to next array only.
+ */
+ if ((verify_reshape_position(info, reshape.level) >= 0) &&
+ (info->reshape_progress == 0))
+ restart = 0;
+ }
if (restart) {
/* reshape already started. just skip to monitoring the reshape */
if (reshape.backup_blocks == 0)
*/
sysfs_freeze_array(info);
/* Check we have enough spares to not be degraded */
+ added_disks = 0;
+ 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;
if (!force &&
- info->new_level > 1 &&
- spares_needed > info->array.spare_disks) {
- fprintf(stderr,
- Name ": Need %d spare%s to avoid degraded array,"
- " and only have %d.\n"
- " Use --force to over-ride this check.\n",
- spares_needed,
- spares_needed == 1 ? "" : "s",
- info->array.spare_disks);
+ 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",
+ spares_needed,
+ spares_needed == 1 ? "" : "s",
+ info->array.spare_disks + added_disks);
goto release;
}
/* Check we have enough spares to not fail */
reshape.after.data_disks)
- array.raid_disks;
if ((info->new_level > 1 || info->new_level == 0) &&
- spares_needed > info->array.spare_disks) {
- fprintf(stderr,
- Name ": Need %d spare%s to create working array,"
- " and only have %d.\n",
- spares_needed,
- spares_needed == 1 ? "" : "s",
- info->array.spare_disks);
+ 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",
+ info->array.spare_disks + added_disks);
goto release;
}
err = sysfs_set_str(info, NULL, "level", c);
if (err) {
err = errno;
- fprintf(stderr, Name ": %s: could not set level to %s\n",
+ pr_err("%s: could not set level to %s\n",
devname, c);
- if (err == EBUSY &&
+ if (err == EBUSY &&
(info->array.state & (1<<MD_SB_BITMAP_PRESENT)))
- fprintf(stderr, " Bitmap must be removed"
- " before level can be changed\n");
+ cont_err("Bitmap must be removed"
+ " before level can be changed\n");
goto release;
}
if (!quiet)
- fprintf(stderr, Name ": level of %s changed to %s\n",
- devname, c);
+ pr_err("level of %s changed to %s\n",
+ devname, c);
orig_level = array.level;
sysfs_freeze_array(info);
if (reshape.level > 0 && st->ss->external) {
/* make sure mdmon is aware of the new level */
+ if (mdmon_running(st->container_dev))
+ flush_mdmon(container);
+
if (!mdmon_running(st->container_dev))
start_mdmon(st->container_dev);
ping_monitor(container);
+ if (mdmon_running(st->container_dev) &&
+ st->update_tail == NULL)
+ st->update_tail = &st->updates;
}
}
/* ->reshape_super might have chosen some spares from the
if (info2) {
sysfs_init(info2, fd, st->devnum);
+ /* 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)
+ subarray_set_num(container, info2, "raid_disks",
+ reshape.after.data_disks +
+ reshape.parity);
for (d = info2->devs; d; d = d->next) {
if (d->disk.state == 0 &&
d->disk.raid_disk >= 0) {
sysfs_free(info2);
}
}
+ /* We might have been given some devices to add to the
+ * array. Now that the array has been changed to the right
+ * level and frozen, we can safely add them.
+ */
+ if (devlist)
+ Manage_subdevs(devname, fd, devlist, !quiet,
+ 0,NULL, 0);
if (reshape.backup_blocks == 0) {
/* No restriping needed, but we might need to impose
info->new_layout != array.layout) {
array.layout = info->new_layout;
if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
- fprintf(stderr, Name ": failed to set new layout\n");
+ pr_err("failed to set new layout\n");
goto release;
} else if (!quiet)
printf("layout for %s set to %d\n",
array.raid_disks != (info->array.raid_disks + info->delta_disks)) {
array.raid_disks += info->delta_disks;
if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
- fprintf(stderr, Name ": failed to set raid disks\n");
+ pr_err("failed to set raid disks\n");
goto release;
} else if (!quiet) {
printf("raid_disks for %s set to %d\n",
info->new_chunk != array.chunk_size) {
if (sysfs_set_num(info, NULL,
"chunk_size", info->new_chunk) != 0) {
- fprintf(stderr, Name ": failed to set chunk size\n");
+ pr_err("failed to set chunk size\n");
goto release;
} else if (!quiet)
printf("chunk size for %s set to %d\n",
* 1/ The array will shrink.
* We need to ensure the reshape will pause before reaching
* the 'critical section'. We also need to fork and wait for
- * that to happen. When it does we
+ * that to happen. When it does we
* suspend/backup/complete/unfreeze
*
* 2/ The array will not change size.
/* Check that we can hold all the data */
get_dev_size(fd, NULL, &array_size);
if (reshape.new_size < (array_size/512)) {
- fprintf(stderr,
- Name ": this change will reduce the size of the array.\n"
- " use --grow --array-size first to truncate array.\n"
- " e.g. mdadm --grow %s --array-size %llu\n",
- devname, reshape.new_size/2);
+ pr_err("this change will reduce the size of the array.\n"
+ " use --grow --array-size first to truncate array.\n"
+ " e.g. mdadm --grow %s --array-size %llu\n",
+ devname, reshape.new_size/2);
goto release;
}
GET_COMPONENT|GET_DEVS|GET_OFFSET|GET_STATE|GET_CHUNK|
GET_CACHE);
if (!sra) {
- fprintf(stderr, Name ": %s: Cannot get array details from sysfs\n",
+ pr_err("%s: Cannot get array details from sysfs\n",
devname);
goto release;
}
* unit. The number we have so far is just a minimum
*/
blocks = reshape.backup_blocks;
- if (reshape.before.data_disks ==
+ if (reshape.before.data_disks ==
reshape.after.data_disks) {
/* Make 'blocks' bigger for better throughput, but
* not so big that we reject it below.
blocks < 16*1024*2)
blocks *= 2;
} else
- fprintf(stderr, Name ": Need to backup %luK of critical "
+ pr_err("Need to backup %luK of critical "
"section..\n", blocks/2);
if (blocks >= sra->component_size/2) {
- fprintf(stderr, Name ": %s: Something wrong"
+ pr_err("%s: Something wrong"
" - reshape aborted\n",
devname);
goto release;
nrdisks = max(reshape.before.data_disks,
reshape.after.data_disks) + reshape.parity
+ sra->array.spare_disks;
- fdlist = malloc((1+nrdisks) * sizeof(int));
- offsets = malloc((1+nrdisks) * sizeof(offsets[0]));
- if (!fdlist || !offsets) {
- fprintf(stderr, Name ": malloc failed: grow aborted\n");
- goto release;
- }
+ fdlist = xcalloc((1+nrdisks), sizeof(int));
+ offsets = xcalloc((1+nrdisks), sizeof(offsets[0]));
odisks = reshape.before.data_disks + reshape.parity;
d = reshape_prepare_fdlist(devname, sra, odisks,
if (d < 0) {
goto release;
}
- if (backup_file == NULL) {
- if (reshape.after.data_disks <= reshape.before.data_disks) {
- fprintf(stderr,
- Name ": %s: Cannot grow - need backup-file\n",
- devname);
- goto release;
- } else if (sra->array.spare_disks == 0) {
- fprintf(stderr, Name ": %s: Cannot grow - need a spare or "
- "backup-file to backup critical section\n",
- devname);
- goto release;
- }
- } else {
- if (!reshape_open_backup_file(backup_file, fd, devname,
- (signed)blocks,
- fdlist+d, offsets+d, restart)) {
- goto release;
+ if ((st->ss->manage_reshape == NULL) ||
+ (st->ss->recover_backup == NULL)) {
+ if (backup_file == NULL) {
+ if (reshape.after.data_disks <=
+ reshape.before.data_disks) {
+ pr_err("%s: Cannot grow - "
+ "need backup-file\n", devname);
+ goto release;
+ } else if (sra->array.spare_disks == 0) {
+ pr_err("%s: Cannot grow - "
+ "need a spare or backup-file to backup "
+ "critical section\n", devname);
+ goto release;
+ }
+ } else {
+ if (!reshape_open_backup_file(backup_file, fd, devname,
+ (signed)blocks,
+ fdlist+d, offsets+d,
+ restart)) {
+ goto release;
+ }
+ d++;
}
- d++;
}
/* lastly, check that the internal stripe cache is
sra->new_chunk = info->new_chunk;
- if (restart)
+ if (restart) {
+ /* for external metadata checkpoint saved by mdmon can be lost
+ * or missed /due to e.g. crash/. Check if md is not during
+ * restart farther than metadata points to.
+ * If so, this means metadata information is obsolete.
+ */
+ if (st->ss->external)
+ verify_reshape_position(info, reshape.level);
sra->reshape_progress = info->reshape_progress;
- else {
+ } else {
sra->reshape_progress = 0;
if (reshape.after.data_disks < reshape.before.data_disks)
/* start from the end of the new array */
ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
int err = errno;
- fprintf(stderr,
- Name ": Cannot set device shape for %s: %s\n",
- devname, strerror(errno));
+ pr_err("Cannot set device shape for %s: %s\n",
+ devname, strerror(errno));
- if (err == EBUSY &&
+ if (err == EBUSY &&
(array.state & (1<<MD_SB_BITMAP_PRESENT)))
- fprintf(stderr,
- " Bitmap must be removed before"
- " shape can be changed\n");
+ cont_err("Bitmap must be removed before"
+ " shape can be changed\n");
goto release;
}
int err = 0;
if (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 && subarray_set_num(container, sra, "raid_disks",
- reshape.after.data_disks +
- reshape.parity) < 0)
+ reshape.after.data_disks +
+ reshape.parity) < 0)
err = errno;
if (err) {
- fprintf(stderr, Name ": Cannot set device shape for %s\n",
+ pr_err("Cannot set device shape for %s\n",
devname);
- if (err == EBUSY &&
+ if (err == EBUSY &&
(array.state & (1<<MD_SB_BITMAP_PRESENT)))
- fprintf(stderr,
- " Bitmap must be removed before"
- " shape can be changed\n");
+ cont_err("Bitmap must be removed before"
+ " shape can be changed\n");
goto release;
}
}
- err = start_reshape(sra, restart);
+ err = start_reshape(sra, restart, reshape.before.data_disks,
+ reshape.after.data_disks);
if (err) {
- fprintf(stderr,
- Name ": Cannot %s reshape for %s\n",
- restart ? "continue" : "start",
- devname);
+ pr_err("Cannot %s reshape for %s\n",
+ restart ? "continue" : "start",
+ devname);
goto release;
}
if (restart)
sysfs_set_str(sra, NULL, "array_state", "active");
+ if (freeze_reshape) {
+ free(fdlist);
+ free(offsets);
+ sysfs_free(sra);
+ pr_err("Reshape has to be continued from"
+ " location %llu when root filesystem has been mounted.\n",
+ sra->reshape_progress);
+ return 1;
+ }
/* Now we just need to kick off the reshape and watch, while
* handling backups of the data...
*/
switch(forked ? 0 : fork()) {
case -1:
- fprintf(stderr, Name ": Cannot run child to monitor reshape: %s\n",
+ pr_err("Cannot run child to monitor reshape: %s\n",
strerror(errno));
abort_reshape(sra);
goto release;
default:
+ free(fdlist);
+ free(offsets);
+ sysfs_free(sra);
return 0;
case 0:
+ map_fork();
break;
}
d - odisks, fdlist+odisks,
offsets+odisks);
+ free(fdlist);
+ free(offsets);
+
if (backup_file && done)
unlink(backup_file);
if (!done) {
/* no need to wait for the reshape to finish as
* there is nothing more to do.
*/
+ sysfs_free(sra);
exit(0);
}
wait_reshape(sra);
/* Re-load the metadata as much could have changed */
int cfd = open_dev(st->container_dev);
if (cfd >= 0) {
- ping_monitor(container);
+ flush_mdmon(container);
st->ss->free_super(st);
st->ss->load_container(st, cfd, container);
close(cfd);
*/
if (reshape.before.data_disks !=
reshape.after.data_disks &&
- info->custom_array_size) {
- struct mdinfo *info2;
- char *subarray = strchr(info->text_version+1, '/')+1;
-
- info2 = st->ss->container_content(st, subarray);
- if (info2) {
- unsigned long long current_size = 0;
- unsigned long long new_size =
- info2->custom_array_size/2;
-
- if (sysfs_get_ll(sra,
- NULL,
- "array_size",
- ¤t_size) == 0 &&
- new_size > current_size) {
- if (sysfs_set_num(sra, NULL,
- "array_size", new_size)
- < 0)
- dprintf("Error: Cannot"
- " set array size");
- else
- dprintf("Array size "
- "changed");
- dprintf(" from %llu to %llu.\n",
- current_size, new_size);
- }
- sysfs_free(info2);
- }
- }
+ info->custom_array_size)
+ set_array_size(st, info, info->text_version);
if (info->new_level != reshape.level) {
if (c) {
err = sysfs_set_str(sra, NULL, "level", c);
if (err)
- fprintf(stderr, Name\
- ": %s: could not set level "
- "to %s\n", devname, c);
+ pr_err("%s: could not set level "
+ "to %s\n", devname, c);
}
+ if (info->new_level == 0)
+ st->update_tail = NULL;
}
out:
+ sysfs_free(sra);
if (forked)
return 0;
unfreeze(st);
exit(0);
release:
+ free(fdlist);
+ free(offsets);
if (orig_level != UnSet && sra) {
c = map_num(pers, orig_level);
if (c && sysfs_set_str(sra, NULL, "level", c) == 0)
- fprintf(stderr, Name ": aborting level change\n");
+ pr_err("aborting level change\n");
}
+ sysfs_free(sra);
if (!forked)
unfreeze(st);
return 1;
}
+/* mdfd handle is passed to be closed in child process (after fork).
+ */
int reshape_container(char *container, char *devname,
- struct supertype *st,
+ int mdfd,
+ struct supertype *st,
struct mdinfo *info,
int force,
char *backup_file,
- int quiet, int restart)
+ int quiet, int restart, int freeze_reshape)
{
struct mdinfo *cc = NULL;
+ int rv = restart;
+ int last_devnum = -1;
/* component_size is not meaningful for a container,
* so pass '-1' meaning 'no change'
reshape_super(st, -1, info->new_level,
info->new_layout, info->new_chunk,
info->array.raid_disks, info->delta_disks,
- backup_file, devname, quiet)) {
+ backup_file, devname, APPLY_METADATA_CHANGES,
+ quiet)) {
unfreeze(st);
return 1;
}
unfreeze(st);
return 1;
default: /* parent */
- printf(Name ": multi-array reshape continues in background\n");
+ if (!freeze_reshape)
+ printf(Name ": multi-array reshape continues"
+ " in background\n");
return 0;
case 0: /* child */
+ map_fork();
break;
}
+ /* close unused handle in child process
+ */
+ if (mdfd > -1)
+ close(mdfd);
+
while(1) {
/* For each member array with reshape_active,
* we need to perform the reshape.
* will take over the reshape.
*/
struct mdinfo *content;
- int rv;
int fd;
struct mdstat_ent *mdstat;
char *adev;
devname2devnum(container));
if (!mdstat)
continue;
+ if (mdstat->active == 0) {
+ pr_err("Skipping inactive "
+ "array md%i.\n", mdstat->devnum);
+ free_mdstat(mdstat);
+ mdstat = NULL;
+ continue;
+ }
break;
}
if (!content)
break;
- fd = open_dev(mdstat->devnum);
- if (fd < 0)
- break;
adev = map_dev(dev2major(mdstat->devnum),
dev2minor(mdstat->devnum),
0);
if (!adev)
adev = content->text_version;
+ fd = open_dev(mdstat->devnum);
+ if (fd < 0) {
+ printf(Name ": Device %s cannot be opened for reshape.",
+ adev);
+ break;
+ }
+
+ if (last_devnum == mdstat->devnum) {
+ /* Do not allow for multiple reshape_array() calls for
+ * the same array.
+ * It can happen when reshape_array() returns without
+ * error, when reshape is not finished (wrong reshape
+ * starting/continuation conditions). Mdmon doesn't
+ * switch to next array in container and reentry
+ * conditions for the same array occur.
+ * This is possibly interim until the behaviour of
+ * reshape_array is resolved().
+ */
+ printf(Name ": Multiple reshape execution detected for "
+ "device %s.", adev);
+ close(fd);
+ break;
+ }
+ last_devnum = mdstat->devnum;
+
sysfs_init(content, fd, mdstat->devnum);
+ if (mdmon_running(devname2devnum(container)))
+ flush_mdmon(container);
+
rv = reshape_array(container, fd, adev, st,
- content, force,
- backup_file, quiet, 1, restart);
+ content, force, NULL,
+ backup_file, quiet, 1, restart,
+ freeze_reshape);
close(fd);
+
+ if (freeze_reshape) {
+ sysfs_free(cc);
+ exit(0);
+ }
+
restart = 0;
if (rv)
break;
+
+ if (mdmon_running(devname2devnum(container)))
+ flush_mdmon(container);
}
- unfreeze(st);
+ if (!rv)
+ unfreeze(st);
sysfs_free(cc);
exit(0);
}
* suspend/backup/allow always come together
* wait/resume/discard do too.
* For the same-size case we have two backups to improve flow.
- *
+ *
*/
int progress_reshape(struct mdinfo *info, struct reshape *reshape,
* this much.
*/
target = 64*1024*2 * min(reshape->before.data_disks,
- reshape->after.data_disks);
+ reshape->after.data_disks);
target /= reshape->backup_blocks;
if (target < 2)
target = 2;
if (fd < 0)
goto check_progress;
- if (sysfs_fd_get_ll(fd, &completed) < 0) {
- close(fd);
+ if (sysfs_fd_get_ll(fd, &completed) < 0)
goto check_progress;
- }
+
while (completed < max_progress && completed < wait_point) {
/* Check that sync_action is still 'reshape' to avoid
* waiting forever on a dead array
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
select(fd+1, NULL, NULL, &rfds, NULL);
- if (sysfs_fd_get_ll(fd, &completed) < 0) {
- close(fd);
+ if (sysfs_fd_get_ll(fd, &completed) < 0)
goto check_progress;
- }
}
/* Some kernels reset 'sync_completed' to zero,
* we need to have real point we are in md
- completed;
}
*reshape_completed = completed;
-
+
close(fd);
/* We return the need_backup flag. Caller will decide
/* if we couldn't read a number from sync_completed, then
* either the reshape did complete, or it aborted.
* We can tell which by checking for 'none' in reshape_position.
+ * If it did abort, then it might immediately restart if it
+ * it was just a device failure that leaves us degraded but
+ * functioning.
*/
strcpy(buf, "hi");
if (sysfs_get_str(info, NULL, "reshape_position", buf, sizeof(buf)) < 0
- || strncmp(buf, "none", 4) != 0)
- return -2; /* abort */
- else {
+ || strncmp(buf, "none", 4) != 0) {
+ /* The abort might only be temporary. Wait up to 10
+ * seconds for fd to contain a valid number again.
+ */
+ struct timeval tv;
+ int rv = -2;
+ tv.tv_sec = 10;
+ tv.tv_usec = 0;
+ while (fd >= 0 && rv < 0 && tv.tv_sec > 0) {
+ fd_set rfds;
+ FD_ZERO(&rfds);
+ FD_SET(fd, &rfds);
+ if (select(fd+1, NULL, NULL, &rfds, &tv) != 1)
+ break;
+ switch (sysfs_fd_get_ll(fd, &completed)) {
+ case 0:
+ /* all good again */
+ rv = 1;
+ break;
+ case -2: /* read error - abort */
+ tv.tv_sec = 0;
+ break;
+ }
+ }
+ if (fd >= 0)
+ close(fd);
+ return rv; /* abort */
+ } else {
/* 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)
}
}
-
/* FIXME return status is never checked */
static int grow_backup(struct mdinfo *sra,
unsigned long long offset, /* per device */
else
lseek64(destfd[i], destoffsets[i], 0);
- rv = save_stripes(sources, offsets,
+ rv = save_stripes(sources, offsets,
disks, chunk, level, layout,
dests, destfd,
offset*512*odata, stripes * chunk * odata,
* every works.
*/
/* FIXME return value is often ignored */
-static int forget_backup(
- int dests, int *destfd, unsigned long long *destoffsets,
- int part)
+static int forget_backup(int dests, int *destfd,
+ unsigned long long *destoffsets,
+ int part)
{
- /*
+ /*
* Erase backup 'part' (which is 0 or 1)
*/
int i;
if ((unsigned long long)lseek64(destfd[i], destoffsets[i]-4096, 0) !=
destoffsets[i]-4096)
rv = -1;
- if (rv == 0 &&
+ if (rv == 0 &&
write(destfd[i], &bsb, 512) != 512)
rv = -1;
fsync(destfd[i]);
fail("magic is bad");
if (memcmp(bsb2.magic, "md_backup_data-2", 16) == 0 &&
bsb2.sb_csum2 != bsb_csum((char*)&bsb2,
- ((char*)&bsb2.sb_csum2)-((char*)&bsb2)))
+ ((char*)&bsb2.sb_csum2)-((char*)&bsb2)))
fail("second csum bad");
if (__le64_to_cpu(bsb2.devstart)*512 != offset)
if ((unsigned long long)read(afd, abuf, len) != len)
fail("read first from array failed");
if (memcmp(bbuf, abuf, len) != 0) {
- #if 0
+#if 0
int i;
printf("offset=%llu len=%llu\n",
(unsigned long long)__le64_to_cpu(bsb2.arraystart)*512, len);
printf("first diff byte %d\n", i);
break;
}
- #endif
+#endif
fail("data1 compare failed");
}
}
free(abuf);
free(bbuf);
abuflen = len;
- abuf = malloc(abuflen);
- bbuf = malloc(abuflen);
+ abuf = xmalloc(abuflen);
+ bbuf = xmalloc(abuflen);
}
lseek64(bfd, offset+__le64_to_cpu(bsb2.devstart2)*512, 0);
int chunk = sra->array.chunk_size;
struct mdinfo *sd;
unsigned long stripes;
+ int uuid[4];
/* set up the backup-super-block. This requires the
* uuid from the array.
continue;
ok = st->ss->load_super(st, devfd, NULL);
close(devfd);
- if (ok >= 0)
+ if (ok == 0)
break;
}
if (!sd) {
- fprintf(stderr, Name ": Cannot find a superblock\n");
+ pr_err("Cannot find a superblock\n");
return 0;
}
memset(&bsb, 0, 512);
memcpy(bsb.magic, "md_backup_data-1", 16);
- st->ss->uuid_from_super(st, (int*)&bsb.set_uuid);
+ st->ss->uuid_from_super(st, uuid);
+ memcpy(bsb.set_uuid, uuid, 16);
bsb.mtime = __cpu_to_le64(time(0));
bsb.devstart2 = blocks;
/* Clear any backup region that is before 'here' */
if (increasing) {
- if (reshape_completed >= (__le64_to_cpu(bsb.arraystart) +
+ if (__le64_to_cpu(bsb.length) > 0 &&
+ reshape_completed >= (__le64_to_cpu(bsb.arraystart) +
__le64_to_cpu(bsb.length)))
forget_backup(dests, destfd,
destoffsets, 0);
- if (reshape_completed >= (__le64_to_cpu(bsb.arraystart2) +
+ if (__le64_to_cpu(bsb.length2) > 0 &&
+ reshape_completed >= (__le64_to_cpu(bsb.arraystart2) +
__le64_to_cpu(bsb.length2)))
forget_backup(dests, destfd,
destoffsets, 1);
} else {
- if (reshape_completed <= (__le64_to_cpu(bsb.arraystart)))
+ if (__le64_to_cpu(bsb.length) > 0 &&
+ reshape_completed <= (__le64_to_cpu(bsb.arraystart)))
forget_backup(dests, destfd,
destoffsets, 0);
- if (reshape_completed <= (__le64_to_cpu(bsb.arraystart2)))
+ if (__le64_to_cpu(bsb.length2) > 0 &&
+ reshape_completed <= (__le64_to_cpu(bsb.arraystart2)))
forget_backup(dests, destfd,
destoffsets, 1);
}
done = 1;
break;
}
+ if (rv == 0 && increasing && !st->ss->external) {
+ /* No longer need to monitor this reshape */
+ done = 1;
+ break;
+ }
while (rv) {
unsigned long long offset;
unsigned long long nstripe, ostripe;
int ndata, odata;
- if (info->new_level != info->array.level)
- return 1; /* Cannot handle level changes (they are instantaneous) */
-
odata = info->array.raid_disks - info->delta_disks - 1;
if (info->array.level == 6) odata--; /* number of data disks */
ndata = info->array.raid_disks - 1;
if (i == old_disks-1) {
fd = open(backup_file, O_RDONLY);
if (fd<0) {
- fprintf(stderr, Name ": backup file %s inaccessible: %s\n",
+ pr_err("backup file %s inaccessible: %s\n",
backup_file, strerror(errno));
continue;
}
if (lseek64(fd,
(dinfo.data_offset + dinfo.component_size - 8) <<9,
0) < 0) {
- fprintf(stderr, Name ": Cannot seek on device %d\n", i);
+ pr_err("Cannot seek on device %d\n", i);
continue; /* Cannot seek */
}
sprintf(namebuf, "device-%d", i);
}
if (read(fd, &bsb, sizeof(bsb)) != sizeof(bsb)) {
if (verbose)
- fprintf(stderr, Name ": Cannot read from %s\n", devname);
+ pr_err("Cannot read from %s\n", devname);
continue; /* Cannot read */
}
if (memcmp(bsb.magic, "md_backup_data-1", 16) != 0 &&
memcmp(bsb.magic, "md_backup_data-2", 16) != 0) {
if (verbose)
- fprintf(stderr, Name ": No backup metadata on %s\n", devname);
+ pr_err("No backup metadata on %s\n", devname);
continue;
}
if (bsb.sb_csum != bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb))) {
if (verbose)
- fprintf(stderr, Name ": 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)
- fprintf(stderr, Name ": 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)
- fprintf(stderr, Name ": Wrong uuid on backup-metadata on %s\n", devname);
+ pr_err("Wrong uuid on backup-metadata on %s\n", devname);
continue; /* Wrong uuid */
}
if (info->array.utime > (int)__le64_to_cpu(bsb.mtime) + 2*60*60 ||
info->array.utime < (int)__le64_to_cpu(bsb.mtime) - 10*60) {
if (check_env("MDADM_GROW_ALLOW_OLD")) {
- fprintf(stderr, Name ": accepting backup with timestamp %lu "
+ pr_err("accepting backup with timestamp %lu "
"for array with timestamp %lu\n",
(unsigned long)__le64_to_cpu(bsb.mtime),
(unsigned long)info->array.utime);
} else {
if (verbose)
- fprintf(stderr, Name ": too-old timestamp on "
+ pr_err("too-old timestamp on "
"backup-metadata on %s\n", devname);
continue; /* time stamp is too bad */
}
< info->reshape_progress) {
nonew:
if (verbose)
- fprintf(stderr, Name
- ": backup-metadata found on %s but is not needed\n", devname);
+ pr_err("backup-metadata found on %s but is not needed\n", devname);
continue; /* No new data here */
}
} else {
if (lseek64(fd, __le64_to_cpu(bsb.devstart)*512, 0)< 0) {
second_fail:
if (verbose)
- fprintf(stderr, Name
- ": Failed to verify secondary backup-metadata block on %s\n",
- devname);
+ pr_err("Failed to verify secondary backup-metadata block on %s\n",
+ devname);
continue; /* Cannot seek */
}
/* There should be a duplicate backup superblock 4k before here */
goto second_fail; /* Cannot find leading superblock */
/* Now need the data offsets for all devices. */
- offsets = malloc(sizeof(*offsets)*info->array.raid_disks);
+ offsets = xmalloc(sizeof(*offsets)*info->array.raid_disks);
for(j=0; j<info->array.raid_disks; j++) {
if (fdlist[j] < 0)
continue;
info->new_layout,
fd, __le64_to_cpu(bsb.devstart)*512,
__le64_to_cpu(bsb.arraystart)*512,
- __le64_to_cpu(bsb.length)*512)) {
+ __le64_to_cpu(bsb.length)*512, NULL)) {
/* didn't succeed, so giveup */
if (verbose)
- fprintf(stderr, Name ": Error restoring backup from %s\n",
+ pr_err("Error restoring backup from %s\n",
devname);
+ free(offsets);
return 1;
}
-
+
if (bsb.magic[15] == '2' &&
restore_stripes(fdlist, offsets,
info->array.raid_disks,
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)) {
+ __le64_to_cpu(bsb.length2)*512, NULL)) {
/* didn't succeed, so giveup */
if (verbose)
- fprintf(stderr, Name ": Error restoring second backup from %s\n",
+ pr_err("Error restoring second backup from %s\n",
devname);
+ free(offsets);
return 1;
}
+ free(offsets);
/* Ok, so the data is restored. Let's update those superblocks. */
}
/* needed to recover critical section! */
if (verbose)
- fprintf(stderr, Name ": Failed to find backup of critical section\n");
+ pr_err("Failed to find backup of critical section\n");
return 1;
}
-int Grow_continue(int mdfd, struct supertype *st, struct mdinfo *info,
- char *backup_file)
+int Grow_continue_command(char *devname, int fd,
+ char *backup_file, int verbose)
{
+ int ret_val = 0;
+ struct supertype *st = NULL;
+ struct mdinfo *content = NULL;
+ struct mdinfo array;
+ char *subarray = NULL;
+ struct mdinfo *cc = NULL;
+ struct mdstat_ent *mdstat = NULL;
char buf[40];
- char *container = NULL;
- int err;
+ int cfd = -1;
+ int fd2 = -1;
+
+ 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);
+ return 1;
+ }
+ dprintf("Grow continue is run for ");
+ if (st->ss->external == 0) {
+ dprintf("native array (%s)\n", devname);
+ if (ioctl(fd, GET_ARRAY_INFO, &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, st->devnum);
+ } else {
+ int container_dev;
+
+ if (subarray) {
+ dprintf("subarray (%s)\n", subarray);
+ container_dev = st->container_dev;
+ cfd = open_dev_excl(st->container_dev);
+ } else {
+ container_dev = st->devnum;
+ close(fd);
+ cfd = open_dev_excl(st->devnum);
+ dprintf("container (%i)\n", container_dev);
+ fd = cfd;
+ }
+ if (cfd < 0) {
+ pr_err("Unable to open container "
+ "for %s\n", devname);
+ ret_val = 1;
+ goto Grow_continue_command_exit;
+ }
+ fmt_devname(buf, container_dev);
+
+ /* find in container array under reshape
+ */
+ ret_val = st->ss->load_container(st, cfd, NULL);
+ if (ret_val) {
+ 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;
+ int allow_reshape = 1;
+
+ if (content->reshape_active == 0)
+ continue;
+ /* The decision about array or container wide
+ * reshape is taken in Grow_continue based
+ * content->reshape_active state, therefore we
+ * need to check_reshape based on
+ * reshape_active and subarray name
+ */
+ if (content->array.state & (1<<MD_SB_BLOCK_VOLUME))
+ allow_reshape = 0;
+ if (content->reshape_active == CONTAINER_RESHAPE &&
+ (content->array.state
+ & (1<<MD_SB_BLOCK_CONTAINER_RESHAPE)))
+ allow_reshape = 0;
+
+ if (!allow_reshape) {
+ pr_err("cannot continue reshape of an array"
+ " in container with unsupported"
+ " metadata: %s(%s)\n",
+ devname, buf);
+ ret_val = 1;
+ goto Grow_continue_command_exit;
+ }
+
+ array = strchr(content->text_version+1, '/')+1;
+ mdstat = mdstat_by_subdev(array, container_dev);
+ if (!mdstat)
+ continue;
+ if (mdstat->active == 0) {
+ pr_err("Skipping inactive "
+ "array md%i.\n", mdstat->devnum);
+ free_mdstat(mdstat);
+ mdstat = NULL;
+ continue;
+ }
+ break;
+ }
+ if (!content) {
+ pr_err("Unable to determine reshaped "
+ "array for %s\n", devname);
+ ret_val = 1;
+ goto Grow_continue_command_exit;
+ }
+ fd2 = open_dev(mdstat->devnum);
+ if (fd2 < 0) {
+ pr_err("cannot open (md%i)\n",
+ mdstat->devnum);
+ ret_val = 1;
+ goto Grow_continue_command_exit;
+ }
+
+ sysfs_init(content, fd2, mdstat->devnum);
+
+ /* start mdmon in case it is not running
+ */
+ if (!mdmon_running(container_dev))
+ start_mdmon(container_dev);
+ ping_monitor(buf);
+
+ if (mdmon_running(container_dev))
+ st->update_tail = &st->updates;
+ else {
+ pr_err("No mdmon found. "
+ "Grow cannot continue.\n");
+ ret_val = 1;
+ goto Grow_continue_command_exit;
+ }
+ }
+
+ /* verify that array under reshape is started from
+ * correct position
+ */
+ if (verify_reshape_position(content,
+ map_name(pers, mdstat->level)) < 0) {
+ ret_val = 1;
+ goto Grow_continue_command_exit;
+ }
+
+ /* continue reshape
+ */
+ ret_val = Grow_continue(fd, st, content, backup_file, 0);
+
+Grow_continue_command_exit:
+ if (fd2 > -1)
+ close(fd2);
+ if (cfd > -1)
+ close(cfd);
+ st->ss->free_super(st);
+ free_mdstat(mdstat);
+ sysfs_free(cc);
+ free(subarray);
+
+ return ret_val;
+}
+
+int Grow_continue(int mdfd, struct supertype *st, struct mdinfo *info,
+ char *backup_file, int freeze_reshape)
+{
+ int ret_val = 2;
+
+ if (!info->reshape_active)
+ return ret_val;
- err = sysfs_set_str(info, NULL, "array_state", "readonly");
- if (err)
- return err;
if (st->ss->external) {
- fmt_devname(buf, st->container_dev);
- container = buf;
- freeze(st);
- if (info->reshape_active == 2)
- return reshape_container(container, NULL,
- st, info, 0, backup_file,
- 0, 1);
- }
- return reshape_array(container, mdfd, "array", st, info, 1,
- backup_file, 0, 0, 1);
+ char container[40];
+ int cfd = open_dev(st->container_dev);
+
+ if (cfd < 0)
+ return 1;
+
+ fmt_devname(container, st->container_dev);
+ st->ss->load_container(st, cfd, container);
+ close(cfd);
+ ret_val = reshape_container(container, NULL, mdfd,
+ st, info, 0, backup_file,
+ 0, 1, freeze_reshape);
+ } else
+ ret_val = reshape_array(NULL, mdfd, "array", st, info, 1,
+ NULL, backup_file, 0, 0, 1,
+ freeze_reshape);
+
+ return ret_val;
}
projects / thirdparty / mdadm.git / blobdiff