util/kconfig/confdata.c

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