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
17 namespace base {
18
19 namespace {
20 const int kForegroundPriority = 0;
21
22 #if defined(OS_CHROMEOS)
23 // We are more aggressive in our lowering of background process priority
24 // for chromeos as we have much more control over other processes running
25 // on the machine.
26 //
27 // TODO(davemoore) Refactor this by adding support for higher levels to set
28 // the foregrounding / backgrounding process so we don't have to keep
29 // chrome / chromeos specific logic here.
30 const int kBackgroundPriority = 19;
31 const char kControlPath[] = "/sys/fs/cgroup/cpu%s/cgroup.procs";
32 const char kForeground[] = "/chrome_renderers/foreground";
33 const char kBackground[] = "/chrome_renderers/background";
34 const char kProcPath[] = "/proc/%d/cgroup";
35
36 struct CGroups {
37 // Check for cgroups files. ChromeOS supports these by default. It creates
38 // a cgroup mount in /sys/fs/cgroup and then configures two cpu task groups,
39 // one contains at most a single foreground renderer and the other contains
40 // all background renderers. This allows us to limit the impact of background
41 // renderers on foreground ones to a greater level than simple renicing.
42 bool enabled;
43 base::FilePath foreground_file;
44 base::FilePath background_file;
45
CGroupsbase::__anon832ced490111::CGroups46 CGroups() {
47 foreground_file =
48 base::FilePath(base::StringPrintf(kControlPath, kForeground));
49 background_file =
50 base::FilePath(base::StringPrintf(kControlPath, kBackground));
51 base::FileSystemType foreground_type;
52 base::FileSystemType background_type;
53 enabled =
54 base::GetFileSystemType(foreground_file, &foreground_type) &&
55 base::GetFileSystemType(background_file, &background_type) &&
56 foreground_type == FILE_SYSTEM_CGROUP &&
57 background_type == FILE_SYSTEM_CGROUP;
58 }
59 };
60
61 base::LazyInstance<CGroups> cgroups = LAZY_INSTANCE_INITIALIZER;
62 #else
63 const int kBackgroundPriority = 5;
64 #endif
65 }
66
IsProcessBackgrounded() const67 bool 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
SetProcessBackgrounded(bool background)89 bool 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 base::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
111 struct CheckForNicePermission {
CheckForNicePermissionbase::CheckForNicePermission112 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
CanBackgroundProcesses()126 bool 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