Add support for the cgroups config we have in chromeos

base/process_linux.cc

 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process.h"
 
 #include <errno.h>
 #include <sys/resource.h>
 
+#include "base/file_util.h"
 #include "base/logging.h"
+#include "base/stringprintf.h"
 

[agl, 2011/03/24 00:02:08]

#if defined(OS_CHROMEOS)

[DaveMoore, 2011/03/24 16:45:17]

Done.

+namespace {

[agl, 2011/03/24 00:02:08]

An anonymous namespace isn't needed if the variables are static anyway. My
personal preference is for 'static' on the variables.

[DaveMoore, 2011/03/24 16:45:17]

Done.

+static bool use_cgroups = false;
+static bool inited = false;

[agl, 2011/03/24 00:02:08]

s/inited/cgroups_inited/

[DaveMoore, 2011/03/24 16:45:17]

Done.

+static const char kForegroundTasks[] =
+    "/tmp/cgroup/cpu/chrome_renderers/foreground/tasks";
+static const char kBackgroundTasks[] =
+    "/tmp/cgroup/cpu/chrome_renderers/background/tasks";
+static FilePath foreground_tasks;
+static FilePath background_tasks;
+}
 namespace base {
 
 #if defined(OS_CHROMEOS)
 // We are more aggressive in our lowering of background process priority
 // for chromeos as we have much more control over other processes running
 // on the machine.
 const int kPriorityAdjustment = 19;
 #else
 const int kPriorityAdjustment = 5;
 #endif
 
 bool Process::IsProcessBackgrounded() const {
   DCHECK(process_);
   return saved_priority_ == kUnsetProcessPriority;
 }
 
 bool Process::SetProcessBackgrounded(bool background) {
   DCHECK(process_);
 
+  // Check for cgroups files. ChromeOS supports these by default. It creates
+  // a cgroup mount in /tmp/cgroup and then configures two cpu task groups,
+  // one for at most single foreground renderer and the other for all

[agl, 2011/03/24 00:02:08]

"one for at most single" <- doesn't read right.

[DaveMoore, 2011/03/24 16:45:17]

Done.

+  // background renderers. This allows us to limit the impact of background
+  // renderers on foreground ones to a greater level than simple renicing.
+  if (!inited) {
+    inited = true;
+    foreground_tasks = FilePath(kForegroundTasks);

[agl, 2011/03/24 00:02:08]

This probably is obviously not thread-safe. I guess that GetFileSystemType isn't
instrumented for file access so you can get away with calling it on the I/O
threads without DCHECKing?

I would consider making it #if defined(OS_CHROMEOS) because nobody else is going
to mount cgroups in /tmp.

[DaveMoore, 2011/03/24 16:45:17]

Done.

+    background_tasks = FilePath(kBackgroundTasks);
+    file_util::FileSystemType foreground_type;
+    file_util::FileSystemType background_type;
+    use_cgroups =
+        file_util::GetFileSystemType(foreground_tasks, &foreground_type) &&
+        file_util::GetFileSystemType(background_tasks, &background_type) &&
+        foreground_type == file_util::FILE_SYSTEM_CGROUP &&
+        background_type == file_util::FILE_SYSTEM_CGROUP;
+  }
+
+  if (use_cgroups) {
+    if (background) {
+      std::string pid = StringPrintf("%d", process_);
+      if (file_util::WriteFile(background_tasks, pid.c_str(), pid.size()) > 0) {

[agl, 2011/03/24 00:02:08]

This doesn't DCHECK on the file checks?

[DaveMoore, 2011/03/24 16:45:17]

I moved the in child_process_launcher to the PROCESS_LAUNCHER thread. I did this
for all platforms. I can limit it to cros if you want, but it seemed beneficial
for all (adds some latency to the priority changing but does make the call on
the UI thread).

On 2011/03/24 00:02:08, agl wrote:

+        // With cgroups there's no real notion of priority as an int, but this
+        // will ensure we only move renderers back to the foreground group
+        // if we've ever put them in the background one.
+        saved_priority_ = 0;
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      if (saved_priority_ == kUnsetProcessPriority) {
+        // Can't restore if we were never backgrounded.
+        return false;
+      }
+      std::string pid = StringPrintf("%d", process_);
+      if (file_util::WriteFile(foreground_tasks, pid.c_str(), pid.size()) > 0) {
+        saved_priority_ = kUnsetProcessPriority;
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+
   if (background) {
     // We won't be able to raise the priority if we don't have the right rlimit.
     // The limit may be adjusted in /etc/security/limits.conf for PAM systems.
     struct rlimit rlim;
     if (getrlimit(RLIMIT_NICE, &rlim) != 0) {
       // Call to getrlimit failed, don't background.
       return false;
     }
     errno = 0;
     int current_priority = GetPriority();
@@ skipping 24 matching lines @@
     }
     int result = setpriority(PRIO_PROCESS, process_, saved_priority_);
     // If we can't restore something has gone terribly wrong.
     DPCHECK(result == 0);
     saved_priority_ = kUnsetProcessPriority;
     return true;
   }
 }
 
 }  // namespace base