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