1/*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2001 Dag-Erling Co��dan Sm��rgrav 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer 12 * in this position and unchanged. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31#include <sys/cdefs.h> 32__FBSDID("$FreeBSD$"); 33 34#include "opt_pseudofs.h" 35 36#include <sys/param.h> 37#include <sys/kernel.h> 38#include <sys/systm.h> 39#include <sys/ctype.h> 40#include <sys/dirent.h> 41#include <sys/fcntl.h> 42#include <sys/limits.h> 43#include <sys/lock.h> 44#include <sys/malloc.h> 45#include <sys/mount.h> 46#include <sys/mutex.h> 47#include <sys/namei.h> 48#include <sys/proc.h> 49#include <sys/sbuf.h> 50#include <sys/sx.h> 51#include <sys/sysctl.h> 52#include <sys/vnode.h> 53 54#include <fs/pseudofs/pseudofs.h> 55#include <fs/pseudofs/pseudofs_internal.h> 56 57#define KASSERT_PN_IS_DIR(pn) \ 58 KASSERT((pn)->pn_type == pfstype_root || \ 59 (pn)->pn_type == pfstype_dir || \ 60 (pn)->pn_type == pfstype_procdir, \ 61 ("%s(): VDIR vnode refers to non-directory pfs_node", __func__)) 62 63#define KASSERT_PN_IS_FILE(pn) \ 64 KASSERT((pn)->pn_type == pfstype_file, \ 65 ("%s(): VREG vnode refers to non-file pfs_node", __func__)) 66 67#define KASSERT_PN_IS_LINK(pn) \ 68 KASSERT((pn)->pn_type == pfstype_symlink, \ 69 ("%s(): VLNK vnode refers to non-link pfs_node", __func__)) 70 71#define PFS_MAXBUFSIZ 1024 * 1024 72 73/* 74 * Returns the fileno, adjusted for target pid 75 */ 76static uint32_t 77pn_fileno(struct pfs_node *pn, pid_t pid) 78{ 79 80 KASSERT(pn->pn_fileno > 0, 81 ("%s(): no fileno allocated", __func__)); 82 if (pid != NO_PID) 83 return (pn->pn_fileno * NO_PID + pid); 84 return (pn->pn_fileno); 85} 86 87/* 88 * Returns non-zero if given file is visible to given thread. 89 */ 90static int 91pfs_visible_proc(struct thread *td, struct pfs_node *pn, struct proc *proc) 92{ 93 int visible; 94 95 if (proc == NULL) 96 return (0); 97 98 PROC_LOCK_ASSERT(proc, MA_OWNED); 99 100 visible = ((proc->p_flag & P_WEXIT) == 0); 101 if (visible) 102 visible = (p_cansee(td, proc) == 0); 103 if (visible && pn->pn_vis != NULL) 104 visible = pn_vis(td, proc, pn); 105 if (!visible) 106 return (0); 107 return (1); 108} 109 110static int 111pfs_visible(struct thread *td, struct pfs_node *pn, pid_t pid, 112 bool allproc_locked, struct proc **p) 113{ 114 struct proc *proc; 115 116 PFS_TRACE(("%s (pid: %d, req: %d)", 117 pn->pn_name, pid, td->td_proc->p_pid)); 118 119 if (p) 120 *p = NULL; 121 if (pid == NO_PID) 122 PFS_RETURN (1); 123 proc = allproc_locked ? pfind_locked(pid) : pfind(pid); 124 if (proc == NULL) 125 PFS_RETURN (0); 126 if (pfs_visible_proc(td, pn, proc)) { 127 if (p) 128 *p = proc; 129 else 130 PROC_UNLOCK(proc); 131 PFS_RETURN (1); 132 } 133 PROC_UNLOCK(proc); 134 PFS_RETURN (0); 135} 136 137/* 138 * Verify permissions 139 */ 140static int 141pfs_access(struct vop_access_args *va) 142{ 143 struct vnode *vn = va->a_vp; 144 struct pfs_vdata *pvd = vn->v_data; 145 struct vattr vattr; 146 int error; 147 148 PFS_TRACE(("%s", pvd->pvd_pn->pn_name)); 149 (void)pvd; 150 151 error = VOP_GETATTR(vn, &vattr, va->a_cred); 152 if (error) 153 PFS_RETURN (error); 154 error = vaccess(vn->v_type, vattr.va_mode, vattr.va_uid, 155 vattr.va_gid, va->a_accmode, va->a_cred, NULL); 156 PFS_RETURN (error); 157} 158 159/* 160 * Close a file or directory 161 */ 162static int 163pfs_close(struct vop_close_args *va) 164{ 165 struct vnode *vn = va->a_vp; 166 struct pfs_vdata *pvd = vn->v_data; 167 struct pfs_node *pn = pvd->pvd_pn; 168 struct proc *proc; 169 int error; 170 171 PFS_TRACE(("%s", pn->pn_name)); 172 pfs_assert_not_owned(pn); 173 174 /* 175 * Do nothing unless this is the last close and the node has a 176 * last-close handler. 177 */ 178 if (vrefcnt(vn) > 1 || pn->pn_close == NULL) 179 PFS_RETURN (0); 180 181 if (pvd->pvd_pid != NO_PID) { 182 proc = pfind(pvd->pvd_pid); 183 } else { 184 proc = NULL; 185 } 186 187 error = pn_close(va->a_td, proc, pn); 188 189 if (proc != NULL) 190 PROC_UNLOCK(proc); 191 192 PFS_RETURN (error); 193} 194 195/* 196 * Get file attributes 197 */ 198static int 199pfs_getattr(struct vop_getattr_args *va) 200{ 201 struct vnode *vn = va->a_vp; 202 struct pfs_vdata *pvd = vn->v_data; 203 struct pfs_node *pn = pvd->pvd_pn; 204 struct vattr *vap = va->a_vap; 205 struct proc *proc; 206 int error = 0; 207 208 PFS_TRACE(("%s", pn->pn_name)); 209 pfs_assert_not_owned(pn); 210 211 if (!pfs_visible(curthread, pn, pvd->pvd_pid, false, &proc)) 212 PFS_RETURN (ENOENT); 213 214 vap->va_type = vn->v_type; 215 vap->va_fileid = pn_fileno(pn, pvd->pvd_pid); 216 vap->va_flags = 0; 217 vap->va_blocksize = PAGE_SIZE; 218 vap->va_bytes = vap->va_size = 0; 219 vap->va_filerev = 0; 220 vap->va_fsid = vn->v_mount->mnt_stat.f_fsid.val[0]; 221 vap->va_nlink = 1; 222 nanotime(&vap->va_ctime); 223 vap->va_atime = vap->va_mtime = vap->va_ctime; 224 225 switch (pn->pn_type) { 226 case pfstype_procdir: 227 case pfstype_root: 228 case pfstype_dir: 229#if 0 230 pfs_lock(pn); 231 /* compute link count */ 232 pfs_unlock(pn); 233#endif 234 vap->va_mode = 0555; 235 break; 236 case pfstype_file: 237 case pfstype_symlink: 238 vap->va_mode = 0444; 239 break; 240 default: 241 printf("shouldn't be here!\n"); 242 vap->va_mode = 0; 243 break; 244 } 245 246 if (proc != NULL) { 247 vap->va_uid = proc->p_ucred->cr_ruid; 248 vap->va_gid = proc->p_ucred->cr_rgid; 249 } else { 250 vap->va_uid = 0; 251 vap->va_gid = 0; 252 } 253 254 if (pn->pn_attr != NULL) 255 error = pn_attr(curthread, proc, pn, vap); 256 257 if(proc != NULL) 258 PROC_UNLOCK(proc); 259 260 PFS_RETURN (error); 261} 262 263/* 264 * Perform an ioctl 265 */ 266static int 267pfs_ioctl(struct vop_ioctl_args *va) 268{ 269 struct vnode *vn; 270 struct pfs_vdata *pvd; 271 struct pfs_node *pn; 272 struct proc *proc; 273 int error; 274 275 vn = va->a_vp; 276 vn_lock(vn, LK_SHARED | LK_RETRY); 277 if (vn->v_iflag & VI_DOOMED) { 278 VOP_UNLOCK(vn, 0); 279 return (EBADF); 280 } 281 pvd = vn->v_data; 282 pn = pvd->pvd_pn; 283 284 PFS_TRACE(("%s: %lx", pn->pn_name, va->a_command)); 285 pfs_assert_not_owned(pn); 286 287 if (vn->v_type != VREG) { 288 VOP_UNLOCK(vn, 0); 289 PFS_RETURN (EINVAL); 290 } 291 KASSERT_PN_IS_FILE(pn); 292 293 if (pn->pn_ioctl == NULL) { 294 VOP_UNLOCK(vn, 0); 295 PFS_RETURN (ENOTTY); 296 } 297 298 /* 299 * This is necessary because process' privileges may 300 * have changed since the open() call. 301 */ 302 if (!pfs_visible(curthread, pn, pvd->pvd_pid, false, &proc)) { 303 VOP_UNLOCK(vn, 0); 304 PFS_RETURN (EIO); 305 } 306 307 error = pn_ioctl(curthread, proc, pn, va->a_command, va->a_data); 308 309 if (proc != NULL) 310 PROC_UNLOCK(proc); 311 312 VOP_UNLOCK(vn, 0); 313 PFS_RETURN (error); 314} 315 316/* 317 * Perform getextattr 318 */ 319static int 320pfs_getextattr(struct vop_getextattr_args *va) 321{ 322 struct vnode *vn = va->a_vp; 323 struct pfs_vdata *pvd = vn->v_data; 324 struct pfs_node *pn = pvd->pvd_pn; 325 struct proc *proc; 326 int error; 327 328 PFS_TRACE(("%s", pn->pn_name)); 329 pfs_assert_not_owned(pn); 330 331 /* 332 * This is necessary because either process' privileges may 333 * have changed since the open() call. 334 */ 335 if (!pfs_visible(curthread, pn, pvd->pvd_pid, false, &proc)) 336 PFS_RETURN (EIO); 337 338 if (pn->pn_getextattr == NULL) 339 error = EOPNOTSUPP; 340 else 341 error = pn_getextattr(curthread, proc, pn, 342 va->a_attrnamespace, va->a_name, va->a_uio, 343 va->a_size, va->a_cred); 344 345 if (proc != NULL) 346 PROC_UNLOCK(proc); 347 348 PFS_RETURN (error); 349} 350 351/* 352 * Convert a vnode to its component name 353 */ 354static int 355pfs_vptocnp(struct vop_vptocnp_args *ap) 356{ 357 struct vnode *vp = ap->a_vp; 358 struct vnode **dvp = ap->a_vpp; 359 struct pfs_vdata *pvd = vp->v_data; 360 struct pfs_node *pd = pvd->pvd_pn; 361 struct pfs_node *pn; 362 struct mount *mp; 363 char *buf = ap->a_buf; 364 int *buflen = ap->a_buflen; 365 char pidbuf[PFS_NAMELEN]; 366 pid_t pid = pvd->pvd_pid; 367 int len, i, error, locked; 368 369 i = *buflen; 370 error = 0; 371 372 pfs_lock(pd); 373 374 if (vp->v_type == VDIR && pd->pn_type == pfstype_root) { 375 *dvp = vp; 376 vhold(*dvp); 377 pfs_unlock(pd); 378 PFS_RETURN (0); 379 } else if (vp->v_type == VDIR && pd->pn_type == pfstype_procdir) { 380 len = snprintf(pidbuf, sizeof(pidbuf), "%d", pid); 381 i -= len; 382 if (i < 0) { 383 error = ENOMEM; 384 goto failed; 385 } 386 bcopy(pidbuf, buf + i, len); 387 } else { 388 len = strlen(pd->pn_name); 389 i -= len; 390 if (i < 0) { 391 error = ENOMEM; 392 goto failed; 393 } 394 bcopy(pd->pn_name, buf + i, len); 395 } 396 397 pn = pd->pn_parent; 398 pfs_unlock(pd); 399 400 mp = vp->v_mount; 401 error = vfs_busy(mp, 0); 402 if (error) 403 return (error); 404 405 /* 406 * vp is held by caller. 407 */ 408 locked = VOP_ISLOCKED(vp); 409 VOP_UNLOCK(vp, 0); 410 411 error = pfs_vncache_alloc(mp, dvp, pn, pid); 412 if (error) { 413 vn_lock(vp, locked | LK_RETRY); 414 vfs_unbusy(mp); 415 PFS_RETURN(error); 416 } 417 418 *buflen = i; 419 VOP_UNLOCK(*dvp, 0); 420 vn_lock(vp, locked | LK_RETRY); 421 vfs_unbusy(mp); 422 423 PFS_RETURN (0); 424failed: 425 pfs_unlock(pd); 426 PFS_RETURN(error); 427} 428 429/* 430 * Look up a file or directory 431 */ 432static int 433pfs_lookup(struct vop_cachedlookup_args *va) 434{ 435 struct vnode *vn = va->a_dvp; 436 struct vnode **vpp = va->a_vpp; 437 struct componentname *cnp = va->a_cnp; 438 struct pfs_vdata *pvd = vn->v_data; 439 struct pfs_node *pd = pvd->pvd_pn; 440 struct pfs_node *pn, *pdn = NULL; 441 struct mount *mp; 442 pid_t pid = pvd->pvd_pid; 443 char *pname; 444 int error, i, namelen, visible; 445 446 PFS_TRACE(("%.*s", (int)cnp->cn_namelen, cnp->cn_nameptr)); 447 pfs_assert_not_owned(pd); 448 449 if (vn->v_type != VDIR) 450 PFS_RETURN (ENOTDIR); 451 KASSERT_PN_IS_DIR(pd); 452 453 /* 454 * Don't support DELETE or RENAME. CREATE is supported so 455 * that O_CREAT will work, but the lookup will still fail if 456 * the file does not exist. 457 */ 458 if ((cnp->cn_flags & ISLASTCN) && 459 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 460 PFS_RETURN (EOPNOTSUPP); 461 462 /* shortcut: check if the name is too long */ 463 if (cnp->cn_namelen >= PFS_NAMELEN) 464 PFS_RETURN (ENOENT); 465 466 /* check that parent directory is visible... */ 467 if (!pfs_visible(curthread, pd, pvd->pvd_pid, false, NULL)) 468 PFS_RETURN (ENOENT); 469 470 /* self */ 471 namelen = cnp->cn_namelen; 472 pname = cnp->cn_nameptr; 473 if (namelen == 1 && pname[0] == '.') { 474 pn = pd; 475 *vpp = vn; 476 VREF(vn); 477 PFS_RETURN (0); 478 } 479 480 mp = vn->v_mount; 481 482 /* parent */ 483 if (cnp->cn_flags & ISDOTDOT) { 484 if (pd->pn_type == pfstype_root) 485 PFS_RETURN (EIO); 486 error = vfs_busy(mp, MBF_NOWAIT); 487 if (error != 0) { 488 vfs_ref(mp); 489 VOP_UNLOCK(vn, 0); 490 error = vfs_busy(mp, 0); 491 vn_lock(vn, LK_EXCLUSIVE | LK_RETRY); 492 vfs_rel(mp); 493 if (error != 0) 494 PFS_RETURN(ENOENT); 495 if (vn->v_iflag & VI_DOOMED) { 496 vfs_unbusy(mp); 497 PFS_RETURN(ENOENT); 498 } 499 } 500 VOP_UNLOCK(vn, 0); 501 KASSERT(pd->pn_parent != NULL, 502 ("%s(): non-root directory has no parent", __func__)); 503 /* 504 * This one is tricky. Descendents of procdir nodes 505 * inherit their parent's process affinity, but 506 * there's no easy reverse mapping. For simplicity, 507 * we assume that if this node is a procdir, its 508 * parent isn't (which is correct as long as 509 * descendents of procdir nodes are never procdir 510 * nodes themselves) 511 */ 512 if (pd->pn_type == pfstype_procdir) 513 pid = NO_PID; 514 pfs_lock(pd); 515 pn = pd->pn_parent; 516 pfs_unlock(pd); 517 goto got_pnode; 518 } 519 520 pfs_lock(pd); 521 522 /* named node */ 523 for (pn = pd->pn_nodes; pn != NULL; pn = pn->pn_next) 524 if (pn->pn_type == pfstype_procdir) 525 pdn = pn; 526 else if (pn->pn_name[namelen] == '\0' && 527 bcmp(pname, pn->pn_name, namelen) == 0) { 528 pfs_unlock(pd); 529 goto got_pnode; 530 } 531 532 /* process dependent node */ 533 if ((pn = pdn) != NULL) { 534 pid = 0; 535 for (pid = 0, i = 0; i < namelen && isdigit(pname[i]); ++i) 536 if ((pid = pid * 10 + pname[i] - '0') > PID_MAX) 537 break; 538 if (i == cnp->cn_namelen) { 539 pfs_unlock(pd); 540 goto got_pnode; 541 } 542 } 543 544 pfs_unlock(pd); 545 546 PFS_RETURN (ENOENT); 547 548 got_pnode: 549 pfs_assert_not_owned(pd); 550 pfs_assert_not_owned(pn); 551 visible = pfs_visible(curthread, pn, pid, false, NULL); 552 if (!visible) { 553 error = ENOENT; 554 goto failed; 555 } 556 557 error = pfs_vncache_alloc(mp, vpp, pn, pid); 558 if (error) 559 goto failed; 560 561 if (cnp->cn_flags & ISDOTDOT) { 562 vfs_unbusy(mp); 563 vn_lock(vn, LK_EXCLUSIVE | LK_RETRY); 564 if (vn->v_iflag & VI_DOOMED) { 565 vput(*vpp); 566 *vpp = NULL; 567 PFS_RETURN(ENOENT); 568 } 569 } 570 if (cnp->cn_flags & MAKEENTRY && !(vn->v_iflag & VI_DOOMED)) 571 cache_enter(vn, *vpp, cnp); 572 PFS_RETURN (0); 573 failed: 574 if (cnp->cn_flags & ISDOTDOT) { 575 vfs_unbusy(mp); 576 vn_lock(vn, LK_EXCLUSIVE | LK_RETRY); 577 *vpp = NULL; 578 } 579 PFS_RETURN(error); 580} 581 582/* 583 * Open a file or directory. 584 */ 585static int 586pfs_open(struct vop_open_args *va) 587{ 588 struct vnode *vn = va->a_vp; 589 struct pfs_vdata *pvd = vn->v_data; 590 struct pfs_node *pn = pvd->pvd_pn; 591 int mode = va->a_mode; 592 593 PFS_TRACE(("%s (mode 0x%x)", pn->pn_name, mode)); 594 pfs_assert_not_owned(pn); 595 596 /* check if the requested mode is permitted */ 597 if (((mode & FREAD) && !(mode & PFS_RD)) || 598 ((mode & FWRITE) && !(mode & PFS_WR))) 599 PFS_RETURN (EPERM); 600 601 /* we don't support locking */ 602 if ((mode & O_SHLOCK) || (mode & O_EXLOCK)) 603 PFS_RETURN (EOPNOTSUPP); 604 605 PFS_RETURN (0); 606} 607 608/* 609 * Read from a file 610 */ 611static int 612pfs_read(struct vop_read_args *va) 613{ 614 struct vnode *vn = va->a_vp; 615 struct pfs_vdata *pvd = vn->v_data; 616 struct pfs_node *pn = pvd->pvd_pn; 617 struct uio *uio = va->a_uio; 618 struct proc *proc; 619 struct sbuf *sb = NULL; 620 int error, locked; 621 off_t buflen; 622 623 PFS_TRACE(("%s", pn->pn_name)); 624 pfs_assert_not_owned(pn); 625 626 if (vn->v_type != VREG) 627 PFS_RETURN (EINVAL); 628 KASSERT_PN_IS_FILE(pn); 629 630 if (!(pn->pn_flags & PFS_RD)) 631 PFS_RETURN (EBADF); 632 633 if (pn->pn_fill == NULL) 634 PFS_RETURN (EIO); 635 636 /* 637 * This is necessary because either process' privileges may 638 * have changed since the open() call. 639 */ 640 if (!pfs_visible(curthread, pn, pvd->pvd_pid, false, &proc)) 641 PFS_RETURN (EIO); 642 if (proc != NULL) { 643 _PHOLD(proc); 644 PROC_UNLOCK(proc); 645 } 646 647 vhold(vn); 648 locked = VOP_ISLOCKED(vn); 649 VOP_UNLOCK(vn, 0); 650 651 if (pn->pn_flags & PFS_RAWRD) { 652 PFS_TRACE(("%zd resid", uio->uio_resid)); 653 error = pn_fill(curthread, proc, pn, NULL, uio); 654 PFS_TRACE(("%zd resid", uio->uio_resid)); 655 goto ret; 656 } 657 658 if (uio->uio_resid < 0 || uio->uio_offset < 0 || 659 uio->uio_resid > OFF_MAX - uio->uio_offset) { 660 error = EINVAL; 661 goto ret; 662 } 663 buflen = uio->uio_offset + uio->uio_resid; 664 if (buflen > PFS_MAXBUFSIZ) 665 buflen = PFS_MAXBUFSIZ; 666 667 sb = sbuf_new(sb, NULL, buflen + 1, 0); 668 if (sb == NULL) { 669 error = EIO; 670 goto ret; 671 } 672 673 error = pn_fill(curthread, proc, pn, sb, uio); 674 675 if (error) { 676 sbuf_delete(sb); 677 goto ret; 678 } 679 680 /* 681 * XXX: If the buffer overflowed, sbuf_len() will not return 682 * the data length. Then just use the full length because an 683 * overflowed sbuf must be full. 684 */ 685 if (sbuf_finish(sb) == 0) 686 buflen = sbuf_len(sb); 687 error = uiomove_frombuf(sbuf_data(sb), buflen, uio); 688 sbuf_delete(sb); 689ret: 690 vn_lock(vn, locked | LK_RETRY); 691 vdrop(vn); 692 if (proc != NULL) 693 PRELE(proc); 694 PFS_RETURN (error); 695} 696 697/* 698 * Iterate through directory entries 699 */ 700static int 701pfs_iterate(struct thread *td, struct proc *proc, struct pfs_node *pd, 702 struct pfs_node **pn, struct proc **p) 703{ 704 int visible; 705 706 sx_assert(&allproc_lock, SX_SLOCKED); 707 pfs_assert_owned(pd); 708 again: 709 if (*pn == NULL) { 710 /* first node */ 711 *pn = pd->pn_nodes; 712 } else if ((*pn)->pn_type != pfstype_procdir) { 713 /* next node */ 714 *pn = (*pn)->pn_next; 715 } 716 if (*pn != NULL && (*pn)->pn_type == pfstype_procdir) { 717 /* next process */ 718 if (*p == NULL) 719 *p = LIST_FIRST(&allproc); 720 else 721 *p = LIST_NEXT(*p, p_list); 722 /* out of processes: next node */ 723 if (*p == NULL) 724 *pn = (*pn)->pn_next; 725 else 726 PROC_LOCK(*p); 727 } 728 729 if ((*pn) == NULL) 730 return (-1); 731 732 if (*p != NULL) { 733 visible = pfs_visible_proc(td, *pn, *p); 734 PROC_UNLOCK(*p); 735 } else if (proc != NULL) { 736 visible = pfs_visible_proc(td, *pn, proc); 737 } else { 738 visible = 1; 739 } 740 if (!visible) 741 goto again; 742 743 return (0); 744} 745 746/* Directory entry list */ 747struct pfsentry { 748 STAILQ_ENTRY(pfsentry) link; 749 struct dirent entry; 750}; 751STAILQ_HEAD(pfsdirentlist, pfsentry); 752 753/* 754 * Return directory entries. 755 */ 756static int 757pfs_readdir(struct vop_readdir_args *va) 758{ 759 struct vnode *vn = va->a_vp; 760 struct pfs_vdata *pvd = vn->v_data; 761 struct pfs_node *pd = pvd->pvd_pn; 762 pid_t pid = pvd->pvd_pid; 763 struct proc *p, *proc; 764 struct pfs_node *pn; 765 struct uio *uio; 766 struct pfsentry *pfsent, *pfsent2; 767 struct pfsdirentlist lst; 768 off_t offset; 769 int error, i, resid; 770 771 STAILQ_INIT(&lst); 772 error = 0; 773 KASSERT(pd->pn_info == vn->v_mount->mnt_data, 774 ("%s(): pn_info does not match mountpoint", __func__)); 775 PFS_TRACE(("%s pid %lu", pd->pn_name, (unsigned long)pid)); 776 pfs_assert_not_owned(pd); 777 778 if (vn->v_type != VDIR) 779 PFS_RETURN (ENOTDIR); 780 KASSERT_PN_IS_DIR(pd); 781 uio = va->a_uio; 782 783 /* only allow reading entire entries */ 784 offset = uio->uio_offset; 785 resid = uio->uio_resid; 786 if (offset < 0 || offset % PFS_DELEN != 0 || 787 (resid && resid < PFS_DELEN)) 788 PFS_RETURN (EINVAL); 789 if (resid == 0) 790 PFS_RETURN (0); 791 792 sx_slock(&allproc_lock); 793 pfs_lock(pd); 794 795 /* check if the directory is visible to the caller */ 796 if (!pfs_visible(curthread, pd, pid, true, &proc)) { 797 sx_sunlock(&allproc_lock); 798 pfs_unlock(pd); 799 PFS_RETURN (ENOENT); 800 } 801 KASSERT(pid == NO_PID || proc != NULL, 802 ("%s(): no process for pid %lu", __func__, (unsigned long)pid)); 803 804 /* skip unwanted entries */ 805 for (pn = NULL, p = NULL; offset > 0; offset -= PFS_DELEN) { 806 if (pfs_iterate(curthread, proc, pd, &pn, &p) == -1) { 807 /* nothing left... */ 808 if (proc != NULL) 809 PROC_UNLOCK(proc); 810 pfs_unlock(pd); 811 sx_sunlock(&allproc_lock); 812 PFS_RETURN (0); 813 } 814 } 815 816 /* fill in entries */ 817 while (pfs_iterate(curthread, proc, pd, &pn, &p) != -1 && 818 resid >= PFS_DELEN) { 819 if ((pfsent = malloc(sizeof(struct pfsentry), M_IOV, 820 M_NOWAIT | M_ZERO)) == NULL) { 821 error = ENOMEM; 822 break; 823 } 824 pfsent->entry.d_reclen = PFS_DELEN; 825 pfsent->entry.d_fileno = pn_fileno(pn, pid); 826 /* PFS_DELEN was picked to fit PFS_NAMLEN */ 827 for (i = 0; i < PFS_NAMELEN - 1 && pn->pn_name[i] != '\0'; ++i) 828 pfsent->entry.d_name[i] = pn->pn_name[i]; 829 pfsent->entry.d_namlen = i; 830 /* NOTE: d_off is the offset of the *next* entry. */ 831 pfsent->entry.d_off = offset + PFS_DELEN; 832 switch (pn->pn_type) { 833 case pfstype_procdir: 834 KASSERT(p != NULL, 835 ("reached procdir node with p == NULL")); 836 pfsent->entry.d_namlen = snprintf(pfsent->entry.d_name, 837 PFS_NAMELEN, "%d", p->p_pid); 838 /* fall through */ 839 case pfstype_root: 840 case pfstype_dir: 841 case pfstype_this: 842 case pfstype_parent: 843 pfsent->entry.d_type = DT_DIR; 844 break; 845 case pfstype_file: 846 pfsent->entry.d_type = DT_REG; 847 break; 848 case pfstype_symlink: 849 pfsent->entry.d_type = DT_LNK; 850 break; 851 default: 852 panic("%s has unexpected node type: %d", pn->pn_name, pn->pn_type); 853 } 854 PFS_TRACE(("%s", pfsent->entry.d_name)); 855 dirent_terminate(&pfsent->entry); 856 STAILQ_INSERT_TAIL(&lst, pfsent, link); 857 offset += PFS_DELEN; 858 resid -= PFS_DELEN; 859 } 860 if (proc != NULL) 861 PROC_UNLOCK(proc); 862 pfs_unlock(pd); 863 sx_sunlock(&allproc_lock); 864 i = 0; 865 STAILQ_FOREACH_SAFE(pfsent, &lst, link, pfsent2) { 866 if (error == 0) 867 error = uiomove(&pfsent->entry, PFS_DELEN, uio); 868 free(pfsent, M_IOV); 869 i++; 870 } 871 PFS_TRACE(("%ju bytes", (uintmax_t)(i * PFS_DELEN))); 872 PFS_RETURN (error); 873} 874 875/* 876 * Read a symbolic link 877 */ 878static int 879pfs_readlink(struct vop_readlink_args *va) 880{ 881 struct vnode *vn = va->a_vp; 882 struct pfs_vdata *pvd = vn->v_data; 883 struct pfs_node *pn = pvd->pvd_pn; 884 struct uio *uio = va->a_uio; 885 struct proc *proc = NULL; 886 char buf[PATH_MAX]; 887 struct sbuf sb; 888 int error, locked; 889 890 PFS_TRACE(("%s", pn->pn_name)); 891 pfs_assert_not_owned(pn); 892 893 if (vn->v_type != VLNK) 894 PFS_RETURN (EINVAL); 895 KASSERT_PN_IS_LINK(pn); 896 897 if (pn->pn_fill == NULL) 898 PFS_RETURN (EIO); 899 900 if (pvd->pvd_pid != NO_PID) { 901 if ((proc = pfind(pvd->pvd_pid)) == NULL) 902 PFS_RETURN (EIO); 903 if (proc->p_flag & P_WEXIT) { 904 PROC_UNLOCK(proc); 905 PFS_RETURN (EIO); 906 } 907 _PHOLD(proc); 908 PROC_UNLOCK(proc); 909 } 910 vhold(vn); 911 locked = VOP_ISLOCKED(vn); 912 VOP_UNLOCK(vn, 0); 913 914 /* sbuf_new() can't fail with a static buffer */ 915 sbuf_new(&sb, buf, sizeof buf, 0); 916 917 error = pn_fill(curthread, proc, pn, &sb, NULL); 918 919 if (proc != NULL) 920 PRELE(proc); 921 vn_lock(vn, locked | LK_RETRY); 922 vdrop(vn); 923 924 if (error) { 925 sbuf_delete(&sb); 926 PFS_RETURN (error); 927 } 928 929 if (sbuf_finish(&sb) != 0) { 930 sbuf_delete(&sb); 931 PFS_RETURN (ENAMETOOLONG); 932 } 933 934 error = uiomove_frombuf(sbuf_data(&sb), sbuf_len(&sb), uio); 935 sbuf_delete(&sb); 936 PFS_RETURN (error); 937} 938 939/* 940 * Reclaim a vnode 941 */ 942static int 943pfs_reclaim(struct vop_reclaim_args *va) 944{ 945 struct vnode *vn = va->a_vp; 946 struct pfs_vdata *pvd = vn->v_data; 947 struct pfs_node *pn = pvd->pvd_pn; 948 949 PFS_TRACE(("%s", pn->pn_name)); 950 pfs_assert_not_owned(pn); 951 952 return (pfs_vncache_free(va->a_vp)); 953} 954 955/* 956 * Set attributes 957 */ 958static int 959pfs_setattr(struct vop_setattr_args *va) 960{ 961 struct vnode *vn = va->a_vp; 962 struct pfs_vdata *pvd = vn->v_data; 963 struct pfs_node *pn = pvd->pvd_pn; 964 965 PFS_TRACE(("%s", pn->pn_name)); 966 pfs_assert_not_owned(pn); 967 968 /* Silently ignore unchangeable attributes. */ 969 PFS_RETURN (0); 970} 971 972/* 973 * Write to a file 974 */ 975static int 976pfs_write(struct vop_write_args *va) 977{ 978 struct vnode *vn = va->a_vp; 979 struct pfs_vdata *pvd = vn->v_data; 980 struct pfs_node *pn = pvd->pvd_pn; 981 struct uio *uio = va->a_uio; 982 struct proc *proc; 983 struct sbuf sb; 984 int error; 985 986 PFS_TRACE(("%s", pn->pn_name)); 987 pfs_assert_not_owned(pn); 988 989 if (vn->v_type != VREG) 990 PFS_RETURN (EINVAL); 991 KASSERT_PN_IS_FILE(pn); 992 993 if (!(pn->pn_flags & PFS_WR)) 994 PFS_RETURN (EBADF); 995 996 if (pn->pn_fill == NULL) 997 PFS_RETURN (EIO); 998 999 if (uio->uio_resid > PFS_MAXBUFSIZ) 1000 PFS_RETURN (EIO); 1001 1002 /* 1003 * This is necessary because either process' privileges may 1004 * have changed since the open() call. 1005 */ 1006 if (!pfs_visible(curthread, pn, pvd->pvd_pid, false, &proc)) 1007 PFS_RETURN (EIO); 1008 if (proc != NULL) { 1009 _PHOLD(proc); 1010 PROC_UNLOCK(proc); 1011 } 1012 1013 if (pn->pn_flags & PFS_RAWWR) { 1014 error = pn_fill(curthread, proc, pn, NULL, uio); 1015 if (proc != NULL) 1016 PRELE(proc); 1017 PFS_RETURN (error); 1018 } 1019 1020 sbuf_uionew(&sb, uio, &error); 1021 if (error) { 1022 if (proc != NULL) 1023 PRELE(proc); 1024 PFS_RETURN (error); 1025 } 1026 1027 error = pn_fill(curthread, proc, pn, &sb, uio); 1028 1029 sbuf_delete(&sb); 1030 if (proc != NULL) 1031 PRELE(proc); 1032 PFS_RETURN (error); 1033} 1034 1035/* 1036 * Vnode operations 1037 */ 1038struct vop_vector pfs_vnodeops = { 1039 .vop_default = &default_vnodeops, 1040 1041 .vop_access = pfs_access, 1042 .vop_cachedlookup = pfs_lookup, 1043 .vop_close = pfs_close, 1044 .vop_create = VOP_EOPNOTSUPP, 1045 .vop_getattr = pfs_getattr, 1046 .vop_getextattr = pfs_getextattr, 1047 .vop_ioctl = pfs_ioctl, 1048 .vop_link = VOP_EOPNOTSUPP, 1049 .vop_lookup = vfs_cache_lookup, 1050 .vop_mkdir = VOP_EOPNOTSUPP, 1051 .vop_mknod = VOP_EOPNOTSUPP, 1052 .vop_open = pfs_open, 1053 .vop_read = pfs_read, 1054 .vop_readdir = pfs_readdir, 1055 .vop_readlink = pfs_readlink, 1056 .vop_reclaim = pfs_reclaim, 1057 .vop_remove = VOP_EOPNOTSUPP, 1058 .vop_rename = VOP_EOPNOTSUPP, 1059 .vop_rmdir = VOP_EOPNOTSUPP, 1060 .vop_setattr = pfs_setattr, 1061 .vop_symlink = VOP_EOPNOTSUPP, 1062 .vop_vptocnp = pfs_vptocnp, 1063 .vop_write = pfs_write, 1064 /* XXX I've probably forgotten a few that need VOP_EOPNOTSUPP */ 1065}; 1066