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