doc: fix broken references
[linux-3.10.git] / tools / perf / util / config.c
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. */
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. */
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 }