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