sys/geom/raid/md_sii.c

   1 /*-
   2  * Copyright (c) 2011 Alexander Motin <mav@FreeBSD.org>
   3  * Copyright (c) 2000 - 2008 Søren Schmidt <sos@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/bio.h>
  33 #include <sys/endian.h>
  34 #include <sys/kernel.h>
  35 #include <sys/kobj.h>
  36 #include <sys/limits.h>
  37 #include <sys/lock.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mutex.h>
  40 #include <sys/systm.h>
  41 #include <sys/taskqueue.h>
  42 #include <geom/geom.h>
  43 #include "geom/raid/g_raid.h"
  44 #include "g_raid_md_if.h"
  45
  46 static MALLOC_DEFINE(M_MD_SII, "md_sii_data", "GEOM_RAID SiI metadata");
  47
  48 struct sii_raid_conf {
  49         uint16_t        ata_params_00_53[54];
  50         uint64_t        total_sectors;          /* 54 - 57 */
  51         uint16_t        ata_params_58_81[72];
  52         uint16_t        product_id;             /* 130 */
  53         uint16_t        vendor_id;              /* 131 */
  54         uint16_t        version_minor;          /* 132 */
  55         uint16_t        version_major;          /* 133 */
  56         uint8_t         timestamp[6];           /* 134 - 136 */
  57         uint16_t        strip_sectors;          /* 137 */
  58         uint16_t        dummy_2;
  59         uint8_t         disk_number;            /* 139 */
  60         uint8_t         type;
  61 #define SII_T_RAID0             0x00
  62 #define SII_T_RAID1             0x01
  63 #define SII_T_RAID01            0x02
  64 #define SII_T_SPARE             0x03
  65 #define SII_T_CONCAT            0x04
  66 #define SII_T_RAID5             0x10
  67 #define SII_T_RESERVED          0xfd
  68 #define SII_T_JBOD              0xff
  69
  70         uint8_t         raid0_disks;            /* 140 */
  71         uint8_t         raid0_ident;
  72         uint8_t         raid1_disks;            /* 141 */
  73         uint8_t         raid1_ident;
  74         uint64_t        rebuild_lba;            /* 142 - 145 */
  75         uint32_t        generation;             /* 146 - 147 */
  76         uint8_t         disk_status;            /* 148 */
  77 #define SII_S_CURRENT           0x01
  78 #define SII_S_REBUILD           0x02
  79 #define SII_S_DROPPED           0x03
  80 #define SII_S_REMOVED           0x04
  81
  82         uint8_t         raid_status;
  83 #define SII_S_ONLINE            0x01
  84 #define SII_S_AVAILABLE         0x02
  85
  86         uint8_t         raid_location;          /* 149 */
  87         uint8_t         disk_location;
  88         uint8_t         auto_rebuild;           /* 150 */
  89 #define SII_R_REBUILD           0x00
  90 #define SII_R_NOREBUILD         0xff
  91
  92         uint8_t         dummy_3;
  93         uint8_t         name[16];               /* 151 - 158 */
  94         uint16_t        checksum;               /* 159 */
  95         uint16_t        ata_params_160_255[96];
  96 } __packed;
  97
  98 struct g_raid_md_sii_perdisk {
  99         struct sii_raid_conf    *pd_meta;
 100         int                      pd_disk_pos;
 101         off_t                    pd_disk_size;
 102 };
 103
 104 struct g_raid_md_sii_object {
 105         struct g_raid_md_object  mdio_base;
 106         uint8_t                  mdio_timestamp[6];
 107         uint8_t                  mdio_location;
 108         uint32_t                 mdio_generation;
 109         struct sii_raid_conf    *mdio_meta;
 110         struct callout           mdio_start_co; /* STARTING state timer. */
 111         int                      mdio_total_disks;
 112         int                      mdio_disks_present;
 113         int                      mdio_started;
 114         int                      mdio_incomplete;
 115         struct root_hold_token  *mdio_rootmount; /* Root mount delay token. */
 116 };
 117
 118 static g_raid_md_create_t g_raid_md_create_sii;
 119 static g_raid_md_taste_t g_raid_md_taste_sii;
 120 static g_raid_md_event_t g_raid_md_event_sii;
 121 static g_raid_md_ctl_t g_raid_md_ctl_sii;
 122 static g_raid_md_write_t g_raid_md_write_sii;
 123 static g_raid_md_fail_disk_t g_raid_md_fail_disk_sii;
 124 static g_raid_md_free_disk_t g_raid_md_free_disk_sii;
 125 static g_raid_md_free_t g_raid_md_free_sii;
 126
 127 static kobj_method_t g_raid_md_sii_methods[] = {
 128         KOBJMETHOD(g_raid_md_create,    g_raid_md_create_sii),
 129         KOBJMETHOD(g_raid_md_taste,     g_raid_md_taste_sii),
 130         KOBJMETHOD(g_raid_md_event,     g_raid_md_event_sii),
 131         KOBJMETHOD(g_raid_md_ctl,       g_raid_md_ctl_sii),
 132         KOBJMETHOD(g_raid_md_write,     g_raid_md_write_sii),
 133         KOBJMETHOD(g_raid_md_fail_disk, g_raid_md_fail_disk_sii),
 134         KOBJMETHOD(g_raid_md_free_disk, g_raid_md_free_disk_sii),
 135         KOBJMETHOD(g_raid_md_free,      g_raid_md_free_sii),
 136         { 0, 0 }
 137 };
 138
 139 static struct g_raid_md_class g_raid_md_sii_class = {
 140         "SiI",
 141         g_raid_md_sii_methods,
 142         sizeof(struct g_raid_md_sii_object),
 143         .mdc_enable = 1,
 144         .mdc_priority = 100
 145 };
 146
 147 static void
 148 g_raid_md_sii_print(struct sii_raid_conf *meta)
 149 {
 150
 151         if (g_raid_debug < 1)
 152                 return;
 153
 154         printf("********* ATA SiI RAID Metadata *********\n");
 155         printf("total_sectors       %llu\n",
 156             (long long unsigned)meta->total_sectors);
 157         printf("product_id          0x%04x\n", meta->product_id);
 158         printf("vendor_id           0x%04x\n", meta->vendor_id);
 159         printf("version_minor       0x%04x\n", meta->version_minor);
 160         printf("version_major       0x%04x\n", meta->version_major);
 161         printf("timestamp           0x%02x%02x%02x%02x%02x%02x\n",
 162             meta->timestamp[5], meta->timestamp[4], meta->timestamp[3],
 163             meta->timestamp[2], meta->timestamp[1], meta->timestamp[0]);
 164         printf("strip_sectors       %d\n", meta->strip_sectors);
 165         printf("disk_number         %d\n", meta->disk_number);
 166         printf("type                0x%02x\n", meta->type);
 167         printf("raid0_disks         %d\n", meta->raid0_disks);
 168         printf("raid0_ident         %d\n", meta->raid0_ident);
 169         printf("raid1_disks         %d\n", meta->raid1_disks);
 170         printf("raid1_ident         %d\n", meta->raid1_ident);
 171         printf("rebuild_lba         %llu\n",
 172             (long long unsigned)meta->rebuild_lba);
 173         printf("generation          %d\n", meta->generation);
 174         printf("disk_status         %d\n", meta->disk_status);
 175         printf("raid_status         %d\n", meta->raid_status);
 176         printf("raid_location       %d\n", meta->raid_location);
 177         printf("disk_location       %d\n", meta->disk_location);
 178         printf("auto_rebuild        %d\n", meta->auto_rebuild);
 179         printf("name                <%.16s>\n", meta->name);
 180         printf("checksum            0x%04x\n", meta->checksum);
 181         printf("=================================================\n");
 182 }
 183
 184 static struct sii_raid_conf *
 185 sii_meta_copy(struct sii_raid_conf *meta)
 186 {
 187         struct sii_raid_conf *nmeta;
 188
 189         nmeta = malloc(sizeof(*meta), M_MD_SII, M_WAITOK);
 190         memcpy(nmeta, meta, sizeof(*meta));
 191         return (nmeta);
 192 }
 193
 194 static int
 195 sii_meta_total_disks(struct sii_raid_conf *meta)
 196 {
 197
 198         switch (meta->type) {
 199         case SII_T_RAID0:
 200         case SII_T_RAID5:
 201         case SII_T_CONCAT:
 202                 return (meta->raid0_disks);
 203         case SII_T_RAID1:
 204                 return (meta->raid1_disks);
 205         case SII_T_RAID01:
 206                 return (meta->raid0_disks * meta->raid1_disks);
 207         case SII_T_SPARE:
 208         case SII_T_JBOD:
 209                 return (1);
 210         }
 211         return (0);
 212 }
 213
 214 static int
 215 sii_meta_disk_pos(struct sii_raid_conf *meta, struct sii_raid_conf *pdmeta)
 216 {
 217
 218         if (pdmeta->type == SII_T_SPARE)
 219                 return (-3);
 220
 221         if (memcmp(&meta->timestamp, &pdmeta->timestamp, 6) != 0)
 222                 return (-1);
 223
 224         switch (pdmeta->type) {
 225         case SII_T_RAID0:
 226         case SII_T_RAID1:
 227         case SII_T_RAID5:
 228         case SII_T_CONCAT:
 229                 return (pdmeta->disk_number);
 230         case SII_T_RAID01:
 231                 return (pdmeta->raid1_ident * pdmeta->raid1_disks +
 232                     pdmeta->raid0_ident);
 233         case SII_T_JBOD:
 234                 return (0);
 235         }
 236         return (-1);
 237 }
 238
 239 static void
 240 sii_meta_get_name(struct sii_raid_conf *meta, char *buf)
 241 {
 242         int i;
 243
 244         strncpy(buf, meta->name, 16);
 245         buf[16] = 0;
 246         for (i = 15; i >= 0; i--) {
 247                 if (buf[i] > 0x20)
 248                         break;
 249                 buf[i] = 0;
 250         }
 251 }
 252
 253 static void
 254 sii_meta_put_name(struct sii_raid_conf *meta, char *buf)
 255 {
 256
 257         memset(meta->name, 0x20, 16);
 258         memcpy(meta->name, buf, MIN(strlen(buf), 16));
 259 }
 260
 261 static struct sii_raid_conf *
 262 sii_meta_read(struct g_consumer *cp)
 263 {
 264         struct g_provider *pp;
 265         struct sii_raid_conf *meta;
 266         char *buf;
 267         int error, i;
 268         uint16_t checksum, *ptr;
 269
 270         pp = cp->provider;
 271
 272         /* Read the anchor sector. */
 273         buf = g_read_data(cp,
 274             pp->mediasize - pp->sectorsize, pp->sectorsize, &error);
 275         if (buf == NULL) {
 276                 G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).",
 277                     pp->name, error);
 278                 return (NULL);
 279         }
 280         meta = malloc(sizeof(*meta), M_MD_SII, M_WAITOK);
 281         memcpy(meta, buf, min(sizeof(*meta), pp->sectorsize));
 282         g_free(buf);
 283
 284         /* Check vendor ID. */
 285         if (meta->vendor_id != 0x1095) {
 286                 G_RAID_DEBUG(1, "SiI vendor ID check failed on %s (0x%04x)",
 287                     pp->name, meta->vendor_id);
 288                 free(meta, M_MD_SII);
 289                 return (NULL);
 290         }
 291
 292         /* Check metadata major version. */
 293         if (meta->version_major != 2) {
 294                 G_RAID_DEBUG(1, "SiI version check failed on %s (%d.%d)",
 295                     pp->name, meta->version_major, meta->version_minor);
 296                 free(meta, M_MD_SII);
 297                 return (NULL);
 298         }
 299
 300         /* Check metadata checksum. */
 301         for (checksum = 0, ptr = (uint16_t *)meta, i = 0; i <= 159; i++)
 302                 checksum += *ptr++;
 303         if (checksum != 0) {
 304                 G_RAID_DEBUG(1, "SiI checksum check failed on %s", pp->name);
 305                 free(meta, M_MD_SII);
 306                 return (NULL);
 307         }
 308
 309         /* Check raid type. */
 310         if (meta->type != SII_T_RAID0 && meta->type != SII_T_RAID1 &&
 311             meta->type != SII_T_RAID01 && meta->type != SII_T_SPARE &&
 312             meta->type != SII_T_RAID5 && meta->type != SII_T_CONCAT &&
 313             meta->type != SII_T_JBOD) {
 314                 G_RAID_DEBUG(1, "SiI unknown RAID level on %s (0x%02x)",
 315                     pp->name, meta->type);
 316                 free(meta, M_MD_SII);
 317                 return (NULL);
 318         }
 319
 320         return (meta);
 321 }
 322
 323 static int
 324 sii_meta_write(struct g_consumer *cp, struct sii_raid_conf *meta)
 325 {
 326         struct g_provider *pp;
 327         char *buf;
 328         int error, i;
 329         uint16_t checksum, *ptr;
 330
 331         pp = cp->provider;
 332
 333         /* Recalculate checksum for case if metadata were changed. */
 334         meta->checksum = 0;
 335         for (checksum = 0, ptr = (uint16_t *)meta, i = 0; i < 159; i++)
 336                 checksum += *ptr++;
 337         meta->checksum -= checksum;
 338
 339         /* Create and fill buffer. */
 340         buf = malloc(pp->sectorsize, M_MD_SII, M_WAITOK | M_ZERO);
 341         memcpy(buf, meta, sizeof(*meta));
 342
 343         /* Write 4 copies of metadata. */
 344         for (i = 0; i < 4; i++) {
 345                 error = g_write_data(cp,
 346                     pp->mediasize - (pp->sectorsize * (1 + 0x200 * i)),
 347                     buf, pp->sectorsize);
 348                 if (error != 0) {
 349                         G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).",
 350                             pp->name, error);
 351                         break;
 352                 }
 353         }
 354
 355         free(buf, M_MD_SII);
 356         return (error);
 357 }
 358
 359 static int
 360 sii_meta_erase(struct g_consumer *cp)
 361 {
 362         struct g_provider *pp;
 363         char *buf;
 364         int error, i;
 365
 366         pp = cp->provider;
 367         buf = malloc(pp->sectorsize, M_MD_SII, M_WAITOK | M_ZERO);
 368         /* Write 4 copies of metadata. */
 369         for (i = 0; i < 4; i++) {
 370                 error = g_write_data(cp,
 371                     pp->mediasize - (pp->sectorsize * (1 + 0x200 * i)),
 372                     buf, pp->sectorsize);
 373                 if (error != 0) {
 374                         G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).",
 375                             pp->name, error);
 376                 }
 377         }
 378         free(buf, M_MD_SII);
 379         return (error);
 380 }
 381
 382 static int
 383 sii_meta_write_spare(struct g_consumer *cp)
 384 {
 385         struct sii_raid_conf *meta;
 386         int error;
 387
 388         meta = malloc(sizeof(*meta), M_MD_SII, M_WAITOK | M_ZERO);
 389         meta->total_sectors = cp->provider->mediasize /
 390             cp->provider->sectorsize - 0x800;
 391         meta->vendor_id = 0x1095;
 392         meta->version_minor = 0;
 393         meta->version_major = 2;
 394         meta->timestamp[0] = arc4random();
 395         meta->timestamp[1] = arc4random();
 396         meta->timestamp[2] = arc4random();
 397         meta->timestamp[3] = arc4random();
 398         meta->timestamp[4] = arc4random();
 399         meta->timestamp[5] = arc4random();
 400         meta->type = SII_T_SPARE;
 401         meta->generation = 1;
 402         meta->raid1_ident = 0xff;
 403         meta->raid_location = arc4random();
 404         error = sii_meta_write(cp, meta);
 405         free(meta, M_MD_SII);
 406         return (error);
 407 }
 408
 409 static struct g_raid_disk *
 410 g_raid_md_sii_get_disk(struct g_raid_softc *sc, int id)
 411 {
 412         struct g_raid_disk      *disk;
 413         struct g_raid_md_sii_perdisk *pd;
 414
 415         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 416                 pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
 417                 if (pd->pd_disk_pos == id)
 418                         break;
 419         }
 420         return (disk);
 421 }
 422
 423 static int
 424 g_raid_md_sii_supported(int level, int qual, int disks, int force)
 425 {
 426
 427         if (disks > 8)
 428                 return (0);
 429         switch (level) {
 430         case G_RAID_VOLUME_RL_RAID0:
 431                 if (disks < 1)
 432                         return (0);
 433                 if (!force && (disks < 2 || disks > 6))
 434                         return (0);
 435                 break;
 436         case G_RAID_VOLUME_RL_RAID1:
 437                 if (disks < 1)
 438                         return (0);
 439                 if (!force && (disks != 2))
 440                         return (0);
 441                 break;
 442         case G_RAID_VOLUME_RL_RAID1E:
 443                 if (disks < 2)
 444                         return (0);
 445                 if (disks % 2 != 0)
 446                         return (0);
 447                 if (!force && (disks < 4))
 448                         return (0);
 449                 break;
 450         case G_RAID_VOLUME_RL_SINGLE:
 451                 if (disks != 1)
 452                         return (0);
 453                 break;
 454         case G_RAID_VOLUME_RL_CONCAT:
 455                 if (disks < 2)
 456                         return (0);
 457                 break;
 458         case G_RAID_VOLUME_RL_RAID5:
 459                 if (disks < 3)
 460                         return (0);
 461                 if (qual != G_RAID_VOLUME_RLQ_R5LS)
 462                         return (0);
 463                 break;
 464         default:
 465                 return (0);
 466         }
 467         if (level != G_RAID_VOLUME_RL_RAID5 && qual != G_RAID_VOLUME_RLQ_NONE)
 468                 return (0);
 469         return (1);
 470 }
 471
 472 static int
 473 g_raid_md_sii_start_disk(struct g_raid_disk *disk)
 474 {
 475         struct g_raid_softc *sc;
 476         struct g_raid_subdisk *sd, *tmpsd;
 477         struct g_raid_disk *olddisk, *tmpdisk;
 478         struct g_raid_md_object *md;
 479         struct g_raid_md_sii_object *mdi;
 480         struct g_raid_md_sii_perdisk *pd, *oldpd;
 481         struct sii_raid_conf *meta;
 482         int disk_pos, resurrection = 0;
 483
 484         sc = disk->d_softc;
 485         md = sc->sc_md;
 486         mdi = (struct g_raid_md_sii_object *)md;
 487         meta = mdi->mdio_meta;
 488         pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
 489         olddisk = NULL;
 490
 491         /* Find disk position in metadata by it's serial. */
 492         if (pd->pd_meta != NULL)
 493                 disk_pos = sii_meta_disk_pos(meta, pd->pd_meta);
 494         else
 495                 disk_pos = -3;
 496         if (disk_pos < 0) {
 497                 G_RAID_DEBUG1(1, sc, "Unknown, probably new or stale disk");
 498                 /* If we are in the start process, that's all for now. */
 499                 if (!mdi->mdio_started)
 500                         goto nofit;
 501                 /*
 502                  * If we have already started - try to get use of the disk.
 503                  * Try to replace OFFLINE disks first, then FAILED.
 504                  */
 505                 TAILQ_FOREACH(tmpdisk, &sc->sc_disks, d_next) {
 506                         if (tmpdisk->d_state != G_RAID_DISK_S_OFFLINE &&
 507                             tmpdisk->d_state != G_RAID_DISK_S_FAILED)
 508                                 continue;
 509                         /* Make sure this disk is big enough. */
 510                         TAILQ_FOREACH(sd, &tmpdisk->d_subdisks, sd_next) {
 511                                 if (sd->sd_offset + sd->sd_size + 512 >
 512                                     pd->pd_disk_size) {
 513                                         G_RAID_DEBUG1(1, sc,
 514                                             "Disk too small (%ju < %ju)",
 515                                             pd->pd_disk_size,
 516                                             sd->sd_offset + sd->sd_size + 512);
 517                                         break;
 518                                 }
 519                         }
 520                         if (sd != NULL)
 521                                 continue;
 522                         if (tmpdisk->d_state == G_RAID_DISK_S_OFFLINE) {
 523                                 olddisk = tmpdisk;
 524                                 break;
 525                         } else if (olddisk == NULL)
 526                                 olddisk = tmpdisk;
 527                 }
 528                 if (olddisk == NULL) {
 529 nofit:
 530                         if (disk_pos == -3 || pd->pd_disk_pos == -3) {
 531                                 g_raid_change_disk_state(disk,
 532                                     G_RAID_DISK_S_SPARE);
 533                                 return (1);
 534                         } else {
 535                                 g_raid_change_disk_state(disk,
 536                                     G_RAID_DISK_S_STALE);
 537                                 return (0);
 538                         }
 539                 }
 540                 oldpd = (struct g_raid_md_sii_perdisk *)olddisk->d_md_data;
 541                 disk_pos = oldpd->pd_disk_pos;
 542                 resurrection = 1;
 543         }
 544
 545         if (olddisk == NULL) {
 546                 /* Find placeholder by position. */
 547                 olddisk = g_raid_md_sii_get_disk(sc, disk_pos);
 548                 if (olddisk == NULL)
 549                         panic("No disk at position %d!", disk_pos);
 550                 if (olddisk->d_state != G_RAID_DISK_S_OFFLINE) {
 551                         G_RAID_DEBUG1(1, sc, "More then one disk for pos %d",
 552                             disk_pos);
 553                         g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE);
 554                         return (0);
 555                 }
 556                 oldpd = (struct g_raid_md_sii_perdisk *)olddisk->d_md_data;
 557         }
 558
 559         /* Replace failed disk or placeholder with new disk. */
 560         TAILQ_FOREACH_SAFE(sd, &olddisk->d_subdisks, sd_next, tmpsd) {
 561                 TAILQ_REMOVE(&olddisk->d_subdisks, sd, sd_next);
 562                 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
 563                 sd->sd_disk = disk;
 564         }
 565         oldpd->pd_disk_pos = -2;
 566         pd->pd_disk_pos = disk_pos;
 567
 568         /* If it was placeholder -- destroy it. */
 569         if (olddisk->d_state == G_RAID_DISK_S_OFFLINE) {
 570                 g_raid_destroy_disk(olddisk);
 571         } else {
 572                 /* Otherwise, make it STALE_FAILED. */
 573                 g_raid_change_disk_state(olddisk, G_RAID_DISK_S_STALE_FAILED);
 574         }
 575
 576         /* Welcome the new disk. */
 577         if (resurrection)
 578                 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
 579         else if (pd->pd_meta->disk_status == SII_S_CURRENT ||
 580             pd->pd_meta->disk_status == SII_S_REBUILD)
 581                 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE);
 582         else
 583                 g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED);
 584         TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
 585
 586                 /*
 587                  * Different disks may have different sizes,
 588                  * in concat mode. Update from real disk size.
 589                  */
 590                 if (meta->type == SII_T_CONCAT || meta->type == SII_T_JBOD)
 591                         sd->sd_size = pd->pd_disk_size - 0x800 * 512;
 592
 593                 if (resurrection) {
 594                         /* New or ex-spare disk. */
 595                         g_raid_change_subdisk_state(sd,
 596                             G_RAID_SUBDISK_S_NEW);
 597                 } else if (pd->pd_meta->disk_status == SII_S_REBUILD) {
 598                         /* Rebuilding disk. */
 599                         g_raid_change_subdisk_state(sd,
 600                             G_RAID_SUBDISK_S_REBUILD);
 601                         if (pd->pd_meta->generation == meta->generation)
 602                                 sd->sd_rebuild_pos = pd->pd_meta->rebuild_lba * 512;
 603                         else
 604                                 sd->sd_rebuild_pos = 0;
 605                 } else if (pd->pd_meta->disk_status == SII_S_CURRENT) {
 606                         if (pd->pd_meta->raid_status == SII_S_ONLINE ||
 607                             pd->pd_meta->generation != meta->generation) {
 608                                 /* Dirty or resyncing disk. */
 609                                 g_raid_change_subdisk_state(sd,
 610                                     G_RAID_SUBDISK_S_STALE);
 611                         } else {
 612                                 /* Up to date disk. */
 613                                 g_raid_change_subdisk_state(sd,
 614                                     G_RAID_SUBDISK_S_ACTIVE);
 615                         }
 616                 } else {
 617                         g_raid_change_subdisk_state(sd,
 618                             G_RAID_SUBDISK_S_FAILED);
 619                 }
 620                 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
 621                     G_RAID_EVENT_SUBDISK);
 622         }
 623
 624         /* Update status of our need for spare. */
 625         if (mdi->mdio_started) {
 626                 mdi->mdio_incomplete =
 627                     (g_raid_ndisks(sc, G_RAID_DISK_S_ACTIVE) <
 628                      mdi->mdio_total_disks);
 629         }
 630
 631         return (resurrection);
 632 }
 633
 634 static void
 635 g_disk_md_sii_retaste(void *arg, int pending)
 636 {
 637
 638         G_RAID_DEBUG(1, "Array is not complete, trying to retaste.");
 639         g_retaste(&g_raid_class);
 640         free(arg, M_MD_SII);
 641 }
 642
 643 static void
 644 g_raid_md_sii_refill(struct g_raid_softc *sc)
 645 {
 646         struct g_raid_md_object *md;
 647         struct g_raid_md_sii_object *mdi;
 648         struct g_raid_disk *disk;
 649         struct task *task;
 650         int update, na;
 651
 652         md = sc->sc_md;
 653         mdi = (struct g_raid_md_sii_object *)md;
 654         update = 0;
 655         do {
 656                 /* Make sure we miss anything. */
 657                 na = g_raid_ndisks(sc, G_RAID_DISK_S_ACTIVE);
 658                 if (na == mdi->mdio_total_disks)
 659                         break;
 660
 661                 G_RAID_DEBUG1(1, md->mdo_softc,
 662                     "Array is not complete (%d of %d), "
 663                     "trying to refill.", na, mdi->mdio_total_disks);
 664
 665                 /* Try to get use some of STALE disks. */
 666                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 667                         if (disk->d_state == G_RAID_DISK_S_STALE) {
 668                                 update += g_raid_md_sii_start_disk(disk);
 669                                 if (disk->d_state == G_RAID_DISK_S_ACTIVE)
 670                                         break;
 671                         }
 672                 }
 673                 if (disk != NULL)
 674                         continue;
 675
 676                 /* Try to get use some of SPARE disks. */
 677                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 678                         if (disk->d_state == G_RAID_DISK_S_SPARE) {
 679                                 update += g_raid_md_sii_start_disk(disk);
 680                                 if (disk->d_state == G_RAID_DISK_S_ACTIVE)
 681                                         break;
 682                         }
 683                 }
 684         } while (disk != NULL);
 685
 686         /* Write new metadata if we changed something. */
 687         if (update)
 688                 g_raid_md_write_sii(md, NULL, NULL, NULL);
 689
 690         /* Update status of our need for spare. */
 691         mdi->mdio_incomplete = (g_raid_ndisks(sc, G_RAID_DISK_S_ACTIVE) <
 692             mdi->mdio_total_disks);
 693
 694         /* Request retaste hoping to find spare. */
 695         if (mdi->mdio_incomplete) {
 696                 task = malloc(sizeof(struct task),
 697                     M_MD_SII, M_WAITOK | M_ZERO);
 698                 TASK_INIT(task, 0, g_disk_md_sii_retaste, task);
 699                 taskqueue_enqueue(taskqueue_swi, task);
 700         }
 701 }
 702
 703 static void
 704 g_raid_md_sii_start(struct g_raid_softc *sc)
 705 {
 706         struct g_raid_md_object *md;
 707         struct g_raid_md_sii_object *mdi;
 708         struct g_raid_md_sii_perdisk *pd;
 709         struct sii_raid_conf *meta;
 710         struct g_raid_volume *vol;
 711         struct g_raid_subdisk *sd;
 712         struct g_raid_disk *disk, *best;
 713         off_t size;
 714         int j, disk_pos;
 715         uint32_t gendiff, bestgendiff;
 716         char buf[17];
 717
 718         md = sc->sc_md;
 719         mdi = (struct g_raid_md_sii_object *)md;
 720         meta = mdi->mdio_meta;
 721
 722         /* Create volumes and subdisks. */
 723         sii_meta_get_name(meta, buf);
 724         vol = g_raid_create_volume(sc, buf, -1);
 725         vol->v_mediasize = (off_t)meta->total_sectors * 512;
 726         vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_NONE;
 727         if (meta->type == SII_T_RAID0) {
 728                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID0;
 729                 size = vol->v_mediasize / mdi->mdio_total_disks;
 730         } else if (meta->type == SII_T_RAID1) {
 731                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1;
 732                 size = vol->v_mediasize;
 733         } else if (meta->type == SII_T_RAID01) {
 734                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E;
 735                 size = vol->v_mediasize / (mdi->mdio_total_disks / 2);
 736         } else if (meta->type == SII_T_CONCAT) {
 737                 if (mdi->mdio_total_disks == 1)
 738                         vol->v_raid_level = G_RAID_VOLUME_RL_SINGLE;
 739                 else
 740                         vol->v_raid_level = G_RAID_VOLUME_RL_CONCAT;
 741                 size = 0;
 742         } else if (meta->type == SII_T_RAID5) {
 743                 vol->v_raid_level = G_RAID_VOLUME_RL_RAID5;
 744                 vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_R5LS;
 745                 size = vol->v_mediasize / (mdi->mdio_total_disks - 1);
 746         } else if (meta->type == SII_T_JBOD) {
 747                 vol->v_raid_level = G_RAID_VOLUME_RL_SINGLE;
 748                 size = 0;
 749         } else {
 750                 vol->v_raid_level = G_RAID_VOLUME_RL_UNKNOWN;
 751                 size = 0;
 752         }
 753         vol->v_strip_size = meta->strip_sectors * 512; //ZZZ
 754         vol->v_disks_count = mdi->mdio_total_disks;
 755         vol->v_sectorsize = 512; //ZZZ
 756         for (j = 0; j < vol->v_disks_count; j++) {
 757                 sd = &vol->v_subdisks[j];
 758                 sd->sd_offset = 0;
 759                 sd->sd_size = size;
 760         }
 761         g_raid_start_volume(vol);
 762
 763         /* Create disk placeholders to store data for later writing. */
 764         for (disk_pos = 0; disk_pos < mdi->mdio_total_disks; disk_pos++) {
 765                 pd = malloc(sizeof(*pd), M_MD_SII, M_WAITOK | M_ZERO);
 766                 pd->pd_disk_pos = disk_pos;
 767                 disk = g_raid_create_disk(sc);
 768                 disk->d_md_data = (void *)pd;
 769                 disk->d_state = G_RAID_DISK_S_OFFLINE;
 770                 sd = &vol->v_subdisks[disk_pos];
 771                 sd->sd_disk = disk;
 772                 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
 773         }
 774
 775         /*
 776          * Make all disks found till the moment take their places
 777          * in order of their generation numbers.
 778          */
 779         do {
 780                 best = NULL;
 781                 bestgendiff = 0xffffffff;
 782                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
 783                         if (disk->d_state != G_RAID_DISK_S_NONE)
 784                                 continue;
 785                         pd = disk->d_md_data;
 786                         if (pd->pd_meta == NULL)
 787                                 gendiff = 0xfffffffe;
 788                         else
 789                                 gendiff = meta->generation -
 790                                     pd->pd_meta->generation;
 791                         if (gendiff < bestgendiff) {
 792                                 best = disk;
 793                                 bestgendiff = gendiff;
 794                         }
 795                 }
 796                 if (best != NULL)
 797                         g_raid_md_sii_start_disk(best);
 798         } while (best != NULL);
 799
 800         mdi->mdio_started = 1;
 801         G_RAID_DEBUG1(0, sc, "Array started.");
 802         g_raid_md_write_sii(md, NULL, NULL, NULL);
 803
 804         /* Pickup any STALE/SPARE disks to refill array if needed. */
 805         g_raid_md_sii_refill(sc);
 806
 807         g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME);
 808
 809         callout_stop(&mdi->mdio_start_co);
 810         G_RAID_DEBUG1(1, sc, "root_mount_rel %p", mdi->mdio_rootmount);
 811         root_mount_rel(mdi->mdio_rootmount);
 812         mdi->mdio_rootmount = NULL;
 813 }
 814
 815 static void
 816 g_raid_md_sii_new_disk(struct g_raid_disk *disk)
 817 {
 818         struct g_raid_softc *sc;
 819         struct g_raid_md_object *md;
 820         struct g_raid_md_sii_object *mdi;
 821         struct sii_raid_conf *pdmeta;
 822         struct g_raid_md_sii_perdisk *pd;
 823
 824         sc = disk->d_softc;
 825         md = sc->sc_md;
 826         mdi = (struct g_raid_md_sii_object *)md;
 827         pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
 828         pdmeta = pd->pd_meta;
 829
 830         if (mdi->mdio_started) {
 831                 if (g_raid_md_sii_start_disk(disk))
 832                         g_raid_md_write_sii(md, NULL, NULL, NULL);
 833         } else {
 834                 if (mdi->mdio_meta == NULL ||
 835                     ((int32_t)(pdmeta->generation - mdi->mdio_generation)) > 0) {
 836                         G_RAID_DEBUG1(1, sc, "Newer disk");
 837                         if (mdi->mdio_meta != NULL)
 838                                 free(mdi->mdio_meta, M_MD_SII);
 839                         mdi->mdio_meta = sii_meta_copy(pdmeta);
 840                         mdi->mdio_generation = mdi->mdio_meta->generation;
 841                         mdi->mdio_total_disks = sii_meta_total_disks(pdmeta);
 842                         mdi->mdio_disks_present = 1;
 843                 } else if (pdmeta->generation == mdi->mdio_generation) {
 844                         mdi->mdio_disks_present++;
 845                         G_RAID_DEBUG1(1, sc, "Matching disk (%d of %d up)",
 846                             mdi->mdio_disks_present,
 847                             mdi->mdio_total_disks);
 848                 } else {
 849                         G_RAID_DEBUG1(1, sc, "Older disk");
 850                 }
 851
 852                 /* If we collected all needed disks - start array. */
 853                 if (mdi->mdio_disks_present == mdi->mdio_total_disks)
 854                         g_raid_md_sii_start(sc);
 855         }
 856 }
 857
 858 static void
 859 g_raid_sii_go(void *arg)
 860 {
 861         struct g_raid_softc *sc;
 862         struct g_raid_md_object *md;
 863         struct g_raid_md_sii_object *mdi;
 864
 865         sc = arg;
 866         md = sc->sc_md;
 867         mdi = (struct g_raid_md_sii_object *)md;
 868         if (!mdi->mdio_started) {
 869                 G_RAID_DEBUG1(0, sc, "Force array start due to timeout.");
 870                 g_raid_event_send(sc, G_RAID_NODE_E_START, 0);
 871         }
 872 }
 873
 874 static int
 875 g_raid_md_create_sii(struct g_raid_md_object *md, struct g_class *mp,
 876     struct g_geom **gp)
 877 {
 878         struct g_raid_softc *sc;
 879         struct g_raid_md_sii_object *mdi;
 880         char name[32];
 881
 882         mdi = (struct g_raid_md_sii_object *)md;
 883         mdi->mdio_timestamp[5] = arc4random();
 884         mdi->mdio_timestamp[4] = arc4random();
 885         mdi->mdio_timestamp[3] = arc4random();
 886         mdi->mdio_timestamp[2] = arc4random();
 887         mdi->mdio_timestamp[1] = arc4random();
 888         mdi->mdio_timestamp[0] = arc4random();
 889         mdi->mdio_location = arc4random();
 890         mdi->mdio_generation = 0;
 891         snprintf(name, sizeof(name), "SiI-%02x%02x%02x%02x%02x%02x",
 892             mdi->mdio_timestamp[5], mdi->mdio_timestamp[4],
 893             mdi->mdio_timestamp[3], mdi->mdio_timestamp[2],
 894             mdi->mdio_timestamp[1], mdi->mdio_timestamp[0]);
 895         sc = g_raid_create_node(mp, name, md);
 896         if (sc == NULL)
 897                 return (G_RAID_MD_TASTE_FAIL);
 898         md->mdo_softc = sc;
 899         *gp = sc->sc_geom;
 900         return (G_RAID_MD_TASTE_NEW);
 901 }
 902
 903 static int
 904 g_raid_md_taste_sii(struct g_raid_md_object *md, struct g_class *mp,
 905                               struct g_consumer *cp, struct g_geom **gp)
 906 {
 907         struct g_consumer *rcp;
 908         struct g_provider *pp;
 909         struct g_raid_md_sii_object *mdi, *mdi1;
 910         struct g_raid_softc *sc;
 911         struct g_raid_disk *disk;
 912         struct sii_raid_conf *meta;
 913         struct g_raid_md_sii_perdisk *pd;
 914         struct g_geom *geom;
 915         int disk_pos, result, spare, len;
 916         char name[32];
 917         uint16_t vendor;
 918
 919         G_RAID_DEBUG(1, "Tasting SiI on %s", cp->provider->name);
 920         mdi = (struct g_raid_md_sii_object *)md;
 921         pp = cp->provider;
 922
 923         /* Read metadata from device. */
 924         meta = NULL;
 925         vendor = 0xffff;
 926         if (g_access(cp, 1, 0, 0) != 0)
 927                 return (G_RAID_MD_TASTE_FAIL);
 928         g_topology_unlock();
 929         len = 2;
 930         if (pp->geom->rank == 1)
 931                 g_io_getattr("GEOM::hba_vendor", cp, &len, &vendor);
 932         meta = sii_meta_read(cp);
 933         g_topology_lock();
 934         g_access(cp, -1, 0, 0);
 935         if (meta == NULL) {
 936                 if (g_raid_aggressive_spare) {
 937                         if (vendor == 0x1095) {
 938                                 G_RAID_DEBUG(1,
 939                                     "No SiI metadata, forcing spare.");
 940                                 spare = 2;
 941                                 goto search;
 942                         } else {
 943                                 G_RAID_DEBUG(1,
 944                                     "SiI vendor mismatch 0x%04x != 0x1095",
 945                                     vendor);
 946                         }
 947                 }
 948                 return (G_RAID_MD_TASTE_FAIL);
 949         }
 950
 951         /* Check this disk position in obtained metadata. */
 952         disk_pos = sii_meta_disk_pos(meta, meta);
 953         if (disk_pos == -1) {
 954                 G_RAID_DEBUG(1, "SiI disk position not found");
 955                 goto fail1;
 956         }
 957
 958         /* Metadata valid. Print it. */
 959         g_raid_md_sii_print(meta);
 960         G_RAID_DEBUG(1, "SiI disk position %d", disk_pos);
 961         spare = (meta->type == SII_T_SPARE) ? 1 : 0;
 962
 963 search:
 964         /* Search for matching node. */
 965         sc = NULL;
 966         mdi1 = NULL;
 967         LIST_FOREACH(geom, &mp->geom, geom) {
 968                 sc = geom->softc;
 969                 if (sc == NULL)
 970                         continue;
 971                 if (sc->sc_stopping != 0)
 972                         continue;
 973                 if (sc->sc_md->mdo_class != md->mdo_class)
 974                         continue;
 975                 mdi1 = (struct g_raid_md_sii_object *)sc->sc_md;
 976                 if (spare) {
 977                         if (mdi1->mdio_incomplete)
 978                                 break;
 979                 } else {
 980                         if (mdi1->mdio_location == meta->raid_location &&
 981                             memcmp(&mdi1->mdio_timestamp,
 982                              &meta->timestamp, 6) == 0)
 983                                 break;
 984                 }
 985         }
 986
 987         /* Found matching node. */
 988         if (geom != NULL) {
 989                 G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name);
 990                 result = G_RAID_MD_TASTE_EXISTING;
 991
 992         } else if (spare) { /* Not found needy node -- left for later. */
 993                 G_RAID_DEBUG(1, "Spare is not needed at this time");
 994                 goto fail1;
 995
 996         } else { /* Not found matching node -- create one. */
 997                 result = G_RAID_MD_TASTE_NEW;
 998                 memcpy(&mdi->mdio_timestamp, &meta->timestamp, 6);
 999                 mdi->mdio_location = meta->raid_location;
1000                 snprintf(name, sizeof(name), "SiI-%02x%02x%02x%02x%02x%02x",
1001                     mdi->mdio_timestamp[5], mdi->mdio_timestamp[4],
1002                     mdi->mdio_timestamp[3], mdi->mdio_timestamp[2],
1003                     mdi->mdio_timestamp[1], mdi->mdio_timestamp[0]);
1004                 sc = g_raid_create_node(mp, name, md);
1005                 md->mdo_softc = sc;
1006                 geom = sc->sc_geom;
1007                 callout_init(&mdi->mdio_start_co, 1);
1008                 callout_reset(&mdi->mdio_start_co, g_raid_start_timeout * hz,
1009                     g_raid_sii_go, sc);
1010                 mdi->mdio_rootmount = root_mount_hold("GRAID-SiI");
1011                 G_RAID_DEBUG1(1, sc, "root_mount_hold %p", mdi->mdio_rootmount);
1012         }
1013
1014         rcp = g_new_consumer(geom);
1015         g_attach(rcp, pp);
1016         if (g_access(rcp, 1, 1, 1) != 0)
1017                 ; //goto fail1;
1018
1019         g_topology_unlock();
1020         sx_xlock(&sc->sc_lock);
1021
1022         pd = malloc(sizeof(*pd), M_MD_SII, M_WAITOK | M_ZERO);
1023         pd->pd_meta = meta;
1024         if (spare == 2) {
1025                 pd->pd_disk_pos = -3;
1026         } else {
1027                 pd->pd_disk_pos = -1;
1028         }
1029         pd->pd_disk_size = pp->mediasize;
1030         disk = g_raid_create_disk(sc);
1031         disk->d_md_data = (void *)pd;
1032         disk->d_consumer = rcp;
1033         rcp->private = disk;
1034
1035         g_raid_get_disk_info(disk);
1036
1037         g_raid_md_sii_new_disk(disk);
1038
1039         sx_xunlock(&sc->sc_lock);
1040         g_topology_lock();
1041         *gp = geom;
1042         return (result);
1043 fail1:
1044         free(meta, M_MD_SII);
1045         return (G_RAID_MD_TASTE_FAIL);
1046 }
1047
1048 static int
1049 g_raid_md_event_sii(struct g_raid_md_object *md,
1050     struct g_raid_disk *disk, u_int event)
1051 {
1052         struct g_raid_softc *sc;
1053         struct g_raid_subdisk *sd;
1054         struct g_raid_md_sii_object *mdi;
1055         struct g_raid_md_sii_perdisk *pd;
1056
1057         sc = md->mdo_softc;
1058         mdi = (struct g_raid_md_sii_object *)md;
1059         if (disk == NULL) {
1060                 switch (event) {
1061                 case G_RAID_NODE_E_START:
1062                         if (!mdi->mdio_started)
1063                                 g_raid_md_sii_start(sc);
1064                         return (0);
1065                 }
1066                 return (-1);
1067         }
1068         pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
1069         switch (event) {
1070         case G_RAID_DISK_E_DISCONNECTED:
1071                 /* If disk was assigned, just update statuses. */
1072                 if (pd->pd_disk_pos >= 0) {
1073                         g_raid_change_disk_state(disk, G_RAID_DISK_S_OFFLINE);
1074                         if (disk->d_consumer) {
1075                                 g_raid_kill_consumer(sc, disk->d_consumer);
1076                                 disk->d_consumer = NULL;
1077                         }
1078                         TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
1079                                 g_raid_change_subdisk_state(sd,
1080                                     G_RAID_SUBDISK_S_NONE);
1081                                 g_raid_event_send(sd, G_RAID_SUBDISK_E_DISCONNECTED,
1082                                     G_RAID_EVENT_SUBDISK);
1083                         }
1084                 } else {
1085                         /* Otherwise -- delete. */
1086                         g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
1087                         g_raid_destroy_disk(disk);
1088                 }
1089
1090                 /* Write updated metadata to all disks. */
1091                 g_raid_md_write_sii(md, NULL, NULL, NULL);
1092
1093                 /* Check if anything left except placeholders. */
1094                 if (g_raid_ndisks(sc, -1) ==
1095                     g_raid_ndisks(sc, G_RAID_DISK_S_OFFLINE))
1096                         g_raid_destroy_node(sc, 0);
1097                 else
1098                         g_raid_md_sii_refill(sc);
1099                 return (0);
1100         }
1101         return (-2);
1102 }
1103
1104 static int
1105 g_raid_md_ctl_sii(struct g_raid_md_object *md,
1106     struct gctl_req *req)
1107 {
1108         struct g_raid_softc *sc;
1109         struct g_raid_volume *vol;
1110         struct g_raid_subdisk *sd;
1111         struct g_raid_disk *disk;
1112         struct g_raid_md_sii_object *mdi;
1113         struct g_raid_md_sii_perdisk *pd;
1114         struct g_consumer *cp;
1115         struct g_provider *pp;
1116         char arg[16];
1117         const char *verb, *volname, *levelname, *diskname;
1118         int *nargs, *force;
1119         off_t size, sectorsize, strip;
1120         intmax_t *sizearg, *striparg;
1121         int numdisks, i, len, level, qual, update;
1122         int error;
1123
1124         sc = md->mdo_softc;
1125         mdi = (struct g_raid_md_sii_object *)md;
1126         verb = gctl_get_param(req, "verb", NULL);
1127         nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs));
1128         error = 0;
1129         if (strcmp(verb, "label") == 0) {
1130
1131                 if (*nargs < 4) {
1132                         gctl_error(req, "Invalid number of arguments.");
1133                         return (-1);
1134                 }
1135                 volname = gctl_get_asciiparam(req, "arg1");
1136                 if (volname == NULL) {
1137                         gctl_error(req, "No volume name.");
1138                         return (-2);
1139                 }
1140                 levelname = gctl_get_asciiparam(req, "arg2");
1141                 if (levelname == NULL) {
1142                         gctl_error(req, "No RAID level.");
1143                         return (-3);
1144                 }
1145                 if (strcasecmp(levelname, "RAID5") == 0)
1146                         levelname = "RAID5-LS";
1147                 if (g_raid_volume_str2level(levelname, &level, &qual)) {
1148                         gctl_error(req, "Unknown RAID level '%s'.", levelname);
1149                         return (-4);
1150                 }
1151                 numdisks = *nargs - 3;
1152                 force = gctl_get_paraml(req, "force", sizeof(*force));
1153                 if (!g_raid_md_sii_supported(level, qual, numdisks,
1154                     force ? *force : 0)) {
1155                         gctl_error(req, "Unsupported RAID level "
1156                             "(0x%02x/0x%02x), or number of disks (%d).",
1157                             level, qual, numdisks);
1158                         return (-5);
1159                 }
1160
1161                 /* Search for disks, connect them and probe. */
1162                 size = 0x7fffffffffffffffllu;
1163                 sectorsize = 0;
1164                 for (i = 0; i < numdisks; i++) {
1165                         snprintf(arg, sizeof(arg), "arg%d", i + 3);
1166                         diskname = gctl_get_asciiparam(req, arg);
1167                         if (diskname == NULL) {
1168                                 gctl_error(req, "No disk name (%s).", arg);
1169                                 error = -6;
1170                                 break;
1171                         }
1172                         if (strcmp(diskname, "NONE") == 0) {
1173                                 cp = NULL;
1174                                 pp = NULL;
1175                         } else {
1176                                 g_topology_lock();
1177                                 cp = g_raid_open_consumer(sc, diskname);
1178                                 if (cp == NULL) {
1179                                         gctl_error(req, "Can't open '%s'.",
1180                                             diskname);
1181                                         g_topology_unlock();
1182                                         error = -7;
1183                                         break;
1184                                 }
1185                                 pp = cp->provider;
1186                         }
1187                         pd = malloc(sizeof(*pd), M_MD_SII, M_WAITOK | M_ZERO);
1188                         pd->pd_disk_pos = i;
1189                         disk = g_raid_create_disk(sc);
1190                         disk->d_md_data = (void *)pd;
1191                         disk->d_consumer = cp;
1192                         if (cp == NULL)
1193                                 continue;
1194                         cp->private = disk;
1195                         g_topology_unlock();
1196
1197                         g_raid_get_disk_info(disk);
1198
1199                         pd->pd_disk_size = pp->mediasize;
1200                         if (size > pp->mediasize)
1201                                 size = pp->mediasize;
1202                         if (sectorsize < pp->sectorsize)
1203                                 sectorsize = pp->sectorsize;
1204                 }
1205                 if (error != 0)
1206                         return (error);
1207
1208                 if (sectorsize <= 0) {
1209                         gctl_error(req, "Can't get sector size.");
1210                         return (-8);
1211                 }
1212
1213                 /* Reserve space for metadata. */
1214                 size -= 0x800 * sectorsize;
1215
1216                 /* Handle size argument. */
1217                 len = sizeof(*sizearg);
1218                 sizearg = gctl_get_param(req, "size", &len);
1219                 if (sizearg != NULL && len == sizeof(*sizearg) &&
1220                     *sizearg > 0) {
1221                         if (*sizearg > size) {
1222                                 gctl_error(req, "Size too big %lld > %lld.",
1223                                     (long long)*sizearg, (long long)size);
1224                                 return (-9);
1225                         }
1226                         size = *sizearg;
1227                 }
1228
1229                 /* Handle strip argument. */
1230                 strip = 131072;
1231                 len = sizeof(*striparg);
1232                 striparg = gctl_get_param(req, "strip", &len);
1233                 if (striparg != NULL && len == sizeof(*striparg) &&
1234                     *striparg > 0) {
1235                         if (*striparg < sectorsize) {
1236                                 gctl_error(req, "Strip size too small.");
1237                                 return (-10);
1238                         }
1239                         if (*striparg % sectorsize != 0) {
1240                                 gctl_error(req, "Incorrect strip size.");
1241                                 return (-11);
1242                         }
1243                         if (strip > 65535 * sectorsize) {
1244                                 gctl_error(req, "Strip size too big.");
1245                                 return (-12);
1246                         }
1247                         strip = *striparg;
1248                 }
1249
1250                 /* Round size down to strip or sector. */
1251                 if (level == G_RAID_VOLUME_RL_RAID1)
1252                         size -= (size % sectorsize);
1253                 else if (level == G_RAID_VOLUME_RL_RAID1E &&
1254                     (numdisks & 1) != 0)
1255                         size -= (size % (2 * strip));
1256                 else
1257                         size -= (size % strip);
1258                 if (size <= 0) {
1259                         gctl_error(req, "Size too small.");
1260                         return (-13);
1261                 }
1262                 if (size > 0xffffffffffffllu * sectorsize) {
1263                         gctl_error(req, "Size too big.");
1264                         return (-14);
1265                 }
1266
1267                 /* We have all we need, create things: volume, ... */
1268                 mdi->mdio_total_disks = numdisks;
1269                 mdi->mdio_started = 1;
1270                 vol = g_raid_create_volume(sc, volname, -1);
1271                 vol->v_md_data = (void *)(intptr_t)0;
1272                 vol->v_raid_level = level;
1273                 vol->v_raid_level_qualifier = qual;
1274                 vol->v_strip_size = strip;
1275                 vol->v_disks_count = numdisks;
1276                 if (level == G_RAID_VOLUME_RL_RAID0 ||
1277                     level == G_RAID_VOLUME_RL_CONCAT ||
1278                     level == G_RAID_VOLUME_RL_SINGLE)
1279                         vol->v_mediasize = size * numdisks;
1280                 else if (level == G_RAID_VOLUME_RL_RAID1)
1281                         vol->v_mediasize = size;
1282                 else if (level == G_RAID_VOLUME_RL_RAID5)
1283                         vol->v_mediasize = size * (numdisks - 1);
1284                 else { /* RAID1E */
1285                         vol->v_mediasize = ((size * numdisks) / strip / 2) *
1286                             strip;
1287                 }
1288                 vol->v_sectorsize = sectorsize;
1289                 g_raid_start_volume(vol);
1290
1291                 /* , and subdisks. */
1292                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1293                         pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
1294                         sd = &vol->v_subdisks[pd->pd_disk_pos];
1295                         sd->sd_disk = disk;
1296                         sd->sd_offset = 0;
1297                         sd->sd_size = size;
1298                         TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next);
1299                         if (sd->sd_disk->d_consumer != NULL) {
1300                                 g_raid_change_disk_state(disk,
1301                                     G_RAID_DISK_S_ACTIVE);
1302                                 g_raid_change_subdisk_state(sd,
1303                                     G_RAID_SUBDISK_S_ACTIVE);
1304                                 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW,
1305                                     G_RAID_EVENT_SUBDISK);
1306                         } else {
1307                                 g_raid_change_disk_state(disk, G_RAID_DISK_S_OFFLINE);
1308                         }
1309                 }
1310
1311                 /* Write metadata based on created entities. */
1312                 G_RAID_DEBUG1(0, sc, "Array started.");
1313                 g_raid_md_write_sii(md, NULL, NULL, NULL);
1314
1315                 /* Pickup any STALE/SPARE disks to refill array if needed. */
1316                 g_raid_md_sii_refill(sc);
1317
1318                 g_raid_event_send(vol, G_RAID_VOLUME_E_START,
1319                     G_RAID_EVENT_VOLUME);
1320                 return (0);
1321         }
1322         if (strcmp(verb, "delete") == 0) {
1323
1324                 /* Check if some volume is still open. */
1325                 force = gctl_get_paraml(req, "force", sizeof(*force));
1326                 if (force != NULL && *force == 0 &&
1327                     g_raid_nopens(sc) != 0) {
1328                         gctl_error(req, "Some volume is still open.");
1329                         return (-4);
1330                 }
1331
1332                 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1333                         if (disk->d_consumer)
1334                                 sii_meta_erase(disk->d_consumer);
1335                 }
1336                 g_raid_destroy_node(sc, 0);
1337                 return (0);
1338         }
1339         if (strcmp(verb, "remove") == 0 ||
1340             strcmp(verb, "fail") == 0) {
1341                 if (*nargs < 2) {
1342                         gctl_error(req, "Invalid number of arguments.");
1343                         return (-1);
1344                 }
1345                 for (i = 1; i < *nargs; i++) {
1346                         snprintf(arg, sizeof(arg), "arg%d", i);
1347                         diskname = gctl_get_asciiparam(req, arg);
1348                         if (diskname == NULL) {
1349                                 gctl_error(req, "No disk name (%s).", arg);
1350                                 error = -2;
1351                                 break;
1352                         }
1353                         if (strncmp(diskname, "/dev/", 5) == 0)
1354                                 diskname += 5;
1355
1356                         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1357                                 if (disk->d_consumer != NULL &&
1358                                     disk->d_consumer->provider != NULL &&
1359                                     strcmp(disk->d_consumer->provider->name,
1360                                      diskname) == 0)
1361                                         break;
1362                         }
1363                         if (disk == NULL) {
1364                                 gctl_error(req, "Disk '%s' not found.",
1365                                     diskname);
1366                                 error = -3;
1367                                 break;
1368                         }
1369
1370                         if (strcmp(verb, "fail") == 0) {
1371                                 g_raid_md_fail_disk_sii(md, NULL, disk);
1372                                 continue;
1373                         }
1374
1375                         pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
1376
1377                         /* Erase metadata on deleting disk. */
1378                         sii_meta_erase(disk->d_consumer);
1379
1380                         /* If disk was assigned, just update statuses. */
1381                         if (pd->pd_disk_pos >= 0) {
1382                                 g_raid_change_disk_state(disk, G_RAID_DISK_S_OFFLINE);
1383                                 g_raid_kill_consumer(sc, disk->d_consumer);
1384                                 disk->d_consumer = NULL;
1385                                 TAILQ_FOREACH(sd, &disk->d_subdisks, sd_next) {
1386                                         g_raid_change_subdisk_state(sd,
1387                                             G_RAID_SUBDISK_S_NONE);
1388                                         g_raid_event_send(sd, G_RAID_SUBDISK_E_DISCONNECTED,
1389                                             G_RAID_EVENT_SUBDISK);
1390                                 }
1391                         } else {
1392                                 /* Otherwise -- delete. */
1393                                 g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE);
1394                                 g_raid_destroy_disk(disk);
1395                         }
1396                 }
1397
1398                 /* Write updated metadata to remaining disks. */
1399                 g_raid_md_write_sii(md, NULL, NULL, NULL);
1400
1401                 /* Check if anything left except placeholders. */
1402                 if (g_raid_ndisks(sc, -1) ==
1403                     g_raid_ndisks(sc, G_RAID_DISK_S_OFFLINE))
1404                         g_raid_destroy_node(sc, 0);
1405                 else
1406                         g_raid_md_sii_refill(sc);
1407                 return (error);
1408         }
1409         if (strcmp(verb, "insert") == 0) {
1410                 if (*nargs < 2) {
1411                         gctl_error(req, "Invalid number of arguments.");
1412                         return (-1);
1413                 }
1414                 update = 0;
1415                 for (i = 1; i < *nargs; i++) {
1416                         /* Get disk name. */
1417                         snprintf(arg, sizeof(arg), "arg%d", i);
1418                         diskname = gctl_get_asciiparam(req, arg);
1419                         if (diskname == NULL) {
1420                                 gctl_error(req, "No disk name (%s).", arg);
1421                                 error = -3;
1422                                 break;
1423                         }
1424
1425                         /* Try to find provider with specified name. */
1426                         g_topology_lock();
1427                         cp = g_raid_open_consumer(sc, diskname);
1428                         if (cp == NULL) {
1429                                 gctl_error(req, "Can't open disk '%s'.",
1430                                     diskname);
1431                                 g_topology_unlock();
1432                                 error = -4;
1433                                 break;
1434                         }
1435                         pp = cp->provider;
1436
1437                         pd = malloc(sizeof(*pd), M_MD_SII, M_WAITOK | M_ZERO);
1438                         pd->pd_disk_pos = -3;
1439                         pd->pd_disk_size = pp->mediasize;
1440
1441                         disk = g_raid_create_disk(sc);
1442                         disk->d_consumer = cp;
1443                         disk->d_md_data = (void *)pd;
1444                         cp->private = disk;
1445                         g_topology_unlock();
1446
1447                         g_raid_get_disk_info(disk);
1448
1449                         /* Welcome the "new" disk. */
1450                         update += g_raid_md_sii_start_disk(disk);
1451                         if (disk->d_state == G_RAID_DISK_S_SPARE) {
1452                                 sii_meta_write_spare(cp);
1453                                 g_raid_destroy_disk(disk);
1454                         } else if (disk->d_state != G_RAID_DISK_S_ACTIVE) {
1455                                 gctl_error(req, "Disk '%s' doesn't fit.",
1456                                     diskname);
1457                                 g_raid_destroy_disk(disk);
1458                                 error = -8;
1459                                 break;
1460                         }
1461                 }
1462
1463                 /* Write new metadata if we changed something. */
1464                 if (update)
1465                         g_raid_md_write_sii(md, NULL, NULL, NULL);
1466                 return (error);
1467         }
1468         gctl_error(req, "Command '%s' is not supported.", verb);
1469         return (-100);
1470 }
1471
1472 static int
1473 g_raid_md_write_sii(struct g_raid_md_object *md, struct g_raid_volume *tvol,
1474     struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
1475 {
1476         struct g_raid_softc *sc;
1477         struct g_raid_volume *vol;
1478         struct g_raid_subdisk *sd;
1479         struct g_raid_disk *disk;
1480         struct g_raid_md_sii_object *mdi;
1481         struct g_raid_md_sii_perdisk *pd;
1482         struct sii_raid_conf *meta;
1483         int i;
1484
1485         sc = md->mdo_softc;
1486         mdi = (struct g_raid_md_sii_object *)md;
1487
1488         if (sc->sc_stopping == G_RAID_DESTROY_HARD)
1489                 return (0);
1490
1491         /* Bump generation. Newly written metadata may differ from previous. */
1492         mdi->mdio_generation++;
1493
1494         /* There is only one volume. */
1495         vol = TAILQ_FIRST(&sc->sc_volumes);
1496
1497         /* Fill global fields. */
1498         meta = malloc(sizeof(*meta), M_MD_SII, M_WAITOK | M_ZERO);
1499         if (mdi->mdio_meta)
1500                 memcpy(meta, mdi->mdio_meta, sizeof(*meta));
1501         meta->total_sectors = vol->v_mediasize / vol->v_sectorsize;
1502         meta->vendor_id = 0x1095;
1503         meta->version_minor = 0;
1504         meta->version_major = 2;
1505         memcpy(&meta->timestamp, &mdi->mdio_timestamp, 6);
1506         meta->strip_sectors = vol->v_strip_size / vol->v_sectorsize;
1507         if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID0) {
1508                 meta->type = SII_T_RAID0;
1509                 meta->raid0_disks = vol->v_disks_count;
1510                 meta->raid1_disks = 0xff;
1511         } else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1) {
1512                 meta->type = SII_T_RAID1;
1513                 meta->raid0_disks = 0xff;
1514                 meta->raid1_disks = vol->v_disks_count;
1515         } else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) {
1516                 meta->type = SII_T_RAID01;
1517                 meta->raid0_disks = vol->v_disks_count / 2;
1518                 meta->raid1_disks = 2;
1519         } else if (vol->v_raid_level == G_RAID_VOLUME_RL_CONCAT ||
1520             vol->v_raid_level == G_RAID_VOLUME_RL_SINGLE) {
1521                 meta->type = SII_T_JBOD;
1522                 meta->raid0_disks = vol->v_disks_count;
1523                 meta->raid1_disks = 0xff;
1524         } else {
1525                 meta->type = SII_T_RAID5;
1526                 meta->raid0_disks = vol->v_disks_count;
1527                 meta->raid1_disks = 0xff;
1528         }
1529         meta->generation = mdi->mdio_generation;
1530         meta->raid_status = vol->v_dirty ? SII_S_ONLINE : SII_S_AVAILABLE;
1531         for (i = 0; i < vol->v_disks_count; i++) {
1532                 sd = &vol->v_subdisks[i];
1533                 if (sd->sd_state == G_RAID_SUBDISK_S_STALE ||
1534                     sd->sd_state == G_RAID_SUBDISK_S_RESYNC)
1535                         meta->raid_status = SII_S_ONLINE;
1536         }
1537         meta->raid_location = mdi->mdio_location;
1538         sii_meta_put_name(meta, vol->v_name);
1539
1540         /* We are done. Print meta data and store them to disks. */
1541         if (mdi->mdio_meta != NULL)
1542                 free(mdi->mdio_meta, M_MD_SII);
1543         mdi->mdio_meta = meta;
1544         TAILQ_FOREACH(disk, &sc->sc_disks, d_next) {
1545                 pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
1546                 if (disk->d_state != G_RAID_DISK_S_ACTIVE)
1547                         continue;
1548                 if (pd->pd_meta != NULL) {
1549                         free(pd->pd_meta, M_MD_SII);
1550                         pd->pd_meta = NULL;
1551                 }
1552                 pd->pd_meta = sii_meta_copy(meta);
1553                 if ((sd = TAILQ_FIRST(&disk->d_subdisks)) != NULL) {
1554                         if (sd->sd_state < G_RAID_SUBDISK_S_NEW)
1555                                 pd->pd_meta->disk_status = SII_S_DROPPED;
1556                         else if (sd->sd_state < G_RAID_SUBDISK_S_STALE) {
1557                                 pd->pd_meta->disk_status = SII_S_REBUILD;
1558                                 pd->pd_meta->rebuild_lba =
1559                                     sd->sd_rebuild_pos / vol->v_sectorsize;
1560                         } else
1561                                 pd->pd_meta->disk_status = SII_S_CURRENT;
1562                         if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1) {
1563                                 pd->pd_meta->disk_number = sd->sd_pos;
1564                                 pd->pd_meta->raid0_ident = 0xff;
1565                                 pd->pd_meta->raid1_ident = 0;
1566                         } else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) {
1567                                 pd->pd_meta->disk_number = sd->sd_pos / meta->raid1_disks;
1568                                 pd->pd_meta->raid0_ident = sd->sd_pos % meta->raid1_disks;
1569                                 pd->pd_meta->raid1_ident = sd->sd_pos / meta->raid1_disks;
1570                         } else {
1571                                 pd->pd_meta->disk_number = sd->sd_pos;
1572                                 pd->pd_meta->raid0_ident = 0;
1573                                 pd->pd_meta->raid1_ident = 0xff;
1574                         }
1575                 }
1576                 G_RAID_DEBUG(1, "Writing SiI metadata to %s",
1577                     g_raid_get_diskname(disk));
1578                 g_raid_md_sii_print(pd->pd_meta);
1579                 sii_meta_write(disk->d_consumer, pd->pd_meta);
1580         }
1581         return (0);
1582 }
1583
1584 static int
1585 g_raid_md_fail_disk_sii(struct g_raid_md_object *md,
1586     struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk)
1587 {
1588         struct g_raid_softc *sc;
1589         struct g_raid_md_sii_perdisk *pd;
1590         struct g_raid_subdisk *sd;
1591
1592         sc = md->mdo_softc;
1593         pd = (struct g_raid_md_sii_perdisk *)tdisk->d_md_data;
1594
1595         /* We can't fail disk that is not a part of array now. */
1596         if (pd->pd_disk_pos < 0)
1597                 return (-1);
1598
1599         /*
1600          * Mark disk as failed in metadata and try to write that metadata
1601          * to the disk itself to prevent it's later resurrection as STALE.
1602          */
1603         if (tdisk->d_consumer) {
1604                 if (pd->pd_meta) {
1605                         pd->pd_meta->disk_status = SII_S_REMOVED;
1606                         sii_meta_write(tdisk->d_consumer, pd->pd_meta);
1607                 } else
1608                         sii_meta_erase(tdisk->d_consumer);
1609         }
1610
1611         /* Change states. */
1612         g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED);
1613         TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) {
1614                 g_raid_change_subdisk_state(sd,
1615                     G_RAID_SUBDISK_S_FAILED);
1616                 g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED,
1617                     G_RAID_EVENT_SUBDISK);
1618         }
1619
1620         /* Write updated metadata to remaining disks. */
1621         g_raid_md_write_sii(md, NULL, NULL, tdisk);
1622
1623         /* Check if anything left except placeholders. */
1624         if (g_raid_ndisks(sc, -1) ==
1625             g_raid_ndisks(sc, G_RAID_DISK_S_OFFLINE))
1626                 g_raid_destroy_node(sc, 0);
1627         else
1628                 g_raid_md_sii_refill(sc);
1629         return (0);
1630 }
1631
1632 static int
1633 g_raid_md_free_disk_sii(struct g_raid_md_object *md,
1634     struct g_raid_disk *disk)
1635 {
1636         struct g_raid_md_sii_perdisk *pd;
1637
1638         pd = (struct g_raid_md_sii_perdisk *)disk->d_md_data;
1639         if (pd->pd_meta != NULL) {
1640                 free(pd->pd_meta, M_MD_SII);
1641                 pd->pd_meta = NULL;
1642         }
1643         free(pd, M_MD_SII);
1644         disk->d_md_data = NULL;
1645         return (0);
1646 }
1647
1648 static int
1649 g_raid_md_free_sii(struct g_raid_md_object *md)
1650 {
1651         struct g_raid_md_sii_object *mdi;
1652
1653         mdi = (struct g_raid_md_sii_object *)md;
1654         if (!mdi->mdio_started) {
1655                 mdi->mdio_started = 0;
1656                 callout_stop(&mdi->mdio_start_co);
1657                 G_RAID_DEBUG1(1, md->mdo_softc,
1658                     "root_mount_rel %p", mdi->mdio_rootmount);
1659                 root_mount_rel(mdi->mdio_rootmount);
1660                 mdi->mdio_rootmount = NULL;
1661         }
1662         if (mdi->mdio_meta != NULL) {
1663                 free(mdi->mdio_meta, M_MD_SII);
1664                 mdi->mdio_meta = NULL;
1665         }
1666         return (0);
1667 }
1668
1669 G_RAID_MD_DECLARE(sii, "SiI");