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