1/* $NetBSD: procfs_linux.c,v 1.72 2016/03/28 17:23:47 mlelstv 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.72 2016/03/28 17:23:47 mlelstv Exp $");
40
41#include <sys/param.h>
42#include <sys/systm.h>
43#include <sys/time.h>
44#include <sys/cpu.h>
45#include <sys/kernel.h>
46#include <sys/proc.h>
47#include <sys/vnode.h>
48#include <sys/exec.h>
49#include <sys/resource.h>
50#include <sys/resourcevar.h>
51#include <sys/signal.h>
52#include <sys/signalvar.h>
53#include <sys/tty.h>
54#include <sys/malloc.h>
55#include <sys/mount.h>
56#include <sys/conf.h>
57#include <sys/sysctl.h>
58#include <sys/kauth.h>
59#include <sys/filedesc.h>
60
61#include <miscfs/procfs/procfs.h>
62
63#include <compat/linux/common/linux_exec.h>
64#include <compat/linux32/common/linux32_sysctl.h>
65
66#include <uvm/uvm_extern.h>
67#include <uvm/uvm.h>
68
69extern struct devsw_conv *devsw_conv;
70extern int max_devsw_convs;
71
72#define PGTOB(p) ((unsigned long)(p) << PAGE_SHIFT)
73#define PGTOKB(p) ((unsigned long)(p) << (PAGE_SHIFT - 10))
74
75#define LBFSZ (8 * 1024)
76
77static void
78get_proc_size_info(struct lwp *l, unsigned long *stext, unsigned long *etext, unsigned long *sstack)
79{
80 struct proc *p = l->l_proc;
81 struct vmspace *vm;
82 struct vm_map *map;
83 struct vm_map_entry *entry;
84
85 *stext = 0;
86 *etext = 0;
87 *sstack = 0;
88
89 proc_vmspace_getref(p, &vm);
90 map = &vm->vm_map;
91 vm_map_lock_read(map);
92
93 for (entry = map->header.next; entry != &map->header;
94 entry = entry->next) {
95 if (UVM_ET_ISSUBMAP(entry))
96 continue;
97 /* assume text is the first entry */
98 if (*stext == *etext) {
99 *stext = entry->start;
100 *etext = entry->end;
101 break;
102 }
103 }
104#if defined(LINUX_USRSTACK32) && defined(USRSTACK32)
105 if (strcmp(p->p_emul->e_name, "linux32") == 0 &&
106 LINUX_USRSTACK32 < USRSTACK32)
107 *sstack = (unsigned long)LINUX_USRSTACK32;
108 else
109#endif
110#ifdef LINUX_USRSTACK
111 if (strcmp(p->p_emul->e_name, "linux") == 0 &&
112 LINUX_USRSTACK < USRSTACK)
113 *sstack = (unsigned long)LINUX_USRSTACK;
114 else
115#endif
116#ifdef USRSTACK32
117 if (strstr(p->p_emul->e_name, "32") != NULL)
118 *sstack = (unsigned long)USRSTACK32;
119 else
120#endif
121 *sstack = (unsigned long)USRSTACK;
122
123 /*
124 * jdk 1.6 compares low <= addr && addr < high
125 * if we put addr == high, then the test fails
126 * so eat one page.
127 */
128 *sstack -= PAGE_SIZE;
129
130 vm_map_unlock_read(map);
131 uvmspace_free(vm);
132}
133
134/*
135 * Linux compatible /proc/meminfo. Only active when the -o linux
136 * mountflag is used.
137 */
138int
139procfs_domeminfo(struct lwp *curl, struct proc *p,
140 struct pfsnode *pfs, struct uio *uio)
141{
142 char *bf;
143 int len;
144 int error = 0;
145
146 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
147
148 len = snprintf(bf, LBFSZ,
149 " total: used: free: shared: buffers: cached:\n"
150 "Mem: %8lu %8lu %8lu %8lu %8lu %8lu\n"
151 "Swap: %8lu %8lu %8lu\n"
152 "MemTotal: %8lu kB\n"
153 "MemFree: %8lu kB\n"
154 "MemShared: %8lu kB\n"
155 "Buffers: %8lu kB\n"
156 "Cached: %8lu kB\n"
157 "SwapTotal: %8lu kB\n"
158 "SwapFree: %8lu kB\n",
159 PGTOB(uvmexp.npages),
160 PGTOB(uvmexp.npages - uvmexp.free),
161 PGTOB(uvmexp.free),
162 0L,
163 PGTOB(uvmexp.filepages),
164 PGTOB(uvmexp.anonpages + uvmexp.filepages + uvmexp.execpages),
165 PGTOB(uvmexp.swpages),
166 PGTOB(uvmexp.swpginuse),
167 PGTOB(uvmexp.swpages - uvmexp.swpginuse),
168 PGTOKB(uvmexp.npages),
169 PGTOKB(uvmexp.free),
170 0L,
171 PGTOKB(uvmexp.filepages),
172 PGTOKB(uvmexp.anonpages + uvmexp.filepages + uvmexp.execpages),
173 PGTOKB(uvmexp.swpages),
174 PGTOKB(uvmexp.swpages - uvmexp.swpginuse));
175
176 if (len == 0)
177 goto out;
178
179 error = uiomove_frombuf(bf, len, uio);
180out:
181 free(bf, M_TEMP);
182 return error;
183}
184
185/*
186 * Linux compatible /proc/devices. Only active when the -o linux
187 * mountflag is used.
188 */
189int
190procfs_dodevices(struct lwp *curl, struct proc *p,
191 struct pfsnode *pfs, struct uio *uio)
192{
193 char *bf;
194 int offset = 0;
195 int i, error = ENAMETOOLONG;
196
197 /* XXX elad - may need filtering. */
198
199 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
200
201 offset += snprintf(&bf[offset], LBFSZ - offset, "Character devices:\n");
202 if (offset >= LBFSZ)
203 goto out;
204
205 mutex_enter(&device_lock);
206 for (i = 0; i < max_devsw_convs; i++) {
207 if ((devsw_conv[i].d_name == NULL) ||
208 (devsw_conv[i].d_cmajor == -1))
209 continue;
210
211 offset += snprintf(&bf[offset], LBFSZ - offset,
212 "%3d %s\n", devsw_conv[i].d_cmajor, devsw_conv[i].d_name);
213 if (offset >= LBFSZ) {
214 mutex_exit(&device_lock);
215 goto out;
216 }
217 }
218
219 offset += snprintf(&bf[offset], LBFSZ - offset, "\nBlock devices:\n");
220 if (offset >= LBFSZ) {
221 mutex_exit(&device_lock);
222 goto out;
223 }
224
225 for (i = 0; i < max_devsw_convs; i++) {
226 if ((devsw_conv[i].d_name == NULL) ||
227 (devsw_conv[i].d_bmajor == -1))
228 continue;
229
230 offset += snprintf(&bf[offset], LBFSZ - offset,
231 "%3d %s\n", devsw_conv[i].d_bmajor, devsw_conv[i].d_name);
232 if (offset >= LBFSZ) {
233 mutex_exit(&device_lock);
234 goto out;
235 }
236 }
237 mutex_exit(&device_lock);
238
239 error = uiomove_frombuf(bf, offset, uio);
240out:
241 free(bf, M_TEMP);
242 return error;
243}
244
245/*
246 * Linux compatible /proc/stat. Only active when the -o linux
247 * mountflag is used.
248 */
249int
250procfs_docpustat(struct lwp *curl, struct proc *p,
251 struct pfsnode *pfs, struct uio *uio)
252{
253 char *bf;
254 int error;
255 int len;
256#if defined(MULTIPROCESSOR)
257 struct cpu_info *ci;
258 CPU_INFO_ITERATOR cii;
259#endif
260 int i;
261 uint64_t nintr;
262 uint64_t nswtch;
263
264 error = ENAMETOOLONG;
265 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
266
267 len = snprintf(bf, LBFSZ,
268 "cpu %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
269 curcpu()->ci_schedstate.spc_cp_time[CP_USER],
270 curcpu()->ci_schedstate.spc_cp_time[CP_NICE],
271 curcpu()->ci_schedstate.spc_cp_time[CP_SYS] /*+ [CP_INTR]*/,
272 curcpu()->ci_schedstate.spc_cp_time[CP_IDLE]);
273 if (len == 0)
274 goto out;
275
276#if defined(MULTIPROCESSOR)
277#define ALLCPUS CPU_INFO_FOREACH(cii, ci)
278#define CPUNAME ci
279#else
280#define ALLCPUS ; i < 1 ;
281#define CPUNAME curcpu()
282#endif
283
284 i = 0;
285 nintr = 0;
286 nswtch = 0;
287 for (ALLCPUS) {
288 len += snprintf(&bf[len], LBFSZ - len,
289 "cpu%d %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
290 "\n", i,
291 CPUNAME->ci_schedstate.spc_cp_time[CP_USER],
292 CPUNAME->ci_schedstate.spc_cp_time[CP_NICE],
293 CPUNAME->ci_schedstate.spc_cp_time[CP_SYS],
294 CPUNAME->ci_schedstate.spc_cp_time[CP_IDLE]);
295 if (len >= LBFSZ)
296 goto out;
297 i += 1;
298 nintr += CPUNAME->ci_data.cpu_nintr;
299 nswtch += CPUNAME->ci_data.cpu_nswtch;
300 }
301
302 len += snprintf(&bf[len], LBFSZ - len,
303 "disk 0 0 0 0\n"
304 "page %u %u\n"
305 "swap %u %u\n"
306 "intr %"PRIu64"\n"
307 "ctxt %"PRIu64"\n"
308 "btime %"PRId64"\n",
309 uvmexp.pageins, uvmexp.pdpageouts,
310 uvmexp.pgswapin, uvmexp.pgswapout,
311 nintr,
312 nswtch,
313 boottime.tv_sec);
314 if (len >= LBFSZ)
315 goto out;
316
317 error = uiomove_frombuf(bf, len, uio);
318out:
319 free(bf, M_TEMP);
320 return error;
321}
322
323/*
324 * Linux compatible /proc/loadavg. Only active when the -o linux
325 * mountflag is used.
326 */
327int
328procfs_doloadavg(struct lwp *curl, struct proc *p,
329 struct pfsnode *pfs, struct uio *uio)
330{
331 char *bf;
332 int error;
333 int len;
334
335 error = ENAMETOOLONG;
336 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
337
338 averunnable.fscale = FSCALE;
339 len = snprintf(bf, LBFSZ,
340 "%d.%02d %d.%02d %d.%02d %d/%d %d\n",
341 (int)(averunnable.ldavg[0] / averunnable.fscale),
342 (int)(averunnable.ldavg[0] * 100 / averunnable.fscale % 100),
343 (int)(averunnable.ldavg[1] / averunnable.fscale),
344 (int)(averunnable.ldavg[1] * 100 / averunnable.fscale % 100),
345 (int)(averunnable.ldavg[2] / averunnable.fscale),
346 (int)(averunnable.ldavg[2] * 100 / averunnable.fscale % 100),
347 1, /* number of ONPROC processes */
348 nprocs,
349 30000); /* last pid */
350 if (len == 0)
351 goto out;
352
353 error = uiomove_frombuf(bf, len, uio);
354out:
355 free(bf, M_TEMP);
356 return error;
357}
358
359/*
360 * Linux compatible /proc/<pid>/statm. Only active when the -o linux
361 * mountflag is used.
362 */
363int
364procfs_do_pid_statm(struct lwp *curl, struct lwp *l,
365 struct pfsnode *pfs, struct uio *uio)
366{
367 struct vmspace *vm;
368 struct proc *p = l->l_proc;
369 char *bf;
370 int error;
371 int len;
372 struct kinfo_proc2 ki;
373
374 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
375
376 /* XXX - we use values from vmspace, since dsl says that ru figures
377 are always 0 except for zombies. See kvm_proc.c::kvm_getproc2() */
378 if ((error = proc_vmspace_getref(p, &vm)) != 0) {
379 goto out;
380 }
381
382 mutex_enter(proc_lock);
383 mutex_enter(p->p_lock);
384
385 /* retrieve RSS size */
386 fill_kproc2(p, &ki, false);
387
388 mutex_exit(p->p_lock);
389 mutex_exit(proc_lock);
390
391 uvmspace_free(vm);
392
393 len = snprintf(bf, LBFSZ,
394 "%lu %lu %lu %lu %lu %lu %lu\n",
395 (unsigned long)(ki.p_vm_msize), /* size */
396 (unsigned long)(ki.p_vm_rssize),/* resident */
397 (unsigned long)(ki.p_uru_ixrss),/* shared */
398 (unsigned long)(ki.p_vm_tsize), /* text */
399 (unsigned long) 0, /* library (unused) */
400 (unsigned long)(ki.p_vm_dsize + ki.p_vm_ssize), /* data+stack */
401 (unsigned long) 0); /* dirty */
402
403 if (len == 0)
404 goto out;
405
406 error = uiomove_frombuf(bf, len, uio);
407out:
408 free(bf, M_TEMP);
409 return error;
410}
411
412#define UTIME2TICKS(s,u) (((uint64_t)(s) * 1000000 + (u)) / 10000)
413
414/*
415 * Linux compatible /proc/<pid>/stat. Only active when the -o linux
416 * mountflag is used.
417 */
418int
419procfs_do_pid_stat(struct lwp *curl, struct lwp *l,
420 struct pfsnode *pfs, struct uio *uio)
421{
422 char *bf;
423 struct proc *p = l->l_proc;
424 int len;
425 struct rusage *cru = &p->p_stats->p_cru;
426 unsigned long stext = 0, etext = 0, sstack = 0;
427 struct timeval rt;
428 struct vmspace *vm;
429 struct kinfo_proc2 ki;
430 int error;
431
432 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
433
434 if ((error = proc_vmspace_getref(p, &vm)) != 0) {
435 goto out;
436 }
437
438 get_proc_size_info(l, &stext, &etext, &sstack);
439
440 mutex_enter(proc_lock);
441 mutex_enter(p->p_lock);
442
443 fill_kproc2(p, &ki, false);
444 calcru(p, NULL, NULL, NULL, &rt);
445
446 len = snprintf(bf, LBFSZ,
447 "%d (%s) %c %d %d %d %u %d "
448 "%u "
449 "%"PRIu64" %lu %"PRIu64" %lu %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64" "
450 "%d %d %"PRIu64" "
451 "%lld %"PRIu64" %"PRId64" %lu %"PRIu64" "
452 "%lu %lu %lu "
453 "%u %u "
454 "%u %u %u %u "
455 "%"PRIu64" %"PRIu64" %"PRIu64" %d %"PRIu64"\n",
456
457 ki.p_pid, /* 1 pid */
458 ki.p_comm, /* 2 tcomm */
459 "0RRSTZXR8"[(ki.p_stat > 8) ? 0 : (int)ki.p_stat], /* 3 state */
460 ki.p_ppid, /* 4 ppid */
461 ki.p__pgid, /* 5 pgrp */
462 ki.p_sid, /* 6 sid */
463 (ki.p_tdev != (uint32_t)NODEV) ? ki.p_tdev : 0, /* 7 tty_nr */
464 ki.p_tpgid, /* 8 tty_pgrp */
465
466 ki.p_flag, /* 9 flags */
467
468 ki.p_uru_minflt, /* 10 min_flt */
469 cru->ru_minflt,
470 ki.p_uru_majflt, /* 12 maj_flt */
471 cru->ru_majflt,
472 UTIME2TICKS(ki.p_uutime_sec, ki.p_uutime_usec), /* 14 utime */
473 UTIME2TICKS(ki.p_ustime_sec, ki.p_ustime_usec), /* 15 stime */
474 UTIME2TICKS(cru->ru_utime.tv_sec, cru->ru_utime.tv_usec), /* 16 cutime */
475 UTIME2TICKS(cru->ru_stime.tv_sec, cru->ru_stime.tv_usec), /* 17 cstime */
476
477 ki.p_priority, /* XXX: 18 priority */
478 ki.p_nice - NZERO, /* 19 nice */
479 ki.p_nlwps, /* 20 num_threads */
480
481 (long long)rt.tv_sec,
482 UTIME2TICKS(ki.p_ustart_sec, ki.p_ustart_usec), /* 22 start_time */
483 ki.p_vm_msize, /* 23 vsize */
484 PGTOKB(ki.p_vm_rssize), /* 24 rss */
485 p->p_rlimit[RLIMIT_RSS].rlim_cur, /* 25 rsslim */
486
487 stext, /* 26 start_code */
488 etext, /* 27 end_code */
489 sstack, /* 28 start_stack */
490
491 0, /* XXX: 29 esp */
492 0, /* XXX: 30 eip */
493
494 ki.p_siglist.__bits[0], /* XXX: 31 pending */
495 0, /* XXX: 32 blocked */
496 ki.p_sigignore.__bits[0], /* 33 sigign */
497 ki.p_sigcatch.__bits[0], /* 34 sigcatch */
498
499 ki.p_wchan, /* 35 wchan */
500 ki.p_uru_nvcsw,
501 ki.p_uru_nivcsw,
502 ki.p_exitsig, /* 38 exit_signal */
503 ki.p_cpuid); /* 39 task_cpu */
504
505 mutex_exit(p->p_lock);
506 mutex_exit(proc_lock);
507
508 uvmspace_free(vm);
509
510 if (len == 0)
511 goto out;
512
513 error = uiomove_frombuf(bf, len, uio);
514out:
515 free(bf, M_TEMP);
516 return error;
517}
518
519int
520procfs_docpuinfo(struct lwp *curl, struct proc *p,
521 struct pfsnode *pfs, struct uio *uio)
522{
523 size_t len = LBFSZ;
524 char *bf = NULL;
525 int error;
526
527 do {
528 if (bf)
529 free(bf, M_TEMP);
530 bf = malloc(len, M_TEMP, M_WAITOK);
531 } while (procfs_getcpuinfstr(bf, &len) < 0);
532
533 if (len == 0) {
534 error = 0;
535 goto done;
536 }
537
538 error = uiomove_frombuf(bf, len, uio);
539done:
540 free(bf, M_TEMP);
541 return error;
542}
543
544int
545procfs_douptime(struct lwp *curl, struct proc *p,
546 struct pfsnode *pfs, struct uio *uio)
547{
548 char *bf;
549 int len;
550 struct timeval runtime;
551 u_int64_t idle;
552 int error = 0;
553
554 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
555
556 microuptime(&runtime);
557 idle = curcpu()->ci_schedstate.spc_cp_time[CP_IDLE];
558 len = snprintf(bf, LBFSZ,
559 "%lld.%02lu %" PRIu64 ".%02" PRIu64 "\n",
560 (long long)runtime.tv_sec, (long)runtime.tv_usec / 10000,
561 idle / hz, (((idle % hz) * 100) / hz) % 100);
562
563 if (len == 0)
564 goto out;
565
566 error = uiomove_frombuf(bf, len, uio);
567out:
568 free(bf, M_TEMP);
569 return error;
570}
571
572static int
573procfs_format_sfs(char **mtab, size_t *mlen, char *buf, size_t blen,
574 const struct statvfs *sfs, struct lwp *curl, int suser)
575{
576 const char *fsname;
577
578 /* Linux uses different names for some filesystems */
579 fsname = sfs->f_fstypename;
580 if (strcmp(fsname, "procfs") == 0)
581 fsname = "proc";
582 else if (strcmp(fsname, "ext2fs") == 0)
583 fsname = "ext2";
584
585 blen = snprintf(buf, blen, "%s %s %s %s%s%s%s%s%s 0 0\n",
586 sfs->f_mntfromname, sfs->f_mntonname, fsname,
587 (sfs->f_flag & ST_RDONLY) ? "ro" : "rw",
588 (sfs->f_flag & ST_NOSUID) ? ",nosuid" : "",
589 (sfs->f_flag & ST_NOEXEC) ? ",noexec" : "",
590 (sfs->f_flag & ST_NODEV) ? ",nodev" : "",
591 (sfs->f_flag & ST_SYNCHRONOUS) ? ",sync" : "",
592 (sfs->f_flag & ST_NOATIME) ? ",noatime" : "");
593
594 *mtab = realloc(*mtab, *mlen + blen, M_TEMP, M_WAITOK);
595 memcpy(*mtab + *mlen, buf, blen);
596 *mlen += blen;
597 return sfs->f_mntonname[0] == '/' && sfs->f_mntonname[1] == '\0';
598}
599
600int
601procfs_domounts(struct lwp *curl, struct proc *p,
602 struct pfsnode *pfs, struct uio *uio)
603{
604 char *bf, *mtab = NULL;
605 size_t mtabsz = 0;
606 struct mount *mp, *nmp;
607 int error = 0, root = 0;
608 struct cwdinfo *cwdi = curl->l_proc->p_cwdi;
609
610 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
611
612 mutex_enter(&mountlist_lock);
613 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
614 struct statvfs sfs;
615
616 if (vfs_busy(mp, &nmp))
617 continue;
618
619 if ((error = dostatvfs(mp, &sfs, curl, MNT_WAIT, 0)) == 0)
620 root |= procfs_format_sfs(&mtab, &mtabsz, bf, LBFSZ,
621 &sfs, curl, 0);
622
623 vfs_unbusy(mp, false, &nmp);
624 }
625 mutex_exit(&mountlist_lock);
626
627 /*
628 * If we are inside a chroot that is not itself a mount point,
629 * fake a root entry.
630 */
631 if (!root && cwdi->cwdi_rdir)
632 (void)procfs_format_sfs(&mtab, &mtabsz, bf, LBFSZ,
633 &cwdi->cwdi_rdir->v_mount->mnt_stat, curl, 1);
634
635 free(bf, M_TEMP);
636
637 if (mtabsz > 0) {
638 error = uiomove_frombuf(mtab, mtabsz, uio);
639 free(mtab, M_TEMP);
640 }
641
642 return error;
643}
644
645/*
646 * Linux compatible /proc/version. Only active when the -o linux
647 * mountflag is used.
648 */
649int
650procfs_doversion(struct lwp *curl, struct proc *p,
651 struct pfsnode *pfs, struct uio *uio)
652{
653 char *bf;
654 char lostype[20], losrelease[20], lversion[80];
655 const char *postype, *posrelease, *pversion;
656 const char *emulname = curlwp->l_proc->p_emul->e_name;
657 int len;
658 int error = 0;
659 int nm[4];
660 size_t buflen;
661
662 CTASSERT(EMUL_LINUX_KERN_OSTYPE == EMUL_LINUX32_KERN_OSTYPE);
663 CTASSERT(EMUL_LINUX_KERN_OSRELEASE == EMUL_LINUX32_KERN_OSRELEASE);
664 CTASSERT(EMUL_LINUX_KERN_VERSION == EMUL_LINUX32_KERN_VERSION);
665
666 bf = malloc(LBFSZ, M_TEMP, M_WAITOK);
667
668 sysctl_lock(false);
669
670 if (strncmp(emulname, "linux", 5) == 0) {
671 /*
672 * Lookup the emulation ostype, osrelease, and version.
673 * Since compat_linux and compat_linux32 can be built as
674 * modules, we use sysctl to obtain the values instead of
675 * using the symbols directly.
676 */
677
678 if (strcmp(emulname, "linux32") == 0) {
679 nm[0] = CTL_EMUL;
680 nm[1] = EMUL_LINUX32;
681 nm[2] = EMUL_LINUX32_KERN;
682 } else {
683 nm[0] = CTL_EMUL;
684 nm[1] = EMUL_LINUX;
685 nm[2] = EMUL_LINUX_KERN;
686 }
687
688 nm[3] = EMUL_LINUX_KERN_OSTYPE;
689 buflen = sizeof(lostype);
690 error = sysctl_dispatch(nm, __arraycount(nm),
691 lostype, &buflen,
692 NULL, 0, NULL, NULL, NULL);
693 if (error)
694 goto out;
695
696 nm[3] = EMUL_LINUX_KERN_OSRELEASE;
697 buflen = sizeof(losrelease);
698 error = sysctl_dispatch(nm, __arraycount(nm),
699 losrelease, &buflen,
700 NULL, 0, NULL, NULL, NULL);
701 if (error)
702 goto out;
703
704 nm[3] = EMUL_LINUX_KERN_VERSION;
705 buflen = sizeof(lversion);
706 error = sysctl_dispatch(nm, __arraycount(nm),
707 lversion, &buflen,
708 NULL, 0, NULL, NULL, NULL);
709 if (error)
710 goto out;
711
712 postype = lostype;
713 posrelease = losrelease;
714 pversion = lversion;
715 } else {
716 postype = ostype;
717 posrelease = osrelease;
718 strlcpy(lversion, version, sizeof(lversion));
719 if (strchr(lversion, '\n'))
720 *strchr(lversion, '\n') = '\0';
721 pversion = lversion;
722 }
723
724 len = snprintf(bf, LBFSZ,
725 "%s version %s (%s@localhost) (gcc version %s) %s\n",
726 postype, posrelease, emulname,
727#ifdef __VERSION__
728 __VERSION__,
729#else
730 "unknown",
731#endif
732 pversion);
733
734 if (len == 0)
735 goto out;
736
737 error = uiomove_frombuf(bf, len, uio);
738out:
739 free(bf, M_TEMP);
740 sysctl_unlock();
741 return error;
742}
743