Trying again to land OOM priority manager changes.

base/process_util.h

 // 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.
 
 // This file/namespace contains utility functions for enumerating, ending and
 // computing statistics of processes.
 
 #ifndef BASE_PROCESS_UTIL_H_
 #define BASE_PROCESS_UTIL_H_
 #pragma once
@@ skipping 155 matching lines @@
 
 #if defined(OS_LINUX)
 // Returns the path to the executable of the given process.
 BASE_EXPORT FilePath GetProcessExecutablePath(ProcessHandle process);
 
 // Parse the data found in /proc/<pid>/stat and return the sum of the
 // CPU-related ticks.  Returns -1 on parse error.
 // Exposed for testing.
 BASE_EXPORT int ParseProcStatCPU(const std::string& input);
 
-static const char kAdjustOOMScoreSwitch[] = "--adjust-oom-score";

[Greg Spencer (Chromium), 2011/08/22 23:28:48]

First landing failed because of an obscure problem with building
linux_shared.  This new change is identical to the original, with the
exception that I reverted this minor change that moved a static const
char[] out of process_util.h in base/ (where it should not be, IMO)
and into the .cc file.  Unfortunately, that causes the linux_shared
build to fail for a reason that is still not clear to me, as libbase
is linked into all the executables which failed to link because they
thought this symbol was missing.  They only failed to link in the
linux_shared build, so it certainly has something to do with our
shared library build.

Instead of leaving the static string in process_util.h, I moved it to
be closer to the one call site that used it, since I don't think that
a switch that is used only by the suid sandbox and its callers on
Linux belongs in base/, especially when there is only one use of the
string, and especially not as a static that gets defined in every
compilation unit that includes it. The suid sandbox doesn't include
anything from base, so we can't re-use the string there.

+// The maximum allowed value for the OOM score.
+const int kMaxOomScore = 1000;
 
-// This adjusts /proc/process/oom_adj so the Linux OOM killer will prefer
-// certain process types over others. The range for the adjustment is
-// [-17,15], with [0,15] being user accessible.
+// This adjusts /proc/<pid>/oom_score_adj so the Linux OOM killer will
+// prefer to kill certain process types over others. The range for the
+// adjustment is [-1000, 1000], with [0, 1000] being user accessible.
+// If the Linux system doesn't support the newer oom_score_adj range
+// of [0, 1000], then we revert to using the older oom_adj, and
+// translate the given value into [0, 15].  Some aliasing of values
+// may occur in that case, of course.
 BASE_EXPORT bool AdjustOOMScore(ProcessId process, int score);
-#endif
+#endif  // defined(OS_LINUX)
 
 #if defined(OS_POSIX)
 // Returns the ID for the parent of the given process.
 BASE_EXPORT ProcessId GetParentProcessId(ProcessHandle process);
 
 // Close all file descriptors, except those which are a destination in the
 // given multimap. Only call this function in a child process where you know
 // that there aren't any other threads.
 BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
-#endif
+#endif  // defined(OS_POSIX)
 
 // TODO(evan): rename these to use StudlyCaps.
 typedef std::vector<std::pair<std::string, std::string> > environment_vector;
 typedef std::vector<std::pair<int, int> > file_handle_mapping_vector;
 
 // Options for launching a subprocess that are passed to LaunchProcess().
 // The default constructor constructs the object with default options.
 struct LaunchOptions {
   LaunchOptions() : wait(false),
 #if defined(OS_WIN)
                     start_hidden(false), inherit_handles(false), as_user(NULL),
                     empty_desktop_name(false)
 #else
                     environ(NULL), fds_to_remap(NULL), new_process_group(false),
                     clone_flags(0)
-#endif
+#endif  // !defined(OS_WIN)
       {}
 
   // If true, wait for the process to complete.
   bool wait;
 
 #if defined(OS_WIN)
   bool start_hidden;
 
   // If true, the new process inherits handles from the parent.
   bool inherit_handles;
@@ skipping 22 matching lines @@
   // call to LaunchProcess().
   const file_handle_mapping_vector* fds_to_remap;
 
   // If true, start the process in a new process group, instead of
   // inheriting the parent's process group.  The pgid of the child process
   // will be the same as its pid.
   bool new_process_group;
 
   // If non-zero, start the process using clone(), using flags as provided.
   int clone_flags;
-#endif
+#endif   // !defined(OS_WIN)
 };
 
 // Launch a process via the command line |cmdline|.
 // See the documentation of LaunchOptions for details on |options|.
 //
 // If |process_handle| is non-NULL, it will be filled in with the
 // handle of the launched process.  NOTE: In this case, the caller is
 // responsible for closing the handle so that it doesn't leak!
 // Otherwise, the process handle will be implicitly closed.
 //
@@ skipping 66 matching lines @@
 // for the command.
 BASE_EXPORT bool GetAppOutputRestricted(const CommandLine& cl,
                                         std::string* output, size_t max_output);
 
 // A version of |GetAppOutput()| which also returns the exit code of the
 // executed command. Returns true if the application runs and exits cleanly. If
 // this is the case the exit code of the application is available in
 // |*exit_code|.
 BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl,
                                           std::string* output, int* exit_code);
-#endif
+#endif  // defined(OS_POSIX)
 
 // Used to filter processes by process ID.
 class ProcessFilter {
  public:
   // Returns true to indicate set-inclusion and false otherwise.  This method
   // should not have side-effects and should be idempotent.
   virtual bool Includes(const ProcessEntry& entry) const = 0;
 
  protected:
   virtual ~ProcessFilter() {}
@@ skipping 16 matching lines @@
 // Attempts to kill the process identified by the given process
 // entry structure, giving it the specified exit code. If |wait| is true, wait
 // for the process to be actually terminated before returning.
 // Returns true if this is successful, false otherwise.
 BASE_EXPORT bool KillProcess(ProcessHandle process, int exit_code, bool wait);
 
 #if defined(OS_POSIX)
 // Attempts to kill the process group identified by |process_group_id|. Returns
 // true on success.
 BASE_EXPORT bool KillProcessGroup(ProcessHandle process_group_id);
-#endif
+#endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
 BASE_EXPORT bool KillProcessById(ProcessId process_id, int exit_code,
                                  bool wait);
-#endif
+#endif  // defined(OS_WIN)
 
 // Get the termination status of the process by interpreting the
 // circumstances of the child process' death. |exit_code| is set to
 // the status returned by waitpid() on POSIX, and from
 // GetExitCodeProcess() on Windows.  |exit_code| may be NULL if the
 // caller is not interested in it.  Note that on Linux, this function
 // will only return a useful result the first time it is called after
 // the child exits (because it will reap the child and the information
 // will no longer be available).
 BASE_EXPORT TerminationStatus GetTerminationStatus(ProcessHandle handle,
@@ skipping 234 matching lines @@
   // If IO information is retrieved successfully, the function returns true
   // and fills in the IO_COUNTERS passed in. The function returns false
   // otherwise.
   bool GetIOCounters(IoCounters* io_counters) const;
 
  private:
 #if !defined(OS_MACOSX)
   explicit ProcessMetrics(ProcessHandle process);
 #else
   ProcessMetrics(ProcessHandle process, PortProvider* port_provider);
-#endif  // !defined(OS_MACOSX)
+#endif  // defined(OS_MACOSX)
 
   ProcessHandle process_;
 
   int processor_count_;
 
   // Used to store the previous times and CPU usage counts so we can
   // compute the CPU usage between calls.
   int64 last_time_;
   int64 last_system_time_;
 
 #if defined(OS_MACOSX)
   // Queries the port provider if it's set.
   mach_port_t TaskForPid(ProcessHandle process) const;
 
   PortProvider* port_provider_;
 #elif defined(OS_POSIX)
   // Jiffie count at the last_time_ we updated.
   int last_cpu_;
-#endif  // defined(OS_MACOSX)
+#endif  // defined(OS_POSIX)
 
   DISALLOW_COPY_AND_ASSIGN(ProcessMetrics);
 };
 
 #if defined(OS_LINUX)
 // Data from /proc/meminfo about system-wide memory consumption.
 // Values are in KB.
 struct SystemMemoryInfoKB {
   SystemMemoryInfoKB() : total(0), free(0), buffers(0), cached(0),
       active_anon(0), inactive_anon(0), shmem(0) {}
   int total;
   int free;
   int buffers;
   int cached;
   int active_anon;
   int inactive_anon;
   int shmem;
 };
 // Retrieves data from /proc/meminfo about system-wide memory consumption.
 // Fills in the provided |meminfo| structure. Returns true on success.
 // Exposed for memory debugging widget.
 BASE_EXPORT bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo);
-#endif
+#endif  // defined(OS_LINUX)
 
 // Returns the memory committed by the system in KBytes.
 // Returns 0 if it can't compute the commit charge.
 BASE_EXPORT size_t GetSystemCommitCharge();
 
 // Enables low fragmentation heap (LFH) for every heaps of this process. This
 // won't have any effect on heaps created after this function call. It will not
 // modify data allocated in the heaps before calling this function. So it is
 // better to call this function early in initialization and again before
 // entering the main loop.
 // Note: Returns true on Windows 2000 without doing anything.
 BASE_EXPORT bool EnableLowFragmentationHeap();
 
 // Enables 'terminate on heap corruption' flag. Helps protect against heap
 // overflow. Has no effect if the OS doesn't provide the necessary facility.
 BASE_EXPORT void EnableTerminationOnHeapCorruption();
 
 #if !defined(OS_WIN)
 // Turns on process termination if memory runs out. This is handled on Windows
 // inside RegisterInvalidParamHandler().
 BASE_EXPORT void EnableTerminationOnOutOfMemory();
 #if defined(OS_MACOSX)
 // Exposed for testing.
 BASE_EXPORT malloc_zone_t* GetPurgeableZone();
-#endif
-#endif
+#endif  // defined(OS_MACOSX)
+#endif  // !defined(OS_WIN)
 
 // Enables stack dump to console output on exception and signals.
 // When enabled, the process will quit immediately. This is meant to be used in
 // unit_tests only!
 BASE_EXPORT bool EnableInProcessStackDumping();
 
 // If supported on the platform, and the user has sufficent rights, increase
 // the current process's scheduling priority to a high priority.
 BASE_EXPORT void RaiseProcessToHighPriority();
 
 #if defined(OS_MACOSX)
 // Restore the default exception handler, setting it to Apple Crash Reporter
 // (ReportCrash).  When forking and execing a new process, the child will
 // inherit the parent's exception ports, which may be set to the Breakpad
 // instance running inside the parent.  The parent's Breakpad instance should
 // not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
 // in the child after forking will restore the standard exception handler.
 // See http://crbug.com/20371/ for more details.
 void RestoreDefaultExceptionHandler();
 #endif  // defined(OS_MACOSX)
 
 }  // namespace base
 
 #endif  // BASE_PROCESS_UTIL_H_