Annotation of sys/miscfs/procfs/procfs_vnops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: procfs_vnops.c,v 1.40 2007/06/18 08:30:07 jasper Exp $ */
! 2: /* $NetBSD: procfs_vnops.c,v 1.40 1996/03/16 23:52:55 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1993 Jan-Simon Pendry
! 6: * Copyright (c) 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * This code is derived from software contributed to Berkeley by
! 10: * Jan-Simon Pendry.
! 11: *
! 12: * Redistribution and use in source and binary forms, with or without
! 13: * modification, are permitted provided that the following conditions
! 14: * are met:
! 15: * 1. Redistributions of source code must retain the above copyright
! 16: * notice, this list of conditions and the following disclaimer.
! 17: * 2. Redistributions in binary form must reproduce the above copyright
! 18: * notice, this list of conditions and the following disclaimer in the
! 19: * documentation and/or other materials provided with the distribution.
! 20: * 3. Neither the name of the University nor the names of its contributors
! 21: * may be used to endorse or promote products derived from this software
! 22: * without specific prior written permission.
! 23: *
! 24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 34: * SUCH DAMAGE.
! 35: *
! 36: * @(#)procfs_vnops.c 8.8 (Berkeley) 6/15/94
! 37: */
! 38:
! 39: /*
! 40: * procfs vnode interface
! 41: */
! 42:
! 43: #include <sys/param.h>
! 44: #include <sys/systm.h>
! 45: #include <sys/time.h>
! 46: #include <sys/kernel.h>
! 47: #include <sys/file.h>
! 48: #include <sys/proc.h>
! 49: #include <sys/mount.h>
! 50: #include <sys/vnode.h>
! 51: #include <sys/namei.h>
! 52: #include <sys/malloc.h>
! 53: #include <sys/dirent.h>
! 54: #include <sys/resourcevar.h>
! 55: #include <sys/poll.h>
! 56: #include <sys/ptrace.h>
! 57: #include <sys/stat.h>
! 58:
! 59: #include <uvm/uvm_extern.h> /* for PAGE_SIZE */
! 60:
! 61: #include <machine/reg.h>
! 62:
! 63: #include <miscfs/procfs/procfs.h>
! 64:
! 65: /*
! 66: * Vnode Operations.
! 67: *
! 68: */
! 69: static int procfs_validfile_linux(struct proc *, struct mount *);
! 70:
! 71: /*
! 72: * This is a list of the valid names in the
! 73: * process-specific sub-directories. It is
! 74: * used in procfs_lookup and procfs_readdir
! 75: */
! 76: struct proc_target {
! 77: u_char pt_type;
! 78: u_char pt_namlen;
! 79: char *pt_name;
! 80: pfstype pt_pfstype;
! 81: int (*pt_valid)(struct proc *p, struct mount *mp);
! 82: } proc_targets[] = {
! 83: #define N(s) sizeof(s)-1, s
! 84: /* name type validp */
! 85: { DT_DIR, N("."), Pproc, NULL },
! 86: { DT_DIR, N(".."), Proot, NULL },
! 87: { DT_REG, N("file"), Pfile, procfs_validfile },
! 88: { DT_REG, N("mem"), Pmem, NULL },
! 89: { DT_REG, N("ctl"), Pctl, NULL },
! 90: { DT_REG, N("status"), Pstatus, NULL },
! 91: { DT_REG, N("note"), Pnote, NULL },
! 92: { DT_REG, N("notepg"), Pnotepg, NULL },
! 93: { DT_REG, N("cmdline"), Pcmdline, NULL },
! 94: { DT_REG, N("exe"), Pfile, procfs_validfile_linux },
! 95: #undef N
! 96: };
! 97: static int nproc_targets = sizeof(proc_targets) / sizeof(proc_targets[0]);
! 98:
! 99: /*
! 100: * List of files in the root directory. Note: the validate function
! 101: * will be called with p == NULL for these
! 102: */
! 103: struct proc_target proc_root_targets[] = {
! 104: #define N(s) sizeof(s)-1, s
! 105: /* name type validp */
! 106: { DT_REG, N("meminfo"), Pmeminfo, procfs_validfile_linux },
! 107: { DT_REG, N("cpuinfo"), Pcpuinfo, procfs_validfile_linux },
! 108: #undef N
! 109: };
! 110: static int nproc_root_targets =
! 111: sizeof(proc_root_targets) / sizeof(proc_root_targets[0]);
! 112:
! 113: static pid_t atopid(const char *, u_int);
! 114:
! 115: /*
! 116: * Prototypes for procfs vnode ops
! 117: */
! 118: int procfs_badop(void *);
! 119:
! 120: int procfs_lookup(void *);
! 121: #define procfs_create procfs_badop
! 122: #define procfs_mknod procfs_badop
! 123: int procfs_open(void *);
! 124: int procfs_close(void *);
! 125: int procfs_access(void *);
! 126: int procfs_getattr(void *);
! 127: int procfs_setattr(void *);
! 128: #define procfs_read procfs_rw
! 129: #define procfs_write procfs_rw
! 130: int procfs_ioctl(void *);
! 131: #define procfs_fsync procfs_badop
! 132: #define procfs_remove procfs_badop
! 133: int procfs_link(void *);
! 134: #define procfs_rename procfs_badop
! 135: #define procfs_mkdir procfs_badop
! 136: #define procfs_rmdir procfs_badop
! 137: int procfs_symlink(void *);
! 138: int procfs_readdir(void *);
! 139: int procfs_readlink(void *);
! 140: int procfs_inactive(void *);
! 141: int procfs_reclaim(void *);
! 142: #define procfs_lock nullop
! 143: #define procfs_unlock nullop
! 144: int procfs_bmap(void *);
! 145: #define procfs_strategy procfs_badop
! 146: int procfs_print(void *);
! 147: int procfs_pathconf(void *);
! 148: #define procfs_islocked nullop
! 149: #define procfs_advlock procfs_badop
! 150:
! 151: static pid_t atopid(const char *, u_int);
! 152:
! 153: /*
! 154: * procfs vnode operations.
! 155: */
! 156: int (**procfs_vnodeop_p)(void *);
! 157: struct vnodeopv_entry_desc procfs_vnodeop_entries[] = {
! 158: { &vop_default_desc, vn_default_error },
! 159: { &vop_lookup_desc, procfs_lookup }, /* lookup */
! 160: { &vop_create_desc, procfs_create }, /* create */
! 161: { &vop_mknod_desc, procfs_mknod }, /* mknod */
! 162: { &vop_open_desc, procfs_open }, /* open */
! 163: { &vop_close_desc, procfs_close }, /* close */
! 164: { &vop_access_desc, procfs_access }, /* access */
! 165: { &vop_getattr_desc, procfs_getattr }, /* getattr */
! 166: { &vop_setattr_desc, procfs_setattr }, /* setattr */
! 167: { &vop_read_desc, procfs_read }, /* read */
! 168: { &vop_write_desc, procfs_write }, /* write */
! 169: { &vop_ioctl_desc, procfs_ioctl }, /* ioctl */
! 170: { &vop_poll_desc, procfs_poll }, /* poll */
! 171: { &vop_fsync_desc, procfs_fsync }, /* fsync */
! 172: { &vop_remove_desc, procfs_remove }, /* remove */
! 173: { &vop_link_desc, procfs_link }, /* link */
! 174: { &vop_rename_desc, procfs_rename }, /* rename */
! 175: { &vop_mkdir_desc, procfs_mkdir }, /* mkdir */
! 176: { &vop_rmdir_desc, procfs_rmdir }, /* rmdir */
! 177: { &vop_symlink_desc, procfs_symlink }, /* symlink */
! 178: { &vop_readdir_desc, procfs_readdir }, /* readdir */
! 179: { &vop_readlink_desc, procfs_readlink }, /* readlink */
! 180: { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
! 181: { &vop_inactive_desc, procfs_inactive }, /* inactive */
! 182: { &vop_reclaim_desc, procfs_reclaim }, /* reclaim */
! 183: { &vop_lock_desc, procfs_lock }, /* lock */
! 184: { &vop_unlock_desc, procfs_unlock }, /* unlock */
! 185: { &vop_bmap_desc, procfs_bmap }, /* bmap */
! 186: { &vop_strategy_desc, procfs_strategy }, /* strategy */
! 187: { &vop_print_desc, procfs_print }, /* print */
! 188: { &vop_islocked_desc, procfs_islocked }, /* islocked */
! 189: { &vop_pathconf_desc, procfs_pathconf }, /* pathconf */
! 190: { &vop_advlock_desc, procfs_advlock }, /* advlock */
! 191: { NULL, NULL }
! 192: };
! 193: struct vnodeopv_desc procfs_vnodeop_opv_desc =
! 194: { &procfs_vnodeop_p, procfs_vnodeop_entries };
! 195: /*
! 196: * set things up for doing i/o on
! 197: * the pfsnode (vp). (vp) is locked
! 198: * on entry, and should be left locked
! 199: * on exit.
! 200: *
! 201: * for procfs we don't need to do anything
! 202: * in particular for i/o. all that is done
! 203: * is to support exclusive open on process
! 204: * memory images.
! 205: */
! 206: int
! 207: procfs_open(void *v)
! 208: {
! 209: struct vop_open_args *ap = v;
! 210: struct pfsnode *pfs = VTOPFS(ap->a_vp);
! 211: struct proc *p1 = ap->a_p; /* tracer */
! 212: struct proc *p2; /* traced */
! 213: int error;
! 214:
! 215: if ((p2 = pfind(pfs->pfs_pid)) == 0)
! 216: return (ENOENT); /* was ESRCH, jsp */
! 217:
! 218: switch (pfs->pfs_type) {
! 219: case Pmem:
! 220: if (((pfs->pfs_flags & FWRITE) && (ap->a_mode & O_EXCL)) ||
! 221: ((pfs->pfs_flags & O_EXCL) && (ap->a_mode & FWRITE)))
! 222: return (EBUSY);
! 223:
! 224: if ((error = process_checkioperm(p1, p2)) != 0)
! 225: return (error);
! 226:
! 227: if (ap->a_mode & FWRITE)
! 228: pfs->pfs_flags = ap->a_mode & (FWRITE|O_EXCL);
! 229:
! 230: return (0);
! 231:
! 232: default:
! 233: break;
! 234: }
! 235:
! 236: return (0);
! 237: }
! 238:
! 239: /*
! 240: * close the pfsnode (vp) after doing i/o.
! 241: * (vp) is not locked on entry or exit.
! 242: *
! 243: * nothing to do for procfs other than undo
! 244: * any exclusive open flag (see _open above).
! 245: */
! 246: int
! 247: procfs_close(void *v)
! 248: {
! 249: struct vop_close_args *ap = v;
! 250: struct pfsnode *pfs = VTOPFS(ap->a_vp);
! 251:
! 252: switch (pfs->pfs_type) {
! 253: case Pmem:
! 254: if ((ap->a_fflag & FWRITE) && (pfs->pfs_flags & O_EXCL))
! 255: pfs->pfs_flags &= ~(FWRITE|O_EXCL);
! 256: break;
! 257: case Pctl:
! 258: case Pstatus:
! 259: case Pnotepg:
! 260: case Pnote:
! 261: case Proot:
! 262: case Pcurproc:
! 263: case Pself:
! 264: case Pproc:
! 265: case Pfile:
! 266: case Pregs:
! 267: case Pfpregs:
! 268: case Pcmdline:
! 269: case Pmeminfo:
! 270: case Pcpuinfo:
! 271: break;
! 272: }
! 273:
! 274: return (0);
! 275: }
! 276:
! 277: /*
! 278: * do an ioctl operation on pfsnode (vp).
! 279: * (vp) is not locked on entry or exit.
! 280: */
! 281: /*ARGSUSED*/
! 282: int
! 283: procfs_ioctl(void *v)
! 284: {
! 285:
! 286: return (ENOTTY);
! 287: }
! 288:
! 289: /*
! 290: * do block mapping for pfsnode (vp).
! 291: * since we don't use the buffer cache
! 292: * for procfs this function should never
! 293: * be called. in any case, it's not clear
! 294: * what part of the kernel ever makes use
! 295: * of this function. for sanity, this is the
! 296: * usual no-op bmap, although returning
! 297: * (EIO) would be a reasonable alternative.
! 298: */
! 299: int
! 300: procfs_bmap(void *v)
! 301: {
! 302: struct vop_bmap_args *ap = v;
! 303:
! 304: if (ap->a_vpp != NULL)
! 305: *ap->a_vpp = ap->a_vp;
! 306: if (ap->a_bnp != NULL)
! 307: *ap->a_bnp = ap->a_bn;
! 308: return (0);
! 309: }
! 310:
! 311: /*
! 312: * _inactive is called when the pfsnode
! 313: * is vrele'd and the reference count goes
! 314: * to zero. (vp) will be on the vnode free
! 315: * list, so to get it back vget() must be
! 316: * used.
! 317: *
! 318: * for procfs, check if the process is still
! 319: * alive and if it isn't then just throw away
! 320: * the vnode by calling vgone(). this may
! 321: * be overkill and a waste of time since the
! 322: * chances are that the process will still be
! 323: * there and pfind is not free.
! 324: *
! 325: * (vp) is not locked on entry or exit.
! 326: */
! 327: int
! 328: procfs_inactive(void *v)
! 329: {
! 330: struct vop_inactive_args *ap = v;
! 331: struct vnode *vp = ap->a_vp;
! 332: struct pfsnode *pfs = VTOPFS(vp);
! 333:
! 334: if (pfind(pfs->pfs_pid) == NULL && !(vp->v_flag & VXLOCK))
! 335: vgone(vp);
! 336:
! 337: return (0);
! 338: }
! 339:
! 340: /*
! 341: * _reclaim is called when getnewvnode()
! 342: * wants to make use of an entry on the vnode
! 343: * free list. at this time the filesystem needs
! 344: * to free any private data and remove the node
! 345: * from any private lists.
! 346: */
! 347: int
! 348: procfs_reclaim(void *v)
! 349: {
! 350: struct vop_reclaim_args *ap = v;
! 351:
! 352: return (procfs_freevp(ap->a_vp));
! 353: }
! 354:
! 355: /*
! 356: * Return POSIX pathconf information applicable to special devices.
! 357: */
! 358: int
! 359: procfs_pathconf(void *v)
! 360: {
! 361: struct vop_pathconf_args *ap = v;
! 362:
! 363: switch (ap->a_name) {
! 364: case _PC_LINK_MAX:
! 365: *ap->a_retval = LINK_MAX;
! 366: return (0);
! 367: case _PC_MAX_CANON:
! 368: *ap->a_retval = MAX_CANON;
! 369: return (0);
! 370: case _PC_MAX_INPUT:
! 371: *ap->a_retval = MAX_INPUT;
! 372: return (0);
! 373: case _PC_PIPE_BUF:
! 374: *ap->a_retval = PIPE_BUF;
! 375: return (0);
! 376: case _PC_CHOWN_RESTRICTED:
! 377: *ap->a_retval = 1;
! 378: return (0);
! 379: case _PC_VDISABLE:
! 380: *ap->a_retval = _POSIX_VDISABLE;
! 381: return (0);
! 382: default:
! 383: return (EINVAL);
! 384: }
! 385: /* NOTREACHED */
! 386: }
! 387:
! 388: /*
! 389: * _print is used for debugging.
! 390: * just print a readable description
! 391: * of (vp).
! 392: */
! 393: int
! 394: procfs_print(void *v)
! 395: {
! 396: struct vop_print_args *ap = v;
! 397: struct pfsnode *pfs = VTOPFS(ap->a_vp);
! 398:
! 399: printf("tag VT_PROCFS, type %d, pid %d, mode %x, flags %lx\n",
! 400: pfs->pfs_type, pfs->pfs_pid, pfs->pfs_mode, pfs->pfs_flags);
! 401: return 0;
! 402: }
! 403:
! 404: int
! 405: procfs_link(void *v)
! 406: {
! 407: struct vop_link_args *ap = v;
! 408:
! 409: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
! 410: vput(ap->a_dvp);
! 411: return (EROFS);
! 412: }
! 413:
! 414: int
! 415: procfs_symlink(void *v)
! 416: {
! 417: struct vop_symlink_args *ap = v;
! 418:
! 419: VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
! 420: vput(ap->a_dvp);
! 421: return (EROFS);
! 422: }
! 423:
! 424:
! 425: /*
! 426: * generic entry point for unsupported operations
! 427: */
! 428: /*ARGSUSED*/
! 429: int
! 430: procfs_badop(void *v)
! 431: {
! 432:
! 433: return (EIO);
! 434: }
! 435:
! 436: /*
! 437: * Invent attributes for pfsnode (vp) and store
! 438: * them in (vap).
! 439: * Directories lengths are returned as zero since
! 440: * any real length would require the genuine size
! 441: * to be computed, and nothing cares anyway.
! 442: *
! 443: * this is relatively minimal for procfs.
! 444: */
! 445: int
! 446: procfs_getattr(void *v)
! 447: {
! 448: struct vop_getattr_args *ap = v;
! 449: struct pfsnode *pfs = VTOPFS(ap->a_vp);
! 450: struct vattr *vap = ap->a_vap;
! 451: struct proc *procp;
! 452: int error;
! 453:
! 454: /* first check the process still exists */
! 455: switch (pfs->pfs_type) {
! 456: case Proot:
! 457: case Pcurproc:
! 458: case Pcpuinfo:
! 459: case Pmeminfo:
! 460: procp = 0;
! 461: break;
! 462:
! 463: default:
! 464: procp = pfind(pfs->pfs_pid);
! 465: if (procp == 0)
! 466: return (ENOENT);
! 467: }
! 468:
! 469: error = 0;
! 470:
! 471: /* start by zeroing out the attributes */
! 472: VATTR_NULL(vap);
! 473:
! 474: /* next do all the common fields */
! 475: vap->va_type = ap->a_vp->v_type;
! 476: vap->va_mode = pfs->pfs_mode;
! 477: vap->va_fileid = pfs->pfs_fileno;
! 478: vap->va_flags = 0;
! 479: vap->va_blocksize = PAGE_SIZE;
! 480: vap->va_bytes = vap->va_size = 0;
! 481:
! 482: /*
! 483: * Make all times be current TOD.
! 484: * It would be possible to get the process start
! 485: * time from the p_stat structure, but there's
! 486: * no "file creation" time stamp anyway, and the
! 487: * p_stat structure is not addressible if u. gets
! 488: * swapped out for that process.
! 489: */
! 490: getnanotime(&vap->va_ctime);
! 491: vap->va_atime = vap->va_mtime = vap->va_ctime;
! 492:
! 493: switch (pfs->pfs_type) {
! 494: case Pregs:
! 495: case Pfpregs:
! 496: #ifndef PTRACE
! 497: break;
! 498: #endif
! 499: case Pmem:
! 500: /*
! 501: * If the process has exercised some setuid or setgid
! 502: * privilege, then rip away read/write permission so
! 503: * that only root can gain access.
! 504: */
! 505: if (procp->p_flag & P_SUGID)
! 506: vap->va_mode &= ~(S_IRUSR|S_IWUSR);
! 507: /* FALLTHROUGH */
! 508: case Pctl:
! 509: case Pstatus:
! 510: case Pnote:
! 511: case Pnotepg:
! 512: case Pcmdline:
! 513: vap->va_nlink = 1;
! 514: vap->va_uid = procp->p_ucred->cr_uid;
! 515: vap->va_gid = procp->p_ucred->cr_gid;
! 516: break;
! 517: case Pmeminfo:
! 518: case Pcpuinfo:
! 519: vap->va_nlink = 1;
! 520: vap->va_uid = vap->va_gid = 0;
! 521: break;
! 522: case Pproc:
! 523: case Pfile:
! 524: case Proot:
! 525: case Pcurproc:
! 526: case Pself:
! 527: break;
! 528: }
! 529:
! 530: /*
! 531: * now do the object specific fields
! 532: *
! 533: * The size could be set from struct reg, but it's hardly
! 534: * worth the trouble, and it puts some (potentially) machine
! 535: * dependent data into this machine-independent code. If it
! 536: * becomes important then this function should break out into
! 537: * a per-file stat function in the corresponding .c file.
! 538: */
! 539:
! 540: switch (pfs->pfs_type) {
! 541: case Proot:
! 542: /*
! 543: * Set nlink to 1 to tell fts(3) we don't actually know.
! 544: */
! 545: vap->va_nlink = 1;
! 546: vap->va_uid = 0;
! 547: vap->va_gid = 0;
! 548: vap->va_size = vap->va_bytes = DEV_BSIZE;
! 549: break;
! 550:
! 551: case Pcurproc: {
! 552: char buf[16]; /* should be enough */
! 553: int len;
! 554:
! 555: len = snprintf(buf, sizeof buf, "%ld", (long)curproc->p_pid);
! 556: if (len == -1 || len >= sizeof buf) {
! 557: error = EINVAL;
! 558: break;
! 559: }
! 560: vap->va_nlink = 1;
! 561: vap->va_uid = 0;
! 562: vap->va_gid = 0;
! 563: vap->va_size = vap->va_bytes = len;
! 564: break;
! 565: }
! 566:
! 567: case Pself:
! 568: vap->va_nlink = 1;
! 569: vap->va_uid = 0;
! 570: vap->va_gid = 0;
! 571: vap->va_size = vap->va_bytes = sizeof("curproc");
! 572: break;
! 573:
! 574: case Pproc:
! 575: vap->va_nlink = 2;
! 576: vap->va_uid = procp->p_ucred->cr_uid;
! 577: vap->va_gid = procp->p_ucred->cr_gid;
! 578: vap->va_size = vap->va_bytes = DEV_BSIZE;
! 579: break;
! 580:
! 581: case Pfile:
! 582: error = EOPNOTSUPP;
! 583: break;
! 584:
! 585: case Pmem:
! 586: vap->va_bytes = vap->va_size =
! 587: ctob(procp->p_vmspace->vm_tsize +
! 588: procp->p_vmspace->vm_dsize +
! 589: procp->p_vmspace->vm_ssize);
! 590: break;
! 591:
! 592: case Pregs:
! 593: #ifdef PTRACE
! 594: vap->va_bytes = vap->va_size = sizeof(struct reg);
! 595: #endif
! 596: break;
! 597:
! 598: case Pfpregs:
! 599: #if defined(PT_GETFPREGS) || defined(PT_SETFPREGS)
! 600: #ifdef PTRACE
! 601: vap->va_bytes = vap->va_size = sizeof(struct fpreg);
! 602: #endif
! 603: #endif
! 604: break;
! 605:
! 606: case Pctl:
! 607: case Pstatus:
! 608: case Pnote:
! 609: case Pnotepg:
! 610: case Pcmdline:
! 611: case Pmeminfo:
! 612: case Pcpuinfo:
! 613: vap->va_bytes = vap->va_size = 0;
! 614: break;
! 615:
! 616: #ifdef DIAGNOSTIC
! 617: default:
! 618: panic("procfs_getattr");
! 619: #endif
! 620: }
! 621:
! 622: return (error);
! 623: }
! 624:
! 625: /*ARGSUSED*/
! 626: int
! 627: procfs_setattr(void *v)
! 628: {
! 629: /*
! 630: * just fake out attribute setting
! 631: * it's not good to generate an error
! 632: * return, otherwise things like creat()
! 633: * will fail when they try to set the
! 634: * file length to 0. worse, this means
! 635: * that echo $note > /proc/$pid/note will fail.
! 636: */
! 637:
! 638: return (0);
! 639: }
! 640:
! 641: /*
! 642: * implement access checking.
! 643: *
! 644: * actually, the check for super-user is slightly
! 645: * broken since it will allow read access to write-only
! 646: * objects. this doesn't cause any particular trouble
! 647: * but does mean that the i/o entry points need to check
! 648: * that the operation really does make sense.
! 649: */
! 650: int
! 651: procfs_access(void *v)
! 652: {
! 653: struct vop_access_args *ap = v;
! 654: struct vattr va;
! 655: int error;
! 656:
! 657: if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_p)) != 0)
! 658: return (error);
! 659:
! 660: return (vaccess(va.va_mode, va.va_uid, va.va_gid, ap->a_mode,
! 661: ap->a_cred));
! 662: }
! 663:
! 664: /*
! 665: * lookup. this is incredibly complicated in the
! 666: * general case, however for most pseudo-filesystems
! 667: * very little needs to be done.
! 668: *
! 669: * unless you want to get a migraine, just make sure your
! 670: * filesystem doesn't do any locking of its own. otherwise
! 671: * read and inwardly digest ufs_lookup().
! 672: */
! 673: int
! 674: procfs_lookup(void *v)
! 675: {
! 676: struct vop_lookup_args *ap = v;
! 677: struct componentname *cnp = ap->a_cnp;
! 678: struct vnode **vpp = ap->a_vpp;
! 679: struct vnode *dvp = ap->a_dvp;
! 680: char *pname = cnp->cn_nameptr;
! 681: struct proc *curp = curproc;
! 682: struct proc_target *pt;
! 683: struct vnode *fvp;
! 684: pid_t pid;
! 685: struct pfsnode *pfs;
! 686: struct proc *p = NULL;
! 687: int i, error, wantpunlock, iscurproc = 0, isself = 0;
! 688:
! 689: *vpp = NULL;
! 690: cnp->cn_flags &= ~PDIRUNLOCK;
! 691:
! 692: if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
! 693: return (EROFS);
! 694:
! 695: if (cnp->cn_namelen == 1 && *pname == '.') {
! 696: *vpp = dvp;
! 697: VREF(dvp);
! 698: return (0);
! 699: }
! 700:
! 701: wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN));
! 702: pfs = VTOPFS(dvp);
! 703: switch (pfs->pfs_type) {
! 704: case Proot:
! 705: if (cnp->cn_flags & ISDOTDOT)
! 706: return (EIO);
! 707:
! 708: iscurproc = CNEQ(cnp, "curproc", 7);
! 709: isself = CNEQ(cnp, "self", 4);
! 710:
! 711: if (iscurproc || isself) {
! 712: error = procfs_allocvp(dvp->v_mount, vpp, 0,
! 713: iscurproc ? Pcurproc : Pself);
! 714: if ((error == 0) && (wantpunlock)) {
! 715: VOP_UNLOCK(dvp, 0, curp);
! 716: cnp->cn_flags |= PDIRUNLOCK;
! 717: }
! 718: return (error);
! 719: }
! 720:
! 721: for (i = 0; i < nproc_root_targets; i++) {
! 722: pt = &proc_root_targets[i];
! 723: if (cnp->cn_namelen == pt->pt_namlen &&
! 724: memcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 &&
! 725: (pt->pt_valid == NULL ||
! 726: (*pt->pt_valid)(p, dvp->v_mount)))
! 727: break;
! 728: }
! 729:
! 730: if (i != nproc_root_targets) {
! 731: error = procfs_allocvp(dvp->v_mount, vpp, 0,
! 732: pt->pt_pfstype);
! 733: if ((error == 0) && (wantpunlock)) {
! 734: VOP_UNLOCK(dvp, 0, curp);
! 735: cnp->cn_flags |= PDIRUNLOCK;
! 736: }
! 737: return (error);
! 738: }
! 739:
! 740: pid = atopid(pname, cnp->cn_namelen);
! 741: if (pid == NO_PID)
! 742: break;
! 743:
! 744: p = pfind(pid);
! 745: if (p == 0)
! 746: break;
! 747:
! 748: error = procfs_allocvp(dvp->v_mount, vpp, pid, Pproc);
! 749: if ((error == 0) && wantpunlock) {
! 750: VOP_UNLOCK(dvp, 0, curp);
! 751: cnp->cn_flags |= PDIRUNLOCK;
! 752: }
! 753: return (error);
! 754:
! 755: case Pproc:
! 756: /*
! 757: * do the .. dance. We unlock the directory, and then
! 758: * get the root dir. That will automatically return ..
! 759: * locked. Then if the caller wanted dvp locked, we
! 760: * re-lock.
! 761: */
! 762: if (cnp->cn_flags & ISDOTDOT) {
! 763: VOP_UNLOCK(dvp, 0, p);
! 764: cnp->cn_flags |= PDIRUNLOCK;
! 765: error = procfs_root(dvp->v_mount, vpp);
! 766: if ((error == 0) && (wantpunlock == 0) &&
! 767: ((error = vn_lock(dvp, LK_EXCLUSIVE, curp)) == 0))
! 768: cnp->cn_flags &= ~PDIRUNLOCK;
! 769: return (error);
! 770: }
! 771:
! 772: p = pfind(pfs->pfs_pid);
! 773: if (p == 0)
! 774: break;
! 775:
! 776: for (pt = proc_targets, i = 0; i < nproc_targets; pt++, i++) {
! 777: if (cnp->cn_namelen == pt->pt_namlen &&
! 778: bcmp(pt->pt_name, pname, cnp->cn_namelen) == 0 &&
! 779: (pt->pt_valid == NULL ||
! 780: (*pt->pt_valid)(p, dvp->v_mount)))
! 781: goto found;
! 782: }
! 783: break;
! 784:
! 785: found:
! 786: if (pt->pt_pfstype == Pfile) {
! 787: fvp = p->p_textvp;
! 788: /* We already checked that it exists. */
! 789: VREF(fvp);
! 790: vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, curp);
! 791: if (wantpunlock) {
! 792: VOP_UNLOCK(dvp, 0, curp);
! 793: cnp->cn_flags |= PDIRUNLOCK;
! 794: }
! 795: *vpp = fvp;
! 796: return (0);
! 797: }
! 798:
! 799: error = procfs_allocvp(dvp->v_mount, vpp, pfs->pfs_pid,
! 800: pt->pt_pfstype);
! 801: if ((error == 0) && (wantpunlock)) {
! 802: VOP_UNLOCK(dvp, 0, curp);
! 803: cnp->cn_flags |= PDIRUNLOCK;
! 804: }
! 805: return (error);
! 806:
! 807: default:
! 808: return (ENOTDIR);
! 809: }
! 810:
! 811: return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
! 812: }
! 813:
! 814: int
! 815: procfs_validfile(struct proc *p, struct mount *mp)
! 816: {
! 817:
! 818: return (p->p_textvp != NULLVP);
! 819: }
! 820:
! 821: int
! 822: procfs_validfile_linux(struct proc *p, struct mount *mp)
! 823: {
! 824: int flags;
! 825:
! 826: flags = VFSTOPROC(mp)->pmnt_flags;
! 827: return ((flags & PROCFSMNT_LINUXCOMPAT) &&
! 828: (p == NULL || procfs_validfile(p, mp)));
! 829: }
! 830:
! 831: /*
! 832: * readdir returns directory entries from pfsnode (vp).
! 833: *
! 834: * the strategy here with procfs is to generate a single
! 835: * directory entry at a time (struct dirent) and then
! 836: * copy that out to userland using uiomove. a more efficent
! 837: * though more complex implementation, would try to minimize
! 838: * the number of calls to uiomove(). for procfs, this is
! 839: * hardly worth the added code complexity.
! 840: *
! 841: * this should just be done through read()
! 842: */
! 843: int
! 844: procfs_readdir(void *v)
! 845: {
! 846: struct vop_readdir_args *ap = v;
! 847: struct uio *uio = ap->a_uio;
! 848: struct dirent d;
! 849: struct pfsnode *pfs;
! 850: struct vnode *vp;
! 851: int i;
! 852: int error;
! 853:
! 854: vp = ap->a_vp;
! 855: pfs = VTOPFS(vp);
! 856:
! 857: if (uio->uio_resid < UIO_MX)
! 858: return (EINVAL);
! 859:
! 860: error = 0;
! 861: i = uio->uio_offset;
! 862: if (i < 0)
! 863: return (EINVAL);
! 864: bzero(&d, UIO_MX);
! 865: d.d_reclen = UIO_MX;
! 866:
! 867: switch (pfs->pfs_type) {
! 868: /*
! 869: * this is for the process-specific sub-directories.
! 870: * all that is needed to is copy out all the entries
! 871: * from the procent[] table (top of this file).
! 872: */
! 873: case Pproc: {
! 874: struct proc *p;
! 875: struct proc_target *pt;
! 876:
! 877: p = pfind(pfs->pfs_pid);
! 878: if (p == NULL)
! 879: break;
! 880:
! 881: for (pt = &proc_targets[i];
! 882: uio->uio_resid >= UIO_MX && i < nproc_targets; pt++, i++) {
! 883: if (pt->pt_valid &&
! 884: (*pt->pt_valid)(p, vp->v_mount) == 0)
! 885: continue;
! 886:
! 887: d.d_fileno = PROCFS_FILENO(pfs->pfs_pid, pt->pt_pfstype);
! 888: d.d_namlen = pt->pt_namlen;
! 889: bcopy(pt->pt_name, d.d_name, pt->pt_namlen + 1);
! 890: d.d_type = pt->pt_type;
! 891:
! 892: if ((error = uiomove(&d, UIO_MX, uio)) != 0)
! 893: break;
! 894: }
! 895:
! 896: break;
! 897: }
! 898:
! 899: /*
! 900: * this is for the root of the procfs filesystem
! 901: * what is needed is a special entry for "curproc"
! 902: * followed by an entry for each process on allproc
! 903: #ifdef PROCFS_ZOMBIE
! 904: * and zombproc.
! 905: #endif
! 906: */
! 907:
! 908: case Proot: {
! 909: #ifdef PROCFS_ZOMBIE
! 910: int doingzomb = 0;
! 911: #endif
! 912: int pcnt = i;
! 913: volatile struct proc *p = LIST_FIRST(&allproc);
! 914:
! 915: if (pcnt > 3)
! 916: pcnt = 3;
! 917: #ifdef PROCFS_ZOMBIE
! 918: again:
! 919: #endif
! 920: for (; p && uio->uio_resid >= UIO_MX; i++, pcnt++) {
! 921: switch (i) {
! 922: case 0: /* `.' */
! 923: case 1: /* `..' */
! 924: d.d_fileno = PROCFS_FILENO(0, Proot);
! 925: d.d_namlen = i + 1;
! 926: bcopy("..", d.d_name, d.d_namlen);
! 927: d.d_name[i + 1] = '\0';
! 928: d.d_type = DT_DIR;
! 929: break;
! 930:
! 931: case 2:
! 932: d.d_fileno = PROCFS_FILENO(0, Pcurproc);
! 933: d.d_namlen = 7;
! 934: bcopy("curproc", d.d_name, 8);
! 935: d.d_type = DT_LNK;
! 936: break;
! 937:
! 938: case 3:
! 939: d.d_fileno = PROCFS_FILENO(0, Pself);
! 940: d.d_namlen = 4;
! 941: bcopy("self", d.d_name, 5);
! 942: d.d_type = DT_LNK;
! 943: break;
! 944:
! 945: case 4:
! 946: if (VFSTOPROC(vp->v_mount)->pmnt_flags &
! 947: PROCFSMNT_LINUXCOMPAT) {
! 948: d.d_fileno = PROCFS_FILENO(0, Pcpuinfo);
! 949: d.d_namlen = 7;
! 950: bcopy("cpuinfo", d.d_name, 8);
! 951: d.d_type = DT_REG;
! 952: break;
! 953: }
! 954: /* fall through */
! 955:
! 956: case 5:
! 957: if (VFSTOPROC(vp->v_mount)->pmnt_flags &
! 958: PROCFSMNT_LINUXCOMPAT) {
! 959: d.d_fileno = PROCFS_FILENO(0, Pmeminfo);
! 960: d.d_namlen = 7;
! 961: bcopy("meminfo", d.d_name, 8);
! 962: d.d_type = DT_REG;
! 963: break;
! 964: }
! 965: /* fall through */
! 966:
! 967: default:
! 968: while (pcnt < i) {
! 969: pcnt++;
! 970: p = LIST_NEXT(p, p_list);
! 971: if (!p)
! 972: goto done;
! 973: }
! 974: d.d_fileno = PROCFS_FILENO(p->p_pid, Pproc);
! 975: d.d_namlen = snprintf(d.d_name, sizeof(d.d_name),
! 976: "%ld", (long)p->p_pid);
! 977: d.d_type = DT_REG;
! 978: p = LIST_NEXT(p, p_list);
! 979: break;
! 980: }
! 981:
! 982: if ((error = uiomove(&d, UIO_MX, uio)) != 0)
! 983: break;
! 984: }
! 985: done:
! 986:
! 987: #ifdef PROCFS_ZOMBIE
! 988: if (p == 0 && doingzomb == 0) {
! 989: doingzomb = 1;
! 990: p = LIST_FIRST(&zombproc);
! 991: goto again;
! 992: }
! 993: #endif
! 994:
! 995: break;
! 996:
! 997: }
! 998:
! 999: default:
! 1000: error = ENOTDIR;
! 1001: break;
! 1002: }
! 1003:
! 1004: uio->uio_offset = i;
! 1005: return (error);
! 1006: }
! 1007:
! 1008: /*
! 1009: * readlink reads the link of `curproc'
! 1010: */
! 1011: int
! 1012: procfs_readlink(void *v)
! 1013: {
! 1014: struct vop_readlink_args *ap = v;
! 1015: char buf[16]; /* should be enough */
! 1016: int len;
! 1017:
! 1018: if (VTOPFS(ap->a_vp)->pfs_fileno == PROCFS_FILENO(0, Pcurproc))
! 1019: len = snprintf(buf, sizeof buf, "%ld", (long)curproc->p_pid);
! 1020: else if (VTOPFS(ap->a_vp)->pfs_fileno == PROCFS_FILENO(0, Pself))
! 1021: len = strlcpy(buf, "curproc", sizeof buf);
! 1022: else
! 1023: return (EINVAL);
! 1024: if (len == -1 || len >= sizeof buf)
! 1025: return (EINVAL);
! 1026:
! 1027: return (uiomove(buf, len, ap->a_uio));
! 1028: }
! 1029:
! 1030: /*
! 1031: * convert decimal ascii to pid_t
! 1032: */
! 1033: static pid_t
! 1034: atopid(const char *b, u_int len)
! 1035: {
! 1036: pid_t p = 0;
! 1037:
! 1038: while (len--) {
! 1039: char c = *b++;
! 1040: if (c < '0' || c > '9')
! 1041: return (NO_PID);
! 1042: p = 10 * p + (c - '0');
! 1043: if (p > PID_MAX)
! 1044: return (NO_PID);
! 1045: }
! 1046:
! 1047: return (p);
! 1048: }
! 1049: int
! 1050: procfs_poll(void *v)
! 1051: {
! 1052: struct vop_poll_args *ap = v;
! 1053:
! 1054: return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
! 1055: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to procfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / miscfs / procfs