sys/geom/raid/md_ddf.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2012 Alexander Motin <mav@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/bio.h>
  34 #include <sys/endian.h>
  35 #include <sys/kernel.h>
  36 #include <sys/kobj.h>
  37 #include <sys/limits.h>
  38 #include <sys/lock.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mutex.h>
  41 #include <sys/systm.h>
  42 #include <sys/time.h>
  43 #include <sys/clock.h>
  44 #include <sys/disk.h>
  45 #include <geom/geom.h>
  46 #include "geom/raid/g_raid.h"
  47 #include "geom/raid/md_ddf.h"
  48 #include "g_raid_md_if.h"
  49
  50 static MALLOC_DEFINE(M_MD_DDF, "md_ddf_data", "GEOM_RAID DDF metadata");
  51
  52 #define DDF_MAX_DISKS_HARD      128
  53
  54 #define DDF_MAX_DISKS   16
  55 #define DDF_MAX_VDISKS  7
  56 #define DDF_MAX_PARTITIONS      1
  57
  58 #define DECADE (3600*24*(365*10+2))     /* 10 years in seconds. */
  59
  60 struct ddf_meta {
  61         u_int   sectorsize;
  62         u_int   bigendian;
  63         struct ddf_header *hdr;
  64         struct ddf_cd_record *cdr;
  65         struct ddf_pd_record *pdr;
  66         struct ddf_vd_record *vdr;
  67         void *cr;
  68         struct ddf_pdd_record *pdd;
  69         struct ddf_bbm_log *bbm;
  70 };
  71
  72 struct ddf_vol_meta {
  73         u_int   sectorsize;
  74         u_int   bigendian;
  75         struct ddf_header *hdr;
  76         struct ddf_cd_record *cdr;
  77         struct ddf_vd_entry *vde;
  78         struct ddf_vdc_record *vdc;
  79         struct ddf_vdc_record *bvdc[DDF_MAX_DISKS_HARD];
  80 };
  81
  82 struct g_raid_md_ddf_perdisk {
  83         struct ddf_meta  pd_meta;
  84 };
  85
  86 struct g_raid_md_ddf_pervolume {
  87         struct ddf_vol_meta              pv_meta;
  88         int                              pv_started;
  89         struct callout                   pv_start_co;   /* STARTING state timer. */
  90 };
  91
  92 struct g_raid_md_ddf_object {
  93         struct g_raid_md_object  mdio_base;
  94         u_int                    mdio_bigendian;
  95         struct ddf_meta          mdio_meta;
  96         int                      mdio_starting;
  97         struct callout           mdio_start_co; /* STARTING state timer. */
  98         int                      mdio_started;
  99         struct root_hold_token  *mdio_rootmount; /* Root mount delay token. */
 100 };
 101
 102 static g_raid_md_create_req_t g_raid_md_create_req_ddf;
 103 static g_raid_md_taste_t g_raid_md_taste_ddf;
 104 static g_raid_md_event_t g_raid_md_event_ddf;
 105 static g_raid_md_volume_event_t g_raid_md_volume_event_ddf;
 106 static g_raid_md_ctl_t g_raid_md_ctl_ddf;
 107 static g_raid_md_write_t g_raid_md_write_ddf;
 108 static g_raid_md_fail_disk_t g_raid_md_fail_disk_ddf;
 109 static g_raid_md_free_disk_t g_raid_md_free_disk_ddf;
 110 static g_raid_md_free_volume_t g_raid_md_free_volume_ddf;
 111 static g_raid_md_free_t g_raid_md_free_ddf;
 112
 113 static kobj_method_t g_raid_md_ddf_methods[] = {
 114         KOBJMETHOD(g_raid_md_create_req,        g_raid_md_create_req_ddf),
 115         KOBJMETHOD(g_raid_md_taste,     g_raid_md_taste_ddf),
 116         KOBJMETHOD(g_raid_md_event,     g_raid_md_event_ddf),
 117         KOBJMETHOD(g_raid_md_volume_event,      g_raid_md_volume_event_ddf),
 118         KOBJMETHOD(g_raid_md_ctl,       g_raid_md_ctl_ddf),
 119         KOBJMETHOD(g_raid_md_write,     g_raid_md_write_ddf),
 120         KOBJMETHOD(g_raid_md_fail_disk, g_raid_md_fail_disk_ddf),
 121         KOBJMETHOD(g_raid_md_free_disk, g_raid_md_free_disk_ddf),
 122         KOBJMETHOD(g_raid_md_free_volume,       g_raid_md_free_volume_ddf),
 123         KOBJMETHOD(g_raid_md_free,      g_raid_md_free_ddf),
 124         { 0, 0 }
 125 };
 126
 127 static struct g_raid_md_class g_raid_md_ddf_class = {
 128         "DDF",
 129         g_raid_md_ddf_methods,
 130         sizeof(struct g_raid_md_ddf_object),
 131         .mdc_enable = 1,
 132         .mdc_priority = 100
 133 };
 134
 135 #define GET8(m, f)      ((m)->f)
 136 #define GET16(m, f)     ((m)->bigendian ? be16dec(&(m)->f) : le16dec(&(m)->f))
 137 #define GET32(m, f)     ((m)->bigendian ? be32dec(&(m)->f) : le32dec(&(m)->f))
 138 #define GET64(m, f)     ((m)->bigendian ? be64dec(&(m)->f) : le64dec(&(m)->f))
 139 #define GET8D(m, f)     (f)
 140 #define GET16D(m, f)    ((m)->bigendian ? be16dec(&f) : le16dec(&f))
 141 #define GET32D(m, f)    ((m)->bigendian ? be32dec(&f) : le32dec(&f))
 142 #define GET64D(m, f)    ((m)->bigendian ? be64dec(&f) : le64dec(&f))
 143 #define GET8P(m, f)     (*(f))
 144 #define GET16P(m, f)    ((m)->bigendian ? be16dec(f) : le16dec(f))
 145 #define GET32P(m, f)    ((m)->bigendian ? be32dec(f) : le32dec(f))
 146 #define GET64P(m, f)    ((m)->bigendian ? be64dec(f) : le64dec(f))
 147
 148 #define SET8P(m, f, v)                                                  \
 149         (*(f) = (v))
 150 #define SET16P(m, f, v)                                                 \
 151         do {                                                            \
 152                 if ((m)->bigendian)                                     \
 153                         be16enc((f), (v));                              \
 154                 else                                                    \
 155                         le16enc((f), (v));                              \
 156         } while (0)
 157 #define SET32P(m, f, v)                                                 \
 158         do {                                                            \
 159                 if ((m)->bigendian)                                     \
 160                         be32enc((f), (v));                              \
 161                 else                                                    \
 162                         le32enc((f), (v));                              \
 163         } while (0)
 164 #define SET64P(m, f, v)                                                 \
 165         do {                                                            \
 166                 if ((m)->bigendian)                                     \
 167                         be64enc((f), (v));                              \
 168                 else                                                    \
 169                         le64enc((f), (v));                              \
 170         } while (0)
 171 #define SET8(m, f, v)   SET8P((m), &((m)->f), (v))
 172 #define SET16(m, f, v)  SET16P((m), &((m)->f), (v))
 173 #define SET32(m, f, v)  SET32P((m), &((m)->f), (v))
 174 #define SET64(m, f, v)  SET64P((m), &((m)->f), (v))
 175 #define SET8D(m, f, v)  SET8P((m), &(f), (v))
 176 #define SET16D(m, f, v) SET16P((m), &(f), (v))
 177 #define SET32D(m, f, v) SET32P((m), &(f), (v))
 178 #define SET64D(m, f, v) SET64P((m), &(f), (v))
 179
 180 #define GETCRNUM(m)     (GET32((m), hdr->cr_length) /                   \
 181         GET16((m), hdr->Configuration_Record_Length))
 182
 183 #define GETVDCPTR(m, n) ((struct ddf_vdc_record *)((uint8_t *)(m)->cr + \
 184         (n) * GET16((m), hdr->Configuration_Record_Length) *            \
 185         (m)->sectorsize))
 186
 187 #define GETSAPTR(m, n)  ((struct ddf_sa_record *)((uint8_t *)(m)->cr +  \
 188         (n) * GET16((m), hdr->Configuration_Record_Length) *            \
 189         (m)->sectorsize))
 190
 191 static int
 192 isff(uint8_t *buf, int size)
 193 {
 194         int i;
 195
 196         for (i = 0; i < size; i++)
 197                 if (buf[i] != 0xff)
 198                         return (0);
 199         return (1);
 200 }
 201
 202 static void
 203 print_guid(uint8_t *buf)
 204 {
 205         int i, ascii;
 206
 207         ascii = 1;
 208         for (i = 0; i < 24; i++) {
 209                 if (buf[i] != 0 && (buf[i] < ' ' || buf[i] > 127)) {
 210                         ascii = 0;
 211                         break;
 212                 }
 213         }
 214         if (ascii) {
 215                 printf("'%.24s'", buf);
 216         } else {
 217                 for (i = 0; i < 24; i++)
 218                         printf("%02x", buf[i]);
 219         }
 220 }
 221
 222 static void
 223 g_raid_md_ddf_print(struct ddf_meta *meta)
 224 {
 225         struct ddf_vdc_record *vdc;
 226         struct ddf_vuc_record *vuc;
 227         struct ddf_sa_record *sa;
 228         uint64_t *val2;
 229         uint32_t val;
 230         int i, j, k, num, num2;
 231
 232         if (g_raid_debug < 1)
 233                 return;
 234
 235         printf("********* DDF Metadata *********\n");
 236         printf("**** Header ****\n");
 237         printf("DDF_Header_GUID      ");
 238         print_guid(meta->hdr->DDF_Header_GUID);
 239         printf("\n");
 240         printf("DDF_rev              %8.8s\n", (char *)&meta->hdr->DDF_rev[0]);
 241         printf("Sequence_Number      0x%08x\n", GET32(meta, hdr->Sequence_Number));
 242         printf("TimeStamp            0x%08x\n", GET32(meta, hdr->TimeStamp));
 243         printf("Open_Flag            0x%02x\n", GET16(meta, hdr->Open_Flag));
 244         printf("Foreign_Flag         0x%02x\n", GET16(meta, hdr->Foreign_Flag));
 245         printf("Diskgrouping         0x%02x\n", GET16(meta, hdr->Diskgrouping));
 246         printf("Primary_Header_LBA   %ju\n", GET64(meta, hdr->Primary_Header_LBA));
 247         printf("Secondary_Header_LBA %ju\n", GET64(meta, hdr->Secondary_Header_LBA));
 248         printf("WorkSpace_Length     %u\n", GET32(meta, hdr->WorkSpace_Length));
 249         printf("WorkSpace_LBA        %ju\n", GET64(meta, hdr->WorkSpace_LBA));
 250         printf("Max_PD_Entries       %u\n", GET16(meta, hdr->Max_PD_Entries));
 251         printf("Max_VD_Entries       %u\n", GET16(meta, hdr->Max_VD_Entries));
 252         printf("Max_Partitions       %u\n", GET16(meta, hdr->Max_Partitions));
 253         printf("Configuration_Record_Length %u\n", GET16(meta, hdr->Configuration_Record_Length));
 254         printf("Max_Primary_Element_Entries %u\n", GET16(meta, hdr->Max_Primary_Element_Entries));
 255         printf("Controller Data      %u:%u\n", GET32(meta, hdr->cd_section), GET32(meta, hdr->cd_length));
 256         printf("Physical Disk        %u:%u\n", GET32(meta, hdr->pdr_section), GET32(meta, hdr->pdr_length));
 257         printf("Virtual Disk         %u:%u\n", GET32(meta, hdr->vdr_section), GET32(meta, hdr->vdr_length));
 258         printf("Configuration Recs   %u:%u\n", GET32(meta, hdr->cr_section), GET32(meta, hdr->cr_length));
 259         printf("Physical Disk Recs   %u:%u\n", GET32(meta, hdr->pdd_section), GET32(meta, hdr->pdd_length));
 260         printf("BBM Log              %u:%u\n", GET32(meta, hdr->bbmlog_section), GET32(meta, hdr->bbmlog_length));
 261         printf("Diagnostic Space     %u:%u\n", GET32(meta, hdr->Diagnostic_Space), GET32(meta, hdr->Diagnostic_Space_Length));
 262         printf("Vendor_Specific_Logs %u:%u\n", GET32(meta, hdr->Vendor_Specific_Logs), GET32(meta, hdr->Vendor_Specific_Logs_Length));
 263         printf("**** Controller Data ****\n");
 264         printf("Controller_GUID      ");
 265         print_guid(meta->cdr->Controller_GUID);
 266         printf("\n");
 267         printf("Controller_Type      0x%04x%04x 0x%04x%04x\n",
 268             GET16(meta, cdr->Controller_Type.Vendor_ID),
 269             GET16(meta, cdr->Controller_Type.Device_ID),
 270             GET16(meta, cdr->Controller_Type.SubVendor_ID),
 271             GET16(meta, cdr->Controller_Type.SubDevice_ID));
 272         printf("Product_ID           '%.16s'\n", (char *)&meta->cdr->Product_ID[0]);
 273         printf("**** Physical Disk Records ****\n");
 274         printf("Populated_PDEs       %u\n", GET16(meta, pdr->Populated_PDEs));
 275         printf("Max_PDE_Supported    %u\n", GET16(meta, pdr->Max_PDE_Supported));
 276         for (j = 0; j < GET16(meta, pdr->Populated_PDEs); j++) {
 277                 if (isff(meta->pdr->entry[j].PD_GUID, 24))
 278                         continue;
 279                 if (GET32(meta, pdr->entry[j].PD_Reference) == 0xffffffff)
 280                         continue;
 281                 printf("PD_GUID              ");
 282                 print_guid(meta->pdr->entry[j].PD_GUID);
 283                 printf("\n");
 284                 printf("PD_Reference         0x%08x\n",
 285                     GET32(meta, pdr->entry[j].PD_Reference));
 286                 printf("PD_Type              0x%04x\n",
 287                     GET16(meta, pdr->entry[j].PD_Type));
 288                 printf("PD_State             0x%04x\n",
 289                     GET16(meta, pdr->entry[j].PD_State));
 290                 printf("Configured_Size      %ju\n",
 291                     GET64(meta, pdr->entry[j].Configured_Size));
 292                 printf("Block_Size           %u\n",
 293                     GET16(meta, pdr->entry[j].Block_Size));
 294         }
 295         printf("**** Virtual Disk Records ****\n");
 296         printf("Populated_VDEs       %u\n", GET16(meta, vdr->Populated_VDEs));
 297         printf("Max_VDE_Supported    %u\n", GET16(meta, vdr->Max_VDE_Supported));
 298         for (j = 0; j < GET16(meta, vdr->Populated_VDEs); j++) {
 299                 if (isff(meta->vdr->entry[j].VD_GUID, 24))
 300                         continue;
 301                 printf("VD_GUID              ");
 302                 print_guid(meta->vdr->entry[j].VD_GUID);
 303                 printf("\n");
 304                 printf("VD_Number            0x%04x\n",
 305                     GET16(meta, vdr->entry[j].VD_Number));
 306                 printf("VD_Type              0x%04x\n",
 307                     GET16(meta, vdr->entry[j].VD_Type));
 308                 printf("VD_State             0x%02x\n",
 309                     GET8(meta, vdr->entry[j].VD_State));
 310                 printf("Init_State           0x%02x\n",
 311                     GET8(meta, vdr->entry[j].Init_State));
 312                 printf("Drive_Failures_Remaining %u\n",
 313                     GET8(meta, vdr->entry[j].Drive_Failures_Remaining));
 314                 printf("VD_Name              '%.16s'\n",
 315                     (char *)&meta->vdr->entry[j].VD_Name);
 316         }
 317         printf("**** Configuration Records ****\n");
 318         num = GETCRNUM(meta);
 319         for (j = 0; j < num; j++) {
 320                 vdc = GETVDCPTR(meta, j);
 321                 val = GET32D(meta, vdc->Signature);
 322                 switch (val) {
 323                 case DDF_VDCR_SIGNATURE:
 324                         printf("** Virtual Disk Configuration **\n");
 325                         printf("VD_GUID              ");
 326                         print_guid(vdc->VD_GUID);
 327                         printf("\n");
 328                         printf("Timestamp            0x%08x\n",
 329                             GET32D(meta, vdc->Timestamp));
 330                         printf("Sequence_Number      0x%08x\n",
 331                             GET32D(meta, vdc->Sequence_Number));
 332                         printf("Primary_Element_Count %u\n",
 333                             GET16D(meta, vdc->Primary_Element_Count));
 334                         printf("Stripe_Size          %u\n",
 335                             GET8D(meta, vdc->Stripe_Size));
 336                         printf("Primary_RAID_Level   0x%02x\n",
 337                             GET8D(meta, vdc->Primary_RAID_Level));
 338                         printf("RLQ                  0x%02x\n",
 339                             GET8D(meta, vdc->RLQ));
 340                         printf("Secondary_Element_Count %u\n",
 341                             GET8D(meta, vdc->Secondary_Element_Count));
 342                         printf("Secondary_Element_Seq %u\n",
 343                             GET8D(meta, vdc->Secondary_Element_Seq));
 344                         printf("Secondary_RAID_Level 0x%02x\n",
 345                             GET8D(meta, vdc->Secondary_RAID_Level));
 346                         printf("Block_Count          %ju\n",
 347                             GET64D(meta, vdc->Block_Count));
 348                         printf("VD_Size              %ju\n",
 349                             GET64D(meta, vdc->VD_Size));
 350                         printf("Block_Size           %u\n",
 351                             GET16D(meta, vdc->Block_Size));
 352                         printf("Rotate_Parity_count  %u\n",
 353                             GET8D(meta, vdc->Rotate_Parity_count));
 354                         printf("Associated_Spare_Disks");
 355                         for (i = 0; i < 8; i++) {
 356                                 if (GET32D(meta, vdc->Associated_Spares[i]) != 0xffffffff)
 357                                         printf(" 0x%08x", GET32D(meta, vdc->Associated_Spares[i]));
 358                         }
 359                         printf("\n");
 360                         printf("Cache_Flags          %016jx\n",
 361                             GET64D(meta, vdc->Cache_Flags));
 362                         printf("BG_Rate              %u\n",
 363                             GET8D(meta, vdc->BG_Rate));
 364                         printf("MDF_Parity_Disks     %u\n",
 365                             GET8D(meta, vdc->MDF_Parity_Disks));
 366                         printf("MDF_Parity_Generator_Polynomial 0x%04x\n",
 367                             GET16D(meta, vdc->MDF_Parity_Generator_Polynomial));
 368                         printf("MDF_Constant_Generation_Method 0x%02x\n",
 369                             GET8D(meta, vdc->MDF_Constant_Generation_Method));
 370                         printf("Physical_Disks      ");
 371                         num2 = GET16D(meta, vdc->Primary_Element_Count);
 372                         val2 = (uint64_t *)&(vdc->Physical_Disk_Sequence[GET16(meta, hdr->Max_Primary_Element_Entries)]);
 373                         for (i = 0; i < num2; i++)
 374                                 printf(" 0x%08x @ %ju",
 375                                     GET32D(meta, vdc->Physical_Disk_Sequence[i]),
 376                                     GET64P(meta, val2 + i));
 377                         printf("\n");
 378                         break;
 379                 case DDF_VUCR_SIGNATURE:
 380                         printf("** Vendor Unique Configuration **\n");
 381                         vuc = (struct ddf_vuc_record *)vdc;
 382                         printf("VD_GUID              ");
 383                         print_guid(vuc->VD_GUID);
 384                         printf("\n");
 385                         break;
 386                 case DDF_SA_SIGNATURE:
 387                         printf("** Spare Assignment Configuration **\n");
 388                         sa = (struct ddf_sa_record *)vdc;
 389                         printf("Timestamp            0x%08x\n",
 390                             GET32D(meta, sa->Timestamp));
 391                         printf("Spare_Type           0x%02x\n",
 392                             GET8D(meta, sa->Spare_Type));
 393                         printf("Populated_SAEs       %u\n",
 394                             GET16D(meta, sa->Populated_SAEs));
 395                         printf("MAX_SAE_Supported    %u\n",
 396                             GET16D(meta, sa->MAX_SAE_Supported));
 397                         for (i = 0; i < GET16D(meta, sa->Populated_SAEs); i++) {
 398                                 if (isff(sa->entry[i].VD_GUID, 24))
 399                                         continue;
 400                                 printf("VD_GUID             ");
 401                                 for (k = 0; k < 24; k++)
 402                                         printf("%02x", sa->entry[i].VD_GUID[k]);
 403                                 printf("\n");
 404                                 printf("Secondary_Element   %u\n",
 405                                     GET16D(meta, sa->entry[i].Secondary_Element));
 406                         }
 407                         break;
 408                 case 0x00000000:
 409                 case 0xFFFFFFFF:
 410                         break;
 411                 default:
 412                         printf("Unknown configuration signature %08x\n", val);
 413                         break;
 414                 }
 415         }
 416         printf("**** Physical Disk Data ****\n");
 417         printf("PD_GUID              ");
 418         print_guid(meta->pdd->PD_GUID);
 419         printf("\n");
 420         printf("PD_Reference         0x%08x\n",
 421             GET32(meta, pdd->PD_Reference));
 422         printf("Forced_Ref_Flag      0x%02x\n",
 423             GET8(meta, pdd->Forced_Ref_Flag));
 424         printf("Forced_PD_GUID_Flag  0x%02x\n",
 425             GET8(meta, pdd->Forced_PD_GUID_Flag));
 426 }
 427
 428 static int
 429 ddf_meta_find_pd(struct ddf_meta *meta, uint8_t *GUID, uint32_t PD_Reference)
 430 {
 431         int i;
 432
 433         for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
 434                 if (GUID != NULL) {
 435                         if (memcmp(meta->pdr->entry[i].PD_GUID, GUID, 24) == 0)
 436                                 return (i);
 437                 } else if (PD_Reference != 0xffffffff) {
 438                         if (GET32(meta, pdr->entry[i].PD_Reference) == PD_Reference)
 439                                 return (i);
 440                 } else
 441                         if (isff(meta->pdr->entry[i].PD_GUID, 24))
 442                                 return (i);
 443         }
 444         if (GUID == NULL && PD_Reference == 0xffffffff) {
 445                 if (i >= GET16(meta, pdr->Max_PDE_Supported))
 446                         return (-1);
 447                 SET16(meta, pdr->Populated_PDEs, i + 1);
 448                 return (i);
 449         }
 450         return (-1);
 451 }
 452
 453 static int
 454 ddf_meta_find_vd(struct ddf_meta *meta, uint8_t *GUID)
 455 {
 456         int i;
 457
 458         for (i = 0; i < GET16(meta, vdr->Populated_VDEs); i++) {
 459                 if (GUID != NULL) {
 460                         if (memcmp(meta->vdr->entry[i].VD_GUID, GUID, 24) == 0)
 461                                 return (i);
 462                 } else
 463                         if (isff(meta->vdr->entry[i].VD_GUID, 24))
 464                                 return (i);
 465         }
 466         if (GUID == NULL) {
 467                 if (i >= GET16(meta, vdr->Max_VDE_Supported))
 468                         return (-1);
 469                 SET16(meta, vdr->Populated_VDEs, i + 1);
 470                 return (i);
 471         }
 472         return (-1);
 473 }
 474
 475 static struct ddf_vdc_record *
 476 ddf_meta_find_vdc(struct ddf_meta *meta, uint8_t *GUID)
 477 {
 478         struct ddf_vdc_record *vdc;
 479         int i, num;
 480
 481         num = GETCRNUM(meta);
 482         for (i = 0; i < num; i++) {
 483                 vdc = GETVDCPTR(meta, i);
 484                 if (GUID != NULL) {
 485                         if (GET32D(meta, vdc->Signature) == DDF_VDCR_SIGNATURE &&
 486                             memcmp(vdc->VD_GUID, GUID, 24) == 0)
 487                                 return (vdc);
 488                 } else
 489                         if (GET32D(meta, vdc->Signature) == 0xffffffff ||
 490                             GET32D(meta, vdc->Signature) == 0)
 491                                 return (vdc);
 492         }
 493         return (NULL);
 494 }
 495
 496 static int
 497 ddf_meta_count_vdc(struct ddf_meta *meta, uint8_t *GUID)
 498 {
 499         struct ddf_vdc_record *vdc;
 500         int i, num, cnt;
 501
 502         cnt = 0;
 503         num = GETCRNUM(meta);
 504         for (i = 0; i < num; i++) {
 505                 vdc = GETVDCPTR(meta, i);
 506                 if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
 507                         continue;
 508                 if (GUID == NULL || memcmp(vdc->VD_GUID, GUID, 24) == 0)
 509                         cnt++;
 510         }
 511         return (cnt);
 512 }
 513
 514 static int
 515 ddf_meta_find_disk(struct ddf_vol_meta *vmeta, uint32_t PD_Reference,
 516     int *bvdp, int *posp)
 517 {
 518         int i, bvd, pos;
 519
 520         i = 0;
 521         for (bvd = 0; bvd < GET8(vmeta, vdc->Secondary_Element_Count); bvd++) {
 522                 if (vmeta->bvdc[bvd] == NULL) {
 523                         i += GET16(vmeta, vdc->Primary_Element_Count); // XXX
 524                         continue;
 525                 }
 526                 for (pos = 0; pos < GET16(vmeta, bvdc[bvd]->Primary_Element_Count);
 527                     pos++, i++) {
 528                         if (GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos]) ==
 529                             PD_Reference) {
 530                                 if (bvdp != NULL)
 531                                         *bvdp = bvd;
 532                                 if (posp != NULL)
 533                                         *posp = pos;
 534                                 return (i);
 535                         }
 536                 }
 537         }
 538         return (-1);
 539 }
 540
 541 static struct ddf_sa_record *
 542 ddf_meta_find_sa(struct ddf_meta *meta, int create)
 543 {
 544         struct ddf_sa_record *sa;
 545         int i, num;
 546
 547         num = GETCRNUM(meta);
 548         for (i = 0; i < num; i++) {
 549                 sa = GETSAPTR(meta, i);
 550                 if (GET32D(meta, sa->Signature) == DDF_SA_SIGNATURE)
 551                         return (sa);
 552         }
 553         if (create) {
 554                 for (i = 0; i < num; i++) {
 555                         sa = GETSAPTR(meta, i);
 556                         if (GET32D(meta, sa->Signature) == 0xffffffff ||
 557                             GET32D(meta, sa->Signature) == 0)
 558                                 return (sa);
 559                 }
 560         }
 561         return (NULL);
 562 }
 563
 564 static void
 565 ddf_meta_create(struct g_raid_disk *disk, struct ddf_meta *sample)
 566 {
 567         struct timespec ts;
 568         struct clocktime ct;
 569         struct g_raid_md_ddf_perdisk *pd;
 570         struct g_raid_md_ddf_object *mdi;
 571         struct ddf_meta *meta;
 572         struct ddf_pd_entry *pde;
 573         off_t anchorlba;
 574         u_int ss, pos, size;
 575         int len, error;
 576         char serial_buffer[DISK_IDENT_SIZE];
 577
 578         if (sample->hdr == NULL)
 579                 sample = NULL;
 580
 581         mdi = (struct g_raid_md_ddf_object *)disk->d_softc->sc_md;
 582         pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
 583         meta = &pd->pd_meta;
 584         ss = disk->d_consumer->provider->sectorsize;
 585         anchorlba = disk->d_consumer->provider->mediasize / ss - 1;
 586
 587         meta->sectorsize = ss;
 588         meta->bigendian = sample ? sample->bigendian : mdi->mdio_bigendian;
 589         getnanotime(&ts);
 590         clock_ts_to_ct(&ts, &ct);
 591
 592         /* Header */
 593         meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
 594         memset(meta->hdr, 0xff, ss);
 595         if (sample) {
 596                 memcpy(meta->hdr, sample->hdr, sizeof(struct ddf_header));
 597                 if (ss != sample->sectorsize) {
 598                         SET32(meta, hdr->WorkSpace_Length,
 599                             howmany(GET32(sample, hdr->WorkSpace_Length) *
 600                                 sample->sectorsize, ss));
 601                         SET16(meta, hdr->Configuration_Record_Length,
 602                             howmany(GET16(sample,
 603                                 hdr->Configuration_Record_Length) *
 604                                 sample->sectorsize, ss));
 605                         SET32(meta, hdr->cd_length,
 606                             howmany(GET32(sample, hdr->cd_length) *
 607                                 sample->sectorsize, ss));
 608                         SET32(meta, hdr->pdr_length,
 609                             howmany(GET32(sample, hdr->pdr_length) *
 610                                 sample->sectorsize, ss));
 611                         SET32(meta, hdr->vdr_length,
 612                             howmany(GET32(sample, hdr->vdr_length) *
 613                                 sample->sectorsize, ss));
 614                         SET32(meta, hdr->cr_length,
 615                             howmany(GET32(sample, hdr->cr_length) *
 616                                 sample->sectorsize, ss));
 617                         SET32(meta, hdr->pdd_length,
 618                             howmany(GET32(sample, hdr->pdd_length) *
 619                                 sample->sectorsize, ss));
 620                         SET32(meta, hdr->bbmlog_length,
 621                             howmany(GET32(sample, hdr->bbmlog_length) *
 622                                 sample->sectorsize, ss));
 623                         SET32(meta, hdr->Diagnostic_Space,
 624                             howmany(GET32(sample, hdr->bbmlog_length) *
 625                                 sample->sectorsize, ss));
 626                         SET32(meta, hdr->Vendor_Specific_Logs,
 627                             howmany(GET32(sample, hdr->bbmlog_length) *
 628                                 sample->sectorsize, ss));
 629                 }
 630         } else {
 631                 SET32(meta, hdr->Signature, DDF_HEADER_SIGNATURE);
 632                 snprintf(meta->hdr->DDF_Header_GUID, 25, "FreeBSD %08x%08x",
 633                     (u_int)(ts.tv_sec - DECADE), arc4random());
 634                 memcpy(meta->hdr->DDF_rev, "02.00.00", 8);
 635                 SET32(meta, hdr->TimeStamp, (ts.tv_sec - DECADE));
 636                 SET32(meta, hdr->WorkSpace_Length, 16 * 1024 * 1024 / ss);
 637                 SET16(meta, hdr->Max_PD_Entries, DDF_MAX_DISKS - 1);
 638                 SET16(meta, hdr->Max_VD_Entries, DDF_MAX_VDISKS);
 639                 SET16(meta, hdr->Max_Partitions, DDF_MAX_PARTITIONS);
 640                 SET16(meta, hdr->Max_Primary_Element_Entries, DDF_MAX_DISKS);
 641                 SET16(meta, hdr->Configuration_Record_Length,
 642                     howmany(sizeof(struct ddf_vdc_record) + (4 + 8) *
 643                         GET16(meta, hdr->Max_Primary_Element_Entries), ss));
 644                 SET32(meta, hdr->cd_length,
 645                     howmany(sizeof(struct ddf_cd_record), ss));
 646                 SET32(meta, hdr->pdr_length,
 647                     howmany(sizeof(struct ddf_pd_record) +
 648                         sizeof(struct ddf_pd_entry) * GET16(meta,
 649                         hdr->Max_PD_Entries), ss));
 650                 SET32(meta, hdr->vdr_length,
 651                     howmany(sizeof(struct ddf_vd_record) +
 652                         sizeof(struct ddf_vd_entry) *
 653                         GET16(meta, hdr->Max_VD_Entries), ss));
 654                 SET32(meta, hdr->cr_length,
 655                     GET16(meta, hdr->Configuration_Record_Length) *
 656                     (GET16(meta, hdr->Max_Partitions) + 1));
 657                 SET32(meta, hdr->pdd_length,
 658                     howmany(sizeof(struct ddf_pdd_record), ss));
 659                 SET32(meta, hdr->bbmlog_length, 0);
 660                 SET32(meta, hdr->Diagnostic_Space_Length, 0);
 661                 SET32(meta, hdr->Vendor_Specific_Logs_Length, 0);
 662         }
 663         pos = 1;
 664         SET32(meta, hdr->cd_section, pos);
 665         pos += GET32(meta, hdr->cd_length);
 666         SET32(meta, hdr->pdr_section, pos);
 667         pos += GET32(meta, hdr->pdr_length);
 668         SET32(meta, hdr->vdr_section, pos);
 669         pos += GET32(meta, hdr->vdr_length);
 670         SET32(meta, hdr->cr_section, pos);
 671         pos += GET32(meta, hdr->cr_length);
 672         SET32(meta, hdr->pdd_section, pos);
 673         pos += GET32(meta, hdr->pdd_length);
 674         SET32(meta, hdr->bbmlog_section,
 675             GET32(meta, hdr->bbmlog_length) != 0 ? pos : 0xffffffff);
 676         pos += GET32(meta, hdr->bbmlog_length);
 677         SET32(meta, hdr->Diagnostic_Space,
 678             GET32(meta, hdr->Diagnostic_Space_Length) != 0 ? pos : 0xffffffff);
 679         pos += GET32(meta, hdr->Diagnostic_Space_Length);
 680         SET32(meta, hdr->Vendor_Specific_Logs,
 681             GET32(meta, hdr->Vendor_Specific_Logs_Length) != 0 ? pos : 0xffffffff);
 682         pos += min(GET32(meta, hdr->Vendor_Specific_Logs_Length), 1);
 683         SET64(meta, hdr->Primary_Header_LBA,
 684             anchorlba - pos);
 685         SET64(meta, hdr->Secondary_Header_LBA,
 686             0xffffffffffffffffULL);
 687         SET64(meta, hdr->WorkSpace_LBA,
 688             anchorlba + 1 - 32 * 1024 * 1024 / ss);
 689
 690         /* Controller Data */
 691         size = GET32(meta, hdr->cd_length) * ss;
 692         meta->cdr = malloc(size, M_MD_DDF, M_WAITOK);
 693         memset(meta->cdr, 0xff, size);
 694         SET32(meta, cdr->Signature, DDF_CONTROLLER_DATA_SIGNATURE);
 695         memcpy(meta->cdr->Controller_GUID, "FreeBSD GEOM RAID SERIAL", 24);
 696         memcpy(meta->cdr->Product_ID, "FreeBSD GEOMRAID", 16);
 697
 698         /* Physical Drive Records. */
 699         size = GET32(meta, hdr->pdr_length) * ss;
 700         meta->pdr = malloc(size, M_MD_DDF, M_WAITOK);
 701         memset(meta->pdr, 0xff, size);
 702         SET32(meta, pdr->Signature, DDF_PDR_SIGNATURE);
 703         SET16(meta, pdr->Populated_PDEs, 1);
 704         SET16(meta, pdr->Max_PDE_Supported,
 705             GET16(meta, hdr->Max_PD_Entries));
 706
 707         pde = &meta->pdr->entry[0];
 708         len = sizeof(serial_buffer);
 709         error = g_io_getattr("GEOM::ident", disk->d_consumer, &len, serial_buffer);
 710         if (error == 0 && (len = strlen (serial_buffer)) >= 6 && len <= 20)
 711                 snprintf(pde->PD_GUID, 25, "DISK%20s", serial_buffer);
 712         else
 713                 snprintf(pde->PD_GUID, 25, "DISK%04d%02d%02d%08x%04x",
 714                     ct.year, ct.mon, ct.day,
 715                     arc4random(), arc4random() & 0xffff);
 716         SET32D(meta, pde->PD_Reference, arc4random());
 717         SET16D(meta, pde->PD_Type, DDF_PDE_GUID_FORCE);
 718         SET16D(meta, pde->PD_State, 0);
 719         SET64D(meta, pde->Configured_Size,
 720             anchorlba + 1 - 32 * 1024 * 1024 / ss);
 721         SET16D(meta, pde->Block_Size, ss);
 722
 723         /* Virtual Drive Records. */
 724         size = GET32(meta, hdr->vdr_length) * ss;
 725         meta->vdr = malloc(size, M_MD_DDF, M_WAITOK);
 726         memset(meta->vdr, 0xff, size);
 727         SET32(meta, vdr->Signature, DDF_VD_RECORD_SIGNATURE);
 728         SET32(meta, vdr->Populated_VDEs, 0);
 729         SET16(meta, vdr->Max_VDE_Supported,
 730             GET16(meta, hdr->Max_VD_Entries));
 731
 732         /* Configuration Records. */
 733         size = GET32(meta, hdr->cr_length) * ss;
 734         meta->cr = malloc(size, M_MD_DDF, M_WAITOK);
 735         memset(meta->cr, 0xff, size);
 736
 737         /* Physical Disk Data. */
 738         size = GET32(meta, hdr->pdd_length) * ss;
 739         meta->pdd = malloc(size, M_MD_DDF, M_WAITOK);
 740         memset(meta->pdd, 0xff, size);
 741         SET32(meta, pdd->Signature, DDF_PDD_SIGNATURE);
 742         memcpy(meta->pdd->PD_GUID, pde->PD_GUID, 24);
 743         SET32(meta, pdd->PD_Reference, GET32D(meta, pde->PD_Reference));
 744         SET8(meta, pdd->Forced_Ref_Flag, DDF_PDD_FORCED_REF);
 745         SET8(meta, pdd->Forced_PD_GUID_Flag, DDF_PDD_FORCED_GUID);
 746
 747         /* Bad Block Management Log. */
 748         if (GET32(meta, hdr->bbmlog_length) != 0) {
 749                 size = GET32(meta, hdr->bbmlog_length) * ss;
 750                 meta->bbm = malloc(size, M_MD_DDF, M_WAITOK);
 751                 memset(meta->bbm, 0xff, size);
 752                 SET32(meta, bbm->Signature, DDF_BBML_SIGNATURE);
 753                 SET32(meta, bbm->Entry_Count, 0);
 754                 SET32(meta, bbm->Spare_Block_Count, 0);
 755         }
 756 }
 757
 758 static void
 759 ddf_meta_copy(struct ddf_meta *dst, struct ddf_meta *src)
 760 {
 761         u_int ss;
 762
 763         dst->bigendian = src->bigendian;
 764         ss = dst->sectorsize = src->sectorsize;
 765         dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
 766         memcpy(dst->hdr, src->hdr, ss);
 767         dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
 768         memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss);
 769         dst->pdr = malloc(GET32(src, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
 770         memcpy(dst->pdr, src->pdr, GET32(src, hdr->pdr_length) * ss);
 771         dst->vdr = malloc(GET32(src, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
 772         memcpy(dst->vdr, src->vdr, GET32(src, hdr->vdr_length) * ss);
 773         dst->cr = malloc(GET32(src, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
 774         memcpy(dst->cr, src->cr, GET32(src, hdr->cr_length) * ss);
 775         dst->pdd = malloc(GET32(src, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
 776         memcpy(dst->pdd, src->pdd, GET32(src, hdr->pdd_length) * ss);
 777         if (src->bbm != NULL) {
 778                 dst->bbm = malloc(GET32(src, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
 779                 memcpy(dst->bbm, src->bbm, GET32(src, hdr->bbmlog_length) * ss);
 780         }
 781 }
 782
 783 static void
 784 ddf_meta_update(struct ddf_meta *meta, struct ddf_meta *src)
 785 {
 786         struct ddf_pd_entry *pde, *spde;
 787         int i, j;
 788
 789         for (i = 0; i < GET16(src, pdr->Populated_PDEs); i++) {
 790                 spde = &src->pdr->entry[i];
 791                 if (isff(spde->PD_GUID, 24))
 792                         continue;
 793                 j = ddf_meta_find_pd(meta, NULL,
 794                     GET32(src, pdr->entry[i].PD_Reference));
 795                 if (j < 0) {
 796                         j = ddf_meta_find_pd(meta, NULL, 0xffffffff);
 797                         pde = &meta->pdr->entry[j];
 798                         memcpy(pde, spde, sizeof(*pde));
 799                 } else {
 800                         pde = &meta->pdr->entry[j];
 801                         SET16D(meta, pde->PD_State,
 802                             GET16D(meta, pde->PD_State) |
 803                             GET16D(src, pde->PD_State));
 804                 }
 805         }
 806 }
 807
 808 static void
 809 ddf_meta_free(struct ddf_meta *meta)
 810 {
 811
 812         if (meta->hdr != NULL) {
 813                 free(meta->hdr, M_MD_DDF);
 814                 meta->hdr = NULL;
 815         }
 816         if (meta->cdr != NULL) {
 817                 free(meta->cdr, M_MD_DDF);
 818                 meta->cdr = NULL;
 819         }
 820         if (meta->pdr != NULL) {
 821                 free(meta->pdr, M_MD_DDF);
 822                 meta->pdr = NULL;
 823         }
 824         if (meta->vdr != NULL) {
 825                 free(meta->vdr, M_MD_DDF);
 826                 meta->vdr = NULL;
 827         }
 828         if (meta->cr != NULL) {
 829                 free(meta->cr, M_MD_DDF);
 830                 meta->cr = NULL;
 831         }
 832         if (meta->pdd != NULL) {
 833                 free(meta->pdd, M_MD_DDF);
 834                 meta->pdd = NULL;
 835         }
 836         if (meta->bbm != NULL) {
 837                 free(meta->bbm, M_MD_DDF);
 838                 meta->bbm = NULL;
 839         }
 840 }
 841
 842 static void
 843 ddf_vol_meta_create(struct ddf_vol_meta *meta, struct ddf_meta *sample)
 844 {
 845         struct timespec ts;
 846         struct clocktime ct;
 847         u_int ss, size;
 848
 849         meta->bigendian = sample->bigendian;
 850         ss = meta->sectorsize = sample->sectorsize;
 851         meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
 852         memcpy(meta->hdr, sample->hdr, ss);
 853         meta->cdr = malloc(GET32(sample, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
 854         memcpy(meta->cdr, sample->cdr, GET32(sample, hdr->cd_length) * ss);
 855         meta->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK);
 856         memset(meta->vde, 0xff, sizeof(struct ddf_vd_entry));
 857         getnanotime(&ts);
 858         clock_ts_to_ct(&ts, &ct);
 859         snprintf(meta->vde->VD_GUID, 25, "FreeBSD%04d%02d%02d%08x%01x",
 860             ct.year, ct.mon, ct.day,
 861             arc4random(), arc4random() & 0xf);
 862         size = GET16(sample, hdr->Configuration_Record_Length) * ss;
 863         meta->vdc = malloc(size, M_MD_DDF, M_WAITOK);
 864         memset(meta->vdc, 0xff, size);
 865         SET32(meta, vdc->Signature, DDF_VDCR_SIGNATURE);
 866         memcpy(meta->vdc->VD_GUID, meta->vde->VD_GUID, 24);
 867         SET32(meta, vdc->Sequence_Number, 0);
 868 }
 869
 870 static void
 871 ddf_vol_meta_update(struct ddf_vol_meta *dst, struct ddf_meta *src,
 872     uint8_t *GUID, int started)
 873 {
 874         struct ddf_vd_entry *vde;
 875         struct ddf_vdc_record *vdc;
 876         int vnew, bvnew, bvd, size;
 877         u_int ss;
 878
 879         vde = &src->vdr->entry[ddf_meta_find_vd(src, GUID)];
 880         vdc = ddf_meta_find_vdc(src, GUID);
 881         if (GET8D(src, vdc->Secondary_Element_Count) == 1)
 882                 bvd = 0;
 883         else
 884                 bvd = GET8D(src, vdc->Secondary_Element_Seq);
 885         size = GET16(src, hdr->Configuration_Record_Length) * src->sectorsize;
 886
 887         if (dst->vdc == NULL ||
 888             (!started && ((int32_t)(GET32D(src, vdc->Sequence_Number) -
 889             GET32(dst, vdc->Sequence_Number))) > 0))
 890                 vnew = 1;
 891         else
 892                 vnew = 0;
 893
 894         if (dst->bvdc[bvd] == NULL ||
 895             (!started && ((int32_t)(GET32D(src, vdc->Sequence_Number) -
 896             GET32(dst, bvdc[bvd]->Sequence_Number))) > 0))
 897                 bvnew = 1;
 898         else
 899                 bvnew = 0;
 900
 901         if (vnew) {
 902                 dst->bigendian = src->bigendian;
 903                 ss = dst->sectorsize = src->sectorsize;
 904                 if (dst->hdr != NULL)
 905                         free(dst->hdr, M_MD_DDF);
 906                 dst->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
 907                 memcpy(dst->hdr, src->hdr, ss);
 908                 if (dst->cdr != NULL)
 909                         free(dst->cdr, M_MD_DDF);
 910                 dst->cdr = malloc(GET32(src, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
 911                 memcpy(dst->cdr, src->cdr, GET32(src, hdr->cd_length) * ss);
 912                 if (dst->vde != NULL)
 913                         free(dst->vde, M_MD_DDF);
 914                 dst->vde = malloc(sizeof(struct ddf_vd_entry), M_MD_DDF, M_WAITOK);
 915                 memcpy(dst->vde, vde, sizeof(struct ddf_vd_entry));
 916                 if (dst->vdc != NULL)
 917                         free(dst->vdc, M_MD_DDF);
 918                 dst->vdc = malloc(size, M_MD_DDF, M_WAITOK);
 919                 memcpy(dst->vdc, vdc, size);
 920         }
 921         if (bvnew) {
 922                 if (dst->bvdc[bvd] != NULL)
 923                         free(dst->bvdc[bvd], M_MD_DDF);
 924                 dst->bvdc[bvd] = malloc(size, M_MD_DDF, M_WAITOK);
 925                 memcpy(dst->bvdc[bvd], vdc, size);
 926         }
 927 }
 928
 929 static void
 930 ddf_vol_meta_free(struct ddf_vol_meta *meta)
 931 {
 932         int i;
 933
 934         if (meta->hdr != NULL) {
 935                 free(meta->hdr, M_MD_DDF);
 936                 meta->hdr = NULL;
 937         }
 938         if (meta->cdr != NULL) {
 939                 free(meta->cdr, M_MD_DDF);
 940                 meta->cdr = NULL;
 941         }
 942         if (meta->vde != NULL) {
 943                 free(meta->vde, M_MD_DDF);
 944                 meta->vde = NULL;
 945         }
 946         if (meta->vdc != NULL) {
 947                 free(meta->vdc, M_MD_DDF);
 948                 meta->vdc = NULL;
 949         }
 950         for (i = 0; i < DDF_MAX_DISKS_HARD; i++) {
 951                 if (meta->bvdc[i] != NULL) {
 952                         free(meta->bvdc[i], M_MD_DDF);
 953                         meta->bvdc[i] = NULL;
 954                 }
 955         }
 956 }
 957
 958 static int
 959 ddf_meta_unused_range(struct ddf_meta *meta, off_t *off, off_t *size)
 960 {
 961         struct ddf_vdc_record *vdc;
 962         off_t beg[32], end[32], beg1, end1;
 963         uint64_t *offp;
 964         int i, j, n, num, pos;
 965         uint32_t ref;
 966
 967         *off = 0;
 968         *size = 0;
 969         ref = GET32(meta, pdd->PD_Reference);
 970         pos = ddf_meta_find_pd(meta, NULL, ref);
 971         beg[0] = 0;
 972         end[0] = GET64(meta, pdr->entry[pos].Configured_Size);
 973         n = 1;
 974         num = GETCRNUM(meta);
 975         for (i = 0; i < num; i++) {
 976                 vdc = GETVDCPTR(meta, i);
 977                 if (GET32D(meta, vdc->Signature) != DDF_VDCR_SIGNATURE)
 978                         continue;
 979                 for (pos = 0; pos < GET16D(meta, vdc->Primary_Element_Count); pos++)
 980                         if (GET32D(meta, vdc->Physical_Disk_Sequence[pos]) == ref)
 981                                 break;
 982                 if (pos == GET16D(meta, vdc->Primary_Element_Count))
 983                         continue;
 984                 offp = (uint64_t *)&(vdc->Physical_Disk_Sequence[
 985                     GET16(meta, hdr->Max_Primary_Element_Entries)]);
 986                 beg1 = GET64P(meta, offp + pos);
 987                 end1 = beg1 + GET64D(meta, vdc->Block_Count);
 988                 for (j = 0; j < n; j++) {
 989                         if (beg[j] >= end1 || end[j] <= beg1 )
 990                                 continue;
 991                         if (beg[j] < beg1 && end[j] > end1) {
 992                                 beg[n] = end1;
 993                                 end[n] = end[j];
 994                                 end[j] = beg1;
 995                                 n++;
 996                         } else if (beg[j] < beg1)
 997                                 end[j] = beg1;
 998                         else
 999                                 beg[j] = end1;
1000                 }
1001         }
1002         for (j = 0; j < n; j++) {
1003                 if (end[j] - beg[j] > *size) {
1004                         *off = beg[j];
1005                         *size = end[j] - beg[j];
1006                 }
1007         }
1008         return ((*size > 0) ? 1 : 0);
1009 }
1010
1011 static void
1012 ddf_meta_get_name(struct ddf_meta *meta, int num, char *buf)
1013 {
1014         const char *b;
1015         int i;
1016
1017         b = meta->vdr->entry[num].VD_Name;
1018         for (i = 15; i >= 0; i--)
1019                 if (b[i] != 0x20)
1020                         break;
1021         memcpy(buf, b, i + 1);
1022         buf[i + 1] = 0;
1023 }
1024
1025 static void
1026 ddf_meta_put_name(struct ddf_vol_meta *meta, char *buf)
1027 {
1028         int len;
1029
1030         len = min(strlen(buf), 16);
1031         memset(meta->vde->VD_Name, 0x20, 16);
1032         memcpy(meta->vde->VD_Name, buf, len);
1033 }
1034
1035 static int
1036 ddf_meta_read(struct g_consumer *cp, struct ddf_meta *meta)
1037 {
1038         struct g_provider *pp;
1039         struct ddf_header *ahdr, *hdr;
1040         char *abuf, *buf;
1041         off_t plba, slba, lba;
1042         int error, len, i;
1043         u_int ss;
1044         uint32_t val;
1045
1046         ddf_meta_free(meta);
1047         pp = cp->provider;
1048         ss = meta->sectorsize = pp->sectorsize;
1049         /* Read anchor block. */
1050         abuf = g_read_data(cp, pp->mediasize - ss, ss, &error);
1051         if (abuf == NULL) {
1052                 G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).",
1053                     pp->name, error);
1054                 return (error);
1055         }
1056         ahdr = (struct ddf_header *)abuf;
1057
1058         /* Check if this is an DDF RAID struct */
1059         if (be32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE)
1060                 meta->bigendian = 1;
1061         else if (le32dec(&ahdr->Signature) == DDF_HEADER_SIGNATURE)
1062                 meta->bigendian = 0;
1063         else {
1064                 G_RAID_DEBUG(1, "DDF signature check failed on %s", pp->name);
1065                 error = EINVAL;
1066                 goto done;
1067         }
1068         if (ahdr->Header_Type != DDF_HEADER_ANCHOR) {
1069                 G_RAID_DEBUG(1, "DDF header type check failed on %s", pp->name);
1070                 error = EINVAL;
1071                 goto done;
1072         }
1073         meta->hdr = ahdr;
1074         plba = GET64(meta, hdr->Primary_Header_LBA);
1075         slba = GET64(meta, hdr->Secondary_Header_LBA);
1076         val = GET32(meta, hdr->CRC);
1077         SET32(meta, hdr->CRC, 0xffffffff);
1078         meta->hdr = NULL;
1079         if (crc32(ahdr, ss) != val) {
1080                 G_RAID_DEBUG(1, "DDF CRC mismatch on %s", pp->name);
1081                 error = EINVAL;
1082                 goto done;
1083         }
1084         if ((plba + 6) * ss >= pp->mediasize) {
1085                 G_RAID_DEBUG(1, "DDF primary header LBA is wrong on %s", pp->name);
1086                 error = EINVAL;
1087                 goto done;
1088         }
1089         if (slba != -1 && (slba + 6) * ss >= pp->mediasize) {
1090                 G_RAID_DEBUG(1, "DDF secondary header LBA is wrong on %s", pp->name);
1091                 error = EINVAL;
1092                 goto done;
1093         }
1094         lba = plba;
1095
1096 doread:
1097         error = 0;
1098         ddf_meta_free(meta);
1099
1100         /* Read header block. */
1101         buf = g_read_data(cp, lba * ss, ss, &error);
1102         if (buf == NULL) {
1103 readerror:
1104                 G_RAID_DEBUG(1, "DDF %s metadata read error on %s (error=%d).",
1105                     (lba == plba) ? "primary" : "secondary", pp->name, error);
1106                 if (lba == plba && slba != -1) {
1107                         lba = slba;
1108                         goto doread;
1109                 }
1110                 G_RAID_DEBUG(1, "DDF metadata read error on %s.", pp->name);
1111                 goto done;
1112         }
1113         meta->hdr = malloc(ss, M_MD_DDF, M_WAITOK);
1114         memcpy(meta->hdr, buf, ss);
1115         g_free(buf);
1116         hdr = meta->hdr;
1117         val = GET32(meta, hdr->CRC);
1118         SET32(meta, hdr->CRC, 0xffffffff);
1119         if (hdr->Signature != ahdr->Signature ||
1120             crc32(meta->hdr, ss) != val ||
1121             memcmp(hdr->DDF_Header_GUID, ahdr->DDF_Header_GUID, 24) ||
1122             GET64(meta, hdr->Primary_Header_LBA) != plba ||
1123             GET64(meta, hdr->Secondary_Header_LBA) != slba) {
1124 hdrerror:
1125                 G_RAID_DEBUG(1, "DDF %s metadata check failed on %s",
1126                     (lba == plba) ? "primary" : "secondary", pp->name);
1127                 if (lba == plba && slba != -1) {
1128                         lba = slba;
1129                         goto doread;
1130                 }
1131                 G_RAID_DEBUG(1, "DDF metadata check failed on %s", pp->name);
1132                 error = EINVAL;
1133                 goto done;
1134         }
1135         if ((lba == plba && hdr->Header_Type != DDF_HEADER_PRIMARY) ||
1136             (lba == slba && hdr->Header_Type != DDF_HEADER_SECONDARY))
1137                 goto hdrerror;
1138         len = 1;
1139         len = max(len, GET32(meta, hdr->cd_section) + GET32(meta, hdr->cd_length));
1140         len = max(len, GET32(meta, hdr->pdr_section) + GET32(meta, hdr->pdr_length));
1141         len = max(len, GET32(meta, hdr->vdr_section) + GET32(meta, hdr->vdr_length));
1142         len = max(len, GET32(meta, hdr->cr_section) + GET32(meta, hdr->cr_length));
1143         len = max(len, GET32(meta, hdr->pdd_section) + GET32(meta, hdr->pdd_length));
1144         if ((val = GET32(meta, hdr->bbmlog_section)) != 0xffffffff)
1145                 len = max(len, val + GET32(meta, hdr->bbmlog_length));
1146         if ((val = GET32(meta, hdr->Diagnostic_Space)) != 0xffffffff)
1147                 len = max(len, val + GET32(meta, hdr->Diagnostic_Space_Length));
1148         if ((val = GET32(meta, hdr->Vendor_Specific_Logs)) != 0xffffffff)
1149                 len = max(len, val + GET32(meta, hdr->Vendor_Specific_Logs_Length));
1150         if ((plba + len) * ss >= pp->mediasize)
1151                 goto hdrerror;
1152         if (slba != -1 && (slba + len) * ss >= pp->mediasize)
1153                 goto hdrerror;
1154         /* Workaround for Adaptec implementation. */
1155         if (GET16(meta, hdr->Max_Primary_Element_Entries) == 0xffff) {
1156                 SET16(meta, hdr->Max_Primary_Element_Entries,
1157                     min(GET16(meta, hdr->Max_PD_Entries),
1158                     (GET16(meta, hdr->Configuration_Record_Length) * ss - 512) / 12));
1159         }
1160
1161         if (GET32(meta, hdr->cd_length) * ss >= MAXPHYS ||
1162             GET32(meta, hdr->pdr_length) * ss >= MAXPHYS ||
1163             GET32(meta, hdr->vdr_length) * ss >= MAXPHYS ||
1164             GET32(meta, hdr->cr_length) * ss >= MAXPHYS ||
1165             GET32(meta, hdr->pdd_length) * ss >= MAXPHYS ||
1166             GET32(meta, hdr->bbmlog_length) * ss >= MAXPHYS) {
1167                 G_RAID_DEBUG(1, "%s: Blocksize is too big.", pp->name);
1168                 goto hdrerror;
1169         }
1170
1171         /* Read controller data. */
1172         buf = g_read_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
1173             GET32(meta, hdr->cd_length) * ss, &error);
1174         if (buf == NULL)
1175                 goto readerror;
1176         meta->cdr = malloc(GET32(meta, hdr->cd_length) * ss, M_MD_DDF, M_WAITOK);
1177         memcpy(meta->cdr, buf, GET32(meta, hdr->cd_length) * ss);
1178         g_free(buf);
1179         if (GET32(meta, cdr->Signature) != DDF_CONTROLLER_DATA_SIGNATURE)
1180                 goto hdrerror;
1181
1182         /* Read physical disk records. */
1183         buf = g_read_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
1184             GET32(meta, hdr->pdr_length) * ss, &error);
1185         if (buf == NULL)
1186                 goto readerror;
1187         meta->pdr = malloc(GET32(meta, hdr->pdr_length) * ss, M_MD_DDF, M_WAITOK);
1188         memcpy(meta->pdr, buf, GET32(meta, hdr->pdr_length) * ss);
1189         g_free(buf);
1190         if (GET32(meta, pdr->Signature) != DDF_PDR_SIGNATURE)
1191                 goto hdrerror;
1192         /*
1193          * Workaround for reading metadata corrupted due to graid bug.
1194          * XXX: Remove this before we have disks above 128PB. :)
1195          */
1196         if (meta->bigendian) {
1197                 for (i = 0; i < GET16(meta, pdr->Populated_PDEs); i++) {
1198                         if (isff(meta->pdr->entry[i].PD_GUID, 24))
1199                                 continue;
1200                         if (GET32(meta, pdr->entry[i].PD_Reference) ==
1201                             0xffffffff)
1202                                 continue;
1203                         if (GET64(meta, pdr->entry[i].Configured_Size) >=
1204                              (1ULL << 48)) {
1205                                 SET16(meta, pdr->entry[i].PD_State,
1206                                     GET16(meta, pdr->entry[i].PD_State) &
1207                                     ~DDF_PDE_FAILED);
1208                                 SET64(meta, pdr->entry[i].Configured_Size,
1209                                     GET64(meta, pdr->entry[i].Configured_Size) &
1210                                     ((1ULL << 48) - 1));
1211                         }
1212                 }
1213         }
1214
1215         /* Read virtual disk records. */
1216         buf = g_read_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
1217             GET32(meta, hdr->vdr_length) * ss, &error);
1218         if (buf == NULL)
1219                 goto readerror;
1220         meta->vdr = malloc(GET32(meta, hdr->vdr_length) * ss, M_MD_DDF, M_WAITOK);
1221         memcpy(meta->vdr, buf, GET32(meta, hdr->vdr_length) * ss);
1222         g_free(buf);
1223         if (GET32(meta, vdr->Signature) != DDF_VD_RECORD_SIGNATURE)
1224                 goto hdrerror;
1225
1226         /* Read configuration records. */
1227         buf = g_read_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
1228             GET32(meta, hdr->cr_length) * ss, &error);
1229         if (buf == NULL)
1230                 goto readerror;
1231         meta->cr = malloc(GET32(meta, hdr->cr_length) * ss, M_MD_DDF, M_WAITOK);
1232         memcpy(meta->cr, buf, GET32(meta, hdr->cr_length) * ss);
1233         g_free(buf);
1234
1235         /* Read physical disk data. */
1236         buf = g_read_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
1237             GET32(meta, hdr->pdd_length) * ss, &error);
1238         if (buf == NULL)
1239                 goto readerror;
1240         meta->pdd = malloc(GET32(meta, hdr->pdd_length) * ss, M_MD_DDF, M_WAITOK);
1241         memcpy(meta->pdd, buf, GET32(meta, hdr->pdd_length) * ss);
1242         g_free(buf);
1243         if (GET32(meta, pdd->Signature) != DDF_PDD_SIGNATURE)
1244                 goto hdrerror;
1245         i = ddf_meta_find_pd(meta, NULL, GET32(meta, pdd->PD_Reference));
1246         if (i < 0)
1247                 goto hdrerror;
1248
1249         /* Read BBM Log. */
1250         if (GET32(meta, hdr->bbmlog_section) != 0xffffffff &&
1251             GET32(meta, hdr->bbmlog_length) != 0) {
1252                 buf = g_read_data(cp, (lba + GET32(meta, hdr->bbmlog_section)) * ss,
1253                     GET32(meta, hdr->bbmlog_length) * ss, &error);
1254                 if (buf == NULL)
1255                         goto readerror;
1256                 meta->bbm = malloc(GET32(meta, hdr->bbmlog_length) * ss, M_MD_DDF, M_WAITOK);
1257                 memcpy(meta->bbm, buf, GET32(meta, hdr->bbmlog_length) * ss);
1258                 g_free(buf);
1259                 if (GET32(meta, bbm->Signature) != DDF_BBML_SIGNATURE)
1260                         goto hdrerror;
1261         }
1262
1263 done:
1264         g_free(abuf);
1265         if (error != 0)
1266                 ddf_meta_free(meta);
1267         return (error);
1268 }
1269
1270 static int
1271 ddf_meta_write(struct g_consumer *cp, struct ddf_meta *meta)
1272 {
1273         struct g_provider *pp;
1274         struct ddf_vdc_record *vdc;
1275         off_t alba, plba, slba, lba;
1276         u_int ss, size;
1277         int error, i, num;
1278
1279         pp = cp->provider;
1280         ss = pp->sectorsize;
1281         lba = alba = pp->mediasize / ss - 1;
1282         plba = GET64(meta, hdr->Primary_Header_LBA);
1283         slba = GET64(meta, hdr->Secondary_Header_LBA);
1284
1285 next:
1286         SET8(meta, hdr->Header_Type, (lba == alba) ? DDF_HEADER_ANCHOR :
1287             (lba == plba) ? DDF_HEADER_PRIMARY : DDF_HEADER_SECONDARY);
1288         SET32(meta, hdr->CRC, 0xffffffff);
1289         SET32(meta, hdr->CRC, crc32(meta->hdr, ss));
1290         error = g_write_data(cp, lba * ss, meta->hdr, ss);
1291         if (error != 0) {
1292 err:
1293                 G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).",
1294                     pp->name, error);
1295                 if (lba != alba)
1296                         goto done;
1297         }
1298         if (lba == alba) {
1299                 lba = plba;
1300                 goto next;
1301         }
1302
1303         size = GET32(meta, hdr->cd_length) * ss;
1304         SET32(meta, cdr->CRC, 0xffffffff);
1305         SET32(meta, cdr->CRC, crc32(meta->cdr, size));
1306         error = g_write_data(cp, (lba + GET32(meta, hdr->cd_section)) * ss,
1307             meta->cdr, size);
1308         if (error != 0)
1309                 goto err;
1310
1311         size = GET32(meta, hdr->pdr_length) * ss;
1312         SET32(meta, pdr->CRC, 0xffffffff);
1313         SET32(meta, pdr->CRC, crc32(meta->pdr, size));
1314         error = g_write_data(cp, (lba + GET32(meta, hdr->pdr_section)) * ss,
1315             meta->pdr, size);
1316         if (error != 0)
1317                 goto err;
1318
1319         size = GET32(meta, hdr->vdr_length) * ss;
1320         SET32(meta, vdr->CRC, 0xffffffff);
1321         SET32(meta, vdr->CRC, crc32(meta->vdr, size));
1322         error = g_write_data(cp, (lba + GET32(meta, hdr->vdr_section)) * ss,
1323             meta->vdr, size);
1324         if (error != 0)
1325                 goto err;
1326
1327         size = GET16(meta, hdr->Configuration_Record_Length) * ss;
1328         num = GETCRNUM(meta);
1329         for (i = 0; i < num; i++) {
1330                 vdc = GETVDCPTR(meta, i);
1331                 SET32D(meta, vdc->CRC, 0xffffffff);
1332                 SET32D(meta, vdc->CRC, crc32(vdc, size));
1333         }
1334         error = g_write_data(cp, (lba + GET32(meta, hdr->cr_section)) * ss,
1335             meta->cr, size * num);
1336         if (error != 0)
1337                 goto err;
1338
1339         size = GET32(meta, hdr->pdd_length) * ss;
1340         SET32(meta, pdd->CRC, 0xffffffff);
1341         SET32(meta, pdd->CRC, crc32(meta->pdd, size));
1342         error = g_write_data(cp, (lba + GET32(meta, hdr->pdd_section)) * ss,
1343             meta->pdd, size);
1344         if (error != 0)
1345                 goto err;
1346
1347         if (GET32(meta, hdr->bbmlog_length) != 0) {
1348                 size = GET32(meta, hdr->bbmlog_length) * ss;
1349                 SET32(meta, bbm->CRC, 0xffffffff);
1350                 SET32(meta, bbm->CRC, crc32(meta->bbm, size));
1351                 error = g_write_data(cp,
1352                     (lba + GET32(meta, hdr->bbmlog_section)) * ss,
1353                     meta->bbm, size);
1354                 if (error != 0)
1355                         goto err;
1356         }
1357
1358 done:
1359         if (lba == plba && slba != -1) {
1360                 lba = slba;
1361                 goto next;
1362         }
1363
1364         return (error);
1365 }
1366
1367 static int
1368 ddf_meta_erase(struct g_consumer *cp)
1369 {
1370         struct g_provider *pp;
1371         char *buf;
1372         int error;
1373
1374         pp = cp->provider;
1375         buf = malloc(pp->sectorsize, M_MD_DDF, M_WAITOK | M_ZERO);
1376         error = g_write_data(cp, pp->mediasize - pp->sectorsize,
1377             buf, pp->sectorsize);
1378         if (error != 0) {
1379                 G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).",
1380                     pp->name, error);
1381         }
1382         free(buf, M_MD_DDF);
1383         return (error);
1384 }
1385
1386 static struct g_raid_volume *
1387 g_raid_md_ddf_get_volume(struct g_raid_softc *sc, uint8_t *GUID)
1388 {
1389         struct g_raid_volume    *vol;
1390         struct g_raid_md_ddf_pervolume *pv;
1391
1392         TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
1393                 pv = vol->v_md_data;
1394                 if (memcmp(pv->pv_meta.vde->VD_GUID, GUID, 24) == 0)
1395                         break;
1396         }
1397         return (vol);
1398 }
1399
1400 static struct g_raid_disk *
1401 g_raid_md_ddf_get_disk(struct g_raid_softc *sc, uint8_t *GUID, uint32_t id)
1402 {
1403         struct g_raid_disk      *disk;
1404         struct g_raid_md_ddf_perdisk *pd;
1405         struct ddf_meta *meta;
1406
1407         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1408                 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1409                 meta = &pd->pd_meta;
1410                 if (GUID != NULL) {
1411                         if (memcmp(meta->pdd->PD_GUID, GUID, 24) == 0)
1412                                 break;
1413                 } else {
1414                         if (GET32(meta, pdd->PD_Reference) == id)
1415                                 break;
1416                 }
1417         }
1418         return (disk);
1419 }
1420
1421 static int
1422 g_raid_md_ddf_purge_volumes(struct g_raid_softc *sc)
1423 {
1424         struct g_raid_volume    *vol, *tvol;
1425         int i, res;
1426
1427         res = 0;
1428         TAILQ_FOREACH_SAFE(vol, &sc->sc_volumes, v_next, tvol) {
1429                 if (vol->v_stopping)
1430                         continue;
1431                 for (i = 0; i < vol->v_disks_count; i++) {
1432                         if (vol->v_subdisks[i].sd_state != G_RAID_SUBDISK_S_NONE)
1433                                 break;
1434                 }
1435                 if (i >= vol->v_disks_count) {
1436                         g_raid_destroy_volume(vol);
1437                         res = 1;
1438                 }
1439         }
1440         return (res);
1441 }
1442
1443 static int
1444 g_raid_md_ddf_purge_disks(struct g_raid_softc *sc)
1445 {
1446 #if 0
1447         struct g_raid_disk      *disk, *tdisk;
1448         struct g_raid_volume    *vol;
1449         struct g_raid_md_ddf_perdisk *pd;
1450         int i, j, res;
1451
1452         res = 0;
1453         TAILQ_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) {
1454                 if (disk->d_state == G_RAID_DISK_S_SPARE)
1455                         continue;
1456                 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1457
1458                 /* Scan for deleted volumes. */
1459                 for (i = 0; i < pd->pd_subdisks; ) {
1460                         vol = g_raid_md_ddf_get_volume(sc,
1461                             pd->pd_meta[i]->volume_id);
1462                         if (vol != NULL && !vol->v_stopping) {
1463                                 i++;
1464                                 continue;
1465                         }
1466                         free(pd->pd_meta[i], M_MD_DDF);
1467                         for (j = i; j < pd->pd_subdisks - 1; j++)
1468                                 pd->pd_meta[j] = pd->pd_meta[j + 1];
1469                         pd->pd_meta[DDF_MAX_SUBDISKS - 1] = NULL;
1470                         pd->pd_subdisks--;
1471                         pd->pd_updated = 1;
1472                 }
1473
1474                 /* If there is no metadata left - erase and delete disk. */
1475                 if (pd->pd_subdisks == 0) {
1476                         ddf_meta_erase(disk->d_consumer);
1477                         g_raid_destroy_disk(disk);
1478                         res = 1;
1479                 }
1480         }
1481         return (res);
1482 #endif
1483         return (0);
1484 }
1485
1486 static int
1487 g_raid_md_ddf_supported(int level, int qual, int disks, int force)
1488 {
1489
1490         if (disks > DDF_MAX_DISKS_HARD)
1491                 return (0);
1492         switch (level) {
1493         case G_RAID_VOLUME_RL_RAID0:
1494                 if (qual != G_RAID_VOLUME_RLQ_NONE)
1495                         return (0);
1496                 if (disks < 1)
1497                         return (0);
1498                 if (!force && disks < 2)
1499                         return (0);
1500                 break;
1501         case G_RAID_VOLUME_RL_RAID1:
1502                 if (disks < 1)
1503                         return (0);
1504                 if (qual == G_RAID_VOLUME_RLQ_R1SM) {
1505                         if (!force && disks != 2)
1506                                 return (0);
1507                 } else if (qual == G_RAID_VOLUME_RLQ_R1MM) {
1508                         if (!force && disks != 3)
1509                                 return (0);
1510                 } else
1511                         return (0);
1512                 break;
1513         case G_RAID_VOLUME_RL_RAID3:
1514                 if (qual != G_RAID_VOLUME_RLQ_R3P0 &&
1515                     qual != G_RAID_VOLUME_RLQ_R3PN)
1516                         return (0);
1517                 if (disks < 3)
1518                         return (0);
1519                 break;
1520         case G_RAID_VOLUME_RL_RAID4:
1521                 if (qual != G_RAID_VOLUME_RLQ_R4P0 &&
1522                     qual != G_RAID_VOLUME_RLQ_R4PN)
1523                         return (0);
1524                 if (disks < 3)
1525                         return (0);
1526                 break;
1527         case G_RAID_VOLUME_RL_RAID5:
1528                 if (qual != G_RAID_VOLUME_RLQ_R5RA &&
1529                     qual != G_RAID_VOLUME_RLQ_R5RS &&
1530                     qual != G_RAID_VOLUME_RLQ_R5LA &&
1531                     qual != G_RAID_VOLUME_RLQ_R5LS)
1532                         return (0);
1533                 if (disks < 3)
1534                         return (0);
1535                 break;
1536         case G_RAID_VOLUME_RL_RAID6:
1537                 if (qual != G_RAID_VOLUME_RLQ_R6RA &&
1538                     qual != G_RAID_VOLUME_RLQ_R6RS &&
1539                     qual != G_RAID_VOLUME_RLQ_R6LA &&
1540                     qual != G_RAID_VOLUME_RLQ_R6LS)
1541                         return (0);
1542                 if (disks < 4)
1543                         return (0);
1544                 break;
1545         case G_RAID_VOLUME_RL_RAIDMDF:
1546                 if (qual != G_RAID_VOLUME_RLQ_RMDFRA &&
1547                     qual != G_RAID_VOLUME_RLQ_RMDFRS &&
1548                     qual != G_RAID_VOLUME_RLQ_RMDFLA &&
1549                     qual != G_RAID_VOLUME_RLQ_RMDFLS)
1550                         return (0);
1551                 if (disks < 4)
1552                         return (0);
1553                 break;
1554         case G_RAID_VOLUME_RL_RAID1E:
1555                 if (qual != G_RAID_VOLUME_RLQ_R1EA &&
1556                     qual != G_RAID_VOLUME_RLQ_R1EO)
1557                         return (0);
1558                 if (disks < 3)
1559                         return (0);
1560                 break;
1561         case G_RAID_VOLUME_RL_SINGLE:
1562                 if (qual != G_RAID_VOLUME_RLQ_NONE)
1563                         return (0);
1564                 if (disks != 1)
1565                         return (0);
1566                 break;
1567         case G_RAID_VOLUME_RL_CONCAT:
1568                 if (qual != G_RAID_VOLUME_RLQ_NONE)
1569                         return (0);
1570                 if (disks < 2)
1571                         return (0);
1572                 break;
1573         case G_RAID_VOLUME_RL_RAID5E:
1574                 if (qual != G_RAID_VOLUME_RLQ_R5ERA &&
1575                     qual != G_RAID_VOLUME_RLQ_R5ERS &&
1576                     qual != G_RAID_VOLUME_RLQ_R5ELA &&
1577                     qual != G_RAID_VOLUME_RLQ_R5ELS)
1578                         return (0);
1579                 if (disks < 4)
1580                         return (0);
1581                 break;
1582         case G_RAID_VOLUME_RL_RAID5EE:
1583                 if (qual != G_RAID_VOLUME_RLQ_R5EERA &&
1584                     qual != G_RAID_VOLUME_RLQ_R5EERS &&
1585                     qual != G_RAID_VOLUME_RLQ_R5EELA &&
1586                     qual != G_RAID_VOLUME_RLQ_R5EELS)
1587                         return (0);
1588                 if (disks < 4)
1589                         return (0);
1590                 break;
1591         case G_RAID_VOLUME_RL_RAID5R:
1592                 if (qual != G_RAID_VOLUME_RLQ_R5RRA &&
1593                     qual != G_RAID_VOLUME_RLQ_R5RRS &&
1594                     qual != G_RAID_VOLUME_RLQ_R5RLA &&
1595                     qual != G_RAID_VOLUME_RLQ_R5RLS)
1596                         return (0);
1597                 if (disks < 3)
1598                         return (0);
1599                 break;
1600         default:
1601                 return (0);
1602         }
1603         return (1);
1604 }
1605
1606 static int
1607 g_raid_md_ddf_start_disk(struct g_raid_disk *disk, struct g_raid_volume *vol)
1608 {
1609         struct g_raid_softc *sc;
1610         struct g_raid_subdisk *sd;
1611         struct g_raid_md_ddf_perdisk *pd;
1612         struct g_raid_md_ddf_pervolume *pv;
1613         struct g_raid_md_ddf_object *mdi;
1614         struct ddf_vol_meta *vmeta;
1615         struct ddf_meta *pdmeta, *gmeta;
1616         struct ddf_vdc_record *vdc1;
1617         struct ddf_sa_record *sa;
1618         off_t size, eoff = 0, esize = 0;
1619         uint64_t *val2;
1620         int disk_pos, md_disk_bvd = -1, md_disk_pos = -1, md_pde_pos;
1621         int i, resurrection = 0;
1622         uint32_t reference;
1623
1624         sc = disk->d_softc;
1625         mdi = (struct g_raid_md_ddf_object *)sc->sc_md;
1626         pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1627         pdmeta = &pd->pd_meta;
1628         reference = GET32(&pd->pd_meta, pdd->PD_Reference);
1629
1630         pv = vol->v_md_data;
1631         vmeta = &pv->pv_meta;
1632         gmeta = &mdi->mdio_meta;
1633
1634         /* Find disk position in metadata by its reference. */
1635         disk_pos = ddf_meta_find_disk(vmeta, reference,
1636             &md_disk_bvd, &md_disk_pos);
1637         md_pde_pos = ddf_meta_find_pd(gmeta, NULL, reference);
1638
1639         if (disk_pos < 0) {
1640                 G_RAID_DEBUG1(1, sc,
1641                     "Disk %s is not a present part of the volume %s",
1642                     g_raid_get_diskname(disk), vol->v_name);
1643
1644                 /* Failed stale disk is useless for us. */
1645                 if ((GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) != 0) {
1646                         g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED);
1647                         return (0);
1648                 }
1649
1650                 /* If disk has some metadata for this volume - erase. */
1651                 if ((vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL)
1652                         SET32D(pdmeta, vdc1->Signature, 0xffffffff);
1653
1654                 /* If we are in the start process, that's all for now. */
1655                 if (!pv->pv_started)
1656                         goto nofit;
1657                 /*
1658                  * If we have already started - try to get use of the disk.
1659                  * Try to replace OFFLINE disks first, then FAILED.
1660                  */
1661                 if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >=
1662                         GET16(&pd->pd_meta, hdr->Max_Partitions)) {
1663                         G_RAID_DEBUG1(1, sc, "No free partitions on disk %s",
1664                             g_raid_get_diskname(disk));
1665                         goto nofit;
1666                 }
1667                 ddf_meta_unused_range(&pd->pd_meta, &eoff, &esize);
1668                 if (esize == 0) {
1669                         G_RAID_DEBUG1(1, sc, "No free space on disk %s",
1670                             g_raid_get_diskname(disk));
1671                         goto nofit;
1672                 }
1673                 eoff *= pd->pd_meta.sectorsize;
1674                 esize *= pd->pd_meta.sectorsize;
1675                 size = INT64_MAX;
1676                 for (i = 0; i < vol->v_disks_count; i++) {
1677                         sd = &vol->v_subdisks[i];
1678                         if (sd->sd_state != G_RAID_SUBDISK_S_NONE)
1679                                 size = sd->sd_size;
1680                         if (sd->sd_state <= G_RAID_SUBDISK_S_FAILED &&
1681                             (disk_pos < 0 ||
1682                              vol->v_subdisks[i].sd_state < sd->sd_state))
1683                                 disk_pos = i;
1684                 }
1685                 if (disk_pos >= 0 &&
1686                     vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT &&
1687                     esize < size) {
1688                         G_RAID_DEBUG1(1, sc, "Disk %s free space "
1689                             "is too small (%ju < %ju)",
1690                             g_raid_get_diskname(disk), esize, size);
1691                         disk_pos = -1;
1692                 }
1693                 if (disk_pos >= 0) {
1694                         if (vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT)
1695                                 esize = size;
1696                         md_disk_bvd = disk_pos / GET16(vmeta, vdc->Primary_Element_Count); // XXX
1697                         md_disk_pos = disk_pos % GET16(vmeta, vdc->Primary_Element_Count); // XXX
1698                 } else {
1699 nofit:
1700                         if (disk->d_state == G_RAID_DISK_S_NONE)
1701                                 g_raid_change_disk_state(disk,
1702                                     G_RAID_DISK_S_STALE);
1703                         return (0);
1704                 }
1705
1706                 /*
1707                  * If spare is committable, delete spare record.
1708                  * Othersize, mark it active and leave there.
1709                  */
1710                 sa = ddf_meta_find_sa(&pd->pd_meta, 0);
1711                 if (sa != NULL) {
1712                         if ((GET8D(&pd->pd_meta, sa->Spare_Type) &
1713                             DDF_SAR_TYPE_REVERTIBLE) == 0) {
1714                                 SET32D(&pd->pd_meta, sa->Signature, 0xffffffff);
1715                         } else {
1716                                 SET8D(&pd->pd_meta, sa->Spare_Type,
1717                                     GET8D(&pd->pd_meta, sa->Spare_Type) |
1718                                     DDF_SAR_TYPE_ACTIVE);
1719                         }
1720                 }
1721
1722                 G_RAID_DEBUG1(1, sc, "Disk %s takes pos %d in the volume %s",
1723                     g_raid_get_diskname(disk), disk_pos, vol->v_name);
1724                 resurrection = 1;
1725         }
1726
1727         sd = &vol->v_subdisks[disk_pos];
1728
1729         if (resurrection && sd->sd_disk != NULL) {
1730                 g_raid_change_disk_state(sd->sd_disk,
1731                     G_RAID_DISK_S_STALE_FAILED);
1732                 TAILQ_REMOVE(&sd->sd_disk->d_subdisks,
1733                     sd, sd_next);
1734         }
1735         vol->v_subdisks[disk_pos].sd_disk = disk;
1736         TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
1737
1738         /* Welcome the new disk. */
1739         if (resurrection)
1740                 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
1741         else if (GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA)
1742                 g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED);
1743         else
1744                 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
1745
1746         if (resurrection) {
1747                 sd->sd_offset = eoff;
1748                 sd->sd_size = esize;
1749         } else if (pdmeta->cr != NULL &&
1750             (vdc1 = ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID)) != NULL) {
1751                 val2 = (uint64_t *)&(vdc1->Physical_Disk_Sequence[GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
1752                 sd->sd_offset = (off_t)GET64P(pdmeta, val2 + md_disk_pos) * 512;
1753                 sd->sd_size = (off_t)GET64D(pdmeta, vdc1->Block_Count) * 512;
1754         }
1755
1756         if (resurrection) {
1757                 /* Stale disk, almost same as new. */
1758                 g_raid_change_subdisk_state(sd,
1759                     G_RAID_SUBDISK_S_NEW);
1760         } else if (GET16(gmeta, pdr->entry[md_pde_pos].PD_State) & DDF_PDE_PFA) {
1761                 /* Failed disk. */
1762                 g_raid_change_subdisk_state(sd,
1763                     G_RAID_SUBDISK_S_FAILED);
1764         } else if ((GET16(gmeta, pdr->entry[md_pde_pos].PD_State) &
1765              (DDF_PDE_FAILED | DDF_PDE_REBUILD)) != 0) {
1766                 /* Rebuilding disk. */
1767                 g_raid_change_subdisk_state(sd,
1768                     G_RAID_SUBDISK_S_REBUILD);
1769                 sd->sd_rebuild_pos = 0;
1770         } else if ((GET8(vmeta, vde->VD_State) & DDF_VDE_DIRTY) != 0 ||
1771             (GET8(vmeta, vde->Init_State) & DDF_VDE_INIT_MASK) !=
1772              DDF_VDE_INIT_FULL) {
1773                 /* Stale disk or dirty volume (unclean shutdown). */
1774                 g_raid_change_subdisk_state(sd,
1775                     G_RAID_SUBDISK_S_STALE);
1776         } else {
1777                 /* Up to date disk. */
1778                 g_raid_change_subdisk_state(sd,
1779                     G_RAID_SUBDISK_S_ACTIVE);
1780         }
1781         g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
1782             G_RAID_EVENT_SUBDISK);
1783
1784         return (resurrection);
1785 }
1786
1787 static void
1788 g_raid_md_ddf_refill(struct g_raid_softc *sc)
1789 {
1790         struct g_raid_volume *vol;
1791         struct g_raid_subdisk *sd;
1792         struct g_raid_disk *disk;
1793         struct g_raid_md_object *md;
1794         struct g_raid_md_ddf_perdisk *pd;
1795         struct g_raid_md_ddf_pervolume *pv;
1796         int update, updated, i, bad;
1797
1798         md = sc->sc_md;
1799 restart:
1800         updated = 0;
1801         TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
1802                 pv = vol->v_md_data;
1803                 if (!pv->pv_started || vol->v_stopping)
1804                         continue;
1805
1806                 /* Search for subdisk that needs replacement. */
1807                 bad = 0;
1808                 for (i = 0; i < vol->v_disks_count; i++) {
1809                         sd = &vol->v_subdisks[i];
1810                         if (sd->sd_state == G_RAID_SUBDISK_S_NONE ||
1811                             sd->sd_state == G_RAID_SUBDISK_S_FAILED)
1812                                 bad = 1;
1813                 }
1814                 if (!bad)
1815                         continue;
1816
1817                 G_RAID_DEBUG1(1, sc, "Volume %s is not complete, "
1818                     "trying to refill.", vol->v_name);
1819
1820                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1821                         /* Skip failed. */
1822                         if (disk->d_state < G_RAID_DISK_S_SPARE)
1823                                 continue;
1824                         /* Skip already used by this volume. */
1825                         for (i = 0; i < vol->v_disks_count; i++) {
1826                                 sd = &vol->v_subdisks[i];
1827                                 if (sd->sd_disk == disk)
1828                                         break;
1829                         }
1830                         if (i < vol->v_disks_count)
1831                                 continue;
1832
1833                         /* Try to use disk if it has empty extents. */
1834                         pd = disk->d_md_data;
1835                         if (ddf_meta_count_vdc(&pd->pd_meta, NULL) <
1836                             GET16(&pd->pd_meta, hdr->Max_Partitions)) {
1837                                 update = g_raid_md_ddf_start_disk(disk, vol);
1838                         } else
1839                                 update = 0;
1840                         if (update) {
1841                                 updated = 1;
1842                                 g_raid_md_write_ddf(md, vol, NULL, disk);
1843                                 break;
1844                         }
1845                 }
1846         }
1847         if (updated)
1848                 goto restart;
1849 }
1850
1851 static void
1852 g_raid_md_ddf_start(struct g_raid_volume *vol)
1853 {
1854         struct g_raid_softc *sc;
1855         struct g_raid_subdisk *sd;
1856         struct g_raid_disk *disk;
1857         struct g_raid_md_object *md;
1858         struct g_raid_md_ddf_perdisk *pd;
1859         struct g_raid_md_ddf_pervolume *pv;
1860         struct g_raid_md_ddf_object *mdi;
1861         struct ddf_vol_meta *vmeta;
1862         uint64_t *val2;
1863         int i, j, bvd;
1864
1865         sc = vol->v_softc;
1866         md = sc->sc_md;
1867         mdi = (struct g_raid_md_ddf_object *)md;
1868         pv = vol->v_md_data;
1869         vmeta = &pv->pv_meta;
1870
1871         vol->v_raid_level = GET8(vmeta, vdc->Primary_RAID_Level);
1872         vol->v_raid_level_qualifier = GET8(vmeta, vdc->RLQ);
1873         if (GET8(vmeta, vdc->Secondary_Element_Count) > 1 &&
1874             vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 &&
1875             GET8(vmeta, vdc->Secondary_RAID_Level) == 0)
1876                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E;
1877         vol->v_sectorsize = GET16(vmeta, vdc->Block_Size);
1878         if (vol->v_sectorsize == 0xffff)
1879                 vol->v_sectorsize = vmeta->sectorsize;
1880         vol->v_strip_size = vol->v_sectorsize << GET8(vmeta, vdc->Stripe_Size);
1881         vol->v_disks_count = GET16(vmeta, vdc->Primary_Element_Count) *
1882             GET8(vmeta, vdc->Secondary_Element_Count);
1883         vol->v_mdf_pdisks = GET8(vmeta, vdc->MDF_Parity_Disks);
1884         vol->v_mdf_polynomial = GET16(vmeta, vdc->MDF_Parity_Generator_Polynomial);
1885         vol->v_mdf_method = GET8(vmeta, vdc->MDF_Constant_Generation_Method);
1886         if (GET8(vmeta, vdc->Rotate_Parity_count) > 31)
1887                 vol->v_rotate_parity = 1;
1888         else
1889                 vol->v_rotate_parity = 1 << GET8(vmeta, vdc->Rotate_Parity_count);
1890         vol->v_mediasize = GET64(vmeta, vdc->VD_Size) * vol->v_sectorsize;
1891         for (i = 0, j = 0, bvd = 0; i < vol->v_disks_count; i++, j++) {
1892                 if (j == GET16(vmeta, vdc->Primary_Element_Count)) {
1893                         j = 0;
1894                         bvd++;
1895                 }
1896                 sd = &vol->v_subdisks[i];
1897                 if (vmeta->bvdc[bvd] == NULL) {
1898                         sd->sd_offset = 0;
1899                         sd->sd_size = GET64(vmeta, vdc->Block_Count) *
1900                             vol->v_sectorsize;
1901                         continue;
1902                 }
1903                 val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[
1904                     GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
1905                 sd->sd_offset = GET64P(vmeta, val2 + j) * vol->v_sectorsize;
1906                 sd->sd_size = GET64(vmeta, bvdc[bvd]->Block_Count) *
1907                     vol->v_sectorsize;
1908         }
1909         g_raid_start_volume(vol);
1910
1911         /* Make all disks found till the moment take their places. */
1912         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1913                 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1914                 if (ddf_meta_find_vdc(&pd->pd_meta, vmeta->vdc->VD_GUID) != NULL)
1915                         g_raid_md_ddf_start_disk(disk, vol);
1916         }
1917
1918         pv->pv_started = 1;
1919         mdi->mdio_starting--;
1920         callout_stop(&pv->pv_start_co);
1921         G_RAID_DEBUG1(0, sc, "Volume started.");
1922         g_raid_md_write_ddf(md, vol, NULL, NULL);
1923
1924         /* Pickup any STALE/SPARE disks to refill array if needed. */
1925         g_raid_md_ddf_refill(sc);
1926
1927         g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME);
1928 }
1929
1930 static void
1931 g_raid_ddf_go(void *arg)
1932 {
1933         struct g_raid_volume *vol;
1934         struct g_raid_softc *sc;
1935         struct g_raid_md_ddf_pervolume *pv;
1936
1937         vol = arg;
1938         pv = vol->v_md_data;
1939         sc = vol->v_softc;
1940         if (!pv->pv_started) {
1941                 G_RAID_DEBUG1(0, sc, "Force volume start due to timeout.");
1942                 g_raid_event_send(vol, G_RAID_VOLUME_E_STARTMD,
1943                     G_RAID_EVENT_VOLUME);
1944         }
1945 }
1946
1947 static void
1948 g_raid_md_ddf_new_disk(struct g_raid_disk *disk)
1949 {
1950         struct g_raid_softc *sc;
1951         struct g_raid_md_object *md;
1952         struct g_raid_md_ddf_perdisk *pd;
1953         struct g_raid_md_ddf_pervolume *pv;
1954         struct g_raid_md_ddf_object *mdi;
1955         struct g_raid_volume *vol;
1956         struct ddf_meta *pdmeta;
1957         struct ddf_vol_meta *vmeta;
1958         struct ddf_vdc_record *vdc;
1959         struct ddf_vd_entry *vde;
1960         int i, j, k, num, have, need, cnt, spare;
1961         uint32_t val;
1962         char buf[17];
1963
1964         sc = disk->d_softc;
1965         md = sc->sc_md;
1966         mdi = (struct g_raid_md_ddf_object *)md;
1967         pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
1968         pdmeta = &pd->pd_meta;
1969         spare = -1;
1970
1971         if (mdi->mdio_meta.hdr == NULL)
1972                 ddf_meta_copy(&mdi->mdio_meta, pdmeta);
1973         else
1974                 ddf_meta_update(&mdi->mdio_meta, pdmeta);
1975
1976         num = GETCRNUM(pdmeta);
1977         for (j = 0; j < num; j++) {
1978                 vdc = GETVDCPTR(pdmeta, j);
1979                 val = GET32D(pdmeta, vdc->Signature);
1980
1981                 if (val == DDF_SA_SIGNATURE && spare == -1)
1982                         spare = 1;
1983
1984                 if (val != DDF_VDCR_SIGNATURE)
1985                         continue;
1986                 spare = 0;
1987                 k = ddf_meta_find_vd(pdmeta, vdc->VD_GUID);
1988                 if (k < 0)
1989                         continue;
1990                 vde = &pdmeta->vdr->entry[k];
1991
1992                 /* Look for volume with matching ID. */
1993                 vol = g_raid_md_ddf_get_volume(sc, vdc->VD_GUID);
1994                 if (vol == NULL) {
1995                         ddf_meta_get_name(pdmeta, k, buf);
1996                         vol = g_raid_create_volume(sc, buf,
1997                             GET16D(pdmeta, vde->VD_Number));
1998                         pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO);
1999                         vol->v_md_data = pv;
2000                         callout_init(&pv->pv_start_co, 1);
2001                         callout_reset(&pv->pv_start_co,
2002                             g_raid_start_timeout * hz,
2003                             g_raid_ddf_go, vol);
2004                         mdi->mdio_starting++;
2005                 } else
2006                         pv = vol->v_md_data;
2007
2008                 /* If we haven't started yet - check metadata freshness. */
2009                 vmeta = &pv->pv_meta;
2010                 ddf_vol_meta_update(vmeta, pdmeta, vdc->VD_GUID, pv->pv_started);
2011         }
2012
2013         if (spare == 1) {
2014                 g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
2015                 g_raid_md_ddf_refill(sc);
2016         }
2017
2018         TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2019                 pv = vol->v_md_data;
2020                 vmeta = &pv->pv_meta;
2021
2022                 if (ddf_meta_find_vdc(pdmeta, vmeta->vdc->VD_GUID) == NULL)
2023                         continue;
2024
2025                 if (pv->pv_started) {
2026                         if (g_raid_md_ddf_start_disk(disk, vol))
2027                                 g_raid_md_write_ddf(md, vol, NULL, NULL);
2028                         continue;
2029                 }
2030
2031                 /* If we collected all needed disks - start array. */
2032                 need = 0;
2033                 have = 0;
2034                 for (k = 0; k < GET8(vmeta, vdc->Secondary_Element_Count); k++) {
2035                         if (vmeta->bvdc[k] == NULL) {
2036                                 need += GET16(vmeta, vdc->Primary_Element_Count);
2037                                 continue;
2038                         }
2039                         cnt = GET16(vmeta, bvdc[k]->Primary_Element_Count);
2040                         need += cnt;
2041                         for (i = 0; i < cnt; i++) {
2042                                 val = GET32(vmeta, bvdc[k]->Physical_Disk_Sequence[i]);
2043                                 if (g_raid_md_ddf_get_disk(sc, NULL, val) != NULL)
2044                                         have++;
2045                         }
2046                 }
2047                 G_RAID_DEBUG1(1, sc, "Volume %s now has %d of %d disks",
2048                     vol->v_name, have, need);
2049                 if (have == need)
2050                         g_raid_md_ddf_start(vol);
2051         }
2052 }
2053
2054 static int
2055 g_raid_md_create_req_ddf(struct g_raid_md_object *md, struct g_class *mp,
2056     struct gctl_req *req, struct g_geom **gp)
2057 {
2058         struct g_geom *geom;
2059         struct g_raid_softc *sc;
2060         struct g_raid_md_ddf_object *mdi, *mdi1;
2061         char name[16];
2062         const char *fmtopt;
2063         int be = 1;
2064
2065         mdi = (struct g_raid_md_ddf_object *)md;
2066         fmtopt = gctl_get_asciiparam(req, "fmtopt");
2067         if (fmtopt == NULL || strcasecmp(fmtopt, "BE") == 0)
2068                 be = 1;
2069         else if (strcasecmp(fmtopt, "LE") == 0)
2070                 be = 0;
2071         else {
2072                 gctl_error(req, "Incorrect fmtopt argument.");
2073                 return (G_RAID_MD_TASTE_FAIL);
2074         }
2075
2076         /* Search for existing node. */
2077         LIST_FOREACH(geom, &mp->geom, geom) {
2078                 sc = geom->softc;
2079                 if (sc == NULL)
2080                         continue;
2081                 if (sc->sc_stopping != 0)
2082                         continue;
2083                 if (sc->sc_md->mdo_class != md->mdo_class)
2084                         continue;
2085                 mdi1 = (struct g_raid_md_ddf_object *)sc->sc_md;
2086                 if (mdi1->mdio_bigendian != be)
2087                         continue;
2088                 break;
2089         }
2090         if (geom != NULL) {
2091                 *gp = geom;
2092                 return (G_RAID_MD_TASTE_EXISTING);
2093         }
2094
2095         /* Create new one if not found. */
2096         mdi->mdio_bigendian = be;
2097         snprintf(name, sizeof(name), "DDF%s", be ? "" : "-LE");
2098         sc = g_raid_create_node(mp, name, md);
2099         if (sc == NULL)
2100                 return (G_RAID_MD_TASTE_FAIL);
2101         md->mdo_softc = sc;
2102         *gp = sc->sc_geom;
2103         return (G_RAID_MD_TASTE_NEW);
2104 }
2105
2106 static int
2107 g_raid_md_taste_ddf(struct g_raid_md_object *md, struct g_class *mp,
2108                               struct g_consumer *cp, struct g_geom **gp)
2109 {
2110         struct g_consumer *rcp;
2111         struct g_provider *pp;
2112         struct g_raid_softc *sc;
2113         struct g_raid_disk *disk;
2114         struct ddf_meta meta;
2115         struct g_raid_md_ddf_perdisk *pd;
2116         struct g_raid_md_ddf_object *mdi;
2117         struct g_geom *geom;
2118         int error, result, be;
2119         char name[16];
2120
2121         G_RAID_DEBUG(1, "Tasting DDF on %s", cp->provider->name);
2122         mdi = (struct g_raid_md_ddf_object *)md;
2123         pp = cp->provider;
2124
2125         /* Read metadata from device. */
2126         g_topology_unlock();
2127         bzero(&meta, sizeof(meta));
2128         error = ddf_meta_read(cp, &meta);
2129         g_topology_lock();
2130         if (error != 0)
2131                 return (G_RAID_MD_TASTE_FAIL);
2132         be = meta.bigendian;
2133
2134         /* Metadata valid. Print it. */
2135         g_raid_md_ddf_print(&meta);
2136
2137         /* Search for matching node. */
2138         sc = NULL;
2139         LIST_FOREACH(geom, &mp->geom, geom) {
2140                 sc = geom->softc;
2141                 if (sc == NULL)
2142                         continue;
2143                 if (sc->sc_stopping != 0)
2144                         continue;
2145                 if (sc->sc_md->mdo_class != md->mdo_class)
2146                         continue;
2147                 mdi = (struct g_raid_md_ddf_object *)sc->sc_md;
2148                 if (mdi->mdio_bigendian != be)
2149                         continue;
2150                 break;
2151         }
2152
2153         /* Found matching node. */
2154         if (geom != NULL) {
2155                 G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name);
2156                 result = G_RAID_MD_TASTE_EXISTING;
2157
2158         } else { /* Not found matching node -- create one. */
2159                 result = G_RAID_MD_TASTE_NEW;
2160                 mdi->mdio_bigendian = be;
2161                 snprintf(name, sizeof(name), "DDF%s", be ? "" : "-LE");
2162                 sc = g_raid_create_node(mp, name, md);
2163                 md->mdo_softc = sc;
2164                 geom = sc->sc_geom;
2165         }
2166
2167         /* There is no return after this point, so we close passed consumer. */
2168         g_access(cp, -1, 0, 0);
2169
2170         rcp = g_new_consumer(geom);
2171         rcp->flags |= G_CF_DIRECT_RECEIVE;
2172         g_attach(rcp, pp);
2173         if (g_access(rcp, 1, 1, 1) != 0)
2174                 ; //goto fail1;
2175
2176         g_topology_unlock();
2177         sx_xlock(&sc->sc_lock);
2178
2179         pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
2180         pd->pd_meta = meta;
2181         disk = g_raid_create_disk(sc);
2182         disk->d_md_data = (void *)pd;
2183         disk->d_consumer = rcp;
2184         rcp->private = disk;
2185
2186         g_raid_get_disk_info(disk);
2187
2188         g_raid_md_ddf_new_disk(disk);
2189
2190         sx_xunlock(&sc->sc_lock);
2191         g_topology_lock();
2192         *gp = geom;
2193         return (result);
2194 }
2195
2196 static int
2197 g_raid_md_event_ddf(struct g_raid_md_object *md,
2198     struct g_raid_disk *disk, u_int event)
2199 {
2200         struct g_raid_softc *sc;
2201
2202         sc = md->mdo_softc;
2203         if (disk == NULL)
2204                 return (-1);
2205         switch (event) {
2206         case G_RAID_DISK_E_DISCONNECTED:
2207                 /* Delete disk. */
2208                 g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
2209                 g_raid_destroy_disk(disk);
2210                 g_raid_md_ddf_purge_volumes(sc);
2211
2212                 /* Write updated metadata to all disks. */
2213                 g_raid_md_write_ddf(md, NULL, NULL, NULL);
2214
2215                 /* Check if anything left. */
2216                 if (g_raid_ndisks(sc, -1) == 0)
2217                         g_raid_destroy_node(sc, 0);
2218                 else
2219                         g_raid_md_ddf_refill(sc);
2220                 return (0);
2221         }
2222         return (-2);
2223 }
2224
2225 static int
2226 g_raid_md_volume_event_ddf(struct g_raid_md_object *md,
2227     struct g_raid_volume *vol, u_int event)
2228 {
2229         struct g_raid_md_ddf_pervolume *pv;
2230
2231         pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2232         switch (event) {
2233         case G_RAID_VOLUME_E_STARTMD:
2234                 if (!pv->pv_started)
2235                         g_raid_md_ddf_start(vol);
2236                 return (0);
2237         }
2238         return (-2);
2239 }
2240
2241 static int
2242 g_raid_md_ctl_ddf(struct g_raid_md_object *md,
2243     struct gctl_req *req)
2244 {
2245         struct g_raid_softc *sc;
2246         struct g_raid_volume *vol, *vol1;
2247         struct g_raid_subdisk *sd;
2248         struct g_raid_disk *disk, *disks[DDF_MAX_DISKS_HARD];
2249         struct g_raid_md_ddf_perdisk *pd;
2250         struct g_raid_md_ddf_pervolume *pv;
2251         struct g_raid_md_ddf_object *mdi;
2252         struct ddf_sa_record *sa;
2253         struct g_consumer *cp;
2254         struct g_provider *pp;
2255         char arg[16];
2256         const char *nodename, *verb, *volname, *levelname, *diskname;
2257         char *tmp;
2258         int *nargs, *force;
2259         off_t size, sectorsize, strip, offs[DDF_MAX_DISKS_HARD], esize;
2260         intmax_t *sizearg, *striparg;
2261         int i, numdisks, len, level, qual;
2262         int error;
2263
2264         sc = md->mdo_softc;
2265         mdi = (struct g_raid_md_ddf_object *)md;
2266         verb = gctl_get_param(req, "verb", NULL);
2267         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
2268         error = 0;
2269
2270         if (strcmp(verb, "label") == 0) {
2271
2272                 if (*nargs < 4) {
2273                         gctl_error(req, "Invalid number of arguments.");
2274                         return (-1);
2275                 }
2276                 volname = gctl_get_asciiparam(req, "arg1");
2277                 if (volname == NULL) {
2278                         gctl_error(req, "No volume name.");
2279                         return (-2);
2280                 }
2281                 levelname = gctl_get_asciiparam(req, "arg2");
2282                 if (levelname == NULL) {
2283                         gctl_error(req, "No RAID level.");
2284                         return (-3);
2285                 }
2286                 if (g_raid_volume_str2level(levelname, &level, &qual)) {
2287                         gctl_error(req, "Unknown RAID level '%s'.", levelname);
2288                         return (-4);
2289                 }
2290                 numdisks = *nargs - 3;
2291                 force = gctl_get_paraml(req, "force", sizeof(*force));
2292                 if (!g_raid_md_ddf_supported(level, qual, numdisks,
2293                     force ? *force : 0)) {
2294                         gctl_error(req, "Unsupported RAID level "
2295                             "(0x%02x/0x%02x), or number of disks (%d).",
2296                             level, qual, numdisks);
2297                         return (-5);
2298                 }
2299
2300                 /* Search for disks, connect them and probe. */
2301                 size = INT64_MAX;
2302                 sectorsize = 0;
2303                 bzero(disks, sizeof(disks));
2304                 bzero(offs, sizeof(offs));
2305                 for (i = 0; i < numdisks; i++) {
2306                         snprintf(arg, sizeof(arg), "arg%d", i + 3);
2307                         diskname = gctl_get_asciiparam(req, arg);
2308                         if (diskname == NULL) {
2309                                 gctl_error(req, "No disk name (%s).", arg);
2310                                 error = -6;
2311                                 break;
2312                         }
2313                         if (strcmp(diskname, "NONE") == 0)
2314                                 continue;
2315
2316                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2317                                 if (disk->d_consumer != NULL &&
2318                                     disk->d_consumer->provider != NULL &&
2319                                     strcmp(disk->d_consumer->provider->name,
2320                                      diskname) == 0)
2321                                         break;
2322                         }
2323                         if (disk != NULL) {
2324                                 if (disk->d_state != G_RAID_DISK_S_ACTIVE) {
2325                                         gctl_error(req, "Disk '%s' is in a "
2326                                             "wrong state (%s).", diskname,
2327                                             g_raid_disk_state2str(disk->d_state));
2328                                         error = -7;
2329                                         break;
2330                                 }
2331                                 pd = disk->d_md_data;
2332                                 if (ddf_meta_count_vdc(&pd->pd_meta, NULL) >=
2333                                     GET16(&pd->pd_meta, hdr->Max_Partitions)) {
2334                                         gctl_error(req, "No free partitions "
2335                                             "on disk '%s'.",
2336                                             diskname);
2337                                         error = -7;
2338                                         break;
2339                                 }
2340                                 pp = disk->d_consumer->provider;
2341                                 disks[i] = disk;
2342                                 ddf_meta_unused_range(&pd->pd_meta,
2343                                     &offs[i], &esize);
2344                                 offs[i] *= pp->sectorsize;
2345                                 size = MIN(size, (off_t)esize * pp->sectorsize);
2346                                 sectorsize = MAX(sectorsize, pp->sectorsize);
2347                                 continue;
2348                         }
2349
2350                         g_topology_lock();
2351                         cp = g_raid_open_consumer(sc, diskname);
2352                         if (cp == NULL) {
2353                                 gctl_error(req, "Can't open disk '%s'.",
2354                                     diskname);
2355                                 g_topology_unlock();
2356                                 error = -8;
2357                                 break;
2358                         }
2359                         pp = cp->provider;
2360                         pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
2361                         disk = g_raid_create_disk(sc);
2362                         disk->d_md_data = (void *)pd;
2363                         disk->d_consumer = cp;
2364                         disks[i] = disk;
2365                         cp->private = disk;
2366                         ddf_meta_create(disk, &mdi->mdio_meta);
2367                         if (mdi->mdio_meta.hdr == NULL)
2368                                 ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta);
2369                         else
2370                                 ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta);
2371                         g_topology_unlock();
2372
2373                         g_raid_get_disk_info(disk);
2374
2375                         /* Reserve some space for metadata. */
2376                         size = MIN(size, GET64(&pd->pd_meta,
2377                             pdr->entry[0].Configured_Size) * pp->sectorsize);
2378                         sectorsize = MAX(sectorsize, pp->sectorsize);
2379                 }
2380                 if (error != 0) {
2381                         for (i = 0; i < numdisks; i++) {
2382                                 if (disks[i] != NULL &&
2383                                     disks[i]->d_state == G_RAID_DISK_S_NONE)
2384                                         g_raid_destroy_disk(disks[i]);
2385                         }
2386                         return (error);
2387                 }
2388
2389                 if (sectorsize <= 0) {
2390                         gctl_error(req, "Can't get sector size.");
2391                         return (-8);
2392                 }
2393
2394                 /* Handle size argument. */
2395                 len = sizeof(*sizearg);
2396                 sizearg = gctl_get_param(req, "size", &len);
2397                 if (sizearg != NULL && len == sizeof(*sizearg) &&
2398                     *sizearg > 0) {
2399                         if (*sizearg > size) {
2400                                 gctl_error(req, "Size too big %lld > %lld.",
2401                                     (long long)*sizearg, (long long)size);
2402                                 return (-9);
2403                         }
2404                         size = *sizearg;
2405                 }
2406
2407                 /* Handle strip argument. */
2408                 strip = 131072;
2409                 len = sizeof(*striparg);
2410                 striparg = gctl_get_param(req, "strip", &len);
2411                 if (striparg != NULL && len == sizeof(*striparg) &&
2412                     *striparg > 0) {
2413                         if (*striparg < sectorsize) {
2414                                 gctl_error(req, "Strip size too small.");
2415                                 return (-10);
2416                         }
2417                         if (*striparg % sectorsize != 0) {
2418                                 gctl_error(req, "Incorrect strip size.");
2419                                 return (-11);
2420                         }
2421                         strip = *striparg;
2422                 }
2423
2424                 /* Round size down to strip or sector. */
2425                 if (level == G_RAID_VOLUME_RL_RAID1 ||
2426                     level == G_RAID_VOLUME_RL_RAID3 ||
2427                     level == G_RAID_VOLUME_RL_SINGLE ||
2428                     level == G_RAID_VOLUME_RL_CONCAT)
2429                         size -= (size % sectorsize);
2430                 else if (level == G_RAID_VOLUME_RL_RAID1E &&
2431                     (numdisks & 1) != 0)
2432                         size -= (size % (2 * strip));
2433                 else
2434                         size -= (size % strip);
2435                 if (size <= 0) {
2436                         gctl_error(req, "Size too small.");
2437                         return (-13);
2438                 }
2439
2440                 /* We have all we need, create things: volume, ... */
2441                 pv = malloc(sizeof(*pv), M_MD_DDF, M_WAITOK | M_ZERO);
2442                 ddf_vol_meta_create(&pv->pv_meta, &mdi->mdio_meta);
2443                 pv->pv_started = 1;
2444                 vol = g_raid_create_volume(sc, volname, -1);
2445                 vol->v_md_data = pv;
2446                 vol->v_raid_level = level;
2447                 vol->v_raid_level_qualifier = qual;
2448                 vol->v_strip_size = strip;
2449                 vol->v_disks_count = numdisks;
2450                 if (level == G_RAID_VOLUME_RL_RAID0 ||
2451                     level == G_RAID_VOLUME_RL_CONCAT ||
2452                     level == G_RAID_VOLUME_RL_SINGLE)
2453                         vol->v_mediasize = size * numdisks;
2454                 else if (level == G_RAID_VOLUME_RL_RAID1)
2455                         vol->v_mediasize = size;
2456                 else if (level == G_RAID_VOLUME_RL_RAID3 ||
2457                     level == G_RAID_VOLUME_RL_RAID4 ||
2458                     level == G_RAID_VOLUME_RL_RAID5)
2459                         vol->v_mediasize = size * (numdisks - 1);
2460                 else if (level == G_RAID_VOLUME_RL_RAID5R) {
2461                         vol->v_mediasize = size * (numdisks - 1);
2462                         vol->v_rotate_parity = 1024;
2463                 } else if (level == G_RAID_VOLUME_RL_RAID6 ||
2464                     level == G_RAID_VOLUME_RL_RAID5E ||
2465                     level == G_RAID_VOLUME_RL_RAID5EE)
2466                         vol->v_mediasize = size * (numdisks - 2);
2467                 else if (level == G_RAID_VOLUME_RL_RAIDMDF) {
2468                         if (numdisks < 5)
2469                                 vol->v_mdf_pdisks = 2;
2470                         else
2471                                 vol->v_mdf_pdisks = 3;
2472                         vol->v_mdf_polynomial = 0x11d;
2473                         vol->v_mdf_method = 0x00;
2474                         vol->v_mediasize = size * (numdisks - vol->v_mdf_pdisks);
2475                 } else { /* RAID1E */
2476                         vol->v_mediasize = ((size * numdisks) / strip / 2) *
2477                             strip;
2478                 }
2479                 vol->v_sectorsize = sectorsize;
2480                 g_raid_start_volume(vol);
2481
2482                 /* , and subdisks. */
2483                 for (i = 0; i < numdisks; i++) {
2484                         disk = disks[i];
2485                         sd = &vol->v_subdisks[i];
2486                         sd->sd_disk = disk;
2487                         sd->sd_offset = offs[i];
2488                         sd->sd_size = size;
2489                         if (disk == NULL)
2490                                 continue;
2491                         TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
2492                         g_raid_change_disk_state(disk,
2493                             G_RAID_DISK_S_ACTIVE);
2494                         g_raid_change_subdisk_state(sd,
2495                             G_RAID_SUBDISK_S_ACTIVE);
2496                         g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
2497                             G_RAID_EVENT_SUBDISK);
2498                 }
2499
2500                 /* Write metadata based on created entities. */
2501                 G_RAID_DEBUG1(0, sc, "Array started.");
2502                 g_raid_md_write_ddf(md, vol, NULL, NULL);
2503
2504                 /* Pickup any STALE/SPARE disks to refill array if needed. */
2505                 g_raid_md_ddf_refill(sc);
2506
2507                 g_raid_event_send(vol, G_RAID_VOLUME_E_START,
2508                     G_RAID_EVENT_VOLUME);
2509                 return (0);
2510         }
2511         if (strcmp(verb, "add") == 0) {
2512
2513                 gctl_error(req, "`add` command is not applicable, "
2514                     "use `label` instead.");
2515                 return (-99);
2516         }
2517         if (strcmp(verb, "delete") == 0) {
2518
2519                 nodename = gctl_get_asciiparam(req, "arg0");
2520                 if (nodename != NULL && strcasecmp(sc->sc_name, nodename) != 0)
2521                         nodename = NULL;
2522
2523                 /* Full node destruction. */
2524                 if (*nargs == 1 && nodename != NULL) {
2525                         /* Check if some volume is still open. */
2526                         force = gctl_get_paraml(req, "force", sizeof(*force));
2527                         if (force != NULL && *force == 0 &&
2528                             g_raid_nopens(sc) != 0) {
2529                                 gctl_error(req, "Some volume is still open.");
2530                                 return (-4);
2531                         }
2532
2533                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2534                                 if (disk->d_consumer)
2535                                         ddf_meta_erase(disk->d_consumer);
2536                         }
2537                         g_raid_destroy_node(sc, 0);
2538                         return (0);
2539                 }
2540
2541                 /* Destroy specified volume. If it was last - all node. */
2542                 if (*nargs > 2) {
2543                         gctl_error(req, "Invalid number of arguments.");
2544                         return (-1);
2545                 }
2546                 volname = gctl_get_asciiparam(req,
2547                     nodename != NULL ? "arg1" : "arg0");
2548                 if (volname == NULL) {
2549                         gctl_error(req, "No volume name.");
2550                         return (-2);
2551                 }
2552
2553                 /* Search for volume. */
2554                 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2555                         if (strcmp(vol->v_name, volname) == 0)
2556                                 break;
2557                         pp = vol->v_provider;
2558                         if (pp == NULL)
2559                                 continue;
2560                         if (strcmp(pp->name, volname) == 0)
2561                                 break;
2562                         if (strncmp(pp->name, "raid/", 5) == 0 &&
2563                             strcmp(pp->name + 5, volname) == 0)
2564                                 break;
2565                 }
2566                 if (vol == NULL) {
2567                         i = strtol(volname, &tmp, 10);
2568                         if (verb != volname && tmp[0] == 0) {
2569                                 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2570                                         if (vol->v_global_id == i)
2571                                                 break;
2572                                 }
2573                         }
2574                 }
2575                 if (vol == NULL) {
2576                         gctl_error(req, "Volume '%s' not found.", volname);
2577                         return (-3);
2578                 }
2579
2580                 /* Check if volume is still open. */
2581                 force = gctl_get_paraml(req, "force", sizeof(*force));
2582                 if (force != NULL && *force == 0 &&
2583                     vol->v_provider_open != 0) {
2584                         gctl_error(req, "Volume is still open.");
2585                         return (-4);
2586                 }
2587
2588                 /* Destroy volume and potentially node. */
2589                 i = 0;
2590                 TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next)
2591                         i++;
2592                 if (i >= 2) {
2593                         g_raid_destroy_volume(vol);
2594                         g_raid_md_ddf_purge_disks(sc);
2595                         g_raid_md_write_ddf(md, NULL, NULL, NULL);
2596                 } else {
2597                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2598                                 if (disk->d_consumer)
2599                                         ddf_meta_erase(disk->d_consumer);
2600                         }
2601                         g_raid_destroy_node(sc, 0);
2602                 }
2603                 return (0);
2604         }
2605         if (strcmp(verb, "remove") == 0 ||
2606             strcmp(verb, "fail") == 0) {
2607                 if (*nargs < 2) {
2608                         gctl_error(req, "Invalid number of arguments.");
2609                         return (-1);
2610                 }
2611                 for (i = 1; i < *nargs; i++) {
2612                         snprintf(arg, sizeof(arg), "arg%d", i);
2613                         diskname = gctl_get_asciiparam(req, arg);
2614                         if (diskname == NULL) {
2615                                 gctl_error(req, "No disk name (%s).", arg);
2616                                 error = -2;
2617                                 break;
2618                         }
2619                         if (strncmp(diskname, "/dev/", 5) == 0)
2620                                 diskname += 5;
2621
2622                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2623                                 if (disk->d_consumer != NULL &&
2624                                     disk->d_consumer->provider != NULL &&
2625                                     strcmp(disk->d_consumer->provider->name,
2626                                      diskname) == 0)
2627                                         break;
2628                         }
2629                         if (disk == NULL) {
2630                                 gctl_error(req, "Disk '%s' not found.",
2631                                     diskname);
2632                                 error = -3;
2633                                 break;
2634                         }
2635
2636                         if (strcmp(verb, "fail") == 0) {
2637                                 g_raid_md_fail_disk_ddf(md, NULL, disk);
2638                                 continue;
2639                         }
2640
2641                         /* Erase metadata on deleting disk and destroy it. */
2642                         ddf_meta_erase(disk->d_consumer);
2643                         g_raid_destroy_disk(disk);
2644                 }
2645                 g_raid_md_ddf_purge_volumes(sc);
2646
2647                 /* Write updated metadata to remaining disks. */
2648                 g_raid_md_write_ddf(md, NULL, NULL, NULL);
2649
2650                 /* Check if anything left. */
2651                 if (g_raid_ndisks(sc, -1) == 0)
2652                         g_raid_destroy_node(sc, 0);
2653                 else
2654                         g_raid_md_ddf_refill(sc);
2655                 return (error);
2656         }
2657         if (strcmp(verb, "insert") == 0) {
2658                 if (*nargs < 2) {
2659                         gctl_error(req, "Invalid number of arguments.");
2660                         return (-1);
2661                 }
2662                 for (i = 1; i < *nargs; i++) {
2663                         /* Get disk name. */
2664                         snprintf(arg, sizeof(arg), "arg%d", i);
2665                         diskname = gctl_get_asciiparam(req, arg);
2666                         if (diskname == NULL) {
2667                                 gctl_error(req, "No disk name (%s).", arg);
2668                                 error = -3;
2669                                 break;
2670                         }
2671
2672                         /* Try to find provider with specified name. */
2673                         g_topology_lock();
2674                         cp = g_raid_open_consumer(sc, diskname);
2675                         if (cp == NULL) {
2676                                 gctl_error(req, "Can't open disk '%s'.",
2677                                     diskname);
2678                                 g_topology_unlock();
2679                                 error = -4;
2680                                 break;
2681                         }
2682                         pp = cp->provider;
2683                         g_topology_unlock();
2684
2685                         pd = malloc(sizeof(*pd), M_MD_DDF, M_WAITOK | M_ZERO);
2686
2687                         disk = g_raid_create_disk(sc);
2688                         disk->d_consumer = cp;
2689                         disk->d_md_data = (void *)pd;
2690                         cp->private = disk;
2691
2692                         g_raid_get_disk_info(disk);
2693
2694                         /* Welcome the "new" disk. */
2695                         g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
2696                         ddf_meta_create(disk, &mdi->mdio_meta);
2697                         sa = ddf_meta_find_sa(&pd->pd_meta, 1);
2698                         if (sa != NULL) {
2699                                 SET32D(&pd->pd_meta, sa->Signature,
2700                                     DDF_SA_SIGNATURE);
2701                                 SET8D(&pd->pd_meta, sa->Spare_Type, 0);
2702                                 SET16D(&pd->pd_meta, sa->Populated_SAEs, 0);
2703                                 SET16D(&pd->pd_meta, sa->MAX_SAE_Supported,
2704                                     (GET16(&pd->pd_meta, hdr->Configuration_Record_Length) *
2705                                      pd->pd_meta.sectorsize -
2706                                      sizeof(struct ddf_sa_record)) /
2707                                     sizeof(struct ddf_sa_entry));
2708                         }
2709                         if (mdi->mdio_meta.hdr == NULL)
2710                                 ddf_meta_copy(&mdi->mdio_meta, &pd->pd_meta);
2711                         else
2712                                 ddf_meta_update(&mdi->mdio_meta, &pd->pd_meta);
2713                         g_raid_md_write_ddf(md, NULL, NULL, NULL);
2714                         g_raid_md_ddf_refill(sc);
2715                 }
2716                 return (error);
2717         }
2718         return (-100);
2719 }
2720
2721 static int
2722 g_raid_md_write_ddf(struct g_raid_md_object *md, struct g_raid_volume *tvol,
2723     struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
2724 {
2725         struct g_raid_softc *sc;
2726         struct g_raid_volume *vol;
2727         struct g_raid_subdisk *sd;
2728         struct g_raid_disk *disk;
2729         struct g_raid_md_ddf_perdisk *pd;
2730         struct g_raid_md_ddf_pervolume *pv;
2731         struct g_raid_md_ddf_object *mdi;
2732         struct ddf_meta *gmeta;
2733         struct ddf_vol_meta *vmeta;
2734         struct ddf_vdc_record *vdc;
2735         struct ddf_sa_record *sa;
2736         uint64_t *val2;
2737         int i, j, pos, bvd, size;
2738
2739         sc = md->mdo_softc;
2740         mdi = (struct g_raid_md_ddf_object *)md;
2741         gmeta = &mdi->mdio_meta;
2742
2743         if (sc->sc_stopping == G_RAID_DESTROY_HARD)
2744                 return (0);
2745
2746         /*
2747          * Clear disk flags to let only really needed ones to be reset.
2748          * Do it only if there are no volumes in starting state now,
2749          * as they can update disk statuses yet and we may kill innocent.
2750          */
2751         if (mdi->mdio_starting == 0) {
2752                 for (i = 0; i < GET16(gmeta, pdr->Populated_PDEs); i++) {
2753                         if (isff(gmeta->pdr->entry[i].PD_GUID, 24))
2754                                 continue;
2755                         SET16(gmeta, pdr->entry[i].PD_Type,
2756                             GET16(gmeta, pdr->entry[i].PD_Type) &
2757                             ~(DDF_PDE_PARTICIPATING |
2758                               DDF_PDE_GLOBAL_SPARE | DDF_PDE_CONFIG_SPARE));
2759                         if ((GET16(gmeta, pdr->entry[i].PD_State) &
2760                             DDF_PDE_PFA) == 0)
2761                                 SET16(gmeta, pdr->entry[i].PD_State, 0);
2762                 }
2763         }
2764
2765         /* Generate/update new per-volume metadata. */
2766         TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2767                 pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2768                 if (vol->v_stopping || !pv->pv_started)
2769                         continue;
2770                 vmeta = &pv->pv_meta;
2771
2772                 SET32(vmeta, vdc->Sequence_Number,
2773                     GET32(vmeta, vdc->Sequence_Number) + 1);
2774                 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E &&
2775                     vol->v_disks_count % 2 == 0)
2776                         SET16(vmeta, vdc->Primary_Element_Count, 2);
2777                 else
2778                         SET16(vmeta, vdc->Primary_Element_Count,
2779                             vol->v_disks_count);
2780                 SET8(vmeta, vdc->Stripe_Size,
2781                     ffs(vol->v_strip_size / vol->v_sectorsize) - 1);
2782                 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E &&
2783                     vol->v_disks_count % 2 == 0) {
2784                         SET8(vmeta, vdc->Primary_RAID_Level,
2785                             DDF_VDCR_RAID1);
2786                         SET8(vmeta, vdc->RLQ, 0);
2787                         SET8(vmeta, vdc->Secondary_Element_Count,
2788                             vol->v_disks_count / 2);
2789                         SET8(vmeta, vdc->Secondary_RAID_Level, 0);
2790                 } else {
2791                         SET8(vmeta, vdc->Primary_RAID_Level,
2792                             vol->v_raid_level);
2793                         SET8(vmeta, vdc->RLQ,
2794                             vol->v_raid_level_qualifier);
2795                         SET8(vmeta, vdc->Secondary_Element_Count, 1);
2796                         SET8(vmeta, vdc->Secondary_RAID_Level, 0);
2797                 }
2798                 SET8(vmeta, vdc->Secondary_Element_Seq, 0);
2799                 SET64(vmeta, vdc->Block_Count, 0);
2800                 SET64(vmeta, vdc->VD_Size, vol->v_mediasize / vol->v_sectorsize);
2801                 SET16(vmeta, vdc->Block_Size, vol->v_sectorsize);
2802                 SET8(vmeta, vdc->Rotate_Parity_count,
2803                     fls(vol->v_rotate_parity) - 1);
2804                 SET8(vmeta, vdc->MDF_Parity_Disks, vol->v_mdf_pdisks);
2805                 SET16(vmeta, vdc->MDF_Parity_Generator_Polynomial,
2806                     vol->v_mdf_polynomial);
2807                 SET8(vmeta, vdc->MDF_Constant_Generation_Method,
2808                     vol->v_mdf_method);
2809
2810                 SET16(vmeta, vde->VD_Number, vol->v_global_id);
2811                 if (vol->v_state <= G_RAID_VOLUME_S_BROKEN)
2812                         SET8(vmeta, vde->VD_State, DDF_VDE_FAILED);
2813                 else if (vol->v_state <= G_RAID_VOLUME_S_DEGRADED)
2814                         SET8(vmeta, vde->VD_State, DDF_VDE_DEGRADED);
2815                 else if (vol->v_state <= G_RAID_VOLUME_S_SUBOPTIMAL)
2816                         SET8(vmeta, vde->VD_State, DDF_VDE_PARTIAL);
2817                 else
2818                         SET8(vmeta, vde->VD_State, DDF_VDE_OPTIMAL);
2819                 if (vol->v_dirty ||
2820                     g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_STALE) > 0 ||
2821                     g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_RESYNC) > 0)
2822                         SET8(vmeta, vde->VD_State,
2823                             GET8(vmeta, vde->VD_State) | DDF_VDE_DIRTY);
2824                 SET8(vmeta, vde->Init_State, DDF_VDE_INIT_FULL); // XXX
2825                 ddf_meta_put_name(vmeta, vol->v_name);
2826
2827                 for (i = 0; i < vol->v_disks_count; i++) {
2828                         sd = &vol->v_subdisks[i];
2829                         bvd = i / GET16(vmeta, vdc->Primary_Element_Count);
2830                         pos = i % GET16(vmeta, vdc->Primary_Element_Count);
2831                         disk = sd->sd_disk;
2832                         if (disk != NULL) {
2833                                 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
2834                                 if (vmeta->bvdc[bvd] == NULL) {
2835                                         size = GET16(vmeta,
2836                                             hdr->Configuration_Record_Length) *
2837                                             vmeta->sectorsize;
2838                                         vmeta->bvdc[bvd] = malloc(size,
2839                                             M_MD_DDF, M_WAITOK);
2840                                         memset(vmeta->bvdc[bvd], 0xff, size);
2841                                 }
2842                                 memcpy(vmeta->bvdc[bvd], vmeta->vdc,
2843                                     sizeof(struct ddf_vdc_record));
2844                                 SET8(vmeta, bvdc[bvd]->Secondary_Element_Seq, bvd);
2845                                 SET64(vmeta, bvdc[bvd]->Block_Count,
2846                                     sd->sd_size / vol->v_sectorsize);
2847                                 SET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos],
2848                                     GET32(&pd->pd_meta, pdd->PD_Reference));
2849                                 val2 = (uint64_t *)&(vmeta->bvdc[bvd]->Physical_Disk_Sequence[
2850                                     GET16(vmeta, hdr->Max_Primary_Element_Entries)]);
2851                                 SET64P(vmeta, val2 + pos,
2852                                     sd->sd_offset / vol->v_sectorsize);
2853                         }
2854                         if (vmeta->bvdc[bvd] == NULL)
2855                                 continue;
2856
2857                         j = ddf_meta_find_pd(gmeta, NULL,
2858                             GET32(vmeta, bvdc[bvd]->Physical_Disk_Sequence[pos]));
2859                         if (j < 0)
2860                                 continue;
2861                         SET16(gmeta, pdr->entry[j].PD_Type,
2862                             GET16(gmeta, pdr->entry[j].PD_Type) |
2863                             DDF_PDE_PARTICIPATING);
2864                         if (sd->sd_state == G_RAID_SUBDISK_S_NONE)
2865                                 SET16(gmeta, pdr->entry[j].PD_State,
2866                                     GET16(gmeta, pdr->entry[j].PD_State) |
2867                                     (DDF_PDE_FAILED | DDF_PDE_MISSING));
2868                         else if (sd->sd_state == G_RAID_SUBDISK_S_FAILED)
2869                                 SET16(gmeta, pdr->entry[j].PD_State,
2870                                     GET16(gmeta, pdr->entry[j].PD_State) |
2871                                     (DDF_PDE_FAILED | DDF_PDE_PFA));
2872                         else if (sd->sd_state <= G_RAID_SUBDISK_S_REBUILD)
2873                                 SET16(gmeta, pdr->entry[j].PD_State,
2874                                     GET16(gmeta, pdr->entry[j].PD_State) |
2875                                     DDF_PDE_REBUILD);
2876                         else
2877                                 SET16(gmeta, pdr->entry[j].PD_State,
2878                                     GET16(gmeta, pdr->entry[j].PD_State) |
2879                                     DDF_PDE_ONLINE);
2880                 }
2881         }
2882
2883         /* Mark spare and failed disks as such. */
2884         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2885                 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
2886                 i = ddf_meta_find_pd(gmeta, NULL,
2887                     GET32(&pd->pd_meta, pdd->PD_Reference));
2888                 if (i < 0)
2889                         continue;
2890                 if (disk->d_state == G_RAID_DISK_S_FAILED) {
2891                         SET16(gmeta, pdr->entry[i].PD_State,
2892                             GET16(gmeta, pdr->entry[i].PD_State) |
2893                             (DDF_PDE_FAILED | DDF_PDE_PFA));
2894                 }
2895                 if (disk->d_state != G_RAID_DISK_S_SPARE)
2896                         continue;
2897                 sa = ddf_meta_find_sa(&pd->pd_meta, 0);
2898                 if (sa == NULL ||
2899                     (GET8D(&pd->pd_meta, sa->Spare_Type) &
2900                      DDF_SAR_TYPE_DEDICATED) == 0) {
2901                         SET16(gmeta, pdr->entry[i].PD_Type,
2902                             GET16(gmeta, pdr->entry[i].PD_Type) |
2903                             DDF_PDE_GLOBAL_SPARE);
2904                 } else {
2905                         SET16(gmeta, pdr->entry[i].PD_Type,
2906                             GET16(gmeta, pdr->entry[i].PD_Type) |
2907                             DDF_PDE_CONFIG_SPARE);
2908                 }
2909                 SET16(gmeta, pdr->entry[i].PD_State,
2910                     GET16(gmeta, pdr->entry[i].PD_State) |
2911                     DDF_PDE_ONLINE);
2912         }
2913
2914         /* Remove disks without "participating" flag (unused). */
2915         for (i = 0, j = -1; i < GET16(gmeta, pdr->Populated_PDEs); i++) {
2916                 if (isff(gmeta->pdr->entry[i].PD_GUID, 24))
2917                         continue;
2918                 if ((GET16(gmeta, pdr->entry[i].PD_Type) &
2919                     (DDF_PDE_PARTICIPATING |
2920                      DDF_PDE_GLOBAL_SPARE | DDF_PDE_CONFIG_SPARE)) != 0 ||
2921                     g_raid_md_ddf_get_disk(sc,
2922                      NULL, GET32(gmeta, pdr->entry[i].PD_Reference)) != NULL)
2923                         j = i;
2924                 else
2925                         memset(&gmeta->pdr->entry[i], 0xff,
2926                             sizeof(struct ddf_pd_entry));
2927         }
2928         SET16(gmeta, pdr->Populated_PDEs, j + 1);
2929
2930         /* Update per-disk metadata and write them. */
2931         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
2932                 pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
2933                 if (disk->d_state != G_RAID_DISK_S_ACTIVE &&
2934                     disk->d_state != G_RAID_DISK_S_SPARE)
2935                         continue;
2936                 /* Update PDR. */
2937                 memcpy(pd->pd_meta.pdr, gmeta->pdr,
2938                     GET32(&pd->pd_meta, hdr->pdr_length) *
2939                     pd->pd_meta.sectorsize);
2940                 /* Update VDR. */
2941                 SET16(&pd->pd_meta, vdr->Populated_VDEs, 0);
2942                 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
2943                         if (vol->v_stopping)
2944                                 continue;
2945                         pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2946                         i = ddf_meta_find_vd(&pd->pd_meta,
2947                             pv->pv_meta.vde->VD_GUID);
2948                         if (i < 0)
2949                                 i = ddf_meta_find_vd(&pd->pd_meta, NULL);
2950                         if (i >= 0)
2951                                 memcpy(&pd->pd_meta.vdr->entry[i],
2952                                     pv->pv_meta.vde,
2953                                     sizeof(struct ddf_vd_entry));
2954                 }
2955                 /* Update VDC. */
2956                 if (mdi->mdio_starting == 0) {
2957                         /* Remove all VDCs to restore needed later. */
2958                         j = GETCRNUM(&pd->pd_meta);
2959                         for (i = 0; i < j; i++) {
2960                                 vdc = GETVDCPTR(&pd->pd_meta, i);
2961                                 if (GET32D(&pd->pd_meta, vdc->Signature) !=
2962                                     DDF_VDCR_SIGNATURE)
2963                                         continue;
2964                                 SET32D(&pd->pd_meta, vdc->Signature, 0xffffffff);
2965                         }
2966                 }
2967                 TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
2968                         vol = sd->sd_volume;
2969                         if (vol->v_stopping)
2970                                 continue;
2971                         pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
2972                         vmeta = &pv->pv_meta;
2973                         vdc = ddf_meta_find_vdc(&pd->pd_meta,
2974                             vmeta->vde->VD_GUID);
2975                         if (vdc == NULL)
2976                                 vdc = ddf_meta_find_vdc(&pd->pd_meta, NULL);
2977                         if (vdc != NULL) {
2978                                 bvd = sd->sd_pos / GET16(vmeta,
2979                                     vdc->Primary_Element_Count);
2980                                 memcpy(vdc, vmeta->bvdc[bvd],
2981                                     GET16(&pd->pd_meta,
2982                                     hdr->Configuration_Record_Length) *
2983                                     pd->pd_meta.sectorsize);
2984                         }
2985                 }
2986                 G_RAID_DEBUG(1, "Writing DDF metadata to %s",
2987                     g_raid_get_diskname(disk));
2988                 g_raid_md_ddf_print(&pd->pd_meta);
2989                 ddf_meta_write(disk->d_consumer, &pd->pd_meta);
2990         }
2991         return (0);
2992 }
2993
2994 static int
2995 g_raid_md_fail_disk_ddf(struct g_raid_md_object *md,
2996     struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
2997 {
2998         struct g_raid_softc *sc;
2999         struct g_raid_md_ddf_perdisk *pd;
3000         struct g_raid_subdisk *sd;
3001         int i;
3002
3003         sc = md->mdo_softc;
3004         pd = (struct g_raid_md_ddf_perdisk *)tdisk->d_md_data;
3005
3006         /* We can't fail disk that is not a part of array now. */
3007         if (tdisk->d_state != G_RAID_DISK_S_ACTIVE)
3008                 return (-1);
3009
3010         /*
3011          * Mark disk as failed in metadata and try to write that metadata
3012          * to the disk itself to prevent it's later resurrection as STALE.
3013          */
3014         G_RAID_DEBUG(1, "Writing DDF metadata to %s",
3015             g_raid_get_diskname(tdisk));
3016         i = ddf_meta_find_pd(&pd->pd_meta, NULL, GET32(&pd->pd_meta, pdd->PD_Reference));
3017         SET16(&pd->pd_meta, pdr->entry[i].PD_State, DDF_PDE_FAILED | DDF_PDE_PFA);
3018         if (tdisk->d_consumer != NULL)
3019                 ddf_meta_write(tdisk->d_consumer, &pd->pd_meta);
3020
3021         /* Change states. */
3022         g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED);
3023         TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) {
3024                 g_raid_change_subdisk_state(sd,
3025                     G_RAID_SUBDISK_S_FAILED);
3026                 g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED,
3027                     G_RAID_EVENT_SUBDISK);
3028         }
3029
3030         /* Write updated metadata to remaining disks. */
3031         g_raid_md_write_ddf(md, NULL, NULL, tdisk);
3032
3033         g_raid_md_ddf_refill(sc);
3034         return (0);
3035 }
3036
3037 static int
3038 g_raid_md_free_disk_ddf(struct g_raid_md_object *md,
3039     struct g_raid_disk *disk)
3040 {
3041         struct g_raid_md_ddf_perdisk *pd;
3042
3043         pd = (struct g_raid_md_ddf_perdisk *)disk->d_md_data;
3044         ddf_meta_free(&pd->pd_meta);
3045         free(pd, M_MD_DDF);
3046         disk->d_md_data = NULL;
3047         return (0);
3048 }
3049
3050 static int
3051 g_raid_md_free_volume_ddf(struct g_raid_md_object *md,
3052     struct g_raid_volume *vol)
3053 {
3054         struct g_raid_md_ddf_object *mdi;
3055         struct g_raid_md_ddf_pervolume *pv;
3056
3057         mdi = (struct g_raid_md_ddf_object *)md;
3058         pv = (struct g_raid_md_ddf_pervolume *)vol->v_md_data;
3059         ddf_vol_meta_free(&pv->pv_meta);
3060         if (!pv->pv_started) {
3061                 pv->pv_started = 1;
3062                 mdi->mdio_starting--;
3063                 callout_stop(&pv->pv_start_co);
3064         }
3065         free(pv, M_MD_DDF);
3066         vol->v_md_data = NULL;
3067         return (0);
3068 }
3069
3070 static int
3071 g_raid_md_free_ddf(struct g_raid_md_object *md)
3072 {
3073         struct g_raid_md_ddf_object *mdi;
3074
3075         mdi = (struct g_raid_md_ddf_object *)md;
3076         if (!mdi->mdio_started) {
3077                 mdi->mdio_started = 0;
3078                 callout_stop(&mdi->mdio_start_co);
3079                 G_RAID_DEBUG1(1, md->mdo_softc,
3080                     "root_mount_rel %p", mdi->mdio_rootmount);
3081                 root_mount_rel(mdi->mdio_rootmount);
3082                 mdi->mdio_rootmount = NULL;
3083         }
3084         ddf_meta_free(&mdi->mdio_meta);
3085         return (0);
3086 }
3087
3088 G_RAID_MD_DECLARE(ddf, "DDF");