~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/config.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp