?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / dev / vnd.c
blob39eeb3a4e55f561eca089b6af089374ce23da18a
1 /* $NetBSD: vnd.c,v 1.204 2009/08/07 00:08:07 dyoung Exp $ */
2
3 /*-
4 * Copyright (c) 1996, 1997, 1998, 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.
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 /*
33 * Copyright (c) 1990, 1993
34 * The Regents of the University of California. All rights reserved.
35 *
36 * This code is derived from software contributed to Berkeley by
37 * the Systems Programming Group of the University of Utah Computer
38 * Science Department.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 * 1. Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in the
47 * documentation and/or other materials provided with the distribution.
48 * 3. Neither the name of the University nor the names of its contributors
49 * may be used to endorse or promote products derived from this software
50 * without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 *
64 * from: Utah $Hdr: vn.c 1.13 94/04/02$
65 *
66 * @(#)vn.c 8.9 (Berkeley) 5/14/95
67 */
68
69 /*
70 * Copyright (c) 1988 University of Utah.
71 *
72 * This code is derived from software contributed to Berkeley by
73 * the Systems Programming Group of the University of Utah Computer
74 * Science Department.
75 *
76 * Redistribution and use in source and binary forms, with or without
77 * modification, are permitted provided that the following conditions
78 * are met:
79 * 1. Redistributions of source code must retain the above copyright
80 * notice, this list of conditions and the following disclaimer.
81 * 2. Redistributions in binary form must reproduce the above copyright
82 * notice, this list of conditions and the following disclaimer in the
83 * documentation and/or other materials provided with the distribution.
84 * 3. All advertising materials mentioning features or use of this software
85 * must display the following acknowledgement:
86 * This product includes software developed by the University of
87 * California, Berkeley and its contributors.
88 * 4. Neither the name of the University nor the names of its contributors
89 * may be used to endorse or promote products derived from this software
90 * without specific prior written permission.
91 *
92 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
93 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
95 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
96 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
97 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
98 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
99 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
100 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
101 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
102 * SUCH DAMAGE.
103 *
104 * from: Utah $Hdr: vn.c 1.13 94/04/02$
105 *
106 * @(#)vn.c 8.9 (Berkeley) 5/14/95
107 */
108
109 /*
110 * Vnode disk driver.
111 *
112 * Block/character interface to a vnode. Allows one to treat a file
113 * as a disk (e.g. build a filesystem in it, mount it, etc.).
114 *
115 * NOTE 1: If the vnode supports the VOP_BMAP and VOP_STRATEGY operations,
116 * this uses them to avoid distorting the local buffer cache. If those
117 * block-level operations are not available, this falls back to the regular
118 * read and write calls. Using these may distort the cache in some cases
119 * but better have the driver working than preventing it to work on file
120 * systems where the block-level operations are not implemented for
121 * whatever reason.
122 *
123 * NOTE 2: There is a security issue involved with this driver.
124 * Once mounted all access to the contents of the "mapped" file via
125 * the special file is controlled by the permissions on the special
126 * file, the protection of the mapped file is ignored (effectively,
127 * by using root credentials in all transactions).
128 *
129 * NOTE 3: Doesn't interact with leases, should it?
130 */
131
132 #include <sys/cdefs.h>
133 __KERNEL_RCSID(0, "$NetBSD: vnd.c,v 1.204 2009/08/07 00:08:07 dyoung Exp $");
134
135 #if defined(_KERNEL_OPT)
136 #include "fs_nfs.h"
137 #include "opt_vnd.h"
138 #endif
139
140 #include <sys/param.h>
141 #include <sys/systm.h>
142 #include <sys/namei.h>
143 #include <sys/proc.h>
144 #include <sys/kthread.h>
145 #include <sys/errno.h>
146 #include <sys/buf.h>
147 #include <sys/bufq.h>
148 #include <sys/malloc.h>
149 #include <sys/ioctl.h>
150 #include <sys/disklabel.h>
151 #include <sys/device.h>
152 #include <sys/disk.h>
153 #include <sys/stat.h>
154 #include <sys/mount.h>
155 #include <sys/vnode.h>
156 #include <sys/file.h>
157 #include <sys/uio.h>
158 #include <sys/conf.h>
159 #include <sys/kauth.h>
160
161 #include <net/zlib.h>
162
163 #include <miscfs/genfs/genfs.h>
164 #include <miscfs/specfs/specdev.h>
165
166 #include <dev/dkvar.h>
167 #include <dev/vndvar.h>
168
169 #include <prop/proplib.h>
170
171 #if defined(VNDDEBUG) && !defined(DEBUG)
172 #define DEBUG
173 #endif
174
175 #ifdef DEBUG
176 int dovndcluster = 1;
177 #define VDB_FOLLOW 0x01
178 #define VDB_INIT 0x02
179 #define VDB_IO 0x04
180 #define VDB_LABEL 0x08
181 int vnddebug = 0x00;
182 #endif
183
184 #define vndunit(x) DISKUNIT(x)
185
186 struct vndxfer {
187 struct buf vx_buf;
188 struct vnd_softc *vx_vnd;
189 };
190 #define VND_BUFTOXFER(bp) ((struct vndxfer *)(void *)bp)
191
192 #define VND_GETXFER(vnd) pool_get(&(vnd)->sc_vxpool, PR_WAITOK)
193 #define VND_PUTXFER(vnd, vx) pool_put(&(vnd)->sc_vxpool, (vx))
194
195 #define VNDLABELDEV(dev) \
196 (MAKEDISKDEV(major((dev)), vndunit((dev)), RAW_PART))
197
198 /* called by main() at boot time */
199 void vndattach(int);
200
201 static void vndclear(struct vnd_softc *, int);
202 static int vnddoclear(struct vnd_softc *, int, int, bool);
203 static int vndsetcred(struct vnd_softc *, kauth_cred_t);
204 static void vndthrottle(struct vnd_softc *, struct vnode *);
205 static void vndiodone(struct buf *);
206 #if 0
207 static void vndshutdown(void);
208 #endif
209
210 static void vndgetdefaultlabel(struct vnd_softc *, struct disklabel *);
211 static void vndgetdisklabel(dev_t, struct vnd_softc *);
212
213 static int vndlock(struct vnd_softc *);
214 static void vndunlock(struct vnd_softc *);
215 #ifdef VND_COMPRESSION
216 static void compstrategy(struct buf *, off_t);
217 static void *vnd_alloc(void *, u_int, u_int);
218 static void vnd_free(void *, void *);
219 #endif /* VND_COMPRESSION */
220
221 static void vndthread(void *);
222 static bool vnode_has_op(const struct vnode *, int);
223 static void handle_with_rdwr(struct vnd_softc *, const struct buf *,
224 struct buf *);
225 static void handle_with_strategy(struct vnd_softc *, const struct buf *,
226 struct buf *);
227 static void vnd_set_properties(struct vnd_softc *);
228
229 static dev_type_open(vndopen);
230 static dev_type_close(vndclose);
231 static dev_type_read(vndread);
232 static dev_type_write(vndwrite);
233 static dev_type_ioctl(vndioctl);
234 static dev_type_strategy(vndstrategy);
235 static dev_type_dump(vnddump);
236 static dev_type_size(vndsize);
237
238 const struct bdevsw vnd_bdevsw = {
239 vndopen, vndclose, vndstrategy, vndioctl, vnddump, vndsize, D_DISK
240 };
241
242 const struct cdevsw vnd_cdevsw = {
243 vndopen, vndclose, vndread, vndwrite, vndioctl,
244 nostop, notty, nopoll, nommap, nokqfilter, D_DISK
245 };
246
247 static int vnd_match(device_t, cfdata_t, void *);
248 static void vnd_attach(device_t, device_t, void *);
249 static int vnd_detach(device_t, int);
250
251 CFATTACH_DECL3_NEW(vnd, sizeof(struct vnd_softc),
252 vnd_match, vnd_attach, vnd_detach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN);
253 extern struct cfdriver vnd_cd;
254
255 static struct vnd_softc *vnd_spawn(int);
256 int vnd_destroy(device_t);
257
258 void
259 vndattach(int num)
260 {
261 int error;
262
263 error = config_cfattach_attach(vnd_cd.cd_name, &vnd_ca);
264 if (error)
265 aprint_error("%s: unable to register cfattach\n",
266 vnd_cd.cd_name);
267 }
268
269 static int
270 vnd_match(device_t self, cfdata_t cfdata, void *aux)
271 {
272
273 return 1;
274 }
275
276 static void
277 vnd_attach(device_t parent, device_t self, void *aux)
278 {
279 struct vnd_softc *sc = device_private(self);
280
281 sc->sc_dev = self;
282 sc->sc_comp_offsets = NULL;
283 sc->sc_comp_buff = NULL;
284 sc->sc_comp_decombuf = NULL;
285 bufq_alloc(&sc->sc_tab, "disksort", BUFQ_SORT_RAWBLOCK);
286 disk_init(&sc->sc_dkdev, device_xname(self), NULL);
287 if (!pmf_device_register(self, NULL, NULL))
288 aprint_error_dev(self, "couldn't establish power handler\n");
289 }
290
291 static int
292 vnd_detach(device_t self, int flags)
293 {
294 int error;
295 struct vnd_softc *sc = device_private(self);
296
297 if (sc->sc_flags & VNF_INITED) {
298 error = vnddoclear(sc, 0, -1, (flags & DETACH_FORCE) != 0);
299 if (error != 0)
300 return error;
301 }
302
303 pmf_device_deregister(self);
304 bufq_free(sc->sc_tab);
305 disk_destroy(&sc->sc_dkdev);
306
307 return 0;
308 }
309
310 static struct vnd_softc *
311 vnd_spawn(int unit)
312 {
313 cfdata_t cf;
314
315 cf = malloc(sizeof(*cf), M_DEVBUF, M_WAITOK);
316 cf->cf_name = vnd_cd.cd_name;
317 cf->cf_atname = vnd_cd.cd_name;
318 cf->cf_unit = unit;
319 cf->cf_fstate = FSTATE_STAR;
320
321 return device_private(config_attach_pseudo(cf));
322 }
323
324 int
325 vnd_destroy(device_t dev)
326 {
327 int error;
328 cfdata_t cf;
329
330 cf = device_cfdata(dev);
331 error = config_detach(dev, DETACH_QUIET);
332 if (error)
333 return error;
334 free(cf, M_DEVBUF);
335 return 0;
336 }
337
338 static int
339 vndopen(dev_t dev, int flags, int mode, struct lwp *l)
340 {
341 int unit = vndunit(dev);
342 struct vnd_softc *sc;
343 int error = 0, part, pmask;
344 struct disklabel *lp;
345
346 #ifdef DEBUG
347 if (vnddebug & VDB_FOLLOW)
348 printf("vndopen(0x%"PRIx64", 0x%x, 0x%x, %p)\n", dev, flags, mode, l);
349 #endif
350 sc = device_lookup_private(&vnd_cd, unit);
351 if (sc == NULL) {
352 sc = vnd_spawn(unit);
353 if (sc == NULL)
354 return ENOMEM;
355 }
356
357 if ((error = vndlock(sc)) != 0)
358 return error;
359
360 if ((sc->sc_flags & VNF_CLEARING) != 0) {
361 error = ENXIO;
362 goto done;
363 }
364
365 lp = sc->sc_dkdev.dk_label;
366
367 part = DISKPART(dev);
368 pmask = (1 << part);
369
370 /*
371 * If we're initialized, check to see if there are any other
372 * open partitions. If not, then it's safe to update the
373 * in-core disklabel. Only read the disklabel if it is
374 * not already valid.
375 */
376 if ((sc->sc_flags & (VNF_INITED|VNF_VLABEL)) == VNF_INITED &&
377 sc->sc_dkdev.dk_openmask == 0)
378 vndgetdisklabel(dev, sc);
379
380 /* Check that the partitions exists. */
381 if (part != RAW_PART) {
382 if (((sc->sc_flags & VNF_INITED) == 0) ||
383 ((part >= lp->d_npartitions) ||
384 (lp->d_partitions[part].p_fstype == FS_UNUSED))) {
385 error = ENXIO;
386 goto done;
387 }
388 }
389
390 /* Prevent our unit from being unconfigured while open. */
391 switch (mode) {
392 case S_IFCHR:
393 sc->sc_dkdev.dk_copenmask |= pmask;
394 break;
395
396 case S_IFBLK:
397 sc->sc_dkdev.dk_bopenmask |= pmask;
398 break;
399 }
400 sc->sc_dkdev.dk_openmask =
401 sc->sc_dkdev.dk_copenmask | sc->sc_dkdev.dk_bopenmask;
402
403 done:
404 vndunlock(sc);
405 return error;
406 }
407
408 static int
409 vndclose(dev_t dev, int flags, int mode, struct lwp *l)
410 {
411 int unit = vndunit(dev);
412 struct vnd_softc *sc;
413 int error = 0, part;
414
415 #ifdef DEBUG
416 if (vnddebug & VDB_FOLLOW)
417 printf("vndclose(0x%"PRIx64", 0x%x, 0x%x, %p)\n", dev, flags, mode, l);
418 #endif
419 sc = device_lookup_private(&vnd_cd, unit);
420 if (sc == NULL)
421 return ENXIO;
422
423 if ((error = vndlock(sc)) != 0)
424 return error;
425
426 part = DISKPART(dev);
427
428 /* ...that much closer to allowing unconfiguration... */
429 switch (mode) {
430 case S_IFCHR:
431 sc->sc_dkdev.dk_copenmask &= ~(1 << part);
432 break;
433
434 case S_IFBLK:
435 sc->sc_dkdev.dk_bopenmask &= ~(1 << part);
436 break;
437 }
438 sc->sc_dkdev.dk_openmask =
439 sc->sc_dkdev.dk_copenmask | sc->sc_dkdev.dk_bopenmask;
440
441 vndunlock(sc);
442
443 if ((sc->sc_flags & VNF_INITED) == 0) {
444 if ((error = vnd_destroy(sc->sc_dev)) != 0) {
445 aprint_error_dev(sc->sc_dev,
446 "unable to detach instance\n");
447 return error;
448 }
449 }
450
451 return 0;
452 }
453
454 /*
455 * Queue the request, and wakeup the kernel thread to handle it.
456 */
457 static void
458 vndstrategy(struct buf *bp)
459 {
460 int unit = vndunit(bp->b_dev);
461 struct vnd_softc *vnd =
462 device_lookup_private(&vnd_cd, unit);
463 struct disklabel *lp;
464 daddr_t blkno;
465 int s = splbio();
466
467 if (vnd == NULL) {
468 bp->b_error = ENXIO;
469 goto done;
470 }
471 lp = vnd->sc_dkdev.dk_label;
472
473 if ((vnd->sc_flags & VNF_INITED) == 0) {
474 bp->b_error = ENXIO;
475 goto done;
476 }
477
478 /*
479 * The transfer must be a whole number of blocks.
480 */
481 if ((bp->b_bcount % lp->d_secsize) != 0) {
482 bp->b_error = EINVAL;
483 goto done;
484 }
485
486 /*
487 * check if we're read-only.
488 */
489 if ((vnd->sc_flags & VNF_READONLY) && !(bp->b_flags & B_READ)) {
490 bp->b_error = EACCES;
491 goto done;
492 }
493
494 /* If it's a nil transfer, wake up the top half now. */
495 if (bp->b_bcount == 0) {
496 goto done;
497 }
498
499 /*
500 * Do bounds checking and adjust transfer. If there's an error,
501 * the bounds check will flag that for us.
502 */
503 if (DISKPART(bp->b_dev) == RAW_PART) {
504 if (bounds_check_with_mediasize(bp, DEV_BSIZE,
505 vnd->sc_size) <= 0)
506 goto done;
507 } else {
508 if (bounds_check_with_label(&vnd->sc_dkdev,
509 bp, vnd->sc_flags & (VNF_WLABEL|VNF_LABELLING)) <= 0)
510 goto done;
511 }
512
513 /*
514 * Put the block number in terms of the logical blocksize
515 * of the "device".
516 */
517
518 blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
519
520 /*
521 * Translate the partition-relative block number to an absolute.
522 */
523 if (DISKPART(bp->b_dev) != RAW_PART) {
524 struct partition *pp;
525
526 pp = &vnd->sc_dkdev.dk_label->d_partitions[
527 DISKPART(bp->b_dev)];
528 blkno += pp->p_offset;
529 }
530 bp->b_rawblkno = blkno;
531
532 #ifdef DEBUG
533 if (vnddebug & VDB_FOLLOW)
534 printf("vndstrategy(%p): unit %d\n", bp, unit);
535 #endif
536 bufq_put(vnd->sc_tab, bp);
537 wakeup(&vnd->sc_tab);
538 splx(s);
539 return;
540
541 done:
542 bp->b_resid = bp->b_bcount;
543 biodone(bp);
544 splx(s);
545 }
546
547 static bool
548 vnode_has_strategy(struct vnd_softc *vnd)
549 {
550 return vnode_has_op(vnd->sc_vp, VOFFSET(vop_bmap)) &&
551 vnode_has_op(vnd->sc_vp, VOFFSET(vop_strategy));
552 }
553
554 /* XXX this function needs a reliable check to detect
555 * sparse files. Otherwise, bmap/strategy may be used
556 * and fail on non-allocated blocks. VOP_READ/VOP_WRITE
557 * works on sparse files.
558 */
559 #if notyet
560 static bool
561 vnode_strategy_probe(struct vnd_softc *vnd)
562 {
563 int error;
564 daddr_t nbn;
565
566 if (!vnode_has_strategy(vnd))
567 return false;
568
569 /* Convert the first logical block number to its
570 * physical block number.
571 */
572 error = 0;
573 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY);
574 error = VOP_BMAP(vnd->sc_vp, 0, NULL, &nbn, NULL);
575 VOP_UNLOCK(vnd->sc_vp, 0);
576
577 /* Test if that worked. */
578 if (error == 0 && (long)nbn == -1)
579 return false;
580
581 return true;
582 }
583 #endif
584
585 static void
586 vndthread(void *arg)
587 {
588 struct vnd_softc *vnd = arg;
589 bool usestrategy;
590 int s;
591
592 /* Determine whether we can *use* VOP_BMAP and VOP_STRATEGY to
593 * directly access the backing vnode. If we can, use these two
594 * operations to avoid messing with the local buffer cache.
595 * Otherwise fall back to regular VOP_READ/VOP_WRITE operations
596 * which are guaranteed to work with any file system. */
597 usestrategy = vnode_has_strategy(vnd);
598
599 #ifdef DEBUG
600 if (vnddebug & VDB_INIT)
601 printf("vndthread: vp %p, %s\n", vnd->sc_vp,
602 usestrategy ?
603 "using bmap/strategy operations" :
604 "using read/write operations");
605 #endif
606
607 s = splbio();
608 vnd->sc_flags |= VNF_KTHREAD;
609 wakeup(&vnd->sc_kthread);
610
611 /*
612 * Dequeue requests and serve them depending on the available
613 * vnode operations.
614 */
615 while ((vnd->sc_flags & VNF_VUNCONF) == 0) {
616 struct vndxfer *vnx;
617 int flags;
618 struct buf *obp;
619 struct buf *bp;
620
621 obp = bufq_get(vnd->sc_tab);
622 if (obp == NULL) {
623 tsleep(&vnd->sc_tab, PRIBIO, "vndbp", 0);
624 continue;
625 };
626 splx(s);
627 flags = obp->b_flags;
628 #ifdef DEBUG
629 if (vnddebug & VDB_FOLLOW)
630 printf("vndthread(%p)\n", obp);
631 #endif
632
633 if (vnd->sc_vp->v_mount == NULL) {
634 obp->b_error = ENXIO;
635 goto done;
636 }
637 #ifdef VND_COMPRESSION
638 /* handle a compressed read */
639 if ((flags & B_READ) != 0 && (vnd->sc_flags & VNF_COMP)) {
640 off_t bn;
641
642 /* Convert to a byte offset within the file. */
643 bn = obp->b_rawblkno *
644 vnd->sc_dkdev.dk_label->d_secsize;
645
646 compstrategy(obp, bn);
647 goto done;
648 }
649 #endif /* VND_COMPRESSION */
650
651 /*
652 * Allocate a header for this transfer and link it to the
653 * buffer
654 */
655 s = splbio();
656 vnx = VND_GETXFER(vnd);
657 splx(s);
658 vnx->vx_vnd = vnd;
659
660 s = splbio();
661 while (vnd->sc_active >= vnd->sc_maxactive) {
662 tsleep(&vnd->sc_tab, PRIBIO, "vndac", 0);
663 }
664 vnd->sc_active++;
665 splx(s);
666
667 /* Instrumentation. */
668 disk_busy(&vnd->sc_dkdev);
669
670 bp = &vnx->vx_buf;
671 buf_init(bp);
672 bp->b_flags = (obp->b_flags & B_READ);
673 bp->b_oflags = obp->b_oflags;
674 bp->b_cflags = obp->b_cflags;
675 bp->b_iodone = vndiodone;
676 bp->b_private = obp;
677 bp->b_vp = vnd->sc_vp;
678 bp->b_objlock = &bp->b_vp->v_interlock;
679 bp->b_data = obp->b_data;
680 bp->b_bcount = obp->b_bcount;
681 BIO_COPYPRIO(bp, obp);
682
683 /* Handle the request using the appropriate operations. */
684 if (usestrategy)
685 handle_with_strategy(vnd, obp, bp);
686 else
687 handle_with_rdwr(vnd, obp, bp);
688
689 s = splbio();
690 continue;
691
692 done:
693 biodone(obp);
694 s = splbio();
695 }
696
697 vnd->sc_flags &= (~VNF_KTHREAD | VNF_VUNCONF);
698 wakeup(&vnd->sc_kthread);
699 splx(s);
700 kthread_exit(0);
701 }
702
703 /*
704 * Checks if the given vnode supports the requested operation.
705 * The operation is specified the offset returned by VOFFSET.
706 *
707 * XXX The test below used to determine this is quite fragile
708 * because it relies on the file system to use genfs to specify
709 * unimplemented operations. There might be another way to do
710 * it more cleanly.
711 */
712 static bool
713 vnode_has_op(const struct vnode *vp, int opoffset)
714 {
715 int (*defaultp)(void *);
716 int (*opp)(void *);
717
718 defaultp = vp->v_op[VOFFSET(vop_default)];
719 opp = vp->v_op[opoffset];
720
721 return opp != defaultp && opp != genfs_eopnotsupp &&
722 opp != genfs_badop && opp != genfs_nullop;
723 }
724
725 /*
726 * Handes the read/write request given in 'bp' using the vnode's VOP_READ
727 * and VOP_WRITE operations.
728 *
729 * 'obp' is a pointer to the original request fed to the vnd device.
730 */
731 static void
732 handle_with_rdwr(struct vnd_softc *vnd, const struct buf *obp, struct buf *bp)
733 {
734 bool doread;
735 off_t offset;
736 size_t resid;
737 struct vnode *vp;
738
739 doread = bp->b_flags & B_READ;
740 offset = obp->b_rawblkno * vnd->sc_dkdev.dk_label->d_secsize;
741 vp = vnd->sc_vp;
742
743 #if defined(DEBUG)
744 if (vnddebug & VDB_IO)
745 printf("vnd (rdwr): vp %p, %s, rawblkno 0x%" PRIx64
746 ", secsize %d, offset %" PRIu64
747 ", bcount %d\n",
748 vp, doread ? "read" : "write", obp->b_rawblkno,
749 vnd->sc_dkdev.dk_label->d_secsize, offset,
750 bp->b_bcount);
751 #endif
752
753 /* Issue the read or write operation. */
754 bp->b_error =
755 vn_rdwr(doread ? UIO_READ : UIO_WRITE,
756 vp, bp->b_data, bp->b_bcount, offset,
757 UIO_SYSSPACE, 0, vnd->sc_cred, &resid, NULL);
758 bp->b_resid = resid;
759
760 /* We need to increase the number of outputs on the vnode if
761 * there was any write to it. */
762 if (!doread) {
763 mutex_enter(&vp->v_interlock);
764 vp->v_numoutput++;
765 mutex_exit(&vp->v_interlock);
766 }
767
768 biodone(bp);
769 }
770
771 /*
772 * Handes the read/write request given in 'bp' using the vnode's VOP_BMAP
773 * and VOP_STRATEGY operations.
774 *
775 * 'obp' is a pointer to the original request fed to the vnd device.
776 */
777 static void
778 handle_with_strategy(struct vnd_softc *vnd, const struct buf *obp,
779 struct buf *bp)
780 {
781 int bsize, error, flags, skipped;
782 size_t resid, sz;
783 off_t bn, offset;
784 struct vnode *vp;
785
786 flags = obp->b_flags;
787
788 if (!(flags & B_READ)) {
789 vp = bp->b_vp;
790 mutex_enter(&vp->v_interlock);
791 vp->v_numoutput++;
792 mutex_exit(&vp->v_interlock);
793 }
794
795 /* convert to a byte offset within the file. */
796 bn = obp->b_rawblkno * vnd->sc_dkdev.dk_label->d_secsize;
797
798 bsize = vnd->sc_vp->v_mount->mnt_stat.f_iosize;
799 skipped = 0;
800
801 /*
802 * Break the request into bsize pieces and feed them
803 * sequentially using VOP_BMAP/VOP_STRATEGY.
804 * We do it this way to keep from flooding NFS servers if we
805 * are connected to an NFS file. This places the burden on
806 * the client rather than the server.
807 */
808 error = 0;
809 bp->b_resid = bp->b_bcount;
810 for (offset = 0, resid = bp->b_resid; resid;
811 resid -= sz, offset += sz) {
812 struct buf *nbp;
813 daddr_t nbn;
814 int off, nra;
815
816 nra = 0;
817 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY);
818 error = VOP_BMAP(vnd->sc_vp, bn / bsize, &vp, &nbn, &nra);
819 VOP_UNLOCK(vnd->sc_vp, 0);
820
821 if (error == 0 && (long)nbn == -1)
822 error = EIO;
823
824 /*
825 * If there was an error or a hole in the file...punt.
826 * Note that we may have to wait for any operations
827 * that we have already fired off before releasing
828 * the buffer.
829 *
830 * XXX we could deal with holes here but it would be
831 * a hassle (in the write case).
832 */
833 if (error) {
834 skipped += resid;
835 break;
836 }
837
838 #ifdef DEBUG
839 if (!dovndcluster)
840 nra = 0;
841 #endif
842
843 off = bn % bsize;
844 sz = MIN(((off_t)1 + nra) * bsize - off, resid);
845 #ifdef DEBUG
846 if (vnddebug & VDB_IO)
847 printf("vndstrategy: vp %p/%p bn 0x%qx/0x%" PRIx64
848 " sz 0x%zx\n", vnd->sc_vp, vp, (long long)bn,
849 nbn, sz);
850 #endif
851
852 nbp = getiobuf(vp, true);
853 nestiobuf_setup(bp, nbp, offset, sz);
854 nbp->b_blkno = nbn + btodb(off);
855
856 #if 0 /* XXX #ifdef DEBUG */
857 if (vnddebug & VDB_IO)
858 printf("vndstart(%ld): bp %p vp %p blkno "
859 "0x%" PRIx64 " flags %x addr %p cnt 0x%x\n",
860 (long) (vnd-vnd_softc), &nbp->vb_buf,
861 nbp->vb_buf.b_vp, nbp->vb_buf.b_blkno,
862 nbp->vb_buf.b_flags, nbp->vb_buf.b_data,
863 nbp->vb_buf.b_bcount);
864 #endif
865 VOP_STRATEGY(vp, nbp);
866 bn += sz;
867 }
868 nestiobuf_done(bp, skipped, error);
869 }
870
871 static void
872 vndiodone(struct buf *bp)
873 {
874 struct vndxfer *vnx = VND_BUFTOXFER(bp);
875 struct vnd_softc *vnd = vnx->vx_vnd;
876 struct buf *obp = bp->b_private;
877
878 KASSERT(&vnx->vx_buf == bp);
879 KASSERT(vnd->sc_active > 0);
880 #ifdef DEBUG
881 if (vnddebug & VDB_IO) {
882 printf("vndiodone1: bp %p iodone: error %d\n",
883 bp, bp->b_error);
884 }
885 #endif
886 disk_unbusy(&vnd->sc_dkdev, bp->b_bcount - bp->b_resid,
887 (bp->b_flags & B_READ));
888 vnd->sc_active--;
889 if (vnd->sc_active == 0) {
890 wakeup(&vnd->sc_tab);
891 }
892 obp->b_error = bp->b_error;
893 obp->b_resid = bp->b_resid;
894 buf_destroy(bp);
895 VND_PUTXFER(vnd, vnx);
896 biodone(obp);
897 }
898
899 /* ARGSUSED */
900 static int
901 vndread(dev_t dev, struct uio *uio, int flags)
902 {
903 int unit = vndunit(dev);
904 struct vnd_softc *sc;
905
906 #ifdef DEBUG
907 if (vnddebug & VDB_FOLLOW)
908 printf("vndread(0x%"PRIx64", %p)\n", dev, uio);
909 #endif
910
911 sc = device_lookup_private(&vnd_cd, unit);
912 if (sc == NULL)
913 return ENXIO;
914
915 if ((sc->sc_flags & VNF_INITED) == 0)
916 return ENXIO;
917
918 return physio(vndstrategy, NULL, dev, B_READ, minphys, uio);
919 }
920
921 /* ARGSUSED */
922 static int
923 vndwrite(dev_t dev, struct uio *uio, int flags)
924 {
925 int unit = vndunit(dev);
926 struct vnd_softc *sc;
927
928 #ifdef DEBUG
929 if (vnddebug & VDB_FOLLOW)
930 printf("vndwrite(0x%"PRIx64", %p)\n", dev, uio);
931 #endif
932
933 sc = device_lookup_private(&vnd_cd, unit);
934 if (sc == NULL)
935 return ENXIO;
936
937 if ((sc->sc_flags & VNF_INITED) == 0)
938 return ENXIO;
939
940 return physio(vndstrategy, NULL, dev, B_WRITE, minphys, uio);
941 }
942
943 static int
944 vnd_cget(struct lwp *l, int unit, int *un, struct vattr *va)
945 {
946 struct vnd_softc *vnd;
947
948 if (*un == -1)
949 *un = unit;
950 if (*un < 0)
951 return EINVAL;
952
953 vnd = device_lookup_private(&vnd_cd, *un);
954 if (vnd == NULL)
955 return (*un >= vnd_cd.cd_ndevs) ? ENXIO : -1;
956
957 if ((vnd->sc_flags & VNF_INITED) == 0)
958 return -1;
959
960 return VOP_GETATTR(vnd->sc_vp, va, l->l_cred);
961 }
962
963 static int
964 vnddoclear(struct vnd_softc *vnd, int pmask, int minor, bool force)
965 {
966 int error;
967
968 if ((error = vndlock(vnd)) != 0)
969 return error;
970
971 /*
972 * Don't unconfigure if any other partitions are open
973 * or if both the character and block flavors of this
974 * partition are open.
975 */
976 if (DK_BUSY(vnd, pmask) && !force) {
977 vndunlock(vnd);
978 return EBUSY;
979 }
980
981 /*
982 * XXX vndclear() might call vndclose() implicitly;
983 * release lock to avoid recursion
984 *
985 * Set VNF_CLEARING to prevent vndopen() from
986 * sneaking in after we vndunlock().
987 */
988 vnd->sc_flags |= VNF_CLEARING;
989 vndunlock(vnd);
990 vndclear(vnd, minor);
991 #ifdef DEBUG
992 if (vnddebug & VDB_INIT)
993 printf("vndioctl: CLRed\n");
994 #endif
995
996 /* Destroy the xfer and buffer pools. */
997 pool_destroy(&vnd->sc_vxpool);
998
999 /* Detach the disk. */
1000 disk_detach(&vnd->sc_dkdev);
1001
1002 return 0;
1003 }
1004
1005 /* ARGSUSED */
1006 static int
1007 vndioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
1008 {
1009 bool force;
1010 int unit = vndunit(dev);
1011 struct vnd_softc *vnd;
1012 struct vnd_ioctl *vio;
1013 struct vattr vattr;
1014 struct nameidata nd;
1015 int error, part, pmask;
1016 size_t geomsize;
1017 int fflags;
1018 #ifdef __HAVE_OLD_DISKLABEL
1019 struct disklabel newlabel;
1020 #endif
1021
1022 #ifdef DEBUG
1023 if (vnddebug & VDB_FOLLOW)
1024 printf("vndioctl(0x%"PRIx64", 0x%lx, %p, 0x%x, %p): unit %d\n",
1025 dev, cmd, data, flag, l->l_proc, unit);
1026 #endif
1027 vnd = device_lookup_private(&vnd_cd, unit);
1028 if (vnd == NULL &&
1029 #ifdef COMPAT_30
1030 cmd != VNDIOOCGET &&
1031 #endif
1032 cmd != VNDIOCGET)
1033 return ENXIO;
1034 vio = (struct vnd_ioctl *)data;
1035
1036 /* Must be open for writes for these commands... */
1037 switch (cmd) {
1038 case VNDIOCSET:
1039 case VNDIOCCLR:
1040 #ifdef VNDIOOCSET
1041 case VNDIOOCSET:
1042 case VNDIOOCCLR:
1043 #endif
1044 case DIOCSDINFO:
1045 case DIOCWDINFO:
1046 #ifdef __HAVE_OLD_DISKLABEL
1047 case ODIOCSDINFO:
1048 case ODIOCWDINFO:
1049 #endif
1050 case DIOCKLABEL:
1051 case DIOCWLABEL:
1052 if ((flag & FWRITE) == 0)
1053 return EBADF;
1054 }
1055
1056 /* Must be initialized for these... */
1057 switch (cmd) {
1058 case VNDIOCCLR:
1059 #ifdef VNDIOOCCLR
1060 case VNDIOOCCLR:
1061 #endif
1062 case DIOCGDINFO:
1063 case DIOCSDINFO:
1064 case DIOCWDINFO:
1065 case DIOCGPART:
1066 case DIOCKLABEL:
1067 case DIOCWLABEL:
1068 case DIOCGDEFLABEL:
1069 case DIOCCACHESYNC:
1070 #ifdef __HAVE_OLD_DISKLABEL
1071 case ODIOCGDINFO:
1072 case ODIOCSDINFO:
1073 case ODIOCWDINFO:
1074 case ODIOCGDEFLABEL:
1075 #endif
1076 if ((vnd->sc_flags & VNF_INITED) == 0)
1077 return ENXIO;
1078 }
1079
1080 switch (cmd) {
1081 #ifdef VNDIOOCSET
1082 case VNDIOOCSET:
1083 #endif
1084 case VNDIOCSET:
1085 if (vnd->sc_flags & VNF_INITED)
1086 return EBUSY;
1087
1088 if ((error = vndlock(vnd)) != 0)
1089 return error;
1090
1091 fflags = FREAD;
1092 if ((vio->vnd_flags & VNDIOF_READONLY) == 0)
1093 fflags |= FWRITE;
1094 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, vio->vnd_file);
1095 if ((error = vn_open(&nd, fflags, 0)) != 0)
1096 goto unlock_and_exit;
1097 KASSERT(l);
1098 error = VOP_GETATTR(nd.ni_vp, &vattr, l->l_cred);
1099 if (!error && nd.ni_vp->v_type != VREG)
1100 error = EOPNOTSUPP;
1101 if (!error && vattr.va_bytes < vattr.va_size)
1102 /* File is definitely sparse, reject here */
1103 error = EINVAL;
1104 if (error) {
1105 VOP_UNLOCK(nd.ni_vp, 0);
1106 goto close_and_exit;
1107 }
1108
1109 /* If using a compressed file, initialize its info */
1110 /* (or abort with an error if kernel has no compression) */
1111 if (vio->vnd_flags & VNF_COMP) {
1112 #ifdef VND_COMPRESSION
1113 struct vnd_comp_header *ch;
1114 int i;
1115 u_int32_t comp_size;
1116 u_int32_t comp_maxsize;
1117
1118 /* allocate space for compresed file header */
1119 ch = malloc(sizeof(struct vnd_comp_header),
1120 M_TEMP, M_WAITOK);
1121
1122 /* read compressed file header */
1123 error = vn_rdwr(UIO_READ, nd.ni_vp, (void *)ch,
1124 sizeof(struct vnd_comp_header), 0, UIO_SYSSPACE,
1125 IO_UNIT|IO_NODELOCKED, l->l_cred, NULL, NULL);
1126 if (error) {
1127 free(ch, M_TEMP);
1128 VOP_UNLOCK(nd.ni_vp, 0);
1129 goto close_and_exit;
1130 }
1131
1132 /* save some header info */
1133 vnd->sc_comp_blksz = ntohl(ch->block_size);
1134 /* note last offset is the file byte size */
1135 vnd->sc_comp_numoffs = ntohl(ch->num_blocks)+1;
1136 free(ch, M_TEMP);
1137 if (vnd->sc_comp_blksz == 0 ||
1138 vnd->sc_comp_blksz % DEV_BSIZE !=0) {
1139 VOP_UNLOCK(nd.ni_vp, 0);
1140 error = EINVAL;
1141 goto close_and_exit;
1142 }
1143 if (sizeof(struct vnd_comp_header) +
1144 sizeof(u_int64_t) * vnd->sc_comp_numoffs >
1145 vattr.va_size) {
1146 VOP_UNLOCK(nd.ni_vp, 0);
1147 error = EINVAL;
1148 goto close_and_exit;
1149 }
1150
1151 /* set decompressed file size */
1152 vattr.va_size =
1153 ((u_quad_t)vnd->sc_comp_numoffs - 1) *
1154 (u_quad_t)vnd->sc_comp_blksz;
1155
1156 /* allocate space for all the compressed offsets */
1157 vnd->sc_comp_offsets =
1158 malloc(sizeof(u_int64_t) * vnd->sc_comp_numoffs,
1159 M_DEVBUF, M_WAITOK);
1160
1161 /* read in the offsets */
1162 error = vn_rdwr(UIO_READ, nd.ni_vp,
1163 (void *)vnd->sc_comp_offsets,
1164 sizeof(u_int64_t) * vnd->sc_comp_numoffs,
1165 sizeof(struct vnd_comp_header), UIO_SYSSPACE,
1166 IO_UNIT|IO_NODELOCKED, l->l_cred, NULL, NULL);
1167 if (error) {
1168 VOP_UNLOCK(nd.ni_vp, 0);
1169 goto close_and_exit;
1170 }
1171 /*
1172 * find largest block size (used for allocation limit).
1173 * Also convert offset to native byte order.
1174 */
1175 comp_maxsize = 0;
1176 for (i = 0; i < vnd->sc_comp_numoffs - 1; i++) {
1177 vnd->sc_comp_offsets[i] =
1178 be64toh(vnd->sc_comp_offsets[i]);
1179 comp_size = be64toh(vnd->sc_comp_offsets[i + 1])
1180 - vnd->sc_comp_offsets[i];
1181 if (comp_size > comp_maxsize)
1182 comp_maxsize = comp_size;
1183 }
1184 vnd->sc_comp_offsets[vnd->sc_comp_numoffs - 1] =
1185 be64toh(vnd->sc_comp_offsets[vnd->sc_comp_numoffs - 1]);
1186
1187 /* create compressed data buffer */
1188 vnd->sc_comp_buff = malloc(comp_maxsize,
1189 M_DEVBUF, M_WAITOK);
1190
1191 /* create decompressed buffer */
1192 vnd->sc_comp_decombuf = malloc(vnd->sc_comp_blksz,
1193 M_DEVBUF, M_WAITOK);
1194 vnd->sc_comp_buffblk = -1;
1195
1196 /* Initialize decompress stream */
1197 memset(&vnd->sc_comp_stream, 0, sizeof(z_stream));
1198 vnd->sc_comp_stream.zalloc = vnd_alloc;
1199 vnd->sc_comp_stream.zfree = vnd_free;
1200 error = inflateInit2(&vnd->sc_comp_stream, MAX_WBITS);
1201 if (error) {
1202 if (vnd->sc_comp_stream.msg)
1203 printf("vnd%d: compressed file, %s\n",
1204 unit, vnd->sc_comp_stream.msg);
1205 VOP_UNLOCK(nd.ni_vp, 0);
1206 error = EINVAL;
1207 goto close_and_exit;
1208 }
1209
1210 vnd->sc_flags |= VNF_COMP | VNF_READONLY;
1211 #else /* !VND_COMPRESSION */
1212 VOP_UNLOCK(nd.ni_vp, 0);
1213 error = EOPNOTSUPP;
1214 goto close_and_exit;
1215 #endif /* VND_COMPRESSION */
1216 }
1217
1218 VOP_UNLOCK(nd.ni_vp, 0);
1219 vnd->sc_vp = nd.ni_vp;
1220 vnd->sc_size = btodb(vattr.va_size); /* note truncation */
1221
1222 /*
1223 * Use pseudo-geometry specified. If none was provided,
1224 * use "standard" Adaptec fictitious geometry.
1225 */
1226 if (vio->vnd_flags & VNDIOF_HASGEOM) {
1227
1228 memcpy(&vnd->sc_geom, &vio->vnd_geom,
1229 sizeof(vio->vnd_geom));
1230
1231 /*
1232 * Sanity-check the sector size.
1233 * XXX Don't allow secsize < DEV_BSIZE. Should
1234 * XXX we?
1235 */
1236 if (vnd->sc_geom.vng_secsize < DEV_BSIZE ||
1237 (vnd->sc_geom.vng_secsize % DEV_BSIZE) != 0 ||
1238 vnd->sc_geom.vng_ncylinders == 0 ||
1239 (vnd->sc_geom.vng_ntracks *
1240 vnd->sc_geom.vng_nsectors) == 0) {
1241 error = EINVAL;
1242 goto close_and_exit;
1243 }
1244
1245 /*
1246 * Compute the size (in DEV_BSIZE blocks) specified
1247 * by the geometry.
1248 */
1249 geomsize = (vnd->sc_geom.vng_nsectors *
1250 vnd->sc_geom.vng_ntracks *
1251 vnd->sc_geom.vng_ncylinders) *
1252 (vnd->sc_geom.vng_secsize / DEV_BSIZE);
1253
1254 /*
1255 * Sanity-check the size against the specified
1256 * geometry.
1257 */
1258 if (vnd->sc_size < geomsize) {
1259 error = EINVAL;
1260 goto close_and_exit;
1261 }
1262 } else if (vnd->sc_size >= (32 * 64)) {
1263 /*
1264 * Size must be at least 2048 DEV_BSIZE blocks
1265 * (1M) in order to use this geometry.
1266 */
1267 vnd->sc_geom.vng_secsize = DEV_BSIZE;
1268 vnd->sc_geom.vng_nsectors = 32;
1269 vnd->sc_geom.vng_ntracks = 64;
1270 vnd->sc_geom.vng_ncylinders = vnd->sc_size / (64 * 32);
1271 } else {
1272 vnd->sc_geom.vng_secsize = DEV_BSIZE;
1273 vnd->sc_geom.vng_nsectors = 1;
1274 vnd->sc_geom.vng_ntracks = 1;
1275 vnd->sc_geom.vng_ncylinders = vnd->sc_size;
1276 }
1277
1278 vnd_set_properties(vnd);
1279
1280 if (vio->vnd_flags & VNDIOF_READONLY) {
1281 vnd->sc_flags |= VNF_READONLY;
1282 }
1283
1284 if ((error = vndsetcred(vnd, l->l_cred)) != 0)
1285 goto close_and_exit;
1286
1287 vndthrottle(vnd, vnd->sc_vp);
1288 vio->vnd_osize = dbtob(vnd->sc_size);
1289 #ifdef VNDIOOCSET
1290 if (cmd != VNDIOOCSET)
1291 #endif
1292 vio->vnd_size = dbtob(vnd->sc_size);
1293 vnd->sc_flags |= VNF_INITED;
1294
1295 /* create the kernel thread, wait for it to be up */
1296 error = kthread_create(PRI_NONE, 0, NULL, vndthread, vnd,
1297 &vnd->sc_kthread, device_xname(vnd->sc_dev));
1298 if (error)
1299 goto close_and_exit;
1300 while ((vnd->sc_flags & VNF_KTHREAD) == 0) {
1301 tsleep(&vnd->sc_kthread, PRIBIO, "vndthr", 0);
1302 }
1303 #ifdef DEBUG
1304 if (vnddebug & VDB_INIT)
1305 printf("vndioctl: SET vp %p size 0x%lx %d/%d/%d/%d\n",
1306 vnd->sc_vp, (unsigned long) vnd->sc_size,
1307 vnd->sc_geom.vng_secsize,
1308 vnd->sc_geom.vng_nsectors,
1309 vnd->sc_geom.vng_ntracks,
1310 vnd->sc_geom.vng_ncylinders);
1311 #endif
1312
1313 /* Attach the disk. */
1314 disk_attach(&vnd->sc_dkdev);
1315
1316 /* Initialize the xfer and buffer pools. */
1317 pool_init(&vnd->sc_vxpool, sizeof(struct vndxfer), 0,
1318 0, 0, "vndxpl", NULL, IPL_BIO);
1319
1320 /* Try and read the disklabel. */
1321 vndgetdisklabel(dev, vnd);
1322
1323 vndunlock(vnd);
1324
1325 break;
1326
1327 close_and_exit:
1328 (void) vn_close(nd.ni_vp, fflags, l->l_cred);
1329 unlock_and_exit:
1330 #ifdef VND_COMPRESSION
1331 /* free any allocated memory (for compressed file) */
1332 if (vnd->sc_comp_offsets) {
1333 free(vnd->sc_comp_offsets, M_DEVBUF);
1334 vnd->sc_comp_offsets = NULL;
1335 }
1336 if (vnd->sc_comp_buff) {
1337 free(vnd->sc_comp_buff, M_DEVBUF);
1338 vnd->sc_comp_buff = NULL;
1339 }
1340 if (vnd->sc_comp_decombuf) {
1341 free(vnd->sc_comp_decombuf, M_DEVBUF);
1342 vnd->sc_comp_decombuf = NULL;
1343 }
1344 #endif /* VND_COMPRESSION */
1345 vndunlock(vnd);
1346 return error;
1347
1348 #ifdef VNDIOOCCLR
1349 case VNDIOOCCLR:
1350 #endif
1351 case VNDIOCCLR:
1352 part = DISKPART(dev);
1353 pmask = (1 << part);
1354 force = (vio->vnd_flags & VNDIOF_FORCE) != 0;
1355
1356 if ((error = vnddoclear(vnd, pmask, minor(dev), force)) != 0)
1357 return error;
1358
1359 break;
1360
1361 #ifdef COMPAT_30
1362 case VNDIOOCGET: {
1363 struct vnd_ouser *vnu;
1364 struct vattr va;
1365 vnu = (struct vnd_ouser *)data;
1366 KASSERT(l);
1367 switch (error = vnd_cget(l, unit, &vnu->vnu_unit, &va)) {
1368 case 0:
1369 vnu->vnu_dev = va.va_fsid;
1370 vnu->vnu_ino = va.va_fileid;
1371 break;
1372 case -1:
1373 /* unused is not an error */
1374 vnu->vnu_dev = 0;
1375 vnu->vnu_ino = 0;
1376 break;
1377 default:
1378 return error;
1379 }
1380 break;
1381 }
1382 #endif
1383 case VNDIOCGET: {
1384 struct vnd_user *vnu;
1385 struct vattr va;
1386 vnu = (struct vnd_user *)data;
1387 KASSERT(l);
1388 switch (error = vnd_cget(l, unit, &vnu->vnu_unit, &va)) {
1389 case 0:
1390 vnu->vnu_dev = va.va_fsid;
1391 vnu->vnu_ino = va.va_fileid;
1392 break;
1393 case -1:
1394 /* unused is not an error */
1395 vnu->vnu_dev = 0;
1396 vnu->vnu_ino = 0;
1397 break;
1398 default:
1399 return error;
1400 }
1401 break;
1402 }
1403
1404 case DIOCGDINFO:
1405 *(struct disklabel *)data = *(vnd->sc_dkdev.dk_label);
1406 break;
1407
1408 #ifdef __HAVE_OLD_DISKLABEL
1409 case ODIOCGDINFO:
1410 newlabel = *(vnd->sc_dkdev.dk_label);
1411 if (newlabel.d_npartitions > OLDMAXPARTITIONS)
1412 return ENOTTY;
1413 memcpy(data, &newlabel, sizeof (struct olddisklabel));
1414 break;
1415 #endif
1416
1417 case DIOCGPART:
1418 ((struct partinfo *)data)->disklab = vnd->sc_dkdev.dk_label;
1419 ((struct partinfo *)data)->part =
1420 &vnd->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
1421 break;
1422
1423 case DIOCWDINFO:
1424 case DIOCSDINFO:
1425 #ifdef __HAVE_OLD_DISKLABEL
1426 case ODIOCWDINFO:
1427 case ODIOCSDINFO:
1428 #endif
1429 {
1430 struct disklabel *lp;
1431
1432 if ((error = vndlock(vnd)) != 0)
1433 return error;
1434
1435 vnd->sc_flags |= VNF_LABELLING;
1436
1437 #ifdef __HAVE_OLD_DISKLABEL
1438 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) {
1439 memset(&newlabel, 0, sizeof newlabel);
1440 memcpy(&newlabel, data, sizeof (struct olddisklabel));
1441 lp = &newlabel;
1442 } else
1443 #endif
1444 lp = (struct disklabel *)data;
1445
1446 error = setdisklabel(vnd->sc_dkdev.dk_label,
1447 lp, 0, vnd->sc_dkdev.dk_cpulabel);
1448 if (error == 0) {
1449 if (cmd == DIOCWDINFO
1450 #ifdef __HAVE_OLD_DISKLABEL
1451 || cmd == ODIOCWDINFO
1452 #endif
1453 )
1454 error = writedisklabel(VNDLABELDEV(dev),
1455 vndstrategy, vnd->sc_dkdev.dk_label,
1456 vnd->sc_dkdev.dk_cpulabel);
1457 }
1458
1459 vnd->sc_flags &= ~VNF_LABELLING;
1460
1461 vndunlock(vnd);
1462
1463 if (error)
1464 return error;
1465 break;
1466 }
1467
1468 case DIOCKLABEL:
1469 if (*(int *)data != 0)
1470 vnd->sc_flags |= VNF_KLABEL;
1471 else
1472 vnd->sc_flags &= ~VNF_KLABEL;
1473 break;
1474
1475 case DIOCWLABEL:
1476 if (*(int *)data != 0)
1477 vnd->sc_flags |= VNF_WLABEL;
1478 else
1479 vnd->sc_flags &= ~VNF_WLABEL;
1480 break;
1481
1482 case DIOCGDEFLABEL:
1483 vndgetdefaultlabel(vnd, (struct disklabel *)data);
1484 break;
1485
1486 #ifdef __HAVE_OLD_DISKLABEL
1487 case ODIOCGDEFLABEL:
1488 vndgetdefaultlabel(vnd, &newlabel);
1489 if (newlabel.d_npartitions > OLDMAXPARTITIONS)
1490 return ENOTTY;
1491 memcpy(data, &newlabel, sizeof (struct olddisklabel));
1492 break;
1493 #endif
1494
1495 case DIOCCACHESYNC:
1496 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY);
1497 error = VOP_FSYNC(vnd->sc_vp, vnd->sc_cred,
1498 FSYNC_WAIT | FSYNC_DATAONLY | FSYNC_CACHE, 0, 0);
1499 VOP_UNLOCK(vnd->sc_vp, 0);
1500 return error;
1501
1502 default:
1503 return ENOTTY;
1504 }
1505
1506 return 0;
1507 }
1508
1509 /*
1510 * Duplicate the current processes' credentials. Since we are called only
1511 * as the result of a SET ioctl and only root can do that, any future access
1512 * to this "disk" is essentially as root. Note that credentials may change
1513 * if some other uid can write directly to the mapped file (NFS).
1514 */
1515 static int
1516 vndsetcred(struct vnd_softc *vnd, kauth_cred_t cred)
1517 {
1518 struct uio auio;
1519 struct iovec aiov;
1520 char *tmpbuf;
1521 int error;
1522
1523 vnd->sc_cred = kauth_cred_dup(cred);
1524 tmpbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK);
1525
1526 /* XXX: Horrible kludge to establish credentials for NFS */
1527 aiov.iov_base = tmpbuf;
1528 aiov.iov_len = min(DEV_BSIZE, dbtob(vnd->sc_size));
1529 auio.uio_iov = &aiov;
1530 auio.uio_iovcnt = 1;
1531 auio.uio_offset = 0;
1532 auio.uio_rw = UIO_READ;
1533 auio.uio_resid = aiov.iov_len;
1534 UIO_SETUP_SYSSPACE(&auio);
1535 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY);
1536 error = VOP_READ(vnd->sc_vp, &auio, 0, vnd->sc_cred);
1537 if (error == 0) {
1538 /*
1539 * Because vnd does all IO directly through the vnode
1540 * we need to flush (at least) the buffer from the above
1541 * VOP_READ from the buffer cache to prevent cache
1542 * incoherencies. Also, be careful to write dirty
1543 * buffers back to stable storage.
1544 */
1545 error = vinvalbuf(vnd->sc_vp, V_SAVE, vnd->sc_cred,
1546 curlwp, 0, 0);
1547 }
1548 VOP_UNLOCK(vnd->sc_vp, 0);
1549
1550 free(tmpbuf, M_TEMP);
1551 return error;
1552 }
1553
1554 /*
1555 * Set maxactive based on FS type
1556 */
1557 static void
1558 vndthrottle(struct vnd_softc *vnd, struct vnode *vp)
1559 {
1560 #ifdef NFS
1561 extern int (**nfsv2_vnodeop_p)(void *);
1562
1563 if (vp->v_op == nfsv2_vnodeop_p)
1564 vnd->sc_maxactive = 2;
1565 else
1566 #endif
1567 vnd->sc_maxactive = 8;
1568
1569 if (vnd->sc_maxactive < 1)
1570 vnd->sc_maxactive = 1;
1571 }
1572
1573 #if 0
1574 static void
1575 vndshutdown(void)
1576 {
1577 struct vnd_softc *vnd;
1578
1579 for (vnd = &vnd_softc[0]; vnd < &vnd_softc[numvnd]; vnd++)
1580 if (vnd->sc_flags & VNF_INITED)
1581 vndclear(vnd);
1582 }
1583 #endif
1584
1585 static void
1586 vndclear(struct vnd_softc *vnd, int myminor)
1587 {
1588 struct vnode *vp = vnd->sc_vp;
1589 int fflags = FREAD;
1590 int bmaj, cmaj, i, mn;
1591 int s;
1592
1593 #ifdef DEBUG
1594 if (vnddebug & VDB_FOLLOW)
1595 printf("vndclear(%p): vp %p\n", vnd, vp);
1596 #endif
1597 /* locate the major number */
1598 bmaj = bdevsw_lookup_major(&vnd_bdevsw);
1599 cmaj = cdevsw_lookup_major(&vnd_cdevsw);
1600
1601 /* Nuke the vnodes for any open instances */
1602 for (i = 0; i < MAXPARTITIONS; i++) {
1603 mn = DISKMINOR(device_unit(vnd->sc_dev), i);
1604 vdevgone(bmaj, mn, mn, VBLK);
1605 if (mn != myminor) /* XXX avoid to kill own vnode */
1606 vdevgone(cmaj, mn, mn, VCHR);
1607 }
1608
1609 if ((vnd->sc_flags & VNF_READONLY) == 0)
1610 fflags |= FWRITE;
1611
1612 s = splbio();
1613 bufq_drain(vnd->sc_tab);
1614 splx(s);
1615
1616 vnd->sc_flags |= VNF_VUNCONF;
1617 wakeup(&vnd->sc_tab);
1618 while (vnd->sc_flags & VNF_KTHREAD)
1619 tsleep(&vnd->sc_kthread, PRIBIO, "vnthr", 0);
1620
1621 #ifdef VND_COMPRESSION
1622 /* free the compressed file buffers */
1623 if (vnd->sc_flags & VNF_COMP) {
1624 if (vnd->sc_comp_offsets) {
1625 free(vnd->sc_comp_offsets, M_DEVBUF);
1626 vnd->sc_comp_offsets = NULL;
1627 }
1628 if (vnd->sc_comp_buff) {
1629 free(vnd->sc_comp_buff, M_DEVBUF);
1630 vnd->sc_comp_buff = NULL;
1631 }
1632 if (vnd->sc_comp_decombuf) {
1633 free(vnd->sc_comp_decombuf, M_DEVBUF);
1634 vnd->sc_comp_decombuf = NULL;
1635 }
1636 }
1637 #endif /* VND_COMPRESSION */
1638 vnd->sc_flags &=
1639 ~(VNF_INITED | VNF_READONLY | VNF_VLABEL
1640 | VNF_VUNCONF | VNF_COMP | VNF_CLEARING);
1641 if (vp == NULL)
1642 panic("vndclear: null vp");
1643 (void) vn_close(vp, fflags, vnd->sc_cred);
1644 kauth_cred_free(vnd->sc_cred);
1645 vnd->sc_vp = NULL;
1646 vnd->sc_cred = NULL;
1647 vnd->sc_size = 0;
1648 }
1649
1650 static int
1651 vndsize(dev_t dev)
1652 {
1653 struct vnd_softc *sc;
1654 struct disklabel *lp;
1655 int part, unit, omask;
1656 int size;
1657
1658 unit = vndunit(dev);
1659 sc = device_lookup_private(&vnd_cd, unit);
1660 if (sc == NULL)
1661 return -1;
1662
1663 if ((sc->sc_flags & VNF_INITED) == 0)
1664 return -1;
1665
1666 part = DISKPART(dev);
1667 omask = sc->sc_dkdev.dk_openmask & (1 << part);
1668 lp = sc->sc_dkdev.dk_label;
1669
1670 if (omask == 0 && vndopen(dev, 0, S_IFBLK, curlwp)) /* XXX */
1671 return -1;
1672
1673 if (lp->d_partitions[part].p_fstype != FS_SWAP)
1674 size = -1;
1675 else
1676 size = lp->d_partitions[part].p_size *
1677 (lp->d_secsize / DEV_BSIZE);
1678
1679 if (omask == 0 && vndclose(dev, 0, S_IFBLK, curlwp)) /* XXX */
1680 return -1;
1681
1682 return size;
1683 }
1684
1685 static int
1686 vnddump(dev_t dev, daddr_t blkno, void *va,
1687 size_t size)
1688 {
1689
1690 /* Not implemented. */
1691 return ENXIO;
1692 }
1693
1694 static void
1695 vndgetdefaultlabel(struct vnd_softc *sc, struct disklabel *lp)
1696 {
1697 struct vndgeom *vng = &sc->sc_geom;
1698 struct partition *pp;
1699
1700 memset(lp, 0, sizeof(*lp));
1701
1702 lp->d_secperunit = sc->sc_size / (vng->vng_secsize / DEV_BSIZE);
1703 lp->d_secsize = vng->vng_secsize;
1704 lp->d_nsectors = vng->vng_nsectors;
1705 lp->d_ntracks = vng->vng_ntracks;
1706 lp->d_ncylinders = vng->vng_ncylinders;
1707 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
1708
1709 strncpy(lp->d_typename, "vnd", sizeof(lp->d_typename));
1710 lp->d_type = DTYPE_VND;
1711 strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
1712 lp->d_rpm = 3600;
1713 lp->d_interleave = 1;
1714 lp->d_flags = 0;
1715
1716 pp = &lp->d_partitions[RAW_PART];
1717 pp->p_offset = 0;
1718 pp->p_size = lp->d_secperunit;
1719 pp->p_fstype = FS_UNUSED;
1720 lp->d_npartitions = RAW_PART + 1;
1721
1722 lp->d_magic = DISKMAGIC;
1723 lp->d_magic2 = DISKMAGIC;
1724 lp->d_checksum = dkcksum(lp);
1725 }
1726
1727 /*
1728 * Read the disklabel from a vnd. If one is not present, create a fake one.
1729 */
1730 static void
1731 vndgetdisklabel(dev_t dev, struct vnd_softc *sc)
1732 {
1733 const char *errstring;
1734 struct disklabel *lp = sc->sc_dkdev.dk_label;
1735 struct cpu_disklabel *clp = sc->sc_dkdev.dk_cpulabel;
1736 int i;
1737
1738 memset(clp, 0, sizeof(*clp));
1739
1740 vndgetdefaultlabel(sc, lp);
1741
1742 /*
1743 * Call the generic disklabel extraction routine.
1744 */
1745 errstring = readdisklabel(VNDLABELDEV(dev), vndstrategy, lp, clp);
1746 if (errstring) {
1747 /*
1748 * Lack of disklabel is common, but we print the warning
1749 * anyway, since it might contain other useful information.
1750 */
1751 aprint_normal_dev(sc->sc_dev, "%s\n", errstring);
1752
1753 /*
1754 * For historical reasons, if there's no disklabel
1755 * present, all partitions must be FS_BSDFFS and
1756 * occupy the entire disk.
1757 */
1758 for (i = 0; i < MAXPARTITIONS; i++) {
1759 /*
1760 * Don't wipe out port specific hack (such as
1761 * dos partition hack of i386 port).
1762 */
1763 if (lp->d_partitions[i].p_size != 0)
1764 continue;
1765
1766 lp->d_partitions[i].p_size = lp->d_secperunit;
1767 lp->d_partitions[i].p_offset = 0;
1768 lp->d_partitions[i].p_fstype = FS_BSDFFS;
1769 }
1770
1771 strncpy(lp->d_packname, "default label",
1772 sizeof(lp->d_packname));
1773
1774 lp->d_npartitions = MAXPARTITIONS;
1775 lp->d_checksum = dkcksum(lp);
1776 }
1777
1778 /* In-core label now valid. */
1779 sc->sc_flags |= VNF_VLABEL;
1780 }
1781
1782 /*
1783 * Wait interruptibly for an exclusive lock.
1784 *
1785 * XXX
1786 * Several drivers do this; it should be abstracted and made MP-safe.
1787 */
1788 static int
1789 vndlock(struct vnd_softc *sc)
1790 {
1791 int error;
1792
1793 while ((sc->sc_flags & VNF_LOCKED) != 0) {
1794 sc->sc_flags |= VNF_WANTED;
1795 if ((error = tsleep(sc, PRIBIO | PCATCH, "vndlck", 0)) != 0)
1796 return error;
1797 }
1798 sc->sc_flags |= VNF_LOCKED;
1799 return 0;
1800 }
1801
1802 /*
1803 * Unlock and wake up any waiters.
1804 */
1805 static void
1806 vndunlock(struct vnd_softc *sc)
1807 {
1808
1809 sc->sc_flags &= ~VNF_LOCKED;
1810 if ((sc->sc_flags & VNF_WANTED) != 0) {
1811 sc->sc_flags &= ~VNF_WANTED;
1812 wakeup(sc);
1813 }
1814 }
1815
1816 #ifdef VND_COMPRESSION
1817 /* compressed file read */
1818 static void
1819 compstrategy(struct buf *bp, off_t bn)
1820 {
1821 int error;
1822 int unit = vndunit(bp->b_dev);
1823 struct vnd_softc *vnd =
1824 device_lookup_private(&vnd_cd, unit);
1825 u_int32_t comp_block;
1826 struct uio auio;
1827 char *addr;
1828 int s;
1829
1830 /* set up constants for data move */
1831 auio.uio_rw = UIO_READ;
1832 UIO_SETUP_SYSSPACE(&auio);
1833
1834 /* read, and transfer the data */
1835 addr = bp->b_data;
1836 bp->b_resid = bp->b_bcount;
1837 s = splbio();
1838 while (bp->b_resid > 0) {
1839 unsigned length;
1840 size_t length_in_buffer;
1841 u_int32_t offset_in_buffer;
1842 struct iovec aiov;
1843
1844 /* calculate the compressed block number */
1845 comp_block = bn / (off_t)vnd->sc_comp_blksz;
1846
1847 /* check for good block number */
1848 if (comp_block >= vnd->sc_comp_numoffs) {
1849 bp->b_error = EINVAL;
1850 splx(s);
1851 return;
1852 }
1853
1854 /* read in the compressed block, if not in buffer */
1855 if (comp_block != vnd->sc_comp_buffblk) {
1856 length = vnd->sc_comp_offsets[comp_block + 1] -
1857 vnd->sc_comp_offsets[comp_block];
1858 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY);
1859 error = vn_rdwr(UIO_READ, vnd->sc_vp, vnd->sc_comp_buff,
1860 length, vnd->sc_comp_offsets[comp_block],
1861 UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, vnd->sc_cred,
1862 NULL, NULL);
1863 if (error) {
1864 bp->b_error = error;
1865 VOP_UNLOCK(vnd->sc_vp, 0);
1866 splx(s);
1867 return;
1868 }
1869 /* uncompress the buffer */
1870 vnd->sc_comp_stream.next_in = vnd->sc_comp_buff;
1871 vnd->sc_comp_stream.avail_in = length;
1872 vnd->sc_comp_stream.next_out = vnd->sc_comp_decombuf;
1873 vnd->sc_comp_stream.avail_out = vnd->sc_comp_blksz;
1874 inflateReset(&vnd->sc_comp_stream);
1875 error = inflate(&vnd->sc_comp_stream, Z_FINISH);
1876 if (error != Z_STREAM_END) {
1877 if (vnd->sc_comp_stream.msg)
1878 aprint_normal_dev(vnd->sc_dev,
1879 "compressed file, %s\n",
1880 vnd->sc_comp_stream.msg);
1881 bp->b_error = EBADMSG;
1882 VOP_UNLOCK(vnd->sc_vp, 0);
1883 splx(s);
1884 return;
1885 }
1886 vnd->sc_comp_buffblk = comp_block;
1887 VOP_UNLOCK(vnd->sc_vp, 0);
1888 }
1889
1890 /* transfer the usable uncompressed data */
1891 offset_in_buffer = bn % (off_t)vnd->sc_comp_blksz;
1892 length_in_buffer = vnd->sc_comp_blksz - offset_in_buffer;
1893 if (length_in_buffer > bp->b_resid)
1894 length_in_buffer = bp->b_resid;
1895 auio.uio_iov = &aiov;
1896 auio.uio_iovcnt = 1;
1897 aiov.iov_base = addr;
1898 aiov.iov_len = length_in_buffer;
1899 auio.uio_resid = aiov.iov_len;
1900 auio.uio_offset = 0;
1901 error = uiomove(vnd->sc_comp_decombuf + offset_in_buffer,
1902 length_in_buffer, &auio);
1903 if (error) {
1904 bp->b_error = error;
1905 splx(s);
1906 return;
1907 }
1908
1909 bn += length_in_buffer;
1910 addr += length_in_buffer;
1911 bp->b_resid -= length_in_buffer;
1912 }
1913 splx(s);
1914 }
1915
1916 /* compression memory allocation routines */
1917 static void *
1918 vnd_alloc(void *aux, u_int items, u_int siz)
1919 {
1920 return malloc(items * siz, M_TEMP, M_NOWAIT);
1921 }
1922
1923 static void
1924 vnd_free(void *aux, void *ptr)
1925 {
1926 free(ptr, M_TEMP);
1927 }
1928 #endif /* VND_COMPRESSION */
1929
1930 static void
1931 vnd_set_properties(struct vnd_softc *vnd)
1932 {
1933 prop_dictionary_t disk_info, odisk_info, geom;
1934
1935 disk_info = prop_dictionary_create();
1936
1937 geom = prop_dictionary_create();
1938
1939 prop_dictionary_set_uint64(geom, "sectors-per-unit",
1940 vnd->sc_geom.vng_nsectors * vnd->sc_geom.vng_ntracks *
1941 vnd->sc_geom.vng_ncylinders);
1942
1943 prop_dictionary_set_uint32(geom, "sector-size",
1944 vnd->sc_geom.vng_secsize);
1945
1946 prop_dictionary_set_uint16(geom, "sectors-per-track",
1947 vnd->sc_geom.vng_nsectors);
1948
1949 prop_dictionary_set_uint16(geom, "tracks-per-cylinder",
1950 vnd->sc_geom.vng_ntracks);
1951
1952 prop_dictionary_set_uint64(geom, "cylinders-per-unit",
1953 vnd->sc_geom.vng_ncylinders);
1954
1955 prop_dictionary_set(disk_info, "geometry", geom);
1956 prop_object_release(geom);
1957
1958 prop_dictionary_set(device_properties(vnd->sc_dev),
1959 "disk-info", disk_info);
1960
1961 /*
1962 * Don't release disk_info here; we keep a reference to it.
1963 * disk_detach() will release it when we go away.
1964 */
1965
1966 odisk_info = vnd->sc_dkdev.dk_info;
1967 vnd->sc_dkdev.dk_info = disk_info;
1968 if (odisk_info)
1969 prop_object_release(odisk_info);
1970 }
1971
1972 #ifdef _MODULE
1973
1974 #include <sys/module.h>
1975
1976 MODULE(MODULE_CLASS_DRIVER, vnd, NULL);
1977 CFDRIVER_DECL(vnd, DV_DISK, NULL);
1978
1979 static int
1980 vnd_modcmd(modcmd_t cmd, void *arg)
1981 {
1982 int bmajor = -1, cmajor = -1, error = 0;
1983
1984 switch (cmd) {
1985 case MODULE_CMD_INIT:
1986 error = config_cfdriver_attach(&vnd_cd);
1987 if (error)
1988 break;
1989
1990 error = config_cfattach_attach(vnd_cd.cd_name, &vnd_ca);
1991 if (error) {
1992 config_cfdriver_detach(&vnd_cd);
1993 aprint_error("%s: unable to register cfattach\n",
1994 vnd_cd.cd_name);
1995 break;
1996 }
1997
1998 error = devsw_attach("vnd", &vnd_bdevsw, &bmajor,
1999 &vnd_cdevsw, &cmajor);
2000 if (error) {
2001 config_cfattach_detach(vnd_cd.cd_name, &vnd_ca);
2002 config_cfdriver_detach(&vnd_cd);
2003 break;
2004 }
2005
2006 break;
2007
2008 case MODULE_CMD_FINI:
2009 error = config_cfattach_detach(vnd_cd.cd_name, &vnd_ca);
2010 if (error)
2011 break;
2012 config_cfdriver_detach(&vnd_cd);
2013 devsw_detach(&vnd_bdevsw, &vnd_cdevsw);
2014 break;
2015
2016 case MODULE_CMD_STAT:
2017 return ENOTTY;
2018
2019 default:
2020 return ENOTTY;
2021 }
2022
2023 return error;
2024 }
2025
2026 #endif
NetBSD on the FriendlyARM MINI2440