// Copyright (c) 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/process/process.h" #include #include #include #include "base/check.h" #include "base/files/file_util.h" #include "base/location.h" #include "base/logging.h" #include "base/notreached.h" #include "base/posix/can_lower_nice_to.h" #include "base/process/internal_linux.h" #include "base/strings/string_number_conversions.h" #include "base/strings/string_split.h" #include "base/strings/stringprintf.h" #include "base/threading/thread_restrictions.h" #include "build/build_config.h" #include "build/chromeos_buildflags.h" #if BUILDFLAG(IS_CHROMEOS) #include "base/bind.h" #include "base/feature_list.h" #include "base/files/file_enumerator.h" #include "base/files/file_path.h" #include "base/process/process_handle.h" #include "base/strings/strcat.h" #include "base/strings/string_util.h" #include "base/task/thread_pool.h" #include "base/unguessable_token.h" #endif // BUILDFLAG(IS_CHROMEOS) namespace base { #if BUILDFLAG(IS_CHROMEOS) const Feature kOneGroupPerRenderer { "OneGroupPerRenderer", #if BUILDFLAG(IS_CHROMEOS_LACROS) FEATURE_ENABLED_BY_DEFAULT }; #else FEATURE_DISABLED_BY_DEFAULT }; #endif // BUILDFLAG(IS_CHROMEOS_LACROS) #endif // BUILDFLAG(IS_CHROMEOS) namespace { const int kForegroundPriority = 0; #if BUILDFLAG(IS_CHROMEOS) // We are more aggressive in our lowering of background process priority // for chromeos as we have much more control over other processes running // on the machine. // // TODO(davemoore) Refactor this by adding support for higher levels to set // the foregrounding / backgrounding process so we don't have to keep // chrome / chromeos specific logic here. const int kBackgroundPriority = 19; const char kControlPath[] = "/sys/fs/cgroup/cpu%s/cgroup.procs"; const char kFullRendererCgroupRoot[] = "/sys/fs/cgroup/cpu/chrome_renderers"; const char kForeground[] = "/chrome_renderers/foreground"; const char kBackground[] = "/chrome_renderers/background"; const char kProcPath[] = "/proc/%d/cgroup"; const char kUclampMinFile[] = "cpu.uclamp.min"; const char kUclampMaxFile[] = "cpu.uclamp.max"; constexpr int kCgroupDeleteRetries = 3; constexpr TimeDelta kCgroupDeleteRetryTime(Seconds(1)); #if BUILDFLAG(IS_CHROMEOS_LACROS) const char kCgroupPrefix[] = "l-"; #elif BUILDFLAG(IS_CHROMEOS_ASH) const char kCgroupPrefix[] = "a-"; #endif struct CGroups { // Check for cgroups files. ChromeOS supports these by default. It creates // a cgroup mount in /sys/fs/cgroup and then configures two cpu task groups, // one contains at most a single foreground renderer and the other contains // all background renderers. This allows us to limit the impact of background // renderers on foreground ones to a greater level than simple renicing. bool enabled; FilePath foreground_file; FilePath background_file; // A unique token for this instance of the browser. std::string group_prefix_token; // UCLAMP settings for the foreground cgroups. std::string uclamp_min; std::string uclamp_max; CGroups() { foreground_file = FilePath(StringPrintf(kControlPath, kForeground)); background_file = FilePath(StringPrintf(kControlPath, kBackground)); FileSystemType foreground_type; FileSystemType background_type; enabled = GetFileSystemType(foreground_file, &foreground_type) && GetFileSystemType(background_file, &background_type) && foreground_type == FILE_SYSTEM_CGROUP && background_type == FILE_SYSTEM_CGROUP; if (!enabled || !FeatureList::IsEnabled(kOneGroupPerRenderer)) { return; } // Generate a unique token for the full browser process group_prefix_token = StrCat({kCgroupPrefix, UnguessableToken::Create().ToString(), "-"}); // Reads the ULCAMP settings from the foreground cgroup that will be used // for each renderer's cgroup. FilePath foreground_path = foreground_file.DirName(); ReadFileToString(foreground_path.Append(kUclampMinFile), &uclamp_min); ReadFileToString(foreground_path.Append(kUclampMaxFile), &uclamp_max); } // Returns the full path to a the cgroup dir of a process using // the supplied token. static FilePath GetForegroundCgroupDir(const std::string& token) { // Get individualized cgroup if the feature is enabled std::string cgroup_path_str; StrAppend(&cgroup_path_str, {kFullRendererCgroupRoot, "/", token}); return FilePath(cgroup_path_str); } // Returns the path to the cgroup.procs file of the foreground cgroup. static FilePath GetForegroundCgroupFile(const std::string& token) { // Processes with an empty token use the default foreground cgroup. if (token.empty()) { return CGroups::Get().foreground_file; } FilePath cgroup_path = GetForegroundCgroupDir(token); return cgroup_path.Append("cgroup.procs"); } static CGroups& Get() { static auto& groups = *new CGroups; return groups; } }; // Returns true if the 'OneGroupPerRenderer' feature is enabled. The feature // is enabled if the kOneGroupPerRenderer feature flag is enabled and the // system supports the chrome cgroups. Will block if this is the first call // that will read the cgroup configs. bool OneGroupPerRendererEnabled() { return FeatureList::IsEnabled(kOneGroupPerRenderer) && CGroups::Get().enabled; } #else const int kBackgroundPriority = 5; #endif // BUILDFLAG(IS_CHROMEOS) } // namespace Time Process::CreationTime() const { int64_t start_ticks = is_current() ? internal::ReadProcSelfStatsAndGetFieldAsInt64( internal::VM_STARTTIME) : internal::ReadProcStatsAndGetFieldAsInt64( Pid(), internal::VM_STARTTIME); if (!start_ticks) return Time(); TimeDelta start_offset = internal::ClockTicksToTimeDelta(start_ticks); Time boot_time = internal::GetBootTime(); if (boot_time.is_null()) return Time(); return Time(boot_time + start_offset); } // static bool Process::CanBackgroundProcesses() { #if BUILDFLAG(IS_CHROMEOS) if (CGroups::Get().enabled) return true; #endif // BUILDFLAG(IS_CHROMEOS) static const bool can_reraise_priority = internal::CanLowerNiceTo(kForegroundPriority); return can_reraise_priority; } bool Process::IsProcessBackgrounded() const { DCHECK(IsValid()); #if BUILDFLAG(IS_CHROMEOS) if (CGroups::Get().enabled) { // Used to allow reading the process priority from proc on thread launch. ThreadRestrictions::ScopedAllowIO allow_io; std::string proc; if (ReadFileToString(FilePath(StringPrintf(kProcPath, process_)), &proc)) { return IsProcessBackgroundedCGroup(proc); } return false; } #endif // BUILDFLAG(IS_CHROMEOS) return GetPriority() == kBackgroundPriority; } bool Process::SetProcessBackgrounded(bool background) { DCHECK(IsValid()); #if BUILDFLAG(IS_CHROMEOS) if (CGroups::Get().enabled) { std::string pid = NumberToString(process_); const FilePath file = background ? CGroups::Get().background_file : CGroups::Get().GetForegroundCgroupFile(unique_token_); return WriteFile(file, pid); } #endif // BUILDFLAG(IS_CHROMEOS) if (!CanBackgroundProcesses()) return false; int priority = background ? kBackgroundPriority : kForegroundPriority; int result = setpriority(PRIO_PROCESS, static_cast(process_), priority); DPCHECK(result == 0); return result == 0; } #if BUILDFLAG(IS_CHROMEOS) bool IsProcessBackgroundedCGroup(const StringPiece& cgroup_contents) { // The process can be part of multiple control groups, and for each cgroup // hierarchy there's an entry in the file. We look for a control group // named "/chrome_renderers/background" to determine if the process is // backgrounded. crbug.com/548818. std::vector lines = SplitStringPiece( cgroup_contents, "\n", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY); for (const auto& line : lines) { std::vector fields = SplitStringPiece(line, ":", TRIM_WHITESPACE, SPLIT_WANT_ALL); if (fields.size() != 3U) { NOTREACHED(); continue; } if (fields[2] == kBackground) return true; } return false; } #endif // BUILDFLAG(IS_CHROMEOS) #if BUILDFLAG(IS_CHROMEOS_ASH) // Reads /proc//status and returns the PID in its PID namespace. // If the process is not in a PID namespace or /proc//status does not // report NSpid, kNullProcessId is returned. ProcessId Process::GetPidInNamespace() const { std::string status; { // Synchronously reading files in /proc does not hit the disk. ThreadRestrictions::ScopedAllowIO allow_io; FilePath status_file = FilePath("/proc").Append(NumberToString(process_)).Append("status"); if (!ReadFileToString(status_file, &status)) { return kNullProcessId; } } StringPairs pairs; SplitStringIntoKeyValuePairs(status, ':', '\n', &pairs); for (const auto& pair : pairs) { const std::string& key = pair.first; const std::string& value_str = pair.second; if (key == "NSpid") { std::vector split_value_str = SplitStringPiece( value_str, "\t", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY); if (split_value_str.size() <= 1) { return kNullProcessId; } int value; // The last value in the list is the PID in the namespace. if (!StringToInt(split_value_str.back(), &value)) { NOTREACHED(); return kNullProcessId; } return value; } } return kNullProcessId; } #endif // BUILDFLAG(IS_CHROMEOS_ASH) #if BUILDFLAG(IS_CHROMEOS) // static bool Process::OneGroupPerRendererEnabledForTesting() { return OneGroupPerRendererEnabled(); } // On Chrome OS, each renderer runs in its own cgroup when running in the // foreground. After process creation the cgroup is created using a // unique token. void Process::InitializePriority() { if (!OneGroupPerRendererEnabled() || !IsValid() || !unique_token_.empty()) { return; } // The token has the following format: // {cgroup_prefix}{UnguessableToken} // The cgroup prefix is to distinguish ash from lacros tokens for stale // cgroup cleanup. unique_token_ = StrCat({CGroups::Get().group_prefix_token, UnguessableToken::Create().ToString()}); FilePath cgroup_path = CGroups::Get().GetForegroundCgroupDir(unique_token_); // Note that CreateDirectoryAndGetError() does not fail if the directory // already exits. if (!CreateDirectoryAndGetError(cgroup_path, nullptr)) { // If creating the directory fails, fall back to use the foreground group. int saved_errno = errno; LOG(ERROR) << "Failed to create cgroup, falling back to foreground" << ", cgroup=" << cgroup_path << ", errno=" << strerror(saved_errno); unique_token_.clear(); return; } if (!CGroups::Get().uclamp_min.empty() && !WriteFile(cgroup_path.Append(kUclampMinFile), CGroups::Get().uclamp_min)) { LOG(ERROR) << "Failed to write uclamp min file, cgroup_path=" << cgroup_path; } if (!CGroups::Get().uclamp_min.empty() && !WriteFile(cgroup_path.Append(kUclampMaxFile), CGroups::Get().uclamp_max)) { LOG(ERROR) << "Failed to write uclamp max file, cgroup_path=" << cgroup_path; } } // static void Process::CleanUpProcessScheduled(Process process, int remaining_retries) { process.CleanUpProcess(remaining_retries); } void Process::CleanUpProcessAsync() const { if (!FeatureList::IsEnabled(kOneGroupPerRenderer) || unique_token_.empty()) { return; } ThreadPool::PostTask(FROM_HERE, {MayBlock(), TaskPriority::BEST_EFFORT}, BindOnce(&Process::CleanUpProcessScheduled, Duplicate(), kCgroupDeleteRetries)); } void Process::CleanUpProcess(int remaining_retries) const { if (!OneGroupPerRendererEnabled() || unique_token_.empty()) { return; } // Try to delete the cgroup // TODO(1322562): We can use notify_on_release to automoatically delete the // cgroup when the process has left the cgroup. FilePath cgroup = CGroups::Get().GetForegroundCgroupDir(unique_token_); if (!DeleteFile(cgroup)) { auto saved_errno = errno; LOG(ERROR) << "Failed to delete cgroup " << cgroup << ", errno=" << strerror(saved_errno); // If the delete failed, then the process is still potentially in the // cgroup. Move the process to background and schedule a callback to try // again. if (remaining_retries > 0) { std::string pidstr = NumberToString(process_); if (!WriteFile(CGroups::Get().background_file, pidstr)) { // Failed to move the process, LOG a warning but try again. saved_errno = errno; LOG(WARNING) << "Failed to move the process to background" << ", pid=" << pidstr << ", errno=" << strerror(saved_errno); } ThreadPool::PostDelayedTask(FROM_HERE, {MayBlock(), TaskPriority::BEST_EFFORT}, BindOnce(&Process::CleanUpProcessScheduled, Duplicate(), remaining_retries - 1), kCgroupDeleteRetryTime); } } } // static void Process::CleanUpStaleProcessStates() { if (!OneGroupPerRendererEnabled()) { return; } FileEnumerator traversal(FilePath(kFullRendererCgroupRoot), false, FileEnumerator::DIRECTORIES); for (FilePath path = traversal.Next(); !path.empty(); path = traversal.Next()) { std::string dirname = path.BaseName().value(); if (dirname == FilePath(kForeground).BaseName().value() || dirname == FilePath(kBackground).BaseName().value()) { continue; } if (!StartsWith(dirname, kCgroupPrefix) || StartsWith(dirname, CGroups::Get().group_prefix_token)) { continue; } if (!DeleteFile(path)) { auto saved_errno = errno; LOG(ERROR) << "Failed to delete " << path << ", errno=" << strerror(saved_errno); } } } #endif // BUILDFLAG(IS_CHROMEOS) } // namespace base