xref: /netbsd-src/sys/miscfs/procfs/procfs_linux.c (revision 4dbe5ed7e761dc649d5ed976ae217050e22cfcdc)
1 /*      $NetBSD: procfs_linux.c,v 1.35 2007/05/24 00:37:40 agc Exp $      */
2 
3 /*
4  * Copyright (c) 2001 Wasabi Systems, Inc.
5  * All rights reserved.
6  *
7  * Written by Frank van der Linden for Wasabi Systems, Inc.
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 for the NetBSD Project by
20  *      Wasabi Systems, Inc.
21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22  *    or promote products derived from this software without specific prior
23  *    written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  */
37 
38 #include <sys/cdefs.h>
39 __KERNEL_RCSID(0, "$NetBSD: procfs_linux.c,v 1.35 2007/05/24 00:37:40 agc Exp $");
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/time.h>
44 #include <sys/kernel.h>
45 #include <sys/proc.h>
46 #include <sys/vnode.h>
47 #include <sys/exec.h>
48 #include <sys/resource.h>
49 #include <sys/resourcevar.h>
50 #include <sys/signal.h>
51 #include <sys/signalvar.h>
52 #include <sys/tty.h>
53 #include <sys/malloc.h>
54 #include <sys/mount.h>
55 #include <sys/conf.h>
56 
57 #include <miscfs/procfs/procfs.h>
58 #include <compat/linux/common/linux_exec.h>
59 
60 #include <uvm/uvm_extern.h>
61 #include <uvm/uvm.h>
62 
63 extern struct devsw_conv *devsw_conv;
64 extern int max_devsw_convs;
65 
66 #define PGTOB(p)	((unsigned long)(p) << PAGE_SHIFT)
67 #define PGTOKB(p)	((unsigned long)(p) << (PAGE_SHIFT - 10))
68 
69 #define LBFSZ (8 * 1024)
70 
71 static void
72 get_proc_size_info(struct lwp *l, unsigned long *stext, unsigned long *etext, unsigned long *sstack)
73 {
74 	struct proc *p = l->l_proc;
75 	struct vmspace *vm;
76 	struct vm_map *map;
77 	struct vm_map_entry *entry;
78 
79 	*stext = 0;
80 	*etext = 0;
81 	*sstack = 0;
82 
83 	proc_vmspace_getref(p, &vm);
84 	map = &vm->vm_map;
85 	vm_map_lock_read(map);
86 
87 	for (entry = map->header.next; entry != &map->header;
88 	    entry = entry->next) {
89 		if (UVM_ET_ISSUBMAP(entry))
90 			continue;
91 		/* assume text is the first entry */
92 		if (*stext == *etext) {
93 			*stext = entry->start;
94 			*etext = entry->end;
95 			break;
96 		}
97 	}
98 #ifdef LINUX_USRSTACK
99 	if (strcmp(p->p_emul->e_name, "linux") == 0 &&
100 	    LINUX_USRSTACK < USRSTACK)
101 		*sstack = (unsigned long) LINUX_USRSTACK;
102 	else
103 #endif
104 		*sstack = (unsigned long) USRSTACK;
105 
106 	/*
107 	 * jdk 1.6 compares low <= addr && addr < high
108 	 * if we put addr == high, then the test fails
109 	 * so eat one page.
110 	 */
111 	*sstack -= PAGE_SIZE;
112 
113 	vm_map_unlock_read(map);
114 	uvmspace_free(vm);
115 }
116 
117 /*
118  * Linux compatible /proc/meminfo. Only active when the -o linux
119  * mountflag is used.
120  */
121 int
122 procfs_domeminfo(struct lwp *curl, struct proc *p,
123     struct pfsnode *pfs, struct uio *uio)
124 {
125 	char *bf;
126 	int len;
127 	int error = 0;
128 
129 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
130 
131 	len = snprintf(bf, LBFSZ,
132 		"        total:    used:    free:  shared: buffers: cached:\n"
133 		"Mem:  %8lu %8lu %8lu %8lu %8lu %8lu\n"
134 		"Swap: %8lu %8lu %8lu\n"
135 		"MemTotal:  %8lu kB\n"
136 		"MemFree:   %8lu kB\n"
137 		"MemShared: %8lu kB\n"
138 		"Buffers:   %8lu kB\n"
139 		"Cached:    %8lu kB\n"
140 		"SwapTotal: %8lu kB\n"
141 		"SwapFree:  %8lu kB\n",
142 		PGTOB(uvmexp.npages),
143 		PGTOB(uvmexp.npages - uvmexp.free),
144 		PGTOB(uvmexp.free),
145 		0L,
146 		PGTOB(uvmexp.filepages),
147 		PGTOB(uvmexp.anonpages + uvmexp.filepages + uvmexp.execpages),
148 		PGTOB(uvmexp.swpages),
149 		PGTOB(uvmexp.swpginuse),
150 		PGTOB(uvmexp.swpages - uvmexp.swpginuse),
151 		PGTOKB(uvmexp.npages),
152 		PGTOKB(uvmexp.free),
153 		0L,
154 		PGTOKB(uvmexp.filepages),
155 		PGTOKB(uvmexp.anonpages + uvmexp.filepages + uvmexp.execpages),
156 		PGTOKB(uvmexp.swpages),
157 		PGTOKB(uvmexp.swpages - uvmexp.swpginuse));
158 
159 	if (len == 0)
160 		goto out;
161 
162 	error = uiomove_frombuf(bf, len, uio);
163 out:
164 	free(bf, M_TEMP);
165 	return error;
166 }
167 
168 /*
169  * Linux compatible /proc/devices. Only active when the -o linux
170  * mountflag is used.
171  */
172 int
173 procfs_dodevices(struct lwp *curl, struct proc *p,
174     struct pfsnode *pfs, struct uio *uio)
175 {
176 	char *bf;
177 	int offset = 0;
178 	int i, error = ENAMETOOLONG;
179 
180 	/* XXX elad - may need filtering. */
181 
182 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
183 
184 	offset += snprintf(&bf[offset], LBFSZ - offset, "Character devices:\n");
185 	if (offset >= LBFSZ)
186 		goto out;
187 
188 	for (i = 0; i < max_devsw_convs; i++) {
189 		if ((devsw_conv[i].d_name == NULL) ||
190 		    (devsw_conv[i].d_cmajor == -1))
191 			continue;
192 
193 		offset += snprintf(&bf[offset], LBFSZ - offset,
194 		    "%3d %s\n", devsw_conv[i].d_cmajor, devsw_conv[i].d_name);
195 		if (offset >= LBFSZ)
196 			goto out;
197 	}
198 
199 	offset += snprintf(&bf[offset], LBFSZ - offset, "\nBlock devices:\n");
200 	if (offset >= LBFSZ)
201 		goto out;
202 
203 	for (i = 0; i < max_devsw_convs; i++) {
204 		if ((devsw_conv[i].d_name == NULL) ||
205 		    (devsw_conv[i].d_bmajor == -1))
206 			continue;
207 
208 		offset += snprintf(&bf[offset], LBFSZ - offset,
209 		    "%3d %s\n", devsw_conv[i].d_bmajor, devsw_conv[i].d_name);
210 		if (offset >= LBFSZ)
211 			goto out;
212 	}
213 
214 	error = uiomove_frombuf(bf, offset, uio);
215 out:
216 	free(bf, M_TEMP);
217 	return error;
218 }
219 
220 /*
221  * Linux compatible /proc/stat. Only active when the -o linux
222  * mountflag is used.
223  */
224 int
225 procfs_docpustat(struct lwp *curl, struct proc *p,
226     struct pfsnode *pfs, struct uio *uio)
227 {
228 	struct timeval	 runtime;
229         struct cpu_info *ci;
230         CPU_INFO_ITERATOR cii;
231 	char		*bf;
232 	int	 	 error;
233 	int	 	 len;
234 	int	 	 i;
235 
236 	error = ENAMETOOLONG;
237 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
238 
239 	len = snprintf(bf, LBFSZ,
240 		"cpu %llu %llu %llu %llu\n",
241 		curcpu()->ci_schedstate.spc_cp_time[CP_USER],
242 		curcpu()->ci_schedstate.spc_cp_time[CP_NICE],
243 		curcpu()->ci_schedstate.spc_cp_time[CP_SYS] /*+ [CP_INTR]*/,
244 		curcpu()->ci_schedstate.spc_cp_time[CP_IDLE]);
245 	if (len == 0)
246 		goto out;
247 
248 	i = 0;
249 	for (CPU_INFO_FOREACH(cii, ci)) {
250 		len += snprintf(&bf[len], LBFSZ - len,
251 			"cpu%d %llu %llu %llu %llu\n", i,
252 			ci->ci_schedstate.spc_cp_time[CP_USER],
253 			ci->ci_schedstate.spc_cp_time[CP_NICE],
254 			ci->ci_schedstate.spc_cp_time[CP_SYS],
255 			ci->ci_schedstate.spc_cp_time[CP_IDLE]);
256 		if (len >= LBFSZ)
257 			goto out;
258 		i += 1;
259 	}
260 
261 	timersub(&curcpu()->ci_schedstate.spc_runtime, &boottime, &runtime);
262 	len += snprintf(&bf[len], LBFSZ - len,
263 			"disk 0 0 0 0\n"
264 			"page %u %u\n"
265 			"swap %u %u\n"
266 			"intr %u\n"
267 			"ctxt %u\n"
268 			"btime %lld\n",
269 			uvmexp.pageins, uvmexp.pdpageouts,
270 			uvmexp.pgswapin, uvmexp.pgswapout,
271 			uvmexp.intrs,
272 			uvmexp.swtch,
273 			(long long)boottime.tv_sec);
274 	if (len >= LBFSZ)
275 		goto out;
276 
277 	error = uiomove_frombuf(bf, len, uio);
278 out:
279 	free(bf, M_TEMP);
280 	return error;
281 }
282 
283 /*
284  * Linux compatible /proc/loadavg. Only active when the -o linux
285  * mountflag is used.
286  */
287 int
288 procfs_doloadavg(struct lwp *curl, struct proc *p,
289     struct pfsnode *pfs, struct uio *uio)
290 {
291 	char	*bf;
292 	int 	 error;
293 	int 	 len;
294 
295 	error = ENAMETOOLONG;
296 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
297 
298 	averunnable.fscale = FSCALE;
299 	len = snprintf(bf, LBFSZ,
300 	        "%d.%02d %d.%02d %d.%02d %d/%d %d\n",
301 		(int)(averunnable.ldavg[0] / averunnable.fscale),
302 		(int)(averunnable.ldavg[0] * 100 / averunnable.fscale % 100),
303 		(int)(averunnable.ldavg[1] / averunnable.fscale),
304 		(int)(averunnable.ldavg[1] * 100 / averunnable.fscale % 100),
305 		(int)(averunnable.ldavg[2] / averunnable.fscale),
306 		(int)(averunnable.ldavg[2] * 100 / averunnable.fscale % 100),
307 		1,		/* number of ONPROC processes */
308 		nprocs,
309 		30000);		/* last pid */
310 	if (len == 0)
311 		goto out;
312 
313 	error = uiomove_frombuf(bf, len, uio);
314 out:
315 	free(bf, M_TEMP);
316 	return error;
317 }
318 
319 /*
320  * Linux compatible /proc/<pid>/statm. Only active when the -o linux
321  * mountflag is used.
322  */
323 int
324 procfs_do_pid_statm(struct lwp *curl, struct lwp *l,
325     struct pfsnode *pfs, struct uio *uio)
326 {
327 	unsigned long	 stext = 0, etext = 0, sstack = 0;
328 	struct proc	*p = l->l_proc;
329 	struct rusage	*ru = &p->p_stats->p_ru;
330 	char		*bf;
331 	int	 	 error;
332 	int	 	 len;
333 
334 	error = ENAMETOOLONG;
335 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
336 
337 	get_proc_size_info(l, &stext, &etext, &sstack);
338 
339 	len = snprintf(bf, LBFSZ,
340 	        "%lu %lu %lu %lu %lu %lu %lu\n",
341 		(ru->ru_ixrss + ru->ru_idrss + ru->ru_isrss), /* size */
342 		ru->ru_maxrss,	/* resident */
343 		ru->ru_ixrss,	/* shared */
344 		stext,
345 		etext,
346 		sstack,
347 		(unsigned long) 0);
348 	if (len == 0)
349 		goto out;
350 
351 	error = uiomove_frombuf(bf, len, uio);
352 out:
353 	free(bf, M_TEMP);
354 	return error;
355 }
356 
357 /*
358  * Linux compatible /proc/<pid>/stat. Only active when the -o linux
359  * mountflag is used.
360  */
361 int
362 procfs_do_pid_stat(struct lwp *curl, struct lwp *l,
363     struct pfsnode *pfs, struct uio *uio)
364 {
365 	char *bf;
366 	struct proc *p = l->l_proc;
367 	int len;
368 	struct tty *tty = p->p_session->s_ttyp;
369 	struct rusage *ru = &p->p_stats->p_ru;
370 	struct rusage *cru = &p->p_stats->p_cru;
371 	unsigned long stext = 0, etext = 0, sstack = 0;
372 	struct timeval rt;
373 	int error = 0;
374 
375 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
376 
377 	get_proc_size_info(l, &stext, &etext, &sstack);
378 
379 	mutex_enter(&proclist_lock);
380 	mutex_enter(&p->p_mutex);
381 	mutex_enter(&p->p_smutex);
382 
383 	calcru(p, NULL, NULL, NULL, &rt);
384 
385 	len = snprintf(bf, LBFSZ,
386 	    "%d (%s) %c %d %d %d %d %d "
387 	    "%u "
388 	    "%lu %lu %lu %lu %lu %lu %lu %lu "
389 	    "%d %d %d "
390 	    "%lu %lu %lu %lu %" PRIu64 " "
391 	    "%lu %lu %lu "
392 	    "%u %u "
393 	    "%u %u %u %u "
394 	    "%lu %lu %lu %d %d\n",
395 
396 	    p->p_pid,
397 	    p->p_comm,
398 	    "0IR3SZD"[(p->p_stat > 6) ? 0 : (int)p->p_stat],
399 	    (p->p_pptr != NULL) ? p->p_pptr->p_pid : 0,
400 
401 	    p->p_pgid,
402 	    p->p_session->s_sid,
403 	    tty ? tty->t_dev : 0,
404 	    (tty && tty->t_pgrp) ? tty->t_pgrp->pg_id : 0,
405 
406 	    p->p_flag,
407 
408 	    ru->ru_minflt,
409 	    cru->ru_minflt,
410 	    ru->ru_majflt,
411 	    cru->ru_majflt,
412 	    ru->ru_utime.tv_sec,
413 	    ru->ru_stime.tv_sec,
414 	    cru->ru_utime.tv_sec,
415 	    cru->ru_stime.tv_sec,
416 
417 	    p->p_nice,					/* XXX: priority */
418 	    p->p_nice,
419 	    0,
420 
421 	    rt.tv_sec,
422 	    p->p_stats->p_start.tv_sec,
423 	    ru->ru_ixrss + ru->ru_idrss + ru->ru_isrss,
424 	    ru->ru_maxrss,
425 	    p->p_rlimit[RLIMIT_RSS].rlim_cur,
426 
427 	    stext,					/* start code */
428 	    etext,					/* end code */
429 	    sstack,					/* mm start stack */
430 	    0,						/* XXX: pc */
431 	    0,						/* XXX: sp */
432 	    p->p_sigpend.sp_set.__bits[0],		/* XXX: pending */
433 	    0,						/* XXX: held */
434 	    p->p_sigctx.ps_sigignore.__bits[0],		/* ignored */
435 	    p->p_sigctx.ps_sigcatch.__bits[0],		/* caught */
436 
437 	    (unsigned long)(intptr_t)l->l_wchan,
438 	    ru->ru_nvcsw,
439 	    ru->ru_nivcsw,
440 	    p->p_exitsig,
441 	    0);						/* XXX: processor */
442 
443 	mutex_exit(&p->p_smutex);
444 	mutex_exit(&p->p_mutex);
445 	mutex_exit(&proclist_lock);
446 
447 	if (len == 0)
448 		goto out;
449 
450 	error = uiomove_frombuf(bf, len, uio);
451 out:
452 	free(bf, M_TEMP);
453 	return error;
454 }
455 
456 int
457 procfs_docpuinfo(struct lwp *curl, struct proc *p,
458     struct pfsnode *pfs, struct uio *uio)
459 {
460 	int len = LBFSZ;
461 	char *bf = malloc(len, M_TEMP, M_WAITOK);
462 	int error;
463 
464 	if (procfs_getcpuinfstr(bf, &len) < 0) {
465 		error = ENOSPC;
466 		goto done;
467 	}
468 
469 	if (len == 0) {
470 		error = 0;
471 		goto done;
472 	}
473 
474 	error = uiomove_frombuf(bf, len, uio);
475 done:
476 	free(bf, M_TEMP);
477 	return error;
478 }
479 
480 int
481 procfs_douptime(struct lwp *curl, struct proc *p,
482     struct pfsnode *pfs, struct uio *uio)
483 {
484 	char *bf;
485 	int len;
486 	struct timeval runtime;
487 	u_int64_t idle;
488 	int error = 0;
489 
490 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
491 
492 	timersub(&curcpu()->ci_schedstate.spc_runtime, &boottime, &runtime);
493 	idle = curcpu()->ci_schedstate.spc_cp_time[CP_IDLE];
494 	len = snprintf(bf, LBFSZ,
495 	    "%lu.%02lu %" PRIu64 ".%02" PRIu64 "\n",
496 	    runtime.tv_sec, runtime.tv_usec / 10000,
497 	    idle / hz, (((idle % hz) * 100) / hz) % 100);
498 
499 	if (len == 0)
500 		goto out;
501 
502 	error = uiomove_frombuf(bf, len, uio);
503 out:
504 	free(bf, M_TEMP);
505 	return error;
506 }
507 
508 int
509 procfs_domounts(struct lwp *curl, struct proc *p,
510     struct pfsnode *pfs, struct uio *uio)
511 {
512 	char *bf, *mtab = NULL;
513 	const char *fsname;
514 	size_t len, mtabsz = 0;
515 	struct mount *mp, *nmp;
516 	struct statvfs *sfs;
517 	int error = 0;
518 
519 	/* XXX elad - may need filtering. */
520 
521 	bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
522 	simple_lock(&mountlist_slock);
523 	for (mp = CIRCLEQ_FIRST(&mountlist); mp != (void *)&mountlist;
524 	     mp = nmp) {
525 		if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock)) {
526 			nmp = CIRCLEQ_NEXT(mp, mnt_list);
527 			continue;
528 		}
529 
530 		sfs = &mp->mnt_stat;
531 
532 		/* Linux uses different names for some filesystems */
533 		fsname = sfs->f_fstypename;
534 		if (strcmp(fsname, "procfs") == 0)
535 			fsname = "proc";
536 		else if (strcmp(fsname, "ext2fs") == 0)
537 			fsname = "ext2";
538 
539 		len = snprintf(bf, LBFSZ, "%s %s %s %s%s%s%s%s%s 0 0\n",
540 			sfs->f_mntfromname,
541 			sfs->f_mntonname,
542 			fsname,
543 			(mp->mnt_flag & MNT_RDONLY) ? "ro" : "rw",
544 			(mp->mnt_flag & MNT_NOSUID) ? ",nosuid" : "",
545 			(mp->mnt_flag & MNT_NOEXEC) ? ",noexec" : "",
546 			(mp->mnt_flag & MNT_NODEV) ? ",nodev" : "",
547 			(mp->mnt_flag & MNT_SYNCHRONOUS) ? ",sync" : "",
548 			(mp->mnt_flag & MNT_NOATIME) ? ",noatime" : ""
549 			);
550 
551 		mtab = realloc(mtab, mtabsz + len, M_TEMP, M_WAITOK);
552 		memcpy(mtab + mtabsz, bf, len);
553 		mtabsz += len;
554 
555 		simple_lock(&mountlist_slock);
556 		nmp = CIRCLEQ_NEXT(mp, mnt_list);
557 		vfs_unbusy(mp);
558 	}
559 	simple_unlock(&mountlist_slock);
560 	free(bf, M_TEMP);
561 
562 	if (mtabsz > 0) {
563 		error = uiomove_frombuf(mtab, mtabsz, uio);
564 		free(mtab, M_TEMP);
565 	}
566 
567 	return error;
568 }
569