Merge changes from topic "SetProcessProfilesCached" am: d950242c0d am: 1936f4cc48 (22bd193d) · Commits · e / os / android_system_core

libprocessgroup/include/processgroup/processgroup.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -35,6 +35,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
		@@ -126,11 +126,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.