git

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
}
196