xref: /dragonfly/sys/vfs/procfs/procfs_subr.c (revision 25a2db75)
1 /*
2  * Copyright (c) 1993 Jan-Simon Pendry
3  * Copyright (c) 1993
4  *	The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * Jan-Simon Pendry.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *	This product includes software developed by the University of
20  *	California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *	@(#)procfs_subr.c	8.6 (Berkeley) 5/14/95
38  *
39  * $FreeBSD: src/sys/miscfs/procfs/procfs_subr.c,v 1.26.2.3 2002/02/18 21:28:04 des Exp $
40  */
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/sysctl.h>
45 #include <sys/proc.h>
46 #include <sys/mount.h>
47 #include <sys/vnode.h>
48 #include <sys/malloc.h>
49 #include <sys/thread2.h>
50 
51 #include <vfs/procfs/procfs.h>
52 
53 #define PFS_HSIZE	256
54 #define PFS_HMASK	(PFS_HSIZE - 1)
55 
56 static struct pfsnode *pfshead[PFS_HSIZE];
57 static int pfsvplock;
58 
59 #define PFSHASH(pid)	&pfshead[(pid) & PFS_HMASK]
60 
61 /*
62  * Allocate a pfsnode/vnode pair.  If no error occurs the returned vnode
63  * will be referenced and exclusively locked.
64  *
65  * The pid, pfs_type, and mount point uniquely identify a pfsnode.
66  * The mount point is needed because someone might mount this filesystem
67  * twice.
68  *
69  * All pfsnodes are maintained on a singly-linked list.  new nodes are
70  * only allocated when they cannot be found on this list.  entries on
71  * the list are removed when the vfs reclaim entry is called.
72  *
73  * A single lock is kept for the entire list.  this is needed because the
74  * getnewvnode() function can block waiting for a vnode to become free,
75  * in which case there may be more than one process trying to get the same
76  * vnode.  this lock is only taken if we are going to call getnewvnode,
77  * since the kernel itself is single-threaded.
78  *
79  * If an entry is found on the list, then call vget() to take a reference
80  * and obtain the lock.  This will properly re-reference the vnode if it
81  * had gotten onto the free list.
82  */
83 int
84 procfs_allocvp(struct mount *mp, struct vnode **vpp, long pid, pfstype pfs_type)
85 {
86 	struct pfsnode *pfs;
87 	struct vnode *vp;
88 	struct pfsnode **pp;
89 	int error;
90 
91 	pp = PFSHASH(pid);
92 loop:
93 	for (pfs = *pp; pfs; pfs = pfs->pfs_next) {
94 		if (pfs->pfs_pid == pid && pfs->pfs_type == pfs_type &&
95 		    PFSTOV(pfs)->v_mount == mp) {
96 			vp = PFSTOV(pfs);
97 			vhold_interlocked(vp);
98 			if (vget(vp, LK_EXCLUSIVE)) {
99 				vdrop(vp);
100 				goto loop;
101 			}
102 
103 			/*
104 			 * Make sure the vnode is still in the cache after
105 			 * getting the interlock to avoid racing a free.
106 			 */
107 			for (pfs = *pp; pfs; pfs = pfs->pfs_next) {
108 				if (PFSTOV(pfs) == vp &&
109 				    pfs->pfs_pid == pid &&
110 				    pfs->pfs_type == pfs_type &&
111 				    PFSTOV(pfs)->v_mount == mp) {
112 					break;
113 				}
114 			}
115 			vdrop(vp);
116 			if (pfs == NULL || PFSTOV(pfs) != vp) {
117 				vput(vp);
118 				goto loop;
119 
120 			}
121 			KKASSERT(vp->v_data == pfs);
122 			*vpp = vp;
123 			return (0);
124 		}
125 	}
126 
127 	/*
128 	 * otherwise lock the vp list while we call getnewvnode
129 	 * since that can block.
130 	 */
131 	if (pfsvplock & PROCFS_LOCKED) {
132 		pfsvplock |= PROCFS_WANT;
133 		(void) tsleep((caddr_t) &pfsvplock, 0, "pfsavp", 0);
134 		goto loop;
135 	}
136 	pfsvplock |= PROCFS_LOCKED;
137 
138 	/*
139 	 * Do the MALLOC before the getnewvnode since doing so afterward
140 	 * might cause a bogus v_data pointer to get dereferenced
141 	 * elsewhere if MALLOC should block.
142 	 *
143 	 * XXX this may not matter anymore since getnewvnode now returns
144 	 * a VX locked vnode.
145 	 */
146 	pfs = kmalloc(sizeof(struct pfsnode), M_TEMP, M_WAITOK);
147 
148 	error = getnewvnode(VT_PROCFS, mp, vpp, 0, 0);
149 	if (error) {
150 		kfree(pfs, M_TEMP);
151 		goto out;
152 	}
153 	vp = *vpp;
154 
155 	vp->v_data = pfs;
156 
157 	pfs->pfs_next = 0;
158 	pfs->pfs_pid = (pid_t) pid;
159 	pfs->pfs_type = pfs_type;
160 	pfs->pfs_vnode = vp;
161 	pfs->pfs_flags = 0;
162 	pfs->pfs_lockowner = 0;
163 	pfs->pfs_fileno = PROCFS_FILENO(pid, pfs_type);
164 
165 	switch (pfs_type) {
166 	case Proot:	/* /proc = dr-xr-xr-x */
167 		pfs->pfs_mode = (VREAD|VEXEC) |
168 				(VREAD|VEXEC) >> 3 |
169 				(VREAD|VEXEC) >> 6;
170 		vp->v_type = VDIR;
171 		vp->v_flag = VROOT;
172 		break;
173 
174 	case Pcurproc:	/* /proc/curproc = lr--r--r-- */
175 		pfs->pfs_mode = (VREAD) |
176 				(VREAD >> 3) |
177 				(VREAD >> 6);
178 		vp->v_type = VLNK;
179 		break;
180 
181 	case Pproc:
182 		pfs->pfs_mode = (VREAD|VEXEC) |
183 				(VREAD|VEXEC) >> 3 |
184 				(VREAD|VEXEC) >> 6;
185 		vp->v_type = VDIR;
186 		break;
187 
188 	case Pfile:
189 		pfs->pfs_mode = (VREAD|VEXEC) |
190 				(VREAD|VEXEC) >> 3 |
191 				(VREAD|VEXEC) >> 6;
192 		vp->v_type = VLNK;
193 		break;
194 
195 	case Pmem:
196 		pfs->pfs_mode = (VREAD|VWRITE);
197 		vp->v_type = VREG;
198 		break;
199 
200 	case Pregs:
201 	case Pfpregs:
202 	case Pdbregs:
203 		pfs->pfs_mode = (VREAD|VWRITE);
204 		vp->v_type = VREG;
205 		break;
206 
207 	case Pctl:
208 	case Pnote:
209 	case Pnotepg:
210 		pfs->pfs_mode = (VWRITE);
211 		vp->v_type = VREG;
212 		break;
213 
214 	case Ptype:
215 	case Pmap:
216 	case Pstatus:
217 	case Pcmdline:
218 	case Prlimit:
219 		pfs->pfs_mode = (VREAD) |
220 				(VREAD >> 3) |
221 				(VREAD >> 6);
222 		vp->v_type = VREG;
223 		break;
224 
225 	default:
226 		panic("procfs_allocvp");
227 	}
228 
229 	/* add to procfs vnode list */
230 	pfs->pfs_next = *pp;
231 	*pp = pfs;
232 
233 out:
234 	pfsvplock &= ~PROCFS_LOCKED;
235 
236 	if (pfsvplock & PROCFS_WANT) {
237 		pfsvplock &= ~PROCFS_WANT;
238 		wakeup((caddr_t) &pfsvplock);
239 	}
240 
241 	return (error);
242 }
243 
244 int
245 procfs_freevp(struct vnode *vp)
246 {
247 	struct pfsnode **pfspp;
248 	struct pfsnode *pfs;
249 
250 	pfs = VTOPFS(vp);
251 	vp->v_data = NULL;
252 
253 	pfspp = PFSHASH(pfs->pfs_pid);
254 	while (*pfspp != pfs && *pfspp)
255 		pfspp = &(*pfspp)->pfs_next;
256 	KKASSERT(*pfspp);
257 	*pfspp = pfs->pfs_next;
258 	pfs->pfs_next = NULL;
259 	pfs->pfs_vnode = NULL;
260 	kfree(pfs, M_TEMP);
261 	return (0);
262 }
263 
264 /*
265  * Try to find the calling pid. Note that pfind()
266  * now references the proc structure to be returned
267  * and needs to be released later with PRELE().
268  */
269 struct proc *
270 pfs_pfind(pid_t pfs_pid)
271 {
272 	struct proc *p = NULL;
273 
274 	if (pfs_pid == 0) {
275 		p = &proc0;
276 		PHOLD(p);
277 	} else {
278 		p = pfind(pfs_pid);
279 	}
280 
281 	/*
282 	 * Make sure the process is not in the middle of exiting (where
283 	 * a lot of its structural members may wind up being NULL).  If it
284 	 * is we give up on it.
285 	 */
286 	if (p) {
287 		lwkt_gettoken(&p->p_token);
288 		if (p->p_flags & P_POSTEXIT) {
289 			lwkt_reltoken(&p->p_token);
290 			PRELE(p);
291 			p = NULL;
292 		}
293 	}
294 	return p;
295 }
296 
297 struct proc *
298 pfs_zpfind(pid_t pfs_pid)
299 {
300 	struct proc *p = NULL;
301 
302 	if (pfs_pid == 0) {
303 		p = &proc0;
304 		PHOLD(p);
305 	} else {
306 		p = zpfind(pfs_pid);
307 	}
308 
309 	/*
310 	 * Make sure the process is not in the middle of exiting (where
311 	 * a lot of its structural members may wind up being NULL).  If it
312 	 * is we give up on it.
313 	 */
314 	if (p) {
315 		lwkt_gettoken(&p->p_token);
316 		if (p->p_flags & P_POSTEXIT) {
317 			lwkt_reltoken(&p->p_token);
318 			PRELE(p);
319 			p = NULL;
320 		}
321 	}
322 	return p;
323 }
324 
325 void
326 pfs_pdone(struct proc *p)
327 {
328 	if (p) {
329 		lwkt_reltoken(&p->p_token);
330 		PRELE(p);
331 	}
332 }
333 
334 int
335 procfs_rw(struct vop_read_args *ap)
336 {
337 	struct vnode *vp = ap->a_vp;
338 	struct uio *uio = ap->a_uio;
339 	struct thread *curtd = uio->uio_td;
340 	struct proc *curp;
341 	struct pfsnode *pfs = VTOPFS(vp);
342 	struct proc *p;
343 	struct lwp *lp;
344 	int rtval;
345 
346 	if (curtd == NULL)
347 		return (EINVAL);
348 	if ((curp = curtd->td_proc) == NULL)	/* XXX */
349 		return (EINVAL);
350 
351 	lwkt_gettoken(&proc_token);
352 	p = pfs_pfind(pfs->pfs_pid);
353 	if (p == NULL) {
354 		rtval = EINVAL;
355 		goto out;
356 	}
357 	if (p->p_pid == 1 && securelevel > 0 && uio->uio_rw == UIO_WRITE) {
358 		rtval = EACCES;
359 		goto out;
360 	}
361 	/* XXX lwp */
362 	lp = FIRST_LWP_IN_PROC(p);
363 	LWPHOLD(lp);
364 
365 	while (pfs->pfs_lockowner) {
366 		tsleep(&pfs->pfs_lockowner, 0, "pfslck", 0);
367 	}
368 	pfs->pfs_lockowner = curproc->p_pid;
369 
370 	switch (pfs->pfs_type) {
371 	case Pnote:
372 	case Pnotepg:
373 		rtval = procfs_donote(curp, lp, pfs, uio);
374 		break;
375 
376 	case Pregs:
377 		rtval = procfs_doregs(curp, lp, pfs, uio);
378 		break;
379 
380 	case Pfpregs:
381 		rtval = procfs_dofpregs(curp, lp, pfs, uio);
382 		break;
383 
384         case Pdbregs:
385                 rtval = procfs_dodbregs(curp, lp, pfs, uio);
386                 break;
387 
388 	case Pctl:
389 		rtval = procfs_doctl(curp, lp, pfs, uio);
390 		break;
391 
392 	case Pstatus:
393 		rtval = procfs_dostatus(curp, lp, pfs, uio);
394 		break;
395 
396 	case Pmap:
397 		rtval = procfs_domap(curp, lp, pfs, uio);
398 		break;
399 
400 	case Pmem:
401 		rtval = procfs_domem(curp, lp, pfs, uio);
402 		break;
403 
404 	case Ptype:
405 		rtval = procfs_dotype(curp, lp, pfs, uio);
406 		break;
407 
408 	case Pcmdline:
409 		rtval = procfs_docmdline(curp, lp, pfs, uio);
410 		break;
411 
412 	case Prlimit:
413 		rtval = procfs_dorlimit(curp, lp, pfs, uio);
414 		break;
415 
416 	default:
417 		rtval = EOPNOTSUPP;
418 		break;
419 	}
420 	LWPRELE(lp);
421 
422 	pfs->pfs_lockowner = 0;
423 	wakeup(&pfs->pfs_lockowner);
424 
425 out:
426 	pfs_pdone(p);
427 	lwkt_reltoken(&proc_token);
428 
429 	return rtval;
430 }
431 
432 /*
433  * Get a string from userland into (buf).  Strip a trailing
434  * nl character (to allow easy access from the shell).
435  * The buffer should be *buflenp + 1 chars long.  vfs_getuserstr
436  * will automatically add a nul char at the end.
437  *
438  * Returns 0 on success or the following errors
439  *
440  * EINVAL:    file offset is non-zero.
441  * EMSGSIZE:  message is longer than kernel buffer
442  * EFAULT:    user i/o buffer is not addressable
443  */
444 int
445 vfs_getuserstr(struct uio *uio, char *buf, int *buflenp)
446 {
447 	int xlen;
448 	int error;
449 
450 	if (uio->uio_offset != 0)
451 		return (EINVAL);
452 
453 	xlen = *buflenp;
454 
455 	/* must be able to read the whole string in one go */
456 	if (xlen < uio->uio_resid)
457 		return (EMSGSIZE);
458 	xlen = uio->uio_resid;
459 
460 	if ((error = uiomove(buf, xlen, uio)) != 0)
461 		return (error);
462 
463 	/* allow multiple writes without seeks */
464 	uio->uio_offset = 0;
465 
466 	/* cleanup string and remove trailing newline */
467 	buf[xlen] = '\0';
468 	xlen = strlen(buf);
469 	if (xlen > 0 && buf[xlen-1] == '\n')
470 		buf[--xlen] = '\0';
471 	*buflenp = xlen;
472 
473 	return (0);
474 }
475 
476 vfs_namemap_t *
477 vfs_findname(vfs_namemap_t *nm, char *buf, int buflen)
478 {
479 
480 	for (; nm->nm_name; nm++)
481 		if (bcmp(buf, nm->nm_name, buflen+1) == 0)
482 			return (nm);
483 
484 	return (0);
485 }
486 
487 void
488 procfs_exit(struct thread *td)
489 {
490 	struct pfsnode *pfs;
491 	struct vnode *vp;
492 	pid_t pid;
493 
494 	KKASSERT(td->td_proc);
495 	pid = td->td_proc->p_pid;
496 
497 	/*
498 	 * NOTE: We can't just vgone() the vnode any more, not while
499 	 * 	 it may potentially still be active.  This will clean
500 	 *	 the vp and clear the mount and cause the new VOP subsystem
501 	 *	 to assert or panic when someone tries to do an operation
502 	 *	 on an open (exited) procfs descriptor.
503 	 *
504 	 * Prevent further operations on this pid by setting pfs_pid to -1.
505 	 * Note that a pfs_pid of 0 is used for nodes which do not track
506 	 * any particular pid.
507 	 *
508 	 * Use vx_get() to properly ref/lock a vp which may not have any
509 	 * refs and which may or may not already be reclaimed.  vx_put()
510 	 * will then properly deactivate it and cause it to be recycled.
511 	 *
512 	 * The hash table can also get ripped out from under us when
513 	 * we block so take the easy way out and restart the scan.
514 	 */
515 again:
516 	pfs = *PFSHASH(pid);
517 	while (pfs) {
518 		if (pfs->pfs_pid == pid) {
519 			vp = PFSTOV(pfs);
520 			vx_get(vp);
521 			pfs->pfs_pid |= PFS_DEAD; /* does not effect hash */
522 			vx_put(vp);
523 			goto again;
524 		}
525 		pfs = pfs->pfs_next;
526 	}
527 }
528 
529