fdesc_vnops.c revision 1.1.1.2
1 /* 2 * Copyright (c) 1992, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software donated to Berkeley by 6 * Jan-Simon Pendry. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)fdesc_vnops.c 8.17 (Berkeley) 5/22/95 37 * 38 * $Id: fdesc_vnops.c,v 1.1.1.2 1998/03/01 02:13:12 fvdl Exp $ 39 */ 40 41 /* 42 * /dev/fd Filesystem 43 */ 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/types.h> 48 #include <sys/time.h> 49 #include <sys/proc.h> 50 #include <sys/kernel.h> /* boottime */ 51 #include <sys/resourcevar.h> 52 #include <sys/filedesc.h> 53 #include <sys/vnode.h> 54 #include <sys/malloc.h> 55 #include <sys/file.h> 56 #include <sys/stat.h> 57 #include <sys/mount.h> 58 #include <sys/namei.h> 59 #include <sys/buf.h> 60 #include <sys/dirent.h> 61 #include <miscfs/fdesc/fdesc.h> 62 63 #define cttyvp(p) ((p)->p_flag & P_CONTROLT ? (p)->p_session->s_ttyvp : NULL) 64 65 #define FDL_WANT 0x01 66 #define FDL_LOCKED 0x02 67 static int fdcache_lock; 68 69 dev_t devctty; 70 71 #if (FD_STDIN != FD_STDOUT-1) || (FD_STDOUT != FD_STDERR-1) 72 FD_STDIN, FD_STDOUT, FD_STDERR must be a sequence n, n+1, n+2 73 #endif 74 75 #define NFDCACHE 4 76 77 #define FD_NHASH(ix) \ 78 (&fdhashtbl[(ix) & fdhash]) 79 LIST_HEAD(fdhashhead, fdescnode) *fdhashtbl; 80 u_long fdhash; 81 82 /* 83 * Initialise cache headers 84 */ 85 fdesc_init(vfsp) 86 struct vfsconf *vfsp; 87 { 88 89 devctty = makedev(nchrdev, 0); 90 fdhashtbl = hashinit(NFDCACHE, M_CACHE, &fdhash); 91 } 92 93 int 94 fdesc_allocvp(ftype, ix, mp, vpp) 95 fdntype ftype; 96 int ix; 97 struct mount *mp; 98 struct vnode **vpp; 99 { 100 struct proc *p = curproc; /* XXX */ 101 struct fdhashhead *fc; 102 struct fdescnode *fd; 103 int error = 0; 104 105 fc = FD_NHASH(ix); 106 loop: 107 for (fd = fc->lh_first; fd != 0; fd = fd->fd_hash.le_next) { 108 if (fd->fd_ix == ix && fd->fd_vnode->v_mount == mp) { 109 if (vget(fd->fd_vnode, 0, p)) 110 goto loop; 111 *vpp = fd->fd_vnode; 112 return (error); 113 } 114 } 115 116 /* 117 * otherwise lock the array while we call getnewvnode 118 * since that can block. 119 */ 120 if (fdcache_lock & FDL_LOCKED) { 121 fdcache_lock |= FDL_WANT; 122 sleep((caddr_t) &fdcache_lock, PINOD); 123 goto loop; 124 } 125 fdcache_lock |= FDL_LOCKED; 126 127 error = getnewvnode(VT_FDESC, mp, fdesc_vnodeop_p, vpp); 128 if (error) 129 goto out; 130 MALLOC(fd, void *, sizeof(struct fdescnode), M_TEMP, M_WAITOK); 131 (*vpp)->v_data = fd; 132 fd->fd_vnode = *vpp; 133 fd->fd_type = ftype; 134 fd->fd_fd = -1; 135 fd->fd_link = 0; 136 fd->fd_ix = ix; 137 LIST_INSERT_HEAD(fc, fd, fd_hash); 138 139 out:; 140 fdcache_lock &= ~FDL_LOCKED; 141 142 if (fdcache_lock & FDL_WANT) { 143 fdcache_lock &= ~FDL_WANT; 144 wakeup((caddr_t) &fdcache_lock); 145 } 146 147 return (error); 148 } 149 150 /* 151 * vp is the current namei directory 152 * ndp is the name to locate in that directory... 153 */ 154 int 155 fdesc_lookup(ap) 156 struct vop_lookup_args /* { 157 struct vnode * a_dvp; 158 struct vnode ** a_vpp; 159 struct componentname * a_cnp; 160 } */ *ap; 161 { 162 struct vnode **vpp = ap->a_vpp; 163 struct vnode *dvp = ap->a_dvp; 164 struct componentname *cnp = ap->a_cnp; 165 char *pname = cnp->cn_nameptr; 166 struct proc *p = cnp->cn_proc; 167 int nfiles = p->p_fd->fd_nfiles; 168 unsigned fd; 169 int error; 170 struct vnode *fvp; 171 char *ln; 172 173 VOP_UNLOCK(dvp, 0, p); 174 if (cnp->cn_namelen == 1 && *pname == '.') { 175 *vpp = dvp; 176 VREF(dvp); 177 vn_lock(dvp, LK_SHARED | LK_RETRY, p); 178 return (0); 179 } 180 181 switch (VTOFDESC(dvp)->fd_type) { 182 default: 183 case Flink: 184 case Fdesc: 185 case Fctty: 186 error = ENOTDIR; 187 goto bad; 188 189 case Froot: 190 if (cnp->cn_namelen == 2 && bcmp(pname, "fd", 2) == 0) { 191 error = fdesc_allocvp(Fdevfd, FD_DEVFD, dvp->v_mount, &fvp); 192 if (error) 193 goto bad; 194 *vpp = fvp; 195 fvp->v_type = VDIR; 196 vn_lock(fvp, LK_SHARED | LK_RETRY, p); 197 return (0); 198 } 199 200 if (cnp->cn_namelen == 3 && bcmp(pname, "tty", 3) == 0) { 201 struct vnode *ttyvp = cttyvp(p); 202 if (ttyvp == NULL) { 203 error = ENXIO; 204 goto bad; 205 } 206 error = fdesc_allocvp(Fctty, FD_CTTY, dvp->v_mount, &fvp); 207 if (error) 208 goto bad; 209 *vpp = fvp; 210 fvp->v_type = VFIFO; 211 vn_lock(fvp, LK_SHARED | LK_RETRY, p); 212 return (0); 213 } 214 215 ln = 0; 216 switch (cnp->cn_namelen) { 217 case 5: 218 if (bcmp(pname, "stdin", 5) == 0) { 219 ln = "fd/0"; 220 fd = FD_STDIN; 221 } 222 break; 223 case 6: 224 if (bcmp(pname, "stdout", 6) == 0) { 225 ln = "fd/1"; 226 fd = FD_STDOUT; 227 } else 228 if (bcmp(pname, "stderr", 6) == 0) { 229 ln = "fd/2"; 230 fd = FD_STDERR; 231 } 232 break; 233 } 234 235 if (ln) { 236 error = fdesc_allocvp(Flink, fd, dvp->v_mount, &fvp); 237 if (error) 238 goto bad; 239 VTOFDESC(fvp)->fd_link = ln; 240 *vpp = fvp; 241 fvp->v_type = VLNK; 242 vn_lock(fvp, LK_SHARED | LK_RETRY, p); 243 return (0); 244 } else { 245 error = ENOENT; 246 goto bad; 247 } 248 249 /* FALL THROUGH */ 250 251 case Fdevfd: 252 if (cnp->cn_namelen == 2 && bcmp(pname, "..", 2) == 0) { 253 if (error = fdesc_root(dvp->v_mount, vpp)) 254 goto bad; 255 return (0); 256 } 257 258 fd = 0; 259 while (*pname >= '0' && *pname <= '9') { 260 fd = 10 * fd + *pname++ - '0'; 261 if (fd >= nfiles) 262 break; 263 } 264 265 if (*pname != '\0') { 266 error = ENOENT; 267 goto bad; 268 } 269 270 if (fd >= nfiles || p->p_fd->fd_ofiles[fd] == NULL) { 271 error = EBADF; 272 goto bad; 273 } 274 275 error = fdesc_allocvp(Fdesc, FD_DESC+fd, dvp->v_mount, &fvp); 276 if (error) 277 goto bad; 278 VTOFDESC(fvp)->fd_fd = fd; 279 vn_lock(fvp, LK_SHARED | LK_RETRY, p); 280 *vpp = fvp; 281 return (0); 282 } 283 284 bad:; 285 vn_lock(dvp, LK_SHARED | LK_RETRY, p); 286 *vpp = NULL; 287 return (error); 288 } 289 290 int 291 fdesc_open(ap) 292 struct vop_open_args /* { 293 struct vnode *a_vp; 294 int a_mode; 295 struct ucred *a_cred; 296 struct proc *a_p; 297 } */ *ap; 298 { 299 struct vnode *vp = ap->a_vp; 300 int error = 0; 301 302 switch (VTOFDESC(vp)->fd_type) { 303 case Fdesc: 304 /* 305 * XXX Kludge: set p->p_dupfd to contain the value of the 306 * the file descriptor being sought for duplication. The error 307 * return ensures that the vnode for this device will be 308 * released by vn_open. Open will detect this special error and 309 * take the actions in dupfdopen. Other callers of vn_open or 310 * VOP_OPEN will simply report the error. 311 */ 312 ap->a_p->p_dupfd = VTOFDESC(vp)->fd_fd; /* XXX */ 313 error = ENODEV; 314 break; 315 316 case Fctty: 317 error = cttyopen(devctty, ap->a_mode, 0, ap->a_p); 318 break; 319 } 320 321 return (error); 322 } 323 324 static int 325 fdesc_attr(fd, vap, cred, p) 326 int fd; 327 struct vattr *vap; 328 struct ucred *cred; 329 struct proc *p; 330 { 331 struct filedesc *fdp = p->p_fd; 332 struct file *fp; 333 struct stat stb; 334 int error; 335 336 if (fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL) 337 return (EBADF); 338 339 switch (fp->f_type) { 340 case DTYPE_VNODE: 341 error = VOP_GETATTR((struct vnode *) fp->f_data, vap, cred, p); 342 if (error == 0 && vap->va_type == VDIR) { 343 /* 344 * directories can cause loops in the namespace, 345 * so turn off the 'x' bits to avoid trouble. 346 */ 347 vap->va_mode &= ~((VEXEC)|(VEXEC>>3)|(VEXEC>>6)); 348 } 349 break; 350 351 case DTYPE_SOCKET: 352 error = soo_stat((struct socket *)fp->f_data, &stb); 353 if (error == 0) { 354 vattr_null(vap); 355 vap->va_type = VSOCK; 356 vap->va_mode = stb.st_mode; 357 vap->va_nlink = stb.st_nlink; 358 vap->va_uid = stb.st_uid; 359 vap->va_gid = stb.st_gid; 360 vap->va_fsid = stb.st_dev; 361 vap->va_fileid = stb.st_ino; 362 vap->va_size = stb.st_size; 363 vap->va_blocksize = stb.st_blksize; 364 vap->va_atime = stb.st_atimespec; 365 vap->va_mtime = stb.st_mtimespec; 366 vap->va_ctime = stb.st_ctimespec; 367 vap->va_gen = stb.st_gen; 368 vap->va_flags = stb.st_flags; 369 vap->va_rdev = stb.st_rdev; 370 vap->va_bytes = stb.st_blocks * stb.st_blksize; 371 } 372 break; 373 374 default: 375 panic("fdesc attr"); 376 break; 377 } 378 379 return (error); 380 } 381 382 int 383 fdesc_getattr(ap) 384 struct vop_getattr_args /* { 385 struct vnode *a_vp; 386 struct vattr *a_vap; 387 struct ucred *a_cred; 388 struct proc *a_p; 389 } */ *ap; 390 { 391 struct vnode *vp = ap->a_vp; 392 struct vattr *vap = ap->a_vap; 393 unsigned fd; 394 int error = 0; 395 396 switch (VTOFDESC(vp)->fd_type) { 397 case Froot: 398 case Fdevfd: 399 case Flink: 400 case Fctty: 401 bzero((caddr_t) vap, sizeof(*vap)); 402 vattr_null(vap); 403 vap->va_fileid = VTOFDESC(vp)->fd_ix; 404 405 switch (VTOFDESC(vp)->fd_type) { 406 case Flink: 407 vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH; 408 vap->va_type = VLNK; 409 vap->va_nlink = 1; 410 vap->va_size = strlen(VTOFDESC(vp)->fd_link); 411 break; 412 413 case Fctty: 414 vap->va_mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH; 415 vap->va_type = VFIFO; 416 vap->va_nlink = 1; 417 vap->va_size = 0; 418 break; 419 420 default: 421 vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH; 422 vap->va_type = VDIR; 423 vap->va_nlink = 2; 424 vap->va_size = DEV_BSIZE; 425 break; 426 } 427 vap->va_uid = 0; 428 vap->va_gid = 0; 429 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 430 vap->va_blocksize = DEV_BSIZE; 431 vap->va_atime.ts_sec = boottime.tv_sec; 432 vap->va_atime.ts_nsec = 0; 433 vap->va_mtime = vap->va_atime; 434 vap->va_ctime = vap->va_mtime; 435 vap->va_gen = 0; 436 vap->va_flags = 0; 437 vap->va_rdev = 0; 438 vap->va_bytes = 0; 439 break; 440 441 case Fdesc: 442 fd = VTOFDESC(vp)->fd_fd; 443 error = fdesc_attr(fd, vap, ap->a_cred, ap->a_p); 444 break; 445 446 default: 447 panic("fdesc_getattr"); 448 break; 449 } 450 451 if (error == 0) 452 vp->v_type = vap->va_type; 453 454 return (error); 455 } 456 457 int 458 fdesc_setattr(ap) 459 struct vop_setattr_args /* { 460 struct vnode *a_vp; 461 struct vattr *a_vap; 462 struct ucred *a_cred; 463 struct proc *a_p; 464 } */ *ap; 465 { 466 struct filedesc *fdp = ap->a_p->p_fd; 467 struct file *fp; 468 unsigned fd; 469 int error; 470 471 /* 472 * Can't mess with the root vnode 473 */ 474 switch (VTOFDESC(ap->a_vp)->fd_type) { 475 case Fdesc: 476 break; 477 478 case Fctty: 479 return (0); 480 481 default: 482 return (EACCES); 483 } 484 485 fd = VTOFDESC(ap->a_vp)->fd_fd; 486 if (fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL) { 487 return (EBADF); 488 } 489 490 /* 491 * Can setattr the underlying vnode, but not sockets! 492 */ 493 switch (fp->f_type) { 494 case DTYPE_VNODE: 495 error = VOP_SETATTR((struct vnode *) fp->f_data, ap->a_vap, ap->a_cred, ap->a_p); 496 break; 497 498 case DTYPE_SOCKET: 499 error = 0; 500 break; 501 502 default: 503 panic("fdesc setattr"); 504 break; 505 } 506 507 return (error); 508 } 509 510 #define UIO_MX 16 511 512 static struct dirtmp { 513 u_long d_fileno; 514 u_short d_reclen; 515 u_short d_namlen; 516 char d_name[8]; 517 } rootent[] = { 518 { FD_DEVFD, UIO_MX, 2, "fd" }, 519 { FD_STDIN, UIO_MX, 5, "stdin" }, 520 { FD_STDOUT, UIO_MX, 6, "stdout" }, 521 { FD_STDERR, UIO_MX, 6, "stderr" }, 522 { FD_CTTY, UIO_MX, 3, "tty" }, 523 { 0 } 524 }; 525 526 int 527 fdesc_readdir(ap) 528 struct vop_readdir_args /* { 529 struct vnode *a_vp; 530 struct uio *a_uio; 531 struct ucred *a_cred; 532 int *a_eofflag; 533 u_long *a_cookies; 534 int a_ncookies; 535 } */ *ap; 536 { 537 struct uio *uio = ap->a_uio; 538 struct filedesc *fdp; 539 int i; 540 int error; 541 542 /* 543 * We don't allow exporting fdesc mounts, and currently local 544 * requests do not need cookies. 545 */ 546 if (ap->a_ncookies) 547 panic("fdesc_readdir: not hungry"); 548 549 switch (VTOFDESC(ap->a_vp)->fd_type) { 550 case Fctty: 551 return (0); 552 553 case Fdesc: 554 return (ENOTDIR); 555 556 default: 557 break; 558 } 559 560 fdp = uio->uio_procp->p_fd; 561 562 if (VTOFDESC(ap->a_vp)->fd_type == Froot) { 563 struct dirent d; 564 struct dirent *dp = &d; 565 struct dirtmp *dt; 566 567 i = uio->uio_offset / UIO_MX; 568 error = 0; 569 570 while (uio->uio_resid > 0) { 571 dt = &rootent[i]; 572 if (dt->d_fileno == 0) { 573 /**eofflagp = 1;*/ 574 break; 575 } 576 i++; 577 578 switch (dt->d_fileno) { 579 case FD_CTTY: 580 if (cttyvp(uio->uio_procp) == NULL) 581 continue; 582 break; 583 584 case FD_STDIN: 585 case FD_STDOUT: 586 case FD_STDERR: 587 if ((dt->d_fileno-FD_STDIN) >= fdp->fd_nfiles) 588 continue; 589 if (fdp->fd_ofiles[dt->d_fileno-FD_STDIN] == NULL) 590 continue; 591 break; 592 } 593 bzero((caddr_t) dp, UIO_MX); 594 dp->d_fileno = dt->d_fileno; 595 dp->d_namlen = dt->d_namlen; 596 dp->d_type = DT_UNKNOWN; 597 dp->d_reclen = dt->d_reclen; 598 bcopy(dt->d_name, dp->d_name, dp->d_namlen+1); 599 error = uiomove((caddr_t) dp, UIO_MX, uio); 600 if (error) 601 break; 602 } 603 uio->uio_offset = i * UIO_MX; 604 return (error); 605 } 606 607 i = uio->uio_offset / UIO_MX; 608 error = 0; 609 while (uio->uio_resid > 0) { 610 if (i >= fdp->fd_nfiles) 611 break; 612 613 if (fdp->fd_ofiles[i] != NULL) { 614 struct dirent d; 615 struct dirent *dp = &d; 616 617 bzero((caddr_t) dp, UIO_MX); 618 619 dp->d_namlen = sprintf(dp->d_name, "%d", i); 620 dp->d_reclen = UIO_MX; 621 dp->d_type = DT_UNKNOWN; 622 dp->d_fileno = i + FD_STDIN; 623 /* 624 * And ship to userland 625 */ 626 error = uiomove((caddr_t) dp, UIO_MX, uio); 627 if (error) 628 break; 629 } 630 i++; 631 } 632 633 uio->uio_offset = i * UIO_MX; 634 return (error); 635 } 636 637 int 638 fdesc_readlink(ap) 639 struct vop_readlink_args /* { 640 struct vnode *a_vp; 641 struct uio *a_uio; 642 struct ucred *a_cred; 643 } */ *ap; 644 { 645 struct vnode *vp = ap->a_vp; 646 int error; 647 648 if (vp->v_type != VLNK) 649 return (EPERM); 650 651 if (VTOFDESC(vp)->fd_type == Flink) { 652 char *ln = VTOFDESC(vp)->fd_link; 653 error = uiomove(ln, strlen(ln), ap->a_uio); 654 } else { 655 error = EOPNOTSUPP; 656 } 657 658 return (error); 659 } 660 661 int 662 fdesc_read(ap) 663 struct vop_read_args /* { 664 struct vnode *a_vp; 665 struct uio *a_uio; 666 int a_ioflag; 667 struct ucred *a_cred; 668 } */ *ap; 669 { 670 int error = EOPNOTSUPP; 671 672 switch (VTOFDESC(ap->a_vp)->fd_type) { 673 case Fctty: 674 error = cttyread(devctty, ap->a_uio, ap->a_ioflag); 675 break; 676 677 default: 678 error = EOPNOTSUPP; 679 break; 680 } 681 682 return (error); 683 } 684 685 int 686 fdesc_write(ap) 687 struct vop_write_args /* { 688 struct vnode *a_vp; 689 struct uio *a_uio; 690 int a_ioflag; 691 struct ucred *a_cred; 692 } */ *ap; 693 { 694 int error = EOPNOTSUPP; 695 696 switch (VTOFDESC(ap->a_vp)->fd_type) { 697 case Fctty: 698 error = cttywrite(devctty, ap->a_uio, ap->a_ioflag); 699 break; 700 701 default: 702 error = EOPNOTSUPP; 703 break; 704 } 705 706 return (error); 707 } 708 709 int 710 fdesc_ioctl(ap) 711 struct vop_ioctl_args /* { 712 struct vnode *a_vp; 713 int a_command; 714 caddr_t a_data; 715 int a_fflag; 716 struct ucred *a_cred; 717 struct proc *a_p; 718 } */ *ap; 719 { 720 int error = EOPNOTSUPP; 721 722 switch (VTOFDESC(ap->a_vp)->fd_type) { 723 case Fctty: 724 error = cttyioctl(devctty, ap->a_command, ap->a_data, 725 ap->a_fflag, ap->a_p); 726 break; 727 728 default: 729 error = EOPNOTSUPP; 730 break; 731 } 732 733 return (error); 734 } 735 736 int 737 fdesc_select(ap) 738 struct vop_select_args /* { 739 struct vnode *a_vp; 740 int a_which; 741 int a_fflags; 742 struct ucred *a_cred; 743 struct proc *a_p; 744 } */ *ap; 745 { 746 int error = EOPNOTSUPP; 747 748 switch (VTOFDESC(ap->a_vp)->fd_type) { 749 case Fctty: 750 error = cttyselect(devctty, ap->a_fflags, ap->a_p); 751 break; 752 753 default: 754 error = EOPNOTSUPP; 755 break; 756 } 757 758 return (error); 759 } 760 761 int 762 fdesc_inactive(ap) 763 struct vop_inactive_args /* { 764 struct vnode *a_vp; 765 struct proc *a_p; 766 } */ *ap; 767 { 768 struct vnode *vp = ap->a_vp; 769 770 /* 771 * Clear out the v_type field to avoid 772 * nasty things happening in vgone(). 773 */ 774 VOP_UNLOCK(vp, 0, ap->a_p); 775 vp->v_type = VNON; 776 return (0); 777 } 778 779 int 780 fdesc_reclaim(ap) 781 struct vop_reclaim_args /* { 782 struct vnode *a_vp; 783 } */ *ap; 784 { 785 struct vnode *vp = ap->a_vp; 786 struct fdescnode *fd = VTOFDESC(vp); 787 788 LIST_REMOVE(fd, fd_hash); 789 FREE(vp->v_data, M_TEMP); 790 vp->v_data = 0; 791 792 return (0); 793 } 794 795 /* 796 * Return POSIX pathconf information applicable to special devices. 797 */ 798 fdesc_pathconf(ap) 799 struct vop_pathconf_args /* { 800 struct vnode *a_vp; 801 int a_name; 802 int *a_retval; 803 } */ *ap; 804 { 805 806 switch (ap->a_name) { 807 case _PC_LINK_MAX: 808 *ap->a_retval = LINK_MAX; 809 return (0); 810 case _PC_MAX_CANON: 811 *ap->a_retval = MAX_CANON; 812 return (0); 813 case _PC_MAX_INPUT: 814 *ap->a_retval = MAX_INPUT; 815 return (0); 816 case _PC_PIPE_BUF: 817 *ap->a_retval = PIPE_BUF; 818 return (0); 819 case _PC_CHOWN_RESTRICTED: 820 *ap->a_retval = 1; 821 return (0); 822 case _PC_VDISABLE: 823 *ap->a_retval = _POSIX_VDISABLE; 824 return (0); 825 default: 826 return (EINVAL); 827 } 828 /* NOTREACHED */ 829 } 830 831 /* 832 * Print out the contents of a /dev/fd vnode. 833 */ 834 /* ARGSUSED */ 835 int 836 fdesc_print(ap) 837 struct vop_print_args /* { 838 struct vnode *a_vp; 839 } */ *ap; 840 { 841 842 printf("tag VT_NON, fdesc vnode\n"); 843 return (0); 844 } 845 846 /*void*/ 847 int 848 fdesc_vfree(ap) 849 struct vop_vfree_args /* { 850 struct vnode *a_pvp; 851 ino_t a_ino; 852 int a_mode; 853 } */ *ap; 854 { 855 856 return (0); 857 } 858 859 /* 860 * /dev/fd "should never get here" operation 861 */ 862 int 863 fdesc_badop() 864 { 865 866 panic("fdesc: bad op"); 867 /* NOTREACHED */ 868 } 869 870 #define fdesc_create ((int (*) __P((struct vop_create_args *)))eopnotsupp) 871 #define fdesc_mknod ((int (*) __P((struct vop_mknod_args *)))eopnotsupp) 872 #define fdesc_close ((int (*) __P((struct vop_close_args *)))nullop) 873 #define fdesc_access ((int (*) __P((struct vop_access_args *)))nullop) 874 #define fdesc_mmap ((int (*) __P((struct vop_mmap_args *)))eopnotsupp) 875 #define fdesc_revoke vop_revoke 876 #define fdesc_fsync ((int (*) __P((struct vop_fsync_args *)))nullop) 877 #define fdesc_seek ((int (*) __P((struct vop_seek_args *)))nullop) 878 #define fdesc_remove ((int (*) __P((struct vop_remove_args *)))eopnotsupp) 879 #define fdesc_link ((int (*) __P((struct vop_link_args *)))eopnotsupp) 880 #define fdesc_rename ((int (*) __P((struct vop_rename_args *)))eopnotsupp) 881 #define fdesc_mkdir ((int (*) __P((struct vop_mkdir_args *)))eopnotsupp) 882 #define fdesc_rmdir ((int (*) __P((struct vop_rmdir_args *)))eopnotsupp) 883 #define fdesc_symlink ((int (*) __P((struct vop_symlink_args *)))eopnotsupp) 884 #define fdesc_abortop ((int (*) __P((struct vop_abortop_args *)))nullop) 885 #define fdesc_lock ((int (*) __P((struct vop_lock_args *)))vop_nolock) 886 #define fdesc_unlock ((int (*) __P((struct vop_unlock_args *)))vop_nounlock) 887 #define fdesc_bmap ((int (*) __P((struct vop_bmap_args *)))fdesc_badop) 888 #define fdesc_strategy ((int (*) __P((struct vop_strategy_args *)))fdesc_badop) 889 #define fdesc_islocked \ 890 ((int (*) __P((struct vop_islocked_args *)))vop_noislocked) 891 #define fdesc_advlock ((int (*) __P((struct vop_advlock_args *)))eopnotsupp) 892 #define fdesc_blkatoff \ 893 ((int (*) __P((struct vop_blkatoff_args *)))eopnotsupp) 894 #define fdesc_valloc ((int(*) __P(( \ 895 struct vnode *pvp, \ 896 int mode, \ 897 struct ucred *cred, \ 898 struct vnode **vpp))) eopnotsupp) 899 #define fdesc_truncate \ 900 ((int (*) __P((struct vop_truncate_args *)))eopnotsupp) 901 #define fdesc_update ((int (*) __P((struct vop_update_args *)))eopnotsupp) 902 #define fdesc_bwrite ((int (*) __P((struct vop_bwrite_args *)))eopnotsupp) 903 904 int (**fdesc_vnodeop_p)(); 905 struct vnodeopv_entry_desc fdesc_vnodeop_entries[] = { 906 { &vop_default_desc, vn_default_error }, 907 { &vop_lookup_desc, fdesc_lookup }, /* lookup */ 908 { &vop_create_desc, fdesc_create }, /* create */ 909 { &vop_mknod_desc, fdesc_mknod }, /* mknod */ 910 { &vop_open_desc, fdesc_open }, /* open */ 911 { &vop_close_desc, fdesc_close }, /* close */ 912 { &vop_access_desc, fdesc_access }, /* access */ 913 { &vop_getattr_desc, fdesc_getattr }, /* getattr */ 914 { &vop_setattr_desc, fdesc_setattr }, /* setattr */ 915 { &vop_read_desc, fdesc_read }, /* read */ 916 { &vop_write_desc, fdesc_write }, /* write */ 917 { &vop_ioctl_desc, fdesc_ioctl }, /* ioctl */ 918 { &vop_select_desc, fdesc_select }, /* select */ 919 { &vop_revoke_desc, fdesc_revoke }, /* revoke */ 920 { &vop_mmap_desc, fdesc_mmap }, /* mmap */ 921 { &vop_fsync_desc, fdesc_fsync }, /* fsync */ 922 { &vop_seek_desc, fdesc_seek }, /* seek */ 923 { &vop_remove_desc, fdesc_remove }, /* remove */ 924 { &vop_link_desc, fdesc_link }, /* link */ 925 { &vop_rename_desc, fdesc_rename }, /* rename */ 926 { &vop_mkdir_desc, fdesc_mkdir }, /* mkdir */ 927 { &vop_rmdir_desc, fdesc_rmdir }, /* rmdir */ 928 { &vop_symlink_desc, fdesc_symlink }, /* symlink */ 929 { &vop_readdir_desc, fdesc_readdir }, /* readdir */ 930 { &vop_readlink_desc, fdesc_readlink }, /* readlink */ 931 { &vop_abortop_desc, fdesc_abortop }, /* abortop */ 932 { &vop_inactive_desc, fdesc_inactive }, /* inactive */ 933 { &vop_reclaim_desc, fdesc_reclaim }, /* reclaim */ 934 { &vop_lock_desc, fdesc_lock }, /* lock */ 935 { &vop_unlock_desc, fdesc_unlock }, /* unlock */ 936 { &vop_bmap_desc, fdesc_bmap }, /* bmap */ 937 { &vop_strategy_desc, fdesc_strategy }, /* strategy */ 938 { &vop_print_desc, fdesc_print }, /* print */ 939 { &vop_islocked_desc, fdesc_islocked }, /* islocked */ 940 { &vop_pathconf_desc, fdesc_pathconf }, /* pathconf */ 941 { &vop_advlock_desc, fdesc_advlock }, /* advlock */ 942 { &vop_blkatoff_desc, fdesc_blkatoff }, /* blkatoff */ 943 { &vop_valloc_desc, fdesc_valloc }, /* valloc */ 944 { &vop_vfree_desc, fdesc_vfree }, /* vfree */ 945 { &vop_truncate_desc, fdesc_truncate }, /* truncate */ 946 { &vop_update_desc, fdesc_update }, /* update */ 947 { &vop_bwrite_desc, fdesc_bwrite }, /* bwrite */ 948 { (struct vnodeop_desc*)NULL, (int(*)())NULL } 949 }; 950 struct vnodeopv_desc fdesc_vnodeop_opv_desc = 951 { &fdesc_vnodeop_p, fdesc_vnodeop_entries }; 952
Indexes created Thu Oct 23 22:10:10 GMT 2025