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.
5 // This file/namespace contains utility functions for enumerating, ending and
6 // computing statistics of processes.
8 #ifndef BASE_PROCESS_UTIL_H_
9 #define BASE_PROCESS_UTIL_H_
12 #include "base/basictypes.h"
17 #elif defined(OS_MACOSX)
18 // kinfo_proc is defined in <sys/sysctl.h>, but this forward declaration
19 // is sufficient for the vector<kinfo_proc> below.
21 // malloc_zone_t is defined in <malloc/malloc.h>, but this forward declaration
22 // is sufficient for GetPurgeableZone() below.
23 typedef struct _malloc_zone_t malloc_zone_t
;
24 #include <mach/mach.h>
25 #elif defined(OS_POSIX)
28 #include <sys/types.h>
36 #include "base/file_descriptor_shuffle.h"
37 #include "base/file_path.h"
38 #include "base/process.h"
45 struct ProcessEntry
: public PROCESSENTRY32
{
46 ProcessId
pid() const { return th32ProcessID
; }
47 ProcessId
parent_pid() const { return th32ParentProcessID
; }
48 const wchar_t* exe_file() const { return szExeFile
; }
51 struct IoCounters
: public IO_COUNTERS
{
54 // Process access masks. These constants provide platform-independent
55 // definitions for the standard Windows access masks.
56 // See http://msdn.microsoft.com/en-us/library/ms684880(VS.85).aspx for
57 // the specific semantics of each mask value.
58 const uint32 kProcessAccessTerminate
= PROCESS_TERMINATE
;
59 const uint32 kProcessAccessCreateThread
= PROCESS_CREATE_THREAD
;
60 const uint32 kProcessAccessSetSessionId
= PROCESS_SET_SESSIONID
;
61 const uint32 kProcessAccessVMOperation
= PROCESS_VM_OPERATION
;
62 const uint32 kProcessAccessVMRead
= PROCESS_VM_READ
;
63 const uint32 kProcessAccessVMWrite
= PROCESS_VM_WRITE
;
64 const uint32 kProcessAccessDuplicateHandle
= PROCESS_DUP_HANDLE
;
65 const uint32 kProcessAccessCreateProcess
= PROCESS_CREATE_PROCESS
;
66 const uint32 kProcessAccessSetQuota
= PROCESS_SET_QUOTA
;
67 const uint32 kProcessAccessSetInformation
= PROCESS_SET_INFORMATION
;
68 const uint32 kProcessAccessQueryInformation
= PROCESS_QUERY_INFORMATION
;
69 const uint32 kProcessAccessSuspendResume
= PROCESS_SUSPEND_RESUME
;
70 const uint32 kProcessAccessQueryLimitedInfomation
=
71 PROCESS_QUERY_LIMITED_INFORMATION
;
72 const uint32 kProcessAccessWaitForTermination
= SYNCHRONIZE
;
73 #elif defined(OS_POSIX)
79 ProcessId
pid() const { return pid_
; }
80 ProcessId
parent_pid() const { return ppid_
; }
81 ProcessId
gid() const { return gid_
; }
82 const char* exe_file() const { return exe_file_
.c_str(); }
83 const std::vector
<std::string
>& cmd_line_args() const {
84 return cmd_line_args_
;
90 std::string exe_file_
;
91 std::vector
<std::string
> cmd_line_args_
;
95 uint64_t ReadOperationCount
;
96 uint64_t WriteOperationCount
;
97 uint64_t OtherOperationCount
;
98 uint64_t ReadTransferCount
;
99 uint64_t WriteTransferCount
;
100 uint64_t OtherTransferCount
;
103 // Process access masks. They are not used on Posix because access checking
104 // does not happen during handle creation.
105 const uint32 kProcessAccessTerminate
= 0;
106 const uint32 kProcessAccessCreateThread
= 0;
107 const uint32 kProcessAccessSetSessionId
= 0;
108 const uint32 kProcessAccessVMOperation
= 0;
109 const uint32 kProcessAccessVMRead
= 0;
110 const uint32 kProcessAccessVMWrite
= 0;
111 const uint32 kProcessAccessDuplicateHandle
= 0;
112 const uint32 kProcessAccessCreateProcess
= 0;
113 const uint32 kProcessAccessSetQuota
= 0;
114 const uint32 kProcessAccessSetInformation
= 0;
115 const uint32 kProcessAccessQueryInformation
= 0;
116 const uint32 kProcessAccessSuspendResume
= 0;
117 const uint32 kProcessAccessQueryLimitedInfomation
= 0;
118 const uint32 kProcessAccessWaitForTermination
= 0;
119 #endif // defined(OS_POSIX)
121 // Return status values from GetTerminationStatus. Don't use these as
122 // exit code arguments to KillProcess*(), use platform/application
123 // specific values instead.
124 enum TerminationStatus
{
125 TERMINATION_STATUS_NORMAL_TERMINATION
, // zero exit status
126 TERMINATION_STATUS_ABNORMAL_TERMINATION
, // non-zero exit status
127 TERMINATION_STATUS_PROCESS_WAS_KILLED
, // e.g. SIGKILL or task manager kill
128 TERMINATION_STATUS_PROCESS_CRASHED
, // e.g. Segmentation fault
129 TERMINATION_STATUS_STILL_RUNNING
// child hasn't exited yet
132 // Returns the id of the current process.
133 ProcessId
GetCurrentProcId();
135 // Returns the ProcessHandle of the current process.
136 ProcessHandle
GetCurrentProcessHandle();
138 // Converts a PID to a process handle. This handle must be closed by
139 // CloseProcessHandle when you are done with it. Returns true on success.
140 bool OpenProcessHandle(ProcessId pid
, ProcessHandle
* handle
);
142 // Converts a PID to a process handle. On Windows the handle is opened
143 // with more access rights and must only be used by trusted code.
144 // You have to close returned handle using CloseProcessHandle. Returns true
146 // TODO(sanjeevr): Replace all calls to OpenPrivilegedProcessHandle with the
147 // more specific OpenProcessHandleWithAccess method and delete this.
148 bool OpenPrivilegedProcessHandle(ProcessId pid
, ProcessHandle
* handle
);
150 // Converts a PID to a process handle using the desired access flags. Use a
151 // combination of the kProcessAccess* flags defined above for |access_flags|.
152 bool OpenProcessHandleWithAccess(ProcessId pid
,
154 ProcessHandle
* handle
);
156 // Closes the process handle opened by OpenProcessHandle.
157 void CloseProcessHandle(ProcessHandle process
);
159 // Returns the unique ID for the specified process. This is functionally the
160 // same as Windows' GetProcessId(), but works on versions of Windows before
161 // Win XP SP1 as well.
162 ProcessId
GetProcId(ProcessHandle process
);
164 #if defined(OS_LINUX)
165 // Returns the path to the executable of the given process.
166 FilePath
GetProcessExecutablePath(ProcessHandle process
);
168 // Parse the data found in /proc/<pid>/stat and return the sum of the
169 // CPU-related ticks. Returns -1 on parse error.
170 // Exposed for testing.
171 int ParseProcStatCPU(const std::string
& input
);
173 static const char kAdjustOOMScoreSwitch
[] = "--adjust-oom-score";
175 // This adjusts /proc/process/oom_adj so the Linux OOM killer will prefer
176 // certain process types over others. The range for the adjustment is
177 // [-17,15], with [0,15] being user accessible.
178 bool AdjustOOMScore(ProcessId process
, int score
);
181 #if defined(OS_POSIX)
182 // Returns the ID for the parent of the given process.
183 ProcessId
GetParentProcessId(ProcessHandle process
);
185 // Close all file descriptors, except those which are a destination in the
186 // given multimap. Only call this function in a child process where you know
187 // that there aren't any other threads.
188 void CloseSuperfluousFds(const InjectiveMultimap
& saved_map
);
193 enum IntegrityLevel
{
199 // Determine the integrity level of the specified process. Returns false
200 // if the system does not support integrity levels (pre-Vista) or in the case
201 // of an underlying system failure.
202 bool GetProcessIntegrityLevel(ProcessHandle process
, IntegrityLevel
*level
);
204 // Runs the given application name with the given command line. Normally, the
205 // first command line argument should be the path to the process, and don't
206 // forget to quote it.
208 // If wait is true, it will block and wait for the other process to finish,
209 // otherwise, it will just continue asynchronously.
211 // Example (including literal quotes)
212 // cmdline = "c:\windows\explorer.exe" -foo "c:\bar\"
214 // If process_handle is non-NULL, the process handle of the launched app will be
215 // stored there on a successful launch.
216 // NOTE: In this case, the caller is responsible for closing the handle so
217 // that it doesn't leak!
218 bool LaunchApp(const std::wstring
& cmdline
,
219 bool wait
, bool start_hidden
, ProcessHandle
* process_handle
);
221 // Same as LaunchApp, except allows the new process to inherit handles of the
223 bool LaunchAppWithHandleInheritance(const std::wstring
& cmdline
,
226 ProcessHandle
* process_handle
);
228 // Runs the given application name with the given command line as if the user
229 // represented by |token| had launched it. The caveats about |cmdline| and
230 // |process_handle| explained for LaunchApp above apply as well.
232 // Whether the application is visible on the interactive desktop depends on
233 // the token belonging to an interactive logon session.
235 // To avoid hard to diagnose problems, this function internally loads the
236 // environment variables associated with the user and if this operation fails
237 // the entire call fails as well.
238 bool LaunchAppAsUser(UserTokenHandle token
, const std::wstring
& cmdline
,
239 bool start_hidden
, ProcessHandle
* process_handle
);
241 // Has the same behavior as LaunchAppAsUser, but offers the boolean option to
242 // use an empty string for the desktop name and a boolean for allowing the
243 // child process to inherit handles from its parent.
244 bool LaunchAppAsUser(UserTokenHandle token
, const std::wstring
& cmdline
,
245 bool start_hidden
, ProcessHandle
* process_handle
,
246 bool empty_desktop_name
, bool inherit_handles
);
249 #elif defined(OS_POSIX)
250 // Runs the application specified in argv[0] with the command line argv.
251 // Before launching all FDs open in the parent process will be marked as
252 // close-on-exec. |fds_to_remap| defines a mapping of src fd->dest fd to
253 // propagate FDs into the child process.
255 // As above, if wait is true, execute synchronously. The pid will be stored
256 // in process_handle if that pointer is non-null.
258 // Note that the first argument in argv must point to the executable filename.
259 // If the filename is not fully specified, PATH will be searched.
260 typedef std::vector
<std::pair
<int, int> > file_handle_mapping_vector
;
261 bool LaunchApp(const std::vector
<std::string
>& argv
,
262 const file_handle_mapping_vector
& fds_to_remap
,
263 bool wait
, ProcessHandle
* process_handle
);
265 // Similar to the above, but also (un)set environment variables in child process
266 // through |environ|.
267 typedef std::vector
<std::pair
<std::string
, std::string
> > environment_vector
;
268 bool LaunchApp(const std::vector
<std::string
>& argv
,
269 const environment_vector
& environ
,
270 const file_handle_mapping_vector
& fds_to_remap
,
271 bool wait
, ProcessHandle
* process_handle
);
273 // Similar to the above two methods, but starts the child process in a process
274 // group of its own, instead of allowing it to inherit the parent's process
275 // group. The pgid of the child process will be the same as its pid.
276 bool LaunchAppInNewProcessGroup(const std::vector
<std::string
>& argv
,
277 const environment_vector
& environ
,
278 const file_handle_mapping_vector
& fds_to_remap
,
279 bool wait
, ProcessHandle
* process_handle
);
281 // AlterEnvironment returns a modified environment vector, constructed from the
282 // given environment and the list of changes given in |changes|. Each key in
283 // the environment is matched against the first element of the pairs. In the
284 // event of a match, the value is replaced by the second of the pair, unless
285 // the second is empty, in which case the key-value is removed.
287 // The returned array is allocated using new[] and must be freed by the caller.
288 char** AlterEnvironment(const environment_vector
& changes
,
289 const char* const* const env
);
290 #endif // defined(OS_POSIX)
292 // Executes the application specified by cl. This function delegates to one
293 // of the above two platform-specific functions.
294 bool LaunchApp(const CommandLine
& cl
,
295 bool wait
, bool start_hidden
, ProcessHandle
* process_handle
);
297 // Executes the application specified by |cl| and wait for it to exit. Stores
298 // the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
299 // on success (application launched and exited cleanly, with exit code
300 // indicating success).
301 bool GetAppOutput(const CommandLine
& cl
, std::string
* output
);
303 #if defined(OS_POSIX)
304 // A restricted version of |GetAppOutput()| which (a) clears the environment,
305 // and (b) stores at most |max_output| bytes; also, it doesn't search the path
307 bool GetAppOutputRestricted(const CommandLine
& cl
,
308 std::string
* output
, size_t max_output
);
311 // Used to filter processes by process ID.
312 class ProcessFilter
{
314 // Returns true to indicate set-inclusion and false otherwise. This method
315 // should not have side-effects and should be idempotent.
316 virtual bool Includes(const ProcessEntry
& entry
) const = 0;
319 virtual ~ProcessFilter() {}
322 // Returns the number of processes on the machine that are running from the
323 // given executable name. If filter is non-null, then only processes selected
324 // by the filter will be counted.
325 int GetProcessCount(const FilePath::StringType
& executable_name
,
326 const ProcessFilter
* filter
);
328 // Attempts to kill all the processes on the current machine that were launched
329 // from the given executable name, ending them with the given exit code. If
330 // filter is non-null, then only processes selected by the filter are killed.
331 // Returns true if all processes were able to be killed off, false if at least
332 // one couldn't be killed.
333 bool KillProcesses(const FilePath::StringType
& executable_name
, int exit_code
,
334 const ProcessFilter
* filter
);
336 // Attempts to kill the process identified by the given process
337 // entry structure, giving it the specified exit code. If |wait| is true, wait
338 // for the process to be actually terminated before returning.
339 // Returns true if this is successful, false otherwise.
340 bool KillProcess(ProcessHandle process
, int exit_code
, bool wait
);
342 #if defined(OS_POSIX)
343 // Attempts to kill the process group identified by |process_group_id|. Returns
345 bool KillProcessGroup(ProcessHandle process_group_id
);
349 bool KillProcessById(ProcessId process_id
, int exit_code
, bool wait
);
352 // Get the termination status of the process by interpreting the
353 // circumstances of the child process' death. |exit_code| is set to
354 // the status returned by waitpid() on POSIX, and from
355 // GetExitCodeProcess() on Windows. |exit_code| may be NULL if the
356 // caller is not interested in it. Note that on Linux, this function
357 // will only return a useful result the first time it is called after
358 // the child exits (because it will reap the child and the information
359 // will no longer be available).
360 TerminationStatus
GetTerminationStatus(ProcessHandle handle
, int* exit_code
);
362 // Waits for process to exit. On POSIX systems, if the process hasn't been
363 // signaled then puts the exit code in |exit_code|; otherwise it's considered
364 // a failure. On Windows |exit_code| is always filled. Returns true on success,
365 // and closes |handle| in any case.
366 bool WaitForExitCode(ProcessHandle handle
, int* exit_code
);
368 // Waits for process to exit. If it did exit within |timeout_milliseconds|,
369 // then puts the exit code in |exit_code|, closes |handle|, and returns true.
370 // In POSIX systems, if the process has been signaled then |exit_code| is set
371 // to -1. Returns false on failure (the caller is then responsible for closing
373 bool WaitForExitCodeWithTimeout(ProcessHandle handle
, int* exit_code
,
374 int64 timeout_milliseconds
);
376 // Wait for all the processes based on the named executable to exit. If filter
377 // is non-null, then only processes selected by the filter are waited on.
378 // Returns after all processes have exited or wait_milliseconds have expired.
379 // Returns true if all the processes exited, false otherwise.
380 bool WaitForProcessesToExit(const FilePath::StringType
& executable_name
,
381 int64 wait_milliseconds
,
382 const ProcessFilter
* filter
);
384 // Wait for a single process to exit. Return true if it exited cleanly within
385 // the given time limit. On Linux |handle| must be a child process, however
386 // on Mac and Windows it can be any process.
387 bool WaitForSingleProcess(ProcessHandle handle
, int64 wait_milliseconds
);
389 // Returns true when |wait_milliseconds| have elapsed and the process
391 bool CrashAwareSleep(ProcessHandle handle
, int64 wait_milliseconds
);
393 // Waits a certain amount of time (can be 0) for all the processes with a given
394 // executable name to exit, then kills off any of them that are still around.
395 // If filter is non-null, then only processes selected by the filter are waited
396 // on. Killed processes are ended with the given exit code. Returns false if
397 // any processes needed to be killed, true if they all exited cleanly within
398 // the wait_milliseconds delay.
399 bool CleanupProcesses(const FilePath::StringType
& executable_name
,
400 int64 wait_milliseconds
,
402 const ProcessFilter
* filter
);
404 // This class provides a way to iterate through a list of processes on the
405 // current machine with a specified filter.
406 // To use, create an instance and then call NextProcessEntry() until it returns
408 class ProcessIterator
{
410 typedef std::list
<ProcessEntry
> ProcessEntries
;
412 explicit ProcessIterator(const ProcessFilter
* filter
);
413 virtual ~ProcessIterator();
415 // If there's another process that matches the given executable name,
416 // returns a const pointer to the corresponding PROCESSENTRY32.
417 // If there are no more matching processes, returns NULL.
418 // The returned pointer will remain valid until NextProcessEntry()
419 // is called again or this NamedProcessIterator goes out of scope.
420 const ProcessEntry
* NextProcessEntry();
422 // Takes a snapshot of all the ProcessEntry found.
423 ProcessEntries
Snapshot();
426 virtual bool IncludeEntry();
427 const ProcessEntry
& entry() { return entry_
; }
430 // Determines whether there's another process (regardless of executable)
431 // left in the list of all processes. Returns true and sets entry_ to
432 // that process's info if there is one, false otherwise.
433 bool CheckForNextProcess();
435 // Initializes a PROCESSENTRY32 data structure so that it's ready for
436 // use with Process32First/Process32Next.
437 void InitProcessEntry(ProcessEntry
* entry
);
441 bool started_iteration_
;
442 #elif defined(OS_MACOSX)
443 std::vector
<kinfo_proc
> kinfo_procs_
;
444 size_t index_of_kinfo_proc_
;
445 #elif defined(OS_POSIX)
449 const ProcessFilter
* filter_
;
451 DISALLOW_COPY_AND_ASSIGN(ProcessIterator
);
454 // This class provides a way to iterate through the list of processes
455 // on the current machine that were started from the given executable
456 // name. To use, create an instance and then call NextProcessEntry()
457 // until it returns false.
458 class NamedProcessIterator
: public ProcessIterator
{
460 NamedProcessIterator(const FilePath::StringType
& executable_name
,
461 const ProcessFilter
* filter
);
462 virtual ~NamedProcessIterator();
465 virtual bool IncludeEntry();
468 FilePath::StringType executable_name_
;
470 DISALLOW_COPY_AND_ASSIGN(NamedProcessIterator
);
473 // Working Set (resident) memory usage broken down by
476 // priv (private): These pages (kbytes) cannot be shared with any other process.
477 // shareable: These pages (kbytes) can be shared with other processes under
478 // the right circumstances.
479 // shared : These pages (kbytes) are currently shared with at least one
483 // priv: Pages mapped only by this process
484 // shared: PSS or 0 if the kernel doesn't support this
487 // On OS X: TODO(thakis): Revise.
491 struct WorkingSetKBytes
{
492 WorkingSetKBytes() : priv(0), shareable(0), shared(0) {}
498 // Committed (resident + paged) memory usage broken down by
499 // private: These pages cannot be shared with any other process.
500 // mapped: These pages are mapped into the view of a section (backed by
502 // image: These pages are mapped into the view of an image section (backed by
504 struct CommittedKBytes
{
505 CommittedKBytes() : priv(0), mapped(0), image(0) {}
511 // Free memory (Megabytes marked as free) in the 2G process address space.
512 // total : total amount in megabytes marked as free. Maximum value is 2048.
513 // largest : size of the largest contiguous amount of memory found. It is
514 // always smaller or equal to FreeMBytes::total.
515 // largest_ptr: starting address of the largest memory block.
522 // Convert a POSIX timeval to microseconds.
523 int64
TimeValToMicroseconds(const struct timeval
& tv
);
525 // Provides performance metrics for a specified process (CPU usage, memory and
526 // IO counters). To use it, invoke CreateProcessMetrics() to get an instance
527 // for a specific process, then access the information with the different get
529 class ProcessMetrics
{
533 // Creates a ProcessMetrics for the specified process.
534 // The caller owns the returned object.
535 #if !defined(OS_MACOSX)
536 static ProcessMetrics
* CreateProcessMetrics(ProcessHandle process
);
540 // Should return the mach task for |process| if possible, or else
541 // |MACH_PORT_NULL|. Only processes that this returns tasks for will have
542 // metrics on OS X (except for the current process, which always gets
544 virtual mach_port_t
TaskForPid(ProcessHandle process
) const = 0;
547 // The port provider needs to outlive the ProcessMetrics object returned by
548 // this function. If NULL is passed as provider, the returned object
549 // only returns valid metrics if |process| is the current process.
550 static ProcessMetrics
* CreateProcessMetrics(ProcessHandle process
,
551 PortProvider
* port_provider
);
552 #endif // !defined(OS_MACOSX)
554 // Returns the current space allocated for the pagefile, in bytes (these pages
555 // may or may not be in memory). On Linux, this returns the total virtual
557 size_t GetPagefileUsage() const;
558 // Returns the peak space allocated for the pagefile, in bytes.
559 size_t GetPeakPagefileUsage() const;
560 // Returns the current working set size, in bytes. On Linux, this returns
561 // the resident set size.
562 size_t GetWorkingSetSize() const;
563 // Returns the peak working set size, in bytes.
564 size_t GetPeakWorkingSetSize() const;
565 // Returns private and sharedusage, in bytes. Private bytes is the amount of
566 // memory currently allocated to a process that cannot be shared. Returns
567 // false on platform specific error conditions. Note: |private_bytes|
568 // returns 0 on unsupported OSes: prior to XP SP2.
569 bool GetMemoryBytes(size_t* private_bytes
,
570 size_t* shared_bytes
);
571 // Fills a CommittedKBytes with both resident and paged
572 // memory usage as per definition of CommittedBytes.
573 void GetCommittedKBytes(CommittedKBytes
* usage
) const;
574 // Fills a WorkingSetKBytes containing resident private and shared memory
575 // usage in bytes, as per definition of WorkingSetBytes.
576 bool GetWorkingSetKBytes(WorkingSetKBytes
* ws_usage
) const;
578 // Computes the current process available memory for allocation.
579 // It does a linear scan of the address space querying each memory region
580 // for its free (unallocated) status. It is useful for estimating the memory
581 // load and fragmentation.
582 bool CalculateFreeMemory(FreeMBytes
* free
) const;
584 // Returns the CPU usage in percent since the last time this method was
585 // called. The first time this method is called it returns 0 and will return
586 // the actual CPU info on subsequent calls.
587 // On Windows, the CPU usage value is for all CPUs. So if you have 2 CPUs and
588 // your process is using all the cycles of 1 CPU and not the other CPU, this
589 // method returns 50.
590 double GetCPUUsage();
592 // Retrieves accounting information for all I/O operations performed by the
594 // If IO information is retrieved successfully, the function returns true
595 // and fills in the IO_COUNTERS passed in. The function returns false
597 bool GetIOCounters(IoCounters
* io_counters
) const;
600 #if !defined(OS_MACOSX)
601 explicit ProcessMetrics(ProcessHandle process
);
603 ProcessMetrics(ProcessHandle process
, PortProvider
* port_provider
);
604 #endif // !defined(OS_MACOSX)
606 ProcessHandle process_
;
608 int processor_count_
;
610 // Used to store the previous times and CPU usage counts so we can
611 // compute the CPU usage between calls.
613 int64 last_system_time_
;
615 #if defined(OS_MACOSX)
616 // Queries the port provider if it's set.
617 mach_port_t
TaskForPid(ProcessHandle process
) const;
619 PortProvider
* port_provider_
;
620 #elif defined(OS_POSIX)
621 // Jiffie count at the last_time_ we updated.
623 #endif // defined(OS_MACOSX)
625 DISALLOW_COPY_AND_ASSIGN(ProcessMetrics
);
628 // Returns the memory commited by the system in KBytes.
629 // Returns 0 if it can't compute the commit charge.
630 size_t GetSystemCommitCharge();
632 // Enables low fragmentation heap (LFH) for every heaps of this process. This
633 // won't have any effect on heaps created after this function call. It will not
634 // modify data allocated in the heaps before calling this function. So it is
635 // better to call this function early in initialization and again before
636 // entering the main loop.
637 // Note: Returns true on Windows 2000 without doing anything.
638 bool EnableLowFragmentationHeap();
640 // Enables 'terminate on heap corruption' flag. Helps protect against heap
641 // overflow. Has no effect if the OS doesn't provide the necessary facility.
642 void EnableTerminationOnHeapCorruption();
645 // Turns on process termination if memory runs out. This is handled on Windows
646 // inside RegisterInvalidParamHandler().
647 void EnableTerminationOnOutOfMemory();
648 #if defined(OS_MACOSX)
649 // Exposed for testing.
650 malloc_zone_t
* GetPurgeableZone();
654 #if defined(UNIT_TEST)
655 // Enables stack dump to console output on exception and signals.
656 // When enabled, the process will quit immediately. This is meant to be used in
658 bool EnableInProcessStackDumping();
659 #endif // defined(UNIT_TEST)
661 // If supported on the platform, and the user has sufficent rights, increase
662 // the current process's scheduling priority to a high priority.
663 void RaiseProcessToHighPriority();
665 #if defined(OS_MACOSX)
666 // Restore the default exception handler, setting it to Apple Crash Reporter
667 // (ReportCrash). When forking and execing a new process, the child will
668 // inherit the parent's exception ports, which may be set to the Breakpad
669 // instance running inside the parent. The parent's Breakpad instance should
670 // not handle the child's exceptions. Calling RestoreDefaultExceptionHandler
671 // in the child after forking will restore the standard exception handler.
672 // See http://crbug.com/20371/ for more details.
673 void RestoreDefaultExceptionHandler();
674 #endif // defined(OS_MACOSX)
678 #endif // BASE_PROCESS_UTIL_H_