logging: Deprecate v1, default to v2

Reduced logging mode selection to deferred, immediate, minimal and
frontend. Decoupled logging version from mode and created CONFIG_LOG1
which can be used to explicitly select deprecated version.

From now on, chosing CONFIG_LOG_MODE_{IMMEDIATE,DEFERRED} will result
in version2.

Deprecated CONFIG_LOG2_MODE_{IMMEDIATE,DEFERRED} with cmake warning.

Codebase adapted to those changes.

Signed-off-by: Krzysztof Chruscinski <krzysztof.chruscinski@nordicsemi.no>

boards/posix/native_posix/doc/index.rst

@@ -644,7 +644,7 @@ development by integrating more seamlessly with the host operating system:
   ``--force-color``.
 
   In native_posix, by default, the logger is configured with
-  :kconfig:`CONFIG_LOG_IMMEDIATE`.
+  :kconfig:`CONFIG_LOG_MODE_IMMEDIATE`.
 
   This backend can be selected with :kconfig:`CONFIG_LOG_BACKEND_NATIVE_POSIX`
   and is enabled by default unless the native_posix UART is compiled in.

doc/reference/logging/index.rst

@@ -117,14 +117,12 @@ Mode of operations:
 
 :kconfig:`CONFIG_LOG_MODE_DEFERRED`: Deferred mode.
 
-:kconfig:`CONFIG_LOG2_MODE_DEFERRED`: Deferred mode v2.
-
 :kconfig:`CONFIG_LOG_MODE_IMMEDIATE`: Immediate (synchronous) mode.
 
-:kconfig:`CONFIG_LOG2_MODE_IMMEDIATE`: Immediate (synchronous) mode v2.
-
 :kconfig:`CONFIG_LOG_MODE_MINIMAL`: Minimal footprint mode.
 
+:kconfig:`CONFIG_LOG1`: Use deprecated version of logging.
+
 Filtering options:
 
 :kconfig:`CONFIG_LOG_RUNTIME_FILTERING`: Enables runtime reconfiguration of the

include/logging/log_backend_std.h

@@ -101,8 +101,7 @@ log_backend_std_sync_string(const struct log_output *const output,
 		flags |= LOG_OUTPUT_FLAG_FORMAT_TIMESTAMP;
 	}
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE) &&
+	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
-		IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
 		/* In order to ensure that one log processing is not interrupted
 		 * by another one, lock context for whole log processing.
 		 */
@@ -111,8 +110,7 @@ log_backend_std_sync_string(const struct log_output *const output,
 
 	log_output_string(output, src_level, timestamp, fmt, ap, flags);
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE) &&
+	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
-		IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
 		irq_unlock(key);
 	}
 }
@@ -144,8 +142,7 @@ log_backend_std_sync_hexdump(const struct log_output *const output,
 		flags |= LOG_OUTPUT_FLAG_FORMAT_TIMESTAMP;
 	}
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE) &&
+	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
-		IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
 		/* In order to ensure that one log processing is not interrupted
 		 * by another one, lock context for whole log processing.
 		 */
@@ -155,8 +152,7 @@ log_backend_std_sync_hexdump(const struct log_output *const output,
 	log_output_hexdump(output, src_level, timestamp,
 			metadata, data, length, flags);
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE) &&
+	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
-		IS_ENABLED(CONFIG_LOG_IMMEDIATE_CLEAN_OUTPUT)) {
 		irq_unlock(key);
 	}
 }

include/logging/log_core.h

@@ -202,7 +202,7 @@ extern "C" {
 #define Z_LOG_INTERNAL2(is_user_context, _src_level, ...) do { \
 	if (is_user_context) { \
 		log_from_user(_src_level, __VA_ARGS__); \
-	} else if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) { \
+	} else if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) { \
 		log_string_sync(_src_level, __VA_ARGS__); \
 	} else { \
 		Z_LOG_INTERNAL_X(Z_LOG_NARGS_POSTFIX(__VA_ARGS__), \
@@ -442,7 +442,7 @@ static inline char z_log_minimal_level_to_char(int level)
 	if (is_user_context) { \
 		log_hexdump_from_user(src_level, _str, \
 				      (const char *)_data, _len); \
-	} else if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) { \
+	} else if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) { \
 		log_hexdump_sync(src_level, _str, (const char *)_data, _len); \
 	} else { \
 		log_hexdump(_str, (const char *)_data, _len, src_level); \
@@ -860,7 +860,7 @@ static inline log_arg_t z_log_do_strdup(uint32_t msk, uint32_t idx,
 do {									       \
 	if (is_user_context) {						       \
 		log_generic_from_user(_src_level, _str, _valist);	       \
-	} else if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {			       \
+	} else if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {		       \
 		log_generic(_src_level, _str, _valist, _strdup_action);        \
 	} else if (_argnum == 0) {					       \
 		_LOG_INTERNAL_0(_src_level, _str);			       \

include/logging/log_ctrl.h

@@ -201,10 +201,9 @@ uint32_t log_get_strdup_longest_string(void);
  */
 static inline bool log_data_pending(void)
 {
-	if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_DEFERRED)) {
-		return z_log_msg2_pending();
+		return IS_ENABLED(CONFIG_LOG2) ?
-	} else if (IS_ENABLED(CONFIG_LOG_MODE_DEFERRED)) {
+			z_log_msg2_pending() : (log_msg_mem_get_used() > 0);
-		return log_msg_mem_get_used() > 0;
 	}
 
 	return false;

include/logging/log_msg2.h

@@ -353,7 +353,7 @@ do {\
 				  Z_LOG_FMT_ARGS(_fmt, ##__VA_ARGS__));\
 	_mode = Z_LOG_MSG2_MODE_RUNTIME; \
 } while (0)
-#elif defined(CONFIG_LOG2_MODE_IMMEDIATE) /* CONFIG_LOG2_ALWAYS_RUNTIME */
+#elif defined(CONFIG_LOG_MODE_IMMEDIATE) /* CONFIG_LOG2_ALWAYS_RUNTIME */
 #define Z_LOG_MSG2_CREATE2(_try_0cpy, _mode,  _cstr_cnt, _domain_id, _source,\
 			  _level, _data, _dlen, ...) \
 do { \

include/shell/shell_log_backend.h

@@ -91,9 +91,9 @@ int z_shell_log_backend_output_func(uint8_t *data, size_t length, void *ctx);
 		.log_output = &_name##_log_output, \
 		.control_block = &_name##_control_block, \
 		.timeout = _timeout, \
-		.mpsc_buffer_config = IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED) ? \
+		.mpsc_buffer_config = IS_ENABLED(CONFIG_LOG2_DEFERRED) ? \
 			&_name##_mpsc_buffer_config : NULL, \
-		.mpsc_buffer = IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED) ? \
+		.mpsc_buffer = IS_ENABLED(CONFIG_LOG2_DEFERRED) ? \
 			&_name##_mpsc_buffer : NULL, \
 	}
 

samples/bluetooth/iso_broadcast_benchmark/prj.conf

@@ -14,5 +14,4 @@ CONFIG_MAIN_STACK_SIZE=2048
 
 CONFIG_LOG=y
 CONFIG_CBPRINTF_FP_SUPPORT=y
-CONFIG_LOG2_MODE_DEFERRED=y
 CONFIG_LOG_BUFFER_SIZE=2048

samples/bluetooth/iso_connected_benchmark/prj.conf

@@ -13,5 +13,4 @@ CONFIG_MAIN_STACK_SIZE=2048
 
 CONFIG_LOG=y
 CONFIG_CBPRINTF_FP_SUPPORT=y
-CONFIG_LOG2_MODE_DEFERRED=y
 CONFIG_LOG_BUFFER_SIZE=2048

samples/subsys/logging/dictionary/prj.conf

@@ -2,4 +2,3 @@ CONFIG_LOG=y
 CONFIG_LOG_PRINTK=y
 CONFIG_LOG_BACKEND_UART_OUTPUT_DICTIONARY_HEX=y
 CONFIG_LOG_BACKEND_UART=y
-CONFIG_LOG2_MODE_DEFERRED=y

samples/subsys/logging/logger/src/main.c

@@ -208,12 +208,12 @@ static void wait_on_log_flushed(void)
  */
 static void performance_showcase(void)
 {
-/* Arbitrary limit when LOG_IMMEDIATE is enabled. */
+/* Arbitrary limit when LOG_MODE_IMMEDIATE is enabled. */
 #define LOG_IMMEDIATE_TEST_MESSAGES_LIMIT 50
 
 	volatile uint32_t current_timestamp;
 	volatile uint32_t start_timestamp;
-	uint32_t limit = COND_CODE_1(CONFIG_LOG_IMMEDIATE,
+	uint32_t limit = COND_CODE_1(CONFIG_LOG_MODE_IMMEDIATE,
 			     (LOG_IMMEDIATE_TEST_MESSAGES_LIMIT),
 			     (CONFIG_LOG_BUFFER_SIZE / sizeof(struct log_msg)));
 	uint32_t per_sec;

samples/subsys/logging/syst/sample.yaml

@@ -9,6 +9,8 @@ tests:
       type: one_line
       regex:
         - "SYS-T RAW DATA: "
+    extra_configs:
+      - CONFIG_LOG1=y
   sample.logger.syst.v2.deferred:
     platform_allow: mps2_an385 sam_e70_xplained
     tags: logging
@@ -17,5 +19,3 @@ tests:
       type: one_line
       regex:
         - "SYS-T RAW DATA: "
-    extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y

subsys/bluetooth/common/dummy.c

@@ -54,7 +54,7 @@ BUILD_ASSERT(CONFIG_BT_DRIVER_RX_HIGH_PRIO < CONFIG_BT_HCI_TX_PRIO);
 #if !defined(CONFIG_TEST) && !defined(CONFIG_ARCH_POSIX) && \
     defined(CONFIG_BT_LL_SW_SPLIT) &&                       \
     defined(INCOMPATIBLE_IMMEDIATE_LOG_BACKEND)
-BUILD_ASSERT(!IS_ENABLED(CONFIG_LOG_IMMEDIATE), "Immediate logging "
+BUILD_ASSERT(!IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE), "Immediate logging "
 	     "on selected backend(s) not "
 	     "supported with the software Link Layer");
 #endif

subsys/bluetooth/host/monitor.c

@@ -368,8 +368,8 @@ static void monitor_log_init(const struct log_backend *const backend)
 }
 
 static const struct log_backend_api monitor_log_api = {
-	.process = IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED) ? monitor_log_process : NULL,
+	.process = IS_ENABLED(CONFIG_LOG2_DEFERRED) ? monitor_log_process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? monitor_log_put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? monitor_log_put : NULL,
 	.panic = monitor_log_panic,
 	.init = monitor_log_init,
 };

subsys/logging/CMakeLists.txt

@@ -84,3 +84,15 @@ if(NOT CONFIG_LOG_MODE_MINIMAL)
 else()
   zephyr_sources(log_minimal.c)
 endif()
+
+if(CONFIG_LOG2_MODE_IMMEDIATE OR CONFIG_LOG2_MODE_DEFERRED)
+  message(WARNING "CONFIG_LOG2_MODE_{IMMEDIATE,DEFERRED} is deprecated. Please \
+                  use CONFIG_LOG_MODE_{IMMEDIATE,DEFERRED} which defaults to v2"
+         )
+endif()
+
+if(CONFIG_LOG1)
+  message(WARNING "Logging v1 has been deprecated. Use v2 and instead and adapt \
+                   custom backend to the new backend API"
+         )
+endif()

subsys/logging/Kconfig.backends

@@ -240,7 +240,7 @@ config LOG_BACKEND_XTENSA_OUTPUT_BUFFER_SIZE
 # rsyslog message to be malformed.
 config LOG_BACKEND_NET
 	bool "Enable networking backend"
-	depends on NETWORKING && NET_UDP && !LOG_IMMEDIATE
+	depends on NETWORKING && NET_UDP && !LOG_MODE_IMMEDIATE
 	select NET_CONTEXT_NET_PKT_POOL
 	help
 	  Send syslog messages to network server.

subsys/logging/Kconfig.formatting

@@ -42,7 +42,7 @@ config LOG_DICTIONARY_SUPPORT
 
 config LOG_IMMEDIATE_CLEAN_OUTPUT
 	bool "Clean log output"
-	depends on LOG_IMMEDIATE
+	depends on LOG_MODE_IMMEDIATE
 	help
 	  If enabled, interrupts are locked during whole log message processing.
 	  As a result, processing on one log message cannot be interrupted by

subsys/logging/Kconfig.mode

@@ -4,36 +4,18 @@
 choice LOG_MODE
 	prompt "Mode"
 	default LOG_MODE_MINIMAL if LOG_DEFAULT_MINIMAL
+	default LOG_MODE_IMMEDIATE if LOG2_MODE_IMMEDIATE
 	default LOG_MODE_DEFERRED
 
 config LOG_MODE_DEFERRED
 	bool "Deferred logging"
-	select MPSC_PBUF
 	help
 	  Log messages are buffered and processed later. This mode has the
 	  least impact on the application. Time consuming processing is
 	  deferred to the known context.
 
-config LOG2_MODE_DEFERRED
-	bool "Deferred logging v2"
-	select MPSC_PBUF
-	select LOG2
-
-config LOG2_MODE_IMMEDIATE
-	bool "Synchronous v2"
-	select LOG2
-	select MPSC_PBUF
-	help
-	  When enabled log is processed in the context of the call. It impacts
-	  performance of the system since time consuming operations are
-	  performed in the context of the log entry (e.g. high priority
-	  interrupt).Logger backends must support exclusive access to work
-	  flawlessly in that mode because one log operation can be interrupted
-	  by another one in the higher priority context.
-
 config LOG_MODE_IMMEDIATE
 	bool "Synchronous"
-	select MPSC_PBUF
 	help
 	  When enabled log is processed in the context of the call. It impacts
 	  performance of the system since time consuming operations are
@@ -42,7 +24,6 @@ config LOG_MODE_IMMEDIATE
 	  flawlessly in that mode because one log operation can be interrupted
 	  by another one in the higher priority context.
 
-
 config LOG_MODE_MINIMAL
 	bool "Minimal-footprint"
 	imply PRINTK
@@ -64,13 +45,43 @@ config LOG_FRONTEND
 
 endchoice
 
+config LOG2_MODE_DEFERRED
+	bool "Deferred v2 (DEPRECATED)"
+	help
+	  Option has been deprecated. Use LOG_MODE_DEFERRED which defaults now
+	  to v2.
+
+config LOG2_MODE_IMMEDIATE
+	bool "Synchronous v2 (DEPRECATED)"
+	help
+	  Option has been deprecated. Use LOG_MODE_IMMEDIATE which defaults now
+	  to v2.
+
+config LOG1
+	bool "Use v1 (DEPRECATED)"
+	help
+	  Deprecated.
+
 config LOG2
 	bool
+	select MPSC_PBUF
+	default y if !LOG1
 
-config LOG_IMMEDIATE
+config LOG1_IMMEDIATE
 	bool
-	default y if LOG_MODE_IMMEDIATE
+	default y if LOG1 && LOG_MODE_IMMEDIATE
-	default y if LOG2_MODE_IMMEDIATE
+
+config LOG1_DEFERRED
+	bool
+	default y if LOG1 && LOG_MODE_DEFERRED
+
+config LOG2_IMMEDIATE
+	bool
+	default y if !LOG1 && LOG_MODE_IMMEDIATE
+
+config LOG2_DEFERRED
+	bool
+	default y if !LOG1 && LOG_MODE_DEFERRED
 
 config LOG_DEFAULT_MINIMAL
 	bool

subsys/logging/Kconfig.processing

@@ -13,12 +13,12 @@ config LOG_PRINTK
 config LOG_PRINTK_MAX_STRING_LENGTH
 	int "Maximum string length supported by LOG_PRINTK"
 	depends on LOG_PRINTK
-	depends on (!LOG_IMMEDIATE || USERSPACE)
+	depends on (!LOG_MODE_IMMEDIATE || USERSPACE)
 	default 128
 	help
 	  Array is allocated on the stack.
 
-if !LOG_IMMEDIATE
+if !LOG_MODE_IMMEDIATE
 
 config LOG_MODE_OVERFLOW
 	bool "Drop oldest message when full"
@@ -106,13 +106,13 @@ config LOG_BUFFER_SIZE
 	help
 	  Number of bytes dedicated for the logger internal buffer.
 
-endif # !LOG_IMMEDIATE
+endif # !LOG_MODE_IMMEDIATE
 
-if LOG_MODE_DEFERRED
+if LOG1_DEFERRED
 
 config LOG_DETECT_MISSED_STRDUP
 	bool "Detect missed handling of transient strings"
-	default y if !LOG_IMMEDIATE
+	default y
 	help
 	  If enabled, logger will assert and log error message is it detects
 	  that string format specifier (%s) and string address which is not from
@@ -147,7 +147,7 @@ config LOG_STRDUP_POOL_PROFILING
 	  When enabled, maximal utilization of the pool is tracked. It can
 	  be read out using shell command.
 
-endif # LOG_MODE_DEFERRED
+endif # LOG1_DEFERRED
 
 if LOG2
 

subsys/logging/log_backend_adsp.c

@@ -78,12 +78,12 @@ static void process(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_adsp_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 		put_sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 		put_sync_hexdump : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 	.panic = panic,
 };
 

subsys/logging/log_backend_native_posix.c

@@ -145,13 +145,13 @@ static void process(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_native_posix_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 	.panic = panic,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };
 
 LOG_BACKEND_DEFINE(log_backend_native_posix,

subsys/logging/log_backend_net.c

@@ -257,11 +257,11 @@ const struct log_backend_api log_backend_net_api = {
 	.panic = panic,
 	.init = init_net,
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? send_output : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? send_output : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 							sync_string : NULL,
 	/* Currently we do not send hexdumps over network to remote server
-	 * in CONFIG_LOG_IMMEDIATE mode. This is just to save resources,
+	 * if CONFIG_LOG_MODE_IMMEDIATE is used. This is just to save resources,
 	 * this can be revisited if needed.
 	 */
 	.put_sync_hexdump = NULL,

subsys/logging/log_backend_rtt.c

@@ -43,7 +43,7 @@
 
 #define CHAR_BUF_SIZE \
 	((IS_ENABLED(CONFIG_LOG_BACKEND_RTT_MODE_BLOCK) && \
-	 !IS_ENABLED(CONFIG_LOG_IMMEDIATE)) ? \
+	 !IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) ? \
 		CONFIG_LOG_BACKEND_RTT_OUTPUT_BUFFER_SIZE : 1)
 
 #define RTT_LOCK() \
@@ -75,7 +75,7 @@ static int line_out_drop_mode(void);
 
 static inline bool is_sync_mode(void)
 {
-	return IS_ENABLED(CONFIG_LOG_IMMEDIATE) || panic_mode;
+	return IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) || panic_mode;
 }
 
 static inline bool is_panic_mode(void)
@@ -327,14 +327,14 @@ static void process(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_rtt_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 	.panic = panic,
 	.init = log_backend_rtt_init,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };
 
 LOG_BACKEND_DEFINE(log_backend_rtt, log_backend_rtt_api, true);

subsys/logging/log_backend_spinel.c

@@ -128,14 +128,14 @@ static int write(uint8_t *data, size_t length, void *ctx)
 
 const struct log_backend_api log_backend_spinel_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 	.panic = panic,
 	.init = log_backend_spinel_init,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };
 
 LOG_BACKEND_DEFINE(log_backend_spinel, log_backend_spinel_api, true);

subsys/logging/log_backend_swo.c

@@ -155,14 +155,14 @@ static void log_backend_swo_sync_hexdump(
 
 const struct log_backend_api log_backend_swo_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? log_backend_swo_process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? log_backend_swo_put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? log_backend_swo_put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			log_backend_swo_sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			log_backend_swo_sync_hexdump : NULL,
 	.panic = log_backend_swo_panic,
 	.init = log_backend_swo_init,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };
 
 LOG_BACKEND_DEFINE(log_backend_swo, log_backend_swo_api, true);

subsys/logging/log_backend_uart.c

@@ -185,14 +185,14 @@ static void sync_hexdump(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_uart_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 	.panic = panic,
 	.init = log_backend_uart_init,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };
 
 LOG_BACKEND_DEFINE(log_backend_uart, log_backend_uart_api, true);

subsys/logging/log_backend_xtensa_sim.c

@@ -15,7 +15,7 @@
 #include <logging/log_backend_std.h>
 #include <xtensa/simcall.h>
 
-#define CHAR_BUF_SIZE (IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? \
+#define CHAR_BUF_SIZE (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? \
 		1 : CONFIG_LOG_BACKEND_XTENSA_OUTPUT_BUFFER_SIZE)
 
 static uint8_t xtensa_log_buf[CHAR_BUF_SIZE];
@@ -82,13 +82,13 @@ static void sync_hexdump(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_xtensa_sim_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 	.panic = panic,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };
 
 LOG_BACKEND_DEFINE(log_backend_xtensa_sim, log_backend_xtensa_sim_api, true);

subsys/logging/log_cmds.c

@@ -366,8 +366,8 @@ static int cmd_log_strdup_utilization(const struct shell *shell,
 				      size_t argc, char **argv)
 {
 
-	/* Defines needed when string duplication is disabled (LOG_IMMEDIATE is
+	/* Defines needed when string duplication is disabled (LOG2 or immediate
-	 * on). In that case, this function is not compiled in.
+	 * mode). In that case, this function is not compiled in.
 	 */
 	#ifndef CONFIG_LOG_STRDUP_BUF_COUNT
 	#define CONFIG_LOG_STRDUP_BUF_COUNT 0

subsys/logging/log_core.c

@@ -388,7 +388,7 @@ void z_log_printk(const char *fmt, va_list ap)
 			vsnprintk(str, sizeof(str), fmt, ap);
 
 			z_log_string_from_user(src_level_union.value, str);
-		} else if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+		} else if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 			log_generic(src_level_union.structure, fmt, ap,
 							LOG_STRDUP_SKIP);
 		} else {
@@ -438,7 +438,7 @@ void log_generic(struct log_msg_ids src_level, const char *fmt, va_list ap,
 {
 	if (k_is_user_context()) {
 		log_generic_from_user(src_level, fmt, ap);
-	} else if (IS_ENABLED(CONFIG_LOG_IMMEDIATE) &&
+	} else if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) &&
 	    (!IS_ENABLED(CONFIG_LOG_FRONTEND))) {
 		struct log_backend const *backend;
 		uint32_t timestamp = timestamp_func();
@@ -563,11 +563,9 @@ void log_core_init(void)
 
 	log_set_timestamp_func(_timestamp_func, freq);
 
-	if (IS_ENABLED(CONFIG_LOG2)) {
+	if (IS_ENABLED(CONFIG_LOG2_DEFERRED)) {
-		if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+		z_log_msg2_init();
-			z_log_msg2_init();
+	} else if (IS_ENABLED(CONFIG_LOG1_DEFERRED)) {
-		}
-	} else if (IS_ENABLED(CONFIG_LOG_MODE_DEFERRED)) {
 		log_msg_pool_init();
 		log_list_init(&list);
 
@@ -614,7 +612,7 @@ static void thread_set(k_tid_t process_tid)
 {
 	proc_tid = process_tid;
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		return;
 	}
 
@@ -667,7 +665,7 @@ void z_impl_log_panic(void)
 		}
 	}
 
-	if (!IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (!IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		/* Flush */
 		while (log_process(false) == true) {
 		}
@@ -746,12 +744,10 @@ static void msg_process(union log_msgs msg, bool bypass)
 		}
 	}
 
-	if (!IS_ENABLED(CONFIG_LOG2_MODE_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG2_DEFERRED)) {
-		if (IS_ENABLED(CONFIG_LOG2)) {
+		z_log_msg2_free(msg.msg2);
-			z_log_msg2_free(msg.msg2);
+	} else if (IS_ENABLED(CONFIG_LOG1_DEFERRED)) {
-		} else {
+		log_msg_put(msg.msg);
-			log_msg_put(msg.msg);
-		}
 	}
 }
 
@@ -882,7 +878,7 @@ char *z_log_strdup(const char *str)
 	struct log_strdup_buf *dup;
 	int err;
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE) ||
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ||
 	    is_rodata(str) || k_is_user_context()) {
 		return (char *)str;
 	}
@@ -1008,7 +1004,7 @@ void z_vrfy_z_log_string_from_user(uint32_t src_level_val, const char *str)
 	Z_OOPS(Z_SYSCALL_VERIFY_MSG(err == 0, "invalid string passed in"));
 	Z_OOPS(Z_SYSCALL_MEMORY_READ(str, len));
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG1_IMMEDIATE)) {
 		log_string_sync(src_level_union.structure, "%s", str);
 	} else if (IS_ENABLED(CONFIG_LOG_PRINTK) &&
 		   (level == LOG_LEVEL_INTERNAL_RAW_STRING)) {
@@ -1103,7 +1099,7 @@ void z_vrfy_z_log_hexdump_from_user(uint32_t src_level_val, const char *metadata
 	Z_OOPS(Z_SYSCALL_VERIFY_MSG(err == 0, "invalid meta passed in"));
 	Z_OOPS(Z_SYSCALL_MEMORY_READ(data, len));
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG1_IMMEDIATE)) {
 		log_hexdump_sync(src_level_union.structure,
 				 kmeta, data, len);
 	} else {
@@ -1193,7 +1189,7 @@ void z_log_msg2_commit(struct log_msg2 *msg)
 {
 	msg->hdr.timestamp = timestamp_func();
 
-	if (IS_ENABLED(CONFIG_LOG2_MODE_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		union log_msgs msgs = {
 			.msg2 = (union log_msg2_generic *)msg
 		};
@@ -1204,10 +1200,7 @@ void z_log_msg2_commit(struct log_msg2 *msg)
 	}
 
 	mpsc_pbuf_commit(&log_buffer, (union mpsc_pbuf_generic *)msg);
-
+	z_log_msg_post_finalize();
-	if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
-		z_log_msg_post_finalize();
-	}
 }
 
 union log_msg2_generic *z_log_msg2_claim(void)

subsys/logging/log_msg2.c

@@ -75,7 +75,7 @@ void z_impl_z_log_msg2_runtime_vcreate(uint8_t domain_id, const void *source,
 	struct log_msg2_desc desc =
 		Z_LOG_MSG_DESC_INITIALIZER(domain_id, level, plen, dlen);
 
-	if (IS_ENABLED(CONFIG_LOG2_MODE_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		msg = alloca(msg_wlen * sizeof(int));
 	} else {
 		msg = z_log_msg2_alloc(msg_wlen);

subsys/logging/log_output.c

@@ -103,7 +103,7 @@ static int out_func(int c, void *ctx)
 	const struct log_output *out_ctx = (const struct log_output *)ctx;
 	int idx;
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		/* Backend must be thread safe in synchronous operation. */
 		out_ctx->func((uint8_t *)&c, 1, out_ctx->control_block->ctx);
 		return 0;

subsys/shell/shell.c

@@ -1152,7 +1152,7 @@ static void shell_log_process(const struct shell *shell)
 	int result;
 
 	do {
-		if (!IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+		if (!IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 			z_shell_cmd_line_erase(shell);
 
 			processed = z_shell_log_backend_process(

subsys/shell/shell_log_backend.c

@@ -30,14 +30,14 @@ static struct log_msg *msg_from_fifo(const struct shell_log_backend *backend)
 /* Set fifo clean state (in case of deferred mode). */
 static void fifo_reset(const struct shell_log_backend *backend)
 {
-	if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+	if (IS_ENABLED(CONFIG_LOG2_DEFERRED)) {
 		mpsc_pbuf_init(backend->mpsc_buffer,
 			       backend->mpsc_buffer_config);
 		return;
 	}
 
 	/* Flush pending log messages without processing. */
-	if (IS_ENABLED(CONFIG_LOG_MODE_DEFERRED)) {
+	if (IS_ENABLED(CONFIG_LOG1_DEFERRED)) {
 		struct log_msg *msg;
 
 		while ((msg = msg_from_fifo(backend)) != NULL) {
@@ -51,7 +51,7 @@ void z_shell_log_backend_enable(const struct shell_log_backend *backend,
 {
 	int err = 0;
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		const struct shell *shell;
 
 		shell = (const struct shell *)ctx;
@@ -176,7 +176,7 @@ bool z_shell_log_backend_process(const struct shell_log_backend *backend)
 		}
 	}
 
-	if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+	if (IS_ENABLED(CONFIG_LOG2_DEFERRED)) {
 		return process_msg2_from_buffer(shell);
 	}
 
@@ -281,7 +281,7 @@ static void panic(const struct log_backend *const backend)
 	const struct shell *shell = (const struct shell *)backend->cb->ctx;
 	int err;
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		return;
 	}
 
@@ -300,11 +300,11 @@ static void panic(const struct log_backend *const backend)
 		z_shell_op_cursor_horiz_move(shell,
 					   -shell->ctx->vt100_ctx.cons.cur_x);
 
-		if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+		if (IS_ENABLED(CONFIG_LOG2_DEFERRED)) {
 			while (process_msg2_from_buffer(shell)) {
 				/* empty */
 			}
-		} else if (IS_ENABLED(CONFIG_LOG_MODE_DEFERRED)) {
+		} else if (IS_ENABLED(CONFIG_LOG1_DEFERRED)) {
 			while (z_shell_log_backend_process(
 						shell->log_backend)) {
 				/* empty */
@@ -416,7 +416,7 @@ static void log2_process(const struct log_backend *const backend,
 
 	switch (shell->log_backend->control_block->state) {
 	case SHELL_LOG_BACKEND_ENABLED:
-		if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+		if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 			process_log_msg2(shell, log_output, msg, true, colors);
 		} else {
 			copy_to_pbuffer(mpsc_buffer, msg,
@@ -445,10 +445,10 @@ static void log2_process(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_shell_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? log2_process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			put_sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			put_sync_hexdump : NULL,
 	.dropped = dropped,
 	.panic = panic,

tests/subsys/logging/log_api/src/mock_backend.c

@@ -381,12 +381,12 @@ static void sync_hexdump(const struct log_backend *const backend,
 
 const struct log_backend_api mock_log_backend_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 	.panic = panic,
 	.init = mock_init,
-	.dropped = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? NULL : dropped,
+	.dropped = IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? NULL : dropped,
 };

tests/subsys/logging/log_api/src/test.inc

@@ -331,7 +331,7 @@ static void test_log_overflow(void)
 {
 	log_timestamp_t exp_timestamp = TIMESTAMP_INIT_VAL;
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		ztest_test_skip();
 	}
 
@@ -372,7 +372,7 @@ static void test_log_overflow(void)
 	exp_timestamp = TIMESTAMP_INIT_VAL;
 	hexdump_len = get_max_hexdump();
 	mock_log_backend_reset(&backend1);
-	if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+	if (IS_ENABLED(CONFIG_LOG2_DEFERRED)) {
 		/* Log2 allocation is not destructive if request exceeds the
 		 * capacity.
 		 */
@@ -577,7 +577,7 @@ static void log_n_messages(uint32_t n_msg, uint32_t exp_dropped)
  */
 static void test_log_msg_dropped_notification(void)
 {
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		ztest_test_skip();
 	}
 
@@ -639,7 +639,7 @@ static void *log_api_suite_setup(void)
 {
 	PRINT("Configuration:\n");
 	PRINT("\t Mode: %s\n",
-	      IS_ENABLED(CONFIG_LOG_IMMEDIATE) ? "Immediate" : "Deferred");
+	      IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? "Immediate" : "Deferred");
 	PRINT("\t Version: %s\n",
 	      IS_ENABLED(CONFIG_LOG2) ? "v2" : "v1");
 	PRINT("\t Runtime filtering: %s\n",

tests/subsys/logging/log_api/testcase.yaml

@@ -6,25 +6,30 @@ common:
 tests:
   logging.log_api_deferred_overflow_rt_filter:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_MODE_OVERFLOW=y
       - CONFIG_LOG_RUNTIME_FILTERING=y
   logging.log_api_deferred_overflow:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_MODE_OVERFLOW=y
   logging.log_api_deferred_no_overflow:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_MODE_OVERFLOW=n
 
   logging.log_api_deferred_static_filter:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_SAMPLE_MODULE_LOG_LEVEL_DBG=y
 
   logging.log_api_deferred_func_prefix:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_SAMPLE_MODULE_LOG_LEVEL_DBG=y
       - CONFIG_LOG_FUNC_NAME_PREFIX_DBG=y
@@ -32,15 +37,18 @@ tests:
 
   logging.log_api_immediate:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_IMMEDIATE=y
 
   logging.log_api_immediate_rt_filter:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_IMMEDIATE=y
       - CONFIG_LOG_RUNTIME_FILTERING=y
 
   logging.log_api_immediate_static_filter:
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_LOG_MODE_IMMEDIATE=y
       - CONFIG_SAMPLE_MODULE_LOG_LEVEL_DBG=y
 
@@ -48,7 +56,7 @@ tests:
     # FIXME:see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_MODE_OVERFLOW=y
       - CONFIG_LOG_RUNTIME_FILTERING=y
 
@@ -56,28 +64,28 @@ tests:
     # FIXME:see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_MODE_OVERFLOW=y
 
   logging.log2_api_deferred_no_overflow:
     # FIXME:see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_MODE_OVERFLOW=n
 
   logging.log2_api_deferred_static_filter:
     # FIXME:see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_SAMPLE_MODULE_LOG_LEVEL_DBG=y
 
   logging.log2_api_deferred_func_prefix:
     # FIXME:see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_SAMPLE_MODULE_LOG_LEVEL_DBG=y
       - CONFIG_LOG_FUNC_NAME_PREFIX_DBG=y
 
@@ -85,32 +93,32 @@ tests:
     # FIXME:see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_DEFERRED=y
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_LOG_TIMESTAMP_64BIT=y
 
   logging.log2_api_immediate:
     # FIXME: qemu_arc_hs6x excluded, see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_IMMEDIATE=y
+      - CONFIG_LOG_MODE_IMMEDIATE=y
 
   logging.log2_api_immediate_rt_filter:
     # FIXME: qemu_arc_hs6x excluded, see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_IMMEDIATE=y
+      - CONFIG_LOG_MODE_IMMEDIATE=y
       - CONFIG_LOG_RUNTIME_FILTERING=y
 
   logging.log2_api_immediate_static_filter:
     # FIXME: qemu_arc_hs6x excluded, see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_IMMEDIATE=y
+      - CONFIG_LOG_MODE_IMMEDIATE=y
       - CONFIG_SAMPLE_MODULE_LOG_LEVEL_DBG=y
 
   logging.log2_api_immediate_64b_timestamp:
     # FIXME: qemu_arc_hs6x excluded, see #38041
     platform_exclude: qemu_arc_hs6x
     extra_configs:
-      - CONFIG_LOG2_MODE_IMMEDIATE=y
+      - CONFIG_LOG_MODE_IMMEDIATE=y
       - CONFIG_LOG_TIMESTAMP_64BIT=y

tests/subsys/logging/log_benchmark/src/main.c

@@ -75,7 +75,7 @@ static void dropped(struct log_backend const *const backend, uint32_t cnt)
 }
 
 const struct log_backend_api log_backend_test_api = {
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
 	.panic = panic,
 	.dropped = dropped,
@@ -240,13 +240,11 @@ void test_log_message_with_string(void)
 /*test case main entry*/
 void test_main(void)
 {
-	PRINT("LOGGING MODE:%s\n", IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? "DEFERREDv1" :
+	PRINT("LOGGING MODE:%s\n", IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? "DEFERRED" : "IMMEDIATE");
-			(IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED) ? "DEFERREDv2" :
+	PRINT("VERSION:v%d\n", IS_ENABLED(CONFIG_LOG1) ? 1 : 2);
-			(IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE) ? "IMMEDIATEv1" :
-			"IMMEDIATEv2")));
 	PRINT("\tOVERWRITE: %d\n", IS_ENABLED(CONFIG_LOG_MODE_OVERFLOW));
 	PRINT("\tBUFFER_SIZE: %d\n", CONFIG_LOG_BUFFER_SIZE);
-	if (IS_ENABLED(CONFIG_LOG2_MODE_DEFERRED)) {
+	if (!IS_ENABLED(CONFIG_LOG1)) {
 		PRINT("\tSPEED: %d", IS_ENABLED(CONFIG_LOG_SPEED));
 	}
 	ztest_test_suite(test_log_benchmark,

tests/subsys/logging/log_benchmark/testcase.yaml

@@ -4,6 +4,7 @@ tests:
       - native_posix
     tags: logging
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_CBPRINTF_COMPLETE=y
       - CONFIG_LOG_STRDUP_BUF_COUNT=8
       - CONFIG_LOG_STRDUP_MAX_STRING=32
@@ -15,6 +16,7 @@ tests:
     tags: logging
     platform_allow: qemu_x86 native_posix
     extra_configs:
+      - CONFIG_LOG1=y
       - CONFIG_CBPRINTF_COMPLETE=y
       - CONFIG_LOG_STRDUP_BUF_COUNT=8
       - CONFIG_LOG_STRDUP_MAX_STRING=32
@@ -26,16 +28,16 @@ tests:
       - native_posix
     tags: logging
     extra_configs:
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_CBPRINTF_COMPLETE=y
-      - CONFIG_LOG2_MODE_DEFERRED=y
 
   logging.log_benchmark_v2_speed:
     integration_platforms:
       - native_posix
     tags: logging
     extra_configs:
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_CBPRINTF_COMPLETE=y
-      - CONFIG_LOG2_MODE_DEFERRED=y
       - CONFIG_LOG_SPEED=y
 
   logging.log_benchmark_user_v2:
@@ -44,7 +46,6 @@ tests:
     tags: logging
     platform_allow: qemu_x86 native_posix
     extra_configs:
+      - CONFIG_LOG_MODE_DEFERRED=y
       - CONFIG_CBPRINTF_COMPLETE=y
-      - CONFIG_CBPRINTF_COMPLETE=y
-      - CONFIG_LOG2_MODE_DEFERRED=y
       - CONFIG_TEST_USERSPACE=y

tests/subsys/logging/log_core/prj.conf

@@ -3,6 +3,7 @@ CONFIG_ZTEST=y
 CONFIG_TEST_USERSPACE=y
 CONFIG_TEST_LOGGING_DEFAULTS=n
 CONFIG_LOG=y
+CONFIG_LOG1=y
 CONFIG_LOG_MODE_DEFERRED=y
 CONFIG_LOG_PRINTK=n
 CONFIG_LOG_RUNTIME_FILTERING=y

tests/subsys/logging/log_core/testcase.yaml

@@ -3,4 +3,4 @@ tests:
     integration_platforms:
       - native_posix
     tags: log_core logging
-    filter: not CONFIG_LOG_IMMEDIATE
+    filter: not CONFIG_LOG_MODE_IMMEDIATE

tests/subsys/logging/log_core_additional/log2.conf

@@ -2,7 +2,6 @@ CONFIG_MAIN_THREAD_PRIORITY=5
 CONFIG_ZTEST=y
 CONFIG_TEST_LOGGING_DEFAULTS=n
 CONFIG_LOG=y
-CONFIG_LOG2_MODE_DEFERRED=y
 CONFIG_LOG_PRINTK=n
 CONFIG_LOG_SPEED=y
 CONFIG_LOG_BUFFER_SIZE=1024

tests/subsys/logging/log_core_additional/log_user.conf

@@ -3,6 +3,7 @@ CONFIG_ZTEST=y
 CONFIG_TEST_USERSPACE=y
 CONFIG_TEST_LOGGING_DEFAULTS=n
 CONFIG_LOG=y
+CONFIG_LOG1=y
 CONFIG_LOG_RUNTIME_FILTERING=y
 CONFIG_LOG_PROCESS_THREAD=n
 CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=1

tests/subsys/logging/log_core_additional/prj.conf

@@ -2,6 +2,7 @@ CONFIG_MAIN_THREAD_PRIORITY=5
 CONFIG_ZTEST=y
 CONFIG_TEST_LOGGING_DEFAULTS=n
 CONFIG_LOG=y
+CONFIG_LOG1=y
 CONFIG_LOG_RUNTIME_FILTERING=y
 CONFIG_LOG_BACKEND_UART=y
 CONFIG_LOG_PROCESS_TRIGGER_THRESHOLD=0

tests/subsys/logging/log_core_additional/src/log_test.c

@@ -66,6 +66,10 @@ static void process(const struct log_backend *const backend,
 	uint32_t flags;
 	struct backend_cb *cb = (struct backend_cb *)backend->cb->ctx;
 
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
+		cb->sync++;
+	}
+
 	if (cb->check_domain_id) {
 		zassert_equal(log_msg2_get_domain(&(msg->log)), CONFIG_LOG_DOMAIN_ID,
 				"Unexpected domain id");
@@ -158,10 +162,10 @@ static void sync_hexdump(const struct log_backend *const backend,
 
 const struct log_backend_api log_backend_test_api = {
 	.process = IS_ENABLED(CONFIG_LOG2) ? process : NULL,
-	.put = IS_ENABLED(CONFIG_LOG_MODE_DEFERRED) ? put : NULL,
+	.put = IS_ENABLED(CONFIG_LOG1_DEFERRED) ? put : NULL,
-	.put_sync_string = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ?
+	.put_sync_string = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_string : NULL,
-	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG_IMMEDIATE) ?
+	.put_sync_hexdump = IS_ENABLED(CONFIG_LOG1_IMMEDIATE) ?
 			sync_hexdump : NULL,
 };
 
@@ -245,7 +249,7 @@ void test_log_domain_id(void)
 /**
  * @brief Synchronous processing of logging messages.
  *
- * @details if CONFIG_LOG_IMMEDIATE is enabled, log message is
+ * @details if CONFIG_LOG_MODE_IMMEDIATE is enabled, log message is
  *          handled immediately
  *
  * @addtogroup logging
@@ -255,7 +259,7 @@ void test_log_sync(void)
 {
 	TC_PRINT("Logging synchronousely\n");
 
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		log_setup(false);
 		LOG_INF("Log immediately");
 		LOG_INF("Log immediately");
@@ -278,7 +282,7 @@ void test_log_sync(void)
 
 void test_log_early_logging(void)
 {
-	if (IS_ENABLED(CONFIG_LOG_IMMEDIATE)) {
+	if (IS_ENABLED(CONFIG_LOG_MODE_IMMEDIATE)) {
 		ztest_test_skip();
 	} else {
 		log_init();
@@ -505,7 +509,7 @@ void test_log_generic(void)
 void test_log_msg2_create(void)
 {
 	log_setup(false);
-	if (IS_ENABLED(CONFIG_LOG2)) {
+	if (!IS_ENABLED(CONFIG_LOG1) && IS_ENABLED(CONFIG_LOG_MODE_DEFERRED)) {
 		int mode;
 
 		domain = 3;

tests/subsys/logging/log_core_additional/testcase.yaml

@@ -5,13 +5,14 @@ common:
 tests:
   logging.add.async:
     tags: logging
+    extra_args: CONF_FILE=log2.conf
   logging.add.sync:
     tags: logging
     extra_args: CONF_FILE=log_sync.conf
-  logging.add.user:
+  logging.add.log1_user:
     tags: logging
     filter: CONFIG_USERSPACE
     extra_args: CONF_FILE=log_user.conf USERSPACE_TEST=1
-  logging.add.log2:
+  logging.add.log1:
     tags: logging
-    extra_args: CONF_FILE=log2.conf
+    extra_args: CONF_FILE=prj.conf

tests/subsys/logging/log_msg/prj.conf

@@ -4,3 +4,4 @@ CONFIG_TEST_LOGGING_DEFAULTS=n
 CONFIG_LOG=y
 CONFIG_LOG_PRINTK=n
 CONFIG_LOG_MODE_DEFERRED=y
+CONFIG_LOG1=y

tests/subsys/logging/log_msg2/prj.conf

@@ -2,7 +2,7 @@ CONFIG_MAIN_THREAD_PRIORITY=5
 CONFIG_ZTEST=y
 CONFIG_TEST_LOGGING_DEFAULTS=n
 CONFIG_LOG=y
-CONFIG_LOG2_MODE_DEFERRED=y
+CONFIG_LOG_MODE_DEFERRED=y
 CONFIG_LOG_PRINTK=n
 CONFIG_LOG_SPEED=y
 CONFIG_LOG_BUFFER_SIZE=1024