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