/*
* mdadm - manage Linux "md" devices aka RAID arrays.
*
- * Copyright (C) 2001-2004 Neil Brown <neilb@cse.unsw.edu.au>
+ * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
*
*
* This program is free software; you can redistribute it and/or modify
d);
return 1;
}
- dv = map_dev(disk.major, disk.minor);
+ dv = map_dev(disk.major, disk.minor, 1);
if (!dv) {
fprintf(stderr, Name ": cannot find device file for device %d\n",
d);
return 1;
}
- fd2 = open(dv, O_RDWR);
+ fd2 = dev_open(dv, O_RDWR);
if (!fd2) {
fprintf(stderr, Name ": cannot open device file %s\n", dv);
return 1;
info.disk.minor = minor(stb.st_rdev);
info.disk.raid_disk = d;
info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
- st->ss->update_super(&info, super, "grow", newdev, 0);
+ st->ss->update_super(&info, super, "grow", newdev, 0, 0, NULL);
if (st->ss->store_super(st, nfd, super)) {
fprintf(stderr, Name ": Cannot store new superblock on %s\n", newdev);
d);
return 1;
}
- dv = map_dev(disk.major, disk.minor);
+ dv = map_dev(disk.major, disk.minor, 1);
if (!dv) {
fprintf(stderr, Name ": cannot find device file for device %d\n",
d);
return 1;
}
- fd2 = open(dv, O_RDWR);
+ fd2 = dev_open(dv, O_RDWR);
if (fd2 < 0) {
fprintf(stderr, Name ": cannot open device file %s\n", dv);
return 1;
info.disk.minor = minor(stb.st_rdev);
info.disk.raid_disk = nd;
info.disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
- st->ss->update_super(&info, super, "grow", dv, 0);
+ st->ss->update_super(&info, super, "grow", dv, 0, 0, NULL);
if (st->ss->store_super(st, fd2, super)) {
fprintf(stderr, Name ": Cannot store new superblock on %s\n", dv);
}
if (array.level == 10) {
- int ncopies = (array.layout&255)*(array.layout>>8);
+ int ncopies = (array.layout&255)*((array.layout>>8)&255);
bitmapsize = bitmapsize * array.raid_disks / ncopies;
}
continue;
if ((disk.state & (1<<MD_DISK_SYNC))==0)
continue;
- dv = map_dev(disk.major, disk.minor);
+ dv = map_dev(disk.major, disk.minor, 1);
if (dv) {
void *super;
- int fd2 = open(dv, O_RDWR);
+ int fd2 = dev_open(dv, O_RDWR);
if (fd2 < 0)
continue;
if (st->ss->load_super(st, fd2, &super, NULL)==0) {
int d;
int max_devs = st->max_devs;
void *super = NULL;
- if (chunk == UnSet)
- chunk = DEFAULT_BITMAP_CHUNK;
/* try to load a superblock */
for (d=0; d<max_devs; d++) {
if ((disk.major==0 && disk.minor==0) ||
(disk.state & (1<<MD_DISK_REMOVED)))
continue;
- dv = map_dev(disk.major, disk.minor);
+ dv = map_dev(disk.major, disk.minor, 1);
if (!dv) continue;
- fd2 = open(dv, O_RDONLY);
+ fd2 = dev_open(dv, O_RDONLY);
if (fd2 >= 0 &&
st->ss->load_super(st, fd2, &super, NULL) == 0) {
close(fd2);
return __cpu_to_le32(csum);
}
-int Grow_reshape(char *devname, int fd, int quiet,
+int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
long long size,
int level, int layout, int chunksize, int raid_disks)
{
* other from happening. Later we could block
* resync for the duration via 'sync_action'...
*/
- if (raid_disks >= 0)
+ if (raid_disks > 0) {
array.raid_disks = raid_disks;
- if (size >= 0)
+ if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+ fprintf(stderr, Name ": Cannot set raid-devices for %s: %s\n",
+ devname, strerror(errno));
+ return 1;
+ }
+ }
+ if (size >= 0) {
array.size = size;
- if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
- fprintf(stderr, Name ": Cannot set device size/shape for %s: %s\n",
- devname, strerror(errno));
- return 1;
+ if (ioctl(fd, SET_ARRAY_INFO, &array) != 0) {
+ fprintf(stderr, Name ": Cannot set device size for %s: %s\n",
+ devname, strerror(errno));
+ return 1;
+ }
}
return 0;
devname);
return 1;
}
- if (sra->spares == 0) {
- fprintf(stderr, Name ": %s: Cannot grow - need a spare to backup critical section\n",
+ if (sra->spares == 0 && backup_file == NULL) {
+ fprintf(stderr, Name ": %s: Cannot grow - need a spare or backup-file to backup critical section\n",
devname);
return 1;
}
nrdisks = array.nr_disks + sra->spares;
/* Now we need to open all these devices so we can read/write.
*/
- fdlist = malloc(nrdisks * sizeof(int));
- offsets = malloc(nrdisks * sizeof(offsets[0]));
+ fdlist = malloc((1+nrdisks) * sizeof(int));
+ offsets = malloc((1+nrdisks) * sizeof(offsets[0]));
if (!fdlist || !offsets) {
fprintf(stderr, Name ": malloc failed: grow aborted\n");
return 1;
}
- for (d=0; d< nrdisks; d++)
+ for (d=0; d <= nrdisks; d++)
fdlist[d] = -1;
d = array.raid_disks;
for (sd = sra->devs; sd; sd=sd->next) {
if (sd->state & (1<<MD_DISK_FAULTY))
continue;
if (sd->state & (1<<MD_DISK_SYNC)) {
- char *dn = map_dev(sd->major, sd->minor);
- fdlist[sd->role] = open(dn, O_RDONLY);
+ char *dn = map_dev(sd->major, sd->minor, 1);
+ fdlist[sd->role] = dev_open(dn, O_RDONLY);
offsets[sd->role] = sd->offset;
if (fdlist[sd->role] < 0) {
fprintf(stderr, Name ": %s: cannot open component %s\n",
- devname, dn);
+ devname, dn?dn:"-unknown-");
goto abort;
}
} else {
/* spare */
- char *dn = map_dev(sd->major, sd->minor);
- fdlist[d] = open(dn, O_RDWR);
+ char *dn = map_dev(sd->major, sd->minor, 1);
+ fdlist[d] = dev_open(dn, O_RDWR);
offsets[d] = sd->offset;
if (fdlist[d]<0) {
fprintf(stderr, Name ": %s: cannot open component %s\n",
- devname, dn);
+ devname, dn?dn:"-unknown");
goto abort;
}
d++;
" --grow aborted\n", devname, i);
goto abort;
}
+ spares = sra->spares;
+ if (backup_file) {
+ fdlist[d] = open(backup_file, O_RDWR|O_CREAT|O_EXCL, 0600);
+ if (fdlist[d] < 0) {
+ fprintf(stderr, Name ": %s: cannot create backup file %s: %s\n",
+ devname, backup_file, strerror(errno));
+ goto abort;
+ }
+ offsets[d] = 8;
+ d++;
+ spares++;
+ }
if (fdlist[array.raid_disks] < 0) {
- fprintf(stderr, Name ": %s: failed to find a spare - --grow aborted\n",
+ fprintf(stderr, Name ": %s: failed to find a spare and no backup-file given - --grow aborted\n",
devname);
goto abort;
}
goto abort;
}
- spares = sra->spares;
- /* Decide offset for the backup and llseek the spares */
+ memcpy(bsb.magic, "md_backup_data-1", 16);
+ st->ss->uuid_from_super((int*)&bsb.set_uuid, super);
+ bsb.mtime = __cpu_to_le64(time(0));
+ bsb.arraystart = 0;
+ bsb.length = __cpu_to_le64(last_block);
+
+ /* Decide offset for the backup, llseek the spares, and write
+ * a leading superblock 4K earlier.
+ */
for (i=array.raid_disks; i<d; i++) {
- offsets[i] += sra->component_size - last_block - 8;
- if (lseek64(fdlist[i], offsets[i]<<9, 0) != offsets[i]<<9) {
+ char buf[4096];
+ if (i==d-1 && backup_file) {
+ /* This is the backup file */
+ offsets[i] = 8;
+ } else
+ offsets[i] += sra->component_size - last_block - 8;
+ if (lseek64(fdlist[i], (offsets[i]<<9) - 4096, 0)
+ != (offsets[i]<<9) - 4096) {
fprintf(stderr, Name ": could not seek...\n");
goto abort;
}
+ memset(buf, 0, sizeof(buf));
+ bsb.devstart = __cpu_to_le64(offsets[i]);
+ bsb.sb_csum = bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb));
+ memcpy(buf, &bsb, sizeof(bsb));
+ if (write(fdlist[i], buf, 4096) != 4096) {
+ fprintf(stderr, Name ": could not write leading superblock\n");
+ goto abort;
+ }
}
array.level = nlevel;
array.raid_disks = ndisks;
err = save_stripes(fdlist, offsets,
odisks, ochunk, olevel, olayout,
spares, fdlist+odisks,
- 0ULL, nstripe*512);
+ 0ULL, last_block*512);
/* abort if there was an error */
if (err < 0) {
devname);
goto abort_resume;
}
- /* FIXME write superblocks */
- memcpy(bsb.magic, "md_backup_data-1", 16);
- st->ss->uuid_from_super((int*)&bsb.set_uuid, super);
- bsb.mtime = __cpu_to_le64(time(0));
- bsb.arraystart = 0;
- bsb.length = __cpu_to_le64(last_block);
+
for (i=odisks; i<d ; i++) {
bsb.devstart = __cpu_to_le64(offsets[i]);
bsb.sb_csum = bsb_csum((char*)&bsb, ((char*)&bsb.sb_csum)-((char*)&bsb));
if (lseek64(fdlist[i], (offsets[i]+last_block)<<9, 0) < 0 ||
- write(fdlist[i], &bsb, sizeof(bsb)) != sizeof(bsb)) {
+ write(fdlist[i], &bsb, sizeof(bsb)) != sizeof(bsb) ||
+ fsync(fdlist[i]) != 0) {
fprintf(stderr, Name ": %s: fail to save metadata for critical region backups.\n",
devname);
goto abort_resume;
memset(&bsb, 0, sizeof(bsb));
for (i=odisks; i<d ; i++) {
lseek64(fdlist[i], (offsets[i]+last_block)<<9, 0);
- write(fdlist[i], &bsb, sizeof(bsb));
+ if (write(fdlist[i], &bsb, sizeof(bsb)) < 0) {
+ fprintf(stderr, Name ": %s: failed to invalidate metadata for raid disk %d\n",
+ devname, i);
+ }
}
/* unsuspend. */
close(fdlist[i]);
free(fdlist);
free(offsets);
+ if (backup_file)
+ unlink(backup_file);
printf(Name ": ... critical section passed.\n");
break;
close(fdlist[i]);
free(fdlist);
free(offsets);
+ if (backup_file)
+ unlink(backup_file);
return 1;
}
* 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)
+int Grow_restart(struct supertype *st, struct mdinfo *info, int *fdlist, int cnt, char *backup_file)
{
int i, j;
int old_disks;
old_disks = info->array.raid_disks - info->delta_disks;
- for (i=old_disks; i<cnt; i++) {
+ for (i=old_disks-(backup_file?1:0); i<cnt; i++) {
void *super = NULL;
struct mdinfo dinfo;
- struct mddev_ident_s id;
struct mdp_backup_super bsb;
+ char buf[4096];
+ int fd;
/* This was a spare and may have some saved data on it.
* Load the superblock, find and load the
* If the backup contains no new info, just return
* else restore data and update all superblocks
*/
- if (fdlist[i] < 0)
- continue;
- if (st->ss->load_super(st, fdlist[i], &super, NULL))
- continue;
+ if (i == old_disks-1) {
+ fd = open(backup_file, O_RDONLY);
+ if (fd<0)
+ continue;
+ } else {
+ fd = fdlist[i];
+ if (fd < 0)
+ continue;
+ if (st->ss->load_super(st, fd, &super, NULL))
+ continue;
- st->ss->getinfo_super(&dinfo, &id, super);
- free(super); super = NULL;
- if (lseek64(fdlist[i],
- (dinfo.data_offset + dinfo.component_size - 8) <<9,
- 0) < 0)
- continue; /* Cannot seek */
- if (read(fdlist[i], &bsb, sizeof(bsb)) != sizeof(bsb))
+ st->ss->getinfo_super(&dinfo, super);
+ free(super); super = NULL;
+ if (lseek64(fd,
+ (dinfo.data_offset + dinfo.component_size - 8) <<9,
+ 0) < 0)
+ continue; /* Cannot seek */
+ }
+ if (read(fd, &bsb, sizeof(bsb)) != sizeof(bsb))
continue; /* Cannot read */
if (memcmp(bsb.magic, "md_backup_data-1", 16) != 0)
continue;
info->reshape_progress)
continue; /* No new data here */
- if (lseek64(fdlist[i], __le64_to_cpu(bsb.devstart)*512, 0)< 0)
+ if (lseek64(fd, __le64_to_cpu(bsb.devstart)*512, 0)< 0)
continue; /* Cannot seek */
+ /* There should be a duplicate backup superblock 4k before here */
+ if (lseek64(fd, -4096, 1) < 0 ||
+ read(fd, buf, 4096) != 4096 ||
+ memcmp(buf, &bsb, sizeof(bsb)) != 0)
+ continue; /* Cannot find leading superblock */
/* Now need the data offsets for all devices. */
offsets = malloc(sizeof(*offsets)*info->array.raid_disks);
if (st->ss->load_super(st, fdlist[j], &super, NULL))
/* FIXME should be this be an error */
continue;
- st->ss->getinfo_super(&dinfo, &id, super);
+ st->ss->getinfo_super(&dinfo, super);
free(super); super = NULL;
offsets[j] = dinfo.data_offset;
}
info->new_chunk,
info->new_level,
info->new_layout,
- fdlist[i], __le64_to_cpu(bsb.devstart)*512,
+ fd, __le64_to_cpu(bsb.devstart)*512,
0, __le64_to_cpu(bsb.length)*512)) {
/* didn't succeed, so giveup */
return -1;
if (fdlist[j] < 0) continue;
if (st->ss->load_super(st, fdlist[j], &super, NULL))
continue;
- st->ss->getinfo_super(&dinfo, &id, super);
+ st->ss->getinfo_super(&dinfo, super);
dinfo.reshape_progress = __le64_to_cpu(bsb.length);
- st->ss->update_super(&dinfo, super, "_reshape_progress",NULL,0);
+ st->ss->update_super(&dinfo, super, "_reshape_progress",NULL,0, 0, NULL);
st->ss->store_super(st, fdlist[j], super);
free(super);
}
projects / thirdparty / mdadm.git / blobdiff