confdata.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794
  1. /*
  2. * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  3. * Released under the terms of the GNU GPL v2.0.
  4. */
  5. #include <sys/stat.h>
  6. #include <ctype.h>
  7. #include <fcntl.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <time.h>
  12. #include <unistd.h>
  13. #define LKC_DIRECT_LINK
  14. #include "lkc.h"
  15. static void conf_warning(const char *fmt, ...)
  16. __attribute__ ((format (printf, 1, 2)));
  17. static const char *conf_filename;
  18. static int conf_lineno, conf_warnings, conf_unsaved;
  19. const char conf_defname[] = "arch/$ARCH/defconfig";
  20. static void conf_warning(const char *fmt, ...)
  21. {
  22. va_list ap;
  23. va_start(ap, fmt);
  24. fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
  25. vfprintf(stderr, fmt, ap);
  26. fprintf(stderr, "\n");
  27. va_end(ap);
  28. conf_warnings++;
  29. }
  30. const char *conf_get_configname(void)
  31. {
  32. char *name = getenv("KCONFIG_CONFIG");
  33. return name ? name : ".config";
  34. }
  35. static char *conf_expand_value(const char *in)
  36. {
  37. struct symbol *sym;
  38. const char *src;
  39. static char res_value[SYMBOL_MAXLENGTH];
  40. char *dst, name[SYMBOL_MAXLENGTH];
  41. res_value[0] = 0;
  42. dst = name;
  43. while ((src = strchr(in, '$'))) {
  44. strncat(res_value, in, src - in);
  45. src++;
  46. dst = name;
  47. while (isalnum(*src) || *src == '_')
  48. *dst++ = *src++;
  49. *dst = 0;
  50. sym = sym_lookup(name, 0);
  51. sym_calc_value(sym);
  52. strcat(res_value, sym_get_string_value(sym));
  53. in = src;
  54. }
  55. strcat(res_value, in);
  56. return res_value;
  57. }
  58. char *conf_get_default_confname(void)
  59. {
  60. struct stat buf;
  61. static char fullname[PATH_MAX+1];
  62. char *env, *name;
  63. name = conf_expand_value(conf_defname);
  64. env = getenv(SRCTREE);
  65. if (env) {
  66. sprintf(fullname, "%s/%s", env, name);
  67. if (!stat(fullname, &buf))
  68. return fullname;
  69. }
  70. return name;
  71. }
  72. int conf_read_simple(const char *name, int def)
  73. {
  74. FILE *in = NULL;
  75. char line[1024];
  76. char *p, *p2;
  77. struct symbol *sym;
  78. int i, def_flags;
  79. if (name) {
  80. in = zconf_fopen(name);
  81. } else {
  82. struct property *prop;
  83. name = conf_get_configname();
  84. in = zconf_fopen(name);
  85. if (in)
  86. goto load;
  87. sym_add_change_count(1);
  88. if (!sym_defconfig_list)
  89. return 1;
  90. for_all_defaults(sym_defconfig_list, prop) {
  91. if (expr_calc_value(prop->visible.expr) == no ||
  92. prop->expr->type != E_SYMBOL)
  93. continue;
  94. name = conf_expand_value(prop->expr->left.sym->name);
  95. in = zconf_fopen(name);
  96. if (in) {
  97. printf(_("#\n"
  98. "# using defaults found in %s\n"
  99. "#\n"), name);
  100. goto load;
  101. }
  102. }
  103. }
  104. if (!in)
  105. return 1;
  106. load:
  107. conf_filename = name;
  108. conf_lineno = 0;
  109. conf_warnings = 0;
  110. conf_unsaved = 0;
  111. def_flags = SYMBOL_DEF << def;
  112. for_all_symbols(i, sym) {
  113. sym->flags |= SYMBOL_CHANGED;
  114. sym->flags &= ~(def_flags|SYMBOL_VALID);
  115. if (sym_is_choice(sym))
  116. sym->flags |= def_flags;
  117. switch (sym->type) {
  118. case S_INT:
  119. case S_HEX:
  120. case S_STRING:
  121. if (sym->def[def].val)
  122. free(sym->def[def].val);
  123. default:
  124. sym->def[def].val = NULL;
  125. sym->def[def].tri = no;
  126. }
  127. }
  128. while (fgets(line, sizeof(line), in)) {
  129. conf_lineno++;
  130. sym = NULL;
  131. switch (line[0]) {
  132. case '#':
  133. if (memcmp(line + 2, "CONFIG_", 7))
  134. continue;
  135. p = strchr(line + 9, ' ');
  136. if (!p)
  137. continue;
  138. *p++ = 0;
  139. if (strncmp(p, "is not set", 10))
  140. continue;
  141. if (def == S_DEF_USER) {
  142. sym = sym_find(line + 9);
  143. if (!sym) {
  144. conf_warning("trying to assign nonexistent symbol %s", line + 9);
  145. break;
  146. }
  147. } else {
  148. sym = sym_lookup(line + 9, 0);
  149. if (sym->type == S_UNKNOWN)
  150. sym->type = S_BOOLEAN;
  151. }
  152. if (sym->flags & def_flags) {
  153. conf_warning("trying to reassign symbol %s", sym->name);
  154. break;
  155. }
  156. switch (sym->type) {
  157. case S_BOOLEAN:
  158. case S_TRISTATE:
  159. sym->def[def].tri = no;
  160. sym->flags |= def_flags;
  161. break;
  162. default:
  163. ;
  164. }
  165. break;
  166. case 'C':
  167. if (memcmp(line, "CONFIG_", 7)) {
  168. conf_warning("unexpected data");
  169. continue;
  170. }
  171. p = strchr(line + 7, '=');
  172. if (!p)
  173. continue;
  174. *p++ = 0;
  175. p2 = strchr(p, '\n');
  176. if (p2) {
  177. *p2-- = 0;
  178. if (*p2 == '\r')
  179. *p2 = 0;
  180. }
  181. if (def == S_DEF_USER) {
  182. sym = sym_find(line + 7);
  183. if (!sym) {
  184. conf_warning("trying to assign nonexistent symbol %s", line + 7);
  185. break;
  186. }
  187. } else {
  188. sym = sym_lookup(line + 7, 0);
  189. if (sym->type == S_UNKNOWN)
  190. sym->type = S_OTHER;
  191. }
  192. if (sym->flags & def_flags) {
  193. conf_warning("trying to reassign symbol %s", sym->name);
  194. break;
  195. }
  196. switch (sym->type) {
  197. case S_TRISTATE:
  198. if (p[0] == 'm') {
  199. sym->def[def].tri = mod;
  200. sym->flags |= def_flags;
  201. break;
  202. }
  203. case S_BOOLEAN:
  204. if (p[0] == 'y') {
  205. sym->def[def].tri = yes;
  206. sym->flags |= def_flags;
  207. break;
  208. }
  209. if (p[0] == 'n') {
  210. sym->def[def].tri = no;
  211. sym->flags |= def_flags;
  212. break;
  213. }
  214. conf_warning("symbol value '%s' invalid for %s", p, sym->name);
  215. break;
  216. case S_OTHER:
  217. if (*p != '"') {
  218. for (p2 = p; *p2 && !isspace(*p2); p2++)
  219. ;
  220. sym->type = S_STRING;
  221. goto done;
  222. }
  223. case S_STRING:
  224. if (*p++ != '"')
  225. break;
  226. for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
  227. if (*p2 == '"') {
  228. *p2 = 0;
  229. break;
  230. }
  231. memmove(p2, p2 + 1, strlen(p2));
  232. }
  233. if (!p2) {
  234. conf_warning("invalid string found");
  235. continue;
  236. }
  237. case S_INT:
  238. case S_HEX:
  239. done:
  240. if (sym_string_valid(sym, p)) {
  241. sym->def[def].val = strdup(p);
  242. sym->flags |= def_flags;
  243. } else {
  244. conf_warning("symbol value '%s' invalid for %s", p, sym->name);
  245. continue;
  246. }
  247. break;
  248. default:
  249. ;
  250. }
  251. break;
  252. case '\r':
  253. case '\n':
  254. break;
  255. default:
  256. conf_warning("unexpected data");
  257. continue;
  258. }
  259. if (sym && sym_is_choice_value(sym)) {
  260. struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
  261. switch (sym->def[def].tri) {
  262. case no:
  263. break;
  264. case mod:
  265. if (cs->def[def].tri == yes) {
  266. conf_warning("%s creates inconsistent choice state", sym->name);
  267. cs->flags &= ~def_flags;
  268. }
  269. break;
  270. case yes:
  271. if (cs->def[def].tri != no) {
  272. conf_warning("%s creates inconsistent choice state", sym->name);
  273. cs->flags &= ~def_flags;
  274. } else
  275. cs->def[def].val = sym;
  276. break;
  277. }
  278. cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);
  279. }
  280. }
  281. fclose(in);
  282. if (modules_sym)
  283. sym_calc_value(modules_sym);
  284. return 0;
  285. }
  286. int conf_read(const char *name)
  287. {
  288. struct symbol *sym;
  289. struct property *prop;
  290. struct expr *e;
  291. int i, flags;
  292. sym_set_change_count(0);
  293. if (conf_read_simple(name, S_DEF_USER))
  294. return 1;
  295. for_all_symbols(i, sym) {
  296. sym_calc_value(sym);
  297. if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
  298. goto sym_ok;
  299. if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
  300. /* check that calculated value agrees with saved value */
  301. switch (sym->type) {
  302. case S_BOOLEAN:
  303. case S_TRISTATE:
  304. if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
  305. break;
  306. if (!sym_is_choice(sym))
  307. goto sym_ok;
  308. default:
  309. if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
  310. goto sym_ok;
  311. break;
  312. }
  313. } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
  314. /* no previous value and not saved */
  315. goto sym_ok;
  316. conf_unsaved++;
  317. /* maybe print value in verbose mode... */
  318. sym_ok:
  319. if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
  320. if (sym->visible == no)
  321. sym->flags &= ~SYMBOL_DEF_USER;
  322. switch (sym->type) {
  323. case S_STRING:
  324. case S_INT:
  325. case S_HEX:
  326. if (!sym_string_within_range(sym, sym->def[S_DEF_USER].val))
  327. sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
  328. default:
  329. break;
  330. }
  331. }
  332. if (!sym_is_choice(sym))
  333. continue;
  334. prop = sym_get_choice_prop(sym);
  335. flags = sym->flags;
  336. for (e = prop->expr; e; e = e->left.expr)
  337. if (e->right.sym->visible != no)
  338. flags &= e->right.sym->flags;
  339. sym->flags &= flags | ~SYMBOL_DEF_USER;
  340. }
  341. sym_add_change_count(conf_warnings || conf_unsaved);
  342. return 0;
  343. }
  344. int conf_write(const char *name)
  345. {
  346. FILE *out;
  347. struct symbol *sym;
  348. struct menu *menu;
  349. const char *basename;
  350. char dirname[128], tmpname[128], newname[128];
  351. int type, l;
  352. const char *str;
  353. time_t now;
  354. int use_timestamp = 1;
  355. char *env;
  356. dirname[0] = 0;
  357. if (name && name[0]) {
  358. struct stat st;
  359. char *slash;
  360. if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
  361. strcpy(dirname, name);
  362. strcat(dirname, "/");
  363. basename = conf_get_configname();
  364. } else if ((slash = strrchr(name, '/'))) {
  365. int size = slash - name + 1;
  366. memcpy(dirname, name, size);
  367. dirname[size] = 0;
  368. if (slash[1])
  369. basename = slash + 1;
  370. else
  371. basename = conf_get_configname();
  372. } else
  373. basename = name;
  374. } else
  375. basename = conf_get_configname();
  376. sprintf(newname, "%s%s", dirname, basename);
  377. env = getenv("KCONFIG_OVERWRITECONFIG");
  378. if (!env || !*env) {
  379. sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
  380. out = fopen(tmpname, "w");
  381. } else {
  382. *tmpname = 0;
  383. out = fopen(newname, "w");
  384. }
  385. if (!out)
  386. return 1;
  387. sym = sym_lookup("KERNELVERSION", 0);
  388. sym_calc_value(sym);
  389. time(&now);
  390. env = getenv("KCONFIG_NOTIMESTAMP");
  391. if (env && *env)
  392. use_timestamp = 0;
  393. fprintf(out, _("#\n"
  394. "# Automatically generated make config: don't edit\n"
  395. "# Linux kernel version: %s\n"
  396. "%s%s"
  397. "#\n"),
  398. sym_get_string_value(sym),
  399. use_timestamp ? "# " : "",
  400. use_timestamp ? ctime(&now) : "");
  401. if (!conf_get_changed())
  402. sym_clear_all_valid();
  403. menu = rootmenu.list;
  404. while (menu) {
  405. sym = menu->sym;
  406. if (!sym) {
  407. if (!menu_is_visible(menu))
  408. goto next;
  409. str = menu_get_prompt(menu);
  410. fprintf(out, "\n"
  411. "#\n"
  412. "# %s\n"
  413. "#\n", str);
  414. } else if (!(sym->flags & SYMBOL_CHOICE)) {
  415. sym_calc_value(sym);
  416. if (!(sym->flags & SYMBOL_WRITE))
  417. goto next;
  418. sym->flags &= ~SYMBOL_WRITE;
  419. type = sym->type;
  420. if (type == S_TRISTATE) {
  421. sym_calc_value(modules_sym);
  422. if (modules_sym->curr.tri == no)
  423. type = S_BOOLEAN;
  424. }
  425. switch (type) {
  426. case S_BOOLEAN:
  427. case S_TRISTATE:
  428. switch (sym_get_tristate_value(sym)) {
  429. case no:
  430. fprintf(out, "# CONFIG_%s is not set\n", sym->name);
  431. break;
  432. case mod:
  433. fprintf(out, "CONFIG_%s=m\n", sym->name);
  434. break;
  435. case yes:
  436. fprintf(out, "CONFIG_%s=y\n", sym->name);
  437. break;
  438. }
  439. break;
  440. case S_STRING:
  441. str = sym_get_string_value(sym);
  442. fprintf(out, "CONFIG_%s=\"", sym->name);
  443. while (1) {
  444. l = strcspn(str, "\"\\");
  445. if (l) {
  446. fwrite(str, l, 1, out);
  447. str += l;
  448. }
  449. if (!*str)
  450. break;
  451. fprintf(out, "\\%c", *str++);
  452. }
  453. fputs("\"\n", out);
  454. break;
  455. case S_HEX:
  456. str = sym_get_string_value(sym);
  457. if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
  458. fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
  459. break;
  460. }
  461. case S_INT:
  462. str = sym_get_string_value(sym);
  463. fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
  464. break;
  465. }
  466. }
  467. next:
  468. if (menu->list) {
  469. menu = menu->list;
  470. continue;
  471. }
  472. if (menu->next)
  473. menu = menu->next;
  474. else while ((menu = menu->parent)) {
  475. if (menu->next) {
  476. menu = menu->next;
  477. break;
  478. }
  479. }
  480. }
  481. fclose(out);
  482. if (*tmpname) {
  483. strcat(dirname, basename);
  484. strcat(dirname, ".old");
  485. rename(newname, dirname);
  486. if (rename(tmpname, newname))
  487. return 1;
  488. }
  489. printf(_("#\n"
  490. "# configuration written to %s\n"
  491. "#\n"), newname);
  492. sym_set_change_count(0);
  493. return 0;
  494. }
  495. int conf_split_config(void)
  496. {
  497. char *name, path[128];
  498. char *s, *d, c;
  499. struct symbol *sym;
  500. struct stat sb;
  501. int res, i, fd;
  502. name = getenv("KCONFIG_AUTOCONFIG");
  503. if (!name)
  504. name = "include/config/auto.conf";
  505. conf_read_simple(name, S_DEF_AUTO);
  506. if (chdir("include/config"))
  507. return 1;
  508. res = 0;
  509. for_all_symbols(i, sym) {
  510. sym_calc_value(sym);
  511. if ((sym->flags & SYMBOL_AUTO) || !sym->name)
  512. continue;
  513. if (sym->flags & SYMBOL_WRITE) {
  514. if (sym->flags & SYMBOL_DEF_AUTO) {
  515. /*
  516. * symbol has old and new value,
  517. * so compare them...
  518. */
  519. switch (sym->type) {
  520. case S_BOOLEAN:
  521. case S_TRISTATE:
  522. if (sym_get_tristate_value(sym) ==
  523. sym->def[S_DEF_AUTO].tri)
  524. continue;
  525. break;
  526. case S_STRING:
  527. case S_HEX:
  528. case S_INT:
  529. if (!strcmp(sym_get_string_value(sym),
  530. sym->def[S_DEF_AUTO].val))
  531. continue;
  532. break;
  533. default:
  534. break;
  535. }
  536. } else {
  537. /*
  538. * If there is no old value, only 'no' (unset)
  539. * is allowed as new value.
  540. */
  541. switch (sym->type) {
  542. case S_BOOLEAN:
  543. case S_TRISTATE:
  544. if (sym_get_tristate_value(sym) == no)
  545. continue;
  546. break;
  547. default:
  548. break;
  549. }
  550. }
  551. } else if (!(sym->flags & SYMBOL_DEF_AUTO))
  552. /* There is neither an old nor a new value. */
  553. continue;
  554. /* else
  555. * There is an old value, but no new value ('no' (unset)
  556. * isn't saved in auto.conf, so the old value is always
  557. * different from 'no').
  558. */
  559. /* Replace all '_' and append ".h" */
  560. s = sym->name;
  561. d = path;
  562. while ((c = *s++)) {
  563. c = tolower(c);
  564. *d++ = (c == '_') ? '/' : c;
  565. }
  566. strcpy(d, ".h");
  567. /* Assume directory path already exists. */
  568. fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  569. if (fd == -1) {
  570. if (errno != ENOENT) {
  571. res = 1;
  572. break;
  573. }
  574. /*
  575. * Create directory components,
  576. * unless they exist already.
  577. */
  578. d = path;
  579. while ((d = strchr(d, '/'))) {
  580. *d = 0;
  581. if (stat(path, &sb) && mkdir(path, 0755)) {
  582. res = 1;
  583. goto out;
  584. }
  585. *d++ = '/';
  586. }
  587. /* Try it again. */
  588. fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
  589. if (fd == -1) {
  590. res = 1;
  591. break;
  592. }
  593. }
  594. close(fd);
  595. }
  596. out:
  597. if (chdir("../.."))
  598. return 1;
  599. return res;
  600. }
  601. int conf_write_autoconf(void)
  602. {
  603. struct symbol *sym;
  604. const char *str;
  605. char *name;
  606. FILE *out, *out_h;
  607. time_t now;
  608. int i, l;
  609. sym_clear_all_valid();
  610. file_write_dep("include/config/auto.conf.cmd");
  611. if (conf_split_config())
  612. return 1;
  613. out = fopen(".tmpconfig", "w");
  614. if (!out)
  615. return 1;
  616. out_h = fopen(".tmpconfig.h", "w");
  617. if (!out_h) {
  618. fclose(out);
  619. return 1;
  620. }
  621. sym = sym_lookup("KERNELVERSION", 0);
  622. sym_calc_value(sym);
  623. time(&now);
  624. fprintf(out, "#\n"
  625. "# Automatically generated make config: don't edit\n"
  626. "# Linux kernel version: %s\n"
  627. "# %s"
  628. "#\n",
  629. sym_get_string_value(sym), ctime(&now));
  630. fprintf(out_h, "/*\n"
  631. " * Automatically generated C config: don't edit\n"
  632. " * Linux kernel version: %s\n"
  633. " * %s"
  634. " */\n"
  635. "#define AUTOCONF_INCLUDED\n",
  636. sym_get_string_value(sym), ctime(&now));
  637. for_all_symbols(i, sym) {
  638. sym_calc_value(sym);
  639. if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
  640. continue;
  641. switch (sym->type) {
  642. case S_BOOLEAN:
  643. case S_TRISTATE:
  644. switch (sym_get_tristate_value(sym)) {
  645. case no:
  646. break;
  647. case mod:
  648. fprintf(out, "CONFIG_%s=m\n", sym->name);
  649. fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
  650. break;
  651. case yes:
  652. fprintf(out, "CONFIG_%s=y\n", sym->name);
  653. fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
  654. break;
  655. }
  656. break;
  657. case S_STRING:
  658. str = sym_get_string_value(sym);
  659. fprintf(out, "CONFIG_%s=\"", sym->name);
  660. fprintf(out_h, "#define CONFIG_%s \"", sym->name);
  661. while (1) {
  662. l = strcspn(str, "\"\\");
  663. if (l) {
  664. fwrite(str, l, 1, out);
  665. fwrite(str, l, 1, out_h);
  666. str += l;
  667. }
  668. if (!*str)
  669. break;
  670. fprintf(out, "\\%c", *str);
  671. fprintf(out_h, "\\%c", *str);
  672. str++;
  673. }
  674. fputs("\"\n", out);
  675. fputs("\"\n", out_h);
  676. break;
  677. case S_HEX:
  678. str = sym_get_string_value(sym);
  679. if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
  680. fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
  681. fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
  682. break;
  683. }
  684. case S_INT:
  685. str = sym_get_string_value(sym);
  686. fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
  687. fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
  688. break;
  689. default:
  690. break;
  691. }
  692. }
  693. fclose(out);
  694. fclose(out_h);
  695. name = getenv("KCONFIG_AUTOHEADER");
  696. if (!name)
  697. name = "include/linux/autoconf.h";
  698. if (rename(".tmpconfig.h", name))
  699. return 1;
  700. name = getenv("KCONFIG_AUTOCONFIG");
  701. if (!name)
  702. name = "include/config/auto.conf";
  703. /*
  704. * This must be the last step, kbuild has a dependency on auto.conf
  705. * and this marks the successful completion of the previous steps.
  706. */
  707. if (rename(".tmpconfig", name))
  708. return 1;
  709. return 0;
  710. }
  711. static int sym_change_count;
  712. static void (*conf_changed_callback)(void);
  713. void sym_set_change_count(int count)
  714. {
  715. int _sym_change_count = sym_change_count;
  716. sym_change_count = count;
  717. if (conf_changed_callback &&
  718. (bool)_sym_change_count != (bool)count)
  719. conf_changed_callback();
  720. }
  721. void sym_add_change_count(int count)
  722. {
  723. sym_set_change_count(count + sym_change_count);
  724. }
  725. bool conf_get_changed(void)
  726. {
  727. return sym_change_count;
  728. }
  729. void conf_set_changed_callback(void (*fn)(void))
  730. {
  731. conf_changed_callback = fn;
  732. }