Trying again to land OOM priority manager changes.

base/process_util_linux.cc

 // Copyright (c) 2011 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_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace {
 
+// Max score for the old oom_adj range.  Used for conversion of new
+// values to old values.
+const int kMaxOldOomScore = 15;
+
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
 // Reads /proc/<pid>/stat and populates |proc_stats| with the values split by
 // spaces. Returns true if successful.
 bool GetProcStats(pid_t pid, std::vector<std::string>* proc_stats) {
   // Synchronously reading files in /proc is safe.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ skipping 687 matching lines @@
   // Android doesn't support setting a new handler.
   DLOG(WARNING) << "Not feasible.";
 #else
   // Set the new-out of memory handler.
   std::set_new_handler(&OnNoMemory);
   // If we're using glibc's allocator, the above functions will override
   // malloc and friends and make them die on out of memory.
 #endif
 }
 
+// NOTE: This is not the only version of this function in the source:
+// the setuid sandbox (in process_util_linux.c, in the sandbox source)
+// also has it's own C version.
 bool AdjustOOMScore(ProcessId process, int score) {
-  if (score < 0 || score > 15)
+  if (score < 0 || score > kMaxOomScore)
     return false;
 
-  FilePath oom_adj("/proc");
-  oom_adj = oom_adj.Append(base::Int64ToString(process));
-  oom_adj = oom_adj.AppendASCII("oom_adj");
+  FilePath oom_path("/proc");
+  oom_path = oom_path.Append(base::Int64ToString(process));
 
-  if (!file_util::PathExists(oom_adj))
-    return false;
+  // Attempt to write the newer oom_score_adj file first.
+  FilePath oom_file = oom_path.AppendASCII("oom_score_adj");
+  if (file_util::PathExists(oom_file)) {
+    std::string score_str = base::IntToString(score);
+    VLOG(1) << "Adjusting oom_score_adj of " << process << " to " << score_str;
+    int score_len = static_cast<int>(score_str.length());
+    return (score_len == file_util::WriteFile(oom_file,
+                                              score_str.c_str(),
+                                              score_len));
+  }
 
-  std::string score_str = base::IntToString(score);
-  return (static_cast<int>(score_str.length()) ==
-          file_util::WriteFile(oom_adj, score_str.c_str(), score_str.length()));
+  // If the oom_score_adj file doesn't exist, then we write the old
+  // style file and translate the oom_adj score to the range 0-15.
+  oom_file = oom_path.AppendASCII("oom_adj");
+  if (file_util::PathExists(oom_file)) {
+    std::string score_str = base::IntToString(
+        score * kMaxOldOomScore / kMaxOomScore);
+    VLOG(1) << "Adjusting oom_adj of " << process << " to " << score_str;
+    int score_len = static_cast<int>(score_str.length());
+    return (score_len == file_util::WriteFile(oom_file,
+                                              score_str.c_str(),
+                                              score_len));
+  }
+
+  return false;
 }
 
 }  // namespace base