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