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 "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 static void conf_warning(const char *fmt, ...) 159 { 160 va_list ap; 161 va_start(ap, fmt); 162 fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno); 163 vfprintf(stderr, fmt, ap); 164 fprintf(stderr, "\n"); 165 va_end(ap); 166 conf_warnings++; 167 } 168 169 static void conf_default_message_callback(const char *s) 170 { 171 printf("#\n# "); 172 printf("%s", s); 173 printf("\n#\n"); 174 } 175 176 static void (*conf_message_callback)(const char *s) = 177 conf_default_message_callback; 178 void conf_set_message_callback(void (*fn)(const char *s)) 179 { 180 conf_message_callback = fn; 181 } 182 183 static void conf_message(const char *fmt, ...) 184 { 185 va_list ap; 186 char buf[4096]; 187 188 if (!conf_message_callback) 189 return; 190 191 va_start(ap, fmt); 192 193 vsnprintf(buf, sizeof(buf), fmt, ap); 194 conf_message_callback(buf); 195 va_end(ap); 196 } 197 198 const char *conf_get_configname(void) 199 { 200 char *name = getenv("KCONFIG_CONFIG"); 201 202 return name ? name : ".config"; 203 } 204 205 static const char *conf_get_autoconfig_name(void) 206 { 207 char *name = getenv("KCONFIG_AUTOCONFIG"); 208 209 return name ? name : "include/config/auto.conf"; 210 } 211 212 static const char *conf_get_autoheader_name(void) 213 { 214 char *name = getenv("KCONFIG_AUTOHEADER"); 215 216 return name ? name : "include/generated/autoconf.h"; 217 } 218 219 static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p) 220 { 221 char *p2; 222 223 switch (sym->type) { 224 case S_TRISTATE: 225 if (p[0] == 'm') { 226 sym->def[def].tri = mod; 227 sym->flags |= def_flags; 228 break; 229 } 230 /* fall through */ 231 case S_BOOLEAN: 232 if (p[0] == 'y') { 233 sym->def[def].tri = yes; 234 sym->flags |= def_flags; 235 break; 236 } 237 if (p[0] == 'n') { 238 sym->def[def].tri = no; 239 sym->flags |= def_flags; 240 break; 241 } 242 if (def != S_DEF_AUTO) 243 conf_warning("symbol value '%s' invalid for %s", 244 p, sym->name); 245 return 1; 246 case S_STRING: 247 /* No escaping for S_DEF_AUTO (include/config/auto.conf) */ 248 if (def != S_DEF_AUTO) { 249 if (*p++ != '"') 250 break; 251 for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) { 252 if (*p2 == '"') { 253 *p2 = 0; 254 break; 255 } 256 memmove(p2, p2 + 1, strlen(p2)); 257 } 258 if (!p2) { 259 conf_warning("invalid string found"); 260 return 1; 261 } 262 } 263 /* fall through */ 264 case S_INT: 265 case S_HEX: 266 if (sym_string_valid(sym, p)) { 267 sym->def[def].val = xstrdup(p); 268 sym->flags |= def_flags; 269 } else { 270 if (def != S_DEF_AUTO) 271 conf_warning("symbol value '%s' invalid for %s", 272 p, sym->name); 273 return 1; 274 } 275 break; 276 default: 277 ; 278 } 279 return 0; 280 } 281 282 #define LINE_GROWTH 16 283 static int add_byte(int c, char **lineptr, size_t slen, size_t *n) 284 { 285 char *nline; 286 size_t new_size = slen + 1; 287 if (new_size > *n) { 288 new_size += LINE_GROWTH - 1; 289 new_size *= 2; 290 nline = xrealloc(*lineptr, new_size); 291 if (!nline) 292 return -1; 293 294 *lineptr = nline; 295 *n = new_size; 296 } 297 298 (*lineptr)[slen] = c; 299 300 return 0; 301 } 302 303 static ssize_t compat_getline(char **lineptr, size_t *n, FILE *stream) 304 { 305 char *line = *lineptr; 306 size_t slen = 0; 307 308 for (;;) { 309 int c = getc(stream); 310 311 switch (c) { 312 case '\n': 313 if (add_byte(c, &line, slen, n) < 0) 314 goto e_out; 315 slen++; 316 /* fall through */ 317 case EOF: 318 if (add_byte('\0', &line, slen, n) < 0) 319 goto e_out; 320 *lineptr = line; 321 if (slen == 0) 322 return -1; 323 return slen; 324 default: 325 if (add_byte(c, &line, slen, n) < 0) 326 goto e_out; 327 slen++; 328 } 329 } 330 331 e_out: 332 line[slen-1] = '\0'; 333 *lineptr = line; 334 return -1; 335 } 336 337 int conf_read_simple(const char *name, int def) 338 { 339 FILE *in = NULL; 340 char *line = NULL; 341 size_t line_asize = 0; 342 char *p, *p2; 343 struct symbol *sym; 344 int i, def_flags; 345 346 if (name) { 347 in = zconf_fopen(name); 348 } else { 349 char *env; 350 351 name = conf_get_configname(); 352 in = zconf_fopen(name); 353 if (in) 354 goto load; 355 conf_set_changed(true); 356 357 env = getenv("KCONFIG_DEFCONFIG_LIST"); 358 if (!env) 359 return 1; 360 361 while (1) { 362 bool is_last; 363 364 while (isspace(*env)) 365 env++; 366 367 if (!*env) 368 break; 369 370 p = env; 371 while (*p && !isspace(*p)) 372 p++; 373 374 is_last = (*p == '\0'); 375 376 *p = '\0'; 377 378 in = zconf_fopen(env); 379 if (in) { 380 conf_message("using defaults found in %s", 381 env); 382 goto load; 383 } 384 385 if (is_last) 386 break; 387 388 env = p + 1; 389 } 390 } 391 if (!in) 392 return 1; 393 394 load: 395 conf_filename = name; 396 conf_lineno = 0; 397 conf_warnings = 0; 398 399 def_flags = SYMBOL_DEF << def; 400 for_all_symbols(i, sym) { 401 sym->flags |= SYMBOL_CHANGED; 402 sym->flags &= ~(def_flags|SYMBOL_VALID); 403 if (sym_is_choice(sym)) 404 sym->flags |= def_flags; 405 switch (sym->type) { 406 case S_INT: 407 case S_HEX: 408 case S_STRING: 409 if (sym->def[def].val) 410 free(sym->def[def].val); 411 /* fall through */ 412 default: 413 sym->def[def].val = NULL; 414 sym->def[def].tri = no; 415 } 416 } 417 418 while (compat_getline(&line, &line_asize, in) != -1) { 419 conf_lineno++; 420 sym = NULL; 421 if (line[0] == '#') { 422 if (memcmp(line + 2, CONFIG_, strlen(CONFIG_))) 423 continue; 424 p = strchr(line + 2 + strlen(CONFIG_), ' '); 425 if (!p) 426 continue; 427 *p++ = 0; 428 if (strncmp(p, "is not set", 10)) 429 continue; 430 if (def == S_DEF_USER) { 431 sym = sym_find(line + 2 + strlen(CONFIG_)); 432 if (!sym) { 433 conf_set_changed(true); 434 continue; 435 } 436 } else { 437 sym = sym_lookup(line + 2 + strlen(CONFIG_), 0); 438 if (sym->type == S_UNKNOWN) 439 sym->type = S_BOOLEAN; 440 } 441 if (sym->flags & def_flags) { 442 conf_warning("override: reassigning to symbol %s", sym->name); 443 } 444 switch (sym->type) { 445 case S_BOOLEAN: 446 case S_TRISTATE: 447 sym->def[def].tri = no; 448 sym->flags |= def_flags; 449 break; 450 default: 451 ; 452 } 453 } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) { 454 p = strchr(line + strlen(CONFIG_), '='); 455 if (!p) 456 continue; 457 *p++ = 0; 458 p2 = strchr(p, '\n'); 459 if (p2) { 460 *p2-- = 0; 461 if (*p2 == '\r') 462 *p2 = 0; 463 } 464 465 sym = sym_find(line + strlen(CONFIG_)); 466 if (!sym) { 467 if (def == S_DEF_AUTO) 468 /* 469 * Reading from include/config/auto.conf 470 * If CONFIG_FOO previously existed in 471 * auto.conf but it is missing now, 472 * include/config/FOO must be touched. 473 */ 474 conf_touch_dep(line + strlen(CONFIG_)); 475 else 476 conf_set_changed(true); 477 continue; 478 } 479 480 if (sym->flags & def_flags) { 481 conf_warning("override: reassigning to symbol %s", sym->name); 482 } 483 if (conf_set_sym_val(sym, def, def_flags, p)) 484 continue; 485 } else { 486 if (line[0] != '\r' && line[0] != '\n') 487 conf_warning("unexpected data: %.*s", 488 (int)strcspn(line, "\r\n"), line); 489 490 continue; 491 } 492 493 if (sym && sym_is_choice_value(sym)) { 494 struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); 495 switch (sym->def[def].tri) { 496 case no: 497 break; 498 case mod: 499 if (cs->def[def].tri == yes) { 500 conf_warning("%s creates inconsistent choice state", sym->name); 501 cs->flags &= ~def_flags; 502 } 503 break; 504 case yes: 505 if (cs->def[def].tri != no) 506 conf_warning("override: %s changes choice state", sym->name); 507 cs->def[def].val = sym; 508 break; 509 } 510 cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri); 511 } 512 } 513 free(line); 514 fclose(in); 515 return 0; 516 } 517 518 int conf_read(const char *name) 519 { 520 struct symbol *sym; 521 int conf_unsaved = 0; 522 int i; 523 524 conf_set_changed(false); 525 526 if (conf_read_simple(name, S_DEF_USER)) { 527 sym_calc_value(modules_sym); 528 return 1; 529 } 530 531 sym_calc_value(modules_sym); 532 533 for_all_symbols(i, sym) { 534 sym_calc_value(sym); 535 if (sym_is_choice(sym) || (sym->flags & SYMBOL_NO_WRITE)) 536 continue; 537 if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) { 538 /* check that calculated value agrees with saved value */ 539 switch (sym->type) { 540 case S_BOOLEAN: 541 case S_TRISTATE: 542 if (sym->def[S_DEF_USER].tri == sym_get_tristate_value(sym)) 543 continue; 544 break; 545 default: 546 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val)) 547 continue; 548 break; 549 } 550 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE)) 551 /* no previous value and not saved */ 552 continue; 553 conf_unsaved++; 554 /* maybe print value in verbose mode... */ 555 } 556 557 for_all_symbols(i, sym) { 558 if (sym_has_value(sym) && !sym_is_choice_value(sym)) { 559 /* Reset values of generates values, so they'll appear 560 * as new, if they should become visible, but that 561 * doesn't quite work if the Kconfig and the saved 562 * configuration disagree. 563 */ 564 if (sym->visible == no && !conf_unsaved) 565 sym->flags &= ~SYMBOL_DEF_USER; 566 switch (sym->type) { 567 case S_STRING: 568 case S_INT: 569 case S_HEX: 570 /* Reset a string value if it's out of range */ 571 if (sym_string_within_range(sym, sym->def[S_DEF_USER].val)) 572 break; 573 sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER); 574 conf_unsaved++; 575 break; 576 default: 577 break; 578 } 579 } 580 } 581 582 if (conf_warnings || conf_unsaved) 583 conf_set_changed(true); 584 585 return 0; 586 } 587 588 struct comment_style { 589 const char *decoration; 590 const char *prefix; 591 const char *postfix; 592 }; 593 594 static const struct comment_style comment_style_pound = { 595 .decoration = "#", 596 .prefix = "#", 597 .postfix = "#", 598 }; 599 600 static const struct comment_style comment_style_c = { 601 .decoration = " *", 602 .prefix = "/*", 603 .postfix = " */", 604 }; 605 606 static void conf_write_heading(FILE *fp, const struct comment_style *cs) 607 { 608 fprintf(fp, "%s\n", cs->prefix); 609 610 fprintf(fp, "%s Automatically generated file; DO NOT EDIT.\n", 611 cs->decoration); 612 613 fprintf(fp, "%s %s\n", cs->decoration, rootmenu.prompt->text); 614 615 fprintf(fp, "%s\n", cs->postfix); 616 } 617 618 /* The returned pointer must be freed on the caller side */ 619 static char *escape_string_value(const char *in) 620 { 621 const char *p; 622 char *out; 623 size_t len; 624 625 len = strlen(in) + strlen("\"\"") + 1; 626 627 p = in; 628 while (1) { 629 p += strcspn(p, "\"\\"); 630 631 if (p[0] == '\0') 632 break; 633 634 len++; 635 p++; 636 } 637 638 out = xmalloc(len); 639 out[0] = '\0'; 640 641 strcat(out, "\""); 642 643 p = in; 644 while (1) { 645 len = strcspn(p, "\"\\"); 646 strncat(out, p, len); 647 p += len; 648 649 if (p[0] == '\0') 650 break; 651 652 strcat(out, "\\"); 653 strncat(out, p++, 1); 654 } 655 656 strcat(out, "\""); 657 658 return out; 659 } 660 661 /* 662 * Kconfig configuration printer 663 * 664 * This printer is used when generating the resulting configuration after 665 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by 666 * passing a non-NULL argument to the printer. 667 */ 668 enum output_n { OUTPUT_N, OUTPUT_N_AS_UNSET, OUTPUT_N_NONE }; 669 670 static void __print_symbol(FILE *fp, struct symbol *sym, enum output_n output_n, 671 bool escape_string) 672 { 673 const char *val; 674 char *escaped = NULL; 675 676 if (sym->type == S_UNKNOWN) 677 return; 678 679 val = sym_get_string_value(sym); 680 681 if ((sym->type == S_BOOLEAN || sym->type == S_TRISTATE) && 682 output_n != OUTPUT_N && *val == 'n') { 683 if (output_n == OUTPUT_N_AS_UNSET) 684 fprintf(fp, "# %s%s is not set\n", CONFIG_, sym->name); 685 return; 686 } 687 688 if (sym->type == S_STRING && escape_string) { 689 escaped = escape_string_value(val); 690 val = escaped; 691 } 692 693 fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, val); 694 695 free(escaped); 696 } 697 698 static void print_symbol_for_dotconfig(FILE *fp, struct symbol *sym) 699 { 700 __print_symbol(fp, sym, OUTPUT_N_AS_UNSET, true); 701 } 702 703 static void print_symbol_for_autoconf(FILE *fp, struct symbol *sym) 704 { 705 __print_symbol(fp, sym, OUTPUT_N_NONE, false); 706 } 707 708 void print_symbol_for_listconfig(struct symbol *sym) 709 { 710 __print_symbol(stdout, sym, OUTPUT_N, true); 711 } 712 713 static void print_symbol_for_c(FILE *fp, struct symbol *sym) 714 { 715 const char *val; 716 const char *sym_suffix = ""; 717 const char *val_prefix = ""; 718 char *escaped = NULL; 719 720 if (sym->type == S_UNKNOWN) 721 return; 722 723 val = sym_get_string_value(sym); 724 725 switch (sym->type) { 726 case S_BOOLEAN: 727 case S_TRISTATE: 728 switch (*val) { 729 case 'n': 730 return; 731 case 'm': 732 sym_suffix = "_MODULE"; 733 /* fall through */ 734 default: 735 val = "1"; 736 } 737 break; 738 case S_HEX: 739 if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X')) 740 val_prefix = "0x"; 741 break; 742 case S_STRING: 743 escaped = escape_string_value(val); 744 val = escaped; 745 default: 746 break; 747 } 748 749 fprintf(fp, "#define %s%s%s %s%s\n", CONFIG_, sym->name, sym_suffix, 750 val_prefix, val); 751 752 free(escaped); 753 } 754 755 /* 756 * Write out a minimal config. 757 * All values that has default values are skipped as this is redundant. 758 */ 759 int conf_write_defconfig(const char *filename) 760 { 761 struct symbol *sym; 762 struct menu *menu; 763 FILE *out; 764 765 out = fopen(filename, "w"); 766 if (!out) 767 return 1; 768 769 sym_clear_all_valid(); 770 771 /* Traverse all menus to find all relevant symbols */ 772 menu = rootmenu.list; 773 774 while (menu != NULL) 775 { 776 sym = menu->sym; 777 if (sym == NULL) { 778 if (!menu_is_visible(menu)) 779 goto next_menu; 780 } else if (!sym_is_choice(sym)) { 781 sym_calc_value(sym); 782 if (!(sym->flags & SYMBOL_WRITE)) 783 goto next_menu; 784 sym->flags &= ~SYMBOL_WRITE; 785 /* If we cannot change the symbol - skip */ 786 if (!sym_is_changeable(sym)) 787 goto next_menu; 788 /* If symbol equals to default value - skip */ 789 if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0) 790 goto next_menu; 791 792 /* 793 * If symbol is a choice value and equals to the 794 * default for a choice - skip. 795 * But only if value is bool and equal to "y" and 796 * choice is not "optional". 797 * (If choice is "optional" then all values can be "n") 798 */ 799 if (sym_is_choice_value(sym)) { 800 struct symbol *cs; 801 struct symbol *ds; 802 803 cs = prop_get_symbol(sym_get_choice_prop(sym)); 804 ds = sym_choice_default(cs); 805 if (!sym_is_optional(cs) && sym == ds) { 806 if ((sym->type == S_BOOLEAN) && 807 sym_get_tristate_value(sym) == yes) 808 goto next_menu; 809 } 810 } 811 print_symbol_for_dotconfig(out, sym); 812 } 813 next_menu: 814 if (menu->list != NULL) { 815 menu = menu->list; 816 } 817 else if (menu->next != NULL) { 818 menu = menu->next; 819 } else { 820 while ((menu = menu->parent)) { 821 if (menu->next != NULL) { 822 menu = menu->next; 823 break; 824 } 825 } 826 } 827 } 828 fclose(out); 829 return 0; 830 } 831 832 int conf_write(const char *name) 833 { 834 FILE *out; 835 struct symbol *sym; 836 struct menu *menu; 837 const char *str; 838 char tmpname[PATH_MAX + 1], oldname[PATH_MAX + 1]; 839 char *env; 840 int i; 841 bool need_newline = false; 842 843 if (!name) 844 name = conf_get_configname(); 845 846 if (!*name) { 847 fprintf(stderr, "config name is empty\n"); 848 return -1; 849 } 850 851 if (is_dir(name)) { 852 fprintf(stderr, "%s: Is a directory\n", name); 853 return -1; 854 } 855 856 if (make_parent_dir(name)) 857 return -1; 858 859 env = getenv("KCONFIG_OVERWRITECONFIG"); 860 if (env && *env) { 861 *tmpname = 0; 862 out = fopen(name, "w"); 863 } else { 864 snprintf(tmpname, sizeof(tmpname), "%s.%d.tmp", 865 name, (int)getpid()); 866 out = fopen(tmpname, "w"); 867 } 868 if (!out) 869 return 1; 870 871 conf_write_heading(out, &comment_style_pound); 872 873 if (!conf_get_changed()) 874 sym_clear_all_valid(); 875 876 menu = rootmenu.list; 877 while (menu) { 878 sym = menu->sym; 879 if (!sym) { 880 if (!menu_is_visible(menu)) 881 goto next; 882 str = menu_get_prompt(menu); 883 fprintf(out, "\n" 884 "#\n" 885 "# %s\n" 886 "#\n", str); 887 need_newline = false; 888 } else if (!(sym->flags & SYMBOL_CHOICE) && 889 !(sym->flags & SYMBOL_WRITTEN)) { 890 sym_calc_value(sym); 891 if (!(sym->flags & SYMBOL_WRITE)) 892 goto next; 893 if (need_newline) { 894 fprintf(out, "\n"); 895 need_newline = false; 896 } 897 sym->flags |= SYMBOL_WRITTEN; 898 print_symbol_for_dotconfig(out, sym); 899 } 900 901 next: 902 if (menu->list) { 903 menu = menu->list; 904 continue; 905 } 906 if (menu->next) 907 menu = menu->next; 908 else while ((menu = menu->parent)) { 909 if (!menu->sym && menu_is_visible(menu) && 910 menu != &rootmenu) { 911 str = menu_get_prompt(menu); 912 fprintf(out, "# end of %s\n", str); 913 need_newline = true; 914 } 915 if (menu->next) { 916 menu = menu->next; 917 break; 918 } 919 } 920 } 921 fclose(out); 922 923 for_all_symbols(i, sym) 924 sym->flags &= ~SYMBOL_WRITTEN; 925 926 if (*tmpname) { 927 if (is_same(name, tmpname)) { 928 conf_message("No change to %s", name); 929 unlink(tmpname); 930 conf_set_changed(false); 931 return 0; 932 } 933 934 snprintf(oldname, sizeof(oldname), "%s.old", name); 935 rename(name, oldname); 936 if (rename(tmpname, name)) 937 return 1; 938 } 939 940 conf_message("configuration written to %s", name); 941 942 conf_set_changed(false); 943 944 return 0; 945 } 946 947 /* write a dependency file as used by kbuild to track dependencies */ 948 static int conf_write_autoconf_cmd(const char *autoconf_name) 949 { 950 char name[PATH_MAX], tmp[PATH_MAX]; 951 struct file *file; 952 FILE *out; 953 int ret; 954 955 ret = snprintf(name, sizeof(name), "%s.cmd", autoconf_name); 956 if (ret >= sizeof(name)) /* check truncation */ 957 return -1; 958 959 if (make_parent_dir(name)) 960 return -1; 961 962 ret = snprintf(tmp, sizeof(tmp), "%s.cmd.tmp", autoconf_name); 963 if (ret >= sizeof(tmp)) /* check truncation */ 964 return -1; 965 966 out = fopen(tmp, "w"); 967 if (!out) { 968 perror("fopen"); 969 return -1; 970 } 971 972 fprintf(out, "deps_config := \\\n"); 973 for (file = file_list; file; file = file->next) 974 fprintf(out, "\t%s \\\n", file->name); 975 976 fprintf(out, "\n%s: $(deps_config)\n\n", autoconf_name); 977 978 env_write_dep(out, autoconf_name); 979 980 fprintf(out, "\n$(deps_config): ;\n"); 981 982 ret = ferror(out); /* error check for all fprintf() calls */ 983 fclose(out); 984 if (ret) 985 return -1; 986 987 if (rename(tmp, name)) { 988 perror("rename"); 989 return -1; 990 } 991 992 return 0; 993 } 994 995 static int conf_touch_deps(void) 996 { 997 const char *name, *tmp; 998 struct symbol *sym; 999 int res, i; 1000 1001 name = conf_get_autoconfig_name(); 1002 tmp = strrchr(name, '/'); 1003 depfile_prefix_len = tmp ? tmp - name + 1 : 0; 1004 if (depfile_prefix_len + 1 > sizeof(depfile_path)) 1005 return -1; 1006 1007 strncpy(depfile_path, name, depfile_prefix_len); 1008 depfile_path[depfile_prefix_len] = 0; 1009 1010 conf_read_simple(name, S_DEF_AUTO); 1011 sym_calc_value(modules_sym); 1012 1013 for_all_symbols(i, sym) { 1014 sym_calc_value(sym); 1015 if ((sym->flags & SYMBOL_NO_WRITE) || !sym->name) 1016 continue; 1017 if (sym->flags & SYMBOL_WRITE) { 1018 if (sym->flags & SYMBOL_DEF_AUTO) { 1019 /* 1020 * symbol has old and new value, 1021 * so compare them... 1022 */ 1023 switch (sym->type) { 1024 case S_BOOLEAN: 1025 case S_TRISTATE: 1026 if (sym_get_tristate_value(sym) == 1027 sym->def[S_DEF_AUTO].tri) 1028 continue; 1029 break; 1030 case S_STRING: 1031 case S_HEX: 1032 case S_INT: 1033 if (!strcmp(sym_get_string_value(sym), 1034 sym->def[S_DEF_AUTO].val)) 1035 continue; 1036 break; 1037 default: 1038 break; 1039 } 1040 } else { 1041 /* 1042 * If there is no old value, only 'no' (unset) 1043 * is allowed as new value. 1044 */ 1045 switch (sym->type) { 1046 case S_BOOLEAN: 1047 case S_TRISTATE: 1048 if (sym_get_tristate_value(sym) == no) 1049 continue; 1050 break; 1051 default: 1052 break; 1053 } 1054 } 1055 } else if (!(sym->flags & SYMBOL_DEF_AUTO)) 1056 /* There is neither an old nor a new value. */ 1057 continue; 1058 /* else 1059 * There is an old value, but no new value ('no' (unset) 1060 * isn't saved in auto.conf, so the old value is always 1061 * different from 'no'). 1062 */ 1063 1064 res = conf_touch_dep(sym->name); 1065 if (res) 1066 return res; 1067 } 1068 1069 return 0; 1070 } 1071 1072 static int __conf_write_autoconf(const char *filename, 1073 void (*print_symbol)(FILE *, struct symbol *), 1074 const struct comment_style *comment_style) 1075 { 1076 char tmp[PATH_MAX]; 1077 FILE *file; 1078 struct symbol *sym; 1079 int ret, i; 1080 1081 if (make_parent_dir(filename)) 1082 return -1; 1083 1084 ret = snprintf(tmp, sizeof(tmp), "%s.tmp", filename); 1085 if (ret >= sizeof(tmp)) /* check truncation */ 1086 return -1; 1087 1088 file = fopen(tmp, "w"); 1089 if (!file) { 1090 perror("fopen"); 1091 return -1; 1092 } 1093 1094 conf_write_heading(file, comment_style); 1095 1096 for_all_symbols(i, sym) 1097 if ((sym->flags & SYMBOL_WRITE) && sym->name) 1098 print_symbol(file, sym); 1099 1100 /* check possible errors in conf_write_heading() and print_symbol() */ 1101 ret = ferror(file); 1102 fclose(file); 1103 if (ret) 1104 return -1; 1105 1106 if (rename(tmp, filename)) { 1107 perror("rename"); 1108 return -1; 1109 } 1110 1111 return 0; 1112 } 1113 1114 int conf_write_autoconf(int overwrite) 1115 { 1116 struct symbol *sym; 1117 const char *autoconf_name = conf_get_autoconfig_name(); 1118 int ret, i; 1119 1120 if (!overwrite && is_present(autoconf_name)) 1121 return 0; 1122 1123 ret = conf_write_autoconf_cmd(autoconf_name); 1124 if (ret) 1125 return -1; 1126 1127 if (conf_touch_deps()) 1128 return 1; 1129 1130 for_all_symbols(i, sym) 1131 sym_calc_value(sym); 1132 1133 ret = __conf_write_autoconf(conf_get_autoheader_name(), 1134 print_symbol_for_c, 1135 &comment_style_c); 1136 if (ret) 1137 return ret; 1138 1139 /* 1140 * Create include/config/auto.conf. This must be the last step because 1141 * Kbuild has a dependency on auto.conf and this marks the successful 1142 * completion of the previous steps. 1143 */ 1144 ret = __conf_write_autoconf(conf_get_autoconfig_name(), 1145 print_symbol_for_autoconf, 1146 &comment_style_pound); 1147 if (ret) 1148 return ret; 1149 1150 return 0; 1151 } 1152 1153 static bool conf_changed; 1154 static void (*conf_changed_callback)(void); 1155 1156 void conf_set_changed(bool val) 1157 { 1158 if (conf_changed_callback && conf_changed != val) 1159 conf_changed_callback(); 1160 1161 conf_changed = val; 1162 } 1163 1164 bool conf_get_changed(void) 1165 { 1166 return conf_changed; 1167 } 1168 1169 void conf_set_changed_callback(void (*fn)(void)) 1170 { 1171 conf_changed_callback = fn; 1172 } 1173 1174 void set_all_choice_values(struct symbol *csym) 1175 { 1176 struct property *prop; 1177 struct symbol *sym; 1178 struct expr *e; 1179 1180 prop = sym_get_choice_prop(csym); 1181 1182 /* 1183 * Set all non-assinged choice values to no 1184 */ 1185 expr_list_for_each_sym(prop->expr, e, sym) { 1186 if (!sym_has_value(sym)) 1187 sym->def[S_DEF_USER].tri = no; 1188 } 1189 csym->flags |= SYMBOL_DEF_USER; 1190 /* clear VALID to get value calculated */ 1191 csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES); 1192 } 1193