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 <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 0; 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 struct property *prop; 364 365 name = conf_get_configname(); 366 in = zconf_fopen(name); 367 if (in) 368 goto load; 369 sym_add_change_count(1); 370 if (!sym_defconfig_list) 371 return 1; 372 373 for_all_defaults(sym_defconfig_list, prop) { 374 if (expr_calc_value(prop->visible.expr) == no || 375 prop->expr->type != E_SYMBOL) 376 continue; 377 sym_calc_value(prop->expr->left.sym); 378 name = sym_get_string_value(prop->expr->left.sym); 379 in = zconf_fopen(name); 380 if (in) { 381 conf_message("using defaults found in %s", 382 name); 383 goto load; 384 } 385 } 386 } 387 if (!in) 388 return 1; 389 390 load: 391 conf_filename = name; 392 conf_lineno = 0; 393 conf_warnings = 0; 394 395 def_flags = SYMBOL_DEF << def; 396 for_all_symbols(i, sym) { 397 sym->flags |= SYMBOL_CHANGED; 398 sym->flags &= ~(def_flags|SYMBOL_VALID); 399 if (sym_is_choice(sym)) 400 sym->flags |= def_flags; 401 switch (sym->type) { 402 case S_INT: 403 case S_HEX: 404 case S_STRING: 405 if (sym->def[def].val) 406 free(sym->def[def].val); 407 /* fall through */ 408 default: 409 sym->def[def].val = NULL; 410 sym->def[def].tri = no; 411 } 412 } 413 414 while (compat_getline(&line, &line_asize, in) != -1) { 415 conf_lineno++; 416 sym = NULL; 417 if (line[0] == '#') { 418 if (memcmp(line + 2, CONFIG_, strlen(CONFIG_))) 419 continue; 420 p = strchr(line + 2 + strlen(CONFIG_), ' '); 421 if (!p) 422 continue; 423 *p++ = 0; 424 if (strncmp(p, "is not set", 10)) 425 continue; 426 if (def == S_DEF_USER) { 427 sym = sym_find(line + 2 + strlen(CONFIG_)); 428 if (!sym) { 429 sym_add_change_count(1); 430 continue; 431 } 432 } else { 433 sym = sym_lookup(line + 2 + strlen(CONFIG_), 0); 434 if (sym->type == S_UNKNOWN) 435 sym->type = S_BOOLEAN; 436 } 437 if (sym->flags & def_flags) { 438 conf_warning("override: reassigning to symbol %s", sym->name); 439 } 440 switch (sym->type) { 441 case S_BOOLEAN: 442 case S_TRISTATE: 443 sym->def[def].tri = no; 444 sym->flags |= def_flags; 445 break; 446 default: 447 ; 448 } 449 } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) { 450 p = strchr(line + strlen(CONFIG_), '='); 451 if (!p) 452 continue; 453 *p++ = 0; 454 p2 = strchr(p, '\n'); 455 if (p2) { 456 *p2-- = 0; 457 if (*p2 == '\r') 458 *p2 = 0; 459 } 460 461 sym = sym_find(line + strlen(CONFIG_)); 462 if (!sym) { 463 if (def == S_DEF_AUTO) 464 /* 465 * Reading from include/config/auto.conf 466 * If CONFIG_FOO previously existed in 467 * auto.conf but it is missing now, 468 * include/config/foo.h must be touched. 469 */ 470 conf_touch_dep(line + strlen(CONFIG_)); 471 else 472 sym_add_change_count(1); 473 continue; 474 } 475 476 if (sym->flags & def_flags) { 477 conf_warning("override: reassigning to symbol %s", sym->name); 478 } 479 if (conf_set_sym_val(sym, def, def_flags, p)) 480 continue; 481 } else { 482 if (line[0] != '\r' && line[0] != '\n') 483 conf_warning("unexpected data: %.*s", 484 (int)strcspn(line, "\r\n"), line); 485 486 continue; 487 } 488 489 if (sym && sym_is_choice_value(sym)) { 490 struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); 491 switch (sym->def[def].tri) { 492 case no: 493 break; 494 case mod: 495 if (cs->def[def].tri == yes) { 496 conf_warning("%s creates inconsistent choice state", sym->name); 497 cs->flags &= ~def_flags; 498 } 499 break; 500 case yes: 501 if (cs->def[def].tri != no) 502 conf_warning("override: %s changes choice state", sym->name); 503 cs->def[def].val = sym; 504 break; 505 } 506 cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri); 507 } 508 } 509 free(line); 510 fclose(in); 511 return 0; 512 } 513 514 int conf_read(const char *name) 515 { 516 struct symbol *sym; 517 int conf_unsaved = 0; 518 int i; 519 520 sym_set_change_count(0); 521 522 if (conf_read_simple(name, S_DEF_USER)) { 523 sym_calc_value(modules_sym); 524 return 1; 525 } 526 527 sym_calc_value(modules_sym); 528 529 for_all_symbols(i, sym) { 530 sym_calc_value(sym); 531 if (sym_is_choice(sym) || (sym->flags & SYMBOL_NO_WRITE)) 532 continue; 533 if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) { 534 /* check that calculated value agrees with saved value */ 535 switch (sym->type) { 536 case S_BOOLEAN: 537 case S_TRISTATE: 538 if (sym->def[S_DEF_USER].tri == sym_get_tristate_value(sym)) 539 continue; 540 break; 541 default: 542 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val)) 543 continue; 544 break; 545 } 546 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE)) 547 /* no previous value and not saved */ 548 continue; 549 conf_unsaved++; 550 /* maybe print value in verbose mode... */ 551 } 552 553 for_all_symbols(i, sym) { 554 if (sym_has_value(sym) && !sym_is_choice_value(sym)) { 555 /* Reset values of generates values, so they'll appear 556 * as new, if they should become visible, but that 557 * doesn't quite work if the Kconfig and the saved 558 * configuration disagree. 559 */ 560 if (sym->visible == no && !conf_unsaved) 561 sym->flags &= ~SYMBOL_DEF_USER; 562 switch (sym->type) { 563 case S_STRING: 564 case S_INT: 565 case S_HEX: 566 /* Reset a string value if it's out of range */ 567 if (sym_string_within_range(sym, sym->def[S_DEF_USER].val)) 568 break; 569 sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER); 570 conf_unsaved++; 571 break; 572 default: 573 break; 574 } 575 } 576 } 577 578 sym_add_change_count(conf_warnings || conf_unsaved); 579 580 return 0; 581 } 582 583 /* 584 * Kconfig configuration printer 585 * 586 * This printer is used when generating the resulting configuration after 587 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by 588 * passing a non-NULL argument to the printer. 589 * 590 */ 591 static void 592 kconfig_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg) 593 { 594 595 switch (sym->type) { 596 case S_BOOLEAN: 597 case S_TRISTATE: 598 if (*value == 'n') { 599 bool skip_unset = (arg != NULL); 600 601 if (!skip_unset) 602 fprintf(fp, "# %s%s is not set\n", 603 CONFIG_, sym->name); 604 return; 605 } 606 break; 607 default: 608 break; 609 } 610 611 fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, value); 612 } 613 614 static void 615 kconfig_print_comment(FILE *fp, const char *value, void *arg) 616 { 617 const char *p = value; 618 size_t l; 619 620 for (;;) { 621 l = strcspn(p, "\n"); 622 fprintf(fp, "#"); 623 if (l) { 624 fprintf(fp, " "); 625 xfwrite(p, l, 1, fp); 626 p += l; 627 } 628 fprintf(fp, "\n"); 629 if (*p++ == '\0') 630 break; 631 } 632 } 633 634 static struct conf_printer kconfig_printer_cb = 635 { 636 .print_symbol = kconfig_print_symbol, 637 .print_comment = kconfig_print_comment, 638 }; 639 640 /* 641 * Header printer 642 * 643 * This printer is used when generating the `include/generated/autoconf.h' file. 644 */ 645 static void 646 header_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg) 647 { 648 649 switch (sym->type) { 650 case S_BOOLEAN: 651 case S_TRISTATE: { 652 const char *suffix = ""; 653 654 switch (*value) { 655 case 'n': 656 break; 657 case 'm': 658 suffix = "_MODULE"; 659 /* fall through */ 660 default: 661 fprintf(fp, "#define %s%s%s 1\n", 662 CONFIG_, sym->name, suffix); 663 } 664 break; 665 } 666 case S_HEX: { 667 const char *prefix = ""; 668 669 if (value[0] != '0' || (value[1] != 'x' && value[1] != 'X')) 670 prefix = "0x"; 671 fprintf(fp, "#define %s%s %s%s\n", 672 CONFIG_, sym->name, prefix, value); 673 break; 674 } 675 case S_STRING: 676 case S_INT: 677 fprintf(fp, "#define %s%s %s\n", 678 CONFIG_, sym->name, value); 679 break; 680 default: 681 break; 682 } 683 684 } 685 686 static void 687 header_print_comment(FILE *fp, const char *value, void *arg) 688 { 689 const char *p = value; 690 size_t l; 691 692 fprintf(fp, "/*\n"); 693 for (;;) { 694 l = strcspn(p, "\n"); 695 fprintf(fp, " *"); 696 if (l) { 697 fprintf(fp, " "); 698 xfwrite(p, l, 1, fp); 699 p += l; 700 } 701 fprintf(fp, "\n"); 702 if (*p++ == '\0') 703 break; 704 } 705 fprintf(fp, " */\n"); 706 } 707 708 static struct conf_printer header_printer_cb = 709 { 710 .print_symbol = header_print_symbol, 711 .print_comment = header_print_comment, 712 }; 713 714 static void conf_write_symbol(FILE *fp, struct symbol *sym, 715 struct conf_printer *printer, void *printer_arg) 716 { 717 const char *str; 718 719 switch (sym->type) { 720 case S_UNKNOWN: 721 break; 722 case S_STRING: 723 str = sym_get_string_value(sym); 724 str = sym_escape_string_value(str); 725 printer->print_symbol(fp, sym, str, printer_arg); 726 free((void *)str); 727 break; 728 default: 729 str = sym_get_string_value(sym); 730 printer->print_symbol(fp, sym, str, printer_arg); 731 } 732 } 733 734 static void 735 conf_write_heading(FILE *fp, struct conf_printer *printer, void *printer_arg) 736 { 737 char buf[256]; 738 739 snprintf(buf, sizeof(buf), 740 "\n" 741 "Automatically generated file; DO NOT EDIT.\n" 742 "%s\n", 743 rootmenu.prompt->text); 744 745 printer->print_comment(fp, buf, printer_arg); 746 } 747 748 /* 749 * Write out a minimal config. 750 * All values that has default values are skipped as this is redundant. 751 */ 752 int conf_write_defconfig(const char *filename) 753 { 754 struct symbol *sym; 755 struct menu *menu; 756 FILE *out; 757 758 out = fopen(filename, "w"); 759 if (!out) 760 return 1; 761 762 sym_clear_all_valid(); 763 764 /* Traverse all menus to find all relevant symbols */ 765 menu = rootmenu.list; 766 767 while (menu != NULL) 768 { 769 sym = menu->sym; 770 if (sym == NULL) { 771 if (!menu_is_visible(menu)) 772 goto next_menu; 773 } else if (!sym_is_choice(sym)) { 774 sym_calc_value(sym); 775 if (!(sym->flags & SYMBOL_WRITE)) 776 goto next_menu; 777 sym->flags &= ~SYMBOL_WRITE; 778 /* If we cannot change the symbol - skip */ 779 if (!sym_is_changeable(sym)) 780 goto next_menu; 781 /* If symbol equals to default value - skip */ 782 if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0) 783 goto next_menu; 784 785 /* 786 * If symbol is a choice value and equals to the 787 * default for a choice - skip. 788 * But only if value is bool and equal to "y" and 789 * choice is not "optional". 790 * (If choice is "optional" then all values can be "n") 791 */ 792 if (sym_is_choice_value(sym)) { 793 struct symbol *cs; 794 struct symbol *ds; 795 796 cs = prop_get_symbol(sym_get_choice_prop(sym)); 797 ds = sym_choice_default(cs); 798 if (!sym_is_optional(cs) && sym == ds) { 799 if ((sym->type == S_BOOLEAN) && 800 sym_get_tristate_value(sym) == yes) 801 goto next_menu; 802 } 803 } 804 conf_write_symbol(out, sym, &kconfig_printer_cb, NULL); 805 } 806 next_menu: 807 if (menu->list != NULL) { 808 menu = menu->list; 809 } 810 else if (menu->next != NULL) { 811 menu = menu->next; 812 } else { 813 while ((menu = menu->parent)) { 814 if (menu->next != NULL) { 815 menu = menu->next; 816 break; 817 } 818 } 819 } 820 } 821 fclose(out); 822 return 0; 823 } 824 825 int conf_write(const char *name) 826 { 827 FILE *out; 828 struct symbol *sym; 829 struct menu *menu; 830 const char *str; 831 char tmpname[PATH_MAX + 1], oldname[PATH_MAX + 1]; 832 char *env; 833 int i; 834 bool need_newline = false; 835 836 if (!name) 837 name = conf_get_configname(); 838 839 if (!*name) { 840 fprintf(stderr, "config name is empty\n"); 841 return -1; 842 } 843 844 if (is_dir(name)) { 845 fprintf(stderr, "%s: Is a directory\n", name); 846 return -1; 847 } 848 849 if (make_parent_dir(name)) 850 return -1; 851 852 env = getenv("KCONFIG_OVERWRITECONFIG"); 853 if (env && *env) { 854 *tmpname = 0; 855 out = fopen(name, "w"); 856 } else { 857 snprintf(tmpname, sizeof(tmpname), "%s.%d.tmp", 858 name, (int)getpid()); 859 out = fopen(tmpname, "w"); 860 } 861 if (!out) 862 return 1; 863 864 conf_write_heading(out, &kconfig_printer_cb, NULL); 865 866 if (!conf_get_changed()) 867 sym_clear_all_valid(); 868 869 menu = rootmenu.list; 870 while (menu) { 871 sym = menu->sym; 872 if (!sym) { 873 if (!menu_is_visible(menu)) 874 goto next; 875 str = menu_get_prompt(menu); 876 fprintf(out, "\n" 877 "#\n" 878 "# %s\n" 879 "#\n", str); 880 need_newline = false; 881 } else if (!(sym->flags & SYMBOL_CHOICE) && 882 !(sym->flags & SYMBOL_WRITTEN)) { 883 sym_calc_value(sym); 884 if (!(sym->flags & SYMBOL_WRITE)) 885 goto next; 886 if (need_newline) { 887 fprintf(out, "\n"); 888 need_newline = false; 889 } 890 sym->flags |= SYMBOL_WRITTEN; 891 conf_write_symbol(out, sym, &kconfig_printer_cb, NULL); 892 } 893 894 next: 895 if (menu->list) { 896 menu = menu->list; 897 continue; 898 } 899 if (menu->next) 900 menu = menu->next; 901 else while ((menu = menu->parent)) { 902 if (!menu->sym && menu_is_visible(menu) && 903 menu != &rootmenu) { 904 str = menu_get_prompt(menu); 905 fprintf(out, "# end of %s\n", str); 906 need_newline = true; 907 } 908 if (menu->next) { 909 menu = menu->next; 910 break; 911 } 912 } 913 } 914 fclose(out); 915 916 for_all_symbols(i, sym) 917 sym->flags &= ~SYMBOL_WRITTEN; 918 919 if (*tmpname) { 920 if (is_same(name, tmpname)) { 921 conf_message("No change to %s", name); 922 unlink(tmpname); 923 sym_set_change_count(0); 924 return 0; 925 } 926 927 snprintf(oldname, sizeof(oldname), "%s.old", name); 928 rename(name, oldname); 929 if (rename(tmpname, name)) 930 return 1; 931 } 932 933 conf_message("configuration written to %s", name); 934 935 sym_set_change_count(0); 936 937 return 0; 938 } 939 940 /* write a dependency file as used by kbuild to track dependencies */ 941 static int conf_write_dep(const char *name) 942 { 943 struct file *file; 944 FILE *out; 945 946 out = fopen("..config.tmp", "w"); 947 if (!out) 948 return 1; 949 fprintf(out, "deps_config := \\\n"); 950 for (file = file_list; file; file = file->next) { 951 if (file->next) 952 fprintf(out, "\t%s \\\n", file->name); 953 else 954 fprintf(out, "\t%s\n", file->name); 955 } 956 fprintf(out, "\n%s: \\\n" 957 "\t$(deps_config)\n\n", conf_get_autoconfig_name()); 958 959 env_write_dep(out, conf_get_autoconfig_name()); 960 961 fprintf(out, "\n$(deps_config): ;\n"); 962 fclose(out); 963 964 if (make_parent_dir(name)) 965 return 1; 966 rename("..config.tmp", name); 967 return 0; 968 } 969 970 static int conf_touch_deps(void) 971 { 972 const char *name; 973 struct symbol *sym; 974 int res, i; 975 976 strcpy(depfile_path, "include/config/"); 977 depfile_prefix_len = strlen(depfile_path); 978 979 name = conf_get_autoconfig_name(); 980 conf_read_simple(name, S_DEF_AUTO); 981 sym_calc_value(modules_sym); 982 983 for_all_symbols(i, sym) { 984 sym_calc_value(sym); 985 if ((sym->flags & SYMBOL_NO_WRITE) || !sym->name) 986 continue; 987 if (sym->flags & SYMBOL_WRITE) { 988 if (sym->flags & SYMBOL_DEF_AUTO) { 989 /* 990 * symbol has old and new value, 991 * so compare them... 992 */ 993 switch (sym->type) { 994 case S_BOOLEAN: 995 case S_TRISTATE: 996 if (sym_get_tristate_value(sym) == 997 sym->def[S_DEF_AUTO].tri) 998 continue; 999 break; 1000 case S_STRING: 1001 case S_HEX: 1002 case S_INT: 1003 if (!strcmp(sym_get_string_value(sym), 1004 sym->def[S_DEF_AUTO].val)) 1005 continue; 1006 break; 1007 default: 1008 break; 1009 } 1010 } else { 1011 /* 1012 * If there is no old value, only 'no' (unset) 1013 * is allowed as new value. 1014 */ 1015 switch (sym->type) { 1016 case S_BOOLEAN: 1017 case S_TRISTATE: 1018 if (sym_get_tristate_value(sym) == no) 1019 continue; 1020 break; 1021 default: 1022 break; 1023 } 1024 } 1025 } else if (!(sym->flags & SYMBOL_DEF_AUTO)) 1026 /* There is neither an old nor a new value. */ 1027 continue; 1028 /* else 1029 * There is an old value, but no new value ('no' (unset) 1030 * isn't saved in auto.conf, so the old value is always 1031 * different from 'no'). 1032 */ 1033 1034 res = conf_touch_dep(sym->name); 1035 if (res) 1036 return res; 1037 } 1038 1039 return 0; 1040 } 1041 1042 int conf_write_autoconf(int overwrite) 1043 { 1044 struct symbol *sym; 1045 const char *name; 1046 const char *autoconf_name = conf_get_autoconfig_name(); 1047 FILE *out, *out_h; 1048 int i; 1049 1050 if (!overwrite && is_present(autoconf_name)) 1051 return 0; 1052 1053 conf_write_dep("include/config/auto.conf.cmd"); 1054 1055 if (conf_touch_deps()) 1056 return 1; 1057 1058 out = fopen(".tmpconfig", "w"); 1059 if (!out) 1060 return 1; 1061 1062 out_h = fopen(".tmpconfig.h", "w"); 1063 if (!out_h) { 1064 fclose(out); 1065 return 1; 1066 } 1067 1068 conf_write_heading(out, &kconfig_printer_cb, NULL); 1069 conf_write_heading(out_h, &header_printer_cb, NULL); 1070 1071 for_all_symbols(i, sym) { 1072 sym_calc_value(sym); 1073 if (!(sym->flags & SYMBOL_WRITE) || !sym->name) 1074 continue; 1075 1076 /* write symbols to auto.conf and autoconf.h */ 1077 conf_write_symbol(out, sym, &kconfig_printer_cb, (void *)1); 1078 conf_write_symbol(out_h, sym, &header_printer_cb, NULL); 1079 } 1080 fclose(out); 1081 fclose(out_h); 1082 1083 name = getenv("KCONFIG_AUTOHEADER"); 1084 if (!name) 1085 name = "include/generated/autoconf.h"; 1086 if (make_parent_dir(name)) 1087 return 1; 1088 if (rename(".tmpconfig.h", name)) 1089 return 1; 1090 1091 if (make_parent_dir(autoconf_name)) 1092 return 1; 1093 /* 1094 * This must be the last step, kbuild has a dependency on auto.conf 1095 * and this marks the successful completion of the previous steps. 1096 */ 1097 if (rename(".tmpconfig", autoconf_name)) 1098 return 1; 1099 1100 return 0; 1101 } 1102 1103 static int sym_change_count; 1104 static void (*conf_changed_callback)(void); 1105 1106 void sym_set_change_count(int count) 1107 { 1108 int _sym_change_count = sym_change_count; 1109 sym_change_count = count; 1110 if (conf_changed_callback && 1111 (bool)_sym_change_count != (bool)count) 1112 conf_changed_callback(); 1113 } 1114 1115 void sym_add_change_count(int count) 1116 { 1117 sym_set_change_count(count + sym_change_count); 1118 } 1119 1120 bool conf_get_changed(void) 1121 { 1122 return sym_change_count; 1123 } 1124 1125 void conf_set_changed_callback(void (*fn)(void)) 1126 { 1127 conf_changed_callback = fn; 1128 } 1129 1130 static bool randomize_choice_values(struct symbol *csym) 1131 { 1132 struct property *prop; 1133 struct symbol *sym; 1134 struct expr *e; 1135 int cnt, def; 1136 1137 /* 1138 * If choice is mod then we may have more items selected 1139 * and if no then no-one. 1140 * In both cases stop. 1141 */ 1142 if (csym->curr.tri != yes) 1143 return false; 1144 1145 prop = sym_get_choice_prop(csym); 1146 1147 /* count entries in choice block */ 1148 cnt = 0; 1149 expr_list_for_each_sym(prop->expr, e, sym) 1150 cnt++; 1151 1152 /* 1153 * find a random value and set it to yes, 1154 * set the rest to no so we have only one set 1155 */ 1156 def = (rand() % cnt); 1157 1158 cnt = 0; 1159 expr_list_for_each_sym(prop->expr, e, sym) { 1160 if (def == cnt++) { 1161 sym->def[S_DEF_USER].tri = yes; 1162 csym->def[S_DEF_USER].val = sym; 1163 } 1164 else { 1165 sym->def[S_DEF_USER].tri = no; 1166 } 1167 sym->flags |= SYMBOL_DEF_USER; 1168 /* clear VALID to get value calculated */ 1169 sym->flags &= ~SYMBOL_VALID; 1170 } 1171 csym->flags |= SYMBOL_DEF_USER; 1172 /* clear VALID to get value calculated */ 1173 csym->flags &= ~(SYMBOL_VALID); 1174 1175 return true; 1176 } 1177 1178 void set_all_choice_values(struct symbol *csym) 1179 { 1180 struct property *prop; 1181 struct symbol *sym; 1182 struct expr *e; 1183 1184 prop = sym_get_choice_prop(csym); 1185 1186 /* 1187 * Set all non-assinged choice values to no 1188 */ 1189 expr_list_for_each_sym(prop->expr, e, sym) { 1190 if (!sym_has_value(sym)) 1191 sym->def[S_DEF_USER].tri = no; 1192 } 1193 csym->flags |= SYMBOL_DEF_USER; 1194 /* clear VALID to get value calculated */ 1195 csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES); 1196 } 1197 1198 bool conf_set_all_new_symbols(enum conf_def_mode mode) 1199 { 1200 struct symbol *sym, *csym; 1201 int i, cnt, pby, pty, ptm; /* pby: probability of bool = y 1202 * pty: probability of tristate = y 1203 * ptm: probability of tristate = m 1204 */ 1205 1206 pby = 50; pty = ptm = 33; /* can't go as the default in switch-case 1207 * below, otherwise gcc whines about 1208 * -Wmaybe-uninitialized */ 1209 if (mode == def_random) { 1210 int n, p[3]; 1211 char *env = getenv("KCONFIG_PROBABILITY"); 1212 n = 0; 1213 while( env && *env ) { 1214 char *endp; 1215 int tmp = strtol( env, &endp, 10 ); 1216 if( tmp >= 0 && tmp <= 100 ) { 1217 p[n++] = tmp; 1218 } else { 1219 errno = ERANGE; 1220 perror( "KCONFIG_PROBABILITY" ); 1221 exit( 1 ); 1222 } 1223 env = (*endp == ':') ? endp+1 : endp; 1224 if( n >=3 ) { 1225 break; 1226 } 1227 } 1228 switch( n ) { 1229 case 1: 1230 pby = p[0]; ptm = pby/2; pty = pby-ptm; 1231 break; 1232 case 2: 1233 pty = p[0]; ptm = p[1]; pby = pty + ptm; 1234 break; 1235 case 3: 1236 pby = p[0]; pty = p[1]; ptm = p[2]; 1237 break; 1238 } 1239 1240 if( pty+ptm > 100 ) { 1241 errno = ERANGE; 1242 perror( "KCONFIG_PROBABILITY" ); 1243 exit( 1 ); 1244 } 1245 } 1246 bool has_changed = false; 1247 1248 for_all_symbols(i, sym) { 1249 if (sym_has_value(sym) || (sym->flags & SYMBOL_VALID)) 1250 continue; 1251 switch (sym_get_type(sym)) { 1252 case S_BOOLEAN: 1253 case S_TRISTATE: 1254 has_changed = true; 1255 switch (mode) { 1256 case def_yes: 1257 sym->def[S_DEF_USER].tri = yes; 1258 break; 1259 case def_mod: 1260 sym->def[S_DEF_USER].tri = mod; 1261 break; 1262 case def_no: 1263 if (sym->flags & SYMBOL_ALLNOCONFIG_Y) 1264 sym->def[S_DEF_USER].tri = yes; 1265 else 1266 sym->def[S_DEF_USER].tri = no; 1267 break; 1268 case def_random: 1269 sym->def[S_DEF_USER].tri = no; 1270 cnt = rand() % 100; 1271 if (sym->type == S_TRISTATE) { 1272 if (cnt < pty) 1273 sym->def[S_DEF_USER].tri = yes; 1274 else if (cnt < (pty+ptm)) 1275 sym->def[S_DEF_USER].tri = mod; 1276 } else if (cnt < pby) 1277 sym->def[S_DEF_USER].tri = yes; 1278 break; 1279 default: 1280 continue; 1281 } 1282 if (!(sym_is_choice(sym) && mode == def_random)) 1283 sym->flags |= SYMBOL_DEF_USER; 1284 break; 1285 default: 1286 break; 1287 } 1288 1289 } 1290 1291 sym_clear_all_valid(); 1292 1293 /* 1294 * We have different type of choice blocks. 1295 * If curr.tri equals to mod then we can select several 1296 * choice symbols in one block. 1297 * In this case we do nothing. 1298 * If curr.tri equals yes then only one symbol can be 1299 * selected in a choice block and we set it to yes, 1300 * and the rest to no. 1301 */ 1302 if (mode != def_random) { 1303 for_all_symbols(i, csym) { 1304 if ((sym_is_choice(csym) && !sym_has_value(csym)) || 1305 sym_is_choice_value(csym)) 1306 csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES; 1307 } 1308 } 1309 1310 for_all_symbols(i, csym) { 1311 if (sym_has_value(csym) || !sym_is_choice(csym)) 1312 continue; 1313 1314 sym_calc_value(csym); 1315 if (mode == def_random) 1316 has_changed |= randomize_choice_values(csym); 1317 else { 1318 set_all_choice_values(csym); 1319 has_changed = true; 1320 } 1321 } 1322 1323 return has_changed; 1324 } 1325 1326 void conf_rewrite_mod_or_yes(enum conf_def_mode mode) 1327 { 1328 struct symbol *sym; 1329 int i; 1330 tristate old_val = (mode == def_y2m) ? yes : mod; 1331 tristate new_val = (mode == def_y2m) ? mod : yes; 1332 1333 for_all_symbols(i, sym) { 1334 if (sym_get_type(sym) == S_TRISTATE && 1335 sym->def[S_DEF_USER].tri == old_val) 1336 sym->def[S_DEF_USER].tri = new_val; 1337 } 1338 sym_clear_all_valid(); 1339 } 1340