2018-12-18 15:13:35 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
|
|
|
|
*/
|
|
|
|
|
2019-05-10 09:12:05 +03:00
|
|
|
#include <sys/mman.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <sys/stat.h>
|
2020-11-23 12:38:18 +03:00
|
|
|
#include <sys/types.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <ctype.h>
|
2010-08-17 09:40:20 +04:00
|
|
|
#include <errno.h>
|
2006-06-09 09:12:42 +04:00
|
|
|
#include <fcntl.h>
|
2018-12-21 11:33:04 +03:00
|
|
|
#include <limits.h>
|
2011-06-02 00:00:46 +04:00
|
|
|
#include <stdarg.h>
|
2021-10-01 08:32:46 +03:00
|
|
|
#include <stdbool.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "lkc.h"
|
|
|
|
|
2018-07-20 10:46:27 +03:00
|
|
|
/* return true if 'path' exists, false otherwise */
|
|
|
|
static bool is_present(const char *path)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
return !stat(path, &st);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return true if 'path' exists and it is a directory, false otherwise */
|
|
|
|
static bool is_dir(const char *path)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (stat(path, &st))
|
2021-03-15 09:55:44 +03:00
|
|
|
return false;
|
2018-07-20 10:46:27 +03:00
|
|
|
|
|
|
|
return S_ISDIR(st.st_mode);
|
|
|
|
}
|
|
|
|
|
2019-05-10 09:12:05 +03:00
|
|
|
/* return true if the given two files are the same, false otherwise */
|
|
|
|
static bool is_same(const char *file1, const char *file2)
|
|
|
|
{
|
|
|
|
int fd1, fd2;
|
|
|
|
struct stat st1, st2;
|
|
|
|
void *map1, *map2;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
fd1 = open(file1, O_RDONLY);
|
|
|
|
if (fd1 < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
fd2 = open(file2, O_RDONLY);
|
|
|
|
if (fd2 < 0)
|
|
|
|
goto close1;
|
|
|
|
|
|
|
|
ret = fstat(fd1, &st1);
|
|
|
|
if (ret)
|
|
|
|
goto close2;
|
|
|
|
ret = fstat(fd2, &st2);
|
|
|
|
if (ret)
|
|
|
|
goto close2;
|
|
|
|
|
|
|
|
if (st1.st_size != st2.st_size)
|
|
|
|
goto close2;
|
|
|
|
|
|
|
|
map1 = mmap(NULL, st1.st_size, PROT_READ, MAP_PRIVATE, fd1, 0);
|
|
|
|
if (map1 == MAP_FAILED)
|
|
|
|
goto close2;
|
|
|
|
|
|
|
|
map2 = mmap(NULL, st2.st_size, PROT_READ, MAP_PRIVATE, fd2, 0);
|
|
|
|
if (map2 == MAP_FAILED)
|
|
|
|
goto close2;
|
|
|
|
|
|
|
|
if (bcmp(map1, map2, st1.st_size))
|
|
|
|
goto close2;
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
close2:
|
|
|
|
close(fd2);
|
|
|
|
close1:
|
|
|
|
close(fd1);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-07-20 10:46:27 +03:00
|
|
|
/*
|
|
|
|
* Create the parent directory of the given path.
|
|
|
|
*
|
|
|
|
* For example, if 'include/config/auto.conf' is given, create 'include/config'.
|
|
|
|
*/
|
|
|
|
static int make_parent_dir(const char *path)
|
|
|
|
{
|
|
|
|
char tmp[PATH_MAX + 1];
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
strncpy(tmp, path, sizeof(tmp));
|
|
|
|
tmp[sizeof(tmp) - 1] = 0;
|
|
|
|
|
|
|
|
/* Remove the base name. Just return if nothing is left */
|
|
|
|
p = strrchr(tmp, '/');
|
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
*(p + 1) = 0;
|
|
|
|
|
|
|
|
/* Just in case it is an absolute path */
|
|
|
|
p = tmp;
|
|
|
|
while (*p == '/')
|
|
|
|
p++;
|
|
|
|
|
|
|
|
while ((p = strchr(p, '/'))) {
|
|
|
|
*p = 0;
|
|
|
|
|
|
|
|
/* skip if the directory exists */
|
|
|
|
if (!is_dir(tmp) && mkdir(tmp, 0755))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
*p = '/';
|
|
|
|
while (*p == '/')
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-30 12:15:50 +03:00
|
|
|
static char depfile_path[PATH_MAX];
|
|
|
|
static size_t depfile_prefix_len;
|
|
|
|
|
|
|
|
/* touch depfile for symbol 'name' */
|
|
|
|
static int conf_touch_dep(const char *name)
|
|
|
|
{
|
2021-10-01 08:32:52 +03:00
|
|
|
int fd;
|
2018-11-30 12:15:50 +03:00
|
|
|
|
2021-04-15 20:36:07 +03:00
|
|
|
/* check overflow: prefix + name + '\0' must fit in buffer. */
|
|
|
|
if (depfile_prefix_len + strlen(name) + 1 > sizeof(depfile_path))
|
2018-11-30 12:15:50 +03:00
|
|
|
return -1;
|
|
|
|
|
2021-10-01 08:32:52 +03:00
|
|
|
strcpy(depfile_path + depfile_prefix_len, name);
|
2018-11-30 12:15:50 +03:00
|
|
|
|
|
|
|
fd = open(depfile_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
|
2021-10-01 08:32:52 +03:00
|
|
|
if (fd == -1)
|
|
|
|
return -1;
|
2018-11-30 12:15:50 +03:00
|
|
|
close(fd);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-09 08:34:54 +03:00
|
|
|
static void conf_warning(const char *fmt, ...)
|
|
|
|
__attribute__ ((format (printf, 1, 2)));
|
|
|
|
|
2010-08-17 12:21:19 +04:00
|
|
|
static void conf_message(const char *fmt, ...)
|
|
|
|
__attribute__ ((format (printf, 1, 2)));
|
|
|
|
|
2005-11-09 08:34:54 +03:00
|
|
|
static const char *conf_filename;
|
2018-01-11 16:39:41 +03:00
|
|
|
static int conf_lineno, conf_warnings;
|
2005-11-09 08:34:54 +03:00
|
|
|
|
|
|
|
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++;
|
|
|
|
}
|
|
|
|
|
2018-07-05 05:46:12 +03:00
|
|
|
static void conf_default_message_callback(const char *s)
|
2010-08-17 12:21:19 +04:00
|
|
|
{
|
|
|
|
printf("#\n# ");
|
2018-07-05 05:46:12 +03:00
|
|
|
printf("%s", s);
|
2010-08-17 12:21:19 +04:00
|
|
|
printf("\n#\n");
|
|
|
|
}
|
|
|
|
|
2018-07-05 05:46:12 +03:00
|
|
|
static void (*conf_message_callback)(const char *s) =
|
2010-08-17 12:21:19 +04:00
|
|
|
conf_default_message_callback;
|
2018-07-05 05:46:12 +03:00
|
|
|
void conf_set_message_callback(void (*fn)(const char *s))
|
2010-08-17 12:21:19 +04:00
|
|
|
{
|
|
|
|
conf_message_callback = fn;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void conf_message(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
2018-07-05 05:46:12 +03:00
|
|
|
char buf[4096];
|
|
|
|
|
|
|
|
if (!conf_message_callback)
|
|
|
|
return;
|
2010-08-17 12:21:19 +04:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2018-07-05 05:46:12 +03:00
|
|
|
|
|
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
|
|
conf_message_callback(buf);
|
2015-01-12 16:18:26 +03:00
|
|
|
va_end(ap);
|
2010-08-17 12:21:19 +04:00
|
|
|
}
|
|
|
|
|
2006-06-09 09:12:51 +04:00
|
|
|
const char *conf_get_configname(void)
|
|
|
|
{
|
|
|
|
char *name = getenv("KCONFIG_CONFIG");
|
|
|
|
|
|
|
|
return name ? name : ".config";
|
|
|
|
}
|
|
|
|
|
2019-05-12 19:00:53 +03:00
|
|
|
static const char *conf_get_autoconfig_name(void)
|
2009-05-18 03:36:54 +04:00
|
|
|
{
|
|
|
|
char *name = getenv("KCONFIG_AUTOCONFIG");
|
|
|
|
|
|
|
|
return name ? name : "include/config/auto.conf";
|
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:49 +03:00
|
|
|
static const char *conf_get_autoheader_name(void)
|
|
|
|
{
|
|
|
|
char *name = getenv("KCONFIG_AUTOHEADER");
|
|
|
|
|
|
|
|
return name ? name : "include/generated/autoconf.h";
|
|
|
|
}
|
|
|
|
|
2007-11-10 22:01:56 +03:00
|
|
|
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;
|
|
|
|
}
|
2011-05-31 20:30:26 +04:00
|
|
|
/* fall through */
|
2007-11-10 22:01:56 +03:00
|
|
|
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;
|
|
|
|
}
|
2013-08-06 20:45:07 +04:00
|
|
|
if (def != S_DEF_AUTO)
|
|
|
|
conf_warning("symbol value '%s' invalid for %s",
|
|
|
|
p, sym->name);
|
2011-05-31 20:31:57 +04:00
|
|
|
return 1;
|
2007-11-10 22:01:56 +03:00
|
|
|
case S_STRING:
|
kbuild: do not quote string values in include/config/auto.conf
The previous commit fixed up all shell scripts to not include
include/config/auto.conf.
Now that include/config/auto.conf is only included by Makefiles,
we can change it into a more Make-friendly form.
Previously, Kconfig output string values enclosed with double-quotes
(both in the .config and include/config/auto.conf):
CONFIG_X="foo bar"
Unlike shell, Make handles double-quotes (and single-quotes as well)
verbatim. We must rip them off when used.
There are some patterns:
[1] $(patsubst "%",%,$(CONFIG_X))
[2] $(CONFIG_X:"%"=%)
[3] $(subst ",,$(CONFIG_X))
[4] $(shell echo $(CONFIG_X))
These are not only ugly, but also fragile.
[1] and [2] do not work if the value contains spaces, like
CONFIG_X=" foo bar "
[3] does not work correctly if the value contains double-quotes like
CONFIG_X="foo\"bar"
[4] seems to work better, but has a cost of forking a process.
Anyway, quoted strings were always PITA for our Makefiles.
This commit changes Kconfig to stop quoting in include/config/auto.conf.
These are the string type symbols referenced in Makefiles or scripts:
ACPI_CUSTOM_DSDT_FILE
ARC_BUILTIN_DTB_NAME
ARC_TUNE_MCPU
BUILTIN_DTB_SOURCE
CC_IMPLICIT_FALLTHROUGH
CC_VERSION_TEXT
CFG80211_EXTRA_REGDB_KEYDIR
EXTRA_FIRMWARE
EXTRA_FIRMWARE_DIR
EXTRA_TARGETS
H8300_BUILTIN_DTB
INITRAMFS_SOURCE
LOCALVERSION
MODULE_SIG_HASH
MODULE_SIG_KEY
NDS32_BUILTIN_DTB
NIOS2_DTB_SOURCE
OPENRISC_BUILTIN_DTB
SOC_CANAAN_K210_DTB_SOURCE
SYSTEM_BLACKLIST_HASH_LIST
SYSTEM_REVOCATION_KEYS
SYSTEM_TRUSTED_KEYS
TARGET_CPU
UNUSED_KSYMS_WHITELIST
XILINX_MICROBLAZE0_FAMILY
XILINX_MICROBLAZE0_HW_VER
XTENSA_VARIANT_NAME
I checked them one by one, and fixed up the code where necessary.
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
2021-12-14 05:53:53 +03:00
|
|
|
/* No escaping for S_DEF_AUTO (include/config/auto.conf) */
|
|
|
|
if (def != S_DEF_AUTO) {
|
|
|
|
if (*p++ != '"')
|
2007-11-10 22:01:56 +03:00
|
|
|
break;
|
kbuild: do not quote string values in include/config/auto.conf
The previous commit fixed up all shell scripts to not include
include/config/auto.conf.
Now that include/config/auto.conf is only included by Makefiles,
we can change it into a more Make-friendly form.
Previously, Kconfig output string values enclosed with double-quotes
(both in the .config and include/config/auto.conf):
CONFIG_X="foo bar"
Unlike shell, Make handles double-quotes (and single-quotes as well)
verbatim. We must rip them off when used.
There are some patterns:
[1] $(patsubst "%",%,$(CONFIG_X))
[2] $(CONFIG_X:"%"=%)
[3] $(subst ",,$(CONFIG_X))
[4] $(shell echo $(CONFIG_X))
These are not only ugly, but also fragile.
[1] and [2] do not work if the value contains spaces, like
CONFIG_X=" foo bar "
[3] does not work correctly if the value contains double-quotes like
CONFIG_X="foo\"bar"
[4] seems to work better, but has a cost of forking a process.
Anyway, quoted strings were always PITA for our Makefiles.
This commit changes Kconfig to stop quoting in include/config/auto.conf.
These are the string type symbols referenced in Makefiles or scripts:
ACPI_CUSTOM_DSDT_FILE
ARC_BUILTIN_DTB_NAME
ARC_TUNE_MCPU
BUILTIN_DTB_SOURCE
CC_IMPLICIT_FALLTHROUGH
CC_VERSION_TEXT
CFG80211_EXTRA_REGDB_KEYDIR
EXTRA_FIRMWARE
EXTRA_FIRMWARE_DIR
EXTRA_TARGETS
H8300_BUILTIN_DTB
INITRAMFS_SOURCE
LOCALVERSION
MODULE_SIG_HASH
MODULE_SIG_KEY
NDS32_BUILTIN_DTB
NIOS2_DTB_SOURCE
OPENRISC_BUILTIN_DTB
SOC_CANAAN_K210_DTB_SOURCE
SYSTEM_BLACKLIST_HASH_LIST
SYSTEM_REVOCATION_KEYS
SYSTEM_TRUSTED_KEYS
TARGET_CPU
UNUSED_KSYMS_WHITELIST
XILINX_MICROBLAZE0_FAMILY
XILINX_MICROBLAZE0_HW_VER
XTENSA_VARIANT_NAME
I checked them one by one, and fixed up the code where necessary.
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
2021-12-14 05:53:53 +03:00
|
|
|
for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
|
|
|
|
if (*p2 == '"') {
|
|
|
|
*p2 = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
memmove(p2, p2 + 1, strlen(p2));
|
2007-11-10 22:01:56 +03:00
|
|
|
}
|
kbuild: do not quote string values in include/config/auto.conf
The previous commit fixed up all shell scripts to not include
include/config/auto.conf.
Now that include/config/auto.conf is only included by Makefiles,
we can change it into a more Make-friendly form.
Previously, Kconfig output string values enclosed with double-quotes
(both in the .config and include/config/auto.conf):
CONFIG_X="foo bar"
Unlike shell, Make handles double-quotes (and single-quotes as well)
verbatim. We must rip them off when used.
There are some patterns:
[1] $(patsubst "%",%,$(CONFIG_X))
[2] $(CONFIG_X:"%"=%)
[3] $(subst ",,$(CONFIG_X))
[4] $(shell echo $(CONFIG_X))
These are not only ugly, but also fragile.
[1] and [2] do not work if the value contains spaces, like
CONFIG_X=" foo bar "
[3] does not work correctly if the value contains double-quotes like
CONFIG_X="foo\"bar"
[4] seems to work better, but has a cost of forking a process.
Anyway, quoted strings were always PITA for our Makefiles.
This commit changes Kconfig to stop quoting in include/config/auto.conf.
These are the string type symbols referenced in Makefiles or scripts:
ACPI_CUSTOM_DSDT_FILE
ARC_BUILTIN_DTB_NAME
ARC_TUNE_MCPU
BUILTIN_DTB_SOURCE
CC_IMPLICIT_FALLTHROUGH
CC_VERSION_TEXT
CFG80211_EXTRA_REGDB_KEYDIR
EXTRA_FIRMWARE
EXTRA_FIRMWARE_DIR
EXTRA_TARGETS
H8300_BUILTIN_DTB
INITRAMFS_SOURCE
LOCALVERSION
MODULE_SIG_HASH
MODULE_SIG_KEY
NDS32_BUILTIN_DTB
NIOS2_DTB_SOURCE
OPENRISC_BUILTIN_DTB
SOC_CANAAN_K210_DTB_SOURCE
SYSTEM_BLACKLIST_HASH_LIST
SYSTEM_REVOCATION_KEYS
SYSTEM_TRUSTED_KEYS
TARGET_CPU
UNUSED_KSYMS_WHITELIST
XILINX_MICROBLAZE0_FAMILY
XILINX_MICROBLAZE0_HW_VER
XTENSA_VARIANT_NAME
I checked them one by one, and fixed up the code where necessary.
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
2021-12-14 05:53:53 +03:00
|
|
|
if (!p2) {
|
2013-08-06 20:45:07 +04:00
|
|
|
conf_warning("invalid string found");
|
kbuild: do not quote string values in include/config/auto.conf
The previous commit fixed up all shell scripts to not include
include/config/auto.conf.
Now that include/config/auto.conf is only included by Makefiles,
we can change it into a more Make-friendly form.
Previously, Kconfig output string values enclosed with double-quotes
(both in the .config and include/config/auto.conf):
CONFIG_X="foo bar"
Unlike shell, Make handles double-quotes (and single-quotes as well)
verbatim. We must rip them off when used.
There are some patterns:
[1] $(patsubst "%",%,$(CONFIG_X))
[2] $(CONFIG_X:"%"=%)
[3] $(subst ",,$(CONFIG_X))
[4] $(shell echo $(CONFIG_X))
These are not only ugly, but also fragile.
[1] and [2] do not work if the value contains spaces, like
CONFIG_X=" foo bar "
[3] does not work correctly if the value contains double-quotes like
CONFIG_X="foo\"bar"
[4] seems to work better, but has a cost of forking a process.
Anyway, quoted strings were always PITA for our Makefiles.
This commit changes Kconfig to stop quoting in include/config/auto.conf.
These are the string type symbols referenced in Makefiles or scripts:
ACPI_CUSTOM_DSDT_FILE
ARC_BUILTIN_DTB_NAME
ARC_TUNE_MCPU
BUILTIN_DTB_SOURCE
CC_IMPLICIT_FALLTHROUGH
CC_VERSION_TEXT
CFG80211_EXTRA_REGDB_KEYDIR
EXTRA_FIRMWARE
EXTRA_FIRMWARE_DIR
EXTRA_TARGETS
H8300_BUILTIN_DTB
INITRAMFS_SOURCE
LOCALVERSION
MODULE_SIG_HASH
MODULE_SIG_KEY
NDS32_BUILTIN_DTB
NIOS2_DTB_SOURCE
OPENRISC_BUILTIN_DTB
SOC_CANAAN_K210_DTB_SOURCE
SYSTEM_BLACKLIST_HASH_LIST
SYSTEM_REVOCATION_KEYS
SYSTEM_TRUSTED_KEYS
TARGET_CPU
UNUSED_KSYMS_WHITELIST
XILINX_MICROBLAZE0_FAMILY
XILINX_MICROBLAZE0_HW_VER
XTENSA_VARIANT_NAME
I checked them one by one, and fixed up the code where necessary.
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
2021-12-14 05:53:53 +03:00
|
|
|
return 1;
|
|
|
|
}
|
2007-11-10 22:01:56 +03:00
|
|
|
}
|
2011-05-31 20:30:26 +04:00
|
|
|
/* fall through */
|
2007-11-10 22:01:56 +03:00
|
|
|
case S_INT:
|
|
|
|
case S_HEX:
|
|
|
|
if (sym_string_valid(sym, p)) {
|
2018-02-16 21:38:31 +03:00
|
|
|
sym->def[def].val = xstrdup(p);
|
2007-11-10 22:01:56 +03:00
|
|
|
sym->flags |= def_flags;
|
|
|
|
} else {
|
2013-08-06 20:45:07 +04:00
|
|
|
if (def != S_DEF_AUTO)
|
|
|
|
conf_warning("symbol value '%s' invalid for %s",
|
|
|
|
p, sym->name);
|
2007-11-10 22:01:56 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-13 22:27:12 +04:00
|
|
|
#define LINE_GROWTH 16
|
|
|
|
static int add_byte(int c, char **lineptr, size_t slen, size_t *n)
|
|
|
|
{
|
|
|
|
char *nline;
|
|
|
|
size_t new_size = slen + 1;
|
|
|
|
if (new_size > *n) {
|
|
|
|
new_size += LINE_GROWTH - 1;
|
|
|
|
new_size *= 2;
|
2018-02-08 19:19:07 +03:00
|
|
|
nline = xrealloc(*lineptr, new_size);
|
2012-07-13 22:27:12 +04:00
|
|
|
if (!nline)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
*lineptr = nline;
|
|
|
|
*n = new_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
(*lineptr)[slen] = c;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t compat_getline(char **lineptr, size_t *n, FILE *stream)
|
|
|
|
{
|
|
|
|
char *line = *lineptr;
|
|
|
|
size_t slen = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int c = getc(stream);
|
|
|
|
|
|
|
|
switch (c) {
|
|
|
|
case '\n':
|
|
|
|
if (add_byte(c, &line, slen, n) < 0)
|
|
|
|
goto e_out;
|
|
|
|
slen++;
|
|
|
|
/* fall through */
|
|
|
|
case EOF:
|
|
|
|
if (add_byte('\0', &line, slen, n) < 0)
|
|
|
|
goto e_out;
|
|
|
|
*lineptr = line;
|
|
|
|
if (slen == 0)
|
|
|
|
return -1;
|
|
|
|
return slen;
|
|
|
|
default:
|
|
|
|
if (add_byte(c, &line, slen, n) < 0)
|
|
|
|
goto e_out;
|
|
|
|
slen++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
e_out:
|
|
|
|
line[slen-1] = '\0';
|
|
|
|
*lineptr = line;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-06-09 09:12:42 +04:00
|
|
|
int conf_read_simple(const char *name, int def)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
FILE *in = NULL;
|
2012-07-13 22:27:12 +04:00
|
|
|
char *line = NULL;
|
|
|
|
size_t line_asize = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
char *p, *p2;
|
|
|
|
struct symbol *sym;
|
2006-06-09 09:12:42 +04:00
|
|
|
int i, def_flags;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
if (name) {
|
|
|
|
in = zconf_fopen(name);
|
|
|
|
} else {
|
2021-03-13 22:48:32 +03:00
|
|
|
char *env;
|
2006-06-09 09:12:45 +04:00
|
|
|
|
2006-06-09 09:12:51 +04:00
|
|
|
name = conf_get_configname();
|
2006-06-09 09:12:38 +04:00
|
|
|
in = zconf_fopen(name);
|
|
|
|
if (in)
|
|
|
|
goto load;
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_set_changed(true);
|
2021-03-13 22:48:32 +03:00
|
|
|
|
|
|
|
env = getenv("KCONFIG_DEFCONFIG_LIST");
|
|
|
|
if (!env)
|
2006-06-09 09:12:45 +04:00
|
|
|
return 1;
|
|
|
|
|
2021-03-13 22:48:32 +03:00
|
|
|
while (1) {
|
|
|
|
bool is_last;
|
|
|
|
|
|
|
|
while (isspace(*env))
|
|
|
|
env++;
|
|
|
|
|
|
|
|
if (!*env)
|
|
|
|
break;
|
|
|
|
|
|
|
|
p = env;
|
|
|
|
while (*p && !isspace(*p))
|
|
|
|
p++;
|
|
|
|
|
|
|
|
is_last = (*p == '\0');
|
|
|
|
|
|
|
|
*p = '\0';
|
|
|
|
|
|
|
|
in = zconf_fopen(env);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (in) {
|
2018-05-22 22:36:12 +03:00
|
|
|
conf_message("using defaults found in %s",
|
2021-03-13 22:48:32 +03:00
|
|
|
env);
|
2006-06-09 09:12:38 +04:00
|
|
|
goto load;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2021-03-13 22:48:32 +03:00
|
|
|
|
|
|
|
if (is_last)
|
|
|
|
break;
|
|
|
|
|
|
|
|
env = p + 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!in)
|
|
|
|
return 1;
|
|
|
|
|
2006-06-09 09:12:38 +04:00
|
|
|
load:
|
2005-11-09 08:34:54 +03:00
|
|
|
conf_filename = name;
|
|
|
|
conf_lineno = 0;
|
|
|
|
conf_warnings = 0;
|
|
|
|
|
2006-06-09 09:12:42 +04:00
|
|
|
def_flags = SYMBOL_DEF << def;
|
2005-04-17 02:20:36 +04:00
|
|
|
for_all_symbols(i, sym) {
|
2006-06-09 09:12:42 +04:00
|
|
|
sym->flags |= SYMBOL_CHANGED;
|
|
|
|
sym->flags &= ~(def_flags|SYMBOL_VALID);
|
2013-06-26 01:37:44 +04:00
|
|
|
if (sym_is_choice(sym))
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 02:20:36 +04:00
|
|
|
switch (sym->type) {
|
|
|
|
case S_INT:
|
|
|
|
case S_HEX:
|
|
|
|
case S_STRING:
|
2006-06-09 09:12:42 +04:00
|
|
|
if (sym->def[def].val)
|
|
|
|
free(sym->def[def].val);
|
2011-05-31 20:30:26 +04:00
|
|
|
/* fall through */
|
2005-04-17 02:20:36 +04:00
|
|
|
default:
|
2006-06-09 09:12:42 +04:00
|
|
|
sym->def[def].val = NULL;
|
|
|
|
sym->def[def].tri = no;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-13 22:27:12 +04:00
|
|
|
while (compat_getline(&line, &line_asize, in) != -1) {
|
2005-11-09 08:34:54 +03:00
|
|
|
conf_lineno++;
|
2005-04-17 02:20:36 +04:00
|
|
|
sym = NULL;
|
2010-08-24 08:14:47 +04:00
|
|
|
if (line[0] == '#') {
|
2010-08-15 07:57:43 +04:00
|
|
|
if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
2010-08-15 07:57:43 +04:00
|
|
|
p = strchr(line + 2 + strlen(CONFIG_), ' ');
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!p)
|
|
|
|
continue;
|
|
|
|
*p++ = 0;
|
|
|
|
if (strncmp(p, "is not set", 10))
|
|
|
|
continue;
|
2006-06-09 09:12:42 +04:00
|
|
|
if (def == S_DEF_USER) {
|
2010-08-15 07:57:43 +04:00
|
|
|
sym = sym_find(line + 2 + strlen(CONFIG_));
|
2008-09-29 07:27:11 +04:00
|
|
|
if (!sym) {
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_set_changed(true);
|
2018-11-30 12:15:48 +03:00
|
|
|
continue;
|
2008-09-29 07:27:11 +04:00
|
|
|
}
|
2006-06-09 09:12:42 +04:00
|
|
|
} else {
|
2010-08-15 07:57:43 +04:00
|
|
|
sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
|
2006-06-09 09:12:42 +04:00
|
|
|
if (sym->type == S_UNKNOWN)
|
|
|
|
sym->type = S_BOOLEAN;
|
|
|
|
}
|
|
|
|
if (sym->flags & def_flags) {
|
2008-01-04 01:33:44 +03:00
|
|
|
conf_warning("override: reassigning to symbol %s", sym->name);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
2006-06-09 09:12:42 +04:00
|
|
|
sym->def[def].tri = no;
|
|
|
|
sym->flags |= def_flags;
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
;
|
|
|
|
}
|
2010-08-15 07:57:43 +04:00
|
|
|
} else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
|
|
|
|
p = strchr(line + strlen(CONFIG_), '=');
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!p)
|
|
|
|
continue;
|
|
|
|
*p++ = 0;
|
|
|
|
p2 = strchr(p, '\n');
|
2006-07-13 22:54:07 +04:00
|
|
|
if (p2) {
|
|
|
|
*p2-- = 0;
|
|
|
|
if (*p2 == '\r')
|
|
|
|
*p2 = 0;
|
|
|
|
}
|
kconfig: remove S_OTHER symbol type and correct dependency tracking
The S_OTHER type could be set only when conf_read_simple() is reading
include/config/auto.conf file.
For example, CONFIG_FOO=y exists in include/config/auto.conf but it is
missing from the currently parsed Kconfig files, sym_lookup() allocates
a new symbol, and sets its type to S_OTHER.
Strangely, it will be set to S_STRING by conf_set_sym_val() a few lines
below while it is obviously bool or tristate type. On the other hand,
when CONFIG_BAR="bar" is being dropped from include/config/auto.conf,
its type remains S_OTHER. Because for_all_symbols() omits S_OTHER
symbols, conf_touch_deps() misses to touch include/config/bar.h
This behavior has been a pretty mystery for me, and digging the git
histroy did not help. At least, touching depfiles is broken for string
type symbols.
I removed S_OTHER entirely, and reimplemented it more simply.
If CONFIG_FOO was visible in the previous syncconfig, but is missing
now, what we want to do is quite simple; just call conf_touch_dep()
to touch include/config/foo.h instead of allocating a new symbol data.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-11-30 12:15:51 +03:00
|
|
|
|
|
|
|
sym = sym_find(line + strlen(CONFIG_));
|
|
|
|
if (!sym) {
|
|
|
|
if (def == S_DEF_AUTO)
|
|
|
|
/*
|
|
|
|
* Reading from include/config/auto.conf
|
|
|
|
* If CONFIG_FOO previously existed in
|
|
|
|
* auto.conf but it is missing now,
|
2021-04-15 20:36:07 +03:00
|
|
|
* include/config/FOO must be touched.
|
kconfig: remove S_OTHER symbol type and correct dependency tracking
The S_OTHER type could be set only when conf_read_simple() is reading
include/config/auto.conf file.
For example, CONFIG_FOO=y exists in include/config/auto.conf but it is
missing from the currently parsed Kconfig files, sym_lookup() allocates
a new symbol, and sets its type to S_OTHER.
Strangely, it will be set to S_STRING by conf_set_sym_val() a few lines
below while it is obviously bool or tristate type. On the other hand,
when CONFIG_BAR="bar" is being dropped from include/config/auto.conf,
its type remains S_OTHER. Because for_all_symbols() omits S_OTHER
symbols, conf_touch_deps() misses to touch include/config/bar.h
This behavior has been a pretty mystery for me, and digging the git
histroy did not help. At least, touching depfiles is broken for string
type symbols.
I removed S_OTHER entirely, and reimplemented it more simply.
If CONFIG_FOO was visible in the previous syncconfig, but is missing
now, what we want to do is quite simple; just call conf_touch_dep()
to touch include/config/foo.h instead of allocating a new symbol data.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-11-30 12:15:51 +03:00
|
|
|
*/
|
|
|
|
conf_touch_dep(line + strlen(CONFIG_));
|
|
|
|
else
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_set_changed(true);
|
kconfig: remove S_OTHER symbol type and correct dependency tracking
The S_OTHER type could be set only when conf_read_simple() is reading
include/config/auto.conf file.
For example, CONFIG_FOO=y exists in include/config/auto.conf but it is
missing from the currently parsed Kconfig files, sym_lookup() allocates
a new symbol, and sets its type to S_OTHER.
Strangely, it will be set to S_STRING by conf_set_sym_val() a few lines
below while it is obviously bool or tristate type. On the other hand,
when CONFIG_BAR="bar" is being dropped from include/config/auto.conf,
its type remains S_OTHER. Because for_all_symbols() omits S_OTHER
symbols, conf_touch_deps() misses to touch include/config/bar.h
This behavior has been a pretty mystery for me, and digging the git
histroy did not help. At least, touching depfiles is broken for string
type symbols.
I removed S_OTHER entirely, and reimplemented it more simply.
If CONFIG_FOO was visible in the previous syncconfig, but is missing
now, what we want to do is quite simple; just call conf_touch_dep()
to touch include/config/foo.h instead of allocating a new symbol data.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-11-30 12:15:51 +03:00
|
|
|
continue;
|
2006-06-09 09:12:42 +04:00
|
|
|
}
|
kconfig: remove S_OTHER symbol type and correct dependency tracking
The S_OTHER type could be set only when conf_read_simple() is reading
include/config/auto.conf file.
For example, CONFIG_FOO=y exists in include/config/auto.conf but it is
missing from the currently parsed Kconfig files, sym_lookup() allocates
a new symbol, and sets its type to S_OTHER.
Strangely, it will be set to S_STRING by conf_set_sym_val() a few lines
below while it is obviously bool or tristate type. On the other hand,
when CONFIG_BAR="bar" is being dropped from include/config/auto.conf,
its type remains S_OTHER. Because for_all_symbols() omits S_OTHER
symbols, conf_touch_deps() misses to touch include/config/bar.h
This behavior has been a pretty mystery for me, and digging the git
histroy did not help. At least, touching depfiles is broken for string
type symbols.
I removed S_OTHER entirely, and reimplemented it more simply.
If CONFIG_FOO was visible in the previous syncconfig, but is missing
now, what we want to do is quite simple; just call conf_touch_dep()
to touch include/config/foo.h instead of allocating a new symbol data.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-11-30 12:15:51 +03:00
|
|
|
|
2006-06-09 09:12:42 +04:00
|
|
|
if (sym->flags & def_flags) {
|
2008-01-04 01:33:44 +03:00
|
|
|
conf_warning("override: reassigning to symbol %s", sym->name);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2007-11-10 22:01:56 +03:00
|
|
|
if (conf_set_sym_val(sym, def, def_flags, p))
|
|
|
|
continue;
|
2010-08-24 08:14:47 +04:00
|
|
|
} else {
|
|
|
|
if (line[0] != '\r' && line[0] != '\n')
|
2016-03-16 23:27:27 +03:00
|
|
|
conf_warning("unexpected data: %.*s",
|
|
|
|
(int)strcspn(line, "\r\n"), line);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
continue;
|
|
|
|
}
|
2018-11-30 12:15:48 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
if (sym && sym_is_choice_value(sym)) {
|
|
|
|
struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
|
2006-06-09 09:12:42 +04:00
|
|
|
switch (sym->def[def].tri) {
|
2005-04-17 02:20:36 +04:00
|
|
|
case no:
|
|
|
|
break;
|
|
|
|
case mod:
|
2006-06-09 09:12:42 +04:00
|
|
|
if (cs->def[def].tri == yes) {
|
2005-11-09 08:34:54 +03:00
|
|
|
conf_warning("%s creates inconsistent choice state", sym->name);
|
2013-06-26 01:37:44 +04:00
|
|
|
cs->flags &= ~def_flags;
|
2005-11-09 08:34:54 +03:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
case yes:
|
2008-01-04 01:33:44 +03:00
|
|
|
if (cs->def[def].tri != no)
|
|
|
|
conf_warning("override: %s changes choice state", sym->name);
|
|
|
|
cs->def[def].val = sym;
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
|
|
|
}
|
2008-01-07 23:09:55 +03:00
|
|
|
cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
2012-07-13 22:27:12 +04:00
|
|
|
free(line);
|
2005-04-17 02:20:36 +04:00
|
|
|
fclose(in);
|
2005-11-09 08:34:49 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int conf_read(const char *name)
|
|
|
|
{
|
2012-01-24 02:29:05 +04:00
|
|
|
struct symbol *sym;
|
2018-01-11 16:39:41 +03:00
|
|
|
int conf_unsaved = 0;
|
2012-01-24 02:29:05 +04:00
|
|
|
int i;
|
2005-11-09 08:34:49 +03:00
|
|
|
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_set_changed(false);
|
2006-06-09 09:12:38 +04:00
|
|
|
|
2016-01-14 21:13:49 +03:00
|
|
|
if (conf_read_simple(name, S_DEF_USER)) {
|
|
|
|
sym_calc_value(modules_sym);
|
2005-11-09 08:34:49 +03:00
|
|
|
return 1;
|
2016-01-14 21:13:49 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
sym_calc_value(modules_sym);
|
2005-11-09 08:34:49 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
for_all_symbols(i, sym) {
|
|
|
|
sym_calc_value(sym);
|
2018-07-03 15:43:31 +03:00
|
|
|
if (sym_is_choice(sym) || (sym->flags & SYMBOL_NO_WRITE))
|
2012-01-24 02:29:05 +04:00
|
|
|
continue;
|
2005-11-09 08:34:54 +03:00
|
|
|
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:
|
2019-07-11 10:33:17 +03:00
|
|
|
if (sym->def[S_DEF_USER].tri == sym_get_tristate_value(sym))
|
2012-01-24 02:29:05 +04:00
|
|
|
continue;
|
2019-07-11 10:33:17 +03:00
|
|
|
break;
|
2005-11-09 08:34:54 +03:00
|
|
|
default:
|
2006-06-09 09:12:41 +04:00
|
|
|
if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
|
2012-01-24 02:29:05 +04:00
|
|
|
continue;
|
2005-11-09 08:34:54 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
|
|
|
|
/* no previous value and not saved */
|
2012-01-24 02:29:05 +04:00
|
|
|
continue;
|
2005-11-09 08:34:54 +03:00
|
|
|
conf_unsaved++;
|
|
|
|
/* maybe print value in verbose mode... */
|
2007-07-09 22:43:58 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
for_all_symbols(i, sym) {
|
2005-04-17 02:20:36 +04:00
|
|
|
if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
|
2007-07-09 22:43:58 +04:00
|
|
|
/* 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)
|
2006-06-09 09:12:42 +04:00
|
|
|
sym->flags &= ~SYMBOL_DEF_USER;
|
2005-04-17 02:20:36 +04:00
|
|
|
switch (sym->type) {
|
|
|
|
case S_STRING:
|
|
|
|
case S_INT:
|
|
|
|
case S_HEX:
|
2007-07-09 22:43:58 +04:00
|
|
|
/* 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;
|
2005-04-17 02:20:36 +04:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-10 09:57:22 +03:00
|
|
|
if (conf_warnings || conf_unsaved)
|
|
|
|
conf_set_changed(true);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:45 +03:00
|
|
|
struct comment_style {
|
|
|
|
const char *decoration;
|
|
|
|
const char *prefix;
|
|
|
|
const char *postfix;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct comment_style comment_style_pound = {
|
|
|
|
.decoration = "#",
|
|
|
|
.prefix = "#",
|
|
|
|
.postfix = "#",
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct comment_style comment_style_c = {
|
|
|
|
.decoration = " *",
|
|
|
|
.prefix = "/*",
|
|
|
|
.postfix = " */",
|
|
|
|
};
|
|
|
|
|
|
|
|
static void conf_write_heading(FILE *fp, const struct comment_style *cs)
|
|
|
|
{
|
|
|
|
fprintf(fp, "%s\n", cs->prefix);
|
|
|
|
|
|
|
|
fprintf(fp, "%s Automatically generated file; DO NOT EDIT.\n",
|
|
|
|
cs->decoration);
|
|
|
|
|
|
|
|
fprintf(fp, "%s %s\n", cs->decoration, rootmenu.prompt->text);
|
|
|
|
|
|
|
|
fprintf(fp, "%s\n", cs->postfix);
|
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:48 +03:00
|
|
|
/* The returned pointer must be freed on the caller side */
|
|
|
|
static char *escape_string_value(const char *in)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
char *out;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
len = strlen(in) + strlen("\"\"") + 1;
|
|
|
|
|
|
|
|
p = in;
|
|
|
|
while (1) {
|
|
|
|
p += strcspn(p, "\"\\");
|
|
|
|
|
|
|
|
if (p[0] == '\0')
|
|
|
|
break;
|
|
|
|
|
|
|
|
len++;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
out = xmalloc(len);
|
|
|
|
out[0] = '\0';
|
|
|
|
|
|
|
|
strcat(out, "\"");
|
|
|
|
|
|
|
|
p = in;
|
|
|
|
while (1) {
|
|
|
|
len = strcspn(p, "\"\\");
|
|
|
|
strncat(out, p, len);
|
|
|
|
p += len;
|
|
|
|
|
|
|
|
if (p[0] == '\0')
|
|
|
|
break;
|
|
|
|
|
|
|
|
strcat(out, "\\");
|
|
|
|
strncat(out, p++, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
strcat(out, "\"");
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2011-05-16 07:42:09 +04:00
|
|
|
/*
|
|
|
|
* Kconfig configuration printer
|
|
|
|
*
|
|
|
|
* This printer is used when generating the resulting configuration after
|
|
|
|
* kconfig invocation and `defconfig' files. Unset symbol might be omitted by
|
|
|
|
* passing a non-NULL argument to the printer.
|
|
|
|
*/
|
2021-10-01 08:32:46 +03:00
|
|
|
enum output_n { OUTPUT_N, OUTPUT_N_AS_UNSET, OUTPUT_N_NONE };
|
2011-05-16 07:42:09 +04:00
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
static void __print_symbol(FILE *fp, struct symbol *sym, enum output_n output_n,
|
|
|
|
bool escape_string)
|
2010-08-01 01:35:33 +04:00
|
|
|
{
|
2021-10-01 08:32:46 +03:00
|
|
|
const char *val;
|
|
|
|
char *escaped = NULL;
|
2011-05-16 07:42:09 +04:00
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
if (sym->type == S_UNKNOWN)
|
|
|
|
return;
|
2010-08-01 01:35:33 +04:00
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
val = sym_get_string_value(sym);
|
2011-07-14 23:31:07 +04:00
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
if ((sym->type == S_BOOLEAN || sym->type == S_TRISTATE) &&
|
|
|
|
output_n != OUTPUT_N && *val == 'n') {
|
|
|
|
if (output_n == OUTPUT_N_AS_UNSET)
|
|
|
|
fprintf(fp, "# %s%s is not set\n", CONFIG_, sym->name);
|
|
|
|
return;
|
2011-07-14 23:31:07 +04:00
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
if (sym->type == S_STRING && escape_string) {
|
2021-10-01 08:32:48 +03:00
|
|
|
escaped = escape_string_value(val);
|
2021-10-01 08:32:46 +03:00
|
|
|
val = escaped;
|
2011-05-16 07:42:09 +04:00
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, val);
|
|
|
|
|
|
|
|
free(escaped);
|
2011-05-16 07:42:09 +04:00
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
static void print_symbol_for_dotconfig(FILE *fp, struct symbol *sym)
|
2011-05-16 07:42:09 +04:00
|
|
|
{
|
2021-10-01 08:32:46 +03:00
|
|
|
__print_symbol(fp, sym, OUTPUT_N_AS_UNSET, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_symbol_for_autoconf(FILE *fp, struct symbol *sym)
|
|
|
|
{
|
kbuild: do not quote string values in include/config/auto.conf
The previous commit fixed up all shell scripts to not include
include/config/auto.conf.
Now that include/config/auto.conf is only included by Makefiles,
we can change it into a more Make-friendly form.
Previously, Kconfig output string values enclosed with double-quotes
(both in the .config and include/config/auto.conf):
CONFIG_X="foo bar"
Unlike shell, Make handles double-quotes (and single-quotes as well)
verbatim. We must rip them off when used.
There are some patterns:
[1] $(patsubst "%",%,$(CONFIG_X))
[2] $(CONFIG_X:"%"=%)
[3] $(subst ",,$(CONFIG_X))
[4] $(shell echo $(CONFIG_X))
These are not only ugly, but also fragile.
[1] and [2] do not work if the value contains spaces, like
CONFIG_X=" foo bar "
[3] does not work correctly if the value contains double-quotes like
CONFIG_X="foo\"bar"
[4] seems to work better, but has a cost of forking a process.
Anyway, quoted strings were always PITA for our Makefiles.
This commit changes Kconfig to stop quoting in include/config/auto.conf.
These are the string type symbols referenced in Makefiles or scripts:
ACPI_CUSTOM_DSDT_FILE
ARC_BUILTIN_DTB_NAME
ARC_TUNE_MCPU
BUILTIN_DTB_SOURCE
CC_IMPLICIT_FALLTHROUGH
CC_VERSION_TEXT
CFG80211_EXTRA_REGDB_KEYDIR
EXTRA_FIRMWARE
EXTRA_FIRMWARE_DIR
EXTRA_TARGETS
H8300_BUILTIN_DTB
INITRAMFS_SOURCE
LOCALVERSION
MODULE_SIG_HASH
MODULE_SIG_KEY
NDS32_BUILTIN_DTB
NIOS2_DTB_SOURCE
OPENRISC_BUILTIN_DTB
SOC_CANAAN_K210_DTB_SOURCE
SYSTEM_BLACKLIST_HASH_LIST
SYSTEM_REVOCATION_KEYS
SYSTEM_TRUSTED_KEYS
TARGET_CPU
UNUSED_KSYMS_WHITELIST
XILINX_MICROBLAZE0_FAMILY
XILINX_MICROBLAZE0_HW_VER
XTENSA_VARIANT_NAME
I checked them one by one, and fixed up the code where necessary.
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
2021-12-14 05:53:53 +03:00
|
|
|
__print_symbol(fp, sym, OUTPUT_N_NONE, false);
|
2021-10-01 08:32:46 +03:00
|
|
|
}
|
2011-05-16 07:42:09 +04:00
|
|
|
|
2021-10-01 08:32:47 +03:00
|
|
|
void print_symbol_for_listconfig(struct symbol *sym)
|
|
|
|
{
|
|
|
|
__print_symbol(stdout, sym, OUTPUT_N, true);
|
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
static void print_symbol_for_c(FILE *fp, struct symbol *sym)
|
2011-05-16 07:42:09 +04:00
|
|
|
{
|
2021-10-01 08:32:44 +03:00
|
|
|
const char *val;
|
2021-10-01 08:32:46 +03:00
|
|
|
const char *sym_suffix = "";
|
|
|
|
const char *val_prefix = "";
|
2021-10-01 08:32:44 +03:00
|
|
|
char *escaped = NULL;
|
2011-05-16 07:42:09 +04:00
|
|
|
|
2021-10-01 08:32:44 +03:00
|
|
|
if (sym->type == S_UNKNOWN)
|
|
|
|
return;
|
|
|
|
|
|
|
|
val = sym_get_string_value(sym);
|
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
switch (sym->type) {
|
|
|
|
case S_BOOLEAN:
|
|
|
|
case S_TRISTATE:
|
|
|
|
switch (*val) {
|
|
|
|
case 'n':
|
|
|
|
return;
|
|
|
|
case 'm':
|
|
|
|
sym_suffix = "_MODULE";
|
|
|
|
/* fall through */
|
|
|
|
default:
|
|
|
|
val = "1";
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case S_HEX:
|
|
|
|
if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X'))
|
|
|
|
val_prefix = "0x";
|
|
|
|
break;
|
|
|
|
case S_STRING:
|
2021-10-01 08:32:48 +03:00
|
|
|
escaped = escape_string_value(val);
|
2021-10-01 08:32:44 +03:00
|
|
|
val = escaped;
|
2021-10-01 08:32:46 +03:00
|
|
|
default:
|
|
|
|
break;
|
2010-08-01 01:35:33 +04:00
|
|
|
}
|
2021-10-01 08:32:44 +03:00
|
|
|
|
2021-10-01 08:32:46 +03:00
|
|
|
fprintf(fp, "#define %s%s%s %s%s\n", CONFIG_, sym->name, sym_suffix,
|
|
|
|
val_prefix, val);
|
2021-10-01 08:32:44 +03:00
|
|
|
|
|
|
|
free(escaped);
|
2010-08-01 01:35:33 +04:00
|
|
|
}
|
|
|
|
|
2010-08-01 01:35:34 +04:00
|
|
|
/*
|
|
|
|
* Write out a minimal config.
|
|
|
|
* All values that has default values are skipped as this is redundant.
|
|
|
|
*/
|
|
|
|
int conf_write_defconfig(const char *filename)
|
|
|
|
{
|
|
|
|
struct symbol *sym;
|
|
|
|
struct menu *menu;
|
|
|
|
FILE *out;
|
|
|
|
|
|
|
|
out = fopen(filename, "w");
|
|
|
|
if (!out)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
sym_clear_all_valid();
|
|
|
|
|
|
|
|
/* Traverse all menus to find all relevant symbols */
|
|
|
|
menu = rootmenu.list;
|
|
|
|
|
|
|
|
while (menu != NULL)
|
|
|
|
{
|
|
|
|
sym = menu->sym;
|
|
|
|
if (sym == NULL) {
|
|
|
|
if (!menu_is_visible(menu))
|
|
|
|
goto next_menu;
|
|
|
|
} else if (!sym_is_choice(sym)) {
|
|
|
|
sym_calc_value(sym);
|
|
|
|
if (!(sym->flags & SYMBOL_WRITE))
|
|
|
|
goto next_menu;
|
|
|
|
sym->flags &= ~SYMBOL_WRITE;
|
|
|
|
/* If we cannot change the symbol - skip */
|
2019-07-04 13:50:41 +03:00
|
|
|
if (!sym_is_changeable(sym))
|
2010-08-01 01:35:34 +04:00
|
|
|
goto next_menu;
|
|
|
|
/* If symbol equals to default value - skip */
|
|
|
|
if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
|
|
|
|
goto next_menu;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If symbol is a choice value and equals to the
|
|
|
|
* default for a choice - skip.
|
2010-08-15 01:22:16 +04:00
|
|
|
* But only if value is bool and equal to "y" and
|
|
|
|
* choice is not "optional".
|
|
|
|
* (If choice is "optional" then all values can be "n")
|
2010-08-01 01:35:34 +04:00
|
|
|
*/
|
|
|
|
if (sym_is_choice_value(sym)) {
|
|
|
|
struct symbol *cs;
|
|
|
|
struct symbol *ds;
|
|
|
|
|
|
|
|
cs = prop_get_symbol(sym_get_choice_prop(sym));
|
|
|
|
ds = sym_choice_default(cs);
|
2010-08-15 01:22:16 +04:00
|
|
|
if (!sym_is_optional(cs) && sym == ds) {
|
2010-08-12 11:11:51 +04:00
|
|
|
if ((sym->type == S_BOOLEAN) &&
|
|
|
|
sym_get_tristate_value(sym) == yes)
|
2010-08-01 01:35:34 +04:00
|
|
|
goto next_menu;
|
|
|
|
}
|
|
|
|
}
|
2021-10-01 08:32:46 +03:00
|
|
|
print_symbol_for_dotconfig(out, sym);
|
2010-08-01 01:35:34 +04:00
|
|
|
}
|
|
|
|
next_menu:
|
|
|
|
if (menu->list != NULL) {
|
|
|
|
menu = menu->list;
|
|
|
|
}
|
|
|
|
else if (menu->next != NULL) {
|
|
|
|
menu = menu->next;
|
|
|
|
} else {
|
|
|
|
while ((menu = menu->parent)) {
|
|
|
|
if (menu->next != NULL) {
|
|
|
|
menu = menu->next;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(out);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
int conf_write(const char *name)
|
|
|
|
{
|
2006-06-09 09:12:39 +04:00
|
|
|
FILE *out;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct symbol *sym;
|
|
|
|
struct menu *menu;
|
|
|
|
const char *str;
|
kconfig: do not accept a directory for configuration output
Currently, conf_write() can be called with a directory name instead
of a file name. As far as I see, this can happen for menuconfig,
nconfig, gconfig.
If it is given with a directory path, conf_write() kindly appends
getenv("KCONFIG_CONFIG"), but this ends up with hacky dir/basename
handling, and screwed up in corner-cases like "what if KCONFIG_CONFIG
is an absolute path?" as discussed before:
https://patchwork.kernel.org/patch/9910037/
Since conf_write() is already messed up, I'd say "do not do it".
Please pass a file path all the time. If a directory path is specified
for the configuration output, conf_write() will simply error out.
Now that the tmp file is created in the same directory as the .config,
the previously reported "what if KCONFIG_CONFIG points to a different
file system?" has been solved.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Cc: Nicolas Porcel <nicolasporcel06@gmail.com>
2019-05-10 09:12:04 +03:00
|
|
|
char tmpname[PATH_MAX + 1], oldname[PATH_MAX + 1];
|
2005-04-17 02:20:36 +04:00
|
|
|
char *env;
|
2019-08-03 13:02:12 +03:00
|
|
|
int i;
|
2019-05-17 22:42:22 +03:00
|
|
|
bool need_newline = false;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
kconfig: do not accept a directory for configuration output
Currently, conf_write() can be called with a directory name instead
of a file name. As far as I see, this can happen for menuconfig,
nconfig, gconfig.
If it is given with a directory path, conf_write() kindly appends
getenv("KCONFIG_CONFIG"), but this ends up with hacky dir/basename
handling, and screwed up in corner-cases like "what if KCONFIG_CONFIG
is an absolute path?" as discussed before:
https://patchwork.kernel.org/patch/9910037/
Since conf_write() is already messed up, I'd say "do not do it".
Please pass a file path all the time. If a directory path is specified
for the configuration output, conf_write() will simply error out.
Now that the tmp file is created in the same directory as the .config,
the previously reported "what if KCONFIG_CONFIG points to a different
file system?" has been solved.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Cc: Nicolas Porcel <nicolasporcel06@gmail.com>
2019-05-10 09:12:04 +03:00
|
|
|
if (!name)
|
|
|
|
name = conf_get_configname();
|
|
|
|
|
|
|
|
if (!*name) {
|
|
|
|
fprintf(stderr, "config name is empty\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_dir(name)) {
|
|
|
|
fprintf(stderr, "%s: Is a directory\n", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2019-05-10 19:56:01 +03:00
|
|
|
if (make_parent_dir(name))
|
|
|
|
return -1;
|
|
|
|
|
2006-06-09 09:12:51 +04:00
|
|
|
env = getenv("KCONFIG_OVERWRITECONFIG");
|
kconfig: do not accept a directory for configuration output
Currently, conf_write() can be called with a directory name instead
of a file name. As far as I see, this can happen for menuconfig,
nconfig, gconfig.
If it is given with a directory path, conf_write() kindly appends
getenv("KCONFIG_CONFIG"), but this ends up with hacky dir/basename
handling, and screwed up in corner-cases like "what if KCONFIG_CONFIG
is an absolute path?" as discussed before:
https://patchwork.kernel.org/patch/9910037/
Since conf_write() is already messed up, I'd say "do not do it".
Please pass a file path all the time. If a directory path is specified
for the configuration output, conf_write() will simply error out.
Now that the tmp file is created in the same directory as the .config,
the previously reported "what if KCONFIG_CONFIG points to a different
file system?" has been solved.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Cc: Nicolas Porcel <nicolasporcel06@gmail.com>
2019-05-10 09:12:04 +03:00
|
|
|
if (env && *env) {
|
2006-06-09 09:12:51 +04:00
|
|
|
*tmpname = 0;
|
kconfig: do not accept a directory for configuration output
Currently, conf_write() can be called with a directory name instead
of a file name. As far as I see, this can happen for menuconfig,
nconfig, gconfig.
If it is given with a directory path, conf_write() kindly appends
getenv("KCONFIG_CONFIG"), but this ends up with hacky dir/basename
handling, and screwed up in corner-cases like "what if KCONFIG_CONFIG
is an absolute path?" as discussed before:
https://patchwork.kernel.org/patch/9910037/
Since conf_write() is already messed up, I'd say "do not do it".
Please pass a file path all the time. If a directory path is specified
for the configuration output, conf_write() will simply error out.
Now that the tmp file is created in the same directory as the .config,
the previously reported "what if KCONFIG_CONFIG points to a different
file system?" has been solved.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Cc: Nicolas Porcel <nicolasporcel06@gmail.com>
2019-05-10 09:12:04 +03:00
|
|
|
out = fopen(name, "w");
|
|
|
|
} else {
|
|
|
|
snprintf(tmpname, sizeof(tmpname), "%s.%d.tmp",
|
|
|
|
name, (int)getpid());
|
|
|
|
out = fopen(tmpname, "w");
|
2006-06-09 09:12:51 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!out)
|
|
|
|
return 1;
|
2006-06-09 09:12:51 +04:00
|
|
|
|
2021-10-01 08:32:45 +03:00
|
|
|
conf_write_heading(out, &comment_style_pound);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-12-13 11:34:06 +03:00
|
|
|
if (!conf_get_changed())
|
2005-04-17 02:20:36 +04:00
|
|
|
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);
|
2019-05-17 22:42:22 +03:00
|
|
|
need_newline = false;
|
kconfig: fix missing choice values in auto.conf
Since commit 00c864f8903d ("kconfig: allow all config targets to write
auto.conf if missing"), Kconfig creates include/config/auto.conf in the
defconfig stage when it is missing.
Joonas Kylmälä reported incorrect auto.conf generation under some
circumstances.
To reproduce it, apply the following diff:
| --- a/arch/arm/configs/imx_v6_v7_defconfig
| +++ b/arch/arm/configs/imx_v6_v7_defconfig
| @@ -345,14 +345,7 @@ CONFIG_USB_CONFIGFS_F_MIDI=y
| CONFIG_USB_CONFIGFS_F_HID=y
| CONFIG_USB_CONFIGFS_F_UVC=y
| CONFIG_USB_CONFIGFS_F_PRINTER=y
| -CONFIG_USB_ZERO=m
| -CONFIG_USB_AUDIO=m
| -CONFIG_USB_ETH=m
| -CONFIG_USB_G_NCM=m
| -CONFIG_USB_GADGETFS=m
| -CONFIG_USB_FUNCTIONFS=m
| -CONFIG_USB_MASS_STORAGE=m
| -CONFIG_USB_G_SERIAL=m
| +CONFIG_USB_FUNCTIONFS=y
| CONFIG_MMC=y
| CONFIG_MMC_SDHCI=y
| CONFIG_MMC_SDHCI_PLTFM=y
And then, run:
$ make ARCH=arm mrproper imx_v6_v7_defconfig
You will see CONFIG_USB_FUNCTIONFS=y is correctly contained in the
.config, but not in the auto.conf.
Please note drivers/usb/gadget/legacy/Kconfig is included from a choice
block in drivers/usb/gadget/Kconfig. So USB_FUNCTIONFS is a choice value.
This is probably a similar situation described in commit beaaddb62540
("kconfig: tests: test defconfig when two choices interact").
When sym_calc_choice() is called, the choice symbol forgets the
SYMBOL_DEF_USER unless all of its choice values are explicitly set by
the user.
The choice symbol is given just one chance to recall it because
set_all_choice_values() is called if SYMBOL_NEED_SET_CHOICE_VALUES
is set.
When sym_calc_choice() is called again, the choice symbol forgets it
forever, since SYMBOL_NEED_SET_CHOICE_VALUES is a one-time aid.
Hence, we cannot call sym_clear_all_valid() again and again.
It is crazy to repeat set and unset of internal flags. However, we
cannot simply get rid of "sym->flags &= flags | ~SYMBOL_DEF_USER;"
Doing so would re-introduce the problem solved by commit 5d09598d488f
("kconfig: fix new choices being skipped upon config update").
To work around the issue, conf_write_autoconf() stopped calling
sym_clear_all_valid().
conf_write() must be changed accordingly. Currently, it clears
SYMBOL_WRITE after the symbol is written into the .config file. This
is needed to prevent it from writing the same symbol multiple times in
case the symbol is declared in two or more locations. I added the new
flag SYMBOL_WRITTEN, to track the symbols that have been written.
Anyway, this is a cheesy workaround in order to suppress the issue
as far as defconfig is concerned.
Handling of choices is totally broken. sym_clear_all_valid() is called
every time a user touches a symbol from the GUI interface. To reproduce
it, just add a new symbol drivers/usb/gadget/legacy/Kconfig, then touch
around unrelated symbols from menuconfig. USB_FUNCTIONFS will disappear
from the .config file.
I added the Fixes tag since it is more fatal than before. But, this
has been broken since long long time before, and still it is.
We should take a closer look to fix this correctly somehow.
Fixes: 00c864f8903d ("kconfig: allow all config targets to write auto.conf if missing")
Cc: linux-stable <stable@vger.kernel.org> # 4.19+
Reported-by: Joonas Kylmälä <joonas.kylmala@iki.fi>
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Tested-by: Joonas Kylmälä <joonas.kylmala@iki.fi>
2019-07-12 09:07:09 +03:00
|
|
|
} else if (!(sym->flags & SYMBOL_CHOICE) &&
|
|
|
|
!(sym->flags & SYMBOL_WRITTEN)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
sym_calc_value(sym);
|
|
|
|
if (!(sym->flags & SYMBOL_WRITE))
|
|
|
|
goto next;
|
2019-05-17 22:42:22 +03:00
|
|
|
if (need_newline) {
|
|
|
|
fprintf(out, "\n");
|
|
|
|
need_newline = false;
|
|
|
|
}
|
kconfig: fix missing choice values in auto.conf
Since commit 00c864f8903d ("kconfig: allow all config targets to write
auto.conf if missing"), Kconfig creates include/config/auto.conf in the
defconfig stage when it is missing.
Joonas Kylmälä reported incorrect auto.conf generation under some
circumstances.
To reproduce it, apply the following diff:
| --- a/arch/arm/configs/imx_v6_v7_defconfig
| +++ b/arch/arm/configs/imx_v6_v7_defconfig
| @@ -345,14 +345,7 @@ CONFIG_USB_CONFIGFS_F_MIDI=y
| CONFIG_USB_CONFIGFS_F_HID=y
| CONFIG_USB_CONFIGFS_F_UVC=y
| CONFIG_USB_CONFIGFS_F_PRINTER=y
| -CONFIG_USB_ZERO=m
| -CONFIG_USB_AUDIO=m
| -CONFIG_USB_ETH=m
| -CONFIG_USB_G_NCM=m
| -CONFIG_USB_GADGETFS=m
| -CONFIG_USB_FUNCTIONFS=m
| -CONFIG_USB_MASS_STORAGE=m
| -CONFIG_USB_G_SERIAL=m
| +CONFIG_USB_FUNCTIONFS=y
| CONFIG_MMC=y
| CONFIG_MMC_SDHCI=y
| CONFIG_MMC_SDHCI_PLTFM=y
And then, run:
$ make ARCH=arm mrproper imx_v6_v7_defconfig
You will see CONFIG_USB_FUNCTIONFS=y is correctly contained in the
.config, but not in the auto.conf.
Please note drivers/usb/gadget/legacy/Kconfig is included from a choice
block in drivers/usb/gadget/Kconfig. So USB_FUNCTIONFS is a choice value.
This is probably a similar situation described in commit beaaddb62540
("kconfig: tests: test defconfig when two choices interact").
When sym_calc_choice() is called, the choice symbol forgets the
SYMBOL_DEF_USER unless all of its choice values are explicitly set by
the user.
The choice symbol is given just one chance to recall it because
set_all_choice_values() is called if SYMBOL_NEED_SET_CHOICE_VALUES
is set.
When sym_calc_choice() is called again, the choice symbol forgets it
forever, since SYMBOL_NEED_SET_CHOICE_VALUES is a one-time aid.
Hence, we cannot call sym_clear_all_valid() again and again.
It is crazy to repeat set and unset of internal flags. However, we
cannot simply get rid of "sym->flags &= flags | ~SYMBOL_DEF_USER;"
Doing so would re-introduce the problem solved by commit 5d09598d488f
("kconfig: fix new choices being skipped upon config update").
To work around the issue, conf_write_autoconf() stopped calling
sym_clear_all_valid().
conf_write() must be changed accordingly. Currently, it clears
SYMBOL_WRITE after the symbol is written into the .config file. This
is needed to prevent it from writing the same symbol multiple times in
case the symbol is declared in two or more locations. I added the new
flag SYMBOL_WRITTEN, to track the symbols that have been written.
Anyway, this is a cheesy workaround in order to suppress the issue
as far as defconfig is concerned.
Handling of choices is totally broken. sym_clear_all_valid() is called
every time a user touches a symbol from the GUI interface. To reproduce
it, just add a new symbol drivers/usb/gadget/legacy/Kconfig, then touch
around unrelated symbols from menuconfig. USB_FUNCTIONFS will disappear
from the .config file.
I added the Fixes tag since it is more fatal than before. But, this
has been broken since long long time before, and still it is.
We should take a closer look to fix this correctly somehow.
Fixes: 00c864f8903d ("kconfig: allow all config targets to write auto.conf if missing")
Cc: linux-stable <stable@vger.kernel.org> # 4.19+
Reported-by: Joonas Kylmälä <joonas.kylmala@iki.fi>
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Tested-by: Joonas Kylmälä <joonas.kylmala@iki.fi>
2019-07-12 09:07:09 +03:00
|
|
|
sym->flags |= SYMBOL_WRITTEN;
|
2021-10-01 08:32:46 +03:00
|
|
|
print_symbol_for_dotconfig(out, sym);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2010-08-01 01:35:33 +04:00
|
|
|
next:
|
2005-04-17 02:20:36 +04:00
|
|
|
if (menu->list) {
|
|
|
|
menu = menu->list;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (menu->next)
|
|
|
|
menu = menu->next;
|
|
|
|
else while ((menu = menu->parent)) {
|
2019-05-17 22:42:22 +03:00
|
|
|
if (!menu->sym && menu_is_visible(menu) &&
|
|
|
|
menu != &rootmenu) {
|
|
|
|
str = menu_get_prompt(menu);
|
|
|
|
fprintf(out, "# end of %s\n", str);
|
|
|
|
need_newline = true;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
if (menu->next) {
|
|
|
|
menu = menu->next;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(out);
|
2006-06-09 09:12:51 +04:00
|
|
|
|
2019-08-03 13:02:12 +03:00
|
|
|
for_all_symbols(i, sym)
|
|
|
|
sym->flags &= ~SYMBOL_WRITTEN;
|
|
|
|
|
2006-06-09 09:12:51 +04:00
|
|
|
if (*tmpname) {
|
2019-05-10 09:12:05 +03:00
|
|
|
if (is_same(name, tmpname)) {
|
|
|
|
conf_message("No change to %s", name);
|
|
|
|
unlink(tmpname);
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_set_changed(false);
|
2019-05-10 09:12:05 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
kconfig: do not accept a directory for configuration output
Currently, conf_write() can be called with a directory name instead
of a file name. As far as I see, this can happen for menuconfig,
nconfig, gconfig.
If it is given with a directory path, conf_write() kindly appends
getenv("KCONFIG_CONFIG"), but this ends up with hacky dir/basename
handling, and screwed up in corner-cases like "what if KCONFIG_CONFIG
is an absolute path?" as discussed before:
https://patchwork.kernel.org/patch/9910037/
Since conf_write() is already messed up, I'd say "do not do it".
Please pass a file path all the time. If a directory path is specified
for the configuration output, conf_write() will simply error out.
Now that the tmp file is created in the same directory as the .config,
the previously reported "what if KCONFIG_CONFIG points to a different
file system?" has been solved.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Cc: Nicolas Porcel <nicolasporcel06@gmail.com>
2019-05-10 09:12:04 +03:00
|
|
|
snprintf(oldname, sizeof(oldname), "%s.old", name);
|
|
|
|
rename(name, oldname);
|
|
|
|
if (rename(tmpname, name))
|
2006-06-09 09:12:51 +04:00
|
|
|
return 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
kconfig: do not accept a directory for configuration output
Currently, conf_write() can be called with a directory name instead
of a file name. As far as I see, this can happen for menuconfig,
nconfig, gconfig.
If it is given with a directory path, conf_write() kindly appends
getenv("KCONFIG_CONFIG"), but this ends up with hacky dir/basename
handling, and screwed up in corner-cases like "what if KCONFIG_CONFIG
is an absolute path?" as discussed before:
https://patchwork.kernel.org/patch/9910037/
Since conf_write() is already messed up, I'd say "do not do it".
Please pass a file path all the time. If a directory path is specified
for the configuration output, conf_write() will simply error out.
Now that the tmp file is created in the same directory as the .config,
the previously reported "what if KCONFIG_CONFIG points to a different
file system?" has been solved.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Cc: Nicolas Porcel <nicolasporcel06@gmail.com>
2019-05-10 09:12:04 +03:00
|
|
|
conf_message("configuration written to %s", name);
|
2006-06-09 09:12:38 +04:00
|
|
|
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_set_changed(false);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-06-09 09:12:39 +04:00
|
|
|
|
2018-07-20 10:46:26 +03:00
|
|
|
/* write a dependency file as used by kbuild to track dependencies */
|
2021-10-01 08:32:51 +03:00
|
|
|
static int conf_write_autoconf_cmd(const char *autoconf_name)
|
2018-07-20 10:46:26 +03:00
|
|
|
{
|
2021-10-01 08:32:51 +03:00
|
|
|
char name[PATH_MAX], tmp[PATH_MAX];
|
2018-07-20 10:46:26 +03:00
|
|
|
struct file *file;
|
|
|
|
FILE *out;
|
2021-10-01 08:32:51 +03:00
|
|
|
int ret;
|
2018-07-20 10:46:26 +03:00
|
|
|
|
2021-10-01 08:32:51 +03:00
|
|
|
ret = snprintf(name, sizeof(name), "%s.cmd", autoconf_name);
|
|
|
|
if (ret >= sizeof(name)) /* check truncation */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (make_parent_dir(name))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = snprintf(tmp, sizeof(tmp), "%s.cmd.tmp", autoconf_name);
|
|
|
|
if (ret >= sizeof(tmp)) /* check truncation */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
out = fopen(tmp, "w");
|
|
|
|
if (!out) {
|
|
|
|
perror("fopen");
|
|
|
|
return -1;
|
2018-07-20 10:46:26 +03:00
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:51 +03:00
|
|
|
fprintf(out, "deps_config := \\\n");
|
|
|
|
for (file = file_list; file; file = file->next)
|
|
|
|
fprintf(out, "\t%s \\\n", file->name);
|
|
|
|
|
|
|
|
fprintf(out, "\n%s: $(deps_config)\n\n", autoconf_name);
|
|
|
|
|
|
|
|
env_write_dep(out, autoconf_name);
|
2018-07-20 10:46:26 +03:00
|
|
|
|
|
|
|
fprintf(out, "\n$(deps_config): ;\n");
|
2021-10-01 08:32:51 +03:00
|
|
|
|
2022-02-12 19:18:37 +03:00
|
|
|
fflush(out);
|
2022-02-08 09:26:18 +03:00
|
|
|
ret = ferror(out); /* error check for all fprintf() calls */
|
2018-07-20 10:46:26 +03:00
|
|
|
fclose(out);
|
2022-02-08 09:26:18 +03:00
|
|
|
if (ret)
|
|
|
|
return -1;
|
2018-07-20 10:46:29 +03:00
|
|
|
|
2021-10-01 08:32:51 +03:00
|
|
|
if (rename(tmp, name)) {
|
|
|
|
perror("rename");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2018-07-20 10:46:26 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-30 12:15:49 +03:00
|
|
|
static int conf_touch_deps(void)
|
2006-06-09 09:12:42 +04:00
|
|
|
{
|
2022-02-11 12:27:36 +03:00
|
|
|
const char *name, *tmp;
|
2006-06-09 09:12:42 +04:00
|
|
|
struct symbol *sym;
|
2018-11-30 12:15:50 +03:00
|
|
|
int res, i;
|
|
|
|
|
2009-05-18 03:36:54 +04:00
|
|
|
name = conf_get_autoconfig_name();
|
2022-02-11 12:27:36 +03:00
|
|
|
tmp = strrchr(name, '/');
|
|
|
|
depfile_prefix_len = tmp ? tmp - name + 1 : 0;
|
|
|
|
if (depfile_prefix_len + 1 > sizeof(depfile_path))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
strncpy(depfile_path, name, depfile_prefix_len);
|
|
|
|
depfile_path[depfile_prefix_len] = 0;
|
|
|
|
|
2006-06-09 09:12:42 +04:00
|
|
|
conf_read_simple(name, S_DEF_AUTO);
|
2016-01-14 21:13:49 +03:00
|
|
|
sym_calc_value(modules_sym);
|
2006-06-09 09:12:42 +04:00
|
|
|
|
|
|
|
for_all_symbols(i, sym) {
|
|
|
|
sym_calc_value(sym);
|
2018-07-03 15:43:31 +03:00
|
|
|
if ((sym->flags & SYMBOL_NO_WRITE) || !sym->name)
|
2006-06-09 09:12:42 +04:00
|
|
|
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').
|
|
|
|
*/
|
|
|
|
|
2018-11-30 12:15:50 +03:00
|
|
|
res = conf_touch_dep(sym->name);
|
|
|
|
if (res)
|
|
|
|
return res;
|
2006-06-09 09:12:42 +04:00
|
|
|
}
|
|
|
|
|
2018-11-30 12:15:50 +03:00
|
|
|
return 0;
|
2006-06-09 09:12:42 +04:00
|
|
|
}
|
|
|
|
|
2021-10-01 08:32:50 +03:00
|
|
|
static int __conf_write_autoconf(const char *filename,
|
|
|
|
void (*print_symbol)(FILE *, struct symbol *),
|
|
|
|
const struct comment_style *comment_style)
|
|
|
|
{
|
|
|
|
char tmp[PATH_MAX];
|
|
|
|
FILE *file;
|
|
|
|
struct symbol *sym;
|
|
|
|
int ret, i;
|
|
|
|
|
|
|
|
if (make_parent_dir(filename))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ret = snprintf(tmp, sizeof(tmp), "%s.tmp", filename);
|
|
|
|
if (ret >= sizeof(tmp)) /* check truncation */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
file = fopen(tmp, "w");
|
|
|
|
if (!file) {
|
|
|
|
perror("fopen");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
conf_write_heading(file, comment_style);
|
|
|
|
|
|
|
|
for_all_symbols(i, sym)
|
|
|
|
if ((sym->flags & SYMBOL_WRITE) && sym->name)
|
|
|
|
print_symbol(file, sym);
|
|
|
|
|
2022-02-12 19:18:37 +03:00
|
|
|
fflush(file);
|
2021-10-01 08:32:50 +03:00
|
|
|
/* check possible errors in conf_write_heading() and print_symbol() */
|
2022-02-08 09:26:18 +03:00
|
|
|
ret = ferror(file);
|
2021-10-01 08:32:50 +03:00
|
|
|
fclose(file);
|
2022-02-08 09:26:18 +03:00
|
|
|
if (ret)
|
|
|
|
return -1;
|
2021-10-01 08:32:50 +03:00
|
|
|
|
|
|
|
if (rename(tmp, filename)) {
|
|
|
|
perror("rename");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
kconfig: allow all config targets to write auto.conf if missing
Currently, only syncconfig creates or updates include/config/auto.conf
and some other files. Other config targets create or update only the
.config file.
When you configure and build the kernel from a pristine source tree,
any config target is followed by syncconfig in the build stage since
include/config/auto.conf is missing.
We are moving compiler tests from Makefile to Kconfig. It means that
parsing Kconfig files will be more costly since Kconfig invokes the
compiler commands internally. Thus, we want to avoid invoking Kconfig
twice (one for *config to create the .config, and one for syncconfig
to synchronize the auto.conf). If auto.conf does not exist, we can
generate all configuration files in the first configuration stage,
which will save the syncconfig in the build stage.
Please note this should be done only when auto.conf is missing. If
*config blindly did this, time stamp files under include/config/ would
be unnecessarily touched, triggering unneeded rebuild of objects.
I assume a scenario like this:
1. You have a source tree that has already been built
with CONFIG_FOO disabled
2. Run "make menuconfig" to enable CONFIG_FOO
3. CONFIG_FOO turns out to be unnecessary.
Run "make menuconfig" again to disable CONFIG_FOO
4. Run "make"
In this case, include/config/foo.h should not be touched since there
is no change in CONFIG_FOO. The sync process should be delayed until
the user really attempts to build the kernel.
This commit has another motivation; I want to suppress the 'No such
file or directory' warning from the 'include' directive.
The top-level Makefile includes auto.conf with '-include' directive,
like this:
ifeq ($(dot-config),1)
-include include/config/auto.conf
endif
This looks strange because auto.conf is mandatory when dot-config is 1.
I guess only the reason of using '-include' is to suppress the warning
'include/config/auto.conf: No such file or directory' when building
from a clean tree. However, this has a side-effect; Make considers
the files included by '-include' are optional. Hence, Make continues
to build even if it fails to generate include/config/auto.conf. I will
change this in the next commit, but the warning message is annoying.
(At least, kbuild test robot reports it as a regression.)
With this commit, Kconfig will generate all configuration files together
with the .config and I guess it is a solution good enough to suppress
the warning.
Note:
GNU Make 4.2 or later does not display the warning from the 'include'
directive if include files are successfully generated. See GNU Make
commit 87a5f98d248f ("[SV 102] Don't show unnecessary include file
errors.") However, older GNU Make versions are still widely used.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-07-20 10:46:31 +03:00
|
|
|
int conf_write_autoconf(int overwrite)
|
2006-06-09 09:12:39 +04:00
|
|
|
{
|
|
|
|
struct symbol *sym;
|
kconfig: allow all config targets to write auto.conf if missing
Currently, only syncconfig creates or updates include/config/auto.conf
and some other files. Other config targets create or update only the
.config file.
When you configure and build the kernel from a pristine source tree,
any config target is followed by syncconfig in the build stage since
include/config/auto.conf is missing.
We are moving compiler tests from Makefile to Kconfig. It means that
parsing Kconfig files will be more costly since Kconfig invokes the
compiler commands internally. Thus, we want to avoid invoking Kconfig
twice (one for *config to create the .config, and one for syncconfig
to synchronize the auto.conf). If auto.conf does not exist, we can
generate all configuration files in the first configuration stage,
which will save the syncconfig in the build stage.
Please note this should be done only when auto.conf is missing. If
*config blindly did this, time stamp files under include/config/ would
be unnecessarily touched, triggering unneeded rebuild of objects.
I assume a scenario like this:
1. You have a source tree that has already been built
with CONFIG_FOO disabled
2. Run "make menuconfig" to enable CONFIG_FOO
3. CONFIG_FOO turns out to be unnecessary.
Run "make menuconfig" again to disable CONFIG_FOO
4. Run "make"
In this case, include/config/foo.h should not be touched since there
is no change in CONFIG_FOO. The sync process should be delayed until
the user really attempts to build the kernel.
This commit has another motivation; I want to suppress the 'No such
file or directory' warning from the 'include' directive.
The top-level Makefile includes auto.conf with '-include' directive,
like this:
ifeq ($(dot-config),1)
-include include/config/auto.conf
endif
This looks strange because auto.conf is mandatory when dot-config is 1.
I guess only the reason of using '-include' is to suppress the warning
'include/config/auto.conf: No such file or directory' when building
from a clean tree. However, this has a side-effect; Make considers
the files included by '-include' are optional. Hence, Make continues
to build even if it fails to generate include/config/auto.conf. I will
change this in the next commit, but the warning message is annoying.
(At least, kbuild test robot reports it as a regression.)
With this commit, Kconfig will generate all configuration files together
with the .config and I guess it is a solution good enough to suppress
the warning.
Note:
GNU Make 4.2 or later does not display the warning from the 'include'
directive if include files are successfully generated. See GNU Make
commit 87a5f98d248f ("[SV 102] Don't show unnecessary include file
errors.") However, older GNU Make versions are still widely used.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-07-20 10:46:31 +03:00
|
|
|
const char *autoconf_name = conf_get_autoconfig_name();
|
2021-10-01 08:32:50 +03:00
|
|
|
int ret, i;
|
2006-06-09 09:12:39 +04:00
|
|
|
|
kconfig: allow all config targets to write auto.conf if missing
Currently, only syncconfig creates or updates include/config/auto.conf
and some other files. Other config targets create or update only the
.config file.
When you configure and build the kernel from a pristine source tree,
any config target is followed by syncconfig in the build stage since
include/config/auto.conf is missing.
We are moving compiler tests from Makefile to Kconfig. It means that
parsing Kconfig files will be more costly since Kconfig invokes the
compiler commands internally. Thus, we want to avoid invoking Kconfig
twice (one for *config to create the .config, and one for syncconfig
to synchronize the auto.conf). If auto.conf does not exist, we can
generate all configuration files in the first configuration stage,
which will save the syncconfig in the build stage.
Please note this should be done only when auto.conf is missing. If
*config blindly did this, time stamp files under include/config/ would
be unnecessarily touched, triggering unneeded rebuild of objects.
I assume a scenario like this:
1. You have a source tree that has already been built
with CONFIG_FOO disabled
2. Run "make menuconfig" to enable CONFIG_FOO
3. CONFIG_FOO turns out to be unnecessary.
Run "make menuconfig" again to disable CONFIG_FOO
4. Run "make"
In this case, include/config/foo.h should not be touched since there
is no change in CONFIG_FOO. The sync process should be delayed until
the user really attempts to build the kernel.
This commit has another motivation; I want to suppress the 'No such
file or directory' warning from the 'include' directive.
The top-level Makefile includes auto.conf with '-include' directive,
like this:
ifeq ($(dot-config),1)
-include include/config/auto.conf
endif
This looks strange because auto.conf is mandatory when dot-config is 1.
I guess only the reason of using '-include' is to suppress the warning
'include/config/auto.conf: No such file or directory' when building
from a clean tree. However, this has a side-effect; Make considers
the files included by '-include' are optional. Hence, Make continues
to build even if it fails to generate include/config/auto.conf. I will
change this in the next commit, but the warning message is annoying.
(At least, kbuild test robot reports it as a regression.)
With this commit, Kconfig will generate all configuration files together
with the .config and I guess it is a solution good enough to suppress
the warning.
Note:
GNU Make 4.2 or later does not display the warning from the 'include'
directive if include files are successfully generated. See GNU Make
commit 87a5f98d248f ("[SV 102] Don't show unnecessary include file
errors.") However, older GNU Make versions are still widely used.
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
2018-07-20 10:46:31 +03:00
|
|
|
if (!overwrite && is_present(autoconf_name))
|
|
|
|
return 0;
|
|
|
|
|
2021-10-01 08:32:51 +03:00
|
|
|
ret = conf_write_autoconf_cmd(autoconf_name);
|
|
|
|
if (ret)
|
|
|
|
return -1;
|
2006-06-09 09:12:39 +04:00
|
|
|
|
2018-11-30 12:15:49 +03:00
|
|
|
if (conf_touch_deps())
|
2006-06-09 09:12:42 +04:00
|
|
|
return 1;
|
|
|
|
|
2021-10-01 08:32:50 +03:00
|
|
|
for_all_symbols(i, sym)
|
2006-06-09 09:12:39 +04:00
|
|
|
sym_calc_value(sym);
|
2010-08-01 01:35:33 +04:00
|
|
|
|
2021-10-01 08:32:50 +03:00
|
|
|
ret = __conf_write_autoconf(conf_get_autoheader_name(),
|
|
|
|
print_symbol_for_c,
|
|
|
|
&comment_style_c);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2018-07-20 10:46:29 +03:00
|
|
|
|
2006-06-09 09:12:39 +04:00
|
|
|
/*
|
2021-10-01 08:32:50 +03:00
|
|
|
* Create include/config/auto.conf. This must be the last step because
|
|
|
|
* Kbuild has a dependency on auto.conf and this marks the successful
|
|
|
|
* completion of the previous steps.
|
2006-06-09 09:12:39 +04:00
|
|
|
*/
|
2021-10-01 08:32:50 +03:00
|
|
|
ret = __conf_write_autoconf(conf_get_autoconfig_name(),
|
|
|
|
print_symbol_for_autoconf,
|
|
|
|
&comment_style_pound);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2006-06-09 09:12:39 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-13 11:34:06 +03:00
|
|
|
|
2021-04-10 09:57:22 +03:00
|
|
|
static bool conf_changed;
|
2006-12-13 11:34:08 +03:00
|
|
|
static void (*conf_changed_callback)(void);
|
2006-12-13 11:34:07 +03:00
|
|
|
|
2021-04-10 09:57:22 +03:00
|
|
|
void conf_set_changed(bool val)
|
2006-12-13 11:34:07 +03:00
|
|
|
{
|
2021-04-10 09:57:22 +03:00
|
|
|
if (conf_changed_callback && conf_changed != val)
|
2006-12-13 11:34:08 +03:00
|
|
|
conf_changed_callback();
|
2006-12-13 11:34:07 +03:00
|
|
|
|
2021-04-10 09:57:22 +03:00
|
|
|
conf_changed = val;
|
2006-12-13 11:34:07 +03:00
|
|
|
}
|
|
|
|
|
2006-12-13 11:34:06 +03:00
|
|
|
bool conf_get_changed(void)
|
|
|
|
{
|
2021-04-10 09:57:22 +03:00
|
|
|
return conf_changed;
|
2006-12-13 11:34:06 +03:00
|
|
|
}
|
2006-12-13 11:34:08 +03:00
|
|
|
|
|
|
|
void conf_set_changed_callback(void (*fn)(void))
|
|
|
|
{
|
|
|
|
conf_changed_callback = fn;
|
|
|
|
}
|
2008-05-06 06:55:55 +04:00
|
|
|
|
2013-06-07 07:37:00 +04:00
|
|
|
void set_all_choice_values(struct symbol *csym)
|
2008-05-06 06:55:55 +04:00
|
|
|
{
|
|
|
|
struct property *prop;
|
2010-08-12 11:11:52 +04:00
|
|
|
struct symbol *sym;
|
2008-05-06 06:55:55 +04:00
|
|
|
struct expr *e;
|
2010-08-12 11:11:52 +04:00
|
|
|
|
|
|
|
prop = sym_get_choice_prop(csym);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set all non-assinged choice values to no
|
|
|
|
*/
|
|
|
|
expr_list_for_each_sym(prop->expr, e, sym) {
|
|
|
|
if (!sym_has_value(sym))
|
|
|
|
sym->def[S_DEF_USER].tri = no;
|
|
|
|
}
|
|
|
|
csym->flags |= SYMBOL_DEF_USER;
|
|
|
|
/* clear VALID to get value calculated */
|
2013-06-07 07:37:00 +04:00
|
|
|
csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES);
|
2010-08-12 11:11:52 +04:00
|
|
|
}
|