void getPss(pid_t pid, size_t* pss_out) {
pm_kernel_t* kernel;
ASSERT_EQ(0, pm_kernel_create(&kernel));
pm_process_t* process;
ASSERT_EQ(0, pm_process_create(kernel, pid, &process));
pm_map_t** maps;
size_t num_maps;
ASSERT_EQ(0, pm_process_maps(process, &maps, &num_maps));
size_t total_pss = 0;
for (size_t i = 0; i < num_maps; i++) {
pm_memusage_t usage;
ASSERT_EQ(0, pm_map_usage(maps[i], &usage));
total_pss += usage.pss;
}
*pss_out = total_pss;
free(maps);
pm_process_destroy(process);
pm_kernel_destroy(kernel);
}
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;
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;
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[]) {
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;
}
