| 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 | |
| 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 | 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); |
| 407 | out: |
| 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 | */ |
| 418 | int |
| 419 | procfs_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); |
| 514 | out: |
| 515 | free(bf, M_TEMP); |
| 516 | return error; |
| 517 | } |
| 518 | |
| 519 | int |
| 520 | procfs_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); |
| 539 | done: |
| 540 | free(bf, M_TEMP); |
| 541 | return error; |
| 542 | } |
| 543 | |
| 544 | int |
| 545 | procfs_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); |
| 567 | out: |
| 568 | free(bf, M_TEMP); |
| 569 | return error; |
| 570 | } |
| 571 | |
| 572 | static int |
| 573 | procfs_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 | |
| 600 | int |
| 601 | procfs_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 | */ |
| 649 | int |
| 650 | procfs_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); |
| 738 | out: |
| 739 | free(bf, M_TEMP); |
| 740 | sysctl_unlock(); |
| 741 | return error; |
| 742 | } |
| 743 | |