1 /* 2 * Copyright (c) 1993, 1995 Jan-Simon Pendry 3 * Copyright (c) 1993, 1995 4 * The Regents of the University of California. All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * Jan-Simon Pendry. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)procfs_vnops.c 8.18 (Berkeley) 5/21/95 34 * 35 * $FreeBSD: src/sys/miscfs/procfs/procfs_vnops.c,v 1.76.2.7 2002/01/22 17:22:59 nectar Exp $ 36 */ 37 38 /* 39 * procfs vnode interface 40 */ 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/time.h> 45 #include <sys/kernel.h> 46 #include <sys/lock.h> 47 #include <sys/fcntl.h> 48 #include <sys/proc.h> 49 #include <sys/priv.h> 50 #include <sys/signalvar.h> 51 #include <sys/vnode.h> 52 #include <sys/uio.h> 53 #include <sys/mount.h> 54 #include <sys/namei.h> 55 #include <sys/dirent.h> 56 #include <sys/malloc.h> 57 #include <sys/reg.h> 58 #include <vm/vm_zone.h> 59 #include <vfs/procfs/procfs.h> 60 #include <sys/pioctl.h> 61 62 #include <sys/spinlock2.h> 63 64 #include <machine/limits.h> 65 66 static int procfs_access (struct vop_access_args *); 67 static int procfs_badop (struct vop_generic_args *); 68 static int procfs_bmap (struct vop_bmap_args *); 69 static int procfs_close (struct vop_close_args *); 70 static int procfs_getattr (struct vop_getattr_args *); 71 static int procfs_inactive (struct vop_inactive_args *); 72 static int procfs_ioctl (struct vop_ioctl_args *); 73 static int procfs_lookup (struct vop_old_lookup_args *); 74 static int procfs_open (struct vop_open_args *); 75 static int procfs_print (struct vop_print_args *); 76 static int procfs_readdir (struct vop_readdir_args *); 77 static int procfs_readlink (struct vop_readlink_args *); 78 static int procfs_reclaim (struct vop_reclaim_args *); 79 static int procfs_setattr (struct vop_setattr_args *); 80 81 static int procfs_readdir_proc(struct vop_readdir_args *); 82 static int procfs_readdir_root(struct vop_readdir_args *); 83 84 /* 85 * procfs vnode operations. 86 */ 87 struct vop_ops procfs_vnode_vops = { 88 .vop_default = vop_defaultop, 89 .vop_access = procfs_access, 90 .vop_advlock = (void *)procfs_badop, 91 .vop_bmap = procfs_bmap, 92 .vop_close = procfs_close, 93 .vop_old_create = (void *)procfs_badop, 94 .vop_getattr = procfs_getattr, 95 .vop_inactive = procfs_inactive, 96 .vop_old_link = (void *)procfs_badop, 97 .vop_old_lookup = procfs_lookup, 98 .vop_old_mkdir = (void *)procfs_badop, 99 .vop_old_mknod = (void *)procfs_badop, 100 .vop_open = procfs_open, 101 .vop_pathconf = vop_stdpathconf, 102 .vop_print = procfs_print, 103 .vop_read = procfs_rw, 104 .vop_readdir = procfs_readdir, 105 .vop_readlink = procfs_readlink, 106 .vop_reclaim = procfs_reclaim, 107 .vop_old_remove = (void *)procfs_badop, 108 .vop_old_rename = (void *)procfs_badop, 109 .vop_old_rmdir = (void *)procfs_badop, 110 .vop_setattr = procfs_setattr, 111 .vop_old_symlink = (void *)procfs_badop, 112 .vop_write = (void *)procfs_rw, 113 .vop_ioctl = procfs_ioctl 114 }; 115 116 117 /* 118 * This is a list of the valid names in the 119 * process-specific sub-directories. It is 120 * used in procfs_lookup and procfs_readdir 121 */ 122 static struct proc_target { 123 u_char pt_type; 124 u_char pt_namlen; 125 char *pt_name; 126 pfstype pt_pfstype; 127 int (*pt_valid) (struct lwp *p); 128 } proc_targets[] = { 129 #define N(s) sizeof(s)-1, s 130 /* name type validp */ 131 { DT_DIR, N("."), Pproc, NULL }, 132 { DT_DIR, N(".."), Proot, NULL }, 133 { DT_REG, N("mem"), Pmem, NULL }, 134 { DT_REG, N("regs"), Pregs, procfs_validregs }, 135 { DT_REG, N("fpregs"), Pfpregs, procfs_validfpregs }, 136 { DT_REG, N("dbregs"), Pdbregs, procfs_validdbregs }, 137 { DT_REG, N("ctl"), Pctl, NULL }, 138 { DT_REG, N("status"), Pstatus, NULL }, 139 { DT_REG, N("note"), Pnote, NULL }, 140 { DT_REG, N("notepg"), Pnotepg, NULL }, 141 { DT_REG, N("map"), Pmap, procfs_validmap }, 142 { DT_REG, N("etype"), Ptype, procfs_validtype }, 143 { DT_REG, N("cmdline"), Pcmdline, NULL }, 144 { DT_REG, N("rlimit"), Prlimit, NULL }, 145 { DT_LNK, N("file"), Pfile, NULL }, 146 #undef N 147 }; 148 static const int nproc_targets = NELEM(proc_targets); 149 150 static pid_t atopid (const char *, u_int); 151 152 /* 153 * set things up for doing i/o on 154 * the pfsnode (vp). (vp) is locked 155 * on entry, and should be left locked 156 * on exit. 157 * 158 * for procfs we don't need to do anything 159 * in particular for i/o. all that is done 160 * is to support exclusive open on process 161 * memory images. 162 * 163 * procfs_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred, 164 * struct file *a_fp) 165 */ 166 static int 167 procfs_open(struct vop_open_args *ap) 168 { 169 struct pfsnode *pfs = VTOPFS(ap->a_vp); 170 struct proc *p1, *p2; 171 int error; 172 173 p2 = pfs_pfind(pfs->pfs_pid); 174 if (p2 == NULL) 175 return (ENOENT); 176 if (pfs->pfs_pid && !PRISON_CHECK(ap->a_cred, p2->p_ucred)) { 177 error = ENOENT; 178 goto done; 179 } 180 181 switch (pfs->pfs_type) { 182 case Pmem: 183 if (((pfs->pfs_flags & FWRITE) && (ap->a_mode & O_EXCL)) || 184 ((pfs->pfs_flags & O_EXCL) && (ap->a_mode & FWRITE))) { 185 error = EBUSY; 186 goto done; 187 } 188 189 p1 = curproc; 190 KKASSERT(p1); 191 /* Can't trace a process that's currently exec'ing. */ 192 if ((p2->p_flags & P_INEXEC) != 0) { 193 error = EAGAIN; 194 goto done; 195 } 196 if (!CHECKIO(p1, p2) || p_trespass(ap->a_cred, p2->p_ucred)) { 197 error = EPERM; 198 goto done; 199 } 200 201 if (ap->a_mode & FWRITE) 202 pfs->pfs_flags = ap->a_mode & (FWRITE|O_EXCL); 203 204 break; 205 206 default: 207 break; 208 } 209 error = vop_stdopen(ap); 210 done: 211 pfs_pdone(p2); 212 return error; 213 } 214 215 /* 216 * close the pfsnode (vp) after doing i/o. 217 * (vp) is not locked on entry or exit. 218 * 219 * nothing to do for procfs other than undo 220 * any exclusive open flag (see _open above). 221 * 222 * procfs_close(struct vnode *a_vp, int a_fflag, struct ucred *a_cred) 223 */ 224 static int 225 procfs_close(struct vop_close_args *ap) 226 { 227 struct pfsnode *pfs = VTOPFS(ap->a_vp); 228 struct proc *p; 229 230 switch (pfs->pfs_type) { 231 case Pmem: 232 if ((ap->a_fflag & FWRITE) && (pfs->pfs_flags & O_EXCL)) 233 pfs->pfs_flags &= ~(FWRITE|O_EXCL); 234 /* 235 * v_opencount determines the last real close on the vnode. 236 * 237 * If this is the last close, then it checks to see if 238 * the target process has PF_LINGER set in p_pfsflags, 239 * if this is *not* the case, then the process' stop flags 240 * are cleared, and the process is woken up. This is 241 * to help prevent the case where a process has been 242 * told to stop on an event, but then the requesting process 243 * has gone away or forgotten about it. 244 */ 245 p = NULL; 246 if ((ap->a_vp->v_opencount < 2) 247 && ((p = pfs_pfind(pfs->pfs_pid)) != NULL || 248 (p = pfs_zpfind(pfs->pfs_pid)) != NULL) 249 && !(p->p_pfsflags & PF_LINGER)) { 250 spin_lock(&p->p_spin); 251 p->p_stops = 0; 252 p->p_step = 0; 253 spin_unlock(&p->p_spin); 254 wakeup(&p->p_stype); 255 wakeup(&p->p_step); 256 } 257 pfs_pdone(p); 258 break; 259 default: 260 break; 261 } 262 263 return (vop_stdclose(ap)); 264 } 265 266 /* 267 * do an ioctl operation on a pfsnode (vp). 268 * (vp) is not locked on entry or exit. 269 */ 270 static int 271 procfs_ioctl(struct vop_ioctl_args *ap) 272 { 273 struct pfsnode *pfs = VTOPFS(ap->a_vp); 274 struct proc *procp; 275 struct proc *p; 276 int error; 277 int signo; 278 struct procfs_status *psp; 279 unsigned char flags; 280 281 procp = pfs_pfind(pfs->pfs_pid); 282 if (procp == NULL) 283 return ENOTTY; 284 p = curproc; 285 if (p == NULL) { 286 error = EINVAL; 287 goto done; 288 } 289 290 /* Can't trace a process that's currently exec'ing. */ 291 if ((procp->p_flags & P_INEXEC) != 0) { 292 error = EAGAIN; 293 goto done; 294 } 295 if (!CHECKIO(p, procp) || p_trespass(ap->a_cred, procp->p_ucred)) { 296 error = EPERM; 297 goto done; 298 } 299 300 switch (ap->a_command) { 301 case PIOCBIS: 302 spin_lock(&procp->p_spin); 303 procp->p_stops |= *(unsigned int*)ap->a_data; 304 spin_unlock(&procp->p_spin); 305 break; 306 case PIOCBIC: 307 spin_lock(&procp->p_spin); 308 procp->p_stops &= ~*(unsigned int*)ap->a_data; 309 spin_unlock(&procp->p_spin); 310 break; 311 case PIOCSFL: 312 /* 313 * NFLAGS is "non-suser_xxx flags" -- currently, only 314 * PFS_ISUGID ("ignore set u/g id"); 315 */ 316 #define NFLAGS (PF_ISUGID) 317 flags = (unsigned char)*(unsigned int*)ap->a_data; 318 if (flags & NFLAGS && (error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0))) 319 goto done; 320 procp->p_pfsflags = flags; 321 break; 322 case PIOCGFL: 323 *(unsigned int*)ap->a_data = (unsigned int)procp->p_pfsflags; 324 break; 325 case PIOCSTATUS: 326 /* 327 * NOTE: syscall entry deals with stopevents and may run without 328 * the MP lock. 329 */ 330 psp = (struct procfs_status *)ap->a_data; 331 psp->flags = procp->p_pfsflags; 332 psp->events = procp->p_stops; 333 spin_lock(&procp->p_spin); 334 if (procp->p_step) { 335 psp->state = 0; 336 psp->why = procp->p_stype; 337 psp->val = procp->p_xstat; 338 spin_unlock(&procp->p_spin); 339 } else { 340 psp->state = 1; 341 spin_unlock(&procp->p_spin); 342 psp->why = 0; /* Not defined values */ 343 psp->val = 0; /* Not defined values */ 344 } 345 break; 346 case PIOCWAIT: 347 /* 348 * NOTE: syscall entry deals with stopevents and may run without 349 * the MP lock. 350 */ 351 psp = (struct procfs_status *)ap->a_data; 352 spin_lock(&procp->p_spin); 353 while (procp->p_step == 0) { 354 tsleep_interlock(&procp->p_stype, PCATCH); 355 spin_unlock(&procp->p_spin); 356 if (procp->p_stops == 0) { 357 error = EINVAL; 358 goto done; 359 } 360 if (procp->p_flags & P_POSTEXIT) { 361 error = EINVAL; 362 goto done; 363 } 364 if (procp->p_flags & P_INEXEC) { 365 error = EAGAIN; 366 goto done; 367 } 368 error = tsleep(&procp->p_stype, PCATCH | PINTERLOCKED, 369 "piocwait", 0); 370 if (error) 371 goto done; 372 spin_lock(&procp->p_spin); 373 } 374 spin_unlock(&procp->p_spin); 375 psp->state = 1; /* It stopped */ 376 psp->flags = procp->p_pfsflags; 377 psp->events = procp->p_stops; 378 psp->why = procp->p_stype; /* why it stopped */ 379 psp->val = procp->p_xstat; /* any extra info */ 380 break; 381 case PIOCCONT: /* Restart a proc */ 382 /* 383 * NOTE: syscall entry deals with stopevents and may run without 384 * the MP lock. However, the caller is presumably interlocked 385 * by having waited. 386 */ 387 if (procp->p_step == 0) { 388 error = EINVAL; /* Can only start a stopped process */ 389 goto done; 390 } 391 if ((signo = *(int*)ap->a_data) != 0) { 392 if (signo >= NSIG || signo <= 0) { 393 error = EINVAL; 394 goto done; 395 } 396 ksignal(procp, signo); 397 } 398 procp->p_step = 0; 399 wakeup(&procp->p_step); 400 break; 401 default: 402 error = ENOTTY; 403 goto done; 404 } 405 error = 0; 406 done: 407 pfs_pdone(procp); 408 return 0; 409 } 410 411 /* 412 * do block mapping for pfsnode (vp). 413 * since we don't use the buffer cache 414 * for procfs this function should never 415 * be called. in any case, it's not clear 416 * what part of the kernel ever makes use 417 * of this function. for sanity, this is the 418 * usual no-op bmap, although returning 419 * (EIO) would be a reasonable alternative. 420 * 421 * XXX mmap assumes buffer cache operation 422 * 423 * procfs_bmap(struct vnode *a_vp, off_t a_loffset, 424 * off_t *a_doffsetp, int *a_runp, int *a_runb) 425 */ 426 static int 427 procfs_bmap(struct vop_bmap_args *ap) 428 { 429 if (ap->a_doffsetp != NULL) 430 *ap->a_doffsetp = ap->a_loffset; 431 if (ap->a_runp != NULL) 432 *ap->a_runp = 0; 433 if (ap->a_runb != NULL) 434 *ap->a_runb = 0; 435 return (0); 436 } 437 438 /* 439 * procfs_inactive is called when the pfsnode 440 * is vrele'd and the reference count goes 441 * to zero. (vp) will be on the vnode free 442 * list, so to get it back vget() must be 443 * used. 444 * 445 * (vp) is locked on entry, but must be unlocked on exit. 446 * 447 * procfs_inactive(struct vnode *a_vp) 448 */ 449 static int 450 procfs_inactive(struct vop_inactive_args *ap) 451 { 452 struct pfsnode *pfs = VTOPFS(ap->a_vp); 453 454 if (pfs->pfs_pid & PFS_DEAD) 455 vrecycle(ap->a_vp); 456 return (0); 457 } 458 459 /* 460 * _reclaim is called when getnewvnode() 461 * wants to make use of an entry on the vnode 462 * free list. at this time the filesystem needs 463 * to free any private data and remove the node 464 * from any private lists. 465 * 466 * procfs_reclaim(struct vnode *a_vp) 467 */ 468 static int 469 procfs_reclaim(struct vop_reclaim_args *ap) 470 { 471 return (procfs_freevp(ap->a_vp)); 472 } 473 474 /* 475 * _print is used for debugging. 476 * just print a readable description 477 * of (vp). 478 * 479 * procfs_print(struct vnode *a_vp) 480 */ 481 static int 482 procfs_print(struct vop_print_args *ap) 483 { 484 struct pfsnode *pfs = VTOPFS(ap->a_vp); 485 486 kprintf("tag VT_PROCFS, type %d, pid %ld, mode %x, flags %lx\n", 487 pfs->pfs_type, (long)pfs->pfs_pid, pfs->pfs_mode, pfs->pfs_flags); 488 return (0); 489 } 490 491 /* 492 * generic entry point for unsupported operations 493 */ 494 static int 495 procfs_badop(struct vop_generic_args *ap) 496 { 497 return (EIO); 498 } 499 500 /* 501 * Invent attributes for pfsnode (vp) and store 502 * them in (vap). 503 * Directories lengths are returned as zero since 504 * any real length would require the genuine size 505 * to be computed, and nothing cares anyway. 506 * 507 * this is relatively minimal for procfs. 508 * 509 * procfs_getattr(struct vnode *a_vp, struct vattr *a_vap) 510 */ 511 static int 512 procfs_getattr(struct vop_getattr_args *ap) 513 { 514 struct pfsnode *pfs = VTOPFS(ap->a_vp); 515 struct vattr *vap = ap->a_vap; 516 struct proc *procp; 517 int error; 518 519 /* 520 * First make sure that the process and its credentials 521 * still exist. 522 */ 523 switch (pfs->pfs_type) { 524 case Proot: 525 case Pcurproc: 526 procp = NULL; 527 break; 528 default: 529 procp = pfs_pfind(pfs->pfs_pid); 530 if (procp == NULL || procp->p_ucred == NULL) { 531 error = ENOENT; 532 goto done; 533 } 534 break; 535 } 536 537 error = 0; 538 539 /* start by zeroing out the attributes */ 540 VATTR_NULL(vap); 541 542 /* next do all the common fields */ 543 vap->va_type = ap->a_vp->v_type; 544 vap->va_mode = pfs->pfs_mode; 545 vap->va_fileid = pfs->pfs_fileno; 546 vap->va_flags = 0; 547 vap->va_blocksize = PAGE_SIZE; 548 vap->va_bytes = vap->va_size = 0; 549 vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0]; 550 551 /* 552 * Make all times be current TOD. 553 * It would be possible to get the process start 554 * time from the p_stat structure, but there's 555 * no "file creation" time stamp anyway, and the 556 * p_stat structure is not addressible if u. gets 557 * swapped out for that process. 558 */ 559 nanotime(&vap->va_ctime); 560 vap->va_atime = vap->va_mtime = vap->va_ctime; 561 562 /* 563 * If the process has exercised some setuid or setgid 564 * privilege, then rip away read/write permission so 565 * that only root can gain access. 566 */ 567 switch (pfs->pfs_type) { 568 case Pctl: 569 case Pregs: 570 case Pfpregs: 571 case Pdbregs: 572 case Pmem: 573 if (procp->p_flags & P_SUGID) { 574 vap->va_mode &= ~((VREAD|VWRITE)| 575 ((VREAD|VWRITE)>>3)| 576 ((VREAD|VWRITE)>>6)); 577 } 578 break; 579 default: 580 break; 581 } 582 583 /* 584 * now do the object specific fields 585 * 586 * The size could be set from struct reg, but it's hardly 587 * worth the trouble, and it puts some (potentially) machine 588 * dependent data into this machine-independent code. If it 589 * becomes important then this function should break out into 590 * a per-file stat function in the corresponding .c file. 591 */ 592 593 vap->va_nlink = 1; 594 if (procp) { 595 if (procp->p_ucred) { 596 vap->va_uid = procp->p_ucred->cr_uid; 597 vap->va_gid = procp->p_ucred->cr_gid; 598 } else { 599 vap->va_uid = -1; 600 vap->va_gid = -1; 601 } 602 } 603 604 switch (pfs->pfs_type) { 605 case Proot: 606 /* 607 * Set nlink to 1 to tell fts(3) we don't actually know. 608 */ 609 vap->va_nlink = 1; 610 vap->va_uid = 0; 611 vap->va_gid = 0; 612 vap->va_size = vap->va_bytes = DEV_BSIZE; 613 break; 614 615 case Pcurproc: { 616 char buf[16]; /* should be enough */ 617 618 vap->va_uid = 0; 619 vap->va_gid = 0; 620 vap->va_size = ksnprintf(buf, sizeof(buf), 621 "%ld", (long)curproc->p_pid); 622 vap->va_bytes = vap->va_size; 623 break; 624 } 625 626 case Pproc: 627 vap->va_nlink = nproc_targets; 628 vap->va_size = vap->va_bytes = DEV_BSIZE; 629 break; 630 631 case Pfile: { 632 char *fullpath, *freepath; 633 634 if (procp->p_textnch.ncp) { 635 struct nchandle nch; 636 637 cache_copy(&procp->p_textnch, &nch); 638 error = cache_fullpath(procp, &nch, NULL, 639 &fullpath, &freepath, 0); 640 cache_drop(&nch); 641 } else { 642 error = EINVAL; 643 } 644 645 if (error == 0) { 646 vap->va_size = strlen(fullpath); 647 kfree(freepath, M_TEMP); 648 } else { 649 vap->va_size = sizeof("unknown") - 1; 650 error = 0; 651 } 652 vap->va_bytes = vap->va_size; 653 break; 654 } 655 656 case Pmem: 657 /* 658 * If we denied owner access earlier, then we have to 659 * change the owner to root - otherwise 'ps' and friends 660 * will break even though they are setgid kmem. *SIGH* 661 */ 662 if (procp->p_flags & P_SUGID) 663 vap->va_uid = 0; 664 else if (procp->p_ucred) 665 vap->va_uid = procp->p_ucred->cr_uid; 666 else 667 vap->va_uid = -1; 668 break; 669 670 case Pregs: 671 vap->va_bytes = vap->va_size = sizeof(struct reg); 672 break; 673 674 case Pfpregs: 675 vap->va_bytes = vap->va_size = sizeof(struct fpreg); 676 break; 677 678 case Pdbregs: 679 vap->va_bytes = vap->va_size = sizeof(struct dbreg); 680 break; 681 682 case Ptype: 683 case Pmap: 684 case Pctl: 685 case Pstatus: 686 case Pnote: 687 case Pnotepg: 688 case Pcmdline: 689 case Prlimit: 690 break; 691 692 default: 693 panic("procfs_getattr"); 694 } 695 done: 696 pfs_pdone(procp); 697 return (error); 698 } 699 700 /* 701 * procfs_setattr(struct vnode *a_vp, struct vattr *a_vap, 702 * struct ucred *a_cred) 703 */ 704 static int 705 procfs_setattr(struct vop_setattr_args *ap) 706 { 707 if (ap->a_vap->va_flags != VNOVAL) 708 return (EOPNOTSUPP); 709 710 /* 711 * just fake out attribute setting 712 * it's not good to generate an error 713 * return, otherwise things like creat() 714 * will fail when they try to set the 715 * file length to 0. worse, this means 716 * that echo $note > /proc/$pid/note will fail. 717 */ 718 719 return (0); 720 } 721 722 /* 723 * implement access checking. 724 * 725 * procfs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred) 726 */ 727 static int 728 procfs_access(struct vop_access_args *ap) 729 { 730 struct vattr vattr; 731 int error; 732 733 error = VOP_GETATTR(ap->a_vp, &vattr); 734 if (!error) 735 error = vop_helper_access(ap, vattr.va_uid, vattr.va_gid, 736 vattr.va_mode, 0); 737 return (error); 738 } 739 740 /* 741 * lookup. this is incredibly complicated in the general case, however 742 * for most pseudo-filesystems very little needs to be done. 743 * 744 * procfs_lookup(struct vnode *a_dvp, struct vnode **a_vpp, 745 * struct componentname *a_cnp) 746 */ 747 static int 748 procfs_lookup(struct vop_old_lookup_args *ap) 749 { 750 struct componentname *cnp = ap->a_cnp; 751 struct vnode **vpp = ap->a_vpp; 752 struct vnode *dvp = ap->a_dvp; 753 char *pname = cnp->cn_nameptr; 754 /* struct proc *curp = cnp->cn_proc; */ 755 struct proc_target *pt; 756 pid_t pid; 757 struct pfsnode *pfs; 758 struct proc *p; 759 struct lwp *lp; 760 int i; 761 int error; 762 763 *vpp = NULL; 764 765 if (cnp->cn_nameiop == NAMEI_DELETE || cnp->cn_nameiop == NAMEI_RENAME) 766 return (EROFS); 767 768 p = NULL; 769 error = 0; 770 if (cnp->cn_namelen == 1 && *pname == '.') { 771 *vpp = dvp; 772 vref(*vpp); 773 goto out; 774 } 775 776 pfs = VTOPFS(dvp); 777 switch (pfs->pfs_type) { 778 case Proot: 779 if (cnp->cn_flags & CNP_ISDOTDOT) 780 return (EIO); 781 782 if (CNEQ(cnp, "curproc", 7)) { 783 error = procfs_allocvp(dvp->v_mount, vpp, 0, Pcurproc); 784 goto out; 785 } 786 787 pid = atopid(pname, cnp->cn_namelen); 788 if (pid == NO_PID) 789 break; 790 791 p = pfs_pfind(pid); 792 if (p == NULL) 793 break; 794 795 if (!PRISON_CHECK(ap->a_cnp->cn_cred, p->p_ucred)) 796 break; 797 798 if (ps_showallprocs == 0 && ap->a_cnp->cn_cred->cr_uid != 0 && 799 ap->a_cnp->cn_cred->cr_uid != p->p_ucred->cr_uid) 800 break; 801 802 error = procfs_allocvp(dvp->v_mount, vpp, pid, Pproc); 803 goto out; 804 805 case Pproc: 806 if (cnp->cn_flags & CNP_ISDOTDOT) { 807 error = procfs_root(dvp->v_mount, vpp); 808 goto out; 809 } 810 811 p = pfs_pfind(pfs->pfs_pid); 812 if (p == NULL) 813 break; 814 /* XXX lwp */ 815 lp = FIRST_LWP_IN_PROC(p); 816 817 if (!PRISON_CHECK(ap->a_cnp->cn_cred, p->p_ucred)) 818 break; 819 820 if (ps_showallprocs == 0 && ap->a_cnp->cn_cred->cr_uid != 0 && 821 ap->a_cnp->cn_cred->cr_uid != p->p_ucred->cr_uid) 822 break; 823 824 for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) { 825 if (cnp->cn_namelen == pt->pt_namlen && 826 bcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 && 827 (pt->pt_valid == NULL || (*pt->pt_valid)(lp))) 828 goto found; 829 } 830 break; 831 found: 832 error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid, 833 pt->pt_pfstype); 834 goto out; 835 836 default: 837 error = ENOTDIR; 838 goto out; 839 } 840 if (cnp->cn_nameiop == NAMEI_LOOKUP) 841 error = ENOENT; 842 else 843 error = EROFS; 844 /* 845 * If no error occured *vpp will hold a referenced locked vnode. 846 * dvp was passed to us locked and *vpp must be returned locked. 847 * If *vpp != dvp then we should unlock dvp if (1) this is not the 848 * last component or (2) CNP_LOCKPARENT is not set. 849 */ 850 out: 851 if (error == 0 && *vpp != dvp) { 852 if ((cnp->cn_flags & CNP_LOCKPARENT) == 0) { 853 cnp->cn_flags |= CNP_PDIRUNLOCK; 854 vn_unlock(dvp); 855 } 856 } 857 pfs_pdone(p); 858 return (error); 859 } 860 861 /* 862 * Does this process have a text file? 863 */ 864 int 865 procfs_validfile(struct lwp *lp) 866 { 867 return (procfs_findtextvp(lp->lwp_proc) != NULLVP); 868 } 869 870 /* 871 * readdir() returns directory entries from pfsnode (vp). 872 * 873 * We generate just one directory entry at a time, as it would probably 874 * not pay off to buffer several entries locally to save uiomove calls. 875 * 876 * procfs_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred, 877 * int *a_eofflag, int *a_ncookies, off_t **a_cookies) 878 */ 879 static int 880 procfs_readdir(struct vop_readdir_args *ap) 881 { 882 struct pfsnode *pfs; 883 int error; 884 885 if (ap->a_uio->uio_offset < 0 || ap->a_uio->uio_offset > INT_MAX) 886 return (EINVAL); 887 if ((error = vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY)) != 0) 888 return (error); 889 pfs = VTOPFS(ap->a_vp); 890 891 switch (pfs->pfs_type) { 892 case Pproc: 893 /* 894 * this is for the process-specific sub-directories. 895 * all that is needed to is copy out all the entries 896 * from the procent[] table (top of this file). 897 */ 898 error = procfs_readdir_proc(ap); 899 break; 900 case Proot: 901 /* 902 * this is for the root of the procfs filesystem 903 * what is needed is a special entry for "curproc" 904 * followed by an entry for each process on allproc 905 */ 906 error = procfs_readdir_root(ap); 907 break; 908 default: 909 error = ENOTDIR; 910 break; 911 } 912 913 vn_unlock(ap->a_vp); 914 return (error); 915 } 916 917 static int 918 procfs_readdir_proc(struct vop_readdir_args *ap) 919 { 920 struct pfsnode *pfs; 921 int error, i, retval; 922 struct proc *p; 923 struct lwp *lp; 924 struct proc_target *pt; 925 struct uio *uio = ap->a_uio; 926 927 pfs = VTOPFS(ap->a_vp); 928 p = pfs_pfind(pfs->pfs_pid); 929 if (p == NULL) 930 return(0); 931 if (!PRISON_CHECK(ap->a_cred, p->p_ucred)) { 932 error = 0; 933 goto done; 934 } 935 /* XXX lwp, not MPSAFE */ 936 lp = FIRST_LWP_IN_PROC(p); 937 938 error = 0; 939 i = (int)uio->uio_offset; 940 if (i < 0) { 941 error = EINVAL; 942 goto done; 943 } 944 945 for (pt = &proc_targets[i]; 946 !error && uio->uio_resid > 0 && i < nproc_targets; pt++, i++) { 947 if (pt->pt_valid && (*pt->pt_valid)(lp) == 0) 948 continue; 949 950 retval = vop_write_dirent(&error, uio, 951 PROCFS_FILENO(pfs->pfs_pid, pt->pt_pfstype), pt->pt_type, 952 pt->pt_namlen, pt->pt_name); 953 if (retval) 954 break; 955 } 956 957 uio->uio_offset = (off_t)i; 958 error = 0; 959 done: 960 pfs_pdone(p); 961 return error; 962 } 963 964 struct procfs_readdir_root_info { 965 int error; 966 int i; 967 int pcnt; 968 struct uio *uio; 969 struct ucred *cred; 970 }; 971 972 static int procfs_readdir_root_callback(struct proc *p, void *data); 973 974 static int 975 procfs_readdir_root(struct vop_readdir_args *ap) 976 { 977 struct procfs_readdir_root_info info; 978 struct uio *uio = ap->a_uio; 979 int res; 980 981 res = 0; 982 info.error = 0; 983 info.i = (int)uio->uio_offset; 984 985 if (info.i < 0) 986 return (EINVAL); 987 988 info.pcnt = 0; 989 info.uio = uio; 990 info.cred = ap->a_cred; 991 while (info.pcnt < 3) { 992 res = procfs_readdir_root_callback(NULL, &info); 993 if (res < 0) 994 break; 995 } 996 if (res >= 0) 997 allproc_scan(procfs_readdir_root_callback, &info); 998 uio->uio_offset = (off_t)info.i; 999 1000 return (info.error); 1001 } 1002 1003 static int 1004 procfs_readdir_root_callback(struct proc *p, void *data) 1005 { 1006 struct procfs_readdir_root_info *info = data; 1007 struct uio *uio; 1008 int retval; 1009 ino_t d_ino; 1010 const char *d_name; 1011 char d_name_pid[20]; 1012 size_t d_namlen; 1013 uint8_t d_type; 1014 1015 uio = info->uio; 1016 1017 if (uio->uio_resid <= 0 || info->error) 1018 return(-1); 1019 1020 switch (info->pcnt) { 1021 case 0: /* `.' */ 1022 d_ino = PROCFS_FILENO(0, Proot); 1023 d_name = "."; 1024 d_namlen = 1; 1025 d_type = DT_DIR; 1026 break; 1027 case 1: /* `..' */ 1028 d_ino = PROCFS_FILENO(0, Proot); 1029 d_name = ".."; 1030 d_namlen = 2; 1031 d_type = DT_DIR; 1032 break; 1033 1034 case 2: 1035 d_ino = PROCFS_FILENO(0, Pcurproc); 1036 d_namlen = 7; 1037 d_name = "curproc"; 1038 d_type = DT_LNK; 1039 break; 1040 1041 1042 default: 1043 if (!PRISON_CHECK(info->cred, p->p_ucred)) 1044 return(0); 1045 if (ps_showallprocs == 0 && 1046 info->cred->cr_uid != 0 && 1047 info->cred->cr_uid != p->p_ucred->cr_uid) { 1048 return(0); 1049 } 1050 1051 /* 1052 * Skip entries we have already returned (optimization) 1053 */ 1054 if (info->pcnt < info->i) { 1055 ++info->pcnt; 1056 return(0); 1057 } 1058 1059 d_ino = PROCFS_FILENO(p->p_pid, Pproc); 1060 d_namlen = ksnprintf(d_name_pid, sizeof(d_name_pid), 1061 "%ld", (long)p->p_pid); 1062 d_name = d_name_pid; 1063 d_type = DT_DIR; 1064 break; 1065 } 1066 1067 /* 1068 * Skip entries we have already returned (optimization) 1069 */ 1070 if (info->pcnt < info->i) { 1071 ++info->pcnt; 1072 return(0); 1073 } 1074 1075 retval = vop_write_dirent(&info->error, uio, 1076 d_ino, d_type, d_namlen, d_name); 1077 if (retval) 1078 return(-1); 1079 ++info->pcnt; 1080 ++info->i; 1081 return(0); 1082 } 1083 1084 /* 1085 * readlink reads the link of `curproc' or `file' 1086 */ 1087 static int 1088 procfs_readlink(struct vop_readlink_args *ap) 1089 { 1090 char buf[16]; /* should be enough */ 1091 struct proc *procp; 1092 struct vnode *vp = ap->a_vp; 1093 struct pfsnode *pfs = VTOPFS(vp); 1094 char *fullpath, *freepath; 1095 int error, len; 1096 1097 switch (pfs->pfs_type) { 1098 case Pcurproc: 1099 if (pfs->pfs_fileno != PROCFS_FILENO(0, Pcurproc)) 1100 return (EINVAL); 1101 1102 len = ksnprintf(buf, sizeof(buf), "%ld", (long)curproc->p_pid); 1103 1104 return (uiomove(buf, len, ap->a_uio)); 1105 /* 1106 * There _should_ be no way for an entire process to disappear 1107 * from under us... 1108 */ 1109 case Pfile: 1110 procp = pfs_pfind(pfs->pfs_pid); 1111 if (procp == NULL || procp->p_ucred == NULL) { 1112 kprintf("procfs_readlink: pid %d disappeared\n", 1113 pfs->pfs_pid); 1114 pfs_pdone(procp); 1115 return (uiomove("unknown", sizeof("unknown") - 1, 1116 ap->a_uio)); 1117 } 1118 if (procp->p_textnch.ncp) { 1119 struct nchandle nch; 1120 1121 cache_copy(&procp->p_textnch, &nch); 1122 error = cache_fullpath(procp, &nch, NULL, 1123 &fullpath, &freepath, 0); 1124 cache_drop(&nch); 1125 } else { 1126 error = EINVAL; 1127 } 1128 1129 if (error != 0) { 1130 pfs_pdone(procp); 1131 return (uiomove("unknown", sizeof("unknown") - 1, 1132 ap->a_uio)); 1133 } 1134 error = uiomove(fullpath, strlen(fullpath), ap->a_uio); 1135 kfree(freepath, M_TEMP); 1136 pfs_pdone(procp); 1137 return (error); 1138 default: 1139 return (EINVAL); 1140 } 1141 } 1142 1143 /* 1144 * convert decimal ascii to pid_t 1145 */ 1146 static pid_t 1147 atopid(const char *b, u_int len) 1148 { 1149 pid_t p = 0; 1150 1151 while (len--) { 1152 char c = *b++; 1153 if (c < '0' || c > '9') 1154 return (NO_PID); 1155 p = 10 * p + (c - '0'); 1156 if (p > PID_MAX) 1157 return (NO_PID); 1158 } 1159 1160 return (p); 1161 } 1162 1163