[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / 69e1c46004ad506b2a7cfbce218f4cd20ba76bfe / . / base / process_util.h
blob: 6745d4b27a9c7cbd9478dd670c4018a28547d8d8 [file] [log] [blame]
tbarzic@chromium.org927054d2012-01-21 01:48:25[diff] [blame]1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:55[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]4
5// This file/namespace contains utility functions for enumerating, ending and
6// computing statistics of processes.
7
deanm@google.comdb717282008-08-27 13:48:03[diff] [blame]8#ifndef BASE_PROCESS_UTIL_H_
9#define BASE_PROCESS_UTIL_H_
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]10
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]11#include "base/basictypes.h"
tedvessenes@gmail.com7e1117c2012-03-31 20:42:41[diff] [blame]12#include "base/time.h"
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]13
dkegel@google.comab0e2222008-10-31 20:19:43[diff] [blame]14#if defined(OS_WIN)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]15#include <windows.h>
16#include <tlhelp32.h>
robert.nagy@gmail.comaf824362011-12-04 14:19:41[diff] [blame]17#elif defined(OS_MACOSX) || defined(OS_BSD)
wtc@chromium.org4a34ce02009-08-31 22:25:00[diff] [blame]18// kinfo_proc is defined in <sys/sysctl.h>, but this forward declaration
19// is sufficient for the vector<kinfo_proc> below.
20struct kinfo_proc;
avi@chromium.org6cfa3392010-07-01 20:11:43[diff] [blame]21// malloc_zone_t is defined in <malloc/malloc.h>, but this forward declaration
22// is sufficient for GetPurgeableZone() below.
23typedef struct _malloc_zone_t malloc_zone_t;
robert.nagy@gmail.comaf824362011-12-04 14:19:41[diff] [blame]24#if !defined(OS_BSD)
thakis@chromium.orgc0028792010-01-12 00:39:15[diff] [blame]25#include <mach/mach.h>
mark@chromium.org817f0f142011-10-13 04:23:22[diff] [blame]26#endif
wtc@chromium.org4a34ce02009-08-31 22:25:00[diff] [blame]27#elif defined(OS_POSIX)
dkegel@google.comab0e2222008-10-31 20:19:43[diff] [blame]28#include <dirent.h>
29#include <limits.h>
30#include <sys/types.h>
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]31#endif
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]32
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]33#include <list>
mcgrathr@chromium.org77540fdf2011-11-15 18:49:10[diff] [blame]34#include <set>
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]35#include <string>
thestig@chromium.org9ec8db02009-07-21 07:00:13[diff] [blame]36#include <utility>
mark@chromium.org962dd312009-02-05 21:44:13[diff] [blame]37#include <vector>
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]38
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]39#include "base/base_export.h"
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]40#include "base/file_descriptor_shuffle.h"
avi@chromium.org4f260d02010-12-23 18:35:42[diff] [blame]41#include "base/file_path.h"
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]42#include "base/process.h"
43
erg@google.com5d91c9e2010-07-28 17:25:28[diff] [blame]44class CommandLine;
erg@google.com5d91c9e2010-07-28 17:25:28[diff] [blame]45
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]46namespace base {
47
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]48#if defined(OS_WIN)
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]49struct ProcessEntry : public PROCESSENTRY32 {
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]50 ProcessId pid() const { return th32ProcessID; }
51 ProcessId parent_pid() const { return th32ParentProcessID; }
52 const wchar_t* exe_file() const { return szExeFile; }
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]53};
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]54
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]55struct IoCounters : public IO_COUNTERS {
56};
57
sanjeevr@chromium.org7d11f6d52010-10-12 21:44:23[diff] [blame]58// Process access masks. These constants provide platform-independent
59// definitions for the standard Windows access masks.
60// See http://msdn.microsoft.com/en-us/library/ms684880(VS.85).aspx for
61// the specific semantics of each mask value.
62const uint32 kProcessAccessTerminate = PROCESS_TERMINATE;
63const uint32 kProcessAccessCreateThread = PROCESS_CREATE_THREAD;
64const uint32 kProcessAccessSetSessionId = PROCESS_SET_SESSIONID;
65const uint32 kProcessAccessVMOperation = PROCESS_VM_OPERATION;
66const uint32 kProcessAccessVMRead = PROCESS_VM_READ;
67const uint32 kProcessAccessVMWrite = PROCESS_VM_WRITE;
68const uint32 kProcessAccessDuplicateHandle = PROCESS_DUP_HANDLE;
69const uint32 kProcessAccessCreateProcess = PROCESS_CREATE_PROCESS;
70const uint32 kProcessAccessSetQuota = PROCESS_SET_QUOTA;
71const uint32 kProcessAccessSetInformation = PROCESS_SET_INFORMATION;
72const uint32 kProcessAccessQueryInformation = PROCESS_QUERY_INFORMATION;
73const uint32 kProcessAccessSuspendResume = PROCESS_SUSPEND_RESUME;
74const uint32 kProcessAccessQueryLimitedInfomation =
75 PROCESS_QUERY_LIMITED_INFORMATION;
76const uint32 kProcessAccessWaitForTermination = SYNCHRONIZE;
paulg@google.com61659062008-08-06 01:04:18[diff] [blame]77#elif defined(OS_POSIX)
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]78
dkegel@google.comab0e2222008-10-31 20:19:43[diff] [blame]79struct ProcessEntry {
erg@google.combbf94a32010-10-13 17:44:15[diff] [blame]80 ProcessEntry();
81 ~ProcessEntry();
82
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]83 ProcessId pid() const { return pid_; }
84 ProcessId parent_pid() const { return ppid_; }
rsimha@chromium.orgc47d81d2010-10-05 23:41:04[diff] [blame]85 ProcessId gid() const { return gid_; }
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]86 const char* exe_file() const { return exe_file_.c_str(); }
rsimha@chromium.orgc47d81d2010-10-05 23:41:04[diff] [blame]87 const std::vector<std::string>& cmd_line_args() const {
88 return cmd_line_args_;
89 }
erg@google.coma502bbe72011-01-07 18:06:45[diff] [blame]90
91 ProcessId pid_;
92 ProcessId ppid_;
93 ProcessId gid_;
94 std::string exe_file_;
95 std::vector<std::string> cmd_line_args_;
dkegel@google.comab0e2222008-10-31 20:19:43[diff] [blame]96};
97
evanm@google.com0b100bc82008-10-14 20:49:16[diff] [blame]98struct IoCounters {
evan@chromium.org34b2b002009-11-20 06:53:28[diff] [blame]99 uint64_t ReadOperationCount;
100 uint64_t WriteOperationCount;
101 uint64_t OtherOperationCount;
102 uint64_t ReadTransferCount;
103 uint64_t WriteTransferCount;
104 uint64_t OtherTransferCount;
evanm@google.com0b100bc82008-10-14 20:49:16[diff] [blame]105};
agl@chromium.org3f04f2b2009-04-30 19:40:03[diff] [blame]106
sanjeevr@chromium.org7d11f6d52010-10-12 21:44:23[diff] [blame]107// Process access masks. They are not used on Posix because access checking
108// does not happen during handle creation.
109const uint32 kProcessAccessTerminate = 0;
110const uint32 kProcessAccessCreateThread = 0;
111const uint32 kProcessAccessSetSessionId = 0;
112const uint32 kProcessAccessVMOperation = 0;
113const uint32 kProcessAccessVMRead = 0;
114const uint32 kProcessAccessVMWrite = 0;
115const uint32 kProcessAccessDuplicateHandle = 0;
116const uint32 kProcessAccessCreateProcess = 0;
117const uint32 kProcessAccessSetQuota = 0;
118const uint32 kProcessAccessSetInformation = 0;
119const uint32 kProcessAccessQueryInformation = 0;
120const uint32 kProcessAccessSuspendResume = 0;
121const uint32 kProcessAccessQueryLimitedInfomation = 0;
122const uint32 kProcessAccessWaitForTermination = 0;
maruel@chromium.orga5a00b1d2010-04-08 15:52:45[diff] [blame]123#endif // defined(OS_POSIX)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]124
gspencer@chromium.org443b80e2010-12-14 00:42:23[diff] [blame]125// Return status values from GetTerminationStatus. Don't use these as
126// exit code arguments to KillProcess*(), use platform/application
127// specific values instead.
128enum TerminationStatus {
129 TERMINATION_STATUS_NORMAL_TERMINATION, // zero exit status
130 TERMINATION_STATUS_ABNORMAL_TERMINATION, // non-zero exit status
131 TERMINATION_STATUS_PROCESS_WAS_KILLED, // e.g. SIGKILL or task manager kill
132 TERMINATION_STATUS_PROCESS_CRASHED, // e.g. Segmentation fault
scheib@chromium.orgbcb2c772011-04-01 20:20:53[diff] [blame]133 TERMINATION_STATUS_STILL_RUNNING, // child hasn't exited yet
134 TERMINATION_STATUS_MAX_ENUM
cpu@google.comeef576f2008-11-03 23:28:06[diff] [blame]135};
136
thestig@chromium.org6a033592012-03-23 00:08:54[diff] [blame]137#if defined(USE_LINUX_BREAKPAD)
yusukes@google.com7dc738a2012-03-23 05:56:35[diff] [blame]138BASE_EXPORT extern size_t g_oom_size;
thestig@chromium.org6a033592012-03-23 00:08:54[diff] [blame]139#endif
140
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]141// Returns the id of the current process.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]142BASE_EXPORT ProcessId GetCurrentProcId();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]143
erikkay@google.com113ab132008-09-18 20:42:55[diff] [blame]144// Returns the ProcessHandle of the current process.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]145BASE_EXPORT ProcessHandle GetCurrentProcessHandle();
maruel@chromium.org52a261f2009-03-03 15:01:12[diff] [blame]146
joi@chromium.org9a182832012-02-10 18:45:58[diff] [blame]147#if defined(OS_WIN)
alexeypa@chromium.orgf56d1582012-05-16 22:46:17[diff] [blame]148// Returns the module handle to which an address belongs. The reference count
149// of the module is not incremented.
joi@chromium.org9a182832012-02-10 18:45:58[diff] [blame]150BASE_EXPORT HMODULE GetModuleFromAddress(void* address);
151#endif
152
brettw@google.com5986ed22009-02-06 00:19:17[diff] [blame]153// Converts a PID to a process handle. This handle must be closed by
phajdan.jr@chromium.org6c6cc802009-04-03 17:01:36[diff] [blame]154// CloseProcessHandle when you are done with it. Returns true on success.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]155BASE_EXPORT bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle);
maruel@chromium.org52a261f2009-03-03 15:01:12[diff] [blame]156
phajdan.jr@chromium.org5d438dbad2009-04-30 08:59:39[diff] [blame]157// Converts a PID to a process handle. On Windows the handle is opened
158// with more access rights and must only be used by trusted code.
159// You have to close returned handle using CloseProcessHandle. Returns true
160// on success.
sanjeevr@chromium.org7d11f6d52010-10-12 21:44:23[diff] [blame]161// TODO(sanjeevr): Replace all calls to OpenPrivilegedProcessHandle with the
162// more specific OpenProcessHandleWithAccess method and delete this.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]163BASE_EXPORT bool OpenPrivilegedProcessHandle(ProcessId pid,
164 ProcessHandle* handle);
phajdan.jr@chromium.org5d438dbad2009-04-30 08:59:39[diff] [blame]165
sanjeevr@chromium.org7d11f6d52010-10-12 21:44:23[diff] [blame]166// Converts a PID to a process handle using the desired access flags. Use a
167// combination of the kProcessAccess* flags defined above for |access_flags|.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]168BASE_EXPORT bool OpenProcessHandleWithAccess(ProcessId pid,
169 uint32 access_flags,
170 ProcessHandle* handle);
sanjeevr@chromium.org7d11f6d52010-10-12 21:44:23[diff] [blame]171
brettw@google.com5986ed22009-02-06 00:19:17[diff] [blame]172// Closes the process handle opened by OpenProcessHandle.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]173BASE_EXPORT void CloseProcessHandle(ProcessHandle process);
erikkay@google.com113ab132008-09-18 20:42:55[diff] [blame]174
cpu@google.comeef576f2008-11-03 23:28:06[diff] [blame]175// Returns the unique ID for the specified process. This is functionally the
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]176// same as Windows' GetProcessId(), but works on versions of Windows before
177// Win XP SP1 as well.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]178BASE_EXPORT ProcessId GetProcId(ProcessHandle process);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]179
robert.nagy@gmail.comaf824362011-12-04 14:19:41[diff] [blame]180#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_BSD)
dkegel@google.com78c6dd62009-06-08 23:29:11[diff] [blame]181// Returns the path to the executable of the given process.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]182BASE_EXPORT FilePath GetProcessExecutablePath(ProcessHandle process);
robert.nagy@gmail.comea725b32011-10-25 17:43:05[diff] [blame]183#endif
evan@chromium.orgd2ed23832009-09-19 01:57:39[diff] [blame]184
robert.nagy@gmail.comea725b32011-10-25 17:43:05[diff] [blame]185#if defined(OS_LINUX) || defined(OS_ANDROID)
evan@chromium.orgd2ed23832009-09-19 01:57:39[diff] [blame]186// Parse the data found in /proc/<pid>/stat and return the sum of the
187// CPU-related ticks. Returns -1 on parse error.
188// Exposed for testing.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]189BASE_EXPORT int ParseProcStatCPU(const std::string& input);
thestig@chromium.orge5856a7a2009-12-10 02:08:10[diff] [blame]190
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]191// The maximum allowed value for the OOM score.
192const int kMaxOomScore = 1000;
thestig@chromium.orge5856a7a2009-12-10 02:08:10[diff] [blame]193
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]194// This adjusts /proc/<pid>/oom_score_adj so the Linux OOM killer will
195// prefer to kill certain process types over others. The range for the
196// adjustment is [-1000, 1000], with [0, 1000] being user accessible.
197// If the Linux system doesn't support the newer oom_score_adj range
198// of [0, 1000], then we revert to using the older oom_adj, and
199// translate the given value into [0, 15]. Some aliasing of values
200// may occur in that case, of course.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]201BASE_EXPORT bool AdjustOOMScore(ProcessId process, int score);
jingzhao@chromium.org4d0f93c2011-09-29 04:43:54[diff] [blame]202#endif // defined(OS_LINUX) || defined(OS_ANDROID)
dkegel@google.com78c6dd62009-06-08 23:29:11[diff] [blame]203
jeremy@chromium.orgfa3097a6a52008-12-17 22:41:50[diff] [blame]204#if defined(OS_POSIX)
dmaclach@chromium.org56f0f262011-02-24 17:14:36[diff] [blame]205// Returns the ID for the parent of the given process.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]206BASE_EXPORT ProcessId GetParentProcessId(ProcessHandle process);
dmaclach@chromium.org56f0f262011-02-24 17:14:36[diff] [blame]207
gspencer@chromium.org443b80e2010-12-14 00:42:23[diff] [blame]208// Close all file descriptors, except those which are a destination in the
agl@chromium.org3f04f2b2009-04-30 19:40:03[diff] [blame]209// given multimap. Only call this function in a child process where you know
210// that there aren't any other threads.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]211BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]212#endif // defined(OS_POSIX)
jeremy@chromium.orgfa3097a6a52008-12-17 22:41:50[diff] [blame]213
thestig@chromium.orga82af392012-02-24 04:40:20[diff] [blame]214typedef std::vector<std::pair<std::string, std::string> > EnvironmentVector;
215typedef std::vector<std::pair<int, int> > FileHandleMappingVector;
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]216
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]217#if defined(OS_MACOSX)
218// Used with LaunchOptions::synchronize and LaunchSynchronize, a
219// LaunchSynchronizationHandle is an opaque value that LaunchProcess will
220// create and set, and that LaunchSynchronize will consume and destroy.
221typedef int* LaunchSynchronizationHandle;
222#endif // defined(OS_MACOSX)
223
evan@chromium.org075fb932011-07-19 16:31:28[diff] [blame]224// Options for launching a subprocess that are passed to LaunchProcess().
evan@chromium.orge5992182011-07-15 16:47:02[diff] [blame]225// The default constructor constructs the object with default options.
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]226struct LaunchOptions {
evan@chromium.orge5992182011-07-15 16:47:02[diff] [blame]227 LaunchOptions() : wait(false),
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]228#if defined(OS_WIN)
229 start_hidden(false), inherit_handles(false), as_user(NULL),
phajdan.jr@chromium.org86f723ec22011-09-07 21:54:42[diff] [blame]230 empty_desktop_name(false), job_handle(NULL)
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]231#else
mcgrathr@chromium.org77540fdf2011-11-15 18:49:10[diff] [blame]232 environ(NULL), fds_to_remap(NULL), maximize_rlimits(NULL),
233 new_process_group(false)
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]234#if defined(OS_LINUX)
235 , clone_flags(0)
236#endif // OS_LINUX
tbarzic@chromium.org927054d2012-01-21 01:48:25[diff] [blame]237#if defined(OS_CHROMEOS)
238 , ctrl_terminal_fd(-1)
239#endif // OS_CHROMEOS
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]240#if defined(OS_MACOSX)
241 , synchronize(NULL)
242#endif // defined(OS_MACOSX)
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]243#endif // !defined(OS_WIN)
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]244 {}
245
246 // If true, wait for the process to complete.
247 bool wait;
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]248
249#if defined(OS_WIN)
250 bool start_hidden;
251
252 // If true, the new process inherits handles from the parent.
253 bool inherit_handles;
254
255 // If non-NULL, runs as if the user represented by the token had launched it.
256 // Whether the application is visible on the interactive desktop depends on
257 // the token belonging to an interactive logon session.
258 //
259 // To avoid hard to diagnose problems, when specified this loads the
260 // environment variables associated with the user and if this operation fails
261 // the entire call fails as well.
262 UserTokenHandle as_user;
263
264 // If true, use an empty string for the desktop name.
265 bool empty_desktop_name;
phajdan.jr@chromium.org86f723ec22011-09-07 21:54:42[diff] [blame]266
erikwright@chromium.org0148e6e2012-03-15 12:40:04[diff] [blame]267 // If non-NULL, launches the application in that job object. The process will
268 // be terminated immediately and LaunchProcess() will fail if assignment to
269 // the job object fails.
phajdan.jr@chromium.org86f723ec22011-09-07 21:54:42[diff] [blame]270 HANDLE job_handle;
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]271#else
272 // If non-NULL, set/unset environment variables.
273 // See documentation of AlterEnvironment().
274 // This pointer is owned by the caller and must live through the
275 // call to LaunchProcess().
thestig@chromium.orga82af392012-02-24 04:40:20[diff] [blame]276 const EnvironmentVector* environ;
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]277
278 // If non-NULL, remap file descriptors according to the mapping of
279 // src fd->dest fd to propagate FDs into the child process.
280 // This pointer is owned by the caller and must live through the
281 // call to LaunchProcess().
thestig@chromium.orga82af392012-02-24 04:40:20[diff] [blame]282 const FileHandleMappingVector* fds_to_remap;
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]283
mcgrathr@chromium.org77540fdf2011-11-15 18:49:10[diff] [blame]284 // Each element is an RLIMIT_* constant that should be raised to its
285 // rlim_max. This pointer is owned by the caller and must live through
286 // the call to LaunchProcess().
287 const std::set<int>* maximize_rlimits;
288
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]289 // If true, start the process in a new process group, instead of
290 // inheriting the parent's process group. The pgid of the child process
291 // will be the same as its pid.
292 bool new_process_group;
bradchen@google.comca7c4562011-07-15 23:55:21[diff] [blame]293
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]294#if defined(OS_LINUX)
bradchen@google.comca7c4562011-07-15 23:55:21[diff] [blame]295 // If non-zero, start the process using clone(), using flags as provided.
296 int clone_flags;
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]297#endif // defined(OS_LINUX)
298
tbarzic@chromium.org927054d2012-01-21 01:48:25[diff] [blame]299#if defined(OS_CHROMEOS)
300 // If non-negative, the specified file descriptor will be set as the launched
301 // process' controlling terminal.
302 int ctrl_terminal_fd;
303#endif // defined(OS_CHROMEOS)
304
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]305#if defined(OS_MACOSX)
306 // When non-NULL, a new LaunchSynchronizationHandle will be created and
307 // stored in *synchronize whenever LaunchProcess returns true in the parent
308 // process. The child process will have been created (with fork) but will
309 // be waiting (before exec) for the parent to call LaunchSynchronize with
310 // this handle. Only when LaunchSynchronize is called will the child be
311 // permitted to continue execution and call exec. LaunchSynchronize
312 // destroys the handle created by LaunchProcess.
313 //
314 // When synchronize is non-NULL, the parent must call LaunchSynchronize
315 // whenever LaunchProcess returns true. No exceptions.
316 //
317 // Synchronization is useful when the parent process needs to guarantee that
318 // it can take some action (such as recording the newly-forked child's
319 // process ID) before the child does something (such as using its process ID
320 // to communicate with its parent).
321 //
322 // |synchronize| and |wait| must not both be set simultaneously.
323 LaunchSynchronizationHandle* synchronize;
324#endif // defined(OS_MACOSX)
325
326#endif // !defined(OS_WIN)
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]327};
328
329// Launch a process via the command line |cmdline|.
evan@chromium.orge5992182011-07-15 16:47:02[diff] [blame]330// See the documentation of LaunchOptions for details on |options|.
331//
erikwright@chromium.org0148e6e2012-03-15 12:40:04[diff] [blame]332// Returns true upon success.
333//
334// Upon success, if |process_handle| is non-NULL, it will be filled in with the
evan@chromium.orge5992182011-07-15 16:47:02[diff] [blame]335// handle of the launched process. NOTE: In this case, the caller is
336// responsible for closing the handle so that it doesn't leak!
337// Otherwise, the process handle will be implicitly closed.
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]338//
339// Unix-specific notes:
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]340// - All file descriptors open in the parent process will be closed in the
341// child process except for any preserved by options::fds_to_remap, and
342// stdin, stdout, and stderr. If not remapped by options::fds_to_remap,
343// stdin is reopened as /dev/null, and the child is allowed to inherit its
344// parent's stdout and stderr.
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]345// - If the first argument on the command line does not contain a slash,
346// PATH will be searched. (See man execvp.)
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]347BASE_EXPORT bool LaunchProcess(const CommandLine& cmdline,
348 const LaunchOptions& options,
349 ProcessHandle* process_handle);
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]350
estade@chromium.orgfb7f9be2008-10-22 01:15:47[diff] [blame]351#if defined(OS_WIN)
tommi@chromium.org48dc9e12010-08-26 19:49:57[diff] [blame]352
353enum IntegrityLevel {
354 INTEGRITY_UNKNOWN,
355 LOW_INTEGRITY,
356 MEDIUM_INTEGRITY,
357 HIGH_INTEGRITY,
358};
359// Determine the integrity level of the specified process. Returns false
360// if the system does not support integrity levels (pre-Vista) or in the case
361// of an underlying system failure.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]362BASE_EXPORT bool GetProcessIntegrityLevel(ProcessHandle process,
thestig@chromium.orga82af392012-02-24 04:40:20[diff] [blame]363 IntegrityLevel* level);
tommi@chromium.org48dc9e12010-08-26 19:49:57[diff] [blame]364
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]365// Windows-specific LaunchProcess that takes the command line as a
366// string. Useful for situations where you need to control the
367// command line arguments directly, but prefer the CommandLine version
368// if launching Chrome itself.
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]369//
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]370// The first command line argument should be the path to the process,
371// and don't forget to quote it.
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]372//
373// Example (including literal quotes)
374// cmdline = "c:\windows\explorer.exe" -foo "c:\bar\"
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]375BASE_EXPORT bool LaunchProcess(const string16& cmdline,
376 const LaunchOptions& options,
377 ProcessHandle* process_handle);
cpu@chromium.orge50130b2010-02-01 03:28:47[diff] [blame]378
estade@chromium.orgfb7f9be2008-10-22 01:15:47[diff] [blame]379#elif defined(OS_POSIX)
evan@chromium.org898a81a2011-06-30 22:56:15[diff] [blame]380// A POSIX-specific version of LaunchProcess that takes an argv array
381// instead of a CommandLine. Useful for situations where you need to
382// control the command line arguments directly, but prefer the
383// CommandLine version if launching Chrome itself.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]384BASE_EXPORT bool LaunchProcess(const std::vector<std::string>& argv,
385 const LaunchOptions& options,
386 ProcessHandle* process_handle);
stuartmorgan@google.com2aea9e092009-08-06 20:03:01[diff] [blame]387
agl@chromium.orgef73044e2010-03-11 15:25:54[diff] [blame]388// AlterEnvironment returns a modified environment vector, constructed from the
389// given environment and the list of changes given in |changes|. Each key in
390// the environment is matched against the first element of the pairs. In the
391// event of a match, the value is replaced by the second of the pair, unless
392// the second is empty, in which case the key-value is removed.
393//
394// The returned array is allocated using new[] and must be freed by the caller.
thestig@chromium.orga82af392012-02-24 04:40:20[diff] [blame]395BASE_EXPORT char** AlterEnvironment(const EnvironmentVector& changes,
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]396 const char* const* const env);
mark@chromium.org84b2d1d2011-09-01 21:44:24[diff] [blame]397
398#if defined(OS_MACOSX)
399
400// After a successful call to LaunchProcess with LaunchOptions::synchronize
401// set, the parent process must call LaunchSynchronize to allow the child
402// process to proceed, and to destroy the LaunchSynchronizationHandle.
403BASE_EXPORT void LaunchSynchronize(LaunchSynchronizationHandle handle);
404
405#endif // defined(OS_MACOSX)
thestig@chromium.org9ec8db02009-07-21 07:00:13[diff] [blame]406#endif // defined(OS_POSIX)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]407
toyoshim@chromium.orgb330cab2011-11-23 23:37:19[diff] [blame]408#if defined(OS_WIN)
409// Set JOBOBJECT_EXTENDED_LIMIT_INFORMATION to JobObject |job_object|.
410// As its limit_info.BasicLimitInformation.LimitFlags has
411// JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE.
412// When the provide JobObject |job_object| is closed, the binded process will
413// be terminated.
414BASE_EXPORT bool SetJobObjectAsKillOnJobClose(HANDLE job_object);
415#endif // defined(OS_WIN)
416
jcampan@chromium.org1e312112009-04-21 21:44:12[diff] [blame]417// Executes the application specified by |cl| and wait for it to exit. Stores
phajdan.jr@chromium.org1912cfe2009-04-21 08:09:30[diff] [blame]418// the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
419// on success (application launched and exited cleanly, with exit code
maruel@chromium.org96878a212010-06-10 18:26:33[diff] [blame]420// indicating success).
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]421BASE_EXPORT bool GetAppOutput(const CommandLine& cl, std::string* output);
phajdan.jr@chromium.orgc0b210ee2009-04-17 09:57:52[diff] [blame]422
viettrungluu@chromium.orgf164cea2009-11-05 23:37:40[diff] [blame]423#if defined(OS_POSIX)
ivankr@chromium.org1a6ec692012-04-26 20:24:37[diff] [blame]424// A POSIX-specific version of GetAppOutput that takes an argv array
425// instead of a CommandLine. Useful for situations where you need to
426// control the command line arguments directly.
427BASE_EXPORT bool GetAppOutput(const std::vector<std::string>& argv,
428 std::string* output);
429
viettrungluu@chromium.orgf164cea2009-11-05 23:37:40[diff] [blame]430// A restricted version of |GetAppOutput()| which (a) clears the environment,
431// and (b) stores at most |max_output| bytes; also, it doesn't search the path
432// for the command.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]433BASE_EXPORT bool GetAppOutputRestricted(const CommandLine& cl,
434 std::string* output, size_t max_output);
benwells@chromium.orgd03b05c2011-07-06 06:14:48[diff] [blame]435
436// A version of |GetAppOutput()| which also returns the exit code of the
437// executed command. Returns true if the application runs and exits cleanly. If
438// this is the case the exit code of the application is available in
439// |*exit_code|.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]440BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl,
441 std::string* output, int* exit_code);
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]442#endif // defined(OS_POSIX)
viettrungluu@chromium.orgf164cea2009-11-05 23:37:40[diff] [blame]443
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]444// Used to filter processes by process ID.
445class ProcessFilter {
446 public:
447 // Returns true to indicate set-inclusion and false otherwise. This method
448 // should not have side-effects and should be idempotent.
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]449 virtual bool Includes(const ProcessEntry& entry) const = 0;
ziadh@chromium.org695092f2010-08-02 16:34:16[diff] [blame]450
451 protected:
452 virtual ~ProcessFilter() {}
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]453};
454
455// Returns the number of processes on the machine that are running from the
456// given executable name. If filter is non-null, then only processes selected
457// by the filter will be counted.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]458BASE_EXPORT int GetProcessCount(const FilePath::StringType& executable_name,
459 const ProcessFilter* filter);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]460
461// Attempts to kill all the processes on the current machine that were launched
462// from the given executable name, ending them with the given exit code. If
463// filter is non-null, then only processes selected by the filter are killed.
rsimha@chromium.org61b93f88f2010-09-22 17:28:30[diff] [blame]464// Returns true if all processes were able to be killed off, false if at least
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]465// one couldn't be killed.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]466BASE_EXPORT bool KillProcesses(const FilePath::StringType& executable_name,
467 int exit_code, const ProcessFilter* filter);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]468
469// Attempts to kill the process identified by the given process
470// entry structure, giving it the specified exit code. If |wait| is true, wait
471// for the process to be actually terminated before returning.
472// Returns true if this is successful, false otherwise.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]473BASE_EXPORT bool KillProcess(ProcessHandle process, int exit_code, bool wait);
rsimha@chromium.org61b93f88f2010-09-22 17:28:30[diff] [blame]474
475#if defined(OS_POSIX)
476// Attempts to kill the process group identified by |process_group_id|. Returns
477// true on success.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]478BASE_EXPORT bool KillProcessGroup(ProcessHandle process_group_id);
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]479#endif // defined(OS_POSIX)
rsimha@chromium.org61b93f88f2010-09-22 17:28:30[diff] [blame]480
agl@chromium.orgdfe14862009-01-22 01:23:11[diff] [blame]481#if defined(OS_WIN)
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]482BASE_EXPORT bool KillProcessById(ProcessId process_id, int exit_code,
483 bool wait);
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]484#endif // defined(OS_WIN)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]485
gspencer@chromium.org443b80e2010-12-14 00:42:23[diff] [blame]486// Get the termination status of the process by interpreting the
487// circumstances of the child process' death. |exit_code| is set to
488// the status returned by waitpid() on POSIX, and from
489// GetExitCodeProcess() on Windows. |exit_code| may be NULL if the
490// caller is not interested in it. Note that on Linux, this function
491// will only return a useful result the first time it is called after
492// the child exits (because it will reap the child and the information
493// will no longer be available).
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]494BASE_EXPORT TerminationStatus GetTerminationStatus(ProcessHandle handle,
495 int* exit_code);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]496
dmaclach@chromium.org56f0f262011-02-24 17:14:36[diff] [blame]497// Waits for process to exit. On POSIX systems, if the process hasn't been
phajdan.jr@chromium.orgc7856632009-01-13 17:38:49[diff] [blame]498// signaled then puts the exit code in |exit_code|; otherwise it's considered
499// a failure. On Windows |exit_code| is always filled. Returns true on success,
500// and closes |handle| in any case.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]501BASE_EXPORT bool WaitForExitCode(ProcessHandle handle, int* exit_code);
phajdan.jr@chromium.orgc7856632009-01-13 17:38:49[diff] [blame]502
phajdan.jr@chromium.org8004e682010-03-16 07:41:22[diff] [blame]503// Waits for process to exit. If it did exit within |timeout_milliseconds|,
phajdan.jr@chromium.org40bbe592011-04-06 12:18:20[diff] [blame]504// then puts the exit code in |exit_code|, and returns true.
phajdan.jr@chromium.org8004e682010-03-16 07:41:22[diff] [blame]505// In POSIX systems, if the process has been signaled then |exit_code| is set
506// to -1. Returns false on failure (the caller is then responsible for closing
507// |handle|).
phajdan.jr@chromium.org40bbe592011-04-06 12:18:20[diff] [blame]508// The caller is always responsible for closing the |handle|.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]509BASE_EXPORT bool WaitForExitCodeWithTimeout(ProcessHandle handle,
510 int* exit_code,
tedvessenes@gmail.coma73999122012-07-08 16:49:49[diff] [blame]511 base::TimeDelta timeout);
phajdan.jr@chromium.org8004e682010-03-16 07:41:22[diff] [blame]512
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]513// Wait for all the processes based on the named executable to exit. If filter
514// is non-null, then only processes selected by the filter are waited on.
515// Returns after all processes have exited or wait_milliseconds have expired.
516// Returns true if all the processes exited, false otherwise.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]517BASE_EXPORT bool WaitForProcessesToExit(
rvargas@google.com26fbf802011-03-25 18:48:03[diff] [blame]518 const FilePath::StringType& executable_name,
tedvessenes@gmail.coma73999122012-07-08 16:49:49[diff] [blame]519 base::TimeDelta wait,
520 const ProcessFilter* filter);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]521
estade@chromium.orgfb7f9be2008-10-22 01:15:47[diff] [blame]522// Wait for a single process to exit. Return true if it exited cleanly within
dmaclach@chromium.org56f0f262011-02-24 17:14:36[diff] [blame]523// the given time limit. On Linux |handle| must be a child process, however
524// on Mac and Windows it can be any process.
tedvessenes@gmail.com7e1117c2012-03-31 20:42:41[diff] [blame]525BASE_EXPORT bool WaitForSingleProcess(ProcessHandle handle,
526 base::TimeDelta wait);
phajdan.jr@chromium.orgc7c980972011-04-05 18:05:34[diff] [blame]527
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]528// Waits a certain amount of time (can be 0) for all the processes with a given
529// executable name to exit, then kills off any of them that are still around.
530// If filter is non-null, then only processes selected by the filter are waited
531// on. Killed processes are ended with the given exit code. Returns false if
532// any processes needed to be killed, true if they all exited cleanly within
533// the wait_milliseconds delay.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]534BASE_EXPORT bool CleanupProcesses(const FilePath::StringType& executable_name,
535 int64 wait_milliseconds,
536 int exit_code,
537 const ProcessFilter* filter);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]538
jam@chromium.orgeaac71592011-11-23 18:32:00[diff] [blame]539// This method ensures that the specified process eventually terminates, and
540// then it closes the given process handle.
541//
542// It assumes that the process has already been signalled to exit, and it
543// begins by waiting a small amount of time for it to exit. If the process
544// does not appear to have exited, then this function starts to become
545// aggressive about ensuring that the process terminates.
546//
547// On Linux this method does not block the calling thread.
548// On OS X this method may block for up to 2 seconds.
549//
550// NOTE: The process handle must have been opened with the PROCESS_TERMINATE
551// and SYNCHRONIZE permissions.
552//
553BASE_EXPORT void EnsureProcessTerminated(ProcessHandle process_handle);
554
555#if defined(OS_POSIX) && !defined(OS_MACOSX)
556// The nicer version of EnsureProcessTerminated() that is patient and will
557// wait for |process_handle| to finish and then reap it.
558BASE_EXPORT void EnsureProcessGetsReaped(ProcessHandle process_handle);
559#endif
560
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]561// This class provides a way to iterate through a list of processes on the
562// current machine with a specified filter.
563// To use, create an instance and then call NextProcessEntry() until it returns
564// false.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]565class BASE_EXPORT ProcessIterator {
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]566 public:
maruel@chromium.orgbaead4f2010-06-11 19:10:30[diff] [blame]567 typedef std::list<ProcessEntry> ProcessEntries;
568
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]569 explicit ProcessIterator(const ProcessFilter* filter);
570 virtual ~ProcessIterator();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]571
572 // If there's another process that matches the given executable name,
573 // returns a const pointer to the corresponding PROCESSENTRY32.
574 // If there are no more matching processes, returns NULL.
575 // The returned pointer will remain valid until NextProcessEntry()
576 // is called again or this NamedProcessIterator goes out of scope.
577 const ProcessEntry* NextProcessEntry();
578
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]579 // Takes a snapshot of all the ProcessEntry found.
maruel@chromium.orgbaead4f2010-06-11 19:10:30[diff] [blame]580 ProcessEntries Snapshot();
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]581
582 protected:
583 virtual bool IncludeEntry();
584 const ProcessEntry& entry() { return entry_; }
585
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]586 private:
587 // Determines whether there's another process (regardless of executable)
588 // left in the list of all processes. Returns true and sets entry_ to
589 // that process's info if there is one, false otherwise.
590 bool CheckForNextProcess();
591
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]592 // Initializes a PROCESSENTRY32 data structure so that it's ready for
593 // use with Process32First/Process32Next.
594 void InitProcessEntry(ProcessEntry* entry);
dkegel@google.comab0e2222008-10-31 20:19:43[diff] [blame]595
596#if defined(OS_WIN)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]597 HANDLE snapshot_;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]598 bool started_iteration_;
robert.nagy@gmail.comaf824362011-12-04 14:19:41[diff] [blame]599#elif defined(OS_MACOSX) || defined(OS_BSD)
mark@chromium.org962dd312009-02-05 21:44:13[diff] [blame]600 std::vector<kinfo_proc> kinfo_procs_;
601 size_t index_of_kinfo_proc_;
wtc@chromium.org4a34ce02009-08-31 22:25:00[diff] [blame]602#elif defined(OS_POSIX)
thestig@chromium.orga82af392012-02-24 04:40:20[diff] [blame]603 DIR* procfs_dir_;
dkegel@google.comab0e2222008-10-31 20:19:43[diff] [blame]604#endif
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]605 ProcessEntry entry_;
606 const ProcessFilter* filter_;
607
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]608 DISALLOW_COPY_AND_ASSIGN(ProcessIterator);
609};
610
611// This class provides a way to iterate through the list of processes
612// on the current machine that were started from the given executable
613// name. To use, create an instance and then call NextProcessEntry()
614// until it returns false.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]615class BASE_EXPORT NamedProcessIterator : public ProcessIterator {
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]616 public:
avi@chromium.org4f260d02010-12-23 18:35:42[diff] [blame]617 NamedProcessIterator(const FilePath::StringType& executable_name,
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]618 const ProcessFilter* filter);
619 virtual ~NamedProcessIterator();
620
621 protected:
avi@chromium.orgb1719462011-11-16 00:08:08[diff] [blame]622 virtual bool IncludeEntry() OVERRIDE;
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]623
624 private:
avi@chromium.org4f260d02010-12-23 18:35:42[diff] [blame]625 FilePath::StringType executable_name_;
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]626
627 DISALLOW_COPY_AND_ASSIGN(NamedProcessIterator);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]628};
629
630// Working Set (resident) memory usage broken down by
agl@chromium.org54fd1d32009-09-01 00:12:58[diff] [blame]631//
632// On Windows:
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]633// priv (private): These pages (kbytes) cannot be shared with any other process.
634// shareable: These pages (kbytes) can be shared with other processes under
635// the right circumstances.
636// shared : These pages (kbytes) are currently shared with at least one
637// other process.
agl@chromium.org54fd1d32009-09-01 00:12:58[diff] [blame]638//
639// On Linux:
640// priv: Pages mapped only by this process
641// shared: PSS or 0 if the kernel doesn't support this
642// shareable: 0
viettrungluu@chromium.org3740cb9b52009-12-19 04:50:04[diff] [blame]643//
644// On OS X: TODO(thakis): Revise.
645// priv: Memory.
646// shared: 0
647// shareable: 0
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]648struct WorkingSetKBytes {
agl@chromium.org54fd1d32009-09-01 00:12:58[diff] [blame]649 WorkingSetKBytes() : priv(0), shareable(0), shared(0) {}
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]650 size_t priv;
651 size_t shareable;
652 size_t shared;
653};
654
655// Committed (resident + paged) memory usage broken down by
656// private: These pages cannot be shared with any other process.
657// mapped: These pages are mapped into the view of a section (backed by
658// pagefile.sys)
659// image: These pages are mapped into the view of an image section (backed by
660// file system)
661struct CommittedKBytes {
agl@chromium.org54fd1d32009-09-01 00:12:58[diff] [blame]662 CommittedKBytes() : priv(0), mapped(0), image(0) {}
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]663 size_t priv;
664 size_t mapped;
665 size_t image;
666};
667
668// Free memory (Megabytes marked as free) in the 2G process address space.
669// total : total amount in megabytes marked as free. Maximum value is 2048.
670// largest : size of the largest contiguous amount of memory found. It is
671// always smaller or equal to FreeMBytes::total.
672// largest_ptr: starting address of the largest memory block.
673struct FreeMBytes {
674 size_t total;
675 size_t largest;
676 void* largest_ptr;
677};
678
evan@chromium.orgd2ed23832009-09-19 01:57:39[diff] [blame]679// Convert a POSIX timeval to microseconds.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]680BASE_EXPORT int64 TimeValToMicroseconds(const struct timeval& tv);
evan@chromium.orgd2ed23832009-09-19 01:57:39[diff] [blame]681
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]682// Provides performance metrics for a specified process (CPU usage, memory and
683// IO counters). To use it, invoke CreateProcessMetrics() to get an instance
684// for a specific process, then access the information with the different get
685// methods.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]686class BASE_EXPORT ProcessMetrics {
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]687 public:
erg@google.coma502bbe72011-01-07 18:06:45[diff] [blame]688 ~ProcessMetrics();
689
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]690 // Creates a ProcessMetrics for the specified process.
691 // The caller owns the returned object.
stuartmorgan@chromium.orgb80ffe22012-07-11 15:35:02[diff] [blame]692#if !defined(OS_MACOSX) || defined(OS_IOS)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]693 static ProcessMetrics* CreateProcessMetrics(ProcessHandle process);
viettrungluu@chromium.org3740cb9b52009-12-19 04:50:04[diff] [blame]694#else
695 class PortProvider {
696 public:
thakis@chromium.orgb2e8e082009-12-21 17:44:20[diff] [blame]697 // Should return the mach task for |process| if possible, or else
698 // |MACH_PORT_NULL|. Only processes that this returns tasks for will have
699 // metrics on OS X (except for the current process, which always gets
700 // metrics).
viettrungluu@chromium.org3740cb9b52009-12-19 04:50:04[diff] [blame]701 virtual mach_port_t TaskForPid(ProcessHandle process) const = 0;
702 };
703
704 // The port provider needs to outlive the ProcessMetrics object returned by
705 // this function. If NULL is passed as provider, the returned object
706 // only returns valid metrics if |process| is the current process.
707 static ProcessMetrics* CreateProcessMetrics(ProcessHandle process,
708 PortProvider* port_provider);
stuartmorgan@chromium.orgb80ffe22012-07-11 15:35:02[diff] [blame]709#endif // !defined(OS_MACOSX) || defined(OS_IOS)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]710
711 // Returns the current space allocated for the pagefile, in bytes (these pages
thomasvl@chromium.org796da7c2009-06-11 12:45:45[diff] [blame]712 // may or may not be in memory). On Linux, this returns the total virtual
713 // memory size.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]714 size_t GetPagefileUsage() const;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]715 // Returns the peak space allocated for the pagefile, in bytes.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]716 size_t GetPeakPagefileUsage() const;
thomasvl@chromium.org796da7c2009-06-11 12:45:45[diff] [blame]717 // Returns the current working set size, in bytes. On Linux, this returns
718 // the resident set size.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]719 size_t GetWorkingSetSize() const;
tc@google.com0c557f12009-05-11 23:35:52[diff] [blame]720 // Returns the peak working set size, in bytes.
721 size_t GetPeakWorkingSetSize() const;
erg@chromium.org98947a02010-05-11 17:46:08[diff] [blame]722 // Returns private and sharedusage, in bytes. Private bytes is the amount of
723 // memory currently allocated to a process that cannot be shared. Returns
724 // false on platform specific error conditions. Note: |private_bytes|
725 // returns 0 on unsupported OSes: prior to XP SP2.
726 bool GetMemoryBytes(size_t* private_bytes,
727 size_t* shared_bytes);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]728 // Fills a CommittedKBytes with both resident and paged
729 // memory usage as per definition of CommittedBytes.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]730 void GetCommittedKBytes(CommittedKBytes* usage) const;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]731 // Fills a WorkingSetKBytes containing resident private and shared memory
732 // usage in bytes, as per definition of WorkingSetBytes.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]733 bool GetWorkingSetKBytes(WorkingSetKBytes* ws_usage) const;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]734
735 // Computes the current process available memory for allocation.
736 // It does a linear scan of the address space querying each memory region
737 // for its free (unallocated) status. It is useful for estimating the memory
738 // load and fragmentation.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]739 bool CalculateFreeMemory(FreeMBytes* free) const;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]740
741 // Returns the CPU usage in percent since the last time this method was
742 // called. The first time this method is called it returns 0 and will return
743 // the actual CPU info on subsequent calls.
thakis@chromium.org022eab62010-01-13 04:55:06[diff] [blame]744 // On Windows, the CPU usage value is for all CPUs. So if you have 2 CPUs and
745 // your process is using all the cycles of 1 CPU and not the other CPU, this
746 // method returns 50.
747 double GetCPUUsage();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]748
749 // Retrieves accounting information for all I/O operations performed by the
750 // process.
751 // If IO information is retrieved successfully, the function returns true
752 // and fills in the IO_COUNTERS passed in. The function returns false
753 // otherwise.
phajdan.jr@chromium.orgd043c2cc2009-03-25 18:30:45[diff] [blame]754 bool GetIOCounters(IoCounters* io_counters) const;
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]755
756 private:
stuartmorgan@chromium.orgb80ffe22012-07-11 15:35:02[diff] [blame]757#if !defined(OS_MACOSX) || defined(OS_IOS)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]758 explicit ProcessMetrics(ProcessHandle process);
viettrungluu@chromium.org3740cb9b52009-12-19 04:50:04[diff] [blame]759#else
760 ProcessMetrics(ProcessHandle process, PortProvider* port_provider);
stuartmorgan@chromium.orgb80ffe22012-07-11 15:35:02[diff] [blame]761#endif // !defined(OS_MACOSX) || defined(OS_IOS)
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]762
763 ProcessHandle process_;
764
765 int processor_count_;
766
evan@chromium.orgd2ed23832009-09-19 01:57:39[diff] [blame]767 // Used to store the previous times and CPU usage counts so we can
768 // compute the CPU usage between calls.
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]769 int64 last_time_;
770 int64 last_system_time_;
771
stuartmorgan@chromium.orgb80ffe22012-07-11 15:35:02[diff] [blame]772#if !defined(OS_IOS)
viettrungluu@chromium.org3740cb9b52009-12-19 04:50:04[diff] [blame]773#if defined(OS_MACOSX)
774 // Queries the port provider if it's set.
775 mach_port_t TaskForPid(ProcessHandle process) const;
776
777 PortProvider* port_provider_;
pvalchev@google.com66700d42010-03-10 07:46:43[diff] [blame]778#elif defined(OS_POSIX)
779 // Jiffie count at the last_time_ we updated.
780 int last_cpu_;
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]781#endif // defined(OS_POSIX)
stuartmorgan@chromium.orgb80ffe22012-07-11 15:35:02[diff] [blame]782#endif // !defined(OS_IOS)
viettrungluu@chromium.org3740cb9b52009-12-19 04:50:04[diff] [blame]783
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]784 DISALLOW_COPY_AND_ASSIGN(ProcessMetrics);
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]785};
786
jingzhao@chromium.org4d0f93c2011-09-29 04:43:54[diff] [blame]787#if defined(OS_LINUX) || defined(OS_ANDROID)
jamescook@chromium.orgf37661dd2011-08-11 18:10:04[diff] [blame]788// Data from /proc/meminfo about system-wide memory consumption.
789// Values are in KB.
jamescook@chromium.orgd6d4dae2012-04-18 17:47:32[diff] [blame]790struct BASE_EXPORT SystemMemoryInfoKB {
791 SystemMemoryInfoKB();
792
jamescook@chromium.orgf37661dd2011-08-11 18:10:04[diff] [blame]793 int total;
794 int free;
795 int buffers;
796 int cached;
797 int active_anon;
798 int inactive_anon;
jamescook@chromium.orgd6d4dae2012-04-18 17:47:32[diff] [blame]799 int active_file;
800 int inactive_file;
jamescook@chromium.orgf37661dd2011-08-11 18:10:04[diff] [blame]801 int shmem;
802};
jamescook@chromium.org14cb2b2d2011-08-02 16:33:24[diff] [blame]803// Retrieves data from /proc/meminfo about system-wide memory consumption.
jamescook@chromium.orgf37661dd2011-08-11 18:10:04[diff] [blame]804// Fills in the provided |meminfo| structure. Returns true on success.
805// Exposed for memory debugging widget.
806BASE_EXPORT bool GetSystemMemoryInfo(SystemMemoryInfoKB* meminfo);
jingzhao@chromium.org4d0f93c2011-09-29 04:43:54[diff] [blame]807#endif // defined(OS_LINUX) || defined(OS_ANDROID)
jamescook@chromium.org14cb2b2d2011-08-02 16:33:24[diff] [blame]808
809// Returns the memory committed by the system in KBytes.
sgk@chromium.orged26d942009-11-09 06:57:28[diff] [blame]810// Returns 0 if it can't compute the commit charge.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]811BASE_EXPORT size_t GetSystemCommitCharge();
sgk@chromium.orged26d942009-11-09 06:57:28[diff] [blame]812
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]813// Enables low fragmentation heap (LFH) for every heaps of this process. This
814// won't have any effect on heaps created after this function call. It will not
815// modify data allocated in the heaps before calling this function. So it is
816// better to call this function early in initialization and again before
817// entering the main loop.
818// Note: Returns true on Windows 2000 without doing anything.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]819BASE_EXPORT bool EnableLowFragmentationHeap();
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]820
maruel@chromium.orgd6fc9fd2009-10-27 18:03:47[diff] [blame]821// Enables 'terminate on heap corruption' flag. Helps protect against heap
maruel@google.comc9d40872008-09-24 12:58:37[diff] [blame]822// overflow. Has no effect if the OS doesn't provide the necessary facility.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]823BASE_EXPORT void EnableTerminationOnHeapCorruption();
maruel@google.comc9d40872008-09-24 12:58:37[diff] [blame]824
jam@chromium.orgfecbc6c2011-08-31 20:37:59[diff] [blame]825// Turns on process termination if memory runs out.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]826BASE_EXPORT void EnableTerminationOnOutOfMemory();
jam@chromium.orgfecbc6c2011-08-31 20:37:59[diff] [blame]827
avi@chromium.org6cfa3392010-07-01 20:11:43[diff] [blame]828#if defined(OS_MACOSX)
829// Exposed for testing.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]830BASE_EXPORT malloc_zone_t* GetPurgeableZone();
gspencer@google.com03eb9d22011-08-23 17:58:21[diff] [blame]831#endif // defined(OS_MACOSX)
avi@chromium.orgcccb2122009-11-12 20:39:56[diff] [blame]832
maruel@chromium.orgd6fc9fd2009-10-27 18:03:47[diff] [blame]833// Enables stack dump to console output on exception and signals.
834// When enabled, the process will quit immediately. This is meant to be used in
835// unit_tests only!
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]836BASE_EXPORT bool EnableInProcessStackDumping();
maruel@chromium.orgd6fc9fd2009-10-27 18:03:47[diff] [blame]837
deanm@google.comdb717282008-08-27 13:48:03[diff] [blame]838// If supported on the platform, and the user has sufficent rights, increase
839// the current process's scheduling priority to a high priority.
darin@chromium.org0bea7252011-08-05 15:34:00[diff] [blame]840BASE_EXPORT void RaiseProcessToHighPriority();
deanm@google.comdb717282008-08-27 13:48:03[diff] [blame]841
mark@chromium.orge9a8c19f2009-09-03 21:27:36[diff] [blame]842#if defined(OS_MACOSX)
843// Restore the default exception handler, setting it to Apple Crash Reporter
844// (ReportCrash). When forking and execing a new process, the child will
845// inherit the parent's exception ports, which may be set to the Breakpad
846// instance running inside the parent. The parent's Breakpad instance should
847// not handle the child's exceptions. Calling RestoreDefaultExceptionHandler
848// in the child after forking will restore the standard exception handler.
849// See http://crbug.com/20371/ for more details.
850void RestoreDefaultExceptionHandler();
maruel@chromium.orgb6128aa2010-04-29 17:44:42[diff] [blame]851#endif // defined(OS_MACOSX)
mark@chromium.orge9a8c19f2009-09-03 21:27:36[diff] [blame]852
brettw@google.com176aa482008-11-14 03:25:15[diff] [blame]853} // namespace base
initial.commitd7cae122008-07-26 21:49:38[diff] [blame]854
deanm@google.comdb717282008-08-27 13:48:03[diff] [blame]855#endif // BASE_PROCESS_UTIL_H_