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