git

1
#include "git-compat-util.h"
2

3
#include "strbuf.h"
4
#include "strvec.h"
5
#include "trace2.h"
6

7
/*
8
 * We need more complex parsing in stat_parent_pid() and
9
 * parse_proc_stat() below than a dumb fscanf(). That's because while
10
 * the statcomm field is surrounded by parentheses, the process itself
11
 * is free to insert any arbitrary byte sequence its its name. That
12
 * can include newlines, spaces, closing parentheses etc.
13
 *
14
 * See do_task_stat() in fs/proc/array.c in linux.git, this is in
15
 * contrast with the escaped version of the name found in
16
 * /proc/%d/status.
17
 *
18
 * So instead of using fscanf() we'll read N bytes from it, look for
19
 * the first "(", and then the last ")", anything in-between is our
20
 * process name.
21
 *
22
 * How much N do we need? On Linux /proc/sys/kernel/pid_max is 2^15 by
23
 * default, but it can be raised set to values of up to 2^22. So
24
 * that's 7 digits for a PID. We have 2 PIDs in the first four fields
25
 * we're interested in, so 2 * 7 = 14.
26
 *
27
 * We then have 3 spaces between those four values, and we'd like to
28
 * get to the space between the 4th and the 5th (the "pgrp" field) to
29
 * make sure we read the entire "ppid" field. So that brings us up to
30
 * 14 + 3 + 1 = 18. Add the two parentheses around the "comm" value
31
 * and it's 20. The "state" value itself is then one character (now at
32
 * 21).
33
 *
34
 * Finally the maximum length of the "comm" name itself is 15
35
 * characters, e.g. a setting of "123456789abcdefg" will be truncated
36
 * to "123456789abcdef". See PR_SET_NAME in prctl(2). So all in all
37
 * we'd need to read 21 + 15 = 36 bytes.
38
 *
39
 * Let's just read 2^6 (64) instead for good measure. If PID_MAX ever
40
 * grows past 2^22 we'll be future-proof. We'll then anchor at the
41
 * last ")" we find to locate the parent PID.
42
 */
43
#define STAT_PARENT_PID_READ_N 64
44

45
static int parse_proc_stat(struct strbuf *sb, struct strbuf *name,
46
			    int *statppid)
47
{
48
	const char *comm_lhs = strchr(sb->buf, '(');
49
	const char *comm_rhs = strrchr(sb->buf, ')');
50
	const char *ppid_lhs, *ppid_rhs;
51
	char *p;
52
	pid_t ppid;
53

54
	if (!comm_lhs || !comm_rhs)
55
		goto bad_kernel;
56

57
	/*
58
	 * We're at the ")", that's followed by " X ", where X is a
59
	 * single "state" character. So advance by 4 bytes.
60
	 */
61
	ppid_lhs = comm_rhs + 4;
62

63
	/*
64
	 * Read until the space between the "ppid" and "pgrp" fields
65
	 * to make sure we're anchored after the untruncated "ppid"
66
	 * field..
67
	 */
68
	ppid_rhs = strchr(ppid_lhs, ' ');
69
	if (!ppid_rhs)
70
		goto bad_kernel;
71

72
	ppid = strtol(ppid_lhs, &p, 10);
73
	if (ppid_rhs == p) {
74
		const char *comm = comm_lhs + 1;
75
		size_t commlen = comm_rhs - comm;
76

77
		strbuf_add(name, comm, commlen);
78
		*statppid = ppid;
79

80
		return 0;
81
	}
82

83
bad_kernel:
84
	/*
85
	 * We were able to read our STAT_PARENT_PID_READ_N bytes from
86
	 * /proc/%d/stat, but the content is bad. Broken kernel?
87
	 * Should not happen, but handle it gracefully.
88
	 */
89
	return -1;
90
}
91

92
static int stat_parent_pid(pid_t pid, struct strbuf *name, int *statppid)
93
{
94
	struct strbuf procfs_path = STRBUF_INIT;
95
	struct strbuf sb = STRBUF_INIT;
96
	FILE *fp;
97
	int ret = -1;
98

99
	/* try to use procfs if it's present. */
100
	strbuf_addf(&procfs_path, "/proc/%d/stat", pid);
101
	fp = fopen(procfs_path.buf, "r");
102
	if (!fp)
103
		goto cleanup;
104

105
	/*
106
	 * We could be more strict here and assert that we read at
107
	 * least STAT_PARENT_PID_READ_N. My reading of procfs(5) is
108
	 * that on any modern kernel (at least since 2.6.0 released in
109
	 * 2003) even if all the mandatory numeric fields were zero'd
110
	 * out we'd get at least 100 bytes, but let's just check that
111
	 * we got anything at all and trust the parse_proc_stat()
112
	 * function to handle its "Bad Kernel?" error checking.
113
	 */
114
	if (!strbuf_fread(&sb, STAT_PARENT_PID_READ_N, fp))
115
		goto cleanup;
116
	if (parse_proc_stat(&sb, name, statppid) < 0)
117
		goto cleanup;
118

119
	ret = 0;
120
cleanup:
121
	if (fp)
122
		fclose(fp);
123
	strbuf_release(&procfs_path);
124
	strbuf_release(&sb);
125

126
	return ret;
127
}
128

129
static void push_ancestry_name(struct strvec *names, pid_t pid)
130
{
131
	struct strbuf name = STRBUF_INIT;
132
	int ppid;
133

134
	if (stat_parent_pid(pid, &name, &ppid) < 0)
135
		goto cleanup;
136

137
	strvec_push(names, name.buf);
138

139
	/*
140
	 * Both errors and reaching the end of the process chain are
141
	 * reported as fields of 0 by proc(5)
142
	 */
143
	if (ppid)
144
		push_ancestry_name(names, ppid);
145
cleanup:
146
	strbuf_release(&name);
147

148
	return;
149
}
150

151
void trace2_collect_process_info(enum trace2_process_info_reason reason)
152
{
153
	struct strvec names = STRVEC_INIT;
154

155
	if (!trace2_is_enabled())
156
		return;
157

158
	switch (reason) {
159
	case TRACE2_PROCESS_INFO_EXIT:
160
		/*
161
		 * The Windows version of this calls its
162
		 * get_peak_memory_info() here. We may want to insert
163
		 * similar process-end statistics here in the future.
164
		 */
165
		break;
166
	case TRACE2_PROCESS_INFO_STARTUP:
167
		push_ancestry_name(&names, getppid());
168

169
		if (names.nr)
170
			trace2_cmd_ancestry(names.v);
171
		strvec_clear(&names);
172
		break;
173
	}
174

175
	return;
176
}
177