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