Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 672cae47 authored by Suren Baghdasaryan's avatar Suren Baghdasaryan Committed by Android (Google) Code Review
Browse files

Merge changes from topic "SetProcessProfilesCached" into sc-v2-dev 

* changes:
  init.rc: Set permissions to cgroup.procs files
  libprocessgroup: Add fd caching support for SetProcessProfiles
  libprocessgroup: Move fd caching code into FdCacheHelper
parents 65f3d094 c5b8f80b

libprocessgroup/include/processgroup/processgroup.h

+2 −0
Original line number Diff line number Diff line
@@ -34,6 +34,8 @@ bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& pr 


#ifndef __ANDROID_VNDK__



bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);



static constexpr const char* CGROUPS_RC_PATH = "/dev/cgroup_info/cgroup.rc";



bool UsePerAppMemcg();

libprocessgroup/processgroup.cpp

+7 −2
Original line number Diff line number Diff line
@@ -112,11 +112,16 @@ static bool isMemoryCgroupSupported() { 
}



void DropTaskProfilesResourceCaching() {

    TaskProfiles::GetInstance().DropResourceCaching();

    TaskProfiles::GetInstance().DropResourceCaching(ProfileAction::RCT_TASK);

    TaskProfiles::GetInstance().DropResourceCaching(ProfileAction::RCT_PROCESS);

}



bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles) {

    return TaskProfiles::GetInstance().SetProcessProfiles(uid, pid, profiles);

    return TaskProfiles::GetInstance().SetProcessProfiles(uid, pid, profiles, false);

}



bool SetProcessProfilesCached(uid_t uid, pid_t pid, const std::vector<std::string>& profiles) {

    return TaskProfiles::GetInstance().SetProcessProfiles(uid, pid, profiles, true);

}



bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache) {

libprocessgroup/task_profiles.cpp

+189 −107
Original line number Diff line number Diff line
@@ -51,6 +51,67 @@ static constexpr const char* TASK_PROFILE_DB_VENDOR_FILE = "/vendor/etc/task_pro 
static constexpr const char* TEMPLATE_TASK_PROFILE_API_FILE =

        "/etc/task_profiles/task_profiles_%u.json";



class FdCacheHelper {

  public:

    enum FdState {

        FDS_INACCESSIBLE = -1,

        FDS_APP_DEPENDENT = -2,

        FDS_NOT_CACHED = -3,

    };



    static void Cache(const std::string& path, android::base::unique_fd& fd);

    static void Drop(android::base::unique_fd& fd);

    static void Init(const std::string& path, android::base::unique_fd& fd);

    static bool IsCached(const android::base::unique_fd& fd) { return fd > FDS_INACCESSIBLE; }



  private:

    static bool IsAppDependentPath(const std::string& path);

};



void FdCacheHelper::Init(const std::string& path, android::base::unique_fd& fd) {

    // file descriptors for app-dependent paths can't be cached

    if (IsAppDependentPath(path)) {

        // file descriptor is not cached

        fd.reset(FDS_APP_DEPENDENT);

        return;

    }

    // file descriptor can be cached later on request

    fd.reset(FDS_NOT_CACHED);

}



void FdCacheHelper::Cache(const std::string& path, android::base::unique_fd& fd) {

    if (fd != FDS_NOT_CACHED) {

        return;

    }



    if (access(path.c_str(), W_OK) != 0) {

        // file is not accessible

        fd.reset(FDS_INACCESSIBLE);

        return;

    }



    unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_WRONLY | O_CLOEXEC)));

    if (tmp_fd < 0) {

        PLOG(ERROR) << "Failed to cache fd '" << path << "'";

        fd.reset(FDS_INACCESSIBLE);

        return;

    }



    fd = std::move(tmp_fd);

}



void FdCacheHelper::Drop(android::base::unique_fd& fd) {

    if (fd == FDS_NOT_CACHED) {

        return;

    }



    fd.reset(FDS_NOT_CACHED);

}



bool FdCacheHelper::IsAppDependentPath(const std::string& path) {

    return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;

}



void ProfileAttribute::Reset(const CgroupController& controller, const std::string& file_name) {

    controller_ = controller;

    file_name_ = file_name;
@@ -144,57 +205,11 @@ bool SetAttributeAction::ExecuteForTask(int tid) const { 
    return true;

}



void CachedFdProfileAction::EnableResourceCaching() {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    if (fd_ != FDS_NOT_CACHED) {

        return;

    }



    std::string tasks_path = GetPath();



    if (access(tasks_path.c_str(), W_OK) != 0) {

        // file is not accessible

        fd_.reset(FDS_INACCESSIBLE);

        return;

    }



    unique_fd fd(TEMP_FAILURE_RETRY(open(tasks_path.c_str(), O_WRONLY | O_CLOEXEC)));

    if (fd < 0) {

        PLOG(ERROR) << "Failed to cache fd '" << tasks_path << "'";

        fd_.reset(FDS_INACCESSIBLE);

        return;

    }



    fd_ = std::move(fd);

}



void CachedFdProfileAction::DropResourceCaching() {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    if (fd_ == FDS_NOT_CACHED) {

        return;

    }



    fd_.reset(FDS_NOT_CACHED);

}



bool CachedFdProfileAction::IsAppDependentPath(const std::string& path) {

    return path.find("<uid>", 0) != std::string::npos || path.find("<pid>", 0) != std::string::npos;

}



void CachedFdProfileAction::InitFd(const std::string& path) {

    // file descriptors for app-dependent paths can't be cached

    if (IsAppDependentPath(path)) {

        // file descriptor is not cached

        fd_.reset(FDS_APP_DEPENDENT);

        return;

    }

    // file descriptor can be cached later on request

    fd_.reset(FDS_NOT_CACHED);

}



SetCgroupAction::SetCgroupAction(const CgroupController& c, const std::string& p)

    : controller_(c), path_(p) {

    InitFd(controller_.GetTasksFilePath(path_));

    FdCacheHelper::Init(controller_.GetTasksFilePath(path_), fd_[ProfileAction::RCT_TASK]);

    // uid and pid don't matter because IsAppDependentPath ensures the path doesn't use them

    FdCacheHelper::Init(controller_.GetProcsFilePath(path_, 0, 0), fd_[ProfileAction::RCT_PROCESS]);

}



bool SetCgroupAction::AddTidToCgroup(int tid, int fd, const char* controller_name) {
@@ -232,7 +247,40 @@ bool SetCgroupAction::AddTidToCgroup(int tid, int fd, const char* controller_nam 
    return false;

}



ProfileAction::CacheUseResult SetCgroupAction::UseCachedFd(ResourceCacheType cache_type,

                                                           int id) const {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    if (FdCacheHelper::IsCached(fd_[cache_type])) {

        // fd is cached, reuse it

        if (!AddTidToCgroup(id, fd_[cache_type], controller()->name())) {

            LOG(ERROR) << "Failed to add task into cgroup";

            return ProfileAction::FAIL;

        }

        return ProfileAction::SUCCESS;

    }



    if (fd_[cache_type] == FdCacheHelper::FDS_INACCESSIBLE) {

        // no permissions to access the file, ignore

        return ProfileAction::SUCCESS;

    }



    if (cache_type == ResourceCacheType::RCT_TASK &&

        fd_[cache_type] == FdCacheHelper::FDS_APP_DEPENDENT) {

        // application-dependent path can't be used with tid

        PLOG(ERROR) << "Application profile can't be applied to a thread";

        return ProfileAction::FAIL;

    }



    return ProfileAction::UNUSED;

}



bool SetCgroupAction::ExecuteForProcess(uid_t uid, pid_t pid) const {

    CacheUseResult result = UseCachedFd(ProfileAction::RCT_PROCESS, pid);

    if (result != ProfileAction::UNUSED) {

        return result == ProfileAction::SUCCESS;

    }



    // fd was not cached or cached fd can't be used

    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)));

    if (tmp_fd < 0) {
@@ -248,28 +296,12 @@ bool SetCgroupAction::ExecuteForProcess(uid_t uid, pid_t pid) const { 
}



bool SetCgroupAction::ExecuteForTask(int tid) const {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    if (IsFdValid()) {

        // fd is cached, reuse it

        if (!AddTidToCgroup(tid, fd_, controller()->name())) {

            LOG(ERROR) << "Failed to add task into cgroup";

            return false;

        }

        return true;

    }



    if (fd_ == FDS_INACCESSIBLE) {

        // no permissions to access the file, ignore

        return true;

    }



    if (fd_ == FDS_APP_DEPENDENT) {

        // application-dependent path can't be used with tid

        PLOG(ERROR) << "Application profile can't be applied to a thread";

        return false;

    CacheUseResult result = UseCachedFd(ProfileAction::RCT_TASK, tid);

    if (result != ProfileAction::UNUSED) {

        return result == ProfileAction::SUCCESS;

    }



    // fd was not cached because cached fd can't be used

    // fd was not cached or cached fd can't be used

    std::string tasks_path = controller()->GetTasksFilePath(path_);

    unique_fd tmp_fd(TEMP_FAILURE_RETRY(open(tasks_path.c_str(), O_WRONLY | O_CLOEXEC)));

    if (tmp_fd < 0) {
@@ -284,10 +316,36 @@ bool SetCgroupAction::ExecuteForTask(int tid) const { 
    return true;

}



void SetCgroupAction::EnableResourceCaching(ResourceCacheType cache_type) {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    // Return early to prevent unnecessary calls to controller_.Get{Tasks|Procs}FilePath() which

    // include regex evaluations

    if (fd_[cache_type] != FdCacheHelper::FDS_NOT_CACHED) {

        return;

    }

    switch (cache_type) {

        case (ProfileAction::RCT_TASK):

            FdCacheHelper::Cache(controller_.GetTasksFilePath(path_), fd_[cache_type]);

            break;

        case (ProfileAction::RCT_PROCESS):

            // uid and pid don't matter because IsAppDependentPath ensures the path doesn't use them

            FdCacheHelper::Cache(controller_.GetProcsFilePath(path_, 0, 0), fd_[cache_type]);

            break;

        default:

            LOG(ERROR) << "Invalid cache type is specified!";

            break;

    }

}



void SetCgroupAction::DropResourceCaching(ResourceCacheType cache_type) {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    FdCacheHelper::Drop(fd_[cache_type]);

}



WriteFileAction::WriteFileAction(const std::string& path, const std::string& value,

                                 bool logfailures)

    : path_(path), value_(value), logfailures_(logfailures) {

    InitFd(path_);

    FdCacheHelper::Init(path_, fd_);

}



bool WriteFileAction::WriteValueToFile(const std::string& value, const std::string& path,
@@ -309,13 +367,43 @@ bool WriteFileAction::WriteValueToFile(const std::string& value, const std::stri 
    return true;

}



bool WriteFileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {

ProfileAction::CacheUseResult WriteFileAction::UseCachedFd(ResourceCacheType cache_type,

                                                           const std::string& value) const {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    if (FdCacheHelper::IsCached(fd_)) {

        // fd is cached, reuse it

        if (!WriteStringToFd(value, fd_)) {

            if (logfailures_) PLOG(ERROR) << "Failed to write '" << value << "' to " << path_;

            return ProfileAction::FAIL;

        }

        return ProfileAction::SUCCESS;

    }



    if (fd_ == FdCacheHelper::FDS_INACCESSIBLE) {

        // no permissions to access the file, ignore

        return ProfileAction::SUCCESS;

    }



    if (cache_type == ResourceCacheType::RCT_TASK && fd_ == FdCacheHelper::FDS_APP_DEPENDENT) {

        // application-dependent path can't be used with tid

        PLOG(ERROR) << "Application profile can't be applied to a thread";

        return ProfileAction::FAIL;

    }

    return ProfileAction::UNUSED;

}



bool WriteFileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {

    std::string value(value_);

    std::string path(path_);



    value = StringReplace(value, "<uid>", std::to_string(uid), true);

    value = StringReplace(value, "<pid>", std::to_string(pid), true);



    CacheUseResult result = UseCachedFd(ProfileAction::RCT_PROCESS, value);

    if (result != ProfileAction::UNUSED) {

        return result == ProfileAction::SUCCESS;

    }



    std::string path(path_);

    path = StringReplace(path, "<uid>", std::to_string(uid), true);

    path = StringReplace(path, "<pid>", std::to_string(pid), true);
@@ -323,41 +411,33 @@ bool WriteFileAction::ExecuteForProcess(uid_t uid, pid_t pid) const { 
}



bool WriteFileAction::ExecuteForTask(int tid) const {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    std::string value(value_);

    int uid = getuid();



    value = StringReplace(value, "<uid>", std::to_string(uid), true);

    value = StringReplace(value, "<pid>", std::to_string(tid), true);



    if (IsFdValid()) {

        // fd is cached, reuse it

        if (!WriteStringToFd(value, fd_)) {

            if (logfailures_) PLOG(ERROR) << "Failed to write '" << value << "' to " << path_;

            return false;

        }

        return true;

    CacheUseResult result = UseCachedFd(ProfileAction::RCT_TASK, value);

    if (result != ProfileAction::UNUSED) {

        return result == ProfileAction::SUCCESS;

    }



    if (fd_ == FDS_INACCESSIBLE) {

        // no permissions to access the file, ignore

        return true;

    return WriteValueToFile(value, path_, logfailures_);

}



    if (fd_ == FDS_APP_DEPENDENT) {

        // application-dependent path can't be used with tid

        PLOG(ERROR) << "Application profile can't be applied to a thread";

        return false;

void WriteFileAction::EnableResourceCaching(ResourceCacheType) {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    FdCacheHelper::Cache(path_, fd_);

}



    return WriteValueToFile(value, path_, logfailures_);

void WriteFileAction::DropResourceCaching(ResourceCacheType) {

    std::lock_guard<std::mutex> lock(fd_mutex_);

    FdCacheHelper::Drop(fd_);

}



bool ApplyProfileAction::ExecuteForProcess(uid_t uid, pid_t pid) const {

    for (const auto& profile : profiles_) {

        if (!profile->ExecuteForProcess(uid, pid)) {

            PLOG(WARNING) << "ExecuteForProcess failed for aggregate profile";

        }

        profile->ExecuteForProcess(uid, pid);

    }

    return true;

}
@@ -369,15 +449,15 @@ bool ApplyProfileAction::ExecuteForTask(int tid) const { 
    return true;

}



void ApplyProfileAction::EnableResourceCaching() {

void ApplyProfileAction::EnableResourceCaching(ResourceCacheType cache_type) {

    for (const auto& profile : profiles_) {

        profile->EnableResourceCaching();

        profile->EnableResourceCaching(cache_type);

    }

}



void ApplyProfileAction::DropResourceCaching() {

void ApplyProfileAction::DropResourceCaching(ResourceCacheType cache_type) {

    for (const auto& profile : profiles_) {

        profile->DropResourceCaching();

        profile->DropResourceCaching(cache_type);

    }

}
@@ -407,33 +487,33 @@ bool TaskProfile::ExecuteForTask(int tid) const { 
    return true;

}



void TaskProfile::EnableResourceCaching() {

void TaskProfile::EnableResourceCaching(ProfileAction::ResourceCacheType cache_type) {

    if (res_cached_) {

        return;

    }



    for (auto& element : elements_) {

        element->EnableResourceCaching();

        element->EnableResourceCaching(cache_type);

    }



    res_cached_ = true;

}



void TaskProfile::DropResourceCaching() {

void TaskProfile::DropResourceCaching(ProfileAction::ResourceCacheType cache_type) {

    if (!res_cached_) {

        return;

    }



    for (auto& element : elements_) {

        element->DropResourceCaching();

        element->DropResourceCaching(cache_type);

    }



    res_cached_ = false;

}



void TaskProfiles::DropResourceCaching() const {

void TaskProfiles::DropResourceCaching(ProfileAction::ResourceCacheType cache_type) const {

    for (auto& iter : profiles_) {

        iter.second->DropResourceCaching();

        iter.second->DropResourceCaching(cache_type);

    }

}
@@ -457,8 +537,7 @@ TaskProfiles::TaskProfiles() { 
                android::base::StringPrintf(TEMPLATE_TASK_PROFILE_API_FILE, api_level);

        if (!access(api_profiles_path.c_str(), F_OK) || errno != ENOENT) {

            if (!Load(CgroupMap::GetInstance(), api_profiles_path)) {

                LOG(ERROR) << "Loading " << api_profiles_path << " for [" << getpid()

                           << "] failed";

                LOG(ERROR) << "Loading " << api_profiles_path << " for [" << getpid() << "] failed";

            }

        }

    }
@@ -651,10 +730,13 @@ const ProfileAttribute* TaskProfiles::GetAttribute(const std::string& name) cons 
}



bool TaskProfiles::SetProcessProfiles(uid_t uid, pid_t pid,

                                      const std::vector<std::string>& profiles) {

                                      const std::vector<std::string>& profiles, bool use_fd_cache) {

    for (const auto& name : profiles) {

        TaskProfile* profile = GetProfile(name);

        if (profile != nullptr) {

            if (use_fd_cache) {

                profile->EnableResourceCaching(ProfileAction::RCT_PROCESS);

            }

            if (!profile->ExecuteForProcess(uid, pid)) {

                PLOG(WARNING) << "Failed to apply " << name << " process profile";

            }
@@ -671,7 +753,7 @@ bool TaskProfiles::SetTaskProfiles(int tid, const std::vector<std::string>& prof 
        TaskProfile* profile = GetProfile(name);

        if (profile != nullptr) {

            if (use_fd_cache) {

                profile->EnableResourceCaching();

                profile->EnableResourceCaching(ProfileAction::RCT_TASK);

            }

            if (!profile->ExecuteForTask(tid)) {

                PLOG(WARNING) << "Failed to apply " << name << " task profile";

libprocessgroup/task_profiles.h

+26 −40
Original line number Diff line number Diff line
@@ -45,14 +45,19 @@ class ProfileAttribute { 
// Abstract profile element

class ProfileAction {

  public:

    enum ResourceCacheType { RCT_TASK = 0, RCT_PROCESS, RCT_COUNT };



    virtual ~ProfileAction() {}



    // Default implementations will fail

    virtual bool ExecuteForProcess(uid_t, pid_t) const { return false; };

    virtual bool ExecuteForTask(int) const { return false; };



    virtual void EnableResourceCaching() {}

    virtual void DropResourceCaching() {}

    virtual void EnableResourceCaching(ResourceCacheType) {}

    virtual void DropResourceCaching(ResourceCacheType) {}



  protected:

    enum CacheUseResult { SUCCESS, FAIL, UNUSED };

};



// Profile actions
@@ -108,67 +113,47 @@ class SetAttributeAction : public ProfileAction { 
    std::string value_;

};



// Abstract profile element for cached fd

class CachedFdProfileAction : public ProfileAction {

  public:

    virtual void EnableResourceCaching();

    virtual void DropResourceCaching();



  protected:

    enum FdState {

        FDS_INACCESSIBLE = -1,

        FDS_APP_DEPENDENT = -2,

        FDS_NOT_CACHED = -3,

    };



    android::base::unique_fd fd_;

    mutable std::mutex fd_mutex_;



    static bool IsAppDependentPath(const std::string& path);



    void InitFd(const std::string& path);

    bool IsFdValid() const { return fd_ > FDS_INACCESSIBLE; }



    virtual const std::string GetPath() const = 0;

};



// Set cgroup profile element

class SetCgroupAction : public CachedFdProfileAction {

class SetCgroupAction : public ProfileAction {

  public:

    SetCgroupAction(const CgroupController& c, const std::string& p);



    virtual bool ExecuteForProcess(uid_t uid, pid_t pid) const;

    virtual bool ExecuteForTask(int tid) const;

    virtual void EnableResourceCaching(ResourceCacheType cache_type);

    virtual void DropResourceCaching(ResourceCacheType cache_type);



    const CgroupController* controller() const { return &controller_; }



  protected:

    const std::string GetPath() const override { return controller_.GetTasksFilePath(path_); }



  private:

    CgroupController controller_;

    std::string path_;

    android::base::unique_fd fd_[ProfileAction::RCT_COUNT];

    mutable std::mutex fd_mutex_;



    static bool AddTidToCgroup(int tid, int fd, const char* controller_name);

    CacheUseResult UseCachedFd(ResourceCacheType cache_type, int id) const;

};



// Write to file action

class WriteFileAction : public CachedFdProfileAction {

class WriteFileAction : public ProfileAction {

  public:

    WriteFileAction(const std::string& path, const std::string& value, bool logfailures);



    virtual bool ExecuteForProcess(uid_t uid, pid_t pid) const;

    virtual bool ExecuteForTask(int tid) const;



  protected:

    const std::string GetPath() const override { return path_; }

    virtual void EnableResourceCaching(ResourceCacheType cache_type);

    virtual void DropResourceCaching(ResourceCacheType cache_type);



  private:

    std::string path_, value_;

    bool logfailures_;

    android::base::unique_fd fd_;

    mutable std::mutex fd_mutex_;



    static bool WriteValueToFile(const std::string& value, const std::string& path,

                                 bool logfailures);

    CacheUseResult UseCachedFd(ResourceCacheType cache_type, const std::string& value) const;

};



class TaskProfile {
@@ -180,8 +165,8 @@ class TaskProfile { 


    bool ExecuteForProcess(uid_t uid, pid_t pid) const;

    bool ExecuteForTask(int tid) const;

    void EnableResourceCaching();

    void DropResourceCaching();

    void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);

    void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);



  private:

    bool res_cached_;
@@ -196,8 +181,8 @@ class ApplyProfileAction : public ProfileAction { 


    virtual bool ExecuteForProcess(uid_t uid, pid_t pid) const;

    virtual bool ExecuteForTask(int tid) const;

    virtual void EnableResourceCaching();

    virtual void DropResourceCaching();

    virtual void EnableResourceCaching(ProfileAction::ResourceCacheType cache_type);

    virtual void DropResourceCaching(ProfileAction::ResourceCacheType cache_type);



  private:

    std::vector<std::shared_ptr<TaskProfile>> profiles_;
@@ -210,8 +195,9 @@ class TaskProfiles { 


    TaskProfile* GetProfile(const std::string& name) const;

    const ProfileAttribute* GetAttribute(const std::string& name) const;

    void DropResourceCaching() const;

    bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles);

    void DropResourceCaching(ProfileAction::ResourceCacheType cache_type) const;

    bool SetProcessProfiles(uid_t uid, pid_t pid, const std::vector<std::string>& profiles,

                            bool use_fd_cache);

    bool SetTaskProfiles(int tid, const std::vector<std::string>& profiles, bool use_fd_cache);



  private:

rootdir/init.rc

+52 −0

File changed.

Preview size limit exceeded, changes collapsed.