Home | History | Annotate | Line # | Download | only in dev
dksubr.c revision 1.68 
      1 /* $NetBSD: dksubr.c,v 1.68 2015/08/02 07:25:40 mlelstv 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.68 2015/08/02 07:25:40 mlelstv 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 
     61 #define IFDEBUG(x,y)		if (dkdebug & (x)) y
     62 #define DPRINTF(x,y)		IFDEBUG(x, printf y)
     63 #define DPRINTF_FOLLOW(y)	DPRINTF(DKDB_FOLLOW, y)
     64 #else
     65 #define IFDEBUG(x,y)
     66 #define DPRINTF(x,y)
     67 #define DPRINTF_FOLLOW(y)
     68 #endif
     69 
     70 static int dk_subr_modcmd(modcmd_t, void *);
     71 
     72 #define DKLABELDEV(dev)	\
     73 	(MAKEDISKDEV(major((dev)), DISKUNIT((dev)), RAW_PART))
     74 
     75 static void	dk_makedisklabel(struct dk_softc *);
     76 
     77 void
     78 dk_init(struct dk_softc *dksc, device_t dev, int dtype)
     79 {
     80 
     81 	memset(dksc, 0x0, sizeof(*dksc));
     82 	dksc->sc_dtype = dtype;
     83 	dksc->sc_dev = dev;
     84 
     85 	strlcpy(dksc->sc_xname, device_xname(dev), DK_XNAME_SIZE);
     86 	dksc->sc_dkdev.dk_name = dksc->sc_xname;
     87 }
     88 
     89 void
     90 dk_attach(struct dk_softc *dksc)
     91 {
     92 	dksc->sc_flags |= DKF_INITED;
     93 #ifdef DIAGNOSTIC
     94 	dksc->sc_flags |= DKF_WARNLABEL | DKF_LABELSANITY;
     95 #endif
     96 }
     97 
     98 void
     99 dk_detach(struct dk_softc *dksc)
    100 {
    101 	dksc->sc_flags &= ~DKF_INITED;
    102 }
    103 
    104 /* ARGSUSED */
    105 int
    106 dk_open(struct dk_softc *dksc, dev_t dev,
    107     int flags, int fmt, struct lwp *l)
    108 {
    109 	struct	disklabel *lp = dksc->sc_dkdev.dk_label;
    110 	int	part = DISKPART(dev);
    111 	int	pmask = 1 << part;
    112 	int	ret = 0;
    113 	struct disk *dk = &dksc->sc_dkdev;
    114 
    115 	DPRINTF_FOLLOW(("dk_open(%s, %p, 0x%"PRIx64", 0x%x)\n",
    116 	    dksc->sc_xname, dksc, dev, flags));
    117 
    118 	mutex_enter(&dk->dk_openlock);
    119 
    120 	/*
    121 	 * If there are wedges, and this is not RAW_PART, then we
    122 	 * need to fail.
    123 	 */
    124 	if (dk->dk_nwedges != 0 && part != RAW_PART) {
    125 		ret = EBUSY;
    126 		goto done;
    127 	}
    128 
    129 	/*
    130 	 * If we're init'ed and there are no other open partitions then
    131 	 * update the in-core disklabel.
    132 	 */
    133 	if ((dksc->sc_flags & DKF_INITED)) {
    134 		if ((dksc->sc_flags & DKF_VLABEL) == 0) {
    135 			dksc->sc_flags |= DKF_VLABEL;
    136 			dk_getdisklabel(dksc, dev);
    137 		}
    138 	}
    139 
    140 	/* Fail if we can't find the partition. */
    141 	if (part != RAW_PART &&
    142 	    ((dksc->sc_flags & DKF_VLABEL) == 0 ||
    143 	     part >= lp->d_npartitions ||
    144 	     lp->d_partitions[part].p_fstype == FS_UNUSED)) {
    145 		ret = ENXIO;
    146 		goto done;
    147 	}
    148 
    149 	/* Mark our unit as open. */
    150 	switch (fmt) {
    151 	case S_IFCHR:
    152 		dk->dk_copenmask |= pmask;
    153 		break;
    154 	case S_IFBLK:
    155 		dk->dk_bopenmask |= pmask;
    156 		break;
    157 	}
    158 
    159 	dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
    160 
    161 done:
    162 	mutex_exit(&dk->dk_openlock);
    163 	return ret;
    164 }
    165 
    166 /* ARGSUSED */
    167 int
    168 dk_close(struct dk_softc *dksc, dev_t dev,
    169     int flags, int fmt, struct lwp *l)
    170 {
    171 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    172 	int	part = DISKPART(dev);
    173 	int	pmask = 1 << part;
    174 	struct disk *dk = &dksc->sc_dkdev;
    175 
    176 	DPRINTF_FOLLOW(("dk_close(%s, %p, 0x%"PRIx64", 0x%x)\n",
    177 	    dksc->sc_xname, dksc, dev, flags));
    178 
    179 	mutex_enter(&dk->dk_openlock);
    180 
    181 	switch (fmt) {
    182 	case S_IFCHR:
    183 		dk->dk_copenmask &= ~pmask;
    184 		break;
    185 	case S_IFBLK:
    186 		dk->dk_bopenmask &= ~pmask;
    187 		break;
    188 	}
    189 	dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
    190 
    191 	if (dk->dk_openmask == 0) {
    192 		if (dkd->d_lastclose != NULL)
    193 			(*dkd->d_lastclose)(dksc->sc_dev);
    194 		if ((dksc->sc_flags & DKF_KLABEL) == 0)
    195 			dksc->sc_flags &= ~DKF_VLABEL;
    196 	}
    197 
    198 	mutex_exit(&dk->dk_openlock);
    199 	return 0;
    200 }
    201 
    202 void
    203 dk_strategy(struct dk_softc *dksc, struct buf *bp)
    204 {
    205 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    206 	int	s, part;
    207 	int	wlabel;
    208 	daddr_t	blkno;
    209 	struct disklabel *lp;
    210 	struct disk *dk;
    211 	uint64_t numsecs;
    212 	unsigned secsize;
    213 
    214 	DPRINTF_FOLLOW(("dk_strategy(%s, %p, %p)\n",
    215 	    dksc->sc_xname, dksc, bp));
    216 
    217 	if (!(dksc->sc_flags & DKF_INITED)) {
    218 		DPRINTF_FOLLOW(("dk_strategy: not inited\n"));
    219 		bp->b_error  = ENXIO;
    220 		biodone(bp);
    221 		return;
    222 	}
    223 
    224 	lp = dksc->sc_dkdev.dk_label;
    225 	dk = &dksc->sc_dkdev;
    226 
    227 	part = DISKPART(bp->b_dev);
    228 	numsecs = dk->dk_geom.dg_secperunit;
    229 	secsize = dk->dk_geom.dg_secsize;
    230 
    231 	bp->b_resid = bp->b_bcount;
    232 
    233 	/*
    234 	 * The transfer must be a whole number of blocks and the offset must
    235 	 * not be negative.
    236 	 */
    237 	if ((bp->b_bcount % secsize) != 0 || bp->b_blkno < 0) {
    238 		bp->b_error = EINVAL;
    239 		biodone(bp);
    240 		return;
    241 	}
    242 
    243 	/* If there is nothing to do, then we are done */
    244 	if (bp->b_bcount == 0) {
    245 		biodone(bp);
    246 		return;
    247 	}
    248 
    249 	wlabel = dksc->sc_flags & (DKF_WLABEL|DKF_LABELLING);
    250 	if (part == RAW_PART) {
    251 		if (bounds_check_with_mediasize(bp, DEV_BSIZE, numsecs) <= 0) {
    252 			biodone(bp);
    253 			return;
    254 		}
    255 	} else {
    256 		if (bounds_check_with_label(&dksc->sc_dkdev, bp, wlabel) <= 0) {
    257 			biodone(bp);
    258 			return;
    259 		}
    260 	}
    261 
    262 	/*
    263 	 * Convert the block number to absolute and put it in terms
    264 	 * of the device's logical block size.
    265 	 */
    266 	if (secsize >= DEV_BSIZE)
    267 		blkno = bp->b_blkno / (secsize / DEV_BSIZE);
    268 	else
    269 		blkno = bp->b_blkno * (DEV_BSIZE / secsize);
    270 
    271 	if (part != RAW_PART)
    272 		blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset;
    273 	bp->b_rawblkno = blkno;
    274 
    275 	/*
    276 	 * Start the unit by calling the start routine
    277 	 * provided by the individual driver.
    278 	 */
    279 	s = splbio();
    280 	bufq_put(dksc->sc_bufq, bp);
    281 	dkd->d_diskstart(dksc->sc_dev);
    282 	splx(s);
    283 	return;
    284 }
    285 
    286 void
    287 dk_done(struct dk_softc *dksc, struct buf *bp)
    288 {
    289 	struct disk *dk = &dksc->sc_dkdev;
    290 
    291 	if (bp->b_error != 0) {
    292 		struct cfdriver *cd = device_cfdriver(dksc->sc_dev);
    293 
    294 		diskerr(bp, cd->cd_name, "error", LOG_PRINTF, 0,
    295 			dk->dk_label);
    296 		printf("\n");
    297 	}
    298 
    299 	disk_unbusy(dk, bp->b_bcount - bp->b_resid, (bp->b_flags & B_READ));
    300 #ifdef notyet
    301 	rnd_add_uint(&dksc->sc_rnd_source, bp->b_rawblkno);
    302 #endif
    303 	biodone(bp);
    304 }
    305 
    306 int
    307 dk_size(struct dk_softc *dksc, dev_t dev)
    308 {
    309 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    310 	struct	disklabel *lp;
    311 	int	is_open;
    312 	int	part;
    313 	int	size;
    314 
    315 	if ((dksc->sc_flags & DKF_INITED) == 0)
    316 		return -1;
    317 
    318 	part = DISKPART(dev);
    319 	is_open = dksc->sc_dkdev.dk_openmask & (1 << part);
    320 
    321 	if (!is_open && dkd->d_open(dev, 0, S_IFBLK, curlwp))
    322 		return -1;
    323 
    324 	lp = dksc->sc_dkdev.dk_label;
    325 	if (lp->d_partitions[part].p_fstype != FS_SWAP)
    326 		size = -1;
    327 	else
    328 		size = lp->d_partitions[part].p_size *
    329 		    (lp->d_secsize / DEV_BSIZE);
    330 
    331 	if (!is_open && dkd->d_close(dev, 0, S_IFBLK, curlwp))
    332 		return -1;
    333 
    334 	return size;
    335 }
    336 
    337 int
    338 dk_ioctl(struct dk_softc *dksc, dev_t dev,
    339 	    u_long cmd, void *data, int flag, struct lwp *l)
    340 {
    341 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    342 	struct	disklabel *lp;
    343 	struct	disk *dk = &dksc->sc_dkdev;
    344 #ifdef __HAVE_OLD_DISKLABEL
    345 	struct	disklabel newlabel;
    346 #endif
    347 	int	error;
    348 
    349 	DPRINTF_FOLLOW(("dk_ioctl(%s, %p, 0x%"PRIx64", 0x%lx)\n",
    350 	    dksc->sc_xname, dksc, dev, cmd));
    351 
    352 	/* ensure that the pseudo disk is open for writes for these commands */
    353 	switch (cmd) {
    354 	case DIOCSDINFO:
    355 	case DIOCWDINFO:
    356 #ifdef __HAVE_OLD_DISKLABEL
    357 	case ODIOCSDINFO:
    358 	case ODIOCWDINFO:
    359 #endif
    360 	case DIOCWLABEL:
    361 	case DIOCAWEDGE:
    362 	case DIOCDWEDGE:
    363 		if ((flag & FWRITE) == 0)
    364 			return EBADF;
    365 	}
    366 
    367 	/* ensure that the pseudo-disk is initialized for these */
    368 	switch (cmd) {
    369 	case DIOCGDINFO:
    370 	case DIOCSDINFO:
    371 	case DIOCWDINFO:
    372 	case DIOCGPART:
    373 	case DIOCKLABEL:
    374 	case DIOCWLABEL:
    375 	case DIOCGDEFLABEL:
    376 	case DIOCAWEDGE:
    377 	case DIOCDWEDGE:
    378 	case DIOCLWEDGES:
    379 	case DIOCMWEDGES:
    380 	case DIOCCACHESYNC:
    381 #ifdef __HAVE_OLD_DISKLABEL
    382 	case ODIOCGDINFO:
    383 	case ODIOCSDINFO:
    384 	case ODIOCWDINFO:
    385 	case ODIOCGDEFLABEL:
    386 #endif
    387 		if ((dksc->sc_flags & DKF_INITED) == 0)
    388 			return ENXIO;
    389 	}
    390 
    391 	error = disk_ioctl(dk, dev, cmd, data, flag, l);
    392 	if (error != EPASSTHROUGH)
    393 		return error;
    394 	else
    395 		error = 0;
    396 
    397 	switch (cmd) {
    398 	case DIOCWDINFO:
    399 	case DIOCSDINFO:
    400 #ifdef __HAVE_OLD_DISKLABEL
    401 	case ODIOCWDINFO:
    402 	case ODIOCSDINFO:
    403 #endif
    404 #ifdef __HAVE_OLD_DISKLABEL
    405 		if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
    406 			memset(&newlabel, 0, sizeof newlabel);
    407 			memcpy(&newlabel, data, sizeof (struct olddisklabel));
    408 			lp = &newlabel;
    409 		} else
    410 #endif
    411 		lp = (struct disklabel *)data;
    412 
    413 		mutex_enter(&dk->dk_openlock);
    414 		dksc->sc_flags |= DKF_LABELLING;
    415 
    416 		error = setdisklabel(dksc->sc_dkdev.dk_label,
    417 		    lp, 0, dksc->sc_dkdev.dk_cpulabel);
    418 		if (error == 0) {
    419 			if (cmd == DIOCWDINFO
    420 #ifdef __HAVE_OLD_DISKLABEL
    421 			    || cmd == ODIOCWDINFO
    422 #endif
    423 			   )
    424 				error = writedisklabel(DKLABELDEV(dev),
    425 				    dkd->d_strategy, dksc->sc_dkdev.dk_label,
    426 				    dksc->sc_dkdev.dk_cpulabel);
    427 		}
    428 
    429 		dksc->sc_flags &= ~DKF_LABELLING;
    430 		mutex_exit(&dk->dk_openlock);
    431 		break;
    432 
    433 	case DIOCKLABEL:
    434 		if ((flag & FWRITE) == 0)
    435 			return (EBADF);
    436 		if (*(int *)data != 0)
    437 			dksc->sc_flags |= DKF_KLABEL;
    438 		else
    439 			dksc->sc_flags &= ~DKF_KLABEL;
    440 		break;
    441 
    442 	case DIOCWLABEL:
    443 		if (*(int *)data != 0)
    444 			dksc->sc_flags |= DKF_WLABEL;
    445 		else
    446 			dksc->sc_flags &= ~DKF_WLABEL;
    447 		break;
    448 
    449 	case DIOCGDEFLABEL:
    450 		dk_getdefaultlabel(dksc, (struct disklabel *)data);
    451 		break;
    452 
    453 #ifdef __HAVE_OLD_DISKLABEL
    454 	case ODIOCGDEFLABEL:
    455 		dk_getdefaultlabel(dksc, &newlabel);
    456 		if (newlabel.d_npartitions > OLDMAXPARTITIONS)
    457 			return ENOTTY;
    458 		memcpy(data, &newlabel, sizeof (struct olddisklabel));
    459 		break;
    460 #endif
    461 
    462 	case DIOCGSTRATEGY:
    463 	    {
    464 		struct disk_strategy *dks = (void *)data;
    465 		int s;
    466 
    467 		s = splbio();
    468 		strlcpy(dks->dks_name, bufq_getstrategyname(dksc->sc_bufq),
    469 		    sizeof(dks->dks_name));
    470 		splx(s);
    471 		dks->dks_paramlen = 0;
    472 
    473 		return 0;
    474 	    }
    475 
    476 	case DIOCSSTRATEGY:
    477 	    {
    478 		struct disk_strategy *dks = (void *)data;
    479 		struct bufq_state *new;
    480 		struct bufq_state *old;
    481 		int s;
    482 
    483 		if ((flag & FWRITE) == 0) {
    484 			return EBADF;
    485 		}
    486 		if (dks->dks_param != NULL) {
    487 			return EINVAL;
    488 		}
    489 		dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */
    490 		error = bufq_alloc(&new, dks->dks_name,
    491 		    BUFQ_EXACT|BUFQ_SORT_RAWBLOCK);
    492 		if (error) {
    493 			return error;
    494 		}
    495 		s = splbio();
    496 		old = dksc->sc_bufq;
    497 		bufq_move(new, old);
    498 		dksc->sc_bufq = new;
    499 		splx(s);
    500 		bufq_free(old);
    501 
    502 		return 0;
    503 	    }
    504 
    505 	default:
    506 		error = ENOTTY;
    507 	}
    508 
    509 	return error;
    510 }
    511 
    512 /*
    513  * dk_dump dumps all of physical memory into the partition specified.
    514  * This requires substantially more framework than {s,w}ddump, and hence
    515  * is probably much more fragile.
    516  *
    517  */
    518 
    519 #define DKF_READYFORDUMP	(DKF_INITED|DKF_TAKEDUMP)
    520 #define DKFF_READYFORDUMP(x)	(((x) & DKF_READYFORDUMP) == DKF_READYFORDUMP)
    521 static volatile int	dk_dumping = 0;
    522 
    523 /* ARGSUSED */
    524 int
    525 dk_dump(struct dk_softc *dksc, dev_t dev,
    526     daddr_t blkno, void *vav, size_t size)
    527 {
    528 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    529 	char *va = vav;
    530 	struct disklabel *lp;
    531 	int part, towrt, nsects, sectoff, maxblkcnt, nblk;
    532 	int maxxfer, rv = 0;
    533 
    534 	/*
    535 	 * ensure that we consider this device to be safe for dumping,
    536 	 * and that the device is configured.
    537 	 */
    538 	if (!DKFF_READYFORDUMP(dksc->sc_flags))
    539 		return ENXIO;
    540 
    541 	/* ensure that we are not already dumping */
    542 	if (dk_dumping)
    543 		return EFAULT;
    544 	dk_dumping = 1;
    545 
    546 	if (dkd->d_dumpblocks == NULL)
    547 		return ENXIO;
    548 
    549 	/* device specific max transfer size */
    550 	maxxfer = MAXPHYS;
    551 	if (dkd->d_iosize != NULL)
    552 		(*dkd->d_iosize)(dksc->sc_dev, &maxxfer);
    553 
    554 	/* Convert to disk sectors.  Request must be a multiple of size. */
    555 	part = DISKPART(dev);
    556 	lp = dksc->sc_dkdev.dk_label;
    557 	if ((size % lp->d_secsize) != 0)
    558 		return (EFAULT);
    559 	towrt = size / lp->d_secsize;
    560 	blkno = dbtob(blkno) / lp->d_secsize;   /* blkno in secsize units */
    561 
    562 	nsects = lp->d_partitions[part].p_size;
    563 	sectoff = lp->d_partitions[part].p_offset;
    564 
    565 	/* Check transfer bounds against partition size. */
    566 	if ((blkno < 0) || ((blkno + towrt) > nsects))
    567 		return (EINVAL);
    568 
    569 	/* Offset block number to start of partition. */
    570 	blkno += sectoff;
    571 
    572 	/* Start dumping and return when done. */
    573 	maxblkcnt = howmany(maxxfer, lp->d_secsize);
    574 	while (towrt > 0) {
    575 		nblk = min(maxblkcnt, towrt);
    576 
    577 		if ((rv = (*dkd->d_dumpblocks)(dksc->sc_dev, va, blkno, nblk)) != 0)
    578 			return (rv);
    579 
    580 		towrt -= nblk;
    581 		blkno += nblk;
    582 		va += nblk * lp->d_secsize;
    583 	}
    584 
    585 	dk_dumping = 0;
    586 
    587 	return 0;
    588 }
    589 
    590 /* ARGSUSED */
    591 void
    592 dk_getdefaultlabel(struct dk_softc *dksc, struct disklabel *lp)
    593 {
    594 	struct disk_geom *dg = &dksc->sc_dkdev.dk_geom;
    595 
    596 	memset(lp, 0, sizeof(*lp));
    597 
    598 	if (dg->dg_secperunit > UINT32_MAX)
    599 		lp->d_secperunit = UINT32_MAX;
    600 	else
    601 		lp->d_secperunit = dg->dg_secperunit;
    602 	lp->d_secsize = dg->dg_secsize;
    603 	lp->d_nsectors = dg->dg_nsectors;
    604 	lp->d_ntracks = dg->dg_ntracks;
    605 	lp->d_ncylinders = dg->dg_ncylinders;
    606 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
    607 
    608 	strlcpy(lp->d_typename, dksc->sc_xname, sizeof(lp->d_typename));
    609 	lp->d_type = dksc->sc_dtype;
    610 	strlcpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
    611 	lp->d_rpm = 3600;
    612 	lp->d_interleave = 1;
    613 	lp->d_flags = 0;
    614 
    615 	lp->d_partitions[RAW_PART].p_offset = 0;
    616 	lp->d_partitions[RAW_PART].p_size = lp->d_secperunit;
    617 	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    618 	lp->d_npartitions = RAW_PART + 1;
    619 
    620 	lp->d_magic = DISKMAGIC;
    621 	lp->d_magic2 = DISKMAGIC;
    622 	lp->d_checksum = dkcksum(dksc->sc_dkdev.dk_label);
    623 }
    624 
    625 /* ARGSUSED */
    626 void
    627 dk_getdisklabel(struct dk_softc *dksc, dev_t dev)
    628 {
    629 	const struct dkdriver *dkd = dksc->sc_dkdev.dk_driver;
    630 	struct	 disklabel *lp = dksc->sc_dkdev.dk_label;
    631 	struct	 cpu_disklabel *clp = dksc->sc_dkdev.dk_cpulabel;
    632 	struct   disk_geom *dg = &dksc->sc_dkdev.dk_geom;
    633 	struct	 partition *pp;
    634 	int	 i;
    635 	const char	*errstring;
    636 
    637 	memset(clp, 0x0, sizeof(*clp));
    638 	dk_getdefaultlabel(dksc, lp);
    639 	errstring = readdisklabel(DKLABELDEV(dev), dkd->d_strategy,
    640 	    dksc->sc_dkdev.dk_label, dksc->sc_dkdev.dk_cpulabel);
    641 	if (errstring) {
    642 		dk_makedisklabel(dksc);
    643 		if (dksc->sc_flags & DKF_WARNLABEL)
    644 			printf("%s: %s\n", dksc->sc_xname, errstring);
    645 		return;
    646 	}
    647 
    648 	if ((dksc->sc_flags & DKF_LABELSANITY) == 0)
    649 		return;
    650 
    651 	/* Sanity check */
    652 	if (lp->d_secperunit < UINT32_MAX ?
    653 		lp->d_secperunit != dg->dg_secperunit :
    654 		lp->d_secperunit > dg->dg_secperunit)
    655 		printf("WARNING: %s: total sector size in disklabel (%ju) "
    656 		    "!= the size of %s (%ju)\n", dksc->sc_xname,
    657 		    (uintmax_t)lp->d_secperunit, dksc->sc_xname,
    658 		    (uintmax_t)dg->dg_secperunit);
    659 
    660 	for (i=0; i < lp->d_npartitions; i++) {
    661 		pp = &lp->d_partitions[i];
    662 		if (pp->p_offset + pp->p_size > dg->dg_secperunit)
    663 			printf("WARNING: %s: end of partition `%c' exceeds "
    664 			    "the size of %s (%ju)\n", dksc->sc_xname,
    665 			    'a' + i, dksc->sc_xname,
    666 			    (uintmax_t)dg->dg_secperunit);
    667 	}
    668 }
    669 
    670 /* ARGSUSED */
    671 static void
    672 dk_makedisklabel(struct dk_softc *dksc)
    673 {
    674 	struct	disklabel *lp = dksc->sc_dkdev.dk_label;
    675 
    676 	lp->d_partitions[RAW_PART].p_fstype = FS_BSDFFS;
    677 	strlcpy(lp->d_packname, "default label", sizeof(lp->d_packname));
    678 	lp->d_checksum = dkcksum(lp);
    679 }
    680 
    681 /* This function is taken from ccd.c:1.76  --rcd */
    682 
    683 /*
    684  * XXX this function looks too generic for dksubr.c, shouldn't we
    685  *     put it somewhere better?
    686  */
    687 
    688 /*
    689  * Lookup the provided name in the filesystem.  If the file exists,
    690  * is a valid block device, and isn't being used by anyone else,
    691  * set *vpp to the file's vnode.
    692  */
    693 int
    694 dk_lookup(struct pathbuf *pb, struct lwp *l, struct vnode **vpp)
    695 {
    696 	struct nameidata nd;
    697 	struct vnode *vp;
    698 	int     error;
    699 
    700 	if (l == NULL)
    701 		return ESRCH;	/* Is ESRCH the best choice? */
    702 
    703 	NDINIT(&nd, LOOKUP, FOLLOW, pb);
    704 	if ((error = vn_open(&nd, FREAD | FWRITE, 0)) != 0) {
    705 		DPRINTF((DKDB_FOLLOW|DKDB_INIT),
    706 		    ("dk_lookup: vn_open error = %d\n", error));
    707 		return error;
    708 	}
    709 
    710 	vp = nd.ni_vp;
    711 	if (vp->v_type != VBLK) {
    712 		error = ENOTBLK;
    713 		goto out;
    714 	}
    715 
    716 	/* Reopen as anonymous vnode to protect against forced unmount. */
    717 	if ((error = bdevvp(vp->v_rdev, vpp)) != 0)
    718 		goto out;
    719 	VOP_UNLOCK(vp);
    720 	if ((error = vn_close(vp, FREAD | FWRITE, l->l_cred)) != 0) {
    721 		vrele(*vpp);
    722 		return error;
    723 	}
    724 	if ((error = VOP_OPEN(*vpp, FREAD | FWRITE, l->l_cred)) != 0) {
    725 		vrele(*vpp);
    726 		return error;
    727 	}
    728 	mutex_enter((*vpp)->v_interlock);
    729 	(*vpp)->v_writecount++;
    730 	mutex_exit((*vpp)->v_interlock);
    731 
    732 	IFDEBUG(DKDB_VNODE, vprint("dk_lookup: vnode info", *vpp));
    733 
    734 	return 0;
    735 out:
    736 	VOP_UNLOCK(vp);
    737 	(void) vn_close(vp, FREAD | FWRITE, l->l_cred);
    738 	return error;
    739 }
    740 
    741 MODULE(MODULE_CLASS_MISC, dk_subr, NULL);
    742 
    743 static int
    744 dk_subr_modcmd(modcmd_t cmd, void *arg)
    745 {
    746 	switch (cmd) {
    747 	case MODULE_CMD_INIT:
    748 	case MODULE_CMD_FINI:
    749 		return 0;
    750 	case MODULE_CMD_STAT:
    751 	case MODULE_CMD_AUTOUNLOAD:
    752 	default:
    753 		return ENOTTY;
    754 	}
    755 }
    756