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