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