6ff2ae94cfe6ad4ea839207bc2f0a5abd046d2d4
[dragonfly.git] / sys / vfs / procfs / procfs_subr.c
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_WEXIT) {
289                         lwkt_reltoken(&p->p_token);
290                         PRELE(p);
291                         p = NULL;
292                 }
293         }
294         return p;
295 }
296
297 void
298 pfs_pdone(struct proc *p)
299 {
300         if (p) {
301                 lwkt_reltoken(&p->p_token);
302                 PRELE(p);
303         }
304 }
305
306 int
307 procfs_rw(struct vop_read_args *ap)
308 {
309         struct vnode *vp = ap->a_vp;
310         struct uio *uio = ap->a_uio;
311         struct thread *curtd = uio->uio_td;
312         struct proc *curp;
313         struct pfsnode *pfs = VTOPFS(vp);
314         struct proc *p;
315         struct lwp *lp;
316         int rtval;
317
318         if (curtd == NULL)
319                 return (EINVAL);
320         if ((curp = curtd->td_proc) == NULL)    /* XXX */
321                 return (EINVAL);
322
323         lwkt_gettoken(&proc_token);
324         p = pfs_pfind(pfs->pfs_pid);
325         if (p == NULL) {
326                 rtval = (EINVAL);
327                 goto out;
328         }
329         if (p->p_pid == 1 && securelevel > 0 && uio->uio_rw == UIO_WRITE) {
330                 rtval = (EACCES);
331                 goto out;
332         }
333         /* XXX lwp */
334         lp = FIRST_LWP_IN_PROC(p);
335         LWPHOLD(lp);
336
337         while (pfs->pfs_lockowner) {
338                 tsleep(&pfs->pfs_lockowner, 0, "pfslck", 0);
339         }
340         pfs->pfs_lockowner = curproc->p_pid;
341
342         switch (pfs->pfs_type) {
343         case Pnote:
344         case Pnotepg:
345                 rtval = procfs_donote(curp, lp, pfs, uio);
346                 break;
347
348         case Pregs:
349                 rtval = procfs_doregs(curp, lp, pfs, uio);
350                 break;
351
352         case Pfpregs:
353                 rtval = procfs_dofpregs(curp, lp, pfs, uio);
354                 break;
355
356         case Pdbregs:
357                 rtval = procfs_dodbregs(curp, lp, pfs, uio);
358                 break;
359
360         case Pctl:
361                 rtval = procfs_doctl(curp, lp, pfs, uio);
362                 break;
363
364         case Pstatus:
365                 rtval = procfs_dostatus(curp, lp, pfs, uio);
366                 break;
367
368         case Pmap:
369                 rtval = procfs_domap(curp, lp, pfs, uio);
370                 break;
371
372         case Pmem:
373                 rtval = procfs_domem(curp, lp, pfs, uio);
374                 break;
375
376         case Ptype:
377                 rtval = procfs_dotype(curp, lp, pfs, uio);
378                 break;
379
380         case Pcmdline:
381                 rtval = procfs_docmdline(curp, lp, pfs, uio);
382                 break;
383
384         case Prlimit:
385                 rtval = procfs_dorlimit(curp, lp, pfs, uio);
386                 break;
387
388         default:
389                 rtval = EOPNOTSUPP;
390                 break;
391         }
392         LWPRELE(lp);
393
394         pfs->pfs_lockowner = 0;
395         wakeup(&pfs->pfs_lockowner);
396
397 out:
398         pfs_pdone(p);
399         lwkt_reltoken(&proc_token);
400
401         return rtval;
402 }
403
404 /*
405  * Get a string from userland into (buf).  Strip a trailing
406  * nl character (to allow easy access from the shell).
407  * The buffer should be *buflenp + 1 chars long.  vfs_getuserstr
408  * will automatically add a nul char at the end.
409  *
410  * Returns 0 on success or the following errors
411  *
412  * EINVAL:    file offset is non-zero.
413  * EMSGSIZE:  message is longer than kernel buffer
414  * EFAULT:    user i/o buffer is not addressable
415  */
416 int
417 vfs_getuserstr(struct uio *uio, char *buf, int *buflenp)
418 {
419         int xlen;
420         int error;
421
422         if (uio->uio_offset != 0)
423                 return (EINVAL);
424
425         xlen = *buflenp;
426
427         /* must be able to read the whole string in one go */
428         if (xlen < uio->uio_resid)
429                 return (EMSGSIZE);
430         xlen = uio->uio_resid;
431
432         if ((error = uiomove(buf, xlen, uio)) != 0)
433                 return (error);
434
435         /* allow multiple writes without seeks */
436         uio->uio_offset = 0;
437
438         /* cleanup string and remove trailing newline */
439         buf[xlen] = '\0';
440         xlen = strlen(buf);
441         if (xlen > 0 && buf[xlen-1] == '\n')
442                 buf[--xlen] = '\0';
443         *buflenp = xlen;
444
445         return (0);
446 }
447
448 vfs_namemap_t *
449 vfs_findname(vfs_namemap_t *nm, char *buf, int buflen)
450 {
451
452         for (; nm->nm_name; nm++)
453                 if (bcmp(buf, nm->nm_name, buflen+1) == 0)
454                         return (nm);
455
456         return (0);
457 }
458
459 void
460 procfs_exit(struct thread *td)
461 {
462         struct pfsnode *pfs;
463         struct vnode *vp;
464         pid_t pid;
465
466         KKASSERT(td->td_proc);
467         pid = td->td_proc->p_pid;
468
469         /*
470          * NOTE: We can't just vgone() the vnode any more, not while
471          *       it may potentially still be active.  This will clean
472          *       the vp and clear the mount and cause the new VOP subsystem
473          *       to assert or panic when someone tries to do an operation
474          *       on an open (exited) procfs descriptor.
475          *
476          * Prevent further operations on this pid by setting pfs_pid to -1.
477          * Note that a pfs_pid of 0 is used for nodes which do not track
478          * any particular pid.
479          *
480          * Use vx_get() to properly ref/lock a vp which may not have any
481          * refs and which may or may not already be reclaimed.  vx_put()
482          * will then properly deactivate it and cause it to be recycled.
483          *
484          * The hash table can also get ripped out from under us when
485          * we block so take the easy way out and restart the scan.
486          */
487 again:
488         pfs = *PFSHASH(pid);
489         while (pfs) {
490                 if (pfs->pfs_pid == pid) {
491                         vp = PFSTOV(pfs);
492                         vx_get(vp);
493                         pfs->pfs_pid |= PFS_DEAD; /* does not effect hash */
494                         vx_put(vp);
495                         goto again;
496                 }
497                 pfs = pfs->pfs_next;
498         }
499 }
500