md_promise.c revision 234727
1/*- 2 * Copyright (c) 2011 Alexander Motin <mav@FreeBSD.org> 3 * Copyright (c) 2000 - 2008 S��ren Schmidt <sos@FreeBSD.org> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD: head/sys/geom/raid/md_promise.c 234727 2012-04-27 08:49:15Z 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 <geom/geom.h> 42#include "geom/raid/g_raid.h" 43#include "g_raid_md_if.h" 44 45static MALLOC_DEFINE(M_MD_PROMISE, "md_promise_data", "GEOM_RAID Promise metadata"); 46 47#define PROMISE_MAX_DISKS 8 48#define PROMISE_MAX_SUBDISKS 2 49#define PROMISE_META_OFFSET 14 50 51struct promise_raid_disk { 52 uint8_t flags; /* Subdisk status. */ 53#define PROMISE_F_VALID 0x01 54#define PROMISE_F_ONLINE 0x02 55#define PROMISE_F_ASSIGNED 0x04 56#define PROMISE_F_SPARE 0x08 57#define PROMISE_F_DUPLICATE 0x10 58#define PROMISE_F_REDIR 0x20 59#define PROMISE_F_DOWN 0x40 60#define PROMISE_F_READY 0x80 61 62 uint8_t number; /* Position in a volume. */ 63 uint8_t channel; /* ATA channel number. */ 64 uint8_t device; /* ATA device number. */ 65 uint64_t id __packed; /* Subdisk ID. */ 66} __packed; 67 68struct promise_raid_conf { 69 char promise_id[24]; 70#define PROMISE_MAGIC "Promise Technology, Inc." 71#define FREEBSD_MAGIC "FreeBSD ATA driver RAID " 72 73 uint32_t dummy_0; 74 uint64_t magic_0; 75#define PROMISE_MAGIC0(x) (((uint64_t)(x.channel) << 48) | \ 76 ((uint64_t)(x.device != 0) << 56)) 77 uint16_t magic_1; 78 uint32_t magic_2; 79 uint8_t filler1[470]; 80 81 uint32_t integrity; 82#define PROMISE_I_VALID 0x00000080 83 84 struct promise_raid_disk disk; /* This subdisk info. */ 85 uint32_t disk_offset; /* Subdisk offset. */ 86 uint32_t disk_sectors; /* Subdisk size */ 87 uint32_t rebuild_lba; /* Rebuild position. */ 88 uint16_t generation; /* Generation number. */ 89 uint8_t status; /* Volume status. */ 90#define PROMISE_S_VALID 0x01 91#define PROMISE_S_ONLINE 0x02 92#define PROMISE_S_INITED 0x04 93#define PROMISE_S_READY 0x08 94#define PROMISE_S_DEGRADED 0x10 95#define PROMISE_S_MARKED 0x20 96#define PROMISE_S_MIGRATING 0x40 97#define PROMISE_S_FUNCTIONAL 0x80 98 99 uint8_t type; /* Voluem type. */ 100#define PROMISE_T_RAID0 0x00 101#define PROMISE_T_RAID1 0x01 102#define PROMISE_T_RAID3 0x02 103#define PROMISE_T_RAID5 0x04 104#define PROMISE_T_SPAN 0x08 105#define PROMISE_T_JBOD 0x10 106 107 uint8_t total_disks; /* Disks in this volume. */ 108 uint8_t stripe_shift; /* Strip size. */ 109 uint8_t array_width; /* Number of RAID0 stripes. */ 110 uint8_t array_number; /* Global volume number. */ 111 uint32_t total_sectors; /* Volume size. */ 112 uint16_t cylinders; /* Volume geometry: C. */ 113 uint8_t heads; /* Volume geometry: H. */ 114 uint8_t sectors; /* Volume geometry: S. */ 115 uint64_t volume_id __packed; /* Volume ID, */ 116 struct promise_raid_disk disks[PROMISE_MAX_DISKS]; 117 /* Subdisks in this volume. */ 118 char name[32]; /* Volume label. */ 119 120 uint32_t filler2[8]; 121 uint32_t magic_3; /* Something related to rebuild. */ 122 uint64_t rebuild_lba64; /* Per-volume rebuild position. */ 123 uint32_t magic_4; 124 uint32_t magic_5; 125 uint32_t total_sectors_high; 126 uint32_t filler3[324]; 127 uint32_t checksum; 128} __packed; 129 130struct g_raid_md_promise_perdisk { 131 int pd_updated; 132 int pd_subdisks; 133 struct promise_raid_conf *pd_meta[PROMISE_MAX_SUBDISKS]; 134}; 135 136struct g_raid_md_promise_pervolume { 137 struct promise_raid_conf *pv_meta; 138 uint64_t pv_id; 139 uint16_t pv_generation; 140 int pv_disks_present; 141 int pv_started; 142 struct callout pv_start_co; /* STARTING state timer. */ 143}; 144 145static g_raid_md_create_t g_raid_md_create_promise; 146static g_raid_md_taste_t g_raid_md_taste_promise; 147static g_raid_md_event_t g_raid_md_event_promise; 148static g_raid_md_volume_event_t g_raid_md_volume_event_promise; 149static g_raid_md_ctl_t g_raid_md_ctl_promise; 150static g_raid_md_write_t g_raid_md_write_promise; 151static g_raid_md_fail_disk_t g_raid_md_fail_disk_promise; 152static g_raid_md_free_disk_t g_raid_md_free_disk_promise; 153static g_raid_md_free_volume_t g_raid_md_free_volume_promise; 154static g_raid_md_free_t g_raid_md_free_promise; 155 156static kobj_method_t g_raid_md_promise_methods[] = { 157 KOBJMETHOD(g_raid_md_create, g_raid_md_create_promise), 158 KOBJMETHOD(g_raid_md_taste, g_raid_md_taste_promise), 159 KOBJMETHOD(g_raid_md_event, g_raid_md_event_promise), 160 KOBJMETHOD(g_raid_md_volume_event, g_raid_md_volume_event_promise), 161 KOBJMETHOD(g_raid_md_ctl, g_raid_md_ctl_promise), 162 KOBJMETHOD(g_raid_md_write, g_raid_md_write_promise), 163 KOBJMETHOD(g_raid_md_fail_disk, g_raid_md_fail_disk_promise), 164 KOBJMETHOD(g_raid_md_free_disk, g_raid_md_free_disk_promise), 165 KOBJMETHOD(g_raid_md_free_volume, g_raid_md_free_volume_promise), 166 KOBJMETHOD(g_raid_md_free, g_raid_md_free_promise), 167 { 0, 0 } 168}; 169 170static struct g_raid_md_class g_raid_md_promise_class = { 171 "Promise", 172 g_raid_md_promise_methods, 173 sizeof(struct g_raid_md_object), 174 .mdc_priority = 100 175}; 176 177 178static void 179g_raid_md_promise_print(struct promise_raid_conf *meta) 180{ 181 int i; 182 183 if (g_raid_debug < 1) 184 return; 185 186 printf("********* ATA Promise Metadata *********\n"); 187 printf("promise_id <%.24s>\n", meta->promise_id); 188 printf("disk %02x %02x %02x %02x %016jx\n", 189 meta->disk.flags, meta->disk.number, meta->disk.channel, 190 meta->disk.device, meta->disk.id); 191 printf("disk_offset %u\n", meta->disk_offset); 192 printf("disk_sectors %u\n", meta->disk_sectors); 193 printf("rebuild_lba %u\n", meta->rebuild_lba); 194 printf("generation %u\n", meta->generation); 195 printf("status 0x%02x\n", meta->status); 196 printf("type %u\n", meta->type); 197 printf("total_disks %u\n", meta->total_disks); 198 printf("stripe_shift %u\n", meta->stripe_shift); 199 printf("array_width %u\n", meta->array_width); 200 printf("array_number %u\n", meta->array_number); 201 printf("total_sectors %u\n", meta->total_sectors); 202 printf("cylinders %u\n", meta->cylinders); 203 printf("heads %u\n", meta->heads); 204 printf("sectors %u\n", meta->sectors); 205 printf("volume_id 0x%016jx\n", meta->volume_id); 206 printf("disks:\n"); 207 for (i = 0; i < PROMISE_MAX_DISKS; i++ ) { 208 printf(" %02x %02x %02x %02x %016jx\n", 209 meta->disks[i].flags, meta->disks[i].number, 210 meta->disks[i].channel, meta->disks[i].device, 211 meta->disks[i].id); 212 } 213 printf("name <%.32s>\n", meta->name); 214 printf("magic_3 0x%08x\n", meta->magic_3); 215 printf("rebuild_lba64 %ju\n", meta->rebuild_lba64); 216 printf("magic_4 0x%08x\n", meta->magic_4); 217 printf("magic_5 0x%08x\n", meta->magic_5); 218 printf("total_sectors_high 0x%08x\n", meta->total_sectors_high); 219 printf("=================================================\n"); 220} 221 222static struct promise_raid_conf * 223promise_meta_copy(struct promise_raid_conf *meta) 224{ 225 struct promise_raid_conf *nmeta; 226 227 nmeta = malloc(sizeof(*nmeta), M_MD_PROMISE, M_WAITOK); 228 memcpy(nmeta, meta, sizeof(*nmeta)); 229 return (nmeta); 230} 231 232static int 233promise_meta_find_disk(struct promise_raid_conf *meta, uint64_t id) 234{ 235 int pos; 236 237 for (pos = 0; pos < meta->total_disks; pos++) { 238 if (meta->disks[pos].id == id) 239 return (pos); 240 } 241 return (-1); 242} 243 244static int 245promise_meta_unused_range(struct promise_raid_conf **metaarr, int nsd, 246 uint32_t sectors, uint32_t *off, uint32_t *size) 247{ 248 uint32_t coff, csize; 249 int i, j; 250 251 sectors -= 131072; 252 *off = 0; 253 *size = 0; 254 coff = 0; 255 csize = sectors; 256 i = 0; 257 while (1) { 258 for (j = 0; j < nsd; j++) { 259 if (metaarr[j]->disk_offset >= coff) { 260 csize = MIN(csize, 261 metaarr[j]->disk_offset - coff); 262 } 263 } 264 if (csize > *size) { 265 *off = coff; 266 *size = csize; 267 } 268 if (i >= nsd) 269 break; 270 coff = metaarr[i]->disk_offset + metaarr[i]->disk_sectors; 271 csize = sectors - coff; 272 i++; 273 }; 274 return ((*size > 0) ? 1 : 0); 275} 276 277static int 278promise_meta_translate_disk(struct g_raid_volume *vol, int md_disk_pos) 279{ 280 int disk_pos, width; 281 282 if (md_disk_pos >= 0 && vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) { 283 width = vol->v_disks_count / 2; 284 disk_pos = (md_disk_pos / width) + 285 (md_disk_pos % width) * width; 286 } else 287 disk_pos = md_disk_pos; 288 return (disk_pos); 289} 290 291static void 292promise_meta_get_name(struct promise_raid_conf *meta, char *buf) 293{ 294 int i; 295 296 strncpy(buf, meta->name, 32); 297 buf[32] = 0; 298 for (i = 31; i >= 0; i--) { 299 if (buf[i] > 0x20) 300 break; 301 buf[i] = 0; 302 } 303} 304 305static void 306promise_meta_put_name(struct promise_raid_conf *meta, char *buf) 307{ 308 309 memset(meta->name, 0x20, 32); 310 memcpy(meta->name, buf, MIN(strlen(buf), 32)); 311} 312 313static int 314promise_meta_read(struct g_consumer *cp, struct promise_raid_conf **metaarr) 315{ 316 struct g_provider *pp; 317 struct promise_raid_conf *meta; 318 char *buf; 319 int error, i, subdisks; 320 uint32_t checksum, *ptr; 321 322 pp = cp->provider; 323 subdisks = 0; 324next: 325 /* Read metadata block. */ 326 buf = g_read_data(cp, pp->mediasize - pp->sectorsize * 327 (63 - subdisks * PROMISE_META_OFFSET), 328 pp->sectorsize * 4, &error); 329 if (buf == NULL) { 330 G_RAID_DEBUG(1, "Cannot read metadata from %s (error=%d).", 331 pp->name, error); 332 return (subdisks); 333 } 334 meta = (struct promise_raid_conf *)buf; 335 336 /* Check if this is an Promise RAID struct */ 337 if (strncmp(meta->promise_id, PROMISE_MAGIC, strlen(PROMISE_MAGIC)) && 338 strncmp(meta->promise_id, FREEBSD_MAGIC, strlen(FREEBSD_MAGIC))) { 339 if (subdisks == 0) 340 G_RAID_DEBUG(1, 341 "Promise signature check failed on %s", pp->name); 342 g_free(buf); 343 return (subdisks); 344 } 345 meta = malloc(sizeof(*meta), M_MD_PROMISE, M_WAITOK); 346 memcpy(meta, buf, MIN(sizeof(*meta), pp->sectorsize * 4)); 347 g_free(buf); 348 349 /* Check metadata checksum. */ 350 for (checksum = 0, ptr = (uint32_t *)meta, i = 0; i < 511; i++) 351 checksum += *ptr++; 352 if (checksum != meta->checksum) { 353 G_RAID_DEBUG(1, "Promise checksum check failed on %s", pp->name); 354 free(meta, M_MD_PROMISE); 355 return (subdisks); 356 } 357 358 if ((meta->integrity & PROMISE_I_VALID) == 0) { 359 G_RAID_DEBUG(1, "Promise metadata is invalid on %s", pp->name); 360 free(meta, M_MD_PROMISE); 361 return (subdisks); 362 } 363 364 if (meta->total_disks > PROMISE_MAX_DISKS) { 365 G_RAID_DEBUG(1, "Wrong number of disks on %s (%d)", 366 pp->name, meta->total_disks); 367 free(meta, M_MD_PROMISE); 368 return (subdisks); 369 } 370 371 /* Save this part and look for next. */ 372 *metaarr = meta; 373 metaarr++; 374 subdisks++; 375 if (subdisks < PROMISE_MAX_SUBDISKS) 376 goto next; 377 378 return (subdisks); 379} 380 381static int 382promise_meta_write(struct g_consumer *cp, 383 struct promise_raid_conf **metaarr, int nsd) 384{ 385 struct g_provider *pp; 386 struct promise_raid_conf *meta; 387 char *buf; 388 int error, i, subdisk, fake; 389 uint32_t checksum, *ptr, off, size; 390 391 pp = cp->provider; 392 subdisk = 0; 393 fake = 0; 394next: 395 buf = malloc(pp->sectorsize * 4, M_MD_PROMISE, M_WAITOK | M_ZERO); 396 meta = NULL; 397 if (subdisk < nsd) { 398 meta = metaarr[subdisk]; 399 } else if (!fake && promise_meta_unused_range(metaarr, nsd, 400 cp->provider->mediasize / cp->provider->sectorsize, 401 &off, &size)) { 402 /* Optionally add record for unused space. */ 403 meta = (struct promise_raid_conf *)buf; 404 memcpy(&meta->promise_id[0], PROMISE_MAGIC, 405 sizeof(PROMISE_MAGIC) - 1); 406 meta->dummy_0 = 0x00020000; 407 meta->integrity = PROMISE_I_VALID; 408 meta->disk.flags = PROMISE_F_ONLINE | PROMISE_F_VALID; 409 meta->disk.number = 0xff; 410 arc4rand(&meta->disk.id, sizeof(meta->disk.id), 0); 411 meta->disk_offset = off; 412 meta->disk_sectors = size; 413 meta->rebuild_lba = UINT32_MAX; 414 fake = 1; 415 } 416 if (meta != NULL) { 417 /* Recalculate checksum for case if metadata were changed. */ 418 meta->checksum = 0; 419 for (checksum = 0, ptr = (uint32_t *)meta, i = 0; i < 511; i++) 420 checksum += *ptr++; 421 meta->checksum = checksum; 422 memcpy(buf, meta, MIN(pp->sectorsize * 4, sizeof(*meta))); 423 } 424 error = g_write_data(cp, pp->mediasize - pp->sectorsize * 425 (63 - subdisk * PROMISE_META_OFFSET), 426 buf, pp->sectorsize * 4); 427 if (error != 0) { 428 G_RAID_DEBUG(1, "Cannot write metadata to %s (error=%d).", 429 pp->name, error); 430 } 431 free(buf, M_MD_PROMISE); 432 433 subdisk++; 434 if (subdisk < PROMISE_MAX_SUBDISKS) 435 goto next; 436 437 return (error); 438} 439 440static int 441promise_meta_erase(struct g_consumer *cp) 442{ 443 struct g_provider *pp; 444 char *buf; 445 int error, subdisk; 446 447 pp = cp->provider; 448 buf = malloc(4 * pp->sectorsize, M_MD_PROMISE, M_WAITOK | M_ZERO); 449 for (subdisk = 0; subdisk < PROMISE_MAX_SUBDISKS; subdisk++) { 450 error = g_write_data(cp, pp->mediasize - pp->sectorsize * 451 (63 - subdisk * PROMISE_META_OFFSET), 452 buf, 4 * pp->sectorsize); 453 if (error != 0) { 454 G_RAID_DEBUG(1, "Cannot erase metadata on %s (error=%d).", 455 pp->name, error); 456 } 457 } 458 free(buf, M_MD_PROMISE); 459 return (error); 460} 461 462static int 463promise_meta_write_spare(struct g_consumer *cp) 464{ 465 struct promise_raid_conf *meta; 466 int error; 467 468 meta = malloc(sizeof(*meta), M_MD_PROMISE, M_WAITOK | M_ZERO); 469 memcpy(&meta->promise_id[0], PROMISE_MAGIC, sizeof(PROMISE_MAGIC) - 1); 470 meta->dummy_0 = 0x00020000; 471 meta->integrity = PROMISE_I_VALID; 472 meta->disk.flags = PROMISE_F_SPARE | PROMISE_F_ONLINE | PROMISE_F_VALID; 473 meta->disk.number = 0xff; 474 arc4rand(&meta->disk.id, sizeof(meta->disk.id), 0); 475 meta->disk_sectors = cp->provider->mediasize / cp->provider->sectorsize; 476 meta->disk_sectors -= 131072; 477 meta->rebuild_lba = UINT32_MAX; 478 error = promise_meta_write(cp, &meta, 1); 479 free(meta, M_MD_PROMISE); 480 return (error); 481} 482 483static struct g_raid_volume * 484g_raid_md_promise_get_volume(struct g_raid_softc *sc, uint64_t id) 485{ 486 struct g_raid_volume *vol; 487 struct g_raid_md_promise_pervolume *pv; 488 489 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 490 pv = vol->v_md_data; 491 if (pv->pv_id == id) 492 break; 493 } 494 return (vol); 495} 496 497static int 498g_raid_md_promise_purge_volumes(struct g_raid_softc *sc) 499{ 500 struct g_raid_volume *vol, *tvol; 501 struct g_raid_md_promise_pervolume *pv; 502 int i, res; 503 504 res = 0; 505 TAILQ_FOREACH_SAFE(vol, &sc->sc_volumes, v_next, tvol) { 506 pv = vol->v_md_data; 507 if (!pv->pv_started || vol->v_stopping) 508 continue; 509 for (i = 0; i < vol->v_disks_count; i++) { 510 if (vol->v_subdisks[i].sd_state != G_RAID_SUBDISK_S_NONE) 511 break; 512 } 513 if (i >= vol->v_disks_count) { 514 g_raid_destroy_volume(vol); 515 res = 1; 516 } 517 } 518 return (res); 519} 520 521static int 522g_raid_md_promise_purge_disks(struct g_raid_softc *sc) 523{ 524 struct g_raid_disk *disk, *tdisk; 525 struct g_raid_volume *vol; 526 struct g_raid_md_promise_perdisk *pd; 527 int i, j, res; 528 529 res = 0; 530 TAILQ_FOREACH_SAFE(disk, &sc->sc_disks, d_next, tdisk) { 531 if (disk->d_state == G_RAID_DISK_S_SPARE) 532 continue; 533 pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 534 535 /* Scan for deleted volumes. */ 536 for (i = 0; i < pd->pd_subdisks; ) { 537 vol = g_raid_md_promise_get_volume(sc, 538 pd->pd_meta[i]->volume_id); 539 if (vol != NULL && !vol->v_stopping) { 540 i++; 541 continue; 542 } 543 free(pd->pd_meta[i], M_MD_PROMISE); 544 for (j = i; j < pd->pd_subdisks - 1; j++) 545 pd->pd_meta[j] = pd->pd_meta[j + 1]; 546 pd->pd_meta[PROMISE_MAX_SUBDISKS - 1] = NULL; 547 pd->pd_subdisks--; 548 pd->pd_updated = 1; 549 } 550 551 /* If there is no metadata left - erase and delete disk. */ 552 if (pd->pd_subdisks == 0) { 553 promise_meta_erase(disk->d_consumer); 554 g_raid_destroy_disk(disk); 555 res = 1; 556 } 557 } 558 return (res); 559} 560 561static int 562g_raid_md_promise_supported(int level, int qual, int disks, int force) 563{ 564 565 if (disks > PROMISE_MAX_DISKS) 566 return (0); 567 switch (level) { 568 case G_RAID_VOLUME_RL_RAID0: 569 if (disks < 1) 570 return (0); 571 if (!force && disks < 2) 572 return (0); 573 break; 574 case G_RAID_VOLUME_RL_RAID1: 575 if (disks < 1) 576 return (0); 577 if (!force && (disks != 2)) 578 return (0); 579 break; 580 case G_RAID_VOLUME_RL_RAID1E: 581 if (disks < 2) 582 return (0); 583 if (disks % 2 != 0) 584 return (0); 585 if (!force && (disks != 4)) 586 return (0); 587 break; 588 case G_RAID_VOLUME_RL_SINGLE: 589 if (disks != 1) 590 return (0); 591 break; 592 case G_RAID_VOLUME_RL_CONCAT: 593 if (disks < 2) 594 return (0); 595 break; 596 case G_RAID_VOLUME_RL_RAID5: 597 if (disks < 3) 598 return (0); 599 if (qual != G_RAID_VOLUME_RLQ_R5LA) 600 return (0); 601 break; 602 default: 603 return (0); 604 } 605 if (level != G_RAID_VOLUME_RL_RAID5 && qual != G_RAID_VOLUME_RLQ_NONE) 606 return (0); 607 return (1); 608} 609 610static int 611g_raid_md_promise_start_disk(struct g_raid_disk *disk, int sdn, 612 struct g_raid_volume *vol) 613{ 614 struct g_raid_softc *sc; 615 struct g_raid_subdisk *sd; 616 struct g_raid_md_promise_perdisk *pd; 617 struct g_raid_md_promise_pervolume *pv; 618 struct promise_raid_conf *meta; 619 off_t size; 620 int disk_pos, md_disk_pos, i, resurrection = 0; 621 uint32_t eoff, esize; 622 623 sc = disk->d_softc; 624 pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 625 626 pv = vol->v_md_data; 627 meta = pv->pv_meta; 628 629 if (sdn >= 0) { 630 /* Find disk position in metadata by it's serial. */ 631 md_disk_pos = promise_meta_find_disk(meta, pd->pd_meta[sdn]->disk.id); 632 /* For RAID0+1 we need to translate order. */ 633 disk_pos = promise_meta_translate_disk(vol, md_disk_pos); 634 } else { 635 md_disk_pos = -1; 636 disk_pos = -1; 637 } 638 if (disk_pos < 0) { 639 G_RAID_DEBUG1(1, sc, "Disk %s is not part of the volume %s", 640 g_raid_get_diskname(disk), vol->v_name); 641 /* Failed stale disk is useless for us. */ 642 if (sdn >= 0 && 643 pd->pd_meta[sdn]->disk.flags & PROMISE_F_DOWN) { 644 g_raid_change_disk_state(disk, G_RAID_DISK_S_STALE_FAILED); 645 return (0); 646 } 647 /* If we were given specific metadata subdisk - erase it. */ 648 if (sdn >= 0) { 649 free(pd->pd_meta[sdn], M_MD_PROMISE); 650 for (i = sdn; i < pd->pd_subdisks - 1; i++) 651 pd->pd_meta[i] = pd->pd_meta[i + 1]; 652 pd->pd_meta[PROMISE_MAX_SUBDISKS - 1] = NULL; 653 pd->pd_subdisks--; 654 } 655 /* If we are in the start process, that's all for now. */ 656 if (!pv->pv_started) 657 goto nofit; 658 /* 659 * If we have already started - try to get use of the disk. 660 * Try to replace OFFLINE disks first, then FAILED. 661 */ 662 promise_meta_unused_range(pd->pd_meta, pd->pd_subdisks, 663 disk->d_consumer->provider->mediasize / 664 disk->d_consumer->provider->sectorsize, 665 &eoff, &esize); 666 if (esize == 0) { 667 G_RAID_DEBUG1(1, sc, "No free space on disk %s", 668 g_raid_get_diskname(disk)); 669 goto nofit; 670 } 671 size = INT64_MAX; 672 for (i = 0; i < vol->v_disks_count; i++) { 673 sd = &vol->v_subdisks[i]; 674 if (sd->sd_state != G_RAID_SUBDISK_S_NONE) 675 size = sd->sd_size; 676 if (sd->sd_state <= G_RAID_SUBDISK_S_FAILED && 677 (disk_pos < 0 || 678 vol->v_subdisks[i].sd_state < sd->sd_state)) 679 disk_pos = i; 680 } 681 if (disk_pos >= 0 && 682 vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT && 683 (off_t)esize * 512 < size) { 684 G_RAID_DEBUG1(1, sc, "Disk %s free space " 685 "is too small (%ju < %ju)", 686 g_raid_get_diskname(disk), 687 (off_t)esize * 512, size); 688 disk_pos = -1; 689 } 690 if (disk_pos >= 0) { 691 if (vol->v_raid_level != G_RAID_VOLUME_RL_CONCAT) 692 esize = size / 512; 693 /* For RAID0+1 we need to translate order. */ 694 md_disk_pos = promise_meta_translate_disk(vol, disk_pos); 695 } else { 696nofit: 697 if (pd->pd_subdisks == 0) { 698 g_raid_change_disk_state(disk, 699 G_RAID_DISK_S_SPARE); 700 } 701 return (0); 702 } 703 G_RAID_DEBUG1(1, sc, "Disk %s takes pos %d in the volume %s", 704 g_raid_get_diskname(disk), disk_pos, vol->v_name); 705 resurrection = 1; 706 } 707 708 sd = &vol->v_subdisks[disk_pos]; 709 710 if (resurrection && sd->sd_disk != NULL) { 711 g_raid_change_disk_state(sd->sd_disk, 712 G_RAID_DISK_S_STALE_FAILED); 713 TAILQ_REMOVE(&sd->sd_disk->d_subdisks, 714 sd, sd_next); 715 } 716 vol->v_subdisks[disk_pos].sd_disk = disk; 717 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next); 718 719 /* Welcome the new disk. */ 720 if (resurrection) 721 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE); 722 else if (meta->disks[md_disk_pos].flags & PROMISE_F_DOWN) 723 g_raid_change_disk_state(disk, G_RAID_DISK_S_FAILED); 724 else 725 g_raid_change_disk_state(disk, G_RAID_DISK_S_ACTIVE); 726 727 if (resurrection) { 728 sd->sd_offset = (off_t)eoff * 512; 729 sd->sd_size = (off_t)esize * 512; 730 } else { 731 sd->sd_offset = (off_t)pd->pd_meta[sdn]->disk_offset * 512; 732 sd->sd_size = (off_t)pd->pd_meta[sdn]->disk_sectors * 512; 733 } 734 735 if (resurrection) { 736 /* Stale disk, almost same as new. */ 737 g_raid_change_subdisk_state(sd, 738 G_RAID_SUBDISK_S_NEW); 739 } else if (meta->disks[md_disk_pos].flags & PROMISE_F_DOWN) { 740 /* Failed disk. */ 741 g_raid_change_subdisk_state(sd, 742 G_RAID_SUBDISK_S_FAILED); 743 } else if (meta->disks[md_disk_pos].flags & PROMISE_F_REDIR) { 744 /* Rebuilding disk. */ 745 g_raid_change_subdisk_state(sd, 746 G_RAID_SUBDISK_S_REBUILD); 747 if (pd->pd_meta[sdn]->generation != meta->generation) 748 sd->sd_rebuild_pos = 0; 749 else { 750 sd->sd_rebuild_pos = 751 (off_t)pd->pd_meta[sdn]->rebuild_lba * 512; 752 } 753 } else if (!(meta->disks[md_disk_pos].flags & PROMISE_F_ONLINE)) { 754 /* Rebuilding disk. */ 755 g_raid_change_subdisk_state(sd, 756 G_RAID_SUBDISK_S_NEW); 757 } else if (pd->pd_meta[sdn]->generation != meta->generation || 758 (meta->status & PROMISE_S_MARKED)) { 759 /* Stale disk or dirty volume (unclean shutdown). */ 760 g_raid_change_subdisk_state(sd, 761 G_RAID_SUBDISK_S_STALE); 762 } else { 763 /* Up to date disk. */ 764 g_raid_change_subdisk_state(sd, 765 G_RAID_SUBDISK_S_ACTIVE); 766 } 767 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW, 768 G_RAID_EVENT_SUBDISK); 769 770 return (resurrection); 771} 772 773static void 774g_raid_md_promise_refill(struct g_raid_softc *sc) 775{ 776 struct g_raid_volume *vol; 777 struct g_raid_subdisk *sd; 778 struct g_raid_disk *disk; 779 struct g_raid_md_object *md; 780 struct g_raid_md_promise_perdisk *pd; 781 struct g_raid_md_promise_pervolume *pv; 782 int update, updated, i, bad; 783 784 md = sc->sc_md; 785restart: 786 updated = 0; 787 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 788 pv = vol->v_md_data; 789 if (!pv->pv_started || vol->v_stopping) 790 continue; 791 792 /* Search for subdisk that needs replacement. */ 793 bad = 0; 794 for (i = 0; i < vol->v_disks_count; i++) { 795 sd = &vol->v_subdisks[i]; 796 if (sd->sd_state == G_RAID_SUBDISK_S_NONE || 797 sd->sd_state == G_RAID_SUBDISK_S_FAILED) 798 bad = 1; 799 } 800 if (!bad) 801 continue; 802 803 G_RAID_DEBUG1(1, sc, "Volume %s is not complete, " 804 "trying to refill.", vol->v_name); 805 806 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 807 /* Skip failed. */ 808 if (disk->d_state < G_RAID_DISK_S_SPARE) 809 continue; 810 /* Skip already used by this volume. */ 811 for (i = 0; i < vol->v_disks_count; i++) { 812 sd = &vol->v_subdisks[i]; 813 if (sd->sd_disk == disk) 814 break; 815 } 816 if (i < vol->v_disks_count) 817 continue; 818 819 /* Try to use disk if it has empty extents. */ 820 pd = disk->d_md_data; 821 if (pd->pd_subdisks < PROMISE_MAX_SUBDISKS) { 822 update = 823 g_raid_md_promise_start_disk(disk, -1, vol); 824 } else 825 update = 0; 826 if (update) { 827 updated = 1; 828 g_raid_md_write_promise(md, vol, NULL, disk); 829 break; 830 } 831 } 832 } 833 if (updated) 834 goto restart; 835} 836 837static void 838g_raid_md_promise_start(struct g_raid_volume *vol) 839{ 840 struct g_raid_softc *sc; 841 struct g_raid_subdisk *sd; 842 struct g_raid_disk *disk; 843 struct g_raid_md_object *md; 844 struct g_raid_md_promise_perdisk *pd; 845 struct g_raid_md_promise_pervolume *pv; 846 struct promise_raid_conf *meta; 847 int i; 848 849 sc = vol->v_softc; 850 md = sc->sc_md; 851 pv = vol->v_md_data; 852 meta = pv->pv_meta; 853 854 vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_NONE; 855 if (meta->type == PROMISE_T_RAID0) 856 vol->v_raid_level = G_RAID_VOLUME_RL_RAID0; 857 else if (meta->type == PROMISE_T_RAID1) { 858 if (meta->array_width == 1) 859 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1; 860 else 861 vol->v_raid_level = G_RAID_VOLUME_RL_RAID1E; 862 } else if (meta->type == PROMISE_T_RAID3) 863 vol->v_raid_level = G_RAID_VOLUME_RL_RAID3; 864 else if (meta->type == PROMISE_T_RAID5) { 865 vol->v_raid_level = G_RAID_VOLUME_RL_RAID5; 866 vol->v_raid_level_qualifier = G_RAID_VOLUME_RLQ_R5LA; 867 } else if (meta->type == PROMISE_T_SPAN) 868 vol->v_raid_level = G_RAID_VOLUME_RL_CONCAT; 869 else if (meta->type == PROMISE_T_JBOD) 870 vol->v_raid_level = G_RAID_VOLUME_RL_SINGLE; 871 else 872 vol->v_raid_level = G_RAID_VOLUME_RL_UNKNOWN; 873 vol->v_strip_size = 512 << meta->stripe_shift; //ZZZ 874 vol->v_disks_count = meta->total_disks; 875 vol->v_mediasize = (off_t)meta->total_sectors * 512; //ZZZ 876 if (meta->total_sectors_high < 256) /* If value looks sane. */ 877 vol->v_mediasize |= 878 ((off_t)meta->total_sectors_high << 32) * 512; //ZZZ 879 vol->v_sectorsize = 512; //ZZZ 880 for (i = 0; i < vol->v_disks_count; i++) { 881 sd = &vol->v_subdisks[i]; 882 sd->sd_offset = (off_t)meta->disk_offset * 512; //ZZZ 883 sd->sd_size = (off_t)meta->disk_sectors * 512; //ZZZ 884 } 885 g_raid_start_volume(vol); 886 887 /* Make all disks found till the moment take their places. */ 888 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 889 pd = disk->d_md_data; 890 for (i = 0; i < pd->pd_subdisks; i++) { 891 if (pd->pd_meta[i]->volume_id == meta->volume_id) 892 g_raid_md_promise_start_disk(disk, i, vol); 893 } 894 } 895 896 pv->pv_started = 1; 897 callout_stop(&pv->pv_start_co); 898 G_RAID_DEBUG1(0, sc, "Volume started."); 899 g_raid_md_write_promise(md, vol, NULL, NULL); 900 901 /* Pickup any STALE/SPARE disks to refill array if needed. */ 902 g_raid_md_promise_refill(sc); 903 904 g_raid_event_send(vol, G_RAID_VOLUME_E_START, G_RAID_EVENT_VOLUME); 905} 906 907static void 908g_raid_promise_go(void *arg) 909{ 910 struct g_raid_volume *vol; 911 struct g_raid_softc *sc; 912 struct g_raid_md_promise_pervolume *pv; 913 914 vol = arg; 915 pv = vol->v_md_data; 916 sc = vol->v_softc; 917 if (!pv->pv_started) { 918 G_RAID_DEBUG1(0, sc, "Force volume start due to timeout."); 919 g_raid_event_send(vol, G_RAID_VOLUME_E_STARTMD, 920 G_RAID_EVENT_VOLUME); 921 } 922} 923 924static void 925g_raid_md_promise_new_disk(struct g_raid_disk *disk) 926{ 927 struct g_raid_softc *sc; 928 struct g_raid_md_object *md; 929 struct promise_raid_conf *pdmeta; 930 struct g_raid_md_promise_perdisk *pd; 931 struct g_raid_md_promise_pervolume *pv; 932 struct g_raid_volume *vol; 933 int i; 934 char buf[33]; 935 936 sc = disk->d_softc; 937 md = sc->sc_md; 938 pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 939 940 if (pd->pd_subdisks == 0) { 941 g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE); 942 g_raid_md_promise_refill(sc); 943 return; 944 } 945 946 for (i = 0; i < pd->pd_subdisks; i++) { 947 pdmeta = pd->pd_meta[i]; 948 949 /* Look for volume with matching ID. */ 950 vol = g_raid_md_promise_get_volume(sc, pdmeta->volume_id); 951 if (vol == NULL) { 952 promise_meta_get_name(pdmeta, buf); 953 vol = g_raid_create_volume(sc, buf, pdmeta->array_number); 954 pv = malloc(sizeof(*pv), M_MD_PROMISE, M_WAITOK | M_ZERO); 955 pv->pv_id = pdmeta->volume_id; 956 vol->v_md_data = pv; 957 callout_init(&pv->pv_start_co, 1); 958 callout_reset(&pv->pv_start_co, 959 g_raid_start_timeout * hz, 960 g_raid_promise_go, vol); 961 } else 962 pv = vol->v_md_data; 963 964 /* If we haven't started yet - check metadata freshness. */ 965 if (pv->pv_meta == NULL || !pv->pv_started) { 966 if (pv->pv_meta == NULL || 967 ((int16_t)(pdmeta->generation - pv->pv_generation)) > 0) { 968 G_RAID_DEBUG1(1, sc, "Newer disk"); 969 if (pv->pv_meta != NULL) 970 free(pv->pv_meta, M_MD_PROMISE); 971 pv->pv_meta = promise_meta_copy(pdmeta); 972 pv->pv_generation = pv->pv_meta->generation; 973 pv->pv_disks_present = 1; 974 } else if (pdmeta->generation == pv->pv_generation) { 975 pv->pv_disks_present++; 976 G_RAID_DEBUG1(1, sc, "Matching disk (%d of %d up)", 977 pv->pv_disks_present, 978 pv->pv_meta->total_disks); 979 } else { 980 G_RAID_DEBUG1(1, sc, "Older disk"); 981 } 982 } 983 } 984 985 for (i = 0; i < pd->pd_subdisks; i++) { 986 pdmeta = pd->pd_meta[i]; 987 988 /* Look for volume with matching ID. */ 989 vol = g_raid_md_promise_get_volume(sc, pdmeta->volume_id); 990 if (vol == NULL) 991 continue; 992 pv = vol->v_md_data; 993 994 if (pv->pv_started) { 995 if (g_raid_md_promise_start_disk(disk, i, vol)) 996 g_raid_md_write_promise(md, vol, NULL, NULL); 997 } else { 998 /* If we collected all needed disks - start array. */ 999 if (pv->pv_disks_present == pv->pv_meta->total_disks) 1000 g_raid_md_promise_start(vol); 1001 } 1002 } 1003} 1004 1005static int 1006g_raid_md_create_promise(struct g_raid_md_object *md, struct g_class *mp, 1007 struct g_geom **gp) 1008{ 1009 struct g_geom *geom; 1010 struct g_raid_softc *sc; 1011 1012 /* Search for existing node. */ 1013 LIST_FOREACH(geom, &mp->geom, geom) { 1014 sc = geom->softc; 1015 if (sc == NULL) 1016 continue; 1017 if (sc->sc_stopping != 0) 1018 continue; 1019 if (sc->sc_md->mdo_class != md->mdo_class) 1020 continue; 1021 break; 1022 } 1023 if (geom != NULL) { 1024 *gp = geom; 1025 return (G_RAID_MD_TASTE_EXISTING); 1026 } 1027 1028 /* Create new one if not found. */ 1029 sc = g_raid_create_node(mp, "Promise", md); 1030 if (sc == NULL) 1031 return (G_RAID_MD_TASTE_FAIL); 1032 md->mdo_softc = sc; 1033 *gp = sc->sc_geom; 1034 return (G_RAID_MD_TASTE_NEW); 1035} 1036 1037static int 1038g_raid_md_taste_promise(struct g_raid_md_object *md, struct g_class *mp, 1039 struct g_consumer *cp, struct g_geom **gp) 1040{ 1041 struct g_consumer *rcp; 1042 struct g_provider *pp; 1043 struct g_raid_softc *sc; 1044 struct g_raid_disk *disk; 1045 struct promise_raid_conf *meta, *metaarr[4]; 1046 struct g_raid_md_promise_perdisk *pd; 1047 struct g_geom *geom; 1048 int error, i, j, result, len, subdisks; 1049 char name[16]; 1050 uint16_t vendor; 1051 1052 G_RAID_DEBUG(1, "Tasting Promise on %s", cp->provider->name); 1053 pp = cp->provider; 1054 1055 /* Read metadata from device. */ 1056 meta = NULL; 1057 vendor = 0xffff; 1058 if (g_access(cp, 1, 0, 0) != 0) 1059 return (G_RAID_MD_TASTE_FAIL); 1060 g_topology_unlock(); 1061 len = 2; 1062 if (pp->geom->rank == 1) 1063 g_io_getattr("GEOM::hba_vendor", cp, &len, &vendor); 1064 subdisks = promise_meta_read(cp, metaarr); 1065 g_topology_lock(); 1066 g_access(cp, -1, 0, 0); 1067 if (subdisks == 0) { 1068 if (g_raid_aggressive_spare) { 1069 if (vendor == 0x105a || vendor == 0x1002) { 1070 G_RAID_DEBUG(1, 1071 "No Promise metadata, forcing spare."); 1072 goto search; 1073 } else { 1074 G_RAID_DEBUG(1, 1075 "Promise/ATI vendor mismatch " 1076 "0x%04x != 0x105a/0x1002", 1077 vendor); 1078 } 1079 } 1080 return (G_RAID_MD_TASTE_FAIL); 1081 } 1082 1083 /* Metadata valid. Print it. */ 1084 for (i = 0; i < subdisks; i++) 1085 g_raid_md_promise_print(metaarr[i]); 1086 1087 /* Purge meaningless (empty/spare) records. */ 1088 for (i = 0; i < subdisks; ) { 1089 if (metaarr[i]->disk.flags & PROMISE_F_ASSIGNED) { 1090 i++; 1091 continue; 1092 } 1093 free(metaarr[i], M_MD_PROMISE); 1094 for (j = i; j < subdisks - 1; j++) 1095 metaarr[i] = metaarr[j + 1]; 1096 metaarr[PROMISE_MAX_SUBDISKS - 1] = NULL; 1097 subdisks--; 1098 } 1099 1100search: 1101 /* Search for matching node. */ 1102 sc = NULL; 1103 LIST_FOREACH(geom, &mp->geom, geom) { 1104 sc = geom->softc; 1105 if (sc == NULL) 1106 continue; 1107 if (sc->sc_stopping != 0) 1108 continue; 1109 if (sc->sc_md->mdo_class != md->mdo_class) 1110 continue; 1111 break; 1112 } 1113 1114 /* Found matching node. */ 1115 if (geom != NULL) { 1116 G_RAID_DEBUG(1, "Found matching array %s", sc->sc_name); 1117 result = G_RAID_MD_TASTE_EXISTING; 1118 1119 } else { /* Not found matching node -- create one. */ 1120 result = G_RAID_MD_TASTE_NEW; 1121 snprintf(name, sizeof(name), "Promise"); 1122 sc = g_raid_create_node(mp, name, md); 1123 md->mdo_softc = sc; 1124 geom = sc->sc_geom; 1125 } 1126 1127 rcp = g_new_consumer(geom); 1128 g_attach(rcp, pp); 1129 if (g_access(rcp, 1, 1, 1) != 0) 1130 ; //goto fail1; 1131 1132 g_topology_unlock(); 1133 sx_xlock(&sc->sc_lock); 1134 1135 pd = malloc(sizeof(*pd), M_MD_PROMISE, M_WAITOK | M_ZERO); 1136 pd->pd_subdisks = subdisks; 1137 for (i = 0; i < subdisks; i++) 1138 pd->pd_meta[i] = metaarr[i]; 1139 disk = g_raid_create_disk(sc); 1140 disk->d_md_data = (void *)pd; 1141 disk->d_consumer = rcp; 1142 rcp->private = disk; 1143 1144 /* Read kernel dumping information. */ 1145 disk->d_kd.offset = 0; 1146 disk->d_kd.length = OFF_MAX; 1147 len = sizeof(disk->d_kd); 1148 error = g_io_getattr("GEOM::kerneldump", rcp, &len, &disk->d_kd); 1149 if (disk->d_kd.di.dumper == NULL) 1150 G_RAID_DEBUG1(2, sc, "Dumping not supported by %s: %d.", 1151 rcp->provider->name, error); 1152 1153 g_raid_md_promise_new_disk(disk); 1154 1155 sx_xunlock(&sc->sc_lock); 1156 g_topology_lock(); 1157 *gp = geom; 1158 return (result); 1159} 1160 1161static int 1162g_raid_md_event_promise(struct g_raid_md_object *md, 1163 struct g_raid_disk *disk, u_int event) 1164{ 1165 struct g_raid_softc *sc; 1166 1167 sc = md->mdo_softc; 1168 if (disk == NULL) 1169 return (-1); 1170 switch (event) { 1171 case G_RAID_DISK_E_DISCONNECTED: 1172 /* Delete disk. */ 1173 g_raid_change_disk_state(disk, G_RAID_DISK_S_NONE); 1174 g_raid_destroy_disk(disk); 1175 g_raid_md_promise_purge_volumes(sc); 1176 1177 /* Write updated metadata to all disks. */ 1178 g_raid_md_write_promise(md, NULL, NULL, NULL); 1179 1180 /* Check if anything left. */ 1181 if (g_raid_ndisks(sc, -1) == 0) 1182 g_raid_destroy_node(sc, 0); 1183 else 1184 g_raid_md_promise_refill(sc); 1185 return (0); 1186 } 1187 return (-2); 1188} 1189 1190static int 1191g_raid_md_volume_event_promise(struct g_raid_md_object *md, 1192 struct g_raid_volume *vol, u_int event) 1193{ 1194 struct g_raid_md_promise_pervolume *pv; 1195 1196 pv = (struct g_raid_md_promise_pervolume *)vol->v_md_data; 1197 switch (event) { 1198 case G_RAID_VOLUME_E_STARTMD: 1199 if (!pv->pv_started) 1200 g_raid_md_promise_start(vol); 1201 return (0); 1202 } 1203 return (-2); 1204} 1205 1206static int 1207g_raid_md_ctl_promise(struct g_raid_md_object *md, 1208 struct gctl_req *req) 1209{ 1210 struct g_raid_softc *sc; 1211 struct g_raid_volume *vol, *vol1; 1212 struct g_raid_subdisk *sd; 1213 struct g_raid_disk *disk, *disks[PROMISE_MAX_DISKS]; 1214 struct g_raid_md_promise_perdisk *pd; 1215 struct g_raid_md_promise_pervolume *pv; 1216 struct g_consumer *cp; 1217 struct g_provider *pp; 1218 char arg[16]; 1219 const char *verb, *volname, *levelname, *diskname; 1220 char *tmp; 1221 int *nargs, *force; 1222 off_t size, sectorsize, strip; 1223 intmax_t *sizearg, *striparg; 1224 uint32_t offs[PROMISE_MAX_DISKS], esize; 1225 int numdisks, i, len, level, qual; 1226 int error; 1227 1228 sc = md->mdo_softc; 1229 verb = gctl_get_param(req, "verb", NULL); 1230 nargs = gctl_get_paraml(req, "nargs", sizeof(*nargs)); 1231 error = 0; 1232 if (strcmp(verb, "label") == 0) { 1233 1234 if (*nargs < 4) { 1235 gctl_error(req, "Invalid number of arguments."); 1236 return (-1); 1237 } 1238 volname = gctl_get_asciiparam(req, "arg1"); 1239 if (volname == NULL) { 1240 gctl_error(req, "No volume name."); 1241 return (-2); 1242 } 1243 levelname = gctl_get_asciiparam(req, "arg2"); 1244 if (levelname == NULL) { 1245 gctl_error(req, "No RAID level."); 1246 return (-3); 1247 } 1248 if (strcasecmp(levelname, "RAID5") == 0) 1249 levelname = "RAID5-LA"; 1250 if (g_raid_volume_str2level(levelname, &level, &qual)) { 1251 gctl_error(req, "Unknown RAID level '%s'.", levelname); 1252 return (-4); 1253 } 1254 numdisks = *nargs - 3; 1255 force = gctl_get_paraml(req, "force", sizeof(*force)); 1256 if (!g_raid_md_promise_supported(level, qual, numdisks, 1257 force ? *force : 0)) { 1258 gctl_error(req, "Unsupported RAID level " 1259 "(0x%02x/0x%02x), or number of disks (%d).", 1260 level, qual, numdisks); 1261 return (-5); 1262 } 1263 1264 /* Search for disks, connect them and probe. */ 1265 size = INT64_MAX; 1266 sectorsize = 0; 1267 bzero(disks, sizeof(disks)); 1268 bzero(offs, sizeof(offs)); 1269 for (i = 0; i < numdisks; i++) { 1270 snprintf(arg, sizeof(arg), "arg%d", i + 3); 1271 diskname = gctl_get_asciiparam(req, arg); 1272 if (diskname == NULL) { 1273 gctl_error(req, "No disk name (%s).", arg); 1274 error = -6; 1275 break; 1276 } 1277 if (strcmp(diskname, "NONE") == 0) 1278 continue; 1279 1280 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1281 if (disk->d_consumer != NULL && 1282 disk->d_consumer->provider != NULL && 1283 strcmp(disk->d_consumer->provider->name, 1284 diskname) == 0) 1285 break; 1286 } 1287 if (disk != NULL) { 1288 if (disk->d_state != G_RAID_DISK_S_ACTIVE) { 1289 gctl_error(req, "Disk '%s' is in a " 1290 "wrong state (%s).", diskname, 1291 g_raid_disk_state2str(disk->d_state)); 1292 error = -7; 1293 break; 1294 } 1295 pd = disk->d_md_data; 1296 if (pd->pd_subdisks >= PROMISE_MAX_SUBDISKS) { 1297 gctl_error(req, "Disk '%s' already " 1298 "used by %d volumes.", 1299 diskname, pd->pd_subdisks); 1300 error = -7; 1301 break; 1302 } 1303 pp = disk->d_consumer->provider; 1304 disks[i] = disk; 1305 promise_meta_unused_range(pd->pd_meta, 1306 pd->pd_subdisks, 1307 pp->mediasize / pp->sectorsize, 1308 &offs[i], &esize); 1309 size = MIN(size, (off_t)esize * pp->sectorsize); 1310 sectorsize = MAX(sectorsize, pp->sectorsize); 1311 continue; 1312 } 1313 1314 g_topology_lock(); 1315 cp = g_raid_open_consumer(sc, diskname); 1316 if (cp == NULL) { 1317 gctl_error(req, "Can't open disk '%s'.", 1318 diskname); 1319 g_topology_unlock(); 1320 error = -8; 1321 break; 1322 } 1323 pp = cp->provider; 1324 pd = malloc(sizeof(*pd), M_MD_PROMISE, M_WAITOK | M_ZERO); 1325 disk = g_raid_create_disk(sc); 1326 disk->d_md_data = (void *)pd; 1327 disk->d_consumer = cp; 1328 disks[i] = disk; 1329 cp->private = disk; 1330 g_topology_unlock(); 1331 1332 if (pp->mediasize / pp->sectorsize > UINT32_MAX) { 1333 gctl_error(req, 1334 "Disk '%s' is too big.", diskname); 1335 error = -8; 1336 break; 1337 } 1338 1339 /* Read kernel dumping information. */ 1340 disk->d_kd.offset = 0; 1341 disk->d_kd.length = OFF_MAX; 1342 len = sizeof(disk->d_kd); 1343 g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd); 1344 if (disk->d_kd.di.dumper == NULL) 1345 G_RAID_DEBUG1(2, sc, 1346 "Dumping not supported by %s.", 1347 cp->provider->name); 1348 1349 /* Reserve some space for metadata. */ 1350 size = MIN(size, pp->mediasize - 131072llu * pp->sectorsize); 1351 sectorsize = MAX(sectorsize, pp->sectorsize); 1352 } 1353 if (error != 0) { 1354 for (i = 0; i < numdisks; i++) { 1355 if (disks[i] != NULL && 1356 disks[i]->d_state == G_RAID_DISK_S_NONE) 1357 g_raid_destroy_disk(disks[i]); 1358 } 1359 return (error); 1360 } 1361 1362 if (sectorsize <= 0) { 1363 gctl_error(req, "Can't get sector size."); 1364 return (-8); 1365 } 1366 1367 /* Handle size argument. */ 1368 len = sizeof(*sizearg); 1369 sizearg = gctl_get_param(req, "size", &len); 1370 if (sizearg != NULL && len == sizeof(*sizearg) && 1371 *sizearg > 0) { 1372 if (*sizearg > size) { 1373 gctl_error(req, "Size too big %lld > %lld.", 1374 (long long)*sizearg, (long long)size); 1375 return (-9); 1376 } 1377 size = *sizearg; 1378 } 1379 1380 /* Handle strip argument. */ 1381 strip = 131072; 1382 len = sizeof(*striparg); 1383 striparg = gctl_get_param(req, "strip", &len); 1384 if (striparg != NULL && len == sizeof(*striparg) && 1385 *striparg > 0) { 1386 if (*striparg < sectorsize) { 1387 gctl_error(req, "Strip size too small."); 1388 return (-10); 1389 } 1390 if (*striparg % sectorsize != 0) { 1391 gctl_error(req, "Incorrect strip size."); 1392 return (-11); 1393 } 1394 strip = *striparg; 1395 } 1396 1397 /* Round size down to strip or sector. */ 1398 if (level == G_RAID_VOLUME_RL_RAID1 || 1399 level == G_RAID_VOLUME_RL_SINGLE || 1400 level == G_RAID_VOLUME_RL_CONCAT) 1401 size -= (size % sectorsize); 1402 else if (level == G_RAID_VOLUME_RL_RAID1E && 1403 (numdisks & 1) != 0) 1404 size -= (size % (2 * strip)); 1405 else 1406 size -= (size % strip); 1407 if (size <= 0) { 1408 gctl_error(req, "Size too small."); 1409 return (-13); 1410 } 1411 if (size > 0xffffffffllu * sectorsize) { 1412 gctl_error(req, "Size too big."); 1413 return (-14); 1414 } 1415 1416 /* We have all we need, create things: volume, ... */ 1417 pv = malloc(sizeof(*pv), M_MD_PROMISE, M_WAITOK | M_ZERO); 1418 arc4rand(&pv->pv_id, sizeof(pv->pv_id), 0); 1419 pv->pv_generation = 0; 1420 pv->pv_started = 1; 1421 vol = g_raid_create_volume(sc, volname, -1); 1422 vol->v_md_data = pv; 1423 vol->v_raid_level = level; 1424 vol->v_raid_level_qualifier = qual; 1425 vol->v_strip_size = strip; 1426 vol->v_disks_count = numdisks; 1427 if (level == G_RAID_VOLUME_RL_RAID0 || 1428 level == G_RAID_VOLUME_RL_CONCAT || 1429 level == G_RAID_VOLUME_RL_SINGLE) 1430 vol->v_mediasize = size * numdisks; 1431 else if (level == G_RAID_VOLUME_RL_RAID1) 1432 vol->v_mediasize = size; 1433 else if (level == G_RAID_VOLUME_RL_RAID3 || 1434 level == G_RAID_VOLUME_RL_RAID5) 1435 vol->v_mediasize = size * (numdisks - 1); 1436 else { /* RAID1E */ 1437 vol->v_mediasize = ((size * numdisks) / strip / 2) * 1438 strip; 1439 } 1440 vol->v_sectorsize = sectorsize; 1441 g_raid_start_volume(vol); 1442 1443 /* , and subdisks. */ 1444 for (i = 0; i < numdisks; i++) { 1445 disk = disks[i]; 1446 sd = &vol->v_subdisks[i]; 1447 sd->sd_disk = disk; 1448 sd->sd_offset = (off_t)offs[i] * 512; 1449 sd->sd_size = size; 1450 if (disk == NULL) 1451 continue; 1452 TAILQ_INSERT_TAIL(&disk->d_subdisks, sd, sd_next); 1453 g_raid_change_disk_state(disk, 1454 G_RAID_DISK_S_ACTIVE); 1455 g_raid_change_subdisk_state(sd, 1456 G_RAID_SUBDISK_S_ACTIVE); 1457 g_raid_event_send(sd, G_RAID_SUBDISK_E_NEW, 1458 G_RAID_EVENT_SUBDISK); 1459 } 1460 1461 /* Write metadata based on created entities. */ 1462 G_RAID_DEBUG1(0, sc, "Array started."); 1463 g_raid_md_write_promise(md, vol, NULL, NULL); 1464 1465 /* Pickup any STALE/SPARE disks to refill array if needed. */ 1466 g_raid_md_promise_refill(sc); 1467 1468 g_raid_event_send(vol, G_RAID_VOLUME_E_START, 1469 G_RAID_EVENT_VOLUME); 1470 return (0); 1471 } 1472 if (strcmp(verb, "add") == 0) { 1473 1474 gctl_error(req, "`add` command is not applicable, " 1475 "use `label` instead."); 1476 return (-99); 1477 } 1478 if (strcmp(verb, "delete") == 0) { 1479 1480 /* Full node destruction. */ 1481 if (*nargs == 1) { 1482 /* Check if some volume is still open. */ 1483 force = gctl_get_paraml(req, "force", sizeof(*force)); 1484 if (force != NULL && *force == 0 && 1485 g_raid_nopens(sc) != 0) { 1486 gctl_error(req, "Some volume is still open."); 1487 return (-4); 1488 } 1489 1490 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1491 if (disk->d_consumer) 1492 promise_meta_erase(disk->d_consumer); 1493 } 1494 g_raid_destroy_node(sc, 0); 1495 return (0); 1496 } 1497 1498 /* Destroy specified volume. If it was last - all node. */ 1499 if (*nargs != 2) { 1500 gctl_error(req, "Invalid number of arguments."); 1501 return (-1); 1502 } 1503 volname = gctl_get_asciiparam(req, "arg1"); 1504 if (volname == NULL) { 1505 gctl_error(req, "No volume name."); 1506 return (-2); 1507 } 1508 1509 /* Search for volume. */ 1510 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 1511 if (strcmp(vol->v_name, volname) == 0) 1512 break; 1513 } 1514 if (vol == NULL) { 1515 i = strtol(volname, &tmp, 10); 1516 if (verb != volname && tmp[0] == 0) { 1517 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 1518 if (vol->v_global_id == i) 1519 break; 1520 } 1521 } 1522 } 1523 if (vol == NULL) { 1524 gctl_error(req, "Volume '%s' not found.", volname); 1525 return (-3); 1526 } 1527 1528 /* Check if volume is still open. */ 1529 force = gctl_get_paraml(req, "force", sizeof(*force)); 1530 if (force != NULL && *force == 0 && 1531 vol->v_provider_open != 0) { 1532 gctl_error(req, "Volume is still open."); 1533 return (-4); 1534 } 1535 1536 /* Destroy volume and potentially node. */ 1537 i = 0; 1538 TAILQ_FOREACH(vol1, &sc->sc_volumes, v_next) 1539 i++; 1540 if (i >= 2) { 1541 g_raid_destroy_volume(vol); 1542 g_raid_md_promise_purge_disks(sc); 1543 g_raid_md_write_promise(md, NULL, NULL, NULL); 1544 } else { 1545 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1546 if (disk->d_consumer) 1547 promise_meta_erase(disk->d_consumer); 1548 } 1549 g_raid_destroy_node(sc, 0); 1550 } 1551 return (0); 1552 } 1553 if (strcmp(verb, "remove") == 0 || 1554 strcmp(verb, "fail") == 0) { 1555 if (*nargs < 2) { 1556 gctl_error(req, "Invalid number of arguments."); 1557 return (-1); 1558 } 1559 for (i = 1; i < *nargs; i++) { 1560 snprintf(arg, sizeof(arg), "arg%d", i); 1561 diskname = gctl_get_asciiparam(req, arg); 1562 if (diskname == NULL) { 1563 gctl_error(req, "No disk name (%s).", arg); 1564 error = -2; 1565 break; 1566 } 1567 if (strncmp(diskname, "/dev/", 5) == 0) 1568 diskname += 5; 1569 1570 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1571 if (disk->d_consumer != NULL && 1572 disk->d_consumer->provider != NULL && 1573 strcmp(disk->d_consumer->provider->name, 1574 diskname) == 0) 1575 break; 1576 } 1577 if (disk == NULL) { 1578 gctl_error(req, "Disk '%s' not found.", 1579 diskname); 1580 error = -3; 1581 break; 1582 } 1583 1584 if (strcmp(verb, "fail") == 0) { 1585 g_raid_md_fail_disk_promise(md, NULL, disk); 1586 continue; 1587 } 1588 1589 /* Erase metadata on deleting disk and destroy it. */ 1590 promise_meta_erase(disk->d_consumer); 1591 g_raid_destroy_disk(disk); 1592 } 1593 g_raid_md_promise_purge_volumes(sc); 1594 1595 /* Write updated metadata to remaining disks. */ 1596 g_raid_md_write_promise(md, NULL, NULL, NULL); 1597 1598 /* Check if anything left. */ 1599 if (g_raid_ndisks(sc, -1) == 0) 1600 g_raid_destroy_node(sc, 0); 1601 else 1602 g_raid_md_promise_refill(sc); 1603 return (error); 1604 } 1605 if (strcmp(verb, "insert") == 0) { 1606 if (*nargs < 2) { 1607 gctl_error(req, "Invalid number of arguments."); 1608 return (-1); 1609 } 1610 for (i = 1; i < *nargs; i++) { 1611 /* Get disk name. */ 1612 snprintf(arg, sizeof(arg), "arg%d", i); 1613 diskname = gctl_get_asciiparam(req, arg); 1614 if (diskname == NULL) { 1615 gctl_error(req, "No disk name (%s).", arg); 1616 error = -3; 1617 break; 1618 } 1619 1620 /* Try to find provider with specified name. */ 1621 g_topology_lock(); 1622 cp = g_raid_open_consumer(sc, diskname); 1623 if (cp == NULL) { 1624 gctl_error(req, "Can't open disk '%s'.", 1625 diskname); 1626 g_topology_unlock(); 1627 error = -4; 1628 break; 1629 } 1630 pp = cp->provider; 1631 g_topology_unlock(); 1632 1633 if (pp->mediasize / pp->sectorsize > UINT32_MAX) { 1634 gctl_error(req, 1635 "Disk '%s' is too big.", diskname); 1636 g_raid_kill_consumer(sc, cp); 1637 error = -8; 1638 break; 1639 } 1640 1641 pd = malloc(sizeof(*pd), M_MD_PROMISE, M_WAITOK | M_ZERO); 1642 1643 disk = g_raid_create_disk(sc); 1644 disk->d_consumer = cp; 1645 disk->d_md_data = (void *)pd; 1646 cp->private = disk; 1647 1648 /* Read kernel dumping information. */ 1649 disk->d_kd.offset = 0; 1650 disk->d_kd.length = OFF_MAX; 1651 len = sizeof(disk->d_kd); 1652 g_io_getattr("GEOM::kerneldump", cp, &len, &disk->d_kd); 1653 if (disk->d_kd.di.dumper == NULL) 1654 G_RAID_DEBUG1(2, sc, 1655 "Dumping not supported by %s.", 1656 cp->provider->name); 1657 1658 /* Welcome the "new" disk. */ 1659 g_raid_change_disk_state(disk, G_RAID_DISK_S_SPARE); 1660 promise_meta_write_spare(cp); 1661 g_raid_md_promise_refill(sc); 1662 } 1663 return (error); 1664 } 1665 return (-100); 1666} 1667 1668static int 1669g_raid_md_write_promise(struct g_raid_md_object *md, struct g_raid_volume *tvol, 1670 struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk) 1671{ 1672 struct g_raid_softc *sc; 1673 struct g_raid_volume *vol; 1674 struct g_raid_subdisk *sd; 1675 struct g_raid_disk *disk; 1676 struct g_raid_md_promise_perdisk *pd; 1677 struct g_raid_md_promise_pervolume *pv; 1678 struct promise_raid_conf *meta; 1679 off_t rebuild_lba64; 1680 int i, j, pos, rebuild; 1681 1682 sc = md->mdo_softc; 1683 1684 if (sc->sc_stopping == G_RAID_DESTROY_HARD) 1685 return (0); 1686 1687 /* Generate new per-volume metadata for affected volumes. */ 1688 TAILQ_FOREACH(vol, &sc->sc_volumes, v_next) { 1689 if (vol->v_stopping) 1690 continue; 1691 1692 /* Skip volumes not related to specified targets. */ 1693 if (tvol != NULL && vol != tvol) 1694 continue; 1695 if (tsd != NULL && vol != tsd->sd_volume) 1696 continue; 1697 if (tdisk != NULL) { 1698 for (i = 0; i < vol->v_disks_count; i++) { 1699 if (vol->v_subdisks[i].sd_disk == tdisk) 1700 break; 1701 } 1702 if (i >= vol->v_disks_count) 1703 continue; 1704 } 1705 1706 pv = (struct g_raid_md_promise_pervolume *)vol->v_md_data; 1707 pv->pv_generation++; 1708 1709 meta = malloc(sizeof(*meta), M_MD_PROMISE, M_WAITOK | M_ZERO); 1710 if (pv->pv_meta != NULL) 1711 memcpy(meta, pv->pv_meta, sizeof(*meta)); 1712 memcpy(meta->promise_id, PROMISE_MAGIC, 1713 sizeof(PROMISE_MAGIC) - 1); 1714 meta->dummy_0 = 0x00020000; 1715 meta->integrity = PROMISE_I_VALID; 1716 1717 meta->generation = pv->pv_generation; 1718 meta->status = PROMISE_S_VALID | PROMISE_S_ONLINE | 1719 PROMISE_S_INITED | PROMISE_S_READY; 1720 if (vol->v_state <= G_RAID_VOLUME_S_DEGRADED) 1721 meta->status |= PROMISE_S_DEGRADED; 1722 if (vol->v_dirty) 1723 meta->status |= PROMISE_S_MARKED; /* XXX: INVENTED! */ 1724 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID0 || 1725 vol->v_raid_level == G_RAID_VOLUME_RL_SINGLE) 1726 meta->type = PROMISE_T_RAID0; 1727 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 || 1728 vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) 1729 meta->type = PROMISE_T_RAID1; 1730 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID3) 1731 meta->type = PROMISE_T_RAID3; 1732 else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID5) 1733 meta->type = PROMISE_T_RAID5; 1734 else if (vol->v_raid_level == G_RAID_VOLUME_RL_CONCAT) 1735 meta->type = PROMISE_T_SPAN; 1736 else 1737 meta->type = PROMISE_T_JBOD; 1738 meta->total_disks = vol->v_disks_count; 1739 meta->stripe_shift = ffs(vol->v_strip_size / 1024); 1740 meta->array_width = vol->v_disks_count; 1741 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 || 1742 vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) 1743 meta->array_width /= 2; 1744 meta->array_number = vol->v_global_id; 1745 meta->total_sectors = vol->v_mediasize / vol->v_sectorsize; 1746 meta->total_sectors_high = 1747 (vol->v_mediasize / vol->v_sectorsize) >> 32; 1748 meta->cylinders = meta->total_sectors / (255 * 63) - 1; 1749 meta->heads = 254; 1750 meta->sectors = 63; 1751 meta->volume_id = pv->pv_id; 1752 rebuild_lba64 = UINT64_MAX; 1753 rebuild = 0; 1754 for (i = 0; i < vol->v_disks_count; i++) { 1755 sd = &vol->v_subdisks[i]; 1756 /* For RAID0+1 we need to translate order. */ 1757 pos = promise_meta_translate_disk(vol, i); 1758 meta->disks[pos].flags = PROMISE_F_VALID | 1759 PROMISE_F_ASSIGNED; 1760 if (sd->sd_state == G_RAID_SUBDISK_S_NONE) { 1761 meta->disks[pos].flags |= 0; 1762 } else if (sd->sd_state == G_RAID_SUBDISK_S_FAILED) { 1763 meta->disks[pos].flags |= 1764 PROMISE_F_DOWN | PROMISE_F_REDIR; 1765 } else if (sd->sd_state <= G_RAID_SUBDISK_S_REBUILD) { 1766 meta->disks[pos].flags |= 1767 PROMISE_F_ONLINE | PROMISE_F_REDIR; 1768 if (sd->sd_state == G_RAID_SUBDISK_S_REBUILD) { 1769 rebuild_lba64 = MIN(rebuild_lba64, 1770 sd->sd_rebuild_pos / 512); 1771 } else 1772 rebuild_lba64 = 0; 1773 rebuild = 1; 1774 } else { 1775 meta->disks[pos].flags |= PROMISE_F_ONLINE; 1776 if (sd->sd_state < G_RAID_SUBDISK_S_ACTIVE) { 1777 meta->status |= PROMISE_S_MARKED; 1778 if (sd->sd_state == G_RAID_SUBDISK_S_RESYNC) { 1779 rebuild_lba64 = MIN(rebuild_lba64, 1780 sd->sd_rebuild_pos / 512); 1781 } else 1782 rebuild_lba64 = 0; 1783 } 1784 } 1785 if (pv->pv_meta != NULL) { 1786 meta->disks[pos].id = pv->pv_meta->disks[pos].id; 1787 } else { 1788 meta->disks[pos].number = i * 2; 1789 arc4rand(&meta->disks[pos].id, 1790 sizeof(meta->disks[pos].id), 0); 1791 } 1792 } 1793 promise_meta_put_name(meta, vol->v_name); 1794 1795 /* Try to mimic AMD BIOS rebuild/resync behavior. */ 1796 if (rebuild_lba64 != UINT64_MAX) { 1797 if (rebuild) 1798 meta->magic_3 = 0x03040010UL; /* Rebuild? */ 1799 else 1800 meta->magic_3 = 0x03040008UL; /* Resync? */ 1801 /* Translate from per-disk to per-volume LBA. */ 1802 if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID1 || 1803 vol->v_raid_level == G_RAID_VOLUME_RL_RAID1E) { 1804 rebuild_lba64 *= meta->array_width; 1805 } else if (vol->v_raid_level == G_RAID_VOLUME_RL_RAID3 || 1806 vol->v_raid_level == G_RAID_VOLUME_RL_RAID5) { 1807 rebuild_lba64 *= meta->array_width - 1; 1808 } else 1809 rebuild_lba64 = 0; 1810 } else 1811 meta->magic_3 = 0x03000000UL; 1812 meta->rebuild_lba64 = rebuild_lba64; 1813 meta->magic_4 = 0x04010101UL; 1814 1815 /* Replace per-volume metadata with new. */ 1816 if (pv->pv_meta != NULL) 1817 free(pv->pv_meta, M_MD_PROMISE); 1818 pv->pv_meta = meta; 1819 1820 /* Copy new metadata to the disks, adding or replacing old. */ 1821 for (i = 0; i < vol->v_disks_count; i++) { 1822 sd = &vol->v_subdisks[i]; 1823 disk = sd->sd_disk; 1824 if (disk == NULL) 1825 continue; 1826 /* For RAID0+1 we need to translate order. */ 1827 pos = promise_meta_translate_disk(vol, i); 1828 pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 1829 for (j = 0; j < pd->pd_subdisks; j++) { 1830 if (pd->pd_meta[j]->volume_id == meta->volume_id) 1831 break; 1832 } 1833 if (j == pd->pd_subdisks) 1834 pd->pd_subdisks++; 1835 if (pd->pd_meta[j] != NULL) 1836 free(pd->pd_meta[j], M_MD_PROMISE); 1837 pd->pd_meta[j] = promise_meta_copy(meta); 1838 pd->pd_meta[j]->disk = meta->disks[pos]; 1839 pd->pd_meta[j]->disk.number = pos; 1840 pd->pd_meta[j]->disk_offset = sd->sd_offset / 512; 1841 pd->pd_meta[j]->disk_sectors = sd->sd_size / 512; 1842 if (sd->sd_state == G_RAID_SUBDISK_S_REBUILD) { 1843 pd->pd_meta[j]->rebuild_lba = 1844 sd->sd_rebuild_pos / 512; 1845 } else if (sd->sd_state < G_RAID_SUBDISK_S_REBUILD) 1846 pd->pd_meta[j]->rebuild_lba = 0; 1847 else 1848 pd->pd_meta[j]->rebuild_lba = UINT32_MAX; 1849 pd->pd_updated = 1; 1850 } 1851 } 1852 1853 TAILQ_FOREACH(disk, &sc->sc_disks, d_next) { 1854 pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 1855 if (disk->d_state != G_RAID_DISK_S_ACTIVE) 1856 continue; 1857 if (!pd->pd_updated) 1858 continue; 1859 G_RAID_DEBUG(1, "Writing Promise metadata to %s", 1860 g_raid_get_diskname(disk)); 1861 for (i = 0; i < pd->pd_subdisks; i++) 1862 g_raid_md_promise_print(pd->pd_meta[i]); 1863 promise_meta_write(disk->d_consumer, 1864 pd->pd_meta, pd->pd_subdisks); 1865 pd->pd_updated = 0; 1866 } 1867 1868 return (0); 1869} 1870 1871static int 1872g_raid_md_fail_disk_promise(struct g_raid_md_object *md, 1873 struct g_raid_subdisk *tsd, struct g_raid_disk *tdisk) 1874{ 1875 struct g_raid_softc *sc; 1876 struct g_raid_md_promise_perdisk *pd; 1877 struct g_raid_subdisk *sd; 1878 int i, pos; 1879 1880 sc = md->mdo_softc; 1881 pd = (struct g_raid_md_promise_perdisk *)tdisk->d_md_data; 1882 1883 /* We can't fail disk that is not a part of array now. */ 1884 if (tdisk->d_state != G_RAID_DISK_S_ACTIVE) 1885 return (-1); 1886 1887 /* 1888 * Mark disk as failed in metadata and try to write that metadata 1889 * to the disk itself to prevent it's later resurrection as STALE. 1890 */ 1891 if (pd->pd_subdisks > 0 && tdisk->d_consumer != NULL) 1892 G_RAID_DEBUG(1, "Writing Promise metadata to %s", 1893 g_raid_get_diskname(tdisk)); 1894 for (i = 0; i < pd->pd_subdisks; i++) { 1895 pd->pd_meta[i]->disk.flags |= 1896 PROMISE_F_DOWN | PROMISE_F_REDIR; 1897 pos = pd->pd_meta[i]->disk.number; 1898 if (pos >= 0 && pos < PROMISE_MAX_DISKS) { 1899 pd->pd_meta[i]->disks[pos].flags |= 1900 PROMISE_F_DOWN | PROMISE_F_REDIR; 1901 } 1902 g_raid_md_promise_print(pd->pd_meta[i]); 1903 } 1904 if (tdisk->d_consumer != NULL) 1905 promise_meta_write(tdisk->d_consumer, 1906 pd->pd_meta, pd->pd_subdisks); 1907 1908 /* Change states. */ 1909 g_raid_change_disk_state(tdisk, G_RAID_DISK_S_FAILED); 1910 TAILQ_FOREACH(sd, &tdisk->d_subdisks, sd_next) { 1911 g_raid_change_subdisk_state(sd, 1912 G_RAID_SUBDISK_S_FAILED); 1913 g_raid_event_send(sd, G_RAID_SUBDISK_E_FAILED, 1914 G_RAID_EVENT_SUBDISK); 1915 } 1916 1917 /* Write updated metadata to remaining disks. */ 1918 g_raid_md_write_promise(md, NULL, NULL, tdisk); 1919 1920 g_raid_md_promise_refill(sc); 1921 return (0); 1922} 1923 1924static int 1925g_raid_md_free_disk_promise(struct g_raid_md_object *md, 1926 struct g_raid_disk *disk) 1927{ 1928 struct g_raid_md_promise_perdisk *pd; 1929 int i; 1930 1931 pd = (struct g_raid_md_promise_perdisk *)disk->d_md_data; 1932 for (i = 0; i < pd->pd_subdisks; i++) { 1933 if (pd->pd_meta[i] != NULL) { 1934 free(pd->pd_meta[i], M_MD_PROMISE); 1935 pd->pd_meta[i] = NULL; 1936 } 1937 } 1938 free(pd, M_MD_PROMISE); 1939 disk->d_md_data = NULL; 1940 return (0); 1941} 1942 1943static int 1944g_raid_md_free_volume_promise(struct g_raid_md_object *md, 1945 struct g_raid_volume *vol) 1946{ 1947 struct g_raid_md_promise_pervolume *pv; 1948 1949 pv = (struct g_raid_md_promise_pervolume *)vol->v_md_data; 1950 if (pv && pv->pv_meta != NULL) { 1951 free(pv->pv_meta, M_MD_PROMISE); 1952 pv->pv_meta = NULL; 1953 } 1954 if (pv && !pv->pv_started) { 1955 pv->pv_started = 1; 1956 callout_stop(&pv->pv_start_co); 1957 } 1958 return (0); 1959} 1960 1961static int 1962g_raid_md_free_promise(struct g_raid_md_object *md) 1963{ 1964 1965 return (0); 1966} 1967 1968G_RAID_MD_DECLARE(g_raid_md_promise); 1969