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