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