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