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