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