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