Home | History | Annotate | Line # | Download | only in dev
dksubr.c revision 1.90 
      1 /* $NetBSD: dksubr.c,v 1.90 2016/10/22 22:32:33 jdolecek Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 1996, 1997, 1998, 1999, 2002, 2008 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 and Roland C. Dowdeswell.
      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: dksubr.c,v 1.90 2016/10/22 22:32:33 jdolecek Exp $");
     34 
     35 #include <sys/param.h>
     36 #include <sys/systm.h>
     37 #include <sys/stat.h>
     38 #include <sys/proc.h>
     39 #include <sys/ioctl.h>
     40 #include <sys/device.h>
     41 #include <sys/disk.h>
     42 #include <sys/disklabel.h>
     43 #include <sys/buf.h>
     44 #include <sys/bufq.h>
     45 #include <sys/vnode.h>
     46 #include <sys/fcntl.h>
     47 #include <sys/namei.h>
     48 #include <sys/module.h>
     49 #include <sys/syslog.h>
     50 
     51 #include <dev/dkvar.h>
     52 #include <miscfs/specfs/specdev.h> /* for v_rdev */
     53 
     54 int	dkdebug = 0;
     55 
     56 #ifdef DEBUG
     57 #define DKDB_FOLLOW	0x1
     58 #define DKDB_INIT	0x2
     59 #define DKDB_VNODE	0x4
     60 #define DKDB_DUMP	0x8
     61 
     62 #define IFDEBUG(x,y)		if (dkdebug & (x)) y
     63 #define DPRINTF(x,y)		IFDEBUG(x, printf y)
     64 #define DPRINTF_FOLLOW(y)	DPRINTF(DKDB_FOLLOW, y)
     65 #else
     66 #define IFDEBUG(x,y)
     67 #define DPRINTF(x,y)
     68 #define DPRINTF_FOLLOW(y)
     69 #endif
     70 
     71 #define DKF_READYFORDUMP	(DKF_INITED|DKF_TAKEDUMP)
     72 
     73 static int dk_subr_modcmd(modcmd_t, void *);
     74 
     75 #define DKLABELDEV(dev)	\
     76 	(MAKEDISKDEV(major((dev)), DISKUNIT((dev)), RAW_PART))
     77 
     78 static void	dk_makedisklabel(struct dk_softc *);
     79 static int	dk_translate(struct dk_softc *, struct buf *);
     80 static void	dk_done1(struct dk_softc *, struct buf *, bool);
     81 
     82 void
     83 dk_init(struct dk_softc *dksc, device_t dev, int dtype)
     84 {
     85 
     86 	memset(dksc, 0x0, sizeof(*dksc));
     87 	dksc->sc_dtype = dtype;
     88 	dksc->sc_dev = dev;
     89 
     90 	strlcpy(dksc->sc_xname, device_xname(dev), DK_XNAME_SIZE);
     91 	dksc->sc_dkdev.dk_name = dksc->sc_xname;
     92 }
     93 
     94 void
     95 dk_attach(struct dk_softc *dksc)
     96 {
     97 	KASSERT(dksc->sc_dev != NULL);
     98 
     99 	mutex_init(&dksc->sc_iolock, MUTEX_DEFAULT, IPL_VM);
    100 	dksc->sc_flags |= DKF_READYFORDUMP;
    101 #ifdef DIAGNOSTIC
    102 	dksc->sc_flags |= DKF_WARNLABEL | DKF_LABELSANITY;
    103 #endif
    104 
    105 	/* Attach the device into the rnd source list. */
    106 	rnd_attach_source(&dksc->sc_rnd_source, dksc->sc_xname,
    107 	    RND_TYPE_DISK, RND_FLAG_DEFAULT);
    108 
    109 	TAILQ_INIT(&dksc->sc_deferred);
    110 }
    111 
    112 void
    113 dk_detach(struct dk_softc *dksc)
    114 {
    115 	/* Unhook the entropy source. */
    116 	rnd_detach_source(&dksc->sc_rnd_source);
    117 
    118 	dksc->sc_flags &= ~DKF_READYFORDUMP;
    119 	mutex_destroy(&dksc->sc_iolock);
    120 }
    121 
    122 /* ARGSUSED */
    123 int
    124 dk_open(struct dk_softc *dksc, dev_t dev,
    125     int flags, int fmt, struct lwp *l)
    126 {
    127 	struct	disklabel *lp = dksc->sc_dkdev.dk_label;
    128 	int	part = DISKPART(dev);
    129 	int	pmask = 1 << part;
    130 	int	ret = 0;
    131 	struct disk *dk = &dksc->sc_dkdev;
    132 
    133 	DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", 0x%x)\n", __func__,
    134 	    dksc->sc_xname, dksc, dev, flags));
    135 
    136 	mutex_enter(&dk->dk_openlock);
    137 
    138 	/*
    139 	 * If there are wedges, and this is not RAW_PART, then we
    140 	 * need to fail.
    141 	 */
    142 	if (dk->dk_nwedges != 0 && part != RAW_PART) {
    143 		ret = EBUSY;
    144 		goto done;
    145 	}
    146 
    147 	/*
    148 	 * If we're init'ed and there are no other open partitions then
    149 	 * update the in-core disklabel.
    150 	 */
    151 	if ((dksc->sc_flags & DKF_INITED)) {
    152 		if ((dksc->sc_flags & DKF_VLABEL) == 0) {
    153 			dksc->sc_flags |= DKF_VLABEL;
    154 			dk_getdisklabel(dksc, dev);
    155 		}
    156 	}
    157 
    158 	/* Fail if we can't find the partition. */
    159 	if (part != RAW_PART &&
    160 	    ((dksc->sc_flags & DKF_VLABEL) == 0 ||
    161 	     part >= lp->d_npartitions ||
    162 	     lp->d_partitions[part].p_fstype == FS_UNUSED)) {
    163 		ret = ENXIO;
    164 		goto done;
    165 	}
    166 
    167 	/* Mark our unit as open. */
    168 	switch (fmt) {
    169 	case S_IFCHR:
    170 		dk->dk_copenmask |= pmask;
    171 		break;
    172 	case S_IFBLK:
    173 		dk->dk_bopenmask |= pmask;
    174 		break;
    175 	}
    176 
    177 	dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
    178 
    179 done:
    180 	mutex_exit(&dk->dk_openlock);
    181 	return ret;
    182 }
    183 
    184 /* ARGSUSED */
    185 int
    186 dk_close(struct dk_softc *dksc, dev_t dev,
    187     int flags, int fmt, struct lwp *l)
    188 {
    189 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    190 	int	part = DISKPART(dev);
    191 	int	pmask = 1 << part;
    192 	struct disk *dk = &dksc->sc_dkdev;
    193 
    194 	DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", 0x%x)\n", __func__,
    195 	    dksc->sc_xname, dksc, dev, flags));
    196 
    197 	mutex_enter(&dk->dk_openlock);
    198 
    199 	switch (fmt) {
    200 	case S_IFCHR:
    201 		dk->dk_copenmask &= ~pmask;
    202 		break;
    203 	case S_IFBLK:
    204 		dk->dk_bopenmask &= ~pmask;
    205 		break;
    206 	}
    207 	dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
    208 
    209 	if (dk->dk_openmask == 0) {
    210 		if (dkd->d_lastclose != NULL)
    211 			(*dkd->d_lastclose)(dksc->sc_dev);
    212 		if ((dksc->sc_flags & DKF_KLABEL) == 0)
    213 			dksc->sc_flags &= ~DKF_VLABEL;
    214 	}
    215 
    216 	mutex_exit(&dk->dk_openlock);
    217 	return 0;
    218 }
    219 
    220 static int
    221 dk_translate(struct dk_softc *dksc, struct buf *bp)
    222 {
    223 	int	part;
    224 	int	wlabel;
    225 	daddr_t	blkno;
    226 	struct disklabel *lp;
    227 	struct disk *dk;
    228 	uint64_t numsecs;
    229 	unsigned secsize;
    230 
    231 	lp = dksc->sc_dkdev.dk_label;
    232 	dk = &dksc->sc_dkdev;
    233 
    234 	part = DISKPART(bp->b_dev);
    235 	numsecs = dk->dk_geom.dg_secperunit;
    236 	secsize = dk->dk_geom.dg_secsize;
    237 
    238 	/*
    239 	 * The transfer must be a whole number of blocks and the offset must
    240 	 * not be negative.
    241 	 */
    242 	if ((bp->b_bcount % secsize) != 0 || bp->b_blkno < 0) {
    243 		bp->b_error = EINVAL;
    244 		goto done;
    245 	}
    246 
    247 	/* If there is nothing to do, then we are done */
    248 	if (bp->b_bcount == 0)
    249 		goto done;
    250 
    251 	wlabel = dksc->sc_flags & (DKF_WLABEL|DKF_LABELLING);
    252 	if (part == RAW_PART) {
    253 		uint64_t numblocks = btodb(numsecs * secsize);
    254 		if (bounds_check_with_mediasize(bp, DEV_BSIZE, numblocks) <= 0)
    255 			goto done;
    256 	} else {
    257 		if (bounds_check_with_label(&dksc->sc_dkdev, bp, wlabel) <= 0)
    258 			goto done;
    259 	}
    260 
    261 	/*
    262 	 * Convert the block number to absolute and put it in terms
    263 	 * of the device's logical block size.
    264 	 */
    265 	if (secsize >= DEV_BSIZE)
    266 		blkno = bp->b_blkno / (secsize / DEV_BSIZE);
    267 	else
    268 		blkno = bp->b_blkno * (DEV_BSIZE / secsize);
    269 
    270 	if (part != RAW_PART)
    271 		blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset;
    272 	bp->b_rawblkno = blkno;
    273 
    274 	return -1;
    275 
    276 done:
    277 	bp->b_resid = bp->b_bcount;
    278 	return bp->b_error;
    279 }
    280 
    281 static int
    282 dk_strategy1(struct dk_softc *dksc, struct buf *bp)
    283 {
    284 	int error;
    285 
    286 	DPRINTF_FOLLOW(("%s(%s, %p, %p)\n", __func__,
    287 	    dksc->sc_xname, dksc, bp));
    288 
    289 	if (!(dksc->sc_flags & DKF_INITED)) {
    290 		DPRINTF_FOLLOW(("%s: not inited\n", __func__));
    291 		bp->b_error = ENXIO;
    292 		bp->b_resid = bp->b_bcount;
    293 		biodone(bp);
    294 		return 1;
    295 	}
    296 
    297 	error = dk_translate(dksc, bp);
    298 	if (error >= 0) {
    299 		biodone(bp);
    300 		return 1;
    301 	}
    302 
    303 	return 0;
    304 }
    305 
    306 void
    307 dk_strategy(struct dk_softc *dksc, struct buf *bp)
    308 {
    309 	int error;
    310 
    311 	error = dk_strategy1(dksc, bp);
    312 	if (error)
    313 		return;
    314 
    315 	/*
    316 	 * Queue buffer and start unit
    317 	 */
    318 	dk_start(dksc, bp);
    319 }
    320 
    321 int
    322 dk_strategy_defer(struct dk_softc *dksc, struct buf *bp)
    323 {
    324 	int error;
    325 
    326 	error = dk_strategy1(dksc, bp);
    327 	if (error)
    328 		return error;
    329 
    330 	/*
    331 	 * Queue buffer only
    332 	 */
    333 	mutex_enter(&dksc->sc_iolock);
    334 	bufq_put(dksc->sc_bufq, bp);
    335 	mutex_exit(&dksc->sc_iolock);
    336 
    337 	return 0;
    338 }
    339 
    340 int
    341 dk_strategy_pending(struct dk_softc *dksc)
    342 {
    343 	struct buf *bp;
    344 
    345 	if (!(dksc->sc_flags & DKF_INITED)) {
    346 		DPRINTF_FOLLOW(("%s: not inited\n", __func__));
    347 		return 0;
    348 	}
    349 
    350 	mutex_enter(&dksc->sc_iolock);
    351 	bp = bufq_peek(dksc->sc_bufq);
    352 	mutex_exit(&dksc->sc_iolock);
    353 
    354 	return bp != NULL;
    355 }
    356 
    357 void
    358 dk_start(struct dk_softc *dksc, struct buf *bp)
    359 {
    360 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    361 	int error;
    362 
    363 	if (!(dksc->sc_flags & DKF_INITED)) {
    364 		DPRINTF_FOLLOW(("%s: not inited\n", __func__));
    365 		return;
    366 	}
    367 
    368 	mutex_enter(&dksc->sc_iolock);
    369 
    370 	if (bp != NULL)
    371 		bufq_put(dksc->sc_bufq, bp);
    372 
    373 	if (dksc->sc_busy)
    374 		goto done;
    375 	dksc->sc_busy = true;
    376 
    377 	/*
    378 	 * Peeking at the buffer queue and committing the operation
    379 	 * only after success isn't atomic.
    380 	 *
    381 	 * So when a diskstart fails, the buffer is saved
    382 	 * and tried again before the next buffer is fetched.
    383 	 * dk_drain() handles flushing of a saved buffer(s).
    384 	 *
    385 	 * This keeps order of I/O operations, unlike bufq_put.
    386 	 */
    387 
    388 	for(;;) {
    389 		bp = TAILQ_FIRST(&dksc->sc_deferred);
    390 		if (__predict_false(bp != NULL))
    391 			TAILQ_REMOVE(&dksc->sc_deferred, bp, b_actq);
    392 		else {
    393 			bp = bufq_get(dksc->sc_bufq);
    394 			if (bp == NULL)
    395 				break;
    396 		}
    397 
    398 		disk_busy(&dksc->sc_dkdev);
    399 		mutex_exit(&dksc->sc_iolock);
    400 		error = dkd->d_diskstart(dksc->sc_dev, bp);
    401 		mutex_enter(&dksc->sc_iolock);
    402 		if (error == EAGAIN) {
    403 			TAILQ_INSERT_TAIL(&dksc->sc_deferred, bp, b_actq);
    404 			disk_unbusy(&dksc->sc_dkdev, 0, (bp->b_flags & B_READ));
    405 			break;
    406 		}
    407 
    408 		if (error != 0) {
    409 			bp->b_error = error;
    410 			bp->b_resid = bp->b_bcount;
    411 			dk_done1(dksc, bp, false);
    412 		}
    413 	}
    414 
    415 	dksc->sc_busy = false;
    416 done:
    417 	mutex_exit(&dksc->sc_iolock);
    418 }
    419 
    420 static void
    421 dk_done1(struct dk_softc *dksc, struct buf *bp, bool lock)
    422 {
    423 	struct disk *dk = &dksc->sc_dkdev;
    424 
    425 	if (bp->b_error != 0) {
    426 		struct cfdriver *cd = device_cfdriver(dksc->sc_dev);
    427 
    428 		diskerr(bp, cd->cd_name, "error", LOG_PRINTF, 0,
    429 			dk->dk_label);
    430 		printf("\n");
    431 	}
    432 
    433 	if (lock)
    434 		mutex_enter(&dksc->sc_iolock);
    435 	disk_unbusy(dk, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ));
    436 	if (lock)
    437 		mutex_exit(&dksc->sc_iolock);
    438 
    439 	rnd_add_uint32(&dksc->sc_rnd_source, bp->b_rawblkno);
    440 
    441 	biodone(bp);
    442 }
    443 
    444 void
    445 dk_done(struct dk_softc *dksc, struct buf *bp)
    446 {
    447 	dk_done1(dksc, bp, true);
    448 }
    449 
    450 void
    451 dk_drain(struct dk_softc *dksc)
    452 {
    453 	struct buf *bp;
    454 
    455 	mutex_enter(&dksc->sc_iolock);
    456 	while ((bp = TAILQ_FIRST(&dksc->sc_deferred)) != NULL) {
    457 		TAILQ_REMOVE(&dksc->sc_deferred, bp, b_actq);
    458 		bp->b_error = EIO;
    459 		bp->b_resid = bp->b_bcount;
    460 		biodone(bp);
    461 	}
    462 	bufq_drain(dksc->sc_bufq);
    463 	mutex_exit(&dksc->sc_iolock);
    464 }
    465 
    466 int
    467 dk_discard(struct dk_softc *dksc, dev_t dev, off_t pos, off_t len)
    468 {
    469 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    470 	unsigned secsize = dksc->sc_dkdev.dk_geom.dg_secsize;
    471 	struct buf tmp, *bp = &tmp;
    472 	int error;
    473 
    474 	DPRINTF_FOLLOW(("%s(%s, %p, 0x"PRIx64", %jd, %jd)\n", __func__,
    475 	    dksc->sc_xname, dksc, (intmax_t)pos, (intmax_t)len));
    476 
    477 	if (!(dksc->sc_flags & DKF_INITED)) {
    478 		DPRINTF_FOLLOW(("%s: not inited\n", __func__));
    479 		return ENXIO;
    480 	}
    481 
    482 	if (secsize == 0 || (pos % secsize) != 0)
    483 		return EINVAL;
    484 
    485 	/* enough data to please the bounds checking code */
    486 	bp->b_dev = dev;
    487 	bp->b_blkno = (daddr_t)(pos / secsize);
    488 	bp->b_bcount = len;
    489 	bp->b_flags = B_WRITE;
    490 
    491 	error = dk_translate(dksc, bp);
    492 	if (error >= 0)
    493 		return error;
    494 
    495 	error = dkd->d_discard(dksc->sc_dev,
    496 		(off_t)bp->b_rawblkno * secsize,
    497 		(off_t)bp->b_bcount);
    498 
    499 	return error;
    500 }
    501 
    502 int
    503 dk_size(struct dk_softc *dksc, dev_t dev)
    504 {
    505 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    506 	struct	disklabel *lp;
    507 	int	is_open;
    508 	int	part;
    509 	int	size;
    510 
    511 	if ((dksc->sc_flags & DKF_INITED) == 0)
    512 		return -1;
    513 
    514 	part = DISKPART(dev);
    515 	is_open = dksc->sc_dkdev.dk_openmask & (1 << part);
    516 
    517 	if (!is_open && dkd->d_open(dev, 0, S_IFBLK, curlwp))
    518 		return -1;
    519 
    520 	lp = dksc->sc_dkdev.dk_label;
    521 	if (lp->d_partitions[part].p_fstype != FS_SWAP)
    522 		size = -1;
    523 	else
    524 		size = lp->d_partitions[part].p_size *
    525 		    (lp->d_secsize / DEV_BSIZE);
    526 
    527 	if (!is_open && dkd->d_close(dev, 0, S_IFBLK, curlwp))
    528 		return -1;
    529 
    530 	return size;
    531 }
    532 
    533 int
    534 dk_ioctl(struct dk_softc *dksc, dev_t dev,
    535 	    u_long cmd, void *data, int flag, struct lwp *l)
    536 {
    537 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    538 	struct	disklabel *lp;
    539 	struct	disk *dk = &dksc->sc_dkdev;
    540 #ifdef __HAVE_OLD_DISKLABEL
    541 	struct	disklabel newlabel;
    542 #endif
    543 	int	error;
    544 
    545 	DPRINTF_FOLLOW(("%s(%s, %p, 0x%"PRIx64", 0x%lx)\n", __func__,
    546 	    dksc->sc_xname, dksc, dev, cmd));
    547 
    548 	/* ensure that the pseudo disk is open for writes for these commands */
    549 	switch (cmd) {
    550 	case DIOCSDINFO:
    551 	case DIOCWDINFO:
    552 #ifdef __HAVE_OLD_DISKLABEL
    553 	case ODIOCSDINFO:
    554 	case ODIOCWDINFO:
    555 #endif
    556 	case DIOCKLABEL:
    557 	case DIOCWLABEL:
    558 	case DIOCAWEDGE:
    559 	case DIOCDWEDGE:
    560 	case DIOCSSTRATEGY:
    561 		if ((flag & FWRITE) == 0)
    562 			return EBADF;
    563 	}
    564 
    565 	/* ensure that the pseudo-disk is initialized for these */
    566 	switch (cmd) {
    567 	case DIOCGDINFO:
    568 	case DIOCSDINFO:
    569 	case DIOCWDINFO:
    570 	case DIOCGPARTINFO:
    571 	case DIOCKLABEL:
    572 	case DIOCWLABEL:
    573 	case DIOCGDEFLABEL:
    574 	case DIOCAWEDGE:
    575 	case DIOCDWEDGE:
    576 	case DIOCLWEDGES:
    577 	case DIOCMWEDGES:
    578 	case DIOCCACHESYNC:
    579 #ifdef __HAVE_OLD_DISKLABEL
    580 	case ODIOCGDINFO:
    581 	case ODIOCSDINFO:
    582 	case ODIOCWDINFO:
    583 	case ODIOCGDEFLABEL:
    584 #endif
    585 		if ((dksc->sc_flags & DKF_INITED) == 0)
    586 			return ENXIO;
    587 	}
    588 
    589 	error = disk_ioctl(dk, dev, cmd, data, flag, l);
    590 	if (error != EPASSTHROUGH)
    591 		return error;
    592 	else
    593 		error = 0;
    594 
    595 	switch (cmd) {
    596 	case DIOCWDINFO:
    597 	case DIOCSDINFO:
    598 #ifdef __HAVE_OLD_DISKLABEL
    599 	case ODIOCWDINFO:
    600 	case ODIOCSDINFO:
    601 #endif
    602 #ifdef __HAVE_OLD_DISKLABEL
    603 		if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
    604 			memset(&newlabel, 0, sizeof newlabel);
    605 			memcpy(&newlabel, data, sizeof (struct olddisklabel));
    606 			lp = &newlabel;
    607 		} else
    608 #endif
    609 		lp = (struct disklabel *)data;
    610 
    611 		mutex_enter(&dk->dk_openlock);
    612 		dksc->sc_flags |= DKF_LABELLING;
    613 
    614 		error = setdisklabel(dksc->sc_dkdev.dk_label,
    615 		    lp, 0, dksc->sc_dkdev.dk_cpulabel);
    616 		if (error == 0) {
    617 			if (cmd == DIOCWDINFO
    618 #ifdef __HAVE_OLD_DISKLABEL
    619 			    || cmd == ODIOCWDINFO
    620 #endif
    621 			   )
    622 				error = writedisklabel(DKLABELDEV(dev),
    623 				    dkd->d_strategy, dksc->sc_dkdev.dk_label,
    624 				    dksc->sc_dkdev.dk_cpulabel);
    625 		}
    626 
    627 		dksc->sc_flags &= ~DKF_LABELLING;
    628 		mutex_exit(&dk->dk_openlock);
    629 		break;
    630 
    631 	case DIOCKLABEL:
    632 		if (*(int *)data != 0)
    633 			dksc->sc_flags |= DKF_KLABEL;
    634 		else
    635 			dksc->sc_flags &= ~DKF_KLABEL;
    636 		break;
    637 
    638 	case DIOCWLABEL:
    639 		if (*(int *)data != 0)
    640 			dksc->sc_flags |= DKF_WLABEL;
    641 		else
    642 			dksc->sc_flags &= ~DKF_WLABEL;
    643 		break;
    644 
    645 	case DIOCGDEFLABEL:
    646 		dk_getdefaultlabel(dksc, (struct disklabel *)data);
    647 		break;
    648 
    649 #ifdef __HAVE_OLD_DISKLABEL
    650 	case ODIOCGDEFLABEL:
    651 		dk_getdefaultlabel(dksc, &newlabel);
    652 		if (newlabel.d_npartitions > OLDMAXPARTITIONS)
    653 			return ENOTTY;
    654 		memcpy(data, &newlabel, sizeof (struct olddisklabel));
    655 		break;
    656 #endif
    657 
    658 	case DIOCGSTRATEGY:
    659 	    {
    660 		struct disk_strategy *dks = (void *)data;
    661 
    662 		mutex_enter(&dksc->sc_iolock);
    663 		if (dksc->sc_bufq != NULL)
    664 			strlcpy(dks->dks_name,
    665 			    bufq_getstrategyname(dksc->sc_bufq),
    666 			    sizeof(dks->dks_name));
    667 		else
    668 			error = EINVAL;
    669 		mutex_exit(&dksc->sc_iolock);
    670 		dks->dks_paramlen = 0;
    671 		break;
    672 	    }
    673 
    674 	case DIOCSSTRATEGY:
    675 	    {
    676 		struct disk_strategy *dks = (void *)data;
    677 		struct bufq_state *new;
    678 		struct bufq_state *old;
    679 
    680 		if (dks->dks_param != NULL) {
    681 			return EINVAL;
    682 		}
    683 		dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */
    684 		error = bufq_alloc(&new, dks->dks_name,
    685 		    BUFQ_EXACT|BUFQ_SORT_RAWBLOCK);
    686 		if (error) {
    687 			return error;
    688 		}
    689 		mutex_enter(&dksc->sc_iolock);
    690 		old = dksc->sc_bufq;
    691 		if (old)
    692 			bufq_move(new, old);
    693 		dksc->sc_bufq = new;
    694 		mutex_exit(&dksc->sc_iolock);
    695 		if (old)
    696 			bufq_free(old);
    697 		break;
    698 	    }
    699 
    700 	default:
    701 		error = ENOTTY;
    702 	}
    703 
    704 	return error;
    705 }
    706 
    707 /*
    708  * dk_dump dumps all of physical memory into the partition specified.
    709  * This requires substantially more framework than {s,w}ddump, and hence
    710  * is probably much more fragile.
    711  *
    712  */
    713 
    714 #define DKFF_READYFORDUMP(x)	(((x) & DKF_READYFORDUMP) == DKF_READYFORDUMP)
    715 static volatile int	dk_dumping = 0;
    716 
    717 /* ARGSUSED */
    718 int
    719 dk_dump(struct dk_softc *dksc, dev_t dev,
    720     daddr_t blkno, void *vav, size_t size)
    721 {
    722 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    723 	char *va = vav;
    724 	struct disklabel *lp;
    725 	struct partition *p;
    726 	int part, towrt, nsects, sectoff, maxblkcnt, nblk;
    727 	int maxxfer, rv = 0;
    728 
    729 	/*
    730 	 * ensure that we consider this device to be safe for dumping,
    731 	 * and that the device is configured.
    732 	 */
    733 	if (!DKFF_READYFORDUMP(dksc->sc_flags)) {
    734 		DPRINTF(DKDB_DUMP, ("%s: bad dump flags 0x%x\n", __func__,
    735 		    dksc->sc_flags));
    736 		return ENXIO;
    737 	}
    738 
    739 	/* ensure that we are not already dumping */
    740 	if (dk_dumping)
    741 		return EFAULT;
    742 	dk_dumping = 1;
    743 
    744 	if (dkd->d_dumpblocks == NULL) {
    745 		DPRINTF(DKDB_DUMP, ("%s: no dumpblocks\n", __func__));
    746 		return ENXIO;
    747 	}
    748 
    749 	/* device specific max transfer size */
    750 	maxxfer = MAXPHYS;
    751 	if (dkd->d_iosize != NULL)
    752 		(*dkd->d_iosize)(dksc->sc_dev, &maxxfer);
    753 
    754 	/* Convert to disk sectors.  Request must be a multiple of size. */
    755 	part = DISKPART(dev);
    756 	lp = dksc->sc_dkdev.dk_label;
    757 	if ((size % lp->d_secsize) != 0) {
    758 		DPRINTF(DKDB_DUMP, ("%s: odd size %zu\n", __func__, size));
    759 		return EFAULT;
    760 	}
    761 	towrt = size / lp->d_secsize;
    762 	blkno = dbtob(blkno) / lp->d_secsize;   /* blkno in secsize units */
    763 
    764 	p = &lp->d_partitions[part];
    765 	if (p->p_fstype != FS_SWAP) {
    766 		DPRINTF(DKDB_DUMP, ("%s: bad fstype %d\n", __func__,
    767 		    p->p_fstype));
    768 		return ENXIO;
    769 	}
    770 	nsects = p->p_size;
    771 	sectoff = p->p_offset;
    772 
    773 	/* Check transfer bounds against partition size. */
    774 	if ((blkno < 0) || ((blkno + towrt) > nsects)) {
    775 		DPRINTF(DKDB_DUMP, ("%s: out of bounds blkno=%jd, towrt=%d, "
    776 		    "nsects=%d\n", __func__, (intmax_t)blkno, towrt, nsects));
    777 		return EINVAL;
    778 	}
    779 
    780 	/* Offset block number to start of partition. */
    781 	blkno += sectoff;
    782 
    783 	/* Start dumping and return when done. */
    784 	maxblkcnt = howmany(maxxfer, lp->d_secsize);
    785 	while (towrt > 0) {
    786 		nblk = min(maxblkcnt, towrt);
    787 
    788 		if ((rv = (*dkd->d_dumpblocks)(dksc->sc_dev, va, blkno, nblk))
    789 		    != 0) {
    790 			DPRINTF(DKDB_DUMP, ("%s: dumpblocks %d\n", __func__,
    791 			    rv));
    792 			return rv;
    793 		}
    794 
    795 		towrt -= nblk;
    796 		blkno += nblk;
    797 		va += nblk * lp->d_secsize;
    798 	}
    799 
    800 	dk_dumping = 0;
    801 
    802 	return 0;
    803 }
    804 
    805 /* ARGSUSED */
    806 void
    807 dk_getdefaultlabel(struct dk_softc *dksc, struct disklabel *lp)
    808 {
    809 	struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
    810 
    811 	memset(lp, 0, sizeof(*lp));
    812 
    813 	if (dg->dg_secperunit > UINT32_MAX)
    814 		lp->d_secperunit = UINT32_MAX;
    815 	else
    816 		lp->d_secperunit = dg->dg_secperunit;
    817 	lp->d_secsize = dg->dg_secsize;
    818 	lp->d_nsectors = dg->dg_nsectors;
    819 	lp->d_ntracks = dg->dg_ntracks;
    820 	lp->d_ncylinders = dg->dg_ncylinders;
    821 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
    822 
    823 	strlcpy(lp->d_typename, dksc->sc_xname, sizeof(lp->d_typename));
    824 	lp->d_type = dksc->sc_dtype;
    825 	strlcpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
    826 	lp->d_rpm = 3600;
    827 	lp->d_interleave = 1;
    828 	lp->d_flags = 0;
    829 
    830 	lp->d_partitions[RAW_PART].p_offset = 0;
    831 	lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
    832 	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    833 	lp->d_npartitions = RAW_PART + 1;
    834 
    835 	lp->d_magic = DISKMAGIC;
    836 	lp->d_magic2 = DISKMAGIC;
    837 	lp->d_checksum = dkcksum(dksc->sc_dkdev.dk_label);
    838 }
    839 
    840 /* ARGSUSED */
    841 void
    842 dk_getdisklabel(struct dk_softc *dksc, dev_t dev)
    843 {
    844 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    845 	struct	 disklabel *lp = dksc->sc_dkdev.dk_label;
    846 	struct	 cpu_disklabel *clp = dksc->sc_dkdev.dk_cpulabel;
    847 	struct   disk_geom *dg = &dksc->sc_dkdev.dk_geom;
    848 	struct	 partition *pp;
    849 	int	 i;
    850 	const char	*errstring;
    851 
    852 	memset(clp, 0x0, sizeof(*clp));
    853 	dk_getdefaultlabel(dksc, lp);
    854 	errstring = readdisklabel(DKLABELDEV(dev), dkd->d_strategy,
    855 	    dksc->sc_dkdev.dk_label, dksc->sc_dkdev.dk_cpulabel);
    856 	if (errstring) {
    857 		dk_makedisklabel(dksc);
    858 		if (dksc->sc_flags & DKF_WARNLABEL)
    859 			printf("%s: %s\n", dksc->sc_xname, errstring);
    860 		return;
    861 	}
    862 
    863 	if ((dksc->sc_flags & DKF_LABELSANITY) == 0)
    864 		return;
    865 
    866 	/* Sanity check */
    867 	if (lp->d_secperunit < UINT32_MAX ?
    868 		lp->d_secperunit != dg->dg_secperunit :
    869 		lp->d_secperunit > dg->dg_secperunit)
    870 		printf("WARNING: %s: total sector size in disklabel (%ju) "
    871 		    "!= the size of %s (%ju)\n", dksc->sc_xname,
    872 		    (uintmax_t)lp->d_secperunit, dksc->sc_xname,
    873 		    (uintmax_t)dg->dg_secperunit);
    874 
    875 	for (i=0; i < lp->d_npartitions; i++) {
    876 		pp = &lp->d_partitions[i];
    877 		if (pp->p_offset + pp->p_size > dg->dg_secperunit)
    878 			printf("WARNING: %s: end of partition `%c' exceeds "
    879 			    "the size of %s (%ju)\n", dksc->sc_xname,
    880 			    'a' + i, dksc->sc_xname,
    881 			    (uintmax_t)dg->dg_secperunit);
    882 	}
    883 }
    884 
    885 /* ARGSUSED */
    886 static void
    887 dk_makedisklabel(struct dk_softc *dksc)
    888 {
    889 	struct	disklabel *lp = dksc->sc_dkdev.dk_label;
    890 
    891 	lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS;
    892 	strlcpy(lp->d_packname, "default label", sizeof(lp->d_packname));
    893 	lp->d_checksum = dkcksum(lp);
    894 }
    895 
    896 /* This function is taken from ccd.c:1.76  --rcd */
    897 
    898 /*
    899  * XXX this function looks too generic for dksubr.c, shouldn't we
    900  *     put it somewhere better?
    901  */
    902 
    903 /*
    904  * Lookup the provided name in the filesystem.  If the file exists,
    905  * is a valid block device, and isn't being used by anyone else,
    906  * set *vpp to the file's vnode.
    907  */
    908 int
    909 dk_lookup(struct pathbuf *pb, struct lwp *l, struct vnode **vpp)
    910 {
    911 	struct nameidata nd;
    912 	struct vnode *vp;
    913 	int     error;
    914 
    915 	if (l == NULL)
    916 		return ESRCH;	/* Is ESRCH the best choice? */
    917 
    918 	NDINIT(&nd, LOOKUP, FOLLOW, pb);
    919 	if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) {
    920 		DPRINTF((DKDB_FOLLOW|DKDB_INIT),
    921 		    ("%s: vn_open error = %d\n", __func__, error));
    922 		return error;
    923 	}
    924 
    925 	vp = nd.ni_vp;
    926 	if (vp->v_type != VBLK) {
    927 		error = ENOTBLK;
    928 		goto out;
    929 	}
    930 
    931 	/* Reopen as anonymous vnode to protect against forced unmount. */
    932 	if ((error = bdevvp(vp->v_rdev, vpp)) != 0)
    933 		goto out;
    934 	VOP_UNLOCK(vp);
    935 	if ((error = vn_close(vp, FREAD | FWRITE, l->l_cred)) != 0) {
    936 		vrele(*vpp);
    937 		return error;
    938 	}
    939 	if ((error = VOP_OPEN(*vpp, FREAD | FWRITE, l->l_cred)) != 0) {
    940 		vrele(*vpp);
    941 		return error;
    942 	}
    943 	mutex_enter((*vpp)->v_interlock);
    944 	(*vpp)->v_writecount++;
    945 	mutex_exit((*vpp)->v_interlock);
    946 
    947 	IFDEBUG(DKDB_VNODE, vprint("dk_lookup: vnode info", *vpp));
    948 
    949 	return 0;
    950 out:
    951 	VOP_UNLOCK(vp);
    952 	(void) vn_close(vp, FREAD | FWRITE, l->l_cred);
    953 	return error;
    954 }
    955 
    956 MODULE(MODULE_CLASS_MISC, dk_subr, NULL);
    957 
    958 static int
    959 dk_subr_modcmd(modcmd_t cmd, void *arg)
    960 {
    961 	switch (cmd) {
    962 	case MODULE_CMD_INIT:
    963 	case MODULE_CMD_FINI:
    964 		return 0;
    965 	case MODULE_CMD_STAT:
    966 	case MODULE_CMD_AUTOUNLOAD:
    967 	default:
    968 		return ENOTTY;
    969 	}
    970 }
    971