~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/kconfig/conf.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/time.h>
 15 #include <errno.h>
 16 
 17 #include "lkc.h"
 18 
 19 static void conf(struct menu *menu);
 20 static void check_conf(struct menu *menu);
 21 
 22 enum input_mode {
 23         oldaskconfig,
 24         syncconfig,
 25         oldconfig,
 26         allnoconfig,
 27         allyesconfig,
 28         allmodconfig,
 29         alldefconfig,
 30         randconfig,
 31         defconfig,
 32         savedefconfig,
 33         listnewconfig,
 34         helpnewconfig,
 35         olddefconfig,
 36         yes2modconfig,
 37         mod2yesconfig,
 38 };
 39 static enum input_mode input_mode = oldaskconfig;
 40 static int input_mode_opt;
 41 static int indent = 1;
 42 static int tty_stdio;
 43 static int sync_kconfig;
 44 static int conf_cnt;
 45 static char line[PATH_MAX];
 46 static struct menu *rootEntry;
 47 
 48 static void print_help(struct menu *menu)
 49 {
 50         struct gstr help = str_new();
 51 
 52         menu_get_ext_help(menu, &help);
 53 
 54         printf("\n%s\n", str_get(&help));
 55         str_free(&help);
 56 }
 57 
 58 static void strip(char *str)
 59 {
 60         char *p = str;
 61         int l;
 62 
 63         while ((isspace(*p)))
 64                 p++;
 65         l = strlen(p);
 66         if (p != str)
 67                 memmove(str, p, l + 1);
 68         if (!l)
 69                 return;
 70         p = str + l - 1;
 71         while ((isspace(*p)))
 72                 *p-- = 0;
 73 }
 74 
 75 /* Helper function to facilitate fgets() by Jean Sacren. */
 76 static void xfgets(char *str, int size, FILE *in)
 77 {
 78         if (!fgets(str, size, in))
 79                 fprintf(stderr, "\nError in reading or end of file.\n");
 80 
 81         if (!tty_stdio)
 82                 printf("%s", str);
 83 }
 84 
 85 static void set_randconfig_seed(void)
 86 {
 87         unsigned int seed;
 88         char *env;
 89         bool seed_set = false;
 90 
 91         env = getenv("KCONFIG_SEED");
 92         if (env && *env) {
 93                 char *endp;
 94 
 95                 seed = strtol(env, &endp, 0);
 96                 if (*endp == '\0')
 97                         seed_set = true;
 98         }
 99 
100         if (!seed_set) {
101                 struct timeval now;
102 
103                 /*
104                  * Use microseconds derived seed, compensate for systems where it may
105                  * be zero.
106                  */
107                 gettimeofday(&now, NULL);
108                 seed = (now.tv_sec + 1) * (now.tv_usec + 1);
109         }
110 
111         printf("KCONFIG_SEED=0x%X\n", seed);
112         srand(seed);
113 }
114 
115 static bool randomize_choice_values(struct symbol *csym)
116 {
117         struct property *prop;
118         struct symbol *sym;
119         struct expr *e;
120         int cnt, def;
121 
122         /*
123          * If choice is mod then we may have more items selected
124          * and if no then no-one.
125          * In both cases stop.
126          */
127         if (csym->curr.tri != yes)
128                 return false;
129 
130         prop = sym_get_choice_prop(csym);
131 
132         /* count entries in choice block */
133         cnt = 0;
134         expr_list_for_each_sym(prop->expr, e, sym)
135                 cnt++;
136 
137         /*
138          * find a random value and set it to yes,
139          * set the rest to no so we have only one set
140          */
141         def = rand() % cnt;
142 
143         cnt = 0;
144         expr_list_for_each_sym(prop->expr, e, sym) {
145                 if (def == cnt++) {
146                         sym->def[S_DEF_USER].tri = yes;
147                         csym->def[S_DEF_USER].val = sym;
148                 } else {
149                         sym->def[S_DEF_USER].tri = no;
150                 }
151                 sym->flags |= SYMBOL_DEF_USER;
152                 /* clear VALID to get value calculated */
153                 sym->flags &= ~SYMBOL_VALID;
154         }
155         csym->flags |= SYMBOL_DEF_USER;
156         /* clear VALID to get value calculated */
157         csym->flags &= ~SYMBOL_VALID;
158 
159         return true;
160 }
161 
162 enum conf_def_mode {
163         def_default,
164         def_yes,
165         def_mod,
166         def_y2m,
167         def_m2y,
168         def_no,
169         def_random
170 };
171 
172 static bool conf_set_all_new_symbols(enum conf_def_mode mode)
173 {
174         struct symbol *sym, *csym;
175         int i, cnt;
176         /*
177          * can't go as the default in switch-case below, otherwise gcc whines
178          * about -Wmaybe-uninitialized
179          */
180         int pby = 50; /* probability of bool     = y */
181         int pty = 33; /* probability of tristate = y */
182         int ptm = 33; /* probability of tristate = m */
183         bool has_changed = false;
184 
185         if (mode == def_random) {
186                 int n, p[3];
187                 char *env = getenv("KCONFIG_PROBABILITY");
188 
189                 n = 0;
190                 while (env && *env) {
191                         char *endp;
192                         int tmp = strtol(env, &endp, 10);
193 
194                         if (tmp >= 0 && tmp <= 100) {
195                                 p[n++] = tmp;
196                         } else {
197                                 errno = ERANGE;
198                                 perror("KCONFIG_PROBABILITY");
199                                 exit(1);
200                         }
201                         env = (*endp == ':') ? endp + 1 : endp;
202                         if (n >= 3)
203                                 break;
204                 }
205                 switch (n) {
206                 case 1:
207                         pby = p[0];
208                         ptm = pby / 2;
209                         pty = pby - ptm;
210                         break;
211                 case 2:
212                         pty = p[0];
213                         ptm = p[1];
214                         pby = pty + ptm;
215                         break;
216                 case 3:
217                         pby = p[0];
218                         pty = p[1];
219                         ptm = p[2];
220                         break;
221                 }
222 
223                 if (pty + ptm > 100) {
224                         errno = ERANGE;
225                         perror("KCONFIG_PROBABILITY");
226                         exit(1);
227                 }
228         }
229 
230         for_all_symbols(i, sym) {
231                 if (sym_has_value(sym) || sym->flags & SYMBOL_VALID)
232                         continue;
233                 switch (sym_get_type(sym)) {
234                 case S_BOOLEAN:
235                 case S_TRISTATE:
236                         has_changed = true;
237                         switch (mode) {
238                         case def_yes:
239                                 sym->def[S_DEF_USER].tri = yes;
240                                 break;
241                         case def_mod:
242                                 sym->def[S_DEF_USER].tri = mod;
243                                 break;
244                         case def_no:
245                                 sym->def[S_DEF_USER].tri = no;
246                                 break;
247                         case def_random:
248                                 sym->def[S_DEF_USER].tri = no;
249                                 cnt = rand() % 100;
250                                 if (sym->type == S_TRISTATE) {
251                                         if (cnt < pty)
252                                                 sym->def[S_DEF_USER].tri = yes;
253                                         else if (cnt < pty + ptm)
254                                                 sym->def[S_DEF_USER].tri = mod;
255                                 } else if (cnt < pby)
256                                         sym->def[S_DEF_USER].tri = yes;
257                                 break;
258                         default:
259                                 continue;
260                         }
261                         if (!(sym_is_choice(sym) && mode == def_random))
262                                 sym->flags |= SYMBOL_DEF_USER;
263                         break;
264                 default:
265                         break;
266                 }
267 
268         }
269 
270         sym_clear_all_valid();
271 
272         /*
273          * We have different type of choice blocks.
274          * If curr.tri equals to mod then we can select several
275          * choice symbols in one block.
276          * In this case we do nothing.
277          * If curr.tri equals yes then only one symbol can be
278          * selected in a choice block and we set it to yes,
279          * and the rest to no.
280          */
281         if (mode != def_random) {
282                 for_all_symbols(i, csym) {
283                         if ((sym_is_choice(csym) && !sym_has_value(csym)) ||
284                             sym_is_choice_value(csym))
285                                 csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES;
286                 }
287         }
288 
289         for_all_symbols(i, csym) {
290                 if (sym_has_value(csym) || !sym_is_choice(csym))
291                         continue;
292 
293                 sym_calc_value(csym);
294                 if (mode == def_random)
295                         has_changed |= randomize_choice_values(csym);
296                 else {
297                         set_all_choice_values(csym);
298                         has_changed = true;
299                 }
300         }
301 
302         return has_changed;
303 }
304 
305 static void conf_rewrite_mod_or_yes(enum conf_def_mode mode)
306 {
307         struct symbol *sym;
308         int i;
309         tristate old_val = (mode == def_y2m) ? yes : mod;
310         tristate new_val = (mode == def_y2m) ? mod : yes;
311 
312         for_all_symbols(i, sym) {
313                 if (sym_get_type(sym) == S_TRISTATE &&
314                     sym->def[S_DEF_USER].tri == old_val)
315                         sym->def[S_DEF_USER].tri = new_val;
316         }
317         sym_clear_all_valid();
318 }
319 
320 static int conf_askvalue(struct symbol *sym, const char *def)
321 {
322         if (!sym_has_value(sym))
323                 printf("(NEW) ");
324 
325         line[0] = '\n';
326         line[1] = 0;
327 
328         if (!sym_is_changeable(sym)) {
329                 printf("%s\n", def);
330                 line[0] = '\n';
331                 line[1] = 0;
332                 return 0;
333         }
334 
335         switch (input_mode) {
336         case oldconfig:
337         case syncconfig:
338                 if (sym_has_value(sym)) {
339                         printf("%s\n", def);
340                         return 0;
341                 }
342                 /* fall through */
343         default:
344                 fflush(stdout);
345                 xfgets(line, sizeof(line), stdin);
346                 break;
347         }
348 
349         return 1;
350 }
351 
352 static int conf_string(struct menu *menu)
353 {
354         struct symbol *sym = menu->sym;
355         const char *def;
356 
357         while (1) {
358                 printf("%*s%s ", indent - 1, "", menu->prompt->text);
359                 printf("(%s) ", sym->name);
360                 def = sym_get_string_value(sym);
361                 if (def)
362                         printf("[%s] ", def);
363                 if (!conf_askvalue(sym, def))
364                         return 0;
365                 switch (line[0]) {
366                 case '\n':
367                         break;
368                 case '?':
369                         /* print help */
370                         if (line[1] == '\n') {
371                                 print_help(menu);
372                                 def = NULL;
373                                 break;
374                         }
375                         /* fall through */
376                 default:
377                         line[strlen(line)-1] = 0;
378                         def = line;
379                 }
380                 if (def && sym_set_string_value(sym, def))
381                         return 0;
382         }
383 }
384 
385 static int conf_sym(struct menu *menu)
386 {
387         struct symbol *sym = menu->sym;
388         tristate oldval, newval;
389 
390         while (1) {
391                 printf("%*s%s ", indent - 1, "", menu->prompt->text);
392                 if (sym->name)
393                         printf("(%s) ", sym->name);
394                 putchar('[');
395                 oldval = sym_get_tristate_value(sym);
396                 switch (oldval) {
397                 case no:
398                         putchar('N');
399                         break;
400                 case mod:
401                         putchar('M');
402                         break;
403                 case yes:
404                         putchar('Y');
405                         break;
406                 }
407                 if (oldval != no && sym_tristate_within_range(sym, no))
408                         printf("/n");
409                 if (oldval != mod && sym_tristate_within_range(sym, mod))
410                         printf("/m");
411                 if (oldval != yes && sym_tristate_within_range(sym, yes))
412                         printf("/y");
413                 printf("/?] ");
414                 if (!conf_askvalue(sym, sym_get_string_value(sym)))
415                         return 0;
416                 strip(line);
417 
418                 switch (line[0]) {
419                 case 'n':
420                 case 'N':
421                         newval = no;
422                         if (!line[1] || !strcmp(&line[1], "o"))
423                                 break;
424                         continue;
425                 case 'm':
426                 case 'M':
427                         newval = mod;
428                         if (!line[1])
429                                 break;
430                         continue;
431                 case 'y':
432                 case 'Y':
433                         newval = yes;
434                         if (!line[1] || !strcmp(&line[1], "es"))
435                                 break;
436                         continue;
437                 case 0:
438                         newval = oldval;
439                         break;
440                 case '?':
441                         goto help;
442                 default:
443                         continue;
444                 }
445                 if (sym_set_tristate_value(sym, newval))
446                         return 0;
447 help:
448                 print_help(menu);
449         }
450 }
451 
452 static int conf_choice(struct menu *menu)
453 {
454         struct symbol *sym, *def_sym;
455         struct menu *child;
456         bool is_new;
457 
458         sym = menu->sym;
459         is_new = !sym_has_value(sym);
460         if (sym_is_changeable(sym)) {
461                 conf_sym(menu);
462                 sym_calc_value(sym);
463                 switch (sym_get_tristate_value(sym)) {
464                 case no:
465                         return 1;
466                 case mod:
467                         return 0;
468                 case yes:
469                         break;
470                 }
471         } else {
472                 switch (sym_get_tristate_value(sym)) {
473                 case no:
474                         return 1;
475                 case mod:
476                         printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
477                         return 0;
478                 case yes:
479                         break;
480                 }
481         }
482 
483         while (1) {
484                 int cnt, def;
485 
486                 printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
487                 def_sym = sym_get_choice_value(sym);
488                 cnt = def = 0;
489                 line[0] = 0;
490                 for (child = menu->list; child; child = child->next) {
491                         if (!menu_is_visible(child))
492                                 continue;
493                         if (!child->sym) {
494                                 printf("%*c %s\n", indent, '*', menu_get_prompt(child));
495                                 continue;
496                         }
497                         cnt++;
498                         if (child->sym == def_sym) {
499                                 def = cnt;
500                                 printf("%*c", indent, '>');
501                         } else
502                                 printf("%*c", indent, ' ');
503                         printf(" %d. %s", cnt, menu_get_prompt(child));
504                         if (child->sym->name)
505                                 printf(" (%s)", child->sym->name);
506                         if (!sym_has_value(child->sym))
507                                 printf(" (NEW)");
508                         printf("\n");
509                 }
510                 printf("%*schoice", indent - 1, "");
511                 if (cnt == 1) {
512                         printf("[1]: 1\n");
513                         goto conf_childs;
514                 }
515                 printf("[1-%d?]: ", cnt);
516                 switch (input_mode) {
517                 case oldconfig:
518                 case syncconfig:
519                         if (!is_new) {
520                                 cnt = def;
521                                 printf("%d\n", cnt);
522                                 break;
523                         }
524                         /* fall through */
525                 case oldaskconfig:
526                         fflush(stdout);
527                         xfgets(line, sizeof(line), stdin);
528                         strip(line);
529                         if (line[0] == '?') {
530                                 print_help(menu);
531                                 continue;
532                         }
533                         if (!line[0])
534                                 cnt = def;
535                         else if (isdigit(line[0]))
536                                 cnt = atoi(line);
537                         else
538                                 continue;
539                         break;
540                 default:
541                         break;
542                 }
543 
544         conf_childs:
545                 for (child = menu->list; child; child = child->next) {
546                         if (!child->sym || !menu_is_visible(child))
547                                 continue;
548                         if (!--cnt)
549                                 break;
550                 }
551                 if (!child)
552                         continue;
553                 if (line[0] && line[strlen(line) - 1] == '?') {
554                         print_help(child);
555                         continue;
556                 }
557                 sym_set_choice_value(sym, child->sym);
558                 for (child = child->list; child; child = child->next) {
559                         indent += 2;
560                         conf(child);
561                         indent -= 2;
562                 }
563                 return 1;
564         }
565 }
566 
567 static void conf(struct menu *menu)
568 {
569         struct symbol *sym;
570         struct property *prop;
571         struct menu *child;
572 
573         if (!menu_is_visible(menu))
574                 return;
575 
576         sym = menu->sym;
577         prop = menu->prompt;
578         if (prop) {
579                 const char *prompt;
580 
581                 switch (prop->type) {
582                 case P_MENU:
583                         /*
584                          * Except in oldaskconfig mode, we show only menus that
585                          * contain new symbols.
586                          */
587                         if (input_mode != oldaskconfig && rootEntry != menu) {
588                                 check_conf(menu);
589                                 return;
590                         }
591                         /* fall through */
592                 case P_COMMENT:
593                         prompt = menu_get_prompt(menu);
594                         if (prompt)
595                                 printf("%*c\n%*c %s\n%*c\n",
596                                         indent, '*',
597                                         indent, '*', prompt,
598                                         indent, '*');
599                 default:
600                         ;
601                 }
602         }
603 
604         if (!sym)
605                 goto conf_childs;
606 
607         if (sym_is_choice(sym)) {
608                 conf_choice(menu);
609                 if (sym->curr.tri != mod)
610                         return;
611                 goto conf_childs;
612         }
613 
614         switch (sym->type) {
615         case S_INT:
616         case S_HEX:
617         case S_STRING:
618                 conf_string(menu);
619                 break;
620         default:
621                 conf_sym(menu);
622                 break;
623         }
624 
625 conf_childs:
626         if (sym)
627                 indent += 2;
628         for (child = menu->list; child; child = child->next)
629                 conf(child);
630         if (sym)
631                 indent -= 2;
632 }
633 
634 static void check_conf(struct menu *menu)
635 {
636         struct symbol *sym;
637         struct menu *child;
638 
639         if (!menu_is_visible(menu))
640                 return;
641 
642         sym = menu->sym;
643         if (sym && !sym_has_value(sym) &&
644             (sym_is_changeable(sym) ||
645              (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes))) {
646 
647                 switch (input_mode) {
648                 case listnewconfig:
649                         if (sym->name) {
650                                 const char *str;
651 
652                                 if (sym->type == S_STRING) {
653                                         str = sym_get_string_value(sym);
654                                         str = sym_escape_string_value(str);
655                                         printf("%s%s=%s\n", CONFIG_, sym->name, str);
656                                         free((void *)str);
657                                 } else {
658                                         str = sym_get_string_value(sym);
659                                         printf("%s%s=%s\n", CONFIG_, sym->name, str);
660                                 }
661                         }
662                         break;
663                 case helpnewconfig:
664                         printf("-----\n");
665                         print_help(menu);
666                         printf("-----\n");
667                         break;
668                 default:
669                         if (!conf_cnt++)
670                                 printf("*\n* Restart config...\n*\n");
671                         rootEntry = menu_get_parent_menu(menu);
672                         conf(rootEntry);
673                         break;
674                 }
675         }
676 
677         for (child = menu->list; child; child = child->next)
678                 check_conf(child);
679 }
680 
681 static struct option long_opts[] = {
682         {"help",          no_argument,       NULL,            'h'},
683         {"silent",        no_argument,       NULL,            's'},
684         {"oldaskconfig",  no_argument,       &input_mode_opt, oldaskconfig},
685         {"oldconfig",     no_argument,       &input_mode_opt, oldconfig},
686         {"syncconfig",    no_argument,       &input_mode_opt, syncconfig},
687         {"defconfig",     required_argument, &input_mode_opt, defconfig},
688         {"savedefconfig", required_argument, &input_mode_opt, savedefconfig},
689         {"allnoconfig",   no_argument,       &input_mode_opt, allnoconfig},
690         {"allyesconfig",  no_argument,       &input_mode_opt, allyesconfig},
691         {"allmodconfig",  no_argument,       &input_mode_opt, allmodconfig},
692         {"alldefconfig",  no_argument,       &input_mode_opt, alldefconfig},
693         {"randconfig",    no_argument,       &input_mode_opt, randconfig},
694         {"listnewconfig", no_argument,       &input_mode_opt, listnewconfig},
695         {"helpnewconfig", no_argument,       &input_mode_opt, helpnewconfig},
696         {"olddefconfig",  no_argument,       &input_mode_opt, olddefconfig},
697         {"yes2modconfig", no_argument,       &input_mode_opt, yes2modconfig},
698         {"mod2yesconfig", no_argument,       &input_mode_opt, mod2yesconfig},
699         {NULL, 0, NULL, 0}
700 };
701 
702 static void conf_usage(const char *progname)
703 {
704         printf("Usage: %s [options] <kconfig-file>\n", progname);
705         printf("\n");
706         printf("Generic options:\n");
707         printf("  -h, --help              Print this message and exit.\n");
708         printf("  -s, --silent            Do not print log.\n");
709         printf("\n");
710         printf("Mode options:\n");
711         printf("  --listnewconfig         List new options\n");
712         printf("  --helpnewconfig         List new options and help text\n");
713         printf("  --oldaskconfig          Start a new configuration using a line-oriented program\n");
714         printf("  --oldconfig             Update a configuration using a provided .config as base\n");
715         printf("  --syncconfig            Similar to oldconfig but generates configuration in\n"
716                "                          include/{generated/,config/}\n");
717         printf("  --olddefconfig          Same as oldconfig but sets new symbols to their default value\n");
718         printf("  --defconfig <file>      New config with default defined in <file>\n");
719         printf("  --savedefconfig <file>  Save the minimal current configuration to <file>\n");
720         printf("  --allnoconfig           New config where all options are answered with no\n");
721         printf("  --allyesconfig          New config where all options are answered with yes\n");
722         printf("  --allmodconfig          New config where all options are answered with mod\n");
723         printf("  --alldefconfig          New config with all symbols set to default\n");
724         printf("  --randconfig            New config with random answer to all options\n");
725         printf("  --yes2modconfig         Change answers from yes to mod if possible\n");
726         printf("  --mod2yesconfig         Change answers from mod to yes if possible\n");
727         printf("  (If none of the above is given, --oldaskconfig is the default)\n");
728 }
729 
730 int main(int ac, char **av)
731 {
732         const char *progname = av[0];
733         int opt;
734         const char *name, *defconfig_file = NULL /* gcc uninit */;
735         int no_conf_write = 0;
736 
737         tty_stdio = isatty(0) && isatty(1);
738 
739         while ((opt = getopt_long(ac, av, "hs", long_opts, NULL)) != -1) {
740                 switch (opt) {
741                 case 'h':
742                         conf_usage(progname);
743                         exit(1);
744                         break;
745                 case 's':
746                         conf_set_message_callback(NULL);
747                         break;
748                 case 0:
749                         input_mode = input_mode_opt;
750                         switch (input_mode) {
751                         case syncconfig:
752                                 /*
753                                  * syncconfig is invoked during the build stage.
754                                  * Suppress distracting
755                                  *   "configuration written to ..."
756                                  */
757                                 conf_set_message_callback(NULL);
758                                 sync_kconfig = 1;
759                                 break;
760                         case defconfig:
761                         case savedefconfig:
762                                 defconfig_file = optarg;
763                                 break;
764                         case randconfig:
765                                 set_randconfig_seed();
766                                 break;
767                         default:
768                                 break;
769                         }
770                 default:
771                         break;
772                 }
773         }
774         if (ac == optind) {
775                 fprintf(stderr, "%s: Kconfig file missing\n", av[0]);
776                 conf_usage(progname);
777                 exit(1);
778         }
779         conf_parse(av[optind]);
780         //zconfdump(stdout);
781 
782         switch (input_mode) {
783         case defconfig:
784                 if (conf_read(defconfig_file)) {
785                         fprintf(stderr,
786                                 "***\n"
787                                   "*** Can't find default configuration \"%s\"!\n"
788                                   "***\n",
789                                 defconfig_file);
790                         exit(1);
791                 }
792                 break;
793         case savedefconfig:
794         case syncconfig:
795         case oldaskconfig:
796         case oldconfig:
797         case listnewconfig:
798         case helpnewconfig:
799         case olddefconfig:
800         case yes2modconfig:
801         case mod2yesconfig:
802                 conf_read(NULL);
803                 break;
804         case allnoconfig:
805         case allyesconfig:
806         case allmodconfig:
807         case alldefconfig:
808         case randconfig:
809                 name = getenv("KCONFIG_ALLCONFIG");
810                 if (!name)
811                         break;
812                 if ((strcmp(name, "") != 0) && (strcmp(name, "1") != 0)) {
813                         if (conf_read_simple(name, S_DEF_USER)) {
814                                 fprintf(stderr,
815                                         "*** Can't read seed configuration \"%s\"!\n",
816                                         name);
817                                 exit(1);
818                         }
819                         break;
820                 }
821                 switch (input_mode) {
822                 case allnoconfig:       name = "allno.config"; break;
823                 case allyesconfig:      name = "allyes.config"; break;
824                 case allmodconfig:      name = "allmod.config"; break;
825                 case alldefconfig:      name = "alldef.config"; break;
826                 case randconfig:        name = "allrandom.config"; break;
827                 default: break;
828                 }
829                 if (conf_read_simple(name, S_DEF_USER) &&
830                     conf_read_simple("all.config", S_DEF_USER)) {
831                         fprintf(stderr,
832                                 "*** KCONFIG_ALLCONFIG set, but no \"%s\" or \"all.config\" file found\n",
833                                 name);
834                         exit(1);
835                 }
836                 break;
837         default:
838                 break;
839         }
840 
841         if (sync_kconfig) {
842                 name = getenv("KCONFIG_NOSILENTUPDATE");
843                 if (name && *name) {
844                         if (conf_get_changed()) {
845                                 fprintf(stderr,
846                                         "\n*** The configuration requires explicit update.\n\n");
847                                 return 1;
848                         }
849                         no_conf_write = 1;
850                 }
851         }
852 
853         switch (input_mode) {
854         case allnoconfig:
855                 conf_set_all_new_symbols(def_no);
856                 break;
857         case allyesconfig:
858                 conf_set_all_new_symbols(def_yes);
859                 break;
860         case allmodconfig:
861                 conf_set_all_new_symbols(def_mod);
862                 break;
863         case alldefconfig:
864                 conf_set_all_new_symbols(def_default);
865                 break;
866         case randconfig:
867                 /* Really nothing to do in this loop */
868                 while (conf_set_all_new_symbols(def_random)) ;
869                 break;
870         case defconfig:
871                 conf_set_all_new_symbols(def_default);
872                 break;
873         case savedefconfig:
874                 break;
875         case yes2modconfig:
876                 conf_rewrite_mod_or_yes(def_y2m);
877                 break;
878         case mod2yesconfig:
879                 conf_rewrite_mod_or_yes(def_m2y);
880                 break;
881         case oldaskconfig:
882                 rootEntry = &rootmenu;
883                 conf(&rootmenu);
884                 input_mode = oldconfig;
885                 /* fall through */
886         case oldconfig:
887         case listnewconfig:
888         case helpnewconfig:
889         case syncconfig:
890                 /* Update until a loop caused no more changes */
891                 do {
892                         conf_cnt = 0;
893                         check_conf(&rootmenu);
894                 } while (conf_cnt);
895                 break;
896         case olddefconfig:
897         default:
898                 break;
899         }
900 
901         if (input_mode == savedefconfig) {
902                 if (conf_write_defconfig(defconfig_file)) {
903                         fprintf(stderr, "n*** Error while saving defconfig to: %s\n\n",
904                                 defconfig_file);
905                         return 1;
906                 }
907         } else if (input_mode != listnewconfig && input_mode != helpnewconfig) {
908                 if (!no_conf_write && conf_write(NULL)) {
909                         fprintf(stderr, "\n*** Error during writing of the configuration.\n\n");
910                         exit(1);
911                 }
912 
913                 /*
914                  * Create auto.conf if it does not exist.
915                  * This prevents GNU Make 4.1 or older from emitting
916                  * "include/config/auto.conf: No such file or directory"
917                  * in the top-level Makefile
918                  *
919                  * syncconfig always creates or updates auto.conf because it is
920                  * used during the build.
921                  */
922                 if (conf_write_autoconf(sync_kconfig) && sync_kconfig) {
923                         fprintf(stderr,
924                                 "\n*** Error during sync of the configuration.\n\n");
925                         return 1;
926                 }
927         }
928         return 0;
929 }
930 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp