unsigned long long start, size;
};
+/* definition of messages passed to imsm_process_update */
+enum imsm_update_type {
+ update_activate_spare,
+ update_create_array,
+};
+
+struct imsm_update_activate_spare {
+ enum imsm_update_type type;
+ int disk_idx;
+ int slot;
+ int array;
+ struct imsm_update_activate_spare *next;
+};
+
+struct imsm_update_create_array {
+ enum imsm_update_type type;
+ struct imsm_dev dev;
+ int dev_idx;
+};
+
static struct supertype *match_metadata_desc_imsm(char *arg)
{
struct supertype *st;
__u32 s;
__u64 sz;
+ if (index < 0)
+ return;
+
printf("\n");
snprintf(str, MAX_RAID_SERIAL_LEN, "%s", disk->serial);
printf(" Disk%02d Serial : %s\n", index, str);
if (super->disks) {
disk = get_imsm_disk(mpb, super->disks->index);
+ if (!disk) {
+ info->disk.number = -1;
+ info->disk.raid_disk = -1;
+ return;
+ }
info->disk.number = super->disks->index;
info->disk.raid_disk = super->disks->index;
info->data_offset = __le32_to_cpu(disk->total_blocks) -
break;
}
- if (i > mpb->num_disks)
- return 2;
+ if (i > mpb->num_disks - 1) {
+ if (devname)
+ fprintf(stderr,
+ Name ": failed to match serial \'%s\' for %s\n",
+ dl->serial, devname);
+ return 0;
+ }
dl->index = i;
mpb_size = __le32_to_cpu(anchor->mpb_size);
mpb_size = ROUND_UP(mpb_size, 512);
- if (posix_memalign((void**)&super->mpb, 512, mpb_size) != 0) {
+ if (posix_memalign(&super->buf, 512, mpb_size) != 0) {
if (devname)
fprintf(stderr,
Name ": unable to allocate %zu byte mpb buffer\n",
if (!super)
return 0;
mpb_size = disks_to_mpb_size(info->nr_disks);
- if (posix_memalign((void**)&mpb, 512, mpb_size) != 0) {
+ if (posix_memalign(&super->buf, 512, mpb_size) != 0) {
free(super);
return 0;
}
+ mpb = super->buf;
memset(mpb, 0, mpb_size);
memcpy(mpb->sig, MPB_SIGNATURE, strlen(MPB_SIGNATURE));
strlen(MPB_VERSION_RAID5));
mpb->mpb_size = mpb_size;
- super->mpb = mpb;
st->sb = super;
return 1;
}
static int write_init_super_imsm(struct supertype *st)
{
- return write_super_imsm(st->sb, 1);
+ if (st->update_tail) {
+ /* queue the recently created array as a metadata update */
+ size_t len;
+ struct imsm_update_create_array *u;
+ struct intel_super *super = st->sb;
+ struct imsm_super *mpb = super->mpb;
+ struct imsm_dev *dev;
+ struct imsm_map *map;
+ struct dl *d;
+
+ if (super->current_vol < 0 ||
+ !(dev = get_imsm_dev(mpb, super->current_vol))) {
+ fprintf(stderr, "%s: could not determine sub-array\n",
+ __func__);
+ return 1;
+ }
+
+
+ map = &dev->vol.map[0];
+ len = sizeof(*u) + sizeof(__u32) * (map->num_members - 1);
+ u = malloc(len);
+ if (!u) {
+ fprintf(stderr, "%s: failed to allocate update buffer\n",
+ __func__);
+ return 1;
+ }
+
+ u->type = update_create_array;
+ u->dev_idx = super->current_vol;
+ memcpy(&u->dev, dev, sizeof(*dev));
+ memcpy(u->dev.vol.map[0].disk_ord_tbl, map->disk_ord_tbl,
+ sizeof(__u32) * map->num_members);
+ append_metadata_update(st, u, len);
+
+ for (d = super->disks; d ; d = d->next) {
+ close(d->fd);
+ d->fd = -1;
+ }
+
+ return 0;
+ } else
+ return write_super_imsm(st->sb, 1);
}
static int store_zero_imsm(struct supertype *st, int fd)
if (!dev) {
/* General test: make sure there is space for
- * 'raiddisks' device extents of size 'size'.
+ * 'raiddisks' device extents of size 'size' at a given
+ * offset
*/
unsigned long long minsize = size*2 /* convert to blocks */;
+ unsigned long long start_offset = ~0ULL;
int dcnt = 0;
if (minsize == 0)
minsize = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
esize = e[i].start - pos;
if (esize >= minsize)
found = 1;
+ if (found && start_offset == ~0ULL) {
+ start_offset = pos;
+ break;
+ } else if (found && pos != start_offset) {
+ found = 0;
+ break;
+ }
pos = e[i].start + e[i].size;
i++;
} while (e[i-1].size);
disk = get_imsm_disk(super->mpb, get_imsm_disk_idx(map, n));
- /* check if we have seen this failure before */
+ /* check for new failures */
status = __le32_to_cpu(disk->status);
if ((state & DS_FAULTY) && !(status & FAILED_DISK)) {
status |= FAILED_DISK;
disk->status = __cpu_to_le32(status);
new_failure = 1;
+ super->updates_pending++;
}
- /**
- * the number of failures have changed, count up 'failed' to determine
+ /* the number of failures have changed, count up 'failed' to determine
* degraded / failed status
*/
if (new_failure && map->map_state != IMSM_T_STATE_FAILED)
failed = imsm_count_failed(super->mpb, map);
+ /* determine map_state based on failed or in_sync count */
if (failed)
map->map_state = imsm_check_degraded(super->mpb, inst, failed);
+ else if (map->map_state == IMSM_T_STATE_DEGRADED) {
+ struct mdinfo *d;
+ int working = 0;
- if (new_failure)
- super->updates_pending++;
+ for (d = a->info.devs ; d ; d = d->next)
+ if (d->curr_state & DS_INSYNC)
+ working++;
+
+ if (working == a->info.array.raid_disks) {
+ map->map_state = IMSM_T_STATE_NORMAL;
+ super->updates_pending++;
+ }
+ }
}
static int store_imsm_mpb(int fd, struct intel_super *super)
super->updates_pending = 0;
}
+static struct mdinfo *imsm_activate_spare(struct active_array *a,
+ struct metadata_update **updates)
+{
+ /**
+ * Take a device that is marked spare in the metadata and use it to
+ * replace a failed/vacant slot in an array. There may be a case where
+ * a device is failed in one array but active in a second.
+ * imsm_process_update catches this case and does not clear the SPARE_DISK
+ * flag, allowing the second array to start using the device on failure.
+ * SPARE_DISK is cleared when all arrays are using a device.
+ *
+ * FIXME: is this a valid use of SPARE_DISK?
+ */
+
+ struct intel_super *super = a->container->sb;
+ struct imsm_super *mpb = super->mpb;
+ int inst = a->info.container_member;
+ struct imsm_dev *dev = get_imsm_dev(mpb, inst);
+ struct imsm_map *map = dev->vol.map;
+ int failed = a->info.array.raid_disks;
+ struct mdinfo *rv = NULL;
+ struct mdinfo *d;
+ struct mdinfo *di;
+ struct metadata_update *mu;
+ struct dl *dl;
+ struct imsm_update_activate_spare *u;
+ int num_spares = 0;
+ int i;
+
+ for (d = a->info.devs ; d ; d = d->next) {
+ if ((d->curr_state & DS_FAULTY) &&
+ d->state_fd >= 0)
+ /* wait for Removal to happen */
+ return NULL;
+ if (d->state_fd >= 0)
+ failed--;
+ }
+
+ dprintf("imsm: activate spare: inst=%d failed=%d (%d) level=%d\n",
+ inst, failed, a->info.array.raid_disks, a->info.array.level);
+ if (imsm_check_degraded(mpb, inst, failed) != IMSM_T_STATE_DEGRADED)
+ return NULL;
+
+ /* For each slot, if it is not working, find a spare */
+ dl = super->disks;
+ for (i = 0; i < a->info.array.raid_disks; i++) {
+ for (d = a->info.devs ; d ; d = d->next)
+ if (d->disk.raid_disk == i)
+ break;
+ dprintf("found %d: %p %x\n", i, d, d?d->curr_state:0);
+ if (d && (d->state_fd >= 0))
+ continue;
+
+ /* OK, this device needs recovery. Find a spare */
+ for ( ; dl ; dl = dl->next) {
+ unsigned long long esize;
+ unsigned long long pos;
+ struct mdinfo *d2;
+ struct extent *ex;
+ struct imsm_disk *disk;
+ int j;
+ int found;
+ __u32 array_start;
+
+ /* If in this array, skip */
+ for (d2 = a->info.devs ; d2 ; d2 = d2->next)
+ if (d2->disk.major == dl->major &&
+ d2->disk.minor == dl->minor) {
+ dprintf("%x:%x already in array\n", dl->major, dl->minor);
+ break;
+ }
+ if (d2)
+ continue;
+
+ /* is this unused device marked as a spare? */
+ disk = get_imsm_disk(mpb, dl->index);
+ if (!(__le32_to_cpu(disk->status) & SPARE_DISK))
+ continue;
+
+ /* We are allowed to use this device - is there space?
+ * We need a->info.component_size sectors */
+ ex = get_extents(super, dl);
+ if (!ex) {
+ dprintf("cannot get extents\n");
+ continue;
+ }
+ found = 0;
+ j = 0;
+ pos = 0;
+ array_start = __le32_to_cpu(map->pba_of_lba0);
+
+ do {
+ /* check that we can start at pba_of_lba0 with
+ * a->info.component_size of space
+ */
+ esize = ex[j].start - pos;
+ if (array_start >= pos &&
+ array_start + a->info.component_size < ex[j].start) {
+ found = 1;
+ break;
+ }
+ pos = ex[j].start + ex[j].size;
+ j++;
+
+ } while (ex[j-1].size);
+
+ free(ex);
+ if (!found) {
+ dprintf("%x:%x does not have %llu at %d\n",
+ dl->major, dl->minor,
+ a->info.component_size,
+ __le32_to_cpu(map->pba_of_lba0));
+ /* No room */
+ continue;
+ }
+
+ /* found a usable disk with enough space */
+ di = malloc(sizeof(*di));
+ memset(di, 0, sizeof(*di));
+ di->disk.number = dl->index;
+ di->disk.raid_disk = i;
+ di->disk.major = dl->major;
+ di->disk.minor = dl->minor;
+ di->disk.state = 0;
+ di->data_offset = array_start;
+ di->component_size = a->info.component_size;
+ di->container_member = inst;
+ di->next = rv;
+ rv = di;
+ num_spares++;
+ dprintf("%x:%x to be %d at %llu\n", dl->major, dl->minor,
+ i, pos);
+
+ break;
+ }
+ }
+
+ if (!rv)
+ /* No spares found */
+ return rv;
+ /* Now 'rv' has a list of devices to return.
+ * Create a metadata_update record to update the
+ * disk_ord_tbl for the array
+ */
+ mu = malloc(sizeof(*mu));
+ mu->buf = malloc(sizeof(struct imsm_update_activate_spare) * num_spares);
+ mu->space = NULL;
+ mu->len = sizeof(struct imsm_update_activate_spare) * num_spares;
+ mu->next = *updates;
+ u = (struct imsm_update_activate_spare *) mu->buf;
+
+ for (di = rv ; di ; di = di->next) {
+ u->type = update_activate_spare;
+ u->disk_idx = di->disk.number;
+ u->slot = di->disk.raid_disk;
+ u->array = inst;
+ u->next = u + 1;
+ u++;
+ }
+ (u-1)->next = NULL;
+ *updates = mu;
+
+ return rv;
+}
+
+static int weight(unsigned int field)
+{
+ int weight;
+
+ for (weight = 0; field; weight++)
+ field &= field - 1;
+
+ return weight;
+}
+
+static int disks_overlap(struct imsm_map *m1, struct imsm_map *m2)
+{
+ int i;
+ int j;
+ int idx;
+
+ for (i = 0; i < m1->num_members; i++) {
+ idx = get_imsm_disk_idx(m1, i);
+ for (j = 0; j < m2->num_members; j++)
+ if (idx == get_imsm_disk_idx(m2, j))
+ return 1;
+ }
+
+ return 0;
+}
+
+static void imsm_process_update(struct supertype *st,
+ struct metadata_update *update)
+{
+ /**
+ * crack open the metadata_update envelope to find the update record
+ * update can be one of:
+ * update_activate_spare - a spare device has replaced a failed
+ * device in an array, update the disk_ord_tbl. If this disk is
+ * present in all member arrays then also clear the SPARE_DISK
+ * flag
+ */
+ struct intel_super *super = st->sb;
+ struct imsm_super *mpb = super->mpb;
+ enum imsm_update_type type = *(enum imsm_update_type *) update->buf;
+
+ switch (type) {
+ case update_activate_spare: {
+ struct imsm_update_activate_spare *u = (void *) update->buf;
+ struct imsm_dev *dev = get_imsm_dev(mpb, u->array);
+ struct imsm_map *map = &dev->vol.map[0];
+ struct active_array *a;
+ struct imsm_disk *disk;
+ __u32 status;
+ struct dl *dl;
+ struct mdinfo *d;
+ unsigned int members;
+ unsigned int found;
+ int victim;
+ int i;
+
+ for (dl = super->disks; dl; dl = dl->next)
+ if (dl->index == u->disk_idx)
+ break;
+
+ if (!dl) {
+ fprintf(stderr, "error: imsm_activate_spare passed "
+ "an unknown disk_idx: %d\n", u->disk_idx);
+ return;
+ }
+
+ super->updates_pending++;
+
+ victim = get_imsm_disk_idx(map, u->slot);
+ map->disk_ord_tbl[u->slot] = __cpu_to_le32(u->disk_idx);
+ disk = get_imsm_disk(mpb, u->disk_idx);
+ status = __le32_to_cpu(disk->status);
+ status |= CONFIGURED_DISK;
+ disk->status = __cpu_to_le32(status);
+
+ /* map unique/live arrays using the spare */
+ members = 0;
+ found = 0;
+ for (a = st->arrays; a; a = a->next) {
+ int inst = a->info.container_member;
+
+ dev = get_imsm_dev(mpb, inst);
+ map = &dev->vol.map[0];
+ if (map->raid_level > 0)
+ members |= 1 << inst;
+ for (d = a->info.devs; d; d = d->next)
+ if (d->disk.major == dl->major &&
+ d->disk.minor == dl->minor)
+ found |= 1 << inst;
+ }
+
+ /* until all arrays that can absorb this disk have absorbed
+ * this disk it can still be considered a spare
+ */
+ if (weight(found) >= weight(members)) {
+ status = __le32_to_cpu(disk->status);
+ status &= ~SPARE_DISK;
+ disk->status = __cpu_to_le32(status);
+ }
+
+ /* count arrays using the victim in the metadata */
+ found = 0;
+ for (a = st->arrays; a ; a = a->next) {
+ dev = get_imsm_dev(mpb, a->info.container_member);
+ map = &dev->vol.map[0];
+ for (i = 0; i < map->num_members; i++)
+ if (victim == get_imsm_disk_idx(map, i))
+ found++;
+ }
+
+ /* clear some flags if the victim is no longer being
+ * utilized anywhere
+ */
+ disk = get_imsm_disk(mpb, victim);
+ if (!found) {
+ status = __le32_to_cpu(disk->status);
+ status &= ~(CONFIGURED_DISK | USABLE_DISK);
+ disk->status = __cpu_to_le32(status);
+ }
+ break;
+ }
+ case update_create_array: {
+ /* someone wants to create a new array, we need to be aware of
+ * a few races/collisions:
+ * 1/ 'Create' called by two separate instances of mdadm
+ * 2/ 'Create' versus 'activate_spare': mdadm has chosen
+ * devices that have since been assimilated via
+ * activate_spare.
+ * In the event this update can not be carried out mdadm will
+ * (FIX ME) notice that its update did not take hold.
+ */
+ struct imsm_update_create_array *u = (void *) update->buf;
+ struct imsm_dev *dev;
+ struct imsm_map *map, *new_map;
+ unsigned long long start, end;
+ unsigned long long new_start, new_end;
+ int i;
+ int overlap = 0;
+
+ /* handle racing creates: first come first serve */
+ if (u->dev_idx < mpb->num_raid_devs) {
+ dprintf("%s: subarray %d already defined\n",
+ __func__, u->dev_idx);
+ return;
+ }
+
+ /* check update is next in sequence */
+ if (u->dev_idx != mpb->num_raid_devs) {
+ dprintf("%s: can not create arrays out of sequence\n",
+ __func__);
+ return;
+ }
+
+ new_map = &u->dev.vol.map[0];
+ new_start = __le32_to_cpu(new_map->pba_of_lba0);
+ new_end = new_start + __le32_to_cpu(new_map->blocks_per_member);
+
+ /* handle activate_spare versus create race:
+ * check to make sure that overlapping arrays do not include
+ * overalpping disks
+ */
+ for (i = 0; i < mpb->num_raid_devs; i++) {
+ dev = get_imsm_dev(mpb, i);
+ map = &dev->vol.map[0];
+ start = __le32_to_cpu(map->pba_of_lba0);
+ end = start + __le32_to_cpu(map->blocks_per_member);
+ if ((new_start >= start && new_start <= end) ||
+ (start >= new_start && start <= new_end))
+ overlap = 1;
+ if (overlap && disks_overlap(map, new_map)) {
+ dprintf("%s: arrays overlap\n", __func__);
+ return;
+ }
+ }
+ /* check num_members sanity */
+ if (new_map->num_members > mpb->num_disks) {
+ dprintf("%s: num_disks out of range\n", __func__);
+ return;
+ }
+
+ super->updates_pending++;
+ mpb->num_raid_devs++;
+ dev = get_imsm_dev(mpb, u->dev_idx);
+ memcpy(dev, &u->dev, sizeof(*dev));
+ map = &dev->vol.map[0];
+ memcpy(map->disk_ord_tbl, new_map->disk_ord_tbl,
+ sizeof(__u32) * new_map->num_members);
+
+ /* fix up flags, if arrays overlap then the drives can not be
+ * spares
+ */
+ for (i = 0; i < map->num_members; i++) {
+ struct imsm_disk *disk;
+ __u32 status;
+
+ disk = get_imsm_disk(mpb, get_imsm_disk_idx(map, i));
+ status = __le32_to_cpu(disk->status);
+ status |= CONFIGURED_DISK;
+ if (overlap)
+ status &= ~SPARE_DISK;
+ disk->status = __cpu_to_le32(status);
+ }
+ break;
+ }
+ }
+}
+
+static void imsm_prepare_update(struct supertype *st,
+ struct metadata_update *update)
+{
+ /* Allocate space to hold a new mpb if necessary. We currently
+ * allocate enough to hold 2 subarrays for the given number of disks.
+ * This may not be sufficient iff reshaping.
+ *
+ * FIX ME handle the reshape case.
+ *
+ * The monitor will be able to safely change super->mpb by arranging
+ * for it to be freed in check_update_queue(). I.e. the monitor thread
+ * will start using the new pointer and the manager can continue to use
+ * the old value until check_update_queue() runs.
+ */
+
+ return;
+}
+
struct superswitch super_imsm = {
#ifndef MDASSEMBLE
.examine_super = examine_super_imsm,
.set_array_state= imsm_set_array_state,
.set_disk = imsm_set_disk,
.sync_metadata = imsm_sync_metadata,
+ .activate_spare = imsm_activate_spare,
+ .process_update = imsm_process_update,
+ .prepare_update = imsm_prepare_update,
};
projects / thirdparty / mdadm.git / blobdiff