Annotation of sys/miscfs/procfs/procfs_subr.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: procfs_subr.c,v 1.27 2007/06/22 09:38:53 jasper Exp $ */
! 2: /* $NetBSD: procfs_subr.c,v 1.15 1996/02/12 15:01:42 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_subr.c 8.5 (Berkeley) 6/15/94
! 37: */
! 38:
! 39: #include <sys/param.h>
! 40: #include <sys/systm.h>
! 41: #include <sys/time.h>
! 42: #include <sys/kernel.h>
! 43: #include <sys/proc.h>
! 44: #include <sys/vnode.h>
! 45: #include <sys/malloc.h>
! 46: #include <sys/stat.h>
! 47: #include <sys/ptrace.h>
! 48:
! 49: #include <miscfs/procfs/procfs.h>
! 50:
! 51: static TAILQ_HEAD(, pfsnode) pfshead;
! 52: struct lock pfs_vlock;
! 53:
! 54: /*ARGSUSED*/
! 55: int
! 56: procfs_init(struct vfsconf *vfsp)
! 57: {
! 58: lockinit(&pfs_vlock, PVFS, "procfsl", 0, 0);
! 59: TAILQ_INIT(&pfshead);
! 60: return (0);
! 61: }
! 62:
! 63: /*
! 64: * allocate a pfsnode/vnode pair. the vnode is
! 65: * referenced, but not locked.
! 66: *
! 67: * the pid, pfs_type, and mount point uniquely
! 68: * identify a pfsnode. the mount point is needed
! 69: * because someone might mount this filesystem
! 70: * twice.
! 71: *
! 72: * all pfsnodes are maintained on a singly-linked
! 73: * list. new nodes are only allocated when they cannot
! 74: * be found on this list. entries on the list are
! 75: * removed when the vfs reclaim entry is called.
! 76: *
! 77: * a single lock is kept for the entire list. this is
! 78: * needed because the getnewvnode() function can block
! 79: * waiting for a vnode to become free, in which case there
! 80: * may be more than one process trying to get the same
! 81: * vnode. this lock is only taken if we are going to
! 82: * call getnewvnode, since the kernel itself is single-threaded.
! 83: *
! 84: * if an entry is found on the list, then call vget() to
! 85: * take a reference. this is done because there may be
! 86: * zero references to it and so it needs to removed from
! 87: * the vnode free list.
! 88: */
! 89: int
! 90: procfs_allocvp(struct mount *mp, struct vnode **vpp, pid_t pid, pfstype pfs_type)
! 91: {
! 92: struct proc *p = curproc;
! 93: struct pfsnode *pfs;
! 94: struct vnode *vp;
! 95: int error;
! 96:
! 97: /*
! 98: * Lock the vp list, getnewvnode can sleep.
! 99: */
! 100: error = lockmgr(&pfs_vlock, LK_EXCLUSIVE, NULL);
! 101: if (error)
! 102: return (error);
! 103: loop:
! 104: TAILQ_FOREACH(pfs, &pfshead, list) {
! 105: vp = PFSTOV(pfs);
! 106: if (pfs->pfs_pid == pid &&
! 107: pfs->pfs_type == pfs_type &&
! 108: vp->v_mount == mp) {
! 109: if (vget(vp, 0, p))
! 110: goto loop;
! 111: *vpp = vp;
! 112: goto out;
! 113: }
! 114: }
! 115:
! 116: if ((error = getnewvnode(VT_PROCFS, mp, procfs_vnodeop_p, vpp)) != 0)
! 117: goto out;
! 118: vp = *vpp;
! 119:
! 120: MALLOC(pfs, void *, sizeof(struct pfsnode), M_TEMP, M_WAITOK);
! 121: vp->v_data = pfs;
! 122:
! 123: pfs->pfs_pid = pid;
! 124: pfs->pfs_type = pfs_type;
! 125: pfs->pfs_vnode = vp;
! 126: pfs->pfs_flags = 0;
! 127: pfs->pfs_fileno = PROCFS_FILENO(pid, pfs_type);
! 128:
! 129: switch (pfs_type) {
! 130: case Proot: /* /proc = dr-xr-xr-x */
! 131: pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
! 132: vp->v_type = VDIR;
! 133: vp->v_flag = VROOT;
! 134: break;
! 135:
! 136: case Pcurproc: /* /proc/curproc = lr--r--r-- */
! 137: case Pself: /* /proc/self = lr--r--r-- */
! 138: pfs->pfs_mode = S_IRUSR|S_IRGRP|S_IROTH;
! 139: vp->v_type = VLNK;
! 140: break;
! 141:
! 142: case Pproc: /* /proc/N = dr-xr-xr-x */
! 143: pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
! 144: vp->v_type = VDIR;
! 145: break;
! 146:
! 147: case Pfile: /* /proc/N/file = -rw------- */
! 148: case Pmem: /* /proc/N/mem = -rw------- */
! 149: case Pregs: /* /proc/N/regs = -rw------- */
! 150: case Pfpregs: /* /proc/N/fpregs = -rw------- */
! 151: pfs->pfs_mode = S_IRUSR|S_IWUSR;
! 152: vp->v_type = VREG;
! 153: break;
! 154:
! 155: case Pctl: /* /proc/N/ctl = --w------ */
! 156: case Pnote: /* /proc/N/note = --w------ */
! 157: case Pnotepg: /* /proc/N/notepg = --w------ */
! 158: pfs->pfs_mode = S_IWUSR;
! 159: vp->v_type = VREG;
! 160: break;
! 161:
! 162: case Pstatus: /* /proc/N/status = -r--r--r-- */
! 163: case Pcmdline: /* /proc/N/cmdline = -r--r--r-- */
! 164: case Pmeminfo: /* /proc/meminfo = -r--r--r-- */
! 165: case Pcpuinfo: /* /proc/cpuinfo = -r--r--r-- */
! 166: pfs->pfs_mode = S_IRUSR|S_IRGRP|S_IROTH;
! 167: vp->v_type = VREG;
! 168: break;
! 169:
! 170: default:
! 171: panic("procfs_allocvp");
! 172: }
! 173:
! 174: /* add to procfs vnode list */
! 175: TAILQ_INSERT_TAIL(&pfshead, pfs, list);
! 176: uvm_vnp_setsize(vp, 0);
! 177: out:
! 178: lockmgr(&pfs_vlock, LK_RELEASE, NULL);
! 179:
! 180: return (error);
! 181: }
! 182:
! 183: int
! 184: procfs_freevp(struct vnode *vp)
! 185: {
! 186: struct pfsnode *pfs = VTOPFS(vp);
! 187:
! 188: TAILQ_REMOVE(&pfshead, pfs, list);
! 189: FREE(vp->v_data, M_TEMP);
! 190: vp->v_data = 0;
! 191: return (0);
! 192: }
! 193:
! 194: int
! 195: procfs_rw(void *v)
! 196: {
! 197: struct vop_read_args *ap = v;
! 198: struct vnode *vp = ap->a_vp;
! 199: struct uio *uio = ap->a_uio;
! 200: struct proc *curp = uio->uio_procp;
! 201: struct pfsnode *pfs = VTOPFS(vp);
! 202: struct proc *p;
! 203:
! 204: p = pfind(pfs->pfs_pid);
! 205: if (p == 0)
! 206: return (EINVAL);
! 207: /* Do not permit games to be played with init(8) */
! 208: if (p->p_pid == 1 && securelevel > 0 && uio->uio_rw == UIO_WRITE)
! 209: return (EPERM);
! 210: if (uio->uio_offset < 0)
! 211: return (EINVAL);
! 212:
! 213: switch (pfs->pfs_type) {
! 214: case Pnote:
! 215: case Pnotepg:
! 216: return (procfs_donote(curp, p, pfs, uio));
! 217:
! 218: case Pctl:
! 219: return (procfs_doctl(curp, p, pfs, uio));
! 220:
! 221: case Pstatus:
! 222: return (procfs_dostatus(curp, p, pfs, uio));
! 223:
! 224: case Pmem:
! 225: return (process_domem(curp, p, uio, PT_WRITE_I));
! 226:
! 227: case Pcmdline:
! 228: return (procfs_docmdline(curp, p, pfs, uio));
! 229:
! 230: case Pmeminfo:
! 231: return (procfs_domeminfo(curp, p, pfs, uio));
! 232:
! 233: case Pcpuinfo:
! 234: return (procfs_docpuinfo(curp, p, pfs, uio));
! 235:
! 236: default:
! 237: return (EOPNOTSUPP);
! 238: }
! 239: }
! 240:
! 241: /*
! 242: * Get a string from userland into (buf). Strip a trailing
! 243: * nl character (to allow easy access from the shell).
! 244: * The buffer should be *buflenp + 1 chars long. vfs_getuserstr
! 245: * will automatically add a nul char at the end.
! 246: *
! 247: * Returns 0 on success or the following errors
! 248: *
! 249: * EINVAL: file offset is non-zero.
! 250: * EMSGSIZE: message is longer than kernel buffer
! 251: * EFAULT: user i/o buffer is not addressable
! 252: */
! 253: int
! 254: vfs_getuserstr(struct uio *uio, char *buf, int *buflenp)
! 255: {
! 256: int xlen;
! 257: int error;
! 258:
! 259: if (uio->uio_offset != 0)
! 260: return (EINVAL);
! 261:
! 262: xlen = *buflenp;
! 263:
! 264: /* must be able to read the whole string in one go */
! 265: if (xlen < uio->uio_resid)
! 266: return (EMSGSIZE);
! 267: xlen = uio->uio_resid;
! 268:
! 269: if ((error = uiomove(buf, xlen, uio)) != 0)
! 270: return (error);
! 271:
! 272: /* allow multiple writes without seeks */
! 273: uio->uio_offset = 0;
! 274:
! 275: /* cleanup string and remove trailing newline */
! 276: buf[xlen] = '\0';
! 277: xlen = strlen(buf);
! 278: if (xlen > 0 && buf[xlen-1] == '\n')
! 279: buf[--xlen] = '\0';
! 280: *buflenp = xlen;
! 281:
! 282: return (0);
! 283: }
! 284:
! 285: const vfs_namemap_t *
! 286: vfs_findname(const vfs_namemap_t *nm, char *buf, int buflen)
! 287: {
! 288: for (; nm->nm_name; nm++)
! 289: if (bcmp(buf, nm->nm_name, buflen + 1) == 0)
! 290: return (nm);
! 291:
! 292: return (0);
! 293: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to procfs_subr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / miscfs / procfs