Home | History | Annotate | Line # | Download | only in procfs
procfs_subr.c revision 1.51
      1 /*	$NetBSD: procfs_subr.c,v 1.51 2003/04/18 21:55:35 christos 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.51 2003/04/18 21:55:35 christos 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 *));
     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)) != 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 =
    148 			    S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
    149 			vp->v_type = VDIR;
    150 		} else {	/* /proc/N/fd/M = [ps-]rw------- */
    151 			struct file *fp;
    152 			struct vnode *vxp;
    153 			struct proc *pown;
    154 
    155 			/* XXX can procfs_getfp() ever fail here? */
    156 			if ((error = procfs_getfp(pfs, &pown, &fp)) != 0)
    157 				goto bad;
    158 			FILE_USE(fp);
    159 
    160 			pfs->pfs_mode = S_IRUSR|S_IWUSR;
    161 			switch (fp->f_type) {
    162 			case DTYPE_VNODE:
    163 				vxp = (struct vnode *)fp->f_data;
    164 
    165 				/*
    166 				 * We make symlinks for directories
    167 				 * to avoid cycles.
    168 				 */
    169 				if (vxp->v_type == VDIR)
    170 					goto symlink;
    171 				vp->v_type = vxp->v_type;
    172 				break;
    173 			case DTYPE_PIPE:
    174 				vp->v_type = VFIFO;
    175 				break;
    176 			case DTYPE_SOCKET:
    177 				vp->v_type = VSOCK;
    178 				break;
    179 			case DTYPE_KQUEUE:
    180 			case DTYPE_MISC:
    181 			symlink:
    182 				pfs->pfs_mode = S_IRUSR|S_IXUSR|S_IRGRP|
    183 				    S_IXGRP|S_IROTH|S_IXOTH;
    184 				vp->v_type = VLNK;
    185 				break;
    186 			default:
    187 				error = EOPNOTSUPP;
    188 				FILE_UNUSE(fp, pown);
    189 				goto bad;
    190 			}
    191 			FILE_UNUSE(fp, pown);
    192 		}
    193 		break;
    194 
    195 	case Pfile:	/* /proc/N/file = -rw------- */
    196 	case Pmem:	/* /proc/N/mem = -rw------- */
    197 	case Pregs:	/* /proc/N/regs = -rw------- */
    198 	case Pfpregs:	/* /proc/N/fpregs = -rw------- */
    199 		pfs->pfs_mode = S_IRUSR|S_IWUSR;
    200 		vp->v_type = VREG;
    201 		break;
    202 
    203 	case Pctl:	/* /proc/N/ctl = --w------ */
    204 	case Pnote:	/* /proc/N/note = --w------ */
    205 	case Pnotepg:	/* /proc/N/notepg = --w------ */
    206 		pfs->pfs_mode = S_IWUSR;
    207 		vp->v_type = VREG;
    208 		break;
    209 
    210 	case Pmap:	/* /proc/N/map = -r--r--r-- */
    211 	case Pmaps:	/* /proc/N/maps = -r--r--r-- */
    212 	case Pstatus:	/* /proc/N/status = -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 proc *curp = uio->uio_procp;
    266 	struct pfsnode *pfs = VTOPFS(vp);
    267 	struct lwp *l;
    268 	struct proc *p;
    269 
    270 	p = PFIND(pfs->pfs_pid);
    271 	if (p == 0)
    272 		return (EINVAL);
    273 
    274 	/* XXX NJWLWP
    275 	 * The entire procfs interface needs work to be useful to
    276 	 * a process with multiple LWPs. For the moment, we'll
    277 	 * just kluge this and fail on others.
    278 	 */
    279 	l = proc_representative_lwp(p);
    280 
    281 	switch (pfs->pfs_type) {
    282 	case Pregs:
    283 	case Pfpregs:
    284 	case Pmem:
    285 #if defined(__HAVE_PROCFS_MACHDEP) && defined(PROCFS_MACHDEP_PROTECT_CASES)
    286 	PROCFS_MACHDEP_PROTECT_CASES
    287 #endif
    288 		/*
    289 		 * Do not allow init to be modified while in secure mode; it
    290 		 * could be duped into changing the security level.
    291 		 */
    292 		if (uio->uio_rw == UIO_WRITE &&
    293 		    p == initproc && securelevel > -1)
    294 			return (EPERM);
    295 		break;
    296 
    297 	default:
    298 		break;
    299 	}
    300 
    301 	switch (pfs->pfs_type) {
    302 	case Pnote:
    303 	case Pnotepg:
    304 		return (procfs_donote(curp, p, pfs, uio));
    305 
    306 	case Pregs:
    307 		return (procfs_doregs(curp, l, pfs, uio));
    308 
    309 	case Pfpregs:
    310 		return (procfs_dofpregs(curp, l, pfs, uio));
    311 
    312 	case Pctl:
    313 		return (procfs_doctl(curp, l, pfs, uio));
    314 
    315 	case Pstatus:
    316 		return (procfs_dostatus(curp, l, pfs, uio));
    317 
    318 	case Pmap:
    319 		return (procfs_domap(curp, p, pfs, uio, 0));
    320 
    321 	case Pmaps:
    322 		return (procfs_domap(curp, p, pfs, uio, 1));
    323 
    324 	case Pmem:
    325 		return (procfs_domem(curp, p, pfs, uio));
    326 
    327 	case Pcmdline:
    328 		return (procfs_docmdline(curp, p, pfs, uio));
    329 
    330 	case Pmeminfo:
    331 		return (procfs_domeminfo(curp, p, pfs, uio));
    332 
    333 	case Pcpuinfo:
    334 		return (procfs_docpuinfo(curp, p, pfs, uio));
    335 
    336 	case Pfd:
    337 		return (procfs_dofd(curp, p, pfs, uio));
    338 
    339 	case Puptime:
    340 		return (procfs_douptime(curp, p, pfs, uio));
    341 
    342 #ifdef __HAVE_PROCFS_MACHDEP
    343 	PROCFS_MACHDEP_NODETYPE_CASES
    344 		return (procfs_machdep_rw(curp, l, pfs, uio));
    345 #endif
    346 
    347 	default:
    348 		return (EOPNOTSUPP);
    349 	}
    350 }
    351 
    352 /*
    353  * Get a string from userland into (buf).  Strip a trailing
    354  * nl character (to allow easy access from the shell).
    355  * The buffer should be *buflenp + 1 chars long.  vfs_getuserstr
    356  * will automatically add a nul char at the end.
    357  *
    358  * Returns 0 on success or the following errors
    359  *
    360  * EINVAL:    file offset is non-zero.
    361  * EMSGSIZE:  message is longer than kernel buffer
    362  * EFAULT:    user i/o buffer is not addressable
    363  */
    364 int
    365 vfs_getuserstr(uio, buf, buflenp)
    366 	struct uio *uio;
    367 	char *buf;
    368 	int *buflenp;
    369 {
    370 	int xlen;
    371 	int error;
    372 
    373 	if (uio->uio_offset != 0)
    374 		return (EINVAL);
    375 
    376 	xlen = *buflenp;
    377 
    378 	/* must be able to read the whole string in one go */
    379 	if (xlen < uio->uio_resid)
    380 		return (EMSGSIZE);
    381 	xlen = uio->uio_resid;
    382 
    383 	if ((error = uiomove(buf, xlen, uio)) != 0)
    384 		return (error);
    385 
    386 	/* allow multiple writes without seeks */
    387 	uio->uio_offset = 0;
    388 
    389 	/* cleanup string and remove trailing newline */
    390 	buf[xlen] = '\0';
    391 	xlen = strlen(buf);
    392 	if (xlen > 0 && buf[xlen-1] == '\n')
    393 		buf[--xlen] = '\0';
    394 	*buflenp = xlen;
    395 
    396 	return (0);
    397 }
    398 
    399 const vfs_namemap_t *
    400 vfs_findname(nm, buf, buflen)
    401 	const vfs_namemap_t *nm;
    402 	const char *buf;
    403 	int buflen;
    404 {
    405 
    406 	for (; nm->nm_name; nm++)
    407 		if (memcmp(buf, nm->nm_name, buflen+1) == 0)
    408 			return (nm);
    409 
    410 	return (0);
    411 }
    412 
    413 /*
    414  * Initialize pfsnode hash table.
    415  */
    416 void
    417 procfs_hashinit()
    418 {
    419 	lockinit(&pfs_hashlock, PINOD, "pfs_hashlock", 0, 0);
    420 	pfs_hashtbl = hashinit(desiredvnodes / 4, HASH_LIST, M_UFSMNT,
    421 	    M_WAITOK, &pfs_ihash);
    422 	simple_lock_init(&pfs_hash_slock);
    423 }
    424 
    425 void
    426 procfs_hashreinit()
    427 {
    428 	struct pfsnode *pp;
    429 	struct pfs_hashhead *oldhash, *hash;
    430 	u_long i, oldmask, mask, val;
    431 
    432 	hash = hashinit(desiredvnodes / 4, HASH_LIST, M_UFSMNT, M_WAITOK,
    433 	    &mask);
    434 
    435 	simple_lock(&pfs_hash_slock);
    436 	oldhash = pfs_hashtbl;
    437 	oldmask = pfs_ihash;
    438 	pfs_hashtbl = hash;
    439 	pfs_ihash = mask;
    440 	for (i = 0; i <= oldmask; i++) {
    441 		while ((pp = LIST_FIRST(&oldhash[i])) != NULL) {
    442 			LIST_REMOVE(pp, pfs_hash);
    443 			val = PFSPIDHASH(pp->pfs_pid);
    444 			LIST_INSERT_HEAD(&hash[val], pp, pfs_hash);
    445 		}
    446 	}
    447 	simple_unlock(&pfs_hash_slock);
    448 	hashdone(oldhash, M_UFSMNT);
    449 }
    450 
    451 /*
    452  * Free pfsnode hash table.
    453  */
    454 void
    455 procfs_hashdone()
    456 {
    457 	hashdone(pfs_hashtbl, M_UFSMNT);
    458 }
    459 
    460 struct vnode *
    461 procfs_hashget(pid, type, fd, mp)
    462 	pid_t pid;
    463 	pfstype type;
    464 	int fd;
    465 	struct mount *mp;
    466 {
    467 	struct pfs_hashhead *ppp;
    468 	struct pfsnode *pp;
    469 	struct vnode *vp;
    470 
    471 loop:
    472 	simple_lock(&pfs_hash_slock);
    473 	ppp = &pfs_hashtbl[PFSPIDHASH(pid)];
    474 	LIST_FOREACH(pp, ppp, pfs_hash) {
    475 		vp = PFSTOV(pp);
    476 		if (pid == pp->pfs_pid && pp->pfs_type == type &&
    477 		    pp->pfs_fd == fd && vp->v_mount == mp) {
    478 			simple_lock(&vp->v_interlock);
    479 			simple_unlock(&pfs_hash_slock);
    480 			if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
    481 				goto loop;
    482 			return (vp);
    483 		}
    484 	}
    485 	simple_unlock(&pfs_hash_slock);
    486 	return (NULL);
    487 }
    488 
    489 /*
    490  * Insert the pfsnode into the hash table and lock it.
    491  */
    492 void
    493 procfs_hashins(pp)
    494 	struct pfsnode *pp;
    495 {
    496 	struct pfs_hashhead *ppp;
    497 
    498 	/* lock the pfsnode, then put it on the appropriate hash list */
    499 	lockmgr(&pp->pfs_vnode->v_lock, LK_EXCLUSIVE, (struct simplelock *)0);
    500 
    501 	simple_lock(&pfs_hash_slock);
    502 	ppp = &pfs_hashtbl[PFSPIDHASH(pp->pfs_pid)];
    503 	LIST_INSERT_HEAD(ppp, pp, pfs_hash);
    504 	simple_unlock(&pfs_hash_slock);
    505 }
    506 
    507 /*
    508  * Remove the pfsnode from the hash table.
    509  */
    510 void
    511 procfs_hashrem(pp)
    512 	struct pfsnode *pp;
    513 {
    514 	simple_lock(&pfs_hash_slock);
    515 	LIST_REMOVE(pp, pfs_hash);
    516 	simple_unlock(&pfs_hash_slock);
    517 }
    518 
    519 void
    520 procfs_revoke_vnodes(p, arg)
    521 	struct proc *p;
    522 	void *arg;
    523 {
    524 	struct pfsnode *pfs, *pnext;
    525 	struct vnode *vp;
    526 	struct mount *mp = (struct mount *)arg;
    527 	struct pfs_hashhead *ppp;
    528 
    529 	if (!(p->p_flag & P_SUGID))
    530 		return;
    531 
    532 	ppp = &pfs_hashtbl[PFSPIDHASH(p->p_pid)];
    533 	for (pfs = LIST_FIRST(ppp); pfs; pfs = pnext) {
    534 		vp = PFSTOV(pfs);
    535 		pnext = LIST_NEXT(pfs, pfs_hash);
    536 		if (vp->v_usecount > 0 && pfs->pfs_pid == p->p_pid &&
    537 		    vp->v_mount == mp)
    538 			VOP_REVOKE(vp, REVOKEALL);
    539 	}
    540 }
    541 
    542 int
    543 procfs_getfp(pfs, pown, fp)
    544 	struct pfsnode *pfs;
    545 	struct proc **pown;
    546 	struct file **fp;
    547 {
    548 	struct proc *p = PFIND(pfs->pfs_pid);
    549 
    550 	if (p == NULL)
    551 		return ESRCH;
    552 
    553 	if (pfs->pfs_fd == -1)
    554 		return EINVAL;
    555 
    556 	if ((*fp = fd_getfile(p->p_fd, pfs->pfs_fd)) == NULL)
    557 		return EBADF;
    558 
    559 	*pown = p;
    560 	return 0;
    561 }
    562