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