int main(int argc, char *argv[]) { pm_kernel_t *ker; pm_process_t *proc; pid_t *pids; struct proc_info **procs; size_t num_procs; unsigned long total_pss; unsigned long total_uss; char cmdline[256]; // this must be within the range of int int error; /// M: get swap usage @{ int show_swap; /// @} #define WS_OFF 0 #define WS_ONLY 1 #define WS_RESET 2 int ws; int arg; size_t i, j; signal(SIGPIPE, SIG_IGN); compfn = &sort_by_pss; order = -1; ws = WS_OFF; /// M: get swap usage @{ show_swap = 0; /// @} for (arg = 1; arg < argc; arg++) { if (!strcmp(argv[arg], "-v")) { compfn = &sort_by_vss; continue; } if (!strcmp(argv[arg], "-r")) { compfn = &sort_by_rss; continue; } if (!strcmp(argv[arg], "-p")) { compfn = &sort_by_pss; continue; } if (!strcmp(argv[arg], "-u")) { compfn = &sort_by_uss; continue; } if (!strcmp(argv[arg], "-w")) { ws = WS_ONLY; continue; } if (!strcmp(argv[arg], "-W")) { ws = WS_RESET; continue; } if (!strcmp(argv[arg], "-R")) { order *= -1; continue; } /// M: get swap usage @{ if (!strcmp(argv[arg], "-s")) { show_swap = 1; continue; } /// @} if (!strcmp(argv[arg], "-h")) { usage(argv[0]); exit(0); } fprintf(stderr, "Invalid argument \"%s\".\n", argv[arg]); usage(argv[0]); exit(EXIT_FAILURE); } error = pm_kernel_create(&ker); if (error) { fprintf(stderr, "Error creating kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } error = pm_kernel_pids(ker, &pids, &num_procs); if (error) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } procs = calloc(num_procs, sizeof(struct proc_info*)); if (procs == NULL) { fprintf(stderr, "calloc: %s", strerror(errno)); exit(EXIT_FAILURE); } for (i = 0; i < num_procs; i++) { procs[i] = malloc(sizeof(struct proc_info)); if (procs[i] == NULL) { fprintf(stderr, "malloc: %s\n", strerror(errno)); exit(EXIT_FAILURE); } procs[i]->pid = pids[i]; pm_memusage_zero(&procs[i]->usage); error = pm_process_create(ker, pids[i], &proc); if (error) { fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]); continue; } switch (ws) { case WS_OFF: error = pm_process_usage(proc, &procs[i]->usage); break; case WS_ONLY: error = pm_process_workingset(proc, &procs[i]->usage, 0); break; case WS_RESET: error = pm_process_workingset(proc, NULL, 1); break; } if (error) { fprintf(stderr, "warning: could not read usage for %d\n", pids[i]); } pm_process_destroy(proc); } free(pids); if (ws == WS_RESET) exit(0); j = 0; for (i = 0; i < num_procs; i++) { if (procs[i]->usage.vss) { procs[j++] = procs[i]; } else { free(procs[i]); } } num_procs = j; qsort(procs, num_procs, sizeof(procs[0]), compfn); if (ws) printf("%5s %7s %7s %7s %s\n", "PID", "WRss", "WPss", "WUss", "cmdline"); else { /// M: get swap usage @{ if (show_swap) { printf("%5s %7s %7s %7s %7s %7s %7s %s\n", "PID", "Vss", "Rss", "Pss", "Uss", "Swap", "PSwap", "cmdline"); } else { printf("%5s %7s %7s %7s %7s %s\n", "PID", "Vss", "Rss", "Pss", "Uss", "cmdline"); } /// @} } total_pss = 0; total_uss = 0; for (i = 0; i < num_procs; i++) { if (getprocname(procs[i]->pid, cmdline, (int)sizeof(cmdline)) < 0) { /* * Something is probably seriously wrong if writing to the stack * failed. */ free(procs[i]); continue; } total_pss += procs[i]->usage.pss; total_uss += procs[i]->usage.uss; if (ws) printf("%5d %6dK %6dK %6dK %s\n", procs[i]->pid, procs[i]->usage.rss / 1024, procs[i]->usage.pss / 1024, procs[i]->usage.uss / 1024, cmdline ); else { /// M: get swap usage @{ if (show_swap) { printf("%5d %6dK %6dK %6dK %6dK %6dK %6dK %s\n", procs[i]->pid, procs[i]->usage.vss / 1024, procs[i]->usage.rss / 1024, procs[i]->usage.pss / 1024, procs[i]->usage.uss / 1024, procs[i]->usage.swap / 1024, procs[i]->usage.pswap / 1024, cmdline ); } else { printf("%5d %6dK %6dK %6dK %6dK %s\n", procs[i]->pid, procs[i]->usage.vss / 1024, procs[i]->usage.rss / 1024, procs[i]->usage.pss / 1024, procs[i]->usage.uss / 1024, cmdline ); } /// @} } free(procs[i]); } free(procs); if (ws) { printf("%5s %7s %7s %7s %s\n", "", "", "------", "------", "------"); printf("%5s %7s %6ldK %6ldK %s\n", "", "", total_pss / 1024, total_uss / 1024, "TOTAL"); } else { printf("%5s %7s %7s %7s %7s %s\n", "", "", "", "------", "------", "------"); printf("%5s %7s %7s %6ldK %6ldK %s\n", "", "", "", total_pss / 1024, total_uss / 1024, "TOTAL"); } printf("\n"); print_mem_info(); return 0; }
int main(int argc, char *argv[]) { pm_kernel_t *ker; pm_process_t *proc; pid_t *pids; size_t num_procs; size_t i; pm_map_t **maps; size_t num_maps; char cmdline[256]; // this must be within the range of int int error; int rc = EXIT_SUCCESS; uint8_t pr_flags = 0; struct ksm_pages kp; memset(&kp, 0, sizeof(kp)); opterr = 0; do { int c = getopt(argc, argv, "hvsa"); if (c == -1) break; switch (c) { case 'a': pr_flags |= PR_ALL; break; case 's': pr_flags |= PR_SORTED; break; case 'v': pr_flags |= PR_VERBOSE; break; case 'h': usage(argv[0]); exit(EXIT_SUCCESS); case '?': fprintf(stderr, "unknown option: %c\n", optopt); usage(argv[0]); exit(EXIT_FAILURE); } } while (1); error = pm_kernel_create(&ker); if (error) { fprintf(stderr, "Error creating kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } if (pr_flags & PR_ALL) { error = pm_kernel_pids(ker, &pids, &num_procs); if (error) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } } else { if (optind != argc - 1) { usage(argv[0]); exit(EXIT_FAILURE); } pids = malloc(sizeof(*pids)); if (pids == NULL) { fprintf(stderr, "Error allocating pid memory\n"); exit(EXIT_FAILURE); } *pids = strtoul(argv[optind], NULL, 10); if (*pids == 0) { fprintf(stderr, "Invalid PID\n"); rc = EXIT_FAILURE; goto exit; } num_procs = 1; if (getprocname(*pids, cmdline, sizeof(cmdline)) < 0) { cmdline[0] = '\0'; } printf("%s (%u):\n", cmdline, *pids); } printf("Warning: this tool only compares the KSM CRCs of pages, there is a chance of " "collisions\n"); for (i = 0; i < num_procs; i++) { error = pm_process_create(ker, pids[i], &proc); if (error) { fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]); rc = EXIT_FAILURE; goto exit; } error = pm_process_maps(proc, &maps, &num_maps); if (error) { pm_process_destroy(proc); fprintf(stderr, "warning: could not read process map for %d\n", pids[i]); rc = EXIT_FAILURE; goto exit; } if (read_pages(&kp, maps, num_maps, pr_flags) < 0) { free(maps); pm_process_destroy(proc); rc = EXIT_FAILURE; goto exit; } free(maps); pm_process_destroy(proc); } if (pr_flags & PR_SORTED) { qsort(kp.pages, kp.len, sizeof(*kp.pages), cmp_pages); } print_pages(&kp, pr_flags); exit: free_pages(&kp, pr_flags); free(pids); return rc; }
int main(int argc, char *argv[]) { pm_kernel_t *ker; pm_process_t *proc; pid_t *pids; size_t num_procs; uint64_t total_pss; uint64_t total_uss; uint64_t total_swap; uint64_t total_pswap; uint64_t total_uswap; uint64_t total_zswap; int error; bool has_swap = false, has_zram = false; uint64_t required_flags = 0; uint64_t flags_mask = 0; int arg; size_t i; enum { WS_OFF, WS_ONLY, WS_RESET, } ws; uint64_t mem[MEMINFO_COUNT] = { }; pm_proportional_swap_t *p_swap; float zram_cr = 0.0; signal(SIGPIPE, SIG_IGN); compfn = &sort_by_pss; order = -1; ws = WS_OFF; bool oomadj = false; for (arg = 1; arg < argc; arg++) { if (!strcmp(argv[arg], "-v")) { compfn = &sort_by_vss; continue; } if (!strcmp(argv[arg], "-r")) { compfn = &sort_by_rss; continue; } if (!strcmp(argv[arg], "-p")) { compfn = &sort_by_pss; continue; } if (!strcmp(argv[arg], "-u")) { compfn = &sort_by_uss; continue; } if (!strcmp(argv[arg], "-s")) { compfn = &sort_by_swap; continue; } if (!strcmp(argv[arg], "-o")) { compfn = &sort_by_oomadj; oomadj = true; continue; } if (!strcmp(argv[arg], "-c")) { required_flags = 0; flags_mask = (1 << KPF_SWAPBACKED); continue; } if (!strcmp(argv[arg], "-C")) { required_flags = flags_mask = (1 << KPF_SWAPBACKED); continue; } if (!strcmp(argv[arg], "-k")) { required_flags = flags_mask = (1 << KPF_KSM); continue; } if (!strcmp(argv[arg], "-w")) { ws = WS_ONLY; continue; } if (!strcmp(argv[arg], "-W")) { ws = WS_RESET; continue; } if (!strcmp(argv[arg], "-R")) { order *= -1; continue; } if (!strcmp(argv[arg], "-h")) { usage(argv[0]); exit(0); } fprintf(stderr, "Invalid argument \"%s\".\n", argv[arg]); usage(argv[0]); exit(EXIT_FAILURE); } get_mem_info(mem); p_swap = pm_memusage_pswap_create(mem[MEMINFO_SWAP_TOTAL] * 1024); error = pm_kernel_create(&ker); if (error) { fprintf(stderr, "Error creating kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } error = pm_kernel_pids(ker, &pids, &num_procs); if (error) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } std::vector<proc_info> procs(num_procs); for (i = 0; i < num_procs; i++) { procs[i].pid = pids[i]; procs[i].oomadj = getoomadj(pids[i]); pm_memusage_zero(&procs[i].usage); pm_memusage_pswap_init_handle(&procs[i].usage, p_swap); error = pm_process_create(ker, pids[i], &proc); if (error) { fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]); continue; } switch (ws) { case WS_OFF: error = pm_process_usage_flags(proc, &procs[i].usage, flags_mask, required_flags); break; case WS_ONLY: error = pm_process_workingset(proc, &procs[i].usage, 0); break; case WS_RESET: error = pm_process_workingset(proc, NULL, 1); break; } if (error) { fprintf(stderr, "warning: could not read usage for %d\n", pids[i]); } if (ws != WS_RESET && procs[i].usage.swap) { has_swap = true; } pm_process_destroy(proc); } free(pids); if (ws == WS_RESET) exit(0); procs.erase(std::remove_if(procs.begin(), procs.end(), [](auto proc){ return proc.usage.vss == 0; }), procs.end()); qsort(procs.data(), procs.size(), sizeof(procs[0]), compfn); if (has_swap) { uint64_t zram_mem_used = get_zram_mem_used(); if (zram_mem_used) { mem[MEMINFO_ZRAM_TOTAL] = zram_mem_used/1024; zram_cr = (float) mem[MEMINFO_ZRAM_TOTAL] / (mem[MEMINFO_SWAP_TOTAL] - mem[MEMINFO_SWAP_FREE]); has_zram = true; } } printf("%5s ", "PID"); if (oomadj) { printf("%5s ", "oom"); } if (ws) { printf("%7s %7s %7s ", "WRss", "WPss", "WUss"); if (has_swap) { printf("%7s %7s %7s ", "WSwap", "WPSwap", "WUSwap"); if (has_zram) { printf("%7s ", "WZSwap"); } } } else { printf("%8s %7s %7s %7s ", "Vss", "Rss", "Pss", "Uss"); if (has_swap) { printf("%7s %7s %7s ", "Swap", "PSwap", "USwap"); if (has_zram) { printf("%7s ", "ZSwap"); } } } printf("%s\n", "cmdline"); total_pss = 0; total_uss = 0; total_swap = 0; total_pswap = 0; total_uswap = 0; total_zswap = 0; std::vector<uint64_t> lmk_minfree; std::vector<int> lmk_adj; if (oomadj) { getminfree(&lmk_minfree, &lmk_adj); } auto lmk_minfree_it = lmk_minfree.cbegin(); auto lmk_adj_it = lmk_adj.cbegin(); auto print_oomadj_totals = [&](int adj){ for (; lmk_adj_it != lmk_adj.cend() && lmk_minfree_it != lmk_minfree.cend() && adj > *lmk_adj_it; lmk_adj_it++, lmk_minfree_it++) { // Print the cumulative total line printf("%5s ", ""); // pid printf("%5s ", ""); // oomadj if (ws) { printf("%7s %6" PRIu64 "K %6" PRIu64 "K ", "", total_pss / 1024, total_uss / 1024); } else { printf("%8s %7s %6" PRIu64 "K %6" PRIu64 "K ", "", "", total_pss / 1024, total_uss / 1024); } if (has_swap) { printf("%6" PRIu64 "K ", total_swap / 1024); printf("%6" PRIu64 "K ", total_pswap / 1024); printf("%6" PRIu64 "K ", total_uswap / 1024); if (has_zram) { printf("%6" PRIu64 "K ", total_zswap / 1024); } } printf("TOTAL for oomadj < %d (%6" PRIu64 "K)\n", *lmk_adj_it, *lmk_minfree_it / 1024); } }; for (auto& proc: procs) { if (oomadj) { print_oomadj_totals(proc.oomadj); } std::string cmdline = getprocname(proc.pid); total_pss += proc.usage.pss; total_uss += proc.usage.uss; total_swap += proc.usage.swap; printf("%5d ", proc.pid); if (oomadj) { printf("%5d ", proc.oomadj); } if (ws) { printf("%6zuK %6zuK %6zuK ", proc.usage.rss / 1024, proc.usage.pss / 1024, proc.usage.uss / 1024 ); } else { printf("%7zuK %6zuK %6zuK %6zuK ", proc.usage.vss / 1024, proc.usage.rss / 1024, proc.usage.pss / 1024, proc.usage.uss / 1024 ); } if (has_swap) { pm_swapusage_t su; pm_memusage_pswap_get_usage(&proc.usage, &su); printf("%6zuK ", proc.usage.swap / 1024); printf("%6zuK ", su.proportional / 1024); printf("%6zuK ", su.unique / 1024); total_pswap += su.proportional; total_uswap += su.unique; pm_memusage_pswap_free(&proc.usage); if (has_zram) { size_t zpswap = su.proportional * zram_cr; printf("%6zuK ", zpswap / 1024); total_zswap += zpswap; } } printf("%s\n", cmdline.c_str()); } pm_memusage_pswap_destroy(p_swap); if (oomadj) { print_oomadj_totals(INT_MAX); } // Print the separator line printf("%5s ", ""); if (oomadj) { printf("%5s ", ""); } if (ws) { printf("%7s %7s %7s ", "", "------", "------"); } else { printf("%8s %7s %7s %7s ", "", "", "------", "------"); } if (has_swap) { printf("%7s %7s %7s ", "------", "------", "------"); if (has_zram) { printf("%7s ", "------"); } } printf("%s\n", "------"); // Print the total line printf("%5s ", ""); if (oomadj) { printf("%5s ", ""); } if (ws) { printf("%7s %6" PRIu64 "K %6" PRIu64 "K ", "", total_pss / 1024, total_uss / 1024); } else { printf("%8s %7s %6" PRIu64 "K %6" PRIu64 "K ", "", "", total_pss / 1024, total_uss / 1024); } if (has_swap) { printf("%6" PRIu64 "K ", total_swap / 1024); printf("%6" PRIu64 "K ", total_pswap / 1024); printf("%6" PRIu64 "K ", total_uswap / 1024); if (has_zram) { printf("%6" PRIu64 "K ", total_zswap / 1024); } } printf("TOTAL\n"); printf("\n"); if (has_swap) { printf("ZRAM: %" PRIu64 "K physical used for %" PRIu64 "K in swap " "(%" PRIu64 "K total swap)\n", mem[MEMINFO_ZRAM_TOTAL], (mem[MEMINFO_SWAP_TOTAL] - mem[MEMINFO_SWAP_FREE]), mem[MEMINFO_SWAP_TOTAL]); } printf(" RAM: %" PRIu64 "K total, %" PRIu64 "K free, %" PRIu64 "K buffers, " "%" PRIu64 "K cached, %" PRIu64 "K shmem, %" PRIu64 "K slab\n", mem[MEMINFO_TOTAL], mem[MEMINFO_FREE], mem[MEMINFO_BUFFERS], mem[MEMINFO_CACHED], mem[MEMINFO_SHMEM], mem[MEMINFO_SLAB]); return 0; }
int main(int argc, char *argv[]) { char cmdline[256]; char *prefix; size_t prefix_len; int (*compfn)(const void *a, const void *b); pm_kernel_t *ker; pm_process_t *proc; pid_t *pids; size_t num_procs; pm_map_t **maps; size_t num_maps; pm_memusage_t map_usage; struct library_info *li, **lis; struct mapping_info *mi, **mis; struct process_info *pi; size_t i, j; int error; int perm; bool all; uint64_t required_flags; uint64_t flags_mask; bool has_swap = false; signal(SIGPIPE, SIG_IGN); compfn = &sort_by_pss; order = -1; prefix = NULL; prefix_len = 0; opterr = 0; perm = 0; all = false; required_flags = 0; flags_mask = 0; while (1) { int c; const struct option longopts[] = { {"all", 0, 0, 'a'}, {"cached", 0, 0, 'c'}, {"nocached", 0, 0, 'C'}, {"ksm", 0, 0, 'k'}, {"help", 0, 0, 'h'}, {"pss", 0, 0, 'p'}, {"uss", 0, 0, 'u'}, {"vss", 0, 0, 'v'}, {"rss", 0, 0, 'r'}, {"swap", 0, 0, 's'}, {"reverse", 0, 0, 'R'}, {"path", required_argument, 0, 'P'}, {"perm", required_argument, 0, 'm'}, {0, 0, 0, 0} }; c = getopt_long(argc, argv, "acChkm:pP:uvrsR", longopts, NULL); if (c < 0) { break; } /* Alphabetical cases */ switch (c) { case 'a': all = true; break; case 'c': required_flags = 0; flags_mask = PM_PAGE_SWAPBACKED; break; case 'C': required_flags = PM_PAGE_SWAPBACKED; flags_mask = PM_PAGE_SWAPBACKED; break; case 'k': required_flags = PM_PAGE_KSM; flags_mask = PM_PAGE_KSM; break; case 'h': usage(argv[0]); exit(EXIT_SUCCESS); case 'm': perm = parse_perm(optarg); break; case 'p': compfn = &sort_by_pss; break; case 'P': prefix = optarg; prefix_len = strlen(prefix); break; case 'u': compfn = &sort_by_uss; break; case 'v': compfn = &sort_by_vss; break; case 'r': compfn = &sort_by_rss; break; case 's': compfn = &sort_by_swap; break; case 'R': order *= -1; break; case '?': fprintf(stderr, "Invalid argument \"%s\".\n", argv[optind - 1]); usage(argv[0]); exit(EXIT_FAILURE); default: abort(); } } argc -= optind; argv += optind; libraries = malloc(INIT_LIBRARIES * sizeof(struct library_info *)); libraries_count = 0; libraries_size = INIT_LIBRARIES; error = pm_kernel_create(&ker); if (error) { fprintf(stderr, "Error initializing kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } error = pm_kernel_pids(ker, &pids, &num_procs); if (error) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } for (i = 0; i < num_procs; i++) { error = pm_process_create(ker, pids[i], &proc); if (error) { fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]); continue; } pi = get_process(pids[i]); error = pm_process_maps(proc, &maps, &num_maps); if (error) { fprintf(stderr, "Error listing maps for process %d.\n", proc->pid); exit(EXIT_FAILURE); } for (j = 0; j < num_maps; j++) { if (prefix && (strncmp(pm_map_name(maps[j]), prefix, prefix_len))) continue; if (perm && (pm_map_flags(maps[j]) & PM_MAP_PERMISSIONS) != perm) continue; li = get_library(pm_map_name(maps[j]), all); if (!li) continue; mi = get_mapping(li, pi); error = pm_map_usage_flags(maps[j], &map_usage, flags_mask, required_flags); if (error) { fprintf(stderr, "Error getting map memory usage of " "map %s in process %d.\n", pm_map_name(maps[j]), proc->pid); exit(EXIT_FAILURE); } if (map_usage.swap) { has_swap = true; } pm_memusage_add(&mi->usage, &map_usage); pm_memusage_add(&li->total_usage, &map_usage); } } printf(" %6s %6s %6s %6s %6s ", "RSStot", "VSS", "RSS", "PSS", "USS"); if (has_swap) { printf(" %6s ", "Swap"); } printf("Name/PID\n"); fflush(stdout); qsort(libraries, libraries_count, sizeof(libraries[0]), &licmp); for (i = 0; i < libraries_count; i++) { li = libraries[i]; printf("%6zdK %6s %6s %6s %6s ", li->total_usage.pss / 1024, "", "", "", ""); if (has_swap) { printf(" %6s ", ""); } printf("%s\n", li->name); fflush(stdout); qsort(li->mappings, li->mappings_count, sizeof(li->mappings[0]), compfn); for (j = 0; j < li->mappings_count; j++) { mi = li->mappings[j]; pi = mi->proc; printf( " %6s %6zdK %6zdK %6zdK %6zdK ", "", mi->usage.vss / 1024, mi->usage.rss / 1024, mi->usage.pss / 1024, mi->usage.uss / 1024); if (has_swap) { printf("%6zdK ", mi->usage.swap / 1024); } printf(" %s [%d]\n", pi->cmdline, pi->pid); } printf("\n"); fflush(stdout); } return 0; }
int main(int argc, char *argv[]) { pm_kernel_t *ker; pm_process_t *proc; pid_t *pids; struct proc_info **procs; size_t num_procs; uint64_t total_pss; uint64_t total_uss; uint64_t total_swap; char cmdline[256]; // this must be within the range of int int error; bool has_swap = false; uint64_t required_flags = 0; uint64_t flags_mask = 0; #define WS_OFF 0 #define WS_ONLY 1 #define WS_RESET 2 int ws; int arg; size_t i, j; signal(SIGPIPE, SIG_IGN); compfn = &sort_by_pss; order = -1; ws = WS_OFF; for (arg = 1; arg < argc; arg++) { if (!strcmp(argv[arg], "-v")) { compfn = &sort_by_vss; continue; } if (!strcmp(argv[arg], "-r")) { compfn = &sort_by_rss; continue; } if (!strcmp(argv[arg], "-p")) { compfn = &sort_by_pss; continue; } if (!strcmp(argv[arg], "-u")) { compfn = &sort_by_uss; continue; } if (!strcmp(argv[arg], "-s")) { compfn = &sort_by_swap; continue; } if (!strcmp(argv[arg], "-c")) { required_flags = 0; flags_mask = PM_PAGE_SWAPBACKED; continue; } if (!strcmp(argv[arg], "-C")) { required_flags = flags_mask = PM_PAGE_SWAPBACKED; continue; } if (!strcmp(argv[arg], "-k")) { required_flags = flags_mask = PM_PAGE_KSM; continue; } if (!strcmp(argv[arg], "-w")) { ws = WS_ONLY; continue; } if (!strcmp(argv[arg], "-W")) { ws = WS_RESET; continue; } if (!strcmp(argv[arg], "-R")) { order *= -1; continue; } if (!strcmp(argv[arg], "-h")) { usage(argv[0]); exit(0); } fprintf(stderr, "Invalid argument \"%s\".\n", argv[arg]); usage(argv[0]); exit(EXIT_FAILURE); } error = pm_kernel_create(&ker); if (error) { fprintf(stderr, "Error creating kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } error = pm_kernel_pids(ker, &pids, &num_procs); if (error) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } procs = calloc(num_procs, sizeof(struct proc_info*)); if (procs == NULL) { fprintf(stderr, "calloc: %s", strerror(errno)); exit(EXIT_FAILURE); } for (i = 0; i < num_procs; i++) { procs[i] = malloc(sizeof(struct proc_info)); if (procs[i] == NULL) { fprintf(stderr, "malloc: %s\n", strerror(errno)); exit(EXIT_FAILURE); } procs[i]->pid = pids[i]; pm_memusage_zero(&procs[i]->usage); error = pm_process_create(ker, pids[i], &proc); if (error) { fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]); continue; } switch (ws) { case WS_OFF: error = pm_process_usage_flags(proc, &procs[i]->usage, flags_mask, required_flags); break; case WS_ONLY: error = pm_process_workingset(proc, &procs[i]->usage, 0); break; case WS_RESET: error = pm_process_workingset(proc, NULL, 1); break; } if (error) { fprintf(stderr, "warning: could not read usage for %d\n", pids[i]); } if (ws != WS_RESET && procs[i]->usage.swap) { has_swap = true; } pm_process_destroy(proc); } free(pids); if (ws == WS_RESET) exit(0); j = 0; for (i = 0; i < num_procs; i++) { if (procs[i]->usage.vss) { procs[j++] = procs[i]; } else { free(procs[i]); } } num_procs = j; qsort(procs, num_procs, sizeof(procs[0]), compfn); printf("%5s ", "PID"); if (ws) { printf("%s %7s %7s ", "WRss", "WPss", "WUss"); if (has_swap) { printf("%7s ", "WSwap"); } } else { printf("%8s %7s %7s %7s ", "Vss", "Rss", "Pss", "Uss"); if (has_swap) { printf("%7s ", "Swap"); } } printf("%s\n", "cmdline"); total_pss = 0; total_uss = 0; total_swap = 0; for (i = 0; i < num_procs; i++) { if (getprocname(procs[i]->pid, cmdline, (int)sizeof(cmdline)) < 0) { /* * Something is probably seriously wrong if writing to the stack * failed. */ free(procs[i]); continue; } total_pss += procs[i]->usage.pss; total_uss += procs[i]->usage.uss; total_swap += procs[i]->usage.swap; printf("%5d ", procs[i]->pid); if (ws) { printf("%6zuK %6zuK %6zuK ", procs[i]->usage.rss / 1024, procs[i]->usage.pss / 1024, procs[i]->usage.uss / 1024 ); } else { printf("%7zuK %6zuK %6zuK %6zuK ", procs[i]->usage.vss / 1024, procs[i]->usage.rss / 1024, procs[i]->usage.pss / 1024, procs[i]->usage.uss / 1024 ); } if (has_swap) { printf("%6zuK ", procs[i]->usage.swap / 1024); } printf("%s\n", cmdline); free(procs[i]); } free(procs); /* Print the separator line */ printf("%5s ", ""); if (ws) { printf("%7s %7s %7s ", "", "------", "------"); } else { printf("%8s %7s %7s %7s ", "", "", "------", "------"); } if (has_swap) { printf("%7s ", "------"); } printf("%s\n", "------"); /* Print the total line */ printf("%5s ", ""); if (ws) { printf("%7s %6" PRIu64 "K %" PRIu64 "K ", "", total_pss / 1024, total_uss / 1024); } else { printf("%8s %7s %6" PRIu64 "K %6" PRIu64 "K ", "", "", total_pss / 1024, total_uss / 1024); } if (has_swap) { printf("%6" PRIu64 "K ", total_swap / 1024); } printf("TOTAL\n"); printf("\n"); print_mem_info(); return 0; }
int main(int argc, char *argv[]) { int ret; pm_kernel_t *ker; size_t num_procs; pid_t *pids; struct memtrack_proc *p; size_t i; (void)argc; (void)argv; ret = memtrack_init(); if (ret < 0) { fprintf(stderr, "failed to initialize HAL: %s (%d)\n", strerror(-ret), ret); exit(EXIT_FAILURE); } ret = pm_kernel_create(&ker); if (ret) { fprintf(stderr, "Error creating kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } ret = pm_kernel_pids(ker, &pids, &num_procs); if (ret) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } p = memtrack_proc_new(); if (ret) { fprintf(stderr, "failed to create memtrack process handle\n"); exit(EXIT_FAILURE); } for (i = 0; i < num_procs; i++) { pid_t pid = pids[i]; char cmdline[256]; size_t v1; size_t v2; size_t v3; size_t v4; size_t v5; size_t v6; getprocname(pid, cmdline, (int)sizeof(cmdline)); ret = memtrack_proc_get(p, pid); if (ret) { fprintf(stderr, "failed to get memory info for pid %d: %s (%d)\n", pid, strerror(-ret), ret); continue; } v1 = DIV_ROUND_UP(memtrack_proc_graphics_total(p), 1024); v2 = DIV_ROUND_UP(memtrack_proc_graphics_pss(p), 1024); v3 = DIV_ROUND_UP(memtrack_proc_gl_total(p), 1024); v4 = DIV_ROUND_UP(memtrack_proc_gl_pss(p), 1024); v5 = DIV_ROUND_UP(memtrack_proc_other_total(p), 1024); v6 = DIV_ROUND_UP(memtrack_proc_other_pss(p), 1024); if (v1 | v2 | v3 | v4 | v5 | v6) { printf("%5d %6zu %6zu %6zu %6zu %6zu %6zu %s\n", pid, v1, v2, v3, v4, v5, v6, cmdline); } } memtrack_proc_destroy(p); return 0; }
int main(int argc, char *argv[]) { char cmdline[256]; char *prefix; size_t prefix_len; int (*compfn)(const void *a, const void *b); /// M: get swap usage @{ int show_swap; /// @} pm_kernel_t *ker; pm_process_t *proc; pid_t *pids; size_t num_procs; pm_map_t **maps; size_t num_maps; pm_memusage_t map_usage; struct library_info *li, **lis; struct mapping_info *mi, **mis; struct process_info *pi; int i, j, error; signal(SIGPIPE, SIG_IGN); compfn = &sort_by_pss; order = -1; prefix = NULL; prefix_len = 0; /// M: get swap usage @{ show_swap = 0; /// @} for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-P")) { if (i + 1 >= argc) { fprintf(stderr, "Option -P requires an argument.\n"); usage(argv[0]); exit(EXIT_FAILURE); } prefix = argv[++i]; prefix_len = strlen(prefix); continue; } if (!strcmp(argv[i], "-v")) { compfn = &sort_by_vss; continue; } if (!strcmp(argv[i], "-r")) { compfn = &sort_by_rss; continue; } if (!strcmp(argv[i], "-p")) { compfn = &sort_by_pss; continue; } if (!strcmp(argv[i], "-u")) { compfn = &sort_by_uss; continue; } if (!strcmp(argv[i], "-R")) { order *= -1; continue; } /// M: get swap usage @{ if (!strcmp(argv[i], "-s")) { show_swap = 1; continue; } /// @} if (!strcmp(argv[i], "-h")) { usage(argv[0]); exit(0); } fprintf(stderr, "Invalid argument \"%s\".\n", argv[i]); usage(argv[0]); exit(EXIT_FAILURE); } libraries = malloc(INIT_LIBRARIES * sizeof(struct library_info *)); libraries_count = 0; libraries_size = INIT_LIBRARIES; error = pm_kernel_create(&ker); if (error) { fprintf(stderr, "Error initializing kernel interface -- " "does this kernel have pagemap?\n"); exit(EXIT_FAILURE); } error = pm_kernel_pids(ker, &pids, &num_procs); if (error) { fprintf(stderr, "Error listing processes.\n"); exit(EXIT_FAILURE); } for (i = 0; i < num_procs; i++) { error = pm_process_create(ker, pids[i], &proc); if (error) { fprintf(stderr, "warning: could not create process interface for %d\n", pids[i]); continue; } pi = get_process(pids[i]); error = pm_process_maps(proc, &maps, &num_maps); if (error) { fprintf(stderr, "Error listing maps for process %d.\n", proc->pid); exit(EXIT_FAILURE); } for (j = 0; j < num_maps; j++) { if (prefix && (strncmp(pm_map_name(maps[j]), prefix, prefix_len))) continue; li = get_library(pm_map_name(maps[j])); if (!li) continue; mi = get_mapping(li, pi); error = pm_map_usage(maps[j], &map_usage); if (error) { fprintf(stderr, "Error getting map memory usage of " "map %s in process %d.\n", pm_map_name(maps[j]), proc->pid); exit(EXIT_FAILURE); } pm_memusage_add(&mi->usage, &map_usage); pm_memusage_add(&li->total_usage, &map_usage); } } /// M: get swap usage @{ if (show_swap) { printf( " %6s %6s %6s %6s %6s %6s %6s %s\n", "RSStot", "VSS", "RSS", "PSS", "USS", "SWAP", "PSWAP", "Name/PID"); } else { printf( " %6s %6s %6s %6s %6s %s\n", "RSStot", "VSS", "RSS", "PSS", "USS", "Name/PID"); } /// @} fflush(stdout); qsort(libraries, libraries_count, sizeof(libraries[0]), &licmp); for (i = 0; i < libraries_count; i++) { li = libraries[i]; printf("%6dK %6s %6s %6s %6s %s\n", li->total_usage.pss / 1024, "", "", "", "", li->name); fflush(stdout); qsort(li->mappings, li->mappings_count, sizeof(li->mappings[0]), compfn); for (j = 0; j < li->mappings_count; j++) { mi = li->mappings[j]; pi = mi->proc; /// M: get swap usage @{ if (show_swap) { printf( " %6s %6dK %6dK %6dK %6dK %6dK %6dK %s [%d]\n", "", mi->usage.vss / 1024, mi->usage.rss / 1024, mi->usage.pss / 1024, mi->usage.uss / 1024, mi->usage.swap / 1024, mi->usage.pswap / 1024, pi->cmdline, pi->pid); } else { printf( " %6s %6dK %6dK %6dK %6dK %s [%d]\n", "", mi->usage.vss / 1024, mi->usage.rss / 1024, mi->usage.pss / 1024, mi->usage.uss / 1024, pi->cmdline, pi->pid); } /// @} } printf("\n"); fflush(stdout); } return 0; }