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