jonathan/libvirt
1
0
Fork 0
forked from rpms/libvirt
Code Pull Requests Activity
67ba56b051
libvirt/SOURCES/libvirt-util-Introduce-a-parser-for-kernel-cmdline-arguments.patch
CentOS Sources 67ba56b051 import libvirt-6.0.0-25.module+el8.3.0+7176+57f10f42
2021-10-08 13:11:20 +00:00

447 lines
19 KiB
Diff
Raw Blame History

From 8b59b9dab54c094dfc9bafd9d9f2c18f25877f36 Mon Sep 17 00:00:00 2001
Message-Id: <8b59b9dab54c094dfc9bafd9d9f2c18f25877f36@dist-git>
From: Paulo de Rezende Pinatti <ppinatti@linux.ibm.com>
Date: Wed, 24 Jun 2020 13:16:17 +0200
Subject: [PATCH] util: Introduce a parser for kernel cmdline arguments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Introduce two utility functions to parse a kernel command
line string according to the kernel code parsing rules in
order to enable the caller to perform operations such as
verifying whether certain argument=value combinations are
present or retrieving an argument's value.
Signed-off-by: Paulo de Rezende Pinatti <ppinatti@linux.ibm.com>
Signed-off-by: Boris Fiuczynski <fiuczy@linux.ibm.com>
Reviewed-by: Erik Skultety <eskultet@redhat.com>
(cherry picked from commit c5fffb959d93b83d87e70b21d19424e9722700b0)
https://bugzilla.redhat.com/show_bug.cgi?id=1848997
https://bugzilla.redhat.com/show_bug.cgi?id=1850351
Conflicts:
src/util/virutil.c
- unrelated commits db72866310d and ab36f729470 were not
backported
Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
Message-Id: <784fbc062d41f991b6321ac051b05e6c80a470cd.1592996194.git.jdenemar@redhat.com>
Reviewed-by: Ján Tomko <jtomko@redhat.com>
---
src/libvirt_private.syms | 2 +
src/util/virutil.c | 185 +++++++++++++++++++++++++++++++++++++++
src/util/virutil.h | 34 +++++++
tests/utiltest.c | 136 ++++++++++++++++++++++++++++
4 files changed, 357 insertions(+)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index a3fe49ae33..9e290c7bdf 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -3395,6 +3395,8 @@ virHexToBin;
virHostGetDRMRenderNode;
virHostHasIOMMU;
virIndexToDiskName;
+virKernelCmdlineMatchParam;
+virKernelCmdlineNextParam;
virMemoryLimitIsSet;
virMemoryLimitTruncate;
virMemoryMaxValue;
diff --git a/src/util/virutil.c b/src/util/virutil.c
index 261b2d2af6..17fd06dbb2 100644
--- a/src/util/virutil.c
+++ b/src/util/virutil.c
@@ -1673,3 +1673,188 @@ virHostGetDRMRenderNode(void)
VIR_DIR_CLOSE(driDir);
return ret;
}
+
+
+static const char *virKernelCmdlineSkipQuote(const char *cmdline,
+ bool *is_quoted)
+{
+ if (cmdline[0] == '"') {
+ *is_quoted = !(*is_quoted);
+ cmdline++;
+ }
+ return cmdline;
+}
+
+
+/**
+ * virKernelCmdlineFindEqual:
+ * @cmdline: target kernel command line string
+ * @is_quoted: indicates whether the string begins with quotes
+ * @res: pointer to the position immediately after the parsed parameter,
+ * can be used in subsequent calls to process further parameters until
+ * the end of the string.
+ *
+ * Iterate over the provided kernel command line string while honoring
+ * the kernel quoting rules and returns the index of the equal sign
+ * separating argument and value.
+ *
+ * Returns 0 for the cases where no equal sign is found or the argument
+ * itself begins with the equal sign (both cases indicating that the
+ * argument has no value). Otherwise, returns the index of the equal
+ * sign in the string.
+ */
+static size_t virKernelCmdlineFindEqual(const char *cmdline,
+ bool is_quoted,
+ const char **res)
+{
+ size_t i;
+ size_t equal_index = 0;
+
+ for (i = 0; cmdline[i]; i++) {
+ if (!(is_quoted) && g_ascii_isspace(cmdline[i]))
+ break;
+ if (equal_index == 0 && cmdline[i] == '=') {
+ equal_index = i;
+ continue;
+ }
+ virKernelCmdlineSkipQuote(cmdline + i, &is_quoted);
+ }
+ *res = cmdline + i;
+ return equal_index;
+}
+
+
+static char* virKernelArgNormalize(const char *arg)
+{
+ return virStringReplace(arg, "_", "-");
+}
+
+
+/**
+ * virKernelCmdlineNextParam:
+ * @cmdline: kernel command line string to be checked for next parameter
+ * @param: pointer to hold retrieved parameter, will be NULL if none found
+ * @val: pointer to hold retrieved value of @param
+ *
+ * Parse the kernel cmdline and store the next parameter in @param
+ * and the value of @param in @val which can be NULL if @param has
+ * no value. In addition returns the address right after @param=@value
+ * for possible further processing.
+ *
+ * Returns a pointer to address right after @param=@val in the
+ * kernel command line, will point to the string's end (NULL)
+ * in case no next parameter is found
+ */
+const char *virKernelCmdlineNextParam(const char *cmdline,
+ char **param,
+ char **val)
+{
+ const char *next;
+ int equal_index;
+ bool is_quoted = false;
+ *param = NULL;
+ *val = NULL;
+
+ virSkipSpaces(&cmdline);
+ cmdline = virKernelCmdlineSkipQuote(cmdline, &is_quoted);
+ equal_index = virKernelCmdlineFindEqual(cmdline, is_quoted, &next);
+
+ if (next == cmdline)
+ return next;
+
+ /* param has no value */
+ if (equal_index == 0) {
+ if (is_quoted && next[-1] == '"')
+ *param = g_strndup(cmdline, next - cmdline - 1);
+ else
+ *param = g_strndup(cmdline, next - cmdline);
+ return next;
+ }
+
+ *param = g_strndup(cmdline, equal_index);
+
+ if (cmdline[equal_index + 1] == '"') {
+ is_quoted = true;
+ equal_index++;
+ }
+
+ if (is_quoted && next[-1] == '"')
+ *val = g_strndup(cmdline + equal_index + 1,
+ next - cmdline - equal_index - 2);
+ else
+ *val = g_strndup(cmdline + equal_index + 1,
+ next - cmdline - equal_index - 1);
+ return next;
+}
+
+
+static bool virKernelCmdlineStrCmp(const char *kernel_val,
+ const char *caller_val,
+ virKernelCmdlineFlags flags)
+{
+ if (flags & VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX)
+ return STRPREFIX(kernel_val, caller_val);
+ return STREQ(kernel_val, caller_val);
+}
+
+
+/**
+ * virKernelCmdlineMatchParam:
+ * @cmdline: kernel command line string to be checked for @arg
+ * @arg: kernel command line argument
+ * @values: array of possible values to match @arg
+ * @len_values: size of array, it can be 0 meaning a match will be positive if
+ * the argument has no value.
+ * @flags: bitwise-OR of virKernelCmdlineFlags
+ *
+ * Try to match the provided kernel cmdline string with the provided @arg
+ * and the list @values of possible values according to the matching strategy
+ * defined in @flags.
+ *
+ *
+ * Returns true if a match is found, false otherwise
+ */
+bool virKernelCmdlineMatchParam(const char *cmdline,
+ const char *arg,
+ const char **values,
+ size_t len_values,
+ virKernelCmdlineFlags flags)
+{
+ bool match = false;
+ size_t i;
+ const char *next = cmdline;
+ g_autofree char *arg_norm = virKernelArgNormalize(arg);
+
+ while (next[0] != '\0') {
+ g_autofree char *kparam = NULL;
+ g_autofree char *kparam_norm = NULL;
+ g_autofree char *kval = NULL;
+
+ next = virKernelCmdlineNextParam(next, &kparam, &kval);
+
+ if (!kparam)
+ break;
+
+ kparam_norm = virKernelArgNormalize(kparam);
+
+ if (STRNEQ(kparam_norm, arg_norm))
+ continue;
+
+ if (!kval) {
+ match = (len_values == 0) ? true : false;
+ } else {
+ match = false;
+ for (i = 0; i < len_values; i++) {
+ if (virKernelCmdlineStrCmp(kval, values[i], flags)) {
+ match = true;
+ break;
+ }
+ }
+ }
+
+ if (match && (flags & VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST))
+ break;
+ }
+
+ return match;
+}
diff --git a/src/util/virutil.h b/src/util/virutil.h
index 0dcaff79ac..f1d2ccdd1f 100644
--- a/src/util/virutil.h
+++ b/src/util/virutil.h
@@ -145,6 +145,40 @@ bool virHostHasIOMMU(void);
char *virHostGetDRMRenderNode(void) G_GNUC_NO_INLINE;
+/* Kernel cmdline match and comparison strategy for arg=value pairs */
+typedef enum {
+ /* substring comparison of argument values */
+ VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX = 1,
+
+ /* strict string comparison of argument values */
+ VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ = 2,
+
+ /* look for any occurrence of the argument with the expected value,
+ * this should be used when an argument set to the expected value overrides
+ * all the other occurrences of the argument, e.g. when looking for 'arg=1'
+ * in 'arg=0 arg=1 arg=0' the search would succeed with this flag
+ */
+ VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST = 4,
+
+ /* look for the last occurrence of argument with the expected value,
+ * this should be used when the last occurrence of the argument overrides
+ * all the other ones, e.g. when looking for 'arg=1' in 'arg=0 arg=1' the
+ * search would succeed with this flag, but in 'arg=1 arg=0' it would not,
+ * because 'arg=0' overrides all the previous occurrences of 'arg'
+ */
+ VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST = 8,
+} virKernelCmdlineFlags;
+
+const char *virKernelCmdlineNextParam(const char *cmdline,
+ char **param,
+ char **val);
+
+bool virKernelCmdlineMatchParam(const char *cmdline,
+ const char *arg,
+ const char **values,
+ size_t len_values,
+ virKernelCmdlineFlags flags);
+
/**
* VIR_ASSIGN_IS_OVERFLOW:
* @rvalue: value that is checked (evaluated twice)
diff --git a/tests/utiltest.c b/tests/utiltest.c
index 5ae04585cb..2bff7859dc 100644
--- a/tests/utiltest.c
+++ b/tests/utiltest.c
@@ -254,6 +254,140 @@ testOverflowCheckMacro(const void *data G_GNUC_UNUSED)
}
+struct testKernelCmdlineNextParamData
+{
+ const char *cmdline;
+ const char *param;
+ const char *val;
+ const char *next;
+};
+
+static struct testKernelCmdlineNextParamData kEntries[] = {
+ { "arg1 arg2 arg3=val1", "arg1", NULL, " arg2 arg3=val1" },
+ { "arg1=val1 arg2 arg3=val3 arg4", "arg1", "val1", " arg2 arg3=val3 arg4" },
+ { "arg1=sub1=val1,sub2=val2 arg3=val3 arg4", "arg1", "sub1=val1,sub2=val2", " arg3=val3 arg4" },
+ { "arg3=val3 ", "arg3", "val3", " " },
+ { "arg3=val3", "arg3", "val3", "" },
+ { "arg-3=val3 arg4", "arg-3", "val3", " arg4" },
+ { " arg_3=val3 arg4", "arg_3", "val3", " arg4" },
+ { "arg2=\"value with space\" arg3=val3", "arg2", "value with space", " arg3=val3" },
+ { " arg2=\"value with space\" arg3=val3", "arg2", "value with space", " arg3=val3" },
+ { " \"arg2=value with space\" arg3=val3", "arg2", "value with space", " arg3=val3" },
+ { "arg2=\"val\"ue arg3", "arg2", "val\"ue", " arg3" },
+ { "arg2=value\" long\" arg3", "arg2", "value\" long\"", " arg3" },
+ { " \"arg2 with space=value with space\" arg3", "arg2 with space", "value with space", " arg3" },
+ { " arg2\" with space=val2\" arg3", "arg2\" with space", "val2\"", " arg3" },
+ { " arg2longer=someval\" long\" arg2=val2", "arg2longer", "someval\" long\"", " arg2=val2" },
+ { "=val1 arg2=val2", "=val1", NULL, " arg2=val2" },
+ { " ", NULL, NULL, "" },
+ { "", NULL, NULL, "" },
+};
+
+static int
+testKernelCmdlineNextParam(const void *data G_GNUC_UNUSED)
+{
+ const char *next;
+ size_t i;
+
+ for (i = 0; i < G_N_ELEMENTS(kEntries); ++i) {
+ g_autofree char * param = NULL;
+ g_autofree char * val = NULL;
+
+ next = virKernelCmdlineNextParam(kEntries[i].cmdline, &param, &val);
+
+ if (STRNEQ_NULLABLE(param, kEntries[i].param) ||
+ STRNEQ_NULLABLE(val, kEntries[i].val) ||
+ STRNEQ(next, kEntries[i].next)) {
+ VIR_TEST_DEBUG("\nKernel cmdline [%s]", kEntries[i].cmdline);
+ VIR_TEST_DEBUG("Expect param [%s]", kEntries[i].param);
+ VIR_TEST_DEBUG("Actual param [%s]", param);
+ VIR_TEST_DEBUG("Expect value [%s]", kEntries[i].val);
+ VIR_TEST_DEBUG("Actual value [%s]", val);
+ VIR_TEST_DEBUG("Expect next [%s]", kEntries[i].next);
+ VIR_TEST_DEBUG("Actual next [%s]", next);
+
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+
+struct testKernelCmdlineMatchData
+{
+ const char *cmdline;
+ const char *arg;
+ const char *values[2];
+ virKernelCmdlineFlags flags;
+ bool result;
+};
+
+static struct testKernelCmdlineMatchData kMatchEntries[] = {
+ {"arg1 myarg=no arg2=val2 myarg=yes arg4=val4 myarg=no arg5", "myarg", {"1", "y"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST | VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ, false },
+ {"arg1 myarg=no arg2=val2 myarg=yes arg4=val4 myarg=no arg5", "myarg", {"on", "yes"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST | VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ, true },
+ {"arg1 myarg=no arg2=val2 myarg=yes arg4=val4 myarg=no arg5", "myarg", {"1", "y"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST | VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX, true },
+ {"arg1 myarg=no arg2=val2 myarg=yes arg4=val4 myarg=no arg5", "myarg", {"a", "b"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST | VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX, false },
+ {"arg1 myarg=no arg2=val2 myarg=yes arg4=val4 myarg=no arg5", "myarg", {"on", "yes"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST | VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ, false },
+ {"arg1 myarg=no arg2=val2 myarg=yes arg4=val4 myarg=no arg5", "myarg", {"1", "y"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST | VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX, false },
+ {"arg1 myarg=no arg2=val2 arg4=val4 myarg=yes arg5", "myarg", {"on", "yes"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST | VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ, true },
+ {"arg1 myarg=no arg2=val2 arg4=val4 myarg=yes arg5", "myarg", {"1", "y"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST | VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX, true },
+ {"arg1 myarg=no arg2=val2 arg4=val4 myarg arg5", "myarg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, true },
+ {"arg1 myarg arg2=val2 arg4=val4 myarg=yes arg5", "myarg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST, true },
+ {"arg1 myarg arg2=val2 arg4=val4 myarg=yes arg5", "myarg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, false },
+ {"arg1 my-arg=no arg2=val2 arg4=val4 my_arg=yes arg5", "my-arg", {"on", "yes"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, true },
+ {"arg1 my-arg=no arg2=val2 arg4=val4 my_arg=yes arg5 ", "my-arg", {"on", "yes"}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST | VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ, true },
+ {"arg1 my-arg arg2=val2 arg4=val4 my_arg=yes arg5", "my_arg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST, true },
+ {"arg1 my-arg arg2=val2 arg4=val4 my-arg=yes arg5", "my_arg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST, true },
+ {"=arg1 my-arg arg2=val2 arg4=val4 my-arg=yes arg5", "my_arg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST, true },
+ {"my-arg =arg1 arg2=val2 arg4=val4 my-arg=yes arg5", "=arg1", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, true },
+ {"arg1 arg2=val2 myarg=sub1=val1 arg5", "myarg", {"sub1=val1", NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, true },
+ {"arg1 arg2=", "arg2", {"", ""}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST | VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ, true },
+ {" ", "myarg", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, false },
+ {"", "", {NULL, NULL}, VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST, false },
+};
+
+
+static int
+testKernelCmdlineMatchParam(const void *data G_GNUC_UNUSED)
+{
+ bool result;
+ size_t i, lenValues;
+
+ for (i = 0; i < G_N_ELEMENTS(kMatchEntries); ++i) {
+ if (kMatchEntries[i].values[0] == NULL)
+ lenValues = 0;
+ else
+ lenValues = G_N_ELEMENTS(kMatchEntries[i].values);
+
+ result = virKernelCmdlineMatchParam(kMatchEntries[i].cmdline,
+ kMatchEntries[i].arg,
+ kMatchEntries[i].values,
+ lenValues,
+ kMatchEntries[i].flags);
+
+ if (result != kMatchEntries[i].result) {
+ VIR_TEST_DEBUG("\nKernel cmdline [%s]", kMatchEntries[i].cmdline);
+ VIR_TEST_DEBUG("Kernel argument [%s]", kMatchEntries[i].arg);
+ VIR_TEST_DEBUG("Kernel values [%s] [%s]", kMatchEntries[i].values[0],
+ kMatchEntries[i].values[1]);
+ if (kMatchEntries[i].flags & VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX)
+ VIR_TEST_DEBUG("Flag [VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX]");
+ if (kMatchEntries[i].flags & VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ)
+ VIR_TEST_DEBUG("Flag [VIR_KERNEL_CMDLINE_FLAGS_CMP_EQ]");
+ if (kMatchEntries[i].flags & VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST)
+ VIR_TEST_DEBUG("Flag [VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST]");
+ if (kMatchEntries[i].flags & VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST)
+ VIR_TEST_DEBUG("Flag [VIR_KERNEL_CMDLINE_FLAGS_SEARCH_LAST]");
+ VIR_TEST_DEBUG("Expect result [%d]", kMatchEntries[i].result);
+ VIR_TEST_DEBUG("Actual result [%d]", result);
+
+ return -1;
+ }
+ }
+
+ return 0;
+}
static int
@@ -277,6 +411,8 @@ mymain(void)
DO_TEST(ParseVersionString);
DO_TEST(RoundValueToPowerOfTwo);
DO_TEST(OverflowCheckMacro);
+ DO_TEST(KernelCmdlineNextParam);
+ DO_TEST(KernelCmdlineMatchParam);
return result == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
--
2.27.0
View Git Blame Copy Permalink