sys/fs/pseudofs/pseudofs_vnops.c

   1 /*-
   2  * Copyright (c) 2001 Dag-Erling Coïdan Smørgrav
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  *      $FreeBSD$
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/kernel.h>
  33 #include <sys/systm.h>
  34 #include <sys/ctype.h>
  35 #include <sys/dirent.h>
  36 #include <sys/fcntl.h>
  37 #include <sys/limits.h>
  38 #include <sys/lock.h>
  39 #include <sys/mount.h>
  40 #include <sys/mutex.h>
  41 #include <sys/namei.h>
  42 #include <sys/proc.h>
  43 #include <sys/sbuf.h>
  44 #include <sys/sx.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/vnode.h>
  47
  48 #include <fs/pseudofs/pseudofs.h>
  49 #include <fs/pseudofs/pseudofs_internal.h>
  50
  51 #if 0
  52 #define PFS_TRACE(foo) \
  53         do { \
  54                 printf("pseudofs: %s(): line %d: ", __func__, __LINE__); \
  55                 printf foo ; \
  56                 printf("\n"); \
  57         } while (0)
  58 #define PFS_RETURN(err) \
  59         do { \
  60                 printf("pseudofs: %s(): line %d: returning %d\n", \
  61                     __func__, __LINE__, err); \
  62                 return (err); \
  63         } while (0)
  64 #else
  65 #define PFS_TRACE(foo) \
  66         do { /* nothing */ } while (0)
  67 #define PFS_RETURN(err) \
  68         return (err)
  69 #endif
  70
  71 /*
  72  * Returns non-zero if given file is visible to given process
  73  */
  74 static int
  75 pfs_visible(struct thread *td, struct pfs_node *pn, pid_t pid)
  76 {
  77         struct proc *proc;
  78         int r;
  79
  80         PFS_TRACE(("%s (pid: %d, req: %d)",
  81             pn->pn_name, pid, td->td_proc->p_pid));
  82
  83         if (pn->pn_flags & PFS_DISABLED)
  84                 PFS_RETURN (0);
  85
  86         r = 1;
  87         if (pid != NO_PID) {
  88                 if ((proc = pfind(pid)) == NULL)
  89                         PFS_RETURN (0);
  90                 if (p_cansee(td, proc) != 0 ||
  91                     (pn->pn_vis != NULL && !(pn->pn_vis)(td, proc, pn)))
  92                         r = 0;
  93                 PROC_UNLOCK(proc);
  94         }
  95         PFS_RETURN (r);
  96 }
  97
  98 /*
  99  * Verify permissions
 100  */
 101 static int
 102 pfs_access(struct vop_access_args *va)
 103 {
 104         struct vnode *vn = va->a_vp;
 105         struct vattr vattr;
 106         int error;
 107
 108         PFS_TRACE((((struct pfs_vdata *)vn->v_data)->pvd_pn->pn_name));
 109
 110         error = VOP_GETATTR(vn, &vattr, va->a_cred, va->a_td);
 111         if (error)
 112                 PFS_RETURN (error);
 113         error = vaccess(vn->v_type, vattr.va_mode, vattr.va_uid,
 114             vattr.va_gid, va->a_mode, va->a_cred, NULL);
 115         PFS_RETURN (error);
 116 }
 117
 118 /*
 119  * Close a file or directory
 120  */
 121 static int
 122 pfs_close(struct vop_close_args *va)
 123 {
 124         struct vnode *vn = va->a_vp;
 125         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 126         struct pfs_node *pn = pvd->pvd_pn;
 127         struct proc *proc;
 128         int error;
 129
 130         PFS_TRACE((pn->pn_name));
 131
 132         /*
 133          * Do nothing unless this is the last close and the node has a
 134          * last-close handler.
 135          */
 136         if (vrefcnt(vn) > 1 || pn->pn_close == NULL)
 137                 PFS_RETURN (0);
 138
 139         if (pvd->pvd_pid != NO_PID)
 140                 proc = pfind(pvd->pvd_pid);
 141         else
 142                 proc = NULL;
 143
 144         error = (pn->pn_close)(va->a_td, proc, pn);
 145
 146         if (proc != NULL)
 147                 PROC_UNLOCK(proc);
 148
 149         PFS_RETURN (error);
 150 }
 151
 152 /*
 153  * Get file attributes
 154  */
 155 static int
 156 pfs_getattr(struct vop_getattr_args *va)
 157 {
 158         struct vnode *vn = va->a_vp;
 159         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 160         struct pfs_node *pn = pvd->pvd_pn;
 161         struct vattr *vap = va->a_vap;
 162         struct proc *proc;
 163         int error = 0;
 164
 165         PFS_TRACE((pn->pn_name));
 166
 167         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 168                 PFS_RETURN (ENOENT);
 169
 170         VATTR_NULL(vap);
 171         vap->va_type = vn->v_type;
 172         vap->va_fileid = pn->pn_fileno;
 173         vap->va_flags = 0;
 174         vap->va_blocksize = PAGE_SIZE;
 175         vap->va_bytes = vap->va_size = 0;
 176         vap->va_fsid = vn->v_mount->mnt_stat.f_fsid.val[0];
 177         vap->va_nlink = 1;
 178         nanotime(&vap->va_ctime);
 179         vap->va_atime = vap->va_mtime = vap->va_ctime;
 180
 181         switch (pn->pn_type) {
 182         case pfstype_procdir:
 183         case pfstype_root:
 184         case pfstype_dir:
 185                 vap->va_mode = 0555;
 186                 break;
 187         case pfstype_file:
 188         case pfstype_symlink:
 189                 vap->va_mode = 0444;
 190                 break;
 191         default:
 192                 printf("shouldn't be here!\n");
 193                 vap->va_mode = 0;
 194                 break;
 195         }
 196
 197         if (pvd->pvd_pid != NO_PID) {
 198                 if ((proc = pfind(pvd->pvd_pid)) == NULL)
 199                         PFS_RETURN (ENOENT);
 200                 vap->va_uid = proc->p_ucred->cr_ruid;
 201                 vap->va_gid = proc->p_ucred->cr_rgid;
 202                 if (pn->pn_attr != NULL)
 203                         error = (pn->pn_attr)(va->a_td, proc, pn, vap);
 204                 PROC_UNLOCK(proc);
 205         } else {
 206                 vap->va_uid = 0;
 207                 vap->va_gid = 0;
 208         }
 209
 210         PFS_RETURN (error);
 211 }
 212
 213 /*
 214  * Perform an ioctl
 215  */
 216 static int
 217 pfs_ioctl(struct vop_ioctl_args *va)
 218 {
 219         struct vnode *vn = va->a_vp;
 220         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 221         struct pfs_node *pn = pvd->pvd_pn;
 222         struct proc *proc = NULL;
 223         int error;
 224
 225         PFS_TRACE(("%s: %lx", pn->pn_name, va->a_command));
 226
 227         if (vn->v_type != VREG)
 228                 PFS_RETURN (EINVAL);
 229
 230         if (pn->pn_ioctl == NULL)
 231                 PFS_RETURN (ENOTTY);
 232
 233         /*
 234          * This is necessary because process' privileges may
 235          * have changed since the open() call.
 236          */
 237         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 238                 PFS_RETURN (EIO);
 239
 240         /* XXX duplicates bits of pfs_visible() */
 241         if (pvd->pvd_pid != NO_PID) {
 242                 if ((proc = pfind(pvd->pvd_pid)) == NULL)
 243                         PFS_RETURN (EIO);
 244                 _PHOLD(proc);
 245                 PROC_UNLOCK(proc);
 246         }
 247
 248         error = (pn->pn_ioctl)(curthread, proc, pn, va->a_command, va->a_data);
 249
 250         if (proc != NULL)
 251                 PRELE(proc);
 252
 253         PFS_RETURN (error);
 254 }
 255
 256 /*
 257  * Perform getextattr
 258  */
 259 static int
 260 pfs_getextattr(struct vop_getextattr_args *va)
 261 {
 262         struct vnode *vn = va->a_vp;
 263         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 264         struct pfs_node *pn = pvd->pvd_pn;
 265         struct proc *proc = NULL;
 266         int error;
 267
 268         PFS_TRACE((pd->pn_name));
 269
 270         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 271                 PFS_RETURN (ENOENT);
 272
 273         if (pn->pn_getextattr == NULL)
 274                 PFS_RETURN (EOPNOTSUPP);
 275
 276         /*
 277          * This is necessary because either process' privileges may
 278          * have changed since the open() call.
 279          */
 280         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 281                 PFS_RETURN (EIO);
 282
 283         /* XXX duplicates bits of pfs_visible() */
 284         if (pvd->pvd_pid != NO_PID) {
 285                 if ((proc = pfind(pvd->pvd_pid)) == NULL)
 286                         PFS_RETURN (EIO);
 287                 _PHOLD(proc);
 288                 PROC_UNLOCK(proc);
 289         }
 290
 291         error = (pn->pn_getextattr)(curthread, proc, pn, va->a_attrnamespace,
 292             va->a_name, va->a_uio, va->a_size, va->a_cred);
 293
 294         if (proc != NULL)
 295                 PRELE(proc);
 296
 297         PFS_RETURN (error);
 298 }
 299
 300 /*
 301  * Look up a file or directory
 302  *
 303  * XXX NOTE!  pfs_lookup() has been hooked into vop_lookup_desc!  This
 304  * will result in a lookup operation for a vnode which may already be
 305  * cached, therefore we have to be careful to purge the VFS cache when
 306  * reusing a vnode.
 307  *
 308  * This code will work, but is not really correct.  Normally we would hook
 309  * vfs_cache_lookup() into vop_lookup_desc and hook pfs_lookup() into
 310  * vop_cachedlookup_desc.
 311  */
 312 static int
 313 pfs_lookup(struct vop_lookup_args *va)
 314 {
 315         struct vnode *vn = va->a_dvp;
 316         struct vnode **vpp = va->a_vpp;
 317         struct componentname *cnp = va->a_cnp;
 318         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 319         struct pfs_node *pd = pvd->pvd_pn;
 320         struct pfs_node *pn, *pdn = NULL;
 321         pid_t pid = pvd->pvd_pid;
 322         int lockparent;
 323         int wantparent;
 324         char *pname;
 325         int error, i, namelen;
 326
 327         PFS_TRACE(("%.*s", (int)cnp->cn_namelen, cnp->cn_nameptr));
 328
 329         cnp->cn_flags &= ~PDIRUNLOCK;
 330
 331         if (vn->v_type != VDIR)
 332                 PFS_RETURN (ENOTDIR);
 333
 334         /*
 335          * Don't support DELETE or RENAME.  CREATE is supported so
 336          * that O_CREAT will work, but the lookup will still fail if
 337          * the file does not exist.
 338          */
 339         if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
 340                 PFS_RETURN (EOPNOTSUPP);
 341
 342         /* shortcut: check if the name is too long */
 343         if (cnp->cn_namelen >= PFS_NAMELEN)
 344                 PFS_RETURN (ENOENT);
 345
 346         /* check that parent directory is visisble... */
 347         if (!pfs_visible(curthread, pd, pvd->pvd_pid))
 348                 PFS_RETURN (ENOENT);
 349
 350         lockparent = cnp->cn_flags & LOCKPARENT;
 351         wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
 352
 353
 354         /* self */
 355         namelen = cnp->cn_namelen;
 356         pname = cnp->cn_nameptr;
 357         if (namelen == 1 && *pname == '.') {
 358                 pn = pd;
 359                 *vpp = vn;
 360                 VREF(vn);
 361                 PFS_RETURN (0);
 362         }
 363
 364         /* parent */
 365         if (cnp->cn_flags & ISDOTDOT) {
 366                 if (pd->pn_type == pfstype_root)
 367                         PFS_RETURN (EIO);
 368                 VOP_UNLOCK(vn, 0, cnp->cn_thread);
 369                 cnp->cn_flags |= PDIRUNLOCK;
 370
 371                 KASSERT(pd->pn_parent, ("non-root directory has no parent"));
 372                 /*
 373                  * This one is tricky.  Descendents of procdir nodes
 374                  * inherit their parent's process affinity, but
 375                  * there's no easy reverse mapping.  For simplicity,
 376                  * we assume that if this node is a procdir, its
 377                  * parent isn't (which is correct as long as
 378                  * descendents of procdir nodes are never procdir
 379                  * nodes themselves)
 380                  */
 381                 if (pd->pn_type == pfstype_procdir)
 382                         pid = NO_PID;
 383                 pn = pd->pn_parent;
 384                 goto got_pnode;
 385         }
 386
 387         /* named node */
 388         for (pn = pd->pn_nodes; pn != NULL; pn = pn->pn_next)
 389                 if (pn->pn_type == pfstype_procdir)
 390                         pdn = pn;
 391                 else if (pn->pn_name[namelen] == '\0'
 392                     && bcmp(pname, pn->pn_name, namelen) == 0)
 393                         goto got_pnode;
 394
 395         /* process dependent node */
 396         if ((pn = pdn) != NULL) {
 397                 pid = 0;
 398                 for (pid = 0, i = 0; i < namelen && isdigit(pname[i]); ++i)
 399                         if ((pid = pid * 10 + pname[i] - '0') > PID_MAX)
 400                                 break;
 401                 if (i == cnp->cn_namelen)
 402                         goto got_pnode;
 403         }
 404
 405         PFS_RETURN (ENOENT);
 406  got_pnode:
 407         if (pn != pd->pn_parent && !pn->pn_parent)
 408                 pn->pn_parent = pd;
 409         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 410                 PFS_RETURN (ENOENT);
 411
 412         error = pfs_vncache_alloc(vn->v_mount, vpp, pn, pid);
 413         if (error)
 414                 PFS_RETURN (error);
 415
 416         if ((cnp->cn_flags & ISDOTDOT) && (cnp->cn_flags & ISLASTCN)
 417             && lockparent) {
 418                 vn_lock(vn, LK_EXCLUSIVE|LK_RETRY, cnp->cn_thread);
 419                 cnp->cn_flags &= ~PDIRUNLOCK;
 420         }
 421         if (!((lockparent && (cnp->cn_flags & ISLASTCN)) ||
 422             (cnp->cn_flags & ISDOTDOT)))
 423                 VOP_UNLOCK(vn, 0, cnp->cn_thread);
 424
 425         /*
 426          * XXX See comment at top of the routine.
 427          */
 428         if (cnp->cn_flags & MAKEENTRY)
 429                 cache_enter(vn, *vpp, cnp);
 430         PFS_RETURN (0);
 431 }
 432
 433 /*
 434  * Open a file or directory.
 435  */
 436 static int
 437 pfs_open(struct vop_open_args *va)
 438 {
 439         struct vnode *vn = va->a_vp;
 440         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 441         struct pfs_node *pn = pvd->pvd_pn;
 442         int mode = va->a_mode;
 443
 444         PFS_TRACE(("%s (mode 0x%x)", pn->pn_name, mode));
 445
 446         /*
 447          * check if the file is visible to the caller
 448          *
 449          * XXX Not sure if this is necessary, as the VFS system calls
 450          * XXX pfs_lookup() and pfs_access() first, and pfs_lookup()
 451          * XXX calls pfs_visible().  There's a race condition here, but
 452          * XXX calling pfs_visible() from here doesn't really close it,
 453          * XXX and the only consequence of that race is an EIO further
 454          * XXX down the line.
 455          */
 456         if (!pfs_visible(va->a_td, pn, pvd->pvd_pid))
 457                 PFS_RETURN (ENOENT);
 458
 459         /* check if the requested mode is permitted */
 460         if (((mode & FREAD) && !(mode & PFS_RD)) ||
 461             ((mode & FWRITE) && !(mode & PFS_WR)))
 462                 PFS_RETURN (EPERM);
 463
 464         /* we don't support locking */
 465         if ((mode & O_SHLOCK) || (mode & O_EXLOCK))
 466                 PFS_RETURN (EOPNOTSUPP);
 467
 468         PFS_RETURN (0);
 469 }
 470
 471 /*
 472  * Read from a file
 473  */
 474 static int
 475 pfs_read(struct vop_read_args *va)
 476 {
 477         struct vnode *vn = va->a_vp;
 478         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 479         struct pfs_node *pn = pvd->pvd_pn;
 480         struct uio *uio = va->a_uio;
 481         struct proc *proc = NULL;
 482         struct sbuf *sb = NULL;
 483         int error;
 484         unsigned int buflen, offset, resid;
 485
 486         PFS_TRACE((pn->pn_name));
 487
 488         if (vn->v_type != VREG)
 489                 PFS_RETURN (EINVAL);
 490
 491         if (!(pn->pn_flags & PFS_RD))
 492                 PFS_RETURN (EBADF);
 493
 494         if (pn->pn_func == NULL)
 495                 PFS_RETURN (EIO);
 496
 497         /*
 498          * This is necessary because either process' privileges may
 499          * have changed since the open() call.
 500          */
 501         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 502                 PFS_RETURN (EIO);
 503
 504         /* XXX duplicates bits of pfs_visible() */
 505         if (pvd->pvd_pid != NO_PID) {
 506                 if ((proc = pfind(pvd->pvd_pid)) == NULL)
 507                         PFS_RETURN (EIO);
 508                 _PHOLD(proc);
 509                 PROC_UNLOCK(proc);
 510         }
 511
 512         if (pn->pn_flags & PFS_RAWRD) {
 513                 error = (pn->pn_func)(curthread, proc, pn, NULL, uio);
 514                 if (proc != NULL)
 515                         PRELE(proc);
 516                 PFS_RETURN (error);
 517         }
 518
 519         /* Beaucoup sanity checks so we don't ask for bogus allocation. */
 520         if (uio->uio_offset < 0 || uio->uio_resid < 0 ||
 521             (offset = uio->uio_offset) != uio->uio_offset ||
 522             (resid = uio->uio_resid) != uio->uio_resid ||
 523             (buflen = offset + resid) < offset || buflen > INT_MAX) {
 524                 if (proc != NULL)
 525                         PRELE(proc);
 526                 PFS_RETURN (EINVAL);
 527         }
 528         if (buflen > MAXPHYS) {
 529                 if (proc != NULL)
 530                         PRELE(proc);
 531                 PFS_RETURN (EIO);
 532         }
 533         sb = sbuf_new(sb, NULL, buflen, 0);
 534         if (sb == NULL) {
 535                 if (proc != NULL)
 536                         PRELE(proc);
 537                 PFS_RETURN (EIO);
 538         }
 539
 540         error = (pn->pn_func)(curthread, proc, pn, sb, uio);
 541
 542         if (proc != NULL)
 543                 PRELE(proc);
 544
 545         if (error) {
 546                 sbuf_delete(sb);
 547                 PFS_RETURN (error);
 548         }
 549
 550         sbuf_finish(sb);
 551         error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio);
 552         sbuf_delete(sb);
 553         PFS_RETURN (error);
 554 }
 555
 556 /*
 557  * Iterate through directory entries
 558  */
 559 static int
 560 pfs_iterate(struct thread *td, pid_t pid, struct pfs_node *pd,
 561             struct pfs_node **pn, struct proc **p)
 562 {
 563         sx_assert(&allproc_lock, SX_LOCKED);
 564  again:
 565         if (*pn == NULL) {
 566                 /* first node */
 567                 *pn = pd->pn_nodes;
 568         } else if ((*pn)->pn_type != pfstype_procdir) {
 569                 /* next node */
 570                 *pn = (*pn)->pn_next;
 571         }
 572         if (*pn != NULL && (*pn)->pn_type == pfstype_procdir) {
 573                 /* next process */
 574                 if (*p == NULL)
 575                         *p = LIST_FIRST(&allproc);
 576                 else
 577                         *p = LIST_NEXT(*p, p_list);
 578                 /* out of processes: next node */
 579                 if (*p == NULL)
 580                         *pn = (*pn)->pn_next;
 581         }
 582
 583         if ((*pn) == NULL)
 584                 return (-1);
 585
 586         if (!pfs_visible(td, *pn, *p ? (*p)->p_pid : pid))
 587                 goto again;
 588
 589         return (0);
 590 }
 591
 592 /*
 593  * Return directory entries.
 594  */
 595 static int
 596 pfs_readdir(struct vop_readdir_args *va)
 597 {
 598         struct vnode *vn = va->a_vp;
 599         struct pfs_info *pi = (struct pfs_info *)vn->v_mount->mnt_data;
 600         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 601         struct pfs_node *pd = pvd->pvd_pn;
 602         pid_t pid = pvd->pvd_pid;
 603         struct pfs_node *pn;
 604         struct dirent entry;
 605         struct uio *uio;
 606         struct proc *p;
 607         off_t offset;
 608         int error, i, resid;
 609         struct sbuf sb;
 610
 611         PFS_TRACE((pd->pn_name));
 612
 613         if (vn->v_type != VDIR)
 614                 PFS_RETURN (ENOTDIR);
 615         uio = va->a_uio;
 616
 617         /* check if the directory is visible to the caller */
 618         if (!pfs_visible(curthread, pd, pid))
 619                 PFS_RETURN (ENOENT);
 620
 621         /* only allow reading entire entries */
 622         offset = uio->uio_offset;
 623         resid = uio->uio_resid;
 624         if (offset < 0 || offset % PFS_DELEN != 0 || resid < PFS_DELEN)
 625                 PFS_RETURN (EINVAL);
 626
 627         if (sbuf_new(&sb, NULL, resid, SBUF_FIXEDLEN) == NULL)
 628                 PFS_RETURN (ENOMEM);
 629
 630         /* skip unwanted entries */
 631         sx_slock(&allproc_lock);
 632         for (pn = NULL, p = NULL; offset > 0; offset -= PFS_DELEN)
 633                 if (pfs_iterate(curthread, pid, pd, &pn, &p) == -1) {
 634                         /* nothing left... */
 635                         sx_sunlock(&allproc_lock);
 636                         sbuf_delete(&sb);
 637                         PFS_RETURN (0);
 638                 }
 639
 640         /* fill in entries */
 641         entry.d_reclen = PFS_DELEN;
 642         while (pfs_iterate(curthread, pid, pd, &pn, &p) != -1 && resid > 0) {
 643                 if (!pn->pn_parent)
 644                         pn->pn_parent = pd;
 645                 if (!pn->pn_fileno)
 646                         pfs_fileno_alloc(pi, pn);
 647                 if (pid != NO_PID)
 648                         entry.d_fileno = pn->pn_fileno * NO_PID + pid;
 649                 else
 650                         entry.d_fileno = pn->pn_fileno;
 651                 /* PFS_DELEN was picked to fit PFS_NAMLEN */
 652                 for (i = 0; i < PFS_NAMELEN - 1 && pn->pn_name[i] != '\0'; ++i)
 653                         entry.d_name[i] = pn->pn_name[i];
 654                 entry.d_name[i] = 0;
 655                 entry.d_namlen = i;
 656                 switch (pn->pn_type) {
 657                 case pfstype_procdir:
 658                         KASSERT(p != NULL,
 659                             ("reached procdir node with p == NULL"));
 660                         entry.d_fileno = pn->pn_fileno * NO_PID + p->p_pid;
 661                         entry.d_namlen = snprintf(entry.d_name,
 662                             PFS_NAMELEN, "%d", p->p_pid);
 663                         /* fall through */
 664                 case pfstype_root:
 665                 case pfstype_dir:
 666                 case pfstype_this:
 667                 case pfstype_parent:
 668                         entry.d_type = DT_DIR;
 669                         break;
 670                 case pfstype_file:
 671                         entry.d_type = DT_REG;
 672                         break;
 673                 case pfstype_symlink:
 674                         entry.d_type = DT_LNK;
 675                         break;
 676                 default:
 677                         panic("%s has unexpected node type: %d", pn->pn_name, pn->pn_type);
 678                 }
 679                 PFS_TRACE((entry.d_name));
 680                 sbuf_bcat(&sb, &entry, PFS_DELEN);
 681                 offset += PFS_DELEN;
 682                 resid -= PFS_DELEN;
 683         }
 684         sx_sunlock(&allproc_lock);
 685         sbuf_finish(&sb);
 686         error = uiomove(sbuf_data(&sb), sbuf_len(&sb), uio);
 687         sbuf_delete(&sb);
 688         PFS_RETURN (error);
 689 }
 690
 691 /*
 692  * Read a symbolic link
 693  */
 694 static int
 695 pfs_readlink(struct vop_readlink_args *va)
 696 {
 697         struct vnode *vn = va->a_vp;
 698         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 699         struct pfs_node *pn = pvd->pvd_pn;
 700         struct uio *uio = va->a_uio;
 701         struct proc *proc = NULL;
 702         char buf[MAXPATHLEN];
 703         struct sbuf sb;
 704         int error;
 705
 706         PFS_TRACE((pn->pn_name));
 707
 708         if (vn->v_type != VLNK)
 709                 PFS_RETURN (EINVAL);
 710
 711         if (pn->pn_func == NULL)
 712                 PFS_RETURN (EIO);
 713
 714         if (pvd->pvd_pid != NO_PID) {
 715                 if ((proc = pfind(pvd->pvd_pid)) == NULL)
 716                         PFS_RETURN (EIO);
 717                 _PHOLD(proc);
 718                 PROC_UNLOCK(proc);
 719         }
 720
 721         /* sbuf_new() can't fail with a static buffer */
 722         sbuf_new(&sb, buf, sizeof buf, 0);
 723
 724         error = (pn->pn_func)(curthread, proc, pn, &sb, NULL);
 725
 726         if (proc != NULL)
 727                 PRELE(proc);
 728
 729         if (error) {
 730                 sbuf_delete(&sb);
 731                 PFS_RETURN (error);
 732         }
 733
 734         sbuf_finish(&sb);
 735         error = uiomove_frombuf(sbuf_data(&sb), sbuf_len(&sb), uio);
 736         sbuf_delete(&sb);
 737         PFS_RETURN (error);
 738 }
 739
 740 /*
 741  * Reclaim a vnode
 742  */
 743 static int
 744 pfs_reclaim(struct vop_reclaim_args *va)
 745 {
 746         PFS_TRACE((((struct pfs_vdata *)va->a_vp->v_data)->pvd_pn->pn_name));
 747
 748         return (pfs_vncache_free(va->a_vp));
 749 }
 750
 751 /*
 752  * Set attributes
 753  */
 754 static int
 755 pfs_setattr(struct vop_setattr_args *va)
 756 {
 757         PFS_TRACE((((struct pfs_vdata *)va->a_vp->v_data)->pvd_pn->pn_name));
 758
 759         PFS_RETURN (EOPNOTSUPP);
 760 }
 761
 762 /*
 763  * Read from a file
 764  */
 765 static int
 766 pfs_write(struct vop_read_args *va)
 767 {
 768         struct vnode *vn = va->a_vp;
 769         struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
 770         struct pfs_node *pn = pvd->pvd_pn;
 771         struct uio *uio = va->a_uio;
 772         struct proc *proc = NULL;
 773         struct sbuf sb;
 774         int error;
 775
 776         PFS_TRACE((pn->pn_name));
 777
 778         if (vn->v_type != VREG)
 779                 PFS_RETURN (EINVAL);
 780
 781         if (!(pn->pn_flags & PFS_WR))
 782                 PFS_RETURN (EBADF);
 783
 784         if (pn->pn_func == NULL)
 785                 PFS_RETURN (EIO);
 786
 787         /*
 788          * This is necessary because either process' privileges may
 789          * have changed since the open() call.
 790          */
 791         if (!pfs_visible(curthread, pn, pvd->pvd_pid))
 792                 PFS_RETURN (EIO);
 793
 794         /* XXX duplicates bits of pfs_visible() */
 795         if (pvd->pvd_pid != NO_PID) {
 796                 if ((proc = pfind(pvd->pvd_pid)) == NULL)
 797                         PFS_RETURN (EIO);
 798                 _PHOLD(proc);
 799                 PROC_UNLOCK(proc);
 800         }
 801
 802         if (pn->pn_flags & PFS_RAWWR) {
 803                 error = (pn->pn_func)(curthread, proc, pn, NULL, uio);
 804                 if (proc != NULL)
 805                         PRELE(proc);
 806                 PFS_RETURN (error);
 807         }
 808
 809         sbuf_uionew(&sb, uio, &error);
 810         if (error)
 811                 PFS_RETURN (error);
 812
 813         error = (pn->pn_func)(curthread, proc, pn, &sb, uio);
 814
 815         if (proc != NULL)
 816                 PRELE(proc);
 817
 818         sbuf_delete(&sb);
 819         PFS_RETURN (error);
 820 }
 821
 822 /*
 823  * Vnode operations
 824  */
 825 vop_t **pfs_vnodeop_p;
 826 static struct vnodeopv_entry_desc pfs_vnodeop_entries[] = {
 827         { &vop_default_desc,            (vop_t *)vop_defaultop  },
 828         { &vop_access_desc,             (vop_t *)pfs_access     },
 829         { &vop_close_desc,              (vop_t *)pfs_close      },
 830         { &vop_create_desc,             (vop_t *)vop_eopnotsupp },
 831         { &vop_getattr_desc,            (vop_t *)pfs_getattr    },
 832         { &vop_getextattr_desc,         (vop_t *)pfs_getextattr },
 833         { &vop_ioctl_desc,              (vop_t *)pfs_ioctl      },
 834         { &vop_link_desc,               (vop_t *)vop_eopnotsupp },
 835         { &vop_lookup_desc,             (vop_t *)pfs_lookup     },
 836         { &vop_mkdir_desc,              (vop_t *)vop_eopnotsupp },
 837         { &vop_mknod_desc,              (vop_t *)vop_eopnotsupp },
 838         { &vop_open_desc,               (vop_t *)pfs_open       },
 839         { &vop_read_desc,               (vop_t *)pfs_read       },
 840         { &vop_readdir_desc,            (vop_t *)pfs_readdir    },
 841         { &vop_readlink_desc,           (vop_t *)pfs_readlink   },
 842         { &vop_reclaim_desc,            (vop_t *)pfs_reclaim    },
 843         { &vop_remove_desc,             (vop_t *)vop_eopnotsupp },
 844         { &vop_rename_desc,             (vop_t *)vop_eopnotsupp },
 845         { &vop_rmdir_desc,              (vop_t *)vop_eopnotsupp },
 846         { &vop_setattr_desc,            (vop_t *)pfs_setattr    },
 847         { &vop_symlink_desc,            (vop_t *)vop_eopnotsupp },
 848         { &vop_write_desc,              (vop_t *)pfs_write      },
 849         /* XXX I've probably forgotten a few that need vop_eopnotsupp */
 850         { NULL,                         (vop_t *)NULL           }
 851 };
 852
 853 static struct vnodeopv_desc pfs_vnodeop_opv_desc =
 854         { &pfs_vnodeop_p, pfs_vnodeop_entries };
 855
 856 VNODEOP_SET(pfs_vnodeop_opv_desc);