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