1 /* $NetBSD: procfs_linux.c,v 1.75 2019/08/23 14:12:39 maxv 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.75 2019/08/23 14:12:39 maxv 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 69 extern struct devsw_conv *devsw_conv; 70 extern 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 77 static void 78 get_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 */ 138 int 139 procfs_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); 180 out: 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 */ 189 int 190 procfs_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); 240 out: 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 */ 249 int 250 procfs_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); 318 out: 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 */ 327 int 328 procfs_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); 354 out: 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 */ 363 int 364 procfs_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 memset(&ki, 0, sizeof(ki)); 387 fill_kproc2(p, &ki, false, false); 388 389 mutex_exit(p->p_lock); 390 mutex_exit(proc_lock); 391 392 uvmspace_free(vm); 393 394 len = snprintf(bf, LBFSZ, 395 "%lu %lu %lu %lu %lu %lu %lu\n", 396 (unsigned long)(ki.p_vm_msize), /* size */ 397 (unsigned long)(ki.p_vm_rssize),/* resident */ 398 (unsigned long)(ki.p_uru_ixrss),/* shared */ 399 (unsigned long)(ki.p_vm_tsize), /* text */ 400 (unsigned long) 0, /* library (unused) */ 401 (unsigned long)(ki.p_vm_dsize + ki.p_vm_ssize), /* data+stack */ 402 (unsigned long) 0); /* dirty */ 403 404 if (len == 0) 405 goto out; 406 407 error = uiomove_frombuf(bf, len, uio); 408 out: 409 free(bf, M_TEMP); 410 return error; 411 } 412 413 #define UTIME2TICKS(s,u) (((uint64_t)(s) * 1000000 + (u)) / 10000) 414 415 /* 416 * Linux compatible /proc/<pid>/stat. Only active when the -o linux 417 * mountflag is used. 418 */ 419 int 420 procfs_do_pid_stat(struct lwp *curl, struct lwp *l, 421 struct pfsnode *pfs, struct uio *uio) 422 { 423 char *bf; 424 struct proc *p = l->l_proc; 425 int len; 426 struct rusage *cru = &p->p_stats->p_cru; 427 unsigned long stext = 0, etext = 0, sstack = 0; 428 struct timeval rt; 429 struct vmspace *vm; 430 struct kinfo_proc2 ki; 431 int error; 432 433 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 434 435 if ((error = proc_vmspace_getref(p, &vm)) != 0) { 436 goto out; 437 } 438 439 get_proc_size_info(l, &stext, &etext, &sstack); 440 441 mutex_enter(proc_lock); 442 mutex_enter(p->p_lock); 443 444 memset(&ki, 0, sizeof(ki)); 445 fill_kproc2(p, &ki, false, false); 446 calcru(p, NULL, NULL, NULL, &rt); 447 448 len = snprintf(bf, LBFSZ, 449 "%d (%s) %c %d %d %d %u %d " 450 "%u " 451 "%"PRIu64" %lu %"PRIu64" %lu %"PRIu64" %"PRIu64" %"PRIu64" %"PRIu64" " 452 "%d %d %"PRIu64" " 453 "%lld %"PRIu64" %"PRId64" %lu %"PRIu64" " 454 "%lu %lu %lu " 455 "%u %u " 456 "%u %u %u %u " 457 "%"PRIu64" %"PRIu64" %"PRIu64" %d %"PRIu64"\n", 458 459 ki.p_pid, /* 1 pid */ 460 ki.p_comm, /* 2 tcomm */ 461 "0RRSTZXR8"[(ki.p_stat > 8) ? 0 : (int)ki.p_stat], /* 3 state */ 462 ki.p_ppid, /* 4 ppid */ 463 ki.p__pgid, /* 5 pgrp */ 464 ki.p_sid, /* 6 sid */ 465 (ki.p_tdev != (uint32_t)NODEV) ? ki.p_tdev : 0, /* 7 tty_nr */ 466 ki.p_tpgid, /* 8 tty_pgrp */ 467 468 ki.p_flag, /* 9 flags */ 469 470 ki.p_uru_minflt, /* 10 min_flt */ 471 cru->ru_minflt, 472 ki.p_uru_majflt, /* 12 maj_flt */ 473 cru->ru_majflt, 474 UTIME2TICKS(ki.p_uutime_sec, ki.p_uutime_usec), /* 14 utime */ 475 UTIME2TICKS(ki.p_ustime_sec, ki.p_ustime_usec), /* 15 stime */ 476 UTIME2TICKS(cru->ru_utime.tv_sec, cru->ru_utime.tv_usec), /* 16 cutime */ 477 UTIME2TICKS(cru->ru_stime.tv_sec, cru->ru_stime.tv_usec), /* 17 cstime */ 478 479 ki.p_priority, /* XXX: 18 priority */ 480 ki.p_nice - NZERO, /* 19 nice */ 481 ki.p_nlwps, /* 20 num_threads */ 482 483 (long long)rt.tv_sec, 484 UTIME2TICKS(ki.p_ustart_sec, ki.p_ustart_usec), /* 22 start_time */ 485 ki.p_vm_msize, /* 23 vsize */ 486 PGTOKB(ki.p_vm_rssize), /* 24 rss */ 487 p->p_rlimit[RLIMIT_RSS].rlim_cur, /* 25 rsslim */ 488 489 stext, /* 26 start_code */ 490 etext, /* 27 end_code */ 491 sstack, /* 28 start_stack */ 492 493 0, /* XXX: 29 esp */ 494 0, /* XXX: 30 eip */ 495 496 ki.p_siglist.__bits[0], /* XXX: 31 pending */ 497 0, /* XXX: 32 blocked */ 498 ki.p_sigignore.__bits[0], /* 33 sigign */ 499 ki.p_sigcatch.__bits[0], /* 34 sigcatch */ 500 501 ki.p_wchan, /* 35 wchan */ 502 ki.p_uru_nvcsw, 503 ki.p_uru_nivcsw, 504 ki.p_exitsig, /* 38 exit_signal */ 505 ki.p_cpuid); /* 39 task_cpu */ 506 507 mutex_exit(p->p_lock); 508 mutex_exit(proc_lock); 509 510 uvmspace_free(vm); 511 512 if (len == 0) 513 goto out; 514 515 error = uiomove_frombuf(bf, len, uio); 516 out: 517 free(bf, M_TEMP); 518 return error; 519 } 520 521 int 522 procfs_docpuinfo(struct lwp *curl, struct proc *p, 523 struct pfsnode *pfs, struct uio *uio) 524 { 525 size_t len = LBFSZ; 526 char *bf = NULL; 527 int error; 528 529 do { 530 if (bf) 531 free(bf, M_TEMP); 532 bf = malloc(len, M_TEMP, M_WAITOK); 533 } while (procfs_getcpuinfstr(bf, &len) < 0); 534 535 if (len == 0) { 536 error = 0; 537 goto done; 538 } 539 540 error = uiomove_frombuf(bf, len, uio); 541 done: 542 free(bf, M_TEMP); 543 return error; 544 } 545 546 int 547 procfs_douptime(struct lwp *curl, struct proc *p, 548 struct pfsnode *pfs, struct uio *uio) 549 { 550 char *bf; 551 int len; 552 struct timeval runtime; 553 u_int64_t idle; 554 int error = 0; 555 556 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 557 558 microuptime(&runtime); 559 idle = curcpu()->ci_schedstate.spc_cp_time[CP_IDLE]; 560 len = snprintf(bf, LBFSZ, 561 "%lld.%02lu %" PRIu64 ".%02" PRIu64 "\n", 562 (long long)runtime.tv_sec, (long)runtime.tv_usec / 10000, 563 idle / hz, (((idle % hz) * 100) / hz) % 100); 564 565 if (len == 0) 566 goto out; 567 568 error = uiomove_frombuf(bf, len, uio); 569 out: 570 free(bf, M_TEMP); 571 return error; 572 } 573 574 static int 575 procfs_format_sfs(char **mtab, size_t *mlen, char *buf, size_t blen, 576 const struct statvfs *sfs, struct lwp *curl, int suser) 577 { 578 const char *fsname; 579 580 /* Linux uses different names for some filesystems */ 581 fsname = sfs->f_fstypename; 582 if (strcmp(fsname, "procfs") == 0) 583 fsname = "proc"; 584 else if (strcmp(fsname, "ext2fs") == 0) 585 fsname = "ext2"; 586 587 blen = snprintf(buf, blen, "%s %s %s %s%s%s%s%s%s 0 0\n", 588 sfs->f_mntfromname, sfs->f_mntonname, fsname, 589 (sfs->f_flag & ST_RDONLY) ? "ro" : "rw", 590 (sfs->f_flag & ST_NOSUID) ? ",nosuid" : "", 591 (sfs->f_flag & ST_NOEXEC) ? ",noexec" : "", 592 (sfs->f_flag & ST_NODEV) ? ",nodev" : "", 593 (sfs->f_flag & ST_SYNCHRONOUS) ? ",sync" : "", 594 (sfs->f_flag & ST_NOATIME) ? ",noatime" : ""); 595 596 *mtab = realloc(*mtab, *mlen + blen, M_TEMP, M_WAITOK); 597 memcpy(*mtab + *mlen, buf, blen); 598 *mlen += blen; 599 return sfs->f_mntonname[0] == '/' && sfs->f_mntonname[1] == '\0'; 600 } 601 602 int 603 procfs_domounts(struct lwp *curl, struct proc *p, 604 struct pfsnode *pfs, struct uio *uio) 605 { 606 char *bf, *mtab = NULL; 607 size_t mtabsz = 0; 608 mount_iterator_t *iter; 609 struct mount *mp; 610 int error = 0, root = 0; 611 struct cwdinfo *cwdi = curl->l_proc->p_cwdi; 612 613 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 614 615 mountlist_iterator_init(&iter); 616 while ((mp = mountlist_iterator_next(iter)) != NULL) { 617 struct statvfs sfs; 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 mountlist_iterator_destroy(iter); 624 625 /* 626 * If we are inside a chroot that is not itself a mount point, 627 * fake a root entry. 628 */ 629 if (!root && cwdi->cwdi_rdir) 630 (void)procfs_format_sfs(&mtab, &mtabsz, bf, LBFSZ, 631 &cwdi->cwdi_rdir->v_mount->mnt_stat, curl, 1); 632 633 free(bf, M_TEMP); 634 635 if (mtabsz > 0) { 636 error = uiomove_frombuf(mtab, mtabsz, uio); 637 free(mtab, M_TEMP); 638 } 639 640 return error; 641 } 642 643 /* 644 * Linux compatible /proc/version. Only active when the -o linux 645 * mountflag is used. 646 */ 647 int 648 procfs_doversion(struct lwp *curl, struct proc *p, 649 struct pfsnode *pfs, struct uio *uio) 650 { 651 char *bf; 652 char lostype[20], losrelease[20], lversion[80]; 653 const char *postype, *posrelease, *pversion; 654 const char *emulname = curlwp->l_proc->p_emul->e_name; 655 int len; 656 int error = 0; 657 int nm[4]; 658 size_t buflen; 659 660 CTASSERT(EMUL_LINUX_KERN_OSTYPE == EMUL_LINUX32_KERN_OSTYPE); 661 CTASSERT(EMUL_LINUX_KERN_OSRELEASE == EMUL_LINUX32_KERN_OSRELEASE); 662 CTASSERT(EMUL_LINUX_KERN_VERSION == EMUL_LINUX32_KERN_VERSION); 663 664 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 665 666 sysctl_lock(false); 667 668 if (strncmp(emulname, "linux", 5) == 0) { 669 /* 670 * Lookup the emulation ostype, osrelease, and version. 671 * Since compat_linux and compat_linux32 can be built as 672 * modules, we use sysctl to obtain the values instead of 673 * using the symbols directly. 674 */ 675 676 if (strcmp(emulname, "linux32") == 0) { 677 nm[0] = CTL_EMUL; 678 nm[1] = EMUL_LINUX32; 679 nm[2] = EMUL_LINUX32_KERN; 680 } else { 681 nm[0] = CTL_EMUL; 682 nm[1] = EMUL_LINUX; 683 nm[2] = EMUL_LINUX_KERN; 684 } 685 686 nm[3] = EMUL_LINUX_KERN_OSTYPE; 687 buflen = sizeof(lostype); 688 error = sysctl_dispatch(nm, __arraycount(nm), 689 lostype, &buflen, 690 NULL, 0, NULL, NULL, NULL); 691 if (error) 692 goto out; 693 694 nm[3] = EMUL_LINUX_KERN_OSRELEASE; 695 buflen = sizeof(losrelease); 696 error = sysctl_dispatch(nm, __arraycount(nm), 697 losrelease, &buflen, 698 NULL, 0, NULL, NULL, NULL); 699 if (error) 700 goto out; 701 702 nm[3] = EMUL_LINUX_KERN_VERSION; 703 buflen = sizeof(lversion); 704 error = sysctl_dispatch(nm, __arraycount(nm), 705 lversion, &buflen, 706 NULL, 0, NULL, NULL, NULL); 707 if (error) 708 goto out; 709 710 postype = lostype; 711 posrelease = losrelease; 712 pversion = lversion; 713 } else { 714 postype = ostype; 715 posrelease = osrelease; 716 strlcpy(lversion, version, sizeof(lversion)); 717 if (strchr(lversion, '\n')) 718 *strchr(lversion, '\n') = '\0'; 719 pversion = lversion; 720 } 721 722 len = snprintf(bf, LBFSZ, 723 "%s version %s (%s@localhost) (gcc version %s) %s\n", 724 postype, posrelease, emulname, 725 #ifdef __VERSION__ 726 __VERSION__, 727 #else 728 "unknown", 729 #endif 730 pversion); 731 732 if (len == 0) 733 goto out; 734 735 error = uiomove_frombuf(bf, len, uio); 736 out: 737 free(bf, M_TEMP); 738 sysctl_unlock(); 739 return error; 740 } 741