};
};
struct disk_data disk;
+ void *mdupdate; /* hold metadata update */
struct vcl *vlist[0]; /* max_part in size */
- } *dlist;
+ } *dlist, *add_list;
};
#ifndef offsetof
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)
{
info->reshape_active = 0;
strcpy(info->text_version, "ddf");
+ info->safe_mode_delay = 0;
// uuid_from_super_ddf(info->uuid, sbv);
sprintf(info->text_version, "/%s/%s",
devnum2devname(st->container_dev),
st->subarray);
+ info->safe_mode_delay = 200;
// info->name[] ?? ;
}
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,
return 1;
}
+#ifndef MDASSEMBLE
static void add_to_super_ddf_bvd(struct supertype *st,
mdu_disk_info_t *dk, int fd, char *devname)
{
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 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);
dfd = dev_open(nm, keep_fd? O_RDWR : O_RDONLY);
if (dfd < 0)
return 2;
+ load_ddf_headers(dfd, super, NULL);
seq = load_ddf_local(dfd, super, NULL, keep_fd);
if (!keep_fd) close(dfd);
}
}
return 0;
}
-#endif
+#endif /* MDASSEMBLE */
static struct mdinfo *container_content_ddf(struct supertype *st)
{
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);
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 (a->resync_start != ~0ULL)
+ consistent = 0;
+ }
if (consistent)
ddf->virt->entries[inst].state &= ~DDF_state_inconsistent;
else
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:
*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
};