confdata.c 17.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
/*
 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
 * Released under the terms of the GNU GPL v2.0.
 */

#include <sys/stat.h>
#include <ctype.h>
8
#include <fcntl.h>
Linus Torvalds's avatar
Linus Torvalds committed
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define LKC_DIRECT_LINK
#include "lkc.h"

18
19
20
21
22
23
static void conf_warning(const char *fmt, ...)
	__attribute__ ((format (printf, 1, 2)));

static const char *conf_filename;
static int conf_lineno, conf_warnings, conf_unsaved;

Linus Torvalds's avatar
Linus Torvalds committed
24
25
const char conf_defname[] = "arch/$ARCH/defconfig";

26
27
28
29
30
31
32
33
34
35
36
static void conf_warning(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);
	conf_warnings++;
}

37
38
39
40
41
42
43
const char *conf_get_configname(void)
{
	char *name = getenv("KCONFIG_CONFIG");

	return name ? name : ".config";
}

J.A. Magallon's avatar
J.A. Magallon committed
44
static char *conf_expand_value(const char *in)
Linus Torvalds's avatar
Linus Torvalds committed
45
46
{
	struct symbol *sym;
J.A. Magallon's avatar
J.A. Magallon committed
47
	const char *src;
Linus Torvalds's avatar
Linus Torvalds committed
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
	static char res_value[SYMBOL_MAXLENGTH];
	char *dst, name[SYMBOL_MAXLENGTH];

	res_value[0] = 0;
	dst = name;
	while ((src = strchr(in, '$'))) {
		strncat(res_value, in, src - in);
		src++;
		dst = name;
		while (isalnum(*src) || *src == '_')
			*dst++ = *src++;
		*dst = 0;
		sym = sym_lookup(name, 0);
		sym_calc_value(sym);
		strcat(res_value, sym_get_string_value(sym));
		in = src;
	}
	strcat(res_value, in);

	return res_value;
}

char *conf_get_default_confname(void)
{
	struct stat buf;
	static char fullname[PATH_MAX+1];
	char *env, *name;

	name = conf_expand_value(conf_defname);
	env = getenv(SRCTREE);
	if (env) {
		sprintf(fullname, "%s/%s", env, name);
		if (!stat(fullname, &buf))
			return fullname;
	}
	return name;
}

86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
{
	char *p2;

	switch (sym->type) {
	case S_TRISTATE:
		if (p[0] == 'm') {
			sym->def[def].tri = mod;
			sym->flags |= def_flags;
			break;
		}
	case S_BOOLEAN:
		if (p[0] == 'y') {
			sym->def[def].tri = yes;
			sym->flags |= def_flags;
			break;
		}
		if (p[0] == 'n') {
			sym->def[def].tri = no;
			sym->flags |= def_flags;
			break;
		}
		conf_warning("symbol value '%s' invalid for %s", p, sym->name);
		break;
	case S_OTHER:
		if (*p != '"') {
			for (p2 = p; *p2 && !isspace(*p2); p2++)
				;
			sym->type = S_STRING;
			goto done;
		}
	case S_STRING:
		if (*p++ != '"')
			break;
		for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
			if (*p2 == '"') {
				*p2 = 0;
				break;
			}
			memmove(p2, p2 + 1, strlen(p2));
		}
		if (!p2) {
			conf_warning("invalid string found");
			return 1;
		}
	case S_INT:
	case S_HEX:
	done:
		if (sym_string_valid(sym, p)) {
			sym->def[def].val = strdup(p);
			sym->flags |= def_flags;
		} else {
			conf_warning("symbol value '%s' invalid for %s", p, sym->name);
			return 1;
		}
		break;
	default:
		;
	}
	return 0;
}

148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
/* Read an environment variable and assign the value to the symbol */
int conf_set_env_sym(const char *env, const char *symname, int def)
{
	struct symbol *sym;
	char *p;
	int def_flags;

	p = getenv(env);
	if (p) {
		char warning[200];
		sprintf(warning, "Environment variable (%s = \"%s\")", env, p);
		conf_filename = warning;
		def_flags = SYMBOL_DEF << def;
		if (def == S_DEF_USER) {
			sym = sym_find(symname);
			if (!sym)
				return 1;
		} else {
			sym = sym_lookup(symname, 0);
			if (sym->type == S_UNKNOWN)
				sym->type = S_OTHER;
		}
		conf_set_sym_val(sym, def, def_flags, p);
	}
	return 0;
}

175
int conf_read_simple(const char *name, int def)
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
{
	FILE *in = NULL;
	char line[1024];
	char *p, *p2;
	struct symbol *sym;
181
	int i, def_flags;
Linus Torvalds's avatar
Linus Torvalds committed
182
183
184
185

	if (name) {
		in = zconf_fopen(name);
	} else {
186
187
		struct property *prop;

188
		name = conf_get_configname();
189
190
191
		in = zconf_fopen(name);
		if (in)
			goto load;
192
		sym_add_change_count(1);
193
194
195
196
197
198
199
200
		if (!sym_defconfig_list)
			return 1;

		for_all_defaults(sym_defconfig_list, prop) {
			if (expr_calc_value(prop->visible.expr) == no ||
			    prop->expr->type != E_SYMBOL)
				continue;
			name = conf_expand_value(prop->expr->left.sym->name);
Linus Torvalds's avatar
Linus Torvalds committed
201
202
			in = zconf_fopen(name);
			if (in) {
203
				printf(_("#\n"
204
205
206
					 "# using defaults found in %s\n"
					 "#\n"), name);
				goto load;
Linus Torvalds's avatar
Linus Torvalds committed
207
208
209
210
211
212
			}
		}
	}
	if (!in)
		return 1;

213
load:
214
215
216
217
218
	conf_filename = name;
	conf_lineno = 0;
	conf_warnings = 0;
	conf_unsaved = 0;

219
	def_flags = SYMBOL_DEF << def;
Linus Torvalds's avatar
Linus Torvalds committed
220
	for_all_symbols(i, sym) {
221
222
		sym->flags |= SYMBOL_CHANGED;
		sym->flags &= ~(def_flags|SYMBOL_VALID);
223
		if (sym_is_choice(sym))
224
			sym->flags |= def_flags;
Linus Torvalds's avatar
Linus Torvalds committed
225
226
227
228
		switch (sym->type) {
		case S_INT:
		case S_HEX:
		case S_STRING:
229
230
			if (sym->def[def].val)
				free(sym->def[def].val);
Linus Torvalds's avatar
Linus Torvalds committed
231
		default:
232
233
			sym->def[def].val = NULL;
			sym->def[def].tri = no;
Linus Torvalds's avatar
Linus Torvalds committed
234
235
236
237
		}
	}

	while (fgets(line, sizeof(line), in)) {
238
		conf_lineno++;
Linus Torvalds's avatar
Linus Torvalds committed
239
240
241
242
243
244
245
246
247
248
249
		sym = NULL;
		switch (line[0]) {
		case '#':
			if (memcmp(line + 2, "CONFIG_", 7))
				continue;
			p = strchr(line + 9, ' ');
			if (!p)
				continue;
			*p++ = 0;
			if (strncmp(p, "is not set", 10))
				continue;
250
251
252
253
254
255
256
257
258
259
260
261
			if (def == S_DEF_USER) {
				sym = sym_find(line + 9);
				if (!sym) {
					conf_warning("trying to assign nonexistent symbol %s", line + 9);
					break;
				}
			} else {
				sym = sym_lookup(line + 9, 0);
				if (sym->type == S_UNKNOWN)
					sym->type = S_BOOLEAN;
			}
			if (sym->flags & def_flags) {
262
				conf_warning("trying to reassign symbol %s", sym->name);
Linus Torvalds's avatar
Linus Torvalds committed
263
264
265
266
267
				break;
			}
			switch (sym->type) {
			case S_BOOLEAN:
			case S_TRISTATE:
268
269
				sym->def[def].tri = no;
				sym->flags |= def_flags;
Linus Torvalds's avatar
Linus Torvalds committed
270
271
272
273
274
275
				break;
			default:
				;
			}
			break;
		case 'C':
276
277
			if (memcmp(line, "CONFIG_", 7)) {
				conf_warning("unexpected data");
Linus Torvalds's avatar
Linus Torvalds committed
278
				continue;
279
			}
Linus Torvalds's avatar
Linus Torvalds committed
280
281
282
283
284
			p = strchr(line + 7, '=');
			if (!p)
				continue;
			*p++ = 0;
			p2 = strchr(p, '\n');
285
286
287
288
289
			if (p2) {
				*p2-- = 0;
				if (*p2 == '\r')
					*p2 = 0;
			}
290
291
292
293
294
295
296
297
298
299
300
301
			if (def == S_DEF_USER) {
				sym = sym_find(line + 7);
				if (!sym) {
					conf_warning("trying to assign nonexistent symbol %s", line + 7);
					break;
				}
			} else {
				sym = sym_lookup(line + 7, 0);
				if (sym->type == S_UNKNOWN)
					sym->type = S_OTHER;
			}
			if (sym->flags & def_flags) {
302
				conf_warning("trying to reassign symbol %s", sym->name);
Linus Torvalds's avatar
Linus Torvalds committed
303
304
				break;
			}
305
306
			if (conf_set_sym_val(sym, def, def_flags, p))
				continue;
Linus Torvalds's avatar
Linus Torvalds committed
307
			break;
308
		case '\r':
Linus Torvalds's avatar
Linus Torvalds committed
309
310
311
		case '\n':
			break;
		default:
312
			conf_warning("unexpected data");
Linus Torvalds's avatar
Linus Torvalds committed
313
314
315
316
			continue;
		}
		if (sym && sym_is_choice_value(sym)) {
			struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
317
			switch (sym->def[def].tri) {
Linus Torvalds's avatar
Linus Torvalds committed
318
319
320
			case no:
				break;
			case mod:
321
				if (cs->def[def].tri == yes) {
322
					conf_warning("%s creates inconsistent choice state", sym->name);
323
					cs->flags &= ~def_flags;
324
				}
Linus Torvalds's avatar
Linus Torvalds committed
325
326
				break;
			case yes:
327
				if (cs->def[def].tri != no) {
328
					conf_warning("%s creates inconsistent choice state", sym->name);
329
					cs->flags &= ~def_flags;
330
				} else
331
					cs->def[def].val = sym;
Linus Torvalds's avatar
Linus Torvalds committed
332
333
				break;
			}
334
			cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);
Linus Torvalds's avatar
Linus Torvalds committed
335
336
337
338
339
340
		}
	}
	fclose(in);

	if (modules_sym)
		sym_calc_value(modules_sym);
341
342
343
344
345
346
347
348
	return 0;
}

int conf_read(const char *name)
{
	struct symbol *sym;
	struct property *prop;
	struct expr *e;
349
	int i, flags;
350

351
	sym_set_change_count(0);
352

353
	if (conf_read_simple(name, S_DEF_USER))
354
355
		return 1;

Linus Torvalds's avatar
Linus Torvalds committed
356
357
	for_all_symbols(i, sym) {
		sym_calc_value(sym);
358
359
360
361
362
363
364
		if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
			goto sym_ok;
		if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
			/* check that calculated value agrees with saved value */
			switch (sym->type) {
			case S_BOOLEAN:
			case S_TRISTATE:
365
				if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
366
367
368
369
					break;
				if (!sym_is_choice(sym))
					goto sym_ok;
			default:
370
				if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
371
372
373
374
375
376
377
378
379
					goto sym_ok;
				break;
			}
		} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
			/* no previous value and not saved */
			goto sym_ok;
		conf_unsaved++;
		/* maybe print value in verbose mode... */
	sym_ok:
380
381
382
383
384
385
386
387
388
389
390
391
392
393
		if (!sym_is_choice(sym))
			continue;
		/* The choice symbol only has a set value (and thus is not new)
		 * if all its visible childs have values.
		 */
		prop = sym_get_choice_prop(sym);
		flags = sym->flags;
		for (e = prop->expr; e; e = e->left.expr)
			if (e->right.sym->visible != no)
				flags &= e->right.sym->flags;
		sym->flags &= flags | ~SYMBOL_DEF_USER;
	}

	for_all_symbols(i, sym) {
Linus Torvalds's avatar
Linus Torvalds committed
394
		if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
395
396
397
398
399
400
			/* Reset values of generates values, so they'll appear
			 * as new, if they should become visible, but that
			 * doesn't quite work if the Kconfig and the saved
			 * configuration disagree.
			 */
			if (sym->visible == no && !conf_unsaved)
401
				sym->flags &= ~SYMBOL_DEF_USER;
Linus Torvalds's avatar
Linus Torvalds committed
402
403
404
405
			switch (sym->type) {
			case S_STRING:
			case S_INT:
			case S_HEX:
406
407
408
409
410
411
				/* Reset a string value if it's out of range */
				if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
					break;
				sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
				conf_unsaved++;
				break;
Linus Torvalds's avatar
Linus Torvalds committed
412
413
414
415
416
417
			default:
				break;
			}
		}
	}

418
	sym_add_change_count(conf_warnings || conf_unsaved);
Linus Torvalds's avatar
Linus Torvalds committed
419
420
421
422
423
424

	return 0;
}

int conf_write(const char *name)
{
425
	FILE *out;
Linus Torvalds's avatar
Linus Torvalds committed
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
	struct symbol *sym;
	struct menu *menu;
	const char *basename;
	char dirname[128], tmpname[128], newname[128];
	int type, l;
	const char *str;
	time_t now;
	int use_timestamp = 1;
	char *env;

	dirname[0] = 0;
	if (name && name[0]) {
		struct stat st;
		char *slash;

		if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
			strcpy(dirname, name);
			strcat(dirname, "/");
444
			basename = conf_get_configname();
Linus Torvalds's avatar
Linus Torvalds committed
445
446
447
448
449
450
451
		} else if ((slash = strrchr(name, '/'))) {
			int size = slash - name + 1;
			memcpy(dirname, name, size);
			dirname[size] = 0;
			if (slash[1])
				basename = slash + 1;
			else
452
				basename = conf_get_configname();
Linus Torvalds's avatar
Linus Torvalds committed
453
454
455
		} else
			basename = name;
	} else
456
		basename = conf_get_configname();
Linus Torvalds's avatar
Linus Torvalds committed
457

458
459
460
461
462
463
464
465
466
	sprintf(newname, "%s%s", dirname, basename);
	env = getenv("KCONFIG_OVERWRITECONFIG");
	if (!env || !*env) {
		sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
		out = fopen(tmpname, "w");
	} else {
		*tmpname = 0;
		out = fopen(newname, "w");
	}
Linus Torvalds's avatar
Linus Torvalds committed
467
468
	if (!out)
		return 1;
469

470
	sym = sym_lookup("KERNELVERSION", 0);
Linus Torvalds's avatar
Linus Torvalds committed
471
472
473
474
475
476
	sym_calc_value(sym);
	time(&now);
	env = getenv("KCONFIG_NOTIMESTAMP");
	if (env && *env)
		use_timestamp = 0;

477
478
479
480
481
	fprintf(out, _("#\n"
		       "# Automatically generated make config: don't edit\n"
		       "# Linux kernel version: %s\n"
		       "%s%s"
		       "#\n"),
Linus Torvalds's avatar
Linus Torvalds committed
482
483
484
485
		     sym_get_string_value(sym),
		     use_timestamp ? "# " : "",
		     use_timestamp ? ctime(&now) : "");

486
	if (!conf_get_changed())
Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
		sym_clear_all_valid();

	menu = rootmenu.list;
	while (menu) {
		sym = menu->sym;
		if (!sym) {
			if (!menu_is_visible(menu))
				goto next;
			str = menu_get_prompt(menu);
			fprintf(out, "\n"
				     "#\n"
				     "# %s\n"
				     "#\n", str);
		} else if (!(sym->flags & SYMBOL_CHOICE)) {
			sym_calc_value(sym);
			if (!(sym->flags & SYMBOL_WRITE))
				goto next;
			sym->flags &= ~SYMBOL_WRITE;
			type = sym->type;
			if (type == S_TRISTATE) {
				sym_calc_value(modules_sym);
				if (modules_sym->curr.tri == no)
					type = S_BOOLEAN;
			}
			switch (type) {
			case S_BOOLEAN:
			case S_TRISTATE:
				switch (sym_get_tristate_value(sym)) {
				case no:
					fprintf(out, "# CONFIG_%s is not set\n", sym->name);
					break;
				case mod:
					fprintf(out, "CONFIG_%s=m\n", sym->name);
					break;
				case yes:
					fprintf(out, "CONFIG_%s=y\n", sym->name);
					break;
				}
				break;
			case S_STRING:
				str = sym_get_string_value(sym);
				fprintf(out, "CONFIG_%s=\"", sym->name);
529
				while (1) {
Linus Torvalds's avatar
Linus Torvalds committed
530
531
532
					l = strcspn(str, "\"\\");
					if (l) {
						fwrite(str, l, 1, out);
533
						str += l;
Linus Torvalds's avatar
Linus Torvalds committed
534
					}
535
536
537
538
					if (!*str)
						break;
					fprintf(out, "\\%c", *str++);
				}
Linus Torvalds's avatar
Linus Torvalds committed
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
				fputs("\"\n", out);
				break;
			case S_HEX:
				str = sym_get_string_value(sym);
				if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
					fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
					break;
				}
			case S_INT:
				str = sym_get_string_value(sym);
				fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
				break;
			}
		}

	next:
		if (menu->list) {
			menu = menu->list;
			continue;
		}
		if (menu->next)
			menu = menu->next;
		else while ((menu = menu->parent)) {
			if (menu->next) {
				menu = menu->next;
				break;
			}
		}
	}
	fclose(out);
569
570

	if (*tmpname) {
571
		strcat(dirname, basename);
572
573
574
575
		strcat(dirname, ".old");
		rename(newname, dirname);
		if (rename(tmpname, newname))
			return 1;
Linus Torvalds's avatar
Linus Torvalds committed
576
577
	}

578
579
	printf(_("#\n"
		 "# configuration written to %s\n"
580
		 "#\n"), newname);
581

582
	sym_set_change_count(0);
Linus Torvalds's avatar
Linus Torvalds committed
583
584
585

	return 0;
}
586

587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
int conf_split_config(void)
{
	char *name, path[128];
	char *s, *d, c;
	struct symbol *sym;
	struct stat sb;
	int res, i, fd;

	name = getenv("KCONFIG_AUTOCONFIG");
	if (!name)
		name = "include/config/auto.conf";
	conf_read_simple(name, S_DEF_AUTO);

	if (chdir("include/config"))
		return 1;

	res = 0;
	for_all_symbols(i, sym) {
		sym_calc_value(sym);
		if ((sym->flags & SYMBOL_AUTO) || !sym->name)
			continue;
		if (sym->flags & SYMBOL_WRITE) {
			if (sym->flags & SYMBOL_DEF_AUTO) {
				/*
				 * symbol has old and new value,
				 * so compare them...
				 */
				switch (sym->type) {
				case S_BOOLEAN:
				case S_TRISTATE:
					if (sym_get_tristate_value(sym) ==
					    sym->def[S_DEF_AUTO].tri)
						continue;
					break;
				case S_STRING:
				case S_HEX:
				case S_INT:
					if (!strcmp(sym_get_string_value(sym),
						    sym->def[S_DEF_AUTO].val))
						continue;
					break;
				default:
					break;
				}
			} else {
				/*
				 * If there is no old value, only 'no' (unset)
				 * is allowed as new value.
				 */
				switch (sym->type) {
				case S_BOOLEAN:
				case S_TRISTATE:
					if (sym_get_tristate_value(sym) == no)
						continue;
					break;
				default:
					break;
				}
			}
		} else if (!(sym->flags & SYMBOL_DEF_AUTO))
			/* There is neither an old nor a new value. */
			continue;
		/* else
		 *	There is an old value, but no new value ('no' (unset)
		 *	isn't saved in auto.conf, so the old value is always
		 *	different from 'no').
		 */

		/* Replace all '_' and append ".h" */
		s = sym->name;
		d = path;
		while ((c = *s++)) {
			c = tolower(c);
			*d++ = (c == '_') ? '/' : c;
		}
		strcpy(d, ".h");

		/* Assume directory path already exists. */
		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
		if (fd == -1) {
			if (errno != ENOENT) {
				res = 1;
				break;
			}
			/*
			 * Create directory components,
			 * unless they exist already.
			 */
			d = path;
			while ((d = strchr(d, '/'))) {
				*d = 0;
				if (stat(path, &sb) && mkdir(path, 0755)) {
					res = 1;
					goto out;
				}
				*d++ = '/';
			}
			/* Try it again. */
			fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
			if (fd == -1) {
				res = 1;
				break;
			}
		}
		close(fd);
	}
out:
	if (chdir("../.."))
		return 1;

	return res;
}

700
701
702
703
704
705
706
707
708
int conf_write_autoconf(void)
{
	struct symbol *sym;
	const char *str;
	char *name;
	FILE *out, *out_h;
	time_t now;
	int i, l;

709
710
	sym_clear_all_valid();

711
712
	file_write_dep("include/config/auto.conf.cmd");

713
714
715
	if (conf_split_config())
		return 1;

716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
	out = fopen(".tmpconfig", "w");
	if (!out)
		return 1;

	out_h = fopen(".tmpconfig.h", "w");
	if (!out_h) {
		fclose(out);
		return 1;
	}

	sym = sym_lookup("KERNELVERSION", 0);
	sym_calc_value(sym);
	time(&now);
	fprintf(out, "#\n"
		     "# Automatically generated make config: don't edit\n"
		     "# Linux kernel version: %s\n"
		     "# %s"
		     "#\n",
		     sym_get_string_value(sym), ctime(&now));
	fprintf(out_h, "/*\n"
		       " * Automatically generated C config: don't edit\n"
		       " * Linux kernel version: %s\n"
		       " * %s"
		       " */\n"
		       "#define AUTOCONF_INCLUDED\n",
		       sym_get_string_value(sym), ctime(&now));

	for_all_symbols(i, sym) {
		sym_calc_value(sym);
		if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
			continue;
		switch (sym->type) {
		case S_BOOLEAN:
		case S_TRISTATE:
			switch (sym_get_tristate_value(sym)) {
			case no:
				break;
			case mod:
				fprintf(out, "CONFIG_%s=m\n", sym->name);
				fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
				break;
			case yes:
				fprintf(out, "CONFIG_%s=y\n", sym->name);
				fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
				break;
			}
			break;
		case S_STRING:
			str = sym_get_string_value(sym);
			fprintf(out, "CONFIG_%s=\"", sym->name);
			fprintf(out_h, "#define CONFIG_%s \"", sym->name);
			while (1) {
				l = strcspn(str, "\"\\");
				if (l) {
					fwrite(str, l, 1, out);
					fwrite(str, l, 1, out_h);
					str += l;
				}
				if (!*str)
					break;
				fprintf(out, "\\%c", *str);
				fprintf(out_h, "\\%c", *str);
				str++;
			}
			fputs("\"\n", out);
			fputs("\"\n", out_h);
			break;
		case S_HEX:
			str = sym_get_string_value(sym);
			if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
				fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
				fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
				break;
			}
		case S_INT:
			str = sym_get_string_value(sym);
			fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
			fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
			break;
		default:
			break;
		}
	}
	fclose(out);
	fclose(out_h);

	name = getenv("KCONFIG_AUTOHEADER");
	if (!name)
		name = "include/linux/autoconf.h";
	if (rename(".tmpconfig.h", name))
		return 1;
	name = getenv("KCONFIG_AUTOCONFIG");
	if (!name)
		name = "include/config/auto.conf";
	/*
	 * This must be the last step, kbuild has a dependency on auto.conf
	 * and this marks the successful completion of the previous steps.
	 */
	if (rename(".tmpconfig", name))
		return 1;

	return 0;
}
819

820
static int sym_change_count;
821
static void (*conf_changed_callback)(void);
822
823
824

void sym_set_change_count(int count)
{
825
	int _sym_change_count = sym_change_count;
826
	sym_change_count = count;
827
828
829
	if (conf_changed_callback &&
	    (bool)_sym_change_count != (bool)count)
		conf_changed_callback();
830
831
832
833
}

void sym_add_change_count(int count)
{
834
	sym_set_change_count(count + sym_change_count);
835
836
}

837
838
839
840
bool conf_get_changed(void)
{
	return sym_change_count;
}
841
842
843
844
845

void conf_set_changed_callback(void (*fn)(void))
{
	conf_changed_callback = fn;
}