xref: /linux/tools/perf/util/config.c (revision 7577911244c437f4a4abac5e4b67b059c06dbe9d) 
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  * Copyright (C) Johannes Schindelin, 2005
6  *
7  */
8 #include "util.h"
9 #include "cache.h"
10 #include "exec_cmd.h"
11 
12 #define MAXNAME (256)
13 
14 #define DEBUG_CACHE_DIR ".debug"
15 
16 
17 char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */
18 
19 static FILE *config_file;
20 static const char *config_file_name;
21 static int config_linenr;
22 static int config_file_eof;
23 
24 static const char *config_exclusive_filename;
25 
26 static int get_next_char(void)
27 {
28 	int c;
29 	FILE *f;
30 
31 	c = '\n';
32 	if ((f = config_file) != NULL) {
33 		c = fgetc(f);
34 		if (c == '\r') {
35 			/* DOS like systems */
36 			c = fgetc(f);
37 			if (c != '\n') {
38 				ungetc(c, f);
39 				c = '\r';
40 			}
41 		}
42 		if (c == '\n')
43 			config_linenr++;
44 		if (c == EOF) {
45 			config_file_eof = 1;
46 			c = '\n';
47 		}
48 	}
49 	return c;
50 }
51 
52 static char *parse_value(void)
53 {
54 	static char value[1024];
55 	int quote = 0, comment = 0, space = 0;
56 	size_t len = 0;
57 
58 	for (;;) {
59 		int c = get_next_char();
60 
61 		if (len >= sizeof(value) - 1)
62 			return NULL;
63 		if (c == '\n') {
64 			if (quote)
65 				return NULL;
66 			value[len] = 0;
67 			return value;
68 		}
69 		if (comment)
70 			continue;
71 		if (isspace(c) && !quote) {
72 			space = 1;
73 			continue;
74 		}
75 		if (!quote) {
76 			if (c == ';' || c == '#') {
77 				comment = 1;
78 				continue;
79 			}
80 		}
81 		if (space) {
82 			if (len)
83 				value[len++] = ' ';
84 			space = 0;
85 		}
86 		if (c == '\\') {
87 			c = get_next_char();
88 			switch (c) {
89 			case '\n':
90 				continue;
91 			case 't':
92 				c = '\t';
93 				break;
94 			case 'b':
95 				c = '\b';
96 				break;
97 			case 'n':
98 				c = '\n';
99 				break;
100 			/* Some characters escape as themselves */
101 			case '\\': case '"':
102 				break;
103 			/* Reject unknown escape sequences */
104 			default:
105 				return NULL;
106 			}
107 			value[len++] = c;
108 			continue;
109 		}
110 		if (c == '"') {
111 			quote = 1-quote;
112 			continue;
113 		}
114 		value[len++] = c;
115 	}
116 }
117 
118 static inline int iskeychar(int c)
119 {
120 	return isalnum(c) || c == '-';
121 }
122 
123 static int get_value(config_fn_t fn, void *data, char *name, unsigned int len)
124 {
125 	int c;
126 	char *value;
127 
128 	/* Get the full name */
129 	for (;;) {
130 		c = get_next_char();
131 		if (config_file_eof)
132 			break;
133 		if (!iskeychar(c))
134 			break;
135 		name[len++] = c;
136 		if (len >= MAXNAME)
137 			return -1;
138 	}
139 	name[len] = 0;
140 	while (c == ' ' || c == '\t')
141 		c = get_next_char();
142 
143 	value = NULL;
144 	if (c != '\n') {
145 		if (c != '=')
146 			return -1;
147 		value = parse_value();
148 		if (!value)
149 			return -1;
150 	}
151 	return fn(name, value, data);
152 }
153 
154 static int get_extended_base_var(char *name, int baselen, int c)
155 {
156 	do {
157 		if (c == '\n')
158 			return -1;
159 		c = get_next_char();
160 	} while (isspace(c));
161 
162 	/* We require the format to be '[base "extension"]' */
163 	if (c != '"')
164 		return -1;
165 	name[baselen++] = '.';
166 
167 	for (;;) {
168 		int ch = get_next_char();
169 
170 		if (ch == '\n')
171 			return -1;
172 		if (ch == '"')
173 			break;
174 		if (ch == '\\') {
175 			ch = get_next_char();
176 			if (ch == '\n')
177 				return -1;
178 		}
179 		name[baselen++] = ch;
180 		if (baselen > MAXNAME / 2)
181 			return -1;
182 	}
183 
184 	/* Final ']' */
185 	if (get_next_char() != ']')
186 		return -1;
187 	return baselen;
188 }
189 
190 static int get_base_var(char *name)
191 {
192 	int baselen = 0;
193 
194 	for (;;) {
195 		int c = get_next_char();
196 		if (config_file_eof)
197 			return -1;
198 		if (c == ']')
199 			return baselen;
200 		if (isspace(c))
201 			return get_extended_base_var(name, baselen, c);
202 		if (!iskeychar(c) && c != '.')
203 			return -1;
204 		if (baselen > MAXNAME / 2)
205 			return -1;
206 		name[baselen++] = tolower(c);
207 	}
208 }
209 
210 static int perf_parse_file(config_fn_t fn, void *data)
211 {
212 	int comment = 0;
213 	int baselen = 0;
214 	static char var[MAXNAME];
215 
216 	/* U+FEFF Byte Order Mark in UTF8 */
217 	static const unsigned char *utf8_bom = (unsigned char *) "\xef\xbb\xbf";
218 	const unsigned char *bomptr = utf8_bom;
219 
220 	for (;;) {
221 		int c = get_next_char();
222 		if (bomptr && *bomptr) {
223 			/* We are at the file beginning; skip UTF8-encoded BOM
224 			 * if present. Sane editors won't put this in on their
225 			 * own, but e.g. Windows Notepad will do it happily. */
226 			if ((unsigned char) c == *bomptr) {
227 				bomptr++;
228 				continue;
229 			} else {
230 				/* Do not tolerate partial BOM. */
231 				if (bomptr != utf8_bom)
232 					break;
233 				/* No BOM at file beginning. Cool. */
234 				bomptr = NULL;
235 			}
236 		}
237 		if (c == '\n') {
238 			if (config_file_eof)
239 				return 0;
240 			comment = 0;
241 			continue;
242 		}
243 		if (comment || isspace(c))
244 			continue;
245 		if (c == '#' || c == ';') {
246 			comment = 1;
247 			continue;
248 		}
249 		if (c == '[') {
250 			baselen = get_base_var(var);
251 			if (baselen <= 0)
252 				break;
253 			var[baselen++] = '.';
254 			var[baselen] = 0;
255 			continue;
256 		}
257 		if (!isalpha(c))
258 			break;
259 		var[baselen] = tolower(c);
260 		if (get_value(fn, data, var, baselen+1) < 0)
261 			break;
262 	}
263 	die("bad config file line %d in %s", config_linenr, config_file_name);
264 }
265 
266 static int parse_unit_factor(const char *end, unsigned long *val)
267 {
268 	if (!*end)
269 		return 1;
270 	else if (!strcasecmp(end, "k")) {
271 		*val *= 1024;
272 		return 1;
273 	}
274 	else if (!strcasecmp(end, "m")) {
275 		*val *= 1024 * 1024;
276 		return 1;
277 	}
278 	else if (!strcasecmp(end, "g")) {
279 		*val *= 1024 * 1024 * 1024;
280 		return 1;
281 	}
282 	return 0;
283 }
284 
285 static int perf_parse_long(const char *value, long *ret)
286 {
287 	if (value && *value) {
288 		char *end;
289 		long val = strtol(value, &end, 0);
290 		unsigned long factor = 1;
291 		if (!parse_unit_factor(end, &factor))
292 			return 0;
293 		*ret = val * factor;
294 		return 1;
295 	}
296 	return 0;
297 }
298 
299 static void die_bad_config(const char *name)
300 {
301 	if (config_file_name)
302 		die("bad config value for '%s' in %s", name, config_file_name);
303 	die("bad config value for '%s'", name);
304 }
305 
306 int perf_config_int(const char *name, const char *value)
307 {
308 	long ret = 0;
309 	if (!perf_parse_long(value, &ret))
310 		die_bad_config(name);
311 	return ret;
312 }
313 
314 static int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
315 {
316 	*is_bool = 1;
317 	if (!value)
318 		return 1;
319 	if (!*value)
320 		return 0;
321 	if (!strcasecmp(value, "true") || !strcasecmp(value, "yes") || !strcasecmp(value, "on"))
322 		return 1;
323 	if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off"))
324 		return 0;
325 	*is_bool = 0;
326 	return perf_config_int(name, value);
327 }
328 
329 int perf_config_bool(const char *name, const char *value)
330 {
331 	int discard;
332 	return !!perf_config_bool_or_int(name, value, &discard);
333 }
334 
335 const char *perf_config_dirname(const char *name, const char *value)
336 {
337 	if (!name)
338 		return NULL;
339 	return value;
340 }
341 
342 static int perf_default_core_config(const char *var __used, const char *value __used)
343 {
344 	/* Add other config variables here and to Documentation/config.txt. */
345 	return 0;
346 }
347 
348 int perf_default_config(const char *var, const char *value, void *dummy __used)
349 {
350 	if (!prefixcmp(var, "core."))
351 		return perf_default_core_config(var, value);
352 
353 	/* Add other config variables here and to Documentation/config.txt. */
354 	return 0;
355 }
356 
357 static int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
358 {
359 	int ret;
360 	FILE *f = fopen(filename, "r");
361 
362 	ret = -1;
363 	if (f) {
364 		config_file = f;
365 		config_file_name = filename;
366 		config_linenr = 1;
367 		config_file_eof = 0;
368 		ret = perf_parse_file(fn, data);
369 		fclose(f);
370 		config_file_name = NULL;
371 	}
372 	return ret;
373 }
374 
375 static const char *perf_etc_perfconfig(void)
376 {
377 	static const char *system_wide;
378 	if (!system_wide)
379 		system_wide = system_path(ETC_PERFCONFIG);
380 	return system_wide;
381 }
382 
383 static int perf_env_bool(const char *k, int def)
384 {
385 	const char *v = getenv(k);
386 	return v ? perf_config_bool(k, v) : def;
387 }
388 
389 static int perf_config_system(void)
390 {
391 	return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);
392 }
393 
394 static int perf_config_global(void)
395 {
396 	return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
397 }
398 
399 int perf_config(config_fn_t fn, void *data)
400 {
401 	int ret = 0, found = 0;
402 	const char *home = NULL;
403 
404 	/* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
405 	if (config_exclusive_filename)
406 		return perf_config_from_file(fn, config_exclusive_filename, data);
407 	if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {
408 		ret += perf_config_from_file(fn, perf_etc_perfconfig(),
409 					    data);
410 		found += 1;
411 	}
412 
413 	home = getenv("HOME");
414 	if (perf_config_global() && home) {
415 		char *user_config = strdup(mkpath("%s/.perfconfig", home));
416 		struct stat st;
417 
418 		if (user_config == NULL) {
419 			warning("Not enough memory to process %s/.perfconfig, "
420 				"ignoring it.", home);
421 			goto out;
422 		}
423 
424 		if (stat(user_config, &st) < 0)
425 			goto out_free;
426 
427 		if (st.st_uid && (st.st_uid != geteuid())) {
428 			warning("File %s not owned by current user or root, "
429 				"ignoring it.", user_config);
430 			goto out_free;
431 		}
432 
433 		if (!st.st_size)
434 			goto out_free;
435 
436 		ret += perf_config_from_file(fn, user_config, data);
437 		found += 1;
438 out_free:
439 		free(user_config);
440 	}
441 out:
442 	if (found == 0)
443 		return -1;
444 	return ret;
445 }
446 
447 /*
448  * Call this to report error for your variable that should not
449  * get a boolean value (i.e. "[my] var" means "true").
450  */
451 int config_error_nonbool(const char *var)
452 {
453 	return error("Missing value for '%s'", var);
454 }
455 
456 struct buildid_dir_config {
457 	char *dir;
458 };
459 
460 static int buildid_dir_command_config(const char *var, const char *value,
461 				      void *data)
462 {
463 	struct buildid_dir_config *c = data;
464 	const char *v;
465 
466 	/* same dir for all commands */
467 	if (!prefixcmp(var, "buildid.") && !strcmp(var + 8, "dir")) {
468 		v = perf_config_dirname(var, value);
469 		if (!v)
470 			return -1;
471 		strncpy(c->dir, v, MAXPATHLEN-1);
472 		c->dir[MAXPATHLEN-1] = '\0';
473 	}
474 	return 0;
475 }
476 
477 static void check_buildid_dir_config(void)
478 {
479 	struct buildid_dir_config c;
480 	c.dir = buildid_dir;
481 	perf_config(buildid_dir_command_config, &c);
482 }
483 
484 void set_buildid_dir(void)
485 {
486 	buildid_dir[0] = '\0';
487 
488 	/* try config file */
489 	check_buildid_dir_config();
490 
491 	/* default to $HOME/.debug */
492 	if (buildid_dir[0] == '\0') {
493 		char *v = getenv("HOME");
494 		if (v) {
495 			snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s",
496 				 v, DEBUG_CACHE_DIR);
497 		} else {
498 			strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1);
499 		}
500 		buildid_dir[MAXPATHLEN-1] = '\0';
501 	}
502 	/* for communicating with external commands */
503 	setenv("PERF_BUILDID_DIR", buildid_dir, 1);
504 }
505