procfs_linux.c revision 1.39.8.4
1 /* procfs_linux.c,v 1.39.8.3 2008/01/09 01:57:05 matt 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, "procfs_linux.c,v 1.39.8.3 2008/01/09 01:57:05 matt 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_USRSTACK32 99 if (strcmp(p->p_emul->e_name, "linux32") == 0 && 100 LINUX_USRSTACK32 < USRSTACK32) 101 *sstack = (unsigned long)LINUX_USRSTACK32; 102 else 103 #endif 104 #ifdef LINUX_USRSTACK 105 if (strcmp(p->p_emul->e_name, "linux") == 0 && 106 LINUX_USRSTACK < USRSTACK) 107 *sstack = (unsigned long)LINUX_USRSTACK; 108 else 109 #endif 110 #ifdef USRSTACK32 111 if (strstr(p->p_emul->e_name, "32") != NULL) 112 *sstack = (unsigned long)USRSTACK32; 113 else 114 #endif 115 *sstack = (unsigned long)USRSTACK; 116 117 /* 118 * jdk 1.6 compares low <= addr && addr < high 119 * if we put addr == high, then the test fails 120 * so eat one page. 121 */ 122 *sstack -= PAGE_SIZE; 123 124 vm_map_unlock_read(map); 125 uvmspace_free(vm); 126 } 127 128 /* 129 * Linux compatible /proc/meminfo. Only active when the -o linux 130 * mountflag is used. 131 */ 132 int 133 procfs_domeminfo(struct lwp *curl, struct proc *p, 134 struct pfsnode *pfs, struct uio *uio) 135 { 136 char *bf; 137 int len; 138 int error = 0; 139 140 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 141 142 len = snprintf(bf, LBFSZ, 143 " total: used: free: shared: buffers: cached:\n" 144 "Mem: %8lu %8lu %8lu %8lu %8lu %8lu\n" 145 "Swap: %8lu %8lu %8lu\n" 146 "MemTotal: %8lu kB\n" 147 "MemFree: %8lu kB\n" 148 "MemShared: %8lu kB\n" 149 "Buffers: %8lu kB\n" 150 "Cached: %8lu kB\n" 151 "SwapTotal: %8lu kB\n" 152 "SwapFree: %8lu kB\n", 153 PGTOB(uvmexp.npages), 154 PGTOB(uvmexp.npages - uvmexp.free), 155 PGTOB(uvmexp.free), 156 0L, 157 PGTOB(uvmexp.filepages), 158 PGTOB(uvmexp.anonpages + uvmexp.filepages + uvmexp.execpages), 159 PGTOB(uvmexp.swpages), 160 PGTOB(uvmexp.swpginuse), 161 PGTOB(uvmexp.swpages - uvmexp.swpginuse), 162 PGTOKB(uvmexp.npages), 163 PGTOKB(uvmexp.free), 164 0L, 165 PGTOKB(uvmexp.filepages), 166 PGTOKB(uvmexp.anonpages + uvmexp.filepages + uvmexp.execpages), 167 PGTOKB(uvmexp.swpages), 168 PGTOKB(uvmexp.swpages - uvmexp.swpginuse)); 169 170 if (len == 0) 171 goto out; 172 173 error = uiomove_frombuf(bf, len, uio); 174 out: 175 free(bf, M_TEMP); 176 return error; 177 } 178 179 /* 180 * Linux compatible /proc/devices. Only active when the -o linux 181 * mountflag is used. 182 */ 183 int 184 procfs_dodevices(struct lwp *curl, struct proc *p, 185 struct pfsnode *pfs, struct uio *uio) 186 { 187 char *bf; 188 int offset = 0; 189 int i, error = ENAMETOOLONG; 190 extern kmutex_t devsw_lock; 191 192 /* XXX elad - may need filtering. */ 193 194 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 195 196 offset += snprintf(&bf[offset], LBFSZ - offset, "Character devices:\n"); 197 if (offset >= LBFSZ) 198 goto out; 199 200 mutex_enter(&devsw_lock); 201 for (i = 0; i < max_devsw_convs; i++) { 202 if ((devsw_conv[i].d_name == NULL) || 203 (devsw_conv[i].d_cmajor == -1)) 204 continue; 205 206 offset += snprintf(&bf[offset], LBFSZ - offset, 207 "%3d %s\n", devsw_conv[i].d_cmajor, devsw_conv[i].d_name); 208 if (offset >= LBFSZ) { 209 mutex_exit(&devsw_lock); 210 goto out; 211 } 212 } 213 214 offset += snprintf(&bf[offset], LBFSZ - offset, "\nBlock devices:\n"); 215 if (offset >= LBFSZ) { 216 mutex_exit(&devsw_lock); 217 goto out; 218 } 219 220 for (i = 0; i < max_devsw_convs; i++) { 221 if ((devsw_conv[i].d_name == NULL) || 222 (devsw_conv[i].d_bmajor == -1)) 223 continue; 224 225 offset += snprintf(&bf[offset], LBFSZ - offset, 226 "%3d %s\n", devsw_conv[i].d_bmajor, devsw_conv[i].d_name); 227 if (offset >= LBFSZ) { 228 mutex_exit(&devsw_lock); 229 goto out; 230 } 231 } 232 mutex_exit(&devsw_lock); 233 234 error = uiomove_frombuf(bf, offset, uio); 235 out: 236 free(bf, M_TEMP); 237 return error; 238 } 239 240 /* 241 * Linux compatible /proc/stat. Only active when the -o linux 242 * mountflag is used. 243 */ 244 int 245 procfs_docpustat(struct lwp *curl, struct proc *p, 246 struct pfsnode *pfs, struct uio *uio) 247 { 248 char *bf; 249 int error; 250 int len; 251 #if defined(MULTIPROCESSOR) 252 struct cpu_info *ci; 253 CPU_INFO_ITERATOR cii; 254 #endif 255 int i; 256 257 error = ENAMETOOLONG; 258 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 259 260 len = snprintf(bf, LBFSZ, 261 "cpu %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 262 curcpu()->ci_schedstate.spc_cp_time[CP_USER], 263 curcpu()->ci_schedstate.spc_cp_time[CP_NICE], 264 curcpu()->ci_schedstate.spc_cp_time[CP_SYS] /*+ [CP_INTR]*/, 265 curcpu()->ci_schedstate.spc_cp_time[CP_IDLE]); 266 if (len == 0) 267 goto out; 268 269 #if defined(MULTIPROCESSOR) 270 #define ALLCPUS CPU_INFO_FOREACH(cii, ci) 271 #define CPUNAME ci 272 #else 273 #define ALLCPUS ; i < 1 ; 274 #define CPUNAME curcpu() 275 #endif 276 277 i = 0; 278 for (ALLCPUS) { 279 len += snprintf(&bf[len], LBFSZ - len, 280 "cpu%d %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 281 "\n", i, 282 CPUNAME->ci_schedstate.spc_cp_time[CP_USER], 283 CPUNAME->ci_schedstate.spc_cp_time[CP_NICE], 284 CPUNAME->ci_schedstate.spc_cp_time[CP_SYS], 285 CPUNAME->ci_schedstate.spc_cp_time[CP_IDLE]); 286 if (len >= LBFSZ) 287 goto out; 288 i += 1; 289 } 290 291 len += snprintf(&bf[len], LBFSZ - len, 292 "disk 0 0 0 0\n" 293 "page %u %u\n" 294 "swap %u %u\n" 295 "intr %u\n" 296 "ctxt %u\n" 297 "btime %lld\n", 298 uvmexp.pageins, uvmexp.pdpageouts, 299 uvmexp.pgswapin, uvmexp.pgswapout, 300 uvmexp.intrs, 301 uvmexp.swtch, 302 (long long)boottime.tv_sec); 303 if (len >= LBFSZ) 304 goto out; 305 306 error = uiomove_frombuf(bf, len, uio); 307 out: 308 free(bf, M_TEMP); 309 return error; 310 } 311 312 /* 313 * Linux compatible /proc/loadavg. Only active when the -o linux 314 * mountflag is used. 315 */ 316 int 317 procfs_doloadavg(struct lwp *curl, struct proc *p, 318 struct pfsnode *pfs, struct uio *uio) 319 { 320 char *bf; 321 int error; 322 int len; 323 324 error = ENAMETOOLONG; 325 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 326 327 averunnable.fscale = FSCALE; 328 len = snprintf(bf, LBFSZ, 329 "%d.%02d %d.%02d %d.%02d %d/%d %d\n", 330 (int)(averunnable.ldavg[0] / averunnable.fscale), 331 (int)(averunnable.ldavg[0] * 100 / averunnable.fscale % 100), 332 (int)(averunnable.ldavg[1] / averunnable.fscale), 333 (int)(averunnable.ldavg[1] * 100 / averunnable.fscale % 100), 334 (int)(averunnable.ldavg[2] / averunnable.fscale), 335 (int)(averunnable.ldavg[2] * 100 / averunnable.fscale % 100), 336 1, /* number of ONPROC processes */ 337 nprocs, 338 30000); /* last pid */ 339 if (len == 0) 340 goto out; 341 342 error = uiomove_frombuf(bf, len, uio); 343 out: 344 free(bf, M_TEMP); 345 return error; 346 } 347 348 /* 349 * Linux compatible /proc/<pid>/statm. Only active when the -o linux 350 * mountflag is used. 351 */ 352 int 353 procfs_do_pid_statm(struct lwp *curl, struct lwp *l, 354 struct pfsnode *pfs, struct uio *uio) 355 { 356 struct vmspace *vm; 357 struct proc *p = l->l_proc; 358 struct rusage *ru = &p->p_stats->p_ru; 359 char *bf; 360 int error; 361 int len; 362 363 error = ENAMETOOLONG; 364 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 365 366 /* XXX - we use values from vmspace, since dsl says that ru figures 367 are always 0 except for zombies. See kvm_proc.c::kvm_getproc2() */ 368 if ((error = proc_vmspace_getref(p, &vm)) != 0) { 369 goto out; 370 } 371 372 len = snprintf(bf, LBFSZ, 373 "%lu %lu %lu %lu %lu %lu %lu\n", 374 (unsigned long)(vm->vm_tsize + vm->vm_dsize + vm->vm_ssize), /* size */ 375 (unsigned long)(vm->vm_rssize), /* resident */ 376 (unsigned long)(ru->ru_ixrss), /* shared */ 377 (unsigned long)(vm->vm_tsize), /* text size in pages */ 378 (unsigned long)(vm->vm_dsize), /* data size in pages */ 379 (unsigned long)(vm->vm_ssize), /* stack size in pages */ 380 (unsigned long) 0); 381 382 if (len == 0) 383 goto out; 384 385 error = uiomove_frombuf(bf, len, uio); 386 out: 387 free(bf, M_TEMP); 388 return error; 389 } 390 391 #define USEC_2_TICKS(x) ((x) / 10000) 392 393 /* 394 * Linux compatible /proc/<pid>/stat. Only active when the -o linux 395 * mountflag is used. 396 */ 397 int 398 procfs_do_pid_stat(struct lwp *curl, struct lwp *l, 399 struct pfsnode *pfs, struct uio *uio) 400 { 401 char *bf; 402 struct proc *p = l->l_proc; 403 int len; 404 struct tty *tty = p->p_session->s_ttyp; 405 struct rusage *ru = &p->p_stats->p_ru; 406 struct rusage *cru = &p->p_stats->p_cru; 407 unsigned long stext = 0, etext = 0, sstack = 0; 408 struct timeval rt; 409 struct vmspace *vm; 410 int error = 0; 411 412 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 413 414 if ((error = proc_vmspace_getref(p, &vm)) != 0) { 415 goto out; 416 } 417 418 get_proc_size_info(l, &stext, &etext, &sstack); 419 420 mutex_enter(&proclist_lock); 421 mutex_enter(&p->p_mutex); 422 mutex_enter(&p->p_smutex); 423 424 calcru(p, NULL, NULL, NULL, &rt); 425 426 len = snprintf(bf, LBFSZ, 427 "%d (%s) %c %d %d %d %d %d " 428 "%u " 429 "%lu %lu %lu %lu %lu %lu %lu %lu " 430 "%d %d %d " 431 "%lu %lu %lu %lu %" PRIu64 " " 432 "%lu %lu %lu " 433 "%u %u " 434 "%u %u %u %u " 435 "%lu %lu %lu %d %d\n", 436 437 p->p_pid, 438 p->p_comm, 439 "0IR3SZD"[(p->p_stat > 6) ? 0 : (int)p->p_stat], 440 (p->p_pptr != NULL) ? p->p_pptr->p_pid : 0, 441 442 p->p_pgid, 443 p->p_session->s_sid, 444 tty ? tty->t_dev : 0, 445 (tty && tty->t_pgrp) ? tty->t_pgrp->pg_id : 0, 446 447 p->p_flag, 448 449 ru->ru_minflt, 450 cru->ru_minflt, 451 ru->ru_majflt, 452 cru->ru_majflt, 453 USEC_2_TICKS(ru->ru_utime.tv_usec), 454 USEC_2_TICKS(ru->ru_stime.tv_usec), 455 USEC_2_TICKS(cru->ru_utime.tv_usec), 456 USEC_2_TICKS(cru->ru_stime.tv_usec), 457 458 l->l_priority, /* XXX: priority */ 459 p->p_nice - 20, 460 0, 461 462 rt.tv_sec, 463 p->p_stats->p_start.tv_sec, 464 (unsigned long)(vm->vm_tsize + vm->vm_dsize + vm->vm_ssize), /* size */ 465 (unsigned long)(vm->vm_rssize), /* resident */ 466 p->p_rlimit[RLIMIT_RSS].rlim_cur, 467 468 stext, /* start code */ 469 etext, /* end code */ 470 sstack, /* mm start stack */ 471 0, /* XXX: pc */ 472 0, /* XXX: sp */ 473 p->p_sigpend.sp_set.__bits[0], /* XXX: pending */ 474 0, /* XXX: held */ 475 p->p_sigctx.ps_sigignore.__bits[0], /* ignored */ 476 p->p_sigctx.ps_sigcatch.__bits[0], /* caught */ 477 478 (unsigned long)(intptr_t)l->l_wchan, 479 ru->ru_nvcsw, 480 ru->ru_nivcsw, 481 p->p_exitsig, 482 0); /* XXX: processor */ 483 484 mutex_exit(&p->p_smutex); 485 mutex_exit(&p->p_mutex); 486 mutex_exit(&proclist_lock); 487 488 if (len == 0) 489 goto out; 490 491 error = uiomove_frombuf(bf, len, uio); 492 out: 493 free(bf, M_TEMP); 494 return error; 495 } 496 497 int 498 procfs_docpuinfo(struct lwp *curl, struct proc *p, 499 struct pfsnode *pfs, struct uio *uio) 500 { 501 int len = LBFSZ; 502 char *bf = malloc(len, M_TEMP, M_WAITOK); 503 int error; 504 505 if (procfs_getcpuinfstr(bf, &len) < 0) { 506 error = ENOSPC; 507 goto done; 508 } 509 510 if (len == 0) { 511 error = 0; 512 goto done; 513 } 514 515 error = uiomove_frombuf(bf, len, uio); 516 done: 517 free(bf, M_TEMP); 518 return error; 519 } 520 521 int 522 procfs_douptime(struct lwp *curl, struct proc *p, 523 struct pfsnode *pfs, struct uio *uio) 524 { 525 char *bf; 526 int len; 527 struct timeval runtime; 528 u_int64_t idle; 529 int error = 0; 530 531 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 532 533 microuptime(&runtime); 534 idle = curcpu()->ci_schedstate.spc_cp_time[CP_IDLE]; 535 len = snprintf(bf, LBFSZ, 536 "%lu.%02lu %" PRIu64 ".%02" PRIu64 "\n", 537 runtime.tv_sec, runtime.tv_usec / 10000, 538 idle / hz, (((idle % hz) * 100) / hz) % 100); 539 540 if (len == 0) 541 goto out; 542 543 error = uiomove_frombuf(bf, len, uio); 544 out: 545 free(bf, M_TEMP); 546 return error; 547 } 548 549 int 550 procfs_domounts(struct lwp *curl, struct proc *p, 551 struct pfsnode *pfs, struct uio *uio) 552 { 553 char *bf, *mtab = NULL; 554 const char *fsname; 555 size_t len, mtabsz = 0; 556 struct mount *mp, *nmp; 557 struct statvfs *sfs; 558 int error = 0; 559 560 bf = malloc(LBFSZ, M_TEMP, M_WAITOK); 561 mutex_enter(&mountlist_lock); 562 for (mp = CIRCLEQ_FIRST(&mountlist); mp != (void *)&mountlist; 563 mp = nmp) { 564 if (vfs_trybusy(mp, RW_READER, &mountlist_lock)) { 565 nmp = CIRCLEQ_NEXT(mp, mnt_list); 566 continue; 567 } 568 569 sfs = &mp->mnt_stat; 570 571 /* Linux uses different names for some filesystems */ 572 fsname = sfs->f_fstypename; 573 if (strcmp(fsname, "procfs") == 0) 574 fsname = "proc"; 575 else if (strcmp(fsname, "ext2fs") == 0) 576 fsname = "ext2"; 577 578 len = snprintf(bf, LBFSZ, "%s %s %s %s%s%s%s%s%s 0 0\n", 579 sfs->f_mntfromname, 580 sfs->f_mntonname, 581 fsname, 582 (mp->mnt_flag & MNT_RDONLY) ? "ro" : "rw", 583 (mp->mnt_flag & MNT_NOSUID) ? ",nosuid" : "", 584 (mp->mnt_flag & MNT_NOEXEC) ? ",noexec" : "", 585 (mp->mnt_flag & MNT_NODEV) ? ",nodev" : "", 586 (mp->mnt_flag & MNT_SYNCHRONOUS) ? ",sync" : "", 587 (mp->mnt_flag & MNT_NOATIME) ? ",noatime" : "" 588 ); 589 590 mtab = realloc(mtab, mtabsz + len, M_TEMP, M_WAITOK); 591 memcpy(mtab + mtabsz, bf, len); 592 mtabsz += len; 593 594 mutex_enter(&mountlist_lock); 595 nmp = CIRCLEQ_NEXT(mp, mnt_list); 596 vfs_unbusy(mp, false); 597 } 598 mutex_exit(&mountlist_lock); 599 free(bf, M_TEMP); 600 601 if (mtabsz > 0) { 602 error = uiomove_frombuf(mtab, mtabsz, uio); 603 free(mtab, M_TEMP); 604 } 605 606 return error; 607 } 608
Indexes created Fri Sep 26 08:10:20 GMT 2025