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