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