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