process_linux.cc revision 58537e28ecd584eab876aee8be7156509866d23a
1// Copyright (c) 2011 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "base/process/process.h" 6 7#include <errno.h> 8#include <sys/resource.h> 9 10#include "base/file_util.h" 11#include "base/lazy_instance.h" 12#include "base/logging.h" 13#include "base/strings/string_split.h" 14#include "base/strings/stringprintf.h" 15#include "base/synchronization/lock.h" 16 17namespace { 18const int kForegroundPriority = 0; 19 20#if defined(OS_CHROMEOS) 21// We are more aggressive in our lowering of background process priority 22// for chromeos as we have much more control over other processes running 23// on the machine. 24// 25// TODO(davemoore) Refactor this by adding support for higher levels to set 26// the foregrounding / backgrounding process so we don't have to keep 27// chrome / chromeos specific logic here. 28const int kBackgroundPriority = 19; 29const char kControlPath[] = "/sys/fs/cgroup/cpu%s/cgroup.procs"; 30const char kForeground[] = "/chrome_renderers/foreground"; 31const char kBackground[] = "/chrome_renderers/background"; 32const char kProcPath[] = "/proc/%d/cgroup"; 33 34struct CGroups { 35 // Check for cgroups files. ChromeOS supports these by default. It creates 36 // a cgroup mount in /sys/fs/cgroup and then configures two cpu task groups, 37 // one contains at most a single foreground renderer and the other contains 38 // all background renderers. This allows us to limit the impact of background 39 // renderers on foreground ones to a greater level than simple renicing. 40 bool enabled; 41 base::FilePath foreground_file; 42 base::FilePath background_file; 43 44 CGroups() { 45 foreground_file = 46 base::FilePath(base::StringPrintf(kControlPath, kForeground)); 47 background_file = 48 base::FilePath(base::StringPrintf(kControlPath, kBackground)); 49 file_util::FileSystemType foreground_type; 50 file_util::FileSystemType background_type; 51 enabled = 52 file_util::GetFileSystemType(foreground_file, &foreground_type) && 53 file_util::GetFileSystemType(background_file, &background_type) && 54 foreground_type == file_util::FILE_SYSTEM_CGROUP && 55 background_type == file_util::FILE_SYSTEM_CGROUP; 56 } 57}; 58 59base::LazyInstance<CGroups> cgroups = LAZY_INSTANCE_INITIALIZER; 60#else 61const int kBackgroundPriority = 5; 62#endif 63} 64 65namespace base { 66 67bool Process::IsProcessBackgrounded() const { 68 DCHECK(process_); 69 70#if defined(OS_CHROMEOS) 71 if (cgroups.Get().enabled) { 72 std::string proc; 73 if (base::ReadFileToString( 74 base::FilePath(StringPrintf(kProcPath, process_)), 75 &proc)) { 76 std::vector<std::string> proc_parts; 77 base::SplitString(proc, ':', &proc_parts); 78 DCHECK(proc_parts.size() == 3); 79 bool ret = proc_parts[2] == std::string(kBackground); 80 return ret; 81 } else { 82 return false; 83 } 84 } 85#endif 86 return GetPriority() == kBackgroundPriority; 87} 88 89bool Process::SetProcessBackgrounded(bool background) { 90 DCHECK(process_); 91 92#if defined(OS_CHROMEOS) 93 if (cgroups.Get().enabled) { 94 std::string pid = StringPrintf("%d", process_); 95 const base::FilePath file = 96 background ? 97 cgroups.Get().background_file : cgroups.Get().foreground_file; 98 return file_util::WriteFile(file, pid.c_str(), pid.size()) > 0; 99 } 100#endif // OS_CHROMEOS 101 102 if (!CanBackgroundProcesses()) 103 return false; 104 105 int priority = background ? kBackgroundPriority : kForegroundPriority; 106 int result = setpriority(PRIO_PROCESS, process_, priority); 107 DPCHECK(result == 0); 108 return result == 0; 109} 110 111struct CheckForNicePermission { 112 CheckForNicePermission() : can_reraise_priority(false) { 113 // We won't be able to raise the priority if we don't have the right rlimit. 114 // The limit may be adjusted in /etc/security/limits.conf for PAM systems. 115 struct rlimit rlim; 116 if ((getrlimit(RLIMIT_NICE, &rlim) == 0) && 117 (20 - kForegroundPriority) <= static_cast<int>(rlim.rlim_cur)) { 118 can_reraise_priority = true; 119 } 120 }; 121 122 bool can_reraise_priority; 123}; 124 125// static 126bool Process::CanBackgroundProcesses() { 127#if defined(OS_CHROMEOS) 128 if (cgroups.Get().enabled) 129 return true; 130#endif 131 132 static LazyInstance<CheckForNicePermission> check_for_nice_permission = 133 LAZY_INSTANCE_INITIALIZER; 134 return check_for_nice_permission.Get().can_reraise_priority; 135} 136 137} // namespace base 138