The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/geom/raid/md_ddf.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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: releng/11.2/sys/geom/raid/md_ddf.c 298755 2016-04-28 19:26:46Z pfg $");
   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("**** Controller 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                             howmany(GET32(sample, hdr->WorkSpace_Length) *
  597                                 sample->sectorsize, ss));
  598                         SET16(meta, hdr->Configuration_Record_Length,
  599                             howmany(GET16(sample,
  600                                 hdr->Configuration_Record_Length) *
  601                                 sample->sectorsize, ss));
  602                         SET32(meta, hdr->cd_length,
  603                             howmany(GET32(sample, hdr->cd_length) *
  604                                 sample->sectorsize, ss));
  605                         SET32(meta, hdr->pdr_length,
  606                             howmany(GET32(sample, hdr->pdr_length) *
  607                                 sample->sectorsize, ss));
  608                         SET32(meta, hdr->vdr_length,
  609                             howmany(GET32(sample, hdr->vdr_length) *
  610                                 sample->sectorsize, ss));
  611                         SET32(meta, hdr->cr_length,
  612                             howmany(GET32(sample, hdr->cr_length) *
  613                                 sample->sectorsize, ss));
  614                         SET32(meta, hdr->pdd_length,
  615                             howmany(GET32(sample, hdr->pdd_length) *
  616                                 sample->sectorsize, ss));
  617                         SET32(meta, hdr->bbmlog_length,
  618                             howmany(GET32(sample, hdr->bbmlog_length) *
  619                                 sample->sectorsize, ss));
  620                         SET32(meta, hdr->Diagnostic_Space,
  621                             howmany(GET32(sample, hdr->bbmlog_length) *
  622                                 sample->sectorsize, ss));
  623                         SET32(meta, hdr->Vendor_Specific_Logs,
  624                             howmany(GET32(sample, hdr->bbmlog_length) *
  625                                 sample->sectorsize, ss));
  626                 }
  627         } else {
  628                 SET32(meta, hdr->Signature, DDF_HEADER_SIGNATURE);
  629                 snprintf(meta->hdr->DDF_Header_GUID, 25, "FreeBSD %08x%08x",
  630                     (u_int)(ts.tv_sec - DECADE), arc4random());
  631                 memcpy(meta->hdr->DDF_rev, "02.00.00", 8);
  632                 SET32(meta, hdr->TimeStamp, (ts.tv_sec - DECADE));
  633                 SET32(meta, hdr->WorkSpace_Length, 16 * 1024 * 1024 / ss);
  634                 SET16(meta, hdr->Max_PD_Entries, DDF_MAX_DISKS - 1);
  635                 SET16(meta, hdr->Max_VD_Entries, DDF_MAX_VDISKS);
  636                 SET16(meta, hdr->Max_Partitions, DDF_MAX_PARTITIONS);
  637                 SET16(meta, hdr->Max_Primary_Element_Entries, DDF_MAX_DISKS);
  638                 SET16(meta, hdr->Configuration_Record_Length,
  639                     howmany(sizeof(struct ddf_vdc_record) + (4 + 8) *
  640                         GET16(meta, hdr->Max_Primary_Element_Entries), ss));
  641                 SET32(meta, hdr->cd_length,
  642                     howmany(sizeof(struct ddf_cd_record), ss));
  643                 SET32(meta, hdr->pdr_length,
  644                     howmany(sizeof(struct ddf_pd_record) +
  645                         sizeof(struct ddf_pd_entry) * GET16(meta,
  646                         hdr->Max_PD_Entries), ss));
  647                 SET32(meta, hdr->vdr_length,
  648                     howmany(sizeof(struct ddf_vd_record) +
  649                         sizeof(struct ddf_vd_entry) *
  650                         GET16(meta, hdr->Max_VD_Entries), 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                     howmany(sizeof(struct ddf_pdd_record), 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");

Cache object: 601d05d3755c02b75db05baf9e27e1cf


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.