};
};
struct disk_data disk;
+ void *mdupdate; /* hold metadata update */
struct vcl *vlist[0]; /* max_part in size */
- } *dlist;
+ } *dlist, *add_list;
};
#ifndef offsetof
newcrc = crc32(0, buf, len);
ddf->crc = oldcrc;
- return newcrc;
+ /* The crc is store (like everything) bigendian, so convert
+ * here for simplicity
+ */
+ return __cpu_to_be32(newcrc);
}
static int load_ddf_header(int fd, unsigned long long lba,
/* All pre-allocated sections are a single block */
if (len != 1)
return NULL;
- } else {
- posix_memalign(&buf, 512, len<<9);
- }
+ } else if (posix_memalign(&buf, 512, len<<9) != 0)
+ buf = NULL;
if (!buf)
return NULL;
unsigned long long dsize;
/* First the local disk info */
- posix_memalign((void**)&dl, 512,
+ if (posix_memalign((void**)&dl, 512,
sizeof(*dl) +
- (super->max_part) * sizeof(dl->vlist[0]));
+ (super->max_part) * sizeof(dl->vlist[0])) != 0) {
+ fprintf(stderr, Name ": %s could not allocate disk info buffer\n",
+ __func__);
+ return 1;
+ }
load_section(fd, super, &dl->disk,
super->active->data_section_offset,
if (vd->magic == DDF_SPARE_ASSIGN_MAGIC) {
if (dl->spare)
continue;
- posix_memalign((void**)&dl->spare, 512,
- super->conf_rec_len*512);
+ if (posix_memalign((void**)&dl->spare, 512,
+ super->conf_rec_len*512) != 0) {
+ fprintf(stderr, Name
+ ": %s could not allocate spare info buf\n",
+ __func__);
+ return 1;
+ }
+
memcpy(dl->spare, vd, super->conf_rec_len*512);
continue;
}
__be32_to_cpu(vcl->conf.seqnum))
continue;
} else {
- posix_memalign((void**)&vcl, 512,
+ if (posix_memalign((void**)&vcl, 512,
(super->conf_rec_len*512 +
- offsetof(struct vcl, conf)));
+ offsetof(struct vcl, conf))) != 0) {
+ fprintf(stderr, Name
+ ": %s could not allocate vcl buf\n",
+ __func__);
+ return 1;
+ }
vcl->next = super->conflist;
vcl->block_sizes = NULL; /* FIXME not for CONCAT */
super->conflist = vcl;
return rv;
}
- load_ddf_local(fd, super, devname, 0);
+ rv = load_ddf_local(fd, super, devname, 0);
+
+ if (rv) {
+ if (devname)
+ fprintf(stderr,
+ Name ": Failed to load all information "
+ "sections on %s\n", devname);
+ free(super);
+ return rv;
+ }
/* Should possibly check the sections .... */
st->minor_version = 0;
st->max_devs = 512;
}
+ st->loaded_container = 0;
return 0;
}
examine_pds(sb);
}
+static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info);
+
+
static void brief_examine_super_ddf(struct supertype *st)
{
/* We just write a generic DDF ARRAY entry
- * The uuid is all hex, 6 groups of 4 bytes
*/
- struct ddf_super *ddf = st->sb;
- int i;
- printf("ARRAY /dev/ddf metadata=ddf UUID=");
- for (i = 0; i < DDF_GUID_LEN; i++) {
- if ((i&3) == 0 && i != 0)
- printf(":");
- printf("%02X", 255&ddf->anchor.guid[i]);
- }
- printf("\n");
+ struct mdinfo info;
+ char nbuf[64];
+ getinfo_super_ddf(st, &info);
+ fname_from_uuid(st, &info, nbuf, ':');
+ printf("ARRAY metadata=ddf UUID=%s\n", nbuf + 5);
}
static void detail_super_ddf(struct supertype *st, char *homehost)
* Can that be stored in ddf_super??
*/
// struct ddf_super *ddf = st->sb;
+ struct mdinfo info;
+ char nbuf[64];
+ getinfo_super_ddf(st, &info);
+ fname_from_uuid(st, &info, nbuf,':');
+ printf(" UUID=%s", nbuf + 5);
}
#endif
ddf->controller.vendor_data[len] == 0);
}
+#ifndef MDASSEMBLE
static struct vd_config *find_vdcr(struct ddf_super *ddf, int inst)
{
struct vcl *v;
return &v->conf;
return NULL;
}
+#endif
static int find_phys(struct ddf_super *ddf, __u32 phys_refnum)
{
* uuid to put into bitmap file (Create, Grow)
* uuid for backup header when saving critical section (Grow)
* comparing uuids when re-adding a device into an array
+ * In these cases the uuid required is that of the data-array,
+ * not the device-set.
+ * uuid to recognise same set when adding a missing device back
+ * to an array. This is a uuid for the device-set.
+ *
* For each of these we can make do with a truncated
* or hashed uuid rather than the original, as long as
* everyone agrees.
- * In each case the uuid required is that of the data-array,
- * not the device-set.
* In the case of SVD we assume the BVD is of interest,
* though that might be the case if a bitmap were made for
* a mirrored SVD - worry about that later.
*/
struct ddf_super *ddf = st->sb;
struct vcl *vcl = ddf->currentconf;
+ char *guid;
+ char buf[20];
+ struct sha1_ctx ctx;
- if (!vcl)
- memset(uuid, 0, sizeof (uuid));
- else {
- char buf[20];
- struct sha1_ctx ctx;
- sha1_init_ctx(&ctx);
- sha1_process_bytes(&vcl->conf.guid, DDF_GUID_LEN, &ctx);
- if (vcl->conf.sec_elmnt_count > 1)
- sha1_process_bytes(&vcl->conf.sec_elmnt_seq, 1, &ctx);
- sha1_finish_ctx(&ctx, buf);
- memcpy(uuid, buf, sizeof(uuid));
- }
+ if (vcl)
+ guid = vcl->conf.guid;
+ else
+ guid = ddf->anchor.guid;
+
+ sha1_init_ctx(&ctx);
+ sha1_process_bytes(guid, DDF_GUID_LEN, &ctx);
+ if (vcl && vcl->conf.sec_elmnt_count > 1)
+ sha1_process_bytes(&vcl->conf.sec_elmnt_seq, 1, &ctx);
+ sha1_finish_ctx(&ctx, buf);
+ memcpy(uuid, buf, 4*4);
}
static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info);
info->reshape_active = 0;
+ info->name[0] = 0;
+ info->array.major_version = -1;
+ info->array.minor_version = -2;
strcpy(info->text_version, "ddf");
+ info->safe_mode_delay = 0;
-// uuid_from_super_ddf(info->uuid, sbv);
+ uuid_from_super_ddf(st, info->uuid);
-// info->name[] ?? ;
}
static int rlq_to_layout(int rlq, int prl, int raiddisks);
uuid_from_super_ddf(st, info->uuid);
info->container_member = atoi(st->subarray);
+ info->array.major_version = -1;
+ info->array.minor_version = -2;
sprintf(info->text_version, "/%s/%s",
devnum2devname(st->container_dev),
st->subarray);
+ info->safe_mode_delay = 200;
-// info->name[] ?? ;
+ info->name[0] = 0;
}
return init_super_ddf_bvd(st, info, size, name, homehost,
uuid);
- posix_memalign((void**)&ddf, 512, sizeof(*ddf));
+ if (posix_memalign((void**)&ddf, 512, sizeof(*ddf)) != 0) {
+ fprintf(stderr, Name ": %s could not allocate superblock\n", __func__);
+ return 0;
+ }
memset(ddf, 0, sizeof(*ddf));
ddf->dlist = NULL; /* no physical disks yet */
ddf->conflist = NULL; /* No virtual disks yet */
memset(ddf->controller.pad, 0xff, 8);
memset(ddf->controller.vendor_data, 0xff, 448);
- posix_memalign((void**)&pd, 512, pdsize);
+ if (posix_memalign((void**)&pd, 512, pdsize) != 0) {
+ fprintf(stderr, Name ": %s could not allocate pd\n", __func__);
+ return 0;
+ }
ddf->phys = pd;
ddf->pdsize = pdsize;
pd->max_pdes = __cpu_to_be16(max_phys_disks);
memset(pd->pad, 0xff, 52);
- posix_memalign((void**)&vd, 512, vdsize);
+ if (posix_memalign((void**)&vd, 512, vdsize) != 0) {
+ fprintf(stderr, Name ": %s could not allocate vd\n", __func__);
+ return 0;
+ }
ddf->virt = vd;
ddf->vdsize = vdsize;
memset(vd, 0, vdsize);
return -1;
}
+#ifndef MDASSEMBLE
struct extent {
unsigned long long start, size;
};
rv[n].size = 0;
return rv;
}
+#endif
static int init_super_ddf_bvd(struct supertype *st,
mdu_array_info_t *info,
__cpu_to_be16(__be16_to_cpu(ddf->virt->populated_vdes)+1);
/* Now create a new vd_config */
- posix_memalign((void**)&vcl, 512,
- (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512));
+ if (posix_memalign((void**)&vcl, 512,
+ (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512)) != 0) {
+ fprintf(stderr, Name ": %s could not allocate vd_config\n", __func__);
+ return 0;
+ }
vcl->lba_offset = (__u64*) &vcl->conf.phys_refnum[ddf->mppe];
vcl->vcnum = venum;
sprintf(st->subarray, "%d", venum);
return 1;
}
+#ifndef MDASSEMBLE
static void add_to_super_ddf_bvd(struct supertype *st,
mdu_disk_info_t *dk, int fd, char *devname)
{
* a phys_disk entry and a more detailed disk_data entry.
*/
fstat(fd, &stb);
- posix_memalign((void**)&dd, 512,
- sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part);
+ if (posix_memalign((void**)&dd, 512,
+ sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part) != 0) {
+ fprintf(stderr, Name
+ ": %s could allocate buffer for new disk, aborting\n",
+ __func__);
+ abort();
+ }
dd->major = major(stb.st_rdev);
dd->minor = minor(stb.st_rdev);
dd->devname = devname;
- dd->next = ddf->dlist;
dd->fd = fd;
dd->spare = NULL;
pde = &ddf->phys->entries[n];
dd->pdnum = n;
- n++;
- ddf->phys->used_pdes = __cpu_to_be16(n);
+ if (st->update_tail) {
+ int len = (sizeof(struct phys_disk) +
+ sizeof(struct phys_disk_entry));
+ struct phys_disk *pd;
+
+ pd = malloc(len);
+ pd->magic = DDF_PHYS_RECORDS_MAGIC;
+ pd->used_pdes = __cpu_to_be16(n);
+ pde = &pd->entries[0];
+ dd->mdupdate = pd;
+ } else {
+ n++;
+ ddf->phys->used_pdes = __cpu_to_be16(n);
+ }
memcpy(pde->guid, dd->disk.guid, DDF_GUID_LEN);
pde->refnum = dd->disk.refnum;
memset(pde->pad, 0xff, 6);
dd->size = size >> 9;
- ddf->dlist = dd;
- ddf->updates_pending = 1;
+ if (st->update_tail) {
+ dd->next = ddf->add_list;
+ ddf->add_list = dd;
+ } else {
+ dd->next = ddf->dlist;
+ ddf->dlist = dd;
+ ddf->updates_pending = 1;
+ }
}
/*
* container.
*/
-#ifndef MDASSEMBLE
-
static unsigned char null_conf[4096+512];
static int __write_init_super_ddf(struct supertype *st, int do_close)
struct dl *d;
int n_config;
int conf_size;
-
+ int attempts = 0;
+ int successes = 0;
unsigned long long size, sector;
+ /* try to write updated metadata,
+ * if we catch a failure move on to the next disk
+ */
for (d = ddf->dlist; d; d=d->next) {
int fd = d->fd;
if (fd < 0)
continue;
+ attempts++;
/* We need to fill in the primary, (secondary) and workspace
* lba's in the headers, set their checksums,
* Also checksum phys, virt....
sector = size - 16*1024*2;
lseek64(fd, sector<<9, 0);
- write(fd, &ddf->primary, 512);
+ if (write(fd, &ddf->primary, 512) < 0)
+ continue;
ddf->controller.crc = calc_crc(&ddf->controller, 512);
- write(fd, &ddf->controller, 512);
+ if (write(fd, &ddf->controller, 512) < 0)
+ continue;
ddf->phys->crc = calc_crc(ddf->phys, ddf->pdsize);
- write(fd, ddf->phys, ddf->pdsize);
+ if (write(fd, ddf->phys, ddf->pdsize) < 0)
+ continue;
ddf->virt->crc = calc_crc(ddf->virt, ddf->vdsize);
- write(fd, ddf->virt, ddf->vdsize);
+ if (write(fd, ddf->virt, ddf->vdsize) < 0)
+ continue;
/* Now write lots of config records. */
n_config = ddf->max_part;
if (c) {
c->conf.crc = calc_crc(&c->conf, conf_size);
- write(fd, &c->conf, conf_size);
+ if (write(fd, &c->conf, conf_size) < 0)
+ break;
} else {
char *null_aligned = (char*)((((unsigned long)null_conf)+511)&~511UL);
if (null_conf[0] != 0xff)
memset(null_conf, 0xff, sizeof(null_conf));
int togo = conf_size;
while (togo > sizeof(null_conf)-512) {
- write(fd, null_aligned, sizeof(null_conf)-512);
+ if (write(fd, null_aligned, sizeof(null_conf)-512) < 0)
+ break;
togo -= sizeof(null_conf)-512;
}
- write(fd, null_aligned, togo);
+ if (write(fd, null_aligned, togo) < 0)
+ break;
}
}
+ if (i <= n_config)
+ continue;
d->disk.crc = calc_crc(&d->disk, 512);
- write(fd, &d->disk, 512);
+ if (write(fd, &d->disk, 512) < 0)
+ continue;
/* Maybe do the same for secondary */
lseek64(fd, (size-1)*512, SEEK_SET);
- write(fd, &ddf->anchor, 512);
- if (do_close) {
- close(fd);
+ if (write(fd, &ddf->anchor, 512) < 0)
+ continue;
+ successes++;
+ }
+
+ if (do_close)
+ for (d = ddf->dlist; d; d=d->next) {
+ close(d->fd);
d->fd = -1;
}
- }
- return 1;
+
+ return attempts != successes;
}
static int write_init_super_ddf(struct supertype *st)
struct ddf_super *ddf = st->sb;
int len;
+ if (!ddf->currentconf) {
+ int len = (sizeof(struct phys_disk) +
+ sizeof(struct phys_disk_entry));
+
+ /* adding a disk to the container. */
+ if (!ddf->add_list)
+ return 0;
+
+ append_metadata_update(st, ddf->add_list->mdupdate, len);
+ ddf->add_list->mdupdate = NULL;
+ return 0;
+ }
+
+ /* Newly created VD */
+
/* First the virtual disk. We have a slightly fake header */
len = sizeof(struct virtual_disk) + sizeof(struct virtual_entry);
vd = malloc(len);
close(dfd);
/* Now we need the device-local bits */
for (sd = sra->devs ; sd ; sd = sd->next) {
+ int rv;
+
sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
dfd = dev_open(nm, keep_fd? O_RDWR : O_RDONLY);
if (dfd < 0)
return 2;
- seq = load_ddf_local(dfd, super, NULL, keep_fd);
+ rv = load_ddf_headers(dfd, super, NULL);
+ if (rv == 0)
+ rv = load_ddf_local(dfd, super, NULL, keep_fd);
if (!keep_fd) close(dfd);
+ if (rv)
+ return 1;
}
if (st->subarray[0]) {
struct vcl *v;
st->max_devs = 512;
st->container_dev = fd2devnum(fd);
}
+ st->loaded_container = 1;
return 0;
}
-#endif
+#endif /* MDASSEMBLE */
static struct mdinfo *container_content_ddf(struct supertype *st)
{
this->array.layout = rlq_to_layout(vc->conf.rlq, vc->conf.prl,
this->array.raid_disks);
this->array.md_minor = -1;
+ this->array.major_version = -1;
+ this->array.minor_version = -2;
this->array.ctime = DECADE +
__be32_to_cpu(*(__u32*)(vc->conf.guid+16));
this->array.utime = DECADE +
this->resync_start = ~0ULL;
}
memcpy(this->name, ddf->virt->entries[i].name, 32);
- this->name[33]=0;
+ this->name[32]=0;
memset(this->uuid, 0, sizeof(this->uuid));
this->component_size = __be64_to_cpu(vc->conf.blocks);
this->array.size = this->component_size / 2;
this->container_member = i;
+ ddf->currentconf = vc;
+ uuid_from_super_ddf(st, this->uuid);
+ ddf->currentconf = NULL;
+
sprintf(this->text_version, "/%s/%d",
devnum2devname(st->container_dev),
this->container_member);
{
unsigned long long dsize;
void *buf;
+ int rc;
if (!get_dev_size(fd, NULL, &dsize))
return 1;
- posix_memalign(&buf, 512, 512);
+ if (posix_memalign(&buf, 512, 512) != 0)
+ return 1;
memset(buf, 0, 512);
lseek64(fd, dsize-512, 0);
- write(fd, buf, 512);
+ rc = write(fd, buf, 512);
free(buf);
+ if (rc < 0)
+ return 1;
return 0;
}
return 0;
}
+#ifndef MDASSEMBLE
/*
* A new array 'a' has been started which claims to be instance 'inst'
* within container 'c'.
* For DDF, we need to clear the DDF_state_inconsistent bit in the
* !global! virtual_disk.virtual_entry structure.
*/
-static void ddf_set_array_state(struct active_array *a, int consistent)
+static int ddf_set_array_state(struct active_array *a, int consistent)
{
struct ddf_super *ddf = a->container->sb;
int inst = a->info.container_member;
int old = ddf->virt->entries[inst].state;
+ if (consistent == 2) {
+ /* Should check if a recovery should be started FIXME */
+ consistent = 1;
+ if (!is_resync_complete(a))
+ consistent = 0;
+ }
if (consistent)
ddf->virt->entries[inst].state &= ~DDF_state_inconsistent;
else
old = ddf->virt->entries[inst].init_state;
ddf->virt->entries[inst].init_state &= ~DDF_initstate_mask;
- if (a->resync_start == ~0ULL)
+ if (is_resync_complete(a))
ddf->virt->entries[inst].init_state |= DDF_init_full;
else if (a->resync_start == 0)
ddf->virt->entries[inst].init_state |= DDF_init_not;
dprintf("ddf mark %d %s %llu\n", inst, consistent?"clean":"dirty",
a->resync_start);
+ return consistent;
}
/*
ddf->phys->used_pdes = __cpu_to_be16(1 +
__be16_to_cpu(ddf->phys->used_pdes));
ddf->updates_pending = 1;
+ if (ddf->add_list) {
+ struct active_array *a;
+ struct dl *al = ddf->add_list;
+ ddf->add_list = al->next;
+
+ al->next = ddf->dlist;
+ ddf->dlist = al;
+
+ /* As a device has been added, we should check
+ * for any degraded devices that might make
+ * use of this spare */
+ for (a = st->arrays ; a; a=a->next)
+ a->check_degraded = 1;
+ }
break;
case DDF_VIRT_RECORDS_MAGIC:
mppe * (sizeof(__u32) + sizeof(__u64)));
} else {
/* A new VD_CONF */
+ if (!update->space)
+ return;
vcl = update->space;
update->space = NULL;
vcl->next = ddf->conflist;
struct ddf_super *ddf = st->sb;
__u32 *magic = (__u32*)update->buf;
if (*magic == DDF_VD_CONF_MAGIC)
- posix_memalign(&update->space, 512,
+ if (posix_memalign(&update->space, 512,
offsetof(struct vcl, conf)
- + ddf->conf_rec_len * 512);
+ + ddf->conf_rec_len * 512) != 0)
+ update->space = NULL;
}
/*
/* Cool, we have a device with some space at pos */
di = malloc(sizeof(*di));
+ if (!di)
+ continue;
memset(di, 0, sizeof(*di));
di->disk.number = i;
di->disk.raid_disk = i;
* phys_refnum and lba_offset values
*/
mu = malloc(sizeof(*mu));
+ if (mu && posix_memalign(&mu->space, 512, sizeof(struct vcl)) != 0) {
+ free(mu);
+ mu = NULL;
+ }
+ if (!mu) {
+ while (rv) {
+ struct mdinfo *n = rv->next;
+
+ free(rv);
+ rv = n;
+ }
+ return NULL;
+ }
+
mu->buf = malloc(ddf->conf_rec_len * 512);
- posix_memalign(&mu->space, 512, sizeof(struct vcl));
mu->len = ddf->conf_rec_len;
mu->next = *updates;
vc = find_vdcr(ddf, a->info.container_member);
*updates = mu;
return rv;
}
+#endif /* MDASSEMBLE */
struct superswitch super_ddf = {
#ifndef MDASSEMBLE
.brief_detail_super = brief_detail_super_ddf,
.validate_geometry = validate_geometry_ddf,
.write_init_super = write_init_super_ddf,
+ .add_to_super = add_to_super_ddf,
#endif
.match_home = match_home_ddf,
.uuid_from_super= uuid_from_super_ddf,
.store_super = store_zero_ddf,
.free_super = free_super_ddf,
.match_metadata_desc = match_metadata_desc_ddf,
- .add_to_super = add_to_super_ddf,
.container_content = container_content_ddf,
.external = 1,
+#ifndef MDASSEMBLE
/* for mdmon */
.open_new = ddf_open_new,
.set_array_state= ddf_set_array_state,
.process_update = ddf_process_update,
.prepare_update = ddf_prepare_update,
.activate_spare = ddf_activate_spare,
-
+#endif
};
projects / thirdparty / mdadm.git / blobdiff