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