/*
|
* SPDX-License-Identifier: MIT
|
*
|
* Copyright (C) 2020 Philippe Gerum <rpm@xenomai.org>
|
*/
|
|
#include <unistd.h>
|
#include <getopt.h>
|
#include <stdbool.h>
|
#include <ctype.h>
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <search.h>
|
#include <error.h>
|
#include <errno.h>
|
#include <sys/utsname.h>
|
|
#define DEFAULT_KCONFIG "/proc/config.gz"
|
#define DEFAULT_CHECKLIST DATADIR"/kconf-checklist"
|
|
#define short_optlist "@hqf:L:a:H:"
|
|
static int hash_size = 16384;
|
|
static bool quiet;
|
|
static const struct option options[] = {
|
{"file", required_argument, NULL, 'f'},
|
{"check-list", required_argument, NULL, 'L'},
|
{"arch", required_argument, NULL, 'a'},
|
{"hash-size", required_argument, NULL, 'H'},
|
{"quiet", no_argument, NULL, 'q'},
|
{"help", no_argument, NULL, 'h'},
|
{0}
|
};
|
|
static char *hash_config(FILE *kconfp)
|
{
|
char buf[BUFSIZ], *sym, *val, *arch = NULL;
|
ENTRY entry, *e;
|
int ret;
|
|
ret = hcreate(hash_size);
|
if (!ret)
|
error(1, errno, "hcreate(%d)", hash_size);
|
|
while (fgets(buf, sizeof(buf), kconfp)) {
|
if (*buf == '#') {
|
sscanf(buf, "# Linux/%m[^ ]", &arch);
|
continue;
|
}
|
ret = sscanf(buf, "%m[^=]=%ms\n", &sym, &val);
|
if (ret != 2)
|
continue;
|
if (strncmp(sym, "CONFIG_", 7))
|
continue;
|
if (strcmp(val, "y") && strcmp(val, "m"))
|
continue;
|
entry.key = sym;
|
entry.data = NULL;
|
e = hsearch(entry, FIND);
|
if (e)
|
continue; /* uhh? */
|
entry.data = val;
|
if (!hsearch(entry, ENTER))
|
error(1, ENOMEM, "h-table full -- try -H");
|
}
|
|
return arch;
|
}
|
|
static char *next_token(char **next)
|
{
|
char *p = *next, *s;
|
|
for (;;) {
|
if (!*p) {
|
*next = p;
|
return strdup("");
|
}
|
if (!isspace(*p))
|
break;
|
p++;
|
}
|
|
s = p;
|
|
if (!isalnum(*p) && *p != '_') {
|
*next = p + 1;
|
return strndup(s, 1);
|
}
|
|
do {
|
if (!isalnum(*p) && *p != '_') {
|
*next = p;
|
return strndup(s, p - s);
|
}
|
} while (*++p);
|
|
*next = p;
|
|
return strdup(s);
|
}
|
|
static const char *get_arch_alias(const char *arch)
|
{
|
if (!strcmp(arch, "arm64"))
|
return "aarch64";
|
|
if (!strcmp(arch, "arm"))
|
return "aarch32";
|
|
return arch;
|
}
|
|
static int apply_checklist(FILE *checkfp, const char *cpuarch)
|
{
|
char buf[BUFSIZ], *token, *next, *sym, *val;
|
int lineno = 0, failed = 0;
|
bool not, notcond;
|
const char *arch;
|
ENTRY entry, *e;
|
|
while (fgets(buf, sizeof(buf), checkfp)) {
|
lineno++;
|
next = buf;
|
|
token = next_token(&next);
|
if (!*token || !strcmp(token, "#")) {
|
free(token);
|
continue;
|
}
|
|
not = *token == '!';
|
if (not) {
|
free(token);
|
token = next_token(&next);
|
}
|
|
sym = token;
|
if (strncmp(sym, "CONFIG_", 7))
|
error(1, EINVAL,
|
"invalid check list symbol '%s' at line %d",
|
sym, lineno);
|
|
token = next_token(&next);
|
val = NULL;
|
if (*token == '=') {
|
free(token);
|
val = next_token(&next);
|
token = next_token(&next);
|
}
|
|
if (!strcmp(token, "if")) {
|
free(token);
|
token = next_token(&next);
|
notcond = *token == '!';
|
if (notcond) {
|
free(token);
|
token = next_token(&next);
|
}
|
if (strncmp(token, "CONFIG_", 7))
|
error(1, EINVAL,
|
"invalid condition symbol '%s' at line %d",
|
token, lineno);
|
entry.key = token;
|
entry.data = NULL;
|
e = hsearch(entry, FIND);
|
free(token);
|
if (!((e && !notcond) || (!e && notcond)))
|
continue;
|
token = next_token(&next);
|
}
|
|
if (!strcmp(token, "on")) {
|
free(token);
|
token = next_token(&next);
|
arch = get_arch_alias(token);
|
if (strncmp(cpuarch, arch, strlen(arch))) {
|
free(token);
|
continue;
|
}
|
}
|
|
free(token);
|
|
entry.key = sym;
|
entry.data = NULL;
|
e = hsearch(entry, FIND);
|
|
if (val && !strcmp(val, "n"))
|
not = !not;
|
|
if (e && (not || (val && strcmp(val, e->data)))) {
|
if (!quiet)
|
printf("%s=%s\n", sym, (const char *)e->data);
|
failed++;
|
} else if (!e && !not) {
|
if (!quiet)
|
printf("%s=n\n", sym);
|
failed++;
|
}
|
|
free(sym);
|
if (val)
|
free(val);
|
}
|
|
return failed;
|
}
|
|
static void usage(char *arg0)
|
{
|
fprintf(stderr, "usage: %s [options]:\n", basename(arg0));
|
fprintf(stderr, "-f --file=<.config> Kconfig file to check [=/proc/config.gz]\n");
|
fprintf(stderr, "-L --check-list=<file> configuration check list [="DATADIR"/kconf-checklist]\n");
|
fprintf(stderr, "-a --arch=<cpuarch> CPU architecture assumed\n");
|
fprintf(stderr, "-H --hash-size=<N> set the hash table size [=16384]\n");
|
fprintf(stderr, "-q --quiet suppress output\n");
|
fprintf(stderr, "-h --help this help\n");
|
}
|
|
int main(int argc, char *const argv[])
|
{
|
const char *kconfig = DEFAULT_KCONFIG, *check_list = NULL,
|
*defarch, *arch = NULL, *p;
|
FILE *kconfp, *checkfp;
|
struct utsname ubuf;
|
int c, ret;
|
char *cmd;
|
|
opterr = 0;
|
|
for (;;) {
|
c = getopt_long(argc, argv, short_optlist, options, NULL);
|
if (c == -1)
|
break;
|
|
switch (c) {
|
case 0:
|
break;
|
case 'f':
|
kconfig = optarg;
|
break;
|
case 'L':
|
check_list = optarg;
|
break;
|
case 'a':
|
arch = optarg;
|
break;
|
case 'H':
|
hash_size = atoi(optarg);
|
if (hash_size < 16384)
|
hash_size = 16384;
|
break;
|
case 'q':
|
quiet = true;
|
break;
|
case 'h':
|
usage(argv[0]);
|
return 0;
|
case '@':
|
printf("check kernel configuration\n");
|
return 0;
|
default:
|
usage(argv[0]);
|
return 1;
|
}
|
}
|
if (optind < argc) {
|
usage(argv[0]);
|
return 1;
|
}
|
|
/*
|
* We may be given a gzipped input file. Finding gunzip on a
|
* minimalist rootfs (e.g. busybox) may be more likely than
|
* having the zlib development files available from a common
|
* cross-toolchain. So go for popen-ing gunzip on the target
|
* instead of depending on libz on the development host.
|
*/
|
if (!strcmp(kconfig, "-")) {
|
kconfp = stdin;
|
} else {
|
p = strstr(kconfig, ".gz");
|
if (!p || strcmp(p, ".gz")) {
|
kconfp = fopen(kconfig, "r");
|
} else {
|
if (access(kconfig, R_OK))
|
error(1, errno, "cannot access %s%s",
|
kconfig,
|
strcmp(kconfig, DEFAULT_KCONFIG) ? "" :
|
"\n(you need CONFIG_IKCONFIG_PROC enabled)");
|
ret = asprintf(&cmd, "gunzip -c %s", kconfig);
|
if (ret < 0)
|
error(1, ENOMEM, "asprintf()");
|
kconfp = popen(cmd, "r");
|
free(cmd);
|
}
|
if (kconfp == NULL)
|
error(1, errno, "cannot open %s for reading", kconfig);
|
}
|
|
defarch = hash_config(kconfp);
|
|
if (check_list == NULL)
|
check_list = DEFAULT_CHECKLIST;
|
|
if (access(check_list, R_OK))
|
error(1, errno, "cannot access %s", check_list);
|
|
checkfp = fopen(check_list, "r");
|
if (checkfp == NULL)
|
error(1, errno, "cannot open %s for reading", check_list);
|
|
if (arch == NULL) {
|
if (defarch) {
|
arch = get_arch_alias(defarch);
|
} else {
|
ret = uname(&ubuf);
|
if (ret)
|
error(1, errno, "utsname()");
|
arch = ubuf.machine;
|
}
|
} else {
|
arch = get_arch_alias(arch);
|
}
|
|
return apply_checklist(checkfp, arch);
|
}
|
