Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
07800601 | 2 | /* |
5f9273d6 NK |
3 | * config.c |
4 | * | |
5 | * Helper functions for parsing config items. | |
6 | * Originally copied from GIT source. | |
07800601 IM |
7 | * |
8 | * Copyright (C) Linus Torvalds, 2005 | |
9 | * Copyright (C) Johannes Schindelin, 2005 | |
10 | * | |
11 | */ | |
a43783ae | 12 | #include <errno.h> |
391e4206 | 13 | #include <sys/param.h> |
07800601 IM |
14 | #include "util.h" |
15 | #include "cache.h" | |
4b6ab94e | 16 | #include <subcmd/exec-cmd.h> |
0b93da17 | 17 | #include "util/hist.h" /* perf_hist_config */ |
aa61fd05 | 18 | #include "util/llvm-utils.h" /* perf_llvm_config */ |
20105ca1 | 19 | #include "config.h" |
7a8ef4c4 ACM |
20 | #include <sys/types.h> |
21 | #include <sys/stat.h> | |
22 | #include <unistd.h> | |
8e99b6d4 | 23 | #include <linux/string.h> |
07800601 | 24 | |
3d689ed6 ACM |
25 | #include "sane_ctype.h" |
26 | ||
07800601 IM |
27 | #define MAXNAME (256) |
28 | ||
45de34bb SE |
29 | #define DEBUG_CACHE_DIR ".debug" |
30 | ||
31 | ||
32 | char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */ | |
33 | ||
07800601 IM |
34 | static FILE *config_file; |
35 | static const char *config_file_name; | |
36 | static int config_linenr; | |
37 | static int config_file_eof; | |
8a0a9c7e | 38 | static struct perf_config_set *config_set; |
07800601 | 39 | |
c7ac2417 | 40 | const char *config_exclusive_filename; |
07800601 IM |
41 | |
42 | static int get_next_char(void) | |
43 | { | |
44 | int c; | |
45 | FILE *f; | |
46 | ||
47 | c = '\n'; | |
48 | if ((f = config_file) != NULL) { | |
49 | c = fgetc(f); | |
50 | if (c == '\r') { | |
51 | /* DOS like systems */ | |
52 | c = fgetc(f); | |
53 | if (c != '\n') { | |
54 | ungetc(c, f); | |
55 | c = '\r'; | |
56 | } | |
57 | } | |
58 | if (c == '\n') | |
59 | config_linenr++; | |
60 | if (c == EOF) { | |
61 | config_file_eof = 1; | |
62 | c = '\n'; | |
63 | } | |
64 | } | |
65 | return c; | |
66 | } | |
67 | ||
68 | static char *parse_value(void) | |
69 | { | |
70 | static char value[1024]; | |
f37a291c IM |
71 | int quote = 0, comment = 0, space = 0; |
72 | size_t len = 0; | |
07800601 IM |
73 | |
74 | for (;;) { | |
75 | int c = get_next_char(); | |
f37a291c | 76 | |
07800601 IM |
77 | if (len >= sizeof(value) - 1) |
78 | return NULL; | |
79 | if (c == '\n') { | |
80 | if (quote) | |
81 | return NULL; | |
82 | value[len] = 0; | |
83 | return value; | |
84 | } | |
85 | if (comment) | |
86 | continue; | |
87 | if (isspace(c) && !quote) { | |
88 | space = 1; | |
89 | continue; | |
90 | } | |
91 | if (!quote) { | |
92 | if (c == ';' || c == '#') { | |
93 | comment = 1; | |
94 | continue; | |
95 | } | |
96 | } | |
97 | if (space) { | |
98 | if (len) | |
99 | value[len++] = ' '; | |
100 | space = 0; | |
101 | } | |
102 | if (c == '\\') { | |
103 | c = get_next_char(); | |
104 | switch (c) { | |
105 | case '\n': | |
106 | continue; | |
107 | case 't': | |
108 | c = '\t'; | |
109 | break; | |
110 | case 'b': | |
111 | c = '\b'; | |
112 | break; | |
113 | case 'n': | |
114 | c = '\n'; | |
115 | break; | |
116 | /* Some characters escape as themselves */ | |
117 | case '\\': case '"': | |
118 | break; | |
119 | /* Reject unknown escape sequences */ | |
120 | default: | |
121 | return NULL; | |
122 | } | |
123 | value[len++] = c; | |
124 | continue; | |
125 | } | |
126 | if (c == '"') { | |
127 | quote = 1-quote; | |
128 | continue; | |
129 | } | |
130 | value[len++] = c; | |
131 | } | |
132 | } | |
133 | ||
134 | static inline int iskeychar(int c) | |
135 | { | |
8dc7c651 | 136 | return isalnum(c) || c == '-' || c == '_'; |
07800601 IM |
137 | } |
138 | ||
139 | static int get_value(config_fn_t fn, void *data, char *name, unsigned int len) | |
140 | { | |
141 | int c; | |
142 | char *value; | |
143 | ||
144 | /* Get the full name */ | |
145 | for (;;) { | |
146 | c = get_next_char(); | |
147 | if (config_file_eof) | |
148 | break; | |
149 | if (!iskeychar(c)) | |
150 | break; | |
45de34bb | 151 | name[len++] = c; |
07800601 IM |
152 | if (len >= MAXNAME) |
153 | return -1; | |
154 | } | |
155 | name[len] = 0; | |
156 | while (c == ' ' || c == '\t') | |
157 | c = get_next_char(); | |
158 | ||
159 | value = NULL; | |
160 | if (c != '\n') { | |
161 | if (c != '=') | |
162 | return -1; | |
163 | value = parse_value(); | |
164 | if (!value) | |
165 | return -1; | |
166 | } | |
167 | return fn(name, value, data); | |
168 | } | |
169 | ||
170 | static int get_extended_base_var(char *name, int baselen, int c) | |
171 | { | |
172 | do { | |
173 | if (c == '\n') | |
174 | return -1; | |
175 | c = get_next_char(); | |
176 | } while (isspace(c)); | |
177 | ||
178 | /* We require the format to be '[base "extension"]' */ | |
179 | if (c != '"') | |
180 | return -1; | |
181 | name[baselen++] = '.'; | |
182 | ||
183 | for (;;) { | |
83a0944f IM |
184 | int ch = get_next_char(); |
185 | ||
186 | if (ch == '\n') | |
07800601 | 187 | return -1; |
83a0944f | 188 | if (ch == '"') |
07800601 | 189 | break; |
83a0944f IM |
190 | if (ch == '\\') { |
191 | ch = get_next_char(); | |
192 | if (ch == '\n') | |
07800601 IM |
193 | return -1; |
194 | } | |
83a0944f | 195 | name[baselen++] = ch; |
07800601 IM |
196 | if (baselen > MAXNAME / 2) |
197 | return -1; | |
198 | } | |
199 | ||
200 | /* Final ']' */ | |
201 | if (get_next_char() != ']') | |
202 | return -1; | |
203 | return baselen; | |
204 | } | |
205 | ||
206 | static int get_base_var(char *name) | |
207 | { | |
208 | int baselen = 0; | |
209 | ||
210 | for (;;) { | |
211 | int c = get_next_char(); | |
212 | if (config_file_eof) | |
213 | return -1; | |
214 | if (c == ']') | |
215 | return baselen; | |
216 | if (isspace(c)) | |
217 | return get_extended_base_var(name, baselen, c); | |
218 | if (!iskeychar(c) && c != '.') | |
219 | return -1; | |
220 | if (baselen > MAXNAME / 2) | |
221 | return -1; | |
222 | name[baselen++] = tolower(c); | |
223 | } | |
224 | } | |
225 | ||
226 | static int perf_parse_file(config_fn_t fn, void *data) | |
227 | { | |
228 | int comment = 0; | |
229 | int baselen = 0; | |
230 | static char var[MAXNAME]; | |
231 | ||
232 | /* U+FEFF Byte Order Mark in UTF8 */ | |
233 | static const unsigned char *utf8_bom = (unsigned char *) "\xef\xbb\xbf"; | |
234 | const unsigned char *bomptr = utf8_bom; | |
235 | ||
236 | for (;;) { | |
49757c9c JO |
237 | int line, c = get_next_char(); |
238 | ||
07800601 IM |
239 | if (bomptr && *bomptr) { |
240 | /* We are at the file beginning; skip UTF8-encoded BOM | |
241 | * if present. Sane editors won't put this in on their | |
242 | * own, but e.g. Windows Notepad will do it happily. */ | |
243 | if ((unsigned char) c == *bomptr) { | |
244 | bomptr++; | |
245 | continue; | |
246 | } else { | |
247 | /* Do not tolerate partial BOM. */ | |
248 | if (bomptr != utf8_bom) | |
249 | break; | |
250 | /* No BOM at file beginning. Cool. */ | |
251 | bomptr = NULL; | |
252 | } | |
253 | } | |
254 | if (c == '\n') { | |
255 | if (config_file_eof) | |
256 | return 0; | |
257 | comment = 0; | |
258 | continue; | |
259 | } | |
260 | if (comment || isspace(c)) | |
261 | continue; | |
262 | if (c == '#' || c == ';') { | |
263 | comment = 1; | |
264 | continue; | |
265 | } | |
266 | if (c == '[') { | |
267 | baselen = get_base_var(var); | |
268 | if (baselen <= 0) | |
269 | break; | |
270 | var[baselen++] = '.'; | |
271 | var[baselen] = 0; | |
272 | continue; | |
273 | } | |
274 | if (!isalpha(c)) | |
275 | break; | |
276 | var[baselen] = tolower(c); | |
49757c9c JO |
277 | |
278 | /* | |
279 | * The get_value function might or might not reach the '\n', | |
280 | * so saving the current line number for error reporting. | |
281 | */ | |
282 | line = config_linenr; | |
283 | if (get_value(fn, data, var, baselen+1) < 0) { | |
284 | config_linenr = line; | |
07800601 | 285 | break; |
49757c9c | 286 | } |
07800601 | 287 | } |
78f71c99 TS |
288 | pr_err("bad config file line %d in %s\n", config_linenr, config_file_name); |
289 | return -1; | |
07800601 IM |
290 | } |
291 | ||
292 | static int parse_unit_factor(const char *end, unsigned long *val) | |
293 | { | |
294 | if (!*end) | |
295 | return 1; | |
296 | else if (!strcasecmp(end, "k")) { | |
297 | *val *= 1024; | |
298 | return 1; | |
299 | } | |
300 | else if (!strcasecmp(end, "m")) { | |
301 | *val *= 1024 * 1024; | |
302 | return 1; | |
303 | } | |
304 | else if (!strcasecmp(end, "g")) { | |
305 | *val *= 1024 * 1024 * 1024; | |
306 | return 1; | |
307 | } | |
308 | return 0; | |
309 | } | |
310 | ||
94c0655f JO |
311 | static int perf_parse_llong(const char *value, long long *ret) |
312 | { | |
313 | if (value && *value) { | |
314 | char *end; | |
315 | long long val = strtoll(value, &end, 0); | |
316 | unsigned long factor = 1; | |
317 | ||
318 | if (!parse_unit_factor(end, &factor)) | |
319 | return 0; | |
320 | *ret = val * factor; | |
321 | return 1; | |
322 | } | |
323 | return 0; | |
324 | } | |
325 | ||
07800601 IM |
326 | static int perf_parse_long(const char *value, long *ret) |
327 | { | |
328 | if (value && *value) { | |
329 | char *end; | |
330 | long val = strtol(value, &end, 0); | |
331 | unsigned long factor = 1; | |
332 | if (!parse_unit_factor(end, &factor)) | |
333 | return 0; | |
334 | *ret = val * factor; | |
335 | return 1; | |
336 | } | |
337 | return 0; | |
338 | } | |
339 | ||
25ce4bb8 | 340 | static void bad_config(const char *name) |
07800601 IM |
341 | { |
342 | if (config_file_name) | |
25ce4bb8 ACM |
343 | pr_warning("bad config value for '%s' in %s, ignoring...\n", name, config_file_name); |
344 | else | |
345 | pr_warning("bad config value for '%s', ignoring...\n", name); | |
07800601 IM |
346 | } |
347 | ||
25ce4bb8 | 348 | int perf_config_u64(u64 *dest, const char *name, const char *value) |
94c0655f JO |
349 | { |
350 | long long ret = 0; | |
351 | ||
25ce4bb8 ACM |
352 | if (!perf_parse_llong(value, &ret)) { |
353 | bad_config(name); | |
354 | return -1; | |
355 | } | |
356 | ||
357 | *dest = ret; | |
358 | return 0; | |
94c0655f JO |
359 | } |
360 | ||
25ce4bb8 | 361 | int perf_config_int(int *dest, const char *name, const char *value) |
07800601 IM |
362 | { |
363 | long ret = 0; | |
25ce4bb8 ACM |
364 | if (!perf_parse_long(value, &ret)) { |
365 | bad_config(name); | |
366 | return -1; | |
367 | } | |
368 | *dest = ret; | |
369 | return 0; | |
07800601 IM |
370 | } |
371 | ||
a41794cd | 372 | static int perf_config_bool_or_int(const char *name, const char *value, int *is_bool) |
07800601 | 373 | { |
25ce4bb8 ACM |
374 | int ret; |
375 | ||
07800601 IM |
376 | *is_bool = 1; |
377 | if (!value) | |
378 | return 1; | |
379 | if (!*value) | |
380 | return 0; | |
381 | if (!strcasecmp(value, "true") || !strcasecmp(value, "yes") || !strcasecmp(value, "on")) | |
382 | return 1; | |
383 | if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off")) | |
384 | return 0; | |
385 | *is_bool = 0; | |
25ce4bb8 | 386 | return perf_config_int(&ret, name, value) < 0 ? -1 : ret; |
07800601 IM |
387 | } |
388 | ||
389 | int perf_config_bool(const char *name, const char *value) | |
390 | { | |
391 | int discard; | |
392 | return !!perf_config_bool_or_int(name, value, &discard); | |
393 | } | |
394 | ||
814b3f51 | 395 | static const char *perf_config_dirname(const char *name, const char *value) |
45de34bb SE |
396 | { |
397 | if (!name) | |
398 | return NULL; | |
399 | return value; | |
400 | } | |
401 | ||
9cb5987c TS |
402 | static int perf_buildid_config(const char *var, const char *value) |
403 | { | |
404 | /* same dir for all commands */ | |
405 | if (!strcmp(var, "buildid.dir")) { | |
d8e28654 | 406 | const char *dir = perf_config_dirname(var, value); |
9cb5987c | 407 | |
ecc4c561 ACM |
408 | if (!dir) { |
409 | pr_err("Invalid buildid directory!\n"); | |
9cb5987c | 410 | return -1; |
ecc4c561 | 411 | } |
d8e28654 | 412 | strncpy(buildid_dir, dir, MAXPATHLEN-1); |
9cb5987c TS |
413 | buildid_dir[MAXPATHLEN-1] = '\0'; |
414 | } | |
415 | ||
416 | return 0; | |
417 | } | |
418 | ||
1d037ca1 IT |
419 | static int perf_default_core_config(const char *var __maybe_unused, |
420 | const char *value __maybe_unused) | |
07800601 | 421 | { |
395cf969 | 422 | /* Add other config variables here. */ |
07800601 IM |
423 | return 0; |
424 | } | |
425 | ||
c8302367 JO |
426 | static int perf_ui_config(const char *var, const char *value) |
427 | { | |
428 | /* Add other config variables here. */ | |
ecc4c561 | 429 | if (!strcmp(var, "ui.show-headers")) |
c8302367 | 430 | symbol_conf.show_hist_headers = perf_config_bool(var, value); |
ecc4c561 | 431 | |
c8302367 JO |
432 | return 0; |
433 | } | |
434 | ||
1d037ca1 IT |
435 | int perf_default_config(const char *var, const char *value, |
436 | void *dummy __maybe_unused) | |
07800601 | 437 | { |
8e99b6d4 | 438 | if (strstarts(var, "core.")) |
07800601 IM |
439 | return perf_default_core_config(var, value); |
440 | ||
8e99b6d4 | 441 | if (strstarts(var, "hist.")) |
0b93da17 NK |
442 | return perf_hist_config(var, value); |
443 | ||
8e99b6d4 | 444 | if (strstarts(var, "ui.")) |
c8302367 JO |
445 | return perf_ui_config(var, value); |
446 | ||
8e99b6d4 | 447 | if (strstarts(var, "call-graph.")) |
2b9240ca NK |
448 | return perf_callchain_config(var, value); |
449 | ||
8e99b6d4 | 450 | if (strstarts(var, "llvm.")) |
aa61fd05 WN |
451 | return perf_llvm_config(var, value); |
452 | ||
8e99b6d4 | 453 | if (strstarts(var, "buildid.")) |
9cb5987c TS |
454 | return perf_buildid_config(var, value); |
455 | ||
395cf969 | 456 | /* Add other config variables here. */ |
07800601 IM |
457 | return 0; |
458 | } | |
459 | ||
a41794cd | 460 | static int perf_config_from_file(config_fn_t fn, const char *filename, void *data) |
07800601 IM |
461 | { |
462 | int ret; | |
463 | FILE *f = fopen(filename, "r"); | |
464 | ||
465 | ret = -1; | |
466 | if (f) { | |
467 | config_file = f; | |
468 | config_file_name = filename; | |
469 | config_linenr = 1; | |
470 | config_file_eof = 0; | |
471 | ret = perf_parse_file(fn, data); | |
472 | fclose(f); | |
473 | config_file_name = NULL; | |
474 | } | |
475 | return ret; | |
476 | } | |
477 | ||
c7ac2417 | 478 | const char *perf_etc_perfconfig(void) |
07800601 IM |
479 | { |
480 | static const char *system_wide; | |
481 | if (!system_wide) | |
482 | system_wide = system_path(ETC_PERFCONFIG); | |
483 | return system_wide; | |
484 | } | |
485 | ||
486 | static int perf_env_bool(const char *k, int def) | |
487 | { | |
488 | const char *v = getenv(k); | |
489 | return v ? perf_config_bool(k, v) : def; | |
490 | } | |
491 | ||
a41794cd | 492 | static int perf_config_system(void) |
07800601 IM |
493 | { |
494 | return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0); | |
495 | } | |
496 | ||
a41794cd | 497 | static int perf_config_global(void) |
07800601 IM |
498 | { |
499 | return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0); | |
500 | } | |
501 | ||
20105ca1 TS |
502 | static struct perf_config_section *find_section(struct list_head *sections, |
503 | const char *section_name) | |
504 | { | |
505 | struct perf_config_section *section; | |
506 | ||
507 | list_for_each_entry(section, sections, node) | |
508 | if (!strcmp(section->name, section_name)) | |
509 | return section; | |
510 | ||
511 | return NULL; | |
512 | } | |
513 | ||
514 | static struct perf_config_item *find_config_item(const char *name, | |
515 | struct perf_config_section *section) | |
516 | { | |
517 | struct perf_config_item *item; | |
518 | ||
519 | list_for_each_entry(item, §ion->items, node) | |
520 | if (!strcmp(item->name, name)) | |
521 | return item; | |
522 | ||
523 | return NULL; | |
524 | } | |
525 | ||
526 | static struct perf_config_section *add_section(struct list_head *sections, | |
527 | const char *section_name) | |
528 | { | |
529 | struct perf_config_section *section = zalloc(sizeof(*section)); | |
530 | ||
531 | if (!section) | |
532 | return NULL; | |
533 | ||
534 | INIT_LIST_HEAD(§ion->items); | |
535 | section->name = strdup(section_name); | |
536 | if (!section->name) { | |
537 | pr_debug("%s: strdup failed\n", __func__); | |
538 | free(section); | |
539 | return NULL; | |
540 | } | |
541 | ||
542 | list_add_tail(§ion->node, sections); | |
543 | return section; | |
544 | } | |
545 | ||
546 | static struct perf_config_item *add_config_item(struct perf_config_section *section, | |
547 | const char *name) | |
548 | { | |
549 | struct perf_config_item *item = zalloc(sizeof(*item)); | |
550 | ||
551 | if (!item) | |
552 | return NULL; | |
553 | ||
554 | item->name = strdup(name); | |
555 | if (!item->name) { | |
556 | pr_debug("%s: strdup failed\n", __func__); | |
557 | free(item); | |
558 | return NULL; | |
559 | } | |
560 | ||
561 | list_add_tail(&item->node, §ion->items); | |
562 | return item; | |
563 | } | |
564 | ||
565 | static int set_value(struct perf_config_item *item, const char *value) | |
566 | { | |
567 | char *val = strdup(value); | |
568 | ||
569 | if (!val) | |
570 | return -1; | |
571 | ||
572 | zfree(&item->value); | |
573 | item->value = val; | |
574 | return 0; | |
575 | } | |
576 | ||
577 | static int collect_config(const char *var, const char *value, | |
578 | void *perf_config_set) | |
579 | { | |
580 | int ret = -1; | |
581 | char *ptr, *key; | |
582 | char *section_name, *name; | |
583 | struct perf_config_section *section = NULL; | |
584 | struct perf_config_item *item = NULL; | |
585 | struct perf_config_set *set = perf_config_set; | |
7db91f25 | 586 | struct list_head *sections; |
20105ca1 | 587 | |
7db91f25 TS |
588 | if (set == NULL) |
589 | return -1; | |
590 | ||
591 | sections = &set->sections; | |
20105ca1 TS |
592 | key = ptr = strdup(var); |
593 | if (!key) { | |
594 | pr_debug("%s: strdup failed\n", __func__); | |
595 | return -1; | |
596 | } | |
597 | ||
598 | section_name = strsep(&ptr, "."); | |
599 | name = ptr; | |
600 | if (name == NULL || value == NULL) | |
601 | goto out_free; | |
602 | ||
603 | section = find_section(sections, section_name); | |
604 | if (!section) { | |
605 | section = add_section(sections, section_name); | |
606 | if (!section) | |
607 | goto out_free; | |
608 | } | |
609 | ||
610 | item = find_config_item(name, section); | |
611 | if (!item) { | |
612 | item = add_config_item(section, name); | |
613 | if (!item) | |
614 | goto out_free; | |
615 | } | |
616 | ||
08d090cf TS |
617 | /* perf_config_set can contain both user and system config items. |
618 | * So we should know where each value is from. | |
619 | * The classification would be needed when a particular config file | |
620 | * is overwrited by setting feature i.e. set_config(). | |
621 | */ | |
622 | if (strcmp(config_file_name, perf_etc_perfconfig()) == 0) { | |
623 | section->from_system_config = true; | |
624 | item->from_system_config = true; | |
625 | } else { | |
626 | section->from_system_config = false; | |
627 | item->from_system_config = false; | |
628 | } | |
629 | ||
20105ca1 TS |
630 | ret = set_value(item, value); |
631 | return ret; | |
632 | ||
633 | out_free: | |
634 | free(key); | |
20105ca1 TS |
635 | return -1; |
636 | } | |
637 | ||
08d090cf | 638 | int perf_config_set__collect(struct perf_config_set *set, const char *file_name, |
c6fc018a TS |
639 | const char *var, const char *value) |
640 | { | |
08d090cf | 641 | config_file_name = file_name; |
c6fc018a TS |
642 | return collect_config(var, value, set); |
643 | } | |
644 | ||
8beeb00f TS |
645 | static int perf_config_set__init(struct perf_config_set *set) |
646 | { | |
647 | int ret = -1; | |
648 | const char *home = NULL; | |
3e00cbe8 JO |
649 | char *user_config; |
650 | struct stat st; | |
8beeb00f TS |
651 | |
652 | /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */ | |
653 | if (config_exclusive_filename) | |
654 | return perf_config_from_file(collect_config, config_exclusive_filename, set); | |
655 | if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) { | |
656 | if (perf_config_from_file(collect_config, perf_etc_perfconfig(), set) < 0) | |
657 | goto out; | |
658 | } | |
659 | ||
660 | home = getenv("HOME"); | |
8beeb00f | 661 | |
3e00cbe8 JO |
662 | /* |
663 | * Skip reading user config if: | |
664 | * - there is no place to read it from (HOME) | |
665 | * - we are asked not to (PERF_CONFIG_NOGLOBAL=1) | |
666 | */ | |
667 | if (!home || !*home || !perf_config_global()) | |
668 | return 0; | |
8beeb00f | 669 | |
3e00cbe8 JO |
670 | user_config = strdup(mkpath("%s/.perfconfig", home)); |
671 | if (user_config == NULL) { | |
4cf134e7 | 672 | pr_warning("Not enough memory to process %s/.perfconfig, ignoring it.", home); |
3e00cbe8 JO |
673 | goto out; |
674 | } | |
675 | ||
676 | if (stat(user_config, &st) < 0) { | |
677 | if (errno == ENOENT) | |
678 | ret = 0; | |
679 | goto out_free; | |
680 | } | |
afc45cf5 | 681 | |
3e00cbe8 | 682 | ret = 0; |
8beeb00f | 683 | |
3e00cbe8 | 684 | if (st.st_uid && (st.st_uid != geteuid())) { |
4cf134e7 | 685 | pr_warning("File %s not owned by current user or root, ignoring it.", user_config); |
3e00cbe8 JO |
686 | goto out_free; |
687 | } | |
688 | ||
689 | if (st.st_size) | |
690 | ret = perf_config_from_file(collect_config, user_config, set); | |
8beeb00f | 691 | |
8beeb00f | 692 | out_free: |
3e00cbe8 | 693 | free(user_config); |
8beeb00f TS |
694 | out: |
695 | return ret; | |
696 | } | |
697 | ||
20105ca1 TS |
698 | struct perf_config_set *perf_config_set__new(void) |
699 | { | |
700 | struct perf_config_set *set = zalloc(sizeof(*set)); | |
701 | ||
702 | if (set) { | |
703 | INIT_LIST_HEAD(&set->sections); | |
8beeb00f | 704 | if (perf_config_set__init(set) < 0) { |
25d8f48f TS |
705 | perf_config_set__delete(set); |
706 | set = NULL; | |
707 | } | |
20105ca1 TS |
708 | } |
709 | ||
710 | return set; | |
711 | } | |
712 | ||
8a0a9c7e TS |
713 | int perf_config(config_fn_t fn, void *data) |
714 | { | |
715 | int ret = 0; | |
716 | char key[BUFSIZ]; | |
717 | struct perf_config_section *section; | |
718 | struct perf_config_item *item; | |
719 | ||
720 | if (config_set == NULL) | |
721 | return -1; | |
722 | ||
723 | perf_config_set__for_each_entry(config_set, section, item) { | |
724 | char *value = item->value; | |
725 | ||
726 | if (value) { | |
727 | scnprintf(key, sizeof(key), "%s.%s", | |
728 | section->name, item->name); | |
729 | ret = fn(key, value, data); | |
730 | if (ret < 0) { | |
731 | pr_err("Error: wrong config key-value pair %s=%s\n", | |
732 | key, value); | |
733 | break; | |
734 | } | |
735 | } | |
736 | } | |
737 | ||
738 | return ret; | |
739 | } | |
740 | ||
741 | void perf_config__init(void) | |
742 | { | |
743 | if (config_set == NULL) | |
744 | config_set = perf_config_set__new(); | |
745 | } | |
746 | ||
747 | void perf_config__exit(void) | |
748 | { | |
749 | perf_config_set__delete(config_set); | |
750 | config_set = NULL; | |
751 | } | |
752 | ||
753 | void perf_config__refresh(void) | |
754 | { | |
755 | perf_config__exit(); | |
756 | perf_config__init(); | |
757 | } | |
758 | ||
20105ca1 TS |
759 | static void perf_config_item__delete(struct perf_config_item *item) |
760 | { | |
761 | zfree(&item->name); | |
762 | zfree(&item->value); | |
763 | free(item); | |
764 | } | |
765 | ||
766 | static void perf_config_section__purge(struct perf_config_section *section) | |
767 | { | |
768 | struct perf_config_item *item, *tmp; | |
769 | ||
770 | list_for_each_entry_safe(item, tmp, §ion->items, node) { | |
771 | list_del_init(&item->node); | |
772 | perf_config_item__delete(item); | |
773 | } | |
774 | } | |
775 | ||
776 | static void perf_config_section__delete(struct perf_config_section *section) | |
777 | { | |
778 | perf_config_section__purge(section); | |
779 | zfree(§ion->name); | |
780 | free(section); | |
781 | } | |
782 | ||
783 | static void perf_config_set__purge(struct perf_config_set *set) | |
784 | { | |
785 | struct perf_config_section *section, *tmp; | |
786 | ||
787 | list_for_each_entry_safe(section, tmp, &set->sections, node) { | |
788 | list_del_init(§ion->node); | |
789 | perf_config_section__delete(section); | |
790 | } | |
791 | } | |
792 | ||
793 | void perf_config_set__delete(struct perf_config_set *set) | |
794 | { | |
826424cc TS |
795 | if (set == NULL) |
796 | return; | |
797 | ||
20105ca1 TS |
798 | perf_config_set__purge(set); |
799 | free(set); | |
800 | } | |
801 | ||
07800601 IM |
802 | /* |
803 | * Call this to report error for your variable that should not | |
804 | * get a boolean value (i.e. "[my] var" means "true"). | |
805 | */ | |
806 | int config_error_nonbool(const char *var) | |
807 | { | |
62d94b00 ACM |
808 | pr_err("Missing value for '%s'", var); |
809 | return -1; | |
07800601 | 810 | } |
45de34bb | 811 | |
99ce8e9f | 812 | void set_buildid_dir(const char *dir) |
45de34bb | 813 | { |
99ce8e9f JO |
814 | if (dir) |
815 | scnprintf(buildid_dir, MAXPATHLEN-1, "%s", dir); | |
45de34bb | 816 | |
45de34bb SE |
817 | /* default to $HOME/.debug */ |
818 | if (buildid_dir[0] == '\0') { | |
37194f44 TS |
819 | char *home = getenv("HOME"); |
820 | ||
821 | if (home) { | |
45de34bb | 822 | snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s", |
37194f44 | 823 | home, DEBUG_CACHE_DIR); |
45de34bb SE |
824 | } else { |
825 | strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1); | |
826 | } | |
827 | buildid_dir[MAXPATHLEN-1] = '\0'; | |
828 | } | |
829 | /* for communicating with external commands */ | |
830 | setenv("PERF_BUILDID_DIR", buildid_dir, 1); | |
831 | } |