Home | History | Annotate | Line # | Download | only in procfs
procfs_subr.c revision 1.55
      1 /*	$NetBSD: procfs_subr.c,v 1.55 2003/06/29 18:43:34 thorpej Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1994 Christopher G. Demetriou.  All rights reserved.
      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. All advertising materials mentioning features or use of this software
     21  *    must display the following acknowledgement:
     22  *	This product includes software developed by the University of
     23  *	California, Berkeley and its contributors.
     24  * 4. Neither the name of the University nor the names of its contributors
     25  *    may be used to endorse or promote products derived from this software
     26  *    without specific prior written permission.
     27  *
     28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38  * SUCH DAMAGE.
     39  *
     40  *	@(#)procfs_subr.c	8.6 (Berkeley) 5/14/95
     41  */
     42 
     43 #include <sys/cdefs.h>
     44 __KERNEL_RCSID(0, "$NetBSD: procfs_subr.c,v 1.55 2003/06/29 18:43:34 thorpej Exp $");
     45 
     46 #include <sys/param.h>
     47 #include <sys/systm.h>
     48 #include <sys/time.h>
     49 #include <sys/kernel.h>
     50 #include <sys/proc.h>
     51 #include <sys/vnode.h>
     52 #include <sys/malloc.h>
     53 #include <sys/stat.h>
     54 #include <sys/file.h>
     55 #include <sys/filedesc.h>
     56 
     57 #include <miscfs/procfs/procfs.h>
     58 
     59 void procfs_hashins __P((struct pfsnode *));
     60 void procfs_hashrem __P((struct pfsnode *));
     61 struct vnode *procfs_hashget __P((pid_t, pfstype, int, struct mount *, struct lwp *));
     62 
     63 LIST_HEAD(pfs_hashhead, pfsnode) *pfs_hashtbl;
     64 u_long	pfs_ihash;	/* size of hash table - 1 */
     65 #define PFSPIDHASH(pid)	((pid) & pfs_ihash)
     66 
     67 struct lock pfs_hashlock;
     68 struct simplelock pfs_hash_slock;
     69 
     70 #define	ISSET(t, f)	((t) & (f))
     71 
     72 /*
     73  * allocate a pfsnode/vnode pair.  the vnode is
     74  * referenced, and locked.
     75  *
     76  * the pid, pfs_type, and mount point uniquely
     77  * identify a pfsnode.  the mount point is needed
     78  * because someone might mount this filesystem
     79  * twice.
     80  *
     81  * all pfsnodes are maintained on a singly-linked
     82  * list.  new nodes are only allocated when they cannot
     83  * be found on this list.  entries on the list are
     84  * removed when the vfs reclaim entry is called.
     85  *
     86  * a single lock is kept for the entire list.  this is
     87  * needed because the getnewvnode() function can block
     88  * waiting for a vnode to become free, in which case there
     89  * may be more than one process trying to get the same
     90  * vnode.  this lock is only taken if we are going to
     91  * call getnewvnode, since the kernel itself is single-threaded.
     92  *
     93  * if an entry is found on the list, then call vget() to
     94  * take a reference.  this is done because there may be
     95  * zero references to it and so it needs to removed from
     96  * the vnode free list.
     97  */
     98 int
     99 procfs_allocvp(mp, vpp, pid, pfs_type, fd)
    100 	struct mount *mp;
    101 	struct vnode **vpp;
    102 	pid_t pid;
    103 	pfstype pfs_type;
    104 	int fd;
    105 {
    106 	struct pfsnode *pfs;
    107 	struct vnode *vp;
    108 	int error;
    109 
    110 	do {
    111 		if ((*vpp = procfs_hashget(pid, pfs_type, fd, mp, curlwp)) != NULL)
    112 			return (0);
    113 	} while (lockmgr(&pfs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0));
    114 
    115 	if ((error = getnewvnode(VT_PROCFS, mp, procfs_vnodeop_p, &vp)) != 0) {
    116 		*vpp = NULL;
    117 		lockmgr(&pfs_hashlock, LK_RELEASE, NULL);
    118 		return (error);
    119 	}
    120 
    121 	MALLOC(pfs, void *, sizeof(struct pfsnode), M_TEMP, M_WAITOK);
    122 	vp->v_data = pfs;
    123 
    124 	pfs->pfs_pid = pid;
    125 	pfs->pfs_type = pfs_type;
    126 	pfs->pfs_vnode = vp;
    127 	pfs->pfs_flags = 0;
    128 	pfs->pfs_fileno = PROCFS_FILENO(pid, pfs_type, fd);
    129 	pfs->pfs_fd = fd;
    130 
    131 	switch (pfs_type) {
    132 	case Proot:	/* /proc = dr-xr-xr-x */
    133 		pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
    134 		vp->v_type = VDIR;
    135 		vp->v_flag = VROOT;
    136 		break;
    137 
    138 	case Pcurproc:	/* /proc/curproc = lr-xr-xr-x */
    139 	case Pself:	/* /proc/self    = lr-xr-xr-x */
    140 		pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
    141 		vp->v_type = VLNK;
    142 		break;
    143 
    144 	case Pproc:	/* /proc/N = dr-xr-xr-x */
    145 	case Pfd:
    146 		if (fd == -1) {	/* /proc/N/fd = dr-xr-xr-x */
    147 			pfs->pfs_mode = S_IRUSR|S_IXUSR;
    148 			vp->v_type = VDIR;
    149 		} else {	/* /proc/N/fd/M = [ps-]rw------- */
    150 			struct file *fp;
    151 			struct vnode *vxp;
    152 			struct proc *pown;
    153 
    154 			/* XXX can procfs_getfp() ever fail here? */
    155 			if ((error = procfs_getfp(pfs, &pown, &fp)) != 0)
    156 				goto bad;
    157 			FILE_USE(fp);
    158 
    159 			pfs->pfs_mode = S_IRUSR|S_IWUSR;
    160 			switch (fp->f_type) {
    161 			case DTYPE_VNODE:
    162 				vxp = (struct vnode *)fp->f_data;
    163 
    164 				/*
    165 				 * We make symlinks for directories
    166 				 * to avoid cycles.
    167 				 */
    168 				if (vxp->v_type == VDIR)
    169 					goto symlink;
    170 				vp->v_type = vxp->v_type;
    171 				break;
    172 			case DTYPE_PIPE:
    173 				vp->v_type = VFIFO;
    174 				break;
    175 			case DTYPE_SOCKET:
    176 				vp->v_type = VSOCK;
    177 				break;
    178 			case DTYPE_KQUEUE:
    179 			case DTYPE_MISC:
    180 			symlink:
    181 				pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|
    182 				    S_IXGRP|S_IROTH|S_IXOTH;
    183 				vp->v_type = VLNK;
    184 				break;
    185 			default:
    186 				error = EOPNOTSUPP;
    187 				FILE_UNUSE(fp, proc_representative_lwp(pown));
    188 				goto bad;
    189 			}
    190 			FILE_UNUSE(fp, proc_representative_lwp(pown));
    191 		}
    192 		break;
    193 
    194 	case Pfile:	/* /proc/N/file = -rw------- */
    195 	case Pmem:	/* /proc/N/mem = -rw------- */
    196 	case Pregs:	/* /proc/N/regs = -rw------- */
    197 	case Pfpregs:	/* /proc/N/fpregs = -rw------- */
    198 		pfs->pfs_mode = S_IRUSR|S_IWUSR;
    199 		vp->v_type = VREG;
    200 		break;
    201 
    202 	case Pctl:	/* /proc/N/ctl = --w------ */
    203 	case Pnote:	/* /proc/N/note = --w------ */
    204 	case Pnotepg:	/* /proc/N/notepg = --w------ */
    205 		pfs->pfs_mode = S_IWUSR;
    206 		vp->v_type = VREG;
    207 		break;
    208 
    209 	case Pmap:	/* /proc/N/map = -r--r--r-- */
    210 	case Pmaps:	/* /proc/N/maps = -r--r--r-- */
    211 	case Pstatus:	/* /proc/N/status = -r--r--r-- */
    212 	case Pstat:	/* /proc/N/stat = -r--r--r-- */
    213 	case Pcmdline:	/* /proc/N/cmdline = -r--r--r-- */
    214 	case Pmeminfo:	/* /proc/meminfo = -r--r--r-- */
    215 	case Pcpuinfo:	/* /proc/cpuinfo = -r--r--r-- */
    216 	case Puptime:	/* /proc/uptime = -r--r--r-- */
    217 		pfs->pfs_mode = S_IRUSR|S_IRGRP|S_IROTH;
    218 		vp->v_type = VREG;
    219 		break;
    220 
    221 #ifdef __HAVE_PROCFS_MACHDEP
    222 	PROCFS_MACHDEP_NODETYPE_CASES
    223 		procfs_machdep_allocvp(vp);
    224 		break;
    225 #endif
    226 
    227 	default:
    228 		panic("procfs_allocvp");
    229 	}
    230 
    231 	procfs_hashins(pfs);
    232 	uvm_vnp_setsize(vp, 0);
    233 	lockmgr(&pfs_hashlock, LK_RELEASE, NULL);
    234 
    235 	*vpp = vp;
    236 	return (0);
    237 
    238  bad:
    239 	lockmgr(&pfs_hashlock, LK_RELEASE, NULL);
    240 	FREE(pfs, M_TEMP);
    241 	ungetnewvnode(vp);
    242 	return (error);
    243 }
    244 
    245 int
    246 procfs_freevp(vp)
    247 	struct vnode *vp;
    248 {
    249 	struct pfsnode *pfs = VTOPFS(vp);
    250 
    251 	procfs_hashrem(pfs);
    252 
    253 	FREE(vp->v_data, M_TEMP);
    254 	vp->v_data = 0;
    255 	return (0);
    256 }
    257 
    258 int
    259 procfs_rw(v)
    260 	void *v;
    261 {
    262 	struct vop_read_args *ap = v;
    263 	struct vnode *vp = ap->a_vp;
    264 	struct uio *uio = ap->a_uio;
    265 	struct lwp *curl;
    266 	struct lwp *l;
    267 	struct pfsnode *pfs = VTOPFS(vp);
    268 	struct proc *p;
    269 
    270 	p = PFIND(pfs->pfs_pid);
    271 	if (p == 0)
    272 		return (EINVAL);
    273 
    274 	curl = uio->uio_lwp;
    275 
    276 	/* XXX NJWLWP
    277 	 * The entire procfs interface needs work to be useful to
    278 	 * a process with multiple LWPs. For the moment, we'll
    279 	 * just kluge this and fail on others.
    280 	 */
    281 	l = proc_representative_lwp(p);
    282 
    283 	switch (pfs->pfs_type) {
    284 	case Pregs:
    285 	case Pfpregs:
    286 	case Pmem:
    287 #if defined(__HAVE_PROCFS_MACHDEP) && defined(PROCFS_MACHDEP_PROTECT_CASES)
    288 	PROCFS_MACHDEP_PROTECT_CASES
    289 #endif
    290 		/*
    291 		 * Do not allow init to be modified while in secure mode; it
    292 		 * could be duped into changing the security level.
    293 		 */
    294 		if (uio->uio_rw == UIO_WRITE &&
    295 		    p == initproc && securelevel > -1)
    296 			return (EPERM);
    297 		break;
    298 
    299 	default:
    300 		break;
    301 	}
    302 
    303 	switch (pfs->pfs_type) {
    304 	case Pnote:
    305 	case Pnotepg:
    306 		return (procfs_donote(curl, p, pfs, uio));
    307 
    308 	case Pregs:
    309 		return (procfs_doregs(curl, l, pfs, uio));
    310 
    311 	case Pfpregs:
    312 		return (procfs_dofpregs(curl, l, pfs, uio));
    313 
    314 	case Pctl:
    315 		return (procfs_doctl(curl, l, pfs, uio));
    316 
    317 	case Pstatus:
    318 		return (procfs_dostatus(curl, l, pfs, uio));
    319 
    320 	case Pstat:
    321 		return (procfs_do_pid_stat(curl, l, pfs, uio));
    322 
    323 	case Pmap:
    324 		return (procfs_domap(curl, p, pfs, uio, 0));
    325 
    326 	case Pmaps:
    327 		return (procfs_domap(curl, p, pfs, uio, 1));
    328 
    329 	case Pmem:
    330 		return (procfs_domem(curl, l, pfs, uio));
    331 
    332 	case Pcmdline:
    333 		return (procfs_docmdline(curl, p, pfs, uio));
    334 
    335 	case Pmeminfo:
    336 		return (procfs_domeminfo(curl, p, pfs, uio));
    337 
    338 	case Pcpuinfo:
    339 		return (procfs_docpuinfo(curl, p, pfs, uio));
    340 
    341 	case Pfd:
    342 		return (procfs_dofd(curl, p, pfs, uio));
    343 
    344 	case Puptime:
    345 		return (procfs_douptime(curl, p, pfs, uio));
    346 
    347 #ifdef __HAVE_PROCFS_MACHDEP
    348 	PROCFS_MACHDEP_NODETYPE_CASES
    349 		return (procfs_machdep_rw(curl, l, pfs, uio));
    350 #endif
    351 
    352 	default:
    353 		return (EOPNOTSUPP);
    354 	}
    355 }
    356 
    357 /*
    358  * Get a string from userland into (buf).  Strip a trailing
    359  * nl character (to allow easy access from the shell).
    360  * The buffer should be *buflenp + 1 chars long.  vfs_getuserstr
    361  * will automatically add a nul char at the end.
    362  *
    363  * Returns 0 on success or the following errors
    364  *
    365  * EINVAL:    file offset is non-zero.
    366  * EMSGSIZE:  message is longer than kernel buffer
    367  * EFAULT:    user i/o buffer is not addressable
    368  */
    369 int
    370 vfs_getuserstr(uio, buf, buflenp)
    371 	struct uio *uio;
    372 	char *buf;
    373 	int *buflenp;
    374 {
    375 	int xlen;
    376 	int error;
    377 
    378 	if (uio->uio_offset != 0)
    379 		return (EINVAL);
    380 
    381 	xlen = *buflenp;
    382 
    383 	/* must be able to read the whole string in one go */
    384 	if (xlen < uio->uio_resid)
    385 		return (EMSGSIZE);
    386 	xlen = uio->uio_resid;
    387 
    388 	if ((error = uiomove(buf, xlen, uio)) != 0)
    389 		return (error);
    390 
    391 	/* allow multiple writes without seeks */
    392 	uio->uio_offset = 0;
    393 
    394 	/* cleanup string and remove trailing newline */
    395 	buf[xlen] = '\0';
    396 	xlen = strlen(buf);
    397 	if (xlen > 0 && buf[xlen-1] == '\n')
    398 		buf[--xlen] = '\0';
    399 	*buflenp = xlen;
    400 
    401 	return (0);
    402 }
    403 
    404 const vfs_namemap_t *
    405 vfs_findname(nm, buf, buflen)
    406 	const vfs_namemap_t *nm;
    407 	const char *buf;
    408 	int buflen;
    409 {
    410 
    411 	for (; nm->nm_name; nm++)
    412 		if (memcmp(buf, nm->nm_name, buflen+1) == 0)
    413 			return (nm);
    414 
    415 	return (0);
    416 }
    417 
    418 /*
    419  * Initialize pfsnode hash table.
    420  */
    421 void
    422 procfs_hashinit()
    423 {
    424 	lockinit(&pfs_hashlock, PINOD, "pfs_hashlock", 0, 0);
    425 	pfs_hashtbl = hashinit(desiredvnodes / 4, HASH_LIST, M_UFSMNT,
    426 	    M_WAITOK, &pfs_ihash);
    427 	simple_lock_init(&pfs_hash_slock);
    428 }
    429 
    430 void
    431 procfs_hashreinit()
    432 {
    433 	struct pfsnode *pp;
    434 	struct pfs_hashhead *oldhash, *hash;
    435 	u_long i, oldmask, mask, val;
    436 
    437 	hash = hashinit(desiredvnodes / 4, HASH_LIST, M_UFSMNT, M_WAITOK,
    438 	    &mask);
    439 
    440 	simple_lock(&pfs_hash_slock);
    441 	oldhash = pfs_hashtbl;
    442 	oldmask = pfs_ihash;
    443 	pfs_hashtbl = hash;
    444 	pfs_ihash = mask;
    445 	for (i = 0; i <= oldmask; i++) {
    446 		while ((pp = LIST_FIRST(&oldhash[i])) != NULL) {
    447 			LIST_REMOVE(pp, pfs_hash);
    448 			val = PFSPIDHASH(pp->pfs_pid);
    449 			LIST_INSERT_HEAD(&hash[val], pp, pfs_hash);
    450 		}
    451 	}
    452 	simple_unlock(&pfs_hash_slock);
    453 	hashdone(oldhash, M_UFSMNT);
    454 }
    455 
    456 /*
    457  * Free pfsnode hash table.
    458  */
    459 void
    460 procfs_hashdone()
    461 {
    462 	hashdone(pfs_hashtbl, M_UFSMNT);
    463 }
    464 
    465 struct vnode *
    466 procfs_hashget(pid, type, fd, mp, l)
    467 	pid_t pid;
    468 	pfstype type;
    469 	int fd;
    470 	struct mount *mp;
    471 	struct lwp *l;
    472 {
    473 	struct pfs_hashhead *ppp;
    474 	struct pfsnode *pp;
    475 	struct vnode *vp;
    476 
    477 loop:
    478 	simple_lock(&pfs_hash_slock);
    479 	ppp = &pfs_hashtbl[PFSPIDHASH(pid)];
    480 	LIST_FOREACH(pp, ppp, pfs_hash) {
    481 		vp = PFSTOV(pp);
    482 		if (pid == pp->pfs_pid && pp->pfs_type == type &&
    483 		    pp->pfs_fd == fd && vp->v_mount == mp) {
    484 			simple_lock(&vp->v_interlock);
    485 			simple_unlock(&pfs_hash_slock);
    486 			if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
    487 				goto loop;
    488 			return (vp);
    489 		}
    490 	}
    491 	simple_unlock(&pfs_hash_slock);
    492 	return (NULL);
    493 }
    494 
    495 /*
    496  * Insert the pfsnode into the hash table and lock it.
    497  */
    498 void
    499 procfs_hashins(pp)
    500 	struct pfsnode *pp;
    501 {
    502 	struct pfs_hashhead *ppp;
    503 
    504 	/* lock the pfsnode, then put it on the appropriate hash list */
    505 	lockmgr(&pp->pfs_vnode->v_lock, LK_EXCLUSIVE, (struct simplelock *)0);
    506 
    507 	simple_lock(&pfs_hash_slock);
    508 	ppp = &pfs_hashtbl[PFSPIDHASH(pp->pfs_pid)];
    509 	LIST_INSERT_HEAD(ppp, pp, pfs_hash);
    510 	simple_unlock(&pfs_hash_slock);
    511 }
    512 
    513 /*
    514  * Remove the pfsnode from the hash table.
    515  */
    516 void
    517 procfs_hashrem(pp)
    518 	struct pfsnode *pp;
    519 {
    520 	simple_lock(&pfs_hash_slock);
    521 	LIST_REMOVE(pp, pfs_hash);
    522 	simple_unlock(&pfs_hash_slock);
    523 }
    524 
    525 void
    526 procfs_revoke_vnodes(l, arg)
    527 	struct lwp *l;
    528 	void *arg;
    529 {
    530 	struct pfsnode *pfs, *pnext;
    531 	struct vnode *vp;
    532 	struct mount *mp = (struct mount *)arg;
    533 	struct pfs_hashhead *ppp;
    534 	struct proc *p;
    535 
    536 	p = l->l_proc;
    537 	if (!(p->p_flag & P_SUGID))
    538 		return;
    539 
    540 	ppp = &pfs_hashtbl[PFSPIDHASH(p->p_pid)];
    541 	for (pfs = LIST_FIRST(ppp); pfs; pfs = pnext) {
    542 		vp = PFSTOV(pfs);
    543 		pnext = LIST_NEXT(pfs, pfs_hash);
    544 		if (vp->v_usecount > 0 && pfs->pfs_pid == p->p_pid &&
    545 		    vp->v_mount == mp)
    546 			VOP_REVOKE(vp, REVOKEALL);
    547 	}
    548 }
    549 
    550 int
    551 procfs_getfp(pfs, pown, fp)
    552 	struct pfsnode *pfs;
    553 	struct proc **pown;
    554 	struct file **fp;
    555 {
    556 	struct proc *p = PFIND(pfs->pfs_pid);
    557 
    558 	if (p == NULL)
    559 		return ESRCH;
    560 
    561 	if (pfs->pfs_fd == -1)
    562 		return EINVAL;
    563 
    564 	if ((*fp = fd_getfile(p->p_fd, pfs->pfs_fd)) == NULL)
    565 		return EBADF;
    566 
    567 	*pown = p;
    568 	return 0;
    569 }
    570