xref: /openbmc/linux/scripts/kconfig/conf.c (revision 6f69e2a3) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
4  */
5 
6 #include <ctype.h>
7 #include <limits.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <time.h>
12 #include <unistd.h>
13 #include <getopt.h>
14 #include <sys/stat.h>
15 #include <sys/time.h>
16 #include <errno.h>
17 
18 #include "lkc.h"
19 
20 static void conf(struct menu *menu);
21 static void check_conf(struct menu *menu);
22 
23 enum input_mode {
24 	oldaskconfig,
25 	syncconfig,
26 	oldconfig,
27 	allnoconfig,
28 	allyesconfig,
29 	allmodconfig,
30 	alldefconfig,
31 	randconfig,
32 	defconfig,
33 	savedefconfig,
34 	listnewconfig,
35 	helpnewconfig,
36 	olddefconfig,
37 };
38 static enum input_mode input_mode = oldaskconfig;
39 
40 static int indent = 1;
41 static int tty_stdio;
42 static int sync_kconfig;
43 static int conf_cnt;
44 static char line[PATH_MAX];
45 static struct menu *rootEntry;
46 
47 static void print_help(struct menu *menu)
48 {
49 	struct gstr help = str_new();
50 
51 	menu_get_ext_help(menu, &help);
52 
53 	printf("\n%s\n", str_get(&help));
54 	str_free(&help);
55 }
56 
57 static void strip(char *str)
58 {
59 	char *p = str;
60 	int l;
61 
62 	while ((isspace(*p)))
63 		p++;
64 	l = strlen(p);
65 	if (p != str)
66 		memmove(str, p, l + 1);
67 	if (!l)
68 		return;
69 	p = str + l - 1;
70 	while ((isspace(*p)))
71 		*p-- = 0;
72 }
73 
74 /* Helper function to facilitate fgets() by Jean Sacren. */
75 static void xfgets(char *str, int size, FILE *in)
76 {
77 	if (!fgets(str, size, in))
78 		fprintf(stderr, "\nError in reading or end of file.\n");
79 
80 	if (!tty_stdio)
81 		printf("%s", str);
82 }
83 
84 static int conf_askvalue(struct symbol *sym, const char *def)
85 {
86 	enum symbol_type type = sym_get_type(sym);
87 
88 	if (!sym_has_value(sym))
89 		printf("(NEW) ");
90 
91 	line[0] = '\n';
92 	line[1] = 0;
93 
94 	if (!sym_is_changeable(sym)) {
95 		printf("%s\n", def);
96 		line[0] = '\n';
97 		line[1] = 0;
98 		return 0;
99 	}
100 
101 	switch (input_mode) {
102 	case oldconfig:
103 	case syncconfig:
104 		if (sym_has_value(sym)) {
105 			printf("%s\n", def);
106 			return 0;
107 		}
108 		/* fall through */
109 	case oldaskconfig:
110 		fflush(stdout);
111 		xfgets(line, sizeof(line), stdin);
112 		return 1;
113 	default:
114 		break;
115 	}
116 
117 	switch (type) {
118 	case S_INT:
119 	case S_HEX:
120 	case S_STRING:
121 		printf("%s\n", def);
122 		return 1;
123 	default:
124 		;
125 	}
126 	printf("%s", line);
127 	return 1;
128 }
129 
130 static int conf_string(struct menu *menu)
131 {
132 	struct symbol *sym = menu->sym;
133 	const char *def;
134 
135 	while (1) {
136 		printf("%*s%s ", indent - 1, "", menu->prompt->text);
137 		printf("(%s) ", sym->name);
138 		def = sym_get_string_value(sym);
139 		if (sym_get_string_value(sym))
140 			printf("[%s] ", def);
141 		if (!conf_askvalue(sym, def))
142 			return 0;
143 		switch (line[0]) {
144 		case '\n':
145 			break;
146 		case '?':
147 			/* print help */
148 			if (line[1] == '\n') {
149 				print_help(menu);
150 				def = NULL;
151 				break;
152 			}
153 			/* fall through */
154 		default:
155 			line[strlen(line)-1] = 0;
156 			def = line;
157 		}
158 		if (def && sym_set_string_value(sym, def))
159 			return 0;
160 	}
161 }
162 
163 static int conf_sym(struct menu *menu)
164 {
165 	struct symbol *sym = menu->sym;
166 	tristate oldval, newval;
167 
168 	while (1) {
169 		printf("%*s%s ", indent - 1, "", menu->prompt->text);
170 		if (sym->name)
171 			printf("(%s) ", sym->name);
172 		putchar('[');
173 		oldval = sym_get_tristate_value(sym);
174 		switch (oldval) {
175 		case no:
176 			putchar('N');
177 			break;
178 		case mod:
179 			putchar('M');
180 			break;
181 		case yes:
182 			putchar('Y');
183 			break;
184 		}
185 		if (oldval != no && sym_tristate_within_range(sym, no))
186 			printf("/n");
187 		if (oldval != mod && sym_tristate_within_range(sym, mod))
188 			printf("/m");
189 		if (oldval != yes && sym_tristate_within_range(sym, yes))
190 			printf("/y");
191 		printf("/?] ");
192 		if (!conf_askvalue(sym, sym_get_string_value(sym)))
193 			return 0;
194 		strip(line);
195 
196 		switch (line[0]) {
197 		case 'n':
198 		case 'N':
199 			newval = no;
200 			if (!line[1] || !strcmp(&line[1], "o"))
201 				break;
202 			continue;
203 		case 'm':
204 		case 'M':
205 			newval = mod;
206 			if (!line[1])
207 				break;
208 			continue;
209 		case 'y':
210 		case 'Y':
211 			newval = yes;
212 			if (!line[1] || !strcmp(&line[1], "es"))
213 				break;
214 			continue;
215 		case 0:
216 			newval = oldval;
217 			break;
218 		case '?':
219 			goto help;
220 		default:
221 			continue;
222 		}
223 		if (sym_set_tristate_value(sym, newval))
224 			return 0;
225 help:
226 		print_help(menu);
227 	}
228 }
229 
230 static int conf_choice(struct menu *menu)
231 {
232 	struct symbol *sym, *def_sym;
233 	struct menu *child;
234 	bool is_new;
235 
236 	sym = menu->sym;
237 	is_new = !sym_has_value(sym);
238 	if (sym_is_changeable(sym)) {
239 		conf_sym(menu);
240 		sym_calc_value(sym);
241 		switch (sym_get_tristate_value(sym)) {
242 		case no:
243 			return 1;
244 		case mod:
245 			return 0;
246 		case yes:
247 			break;
248 		}
249 	} else {
250 		switch (sym_get_tristate_value(sym)) {
251 		case no:
252 			return 1;
253 		case mod:
254 			printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
255 			return 0;
256 		case yes:
257 			break;
258 		}
259 	}
260 
261 	while (1) {
262 		int cnt, def;
263 
264 		printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
265 		def_sym = sym_get_choice_value(sym);
266 		cnt = def = 0;
267 		line[0] = 0;
268 		for (child = menu->list; child; child = child->next) {
269 			if (!menu_is_visible(child))
270 				continue;
271 			if (!child->sym) {
272 				printf("%*c %s\n", indent, '*', menu_get_prompt(child));
273 				continue;
274 			}
275 			cnt++;
276 			if (child->sym == def_sym) {
277 				def = cnt;
278 				printf("%*c", indent, '>');
279 			} else
280 				printf("%*c", indent, ' ');
281 			printf(" %d. %s", cnt, menu_get_prompt(child));
282 			if (child->sym->name)
283 				printf(" (%s)", child->sym->name);
284 			if (!sym_has_value(child->sym))
285 				printf(" (NEW)");
286 			printf("\n");
287 		}
288 		printf("%*schoice", indent - 1, "");
289 		if (cnt == 1) {
290 			printf("[1]: 1\n");
291 			goto conf_childs;
292 		}
293 		printf("[1-%d?]: ", cnt);
294 		switch (input_mode) {
295 		case oldconfig:
296 		case syncconfig:
297 			if (!is_new) {
298 				cnt = def;
299 				printf("%d\n", cnt);
300 				break;
301 			}
302 			/* fall through */
303 		case oldaskconfig:
304 			fflush(stdout);
305 			xfgets(line, sizeof(line), stdin);
306 			strip(line);
307 			if (line[0] == '?') {
308 				print_help(menu);
309 				continue;
310 			}
311 			if (!line[0])
312 				cnt = def;
313 			else if (isdigit(line[0]))
314 				cnt = atoi(line);
315 			else
316 				continue;
317 			break;
318 		default:
319 			break;
320 		}
321 
322 	conf_childs:
323 		for (child = menu->list; child; child = child->next) {
324 			if (!child->sym || !menu_is_visible(child))
325 				continue;
326 			if (!--cnt)
327 				break;
328 		}
329 		if (!child)
330 			continue;
331 		if (line[0] && line[strlen(line) - 1] == '?') {
332 			print_help(child);
333 			continue;
334 		}
335 		sym_set_choice_value(sym, child->sym);
336 		for (child = child->list; child; child = child->next) {
337 			indent += 2;
338 			conf(child);
339 			indent -= 2;
340 		}
341 		return 1;
342 	}
343 }
344 
345 static void conf(struct menu *menu)
346 {
347 	struct symbol *sym;
348 	struct property *prop;
349 	struct menu *child;
350 
351 	if (!menu_is_visible(menu))
352 		return;
353 
354 	sym = menu->sym;
355 	prop = menu->prompt;
356 	if (prop) {
357 		const char *prompt;
358 
359 		switch (prop->type) {
360 		case P_MENU:
361 			/*
362 			 * Except in oldaskconfig mode, we show only menus that
363 			 * contain new symbols.
364 			 */
365 			if (input_mode != oldaskconfig && rootEntry != menu) {
366 				check_conf(menu);
367 				return;
368 			}
369 			/* fall through */
370 		case P_COMMENT:
371 			prompt = menu_get_prompt(menu);
372 			if (prompt)
373 				printf("%*c\n%*c %s\n%*c\n",
374 					indent, '*',
375 					indent, '*', prompt,
376 					indent, '*');
377 		default:
378 			;
379 		}
380 	}
381 
382 	if (!sym)
383 		goto conf_childs;
384 
385 	if (sym_is_choice(sym)) {
386 		conf_choice(menu);
387 		if (sym->curr.tri != mod)
388 			return;
389 		goto conf_childs;
390 	}
391 
392 	switch (sym->type) {
393 	case S_INT:
394 	case S_HEX:
395 	case S_STRING:
396 		conf_string(menu);
397 		break;
398 	default:
399 		conf_sym(menu);
400 		break;
401 	}
402 
403 conf_childs:
404 	if (sym)
405 		indent += 2;
406 	for (child = menu->list; child; child = child->next)
407 		conf(child);
408 	if (sym)
409 		indent -= 2;
410 }
411 
412 static void check_conf(struct menu *menu)
413 {
414 	struct symbol *sym;
415 	struct menu *child;
416 
417 	if (!menu_is_visible(menu))
418 		return;
419 
420 	sym = menu->sym;
421 	if (sym && !sym_has_value(sym)) {
422 		if (sym_is_changeable(sym) ||
423 		    (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)) {
424 			if (input_mode == listnewconfig) {
425 				if (sym->name) {
426 					const char *str;
427 
428 					if (sym->type == S_STRING) {
429 						str = sym_get_string_value(sym);
430 						str = sym_escape_string_value(str);
431 						printf("%s%s=%s\n", CONFIG_, sym->name, str);
432 						free((void *)str);
433 					} else {
434 						str = sym_get_string_value(sym);
435 						printf("%s%s=%s\n", CONFIG_, sym->name, str);
436 					}
437 				}
438 			} else if (input_mode == helpnewconfig) {
439 				printf("-----\n");
440 				print_help(menu);
441 				printf("-----\n");
442 
443 			} else {
444 				if (!conf_cnt++)
445 					printf("*\n* Restart config...\n*\n");
446 				rootEntry = menu_get_parent_menu(menu);
447 				conf(rootEntry);
448 			}
449 		}
450 	}
451 
452 	for (child = menu->list; child; child = child->next)
453 		check_conf(child);
454 }
455 
456 static struct option long_opts[] = {
457 	{"oldaskconfig",    no_argument,       NULL, oldaskconfig},
458 	{"oldconfig",       no_argument,       NULL, oldconfig},
459 	{"syncconfig",      no_argument,       NULL, syncconfig},
460 	{"defconfig",       required_argument, NULL, defconfig},
461 	{"savedefconfig",   required_argument, NULL, savedefconfig},
462 	{"allnoconfig",     no_argument,       NULL, allnoconfig},
463 	{"allyesconfig",    no_argument,       NULL, allyesconfig},
464 	{"allmodconfig",    no_argument,       NULL, allmodconfig},
465 	{"alldefconfig",    no_argument,       NULL, alldefconfig},
466 	{"randconfig",      no_argument,       NULL, randconfig},
467 	{"listnewconfig",   no_argument,       NULL, listnewconfig},
468 	{"helpnewconfig",   no_argument,       NULL, helpnewconfig},
469 	{"olddefconfig",    no_argument,       NULL, olddefconfig},
470 	{NULL, 0, NULL, 0}
471 };
472 
473 static void conf_usage(const char *progname)
474 {
475 
476 	printf("Usage: %s [-s] [option] <kconfig-file>\n", progname);
477 	printf("[option] is _one_ of the following:\n");
478 	printf("  --listnewconfig         List new options\n");
479 	printf("  --helpnewconfig         List new options and help text\n");
480 	printf("  --oldaskconfig          Start a new configuration using a line-oriented program\n");
481 	printf("  --oldconfig             Update a configuration using a provided .config as base\n");
482 	printf("  --syncconfig            Similar to oldconfig but generates configuration in\n"
483 	       "                          include/{generated/,config/}\n");
484 	printf("  --olddefconfig          Same as oldconfig but sets new symbols to their default value\n");
485 	printf("  --defconfig <file>      New config with default defined in <file>\n");
486 	printf("  --savedefconfig <file>  Save the minimal current configuration to <file>\n");
487 	printf("  --allnoconfig           New config where all options are answered with no\n");
488 	printf("  --allyesconfig          New config where all options are answered with yes\n");
489 	printf("  --allmodconfig          New config where all options are answered with mod\n");
490 	printf("  --alldefconfig          New config with all symbols set to default\n");
491 	printf("  --randconfig            New config with random answer to all options\n");
492 }
493 
494 int main(int ac, char **av)
495 {
496 	const char *progname = av[0];
497 	int opt;
498 	const char *name, *defconfig_file = NULL /* gcc uninit */;
499 	int no_conf_write = 0;
500 
501 	tty_stdio = isatty(0) && isatty(1);
502 
503 	while ((opt = getopt_long(ac, av, "s", long_opts, NULL)) != -1) {
504 		if (opt == 's') {
505 			conf_set_message_callback(NULL);
506 			continue;
507 		}
508 		input_mode = (enum input_mode)opt;
509 		switch (opt) {
510 		case syncconfig:
511 			/*
512 			 * syncconfig is invoked during the build stage.
513 			 * Suppress distracting "configuration written to ..."
514 			 */
515 			conf_set_message_callback(NULL);
516 			sync_kconfig = 1;
517 			break;
518 		case defconfig:
519 		case savedefconfig:
520 			defconfig_file = optarg;
521 			break;
522 		case randconfig:
523 		{
524 			struct timeval now;
525 			unsigned int seed;
526 			char *seed_env;
527 
528 			/*
529 			 * Use microseconds derived seed,
530 			 * compensate for systems where it may be zero
531 			 */
532 			gettimeofday(&now, NULL);
533 			seed = (unsigned int)((now.tv_sec + 1) * (now.tv_usec + 1));
534 
535 			seed_env = getenv("KCONFIG_SEED");
536 			if( seed_env && *seed_env ) {
537 				char *endp;
538 				int tmp = (int)strtol(seed_env, &endp, 0);
539 				if (*endp == '\0') {
540 					seed = tmp;
541 				}
542 			}
543 			fprintf( stderr, "KCONFIG_SEED=0x%X\n", seed );
544 			srand(seed);
545 			break;
546 		}
547 		case oldaskconfig:
548 		case oldconfig:
549 		case allnoconfig:
550 		case allyesconfig:
551 		case allmodconfig:
552 		case alldefconfig:
553 		case listnewconfig:
554 		case helpnewconfig:
555 		case olddefconfig:
556 			break;
557 		case '?':
558 			conf_usage(progname);
559 			exit(1);
560 			break;
561 		}
562 	}
563 	if (ac == optind) {
564 		fprintf(stderr, "%s: Kconfig file missing\n", av[0]);
565 		conf_usage(progname);
566 		exit(1);
567 	}
568 	name = av[optind];
569 	conf_parse(name);
570 	//zconfdump(stdout);
571 
572 	switch (input_mode) {
573 	case defconfig:
574 		if (conf_read(defconfig_file)) {
575 			fprintf(stderr,
576 				"***\n"
577 				  "*** Can't find default configuration \"%s\"!\n"
578 				  "***\n",
579 				defconfig_file);
580 			exit(1);
581 		}
582 		break;
583 	case savedefconfig:
584 	case syncconfig:
585 	case oldaskconfig:
586 	case oldconfig:
587 	case listnewconfig:
588 	case helpnewconfig:
589 	case olddefconfig:
590 		conf_read(NULL);
591 		break;
592 	case allnoconfig:
593 	case allyesconfig:
594 	case allmodconfig:
595 	case alldefconfig:
596 	case randconfig:
597 		name = getenv("KCONFIG_ALLCONFIG");
598 		if (!name)
599 			break;
600 		if ((strcmp(name, "") != 0) && (strcmp(name, "1") != 0)) {
601 			if (conf_read_simple(name, S_DEF_USER)) {
602 				fprintf(stderr,
603 					"*** Can't read seed configuration \"%s\"!\n",
604 					name);
605 				exit(1);
606 			}
607 			break;
608 		}
609 		switch (input_mode) {
610 		case allnoconfig:	name = "allno.config"; break;
611 		case allyesconfig:	name = "allyes.config"; break;
612 		case allmodconfig:	name = "allmod.config"; break;
613 		case alldefconfig:	name = "alldef.config"; break;
614 		case randconfig:	name = "allrandom.config"; break;
615 		default: break;
616 		}
617 		if (conf_read_simple(name, S_DEF_USER) &&
618 		    conf_read_simple("all.config", S_DEF_USER)) {
619 			fprintf(stderr,
620 				"*** KCONFIG_ALLCONFIG set, but no \"%s\" or \"all.config\" file found\n",
621 				name);
622 			exit(1);
623 		}
624 		break;
625 	default:
626 		break;
627 	}
628 
629 	if (sync_kconfig) {
630 		name = getenv("KCONFIG_NOSILENTUPDATE");
631 		if (name && *name) {
632 			if (conf_get_changed()) {
633 				fprintf(stderr,
634 					"\n*** The configuration requires explicit update.\n\n");
635 				return 1;
636 			}
637 			no_conf_write = 1;
638 		}
639 	}
640 
641 	switch (input_mode) {
642 	case allnoconfig:
643 		conf_set_all_new_symbols(def_no);
644 		break;
645 	case allyesconfig:
646 		conf_set_all_new_symbols(def_yes);
647 		break;
648 	case allmodconfig:
649 		conf_set_all_new_symbols(def_mod);
650 		break;
651 	case alldefconfig:
652 		conf_set_all_new_symbols(def_default);
653 		break;
654 	case randconfig:
655 		/* Really nothing to do in this loop */
656 		while (conf_set_all_new_symbols(def_random)) ;
657 		break;
658 	case defconfig:
659 		conf_set_all_new_symbols(def_default);
660 		break;
661 	case savedefconfig:
662 		break;
663 	case oldaskconfig:
664 		rootEntry = &rootmenu;
665 		conf(&rootmenu);
666 		input_mode = oldconfig;
667 		/* fall through */
668 	case oldconfig:
669 	case listnewconfig:
670 	case helpnewconfig:
671 	case syncconfig:
672 		/* Update until a loop caused no more changes */
673 		do {
674 			conf_cnt = 0;
675 			check_conf(&rootmenu);
676 		} while (conf_cnt);
677 		break;
678 	case olddefconfig:
679 	default:
680 		break;
681 	}
682 
683 	if (input_mode == savedefconfig) {
684 		if (conf_write_defconfig(defconfig_file)) {
685 			fprintf(stderr, "n*** Error while saving defconfig to: %s\n\n",
686 				defconfig_file);
687 			return 1;
688 		}
689 	} else if (input_mode != listnewconfig && input_mode != helpnewconfig) {
690 		if (!no_conf_write && conf_write(NULL)) {
691 			fprintf(stderr, "\n*** Error during writing of the configuration.\n\n");
692 			exit(1);
693 		}
694 
695 		/*
696 		 * Create auto.conf if it does not exist.
697 		 * This prevents GNU Make 4.1 or older from emitting
698 		 * "include/config/auto.conf: No such file or directory"
699 		 * in the top-level Makefile
700 		 *
701 		 * syncconfig always creates or updates auto.conf because it is
702 		 * used during the build.
703 		 */
704 		if (conf_write_autoconf(sync_kconfig) && sync_kconfig) {
705 			fprintf(stderr,
706 				"\n*** Error during sync of the configuration.\n\n");
707 			return 1;
708 		}
709 	}
710 	return 0;
711 }
712