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