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


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

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

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

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

Cache object: 13b99a2710b3466be71efe2f00278a2a


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


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