vehicle_monitor_service/ProcessMonitor.cpp - platform/packages/services/Car - Git at Google

 /*
  * 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
	/*
	* 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