198 lines
6.8 KiB
C++
198 lines
6.8 KiB
C++
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <getopt.h>
|
|
#include <inttypes.h>
|
|
#include <linux/kernel-page-flags.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <set>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include <android-base/parseint.h>
|
|
#include <android-base/strings.h>
|
|
#include <meminfo/procmeminfo.h>
|
|
#include <procinfo/process.h>
|
|
|
|
#include <processrecord.h>
|
|
#include <smapinfo.h>
|
|
|
|
using ::android::smapinfo::SortOrder;
|
|
|
|
[[noreturn]] static void usage(int exit_status) {
|
|
std::cerr << "Usage: " << getprogname() << " [ -W ] [ -v | -r | -p | -u | -s | -h ] [-d PID]"
|
|
<< std::endl
|
|
<< " -v Sort by VSS." << std::endl
|
|
<< " -r Sort by RSS." << std::endl
|
|
<< " -p Sort by PSS." << std::endl
|
|
<< " -u Sort by USS." << std::endl
|
|
<< " -s Sort by swap." << std::endl
|
|
<< " (Default sort order is PSS.)" << std::endl
|
|
<< " -R Reverse sort order (default is descending)." << std::endl
|
|
<< " -c Only show cached (storage backed) pages" << std::endl
|
|
<< " -C Only show non-cached (ram/swap backed) pages" << std::endl
|
|
<< " -k Only show pages collapsed by KSM" << std::endl
|
|
<< " -w Display statistics for working set only." << std::endl
|
|
<< " -W Reset working set of processes." << std::endl
|
|
<< " -o Show and sort by oom score against lowmemorykiller thresholds."
|
|
<< std::endl
|
|
<< " -d Filter to descendants of specified process (can be repeated)" << std::endl
|
|
<< " -h Display this help screen." << std::endl;
|
|
exit(exit_status);
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
// Count all pages by default.
|
|
uint64_t pgflags = 0;
|
|
uint64_t pgflags_mask = 0;
|
|
|
|
// Sort by PSS descending by default.
|
|
SortOrder sort_order = SortOrder::BY_PSS;
|
|
bool reverse_sort = false;
|
|
|
|
bool get_oomadj = false;
|
|
bool get_wss = false;
|
|
bool reset_wss = false;
|
|
|
|
std::vector<pid_t> descendant_filter;
|
|
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, "cCd:hkoprRsuvwW")) != -1) {
|
|
switch (opt) {
|
|
case 'c':
|
|
pgflags = 0;
|
|
pgflags_mask = (1 << KPF_SWAPBACKED);
|
|
break;
|
|
case 'C':
|
|
pgflags = (1 << KPF_SWAPBACKED);
|
|
pgflags_mask = (1 << KPF_SWAPBACKED);
|
|
break;
|
|
case 'd': {
|
|
pid_t p;
|
|
if (!android::base::ParseInt(optarg, &p)) {
|
|
std::cerr << "Failed to parse pid '" << optarg << "'" << std::endl;
|
|
usage(EXIT_FAILURE);
|
|
}
|
|
descendant_filter.push_back(p);
|
|
break;
|
|
}
|
|
case 'h':
|
|
usage(EXIT_SUCCESS);
|
|
case 'k':
|
|
pgflags = (1 << KPF_KSM);
|
|
pgflags_mask = (1 << KPF_KSM);
|
|
break;
|
|
case 'o':
|
|
sort_order = SortOrder::BY_OOMADJ;
|
|
get_oomadj = true;
|
|
break;
|
|
case 'p':
|
|
sort_order = SortOrder::BY_PSS;
|
|
break;
|
|
case 'r':
|
|
sort_order = SortOrder::BY_RSS;
|
|
break;
|
|
case 'R':
|
|
reverse_sort = true;
|
|
break;
|
|
case 's':
|
|
sort_order = SortOrder::BY_SWAP;
|
|
break;
|
|
case 'u':
|
|
sort_order = SortOrder::BY_USS;
|
|
break;
|
|
case 'v':
|
|
sort_order = SortOrder::BY_VSS;
|
|
break;
|
|
case 'w':
|
|
get_wss = true;
|
|
break;
|
|
case 'W':
|
|
reset_wss = true;
|
|
break;
|
|
default:
|
|
usage(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
std::set<pid_t> pids;
|
|
if (!::android::smapinfo::get_all_pids(&pids)) {
|
|
std::cerr << "Failed to get all pids." << std::endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (descendant_filter.size()) {
|
|
// Map from parent pid to all of its children.
|
|
std::unordered_map<pid_t, std::vector<pid_t>> pid_tree;
|
|
|
|
for (pid_t pid : pids) {
|
|
android::procinfo::ProcessInfo info;
|
|
std::string error;
|
|
if (!android::procinfo::GetProcessInfo(pid, &info, &error)) {
|
|
std::cerr << "warning: failed to get process info for: " << pid << ": " << error
|
|
<< std::endl;
|
|
continue;
|
|
}
|
|
|
|
pid_tree[info.ppid].push_back(pid);
|
|
}
|
|
|
|
std::set<pid_t> final_pids;
|
|
std::vector<pid_t>& frontier = descendant_filter;
|
|
|
|
// Do a breadth-first walk of the process tree, starting from the pids we were given.
|
|
while (!frontier.empty()) {
|
|
pid_t pid = frontier.back();
|
|
frontier.pop_back();
|
|
|
|
// It's possible for the pid we're looking at to already be in our list if one of the
|
|
// passed in processes descends from another, or if the same pid is passed twice.
|
|
auto [it, inserted] = final_pids.insert(pid);
|
|
if (inserted) {
|
|
auto it = pid_tree.find(pid);
|
|
if (it != pid_tree.end()) {
|
|
// Add all of the children of |pid| to the list of nodes to visit.
|
|
frontier.insert(frontier.end(), it->second.begin(), it->second.end());
|
|
}
|
|
}
|
|
}
|
|
|
|
pids = std::move(final_pids);
|
|
}
|
|
|
|
if (reset_wss) {
|
|
for (pid_t pid : pids) {
|
|
if (!::android::meminfo::ProcMemInfo::ResetWorkingSet(pid)) {
|
|
std::cerr << "Failed to reset working set of all processes" << std::endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
// Other options passed to procrank are ignored if reset_wss is true.
|
|
return 0;
|
|
}
|
|
|
|
bool success = ::android::smapinfo::run_procrank(pgflags, pgflags_mask, pids, get_oomadj,
|
|
get_wss, sort_order, reverse_sort, nullptr,
|
|
std::cout, std::cerr);
|
|
if (!success) {
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
return 0;
|
|
}
|