Merge branch 'vendor/FILE'
[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  * $DragonFly: src/sys/emulation/linux/i386/linprocfs/linprocfs_misc.c,v 1.19 2008/05/10 17:24:05 dillon Exp $
43  */
44
45 #include <sys/param.h>
46 #include <sys/blist.h>
47 #include <sys/kernel.h>
48 #include <sys/kinfo.h>
49 #include <sys/proc.h>
50 #include <sys/jail.h>
51 #include <sys/resourcevar.h>
52 #include <sys/systm.h>
53 #include <sys/tty.h>
54 #include <sys/vnode.h>
55 #include <sys/lock.h>
56
57 #include <vm/vm.h>
58 #include <vm/pmap.h>
59 #include <vm/vm_map.h>
60 #include <vm/vm_param.h>
61 #include <vm/vm_object.h>
62 #include <vm/swap_pager.h>
63 #include <sys/vmmeter.h>
64 #include <sys/exec.h>
65
66 #include <machine/clock.h>
67 #include <machine/cputypes.h>
68 #include <machine/inttypes.h>
69 #include <machine/md_var.h>
70
71 #include "linprocfs.h"
72
73 /*
74  * Various conversion macros
75  */
76 #define T2J(x) (((x) * 100) / (stathz ? stathz : hz))   /* ticks to jiffies */
77 #define T2S(x) ((x) / (stathz ? stathz : hz))           /* ticks to seconds */
78 #define B2K(x) ((unsigned long)((x) >> 10))                     /* bytes to kbytes */
79 #define P2B(x) ((x) << PAGE_SHIFT)                      /* pages to bytes */
80 #define P2K(x) ((x) << (PAGE_SHIFT - 10))               /* pages to kbytes */
81
82 int
83 linprocfs_domeminfo(struct proc *curp, struct proc *p, struct pfsnode *pfs,
84                     struct uio *uio)
85 {
86         char *ps;
87         char psbuf[512];                /* XXX - conservative */
88         unsigned long memtotal;         /* total memory in bytes */
89         unsigned long memused;          /* used memory in bytes */
90         unsigned long memfree;          /* free memory in bytes */
91         unsigned long memshared;        /* shared memory ??? */
92         unsigned long buffers, cached;  /* buffer / cache memory ??? */
93         unsigned long long swaptotal;   /* total swap space in bytes */
94         unsigned long long swapused;    /* used swap space in bytes */
95         unsigned long long swapfree;    /* free swap space in bytes */
96         vm_object_t object;
97
98         if (uio->uio_rw != UIO_READ)
99                 return (EOPNOTSUPP);
100
101         memtotal = Maxmem * PAGE_SIZE;
102         /*
103          * The correct thing here would be:
104          *
105         memfree = vmstats.v_free_count * PAGE_SIZE;
106         memused = memtotal - memfree;
107          *
108          * but it might mislead linux binaries into thinking there
109          * is very little memory left, so we cheat and tell them that
110          * all memory that isn't wired down is free.
111          */
112         memused = vmstats.v_wire_count * PAGE_SIZE;
113         memfree = memtotal - memused;
114         if (swapblist == NULL) {
115                 swaptotal = 0;
116                 swapfree = 0;
117         } else {
118                 swaptotal = swapblist->bl_blocks * 1024LL; /* XXX why 1024? */
119                 swapfree = (unsigned long long)swapblist->bl_root->u.bmu_avail * PAGE_SIZE;
120         }
121         swapused = swaptotal - swapfree;
122         memshared = 0;
123         for (object = TAILQ_FIRST(&vm_object_list); object != NULL;
124             object = TAILQ_NEXT(object, object_list))
125                 if (object->shadow_count > 1)
126                         memshared += object->resident_page_count;
127         memshared *= PAGE_SIZE;
128         /*
129          * We'd love to be able to write:
130          *
131         buffers = bufspace;
132          *
133          * but bufspace is internal to vfs_bio.c and we don't feel
134          * like unstaticizing it just for linprocfs's sake.
135          */
136         buffers = 0;
137         cached = vmstats.v_cache_count * PAGE_SIZE;
138
139         ps = psbuf;
140         ps += ksprintf(ps,
141                 "        total:    used:    free:  shared: buffers:  cached:\n"
142                 "Mem:  %lu %lu %lu %lu %lu %lu\n"
143                 "Swap: %llu %llu %llu\n"
144                 "MemTotal: %9lu kB\n"
145                 "MemFree:  %9lu kB\n"
146                 "MemShared:%9lu kB\n"
147                 "Buffers:  %9lu kB\n"
148                 "Cached:   %9lu kB\n"
149                 "SwapTotal:%9lu kB\n"
150                 "SwapFree: %9lu kB\n",
151                 memtotal, memused, memfree, memshared, buffers, cached,
152                 swaptotal, swapused, swapfree,
153                 B2K(memtotal), B2K(memfree),
154                 B2K(memshared), B2K(buffers), B2K(cached),
155                 B2K(swaptotal), B2K(swapfree));
156
157         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
158 }
159
160 int
161 linprocfs_docpuinfo(struct proc *curp, struct proc *p, struct pfsnode *pfs,
162                     struct uio *uio)
163 {
164         char *ps;
165         char psbuf[512];                /* XXX - conservative */
166         int class;
167         int i;
168 #if 0
169         extern char *cpu_model;         /* Yuck */
170 #endif
171         /* We default the flags to include all non-conflicting flags,
172            and the Intel versions of conflicting flags.  Note the space
173            before each name; that is significant, and should be 
174            preserved. */
175
176         static char *flags[] = {
177                 "fpu",      "vme",     "de",       "pse",      "tsc",
178                 "msr",      "pae",     "mce",      "cx8",      "apic",
179                 "sep",      "sep",     "mtrr",     "pge",      "mca",
180                 "cmov",     "pat",     "pse36",    "pn",       "b19",
181                 "b20",      "b21",     "mmxext",   "mmx",      "fxsr",
182                 "xmm",      "b26",     "b27",      "b28",      "b29",
183                 "3dnowext", "3dnow"
184         };
185
186         if (uio->uio_rw != UIO_READ)
187                 return (EOPNOTSUPP);
188
189         switch (cpu_class) {
190         case CPUCLASS_286:
191                 class = 2;
192                 break;
193         case CPUCLASS_386:
194                 class = 3;
195                 break;
196         case CPUCLASS_486:
197                 class = 4;
198                 break;
199         case CPUCLASS_586:
200                 class = 5;
201                 break;
202         case CPUCLASS_686:
203                 class = 6;
204                 break;
205         default:
206                 class = 0;
207                 break;
208         }
209
210         ps = psbuf;
211         ps += ksprintf(ps,
212                         "processor\t: %d\n"
213                         "vendor_id\t: %.20s\n"
214                         "cpu family\t: %d\n"
215                         "model\t\t: %d\n"
216                         "stepping\t: %d\n",
217                         0, cpu_vendor, class, cpu, cpu_id & 0xf);
218
219         ps += ksprintf(ps,
220                         "flags\t\t:");
221
222         if (!strcmp(cpu_vendor, "AuthenticAMD") && (class < 6)) {
223                 flags[16] = "fcmov";
224         } else if (!strcmp(cpu_vendor, "CyrixInstead")) {
225                 flags[24] = "cxmmx";
226         }
227         
228         for (i = 0; i < 32; i++)
229                 if (cpu_feature & (1 << i))
230                         ps += ksprintf(ps, " %s", flags[i]);
231         ps += ksprintf(ps, "\n");
232         if (class >= 5) {
233                 ps += ksprintf(ps,
234                         "cpu MHz\t\t: %d.%02d\n"
235                         "bogomips\t: %d.%02d\n",
236                         (int)((tsc_frequency + 4999) / 1000000),
237                         (int)((tsc_frequency + 4999) / 10000) % 100,
238                         (int)((tsc_frequency + 4999) / 1000000),
239                         (int)((tsc_frequency + 4999) / 10000) % 100);
240         }
241         
242         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
243 }
244
245 static unsigned int
246 cpucnt(int offset)
247 {
248     int i;
249     int count = 0;
250
251     for (i = 0; i < ncpus; ++i) {
252         struct globaldata *gd = globaldata_find(i);
253         count += *(unsigned int *)((char *)&gd->gd_cnt + offset);
254     }
255     return(count);
256 }
257
258 int
259 linprocfs_dostat(struct proc *curp, struct proc *p, struct pfsnode *pfs,
260                  struct uio *uio)
261 {
262         char *ps;
263         char psbuf[512];
264
265         ps = psbuf;
266         ps += ksprintf(ps,
267                       "cpu %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64"\n"
268                       "disk 0 0 0 0\n"
269                       "page %u %u\n"
270                       "swap %u %u\n"
271                       "intr %u\n"
272                       "ctxt %u\n"
273                       "btime %ld\n",
274                       T2J(cpu_time.cp_user),
275                       T2J(cpu_time.cp_nice),
276                       T2J(cpu_time.cp_sys /*+ cpu_time[CP_INTR]*/),
277                       T2J(cpu_time.cp_idle),
278                       cpucnt(offsetof(struct vmmeter, v_vnodepgsin)),
279                       cpucnt(offsetof(struct vmmeter, v_vnodepgsout)),
280                       cpucnt(offsetof(struct vmmeter, v_swappgsin)),
281                       cpucnt(offsetof(struct vmmeter, v_swappgsout)),
282                       cpucnt(offsetof(struct vmmeter, v_intr)),
283                       cpucnt(offsetof(struct vmmeter, v_swtch)),
284                       boottime.tv_sec);
285         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
286 }
287
288 int
289 linprocfs_douptime(struct proc *curp, struct proc *p, struct pfsnode *pfs,
290                    struct uio *uio)
291 {
292         char *ps;
293         char psbuf[64];
294         struct timeval tv;
295
296         getmicrouptime(&tv);
297         ps = psbuf;
298         ps += ksprintf(ps, "%ld.%02ld %"PRIu64".%02"PRIu64"\n",
299                       tv.tv_sec, tv.tv_usec / 10000,
300                       T2S(cpu_time.cp_idle), T2J(cpu_time.cp_idle) % 100);
301         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
302 }
303
304 int
305 linprocfs_doversion(struct proc *curp, struct proc *p, struct pfsnode *pfs,
306                     struct uio *uio)
307 {
308         char *ps;
309         int xlen;
310
311         ps = version; /* XXX not entirely correct */
312         for (xlen = 0; ps[xlen] != '\n'; ++xlen)
313                 /* nothing */ ;
314         ++xlen;
315         return (uiomove_frombuf(ps, xlen, uio));
316 }
317
318 int
319 linprocfs_doprocstat(struct proc *curp, struct proc *p, struct pfsnode *pfs,
320                      struct uio *uio)
321 {
322         char *ps, psbuf[1024];
323
324         ps = psbuf;
325         ps += ksprintf(ps, "%d", p->p_pid);
326 #define PS_ADD(name, fmt, arg) ps += ksprintf(ps, " " fmt, arg)
327         PS_ADD("comm",          "(%s)", p->p_comm);
328         PS_ADD("statr",         "%c",   '0'); /* XXX */
329         PS_ADD("ppid",          "%d",   p->p_pptr ? p->p_pptr->p_pid : 0);
330         PS_ADD("pgrp",          "%d",   p->p_pgid);
331         PS_ADD("session",       "%d",   p->p_session->s_sid);
332         PS_ADD("tty",           "%d",   0); /* XXX */
333         PS_ADD("tpgid",         "%d",   0); /* XXX */
334         PS_ADD("flags",         "%u",   0); /* XXX */
335         PS_ADD("minflt",        "%u",   0); /* XXX */
336         PS_ADD("cminflt",       "%u",   0); /* XXX */
337         PS_ADD("majflt",        "%u",   0); /* XXX */
338         PS_ADD("cminflt",       "%u",   0); /* XXX */
339         PS_ADD("utime",         "%d",   0); /* XXX */
340         PS_ADD("stime",         "%d",   0); /* XXX */
341         PS_ADD("cutime",        "%d",   0); /* XXX */
342         PS_ADD("cstime",        "%d",   0); /* XXX */
343         PS_ADD("counter",       "%d",   0); /* XXX */
344         PS_ADD("priority",      "%d",   0); /* XXX */
345         PS_ADD("timeout",       "%u",   0); /* XXX */
346         PS_ADD("itrealvalue",   "%u",   0); /* XXX */
347         PS_ADD("starttime",     "%d",   0); /* XXX */
348         PS_ADD("vsize",         "%u",   0); /* XXX */
349         PS_ADD("rss",           "%u",   0); /* XXX */
350         PS_ADD("rlim",          "%u",   0); /* XXX */
351         PS_ADD("startcode",     "%u",   0); /* XXX */
352         PS_ADD("endcode",       "%u",   0); /* XXX */
353         PS_ADD("startstack",    "%u",   0); /* XXX */
354         PS_ADD("kstkesp",       "%u",   0); /* XXX */
355         PS_ADD("kstkeip",       "%u",   0); /* XXX */
356         PS_ADD("signal",        "%d",   0); /* XXX */
357         PS_ADD("blocked",       "%d",   0); /* XXX */
358         PS_ADD("sigignore",     "%d",   0); /* XXX */
359         PS_ADD("sigcatch",      "%d",   0); /* XXX */
360         PS_ADD("wchan",         "%u",   0); /* XXX */
361 #undef PS_ADD
362         ps += ksprintf(ps, "\n");
363         
364         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
365 }
366
367 /*
368  * Map process state to descriptive letter. Note that this does not
369  * quite correspond to what Linux outputs, but it's close enough.
370  */
371 static char *state_str[] = {
372         "? (unknown)",
373         "I (idle)",
374         "R (running)",
375         "T (stopped)",
376         "Z (zombie)",
377         "S (sleeping)",
378         "W (waiting)",
379         "M (mutex)"
380 };
381
382 int
383 linprocfs_doprocstatus(struct proc *curp, struct proc *p, struct pfsnode *pfs,
384                        struct uio *uio)
385 {
386         char *ps, psbuf[1024];
387         char *state;
388         int i;
389
390         ps = psbuf;
391
392         if (p->p_stat > sizeof state_str / sizeof *state_str)
393                 state = state_str[0];
394         else
395                 state = state_str[(int)p->p_stat];
396
397 #define PS_ADD ps += ksprintf
398         PS_ADD(ps, "Name:\t%s\n",         p->p_comm); /* XXX escape */
399         PS_ADD(ps, "State:\t%s\n",        state);
400
401         /*
402          * Credentials
403          */
404         PS_ADD(ps, "Pid:\t%d\n",          p->p_pid);
405         PS_ADD(ps, "PPid:\t%d\n",         p->p_pptr ? p->p_pptr->p_pid : 0);
406         PS_ADD(ps, "Uid:\t%d %d %d %d\n", p->p_ucred->cr_ruid,
407                                           p->p_ucred->cr_uid,
408                                           p->p_ucred->cr_svuid,
409                                           /* FreeBSD doesn't have fsuid */
410                                           p->p_ucred->cr_uid);
411         PS_ADD(ps, "Gid:\t%d %d %d %d\n", p->p_ucred->cr_rgid,
412                                           p->p_ucred->cr_gid,
413                                           p->p_ucred->cr_svgid,
414                                           /* FreeBSD doesn't have fsgid */
415                                           p->p_ucred->cr_gid);
416         PS_ADD(ps, "Groups:\t");
417         for (i = 0; i < p->p_ucred->cr_ngroups; i++)
418                 PS_ADD(ps, "%d ", p->p_ucred->cr_groups[i]);
419         PS_ADD(ps, "\n");
420         
421         /*
422          * Memory
423          */
424         PS_ADD(ps, "VmSize:\t%8lu kB\n",  B2K(p->p_vmspace->vm_map.size));
425         PS_ADD(ps, "VmLck:\t%8u kB\n",    P2K(0)); /* XXX */
426         /* XXX vm_rssize seems to always be zero, how can this be? */
427         PS_ADD(ps, "VmRss:\t%8u kB\n",    P2K(p->p_vmspace->vm_rssize));
428         PS_ADD(ps, "VmData:\t%8u kB\n",   P2K(p->p_vmspace->vm_dsize));
429         PS_ADD(ps, "VmStk:\t%8u kB\n",    P2K(p->p_vmspace->vm_ssize));
430         PS_ADD(ps, "VmExe:\t%8u kB\n",    P2K(p->p_vmspace->vm_tsize));
431         PS_ADD(ps, "VmLib:\t%8u kB\n",    P2K(0)); /* XXX */
432
433         /*
434          * Signal masks
435          *
436          * We support up to 128 signals, while Linux supports 32,
437          * but we only define 32 (the same 32 as Linux, to boot), so
438          * just show the lower 32 bits of each mask. XXX hack.
439          *
440          * NB: on certain platforms (Sparc at least) Linux actually
441          * supports 64 signals, but this code is a long way from
442          * running on anything but i386, so ignore that for now.
443          */
444         PS_ADD(ps, "SigPnd:\t%08x\n",     p->p_siglist.__bits[0]);
445         PS_ADD(ps, "SigBlk:\t%08x\n",     0); /* XXX */
446         PS_ADD(ps, "SigIgn:\t%08x\n",     p->p_sigignore.__bits[0]);
447         PS_ADD(ps, "SigCgt:\t%08x\n",     p->p_sigcatch.__bits[0]);
448         
449         /*
450          * Linux also prints the capability masks, but we don't have
451          * capabilities yet, and when we do get them they're likely to
452          * be meaningless to Linux programs, so we lie. XXX
453          */
454         PS_ADD(ps, "CapInh:\t%016x\n",    0);
455         PS_ADD(ps, "CapPrm:\t%016x\n",    0);
456         PS_ADD(ps, "CapEff:\t%016x\n",    0);
457 #undef PS_ADD
458         
459         return (uiomove_frombuf(psbuf, ps - psbuf, uio));
460 }
461
462 int
463 linprocfs_doloadavg(struct proc *curp, struct proc *p,
464                     struct pfsnode *pfs, struct uio *uio)
465 {
466         char *ps, psbuf[512];
467
468         ps = psbuf;
469         ps += ksprintf(ps, "%d.%02d %d.%02d %d.%02d %d/%d %d\n",
470             (int)(averunnable.ldavg[0] / averunnable.fscale),
471             (int)(averunnable.ldavg[0] * 100 / averunnable.fscale % 100),
472             (int)(averunnable.ldavg[1] / averunnable.fscale),
473             (int)(averunnable.ldavg[1] * 100 / averunnable.fscale % 100),
474             (int)(averunnable.ldavg[2] / averunnable.fscale),
475             (int)(averunnable.ldavg[2] * 100 / averunnable.fscale % 100),
476             1,                      /* number of running tasks */
477             -1,                     /* number of tasks */
478             1         /* The last pid, just kidding */
479         );
480         return(uiomove_frombuf(psbuf, ps - psbuf, uio));
481 }
482