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/files/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 base {
18
19namespace {
20const 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.
30const int kBackgroundPriority = 19;
31const char kControlPath[] = "/sys/fs/cgroup/cpu%s/cgroup.procs";
32const char kForeground[] = "/chrome_renderers/foreground";
33const char kBackground[] = "/chrome_renderers/background";
34const char kProcPath[] = "/proc/%d/cgroup";
35
36struct 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
46  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
61base::LazyInstance<CGroups> cgroups = LAZY_INSTANCE_INITIALIZER;
62#else
63const int kBackgroundPriority = 5;
64#endif
65}
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 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
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