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