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