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