int sysfs_set_num_signed(struct mdinfo *sra, struct mdinfo *dev,
char *name, long long val)
{
char valstr[50];
sprintf(valstr, "%lli", val);
return sysfs_set_str(sra, dev, name, valstr);
}
int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume)
{
char dv[PATH_MAX];
char nm[PATH_MAX];
char *dname;
int rv;
sprintf(dv, "%d:%d", sd->disk.major, sd->disk.minor);
rv = sysfs_set_str(sra, NULL, "new_dev", dv);
if (rv)
return rv;
memset(nm, 0, sizeof(nm));
sprintf(dv, "/sys/dev/block/%d:%d", sd->disk.major, sd->disk.minor);
rv = readlink(dv, nm, sizeof(nm)-1);
if (rv <= 0)
return -1;
nm[rv] = '\0';
dname = strrchr(nm, '/');
if (dname) dname++;
strcpy(sd->sys_name, "dev-");
strcpy(sd->sys_name+4, dname);
/* test write to see if 'recovery_start' is available */
if (resume && sd->recovery_start < MaxSector &&
sysfs_set_num(sra, sd, "recovery_start", 0)) {
sysfs_set_str(sra, sd, "state", "remove");
return -1;
}
rv = sysfs_set_num(sra, sd, "offset", sd->data_offset);
rv |= sysfs_set_num(sra, sd, "size", (sd->component_size+1) / 2);
if (sra->array.level != LEVEL_CONTAINER) {
if (sd->recovery_start == MaxSector)
/* This can correctly fail if array isn't started,
* yet, so just ignore status for now.
*/
sysfs_set_str(sra, sd, "state", "insync");
if (sd->disk.raid_disk >= 0)
rv |= sysfs_set_num(sra, sd, "slot", sd->disk.raid_disk);
if (resume)
sysfs_set_num(sra, sd, "recovery_start", sd->recovery_start);
}
return rv;
}
int unblock_subarray(struct mdinfo *sra, const int unfreeze)
{
char buf[64];
int rc = 0;
if (sra) {
sprintf(buf, "external:%s\n", sra->text_version);
buf[9] = '/';
} else
buf[9] = '-';
if (buf[9] == '-' ||
sysfs_set_str(sra, NULL, "metadata_version", buf) ||
(unfreeze &&
sysfs_attribute_available(sra, NULL, "sync_action") &&
sysfs_set_str(sra, NULL, "sync_action", "idle")))
rc = -1;
return rc;
}
int block_subarray(struct mdinfo *sra)
{
char buf[64];
int rc = 0;
sprintf(buf, "external:%s\n", sra->text_version);
buf[9] = '-';
if (sysfs_set_str(sra, NULL, "metadata_version", buf))
rc = -1;
return rc;
}
int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms)
{
unsigned long sec;
unsigned long msec;
char delay[30];
sec = ms / 1000;
msec = ms % 1000;
sprintf(delay, "%ld.%03ld\n", sec, msec);
/* this '\n' ^ needed for kernels older than 2.6.28 */
return sysfs_set_str(sra, NULL, "safe_mode_delay", delay);
}
int sysfs_freeze_array(struct mdinfo *sra)
{
/* Try to freeze resync/rebuild on this array/container.
* Return -1 if the array is busy,
* return 0 if this kernel doesn't support 'frozen'
* return 1 if it worked.
*/
char buf[20];
if (!sysfs_attribute_available(sra, NULL, "sync_action"))
return 1; /* no sync_action == frozen */
if (sysfs_get_str(sra, NULL, "sync_action", buf, 20) <= 0)
return 0;
if (strcmp(buf, "frozen\n") == 0)
/* Already frozen */
return 0;
if (strcmp(buf, "idle\n") != 0 && strcmp(buf, "recover\n") != 0)
return -1;
if (sysfs_set_str(sra, NULL, "sync_action", "frozen") < 0)
return 0;
return 1;
}
int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume)
{
char dv[PATH_MAX];
char nm[PATH_MAX];
char *dname;
int rv;
int i;
sprintf(dv, "%d:%d", sd->disk.major, sd->disk.minor);
rv = sysfs_set_str(sra, NULL, "new_dev", dv);
if (rv)
return rv;
memset(nm, 0, sizeof(nm));
dname = devid2kname(makedev(sd->disk.major, sd->disk.minor));
strcpy(sd->sys_name, "dev-");
strcpy(sd->sys_name+4, dname);
/* test write to see if 'recovery_start' is available */
if (resume && sd->recovery_start < MaxSector &&
sysfs_set_num(sra, sd, "recovery_start", 0)) {
sysfs_set_str(sra, sd, "state", "remove");
return -1;
}
rv = sysfs_set_num(sra, sd, "offset", sd->data_offset);
rv |= sysfs_set_num(sra, sd, "size", (sd->component_size+1) / 2);
if (sra->array.level != LEVEL_CONTAINER) {
if (sd->recovery_start == MaxSector)
/* This can correctly fail if array isn't started,
* yet, so just ignore status for now.
*/
sysfs_set_str(sra, sd, "state", "insync");
if (sd->disk.raid_disk >= 0)
rv |= sysfs_set_num(sra, sd, "slot", sd->disk.raid_disk);
if (resume)
sysfs_set_num(sra, sd, "recovery_start", sd->recovery_start);
}
if (sd->bb.supported) {
if (sysfs_set_str(sra, sd, "state", "external_bbl")) {
/*
* backward compatibility - if kernel doesn't support
* bad blocks for external metadata, let it continue
* as long as there are none known so far
*/
if (sd->bb.count) {
pr_err("The kernel has no support for bad blocks in external metadata\n");
return -1;
}
}
for (i = 0; i < sd->bb.count; i++) {
char s[30];
const struct md_bb_entry *entry = &sd->bb.entries[i];
snprintf(s, sizeof(s) - 1, "%llu %d\n", entry->sector,
entry->length);
rv |= sysfs_set_str(sra, sd, "bad_blocks", s);
}
}
return rv;
}
int sysfs_set_array(struct mdinfo *info, int vers)
{
int rv = 0;
char ver[100];
int raid_disks = info->array.raid_disks;
ver[0] = 0;
if (info->array.major_version == -1 &&
info->array.minor_version == -2) {
char buf[1024];
strcat(strcpy(ver, "external:"), info->text_version);
/* meta version might already be set if we are setting
* new geometry for a reshape. In that case we don't
* want to over-write the 'readonly' flag that is
* stored in the metadata version. So read the current
* version first, and preserve the flag
*/
if (sysfs_get_str(info, NULL, "metadata_version",
buf, 1024) > 0)
if (strlen(buf) >= 9 && buf[9] == '-')
ver[9] = '-';
if ((vers % 100) < 2 ||
sysfs_set_str(info, NULL, "metadata_version",
ver) < 0) {
pr_err("This kernel does not support external metadata.\n");
return 1;
}
}
if (info->array.level < 0)
return 0; /* FIXME */
rv |= sysfs_set_str(info, NULL, "level",
map_num(pers, info->array.level));
if (info->reshape_active && info->delta_disks != UnSet)
raid_disks -= info->delta_disks;
rv |= sysfs_set_num(info, NULL, "raid_disks", raid_disks);
rv |= sysfs_set_num(info, NULL, "chunk_size", info->array.chunk_size);
rv |= sysfs_set_num(info, NULL, "layout", info->array.layout);
rv |= sysfs_set_num(info, NULL, "component_size", info->component_size/2);
if (info->custom_array_size) {
int rc;
rc = sysfs_set_num(info, NULL, "array_size",
info->custom_array_size/2);
if (rc && errno == ENOENT) {
pr_err("This kernel does not have the md/array_size attribute, the array may be larger than expected\n");
rc = 0;
}
rv |= rc;
}
if (info->array.level > 0)
rv |= sysfs_set_num(info, NULL, "resync_start", info->resync_start);
if (info->reshape_active) {
rv |= sysfs_set_num(info, NULL, "reshape_position",
info->reshape_progress);
rv |= sysfs_set_num(info, NULL, "chunk_size", info->new_chunk);
rv |= sysfs_set_num(info, NULL, "layout", info->new_layout);
rv |= sysfs_set_num(info, NULL, "raid_disks",
info->array.raid_disks);
/* We don't set 'new_level' here. That can only happen
* once the reshape completes.
*/
}
return rv;
}
int Manage_subdevs(char *devname, int fd,
struct mddev_dev *devlist, int verbose, int test,
char *update)
{
/* do something to each dev.
* devmode can be
* 'a' - add the device
* try HOT_ADD_DISK
* If that fails EINVAL, try ADD_NEW_DISK
* 'r' - remove the device HOT_REMOVE_DISK
* device can be 'faulty' or 'detached' in which case all
* matching devices are removed.
* 'f' - set the device faulty SET_DISK_FAULTY
* device can be 'detached' in which case any device that
* is inaccessible will be marked faulty.
* For 'f' and 'r', the device can also be a kernel-internal
* name such as 'sdb'.
*/
struct mddev_dev *add_devlist = NULL;
mdu_array_info_t array;
mdu_disk_info_t disc;
unsigned long long array_size;
struct mddev_dev *dv, *next = NULL;
struct stat stb;
int j, jnext = 0;
int tfd = -1;
struct supertype *st, *tst;
char *subarray = NULL;
int duuid[4];
int ouuid[4];
int lfd = -1;
int sysfd = -1;
int count = 0; /* number of actions taken */
if (ioctl(fd, GET_ARRAY_INFO, &array)) {
fprintf(stderr, Name ": cannot get array info for %s\n",
devname);
return 1;
}
/* array.size is only 32 bit and may be truncated.
* So read from sysfs if possible, and record number of sectors
*/
array_size = get_component_size(fd);
if (array_size <= 0)
array_size = array.size * 2;
tst = super_by_fd(fd, &subarray);
if (!tst) {
fprintf(stderr, Name ": unsupport array - version %d.%d\n",
array.major_version, array.minor_version);
return 1;
}
stb.st_rdev = 0;
for (dv = devlist, j=0 ; dv; dv = next, j = jnext) {
unsigned long long ldsize;
char dvname[20];
char *dnprintable = dv->devname;
char *add_dev = dv->devname;
int err;
int re_add_failed = 0;
next = dv->next;
jnext = 0;
if (strcmp(dv->devname, "failed")==0 ||
strcmp(dv->devname, "faulty")==0) {
int remaining_disks = array.nr_disks;
if (dv->disposition != 'r') {
fprintf(stderr, Name ": %s only meaningful "
"with -r, not -%c\n",
dv->devname, dv->disposition);
return 1;
}
for (; j < 1024 && remaining_disks > 0; j++) {
unsigned dev;
disc.number = j;
if (ioctl(fd, GET_DISK_INFO, &disc))
continue;
if (disc.major == 0 && disc.minor == 0)
continue;
remaining_disks --;
if ((disc.state & 1) == 0) /* faulty */
continue;
dev = makedev(disc.major, disc.minor);
if (stb.st_rdev == dev)
/* already did that one */
continue;
stb.st_rdev = dev;
next = dv;
/* same slot again next time - things might
* have reshuffled */
jnext = j;
sprintf(dvname,"%d:%d", disc.major, disc.minor);
dnprintable = dvname;
break;
}
if (next != dv)
continue;
} else if (strcmp(dv->devname, "detached") == 0) {
int remaining_disks = array.nr_disks;
if (dv->disposition != 'r' && dv->disposition != 'f') {
fprintf(stderr, Name ": %s only meaningful "
"with -r of -f, not -%c\n",
dv->devname, dv->disposition);
return 1;
}
for (; j < 1024 && remaining_disks > 0; j++) {
int sfd;
unsigned dev;
disc.number = j;
if (ioctl(fd, GET_DISK_INFO, &disc))
continue;
if (disc.major == 0 && disc.minor == 0)
continue;
remaining_disks --;
sprintf(dvname,"%d:%d", disc.major, disc.minor);
sfd = dev_open(dvname, O_RDONLY);
if (sfd >= 0) {
close(sfd);
continue;
}
if (dv->disposition == 'f' &&
(disc.state & 1) == 1) /* already faulty */
continue;
if (errno != ENXIO)
continue;
dev = makedev(disc.major, disc.minor);
if (stb.st_rdev == dev)
/* already did that one */
continue;
stb.st_rdev = dev;
next = dv;
/* same slot again next time - things might
* have reshuffled */
jnext = j;
dnprintable = dvname;
break;
}
if (next != dv)
continue;
} else if (strcmp(dv->devname, "missing") == 0) {
if (dv->disposition != 'a' || dv->re_add == 0) {
fprintf(stderr, Name ": 'missing' only meaningful "
"with --re-add\n");
return 1;
}
if (add_devlist == NULL)
add_devlist = conf_get_devs();
if (add_devlist == NULL) {
fprintf(stderr, Name ": no devices to scan for missing members.");
continue;
}
add_dev = add_devlist->devname;
add_devlist = add_devlist->next;
if (add_devlist != NULL)
next = dv;
if (stat(add_dev, &stb) < 0)
continue;
} else if (strchr(dv->devname, '/') == NULL &&
strchr(dv->devname, ':') == NULL &&
strlen(dv->devname) < 50) {
/* Assume this is a kernel-internal name like 'sda1' */
int found = 0;
char dname[55];
if (dv->disposition != 'r' && dv->disposition != 'f') {
fprintf(stderr, Name ": %s only meaningful "
"with -r or -f, not -%c\n",
dv->devname, dv->disposition);
return 1;
}
sprintf(dname, "dev-%s", dv->devname);
sysfd = sysfs_open(fd2devnum(fd), dname, "block/dev");
if (sysfd >= 0) {
char dn[20];
int mj,mn;
if (sysfs_fd_get_str(sysfd, dn, 20) > 0 &&
sscanf(dn, "%d:%d", &mj,&mn) == 2) {
stb.st_rdev = makedev(mj,mn);
found = 1;
}
close(sysfd);
sysfd = -1;
}
if (!found) {
sysfd = sysfs_open(fd2devnum(fd), dname, "state");
if (sysfd < 0) {
fprintf(stderr, Name ": %s does not appear "
"to be a component of %s\n",
dv->devname, devname);
return 1;
}
}
} else {
j = 0;
tfd = dev_open(dv->devname, O_RDONLY);
if (tfd < 0 && dv->disposition == 'r' &&
lstat(dv->devname, &stb) == 0)
/* Be happy, the lstat worked, that is
* enough for --remove
*/
;
else {
if (tfd < 0 || fstat(tfd, &stb) != 0) {
fprintf(stderr, Name ": cannot find %s: %s\n",
dv->devname, strerror(errno));
if (tfd >= 0)
close(tfd);
return 1;
}
close(tfd);
tfd = -1;
}
if ((stb.st_mode & S_IFMT) != S_IFBLK) {
fprintf(stderr, Name ": %s is not a "
"block device.\n",
dv->devname);
return 1;
}
}
switch(dv->disposition){
default:
fprintf(stderr, Name ": internal error - devmode[%s]=%d\n",
dv->devname, dv->disposition);
return 1;
case 'a':
/* add the device */
if (subarray) {
fprintf(stderr, Name ": Cannot add disks to a"
" \'member\' array, perform this"
" operation on the parent container\n");
return 1;
}
/* Make sure it isn't in use (in 2.6 or later) */
tfd = dev_open(add_dev, O_RDONLY|O_EXCL|O_DIRECT);
if (tfd < 0 && add_dev != dv->devname)
continue;
if (tfd < 0) {
fprintf(stderr, Name ": Cannot open %s: %s\n",
dv->devname, strerror(errno));
return 1;
}
st = dup_super(tst);
if (array.not_persistent==0)
st->ss->load_super(st, tfd, NULL);
if (add_dev == dv->devname) {
if (!get_dev_size(tfd, dv->devname, &ldsize)) {
close(tfd);
return 1;
}
} else if (!get_dev_size(tfd, NULL, &ldsize)) {
close(tfd);
tfd = -1;
continue;
}
if (!tst->ss->external &&
array.major_version == 0 &&
md_get_version(fd)%100 < 2) {
close(tfd);
tfd = -1;
if (ioctl(fd, HOT_ADD_DISK,
(unsigned long)stb.st_rdev)==0) {
if (verbose >= 0)
fprintf(stderr, Name ": hot added %s\n",
add_dev);
continue;
}
fprintf(stderr, Name ": hot add failed for %s: %s\n",
add_dev, strerror(errno));
return 1;
}
if (array.not_persistent == 0 || tst->ss->external) {
/* need to find a sample superblock to copy, and
* a spare slot to use.
* For 'external' array (well, container based),
* We can just load the metadata for the array.
*/
if (tst->sb)
/* already loaded */;
else if (tst->ss->external) {
tst->ss->load_container(tst, fd, NULL);
} else for (j = 0; j < tst->max_devs; j++) {
char *dev;
int dfd;
disc.number = j;
if (ioctl(fd, GET_DISK_INFO, &disc))
continue;
if (disc.major==0 && disc.minor==0)
continue;
if ((disc.state & 4)==0) continue; /* sync */
/* Looks like a good device to try */
dev = map_dev(disc.major, disc.minor, 1);
if (!dev) continue;
dfd = dev_open(dev, O_RDONLY);
if (dfd < 0) continue;
if (tst->ss->load_super(tst, dfd,
NULL)) {
close(dfd);
continue;
}
close(dfd);
break;
}
/* FIXME this is a bad test to be using */
if (!tst->sb) {
close(tfd);
fprintf(stderr, Name ": cannot load array metadata from %s\n", devname);
return 1;
}
/* Make sure device is large enough */
if (tst->ss->avail_size(tst, ldsize/512) <
array_size) {
close(tfd);
tfd = -1;
if (add_dev != dv->devname)
continue;
fprintf(stderr, Name ": %s not large enough to join array\n",
dv->devname);
return 1;
}
/* Possibly this device was recently part of the array
* and was temporarily removed, and is now being re-added.
* If so, we can simply re-add it.
*/
tst->ss->uuid_from_super(tst, duuid);
if (st->sb) {
struct mdinfo mdi;
st->ss->getinfo_super(st, &mdi, NULL);
st->ss->uuid_from_super(st, ouuid);
if ((mdi.disk.state & (1<<MD_DISK_ACTIVE)) &&
!(mdi.disk.state & (1<<MD_DISK_FAULTY)) &&
memcmp(duuid, ouuid, sizeof(ouuid))==0) {
/* look like it is worth a try. Need to
* make sure kernel will accept it though.
*/
/* re-add doesn't work for version-1 superblocks
* before 2.6.18 :-(
*/
if (array.major_version == 1 &&
get_linux_version() <= 2006018)
goto skip_re_add;
disc.number = mdi.disk.number;
if (ioctl(fd, GET_DISK_INFO, &disc) != 0
|| disc.major != 0 || disc.minor != 0
|| !enough_fd(fd))
goto skip_re_add;
disc.major = major(stb.st_rdev);
disc.minor = minor(stb.st_rdev);
disc.number = mdi.disk.number;
disc.raid_disk = mdi.disk.raid_disk;
disc.state = mdi.disk.state;
if (dv->writemostly == 1)
disc.state |= 1 << MD_DISK_WRITEMOSTLY;
if (dv->writemostly == 2)
disc.state &= ~(1 << MD_DISK_WRITEMOSTLY);
remove_partitions(tfd);
close(tfd);
tfd = -1;
if (update) {
int rv = -1;
tfd = dev_open(dv->devname, O_RDWR);
if (tfd >= 0)
rv = st->ss->update_super(
st, NULL, update,
devname, verbose, 0, NULL);
if (rv == 0)
rv = st->ss->store_super(st, tfd);
close(tfd);
tfd = -1;
if (rv != 0) {
fprintf(stderr, Name ": failed to update"
" superblock during re-add\n");
return 1;
}
}
/* don't even try if disk is marked as faulty */
errno = 0;
if (ioctl(fd, ADD_NEW_DISK, &disc) == 0) {
if (verbose >= 0)
fprintf(stderr, Name ": re-added %s\n", add_dev);
count++;
continue;
}
if (errno == ENOMEM || errno == EROFS) {
fprintf(stderr, Name ": add new device failed for %s: %s\n",
add_dev, strerror(errno));
if (add_dev != dv->devname)
continue;
return 1;
}
skip_re_add:
re_add_failed = 1;
}
st->ss->free_super(st);
}
if (add_dev != dv->devname) {
if (verbose > 0)
fprintf(stderr, Name
": --re-add for %s to %s is not possible\n",
add_dev, devname);
if (tfd >= 0) {
close(tfd);
tfd = -1;
}
continue;
}
if (dv->re_add) {
if (tfd >= 0)
close(tfd);
fprintf(stderr, Name
": --re-add for %s to %s is not possible\n",
dv->devname, devname);
return 1;
}
if (re_add_failed) {
fprintf(stderr, Name ": %s reports being an active member for %s, but a --re-add fails.\n",
dv->devname, devname);
fprintf(stderr, Name ": not performing --add as that would convert %s in to a spare.\n",
dv->devname);
fprintf(stderr, Name ": To make this a spare, use \"mdadm --zero-superblock %s\" first.\n",
dv->devname);
if (tfd >= 0)
close(tfd);
return 1;
}
} else {
/* non-persistent. Must ensure that new drive
* is at least array.size big.
*/
if (ldsize/512 < array_size) {
fprintf(stderr, Name ": %s not large enough to join array\n",
dv->devname);
if (tfd >= 0)
close(tfd);
return 1;
}
}
/* committed to really trying this device now*/
if (tfd >= 0) {
remove_partitions(tfd);
close(tfd);
tfd = -1;
}
/* in 2.6.17 and earlier, version-1 superblocks won't
* use the number we write, but will choose a free number.
* we must choose the same free number, which requires
* starting at 'raid_disks' and counting up
*/
for (j = array.raid_disks; j< tst->max_devs; j++) {
disc.number = j;
if (ioctl(fd, GET_DISK_INFO, &disc))
break;
if (disc.major==0 && disc.minor==0)
break;
if (disc.state & 8) /* removed */
break;
}
disc.major = major(stb.st_rdev);
disc.minor = minor(stb.st_rdev);
disc.number =j;
disc.state = 0;
if (array.not_persistent==0) {
int dfd;
if (dv->writemostly == 1)
disc.state |= 1 << MD_DISK_WRITEMOSTLY;
dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
if (tst->ss->add_to_super(tst, &disc, dfd,
dv->devname)) {
close(dfd);
return 1;
}
if (tst->ss->write_init_super(tst)) {
close(dfd);
return 1;
}
} else if (dv->re_add) {
/* this had better be raid1.
* As we are "--re-add"ing we must find a spare slot
* to fill.
*/
char *used = malloc(array.raid_disks);
memset(used, 0, array.raid_disks);
for (j=0; j< tst->max_devs; j++) {
mdu_disk_info_t disc2;
disc2.number = j;
if (ioctl(fd, GET_DISK_INFO, &disc2))
continue;
if (disc2.major==0 && disc2.minor==0)
continue;
if (disc2.state & 8) /* removed */
continue;
if (disc2.raid_disk < 0)
continue;
if (disc2.raid_disk > array.raid_disks)
continue;
used[disc2.raid_disk] = 1;
}
for (j=0 ; j<array.raid_disks; j++)
if (!used[j]) {
disc.raid_disk = j;
disc.state |= (1<<MD_DISK_SYNC);
break;
}
free(used);
}
if (dv->writemostly == 1)
disc.state |= (1 << MD_DISK_WRITEMOSTLY);
if (tst->ss->external) {
/* add a disk
* to an external metadata container */
struct mdinfo new_mdi;
struct mdinfo *sra;
int container_fd;
int devnum = fd2devnum(fd);
int dfd;
container_fd = open_dev_excl(devnum);
if (container_fd < 0) {
fprintf(stderr, Name ": add failed for %s:"
" could not get exclusive access to container\n",
dv->devname);
tst->ss->free_super(tst);
return 1;
}
dfd = dev_open(dv->devname, O_RDWR | O_EXCL|O_DIRECT);
if (mdmon_running(tst->container_dev))
tst->update_tail = &tst->updates;
if (tst->ss->add_to_super(tst, &disc, dfd,
dv->devname)) {
close(dfd);
close(container_fd);
return 1;
}
if (tst->update_tail)
flush_metadata_updates(tst);
else
tst->ss->sync_metadata(tst);
sra = sysfs_read(container_fd, -1, 0);
if (!sra) {
fprintf(stderr, Name ": add failed for %s: sysfs_read failed\n",
dv->devname);
close(container_fd);
tst->ss->free_super(tst);
return 1;
}
sra->array.level = LEVEL_CONTAINER;
/* Need to set data_offset and component_size */
tst->ss->getinfo_super(tst, &new_mdi, NULL);
new_mdi.disk.major = disc.major;
new_mdi.disk.minor = disc.minor;
new_mdi.recovery_start = 0;
/* Make sure fds are closed as they are O_EXCL which
* would block add_disk */
tst->ss->free_super(tst);
if (sysfs_add_disk(sra, &new_mdi, 0) != 0) {
fprintf(stderr, Name ": add new device to external metadata"
" failed for %s\n", dv->devname);
close(container_fd);
sysfs_free(sra);
return 1;
}
ping_monitor_by_id(devnum);
sysfs_free(sra);
close(container_fd);
} else {
tst->ss->free_super(tst);
if (ioctl(fd, ADD_NEW_DISK, &disc)) {
fprintf(stderr, Name ": add new device failed for %s as %d: %s\n",
dv->devname, j, strerror(errno));
return 1;
}
}
if (verbose >= 0)
fprintf(stderr, Name ": added %s\n", dv->devname);
break;
case 'r':
/* hot remove */
if (subarray) {
fprintf(stderr, Name ": Cannot remove disks from a"
" \'member\' array, perform this"
" operation on the parent container\n");
if (sysfd >= 0)
close(sysfd);
return 1;
}
if (tst->ss->external) {
/* To remove a device from a container, we must
* check that it isn't in use in an array.
* This involves looking in the 'holders'
* directory - there must be just one entry,
* the container.
* To ensure that it doesn't get used as a
* hold spare while we are checking, we
* get an O_EXCL open on the container
*/
int dnum = fd2devnum(fd);
lfd = open_dev_excl(dnum);
if (lfd < 0) {
fprintf(stderr, Name
": Cannot get exclusive access "
" to container - odd\n");
if (sysfd >= 0)
close(sysfd);
return 1;
}
/* in the detached case it is not possible to
* check if we are the unique holder, so just
* rely on the 'detached' checks
*/
if (strcmp(dv->devname, "detached") == 0 ||
sysfd >= 0 ||
sysfs_unique_holder(dnum, stb.st_rdev))
/* pass */;
else {
fprintf(stderr, Name
": %s is %s, cannot remove.\n",
dnprintable,
errno == EEXIST ? "still in use":
"not a member");
close(lfd);
return 1;
}
}
/* FIXME check that it is a current member */
if (sysfd >= 0) {
/* device has been removed and we don't know
* the major:minor number
*/
int n = write(sysfd, "remove", 6);
if (n != 6)
err = -1;
else
err = 0;
close(sysfd);
sysfd = -1;
} else {
err = ioctl(fd, HOT_REMOVE_DISK, (unsigned long)stb.st_rdev);
if (err && errno == ENODEV) {
/* Old kernels rejected this if no personality
* registered */
struct mdinfo *sra = sysfs_read(fd, 0, GET_DEVS);
struct mdinfo *dv = NULL;
if (sra)
dv = sra->devs;
for ( ; dv ; dv=dv->next)
if (dv->disk.major == (int)major(stb.st_rdev) &&
dv->disk.minor == (int)minor(stb.st_rdev))
break;
if (dv)
err = sysfs_set_str(sra, dv,
"state", "remove");
else
err = -1;
if (sra)
sysfs_free(sra);
}
}
if (err) {
fprintf(stderr, Name ": hot remove failed "
"for %s: %s\n", dnprintable,
strerror(errno));
if (lfd >= 0)
close(lfd);
return 1;
}
if (tst->ss->external) {
/*
* Before dropping our exclusive open we make an
* attempt at preventing mdmon from seeing an
* 'add' event before reconciling this 'remove'
* event.
*/
char *name = devnum2devname(fd2devnum(fd));
if (!name) {
fprintf(stderr, Name ": unable to get container name\n");
return 1;
}
ping_manager(name);
free(name);
}
if (lfd >= 0)
close(lfd);
count++;
if (verbose >= 0)
fprintf(stderr, Name ": hot removed %s from %s\n",
dnprintable, devname);
break;
case 'f': /* set faulty */
/* FIXME check current member */
if ((sysfd >= 0 && write(sysfd, "faulty", 6) != 6) ||
(sysfd < 0 && ioctl(fd, SET_DISK_FAULTY,
(unsigned long) stb.st_rdev))) {
fprintf(stderr, Name ": set device faulty failed for %s: %s\n",
dnprintable, strerror(errno));
if (sysfd >= 0)
close(sysfd);
return 1;
}
if (sysfd >= 0)
close(sysfd);
sysfd = -1;
count++;
if (verbose >= 0)
fprintf(stderr, Name ": set %s faulty in %s\n",
dnprintable, devname);
break;
}
}
if (test && count == 0)
return 2;
return 0;
}
int Manage_ro(char *devname, int fd, int readonly)
{
/* switch to readonly or rw
*
* requires >= 0.90.0
* first check that array is runing
* use RESTART_ARRAY_RW or STOP_ARRAY_RO
*
*/
mdu_array_info_t array;
#ifndef MDASSEMBLE
struct mdinfo *mdi;
#endif
if (md_get_version(fd) < 9000) {
fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
return 1;
}
#ifndef MDASSEMBLE
/* If this is an externally-manage array, we need to modify the
* metadata_version so that mdmon doesn't undo our change.
*/
mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
if (mdi &&
mdi->array.major_version == -1 &&
is_subarray(mdi->text_version)) {
char vers[64];
strcpy(vers, "external:");
strcat(vers, mdi->text_version);
if (readonly > 0) {
int rv;
/* We set readonly ourselves. */
vers[9] = '-';
sysfs_set_str(mdi, NULL, "metadata_version", vers);
close(fd);
rv = sysfs_set_str(mdi, NULL, "array_state", "readonly");
if (rv < 0) {
fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
devname, strerror(errno));
vers[9] = mdi->text_version[0];
sysfs_set_str(mdi, NULL, "metadata_version", vers);
return 1;
}
} else {
char *cp;
/* We cannot set read/write - must signal mdmon */
vers[9] = '/';
sysfs_set_str(mdi, NULL, "metadata_version", vers);
cp = strchr(vers+10, '/');
if (*cp)
*cp = 0;
ping_monitor(vers+10);
if (mdi->array.level <= 0)
sysfs_set_str(mdi, NULL, "array_state", "active");
}
return 0;
}
#endif
if (ioctl(fd, GET_ARRAY_INFO, &array)) {
fprintf(stderr, Name ": %s does not appear to be active.\n",
devname);
return 1;
}
if (readonly>0) {
if (ioctl(fd, STOP_ARRAY_RO, NULL)) {
fprintf(stderr, Name ": failed to set readonly for %s: %s\n",
devname, strerror(errno));
return 1;
}
} else if (readonly < 0) {
if (ioctl(fd, RESTART_ARRAY_RW, NULL)) {
fprintf(stderr, Name ": failed to set writable for %s: %s\n",
devname, strerror(errno));
return 1;
}
}
return 0;
}
int Manage_runstop(char *devname, int fd, int runstop, int quiet)
{
/* Run or stop the array. array must already be configured
* required >= 0.90.0
* Only print failure messages if quiet == 0;
* quiet > 0 means really be quiet
* quiet < 0 means we will try again if it fails.
*/
mdu_param_t param; /* unused */
if (runstop == -1 && md_get_version(fd) < 9000) {
if (ioctl(fd, STOP_MD, 0)) {
if (quiet == 0) fprintf(stderr,
Name ": stopping device %s "
"failed: %s\n",
devname, strerror(errno));
return 1;
}
}
if (md_get_version(fd) < 9000) {
fprintf(stderr, Name ": need md driver version 0.90.0 or later\n");
return 1;
}
/*
if (ioctl(fd, GET_ARRAY_INFO, &array)) {
fprintf(stderr, Name ": %s does not appear to be active.\n",
devname);
return 1;
}
*/
if (runstop>0) {
if (ioctl(fd, RUN_ARRAY, ¶m)) {
fprintf(stderr, Name ": failed to run array %s: %s\n",
devname, strerror(errno));
return 1;
}
if (quiet <= 0)
fprintf(stderr, Name ": started %s\n", devname);
} else if (runstop < 0){
struct map_ent *map = NULL;
struct stat stb;
struct mdinfo *mdi;
int devnum;
int err;
int count;
/* If this is an mdmon managed array, just write 'inactive'
* to the array state and let mdmon clear up.
*/
devnum = fd2devnum(fd);
/* Get EXCL access first. If this fails, then attempting
* to stop is probably a bad idea.
*/
close(fd);
fd = open(devname, O_RDONLY|O_EXCL);
if (fd < 0 || fd2devnum(fd) != devnum) {
if (fd >= 0)
close(fd);
fprintf(stderr,
Name ": Cannot get exclusive access to %s:"
"Perhaps a running "
"process, mounted filesystem "
"or active volume group?\n",
devname);
return 1;
}
mdi = sysfs_read(fd, -1, GET_LEVEL|GET_VERSION);
if (mdi &&
mdi->array.level > 0 &&
is_subarray(mdi->text_version)) {
int err;
/* This is mdmon managed. */
close(fd);
count = 25;
while (count &&
(err = sysfs_set_str(mdi, NULL,
"array_state",
"inactive")) < 0
&& errno == EBUSY) {
usleep(200000);
count--;
}
if (err && !quiet) {
fprintf(stderr, Name
": failed to stop array %s: %s\n",
devname, strerror(errno));
return 1;
}
/* Give monitor a chance to act */
ping_monitor(mdi->text_version);
fd = open_dev_excl(devnum);
if (fd < 0) {
fprintf(stderr, Name
": failed to completely stop %s"
": Device is busy\n",
devname);
return 1;
}
} else if (mdi &&
mdi->array.major_version == -1 &&
mdi->array.minor_version == -2 &&
!is_subarray(mdi->text_version)) {
struct mdstat_ent *mds, *m;
/* container, possibly mdmon-managed.
* Make sure mdmon isn't opening it, which
* would interfere with the 'stop'
*/
ping_monitor(mdi->sys_name);
/* now check that there are no existing arrays
* which are members of this array
*/
mds = mdstat_read(0, 0);
for (m=mds; m; m=m->next)
if (m->metadata_version &&
strncmp(m->metadata_version, "external:", 9)==0 &&
is_subarray(m->metadata_version+9) &&
devname2devnum(m->metadata_version+10) == devnum) {
if (!quiet)
fprintf(stderr, Name
": Cannot stop container %s: "
"member %s still active\n",
devname, m->dev);
free_mdstat(mds);
if (mdi)
sysfs_free(mdi);
return 1;
}
}
/* As we have an O_EXCL open, any use of the device
* which blocks STOP_ARRAY is probably a transient use,
* so it is reasonable to retry for a while - 5 seconds.
*/
count = 25; err = 0;
while (count && fd >= 0
&& (err = ioctl(fd, STOP_ARRAY, NULL)) < 0
&& errno == EBUSY) {
usleep(200000);
count --;
}
if (fd >= 0 && err) {
if (quiet == 0) {
fprintf(stderr, Name
": failed to stop array %s: %s\n",
devname, strerror(errno));
if (errno == EBUSY)
fprintf(stderr, "Perhaps a running "
"process, mounted filesystem "
"or active volume group?\n");
}
if (mdi)
sysfs_free(mdi);
return 1;
}
/* prior to 2.6.28, KOBJ_CHANGE was not sent when an md array
* was stopped, so We'll do it here just to be sure. Drop any
* partitions as well...
*/
if (fd >= 0)
ioctl(fd, BLKRRPART, 0);
if (mdi)
sysfs_uevent(mdi, "change");
if (devnum != NoMdDev &&
(stat("/dev/.udev", &stb) != 0 ||
check_env("MDADM_NO_UDEV"))) {
struct map_ent *mp = map_by_devnum(&map, devnum);
remove_devices(devnum, mp ? mp->path : NULL);
}
if (quiet <= 0)
fprintf(stderr, Name ": stopped %s\n", devname);
map_lock(&map);
map_remove(&map, devnum);
map_unlock(&map);
}
return 0;
}