if (get_dev_size(fd, devname, &dsize) == 0)
return 1;
+ if (test_partition(fd))
+ /* DDF is not allowed on partitions */
+ return 1;
+
/* 32M is a lower bound */
if (dsize <= 32*1024*1024) {
if (devname)
static void uuid_from_super_ddf(struct supertype *st, int uuid[4]);
static void brief_examine_super_ddf(struct supertype *st, int verbose)
+{
+ /* We just write a generic DDF ARRAY entry
+ */
+ 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 brief_examine_subarrays_ddf(struct supertype *st, int verbose)
{
/* We just write a generic DDF ARRAY entry
*/
printf("ARRAY container=%s member=%d UUID=%s\n",
nbuf+5, i, nbuf1+5);
}
- printf("ARRAY metadata=ddf UUID=%s\n", nbuf + 5);
}
static void export_examine_super_ddf(struct supertype *st)
* the hostname
*/
struct ddf_super *ddf = st->sb;
- int len = strlen(homehost);
+ int len;
+
+ if (!homehost)
+ return 0;
+ len = strlen(homehost);
return (memcmp(ddf->controller.guid, T10, 8) == 0 &&
len < sizeof(ddf->controller.vendor_data) &&
(ddf->anchor.guid+16));
info->array.utime = 0;
info->array.chunk_size = 0;
+ info->container_enough = 0;
info->disk.major = 0;
info->disk.raid_disk = -1;
// info->disk.raid_disk = find refnum in the table and use index;
}
- info->disk.state = (1 << MD_DISK_SYNC);
+ info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
+ info->recovery_start = MaxSector;
info->reshape_active = 0;
info->name[0] = 0;
info->container_member = ddf->currentconf->vcnum;
+ info->recovery_start = MaxSector;
info->resync_start = 0;
+ info->reshape_active = 0;
if (!(ddf->virt->entries[info->container_member].state
& DDF_state_inconsistent) &&
(ddf->virt->entries[info->container_member].init_state
& DDF_initstate_mask)
== DDF_init_full)
- info->resync_start = ~0ULL;
+ info->resync_start = MaxSector;
uuid_from_super_ddf(st, info->uuid);
struct phys_disk *pd;
struct virtual_disk *vd;
- if (!info) {
- st->sb = NULL;
- return 0;
- }
if (st->sb)
- return init_super_ddf_bvd(st, info, size, name, homehost,
- uuid);
+ return init_super_ddf_bvd(st, info, size, name, homehost, uuid);
if (posix_memalign((void**)&ddf, 512, sizeof(*ddf)) != 0) {
fprintf(stderr, Name ": %s could not allocate superblock\n", __func__);
memset(ddf, 0, sizeof(*ddf));
ddf->dlist = NULL; /* no physical disks yet */
ddf->conflist = NULL; /* No virtual disks yet */
+ st->sb = ddf;
+
+ if (info == NULL) {
+ /* zeroing superblock */
+ return 0;
+ }
/* At least 32MB *must* be reserved for the ddf. So let's just
* start 32MB from the end, and put the primary header there.
memset(pd, 0xff, pdsize);
memset(pd, 0, sizeof(*pd));
- pd->magic = DDF_PHYS_DATA_MAGIC;
+ pd->magic = DDF_PHYS_RECORDS_MAGIC;
pd->used_pdes = __cpu_to_be16(0);
pd->max_pdes = __cpu_to_be16(max_phys_disks);
memset(pd->pad, 0xff, 52);
/* FIXME I need to close the fds! */
return 0;
- } else
+ } else {
+ struct dl *d;
+ for (d = ddf->dlist; d; d=d->next)
+ while (Kill(d->devname, NULL, 0, 1, 1) == 0);
return __write_init_super_ddf(st, 1);
+ }
}
#endif
for (i=0; ddf_level_num[i].num1 != MAXINT; i++)
if (ddf_level_num[i].num2 == level)
break;
- if (ddf_level_num[i].num1 == MAXINT)
+ if (ddf_level_num[i].num1 == MAXINT) {
+ if (verbose)
+ fprintf(stderr, Name ": DDF does not support level %d arrays\n",
+ level);
return 0;
+ }
/* Should check layout? etc */
if (st->sb && freesize) {
if (verbose)
fprintf(stderr,
Name ": ddf: Cannot create this array "
- "on device %s\n",
+ "on device %s - a container is required.\n",
dev);
return 0;
}
struct extent *e;
int i;
/* ddf/bvd supports lots of things, but not containers */
- if (level == LEVEL_CONTAINER)
+ if (level == LEVEL_CONTAINER) {
+ if (verbose)
+ fprintf(stderr, Name ": DDF cannot create a container within an container\n");
return 0;
+ }
/* We must have the container info already read in. */
if (!ddf)
return 0;
this->resync_start = 0;
} else {
this->array.state = 1;
- this->resync_start = ~0ULL;
+ this->resync_start = MaxSector;
}
memcpy(this->name, ddf->virt->entries[i].name, 16);
this->name[16]=0;
dev->disk.minor = d->minor;
dev->disk.raid_disk = i;
dev->disk.state = (1<<MD_DISK_SYNC)|(1<<MD_DISK_ACTIVE);
+ dev->recovery_start = MaxSector;
dev->events = __be32_to_cpu(ddf->primary.seq);
dev->data_offset = __be64_to_cpu(vc->lba_offset[i]);
return rest;
}
-static int store_zero_ddf(struct supertype *st, int fd)
+static int store_super_ddf(struct supertype *st, int fd)
{
+ struct ddf_super *ddf = st->sb;
unsigned long long dsize;
void *buf;
int rc;
+ if (!ddf)
+ return 1;
+
+ /* ->dlist and ->conflist will be set for updates, currently not
+ * supported
+ */
+ if (ddf->dlist || ddf->conflist)
+ return 1;
+
if (!get_dev_size(fd, NULL, &dsize))
return 1;
if (consistent == 2) {
/* Should check if a recovery should be started FIXME */
consistent = 1;
- if (!is_resync_complete(a))
+ if (!is_resync_complete(&a->info))
consistent = 0;
}
if (consistent)
old = ddf->virt->entries[inst].init_state;
ddf->virt->entries[inst].init_state &= ~DDF_initstate_mask;
- if (is_resync_complete(a))
+ if (is_resync_complete(&a->info))
ddf->virt->entries[inst].init_state |= DDF_init_full;
- else if (a->resync_start == 0)
+ else if (a->info.resync_start == 0)
ddf->virt->entries[inst].init_state |= DDF_init_not;
else
ddf->virt->entries[inst].init_state |= DDF_init_quick;
ddf->updates_pending = 1;
dprintf("ddf mark %d %s %llu\n", inst, consistent?"clean":"dirty",
- a->resync_start);
+ a->info.resync_start);
return consistent;
}
di->disk.major = dl->major;
di->disk.minor = dl->minor;
di->disk.state = 0;
+ di->recovery_start = 0;
di->data_offset = pos;
di->component_size = a->info.component_size;
di->container_member = dl->pdnum;
#ifndef MDASSEMBLE
.examine_super = examine_super_ddf,
.brief_examine_super = brief_examine_super_ddf,
+ .brief_examine_subarrays = brief_examine_subarrays_ddf,
.export_examine_super = export_examine_super_ddf,
.detail_super = detail_super_ddf,
.brief_detail_super = brief_detail_super_ddf,
.load_super = load_super_ddf,
.init_super = init_super_ddf,
- .store_super = store_zero_ddf,
+ .store_super = store_super_ddf,
.free_super = free_super_ddf,
.match_metadata_desc = match_metadata_desc_ddf,
.container_content = container_content_ddf,
projects / thirdparty / mdadm.git / blobdiff