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