vnd.c revision 1.106
1 /* $NetBSD: vnd.c,v 1.106 2004/01/25 18:06:48 hannken 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: This uses the VOP_BMAP/VOP_STRATEGY interface to the vnode 123 * instead of a simple VOP_RDWR. We do this to avoid distorting the 124 * local buffer cache. 125 * 126 * NOTE 2: There is a security issue involved with this driver. 127 * Once mounted all access to the contents of the "mapped" file via 128 * the special file is controlled by the permissions on the special 129 * file, the protection of the mapped file is ignored (effectively, 130 * by using root credentials in all transactions). 131 * 132 * NOTE 3: Doesn't interact with leases, should it? 133 */ 134 135 #include <sys/cdefs.h> 136 __KERNEL_RCSID(0, "$NetBSD: vnd.c,v 1.106 2004/01/25 18:06:48 hannken Exp $"); 137 138 #if defined(_KERNEL_OPT) 139 #include "fs_nfs.h" 140 #endif 141 142 #include <sys/param.h> 143 #include <sys/systm.h> 144 #include <sys/namei.h> 145 #include <sys/proc.h> 146 #include <sys/errno.h> 147 #include <sys/buf.h> 148 #include <sys/malloc.h> 149 #include <sys/ioctl.h> 150 #include <sys/disklabel.h> 151 #include <sys/device.h> 152 #include <sys/disk.h> 153 #include <sys/stat.h> 154 #include <sys/mount.h> 155 #include <sys/vnode.h> 156 #include <sys/file.h> 157 #include <sys/uio.h> 158 #include <sys/conf.h> 159 160 #include <miscfs/specfs/specdev.h> 161 162 #include <dev/vndvar.h> 163 164 #if defined(VNDDEBUG) && !defined(DEBUG) 165 #define DEBUG 166 #endif 167 168 #ifdef DEBUG 169 int dovndcluster = 1; 170 #define VDB_FOLLOW 0x01 171 #define VDB_INIT 0x02 172 #define VDB_IO 0x04 173 #define VDB_LABEL 0x08 174 int vnddebug = 0x00; 175 #endif 176 177 #define vndunit(x) DISKUNIT(x) 178 179 struct vndxfer { 180 struct buf *vx_bp; /* Pointer to parent buffer */ 181 int vx_error; 182 int vx_pending; /* # of pending aux buffers */ 183 int vx_flags; 184 #define VX_BUSY 1 185 }; 186 187 struct vndbuf { 188 struct buf vb_buf; 189 struct vndxfer *vb_xfer; 190 }; 191 192 #define VND_GETXFER(vnd) pool_get(&(vnd)->sc_vxpool, PR_NOWAIT) 193 #define VND_PUTXFER(vnd, vx) pool_put(&(vnd)->sc_vxpool, (vx)) 194 195 #define VND_GETBUF(vnd) pool_get(&(vnd)->sc_vbpool, PR_NOWAIT) 196 #define VND_PUTBUF(vnd, vb) pool_put(&(vnd)->sc_vbpool, (vb)) 197 198 struct vnd_softc *vnd_softc; 199 int numvnd = 0; 200 201 #define VNDLABELDEV(dev) \ 202 (MAKEDISKDEV(major((dev)), vndunit((dev)), RAW_PART)) 203 204 /* called by main() at boot time (XXX: and the LKM driver) */ 205 void vndattach __P((int)); 206 int vnddetach __P((void)); 207 208 void vndclear __P((struct vnd_softc *, int)); 209 void vndstart __P((struct vnd_softc *)); 210 int vndsetcred __P((struct vnd_softc *, struct ucred *)); 211 void vndthrottle __P((struct vnd_softc *, struct vnode *)); 212 void vndiodone __P((struct buf *)); 213 #if 0 214 void vndshutdown __P((void)); 215 #endif 216 217 void vndgetdefaultlabel __P((struct vnd_softc *, struct disklabel *)); 218 void vndgetdisklabel __P((dev_t)); 219 220 static int vndlock __P((struct vnd_softc *)); 221 static void vndunlock __P((struct vnd_softc *)); 222 223 dev_type_open(vndopen); 224 dev_type_close(vndclose); 225 dev_type_read(vndread); 226 dev_type_write(vndwrite); 227 dev_type_ioctl(vndioctl); 228 dev_type_strategy(vndstrategy); 229 dev_type_dump(vnddump); 230 dev_type_size(vndsize); 231 232 const struct bdevsw vnd_bdevsw = { 233 vndopen, vndclose, vndstrategy, vndioctl, vnddump, vndsize, D_DISK 234 }; 235 236 const struct cdevsw vnd_cdevsw = { 237 vndopen, vndclose, vndread, vndwrite, vndioctl, 238 nostop, notty, nopoll, nommap, nokqfilter, D_DISK 239 }; 240 241 int vndattached = 0; 242 243 void 244 vndattach(num) 245 int num; 246 { 247 int i; 248 char *mem; 249 250 if (vndattached) 251 return; 252 vndattached = 1; 253 if (num <= 0) 254 return; 255 i = num * sizeof(struct vnd_softc); 256 mem = malloc(i, M_DEVBUF, M_NOWAIT|M_ZERO); 257 if (mem == NULL) { 258 printf("WARNING: no memory for vnode disks\n"); 259 return; 260 } 261 vnd_softc = (struct vnd_softc *)mem; 262 numvnd = num; 263 264 for (i = 0; i < numvnd; i++) { 265 vnd_softc[i].sc_unit = i; 266 bufq_alloc(&vnd_softc[i].sc_tab, 267 BUFQ_DISKSORT|BUFQ_SORT_RAWBLOCK); 268 } 269 } 270 271 int 272 vnddetach() 273 { 274 int i; 275 276 /* First check we aren't in use. */ 277 for (i = 0; i < numvnd; i++) 278 if (vnd_softc[i].sc_flags & VNF_INITED) 279 return (EBUSY); 280 281 for (i = 0; i < numvnd; i++) 282 bufq_free(&vnd_softc[i].sc_tab); 283 284 free(vnd_softc, M_DEVBUF); 285 vndattached = 0; 286 287 return (0); 288 } 289 290 int 291 vndopen(dev, flags, mode, p) 292 dev_t dev; 293 int flags, mode; 294 struct proc *p; 295 { 296 int unit = vndunit(dev); 297 struct vnd_softc *sc; 298 int error = 0, part, pmask; 299 struct disklabel *lp; 300 301 #ifdef DEBUG 302 if (vnddebug & VDB_FOLLOW) 303 printf("vndopen(0x%x, 0x%x, 0x%x, %p)\n", dev, flags, mode, p); 304 #endif 305 if (unit >= numvnd) 306 return (ENXIO); 307 sc = &vnd_softc[unit]; 308 309 if ((error = vndlock(sc)) != 0) 310 return (error); 311 312 lp = sc->sc_dkdev.dk_label; 313 314 part = DISKPART(dev); 315 pmask = (1 << part); 316 317 /* 318 * If we're initialized, check to see if there are any other 319 * open partitions. If not, then it's safe to update the 320 * in-core disklabel. Only read the disklabel if it is 321 * not realdy valid. 322 */ 323 if ((sc->sc_flags & (VNF_INITED|VNF_VLABEL)) == VNF_INITED && 324 sc->sc_dkdev.dk_openmask == 0) 325 vndgetdisklabel(dev); 326 327 /* Check that the partitions exists. */ 328 if (part != RAW_PART) { 329 if (((sc->sc_flags & VNF_INITED) == 0) || 330 ((part >= lp->d_npartitions) || 331 (lp->d_partitions[part].p_fstype == FS_UNUSED))) { 332 error = ENXIO; 333 goto done; 334 } 335 } 336 337 /* Prevent our unit from being unconfigured while open. */ 338 switch (mode) { 339 case S_IFCHR: 340 sc->sc_dkdev.dk_copenmask |= pmask; 341 break; 342 343 case S_IFBLK: 344 sc->sc_dkdev.dk_bopenmask |= pmask; 345 break; 346 } 347 sc->sc_dkdev.dk_openmask = 348 sc->sc_dkdev.dk_copenmask | sc->sc_dkdev.dk_bopenmask; 349 350 done: 351 vndunlock(sc); 352 return (error); 353 } 354 355 int 356 vndclose(dev, flags, mode, p) 357 dev_t dev; 358 int flags, mode; 359 struct proc *p; 360 { 361 int unit = vndunit(dev); 362 struct vnd_softc *sc; 363 int error = 0, part; 364 365 #ifdef DEBUG 366 if (vnddebug & VDB_FOLLOW) 367 printf("vndclose(0x%x, 0x%x, 0x%x, %p)\n", dev, flags, mode, p); 368 #endif 369 370 if (unit >= numvnd) 371 return (ENXIO); 372 sc = &vnd_softc[unit]; 373 374 if ((error = vndlock(sc)) != 0) 375 return (error); 376 377 part = DISKPART(dev); 378 379 /* ...that much closer to allowing unconfiguration... */ 380 switch (mode) { 381 case S_IFCHR: 382 sc->sc_dkdev.dk_copenmask &= ~(1 << part); 383 break; 384 385 case S_IFBLK: 386 sc->sc_dkdev.dk_bopenmask &= ~(1 << part); 387 break; 388 } 389 sc->sc_dkdev.dk_openmask = 390 sc->sc_dkdev.dk_copenmask | sc->sc_dkdev.dk_bopenmask; 391 392 if (sc->sc_dkdev.dk_openmask == 0) { 393 if ((sc->sc_flags & VNF_KLABEL) == 0) 394 sc->sc_flags &= ~VNF_VLABEL; 395 } 396 397 vndunlock(sc); 398 return (0); 399 } 400 401 /* 402 * Break the request into bsize pieces and submit using VOP_BMAP/VOP_STRATEGY. 403 */ 404 void 405 vndstrategy(bp) 406 struct buf *bp; 407 { 408 int unit = vndunit(bp->b_dev); 409 struct vnd_softc *vnd = &vnd_softc[unit]; 410 struct vndxfer *vnx; 411 struct mount *mp; 412 int s, bsize, resid; 413 off_t bn; 414 caddr_t addr; 415 int sz, flags, error, wlabel; 416 struct disklabel *lp; 417 struct partition *pp; 418 419 #ifdef DEBUG 420 if (vnddebug & VDB_FOLLOW) 421 printf("vndstrategy(%p): unit %d\n", bp, unit); 422 #endif 423 if ((vnd->sc_flags & VNF_INITED) == 0) { 424 bp->b_error = ENXIO; 425 bp->b_flags |= B_ERROR; 426 goto done; 427 } 428 429 /* If it's a nil transfer, wake up the top half now. */ 430 if (bp->b_bcount == 0) 431 goto done; 432 433 lp = vnd->sc_dkdev.dk_label; 434 435 /* 436 * The transfer must be a whole number of blocks. 437 */ 438 if ((bp->b_bcount % lp->d_secsize) != 0) { 439 bp->b_error = EINVAL; 440 bp->b_flags |= B_ERROR; 441 goto done; 442 } 443 444 /* 445 * Do bounds checking and adjust transfer. If there's an error, 446 * the bounds check will flag that for us. 447 */ 448 wlabel = vnd->sc_flags & (VNF_WLABEL|VNF_LABELLING); 449 if (DISKPART(bp->b_dev) != RAW_PART) 450 if (bounds_check_with_label(&vnd->sc_dkdev, bp, wlabel) <= 0) 451 goto done; 452 453 /* 454 * check if we're read-only. 455 */ 456 if ((vnd->sc_flags & VNF_READONLY) && !(bp->b_flags & B_READ)) { 457 bp->b_error = EACCES; 458 bp->b_flags |= B_ERROR; 459 goto done; 460 } 461 462 bp->b_resid = bp->b_bcount; 463 464 /* 465 * Put the block number in terms of the logical blocksize 466 * of the "device". 467 */ 468 bn = bp->b_blkno / (lp->d_secsize / DEV_BSIZE); 469 470 /* 471 * Translate the partition-relative block number to an absolute. 472 */ 473 if (DISKPART(bp->b_dev) != RAW_PART) { 474 pp = &vnd->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)]; 475 bn += pp->p_offset; 476 } 477 478 /* ...and convert to a byte offset within the file. */ 479 bn *= lp->d_secsize; 480 481 if (vnd->sc_vp->v_mount == NULL) { 482 bp->b_error = ENXIO; 483 bp->b_flags |= B_ERROR; 484 goto done; 485 } 486 bsize = vnd->sc_vp->v_mount->mnt_stat.f_iosize; 487 addr = bp->b_data; 488 flags = (bp->b_flags & (B_READ|B_ASYNC)) | B_CALL; 489 490 /* Allocate a header for this transfer and link it to the buffer */ 491 s = splbio(); 492 vnx = VND_GETXFER(vnd); 493 splx(s); 494 vnx->vx_flags = VX_BUSY; 495 vnx->vx_error = 0; 496 vnx->vx_pending = 0; 497 vnx->vx_bp = bp; 498 499 if ((flags & B_READ) == 0) 500 vn_start_write(vnd->sc_vp, &mp, V_WAIT); 501 502 for (resid = bp->b_resid; resid; resid -= sz) { 503 struct vndbuf *nbp; 504 struct vnode *vp; 505 daddr_t nbn; 506 int off, nra; 507 508 nra = 0; 509 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY | LK_CANRECURSE); 510 error = VOP_BMAP(vnd->sc_vp, bn / bsize, &vp, &nbn, &nra); 511 VOP_UNLOCK(vnd->sc_vp, 0); 512 513 if (error == 0 && (long)nbn == -1) 514 error = EIO; 515 516 /* 517 * If there was an error or a hole in the file...punt. 518 * Note that we may have to wait for any operations 519 * that we have already fired off before releasing 520 * the buffer. 521 * 522 * XXX we could deal with holes here but it would be 523 * a hassle (in the write case). 524 */ 525 if (error) { 526 s = splbio(); 527 vnx->vx_error = error; 528 goto out; 529 } 530 531 #ifdef DEBUG 532 if (!dovndcluster) 533 nra = 0; 534 #endif 535 536 if ((off = bn % bsize) != 0) 537 sz = bsize - off; 538 else 539 sz = (1 + nra) * bsize; 540 if (resid < sz) 541 sz = resid; 542 #ifdef DEBUG 543 if (vnddebug & VDB_IO) 544 printf("vndstrategy: vp %p/%p bn 0x%qx/0x%" PRIx64 545 " sz 0x%x\n", 546 vnd->sc_vp, vp, (long long)bn, nbn, sz); 547 #endif 548 549 s = splbio(); 550 nbp = VND_GETBUF(vnd); 551 splx(s); 552 BUF_INIT(&nbp->vb_buf); 553 nbp->vb_buf.b_flags = flags; 554 nbp->vb_buf.b_bcount = sz; 555 nbp->vb_buf.b_bufsize = round_page((ulong)addr + sz) 556 - trunc_page((ulong) addr); 557 nbp->vb_buf.b_error = 0; 558 nbp->vb_buf.b_data = addr; 559 nbp->vb_buf.b_blkno = nbp->vb_buf.b_rawblkno = nbn + btodb(off); 560 nbp->vb_buf.b_proc = bp->b_proc; 561 nbp->vb_buf.b_iodone = vndiodone; 562 nbp->vb_buf.b_vp = NULLVP; 563 564 nbp->vb_xfer = vnx; 565 566 BIO_COPYPRIO(&nbp->vb_buf, bp); 567 568 /* 569 * Just sort by block number 570 */ 571 s = splbio(); 572 if (vnx->vx_error != 0) { 573 VND_PUTBUF(vnd, nbp); 574 goto out; 575 } 576 vnx->vx_pending++; 577 bgetvp(vp, &nbp->vb_buf); 578 BUFQ_PUT(&vnd->sc_tab, &nbp->vb_buf); 579 vndstart(vnd); 580 splx(s); 581 bn += sz; 582 addr += sz; 583 } 584 585 s = splbio(); 586 587 out: /* Arrive here at splbio */ 588 if ((flags & B_READ) == 0) 589 vn_finished_write(mp, 0); 590 vnx->vx_flags &= ~VX_BUSY; 591 if (vnx->vx_pending == 0) { 592 if (vnx->vx_error != 0) { 593 bp->b_error = vnx->vx_error; 594 bp->b_flags |= B_ERROR; 595 } 596 VND_PUTXFER(vnd, vnx); 597 biodone(bp); 598 } 599 splx(s); 600 return; 601 602 done: 603 biodone(bp); 604 } 605 606 /* 607 * Feed requests sequentially. 608 * We do it this way to keep from flooding NFS servers if we are connected 609 * to an NFS file. This places the burden on the client rather than the 610 * server. 611 */ 612 void 613 vndstart(vnd) 614 struct vnd_softc *vnd; 615 { 616 struct buf *bp; 617 618 /* 619 * Dequeue now since lower level strategy routine might 620 * queue using same links 621 */ 622 623 if ((vnd->sc_flags & VNF_BUSY) != 0) 624 return; 625 626 vnd->sc_flags |= VNF_BUSY; 627 628 while (vnd->sc_active < vnd->sc_maxactive) { 629 bp = BUFQ_GET(&vnd->sc_tab); 630 if (bp == NULL) 631 break; 632 vnd->sc_active++; 633 #ifdef DEBUG 634 if (vnddebug & VDB_IO) 635 printf("vndstart(%ld): bp %p vp %p blkno 0x%" PRIx64 636 " flags %lx addr %p cnt 0x%lx\n", 637 (long) (vnd-vnd_softc), bp, bp->b_vp, bp->b_blkno, 638 bp->b_flags, bp->b_data, bp->b_bcount); 639 #endif 640 641 /* Instrumentation. */ 642 disk_busy(&vnd->sc_dkdev); 643 644 if ((bp->b_flags & B_READ) == 0) 645 bp->b_vp->v_numoutput++; 646 VOP_STRATEGY(bp->b_vp, bp); 647 } 648 vnd->sc_flags &= ~VNF_BUSY; 649 } 650 651 void 652 vndiodone(bp) 653 struct buf *bp; 654 { 655 struct vndbuf *vbp = (struct vndbuf *) bp; 656 struct vndxfer *vnx = (struct vndxfer *)vbp->vb_xfer; 657 struct buf *pbp = vnx->vx_bp; 658 struct vnd_softc *vnd = &vnd_softc[vndunit(pbp->b_dev)]; 659 int s, resid; 660 661 s = splbio(); 662 #ifdef DEBUG 663 if (vnddebug & VDB_IO) 664 printf("vndiodone(%ld): vbp %p vp %p blkno 0x%" PRIx64 665 " addr %p cnt 0x%lx\n", 666 (long) (vnd-vnd_softc), vbp, vbp->vb_buf.b_vp, 667 vbp->vb_buf.b_blkno, vbp->vb_buf.b_data, 668 vbp->vb_buf.b_bcount); 669 #endif 670 671 resid = vbp->vb_buf.b_bcount - vbp->vb_buf.b_resid; 672 pbp->b_resid -= resid; 673 disk_unbusy(&vnd->sc_dkdev, resid, (pbp->b_flags & B_READ)); 674 vnx->vx_pending--; 675 676 if (vbp->vb_buf.b_error) { 677 #ifdef DEBUG 678 if (vnddebug & VDB_IO) 679 printf("vndiodone: vbp %p error %d\n", vbp, 680 vbp->vb_buf.b_error); 681 #endif 682 vnx->vx_error = vbp->vb_buf.b_error; 683 } 684 685 if (vbp->vb_buf.b_vp != NULLVP) 686 brelvp(&vbp->vb_buf); 687 688 VND_PUTBUF(vnd, vbp); 689 690 /* 691 * Wrap up this transaction if it has run to completion or, in 692 * case of an error, when all auxiliary buffers have returned. 693 */ 694 if (vnx->vx_error != 0) { 695 pbp->b_flags |= B_ERROR; 696 pbp->b_error = vnx->vx_error; 697 if ((vnx->vx_flags & VX_BUSY) == 0 && vnx->vx_pending == 0) { 698 699 #ifdef DEBUG 700 if (vnddebug & VDB_IO) 701 printf("vndiodone: pbp %p iodone: error %d\n", 702 pbp, vnx->vx_error); 703 #endif 704 VND_PUTXFER(vnd, vnx); 705 biodone(pbp); 706 } 707 } else if (pbp->b_resid == 0) { 708 709 #ifdef DIAGNOSTIC 710 if (vnx->vx_pending != 0) 711 panic("vndiodone: vnx pending: %d", vnx->vx_pending); 712 #endif 713 714 if ((vnx->vx_flags & VX_BUSY) == 0) { 715 #ifdef DEBUG 716 if (vnddebug & VDB_IO) 717 printf("vndiodone: pbp %p iodone\n", pbp); 718 #endif 719 VND_PUTXFER(vnd, vnx); 720 biodone(pbp); 721 } 722 } 723 724 vnd->sc_active--; 725 vndstart(vnd); 726 splx(s); 727 } 728 729 /* ARGSUSED */ 730 int 731 vndread(dev, uio, flags) 732 dev_t dev; 733 struct uio *uio; 734 int flags; 735 { 736 int unit = vndunit(dev); 737 struct vnd_softc *sc; 738 739 #ifdef DEBUG 740 if (vnddebug & VDB_FOLLOW) 741 printf("vndread(0x%x, %p)\n", dev, uio); 742 #endif 743 744 if (unit >= numvnd) 745 return (ENXIO); 746 sc = &vnd_softc[unit]; 747 748 if ((sc->sc_flags & VNF_INITED) == 0) 749 return (ENXIO); 750 751 return (physio(vndstrategy, NULL, dev, B_READ, minphys, uio)); 752 } 753 754 /* ARGSUSED */ 755 int 756 vndwrite(dev, uio, flags) 757 dev_t dev; 758 struct uio *uio; 759 int flags; 760 { 761 int unit = vndunit(dev); 762 struct vnd_softc *sc; 763 764 #ifdef DEBUG 765 if (vnddebug & VDB_FOLLOW) 766 printf("vndwrite(0x%x, %p)\n", dev, uio); 767 #endif 768 769 if (unit >= numvnd) 770 return (ENXIO); 771 sc = &vnd_softc[unit]; 772 773 if ((sc->sc_flags & VNF_INITED) == 0) 774 return (ENXIO); 775 776 return (physio(vndstrategy, NULL, dev, B_WRITE, minphys, uio)); 777 } 778 779 /* ARGSUSED */ 780 int 781 vndioctl(dev, cmd, data, flag, p) 782 dev_t dev; 783 u_long cmd; 784 caddr_t data; 785 int flag; 786 struct proc *p; 787 { 788 int unit = vndunit(dev); 789 struct vnd_softc *vnd; 790 struct vnd_ioctl *vio; 791 struct vattr vattr; 792 struct nameidata nd; 793 int error, part, pmask; 794 size_t geomsize; 795 int fflags; 796 #ifdef __HAVE_OLD_DISKLABEL 797 struct disklabel newlabel; 798 #endif 799 800 #ifdef DEBUG 801 if (vnddebug & VDB_FOLLOW) 802 printf("vndioctl(0x%x, 0x%lx, %p, 0x%x, %p): unit %d\n", 803 dev, cmd, data, flag, p, unit); 804 #endif 805 if (unit >= numvnd) 806 return (ENXIO); 807 808 vnd = &vnd_softc[unit]; 809 vio = (struct vnd_ioctl *)data; 810 811 /* Must be open for writes for these commands... */ 812 switch (cmd) { 813 case VNDIOCSET: 814 case VNDIOCCLR: 815 case DIOCSDINFO: 816 case DIOCWDINFO: 817 #ifdef __HAVE_OLD_DISKLABEL 818 case ODIOCSDINFO: 819 case ODIOCWDINFO: 820 #endif 821 case DIOCKLABEL: 822 case DIOCWLABEL: 823 if ((flag & FWRITE) == 0) 824 return (EBADF); 825 } 826 827 /* Must be initialized for these... */ 828 switch (cmd) { 829 case VNDIOCCLR: 830 case DIOCGDINFO: 831 case DIOCSDINFO: 832 case DIOCWDINFO: 833 case DIOCGPART: 834 case DIOCKLABEL: 835 case DIOCWLABEL: 836 case DIOCGDEFLABEL: 837 #ifdef __HAVE_OLD_DISKLABEL 838 case ODIOCGDINFO: 839 case ODIOCSDINFO: 840 case ODIOCWDINFO: 841 case ODIOCGDEFLABEL: 842 #endif 843 if ((vnd->sc_flags & VNF_INITED) == 0) 844 return (ENXIO); 845 } 846 847 switch (cmd) { 848 case VNDIOCSET: 849 if (vnd->sc_flags & VNF_INITED) 850 return (EBUSY); 851 852 if ((error = vndlock(vnd)) != 0) 853 return (error); 854 855 fflags = FREAD; 856 if ((vio->vnd_flags & VNDIOF_READONLY) == 0) 857 fflags |= FWRITE; 858 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, vio->vnd_file, p); 859 if ((error = vn_open(&nd, fflags, 0)) != 0) 860 goto unlock_and_exit; 861 error = VOP_GETATTR(nd.ni_vp, &vattr, p->p_ucred, p); 862 VOP_UNLOCK(nd.ni_vp, 0); 863 if (!error && nd.ni_vp->v_type != VREG) 864 error = EOPNOTSUPP; 865 if (error) 866 goto close_and_exit; 867 vnd->sc_vp = nd.ni_vp; 868 vnd->sc_size = btodb(vattr.va_size); /* note truncation */ 869 870 /* 871 * Use pseudo-geometry specified. If none was provided, 872 * use "standard" Adaptec fictitious geometry. 873 */ 874 if (vio->vnd_flags & VNDIOF_HASGEOM) { 875 876 memcpy(&vnd->sc_geom, &vio->vnd_geom, 877 sizeof(vio->vnd_geom)); 878 879 /* 880 * Sanity-check the sector size. 881 * XXX Don't allow secsize < DEV_BSIZE. Should 882 * XXX we? 883 */ 884 if (vnd->sc_geom.vng_secsize < DEV_BSIZE || 885 (vnd->sc_geom.vng_secsize % DEV_BSIZE) != 0 || 886 vnd->sc_geom.vng_ncylinders == 0 || 887 (vnd->sc_geom.vng_ntracks * 888 vnd->sc_geom.vng_nsectors) == 0) { 889 error = EINVAL; 890 goto close_and_exit; 891 } 892 893 /* 894 * Compute the size (in DEV_BSIZE blocks) specified 895 * by the geometry. 896 */ 897 geomsize = (vnd->sc_geom.vng_nsectors * 898 vnd->sc_geom.vng_ntracks * 899 vnd->sc_geom.vng_ncylinders) * 900 (vnd->sc_geom.vng_secsize / DEV_BSIZE); 901 902 /* 903 * Sanity-check the size against the specified 904 * geometry. 905 */ 906 if (vnd->sc_size < geomsize) { 907 error = EINVAL; 908 goto close_and_exit; 909 } 910 } else { 911 /* 912 * Size must be at least 2048 DEV_BSIZE blocks 913 * (1M) in order to use this geometry. 914 */ 915 if (vnd->sc_size < (32 * 64)) { 916 error = EINVAL; 917 goto close_and_exit; 918 } 919 920 vnd->sc_geom.vng_secsize = DEV_BSIZE; 921 vnd->sc_geom.vng_nsectors = 32; 922 vnd->sc_geom.vng_ntracks = 64; 923 vnd->sc_geom.vng_ncylinders = vnd->sc_size / (64 * 32); 924 } 925 926 if (vio->vnd_flags & VNDIOF_READONLY) { 927 vnd->sc_flags |= VNF_READONLY; 928 } 929 930 if ((error = vndsetcred(vnd, p->p_ucred)) != 0) 931 goto close_and_exit; 932 vndthrottle(vnd, vnd->sc_vp); 933 vio->vnd_size = dbtob(vnd->sc_size); 934 vnd->sc_flags |= VNF_INITED; 935 #ifdef DEBUG 936 if (vnddebug & VDB_INIT) 937 printf("vndioctl: SET vp %p size 0x%lx %d/%d/%d/%d\n", 938 vnd->sc_vp, (unsigned long) vnd->sc_size, 939 vnd->sc_geom.vng_secsize, 940 vnd->sc_geom.vng_nsectors, 941 vnd->sc_geom.vng_ntracks, 942 vnd->sc_geom.vng_ncylinders); 943 #endif 944 945 /* Attach the disk. */ 946 memset(vnd->sc_xname, 0, sizeof(vnd->sc_xname)); /* XXX */ 947 sprintf(vnd->sc_xname, "vnd%d", unit); /* XXX */ 948 vnd->sc_dkdev.dk_name = vnd->sc_xname; 949 disk_attach(&vnd->sc_dkdev); 950 951 /* Initialize the xfer and buffer pools. */ 952 pool_init(&vnd->sc_vxpool, sizeof(struct vndxfer), 0, 953 0, 0, "vndxpl", NULL); 954 pool_init(&vnd->sc_vbpool, sizeof(struct vndbuf), 0, 955 0, 0, "vndbpl", NULL); 956 957 /* Try and read the disklabel. */ 958 vndgetdisklabel(dev); 959 960 vndunlock(vnd); 961 962 break; 963 964 close_and_exit: 965 (void) vn_close(nd.ni_vp, fflags, p->p_ucred, p); 966 unlock_and_exit: 967 vndunlock(vnd); 968 return (error); 969 970 case VNDIOCCLR: 971 if ((error = vndlock(vnd)) != 0) 972 return (error); 973 974 /* 975 * Don't unconfigure if any other partitions are open 976 * or if both the character and block flavors of this 977 * partition are open. 978 */ 979 part = DISKPART(dev); 980 pmask = (1 << part); 981 if (((vnd->sc_dkdev.dk_openmask & ~pmask) || 982 ((vnd->sc_dkdev.dk_bopenmask & pmask) && 983 (vnd->sc_dkdev.dk_copenmask & pmask))) && 984 !(vio->vnd_flags & VNDIOF_FORCE)) { 985 vndunlock(vnd); 986 return (EBUSY); 987 } 988 989 /* 990 * XXX vndclear() might call vndclose() implicitely; 991 * release lock to avoid recursion 992 */ 993 vndunlock(vnd); 994 vndclear(vnd, minor(dev)); 995 #ifdef DEBUG 996 if (vnddebug & VDB_INIT) 997 printf("vndioctl: CLRed\n"); 998 #endif 999 1000 /* Destroy the xfer and buffer pools. */ 1001 pool_destroy(&vnd->sc_vxpool); 1002 pool_destroy(&vnd->sc_vbpool); 1003 1004 /* Detatch the disk. */ 1005 disk_detach(&vnd->sc_dkdev); 1006 1007 break; 1008 1009 case VNDIOCGET: { 1010 struct vnd_user *vnu; 1011 struct vattr va; 1012 1013 vnu = (struct vnd_user *)data; 1014 1015 if (vnu->vnu_unit == -1) 1016 vnu->vnu_unit = unit; 1017 if (vnu->vnu_unit >= numvnd) 1018 return (ENXIO); 1019 if (vnu->vnu_unit < 0) 1020 return (EINVAL); 1021 1022 vnd = &vnd_softc[vnu->vnu_unit]; 1023 1024 if (vnd->sc_flags & VNF_INITED) { 1025 error = VOP_GETATTR(vnd->sc_vp, &va, p->p_ucred, p); 1026 if (error) 1027 return (error); 1028 vnu->vnu_dev = va.va_fsid; 1029 vnu->vnu_ino = va.va_fileid; 1030 } 1031 else { 1032 /* unused is not an error */ 1033 vnu->vnu_dev = 0; 1034 vnu->vnu_ino = 0; 1035 } 1036 1037 break; 1038 } 1039 1040 case DIOCGDINFO: 1041 *(struct disklabel *)data = *(vnd->sc_dkdev.dk_label); 1042 break; 1043 1044 #ifdef __HAVE_OLD_DISKLABEL 1045 case ODIOCGDINFO: 1046 newlabel = *(vnd->sc_dkdev.dk_label); 1047 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 1048 return ENOTTY; 1049 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 1050 break; 1051 #endif 1052 1053 case DIOCGPART: 1054 ((struct partinfo *)data)->disklab = vnd->sc_dkdev.dk_label; 1055 ((struct partinfo *)data)->part = 1056 &vnd->sc_dkdev.dk_label->d_partitions[DISKPART(dev)]; 1057 break; 1058 1059 case DIOCWDINFO: 1060 case DIOCSDINFO: 1061 #ifdef __HAVE_OLD_DISKLABEL 1062 case ODIOCWDINFO: 1063 case ODIOCSDINFO: 1064 #endif 1065 { 1066 struct disklabel *lp; 1067 1068 if ((error = vndlock(vnd)) != 0) 1069 return (error); 1070 1071 vnd->sc_flags |= VNF_LABELLING; 1072 1073 #ifdef __HAVE_OLD_DISKLABEL 1074 if (cmd == ODIOCSDINFO || cmd == ODIOCWDINFO) { 1075 memset(&newlabel, 0, sizeof newlabel); 1076 memcpy(&newlabel, data, sizeof (struct olddisklabel)); 1077 lp = &newlabel; 1078 } else 1079 #endif 1080 lp = (struct disklabel *)data; 1081 1082 error = setdisklabel(vnd->sc_dkdev.dk_label, 1083 lp, 0, vnd->sc_dkdev.dk_cpulabel); 1084 if (error == 0) { 1085 if (cmd == DIOCWDINFO 1086 #ifdef __HAVE_OLD_DISKLABEL 1087 || cmd == ODIOCWDINFO 1088 #endif 1089 ) 1090 error = writedisklabel(VNDLABELDEV(dev), 1091 vndstrategy, vnd->sc_dkdev.dk_label, 1092 vnd->sc_dkdev.dk_cpulabel); 1093 } 1094 1095 vnd->sc_flags &= ~VNF_LABELLING; 1096 1097 vndunlock(vnd); 1098 1099 if (error) 1100 return (error); 1101 break; 1102 } 1103 1104 case DIOCKLABEL: 1105 if (*(int *)data != 0) 1106 vnd->sc_flags |= VNF_KLABEL; 1107 else 1108 vnd->sc_flags &= ~VNF_KLABEL; 1109 break; 1110 1111 case DIOCWLABEL: 1112 if (*(int *)data != 0) 1113 vnd->sc_flags |= VNF_WLABEL; 1114 else 1115 vnd->sc_flags &= ~VNF_WLABEL; 1116 break; 1117 1118 case DIOCGDEFLABEL: 1119 vndgetdefaultlabel(vnd, (struct disklabel *)data); 1120 break; 1121 1122 #ifdef __HAVE_OLD_DISKLABEL 1123 case ODIOCGDEFLABEL: 1124 vndgetdefaultlabel(vnd, &newlabel); 1125 if (newlabel.d_npartitions > OLDMAXPARTITIONS) 1126 return ENOTTY; 1127 memcpy(data, &newlabel, sizeof (struct olddisklabel)); 1128 break; 1129 #endif 1130 1131 default: 1132 return (ENOTTY); 1133 } 1134 1135 return (0); 1136 } 1137 1138 /* 1139 * Duplicate the current processes' credentials. Since we are called only 1140 * as the result of a SET ioctl and only root can do that, any future access 1141 * to this "disk" is essentially as root. Note that credentials may change 1142 * if some other uid can write directly to the mapped file (NFS). 1143 */ 1144 int 1145 vndsetcred(vnd, cred) 1146 struct vnd_softc *vnd; 1147 struct ucred *cred; 1148 { 1149 struct uio auio; 1150 struct iovec aiov; 1151 char *tmpbuf; 1152 int error; 1153 1154 vnd->sc_cred = crdup(cred); 1155 tmpbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK); 1156 1157 /* XXX: Horrible kludge to establish credentials for NFS */ 1158 aiov.iov_base = tmpbuf; 1159 aiov.iov_len = min(DEV_BSIZE, dbtob(vnd->sc_size)); 1160 auio.uio_iov = &aiov; 1161 auio.uio_iovcnt = 1; 1162 auio.uio_offset = 0; 1163 auio.uio_rw = UIO_READ; 1164 auio.uio_segflg = UIO_SYSSPACE; 1165 auio.uio_resid = aiov.iov_len; 1166 vn_lock(vnd->sc_vp, LK_EXCLUSIVE | LK_RETRY); 1167 error = VOP_READ(vnd->sc_vp, &auio, 0, vnd->sc_cred); 1168 if (error == 0) { 1169 /* 1170 * Because vnd does all IO directly through the vnode 1171 * we need to flush (at least) the buffer from the above 1172 * VOP_READ from the buffer cache to prevent cache 1173 * incoherencies. Also, be careful to write dirty 1174 * buffers back to stable storage. 1175 */ 1176 error = vinvalbuf(vnd->sc_vp, V_SAVE, vnd->sc_cred, 1177 curproc, 0, 0); 1178 } 1179 VOP_UNLOCK(vnd->sc_vp, 0); 1180 1181 free(tmpbuf, M_TEMP); 1182 return (error); 1183 } 1184 1185 /* 1186 * Set maxactive based on FS type 1187 */ 1188 void 1189 vndthrottle(vnd, vp) 1190 struct vnd_softc *vnd; 1191 struct vnode *vp; 1192 { 1193 #ifdef NFS 1194 extern int (**nfsv2_vnodeop_p) __P((void *)); 1195 1196 if (vp->v_op == nfsv2_vnodeop_p) 1197 vnd->sc_maxactive = 2; 1198 else 1199 #endif 1200 vnd->sc_maxactive = 8; 1201 1202 if (vnd->sc_maxactive < 1) 1203 vnd->sc_maxactive = 1; 1204 } 1205 1206 #if 0 1207 void 1208 vndshutdown() 1209 { 1210 struct vnd_softc *vnd; 1211 1212 for (vnd = &vnd_softc[0]; vnd < &vnd_softc[numvnd]; vnd++) 1213 if (vnd->sc_flags & VNF_INITED) 1214 vndclear(vnd); 1215 } 1216 #endif 1217 1218 void 1219 vndclear(vnd, myminor) 1220 struct vnd_softc *vnd; 1221 int myminor; 1222 { 1223 struct vnode *vp = vnd->sc_vp; 1224 struct proc *p = curproc; /* XXX */ 1225 int fflags = FREAD; 1226 int bmaj, cmaj, i, mn; 1227 1228 #ifdef DEBUG 1229 if (vnddebug & VDB_FOLLOW) 1230 printf("vndclear(%p): vp %p\n", vnd, vp); 1231 #endif 1232 /* locate the major number */ 1233 bmaj = bdevsw_lookup_major(&vnd_bdevsw); 1234 cmaj = cdevsw_lookup_major(&vnd_cdevsw); 1235 1236 /* Nuke the vnodes for any open instances */ 1237 for (i = 0; i < MAXPARTITIONS; i++) { 1238 mn = DISKMINOR(vnd->sc_unit, i); 1239 vdevgone(bmaj, mn, mn, VBLK); 1240 if (mn != myminor) /* XXX avoid to kill own vnode */ 1241 vdevgone(cmaj, mn, mn, VCHR); 1242 } 1243 1244 if ((vnd->sc_flags & VNF_READONLY) == 0) 1245 fflags |= FWRITE; 1246 vnd->sc_flags &= ~(VNF_INITED | VNF_READONLY | VNF_VLABEL); 1247 if (vp == (struct vnode *)0) 1248 panic("vndioctl: null vp"); 1249 (void) vn_close(vp, fflags, vnd->sc_cred, p); 1250 crfree(vnd->sc_cred); 1251 vnd->sc_vp = (struct vnode *)0; 1252 vnd->sc_cred = (struct ucred *)0; 1253 vnd->sc_size = 0; 1254 } 1255 1256 int 1257 vndsize(dev) 1258 dev_t dev; 1259 { 1260 struct vnd_softc *sc; 1261 struct disklabel *lp; 1262 int part, unit, omask; 1263 int size; 1264 1265 unit = vndunit(dev); 1266 if (unit >= numvnd) 1267 return (-1); 1268 sc = &vnd_softc[unit]; 1269 1270 if ((sc->sc_flags & VNF_INITED) == 0) 1271 return (-1); 1272 1273 part = DISKPART(dev); 1274 omask = sc->sc_dkdev.dk_openmask & (1 << part); 1275 lp = sc->sc_dkdev.dk_label; 1276 1277 if (omask == 0 && vndopen(dev, 0, S_IFBLK, curproc)) 1278 return (-1); 1279 1280 if (lp->d_partitions[part].p_fstype != FS_SWAP) 1281 size = -1; 1282 else 1283 size = lp->d_partitions[part].p_size * 1284 (lp->d_secsize / DEV_BSIZE); 1285 1286 if (omask == 0 && vndclose(dev, 0, S_IFBLK, curproc)) 1287 return (-1); 1288 1289 return (size); 1290 } 1291 1292 int 1293 vnddump(dev, blkno, va, size) 1294 dev_t dev; 1295 daddr_t blkno; 1296 caddr_t va; 1297 size_t size; 1298 { 1299 1300 /* Not implemented. */ 1301 return ENXIO; 1302 } 1303 1304 void 1305 vndgetdefaultlabel(sc, lp) 1306 struct vnd_softc *sc; 1307 struct disklabel *lp; 1308 { 1309 struct vndgeom *vng = &sc->sc_geom; 1310 struct partition *pp; 1311 1312 memset(lp, 0, sizeof(*lp)); 1313 1314 lp->d_secperunit = sc->sc_size / (vng->vng_secsize / DEV_BSIZE); 1315 lp->d_secsize = vng->vng_secsize; 1316 lp->d_nsectors = vng->vng_nsectors; 1317 lp->d_ntracks = vng->vng_ntracks; 1318 lp->d_ncylinders = vng->vng_ncylinders; 1319 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 1320 1321 strncpy(lp->d_typename, "vnd", sizeof(lp->d_typename)); 1322 lp->d_type = DTYPE_VND; 1323 strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); 1324 lp->d_rpm = 3600; 1325 lp->d_interleave = 1; 1326 lp->d_flags = 0; 1327 1328 pp = &lp->d_partitions[RAW_PART]; 1329 pp->p_offset = 0; 1330 pp->p_size = lp->d_secperunit; 1331 pp->p_fstype = FS_UNUSED; 1332 lp->d_npartitions = RAW_PART + 1; 1333 1334 lp->d_magic = DISKMAGIC; 1335 lp->d_magic2 = DISKMAGIC; 1336 lp->d_checksum = dkcksum(lp); 1337 } 1338 1339 /* 1340 * Read the disklabel from a vnd. If one is not present, create a fake one. 1341 */ 1342 void 1343 vndgetdisklabel(dev) 1344 dev_t dev; 1345 { 1346 struct vnd_softc *sc = &vnd_softc[vndunit(dev)]; 1347 const char *errstring; 1348 struct disklabel *lp = sc->sc_dkdev.dk_label; 1349 struct cpu_disklabel *clp = sc->sc_dkdev.dk_cpulabel; 1350 int i; 1351 1352 memset(clp, 0, sizeof(*clp)); 1353 1354 vndgetdefaultlabel(sc, lp); 1355 1356 /* 1357 * Call the generic disklabel extraction routine. 1358 */ 1359 errstring = readdisklabel(VNDLABELDEV(dev), vndstrategy, lp, clp); 1360 if (errstring) { 1361 /* 1362 * Lack of disklabel is common, but we print the warning 1363 * anyway, since it might contain other useful information. 1364 */ 1365 printf("%s: %s\n", sc->sc_xname, errstring); 1366 1367 /* 1368 * For historical reasons, if there's no disklabel 1369 * present, all partitions must be FS_BSDFFS and 1370 * occupy the entire disk. 1371 */ 1372 for (i = 0; i < MAXPARTITIONS; i++) { 1373 /* 1374 * Don't wipe out port specific hack (such as 1375 * dos partition hack of i386 port). 1376 */ 1377 if (lp->d_partitions[i].p_size != 0) 1378 continue; 1379 1380 lp->d_partitions[i].p_size = lp->d_secperunit; 1381 lp->d_partitions[i].p_offset = 0; 1382 lp->d_partitions[i].p_fstype = FS_BSDFFS; 1383 } 1384 1385 strncpy(lp->d_packname, "default label", 1386 sizeof(lp->d_packname)); 1387 1388 lp->d_npartitions = MAXPARTITIONS; 1389 lp->d_checksum = dkcksum(lp); 1390 } 1391 1392 /* In-core label now valid. */ 1393 sc->sc_flags |= VNF_VLABEL; 1394 } 1395 1396 /* 1397 * Wait interruptibly for an exclusive lock. 1398 * 1399 * XXX 1400 * Several drivers do this; it should be abstracted and made MP-safe. 1401 */ 1402 static int 1403 vndlock(sc) 1404 struct vnd_softc *sc; 1405 { 1406 int error; 1407 1408 while ((sc->sc_flags & VNF_LOCKED) != 0) { 1409 sc->sc_flags |= VNF_WANTED; 1410 if ((error = tsleep(sc, PRIBIO | PCATCH, "vndlck", 0)) != 0) 1411 return (error); 1412 } 1413 sc->sc_flags |= VNF_LOCKED; 1414 return (0); 1415 } 1416 1417 /* 1418 * Unlock and wake up any waiters. 1419 */ 1420 static void 1421 vndunlock(sc) 1422 struct vnd_softc *sc; 1423 { 1424 1425 sc->sc_flags &= ~VNF_LOCKED; 1426 if ((sc->sc_flags & VNF_WANTED) != 0) { 1427 sc->sc_flags &= ~VNF_WANTED; 1428 wakeup(sc); 1429 } 1430 } 1431
Indexes created Tue Sep 30 06:09:59 GMT 2025