1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
4 */
5
6#include <sys/mman.h>
7#include <sys/stat.h>
8#include <sys/types.h>
9#include <ctype.h>
10#include <errno.h>
11#include <fcntl.h>
12#include <limits.h>
13#include <stdarg.h>
14#include <stdbool.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18#include <time.h>
19#include <unistd.h>
20
21#include <xalloc.h>
22#include "internal.h"
23#include "lkc.h"
24
25struct gstr autoconf_cmd;
26
27/* return true if 'path' exists, false otherwise */
28static bool is_present(const char *path)
29{
30 struct stat st;
31
32 return !stat(file: path, buf: &st);
33}
34
35/* return true if 'path' exists and it is a directory, false otherwise */
36static bool is_dir(const char *path)
37{
38 struct stat st;
39
40 if (stat(file: path, buf: &st))
41 return false;
42
43 return S_ISDIR(st.st_mode);
44}
45
46/* return true if the given two files are the same, false otherwise */
47static bool is_same(const char *file1, const char *file2)
48{
49 int fd1, fd2;
50 struct stat st1, st2;
51 void *map1, *map2;
52 bool ret = false;
53
54 fd1 = open(file: file1, O_RDONLY);
55 if (fd1 < 0)
56 return ret;
57
58 fd2 = open(file: file2, O_RDONLY);
59 if (fd2 < 0)
60 goto close1;
61
62 ret = fstat(fd: fd1, buf: &st1);
63 if (ret)
64 goto close2;
65 ret = fstat(fd: fd2, buf: &st2);
66 if (ret)
67 goto close2;
68
69 if (st1.st_size != st2.st_size)
70 goto close2;
71
72 map1 = mmap(NULL, len: st1.st_size, PROT_READ, MAP_PRIVATE, fd: fd1, offset: 0);
73 if (map1 == MAP_FAILED)
74 goto close2;
75
76 map2 = mmap(NULL, len: st2.st_size, PROT_READ, MAP_PRIVATE, fd: fd2, offset: 0);
77 if (map2 == MAP_FAILED)
78 goto close2;
79
80 if (memcmp(s1: map1, s2: map2, n: st1.st_size))
81 goto close2;
82
83 ret = true;
84close2:
85 close(fd: fd2);
86close1:
87 close(fd: fd1);
88
89 return ret;
90}
91
92/*
93 * Create the parent directory of the given path.
94 *
95 * For example, if 'include/config/auto.conf' is given, create 'include/config'.
96 */
97static int make_parent_dir(const char *path)
98{
99 char tmp[PATH_MAX + 1];
100 char *p;
101
102 strncpy(dest: tmp, src: path, n: sizeof(tmp));
103 tmp[sizeof(tmp) - 1] = 0;
104
105 /* Remove the base name. Just return if nothing is left */
106 p = strrchr(s: tmp, c: '/');
107 if (!p)
108 return 0;
109 *(p + 1) = 0;
110
111 /* Just in case it is an absolute path */
112 p = tmp;
113 while (*p == '/')
114 p++;
115
116 while ((p = strchr(s: p, c: '/'))) {
117 *p = 0;
118
119 /* skip if the directory exists */
120 if (!is_dir(path: tmp) && mkdir(path: tmp, mode: 0755))
121 return -1;
122
123 *p = '/';
124 while (*p == '/')
125 p++;
126 }
127
128 return 0;
129}
130
131static char depfile_path[PATH_MAX];
132static size_t depfile_prefix_len;
133
134/* touch depfile for symbol 'name' */
135static int conf_touch_dep(const char *name)
136{
137 int fd;
138
139 /* check overflow: prefix + name + '\0' must fit in buffer. */
140 if (depfile_prefix_len + strlen(s: name) + 1 > sizeof(depfile_path))
141 return -1;
142
143 strcpy(dest: depfile_path + depfile_prefix_len, src: name);
144
145 fd = open(file: depfile_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
146 if (fd == -1)
147 return -1;
148 close(fd: fd);
149
150 return 0;
151}
152
153static void conf_warning(const char *fmt, ...)
154 __attribute__ ((format (printf, 1, 2)));
155
156static void conf_message(const char *fmt, ...)
157 __attribute__ ((format (printf, 1, 2)));
158
159static const char *conf_filename;
160static int conf_lineno, conf_warnings;
161
162bool conf_errors(void)
163{
164 if (conf_warnings)
165 return getenv(name: "KCONFIG_WERROR");
166 return false;
167}
168
169static void conf_warning(const char *fmt, ...)
170{
171 va_list ap;
172 va_start(ap, fmt);
173 fprintf(stderr, format: "%s:%d:warning: ", conf_filename, conf_lineno);
174 vfprintf(stderr, format: fmt, arg: ap);
175 fprintf(stderr, format: "\n");
176 va_end(ap);
177 conf_warnings++;
178}
179
180static void conf_default_message_callback(const char *s)
181{
182 printf(format: "#\n# ");
183 printf(format: "%s", s);
184 printf(format: "\n#\n");
185}
186
187static void (*conf_message_callback)(const char *s) =
188 conf_default_message_callback;
189void conf_set_message_callback(void (*fn)(const char *s))
190{
191 conf_message_callback = fn;
192}
193
194static void conf_message(const char *fmt, ...)
195{
196 va_list ap;
197 char buf[4096];
198
199 if (!conf_message_callback)
200 return;
201
202 va_start(ap, fmt);
203
204 vsnprintf(s: buf, maxlen: sizeof(buf), format: fmt, arg: ap);
205 conf_message_callback(buf);
206 va_end(ap);
207}
208
209const char *conf_get_configname(void)
210{
211 char *name = getenv(name: "KCONFIG_CONFIG");
212
213 return name ? name : ".config";
214}
215
216static const char *conf_get_autoconfig_name(void)
217{
218 char *name = getenv(name: "KCONFIG_AUTOCONFIG");
219
220 return name ? name : "include/config/auto.conf";
221}
222
223static const char *conf_get_autoheader_name(void)
224{
225 char *name = getenv(name: "KCONFIG_AUTOHEADER");
226
227 return name ? name : "include/generated/autoconf.h";
228}
229
230static const char *conf_get_rustccfg_name(void)
231{
232 char *name = getenv(name: "KCONFIG_RUSTCCFG");
233
234 return name ? name : "include/generated/rustc_cfg";
235}
236
237static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
238{
239 char *p2;
240
241 switch (sym->type) {
242 case S_TRISTATE:
243 if (p[0] == 'm') {
244 sym->def[def].tri = mod;
245 sym->flags |= def_flags;
246 break;
247 }
248 /* fall through */
249 case S_BOOLEAN:
250 if (p[0] == 'y') {
251 sym->def[def].tri = yes;
252 sym->flags |= def_flags;
253 break;
254 }
255 if (p[0] == 'n') {
256 sym->def[def].tri = no;
257 sym->flags |= def_flags;
258 break;
259 }
260 if (def != S_DEF_AUTO)
261 conf_warning(fmt: "symbol value '%s' invalid for %s",
262 p, sym->name);
263 return 1;
264 case S_STRING:
265 /* No escaping for S_DEF_AUTO (include/config/auto.conf) */
266 if (def != S_DEF_AUTO) {
267 if (*p++ != '"')
268 break;
269 for (p2 = p; (p2 = strpbrk(s: p2, accept: "\"\\")); p2++) {
270 if (*p2 == '"') {
271 *p2 = 0;
272 break;
273 }
274 memmove(dest: p2, src: p2 + 1, n: strlen(s: p2));
275 }
276 if (!p2) {
277 conf_warning(fmt: "invalid string found");
278 return 1;
279 }
280 }
281 /* fall through */
282 case S_INT:
283 case S_HEX:
284 if (sym_string_valid(sym, newval: p)) {
285 sym->def[def].val = xstrdup(p);
286 sym->flags |= def_flags;
287 } else {
288 if (def != S_DEF_AUTO)
289 conf_warning(fmt: "symbol value '%s' invalid for %s",
290 p, sym->name);
291 return 1;
292 }
293 break;
294 default:
295 ;
296 }
297 return 0;
298}
299
300/* like getline(), but the newline character is stripped away */
301static ssize_t getline_stripped(char **lineptr, size_t *n, FILE *stream)
302{
303 ssize_t len;
304
305 len = getline(lineptr: lineptr, n: n, stream: stream);
306
307 if (len > 0 && (*lineptr)[len - 1] == '\n') {
308 len--;
309 (*lineptr)[len] = '\0';
310
311 if (len > 0 && (*lineptr)[len - 1] == '\r') {
312 len--;
313 (*lineptr)[len] = '\0';
314 }
315 }
316
317 return len;
318}
319
320int conf_read_simple(const char *name, int def)
321{
322 FILE *in = NULL;
323 char *line = NULL;
324 size_t line_asize = 0;
325 char *p, *val;
326 struct symbol *sym;
327 int def_flags;
328 const char *warn_unknown, *sym_name;
329
330 warn_unknown = getenv(name: "KCONFIG_WARN_UNKNOWN_SYMBOLS");
331 if (name) {
332 in = zconf_fopen(name);
333 } else {
334 char *env;
335
336 name = conf_get_configname();
337 in = zconf_fopen(name);
338 if (in)
339 goto load;
340 conf_set_changed(true);
341
342 env = getenv(name: "KCONFIG_DEFCONFIG_LIST");
343 if (!env)
344 return 1;
345
346 while (1) {
347 bool is_last;
348
349 while (isspace(*env))
350 env++;
351
352 if (!*env)
353 break;
354
355 p = env;
356 while (*p && !isspace(*p))
357 p++;
358
359 is_last = (*p == '\0');
360
361 *p = '\0';
362
363 name = env;
364
365 in = zconf_fopen(name);
366 if (in) {
367 conf_message(fmt: "using defaults found in %s",
368 name);
369 goto load;
370 }
371
372 if (is_last)
373 break;
374
375 env = p + 1;
376 }
377 }
378 if (!in)
379 return 1;
380
381load:
382 conf_filename = name;
383 conf_lineno = 0;
384 conf_warnings = 0;
385
386 def_flags = SYMBOL_DEF << def;
387 for_all_symbols(sym) {
388 sym->flags &= ~def_flags;
389 switch (sym->type) {
390 case S_INT:
391 case S_HEX:
392 case S_STRING:
393 free(ptr: sym->def[def].val);
394 /* fall through */
395 default:
396 sym->def[def].val = NULL;
397 sym->def[def].tri = no;
398 }
399 }
400
401 if (def == S_DEF_USER) {
402 for_all_symbols(sym)
403 sym->flags &= ~SYMBOL_VALID;
404 expr_invalidate_all();
405 }
406
407 while (getline_stripped(lineptr: &line, n: &line_asize, stream: in) != -1) {
408 struct menu *choice;
409
410 conf_lineno++;
411
412 if (!line[0]) /* blank line */
413 continue;
414
415 if (line[0] == '#') {
416 if (line[1] != ' ')
417 continue;
418 p = line + 2;
419 if (memcmp(s1: p, CONFIG_, n: strlen(CONFIG_)))
420 continue;
421 sym_name = p + strlen(CONFIG_);
422 p = strchr(s: sym_name, c: ' ');
423 if (!p)
424 continue;
425 *p++ = 0;
426 if (strcmp(s1: p, s2: "is not set"))
427 continue;
428
429 val = "n";
430 } else {
431 if (memcmp(s1: line, CONFIG_, n: strlen(CONFIG_))) {
432 conf_warning(fmt: "unexpected data: %s", line);
433 continue;
434 }
435
436 sym_name = line + strlen(CONFIG_);
437 p = strchr(s: sym_name, c: '=');
438 if (!p) {
439 conf_warning(fmt: "unexpected data: %s", line);
440 continue;
441 }
442 *p = 0;
443 val = p + 1;
444 }
445
446 sym = sym_find(name: sym_name);
447 if (!sym) {
448 if (def == S_DEF_AUTO) {
449 /*
450 * Reading from include/config/auto.conf.
451 * If CONFIG_FOO previously existed in auto.conf
452 * but it is missing now, include/config/FOO
453 * must be touched.
454 */
455 conf_touch_dep(name: sym_name);
456 } else {
457 if (warn_unknown)
458 conf_warning(fmt: "unknown symbol: %s", sym_name);
459
460 conf_set_changed(true);
461 }
462 continue;
463 }
464
465 if (sym->flags & def_flags)
466 conf_warning(fmt: "override: reassigning to symbol %s", sym->name);
467
468 if (conf_set_sym_val(sym, def, def_flags, p: val))
469 continue;
470
471 if (def != S_DEF_USER)
472 continue;
473
474 /*
475 * If this is a choice member, give it the highest priority.
476 * If conflicting CONFIG options are given from an input file,
477 * the last one wins.
478 */
479 choice = sym_get_choice_menu(sym);
480 if (choice)
481 list_move(&sym->choice_link, &choice->choice_members);
482 }
483 free(ptr: line);
484 fclose(stream: in);
485
486 return 0;
487}
488
489int conf_read(const char *name)
490{
491 struct symbol *sym;
492
493 conf_set_changed(false);
494
495 if (conf_read_simple(name, def: S_DEF_USER)) {
496 sym_calc_value(sym: modules_sym);
497 return 1;
498 }
499
500 sym_calc_value(sym: modules_sym);
501
502 for_all_symbols(sym) {
503 sym_calc_value(sym);
504 if (sym_is_choice(sym))
505 continue;
506 if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
507 /* check that calculated value agrees with saved value */
508 switch (sym->type) {
509 case S_BOOLEAN:
510 case S_TRISTATE:
511 if (sym->def[S_DEF_USER].tri == sym_get_tristate_value(sym))
512 continue;
513 break;
514 default:
515 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
516 continue;
517 break;
518 }
519 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
520 /* no previous value and not saved */
521 continue;
522 conf_set_changed(true);
523 /* maybe print value in verbose mode... */
524 }
525
526 if (conf_warnings)
527 conf_set_changed(true);
528
529 return 0;
530}
531
532struct comment_style {
533 const char *decoration;
534 const char *prefix;
535 const char *postfix;
536};
537
538static const struct comment_style comment_style_pound = {
539 .decoration = "#",
540 .prefix = "#",
541 .postfix = "#",
542};
543
544static const struct comment_style comment_style_c = {
545 .decoration = " *",
546 .prefix = "/*",
547 .postfix = " */",
548};
549
550static void conf_write_heading(FILE *fp, const struct comment_style *cs)
551{
552 if (!cs)
553 return;
554
555 fprintf(stream: fp, format: "%s\n", cs->prefix);
556
557 fprintf(stream: fp, format: "%s Automatically generated file; DO NOT EDIT.\n",
558 cs->decoration);
559
560 fprintf(stream: fp, format: "%s %s\n", cs->decoration, rootmenu.prompt->text);
561
562 fprintf(stream: fp, format: "%s\n", cs->postfix);
563}
564
565/* The returned pointer must be freed on the caller side */
566static char *escape_string_value(const char *in)
567{
568 const char *p;
569 char *out;
570 size_t len;
571
572 len = strlen(s: in) + strlen(s: "\"\"") + 1;
573
574 p = in;
575 while (1) {
576 p += strcspn(s: p, reject: "\"\\");
577
578 if (p[0] == '\0')
579 break;
580
581 len++;
582 p++;
583 }
584
585 out = xmalloc(len);
586 out[0] = '\0';
587
588 strcat(dest: out, src: "\"");
589
590 p = in;
591 while (1) {
592 len = strcspn(s: p, reject: "\"\\");
593 strncat(dest: out, src: p, n: len);
594 p += len;
595
596 if (p[0] == '\0')
597 break;
598
599 strcat(dest: out, src: "\\");
600 strncat(dest: out, src: p++, n: 1);
601 }
602
603 strcat(dest: out, src: "\"");
604
605 return out;
606}
607
608enum output_n { OUTPUT_N, OUTPUT_N_AS_UNSET, OUTPUT_N_NONE };
609
610static void __print_symbol(FILE *fp, struct symbol *sym, enum output_n output_n,
611 bool escape_string)
612{
613 const char *val;
614 char *escaped = NULL;
615
616 if (sym->type == S_UNKNOWN)
617 return;
618
619 val = sym_get_string_value(sym);
620
621 if ((sym->type == S_BOOLEAN || sym->type == S_TRISTATE) &&
622 output_n != OUTPUT_N && *val == 'n') {
623 if (output_n == OUTPUT_N_AS_UNSET)
624 fprintf(stream: fp, format: "# %s%s is not set\n", CONFIG_, sym->name);
625 return;
626 }
627
628 if (sym->type == S_STRING && escape_string) {
629 escaped = escape_string_value(in: val);
630 val = escaped;
631 }
632
633 fprintf(stream: fp, format: "%s%s=%s\n", CONFIG_, sym->name, val);
634
635 free(ptr: escaped);
636}
637
638static void print_symbol_for_dotconfig(FILE *fp, struct symbol *sym)
639{
640 __print_symbol(fp, sym, output_n: OUTPUT_N_AS_UNSET, true);
641}
642
643static void print_symbol_for_autoconf(FILE *fp, struct symbol *sym)
644{
645 __print_symbol(fp, sym, output_n: OUTPUT_N_NONE, false);
646}
647
648void print_symbol_for_listconfig(struct symbol *sym)
649{
650 __print_symbol(stdout, sym, output_n: OUTPUT_N, true);
651}
652
653static void print_symbol_for_c(FILE *fp, struct symbol *sym)
654{
655 const char *val;
656 const char *sym_suffix = "";
657 const char *val_prefix = "";
658 char *escaped = NULL;
659
660 if (sym->type == S_UNKNOWN)
661 return;
662
663 val = sym_get_string_value(sym);
664
665 switch (sym->type) {
666 case S_BOOLEAN:
667 case S_TRISTATE:
668 switch (*val) {
669 case 'n':
670 return;
671 case 'm':
672 sym_suffix = "_MODULE";
673 /* fall through */
674 default:
675 val = "1";
676 }
677 break;
678 case S_HEX:
679 if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X'))
680 val_prefix = "0x";
681 break;
682 case S_STRING:
683 escaped = escape_string_value(in: val);
684 val = escaped;
685 default:
686 break;
687 }
688
689 fprintf(stream: fp, format: "#define %s%s%s %s%s\n", CONFIG_, sym->name, sym_suffix,
690 val_prefix, val);
691
692 free(ptr: escaped);
693}
694
695static void print_symbol_for_rustccfg(FILE *fp, struct symbol *sym)
696{
697 const char *val;
698 const char *val_prefix = "";
699 char *val_prefixed = NULL;
700 size_t val_prefixed_len;
701 char *escaped = NULL;
702
703 if (sym->type == S_UNKNOWN)
704 return;
705
706 val = sym_get_string_value(sym);
707
708 switch (sym->type) {
709 case S_BOOLEAN:
710 case S_TRISTATE:
711 /*
712 * We do not care about disabled ones, i.e. no need for
713 * what otherwise are "comments" in other printers.
714 */
715 if (*val == 'n')
716 return;
717
718 /*
719 * To have similar functionality to the C macro `IS_ENABLED()`
720 * we provide an empty `--cfg CONFIG_X` here in both `y`
721 * and `m` cases.
722 *
723 * Then, the common `fprintf()` below will also give us
724 * a `--cfg CONFIG_X="y"` or `--cfg CONFIG_X="m"`, which can
725 * be used as the equivalent of `IS_BUILTIN()`/`IS_MODULE()`.
726 */
727 fprintf(stream: fp, format: "--cfg=%s%s\n", CONFIG_, sym->name);
728 break;
729 case S_HEX:
730 if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X'))
731 val_prefix = "0x";
732 break;
733 default:
734 break;
735 }
736
737 if (strlen(s: val_prefix) > 0) {
738 val_prefixed_len = strlen(s: val) + strlen(s: val_prefix) + 1;
739 val_prefixed = xmalloc(val_prefixed_len);
740 snprintf(s: val_prefixed, maxlen: val_prefixed_len, format: "%s%s", val_prefix, val);
741 val = val_prefixed;
742 }
743
744 /* All values get escaped: the `--cfg` option only takes strings */
745 escaped = escape_string_value(in: val);
746 val = escaped;
747
748 fprintf(stream: fp, format: "--cfg=%s%s=%s\n", CONFIG_, sym->name, val);
749
750 free(ptr: escaped);
751 free(ptr: val_prefixed);
752}
753
754/*
755 * Write out a minimal config.
756 * All values that has default values are skipped as this is redundant.
757 */
758int conf_write_defconfig(const char *filename)
759{
760 struct symbol *sym;
761 struct menu *menu;
762 FILE *out;
763
764 out = fopen(filename: filename, modes: "w");
765 if (!out)
766 return 1;
767
768 sym_clear_all_valid();
769
770 menu_for_each_entry(menu) {
771 struct menu *choice;
772
773 sym = menu->sym;
774
775 if (!sym || sym_is_choice(sym))
776 continue;
777
778 sym_calc_value(sym);
779 if (!(sym->flags & SYMBOL_WRITE))
780 continue;
781 sym->flags &= ~SYMBOL_WRITE;
782 /* Skip unchangeable symbols */
783 if (!sym_is_changeable(sym))
784 continue;
785 /* Skip symbols that are equal to the default */
786 if (!strcmp(s1: sym_get_string_value(sym), s2: sym_get_string_default(sym)))
787 continue;
788
789 /* Skip choice values that are equal to the default */
790 choice = sym_get_choice_menu(sym);
791 if (choice) {
792 struct symbol *ds;
793
794 ds = sym_choice_default(choice);
795 if (sym == ds && sym_get_tristate_value(sym) == yes)
796 continue;
797 }
798 print_symbol_for_dotconfig(fp: out, sym);
799 }
800 fclose(stream: out);
801 return 0;
802}
803
804int conf_write(const char *name)
805{
806 FILE *out;
807 struct symbol *sym;
808 struct menu *menu;
809 const char *str;
810 char tmpname[PATH_MAX + 1], oldname[PATH_MAX + 1];
811 char *env;
812 bool need_newline = false;
813
814 if (!name)
815 name = conf_get_configname();
816
817 if (!*name) {
818 fprintf(stderr, format: "config name is empty\n");
819 return -1;
820 }
821
822 if (is_dir(path: name)) {
823 fprintf(stderr, format: "%s: Is a directory\n", name);
824 return -1;
825 }
826
827 if (make_parent_dir(path: name))
828 return -1;
829
830 env = getenv(name: "KCONFIG_OVERWRITECONFIG");
831 if (env && *env) {
832 *tmpname = 0;
833 out = fopen(filename: name, modes: "w");
834 } else {
835 snprintf(s: tmpname, maxlen: sizeof(tmpname), format: "%s.%d.tmp",
836 name, (int)getpid());
837 out = fopen(filename: tmpname, modes: "w");
838 }
839 if (!out)
840 return 1;
841
842 conf_write_heading(fp: out, cs: &comment_style_pound);
843
844 if (!conf_get_changed())
845 sym_clear_all_valid();
846
847 menu = rootmenu.list;
848 while (menu) {
849 sym = menu->sym;
850 if (!sym) {
851 if (!menu_is_visible(menu))
852 goto next;
853 str = menu_get_prompt(menu);
854 fprintf(stream: out, format: "\n"
855 "#\n"
856 "# %s\n"
857 "#\n", str);
858 need_newline = false;
859 } else if (!sym_is_choice(sym) &&
860 !(sym->flags & SYMBOL_WRITTEN)) {
861 sym_calc_value(sym);
862 if (!(sym->flags & SYMBOL_WRITE))
863 goto next;
864 if (need_newline) {
865 fprintf(stream: out, format: "\n");
866 need_newline = false;
867 }
868 sym->flags |= SYMBOL_WRITTEN;
869 print_symbol_for_dotconfig(fp: out, sym);
870 }
871
872next:
873 if (menu->list) {
874 menu = menu->list;
875 continue;
876 }
877
878end_check:
879 if (!menu->sym && menu_is_visible(menu) && menu != &rootmenu &&
880 menu->prompt->type == P_MENU) {
881 fprintf(stream: out, format: "# end of %s\n", menu_get_prompt(menu));
882 need_newline = true;
883 }
884
885 if (menu->next) {
886 menu = menu->next;
887 } else {
888 menu = menu->parent;
889 if (menu)
890 goto end_check;
891 }
892 }
893 fclose(stream: out);
894
895 for_all_symbols(sym)
896 sym->flags &= ~SYMBOL_WRITTEN;
897
898 if (*tmpname) {
899 if (is_same(file1: name, file2: tmpname)) {
900 conf_message(fmt: "No change to %s", name);
901 unlink(name: tmpname);
902 conf_set_changed(false);
903 return 0;
904 }
905
906 snprintf(s: oldname, maxlen: sizeof(oldname), format: "%s.old", name);
907 rename(old: name, new: oldname);
908 if (rename(old: tmpname, new: name))
909 return 1;
910 }
911
912 conf_message(fmt: "configuration written to %s", name);
913
914 conf_set_changed(false);
915
916 return 0;
917}
918
919/* write a dependency file as used by kbuild to track dependencies */
920static int conf_write_autoconf_cmd(const char *autoconf_name)
921{
922 char name[PATH_MAX], tmp[PATH_MAX];
923 FILE *out;
924 int ret;
925
926 ret = snprintf(s: name, maxlen: sizeof(name), format: "%s.cmd", autoconf_name);
927 if (ret >= sizeof(name)) /* check truncation */
928 return -1;
929
930 if (make_parent_dir(path: name))
931 return -1;
932
933 ret = snprintf(s: tmp, maxlen: sizeof(tmp), format: "%s.cmd.tmp", autoconf_name);
934 if (ret >= sizeof(tmp)) /* check truncation */
935 return -1;
936
937 out = fopen(filename: tmp, modes: "w");
938 if (!out) {
939 perror(s: "fopen");
940 return -1;
941 }
942
943 fprintf(stream: out, format: "autoconfig := %s\n", autoconf_name);
944
945 fputs(s: str_get(gs: &autoconf_cmd), stream: out);
946
947 fflush(stream: out);
948 ret = ferror(stream: out); /* error check for all fprintf() calls */
949 fclose(stream: out);
950 if (ret)
951 return -1;
952
953 if (rename(old: tmp, new: name)) {
954 perror(s: "rename");
955 return -1;
956 }
957
958 return 0;
959}
960
961static int conf_touch_deps(void)
962{
963 const char *name, *tmp;
964 struct symbol *sym;
965 int res;
966
967 name = conf_get_autoconfig_name();
968 tmp = strrchr(s: name, c: '/');
969 depfile_prefix_len = tmp ? tmp - name + 1 : 0;
970 if (depfile_prefix_len + 1 > sizeof(depfile_path))
971 return -1;
972
973 strncpy(dest: depfile_path, src: name, n: depfile_prefix_len);
974 depfile_path[depfile_prefix_len] = 0;
975
976 conf_read_simple(name, def: S_DEF_AUTO);
977
978 for_all_symbols(sym) {
979 if (sym_is_choice(sym))
980 continue;
981 if (sym->flags & SYMBOL_WRITE) {
982 if (sym->flags & SYMBOL_DEF_AUTO) {
983 /*
984 * symbol has old and new value,
985 * so compare them...
986 */
987 switch (sym->type) {
988 case S_BOOLEAN:
989 case S_TRISTATE:
990 if (sym_get_tristate_value(sym) ==
991 sym->def[S_DEF_AUTO].tri)
992 continue;
993 break;
994 case S_STRING:
995 case S_HEX:
996 case S_INT:
997 if (!strcmp(sym_get_string_value(sym),
998 sym->def[S_DEF_AUTO].val))
999 continue;
1000 break;
1001 default:
1002 break;
1003 }
1004 } else {
1005 /*
1006 * If there is no old value, only 'no' (unset)
1007 * is allowed as new value.
1008 */
1009 switch (sym->type) {
1010 case S_BOOLEAN:
1011 case S_TRISTATE:
1012 if (sym_get_tristate_value(sym) == no)
1013 continue;
1014 break;
1015 default:
1016 break;
1017 }
1018 }
1019 } else if (!(sym->flags & SYMBOL_DEF_AUTO))
1020 /* There is neither an old nor a new value. */
1021 continue;
1022 /* else
1023 * There is an old value, but no new value ('no' (unset)
1024 * isn't saved in auto.conf, so the old value is always
1025 * different from 'no').
1026 */
1027
1028 res = conf_touch_dep(name: sym->name);
1029 if (res)
1030 return res;
1031 }
1032
1033 return 0;
1034}
1035
1036static int __conf_write_autoconf(const char *filename,
1037 void (*print_symbol)(FILE *, struct symbol *),
1038 const struct comment_style *comment_style)
1039{
1040 char tmp[PATH_MAX];
1041 FILE *file;
1042 struct symbol *sym;
1043 int ret;
1044
1045 if (make_parent_dir(path: filename))
1046 return -1;
1047
1048 ret = snprintf(s: tmp, maxlen: sizeof(tmp), format: "%s.tmp", filename);
1049 if (ret >= sizeof(tmp)) /* check truncation */
1050 return -1;
1051
1052 file = fopen(filename: tmp, modes: "w");
1053 if (!file) {
1054 perror(s: "fopen");
1055 return -1;
1056 }
1057
1058 conf_write_heading(fp: file, cs: comment_style);
1059
1060 for_all_symbols(sym)
1061 if ((sym->flags & SYMBOL_WRITE) && sym->name)
1062 print_symbol(file, sym);
1063
1064 fflush(stream: file);
1065 /* check possible errors in conf_write_heading() and print_symbol() */
1066 ret = ferror(stream: file);
1067 fclose(stream: file);
1068 if (ret)
1069 return -1;
1070
1071 if (rename(old: tmp, new: filename)) {
1072 perror(s: "rename");
1073 return -1;
1074 }
1075
1076 return 0;
1077}
1078
1079int conf_write_autoconf(int overwrite)
1080{
1081 struct symbol *sym;
1082 const char *autoconf_name = conf_get_autoconfig_name();
1083 int ret;
1084
1085 if (!overwrite && is_present(path: autoconf_name))
1086 return 0;
1087
1088 ret = conf_write_autoconf_cmd(autoconf_name);
1089 if (ret)
1090 return -1;
1091
1092 for_all_symbols(sym)
1093 sym_calc_value(sym);
1094
1095 if (conf_touch_deps())
1096 return 1;
1097
1098 ret = __conf_write_autoconf(filename: conf_get_autoheader_name(),
1099 print_symbol: print_symbol_for_c,
1100 comment_style: &comment_style_c);
1101 if (ret)
1102 return ret;
1103
1104 ret = __conf_write_autoconf(filename: conf_get_rustccfg_name(),
1105 print_symbol: print_symbol_for_rustccfg,
1106 NULL);
1107 if (ret)
1108 return ret;
1109
1110 /*
1111 * Create include/config/auto.conf. This must be the last step because
1112 * Kbuild has a dependency on auto.conf and this marks the successful
1113 * completion of the previous steps.
1114 */
1115 ret = __conf_write_autoconf(filename: conf_get_autoconfig_name(),
1116 print_symbol: print_symbol_for_autoconf,
1117 comment_style: &comment_style_pound);
1118 if (ret)
1119 return ret;
1120
1121 return 0;
1122}
1123
1124static bool conf_changed;
1125static void (*conf_changed_callback)(bool);
1126
1127void conf_set_changed(bool val)
1128{
1129 if (conf_changed_callback && conf_changed != val)
1130 conf_changed_callback(val);
1131
1132 conf_changed = val;
1133}
1134
1135bool conf_get_changed(void)
1136{
1137 return conf_changed;
1138}
1139
1140void conf_set_changed_callback(void (*fn)(bool))
1141{
1142 conf_changed_callback = fn;
1143}
1144

source code of linux/scripts/kconfig/confdata.c