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