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_intel.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) 2010 Alexander Motin <mav@FreeBSD.org>
    3  * Copyright (c) 2000 - 2008 Søren Schmidt <sos@FreeBSD.org>
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  */
   27 
   28 #include <sys/cdefs.h>
   29 __FBSDID("$FreeBSD$");
   30 
   31 #include <sys/param.h>
   32 #include <sys/bio.h>
   33 #include <sys/endian.h>
   34 #include <sys/kernel.h>
   35 #include <sys/kobj.h>
   36 #include <sys/limits.h>
   37 #include <sys/lock.h>
   38 #include <sys/malloc.h>
   39 #include <sys/mutex.h>
   40 #include <sys/systm.h>
   41 #include <sys/taskqueue.h>
   42 #include <geom/geom.h>
   43 #include "geom/raid/g_raid.h"
   44 #include "g_raid_md_if.h"
   45 
   46 static MALLOC_DEFINE(M_MD_INTEL, "md_intel_data", "GEOM_RAID Intel metadata");
   47 
   48 struct intel_raid_map {
   49         uint32_t        offset;
   50         uint32_t        disk_sectors;
   51         uint32_t        stripe_count;
   52         uint16_t        strip_sectors;
   53         uint8_t         status;
   54 #define INTEL_S_READY           0x00
   55 #define INTEL_S_UNINITIALIZED   0x01
   56 #define INTEL_S_DEGRADED        0x02
   57 #define INTEL_S_FAILURE         0x03
   58 
   59         uint8_t         type;
   60 #define INTEL_T_RAID0           0x00
   61 #define INTEL_T_RAID1           0x01
   62 #define INTEL_T_RAID5           0x05
   63 
   64         uint8_t         total_disks;
   65         uint8_t         total_domains;
   66         uint8_t         failed_disk_num;
   67         uint8_t         ddf;
   68         uint32_t        offset_hi;
   69         uint32_t        disk_sectors_hi;
   70         uint32_t        stripe_count_hi;
   71         uint32_t        filler_2[4];
   72         uint32_t        disk_idx[1];    /* total_disks entries. */
   73 #define INTEL_DI_IDX    0x00ffffff
   74 #define INTEL_DI_RBLD   0x01000000
   75 } __packed;
   76 
   77 struct intel_raid_vol {
   78         uint8_t         name[16];
   79         u_int64_t       total_sectors __packed;
   80         uint32_t        state;
   81 #define INTEL_ST_BOOTABLE               0x00000001
   82 #define INTEL_ST_BOOT_DEVICE            0x00000002
   83 #define INTEL_ST_READ_COALESCING        0x00000004
   84 #define INTEL_ST_WRITE_COALESCING       0x00000008
   85 #define INTEL_ST_LAST_SHUTDOWN_DIRTY    0x00000010
   86 #define INTEL_ST_HIDDEN_AT_BOOT         0x00000020
   87 #define INTEL_ST_CURRENTLY_HIDDEN       0x00000040
   88 #define INTEL_ST_VERIFY_AND_FIX         0x00000080
   89 #define INTEL_ST_MAP_STATE_UNINIT       0x00000100
   90 #define INTEL_ST_NO_AUTO_RECOVERY       0x00000200
   91 #define INTEL_ST_CLONE_N_GO             0x00000400
   92 #define INTEL_ST_CLONE_MAN_SYNC         0x00000800
   93 #define INTEL_ST_CNG_MASTER_DISK_NUM    0x00001000
   94         uint32_t        reserved;
   95         uint8_t         migr_priority;
   96         uint8_t         num_sub_vols;
   97         uint8_t         tid;
   98         uint8_t         cng_master_disk;
   99         uint16_t        cache_policy;
  100         uint8_t         cng_state;
  101 #define INTEL_CNGST_UPDATED             0
  102 #define INTEL_CNGST_NEEDS_UPDATE        1
  103 #define INTEL_CNGST_MASTER_MISSING      2
  104         uint8_t         cng_sub_state;
  105         uint32_t        filler_0[10];
  106 
  107         uint32_t        curr_migr_unit;
  108         uint32_t        checkpoint_id;
  109         uint8_t         migr_state;
  110         uint8_t         migr_type;
  111 #define INTEL_MT_INIT           0
  112 #define INTEL_MT_REBUILD        1
  113 #define INTEL_MT_VERIFY         2
  114 #define INTEL_MT_GEN_MIGR       3
  115 #define INTEL_MT_STATE_CHANGE   4
  116 #define INTEL_MT_REPAIR         5
  117         uint8_t         dirty;
  118         uint8_t         fs_state;
  119         uint16_t        verify_errors;
  120         uint16_t        bad_blocks;
  121         uint32_t        curr_migr_unit_hi;
  122         uint32_t        filler_1[3];
  123         struct intel_raid_map map[1];   /* 2 entries if migr_state != 0. */
  124 } __packed;
  125 
  126 struct intel_raid_disk {
  127 #define INTEL_SERIAL_LEN        16
  128         uint8_t         serial[INTEL_SERIAL_LEN];
  129         uint32_t        sectors;
  130         uint32_t        id;
  131         uint32_t        flags;
  132 #define INTEL_F_SPARE           0x01
  133 #define INTEL_F_ASSIGNED        0x02
  134 #define INTEL_F_FAILED          0x04
  135 #define INTEL_F_ONLINE          0x08
  136 #define INTEL_F_DISABLED        0x80
  137         uint32_t        owner_cfg_num;
  138         uint32_t        sectors_hi;
  139         uint32_t        filler[3];
  140 } __packed;
  141 
  142 struct intel_raid_conf {
  143         uint8_t         intel_id[24];
  144 #define INTEL_MAGIC             "Intel Raid ISM Cfg Sig. "
  145 
  146         uint8_t         version[6];
  147 #define INTEL_VERSION_1000      "1.0.00"        /* RAID0 */
  148 #define INTEL_VERSION_1100      "1.1.00"        /* RAID1 */
  149 #define INTEL_VERSION_1200      "1.2.00"        /* Many volumes */
  150 #define INTEL_VERSION_1201      "1.2.01"        /* 3 or 4 disks */
  151 #define INTEL_VERSION_1202      "1.2.02"        /* RAID5 */
  152 #define INTEL_VERSION_1204      "1.2.04"        /* 5 or 6 disks */
  153 #define INTEL_VERSION_1206      "1.2.06"        /* CNG */
  154 #define INTEL_VERSION_1300      "1.3.00"        /* Attributes */
  155 
  156         uint8_t         dummy_0[2];
  157         uint32_t        checksum;
  158         uint32_t        config_size;
  159         uint32_t        config_id;
  160         uint32_t        generation;
  161         uint32_t        error_log_size;
  162         uint32_t        attributes;
  163 #define INTEL_ATTR_RAID0        0x00000001
  164 #define INTEL_ATTR_RAID1        0x00000002
  165 #define INTEL_ATTR_RAID10       0x00000004
  166 #define INTEL_ATTR_RAID1E       0x00000008
  167 #define INTEL_ATTR_RAID5        0x00000010
  168 #define INTEL_ATTR_RAIDCNG      0x00000020
  169 #define INTEL_ATTR_EXT_STRIP    0x00000040
  170 #define INTEL_ATTR_NVM_CACHE    0x02000000
  171 #define INTEL_ATTR_2TB_DISK     0x04000000
  172 #define INTEL_ATTR_BBM          0x08000000
  173 #define INTEL_ATTR_NVM_CACHE2   0x10000000
  174 #define INTEL_ATTR_2TB          0x20000000
  175 #define INTEL_ATTR_PM           0x40000000
  176 #define INTEL_ATTR_CHECKSUM     0x80000000
  177 
  178         uint8_t         total_disks;
  179         uint8_t         total_volumes;
  180         uint8_t         error_log_pos;
  181         uint8_t         dummy_2[1];
  182         uint32_t        cache_size;
  183         uint32_t        orig_config_id;
  184         uint32_t        pwr_cycle_count;
  185         uint32_t        bbm_log_size;
  186         uint32_t        filler_0[35];
  187         struct intel_raid_disk  disk[1];        /* total_disks entries. */
  188         /* Here goes total_volumes of struct intel_raid_vol. */
  189 } __packed;
  190 
  191 #define INTEL_ATTR_SUPPORTED    ( INTEL_ATTR_RAID0 | INTEL_ATTR_RAID1 | \
  192     INTEL_ATTR_RAID10 | INTEL_ATTR_RAID1E | INTEL_ATTR_RAID5 |          \
  193     INTEL_ATTR_RAIDCNG | INTEL_ATTR_EXT_STRIP | INTEL_ATTR_2TB_DISK |   \
  194     INTEL_ATTR_2TB | INTEL_ATTR_PM | INTEL_ATTR_CHECKSUM )
  195 
  196 #define INTEL_MAX_MD_SIZE(ndisks)                               \
  197     (sizeof(struct intel_raid_conf) +                           \
  198      sizeof(struct intel_raid_disk) * (ndisks - 1) +            \
  199      sizeof(struct intel_raid_vol) * 2 +                        \
  200      sizeof(struct intel_raid_map) * 2 +                        \
  201      sizeof(uint32_t) * (ndisks - 1) * 4)
  202 
  203 struct g_raid_md_intel_perdisk {
  204         struct intel_raid_conf  *pd_meta;
  205         int                      pd_disk_pos;
  206         struct intel_raid_disk   pd_disk_meta;
  207 };
  208 
  209 struct g_raid_md_intel_pervolume {
  210         int                      pv_volume_pos;
  211         int                      pv_cng;
  212         int                      pv_cng_man_sync;
  213         int                      pv_cng_master_disk;
  214 };
  215 
  216 struct g_raid_md_intel_object {
  217         struct g_raid_md_object  mdio_base;
  218         uint32_t                 mdio_config_id;
  219         uint32_t                 mdio_orig_config_id;
  220         uint32_t                 mdio_generation;
  221         struct intel_raid_conf  *mdio_meta;
  222         struct callout           mdio_start_co; /* STARTING state timer. */
  223         int                      mdio_disks_present;
  224         int                      mdio_started;
  225         int                      mdio_incomplete;
  226         struct root_hold_token  *mdio_rootmount; /* Root mount delay token. */
  227 };
  228 
  229 static g_raid_md_create_t g_raid_md_create_intel;
  230 static g_raid_md_taste_t g_raid_md_taste_intel;
  231 static g_raid_md_event_t g_raid_md_event_intel;
  232 static g_raid_md_ctl_t g_raid_md_ctl_intel;
  233 static g_raid_md_write_t g_raid_md_write_intel;
  234 static g_raid_md_fail_disk_t g_raid_md_fail_disk_intel;
  235 static g_raid_md_free_disk_t g_raid_md_free_disk_intel;
  236 static g_raid_md_free_volume_t g_raid_md_free_volume_intel;
  237 static g_raid_md_free_t g_raid_md_free_intel;
  238 
  239 static kobj_method_t g_raid_md_intel_methods[] = {
  240         KOBJMETHOD(g_raid_md_create,    g_raid_md_create_intel),
  241         KOBJMETHOD(g_raid_md_taste,     g_raid_md_taste_intel),
  242         KOBJMETHOD(g_raid_md_event,     g_raid_md_event_intel),
  243         KOBJMETHOD(g_raid_md_ctl,       g_raid_md_ctl_intel),
  244         KOBJMETHOD(g_raid_md_write,     g_raid_md_write_intel),
  245         KOBJMETHOD(g_raid_md_fail_disk, g_raid_md_fail_disk_intel),
  246         KOBJMETHOD(g_raid_md_free_disk, g_raid_md_free_disk_intel),
  247         KOBJMETHOD(g_raid_md_free_volume,       g_raid_md_free_volume_intel),
  248         KOBJMETHOD(g_raid_md_free,      g_raid_md_free_intel),
  249         { 0, 0 }
  250 };
  251 
  252 static struct g_raid_md_class g_raid_md_intel_class = {
  253         "Intel",
  254         g_raid_md_intel_methods,
  255         sizeof(struct g_raid_md_intel_object),
  256         .mdc_enable = 1,
  257         .mdc_priority = 100
  258 };
  259 
  260 
  261 static struct intel_raid_map *
  262 intel_get_map(struct intel_raid_vol *mvol, int i)
  263 {
  264         struct intel_raid_map *mmap;
  265 
  266         if (i > (mvol->migr_state ? 1 : 0))
  267                 return (NULL);
  268         mmap = &mvol->map[0];
  269         for (; i > 0; i--) {
  270                 mmap = (struct intel_raid_map *)
  271                     &mmap->disk_idx[mmap->total_disks];
  272         }
  273         return ((struct intel_raid_map *)mmap);
  274 }
  275 
  276 static struct intel_raid_vol *
  277 intel_get_volume(struct intel_raid_conf *meta, int i)
  278 {
  279         struct intel_raid_vol *mvol;
  280         struct intel_raid_map *mmap;
  281 
  282         if (i > 1)
  283                 return (NULL);
  284         mvol = (struct intel_raid_vol *)&meta->disk[meta->total_disks];
  285         for (; i > 0; i--) {
  286                 mmap = intel_get_map(mvol, mvol->migr_state ? 1 : 0);
  287                 mvol = (struct intel_raid_vol *)
  288                     &mmap->disk_idx[mmap->total_disks];
  289         }
  290         return (mvol);
  291 }
  292 
  293 static off_t
  294 intel_get_map_offset(struct intel_raid_map *mmap)
  295 {
  296         off_t offset = (off_t)mmap->offset_hi << 32;
  297 
  298         offset += mmap->offset;
  299         return (offset);
  300 }
  301 
  302 static void
  303 intel_set_map_offset(struct intel_raid_map *mmap, off_t offset)
  304 {
  305 
  306         mmap->offset = offset & 0xffffffff;
  307         mmap->offset_hi = offset >> 32;
  308 }
  309 
  310 static off_t
  311 intel_get_map_disk_sectors(struct intel_raid_map *mmap)
  312 {
  313         off_t disk_sectors = (off_t)mmap->disk_sectors_hi << 32;
  314 
  315         disk_sectors += mmap->disk_sectors;
  316         return (disk_sectors);
  317 }
  318 
  319 static void
  320 intel_set_map_disk_sectors(struct intel_raid_map *mmap, off_t disk_sectors)
  321 {
  322 
  323         mmap->disk_sectors = disk_sectors & 0xffffffff;
  324         mmap->disk_sectors_hi = disk_sectors >> 32;
  325 }
  326 
  327 static void
  328 intel_set_map_stripe_count(struct intel_raid_map *mmap, off_t stripe_count)
  329 {
  330 
  331         mmap->stripe_count = stripe_count & 0xffffffff;
  332         mmap->stripe_count_hi = stripe_count >> 32;
  333 }
  334 
  335 static off_t
  336 intel_get_disk_sectors(struct intel_raid_disk *disk)
  337 {
  338         off_t sectors = (off_t)disk->sectors_hi << 32;
  339 
  340         sectors += disk->sectors;
  341         return (sectors);
  342 }
  343 
  344 static void
  345 intel_set_disk_sectors(struct intel_raid_disk *disk, off_t sectors)
  346 {
  347 
  348         disk->sectors = sectors & 0xffffffff;
  349         disk->sectors_hi = sectors >> 32;
  350 }
  351 
  352 static off_t
  353 intel_get_vol_curr_migr_unit(struct intel_raid_vol *vol)
  354 {
  355         off_t curr_migr_unit = (off_t)vol->curr_migr_unit_hi << 32;
  356 
  357         curr_migr_unit += vol->curr_migr_unit;
  358         return (curr_migr_unit);
  359 }
  360 
  361 static void
  362 intel_set_vol_curr_migr_unit(struct intel_raid_vol *vol, off_t curr_migr_unit)
  363 {
  364 
  365         vol->curr_migr_unit = curr_migr_unit & 0xffffffff;
  366         vol->curr_migr_unit_hi = curr_migr_unit >> 32;
  367 }
  368 
  369 static char *
  370 intel_status2str(int status)
  371 {
  372 
  373         switch (status) {
  374         case INTEL_S_READY:
  375                 return ("READY");
  376         case INTEL_S_UNINITIALIZED:
  377                 return ("UNINITIALIZED");
  378         case INTEL_S_DEGRADED:
  379                 return ("DEGRADED");
  380         case INTEL_S_FAILURE:
  381                 return ("FAILURE");
  382         default:
  383                 return ("UNKNOWN");
  384         }
  385 }
  386 
  387 static char *
  388 intel_type2str(int type)
  389 {
  390 
  391         switch (type) {
  392         case INTEL_T_RAID0:
  393                 return ("RAID0");
  394         case INTEL_T_RAID1:
  395                 return ("RAID1");
  396         case INTEL_T_RAID5:
  397                 return ("RAID5");
  398         default:
  399                 return ("UNKNOWN");
  400         }
  401 }
  402 
  403 static char *
  404 intel_cngst2str(int cng_state)
  405 {
  406 
  407         switch (cng_state) {
  408         case INTEL_CNGST_UPDATED:
  409                 return ("UPDATED");
  410         case INTEL_CNGST_NEEDS_UPDATE:
  411                 return ("NEEDS_UPDATE");
  412         case INTEL_CNGST_MASTER_MISSING:
  413                 return ("MASTER_MISSING");
  414         default:
  415                 return ("UNKNOWN");
  416         }
  417 }
  418 
  419 static char *
  420 intel_mt2str(int type)
  421 {
  422 
  423         switch (type) {
  424         case INTEL_MT_INIT:
  425                 return ("INIT");
  426         case INTEL_MT_REBUILD:
  427                 return ("REBUILD");
  428         case INTEL_MT_VERIFY:
  429                 return ("VERIFY");
  430         case INTEL_MT_GEN_MIGR:
  431                 return ("GEN_MIGR");
  432         case INTEL_MT_STATE_CHANGE:
  433                 return ("STATE_CHANGE");
  434         case INTEL_MT_REPAIR:
  435                 return ("REPAIR");
  436         default:
  437                 return ("UNKNOWN");
  438         }
  439 }
  440 
  441 static void
  442 g_raid_md_intel_print(struct intel_raid_conf *meta)
  443 {
  444         struct intel_raid_vol *mvol;
  445         struct intel_raid_map *mmap;
  446         int i, j, k;
  447 
  448         if (g_raid_debug < 1)
  449                 return;
  450 
  451         printf("********* ATA Intel MatrixRAID Metadata *********\n");
  452         printf("intel_id            <%.24s>\n", meta->intel_id);
  453         printf("version             <%.6s>\n", meta->version);
  454         printf("checksum            0x%08x\n", meta->checksum);
  455         printf("config_size         0x%08x\n", meta->config_size);
  456         printf("config_id           0x%08x\n", meta->config_id);
  457         printf("generation          0x%08x\n", meta->generation);
  458         printf("error_log_size      %d\n", meta->error_log_size);
  459         printf("attributes          0x%b\n", meta->attributes,
  460                 "\020"
  461                 "\001RAID0"
  462                 "\002RAID1"
  463                 "\003RAID10"
  464                 "\004RAID1E"
  465                 "\005RAID15"
  466                 "\006RAIDCNG"
  467                 "\007EXT_STRIP"
  468                 "\032NVM_CACHE"
  469                 "\0332TB_DISK"
  470                 "\034BBM"
  471                 "\035NVM_CACHE"
  472                 "\0362TB"
  473                 "\037PM"
  474                 "\040CHECKSUM");
  475         printf("total_disks         %u\n", meta->total_disks);
  476         printf("total_volumes       %u\n", meta->total_volumes);
  477         printf("error_log_pos       %u\n", meta->error_log_pos);
  478         printf("cache_size          %u\n", meta->cache_size);
  479         printf("orig_config_id      0x%08x\n", meta->orig_config_id);
  480         printf("pwr_cycle_count     %u\n", meta->pwr_cycle_count);
  481         printf("bbm_log_size        %u\n", meta->bbm_log_size);
  482         printf("Flags: S - Spare, A - Assigned, F - Failed, O - Online, D - Disabled\n");
  483         printf("DISK#   serial disk_sectors disk_sectors_hi disk_id flags owner\n");
  484         for (i = 0; i < meta->total_disks; i++ ) {
  485                 printf("    %d   <%.16s> %u %u 0x%08x 0x%b %08x\n", i,
  486                     meta->disk[i].serial, meta->disk[i].sectors,
  487                     meta->disk[i].sectors_hi, meta->disk[i].id,
  488                     meta->disk[i].flags, "\2\01S\02A\03F\04O\05D",
  489                     meta->disk[i].owner_cfg_num);
  490         }
  491         for (i = 0; i < meta->total_volumes; i++) {
  492                 mvol = intel_get_volume(meta, i);
  493                 printf(" ****** Volume %d ******\n", i);
  494                 printf(" name               %.16s\n", mvol->name);
  495                 printf(" total_sectors      %ju\n", mvol->total_sectors);
  496                 printf(" state              0x%b\n", mvol->state,
  497                         "\020"
  498                         "\001BOOTABLE"
  499                         "\002BOOT_DEVICE"
  500                         "\003READ_COALESCING"
  501                         "\004WRITE_COALESCING"
  502                         "\005LAST_SHUTDOWN_DIRTY"
  503                         "\006HIDDEN_AT_BOOT"
  504                         "\007CURRENTLY_HIDDEN"
  505                         "\010VERIFY_AND_FIX"
  506                         "\011MAP_STATE_UNINIT"
  507                         "\012NO_AUTO_RECOVERY"
  508                         "\013CLONE_N_GO"
  509                         "\014CLONE_MAN_SYNC"
  510                         "\015CNG_MASTER_DISK_NUM");
  511                 printf(" reserved           %u\n", mvol->reserved);
  512                 printf(" migr_priority      %u\n", mvol->migr_priority);
  513                 printf(" num_sub_vols       %u\n", mvol->num_sub_vols);
  514                 printf(" tid                %u\n", mvol->tid);
  515                 printf(" cng_master_disk    %u\n", mvol->cng_master_disk);
  516                 printf(" cache_policy       %u\n", mvol->cache_policy);
  517                 printf(" cng_state          %u (%s)\n", mvol->cng_state,
  518                         intel_cngst2str(mvol->cng_state));
  519                 printf(" cng_sub_state      %u\n", mvol->cng_sub_state);
  520                 printf(" curr_migr_unit     %u\n", mvol->curr_migr_unit);
  521                 printf(" curr_migr_unit_hi  %u\n", mvol->curr_migr_unit_hi);
  522                 printf(" checkpoint_id      %u\n", mvol->checkpoint_id);
  523                 printf(" migr_state         %u\n", mvol->migr_state);
  524                 printf(" migr_type          %u (%s)\n", mvol->migr_type,
  525                         intel_mt2str(mvol->migr_type));
  526                 printf(" dirty              %u\n", mvol->dirty);
  527                 printf(" fs_state           %u\n", mvol->fs_state);
  528                 printf(" verify_errors      %u\n", mvol->verify_errors);
  529                 printf(" bad_blocks         %u\n", mvol->bad_blocks);
  530 
  531                 for (j = 0; j < (mvol->migr_state ? 2 : 1); j++) {
  532                         printf("  *** Map %d ***\n", j);
  533                         mmap = intel_get_map(mvol, j);
  534                         printf("  offset            %u\n", mmap->offset);
  535                         printf("  offset_hi         %u\n", mmap->offset_hi);
  536                         printf("  disk_sectors      %u\n", mmap->disk_sectors);
  537                         printf("  disk_sectors_hi   %u\n", mmap->disk_sectors_hi);
  538                         printf("  stripe_count      %u\n", mmap->stripe_count);
  539                         printf("  stripe_count_hi   %u\n", mmap->stripe_count_hi);
  540                         printf("  strip_sectors     %u\n", mmap->strip_sectors);
  541                         printf("  status            %u (%s)\n", mmap->status,
  542                                 intel_status2str(mmap->status));
  543                         printf("  type              %u (%s)\n", mmap->type,
  544                                 intel_type2str(mmap->type));
  545                         printf("  total_disks       %u\n", mmap->total_disks);
  546                         printf("  total_domains     %u\n", mmap->total_domains);
  547                         printf("  failed_disk_num   %u\n", mmap->failed_disk_num);
  548                         printf("  ddf               %u\n", mmap->ddf);
  549                         printf("  disk_idx         ");
  550                         for (k = 0; k < mmap->total_disks; k++)
  551                                 printf(" 0x%08x", mmap->disk_idx[k]);
  552                         printf("\n");
  553                 }
  554         }
  555         printf("=================================================\n");
  556 }
  557 
  558 static struct intel_raid_conf *
  559 intel_meta_copy(struct intel_raid_conf *meta)
  560 {
  561         struct intel_raid_conf *nmeta;
  562 
  563         nmeta = malloc(meta->config_size, M_MD_INTEL, M_WAITOK);
  564         memcpy(nmeta, meta, meta->config_size);
  565         return (nmeta);
  566 }
  567 
  568 static int
  569 intel_meta_find_disk(struct intel_raid_conf *meta, char *serial)
  570 {
  571         int pos;
  572 
  573         for (pos = 0; pos < meta->total_disks; pos++) {
  574                 if (strncmp(meta->disk[pos].serial,
  575                     serial, INTEL_SERIAL_LEN) == 0)
  576                         return (pos);
  577         }
  578         return (-1);
  579 }
  580 
  581 static struct intel_raid_conf *
  582 intel_meta_read(struct g_consumer *cp)
  583 {
  584         struct g_provider *pp;
  585         struct intel_raid_conf *meta;
  586         struct intel_raid_vol *mvol;
  587         struct intel_raid_map *mmap, *mmap1;
  588         char *buf;
  589         int error, i, j, k, left, size;
  590         uint32_t checksum, *ptr;
  591 
  592         pp = cp->provider;
  593 
  594         /* Read the anchor sector. */
  595         buf = g_read_data(cp,
  596             pp->mediasize - pp->sectorsize * 2, pp->sectorsize, &error);
  597         if (buf == NULL) {
  598                 G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).",
  599                     pp->name, error);
  600                 return (NULL);
  601         }
  602         meta = (struct intel_raid_conf *)buf;
  603 
  604         /* Check if this is an Intel RAID struct */
  605         if (strncmp(meta->intel_id, INTEL_MAGIC, strlen(INTEL_MAGIC))) {
  606                 G_RAID_DEBUG(1, "Intel signature check failed on %s", pp->name);
  607                 g_free(buf);
  608                 return (NULL);
  609         }
  610         if (meta->config_size > 65536 ||
  611             meta->config_size < sizeof(struct intel_raid_conf)) {
  612                 G_RAID_DEBUG(1, "Intel metadata size looks wrong: %d",
  613                     meta->config_size);
  614                 g_free(buf);
  615                 return (NULL);
  616         }
  617         size = meta->config_size;
  618         meta = malloc(size, M_MD_INTEL, M_WAITOK);
  619         memcpy(meta, buf, min(size, pp->sectorsize));
  620         g_free(buf);
  621 
  622         /* Read all the rest, if needed. */
  623         if (meta->config_size > pp->sectorsize) {
  624                 left = (meta->config_size - 1) / pp->sectorsize;
  625                 buf = g_read_data(cp,
  626                     pp->mediasize - pp->sectorsize * (2 + left),
  627                     pp->sectorsize * left, &error);
  628                 if (buf == NULL) {
  629                         G_RAID_DEBUG(1, "Cannot read remaining metadata"
  630                             " part from %s (error=%d).",
  631                             pp->name, error);
  632                         free(meta, M_MD_INTEL);
  633                         return (NULL);
  634                 }
  635                 memcpy(((char *)meta) + pp->sectorsize, buf,
  636                     pp->sectorsize * left);
  637                 g_free(buf);
  638         }
  639 
  640         /* Check metadata checksum. */
  641         for (checksum = 0, ptr = (uint32_t *)meta, i = 0;
  642             i < (meta->config_size / sizeof(uint32_t)); i++) {
  643                 checksum += *ptr++;
  644         }
  645         checksum -= meta->checksum;
  646         if (checksum != meta->checksum) {
  647                 G_RAID_DEBUG(1, "Intel checksum check failed on %s", pp->name);
  648                 free(meta, M_MD_INTEL);
  649                 return (NULL);
  650         }
  651 
  652         /* Validate metadata size. */
  653         size = sizeof(struct intel_raid_conf) +
  654             sizeof(struct intel_raid_disk) * (meta->total_disks - 1) +
  655             sizeof(struct intel_raid_vol) * meta->total_volumes;
  656         if (size > meta->config_size) {
  657 badsize:
  658                 G_RAID_DEBUG(1, "Intel metadata size incorrect %d < %d",
  659                     meta->config_size, size);
  660                 free(meta, M_MD_INTEL);
  661                 return (NULL);
  662         }
  663         for (i = 0; i < meta->total_volumes; i++) {
  664                 mvol = intel_get_volume(meta, i);
  665                 mmap = intel_get_map(mvol, 0);
  666                 size += 4 * (mmap->total_disks - 1);
  667                 if (size > meta->config_size)
  668                         goto badsize;
  669                 if (mvol->migr_state) {
  670                         size += sizeof(struct intel_raid_map);
  671                         if (size > meta->config_size)
  672                                 goto badsize;
  673                         mmap = intel_get_map(mvol, 1);
  674                         size += 4 * (mmap->total_disks - 1);
  675                         if (size > meta->config_size)
  676                                 goto badsize;
  677                 }
  678         }
  679 
  680         g_raid_md_intel_print(meta);
  681 
  682         if (strncmp(meta->version, INTEL_VERSION_1300, 6) > 0) {
  683                 G_RAID_DEBUG(1, "Intel unsupported version: '%.6s'",
  684                     meta->version);
  685                 free(meta, M_MD_INTEL);
  686                 return (NULL);
  687         }
  688 
  689         if (strncmp(meta->version, INTEL_VERSION_1300, 6) >= 0 &&
  690             (meta->attributes & ~INTEL_ATTR_SUPPORTED) != 0) {
  691                 G_RAID_DEBUG(1, "Intel unsupported attributes: 0x%08x",
  692                     meta->attributes & ~INTEL_ATTR_SUPPORTED);
  693                 free(meta, M_MD_INTEL);
  694                 return (NULL);
  695         }
  696 
  697         /* Validate disk indexes. */
  698         for (i = 0; i < meta->total_volumes; i++) {
  699                 mvol = intel_get_volume(meta, i);
  700                 for (j = 0; j < (mvol->migr_state ? 2 : 1); j++) {
  701                         mmap = intel_get_map(mvol, j);
  702                         for (k = 0; k < mmap->total_disks; k++) {
  703                                 if ((mmap->disk_idx[k] & INTEL_DI_IDX) >
  704                                     meta->total_disks) {
  705                                         G_RAID_DEBUG(1, "Intel metadata disk"
  706                                             " index %d too big (>%d)",
  707                                             mmap->disk_idx[k] & INTEL_DI_IDX,
  708                                             meta->total_disks);
  709                                         free(meta, M_MD_INTEL);
  710                                         return (NULL);
  711                                 }
  712                         }
  713                 }
  714         }
  715 
  716         /* Validate migration types. */
  717         for (i = 0; i < meta->total_volumes; i++) {
  718                 mvol = intel_get_volume(meta, i);
  719                 /* Deny unknown migration types. */
  720                 if (mvol->migr_state &&
  721                     mvol->migr_type != INTEL_MT_INIT &&
  722                     mvol->migr_type != INTEL_MT_REBUILD &&
  723                     mvol->migr_type != INTEL_MT_VERIFY &&
  724                     mvol->migr_type != INTEL_MT_GEN_MIGR &&
  725                     mvol->migr_type != INTEL_MT_REPAIR) {
  726                         G_RAID_DEBUG(1, "Intel metadata has unsupported"
  727                             " migration type %d", mvol->migr_type);
  728                         free(meta, M_MD_INTEL);
  729                         return (NULL);
  730                 }
  731                 /* Deny general migrations except SINGLE->RAID1. */
  732                 if (mvol->migr_state &&
  733                     mvol->migr_type == INTEL_MT_GEN_MIGR) {
  734                         mmap = intel_get_map(mvol, 0);
  735                         mmap1 = intel_get_map(mvol, 1);
  736                         if (mmap1->total_disks != 1 ||
  737                             mmap->type != INTEL_T_RAID1 ||
  738                             mmap->total_disks != 2 ||
  739                             mmap->offset != mmap1->offset ||
  740                             mmap->disk_sectors != mmap1->disk_sectors ||
  741                             mmap->total_domains != mmap->total_disks ||
  742                             mmap->offset_hi != mmap1->offset_hi ||
  743                             mmap->disk_sectors_hi != mmap1->disk_sectors_hi ||
  744                             (mmap->disk_idx[0] != mmap1->disk_idx[0] &&
  745                              mmap->disk_idx[0] != mmap1->disk_idx[1])) {
  746                                 G_RAID_DEBUG(1, "Intel metadata has unsupported"
  747                                     " variant of general migration");
  748                                 free(meta, M_MD_INTEL);
  749                                 return (NULL);
  750                         }
  751                 }
  752         }
  753 
  754         return (meta);
  755 }
  756 
  757 static int
  758 intel_meta_write(struct g_consumer *cp, struct intel_raid_conf *meta)
  759 {
  760         struct g_provider *pp;
  761         char *buf;
  762         int error, i, sectors;
  763         uint32_t checksum, *ptr;
  764 
  765         pp = cp->provider;
  766 
  767         /* Recalculate checksum for case if metadata were changed. */
  768         meta->checksum = 0;
  769         for (checksum = 0, ptr = (uint32_t *)meta, i = 0;
  770             i < (meta->config_size / sizeof(uint32_t)); i++) {
  771                 checksum += *ptr++;
  772         }
  773         meta->checksum = checksum;
  774 
  775         /* Create and fill buffer. */
  776         sectors = (meta->config_size + pp->sectorsize - 1) / pp->sectorsize;
  777         buf = malloc(sectors * pp->sectorsize, M_MD_INTEL, M_WAITOK | M_ZERO);
  778         if (sectors > 1) {
  779                 memcpy(buf, ((char *)meta) + pp->sectorsize,
  780                     (sectors - 1) * pp->sectorsize);
  781         }
  782         memcpy(buf + (sectors - 1) * pp->sectorsize, meta, pp->sectorsize);
  783 
  784         error = g_write_data(cp,
  785             pp->mediasize - pp->sectorsize * (1 + sectors),
  786             buf, pp->sectorsize * sectors);
  787         if (error != 0) {
  788                 G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).",
  789                     pp->name, error);
  790         }
  791 
  792         free(buf, M_MD_INTEL);
  793         return (error);
  794 }
  795 
  796 static int
  797 intel_meta_erase(struct g_consumer *cp)
  798 {
  799         struct g_provider *pp;
  800         char *buf;
  801         int error;
  802 
  803         pp = cp->provider;
  804         buf = malloc(pp->sectorsize, M_MD_INTEL, M_WAITOK | M_ZERO);
  805         error = g_write_data(cp,
  806             pp->mediasize - 2 * pp->sectorsize,
  807             buf, pp->sectorsize);
  808         if (error != 0) {
  809                 G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).",
  810                     pp->name, error);
  811         }
  812         free(buf, M_MD_INTEL);
  813         return (error);
  814 }
  815 
  816 static int
  817 intel_meta_write_spare(struct g_consumer *cp, struct intel_raid_disk *d)
  818 {
  819         struct intel_raid_conf *meta;
  820         int error;
  821 
  822         /* Fill anchor and single disk. */
  823         meta = malloc(INTEL_MAX_MD_SIZE(1), M_MD_INTEL, M_WAITOK | M_ZERO);
  824         memcpy(&meta->intel_id[0], INTEL_MAGIC, sizeof(INTEL_MAGIC) - 1);
  825         memcpy(&meta->version[0], INTEL_VERSION_1000,
  826             sizeof(INTEL_VERSION_1000) - 1);
  827         meta->config_size = INTEL_MAX_MD_SIZE(1);
  828         meta->config_id = meta->orig_config_id = arc4random();
  829         meta->generation = 1;
  830         meta->total_disks = 1;
  831         meta->disk[0] = *d;
  832         error = intel_meta_write(cp, meta);
  833         free(meta, M_MD_INTEL);
  834         return (error);
  835 }
  836 
  837 static struct g_raid_disk *
  838 g_raid_md_intel_get_disk(struct g_raid_softc *sc, int id)
  839 {
  840         struct g_raid_disk      *disk;
  841         struct g_raid_md_intel_perdisk *pd;
  842 
  843         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
  844                 pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
  845                 if (pd->pd_disk_pos == id)
  846                         break;
  847         }
  848         return (disk);
  849 }
  850 
  851 static int
  852 g_raid_md_intel_supported(int level, int qual, int disks, int force)
  853 {
  854 
  855         switch (level) {
  856         case G_RAID_VOLUME_RL_RAID0:
  857                 if (disks < 1)
  858                         return (0);
  859                 if (!force && (disks < 2 || disks > 6))
  860                         return (0);
  861                 break;
  862         case G_RAID_VOLUME_RL_RAID1:
  863                 if (disks < 1)
  864                         return (0);
  865                 if (!force && (disks != 2))
  866                         return (0);
  867                 break;
  868         case G_RAID_VOLUME_RL_RAID1E:
  869                 if (disks < 2)
  870                         return (0);
  871                 if (!force && (disks != 4))
  872                         return (0);
  873                 break;
  874         case G_RAID_VOLUME_RL_RAID5:
  875                 if (disks < 3)
  876                         return (0);
  877                 if (!force && disks > 6)
  878                         return (0);
  879                 if (qual != G_RAID_VOLUME_RLQ_R5LA)
  880                         return (0);
  881                 break;
  882         default:
  883                 return (0);
  884         }
  885         if (level != G_RAID_VOLUME_RL_RAID5 && qual != G_RAID_VOLUME_RLQ_NONE)
  886                 return (0);
  887         return (1);
  888 }
  889 
  890 static struct g_raid_volume *
  891 g_raid_md_intel_get_volume(struct g_raid_softc *sc, int id)
  892 {
  893         struct g_raid_volume    *mvol;
  894         struct g_raid_md_intel_pervolume *pv;
  895 
  896         TAILQ_FOREACH(mvol, &sc->sc_volumes, v_next) {
  897                 pv = mvol->v_md_data;
  898                 if (pv->pv_volume_pos == id)
  899                         break;
  900         }
  901         return (mvol);
  902 }
  903 
  904 static int
  905 g_raid_md_intel_start_disk(struct g_raid_disk *disk)
  906 {
  907         struct g_raid_softc *sc;
  908         struct g_raid_subdisk *sd, *tmpsd;
  909         struct g_raid_disk *olddisk, *tmpdisk;
  910         struct g_raid_md_object *md;
  911         struct g_raid_md_intel_object *mdi;
  912         struct g_raid_md_intel_pervolume *pv;
  913         struct g_raid_md_intel_perdisk *pd, *oldpd;
  914         struct intel_raid_conf *meta;
  915         struct intel_raid_vol *mvol;
  916         struct intel_raid_map *mmap0, *mmap1;
  917         int disk_pos, resurrection = 0, migr_global, i;
  918 
  919         sc = disk->d_softc;
  920         md = sc->sc_md;
  921         mdi = (struct g_raid_md_intel_object *)md;
  922         meta = mdi->mdio_meta;
  923         pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
  924         olddisk = NULL;
  925 
  926         /* Find disk position in metadata by it's serial. */
  927         disk_pos = intel_meta_find_disk(meta, pd->pd_disk_meta.serial);
  928         if (disk_pos < 0) {
  929                 G_RAID_DEBUG1(1, sc, "Unknown, probably new or stale disk");
  930                 /* Failed stale disk is useless for us. */
  931                 if ((pd->pd_disk_meta.flags & INTEL_F_FAILED) &&
  932                     !(pd->pd_disk_meta.flags & INTEL_F_DISABLED)) {
  933                         g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED);
  934                         return (0);
  935                 }
  936                 /* If we are in the start process, that's all for now. */
  937                 if (!mdi->mdio_started)
  938                         goto nofit;
  939                 /*
  940                  * If we have already started - try to get use of the disk.
  941                  * Try to replace OFFLINE disks first, then FAILED.
  942                  */
  943                 TAILQ_FOREACH(tmpdisk, &sc->sc_disks, d_next) {
  944                         if (tmpdisk->d_state != G_RAID_DISK_S_OFFLINE &&
  945                             tmpdisk->d_state != G_RAID_DISK_S_FAILED)
  946                                 continue;
  947                         /* Make sure this disk is big enough. */
  948                         TAILQ_FOREACH(sd, &tmpdisk->d_subdisks, sd_next) {
  949                                 off_t disk_sectors = 
  950                                     intel_get_disk_sectors(&pd->pd_disk_meta);
  951 
  952                                 if (sd->sd_offset + sd->sd_size + 4096 >
  953                                     disk_sectors * 512) {
  954                                         G_RAID_DEBUG1(1, sc,
  955                                             "Disk too small (%llu < %llu)",
  956                                             (unsigned long long)
  957                                             disk_sectors * 512,
  958                                             (unsigned long long)
  959                                             sd->sd_offset + sd->sd_size + 4096);
  960                                         break;
  961                                 }
  962                         }
  963                         if (sd != NULL)
  964                                 continue;
  965                         if (tmpdisk->d_state == G_RAID_DISK_S_OFFLINE) {
  966                                 olddisk = tmpdisk;
  967                                 break;
  968                         } else if (olddisk == NULL)
  969                                 olddisk = tmpdisk;
  970                 }
  971                 if (olddisk == NULL) {
  972 nofit:
  973                         if (pd->pd_disk_meta.flags & INTEL_F_SPARE) {
  974                                 g_raid_change_disk_state(disk,
  975                                     G_RAID_DISK_S_SPARE);
  976                                 return (1);
  977                         } else {
  978                                 g_raid_change_disk_state(disk,
  979                                     G_RAID_DISK_S_STALE);
  980                                 return (0);
  981                         }
  982                 }
  983                 oldpd = (struct g_raid_md_intel_perdisk *)olddisk->d_md_data;
  984                 disk_pos = oldpd->pd_disk_pos;
  985                 resurrection = 1;
  986         }
  987 
  988         if (olddisk == NULL) {
  989                 /* Find placeholder by position. */
  990                 olddisk = g_raid_md_intel_get_disk(sc, disk_pos);
  991                 if (olddisk == NULL)
  992                         panic("No disk at position %d!", disk_pos);
  993                 if (olddisk->d_state != G_RAID_DISK_S_OFFLINE) {
  994                         G_RAID_DEBUG1(1, sc, "More then one disk for pos %d",
  995                             disk_pos);
  996                         g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE);
  997                         return (0);
  998                 }
  999                 oldpd = (struct g_raid_md_intel_perdisk *)olddisk->d_md_data;
 1000         }
 1001 
 1002         /* Replace failed disk or placeholder with new disk. */
 1003         TAILQ_FOREACH_SAFE(sd, &olddisk->d_subdisks, sd_next, tmpsd) {
 1004                 TAILQ_REMOVE(&olddisk->d_subdisks, sd, sd_next);
 1005                 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
 1006                 sd->sd_disk = disk;
 1007         }
 1008         oldpd->pd_disk_pos = -2;
 1009         pd->pd_disk_pos = disk_pos;
 1010 
 1011         /* If it was placeholder -- destroy it. */
 1012         if (olddisk->d_state == G_RAID_DISK_S_OFFLINE) {
 1013                 g_raid_destroy_disk(olddisk);
 1014         } else {
 1015                 /* Otherwise, make it STALE_FAILED. */
 1016                 g_raid_change_disk_state(olddisk, G_RAID_DISK_S_STALE_FAILED);
 1017                 /* Update global metadata just in case. */
 1018                 memcpy(&meta->disk[disk_pos], &pd->pd_disk_meta,
 1019                     sizeof(struct intel_raid_disk));
 1020         }
 1021 
 1022         /* Welcome the new disk. */
 1023         if ((meta->disk[disk_pos].flags & INTEL_F_DISABLED) &&
 1024             !(pd->pd_disk_meta.flags & INTEL_F_SPARE))
 1025                 g_raid_change_disk_state(disk, G_RAID_DISK_S_DISABLED);
 1026         else if (resurrection)
 1027                 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
 1028         else if (meta->disk[disk_pos].flags & INTEL_F_FAILED)
 1029                 g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED);
 1030         else if (meta->disk[disk_pos].flags & INTEL_F_SPARE)
 1031                 g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE);
 1032         else
 1033                 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
 1034         TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
 1035                 pv = sd->sd_volume->v_md_data;
 1036                 mvol = intel_get_volume(meta, pv->pv_volume_pos);
 1037                 mmap0 = intel_get_map(mvol, 0);
 1038                 if (mvol->migr_state)
 1039                         mmap1 = intel_get_map(mvol, 1);
 1040                 else
 1041                         mmap1 = mmap0;
 1042 
 1043                 migr_global = 1;
 1044                 for (i = 0; i < mmap0->total_disks; i++) {
 1045                         if ((mmap0->disk_idx[i] & INTEL_DI_RBLD) == 0 &&
 1046                             (mmap1->disk_idx[i] & INTEL_DI_RBLD) != 0)
 1047                                 migr_global = 0;
 1048                 }
 1049 
 1050                 if ((meta->disk[disk_pos].flags & INTEL_F_DISABLED) &&
 1051                     !(pd->pd_disk_meta.flags & INTEL_F_SPARE)) {
 1052                         /* Disabled disk, useless. */
 1053                         g_raid_change_subdisk_state(sd,
 1054                             G_RAID_SUBDISK_S_NONE);
 1055                 } else if (resurrection) {
 1056                         /* Stale disk, almost same as new. */
 1057                         g_raid_change_subdisk_state(sd,
 1058                             G_RAID_SUBDISK_S_NEW);
 1059                 } else if (meta->disk[disk_pos].flags & INTEL_F_FAILED) {
 1060                         /* Failed disk, almost useless. */
 1061                         g_raid_change_subdisk_state(sd,
 1062                             G_RAID_SUBDISK_S_FAILED);
 1063                 } else if (mvol->migr_state == 0) {
 1064                         if (mmap0->status == INTEL_S_UNINITIALIZED &&
 1065                             (!pv->pv_cng || pv->pv_cng_master_disk != disk_pos)) {
 1066                                 /* Freshly created uninitialized volume. */
 1067                                 g_raid_change_subdisk_state(sd,
 1068                                     G_RAID_SUBDISK_S_UNINITIALIZED);
 1069                         } else if (mmap0->disk_idx[sd->sd_pos] & INTEL_DI_RBLD) {
 1070                                 /* Freshly inserted disk. */
 1071                                 g_raid_change_subdisk_state(sd,
 1072                                     G_RAID_SUBDISK_S_NEW);
 1073                         } else if (mvol->dirty && (!pv->pv_cng ||
 1074                             pv->pv_cng_master_disk != disk_pos)) {
 1075                                 /* Dirty volume (unclean shutdown). */
 1076                                 g_raid_change_subdisk_state(sd,
 1077                                     G_RAID_SUBDISK_S_STALE);
 1078                         } else {
 1079                                 /* Up to date disk. */
 1080                                 g_raid_change_subdisk_state(sd,
 1081                                     G_RAID_SUBDISK_S_ACTIVE);
 1082                         }
 1083                 } else if (mvol->migr_type == INTEL_MT_INIT ||
 1084                            mvol->migr_type == INTEL_MT_REBUILD) {
 1085                         if (mmap0->disk_idx[sd->sd_pos] & INTEL_DI_RBLD) {
 1086                                 /* Freshly inserted disk. */
 1087                                 g_raid_change_subdisk_state(sd,
 1088                                     G_RAID_SUBDISK_S_NEW);
 1089                         } else if (mmap1->disk_idx[sd->sd_pos] & INTEL_DI_RBLD) {
 1090                                 /* Rebuilding disk. */
 1091                                 g_raid_change_subdisk_state(sd,
 1092                                     G_RAID_SUBDISK_S_REBUILD);
 1093                                 if (mvol->dirty) {
 1094                                         sd->sd_rebuild_pos = 0;
 1095                                 } else {
 1096                                         sd->sd_rebuild_pos =
 1097                                             intel_get_vol_curr_migr_unit(mvol) *
 1098                                             sd->sd_volume->v_strip_size *
 1099                                             mmap0->total_domains;
 1100                                 }
 1101                         } else if (mvol->migr_type == INTEL_MT_INIT &&
 1102                             migr_global) {
 1103                                 /* Freshly created uninitialized volume. */
 1104                                 g_raid_change_subdisk_state(sd,
 1105                                     G_RAID_SUBDISK_S_UNINITIALIZED);
 1106                         } else if (mvol->dirty && (!pv->pv_cng ||
 1107                             pv->pv_cng_master_disk != disk_pos)) {
 1108                                 /* Dirty volume (unclean shutdown). */
 1109                                 g_raid_change_subdisk_state(sd,
 1110                                     G_RAID_SUBDISK_S_STALE);
 1111                         } else {
 1112                                 /* Up to date disk. */
 1113                                 g_raid_change_subdisk_state(sd,
 1114                                     G_RAID_SUBDISK_S_ACTIVE);
 1115                         }
 1116                 } else if (mvol->migr_type == INTEL_MT_VERIFY ||
 1117                            mvol->migr_type == INTEL_MT_REPAIR) {
 1118                         if (mmap0->disk_idx[sd->sd_pos] & INTEL_DI_RBLD) {
 1119                                 /* Freshly inserted disk. */
 1120                                 g_raid_change_subdisk_state(sd,
 1121                                     G_RAID_SUBDISK_S_NEW);
 1122                         } else if ((mmap1->disk_idx[sd->sd_pos] & INTEL_DI_RBLD) ||
 1123                             migr_global) {
 1124                                 /* Resyncing disk. */
 1125                                 g_raid_change_subdisk_state(sd,
 1126                                     G_RAID_SUBDISK_S_RESYNC);
 1127                                 if (mvol->dirty) {
 1128                                         sd->sd_rebuild_pos = 0;
 1129                                 } else {
 1130                                         sd->sd_rebuild_pos =
 1131                                             intel_get_vol_curr_migr_unit(mvol) *
 1132                                             sd->sd_volume->v_strip_size *
 1133                                             mmap0->total_domains;
 1134                                 }
 1135                         } else if (mvol->dirty) {
 1136                                 /* Dirty volume (unclean shutdown). */
 1137                                 g_raid_change_subdisk_state(sd,
 1138                                     G_RAID_SUBDISK_S_STALE);
 1139                         } else {
 1140                                 /* Up to date disk. */
 1141                                 g_raid_change_subdisk_state(sd,
 1142                                     G_RAID_SUBDISK_S_ACTIVE);
 1143                         }
 1144                 } else if (mvol->migr_type == INTEL_MT_GEN_MIGR) {
 1145                         if ((mmap1->disk_idx[0] & INTEL_DI_IDX) != disk_pos) {
 1146                                 /* Freshly inserted disk. */
 1147                                 g_raid_change_subdisk_state(sd,
 1148                                     G_RAID_SUBDISK_S_NEW);
 1149                         } else {
 1150                                 /* Up to date disk. */
 1151                                 g_raid_change_subdisk_state(sd,
 1152                                     G_RAID_SUBDISK_S_ACTIVE);
 1153                         }
 1154                 }
 1155                 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
 1156                     G_RAID_EVENT_SUBDISK);
 1157         }
 1158 
 1159         /* Update status of our need for spare. */
 1160         if (mdi->mdio_started) {
 1161                 mdi->mdio_incomplete =
 1162                     (g_raid_ndisks(sc, G_RAID_DISK_S_ACTIVE) +
 1163                      g_raid_ndisks(sc, G_RAID_DISK_S_DISABLED) <
 1164                      meta->total_disks);
 1165         }
 1166 
 1167         return (resurrection);
 1168 }
 1169 
 1170 static void
 1171 g_disk_md_intel_retaste(void *arg, int pending)
 1172 {
 1173 
 1174         G_RAID_DEBUG(1, "Array is not complete, trying to retaste.");
 1175         g_retaste(&g_raid_class);
 1176         free(arg, M_MD_INTEL);
 1177 }
 1178 
 1179 static void
 1180 g_raid_md_intel_refill(struct g_raid_softc *sc)
 1181 {
 1182         struct g_raid_md_object *md;
 1183         struct g_raid_md_intel_object *mdi;
 1184         struct intel_raid_conf *meta;
 1185         struct g_raid_disk *disk;
 1186         struct task *task;
 1187         int update, na;
 1188 
 1189         md = sc->sc_md;
 1190         mdi = (struct g_raid_md_intel_object *)md;
 1191         meta = mdi->mdio_meta;
 1192         update = 0;
 1193         do {
 1194                 /* Make sure we miss anything. */
 1195                 na = g_raid_ndisks(sc, G_RAID_DISK_S_ACTIVE) +
 1196                     g_raid_ndisks(sc, G_RAID_DISK_S_DISABLED);
 1197                 if (na == meta->total_disks)
 1198                         break;
 1199 
 1200                 G_RAID_DEBUG1(1, md->mdo_softc,
 1201                     "Array is not complete (%d of %d), "
 1202                     "trying to refill.", na, meta->total_disks);
 1203 
 1204                 /* Try to get use some of STALE disks. */
 1205                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 1206                         if (disk->d_state == G_RAID_DISK_S_STALE) {
 1207                                 update += g_raid_md_intel_start_disk(disk);
 1208                                 if (disk->d_state == G_RAID_DISK_S_ACTIVE ||
 1209                                     disk->d_state == G_RAID_DISK_S_DISABLED)
 1210                                         break;
 1211                         }
 1212                 }
 1213                 if (disk != NULL)
 1214                         continue;
 1215 
 1216                 /* Try to get use some of SPARE disks. */
 1217                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 1218                         if (disk->d_state == G_RAID_DISK_S_SPARE) {
 1219                                 update += g_raid_md_intel_start_disk(disk);
 1220                                 if (disk->d_state == G_RAID_DISK_S_ACTIVE)
 1221                                         break;
 1222                         }
 1223                 }
 1224         } while (disk != NULL);
 1225 
 1226         /* Write new metadata if we changed something. */
 1227         if (update) {
 1228                 g_raid_md_write_intel(md, NULL, NULL, NULL);
 1229                 meta = mdi->mdio_meta;
 1230         }
 1231 
 1232         /* Update status of our need for spare. */
 1233         mdi->mdio_incomplete = (g_raid_ndisks(sc, G_RAID_DISK_S_ACTIVE) +
 1234             g_raid_ndisks(sc, G_RAID_DISK_S_DISABLED) < meta->total_disks);
 1235 
 1236         /* Request retaste hoping to find spare. */
 1237         if (mdi->mdio_incomplete) {
 1238                 task = malloc(sizeof(struct task),
 1239                     M_MD_INTEL, M_WAITOK | M_ZERO);
 1240                 TASK_INIT(task, 0, g_disk_md_intel_retaste, task);
 1241                 taskqueue_enqueue(taskqueue_swi, task);
 1242         }
 1243 }
 1244 
 1245 static void
 1246 g_raid_md_intel_start(struct g_raid_softc *sc)
 1247 {
 1248         struct g_raid_md_object *md;
 1249         struct g_raid_md_intel_object *mdi;
 1250         struct g_raid_md_intel_pervolume *pv;
 1251         struct g_raid_md_intel_perdisk *pd;
 1252         struct intel_raid_conf *meta;
 1253         struct intel_raid_vol *mvol;
 1254         struct intel_raid_map *mmap;
 1255         struct g_raid_volume *vol;
 1256         struct g_raid_subdisk *sd;
 1257         struct g_raid_disk *disk;
 1258         int i, j, disk_pos;
 1259 
 1260         md = sc->sc_md;
 1261         mdi = (struct g_raid_md_intel_object *)md;
 1262         meta = mdi->mdio_meta;
 1263 
 1264         /* Create volumes and subdisks. */
 1265         for (i = 0; i < meta->total_volumes; i++) {
 1266                 mvol = intel_get_volume(meta, i);
 1267                 mmap = intel_get_map(mvol, 0);
 1268                 vol = g_raid_create_volume(sc, mvol->name, mvol->tid - 1);
 1269                 pv = malloc(sizeof(*pv), M_MD_INTEL, M_WAITOK | M_ZERO);
 1270                 pv->pv_volume_pos = i;
 1271                 pv->pv_cng = (mvol->state & INTEL_ST_CLONE_N_GO) != 0;
 1272                 pv->pv_cng_man_sync = (mvol->state & INTEL_ST_CLONE_MAN_SYNC) != 0;
 1273                 if (mvol->cng_master_disk < mmap->total_disks)
 1274                         pv->pv_cng_master_disk = mvol->cng_master_disk;
 1275                 vol->v_md_data = pv;
 1276                 vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_NONE;
 1277                 if (mmap->type == INTEL_T_RAID0)
 1278                         vol->v_raid_level = G_RAID_VOLUME_RL_RAID0;
 1279                 else if (mmap->type == INTEL_T_RAID1 &&
 1280                     mmap->total_domains >= 2 &&
 1281                     mmap->total_domains <= mmap->total_disks) {
 1282                         /* Assume total_domains is correct. */
 1283                         if (mmap->total_domains == mmap->total_disks)
 1284                                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1;
 1285                         else
 1286                                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E;
 1287                 } else if (mmap->type == INTEL_T_RAID1) {
 1288                         /* total_domains looks wrong. */
 1289                         if (mmap->total_disks <= 2)
 1290                                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1;
 1291                         else
 1292                                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E;
 1293                 } else if (mmap->type == INTEL_T_RAID5) {
 1294                         vol->v_raid_level = G_RAID_VOLUME_RL_RAID5;
 1295                         vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_R5LA;
 1296                 } else
 1297                         vol->v_raid_level = G_RAID_VOLUME_RL_UNKNOWN;
 1298                 vol->v_strip_size = (u_int)mmap->strip_sectors * 512; //ZZZ
 1299                 vol->v_disks_count = mmap->total_disks;
 1300                 vol->v_mediasize = (off_t)mvol->total_sectors * 512; //ZZZ
 1301                 vol->v_sectorsize = 512; //ZZZ
 1302                 for (j = 0; j < vol->v_disks_count; j++) {
 1303                         sd = &vol->v_subdisks[j];
 1304                         sd->sd_offset = intel_get_map_offset(mmap) * 512; //ZZZ
 1305                         sd->sd_size = intel_get_map_disk_sectors(mmap) * 512; //ZZZ
 1306                 }
 1307                 g_raid_start_volume(vol);
 1308         }
 1309 
 1310         /* Create disk placeholders to store data for later writing. */
 1311         for (disk_pos = 0; disk_pos < meta->total_disks; disk_pos++) {
 1312                 pd = malloc(sizeof(*pd), M_MD_INTEL, M_WAITOK | M_ZERO);
 1313                 pd->pd_disk_pos = disk_pos;
 1314                 pd->pd_disk_meta = meta->disk[disk_pos];
 1315                 disk = g_raid_create_disk(sc);
 1316                 disk->d_md_data = (void *)pd;
 1317                 disk->d_state = G_RAID_DISK_S_OFFLINE;
 1318                 for (i = 0; i < meta->total_volumes; i++) {
 1319                         mvol = intel_get_volume(meta, i);
 1320                         mmap = intel_get_map(mvol, 0);
 1321                         for (j = 0; j < mmap->total_disks; j++) {
 1322                                 if ((mmap->disk_idx[j] & INTEL_DI_IDX) == disk_pos)
 1323                                         break;
 1324                         }
 1325                         if (j == mmap->total_disks)
 1326                                 continue;
 1327                         vol = g_raid_md_intel_get_volume(sc, i);
 1328                         sd = &vol->v_subdisks[j];
 1329                         sd->sd_disk = disk;
 1330                         TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
 1331                 }
 1332         }
 1333 
 1334         /* Make all disks found till the moment take their places. */
 1335         do {
 1336                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 1337                         if (disk->d_state == G_RAID_DISK_S_NONE) {
 1338                                 g_raid_md_intel_start_disk(disk);
 1339                                 break;
 1340                         }
 1341                 }
 1342         } while (disk != NULL);
 1343 
 1344         mdi->mdio_started = 1;
 1345         G_RAID_DEBUG1(0, sc, "Array started.");
 1346         g_raid_md_write_intel(md, NULL, NULL, NULL);
 1347 
 1348         /* Pickup any STALE/SPARE disks to refill array if needed. */
 1349         g_raid_md_intel_refill(sc);
 1350 
 1351         TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
 1352                 g_raid_event_send(vol, G_RAID_VOLUME_E_START,
 1353                     G_RAID_EVENT_VOLUME);
 1354         }
 1355 
 1356         callout_stop(&mdi->mdio_start_co);
 1357         G_RAID_DEBUG1(1, sc, "root_mount_rel %p", mdi->mdio_rootmount);
 1358         root_mount_rel(mdi->mdio_rootmount);
 1359         mdi->mdio_rootmount = NULL;
 1360 }
 1361 
 1362 static void
 1363 g_raid_md_intel_new_disk(struct g_raid_disk *disk)
 1364 {
 1365         struct g_raid_softc *sc;
 1366         struct g_raid_md_object *md;
 1367         struct g_raid_md_intel_object *mdi;
 1368         struct intel_raid_conf *pdmeta;
 1369         struct g_raid_md_intel_perdisk *pd;
 1370 
 1371         sc = disk->d_softc;
 1372         md = sc->sc_md;
 1373         mdi = (struct g_raid_md_intel_object *)md;
 1374         pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 1375         pdmeta = pd->pd_meta;
 1376 
 1377         if (mdi->mdio_started) {
 1378                 if (g_raid_md_intel_start_disk(disk))
 1379                         g_raid_md_write_intel(md, NULL, NULL, NULL);
 1380         } else {
 1381                 /* If we haven't started yet - check metadata freshness. */
 1382                 if (mdi->mdio_meta == NULL ||
 1383                     ((int32_t)(pdmeta->generation - mdi->mdio_generation)) > 0) {
 1384                         G_RAID_DEBUG1(1, sc, "Newer disk");
 1385                         if (mdi->mdio_meta != NULL)
 1386                                 free(mdi->mdio_meta, M_MD_INTEL);
 1387                         mdi->mdio_meta = intel_meta_copy(pdmeta);
 1388                         mdi->mdio_generation = mdi->mdio_meta->generation;
 1389                         mdi->mdio_disks_present = 1;
 1390                 } else if (pdmeta->generation == mdi->mdio_generation) {
 1391                         mdi->mdio_disks_present++;
 1392                         G_RAID_DEBUG1(1, sc, "Matching disk (%d of %d up)",
 1393                             mdi->mdio_disks_present,
 1394                             mdi->mdio_meta->total_disks);
 1395                 } else {
 1396                         G_RAID_DEBUG1(1, sc, "Older disk");
 1397                 }
 1398                 /* If we collected all needed disks - start array. */
 1399                 if (mdi->mdio_disks_present == mdi->mdio_meta->total_disks)
 1400                         g_raid_md_intel_start(sc);
 1401         }
 1402 }
 1403 
 1404 static void
 1405 g_raid_intel_go(void *arg)
 1406 {
 1407         struct g_raid_softc *sc;
 1408         struct g_raid_md_object *md;
 1409         struct g_raid_md_intel_object *mdi;
 1410 
 1411         sc = arg;
 1412         md = sc->sc_md;
 1413         mdi = (struct g_raid_md_intel_object *)md;
 1414         if (!mdi->mdio_started) {
 1415                 G_RAID_DEBUG1(0, sc, "Force array start due to timeout.");
 1416                 g_raid_event_send(sc, G_RAID_NODE_E_START, 0);
 1417         }
 1418 }
 1419 
 1420 static int
 1421 g_raid_md_create_intel(struct g_raid_md_object *md, struct g_class *mp,
 1422     struct g_geom **gp)
 1423 {
 1424         struct g_raid_softc *sc;
 1425         struct g_raid_md_intel_object *mdi;
 1426         char name[16];
 1427 
 1428         mdi = (struct g_raid_md_intel_object *)md;
 1429         mdi->mdio_config_id = mdi->mdio_orig_config_id = arc4random();
 1430         mdi->mdio_generation = 0;
 1431         snprintf(name, sizeof(name), "Intel-%08x", mdi->mdio_config_id);
 1432         sc = g_raid_create_node(mp, name, md);
 1433         if (sc == NULL)
 1434                 return (G_RAID_MD_TASTE_FAIL);
 1435         md->mdo_softc = sc;
 1436         *gp = sc->sc_geom;
 1437         return (G_RAID_MD_TASTE_NEW);
 1438 }
 1439 
 1440 /*
 1441  * Return the last N characters of the serial label.  The Linux and
 1442  * ataraid(7) code always uses the last 16 characters of the label to
 1443  * store into the Intel meta format.  Generalize this to N characters
 1444  * since that's easy.  Labels can be up to 20 characters for SATA drives
 1445  * and up 251 characters for SAS drives.  Since intel controllers don't
 1446  * support SAS drives, just stick with the SATA limits for stack friendliness.
 1447  */
 1448 static int
 1449 g_raid_md_get_label(struct g_consumer *cp, char *serial, int serlen)
 1450 {
 1451         char serial_buffer[24];
 1452         int len, error;
 1453         
 1454         len = sizeof(serial_buffer);
 1455         error = g_io_getattr("GEOM::ident", cp, &len, serial_buffer);
 1456         if (error != 0)
 1457                 return (error);
 1458         len = strlen(serial_buffer);
 1459         if (len > serlen)
 1460                 len -= serlen;
 1461         else
 1462                 len = 0;
 1463         strncpy(serial, serial_buffer + len, serlen);
 1464         return (0);
 1465 }
 1466 
 1467 static int
 1468 g_raid_md_taste_intel(struct g_raid_md_object *md, struct g_class *mp,
 1469                               struct g_consumer *cp, struct g_geom **gp)
 1470 {
 1471         struct g_consumer *rcp;
 1472         struct g_provider *pp;
 1473         struct g_raid_md_intel_object *mdi, *mdi1;
 1474         struct g_raid_softc *sc;
 1475         struct g_raid_disk *disk;
 1476         struct intel_raid_conf *meta;
 1477         struct g_raid_md_intel_perdisk *pd;
 1478         struct g_geom *geom;
 1479         int error, disk_pos, result, spare, len;
 1480         char serial[INTEL_SERIAL_LEN];
 1481         char name[16];
 1482         uint16_t vendor;
 1483 
 1484         G_RAID_DEBUG(1, "Tasting Intel on %s", cp->provider->name);
 1485         mdi = (struct g_raid_md_intel_object *)md;
 1486         pp = cp->provider;
 1487 
 1488         /* Read metadata from device. */
 1489         meta = NULL;
 1490         vendor = 0xffff;
 1491         disk_pos = 0;
 1492         g_topology_unlock();
 1493         error = g_raid_md_get_label(cp, serial, sizeof(serial));
 1494         if (error != 0) {
 1495                 G_RAID_DEBUG(1, "Cannot get serial number from %s (error=%d).",
 1496                     pp->name, error);
 1497                 goto fail2;
 1498         }
 1499         len = 2;
 1500         if (pp->geom->rank == 1)
 1501                 g_io_getattr("GEOM::hba_vendor", cp, &len, &vendor);
 1502         meta = intel_meta_read(cp);
 1503         g_topology_lock();
 1504         if (meta == NULL) {
 1505                 if (g_raid_aggressive_spare) {
 1506                         if (vendor != 0x8086) {
 1507                                 G_RAID_DEBUG(1,
 1508                                     "Intel vendor mismatch 0x%04x != 0x8086",
 1509                                     vendor);
 1510                         } else {
 1511                                 G_RAID_DEBUG(1,
 1512                                     "No Intel metadata, forcing spare.");
 1513                                 spare = 2;
 1514                                 goto search;
 1515                         }
 1516                 }
 1517                 return (G_RAID_MD_TASTE_FAIL);
 1518         }
 1519 
 1520         /* Check this disk position in obtained metadata. */
 1521         disk_pos = intel_meta_find_disk(meta, serial);
 1522         if (disk_pos < 0) {
 1523                 G_RAID_DEBUG(1, "Intel serial '%s' not found", serial);
 1524                 goto fail1;
 1525         }
 1526         if (intel_get_disk_sectors(&meta->disk[disk_pos]) !=
 1527             (pp->mediasize / pp->sectorsize)) {
 1528                 G_RAID_DEBUG(1, "Intel size mismatch %ju != %ju",
 1529                     intel_get_disk_sectors(&meta->disk[disk_pos]),
 1530                     (off_t)(pp->mediasize / pp->sectorsize));
 1531                 goto fail1;
 1532         }
 1533 
 1534         G_RAID_DEBUG(1, "Intel disk position %d", disk_pos);
 1535         spare = meta->disk[disk_pos].flags & INTEL_F_SPARE;
 1536 
 1537 search:
 1538         /* Search for matching node. */
 1539         sc = NULL;
 1540         mdi1 = NULL;
 1541         LIST_FOREACH(geom, &mp->geom, geom) {
 1542                 sc = geom->softc;
 1543                 if (sc == NULL)
 1544                         continue;
 1545                 if (sc->sc_stopping != 0)
 1546                         continue;
 1547                 if (sc->sc_md->mdo_class != md->mdo_class)
 1548                         continue;
 1549                 mdi1 = (struct g_raid_md_intel_object *)sc->sc_md;
 1550                 if (spare) {
 1551                         if (mdi1->mdio_incomplete)
 1552                                 break;
 1553                 } else {
 1554                         if (mdi1->mdio_config_id == meta->config_id)
 1555                                 break;
 1556                 }
 1557         }
 1558 
 1559         /* Found matching node. */
 1560         if (geom != NULL) {
 1561                 G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name);
 1562                 result = G_RAID_MD_TASTE_EXISTING;
 1563 
 1564         } else if (spare) { /* Not found needy node -- left for later. */
 1565                 G_RAID_DEBUG(1, "Spare is not needed at this time");
 1566                 goto fail1;
 1567 
 1568         } else { /* Not found matching node -- create one. */
 1569                 result = G_RAID_MD_TASTE_NEW;
 1570                 mdi->mdio_config_id = meta->config_id;
 1571                 mdi->mdio_orig_config_id = meta->orig_config_id;
 1572                 snprintf(name, sizeof(name), "Intel-%08x", meta->config_id);
 1573                 sc = g_raid_create_node(mp, name, md);
 1574                 md->mdo_softc = sc;
 1575                 geom = sc->sc_geom;
 1576                 callout_init(&mdi->mdio_start_co, 1);
 1577                 callout_reset(&mdi->mdio_start_co, g_raid_start_timeout * hz,
 1578                     g_raid_intel_go, sc);
 1579                 mdi->mdio_rootmount = root_mount_hold("GRAID-Intel");
 1580                 G_RAID_DEBUG1(1, sc, "root_mount_hold %p", mdi->mdio_rootmount);
 1581         }
 1582 
 1583         /* There is no return after this point, so we close passed consumer. */
 1584         g_access(cp, -1, 0, 0);
 1585 
 1586         rcp = g_new_consumer(geom);
 1587         g_attach(rcp, pp);
 1588         if (g_access(rcp, 1, 1, 1) != 0)
 1589                 ; //goto fail1;
 1590 
 1591         g_topology_unlock();
 1592         sx_xlock(&sc->sc_lock);
 1593 
 1594         pd = malloc(sizeof(*pd), M_MD_INTEL, M_WAITOK | M_ZERO);
 1595         pd->pd_meta = meta;
 1596         pd->pd_disk_pos = -1;
 1597         if (spare == 2) {
 1598                 memcpy(&pd->pd_disk_meta.serial[0], serial, INTEL_SERIAL_LEN);
 1599                 intel_set_disk_sectors(&pd->pd_disk_meta, 
 1600                     pp->mediasize / pp->sectorsize);
 1601                 pd->pd_disk_meta.id = 0;
 1602                 pd->pd_disk_meta.flags = INTEL_F_SPARE;
 1603         } else {
 1604                 pd->pd_disk_meta = meta->disk[disk_pos];
 1605         }
 1606         disk = g_raid_create_disk(sc);
 1607         disk->d_md_data = (void *)pd;
 1608         disk->d_consumer = rcp;
 1609         rcp->private = disk;
 1610 
 1611         g_raid_get_disk_info(disk);
 1612 
 1613         g_raid_md_intel_new_disk(disk);
 1614 
 1615         sx_xunlock(&sc->sc_lock);
 1616         g_topology_lock();
 1617         *gp = geom;
 1618         return (result);
 1619 fail2:
 1620         g_topology_lock();
 1621 fail1:
 1622         free(meta, M_MD_INTEL);
 1623         return (G_RAID_MD_TASTE_FAIL);
 1624 }
 1625 
 1626 static int
 1627 g_raid_md_event_intel(struct g_raid_md_object *md,
 1628     struct g_raid_disk *disk, u_int event)
 1629 {
 1630         struct g_raid_softc *sc;
 1631         struct g_raid_subdisk *sd;
 1632         struct g_raid_md_intel_object *mdi;
 1633         struct g_raid_md_intel_perdisk *pd;
 1634 
 1635         sc = md->mdo_softc;
 1636         mdi = (struct g_raid_md_intel_object *)md;
 1637         if (disk == NULL) {
 1638                 switch (event) {
 1639                 case G_RAID_NODE_E_START:
 1640                         if (!mdi->mdio_started)
 1641                                 g_raid_md_intel_start(sc);
 1642                         return (0);
 1643                 }
 1644                 return (-1);
 1645         }
 1646         pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 1647         switch (event) {
 1648         case G_RAID_DISK_E_DISCONNECTED:
 1649                 /* If disk was assigned, just update statuses. */
 1650                 if (pd->pd_disk_pos >= 0) {
 1651                         g_raid_change_disk_state(disk, G_RAID_DISK_S_OFFLINE);
 1652                         if (disk->d_consumer) {
 1653                                 g_raid_kill_consumer(sc, disk->d_consumer);
 1654                                 disk->d_consumer = NULL;
 1655                         }
 1656                         TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
 1657                                 g_raid_change_subdisk_state(sd,
 1658                                     G_RAID_SUBDISK_S_NONE);
 1659                                 g_raid_event_send(sd, G_RAID_SUBDISK_E_DISCONNECTED,
 1660                                     G_RAID_EVENT_SUBDISK);
 1661                         }
 1662                 } else {
 1663                         /* Otherwise -- delete. */
 1664                         g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
 1665                         g_raid_destroy_disk(disk);
 1666                 }
 1667 
 1668                 /* Write updated metadata to all disks. */
 1669                 g_raid_md_write_intel(md, NULL, NULL, NULL);
 1670 
 1671                 /* Check if anything left except placeholders. */
 1672                 if (g_raid_ndisks(sc, -1) ==
 1673                     g_raid_ndisks(sc, G_RAID_DISK_S_OFFLINE))
 1674                         g_raid_destroy_node(sc, 0);
 1675                 else
 1676                         g_raid_md_intel_refill(sc);
 1677                 return (0);
 1678         }
 1679         return (-2);
 1680 }
 1681 
 1682 static int
 1683 g_raid_md_ctl_intel(struct g_raid_md_object *md,
 1684     struct gctl_req *req)
 1685 {
 1686         struct g_raid_softc *sc;
 1687         struct g_raid_volume *vol, *vol1;
 1688         struct g_raid_subdisk *sd;
 1689         struct g_raid_disk *disk;
 1690         struct g_raid_md_intel_object *mdi;
 1691         struct g_raid_md_intel_pervolume *pv;
 1692         struct g_raid_md_intel_perdisk *pd;
 1693         struct g_consumer *cp;
 1694         struct g_provider *pp;
 1695         char arg[16], serial[INTEL_SERIAL_LEN];
 1696         const char *nodename, *verb, *volname, *levelname, *diskname;
 1697         char *tmp;
 1698         int *nargs, *force;
 1699         off_t off, size, sectorsize, strip, disk_sectors;
 1700         intmax_t *sizearg, *striparg;
 1701         int numdisks, i, len, level, qual, update;
 1702         int error;
 1703 
 1704         sc = md->mdo_softc;
 1705         mdi = (struct g_raid_md_intel_object *)md;
 1706         verb = gctl_get_param(req, "verb", NULL);
 1707         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
 1708         error = 0;
 1709         if (strcmp(verb, "label") == 0) {
 1710 
 1711                 if (*nargs < 4) {
 1712                         gctl_error(req, "Invalid number of arguments.");
 1713                         return (-1);
 1714                 }
 1715                 volname = gctl_get_asciiparam(req, "arg1");
 1716                 if (volname == NULL) {
 1717                         gctl_error(req, "No volume name.");
 1718                         return (-2);
 1719                 }
 1720                 levelname = gctl_get_asciiparam(req, "arg2");
 1721                 if (levelname == NULL) {
 1722                         gctl_error(req, "No RAID level.");
 1723                         return (-3);
 1724                 }
 1725                 if (strcasecmp(levelname, "RAID5") == 0)
 1726                         levelname = "RAID5-LA";
 1727                 if (g_raid_volume_str2level(levelname, &level, &qual)) {
 1728                         gctl_error(req, "Unknown RAID level '%s'.", levelname);
 1729                         return (-4);
 1730                 }
 1731                 numdisks = *nargs - 3;
 1732                 force = gctl_get_paraml(req, "force", sizeof(*force));
 1733                 if (!g_raid_md_intel_supported(level, qual, numdisks,
 1734                     force ? *force : 0)) {
 1735                         gctl_error(req, "Unsupported RAID level "
 1736                             "(0x%02x/0x%02x), or number of disks (%d).",
 1737                             level, qual, numdisks);
 1738                         return (-5);
 1739                 }
 1740 
 1741                 /* Search for disks, connect them and probe. */
 1742                 size = 0x7fffffffffffffffllu;
 1743                 sectorsize = 0;
 1744                 for (i = 0; i < numdisks; i++) {
 1745                         snprintf(arg, sizeof(arg), "arg%d", i + 3);
 1746                         diskname = gctl_get_asciiparam(req, arg);
 1747                         if (diskname == NULL) {
 1748                                 gctl_error(req, "No disk name (%s).", arg);
 1749                                 error = -6;
 1750                                 break;
 1751                         }
 1752                         if (strcmp(diskname, "NONE") == 0) {
 1753                                 cp = NULL;
 1754                                 pp = NULL;
 1755                         } else {
 1756                                 g_topology_lock();
 1757                                 cp = g_raid_open_consumer(sc, diskname);
 1758                                 if (cp == NULL) {
 1759                                         gctl_error(req, "Can't open disk '%s'.",
 1760                                             diskname);
 1761                                         g_topology_unlock();
 1762                                         error = -7;
 1763                                         break;
 1764                                 }
 1765                                 pp = cp->provider;
 1766                         }
 1767                         pd = malloc(sizeof(*pd), M_MD_INTEL, M_WAITOK | M_ZERO);
 1768                         pd->pd_disk_pos = i;
 1769                         disk = g_raid_create_disk(sc);
 1770                         disk->d_md_data = (void *)pd;
 1771                         disk->d_consumer = cp;
 1772                         if (cp == NULL) {
 1773                                 strcpy(&pd->pd_disk_meta.serial[0], "NONE");
 1774                                 pd->pd_disk_meta.id = 0xffffffff;
 1775                                 pd->pd_disk_meta.flags = INTEL_F_ASSIGNED;
 1776                                 continue;
 1777                         }
 1778                         cp->private = disk;
 1779                         g_topology_unlock();
 1780 
 1781                         error = g_raid_md_get_label(cp,
 1782                             &pd->pd_disk_meta.serial[0], INTEL_SERIAL_LEN);
 1783                         if (error != 0) {
 1784                                 gctl_error(req,
 1785                                     "Can't get serial for provider '%s'.",
 1786                                     diskname);
 1787                                 error = -8;
 1788                                 break;
 1789                         }
 1790 
 1791                         g_raid_get_disk_info(disk);
 1792 
 1793                         intel_set_disk_sectors(&pd->pd_disk_meta,
 1794                             pp->mediasize / pp->sectorsize);
 1795                         if (size > pp->mediasize)
 1796                                 size = pp->mediasize;
 1797                         if (sectorsize < pp->sectorsize)
 1798                                 sectorsize = pp->sectorsize;
 1799                         pd->pd_disk_meta.id = 0;
 1800                         pd->pd_disk_meta.flags = INTEL_F_ASSIGNED | INTEL_F_ONLINE;
 1801                 }
 1802                 if (error != 0)
 1803                         return (error);
 1804 
 1805                 if (sectorsize <= 0) {
 1806                         gctl_error(req, "Can't get sector size.");
 1807                         return (-8);
 1808                 }
 1809 
 1810                 /* Reserve some space for metadata. */
 1811                 size -= ((4096 + sectorsize - 1) / sectorsize) * sectorsize;
 1812 
 1813                 /* Handle size argument. */
 1814                 len = sizeof(*sizearg);
 1815                 sizearg = gctl_get_param(req, "size", &len);
 1816                 if (sizearg != NULL && len == sizeof(*sizearg) &&
 1817                     *sizearg > 0) {
 1818                         if (*sizearg > size) {
 1819                                 gctl_error(req, "Size too big %lld > %lld.",
 1820                                     (long long)*sizearg, (long long)size);
 1821                                 return (-9);
 1822                         }
 1823                         size = *sizearg;
 1824                 }
 1825 
 1826                 /* Handle strip argument. */
 1827                 strip = 131072;
 1828                 len = sizeof(*striparg);
 1829                 striparg = gctl_get_param(req, "strip", &len);
 1830                 if (striparg != NULL && len == sizeof(*striparg) &&
 1831                     *striparg > 0) {
 1832                         if (*striparg < sectorsize) {
 1833                                 gctl_error(req, "Strip size too small.");
 1834                                 return (-10);
 1835                         }
 1836                         if (*striparg % sectorsize != 0) {
 1837                                 gctl_error(req, "Incorrect strip size.");
 1838                                 return (-11);
 1839                         }
 1840                         if (strip > 65535 * sectorsize) {
 1841                                 gctl_error(req, "Strip size too big.");
 1842                                 return (-12);
 1843                         }
 1844                         strip = *striparg;
 1845                 }
 1846 
 1847                 /* Round size down to strip or sector. */
 1848                 if (level == G_RAID_VOLUME_RL_RAID1)
 1849                         size -= (size % sectorsize);
 1850                 else if (level == G_RAID_VOLUME_RL_RAID1E &&
 1851                     (numdisks & 1) != 0)
 1852                         size -= (size % (2 * strip));
 1853                 else
 1854                         size -= (size % strip);
 1855                 if (size <= 0) {
 1856                         gctl_error(req, "Size too small.");
 1857                         return (-13);
 1858                 }
 1859 
 1860                 /* We have all we need, create things: volume, ... */
 1861                 mdi->mdio_started = 1;
 1862                 vol = g_raid_create_volume(sc, volname, -1);
 1863                 pv = malloc(sizeof(*pv), M_MD_INTEL, M_WAITOK | M_ZERO);
 1864                 pv->pv_volume_pos = 0;
 1865                 vol->v_md_data = pv;
 1866                 vol->v_raid_level = level;
 1867                 vol->v_raid_level_qualifier = qual;
 1868                 vol->v_strip_size = strip;
 1869                 vol->v_disks_count = numdisks;
 1870                 if (level == G_RAID_VOLUME_RL_RAID0)
 1871                         vol->v_mediasize = size * numdisks;
 1872                 else if (level == G_RAID_VOLUME_RL_RAID1)
 1873                         vol->v_mediasize = size;
 1874                 else if (level == G_RAID_VOLUME_RL_RAID5)
 1875                         vol->v_mediasize = size * (numdisks - 1);
 1876                 else { /* RAID1E */
 1877                         vol->v_mediasize = ((size * numdisks) / strip / 2) *
 1878                             strip;
 1879                 }
 1880                 vol->v_sectorsize = sectorsize;
 1881                 g_raid_start_volume(vol);
 1882 
 1883                 /* , and subdisks. */
 1884                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 1885                         pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 1886                         sd = &vol->v_subdisks[pd->pd_disk_pos];
 1887                         sd->sd_disk = disk;
 1888                         sd->sd_offset = 0;
 1889                         sd->sd_size = size;
 1890                         TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
 1891                         if (sd->sd_disk->d_consumer != NULL) {
 1892                                 g_raid_change_disk_state(disk,
 1893                                     G_RAID_DISK_S_ACTIVE);
 1894                                 if (level == G_RAID_VOLUME_RL_RAID5)
 1895                                         g_raid_change_subdisk_state(sd,
 1896                                             G_RAID_SUBDISK_S_UNINITIALIZED);
 1897                                 else
 1898                                         g_raid_change_subdisk_state(sd,
 1899                                             G_RAID_SUBDISK_S_ACTIVE);
 1900                                 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
 1901                                     G_RAID_EVENT_SUBDISK);
 1902                         } else {
 1903                                 g_raid_change_disk_state(disk, G_RAID_DISK_S_OFFLINE);
 1904                         }
 1905                 }
 1906 
 1907                 /* Write metadata based on created entities. */
 1908                 G_RAID_DEBUG1(0, sc, "Array started.");
 1909                 g_raid_md_write_intel(md, NULL, NULL, NULL);
 1910 
 1911                 /* Pickup any STALE/SPARE disks to refill array if needed. */
 1912                 g_raid_md_intel_refill(sc);
 1913 
 1914                 g_raid_event_send(vol, G_RAID_VOLUME_E_START,
 1915                     G_RAID_EVENT_VOLUME);
 1916                 return (0);
 1917         }
 1918         if (strcmp(verb, "add") == 0) {
 1919 
 1920                 if (*nargs != 3) {
 1921                         gctl_error(req, "Invalid number of arguments.");
 1922                         return (-1);
 1923                 }
 1924                 volname = gctl_get_asciiparam(req, "arg1");
 1925                 if (volname == NULL) {
 1926                         gctl_error(req, "No volume name.");
 1927                         return (-2);
 1928                 }
 1929                 levelname = gctl_get_asciiparam(req, "arg2");
 1930                 if (levelname == NULL) {
 1931                         gctl_error(req, "No RAID level.");
 1932                         return (-3);
 1933                 }
 1934                 if (strcasecmp(levelname, "RAID5") == 0)
 1935                         levelname = "RAID5-LA";
 1936                 if (g_raid_volume_str2level(levelname, &level, &qual)) {
 1937                         gctl_error(req, "Unknown RAID level '%s'.", levelname);
 1938                         return (-4);
 1939                 }
 1940 
 1941                 /* Look for existing volumes. */
 1942                 i = 0;
 1943                 vol1 = NULL;
 1944                 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
 1945                         vol1 = vol;
 1946                         i++;
 1947                 }
 1948                 if (i > 1) {
 1949                         gctl_error(req, "Maximum two volumes supported.");
 1950                         return (-6);
 1951                 }
 1952                 if (vol1 == NULL) {
 1953                         gctl_error(req, "At least one volume must exist.");
 1954                         return (-7);
 1955                 }
 1956 
 1957                 numdisks = vol1->v_disks_count;
 1958                 force = gctl_get_paraml(req, "force", sizeof(*force));
 1959                 if (!g_raid_md_intel_supported(level, qual, numdisks,
 1960                     force ? *force : 0)) {
 1961                         gctl_error(req, "Unsupported RAID level "
 1962                             "(0x%02x/0x%02x), or number of disks (%d).",
 1963                             level, qual, numdisks);
 1964                         return (-5);
 1965                 }
 1966 
 1967                 /* Collect info about present disks. */
 1968                 size = 0x7fffffffffffffffllu;
 1969                 sectorsize = 512;
 1970                 for (i = 0; i < numdisks; i++) {
 1971                         disk = vol1->v_subdisks[i].sd_disk;
 1972                         pd = (struct g_raid_md_intel_perdisk *)
 1973                             disk->d_md_data;
 1974                         disk_sectors = 
 1975                             intel_get_disk_sectors(&pd->pd_disk_meta);
 1976 
 1977                         if (disk_sectors * 512 < size)
 1978                                 size = disk_sectors * 512;
 1979                         if (disk->d_consumer != NULL &&
 1980                             disk->d_consumer->provider != NULL &&
 1981                             disk->d_consumer->provider->sectorsize >
 1982                              sectorsize) {
 1983                                 sectorsize =
 1984                                     disk->d_consumer->provider->sectorsize;
 1985                         }
 1986                 }
 1987 
 1988                 /* Reserve some space for metadata. */
 1989                 size -= ((4096 + sectorsize - 1) / sectorsize) * sectorsize;
 1990 
 1991                 /* Decide insert before or after. */
 1992                 sd = &vol1->v_subdisks[0];
 1993                 if (sd->sd_offset >
 1994                     size - (sd->sd_offset + sd->sd_size)) {
 1995                         off = 0;
 1996                         size = sd->sd_offset;
 1997                 } else {
 1998                         off = sd->sd_offset + sd->sd_size;
 1999                         size = size - (sd->sd_offset + sd->sd_size);
 2000                 }
 2001 
 2002                 /* Handle strip argument. */
 2003                 strip = 131072;
 2004                 len = sizeof(*striparg);
 2005                 striparg = gctl_get_param(req, "strip", &len);
 2006                 if (striparg != NULL && len == sizeof(*striparg) &&
 2007                     *striparg > 0) {
 2008                         if (*striparg < sectorsize) {
 2009                                 gctl_error(req, "Strip size too small.");
 2010                                 return (-10);
 2011                         }
 2012                         if (*striparg % sectorsize != 0) {
 2013                                 gctl_error(req, "Incorrect strip size.");
 2014                                 return (-11);
 2015                         }
 2016                         if (strip > 65535 * sectorsize) {
 2017                                 gctl_error(req, "Strip size too big.");
 2018                                 return (-12);
 2019                         }
 2020                         strip = *striparg;
 2021                 }
 2022 
 2023                 /* Round offset up to strip. */
 2024                 if (off % strip != 0) {
 2025                         size -= strip - off % strip;
 2026                         off += strip - off % strip;
 2027                 }
 2028 
 2029                 /* Handle size argument. */
 2030                 len = sizeof(*sizearg);
 2031                 sizearg = gctl_get_param(req, "size", &len);
 2032                 if (sizearg != NULL && len == sizeof(*sizearg) &&
 2033                     *sizearg > 0) {
 2034                         if (*sizearg > size) {
 2035                                 gctl_error(req, "Size too big %lld > %lld.",
 2036                                     (long long)*sizearg, (long long)size);
 2037                                 return (-9);
 2038                         }
 2039                         size = *sizearg;
 2040                 }
 2041 
 2042                 /* Round size down to strip or sector. */
 2043                 if (level == G_RAID_VOLUME_RL_RAID1)
 2044                         size -= (size % sectorsize);
 2045                 else
 2046                         size -= (size % strip);
 2047                 if (size <= 0) {
 2048                         gctl_error(req, "Size too small.");
 2049                         return (-13);
 2050                 }
 2051                 if (size > 0xffffffffllu * sectorsize) {
 2052                         gctl_error(req, "Size too big.");
 2053                         return (-14);
 2054                 }
 2055 
 2056                 /* We have all we need, create things: volume, ... */
 2057                 vol = g_raid_create_volume(sc, volname, -1);
 2058                 pv = malloc(sizeof(*pv), M_MD_INTEL, M_WAITOK | M_ZERO);
 2059                 pv->pv_volume_pos = i;
 2060                 vol->v_md_data = pv;
 2061                 vol->v_raid_level = level;
 2062                 vol->v_raid_level_qualifier = qual;
 2063                 vol->v_strip_size = strip;
 2064                 vol->v_disks_count = numdisks;
 2065                 if (level == G_RAID_VOLUME_RL_RAID0)
 2066                         vol->v_mediasize = size * numdisks;
 2067                 else if (level == G_RAID_VOLUME_RL_RAID1)
 2068                         vol->v_mediasize = size;
 2069                 else if (level == G_RAID_VOLUME_RL_RAID5)
 2070                         vol->v_mediasize = size * (numdisks - 1);
 2071                 else { /* RAID1E */
 2072                         vol->v_mediasize = ((size * numdisks) / strip / 2) *
 2073                             strip;
 2074                 }
 2075                 vol->v_sectorsize = sectorsize;
 2076                 g_raid_start_volume(vol);
 2077 
 2078                 /* , and subdisks. */
 2079                 for (i = 0; i < numdisks; i++) {
 2080                         disk = vol1->v_subdisks[i].sd_disk;
 2081                         sd = &vol->v_subdisks[i];
 2082                         sd->sd_disk = disk;
 2083                         sd->sd_offset = off;
 2084                         sd->sd_size = size;
 2085                         TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
 2086                         if (disk->d_state == G_RAID_DISK_S_ACTIVE) {
 2087                                 if (level == G_RAID_VOLUME_RL_RAID5)
 2088                                         g_raid_change_subdisk_state(sd,
 2089                                             G_RAID_SUBDISK_S_UNINITIALIZED);
 2090                                 else
 2091                                         g_raid_change_subdisk_state(sd,
 2092                                             G_RAID_SUBDISK_S_ACTIVE);
 2093                                 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
 2094                                     G_RAID_EVENT_SUBDISK);
 2095                         }
 2096                 }
 2097 
 2098                 /* Write metadata based on created entities. */
 2099                 g_raid_md_write_intel(md, NULL, NULL, NULL);
 2100 
 2101                 g_raid_event_send(vol, G_RAID_VOLUME_E_START,
 2102                     G_RAID_EVENT_VOLUME);
 2103                 return (0);
 2104         }
 2105         if (strcmp(verb, "delete") == 0) {
 2106 
 2107                 nodename = gctl_get_asciiparam(req, "arg0");
 2108                 if (nodename != NULL && strcasecmp(sc->sc_name, nodename) != 0)
 2109                         nodename = NULL;
 2110 
 2111                 /* Full node destruction. */
 2112                 if (*nargs == 1 && nodename != NULL) {
 2113                         /* Check if some volume is still open. */
 2114                         force = gctl_get_paraml(req, "force", sizeof(*force));
 2115                         if (force != NULL && *force == 0 &&
 2116                             g_raid_nopens(sc) != 0) {
 2117                                 gctl_error(req, "Some volume is still open.");
 2118                                 return (-4);
 2119                         }
 2120 
 2121                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 2122                                 if (disk->d_consumer)
 2123                                         intel_meta_erase(disk->d_consumer);
 2124                         }
 2125                         g_raid_destroy_node(sc, 0);
 2126                         return (0);
 2127                 }
 2128 
 2129                 /* Destroy specified volume. If it was last - all node. */
 2130                 if (*nargs > 2) {
 2131                         gctl_error(req, "Invalid number of arguments.");
 2132                         return (-1);
 2133                 }
 2134                 volname = gctl_get_asciiparam(req,
 2135                     nodename != NULL ? "arg1" : "arg0");
 2136                 if (volname == NULL) {
 2137                         gctl_error(req, "No volume name.");
 2138                         return (-2);
 2139                 }
 2140 
 2141                 /* Search for volume. */
 2142                 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
 2143                         if (strcmp(vol->v_name, volname) == 0)
 2144                                 break;
 2145                         pp = vol->v_provider;
 2146                         if (pp == NULL)
 2147                                 continue;
 2148                         if (strcmp(pp->name, volname) == 0)
 2149                                 break;
 2150                         if (strncmp(pp->name, "raid/", 5) == 0 &&
 2151                             strcmp(pp->name + 5, volname) == 0)
 2152                                 break;
 2153                 }
 2154                 if (vol == NULL) {
 2155                         i = strtol(volname, &tmp, 10);
 2156                         if (verb != volname && tmp[0] == 0) {
 2157                                 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
 2158                                         if (vol->v_global_id == i)
 2159                                                 break;
 2160                                 }
 2161                         }
 2162                 }
 2163                 if (vol == NULL) {
 2164                         gctl_error(req, "Volume '%s' not found.", volname);
 2165                         return (-3);
 2166                 }
 2167 
 2168                 /* Check if volume is still open. */
 2169                 force = gctl_get_paraml(req, "force", sizeof(*force));
 2170                 if (force != NULL && *force == 0 &&
 2171                     vol->v_provider_open != 0) {
 2172                         gctl_error(req, "Volume is still open.");
 2173                         return (-4);
 2174                 }
 2175 
 2176                 /* Destroy volume and potentially node. */
 2177                 i = 0;
 2178                 TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next)
 2179                         i++;
 2180                 if (i >= 2) {
 2181                         g_raid_destroy_volume(vol);
 2182                         g_raid_md_write_intel(md, NULL, NULL, NULL);
 2183                 } else {
 2184                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 2185                                 if (disk->d_consumer)
 2186                                         intel_meta_erase(disk->d_consumer);
 2187                         }
 2188                         g_raid_destroy_node(sc, 0);
 2189                 }
 2190                 return (0);
 2191         }
 2192         if (strcmp(verb, "remove") == 0 ||
 2193             strcmp(verb, "fail") == 0) {
 2194                 if (*nargs < 2) {
 2195                         gctl_error(req, "Invalid number of arguments.");
 2196                         return (-1);
 2197                 }
 2198                 for (i = 1; i < *nargs; i++) {
 2199                         snprintf(arg, sizeof(arg), "arg%d", i);
 2200                         diskname = gctl_get_asciiparam(req, arg);
 2201                         if (diskname == NULL) {
 2202                                 gctl_error(req, "No disk name (%s).", arg);
 2203                                 error = -2;
 2204                                 break;
 2205                         }
 2206                         if (strncmp(diskname, "/dev/", 5) == 0)
 2207                                 diskname += 5;
 2208 
 2209                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 2210                                 if (disk->d_consumer != NULL && 
 2211                                     disk->d_consumer->provider != NULL &&
 2212                                     strcmp(disk->d_consumer->provider->name,
 2213                                      diskname) == 0)
 2214                                         break;
 2215                         }
 2216                         if (disk == NULL) {
 2217                                 gctl_error(req, "Disk '%s' not found.",
 2218                                     diskname);
 2219                                 error = -3;
 2220                                 break;
 2221                         }
 2222 
 2223                         if (strcmp(verb, "fail") == 0) {
 2224                                 g_raid_md_fail_disk_intel(md, NULL, disk);
 2225                                 continue;
 2226                         }
 2227 
 2228                         pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 2229 
 2230                         /* Erase metadata on deleting disk. */
 2231                         intel_meta_erase(disk->d_consumer);
 2232 
 2233                         /* If disk was assigned, just update statuses. */
 2234                         if (pd->pd_disk_pos >= 0) {
 2235                                 g_raid_change_disk_state(disk, G_RAID_DISK_S_OFFLINE);
 2236                                 g_raid_kill_consumer(sc, disk->d_consumer);
 2237                                 disk->d_consumer = NULL;
 2238                                 TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
 2239                                         g_raid_change_subdisk_state(sd,
 2240                                             G_RAID_SUBDISK_S_NONE);
 2241                                         g_raid_event_send(sd, G_RAID_SUBDISK_E_DISCONNECTED,
 2242                                             G_RAID_EVENT_SUBDISK);
 2243                                 }
 2244                         } else {
 2245                                 /* Otherwise -- delete. */
 2246                                 g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
 2247                                 g_raid_destroy_disk(disk);
 2248                         }
 2249                 }
 2250 
 2251                 /* Write updated metadata to remaining disks. */
 2252                 g_raid_md_write_intel(md, NULL, NULL, NULL);
 2253 
 2254                 /* Check if anything left except placeholders. */
 2255                 if (g_raid_ndisks(sc, -1) ==
 2256                     g_raid_ndisks(sc, G_RAID_DISK_S_OFFLINE))
 2257                         g_raid_destroy_node(sc, 0);
 2258                 else
 2259                         g_raid_md_intel_refill(sc);
 2260                 return (error);
 2261         }
 2262         if (strcmp(verb, "insert") == 0) {
 2263                 if (*nargs < 2) {
 2264                         gctl_error(req, "Invalid number of arguments.");
 2265                         return (-1);
 2266                 }
 2267                 update = 0;
 2268                 for (i = 1; i < *nargs; i++) {
 2269                         /* Get disk name. */
 2270                         snprintf(arg, sizeof(arg), "arg%d", i);
 2271                         diskname = gctl_get_asciiparam(req, arg);
 2272                         if (diskname == NULL) {
 2273                                 gctl_error(req, "No disk name (%s).", arg);
 2274                                 error = -3;
 2275                                 break;
 2276                         }
 2277 
 2278                         /* Try to find provider with specified name. */
 2279                         g_topology_lock();
 2280                         cp = g_raid_open_consumer(sc, diskname);
 2281                         if (cp == NULL) {
 2282                                 gctl_error(req, "Can't open disk '%s'.",
 2283                                     diskname);
 2284                                 g_topology_unlock();
 2285                                 error = -4;
 2286                                 break;
 2287                         }
 2288                         pp = cp->provider;
 2289                         g_topology_unlock();
 2290 
 2291                         /* Read disk serial. */
 2292                         error = g_raid_md_get_label(cp,
 2293                             &serial[0], INTEL_SERIAL_LEN);
 2294                         if (error != 0) {
 2295                                 gctl_error(req,
 2296                                     "Can't get serial for provider '%s'.",
 2297                                     diskname);
 2298                                 g_raid_kill_consumer(sc, cp);
 2299                                 error = -7;
 2300                                 break;
 2301                         }
 2302 
 2303                         pd = malloc(sizeof(*pd), M_MD_INTEL, M_WAITOK | M_ZERO);
 2304                         pd->pd_disk_pos = -1;
 2305 
 2306                         disk = g_raid_create_disk(sc);
 2307                         disk->d_consumer = cp;
 2308                         disk->d_md_data = (void *)pd;
 2309                         cp->private = disk;
 2310 
 2311                         g_raid_get_disk_info(disk);
 2312 
 2313                         memcpy(&pd->pd_disk_meta.serial[0], &serial[0],
 2314                             INTEL_SERIAL_LEN);
 2315                         intel_set_disk_sectors(&pd->pd_disk_meta,
 2316                             pp->mediasize / pp->sectorsize);
 2317                         pd->pd_disk_meta.id = 0;
 2318                         pd->pd_disk_meta.flags = INTEL_F_SPARE;
 2319 
 2320                         /* Welcome the "new" disk. */
 2321                         update += g_raid_md_intel_start_disk(disk);
 2322                         if (disk->d_state == G_RAID_DISK_S_SPARE) {
 2323                                 intel_meta_write_spare(cp, &pd->pd_disk_meta);
 2324                                 g_raid_destroy_disk(disk);
 2325                         } else if (disk->d_state != G_RAID_DISK_S_ACTIVE) {
 2326                                 gctl_error(req, "Disk '%s' doesn't fit.",
 2327                                     diskname);
 2328                                 g_raid_destroy_disk(disk);
 2329                                 error = -8;
 2330                                 break;
 2331                         }
 2332                 }
 2333 
 2334                 /* Write new metadata if we changed something. */
 2335                 if (update)
 2336                         g_raid_md_write_intel(md, NULL, NULL, NULL);
 2337                 return (error);
 2338         }
 2339         return (-100);
 2340 }
 2341 
 2342 static int
 2343 g_raid_md_write_intel(struct g_raid_md_object *md, struct g_raid_volume *tvol,
 2344     struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
 2345 {
 2346         struct g_raid_softc *sc;
 2347         struct g_raid_volume *vol;
 2348         struct g_raid_subdisk *sd;
 2349         struct g_raid_disk *disk;
 2350         struct g_raid_md_intel_object *mdi;
 2351         struct g_raid_md_intel_pervolume *pv;
 2352         struct g_raid_md_intel_perdisk *pd;
 2353         struct intel_raid_conf *meta;
 2354         struct intel_raid_vol *mvol;
 2355         struct intel_raid_map *mmap0, *mmap1;
 2356         off_t sectorsize = 512, pos;
 2357         const char *version, *cv;
 2358         int vi, sdi, numdisks, len, state, stale;
 2359 
 2360         sc = md->mdo_softc;
 2361         mdi = (struct g_raid_md_intel_object *)md;
 2362 
 2363         if (sc->sc_stopping == G_RAID_DESTROY_HARD)
 2364                 return (0);
 2365 
 2366         /* Bump generation. Newly written metadata may differ from previous. */
 2367         mdi->mdio_generation++;
 2368 
 2369         /* Count number of disks. */
 2370         numdisks = 0;
 2371         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 2372                 pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 2373                 if (pd->pd_disk_pos < 0)
 2374                         continue;
 2375                 numdisks++;
 2376                 if (disk->d_state == G_RAID_DISK_S_ACTIVE) {
 2377                         pd->pd_disk_meta.flags =
 2378                             INTEL_F_ONLINE | INTEL_F_ASSIGNED;
 2379                 } else if (disk->d_state == G_RAID_DISK_S_FAILED) {
 2380                         pd->pd_disk_meta.flags = INTEL_F_FAILED |
 2381                             INTEL_F_ASSIGNED;
 2382                 } else if (disk->d_state == G_RAID_DISK_S_DISABLED) {
 2383                         pd->pd_disk_meta.flags = INTEL_F_FAILED |
 2384                             INTEL_F_ASSIGNED | INTEL_F_DISABLED;
 2385                 } else {
 2386                         if (!(pd->pd_disk_meta.flags & INTEL_F_DISABLED))
 2387                                 pd->pd_disk_meta.flags = INTEL_F_ASSIGNED;
 2388                         if (pd->pd_disk_meta.id != 0xffffffff) {
 2389                                 pd->pd_disk_meta.id = 0xffffffff;
 2390                                 len = strlen(pd->pd_disk_meta.serial);
 2391                                 len = min(len, INTEL_SERIAL_LEN - 3);
 2392                                 strcpy(pd->pd_disk_meta.serial + len, ":0");
 2393                         }
 2394                 }
 2395         }
 2396 
 2397         /* Fill anchor and disks. */
 2398         meta = malloc(INTEL_MAX_MD_SIZE(numdisks),
 2399             M_MD_INTEL, M_WAITOK | M_ZERO);
 2400         memcpy(&meta->intel_id[0], INTEL_MAGIC, sizeof(INTEL_MAGIC) - 1);
 2401         meta->config_size = INTEL_MAX_MD_SIZE(numdisks);
 2402         meta->config_id = mdi->mdio_config_id;
 2403         meta->orig_config_id = mdi->mdio_orig_config_id;
 2404         meta->generation = mdi->mdio_generation;
 2405         meta->attributes = INTEL_ATTR_CHECKSUM;
 2406         meta->total_disks = numdisks;
 2407         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 2408                 pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 2409                 if (pd->pd_disk_pos < 0)
 2410                         continue;
 2411                 meta->disk[pd->pd_disk_pos] = pd->pd_disk_meta;
 2412                 if (pd->pd_disk_meta.sectors_hi != 0)
 2413                         meta->attributes |= INTEL_ATTR_2TB_DISK;
 2414         }
 2415 
 2416         /* Fill volumes and maps. */
 2417         vi = 0;
 2418         version = INTEL_VERSION_1000;
 2419         TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) {
 2420                 pv = vol->v_md_data;
 2421                 if (vol->v_stopping)
 2422                         continue;
 2423                 mvol = intel_get_volume(meta, vi);
 2424 
 2425                 /* New metadata may have different volumes order. */
 2426                 pv->pv_volume_pos = vi;
 2427 
 2428                 for (sdi = 0; sdi < vol->v_disks_count; sdi++) {
 2429                         sd = &vol->v_subdisks[sdi];
 2430                         if (sd->sd_disk != NULL)
 2431                                 break;
 2432                 }
 2433                 if (sdi >= vol->v_disks_count)
 2434                         panic("No any filled subdisk in volume");
 2435                 if (vol->v_mediasize >= 0x20000000000llu)
 2436                         meta->attributes |= INTEL_ATTR_2TB;
 2437                 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID0)
 2438                         meta->attributes |= INTEL_ATTR_RAID0;
 2439                 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1)
 2440                         meta->attributes |= INTEL_ATTR_RAID1;
 2441                 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID5)
 2442                         meta->attributes |= INTEL_ATTR_RAID5;
 2443                 else if ((vol->v_disks_count & 1) == 0)
 2444                         meta->attributes |= INTEL_ATTR_RAID10;
 2445                 else
 2446                         meta->attributes |= INTEL_ATTR_RAID1E;
 2447                 if (pv->pv_cng)
 2448                         meta->attributes |= INTEL_ATTR_RAIDCNG;
 2449                 if (vol->v_strip_size > 131072)
 2450                         meta->attributes |= INTEL_ATTR_EXT_STRIP;
 2451 
 2452                 if (pv->pv_cng)
 2453                         cv = INTEL_VERSION_1206;
 2454                 else if (vol->v_disks_count > 4)
 2455                         cv = INTEL_VERSION_1204;
 2456                 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID5)
 2457                         cv = INTEL_VERSION_1202;
 2458                 else if (vol->v_disks_count > 2)
 2459                         cv = INTEL_VERSION_1201;
 2460                 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1)
 2461                         cv = INTEL_VERSION_1100;
 2462                 else
 2463                         cv = INTEL_VERSION_1000;
 2464                 if (strcmp(cv, version) > 0)
 2465                         version = cv;
 2466 
 2467                 strlcpy(&mvol->name[0], vol->v_name, sizeof(mvol->name));
 2468                 mvol->total_sectors = vol->v_mediasize / sectorsize;
 2469                 mvol->state = (INTEL_ST_READ_COALESCING |
 2470                     INTEL_ST_WRITE_COALESCING);
 2471                 mvol->tid = vol->v_global_id + 1;
 2472                 if (pv->pv_cng) {
 2473                         mvol->state |= INTEL_ST_CLONE_N_GO;
 2474                         if (pv->pv_cng_man_sync)
 2475                                 mvol->state |= INTEL_ST_CLONE_MAN_SYNC;
 2476                         mvol->cng_master_disk = pv->pv_cng_master_disk;
 2477                         if (vol->v_subdisks[pv->pv_cng_master_disk].sd_state ==
 2478                             G_RAID_SUBDISK_S_NONE)
 2479                                 mvol->cng_state = INTEL_CNGST_MASTER_MISSING;
 2480                         else if (vol->v_state != G_RAID_VOLUME_S_OPTIMAL)
 2481                                 mvol->cng_state = INTEL_CNGST_NEEDS_UPDATE;
 2482                         else
 2483                                 mvol->cng_state = INTEL_CNGST_UPDATED;
 2484                 }
 2485 
 2486                 /* Check for any recovery in progress. */
 2487                 state = G_RAID_SUBDISK_S_ACTIVE;
 2488                 pos = 0x7fffffffffffffffllu;
 2489                 stale = 0;
 2490                 for (sdi = 0; sdi < vol->v_disks_count; sdi++) {
 2491                         sd = &vol->v_subdisks[sdi];
 2492                         if (sd->sd_state == G_RAID_SUBDISK_S_REBUILD)
 2493                                 state = G_RAID_SUBDISK_S_REBUILD;
 2494                         else if (sd->sd_state == G_RAID_SUBDISK_S_RESYNC &&
 2495                             state != G_RAID_SUBDISK_S_REBUILD)
 2496                                 state = G_RAID_SUBDISK_S_RESYNC;
 2497                         else if (sd->sd_state == G_RAID_SUBDISK_S_STALE)
 2498                                 stale = 1;
 2499                         if ((sd->sd_state == G_RAID_SUBDISK_S_REBUILD ||
 2500                             sd->sd_state == G_RAID_SUBDISK_S_RESYNC) &&
 2501                              sd->sd_rebuild_pos < pos)
 2502                                 pos = sd->sd_rebuild_pos;
 2503                 }
 2504                 if (state == G_RAID_SUBDISK_S_REBUILD) {
 2505                         mvol->migr_state = 1;
 2506                         mvol->migr_type = INTEL_MT_REBUILD;
 2507                 } else if (state == G_RAID_SUBDISK_S_RESYNC) {
 2508                         mvol->migr_state = 1;
 2509                         /* mvol->migr_type = INTEL_MT_REPAIR; */
 2510                         mvol->migr_type = INTEL_MT_VERIFY;
 2511                         mvol->state |= INTEL_ST_VERIFY_AND_FIX;
 2512                 } else
 2513                         mvol->migr_state = 0;
 2514                 mvol->dirty = (vol->v_dirty || stale);
 2515 
 2516                 mmap0 = intel_get_map(mvol, 0);
 2517 
 2518                 /* Write map / common part of two maps. */
 2519                 intel_set_map_offset(mmap0, sd->sd_offset / sectorsize);
 2520                 intel_set_map_disk_sectors(mmap0, sd->sd_size / sectorsize);
 2521                 mmap0->strip_sectors = vol->v_strip_size / sectorsize;
 2522                 if (vol->v_state == G_RAID_VOLUME_S_BROKEN)
 2523                         mmap0->status = INTEL_S_FAILURE;
 2524                 else if (vol->v_state == G_RAID_VOLUME_S_DEGRADED)
 2525                         mmap0->status = INTEL_S_DEGRADED;
 2526                 else if (g_raid_nsubdisks(vol, G_RAID_SUBDISK_S_UNINITIALIZED)
 2527                     == g_raid_nsubdisks(vol, -1))
 2528                         mmap0->status = INTEL_S_UNINITIALIZED;
 2529                 else
 2530                         mmap0->status = INTEL_S_READY;
 2531                 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID0)
 2532                         mmap0->type = INTEL_T_RAID0;
 2533                 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 ||
 2534                     vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E)
 2535                         mmap0->type = INTEL_T_RAID1;
 2536                 else
 2537                         mmap0->type = INTEL_T_RAID5;
 2538                 mmap0->total_disks = vol->v_disks_count;
 2539                 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1)
 2540                         mmap0->total_domains = vol->v_disks_count;
 2541                 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E)
 2542                         mmap0->total_domains = 2;
 2543                 else
 2544                         mmap0->total_domains = 1;
 2545                 intel_set_map_stripe_count(mmap0,
 2546                     sd->sd_size / vol->v_strip_size / mmap0->total_domains);
 2547                 mmap0->failed_disk_num = 0xff;
 2548                 mmap0->ddf = 1;
 2549 
 2550                 /* If there are two maps - copy common and update. */
 2551                 if (mvol->migr_state) {
 2552                         intel_set_vol_curr_migr_unit(mvol,
 2553                             pos / vol->v_strip_size / mmap0->total_domains);
 2554                         mmap1 = intel_get_map(mvol, 1);
 2555                         memcpy(mmap1, mmap0, sizeof(struct intel_raid_map));
 2556                         mmap0->status = INTEL_S_READY;
 2557                 } else
 2558                         mmap1 = NULL;
 2559 
 2560                 /* Write disk indexes and put rebuild flags. */
 2561                 for (sdi = 0; sdi < vol->v_disks_count; sdi++) {
 2562                         sd = &vol->v_subdisks[sdi];
 2563                         pd = (struct g_raid_md_intel_perdisk *)
 2564                             sd->sd_disk->d_md_data;
 2565                         mmap0->disk_idx[sdi] = pd->pd_disk_pos;
 2566                         if (mvol->migr_state)
 2567                                 mmap1->disk_idx[sdi] = pd->pd_disk_pos;
 2568                         if (sd->sd_state == G_RAID_SUBDISK_S_REBUILD ||
 2569                             sd->sd_state == G_RAID_SUBDISK_S_RESYNC) {
 2570                                 mmap1->disk_idx[sdi] |= INTEL_DI_RBLD;
 2571                         } else if (sd->sd_state != G_RAID_SUBDISK_S_ACTIVE &&
 2572                             sd->sd_state != G_RAID_SUBDISK_S_STALE &&
 2573                             sd->sd_state != G_RAID_SUBDISK_S_UNINITIALIZED) {
 2574                                 mmap0->disk_idx[sdi] |= INTEL_DI_RBLD;
 2575                                 if (mvol->migr_state)
 2576                                         mmap1->disk_idx[sdi] |= INTEL_DI_RBLD;
 2577                         }
 2578                         if ((sd->sd_state == G_RAID_SUBDISK_S_NONE ||
 2579                              sd->sd_state == G_RAID_SUBDISK_S_FAILED ||
 2580                              sd->sd_state == G_RAID_SUBDISK_S_REBUILD) &&
 2581                             mmap0->failed_disk_num == 0xff) {
 2582                                 mmap0->failed_disk_num = sdi;
 2583                                 if (mvol->migr_state)
 2584                                         mmap1->failed_disk_num = sdi;
 2585                         }
 2586                 }
 2587                 vi++;
 2588         }
 2589         meta->total_volumes = vi;
 2590         if (vi > 1 || meta->attributes &
 2591              (INTEL_ATTR_EXT_STRIP | INTEL_ATTR_2TB_DISK | INTEL_ATTR_2TB))
 2592                 version = INTEL_VERSION_1300;
 2593         if (strcmp(version, INTEL_VERSION_1300) < 0)
 2594                 meta->attributes &= INTEL_ATTR_CHECKSUM;
 2595         memcpy(&meta->version[0], version, sizeof(INTEL_VERSION_1000) - 1);
 2596 
 2597         /* We are done. Print meta data and store them to disks. */
 2598         g_raid_md_intel_print(meta);
 2599         if (mdi->mdio_meta != NULL)
 2600                 free(mdi->mdio_meta, M_MD_INTEL);
 2601         mdi->mdio_meta = meta;
 2602         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 2603                 pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 2604                 if (disk->d_state != G_RAID_DISK_S_ACTIVE)
 2605                         continue;
 2606                 if (pd->pd_meta != NULL) {
 2607                         free(pd->pd_meta, M_MD_INTEL);
 2608                         pd->pd_meta = NULL;
 2609                 }
 2610                 pd->pd_meta = intel_meta_copy(meta);
 2611                 intel_meta_write(disk->d_consumer, meta);
 2612         }
 2613         return (0);
 2614 }
 2615 
 2616 static int
 2617 g_raid_md_fail_disk_intel(struct g_raid_md_object *md,
 2618     struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
 2619 {
 2620         struct g_raid_softc *sc;
 2621         struct g_raid_md_intel_object *mdi;
 2622         struct g_raid_md_intel_perdisk *pd;
 2623         struct g_raid_subdisk *sd;
 2624 
 2625         sc = md->mdo_softc;
 2626         mdi = (struct g_raid_md_intel_object *)md;
 2627         pd = (struct g_raid_md_intel_perdisk *)tdisk->d_md_data;
 2628 
 2629         /* We can't fail disk that is not a part of array now. */
 2630         if (pd->pd_disk_pos < 0)
 2631                 return (-1);
 2632 
 2633         /*
 2634          * Mark disk as failed in metadata and try to write that metadata
 2635          * to the disk itself to prevent it's later resurrection as STALE.
 2636          */
 2637         mdi->mdio_meta->disk[pd->pd_disk_pos].flags = INTEL_F_FAILED;
 2638         pd->pd_disk_meta.flags = INTEL_F_FAILED;
 2639         g_raid_md_intel_print(mdi->mdio_meta);
 2640         if (tdisk->d_consumer)
 2641                 intel_meta_write(tdisk->d_consumer, mdi->mdio_meta);
 2642 
 2643         /* Change states. */
 2644         g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED);
 2645         TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) {
 2646                 g_raid_change_subdisk_state(sd,
 2647                     G_RAID_SUBDISK_S_FAILED);
 2648                 g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED,
 2649                     G_RAID_EVENT_SUBDISK);
 2650         }
 2651 
 2652         /* Write updated metadata to remaining disks. */
 2653         g_raid_md_write_intel(md, NULL, NULL, tdisk);
 2654 
 2655         /* Check if anything left except placeholders. */
 2656         if (g_raid_ndisks(sc, -1) ==
 2657             g_raid_ndisks(sc, G_RAID_DISK_S_OFFLINE))
 2658                 g_raid_destroy_node(sc, 0);
 2659         else
 2660                 g_raid_md_intel_refill(sc);
 2661         return (0);
 2662 }
 2663 
 2664 static int
 2665 g_raid_md_free_disk_intel(struct g_raid_md_object *md,
 2666     struct g_raid_disk *disk)
 2667 {
 2668         struct g_raid_md_intel_perdisk *pd;
 2669 
 2670         pd = (struct g_raid_md_intel_perdisk *)disk->d_md_data;
 2671         if (pd->pd_meta != NULL) {
 2672                 free(pd->pd_meta, M_MD_INTEL);
 2673                 pd->pd_meta = NULL;
 2674         }
 2675         free(pd, M_MD_INTEL);
 2676         disk->d_md_data = NULL;
 2677         return (0);
 2678 }
 2679 
 2680 static int
 2681 g_raid_md_free_volume_intel(struct g_raid_md_object *md,
 2682     struct g_raid_volume *vol)
 2683 {
 2684         struct g_raid_md_intel_pervolume *pv;
 2685 
 2686         pv = (struct g_raid_md_intel_pervolume *)vol->v_md_data;
 2687         free(pv, M_MD_INTEL);
 2688         vol->v_md_data = NULL;
 2689         return (0);
 2690 }
 2691 
 2692 static int
 2693 g_raid_md_free_intel(struct g_raid_md_object *md)
 2694 {
 2695         struct g_raid_md_intel_object *mdi;
 2696 
 2697         mdi = (struct g_raid_md_intel_object *)md;
 2698         if (!mdi->mdio_started) {
 2699                 mdi->mdio_started = 0;
 2700                 callout_stop(&mdi->mdio_start_co);
 2701                 G_RAID_DEBUG1(1, md->mdo_softc,
 2702                     "root_mount_rel %p", mdi->mdio_rootmount);
 2703                 root_mount_rel(mdi->mdio_rootmount);
 2704                 mdi->mdio_rootmount = NULL;
 2705         }
 2706         if (mdi->mdio_meta != NULL) {
 2707                 free(mdi->mdio_meta, M_MD_INTEL);
 2708                 mdi->mdio_meta = NULL;
 2709         }
 2710         return (0);
 2711 }
 2712 
 2713 G_RAID_MD_DECLARE(intel, "Intel");

Cache object: 7f29622c779d78007c1afffac6f612ca


[ 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.