compat/win32/trace2_win32_process_info.c

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