1// Copyright (c) 2009 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#ifndef CHROME_BROWSER_PROCESS_INFO_SNAPSHOT_H_
6#define CHROME_BROWSER_PROCESS_INFO_SNAPSHOT_H_
7#pragma once
8
9#include <sys/types.h>
10
11#include <map>
12#include <string>
13#include <vector>
14
15#include "base/process_util.h"
16
17// A class which captures process information at a given point in time when its
18// |Sample()| method is called. This information can then be probed by PID.
19// |Sample()| may take a while to complete, so if calling from the browser
20// process, only do so from the file thread.
21// TODO(viettrungluu): This is currently only implemented and used on Mac, so
22// things are very Mac-specific. If this is ever implemented for other
23// platforms, we should subclass and add opaqueness (probably |ProcInfoEntry|
24// should be considered opaque).
25class ProcessInfoSnapshot {
26 public:
27  ProcessInfoSnapshot();
28  ~ProcessInfoSnapshot();
29
30  // Maximum size of lists of PIDs which this class will accept; used in
31  // |Sample()| below.
32  static const size_t kMaxPidListSize;
33
34  // Capture a snapshot of process memory information for the
35  // given list of PIDs. Call only from the file thread.
36  //   |pid_list| - list of |ProcessId|s on which to capture information; must
37  //     have no more than |kMaxPidListSize| (above) entries,
38  //   returns - |true| if okay, |false| on error.
39  bool Sample(std::vector<base::ProcessId> pid_list);
40
41  // Reset all statistics (deallocating any memory allocated).
42  void Reset();
43
44  // Our basic structure for storing information about a process (the names are
45  // mostly self-explanatory). Note that |command| may not actually reflect the
46  // actual executable name; never trust it absolutely, and only take it
47  // half-seriously when it begins with '/'.
48  struct ProcInfoEntry {
49    base::ProcessId pid;
50    base::ProcessId ppid;
51    uid_t uid;
52    uid_t euid;
53    // Explicitly use uint64_t instead of size_t in case this code is running
54    // in a 32 bit process and the target process is 64 bit.
55    uint64_t rss;
56    uint64_t rshrd;
57    uint64_t rprvt;
58    uint64_t vsize;
59    std::string command;
60
61    ProcInfoEntry()
62        : pid(0),
63          ppid(0),
64          uid(0),
65          euid(0),
66          rss(0),
67          rshrd(0),
68          rprvt(0),
69          vsize(0) {
70    }
71  };
72
73  // Get process information for a given PID.
74  //   |pid| - self-explanatory.
75  //   |proc_info| - place to put the process information.
76  //   returns - |true| if okay, |false| on error (including PID not found).
77  bool GetProcInfo(int pid,
78                   ProcInfoEntry* proc_info) const;
79
80  // Fills a |CommittedKBytes| with both resident and paged memory usage, as per
81  // its definition (or as close as we can manage). In the current (Mac)
82  // implementation, we map:
83  //                              vsize --> comm_priv,
84  //                                  0 --> comm_mapped,
85  //                                  0 --> comm_image;
86  //   in about:memory: virtual:private  =  comm_priv,
87  //                     virtual:mapped  =  comm_mapped.
88  // TODO(viettrungluu): Doing such a mapping is kind of ugly.
89  //   |pid| - self-explanatory.
90  //   |usage| - pointer to |CommittedBytes| to fill; zero-ed on error.
91  //   returns - |true| on success, |false| on error (including PID not found).
92  bool GetCommittedKBytesOfPID(int pid,
93                               base::CommittedKBytes* usage) const;
94
95  // Fills a |WorkingSetKBytes| containing resident private and shared memory,
96  // as per its definition (or as close as we can manage). In the current (Mac)
97  // implementation, we map:
98  //                          rprvt --> ws_priv,
99  //                            rss --> ws_shareable,
100  //                          rshrd --> ws_shared;
101  //   in about:memory: res:private  =  ws_priv + ws_shareable - ws_shared,
102  //                     res:shared  =  ws_shared / num_procs,
103  //                      res:total  =  res:private + res:shared.
104  // TODO(viettrungluu): Doing such a mapping is kind of ugly.
105  //   |pid| - self-explanatory.
106  //   |ws_usage| - pointer to |WorkingSetKBytes| to fill; zero-ed on error.
107  //   returns - |true| on success, |false| on error (including PID not found).
108  bool GetWorkingSetKBytesOfPID(int pid,
109                                base::WorkingSetKBytes* ws_usage) const;
110
111  // TODO(viettrungluu): Maybe we should also have the following (again, for
112  // "compatibility"):
113  //    size_t GetWorkingSetSizeOfPID(int pid) const;
114  //    size_t GetPeakWorkingSetSizeOfPID(int pid) const;
115  //    size_t GetPrivateBytesOfPID(int pid) const;
116
117 private:
118  // map from |int| (PID) to |ProcInfoEntry|
119  std::map<int,ProcInfoEntry> proc_info_entries_;
120};
121
122#endif  // CHROME_BROWSER_PROCESS_INFO_SNAPSHOT_H_
123