/*
* Copyright (C) 2016 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.
*/
#define LOG_TAG "ProcessMonitor"
#include <mutex>
#include <sys/param.h>
#include <dirent.h>
#include "ProcessMonitor.h"
#define DBG_VERBOSE
#ifdef DBG_VERBOSE
#define LOG_VERBOSE(x...) ALOGD(x)
#else
#define LOG_VERBOSE(x...)
#endif
#define MAX_LINE 256
#define SELF_IO "/proc/self/io"
#define NUM_PROC_DUMP 10
namespace android {
static bool procDeltaCpuCmp(const std::pair<pid_t, const std::shared_ptr<ProcInfo>> a,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>> b) {
return a.second->delta_time > b.second->delta_time;
}
static bool procDeltaMemCmp(const std::pair<pid_t, const std::shared_ptr<ProcInfo>> a,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>> b) {
return a.second->delta_rss > b.second->delta_rss;
}
static bool procDeltaWbytesCmp(const std::pair<pid_t, const std::shared_ptr<ProcInfo>> a,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>> b) {
return a.second->delta_wbytes > b.second->delta_wbytes;
}
static bool procCpuCmp(const std::pair<pid_t, const std::shared_ptr<ProcInfo>> a,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>> b) {
return (a.second->utime + a.second->utime) > (b.second->stime + b.second->stime);
}
static bool procMemCmp(const std::pair<pid_t, const std::shared_ptr<ProcInfo>> a,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>> b) {
return a.second->rss > b.second->rss;
}
static bool procWbytesCmp(const std::pair<pid_t, const std::shared_ptr<ProcInfo>> a,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>> b) {
return a.second->wbytes > b.second->wbytes;
}
ProcessMonitor::ProcessMonitor() {
//TODO: read config from policy files.
if (access(SELF_IO, F_OK) == -1) {
mIoSupported = false;
ALOGE("**** DISK I/O PROFILING DISABLED!!!!****\n"
"Kernel doesn't support I/O profiling.");
} else {
mIoSupported = true;
}
}
ProcessMonitor::~ProcessMonitor() {
}
void ProcessMonitor::dump(String8& msg) {
std::shared_lock<std::shared_timed_mutex> lock(mMutex);
msg.append("ProcessMonitor\n");
msg.appendFormat("Processes count: %d\n", (int) mProcInfoMap.size());
msg.append("Top CPU usage\n");
dumpTopProcesses(msg, procCpuCmp);
msg.append("Top CPU usage increase\n");
dumpTopProcesses(msg, procDeltaCpuCmp);
msg.append("Top memory usage\n");
dumpTopProcesses(msg, procMemCmp);
msg.append("Top memory usage increase\n");
dumpTopProcesses(msg, procDeltaMemCmp);
if (mIoSupported) {
msg.append("Top disk IO \n");
dumpTopProcesses(msg, procWbytesCmp);
msg.append("Top disk IO increase \n");
dumpTopProcesses(msg, procDeltaWbytesCmp);
} else {
msg.append("Disk IO monitoring not supported.\n");
}
}
void ProcessMonitor::dumpTopProcesses(
String8& msg,
bool (*procCmpFn) (
const std::pair<pid_t, const std::shared_ptr<ProcInfo>>,
const std::pair<pid_t, const std::shared_ptr<ProcInfo>>)) {
std::vector<std::pair<pid_t, std::shared_ptr<ProcInfo>>> topPids(NUM_PROC_DUMP);
std::partial_sort_copy(mProcInfoMap.begin(),
mProcInfoMap.end(),
topPids.begin(),
topPids.end(),
*procCmpFn);
for (auto it = topPids.begin(); it != topPids.end(); ++it) {
msg.appendFormat("(%s) PID: %d: delta_time: %" PRIu64 ", delta_rss: %" PRIu64 ", "
"delta_wbytes: %" PRIu64 ", utime: %" PRIu64" , stime: %" PRIu64 ", "
"rss: %" PRIu64 ", wbytes: %" PRIu64 "\n",
it->second->name.c_str(),
it->first,
it->second->delta_time,
it->second->delta_rss,
it->second->delta_wbytes,
it->second->utime,
it->second->stime,
it->second->rss,
it->second->wbytes);
}
}
status_t ProcessMonitor::setAppPriority(uint32_t , uint32_t, uint32_t) {
std::unique_lock<std::shared_timed_mutex> lock(mMutex);
// TODO implement.
return NO_ERROR;
}
status_t ProcessMonitor::process() {
status_t status = updateProcessInfo();
if (status != NO_ERROR) {
return status;
}
return improveSystemHealth();
}
status_t ProcessMonitor::improveSystemHealth() {
// TODO: implement policy enforcer. kill apps that abuse system.
return NO_ERROR;
}
status_t ProcessMonitor::updateProcessInfo() {
std::unique_lock<std::shared_timed_mutex> lock(mMutex);
std::set<pid_t> oldPids;
populateExistingPids(oldPids);
DIR *procDir;
procDir = opendir("/proc");
if (!procDir) {
ALOGE("Failed to open /proc dir");
return PERMISSION_DENIED;
}
struct dirent *pidDir;
pid_t pid;
while ((pidDir = readdir(procDir))) {
if (!isdigit(pidDir->d_name[0])) {
continue;
}
pid = atoi(pidDir->d_name);
updateOrAddProcess(pid);
oldPids.erase(pid);
}
deleteOutdatedPids(oldPids);
return NO_ERROR;
}
void ProcessMonitor::deleteOutdatedPids(std::set<pid_t>& pidSet) {
for(auto it = pidSet.begin(); it != pidSet.end(); ++it) {
LOG_VERBOSE("Process %d ended. Removing from process map", *it);
mProcInfoMap.erase(*it);
}
}
void ProcessMonitor::populateExistingPids(std::set<pid_t>& pidSet) {
for(auto it = mProcInfoMap.begin(); it != mProcInfoMap.end(); ++it) {
pidSet.insert(it->first);
}
}
void ProcessMonitor::updateOrAddProcess(pid_t pid) {
auto pidDataIt = mProcInfoMap.find(pid);
std::shared_ptr<ProcInfo> pidData;
if (pidDataIt == mProcInfoMap.end()) {
pidData = std::make_shared<ProcInfo>();
mProcInfoMap.insert(std::pair<pid_t, std::shared_ptr<ProcInfo>>(pid, pidData));
} else {
pidData = pidDataIt->second;
}
auto originalPidData = std::make_shared<ProcInfo>(*pidData);
readStat(pidData, pid);
if (mIoSupported) {
readIo(pidData, pid);
}
readCmdline(pidData, pid);
readStatus(pidData, pid);
updateDiffs(pidData, originalPidData);
}
void ProcessMonitor::readStat(std::shared_ptr<ProcInfo> pidData, pid_t pid) {
char filename[64];
sprintf(filename, "/proc/%d/stat", pid);
FILE *file;
file = fopen(filename, "r");
if (!file) {
ALOGD("Failed to open file %s for reading", filename);
return;
}
fscanf(file,
"%*d %*s %*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
"%" SCNu64
"%" SCNu64 "%*d %*d %*d %*d %*d %*d %*d "
"%*" SCNu64
"%" SCNu64 "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
"%*d",
&pidData->utime,
&pidData->stime,
&pidData->rss);
fclose(file);
}
void ProcessMonitor::readIo(std::shared_ptr<ProcInfo> pidData, pid_t pid) {
char filename[64];
sprintf(filename, "/proc/%d/io", pid);
FILE *file;
file = fopen(filename, "r");
if (!file) {
ALOGD("Failed to open file %s for reading", filename);
return;
}
char buf[MAX_LINE];
while (fgets(buf, MAX_LINE, file)) {
sscanf(buf, "write_bytes: %" PRIu64, &pidData->wbytes);
}
fclose(file);
}
void ProcessMonitor::readCmdline(std::shared_ptr<ProcInfo> pidData, pid_t pid) {
char filename[64];
sprintf(filename, "/proc/%d/cmdline", pid);
FILE *file;
file = fopen(filename, "r");
if (!file) {
ALOGD("Failed to open file %s for reading", filename);
return;
}
char buf[MAXPATHLEN];
fgets(buf, MAXPATHLEN, file);
fclose(file);
if (strlen(buf) > 0) {
pidData->name.assign(buf);
}
}
void ProcessMonitor::readStatus(std::shared_ptr<ProcInfo> pidData, pid_t pid) {
char filename[64];
sprintf(filename, "/proc/%d/status", pid);
FILE *file;
file = fopen(filename, "r");
if (!file) {
ALOGD("Failed to open file %s for reading", filename);
return;
}
char line[MAX_LINE];
unsigned int uid;
while (fgets(line, MAX_LINE, file)) {
sscanf(line, "Uid: %u", &uid);
}
fclose(file);
pidData->uid = uid;
}
void ProcessMonitor::updateDiffs(std::shared_ptr<ProcInfo> pidData,
std::shared_ptr<ProcInfo> oldPidData) {
pidData->delta_utime = pidData->utime - oldPidData->utime;
pidData->delta_stime = pidData->stime - oldPidData->stime;
pidData->delta_time = pidData->delta_utime + pidData->delta_stime;
pidData->delta_rss = pidData->rss - oldPidData->rss;
pidData->delta_wbytes = pidData->wbytes - oldPidData->wbytes;
}
}; // namespace android