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 /* 714 * Tristate printer 715 * 716 * This printer is used when generating the `include/config/tristate.conf' file. 717 */ 718 static void 719 tristate_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg) 720 { 721 722 if (sym->type == S_TRISTATE && *value != 'n') 723 fprintf(fp, "%s%s=%c\n", CONFIG_, sym->name, (char)toupper(*value)); 724 } 725 726 static struct conf_printer tristate_printer_cb = 727 { 728 .print_symbol = tristate_print_symbol, 729 .print_comment = kconfig_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 bool need_newline = false; 852 853 if (!name) 854 name = conf_get_configname(); 855 856 if (!*name) { 857 fprintf(stderr, "config name is empty\n"); 858 return -1; 859 } 860 861 if (is_dir(name)) { 862 fprintf(stderr, "%s: Is a directory\n", name); 863 return -1; 864 } 865 866 if (make_parent_dir(name)) 867 return -1; 868 869 env = getenv("KCONFIG_OVERWRITECONFIG"); 870 if (env && *env) { 871 *tmpname = 0; 872 out = fopen(name, "w"); 873 } else { 874 snprintf(tmpname, sizeof(tmpname), "%s.%d.tmp", 875 name, (int)getpid()); 876 out = fopen(tmpname, "w"); 877 } 878 if (!out) 879 return 1; 880 881 conf_write_heading(out, &kconfig_printer_cb, NULL); 882 883 if (!conf_get_changed()) 884 sym_clear_all_valid(); 885 886 menu = rootmenu.list; 887 while (menu) { 888 sym = menu->sym; 889 if (!sym) { 890 if (!menu_is_visible(menu)) 891 goto next; 892 str = menu_get_prompt(menu); 893 fprintf(out, "\n" 894 "#\n" 895 "# %s\n" 896 "#\n", str); 897 need_newline = false; 898 } else if (!(sym->flags & SYMBOL_CHOICE) && 899 !(sym->flags & SYMBOL_WRITTEN)) { 900 sym_calc_value(sym); 901 if (!(sym->flags & SYMBOL_WRITE)) 902 goto next; 903 if (need_newline) { 904 fprintf(out, "\n"); 905 need_newline = false; 906 } 907 sym->flags |= SYMBOL_WRITTEN; 908 conf_write_symbol(out, sym, &kconfig_printer_cb, NULL); 909 } 910 911 next: 912 if (menu->list) { 913 menu = menu->list; 914 continue; 915 } 916 if (menu->next) 917 menu = menu->next; 918 else while ((menu = menu->parent)) { 919 if (!menu->sym && menu_is_visible(menu) && 920 menu != &rootmenu) { 921 str = menu_get_prompt(menu); 922 fprintf(out, "# end of %s\n", str); 923 need_newline = true; 924 } 925 if (menu->next) { 926 menu = menu->next; 927 break; 928 } 929 } 930 } 931 fclose(out); 932 933 if (*tmpname) { 934 if (is_same(name, tmpname)) { 935 conf_message("No change to %s", name); 936 unlink(tmpname); 937 sym_set_change_count(0); 938 return 0; 939 } 940 941 snprintf(oldname, sizeof(oldname), "%s.old", name); 942 rename(name, oldname); 943 if (rename(tmpname, name)) 944 return 1; 945 } 946 947 conf_message("configuration written to %s", name); 948 949 sym_set_change_count(0); 950 951 return 0; 952 } 953 954 /* write a dependency file as used by kbuild to track dependencies */ 955 static int conf_write_dep(const char *name) 956 { 957 struct file *file; 958 FILE *out; 959 960 out = fopen("..config.tmp", "w"); 961 if (!out) 962 return 1; 963 fprintf(out, "deps_config := \\\n"); 964 for (file = file_list; file; file = file->next) { 965 if (file->next) 966 fprintf(out, "\t%s \\\n", file->name); 967 else 968 fprintf(out, "\t%s\n", file->name); 969 } 970 fprintf(out, "\n%s: \\\n" 971 "\t$(deps_config)\n\n", conf_get_autoconfig_name()); 972 973 env_write_dep(out, conf_get_autoconfig_name()); 974 975 fprintf(out, "\n$(deps_config): ;\n"); 976 fclose(out); 977 978 if (make_parent_dir(name)) 979 return 1; 980 rename("..config.tmp", name); 981 return 0; 982 } 983 984 static int conf_touch_deps(void) 985 { 986 const char *name; 987 struct symbol *sym; 988 int res, i; 989 990 strcpy(depfile_path, "include/config/"); 991 depfile_prefix_len = strlen(depfile_path); 992 993 name = conf_get_autoconfig_name(); 994 conf_read_simple(name, S_DEF_AUTO); 995 sym_calc_value(modules_sym); 996 997 for_all_symbols(i, sym) { 998 sym_calc_value(sym); 999 if ((sym->flags & SYMBOL_NO_WRITE) || !sym->name) 1000 continue; 1001 if (sym->flags & SYMBOL_WRITE) { 1002 if (sym->flags & SYMBOL_DEF_AUTO) { 1003 /* 1004 * symbol has old and new value, 1005 * so compare them... 1006 */ 1007 switch (sym->type) { 1008 case S_BOOLEAN: 1009 case S_TRISTATE: 1010 if (sym_get_tristate_value(sym) == 1011 sym->def[S_DEF_AUTO].tri) 1012 continue; 1013 break; 1014 case S_STRING: 1015 case S_HEX: 1016 case S_INT: 1017 if (!strcmp(sym_get_string_value(sym), 1018 sym->def[S_DEF_AUTO].val)) 1019 continue; 1020 break; 1021 default: 1022 break; 1023 } 1024 } else { 1025 /* 1026 * If there is no old value, only 'no' (unset) 1027 * is allowed as new value. 1028 */ 1029 switch (sym->type) { 1030 case S_BOOLEAN: 1031 case S_TRISTATE: 1032 if (sym_get_tristate_value(sym) == no) 1033 continue; 1034 break; 1035 default: 1036 break; 1037 } 1038 } 1039 } else if (!(sym->flags & SYMBOL_DEF_AUTO)) 1040 /* There is neither an old nor a new value. */ 1041 continue; 1042 /* else 1043 * There is an old value, but no new value ('no' (unset) 1044 * isn't saved in auto.conf, so the old value is always 1045 * different from 'no'). 1046 */ 1047 1048 res = conf_touch_dep(sym->name); 1049 if (res) 1050 return res; 1051 } 1052 1053 return 0; 1054 } 1055 1056 int conf_write_autoconf(int overwrite) 1057 { 1058 struct symbol *sym; 1059 const char *name; 1060 const char *autoconf_name = conf_get_autoconfig_name(); 1061 FILE *out, *tristate, *out_h; 1062 int i; 1063 1064 if (!overwrite && is_present(autoconf_name)) 1065 return 0; 1066 1067 conf_write_dep("include/config/auto.conf.cmd"); 1068 1069 if (conf_touch_deps()) 1070 return 1; 1071 1072 out = fopen(".tmpconfig", "w"); 1073 if (!out) 1074 return 1; 1075 1076 tristate = fopen(".tmpconfig_tristate", "w"); 1077 if (!tristate) { 1078 fclose(out); 1079 return 1; 1080 } 1081 1082 out_h = fopen(".tmpconfig.h", "w"); 1083 if (!out_h) { 1084 fclose(out); 1085 fclose(tristate); 1086 return 1; 1087 } 1088 1089 conf_write_heading(out, &kconfig_printer_cb, NULL); 1090 1091 conf_write_heading(tristate, &tristate_printer_cb, NULL); 1092 1093 conf_write_heading(out_h, &header_printer_cb, NULL); 1094 1095 for_all_symbols(i, sym) { 1096 sym_calc_value(sym); 1097 if (!(sym->flags & SYMBOL_WRITE) || !sym->name) 1098 continue; 1099 1100 /* write symbol to auto.conf, tristate and header files */ 1101 conf_write_symbol(out, sym, &kconfig_printer_cb, (void *)1); 1102 1103 conf_write_symbol(tristate, sym, &tristate_printer_cb, (void *)1); 1104 1105 conf_write_symbol(out_h, sym, &header_printer_cb, NULL); 1106 } 1107 fclose(out); 1108 fclose(tristate); 1109 fclose(out_h); 1110 1111 name = getenv("KCONFIG_AUTOHEADER"); 1112 if (!name) 1113 name = "include/generated/autoconf.h"; 1114 if (make_parent_dir(name)) 1115 return 1; 1116 if (rename(".tmpconfig.h", name)) 1117 return 1; 1118 1119 name = getenv("KCONFIG_TRISTATE"); 1120 if (!name) 1121 name = "include/config/tristate.conf"; 1122 if (make_parent_dir(name)) 1123 return 1; 1124 if (rename(".tmpconfig_tristate", name)) 1125 return 1; 1126 1127 if (make_parent_dir(autoconf_name)) 1128 return 1; 1129 /* 1130 * This must be the last step, kbuild has a dependency on auto.conf 1131 * and this marks the successful completion of the previous steps. 1132 */ 1133 if (rename(".tmpconfig", autoconf_name)) 1134 return 1; 1135 1136 return 0; 1137 } 1138 1139 static int sym_change_count; 1140 static void (*conf_changed_callback)(void); 1141 1142 void sym_set_change_count(int count) 1143 { 1144 int _sym_change_count = sym_change_count; 1145 sym_change_count = count; 1146 if (conf_changed_callback && 1147 (bool)_sym_change_count != (bool)count) 1148 conf_changed_callback(); 1149 } 1150 1151 void sym_add_change_count(int count) 1152 { 1153 sym_set_change_count(count + sym_change_count); 1154 } 1155 1156 bool conf_get_changed(void) 1157 { 1158 return sym_change_count; 1159 } 1160 1161 void conf_set_changed_callback(void (*fn)(void)) 1162 { 1163 conf_changed_callback = fn; 1164 } 1165 1166 static bool randomize_choice_values(struct symbol *csym) 1167 { 1168 struct property *prop; 1169 struct symbol *sym; 1170 struct expr *e; 1171 int cnt, def; 1172 1173 /* 1174 * If choice is mod then we may have more items selected 1175 * and if no then no-one. 1176 * In both cases stop. 1177 */ 1178 if (csym->curr.tri != yes) 1179 return false; 1180 1181 prop = sym_get_choice_prop(csym); 1182 1183 /* count entries in choice block */ 1184 cnt = 0; 1185 expr_list_for_each_sym(prop->expr, e, sym) 1186 cnt++; 1187 1188 /* 1189 * find a random value and set it to yes, 1190 * set the rest to no so we have only one set 1191 */ 1192 def = (rand() % cnt); 1193 1194 cnt = 0; 1195 expr_list_for_each_sym(prop->expr, e, sym) { 1196 if (def == cnt++) { 1197 sym->def[S_DEF_USER].tri = yes; 1198 csym->def[S_DEF_USER].val = sym; 1199 } 1200 else { 1201 sym->def[S_DEF_USER].tri = no; 1202 } 1203 sym->flags |= SYMBOL_DEF_USER; 1204 /* clear VALID to get value calculated */ 1205 sym->flags &= ~SYMBOL_VALID; 1206 } 1207 csym->flags |= SYMBOL_DEF_USER; 1208 /* clear VALID to get value calculated */ 1209 csym->flags &= ~(SYMBOL_VALID); 1210 1211 return true; 1212 } 1213 1214 void set_all_choice_values(struct symbol *csym) 1215 { 1216 struct property *prop; 1217 struct symbol *sym; 1218 struct expr *e; 1219 1220 prop = sym_get_choice_prop(csym); 1221 1222 /* 1223 * Set all non-assinged choice values to no 1224 */ 1225 expr_list_for_each_sym(prop->expr, e, sym) { 1226 if (!sym_has_value(sym)) 1227 sym->def[S_DEF_USER].tri = no; 1228 } 1229 csym->flags |= SYMBOL_DEF_USER; 1230 /* clear VALID to get value calculated */ 1231 csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES); 1232 } 1233 1234 bool conf_set_all_new_symbols(enum conf_def_mode mode) 1235 { 1236 struct symbol *sym, *csym; 1237 int i, cnt, pby, pty, ptm; /* pby: probability of bool = y 1238 * pty: probability of tristate = y 1239 * ptm: probability of tristate = m 1240 */ 1241 1242 pby = 50; pty = ptm = 33; /* can't go as the default in switch-case 1243 * below, otherwise gcc whines about 1244 * -Wmaybe-uninitialized */ 1245 if (mode == def_random) { 1246 int n, p[3]; 1247 char *env = getenv("KCONFIG_PROBABILITY"); 1248 n = 0; 1249 while( env && *env ) { 1250 char *endp; 1251 int tmp = strtol( env, &endp, 10 ); 1252 if( tmp >= 0 && tmp <= 100 ) { 1253 p[n++] = tmp; 1254 } else { 1255 errno = ERANGE; 1256 perror( "KCONFIG_PROBABILITY" ); 1257 exit( 1 ); 1258 } 1259 env = (*endp == ':') ? endp+1 : endp; 1260 if( n >=3 ) { 1261 break; 1262 } 1263 } 1264 switch( n ) { 1265 case 1: 1266 pby = p[0]; ptm = pby/2; pty = pby-ptm; 1267 break; 1268 case 2: 1269 pty = p[0]; ptm = p[1]; pby = pty + ptm; 1270 break; 1271 case 3: 1272 pby = p[0]; pty = p[1]; ptm = p[2]; 1273 break; 1274 } 1275 1276 if( pty+ptm > 100 ) { 1277 errno = ERANGE; 1278 perror( "KCONFIG_PROBABILITY" ); 1279 exit( 1 ); 1280 } 1281 } 1282 bool has_changed = false; 1283 1284 for_all_symbols(i, sym) { 1285 if (sym_has_value(sym) || (sym->flags & SYMBOL_VALID)) 1286 continue; 1287 switch (sym_get_type(sym)) { 1288 case S_BOOLEAN: 1289 case S_TRISTATE: 1290 has_changed = true; 1291 switch (mode) { 1292 case def_yes: 1293 sym->def[S_DEF_USER].tri = yes; 1294 break; 1295 case def_mod: 1296 sym->def[S_DEF_USER].tri = mod; 1297 break; 1298 case def_no: 1299 if (sym->flags & SYMBOL_ALLNOCONFIG_Y) 1300 sym->def[S_DEF_USER].tri = yes; 1301 else 1302 sym->def[S_DEF_USER].tri = no; 1303 break; 1304 case def_random: 1305 sym->def[S_DEF_USER].tri = no; 1306 cnt = rand() % 100; 1307 if (sym->type == S_TRISTATE) { 1308 if (cnt < pty) 1309 sym->def[S_DEF_USER].tri = yes; 1310 else if (cnt < (pty+ptm)) 1311 sym->def[S_DEF_USER].tri = mod; 1312 } else if (cnt < pby) 1313 sym->def[S_DEF_USER].tri = yes; 1314 break; 1315 default: 1316 continue; 1317 } 1318 if (!(sym_is_choice(sym) && mode == def_random)) 1319 sym->flags |= SYMBOL_DEF_USER; 1320 break; 1321 default: 1322 break; 1323 } 1324 1325 } 1326 1327 sym_clear_all_valid(); 1328 1329 /* 1330 * We have different type of choice blocks. 1331 * If curr.tri equals to mod then we can select several 1332 * choice symbols in one block. 1333 * In this case we do nothing. 1334 * If curr.tri equals yes then only one symbol can be 1335 * selected in a choice block and we set it to yes, 1336 * and the rest to no. 1337 */ 1338 if (mode != def_random) { 1339 for_all_symbols(i, csym) { 1340 if ((sym_is_choice(csym) && !sym_has_value(csym)) || 1341 sym_is_choice_value(csym)) 1342 csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES; 1343 } 1344 } 1345 1346 for_all_symbols(i, csym) { 1347 if (sym_has_value(csym) || !sym_is_choice(csym)) 1348 continue; 1349 1350 sym_calc_value(csym); 1351 if (mode == def_random) 1352 has_changed = randomize_choice_values(csym); 1353 else { 1354 set_all_choice_values(csym); 1355 has_changed = true; 1356 } 1357 } 1358 1359 return has_changed; 1360 } 1361