kernel/linprocfs: Fix a panic when accessing /proc/<pid>/maps.
[dragonfly.git] / sys / emulation / linux / i386 / linprocfs / linprocfs_misc.c
1 /*
2  * Copyright (c) 2000 Dag-Erling Coïdan Smørgrav
3  * Copyright (c) 1999 Pierre Beyssac
4  * Copyright (c) 1993 Jan-Simon Pendry
5  * Copyright (c) 1993
6  *      The Regents of the University of California.  All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Jan-Simon Pendry.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  *      @(#)procfs_status.c     8.4 (Berkeley) 6/15/94
40  *
41  * $FreeBSD: src/sys/i386/linux/linprocfs/linprocfs_misc.c,v 1.3.2.8 2001/06/25 19:46:47 pirzyk Exp $
42  */
43
44 #include <sys/param.h>
45 #include <sys/blist.h>
46 #include <sys/kernel.h>
47 #include <sys/kinfo.h>
48 #include <sys/proc.h>
49 #include <sys/jail.h>
50 #include <sys/resourcevar.h>
51 #include <sys/systm.h>
52 #include <sys/tty.h>
53 #include <sys/vnode.h>
54 #include <sys/lock.h>
55 #include <sys/sbuf.h>
56 #include <sys/mount.h>
57 #include <sys/sysctl.h>
58
59 #include <vm/vm.h>
60 #include <vm/pmap.h>
61 #include <vm/vm_map.h>
62 #include <vm/vm_param.h>
63 #include <vm/vm_object.h>
64 #include <vm/swap_pager.h>
65 #include <sys/vmmeter.h>
66 #include <sys/exec.h>
67
68 #include <machine/clock.h>
69 #include <machine/cputypes.h>
70 #include <machine/inttypes.h>
71 #include <machine/md_var.h>
72 #include <machine/vmparam.h>
73
74 #include "linprocfs.h"
75 #include "../linux.h"
76 #include "../../linux_ioctl.h"
77 #include "../../linux_mib.h"
78
79 /*
80  * Various conversion macros
81  */
82 #define T2J(x) (((x) * 100) / (stathz ? stathz : hz))   /* ticks to jiffies */
83 #define T2S(x) ((x) / (stathz ? stathz : hz))           /* ticks to seconds */
84 #define B2K(x) ((unsigned long)((x) >> 10))                     /* bytes to kbytes */
85 #define P2B(x) ((x) << PAGE_SHIFT)                      /* pages to bytes */
86 #define P2K(x) ((x) << (PAGE_SHIFT - 10))               /* pages to kbytes */
87
88 int
89 linprocfs_domeminfo(struct proc *curp, struct proc *p, struct pfsnode *pfs,
90                     struct uio *uio)
91 {
92         char *ps;
93         char psbuf[512];                /* XXX - conservative */
94         unsigned long memtotal;         /* total memory in bytes */
95         unsigned long memused;          /* used memory in bytes */
96         unsigned long memfree;          /* free memory in bytes */
97         unsigned long memshared;        /* shared memory ??? */
98         unsigned long buffers, cached;  /* buffer / cache memory ??? */
99         unsigned long long swaptotal;   /* total swap space in bytes */
100         unsigned long long swapused;    /* used swap space in bytes */
101         unsigned long long swapfree;    /* free swap space in bytes */
102         vm_object_t object;
103
104         if (uio->uio_rw != UIO_READ)
105                 return (EOPNOTSUPP);
106
107         memtotal = Maxmem * PAGE_SIZE;
108         /*
109          * The correct thing here would be:
110          *
111         memfree = vmstats.v_free_count * PAGE_SIZE;
112         memused = memtotal - memfree;
113          *
114          * but it might mislead linux binaries into thinking there
115          * is very little memory left, so we cheat and tell them that
116          * all memory that isn't wired down is free.
117          */
118         memused = vmstats.v_wire_count * PAGE_SIZE;
119         memfree = memtotal - memused;
120         if (swapblist == NULL) {
121                 swaptotal = 0;
122                 swapfree = 0;
123         } else {
124                 swaptotal = swapblist->bl_blocks * 1024LL; /* XXX why 1024? */
125                 swapfree = (unsigned long long)swapblist->bl_root->u.bmu_avail * PAGE_SIZE;
126         }
127         swapused = swaptotal - swapfree;
128         memshared = 0;
129
130         lwkt_gettoken(&vmobj_token);
131         for (object = TAILQ_FIRST(&vm_object_list); object != NULL;
132             object = TAILQ_NEXT(object, object_list)) {
133                 if (object->type == OBJT_MARKER)
134                         continue;
135                 if (object->shadow_count > 1)
136                         memshared += object->resident_page_count;
137         }
138         lwkt_reltoken(&vmobj_token);
139         memshared *= PAGE_SIZE;
140         /*
141          * We'd love to be able to write:
142          *
143         buffers = bufspace;
144          *
145          * but bufspace is internal to vfs_bio.c and we don't feel
146          * like unstaticizing it just for linprocfs's sake.
147          */
148         buffers = 0;
149         cached = vmstats.v_cache_count * PAGE_SIZE;
150
151         ps = psbuf;
152         ps += ksprintf(ps,
153                 "        total:    used:    free:  shared: buffers:  cached:\n"
154                 "Mem:  %lu %lu %lu %lu %lu %lu\n"
155                 "Swap: %llu %llu %llu\n"
156                 "MemTotal: %9lu kB\n"
157                 "MemFree:  %9lu kB\n"
158                 "MemShared:%9lu kB\n"
159                 "Buffers:  %9lu kB\n"
160                 "Cached:   %9lu kB\n"
161                 "SwapTotal:%9lu kB\n"
162                 "SwapFree: %9lu kB\n",
163                 memtotal, memused, memfree, memshared, buffers, cached,
164                 swaptotal, swapused, swapfree,
165                 B2K(memtotal), B2K(memfree),
166                 B2K(memshared), B2K(buffers), B2K(cached),
167                 B2K(swaptotal), B2K(swapfree));
168
169         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
170 }
171
172 int
173 linprocfs_docpuinfo(struct proc *curp, struct proc *p, struct pfsnode *pfs,
174                     struct uio *uio)
175 {
176         char *ps;
177         char psbuf[8192];
178         char hwmodel[128];
179         size_t  modellen = sizeof(hwmodel);
180         int mib[] = { CTL_HW, HW_MODEL };
181         int class;
182         int cpu;
183         int i;
184         int error;
185 #if 0
186         extern char *cpu_model;         /* Yuck */
187 #endif
188         /* We default the flags to include all non-conflicting flags,
189            and the Intel versions of conflicting flags.  Note the space
190            before each name; that is significant, and should be 
191            preserved. */
192
193         static char *flags[] = {
194                 "fpu",      "vme",     "de",       "pse",      "tsc",
195                 "msr",      "pae",     "mce",      "cx8",      "apic",
196                 "sep",      "sep",     "mtrr",     "pge",      "mca",
197                 "cmov",     "pat",     "pse36",    "pn",       "b19",
198                 "b20",      "b21",     "mmxext",   "mmx",      "fxsr",
199                 "xmm",      "b26",     "b27",      "b28",      "b29",
200                 "3dnowext", "3dnow"
201         };
202
203         if (uio->uio_rw != UIO_READ)
204                 return (EOPNOTSUPP);
205
206         switch (cpu_class) {
207         case CPUCLASS_286:
208                 class = 2;
209                 break;
210         case CPUCLASS_386:
211                 class = 3;
212                 break;
213         case CPUCLASS_486:
214                 class = 4;
215                 break;
216         case CPUCLASS_586:
217                 class = 5;
218                 break;
219         case CPUCLASS_686:
220                 class = 6;
221                 break;
222         default:
223                 class = 0;
224                 break;
225         }
226
227         ps = psbuf;
228
229         error = kernel_sysctl(mib, 2, hwmodel, &modellen, NULL, 0, NULL);
230         if (error)
231                 strcpy(hwmodel, "unknown");
232
233         for (cpu = 0; cpu < ncpus; cpu++) {
234                 ps += ksprintf(ps,
235                     "processor\t: %d\n"
236                     "vendor_id\t: %.20s\n"
237                     "cpu family\t: %d\n"
238                     "model\t\t: %d\n"
239                     "model name\t: %s\n"
240                     "stepping\t: %d\n",
241                     cpu, cpu_vendor, class, cpu, hwmodel, cpu_id & 0xf);
242         }
243
244         ps += ksprintf(ps,
245                         "flags\t\t:");
246
247         if (cpu_vendor_id == CPU_VENDOR_AMD && (class < 6)) {
248                 flags[16] = "fcmov";
249         } else if (cpu_vendor_id == CPU_VENDOR_CYRIX) {
250                 flags[24] = "cxmmx";
251         }
252         
253         for (i = 0; i < 32; i++)
254                 if (cpu_feature & (1 << i))
255                         ps += ksprintf(ps, " %s", flags[i]);
256         ps += ksprintf(ps, "\n");
257         if (class >= 5) {
258                 ps += ksprintf(ps,
259                         "cpu MHz\t\t: %d.%02d\n"
260                         "bogomips\t: %d.%02d\n",
261                         (int)((tsc_frequency + 4999) / 1000000),
262                         (int)((tsc_frequency + 4999) / 10000) % 100,
263                         (int)((tsc_frequency + 4999) / 1000000),
264                         (int)((tsc_frequency + 4999) / 10000) % 100);
265         }
266         
267         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
268 }
269
270 static unsigned int
271 cpucnt(int offset)
272 {
273     int i;
274     int count = 0;
275
276     for (i = 0; i < ncpus; ++i) {
277         struct globaldata *gd = globaldata_find(i);
278         count += *(unsigned int *)((char *)&gd->gd_cnt + offset);
279     }
280     return(count);
281 }
282
283 static int
284 linprocfs_domounts_callback(struct mount *mp, void *data)
285 {
286         struct statfs *st;
287         struct sbuf *sb = (struct sbuf *)data;
288         char *to, *from, *fs;
289
290         st = &mp->mnt_stat;
291
292         from = st->f_mntfromname;
293         to = st->f_mntonname;
294         fs = st->f_fstypename;
295
296         if (!strcmp(st->f_fstypename, "linprocfs"))
297                 fs = "proc";
298         else if (!strcmp(st->f_fstypename, "ext2fs"))
299                 fs = "ext2";
300         else if (!strcmp(st->f_fstypename, "msdos"))
301                 fs = "vfat";
302         else if (!strcmp(st->f_fstypename, "msdosfs"))
303                 fs = "vfat";
304
305         sbuf_printf(sb, "%s %s %s %s", from, to, fs,
306             st->f_flags & MNT_RDONLY ? "ro" : "rw");
307
308 #define OPT_ADD(name, flag) if (st->f_flags & (flag)) sbuf_printf(sb, "," name)
309         OPT_ADD("sync",         MNT_SYNCHRONOUS);
310         OPT_ADD("noexec",       MNT_NOEXEC);
311         OPT_ADD("nosuid",       MNT_NOSUID);
312         OPT_ADD("nodev",        MNT_NODEV);
313         OPT_ADD("async",        MNT_ASYNC);
314         OPT_ADD("suiddir",      MNT_SUIDDIR);
315         OPT_ADD("nosymfollow",  MNT_NOSYMFOLLOW);
316         OPT_ADD("noatime",      MNT_NOATIME);
317 #undef OPT_ADD
318
319         sbuf_printf(sb, " 0 0\n");
320
321         return 0;
322 }
323
324 int
325 linprocfs_domounts(struct proc *curp, struct proc *p, struct pfsnode *pfs,
326                     struct uio *uio)
327 {
328         struct sbuf *sb;
329         int error;
330
331         sb = sbuf_new_auto();
332
333         error = mountlist_scan(linprocfs_domounts_callback, sb, MNTSCAN_FORWARD);
334
335         sbuf_finish(sb);
336         if (error == 0)
337                 error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio);
338         sbuf_delete(sb);
339         return (error);
340 }
341
342 int
343 linprocfs_dostat(struct proc *curp, struct proc *p, struct pfsnode *pfs,
344                  struct uio *uio)
345 {
346         char *ps;
347         char psbuf[8192];
348         int cpu;
349
350         ps = psbuf;
351         ps += ksprintf(ps,
352                       "cpu %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64"\n",
353                       T2J(cpu_time.cp_user),
354                       T2J(cpu_time.cp_nice),
355                       T2J(cpu_time.cp_sys),
356                       T2J(cpu_time.cp_idle));
357
358         for (cpu = 0; cpu < ncpus; cpu++) {
359                 ps += ksprintf(ps,
360                       "cpu%d %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64"\n",
361                       cpu,
362                       T2J(cputime_percpu[cpu].cp_user),
363                       T2J(cputime_percpu[cpu].cp_nice),
364                       T2J(cputime_percpu[cpu].cp_sys),
365                       T2J(cputime_percpu[cpu].cp_idle));                        
366         }
367
368         ps += ksprintf(ps,
369                       "disk 0 0 0 0\n"
370                       "page %u %u\n"
371                       "swap %u %u\n"
372                       "intr %u\n"
373                       "ctxt %u\n"
374                       "btime %ld\n",
375                       cpucnt(offsetof(struct vmmeter, v_vnodepgsin)),
376                       cpucnt(offsetof(struct vmmeter, v_vnodepgsout)),
377                       cpucnt(offsetof(struct vmmeter, v_swappgsin)),
378                       cpucnt(offsetof(struct vmmeter, v_swappgsout)),
379                       cpucnt(offsetof(struct vmmeter, v_intr)),
380                       cpucnt(offsetof(struct vmmeter, v_swtch)),
381                       boottime.tv_sec);
382
383         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
384 }
385
386 int
387 linprocfs_douptime(struct proc *curp, struct proc *p, struct pfsnode *pfs,
388                    struct uio *uio)
389 {
390         char *ps;
391         char psbuf[64];
392         struct timeval tv;
393
394         getmicrouptime(&tv);
395         ps = psbuf;
396         ps += ksprintf(ps, "%ld.%02ld %"PRIu64".%02"PRIu64"\n",
397                       tv.tv_sec, tv.tv_usec / 10000,
398                       T2S(cpu_time.cp_idle), T2J(cpu_time.cp_idle) % 100);
399         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
400 }
401
402 int
403 linprocfs_doversion(struct proc *curp, struct proc *p, struct pfsnode *pfs,
404                     struct uio *uio)
405 {
406         char *ps;
407         size_t xlen;
408
409         ps = version; /* XXX not entirely correct */
410         for (xlen = 0; ps[xlen] != '\n'; ++xlen)
411                 /* nothing */ ;
412         ++xlen;
413         return (uiomove_frombuf(ps, xlen, uio));
414 }
415
416 #define B2P(x) ((x) >> PAGE_SHIFT)                      /* bytes to pages */
417 int
418 linprocfs_dostatm(struct proc *curp, struct proc *p, struct pfsnode *pfs,
419                     struct uio *uio)
420 {
421         char *ps, psbuf[1024];
422         struct kinfo_proc kp;
423
424         lwkt_gettoken(&p->p_token);
425         fill_kinfo_proc(p, &kp);
426
427         ps = psbuf;
428         ps += ksprintf(ps, "%d", p->p_pid);
429 #define PS_ADD(name, fmt, arg) ps += ksprintf(ps, " " fmt, arg)
430         PS_ADD("",      "%ju",  B2P((uintmax_t)(kp.kp_vm_tsize + kp.kp_vm_dsize + kp.kp_vm_ssize)));
431         PS_ADD("",      "%ju",  (uintmax_t)kp.kp_vm_rssize);
432         PS_ADD("",      "%ju",  (uintmax_t)0); /* XXX */
433         PS_ADD("",      "%ju",  (uintmax_t)kp.kp_vm_tsize);
434         PS_ADD("",      "%ju",  (uintmax_t)kp.kp_vm_dsize);
435         PS_ADD("",      "%ju",  (uintmax_t)kp.kp_vm_ssize);
436         PS_ADD("",      "%ju",  (uintmax_t)0); /* XXX */
437 #undef  PS_ADD
438         ps += ksprintf(ps, "\n");
439         lwkt_reltoken(&p->p_token);
440
441         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
442 }
443
444 #define P2K(x) ((x) << (PAGE_SHIFT - 10))               /* pages to kbytes */
445 int
446 linprocfs_doprocstat(struct proc *curp, struct proc *p, struct pfsnode *pfs,
447                      struct uio *uio)
448 {
449         vm_map_t map = &p->p_vmspace->vm_map;
450         vm_map_entry_t entry;
451         vm_offset_t start, end;
452         char *ps, psbuf[1024];
453         struct kinfo_proc kp;
454
455         lwkt_gettoken(&p->p_token);
456         fill_kinfo_proc(p, &kp);
457
458         start = 0;
459         end = 0;
460         vm_map_lock_read(map);
461         for (entry = map->header.next; entry != &map->header;
462                 entry = entry->next) {
463                 if (entry->maptype != VM_MAPTYPE_NORMAL &&
464                     entry->maptype != VM_MAPTYPE_VPAGETABLE) {
465                         continue;
466                 }
467                 /* Assuming that text is the first entry */
468                 start = entry->start;
469                 end = entry->end;
470         }
471         vm_map_unlock_read(map);
472
473         ps = psbuf;
474         ps += ksprintf(ps, "%d", p->p_pid);
475 #define PS_ADD(name, fmt, arg) ps += ksprintf(ps, " " fmt, arg)
476         PS_ADD("comm",          "(%s)", p->p_comm);
477         PS_ADD("statr",         "%c",   '0'); /* XXX */
478         PS_ADD("ppid",          "%d",   p->p_pptr ? p->p_pptr->p_pid : 0);
479         PS_ADD("pgrp",          "%d",   p->p_pgid);
480         PS_ADD("session",       "%d",   p->p_session->s_sid);
481         PS_ADD("tty",           "%d",   0); /* XXX */
482         PS_ADD("tpgid",         "%d",   kp.kp_tpgid); /* XXX */
483         PS_ADD("flags",         "%u",   0); /* XXX */
484         PS_ADD("minflt",        "%lu",  kp.kp_ru.ru_minflt); /* XXX */
485         PS_ADD("cminflt",       "%lu",  kp.kp_cru.ru_minflt); /* XXX */
486         PS_ADD("majflt",        "%lu",  kp.kp_ru.ru_majflt); /* XXX */
487         PS_ADD("cmajflt",       "%lu",  kp.kp_cru.ru_majflt); /* XXX */
488         PS_ADD("utime",         "%d",   T2J(tvtohz_high(&kp.kp_ru.ru_utime))); /* XXX */
489         PS_ADD("stime",         "%d",   T2J(tvtohz_high(&kp.kp_ru.ru_stime))); /* XXX */
490         PS_ADD("cutime",        "%d",   T2J(tvtohz_high(&kp.kp_cru.ru_utime))); /* XXX */
491         PS_ADD("cstime",        "%d",   T2J(tvtohz_high(&kp.kp_cru.ru_stime))); /* XXX */
492         PS_ADD("priority",      "%d",   0); /* XXX */
493         PS_ADD("nice",          "%d",   kp.kp_nice);
494         PS_ADD("timeout",       "%u",   0); /* XXX */
495         PS_ADD("itrealvalue",   "%u",   0); /* XXX */
496         PS_ADD("starttime",     "%d",   T2J(tvtohz_high(&kp.kp_start))); /* XXX */
497         PS_ADD("vsize",         "%ju",  P2K((uintmax_t)(kp.kp_vm_tsize + kp.kp_vm_dsize + kp.kp_vm_ssize))); /* XXX: not sure */
498         PS_ADD("rss",           "%ju",  (uintmax_t)kp.kp_vm_rssize); /* XXX */
499         PS_ADD("rlim",          "%lu",  kp.kp_ru.ru_maxrss); /* XXX */
500         PS_ADD("startcode",     "%lu",  start); /* XXX */
501         PS_ADD("endcode",       "%lu",  end); /* XXX */
502         PS_ADD("startstack",    "%lu",  (u_long)p->p_vmspace->vm_minsaddr); /* XXX */
503         PS_ADD("kstkesp",       "%u",   0); /* XXX */
504         PS_ADD("kstkeip",       "%u",   0); /* XXX */
505         PS_ADD("signal",        "%d",   0); /* XXX */
506         PS_ADD("blocked",       "%d",   0); /* XXX */
507         PS_ADD("sigignore",     "%d",   0); /* XXX */
508         PS_ADD("sigcatch",      "%d",   0); /* XXX */
509         PS_ADD("wchan",         "%u",   0); /* XXX */
510         PS_ADD("nswap",         "%lu",  kp.kp_ru.ru_nswap); /* XXX */
511         PS_ADD("cnswap",        "%lu",  kp.kp_cru.ru_nswap); /* XXX */
512         PS_ADD("exitsignal",    "%d",   0); /* XXX */
513         PS_ADD("processor",     "%u",   kp.kp_lwp.kl_cpuid); /* XXX */
514         PS_ADD("rt_priority",   "%u",   0); /* XXX */ /* >= 2.5.19 */
515         PS_ADD("policy",        "%u",   kp.kp_nice); /* XXX */ /* >= 2.5.19 */
516 #undef PS_ADD
517         ps += ksprintf(ps, "\n");
518         lwkt_reltoken(&p->p_token);
519         
520         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
521 }
522
523 /*
524  * Map process state to descriptive letter. Note that this does not
525  * quite correspond to what Linux outputs, but it's close enough.
526  */
527 static char *state_str[] = {
528         "? (unknown)",
529         "I (idle)",
530         "R (running)",
531         "T (stopped)",
532         "Z (zombie)",
533         "S (sleeping)",
534         "W (waiting)",
535         "M (mutex)"
536 };
537
538 int
539 linprocfs_doprocstatus(struct proc *curp, struct proc *p, struct pfsnode *pfs,
540                        struct uio *uio)
541 {
542         char *ps, psbuf[1024];
543         char *state;
544         int i;
545
546         ps = psbuf;
547
548         lwkt_gettoken(&p->p_token);
549         if (p->p_stat > NELEM(state_str))
550                 state = state_str[0];
551         else
552                 state = state_str[(int)p->p_stat];
553
554 #define PS_ADD ps += ksprintf
555         PS_ADD(ps, "Name:\t%s\n",         p->p_comm); /* XXX escape */
556         PS_ADD(ps, "State:\t%s\n",        state);
557
558         /*
559          * Credentials
560          */
561         PS_ADD(ps, "Pid:\t%d\n",          p->p_pid);
562         PS_ADD(ps, "PPid:\t%d\n",         p->p_pptr ? p->p_pptr->p_pid : 0);
563         PS_ADD(ps, "Uid:\t%d %d %d %d\n", p->p_ucred->cr_ruid,
564                                           p->p_ucred->cr_uid,
565                                           p->p_ucred->cr_svuid,
566                                           /* FreeBSD doesn't have fsuid */
567                                           p->p_ucred->cr_uid);
568         PS_ADD(ps, "Gid:\t%d %d %d %d\n", p->p_ucred->cr_rgid,
569                                           p->p_ucred->cr_gid,
570                                           p->p_ucred->cr_svgid,
571                                           /* FreeBSD doesn't have fsgid */
572                                           p->p_ucred->cr_gid);
573         PS_ADD(ps, "Groups:\t");
574         for (i = 0; i < p->p_ucred->cr_ngroups; i++)
575                 PS_ADD(ps, "%d ", p->p_ucred->cr_groups[i]);
576         PS_ADD(ps, "\n");
577         
578         /*
579          * Memory
580          */
581         PS_ADD(ps, "VmSize:\t%8lu kB\n",  B2K(p->p_vmspace->vm_map.size));
582         PS_ADD(ps, "VmLck:\t%8u kB\n",    P2K(0)); /* XXX */
583         /* XXX vm_rssize seems to always be zero, how can this be? */
584         PS_ADD(ps, "VmRss:\t%8u kB\n",    P2K(p->p_vmspace->vm_rssize));
585         PS_ADD(ps, "VmData:\t%8u kB\n",   P2K(p->p_vmspace->vm_dsize));
586         PS_ADD(ps, "VmStk:\t%8u kB\n",    P2K(p->p_vmspace->vm_ssize));
587         PS_ADD(ps, "VmExe:\t%8u kB\n",    P2K(p->p_vmspace->vm_tsize));
588         PS_ADD(ps, "VmLib:\t%8u kB\n",    P2K(0)); /* XXX */
589
590         /*
591          * Signal masks
592          *
593          * We support up to 128 signals, while Linux supports 32,
594          * but we only define 32 (the same 32 as Linux, to boot), so
595          * just show the lower 32 bits of each mask. XXX hack.
596          *
597          * NB: on certain platforms (Sparc at least) Linux actually
598          * supports 64 signals, but this code is a long way from
599          * running on anything but i386, so ignore that for now.
600          */
601         PS_ADD(ps, "SigPnd:\t%08x\n",     p->p_siglist.__bits[0]);
602         PS_ADD(ps, "SigBlk:\t%08x\n",     0); /* XXX */
603         PS_ADD(ps, "SigIgn:\t%08x\n",     p->p_sigignore.__bits[0]);
604         PS_ADD(ps, "SigCgt:\t%08x\n",     p->p_sigcatch.__bits[0]);
605         
606         /*
607          * Linux also prints the capability masks, but we don't have
608          * capabilities yet, and when we do get them they're likely to
609          * be meaningless to Linux programs, so we lie. XXX
610          */
611         PS_ADD(ps, "CapInh:\t%016x\n",    0);
612         PS_ADD(ps, "CapPrm:\t%016x\n",    0);
613         PS_ADD(ps, "CapEff:\t%016x\n",    0);
614 #undef PS_ADD
615         lwkt_reltoken(&p->p_token);
616         
617         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
618 }
619
620 int
621 linprocfs_doloadavg(struct proc *curp, struct proc *p,
622                     struct pfsnode *pfs, struct uio *uio)
623 {
624         char *ps, psbuf[512];
625
626         ps = psbuf;
627         ps += ksprintf(ps, "%d.%02d %d.%02d %d.%02d %d/%d %d\n",
628             (int)(averunnable.ldavg[0] / averunnable.fscale),
629             (int)(averunnable.ldavg[0] * 100 / averunnable.fscale % 100),
630             (int)(averunnable.ldavg[1] / averunnable.fscale),
631             (int)(averunnable.ldavg[1] * 100 / averunnable.fscale % 100),
632             (int)(averunnable.ldavg[2] / averunnable.fscale),
633             (int)(averunnable.ldavg[2] * 100 / averunnable.fscale % 100),
634             1,                      /* number of running tasks */
635             -1,                     /* number of tasks */
636             1         /* The last pid, just kidding */
637         );
638         return(uiomove_frombuf(psbuf, ps - psbuf, uio));
639 }
640
641 int
642 linprocfs_donetdev(struct proc *curp, struct proc *p, struct pfsnode *pfs,
643                    struct uio *uio)
644 {
645         struct sbuf *sb;
646         char ifname[16]; /* XXX LINUX_IFNAMSIZ */
647         struct ifnet *ifp;
648         int error;
649
650         sb = sbuf_new_auto();
651
652         sbuf_printf(sb, "%6s|%58s|%s\n%6s|%58s|%58s\n",
653             "Inter-", "   Receive", "  Transmit", " face",
654             "bytes    packets errs drop fifo frame compressed",
655             "bytes    packets errs drop fifo frame compressed");
656
657         crit_enter();
658         TAILQ_FOREACH(ifp, &ifnet, if_link) {
659                 linux_ifname(ifp, ifname, sizeof ifname);
660                 sbuf_printf(sb, "%6.6s:", ifname);
661                 sbuf_printf(sb, "%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu ",
662                     0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL);
663                 sbuf_printf(sb, "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
664                     0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL);
665         }
666         crit_exit();
667         sbuf_finish(sb);
668         error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio);
669         sbuf_delete(sb);
670         return (error);
671 }
672
673 int
674 linprocfs_dodevices(struct proc *curp, struct proc *p, struct pfsnode *pfs,
675                    struct uio *uio)
676 {
677         return 0;
678 }
679
680 int
681 linprocfs_doosrelease(struct proc *curp, struct proc *p, struct pfsnode *pfs,
682                    struct uio *uio)
683 {
684         char *osrelease;
685
686         osrelease = linux_get_osrelease(curthread);
687         return(uiomove_frombuf(osrelease, strlen(osrelease)+1, uio));
688 }
689
690 int
691 linprocfs_doostype(struct proc *curp, struct proc *p, struct pfsnode *pfs,
692                    struct uio *uio)
693 {
694         char *osname;
695
696         osname = linux_get_osname(curthread);
697         return(uiomove_frombuf(osname, strlen(osname)+1, uio));
698 }
699
700 int
701 linprocfs_dopidmax(struct proc *curp, struct proc *p, struct pfsnode *pfs,
702                    struct uio *uio)
703 {
704         char buf[32];
705
706         ksnprintf(buf, sizeof(buf), "%d", PID_MAX);
707         return(uiomove_frombuf(buf, strlen(buf)+1, uio));
708         return 0;
709 }
710
711 int
712 linprocfs_domaps(struct proc *curp, struct proc *p, struct pfsnode *pfs,
713              struct uio *uio)
714 {
715         int error;
716         vm_map_t map = &p->p_vmspace->vm_map;
717         vm_map_entry_t entry;
718         vm_ooffset_t off = 0;
719         struct sbuf *sb;
720         char *name = "", *freename = NULL;
721         struct vnode *vp;
722         struct vattr vat;
723         int major, minor;
724         ino_t ino;
725
726         if (uio->uio_rw != UIO_READ)
727                 return (EOPNOTSUPP);
728
729         sb = sbuf_new_auto();
730
731         error = 0;
732         vm_map_lock_read(map);
733         for (entry = map->header.next;
734                 ((uio->uio_resid > 0) && (entry != &map->header));
735                 entry = entry->next) {
736                 vm_object_t obj, tobj, lobj;
737                 vm_offset_t ostart;
738                 name = "";
739                 freename = NULL;
740                 ino = 0;
741                 if (entry->maptype != VM_MAPTYPE_NORMAL &&
742                     entry->maptype != VM_MAPTYPE_VPAGETABLE) {
743                         continue;
744                 }
745                 /*
746                  * Use map->hint as a poor man's ripout detector.
747                  */
748                 map->hint = entry;
749                 ostart = entry->start;
750
751                 /*
752                  * Find the bottom-most object, leaving the base object
753                  * and the bottom-most object held (but only one hold
754                  * if they happen to be the same).
755                  */
756                 obj = entry->object.vm_object;
757                 if (obj)
758                         vm_object_hold(obj);
759
760                 lobj = obj;
761                 while (lobj && (tobj = lobj->backing_object) != NULL) {
762                         KKASSERT(tobj != obj);
763                         vm_object_hold(tobj);
764                         if (tobj == lobj->backing_object) {
765                                 if (lobj != obj) {
766                                         vm_object_lock_swap();
767                                         vm_object_drop(lobj);
768                                 }
769                                 lobj = tobj;
770                         } else {
771                                 vm_object_drop(tobj);
772                         }
773                 }
774
775                 if (lobj) {
776                         off = IDX_TO_OFF(lobj->size);
777                         if (lobj->type == OBJT_VNODE) {
778                                 vp = lobj->handle;
779                                 if (vp)
780                                         vref(vp);
781                         } else {
782                                 vp = NULL;
783                         }
784                         
785                         if (vp) {
786                                 vn_fullpath(curproc, vp, &name, &freename, 1);
787                                 vn_lock(vp, LK_SHARED | LK_RETRY);
788                                 VOP_GETATTR(vp, &vat);
789                                 ino = vat.va_fileid;
790                                 major = vat.va_rmajor;
791                                 minor = vat.va_rminor;
792                                 vput(vp);
793                         }
794                 }
795                 if (freename == NULL) {
796                         if (entry->eflags & MAP_ENTRY_STACK)
797                                 name = "[stack]";
798                 }
799
800                 if (lobj != obj)
801                         vm_object_drop(lobj);
802                 if (obj)
803                         vm_object_drop(obj);
804
805                 /*
806                  * We cannot safely hold the map locked while accessing
807                  * userspace as a VM fault might recurse the locked map.
808                  */
809                 vm_map_unlock_read(map);
810
811                 /*
812                  * format:
813                  *  start-end access offset major:minor inode [.text file]
814                  */
815                 error = sbuf_printf(sb,
816                     "%08lx-%08lx %s%s%s%s %08llx %02x:%02x %llu%s%s\n",
817                     (u_long)entry->start, (u_long)entry->end,
818                     (entry->protection & VM_PROT_READ)?"r":"-",
819                     (entry->protection & VM_PROT_WRITE)?"w":"-",
820                     (entry->protection & VM_PROT_EXECUTE)?"x":"-",
821                     "p",
822                     off,        /* offset */
823                     0,          /* major */
824                     0,          /* minor */
825                     ino,        /* inode */
826                     (name && *name) ? "     " : "",
827                     name ? name : "");
828                 if (error == -1)
829                         error = ENOMEM;
830                 if (freename)
831                         kfree(freename, M_TEMP);
832
833                 vm_map_lock_read(map);
834                 if (error)
835                         break;
836
837                 /*
838                  * We use map->hint as a poor man's ripout detector.  If
839                  * it does not match the entry we set it to prior to
840                  * unlocking the map the entry MIGHT now be stale.  In
841                  * this case we do an expensive lookup to find our place
842                  * in the iteration again.
843                  */
844                 if (map->hint != entry) {
845                         vm_map_entry_t reentry;
846                 
847                         vm_map_lookup_entry(map, ostart, &reentry);
848                         entry = reentry;
849                 }
850         }
851         vm_map_unlock_read(map);
852
853         sbuf_finish(sb);
854         if (error == 0)
855                 error = uiomove_frombuf(sbuf_data(sb) + uio->uio_offset,
856                     sbuf_len(sb) - uio->uio_offset, uio);
857         sbuf_delete(sb);
858         return error;
859 }