#include <sys/stat.h>
#include <ctype.h>
+#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static const char *conf_filename;
static int conf_lineno, conf_warnings, conf_unsaved;
-const char conf_def_filename[] = ".config";
-
const char conf_defname[] = "arch/$ARCH/defconfig";
-const char *conf_confnames[] = {
- ".config",
- "/lib/modules/$UNAME_RELEASE/.config",
- "/etc/kernel-config",
- "/boot/config-$UNAME_RELEASE",
- conf_defname,
- NULL,
-};
-
static void conf_warning(const char *fmt, ...)
{
va_list ap;
conf_warnings++;
}
+const char *conf_get_configname(void)
+{
+ char *name = getenv("KCONFIG_CONFIG");
+
+ return name ? name : ".config";
+}
+
static char *conf_expand_value(const char *in)
{
struct symbol *sym;
return name;
}
-int conf_read_simple(const char *name)
+int conf_read_simple(const char *name, int def)
{
FILE *in = NULL;
char line[1024];
char *p, *p2;
struct symbol *sym;
- int i;
+ int i, def_flags;
if (name) {
in = zconf_fopen(name);
} else {
- const char **names = conf_confnames;
- name = *names++;
- if (!name)
- return 1;
+ struct property *prop;
+
+ name = conf_get_configname();
in = zconf_fopen(name);
if (in)
goto load;
sym_change_count++;
- while ((name = *names++)) {
- name = conf_expand_value(name);
+ 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);
in = zconf_fopen(name);
if (in) {
printf(_("#\n"
conf_warnings = 0;
conf_unsaved = 0;
+ def_flags = SYMBOL_DEF << def;
for_all_symbols(i, sym) {
- sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED;
+ sym->flags |= SYMBOL_CHANGED;
+ sym->flags &= ~(def_flags|SYMBOL_VALID);
if (sym_is_choice(sym))
- sym->flags &= ~SYMBOL_NEW;
- sym->flags &= ~SYMBOL_VALID;
+ sym->flags |= def_flags;
switch (sym->type) {
case S_INT:
case S_HEX:
case S_STRING:
- if (sym->user.val)
- free(sym->user.val);
+ if (sym->def[def].val)
+ free(sym->def[def].val);
default:
- sym->user.val = NULL;
- sym->user.tri = no;
+ sym->def[def].val = NULL;
+ sym->def[def].tri = no;
}
}
*p++ = 0;
if (strncmp(p, "is not set", 10))
continue;
- sym = sym_find(line + 9);
- if (!sym) {
- conf_warning("trying to assign nonexistent symbol %s", line + 9);
- break;
- } else if (!(sym->flags & SYMBOL_NEW)) {
+ 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) {
conf_warning("trying to reassign symbol %s", sym->name);
break;
}
switch (sym->type) {
case S_BOOLEAN:
case S_TRISTATE:
- sym->user.tri = no;
- sym->flags &= ~SYMBOL_NEW;
+ sym->def[def].tri = no;
+ sym->flags |= def_flags;
break;
default:
;
continue;
*p++ = 0;
p2 = strchr(p, '\n');
- if (p2)
- *p2 = 0;
- sym = sym_find(line + 7);
- if (!sym) {
- conf_warning("trying to assign nonexistent symbol %s", line + 7);
- break;
- } else if (!(sym->flags & SYMBOL_NEW)) {
+ if (p2) {
+ *p2-- = 0;
+ if (*p2 == '\r')
+ *p2 = 0;
+ }
+ 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) {
conf_warning("trying to reassign symbol %s", sym->name);
break;
}
switch (sym->type) {
case S_TRISTATE:
if (p[0] == 'm') {
- sym->user.tri = mod;
- sym->flags &= ~SYMBOL_NEW;
+ sym->def[def].tri = mod;
+ sym->flags |= def_flags;
break;
}
case S_BOOLEAN:
if (p[0] == 'y') {
- sym->user.tri = yes;
- sym->flags &= ~SYMBOL_NEW;
+ sym->def[def].tri = yes;
+ sym->flags |= def_flags;
break;
}
if (p[0] == 'n') {
- sym->user.tri = no;
- sym->flags &= ~SYMBOL_NEW;
+ 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;
}
case S_INT:
case S_HEX:
+ done:
if (sym_string_valid(sym, p)) {
- sym->user.val = strdup(p);
- sym->flags &= ~SYMBOL_NEW;
+ sym->def[def].val = strdup(p);
+ sym->flags |= def_flags;
} else {
conf_warning("symbol value '%s' invalid for %s", p, sym->name);
continue;
;
}
break;
+ case '\r':
case '\n':
break;
default:
}
if (sym && sym_is_choice_value(sym)) {
struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
- switch (sym->user.tri) {
+ switch (sym->def[def].tri) {
case no:
break;
case mod:
- if (cs->user.tri == yes) {
+ if (cs->def[def].tri == yes) {
conf_warning("%s creates inconsistent choice state", sym->name);
- cs->flags |= SYMBOL_NEW;
+ cs->flags &= ~def_flags;
}
break;
case yes:
- if (cs->user.tri != no) {
+ if (cs->def[def].tri != no) {
conf_warning("%s creates inconsistent choice state", sym->name);
- cs->flags |= SYMBOL_NEW;
+ cs->flags &= ~def_flags;
} else
- cs->user.val = sym;
+ cs->def[def].val = sym;
break;
}
- cs->user.tri = E_OR(cs->user.tri, sym->user.tri);
+ cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);
}
}
fclose(in);
struct symbol *sym;
struct property *prop;
struct expr *e;
- int i;
+ int i, flags;
sym_change_count = 0;
- if (conf_read_simple(name))
+ if (conf_read_simple(name, S_DEF_USER))
return 1;
for_all_symbols(i, sym) {
switch (sym->type) {
case S_BOOLEAN:
case S_TRISTATE:
- if (sym->user.tri != sym_get_tristate_value(sym))
+ if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
break;
if (!sym_is_choice(sym))
goto sym_ok;
default:
- if (!strcmp(sym->curr.val, sym->user.val))
+ if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
goto sym_ok;
break;
}
sym_ok:
if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
if (sym->visible == no)
- sym->flags |= SYMBOL_NEW;
+ sym->flags &= ~SYMBOL_DEF_USER;
switch (sym->type) {
case S_STRING:
case S_INT:
case S_HEX:
- if (!sym_string_within_range(sym, sym->user.val)) {
- sym->flags |= SYMBOL_NEW;
- sym->flags &= ~SYMBOL_VALID;
- }
+ if (!sym_string_within_range(sym, sym->def[S_DEF_USER].val))
+ sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
default:
break;
}
if (!sym_is_choice(sym))
continue;
prop = sym_get_choice_prop(sym);
+ flags = sym->flags;
for (e = prop->expr; e; e = e->left.expr)
if (e->right.sym->visible != no)
- sym->flags |= e->right.sym->flags & SYMBOL_NEW;
+ flags &= e->right.sym->flags;
+ sym->flags &= flags | ~SYMBOL_DEF_USER;
}
sym_change_count += conf_warnings || conf_unsaved;
if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
strcpy(dirname, name);
strcat(dirname, "/");
- basename = conf_def_filename;
+ basename = conf_get_configname();
} else if ((slash = strrchr(name, '/'))) {
int size = slash - name + 1;
memcpy(dirname, name, size);
if (slash[1])
basename = slash + 1;
else
- basename = conf_def_filename;
+ basename = conf_get_configname();
} else
basename = name;
} else
- basename = conf_def_filename;
+ basename = conf_get_configname();
- sprintf(newname, "%s.tmpconfig.%d", dirname, (int)getpid());
- out = fopen(newname, "w");
+ 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");
+ }
if (!out)
return 1;
+
sym = sym_lookup("KERNELVERSION", 0);
sym_calc_value(sym);
time(&now);
}
}
fclose(out);
- if (!name || basename != conf_def_filename) {
- if (!name)
- name = conf_def_filename;
- sprintf(tmpname, "%s.old", name);
- rename(name, tmpname);
+
+ if (*tmpname) {
+ strcat(dirname, basename);
+ strcat(dirname, ".old");
+ rename(newname, dirname);
+ if (rename(tmpname, newname))
+ return 1;
}
- sprintf(tmpname, "%s%s", dirname, basename);
- if (rename(newname, tmpname))
- return 1;
printf(_("#\n"
"# configuration written to %s\n"
- "#\n"), tmpname);
+ "#\n"), newname);
sym_change_count = 0;
return 0;
}
+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;
+}
+
int conf_write_autoconf(void)
{
struct symbol *sym;
time_t now;
int i, l;
+ sym_clear_all_valid();
+
file_write_dep("include/config/auto.conf.cmd");
+ if (conf_split_config())
+ return 1;
+
out = fopen(".tmpconfig", "w");
if (!out)
return 1;
"#define AUTOCONF_INCLUDED\n",
sym_get_string_value(sym), ctime(&now));
- sym_clear_all_valid();
-
for_all_symbols(i, sym) {
sym_calc_value(sym);
if (!(sym->flags & SYMBOL_WRITE) || !sym->name)