base/process/process_linux.cc

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