/* $NetBSD: dk.c,v 1.173 2025/04/13 14:01:00 jakllsch Exp $ */ /*- * Copyright (c) 2004, 2005, 2006, 2007 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Jason R. Thorpe. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: dk.c,v 1.173 2025/04/13 14:01:00 jakllsch Exp $"); #ifdef _KERNEL_OPT #include "opt_dkwedge.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include MALLOC_DEFINE(M_DKWEDGE, "dkwedge", "Disk wedge structures"); typedef enum { DKW_STATE_LARVAL = 0, DKW_STATE_RUNNING = 1, DKW_STATE_DYING = 2, DKW_STATE_DEAD = 666 } dkwedge_state_t; /* * Lock order: * * sc->sc_dk.dk_openlock * => sc->sc_parent->dk_rawlock * => sc->sc_parent->dk_openlock * => dkwedges_lock * => sc->sc_sizelock * * Locking notes: * * W dkwedges_lock * D device reference * O sc->sc_dk.dk_openlock * P sc->sc_parent->dk_openlock * R sc->sc_parent->dk_rawlock * S sc->sc_sizelock * I sc->sc_iolock * $ stable after initialization * 1 used only by a single thread * * x&y means both x and y must be held to write (with a write lock if * one is rwlock), and either x or y must be held to read. */ struct dkwedge_softc { device_t sc_dev; /* P&W: pointer to our pseudo-device */ /* sc_dev is also stable while device is referenced */ struct cfdata sc_cfdata; /* 1: our cfdata structure */ uint8_t sc_wname[128]; /* $: wedge name (Unicode, UTF-8) */ dkwedge_state_t sc_state; /* state this wedge is in */ /* stable while device is referenced */ /* used only in assertions when stable, and in dump in ddb */ struct disk *sc_parent; /* $: parent disk */ /* P: sc_parent->dk_openmask */ /* P: sc_parent->dk_nwedges */ /* P: sc_parent->dk_wedges */ /* R: sc_parent->dk_rawopens */ /* R: sc_parent->dk_rawvp (also stable while wedge is open) */ daddr_t sc_offset; /* $: LBA offset of wedge in parent */ krwlock_t sc_sizelock; uint64_t sc_size; /* S: size of wedge in blocks */ char sc_ptype[32]; /* $: partition type */ dev_t sc_pdev; /* $: cached parent's dev_t */ /* P: link on parent's wedge list */ LIST_ENTRY(dkwedge_softc) sc_plink; struct disk sc_dk; /* our own disk structure */ /* O&R: sc_dk.dk_bopenmask */ /* O&R: sc_dk.dk_copenmask */ /* O&R: sc_dk.dk_openmask */ struct bufq_state *sc_bufq; /* $: buffer queue */ struct callout sc_restart_ch; /* I: callout to restart I/O */ kmutex_t sc_iolock; bool sc_iostop; /* I: don't schedule restart */ int sc_mode; /* O&R: parent open mode */ }; static int dkwedge_match(device_t, cfdata_t, void *); static void dkwedge_attach(device_t, device_t, void *); static int dkwedge_detach(device_t, int); static void dk_set_geometry(struct dkwedge_softc *, struct disk *); static void dkstart(struct dkwedge_softc *); static void dkiodone(struct buf *); static void dkrestart(void *); static void dkminphys(struct buf *); static int dkfirstopen(struct dkwedge_softc *, int); static void dklastclose(struct dkwedge_softc *); static int dkwedge_detach(device_t, int); static void dkwedge_delall1(struct disk *, bool); static int dkwedge_del1(struct dkwedge_info *, int); static int dk_open_parent(dev_t, int, struct vnode **); static int dk_close_parent(struct vnode *, int); static dev_type_open(dkopen); static dev_type_close(dkclose); static dev_type_cancel(dkcancel); static dev_type_read(dkread); static dev_type_write(dkwrite); static dev_type_ioctl(dkioctl); static dev_type_strategy(dkstrategy); static dev_type_dump(dkdump); static dev_type_size(dksize); static dev_type_discard(dkdiscard); CFDRIVER_DECL(dk, DV_DISK, NULL); CFATTACH_DECL3_NEW(dk, 0, dkwedge_match, dkwedge_attach, dkwedge_detach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN); const struct bdevsw dk_bdevsw = { .d_open = dkopen, .d_close = dkclose, .d_cancel = dkcancel, .d_strategy = dkstrategy, .d_ioctl = dkioctl, .d_dump = dkdump, .d_psize = dksize, .d_discard = dkdiscard, .d_cfdriver = &dk_cd, .d_devtounit = dev_minor_unit, .d_flag = D_DISK | D_MPSAFE }; const struct cdevsw dk_cdevsw = { .d_open = dkopen, .d_close = dkclose, .d_cancel = dkcancel, .d_read = dkread, .d_write = dkwrite, .d_ioctl = dkioctl, .d_stop = nostop, .d_tty = notty, .d_poll = nopoll, .d_mmap = nommap, .d_kqfilter = nokqfilter, .d_discard = dkdiscard, .d_cfdriver = &dk_cd, .d_devtounit = dev_minor_unit, .d_flag = D_DISK | D_MPSAFE }; static struct dkwedge_softc **dkwedges; static u_int ndkwedges; static krwlock_t dkwedges_lock; static LIST_HEAD(, dkwedge_discovery_method) dkwedge_discovery_methods; static krwlock_t dkwedge_discovery_methods_lock; /* * dkwedge_match: * * Autoconfiguration match function for pseudo-device glue. */ static int dkwedge_match(device_t parent, cfdata_t match, void *aux) { /* Pseudo-device; always present. */ return 1; } /* * dkwedge_attach: * * Autoconfiguration attach function for pseudo-device glue. */ static void dkwedge_attach(device_t parent, device_t self, void *aux) { struct dkwedge_softc *sc = aux; struct disk *pdk = sc->sc_parent; int unit = device_unit(self); KASSERTMSG(unit >= 0, "unit=%d", unit); if (!pmf_device_register(self, NULL, NULL)) aprint_error_dev(self, "couldn't establish power handler\n"); mutex_enter(&pdk->dk_openlock); rw_enter(&dkwedges_lock, RW_WRITER); KASSERTMSG(unit < ndkwedges, "unit=%d ndkwedges=%u", unit, ndkwedges); KASSERTMSG(sc == dkwedges[unit], "sc=%p dkwedges[%d]=%p", sc, unit, dkwedges[unit]); KASSERTMSG(sc->sc_dev == NULL, "sc=%p sc->sc_dev=%p", sc, sc->sc_dev); sc->sc_dev = self; rw_exit(&dkwedges_lock); mutex_exit(&pdk->dk_openlock); disk_init(&sc->sc_dk, device_xname(sc->sc_dev), NULL); mutex_enter(&pdk->dk_openlock); dk_set_geometry(sc, pdk); mutex_exit(&pdk->dk_openlock); disk_attach(&sc->sc_dk); /* Disk wedge is ready for use! */ device_set_private(self, sc); sc->sc_state = DKW_STATE_RUNNING; } /* * dkwedge_compute_pdev: * * Compute the parent disk's dev_t. */ static int dkwedge_compute_pdev(const char *pname, dev_t *pdevp, enum vtype type) { const char *name, *cp; devmajor_t pmaj; int punit; char devname[16]; name = pname; switch (type) { case VBLK: pmaj = devsw_name2blk(name, devname, sizeof(devname)); break; case VCHR: pmaj = devsw_name2chr(name, devname, sizeof(devname)); break; default: pmaj = NODEVMAJOR; break; } if (pmaj == NODEVMAJOR) return ENXIO; name += strlen(devname); for (cp = name, punit = 0; *cp >= '0' && *cp <= '9'; cp++) punit = (punit * 10) + (*cp - '0'); if (cp == name) { /* Invalid parent disk name. */ return ENXIO; } *pdevp = MAKEDISKDEV(pmaj, punit, RAW_PART); return 0; } /* * dkwedge_array_expand: * * Expand the dkwedges array. * * Releases and reacquires dkwedges_lock as a writer. */ static int dkwedge_array_expand(void) { const unsigned incr = 16; unsigned newcnt, oldcnt; struct dkwedge_softc **newarray = NULL, **oldarray = NULL; KASSERT(rw_write_held(&dkwedges_lock)); oldcnt = ndkwedges; oldarray = dkwedges; if (oldcnt >= INT_MAX - incr) return ENFILE; /* XXX */ newcnt = oldcnt + incr; rw_exit(&dkwedges_lock); newarray = malloc(newcnt * sizeof(*newarray), M_DKWEDGE, M_WAITOK|M_ZERO); rw_enter(&dkwedges_lock, RW_WRITER); if (ndkwedges != oldcnt || dkwedges != oldarray) { oldarray = NULL; /* already recycled */ goto out; } if (oldarray != NULL) memcpy(newarray, dkwedges, ndkwedges * sizeof(*newarray)); dkwedges = newarray; newarray = NULL; /* transferred to dkwedges */ ndkwedges = newcnt; out: rw_exit(&dkwedges_lock); if (oldarray != NULL) free(oldarray, M_DKWEDGE); if (newarray != NULL) free(newarray, M_DKWEDGE); rw_enter(&dkwedges_lock, RW_WRITER); return 0; } static void dkwedge_size_init(struct dkwedge_softc *sc, uint64_t size) { rw_init(&sc->sc_sizelock); sc->sc_size = size; } static void dkwedge_size_fini(struct dkwedge_softc *sc) { rw_destroy(&sc->sc_sizelock); } static uint64_t dkwedge_size(struct dkwedge_softc *sc) { uint64_t size; rw_enter(&sc->sc_sizelock, RW_READER); size = sc->sc_size; rw_exit(&sc->sc_sizelock); return size; } static void dkwedge_size_increase(struct dkwedge_softc *sc, uint64_t size) { KASSERT(mutex_owned(&sc->sc_parent->dk_openlock)); rw_enter(&sc->sc_sizelock, RW_WRITER); KASSERTMSG(size >= sc->sc_size, "decreasing dkwedge size from %"PRIu64" to %"PRIu64, sc->sc_size, size); sc->sc_size = size; rw_exit(&sc->sc_sizelock); } static void dk_set_geometry(struct dkwedge_softc *sc, struct disk *pdk) { struct disk *dk = &sc->sc_dk; struct disk_geom *dg = &dk->dk_geom; uint32_t r, lspps; KASSERT(mutex_owned(&pdk->dk_openlock)); memset(dg, 0, sizeof(*dg)); dg->dg_secperunit = dkwedge_size(sc); dg->dg_secsize = DEV_BSIZE << pdk->dk_blkshift; /* fake numbers, 1 cylinder is 1 MB with default sector size */ dg->dg_nsectors = 32; dg->dg_ntracks = 64; dg->dg_ncylinders = dg->dg_secperunit / (dg->dg_nsectors * dg->dg_ntracks); dg->dg_physsecsize = pdk->dk_geom.dg_physsecsize; dg->dg_alignedsec = pdk->dk_geom.dg_alignedsec; lspps = MAX(1u, dg->dg_physsecsize / dg->dg_secsize); r = sc->sc_offset % lspps; if (r > dg->dg_alignedsec) dg->dg_alignedsec += lspps; dg->dg_alignedsec -= r; dg->dg_alignedsec %= lspps; disk_set_info(sc->sc_dev, dk, NULL); } /* * dkwedge_add: [exported function] * * Add a disk wedge based on the provided information. * * The incoming dkw_devname[] is ignored, instead being * filled in and returned to the caller. */ int dkwedge_add(struct dkwedge_info *dkw) { struct dkwedge_softc *sc, *lsc; struct disk *pdk; u_int unit; int error; dev_t pdev; device_t dev __diagused; dkw->dkw_parent[sizeof(dkw->dkw_parent) - 1] = '\0'; pdk = disk_find(dkw->dkw_parent); if (pdk == NULL) return ENXIO; error = dkwedge_compute_pdev(pdk->dk_name, &pdev, VBLK); if (error) return error; if (dkw->dkw_offset < 0) return EINVAL; /* * Check for an existing wedge at the same disk offset. Allow * updating a wedge if the only change is the size, and the new * size is larger than the old. */ sc = NULL; mutex_enter(&pdk->dk_openlock); LIST_FOREACH(lsc, &pdk->dk_wedges, sc_plink) { if (lsc->sc_offset != dkw->dkw_offset) continue; if (strcmp(lsc->sc_wname, dkw->dkw_wname) != 0) break; if (strcmp(lsc->sc_ptype, dkw->dkw_ptype) != 0) break; if (dkwedge_size(lsc) > dkw->dkw_size) break; if (lsc->sc_dev == NULL) break; sc = lsc; device_acquire(sc->sc_dev); dkwedge_size_increase(sc, dkw->dkw_size); dk_set_geometry(sc, pdk); break; } mutex_exit(&pdk->dk_openlock); if (sc != NULL) goto announce; sc = malloc(sizeof(*sc), M_DKWEDGE, M_WAITOK|M_ZERO); sc->sc_state = DKW_STATE_LARVAL; sc->sc_parent = pdk; sc->sc_pdev = pdev; sc->sc_offset = dkw->dkw_offset; dkwedge_size_init(sc, dkw->dkw_size); memcpy(sc->sc_wname, dkw->dkw_wname, sizeof(sc->sc_wname)); sc->sc_wname[sizeof(sc->sc_wname) - 1] = '\0'; memcpy(sc->sc_ptype, dkw->dkw_ptype, sizeof(sc->sc_ptype)); sc->sc_ptype[sizeof(sc->sc_ptype) - 1] = '\0'; bufq_alloc(&sc->sc_bufq, "fcfs", 0); callout_init(&sc->sc_restart_ch, 0); callout_setfunc(&sc->sc_restart_ch, dkrestart, sc); mutex_init(&sc->sc_iolock, MUTEX_DEFAULT, IPL_BIO); /* * Wedge will be added; increment the wedge count for the parent. * Only allow this to happen if RAW_PART is the only thing open. */ mutex_enter(&pdk->dk_openlock); if (pdk->dk_openmask & ~(1 << RAW_PART)) error = EBUSY; else { /* Check for wedge overlap. */ LIST_FOREACH(lsc, &pdk->dk_wedges, sc_plink) { /* XXX arithmetic overflow */ uint64_t size = dkwedge_size(sc); uint64_t lsize = dkwedge_size(lsc); daddr_t lastblk = sc->sc_offset + size - 1; daddr_t llastblk = lsc->sc_offset + lsize - 1; if (sc->sc_offset >= lsc->sc_offset && sc->sc_offset <= llastblk) { /* Overlaps the tail of the existing wedge. */ break; } if (lastblk >= lsc->sc_offset && lastblk <= llastblk) { /* Overlaps the head of the existing wedge. */ break; } } if (lsc != NULL) { if (sc->sc_offset == lsc->sc_offset && dkwedge_size(sc) == dkwedge_size(lsc) && strcmp(sc->sc_wname, lsc->sc_wname) == 0) error = EEXIST; else error = EINVAL; } else { pdk->dk_nwedges++; LIST_INSERT_HEAD(&pdk->dk_wedges, sc, sc_plink); } } mutex_exit(&pdk->dk_openlock); if (error) { mutex_destroy(&sc->sc_iolock); bufq_free(sc->sc_bufq); dkwedge_size_fini(sc); free(sc, M_DKWEDGE); return error; } /* Fill in our cfdata for the pseudo-device glue. */ sc->sc_cfdata.cf_name = dk_cd.cd_name; sc->sc_cfdata.cf_atname = dk_ca.ca_name; /* sc->sc_cfdata.cf_unit set below */ sc->sc_cfdata.cf_fstate = FSTATE_NOTFOUND; /* use chosen cf_unit */ /* Insert the larval wedge into the array. */ rw_enter(&dkwedges_lock, RW_WRITER); for (error = 0;;) { struct dkwedge_softc **scpp; /* * Check for a duplicate wname while searching for * a slot. */ for (scpp = NULL, unit = 0; unit < ndkwedges; unit++) { if (dkwedges[unit] == NULL) { if (scpp == NULL) { scpp = &dkwedges[unit]; sc->sc_cfdata.cf_unit = unit; } } else { /* XXX Unicode. */ if (strcmp(dkwedges[unit]->sc_wname, sc->sc_wname) == 0) { error = EEXIST; break; } } } if (error) break; KASSERT(unit == ndkwedges); if (scpp == NULL) { error = dkwedge_array_expand(); if (error) break; } else { KASSERT(scpp == &dkwedges[sc->sc_cfdata.cf_unit]); *scpp = sc; break; } } rw_exit(&dkwedges_lock); if (error) { mutex_enter(&pdk->dk_openlock); pdk->dk_nwedges--; LIST_REMOVE(sc, sc_plink); mutex_exit(&pdk->dk_openlock); mutex_destroy(&sc->sc_iolock); bufq_free(sc->sc_bufq); dkwedge_size_fini(sc); free(sc, M_DKWEDGE); return error; } /* * Now that we know the unit #, attach a pseudo-device for * this wedge instance. This will provide us with the * device_t necessary for glue to other parts of the system. * * This should never fail, unless we're almost totally out of * memory. */ if ((dev = config_attach_pseudo_acquire(&sc->sc_cfdata, sc)) == NULL) { aprint_error("%s%u: unable to attach pseudo-device\n", sc->sc_cfdata.cf_name, sc->sc_cfdata.cf_unit); rw_enter(&dkwedges_lock, RW_WRITER); KASSERT(dkwedges[sc->sc_cfdata.cf_unit] == sc); dkwedges[sc->sc_cfdata.cf_unit] = NULL; rw_exit(&dkwedges_lock); mutex_enter(&pdk->dk_openlock); pdk->dk_nwedges--; LIST_REMOVE(sc, sc_plink); mutex_exit(&pdk->dk_openlock); mutex_destroy(&sc->sc_iolock); bufq_free(sc->sc_bufq); dkwedge_size_fini(sc); free(sc, M_DKWEDGE); return ENOMEM; } KASSERT(dev == sc->sc_dev); announce: /* Announce our arrival. */ aprint_normal( "%s at %s: \"%s\", %"PRIu64" blocks at %"PRId64", type: %s\n", device_xname(sc->sc_dev), pdk->dk_name, sc->sc_wname, /* XXX Unicode */ dkwedge_size(sc), sc->sc_offset, sc->sc_ptype[0] == '\0' ? "" : sc->sc_ptype); /* Return the devname to the caller. */ strlcpy(dkw->dkw_devname, device_xname(sc->sc_dev), sizeof(dkw->dkw_devname)); device_release(sc->sc_dev); return 0; } /* * dkwedge_find_acquire: * * Lookup a disk wedge based on the provided information. * NOTE: We look up the wedge based on the wedge devname, * not wname. * * Return NULL if the wedge is not found, otherwise return * the wedge's softc. Assign the wedge's unit number to unitp * if unitp is not NULL. The wedge's sc_dev is referenced and * must be released by device_release or equivalent. */ static struct dkwedge_softc * dkwedge_find_acquire(struct dkwedge_info *dkw, u_int *unitp) { struct dkwedge_softc *sc = NULL; u_int unit; /* Find our softc. */ dkw->dkw_devname[sizeof(dkw->dkw_devname) - 1] = '\0'; rw_enter(&dkwedges_lock, RW_READER); for (unit = 0; unit < ndkwedges; unit++) { if ((sc = dkwedges[unit]) != NULL && sc->sc_dev != NULL && strcmp(device_xname(sc->sc_dev), dkw->dkw_devname) == 0 && strcmp(sc->sc_parent->dk_name, dkw->dkw_parent) == 0) { device_acquire(sc->sc_dev); break; } } rw_exit(&dkwedges_lock); if (sc == NULL) return NULL; if (unitp != NULL) *unitp = unit; return sc; } /* * dkwedge_del: [exported function] * * Delete a disk wedge based on the provided information. * NOTE: We look up the wedge based on the wedge devname, * not wname. */ int dkwedge_del(struct dkwedge_info *dkw) { return dkwedge_del1(dkw, 0); } int dkwedge_del1(struct dkwedge_info *dkw, int flags) { struct dkwedge_softc *sc = NULL; /* Find our softc. */ if ((sc = dkwedge_find_acquire(dkw, NULL)) == NULL) return ESRCH; return config_detach_release(sc->sc_dev, flags); } /* * dkwedge_detach: * * Autoconfiguration detach function for pseudo-device glue. */ static int dkwedge_detach(device_t self, int flags) { struct dkwedge_softc *const sc = device_private(self); const u_int unit = device_unit(self); int bmaj, cmaj, error; error = disk_begindetach(&sc->sc_dk, /*lastclose*/NULL, self, flags); if (error) return error; /* Mark the wedge as dying. */ sc->sc_state = DKW_STATE_DYING; pmf_device_deregister(self); /* Kill any pending restart. */ mutex_enter(&sc->sc_iolock); sc->sc_iostop = true; mutex_exit(&sc->sc_iolock); callout_halt(&sc->sc_restart_ch, NULL); /* Locate the wedge major numbers. */ bmaj = bdevsw_lookup_major(&dk_bdevsw); cmaj = cdevsw_lookup_major(&dk_cdevsw); /* Nuke the vnodes for any open instances. */ vdevgone(bmaj, unit, unit, VBLK); vdevgone(cmaj, unit, unit, VCHR); /* * At this point, all block device opens have been closed, * synchronously flushing any buffered writes; and all * character device I/O operations have completed * synchronously, and character device opens have been closed. * * So there can be no more opens or queued buffers by now. */ KASSERT(sc->sc_dk.dk_openmask == 0); KASSERT(bufq_peek(sc->sc_bufq) == NULL); bufq_drain(sc->sc_bufq); /* Announce our departure. */ aprint_normal("%s at %s (%s) deleted\n", device_xname(sc->sc_dev), sc->sc_parent->dk_name, sc->sc_wname); /* XXX Unicode */ mutex_enter(&sc->sc_parent->dk_openlock); sc->sc_parent->dk_nwedges--; LIST_REMOVE(sc, sc_plink); mutex_exit(&sc->sc_parent->dk_openlock); /* Delete our buffer queue. */ bufq_free(sc->sc_bufq); /* Detach from the disk list. */ disk_detach(&sc->sc_dk); disk_destroy(&sc->sc_dk); /* Poof. */ rw_enter(&dkwedges_lock, RW_WRITER); KASSERT(dkwedges[unit] == sc); dkwedges[unit] = NULL; sc->sc_state = DKW_STATE_DEAD; rw_exit(&dkwedges_lock); mutex_destroy(&sc->sc_iolock); dkwedge_size_fini(sc); free(sc, M_DKWEDGE); return 0; } /* * dkwedge_delall: [exported function] * * Forcibly delete all of the wedges on the specified disk. Used * when a disk is being detached. */ void dkwedge_delall(struct disk *pdk) { dkwedge_delall1(pdk, /*idleonly*/false); } /* * dkwedge_delidle: [exported function] * * Delete all of the wedges on the specified disk if idle. Used * by ioctl(DIOCRMWEDGES). */ void dkwedge_delidle(struct disk *pdk) { dkwedge_delall1(pdk, /*idleonly*/true); } static void dkwedge_delall1(struct disk *pdk, bool idleonly) { struct dkwedge_softc *sc; int flags; flags = DETACH_QUIET; if (!idleonly) flags |= DETACH_FORCE; for (;;) { mutex_enter(&pdk->dk_rawlock); /* for sc->sc_dk.dk_openmask */ mutex_enter(&pdk->dk_openlock); LIST_FOREACH(sc, &pdk->dk_wedges, sc_plink) { /* * Wedge is not yet created. This is a race -- * it may as well have been added just after we * deleted all the wedges, so pretend it's not * here yet. */ if (sc->sc_dev == NULL) continue; if (!idleonly || sc->sc_dk.dk_openmask == 0) { device_acquire(sc->sc_dev); break; } } if (sc == NULL) { KASSERT(idleonly || pdk->dk_nwedges == 0); mutex_exit(&pdk->dk_openlock); mutex_exit(&pdk->dk_rawlock); return; } mutex_exit(&pdk->dk_openlock); mutex_exit(&pdk->dk_rawlock); (void)config_detach_release(sc->sc_dev, flags); } } /* * dkwedge_list: [exported function] * * List all of the wedges on a particular disk. */ int dkwedge_list(struct disk *pdk, struct dkwedge_list *dkwl, struct lwp *l) { struct uio uio; struct iovec iov; struct dkwedge_softc *sc; struct dkwedge_info dkw; int error = 0; iov.iov_base = dkwl->dkwl_buf; iov.iov_len = dkwl->dkwl_bufsize; uio.uio_iov = &iov; uio.uio_iovcnt = 1; uio.uio_offset = 0; uio.uio_resid = dkwl->dkwl_bufsize; uio.uio_rw = UIO_READ; KASSERT(l == curlwp); uio.uio_vmspace = l->l_proc->p_vmspace; dkwl->dkwl_ncopied = 0; mutex_enter(&pdk->dk_openlock); LIST_FOREACH(sc, &pdk->dk_wedges, sc_plink) { if (uio.uio_resid < sizeof(dkw)) break; if (sc->sc_dev == NULL) continue; strlcpy(dkw.dkw_devname, device_xname(sc->sc_dev), sizeof(dkw.dkw_devname)); memcpy(dkw.dkw_wname, sc->sc_wname, sizeof(dkw.dkw_wname)); dkw.dkw_wname[sizeof(dkw.dkw_wname) - 1] = '\0'; strlcpy(dkw.dkw_parent, sc->sc_parent->dk_name, sizeof(dkw.dkw_parent)); dkw.dkw_offset = sc->sc_offset; dkw.dkw_size = dkwedge_size(sc); strlcpy(dkw.dkw_ptype, sc->sc_ptype, sizeof(dkw.dkw_ptype)); /* * Acquire a device reference so this wedge doesn't go * away before our next iteration in LIST_FOREACH, and * then release the lock for uiomove. */ device_acquire(sc->sc_dev); mutex_exit(&pdk->dk_openlock); error = uiomove(&dkw, sizeof(dkw), &uio); mutex_enter(&pdk->dk_openlock); device_release(sc->sc_dev); if (error) break; dkwl->dkwl_ncopied++; } dkwl->dkwl_nwedges = pdk->dk_nwedges; mutex_exit(&pdk->dk_openlock); return error; } static device_t dkwedge_find_by_wname_acquire(const char *wname) { device_t dv = NULL; struct dkwedge_softc *sc; int i; rw_enter(&dkwedges_lock, RW_READER); for (i = 0; i < ndkwedges; i++) { if ((sc = dkwedges[i]) == NULL || sc->sc_dev == NULL) continue; if (strcmp(sc->sc_wname, wname) == 0) { if (dv != NULL) { printf( "WARNING: double match for wedge name %s " "(%s, %s)\n", wname, device_xname(dv), device_xname(sc->sc_dev)); continue; } device_acquire(sc->sc_dev); dv = sc->sc_dev; } } rw_exit(&dkwedges_lock); return dv; } static device_t dkwedge_find_by_parent_acquire(const char *name, size_t *i) { rw_enter(&dkwedges_lock, RW_READER); for (; *i < (size_t)ndkwedges; (*i)++) { struct dkwedge_softc *sc; if ((sc = dkwedges[*i]) == NULL || sc->sc_dev == NULL) continue; if (strcmp(sc->sc_parent->dk_name, name) != 0) continue; device_acquire(sc->sc_dev); rw_exit(&dkwedges_lock); return sc->sc_dev; } rw_exit(&dkwedges_lock); return NULL; } /* XXX unsafe */ device_t dkwedge_find_by_wname(const char *wname) { device_t dv; if ((dv = dkwedge_find_by_wname_acquire(wname)) == NULL) return NULL; device_release(dv); return dv; } /* XXX unsafe */ device_t dkwedge_find_by_parent(const char *name, size_t *i) { device_t dv; if ((dv = dkwedge_find_by_parent_acquire(name, i)) == NULL) return NULL; device_release(dv); return dv; } void dkwedge_print_wnames(void) { struct dkwedge_softc *sc; int i; rw_enter(&dkwedges_lock, RW_READER); for (i = 0; i < ndkwedges; i++) { if ((sc = dkwedges[i]) == NULL || sc->sc_dev == NULL) continue; printf(" wedge:%s", sc->sc_wname); } rw_exit(&dkwedges_lock); } /* * We need a dummy object to stuff into the dkwedge discovery method link * set to ensure that there is always at least one object in the set. */ static struct dkwedge_discovery_method dummy_discovery_method; __link_set_add_bss(dkwedge_methods, dummy_discovery_method); /* * dkwedge_init: * * Initialize the disk wedge subsystem. */ void dkwedge_init(void) { __link_set_decl(dkwedge_methods, struct dkwedge_discovery_method); struct dkwedge_discovery_method * const *ddmp; struct dkwedge_discovery_method *lddm, *ddm; rw_init(&dkwedges_lock); rw_init(&dkwedge_discovery_methods_lock); if (config_cfdriver_attach(&dk_cd) != 0) panic("dkwedge: unable to attach cfdriver"); if (config_cfattach_attach(dk_cd.cd_name, &dk_ca) != 0) panic("dkwedge: unable to attach cfattach"); rw_enter(&dkwedge_discovery_methods_lock, RW_WRITER); LIST_INIT(&dkwedge_discovery_methods); __link_set_foreach(ddmp, dkwedge_methods) { ddm = *ddmp; if (ddm == &dummy_discovery_method) continue; if (LIST_EMPTY(&dkwedge_discovery_methods)) { LIST_INSERT_HEAD(&dkwedge_discovery_methods, ddm, ddm_list); continue; } LIST_FOREACH(lddm, &dkwedge_discovery_methods, ddm_list) { if (ddm->ddm_priority == lddm->ddm_priority) { aprint_error("dk-method-%s: method \"%s\" " "already exists at priority %d\n", ddm->ddm_name, lddm->ddm_name, lddm->ddm_priority); /* Not inserted. */ break; } if (ddm->ddm_priority < lddm->ddm_priority) { /* Higher priority; insert before. */ LIST_INSERT_BEFORE(lddm, ddm, ddm_list); break; } if (LIST_NEXT(lddm, ddm_list) == NULL) { /* Last one; insert after. */ KASSERT(lddm->ddm_priority < ddm->ddm_priority); LIST_INSERT_AFTER(lddm, ddm, ddm_list); break; } } } rw_exit(&dkwedge_discovery_methods_lock); } #ifdef DKWEDGE_AUTODISCOVER int dkwedge_autodiscover = 1; #else int dkwedge_autodiscover = 0; #endif /* * dkwedge_discover: [exported function] * * Discover the wedges on a newly attached disk. * Remove all unused wedges on the disk first. */ void dkwedge_discover(struct disk *pdk) { struct dkwedge_discovery_method *ddm; struct vnode *vp; int error; dev_t pdev; /* * Require people playing with wedges to enable this explicitly. */ if (dkwedge_autodiscover == 0) return; rw_enter(&dkwedge_discovery_methods_lock, RW_READER); /* * Use the character device for scanning, the block device * is busy if there are already wedges attached. */ error = dkwedge_compute_pdev(pdk->dk_name, &pdev, VCHR); if (error) { aprint_error("%s: unable to compute pdev, error = %d\n", pdk->dk_name, error); goto out; } error = cdevvp(pdev, &vp); if (error) { aprint_error("%s: unable to find vnode for pdev, error = %d\n", pdk->dk_name, error); goto out; } error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); if (error) { aprint_error("%s: unable to lock vnode for pdev, error = %d\n", pdk->dk_name, error); vrele(vp); goto out; } error = VOP_OPEN(vp, FREAD | FSILENT, NOCRED); if (error) { if (error != ENXIO) aprint_error("%s: unable to open device, error = %d\n", pdk->dk_name, error); vput(vp); goto out; } VOP_UNLOCK(vp); /* * Remove unused wedges */ dkwedge_delidle(pdk); /* * For each supported partition map type, look to see if * this map type exists. If so, parse it and add the * corresponding wedges. */ LIST_FOREACH(ddm, &dkwedge_discovery_methods, ddm_list) { error = (*ddm->ddm_discover)(pdk, vp); if (error == 0) { /* Successfully created wedges; we're done. */ break; } } error = vn_close(vp, FREAD, NOCRED); if (error) { aprint_error("%s: unable to close device, error = %d\n", pdk->dk_name, error); /* We'll just assume the vnode has been cleaned up. */ } out: rw_exit(&dkwedge_discovery_methods_lock); } /* * dkwedge_read: * * Read some data from the specified disk, used for * partition discovery. */ int dkwedge_read(struct disk *pdk, struct vnode *vp, daddr_t blkno, void *tbuf, size_t len) { buf_t *bp; int error; bool isopen; dev_t bdev; struct vnode *bdvp; /* * The kernel cannot read from a character device vnode * as physio() only handles user memory. * * If the block device has already been opened by a wedge * use that vnode and temporarily bump the open counter. * * Otherwise try to open the block device. */ bdev = devsw_chr2blk(vp->v_rdev); mutex_enter(&pdk->dk_rawlock); if (pdk->dk_rawopens != 0) { KASSERT(pdk->dk_rawvp != NULL); isopen = true; ++pdk->dk_rawopens; bdvp = pdk->dk_rawvp; error = 0; } else { isopen = false; error = dk_open_parent(bdev, FREAD, &bdvp); } mutex_exit(&pdk->dk_rawlock); if (error) return error; bp = getiobuf(bdvp, true); bp->b_flags = B_READ; bp->b_cflags = BC_BUSY; bp->b_dev = bdev; bp->b_data = tbuf; bp->b_bufsize = bp->b_bcount = len; bp->b_blkno = blkno; bp->b_cylinder = 0; bp->b_error = 0; VOP_STRATEGY(bdvp, bp); error = biowait(bp); putiobuf(bp); mutex_enter(&pdk->dk_rawlock); if (isopen) { --pdk->dk_rawopens; } else { dk_close_parent(bdvp, FREAD); } mutex_exit(&pdk->dk_rawlock); return error; } /* * dkwedge_lookup: * * Look up a dkwedge_softc based on the provided dev_t. * * Caller must guarantee the wedge is referenced. */ static struct dkwedge_softc * dkwedge_lookup(dev_t dev) { return device_lookup_private(&dk_cd, minor(dev)); } static struct dkwedge_softc * dkwedge_lookup_acquire(dev_t dev) { device_t dv = device_lookup_acquire(&dk_cd, minor(dev)); if (dv == NULL) return NULL; return device_private(dv); } static int dk_open_parent(dev_t dev, int mode, struct vnode **vpp) { struct vnode *vp; int error; error = bdevvp(dev, &vp); if (error) return error; error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); if (error) { vrele(vp); return error; } error = VOP_OPEN(vp, mode, NOCRED); if (error) { vput(vp); return error; } /* VOP_OPEN() doesn't do this for us. */ if (mode & FWRITE) { mutex_enter(vp->v_interlock); vp->v_writecount++; mutex_exit(vp->v_interlock); } VOP_UNLOCK(vp); *vpp = vp; return 0; } static int dk_close_parent(struct vnode *vp, int mode) { int error; error = vn_close(vp, mode, NOCRED); return error; } /* * dkopen: [devsw entry point] * * Open a wedge. */ static int dkopen(dev_t dev, int flags, int fmt, struct lwp *l) { struct dkwedge_softc *sc = dkwedge_lookup(dev); int error = 0; if (sc == NULL) return ENXIO; KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state == DKW_STATE_RUNNING); /* * We go through a complicated little dance to only open the parent * vnode once per wedge, no matter how many times the wedge is * opened. The reason? We see one dkopen() per open call, but * only dkclose() on the last close. */ mutex_enter(&sc->sc_dk.dk_openlock); mutex_enter(&sc->sc_parent->dk_rawlock); if (sc->sc_dk.dk_openmask == 0) { error = dkfirstopen(sc, flags); if (error) goto out; } else if (flags & ~sc->sc_mode & FWRITE) { /* * The parent is already open, but the previous attempt * to open it read/write failed and fell back to * read-only. In that case, we assume the medium is * read-only and fail to open the wedge read/write. */ error = EROFS; goto out; } KASSERT(sc->sc_mode != 0); KASSERTMSG(sc->sc_mode & FREAD, "%s: sc_mode=%x", device_xname(sc->sc_dev), sc->sc_mode); KASSERTMSG((flags & FWRITE) ? (sc->sc_mode & FWRITE) : 1, "%s: flags=%x sc_mode=%x", device_xname(sc->sc_dev), flags, sc->sc_mode); if (fmt == S_IFCHR) sc->sc_dk.dk_copenmask |= 1; else sc->sc_dk.dk_bopenmask |= 1; sc->sc_dk.dk_openmask = sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask; out: mutex_exit(&sc->sc_parent->dk_rawlock); mutex_exit(&sc->sc_dk.dk_openlock); return error; } static int dkfirstopen(struct dkwedge_softc *sc, int flags) { struct dkwedge_softc *nsc; struct vnode *vp; int mode; int error; KASSERT(mutex_owned(&sc->sc_dk.dk_openlock)); KASSERT(mutex_owned(&sc->sc_parent->dk_rawlock)); if (sc->sc_parent->dk_rawopens == 0) { KASSERT(sc->sc_parent->dk_rawvp == NULL); /* * Try open read-write. If this fails for EROFS * and wedge is read-only, retry to open read-only. */ mode = FREAD | FWRITE; error = dk_open_parent(sc->sc_pdev, mode, &vp); if (error == EROFS && (flags & FWRITE) == 0) { mode &= ~FWRITE; error = dk_open_parent(sc->sc_pdev, mode, &vp); } if (error) return error; KASSERT(vp != NULL); sc->sc_parent->dk_rawvp = vp; } else { /* * Retrieve mode from an already opened wedge. * * At this point, dk_rawopens is bounded by the number * of dkwedge devices in the system, which is limited * by autoconf device numbering to INT_MAX. Since * dk_rawopens is unsigned, this can't overflow. */ KASSERT(sc->sc_parent->dk_rawopens < UINT_MAX); KASSERT(sc->sc_parent->dk_rawvp != NULL); mode = 0; mutex_enter(&sc->sc_parent->dk_openlock); LIST_FOREACH(nsc, &sc->sc_parent->dk_wedges, sc_plink) { if (nsc == sc || nsc->sc_dk.dk_openmask == 0) continue; mode = nsc->sc_mode; break; } mutex_exit(&sc->sc_parent->dk_openlock); } sc->sc_mode = mode; sc->sc_parent->dk_rawopens++; return 0; } static void dklastclose(struct dkwedge_softc *sc) { KASSERT(mutex_owned(&sc->sc_dk.dk_openlock)); KASSERT(mutex_owned(&sc->sc_parent->dk_rawlock)); KASSERT(sc->sc_parent->dk_rawopens > 0); KASSERT(sc->sc_parent->dk_rawvp != NULL); if (--sc->sc_parent->dk_rawopens == 0) { struct vnode *const vp = sc->sc_parent->dk_rawvp; const int mode = sc->sc_mode; sc->sc_parent->dk_rawvp = NULL; sc->sc_mode = 0; dk_close_parent(vp, mode); } } /* * dkclose: [devsw entry point] * * Close a wedge. */ static int dkclose(dev_t dev, int flags, int fmt, struct lwp *l) { struct dkwedge_softc *sc = dkwedge_lookup(dev); /* * dkclose can be called even if dkopen didn't succeed, so we * have to handle the same possibility that the wedge may not * exist. */ if (sc == NULL) return ENXIO; KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); mutex_enter(&sc->sc_dk.dk_openlock); mutex_enter(&sc->sc_parent->dk_rawlock); KASSERT(sc->sc_dk.dk_openmask != 0); if (fmt == S_IFCHR) sc->sc_dk.dk_copenmask &= ~1; else sc->sc_dk.dk_bopenmask &= ~1; sc->sc_dk.dk_openmask = sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask; if (sc->sc_dk.dk_openmask == 0) { dklastclose(sc); } mutex_exit(&sc->sc_parent->dk_rawlock); mutex_exit(&sc->sc_dk.dk_openlock); return 0; } /* * dkcancel: [devsw entry point] * * Cancel any pending I/O operations waiting on a wedge. */ static int dkcancel(dev_t dev, int flags, int fmt, struct lwp *l) { struct dkwedge_softc *sc = dkwedge_lookup(dev); KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); /* * Disk I/O is expected to complete or fail within a reasonable * timeframe -- it's storage, not communication. Further, the * character and block device interface guarantees that prior * reads and writes have completed or failed by the time close * returns -- we are not to cancel them here. If the parent * device's hardware is gone, the parent driver can make them * fail. Nothing for dk(4) itself to do. */ return 0; } /* * dkstrategy: [devsw entry point] * * Perform I/O based on the wedge I/O strategy. */ static void dkstrategy(struct buf *bp) { struct dkwedge_softc *sc = dkwedge_lookup(bp->b_dev); uint64_t p_size, p_offset; KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); KASSERT(sc->sc_parent->dk_rawvp != NULL); /* If it's an empty transfer, wake up the top half now. */ if (bp->b_bcount == 0) goto done; p_offset = sc->sc_offset << sc->sc_parent->dk_blkshift; p_size = dkwedge_size(sc) << sc->sc_parent->dk_blkshift; /* Make sure it's in-range. */ if (bounds_check_with_mediasize(bp, DEV_BSIZE, p_size) <= 0) goto done; /* Translate it to the parent's raw LBA. */ bp->b_rawblkno = bp->b_blkno + p_offset; /* Place it in the queue and start I/O on the unit. */ mutex_enter(&sc->sc_iolock); disk_wait(&sc->sc_dk); bufq_put(sc->sc_bufq, bp); mutex_exit(&sc->sc_iolock); dkstart(sc); return; done: bp->b_resid = bp->b_bcount; biodone(bp); } /* * dkstart: * * Start I/O that has been enqueued on the wedge. */ static void dkstart(struct dkwedge_softc *sc) { struct vnode *vp; struct buf *bp, *nbp; mutex_enter(&sc->sc_iolock); /* Do as much work as has been enqueued. */ while ((bp = bufq_peek(sc->sc_bufq)) != NULL) { if (sc->sc_iostop) { (void) bufq_get(sc->sc_bufq); mutex_exit(&sc->sc_iolock); bp->b_error = ENXIO; bp->b_resid = bp->b_bcount; biodone(bp); mutex_enter(&sc->sc_iolock); continue; } /* fetch an I/O buf with sc_iolock dropped */ mutex_exit(&sc->sc_iolock); nbp = getiobuf(sc->sc_parent->dk_rawvp, false); mutex_enter(&sc->sc_iolock); if (nbp == NULL) { /* * No resources to run this request; leave the * buffer queued up, and schedule a timer to * restart the queue in 1/2 a second. */ if (!sc->sc_iostop) callout_schedule(&sc->sc_restart_ch, hz/2); break; } /* * fetch buf, this can fail if another thread * has already processed the queue, it can also * return a completely different buf. */ bp = bufq_get(sc->sc_bufq); if (bp == NULL) { mutex_exit(&sc->sc_iolock); putiobuf(nbp); mutex_enter(&sc->sc_iolock); continue; } /* Instrumentation. */ disk_busy(&sc->sc_dk); /* release lock for VOP_STRATEGY */ mutex_exit(&sc->sc_iolock); nbp->b_data = bp->b_data; nbp->b_flags = bp->b_flags; nbp->b_oflags = bp->b_oflags; nbp->b_cflags = bp->b_cflags; nbp->b_iodone = dkiodone; nbp->b_proc = bp->b_proc; nbp->b_blkno = bp->b_rawblkno; nbp->b_dev = sc->sc_parent->dk_rawvp->v_rdev; nbp->b_bcount = bp->b_bcount; nbp->b_private = bp; BIO_COPYPRIO(nbp, bp); vp = nbp->b_vp; if ((nbp->b_flags & B_READ) == 0) { mutex_enter(vp->v_interlock); vp->v_numoutput++; mutex_exit(vp->v_interlock); } VOP_STRATEGY(vp, nbp); mutex_enter(&sc->sc_iolock); } mutex_exit(&sc->sc_iolock); } /* * dkiodone: * * I/O to a wedge has completed; alert the top half. */ static void dkiodone(struct buf *bp) { struct buf *obp = bp->b_private; struct dkwedge_softc *sc = dkwedge_lookup(obp->b_dev); KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); if (bp->b_error != 0) obp->b_error = bp->b_error; obp->b_resid = bp->b_resid; putiobuf(bp); mutex_enter(&sc->sc_iolock); disk_unbusy(&sc->sc_dk, obp->b_bcount - obp->b_resid, obp->b_flags & B_READ); mutex_exit(&sc->sc_iolock); biodone(obp); /* Kick the queue in case there is more work we can do. */ dkstart(sc); } /* * dkrestart: * * Restart the work queue after it was stalled due to * a resource shortage. Invoked via a callout. */ static void dkrestart(void *v) { struct dkwedge_softc *sc = v; dkstart(sc); } /* * dkminphys: * * Call parent's minphys function. */ static void dkminphys(struct buf *bp) { struct dkwedge_softc *sc = dkwedge_lookup(bp->b_dev); dev_t dev; KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); dev = bp->b_dev; bp->b_dev = sc->sc_pdev; if (sc->sc_parent->dk_driver && sc->sc_parent->dk_driver->d_minphys) (*sc->sc_parent->dk_driver->d_minphys)(bp); else minphys(bp); bp->b_dev = dev; } /* * dkread: [devsw entry point] * * Read from a wedge. */ static int dkread(dev_t dev, struct uio *uio, int flags) { struct dkwedge_softc *sc __diagused = dkwedge_lookup(dev); KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); return physio(dkstrategy, NULL, dev, B_READ, dkminphys, uio); } /* * dkwrite: [devsw entry point] * * Write to a wedge. */ static int dkwrite(dev_t dev, struct uio *uio, int flags) { struct dkwedge_softc *sc __diagused = dkwedge_lookup(dev); KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); return physio(dkstrategy, NULL, dev, B_WRITE, dkminphys, uio); } /* * dkioctl: [devsw entry point] * * Perform an ioctl request on a wedge. */ static int dkioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) { struct dkwedge_softc *sc = dkwedge_lookup(dev); int error = 0; KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); KASSERT(sc->sc_parent->dk_rawvp != NULL); /* * We pass NODEV instead of our device to indicate we don't * want to handle disklabel ioctls */ error = disk_ioctl(&sc->sc_dk, NODEV, cmd, data, flag, l); if (error != EPASSTHROUGH) return error; error = 0; switch (cmd) { case DIOCGSTRATEGY: case DIOCGCACHE: case DIOCCACHESYNC: error = VOP_IOCTL(sc->sc_parent->dk_rawvp, cmd, data, flag, l != NULL ? l->l_cred : NOCRED); break; case DIOCGWEDGEINFO: { struct dkwedge_info *dkw = data; strlcpy(dkw->dkw_devname, device_xname(sc->sc_dev), sizeof(dkw->dkw_devname)); memcpy(dkw->dkw_wname, sc->sc_wname, sizeof(dkw->dkw_wname)); dkw->dkw_wname[sizeof(dkw->dkw_wname) - 1] = '\0'; strlcpy(dkw->dkw_parent, sc->sc_parent->dk_name, sizeof(dkw->dkw_parent)); dkw->dkw_offset = sc->sc_offset; dkw->dkw_size = dkwedge_size(sc); strlcpy(dkw->dkw_ptype, sc->sc_ptype, sizeof(dkw->dkw_ptype)); break; } case DIOCGSECTORALIGN: { struct disk_sectoralign *dsa = data; uint32_t r; error = VOP_IOCTL(sc->sc_parent->dk_rawvp, cmd, dsa, flag, l != NULL ? l->l_cred : NOCRED); if (error) break; r = sc->sc_offset % dsa->dsa_alignment; if (r < dsa->dsa_firstaligned) dsa->dsa_firstaligned = dsa->dsa_firstaligned - r; else dsa->dsa_firstaligned = (dsa->dsa_firstaligned + dsa->dsa_alignment) - r; dsa->dsa_firstaligned %= dsa->dsa_alignment; break; } default: error = ENOTTY; } return error; } /* * dkdiscard: [devsw entry point] * * Perform a discard-range request on a wedge. */ static int dkdiscard(dev_t dev, off_t pos, off_t len) { struct dkwedge_softc *sc = dkwedge_lookup(dev); uint64_t size = dkwedge_size(sc); unsigned shift; off_t offset, maxlen; int error; KASSERT(sc != NULL); KASSERT(sc->sc_dev != NULL); KASSERT(sc->sc_state != DKW_STATE_LARVAL); KASSERT(sc->sc_state != DKW_STATE_DEAD); KASSERT(sc->sc_parent->dk_rawvp != NULL); /* XXX check bounds on size/offset up front */ shift = (sc->sc_parent->dk_blkshift + DEV_BSHIFT); KASSERT(__type_fit(off_t, size)); KASSERT(__type_fit(off_t, sc->sc_offset)); KASSERT(0 <= sc->sc_offset); KASSERT(size <= (__type_max(off_t) >> shift)); KASSERT(sc->sc_offset <= ((__type_max(off_t) >> shift) - size)); offset = ((off_t)sc->sc_offset << shift); maxlen = ((off_t)size << shift); if (len > maxlen) return EINVAL; if (pos > (maxlen - len)) return EINVAL; pos += offset; vn_lock(sc->sc_parent->dk_rawvp, LK_EXCLUSIVE | LK_RETRY); error = VOP_FDISCARD(sc->sc_parent->dk_rawvp, pos, len); VOP_UNLOCK(sc->sc_parent->dk_rawvp); return error; } /* * dksize: [devsw entry point] * * Query the size of a wedge for the purpose of performing a dump * or for swapping to. */ static int dksize(dev_t dev) { /* * Don't bother taking a reference because this is only used * either (a) while the device is open (for swap), or (b) while * any multiprocessing is quiescent (for crash dumps). */ struct dkwedge_softc *sc = dkwedge_lookup(dev); uint64_t p_size; int rv = -1; if (sc == NULL) return -1; if (sc->sc_state != DKW_STATE_RUNNING) return -1; /* Our content type is static, no need to open the device. */ p_size = dkwedge_size(sc) << sc->sc_parent->dk_blkshift; if (strcmp(sc->sc_ptype, DKW_PTYPE_SWAP) == 0) { /* Saturate if we are larger than INT_MAX. */ if (p_size > INT_MAX) rv = INT_MAX; else rv = (int)p_size; } return rv; } /* * dkdump: [devsw entry point] * * Perform a crash dump to a wedge. */ static int dkdump(dev_t dev, daddr_t blkno, void *va, size_t size) { /* * Don't bother taking a reference because this is only used * while any multiprocessing is quiescent. */ struct dkwedge_softc *sc = dkwedge_lookup(dev); const struct bdevsw *bdev; uint64_t p_size, p_offset; if (sc == NULL) return ENXIO; if (sc->sc_state != DKW_STATE_RUNNING) return ENXIO; /* Our content type is static, no need to open the device. */ if (strcmp(sc->sc_ptype, DKW_PTYPE_SWAP) != 0 && strcmp(sc->sc_ptype, DKW_PTYPE_RAID) != 0 && strcmp(sc->sc_ptype, DKW_PTYPE_CGD) != 0) return ENXIO; if (size % DEV_BSIZE != 0) return EINVAL; p_offset = sc->sc_offset << sc->sc_parent->dk_blkshift; p_size = dkwedge_size(sc) << sc->sc_parent->dk_blkshift; if (blkno < 0 || blkno + size/DEV_BSIZE > p_size) { printf("%s: blkno (%" PRIu64 ") + size / DEV_BSIZE (%zu) > " "p_size (%" PRIu64 ")\n", __func__, blkno, size/DEV_BSIZE, p_size); return EINVAL; } bdev = bdevsw_lookup(sc->sc_pdev); return (*bdev->d_dump)(sc->sc_pdev, blkno + p_offset, va, size); } /* * config glue */ /* * dkwedge_find_partition * * Find wedge corresponding to the specified parent name * and offset/length. */ static device_t dkwedge_find_partition_acquire(device_t parent, daddr_t startblk, uint64_t nblks) { struct dkwedge_softc *sc; int i; device_t wedge = NULL; rw_enter(&dkwedges_lock, RW_READER); for (i = 0; i < ndkwedges; i++) { if ((sc = dkwedges[i]) == NULL || sc->sc_dev == NULL) continue; if (strcmp(sc->sc_parent->dk_name, device_xname(parent)) == 0 && sc->sc_offset == startblk && dkwedge_size(sc) == nblks) { if (wedge) { printf("WARNING: double match for boot wedge " "(%s, %s)\n", device_xname(wedge), device_xname(sc->sc_dev)); continue; } wedge = sc->sc_dev; device_acquire(wedge); } } rw_exit(&dkwedges_lock); return wedge; } /* XXX unsafe */ device_t dkwedge_find_partition(device_t parent, daddr_t startblk, uint64_t nblks) { device_t dv; if ((dv = dkwedge_find_partition_acquire(parent, startblk, nblks)) == NULL) return NULL; device_release(dv); return dv; } const char * dkwedge_get_parent_name(dev_t dev) { /* XXX: perhaps do this in lookup? */ int bmaj = bdevsw_lookup_major(&dk_bdevsw); int cmaj = cdevsw_lookup_major(&dk_cdevsw); if (major(dev) != bmaj && major(dev) != cmaj) return NULL; struct dkwedge_softc *const sc = dkwedge_lookup_acquire(dev); if (sc == NULL) return NULL; const char *const name = sc->sc_parent->dk_name; device_release(sc->sc_dev); return name; }