dk.c revision 1.136
1 /* $NetBSD: dk.c,v 1.136 2023/04/21 18:26:35 riastradh Exp $ */ 2 3 /*- 4 * Copyright (c) 2004, 2005, 2006, 2007 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: dk.c,v 1.136 2023/04/21 18:26:35 riastradh Exp $"); 34 35 #ifdef _KERNEL_OPT 36 #include "opt_dkwedge.h" 37 #endif 38 39 #include <sys/param.h> 40 #include <sys/types.h> 41 42 #include <sys/buf.h> 43 #include <sys/bufq.h> 44 #include <sys/callout.h> 45 #include <sys/conf.h> 46 #include <sys/device.h> 47 #include <sys/disk.h> 48 #include <sys/disklabel.h> 49 #include <sys/errno.h> 50 #include <sys/fcntl.h> 51 #include <sys/ioctl.h> 52 #include <sys/kauth.h> 53 #include <sys/kernel.h> 54 #include <sys/malloc.h> 55 #include <sys/pool.h> 56 #include <sys/proc.h> 57 #include <sys/rwlock.h> 58 #include <sys/stat.h> 59 #include <sys/systm.h> 60 #include <sys/vnode.h> 61 62 #include <miscfs/specfs/specdev.h> 63 64 MALLOC_DEFINE(M_DKWEDGE, "dkwedge", "Disk wedge structures"); 65 66 typedef enum { 67 DKW_STATE_LARVAL = 0, 68 DKW_STATE_RUNNING = 1, 69 DKW_STATE_DYING = 2, 70 DKW_STATE_DEAD = 666 71 } dkwedge_state_t; 72 73 struct dkwedge_softc { 74 device_t sc_dev; /* pointer to our pseudo-device */ 75 struct cfdata sc_cfdata; /* our cfdata structure */ 76 uint8_t sc_wname[128]; /* wedge name (Unicode, UTF-8) */ 77 78 dkwedge_state_t sc_state; /* state this wedge is in */ 79 80 struct disk *sc_parent; /* parent disk */ 81 daddr_t sc_offset; /* LBA offset of wedge in parent */ 82 krwlock_t sc_sizelock; 83 uint64_t sc_size; /* size of wedge in blocks */ 84 char sc_ptype[32]; /* partition type */ 85 dev_t sc_pdev; /* cached parent's dev_t */ 86 /* link on parent's wedge list */ 87 LIST_ENTRY(dkwedge_softc) sc_plink; 88 89 struct disk sc_dk; /* our own disk structure */ 90 struct bufq_state *sc_bufq; /* buffer queue */ 91 struct callout sc_restart_ch; /* callout to restart I/O */ 92 93 kmutex_t sc_iolock; 94 kcondvar_t sc_dkdrn; 95 u_int sc_iopend; /* I/Os pending */ 96 int sc_mode; /* parent open mode */ 97 }; 98 99 static int dkwedge_match(device_t, cfdata_t, void *); 100 static void dkwedge_attach(device_t, device_t, void *); 101 static int dkwedge_detach(device_t, int); 102 103 static void dkstart(struct dkwedge_softc *); 104 static void dkiodone(struct buf *); 105 static void dkrestart(void *); 106 static void dkminphys(struct buf *); 107 108 static int dkfirstopen(struct dkwedge_softc *, int); 109 static void dklastclose(struct dkwedge_softc *); 110 static int dkwedge_cleanup_parent(struct dkwedge_softc *, int); 111 static int dkwedge_detach(device_t, int); 112 static void dkwedge_delall1(struct disk *, bool); 113 static int dkwedge_del1(struct dkwedge_info *, int); 114 static int dk_open_parent(dev_t, int, struct vnode **); 115 static int dk_close_parent(struct vnode *, int); 116 117 static dev_type_open(dkopen); 118 static dev_type_close(dkclose); 119 static dev_type_read(dkread); 120 static dev_type_write(dkwrite); 121 static dev_type_ioctl(dkioctl); 122 static dev_type_strategy(dkstrategy); 123 static dev_type_dump(dkdump); 124 static dev_type_size(dksize); 125 static dev_type_discard(dkdiscard); 126 127 CFDRIVER_DECL(dk, DV_DISK, NULL); 128 CFATTACH_DECL3_NEW(dk, 0, 129 dkwedge_match, dkwedge_attach, dkwedge_detach, NULL, NULL, NULL, 130 DVF_DETACH_SHUTDOWN); 131 132 const struct bdevsw dk_bdevsw = { 133 .d_open = dkopen, 134 .d_close = dkclose, 135 .d_strategy = dkstrategy, 136 .d_ioctl = dkioctl, 137 .d_dump = dkdump, 138 .d_psize = dksize, 139 .d_discard = dkdiscard, 140 .d_flag = D_DISK | D_MPSAFE 141 }; 142 143 const struct cdevsw dk_cdevsw = { 144 .d_open = dkopen, 145 .d_close = dkclose, 146 .d_read = dkread, 147 .d_write = dkwrite, 148 .d_ioctl = dkioctl, 149 .d_stop = nostop, 150 .d_tty = notty, 151 .d_poll = nopoll, 152 .d_mmap = nommap, 153 .d_kqfilter = nokqfilter, 154 .d_discard = dkdiscard, 155 .d_flag = D_DISK | D_MPSAFE 156 }; 157 158 static struct dkwedge_softc **dkwedges; 159 static u_int ndkwedges; 160 static krwlock_t dkwedges_lock; 161 162 static LIST_HEAD(, dkwedge_discovery_method) dkwedge_discovery_methods; 163 static krwlock_t dkwedge_discovery_methods_lock; 164 165 /* 166 * dkwedge_match: 167 * 168 * Autoconfiguration match function for pseudo-device glue. 169 */ 170 static int 171 dkwedge_match(device_t parent, cfdata_t match, void *aux) 172 { 173 174 /* Pseudo-device; always present. */ 175 return 1; 176 } 177 178 /* 179 * dkwedge_attach: 180 * 181 * Autoconfiguration attach function for pseudo-device glue. 182 */ 183 static void 184 dkwedge_attach(device_t parent, device_t self, void *aux) 185 { 186 187 if (!pmf_device_register(self, NULL, NULL)) 188 aprint_error_dev(self, "couldn't establish power handler\n"); 189 } 190 191 /* 192 * dkwedge_wait_drain: 193 * 194 * Wait for I/O on the wedge to drain. 195 */ 196 static void 197 dkwedge_wait_drain(struct dkwedge_softc *sc) 198 { 199 200 mutex_enter(&sc->sc_iolock); 201 while (sc->sc_iopend != 0) 202 cv_wait(&sc->sc_dkdrn, &sc->sc_iolock); 203 mutex_exit(&sc->sc_iolock); 204 } 205 206 /* 207 * dkwedge_compute_pdev: 208 * 209 * Compute the parent disk's dev_t. 210 */ 211 static int 212 dkwedge_compute_pdev(const char *pname, dev_t *pdevp, enum vtype type) 213 { 214 const char *name, *cp; 215 devmajor_t pmaj; 216 int punit; 217 char devname[16]; 218 219 name = pname; 220 switch (type) { 221 case VBLK: 222 pmaj = devsw_name2blk(name, devname, sizeof(devname)); 223 break; 224 case VCHR: 225 pmaj = devsw_name2chr(name, devname, sizeof(devname)); 226 break; 227 default: 228 pmaj = NODEVMAJOR; 229 break; 230 } 231 if (pmaj == NODEVMAJOR) 232 return ENXIO; 233 234 name += strlen(devname); 235 for (cp = name, punit = 0; *cp >= '0' && *cp <= '9'; cp++) 236 punit = (punit * 10) + (*cp - '0'); 237 if (cp == name) { 238 /* Invalid parent disk name. */ 239 return ENXIO; 240 } 241 242 *pdevp = MAKEDISKDEV(pmaj, punit, RAW_PART); 243 244 return 0; 245 } 246 247 /* 248 * dkwedge_array_expand: 249 * 250 * Expand the dkwedges array. 251 * 252 * Releases and reacquires dkwedges_lock as a writer. 253 */ 254 static int 255 dkwedge_array_expand(void) 256 { 257 258 const unsigned incr = 16; 259 unsigned newcnt, oldcnt; 260 struct dkwedge_softc **newarray = NULL, **oldarray = NULL; 261 262 KASSERT(rw_write_held(&dkwedges_lock)); 263 264 oldcnt = ndkwedges; 265 oldarray = dkwedges; 266 267 if (oldcnt >= INT_MAX - incr) 268 return ENFILE; /* XXX */ 269 newcnt = oldcnt + incr; 270 271 rw_exit(&dkwedges_lock); 272 newarray = malloc(newcnt * sizeof(*newarray), M_DKWEDGE, 273 M_WAITOK|M_ZERO); 274 rw_enter(&dkwedges_lock, RW_WRITER); 275 276 if (ndkwedges != oldcnt || dkwedges != oldarray) { 277 oldarray = NULL; /* already recycled */ 278 goto out; 279 } 280 281 if (oldarray != NULL) 282 memcpy(newarray, dkwedges, ndkwedges * sizeof(*newarray)); 283 dkwedges = newarray; 284 newarray = NULL; /* transferred to dkwedges */ 285 ndkwedges = newcnt; 286 287 out: rw_exit(&dkwedges_lock); 288 if (oldarray != NULL) 289 free(oldarray, M_DKWEDGE); 290 if (newarray != NULL) 291 free(newarray, M_DKWEDGE); 292 rw_enter(&dkwedges_lock, RW_WRITER); 293 return 0; 294 } 295 296 static void 297 dkwedge_size_init(struct dkwedge_softc *sc, uint64_t size) 298 { 299 300 rw_init(&sc->sc_sizelock); 301 sc->sc_size = size; 302 } 303 304 static void 305 dkwedge_size_fini(struct dkwedge_softc *sc) 306 { 307 308 rw_destroy(&sc->sc_sizelock); 309 } 310 311 static uint64_t 312 dkwedge_size(struct dkwedge_softc *sc) 313 { 314 uint64_t size; 315 316 rw_enter(&sc->sc_sizelock, RW_READER); 317 size = sc->sc_size; 318 rw_exit(&sc->sc_sizelock); 319 320 return size; 321 } 322 323 static void 324 dkwedge_size_increase(struct dkwedge_softc *sc, uint64_t size) 325 { 326 327 KASSERT(mutex_owned(&sc->sc_dk.dk_openlock)); 328 329 rw_enter(&sc->sc_sizelock, RW_WRITER); 330 KASSERTMSG(size >= sc->sc_size, 331 "decreasing dkwedge size from %"PRIu64" to %"PRIu64, 332 sc->sc_size, size); 333 sc->sc_size = size; 334 rw_exit(&sc->sc_sizelock); 335 } 336 337 static void 338 dk_set_geometry(struct dkwedge_softc *sc, struct disk *pdk) 339 { 340 struct disk *dk = &sc->sc_dk; 341 struct disk_geom *dg = &dk->dk_geom; 342 343 memset(dg, 0, sizeof(*dg)); 344 345 dg->dg_secperunit = dkwedge_size(sc); 346 dg->dg_secsize = DEV_BSIZE << pdk->dk_blkshift; 347 348 /* fake numbers, 1 cylinder is 1 MB with default sector size */ 349 dg->dg_nsectors = 32; 350 dg->dg_ntracks = 64; 351 dg->dg_ncylinders = 352 dg->dg_secperunit / (dg->dg_nsectors * dg->dg_ntracks); 353 354 disk_set_info(sc->sc_dev, dk, NULL); 355 } 356 357 /* 358 * dkwedge_add: [exported function] 359 * 360 * Add a disk wedge based on the provided information. 361 * 362 * The incoming dkw_devname[] is ignored, instead being 363 * filled in and returned to the caller. 364 */ 365 int 366 dkwedge_add(struct dkwedge_info *dkw) 367 { 368 struct dkwedge_softc *sc, *lsc; 369 struct disk *pdk; 370 u_int unit; 371 int error; 372 dev_t pdev; 373 374 dkw->dkw_parent[sizeof(dkw->dkw_parent) - 1] = '\0'; 375 pdk = disk_find(dkw->dkw_parent); 376 if (pdk == NULL) 377 return ENXIO; 378 379 error = dkwedge_compute_pdev(pdk->dk_name, &pdev, VBLK); 380 if (error) 381 return error; 382 383 if (dkw->dkw_offset < 0) 384 return EINVAL; 385 386 /* 387 * Check for an existing wedge at the same disk offset. Allow 388 * updating a wedge if the only change is the size, and the new 389 * size is larger than the old. 390 */ 391 sc = NULL; 392 mutex_enter(&pdk->dk_openlock); 393 LIST_FOREACH(lsc, &pdk->dk_wedges, sc_plink) { 394 if (lsc->sc_offset != dkw->dkw_offset) 395 continue; 396 if (strcmp(lsc->sc_wname, dkw->dkw_wname) != 0) 397 break; 398 if (strcmp(lsc->sc_ptype, dkw->dkw_ptype) != 0) 399 break; 400 if (dkwedge_size(lsc) > dkw->dkw_size) 401 break; 402 403 sc = lsc; 404 dkwedge_size_increase(sc, dkw->dkw_size); 405 dk_set_geometry(sc, pdk); 406 407 break; 408 } 409 mutex_exit(&pdk->dk_openlock); 410 411 if (sc != NULL) 412 goto announce; 413 414 sc = malloc(sizeof(*sc), M_DKWEDGE, M_WAITOK|M_ZERO); 415 sc->sc_state = DKW_STATE_LARVAL; 416 sc->sc_parent = pdk; 417 sc->sc_pdev = pdev; 418 sc->sc_offset = dkw->dkw_offset; 419 dkwedge_size_init(sc, dkw->dkw_size); 420 421 memcpy(sc->sc_wname, dkw->dkw_wname, sizeof(sc->sc_wname)); 422 sc->sc_wname[sizeof(sc->sc_wname) - 1] = '\0'; 423 424 memcpy(sc->sc_ptype, dkw->dkw_ptype, sizeof(sc->sc_ptype)); 425 sc->sc_ptype[sizeof(sc->sc_ptype) - 1] = '\0'; 426 427 bufq_alloc(&sc->sc_bufq, "fcfs", 0); 428 429 callout_init(&sc->sc_restart_ch, 0); 430 callout_setfunc(&sc->sc_restart_ch, dkrestart, sc); 431 432 mutex_init(&sc->sc_iolock, MUTEX_DEFAULT, IPL_BIO); 433 cv_init(&sc->sc_dkdrn, "dkdrn"); 434 435 /* 436 * Wedge will be added; increment the wedge count for the parent. 437 * Only allow this to happen if RAW_PART is the only thing open. 438 */ 439 mutex_enter(&pdk->dk_openlock); 440 if (pdk->dk_openmask & ~(1 << RAW_PART)) 441 error = EBUSY; 442 else { 443 /* Check for wedge overlap. */ 444 LIST_FOREACH(lsc, &pdk->dk_wedges, sc_plink) { 445 /* XXX arithmetic overflow */ 446 uint64_t size = dkwedge_size(sc); 447 uint64_t lsize = dkwedge_size(lsc); 448 daddr_t lastblk = sc->sc_offset + size - 1; 449 daddr_t llastblk = lsc->sc_offset + lsize - 1; 450 451 if (sc->sc_offset >= lsc->sc_offset && 452 sc->sc_offset <= llastblk) { 453 /* Overlaps the tail of the existing wedge. */ 454 break; 455 } 456 if (lastblk >= lsc->sc_offset && 457 lastblk <= llastblk) { 458 /* Overlaps the head of the existing wedge. */ 459 break; 460 } 461 } 462 if (lsc != NULL) { 463 if (sc->sc_offset == lsc->sc_offset && 464 dkwedge_size(sc) == dkwedge_size(lsc) && 465 strcmp(sc->sc_wname, lsc->sc_wname) == 0) 466 error = EEXIST; 467 else 468 error = EINVAL; 469 } else { 470 pdk->dk_nwedges++; 471 LIST_INSERT_HEAD(&pdk->dk_wedges, sc, sc_plink); 472 } 473 } 474 mutex_exit(&pdk->dk_openlock); 475 if (error) { 476 cv_destroy(&sc->sc_dkdrn); 477 mutex_destroy(&sc->sc_iolock); 478 bufq_free(sc->sc_bufq); 479 dkwedge_size_fini(sc); 480 free(sc, M_DKWEDGE); 481 return error; 482 } 483 484 /* Fill in our cfdata for the pseudo-device glue. */ 485 sc->sc_cfdata.cf_name = dk_cd.cd_name; 486 sc->sc_cfdata.cf_atname = dk_ca.ca_name; 487 /* sc->sc_cfdata.cf_unit set below */ 488 sc->sc_cfdata.cf_fstate = FSTATE_STAR; 489 490 /* Insert the larval wedge into the array. */ 491 rw_enter(&dkwedges_lock, RW_WRITER); 492 for (error = 0;;) { 493 struct dkwedge_softc **scpp; 494 495 /* 496 * Check for a duplicate wname while searching for 497 * a slot. 498 */ 499 for (scpp = NULL, unit = 0; unit < ndkwedges; unit++) { 500 if (dkwedges[unit] == NULL) { 501 if (scpp == NULL) { 502 scpp = &dkwedges[unit]; 503 sc->sc_cfdata.cf_unit = unit; 504 } 505 } else { 506 /* XXX Unicode. */ 507 if (strcmp(dkwedges[unit]->sc_wname, 508 sc->sc_wname) == 0) { 509 error = EEXIST; 510 break; 511 } 512 } 513 } 514 if (error) 515 break; 516 KASSERT(unit == ndkwedges); 517 if (scpp == NULL) { 518 error = dkwedge_array_expand(); 519 if (error) 520 break; 521 } else { 522 KASSERT(scpp == &dkwedges[sc->sc_cfdata.cf_unit]); 523 *scpp = sc; 524 break; 525 } 526 } 527 rw_exit(&dkwedges_lock); 528 if (error) { 529 mutex_enter(&pdk->dk_openlock); 530 pdk->dk_nwedges--; 531 LIST_REMOVE(sc, sc_plink); 532 mutex_exit(&pdk->dk_openlock); 533 534 cv_destroy(&sc->sc_dkdrn); 535 mutex_destroy(&sc->sc_iolock); 536 bufq_free(sc->sc_bufq); 537 dkwedge_size_fini(sc); 538 free(sc, M_DKWEDGE); 539 return error; 540 } 541 542 /* 543 * Now that we know the unit #, attach a pseudo-device for 544 * this wedge instance. This will provide us with the 545 * device_t necessary for glue to other parts of the system. 546 * 547 * This should never fail, unless we're almost totally out of 548 * memory. 549 */ 550 if ((sc->sc_dev = config_attach_pseudo(&sc->sc_cfdata)) == NULL) { 551 aprint_error("%s%u: unable to attach pseudo-device\n", 552 sc->sc_cfdata.cf_name, sc->sc_cfdata.cf_unit); 553 554 rw_enter(&dkwedges_lock, RW_WRITER); 555 dkwedges[sc->sc_cfdata.cf_unit] = NULL; 556 rw_exit(&dkwedges_lock); 557 558 mutex_enter(&pdk->dk_openlock); 559 pdk->dk_nwedges--; 560 LIST_REMOVE(sc, sc_plink); 561 mutex_exit(&pdk->dk_openlock); 562 563 cv_destroy(&sc->sc_dkdrn); 564 mutex_destroy(&sc->sc_iolock); 565 bufq_free(sc->sc_bufq); 566 dkwedge_size_fini(sc); 567 free(sc, M_DKWEDGE); 568 return ENOMEM; 569 } 570 571 /* 572 * XXX Really ought to make the disk_attach() and the changing 573 * of state to RUNNING atomic. 574 */ 575 576 disk_init(&sc->sc_dk, device_xname(sc->sc_dev), NULL); 577 dk_set_geometry(sc, pdk); 578 disk_attach(&sc->sc_dk); 579 580 /* Disk wedge is ready for use! */ 581 sc->sc_state = DKW_STATE_RUNNING; 582 583 announce: 584 /* Announce our arrival. */ 585 aprint_normal( 586 "%s at %s: \"%s\", %"PRIu64" blocks at %"PRId64", type: %s\n", 587 device_xname(sc->sc_dev), pdk->dk_name, 588 sc->sc_wname, /* XXX Unicode */ 589 dkwedge_size(sc), sc->sc_offset, 590 sc->sc_ptype[0] == '\0' ? "<unknown>" : sc->sc_ptype); 591 592 /* Return the devname to the caller. */ 593 strlcpy(dkw->dkw_devname, device_xname(sc->sc_dev), 594 sizeof(dkw->dkw_devname)); 595 596 return 0; 597 } 598 599 /* 600 * dkwedge_find: 601 * 602 * Lookup a disk wedge based on the provided information. 603 * NOTE: We look up the wedge based on the wedge devname, 604 * not wname. 605 * 606 * Return NULL if the wedge is not found, otherwise return 607 * the wedge's softc. Assign the wedge's unit number to unitp 608 * if unitp is not NULL. 609 */ 610 static struct dkwedge_softc * 611 dkwedge_find(struct dkwedge_info *dkw, u_int *unitp) 612 { 613 struct dkwedge_softc *sc = NULL; 614 u_int unit; 615 616 /* Find our softc. */ 617 dkw->dkw_devname[sizeof(dkw->dkw_devname) - 1] = '\0'; 618 rw_enter(&dkwedges_lock, RW_READER); 619 for (unit = 0; unit < ndkwedges; unit++) { 620 if ((sc = dkwedges[unit]) != NULL && 621 strcmp(device_xname(sc->sc_dev), dkw->dkw_devname) == 0 && 622 strcmp(sc->sc_parent->dk_name, dkw->dkw_parent) == 0) { 623 break; 624 } 625 } 626 rw_exit(&dkwedges_lock); 627 if (unit == ndkwedges) 628 return NULL; 629 630 if (unitp != NULL) 631 *unitp = unit; 632 633 return sc; 634 } 635 636 /* 637 * dkwedge_del: [exported function] 638 * 639 * Delete a disk wedge based on the provided information. 640 * NOTE: We look up the wedge based on the wedge devname, 641 * not wname. 642 */ 643 int 644 dkwedge_del(struct dkwedge_info *dkw) 645 { 646 647 return dkwedge_del1(dkw, 0); 648 } 649 650 int 651 dkwedge_del1(struct dkwedge_info *dkw, int flags) 652 { 653 struct dkwedge_softc *sc = NULL; 654 655 /* Find our softc. */ 656 if ((sc = dkwedge_find(dkw, NULL)) == NULL) 657 return ESRCH; 658 659 return config_detach(sc->sc_dev, flags); 660 } 661 662 static int 663 dkwedge_cleanup_parent(struct dkwedge_softc *sc, int flags) 664 { 665 struct disk *dk = &sc->sc_dk; 666 int rc; 667 668 rc = 0; 669 mutex_enter(&dk->dk_openlock); 670 if (dk->dk_openmask == 0) { 671 /* nothing to do */ 672 } else if ((flags & DETACH_FORCE) == 0) { 673 rc = EBUSY; 674 } else { 675 mutex_enter(&sc->sc_parent->dk_rawlock); 676 dklastclose(sc); 677 mutex_exit(&sc->sc_parent->dk_rawlock); 678 } 679 mutex_exit(&sc->sc_dk.dk_openlock); 680 681 return rc; 682 } 683 684 /* 685 * dkwedge_detach: 686 * 687 * Autoconfiguration detach function for pseudo-device glue. 688 */ 689 static int 690 dkwedge_detach(device_t self, int flags) 691 { 692 struct dkwedge_softc *sc = NULL; 693 u_int unit; 694 int bmaj, cmaj, rc; 695 696 rw_enter(&dkwedges_lock, RW_WRITER); 697 for (unit = 0; unit < ndkwedges; unit++) { 698 if ((sc = dkwedges[unit]) != NULL && sc->sc_dev == self) 699 break; 700 } 701 if (unit == ndkwedges) 702 rc = ENXIO; 703 else if ((rc = dkwedge_cleanup_parent(sc, flags)) == 0) { 704 /* Mark the wedge as dying. */ 705 sc->sc_state = DKW_STATE_DYING; 706 } 707 rw_exit(&dkwedges_lock); 708 709 if (rc != 0) 710 return rc; 711 712 pmf_device_deregister(self); 713 714 /* Locate the wedge major numbers. */ 715 bmaj = bdevsw_lookup_major(&dk_bdevsw); 716 cmaj = cdevsw_lookup_major(&dk_cdevsw); 717 718 /* Kill any pending restart. */ 719 callout_stop(&sc->sc_restart_ch); 720 721 /* 722 * dkstart() will kill any queued buffers now that the 723 * state of the wedge is not RUNNING. Once we've done 724 * that, wait for any other pending I/O to complete. 725 */ 726 dkstart(sc); 727 dkwedge_wait_drain(sc); 728 729 /* Nuke the vnodes for any open instances. */ 730 vdevgone(bmaj, unit, unit, VBLK); 731 vdevgone(cmaj, unit, unit, VCHR); 732 733 /* Clean up the parent. */ 734 dkwedge_cleanup_parent(sc, flags | DETACH_FORCE); 735 736 /* Announce our departure. */ 737 aprint_normal("%s at %s (%s) deleted\n", device_xname(sc->sc_dev), 738 sc->sc_parent->dk_name, 739 sc->sc_wname); /* XXX Unicode */ 740 741 mutex_enter(&sc->sc_parent->dk_openlock); 742 sc->sc_parent->dk_nwedges--; 743 LIST_REMOVE(sc, sc_plink); 744 mutex_exit(&sc->sc_parent->dk_openlock); 745 746 /* Delete our buffer queue. */ 747 bufq_free(sc->sc_bufq); 748 749 /* Detach from the disk list. */ 750 disk_detach(&sc->sc_dk); 751 disk_destroy(&sc->sc_dk); 752 753 /* Poof. */ 754 rw_enter(&dkwedges_lock, RW_WRITER); 755 dkwedges[unit] = NULL; 756 sc->sc_state = DKW_STATE_DEAD; 757 rw_exit(&dkwedges_lock); 758 759 mutex_destroy(&sc->sc_iolock); 760 cv_destroy(&sc->sc_dkdrn); 761 dkwedge_size_fini(sc); 762 763 free(sc, M_DKWEDGE); 764 765 return 0; 766 } 767 768 /* 769 * dkwedge_delall: [exported function] 770 * 771 * Delete all of the wedges on the specified disk. Used when 772 * a disk is being detached. 773 */ 774 void 775 dkwedge_delall(struct disk *pdk) 776 { 777 778 dkwedge_delall1(pdk, false); 779 } 780 781 static void 782 dkwedge_delall1(struct disk *pdk, bool idleonly) 783 { 784 struct dkwedge_info dkw; 785 struct dkwedge_softc *sc; 786 int flags; 787 788 flags = DETACH_QUIET; 789 if (!idleonly) 790 flags |= DETACH_FORCE; 791 792 for (;;) { 793 mutex_enter(&pdk->dk_openlock); 794 LIST_FOREACH(sc, &pdk->dk_wedges, sc_plink) { 795 if (!idleonly || sc->sc_dk.dk_openmask == 0) 796 break; 797 } 798 if (sc == NULL) { 799 KASSERT(idleonly || pdk->dk_nwedges == 0); 800 mutex_exit(&pdk->dk_openlock); 801 return; 802 } 803 strlcpy(dkw.dkw_parent, pdk->dk_name, sizeof(dkw.dkw_parent)); 804 strlcpy(dkw.dkw_devname, device_xname(sc->sc_dev), 805 sizeof(dkw.dkw_devname)); 806 mutex_exit(&pdk->dk_openlock); 807 (void) dkwedge_del1(&dkw, flags); 808 } 809 } 810 811 /* 812 * dkwedge_list: [exported function] 813 * 814 * List all of the wedges on a particular disk. 815 */ 816 int 817 dkwedge_list(struct disk *pdk, struct dkwedge_list *dkwl, struct lwp *l) 818 { 819 struct uio uio; 820 struct iovec iov; 821 struct dkwedge_softc *sc; 822 struct dkwedge_info dkw; 823 int error = 0; 824 825 iov.iov_base = dkwl->dkwl_buf; 826 iov.iov_len = dkwl->dkwl_bufsize; 827 828 uio.uio_iov = &iov; 829 uio.uio_iovcnt = 1; 830 uio.uio_offset = 0; 831 uio.uio_resid = dkwl->dkwl_bufsize; 832 uio.uio_rw = UIO_READ; 833 KASSERT(l == curlwp); 834 uio.uio_vmspace = l->l_proc->p_vmspace; 835 836 dkwl->dkwl_ncopied = 0; 837 838 mutex_enter(&pdk->dk_openlock); 839 LIST_FOREACH(sc, &pdk->dk_wedges, sc_plink) { 840 if (uio.uio_resid < sizeof(dkw)) 841 break; 842 843 if (sc->sc_state != DKW_STATE_RUNNING) 844 continue; 845 846 strlcpy(dkw.dkw_devname, device_xname(sc->sc_dev), 847 sizeof(dkw.dkw_devname)); 848 memcpy(dkw.dkw_wname, sc->sc_wname, sizeof(dkw.dkw_wname)); 849 dkw.dkw_wname[sizeof(dkw.dkw_wname) - 1] = '\0'; 850 strlcpy(dkw.dkw_parent, sc->sc_parent->dk_name, 851 sizeof(dkw.dkw_parent)); 852 dkw.dkw_offset = sc->sc_offset; 853 dkw.dkw_size = dkwedge_size(sc); 854 strlcpy(dkw.dkw_ptype, sc->sc_ptype, sizeof(dkw.dkw_ptype)); 855 856 error = uiomove(&dkw, sizeof(dkw), &uio); 857 if (error) 858 break; 859 dkwl->dkwl_ncopied++; 860 } 861 dkwl->dkwl_nwedges = pdk->dk_nwedges; 862 mutex_exit(&pdk->dk_openlock); 863 864 return error; 865 } 866 867 device_t 868 dkwedge_find_by_wname(const char *wname) 869 { 870 device_t dv = NULL; 871 struct dkwedge_softc *sc; 872 int i; 873 874 rw_enter(&dkwedges_lock, RW_WRITER); 875 for (i = 0; i < ndkwedges; i++) { 876 if ((sc = dkwedges[i]) == NULL) 877 continue; 878 if (strcmp(sc->sc_wname, wname) == 0) { 879 if (dv != NULL) { 880 printf( 881 "WARNING: double match for wedge name %s " 882 "(%s, %s)\n", wname, device_xname(dv), 883 device_xname(sc->sc_dev)); 884 continue; 885 } 886 dv = sc->sc_dev; 887 } 888 } 889 rw_exit(&dkwedges_lock); 890 return dv; 891 } 892 893 device_t 894 dkwedge_find_by_parent(const char *name, size_t *i) 895 { 896 897 rw_enter(&dkwedges_lock, RW_WRITER); 898 for (; *i < (size_t)ndkwedges; (*i)++) { 899 struct dkwedge_softc *sc; 900 if ((sc = dkwedges[*i]) == NULL) 901 continue; 902 if (strcmp(sc->sc_parent->dk_name, name) != 0) 903 continue; 904 rw_exit(&dkwedges_lock); 905 return sc->sc_dev; 906 } 907 rw_exit(&dkwedges_lock); 908 return NULL; 909 } 910 911 void 912 dkwedge_print_wnames(void) 913 { 914 struct dkwedge_softc *sc; 915 int i; 916 917 rw_enter(&dkwedges_lock, RW_WRITER); 918 for (i = 0; i < ndkwedges; i++) { 919 if ((sc = dkwedges[i]) == NULL) 920 continue; 921 printf(" wedge:%s", sc->sc_wname); 922 } 923 rw_exit(&dkwedges_lock); 924 } 925 926 /* 927 * We need a dummy object to stuff into the dkwedge discovery method link 928 * set to ensure that there is always at least one object in the set. 929 */ 930 static struct dkwedge_discovery_method dummy_discovery_method; 931 __link_set_add_bss(dkwedge_methods, dummy_discovery_method); 932 933 /* 934 * dkwedge_init: 935 * 936 * Initialize the disk wedge subsystem. 937 */ 938 void 939 dkwedge_init(void) 940 { 941 __link_set_decl(dkwedge_methods, struct dkwedge_discovery_method); 942 struct dkwedge_discovery_method * const *ddmp; 943 struct dkwedge_discovery_method *lddm, *ddm; 944 945 rw_init(&dkwedges_lock); 946 rw_init(&dkwedge_discovery_methods_lock); 947 948 if (config_cfdriver_attach(&dk_cd) != 0) 949 panic("dkwedge: unable to attach cfdriver"); 950 if (config_cfattach_attach(dk_cd.cd_name, &dk_ca) != 0) 951 panic("dkwedge: unable to attach cfattach"); 952 953 rw_enter(&dkwedge_discovery_methods_lock, RW_WRITER); 954 955 LIST_INIT(&dkwedge_discovery_methods); 956 957 __link_set_foreach(ddmp, dkwedge_methods) { 958 ddm = *ddmp; 959 if (ddm == &dummy_discovery_method) 960 continue; 961 if (LIST_EMPTY(&dkwedge_discovery_methods)) { 962 LIST_INSERT_HEAD(&dkwedge_discovery_methods, 963 ddm, ddm_list); 964 continue; 965 } 966 LIST_FOREACH(lddm, &dkwedge_discovery_methods, ddm_list) { 967 if (ddm->ddm_priority == lddm->ddm_priority) { 968 aprint_error("dk-method-%s: method \"%s\" " 969 "already exists at priority %d\n", 970 ddm->ddm_name, lddm->ddm_name, 971 lddm->ddm_priority); 972 /* Not inserted. */ 973 break; 974 } 975 if (ddm->ddm_priority < lddm->ddm_priority) { 976 /* Higher priority; insert before. */ 977 LIST_INSERT_BEFORE(lddm, ddm, ddm_list); 978 break; 979 } 980 if (LIST_NEXT(lddm, ddm_list) == NULL) { 981 /* Last one; insert after. */ 982 KASSERT(lddm->ddm_priority < ddm->ddm_priority); 983 LIST_INSERT_AFTER(lddm, ddm, ddm_list); 984 break; 985 } 986 } 987 } 988 989 rw_exit(&dkwedge_discovery_methods_lock); 990 } 991 992 #ifdef DKWEDGE_AUTODISCOVER 993 int dkwedge_autodiscover = 1; 994 #else 995 int dkwedge_autodiscover = 0; 996 #endif 997 998 /* 999 * dkwedge_discover: [exported function] 1000 * 1001 * Discover the wedges on a newly attached disk. 1002 * Remove all unused wedges on the disk first. 1003 */ 1004 void 1005 dkwedge_discover(struct disk *pdk) 1006 { 1007 struct dkwedge_discovery_method *ddm; 1008 struct vnode *vp; 1009 int error; 1010 dev_t pdev; 1011 1012 /* 1013 * Require people playing with wedges to enable this explicitly. 1014 */ 1015 if (dkwedge_autodiscover == 0) 1016 return; 1017 1018 rw_enter(&dkwedge_discovery_methods_lock, RW_READER); 1019 1020 /* 1021 * Use the character device for scanning, the block device 1022 * is busy if there are already wedges attached. 1023 */ 1024 error = dkwedge_compute_pdev(pdk->dk_name, &pdev, VCHR); 1025 if (error) { 1026 aprint_error("%s: unable to compute pdev, error = %d\n", 1027 pdk->dk_name, error); 1028 goto out; 1029 } 1030 1031 error = cdevvp(pdev, &vp); 1032 if (error) { 1033 aprint_error("%s: unable to find vnode for pdev, error = %d\n", 1034 pdk->dk_name, error); 1035 goto out; 1036 } 1037 1038 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1039 if (error) { 1040 aprint_error("%s: unable to lock vnode for pdev, error = %d\n", 1041 pdk->dk_name, error); 1042 vrele(vp); 1043 goto out; 1044 } 1045 1046 error = VOP_OPEN(vp, FREAD | FSILENT, NOCRED); 1047 if (error) { 1048 if (error != ENXIO) 1049 aprint_error("%s: unable to open device, error = %d\n", 1050 pdk->dk_name, error); 1051 vput(vp); 1052 goto out; 1053 } 1054 VOP_UNLOCK(vp); 1055 1056 /* 1057 * Remove unused wedges 1058 */ 1059 dkwedge_delall1(pdk, true); 1060 1061 /* 1062 * For each supported partition map type, look to see if 1063 * this map type exists. If so, parse it and add the 1064 * corresponding wedges. 1065 */ 1066 LIST_FOREACH(ddm, &dkwedge_discovery_methods, ddm_list) { 1067 error = (*ddm->ddm_discover)(pdk, vp); 1068 if (error == 0) { 1069 /* Successfully created wedges; we're done. */ 1070 break; 1071 } 1072 } 1073 1074 error = vn_close(vp, FREAD, NOCRED); 1075 if (error) { 1076 aprint_error("%s: unable to close device, error = %d\n", 1077 pdk->dk_name, error); 1078 /* We'll just assume the vnode has been cleaned up. */ 1079 } 1080 1081 out: 1082 rw_exit(&dkwedge_discovery_methods_lock); 1083 } 1084 1085 /* 1086 * dkwedge_read: 1087 * 1088 * Read some data from the specified disk, used for 1089 * partition discovery. 1090 */ 1091 int 1092 dkwedge_read(struct disk *pdk, struct vnode *vp, daddr_t blkno, 1093 void *tbuf, size_t len) 1094 { 1095 buf_t *bp; 1096 int error; 1097 bool isopen; 1098 dev_t bdev; 1099 struct vnode *bdvp; 1100 1101 /* 1102 * The kernel cannot read from a character device vnode 1103 * as physio() only handles user memory. 1104 * 1105 * If the block device has already been opened by a wedge 1106 * use that vnode and temporarily bump the open counter. 1107 * 1108 * Otherwise try to open the block device. 1109 */ 1110 1111 bdev = devsw_chr2blk(vp->v_rdev); 1112 1113 mutex_enter(&pdk->dk_rawlock); 1114 if (pdk->dk_rawopens != 0) { 1115 KASSERT(pdk->dk_rawvp != NULL); 1116 isopen = true; 1117 ++pdk->dk_rawopens; 1118 bdvp = pdk->dk_rawvp; 1119 error = 0; 1120 } else { 1121 isopen = false; 1122 error = dk_open_parent(bdev, FREAD, &bdvp); 1123 } 1124 mutex_exit(&pdk->dk_rawlock); 1125 1126 if (error) 1127 return error; 1128 1129 bp = getiobuf(bdvp, true); 1130 bp->b_flags = B_READ; 1131 bp->b_cflags = BC_BUSY; 1132 bp->b_dev = bdev; 1133 bp->b_data = tbuf; 1134 bp->b_bufsize = bp->b_bcount = len; 1135 bp->b_blkno = blkno; 1136 bp->b_cylinder = 0; 1137 bp->b_error = 0; 1138 1139 VOP_STRATEGY(bdvp, bp); 1140 error = biowait(bp); 1141 putiobuf(bp); 1142 1143 mutex_enter(&pdk->dk_rawlock); 1144 if (isopen) { 1145 --pdk->dk_rawopens; 1146 } else { 1147 dk_close_parent(bdvp, FREAD); 1148 } 1149 mutex_exit(&pdk->dk_rawlock); 1150 1151 return error; 1152 } 1153 1154 /* 1155 * dkwedge_lookup: 1156 * 1157 * Look up a dkwedge_softc based on the provided dev_t. 1158 */ 1159 static struct dkwedge_softc * 1160 dkwedge_lookup(dev_t dev) 1161 { 1162 int unit = minor(dev); 1163 1164 if (unit >= ndkwedges) 1165 return NULL; 1166 1167 KASSERT(dkwedges != NULL); 1168 1169 return dkwedges[unit]; 1170 } 1171 1172 static int 1173 dk_open_parent(dev_t dev, int mode, struct vnode **vpp) 1174 { 1175 struct vnode *vp; 1176 int error; 1177 1178 error = bdevvp(dev, &vp); 1179 if (error) 1180 return error; 1181 1182 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 1183 if (error) { 1184 vrele(vp); 1185 return error; 1186 } 1187 error = VOP_OPEN(vp, mode, NOCRED); 1188 if (error) { 1189 vput(vp); 1190 return error; 1191 } 1192 1193 /* VOP_OPEN() doesn't do this for us. */ 1194 if (mode & FWRITE) { 1195 mutex_enter(vp->v_interlock); 1196 vp->v_writecount++; 1197 mutex_exit(vp->v_interlock); 1198 } 1199 1200 VOP_UNLOCK(vp); 1201 1202 *vpp = vp; 1203 1204 return 0; 1205 } 1206 1207 static int 1208 dk_close_parent(struct vnode *vp, int mode) 1209 { 1210 int error; 1211 1212 error = vn_close(vp, mode, NOCRED); 1213 return error; 1214 } 1215 1216 /* 1217 * dkopen: [devsw entry point] 1218 * 1219 * Open a wedge. 1220 */ 1221 static int 1222 dkopen(dev_t dev, int flags, int fmt, struct lwp *l) 1223 { 1224 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1225 int error = 0; 1226 1227 if (sc == NULL) 1228 return ENXIO; 1229 if (sc->sc_state != DKW_STATE_RUNNING) 1230 return ENXIO; 1231 1232 /* 1233 * We go through a complicated little dance to only open the parent 1234 * vnode once per wedge, no matter how many times the wedge is 1235 * opened. The reason? We see one dkopen() per open call, but 1236 * only dkclose() on the last close. 1237 */ 1238 mutex_enter(&sc->sc_dk.dk_openlock); 1239 mutex_enter(&sc->sc_parent->dk_rawlock); 1240 if (sc->sc_dk.dk_openmask == 0) { 1241 error = dkfirstopen(sc, flags); 1242 if (error) 1243 goto popen_fail; 1244 } 1245 KASSERT(sc->sc_mode != 0); 1246 if (flags & ~sc->sc_mode & FWRITE) { 1247 error = EROFS; 1248 goto popen_fail; 1249 } 1250 if (fmt == S_IFCHR) 1251 sc->sc_dk.dk_copenmask |= 1; 1252 else 1253 sc->sc_dk.dk_bopenmask |= 1; 1254 sc->sc_dk.dk_openmask = 1255 sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask; 1256 1257 popen_fail: 1258 mutex_exit(&sc->sc_parent->dk_rawlock); 1259 mutex_exit(&sc->sc_dk.dk_openlock); 1260 return error; 1261 } 1262 1263 static int 1264 dkfirstopen(struct dkwedge_softc *sc, int flags) 1265 { 1266 struct dkwedge_softc *nsc; 1267 struct vnode *vp; 1268 int mode; 1269 int error; 1270 1271 KASSERT(mutex_owned(&sc->sc_dk.dk_openlock)); 1272 KASSERT(mutex_owned(&sc->sc_parent->dk_rawlock)); 1273 1274 if (sc->sc_parent->dk_rawopens == 0) { 1275 KASSERT(sc->sc_parent->dk_rawvp == NULL); 1276 /* 1277 * Try open read-write. If this fails for EROFS 1278 * and wedge is read-only, retry to open read-only. 1279 */ 1280 mode = FREAD | FWRITE; 1281 error = dk_open_parent(sc->sc_pdev, mode, &vp); 1282 if (error == EROFS && (flags & FWRITE) == 0) { 1283 mode &= ~FWRITE; 1284 error = dk_open_parent(sc->sc_pdev, mode, &vp); 1285 } 1286 if (error) 1287 return error; 1288 sc->sc_parent->dk_rawvp = vp; 1289 } else { 1290 /* 1291 * Retrieve mode from an already opened wedge. 1292 * 1293 * At this point, dk_rawopens is bounded by the number 1294 * of dkwedge devices in the system, which is limited 1295 * by autoconf device numbering to INT_MAX. Since 1296 * dk_rawopens is unsigned, this can't overflow. 1297 */ 1298 KASSERT(sc->sc_parent->dk_rawopens < UINT_MAX); 1299 mode = 0; 1300 LIST_FOREACH(nsc, &sc->sc_parent->dk_wedges, sc_plink) { 1301 if (nsc == sc || nsc->sc_dk.dk_openmask == 0) 1302 continue; 1303 mode = nsc->sc_mode; 1304 break; 1305 } 1306 } 1307 sc->sc_mode = mode; 1308 sc->sc_parent->dk_rawopens++; 1309 1310 return 0; 1311 } 1312 1313 static void 1314 dklastclose(struct dkwedge_softc *sc) 1315 { 1316 1317 KASSERT(mutex_owned(&sc->sc_dk.dk_openlock)); 1318 KASSERT(mutex_owned(&sc->sc_parent->dk_rawlock)); 1319 KASSERT(sc->sc_parent->dk_rawopens > 0); 1320 KASSERT(sc->sc_parent->dk_rawvp != NULL); 1321 1322 if (--sc->sc_parent->dk_rawopens == 0) { 1323 struct vnode *const vp = sc->sc_parent->dk_rawvp; 1324 const int mode = sc->sc_mode; 1325 1326 sc->sc_parent->dk_rawvp = NULL; 1327 sc->sc_mode = 0; 1328 1329 dk_close_parent(vp, mode); 1330 } 1331 } 1332 1333 /* 1334 * dkclose: [devsw entry point] 1335 * 1336 * Close a wedge. 1337 */ 1338 static int 1339 dkclose(dev_t dev, int flags, int fmt, struct lwp *l) 1340 { 1341 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1342 1343 if (sc == NULL) 1344 return ENXIO; 1345 if (sc->sc_state != DKW_STATE_RUNNING) 1346 return ENXIO; 1347 1348 mutex_enter(&sc->sc_dk.dk_openlock); 1349 mutex_enter(&sc->sc_parent->dk_rawlock); 1350 1351 KASSERT(sc->sc_dk.dk_openmask != 0); 1352 1353 if (fmt == S_IFCHR) 1354 sc->sc_dk.dk_copenmask &= ~1; 1355 else 1356 sc->sc_dk.dk_bopenmask &= ~1; 1357 sc->sc_dk.dk_openmask = 1358 sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask; 1359 1360 if (sc->sc_dk.dk_openmask == 0) { 1361 dklastclose(sc); 1362 } 1363 1364 mutex_exit(&sc->sc_parent->dk_rawlock); 1365 mutex_exit(&sc->sc_dk.dk_openlock); 1366 1367 return 0; 1368 } 1369 1370 /* 1371 * dkstrategy: [devsw entry point] 1372 * 1373 * Perform I/O based on the wedge I/O strategy. 1374 */ 1375 static void 1376 dkstrategy(struct buf *bp) 1377 { 1378 struct dkwedge_softc *sc = dkwedge_lookup(bp->b_dev); 1379 uint64_t p_size, p_offset; 1380 1381 if (sc == NULL) { 1382 bp->b_error = ENXIO; 1383 goto done; 1384 } 1385 1386 if (sc->sc_state != DKW_STATE_RUNNING || 1387 sc->sc_parent->dk_rawvp == NULL) { 1388 bp->b_error = ENXIO; 1389 goto done; 1390 } 1391 1392 /* If it's an empty transfer, wake up the top half now. */ 1393 if (bp->b_bcount == 0) 1394 goto done; 1395 1396 p_offset = sc->sc_offset << sc->sc_parent->dk_blkshift; 1397 p_size = dkwedge_size(sc) << sc->sc_parent->dk_blkshift; 1398 1399 /* Make sure it's in-range. */ 1400 if (bounds_check_with_mediasize(bp, DEV_BSIZE, p_size) <= 0) 1401 goto done; 1402 1403 /* Translate it to the parent's raw LBA. */ 1404 bp->b_rawblkno = bp->b_blkno + p_offset; 1405 1406 /* Place it in the queue and start I/O on the unit. */ 1407 mutex_enter(&sc->sc_iolock); 1408 sc->sc_iopend++; 1409 disk_wait(&sc->sc_dk); 1410 bufq_put(sc->sc_bufq, bp); 1411 mutex_exit(&sc->sc_iolock); 1412 1413 dkstart(sc); 1414 return; 1415 1416 done: 1417 bp->b_resid = bp->b_bcount; 1418 biodone(bp); 1419 } 1420 1421 /* 1422 * dkstart: 1423 * 1424 * Start I/O that has been enqueued on the wedge. 1425 */ 1426 static void 1427 dkstart(struct dkwedge_softc *sc) 1428 { 1429 struct vnode *vp; 1430 struct buf *bp, *nbp; 1431 1432 mutex_enter(&sc->sc_iolock); 1433 1434 /* Do as much work as has been enqueued. */ 1435 while ((bp = bufq_peek(sc->sc_bufq)) != NULL) { 1436 if (sc->sc_state != DKW_STATE_RUNNING) { 1437 (void) bufq_get(sc->sc_bufq); 1438 if (--sc->sc_iopend == 0) 1439 cv_broadcast(&sc->sc_dkdrn); 1440 mutex_exit(&sc->sc_iolock); 1441 bp->b_error = ENXIO; 1442 bp->b_resid = bp->b_bcount; 1443 biodone(bp); 1444 mutex_enter(&sc->sc_iolock); 1445 continue; 1446 } 1447 1448 /* fetch an I/O buf with sc_iolock dropped */ 1449 mutex_exit(&sc->sc_iolock); 1450 nbp = getiobuf(sc->sc_parent->dk_rawvp, false); 1451 mutex_enter(&sc->sc_iolock); 1452 if (nbp == NULL) { 1453 /* 1454 * No resources to run this request; leave the 1455 * buffer queued up, and schedule a timer to 1456 * restart the queue in 1/2 a second. 1457 */ 1458 callout_schedule(&sc->sc_restart_ch, hz/2); 1459 break; 1460 } 1461 1462 /* 1463 * fetch buf, this can fail if another thread 1464 * has already processed the queue, it can also 1465 * return a completely different buf. 1466 */ 1467 bp = bufq_get(sc->sc_bufq); 1468 if (bp == NULL) { 1469 mutex_exit(&sc->sc_iolock); 1470 putiobuf(nbp); 1471 mutex_enter(&sc->sc_iolock); 1472 continue; 1473 } 1474 1475 /* Instrumentation. */ 1476 disk_busy(&sc->sc_dk); 1477 1478 /* release lock for VOP_STRATEGY */ 1479 mutex_exit(&sc->sc_iolock); 1480 1481 nbp->b_data = bp->b_data; 1482 nbp->b_flags = bp->b_flags; 1483 nbp->b_oflags = bp->b_oflags; 1484 nbp->b_cflags = bp->b_cflags; 1485 nbp->b_iodone = dkiodone; 1486 nbp->b_proc = bp->b_proc; 1487 nbp->b_blkno = bp->b_rawblkno; 1488 nbp->b_dev = sc->sc_parent->dk_rawvp->v_rdev; 1489 nbp->b_bcount = bp->b_bcount; 1490 nbp->b_private = bp; 1491 BIO_COPYPRIO(nbp, bp); 1492 1493 vp = nbp->b_vp; 1494 if ((nbp->b_flags & B_READ) == 0) { 1495 mutex_enter(vp->v_interlock); 1496 vp->v_numoutput++; 1497 mutex_exit(vp->v_interlock); 1498 } 1499 VOP_STRATEGY(vp, nbp); 1500 1501 mutex_enter(&sc->sc_iolock); 1502 } 1503 1504 mutex_exit(&sc->sc_iolock); 1505 } 1506 1507 /* 1508 * dkiodone: 1509 * 1510 * I/O to a wedge has completed; alert the top half. 1511 */ 1512 static void 1513 dkiodone(struct buf *bp) 1514 { 1515 struct buf *obp = bp->b_private; 1516 struct dkwedge_softc *sc = dkwedge_lookup(obp->b_dev); 1517 1518 if (bp->b_error != 0) 1519 obp->b_error = bp->b_error; 1520 obp->b_resid = bp->b_resid; 1521 putiobuf(bp); 1522 1523 mutex_enter(&sc->sc_iolock); 1524 if (--sc->sc_iopend == 0) 1525 cv_broadcast(&sc->sc_dkdrn); 1526 1527 disk_unbusy(&sc->sc_dk, obp->b_bcount - obp->b_resid, 1528 obp->b_flags & B_READ); 1529 mutex_exit(&sc->sc_iolock); 1530 1531 biodone(obp); 1532 1533 /* Kick the queue in case there is more work we can do. */ 1534 dkstart(sc); 1535 } 1536 1537 /* 1538 * dkrestart: 1539 * 1540 * Restart the work queue after it was stalled due to 1541 * a resource shortage. Invoked via a callout. 1542 */ 1543 static void 1544 dkrestart(void *v) 1545 { 1546 struct dkwedge_softc *sc = v; 1547 1548 dkstart(sc); 1549 } 1550 1551 /* 1552 * dkminphys: 1553 * 1554 * Call parent's minphys function. 1555 */ 1556 static void 1557 dkminphys(struct buf *bp) 1558 { 1559 struct dkwedge_softc *sc = dkwedge_lookup(bp->b_dev); 1560 dev_t dev; 1561 1562 dev = bp->b_dev; 1563 bp->b_dev = sc->sc_pdev; 1564 if (sc->sc_parent->dk_driver && sc->sc_parent->dk_driver->d_minphys) 1565 (*sc->sc_parent->dk_driver->d_minphys)(bp); 1566 else 1567 minphys(bp); 1568 bp->b_dev = dev; 1569 } 1570 1571 /* 1572 * dkread: [devsw entry point] 1573 * 1574 * Read from a wedge. 1575 */ 1576 static int 1577 dkread(dev_t dev, struct uio *uio, int flags) 1578 { 1579 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1580 1581 if (sc == NULL) 1582 return ENXIO; 1583 if (sc->sc_state != DKW_STATE_RUNNING) 1584 return ENXIO; 1585 1586 return physio(dkstrategy, NULL, dev, B_READ, dkminphys, uio); 1587 } 1588 1589 /* 1590 * dkwrite: [devsw entry point] 1591 * 1592 * Write to a wedge. 1593 */ 1594 static int 1595 dkwrite(dev_t dev, struct uio *uio, int flags) 1596 { 1597 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1598 1599 if (sc == NULL) 1600 return ENXIO; 1601 if (sc->sc_state != DKW_STATE_RUNNING) 1602 return ENXIO; 1603 1604 return physio(dkstrategy, NULL, dev, B_WRITE, dkminphys, uio); 1605 } 1606 1607 /* 1608 * dkioctl: [devsw entry point] 1609 * 1610 * Perform an ioctl request on a wedge. 1611 */ 1612 static int 1613 dkioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 1614 { 1615 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1616 int error = 0; 1617 1618 if (sc == NULL) 1619 return ENXIO; 1620 if (sc->sc_state != DKW_STATE_RUNNING) 1621 return ENXIO; 1622 if (sc->sc_parent->dk_rawvp == NULL) 1623 return ENXIO; 1624 1625 /* 1626 * We pass NODEV instead of our device to indicate we don't 1627 * want to handle disklabel ioctls 1628 */ 1629 error = disk_ioctl(&sc->sc_dk, NODEV, cmd, data, flag, l); 1630 if (error != EPASSTHROUGH) 1631 return error; 1632 1633 error = 0; 1634 1635 switch (cmd) { 1636 case DIOCGSTRATEGY: 1637 case DIOCGCACHE: 1638 case DIOCCACHESYNC: 1639 error = VOP_IOCTL(sc->sc_parent->dk_rawvp, cmd, data, flag, 1640 l != NULL ? l->l_cred : NOCRED); 1641 break; 1642 case DIOCGWEDGEINFO: { 1643 struct dkwedge_info *dkw = data; 1644 1645 strlcpy(dkw->dkw_devname, device_xname(sc->sc_dev), 1646 sizeof(dkw->dkw_devname)); 1647 memcpy(dkw->dkw_wname, sc->sc_wname, sizeof(dkw->dkw_wname)); 1648 dkw->dkw_wname[sizeof(dkw->dkw_wname) - 1] = '\0'; 1649 strlcpy(dkw->dkw_parent, sc->sc_parent->dk_name, 1650 sizeof(dkw->dkw_parent)); 1651 dkw->dkw_offset = sc->sc_offset; 1652 dkw->dkw_size = dkwedge_size(sc); 1653 strlcpy(dkw->dkw_ptype, sc->sc_ptype, sizeof(dkw->dkw_ptype)); 1654 1655 break; 1656 } 1657 case DIOCGSECTORALIGN: { 1658 struct disk_sectoralign *dsa = data; 1659 uint32_t r; 1660 1661 error = VOP_IOCTL(sc->sc_parent->dk_rawvp, cmd, dsa, flag, 1662 l != NULL ? l->l_cred : NOCRED); 1663 if (error) 1664 break; 1665 1666 r = sc->sc_offset % dsa->dsa_alignment; 1667 if (r < dsa->dsa_firstaligned) 1668 dsa->dsa_firstaligned = dsa->dsa_firstaligned - r; 1669 else 1670 dsa->dsa_firstaligned = (dsa->dsa_firstaligned + 1671 dsa->dsa_alignment) - r; 1672 break; 1673 } 1674 default: 1675 error = ENOTTY; 1676 } 1677 1678 return error; 1679 } 1680 1681 /* 1682 * dkdiscard: [devsw entry point] 1683 * 1684 * Perform a discard-range request on a wedge. 1685 */ 1686 static int 1687 dkdiscard(dev_t dev, off_t pos, off_t len) 1688 { 1689 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1690 uint64_t size = dkwedge_size(sc); 1691 unsigned shift; 1692 off_t offset, maxlen; 1693 int error; 1694 1695 if (sc == NULL) 1696 return ENXIO; 1697 if (sc->sc_state != DKW_STATE_RUNNING) 1698 return ENXIO; 1699 if (sc->sc_parent->dk_rawvp == NULL) 1700 return ENXIO; 1701 1702 /* XXX check bounds on size/offset up front */ 1703 shift = (sc->sc_parent->dk_blkshift + DEV_BSHIFT); 1704 KASSERT(__type_fit(off_t, size)); 1705 KASSERT(__type_fit(off_t, sc->sc_offset)); 1706 KASSERT(0 <= sc->sc_offset); 1707 KASSERT(size <= (__type_max(off_t) >> shift)); 1708 KASSERT(sc->sc_offset <= ((__type_max(off_t) >> shift) - size)); 1709 offset = ((off_t)sc->sc_offset << shift); 1710 maxlen = ((off_t)size << shift); 1711 1712 if (len > maxlen) 1713 return EINVAL; 1714 if (pos > (maxlen - len)) 1715 return EINVAL; 1716 1717 pos += offset; 1718 1719 vn_lock(sc->sc_parent->dk_rawvp, LK_EXCLUSIVE | LK_RETRY); 1720 error = VOP_FDISCARD(sc->sc_parent->dk_rawvp, pos, len); 1721 VOP_UNLOCK(sc->sc_parent->dk_rawvp); 1722 1723 return error; 1724 } 1725 1726 /* 1727 * dksize: [devsw entry point] 1728 * 1729 * Query the size of a wedge for the purpose of performing a dump 1730 * or for swapping to. 1731 */ 1732 static int 1733 dksize(dev_t dev) 1734 { 1735 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1736 uint64_t p_size; 1737 int rv = -1; 1738 1739 if (sc == NULL) 1740 return -1; 1741 if (sc->sc_state != DKW_STATE_RUNNING) 1742 return -1; 1743 1744 mutex_enter(&sc->sc_dk.dk_openlock); 1745 mutex_enter(&sc->sc_parent->dk_rawlock); 1746 1747 /* Our content type is static, no need to open the device. */ 1748 1749 p_size = dkwedge_size(sc) << sc->sc_parent->dk_blkshift; 1750 if (strcmp(sc->sc_ptype, DKW_PTYPE_SWAP) == 0) { 1751 /* Saturate if we are larger than INT_MAX. */ 1752 if (p_size > INT_MAX) 1753 rv = INT_MAX; 1754 else 1755 rv = (int)p_size; 1756 } 1757 1758 mutex_exit(&sc->sc_parent->dk_rawlock); 1759 mutex_exit(&sc->sc_dk.dk_openlock); 1760 1761 return rv; 1762 } 1763 1764 /* 1765 * dkdump: [devsw entry point] 1766 * 1767 * Perform a crash dump to a wedge. 1768 */ 1769 static int 1770 dkdump(dev_t dev, daddr_t blkno, void *va, size_t size) 1771 { 1772 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1773 const struct bdevsw *bdev; 1774 uint64_t p_size, p_offset; 1775 int rv = 0; 1776 1777 if (sc == NULL) 1778 return ENXIO; 1779 if (sc->sc_state != DKW_STATE_RUNNING) 1780 return ENXIO; 1781 1782 mutex_enter(&sc->sc_dk.dk_openlock); 1783 mutex_enter(&sc->sc_parent->dk_rawlock); 1784 1785 /* Our content type is static, no need to open the device. */ 1786 1787 if (strcmp(sc->sc_ptype, DKW_PTYPE_SWAP) != 0 && 1788 strcmp(sc->sc_ptype, DKW_PTYPE_RAID) != 0 && 1789 strcmp(sc->sc_ptype, DKW_PTYPE_CGD) != 0) { 1790 rv = ENXIO; 1791 goto out; 1792 } 1793 if (size % DEV_BSIZE != 0) { 1794 rv = EINVAL; 1795 goto out; 1796 } 1797 1798 p_offset = sc->sc_offset << sc->sc_parent->dk_blkshift; 1799 p_size = dkwedge_size(sc) << sc->sc_parent->dk_blkshift; 1800 1801 if (blkno < 0 || blkno + size/DEV_BSIZE > p_size) { 1802 printf("%s: blkno (%" PRIu64 ") + size / DEV_BSIZE (%zu) > " 1803 "p_size (%" PRIu64 ")\n", __func__, blkno, 1804 size/DEV_BSIZE, p_size); 1805 rv = EINVAL; 1806 goto out; 1807 } 1808 1809 bdev = bdevsw_lookup(sc->sc_pdev); 1810 rv = (*bdev->d_dump)(sc->sc_pdev, blkno + p_offset, va, size); 1811 1812 out: 1813 mutex_exit(&sc->sc_parent->dk_rawlock); 1814 mutex_exit(&sc->sc_dk.dk_openlock); 1815 1816 return rv; 1817 } 1818 1819 /* 1820 * config glue 1821 */ 1822 1823 /* 1824 * dkwedge_find_partition 1825 * 1826 * Find wedge corresponding to the specified parent name 1827 * and offset/length. 1828 */ 1829 device_t 1830 dkwedge_find_partition(device_t parent, daddr_t startblk, uint64_t nblks) 1831 { 1832 struct dkwedge_softc *sc; 1833 int i; 1834 device_t wedge = NULL; 1835 1836 rw_enter(&dkwedges_lock, RW_READER); 1837 for (i = 0; i < ndkwedges; i++) { 1838 if ((sc = dkwedges[i]) == NULL) 1839 continue; 1840 if (strcmp(sc->sc_parent->dk_name, device_xname(parent)) == 0 && 1841 sc->sc_offset == startblk && 1842 dkwedge_size(sc) == nblks) { 1843 if (wedge) { 1844 printf("WARNING: double match for boot wedge " 1845 "(%s, %s)\n", 1846 device_xname(wedge), 1847 device_xname(sc->sc_dev)); 1848 continue; 1849 } 1850 wedge = sc->sc_dev; 1851 } 1852 } 1853 rw_exit(&dkwedges_lock); 1854 1855 return wedge; 1856 } 1857 1858 const char * 1859 dkwedge_get_parent_name(dev_t dev) 1860 { 1861 /* XXX: perhaps do this in lookup? */ 1862 int bmaj = bdevsw_lookup_major(&dk_bdevsw); 1863 int cmaj = cdevsw_lookup_major(&dk_cdevsw); 1864 1865 if (major(dev) != bmaj && major(dev) != cmaj) 1866 return NULL; 1867 struct dkwedge_softc *sc = dkwedge_lookup(dev); 1868 if (sc == NULL) 1869 return NULL; 1870 return sc->sc_parent->dk_name; 1871 } 1872
Indexes created Thu Sep 25 16:09:42 GMT 2025