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