sys/geom/raid/md_ddf.c

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