summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--sbin/geom/class/raid/graid.815
-rw-r--r--sys/conf/files1
-rw-r--r--sys/geom/raid/md_ddf.c2900
-rw-r--r--sys/geom/raid/md_ddf.h345
-rw-r--r--sys/modules/geom/geom_raid/Makefile2
5 files changed, 3261 insertions, 2 deletions
diff --git a/sbin/geom/class/raid/graid.8 b/sbin/geom/class/raid/graid.8
index e9fd5a4..75c0bd9 100644
--- a/sbin/geom/class/raid/graid.8
+++ b/sbin/geom/class/raid/graid.8
@@ -24,7 +24,7 @@
.\"
.\" $FreeBSD$
.\"
-.Dd April 19, 2012
+.Dd April 30, 2012
.Dt GRAID 8
.Os
.Sh NAME
@@ -200,6 +200,19 @@ The GEOM RAID class follows a modular design, allowing different metadata
formats to be used.
Support is currently implemented for the following formats:
.Bl -tag -width "Intel"
+.It DDF
+The format defined by the SNIA Common RAID Disk Data Format v2.0 specification.
+Used by some Adaptec RAID BIOSes and some hardware RAID controllers.
+Because of high format flexibility different implementations support
+different set of features and have different on-disk metadata layouts.
+To provide compatibility, the GEOM RAID class mimics capabilities and
+metadata layout of the first detected DDF array.
+Respecting that, it may support different number of disks per volume,
+volumes per array, partitions per disk, etc.
+The following configurations are supported: RAID0 (2+ disks), RAID1 (2+ disks),
+RAID1E (3+ disks), RAID3 (3+ disks), RAID4 (3+ disks), RAID5 (3+ disks),
+RAID5E (4+ disks), RAID5EE (4+ disks), RAID5R (3+ disks), RAID6 (4+ disks),
+RAIDMDF (5+ disks), RAID10 (4+ disks), SINGLE (1 disk), CONCAT (2+ disks).
.It Intel
The format used by Intel RAID BIOS.
Supports up to two volumes per array.
diff --git a/sys/conf/files b/sys/conf/files
index c533869..49765bf 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -2396,6 +2396,7 @@ geom/raid/g_raid.c optional geom_raid
geom/raid/g_raid_ctl.c optional geom_raid
geom/raid/g_raid_md_if.m optional geom_raid
geom/raid/g_raid_tr_if.m optional geom_raid
+geom/raid/md_ddf.c optional geom_raid
geom/raid/md_intel.c optional geom_raid
geom/raid/md_jmicron.c optional geom_raid
geom/raid/md_nvidia.c optional geom_raid
diff --git a/sys/geom/raid/md_ddf.c b/sys/geom/raid/md_ddf.c
new file mode 100644
index 0000000..d1f9d79
--- /dev/null
+++ b/sys/geom/raid/md_ddf.c
@@ -0,0 +1,2900 @@
+/*-
+ * Copyright (c) 2012 Alexander Motin <mav@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/bio.h>
+#include <sys/endian.h>
+#include <sys/kernel.h>
+#include <sys/kobj.h>
+#include <sys/limits.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mutex.h>
+#include <sys/systm.h>
+#include <sys/time.h>
+#include <sys/clock.h>
+#include <geom/geom.h>
+#include "geom/raid/g_raid.h"
+#include "geom/raid/md_ddf.h"
+#include "g_raid_md_if.h"
+
+static MALLOC_DEFINE(M_MD_DDF, "md_ddf_data", "GEOM_RAID DDF metadata");
+
+#define DDF_MAX_DISKS_HARD 128
+
+#define DDF_MAX_DISKS 16
+#define DDF_MAX_VDISKS 7
+#define DDF_MAX_PARTITIONS 1
+
+#define DECADE (3600*24*(365*10+2)) /* 10 years in seconds. */
+
+struct ddf_meta {
+ u_int sectorsize;
+ u_int bigendian;
+ struct ddf_header *hdr;
+ struct ddf_cd_record *cdr;
+ struct ddf_pd_record *pdr;
+ struct ddf_vd_record *vdr;
+ void *cr;
+ struct ddf_pdd_record *pdd;
+ struct ddf_bbm_log *bbm;
+};
+
+struct ddf_vol_meta {
+ u_int sectorsize;
+ u_int bigendian;
+ struct ddf_header *hdr;
+ struct ddf_cd_record *cdr;
+ struct ddf_vd_entry *vde;
+ struct ddf_vdc_record *vdc;
+ struct ddf_vdc_record *bvdc[DDF_MAX_DISKS_HARD];
+};
+
+struct g_raid_md_ddf_perdisk {
+ struct ddf_meta pd_meta;
+};
+
+struct g_raid_md_ddf_pervolume {
+ struct ddf_vol_meta pv_meta;
+ int pv_started;
+ struct callout pv_start_co; /* STARTING state timer. */
+};
+
+struct g_raid_md_ddf_object {
+ struct g_raid_md_object mdio_base;
+ struct ddf_meta mdio_meta;
+ struct callout mdio_start_co; /* STARTING state timer. */
+ int mdio_started;
+ int mdio_incomplete;
+ struct root_hold_token *mdio_rootmount; /* Root mount delay token. */
+};
+
+static g_raid_md_create_t g_raid_md_create_ddf;
+static g_raid_md_taste_t g_raid_md_taste_ddf;
+static g_raid_md_event_t g_raid_md_event_ddf;
+static g_raid_md_volume_event_t g_raid_md_volume_event_ddf;
+static g_raid_md_ctl_t g_raid_md_ctl_ddf;
+static g_raid_md_write_t g_raid_md_write_ddf;
+static g_raid_md_fail_disk_t g_raid_md_fail_disk_ddf;
+static g_raid_md_free_disk_t g_raid_md_free_disk_ddf;
+static g_raid_md_free_volume_t g_raid_md_free_volume_ddf;
+static g_raid_md_free_t g_raid_md_free_ddf;
+
+static kobj_method_t g_raid_md_ddf_methods[] = {
+ KOBJMETHOD(g_raid_md_create, g_raid_md_create_ddf),
+ KOBJMETHOD(g_raid_md_taste, g_raid_md_taste_ddf),
+ KOBJMETHOD(g_raid_md_event, g_raid_md_event_ddf),
+ KOBJMETHOD(g_raid_md_volume_event, g_raid_md_volume_event_ddf),
+ KOBJMETHOD(g_raid_md_ctl, g_raid_md_ctl_ddf),
+ KOBJMETHOD(g_raid_md_write, g_raid_md_write_ddf),
+ KOBJMETHOD(g_raid_md_fail_disk, g_raid_md_fail_disk_ddf),
+ KOBJMETHOD(g_raid_md_free_disk, g_raid_md_free_disk_ddf),
+ KOBJMETHOD(g_raid_md_free_volume, g_raid_md_free_volume_ddf),
+ KOBJMETHOD(g_raid_md_free, g_raid_md_free_ddf),
+ { 0, 0 }
+};
+
+static struct g_raid_md_class g_raid_md_ddf_class = {
+ "DDF",
+ g_raid_md_ddf_methods,
+ sizeof(struct g_raid_md_ddf_object),
+ .mdc_priority = 100
+};
+
+#define GET8(m, f) ((m)->f)
+#define GET16(m, f) ((m)->bigendian ? be16dec(&(m)->f) : le16dec(&(m)->f))
+#define GET32(m, f) ((m)->bigendian ? be32dec(&(m)->f) : le32dec(&(m)->f))
+#define GET64(m, f) ((m)->bigendian ? be64dec(&(m)->f) : le64dec(&(m)->f))
+#define GET8D(m, f) (f)
+#define GET16D(m, f) ((m)->bigendian ? be16dec(&f) : le16dec(&f))
+#define GET32D(m, f) ((m)->bigendian ? be32dec(&f) : le32dec(&f))
+#define GET64D(m, f) ((m)->bigendian ? be64dec(&f) : le64dec(&f))
+#define GET8P(m, f) (*(f))
+#define GET16P(m, f) ((m)->bigendian ? be16dec(f) : le16dec(f))
+#define GET32P(m, f) ((m)->bigendian ? be32dec(f) : le32dec(f))
+#define GET64P(m, f) ((m)->bigendian ? be64dec(f) : le64dec(f))
+
+#define SET8P(m, f, v) \
+ (*(f) = (v))
+#define SET16P(m, f, v) \
+ do { \
+ if ((m)->bigendian) \
+ be16enc((f), (v)); \
+ else \
+ le16enc((f), (v)); \
+ } while (0)
+#define SET32P(m, f, v) \
+ do { \
+ if ((m)->bigendian) \
+ be32enc((f), (v)); \
+ else \
+ le32enc((f), (v)); \
+ } while (0)
+#define SET64P(m, f, v) \
+ do { \
+ if ((m)->bigendian) \
+ be64enc((f), (v)); \
+ else \
+ le64enc((f), (v)); \
+ } while (0)
+#define SET8(m, f, v) SET8P((m), &((m)->f), (v))
+#define SET16(m, f, v) SET16P((m), &((m)->f), (v))
+#define SET32(m, f, v) SET32P((m), &((m)->f), (v))
+#define SET64(m, f, v) SET64P((m), &((m)->f), (v))
+#define SET8D(m, f, v) SET8P((m), &(f), (v))
+#define SET16D(m, f, v) SET16P((m), &(f), (v))
+#define SET32D(m, f, v) SET32P((m), &(f), (v))
+#define SET64D(m, f, v) SET64P((m), &(f), (v))
+
+static int
+isff(uint8_t *buf, int size)
+{
+ int i;
+
+ for (i = 0; i < size; i++)
+ if (buf[i] != 0xff)
+ return (0);
+ return (1);
+}
+
+static void
+print_guid(uint8_t *buf)
+{
+ int i, ascii;
+
+ ascii = 1;
+ for (i = 0; i < 24; i++) {
+ if (buf[i] != 0 && (buf[i] < ' ' || buf[i] > 127)) {
+ ascii = 0;
+ break;
+ }
+ }
+ if (ascii) {
+ printf("'%.24s'", buf);
+ } else {
+ for (i = 0; i < 24; i++)
+ printf("%02x", buf[i]);
+ }
+}
+
+static void
+g_raid_md_ddf_print(struct ddf_meta *meta)
+{
+ struct ddf_vdc_record *vdc;
+ struct ddf_vuc_record *vuc;
+ struct ddf_sa_record *sa;
+ uint64_t *val2;
+ uint32_t val;
+ int i, j, k, num, num2;
+
+ if (g_raid_debug < 1)
+ return;
+
+ printf("********* DDF Metadata *********\n");
+ printf("**** Header ****\n");
+ printf("DDF_Header_GUID ");
+ print_guid(meta->hdr->DDF_Header_GUID);
+ printf("\n");
+ printf("DDF_rev %8.8s\n", (char *)&meta->hdr->DDF_rev[0]);
+ printf("Sequence_Number 0x%08x\n", GET32(meta, hdr->Sequence_Number));
+ printf("TimeStamp 0x%08x\n", GET32(meta, hdr->TimeStamp));
+ printf("Open_Flag 0x%02x\n", GET16(meta, hdr->Open_Flag));
+ printf("Foreign_Flag 0x%02x\n", GET16(meta, hdr->Foreign_Flag));
+ printf("Diskgrouping 0x%02x\n", GET16(meta, hdr->Diskgrouping));
+ printf("Primary_Header_LBA %ju\n", GET64(meta, hdr->Primary_Header_LBA));
+ printf("Secondary_Header_LBA %ju\n", GET64(meta, hdr->Secondary_Header_LBA));
+ printf("WorkSpace_Length %u\n", GET32(meta, hdr->WorkSpace_Length));
+ printf("WorkSpace_LBA %ju\n", GET64(meta, hdr->WorkSpace_LBA));
+ printf("Max_PD_Entries %u\n", GET16(meta, hdr->Max_PD_Entries));
+ printf("Max_VD_Entries %u\n", GET16(meta, hdr->Max_VD_Entries));
+ printf("Max_Partitions %u\n", GET16(meta, hdr->Max_Partitions));
+ printf("Configuration_Record_Length %u\n", GET16(meta, hdr->Configuration_Record_Length));
+ printf("Max_Primary_Element_Entries %u\n", GET16(meta, hdr->Max_Primary_Element_Entries));
+ printf("Controller Data %u:%u\n", GET32(meta, hdr->cd_section), GET32(meta, hdr->cd_length));
+ printf("Physical Disk %u:%u\n", GET32(meta, hdr->pdr_section), GET32(meta, hdr->pdr_length));
+ printf("Virtual Disk %u:%u\n", GET32(meta, hdr->vdr_section), GET32(meta, hdr->vdr_length));
+ printf("Configuration Recs %u:%u\n", GET32(meta, hdr->cr_section), GET32(meta, hdr->cr_length));
+ printf("Physical Disk Recs %u:%u\n", GET32(meta, hdr->pdd_section), GET32(meta, hdr->pdd_length));
+ printf("BBM Log %u:%u\n", GET32(meta, hdr->bbmlog_section), GET32(meta, hdr->bbmlog_length));
+ printf("Diagnostic Space %u:%u\n", GET32(meta, hdr->Diagnostic_Space), GET32(meta, hdr->Diagnostic_Space_Length));
+ printf("Vendor_Specific_Logs %u:%u\n", GET32(meta, hdr->Vendor_Specific_Logs), GET32(meta, hdr->Vendor_Specific_Logs_Length));
+ printf("**** Controler Data ****\n");
+ printf("Controller_GUID ");
+ print_guid(meta->cdr->Controller_GUID);
+ printf("\n");
+ printf("Controller_Type 0x%04x%04x 0x%04x%04x\n",
+ GET16(meta, cdr->Controller_Type.Vendor_ID),
+ GET16(meta, cdr->Controller_Type.Device_ID),
+ GET16(meta, cdr->Controller_Type.SubVendor_ID),
+ GET16(meta, cdr->Controller_Type.SubDevice_ID));
+ printf("Product_ID '%.16s'\n", (char *)&meta->cdr->Product_ID[0]);
+ printf("**** Physical Disk Data ****\n");
+ printf("Populated_PDEs %u\n", GET16(meta, pdr->Populated_PDEs));
+ printf("Max_PDE_Supported %u\n", GET16(meta, pdr->Max_PDE_Supported));
+ for (j = 0; j < GET16(meta, pdr->Populated_PDEs); j++) {
+ if (isff(meta->pdr->entry[j].PD_GUID, 24))
+ continue;
+ if (GET32(meta, pdr->entry[j].PD_Reference) == 0xffffffff)
+ continue;
+ printf("PD_GUID ");
+ print_guid(meta->pdr->entry[j].PD_GUID);
+ printf("\n");
+ printf("PD_Reference 0x%08x\n",
+ GET32(meta, pdr->entry[j].PD_Reference));
+ printf("PD_Type 0x%04x\n",
+ GET16(meta, pdr->entry[j].PD_Type));
+ printf("PD_State 0x%04x\n",
+ GET16(meta, pdr->entry[j].PD_State));
+ printf("Configured_Size %ju\n",
+ GET64(meta, pdr->entry[j].Configured_Size));
+ printf("Block_Size %u\n",
+ GET16(meta, pdr->entry[j].Block_Size));
+ }
+ printf("**** Virtual Disk Data ****\n");
+ printf("Populated_VDEs %u\n", GET16(meta, vdr->Populated_VDEs));
+ printf("Max_VDE_Supported %u\n", GET16(meta, vdr->Max_VDE_Supported));
+ for (j = 0; j < GET16(meta, vdr->Populated_VDEs); j++) {
+ if (isff(meta->vdr->entry[j].VD_GUID, 24))
+ continue;
+ printf("VD_GUID ");
+ print_guid(meta->vdr->entry[j].VD_GUID);
+ printf("\n");
+ printf("VD_Number 0x%04x\n",
+ GET16(meta, vdr->entry[j].VD_Number));
+ printf("VD_Type 0x%02x\n",
+ GET8(meta, vdr->entry[j].VD_Type));
+ printf("VD_State 0x%02x\n",
+ GET8(meta, vdr->entry[j].VD_State));
+ printf("Init_State 0x%02x\n",
+ GET8(meta, vdr->entry[j].Init_State));
+ printf("Drive_Failures_Remaining %u\n",
+ GET8(meta, vdr->entry[j].Drive_Failures_Remaining));
+ printf("VD_Name '%.16s'\n",
+ (char *)&meta->vdr->entry[j].VD_Name);
+ }
+ printf("**** Configuration Records ****\n");
+ num = GET32(meta, hdr->cr_length) / GET16(meta, hdr->Configuration_Record_Length);
+ for (j = 0; j < num; j++) {
+ vdc = (struct ddf_vdc_record *)((uint8_t *)meta->cr +
+ j * GET16(meta, hdr->Configuration_Record_Length) *
+ meta->sectorsize);
+ val = GET32D(meta, vdc->Signature);
+ switch (val) {
+ case DDF_VDCR_SIGNATURE:
+ printf("** Virtual Disk Configuration **\n");
+ printf("VD_GUID ");
+ print_guid(vdc->VD_GUID);
+ printf("\n");
+ printf("Timestamp 0x%08x\n",
+ GET32D(meta, vdc->Timestamp));
+ printf("Sequence_Number 0x%08x\n",
+ GET32D(meta, vdc->Sequence_Number));
+ printf("Primary_Element_Count %u\n",
+ GET16D(meta, vdc->Primary_Element_Count));
+ printf("Stripe_Size %u\n",
+ GET8D(meta, vdc->Stripe_Size));
+ printf("Primary_RAID_Level 0x%02x\n",
+ GET8D(meta, vdc->Primary_RAID_Level));
+ printf("RLQ 0x%02x\n",
+ GET8D(meta, vdc->RLQ));
+ printf("Secondary_Element_Count %u\n",
+ GET8D(meta, vdc->Secondary_Element_Count));
+ printf("Secondary_Element_Seq %u\n",
+ GET8D(meta, vdc->Secondary_Element_Seq));
+ printf("Secondary_RAID_Level 0x%02x\n",
+ GET8D(meta, vdc->Secondary_RAID_Level));
+ printf("Block_Count %ju\n",
+ GET64D(meta, vdc->Block_Count));
+ printf("VD_Size %ju\n",
+ GET64D(meta, vdc->VD_Size));
+ printf("Block_Size %u\n",
+ GET16D(meta, vdc->Block_Size));
+ printf("Rotate_Parity_count %u\n",
+ GET8D(meta, vdc->Rotate_Parity_count));
+ printf("Associated_Spare_Disks");
+ for (i = 0; i < 8; i++) {
+ if (GET32D(meta, vdc->Associated_Spares[i]) != 0xffffffff)
+ printf(" 0x%08x", GET32D(meta, vdc->Associated_Spares[i]));
+ }
+ printf("\n");
+ printf("Cache_Flags %016jx\n",
+ GET64D(meta, vdc->Cache_Flags));
+ printf("BG_Rate %u\n",
+ GET8D(meta, vdc->BG_Rate));
+ printf("MDF_Parity_Disks %u\n",
+ GET8D(meta, vdc->MDF_Parity_Disks));
+ printf("MDF_Parity_Generator_Polynomial 0x%04x\n",
+ GET16D(meta, vdc->MDF_Parity_Generator_Polynomial));
+ printf("MDF_Constant_Generation_Method 0x%02x\n",
+ GET8D(meta, vdc->MDF_Constant_Generation_Method));
+ printf("Physical_Disks ");
+ num2 = GET16D(meta, vdc->Primary_Element_Count);
+ val2 = (uint64_t *)&(vdc->Physical_Disk_Sequence[GET16(meta, hdr->Max_Primary_Element_Entries)]);
+ for (i = 0; i < num2; i++)
+ printf(" 0x%08x @ %ju",
+ GET32D(meta, vdc->Physical_Disk_Sequence[i]),
+ GET64P(meta, val2 + i));
+ printf("\n");
+ break;
+ case DDF_VUCR_SIGNATURE:
+ printf("** Vendor Unique Configuration **\n");
+ vuc = (struct ddf_vuc_record *)vdc;
+ printf("VD_GUID ");
+ print_guid(vuc->VD_GUID);
+ printf("\n");
+ break;
+ case DDF_SA_SIGNATURE:
+ printf("** Spare Assignment Configuration **\n");
+ sa = (struct ddf_sa_record *)vdc;
+ printf("Timestamp 0x%08x\n",
+ GET32D(meta, sa->Timestamp));
+ printf("Spare_Type 0x%02x\n",
+ GET8D(meta, sa->Spare_Type));
+ printf("Populated_SAEs %u\n",
+ GET16D(meta, sa->Populated_SAEs));
+ printf("MAX_SAE_Supported %u\n",
+ GET16D(meta, sa->MAX_SAE_Supported));
+ for (i = 0; i < GET16D(meta, sa->Populated_SAEs); i++) {
+ if (isff(sa->entry[i].VD_GUID, 24))
+ continue;
+ printf("VD_GUID ");
+ for (k = 0; k < 24; k++)
+ printf("%02x", sa->entry[i].VD_GUID[k]);
+ printf("\n");
+ printf("Secondary_Element %u\n",
+ GET16D(meta, sa->entry[i].Secondary_Element));
+ }
+ break;
+ case 0xFFFFFFFF:
+ break;
+ default:
+ printf("Unknown configuration signature %08x\n", val);
+ break;
+ }
+ }
+ printf("**** Physical Disk Data ****\n");
+ printf("PD_GUID ");
+ print_guid(meta->pdd->PD_GUID);
+ printf("\n");
+ printf("PD_Reference 0x%08x\n",
+ GET32(meta, pdd->PD_Reference));
+ printf("Forced_Ref_Flag 0x%02x\n",
+ GET8(meta, pdd->Forced_Ref_Flag));
+ printf("Forced_PD_GUID_Flag 0x%02x\n",
+ GET8(meta, pdd->Forced_PD_GUID_Flag));
+}
+
+static int
+ddf_meta_find_pd(struct ddf_meta *meta, uint8_t *GUID, uint32_t PD_Reference)
+{
+ int i;
+
+ for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
+ if (GUID != NULL) {
+ if (memcmp(meta->pdr->entry[i].PD_GUID, GUID, 24) == 0)
+ return (i);
+ } else if (PD_Reference != 0xffffffff) {
+ if (GET32(meta, pdr->entry[i].PD_Reference) == PD_Reference)
+ return (i);
+ } else
+ if (isff(meta->pdr->entry[i].PD_GUID, 24))
+ return (i);
+ }
+ if (GUID == NULL && PD_Reference == 0xffffffff) {
+ if (i >= GET16(meta, pdr->Max_PDE_Supported))
+ return (-1);
+ SET16(meta, pdr->Populated_PDEs, i + 1);
+ return (i);
+ }
+ return (-1);
+}
+
+static int
+ddf_meta_find_vd(struct ddf_meta *meta, uint8_t *GUID)
+{
+ int i;
+
+ for (i = 0; i < GET16(meta, vdr->Populated_VDEs); i++) {
+ if (GUID != NULL) {
+ if (memcmp(meta->vdr->entry[i].VD_GUID, GUID, 24) == 0)
+ return (i);
+ } else
+ if (isff(meta->vdr->entry[i].VD_GUID, 24))
+ return (i);
+ }
+ if (GUID == NULL) {
+ if (i >= GET16(meta, vdr->Max_VDE_Supported))
+ return (-1);
+ SET16(meta, vdr->Populated_VDEs, i + 1);
+ return (i);
+ }
+ return (-1);
+}
+
+static struct ddf_vdc_record *
+ddf_meta_find_vdc(struct ddf_meta *meta, uint8_t *GUID)
+{
+ struct ddf_vdc_record *vdc;
+ int i, num;
+
+ num = GET32(meta, hdr->cr_length) / GET16(meta, hdr->Configuration_Record_Length);
+ for (i = 0; i < num; i++) {
+ vdc = (struct ddf_vdc_record *)((uint8_t *)meta->cr +
+ i * GET16(meta, hdr->Configuration_Record_Length) *
+ meta->sectorsize);
+ if (GUID != NULL) {
+ if (GET32D(meta, vdc->Signature) == DDF_VDCR_SIGNATURE &&
+ memcmp(vdc->VD_GUID, GUID, 24) == 0)
+ return (vdc);
+ } else
+ if (GET32D(meta, vdc->Signature) == 0xffffffff)
+ return (vdc);
+ }
+ return (NULL);
+}
+
+static int
+ddf_meta_count_vdc(struct ddf_meta *meta, uint8_t *GUID)
+{
+ struct ddf_vdc_record *vdc;
+ int i, num, cnt;
+
+ cnt = 0;
+ num = GET32(meta, hdr->cr_length) / GET16(meta, hdr->Configuration_Record_Length);
+ for (i = 0; i < num; i++) {
+ vdc = (struct ddf_vdc_record *)((uint8_t *)meta->cr +
+ i * GET16(meta, hdr->Configuration_Record_Length) *
+ meta->sectorsize);
+ if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
+ continue;
+ if (GUID == NULL || memcmp(vdc->VD_GUID, GUID, 24) == 0)
+ cnt++;
+ }
+ return (cnt);
+}
+
+static int
+ddf_meta_find_disk(struct ddf_vol_meta *vmeta, uint32_t PD_Reference,
+ int *bvdp, int *posp)
+{
+ int i, bvd, pos;
+
+ i = 0;
+ for (bvd = 0; bvd < GET16(vmeta, vdc->Secondary_Element_Count); bvd++) {
+ if (vmeta->bvdc[bvd] == NULL) {
+ i += GET16(vmeta, vdc->Primary_Element_Count); // XXX
+ continue;
+ }
+ for (pos = 0; pos < GET16(vmeta, bvdc[bvd]->Primary_Element_Count);
+ pos++, i++) {
+ if (GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos]) ==
+ PD_Reference) {
+ if (bvdp != NULL)
+ *bvdp = bvd;
+ if (posp != NULL)
+ *posp = pos;
+ return (i);
+ }
+ }
+ }
+ return (-1);
+}
+
+static void
+ddf_meta_create(struct g_raid_disk *disk, struct ddf_meta *sample)
+{
+ struct timespec ts;
+ struct clocktime ct;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct ddf_meta *meta;
+ struct ddf_pd_entry *pde;
+ off_t anchorlba;
+ u_int ss, pos, size;
+ int len, error;
+ char serial_buffer[24];
+
+ if (sample->hdr == NULL)
+ sample = NULL;
+
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ meta = &pd->pd_meta;
+ ss = disk->d_consumer->provider->sectorsize;
+ anchorlba = disk->d_consumer->provider->mediasize / ss - 1;
+
+ meta->sectorsize = ss;
+ meta->bigendian = sample ? sample->bigendian : 0;
+ getnanotime(&ts);
+ clock_ts_to_ct(&ts, &ct);
+
+ /* Header */
+ meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
+ memset(meta->hdr, 0xff, ss);
+ if (sample) {
+ memcpy(meta->hdr, sample->hdr, sizeof(struct ddf_header));
+ if (ss != sample->sectorsize) {
+ SET32(meta, hdr->WorkSpace_Length,
+ (GET32(sample, hdr->WorkSpace_Length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET16(meta, hdr->Configuration_Record_Length,
+ (GET16(sample, hdr->Configuration_Record_Length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->cd_length,
+ (GET32(sample, hdr->cd_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->pdr_length,
+ (GET32(sample, hdr->pdr_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->vdr_length,
+ (GET32(sample, hdr->vdr_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->cr_length,
+ (GET32(sample, hdr->cr_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->pdd_length,
+ (GET32(sample, hdr->pdd_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->bbmlog_length,
+ (GET32(sample, hdr->bbmlog_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->Diagnostic_Space,
+ (GET32(sample, hdr->bbmlog_length) *
+ sample->sectorsize + ss - 1) / ss);
+ SET32(meta, hdr->Vendor_Specific_Logs,
+ (GET32(sample, hdr->bbmlog_length) *
+ sample->sectorsize + ss - 1) / ss);
+ }
+ } else {
+ SET32(meta, hdr->Signature, DDF_HEADER_SIGNATURE);
+ snprintf(meta->hdr->DDF_Header_GUID, 25, "FreeBSD %08x%08x",
+ (u_int)(ts.tv_sec - DECADE), arc4random());
+ memcpy(meta->hdr->DDF_rev, "02.00.00", 8);
+ SET32(meta, hdr->TimeStamp, (ts.tv_sec - DECADE));
+ SET32(meta, hdr->WorkSpace_Length, 16 * 1024 * 1024 / ss);
+ SET16(meta, hdr->Max_PD_Entries, DDF_MAX_DISKS - 1);
+ SET16(meta, hdr->Max_VD_Entries, DDF_MAX_VDISKS);
+ SET16(meta, hdr->Max_Partitions, DDF_MAX_PARTITIONS);
+ SET16(meta, hdr->Max_Primary_Element_Entries, DDF_MAX_DISKS);
+ SET16(meta, hdr->Configuration_Record_Length,
+ (sizeof(struct ddf_vdc_record) +
+ (4 + 8) * GET16(meta, hdr->Max_Primary_Element_Entries) +
+ ss - 1) / ss);
+ SET32(meta, hdr->cd_length,
+ (sizeof(struct ddf_cd_record) + ss - 1) / ss);
+ SET32(meta, hdr->pdr_length,
+ (sizeof(struct ddf_pd_record) +
+ sizeof(struct ddf_pd_entry) *
+ GET16(meta, hdr->Max_PD_Entries) + ss - 1) / ss);
+ SET32(meta, hdr->vdr_length,
+ (sizeof(struct ddf_vd_record) +
+ sizeof(struct ddf_vd_entry) *
+ GET16(meta, hdr->Max_VD_Entries) + ss - 1) / ss);
+ SET32(meta, hdr->cr_length,
+ GET16(meta, hdr->Configuration_Record_Length) *
+ (GET16(meta, hdr->Max_Partitions) + 1));
+ SET32(meta, hdr->pdd_length,
+ (sizeof(struct ddf_pdd_record) + ss - 1) / ss);
+ SET32(meta, hdr->bbmlog_length, 0);
+ SET32(meta, hdr->Diagnostic_Space_Length, 0);
+ SET32(meta, hdr->Vendor_Specific_Logs_Length, 0);
+ }
+ pos = 1;
+ SET32(meta, hdr->cd_section, pos);
+ pos += GET32(meta, hdr->cd_length);
+ SET32(meta, hdr->pdr_section, pos);
+ pos += GET32(meta, hdr->pdr_length);
+ SET32(meta, hdr->vdr_section, pos);
+ pos += GET32(meta, hdr->vdr_length);
+ SET32(meta, hdr->cr_section, pos);
+ pos += GET32(meta, hdr->cr_length);
+ SET32(meta, hdr->pdd_section, pos);
+ pos += GET32(meta, hdr->pdd_length);
+ SET32(meta, hdr->bbmlog_section,
+ GET32(meta, hdr->bbmlog_length) != 0 ? pos : 0xffffffff);
+ pos += GET32(meta, hdr->bbmlog_length);
+ SET32(meta, hdr->Diagnostic_Space,
+ GET32(meta, hdr->Diagnostic_Space_Length) != 0 ? pos : 0xffffffff);
+ pos += GET32(meta, hdr->Diagnostic_Space_Length);
+ SET32(meta, hdr->Vendor_Specific_Logs,
+ GET32(meta, hdr->Vendor_Specific_Logs_Length) != 0 ? pos : 0xffffffff);
+ pos += GET32(meta, hdr->Vendor_Specific_Logs_Length);
+ SET64(meta, hdr->Primary_Header_LBA,
+ anchorlba - pos - 16);
+ SET64(meta, hdr->Secondary_Header_LBA,
+ 0xffffffffffffffffULL);
+ SET64(meta, hdr->WorkSpace_LBA,
+ anchorlba + 1 - 32 * 1024 * 1024 / ss);
+
+ /* Controller Data */
+ size = GET32(meta, hdr->cd_length) * ss;
+ meta->cdr = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->cdr, 0xff, size);
+ SET32(meta, cdr->Signature, DDF_CONTROLLER_DATA_SIGNATURE);
+ memcpy(meta->cdr->Controller_GUID, "FreeBSD GEOM RAID SERIAL", 24);
+ memcpy(meta->cdr->Product_ID, "FreeBSD GEOMRAID", 16);
+
+ /* Physical Drive Records. */
+ size = GET32(meta, hdr->pdr_length) * ss;
+ meta->pdr = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->pdr, 0xff, size);
+ SET32(meta, pdr->Signature, DDF_PDR_SIGNATURE);
+ SET16(meta, pdr->Populated_PDEs, 1);
+ SET16(meta, pdr->Max_PDE_Supported,
+ GET16(meta, hdr->Max_PD_Entries));
+
+ pde = &meta->pdr->entry[0];
+ len = sizeof(serial_buffer);
+ error = g_io_getattr("GEOM::ident", disk->d_consumer, &len, serial_buffer);
+ if (error == 0 && (len = strlen (serial_buffer)) >= 6 && len <= 20)
+ snprintf(pde->PD_GUID, 25, "DISK%20s", serial_buffer);
+ else
+ snprintf(pde->PD_GUID, 25, "DISK%04d%02d%02d%08x%04x",
+ ct.year, ct.mon, ct.day,
+ arc4random(), arc4random() & 0xffff);
+ SET32D(meta, pde->PD_Reference, arc4random());
+ SET16D(meta, pde->PD_Type, DDF_PDE_GUID_FORCE);
+ SET16D(meta, pde->PD_State, 0);
+ SET64D(meta, pde->Configured_Size,
+ anchorlba + 1 - 32 * 1024 * 1024 / ss);
+ SET16D(meta, pde->Block_Size, ss);
+
+ /* Virtual Drive Records. */
+ size = GET32(meta, hdr->vdr_length) * ss;
+ meta->vdr = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->vdr, 0xff, size);
+ SET32(meta, vdr->Signature, DDF_VD_RECORD_SIGNATURE);
+ SET32(meta, vdr->Populated_VDEs, 0);
+ SET16(meta, vdr->Max_VDE_Supported,
+ GET16(meta, hdr->Max_VD_Entries));
+
+ /* Configuration Records. */
+ size = GET32(meta, hdr->cr_length) * ss;
+ meta->cr = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->cr, 0xff, size);
+
+ /* Physical Disk Data. */
+ size = GET32(meta, hdr->pdd_length) * ss;
+ meta->pdd = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->pdd, 0xff, size);
+ SET32(meta, pdd->Signature, DDF_PDD_SIGNATURE);
+ memcpy(meta->pdd->PD_GUID, pde->PD_GUID, 24);
+ SET32(meta, pdd->PD_Reference, GET32D(meta, pde->PD_Reference));
+ SET8(meta, pdd->Forced_Ref_Flag, DDF_PDD_FORCED_REF);
+ SET8(meta, pdd->Forced_PD_GUID_Flag, DDF_PDD_FORCED_GUID);
+
+ /* Bad Block Management Log. */
+ if (GET32(meta, hdr->bbmlog_length) != 0) {
+ size = GET32(meta, hdr->bbmlog_length) * ss;
+ meta->bbm = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->bbm, 0xff, size);
+ SET32(meta, bbm->Signature, DDF_BBML_SIGNATURE);
+ SET32(meta, bbm->Entry_Count, 0);
+ SET32(meta, bbm->Spare_Block_Count, 0);
+ }
+}
+
+static void
+ddf_meta_copy(struct ddf_meta *dst, struct ddf_meta *src)
+{
+ struct ddf_header *hdr;
+ u_int ss;
+
+ hdr = src->hdr;
+ dst->bigendian = src->bigendian;
+ ss = dst->sectorsize = src->sectorsize;
+ dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->hdr, src->hdr, ss);
+ dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss);
+ dst->pdr = malloc(GET32(src, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->pdr, src->pdr, GET32(src, hdr->pdr_length) * ss);
+ dst->vdr = malloc(GET32(src, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->vdr, src->vdr, GET32(src, hdr->vdr_length) * ss);
+ dst->cr = malloc(GET32(src, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->cr, src->cr, GET32(src, hdr->cr_length) * ss);
+ dst->pdd = malloc(GET32(src, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->pdd, src->pdd, GET32(src, hdr->pdd_length) * ss);
+ if (src->bbm != NULL) {
+ dst->bbm = malloc(GET32(src, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->bbm, src->bbm, GET32(src, hdr->bbmlog_length) * ss);
+ }
+}
+
+static void
+ddf_meta_update(struct ddf_meta *meta, struct ddf_meta *src)
+{
+ struct ddf_pd_entry *pde, *spde;
+ int i, j;
+
+ for (i = 0; i < GET16(src, pdr->Populated_PDEs); i++) {
+ spde = &src->pdr->entry[i];
+ if (isff(spde->PD_GUID, 24))
+ continue;
+ j = ddf_meta_find_pd(meta, NULL,
+ src->pdr->entry[i].PD_Reference);
+ if (j < 0) {
+ j = ddf_meta_find_pd(meta, NULL, 0xffffffff);
+ pde = &meta->pdr->entry[j];
+ memcpy(pde, spde, sizeof(*pde));
+ } else {
+ pde = &meta->pdr->entry[j];
+ SET16D(meta, pde->PD_State,
+ GET16D(meta, pde->PD_State) |
+ GET16D(src, pde->PD_State));
+ }
+ }
+}
+
+static void
+ddf_meta_free(struct ddf_meta *meta)
+{
+
+ if (meta->hdr != NULL) {
+ free(meta->hdr, M_MD_DDF);
+ meta->hdr = NULL;
+ }
+ if (meta->cdr != NULL) {
+ free(meta->cdr, M_MD_DDF);
+ meta->cdr = NULL;
+ }
+ if (meta->pdr != NULL) {
+ free(meta->pdr, M_MD_DDF);
+ meta->pdr = NULL;
+ }
+ if (meta->vdr != NULL) {
+ free(meta->vdr, M_MD_DDF);
+ meta->vdr = NULL;
+ }
+ if (meta->cr != NULL) {
+ free(meta->cr, M_MD_DDF);
+ meta->cr = NULL;
+ }
+ if (meta->pdd != NULL) {
+ free(meta->pdd, M_MD_DDF);
+ meta->pdd = NULL;
+ }
+ if (meta->bbm != NULL) {
+ free(meta->bbm, M_MD_DDF);
+ meta->bbm = NULL;
+ }
+}
+
+static void
+ddf_vol_meta_create(struct ddf_vol_meta *meta, struct ddf_meta *sample)
+{
+ struct timespec ts;
+ struct clocktime ct;
+ struct ddf_header *hdr;
+ u_int ss, size;
+
+ hdr = sample->hdr;
+ meta->bigendian = sample->bigendian;
+ ss = meta->sectorsize = sample->sectorsize;
+ meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->hdr, sample->hdr, ss);
+ meta->cdr = malloc(GET32(sample, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->cdr, sample->cdr, GET32(sample, hdr->cd_length) * ss);
+ meta->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK);
+ memset(meta->vde, 0xff, sizeof(struct ddf_vd_entry));
+ getnanotime(&ts);
+ clock_ts_to_ct(&ts, &ct);
+ snprintf(meta->vde->VD_GUID, 25, "FreeBSD%04d%02d%02d%08x%01x",
+ ct.year, ct.mon, ct.day,
+ arc4random(), arc4random() & 0xf);
+ size = GET16(sample, hdr->Configuration_Record_Length) * ss;
+ meta->vdc = malloc(size, M_MD_DDF, M_WAITOK);
+ memset(meta->vdc, 0xff, size);
+ SET32(meta, vdc->Signature, DDF_VDCR_SIGNATURE);
+ memcpy(meta->vdc->VD_GUID, meta->vde->VD_GUID, 24);
+ SET32(meta, vdc->Sequence_Number, 0);
+}
+
+static void
+ddf_vol_meta_update(struct ddf_vol_meta *dst, struct ddf_meta *src, uint8_t *GUID)
+{
+ struct ddf_header *hdr;
+ struct ddf_vd_entry *vde;
+ struct ddf_vdc_record *vdc;
+ int vnew, bvnew, bvd, size;
+ u_int ss;
+
+ hdr = src->hdr;
+ vde = &src->vdr->entry[ddf_meta_find_vd(src, GUID)];
+ vdc = ddf_meta_find_vdc(src, GUID);
+ bvd = GET8D(src, vdc->Secondary_Element_Seq);
+ size = GET16(src, hdr->Configuration_Record_Length) * src->sectorsize;
+
+ if (dst->vdc == NULL ||
+ ((int32_t)(GET32D(src, vdc->Sequence_Number) -
+ GET32(dst, vdc->Sequence_Number))) > 0)
+ vnew = 1;
+ else
+ vnew = 0;
+
+ if (dst->bvdc[bvd] == NULL ||
+ ((int32_t)(GET32D(src, vdc->Sequence_Number) -
+ GET32(dst, bvdc[bvd]->Sequence_Number))) > 0)
+ bvnew = 1;
+ else
+ bvnew = 0;
+
+ if (vnew) {
+ dst->bigendian = src->bigendian;
+ ss = dst->sectorsize = src->sectorsize;
+ if (dst->hdr != NULL)
+ free(dst->hdr, M_MD_DDF);
+ dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->hdr, src->hdr, ss);
+ if (dst->cdr != NULL)
+ free(dst->cdr, M_MD_DDF);
+ dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss);
+ if (dst->vde != NULL)
+ free(dst->vde, M_MD_DDF);
+ dst->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK);
+ memcpy(dst->vde, vde, sizeof(struct ddf_vd_entry));
+ if (dst->vdc != NULL)
+ free(dst->vdc, M_MD_DDF);
+ dst->vdc = malloc(size, M_MD_DDF, M_WAITOK);
+ memcpy(dst->vdc, vdc, size);
+ }
+ if (bvnew) {
+ if (dst->bvdc[bvd] != NULL)
+ free(dst->bvdc[bvd], M_MD_DDF);
+ dst->bvdc[bvd] = malloc(size, M_MD_DDF, M_WAITOK);
+ memcpy(dst->bvdc[bvd], vdc, size);
+ }
+}
+
+static void
+ddf_vol_meta_free(struct ddf_vol_meta *meta)
+{
+ int i;
+
+ if (meta->hdr != NULL) {
+ free(meta->hdr, M_MD_DDF);
+ meta->hdr = NULL;
+ }
+ if (meta->cdr != NULL) {
+ free(meta->cdr, M_MD_DDF);
+ meta->cdr = NULL;
+ }
+ if (meta->vde != NULL) {
+ free(meta->vde, M_MD_DDF);
+ meta->vde = NULL;
+ }
+ if (meta->vdc != NULL) {
+ free(meta->vdc, M_MD_DDF);
+ meta->vdc = NULL;
+ }
+ for (i = 0; i < DDF_MAX_DISKS_HARD; i++) {
+ if (meta->bvdc[i] != NULL) {
+ free(meta->bvdc[i], M_MD_DDF);
+ meta->bvdc[i] = NULL;
+ }
+ }
+}
+
+static int
+ddf_meta_unused_range(struct ddf_meta *meta, off_t *off, off_t *size)
+{
+ struct ddf_vdc_record *vdc;
+ off_t beg[32], end[32], beg1, end1;
+ uint64_t *offp;
+ int i, j, n, num, pos;
+ uint32_t ref;
+
+ *off = 0;
+ *size = 0;
+ ref = GET32(meta, pdd->PD_Reference);
+ pos = ddf_meta_find_pd(meta, NULL, ref);
+ beg[0] = 0;
+ end[0] = GET64(meta, pdr->entry[pos].Configured_Size);
+ n = 1;
+ num = GET32(meta, hdr->cr_length) /
+ GET16(meta, hdr->Configuration_Record_Length);
+ for (i = 0; i < num; i++) {
+ vdc = (struct ddf_vdc_record *)((uint8_t *)meta->cr +
+ i * GET16(meta, hdr->Configuration_Record_Length) *
+ meta->sectorsize);
+ if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
+ continue;
+ for (pos = 0; pos < GET16D(meta, vdc->Primary_Element_Count); pos++)
+ if (GET32D(meta, vdc->Physical_Disk_Sequence[pos]) == ref)
+ break;
+ if (pos == GET16D(meta, vdc->Primary_Element_Count))
+ continue;
+ offp = (uint64_t *)&(vdc->Physical_Disk_Sequence[
+ GET16(meta, hdr->Max_Primary_Element_Entries)]);
+ beg1 = GET64P(meta, offp + pos);
+ end1 = beg1 + GET64D(meta, vdc->Block_Count);
+ for (j = 0; j < n; j++) {
+ if (beg[j] >= end1 || end[j] <= beg1 )
+ continue;
+ if (beg[j] < beg1 && end[j] > end1) {
+ beg[n] = end1;
+ end[n] = end[j];
+ end[j] = beg1;
+ n++;
+ } else if (beg[j] < beg1)
+ end[j] = beg1;
+ else
+ beg[j] = end1;
+ }
+ }
+ for (j = 0; j < n; j++) {
+ if (end[j] - beg[j] > *size) {
+ *off = beg[j];
+ *size = end[j] - beg[j];
+ }
+ }
+ return ((*size > 0) ? 1 : 0);
+}
+
+static void
+ddf_meta_get_name(struct ddf_meta *meta, int num, char *buf)
+{
+ const char *b;
+ int i;
+
+ b = meta->vdr->entry[num].VD_Name;
+ for (i = 15; i >= 0; i--)
+ if (b[i] != 0x20)
+ break;
+ memcpy(buf, b, i + 1);
+ buf[i + 1] = 0;
+}
+
+static void
+ddf_meta_put_name(struct ddf_vol_meta *meta, char *buf)
+{
+ int len;
+
+ len = min(strlen(buf), 16);
+ memset(meta->vde->VD_Name, 0x20, 16);
+ memcpy(meta->vde->VD_Name, buf, len);
+}
+
+static int
+ddf_meta_read(struct g_consumer *cp, struct ddf_meta *meta)
+{
+ struct g_provider *pp;
+ struct ddf_header *ahdr, *hdr;
+ char *abuf, *buf;
+ off_t plba, slba, lba;
+ int error, len, i;
+ u_int ss;
+ uint32_t val;
+
+ ddf_meta_free(meta);
+ pp = cp->provider;
+ ss = meta->sectorsize = pp->sectorsize;
+ /* Read anchor block. */
+ abuf = g_read_data(cp, pp->mediasize - ss, ss, &error);
+ if (abuf == NULL) {
+ G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).",
+ pp->name, error);
+ return (error);
+ }
+ ahdr = (struct ddf_header *)abuf;
+
+ /* Check if this is an DDF RAID struct */
+ if (be32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE)
+ meta->bigendian = 1;
+ else if (le32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE)
+ meta->bigendian = 0;
+ else {
+ G_RAID_DEBUG(1, "DDF signature check failed on %s", pp->name);
+ error = EINVAL;
+ goto done;
+ }
+ if (ahdr->Header_Type != DDF_HEADER_ANCHOR) {
+ G_RAID_DEBUG(1, "DDF header type check failed on %s", pp->name);
+ error = EINVAL;
+ goto done;
+ }
+ meta->hdr = ahdr;
+ plba = GET64(meta, hdr->Primary_Header_LBA);
+ slba = GET64(meta, hdr->Secondary_Header_LBA);
+ val = GET32(meta, hdr->CRC);
+ SET32(meta, hdr->CRC, 0xffffffff);
+ meta->hdr = NULL;
+ if (crc32(ahdr, ss) != val) {
+ G_RAID_DEBUG(1, "DDF CRC mismatch on %s", pp->name);
+ error = EINVAL;
+ goto done;
+ }
+ if ((plba + 6) * ss >= pp->mediasize) {
+ G_RAID_DEBUG(1, "DDF primary header LBA is wrong on %s", pp->name);
+ error = EINVAL;
+ goto done;
+ }
+ if (slba != -1 && (slba + 6) * ss >= pp->mediasize) {
+ G_RAID_DEBUG(1, "DDF secondary header LBA is wrong on %s", pp->name);
+ error = EINVAL;
+ goto done;
+ }
+ lba = plba;
+
+doread:
+ error = 0;
+ ddf_meta_free(meta);
+
+ /* Read header block. */
+ buf = g_read_data(cp, lba * ss, ss, &error);
+ if (buf == NULL) {
+readerror:
+ G_RAID_DEBUG(1, "DDF %s metadata read error on %s (error=%d).",
+ (lba == plba) ? "primary" : "secondary", pp->name, error);
+ if (lba == plba && slba != -1) {
+ lba = slba;
+ goto doread;
+ }
+ G_RAID_DEBUG(1, "DDF metadata read error on %s.", pp->name);
+ goto done;
+ }
+ meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->hdr, buf, ss);
+ g_free(buf);
+ hdr = meta->hdr;
+ val = GET32(meta, hdr->CRC);
+ SET32(meta, hdr->CRC, 0xffffffff);
+ if (hdr->Signature != ahdr->Signature ||
+ crc32(meta->hdr, ss) != val ||
+ memcmp(hdr->DDF_Header_GUID, ahdr->DDF_Header_GUID, 24) ||
+ GET64(meta, hdr->Primary_Header_LBA) != plba ||
+ GET64(meta, hdr->Secondary_Header_LBA) != slba) {
+hdrerror:
+ G_RAID_DEBUG(1, "DDF %s metadata check failed on %s",
+ (lba == plba) ? "primary" : "secondary", pp->name);
+ if (lba == plba && slba != -1) {
+ lba = slba;
+ goto doread;
+ }
+ G_RAID_DEBUG(1, "DDF metadata check failed on %s", pp->name);
+ error = EINVAL;
+ goto done;
+ }
+ if ((lba == plba && hdr->Header_Type != DDF_HEADER_PRIMARY) ||
+ (lba == slba && hdr->Header_Type != DDF_HEADER_SECONDARY))
+ goto hdrerror;
+ len = 1;
+ len = max(len, GET32(meta, hdr->cd_section) + GET32(meta, hdr->cd_length));
+ len = max(len, GET32(meta, hdr->pdr_section) + GET32(meta, hdr->pdr_length));
+ len = max(len, GET32(meta, hdr->vdr_section) + GET32(meta, hdr->vdr_length));
+ len = max(len, GET32(meta, hdr->cr_section) + GET32(meta, hdr->cr_length));
+ len = max(len, GET32(meta, hdr->pdd_section) + GET32(meta, hdr->pdd_length));
+ if ((val = GET32(meta, hdr->bbmlog_section)) != 0xffffffff)
+ len = max(len, val + GET32(meta, hdr->bbmlog_length));
+ if ((val = GET32(meta, hdr->Diagnostic_Space)) != 0xffffffff)
+ len = max(len, val + GET32(meta, hdr->Diagnostic_Space_Length));
+ if ((val = GET32(meta, hdr->Vendor_Specific_Logs)) != 0xffffffff)
+ len = max(len, val + GET32(meta, hdr->Vendor_Specific_Logs_Length));
+ if ((plba + len) * ss >= pp->mediasize)
+ goto hdrerror;
+ if (slba != -1 && (slba + len) * ss >= pp->mediasize)
+ goto hdrerror;
+ /* Workaround for Adaptec implementation. */
+ if (GET16(meta, hdr->Max_Primary_Element_Entries) == 0xffff) {
+ SET16(meta, hdr->Max_Primary_Element_Entries,
+ min(GET16(meta, hdr->Max_PD_Entries),
+ (GET16(meta, hdr->Configuration_Record_Length) * ss - 512) / 12));
+ }
+
+ /* Read controller data. */
+ buf = g_read_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
+ GET32(meta, hdr->cd_length) * ss, &error);
+ if (buf == NULL)
+ goto readerror;
+ meta->cdr = malloc(GET32(meta, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->cdr, buf, GET32(meta, hdr->cd_length) * ss);
+ g_free(buf);
+ if (GET32(meta, cdr->Signature) != DDF_CONTROLLER_DATA_SIGNATURE)
+ goto hdrerror;
+
+ /* Read physical disk records. */
+ buf = g_read_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
+ GET32(meta, hdr->pdr_length) * ss, &error);
+ if (buf == NULL)
+ goto readerror;
+ meta->pdr = malloc(GET32(meta, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->pdr, buf, GET32(meta, hdr->pdr_length) * ss);
+ g_free(buf);
+ if (GET32(meta, pdr->Signature) != DDF_PDR_SIGNATURE)
+ goto hdrerror;
+
+ /* Read virtual disk records. */
+ buf = g_read_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
+ GET32(meta, hdr->vdr_length) * ss, &error);
+ if (buf == NULL)
+ goto readerror;
+ meta->vdr = malloc(GET32(meta, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->vdr, buf, GET32(meta, hdr->vdr_length) * ss);
+ g_free(buf);
+ if (GET32(meta, vdr->Signature) != DDF_VD_RECORD_SIGNATURE)
+ goto hdrerror;
+
+ /* Read configuration records. */
+ buf = g_read_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
+ GET32(meta, hdr->cr_length) * ss, &error);
+ if (buf == NULL)
+ goto readerror;
+ meta->cr = malloc(GET32(meta, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->cr, buf, GET32(meta, hdr->cr_length) * ss);
+ g_free(buf);
+
+ /* Read physical disk data. */
+ buf = g_read_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
+ GET32(meta, hdr->pdd_length) * ss, &error);
+ if (buf == NULL)
+ goto readerror;
+ meta->pdd = malloc(GET32(meta, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->pdd, buf, GET32(meta, hdr->pdd_length) * ss);
+ g_free(buf);
+ if (GET32(meta, pdd->Signature) != DDF_PDD_SIGNATURE)
+ goto hdrerror;
+ i = ddf_meta_find_pd(meta, NULL, GET32(meta, pdd->PD_Reference));
+ if (i < 0)
+ goto hdrerror;
+
+ /* Read BBM Log. */
+ if (GET32(meta, hdr->bbmlog_section) != 0xffffffff &&
+ GET32(meta, hdr->bbmlog_length) != 0) {
+ buf = g_read_data(cp, (lba + GET32(meta, hdr->bbmlog_section)) * ss,
+ GET32(meta, hdr->bbmlog_length) * ss, &error);
+ if (buf == NULL)
+ goto readerror;
+ meta->bbm = malloc(GET32(meta, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
+ memcpy(meta->bbm, buf, GET32(meta, hdr->bbmlog_length) * ss);
+ g_free(buf);
+ if (GET32(meta, bbm->Signature) != DDF_BBML_SIGNATURE)
+ goto hdrerror;
+ }
+
+done:
+ free(abuf, M_MD_DDF);
+ if (error != 0)
+ ddf_meta_free(meta);
+ return (error);
+}
+
+static int
+ddf_meta_write(struct g_consumer *cp, struct ddf_meta *meta)
+{
+ struct g_provider *pp;
+ struct ddf_vdc_record *vdc;
+ off_t alba, plba, slba, lba;
+ u_int ss, size;
+ int error, i, num;
+
+ pp = cp->provider;
+ ss = pp->sectorsize;
+ lba = alba = pp->mediasize / ss - 1;
+ plba = GET64(meta, hdr->Primary_Header_LBA);
+ slba = GET64(meta, hdr->Secondary_Header_LBA);
+
+next:
+ SET8(meta, hdr->Header_Type, (lba == alba) ? DDF_HEADER_ANCHOR :
+ (lba == plba) ? DDF_HEADER_PRIMARY : DDF_HEADER_SECONDARY);
+ SET32(meta, hdr->CRC, 0xffffffff);
+ SET32(meta, hdr->CRC, crc32(meta->hdr, ss));
+ error = g_write_data(cp, lba * ss, meta->hdr, ss);
+ if (error != 0) {
+err:
+ G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).",
+ pp->name, error);
+ if (lba != alba)
+ goto done;
+ }
+ if (lba == alba) {
+ lba = plba;
+ goto next;
+ }
+
+ size = GET32(meta, hdr->cd_length) * ss;
+ SET32(meta, cdr->CRC, 0xffffffff);
+ SET32(meta, cdr->CRC, crc32(meta->cdr, size));
+ error = g_write_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
+ meta->cdr, size);
+ if (error != 0)
+ goto err;
+
+ size = GET32(meta, hdr->pdr_length) * ss;
+ SET32(meta, pdr->CRC, 0xffffffff);
+ SET32(meta, pdr->CRC, crc32(meta->pdr, size));
+ error = g_write_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
+ meta->pdr, size);
+ if (error != 0)
+ goto err;
+
+ size = GET32(meta, hdr->vdr_length) * ss;
+ SET32(meta, vdr->CRC, 0xffffffff);
+ SET32(meta, vdr->CRC, crc32(meta->vdr, size));
+ error = g_write_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
+ meta->vdr, size);
+ if (error != 0)
+ goto err;
+
+ size = GET16(meta, hdr->Configuration_Record_Length);
+ num = GET32(meta, hdr->cr_length) / size;
+ size *= ss;
+ for (i = 0; i < num; i++) {
+ vdc = (struct ddf_vdc_record *)((uint8_t *)meta->cr + i * size);
+ SET32D(meta, vdc->CRC, 0xffffffff);
+ SET32D(meta, vdc->CRC, crc32(vdc, size));
+ }
+ error = g_write_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
+ meta->cr, size * num);
+ if (error != 0)
+ goto err;
+
+ size = GET32(meta, hdr->pdd_length) * ss;
+ SET32(meta, pdd->CRC, 0xffffffff);
+ SET32(meta, pdd->CRC, crc32(meta->pdd, size));
+ error = g_write_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
+ meta->pdd, size);
+ if (error != 0)
+ goto err;
+
+ if (GET32(meta, hdr->bbmlog_length) != 0) {
+ size = GET32(meta, hdr->bbmlog_length) * ss;
+ SET32(meta, bbm->CRC, 0xffffffff);
+ SET32(meta, bbm->CRC, crc32(meta->bbm, size));
+ error = g_write_data(cp,
+ (lba + GET32(meta, hdr->bbmlog_section)) * ss,
+ meta->bbm, size);
+ if (error != 0)
+ goto err;
+ }
+
+done:
+ if (lba == plba && slba != -1) {
+ lba = slba;
+ goto next;
+ }
+
+ return (error);
+}
+
+static int
+ddf_meta_erase(struct g_consumer *cp)
+{
+ struct g_provider *pp;
+ char *buf;
+ int error;
+
+ pp = cp->provider;
+ buf = malloc(pp->sectorsize, M_MD_DDF, M_WAITOK | M_ZERO);
+ error = g_write_data(cp, pp->mediasize - pp->sectorsize,
+ buf, pp->sectorsize);
+ if (error != 0) {
+ G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).",
+ pp->name, error);
+ }
+ free(buf, M_MD_DDF);
+ return (error);
+}
+
+#if 0
+static int
+ddf_meta_write_spare(struct g_consumer *cp)
+{
+ struct ddf_header *meta;
+ int error;
+
+ meta = malloc(sizeof(*meta), M_MD_DDF, M_WAITOK | M_ZERO);
+ memcpy(&meta->ddf_id[0], DDF_MAGIC, sizeof(DDF_MAGIC) - 1);
+ meta->dummy_0 = 0x00020000;
+ meta->integrity = DDF_I_VALID;
+ meta->disk.flags = DDF_F_SPARE | DDF_F_ONLINE | DDF_F_VALID;
+ meta->disk.number = 0xff;
+ arc4rand(&meta->disk.id, sizeof(meta->disk.id), 0);
+ meta->disk_sectors = cp->provider->mediasize / cp->provider->sectorsize;
+ meta->disk_sectors -= 131072;
+ meta->rebuild_lba = UINT32_MAX;
+ error = ddf_meta_write(cp, &meta, 1);
+ free(meta, M_MD_DDF);
+ return (error);
+}
+#endif
+
+static struct g_raid_volume *
+g_raid_md_ddf_get_volume(struct g_raid_softc *sc, uint8_t *GUID)
+{
+ struct g_raid_volume *vol;
+ struct g_raid_md_ddf_pervolume *pv;
+
+ TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
+ pv = vol->v_md_data;
+ if (memcmp(pv->pv_meta.vde->VD_GUID, GUID, 24) == 0)
+ break;
+ }
+ return (vol);
+}
+
+static struct g_raid_disk *
+g_raid_md_ddf_get_disk(struct g_raid_softc *sc, uint8_t *GUID, uint32_t id)
+{
+ struct g_raid_disk *disk;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct ddf_meta *meta;
+
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ meta = &pd->pd_meta;
+ if (GUID != NULL) {
+ if (memcmp(meta->pdd->PD_GUID, GUID, 24) == 0)
+ break;
+ } else {
+ if (GET32(meta, pdd->PD_Reference) == id)
+ break;
+ }
+ }
+ return (disk);
+}
+
+static int
+g_raid_md_ddf_purge_volumes(struct g_raid_softc *sc)
+{
+ struct g_raid_volume *vol, *tvol;
+ struct g_raid_md_ddf_pervolume *pv;
+ int i, res;
+
+ res = 0;
+ TAILQ_FOREACH_SAFE(vol, &sc->sc_volumes, v_next, tvol) {
+ pv = vol->v_md_data;
+ if (vol->v_stopping)
+ continue;
+ for (i = 0; i < vol->v_disks_count; i++) {
+ if (vol->v_subdisks[i].sd_state != G_RAID_SUBDISK_S_NONE)
+ break;
+ }
+ if (i >= vol->v_disks_count) {
+ g_raid_destroy_volume(vol);
+ res = 1;
+ }
+ }
+ return (res);
+}
+
+static int
+g_raid_md_ddf_purge_disks(struct g_raid_softc *sc)
+{
+#if 0
+ struct g_raid_disk *disk, *tdisk;
+ struct g_raid_volume *vol;
+ struct g_raid_md_ddf_perdisk *pd;
+ int i, j, res;
+
+ res = 0;
+ TAILQ_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) {
+ if (disk->d_state == G_RAID_DISK_S_SPARE)
+ continue;
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+
+ /* Scan for deleted volumes. */
+ for (i = 0; i < pd->pd_subdisks; ) {
+ vol = g_raid_md_ddf_get_volume(sc,
+ pd->pd_meta[i]->volume_id);
+ if (vol != NULL && !vol->v_stopping) {
+ i++;
+ continue;
+ }
+ free(pd->pd_meta[i], M_MD_DDF);
+ for (j = i; j < pd->pd_subdisks - 1; j++)
+ pd->pd_meta[j] = pd->pd_meta[j + 1];
+ pd->pd_meta[DDF_MAX_SUBDISKS - 1] = NULL;
+ pd->pd_subdisks--;
+ pd->pd_updated = 1;
+ }
+
+ /* If there is no metadata left - erase and delete disk. */
+ if (pd->pd_subdisks == 0) {
+ ddf_meta_erase(disk->d_consumer);
+ g_raid_destroy_disk(disk);
+ res = 1;
+ }
+ }
+ return (res);
+#endif
+ return (0);
+}
+
+static int
+g_raid_md_ddf_supported(int level, int qual, int disks, int force)
+{
+
+ if (disks > DDF_MAX_DISKS_HARD)
+ return (0);
+ switch (level) {
+ case G_RAID_VOLUME_RL_RAID0:
+ if (qual != G_RAID_VOLUME_RLQ_NONE)
+ return (0);
+ if (disks < 1)
+ return (0);
+ if (!force && disks < 2)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID1:
+ if (disks < 1)
+ return (0);
+ if (qual == G_RAID_VOLUME_RLQ_R1SM) {
+ if (!force && disks != 2)
+ return (0);
+ } else if (qual == G_RAID_VOLUME_RLQ_R1MM) {
+ if (!force && disks != 3)
+ return (0);
+ } else
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID3:
+ if (qual != G_RAID_VOLUME_RLQ_R3P0 &&
+ qual != G_RAID_VOLUME_RLQ_R3PN)
+ return (0);
+ if (disks < 3)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID4:
+ if (qual != G_RAID_VOLUME_RLQ_R4P0 &&
+ qual != G_RAID_VOLUME_RLQ_R4PN)
+ return (0);
+ if (disks < 3)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID5:
+ if (qual != G_RAID_VOLUME_RLQ_R5RA &&
+ qual != G_RAID_VOLUME_RLQ_R5RS &&
+ qual != G_RAID_VOLUME_RLQ_R5LA &&
+ qual != G_RAID_VOLUME_RLQ_R5LS)
+ return (0);
+ if (disks < 3)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID6:
+ if (qual != G_RAID_VOLUME_RLQ_R6RA &&
+ qual != G_RAID_VOLUME_RLQ_R6RS &&
+ qual != G_RAID_VOLUME_RLQ_R6LA &&
+ qual != G_RAID_VOLUME_RLQ_R6LS)
+ return (0);
+ if (disks < 4)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAIDMDF:
+ if (qual != G_RAID_VOLUME_RLQ_RMDFRA &&
+ qual != G_RAID_VOLUME_RLQ_RMDFRS &&
+ qual != G_RAID_VOLUME_RLQ_RMDFLA &&
+ qual != G_RAID_VOLUME_RLQ_RMDFLS)
+ return (0);
+ if (disks < 5)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID1E:
+ if (qual != G_RAID_VOLUME_RLQ_R1EA &&
+ qual != G_RAID_VOLUME_RLQ_R1EO)
+ return (0);
+ if (disks < 2)
+ return (0);
+ if (disks % 2 != 0)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_SINGLE:
+ if (qual != G_RAID_VOLUME_RLQ_NONE)
+ return (0);
+ if (disks != 1)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_CONCAT:
+ if (qual != G_RAID_VOLUME_RLQ_NONE)
+ return (0);
+ if (disks < 2)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID5E:
+ if (qual != G_RAID_VOLUME_RLQ_R5ERA &&
+ qual != G_RAID_VOLUME_RLQ_R5ERS &&
+ qual != G_RAID_VOLUME_RLQ_R5ELA &&
+ qual != G_RAID_VOLUME_RLQ_R5ELS)
+ return (0);
+ if (disks < 4)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID5EE:
+ if (qual != G_RAID_VOLUME_RLQ_R5EERA &&
+ qual != G_RAID_VOLUME_RLQ_R5EERS &&
+ qual != G_RAID_VOLUME_RLQ_R5EELA &&
+ qual != G_RAID_VOLUME_RLQ_R5EELS)
+ return (0);
+ if (disks < 4)
+ return (0);
+ break;
+ case G_RAID_VOLUME_RL_RAID5R:
+ if (qual != G_RAID_VOLUME_RLQ_R5RRA &&
+ qual != G_RAID_VOLUME_RLQ_R5RRS &&
+ qual != G_RAID_VOLUME_RLQ_R5RLA &&
+ qual != G_RAID_VOLUME_RLQ_R5RLS)
+ return (0);
+ if (disks < 3)
+ return (0);
+ break;
+ default:
+ return (0);
+ }
+ return (1);
+}
+
+static int
+g_raid_md_ddf_start_disk(struct g_raid_disk *disk, struct g_raid_volume *vol)
+{
+ struct g_raid_softc *sc;
+ struct g_raid_subdisk *sd;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_raid_md_ddf_pervolume *pv;
+ struct g_raid_md_ddf_object *mdi;
+ struct ddf_vol_meta *vmeta;
+ struct ddf_meta *pdmeta, *gmeta;
+ struct ddf_vdc_record *vdc1;
+ off_t size, eoff = 0, esize = 0;
+ uint64_t *val2;
+ int disk_pos, md_disk_bvd = -1, md_disk_pos = -1, md_pde_pos;
+ int i, resurrection = 0;
+ uint32_t reference;
+
+ sc = disk->d_softc;
+ mdi = (struct g_raid_md_ddf_object *)sc->sc_md;
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ pdmeta = &pd->pd_meta;
+ reference = GET32(&pd->pd_meta, pdd->PD_Reference);
+
+ pv = vol->v_md_data;
+ vmeta = &pv->pv_meta;
+ gmeta = &mdi->mdio_meta;
+
+ /* Find disk position in metadata by it's reference. */
+ disk_pos = ddf_meta_find_disk(vmeta, reference,
+ &md_disk_bvd, &md_disk_pos);
+ md_pde_pos = ddf_meta_find_pd(gmeta, NULL, reference);
+
+ if (disk_pos < 0) {
+ G_RAID_DEBUG1(1, sc, "Disk %s is not part of the volume %s",
+ g_raid_get_diskname(disk), vol->v_name);
+
+ /* Failed stale disk is useless for us. */
+ if ((GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) != 0) {
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED);
+ return (0);
+ }
+
+ /* If disk has some metadata for this volume - erase. */
+ if (pdmeta->cr != NULL &&
+ (vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL) {
+ SET32D(pdmeta, vdc1->Signature, 0xffffffff);
+ }
+
+ /* If we are in the start process, that's all for now. */
+ if (!pv->pv_started)
+ goto nofit;
+ /*
+ * If we have already started - try to get use of the disk.
+ * Try to replace OFFLINE disks first, then FAILED.
+ */
+ if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >=
+ GET16(&pd->pd_meta, hdr->Max_Partitions)) {
+ G_RAID_DEBUG1(1, sc, "No free partitions on disk %s",
+ g_raid_get_diskname(disk));
+ goto nofit;
+ }
+ ddf_meta_unused_range(&pd->pd_meta, &eoff, &esize);
+ if (esize == 0) {
+ G_RAID_DEBUG1(1, sc, "No free space on disk %s",
+ g_raid_get_diskname(disk));
+ goto nofit;
+ }
+ size = INT64_MAX;
+ for (i = 0; i < vol->v_disks_count; i++) {
+ sd = &vol->v_subdisks[i];
+ if (sd->sd_state != G_RAID_SUBDISK_S_NONE)
+ size = sd->sd_size;
+ if (sd->sd_state <= G_RAID_SUBDISK_S_FAILED &&
+ (disk_pos < 0 ||
+ vol->v_subdisks[i].sd_state < sd->sd_state))
+ disk_pos = i;
+ }
+ if (disk_pos >= 0 &&
+ vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT &&
+ (off_t)esize * 512 < size) {
+ G_RAID_DEBUG1(1, sc, "Disk %s free space "
+ "is too small (%ju < %ju)",
+ g_raid_get_diskname(disk),
+ (off_t)esize * 512, size);
+ disk_pos = -1;
+ }
+ if (disk_pos >= 0) {
+ if (vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT)
+ esize = size / 512;
+ md_disk_bvd = disk_pos / GET16(vmeta, vdc->Primary_Element_Count); // XXX
+ md_disk_pos = disk_pos % GET16(vmeta, vdc->Primary_Element_Count); // XXX
+ } else {
+nofit:
+ if (ddf_meta_count_vdc(&pd->pd_meta, NULL) == 0) {
+ g_raid_change_disk_state(disk,
+ G_RAID_DISK_S_SPARE);
+ }
+ return (0);
+ }
+ G_RAID_DEBUG1(1, sc, "Disk %s takes pos %d in the volume %s",
+ g_raid_get_diskname(disk), disk_pos, vol->v_name);
+ resurrection = 1;
+ }
+
+ sd = &vol->v_subdisks[disk_pos];
+
+ if (resurrection && sd->sd_disk != NULL) {
+ g_raid_change_disk_state(sd->sd_disk,
+ G_RAID_DISK_S_STALE_FAILED);
+ TAILQ_REMOVE(&sd->sd_disk->d_subdisks,
+ sd, sd_next);
+ }
+ vol->v_subdisks[disk_pos].sd_disk = disk;
+ TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
+
+ /* Welcome the new disk. */
+ if (resurrection)
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
+ else if (GET8(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA)
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED);
+ else
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
+
+ if (resurrection) {
+ sd->sd_offset = (off_t)eoff * 512;
+ sd->sd_size = (off_t)esize * 512;
+ } else if (pdmeta->cr != NULL &&
+ (vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL) {
+ val2 = (uint64_t *)&(vdc1->Physical_Disk_Sequence[GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
+ sd->sd_offset = (off_t)GET64P(pdmeta, val2 + md_disk_pos) * 512;
+ sd->sd_size = (off_t)GET64D(pdmeta, vdc1->Block_Count) * 512;
+ }
+
+ if (resurrection) {
+ /* Stale disk, almost same as new. */
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_NEW);
+ } else if (GET8(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) {
+ /* Failed disk. */
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_FAILED);
+ } else if ((GET8(gmeta, pdr->entry[md_pde_pos].PD_State) &
+ (DDF_PDE_FAILED | DDF_PDE_REBUILD)) != 0) {
+ /* Rebuilding disk. */
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_REBUILD);
+ sd->sd_rebuild_pos = 0;
+ } else if ((GET8(vmeta, vde->VD_State) & DDF_VDE_DIRTY) != 0 ||
+ (GET8(vmeta, vde->Init_State) & DDF_VDE_INIT_MASK) !=
+ DDF_VDE_INIT_FULL) {
+ /* Stale disk or dirty volume (unclean shutdown). */
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_STALE);
+ } else {
+ /* Up to date disk. */
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_ACTIVE);
+ }
+ g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
+ G_RAID_EVENT_SUBDISK);
+
+ return (resurrection);
+}
+
+static void
+g_raid_md_ddf_refill(struct g_raid_softc *sc)
+{
+ struct g_raid_volume *vol;
+ struct g_raid_subdisk *sd;
+ struct g_raid_disk *disk;
+ struct g_raid_md_object *md;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_raid_md_ddf_pervolume *pv;
+ int update, updated, i, bad;
+
+ md = sc->sc_md;
+restart:
+ updated = 0;
+ TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
+ pv = vol->v_md_data;
+ if (!pv->pv_started || vol->v_stopping)
+ continue;
+
+ /* Search for subdisk that needs replacement. */
+ bad = 0;
+ for (i = 0; i < vol->v_disks_count; i++) {
+ sd = &vol->v_subdisks[i];
+ if (sd->sd_state == G_RAID_SUBDISK_S_NONE ||
+ sd->sd_state == G_RAID_SUBDISK_S_FAILED)
+ bad = 1;
+ }
+ if (!bad)
+ continue;
+
+ G_RAID_DEBUG1(1, sc, "Volume %s is not complete, "
+ "trying to refill.", vol->v_name);
+
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ /* Skip failed. */
+ if (disk->d_state < G_RAID_DISK_S_SPARE)
+ continue;
+ /* Skip already used by this volume. */
+ for (i = 0; i < vol->v_disks_count; i++) {
+ sd = &vol->v_subdisks[i];
+ if (sd->sd_disk == disk)
+ break;
+ }
+ if (i < vol->v_disks_count)
+ continue;
+
+ /* Try to use disk if it has empty extents. */
+ pd = disk->d_md_data;
+ if (ddf_meta_count_vdc(&pd->pd_meta, NULL) <
+ GET16(&pd->pd_meta, hdr->Max_Partitions)) {
+ update = g_raid_md_ddf_start_disk(disk, vol);
+ } else
+ update = 0;
+ if (update) {
+ updated = 1;
+ g_raid_md_write_ddf(md, vol, NULL, disk);
+ break;
+ }
+ }
+ }
+ if (updated)
+ goto restart;
+}
+
+static void
+g_raid_md_ddf_start(struct g_raid_volume *vol)
+{
+ struct g_raid_softc *sc;
+ struct g_raid_subdisk *sd;
+ struct g_raid_disk *disk;
+ struct g_raid_md_object *md;
+ struct g_raid_md_ddf_pervolume *pv;
+ struct ddf_vol_meta *vmeta;
+ struct ddf_vdc_record *vdc;
+ uint64_t *val2;
+ int i, j, bvd;
+
+ sc = vol->v_softc;
+ md = sc->sc_md;
+ pv = vol->v_md_data;
+ vmeta = &pv->pv_meta;
+ vdc = vmeta->vdc;
+
+ vol->v_raid_level = GET8(vmeta, vdc->Primary_RAID_Level);
+ vol->v_raid_level_qualifier = GET8(vmeta, vdc->RLQ);
+ if (GET8(vmeta, vdc->Secondary_Element_Count) > 1 &&
+ vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 &&
+ GET8(vmeta, vdc->Secondary_RAID_Level) == 0)
+ vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E;
+ vol->v_sectorsize = GET16(vmeta, vdc->Block_Size);
+ if (vol->v_sectorsize == 0xffff)
+ vol->v_sectorsize = vmeta->sectorsize;
+ vol->v_strip_size = vol->v_sectorsize << GET8(vmeta, vdc->Stripe_Size);
+ vol->v_disks_count = GET16(vmeta, vdc->Primary_Element_Count) *
+ GET8(vmeta, vdc->Secondary_Element_Count);
+ vol->v_mediasize = GET64(vmeta, vdc->VD_Size) * vol->v_sectorsize;
+ for (i = 0, j = 0, bvd = 0; i < vol->v_disks_count; i++, j++) {
+ if (j == GET16(vmeta, vdc->Primary_Element_Count)) {
+ j = 0;
+ bvd++;
+ }
+ sd = &vol->v_subdisks[i];
+ if (vmeta->bvdc[bvd] == NULL) {
+ sd->sd_offset = 0;
+ sd->sd_size = GET64(vmeta, vdc->Block_Count) *
+ vol->v_sectorsize;
+ continue;
+ }
+ val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[
+ GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
+ sd->sd_offset = GET64P(vmeta, val2 + j) * vol->v_sectorsize;
+ sd->sd_size = GET64(vmeta, bvdc[bvd]->Block_Count) *
+ vol->v_sectorsize;
+ }
+ g_raid_start_volume(vol);
+
+ /* Make all disks found till the moment take their places. */
+ for (i = 0, j = 0, bvd = 0; i < vol->v_disks_count; i++, j++) {
+ if (j == GET16(vmeta, vdc->Primary_Element_Count)) {
+ j = 0;
+ bvd++;
+ }
+ if (vmeta->bvdc[bvd] == NULL)
+ continue;
+ disk = g_raid_md_ddf_get_disk(sc, NULL,
+ GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[j]));
+ if (disk != NULL)
+ g_raid_md_ddf_start_disk(disk, vol);
+ }
+
+ pv->pv_started = 1;
+ callout_stop(&pv->pv_start_co);
+ G_RAID_DEBUG1(0, sc, "Volume started.");
+ g_raid_md_write_ddf(md, vol, NULL, NULL);
+
+ /* Pickup any STALE/SPARE disks to refill array if needed. */
+ g_raid_md_ddf_refill(sc);
+
+ g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME);
+}
+
+static void
+g_raid_ddf_go(void *arg)
+{
+ struct g_raid_volume *vol;
+ struct g_raid_softc *sc;
+ struct g_raid_md_ddf_pervolume *pv;
+
+ vol = arg;
+ pv = vol->v_md_data;
+ sc = vol->v_softc;
+ if (!pv->pv_started) {
+ G_RAID_DEBUG1(0, sc, "Force volume start due to timeout.");
+ g_raid_event_send(vol, G_RAID_VOLUME_E_STARTMD,
+ G_RAID_EVENT_VOLUME);
+ }
+}
+
+static void
+g_raid_md_ddf_new_disk(struct g_raid_disk *disk)
+{
+ struct g_raid_softc *sc;
+ struct g_raid_md_object *md;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_raid_md_ddf_pervolume *pv;
+ struct g_raid_md_ddf_object *mdi;
+ struct g_raid_volume *vol;
+ struct ddf_meta *pdmeta;
+ struct ddf_vol_meta *vmeta;
+ struct ddf_vdc_record *vdc;
+ struct ddf_vd_entry *vde;
+ int i, j, k, num, have, need, needthis, cnt, spare;
+ uint32_t val;
+ char buf[17];
+
+ sc = disk->d_softc;
+ md = sc->sc_md;
+ mdi = (struct g_raid_md_ddf_object *)md;
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ pdmeta = &pd->pd_meta;
+ spare = -1;
+
+ if (mdi->mdio_meta.hdr == NULL)
+ ddf_meta_copy(&mdi->mdio_meta, pdmeta);
+ else
+ ddf_meta_update(&mdi->mdio_meta, pdmeta);
+
+ num = GET32(pdmeta, hdr->cr_length) / GET16(pdmeta, hdr->Configuration_Record_Length);
+ for (j = 0; j < num; j++) {
+ vdc = (struct ddf_vdc_record *)((uint8_t *)pdmeta->cr +
+ j * GET16(pdmeta, hdr->Configuration_Record_Length) *
+ pdmeta->sectorsize);
+ val = GET32D(pdmeta, vdc->Signature);
+
+ if (val == DDF_SA_SIGNATURE && spare == -1)
+ spare = 1;
+
+ if (val != DDF_VDCR_SIGNATURE)
+ continue;
+ spare = 0;
+ k = ddf_meta_find_vd(pdmeta, vdc->VD_GUID);
+ if (k < 0)
+ continue;
+ vde = &pdmeta->vdr->entry[k];
+
+ /* Look for volume with matching ID. */
+ vol = g_raid_md_ddf_get_volume(sc, vdc->VD_GUID);
+ if (vol == NULL) {
+ ddf_meta_get_name(pdmeta, k, buf);
+ vol = g_raid_create_volume(sc, buf,
+ GET16D(pdmeta, vde->VD_Number));
+ pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO);
+ vol->v_md_data = pv;
+ callout_init(&pv->pv_start_co, 1);
+ callout_reset(&pv->pv_start_co,
+ g_raid_start_timeout * hz,
+ g_raid_ddf_go, vol);
+ } else
+ pv = vol->v_md_data;
+
+ /* If we haven't started yet - check metadata freshness. */
+ vmeta = &pv->pv_meta;
+ if (vmeta->hdr == NULL || !pv->pv_started)
+ ddf_vol_meta_update(vmeta, pdmeta, vdc->VD_GUID);
+ }
+
+ if (spare == 1) {
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
+ g_raid_md_ddf_refill(sc);
+ }
+
+ TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
+ pv = vol->v_md_data;
+ vmeta = &pv->pv_meta;
+
+ /* If we collected all needed disks - start array. */
+ need = 0;
+ needthis = 0;
+ have = 0;
+ for (k = 0; k < GET8(vmeta, vdc->Secondary_Element_Count); k++) {
+ if (vmeta->bvdc[k] == NULL) {
+ need += GET16(vmeta, vdc->Primary_Element_Count);
+ continue;
+ }
+ cnt = GET16(vmeta, bvdc[k]->Primary_Element_Count);
+ need += cnt;
+ for (i = 0; i < cnt; i++) {
+ val = GET32(vmeta, bvdc[k]->Physical_Disk_Sequence[i]);
+ if (GET32(pdmeta, pdd->PD_Reference) == val)
+ needthis++;
+ else if (g_raid_md_ddf_get_disk(sc, NULL, val) != NULL)
+ have++;
+ }
+ }
+ if (!needthis)
+ continue;
+ if (pv->pv_started) {
+ if (g_raid_md_ddf_start_disk(disk, vol))
+ g_raid_md_write_ddf(md, vol, NULL, NULL);
+ } else {
+ G_RAID_DEBUG1(1, sc, "Volume %s now has %d of %d disks",
+ vol->v_name, have + needthis, need);
+ if (have + needthis == need)
+ g_raid_md_ddf_start(vol);
+ }
+ }
+}
+
+static int
+g_raid_md_create_ddf(struct g_raid_md_object *md, struct g_class *mp,
+ struct g_geom **gp)
+{
+ struct g_geom *geom;
+ struct g_raid_softc *sc;
+
+ /* Search for existing node. */
+ LIST_FOREACH(geom, &mp->geom, geom) {
+ sc = geom->softc;
+ if (sc == NULL)
+ continue;
+ if (sc->sc_stopping != 0)
+ continue;
+ if (sc->sc_md->mdo_class != md->mdo_class)
+ continue;
+ break;
+ }
+ if (geom != NULL) {
+ *gp = geom;
+ return (G_RAID_MD_TASTE_EXISTING);
+ }
+
+ /* Create new one if not found. */
+ sc = g_raid_create_node(mp, "DDF", md);
+ if (sc == NULL)
+ return (G_RAID_MD_TASTE_FAIL);
+ md->mdo_softc = sc;
+ *gp = sc->sc_geom;
+ return (G_RAID_MD_TASTE_NEW);
+}
+
+static int
+g_raid_md_taste_ddf(struct g_raid_md_object *md, struct g_class *mp,
+ struct g_consumer *cp, struct g_geom **gp)
+{
+ struct g_consumer *rcp;
+ struct g_provider *pp;
+ struct g_raid_softc *sc;
+ struct g_raid_disk *disk;
+ struct ddf_meta meta;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_geom *geom;
+ int error, result, len;
+ char name[16];
+
+ G_RAID_DEBUG(1, "Tasting DDF on %s", cp->provider->name);
+ pp = cp->provider;
+
+ /* Read metadata from device. */
+ if (g_access(cp, 1, 0, 0) != 0)
+ return (G_RAID_MD_TASTE_FAIL);
+ g_topology_unlock();
+ bzero(&meta, sizeof(meta));
+ error = ddf_meta_read(cp, &meta);
+ g_topology_lock();
+ g_access(cp, -1, 0, 0);
+ if (error != 0)
+ return (G_RAID_MD_TASTE_FAIL);
+
+ /* Metadata valid. Print it. */
+ g_raid_md_ddf_print(&meta);
+
+ /* Search for matching node. */
+ sc = NULL;
+ LIST_FOREACH(geom, &mp->geom, geom) {
+ sc = geom->softc;
+ if (sc == NULL)
+ continue;
+ if (sc->sc_stopping != 0)
+ continue;
+ if (sc->sc_md->mdo_class != md->mdo_class)
+ continue;
+ break;
+ }
+
+ /* Found matching node. */
+ if (geom != NULL) {
+ G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name);
+ result = G_RAID_MD_TASTE_EXISTING;
+
+ } else { /* Not found matching node -- create one. */
+ result = G_RAID_MD_TASTE_NEW;
+ snprintf(name, sizeof(name), "DDF");
+ sc = g_raid_create_node(mp, name, md);
+ md->mdo_softc = sc;
+ geom = sc->sc_geom;
+ }
+
+ rcp = g_new_consumer(geom);
+ g_attach(rcp, pp);
+ if (g_access(rcp, 1, 1, 1) != 0)
+ ; //goto fail1;
+
+ g_topology_unlock();
+ sx_xlock(&sc->sc_lock);
+
+ pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
+ pd->pd_meta = meta;
+ disk = g_raid_create_disk(sc);
+ disk->d_md_data = (void *)pd;
+ disk->d_consumer = rcp;
+ rcp->private = disk;
+
+ /* Read kernel dumping information. */
+ disk->d_kd.offset = 0;
+ disk->d_kd.length = OFF_MAX;
+ len = sizeof(disk->d_kd);
+ error = g_io_getattr("GEOM::kerneldump", rcp, &len, &disk->d_kd);
+ if (disk->d_kd.di.dumper == NULL)
+ G_RAID_DEBUG1(2, sc, "Dumping not supported by %s: %d.",
+ rcp->provider->name, error);
+
+ g_raid_md_ddf_new_disk(disk);
+
+ sx_xunlock(&sc->sc_lock);
+ g_topology_lock();
+ *gp = geom;
+ return (result);
+}
+
+static int
+g_raid_md_event_ddf(struct g_raid_md_object *md,
+ struct g_raid_disk *disk, u_int event)
+{
+ struct g_raid_softc *sc;
+
+ sc = md->mdo_softc;
+ if (disk == NULL)
+ return (-1);
+ switch (event) {
+ case G_RAID_DISK_E_DISCONNECTED:
+ /* Delete disk. */
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
+ g_raid_destroy_disk(disk);
+ g_raid_md_ddf_purge_volumes(sc);
+
+ /* Write updated metadata to all disks. */
+ g_raid_md_write_ddf(md, NULL, NULL, NULL);
+
+ /* Check if anything left. */
+ if (g_raid_ndisks(sc, -1) == 0)
+ g_raid_destroy_node(sc, 0);
+ else
+ g_raid_md_ddf_refill(sc);
+ return (0);
+ }
+ return (-2);
+}
+
+static int
+g_raid_md_volume_event_ddf(struct g_raid_md_object *md,
+ struct g_raid_volume *vol, u_int event)
+{
+ struct g_raid_md_ddf_pervolume *pv;
+
+ pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
+ switch (event) {
+ case G_RAID_VOLUME_E_STARTMD:
+ if (!pv->pv_started)
+ g_raid_md_ddf_start(vol);
+ return (0);
+ }
+ return (-2);
+}
+
+static int
+g_raid_md_ctl_ddf(struct g_raid_md_object *md,
+ struct gctl_req *req)
+{
+ struct g_raid_softc *sc;
+ struct g_raid_volume *vol, *vol1;
+ struct g_raid_subdisk *sd;
+ struct g_raid_disk *disk, *disks[DDF_MAX_DISKS_HARD];
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_raid_md_ddf_pervolume *pv;
+ struct g_raid_md_ddf_object *mdi;
+ struct g_consumer *cp;
+ struct g_provider *pp;
+ char arg[16];
+ const char *verb, *volname, *levelname, *diskname;
+ char *tmp;
+ int *nargs, *force;
+ off_t size, sectorsize, strip, offs[DDF_MAX_DISKS_HARD], esize;
+ intmax_t *sizearg, *striparg;
+ int i, numdisks, len, level, qual;
+ int error;
+
+ sc = md->mdo_softc;
+ mdi = (struct g_raid_md_ddf_object *)md;
+ verb = gctl_get_param(req, "verb", NULL);
+ nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
+ error = 0;
+
+ if (strcmp(verb, "label") == 0) {
+
+ if (*nargs < 4) {
+ gctl_error(req, "Invalid number of arguments.");
+ return (-1);
+ }
+ volname = gctl_get_asciiparam(req, "arg1");
+ if (volname == NULL) {
+ gctl_error(req, "No volume name.");
+ return (-2);
+ }
+ levelname = gctl_get_asciiparam(req, "arg2");
+ if (levelname == NULL) {
+ gctl_error(req, "No RAID level.");
+ return (-3);
+ }
+ if (g_raid_volume_str2level(levelname, &level, &qual)) {
+ gctl_error(req, "Unknown RAID level '%s'.", levelname);
+ return (-4);
+ }
+ numdisks = *nargs - 3;
+ force = gctl_get_paraml(req, "force", sizeof(*force));
+ if (!g_raid_md_ddf_supported(level, qual, numdisks,
+ force ? *force : 0)) {
+ gctl_error(req, "Unsupported RAID level "
+ "(0x%02x/0x%02x), or number of disks (%d).",
+ level, qual, numdisks);
+ return (-5);
+ }
+
+ /* Search for disks, connect them and probe. */
+ size = INT64_MAX;
+ sectorsize = 0;
+ bzero(disks, sizeof(disks));
+ bzero(offs, sizeof(offs));
+ for (i = 0; i < numdisks; i++) {
+ snprintf(arg, sizeof(arg), "arg%d", i + 3);
+ diskname = gctl_get_asciiparam(req, arg);
+ if (diskname == NULL) {
+ gctl_error(req, "No disk name (%s).", arg);
+ error = -6;
+ break;
+ }
+ if (strcmp(diskname, "NONE") == 0)
+ continue;
+
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ if (disk->d_consumer != NULL &&
+ disk->d_consumer->provider != NULL &&
+ strcmp(disk->d_consumer->provider->name,
+ diskname) == 0)
+ break;
+ }
+ if (disk != NULL) {
+ if (disk->d_state != G_RAID_DISK_S_ACTIVE) {
+ gctl_error(req, "Disk '%s' is in a "
+ "wrong state (%s).", diskname,
+ g_raid_disk_state2str(disk->d_state));
+ error = -7;
+ break;
+ }
+ pd = disk->d_md_data;
+ if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >=
+ GET16(&pd->pd_meta, hdr->Max_Partitions)) {
+ gctl_error(req, "No free partitions "
+ "on disk '%s'.",
+ diskname);
+ error = -7;
+ break;
+ }
+ pp = disk->d_consumer->provider;
+ disks[i] = disk;
+ ddf_meta_unused_range(&pd->pd_meta,
+ &offs[i], &esize);
+ size = MIN(size, (off_t)esize * pp->sectorsize);
+ sectorsize = MAX(sectorsize, pp->sectorsize);
+ continue;
+ }
+
+ g_topology_lock();
+ cp = g_raid_open_consumer(sc, diskname);
+ if (cp == NULL) {
+ gctl_error(req, "Can't open disk '%s'.",
+ diskname);
+ g_topology_unlock();
+ error = -8;
+ break;
+ }
+ pp = cp->provider;
+ pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
+ disk = g_raid_create_disk(sc);
+ disk->d_md_data = (void *)pd;
+ disk->d_consumer = cp;
+ disks[i] = disk;
+ cp->private = disk;
+ ddf_meta_create(disk, &mdi->mdio_meta);
+ if (mdi->mdio_meta.hdr == NULL)
+ ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta);
+ else
+ ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta);
+ g_topology_unlock();
+
+ /* Read kernel dumping information. */
+ disk->d_kd.offset = 0;
+ disk->d_kd.length = OFF_MAX;
+ len = sizeof(disk->d_kd);
+ g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd);
+ if (disk->d_kd.di.dumper == NULL)
+ G_RAID_DEBUG1(2, sc,
+ "Dumping not supported by %s.",
+ cp->provider->name);
+
+ /* Reserve some space for metadata. */
+ size = MIN(size, pp->mediasize - 131072llu * pp->sectorsize);
+ sectorsize = MAX(sectorsize, pp->sectorsize);
+ }
+ if (error != 0) {
+ for (i = 0; i < numdisks; i++) {
+ if (disks[i] != NULL &&
+ disks[i]->d_state == G_RAID_DISK_S_NONE)
+ g_raid_destroy_disk(disks[i]);
+ }
+ return (error);
+ }
+
+ if (sectorsize <= 0) {
+ gctl_error(req, "Can't get sector size.");
+ return (-8);
+ }
+
+ /* Handle size argument. */
+ len = sizeof(*sizearg);
+ sizearg = gctl_get_param(req, "size", &len);
+ if (sizearg != NULL && len == sizeof(*sizearg) &&
+ *sizearg > 0) {
+ if (*sizearg > size) {
+ gctl_error(req, "Size too big %lld > %lld.",
+ (long long)*sizearg, (long long)size);
+ return (-9);
+ }
+ size = *sizearg;
+ }
+
+ /* Handle strip argument. */
+ strip = 131072;
+ len = sizeof(*striparg);
+ striparg = gctl_get_param(req, "strip", &len);
+ if (striparg != NULL && len == sizeof(*striparg) &&
+ *striparg > 0) {
+ if (*striparg < sectorsize) {
+ gctl_error(req, "Strip size too small.");
+ return (-10);
+ }
+ if (*striparg % sectorsize != 0) {
+ gctl_error(req, "Incorrect strip size.");
+ return (-11);
+ }
+ strip = *striparg;
+ }
+
+ /* Round size down to strip or sector. */
+ if (level == G_RAID_VOLUME_RL_RAID1 ||
+ level == G_RAID_VOLUME_RL_RAID3 ||
+ level == G_RAID_VOLUME_RL_SINGLE ||
+ level == G_RAID_VOLUME_RL_CONCAT)
+ size -= (size % sectorsize);
+ else if (level == G_RAID_VOLUME_RL_RAID1E &&
+ (numdisks & 1) != 0)
+ size -= (size % (2 * strip));
+ else
+ size -= (size % strip);
+ if (size <= 0) {
+ gctl_error(req, "Size too small.");
+ return (-13);
+ }
+
+ /* We have all we need, create things: volume, ... */
+ pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO);
+ ddf_vol_meta_create(&pv->pv_meta, &mdi->mdio_meta);
+ pv->pv_started = 1;
+ vol = g_raid_create_volume(sc, volname, -1);
+ vol->v_md_data = pv;
+ vol->v_raid_level = level;
+ vol->v_raid_level_qualifier = qual;
+ vol->v_strip_size = strip;
+ vol->v_disks_count = numdisks;
+ if (level == G_RAID_VOLUME_RL_RAID0 ||
+ level == G_RAID_VOLUME_RL_CONCAT ||
+ level == G_RAID_VOLUME_RL_SINGLE)
+ vol->v_mediasize = size * numdisks;
+ else if (level == G_RAID_VOLUME_RL_RAID1)
+ vol->v_mediasize = size;
+ else if (level == G_RAID_VOLUME_RL_RAID3 ||
+ level == G_RAID_VOLUME_RL_RAID4 ||
+ level == G_RAID_VOLUME_RL_RAID5 ||
+ level == G_RAID_VOLUME_RL_RAID5R)
+ vol->v_mediasize = size * (numdisks - 1);
+ else if (level == G_RAID_VOLUME_RL_RAID6 ||
+ level == G_RAID_VOLUME_RL_RAID5E ||
+ level == G_RAID_VOLUME_RL_RAID5EE)
+ vol->v_mediasize = size * (numdisks - 2);
+ else if (level == G_RAID_VOLUME_RL_RAIDMDF)
+ vol->v_mediasize = size * (numdisks - 3);
+ else { /* RAID1E */
+ vol->v_mediasize = ((size * numdisks) / strip / 2) *
+ strip;
+ }
+ vol->v_sectorsize = sectorsize;
+ g_raid_start_volume(vol);
+
+ /* , and subdisks. */
+ for (i = 0; i < numdisks; i++) {
+ disk = disks[i];
+ sd = &vol->v_subdisks[i];
+ sd->sd_disk = disk;
+ sd->sd_offset = (off_t)offs[i] * 512;
+ sd->sd_size = size;
+ if (disk == NULL)
+ continue;
+ TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
+ g_raid_change_disk_state(disk,
+ G_RAID_DISK_S_ACTIVE);
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_ACTIVE);
+ g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
+ G_RAID_EVENT_SUBDISK);
+ }
+
+ /* Write metadata based on created entities. */
+ G_RAID_DEBUG1(0, sc, "Array started.");
+ g_raid_md_write_ddf(md, vol, NULL, NULL);
+
+ /* Pickup any STALE/SPARE disks to refill array if needed. */
+ g_raid_md_ddf_refill(sc);
+
+ g_raid_event_send(vol, G_RAID_VOLUME_E_START,
+ G_RAID_EVENT_VOLUME);
+ return (0);
+ }
+ if (strcmp(verb, "add") == 0) {
+
+ gctl_error(req, "`add` command is not applicable, "
+ "use `label` instead.");
+ return (-99);
+ }
+ if (strcmp(verb, "delete") == 0) {
+
+ /* Full node destruction. */
+ if (*nargs == 1) {
+ /* Check if some volume is still open. */
+ force = gctl_get_paraml(req, "force", sizeof(*force));
+ if (force != NULL && *force == 0 &&
+ g_raid_nopens(sc) != 0) {
+ gctl_error(req, "Some volume is still open.");
+ return (-4);
+ }
+
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ if (disk->d_consumer)
+ ddf_meta_erase(disk->d_consumer);
+ }
+ g_raid_destroy_node(sc, 0);
+ return (0);
+ }
+
+ /* Destroy specified volume. If it was last - all node. */
+ if (*nargs != 2) {
+ gctl_error(req, "Invalid number of arguments.");
+ return (-1);
+ }
+ volname = gctl_get_asciiparam(req, "arg1");
+ if (volname == NULL) {
+ gctl_error(req, "No volume name.");
+ return (-2);
+ }
+
+ /* Search for volume. */
+ TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
+ if (strcmp(vol->v_name, volname) == 0)
+ break;
+ }
+ if (vol == NULL) {
+ i = strtol(volname, &tmp, 10);
+ if (verb != volname && tmp[0] == 0) {
+ TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
+ if (vol->v_global_id == i)
+ break;
+ }
+ }
+ }
+ if (vol == NULL) {
+ gctl_error(req, "Volume '%s' not found.", volname);
+ return (-3);
+ }
+
+ /* Check if volume is still open. */
+ force = gctl_get_paraml(req, "force", sizeof(*force));
+ if (force != NULL && *force == 0 &&
+ vol->v_provider_open != 0) {
+ gctl_error(req, "Volume is still open.");
+ return (-4);
+ }
+
+ /* Destroy volume and potentially node. */
+ i = 0;
+ TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next)
+ i++;
+ if (i >= 2) {
+ g_raid_destroy_volume(vol);
+ g_raid_md_ddf_purge_disks(sc);
+ g_raid_md_write_ddf(md, NULL, NULL, NULL);
+ } else {
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ if (disk->d_consumer)
+ ddf_meta_erase(disk->d_consumer);
+ }
+ g_raid_destroy_node(sc, 0);
+ }
+ return (0);
+ }
+ if (strcmp(verb, "remove") == 0 ||
+ strcmp(verb, "fail") == 0) {
+ if (*nargs < 2) {
+ gctl_error(req, "Invalid number of arguments.");
+ return (-1);
+ }
+ for (i = 1; i < *nargs; i++) {
+ snprintf(arg, sizeof(arg), "arg%d", i);
+ diskname = gctl_get_asciiparam(req, arg);
+ if (diskname == NULL) {
+ gctl_error(req, "No disk name (%s).", arg);
+ error = -2;
+ break;
+ }
+ if (strncmp(diskname, "/dev/", 5) == 0)
+ diskname += 5;
+
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ if (disk->d_consumer != NULL &&
+ disk->d_consumer->provider != NULL &&
+ strcmp(disk->d_consumer->provider->name,
+ diskname) == 0)
+ break;
+ }
+ if (disk == NULL) {
+ gctl_error(req, "Disk '%s' not found.",
+ diskname);
+ error = -3;
+ break;
+ }
+
+ if (strcmp(verb, "fail") == 0) {
+ g_raid_md_fail_disk_ddf(md, NULL, disk);
+ continue;
+ }
+
+ /* Erase metadata on deleting disk and destroy it. */
+ ddf_meta_erase(disk->d_consumer);
+ g_raid_destroy_disk(disk);
+ }
+ g_raid_md_ddf_purge_volumes(sc);
+
+ /* Write updated metadata to remaining disks. */
+ g_raid_md_write_ddf(md, NULL, NULL, NULL);
+
+ /* Check if anything left. */
+ if (g_raid_ndisks(sc, -1) == 0)
+ g_raid_destroy_node(sc, 0);
+ else
+ g_raid_md_ddf_refill(sc);
+ return (error);
+ }
+ if (strcmp(verb, "insert") == 0) {
+ if (*nargs < 2) {
+ gctl_error(req, "Invalid number of arguments.");
+ return (-1);
+ }
+ for (i = 1; i < *nargs; i++) {
+ /* Get disk name. */
+ snprintf(arg, sizeof(arg), "arg%d", i);
+ diskname = gctl_get_asciiparam(req, arg);
+ if (diskname == NULL) {
+ gctl_error(req, "No disk name (%s).", arg);
+ error = -3;
+ break;
+ }
+
+ /* Try to find provider with specified name. */
+ g_topology_lock();
+ cp = g_raid_open_consumer(sc, diskname);
+ if (cp == NULL) {
+ gctl_error(req, "Can't open disk '%s'.",
+ diskname);
+ g_topology_unlock();
+ error = -4;
+ break;
+ }
+ pp = cp->provider;
+ g_topology_unlock();
+
+ pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
+
+ disk = g_raid_create_disk(sc);
+ disk->d_consumer = cp;
+ disk->d_md_data = (void *)pd;
+ cp->private = disk;
+
+ /* Read kernel dumping information. */
+ disk->d_kd.offset = 0;
+ disk->d_kd.length = OFF_MAX;
+ len = sizeof(disk->d_kd);
+ g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd);
+ if (disk->d_kd.di.dumper == NULL)
+ G_RAID_DEBUG1(2, sc,
+ "Dumping not supported by %s.",
+ cp->provider->name);
+
+ /* Welcome the "new" disk. */
+ g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
+ ddf_meta_create(disk, &mdi->mdio_meta);
+ if (mdi->mdio_meta.hdr == NULL)
+ ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta);
+ else
+ ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta);
+// ddf_meta_write_spare(cp);
+ g_raid_md_ddf_refill(sc);
+ }
+ return (error);
+ }
+ return (-100);
+}
+
+static int
+g_raid_md_write_ddf(struct g_raid_md_object *md, struct g_raid_volume *tvol,
+ struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
+{
+ struct g_raid_softc *sc;
+ struct g_raid_volume *vol;
+ struct g_raid_subdisk *sd;
+ struct g_raid_disk *disk;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_raid_md_ddf_pervolume *pv;
+ struct g_raid_md_ddf_object *mdi;
+ struct ddf_meta *gmeta;
+ struct ddf_vol_meta *vmeta;
+ struct ddf_vdc_record *vdc;
+ uint64_t *val2;
+ int i, j, pos, bvd, size;
+
+ sc = md->mdo_softc;
+ mdi = (struct g_raid_md_ddf_object *)md;
+ gmeta = &mdi->mdio_meta;
+
+ if (sc->sc_stopping == G_RAID_DESTROY_HARD)
+ return (0);
+
+ /* Generate new per-volume metadata for affected volumes. */
+ TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
+ if (vol->v_stopping)
+ continue;
+
+ /* Skip volumes not related to specified targets. */
+ if (tvol != NULL && vol != tvol)
+ continue;
+ if (tsd != NULL && vol != tsd->sd_volume)
+ continue;
+ if (tdisk != NULL) {
+ for (i = 0; i < vol->v_disks_count; i++) {
+ if (vol->v_subdisks[i].sd_disk == tdisk)
+ break;
+ }
+ if (i >= vol->v_disks_count)
+ continue;
+ }
+
+ pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
+ vmeta = &pv->pv_meta;
+
+ SET32(vmeta, vdc->Sequence_Number,
+ GET32(vmeta, vdc->Sequence_Number) + 1);
+ if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E &&
+ vol->v_disks_count % 2 == 0)
+ SET16(vmeta, vdc->Primary_Element_Count, 2);
+ else
+ SET16(vmeta, vdc->Primary_Element_Count,
+ vol->v_disks_count);
+ SET8(vmeta, vdc->Stripe_Size,
+ ffs(vol->v_strip_size / vol->v_sectorsize) - 1);
+ if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E &&
+ vol->v_disks_count % 2 == 0) {
+ SET8(vmeta, vdc->Primary_RAID_Level,
+ DDF_VDCR_RAID1);
+ SET8(vmeta, vdc->RLQ, 0);
+ SET8(vmeta, vdc->Secondary_Element_Count,
+ vol->v_disks_count / 2);
+ SET8(vmeta, vdc->Secondary_RAID_Level, 0);
+ } else {
+ SET8(vmeta, vdc->Primary_RAID_Level,
+ vol->v_raid_level);
+ SET8(vmeta, vdc->RLQ,
+ vol->v_raid_level_qualifier);
+ SET8(vmeta, vdc->Secondary_Element_Count, 1);
+ SET8(vmeta, vdc->Secondary_RAID_Level, 0);
+ }
+ SET8(vmeta, vdc->Secondary_Element_Seq, 0);
+ SET64(vmeta, vdc->Block_Count, 0);
+ SET64(vmeta, vdc->VD_Size, vol->v_mediasize / vol->v_sectorsize);
+ SET16(vmeta, vdc->Block_Size, vol->v_sectorsize);
+
+ SET16(vmeta, vde->VD_Number, vol->v_global_id);
+ if (vol->v_state <= G_RAID_VOLUME_S_BROKEN)
+ SET8(vmeta, vde->VD_State, DDF_VDE_FAILED);
+ else if (vol->v_state <= G_RAID_VOLUME_S_DEGRADED)
+ SET8(vmeta, vde->VD_State, DDF_VDE_DEGRADED);
+ else if (vol->v_state <= G_RAID_VOLUME_S_SUBOPTIMAL)
+ SET8(vmeta, vde->VD_State, DDF_VDE_PARTIAL);
+ else
+ SET8(vmeta, vde->VD_State, DDF_VDE_OPTIMAL);
+ if (vol->v_dirty)
+ SET8(vmeta, vde->VD_State,
+ GET8(vmeta, vde->VD_State) | DDF_VDE_DIRTY);
+ SET8(vmeta, vde->Init_State, DDF_VDE_INIT_FULL); // XXX
+ ddf_meta_put_name(vmeta, vol->v_name);
+
+ for (i = 0; i < vol->v_disks_count; i++) {
+ sd = &vol->v_subdisks[i];
+ disk = sd->sd_disk;
+ if (disk == NULL)
+ continue;
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ bvd = i / GET16(vmeta, vdc->Primary_Element_Count);
+ pos = i % GET16(vmeta, vdc->Primary_Element_Count);
+ if (vmeta->bvdc[bvd] == NULL) {
+ size = GET16(vmeta,
+ hdr->Configuration_Record_Length) *
+ vmeta->sectorsize;
+ vmeta->bvdc[bvd] = malloc(size, M_MD_DDF, M_WAITOK);
+ memcpy(vmeta->bvdc[bvd], vmeta->vdc, size);
+ SET8(vmeta, bvdc[bvd]->Secondary_Element_Seq, bvd);
+ }
+ SET64(vmeta, bvdc[bvd]->Block_Count,
+ sd->sd_size / vol->v_sectorsize);
+ SET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos],
+ GET32(&pd->pd_meta, pdd->PD_Reference));
+ val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[
+ GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
+ SET64P(vmeta, val2 + pos,
+ sd->sd_offset / vol->v_sectorsize);
+
+ j = ddf_meta_find_pd(gmeta, NULL,
+ GET32(&pd->pd_meta, pdd->PD_Reference));
+ if (j < 0)
+ continue;
+ SET32(gmeta, pdr->entry[j].PD_Type,
+ GET32(gmeta, pdr->entry[j].PD_Type) |
+ DDF_PDE_PARTICIPATING);
+ if (sd->sd_state == G_RAID_SUBDISK_S_FAILED)
+ SET32(gmeta, pdr->entry[j].PD_State,
+ GET32(gmeta, pdr->entry[j].PD_State) |
+ DDF_PDE_FAILED | DDF_PDE_PFA);
+ else if (sd->sd_state <= G_RAID_SUBDISK_S_UNINITIALIZED)
+ SET32(gmeta, pdr->entry[j].PD_State,
+ GET32(gmeta, pdr->entry[j].PD_State) |
+ DDF_PDE_FAILED);
+ else if (sd->sd_state < G_RAID_SUBDISK_S_ACTIVE)
+ SET32(gmeta, pdr->entry[j].PD_State,
+ GET32(gmeta, pdr->entry[j].PD_State) |
+ DDF_PDE_FAILED);
+ else
+ SET32(gmeta, pdr->entry[j].PD_State,
+ GET32(gmeta, pdr->entry[j].PD_State) |
+ DDF_PDE_ONLINE);
+ }
+ }
+
+ TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ if (disk->d_state != G_RAID_DISK_S_ACTIVE)
+ continue;
+ memcpy(pd->pd_meta.pdr, gmeta->pdr,
+ GET32(&pd->pd_meta, hdr->pdr_length) *
+ pd->pd_meta.sectorsize);
+ TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
+ vol = sd->sd_volume;
+ pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
+ vmeta = &pv->pv_meta;
+ i = ddf_meta_find_vd(&pd->pd_meta,
+ pv->pv_meta.vde->VD_GUID);
+ if (i < 0)
+ i = ddf_meta_find_vd(&pd->pd_meta, NULL);
+ if (i >= 0)
+ memcpy(&pd->pd_meta.vdr->entry[i],
+ pv->pv_meta.vde,
+ sizeof(struct ddf_vd_entry));
+ vdc = ddf_meta_find_vdc(&pd->pd_meta,
+ pv->pv_meta.vde->VD_GUID);
+ if (vdc == NULL)
+ vdc = ddf_meta_find_vdc(&pd->pd_meta, NULL);
+ if (vdc != NULL) {
+ bvd = sd->sd_pos / GET16(vmeta,
+ vdc->Primary_Element_Count);
+ memcpy(vdc, pv->pv_meta.bvdc[bvd],
+ GET16(&pd->pd_meta,
+ hdr->Configuration_Record_Length) *
+ pd->pd_meta.sectorsize);
+ }
+ }
+ G_RAID_DEBUG(1, "Writing DDF metadata to %s",
+ g_raid_get_diskname(disk));
+ g_raid_md_ddf_print(&pd->pd_meta);
+ ddf_meta_write(disk->d_consumer, &pd->pd_meta);
+ }
+ return (0);
+}
+
+static int
+g_raid_md_fail_disk_ddf(struct g_raid_md_object *md,
+ struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
+{
+ struct g_raid_softc *sc;
+ struct g_raid_md_ddf_perdisk *pd;
+ struct g_raid_subdisk *sd;
+ int i;
+
+ sc = md->mdo_softc;
+ pd = (struct g_raid_md_ddf_perdisk *)tdisk->d_md_data;
+
+ /* We can't fail disk that is not a part of array now. */
+ if (tdisk->d_state != G_RAID_DISK_S_ACTIVE)
+ return (-1);
+
+ /*
+ * Mark disk as failed in metadata and try to write that metadata
+ * to the disk itself to prevent it's later resurrection as STALE.
+ */
+ G_RAID_DEBUG(1, "Writing DDF metadata to %s",
+ g_raid_get_diskname(tdisk));
+ i = ddf_meta_find_pd(&pd->pd_meta, NULL, GET32(&pd->pd_meta, pdd->PD_Reference));
+ SET16(&pd->pd_meta, pdr->entry[i].PD_State, DDF_PDE_FAILED | DDF_PDE_PFA);
+ if (tdisk->d_consumer != NULL)
+ ddf_meta_write(tdisk->d_consumer, &pd->pd_meta);
+
+ /* Change states. */
+ g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED);
+ TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) {
+ g_raid_change_subdisk_state(sd,
+ G_RAID_SUBDISK_S_FAILED);
+ g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED,
+ G_RAID_EVENT_SUBDISK);
+ }
+
+ /* Write updated metadata to remaining disks. */
+ g_raid_md_write_ddf(md, NULL, NULL, tdisk);
+
+ g_raid_md_ddf_refill(sc);
+ return (0);
+}
+
+static int
+g_raid_md_free_disk_ddf(struct g_raid_md_object *md,
+ struct g_raid_disk *disk)
+{
+ struct g_raid_md_ddf_perdisk *pd;
+
+ pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
+ ddf_meta_free(&pd->pd_meta);
+ free(pd, M_MD_DDF);
+ disk->d_md_data = NULL;
+ return (0);
+}
+
+static int
+g_raid_md_free_volume_ddf(struct g_raid_md_object *md,
+ struct g_raid_volume *vol)
+{
+ struct g_raid_md_ddf_pervolume *pv;
+
+ pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
+ ddf_vol_meta_free(&pv->pv_meta);
+ if (!pv->pv_started) {
+ pv->pv_started = 1;
+ callout_stop(&pv->pv_start_co);
+ }
+ return (0);
+}
+
+static int
+g_raid_md_free_ddf(struct g_raid_md_object *md)
+{
+ struct g_raid_md_ddf_object *mdi;
+
+ mdi = (struct g_raid_md_ddf_object *)md;
+ if (!mdi->mdio_started) {
+ mdi->mdio_started = 0;
+ callout_stop(&mdi->mdio_start_co);
+ G_RAID_DEBUG1(1, md->mdo_softc,
+ "root_mount_rel %p", mdi->mdio_rootmount);
+ root_mount_rel(mdi->mdio_rootmount);
+ mdi->mdio_rootmount = NULL;
+ }
+ ddf_meta_free(&mdi->mdio_meta);
+ return (0);
+}
+
+G_RAID_MD_DECLARE(g_raid_md_ddf);
diff --git a/sys/geom/raid/md_ddf.h b/sys/geom/raid/md_ddf.h
new file mode 100644
index 0000000..2027d0c
--- /dev/null
+++ b/sys/geom/raid/md_ddf.h
@@ -0,0 +1,345 @@
+/*-
+ * Copyright (c) 2012 Alexander Motin <mav@FreeBSD.org>
+ * Copyright (c) 2008 Scott Long
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer,
+ * without modification, immediately at the beginning of the file.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef MD_DDF_H
+#define MD_DDF_H
+
+/* Definitions from the SNIA DDF spec, rev 1.2/2.0 */
+
+#define DDF_HEADER_LENGTH 512
+struct ddf_header {
+ uint32_t Signature;
+#define DDF_HEADER_SIGNATURE 0xde11de11
+ uint32_t CRC;
+ uint8_t DDF_Header_GUID[24];
+ uint8_t DDF_rev[8];
+ uint32_t Sequence_Number;
+ uint32_t TimeStamp;
+ uint8_t Open_Flag;
+#define DDF_HEADER_CLOSED 0x00
+#define DDF_HEADER_OPENED_MASK 0x0f
+#define DDF_HEADER_OPEN_ANCHOR 0xff
+ uint8_t Foreign_Flag;
+ uint8_t Diskgrouping;
+ uint8_t pad1[13];
+ uint8_t Header_ext[32];
+ uint64_t Primary_Header_LBA;
+ uint64_t Secondary_Header_LBA;
+ uint8_t Header_Type;
+#define DDF_HEADER_ANCHOR 0x00
+#define DDF_HEADER_PRIMARY 0x01
+#define DDF_HEADER_SECONDARY 0x02
+ uint8_t pad2[3];
+ uint32_t WorkSpace_Length;
+ uint64_t WorkSpace_LBA;
+ uint16_t Max_PD_Entries;
+ uint16_t Max_VD_Entries;
+ uint16_t Max_Partitions;
+ uint16_t Configuration_Record_Length;
+ uint16_t Max_Primary_Element_Entries;
+ uint32_t Max_Mapped_Block_Entries; /* DDF 2.0 */
+ uint8_t pad3[50];
+ uint32_t cd_section; /* Controller_Data_Section */
+ uint32_t cd_length; /* Controller_Data_Section_Length */
+ uint32_t pdr_section; /* Physical_Drive_Records_Section */
+ uint32_t pdr_length; /* Physical_Drive_Records_Length */
+ uint32_t vdr_section; /* Virtual_Drive_Records_Section */
+ uint32_t vdr_length; /* Virtual_Drive_Records_Length */
+ uint32_t cr_section; /* Configuration_Records_Section */
+ uint32_t cr_length; /* Configuration_Records_Length */
+ uint32_t pdd_section; /* Physical_Drive_Data_Section */
+ uint32_t pdd_length; /* Physical_Drive_Data_Length */
+ uint32_t bbmlog_section; /* BBM_Log_Section */
+ uint32_t bbmlog_length; /* BBM_Log_Section_Length */
+ uint32_t Diagnostic_Space;
+ uint32_t Diagnostic_Space_Length;
+ uint32_t Vendor_Specific_Logs;
+ uint32_t Vendor_Specific_Logs_Length;
+ uint8_t pad4[256];
+} __packed;
+
+struct ddf_cd_record {
+ uint32_t Signature;
+#define DDF_CONTROLLER_DATA_SIGNATURE 0xad111111
+ uint32_t CRC;
+ uint8_t Controller_GUID[24];
+ struct {
+ uint16_t Vendor_ID;
+ uint16_t Device_ID;
+ uint16_t SubVendor_ID;
+ uint16_t SubDevice_ID;
+ } Controller_Type __packed;
+ uint8_t Product_ID[16];
+ uint8_t pad1[8];
+ uint8_t Controller_Data[448];
+} __packed;
+
+struct ddf_device_scsi {
+ uint8_t Lun;
+ uint8_t Id;
+ uint8_t Channel;
+ uint8_t Path_Flags;
+#define DDF_DEVICE_SCSI_FLAG_BROKEN (1 << 7)
+} __packed;
+
+struct ddf_device_sas {
+ uint64_t Initiator_Path;
+} __packed;
+
+union ddf_pathinfo {
+ struct {
+ struct ddf_device_scsi Path0;
+ struct ddf_device_scsi Path1;
+ uint8_t pad[10];
+ } __packed scsi;
+ struct {
+ struct ddf_device_sas Path0;
+ struct ddf_device_sas Path1;
+ uint8_t Path0_Flags;
+ uint8_t Path1_Flags;
+#define DDF_DEVICE_SAS_PHY_ID 0x7f
+#define DDF_DEVICE_SAS_FLAG_BROKEN (1 << 7)
+ } __packed sas;
+} __packed;
+
+struct ddf_pd_entry {
+ uint8_t PD_GUID[24];
+ uint32_t PD_Reference;
+ uint16_t PD_Type;
+#define DDF_PDE_GUID_FORCE (1 << 0)
+#define DDF_PDE_PARTICIPATING (1 << 1)
+#define DDF_PDE_GLOBAL_SPARE (1 << 2)
+#define DDF_PDE_CONFIG_SPARE (1 << 3)
+#define DDF_PDE_FOREIGN (1 << 4)
+#define DDF_PDE_LEGACY (1 << 5)
+#define DDF_PDE_TYPE_MASK (0x0f << 12)
+#define DDF_PDE_UNKNOWN (0x00 << 12)
+#define DDF_PDE_SCSI (0x01 << 12)
+#define DDF_PDE_SAS (0x02 << 12)
+#define DDF_PDE_SATA (0x03 << 12)
+#define DDF_PDE_FC (0x04 << 12)
+ uint16_t PD_State;
+#define DDF_PDE_ONLINE (1 << 0)
+#define DDF_PDE_FAILED (1 << 1)
+#define DDF_PDE_REBUILD (1 << 2)
+#define DDF_PDE_TRANSITION (1 << 3)
+#define DDF_PDE_PFA (1 << 4)
+#define DDF_PDE_UNRECOVERED (1 << 5)
+#define DDF_PDE_MISSING (1 << 6)
+ uint64_t Configured_Size;
+ union ddf_pathinfo Path_Information;
+ uint16_t Block_Size; /* DDF 2.0 */
+ uint8_t pad1[4];
+} __packed;
+
+struct ddf_pd_record {
+ uint32_t Signature;
+#define DDF_PDR_SIGNATURE 0x22222222
+ uint32_t CRC;
+ uint16_t Populated_PDEs;
+ uint16_t Max_PDE_Supported;
+ uint8_t pad1[52];
+ struct ddf_pd_entry entry[0];
+} __packed;
+
+struct ddf_vd_entry {
+ uint8_t VD_GUID[24];
+ uint16_t VD_Number;
+ uint8_t pad1[2];
+ uint16_t VD_Type;
+#define DDF_VDE_SHARED (1 << 0)
+#define DDF_VDE_ENFORCE_GROUP (1 << 1)
+#define DDF_VDE_UNICODE_NAME (1 << 2)
+#define DDF_VDE_OWNER_ID_VALID (1 << 3)
+ uint16_t Controller_GUID_CRC;
+ uint8_t VD_State;
+#define DDF_VDE_OPTIMAL 0x00
+#define DDF_VDE_DEGRADED 0x01
+#define DDF_VDE_DELETED 0x02
+#define DDF_VDE_MISSING 0x03
+#define DDF_VDE_FAILED 0x04
+#define DDF_VDE_PARTIAL 0x05
+#define DDF_VDE_OFFLINE 0x06
+#define DDF_VDE_STATE_MASK 0x07
+#define DDF_VDE_MORPH (1 << 3)
+#define DDF_VDE_DIRTY (1 << 4)
+ uint8_t Init_State;
+#define DDF_VDE_UNINTIALIZED 0x00
+#define DDF_VDE_INIT_QUICK 0x01
+#define DDF_VDE_INIT_FULL 0x02
+#define DDF_VDE_INIT_MASK 0x03
+#define DDF_VDE_UACCESS_RW 0x00
+#define DDF_VDE_UACCESS_RO 0x80
+#define DDF_VDE_UACCESS_BLOCKED 0xc0
+#define DDF_VDE_UACCESS_MASK 0xc0
+ uint8_t Drive_Failures_Remaining; /* DDF 2.0 */
+ uint8_t pad2[13];
+ uint8_t VD_Name[16];
+} __packed;
+
+struct ddf_vd_record {
+ uint32_t Signature;
+#define DDF_VD_RECORD_SIGNATURE 0xdddddddd
+ uint32_t CRC;
+ uint16_t Populated_VDEs;
+ uint16_t Max_VDE_Supported;
+ uint8_t pad1[52];
+ struct ddf_vd_entry entry[0];
+} __packed;
+
+#define DDF_CR_INVALID 0xffffffff
+
+struct ddf_vdc_record {
+ uint32_t Signature;
+#define DDF_VDCR_SIGNATURE 0xeeeeeeee
+ uint32_t CRC;
+ uint8_t VD_GUID[24];
+ uint32_t Timestamp;
+ uint32_t Sequence_Number;
+ uint8_t pad1[24];
+ uint16_t Primary_Element_Count;
+ uint8_t Stripe_Size;
+ uint8_t Primary_RAID_Level;
+#define DDF_VDCR_RAID0 0x00
+#define DDF_VDCR_RAID1 0x01
+#define DDF_VDCR_RAID3 0x03
+#define DDF_VDCR_RAID4 0x04
+#define DDF_VDCR_RAID5 0x05
+#define DDF_VDCR_RAID6 0x06
+#define DDF_VDCR_RAID1E 0x11
+#define DDF_VDCR_SINGLE 0x0f
+#define DDF_VDCR_CONCAT 0x1f
+#define DDF_VDCR_RAID5E 0x15
+#define DDF_VDCR_RAID5EE 0x25
+ uint8_t RLQ;
+ uint8_t Secondary_Element_Count;
+ uint8_t Secondary_Element_Seq;
+ uint8_t Secondary_RAID_Level;
+ uint64_t Block_Count;
+ uint64_t VD_Size;
+ uint16_t Block_Size; /* DDF 2.0 */
+ uint8_t Rotate_Parity_count; /* DDF 2.0 */
+ uint8_t pad2[5];
+ uint32_t Associated_Spares[8];
+ uint64_t Cache_Flags;
+#define DDF_VDCR_CACHE_WB (1 << 0)
+#define DDF_VDCR_CACHE_WB_ADAPTIVE (1 << 1)
+#define DDF_VDCR_CACHE_RA (1 << 2)
+#define DDF_VDCR_CACHE_RA_ADAPTIVE (1 << 3)
+#define DDF_VDCR_CACHE_WCACHE_NOBATTERY (1 << 4)
+#define DDF_VDCR_CACHE_WCACHE_ALLOW (1 << 5)
+#define DDF_VDCR_CACHE_RCACHE_ALLOW (1 << 6)
+#define DDF_VDCR_CACHE_VENDOR (1 << 7)
+ uint8_t BG_Rate;
+ uint8_t pad3[3];
+ uint8_t MDF_Parity_Disks; /* DDF 2.0 */
+ uint16_t MDF_Parity_Generator_Polynomial; /* DDF 2.0 */
+ uint8_t pad4;
+ uint8_t MDF_Constant_Generation_Method; /* DDF 2.0 */
+ uint8_t pad5[47];
+ uint8_t pad6[192];
+ uint8_t V0[32];
+ uint8_t V1[32];
+ uint8_t V2[16];
+ uint8_t V3[16];
+ uint8_t Vendor_Scratch[32];
+ uint32_t Physical_Disk_Sequence[0];
+} __packed;
+
+struct ddf_vuc_record {
+ uint32_t Signature;
+#define DDF_VUCR_SIGNATURE 0x88888888
+ uint32_t CRC;
+ uint8_t VD_GUID[24];
+} __packed;
+
+struct ddf_sa_entry {
+ uint8_t VD_GUID[24];
+ uint16_t Secondary_Element;
+ uint8_t rsrvd2[6];
+} __packed;
+
+struct ddf_sa_record {
+ uint32_t Signature;
+#define DDF_SA_SIGNATURE 0x55555555
+ uint32_t CRC;
+ uint32_t Timestamp;
+ uint8_t pad1[7];
+ uint8_t Spare_Type;
+#define DDF_SAR_TYPE_DEDICATED (1 << 0)
+#define DDF_SAR_TYPE_REVERTIBLE (1 << 1)
+#define DDF_SAR_TYPE_ACTIVE (1 << 2)
+#define DDF_SAR_TYPE_ENCL_AFFINITY (1 << 3)
+ uint16_t Populated_SAEs;
+ uint16_t MAX_SAE_Supported;
+ uint8_t pad2[8];
+ struct ddf_sa_entry entry[0];
+} __packed;
+
+struct ddf_pdd_record {
+ uint32_t Signature;
+#define DDF_PDD_SIGNATURE 0x33333333
+ uint32_t CRC;
+ uint8_t PD_GUID[24];
+ uint32_t PD_Reference;
+ uint8_t Forced_Ref_Flag;
+#define DDF_PDD_FORCED_REF 0x01
+ uint8_t Forced_PD_GUID_Flag;
+#define DDF_PDD_FORCED_GUID 0x01
+ uint8_t Vendor_Scratch[32];
+ uint8_t pad2[442];
+} __packed;
+
+struct ddf_bbm_entry {
+ uint64_t Defective_Block_Start;
+ uint32_t Spare_Block_Offset;
+ uint16_t Remapped_Count;
+ uint8_t pad[2];
+};
+
+struct ddf_bbm_log {
+ uint32_t Signature;
+#define DDF_BBML_SIGNATURE 0xabadb10c
+ uint32_t CRC;
+ uint32_t Entry_Count;
+ uint32_t Spare_Block_Count;
+ uint8_t pad1[8];
+ uint64_t First_Spare_LBA;
+ uint64_t Mapped_Block_Entry[0];
+} __packed;
+
+struct ddf_vendor_log {
+ uint32_t Signature;
+#define DDF_VENDOR_LOG_SIGNATURE 0x01dbeef0
+ uint32_t CRC;
+ uint64_t Log_Owner;
+ uint8_t pad1[16];
+} __packed;
+
+#endif
diff --git a/sys/modules/geom/geom_raid/Makefile b/sys/modules/geom/geom_raid/Makefile
index 26c3532..2092a64 100644
--- a/sys/modules/geom/geom_raid/Makefile
+++ b/sys/modules/geom/geom_raid/Makefile
@@ -9,7 +9,7 @@ SRCS+= bus_if.h device_if.h
SRCS+= g_raid_md_if.h g_raid_md_if.c
SRCS+= g_raid_tr_if.h g_raid_tr_if.c
-SRCS+= md_intel.c md_jmicron.c md_nvidia.c md_promise.c md_sii.c
+SRCS+= md_ddf.c md_intel.c md_jmicron.c md_nvidia.c md_promise.c md_sii.c
SRCS+= tr_concat.c tr_raid0.c tr_raid1.c tr_raid1e.c tr_raid5.c
OpenPOWER on IntegriCloud