compat/win32/trace2_win32_process_info.c

   1 #include "../../cache.h"
   2 #include "../../json-writer.h"
   3 #include "lazyload.h"
   4 #include <Psapi.h>
   5 #include <tlHelp32.h>
   6
   7 /*
   8  * An arbitrarily chosen value to limit the size of the ancestor
   9  * array built in git_processes().
  10  */
  11 #define NR_PIDS_LIMIT 10
  12
  13 /*
  14  * Find the process data for the given PID in the given snapshot
  15  * and update the PROCESSENTRY32 data.
  16  */
  17 static int find_pid(DWORD pid, HANDLE hSnapshot, PROCESSENTRY32 *pe32)
  18 {
  19         pe32->dwSize = sizeof(PROCESSENTRY32);
  20
  21         if (Process32First(hSnapshot, pe32)) {
  22                 do {
  23                         if (pe32->th32ProcessID == pid)
  24                                 return 1;
  25                 } while (Process32Next(hSnapshot, pe32));
  26         }
  27         return 0;
  28 }
  29
  30 /*
  31  * Accumulate JSON array of our parent processes:
  32  *     [
  33  *         exe-name-parent,
  34  *         exe-name-grand-parent,
  35  *         ...
  36  *     ]
  37  *
  38  * Note: we only report the filename of the process executable; the
  39  *       only way to get its full pathname is to use OpenProcess()
  40  *       and GetModuleFileNameEx() or QueryfullProcessImageName()
  41  *       and that seems rather expensive (on top of the cost of
  42  *       getting the snapshot).
  43  *
  44  * Note: we compute the set of parent processes by walking the PPID
  45  *       link in each visited PROCESSENTRY32 record.  This search
  46  *       stops when an ancestor process is not found in the snapshot
  47  *       (because it exited before the current or intermediate parent
  48  *       process exited).
  49  *
  50  *       This search may compute an incorrect result if the PPID link
  51  *       refers to the PID of an exited parent and that PID has been
  52  *       recycled and given to a new unrelated process.
  53  *
  54  *       Worse, it is possible for a child or descendant of the
  55  *       current process to be given the recycled PID and cause a
  56  *       PPID-cycle.  This would cause an infinite loop building our
  57  *       parent process array.
  58  *
  59  * Note: for completeness, the "System Idle" process has PID=0 and
  60  *       PPID=0 and could cause another PPID-cycle.  We don't expect
  61  *       Git to be a descendant of the idle process, but because of
  62  *       PID recycling, it might be possible to get a PPID link value
  63  *       of 0.  This too would cause an infinite loop.
  64  *
  65  * Therefore, we keep an array of the visited PPIDs to guard against
  66  * cycles.
  67  *
  68  * We use a fixed-size array rather than ALLOC_GROW to keep things
  69  * simple and avoid the alloc/realloc overhead.  It is OK if we
  70  * truncate the search and return a partial answer.
  71  */
  72 static void get_processes(struct json_writer *jw, HANDLE hSnapshot)
  73 {
  74         PROCESSENTRY32 pe32;
  75         DWORD pid;
  76         DWORD pid_list[NR_PIDS_LIMIT];
  77         int k, nr_pids = 0;
  78
  79         pid = GetCurrentProcessId();
  80         while (find_pid(pid, hSnapshot, &pe32)) {
  81                 /* Only report parents. Omit self from the JSON output. */
  82                 if (nr_pids)
  83                         jw_array_string(jw, pe32.szExeFile);
  84
  85                 /* Check for cycle in snapshot. (Yes, it happened.) */
  86                 for (k = 0; k < nr_pids; k++)
  87                         if (pid == pid_list[k]) {
  88                                 jw_array_string(jw, "(cycle)");
  89                                 return;
  90                         }
  91
  92                 if (nr_pids == NR_PIDS_LIMIT) {
  93                         jw_array_string(jw, "(truncated)");
  94                         return;
  95                 }
  96
  97                 pid_list[nr_pids++] = pid;
  98
  99                 pid = pe32.th32ParentProcessID;
 100         }
 101 }
 102
 103 /*
 104  * Emit JSON data for the current and parent processes.  Individual
 105  * trace2 targets can decide how to actually print it.
 106  */
 107 static void get_ancestry(void)
 108 {
 109         HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 110
 111         if (hSnapshot != INVALID_HANDLE_VALUE) {
 112                 struct json_writer jw = JSON_WRITER_INIT;
 113
 114                 jw_array_begin(&jw, 0);
 115                 get_processes(&jw, hSnapshot);
 116                 jw_end(&jw);
 117
 118                 trace2_data_json("process", the_repository, "windows/ancestry",
 119                                  &jw);
 120
 121                 jw_release(&jw);
 122                 CloseHandle(hSnapshot);
 123         }
 124 }
 125
 126 /*
 127  * Is a debugger attached to the current process?
 128  *
 129  * This will catch debug runs (where the debugger started the process).
 130  * This is the normal case.  Since this code is called during our startup,
 131  * it will not report instances where a debugger is attached dynamically
 132  * to a running git process, but that is relatively rare.
 133  */
 134 static void get_is_being_debugged(void)
 135 {
 136         if (IsDebuggerPresent())
 137                 trace2_data_intmax("process", the_repository,
 138                                    "windows/debugger_present", 1);
 139 }
 140
 141 /*
 142  * Emit JSON data with the peak memory usage of the current process.
 143  */
 144 static void get_peak_memory_info(void)
 145 {
 146         DECLARE_PROC_ADDR(psapi.dll, BOOL, GetProcessMemoryInfo, HANDLE,
 147                           PPROCESS_MEMORY_COUNTERS, DWORD);
 148
 149         if (INIT_PROC_ADDR(GetProcessMemoryInfo)) {
 150                 PROCESS_MEMORY_COUNTERS pmc;
 151
 152                 if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc,
 153                                          sizeof(pmc))) {
 154                         struct json_writer jw = JSON_WRITER_INIT;
 155
 156                         jw_object_begin(&jw, 0);
 157
 158 #define KV(kv) #kv, (intmax_t)pmc.kv
 159
 160                         jw_object_intmax(&jw, KV(PageFaultCount));
 161                         jw_object_intmax(&jw, KV(PeakWorkingSetSize));
 162                         jw_object_intmax(&jw, KV(PeakPagefileUsage));
 163
 164                         jw_end(&jw);
 165
 166                         trace2_data_json("process", the_repository,
 167                                          "windows/memory", &jw);
 168                         jw_release(&jw);
 169                 }
 170         }
 171 }
 172
 173 void trace2_collect_process_info(enum trace2_process_info_reason reason)
 174 {
 175         if (!trace2_is_enabled())
 176                 return;
 177
 178         switch (reason) {
 179         case TRACE2_PROCESS_INFO_STARTUP:
 180                 get_is_being_debugged();
 181                 get_ancestry();
 182                 return;
 183
 184         case TRACE2_PROCESS_INFO_EXIT:
 185                 get_peak_memory_info();
 186                 return;
 187
 188         default:
 189                 BUG("trace2_collect_process_info: unknown reason '%d'", reason);
 190         }
 191 }