1 /* $NetBSD: procfs_vnops.c,v 1.182 2011/09/04 17:32:10 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran. 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 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 1993, 1995 34 * The Regents of the University of California. All rights reserved. 35 * 36 * This code is derived from software contributed to Berkeley by 37 * Jan-Simon Pendry. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. Neither the name of the University nor the names of its contributors 48 * may be used to endorse or promote products derived from this software 49 * without specific prior written permission. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 54 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 61 * SUCH DAMAGE. 62 * 63 * @(#)procfs_vnops.c 8.18 (Berkeley) 5/21/95 64 */ 65 66 /* 67 * Copyright (c) 1993 Jan-Simon Pendry 68 * 69 * This code is derived from software contributed to Berkeley by 70 * Jan-Simon Pendry. 71 * 72 * Redistribution and use in source and binary forms, with or without 73 * modification, are permitted provided that the following conditions 74 * are met: 75 * 1. Redistributions of source code must retain the above copyright 76 * notice, this list of conditions and the following disclaimer. 77 * 2. Redistributions in binary form must reproduce the above copyright 78 * notice, this list of conditions and the following disclaimer in the 79 * documentation and/or other materials provided with the distribution. 80 * 3. All advertising materials mentioning features or use of this software 81 * must display the following acknowledgement: 82 * This product includes software developed by the University of 83 * California, Berkeley and its contributors. 84 * 4. Neither the name of the University nor the names of its contributors 85 * may be used to endorse or promote products derived from this software 86 * without specific prior written permission. 87 * 88 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 89 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 90 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 91 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 92 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 93 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 94 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 95 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 96 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 97 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 98 * SUCH DAMAGE. 99 * 100 * @(#)procfs_vnops.c 8.18 (Berkeley) 5/21/95 101 */ 102 103 /* 104 * procfs vnode interface 105 */ 106 107 #include <sys/cdefs.h> 108 __KERNEL_RCSID(0, "$NetBSD: procfs_vnops.c,v 1.182 2011/09/04 17:32:10 jmcneill Exp $"); 109 110 #include <sys/param.h> 111 #include <sys/systm.h> 112 #include <sys/time.h> 113 #include <sys/kernel.h> 114 #include <sys/file.h> 115 #include <sys/filedesc.h> 116 #include <sys/proc.h> 117 #include <sys/vnode.h> 118 #include <sys/namei.h> 119 #include <sys/malloc.h> 120 #include <sys/mount.h> 121 #include <sys/dirent.h> 122 #include <sys/resourcevar.h> 123 #include <sys/stat.h> 124 #include <sys/ptrace.h> 125 #include <sys/kauth.h> 126 127 #include <uvm/uvm_extern.h> /* for PAGE_SIZE */ 128 129 #include <machine/reg.h> 130 131 #include <miscfs/genfs/genfs.h> 132 #include <miscfs/procfs/procfs.h> 133 134 /* 135 * Vnode Operations. 136 * 137 */ 138 139 static int procfs_validfile_linux(struct lwp *, struct mount *); 140 static int procfs_root_readdir_callback(struct proc *, void *); 141 static void procfs_dir(pfstype, struct lwp *, struct proc *, char **, char *, 142 size_t); 143 144 /* 145 * This is a list of the valid names in the 146 * process-specific sub-directories. It is 147 * used in procfs_lookup and procfs_readdir 148 */ 149 static const struct proc_target { 150 u_char pt_type; 151 u_char pt_namlen; 152 const char *pt_name; 153 pfstype pt_pfstype; 154 int (*pt_valid)(struct lwp *, struct mount *); 155 } proc_targets[] = { 156 #define N(s) sizeof(s)-1, s 157 /* name type validp */ 158 { DT_DIR, N("."), PFSproc, NULL }, 159 { DT_DIR, N(".."), PFSroot, NULL }, 160 { DT_DIR, N("fd"), PFSfd, NULL }, 161 { DT_REG, N("file"), PFSfile, procfs_validfile }, 162 { DT_REG, N("mem"), PFSmem, NULL }, 163 { DT_REG, N("regs"), PFSregs, procfs_validregs }, 164 { DT_REG, N("fpregs"), PFSfpregs, procfs_validfpregs }, 165 { DT_REG, N("ctl"), PFSctl, NULL }, 166 { DT_REG, N("stat"), PFSstat, procfs_validfile_linux }, 167 { DT_REG, N("status"), PFSstatus, NULL }, 168 { DT_REG, N("note"), PFSnote, NULL }, 169 { DT_REG, N("notepg"), PFSnotepg, NULL }, 170 { DT_REG, N("map"), PFSmap, procfs_validmap }, 171 { DT_REG, N("maps"), PFSmaps, procfs_validmap }, 172 { DT_REG, N("cmdline"), PFScmdline, NULL }, 173 { DT_REG, N("exe"), PFSexe, procfs_validfile }, 174 { DT_LNK, N("cwd"), PFScwd, NULL }, 175 { DT_LNK, N("root"), PFSchroot, NULL }, 176 { DT_LNK, N("emul"), PFSemul, NULL }, 177 { DT_REG, N("statm"), PFSstatm, procfs_validfile_linux }, 178 #ifdef __HAVE_PROCFS_MACHDEP 179 PROCFS_MACHDEP_NODETYPE_DEFNS 180 #endif 181 #undef N 182 }; 183 static const int nproc_targets = sizeof(proc_targets) / sizeof(proc_targets[0]); 184 185 /* 186 * List of files in the root directory. Note: the validate function will 187 * be called with p == NULL for these ones. 188 */ 189 static const struct proc_target proc_root_targets[] = { 190 #define N(s) sizeof(s)-1, s 191 /* name type validp */ 192 { DT_REG, N("meminfo"), PFSmeminfo, procfs_validfile_linux }, 193 { DT_REG, N("cpuinfo"), PFScpuinfo, procfs_validfile_linux }, 194 { DT_REG, N("uptime"), PFSuptime, procfs_validfile_linux }, 195 { DT_REG, N("mounts"), PFSmounts, procfs_validfile_linux }, 196 { DT_REG, N("devices"), PFSdevices, procfs_validfile_linux }, 197 { DT_REG, N("stat"), PFScpustat, procfs_validfile_linux }, 198 { DT_REG, N("loadavg"), PFSloadavg, procfs_validfile_linux }, 199 { DT_REG, N("version"), PFSversion, procfs_validfile_linux }, 200 #undef N 201 }; 202 static const int nproc_root_targets = 203 sizeof(proc_root_targets) / sizeof(proc_root_targets[0]); 204 205 int procfs_lookup(void *); 206 #define procfs_create genfs_eopnotsupp 207 #define procfs_mknod genfs_eopnotsupp 208 int procfs_open(void *); 209 int procfs_close(void *); 210 int procfs_access(void *); 211 int procfs_getattr(void *); 212 int procfs_setattr(void *); 213 #define procfs_read procfs_rw 214 #define procfs_write procfs_rw 215 #define procfs_fcntl genfs_fcntl 216 #define procfs_ioctl genfs_enoioctl 217 #define procfs_poll genfs_poll 218 #define procfs_revoke genfs_revoke 219 #define procfs_fsync genfs_nullop 220 #define procfs_seek genfs_nullop 221 #define procfs_remove genfs_eopnotsupp 222 int procfs_link(void *); 223 #define procfs_rename genfs_eopnotsupp 224 #define procfs_mkdir genfs_eopnotsupp 225 #define procfs_rmdir genfs_eopnotsupp 226 int procfs_symlink(void *); 227 int procfs_readdir(void *); 228 int procfs_readlink(void *); 229 #define procfs_abortop genfs_abortop 230 int procfs_inactive(void *); 231 int procfs_reclaim(void *); 232 #define procfs_lock genfs_lock 233 #define procfs_unlock genfs_unlock 234 #define procfs_bmap genfs_badop 235 #define procfs_strategy genfs_badop 236 int procfs_print(void *); 237 int procfs_pathconf(void *); 238 #define procfs_islocked genfs_islocked 239 #define procfs_advlock genfs_einval 240 #define procfs_bwrite genfs_eopnotsupp 241 #define procfs_putpages genfs_null_putpages 242 243 static int atoi(const char *, size_t); 244 245 /* 246 * procfs vnode operations. 247 */ 248 int (**procfs_vnodeop_p)(void *); 249 const struct vnodeopv_entry_desc procfs_vnodeop_entries[] = { 250 { &vop_default_desc, vn_default_error }, 251 { &vop_lookup_desc, procfs_lookup }, /* lookup */ 252 { &vop_create_desc, procfs_create }, /* create */ 253 { &vop_mknod_desc, procfs_mknod }, /* mknod */ 254 { &vop_open_desc, procfs_open }, /* open */ 255 { &vop_close_desc, procfs_close }, /* close */ 256 { &vop_access_desc, procfs_access }, /* access */ 257 { &vop_getattr_desc, procfs_getattr }, /* getattr */ 258 { &vop_setattr_desc, procfs_setattr }, /* setattr */ 259 { &vop_read_desc, procfs_read }, /* read */ 260 { &vop_write_desc, procfs_write }, /* write */ 261 { &vop_fcntl_desc, procfs_fcntl }, /* fcntl */ 262 { &vop_ioctl_desc, procfs_ioctl }, /* ioctl */ 263 { &vop_poll_desc, procfs_poll }, /* poll */ 264 { &vop_revoke_desc, procfs_revoke }, /* revoke */ 265 { &vop_fsync_desc, procfs_fsync }, /* fsync */ 266 { &vop_seek_desc, procfs_seek }, /* seek */ 267 { &vop_remove_desc, procfs_remove }, /* remove */ 268 { &vop_link_desc, procfs_link }, /* link */ 269 { &vop_rename_desc, procfs_rename }, /* rename */ 270 { &vop_mkdir_desc, procfs_mkdir }, /* mkdir */ 271 { &vop_rmdir_desc, procfs_rmdir }, /* rmdir */ 272 { &vop_symlink_desc, procfs_symlink }, /* symlink */ 273 { &vop_readdir_desc, procfs_readdir }, /* readdir */ 274 { &vop_readlink_desc, procfs_readlink }, /* readlink */ 275 { &vop_abortop_desc, procfs_abortop }, /* abortop */ 276 { &vop_inactive_desc, procfs_inactive }, /* inactive */ 277 { &vop_reclaim_desc, procfs_reclaim }, /* reclaim */ 278 { &vop_lock_desc, procfs_lock }, /* lock */ 279 { &vop_unlock_desc, procfs_unlock }, /* unlock */ 280 { &vop_bmap_desc, procfs_bmap }, /* bmap */ 281 { &vop_strategy_desc, procfs_strategy }, /* strategy */ 282 { &vop_print_desc, procfs_print }, /* print */ 283 { &vop_islocked_desc, procfs_islocked }, /* islocked */ 284 { &vop_pathconf_desc, procfs_pathconf }, /* pathconf */ 285 { &vop_advlock_desc, procfs_advlock }, /* advlock */ 286 { &vop_putpages_desc, procfs_putpages }, /* putpages */ 287 { NULL, NULL } 288 }; 289 const struct vnodeopv_desc procfs_vnodeop_opv_desc = 290 { &procfs_vnodeop_p, procfs_vnodeop_entries }; 291 /* 292 * set things up for doing i/o on 293 * the pfsnode (vp). (vp) is locked 294 * on entry, and should be left locked 295 * on exit. 296 * 297 * for procfs we don't need to do anything 298 * in particular for i/o. all that is done 299 * is to support exclusive open on process 300 * memory images. 301 */ 302 int 303 procfs_open(void *v) 304 { 305 struct vop_open_args /* { 306 struct vnode *a_vp; 307 int a_mode; 308 kauth_cred_t a_cred; 309 } */ *ap = v; 310 struct pfsnode *pfs = VTOPFS(ap->a_vp); 311 struct lwp *l1; 312 struct proc *p2; 313 int error; 314 315 if ((error = procfs_proc_lock(pfs->pfs_pid, &p2, ENOENT)) != 0) 316 return error; 317 318 l1 = curlwp; /* tracer */ 319 320 #define M2K(m) (((m) & FREAD) && ((m) & FWRITE) ? \ 321 KAUTH_REQ_PROCESS_PROCFS_RW : \ 322 (m) & FWRITE ? KAUTH_REQ_PROCESS_PROCFS_WRITE : \ 323 KAUTH_REQ_PROCESS_PROCFS_READ) 324 325 mutex_enter(p2->p_lock); 326 error = kauth_authorize_process(l1->l_cred, KAUTH_PROCESS_PROCFS, 327 p2, pfs, KAUTH_ARG(M2K(ap->a_mode)), NULL); 328 mutex_exit(p2->p_lock); 329 if (error) { 330 procfs_proc_unlock(p2); 331 return (error); 332 } 333 334 #undef M2K 335 336 switch (pfs->pfs_type) { 337 case PFSmem: 338 if (((pfs->pfs_flags & FWRITE) && (ap->a_mode & O_EXCL)) || 339 ((pfs->pfs_flags & O_EXCL) && (ap->a_mode & FWRITE))) { 340 error = EBUSY; 341 break; 342 } 343 344 if (!proc_isunder(p2, l1)) { 345 error = EPERM; 346 break; 347 } 348 349 if (ap->a_mode & FWRITE) 350 pfs->pfs_flags = ap->a_mode & (FWRITE|O_EXCL); 351 352 break; 353 354 case PFSregs: 355 case PFSfpregs: 356 if (!proc_isunder(p2, l1)) { 357 error = EPERM; 358 break; 359 } 360 break; 361 362 default: 363 break; 364 } 365 366 procfs_proc_unlock(p2); 367 return (error); 368 } 369 370 /* 371 * close the pfsnode (vp) after doing i/o. 372 * (vp) is not locked on entry or exit. 373 * 374 * nothing to do for procfs other than undo 375 * any exclusive open flag (see _open above). 376 */ 377 int 378 procfs_close(void *v) 379 { 380 struct vop_close_args /* { 381 struct vnode *a_vp; 382 int a_fflag; 383 kauth_cred_t a_cred; 384 } */ *ap = v; 385 struct pfsnode *pfs = VTOPFS(ap->a_vp); 386 387 switch (pfs->pfs_type) { 388 case PFSmem: 389 if ((ap->a_fflag & FWRITE) && (pfs->pfs_flags & O_EXCL)) 390 pfs->pfs_flags &= ~(FWRITE|O_EXCL); 391 break; 392 393 default: 394 break; 395 } 396 397 return (0); 398 } 399 400 /* 401 * _inactive is called when the pfsnode 402 * is vrele'd and the reference count goes 403 * to zero. (vp) will be on the vnode free 404 * list, so to get it back vget() must be 405 * used. 406 * 407 * (vp) is locked on entry, but must be unlocked on exit. 408 */ 409 int 410 procfs_inactive(void *v) 411 { 412 struct vop_inactive_args /* { 413 struct vnode *a_vp; 414 bool *a_recycle; 415 } */ *ap = v; 416 struct vnode *vp = ap->a_vp; 417 struct pfsnode *pfs = VTOPFS(vp); 418 419 mutex_enter(proc_lock); 420 *ap->a_recycle = (proc_find(pfs->pfs_pid) == NULL); 421 mutex_exit(proc_lock); 422 423 VOP_UNLOCK(vp); 424 425 return (0); 426 } 427 428 /* 429 * _reclaim is called when getnewvnode() 430 * wants to make use of an entry on the vnode 431 * free list. at this time the filesystem needs 432 * to free any private data and remove the node 433 * from any private lists. 434 */ 435 int 436 procfs_reclaim(void *v) 437 { 438 struct vop_reclaim_args /* { 439 struct vnode *a_vp; 440 } */ *ap = v; 441 442 return (procfs_freevp(ap->a_vp)); 443 } 444 445 /* 446 * Return POSIX pathconf information applicable to special devices. 447 */ 448 int 449 procfs_pathconf(void *v) 450 { 451 struct vop_pathconf_args /* { 452 struct vnode *a_vp; 453 int a_name; 454 register_t *a_retval; 455 } */ *ap = v; 456 457 switch (ap->a_name) { 458 case _PC_LINK_MAX: 459 *ap->a_retval = LINK_MAX; 460 return (0); 461 case _PC_MAX_CANON: 462 *ap->a_retval = MAX_CANON; 463 return (0); 464 case _PC_MAX_INPUT: 465 *ap->a_retval = MAX_INPUT; 466 return (0); 467 case _PC_PIPE_BUF: 468 *ap->a_retval = PIPE_BUF; 469 return (0); 470 case _PC_CHOWN_RESTRICTED: 471 *ap->a_retval = 1; 472 return (0); 473 case _PC_VDISABLE: 474 *ap->a_retval = _POSIX_VDISABLE; 475 return (0); 476 case _PC_SYNC_IO: 477 *ap->a_retval = 1; 478 return (0); 479 default: 480 return (EINVAL); 481 } 482 /* NOTREACHED */ 483 } 484 485 /* 486 * _print is used for debugging. 487 * just print a readable description 488 * of (vp). 489 */ 490 int 491 procfs_print(void *v) 492 { 493 struct vop_print_args /* { 494 struct vnode *a_vp; 495 } */ *ap = v; 496 struct pfsnode *pfs = VTOPFS(ap->a_vp); 497 498 printf("tag VT_PROCFS, type %d, pid %d, mode %x, flags %lx\n", 499 pfs->pfs_type, pfs->pfs_pid, pfs->pfs_mode, pfs->pfs_flags); 500 return 0; 501 } 502 503 int 504 procfs_link(void *v) 505 { 506 struct vop_link_args /* { 507 struct vnode *a_dvp; 508 struct vnode *a_vp; 509 struct componentname *a_cnp; 510 } */ *ap = v; 511 512 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 513 vput(ap->a_dvp); 514 return (EROFS); 515 } 516 517 int 518 procfs_symlink(void *v) 519 { 520 struct vop_symlink_args /* { 521 struct vnode *a_dvp; 522 struct vnode **a_vpp; 523 struct componentname *a_cnp; 524 struct vattr *a_vap; 525 char *a_target; 526 } */ *ap = v; 527 528 VOP_ABORTOP(ap->a_dvp, ap->a_cnp); 529 vput(ap->a_dvp); 530 return (EROFS); 531 } 532 533 /* 534 * Works out the path to (and vnode of) the target process's current 535 * working directory or chroot. If the caller is in a chroot and 536 * can't "reach" the target's cwd or root (or some other error 537 * occurs), a "/" is returned for the path and a NULL pointer is 538 * returned for the vnode. 539 */ 540 static void 541 procfs_dir(pfstype t, struct lwp *caller, struct proc *target, char **bpp, 542 char *path, size_t len) 543 { 544 struct cwdinfo *cwdi; 545 struct vnode *vp, *rvp; 546 char *bp; 547 548 cwdi = caller->l_proc->p_cwdi; 549 rw_enter(&cwdi->cwdi_lock, RW_READER); 550 551 rvp = cwdi->cwdi_rdir; 552 bp = bpp ? *bpp : NULL; 553 554 switch (t) { 555 case PFScwd: 556 vp = target->p_cwdi->cwdi_cdir; 557 break; 558 case PFSchroot: 559 vp = target->p_cwdi->cwdi_rdir; 560 break; 561 case PFSexe: 562 vp = target->p_textvp; 563 break; 564 default: 565 rw_exit(&cwdi->cwdi_lock); 566 return; 567 } 568 569 /* 570 * XXX: this horrible kludge avoids locking panics when 571 * attempting to lookup links that point to within procfs 572 */ 573 if (vp != NULL && vp->v_tag == VT_PROCFS) { 574 if (bpp) { 575 *--bp = '/'; 576 *bpp = bp; 577 } 578 rw_exit(&cwdi->cwdi_lock); 579 return; 580 } 581 582 if (rvp == NULL) 583 rvp = rootvnode; 584 if (vp == NULL || getcwd_common(vp, rvp, bp ? &bp : NULL, path, 585 len / 2, 0, caller) != 0) { 586 vp = NULL; 587 if (bpp) { 588 /* 589 if (t == PFSexe) { 590 snprintf(path, len, "%s/%d/file" 591 mp->mnt_stat.f_mntonname, pfs->pfs_pid); 592 } else */ { 593 bp = *bpp; 594 *--bp = '/'; 595 } 596 } 597 } 598 599 if (bpp) 600 *bpp = bp; 601 602 rw_exit(&cwdi->cwdi_lock); 603 } 604 605 /* 606 * Invent attributes for pfsnode (vp) and store 607 * them in (vap). 608 * Directories lengths are returned as zero since 609 * any real length would require the genuine size 610 * to be computed, and nothing cares anyway. 611 * 612 * this is relatively minimal for procfs. 613 */ 614 int 615 procfs_getattr(void *v) 616 { 617 struct vop_getattr_args /* { 618 struct vnode *a_vp; 619 struct vattr *a_vap; 620 kauth_cred_t a_cred; 621 } */ *ap = v; 622 struct pfsnode *pfs = VTOPFS(ap->a_vp); 623 struct vattr *vap = ap->a_vap; 624 struct proc *procp; 625 char *path; 626 int error; 627 628 /* first check the process still exists */ 629 switch (pfs->pfs_type) { 630 case PFSroot: 631 case PFScurproc: 632 case PFSself: 633 procp = NULL; 634 break; 635 636 default: 637 error = procfs_proc_lock(pfs->pfs_pid, &procp, ENOENT); 638 if (error != 0) 639 return (error); 640 break; 641 } 642 643 switch (pfs->pfs_type) { 644 case PFScwd: 645 case PFSchroot: 646 case PFSexe: 647 path = malloc(MAXPATHLEN + 4, M_TEMP, M_WAITOK|M_CANFAIL); 648 if (path == NULL && procp != NULL) { 649 procfs_proc_unlock(procp); 650 return (ENOMEM); 651 } 652 break; 653 654 default: 655 path = NULL; 656 break; 657 } 658 659 if (procp != NULL) { 660 mutex_enter(procp->p_lock); 661 error = kauth_authorize_process(kauth_cred_get(), 662 KAUTH_PROCESS_CANSEE, procp, 663 KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL); 664 mutex_exit(procp->p_lock); 665 if (error != 0) { 666 procfs_proc_unlock(procp); 667 if (path != NULL) 668 free(path, M_TEMP); 669 return (ENOENT); 670 } 671 } 672 673 error = 0; 674 675 /* start by zeroing out the attributes */ 676 vattr_null(vap); 677 678 /* next do all the common fields */ 679 vap->va_type = ap->a_vp->v_type; 680 vap->va_mode = pfs->pfs_mode; 681 vap->va_fileid = pfs->pfs_fileno; 682 vap->va_flags = 0; 683 vap->va_blocksize = PAGE_SIZE; 684 685 /* 686 * Make all times be current TOD. 687 * 688 * It would be possible to get the process start 689 * time from the p_stats structure, but there's 690 * no "file creation" time stamp anyway, and the 691 * p_stats structure is not addressable if u. gets 692 * swapped out for that process. 693 */ 694 getnanotime(&vap->va_ctime); 695 vap->va_atime = vap->va_mtime = vap->va_ctime; 696 if (procp) 697 TIMEVAL_TO_TIMESPEC(&procp->p_stats->p_start, 698 &vap->va_birthtime); 699 else 700 getnanotime(&vap->va_birthtime); 701 702 switch (pfs->pfs_type) { 703 case PFSmem: 704 case PFSregs: 705 case PFSfpregs: 706 #if defined(__HAVE_PROCFS_MACHDEP) && defined(PROCFS_MACHDEP_PROTECT_CASES) 707 PROCFS_MACHDEP_PROTECT_CASES 708 #endif 709 /* 710 * If the process has exercised some setuid or setgid 711 * privilege, then rip away read/write permission so 712 * that only root can gain access. 713 */ 714 if (procp->p_flag & PK_SUGID) 715 vap->va_mode &= ~(S_IRUSR|S_IWUSR); 716 /* FALLTHROUGH */ 717 case PFSctl: 718 case PFSstatus: 719 case PFSstat: 720 case PFSnote: 721 case PFSnotepg: 722 case PFSmap: 723 case PFSmaps: 724 case PFScmdline: 725 case PFSemul: 726 case PFSstatm: 727 if (pfs->pfs_type == PFSmap || pfs->pfs_type == PFSmaps) 728 vap->va_mode = S_IRUSR; 729 vap->va_nlink = 1; 730 vap->va_uid = kauth_cred_geteuid(procp->p_cred); 731 vap->va_gid = kauth_cred_getegid(procp->p_cred); 732 break; 733 case PFSmeminfo: 734 case PFSdevices: 735 case PFScpuinfo: 736 case PFSuptime: 737 case PFSmounts: 738 case PFScpustat: 739 case PFSloadavg: 740 case PFSversion: 741 vap->va_nlink = 1; 742 vap->va_uid = vap->va_gid = 0; 743 break; 744 745 default: 746 break; 747 } 748 749 /* 750 * now do the object specific fields 751 * 752 * The size could be set from struct reg, but it's hardly 753 * worth the trouble, and it puts some (potentially) machine 754 * dependent data into this machine-independent code. If it 755 * becomes important then this function should break out into 756 * a per-file stat function in the corresponding .c file. 757 */ 758 759 switch (pfs->pfs_type) { 760 case PFSroot: 761 /* 762 * Set nlink to 1 to tell fts(3) we don't actually know. 763 */ 764 vap->va_nlink = 1; 765 vap->va_uid = 0; 766 vap->va_gid = 0; 767 vap->va_bytes = vap->va_size = DEV_BSIZE; 768 break; 769 770 case PFSself: 771 case PFScurproc: { 772 char bf[16]; /* should be enough */ 773 vap->va_nlink = 1; 774 vap->va_uid = 0; 775 vap->va_gid = 0; 776 vap->va_bytes = vap->va_size = 777 snprintf(bf, sizeof(bf), "%ld", (long)curproc->p_pid); 778 break; 779 } 780 781 case PFSfd: 782 if (pfs->pfs_fd != -1) { 783 file_t *fp; 784 785 fp = fd_getfile2(procp, pfs->pfs_fd); 786 if (fp == NULL) { 787 error = EBADF; 788 break; 789 } 790 vap->va_nlink = 1; 791 vap->va_uid = kauth_cred_geteuid(fp->f_cred); 792 vap->va_gid = kauth_cred_getegid(fp->f_cred); 793 switch (fp->f_type) { 794 case DTYPE_VNODE: 795 vap->va_bytes = vap->va_size = 796 ((struct vnode *)fp->f_data)->v_size; 797 break; 798 default: 799 vap->va_bytes = vap->va_size = 0; 800 break; 801 } 802 closef(fp); 803 break; 804 } 805 /*FALLTHROUGH*/ 806 case PFSproc: 807 vap->va_nlink = 2; 808 vap->va_uid = kauth_cred_geteuid(procp->p_cred); 809 vap->va_gid = kauth_cred_getegid(procp->p_cred); 810 vap->va_bytes = vap->va_size = DEV_BSIZE; 811 break; 812 813 case PFSfile: 814 error = EOPNOTSUPP; 815 break; 816 817 case PFSmem: 818 vap->va_bytes = vap->va_size = 819 ctob(procp->p_vmspace->vm_tsize + 820 procp->p_vmspace->vm_dsize + 821 procp->p_vmspace->vm_ssize); 822 break; 823 824 #if defined(PT_GETREGS) || defined(PT_SETREGS) 825 case PFSregs: 826 vap->va_bytes = vap->va_size = sizeof(struct reg); 827 break; 828 #endif 829 830 #if defined(PT_GETFPREGS) || defined(PT_SETFPREGS) 831 case PFSfpregs: 832 vap->va_bytes = vap->va_size = sizeof(struct fpreg); 833 break; 834 #endif 835 836 case PFSctl: 837 case PFSstatus: 838 case PFSstat: 839 case PFSnote: 840 case PFSnotepg: 841 case PFScmdline: 842 case PFSmeminfo: 843 case PFSdevices: 844 case PFScpuinfo: 845 case PFSuptime: 846 case PFSmounts: 847 case PFScpustat: 848 case PFSloadavg: 849 case PFSstatm: 850 case PFSversion: 851 vap->va_bytes = vap->va_size = 0; 852 break; 853 case PFSmap: 854 case PFSmaps: 855 /* 856 * Advise a larger blocksize for the map files, so that 857 * they may be read in one pass. 858 */ 859 vap->va_blocksize = 4 * PAGE_SIZE; 860 vap->va_bytes = vap->va_size = 0; 861 break; 862 863 case PFScwd: 864 case PFSchroot: 865 case PFSexe: { 866 char *bp; 867 868 vap->va_nlink = 1; 869 vap->va_uid = 0; 870 vap->va_gid = 0; 871 bp = path + MAXPATHLEN; 872 *--bp = '\0'; 873 procfs_dir(pfs->pfs_type, curlwp, procp, &bp, path, 874 MAXPATHLEN); 875 vap->va_bytes = vap->va_size = strlen(bp); 876 break; 877 } 878 879 case PFSemul: 880 vap->va_bytes = vap->va_size = strlen(procp->p_emul->e_name); 881 break; 882 883 #ifdef __HAVE_PROCFS_MACHDEP 884 PROCFS_MACHDEP_NODETYPE_CASES 885 error = procfs_machdep_getattr(ap->a_vp, vap, procp); 886 break; 887 #endif 888 889 default: 890 panic("procfs_getattr"); 891 } 892 893 if (procp != NULL) 894 procfs_proc_unlock(procp); 895 if (path != NULL) 896 free(path, M_TEMP); 897 898 return (error); 899 } 900 901 /*ARGSUSED*/ 902 int 903 procfs_setattr(void *v) 904 { 905 /* 906 * just fake out attribute setting 907 * it's not good to generate an error 908 * return, otherwise things like creat() 909 * will fail when they try to set the 910 * file length to 0. worse, this means 911 * that echo $note > /proc/$pid/note will fail. 912 */ 913 914 return (0); 915 } 916 917 static int 918 procfs_check_possible(struct vnode *vp, mode_t mode) 919 { 920 921 return 0; 922 } 923 924 static int 925 procfs_check_permitted(struct vattr *va, mode_t mode, kauth_cred_t cred) 926 { 927 928 return genfs_can_access(va->va_type, va->va_mode, 929 va->va_uid, va->va_gid, mode, cred); 930 } 931 932 /* 933 * implement access checking. 934 * 935 * actually, the check for super-user is slightly 936 * broken since it will allow read access to write-only 937 * objects. this doesn't cause any particular trouble 938 * but does mean that the i/o entry points need to check 939 * that the operation really does make sense. 940 */ 941 int 942 procfs_access(void *v) 943 { 944 struct vop_access_args /* { 945 struct vnode *a_vp; 946 int a_mode; 947 kauth_cred_t a_cred; 948 } */ *ap = v; 949 struct vattr va; 950 int error; 951 952 if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0) 953 return (error); 954 955 error = procfs_check_possible(ap->a_vp, ap->a_mode); 956 if (error) 957 return error; 958 959 error = procfs_check_permitted(&va, ap->a_mode, ap->a_cred); 960 961 return error; 962 } 963 964 /* 965 * lookup. this is incredibly complicated in the 966 * general case, however for most pseudo-filesystems 967 * very little needs to be done. 968 * 969 * Locking isn't hard here, just poorly documented. 970 * 971 * If we're looking up ".", just vref the parent & return it. 972 * 973 * If we're looking up "..", unlock the parent, and lock "..". If everything 974 * went ok, and we're on the last component and the caller requested the 975 * parent locked, try to re-lock the parent. We do this to prevent lock 976 * races. 977 * 978 * For anything else, get the needed node. Then unlock the parent if not 979 * the last component or not LOCKPARENT (i.e. if we wouldn't re-lock the 980 * parent in the .. case). 981 * 982 * We try to exit with the parent locked in error cases. 983 */ 984 int 985 procfs_lookup(void *v) 986 { 987 struct vop_lookup_args /* { 988 struct vnode * a_dvp; 989 struct vnode ** a_vpp; 990 struct componentname * a_cnp; 991 } */ *ap = v; 992 struct componentname *cnp = ap->a_cnp; 993 struct vnode **vpp = ap->a_vpp; 994 struct vnode *dvp = ap->a_dvp; 995 const char *pname = cnp->cn_nameptr; 996 const struct proc_target *pt = NULL; 997 struct vnode *fvp; 998 pid_t pid, vnpid; 999 struct pfsnode *pfs; 1000 struct proc *p = NULL; 1001 struct lwp *plwp; 1002 int i, error; 1003 pfstype type; 1004 1005 *vpp = NULL; 1006 1007 if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME) 1008 return (EROFS); 1009 1010 if (cnp->cn_namelen == 1 && *pname == '.') { 1011 *vpp = dvp; 1012 vref(dvp); 1013 return (0); 1014 } 1015 1016 pfs = VTOPFS(dvp); 1017 switch (pfs->pfs_type) { 1018 case PFSroot: 1019 /* 1020 * Shouldn't get here with .. in the root node. 1021 */ 1022 if (cnp->cn_flags & ISDOTDOT) 1023 return (EIO); 1024 1025 for (i = 0; i < nproc_root_targets; i++) { 1026 pt = &proc_root_targets[i]; 1027 /* 1028 * check for node match. proc is always NULL here, 1029 * so call pt_valid with constant NULL lwp. 1030 */ 1031 if (cnp->cn_namelen == pt->pt_namlen && 1032 memcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 && 1033 (pt->pt_valid == NULL || 1034 (*pt->pt_valid)(NULL, dvp->v_mount))) 1035 break; 1036 } 1037 1038 if (i != nproc_root_targets) { 1039 error = procfs_allocvp(dvp->v_mount, vpp, 0, 1040 pt->pt_pfstype, -1, NULL); 1041 return (error); 1042 } 1043 1044 if (CNEQ(cnp, "curproc", 7)) { 1045 pid = curproc->p_pid; 1046 vnpid = 0; 1047 type = PFScurproc; 1048 } else if (CNEQ(cnp, "self", 4)) { 1049 pid = curproc->p_pid; 1050 vnpid = 0; 1051 type = PFSself; 1052 } else { 1053 pid = (pid_t)atoi(pname, cnp->cn_namelen); 1054 vnpid = pid; 1055 type = PFSproc; 1056 } 1057 1058 if (procfs_proc_lock(pid, &p, ESRCH) != 0) 1059 break; 1060 error = procfs_allocvp(dvp->v_mount, vpp, vnpid, type, -1, p); 1061 procfs_proc_unlock(p); 1062 return (error); 1063 1064 case PFSproc: 1065 /* 1066 * do the .. dance. We unlock the directory, and then 1067 * get the root dir. That will automatically return .. 1068 * locked. Then if the caller wanted dvp locked, we 1069 * re-lock. 1070 */ 1071 if (cnp->cn_flags & ISDOTDOT) { 1072 VOP_UNLOCK(dvp); 1073 error = procfs_root(dvp->v_mount, vpp); 1074 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 1075 return (error); 1076 } 1077 1078 if (procfs_proc_lock(pfs->pfs_pid, &p, ESRCH) != 0) 1079 break; 1080 1081 mutex_enter(p->p_lock); 1082 LIST_FOREACH(plwp, &p->p_lwps, l_sibling) { 1083 if (plwp->l_stat != LSZOMB) 1084 break; 1085 } 1086 /* Process is exiting if no-LWPS or all LWPs are LSZOMB */ 1087 if (plwp == NULL) { 1088 mutex_exit(p->p_lock); 1089 procfs_proc_unlock(p); 1090 return ESRCH; 1091 } 1092 1093 lwp_addref(plwp); 1094 mutex_exit(p->p_lock); 1095 1096 for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) { 1097 int found; 1098 1099 found = cnp->cn_namelen == pt->pt_namlen && 1100 memcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 && 1101 (pt->pt_valid == NULL 1102 || (*pt->pt_valid)(plwp, dvp->v_mount)); 1103 if (found) 1104 break; 1105 } 1106 lwp_delref(plwp); 1107 1108 if (i == nproc_targets) { 1109 procfs_proc_unlock(p); 1110 break; 1111 } 1112 if (pt->pt_pfstype == PFSfile) { 1113 fvp = p->p_textvp; 1114 /* We already checked that it exists. */ 1115 vref(fvp); 1116 procfs_proc_unlock(p); 1117 vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY); 1118 *vpp = fvp; 1119 return (0); 1120 } 1121 1122 error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid, 1123 pt->pt_pfstype, -1, p); 1124 procfs_proc_unlock(p); 1125 return (error); 1126 1127 case PFSfd: { 1128 int fd; 1129 file_t *fp; 1130 1131 if ((error = procfs_proc_lock(pfs->pfs_pid, &p, ENOENT)) != 0) 1132 return error; 1133 1134 /* 1135 * do the .. dance. We unlock the directory, and then 1136 * get the proc dir. That will automatically return .. 1137 * locked. Then re-lock the directory. 1138 */ 1139 if (cnp->cn_flags & ISDOTDOT) { 1140 VOP_UNLOCK(dvp); 1141 error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid, 1142 PFSproc, -1, p); 1143 procfs_proc_unlock(p); 1144 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 1145 return (error); 1146 } 1147 fd = atoi(pname, cnp->cn_namelen); 1148 1149 fp = fd_getfile2(p, fd); 1150 if (fp == NULL) { 1151 procfs_proc_unlock(p); 1152 return ENOENT; 1153 } 1154 fvp = fp->f_data; 1155 1156 /* Don't show directories */ 1157 if (fp->f_type == DTYPE_VNODE && fvp->v_type != VDIR) { 1158 vref(fvp); 1159 closef(fp); 1160 procfs_proc_unlock(p); 1161 vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY); 1162 *vpp = fvp; 1163 return 0; 1164 } 1165 1166 closef(fp); 1167 error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid, 1168 PFSfd, fd, p); 1169 procfs_proc_unlock(p); 1170 return error; 1171 } 1172 default: 1173 return (ENOTDIR); 1174 } 1175 1176 return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS); 1177 } 1178 1179 int 1180 procfs_validfile(struct lwp *l, struct mount *mp) 1181 { 1182 return l != NULL && l->l_proc != NULL && l->l_proc->p_textvp != NULL; 1183 } 1184 1185 static int 1186 procfs_validfile_linux(struct lwp *l, struct mount *mp) 1187 { 1188 int flags; 1189 1190 flags = VFSTOPROC(mp)->pmnt_flags; 1191 return (flags & PROCFSMNT_LINUXCOMPAT) && 1192 (l == NULL || l->l_proc == NULL || procfs_validfile(l, mp)); 1193 } 1194 1195 struct procfs_root_readdir_ctx { 1196 struct uio *uiop; 1197 off_t *cookies; 1198 int ncookies; 1199 off_t off; 1200 off_t startoff; 1201 int error; 1202 }; 1203 1204 static int 1205 procfs_root_readdir_callback(struct proc *p, void *arg) 1206 { 1207 struct procfs_root_readdir_ctx *ctxp = arg; 1208 struct dirent d; 1209 struct uio *uiop; 1210 int error; 1211 1212 uiop = ctxp->uiop; 1213 if (uiop->uio_resid < UIO_MX) 1214 return -1; /* no space */ 1215 1216 if (ctxp->off < ctxp->startoff) { 1217 ctxp->off++; 1218 return 0; 1219 } 1220 1221 if (kauth_authorize_process(kauth_cred_get(), 1222 KAUTH_PROCESS_CANSEE, p, 1223 KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL) != 0) 1224 return 0; 1225 1226 memset(&d, 0, UIO_MX); 1227 d.d_reclen = UIO_MX; 1228 d.d_fileno = PROCFS_FILENO(p->p_pid, PFSproc, -1); 1229 d.d_namlen = snprintf(d.d_name, 1230 UIO_MX - offsetof(struct dirent, d_name), "%ld", (long)p->p_pid); 1231 d.d_type = DT_DIR; 1232 1233 mutex_exit(proc_lock); 1234 error = uiomove(&d, UIO_MX, uiop); 1235 mutex_enter(proc_lock); 1236 if (error) { 1237 ctxp->error = error; 1238 return -1; 1239 } 1240 1241 ctxp->ncookies++; 1242 if (ctxp->cookies) 1243 *(ctxp->cookies)++ = ctxp->off + 1; 1244 ctxp->off++; 1245 1246 return 0; 1247 } 1248 1249 /* 1250 * readdir returns directory entries from pfsnode (vp). 1251 * 1252 * the strategy here with procfs is to generate a single 1253 * directory entry at a time (struct dirent) and then 1254 * copy that out to userland using uiomove. a more efficent 1255 * though more complex implementation, would try to minimize 1256 * the number of calls to uiomove(). for procfs, this is 1257 * hardly worth the added code complexity. 1258 * 1259 * this should just be done through read() 1260 */ 1261 int 1262 procfs_readdir(void *v) 1263 { 1264 struct vop_readdir_args /* { 1265 struct vnode *a_vp; 1266 struct uio *a_uio; 1267 kauth_cred_t a_cred; 1268 int *a_eofflag; 1269 off_t **a_cookies; 1270 int *a_ncookies; 1271 } */ *ap = v; 1272 struct uio *uio = ap->a_uio; 1273 struct dirent d; 1274 struct pfsnode *pfs; 1275 off_t i; 1276 int error; 1277 off_t *cookies = NULL; 1278 int ncookies; 1279 struct vnode *vp; 1280 const struct proc_target *pt; 1281 struct procfs_root_readdir_ctx ctx; 1282 struct lwp *l; 1283 int nfd; 1284 1285 vp = ap->a_vp; 1286 pfs = VTOPFS(vp); 1287 1288 if (uio->uio_resid < UIO_MX) 1289 return (EINVAL); 1290 if (uio->uio_offset < 0) 1291 return (EINVAL); 1292 1293 error = 0; 1294 i = uio->uio_offset; 1295 memset(&d, 0, UIO_MX); 1296 d.d_reclen = UIO_MX; 1297 ncookies = uio->uio_resid / UIO_MX; 1298 1299 switch (pfs->pfs_type) { 1300 /* 1301 * this is for the process-specific sub-directories. 1302 * all that is needed to is copy out all the entries 1303 * from the procent[] table (top of this file). 1304 */ 1305 case PFSproc: { 1306 struct proc *p; 1307 1308 if (i >= nproc_targets) 1309 return 0; 1310 1311 if (procfs_proc_lock(pfs->pfs_pid, &p, ESRCH) != 0) 1312 break; 1313 1314 if (ap->a_ncookies) { 1315 ncookies = min(ncookies, (nproc_targets - i)); 1316 cookies = malloc(ncookies * sizeof (off_t), 1317 M_TEMP, M_WAITOK); 1318 *ap->a_cookies = cookies; 1319 } 1320 1321 for (pt = &proc_targets[i]; 1322 uio->uio_resid >= UIO_MX && i < nproc_targets; pt++, i++) { 1323 if (pt->pt_valid) { 1324 /* XXXSMP LWP can disappear */ 1325 mutex_enter(p->p_lock); 1326 l = LIST_FIRST(&p->p_lwps); 1327 KASSERT(l != NULL); 1328 mutex_exit(p->p_lock); 1329 if ((*pt->pt_valid)(l, vp->v_mount) == 0) 1330 continue; 1331 } 1332 1333 d.d_fileno = PROCFS_FILENO(pfs->pfs_pid, 1334 pt->pt_pfstype, -1); 1335 d.d_namlen = pt->pt_namlen; 1336 memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1); 1337 d.d_type = pt->pt_type; 1338 1339 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1340 break; 1341 if (cookies) 1342 *cookies++ = i + 1; 1343 } 1344 1345 procfs_proc_unlock(p); 1346 break; 1347 } 1348 case PFSfd: { 1349 struct proc *p; 1350 file_t *fp; 1351 int lim, nc = 0; 1352 1353 if ((error = procfs_proc_lock(pfs->pfs_pid, &p, ESRCH)) != 0) 1354 return error; 1355 1356 /* XXX Should this be by file as well? */ 1357 if (kauth_authorize_process(kauth_cred_get(), 1358 KAUTH_PROCESS_CANSEE, p, 1359 KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_OPENFILES), NULL, 1360 NULL) != 0) { 1361 procfs_proc_unlock(p); 1362 return ESRCH; 1363 } 1364 1365 nfd = p->p_fd->fd_dt->dt_nfiles; 1366 1367 lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles); 1368 if (i >= lim) { 1369 procfs_proc_unlock(p); 1370 return 0; 1371 } 1372 1373 if (ap->a_ncookies) { 1374 ncookies = min(ncookies, (nfd + 2 - i)); 1375 cookies = malloc(ncookies * sizeof (off_t), 1376 M_TEMP, M_WAITOK); 1377 *ap->a_cookies = cookies; 1378 } 1379 1380 for (; i < 2 && uio->uio_resid >= UIO_MX; i++) { 1381 pt = &proc_targets[i]; 1382 d.d_namlen = pt->pt_namlen; 1383 d.d_fileno = PROCFS_FILENO(pfs->pfs_pid, 1384 pt->pt_pfstype, -1); 1385 (void)memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1); 1386 d.d_type = pt->pt_type; 1387 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1388 break; 1389 if (cookies) 1390 *cookies++ = i + 1; 1391 nc++; 1392 } 1393 if (error) { 1394 ncookies = nc; 1395 break; 1396 } 1397 for (; uio->uio_resid >= UIO_MX && i < nfd; i++) { 1398 /* check the descriptor exists */ 1399 if ((fp = fd_getfile2(p, i - 2)) == NULL) 1400 continue; 1401 closef(fp); 1402 1403 d.d_fileno = PROCFS_FILENO(pfs->pfs_pid, PFSfd, i - 2); 1404 d.d_namlen = snprintf(d.d_name, sizeof(d.d_name), 1405 "%lld", (long long)(i - 2)); 1406 d.d_type = VREG; 1407 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1408 break; 1409 if (cookies) 1410 *cookies++ = i + 1; 1411 nc++; 1412 } 1413 ncookies = nc; 1414 procfs_proc_unlock(p); 1415 break; 1416 } 1417 1418 /* 1419 * this is for the root of the procfs filesystem 1420 * what is needed are special entries for "curproc" 1421 * and "self" followed by an entry for each process 1422 * on allproc. 1423 */ 1424 1425 case PFSroot: { 1426 int nc = 0; 1427 1428 if (ap->a_ncookies) { 1429 /* 1430 * XXX Potentially allocating too much space here, 1431 * but I'm lazy. This loop needs some work. 1432 */ 1433 cookies = malloc(ncookies * sizeof (off_t), 1434 M_TEMP, M_WAITOK); 1435 *ap->a_cookies = cookies; 1436 } 1437 error = 0; 1438 /* 0 ... 3 are static entries. */ 1439 for (; i <= 3 && uio->uio_resid >= UIO_MX; i++) { 1440 switch (i) { 1441 case 0: /* `.' */ 1442 case 1: /* `..' */ 1443 d.d_fileno = PROCFS_FILENO(0, PFSroot, -1); 1444 d.d_namlen = i + 1; 1445 memcpy(d.d_name, "..", d.d_namlen); 1446 d.d_name[i + 1] = '\0'; 1447 d.d_type = DT_DIR; 1448 break; 1449 1450 case 2: 1451 d.d_fileno = PROCFS_FILENO(0, PFScurproc, -1); 1452 d.d_namlen = sizeof("curproc") - 1; 1453 memcpy(d.d_name, "curproc", sizeof("curproc")); 1454 d.d_type = DT_LNK; 1455 break; 1456 1457 case 3: 1458 d.d_fileno = PROCFS_FILENO(0, PFSself, -1); 1459 d.d_namlen = sizeof("self") - 1; 1460 memcpy(d.d_name, "self", sizeof("self")); 1461 d.d_type = DT_LNK; 1462 break; 1463 } 1464 1465 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1466 break; 1467 nc++; 1468 if (cookies) 1469 *cookies++ = i + 1; 1470 } 1471 /* 4 ... are process entries. */ 1472 ctx.uiop = uio; 1473 ctx.error = 0; 1474 ctx.off = 4; 1475 ctx.startoff = i; 1476 ctx.cookies = cookies; 1477 ctx.ncookies = nc; 1478 proclist_foreach_call(&allproc, 1479 procfs_root_readdir_callback, &ctx); 1480 cookies = ctx.cookies; 1481 nc = ctx.ncookies; 1482 error = ctx.error; 1483 if (error) 1484 break; 1485 1486 /* misc entries. */ 1487 if (i < ctx.off) 1488 i = ctx.off; 1489 if (i >= ctx.off + nproc_root_targets) 1490 break; 1491 for (pt = &proc_root_targets[i - ctx.off]; 1492 uio->uio_resid >= UIO_MX && 1493 pt < &proc_root_targets[nproc_root_targets]; 1494 pt++, i++) { 1495 if (pt->pt_valid && 1496 (*pt->pt_valid)(NULL, vp->v_mount) == 0) 1497 continue; 1498 d.d_fileno = PROCFS_FILENO(0, pt->pt_pfstype, -1); 1499 d.d_namlen = pt->pt_namlen; 1500 memcpy(d.d_name, pt->pt_name, pt->pt_namlen + 1); 1501 d.d_type = pt->pt_type; 1502 1503 if ((error = uiomove(&d, UIO_MX, uio)) != 0) 1504 break; 1505 nc++; 1506 if (cookies) 1507 *cookies++ = i + 1; 1508 } 1509 1510 ncookies = nc; 1511 break; 1512 } 1513 1514 default: 1515 error = ENOTDIR; 1516 break; 1517 } 1518 1519 if (ap->a_ncookies) { 1520 if (error) { 1521 if (cookies) 1522 free(*ap->a_cookies, M_TEMP); 1523 *ap->a_ncookies = 0; 1524 *ap->a_cookies = NULL; 1525 } else 1526 *ap->a_ncookies = ncookies; 1527 } 1528 uio->uio_offset = i; 1529 return (error); 1530 } 1531 1532 /* 1533 * readlink reads the link of `curproc' and others 1534 */ 1535 int 1536 procfs_readlink(void *v) 1537 { 1538 struct vop_readlink_args *ap = v; 1539 char bf[16]; /* should be enough */ 1540 char *bp = bf; 1541 char *path = NULL; 1542 int len = 0; 1543 int error = 0; 1544 struct pfsnode *pfs = VTOPFS(ap->a_vp); 1545 struct proc *pown; 1546 1547 if (pfs->pfs_fileno == PROCFS_FILENO(0, PFScurproc, -1)) 1548 len = snprintf(bf, sizeof(bf), "%ld", (long)curproc->p_pid); 1549 else if (pfs->pfs_fileno == PROCFS_FILENO(0, PFSself, -1)) 1550 len = snprintf(bf, sizeof(bf), "%s", "curproc"); 1551 else if (pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFScwd, -1) || 1552 pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFSchroot, -1) || 1553 pfs->pfs_fileno == PROCFS_FILENO(pfs->pfs_pid, PFSexe, -1)) { 1554 if ((error = procfs_proc_lock(pfs->pfs_pid, &pown, ESRCH)) != 0) 1555 return error; 1556 path = malloc(MAXPATHLEN + 4, M_TEMP, M_WAITOK|M_CANFAIL); 1557 if (path == NULL) { 1558 procfs_proc_unlock(pown); 1559 return (ENOMEM); 1560 } 1561 bp = path + MAXPATHLEN; 1562 *--bp = '\0'; 1563 procfs_dir(PROCFS_TYPE(pfs->pfs_fileno), curlwp, pown, 1564 &bp, path, MAXPATHLEN); 1565 procfs_proc_unlock(pown); 1566 len = strlen(bp); 1567 } else { 1568 file_t *fp; 1569 struct vnode *vxp, *vp; 1570 1571 if ((error = procfs_proc_lock(pfs->pfs_pid, &pown, ESRCH)) != 0) 1572 return error; 1573 1574 fp = fd_getfile2(pown, pfs->pfs_fd); 1575 if (fp == NULL) { 1576 procfs_proc_unlock(pown); 1577 return EBADF; 1578 } 1579 1580 switch (fp->f_type) { 1581 case DTYPE_VNODE: 1582 vxp = (struct vnode *)fp->f_data; 1583 if (vxp->v_type != VDIR) { 1584 error = EINVAL; 1585 break; 1586 } 1587 if ((path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK)) 1588 == NULL) { 1589 error = ENOMEM; 1590 break; 1591 } 1592 bp = path + MAXPATHLEN; 1593 *--bp = '\0'; 1594 1595 /* 1596 * XXX: kludge to avoid locking against ourselves 1597 * in getcwd() 1598 */ 1599 if (vxp->v_tag == VT_PROCFS) { 1600 *--bp = '/'; 1601 } else { 1602 rw_enter(&curproc->p_cwdi->cwdi_lock, RW_READER); 1603 vp = curproc->p_cwdi->cwdi_rdir; 1604 if (vp == NULL) 1605 vp = rootvnode; 1606 error = getcwd_common(vxp, vp, &bp, path, 1607 MAXPATHLEN / 2, 0, curlwp); 1608 rw_exit(&curproc->p_cwdi->cwdi_lock); 1609 } 1610 if (error) 1611 break; 1612 len = strlen(bp); 1613 break; 1614 1615 case DTYPE_MISC: 1616 len = snprintf(bf, sizeof(bf), "%s", "[misc]"); 1617 break; 1618 1619 case DTYPE_KQUEUE: 1620 len = snprintf(bf, sizeof(bf), "%s", "[kqueue]"); 1621 break; 1622 1623 default: 1624 error = EINVAL; 1625 break; 1626 } 1627 closef(fp); 1628 procfs_proc_unlock(pown); 1629 } 1630 1631 if (error == 0) 1632 error = uiomove(bp, len, ap->a_uio); 1633 if (path) 1634 free(path, M_TEMP); 1635 return error; 1636 } 1637 1638 /* 1639 * convert decimal ascii to int 1640 */ 1641 static int 1642 atoi(const char *b, size_t len) 1643 { 1644 int p = 0; 1645 1646 while (len--) { 1647 char c = *b++; 1648 if (c < '0' || c > '9') 1649 return -1; 1650 p = 10 * p + (c - '0'); 1651 } 1652 1653 return p; 1654 } 1655