1 /* $OpenBSD: softraid.c,v 1.291 2013/03/25 16:01:48 jsing Exp $ */ 2 /* 3 * Copyright (c) 2007, 2008, 2009 Marco Peereboom <marco@peereboom.us> 4 * Copyright (c) 2008 Chris Kuethe <ckuethe@openbsd.org> 5 * Copyright (c) 2009 Joel Sing <jsing@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include "bio.h" 21 22 #include <sys/param.h> 23 #include <sys/systm.h> 24 #include <sys/buf.h> 25 #include <sys/device.h> 26 #include <sys/ioctl.h> 27 #include <sys/proc.h> 28 #include <sys/malloc.h> 29 #include <sys/pool.h> 30 #include <sys/kernel.h> 31 #include <sys/disk.h> 32 #include <sys/rwlock.h> 33 #include <sys/queue.h> 34 #include <sys/fcntl.h> 35 #include <sys/disklabel.h> 36 #include <sys/mount.h> 37 #include <sys/sensors.h> 38 #include <sys/stat.h> 39 #include <sys/conf.h> 40 #include <sys/uio.h> 41 #include <sys/workq.h> 42 #include <sys/kthread.h> 43 #include <sys/dkio.h> 44 45 #ifdef AOE 46 #include <sys/mbuf.h> 47 #include <net/if_aoe.h> 48 #endif /* AOE */ 49 50 #include <crypto/cryptodev.h> 51 52 #include <scsi/scsi_all.h> 53 #include <scsi/scsiconf.h> 54 #include <scsi/scsi_disk.h> 55 56 #include <dev/softraidvar.h> 57 #include <dev/rndvar.h> 58 59 /* #define SR_FANCY_STATS */ 60 61 #ifdef SR_DEBUG 62 #define SR_FANCY_STATS 63 uint32_t sr_debug = 0 64 /* | SR_D_CMD */ 65 /* | SR_D_MISC */ 66 /* | SR_D_INTR */ 67 /* | SR_D_IOCTL */ 68 /* | SR_D_CCB */ 69 /* | SR_D_WU */ 70 /* | SR_D_META */ 71 /* | SR_D_DIS */ 72 /* | SR_D_STATE */ 73 ; 74 #endif 75 76 struct sr_softc *softraid0; 77 struct sr_uuid sr_bootuuid; 78 u_int8_t sr_bootkey[SR_CRYPTO_MAXKEYBYTES]; 79 80 int sr_match(struct device *, void *, void *); 81 void sr_attach(struct device *, struct device *, void *); 82 int sr_detach(struct device *, int); 83 void sr_map_root(void); 84 85 struct cfattach softraid_ca = { 86 sizeof(struct sr_softc), sr_match, sr_attach, sr_detach, 87 }; 88 89 struct cfdriver softraid_cd = { 90 NULL, "softraid", DV_DULL 91 }; 92 93 /* scsi & discipline */ 94 void sr_scsi_cmd(struct scsi_xfer *); 95 void sr_minphys(struct buf *, struct scsi_link *); 96 int sr_scsi_probe(struct scsi_link *); 97 void sr_copy_internal_data(struct scsi_xfer *, 98 void *, size_t); 99 int sr_scsi_ioctl(struct scsi_link *, u_long, 100 caddr_t, int); 101 int sr_bio_ioctl(struct device *, u_long, caddr_t); 102 int sr_ioctl_inq(struct sr_softc *, struct bioc_inq *); 103 int sr_ioctl_vol(struct sr_softc *, struct bioc_vol *); 104 int sr_ioctl_disk(struct sr_softc *, struct bioc_disk *); 105 int sr_ioctl_setstate(struct sr_softc *, 106 struct bioc_setstate *); 107 int sr_ioctl_createraid(struct sr_softc *, 108 struct bioc_createraid *, int, void *); 109 int sr_ioctl_deleteraid(struct sr_softc *, 110 struct bioc_deleteraid *); 111 int sr_ioctl_discipline(struct sr_softc *, 112 struct bioc_discipline *); 113 int sr_ioctl_installboot(struct sr_softc *, 114 struct bioc_installboot *); 115 void sr_chunks_unwind(struct sr_softc *, 116 struct sr_chunk_head *); 117 void sr_discipline_free(struct sr_discipline *); 118 void sr_discipline_shutdown(struct sr_discipline *, int); 119 int sr_discipline_init(struct sr_discipline *, int); 120 void sr_set_chunk_state(struct sr_discipline *, int, int); 121 void sr_set_vol_state(struct sr_discipline *); 122 123 /* utility functions */ 124 void sr_shutdown(struct sr_softc *); 125 void sr_shutdownhook(void *); 126 void sr_uuid_generate(struct sr_uuid *); 127 char *sr_uuid_format(struct sr_uuid *); 128 void sr_uuid_print(struct sr_uuid *, int); 129 void sr_checksum_print(u_int8_t *); 130 int sr_boot_assembly(struct sr_softc *); 131 int sr_already_assembled(struct sr_discipline *); 132 int sr_hotspare(struct sr_softc *, dev_t); 133 void sr_hotspare_rebuild(struct sr_discipline *); 134 int sr_rebuild_init(struct sr_discipline *, dev_t, int); 135 void sr_rebuild(void *); 136 void sr_rebuild_thread(void *); 137 void sr_roam_chunks(struct sr_discipline *); 138 int sr_chunk_in_use(struct sr_softc *, dev_t); 139 void sr_startwu_callback(void *, void *); 140 int sr_rw(struct sr_softc *, dev_t, char *, size_t, 141 daddr64_t, long); 142 void sr_wu_done_callback(void *, void *); 143 144 /* don't include these on RAMDISK */ 145 #ifndef SMALL_KERNEL 146 void sr_sensors_refresh(void *); 147 int sr_sensors_create(struct sr_discipline *); 148 void sr_sensors_delete(struct sr_discipline *); 149 #endif 150 151 /* metadata */ 152 int sr_meta_probe(struct sr_discipline *, dev_t *, int); 153 int sr_meta_attach(struct sr_discipline *, int, int); 154 int sr_meta_rw(struct sr_discipline *, dev_t, void *, 155 size_t, daddr64_t, long); 156 int sr_meta_clear(struct sr_discipline *); 157 void sr_meta_init(struct sr_discipline *, int, int); 158 void sr_meta_init_complete(struct sr_discipline *); 159 void sr_meta_opt_handler(struct sr_discipline *, 160 struct sr_meta_opt_hdr *); 161 162 /* hotplug magic */ 163 void sr_disk_attach(struct disk *, int); 164 165 struct sr_hotplug_list { 166 void (*sh_hotplug)(struct sr_discipline *, 167 struct disk *, int); 168 struct sr_discipline *sh_sd; 169 170 SLIST_ENTRY(sr_hotplug_list) shl_link; 171 }; 172 SLIST_HEAD(sr_hotplug_list_head, sr_hotplug_list); 173 174 struct sr_hotplug_list_head sr_hotplug_callbacks; 175 extern void (*softraid_disk_attach)(struct disk *, int); 176 177 /* scsi glue */ 178 struct scsi_adapter sr_switch = { 179 sr_scsi_cmd, sr_minphys, sr_scsi_probe, NULL, sr_scsi_ioctl 180 }; 181 182 /* native metadata format */ 183 int sr_meta_native_bootprobe(struct sr_softc *, dev_t, 184 struct sr_boot_chunk_head *); 185 #define SR_META_NOTCLAIMED (0) 186 #define SR_META_CLAIMED (1) 187 int sr_meta_native_probe(struct sr_softc *, 188 struct sr_chunk *); 189 int sr_meta_native_attach(struct sr_discipline *, int); 190 int sr_meta_native_write(struct sr_discipline *, dev_t, 191 struct sr_metadata *,void *); 192 193 #ifdef SR_DEBUG 194 void sr_meta_print(struct sr_metadata *); 195 #else 196 #define sr_meta_print(m) 197 #endif 198 199 /* the metadata driver should remain stateless */ 200 struct sr_meta_driver { 201 daddr64_t smd_offset; /* metadata location */ 202 u_int32_t smd_size; /* size of metadata */ 203 204 int (*smd_probe)(struct sr_softc *, 205 struct sr_chunk *); 206 int (*smd_attach)(struct sr_discipline *, int); 207 int (*smd_detach)(struct sr_discipline *); 208 int (*smd_read)(struct sr_discipline *, dev_t, 209 struct sr_metadata *, void *); 210 int (*smd_write)(struct sr_discipline *, dev_t, 211 struct sr_metadata *, void *); 212 int (*smd_validate)(struct sr_discipline *, 213 struct sr_metadata *, void *); 214 } smd[] = { 215 { SR_META_OFFSET, SR_META_SIZE * 512, 216 sr_meta_native_probe, sr_meta_native_attach, NULL, 217 sr_meta_native_read, sr_meta_native_write, NULL }, 218 { 0, 0, NULL, NULL, NULL, NULL } 219 }; 220 221 int 222 sr_meta_attach(struct sr_discipline *sd, int chunk_no, int force) 223 { 224 struct sr_softc *sc = sd->sd_sc; 225 struct sr_chunk_head *cl; 226 struct sr_chunk *ch_entry, *chunk1, *chunk2; 227 int rv = 1, i = 0; 228 229 DNPRINTF(SR_D_META, "%s: sr_meta_attach(%d)\n", DEVNAME(sc)); 230 231 /* in memory copy of metadata */ 232 sd->sd_meta = malloc(SR_META_SIZE * 512, M_DEVBUF, M_ZERO | M_NOWAIT); 233 if (!sd->sd_meta) { 234 sr_error(sc, "could not allocate memory for metadata"); 235 goto bad; 236 } 237 238 if (sd->sd_meta_type != SR_META_F_NATIVE) { 239 /* in memory copy of foreign metadata */ 240 sd->sd_meta_foreign = malloc(smd[sd->sd_meta_type].smd_size, 241 M_DEVBUF, M_ZERO | M_NOWAIT); 242 if (!sd->sd_meta_foreign) { 243 /* unwind frees sd_meta */ 244 sr_error(sc, "could not allocate memory for foreign " 245 "metadata"); 246 goto bad; 247 } 248 } 249 250 /* we have a valid list now create an array index */ 251 cl = &sd->sd_vol.sv_chunk_list; 252 sd->sd_vol.sv_chunks = malloc(sizeof(struct sr_chunk *) * chunk_no, 253 M_DEVBUF, M_WAITOK | M_ZERO); 254 255 /* fill out chunk array */ 256 i = 0; 257 SLIST_FOREACH(ch_entry, cl, src_link) 258 sd->sd_vol.sv_chunks[i++] = ch_entry; 259 260 /* attach metadata */ 261 if (smd[sd->sd_meta_type].smd_attach(sd, force)) 262 goto bad; 263 264 /* Force chunks into correct order now that metadata is attached. */ 265 SLIST_FOREACH(ch_entry, cl, src_link) 266 SLIST_REMOVE(cl, ch_entry, sr_chunk, src_link); 267 for (i = 0; i < chunk_no; i++) { 268 ch_entry = sd->sd_vol.sv_chunks[i]; 269 chunk2 = NULL; 270 SLIST_FOREACH(chunk1, cl, src_link) { 271 if (chunk1->src_meta.scmi.scm_chunk_id > 272 ch_entry->src_meta.scmi.scm_chunk_id) 273 break; 274 chunk2 = chunk1; 275 } 276 if (chunk2 == NULL) 277 SLIST_INSERT_HEAD(cl, ch_entry, src_link); 278 else 279 SLIST_INSERT_AFTER(chunk2, ch_entry, src_link); 280 } 281 i = 0; 282 SLIST_FOREACH(ch_entry, cl, src_link) 283 sd->sd_vol.sv_chunks[i++] = ch_entry; 284 285 rv = 0; 286 bad: 287 return (rv); 288 } 289 290 int 291 sr_meta_probe(struct sr_discipline *sd, dev_t *dt, int no_chunk) 292 { 293 struct sr_softc *sc = sd->sd_sc; 294 struct vnode *vn; 295 struct sr_chunk *ch_entry, *ch_prev = NULL; 296 struct sr_chunk_head *cl; 297 char devname[32]; 298 int i, d, type, found, prevf, error; 299 dev_t dev; 300 301 DNPRINTF(SR_D_META, "%s: sr_meta_probe(%d)\n", DEVNAME(sc), no_chunk); 302 303 if (no_chunk == 0) 304 goto unwind; 305 306 cl = &sd->sd_vol.sv_chunk_list; 307 308 for (d = 0, prevf = SR_META_F_INVALID; d < no_chunk; d++) { 309 ch_entry = malloc(sizeof(struct sr_chunk), M_DEVBUF, 310 M_WAITOK | M_ZERO); 311 /* keep disks in user supplied order */ 312 if (ch_prev) 313 SLIST_INSERT_AFTER(ch_prev, ch_entry, src_link); 314 else 315 SLIST_INSERT_HEAD(cl, ch_entry, src_link); 316 ch_prev = ch_entry; 317 dev = dt[d]; 318 ch_entry->src_dev_mm = dev; 319 320 if (dev == NODEV) { 321 ch_entry->src_meta.scm_status = BIOC_SDOFFLINE; 322 continue; 323 } else { 324 sr_meta_getdevname(sc, dev, devname, sizeof(devname)); 325 if (bdevvp(dev, &vn)) { 326 sr_error(sc, "sr_meta_probe: cannot allocate " 327 "vnode"); 328 goto unwind; 329 } 330 331 /* 332 * XXX leaving dev open for now; move this to attach 333 * and figure out the open/close dance for unwind. 334 */ 335 error = VOP_OPEN(vn, FREAD | FWRITE, NOCRED, curproc); 336 if (error) { 337 DNPRINTF(SR_D_META,"%s: sr_meta_probe can't " 338 "open %s\n", DEVNAME(sc), devname); 339 vput(vn); 340 goto unwind; 341 } 342 343 strlcpy(ch_entry->src_devname, devname, 344 sizeof(ch_entry->src_devname)); 345 ch_entry->src_vn = vn; 346 } 347 348 /* determine if this is a device we understand */ 349 for (i = 0, found = SR_META_F_INVALID; smd[i].smd_probe; i++) { 350 type = smd[i].smd_probe(sc, ch_entry); 351 if (type == SR_META_F_INVALID) 352 continue; 353 else { 354 found = type; 355 break; 356 } 357 } 358 359 if (found == SR_META_F_INVALID) 360 goto unwind; 361 if (prevf == SR_META_F_INVALID) 362 prevf = found; 363 if (prevf != found) { 364 DNPRINTF(SR_D_META, "%s: prevf != found\n", 365 DEVNAME(sc)); 366 goto unwind; 367 } 368 } 369 370 return (prevf); 371 unwind: 372 return (SR_META_F_INVALID); 373 } 374 375 void 376 sr_meta_getdevname(struct sr_softc *sc, dev_t dev, char *buf, int size) 377 { 378 int maj, unit, part; 379 char *name; 380 381 DNPRINTF(SR_D_META, "%s: sr_meta_getdevname(%p, %d)\n", 382 DEVNAME(sc), buf, size); 383 384 if (!buf) 385 return; 386 387 maj = major(dev); 388 part = DISKPART(dev); 389 unit = DISKUNIT(dev); 390 391 name = findblkname(maj); 392 if (name == NULL) 393 return; 394 395 snprintf(buf, size, "%s%d%c", name, unit, part + 'a'); 396 } 397 398 int 399 sr_rw(struct sr_softc *sc, dev_t dev, char *buf, size_t size, daddr64_t offset, 400 long flags) 401 { 402 struct vnode *vp; 403 struct buf b; 404 size_t bufsize, dma_bufsize; 405 int rv = 1; 406 char *dma_buf; 407 408 DNPRINTF(SR_D_MISC, "%s: sr_rw(0x%x, %p, %d, %llu 0x%x)\n", 409 DEVNAME(sc), dev, buf, size, offset, flags); 410 411 dma_bufsize = (size > MAXPHYS) ? MAXPHYS : size; 412 dma_buf = dma_alloc(dma_bufsize, PR_WAITOK); 413 414 if (bdevvp(dev, &vp)) { 415 printf("%s: sr_rw: failed to allocate vnode\n", DEVNAME(sc)); 416 goto done; 417 } 418 419 while (size > 0) { 420 DNPRINTF(SR_D_MISC, "%s: dma_buf %p, size %d, offset %llu)\n", 421 DEVNAME(sc), dma_buf, size, offset); 422 423 bufsize = (size > MAXPHYS) ? MAXPHYS : size; 424 if (flags == B_WRITE) 425 bcopy(buf, dma_buf, bufsize); 426 427 bzero(&b, sizeof(b)); 428 b.b_flags = flags | B_PHYS; 429 b.b_proc = curproc; 430 b.b_dev = dev; 431 b.b_iodone = NULL; 432 b.b_error = 0; 433 b.b_blkno = offset; 434 b.b_data = dma_buf; 435 b.b_bcount = bufsize; 436 b.b_bufsize = bufsize; 437 b.b_resid = bufsize; 438 b.b_vp = vp; 439 440 if ((b.b_flags & B_READ) == 0) 441 vp->v_numoutput++; 442 443 LIST_INIT(&b.b_dep); 444 VOP_STRATEGY(&b); 445 biowait(&b); 446 447 if (b.b_flags & B_ERROR) { 448 printf("%s: I/O error %d on dev 0x%x at block %llu\n", 449 DEVNAME(sc), b.b_error, dev, b.b_blkno); 450 goto done; 451 } 452 453 if (flags == B_READ) 454 bcopy(dma_buf, buf, bufsize); 455 456 size -= bufsize; 457 buf += bufsize; 458 offset += howmany(bufsize, DEV_BSIZE); 459 } 460 461 rv = 0; 462 463 done: 464 if (vp) 465 vput(vp); 466 467 dma_free(dma_buf, dma_bufsize); 468 469 return (rv); 470 } 471 472 int 473 sr_meta_rw(struct sr_discipline *sd, dev_t dev, void *md, size_t size, 474 daddr64_t offset, long flags) 475 { 476 int rv = 1; 477 478 DNPRINTF(SR_D_META, "%s: sr_meta_rw(0x%x, %p, %d, %llu 0x%x)\n", 479 DEVNAME(sd->sd_sc), dev, md, size, offset, flags); 480 481 if (md == NULL) { 482 printf("%s: sr_meta_rw: invalid metadata pointer\n", 483 DEVNAME(sd->sd_sc)); 484 goto done; 485 } 486 487 rv = sr_rw(sd->sd_sc, dev, md, size, offset, flags); 488 489 done: 490 return (rv); 491 } 492 493 int 494 sr_meta_clear(struct sr_discipline *sd) 495 { 496 struct sr_softc *sc = sd->sd_sc; 497 struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list; 498 struct sr_chunk *ch_entry; 499 void *m; 500 int rv = 1; 501 502 DNPRINTF(SR_D_META, "%s: sr_meta_clear\n", DEVNAME(sc)); 503 504 if (sd->sd_meta_type != SR_META_F_NATIVE) { 505 sr_error(sc, "cannot clear foreign metadata"); 506 goto done; 507 } 508 509 m = malloc(SR_META_SIZE * 512, M_DEVBUF, M_WAITOK | M_ZERO); 510 SLIST_FOREACH(ch_entry, cl, src_link) { 511 if (sr_meta_native_write(sd, ch_entry->src_dev_mm, m, NULL)) { 512 /* XXX mark disk offline */ 513 DNPRINTF(SR_D_META, "%s: sr_meta_clear failed to " 514 "clear %s\n", ch_entry->src_devname); 515 rv++; 516 continue; 517 } 518 bzero(&ch_entry->src_meta, sizeof(ch_entry->src_meta)); 519 } 520 521 bzero(sd->sd_meta, SR_META_SIZE * 512); 522 523 free(m, M_DEVBUF); 524 rv = 0; 525 done: 526 return (rv); 527 } 528 529 void 530 sr_meta_init(struct sr_discipline *sd, int level, int no_chunk) 531 { 532 struct sr_softc *sc = sd->sd_sc; 533 struct sr_metadata *sm = sd->sd_meta; 534 struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list; 535 struct sr_meta_chunk *scm; 536 struct sr_chunk *chunk; 537 int cid = 0; 538 u_int64_t max_chunk_sz = 0, min_chunk_sz = 0; 539 540 DNPRINTF(SR_D_META, "%s: sr_meta_init\n", DEVNAME(sc)); 541 542 if (!sm) 543 return; 544 545 /* Initialise volume metadata. */ 546 sm->ssdi.ssd_magic = SR_MAGIC; 547 sm->ssdi.ssd_version = SR_META_VERSION; 548 sm->ssdi.ssd_vol_flags = sd->sd_meta_flags; 549 sm->ssdi.ssd_volid = 0; 550 sm->ssdi.ssd_chunk_no = no_chunk; 551 sm->ssdi.ssd_level = level; 552 553 sm->ssd_data_offset = SR_DATA_OFFSET; 554 sm->ssd_ondisk = 0; 555 556 sr_uuid_generate(&sm->ssdi.ssd_uuid); 557 558 /* Initialise chunk metadata and get min/max chunk sizes. */ 559 SLIST_FOREACH(chunk, cl, src_link) { 560 scm = &chunk->src_meta; 561 scm->scmi.scm_size = chunk->src_size; 562 scm->scmi.scm_chunk_id = cid++; 563 scm->scm_status = BIOC_SDONLINE; 564 scm->scmi.scm_volid = 0; 565 strlcpy(scm->scmi.scm_devname, chunk->src_devname, 566 sizeof(scm->scmi.scm_devname)); 567 bcopy(&sm->ssdi.ssd_uuid, &scm->scmi.scm_uuid, 568 sizeof(scm->scmi.scm_uuid)); 569 sr_checksum(sc, scm, &scm->scm_checksum, 570 sizeof(scm->scm_checksum)); 571 572 if (min_chunk_sz == 0) 573 min_chunk_sz = scm->scmi.scm_size; 574 min_chunk_sz = MIN(min_chunk_sz, scm->scmi.scm_size); 575 max_chunk_sz = MAX(max_chunk_sz, scm->scmi.scm_size); 576 } 577 578 /* Equalize chunk sizes. */ 579 SLIST_FOREACH(chunk, cl, src_link) 580 chunk->src_meta.scmi.scm_coerced_size = min_chunk_sz; 581 582 sd->sd_vol.sv_chunk_minsz = min_chunk_sz; 583 sd->sd_vol.sv_chunk_maxsz = max_chunk_sz; 584 } 585 586 void 587 sr_meta_init_complete(struct sr_discipline *sd) 588 { 589 #ifdef SR_DEBUG 590 struct sr_softc *sc = sd->sd_sc; 591 #endif 592 struct sr_metadata *sm = sd->sd_meta; 593 594 DNPRINTF(SR_D_META, "%s: sr_meta_complete\n", DEVNAME(sc)); 595 596 /* Complete initialisation of volume metadata. */ 597 strlcpy(sm->ssdi.ssd_vendor, "OPENBSD", sizeof(sm->ssdi.ssd_vendor)); 598 snprintf(sm->ssdi.ssd_product, sizeof(sm->ssdi.ssd_product), 599 "SR %s", sd->sd_name); 600 snprintf(sm->ssdi.ssd_revision, sizeof(sm->ssdi.ssd_revision), 601 "%03d", sm->ssdi.ssd_version); 602 } 603 604 void 605 sr_meta_opt_handler(struct sr_discipline *sd, struct sr_meta_opt_hdr *om) 606 { 607 if (om->som_type != SR_OPT_BOOT) 608 panic("unknown optional metadata type"); 609 } 610 611 void 612 sr_meta_save_callback(void *arg1, void *arg2) 613 { 614 struct sr_discipline *sd = arg1; 615 int s; 616 617 s = splbio(); 618 619 if (sr_meta_save(arg1, SR_META_DIRTY)) 620 printf("%s: save metadata failed\n", DEVNAME(sd->sd_sc)); 621 622 sd->sd_must_flush = 0; 623 splx(s); 624 } 625 626 int 627 sr_meta_save(struct sr_discipline *sd, u_int32_t flags) 628 { 629 struct sr_softc *sc = sd->sd_sc; 630 struct sr_metadata *sm = sd->sd_meta, *m; 631 struct sr_meta_driver *s; 632 struct sr_chunk *src; 633 struct sr_meta_chunk *cm; 634 struct sr_workunit wu; 635 struct sr_meta_opt_hdr *omh; 636 struct sr_meta_opt_item *omi; 637 int i; 638 639 DNPRINTF(SR_D_META, "%s: sr_meta_save %s\n", 640 DEVNAME(sc), sd->sd_meta->ssd_devname); 641 642 if (!sm) { 643 printf("%s: no in memory copy of metadata\n", DEVNAME(sc)); 644 goto bad; 645 } 646 647 /* meta scratchpad */ 648 s = &smd[sd->sd_meta_type]; 649 m = malloc(SR_META_SIZE * 512, M_DEVBUF, M_ZERO | M_NOWAIT); 650 if (!m) { 651 printf("%s: could not allocate metadata scratch area\n", 652 DEVNAME(sc)); 653 goto bad; 654 } 655 656 /* from here on out metadata is updated */ 657 restart: 658 sm->ssd_ondisk++; 659 sm->ssd_meta_flags = flags; 660 bcopy(sm, m, sizeof(*m)); 661 662 /* Chunk metadata. */ 663 cm = (struct sr_meta_chunk *)(m + 1); 664 for (i = 0; i < sm->ssdi.ssd_chunk_no; i++) { 665 src = sd->sd_vol.sv_chunks[i]; 666 bcopy(&src->src_meta, cm, sizeof(*cm)); 667 cm++; 668 } 669 670 /* Optional metadata. */ 671 omh = (struct sr_meta_opt_hdr *)(cm); 672 SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link) { 673 DNPRINTF(SR_D_META, "%s: saving optional metadata type %u with " 674 "length %u\n", DEVNAME(sc), omi->omi_som->som_type, 675 omi->omi_som->som_length); 676 bzero(&omi->omi_som->som_checksum, MD5_DIGEST_LENGTH); 677 sr_checksum(sc, omi->omi_som, &omi->omi_som->som_checksum, 678 omi->omi_som->som_length); 679 bcopy(omi->omi_som, omh, omi->omi_som->som_length); 680 omh = (struct sr_meta_opt_hdr *)((u_int8_t *)omh + 681 omi->omi_som->som_length); 682 } 683 684 for (i = 0; i < sm->ssdi.ssd_chunk_no; i++) { 685 src = sd->sd_vol.sv_chunks[i]; 686 687 /* skip disks that are offline */ 688 if (src->src_meta.scm_status == BIOC_SDOFFLINE) 689 continue; 690 691 /* calculate metadata checksum for correct chunk */ 692 m->ssdi.ssd_chunk_id = i; 693 sr_checksum(sc, m, &m->ssd_checksum, 694 sizeof(struct sr_meta_invariant)); 695 696 #ifdef SR_DEBUG 697 DNPRINTF(SR_D_META, "%s: sr_meta_save %s: volid: %d " 698 "chunkid: %d checksum: ", 699 DEVNAME(sc), src->src_meta.scmi.scm_devname, 700 m->ssdi.ssd_volid, m->ssdi.ssd_chunk_id); 701 702 if (sr_debug & SR_D_META) 703 sr_checksum_print((u_int8_t *)&m->ssd_checksum); 704 DNPRINTF(SR_D_META, "\n"); 705 sr_meta_print(m); 706 #endif 707 708 /* translate and write to disk */ 709 if (s->smd_write(sd, src->src_dev_mm, m, NULL /* XXX */)) { 710 printf("%s: could not write metadata to %s\n", 711 DEVNAME(sc), src->src_devname); 712 /* restart the meta write */ 713 src->src_meta.scm_status = BIOC_SDOFFLINE; 714 /* XXX recalculate volume status */ 715 goto restart; 716 } 717 } 718 719 /* not all disciplines have sync */ 720 if (sd->sd_scsi_sync) { 721 bzero(&wu, sizeof(wu)); 722 wu.swu_fake = 1; 723 wu.swu_dis = sd; 724 sd->sd_scsi_sync(&wu); 725 } 726 free(m, M_DEVBUF); 727 return (0); 728 bad: 729 return (1); 730 } 731 732 int 733 sr_meta_read(struct sr_discipline *sd) 734 { 735 struct sr_softc *sc = sd->sd_sc; 736 struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list; 737 struct sr_metadata *sm; 738 struct sr_chunk *ch_entry; 739 struct sr_meta_chunk *cp; 740 struct sr_meta_driver *s; 741 void *fm = NULL; 742 int no_disk = 0, got_meta = 0; 743 744 DNPRINTF(SR_D_META, "%s: sr_meta_read\n", DEVNAME(sc)); 745 746 sm = malloc(SR_META_SIZE * 512, M_DEVBUF, M_WAITOK | M_ZERO); 747 s = &smd[sd->sd_meta_type]; 748 if (sd->sd_meta_type != SR_META_F_NATIVE) 749 fm = malloc(s->smd_size, M_DEVBUF, M_WAITOK | M_ZERO); 750 751 cp = (struct sr_meta_chunk *)(sm + 1); 752 SLIST_FOREACH(ch_entry, cl, src_link) { 753 /* skip disks that are offline */ 754 if (ch_entry->src_meta.scm_status == BIOC_SDOFFLINE) { 755 DNPRINTF(SR_D_META, 756 "%s: %s chunk marked offline, spoofing status\n", 757 DEVNAME(sc), ch_entry->src_devname); 758 cp++; /* adjust chunk pointer to match failure */ 759 continue; 760 } else if (s->smd_read(sd, ch_entry->src_dev_mm, sm, fm)) { 761 /* read and translate */ 762 /* XXX mark chunk offline, elsewhere!! */ 763 ch_entry->src_meta.scm_status = BIOC_SDOFFLINE; 764 cp++; /* adjust chunk pointer to match failure */ 765 DNPRINTF(SR_D_META, "%s: sr_meta_read failed\n", 766 DEVNAME(sc)); 767 continue; 768 } 769 770 if (sm->ssdi.ssd_magic != SR_MAGIC) { 771 DNPRINTF(SR_D_META, "%s: sr_meta_read !SR_MAGIC\n", 772 DEVNAME(sc)); 773 continue; 774 } 775 776 /* validate metadata */ 777 if (sr_meta_validate(sd, ch_entry->src_dev_mm, sm, fm)) { 778 DNPRINTF(SR_D_META, "%s: invalid metadata\n", 779 DEVNAME(sc)); 780 no_disk = -1; 781 goto done; 782 } 783 784 /* assume first chunk contains metadata */ 785 if (got_meta == 0) { 786 sr_meta_opt_load(sc, sm, &sd->sd_meta_opt); 787 bcopy(sm, sd->sd_meta, sizeof(*sd->sd_meta)); 788 got_meta = 1; 789 } 790 791 bcopy(cp, &ch_entry->src_meta, sizeof(ch_entry->src_meta)); 792 793 no_disk++; 794 cp++; 795 } 796 797 free(sm, M_DEVBUF); 798 if (fm) 799 free(fm, M_DEVBUF); 800 801 done: 802 DNPRINTF(SR_D_META, "%s: sr_meta_read found %d parts\n", DEVNAME(sc), 803 no_disk); 804 return (no_disk); 805 } 806 807 void 808 sr_meta_opt_load(struct sr_softc *sc, struct sr_metadata *sm, 809 struct sr_meta_opt_head *som) 810 { 811 struct sr_meta_opt_hdr *omh; 812 struct sr_meta_opt_item *omi; 813 u_int8_t checksum[MD5_DIGEST_LENGTH]; 814 int i; 815 816 /* Process optional metadata. */ 817 omh = (struct sr_meta_opt_hdr *)((u_int8_t *)(sm + 1) + 818 sizeof(struct sr_meta_chunk) * sm->ssdi.ssd_chunk_no); 819 for (i = 0; i < sm->ssdi.ssd_opt_no; i++) { 820 821 omi = malloc(sizeof(struct sr_meta_opt_item), M_DEVBUF, 822 M_WAITOK | M_ZERO); 823 SLIST_INSERT_HEAD(som, omi, omi_link); 824 825 if (omh->som_length == 0) { 826 827 /* Load old fixed length optional metadata. */ 828 DNPRINTF(SR_D_META, "%s: old optional metadata of type " 829 "%u\n", DEVNAME(sc), omh->som_type); 830 831 /* Validate checksum. */ 832 sr_checksum(sc, (void *)omh, &checksum, 833 SR_OLD_META_OPT_SIZE - MD5_DIGEST_LENGTH); 834 if (bcmp(&checksum, (void *)omh + SR_OLD_META_OPT_MD5, 835 sizeof(checksum))) 836 panic("%s: invalid optional metadata " 837 "checksum", DEVNAME(sc)); 838 839 /* Determine correct length. */ 840 switch (omh->som_type) { 841 case SR_OPT_CRYPTO: 842 omh->som_length = sizeof(struct sr_meta_crypto); 843 break; 844 case SR_OPT_BOOT: 845 omh->som_length = sizeof(struct sr_meta_boot); 846 break; 847 case SR_OPT_KEYDISK: 848 omh->som_length = 849 sizeof(struct sr_meta_keydisk); 850 break; 851 default: 852 panic("unknown old optional metadata " 853 "type %u\n", omh->som_type); 854 } 855 856 omi->omi_som = malloc(omh->som_length, M_DEVBUF, 857 M_WAITOK | M_ZERO); 858 bcopy((u_int8_t *)omh + SR_OLD_META_OPT_OFFSET, 859 (u_int8_t *)omi->omi_som + sizeof(*omi->omi_som), 860 omh->som_length - sizeof(*omi->omi_som)); 861 omi->omi_som->som_type = omh->som_type; 862 omi->omi_som->som_length = omh->som_length; 863 864 omh = (struct sr_meta_opt_hdr *)((void *)omh + 865 SR_OLD_META_OPT_SIZE); 866 } else { 867 868 /* Load variable length optional metadata. */ 869 DNPRINTF(SR_D_META, "%s: optional metadata of type %u, " 870 "length %u\n", DEVNAME(sc), omh->som_type, 871 omh->som_length); 872 omi->omi_som = malloc(omh->som_length, M_DEVBUF, 873 M_WAITOK | M_ZERO); 874 bcopy(omh, omi->omi_som, omh->som_length); 875 876 /* Validate checksum. */ 877 bcopy(&omi->omi_som->som_checksum, &checksum, 878 MD5_DIGEST_LENGTH); 879 bzero(&omi->omi_som->som_checksum, MD5_DIGEST_LENGTH); 880 sr_checksum(sc, omi->omi_som, 881 &omi->omi_som->som_checksum, omh->som_length); 882 if (bcmp(&checksum, &omi->omi_som->som_checksum, 883 sizeof(checksum))) 884 panic("%s: invalid optional metadata checksum", 885 DEVNAME(sc)); 886 887 omh = (struct sr_meta_opt_hdr *)((void *)omh + 888 omh->som_length); 889 } 890 } 891 } 892 893 int 894 sr_meta_validate(struct sr_discipline *sd, dev_t dev, struct sr_metadata *sm, 895 void *fm) 896 { 897 struct sr_softc *sc = sd->sd_sc; 898 struct sr_meta_driver *s; 899 #ifdef SR_DEBUG 900 struct sr_meta_chunk *mc; 901 #endif 902 u_int8_t checksum[MD5_DIGEST_LENGTH]; 903 char devname[32]; 904 int rv = 1; 905 906 DNPRINTF(SR_D_META, "%s: sr_meta_validate(%p)\n", DEVNAME(sc), sm); 907 908 sr_meta_getdevname(sc, dev, devname, sizeof(devname)); 909 910 s = &smd[sd->sd_meta_type]; 911 if (sd->sd_meta_type != SR_META_F_NATIVE) 912 if (s->smd_validate(sd, sm, fm)) { 913 sr_error(sc, "invalid foreign metadata"); 914 goto done; 915 } 916 917 /* 918 * at this point all foreign metadata has been translated to the native 919 * format and will be treated just like the native format 920 */ 921 922 if (sm->ssdi.ssd_magic != SR_MAGIC) { 923 sr_error(sc, "not valid softraid metadata"); 924 goto done; 925 } 926 927 /* Verify metadata checksum. */ 928 sr_checksum(sc, sm, &checksum, sizeof(struct sr_meta_invariant)); 929 if (bcmp(&checksum, &sm->ssd_checksum, sizeof(checksum))) { 930 sr_error(sc, "invalid metadata checksum"); 931 goto done; 932 } 933 934 /* Handle changes between versions. */ 935 if (sm->ssdi.ssd_version == 3) { 936 937 /* 938 * Version 3 - update metadata version and fix up data offset 939 * value since this did not exist in version 3. 940 */ 941 if (sm->ssd_data_offset == 0) 942 sm->ssd_data_offset = SR_META_V3_DATA_OFFSET; 943 944 } else if (sm->ssdi.ssd_version == 4) { 945 946 /* 947 * Version 4 - original metadata format did not store 948 * data offset so fix this up if necessary. 949 */ 950 if (sm->ssd_data_offset == 0) 951 sm->ssd_data_offset = SR_DATA_OFFSET; 952 953 } else if (sm->ssdi.ssd_version == SR_META_VERSION) { 954 955 /* 956 * Version 5 - variable length optional metadata. Migration 957 * from earlier fixed length optional metadata is handled 958 * in sr_meta_read(). 959 */ 960 961 } else { 962 963 sr_error(sc, "cannot read metadata version %u on %s, " 964 "expected version %u or earlier", 965 sm->ssdi.ssd_version, devname, SR_META_VERSION); 966 goto done; 967 968 } 969 970 /* Update version number and revision string. */ 971 sm->ssdi.ssd_version = SR_META_VERSION; 972 snprintf(sm->ssdi.ssd_revision, sizeof(sm->ssdi.ssd_revision), 973 "%03d", SR_META_VERSION); 974 975 #ifdef SR_DEBUG 976 /* warn if disk changed order */ 977 mc = (struct sr_meta_chunk *)(sm + 1); 978 if (strncmp(mc[sm->ssdi.ssd_chunk_id].scmi.scm_devname, devname, 979 sizeof(mc[sm->ssdi.ssd_chunk_id].scmi.scm_devname))) 980 DNPRINTF(SR_D_META, "%s: roaming device %s -> %s\n", 981 DEVNAME(sc), mc[sm->ssdi.ssd_chunk_id].scmi.scm_devname, 982 devname); 983 #endif 984 985 /* we have meta data on disk */ 986 DNPRINTF(SR_D_META, "%s: sr_meta_validate valid metadata %s\n", 987 DEVNAME(sc), devname); 988 989 rv = 0; 990 done: 991 return (rv); 992 } 993 994 int 995 sr_meta_native_bootprobe(struct sr_softc *sc, dev_t devno, 996 struct sr_boot_chunk_head *bch) 997 { 998 struct vnode *vn; 999 struct disklabel label; 1000 struct sr_metadata *md = NULL; 1001 struct sr_discipline *fake_sd = NULL; 1002 struct sr_boot_chunk *bc; 1003 char devname[32]; 1004 dev_t chrdev, rawdev; 1005 int error, i; 1006 int rv = SR_META_NOTCLAIMED; 1007 1008 DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe\n", DEVNAME(sc)); 1009 1010 /* 1011 * Use character raw device to avoid SCSI complaints about missing 1012 * media on removable media devices. 1013 */ 1014 chrdev = blktochr(devno); 1015 rawdev = MAKEDISKDEV(major(chrdev), DISKUNIT(devno), RAW_PART); 1016 if (cdevvp(rawdev, &vn)) { 1017 sr_error(sc, "sr_meta_native_bootprobe: cannot allocate vnode"); 1018 goto done; 1019 } 1020 1021 /* open device */ 1022 error = VOP_OPEN(vn, FREAD, NOCRED, curproc); 1023 if (error) { 1024 DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe open " 1025 "failed\n", DEVNAME(sc)); 1026 vput(vn); 1027 goto done; 1028 } 1029 1030 /* get disklabel */ 1031 error = VOP_IOCTL(vn, DIOCGDINFO, (caddr_t)&label, FREAD, NOCRED, 1032 curproc); 1033 if (error) { 1034 DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe ioctl " 1035 "failed\n", DEVNAME(sc)); 1036 VOP_CLOSE(vn, FREAD, NOCRED, curproc); 1037 vput(vn); 1038 goto done; 1039 } 1040 1041 /* we are done, close device */ 1042 error = VOP_CLOSE(vn, FREAD, NOCRED, curproc); 1043 if (error) { 1044 DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe close " 1045 "failed\n", DEVNAME(sc)); 1046 vput(vn); 1047 goto done; 1048 } 1049 vput(vn); 1050 1051 /* Make sure this is a 512-byte/sector device. */ 1052 if (label.d_secsize != DEV_BSIZE) { 1053 DNPRINTF(SR_D_META, "%s: %s has unsupported sector size (%d)", 1054 DEVNAME(sc), devname, label.d_secsize); 1055 goto done; 1056 } 1057 1058 md = malloc(SR_META_SIZE * 512, M_DEVBUF, M_ZERO | M_NOWAIT); 1059 if (md == NULL) { 1060 sr_error(sc, "not enough memory for metadata buffer"); 1061 goto done; 1062 } 1063 1064 /* create fake sd to use utility functions */ 1065 fake_sd = malloc(sizeof(struct sr_discipline), M_DEVBUF, 1066 M_ZERO | M_NOWAIT); 1067 if (fake_sd == NULL) { 1068 sr_error(sc, "not enough memory for fake discipline"); 1069 goto done; 1070 } 1071 fake_sd->sd_sc = sc; 1072 fake_sd->sd_meta_type = SR_META_F_NATIVE; 1073 1074 for (i = 0; i < MAXPARTITIONS; i++) { 1075 if (label.d_partitions[i].p_fstype != FS_RAID) 1076 continue; 1077 1078 /* open partition */ 1079 rawdev = MAKEDISKDEV(major(devno), DISKUNIT(devno), i); 1080 if (bdevvp(rawdev, &vn)) { 1081 sr_error(sc, "sr_meta_native_bootprobe: cannot " 1082 "allocate vnode for partition"); 1083 goto done; 1084 } 1085 error = VOP_OPEN(vn, FREAD, NOCRED, curproc); 1086 if (error) { 1087 DNPRINTF(SR_D_META, "%s: sr_meta_native_bootprobe " 1088 "open failed, partition %d\n", 1089 DEVNAME(sc), i); 1090 vput(vn); 1091 continue; 1092 } 1093 1094 if (sr_meta_native_read(fake_sd, rawdev, md, NULL)) { 1095 sr_error(sc, "native bootprobe could not read native " 1096 "metadata"); 1097 VOP_CLOSE(vn, FREAD, NOCRED, curproc); 1098 vput(vn); 1099 continue; 1100 } 1101 1102 /* are we a softraid partition? */ 1103 if (md->ssdi.ssd_magic != SR_MAGIC) { 1104 VOP_CLOSE(vn, FREAD, NOCRED, curproc); 1105 vput(vn); 1106 continue; 1107 } 1108 1109 sr_meta_getdevname(sc, rawdev, devname, sizeof(devname)); 1110 if (sr_meta_validate(fake_sd, rawdev, md, NULL) == 0) { 1111 /* XXX fix M_WAITOK, this is boot time */ 1112 bc = malloc(sizeof(struct sr_boot_chunk), 1113 M_DEVBUF, M_WAITOK | M_ZERO); 1114 bc->sbc_metadata = malloc(sizeof(struct sr_metadata), 1115 M_DEVBUF, M_WAITOK | M_ZERO); 1116 bcopy(md, bc->sbc_metadata, sizeof(struct sr_metadata)); 1117 bc->sbc_mm = rawdev; 1118 SLIST_INSERT_HEAD(bch, bc, sbc_link); 1119 rv = SR_META_CLAIMED; 1120 } 1121 1122 /* we are done, close partition */ 1123 VOP_CLOSE(vn, FREAD, NOCRED, curproc); 1124 vput(vn); 1125 } 1126 1127 done: 1128 if (fake_sd) 1129 free(fake_sd, M_DEVBUF); 1130 if (md) 1131 free(md, M_DEVBUF); 1132 1133 return (rv); 1134 } 1135 1136 int 1137 sr_boot_assembly(struct sr_softc *sc) 1138 { 1139 struct sr_boot_volume_head bvh; 1140 struct sr_boot_chunk_head bch, kdh; 1141 struct sr_boot_volume *bv, *bv1, *bv2; 1142 struct sr_boot_chunk *bc, *bcnext, *bc1, *bc2; 1143 struct sr_disk_head sdklist; 1144 struct sr_disk *sdk; 1145 struct disk *dk; 1146 struct bioc_createraid bcr; 1147 struct sr_meta_chunk *hm; 1148 struct sr_chunk_head *cl; 1149 struct sr_chunk *hotspare, *chunk, *last; 1150 u_int64_t *ondisk = NULL; 1151 dev_t *devs = NULL; 1152 void *data; 1153 char devname[32]; 1154 int rv = 0, i; 1155 1156 DNPRINTF(SR_D_META, "%s: sr_boot_assembly\n", DEVNAME(sc)); 1157 1158 SLIST_INIT(&sdklist); 1159 SLIST_INIT(&bvh); 1160 SLIST_INIT(&bch); 1161 SLIST_INIT(&kdh); 1162 1163 dk = TAILQ_FIRST(&disklist); 1164 while (dk != TAILQ_END(&disklist)) { 1165 1166 /* See if this disk has been checked. */ 1167 SLIST_FOREACH(sdk, &sdklist, sdk_link) 1168 if (sdk->sdk_devno == dk->dk_devno) 1169 break; 1170 1171 if (sdk != NULL || dk->dk_devno == NODEV) { 1172 dk = TAILQ_NEXT(dk, dk_link); 1173 continue; 1174 } 1175 1176 /* Add this disk to the list that we've checked. */ 1177 sdk = malloc(sizeof(struct sr_disk), M_DEVBUF, 1178 M_NOWAIT | M_CANFAIL | M_ZERO); 1179 if (sdk == NULL) 1180 goto unwind; 1181 sdk->sdk_devno = dk->dk_devno; 1182 SLIST_INSERT_HEAD(&sdklist, sdk, sdk_link); 1183 1184 /* Only check sd(4) and wd(4) devices. */ 1185 if (strncmp(dk->dk_name, "sd", 2) && 1186 strncmp(dk->dk_name, "wd", 2)) { 1187 dk = TAILQ_NEXT(dk, dk_link); 1188 continue; 1189 } 1190 1191 /* native softraid uses partitions */ 1192 sr_meta_native_bootprobe(sc, dk->dk_devno, &bch); 1193 1194 /* probe non-native disks if native failed. */ 1195 1196 /* Restart scan since we may have slept. */ 1197 dk = TAILQ_FIRST(&disklist); 1198 } 1199 1200 /* 1201 * Create a list of volumes and associate chunks with each volume. 1202 */ 1203 for (bc = SLIST_FIRST(&bch); bc != SLIST_END(&bch); bc = bcnext) { 1204 1205 bcnext = SLIST_NEXT(bc, sbc_link); 1206 SLIST_REMOVE(&bch, bc, sr_boot_chunk, sbc_link); 1207 bc->sbc_chunk_id = bc->sbc_metadata->ssdi.ssd_chunk_id; 1208 1209 /* Handle key disks separately. */ 1210 if (bc->sbc_metadata->ssdi.ssd_level == SR_KEYDISK_LEVEL) { 1211 SLIST_INSERT_HEAD(&kdh, bc, sbc_link); 1212 continue; 1213 } 1214 1215 SLIST_FOREACH(bv, &bvh, sbv_link) { 1216 if (bcmp(&bc->sbc_metadata->ssdi.ssd_uuid, 1217 &bv->sbv_uuid, 1218 sizeof(bc->sbc_metadata->ssdi.ssd_uuid)) == 0) 1219 break; 1220 } 1221 1222 if (bv == NULL) { 1223 bv = malloc(sizeof(struct sr_boot_volume), 1224 M_DEVBUF, M_NOWAIT | M_CANFAIL | M_ZERO); 1225 if (bv == NULL) { 1226 sr_error(sc, "failed to allocate boot volume"); 1227 goto unwind; 1228 } 1229 1230 bv->sbv_level = bc->sbc_metadata->ssdi.ssd_level; 1231 bv->sbv_volid = bc->sbc_metadata->ssdi.ssd_volid; 1232 bv->sbv_chunk_no = bc->sbc_metadata->ssdi.ssd_chunk_no; 1233 bv->sbv_flags = bc->sbc_metadata->ssdi.ssd_vol_flags; 1234 bcopy(&bc->sbc_metadata->ssdi.ssd_uuid, &bv->sbv_uuid, 1235 sizeof(bc->sbc_metadata->ssdi.ssd_uuid)); 1236 SLIST_INIT(&bv->sbv_chunks); 1237 1238 /* Maintain volume order. */ 1239 bv2 = NULL; 1240 SLIST_FOREACH(bv1, &bvh, sbv_link) { 1241 if (bv1->sbv_volid > bv->sbv_volid) 1242 break; 1243 bv2 = bv1; 1244 } 1245 if (bv2 == NULL) { 1246 DNPRINTF(SR_D_META, "%s: insert volume %u " 1247 "at head\n", DEVNAME(sc), bv->sbv_volid); 1248 SLIST_INSERT_HEAD(&bvh, bv, sbv_link); 1249 } else { 1250 DNPRINTF(SR_D_META, "%s: insert volume %u " 1251 "after %u\n", DEVNAME(sc), bv->sbv_volid, 1252 bv2->sbv_volid); 1253 SLIST_INSERT_AFTER(bv2, bv, sbv_link); 1254 } 1255 } 1256 1257 /* Maintain chunk order. */ 1258 bc2 = NULL; 1259 SLIST_FOREACH(bc1, &bv->sbv_chunks, sbc_link) { 1260 if (bc1->sbc_chunk_id > bc->sbc_chunk_id) 1261 break; 1262 bc2 = bc1; 1263 } 1264 if (bc2 == NULL) { 1265 DNPRINTF(SR_D_META, "%s: volume %u insert chunk %u " 1266 "at head\n", DEVNAME(sc), bv->sbv_volid, 1267 bc->sbc_chunk_id); 1268 SLIST_INSERT_HEAD(&bv->sbv_chunks, bc, sbc_link); 1269 } else { 1270 DNPRINTF(SR_D_META, "%s: volume %u insert chunk %u " 1271 "after %u\n", DEVNAME(sc), bv->sbv_volid, 1272 bc->sbc_chunk_id, bc2->sbc_chunk_id); 1273 SLIST_INSERT_AFTER(bc2, bc, sbc_link); 1274 } 1275 1276 bv->sbv_chunks_found++; 1277 } 1278 1279 /* Allocate memory for device and ondisk version arrays. */ 1280 devs = malloc(BIOC_CRMAXLEN * sizeof(dev_t), M_DEVBUF, 1281 M_NOWAIT | M_CANFAIL); 1282 if (devs == NULL) { 1283 printf("%s: failed to allocate device array\n", DEVNAME(sc)); 1284 goto unwind; 1285 } 1286 ondisk = malloc(BIOC_CRMAXLEN * sizeof(u_int64_t), M_DEVBUF, 1287 M_NOWAIT | M_CANFAIL); 1288 if (ondisk == NULL) { 1289 printf("%s: failed to allocate ondisk array\n", DEVNAME(sc)); 1290 goto unwind; 1291 } 1292 1293 /* 1294 * Assemble hotspare "volumes". 1295 */ 1296 SLIST_FOREACH(bv, &bvh, sbv_link) { 1297 1298 /* Check if this is a hotspare "volume". */ 1299 if (bv->sbv_level != SR_HOTSPARE_LEVEL || 1300 bv->sbv_chunk_no != 1) 1301 continue; 1302 1303 #ifdef SR_DEBUG 1304 DNPRINTF(SR_D_META, "%s: assembling hotspare volume ", 1305 DEVNAME(sc)); 1306 if (sr_debug & SR_D_META) 1307 sr_uuid_print(&bv->sbv_uuid, 0); 1308 DNPRINTF(SR_D_META, " volid %u with %u chunks\n", 1309 bv->sbv_volid, bv->sbv_chunk_no); 1310 #endif 1311 1312 /* Create hotspare chunk metadata. */ 1313 hotspare = malloc(sizeof(struct sr_chunk), M_DEVBUF, 1314 M_NOWAIT | M_CANFAIL | M_ZERO); 1315 if (hotspare == NULL) { 1316 printf("%s: failed to allocate hotspare\n", 1317 DEVNAME(sc)); 1318 goto unwind; 1319 } 1320 1321 bc = SLIST_FIRST(&bv->sbv_chunks); 1322 sr_meta_getdevname(sc, bc->sbc_mm, devname, sizeof(devname)); 1323 hotspare->src_dev_mm = bc->sbc_mm; 1324 strlcpy(hotspare->src_devname, devname, 1325 sizeof(hotspare->src_devname)); 1326 hotspare->src_size = bc->sbc_metadata->ssdi.ssd_size; 1327 1328 hm = &hotspare->src_meta; 1329 hm->scmi.scm_volid = SR_HOTSPARE_VOLID; 1330 hm->scmi.scm_chunk_id = 0; 1331 hm->scmi.scm_size = bc->sbc_metadata->ssdi.ssd_size; 1332 hm->scmi.scm_coerced_size = bc->sbc_metadata->ssdi.ssd_size; 1333 strlcpy(hm->scmi.scm_devname, devname, 1334 sizeof(hm->scmi.scm_devname)); 1335 bcopy(&bc->sbc_metadata->ssdi.ssd_uuid, &hm->scmi.scm_uuid, 1336 sizeof(struct sr_uuid)); 1337 1338 sr_checksum(sc, hm, &hm->scm_checksum, 1339 sizeof(struct sr_meta_chunk_invariant)); 1340 1341 hm->scm_status = BIOC_SDHOTSPARE; 1342 1343 /* Add chunk to hotspare list. */ 1344 rw_enter_write(&sc->sc_hs_lock); 1345 cl = &sc->sc_hotspare_list; 1346 if (SLIST_EMPTY(cl)) 1347 SLIST_INSERT_HEAD(cl, hotspare, src_link); 1348 else { 1349 SLIST_FOREACH(chunk, cl, src_link) 1350 last = chunk; 1351 SLIST_INSERT_AFTER(last, hotspare, src_link); 1352 } 1353 sc->sc_hotspare_no++; 1354 rw_exit_write(&sc->sc_hs_lock); 1355 1356 } 1357 1358 /* 1359 * Assemble RAID volumes. 1360 */ 1361 SLIST_FOREACH(bv, &bvh, sbv_link) { 1362 1363 bzero(&bcr, sizeof(bcr)); 1364 data = NULL; 1365 1366 /* Check if this is a hotspare "volume". */ 1367 if (bv->sbv_level == SR_HOTSPARE_LEVEL && 1368 bv->sbv_chunk_no == 1) 1369 continue; 1370 1371 /* 1372 * Skip volumes that are marked as no auto assemble, unless 1373 * this was the volume which we actually booted from. 1374 */ 1375 if (bcmp(&sr_bootuuid, &bv->sbv_uuid, sizeof(sr_bootuuid)) != 0) 1376 if (bv->sbv_flags & BIOC_SCNOAUTOASSEMBLE) 1377 continue; 1378 1379 #ifdef SR_DEBUG 1380 DNPRINTF(SR_D_META, "%s: assembling volume ", DEVNAME(sc)); 1381 if (sr_debug & SR_D_META) 1382 sr_uuid_print(&bv->sbv_uuid, 0); 1383 DNPRINTF(SR_D_META, " volid %u with %u chunks\n", 1384 bv->sbv_volid, bv->sbv_chunk_no); 1385 #endif 1386 1387 /* 1388 * If this is a crypto volume, try to find a matching 1389 * key disk... 1390 */ 1391 bcr.bc_key_disk = NODEV; 1392 if (bv->sbv_level == 'C') { 1393 SLIST_FOREACH(bc, &kdh, sbc_link) { 1394 if (bcmp(&bc->sbc_metadata->ssdi.ssd_uuid, 1395 &bv->sbv_uuid, 1396 sizeof(bc->sbc_metadata->ssdi.ssd_uuid)) 1397 == 0) 1398 bcr.bc_key_disk = bc->sbc_mm; 1399 } 1400 } 1401 1402 for (i = 0; i < BIOC_CRMAXLEN; i++) { 1403 devs[i] = NODEV; /* mark device as illegal */ 1404 ondisk[i] = 0; 1405 } 1406 1407 SLIST_FOREACH(bc, &bv->sbv_chunks, sbc_link) { 1408 if (devs[bc->sbc_chunk_id] != NODEV) { 1409 bv->sbv_chunks_found--; 1410 sr_meta_getdevname(sc, bc->sbc_mm, devname, 1411 sizeof(devname)); 1412 printf("%s: found duplicate chunk %u for " 1413 "volume %u on device %s\n", DEVNAME(sc), 1414 bc->sbc_chunk_id, bv->sbv_volid, devname); 1415 } 1416 1417 if (devs[bc->sbc_chunk_id] == NODEV || 1418 bc->sbc_metadata->ssd_ondisk > 1419 ondisk[bc->sbc_chunk_id]) { 1420 devs[bc->sbc_chunk_id] = bc->sbc_mm; 1421 ondisk[bc->sbc_chunk_id] = 1422 bc->sbc_metadata->ssd_ondisk; 1423 DNPRINTF(SR_D_META, "%s: using ondisk " 1424 "metadata version %llu for chunk %u\n", 1425 DEVNAME(sc), ondisk[bc->sbc_chunk_id], 1426 bc->sbc_chunk_id); 1427 } 1428 } 1429 1430 if (bv->sbv_chunk_no != bv->sbv_chunks_found) { 1431 printf("%s: not all chunks were provided; " 1432 "attempting to bring volume %d online\n", 1433 DEVNAME(sc), bv->sbv_volid); 1434 } 1435 1436 bcr.bc_level = bv->sbv_level; 1437 bcr.bc_dev_list_len = bv->sbv_chunk_no * sizeof(dev_t); 1438 bcr.bc_dev_list = devs; 1439 bcr.bc_flags = BIOC_SCDEVT | 1440 (bv->sbv_flags & BIOC_SCNOAUTOASSEMBLE); 1441 1442 if (bv->sbv_level == 'C' && 1443 bcmp(&sr_bootuuid, &bv->sbv_uuid, sizeof(sr_bootuuid)) == 0) 1444 data = sr_bootkey; 1445 1446 rw_enter_write(&sc->sc_lock); 1447 bio_status_init(&sc->sc_status, &sc->sc_dev); 1448 sr_ioctl_createraid(sc, &bcr, 0, data); 1449 rw_exit_write(&sc->sc_lock); 1450 1451 rv++; 1452 } 1453 1454 /* done with metadata */ 1455 unwind: 1456 /* Free boot volumes and associated chunks. */ 1457 for (bv1 = SLIST_FIRST(&bvh); bv1 != SLIST_END(&bvh); bv1 = bv2) { 1458 bv2 = SLIST_NEXT(bv1, sbv_link); 1459 for (bc1 = SLIST_FIRST(&bv1->sbv_chunks); 1460 bc1 != SLIST_END(&bv1->sbv_chunks); bc1 = bc2) { 1461 bc2 = SLIST_NEXT(bc1, sbc_link); 1462 if (bc1->sbc_metadata) 1463 free(bc1->sbc_metadata, M_DEVBUF); 1464 free(bc1, M_DEVBUF); 1465 } 1466 free(bv1, M_DEVBUF); 1467 } 1468 /* Free keydisks chunks. */ 1469 for (bc1 = SLIST_FIRST(&kdh); bc1 != SLIST_END(&kdh); bc1 = bc2) { 1470 bc2 = SLIST_NEXT(bc1, sbc_link); 1471 if (bc1->sbc_metadata) 1472 free(bc1->sbc_metadata, M_DEVBUF); 1473 free(bc1, M_DEVBUF); 1474 } 1475 /* Free unallocated chunks. */ 1476 for (bc1 = SLIST_FIRST(&bch); bc1 != SLIST_END(&bch); bc1 = bc2) { 1477 bc2 = SLIST_NEXT(bc1, sbc_link); 1478 if (bc1->sbc_metadata) 1479 free(bc1->sbc_metadata, M_DEVBUF); 1480 free(bc1, M_DEVBUF); 1481 } 1482 1483 while (!SLIST_EMPTY(&sdklist)) { 1484 sdk = SLIST_FIRST(&sdklist); 1485 SLIST_REMOVE_HEAD(&sdklist, sdk_link); 1486 free(sdk, M_DEVBUF); 1487 } 1488 1489 if (devs) 1490 free(devs, M_DEVBUF); 1491 if (ondisk) 1492 free(ondisk, M_DEVBUF); 1493 1494 return (rv); 1495 } 1496 1497 void 1498 sr_map_root(void) 1499 { 1500 struct sr_softc *sc = softraid0; 1501 struct sr_discipline *sd; 1502 struct sr_meta_opt_item *omi; 1503 struct sr_meta_boot *sbm; 1504 u_char duid[8]; 1505 int i; 1506 1507 DNPRINTF(SR_D_MISC, "%s: sr_map_root\n", DEVNAME(sc)); 1508 1509 if (sc == NULL) 1510 return; 1511 1512 bzero(duid, sizeof(duid)); 1513 if (bcmp(rootduid, duid, sizeof(duid)) == 0) { 1514 DNPRINTF(SR_D_MISC, "%s: root duid is zero\n", DEVNAME(sc)); 1515 return; 1516 } 1517 1518 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 1519 SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link) { 1520 if (omi->omi_som->som_type != SR_OPT_BOOT) 1521 continue; 1522 sbm = (struct sr_meta_boot *)omi->omi_som; 1523 for (i = 0; i < SR_MAX_BOOT_DISKS; i++) { 1524 if (bcmp(rootduid, sbm->sbm_boot_duid[i], 1525 sizeof(rootduid)) == 0) { 1526 bcopy(sbm->sbm_root_duid, rootduid, 1527 sizeof(rootduid)); 1528 DNPRINTF(SR_D_MISC, "%s: root duid " 1529 "mapped to %02hx%02hx%02hx%02hx" 1530 "%02hx%02hx%02hx%02hx\n", 1531 DEVNAME(sc), rootduid[0], 1532 rootduid[1], rootduid[2], 1533 rootduid[3], rootduid[4], 1534 rootduid[5], rootduid[6], 1535 rootduid[7]); 1536 return; 1537 } 1538 } 1539 } 1540 } 1541 } 1542 1543 int 1544 sr_meta_native_probe(struct sr_softc *sc, struct sr_chunk *ch_entry) 1545 { 1546 struct disklabel label; 1547 char *devname; 1548 int error, part; 1549 daddr64_t size; 1550 1551 DNPRINTF(SR_D_META, "%s: sr_meta_native_probe(%s)\n", 1552 DEVNAME(sc), ch_entry->src_devname); 1553 1554 devname = ch_entry->src_devname; 1555 part = DISKPART(ch_entry->src_dev_mm); 1556 1557 /* get disklabel */ 1558 error = VOP_IOCTL(ch_entry->src_vn, DIOCGDINFO, (caddr_t)&label, FREAD, 1559 NOCRED, curproc); 1560 if (error) { 1561 DNPRINTF(SR_D_META, "%s: %s can't obtain disklabel\n", 1562 DEVNAME(sc), devname); 1563 goto unwind; 1564 } 1565 bcopy(label.d_uid, ch_entry->src_duid, sizeof(ch_entry->src_duid)); 1566 1567 /* Make sure this is a 512-byte/sector device. */ 1568 if (label.d_secsize != DEV_BSIZE) { 1569 sr_error(sc, "%s has unsupported sector size (%d)", 1570 devname, label.d_secsize); 1571 goto unwind; 1572 } 1573 1574 /* make sure the partition is of the right type */ 1575 if (label.d_partitions[part].p_fstype != FS_RAID) { 1576 DNPRINTF(SR_D_META, 1577 "%s: %s partition not of type RAID (%d)\n", DEVNAME(sc), 1578 devname, 1579 label.d_partitions[part].p_fstype); 1580 goto unwind; 1581 } 1582 1583 size = DL_GETPSIZE(&label.d_partitions[part]) - SR_DATA_OFFSET; 1584 if (size <= 0) { 1585 DNPRINTF(SR_D_META, "%s: %s partition too small\n", DEVNAME(sc), 1586 devname); 1587 goto unwind; 1588 } 1589 ch_entry->src_size = size; 1590 1591 DNPRINTF(SR_D_META, "%s: probe found %s size %d\n", DEVNAME(sc), 1592 devname, size); 1593 1594 return (SR_META_F_NATIVE); 1595 unwind: 1596 DNPRINTF(SR_D_META, "%s: invalid device: %s\n", DEVNAME(sc), 1597 devname ? devname : "nodev"); 1598 return (SR_META_F_INVALID); 1599 } 1600 1601 int 1602 sr_meta_native_attach(struct sr_discipline *sd, int force) 1603 { 1604 struct sr_softc *sc = sd->sd_sc; 1605 struct sr_chunk_head *cl = &sd->sd_vol.sv_chunk_list; 1606 struct sr_metadata *md = NULL; 1607 struct sr_chunk *ch_entry, *ch_next; 1608 struct sr_uuid uuid; 1609 u_int64_t version = 0; 1610 int sr, not_sr, rv = 1, d, expected = -1, old_meta = 0; 1611 1612 DNPRINTF(SR_D_META, "%s: sr_meta_native_attach\n", DEVNAME(sc)); 1613 1614 md = malloc(SR_META_SIZE * 512, M_DEVBUF, M_ZERO | M_NOWAIT); 1615 if (md == NULL) { 1616 sr_error(sc, "not enough memory for metadata buffer"); 1617 goto bad; 1618 } 1619 1620 bzero(&uuid, sizeof uuid); 1621 1622 sr = not_sr = d = 0; 1623 SLIST_FOREACH(ch_entry, cl, src_link) { 1624 if (ch_entry->src_dev_mm == NODEV) 1625 continue; 1626 1627 if (sr_meta_native_read(sd, ch_entry->src_dev_mm, md, NULL)) { 1628 sr_error(sc, "could not read native metadata"); 1629 goto bad; 1630 } 1631 1632 if (md->ssdi.ssd_magic == SR_MAGIC) { 1633 sr++; 1634 ch_entry->src_meta.scmi.scm_chunk_id = 1635 md->ssdi.ssd_chunk_id; 1636 if (d == 0) { 1637 bcopy(&md->ssdi.ssd_uuid, &uuid, sizeof uuid); 1638 expected = md->ssdi.ssd_chunk_no; 1639 version = md->ssd_ondisk; 1640 d++; 1641 continue; 1642 } else if (bcmp(&md->ssdi.ssd_uuid, &uuid, 1643 sizeof uuid)) { 1644 sr_error(sc, "not part of the same volume"); 1645 goto bad; 1646 } 1647 if (md->ssd_ondisk != version) { 1648 old_meta++; 1649 version = MAX(md->ssd_ondisk, version); 1650 } 1651 } else 1652 not_sr++; 1653 } 1654 1655 if (sr && not_sr) { 1656 sr_error(sc, "not all chunks are of the native metadata " 1657 "format"); 1658 goto bad; 1659 } 1660 1661 /* mixed metadata versions; mark bad disks offline */ 1662 if (old_meta) { 1663 d = 0; 1664 for (ch_entry = SLIST_FIRST(cl); ch_entry != SLIST_END(cl); 1665 ch_entry = ch_next, d++) { 1666 ch_next = SLIST_NEXT(ch_entry, src_link); 1667 1668 /* XXX do we want to read this again? */ 1669 if (ch_entry->src_dev_mm == NODEV) 1670 panic("src_dev_mm == NODEV"); 1671 if (sr_meta_native_read(sd, ch_entry->src_dev_mm, md, 1672 NULL)) 1673 sr_warn(sc, "could not read native metadata"); 1674 if (md->ssd_ondisk != version) 1675 sd->sd_vol.sv_chunks[d]->src_meta.scm_status = 1676 BIOC_SDOFFLINE; 1677 } 1678 } 1679 1680 if (expected != sr && !force && expected != -1) { 1681 DNPRINTF(SR_D_META, "%s: not all chunks were provided, trying " 1682 "anyway\n", DEVNAME(sc)); 1683 } 1684 1685 rv = 0; 1686 bad: 1687 if (md) 1688 free(md, M_DEVBUF); 1689 return (rv); 1690 } 1691 1692 int 1693 sr_meta_native_read(struct sr_discipline *sd, dev_t dev, 1694 struct sr_metadata *md, void *fm) 1695 { 1696 #ifdef SR_DEBUG 1697 struct sr_softc *sc = sd->sd_sc; 1698 #endif 1699 DNPRINTF(SR_D_META, "%s: sr_meta_native_read(0x%x, %p)\n", 1700 DEVNAME(sc), dev, md); 1701 1702 return (sr_meta_rw(sd, dev, md, SR_META_SIZE * 512, SR_META_OFFSET, 1703 B_READ)); 1704 } 1705 1706 int 1707 sr_meta_native_write(struct sr_discipline *sd, dev_t dev, 1708 struct sr_metadata *md, void *fm) 1709 { 1710 #ifdef SR_DEBUG 1711 struct sr_softc *sc = sd->sd_sc; 1712 #endif 1713 DNPRINTF(SR_D_META, "%s: sr_meta_native_write(0x%x, %p)\n", 1714 DEVNAME(sc), dev, md); 1715 1716 return (sr_meta_rw(sd, dev, md, SR_META_SIZE * 512, SR_META_OFFSET, 1717 B_WRITE)); 1718 } 1719 1720 void 1721 sr_hotplug_register(struct sr_discipline *sd, void *func) 1722 { 1723 struct sr_hotplug_list *mhe; 1724 1725 DNPRINTF(SR_D_MISC, "%s: sr_hotplug_register: %p\n", 1726 DEVNAME(sd->sd_sc), func); 1727 1728 /* make sure we aren't on the list yet */ 1729 SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link) 1730 if (mhe->sh_hotplug == func) 1731 return; 1732 1733 mhe = malloc(sizeof(struct sr_hotplug_list), M_DEVBUF, 1734 M_WAITOK | M_ZERO); 1735 mhe->sh_hotplug = func; 1736 mhe->sh_sd = sd; 1737 SLIST_INSERT_HEAD(&sr_hotplug_callbacks, mhe, shl_link); 1738 } 1739 1740 void 1741 sr_hotplug_unregister(struct sr_discipline *sd, void *func) 1742 { 1743 struct sr_hotplug_list *mhe; 1744 1745 DNPRINTF(SR_D_MISC, "%s: sr_hotplug_unregister: %s %p\n", 1746 DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, func); 1747 1748 /* make sure we are on the list yet */ 1749 SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link) 1750 if (mhe->sh_hotplug == func) { 1751 SLIST_REMOVE(&sr_hotplug_callbacks, mhe, 1752 sr_hotplug_list, shl_link); 1753 free(mhe, M_DEVBUF); 1754 if (SLIST_EMPTY(&sr_hotplug_callbacks)) 1755 SLIST_INIT(&sr_hotplug_callbacks); 1756 return; 1757 } 1758 } 1759 1760 void 1761 sr_disk_attach(struct disk *diskp, int action) 1762 { 1763 struct sr_hotplug_list *mhe; 1764 1765 SLIST_FOREACH(mhe, &sr_hotplug_callbacks, shl_link) 1766 if (mhe->sh_sd->sd_ready) 1767 mhe->sh_hotplug(mhe->sh_sd, diskp, action); 1768 } 1769 1770 int 1771 sr_match(struct device *parent, void *match, void *aux) 1772 { 1773 return (1); 1774 } 1775 1776 void 1777 sr_attach(struct device *parent, struct device *self, void *aux) 1778 { 1779 struct sr_softc *sc = (void *)self; 1780 struct scsibus_attach_args saa; 1781 1782 DNPRINTF(SR_D_MISC, "\n%s: sr_attach", DEVNAME(sc)); 1783 1784 if (softraid0 == NULL) 1785 softraid0 = sc; 1786 1787 rw_init(&sc->sc_lock, "sr_lock"); 1788 rw_init(&sc->sc_hs_lock, "sr_hs_lock"); 1789 1790 SLIST_INIT(&sr_hotplug_callbacks); 1791 TAILQ_INIT(&sc->sc_dis_list); 1792 SLIST_INIT(&sc->sc_hotspare_list); 1793 1794 #if NBIO > 0 1795 if (bio_register(&sc->sc_dev, sr_bio_ioctl) != 0) 1796 printf("%s: controller registration failed", DEVNAME(sc)); 1797 #endif /* NBIO > 0 */ 1798 1799 #ifndef SMALL_KERNEL 1800 strlcpy(sc->sc_sensordev.xname, DEVNAME(sc), 1801 sizeof(sc->sc_sensordev.xname)); 1802 sensordev_install(&sc->sc_sensordev); 1803 #endif /* SMALL_KERNEL */ 1804 1805 printf("\n"); 1806 1807 sc->sc_link.adapter_softc = sc; 1808 sc->sc_link.adapter = &sr_switch; 1809 sc->sc_link.adapter_target = SR_MAX_LD; 1810 sc->sc_link.adapter_buswidth = SR_MAX_LD; 1811 sc->sc_link.luns = 1; 1812 1813 bzero(&saa, sizeof(saa)); 1814 saa.saa_sc_link = &sc->sc_link; 1815 1816 sc->sc_scsibus = (struct scsibus_softc *)config_found(&sc->sc_dev, 1817 &saa, scsiprint); 1818 1819 softraid_disk_attach = sr_disk_attach; 1820 1821 sc->sc_shutdownhook = shutdownhook_establish(sr_shutdownhook, sc); 1822 1823 sr_boot_assembly(sc); 1824 1825 explicit_bzero(sr_bootkey, sizeof(sr_bootkey)); 1826 } 1827 1828 int 1829 sr_detach(struct device *self, int flags) 1830 { 1831 struct sr_softc *sc = (void *)self; 1832 int rv; 1833 1834 DNPRINTF(SR_D_MISC, "%s: sr_detach\n", DEVNAME(sc)); 1835 1836 if (sc->sc_shutdownhook) 1837 shutdownhook_disestablish(sc->sc_shutdownhook); 1838 1839 softraid_disk_attach = NULL; 1840 1841 sr_shutdown(sc); 1842 1843 #ifndef SMALL_KERNEL 1844 if (sc->sc_sensor_task != NULL) 1845 sensor_task_unregister(sc->sc_sensor_task); 1846 sensordev_deinstall(&sc->sc_sensordev); 1847 #endif /* SMALL_KERNEL */ 1848 1849 if (sc->sc_scsibus != NULL) { 1850 rv = config_detach((struct device *)sc->sc_scsibus, flags); 1851 if (rv != 0) 1852 return (rv); 1853 sc->sc_scsibus = NULL; 1854 } 1855 1856 return (rv); 1857 } 1858 1859 void 1860 sr_info(struct sr_softc *sc, const char *fmt, ...) 1861 { 1862 va_list ap; 1863 1864 rw_assert_wrlock(&sc->sc_lock); 1865 1866 va_start(ap, fmt); 1867 bio_status(&sc->sc_status, 0, BIO_MSG_INFO, fmt, &ap); 1868 va_end(ap); 1869 } 1870 1871 void 1872 sr_warn(struct sr_softc *sc, const char *fmt, ...) 1873 { 1874 va_list ap; 1875 1876 rw_assert_wrlock(&sc->sc_lock); 1877 1878 va_start(ap, fmt); 1879 bio_status(&sc->sc_status, 1, BIO_MSG_WARN, fmt, &ap); 1880 va_end(ap); 1881 } 1882 1883 void 1884 sr_error(struct sr_softc *sc, const char *fmt, ...) 1885 { 1886 va_list ap; 1887 1888 rw_assert_wrlock(&sc->sc_lock); 1889 1890 va_start(ap, fmt); 1891 bio_status(&sc->sc_status, 1, BIO_MSG_ERROR, fmt, &ap); 1892 va_end(ap); 1893 } 1894 1895 void 1896 sr_minphys(struct buf *bp, struct scsi_link *sl) 1897 { 1898 DNPRINTF(SR_D_MISC, "sr_minphys: %d\n", bp->b_bcount); 1899 1900 /* XXX currently using SR_MAXFER = MAXPHYS */ 1901 if (bp->b_bcount > SR_MAXFER) 1902 bp->b_bcount = SR_MAXFER; 1903 minphys(bp); 1904 } 1905 1906 void 1907 sr_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size) 1908 { 1909 size_t copy_cnt; 1910 1911 DNPRINTF(SR_D_MISC, "sr_copy_internal_data xs: %p size: %d\n", 1912 xs, size); 1913 1914 if (xs->datalen) { 1915 copy_cnt = MIN(size, xs->datalen); 1916 bcopy(v, xs->data, copy_cnt); 1917 } 1918 } 1919 1920 int 1921 sr_ccb_alloc(struct sr_discipline *sd) 1922 { 1923 struct sr_ccb *ccb; 1924 int i; 1925 1926 if (!sd) 1927 return (1); 1928 1929 DNPRINTF(SR_D_CCB, "%s: sr_ccb_alloc\n", DEVNAME(sd->sd_sc)); 1930 1931 if (sd->sd_ccb) 1932 return (1); 1933 1934 sd->sd_ccb = malloc(sizeof(struct sr_ccb) * 1935 sd->sd_max_wu * sd->sd_max_ccb_per_wu, M_DEVBUF, M_WAITOK | M_ZERO); 1936 TAILQ_INIT(&sd->sd_ccb_freeq); 1937 for (i = 0; i < sd->sd_max_wu * sd->sd_max_ccb_per_wu; i++) { 1938 ccb = &sd->sd_ccb[i]; 1939 ccb->ccb_dis = sd; 1940 sr_ccb_put(ccb); 1941 } 1942 1943 DNPRINTF(SR_D_CCB, "%s: sr_ccb_alloc ccb: %d\n", 1944 DEVNAME(sd->sd_sc), sd->sd_max_wu * sd->sd_max_ccb_per_wu); 1945 1946 return (0); 1947 } 1948 1949 void 1950 sr_ccb_free(struct sr_discipline *sd) 1951 { 1952 struct sr_ccb *ccb; 1953 1954 if (!sd) 1955 return; 1956 1957 DNPRINTF(SR_D_CCB, "%s: sr_ccb_free %p\n", DEVNAME(sd->sd_sc), sd); 1958 1959 while ((ccb = TAILQ_FIRST(&sd->sd_ccb_freeq)) != NULL) 1960 TAILQ_REMOVE(&sd->sd_ccb_freeq, ccb, ccb_link); 1961 1962 if (sd->sd_ccb) 1963 free(sd->sd_ccb, M_DEVBUF); 1964 } 1965 1966 struct sr_ccb * 1967 sr_ccb_get(struct sr_discipline *sd) 1968 { 1969 struct sr_ccb *ccb; 1970 int s; 1971 1972 s = splbio(); 1973 1974 ccb = TAILQ_FIRST(&sd->sd_ccb_freeq); 1975 if (ccb) { 1976 TAILQ_REMOVE(&sd->sd_ccb_freeq, ccb, ccb_link); 1977 ccb->ccb_state = SR_CCB_INPROGRESS; 1978 } 1979 1980 splx(s); 1981 1982 DNPRINTF(SR_D_CCB, "%s: sr_ccb_get: %p\n", DEVNAME(sd->sd_sc), 1983 ccb); 1984 1985 return (ccb); 1986 } 1987 1988 void 1989 sr_ccb_put(struct sr_ccb *ccb) 1990 { 1991 struct sr_discipline *sd = ccb->ccb_dis; 1992 int s; 1993 1994 DNPRINTF(SR_D_CCB, "%s: sr_ccb_put: %p\n", DEVNAME(sd->sd_sc), 1995 ccb); 1996 1997 s = splbio(); 1998 1999 ccb->ccb_wu = NULL; 2000 ccb->ccb_state = SR_CCB_FREE; 2001 ccb->ccb_target = -1; 2002 ccb->ccb_opaque = NULL; 2003 2004 TAILQ_INSERT_TAIL(&sd->sd_ccb_freeq, ccb, ccb_link); 2005 2006 splx(s); 2007 } 2008 2009 struct sr_ccb * 2010 sr_ccb_rw(struct sr_discipline *sd, int chunk, daddr64_t blkno, 2011 daddr64_t len, u_int8_t *data, int xsflags, int ccbflag) 2012 { 2013 struct sr_chunk *sc = sd->sd_vol.sv_chunks[chunk]; 2014 struct sr_ccb *ccb = NULL; 2015 2016 ccb = sr_ccb_get(sd); 2017 if (ccb == NULL) 2018 goto out; 2019 2020 ccb->ccb_flag = ccbflag; 2021 ccb->ccb_target = chunk; 2022 2023 ccb->ccb_buf.b_flags = B_PHYS | B_CALL; 2024 if (ISSET(xsflags, SCSI_DATA_IN)) 2025 ccb->ccb_buf.b_flags |= B_READ; 2026 else 2027 ccb->ccb_buf.b_flags |= B_WRITE; 2028 2029 ccb->ccb_buf.b_blkno = blkno; 2030 ccb->ccb_buf.b_bcount = len; 2031 ccb->ccb_buf.b_bufsize = len; 2032 ccb->ccb_buf.b_resid = len; 2033 ccb->ccb_buf.b_data = data; 2034 ccb->ccb_buf.b_error = 0; 2035 ccb->ccb_buf.b_iodone = sd->sd_scsi_intr; 2036 ccb->ccb_buf.b_proc = curproc; 2037 ccb->ccb_buf.b_dev = sc->src_dev_mm; 2038 ccb->ccb_buf.b_vp = sc->src_vn; 2039 ccb->ccb_buf.b_bq = NULL; 2040 2041 if (!ISSET(ccb->ccb_buf.b_flags, B_READ)) 2042 ccb->ccb_buf.b_vp->v_numoutput++; 2043 2044 LIST_INIT(&ccb->ccb_buf.b_dep); 2045 2046 DNPRINTF(SR_D_DIS, "%s: %s %s ccb " 2047 "b_bcount %d b_blkno %lld b_flags 0x%0x b_data %p\n", 2048 DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, sd->sd_name, 2049 ccb->ccb_buf.b_bcount, ccb->ccb_buf.b_blkno, 2050 ccb->ccb_buf.b_flags, ccb->ccb_buf.b_data); 2051 2052 out: 2053 return ccb; 2054 } 2055 2056 void 2057 sr_ccb_done(struct sr_ccb *ccb) 2058 { 2059 struct sr_workunit *wu = ccb->ccb_wu; 2060 struct sr_discipline *sd = wu->swu_dis; 2061 struct sr_softc *sc = sd->sd_sc; 2062 2063 DNPRINTF(SR_D_INTR, "%s: %s %s ccb done b_bcount %d b_resid %d" 2064 " b_flags 0x%0x block %lld target %d\n", 2065 DEVNAME(sc), sd->sd_meta->ssd_devname, sd->sd_name, 2066 ccb->ccb_buf.b_bcount, ccb->ccb_buf.b_resid, ccb->ccb_buf.b_flags, 2067 ccb->ccb_buf.b_blkno, ccb->ccb_target); 2068 2069 splassert(IPL_BIO); 2070 2071 if (ccb->ccb_target == -1) 2072 panic("%s: invalid target on wu: %p", DEVNAME(sc), wu); 2073 2074 if (ccb->ccb_buf.b_flags & B_ERROR) { 2075 DNPRINTF(SR_D_INTR, "%s: i/o error on block %lld target %d\n", 2076 DEVNAME(sc), ccb->ccb_buf.b_blkno, ccb->ccb_target); 2077 if (!ISSET(sd->sd_capabilities, SR_CAP_REDUNDANT)) 2078 printf("%s: i/o error on block %lld target %d " 2079 "b_error %d\n", DEVNAME(sc), ccb->ccb_buf.b_blkno, 2080 ccb->ccb_target, ccb->ccb_buf.b_error); 2081 ccb->ccb_state = SR_CCB_FAILED; 2082 sd->sd_set_chunk_state(sd, ccb->ccb_target, BIOC_SDOFFLINE); 2083 wu->swu_ios_failed++; 2084 } else { 2085 ccb->ccb_state = SR_CCB_OK; 2086 wu->swu_ios_succeeded++; 2087 } 2088 2089 wu->swu_ios_complete++; 2090 } 2091 2092 int 2093 sr_wu_alloc(struct sr_discipline *sd) 2094 { 2095 struct sr_workunit *wu; 2096 int i, no_wu; 2097 2098 if (!sd) 2099 return (1); 2100 2101 DNPRINTF(SR_D_WU, "%s: sr_wu_alloc %p %d\n", DEVNAME(sd->sd_sc), 2102 sd, sd->sd_max_wu); 2103 2104 if (sd->sd_wu) 2105 return (1); 2106 2107 no_wu = sd->sd_max_wu; 2108 sd->sd_wu_pending = no_wu; 2109 2110 sd->sd_wu = malloc(sizeof(struct sr_workunit) * no_wu, 2111 M_DEVBUF, M_WAITOK | M_ZERO); 2112 TAILQ_INIT(&sd->sd_wu_freeq); 2113 TAILQ_INIT(&sd->sd_wu_pendq); 2114 TAILQ_INIT(&sd->sd_wu_defq); 2115 for (i = 0; i < no_wu; i++) { 2116 wu = &sd->sd_wu[i]; 2117 TAILQ_INIT(&wu->swu_ccb); 2118 sr_wu_put(sd, wu); 2119 } 2120 2121 return (0); 2122 } 2123 2124 void 2125 sr_wu_free(struct sr_discipline *sd) 2126 { 2127 struct sr_workunit *wu; 2128 2129 if (!sd) 2130 return; 2131 2132 DNPRINTF(SR_D_WU, "%s: sr_wu_free %p\n", DEVNAME(sd->sd_sc), sd); 2133 2134 while ((wu = TAILQ_FIRST(&sd->sd_wu_freeq)) != NULL) 2135 TAILQ_REMOVE(&sd->sd_wu_freeq, wu, swu_link); 2136 while ((wu = TAILQ_FIRST(&sd->sd_wu_pendq)) != NULL) 2137 TAILQ_REMOVE(&sd->sd_wu_pendq, wu, swu_link); 2138 while ((wu = TAILQ_FIRST(&sd->sd_wu_defq)) != NULL) 2139 TAILQ_REMOVE(&sd->sd_wu_defq, wu, swu_link); 2140 2141 if (sd->sd_wu) 2142 free(sd->sd_wu, M_DEVBUF); 2143 } 2144 2145 void * 2146 sr_wu_get(void *xsd) 2147 { 2148 struct sr_discipline *sd = (struct sr_discipline *)xsd; 2149 struct sr_workunit *wu; 2150 2151 mtx_enter(&sd->sd_wu_mtx); 2152 wu = TAILQ_FIRST(&sd->sd_wu_freeq); 2153 if (wu) { 2154 TAILQ_REMOVE(&sd->sd_wu_freeq, wu, swu_link); 2155 sd->sd_wu_pending++; 2156 } 2157 mtx_leave(&sd->sd_wu_mtx); 2158 2159 DNPRINTF(SR_D_WU, "%s: sr_wu_get: %p\n", DEVNAME(sd->sd_sc), wu); 2160 2161 return (wu); 2162 } 2163 2164 void 2165 sr_wu_put(void *xsd, void *xwu) 2166 { 2167 struct sr_discipline *sd = (struct sr_discipline *)xsd; 2168 struct sr_workunit *wu = (struct sr_workunit *)xwu; 2169 2170 DNPRINTF(SR_D_WU, "%s: sr_wu_put: %p\n", DEVNAME(sd->sd_sc), wu); 2171 2172 sr_wu_release_ccbs(wu); 2173 sr_wu_init(sd, wu); 2174 2175 mtx_enter(&sd->sd_wu_mtx); 2176 TAILQ_INSERT_TAIL(&sd->sd_wu_freeq, wu, swu_link); 2177 sd->sd_wu_pending--; 2178 mtx_leave(&sd->sd_wu_mtx); 2179 } 2180 2181 void 2182 sr_wu_init(struct sr_discipline *sd, struct sr_workunit *wu) 2183 { 2184 int s; 2185 2186 s = splbio(); 2187 if (wu->swu_cb_active == 1) 2188 panic("%s: sr_wu_init got active wu", DEVNAME(sd->sd_sc)); 2189 splx(s); 2190 2191 bzero(wu, sizeof(*wu)); 2192 TAILQ_INIT(&wu->swu_ccb); 2193 wu->swu_dis = sd; 2194 } 2195 2196 void 2197 sr_wu_enqueue_ccb(struct sr_workunit *wu, struct sr_ccb *ccb) 2198 { 2199 struct sr_discipline *sd = wu->swu_dis; 2200 int s; 2201 2202 s = splbio(); 2203 if (wu->swu_cb_active == 1) 2204 panic("%s: sr_wu_enqueue_ccb got active wu", 2205 DEVNAME(sd->sd_sc)); 2206 ccb->ccb_wu = wu; 2207 wu->swu_io_count++; 2208 TAILQ_INSERT_TAIL(&wu->swu_ccb, ccb, ccb_link); 2209 splx(s); 2210 } 2211 2212 void 2213 sr_wu_release_ccbs(struct sr_workunit *wu) 2214 { 2215 struct sr_ccb *ccb; 2216 2217 /* Return all ccbs that are associated with this workunit. */ 2218 while ((ccb = TAILQ_FIRST(&wu->swu_ccb)) != NULL) { 2219 TAILQ_REMOVE(&wu->swu_ccb, ccb, ccb_link); 2220 sr_ccb_put(ccb); 2221 } 2222 2223 wu->swu_io_count = 0; 2224 wu->swu_ios_complete = 0; 2225 wu->swu_ios_failed = 0; 2226 wu->swu_ios_succeeded = 0; 2227 } 2228 2229 void 2230 sr_wu_done(struct sr_workunit *wu) 2231 { 2232 struct sr_discipline *sd = wu->swu_dis; 2233 2234 DNPRINTF(SR_D_INTR, "%s: sr_wu_done count %d completed %d failed %d\n", 2235 DEVNAME(sd->sd_sc), wu->swu_io_count, wu->swu_ios_complete, 2236 wu->swu_ios_failed); 2237 2238 if (wu->swu_ios_complete < wu->swu_io_count) 2239 return; 2240 2241 workq_queue_task(sd->sd_workq, &wu->swu_wqt, 0, 2242 sr_wu_done_callback, sd, wu); 2243 } 2244 2245 void 2246 sr_wu_done_callback(void *arg1, void *arg2) 2247 { 2248 struct sr_discipline *sd = (struct sr_discipline *)arg1; 2249 struct sr_workunit *wu = (struct sr_workunit *)arg2; 2250 struct scsi_xfer *xs = wu->swu_xs; 2251 struct sr_workunit *wup; 2252 int s; 2253 2254 s = splbio(); 2255 2256 TAILQ_FOREACH(wup, &sd->sd_wu_pendq, swu_link) 2257 if (wup == wu) 2258 break; 2259 2260 if (wup == NULL) 2261 panic("%s: wu %p not on pending queue", 2262 DEVNAME(sd->sd_sc), wu); 2263 2264 TAILQ_REMOVE(&sd->sd_wu_pendq, wu, swu_link); 2265 2266 if (wu->swu_collider) { 2267 wu->swu_collider->swu_state = SR_WU_INPROGRESS; 2268 TAILQ_REMOVE(&sd->sd_wu_defq, wu->swu_collider, swu_link); 2269 sr_raid_startwu(wu->swu_collider); 2270 } 2271 2272 if (wu->swu_ios_failed) 2273 xs->error = XS_DRIVER_STUFFUP; 2274 else 2275 xs->error = XS_NOERROR; 2276 2277 /* 2278 * If a discipline provides its own sd_scsi_done function, then it 2279 * is responsible for calling sr_scsi_done() once I/O is complete. 2280 */ 2281 if (sd->sd_scsi_done) { 2282 sd->sd_scsi_done(wu); 2283 } else { 2284 sr_scsi_done(sd, xs); 2285 2286 /* XXX - move to sr_scsi_done? */ 2287 if (sd->sd_sync && sd->sd_wu_pending == 0) 2288 wakeup(sd); 2289 } 2290 2291 splx(s); 2292 } 2293 2294 void 2295 sr_scsi_done(struct sr_discipline *sd, struct scsi_xfer *xs) 2296 { 2297 DNPRINTF(SR_D_DIS, "%s: sr_scsi_done: xs %p\n", DEVNAME(sd->sd_sc), xs); 2298 2299 if (xs->error == XS_NOERROR) 2300 xs->resid = 0; 2301 2302 scsi_done(xs); 2303 } 2304 2305 void 2306 sr_scsi_cmd(struct scsi_xfer *xs) 2307 { 2308 struct scsi_link *link = xs->sc_link; 2309 struct sr_softc *sc = link->adapter_softc; 2310 struct sr_workunit *wu = xs->io; 2311 struct sr_discipline *sd; 2312 2313 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: target %d xs: %p " 2314 "flags: %#x\n", DEVNAME(sc), link->target, xs, xs->flags); 2315 2316 sd = sc->sc_targets[link->target]; 2317 if (sd == NULL) { 2318 printf("%s: sr_scsi_cmd NULL discipline\n", DEVNAME(sc)); 2319 goto stuffup; 2320 } 2321 2322 if (sd->sd_deleted) { 2323 printf("%s: %s device is being deleted, failing io\n", 2324 DEVNAME(sc), sd->sd_meta->ssd_devname); 2325 goto stuffup; 2326 } 2327 2328 /* scsi layer *can* re-send wu without calling sr_wu_put(). */ 2329 sr_wu_release_ccbs(wu); 2330 sr_wu_init(sd, wu); 2331 wu->swu_state = SR_WU_INPROGRESS; 2332 wu->swu_xs = xs; 2333 2334 switch (xs->cmd->opcode) { 2335 case READ_COMMAND: 2336 case READ_BIG: 2337 case READ_16: 2338 case WRITE_COMMAND: 2339 case WRITE_BIG: 2340 case WRITE_16: 2341 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: READ/WRITE %02x\n", 2342 DEVNAME(sc), xs->cmd->opcode); 2343 if (sd->sd_scsi_rw(wu)) 2344 goto stuffup; 2345 break; 2346 2347 case SYNCHRONIZE_CACHE: 2348 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: SYNCHRONIZE_CACHE\n", 2349 DEVNAME(sc)); 2350 if (sd->sd_scsi_sync(wu)) 2351 goto stuffup; 2352 goto complete; 2353 2354 case TEST_UNIT_READY: 2355 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: TEST_UNIT_READY\n", 2356 DEVNAME(sc)); 2357 if (sd->sd_scsi_tur(wu)) 2358 goto stuffup; 2359 goto complete; 2360 2361 case START_STOP: 2362 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: START_STOP\n", 2363 DEVNAME(sc)); 2364 if (sd->sd_scsi_start_stop(wu)) 2365 goto stuffup; 2366 goto complete; 2367 2368 case INQUIRY: 2369 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd: INQUIRY\n", 2370 DEVNAME(sc)); 2371 if (sd->sd_scsi_inquiry(wu)) 2372 goto stuffup; 2373 goto complete; 2374 2375 case READ_CAPACITY: 2376 case READ_CAPACITY_16: 2377 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd READ CAPACITY 0x%02x\n", 2378 DEVNAME(sc), xs->cmd->opcode); 2379 if (sd->sd_scsi_read_cap(wu)) 2380 goto stuffup; 2381 goto complete; 2382 2383 case REQUEST_SENSE: 2384 DNPRINTF(SR_D_CMD, "%s: sr_scsi_cmd REQUEST SENSE\n", 2385 DEVNAME(sc)); 2386 if (sd->sd_scsi_req_sense(wu)) 2387 goto stuffup; 2388 goto complete; 2389 2390 default: 2391 DNPRINTF(SR_D_CMD, "%s: unsupported scsi command %x\n", 2392 DEVNAME(sc), xs->cmd->opcode); 2393 /* XXX might need to add generic function to handle others */ 2394 goto stuffup; 2395 } 2396 2397 return; 2398 stuffup: 2399 if (sd && sd->sd_scsi_sense.error_code) { 2400 xs->error = XS_SENSE; 2401 bcopy(&sd->sd_scsi_sense, &xs->sense, sizeof(xs->sense)); 2402 bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense)); 2403 } else { 2404 xs->error = XS_DRIVER_STUFFUP; 2405 } 2406 complete: 2407 sr_scsi_done(sd, xs); 2408 } 2409 2410 int 2411 sr_scsi_probe(struct scsi_link *link) 2412 { 2413 struct sr_softc *sc = link->adapter_softc; 2414 struct sr_discipline *sd; 2415 2416 KASSERT(link->target < SR_MAX_LD && link->lun == 0); 2417 2418 sd = sc->sc_targets[link->target]; 2419 if (sd == NULL) 2420 return (ENODEV); 2421 2422 link->pool = &sd->sd_iopool; 2423 if (sd->sd_openings) 2424 link->openings = sd->sd_openings(sd); 2425 else 2426 link->openings = sd->sd_max_wu; 2427 2428 return (0); 2429 } 2430 2431 int 2432 sr_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag) 2433 { 2434 DNPRINTF(SR_D_IOCTL, "%s: sr_scsi_ioctl cmd: %#x\n", 2435 DEVNAME((struct sr_softc *)link->adapter_softc), cmd); 2436 2437 /* Pass bio ioctls through to bio handler. */ 2438 if (IOCGROUP(cmd) == 'B') 2439 return (sr_bio_ioctl(link->adapter_softc, cmd, addr)); 2440 2441 switch (cmd) { 2442 case DIOCGCACHE: 2443 case DIOCSCACHE: 2444 return (EOPNOTSUPP); 2445 default: 2446 return (ENOTTY); 2447 } 2448 } 2449 2450 int 2451 sr_bio_ioctl(struct device *dev, u_long cmd, caddr_t addr) 2452 { 2453 struct sr_softc *sc = (struct sr_softc *)dev; 2454 struct bio *bio = (struct bio *)addr; 2455 int rv = 0; 2456 2457 DNPRINTF(SR_D_IOCTL, "%s: sr_bio_ioctl ", DEVNAME(sc)); 2458 2459 rw_enter_write(&sc->sc_lock); 2460 2461 bio_status_init(&sc->sc_status, &sc->sc_dev); 2462 2463 switch (cmd) { 2464 case BIOCINQ: 2465 DNPRINTF(SR_D_IOCTL, "inq\n"); 2466 rv = sr_ioctl_inq(sc, (struct bioc_inq *)addr); 2467 break; 2468 2469 case BIOCVOL: 2470 DNPRINTF(SR_D_IOCTL, "vol\n"); 2471 rv = sr_ioctl_vol(sc, (struct bioc_vol *)addr); 2472 break; 2473 2474 case BIOCDISK: 2475 DNPRINTF(SR_D_IOCTL, "disk\n"); 2476 rv = sr_ioctl_disk(sc, (struct bioc_disk *)addr); 2477 break; 2478 2479 case BIOCALARM: 2480 DNPRINTF(SR_D_IOCTL, "alarm\n"); 2481 /*rv = sr_ioctl_alarm(sc, (struct bioc_alarm *)addr); */ 2482 break; 2483 2484 case BIOCBLINK: 2485 DNPRINTF(SR_D_IOCTL, "blink\n"); 2486 /*rv = sr_ioctl_blink(sc, (struct bioc_blink *)addr); */ 2487 break; 2488 2489 case BIOCSETSTATE: 2490 DNPRINTF(SR_D_IOCTL, "setstate\n"); 2491 rv = sr_ioctl_setstate(sc, (struct bioc_setstate *)addr); 2492 break; 2493 2494 case BIOCCREATERAID: 2495 DNPRINTF(SR_D_IOCTL, "createraid\n"); 2496 rv = sr_ioctl_createraid(sc, (struct bioc_createraid *)addr, 2497 1, NULL); 2498 break; 2499 2500 case BIOCDELETERAID: 2501 DNPRINTF(SR_D_IOCTL, "deleteraid\n"); 2502 rv = sr_ioctl_deleteraid(sc, (struct bioc_deleteraid *)addr); 2503 break; 2504 2505 case BIOCDISCIPLINE: 2506 DNPRINTF(SR_D_IOCTL, "discipline\n"); 2507 rv = sr_ioctl_discipline(sc, (struct bioc_discipline *)addr); 2508 break; 2509 2510 case BIOCINSTALLBOOT: 2511 DNPRINTF(SR_D_IOCTL, "installboot\n"); 2512 rv = sr_ioctl_installboot(sc, (struct bioc_installboot *)addr); 2513 break; 2514 2515 default: 2516 DNPRINTF(SR_D_IOCTL, "invalid ioctl\n"); 2517 rv = ENOTTY; 2518 } 2519 2520 sc->sc_status.bs_status = (rv ? BIO_STATUS_ERROR : BIO_STATUS_SUCCESS); 2521 2522 bcopy(&sc->sc_status, &bio->bio_status, sizeof(struct bio_status)); 2523 2524 rw_exit_write(&sc->sc_lock); 2525 2526 return (0); 2527 } 2528 2529 int 2530 sr_ioctl_inq(struct sr_softc *sc, struct bioc_inq *bi) 2531 { 2532 struct sr_discipline *sd; 2533 int vol = 0, disk = 0; 2534 2535 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 2536 vol++; 2537 disk += sd->sd_meta->ssdi.ssd_chunk_no; 2538 } 2539 2540 strlcpy(bi->bi_dev, sc->sc_dev.dv_xname, sizeof(bi->bi_dev)); 2541 bi->bi_novol = vol + sc->sc_hotspare_no; 2542 bi->bi_nodisk = disk + sc->sc_hotspare_no; 2543 2544 return (0); 2545 } 2546 2547 int 2548 sr_ioctl_vol(struct sr_softc *sc, struct bioc_vol *bv) 2549 { 2550 int vol = -1, rv = EINVAL; 2551 struct sr_discipline *sd; 2552 struct sr_chunk *hotspare; 2553 daddr64_t rb, sz; 2554 2555 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 2556 vol++; 2557 if (vol != bv->bv_volid) 2558 continue; 2559 2560 bv->bv_status = sd->sd_vol_status; 2561 bv->bv_size = sd->sd_meta->ssdi.ssd_size << DEV_BSHIFT; 2562 bv->bv_level = sd->sd_meta->ssdi.ssd_level; 2563 bv->bv_nodisk = sd->sd_meta->ssdi.ssd_chunk_no; 2564 2565 #ifdef CRYPTO 2566 if (sd->sd_meta->ssdi.ssd_level == 'C' && 2567 sd->mds.mdd_crypto.key_disk != NULL) 2568 bv->bv_nodisk++; 2569 #endif 2570 2571 if (bv->bv_status == BIOC_SVREBUILD) { 2572 sz = sd->sd_meta->ssdi.ssd_size; 2573 rb = sd->sd_meta->ssd_rebuild; 2574 if (rb > 0) 2575 bv->bv_percent = 100 - 2576 ((sz * 100 - rb * 100) / sz) - 1; 2577 else 2578 bv->bv_percent = 0; 2579 } 2580 strlcpy(bv->bv_dev, sd->sd_meta->ssd_devname, 2581 sizeof(bv->bv_dev)); 2582 strlcpy(bv->bv_vendor, sd->sd_meta->ssdi.ssd_vendor, 2583 sizeof(bv->bv_vendor)); 2584 rv = 0; 2585 goto done; 2586 } 2587 2588 /* Check hotspares list. */ 2589 SLIST_FOREACH(hotspare, &sc->sc_hotspare_list, src_link) { 2590 vol++; 2591 if (vol != bv->bv_volid) 2592 continue; 2593 2594 bv->bv_status = BIOC_SVONLINE; 2595 bv->bv_size = hotspare->src_meta.scmi.scm_size << DEV_BSHIFT; 2596 bv->bv_level = -1; /* Hotspare. */ 2597 bv->bv_nodisk = 1; 2598 strlcpy(bv->bv_dev, hotspare->src_meta.scmi.scm_devname, 2599 sizeof(bv->bv_dev)); 2600 strlcpy(bv->bv_vendor, hotspare->src_meta.scmi.scm_devname, 2601 sizeof(bv->bv_vendor)); 2602 rv = 0; 2603 goto done; 2604 } 2605 2606 done: 2607 return (rv); 2608 } 2609 2610 int 2611 sr_ioctl_disk(struct sr_softc *sc, struct bioc_disk *bd) 2612 { 2613 struct sr_discipline *sd; 2614 struct sr_chunk *src, *hotspare; 2615 int vol = -1, rv = EINVAL; 2616 2617 if (bd->bd_diskid < 0) 2618 goto done; 2619 2620 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 2621 vol++; 2622 if (vol != bd->bd_volid) 2623 continue; 2624 2625 if (bd->bd_diskid < sd->sd_meta->ssdi.ssd_chunk_no) 2626 src = sd->sd_vol.sv_chunks[bd->bd_diskid]; 2627 #ifdef CRYPTO 2628 else if (bd->bd_diskid == sd->sd_meta->ssdi.ssd_chunk_no && 2629 sd->sd_meta->ssdi.ssd_level == 'C' && 2630 sd->mds.mdd_crypto.key_disk != NULL) 2631 src = sd->mds.mdd_crypto.key_disk; 2632 #endif 2633 else 2634 break; 2635 2636 bd->bd_status = src->src_meta.scm_status; 2637 bd->bd_size = src->src_meta.scmi.scm_size << DEV_BSHIFT; 2638 bd->bd_channel = vol; 2639 bd->bd_target = bd->bd_diskid; 2640 strlcpy(bd->bd_vendor, src->src_meta.scmi.scm_devname, 2641 sizeof(bd->bd_vendor)); 2642 rv = 0; 2643 goto done; 2644 } 2645 2646 /* Check hotspares list. */ 2647 SLIST_FOREACH(hotspare, &sc->sc_hotspare_list, src_link) { 2648 vol++; 2649 if (vol != bd->bd_volid) 2650 continue; 2651 2652 if (bd->bd_diskid != 0) 2653 break; 2654 2655 bd->bd_status = hotspare->src_meta.scm_status; 2656 bd->bd_size = hotspare->src_meta.scmi.scm_size << DEV_BSHIFT; 2657 bd->bd_channel = vol; 2658 bd->bd_target = bd->bd_diskid; 2659 strlcpy(bd->bd_vendor, hotspare->src_meta.scmi.scm_devname, 2660 sizeof(bd->bd_vendor)); 2661 rv = 0; 2662 goto done; 2663 } 2664 2665 done: 2666 return (rv); 2667 } 2668 2669 int 2670 sr_ioctl_setstate(struct sr_softc *sc, struct bioc_setstate *bs) 2671 { 2672 int rv = EINVAL; 2673 int vol = -1, found, c; 2674 struct sr_discipline *sd; 2675 struct sr_chunk *ch_entry; 2676 struct sr_chunk_head *cl; 2677 2678 if (bs->bs_other_id_type == BIOC_SSOTHER_UNUSED) 2679 goto done; 2680 2681 if (bs->bs_status == BIOC_SSHOTSPARE) { 2682 rv = sr_hotspare(sc, (dev_t)bs->bs_other_id); 2683 goto done; 2684 } 2685 2686 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 2687 vol++; 2688 if (vol == bs->bs_volid) 2689 break; 2690 } 2691 if (sd == NULL) 2692 goto done; 2693 2694 switch (bs->bs_status) { 2695 case BIOC_SSOFFLINE: 2696 /* Take chunk offline */ 2697 found = c = 0; 2698 cl = &sd->sd_vol.sv_chunk_list; 2699 SLIST_FOREACH(ch_entry, cl, src_link) { 2700 if (ch_entry->src_dev_mm == bs->bs_other_id) { 2701 found = 1; 2702 break; 2703 } 2704 c++; 2705 } 2706 if (found == 0) { 2707 sr_error(sc, "chunk not part of array"); 2708 goto done; 2709 } 2710 2711 /* XXX: check current state first */ 2712 sd->sd_set_chunk_state(sd, c, BIOC_SDOFFLINE); 2713 2714 if (sr_meta_save(sd, SR_META_DIRTY)) { 2715 sr_error(sc, "could not save metadata for %s", 2716 sd->sd_meta->ssd_devname); 2717 goto done; 2718 } 2719 rv = 0; 2720 break; 2721 2722 case BIOC_SDSCRUB: 2723 break; 2724 2725 case BIOC_SSREBUILD: 2726 rv = sr_rebuild_init(sd, (dev_t)bs->bs_other_id, 0); 2727 break; 2728 2729 default: 2730 sr_error(sc, "unsupported state request %d", bs->bs_status); 2731 } 2732 2733 done: 2734 return (rv); 2735 } 2736 2737 int 2738 sr_chunk_in_use(struct sr_softc *sc, dev_t dev) 2739 { 2740 struct sr_discipline *sd; 2741 struct sr_chunk *chunk; 2742 int i; 2743 2744 DNPRINTF(SR_D_MISC, "%s: sr_chunk_in_use(%d)\n", DEVNAME(sc), dev); 2745 2746 if (dev == NODEV) 2747 return BIOC_SDINVALID; 2748 2749 /* See if chunk is already in use. */ 2750 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 2751 for (i = 0; i < sd->sd_meta->ssdi.ssd_chunk_no; i++) { 2752 chunk = sd->sd_vol.sv_chunks[i]; 2753 if (chunk->src_dev_mm == dev) 2754 return chunk->src_meta.scm_status; 2755 } 2756 } 2757 2758 /* Check hotspares list. */ 2759 SLIST_FOREACH(chunk, &sc->sc_hotspare_list, src_link) 2760 if (chunk->src_dev_mm == dev) 2761 return chunk->src_meta.scm_status; 2762 2763 return BIOC_SDINVALID; 2764 } 2765 2766 int 2767 sr_hotspare(struct sr_softc *sc, dev_t dev) 2768 { 2769 struct sr_discipline *sd = NULL; 2770 struct sr_metadata *sm = NULL; 2771 struct sr_meta_chunk *hm; 2772 struct sr_chunk_head *cl; 2773 struct sr_chunk *chunk, *last, *hotspare = NULL; 2774 struct sr_uuid uuid; 2775 struct disklabel label; 2776 struct vnode *vn; 2777 daddr64_t size; 2778 char devname[32]; 2779 int rv = EINVAL; 2780 int c, part, open = 0; 2781 2782 /* 2783 * Add device to global hotspares list. 2784 */ 2785 2786 sr_meta_getdevname(sc, dev, devname, sizeof(devname)); 2787 2788 /* Make sure chunk is not already in use. */ 2789 c = sr_chunk_in_use(sc, dev); 2790 if (c != BIOC_SDINVALID && c != BIOC_SDOFFLINE) { 2791 if (c == BIOC_SDHOTSPARE) 2792 sr_error(sc, "%s is already a hotspare", devname); 2793 else 2794 sr_error(sc, "%s is already in use", devname); 2795 goto done; 2796 } 2797 2798 /* XXX - See if there is an existing degraded volume... */ 2799 2800 /* Open device. */ 2801 if (bdevvp(dev, &vn)) { 2802 sr_error(sc, "sr_hotspare: cannot allocate vnode"); 2803 goto done; 2804 } 2805 if (VOP_OPEN(vn, FREAD | FWRITE, NOCRED, curproc)) { 2806 DNPRINTF(SR_D_META,"%s: sr_hotspare cannot open %s\n", 2807 DEVNAME(sc), devname); 2808 vput(vn); 2809 goto fail; 2810 } 2811 open = 1; /* close dev on error */ 2812 2813 /* Get partition details. */ 2814 part = DISKPART(dev); 2815 if (VOP_IOCTL(vn, DIOCGDINFO, (caddr_t)&label, FREAD, 2816 NOCRED, curproc)) { 2817 DNPRINTF(SR_D_META, "%s: sr_hotspare ioctl failed\n", 2818 DEVNAME(sc)); 2819 VOP_CLOSE(vn, FREAD | FWRITE, NOCRED, curproc); 2820 vput(vn); 2821 goto fail; 2822 } 2823 if (label.d_secsize != DEV_BSIZE) { 2824 sr_error(sc, "%s has unsupported sector size (%d)", 2825 devname, label.d_secsize); 2826 goto fail; 2827 } 2828 if (label.d_partitions[part].p_fstype != FS_RAID) { 2829 sr_error(sc, "%s partition not of type RAID (%d)", 2830 devname, label.d_partitions[part].p_fstype); 2831 goto fail; 2832 } 2833 2834 /* Calculate partition size. */ 2835 size = DL_GETPSIZE(&label.d_partitions[part]) - SR_DATA_OFFSET; 2836 2837 /* 2838 * Create and populate chunk metadata. 2839 */ 2840 2841 sr_uuid_generate(&uuid); 2842 hotspare = malloc(sizeof(struct sr_chunk), M_DEVBUF, M_WAITOK | M_ZERO); 2843 2844 hotspare->src_dev_mm = dev; 2845 hotspare->src_vn = vn; 2846 strlcpy(hotspare->src_devname, devname, sizeof(hm->scmi.scm_devname)); 2847 hotspare->src_size = size; 2848 2849 hm = &hotspare->src_meta; 2850 hm->scmi.scm_volid = SR_HOTSPARE_VOLID; 2851 hm->scmi.scm_chunk_id = 0; 2852 hm->scmi.scm_size = size; 2853 hm->scmi.scm_coerced_size = size; 2854 strlcpy(hm->scmi.scm_devname, devname, sizeof(hm->scmi.scm_devname)); 2855 bcopy(&uuid, &hm->scmi.scm_uuid, sizeof(struct sr_uuid)); 2856 2857 sr_checksum(sc, hm, &hm->scm_checksum, 2858 sizeof(struct sr_meta_chunk_invariant)); 2859 2860 hm->scm_status = BIOC_SDHOTSPARE; 2861 2862 /* 2863 * Create and populate our own discipline and metadata. 2864 */ 2865 2866 sm = malloc(sizeof(struct sr_metadata), M_DEVBUF, M_WAITOK | M_ZERO); 2867 sm->ssdi.ssd_magic = SR_MAGIC; 2868 sm->ssdi.ssd_version = SR_META_VERSION; 2869 sm->ssd_ondisk = 0; 2870 sm->ssdi.ssd_vol_flags = 0; 2871 bcopy(&uuid, &sm->ssdi.ssd_uuid, sizeof(struct sr_uuid)); 2872 sm->ssdi.ssd_chunk_no = 1; 2873 sm->ssdi.ssd_volid = SR_HOTSPARE_VOLID; 2874 sm->ssdi.ssd_level = SR_HOTSPARE_LEVEL; 2875 sm->ssdi.ssd_size = size; 2876 strlcpy(sm->ssdi.ssd_vendor, "OPENBSD", sizeof(sm->ssdi.ssd_vendor)); 2877 snprintf(sm->ssdi.ssd_product, sizeof(sm->ssdi.ssd_product), 2878 "SR %s", "HOTSPARE"); 2879 snprintf(sm->ssdi.ssd_revision, sizeof(sm->ssdi.ssd_revision), 2880 "%03d", SR_META_VERSION); 2881 2882 sd = malloc(sizeof(struct sr_discipline), M_DEVBUF, M_WAITOK | M_ZERO); 2883 sd->sd_sc = sc; 2884 sd->sd_meta = sm; 2885 sd->sd_meta_type = SR_META_F_NATIVE; 2886 sd->sd_vol_status = BIOC_SVONLINE; 2887 strlcpy(sd->sd_name, "HOTSPARE", sizeof(sd->sd_name)); 2888 SLIST_INIT(&sd->sd_meta_opt); 2889 2890 /* Add chunk to volume. */ 2891 sd->sd_vol.sv_chunks = malloc(sizeof(struct sr_chunk *), M_DEVBUF, 2892 M_WAITOK | M_ZERO); 2893 sd->sd_vol.sv_chunks[0] = hotspare; 2894 SLIST_INIT(&sd->sd_vol.sv_chunk_list); 2895 SLIST_INSERT_HEAD(&sd->sd_vol.sv_chunk_list, hotspare, src_link); 2896 2897 /* Save metadata. */ 2898 if (sr_meta_save(sd, SR_META_DIRTY)) { 2899 sr_error(sc, "could not save metadata to %s", devname); 2900 goto fail; 2901 } 2902 2903 /* 2904 * Add chunk to hotspare list. 2905 */ 2906 rw_enter_write(&sc->sc_hs_lock); 2907 cl = &sc->sc_hotspare_list; 2908 if (SLIST_EMPTY(cl)) 2909 SLIST_INSERT_HEAD(cl, hotspare, src_link); 2910 else { 2911 SLIST_FOREACH(chunk, cl, src_link) 2912 last = chunk; 2913 SLIST_INSERT_AFTER(last, hotspare, src_link); 2914 } 2915 sc->sc_hotspare_no++; 2916 rw_exit_write(&sc->sc_hs_lock); 2917 2918 rv = 0; 2919 goto done; 2920 2921 fail: 2922 if (hotspare) 2923 free(hotspare, M_DEVBUF); 2924 2925 done: 2926 if (sd && sd->sd_vol.sv_chunks) 2927 free(sd->sd_vol.sv_chunks, M_DEVBUF); 2928 if (sd) 2929 free(sd, M_DEVBUF); 2930 if (sm) 2931 free(sm, M_DEVBUF); 2932 if (open) { 2933 VOP_CLOSE(vn, FREAD | FWRITE, NOCRED, curproc); 2934 vput(vn); 2935 } 2936 2937 return (rv); 2938 } 2939 2940 void 2941 sr_hotspare_rebuild_callback(void *arg1, void *arg2) 2942 { 2943 sr_hotspare_rebuild((struct sr_discipline *)arg1); 2944 } 2945 2946 void 2947 sr_hotspare_rebuild(struct sr_discipline *sd) 2948 { 2949 struct sr_softc *sc = sd->sd_sc; 2950 struct sr_chunk_head *cl; 2951 struct sr_chunk *hotspare, *chunk = NULL; 2952 struct sr_workunit *wu; 2953 struct sr_ccb *ccb; 2954 int i, s, chunk_no, busy; 2955 2956 /* 2957 * Attempt to locate a hotspare and initiate rebuild. 2958 */ 2959 2960 for (i = 0; i < sd->sd_meta->ssdi.ssd_chunk_no; i++) { 2961 if (sd->sd_vol.sv_chunks[i]->src_meta.scm_status == 2962 BIOC_SDOFFLINE) { 2963 chunk_no = i; 2964 chunk = sd->sd_vol.sv_chunks[i]; 2965 break; 2966 } 2967 } 2968 2969 if (chunk == NULL) { 2970 printf("%s: no offline chunk found on %s!\n", 2971 DEVNAME(sc), sd->sd_meta->ssd_devname); 2972 return; 2973 } 2974 2975 /* See if we have a suitable hotspare... */ 2976 rw_enter_write(&sc->sc_hs_lock); 2977 cl = &sc->sc_hotspare_list; 2978 SLIST_FOREACH(hotspare, cl, src_link) 2979 if (hotspare->src_size >= chunk->src_size) 2980 break; 2981 2982 if (hotspare != NULL) { 2983 2984 printf("%s: %s volume degraded, will attempt to " 2985 "rebuild on hotspare %s\n", DEVNAME(sc), 2986 sd->sd_meta->ssd_devname, hotspare->src_devname); 2987 2988 /* 2989 * Ensure that all pending I/O completes on the failed chunk 2990 * before trying to initiate a rebuild. 2991 */ 2992 i = 0; 2993 do { 2994 busy = 0; 2995 2996 s = splbio(); 2997 TAILQ_FOREACH(wu, &sd->sd_wu_pendq, swu_link) { 2998 TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link) { 2999 if (ccb->ccb_target == chunk_no) 3000 busy = 1; 3001 } 3002 } 3003 TAILQ_FOREACH(wu, &sd->sd_wu_defq, swu_link) { 3004 TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link) { 3005 if (ccb->ccb_target == chunk_no) 3006 busy = 1; 3007 } 3008 } 3009 splx(s); 3010 3011 if (busy) { 3012 tsleep(sd, PRIBIO, "sr_hotspare", hz); 3013 i++; 3014 } 3015 3016 } while (busy && i < 120); 3017 3018 DNPRINTF(SR_D_META, "%s: waited %i seconds for I/O to " 3019 "complete on failed chunk %s\n", DEVNAME(sc), 3020 i, chunk->src_devname); 3021 3022 if (busy) { 3023 printf("%s: pending I/O failed to complete on " 3024 "failed chunk %s, hotspare rebuild aborted...\n", 3025 DEVNAME(sc), chunk->src_devname); 3026 goto done; 3027 } 3028 3029 s = splbio(); 3030 rw_enter_write(&sc->sc_lock); 3031 bio_status_init(&sc->sc_status, &sc->sc_dev); 3032 if (sr_rebuild_init(sd, hotspare->src_dev_mm, 1) == 0) { 3033 3034 /* Remove hotspare from available list. */ 3035 sc->sc_hotspare_no--; 3036 SLIST_REMOVE(cl, hotspare, sr_chunk, src_link); 3037 free(hotspare, M_DEVBUF); 3038 3039 } 3040 rw_exit_write(&sc->sc_lock); 3041 splx(s); 3042 } 3043 done: 3044 rw_exit_write(&sc->sc_hs_lock); 3045 } 3046 3047 int 3048 sr_rebuild_init(struct sr_discipline *sd, dev_t dev, int hotspare) 3049 { 3050 struct sr_softc *sc = sd->sd_sc; 3051 struct sr_chunk *chunk = NULL; 3052 struct sr_meta_chunk *meta; 3053 struct disklabel label; 3054 struct vnode *vn; 3055 daddr64_t size, csize; 3056 char devname[32]; 3057 int rv = EINVAL, open = 0; 3058 int cid, i, part, status; 3059 3060 /* 3061 * Attempt to initiate a rebuild onto the specified device. 3062 */ 3063 3064 if (!(sd->sd_capabilities & SR_CAP_REBUILD)) { 3065 sr_error(sc, "discipline does not support rebuild"); 3066 goto done; 3067 } 3068 3069 /* make sure volume is in the right state */ 3070 if (sd->sd_vol_status == BIOC_SVREBUILD) { 3071 sr_error(sc, "rebuild already in progress"); 3072 goto done; 3073 } 3074 if (sd->sd_vol_status != BIOC_SVDEGRADED) { 3075 sr_error(sc, "volume not degraded"); 3076 goto done; 3077 } 3078 3079 /* Find first offline chunk. */ 3080 for (cid = 0; cid < sd->sd_meta->ssdi.ssd_chunk_no; cid++) { 3081 if (sd->sd_vol.sv_chunks[cid]->src_meta.scm_status == 3082 BIOC_SDOFFLINE) { 3083 chunk = sd->sd_vol.sv_chunks[cid]; 3084 break; 3085 } 3086 } 3087 if (chunk == NULL) { 3088 sr_error(sc, "no offline chunks available to rebuild"); 3089 goto done; 3090 } 3091 3092 /* Get coerced size from another online chunk. */ 3093 for (i = 0; i < sd->sd_meta->ssdi.ssd_chunk_no; i++) { 3094 if (sd->sd_vol.sv_chunks[i]->src_meta.scm_status == 3095 BIOC_SDONLINE) { 3096 meta = &sd->sd_vol.sv_chunks[i]->src_meta; 3097 csize = meta->scmi.scm_coerced_size; 3098 break; 3099 } 3100 } 3101 3102 sr_meta_getdevname(sc, dev, devname, sizeof(devname)); 3103 if (bdevvp(dev, &vn)) { 3104 printf("%s: sr_rebuild_init: can't allocate vnode\n", 3105 DEVNAME(sc)); 3106 goto done; 3107 } 3108 if (VOP_OPEN(vn, FREAD | FWRITE, NOCRED, curproc)) { 3109 DNPRINTF(SR_D_META,"%s: sr_ioctl_setstate can't " 3110 "open %s\n", DEVNAME(sc), devname); 3111 vput(vn); 3112 goto done; 3113 } 3114 open = 1; /* close dev on error */ 3115 3116 /* Get disklabel and check partition. */ 3117 part = DISKPART(dev); 3118 if (VOP_IOCTL(vn, DIOCGDINFO, (caddr_t)&label, FREAD, 3119 NOCRED, curproc)) { 3120 DNPRINTF(SR_D_META, "%s: sr_ioctl_setstate ioctl failed\n", 3121 DEVNAME(sc)); 3122 goto done; 3123 } 3124 if (label.d_secsize != DEV_BSIZE) { 3125 sr_error(sc, "%s has unsupported sector size (%d)", 3126 devname, label.d_secsize); 3127 goto done; 3128 } 3129 if (label.d_partitions[part].p_fstype != FS_RAID) { 3130 sr_error(sc, "%s partition not of type RAID (%d)", 3131 devname, label.d_partitions[part].p_fstype); 3132 goto done; 3133 } 3134 3135 /* Is the partition large enough? */ 3136 size = DL_GETPSIZE(&label.d_partitions[part]) - SR_DATA_OFFSET; 3137 if (size < csize) { 3138 sr_error(sc, "%s partition too small, at least %llu bytes " 3139 "required", devname, csize << DEV_BSHIFT); 3140 goto done; 3141 } else if (size > csize) 3142 sr_warn(sc, "%s partition too large, wasting %llu bytes", 3143 devname, (size - csize) << DEV_BSHIFT); 3144 3145 /* Ensure that this chunk is not already in use. */ 3146 status = sr_chunk_in_use(sc, dev); 3147 if (status != BIOC_SDINVALID && status != BIOC_SDOFFLINE && 3148 !(hotspare && status == BIOC_SDHOTSPARE)) { 3149 sr_error(sc, "%s is already in use", devname); 3150 goto done; 3151 } 3152 3153 /* Reset rebuild counter since we rebuilding onto a new chunk. */ 3154 sd->sd_meta->ssd_rebuild = 0; 3155 3156 open = 0; /* leave dev open from here on out */ 3157 3158 /* Fix up chunk. */ 3159 bcopy(label.d_uid, chunk->src_duid, sizeof(chunk->src_duid)); 3160 chunk->src_dev_mm = dev; 3161 chunk->src_vn = vn; 3162 3163 /* Reconstruct metadata. */ 3164 meta = &chunk->src_meta; 3165 meta->scmi.scm_volid = sd->sd_meta->ssdi.ssd_volid; 3166 meta->scmi.scm_chunk_id = cid; 3167 strlcpy(meta->scmi.scm_devname, devname, 3168 sizeof(meta->scmi.scm_devname)); 3169 meta->scmi.scm_size = size; 3170 meta->scmi.scm_coerced_size = csize; 3171 bcopy(&sd->sd_meta->ssdi.ssd_uuid, &meta->scmi.scm_uuid, 3172 sizeof(meta->scmi.scm_uuid)); 3173 sr_checksum(sc, meta, &meta->scm_checksum, 3174 sizeof(struct sr_meta_chunk_invariant)); 3175 3176 sd->sd_set_chunk_state(sd, cid, BIOC_SDREBUILD); 3177 3178 if (sr_meta_save(sd, SR_META_DIRTY)) { 3179 sr_error(sc, "could not save metadata to %s", devname); 3180 open = 1; 3181 goto done; 3182 } 3183 3184 sr_warn(sc, "rebuild of %s started on %s", 3185 sd->sd_meta->ssd_devname, devname); 3186 3187 sd->sd_reb_abort = 0; 3188 kthread_create_deferred(sr_rebuild, sd); 3189 3190 rv = 0; 3191 done: 3192 if (open) { 3193 VOP_CLOSE(vn, FREAD | FWRITE, NOCRED, curproc); 3194 vput(vn); 3195 } 3196 3197 return (rv); 3198 } 3199 3200 void 3201 sr_roam_chunks(struct sr_discipline *sd) 3202 { 3203 struct sr_softc *sc = sd->sd_sc; 3204 struct sr_chunk *chunk; 3205 struct sr_meta_chunk *meta; 3206 int roamed = 0; 3207 3208 /* Have any chunks roamed? */ 3209 SLIST_FOREACH(chunk, &sd->sd_vol.sv_chunk_list, src_link) { 3210 meta = &chunk->src_meta; 3211 if (strncmp(meta->scmi.scm_devname, chunk->src_devname, 3212 sizeof(meta->scmi.scm_devname))) { 3213 3214 printf("%s: roaming device %s -> %s\n", DEVNAME(sc), 3215 meta->scmi.scm_devname, chunk->src_devname); 3216 3217 strlcpy(meta->scmi.scm_devname, chunk->src_devname, 3218 sizeof(meta->scmi.scm_devname)); 3219 3220 roamed++; 3221 } 3222 } 3223 3224 if (roamed) 3225 sr_meta_save(sd, SR_META_DIRTY); 3226 } 3227 3228 int 3229 sr_ioctl_createraid(struct sr_softc *sc, struct bioc_createraid *bc, 3230 int user, void *data) 3231 { 3232 struct sr_meta_opt_item *omi; 3233 struct sr_chunk_head *cl; 3234 struct sr_discipline *sd = NULL; 3235 struct sr_chunk *ch_entry; 3236 struct scsi_link *link; 3237 struct device *dev; 3238 char *uuid, devname[32]; 3239 dev_t *dt; 3240 int i, no_chunk, rv = EINVAL, target, vol; 3241 int no_meta; 3242 3243 DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_createraid(%d)\n", 3244 DEVNAME(sc), user); 3245 3246 /* user input */ 3247 if (bc->bc_dev_list_len > BIOC_CRMAXLEN) 3248 goto unwind; 3249 3250 dt = malloc(bc->bc_dev_list_len, M_DEVBUF, M_WAITOK | M_ZERO); 3251 if (user) { 3252 if (copyin(bc->bc_dev_list, dt, bc->bc_dev_list_len) != 0) 3253 goto unwind; 3254 } else 3255 bcopy(bc->bc_dev_list, dt, bc->bc_dev_list_len); 3256 3257 /* Initialise discipline. */ 3258 sd = malloc(sizeof(struct sr_discipline), M_DEVBUF, M_WAITOK | M_ZERO); 3259 sd->sd_sc = sc; 3260 SLIST_INIT(&sd->sd_meta_opt); 3261 sd->sd_workq = workq_create("srdis", 1, IPL_BIO); 3262 if (sd->sd_workq == NULL) { 3263 sr_error(sc, "could not create discipline workq"); 3264 goto unwind; 3265 } 3266 if (sr_discipline_init(sd, bc->bc_level)) { 3267 sr_error(sc, "could not initialize discipline"); 3268 goto unwind; 3269 } 3270 3271 no_chunk = bc->bc_dev_list_len / sizeof(dev_t); 3272 cl = &sd->sd_vol.sv_chunk_list; 3273 SLIST_INIT(cl); 3274 3275 /* Ensure that chunks are not already in use. */ 3276 for (i = 0; i < no_chunk; i++) { 3277 if (sr_chunk_in_use(sc, dt[i]) != BIOC_SDINVALID) { 3278 sr_meta_getdevname(sc, dt[i], devname, sizeof(devname)); 3279 sr_error(sc, "chunk %s already in use", devname); 3280 goto unwind; 3281 } 3282 } 3283 3284 sd->sd_meta_type = sr_meta_probe(sd, dt, no_chunk); 3285 if (sd->sd_meta_type == SR_META_F_INVALID) { 3286 sr_error(sc, "invalid metadata format"); 3287 goto unwind; 3288 } 3289 3290 if (sr_meta_attach(sd, no_chunk, bc->bc_flags & BIOC_SCFORCE)) 3291 goto unwind; 3292 3293 /* force the raid volume by clearing metadata region */ 3294 if (bc->bc_flags & BIOC_SCFORCE) { 3295 /* make sure disk isn't up and running */ 3296 if (sr_meta_read(sd)) 3297 if (sr_already_assembled(sd)) { 3298 uuid = sr_uuid_format( 3299 &sd->sd_meta->ssdi.ssd_uuid); 3300 sr_error(sc, "disk %s is currently in use; " 3301 "cannot force create", uuid); 3302 free(uuid, M_DEVBUF); 3303 goto unwind; 3304 } 3305 3306 if (sr_meta_clear(sd)) { 3307 sr_error(sc, "failed to clear metadata"); 3308 goto unwind; 3309 } 3310 } 3311 3312 no_meta = sr_meta_read(sd); 3313 if (no_meta == -1) { 3314 3315 /* Corrupt metadata on one or more chunks. */ 3316 sr_error(sc, "one of the chunks has corrupt metadata; " 3317 "aborting assembly"); 3318 goto unwind; 3319 3320 } else if (no_meta == 0) { 3321 3322 /* Initialise volume and chunk metadata. */ 3323 sr_meta_init(sd, bc->bc_level, no_chunk); 3324 sd->sd_vol_status = BIOC_SVONLINE; 3325 sd->sd_meta_flags = bc->bc_flags & BIOC_SCNOAUTOASSEMBLE; 3326 if (sd->sd_create) { 3327 if ((i = sd->sd_create(sd, bc, no_chunk, 3328 sd->sd_vol.sv_chunk_minsz))) { 3329 rv = i; 3330 goto unwind; 3331 } 3332 } 3333 sr_meta_init_complete(sd); 3334 3335 DNPRINTF(SR_D_IOCTL, 3336 "%s: sr_ioctl_createraid: vol_size: %lld\n", 3337 DEVNAME(sc), sd->sd_meta->ssdi.ssd_size); 3338 3339 /* Warn if we've wasted chunk space due to coercing. */ 3340 if ((sd->sd_capabilities & SR_CAP_NON_COERCED) == 0 && 3341 sd->sd_vol.sv_chunk_minsz != sd->sd_vol.sv_chunk_maxsz) 3342 sr_warn(sc, "chunk sizes are not equal; up to %llu " 3343 "blocks wasted per chunk", 3344 sd->sd_vol.sv_chunk_maxsz - 3345 sd->sd_vol.sv_chunk_minsz); 3346 3347 } else { 3348 3349 /* Ensure metadata level matches requested assembly level. */ 3350 if (sd->sd_meta->ssdi.ssd_level != bc->bc_level) { 3351 sr_error(sc, "volume level does not match metadata " 3352 "level"); 3353 goto unwind; 3354 } 3355 3356 if (sr_already_assembled(sd)) { 3357 uuid = sr_uuid_format(&sd->sd_meta->ssdi.ssd_uuid); 3358 sr_error(sc, "disk %s already assembled", uuid); 3359 free(uuid, M_DEVBUF); 3360 goto unwind; 3361 } 3362 3363 if (user == 0 && sd->sd_meta_flags & BIOC_SCNOAUTOASSEMBLE) { 3364 DNPRINTF(SR_D_META, "%s: disk not auto assembled from " 3365 "metadata\n", DEVNAME(sc)); 3366 goto unwind; 3367 } 3368 3369 if (no_meta != no_chunk) 3370 sr_warn(sc, "trying to bring up %s degraded", 3371 sd->sd_meta->ssd_devname); 3372 3373 if (sd->sd_meta->ssd_meta_flags & SR_META_DIRTY) 3374 sr_warn(sc, "%s was not shutdown properly", 3375 sd->sd_meta->ssd_devname); 3376 3377 SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link) 3378 if (sd->sd_meta_opt_handler == NULL || 3379 sd->sd_meta_opt_handler(sd, omi->omi_som) != 0) 3380 sr_meta_opt_handler(sd, omi->omi_som); 3381 3382 if (sd->sd_assemble) { 3383 if ((i = sd->sd_assemble(sd, bc, no_chunk, data))) { 3384 rv = i; 3385 goto unwind; 3386 } 3387 } 3388 3389 DNPRINTF(SR_D_META, "%s: disk assembled from metadata\n", 3390 DEVNAME(sc)); 3391 3392 } 3393 3394 /* Metadata MUST be fully populated by this point. */ 3395 TAILQ_INSERT_TAIL(&sc->sc_dis_list, sd, sd_link); 3396 3397 /* Allocate all resources. */ 3398 if ((rv = sd->sd_alloc_resources(sd))) 3399 goto unwind; 3400 3401 /* Adjust flags if necessary. */ 3402 if ((sd->sd_capabilities & SR_CAP_AUTO_ASSEMBLE) && 3403 (bc->bc_flags & BIOC_SCNOAUTOASSEMBLE) != 3404 (sd->sd_meta->ssdi.ssd_vol_flags & BIOC_SCNOAUTOASSEMBLE)) { 3405 sd->sd_meta->ssdi.ssd_vol_flags &= ~BIOC_SCNOAUTOASSEMBLE; 3406 sd->sd_meta->ssdi.ssd_vol_flags |= 3407 bc->bc_flags & BIOC_SCNOAUTOASSEMBLE; 3408 } 3409 3410 if (sd->sd_capabilities & SR_CAP_SYSTEM_DISK) { 3411 3412 /* Initialise volume state. */ 3413 sd->sd_set_vol_state(sd); 3414 if (sd->sd_vol_status == BIOC_SVOFFLINE) { 3415 sr_error(sc, "%s is offline, will not be brought " 3416 "online", sd->sd_meta->ssd_devname); 3417 goto unwind; 3418 } 3419 3420 /* Setup SCSI iopool. */ 3421 mtx_init(&sd->sd_wu_mtx, IPL_BIO); 3422 scsi_iopool_init(&sd->sd_iopool, sd, sr_wu_get, sr_wu_put); 3423 3424 /* 3425 * All checks passed - return ENXIO if volume cannot be created. 3426 */ 3427 rv = ENXIO; 3428 3429 /* 3430 * Find a free target. 3431 * 3432 * XXX: We reserve sd_target == 0 to indicate the 3433 * discipline is not linked into sc->sc_targets, so begin 3434 * the search with target = 1. 3435 */ 3436 for (target = 1; target < SR_MAX_LD; target++) 3437 if (sc->sc_targets[target] == NULL) 3438 break; 3439 if (target == SR_MAX_LD) { 3440 sr_error(sc, "no free target for %s", 3441 sd->sd_meta->ssd_devname); 3442 goto unwind; 3443 } 3444 3445 /* Clear sense data. */ 3446 bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense)); 3447 3448 /* Attach discipline and get midlayer to probe it. */ 3449 sd->sd_target = target; 3450 sc->sc_targets[target] = sd; 3451 if (scsi_probe_lun(sc->sc_scsibus, target, 0) != 0) { 3452 sr_error(sc, "scsi_probe_lun failed"); 3453 sc->sc_targets[target] = NULL; 3454 sd->sd_target = 0; 3455 goto unwind; 3456 } 3457 3458 link = scsi_get_link(sc->sc_scsibus, target, 0); 3459 dev = link->device_softc; 3460 DNPRINTF(SR_D_IOCTL, "%s: sr device added: %s at target %d\n", 3461 DEVNAME(sc), dev->dv_xname, sd->sd_target); 3462 3463 /* XXX - Count volumes, not targets. */ 3464 for (i = 0, vol = -1; i <= sd->sd_target; i++) 3465 if (sc->sc_targets[i]) 3466 vol++; 3467 3468 rv = 0; 3469 3470 if (sd->sd_meta->ssd_devname[0] != '\0' && 3471 strncmp(sd->sd_meta->ssd_devname, dev->dv_xname, 3472 sizeof(dev->dv_xname))) 3473 sr_warn(sc, "volume %s is roaming, it used to be %s, " 3474 "updating metadata", dev->dv_xname, 3475 sd->sd_meta->ssd_devname); 3476 3477 /* Populate remaining volume metadata. */ 3478 sd->sd_meta->ssdi.ssd_volid = vol; 3479 strlcpy(sd->sd_meta->ssd_devname, dev->dv_xname, 3480 sizeof(sd->sd_meta->ssd_devname)); 3481 3482 sr_info(sc, "%s volume attached as %s", 3483 sd->sd_meta->ssdi.ssd_product, sd->sd_meta->ssd_devname); 3484 3485 /* Update device name on any roaming chunks. */ 3486 sr_roam_chunks(sd); 3487 3488 #ifndef SMALL_KERNEL 3489 if (sr_sensors_create(sd)) 3490 sr_warn(sc, "unable to create sensor for %s", 3491 dev->dv_xname); 3492 #endif /* SMALL_KERNEL */ 3493 } else { 3494 /* This volume does not attach as a system disk. */ 3495 ch_entry = SLIST_FIRST(cl); /* XXX */ 3496 strlcpy(sd->sd_meta->ssd_devname, ch_entry->src_devname, 3497 sizeof(sd->sd_meta->ssd_devname)); 3498 3499 if (sd->sd_start_discipline(sd)) 3500 goto unwind; 3501 } 3502 3503 /* Save current metadata to disk. */ 3504 rv = sr_meta_save(sd, SR_META_DIRTY); 3505 3506 if (sd->sd_vol_status == BIOC_SVREBUILD) 3507 kthread_create_deferred(sr_rebuild, sd); 3508 3509 sd->sd_ready = 1; 3510 3511 return (rv); 3512 3513 unwind: 3514 sr_discipline_shutdown(sd, 0); 3515 3516 if (rv == EAGAIN) 3517 rv = 0; 3518 3519 return (rv); 3520 } 3521 3522 int 3523 sr_ioctl_deleteraid(struct sr_softc *sc, struct bioc_deleteraid *bd) 3524 { 3525 struct sr_discipline *sd; 3526 int rv = 1; 3527 3528 DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_deleteraid %s\n", DEVNAME(sc), 3529 dr->bd_dev); 3530 3531 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 3532 if (!strncmp(sd->sd_meta->ssd_devname, bd->bd_dev, 3533 sizeof(sd->sd_meta->ssd_devname))) 3534 break; 3535 } 3536 if (sd == NULL) { 3537 sr_error(sc, "volume %s not found", bd->bd_dev); 3538 goto bad; 3539 } 3540 3541 sd->sd_deleted = 1; 3542 sd->sd_meta->ssdi.ssd_vol_flags = BIOC_SCNOAUTOASSEMBLE; 3543 sr_discipline_shutdown(sd, 1); 3544 3545 rv = 0; 3546 bad: 3547 return (rv); 3548 } 3549 3550 int 3551 sr_ioctl_discipline(struct sr_softc *sc, struct bioc_discipline *bd) 3552 { 3553 struct sr_discipline *sd; 3554 int rv = 1; 3555 3556 /* Dispatch a discipline specific ioctl. */ 3557 3558 DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_discipline %s\n", DEVNAME(sc), 3559 bd->bd_dev); 3560 3561 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 3562 if (!strncmp(sd->sd_meta->ssd_devname, bd->bd_dev, 3563 sizeof(sd->sd_meta->ssd_devname))) 3564 break; 3565 } 3566 if (sd == NULL) { 3567 sr_error(sc, "volume %s not found", bd->bd_dev); 3568 goto bad; 3569 } 3570 3571 if (sd->sd_ioctl_handler) 3572 rv = sd->sd_ioctl_handler(sd, bd); 3573 3574 bad: 3575 return (rv); 3576 } 3577 3578 int 3579 sr_ioctl_installboot(struct sr_softc *sc, struct bioc_installboot *bb) 3580 { 3581 void *bootblk = NULL, *bootldr = NULL; 3582 struct sr_discipline *sd; 3583 struct sr_chunk *chunk; 3584 struct sr_meta_opt_item *omi; 3585 struct sr_meta_boot *sbm; 3586 struct disk *dk; 3587 u_int32_t bbs, bls; 3588 u_char duid[8]; 3589 int rv = EINVAL; 3590 int i; 3591 3592 DNPRINTF(SR_D_IOCTL, "%s: sr_ioctl_installboot %s\n", DEVNAME(sc), 3593 bb->bb_dev); 3594 3595 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 3596 if (!strncmp(sd->sd_meta->ssd_devname, bb->bb_dev, 3597 sizeof(sd->sd_meta->ssd_devname))) 3598 break; 3599 } 3600 if (sd == NULL) { 3601 sr_error(sc, "volume %s not found", bb->bb_dev); 3602 goto done; 3603 } 3604 3605 bzero(duid, sizeof(duid)); 3606 TAILQ_FOREACH(dk, &disklist, dk_link) 3607 if (!strncmp(dk->dk_name, bb->bb_dev, sizeof(bb->bb_dev))) 3608 break; 3609 if (dk == NULL || dk->dk_label == NULL || 3610 (dk->dk_flags & DKF_LABELVALID) == 0 || 3611 bcmp(dk->dk_label->d_uid, &duid, sizeof(duid)) == 0) { 3612 sr_error(sc, "failed to get DUID for softraid volume"); 3613 goto done; 3614 } 3615 bcopy(dk->dk_label->d_uid, duid, sizeof(duid)); 3616 3617 /* Ensure that boot storage area is large enough. */ 3618 if (sd->sd_meta->ssd_data_offset < (SR_BOOT_OFFSET + SR_BOOT_SIZE)) { 3619 sr_error(sc, "insufficient boot storage"); 3620 goto done; 3621 } 3622 3623 if (bb->bb_bootblk_size > SR_BOOT_BLOCKS_SIZE * 512) 3624 goto done; 3625 3626 if (bb->bb_bootldr_size > SR_BOOT_LOADER_SIZE * 512) 3627 goto done; 3628 3629 /* Copy in boot block. */ 3630 bbs = howmany(bb->bb_bootblk_size, DEV_BSIZE) * DEV_BSIZE; 3631 bootblk = malloc(bbs, M_DEVBUF, M_WAITOK | M_ZERO); 3632 if (copyin(bb->bb_bootblk, bootblk, bb->bb_bootblk_size) != 0) 3633 goto done; 3634 3635 /* Copy in boot loader. */ 3636 bls = howmany(bb->bb_bootldr_size, DEV_BSIZE) * DEV_BSIZE; 3637 bootldr = malloc(bls, M_DEVBUF, M_WAITOK | M_ZERO); 3638 if (copyin(bb->bb_bootldr, bootldr, bb->bb_bootldr_size) != 0) 3639 goto done; 3640 3641 /* Create or update optional meta for bootable volumes. */ 3642 SLIST_FOREACH(omi, &sd->sd_meta_opt, omi_link) 3643 if (omi->omi_som->som_type == SR_OPT_BOOT) 3644 break; 3645 if (omi == NULL) { 3646 omi = malloc(sizeof(struct sr_meta_opt_item), M_DEVBUF, 3647 M_WAITOK | M_ZERO); 3648 omi->omi_som = malloc(sizeof(struct sr_meta_crypto), M_DEVBUF, 3649 M_WAITOK | M_ZERO); 3650 omi->omi_som->som_type = SR_OPT_BOOT; 3651 omi->omi_som->som_length = sizeof(struct sr_meta_boot); 3652 SLIST_INSERT_HEAD(&sd->sd_meta_opt, omi, omi_link); 3653 sd->sd_meta->ssdi.ssd_opt_no++; 3654 } 3655 sbm = (struct sr_meta_boot *)omi->omi_som; 3656 3657 bcopy(duid, sbm->sbm_root_duid, sizeof(sbm->sbm_root_duid)); 3658 bzero(&sbm->sbm_boot_duid, sizeof(sbm->sbm_boot_duid)); 3659 sbm->sbm_bootblk_size = bbs; 3660 sbm->sbm_bootldr_size = bls; 3661 3662 DNPRINTF(SR_D_IOCTL, "sr_ioctl_installboot: root duid is " 3663 "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx\n", 3664 sbm->sbm_root_duid[0], sbm->sbm_root_duid[1], 3665 sbm->sbm_root_duid[2], sbm->sbm_root_duid[3], 3666 sbm->sbm_root_duid[4], sbm->sbm_root_duid[5], 3667 sbm->sbm_root_duid[6], sbm->sbm_root_duid[7]); 3668 3669 /* Save boot block and boot loader to each chunk. */ 3670 for (i = 0; i < sd->sd_meta->ssdi.ssd_chunk_no; i++) { 3671 3672 chunk = sd->sd_vol.sv_chunks[i]; 3673 if (chunk->src_meta.scm_status != BIOC_SDONLINE && 3674 chunk->src_meta.scm_status != BIOC_SDREBUILD) 3675 continue; 3676 3677 if (i < SR_MAX_BOOT_DISKS) 3678 bcopy(chunk->src_duid, &sbm->sbm_boot_duid[i], 3679 sizeof(sbm->sbm_boot_duid[i])); 3680 3681 /* Save boot blocks. */ 3682 DNPRINTF(SR_D_IOCTL, 3683 "sr_ioctl_installboot: saving boot block to %s " 3684 "(%u bytes)\n", chunk->src_devname, bbs); 3685 3686 if (sr_rw(sc, chunk->src_dev_mm, bootblk, bbs, 3687 SR_BOOT_BLOCKS_OFFSET, B_WRITE)) { 3688 sr_error(sc, "failed to write boot block", DEVNAME(sc)); 3689 goto done; 3690 } 3691 3692 /* Save boot loader.*/ 3693 DNPRINTF(SR_D_IOCTL, 3694 "sr_ioctl_installboot: saving boot loader to %s " 3695 "(%u bytes)\n", chunk->src_devname, bls); 3696 3697 if (sr_rw(sc, chunk->src_dev_mm, bootldr, bls, 3698 SR_BOOT_LOADER_OFFSET, B_WRITE)) { 3699 sr_error(sc, "failed to write boot loader"); 3700 goto done; 3701 } 3702 3703 } 3704 3705 /* XXX - Install boot block on disk - MD code. */ 3706 3707 /* Mark volume as bootable and save metadata. */ 3708 sd->sd_meta->ssdi.ssd_vol_flags |= BIOC_SCBOOTABLE; 3709 if (sr_meta_save(sd, SR_META_DIRTY)) { 3710 sr_error(sc, "could not save metadata to %s", 3711 chunk->src_devname); 3712 goto done; 3713 } 3714 3715 rv = 0; 3716 3717 done: 3718 if (bootblk) 3719 free(bootblk, M_DEVBUF); 3720 if (bootldr) 3721 free(bootldr, M_DEVBUF); 3722 3723 return (rv); 3724 } 3725 3726 void 3727 sr_chunks_unwind(struct sr_softc *sc, struct sr_chunk_head *cl) 3728 { 3729 struct sr_chunk *ch_entry, *ch_next; 3730 3731 DNPRINTF(SR_D_IOCTL, "%s: sr_chunks_unwind\n", DEVNAME(sc)); 3732 3733 if (!cl) 3734 return; 3735 3736 for (ch_entry = SLIST_FIRST(cl); 3737 ch_entry != SLIST_END(cl); ch_entry = ch_next) { 3738 ch_next = SLIST_NEXT(ch_entry, src_link); 3739 3740 DNPRINTF(SR_D_IOCTL, "%s: sr_chunks_unwind closing: %s\n", 3741 DEVNAME(sc), ch_entry->src_devname); 3742 if (ch_entry->src_vn) { 3743 /* 3744 * XXX - explicitly lock the vnode until we can resolve 3745 * the problem introduced by vnode aliasing... specfs 3746 * has no locking, whereas ufs/ffs does! 3747 */ 3748 vn_lock(ch_entry->src_vn, LK_EXCLUSIVE | 3749 LK_RETRY, curproc); 3750 VOP_CLOSE(ch_entry->src_vn, FREAD | FWRITE, NOCRED, 3751 curproc); 3752 vput(ch_entry->src_vn); 3753 } 3754 free(ch_entry, M_DEVBUF); 3755 } 3756 SLIST_INIT(cl); 3757 } 3758 3759 void 3760 sr_discipline_free(struct sr_discipline *sd) 3761 { 3762 struct sr_softc *sc; 3763 struct sr_discipline *sdtmp1, *sdtmp2; 3764 struct sr_meta_opt_head *som; 3765 struct sr_meta_opt_item *omi, *omi_next; 3766 3767 if (!sd) 3768 return; 3769 3770 sc = sd->sd_sc; 3771 3772 DNPRINTF(SR_D_DIS, "%s: sr_discipline_free %s\n", 3773 DEVNAME(sc), 3774 sd->sd_meta ? sd->sd_meta->ssd_devname : "nodev"); 3775 if (sd->sd_free_resources) 3776 sd->sd_free_resources(sd); 3777 if (sd->sd_vol.sv_chunks) 3778 free(sd->sd_vol.sv_chunks, M_DEVBUF); 3779 if (sd->sd_meta) 3780 free(sd->sd_meta, M_DEVBUF); 3781 if (sd->sd_meta_foreign) 3782 free(sd->sd_meta_foreign, M_DEVBUF); 3783 3784 som = &sd->sd_meta_opt; 3785 for (omi = SLIST_FIRST(som); omi != SLIST_END(som); omi = omi_next) { 3786 omi_next = SLIST_NEXT(omi, omi_link); 3787 if (omi->omi_som) 3788 free(omi->omi_som, M_DEVBUF); 3789 free(omi, M_DEVBUF); 3790 } 3791 3792 if (sd->sd_target != 0) { 3793 KASSERT(sc->sc_targets[sd->sd_target] == sd); 3794 sc->sc_targets[sd->sd_target] = NULL; 3795 } 3796 3797 TAILQ_FOREACH_SAFE(sdtmp1, &sc->sc_dis_list, sd_link, sdtmp2) { 3798 if (sdtmp1 == sd) { 3799 TAILQ_REMOVE(&sc->sc_dis_list, sd, sd_link); 3800 break; 3801 } 3802 } 3803 3804 explicit_bzero(sd, sizeof *sd); 3805 free(sd, M_DEVBUF); 3806 } 3807 3808 void 3809 sr_discipline_shutdown(struct sr_discipline *sd, int meta_save) 3810 { 3811 struct sr_softc *sc; 3812 int s; 3813 3814 if (!sd) 3815 return; 3816 sc = sd->sd_sc; 3817 3818 DNPRINTF(SR_D_DIS, "%s: sr_discipline_shutdown %s\n", DEVNAME(sc), 3819 sd->sd_meta ? sd->sd_meta->ssd_devname : "nodev"); 3820 3821 /* If rebuilding, abort rebuild and drain I/O. */ 3822 if (sd->sd_reb_active) { 3823 sd->sd_reb_abort = 1; 3824 while (sd->sd_reb_active) 3825 tsleep(sd, PWAIT, "sr_shutdown", 1); 3826 } 3827 3828 if (meta_save) 3829 sr_meta_save(sd, 0); 3830 3831 s = splbio(); 3832 3833 sd->sd_ready = 0; 3834 3835 /* make sure there isn't a sync pending and yield */ 3836 wakeup(sd); 3837 while (sd->sd_sync || sd->sd_must_flush) 3838 if (tsleep(&sd->sd_sync, MAXPRI, "sr_down", 60 * hz) == 3839 EWOULDBLOCK) 3840 break; 3841 3842 #ifndef SMALL_KERNEL 3843 sr_sensors_delete(sd); 3844 #endif /* SMALL_KERNEL */ 3845 3846 if (sd->sd_target != 0) 3847 scsi_detach_lun(sc->sc_scsibus, sd->sd_target, 0, DETACH_FORCE); 3848 3849 sr_chunks_unwind(sc, &sd->sd_vol.sv_chunk_list); 3850 3851 if (sd->sd_workq) 3852 workq_destroy(sd->sd_workq); 3853 3854 sr_discipline_free(sd); 3855 3856 splx(s); 3857 } 3858 3859 int 3860 sr_discipline_init(struct sr_discipline *sd, int level) 3861 { 3862 int rv = 1; 3863 3864 /* Initialise discipline function pointers with defaults. */ 3865 sd->sd_alloc_resources = NULL; 3866 sd->sd_assemble = NULL; 3867 sd->sd_create = NULL; 3868 sd->sd_free_resources = NULL; 3869 sd->sd_ioctl_handler = NULL; 3870 sd->sd_openings = NULL; 3871 sd->sd_meta_opt_handler = NULL; 3872 sd->sd_scsi_inquiry = sr_raid_inquiry; 3873 sd->sd_scsi_read_cap = sr_raid_read_cap; 3874 sd->sd_scsi_tur = sr_raid_tur; 3875 sd->sd_scsi_req_sense = sr_raid_request_sense; 3876 sd->sd_scsi_start_stop = sr_raid_start_stop; 3877 sd->sd_scsi_sync = sr_raid_sync; 3878 sd->sd_scsi_rw = NULL; 3879 sd->sd_scsi_intr = NULL; 3880 sd->sd_scsi_done = NULL; 3881 sd->sd_set_chunk_state = sr_set_chunk_state; 3882 sd->sd_set_vol_state = sr_set_vol_state; 3883 sd->sd_start_discipline = NULL; 3884 3885 switch (level) { 3886 case 0: 3887 sr_raid0_discipline_init(sd); 3888 break; 3889 case 1: 3890 sr_raid1_discipline_init(sd); 3891 break; 3892 case 4: 3893 sr_raidp_discipline_init(sd, SR_MD_RAID4); 3894 break; 3895 case 5: 3896 sr_raidp_discipline_init(sd, SR_MD_RAID5); 3897 break; 3898 case 6: 3899 sr_raid6_discipline_init(sd); 3900 break; 3901 #ifdef AOE 3902 /* AOE target. */ 3903 case 'A': 3904 sr_aoe_server_discipline_init(sd); 3905 break; 3906 /* AOE initiator. */ 3907 case 'a': 3908 sr_aoe_discipline_init(sd); 3909 break; 3910 #endif 3911 #ifdef CRYPTO 3912 case 'C': 3913 sr_crypto_discipline_init(sd); 3914 break; 3915 #endif 3916 case 'c': 3917 sr_concat_discipline_init(sd); 3918 break; 3919 default: 3920 goto bad; 3921 } 3922 3923 rv = 0; 3924 bad: 3925 return (rv); 3926 } 3927 3928 int 3929 sr_raid_inquiry(struct sr_workunit *wu) 3930 { 3931 struct sr_discipline *sd = wu->swu_dis; 3932 struct scsi_xfer *xs = wu->swu_xs; 3933 struct scsi_inquiry *cdb = (struct scsi_inquiry *)xs->cmd; 3934 struct scsi_inquiry_data inq; 3935 3936 DNPRINTF(SR_D_DIS, "%s: sr_raid_inquiry\n", DEVNAME(sd->sd_sc)); 3937 3938 if (xs->cmdlen != sizeof(*cdb)) 3939 return (EINVAL); 3940 3941 if (ISSET(cdb->flags, SI_EVPD)) 3942 return (EOPNOTSUPP); 3943 3944 bzero(&inq, sizeof(inq)); 3945 inq.device = T_DIRECT; 3946 inq.dev_qual2 = 0; 3947 inq.version = 2; 3948 inq.response_format = 2; 3949 inq.additional_length = 32; 3950 inq.flags |= SID_CmdQue; 3951 strlcpy(inq.vendor, sd->sd_meta->ssdi.ssd_vendor, 3952 sizeof(inq.vendor)); 3953 strlcpy(inq.product, sd->sd_meta->ssdi.ssd_product, 3954 sizeof(inq.product)); 3955 strlcpy(inq.revision, sd->sd_meta->ssdi.ssd_revision, 3956 sizeof(inq.revision)); 3957 sr_copy_internal_data(xs, &inq, sizeof(inq)); 3958 3959 return (0); 3960 } 3961 3962 int 3963 sr_raid_read_cap(struct sr_workunit *wu) 3964 { 3965 struct sr_discipline *sd = wu->swu_dis; 3966 struct scsi_xfer *xs = wu->swu_xs; 3967 struct scsi_read_cap_data rcd; 3968 struct scsi_read_cap_data_16 rcd16; 3969 daddr64_t addr; 3970 int rv = 1; 3971 3972 DNPRINTF(SR_D_DIS, "%s: sr_raid_read_cap\n", DEVNAME(sd->sd_sc)); 3973 3974 addr = sd->sd_meta->ssdi.ssd_size - 1; 3975 if (xs->cmd->opcode == READ_CAPACITY) { 3976 bzero(&rcd, sizeof(rcd)); 3977 if (addr > 0xffffffffllu) 3978 _lto4b(0xffffffff, rcd.addr); 3979 else 3980 _lto4b(addr, rcd.addr); 3981 _lto4b(512, rcd.length); 3982 sr_copy_internal_data(xs, &rcd, sizeof(rcd)); 3983 rv = 0; 3984 } else if (xs->cmd->opcode == READ_CAPACITY_16) { 3985 bzero(&rcd16, sizeof(rcd16)); 3986 _lto8b(addr, rcd16.addr); 3987 _lto4b(512, rcd16.length); 3988 sr_copy_internal_data(xs, &rcd16, sizeof(rcd16)); 3989 rv = 0; 3990 } 3991 3992 return (rv); 3993 } 3994 3995 int 3996 sr_raid_tur(struct sr_workunit *wu) 3997 { 3998 struct sr_discipline *sd = wu->swu_dis; 3999 4000 DNPRINTF(SR_D_DIS, "%s: sr_raid_tur\n", DEVNAME(sd->sd_sc)); 4001 4002 if (sd->sd_vol_status == BIOC_SVOFFLINE) { 4003 sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT; 4004 sd->sd_scsi_sense.flags = SKEY_NOT_READY; 4005 sd->sd_scsi_sense.add_sense_code = 0x04; 4006 sd->sd_scsi_sense.add_sense_code_qual = 0x11; 4007 sd->sd_scsi_sense.extra_len = 4; 4008 return (1); 4009 } else if (sd->sd_vol_status == BIOC_SVINVALID) { 4010 sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT; 4011 sd->sd_scsi_sense.flags = SKEY_HARDWARE_ERROR; 4012 sd->sd_scsi_sense.add_sense_code = 0x05; 4013 sd->sd_scsi_sense.add_sense_code_qual = 0x00; 4014 sd->sd_scsi_sense.extra_len = 4; 4015 return (1); 4016 } 4017 4018 return (0); 4019 } 4020 4021 int 4022 sr_raid_request_sense(struct sr_workunit *wu) 4023 { 4024 struct sr_discipline *sd = wu->swu_dis; 4025 struct scsi_xfer *xs = wu->swu_xs; 4026 4027 DNPRINTF(SR_D_DIS, "%s: sr_raid_request_sense\n", 4028 DEVNAME(sd->sd_sc)); 4029 4030 /* use latest sense data */ 4031 bcopy(&sd->sd_scsi_sense, &xs->sense, sizeof(xs->sense)); 4032 4033 /* clear sense data */ 4034 bzero(&sd->sd_scsi_sense, sizeof(sd->sd_scsi_sense)); 4035 4036 return (0); 4037 } 4038 4039 int 4040 sr_raid_start_stop(struct sr_workunit *wu) 4041 { 4042 struct scsi_xfer *xs = wu->swu_xs; 4043 struct scsi_start_stop *ss = (struct scsi_start_stop *)xs->cmd; 4044 4045 DNPRINTF(SR_D_DIS, "%s: sr_raid_start_stop\n", 4046 DEVNAME(wu->swu_dis->sd_sc)); 4047 4048 if (!ss) 4049 return (1); 4050 4051 /* 4052 * do nothing! 4053 * a softraid discipline should always reflect correct status 4054 */ 4055 return (0); 4056 } 4057 4058 int 4059 sr_raid_sync(struct sr_workunit *wu) 4060 { 4061 struct sr_discipline *sd = wu->swu_dis; 4062 int s, rv = 0, ios; 4063 4064 DNPRINTF(SR_D_DIS, "%s: sr_raid_sync\n", DEVNAME(sd->sd_sc)); 4065 4066 /* when doing a fake sync don't count the wu */ 4067 ios = wu->swu_fake ? 0 : 1; 4068 4069 s = splbio(); 4070 sd->sd_sync = 1; 4071 4072 while (sd->sd_wu_pending > ios) 4073 if (tsleep(sd, PRIBIO, "sr_sync", 15 * hz) == EWOULDBLOCK) { 4074 DNPRINTF(SR_D_DIS, "%s: sr_raid_sync timeout\n", 4075 DEVNAME(sd->sd_sc)); 4076 rv = 1; 4077 break; 4078 } 4079 4080 sd->sd_sync = 0; 4081 splx(s); 4082 4083 wakeup(&sd->sd_sync); 4084 4085 return (rv); 4086 } 4087 4088 void 4089 sr_startwu_callback(void *arg1, void *arg2) 4090 { 4091 struct sr_discipline *sd = arg1; 4092 struct sr_workunit *wu = arg2; 4093 struct sr_ccb *ccb; 4094 int s; 4095 4096 s = splbio(); 4097 if (wu->swu_cb_active == 1) 4098 panic("%s: sr_startwu_callback", DEVNAME(sd->sd_sc)); 4099 wu->swu_cb_active = 1; 4100 4101 TAILQ_FOREACH(ccb, &wu->swu_ccb, ccb_link) 4102 VOP_STRATEGY(&ccb->ccb_buf); 4103 4104 wu->swu_cb_active = 0; 4105 splx(s); 4106 } 4107 4108 void 4109 sr_raid_startwu(struct sr_workunit *wu) 4110 { 4111 struct sr_discipline *sd = wu->swu_dis; 4112 4113 splassert(IPL_BIO); 4114 4115 if (wu->swu_state == SR_WU_RESTART) 4116 /* 4117 * no need to put the wu on the pending queue since we 4118 * are restarting the io 4119 */ 4120 ; 4121 else 4122 /* move wu to pending queue */ 4123 TAILQ_INSERT_TAIL(&sd->sd_wu_pendq, wu, swu_link); 4124 4125 /* start all individual ios */ 4126 workq_queue_task(sd->sd_workq, &wu->swu_wqt, 0, sr_startwu_callback, 4127 sd, wu); 4128 } 4129 4130 void 4131 sr_raid_recreate_wu(struct sr_workunit *wu) 4132 { 4133 struct sr_discipline *sd = wu->swu_dis; 4134 struct sr_workunit *wup = wu; 4135 4136 /* 4137 * Recreate a work unit by releasing the associated CCBs and reissuing 4138 * the SCSI I/O request. This process is then repeated for all of the 4139 * colliding work units. 4140 */ 4141 do { 4142 sr_wu_release_ccbs(wup); 4143 4144 wup->swu_state = SR_WU_REQUEUE; 4145 if (sd->sd_scsi_rw(wup)) 4146 panic("could not requeue I/O"); 4147 4148 wup = wup->swu_collider; 4149 } while (wup); 4150 } 4151 4152 void 4153 sr_set_chunk_state(struct sr_discipline *sd, int c, int new_state) 4154 { 4155 int old_state, s; 4156 4157 DNPRINTF(SR_D_STATE, "%s: %s: %s: sr_set_chunk_state %d -> %d\n", 4158 DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, 4159 sd->sd_vol.sv_chunks[c]->src_meta.scmi.scm_devname, c, new_state); 4160 4161 /* ok to go to splbio since this only happens in error path */ 4162 s = splbio(); 4163 old_state = sd->sd_vol.sv_chunks[c]->src_meta.scm_status; 4164 4165 /* multiple IOs to the same chunk that fail will come through here */ 4166 if (old_state == new_state) 4167 goto done; 4168 4169 switch (old_state) { 4170 case BIOC_SDONLINE: 4171 if (new_state == BIOC_SDOFFLINE) 4172 break; 4173 else 4174 goto die; 4175 break; 4176 4177 case BIOC_SDOFFLINE: 4178 goto die; 4179 4180 default: 4181 die: 4182 splx(s); /* XXX */ 4183 panic("%s: %s: %s: invalid chunk state transition " 4184 "%d -> %d\n", DEVNAME(sd->sd_sc), 4185 sd->sd_meta->ssd_devname, 4186 sd->sd_vol.sv_chunks[c]->src_meta.scmi.scm_devname, 4187 old_state, new_state); 4188 /* NOTREACHED */ 4189 } 4190 4191 sd->sd_vol.sv_chunks[c]->src_meta.scm_status = new_state; 4192 sd->sd_set_vol_state(sd); 4193 4194 sd->sd_must_flush = 1; 4195 workq_add_task(NULL, 0, sr_meta_save_callback, sd, NULL); 4196 done: 4197 splx(s); 4198 } 4199 4200 void 4201 sr_set_vol_state(struct sr_discipline *sd) 4202 { 4203 int states[SR_MAX_STATES]; 4204 int new_state, i, s, nd; 4205 int old_state = sd->sd_vol_status; 4206 4207 DNPRINTF(SR_D_STATE, "%s: %s: sr_set_vol_state\n", 4208 DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname); 4209 4210 nd = sd->sd_meta->ssdi.ssd_chunk_no; 4211 4212 for (i = 0; i < SR_MAX_STATES; i++) 4213 states[i] = 0; 4214 4215 for (i = 0; i < nd; i++) { 4216 s = sd->sd_vol.sv_chunks[i]->src_meta.scm_status; 4217 if (s >= SR_MAX_STATES) 4218 panic("%s: %s: %s: invalid chunk state", 4219 DEVNAME(sd->sd_sc), 4220 sd->sd_meta->ssd_devname, 4221 sd->sd_vol.sv_chunks[i]->src_meta.scmi.scm_devname); 4222 states[s]++; 4223 } 4224 4225 if (states[BIOC_SDONLINE] == nd) 4226 new_state = BIOC_SVONLINE; 4227 else 4228 new_state = BIOC_SVOFFLINE; 4229 4230 DNPRINTF(SR_D_STATE, "%s: %s: sr_set_vol_state %d -> %d\n", 4231 DEVNAME(sd->sd_sc), sd->sd_meta->ssd_devname, 4232 old_state, new_state); 4233 4234 switch (old_state) { 4235 case BIOC_SVONLINE: 4236 if (new_state == BIOC_SVOFFLINE || new_state == BIOC_SVONLINE) 4237 break; 4238 else 4239 goto die; 4240 break; 4241 4242 case BIOC_SVOFFLINE: 4243 /* XXX this might be a little too much */ 4244 goto die; 4245 4246 default: 4247 die: 4248 panic("%s: %s: invalid volume state transition " 4249 "%d -> %d\n", DEVNAME(sd->sd_sc), 4250 sd->sd_meta->ssd_devname, 4251 old_state, new_state); 4252 /* NOTREACHED */ 4253 } 4254 4255 sd->sd_vol_status = new_state; 4256 } 4257 4258 void 4259 sr_checksum_print(u_int8_t *md5) 4260 { 4261 int i; 4262 4263 for (i = 0; i < MD5_DIGEST_LENGTH; i++) 4264 printf("%02x", md5[i]); 4265 } 4266 4267 void 4268 sr_checksum(struct sr_softc *sc, void *src, void *md5, u_int32_t len) 4269 { 4270 MD5_CTX ctx; 4271 4272 DNPRINTF(SR_D_MISC, "%s: sr_checksum(%p %p %d)\n", DEVNAME(sc), src, 4273 md5, len); 4274 4275 MD5Init(&ctx); 4276 MD5Update(&ctx, src, len); 4277 MD5Final(md5, &ctx); 4278 } 4279 4280 void 4281 sr_uuid_generate(struct sr_uuid *uuid) 4282 { 4283 arc4random_buf(uuid->sui_id, sizeof(uuid->sui_id)); 4284 /* UUID version 4: random */ 4285 uuid->sui_id[6] &= 0x0f; 4286 uuid->sui_id[6] |= 0x40; 4287 /* RFC4122 variant */ 4288 uuid->sui_id[8] &= 0x3f; 4289 uuid->sui_id[8] |= 0x80; 4290 } 4291 4292 char * 4293 sr_uuid_format(struct sr_uuid *uuid) 4294 { 4295 char *uuidstr; 4296 4297 uuidstr = malloc(37, M_DEVBUF, M_WAITOK); 4298 4299 snprintf(uuidstr, 37, 4300 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-" 4301 "%02x%02x%02x%02x%02x%02x", 4302 uuid->sui_id[0], uuid->sui_id[1], 4303 uuid->sui_id[2], uuid->sui_id[3], 4304 uuid->sui_id[4], uuid->sui_id[5], 4305 uuid->sui_id[6], uuid->sui_id[7], 4306 uuid->sui_id[8], uuid->sui_id[9], 4307 uuid->sui_id[10], uuid->sui_id[11], 4308 uuid->sui_id[12], uuid->sui_id[13], 4309 uuid->sui_id[14], uuid->sui_id[15]); 4310 4311 return uuidstr; 4312 } 4313 4314 void 4315 sr_uuid_print(struct sr_uuid *uuid, int cr) 4316 { 4317 char *uuidstr; 4318 4319 uuidstr = sr_uuid_format(uuid); 4320 printf("%s%s", uuidstr, (cr ? "\n" : "")); 4321 free(uuidstr, M_DEVBUF); 4322 } 4323 4324 int 4325 sr_already_assembled(struct sr_discipline *sd) 4326 { 4327 struct sr_softc *sc = sd->sd_sc; 4328 struct sr_discipline *sdtmp; 4329 4330 TAILQ_FOREACH(sdtmp, &sc->sc_dis_list, sd_link) { 4331 if (!bcmp(&sd->sd_meta->ssdi.ssd_uuid, 4332 &sdtmp->sd_meta->ssdi.ssd_uuid, 4333 sizeof(sd->sd_meta->ssdi.ssd_uuid))) 4334 return (1); 4335 } 4336 4337 return (0); 4338 } 4339 4340 int32_t 4341 sr_validate_stripsize(u_int32_t b) 4342 { 4343 int s = 0; 4344 4345 if (b % 512) 4346 return (-1); 4347 4348 while ((b & 1) == 0) { 4349 b >>= 1; 4350 s++; 4351 } 4352 4353 /* only multiple of twos */ 4354 b >>= 1; 4355 if (b) 4356 return(-1); 4357 4358 return (s); 4359 } 4360 4361 void 4362 sr_shutdownhook(void *arg) 4363 { 4364 sr_shutdown((struct sr_softc *)arg); 4365 } 4366 4367 void 4368 sr_shutdown(struct sr_softc *sc) 4369 { 4370 struct sr_discipline *sd; 4371 4372 DNPRINTF(SR_D_MISC, "%s: sr_shutdown\n", DEVNAME(sc)); 4373 4374 /* Shutdown disciplines in reverse attach order. */ 4375 while ((sd = TAILQ_LAST(&sc->sc_dis_list, sr_discipline_list)) != NULL) 4376 sr_discipline_shutdown(sd, 1); 4377 } 4378 4379 int 4380 sr_validate_io(struct sr_workunit *wu, daddr64_t *blk, char *func) 4381 { 4382 struct sr_discipline *sd = wu->swu_dis; 4383 struct scsi_xfer *xs = wu->swu_xs; 4384 int rv = 1; 4385 4386 DNPRINTF(SR_D_DIS, "%s: %s 0x%02x\n", DEVNAME(sd->sd_sc), func, 4387 xs->cmd->opcode); 4388 4389 if (sd->sd_meta->ssd_data_offset == 0) 4390 panic("invalid data offset"); 4391 4392 if (sd->sd_vol_status == BIOC_SVOFFLINE) { 4393 DNPRINTF(SR_D_DIS, "%s: %s device offline\n", 4394 DEVNAME(sd->sd_sc), func); 4395 goto bad; 4396 } 4397 4398 if (xs->datalen == 0) { 4399 printf("%s: %s: illegal block count for %s\n", 4400 DEVNAME(sd->sd_sc), func, sd->sd_meta->ssd_devname); 4401 goto bad; 4402 } 4403 4404 if (xs->cmdlen == 10) 4405 *blk = _4btol(((struct scsi_rw_big *)xs->cmd)->addr); 4406 else if (xs->cmdlen == 16) 4407 *blk = _8btol(((struct scsi_rw_16 *)xs->cmd)->addr); 4408 else if (xs->cmdlen == 6) 4409 *blk = _3btol(((struct scsi_rw *)xs->cmd)->addr); 4410 else { 4411 printf("%s: %s: illegal cmdlen for %s\n", 4412 DEVNAME(sd->sd_sc), func, sd->sd_meta->ssd_devname); 4413 goto bad; 4414 } 4415 4416 wu->swu_blk_start = *blk; 4417 wu->swu_blk_end = *blk + (xs->datalen >> DEV_BSHIFT) - 1; 4418 4419 if (wu->swu_blk_end > sd->sd_meta->ssdi.ssd_size) { 4420 DNPRINTF(SR_D_DIS, "%s: %s out of bounds start: %lld " 4421 "end: %lld length: %d\n", 4422 DEVNAME(sd->sd_sc), func, wu->swu_blk_start, 4423 wu->swu_blk_end, xs->datalen); 4424 4425 sd->sd_scsi_sense.error_code = SSD_ERRCODE_CURRENT | 4426 SSD_ERRCODE_VALID; 4427 sd->sd_scsi_sense.flags = SKEY_ILLEGAL_REQUEST; 4428 sd->sd_scsi_sense.add_sense_code = 0x21; 4429 sd->sd_scsi_sense.add_sense_code_qual = 0x00; 4430 sd->sd_scsi_sense.extra_len = 4; 4431 goto bad; 4432 } 4433 4434 rv = 0; 4435 bad: 4436 return (rv); 4437 } 4438 4439 int 4440 sr_check_io_collision(struct sr_workunit *wu) 4441 { 4442 struct sr_discipline *sd = wu->swu_dis; 4443 struct sr_workunit *wup; 4444 4445 splassert(IPL_BIO); 4446 4447 /* walk queue backwards and fill in collider if we have one */ 4448 TAILQ_FOREACH_REVERSE(wup, &sd->sd_wu_pendq, sr_wu_list, swu_link) { 4449 if (wu->swu_blk_end < wup->swu_blk_start || 4450 wup->swu_blk_end < wu->swu_blk_start) 4451 continue; 4452 4453 /* we have an LBA collision, defer wu */ 4454 wu->swu_state = SR_WU_DEFERRED; 4455 if (wup->swu_collider) 4456 /* wu is on deferred queue, append to last wu */ 4457 while (wup->swu_collider) 4458 wup = wup->swu_collider; 4459 4460 wup->swu_collider = wu; 4461 TAILQ_INSERT_TAIL(&sd->sd_wu_defq, wu, swu_link); 4462 sd->sd_wu_collisions++; 4463 goto queued; 4464 } 4465 4466 return (0); 4467 queued: 4468 return (1); 4469 } 4470 4471 void 4472 sr_rebuild(void *arg) 4473 { 4474 struct sr_discipline *sd = arg; 4475 struct sr_softc *sc = sd->sd_sc; 4476 4477 if (kthread_create(sr_rebuild_thread, sd, &sd->sd_background_proc, 4478 DEVNAME(sc)) != 0) 4479 printf("%s: unable to start background operation\n", 4480 DEVNAME(sc)); 4481 } 4482 4483 void 4484 sr_rebuild_thread(void *arg) 4485 { 4486 struct sr_discipline *sd = arg; 4487 struct sr_softc *sc = sd->sd_sc; 4488 daddr64_t whole_blk, partial_blk, blk, sz, lba; 4489 daddr64_t psz, rb, restart; 4490 struct sr_workunit *wu_r, *wu_w; 4491 struct scsi_xfer xs_r, xs_w; 4492 struct scsi_rw_16 *cr, *cw; 4493 int c, s, slept, percent = 0, old_percent = -1; 4494 u_int8_t *buf; 4495 4496 whole_blk = sd->sd_meta->ssdi.ssd_size / SR_REBUILD_IO_SIZE; 4497 partial_blk = sd->sd_meta->ssdi.ssd_size % SR_REBUILD_IO_SIZE; 4498 4499 restart = sd->sd_meta->ssd_rebuild / SR_REBUILD_IO_SIZE; 4500 if (restart > whole_blk) { 4501 printf("%s: bogus rebuild restart offset, starting from 0\n", 4502 DEVNAME(sc)); 4503 restart = 0; 4504 } 4505 if (restart) { 4506 /* 4507 * XXX there is a hole here; there is a posibility that we 4508 * had a restart however the chunk that was supposed to 4509 * be rebuilt is no longer valid; we can reach this situation 4510 * when a rebuild is in progress and the box crashes and 4511 * on reboot the rebuild chunk is different (like zero'd or 4512 * replaced). We need to check the uuid of the chunk that is 4513 * being rebuilt to assert this. 4514 */ 4515 psz = sd->sd_meta->ssdi.ssd_size; 4516 rb = sd->sd_meta->ssd_rebuild; 4517 if (rb > 0) 4518 percent = 100 - ((psz * 100 - rb * 100) / psz) - 1; 4519 else 4520 percent = 0; 4521 printf("%s: resuming rebuild on %s at %d%%\n", 4522 DEVNAME(sc), sd->sd_meta->ssd_devname, percent); 4523 } 4524 4525 sd->sd_reb_active = 1; 4526 4527 /* currently this is 64k therefore we can use dma_alloc */ 4528 buf = dma_alloc(SR_REBUILD_IO_SIZE << DEV_BSHIFT, PR_WAITOK); 4529 for (blk = restart; blk <= whole_blk; blk++) { 4530 lba = blk * SR_REBUILD_IO_SIZE; 4531 sz = SR_REBUILD_IO_SIZE; 4532 if (blk == whole_blk) { 4533 if (partial_blk == 0) 4534 break; 4535 sz = partial_blk; 4536 } 4537 4538 /* get some wu */ 4539 if ((wu_r = scsi_io_get(&sd->sd_iopool, 0)) == NULL) 4540 panic("%s: rebuild exhausted wu_r", DEVNAME(sc)); 4541 if ((wu_w = scsi_io_get(&sd->sd_iopool, 0)) == NULL) 4542 panic("%s: rebuild exhausted wu_w", DEVNAME(sc)); 4543 4544 /* setup read io */ 4545 bzero(&xs_r, sizeof xs_r); 4546 xs_r.error = XS_NOERROR; 4547 xs_r.flags = SCSI_DATA_IN; 4548 xs_r.datalen = sz << DEV_BSHIFT; 4549 xs_r.data = buf; 4550 xs_r.cmdlen = sizeof(*cr); 4551 xs_r.cmd = &xs_r.cmdstore; 4552 cr = (struct scsi_rw_16 *)xs_r.cmd; 4553 cr->opcode = READ_16; 4554 _lto4b(sz, cr->length); 4555 _lto8b(lba, cr->addr); 4556 wu_r->swu_flags |= SR_WUF_REBUILD; 4557 wu_r->swu_xs = &xs_r; 4558 if (sd->sd_scsi_rw(wu_r)) { 4559 printf("%s: could not create read io\n", 4560 DEVNAME(sc)); 4561 goto fail; 4562 } 4563 4564 /* setup write io */ 4565 bzero(&xs_w, sizeof xs_w); 4566 xs_w.error = XS_NOERROR; 4567 xs_w.flags = SCSI_DATA_OUT; 4568 xs_w.datalen = sz << DEV_BSHIFT; 4569 xs_w.data = buf; 4570 xs_w.cmdlen = sizeof(*cw); 4571 xs_w.cmd = &xs_w.cmdstore; 4572 cw = (struct scsi_rw_16 *)xs_w.cmd; 4573 cw->opcode = WRITE_16; 4574 _lto4b(sz, cw->length); 4575 _lto8b(lba, cw->addr); 4576 wu_w->swu_flags |= SR_WUF_REBUILD; 4577 wu_w->swu_xs = &xs_w; 4578 if (sd->sd_scsi_rw(wu_w)) { 4579 printf("%s: could not create write io\n", 4580 DEVNAME(sc)); 4581 goto fail; 4582 } 4583 4584 /* 4585 * collide with the read io so that we get automatically 4586 * started when the read is done 4587 */ 4588 wu_w->swu_state = SR_WU_DEFERRED; 4589 wu_r->swu_collider = wu_w; 4590 s = splbio(); 4591 TAILQ_INSERT_TAIL(&sd->sd_wu_defq, wu_w, swu_link); 4592 4593 /* schedule io */ 4594 if (sr_check_io_collision(wu_r)) 4595 goto queued; 4596 4597 sr_raid_startwu(wu_r); 4598 queued: 4599 splx(s); 4600 4601 /* wait for read completion */ 4602 slept = 0; 4603 while ((wu_w->swu_flags & SR_WUF_REBUILDIOCOMP) == 0) { 4604 tsleep(wu_w, PRIBIO, "sr_rebuild", 0); 4605 slept = 1; 4606 } 4607 /* yield if we didn't sleep */ 4608 if (slept == 0) 4609 tsleep(sc, PWAIT, "sr_yield", 1); 4610 4611 scsi_io_put(&sd->sd_iopool, wu_r); 4612 scsi_io_put(&sd->sd_iopool, wu_w); 4613 4614 sd->sd_meta->ssd_rebuild = lba; 4615 4616 /* save metadata every percent */ 4617 psz = sd->sd_meta->ssdi.ssd_size; 4618 rb = sd->sd_meta->ssd_rebuild; 4619 if (rb > 0) 4620 percent = 100 - ((psz * 100 - rb * 100) / psz) - 1; 4621 else 4622 percent = 0; 4623 if (percent != old_percent && blk != whole_blk) { 4624 if (sr_meta_save(sd, SR_META_DIRTY)) 4625 printf("%s: could not save metadata to %s\n", 4626 DEVNAME(sc), sd->sd_meta->ssd_devname); 4627 old_percent = percent; 4628 } 4629 4630 if (sd->sd_reb_abort) 4631 goto abort; 4632 } 4633 4634 /* all done */ 4635 sd->sd_meta->ssd_rebuild = 0; 4636 for (c = 0; c < sd->sd_meta->ssdi.ssd_chunk_no; c++) 4637 if (sd->sd_vol.sv_chunks[c]->src_meta.scm_status == 4638 BIOC_SDREBUILD) { 4639 sd->sd_set_chunk_state(sd, c, BIOC_SDONLINE); 4640 break; 4641 } 4642 4643 abort: 4644 if (sr_meta_save(sd, SR_META_DIRTY)) 4645 printf("%s: could not save metadata to %s\n", 4646 DEVNAME(sc), sd->sd_meta->ssd_devname); 4647 fail: 4648 dma_free(buf, SR_REBUILD_IO_SIZE << DEV_BSHIFT); 4649 sd->sd_reb_active = 0; 4650 kthread_exit(0); 4651 } 4652 4653 #ifndef SMALL_KERNEL 4654 int 4655 sr_sensors_create(struct sr_discipline *sd) 4656 { 4657 struct sr_softc *sc = sd->sd_sc; 4658 int rv = 1; 4659 4660 DNPRINTF(SR_D_STATE, "%s: %s: sr_sensors_create\n", 4661 DEVNAME(sc), sd->sd_meta->ssd_devname); 4662 4663 sd->sd_vol.sv_sensor.type = SENSOR_DRIVE; 4664 sd->sd_vol.sv_sensor.status = SENSOR_S_UNKNOWN; 4665 strlcpy(sd->sd_vol.sv_sensor.desc, sd->sd_meta->ssd_devname, 4666 sizeof(sd->sd_vol.sv_sensor.desc)); 4667 4668 sensor_attach(&sc->sc_sensordev, &sd->sd_vol.sv_sensor); 4669 sd->sd_vol.sv_sensor_attached = 1; 4670 4671 if (sc->sc_sensor_task == NULL) { 4672 sc->sc_sensor_task = sensor_task_register(sc, 4673 sr_sensors_refresh, 10); 4674 if (sc->sc_sensor_task == NULL) 4675 goto bad; 4676 } 4677 4678 rv = 0; 4679 bad: 4680 return (rv); 4681 } 4682 4683 void 4684 sr_sensors_delete(struct sr_discipline *sd) 4685 { 4686 DNPRINTF(SR_D_STATE, "%s: sr_sensors_delete\n", DEVNAME(sd->sd_sc)); 4687 4688 if (sd->sd_vol.sv_sensor_attached) 4689 sensor_detach(&sd->sd_sc->sc_sensordev, &sd->sd_vol.sv_sensor); 4690 } 4691 4692 void 4693 sr_sensors_refresh(void *arg) 4694 { 4695 struct sr_softc *sc = arg; 4696 struct sr_volume *sv; 4697 struct sr_discipline *sd; 4698 4699 DNPRINTF(SR_D_STATE, "%s: sr_sensors_refresh\n", DEVNAME(sc)); 4700 4701 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 4702 sv = &sd->sd_vol; 4703 4704 switch(sd->sd_vol_status) { 4705 case BIOC_SVOFFLINE: 4706 sv->sv_sensor.value = SENSOR_DRIVE_FAIL; 4707 sv->sv_sensor.status = SENSOR_S_CRIT; 4708 break; 4709 4710 case BIOC_SVDEGRADED: 4711 sv->sv_sensor.value = SENSOR_DRIVE_PFAIL; 4712 sv->sv_sensor.status = SENSOR_S_WARN; 4713 break; 4714 4715 case BIOC_SVSCRUB: 4716 case BIOC_SVONLINE: 4717 sv->sv_sensor.value = SENSOR_DRIVE_ONLINE; 4718 sv->sv_sensor.status = SENSOR_S_OK; 4719 break; 4720 4721 default: 4722 sv->sv_sensor.value = 0; /* unknown */ 4723 sv->sv_sensor.status = SENSOR_S_UNKNOWN; 4724 } 4725 } 4726 } 4727 #endif /* SMALL_KERNEL */ 4728 4729 #ifdef SR_FANCY_STATS 4730 void sr_print_stats(void); 4731 4732 void 4733 sr_print_stats(void) 4734 { 4735 struct sr_softc *sc = softraid0; 4736 struct sr_discipline *sd; 4737 4738 if (sc == NULL) { 4739 printf("no softraid softc found\n"); 4740 return; 4741 } 4742 4743 TAILQ_FOREACH(sd, &sc->sc_dis_list, sd_link) { 4744 printf("%s: ios pending %d, collisions %llu\n", 4745 sd->sd_meta->ssd_devname, 4746 sd->sd_wu_pending, 4747 sd->sd_wu_collisions); 4748 } 4749 } 4750 #endif /* SR_FANCY_STATS */ 4751 4752 #ifdef SR_DEBUG 4753 void 4754 sr_meta_print(struct sr_metadata *m) 4755 { 4756 int i; 4757 struct sr_meta_chunk *mc; 4758 struct sr_meta_opt_hdr *omh; 4759 4760 if (!(sr_debug & SR_D_META)) 4761 return; 4762 4763 printf("\tssd_magic 0x%llx\n", m->ssdi.ssd_magic); 4764 printf("\tssd_version %d\n", m->ssdi.ssd_version); 4765 printf("\tssd_vol_flags 0x%x\n", m->ssdi.ssd_vol_flags); 4766 printf("\tssd_uuid "); 4767 sr_uuid_print(&m->ssdi.ssd_uuid, 1); 4768 printf("\tssd_chunk_no %d\n", m->ssdi.ssd_chunk_no); 4769 printf("\tssd_chunk_id %d\n", m->ssdi.ssd_chunk_id); 4770 printf("\tssd_opt_no %d\n", m->ssdi.ssd_opt_no); 4771 printf("\tssd_volid %d\n", m->ssdi.ssd_volid); 4772 printf("\tssd_level %d\n", m->ssdi.ssd_level); 4773 printf("\tssd_size %lld\n", m->ssdi.ssd_size); 4774 printf("\tssd_devname %s\n", m->ssd_devname); 4775 printf("\tssd_vendor %s\n", m->ssdi.ssd_vendor); 4776 printf("\tssd_product %s\n", m->ssdi.ssd_product); 4777 printf("\tssd_revision %s\n", m->ssdi.ssd_revision); 4778 printf("\tssd_strip_size %d\n", m->ssdi.ssd_strip_size); 4779 printf("\tssd_checksum "); 4780 sr_checksum_print(m->ssd_checksum); 4781 printf("\n"); 4782 printf("\tssd_meta_flags 0x%x\n", m->ssd_meta_flags); 4783 printf("\tssd_ondisk %llu\n", m->ssd_ondisk); 4784 4785 mc = (struct sr_meta_chunk *)(m + 1); 4786 for (i = 0; i < m->ssdi.ssd_chunk_no; i++, mc++) { 4787 printf("\t\tscm_volid %d\n", mc->scmi.scm_volid); 4788 printf("\t\tscm_chunk_id %d\n", mc->scmi.scm_chunk_id); 4789 printf("\t\tscm_devname %s\n", mc->scmi.scm_devname); 4790 printf("\t\tscm_size %lld\n", mc->scmi.scm_size); 4791 printf("\t\tscm_coerced_size %lld\n",mc->scmi.scm_coerced_size); 4792 printf("\t\tscm_uuid "); 4793 sr_uuid_print(&mc->scmi.scm_uuid, 1); 4794 printf("\t\tscm_checksum "); 4795 sr_checksum_print(mc->scm_checksum); 4796 printf("\n"); 4797 printf("\t\tscm_status %d\n", mc->scm_status); 4798 } 4799 4800 omh = (struct sr_meta_opt_hdr *)((u_int8_t *)(m + 1) + 4801 sizeof(struct sr_meta_chunk) * m->ssdi.ssd_chunk_no); 4802 for (i = 0; i < m->ssdi.ssd_opt_no; i++) { 4803 printf("\t\t\tsom_type %d\n", omh->som_type); 4804 printf("\t\t\tsom_checksum "); 4805 sr_checksum_print(omh->som_checksum); 4806 printf("\n"); 4807 omh = (struct sr_meta_opt_hdr *)((void *)omh + 4808 omh->som_length); 4809 } 4810 } 4811 4812 void 4813 sr_dump_mem(u_int8_t *p, int len) 4814 { 4815 int i; 4816 4817 for (i = 0; i < len; i++) 4818 printf("%02x ", *p++); 4819 printf("\n"); 4820 } 4821 4822 #endif /* SR_DEBUG */ 4823