fdesc_vnops.c revision 1.64.2.2
1 /* $NetBSD: fdesc_vnops.c,v 1.64.2.2 2001/09/08 03:29:22 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software donated to Berkeley by 8 * Jan-Simon Pendry. 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 University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)fdesc_vnops.c 8.17 (Berkeley) 5/22/95 39 * 40 * #Id: fdesc_vnops.c,v 1.12 1993/04/06 16:17:17 jsp Exp # 41 */ 42 43 /* 44 * /dev/fd Filesystem 45 */ 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/types.h> 50 #include <sys/time.h> 51 #include <sys/proc.h> 52 #include <sys/kernel.h> /* boottime */ 53 #include <sys/resourcevar.h> 54 #include <sys/socketvar.h> 55 #include <sys/filedesc.h> 56 #include <sys/vnode.h> 57 #include <sys/malloc.h> 58 #include <sys/conf.h> 59 #include <sys/file.h> 60 #include <sys/stat.h> 61 #include <sys/mount.h> 62 #include <sys/namei.h> 63 #include <sys/buf.h> 64 #include <sys/dirent.h> 65 #include <sys/tty.h> 66 67 #include <miscfs/fdesc/fdesc.h> 68 #include <miscfs/genfs/genfs.h> 69 70 #define cttyvp(p) ((p)->p_flag & P_CONTROLT ? (p)->p_session->s_ttyvp : NULL) 71 72 #define FDL_WANT 0x01 73 #define FDL_LOCKED 0x02 74 static int fdcache_lock; 75 76 dev_t devctty; 77 78 #if (FD_STDIN != FD_STDOUT-1) || (FD_STDOUT != FD_STDERR-1) 79 FD_STDIN, FD_STDOUT, FD_STDERR must be a sequence n, n+1, n+2 80 #endif 81 82 #define NFDCACHE 4 83 84 #define FD_NHASH(ix) \ 85 (&fdhashtbl[(ix) & fdhash]) 86 LIST_HEAD(fdhashhead, fdescnode) *fdhashtbl; 87 u_long fdhash; 88 89 int fdesc_lookup __P((void *)); 90 #define fdesc_create genfs_eopnotsupp_rele 91 #define fdesc_mknod genfs_eopnotsupp_rele 92 int fdesc_open __P((void *)); 93 #define fdesc_close genfs_nullop 94 #define fdesc_access genfs_nullop 95 int fdesc_getattr __P((void *)); 96 int fdesc_setattr __P((void *)); 97 int fdesc_read __P((void *)); 98 int fdesc_write __P((void *)); 99 int fdesc_ioctl __P((void *)); 100 int fdesc_poll __P((void *)); 101 int fdesc_kqfilter __P((void *)); 102 #define fdesc_mmap genfs_eopnotsupp 103 #define fdesc_fcntl genfs_fcntl 104 #define fdesc_fsync genfs_nullop 105 #define fdesc_seek genfs_seek 106 #define fdesc_remove genfs_eopnotsupp_rele 107 int fdesc_link __P((void *)); 108 #define fdesc_rename genfs_eopnotsupp_rele 109 #define fdesc_mkdir genfs_eopnotsupp_rele 110 #define fdesc_rmdir genfs_eopnotsupp_rele 111 int fdesc_symlink __P((void *)); 112 int fdesc_readdir __P((void *)); 113 int fdesc_readlink __P((void *)); 114 #define fdesc_abortop genfs_abortop 115 int fdesc_inactive __P((void *)); 116 int fdesc_reclaim __P((void *)); 117 #define fdesc_lock genfs_lock 118 #define fdesc_unlock genfs_unlock 119 #define fdesc_bmap genfs_badop 120 #define fdesc_strategy genfs_badop 121 int fdesc_print __P((void *)); 122 int fdesc_pathconf __P((void *)); 123 #define fdesc_islocked genfs_islocked 124 #define fdesc_advlock genfs_einval 125 #define fdesc_blkatoff genfs_eopnotsupp 126 #define fdesc_valloc genfs_eopnotsupp 127 #define fdesc_vfree genfs_nullop 128 #define fdesc_truncate genfs_eopnotsupp 129 #define fdesc_update genfs_nullop 130 #define fdesc_bwrite genfs_eopnotsupp 131 #define fdesc_revoke genfs_revoke 132 133 static int fdesc_attr __P((int, struct vattr *, struct ucred *, struct proc *)); 134 135 int (**fdesc_vnodeop_p) __P((void *)); 136 const struct vnodeopv_entry_desc fdesc_vnodeop_entries[] = { 137 { &vop_default_desc, vn_default_error }, 138 { &vop_lookup_desc, fdesc_lookup }, /* lookup */ 139 { &vop_create_desc, fdesc_create }, /* create */ 140 { &vop_mknod_desc, fdesc_mknod }, /* mknod */ 141 { &vop_open_desc, fdesc_open }, /* open */ 142 { &vop_close_desc, fdesc_close }, /* close */ 143 { &vop_access_desc, fdesc_access }, /* access */ 144 { &vop_getattr_desc, fdesc_getattr }, /* getattr */ 145 { &vop_setattr_desc, fdesc_setattr }, /* setattr */ 146 { &vop_read_desc, fdesc_read }, /* read */ 147 { &vop_write_desc, fdesc_write }, /* write */ 148 { &vop_ioctl_desc, fdesc_ioctl }, /* ioctl */ 149 { &vop_fcntl_desc, fdesc_fcntl }, /* fcntl */ 150 { &vop_poll_desc, fdesc_poll }, /* poll */ 151 { &vop_kqfilter_desc, fdesc_kqfilter }, /* kqfilter */ 152 { &vop_revoke_desc, fdesc_revoke }, /* revoke */ 153 { &vop_mmap_desc, fdesc_mmap }, /* mmap */ 154 { &vop_fsync_desc, fdesc_fsync }, /* fsync */ 155 { &vop_seek_desc, fdesc_seek }, /* seek */ 156 { &vop_remove_desc, fdesc_remove }, /* remove */ 157 { &vop_link_desc, fdesc_link }, /* link */ 158 { &vop_rename_desc, fdesc_rename }, /* rename */ 159 { &vop_mkdir_desc, fdesc_mkdir }, /* mkdir */ 160 { &vop_rmdir_desc, fdesc_rmdir }, /* rmdir */ 161 { &vop_symlink_desc, fdesc_symlink }, /* symlink */ 162 { &vop_readdir_desc, fdesc_readdir }, /* readdir */ 163 { &vop_readlink_desc, fdesc_readlink }, /* readlink */ 164 { &vop_abortop_desc, fdesc_abortop }, /* abortop */ 165 { &vop_inactive_desc, fdesc_inactive }, /* inactive */ 166 { &vop_reclaim_desc, fdesc_reclaim }, /* reclaim */ 167 { &vop_lock_desc, fdesc_lock }, /* lock */ 168 { &vop_unlock_desc, fdesc_unlock }, /* unlock */ 169 { &vop_bmap_desc, fdesc_bmap }, /* bmap */ 170 { &vop_strategy_desc, fdesc_strategy }, /* strategy */ 171 { &vop_print_desc, fdesc_print }, /* print */ 172 { &vop_islocked_desc, fdesc_islocked }, /* islocked */ 173 { &vop_pathconf_desc, fdesc_pathconf }, /* pathconf */ 174 { &vop_advlock_desc, fdesc_advlock }, /* advlock */ 175 { &vop_blkatoff_desc, fdesc_blkatoff }, /* blkatoff */ 176 { &vop_valloc_desc, fdesc_valloc }, /* valloc */ 177 { &vop_vfree_desc, fdesc_vfree }, /* vfree */ 178 { &vop_truncate_desc, fdesc_truncate }, /* truncate */ 179 { &vop_update_desc, fdesc_update }, /* update */ 180 { &vop_bwrite_desc, fdesc_bwrite }, /* bwrite */ 181 { (struct vnodeop_desc*)NULL, (int(*) __P((void *)))NULL } 182 }; 183 184 const struct vnodeopv_desc fdesc_vnodeop_opv_desc = 185 { &fdesc_vnodeop_p, fdesc_vnodeop_entries }; 186 187 /* 188 * Initialise cache headers 189 */ 190 void 191 fdesc_init() 192 { 193 int cttymajor; 194 195 /* locate the major number */ 196 for (cttymajor = 0; cttymajor < nchrdev; cttymajor++) 197 if (cdevsw[cttymajor].d_open == cttyopen) 198 break; 199 devctty = makedev(cttymajor, 0); 200 fdhashtbl = hashinit(NFDCACHE, HASH_LIST, M_CACHE, M_NOWAIT, &fdhash); 201 } 202 203 /* 204 * Free hash table. 205 */ 206 void 207 fdesc_done() 208 { 209 hashdone(fdhashtbl, M_CACHE); 210 } 211 212 /* 213 * Return a locked vnode of the correct type. 214 */ 215 int 216 fdesc_allocvp(ftype, ix, mp, vpp) 217 fdntype ftype; 218 int ix; 219 struct mount *mp; 220 struct vnode **vpp; 221 { 222 struct fdhashhead *fc; 223 struct fdescnode *fd; 224 int error = 0; 225 226 fc = FD_NHASH(ix); 227 loop: 228 for (fd = fc->lh_first; fd != 0; fd = fd->fd_hash.le_next) { 229 if (fd->fd_ix == ix && fd->fd_vnode->v_mount == mp) { 230 if (vget(fd->fd_vnode, LK_EXCLUSIVE)) 231 goto loop; 232 *vpp = fd->fd_vnode; 233 return (error); 234 } 235 } 236 237 /* 238 * otherwise lock the array while we call getnewvnode 239 * since that can block. 240 */ 241 if (fdcache_lock & FDL_LOCKED) { 242 fdcache_lock |= FDL_WANT; 243 (void) tsleep(&fdcache_lock, PINOD, "fdcache", 0); 244 goto loop; 245 } 246 fdcache_lock |= FDL_LOCKED; 247 248 error = getnewvnode(VT_FDESC, mp, fdesc_vnodeop_p, vpp); 249 if (error) 250 goto out; 251 MALLOC(fd, void *, sizeof(struct fdescnode), M_TEMP, M_WAITOK); 252 (*vpp)->v_data = fd; 253 fd->fd_vnode = *vpp; 254 fd->fd_type = ftype; 255 fd->fd_fd = -1; 256 fd->fd_link = 0; 257 fd->fd_ix = ix; 258 VOP_LOCK(*vpp, LK_EXCLUSIVE); 259 LIST_INSERT_HEAD(fc, fd, fd_hash); 260 261 out:; 262 fdcache_lock &= ~FDL_LOCKED; 263 264 if (fdcache_lock & FDL_WANT) { 265 fdcache_lock &= ~FDL_WANT; 266 wakeup((caddr_t) &fdcache_lock); 267 } 268 269 return (error); 270 } 271 272 /* 273 * vp is the current namei directory 274 * ndp is the name to locate in that directory... 275 */ 276 int 277 fdesc_lookup(v) 278 void *v; 279 { 280 struct vop_lookup_args /* { 281 struct vnode * a_dvp; 282 struct vnode ** a_vpp; 283 struct componentname * a_cnp; 284 } */ *ap = v; 285 struct vnode **vpp = ap->a_vpp; 286 struct vnode *dvp = ap->a_dvp; 287 struct componentname *cnp = ap->a_cnp; 288 struct proc *p = cnp->cn_proc; 289 const char *pname = cnp->cn_nameptr; 290 int nfiles = p->p_fd->fd_nfiles; 291 unsigned fd = 0; 292 int error; 293 struct vnode *fvp; 294 char *ln; 295 296 if (cnp->cn_namelen == 1 && *pname == '.') { 297 *vpp = dvp; 298 VREF(dvp); 299 return (0); 300 } 301 302 switch (VTOFDESC(dvp)->fd_type) { 303 default: 304 case Flink: 305 case Fdesc: 306 case Fctty: 307 error = ENOTDIR; 308 goto bad; 309 310 case Froot: 311 if (cnp->cn_namelen == 2 && memcmp(pname, "fd", 2) == 0) { 312 error = fdesc_allocvp(Fdevfd, FD_DEVFD, dvp->v_mount, &fvp); 313 if (error) 314 goto bad; 315 *vpp = fvp; 316 fvp->v_type = VDIR; 317 goto good; 318 } 319 320 if (cnp->cn_namelen == 3 && memcmp(pname, "tty", 3) == 0) { 321 struct vnode *ttyvp = cttyvp(p); 322 if (ttyvp == NULL) { 323 error = ENXIO; 324 goto bad; 325 } 326 error = fdesc_allocvp(Fctty, FD_CTTY, dvp->v_mount, &fvp); 327 if (error) 328 goto bad; 329 *vpp = fvp; 330 fvp->v_type = VCHR; 331 goto good; 332 } 333 334 ln = 0; 335 switch (cnp->cn_namelen) { 336 case 5: 337 if (memcmp(pname, "stdin", 5) == 0) { 338 ln = "fd/0"; 339 fd = FD_STDIN; 340 } 341 break; 342 case 6: 343 if (memcmp(pname, "stdout", 6) == 0) { 344 ln = "fd/1"; 345 fd = FD_STDOUT; 346 } else 347 if (memcmp(pname, "stderr", 6) == 0) { 348 ln = "fd/2"; 349 fd = FD_STDERR; 350 } 351 break; 352 } 353 354 if (ln) { 355 error = fdesc_allocvp(Flink, fd, dvp->v_mount, &fvp); 356 if (error) 357 goto bad; 358 VTOFDESC(fvp)->fd_link = ln; 359 *vpp = fvp; 360 fvp->v_type = VLNK; 361 goto good; 362 } else { 363 error = ENOENT; 364 goto bad; 365 } 366 367 /* FALL THROUGH */ 368 369 case Fdevfd: 370 if (cnp->cn_namelen == 2 && memcmp(pname, "..", 2) == 0) { 371 VOP_UNLOCK(dvp, 0); 372 cnp->cn_flags |= PDIRUNLOCK; 373 error = fdesc_root(dvp->v_mount, vpp); 374 if (error) 375 goto bad; 376 /* 377 * If we're at the last component and need the 378 * parent locked, undo the unlock above. 379 */ 380 if (((~cnp->cn_flags & (ISLASTCN | LOCKPARENT)) == 0) && 381 ((error = vn_lock(dvp, LK_EXCLUSIVE)) == 0)) 382 cnp->cn_flags &= ~PDIRUNLOCK; 383 return (error); 384 } 385 386 fd = 0; 387 while (*pname >= '0' && *pname <= '9') { 388 fd = 10 * fd + *pname++ - '0'; 389 if (fd >= nfiles) 390 break; 391 } 392 393 if (*pname != '\0') { 394 error = ENOENT; 395 goto bad; 396 } 397 398 if (fd >= nfiles || p->p_fd->fd_ofiles[fd] == NULL || 399 FILE_IS_USABLE(p->p_fd->fd_ofiles[fd]) == 0) { 400 error = EBADF; 401 goto bad; 402 } 403 404 error = fdesc_allocvp(Fdesc, FD_DESC+fd, dvp->v_mount, &fvp); 405 if (error) 406 goto bad; 407 VTOFDESC(fvp)->fd_fd = fd; 408 *vpp = fvp; 409 goto good; 410 } 411 412 bad:; 413 *vpp = NULL; 414 return (error); 415 416 good:; 417 /* 418 * As "." was special cased above, we now unlock the parent if we're 419 * suppoed to. We're only supposed to not unlock if this is the 420 * last component, and the caller requested LOCKPARENT. So if either 421 * condition is false, unlock. 422 */ 423 if (((~cnp->cn_flags) & (ISLASTCN | LOCKPARENT)) != 0) { 424 VOP_UNLOCK(dvp, 0); 425 cnp->cn_flags |= PDIRUNLOCK; 426 } 427 return (0); 428 } 429 430 int 431 fdesc_open(v) 432 void *v; 433 { 434 struct vop_open_args /* { 435 struct vnode *a_vp; 436 int a_mode; 437 struct ucred *a_cred; 438 struct proc *a_p; 439 } */ *ap = v; 440 struct vnode *vp = ap->a_vp; 441 442 switch (VTOFDESC(vp)->fd_type) { 443 case Fdesc: 444 /* 445 * XXX Kludge: set p->p_dupfd to contain the value of the 446 * the file descriptor being sought for duplication. The error 447 * return ensures that the vnode for this device will be 448 * released by vn_open. Open will detect this special error and 449 * take the actions in dupfdopen. Other callers of vn_open or 450 * VOP_OPEN will simply report the error. 451 */ 452 ap->a_p->p_dupfd = VTOFDESC(vp)->fd_fd; /* XXX */ 453 return (ENODEV); 454 455 case Fctty: 456 return (cttyopen(devctty, ap->a_mode, 0, ap->a_p)); 457 case Froot: 458 case Fdevfd: 459 case Flink: 460 break; 461 } 462 463 return (0); 464 } 465 466 static int 467 fdesc_attr(fd, vap, cred, p) 468 int fd; 469 struct vattr *vap; 470 struct ucred *cred; 471 struct proc *p; 472 { 473 struct filedesc *fdp = p->p_fd; 474 struct file *fp; 475 struct stat stb; 476 int error; 477 478 if ((fp = fd_getfile(fdp, fd)) == NULL) 479 return (EBADF); 480 481 switch (fp->f_type) { 482 case DTYPE_VNODE: 483 error = VOP_GETATTR((struct vnode *) fp->f_data, vap, cred, p); 484 if (error == 0 && vap->va_type == VDIR) { 485 /* 486 * directories can cause loops in the namespace, 487 * so turn off the 'x' bits to avoid trouble. 488 */ 489 vap->va_mode &= ~(S_IXUSR|S_IXGRP|S_IXOTH); 490 } 491 break; 492 493 case DTYPE_SOCKET: 494 case DTYPE_PIPE: 495 case DTYPE_KQUEUE: 496 FILE_USE(fp); 497 error = (*fp->f_ops->fo_stat)(fp, &stb, p); 498 FILE_UNUSE(fp, p); 499 if (error == 0) { 500 vattr_null(vap); 501 if (fp->f_type == DTYPE_SOCKET) 502 vap->va_type = VSOCK; 503 else 504 vap->va_type = VFIFO; 505 vap->va_mode = stb.st_mode; 506 vap->va_nlink = stb.st_nlink; 507 vap->va_uid = stb.st_uid; 508 vap->va_gid = stb.st_gid; 509 vap->va_fsid = stb.st_dev; 510 vap->va_fileid = stb.st_ino; 511 vap->va_size = stb.st_size; 512 vap->va_blocksize = stb.st_blksize; 513 vap->va_atime = stb.st_atimespec; 514 vap->va_mtime = stb.st_mtimespec; 515 vap->va_ctime = stb.st_ctimespec; 516 vap->va_gen = stb.st_gen; 517 vap->va_flags = stb.st_flags; 518 vap->va_rdev = stb.st_rdev; 519 vap->va_bytes = stb.st_blocks * stb.st_blksize; 520 } 521 break; 522 523 default: 524 panic("fdesc attr"); 525 break; 526 } 527 528 return (error); 529 } 530 531 int 532 fdesc_getattr(v) 533 void *v; 534 { 535 struct vop_getattr_args /* { 536 struct vnode *a_vp; 537 struct vattr *a_vap; 538 struct ucred *a_cred; 539 struct proc *a_p; 540 } */ *ap = v; 541 struct vnode *vp = ap->a_vp; 542 struct vattr *vap = ap->a_vap; 543 unsigned fd; 544 int error = 0; 545 546 switch (VTOFDESC(vp)->fd_type) { 547 case Froot: 548 case Fdevfd: 549 case Flink: 550 case Fctty: 551 VATTR_NULL(vap); 552 vap->va_fileid = VTOFDESC(vp)->fd_ix; 553 554 #define R_ALL (S_IRUSR|S_IRGRP|S_IROTH) 555 #define W_ALL (S_IWUSR|S_IWGRP|S_IWOTH) 556 #define X_ALL (S_IXUSR|S_IXGRP|S_IXOTH) 557 558 switch (VTOFDESC(vp)->fd_type) { 559 case Flink: 560 vap->va_mode = R_ALL|X_ALL; 561 vap->va_type = VLNK; 562 vap->va_rdev = 0; 563 vap->va_nlink = 1; 564 vap->va_size = strlen(VTOFDESC(vp)->fd_link); 565 break; 566 567 case Fctty: 568 vap->va_mode = R_ALL|W_ALL; 569 vap->va_type = VCHR; 570 vap->va_rdev = devctty; 571 vap->va_nlink = 1; 572 vap->va_size = 0; 573 break; 574 575 default: 576 vap->va_mode = R_ALL|X_ALL; 577 vap->va_type = VDIR; 578 vap->va_rdev = 0; 579 vap->va_nlink = 2; 580 vap->va_size = DEV_BSIZE; 581 break; 582 } 583 vap->va_uid = 0; 584 vap->va_gid = 0; 585 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 586 vap->va_blocksize = DEV_BSIZE; 587 vap->va_atime.tv_sec = boottime.tv_sec; 588 vap->va_atime.tv_nsec = 0; 589 vap->va_mtime = vap->va_atime; 590 vap->va_ctime = vap->va_mtime; 591 vap->va_gen = 0; 592 vap->va_flags = 0; 593 vap->va_bytes = 0; 594 break; 595 596 case Fdesc: 597 fd = VTOFDESC(vp)->fd_fd; 598 error = fdesc_attr(fd, vap, ap->a_cred, ap->a_p); 599 break; 600 601 default: 602 panic("fdesc_getattr"); 603 break; 604 } 605 606 if (error == 0) 607 vp->v_type = vap->va_type; 608 609 return (error); 610 } 611 612 int 613 fdesc_setattr(v) 614 void *v; 615 { 616 struct vop_setattr_args /* { 617 struct vnode *a_vp; 618 struct vattr *a_vap; 619 struct ucred *a_cred; 620 struct proc *a_p; 621 } */ *ap = v; 622 struct filedesc *fdp = ap->a_p->p_fd; 623 struct file *fp; 624 unsigned fd; 625 int error; 626 627 /* 628 * Can't mess with the root vnode 629 */ 630 switch (VTOFDESC(ap->a_vp)->fd_type) { 631 case Fdesc: 632 break; 633 634 case Fctty: 635 return (0); 636 637 default: 638 return (EACCES); 639 } 640 641 fd = VTOFDESC(ap->a_vp)->fd_fd; 642 if ((fp = fd_getfile(fdp, fd)) == NULL) 643 return (EBADF); 644 645 /* 646 * Can setattr the underlying vnode, but not sockets! 647 */ 648 switch (fp->f_type) { 649 case DTYPE_VNODE: 650 case DTYPE_SOCKET: 651 case DTYPE_KQUEUE: 652 error = 0; 653 break; 654 655 default: 656 panic("fdesc setattr"); 657 break; 658 } 659 660 return (error); 661 } 662 663 #define UIO_MX 32 664 665 struct fdesc_target { 666 ino_t ft_fileno; 667 u_char ft_type; 668 u_char ft_namlen; 669 char *ft_name; 670 } fdesc_targets[] = { 671 /* NOTE: The name must be less than UIO_MX-16 chars in length */ 672 #define N(s) sizeof(s)-1, s 673 { FD_DEVFD, DT_DIR, N("fd") }, 674 { FD_STDIN, DT_LNK, N("stdin") }, 675 { FD_STDOUT, DT_LNK, N("stdout") }, 676 { FD_STDERR, DT_LNK, N("stderr") }, 677 { FD_CTTY, DT_UNKNOWN, N("tty") }, 678 #undef N 679 }; 680 static int nfdesc_targets = sizeof(fdesc_targets) / sizeof(fdesc_targets[0]); 681 682 int 683 fdesc_readdir(v) 684 void *v; 685 { 686 struct vop_readdir_args /* { 687 struct vnode *a_vp; 688 struct uio *a_uio; 689 struct ucred *a_cred; 690 int *a_eofflag; 691 off_t **a_cookies; 692 int *a_ncookies; 693 } */ *ap = v; 694 struct uio *uio = ap->a_uio; 695 struct dirent d; 696 struct filedesc *fdp; 697 off_t i; 698 int error; 699 off_t *cookies = NULL; 700 int ncookies = 0; 701 702 switch (VTOFDESC(ap->a_vp)->fd_type) { 703 case Fctty: 704 return (0); 705 706 case Fdesc: 707 return (ENOTDIR); 708 709 default: 710 break; 711 } 712 713 fdp = uio->uio_procp->p_fd; 714 715 if (uio->uio_resid < UIO_MX) 716 return (EINVAL); 717 if (uio->uio_offset < 0) 718 return (EINVAL); 719 720 error = 0; 721 i = uio->uio_offset; 722 memset((caddr_t)&d, 0, UIO_MX); 723 d.d_reclen = UIO_MX; 724 if (ap->a_ncookies) 725 ncookies = (uio->uio_resid / UIO_MX); 726 727 if (VTOFDESC(ap->a_vp)->fd_type == Froot) { 728 struct fdesc_target *ft; 729 730 if (i >= nfdesc_targets) 731 return 0; 732 733 if (ap->a_ncookies) { 734 ncookies = min(ncookies, (nfdesc_targets - i)); 735 cookies = malloc(ncookies * sizeof(off_t), 736 M_TEMP, M_WAITOK); 737 *ap->a_cookies = cookies; 738 *ap->a_ncookies = ncookies; 739 } 740 741 for (ft = &fdesc_targets[i]; 742 uio->uio_resid >= UIO_MX && i < nfdesc_targets; ft++, i++) { 743 switch (ft->ft_fileno) { 744 case FD_CTTY: 745 if (cttyvp(uio->uio_procp) == NULL) 746 continue; 747 break; 748 749 case FD_STDIN: 750 case FD_STDOUT: 751 case FD_STDERR: 752 if ((ft->ft_fileno - FD_STDIN) >= fdp->fd_nfiles) 753 continue; 754 if (fdp->fd_ofiles[ft->ft_fileno - FD_STDIN] == NULL 755 || FILE_IS_USABLE(fdp->fd_ofiles[ft->ft_fileno - FD_STDIN]) == 0) 756 continue; 757 break; 758 } 759 760 d.d_fileno = ft->ft_fileno; 761 d.d_namlen = ft->ft_namlen; 762 memcpy(d.d_name, ft->ft_name, ft->ft_namlen + 1); 763 d.d_type = ft->ft_type; 764 765 if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) 766 break; 767 if (cookies) 768 *cookies++ = i + 1; 769 } 770 } else { 771 if (ap->a_ncookies) { 772 ncookies = min(ncookies, (fdp->fd_nfiles + 2)); 773 cookies = malloc(ncookies * sizeof(off_t), 774 M_TEMP, M_WAITOK); 775 *ap->a_cookies = cookies; 776 *ap->a_ncookies = ncookies; 777 } 778 for (; i - 2 < fdp->fd_nfiles && uio->uio_resid >= UIO_MX; 779 i++) { 780 switch (i) { 781 case 0: 782 case 1: 783 d.d_fileno = FD_ROOT; /* XXX */ 784 d.d_namlen = i + 1; 785 memcpy(d.d_name, "..", d.d_namlen); 786 d.d_name[i + 1] = '\0'; 787 d.d_type = DT_DIR; 788 break; 789 790 default: 791 if (fdp->fd_ofiles[i - 2] == NULL || 792 FILE_IS_USABLE(fdp->fd_ofiles[i - 2]) == 0) 793 continue; 794 d.d_fileno = i - 2 + FD_STDIN; 795 d.d_namlen = sprintf(d.d_name, "%d", (int) i - 2); 796 d.d_type = DT_UNKNOWN; 797 break; 798 } 799 800 if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0) 801 break; 802 if (cookies) 803 *cookies++ = i + 1; 804 } 805 } 806 807 if (ap->a_ncookies && error) { 808 free(*ap->a_cookies, M_TEMP); 809 *ap->a_ncookies = 0; 810 *ap->a_cookies = NULL; 811 } 812 813 uio->uio_offset = i; 814 return (error); 815 } 816 817 int 818 fdesc_readlink(v) 819 void *v; 820 { 821 struct vop_readlink_args /* { 822 struct vnode *a_vp; 823 struct uio *a_uio; 824 struct ucred *a_cred; 825 } */ *ap = v; 826 struct vnode *vp = ap->a_vp; 827 int error; 828 829 if (vp->v_type != VLNK) 830 return (EPERM); 831 832 if (VTOFDESC(vp)->fd_type == Flink) { 833 char *ln = VTOFDESC(vp)->fd_link; 834 error = uiomove(ln, strlen(ln), ap->a_uio); 835 } else { 836 error = EOPNOTSUPP; 837 } 838 839 return (error); 840 } 841 842 int 843 fdesc_read(v) 844 void *v; 845 { 846 struct vop_read_args /* { 847 struct vnode *a_vp; 848 struct uio *a_uio; 849 int a_ioflag; 850 struct ucred *a_cred; 851 } */ *ap = v; 852 int error = EOPNOTSUPP; 853 struct vnode *vp = ap->a_vp; 854 855 switch (VTOFDESC(vp)->fd_type) { 856 case Fctty: 857 VOP_UNLOCK(vp, 0); 858 error = cttyread(devctty, ap->a_uio, ap->a_ioflag); 859 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 860 break; 861 862 default: 863 error = EOPNOTSUPP; 864 break; 865 } 866 867 return (error); 868 } 869 870 int 871 fdesc_write(v) 872 void *v; 873 { 874 struct vop_write_args /* { 875 struct vnode *a_vp; 876 struct uio *a_uio; 877 int a_ioflag; 878 struct ucred *a_cred; 879 } */ *ap = v; 880 int error = EOPNOTSUPP; 881 struct vnode *vp = ap->a_vp; 882 883 switch (VTOFDESC(vp)->fd_type) { 884 case Fctty: 885 VOP_UNLOCK(vp, 0); 886 error = cttywrite(devctty, ap->a_uio, ap->a_ioflag); 887 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 888 break; 889 890 default: 891 error = EOPNOTSUPP; 892 break; 893 } 894 895 return (error); 896 } 897 898 int 899 fdesc_ioctl(v) 900 void *v; 901 { 902 struct vop_ioctl_args /* { 903 struct vnode *a_vp; 904 u_long a_command; 905 caddr_t a_data; 906 int a_fflag; 907 struct ucred *a_cred; 908 struct proc *a_p; 909 } */ *ap = v; 910 int error = EOPNOTSUPP; 911 912 switch (VTOFDESC(ap->a_vp)->fd_type) { 913 case Fctty: 914 error = cttyioctl(devctty, ap->a_command, ap->a_data, 915 ap->a_fflag, ap->a_p); 916 break; 917 918 default: 919 error = EOPNOTSUPP; 920 break; 921 } 922 923 return (error); 924 } 925 926 int 927 fdesc_poll(v) 928 void *v; 929 { 930 struct vop_poll_args /* { 931 struct vnode *a_vp; 932 int a_events; 933 struct proc *a_p; 934 } */ *ap = v; 935 int revents; 936 937 switch (VTOFDESC(ap->a_vp)->fd_type) { 938 case Fctty: 939 revents = cttypoll(devctty, ap->a_events, ap->a_p); 940 break; 941 942 default: 943 revents = genfs_poll(v); 944 break; 945 } 946 947 return (revents); 948 } 949 950 int 951 fdesc_kqfilter(v) 952 void *v; 953 { 954 struct vop_kqfilter_args /* { 955 struct vnode *a_vp; 956 struct knote *a_kn; 957 } */ *ap = v; 958 int rv; 959 960 switch (VTOFDESC(ap->a_vp)->fd_type) { 961 case Fctty: 962 rv = cttykqfilter(devctty, ap->a_kn); 963 break; 964 965 default: 966 rv = 1; /* XXXLUKEM (thorpej) */ 967 break; 968 } 969 970 return (rv); 971 } 972 973 int 974 fdesc_inactive(v) 975 void *v; 976 { 977 struct vop_inactive_args /* { 978 struct vnode *a_vp; 979 struct proc *a_p; 980 } */ *ap = v; 981 struct vnode *vp = ap->a_vp; 982 983 /* 984 * Clear out the v_type field to avoid 985 * nasty things happening in vgone(). 986 */ 987 VOP_UNLOCK(vp, 0); 988 vp->v_type = VNON; 989 return (0); 990 } 991 992 int 993 fdesc_reclaim(v) 994 void *v; 995 { 996 struct vop_reclaim_args /* { 997 struct vnode *a_vp; 998 } */ *ap = v; 999 struct vnode *vp = ap->a_vp; 1000 struct fdescnode *fd = VTOFDESC(vp); 1001 1002 LIST_REMOVE(fd, fd_hash); 1003 FREE(vp->v_data, M_TEMP); 1004 vp->v_data = 0; 1005 1006 return (0); 1007 } 1008 1009 /* 1010 * Return POSIX pathconf information applicable to special devices. 1011 */ 1012 int 1013 fdesc_pathconf(v) 1014 void *v; 1015 { 1016 struct vop_pathconf_args /* { 1017 struct vnode *a_vp; 1018 int a_name; 1019 register_t *a_retval; 1020 } */ *ap = v; 1021 1022 switch (ap->a_name) { 1023 case _PC_LINK_MAX: 1024 *ap->a_retval = LINK_MAX; 1025 return (0); 1026 case _PC_MAX_CANON: 1027 *ap->a_retval = MAX_CANON; 1028 return (0); 1029 case _PC_MAX_INPUT: 1030 *ap->a_retval = MAX_INPUT; 1031 return (0); 1032 case _PC_PIPE_BUF: 1033 *ap->a_retval = PIPE_BUF; 1034 return (0); 1035 case _PC_CHOWN_RESTRICTED: 1036 *ap->a_retval = 1; 1037 return (0); 1038 case _PC_VDISABLE: 1039 *ap->a_retval = _POSIX_VDISABLE; 1040 return (0); 1041 case _PC_SYNC_IO: 1042 *ap->a_retval = 1; 1043 return (0); 1044 default: 1045 return (EINVAL); 1046 } 1047 /* NOTREACHED */ 1048 } 1049 1050 /* 1051 * Print out the contents of a /dev/fd vnode. 1052 */ 1053 /* ARGSUSED */ 1054 int 1055 fdesc_print(v) 1056 void *v; 1057 { 1058 printf("tag VT_NON, fdesc vnode\n"); 1059 return (0); 1060 } 1061 1062 int 1063 fdesc_link(v) 1064 void *v; 1065 { 1066 struct vop_link_args /* { 1067 struct vnode *a_dvp; 1068 struct vnode *a_vp; 1069 struct componentname *a_cnp; 1070 } */ *ap = v; 1071 1072 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 1073 vput(ap->a_dvp); 1074 return (EROFS); 1075 } 1076 1077 int 1078 fdesc_symlink(v) 1079 void *v; 1080 { 1081 struct vop_symlink_args /* { 1082 struct vnode *a_dvp; 1083 struct vnode **a_vpp; 1084 struct componentname *a_cnp; 1085 struct vattr *a_vap; 1086 char *a_target; 1087 } */ *ap = v; 1088 1089 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 1090 vput(ap->a_dvp); 1091 return (EROFS); 1092 } 1093
Indexes created Wed Oct 22 06:10:02 GMT 2025