ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

libprocessgroup: use libcgrouprc to read cgroup.rc

Browse source 
am: 53e0deb7b2

Change-Id: I154787974376c5bce3d158ac2b70a9444c0fc295
This commit is contained in:
Yifan Hong 2019-04-03 12:32:51 -07:00 • committed by android-build-merger
commit c2cb4aa768
9 changed files with 104 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
libcutils/Android.bp
View file

@ -235,6 +235,7 @@ test_libraries = [
"libbase", "libbase",
"libjsoncpp", "libjsoncpp",
"libprocessgroup", "libprocessgroup",
"libcgrouprc",
] ]
cc_test { cc_test {
@ -249,7 +250,10 @@ cc_test {
name: "libcutils_test_static", name: "libcutils_test_static",
test_suites: ["device-tests"], test_suites: ["device-tests"],
defaults: ["libcutils_test_default"], defaults: ["libcutils_test_default"],
static_libs: ["libc"] + test_libraries, static_libs: [
"libc",
"libcgrouprc_format",
] + test_libraries,
stl: "libc++_static", stl: "libc++_static",
target: { target: {

1
libprocessgroup/Android.bp
View file

@ -31,6 +31,7 @@ cc_library {
}, },
shared_libs: [ shared_libs: [
"libbase", "libbase",
"libcgrouprc",
"libjsoncpp", "libjsoncpp",
], ],
// for cutils/android_filesystem_config.h // for cutils/android_filesystem_config.h

135
libprocessgroup/cgroup_map.cpp
View file

@ -48,28 +48,38 @@ static constexpr const char* CGROUP_PROCS_FILE = "/cgroup.procs";
static constexpr const char* CGROUP_TASKS_FILE = "/tasks"; static constexpr const char* CGROUP_TASKS_FILE = "/tasks";
static constexpr const char* CGROUP_TASKS_FILE_V2 = "/cgroup.tasks"; static constexpr const char* CGROUP_TASKS_FILE_V2 = "/cgroup.tasks";
CgroupController::CgroupController(uint32_t version, const std::string& name, uint32_t CgroupController::version() const {
const std::string& path) { CHECK(HasValue());
version_ = version; return ACgroupController_getVersion(controller_);
strncpy(name_, name.c_str(), sizeof(name_) - 1);
name_[sizeof(name_) - 1] = '\0';
strncpy(path_, path.c_str(), sizeof(path_) - 1);
path_[sizeof(path_) - 1] = '\0';
} }
std::string CgroupController::GetTasksFilePath(const std::string& path) const { const char* CgroupController::name() const {
std::string tasks_path = path_; CHECK(HasValue());
return ACgroupController_getName(controller_);
}
if (!path.empty()) { const char* CgroupController::path() const {
tasks_path += "/" + path; CHECK(HasValue());
return ACgroupController_getPath(controller_);
}
bool CgroupController::HasValue() const {
return controller_ != nullptr;
}
std::string CgroupController::GetTasksFilePath(const std::string& rel_path) const {
std::string tasks_path = path();
if (!rel_path.empty()) {
tasks_path += "/" + rel_path;
} }
return (version_ == 1) ? tasks_path + CGROUP_TASKS_FILE : tasks_path + CGROUP_TASKS_FILE_V2; return (version() == 1) ? tasks_path + CGROUP_TASKS_FILE : tasks_path + CGROUP_TASKS_FILE_V2;
} }
std::string CgroupController::GetProcsFilePath(const std::string& path, uid_t uid, std::string CgroupController::GetProcsFilePath(const std::string& rel_path, uid_t uid,
pid_t pid) const { pid_t pid) const {
std::string proc_path(path_); std::string proc_path(path());
proc_path.append("/").append(path); proc_path.append("/").append(rel_path);
proc_path = regex_replace(proc_path, std::regex("<uid>"), std::to_string(uid)); proc_path = regex_replace(proc_path, std::regex("<uid>"), std::to_string(uid));
proc_path = regex_replace(proc_path, std::regex("<pid>"), std::to_string(pid)); proc_path = regex_replace(proc_path, std::regex("<pid>"), std::to_string(pid));
@ -90,7 +100,7 @@ bool CgroupController::GetTaskGroup(int tid, std::string* group) const {
return true; return true;
} }
std::string cg_tag = StringPrintf(":%s:", name_); std::string cg_tag = StringPrintf(":%s:", name());
size_t start_pos = content.find(cg_tag); size_t start_pos = content.find(cg_tag);
if (start_pos == std::string::npos) { if (start_pos == std::string::npos) {
return false; return false;
@ -107,20 +117,12 @@ bool CgroupController::GetTaskGroup(int tid, std::string* group) const {
return true; return true;
} }
CgroupMap::CgroupMap() : cg_file_data_(nullptr), cg_file_size_(0) { CgroupMap::CgroupMap() {
if (!LoadRcFile()) { if (!LoadRcFile()) {
LOG(ERROR) << "CgroupMap::LoadRcFile called for [" << getpid() << "] failed"; LOG(ERROR) << "CgroupMap::LoadRcFile called for [" << getpid() << "] failed";
} }
} }
CgroupMap::~CgroupMap() {
if (cg_file_data_) {
munmap(cg_file_data_, cg_file_size_);
cg_file_data_ = nullptr;
cg_file_size_ = 0;
}
}
CgroupMap& CgroupMap::GetInstance() { CgroupMap& CgroupMap::GetInstance() {
// Deliberately leak this object to avoid a race between destruction on // Deliberately leak this object to avoid a race between destruction on
// process exit and concurrent access from another thread. // process exit and concurrent access from another thread.
@ -129,85 +131,46 @@ CgroupMap& CgroupMap::GetInstance() {
} }
bool CgroupMap::LoadRcFile() { bool CgroupMap::LoadRcFile() {
struct stat sb; if (!loaded_) {
loaded_ = (ACgroupFile_getVersion() != 0);
if (cg_file_data_) {
// Data already initialized
return true;
} }
return loaded_;
unique_fd fd(TEMP_FAILURE_RETRY(open(CGROUPS_RC_PATH, O_RDONLY | O_CLOEXEC)));
if (fd < 0) {
PLOG(ERROR) << "open() failed for " << CGROUPS_RC_PATH;
return false;
}
if (fstat(fd, &sb) < 0) {
PLOG(ERROR) << "fstat() failed for " << CGROUPS_RC_PATH;
return false;
}
size_t file_size = sb.st_size;
if (file_size < sizeof(CgroupFile)) {
LOG(ERROR) << "Invalid file format " << CGROUPS_RC_PATH;
return false;
}
CgroupFile* file_data = (CgroupFile*)mmap(nullptr, file_size, PROT_READ, MAP_SHARED, fd, 0);
if (file_data == MAP_FAILED) {
PLOG(ERROR) << "Failed to mmap " << CGROUPS_RC_PATH;
return false;
}
if (file_data->version_ != CgroupFile::FILE_CURR_VERSION) {
LOG(ERROR) << CGROUPS_RC_PATH << " file version mismatch";
munmap(file_data, file_size);
return false;
}
if (file_size != sizeof(CgroupFile) + file_data->controller_count_ * sizeof(CgroupController)) {
LOG(ERROR) << CGROUPS_RC_PATH << " file has invalid size";
munmap(file_data, file_size);
return false;
}
cg_file_data_ = file_data;
cg_file_size_ = file_size;
return true;
} }
void CgroupMap::Print() const { void CgroupMap::Print() const {
if (!cg_file_data_) { if (!loaded_) {
LOG(ERROR) << "CgroupMap::Print called for [" << getpid() LOG(ERROR) << "CgroupMap::Print called for [" << getpid()
<< "] failed, RC file was not initialized properly"; << "] failed, RC file was not initialized properly";
return; return;
} }
LOG(INFO) << "File version = " << cg_file_data_->version_; LOG(INFO) << "File version = " << ACgroupFile_getVersion();
LOG(INFO) << "File controller count = " << cg_file_data_->controller_count_; LOG(INFO) << "File controller count = " << ACgroupFile_getControllerCount();
LOG(INFO) << "Mounted cgroups:"; LOG(INFO) << "Mounted cgroups:";
CgroupController* controller = (CgroupController*)(cg_file_data_ + 1);
for (int i = 0; i < cg_file_data_->controller_count_; i++, controller++) { auto controller_count = ACgroupFile_getControllerCount();
LOG(INFO) << "\t" << controller->name() << " ver " << controller->version() << " path " for (uint32_t i = 0; i < controller_count; ++i) {
<< controller->path(); const ACgroupController* controller = ACgroupFile_getController(i);
LOG(INFO) << "\t" << ACgroupController_getName(controller) << " ver "
<< ACgroupController_getVersion(controller) << " path "
<< ACgroupController_getPath(controller);
} }
} }
const CgroupController* CgroupMap::FindController(const std::string& name) const { CgroupController CgroupMap::FindController(const std::string& name) const {
if (!cg_file_data_) { if (!loaded_) {
LOG(ERROR) << "CgroupMap::FindController called for [" << getpid() LOG(ERROR) << "CgroupMap::FindController called for [" << getpid()
<< "] failed, RC file was not initialized properly"; << "] failed, RC file was not initialized properly";
return nullptr; return CgroupController(nullptr);
} }
// skip the file header to get to the first controller auto controller_count = ACgroupFile_getControllerCount();
CgroupController* controller = (CgroupController*)(cg_file_data_ + 1); for (uint32_t i = 0; i < controller_count; ++i) {
for (int i = 0; i < cg_file_data_->controller_count_; i++, controller++) { const ACgroupController* controller = ACgroupFile_getController(i);
if (name == controller->name()) { if (name == ACgroupController_getName(controller)) {
return controller; return CgroupController(controller);
} }
} }
return nullptr; return CgroupController(nullptr);
} }

44
libprocessgroup/cgroup_map.h
View file

@ -20,39 +20,30 @@
#include <sys/types.h> #include <sys/types.h>
#include <map> #include <map>
#include <memory>
#include <mutex> #include <mutex>
#include <string> #include <string>
#include <vector>
// Minimal controller description to be mmapped into process address space #include <android/cgrouprc.h>
// Convenient wrapper of an ACgroupController pointer.
class CgroupController { class CgroupController {
public: public:
CgroupController() {} // Does not own controller
CgroupController(uint32_t version, const std::string& name, const std::string& path); explicit CgroupController(const ACgroupController* controller) : controller_(controller) {}
uint32_t version() const { return version_; } uint32_t version() const;
const char* name() const { return name_; } const char* name() const;
const char* path() const { return path_; } const char* path() const;
bool HasValue() const;
std::string GetTasksFilePath(const std::string& path) const; std::string GetTasksFilePath(const std::string& path) const;
std::string GetProcsFilePath(const std::string& path, uid_t uid, pid_t pid) const; std::string GetProcsFilePath(const std::string& path, uid_t uid, pid_t pid) const;
bool GetTaskGroup(int tid, std::string* group) const; bool GetTaskGroup(int tid, std::string* group) const;
private: private:
static constexpr size_t CGROUP_NAME_BUF_SZ = 16; const ACgroupController* controller_ = nullptr;
static constexpr size_t CGROUP_PATH_BUF_SZ = 32;
uint32_t version_;
char name_[CGROUP_NAME_BUF_SZ];
char path_[CGROUP_PATH_BUF_SZ];
};
struct CgroupFile {
static constexpr uint32_t FILE_VERSION_1 = 1;
static constexpr uint32_t FILE_CURR_VERSION = FILE_VERSION_1;
uint32_t version_;
uint32_t controller_count_;
CgroupController controllers_[];
}; };
class CgroupMap { class CgroupMap {
@ -61,16 +52,11 @@ class CgroupMap {
static bool SetupCgroups(); static bool SetupCgroups();
static CgroupMap& GetInstance(); static CgroupMap& GetInstance();
CgroupController FindController(const std::string& name) const;
const CgroupController* FindController(const std::string& name) const;
private: private:
struct CgroupFile* cg_file_data_; bool loaded_ = false;
size_t cg_file_size_;
CgroupMap(); CgroupMap();
~CgroupMap();
bool LoadRcFile(); bool LoadRcFile();
void Print() const; void Print() const;
}; };

7
libprocessgroup/cgrouprc/Android.bp
View file

@ -12,10 +12,15 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
cc_library_shared { cc_library {
name: "libcgrouprc", name: "libcgrouprc",
host_supported: true, host_supported: true,
recovery_available: true, recovery_available: true,
// Do not ever mark this as vendor_available; otherwise, vendor modules
// that links to the static library will behave unexpectedly. All on-device
// modules should use libprocessgroup which links to the LL-NDK library
// defined below. The static library is built for tests.
vendor_available: false,
srcs: [ srcs: [
"cgroup_controller.cpp", "cgroup_controller.cpp",
"cgroup_file.cpp", "cgroup_file.cpp",

8
libprocessgroup/processgroup.cpp
View file

@ -56,14 +56,14 @@ using namespace std::chrono_literals;
#define PROCESSGROUP_CGROUP_PROCS_FILE "/cgroup.procs" #define PROCESSGROUP_CGROUP_PROCS_FILE "/cgroup.procs"
bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path) { bool CgroupGetControllerPath(const std::string& cgroup_name, std::string* path) {
const CgroupController* controller = CgroupMap::GetInstance().FindController(cgroup_name); auto controller = CgroupMap::GetInstance().FindController(cgroup_name);
if (controller == nullptr) { if (!controller.HasValue()) {
return false; return false;
} }
if (path) { if (path) {
*path = controller->path(); *path = controller.path();
} }
return true; return true;
@ -107,7 +107,7 @@ bool UsePerAppMemcg() {
static bool isMemoryCgroupSupported() { static bool isMemoryCgroupSupported() {
std::string cgroup_name; std::string cgroup_name;
static bool memcg_supported = (CgroupMap::GetInstance().FindController("memory") != nullptr); static bool memcg_supported = CgroupMap::GetInstance().FindController("memory").HasValue();
return memcg_supported; return memcg_supported;
} }

10
libprocessgroup/sched_policy.cpp
View file

@ -152,21 +152,21 @@ int set_sched_policy(int tid, SchedPolicy policy) {
} }
bool cpusets_enabled() { bool cpusets_enabled() {
static bool enabled = (CgroupMap::GetInstance().FindController("cpuset") != nullptr); static bool enabled = (CgroupMap::GetInstance().FindController("cpuset").HasValue());
return enabled; return enabled;
} }
bool schedboost_enabled() { bool schedboost_enabled() {
static bool enabled = (CgroupMap::GetInstance().FindController("schedtune") != nullptr); static bool enabled = (CgroupMap::GetInstance().FindController("schedtune").HasValue());
return enabled; return enabled;
} }
static int getCGroupSubsys(int tid, const char* subsys, std::string& subgroup) { static int getCGroupSubsys(int tid, const char* subsys, std::string& subgroup) {
const CgroupController* controller = CgroupMap::GetInstance().FindController(subsys); auto controller = CgroupMap::GetInstance().FindController(subsys);
if (!controller) return -1; if (!controller.HasValue()) return -1;
if (!controller->GetTaskGroup(tid, &subgroup)) { if (!controller.GetTaskGroup(tid, &subgroup)) {
LOG(ERROR) << "Failed to find cgroup for tid " << tid; LOG(ERROR) << "Failed to find cgroup for tid " << tid;
return -1; return -1;
} }

25
libprocessgroup/task_profiles.cpp
View file

@ -46,7 +46,7 @@ using android::base::WriteStringToFile;
bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const { bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
std::string subgroup; std::string subgroup;
if (!controller_->GetTaskGroup(tid, &subgroup)) { if (!controller()->GetTaskGroup(tid, &subgroup)) {
return false; return false;
} }
@ -55,9 +55,10 @@ bool ProfileAttribute::GetPathForTask(int tid, std::string* path) const {
} }
if (subgroup.empty()) { if (subgroup.empty()) {
*path = StringPrintf("%s/%s", controller_->path(), file_name_.c_str()); *path = StringPrintf("%s/%s", controller()->path(), file_name_.c_str());
} else { } else {
*path = StringPrintf("%s/%s/%s", controller_->path(), subgroup.c_str(), file_name_.c_str()); *path = StringPrintf("%s/%s/%s", controller()->path(), subgroup.c_str(),
file_name_.c_str());
} }
return true; return true;
} }
@ -135,7 +136,7 @@ bool SetCgroupAction::IsAppDependentPath(const std::string& path) {
return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos; return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;
} }
SetCgroupAction::SetCgroupAction(const CgroupController* c, const std::string& p) SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)
: controller_(c), path_(p) { : controller_(c), path_(p) {
#ifdef CACHE_FILE_DESCRIPTORS #ifdef CACHE_FILE_DESCRIPTORS
// cache file descriptor only if path is app independent // cache file descriptor only if path is app independent
@ -145,7 +146,7 @@ SetCgroupAction::SetCgroupAction(const CgroupController* c, const std::string& p
return; return;
} }
std::string tasks_path = c->GetTasksFilePath(p.c_str()); std::string tasks_path = c.GetTasksFilePath(p);
if (access(tasks_path.c_str(), W_OK) != 0) { if (access(tasks_path.c_str(), W_OK) != 0) {
// file is not accessible // file is not accessible
@ -199,7 +200,7 @@ bool SetCgroupAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
} }
// this is app-dependent path, file descriptor is not cached // this is app-dependent path, file descriptor is not cached
std::string procs_path = controller_->GetProcsFilePath(path_, uid, pid); std::string procs_path = controller()->GetProcsFilePath(path_, uid, pid);
unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(procs_path.c_str(), O_WRONLY | O_CLOEXEC))); unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(procs_path.c_str(), O_WRONLY | O_CLOEXEC)));
if (tmp_fd < 0) { if (tmp_fd < 0) {
PLOG(WARNING) << "Failed to open " << procs_path; PLOG(WARNING) << "Failed to open " << procs_path;
@ -212,7 +213,7 @@ bool SetCgroupAction::ExecuteForProcess(uid_t uid, pid_t pid) const {
return true; return true;
#else #else
std::string procs_path = controller_->GetProcsFilePath(path_, uid, pid); std::string procs_path = controller()->GetProcsFilePath(path_, uid, pid);
unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(procs_path.c_str(), O_WRONLY | O_CLOEXEC))); unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(procs_path.c_str(), O_WRONLY | O_CLOEXEC)));
if (tmp_fd < 0) { if (tmp_fd < 0) {
// no permissions to access the file, ignore // no permissions to access the file, ignore
@ -247,7 +248,7 @@ bool SetCgroupAction::ExecuteForTask(int tid) const {
LOG(ERROR) << "Application profile can't be applied to a thread"; LOG(ERROR) << "Application profile can't be applied to a thread";
return false; return false;
#else #else
std::string tasks_path = controller_->GetTasksFilePath(path_); std::string tasks_path = controller()->GetTasksFilePath(path_);
unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(tasks_path.c_str(), O_WRONLY | O_CLOEXEC))); unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(tasks_path.c_str(), O_WRONLY | O_CLOEXEC)));
if (tmp_fd < 0) { if (tmp_fd < 0) {
// no permissions to access the file, ignore // no permissions to access the file, ignore
@ -326,8 +327,8 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
std::string file_attr = attr[i]["File"].asString(); std::string file_attr = attr[i]["File"].asString();
if (attributes_.find(name) == attributes_.end()) { if (attributes_.find(name) == attributes_.end()) {
const CgroupController* controller = cg_map.FindController(controller_name); auto controller = cg_map.FindController(controller_name);
if (controller) { if (controller.HasValue()) {
attributes_[name] = std::make_unique<ProfileAttribute>(controller, file_attr); attributes_[name] = std::make_unique<ProfileAttribute>(controller, file_attr);
} else { } else {
LOG(WARNING) << "Controller " << controller_name << " is not found"; LOG(WARNING) << "Controller " << controller_name << " is not found";
@ -355,8 +356,8 @@ bool TaskProfiles::Load(const CgroupMap& cg_map, const std::string& file_name) {
std::string controller_name = params_val["Controller"].asString(); std::string controller_name = params_val["Controller"].asString();
std::string path = params_val["Path"].asString(); std::string path = params_val["Path"].asString();
const CgroupController* controller = cg_map.FindController(controller_name); auto controller = cg_map.FindController(controller_name);
if (controller) { if (controller.HasValue()) {
profile->Add(std::make_unique<SetCgroupAction>(controller, path)); profile->Add(std::make_unique<SetCgroupAction>(controller, path));
} else { } else {
LOG(WARNING) << "JoinCgroup: controller " << controller_name << " is not found"; LOG(WARNING) << "JoinCgroup: controller " << controller_name << " is not found";

12
libprocessgroup/task_profiles.h
View file

@ -27,16 +27,16 @@
class ProfileAttribute { class ProfileAttribute {
public: public:
ProfileAttribute(const CgroupController* controller, const std::string& file_name) ProfileAttribute(const CgroupController& controller, const std::string& file_name)
: controller_(controller), file_name_(file_name) {} : controller_(controller), file_name_(file_name) {}
const CgroupController* controller() const { return controller_; } const CgroupController* controller() const { return &controller_; }
const std::string& file_name() const { return file_name_; } const std::string& file_name() const { return file_name_; }
bool GetPathForTask(int tid, std::string* path) const; bool GetPathForTask(int tid, std::string* path) const;
private: private:
const CgroupController* controller_; CgroupController controller_;
std::string file_name_; std::string file_name_;
}; };
@ -106,16 +106,16 @@ class SetAttributeAction : public ProfileAction {
// Set cgroup profile element // Set cgroup profile element
class SetCgroupAction : public ProfileAction { class SetCgroupAction : public ProfileAction {
public: public:
SetCgroupAction(const CgroupController* c, const std::string& p); SetCgroupAction(const CgroupController& c, const std::string& p);
virtual bool ExecuteForProcess(uid_t uid, pid_t pid) const; virtual bool ExecuteForProcess(uid_t uid, pid_t pid) const;
virtual bool ExecuteForTask(int tid) const; virtual bool ExecuteForTask(int tid) const;
const CgroupController* controller() const { return controller_; } const CgroupController* controller() const { return &controller_; }
std::string path() const { return path_; } std::string path() const { return path_; }
private: private:
const CgroupController* controller_; CgroupController controller_;
std::string path_; std::string path_;
#ifdef CACHE_FILE_DESCRIPTORS #ifdef CACHE_FILE_DESCRIPTORS
android::base::unique_fd fd_; android::base::unique_fd fd_;