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