Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 806 insertions, 0 deletions

diff --git a/src/spdk/lib/log/Makefile b/src/spdk/lib/log/Makefile
new file mode 100644
index 00000000..8125ebb1
--- /dev/null
+++ b/src/spdk/lib/log/Makefile
@@ -0,0 +1,45 @@
+#
+#  BSD LICENSE
+#
+#  Copyright (c) Intel Corporation.
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in
+#      the documentation and/or other materials provided with the
+#      distribution.
+#    * Neither the name of Intel Corporation nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
+include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
+
+C_SRCS = log.c log_flags.c
+LIBNAME = log
+ifeq ($(CONFIG_LOG_BACKTRACE),y)
+LOCAL_SYS_LIBS += -lunwind
+endif
+
+DIRS-y = rpc
+
+include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/src/spdk/lib/log/log.c b/src/spdk/lib/log/log.c
new file mode 100644
index 00000000..9f4546ce
--- /dev/null
+++ b/src/spdk/lib/log/log.c
@@ -0,0 +1,189 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright (c) Intel Corporation.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "spdk/stdinc.h"
+
+#include "spdk_internal/log.h"
+
+#ifdef SPDK_LOG_BACKTRACE_LVL
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+#endif
+
+static const char *const spdk_level_names[] = {
+	[SPDK_LOG_ERROR]	= "ERROR",
+	[SPDK_LOG_WARN]		= "WARNING",
+	[SPDK_LOG_NOTICE]	= "NOTICE",
+	[SPDK_LOG_INFO]		= "INFO",
+	[SPDK_LOG_DEBUG]	= "DEBUG",
+};
+
+#define MAX_TMPBUF 1024
+
+void
+spdk_log_open(void)
+{
+	openlog("spdk", LOG_PID, LOG_LOCAL7);
+}
+
+void
+spdk_log_close(void)
+{
+	closelog();
+}
+
+#ifdef SPDK_LOG_BACKTRACE_LVL
+static void
+spdk_log_unwind_stack(FILE *fp, enum spdk_log_level level)
+{
+	unw_error_t err;
+	unw_cursor_t cursor;
+	unw_context_t uc;
+	unw_word_t ip;
+	unw_word_t offp;
+	char f_name[64];
+	int frame;
+
+	if (level > g_spdk_log_backtrace_level) {
+		return;
+	}
+
+	unw_getcontext(&uc);
+	unw_init_local(&cursor, &uc);
+	fprintf(fp, "*%s*: === BACKTRACE START ===\n", spdk_level_names[level]);
+
+	unw_step(&cursor);
+	for (frame = 1; unw_step(&cursor) > 0; frame++) {
+		unw_get_reg(&cursor, UNW_REG_IP, &ip);
+		err = unw_get_proc_name(&cursor, f_name, sizeof(f_name), &offp);
+		if (err || strcmp(f_name, "main") == 0) {
+			break;
+		}
+
+		fprintf(fp, "*%s*: %3d: %*s%s() at %#lx\n", spdk_level_names[level], frame, frame - 1, "", f_name,
+			(unsigned long)ip);
+	}
+	fprintf(fp, "*%s*: === BACKTRACE END ===\n", spdk_level_names[level]);
+}
+
+#else
+#define spdk_log_unwind_stack(fp, lvl)
+#endif
+
+void
+spdk_log(enum spdk_log_level level, const char *file, const int line, const char *func,
+	 const char *format, ...)
+{
+	int severity = LOG_INFO;
+	char buf[MAX_TMPBUF];
+	va_list ap;
+
+	switch (level) {
+	case SPDK_LOG_ERROR:
+		severity = LOG_ERR;
+		break;
+	case SPDK_LOG_WARN:
+		severity = LOG_WARNING;
+		break;
+	case SPDK_LOG_NOTICE:
+		severity = LOG_NOTICE;
+		break;
+	case SPDK_LOG_INFO:
+	case SPDK_LOG_DEBUG:
+		severity = LOG_INFO;
+		break;
+	case SPDK_LOG_DISABLED:
+		return;
+	}
+
+	va_start(ap, format);
+
+	vsnprintf(buf, sizeof(buf), format, ap);
+
+	if (level <= g_spdk_log_print_level) {
+		fprintf(stderr, "%s:%4d:%s: *%s*: %s", file, line, func, spdk_level_names[level], buf);
+		spdk_log_unwind_stack(stderr, level);
+	}
+
+	if (level <= g_spdk_log_level) {
+		syslog(severity, "%s:%4d:%s: *%s*: %s", file, line, func, spdk_level_names[level], buf);
+	}
+
+	va_end(ap);
+}
+
+static void
+fdump(FILE *fp, const char *label, const uint8_t *buf, size_t len)
+{
+	char tmpbuf[MAX_TMPBUF];
+	char buf16[16 + 1];
+	size_t total;
+	unsigned int idx;
+
+	fprintf(fp, "%s\n", label);
+
+	memset(buf16, 0, sizeof buf16);
+	total = 0;
+	for (idx = 0; idx < len; idx++) {
+		if (idx != 0 && idx % 16 == 0) {
+			snprintf(tmpbuf + total, sizeof tmpbuf - total,
+				 " %s", buf16);
+			fprintf(fp, "%s\n", tmpbuf);
+			total = 0;
+		}
+		if (idx % 16 == 0) {
+			total += snprintf(tmpbuf + total, sizeof tmpbuf - total,
+					  "%08x ", idx);
+		}
+		if (idx % 8 == 0) {
+			total += snprintf(tmpbuf + total, sizeof tmpbuf - total,
+					  "%s", " ");
+		}
+		total += snprintf(tmpbuf + total, sizeof tmpbuf - total,
+				  "%2.2x ", buf[idx] & 0xff);
+		buf16[idx % 16] = isprint(buf[idx]) ? buf[idx] : '.';
+	}
+	for (; idx % 16 != 0; idx++) {
+		total += snprintf(tmpbuf + total, sizeof tmpbuf - total, "   ");
+		buf16[idx % 16] = ' ';
+	}
+	snprintf(tmpbuf + total, sizeof tmpbuf - total, "  %s", buf16);
+	fprintf(fp, "%s\n", tmpbuf);
+	fflush(fp);
+}
+
+void
+spdk_trace_dump(FILE *fp, const char *label, const void *buf, size_t len)
+{
+	fdump(fp, label, buf, len);
+}
diff --git a/src/spdk/lib/log/log_flags.c b/src/spdk/lib/log/log_flags.c
new file mode 100644
index 00000000..1b766c44
--- /dev/null
+++ b/src/spdk/lib/log/log_flags.c
@@ -0,0 +1,196 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright (c) Intel Corporation.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "spdk/stdinc.h"
+
+#include "spdk_internal/log.h"
+
+static TAILQ_HEAD(, spdk_trace_flag) g_trace_flags = TAILQ_HEAD_INITIALIZER(g_trace_flags);
+
+enum spdk_log_level g_spdk_log_level = SPDK_LOG_NOTICE;
+enum spdk_log_level g_spdk_log_print_level = SPDK_LOG_NOTICE;
+enum spdk_log_level g_spdk_log_backtrace_level = SPDK_LOG_DISABLED;
+
+SPDK_LOG_REGISTER_COMPONENT("log", SPDK_LOG_LOG)
+
+#define MAX_TMPBUF 1024
+
+void
+spdk_log_set_level(enum spdk_log_level level)
+{
+	g_spdk_log_level = level;
+}
+
+enum spdk_log_level
+spdk_log_get_level(void) {
+	return g_spdk_log_level;
+}
+
+void
+spdk_log_set_print_level(enum spdk_log_level level)
+{
+	g_spdk_log_print_level = level;
+}
+
+enum spdk_log_level
+spdk_log_get_print_level(void) {
+	return g_spdk_log_print_level;
+}
+
+void
+spdk_log_set_backtrace_level(enum spdk_log_level level)
+{
+	g_spdk_log_backtrace_level = level;
+}
+
+enum spdk_log_level
+spdk_log_get_backtrace_level(void) {
+	return g_spdk_log_backtrace_level;
+}
+
+static struct spdk_trace_flag *
+get_trace_flag(const char *name)
+{
+	struct spdk_trace_flag *flag;
+
+	TAILQ_FOREACH(flag, &g_trace_flags, tailq) {
+		if (strcasecmp(name, flag->name) == 0) {
+			return flag;
+		}
+	}
+
+	return NULL;
+}
+
+void
+spdk_log_register_trace_flag(const char *name, struct spdk_trace_flag *flag)
+{
+	struct spdk_trace_flag *iter;
+
+	if (name == NULL || flag == NULL) {
+		SPDK_ERRLOG("missing spdk_trace_flag parameters\n");
+		assert(false);
+		return;
+	}
+
+	if (get_trace_flag(name)) {
+		SPDK_ERRLOG("duplicate spdk_trace_flag '%s'\n", name);
+		assert(false);
+		return;
+	}
+
+	TAILQ_FOREACH(iter, &g_trace_flags, tailq) {
+		if (strcasecmp(iter->name, flag->name) > 0) {
+			TAILQ_INSERT_BEFORE(iter, flag, tailq);
+			return;
+		}
+	}
+
+	TAILQ_INSERT_TAIL(&g_trace_flags, flag, tailq);
+}
+
+bool
+spdk_log_get_trace_flag(const char *name)
+{
+	struct spdk_trace_flag *flag = get_trace_flag(name);
+
+	if (flag && flag->enabled) {
+		return true;
+	}
+
+	return false;
+}
+
+static int
+set_trace_flag(const char *name, bool value)
+{
+	struct spdk_trace_flag *flag;
+
+	if (strcasecmp(name, "all") == 0) {
+		TAILQ_FOREACH(flag, &g_trace_flags, tailq) {
+			flag->enabled = value;
+		}
+		return 0;
+	}
+
+	flag = get_trace_flag(name);
+	if (flag == NULL) {
+		return -1;
+	}
+
+	flag->enabled = value;
+
+	return 0;
+}
+
+int
+spdk_log_set_trace_flag(const char *name)
+{
+	return set_trace_flag(name, true);
+}
+
+int
+spdk_log_clear_trace_flag(const char *name)
+{
+	return set_trace_flag(name, false);
+}
+
+struct spdk_trace_flag *
+spdk_log_get_first_trace_flag(void)
+{
+	return TAILQ_FIRST(&g_trace_flags);
+}
+
+struct spdk_trace_flag *
+spdk_log_get_next_trace_flag(struct spdk_trace_flag *flag)
+{
+	return TAILQ_NEXT(flag, tailq);
+}
+
+void
+spdk_tracelog_usage(FILE *f, const char *trace_arg)
+{
+#ifdef DEBUG
+	struct spdk_trace_flag *flag;
+	fprintf(f, " %s, --traceflag <flag>    enable debug log flag (all", trace_arg);
+
+	TAILQ_FOREACH(flag, &g_trace_flags, tailq) {
+		fprintf(f, ", %s", flag->name);
+	}
+
+	fprintf(f, ")\n");
+#else
+	fprintf(f, " %s, --traceflag <flag>    enable debug log flag (not supported"
+		" - must rebuild with --enable-debug)\n", trace_arg);
+#endif
+}
diff --git a/src/spdk/lib/log/rpc/Makefile b/src/spdk/lib/log/rpc/Makefile
new file mode 100644
index 00000000..bf53a64c
--- /dev/null
+++ b/src/spdk/lib/log/rpc/Makefile
@@ -0,0 +1,40 @@
+#
+#  BSD LICENSE
+#
+#  Copyright (c) Intel Corporation.
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in
+#      the documentation and/or other materials provided with the
+#      distribution.
+#    * Neither the name of Intel Corporation nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
+include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
+
+C_SRCS = log_rpc.c
+LIBNAME = log_rpc
+
+include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk
diff --git a/src/spdk/lib/log/rpc/log_rpc.c b/src/spdk/lib/log/rpc/log_rpc.c
new file mode 100644
index 00000000..fea7607a
--- /dev/null
+++ b/src/spdk/lib/log/rpc/log_rpc.c
@@ -0,0 +1,336 @@
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright (c) Intel Corporation.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "spdk/rpc.h"
+#include "spdk/util.h"
+
+#include "spdk_internal/log.h"
+
+struct rpc_trace_flag {
+	char *flag;
+};
+
+struct rpc_log_level {
+	char *level;
+};
+
+static void
+free_rpc_trace_flag(struct rpc_trace_flag *p)
+{
+	free(p->flag);
+}
+
+static void
+free_rpc_log_level(struct rpc_log_level *p)
+{
+	free(p->level);
+}
+
+static const struct spdk_json_object_decoder rpc_trace_flag_decoders[] = {
+	{"flag", offsetof(struct rpc_trace_flag, flag), spdk_json_decode_string},
+};
+
+static const struct spdk_json_object_decoder rpc_log_level_decoders[] = {
+	{"level", offsetof(struct rpc_log_level, level), spdk_json_decode_string},
+};
+
+static int
+_parse_log_level(char *level)
+{
+	if (!strcasecmp(level, "ERROR")) {
+		return SPDK_LOG_ERROR;
+	} else if (!strcasecmp(level, "WARNING")) {
+		return SPDK_LOG_WARN;
+	} else if (!strcasecmp(level, "NOTICE")) {
+		return SPDK_LOG_NOTICE;
+	} else if (!strcasecmp(level, "INFO")) {
+		return SPDK_LOG_INFO;
+	} else if (!strcasecmp(level, "DEBUG")) {
+		return SPDK_LOG_DEBUG;
+	}
+	return -1;
+}
+
+static const char *
+_get_log_level_name(int level)
+{
+	if (level == SPDK_LOG_ERROR) {
+		return "ERROR";
+	} else if (level == SPDK_LOG_WARN) {
+		return "WARNING";
+	} else if (level == SPDK_LOG_NOTICE) {
+		return "NOTICE";
+	} else if (level == SPDK_LOG_INFO) {
+		return "INFO";
+	} else if (level == SPDK_LOG_DEBUG) {
+		return "DEBUG";
+	}
+	return NULL;
+}
+
+static void
+spdk_rpc_set_log_print_level(struct spdk_jsonrpc_request *request,
+			     const struct spdk_json_val *params)
+{
+	struct rpc_log_level req = {};
+	int level;
+	struct spdk_json_write_ctx *w;
+
+	if (spdk_json_decode_object(params, rpc_log_level_decoders,
+				    SPDK_COUNTOF(rpc_log_level_decoders), &req)) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
+		goto invalid;
+	}
+
+	level = _parse_log_level(req.level);
+	if (level == -1) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "try to set invalid log level\n");
+		goto invalid;
+	}
+
+	spdk_log_set_print_level(level);
+	free_rpc_log_level(&req);
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	spdk_json_write_bool(w, true);
+	spdk_jsonrpc_end_result(request, w);
+	return;
+
+invalid:
+	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
+	free_rpc_log_level(&req);
+}
+SPDK_RPC_REGISTER("set_log_print_level", spdk_rpc_set_log_print_level,
+		  SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
+
+static void
+spdk_rpc_get_log_print_level(struct spdk_jsonrpc_request *request,
+			     const struct spdk_json_val *params)
+{
+	struct spdk_json_write_ctx *w;
+	int level;
+	const char *name;
+
+	if (params != NULL) {
+		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
+						 "get_trace_flags requires no parameters");
+		return;
+	}
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	level = spdk_log_get_print_level();
+	name = _get_log_level_name(level);
+	spdk_json_write_string(w, name);
+
+
+	spdk_jsonrpc_end_result(request, w);
+}
+SPDK_RPC_REGISTER("get_log_print_level", spdk_rpc_get_log_print_level,
+		  SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
+
+static void
+spdk_rpc_set_log_level(struct spdk_jsonrpc_request *request,
+		       const struct spdk_json_val *params)
+{
+	struct rpc_log_level req = {};
+	int level;
+	struct spdk_json_write_ctx *w;
+
+	if (spdk_json_decode_object(params, rpc_log_level_decoders,
+				    SPDK_COUNTOF(rpc_log_level_decoders), &req)) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
+		goto invalid;
+	}
+
+	level = _parse_log_level(req.level);
+	if (level == -1) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "try to set invalid log level\n");
+		goto invalid;
+	}
+
+
+	spdk_log_set_level(level);
+	free_rpc_log_level(&req);
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	spdk_json_write_bool(w, true);
+	spdk_jsonrpc_end_result(request, w);
+	return;
+
+invalid:
+	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
+	free_rpc_log_level(&req);
+}
+SPDK_RPC_REGISTER("set_log_level", spdk_rpc_set_log_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
+
+static void
+spdk_rpc_get_log_level(struct spdk_jsonrpc_request *request,
+		       const struct spdk_json_val *params)
+{
+	struct spdk_json_write_ctx *w;
+	int level;
+	const char *name;
+
+	if (params != NULL) {
+		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
+						 "get_trace_flags requires no parameters");
+		return;
+	}
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	level = spdk_log_get_level();
+	name = _get_log_level_name(level);
+	spdk_json_write_string(w, name);
+
+	spdk_jsonrpc_end_result(request, w);
+}
+SPDK_RPC_REGISTER("get_log_level", spdk_rpc_get_log_level, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
+
+static void
+spdk_rpc_set_trace_flag(struct spdk_jsonrpc_request *request,
+			const struct spdk_json_val *params)
+{
+	struct rpc_trace_flag req = {};
+	struct spdk_json_write_ctx *w;
+
+	if (spdk_json_decode_object(params, rpc_trace_flag_decoders,
+				    SPDK_COUNTOF(rpc_trace_flag_decoders), &req)) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
+		goto invalid;
+	}
+
+	if (req.flag == 0) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "flag was 0\n");
+		goto invalid;
+	}
+
+	spdk_log_set_trace_flag(req.flag);
+	free_rpc_trace_flag(&req);
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	spdk_json_write_bool(w, true);
+	spdk_jsonrpc_end_result(request, w);
+	return;
+
+invalid:
+	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
+	free_rpc_trace_flag(&req);
+}
+SPDK_RPC_REGISTER("set_trace_flag", spdk_rpc_set_trace_flag, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
+
+static void
+spdk_rpc_clear_trace_flag(struct spdk_jsonrpc_request *request,
+			  const struct spdk_json_val *params)
+{
+	struct rpc_trace_flag req = {};
+	struct spdk_json_write_ctx *w;
+
+	if (spdk_json_decode_object(params, rpc_trace_flag_decoders,
+				    SPDK_COUNTOF(rpc_trace_flag_decoders), &req)) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "spdk_json_decode_object failed\n");
+		goto invalid;
+	}
+
+	if (req.flag == 0) {
+		SPDK_DEBUGLOG(SPDK_LOG_LOG, "flag was 0\n");
+		goto invalid;
+	}
+
+	spdk_log_clear_trace_flag(req.flag);
+	free_rpc_trace_flag(&req);
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	spdk_json_write_bool(w, true);
+	spdk_jsonrpc_end_result(request, w);
+	return;
+
+invalid:
+	spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
+	free_rpc_trace_flag(&req);
+}
+SPDK_RPC_REGISTER("clear_trace_flag", spdk_rpc_clear_trace_flag,
+		  SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)
+
+static void
+spdk_rpc_get_trace_flags(struct spdk_jsonrpc_request *request,
+			 const struct spdk_json_val *params)
+{
+	struct spdk_json_write_ctx *w;
+	struct spdk_trace_flag *flag;
+
+	if (params != NULL) {
+		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS,
+						 "get_trace_flags requires no parameters");
+		return;
+	}
+
+	w = spdk_jsonrpc_begin_result(request);
+	if (w == NULL) {
+		return;
+	}
+
+	spdk_json_write_object_begin(w);
+	flag = spdk_log_get_first_trace_flag();
+	while (flag) {
+		spdk_json_write_name(w, flag->name);
+		spdk_json_write_bool(w, flag->enabled);
+		flag = spdk_log_get_next_trace_flag(flag);
+	}
+	spdk_json_write_object_end(w);
+	spdk_jsonrpc_end_result(request, w);
+}
+SPDK_RPC_REGISTER("get_trace_flags", spdk_rpc_get_trace_flags, SPDK_RPC_STARTUP | SPDK_RPC_RUNTIME)