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

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