spec_vnops.c revision 1.65
1 /* $NetBSD: spec_vnops.c,v 1.65 2002/10/23 09:14:38 jdolecek Exp $ */ 2 3 /* 4 * Copyright (c) 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)spec_vnops.c 8.15 (Berkeley) 7/14/95 36 */ 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: spec_vnops.c,v 1.65 2002/10/23 09:14:38 jdolecek Exp $"); 40 41 #include <sys/param.h> 42 #include <sys/proc.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/conf.h> 46 #include <sys/buf.h> 47 #include <sys/mount.h> 48 #include <sys/namei.h> 49 #include <sys/vnode.h> 50 #include <sys/stat.h> 51 #include <sys/errno.h> 52 #include <sys/ioctl.h> 53 #include <sys/file.h> 54 #include <sys/disklabel.h> 55 #include <sys/lockf.h> 56 57 #include <miscfs/genfs/genfs.h> 58 #include <miscfs/specfs/specdev.h> 59 60 /* symbolic sleep message strings for devices */ 61 const char devopn[] = "devopn"; 62 const char devio[] = "devio"; 63 const char devwait[] = "devwait"; 64 const char devin[] = "devin"; 65 const char devout[] = "devout"; 66 const char devioc[] = "devioc"; 67 const char devcls[] = "devcls"; 68 69 struct vnode *speclisth[SPECHSZ]; 70 71 /* 72 * This vnode operations vector is used for two things only: 73 * - special device nodes created from whole cloth by the kernel. 74 * - as a temporary vnodeops replacement for vnodes which were found to 75 * be aliased by callers of checkalias(). 76 * For the ops vector for vnodes built from special devices found in a 77 * filesystem, see (e.g) ffs_specop_entries[] in ffs_vnops.c or the 78 * equivalent for other filesystems. 79 */ 80 81 int (**spec_vnodeop_p) __P((void *)); 82 const struct vnodeopv_entry_desc spec_vnodeop_entries[] = { 83 { &vop_default_desc, vn_default_error }, 84 { &vop_lookup_desc, spec_lookup }, /* lookup */ 85 { &vop_create_desc, spec_create }, /* create */ 86 { &vop_mknod_desc, spec_mknod }, /* mknod */ 87 { &vop_open_desc, spec_open }, /* open */ 88 { &vop_close_desc, spec_close }, /* close */ 89 { &vop_access_desc, spec_access }, /* access */ 90 { &vop_getattr_desc, spec_getattr }, /* getattr */ 91 { &vop_setattr_desc, spec_setattr }, /* setattr */ 92 { &vop_read_desc, spec_read }, /* read */ 93 { &vop_write_desc, spec_write }, /* write */ 94 { &vop_lease_desc, spec_lease_check }, /* lease */ 95 { &vop_fcntl_desc, spec_fcntl }, /* fcntl */ 96 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ 97 { &vop_poll_desc, spec_poll }, /* poll */ 98 { &vop_kqfilter_desc, spec_kqfilter }, /* kqfilter */ 99 { &vop_revoke_desc, spec_revoke }, /* revoke */ 100 { &vop_mmap_desc, spec_mmap }, /* mmap */ 101 { &vop_fsync_desc, spec_fsync }, /* fsync */ 102 { &vop_seek_desc, spec_seek }, /* seek */ 103 { &vop_remove_desc, spec_remove }, /* remove */ 104 { &vop_link_desc, spec_link }, /* link */ 105 { &vop_rename_desc, spec_rename }, /* rename */ 106 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */ 107 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */ 108 { &vop_symlink_desc, spec_symlink }, /* symlink */ 109 { &vop_readdir_desc, spec_readdir }, /* readdir */ 110 { &vop_readlink_desc, spec_readlink }, /* readlink */ 111 { &vop_abortop_desc, spec_abortop }, /* abortop */ 112 { &vop_inactive_desc, spec_inactive }, /* inactive */ 113 { &vop_reclaim_desc, spec_reclaim }, /* reclaim */ 114 { &vop_lock_desc, spec_lock }, /* lock */ 115 { &vop_unlock_desc, spec_unlock }, /* unlock */ 116 { &vop_bmap_desc, spec_bmap }, /* bmap */ 117 { &vop_strategy_desc, spec_strategy }, /* strategy */ 118 { &vop_print_desc, spec_print }, /* print */ 119 { &vop_islocked_desc, spec_islocked }, /* islocked */ 120 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ 121 { &vop_advlock_desc, spec_advlock }, /* advlock */ 122 { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */ 123 { &vop_valloc_desc, spec_valloc }, /* valloc */ 124 { &vop_vfree_desc, spec_vfree }, /* vfree */ 125 { &vop_truncate_desc, spec_truncate }, /* truncate */ 126 { &vop_update_desc, spec_update }, /* update */ 127 { &vop_bwrite_desc, spec_bwrite }, /* bwrite */ 128 { &vop_getpages_desc, spec_getpages }, /* getpages */ 129 { &vop_putpages_desc, spec_putpages }, /* putpages */ 130 { NULL, NULL } 131 }; 132 const struct vnodeopv_desc spec_vnodeop_opv_desc = 133 { &spec_vnodeop_p, spec_vnodeop_entries }; 134 135 /* 136 * Trivial lookup routine that always fails. 137 */ 138 int 139 spec_lookup(v) 140 void *v; 141 { 142 struct vop_lookup_args /* { 143 struct vnode *a_dvp; 144 struct vnode **a_vpp; 145 struct componentname *a_cnp; 146 } */ *ap = v; 147 148 *ap->a_vpp = NULL; 149 return (ENOTDIR); 150 } 151 152 /* 153 * Open a special file. 154 */ 155 /* ARGSUSED */ 156 int 157 spec_open(v) 158 void *v; 159 { 160 struct vop_open_args /* { 161 struct vnode *a_vp; 162 int a_mode; 163 struct ucred *a_cred; 164 struct proc *a_p; 165 } */ *ap = v; 166 struct proc *p = ap->a_p; 167 struct vnode *bvp, *vp = ap->a_vp; 168 const struct bdevsw *bdev; 169 const struct cdevsw *cdev; 170 dev_t blkdev, dev = (dev_t)vp->v_rdev; 171 int error; 172 struct partinfo pi; 173 174 /* 175 * Don't allow open if fs is mounted -nodev. 176 */ 177 if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV)) 178 return (ENXIO); 179 180 switch (vp->v_type) { 181 182 case VCHR: 183 cdev = cdevsw_lookup(dev); 184 if (cdev == NULL) 185 return (ENXIO); 186 if (ap->a_cred != FSCRED && (ap->a_mode & FWRITE)) { 187 /* 188 * When running in very secure mode, do not allow 189 * opens for writing of any disk character devices. 190 */ 191 if (securelevel >= 2 && cdev->d_type == D_DISK) 192 return (EPERM); 193 /* 194 * When running in secure mode, do not allow opens 195 * for writing of /dev/mem, /dev/kmem, or character 196 * devices whose corresponding block devices are 197 * currently mounted. 198 */ 199 if (securelevel >= 1) { 200 blkdev = devsw_chr2blk(dev); 201 if (blkdev != (dev_t)NODEV && 202 vfinddev(blkdev, VBLK, &bvp) && 203 (error = vfs_mountedon(bvp))) 204 return (error); 205 if (iskmemdev(dev)) 206 return (EPERM); 207 } 208 } 209 if (cdev->d_type == D_TTY) 210 vp->v_flag |= VISTTY; 211 VOP_UNLOCK(vp, 0); 212 error = (*cdev->d_open)(dev, ap->a_mode, S_IFCHR, p); 213 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 214 return (error); 215 216 case VBLK: 217 bdev = bdevsw_lookup(dev); 218 if (bdev == NULL) 219 return (ENXIO); 220 /* 221 * When running in very secure mode, do not allow 222 * opens for writing of any disk block devices. 223 */ 224 if (securelevel >= 2 && ap->a_cred != FSCRED && 225 (ap->a_mode & FWRITE) && bdev->d_type == D_DISK) 226 return (EPERM); 227 /* 228 * Do not allow opens of block devices that are 229 * currently mounted. 230 */ 231 if ((error = vfs_mountedon(vp)) != 0) 232 return (error); 233 error = (*bdev->d_open)(dev, ap->a_mode, S_IFBLK, p); 234 if (error) { 235 return error; 236 } 237 error = (*bdev->d_ioctl)(vp->v_rdev, 238 DIOCGPART, (caddr_t)&pi, FREAD, curproc); 239 if (error == 0) { 240 vp->v_size = (voff_t)pi.disklab->d_secsize * 241 pi.part->p_size; 242 } 243 return 0; 244 245 case VNON: 246 case VLNK: 247 case VDIR: 248 case VREG: 249 case VBAD: 250 case VFIFO: 251 case VSOCK: 252 break; 253 } 254 return (0); 255 } 256 257 /* 258 * Vnode op for read 259 */ 260 /* ARGSUSED */ 261 int 262 spec_read(v) 263 void *v; 264 { 265 struct vop_read_args /* { 266 struct vnode *a_vp; 267 struct uio *a_uio; 268 int a_ioflag; 269 struct ucred *a_cred; 270 } */ *ap = v; 271 struct vnode *vp = ap->a_vp; 272 struct uio *uio = ap->a_uio; 273 struct proc *p = uio->uio_procp; 274 struct buf *bp; 275 const struct bdevsw *bdev; 276 const struct cdevsw *cdev; 277 daddr_t bn; 278 int bsize, bscale; 279 struct partinfo dpart; 280 int n, on; 281 int error = 0; 282 283 #ifdef DIAGNOSTIC 284 if (uio->uio_rw != UIO_READ) 285 panic("spec_read mode"); 286 if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) 287 panic("spec_read proc"); 288 #endif 289 if (uio->uio_resid == 0) 290 return (0); 291 292 switch (vp->v_type) { 293 294 case VCHR: 295 VOP_UNLOCK(vp, 0); 296 cdev = cdevsw_lookup(vp->v_rdev); 297 if (cdev != NULL) 298 error = (*cdev->d_read)(vp->v_rdev, uio, ap->a_ioflag); 299 else 300 error = ENXIO; 301 vn_lock(vp, LK_SHARED | LK_RETRY); 302 return (error); 303 304 case VBLK: 305 if (uio->uio_offset < 0) 306 return (EINVAL); 307 bsize = BLKDEV_IOSIZE; 308 bdev = bdevsw_lookup(vp->v_rdev); 309 if (bdev != NULL && 310 (*bdev->d_ioctl)(vp->v_rdev, DIOCGPART, (caddr_t)&dpart, 311 FREAD, p) == 0) { 312 if (dpart.part->p_fstype == FS_BSDFFS && 313 dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) 314 bsize = dpart.part->p_frag * 315 dpart.part->p_fsize; 316 } 317 bscale = bsize >> DEV_BSHIFT; 318 do { 319 bn = (uio->uio_offset >> DEV_BSHIFT) &~ (bscale - 1); 320 on = uio->uio_offset % bsize; 321 n = min((unsigned)(bsize - on), uio->uio_resid); 322 error = bread(vp, bn, bsize, NOCRED, &bp); 323 n = min(n, bsize - bp->b_resid); 324 if (error) { 325 brelse(bp); 326 return (error); 327 } 328 error = uiomove((char *)bp->b_data + on, n, uio); 329 brelse(bp); 330 } while (error == 0 && uio->uio_resid > 0 && n != 0); 331 return (error); 332 333 default: 334 panic("spec_read type"); 335 } 336 /* NOTREACHED */ 337 } 338 339 /* 340 * Vnode op for write 341 */ 342 /* ARGSUSED */ 343 int 344 spec_write(v) 345 void *v; 346 { 347 struct vop_write_args /* { 348 struct vnode *a_vp; 349 struct uio *a_uio; 350 int a_ioflag; 351 struct ucred *a_cred; 352 } */ *ap = v; 353 struct vnode *vp = ap->a_vp; 354 struct uio *uio = ap->a_uio; 355 struct proc *p = uio->uio_procp; 356 struct buf *bp; 357 const struct bdevsw *bdev; 358 const struct cdevsw *cdev; 359 daddr_t bn; 360 int bsize, bscale; 361 struct partinfo dpart; 362 int n, on; 363 int error = 0; 364 365 #ifdef DIAGNOSTIC 366 if (uio->uio_rw != UIO_WRITE) 367 panic("spec_write mode"); 368 if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) 369 panic("spec_write proc"); 370 #endif 371 372 switch (vp->v_type) { 373 374 case VCHR: 375 VOP_UNLOCK(vp, 0); 376 cdev = cdevsw_lookup(vp->v_rdev); 377 if (cdev != NULL) 378 error = (*cdev->d_write)(vp->v_rdev, uio, ap->a_ioflag); 379 else 380 error = ENXIO; 381 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 382 return (error); 383 384 case VBLK: 385 if (uio->uio_resid == 0) 386 return (0); 387 if (uio->uio_offset < 0) 388 return (EINVAL); 389 bsize = BLKDEV_IOSIZE; 390 bdev = bdevsw_lookup(vp->v_rdev); 391 if (bdev != NULL && 392 (*bdev->d_ioctl)(vp->v_rdev, DIOCGPART, (caddr_t)&dpart, 393 FREAD, p) == 0) { 394 if (dpart.part->p_fstype == FS_BSDFFS && 395 dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) 396 bsize = dpart.part->p_frag * 397 dpart.part->p_fsize; 398 } 399 bscale = bsize >> DEV_BSHIFT; 400 do { 401 bn = (uio->uio_offset >> DEV_BSHIFT) &~ (bscale - 1); 402 on = uio->uio_offset % bsize; 403 n = min((unsigned)(bsize - on), uio->uio_resid); 404 if (n == bsize) 405 bp = getblk(vp, bn, bsize, 0, 0); 406 else 407 error = bread(vp, bn, bsize, NOCRED, &bp); 408 if (error) { 409 brelse(bp); 410 return (error); 411 } 412 n = min(n, bsize - bp->b_resid); 413 error = uiomove((char *)bp->b_data + on, n, uio); 414 if (error) 415 brelse(bp); 416 else { 417 if (n + on == bsize) 418 bawrite(bp); 419 else 420 bdwrite(bp); 421 if (bp->b_flags & B_ERROR) 422 error = bp->b_error; 423 } 424 } while (error == 0 && uio->uio_resid > 0 && n != 0); 425 return (error); 426 427 default: 428 panic("spec_write type"); 429 } 430 /* NOTREACHED */ 431 } 432 433 /* 434 * Device ioctl operation. 435 */ 436 /* ARGSUSED */ 437 int 438 spec_ioctl(v) 439 void *v; 440 { 441 struct vop_ioctl_args /* { 442 struct vnode *a_vp; 443 u_long a_command; 444 caddr_t a_data; 445 int a_fflag; 446 struct ucred *a_cred; 447 struct proc *a_p; 448 } */ *ap = v; 449 const struct bdevsw *bdev; 450 const struct cdevsw *cdev; 451 dev_t dev = ap->a_vp->v_rdev; 452 453 switch (ap->a_vp->v_type) { 454 455 case VCHR: 456 cdev = cdevsw_lookup(dev); 457 if (cdev == NULL) 458 return (ENXIO); 459 return ((*cdev->d_ioctl)(dev, ap->a_command, ap->a_data, 460 ap->a_fflag, ap->a_p)); 461 462 case VBLK: 463 bdev = bdevsw_lookup(dev); 464 if (bdev == NULL) 465 return (ENXIO); 466 if (ap->a_command == 0 && (long)ap->a_data == B_TAPE) { 467 if (bdev->d_type == D_TAPE) 468 return (0); 469 else 470 return (1); 471 } 472 return ((*bdev->d_ioctl)(dev, ap->a_command, ap->a_data, 473 ap->a_fflag, ap->a_p)); 474 475 default: 476 panic("spec_ioctl"); 477 /* NOTREACHED */ 478 } 479 } 480 481 /* ARGSUSED */ 482 int 483 spec_poll(v) 484 void *v; 485 { 486 struct vop_poll_args /* { 487 struct vnode *a_vp; 488 int a_events; 489 struct proc *a_p; 490 } */ *ap = v; 491 const struct cdevsw *cdev; 492 dev_t dev; 493 494 switch (ap->a_vp->v_type) { 495 496 case VCHR: 497 dev = ap->a_vp->v_rdev; 498 cdev = cdevsw_lookup(dev); 499 if (cdev == NULL) 500 return (ENXIO); 501 return (*cdev->d_poll)(dev, ap->a_events, ap->a_p); 502 503 default: 504 return (genfs_poll(v)); 505 } 506 } 507 508 /* ARGSUSED */ 509 int 510 spec_kqfilter(v) 511 void *v; 512 { 513 struct vop_kqfilter_args /* { 514 struct vnode *a_vp; 515 struct proc *a_kn; 516 } */ *ap = v; 517 const struct cdevsw *cdev; 518 dev_t dev; 519 520 switch (ap->a_vp->v_type) { 521 522 case VCHR: 523 dev = ap->a_vp->v_rdev; 524 cdev = cdevsw_lookup(dev); 525 if (cdev == NULL) 526 return (ENXIO); 527 return (*cdev->d_kqfilter)(dev, ap->a_kn); 528 default: 529 /* 530 * Block devices don't support kqfilter, and refuse it 531 * for any other files (like those vflush()ed) too. 532 */ 533 return (EOPNOTSUPP); 534 } 535 } 536 537 /* 538 * Synch buffers associated with a block device 539 */ 540 /* ARGSUSED */ 541 int 542 spec_fsync(v) 543 void *v; 544 { 545 struct vop_fsync_args /* { 546 struct vnode *a_vp; 547 struct ucred *a_cred; 548 int a_flags; 549 off_t offlo; 550 off_t offhi; 551 struct proc *a_p; 552 } */ *ap = v; 553 struct vnode *vp = ap->a_vp; 554 555 if (vp->v_type == VBLK) 556 vflushbuf(vp, (ap->a_flags & FSYNC_WAIT) != 0); 557 return (0); 558 } 559 560 /* 561 * Just call the device strategy routine 562 */ 563 int 564 spec_strategy(v) 565 void *v; 566 { 567 struct vop_strategy_args /* { 568 struct buf *a_bp; 569 } */ *ap = v; 570 struct buf *bp; 571 const struct bdevsw *bdev; 572 573 bp = ap->a_bp; 574 if (!(bp->b_flags & B_READ) && 575 (LIST_FIRST(&bp->b_dep)) != NULL && bioops.io_start) 576 (*bioops.io_start)(bp); 577 bdev = bdevsw_lookup(bp->b_dev); 578 if (bdev != NULL) 579 (*bdev->d_strategy)(bp); 580 return (0); 581 } 582 583 int 584 spec_inactive(v) 585 void *v; 586 { 587 struct vop_inactive_args /* { 588 struct vnode *a_vp; 589 struct proc *a_p; 590 } */ *ap = v; 591 592 VOP_UNLOCK(ap->a_vp, 0); 593 return (0); 594 } 595 596 /* 597 * This is a noop, simply returning what one has been given. 598 */ 599 int 600 spec_bmap(v) 601 void *v; 602 { 603 struct vop_bmap_args /* { 604 struct vnode *a_vp; 605 daddr_t a_bn; 606 struct vnode **a_vpp; 607 daddr_t *a_bnp; 608 int *a_runp; 609 } */ *ap = v; 610 611 if (ap->a_vpp != NULL) 612 *ap->a_vpp = ap->a_vp; 613 if (ap->a_bnp != NULL) 614 *ap->a_bnp = ap->a_bn; 615 if (ap->a_runp != NULL) 616 *ap->a_runp = (MAXBSIZE >> DEV_BSHIFT) - 1; 617 return (0); 618 } 619 620 /* 621 * Device close routine 622 */ 623 /* ARGSUSED */ 624 int 625 spec_close(v) 626 void *v; 627 { 628 struct vop_close_args /* { 629 struct vnode *a_vp; 630 int a_fflag; 631 struct ucred *a_cred; 632 struct proc *a_p; 633 } */ *ap = v; 634 struct vnode *vp = ap->a_vp; 635 const struct bdevsw *bdev; 636 const struct cdevsw *cdev; 637 dev_t dev = vp->v_rdev; 638 int (*devclose) __P((dev_t, int, int, struct proc *)); 639 int mode, error, count, flags, flags1; 640 641 count = vcount(vp); 642 simple_lock(&vp->v_interlock); 643 flags = vp->v_flag; 644 simple_unlock(&vp->v_interlock); 645 646 switch (vp->v_type) { 647 648 case VCHR: 649 /* 650 * Hack: a tty device that is a controlling terminal 651 * has a reference from the session structure. 652 * We cannot easily tell that a character device is 653 * a controlling terminal, unless it is the closing 654 * process' controlling terminal. In that case, 655 * if the reference count is 2 (this last descriptor 656 * plus the session), release the reference from the session. 657 */ 658 if (count == 2 && ap->a_p && 659 vp == ap->a_p->p_session->s_ttyvp) { 660 vrele(vp); 661 count--; 662 ap->a_p->p_session->s_ttyvp = NULL; 663 } 664 /* 665 * If the vnode is locked, then we are in the midst 666 * of forcably closing the device, otherwise we only 667 * close on last reference. 668 */ 669 if (count > 1 && (flags & VXLOCK) == 0) 670 return (0); 671 cdev = cdevsw_lookup(dev); 672 if (cdev != NULL) 673 devclose = cdev->d_close; 674 else 675 devclose = NULL; 676 mode = S_IFCHR; 677 break; 678 679 case VBLK: 680 /* 681 * On last close of a block device (that isn't mounted) 682 * we must invalidate any in core blocks, so that 683 * we can, for instance, change floppy disks. 684 */ 685 error = vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_p, 0, 0); 686 if (error) 687 return (error); 688 /* 689 * We do not want to really close the device if it 690 * is still in use unless we are trying to close it 691 * forcibly. Since every use (buffer, vnode, swap, cmap) 692 * holds a reference to the vnode, and because we mark 693 * any other vnodes that alias this device, when the 694 * sum of the reference counts on all the aliased 695 * vnodes descends to one, we are on last close. 696 */ 697 if (count > 1 && (flags & VXLOCK) == 0) 698 return (0); 699 bdev = bdevsw_lookup(dev); 700 if (bdev != NULL) 701 devclose = bdev->d_close; 702 else 703 devclose = NULL; 704 mode = S_IFBLK; 705 break; 706 707 default: 708 panic("spec_close: not special"); 709 } 710 711 flags1 = ap->a_fflag; 712 713 /* 714 * if VXLOCK is set, then we're going away soon, so make this 715 * non-blocking. Also ensures that we won't wedge in vn_lock below. 716 */ 717 if (flags & VXLOCK) 718 flags1 |= FNONBLOCK; 719 720 /* 721 * If we're able to block, release the vnode lock & reacquire. We 722 * might end up sleaping for someone else who wants our queues. They 723 * won't get them if we hold the vnode locked. Also, if VXLOCK is set, 724 * don't release the lock as we won't be able to regain it. 725 */ 726 if (!(flags1 & FNONBLOCK)) 727 VOP_UNLOCK(vp, 0); 728 729 if (devclose != NULL) 730 error = (*devclose)(dev, flags1, mode, ap->a_p); 731 else 732 error = ENXIO; 733 734 if (!(flags1 & FNONBLOCK)) 735 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 736 737 return (error); 738 } 739 740 /* 741 * Print out the contents of a special device vnode. 742 */ 743 int 744 spec_print(v) 745 void *v; 746 { 747 struct vop_print_args /* { 748 struct vnode *a_vp; 749 } */ *ap = v; 750 751 printf("tag VT_NON, dev %d, %d\n", major(ap->a_vp->v_rdev), 752 minor(ap->a_vp->v_rdev)); 753 return 0; 754 } 755 756 /* 757 * Return POSIX pathconf information applicable to special devices. 758 */ 759 int 760 spec_pathconf(v) 761 void *v; 762 { 763 struct vop_pathconf_args /* { 764 struct vnode *a_vp; 765 int a_name; 766 register_t *a_retval; 767 } */ *ap = v; 768 769 switch (ap->a_name) { 770 case _PC_LINK_MAX: 771 *ap->a_retval = LINK_MAX; 772 return (0); 773 case _PC_MAX_CANON: 774 *ap->a_retval = MAX_CANON; 775 return (0); 776 case _PC_MAX_INPUT: 777 *ap->a_retval = MAX_INPUT; 778 return (0); 779 case _PC_PIPE_BUF: 780 *ap->a_retval = PIPE_BUF; 781 return (0); 782 case _PC_CHOWN_RESTRICTED: 783 *ap->a_retval = 1; 784 return (0); 785 case _PC_VDISABLE: 786 *ap->a_retval = _POSIX_VDISABLE; 787 return (0); 788 case _PC_SYNC_IO: 789 *ap->a_retval = 1; 790 return (0); 791 default: 792 return (EINVAL); 793 } 794 /* NOTREACHED */ 795 } 796 797 /* 798 * Advisory record locking support. 799 */ 800 int 801 spec_advlock(v) 802 void *v; 803 { 804 struct vop_advlock_args /* { 805 struct vnode *a_vp; 806 caddr_t a_id; 807 int a_op; 808 struct flock *a_fl; 809 int a_flags; 810 } */ *ap = v; 811 struct vnode *vp = ap->a_vp; 812 813 return lf_advlock(ap, &vp->v_speclockf, (off_t)0); 814 } 815
Indexes created Tue Sep 23 22:09:46 GMT 2025