logging: rpc: add RPC command to stop log history transfer

Add the support for pausing or cancelling the ongoing log
history transfer.

Signed-off-by: Damian Krolik <[email protected]>

Author: Damian-Nordic

include/logging/log_rpc.h

@@ -7,6 +7,7 @@
 #ifndef LOG_RPC_H_
 #define LOG_RPC_H_
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -62,12 +63,9 @@ typedef void (*log_rpc_history_threshold_reached_handler_t)(void);
  * This function issues an nRF RPC command that configures the remote device to
  * stream log messages whose level is less than or equal to the specified level.
  *
- * @param level		Logging level, see @ref log_rpc_level.
- *
- * @retval 0		On success.
- * @retval -errno	On failure.
+ * @param level	Logging level, see @ref log_rpc_level.
  */
-int log_rpc_set_stream_level(enum log_rpc_level level);
+void log_rpc_set_stream_level(enum log_rpc_level level);
 
 /**
  * @brief Sets the log history verbosity level.
@@ -79,12 +77,9 @@ int log_rpc_set_stream_level(enum log_rpc_level level);
  * This function issues an nRF RPC command that configures the remote device to
  * save log messages whose level is less than or equal to the specified level.
  *
- * @param level		Logging level, see @ref log_rpc_level.
- *
- * @retval 0		On success.
- * @retval -errno	On failure.
+ * @param level	Logging level, see @ref log_rpc_level.
  */
-int log_rpc_set_history_level(enum log_rpc_level level);
+void log_rpc_set_history_level(enum log_rpc_level level);
 
 /**
  * @brief Gets the current history usage threshold.
@@ -135,6 +130,18 @@ void log_rpc_set_history_usage_threshold(log_rpc_history_threshold_reached_handl
  */
 int log_rpc_fetch_history(log_rpc_history_handler_t handler);
 
+/**
+ * @brief Stops the log history transfer.
+ *
+ * This function issues an nRF RPC command that stops the log history transfer.
+ *
+ * @param pause		Indicates that the transfer should be put on hold rather
+ *			than cancelled, which means that the history overwriting
+ *			is kept disabled and the transfer position is retained
+ *			so that the transfer can be resumed later on.
+ */
+void log_rpc_stop_fetch_history(bool pause);
+
 /**
  * @brief Retrieves the crash log retained on the remote device.
  *

samples/nrf_rpc/protocols_serialization/client/src/log_rpc_shell.c

@@ -18,17 +18,12 @@ static int cmd_log_rpc_stream_level(const struct shell *sh, size_t argc, char *a
 
 	level = (enum log_rpc_level)shell_strtol(argv[1], 10, &rc);
 
-	if (rc) {
+	if (rc || level < LOG_RPC_LEVEL_NONE || level > LOG_RPC_LEVEL_DBG) {
 		shell_error(sh, "Invalid argument: %d", rc);
 		return -EINVAL;
 	}
 
-	rc = log_rpc_set_stream_level(level);
-
-	if (rc) {
-		shell_error(sh, "Error: %d", rc);
-		return -ENOEXEC;
-	}
+	log_rpc_set_stream_level(level);
 
 	return 0;
 }
@@ -40,17 +35,12 @@ static int cmd_log_rpc_history_level(const struct shell *sh, size_t argc, char *
 
 	level = (enum log_rpc_level)shell_strtol(argv[1], 10, &rc);
 
-	if (rc) {
+	if (rc || level < LOG_RPC_LEVEL_NONE || level > LOG_RPC_LEVEL_DBG) {
 		shell_error(sh, "Invalid argument: %d", rc);
 		return -EINVAL;
 	}
 
-	rc = log_rpc_set_history_level(level);
-
-	if (rc) {
-		shell_error(sh, "Error: %d", rc);
-		return -ENOEXEC;
-	}
+	log_rpc_set_history_level(level);
 
 	return 0;
 }
@@ -99,6 +89,23 @@ static int cmd_log_rpc_history_fetch(const struct shell *sh, size_t argc, char *
 	return 0;
 }
 
+static int cmd_log_rpc_history_stop_fetch(const struct shell *sh, size_t argc, char *argv[])
+{
+	int rc = 0;
+	bool pause;
+
+	pause = shell_strtobool(argv[1], 0, &rc);
+
+	if (rc) {
+		shell_error(sh, "Invalid argument: %d", rc);
+		return -EINVAL;
+	}
+
+	log_rpc_stop_fetch_history(pause);
+
+	return 0;
+}
+
 static void history_threshold_reached_handler(void)
 {
 	shell_print(shell, "History usage threshold reached");
@@ -177,15 +184,18 @@ static int cmd_log_rpc_echo(const struct shell *sh, size_t argc, char *argv[])
 
 SHELL_STATIC_SUBCMD_SET_CREATE(
 	log_rpc_cmds,
-	SHELL_CMD_ARG(stream_level, NULL, "Set log streaming level", cmd_log_rpc_stream_level, 2,
-		      0),
-	SHELL_CMD_ARG(history_level, NULL, "Set log history level", cmd_log_rpc_history_level, 2,
-		      0),
+	SHELL_CMD_ARG(stream_level, NULL, "Set log streaming level <0-4>", cmd_log_rpc_stream_level,
+		      2, 0),
+	SHELL_CMD_ARG(history_level, NULL, "Set log history level <0-4>", cmd_log_rpc_history_level,
+		      2, 0),
 	SHELL_CMD_ARG(history_fetch, NULL, "Fetch log history", cmd_log_rpc_history_fetch, 1, 0),
-	SHELL_CMD_ARG(history_threshold, NULL, "Get or set history usage threshold",
+	SHELL_CMD_ARG(history_stop_fetch, NULL, "Stop log history transfer <pause?>",
+		      cmd_log_rpc_history_stop_fetch, 2, 0),
+	SHELL_CMD_ARG(history_threshold, NULL, "Get or set history usage threshold [0-100]",
 		      cmd_log_rpc_history_threshold, 1, 1),
 	SHELL_CMD_ARG(crash, NULL, "Retrieve remote device crash log", cmd_log_rpc_crash, 1, 0),
-	SHELL_CMD_ARG(echo, NULL, "Generate log message on remote", cmd_log_rpc_echo, 3, 0),
+	SHELL_CMD_ARG(echo, NULL, "Generate log message on remote <0-4> <msg>", cmd_log_rpc_echo, 3,
+		      0),
 	SHELL_SUBCMD_SET_END);
 
 SHELL_CMD_ARG_REGISTER(log_rpc, &log_rpc_cmds, "RPC logging commands", NULL, 1, 0);

subsys/logging/log_backend_rpc.c

@@ -488,6 +488,13 @@ static void history_transfer_task(struct k_work *work)
 	NRF_RPC_CBOR_ALLOC(&log_rpc_group, ctx, CONFIG_LOG_BACKEND_RPC_HISTORY_UPLOAD_CHUNK_SIZE);
 
 	k_mutex_lock(&history_transfer_mtx, K_FOREVER);
+
+	if (history_transfer_id == 0) {
+		/* History transfer has been stopped */
+		k_mutex_unlock(&history_transfer_mtx);
+		return;
+	}
+
 	nrf_rpc_encode_uint(&ctx, history_transfer_id);
 
 	while (true) {
@@ -564,6 +571,31 @@ static void log_rpc_fetch_history_handler(const struct nrf_rpc_group *group,
 NRF_RPC_CBOR_CMD_DECODER(log_rpc_group, log_rpc_fetch_history_handler, LOG_RPC_CMD_FETCH_HISTORY,
 			 log_rpc_fetch_history_handler, NULL);
 
+static void log_rpc_stop_fetch_history_handler(const struct nrf_rpc_group *group,
+					       struct nrf_rpc_cbor_ctx *ctx, void *handler_data)
+{
+	bool pause;
+
+	pause = nrf_rpc_decode_bool(ctx);
+
+	if (!nrf_rpc_decoding_done_and_check(group, ctx)) {
+		nrf_rpc_err(-EBADMSG, NRF_RPC_ERR_SRC_RECV, group, LOG_RPC_CMD_STOP_FETCH_HISTORY,
+			    NRF_RPC_PACKET_TYPE_CMD);
+		return;
+	}
+
+	k_mutex_lock(&history_transfer_mtx, K_FOREVER);
+	history_transfer_id = 0;
+	log_rpc_history_set_overwriting(!pause);
+	history_threshold_active = history_threshold > 0;
+	k_mutex_unlock(&history_transfer_mtx);
+
+	nrf_rpc_rsp_send_void(group);
+}
+
+NRF_RPC_CBOR_CMD_DECODER(log_rpc_group, log_rpc_stop_fetch_history_handler,
+			 LOG_RPC_CMD_STOP_FETCH_HISTORY, log_rpc_stop_fetch_history_handler, NULL);
+
 static void log_rpc_get_history_usage_threshold_handler(const struct nrf_rpc_group *group,
 							struct nrf_rpc_cbor_ctx *ctx,
 							void *handler_data)

subsys/logging/log_forwarder_rpc.c

@@ -66,28 +66,24 @@ static void log_rpc_msg_handler(const struct nrf_rpc_group *group, struct nrf_rp
 NRF_RPC_CBOR_EVT_DECODER(log_rpc_group, log_rpc_msg_handler, LOG_RPC_EVT_MSG, log_rpc_msg_handler,
 			 NULL);
 
-int log_rpc_set_stream_level(enum log_rpc_level level)
+void log_rpc_set_stream_level(enum log_rpc_level level)
 {
 	struct nrf_rpc_cbor_ctx ctx;
 
 	NRF_RPC_CBOR_ALLOC(&log_rpc_group, ctx, 1 + sizeof(level));
 	nrf_rpc_encode_uint(&ctx, level);
 	nrf_rpc_cbor_cmd_no_err(&log_rpc_group, LOG_RPC_CMD_SET_STREAM_LEVEL, &ctx,
 				nrf_rpc_rsp_decode_void, NULL);
-
-	return 0;
 }
 
-int log_rpc_set_history_level(enum log_rpc_level level)
+void log_rpc_set_history_level(enum log_rpc_level level)
 {
 	struct nrf_rpc_cbor_ctx ctx;
 
 	NRF_RPC_CBOR_ALLOC(&log_rpc_group, ctx, 1 + sizeof(level));
 	nrf_rpc_encode_uint(&ctx, level);
 	nrf_rpc_cbor_cmd_no_err(&log_rpc_group, LOG_RPC_CMD_SET_HISTORY_LEVEL, &ctx,
 				nrf_rpc_rsp_decode_void, NULL);
-
-	return 0;
 }
 
 int log_rpc_fetch_history(log_rpc_history_handler_t handler)
@@ -108,6 +104,20 @@ int log_rpc_fetch_history(log_rpc_history_handler_t handler)
 	return 0;
 }
 
+void log_rpc_stop_fetch_history(bool pause)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+
+	k_mutex_lock(&history_transfer_mtx, K_FOREVER);
+	history_handler = NULL;
+	k_mutex_unlock(&history_transfer_mtx);
+
+	NRF_RPC_CBOR_ALLOC(&log_rpc_group, ctx, 1);
+	nrf_rpc_encode_bool(&ctx, pause);
+	nrf_rpc_cbor_cmd_no_err(&log_rpc_group, LOG_RPC_CMD_STOP_FETCH_HISTORY, &ctx,
+				nrf_rpc_rsp_decode_void, NULL);
+}
+
 static void log_rpc_put_history_chunk_handler(const struct nrf_rpc_group *group,
 					      struct nrf_rpc_cbor_ctx *ctx, void *handler_data)
 {

subsys/logging/log_rpc_group.h

@@ -42,6 +42,7 @@ enum log_rpc_cmd_backend {
 	LOG_RPC_CMD_GET_HISTORY_USAGE_THRESHOLD,
 	LOG_RPC_CMD_SET_HISTORY_USAGE_THRESHOLD,
 	LOG_RPC_CMD_FETCH_HISTORY,
+	LOG_RPC_CMD_STOP_FETCH_HISTORY,
 	LOG_RPC_CMD_GET_CRASH_LOG,
 	LOG_RPC_CMD_ECHO,
 };