1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * %sccs.include.redist.c% 6 * 7 * @(#)spec_vnops.c 7.53 (Berkeley) 04/28/93 8 */ 9 10 #include <sys/param.h> 11 #include <sys/proc.h> 12 #include <sys/systm.h> 13 #include <sys/kernel.h> 14 #include <sys/conf.h> 15 #include <sys/buf.h> 16 #include <sys/mount.h> 17 #include <sys/namei.h> 18 #include <sys/vnode.h> 19 #include <sys/stat.h> 20 #include <sys/errno.h> 21 #include <sys/ioctl.h> 22 #include <sys/file.h> 23 #include <sys/disklabel.h> 24 #include <miscfs/specfs/specdev.h> 25 26 /* symbolic sleep message strings for devices */ 27 char devopn[] = "devopn"; 28 char devio[] = "devio"; 29 char devwait[] = "devwait"; 30 char devin[] = "devin"; 31 char devout[] = "devout"; 32 char devioc[] = "devioc"; 33 char devcls[] = "devcls"; 34 35 int (**spec_vnodeop_p)(); 36 struct vnodeopv_entry_desc spec_vnodeop_entries[] = { 37 { &vop_default_desc, vn_default_error }, 38 { &vop_lookup_desc, spec_lookup }, /* lookup */ 39 { &vop_create_desc, spec_create }, /* create */ 40 { &vop_mknod_desc, spec_mknod }, /* mknod */ 41 { &vop_open_desc, spec_open }, /* open */ 42 { &vop_close_desc, spec_close }, /* close */ 43 { &vop_access_desc, spec_access }, /* access */ 44 { &vop_getattr_desc, spec_getattr }, /* getattr */ 45 { &vop_setattr_desc, spec_setattr }, /* setattr */ 46 { &vop_read_desc, spec_read }, /* read */ 47 { &vop_write_desc, spec_write }, /* write */ 48 { &vop_ioctl_desc, spec_ioctl }, /* ioctl */ 49 { &vop_select_desc, spec_select }, /* select */ 50 { &vop_mmap_desc, spec_mmap }, /* mmap */ 51 { &vop_fsync_desc, spec_fsync }, /* fsync */ 52 { &vop_seek_desc, spec_seek }, /* seek */ 53 { &vop_remove_desc, spec_remove }, /* remove */ 54 { &vop_link_desc, spec_link }, /* link */ 55 { &vop_rename_desc, spec_rename }, /* rename */ 56 { &vop_mkdir_desc, spec_mkdir }, /* mkdir */ 57 { &vop_rmdir_desc, spec_rmdir }, /* rmdir */ 58 { &vop_symlink_desc, spec_symlink }, /* symlink */ 59 { &vop_readdir_desc, spec_readdir }, /* readdir */ 60 { &vop_readlink_desc, spec_readlink }, /* readlink */ 61 { &vop_abortop_desc, spec_abortop }, /* abortop */ 62 { &vop_inactive_desc, spec_inactive }, /* inactive */ 63 { &vop_reclaim_desc, spec_reclaim }, /* reclaim */ 64 { &vop_lock_desc, spec_lock }, /* lock */ 65 { &vop_unlock_desc, spec_unlock }, /* unlock */ 66 { &vop_bmap_desc, spec_bmap }, /* bmap */ 67 { &vop_strategy_desc, spec_strategy }, /* strategy */ 68 { &vop_print_desc, spec_print }, /* print */ 69 { &vop_islocked_desc, spec_islocked }, /* islocked */ 70 { &vop_advlock_desc, spec_advlock }, /* advlock */ 71 { &vop_blkatoff_desc, spec_blkatoff }, /* blkatoff */ 72 { &vop_valloc_desc, spec_valloc }, /* valloc */ 73 { &vop_vfree_desc, spec_vfree }, /* vfree */ 74 { &vop_truncate_desc, spec_truncate }, /* truncate */ 75 { &vop_update_desc, spec_update }, /* update */ 76 { &vop_bwrite_desc, spec_bwrite }, /* bwrite */ 77 { (struct vnodeop_desc*)NULL, (int(*)())NULL } 78 }; 79 struct vnodeopv_desc spec_vnodeop_opv_desc = 80 { &spec_vnodeop_p, spec_vnodeop_entries }; 81 82 /* 83 * Trivial lookup routine that always fails. 84 */ 85 int 86 spec_lookup(ap) 87 struct vop_lookup_args /* { 88 struct vnode *a_dvp; 89 struct vnode **a_vpp; 90 struct componentname *a_cnp; 91 } */ *ap; 92 { 93 94 *ap->a_vpp = NULL; 95 return (ENOTDIR); 96 } 97 98 /* 99 * Open a special file. 100 */ 101 /* ARGSUSED */ 102 spec_open(ap) 103 struct vop_open_args /* { 104 struct vnode *a_vp; 105 int a_mode; 106 struct ucred *a_cred; 107 struct proc *a_p; 108 } */ *ap; 109 { 110 struct vnode *bvp, *vp = ap->a_vp; 111 dev_t bdev, dev = (dev_t)vp->v_rdev; 112 register int maj = major(dev); 113 int error; 114 115 /* 116 * Don't allow open if fs is mounted -nodev. 117 */ 118 if (vp->v_mount && (vp->v_mount->mnt_flag & MNT_NODEV)) 119 return (ENXIO); 120 121 switch (vp->v_type) { 122 123 case VCHR: 124 if ((u_int)maj >= nchrdev) 125 return (ENXIO); 126 if (ap->a_cred != FSCRED && (ap->a_mode & FWRITE)) { 127 /* 128 * When running in very secure mode, do not allow 129 * opens for writing of any disk character devices. 130 */ 131 if (securelevel >= 2 && isdisk(dev, VCHR)) 132 return (EPERM); 133 /* 134 * When running in secure mode, do not allow opens 135 * for writing of /dev/mem, /dev/kmem, or character 136 * devices whose corresponding block devices are 137 * currently mounted. 138 */ 139 if (securelevel >= 1) { 140 if ((bdev = chrtoblk(dev)) != NODEV && 141 vfinddev(bdev, VBLK, &bvp) && 142 bvp->v_usecount > 0 && 143 (error = ufs_mountedon(bvp))) 144 return (error); 145 if (iskmemdev(dev)) 146 return (EPERM); 147 } 148 } 149 VOP_UNLOCK(vp); 150 error = (*cdevsw[maj].d_open)(dev, ap->a_mode, S_IFCHR, ap->a_p); 151 VOP_LOCK(vp); 152 return (error); 153 154 case VBLK: 155 if ((u_int)maj >= nblkdev) 156 return (ENXIO); 157 /* 158 * When running in very secure mode, do not allow 159 * opens for writing of any disk block devices. 160 */ 161 if (securelevel >= 2 && ap->a_cred != FSCRED && 162 (ap->a_mode & FWRITE) && isdisk(dev, VBLK)) 163 return (EPERM); 164 /* 165 * Do not allow opens of block devices that are 166 * currently mounted. 167 */ 168 if (error = ufs_mountedon(vp)) 169 return (error); 170 return ((*bdevsw[maj].d_open)(dev, ap->a_mode, S_IFBLK, ap->a_p)); 171 } 172 return (0); 173 } 174 175 /* 176 * Vnode op for read 177 */ 178 /* ARGSUSED */ 179 spec_read(ap) 180 struct vop_read_args /* { 181 struct vnode *a_vp; 182 struct uio *a_uio; 183 int a_ioflag; 184 struct ucred *a_cred; 185 } */ *ap; 186 { 187 register struct vnode *vp = ap->a_vp; 188 register struct uio *uio = ap->a_uio; 189 struct proc *p = uio->uio_procp; 190 struct buf *bp; 191 daddr_t bn, nextbn; 192 long bsize, bscale; 193 struct partinfo dpart; 194 register int n, on; 195 int error = 0; 196 197 #ifdef DIAGNOSTIC 198 if (uio->uio_rw != UIO_READ) 199 panic("spec_read mode"); 200 if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) 201 panic("spec_read proc"); 202 #endif 203 if (uio->uio_resid == 0) 204 return (0); 205 206 switch (vp->v_type) { 207 208 case VCHR: 209 VOP_UNLOCK(vp); 210 error = (*cdevsw[major(vp->v_rdev)].d_read) 211 (vp->v_rdev, uio, ap->a_ioflag); 212 VOP_LOCK(vp); 213 return (error); 214 215 case VBLK: 216 if (uio->uio_offset < 0) 217 return (EINVAL); 218 bsize = BLKDEV_IOSIZE; 219 if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART, 220 (caddr_t)&dpart, FREAD, p) == 0) { 221 if (dpart.part->p_fstype == FS_BSDFFS && 222 dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) 223 bsize = dpart.part->p_frag * 224 dpart.part->p_fsize; 225 } 226 bscale = bsize / DEV_BSIZE; 227 do { 228 bn = (uio->uio_offset / DEV_BSIZE) &~ (bscale - 1); 229 on = uio->uio_offset % bsize; 230 n = min((unsigned)(bsize - on), uio->uio_resid); 231 if (vp->v_lastr + bscale == bn) { 232 nextbn = bn + bscale; 233 error = breadn(vp, bn, (int)bsize, &nextbn, 234 (int *)&bsize, 1, NOCRED, &bp); 235 } else 236 error = bread(vp, bn, (int)bsize, NOCRED, &bp); 237 vp->v_lastr = bn; 238 n = min(n, bsize - bp->b_resid); 239 if (error) { 240 brelse(bp); 241 return (error); 242 } 243 error = uiomove(bp->b_un.b_addr + on, n, uio); 244 if (n + on == bsize) 245 bp->b_flags |= B_AGE; 246 brelse(bp); 247 } while (error == 0 && uio->uio_resid > 0 && n != 0); 248 return (error); 249 250 default: 251 panic("spec_read type"); 252 } 253 /* NOTREACHED */ 254 } 255 256 /* 257 * Vnode op for write 258 */ 259 /* ARGSUSED */ 260 spec_write(ap) 261 struct vop_write_args /* { 262 struct vnode *a_vp; 263 struct uio *a_uio; 264 int a_ioflag; 265 struct ucred *a_cred; 266 } */ *ap; 267 { 268 register struct vnode *vp = ap->a_vp; 269 register struct uio *uio = ap->a_uio; 270 struct proc *p = uio->uio_procp; 271 struct buf *bp; 272 daddr_t bn; 273 int bsize, blkmask; 274 struct partinfo dpart; 275 register int n, on; 276 int error = 0; 277 278 #ifdef DIAGNOSTIC 279 if (uio->uio_rw != UIO_WRITE) 280 panic("spec_write mode"); 281 if (uio->uio_segflg == UIO_USERSPACE && uio->uio_procp != curproc) 282 panic("spec_write proc"); 283 #endif 284 285 switch (vp->v_type) { 286 287 case VCHR: 288 VOP_UNLOCK(vp); 289 error = (*cdevsw[major(vp->v_rdev)].d_write) 290 (vp->v_rdev, uio, ap->a_ioflag); 291 VOP_LOCK(vp); 292 return (error); 293 294 case VBLK: 295 if (uio->uio_resid == 0) 296 return (0); 297 if (uio->uio_offset < 0) 298 return (EINVAL); 299 bsize = BLKDEV_IOSIZE; 300 if ((*bdevsw[major(vp->v_rdev)].d_ioctl)(vp->v_rdev, DIOCGPART, 301 (caddr_t)&dpart, FREAD, p) == 0) { 302 if (dpart.part->p_fstype == FS_BSDFFS && 303 dpart.part->p_frag != 0 && dpart.part->p_fsize != 0) 304 bsize = dpart.part->p_frag * 305 dpart.part->p_fsize; 306 } 307 blkmask = (bsize / DEV_BSIZE) - 1; 308 do { 309 bn = (uio->uio_offset / DEV_BSIZE) &~ blkmask; 310 on = uio->uio_offset % bsize; 311 n = min((unsigned)(bsize - on), uio->uio_resid); 312 if (n == bsize) 313 bp = getblk(vp, bn, bsize, 0, 0); 314 else 315 error = bread(vp, bn, bsize, NOCRED, &bp); 316 n = min(n, bsize - bp->b_resid); 317 if (error) { 318 brelse(bp); 319 return (error); 320 } 321 error = uiomove(bp->b_un.b_addr + on, n, uio); 322 if (n + on == bsize) { 323 bp->b_flags |= B_AGE; 324 bawrite(bp); 325 } else 326 bdwrite(bp); 327 } while (error == 0 && uio->uio_resid > 0 && n != 0); 328 return (error); 329 330 default: 331 panic("spec_write type"); 332 } 333 /* NOTREACHED */ 334 } 335 336 /* 337 * Device ioctl operation. 338 */ 339 /* ARGSUSED */ 340 spec_ioctl(ap) 341 struct vop_ioctl_args /* { 342 struct vnode *a_vp; 343 int a_command; 344 caddr_t a_data; 345 int a_fflag; 346 struct ucred *a_cred; 347 struct proc *a_p; 348 } */ *ap; 349 { 350 dev_t dev = ap->a_vp->v_rdev; 351 352 switch (ap->a_vp->v_type) { 353 354 case VCHR: 355 return ((*cdevsw[major(dev)].d_ioctl)(dev, ap->a_command, ap->a_data, 356 ap->a_fflag, ap->a_p)); 357 358 case VBLK: 359 if (ap->a_command == 0 && (int)ap->a_data == B_TAPE) 360 if (bdevsw[major(dev)].d_flags & B_TAPE) 361 return (0); 362 else 363 return (1); 364 return ((*bdevsw[major(dev)].d_ioctl)(dev, ap->a_command, ap->a_data, 365 ap->a_fflag, ap->a_p)); 366 367 default: 368 panic("spec_ioctl"); 369 /* NOTREACHED */ 370 } 371 } 372 373 /* ARGSUSED */ 374 spec_select(ap) 375 struct vop_select_args /* { 376 struct vnode *a_vp; 377 int a_which; 378 int a_fflags; 379 struct ucred *a_cred; 380 struct proc *a_p; 381 } */ *ap; 382 { 383 register dev_t dev; 384 385 switch (ap->a_vp->v_type) { 386 387 default: 388 return (1); /* XXX */ 389 390 case VCHR: 391 dev = ap->a_vp->v_rdev; 392 return (*cdevsw[major(dev)].d_select)(dev, ap->a_which, ap->a_p); 393 } 394 } 395 /* 396 * Synch buffers associated with a block device 397 */ 398 /* ARGSUSED */ 399 int 400 spec_fsync(ap) 401 struct vop_fsync_args /* { 402 struct vnode *a_vp; 403 struct ucred *a_cred; 404 int a_waitfor; 405 struct proc *a_p; 406 } */ *ap; 407 { 408 register struct vnode *vp = ap->a_vp; 409 register struct buf *bp; 410 struct buf *nbp; 411 int s; 412 413 if (vp->v_type == VCHR) 414 return (0); 415 /* 416 * Flush all dirty buffers associated with a block device. 417 */ 418 loop: 419 s = splbio(); 420 for (bp = vp->v_dirtyblkhd.le_next; bp; bp = nbp) { 421 nbp = bp->b_vnbufs.qe_next; 422 if ((bp->b_flags & B_BUSY)) 423 continue; 424 if ((bp->b_flags & B_DELWRI) == 0) 425 panic("spec_fsync: not dirty"); 426 bremfree(bp); 427 bp->b_flags |= B_BUSY; 428 splx(s); 429 bawrite(bp); 430 goto loop; 431 } 432 if (ap->a_waitfor == MNT_WAIT) { 433 while (vp->v_numoutput) { 434 vp->v_flag |= VBWAIT; 435 sleep((caddr_t)&vp->v_numoutput, PRIBIO + 1); 436 } 437 #ifdef DIAGNOSTIC 438 if (vp->v_dirtyblkhd.le_next) { 439 vprint("spec_fsync: dirty", vp); 440 goto loop; 441 } 442 #endif 443 } 444 splx(s); 445 return (0); 446 } 447 448 /* 449 * Just call the device strategy routine 450 */ 451 spec_strategy(ap) 452 struct vop_strategy_args /* { 453 struct buf *a_bp; 454 } */ *ap; 455 { 456 457 (*bdevsw[major(ap->a_bp->b_dev)].d_strategy)(ap->a_bp); 458 return (0); 459 } 460 461 /* 462 * This is a noop, simply returning what one has been given. 463 */ 464 spec_bmap(ap) 465 struct vop_bmap_args /* { 466 struct vnode *a_vp; 467 daddr_t a_bn; 468 struct vnode **a_vpp; 469 daddr_t *a_bnp; 470 } */ *ap; 471 { 472 473 if (ap->a_vpp != NULL) 474 *ap->a_vpp = ap->a_vp; 475 if (ap->a_bnp != NULL) 476 *ap->a_bnp = ap->a_bn; 477 return (0); 478 } 479 480 /* 481 * At the moment we do not do any locking. 482 */ 483 /* ARGSUSED */ 484 spec_lock(ap) 485 struct vop_lock_args /* { 486 struct vnode *a_vp; 487 } */ *ap; 488 { 489 490 return (0); 491 } 492 493 /* ARGSUSED */ 494 spec_unlock(ap) 495 struct vop_unlock_args /* { 496 struct vnode *a_vp; 497 } */ *ap; 498 { 499 500 return (0); 501 } 502 503 /* 504 * Device close routine 505 */ 506 /* ARGSUSED */ 507 spec_close(ap) 508 struct vop_close_args /* { 509 struct vnode *a_vp; 510 int a_fflag; 511 struct ucred *a_cred; 512 struct proc *a_p; 513 } */ *ap; 514 { 515 register struct vnode *vp = ap->a_vp; 516 dev_t dev = vp->v_rdev; 517 int (*devclose) __P((dev_t, int, int, struct proc *)); 518 int mode, error; 519 520 switch (vp->v_type) { 521 522 case VCHR: 523 /* 524 * If the vnode is locked, then we are in the midst 525 * of forcably closing the device, otherwise we only 526 * close on last reference. 527 */ 528 if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0) 529 return (0); 530 devclose = cdevsw[major(dev)].d_close; 531 mode = S_IFCHR; 532 break; 533 534 case VBLK: 535 /* 536 * On last close of a block device (that isn't mounted) 537 * we must invalidate any in core blocks, so that 538 * we can, for instance, change floppy disks. 539 */ 540 if (error = vinvalbuf(vp, 1, ap->a_cred, ap->a_p, 0, 0)) 541 return (error); 542 /* 543 * We do not want to really close the device if it 544 * is still in use unless we are trying to close it 545 * forcibly. Since every use (buffer, vnode, swap, cmap) 546 * holds a reference to the vnode, and because we mark 547 * any other vnodes that alias this device, when the 548 * sum of the reference counts on all the aliased 549 * vnodes descends to one, we are on last close. 550 */ 551 if (vcount(vp) > 1 && (vp->v_flag & VXLOCK) == 0) 552 return (0); 553 devclose = bdevsw[major(dev)].d_close; 554 mode = S_IFBLK; 555 break; 556 557 default: 558 panic("spec_close: not special"); 559 } 560 561 return ((*devclose)(dev, ap->a_fflag, mode, ap->a_p)); 562 } 563 564 /* 565 * Print out the contents of a special device vnode. 566 */ 567 spec_print(ap) 568 struct vop_print_args /* { 569 struct vnode *a_vp; 570 } */ *ap; 571 { 572 573 printf("tag VT_NON, dev %d, %d\n", major(ap->a_vp->v_rdev), 574 minor(ap->a_vp->v_rdev)); 575 } 576 577 /* 578 * Special device advisory byte-level locks. 579 */ 580 /* ARGSUSED */ 581 spec_advlock(ap) 582 struct vop_advlock_args /* { 583 struct vnode *a_vp; 584 caddr_t a_id; 585 int a_op; 586 struct flock *a_fl; 587 int a_flags; 588 } */ *ap; 589 { 590 591 return (EOPNOTSUPP); 592 } 593 594 /* 595 * Special device failed operation 596 */ 597 spec_ebadf() 598 { 599 600 return (EBADF); 601 } 602 603 /* 604 * Special device bad operation 605 */ 606 spec_badop() 607 { 608 609 panic("spec_badop called"); 610 /* NOTREACHED */ 611 } 612