__u64 *lba_offset; /* location in 'conf' of
* the lba table */
unsigned int vcnum; /* index into ->virt */
+ struct vd_config **other_bvds;
__u64 *block_sizes; /* NULL if all the same */
};
};
char *devname;
int fd;
unsigned long long size; /* sectors */
+ unsigned long long primary_lba; /* sectors */
+ unsigned long long secondary_lba; /* sectors */
+ unsigned long long workspace_lba; /* sectors */
int pdnum; /* index in ->phys */
struct spare_assign *spare;
void *mdupdate; /* hold metadata update */
return 0;
}
+static void add_other_bvd(struct vcl *vcl, struct vd_config *vd,
+ unsigned int len)
+{
+ int i;
+ for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++)
+ if (vcl->other_bvds[i] != NULL &&
+ vcl->other_bvds[i]->sec_elmnt_seq == vd->sec_elmnt_seq)
+ break;
+
+ if (i < vcl->conf.sec_elmnt_count-1) {
+ if (vd->seqnum <= vcl->other_bvds[i]->seqnum)
+ return;
+ } else {
+ for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++)
+ if (vcl->other_bvds[i] == NULL)
+ break;
+ if (i == vcl->conf.sec_elmnt_count-1) {
+ pr_err("no space for sec level config %u, count is %u\n",
+ vd->sec_elmnt_seq, vcl->conf.sec_elmnt_count);
+ return;
+ }
+ if (posix_memalign((void **)&vcl->other_bvds[i], 512, len)
+ != 0) {
+ pr_err("%s could not allocate vd buf\n", __func__);
+ return;
+ }
+ }
+ memcpy(vcl->other_bvds[i], vd, len);
+}
+
static int load_ddf_local(int fd, struct ddf_super *super,
char *devname, int keep)
{
dl->size = 0;
if (get_dev_size(fd, devname, &dsize))
dl->size = dsize >> 9;
+ /* If the disks have different sizes, the LBAs will differ
+ * between phys disks.
+ * At this point here, the values in super->active must be valid
+ * for this phys disk. */
+ dl->primary_lba = super->active->primary_lba;
+ dl->secondary_lba = super->active->secondary_lba;
+ dl->workspace_lba = super->active->workspace_lba;
dl->spare = NULL;
for (i = 0 ; i < super->max_part ; i++)
dl->vlist[i] = NULL;
if (vcl) {
dl->vlist[vnum++] = vcl;
+ if (vcl->other_bvds != NULL &&
+ vcl->conf.sec_elmnt_seq != vd->sec_elmnt_seq) {
+ add_other_bvd(vcl, vd, super->conf_rec_len*512);
+ continue;
+ }
if (__be32_to_cpu(vd->seqnum) <=
__be32_to_cpu(vcl->conf.seqnum))
continue;
}
vcl->next = super->conflist;
vcl->block_sizes = NULL; /* FIXME not for CONCAT */
+ if (vd->sec_elmnt_count > 1)
+ vcl->other_bvds =
+ xcalloc(vd->sec_elmnt_count - 1,
+ sizeof(struct vd_config *));
+ else
+ vcl->other_bvds = NULL;
super->conflist = vcl;
dl->vlist[vnum++] = vcl;
}
ddf->conflist = v->next;
if (v->block_sizes)
free(v->block_sizes);
+ if (v->other_bvds) {
+ int i;
+ for (i = 0; i < v->conf.sec_elmnt_count-1; i++)
+ if (v->other_bvds[i] != NULL)
+ free(v->other_bvds[i]);
+ free(v->other_bvds);
+ }
free(v);
}
while (ddf->dlist) {
return NULL;
st = xcalloc(1, sizeof(*st));
- st->container_dev = NoMdDev;
st->ss = &super_ddf;
st->max_devs = 512;
st->minor_version = 0;
info->array.major_version = -1;
info->array.minor_version = -2;
sprintf(info->text_version, "/%s/%d",
- devnum2devname(st->container_dev),
+ st->container_devnm,
info->container_member);
info->safe_mode_delay = 200;
vcl->lba_offset = (__u64*) &vcl->conf.phys_refnum[ddf->mppe];
vcl->vcnum = venum;
vcl->block_sizes = NULL; /* FIXME not for CONCAT */
+ vcl->other_bvds = NULL;
vc = &vcl->conf;
* expanding a pre-existing container
*/
static int add_to_super_ddf(struct supertype *st,
- mdu_disk_info_t *dk, int fd, char *devname)
+ mdu_disk_info_t *dk, int fd, char *devname,
+ unsigned long long data_offset)
{
struct ddf_super *ddf = st->sb;
struct dl *dd;
*/
#define NULL_CONF_SZ 4096
-static int __write_init_super_ddf(struct supertype *st)
+static unsigned int get_pd_index_from_refnum(const struct vcl *vc,
+ __u32 refnum, unsigned int nmax,
+ const struct vd_config **bvd,
+ unsigned int *idx);
+
+static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type,
+ char *null_aligned)
{
+ unsigned long long sector;
+ struct ddf_header *header;
+ int fd, i, n_config, conf_size;
+ fd = d->fd;
+
+ switch (type) {
+ case DDF_HEADER_PRIMARY:
+ header = &ddf->primary;
+ sector = __be64_to_cpu(header->primary_lba);
+ break;
+ case DDF_HEADER_SECONDARY:
+ header = &ddf->secondary;
+ sector = __be64_to_cpu(header->secondary_lba);
+ break;
+ default:
+ return 0;
+ }
+
+ header->type = type;
+ header->openflag = 0;
+ header->crc = calc_crc(header, 512);
+
+ lseek64(fd, sector<<9, 0);
+ if (write(fd, header, 512) < 0)
+ return 0;
+
+ ddf->controller.crc = calc_crc(&ddf->controller, 512);
+ if (write(fd, &ddf->controller, 512) < 0)
+ return 0;
+
+ ddf->phys->crc = calc_crc(ddf->phys, ddf->pdsize);
+ if (write(fd, ddf->phys, ddf->pdsize) < 0)
+ return 0;
+ ddf->virt->crc = calc_crc(ddf->virt, ddf->vdsize);
+ if (write(fd, ddf->virt, ddf->vdsize) < 0)
+ return 0;
+
+ /* Now write lots of config records. */
+ n_config = ddf->max_part;
+ conf_size = ddf->conf_rec_len * 512;
+ for (i = 0 ; i <= n_config ; i++) {
+ struct vcl *c;
+ struct vd_config *vdc = NULL;
+ if (i == n_config) {
+ c = (struct vcl *)d->spare;
+ if (c)
+ vdc = &c->conf;
+ } else {
+ unsigned int dummy;
+ c = d->vlist[i];
+ if (c)
+ get_pd_index_from_refnum(
+ c, d->disk.refnum,
+ ddf->mppe,
+ (const struct vd_config **)&vdc,
+ &dummy);
+ }
+ if (c) {
+ vdc->seqnum = ddf->primary.seq;
+ vdc->crc = calc_crc(vdc, conf_size);
+ if (write(fd, vdc, conf_size) < 0)
+ break;
+ } else {
+ unsigned int togo = conf_size;
+ while (togo > NULL_CONF_SZ) {
+ if (write(fd, null_aligned, NULL_CONF_SZ) < 0)
+ break;
+ togo -= NULL_CONF_SZ;
+ }
+ if (write(fd, null_aligned, togo) < 0)
+ break;
+ }
+ }
+ if (i <= n_config)
+ return 0;
+
+ d->disk.crc = calc_crc(&d->disk, 512);
+ if (write(fd, &d->disk, 512) < 0)
+ return 0;
+
+ return 1;
+}
+
+static int __write_init_super_ddf(struct supertype *st)
+{
struct ddf_super *ddf = st->sb;
- int i;
struct dl *d;
- int n_config;
- int conf_size;
int attempts = 0;
int successes = 0;
- unsigned long long size, sector;
+ unsigned long long size;
char *null_aligned;
+ __u32 seq;
if (posix_memalign((void**)&null_aligned, 4096, NULL_CONF_SZ) != 0) {
return -ENOMEM;
}
memset(null_aligned, 0xff, NULL_CONF_SZ);
+ if (ddf->primary.seq != 0xffffffff)
+ seq = __cpu_to_be32(__be32_to_cpu(ddf->primary.seq)+1);
+ else if (ddf->secondary.seq != 0xffffffff)
+ seq = __cpu_to_be32(__be32_to_cpu(ddf->secondary.seq)+1);
+ else
+ seq = __cpu_to_be32(1);
+
/* try to write updated metadata,
* if we catch a failure move on to the next disk
*/
*/
get_dev_size(fd, NULL, &size);
size /= 512;
- ddf->anchor.workspace_lba = __cpu_to_be64(size - 32*1024*2);
- ddf->anchor.primary_lba = __cpu_to_be64(size - 16*1024*2);
- ddf->anchor.seq = __cpu_to_be32(1);
+ if (d->workspace_lba != 0)
+ ddf->anchor.workspace_lba = d->workspace_lba;
+ else
+ ddf->anchor.workspace_lba =
+ __cpu_to_be64(size - 32*1024*2);
+ if (d->primary_lba != 0)
+ ddf->anchor.primary_lba = d->primary_lba;
+ else
+ ddf->anchor.primary_lba =
+ __cpu_to_be64(size - 16*1024*2);
+ if (d->secondary_lba != 0)
+ ddf->anchor.secondary_lba = d->secondary_lba;
+ else
+ ddf->anchor.secondary_lba =
+ __cpu_to_be64(size - 32*1024*2);
+ ddf->anchor.seq = seq;
memcpy(&ddf->primary, &ddf->anchor, 512);
memcpy(&ddf->secondary, &ddf->anchor, 512);
ddf->anchor.seq = 0xFFFFFFFF; /* no sequencing in anchor */
ddf->anchor.crc = calc_crc(&ddf->anchor, 512);
- ddf->primary.openflag = 0;
- ddf->primary.type = DDF_HEADER_PRIMARY;
-
- ddf->secondary.openflag = 0;
- ddf->secondary.type = DDF_HEADER_SECONDARY;
-
- ddf->primary.crc = calc_crc(&ddf->primary, 512);
- ddf->secondary.crc = calc_crc(&ddf->secondary, 512);
-
- sector = size - 16*1024*2;
- lseek64(fd, sector<<9, 0);
- if (write(fd, &ddf->primary, 512) < 0)
+ if (!__write_ddf_structure(d, ddf, DDF_HEADER_PRIMARY,
+ null_aligned))
continue;
- ddf->controller.crc = calc_crc(&ddf->controller, 512);
- if (write(fd, &ddf->controller, 512) < 0)
+ if (!__write_ddf_structure(d, ddf, DDF_HEADER_SECONDARY,
+ null_aligned))
continue;
- ddf->phys->crc = calc_crc(ddf->phys, ddf->pdsize);
-
- if (write(fd, ddf->phys, ddf->pdsize) < 0)
- continue;
-
- ddf->virt->crc = calc_crc(ddf->virt, ddf->vdsize);
- if (write(fd, ddf->virt, ddf->vdsize) < 0)
- continue;
-
- /* Now write lots of config records. */
- n_config = ddf->max_part;
- conf_size = ddf->conf_rec_len * 512;
- for (i = 0 ; i <= n_config ; i++) {
- struct vcl *c = d->vlist[i];
- if (i == n_config)
- c = (struct vcl*)d->spare;
-
- if (c) {
- c->conf.crc = calc_crc(&c->conf, conf_size);
- if (write(fd, &c->conf, conf_size) < 0)
- break;
- } else {
- unsigned int togo = conf_size;
- while (togo > NULL_CONF_SZ) {
- if (write(fd, null_aligned, NULL_CONF_SZ) < 0)
- break;
- togo -= NULL_CONF_SZ;
- }
- if (write(fd, null_aligned, togo) < 0)
- break;
- }
- }
- if (i <= n_config)
- continue;
- d->disk.crc = calc_crc(&d->disk, 512);
- if (write(fd, &d->disk, 512) < 0)
- continue;
-
- /* Maybe do the same for secondary */
-
lseek64(fd, (size-1)*512, SEEK_SET);
if (write(fd, &ddf->anchor, 512) < 0)
continue;
*/
fd = open(dev, O_RDONLY|O_EXCL, 0);
if (fd >= 0) {
- sra = sysfs_read(fd, 0, GET_VERSION);
+ sra = sysfs_read(fd, NULL, GET_VERSION);
close(fd);
if (sra && sra->array.major_version == -1 &&
strcmp(sra->text_version, "ddf") == 0) {
dev, strerror(EBUSY));
return 0;
}
- sra = sysfs_read(cfd, 0, GET_VERSION);
+ sra = sysfs_read(cfd, NULL, GET_VERSION);
close(fd);
if (sra && sra->array.major_version == -1 &&
strcmp(sra->text_version, "ddf") == 0) {
struct ddf_super *ddf;
if (load_super_ddf_all(st, cfd, (void **)&ddf, NULL) == 0) {
st->sb = ddf;
- st->container_dev = fd2devnum(cfd);
+ strcpy(st->container_devnm, fd2devnm(cfd));
close(cfd);
return validate_geometry_ddf_bvd(st, level, layout,
raiddisks, chunk, size,
st->minor_version = 0;
st->max_devs = 512;
}
- st->container_dev = fd2devnum(fd);
+ strcpy(st->container_devnm, fd2devnm(fd));
return 0;
}
#endif /* MDASSEMBLE */
+static int check_secondary(const struct vcl *vc)
+{
+ const struct vd_config *conf = &vc->conf;
+ int i;
+
+ /* The only DDF secondary RAID level md can support is
+ * RAID 10, if the stripe sizes and Basic volume sizes
+ * are all equal.
+ * Other configurations could in theory be supported by exposing
+ * the BVDs to user space and using device mapper for the secondary
+ * mapping. So far we don't support that.
+ */
+
+ __u64 sec_elements[4] = {0, 0, 0, 0};
+#define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
+#define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
+
+ if (vc->other_bvds == NULL) {
+ pr_err("No BVDs for secondary RAID found\n");
+ return -1;
+ }
+ if (conf->prl != DDF_RAID1) {
+ pr_err("Secondary RAID level only supported for mirrored BVD\n");
+ return -1;
+ }
+ if (conf->srl != DDF_2STRIPED && conf->srl != DDF_2SPANNED) {
+ pr_err("Secondary RAID level %d is unsupported\n",
+ conf->srl);
+ return -1;
+ }
+ __set_sec_seen(conf->sec_elmnt_seq);
+ for (i = 0; i < conf->sec_elmnt_count-1; i++) {
+ const struct vd_config *bvd = vc->other_bvds[i];
+ if (bvd == NULL) {
+ pr_err("BVD %d is missing\n", i+1);
+ return -1;
+ }
+ if (bvd->srl != conf->srl) {
+ pr_err("Inconsistent secondary RAID level across BVDs\n");
+ return -1;
+ }
+ if (bvd->prl != conf->prl) {
+ pr_err("Different RAID levels for BVDs are unsupported\n");
+ return -1;
+ }
+ if (bvd->prim_elmnt_count != conf->prim_elmnt_count) {
+ pr_err("All BVDs must have the same number of primary elements\n");
+ return -1;
+ }
+ if (bvd->chunk_shift != conf->chunk_shift) {
+ pr_err("Different strip sizes for BVDs are unsupported\n");
+ return -1;
+ }
+ if (bvd->array_blocks != conf->array_blocks) {
+ pr_err("Different BVD sizes are unsupported\n");
+ return -1;
+ }
+ __set_sec_seen(bvd->sec_elmnt_seq);
+ }
+ for (i = 0; i < conf->sec_elmnt_count; i++) {
+ if (!__was_sec_seen(i)) {
+ pr_err("BVD %d is missing\n", i);
+ return -1;
+ }
+ }
+ return 0;
+}
+
+#define NO_SUCH_REFNUM (0xFFFFFFFF)
+static unsigned int get_pd_index_from_refnum(const struct vcl *vc,
+ __u32 refnum, unsigned int nmax,
+ const struct vd_config **bvd,
+ unsigned int *idx)
+{
+ unsigned int i, j, n, sec, cnt;
+
+ cnt = __be16_to_cpu(vc->conf.prim_elmnt_count);
+ sec = (vc->conf.sec_elmnt_count == 1 ? 0 : vc->conf.sec_elmnt_seq);
+
+ for (i = 0, j = 0 ; i < nmax ; i++) {
+ /* j counts valid entries for this BVD */
+ if (vc->conf.phys_refnum[i] != 0xffffffff)
+ j++;
+ if (vc->conf.phys_refnum[i] == refnum) {
+ *bvd = &vc->conf;
+ *idx = i;
+ return sec * cnt + j - 1;
+ }
+ }
+ if (vc->other_bvds == NULL)
+ goto bad;
+
+ for (n = 1; n < vc->conf.sec_elmnt_count; n++) {
+ struct vd_config *vd = vc->other_bvds[n-1];
+ if (vd == NULL)
+ continue;
+ sec = vd->sec_elmnt_seq;
+ for (i = 0, j = 0 ; i < nmax ; i++) {
+ if (vd->phys_refnum[i] != 0xffffffff)
+ j++;
+ if (vd->phys_refnum[i] == refnum) {
+ *bvd = vd;
+ *idx = i;
+ return sec * cnt + j - 1;
+ }
+ }
+ }
+bad:
+ *bvd = NULL;
+ return NO_SUCH_REFNUM;
+}
+
static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray)
{
/* Given a container loaded by load_super_ddf_all,
struct mdinfo *this;
char *ep;
__u32 *cptr;
+ unsigned int pd;
if (subarray &&
(strtoul(subarray, &ep, 10) != vc->vcnum ||
*ep != '\0'))
continue;
+ if (vc->conf.sec_elmnt_count > 1) {
+ if (check_secondary(vc) != 0)
+ continue;
+ }
+
this = xcalloc(1, sizeof(*this));
this->next = rest;
rest = this;
- this->array.level = map_num1(ddf_level_num, vc->conf.prl);
- this->array.raid_disks =
- __be16_to_cpu(vc->conf.prim_elmnt_count);
- this->array.layout = rlq_to_layout(vc->conf.rlq, vc->conf.prl,
- this->array.raid_disks);
+ if (vc->conf.sec_elmnt_count == 1) {
+ this->array.level = map_num1(ddf_level_num,
+ vc->conf.prl);
+ this->array.raid_disks =
+ __be16_to_cpu(vc->conf.prim_elmnt_count);
+ this->array.layout =
+ rlq_to_layout(vc->conf.rlq, vc->conf.prl,
+ this->array.raid_disks);
+ } else {
+ /* The only supported layout is RAID 10.
+ * Compatibility has been checked in check_secondary()
+ * above.
+ */
+ this->array.level = 10;
+ this->array.raid_disks =
+ __be16_to_cpu(vc->conf.prim_elmnt_count)
+ * vc->conf.sec_elmnt_count;
+ this->array.layout = 0x100 |
+ __be16_to_cpu(vc->conf.prim_elmnt_count);
+ }
this->array.md_minor = -1;
this->array.major_version = -1;
this->array.minor_version = -2;
ddf->currentconf = NULL;
sprintf(this->text_version, "/%s/%d",
- devnum2devname(st->container_dev),
- this->container_member);
+ st->container_devnm, this->container_member);
- for (i = 0 ; i < ddf->mppe ; i++) {
+ for (pd = 0; pd < __be16_to_cpu(ddf->phys->used_pdes); pd++) {
struct mdinfo *dev;
struct dl *d;
+ const struct vd_config *bvd;
+ unsigned int iphys;
+ __u64 *lba_offset;
int stt;
- int pd;
- if (vc->conf.phys_refnum[i] == 0xFFFFFFFF)
- continue;
-
- for (pd = __be16_to_cpu(ddf->phys->used_pdes);
- pd--;)
- if (ddf->phys->entries[pd].refnum
- == vc->conf.phys_refnum[i])
- break;
- if (pd < 0)
+ if (ddf->phys->entries[pd].refnum == 0xFFFFFFFF)
continue;
stt = __be16_to_cpu(ddf->phys->entries[pd].state);
!= DDF_Online)
continue;
+ i = get_pd_index_from_refnum(
+ vc, ddf->phys->entries[pd].refnum,
+ ddf->mppe, &bvd, &iphys);
+ if (i == NO_SUCH_REFNUM)
+ continue;
+
this->array.working_disks++;
for (d = ddf->dlist; d ; d=d->next)
- if (d->disk.refnum == vc->conf.phys_refnum[i])
+ if (d->disk.refnum ==
+ ddf->phys->entries[pd].refnum)
break;
if (d == NULL)
/* Haven't found that one yet, maybe there are others */
dev->recovery_start = MaxSector;
dev->events = __be32_to_cpu(ddf->primary.seq);
- dev->data_offset = __be64_to_cpu(vc->lba_offset[i]);
- dev->component_size = __be64_to_cpu(vc->conf.blocks);
+ lba_offset = (__u64 *)&bvd->phys_refnum[ddf->mppe];
+ dev->data_offset = __be64_to_cpu(lba_offset[iphys]);
+ dev->component_size = __be64_to_cpu(bvd->blocks);
if (d->devname)
strcpy(dev->name, d->devname);
}
*/
struct ddf_super *first = st->sb;
struct ddf_super *second = tst->sb;
+ struct dl *dl1, *dl2;
+ struct vcl *vl1, *vl2;
+ unsigned int max_vds, max_pds, pd, vd;
if (!first) {
st->sb = tst->sb;
if (memcmp(first->anchor.guid, second->anchor.guid, DDF_GUID_LEN) != 0)
return 2;
+ if (first->anchor.seq != second->anchor.seq) {
+ dprintf("%s: sequence number mismatch %u/%u\n", __func__,
+ __be32_to_cpu(first->anchor.seq),
+ __be32_to_cpu(second->anchor.seq));
+ return 3;
+ }
+ if (first->max_part != second->max_part ||
+ first->phys->used_pdes != second->phys->used_pdes ||
+ first->virt->populated_vdes != second->virt->populated_vdes) {
+ dprintf("%s: PD/VD number mismatch\n", __func__);
+ return 3;
+ }
+
+ max_pds = __be16_to_cpu(first->phys->used_pdes);
+ for (dl2 = second->dlist; dl2; dl2 = dl2->next) {
+ for (pd = 0; pd < max_pds; pd++)
+ if (first->phys->entries[pd].refnum == dl2->disk.refnum)
+ break;
+ if (pd == max_pds) {
+ dprintf("%s: no match for disk %08x\n", __func__,
+ __be32_to_cpu(dl2->disk.refnum));
+ return 3;
+ }
+ }
+
+ max_vds = __be16_to_cpu(first->active->max_vd_entries);
+ for (vl2 = second->conflist; vl2; vl2 = vl2->next) {
+ if (vl2->conf.magic != DDF_VD_CONF_MAGIC)
+ continue;
+ for (vd = 0; vd < max_vds; vd++)
+ if (!memcmp(first->virt->entries[vd].guid,
+ vl2->conf.guid, DDF_GUID_LEN))
+ break;
+ if (vd == max_vds) {
+ dprintf("%s: no match for VD config\n", __func__);
+ return 3;
+ }
+ }
/* FIXME should I look at anything else? */
+
+ /*
+ At this point we are fairly sure that the meta data matches.
+ But the new disk may contain additional local data.
+ Add it to the super block.
+ */
+ for (vl2 = second->conflist; vl2; vl2 = vl2->next) {
+ for (vl1 = first->conflist; vl1; vl1 = vl1->next)
+ if (!memcmp(vl1->conf.guid, vl2->conf.guid,
+ DDF_GUID_LEN))
+ break;
+ if (vl1) {
+ if (vl1->other_bvds != NULL &&
+ vl1->conf.sec_elmnt_seq !=
+ vl2->conf.sec_elmnt_seq) {
+ dprintf("%s: adding BVD %u\n", __func__,
+ vl2->conf.sec_elmnt_seq);
+ add_other_bvd(vl1, &vl2->conf,
+ first->conf_rec_len*512);
+ }
+ continue;
+ }
+
+ if (posix_memalign((void **)&vl1, 512,
+ (first->conf_rec_len*512 +
+ offsetof(struct vcl, conf))) != 0) {
+ pr_err("%s could not allocate vcl buf\n",
+ __func__);
+ return 3;
+ }
+
+ vl1->next = first->conflist;
+ vl1->block_sizes = NULL;
+ if (vl1->conf.sec_elmnt_count > 1) {
+ vl1->other_bvds = xcalloc(vl2->conf.sec_elmnt_count - 1,
+ sizeof(struct vd_config *));
+ } else
+ vl1->other_bvds = NULL;
+ memcpy(&vl1->conf, &vl2->conf, first->conf_rec_len*512);
+ vl1->lba_offset = (__u64 *)
+ &vl1->conf.phys_refnum[first->mppe];
+ for (vd = 0; vd < max_vds; vd++)
+ if (!memcmp(first->virt->entries[vd].guid,
+ vl1->conf.guid, DDF_GUID_LEN))
+ break;
+ vl1->vcnum = vd;
+ dprintf("%s: added config for VD %u\n", __func__, vl1->vcnum);
+ first->conflist = vl1;
+ }
+
+ for (dl2 = second->dlist; dl2; dl2 = dl2->next) {
+ for (dl1 = first->dlist; dl1; dl1 = dl1->next)
+ if (dl1->disk.refnum == dl2->disk.refnum)
+ break;
+ if (dl1)
+ continue;
+
+ if (posix_memalign((void **)&dl1, 512,
+ sizeof(*dl1) + (first->max_part) * sizeof(dl1->vlist[0]))
+ != 0) {
+ pr_err("%s could not allocate disk info buffer\n",
+ __func__);
+ return 3;
+ }
+ memcpy(dl1, dl2, sizeof(*dl1));
+ dl1->mdupdate = NULL;
+ dl1->next = first->dlist;
+ dl1->fd = -1;
+ for (pd = 0; pd < max_pds; pd++)
+ if (first->phys->entries[pd].refnum == dl1->disk.refnum)
+ break;
+ dl1->pdnum = pd;
+ if (dl2->spare) {
+ if (posix_memalign((void **)&dl1->spare, 512,
+ first->conf_rec_len*512) != 0) {
+ pr_err("%s could not allocate spare info buf\n",
+ __func__);
+ return 3;
+ }
+ memcpy(dl1->spare, dl2->spare, first->conf_rec_len*512);
+ }
+ for (vd = 0 ; vd < first->max_part ; vd++) {
+ if (!dl2->vlist[vd]) {
+ dl1->vlist[vd] = NULL;
+ continue;
+ }
+ for (vl1 = first->conflist; vl1; vl1 = vl1->next) {
+ if (!memcmp(vl1->conf.guid,
+ dl2->vlist[vd]->conf.guid,
+ DDF_GUID_LEN))
+ break;
+ dl1->vlist[vd] = vl1;
+ }
+ }
+ first->dlist = dl1;
+ dprintf("%s: added disk %d: %08x\n", __func__, dl1->pdnum,
+ dl1->disk.refnum);
+ }
+
return 0;
}
}
#define container_of(ptr, type, member) ({ \
- const typeof( ((type *)0)->member ) *__mptr = (ptr); \
- (type *)( (char *)__mptr - offsetof(type,member) );})
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+ (type *)( (char *)__mptr - offsetof(type,member) );})
/*
* The state of each disk is stored in the global phys_disk structure
* in phys_disk.entries[n].state.
projects / thirdparty / mdadm.git / blobdiff