diff --git a/include/zephyr/debug/gcov.h b/include/zephyr/debug/gcov.h
index 4fc334ac1f331..175aa5cce045d 100644
--- a/include/zephyr/debug/gcov.h
+++ b/include/zephyr/debug/gcov.h
@@ -9,6 +9,7 @@
 
 #ifdef CONFIG_COVERAGE_GCOV
 void gcov_coverage_dump(void);
+void gcov_coverage_semihost(void);
 void gcov_static_init(void);
 #else
 static inline void gcov_coverage_dump(void) { }
diff --git a/kernel/Kconfig b/kernel/Kconfig
index bb2c5bade905b..447f124330725 100644
--- a/kernel/Kconfig
+++ b/kernel/Kconfig
@@ -246,7 +246,7 @@ if DYNAMIC_THREAD
 
 config DYNAMIC_THREAD_STACK_SIZE
 	int "Size of each pre-allocated thread stack"
-	default 4096 if X86
+	default 4096 if X86 || COVERAGE_GCOV
 	default 1024 if !X86 && !64BIT
 	default 2048 if !X86 && 64BIT
 	help
diff --git a/kernel/init.c b/kernel/init.c
index a758c16ee0e9a..190114b0d601f 100644
--- a/kernel/init.c
+++ b/kernel/init.c
@@ -353,6 +353,8 @@ static void bg_thread_main(void *unused1, void *unused2, void *unused3)
 #ifdef CONFIG_COVERAGE_DUMP
 	/* Dump coverage data once the main() has exited. */
 	gcov_coverage_dump();
+#elif defined(CONFIG_COVERAGE_SEMIHOST)
+	gcov_coverage_semihost();
 #endif /* CONFIG_COVERAGE_DUMP */
 } /* LCOV_EXCL_LINE ... because we just dumped final coverage data */
 
diff --git a/lib/os/reboot.c b/lib/os/reboot.c
index 1472ff1e02a84..0a483895dafe3 100644
--- a/lib/os/reboot.c
+++ b/lib/os/reboot.c
@@ -17,6 +17,8 @@ FUNC_NORETURN void sys_reboot(int type)
 {
 #ifdef CONFIG_COVERAGE_DUMP
 	gcov_coverage_dump();
+#elif defined(CONFIG_COVERAGE_SEMIHOST)
+	gcov_coverage_semihost();
 #endif /* CONFIG_COVERAGE_DUMP */
 
 	(void)irq_lock();
diff --git a/subsys/testsuite/Kconfig b/subsys/testsuite/Kconfig
index 6fb7d695fc283..a2486eb042ca1 100644
--- a/subsys/testsuite/Kconfig
+++ b/subsys/testsuite/Kconfig
@@ -24,97 +24,6 @@ config TEST_EXTRA_STACK_SIZE
 	  Additional stack for tests on some platform where default is not
 	  enough.
 
-config HAS_COVERAGE_SUPPORT
-	bool
-	help
-	  The code coverage report generation is only available on boards
-	  with enough spare RAM to buffer the coverage data, or on boards
-	  based on the POSIX ARCH.
-
-config COVERAGE
-	bool "Create coverage data"
-	depends on HAS_COVERAGE_SUPPORT
-	help
-	  This option will build your application with the -coverage option
-	  which will generate data that can be used to create coverage reports.
-	  For more information see
-	  https://docs.zephyrproject.org/latest/guides/coverage.html
-
-choice
-	prompt "Coverage mode"
-	default COVERAGE_NATIVE_GCOV if NATIVE_BUILD
-	default COVERAGE_GCOV if !NATIVE_BUILD
-	depends on COVERAGE
-
-config COVERAGE_NATIVE_GCOV
-	bool "Host compiler gcov based code coverage"
-	depends on NATIVE_BUILD
-	help
-	  Build natively with the compiler standard `--coverage` options,
-	  that is with gcov/GCC-compatible coverage
-
-config COVERAGE_NATIVE_SOURCE
-	bool "Host compiler source based code coverage"
-	depends on NATIVE_BUILD
-	depends on "$(ZEPHYR_TOOLCHAIN_VARIANT)" = "llvm"
-	help
-	  Build natively with the compiler source based coverage options.
-	  Today this is only supported with LLVM
-
-config COVERAGE_GCOV
-	bool "Create Coverage data from hardware platform"
-	depends on !NATIVE_BUILD
-	help
-	  This option will select the custom gcov library. The reports will
-	  be available over serial. This serial dump can be passed to
-	  gen_gcov_files.py which creates the required .gcda files. These
-	  can be read by gcov utility. For more details see gcovr.com .
-
-endchoice
-
-if COVERAGE_GCOV
-
-config COVERAGE_GCOV_HEAP_SIZE
-	int "Size of heap allocated for gcov coverage data dump"
-	depends on COVERAGE_GCOV
-	default 32768 if X86 || SOC_SERIES_MPS2
-	default 16384
-	help
-	  This option configures the heap size allocated for gcov coverage
-	  data to be dumped over serial. If the value is 0, no buffer will be used,
-	  data will be dumped directly over serial.
-
-choice COVERAGE_DUMP_METHOD
-	prompt "Method to dump coverage data"
-	default COVERAGE_DUMP
-
-config COVERAGE_DUMP
-	bool "Dump coverage data to console on exit"
-	help
-	  Dump collected coverage information to console on exit.
-
-endchoice
-
-config COVERAGE_DUMP_PATH_EXCLUDE
-	string "Exclude files matching this pattern from the coverage data"
-	default ""
-	help
-	  Filenames are matched against the pattern using the POSIX fnmatch
-	  function. Filenames are based on their path in the build folder, not the
-	  original source tree. The empty string "" disables the pattern
-	  matching.
-
-endif # COVERAGE_GCOV
-
-config FORCE_COVERAGE
-	bool "Force coverage"
-	select HAS_COVERAGE_SUPPORT
-	help
-	  Regardless of platform support, it will enable coverage data production.
-	  If the platform does not support coverage by default, setting this config
-	  does not guarantee that coverage data will be gathered.
-	  Application may not fit memory or crash at runtime.
-
 config TEST_USERSPACE
 	bool "Indicate that this test exercises user mode"
 	help
@@ -217,3 +126,6 @@ config TEST_BUSY_SIM
 	  with random intervals and random busy looping in the interrupt.
 
 endmenu
+
+
+rsource "Kconfig.coverage"
diff --git a/subsys/testsuite/Kconfig.coverage b/subsys/testsuite/Kconfig.coverage
new file mode 100644
index 0000000000000..ccbad9275d7bb
--- /dev/null
+++ b/subsys/testsuite/Kconfig.coverage
@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright The Zephyr Project Contributors
+#
+menu "Coverage"
+
+config HAS_COVERAGE_SUPPORT
+	bool
+	help
+	  The code coverage report generation is only available on boards
+	  with enough spare RAM to buffer the coverage data, or on boards
+	  based on the POSIX ARCH.
+
+config COVERAGE
+	bool "Create coverage data"
+	depends on HAS_COVERAGE_SUPPORT
+	help
+	  This option will build your application with the -coverage option
+	  which will generate data that can be used to create coverage reports.
+	  For more information see
+	  https://docs.zephyrproject.org/latest/guides/coverage.html
+
+choice
+	prompt "Coverage mode"
+	default COVERAGE_NATIVE_GCOV if NATIVE_BUILD
+	default COVERAGE_GCOV if !NATIVE_BUILD
+	depends on COVERAGE
+
+config COVERAGE_NATIVE_GCOV
+	bool "Host compiler gcov based code coverage"
+	depends on NATIVE_BUILD
+	help
+	  Build natively with the compiler standard `--coverage` options,
+	  that is with gcov/GCC-compatible coverage
+
+config COVERAGE_NATIVE_SOURCE
+	bool "Host compiler source based code coverage"
+	depends on NATIVE_BUILD
+	depends on "$(ZEPHYR_TOOLCHAIN_VARIANT)" = "llvm"
+	help
+	  Build natively with the compiler source based coverage options.
+	  Today this is only supported with LLVM
+
+config COVERAGE_GCOV
+	bool "Create Coverage data from hardware platform"
+	depends on !NATIVE_BUILD
+	help
+	  This option will select the custom gcov library. The reports will
+	  be available over serial. This serial dump can be passed to
+	  gen_gcov_files.py which creates the required .gcda files. These
+	  can be read by gcov utility. For more details see gcovr.com .
+
+endchoice
+
+config COVERAGE_GCOV_HEAP_SIZE
+	int "Size of heap allocated for gcov coverage data dump"
+	depends on COVERAGE_GCOV
+	default 32768 if X86 || SOC_SERIES_MPS2
+	default 16384
+	help
+	  This option configures the heap size allocated for gcov coverage
+	  data to be dumped over serial. If the value is 0, no buffer will be used,
+	  data will be dumped directly over serial.
+
+choice COVERAGE_DUMP_METHOD
+	prompt "Method to dump coverage data"
+	default COVERAGE_DUMP
+
+config COVERAGE_DUMP
+	bool "Dump coverage data to console on exit"
+	help
+	  Dump collected coverage information to console on exit.
+
+config COVERAGE_SEMIHOST
+	bool "Use semihosting to write coverage data"
+	depends on SEMIHOST
+	help
+	  Use semihosting to write coverage data to a file on the host.
+
+endchoice
+
+config FORCE_COVERAGE
+	bool "Force coverage"
+	select HAS_COVERAGE_SUPPORT
+	help
+	  Regardless of platform support, it will enable coverage data production.
+	  If the platform does not support coverage by default, setting this config
+	  does not guarantee that coverage data will be gathered.
+	  Application may not fit memory or crash at runtime.
+
+config COVERAGE_DUMP_PATH_EXCLUDE
+	string "Exclude files matching this pattern from the coverage data"
+	default ""
+	help
+	  Filenames are matched against the pattern using the POSIX fnmatch
+	  function. Filenames are based on their path in the build folder, not the
+	  original source tree. The empty string "" disables the pattern
+	  matching.
+
+endmenu
diff --git a/subsys/testsuite/coverage/coverage.c b/subsys/testsuite/coverage/coverage.c
index 832606a922410..f189a720e8e95 100644
--- a/subsys/testsuite/coverage/coverage.c
+++ b/subsys/testsuite/coverage/coverage.c
@@ -11,6 +11,8 @@
 #include <string.h>
 #include <fnmatch.h>
 #include "coverage.h"
+#include <zephyr/arch/common/semihost.h>
+#include <sys/types.h>
 
 K_HEAP_DEFINE(gcov_heap, CONFIG_COVERAGE_GCOV_HEAP_SIZE);
 
@@ -280,6 +282,7 @@ void gcov_reset_all_counts(void)
 #endif
 }
 
+#ifdef CONFIG_COVERAGE_DUMP
 void dump_on_console_start(const char *filename)
 {
 	printk("\n%c", FILE_START_INDICATOR);
@@ -298,6 +301,7 @@ void dump_on_console_data(char *ptr, size_t len)
 	}
 }
 
+
 /**
  * Retrieves gcov coverage data and sends it over the given interface.
  */
@@ -309,11 +313,11 @@ void gcov_coverage_dump(void)
 	struct gcov_info *gcov_list_first = gcov_info_head;
 	struct gcov_info *gcov_list = gcov_info_head;
 
-	if (!k_is_in_isr()) {
 #ifdef CONFIG_MULTITHREADING
+	if (!k_is_in_isr()) {
 		k_sched_lock();
-#endif
 	}
+#endif
 	printk("\nGCOV_COVERAGE_DUMP_START");
 	while (gcov_list) {
 		if ((strlen(CONFIG_COVERAGE_DUMP_PATH_EXCLUDE) > 0) &&
@@ -327,13 +331,15 @@ void gcov_coverage_dump(void)
 
 		buffer = k_heap_alloc(&gcov_heap, size, K_NO_WAIT);
 		if (CONFIG_COVERAGE_GCOV_HEAP_SIZE > 0 && !buffer) {
-			printk("No Mem available to continue dump\n");
+			printk("No memory available to continue dump\n");
+			k_heap_free(&gcov_heap, buffer);
 			goto coverage_dump_end;
 		}
 
 		written_size = gcov_populate_buffer(buffer, gcov_list);
 		if (written_size != size) {
-			printk("Write Error on buff\n");
+			printk("Write Error on buffer\n");
+			k_heap_free(&gcov_heap, buffer);
 			goto coverage_dump_end;
 		}
 
@@ -348,14 +354,83 @@ void gcov_coverage_dump(void)
 	}
 coverage_dump_end:
 	printk("\nGCOV_COVERAGE_DUMP_END\n");
-	if (!k_is_in_isr()) {
 #ifdef CONFIG_MULTITHREADING
+	if (!k_is_in_isr()) {
 		k_sched_unlock();
-#endif
 	}
+#endif
 	return;
 }
 
+#elif CONFIG_COVERAGE_SEMIHOST
+/**
+ * Retrieves gcov coverage data and sends it over the given interface.
+ */
+void gcov_coverage_semihost(void)
+{
+	uint8_t *buffer;
+	size_t size;
+	size_t written_size;
+	struct gcov_info *gcov_list_first = gcov_info_head;
+	struct gcov_info *gcov_list = gcov_info_head;
+
+#ifdef CONFIG_MULTITHREADING
+	if (!k_is_in_isr()) {
+		k_sched_lock();
+	}
+#endif
+	while (gcov_list) {
+
+		int fd = semihost_open(gcov_list->filename, SEMIHOST_OPEN_WB);
+
+		if (fd < 0) {
+			printk("Failed to open file: %s\n", gcov_list->filename);
+			goto coverage_dump_end;
+		}
+
+		size = gcov_calculate_buff_size(gcov_list);
+
+		buffer = k_heap_alloc(&gcov_heap, size, K_NO_WAIT);
+		if (CONFIG_COVERAGE_GCOV_HEAP_SIZE > 0 && !buffer) {
+			printk("No memory available to continue dump\n");
+			semihost_close(fd);
+			k_heap_free(&gcov_heap, buffer);
+			goto coverage_dump_end;
+		}
+
+		written_size = gcov_populate_buffer(buffer, gcov_list);
+		if (written_size != size) {
+			printk("Write Error on buffer\n");
+			semihost_close(fd);
+			k_heap_free(&gcov_heap, buffer);
+			goto coverage_dump_end;
+		}
+
+		int ret = semihost_write(fd, (const void *)buffer, size);
+
+		if (ret < 0) {
+			printk("Failed to write data to file: %s\n", gcov_list->filename);
+			semihost_close(fd);
+			k_heap_free(&gcov_heap, buffer);
+			goto coverage_dump_end;
+		}
+
+		k_heap_free(&gcov_heap, buffer);
+		gcov_list = gcov_list->next;
+		if (gcov_list_first == gcov_list) {
+			semihost_close(fd);
+			goto coverage_dump_end;
+		}
+	}
+coverage_dump_end:
+#ifdef CONFIG_MULTITHREADING
+	if (!k_is_in_isr()) {
+		k_sched_unlock();
+	}
+#endif
+}
+#endif
+
 struct gcov_info *gcov_get_list_head(void)
 {
 	/* Locking someway before getting this is recommended. */
diff --git a/tests/arch/arm/arm_interrupt/src/arm_interrupt.c b/tests/arch/arm/arm_interrupt/src/arm_interrupt.c
index 05535283be332..560305216af34 100644
--- a/tests/arch/arm/arm_interrupt/src/arm_interrupt.c
+++ b/tests/arch/arm/arm_interrupt/src/arm_interrupt.c
@@ -16,7 +16,7 @@ static volatile int expected_reason = -1;
 static volatile int run_esf_validation;
 static volatile int esf_validation_rv;
 static volatile uint32_t expected_msp;
-static K_THREAD_STACK_DEFINE(esf_collection_stack, 2048);
+static K_THREAD_STACK_DEFINE(esf_collection_stack, 2048 + CONFIG_TEST_EXTRA_STACK_SIZE);
 static struct k_thread esf_collection_thread;
 #define MAIN_PRIORITY 7
 #define PRIORITY      5
diff --git a/tests/arch/arm/arm_thread_swap/src/arm_syscalls.c b/tests/arch/arm/arm_thread_swap/src/arm_syscalls.c
index 4d55241bed77c..c686b3f9d633b 100644
--- a/tests/arch/arm/arm_thread_swap/src/arm_syscalls.c
+++ b/tests/arch/arm/arm_thread_swap/src/arm_syscalls.c
@@ -22,7 +22,7 @@
 #define DB_VAL   0xDEADBEEF
 
 static struct k_thread user_thread;
-static K_THREAD_STACK_DEFINE(user_thread_stack, 1024);
+static K_THREAD_STACK_DEFINE(user_thread_stack, 1024 + CONFIG_TEST_EXTRA_STACK_SIZE);
 
 #include <zephyr/internal/syscall_handler.h>
 #include "test_syscalls.h"
diff --git a/tests/arch/arm/arm_thread_swap/src/arm_thread_arch.c b/tests/arch/arm/arm_thread_swap/src/arm_thread_arch.c
index f37e795fc46cf..7aae3db470f10 100644
--- a/tests/arch/arm/arm_thread_swap/src/arm_thread_arch.c
+++ b/tests/arch/arm/arm_thread_swap/src/arm_thread_arch.c
@@ -39,7 +39,7 @@
 extern void z_move_thread_to_end_of_prio_q(struct k_thread *thread);
 
 static struct k_thread alt_thread;
-static K_THREAD_STACK_DEFINE(alt_thread_stack, 1024);
+static K_THREAD_STACK_DEFINE(alt_thread_stack, 1024 + CONFIG_TEST_EXTRA_STACK_SIZE);
 
 /* Status variable to indicate that context-switch has occurred. */
 bool volatile switch_flag;
diff --git a/tests/arch/common/interrupt/src/interrupt_offload.c b/tests/arch/common/interrupt/src/interrupt_offload.c
index 488e0397495a2..f26c20f84c904 100644
--- a/tests/arch/common/interrupt/src/interrupt_offload.c
+++ b/tests/arch/common/interrupt/src/interrupt_offload.c
@@ -11,7 +11,7 @@
 #include <soc.h>
 #endif
 
-#define STACK_SIZE	1024
+#define STACK_SIZE	1024 + CONFIG_TEST_EXTRA_STACK_SIZE
 #define NUM_WORK	4
 
 static struct k_work offload_work[NUM_WORK];
diff --git a/tests/kernel/context/prj.conf b/tests/kernel/context/prj.conf
index b138c1a230f26..dc48ba72008cb 100644
--- a/tests/kernel/context/prj.conf
+++ b/tests/kernel/context/prj.conf
@@ -1,6 +1,3 @@
 CONFIG_IRQ_OFFLOAD=y
 CONFIG_ZTEST=y
-#CONFIG_MAIN_STACK_SIZE=1024
-#CONFIG_ZTEST_STACK_SIZE=2048
-#CONFIG_IDLE_STACK_SIZE=512
 CONFIG_MP_MAX_NUM_CPUS=1
diff --git a/tests/kernel/context/src/main.c b/tests/kernel/context/src/main.c
index cf214d4f91ab5..a0e462efd6f24 100644
--- a/tests/kernel/context/src/main.c
+++ b/tests/kernel/context/src/main.c
@@ -32,8 +32,8 @@
 #include <soc.h>
 #endif
 
-#define THREAD_STACKSIZE    (512 + CONFIG_TEST_EXTRA_STACK_SIZE)
-#define THREAD_STACKSIZE2   (384 + CONFIG_TEST_EXTRA_STACK_SIZE)
+#define THREAD_STACKSIZE    (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)
+#define THREAD_STACKSIZE2   (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)
 #define THREAD_PRIORITY     4
 
 #define THREAD_SELF_CMD    0
diff --git a/tests/kernel/mem_protect/stackprot/prj.conf b/tests/kernel/mem_protect/stackprot/prj.conf
index 63875657b1b4c..4b757eff73070 100644
--- a/tests/kernel/mem_protect/stackprot/prj.conf
+++ b/tests/kernel/mem_protect/stackprot/prj.conf
@@ -3,4 +3,4 @@ CONFIG_STACK_CANARIES=y
 CONFIG_ENTROPY_GENERATOR=y
 CONFIG_TEST_RANDOM_GENERATOR=y
 CONFIG_TEST_USERSPACE=y
-CONFIG_MAIN_STACK_SIZE=2048
+CONFIG_MAIN_STACK_SIZE=4096
diff --git a/tests/kernel/pipe/pipe_api/src/concurrency.c b/tests/kernel/pipe/pipe_api/src/concurrency.c
index 601a4bdd5d75b..f147e2ede2679 100644
--- a/tests/kernel/pipe/pipe_api/src/concurrency.c
+++ b/tests/kernel/pipe/pipe_api/src/concurrency.c
@@ -15,7 +15,7 @@ ZTEST_SUITE(k_pipe_concurrency, NULL, NULL, NULL, NULL, NULL);
 static const int partial_wait_time = 2000;
 #define DUMMY_DATA_SIZE 16
 static struct k_thread thread;
-static K_THREAD_STACK_DEFINE(stack, 1024);
+static K_THREAD_STACK_DEFINE(stack, 1024 + CONFIG_TEST_EXTRA_STACK_SIZE);
 static struct k_pipe pipe;
 
 static void thread_close(void *arg1, void *arg2, void *arg3)
diff --git a/tests/kernel/sched/metairq/src/main.c b/tests/kernel/sched/metairq/src/main.c
index 5afd3e0779490..df004c636e960 100644
--- a/tests/kernel/sched/metairq/src/main.c
+++ b/tests/kernel/sched/metairq/src/main.c
@@ -30,7 +30,7 @@
 #endif
 
 
-#define STACKSIZE 1024
+#define STACKSIZE 1024 + CONFIG_TEST_EXTRA_STACK_SIZE
 #define DEFINE_PARTICIPANT_THREAD(id)                                       \
 		K_THREAD_STACK_DEFINE(thread_##id##_stack_area, STACKSIZE); \
 		struct k_thread thread_##id##_thread_data;                  \
diff --git a/tests/kernel/smp_abort/src/main.c b/tests/kernel/smp_abort/src/main.c
index e0eb2c78819d0..67b8003ac6eeb 100644
--- a/tests/kernel/smp_abort/src/main.c
+++ b/tests/kernel/smp_abort/src/main.c
@@ -14,7 +14,7 @@
 #endif
 
 #define NUM_THREADS CONFIG_MP_MAX_NUM_CPUS
-#define STACK_SIZE 1024
+#define STACK_SIZE 1024 + CONFIG_TEST_EXTRA_STACK_SIZE
 
 K_THREAD_STACK_ARRAY_DEFINE(thread_stack, NUM_THREADS, STACK_SIZE);
 struct k_thread thread[NUM_THREADS];
diff --git a/tests/kernel/smp_suspend/src/main.c b/tests/kernel/smp_suspend/src/main.c
index 013fcd9d5a01e..54ae3b12099fe 100644
--- a/tests/kernel/smp_suspend/src/main.c
+++ b/tests/kernel/smp_suspend/src/main.c
@@ -12,7 +12,7 @@
 #error "SMP test requires at least two CPUs!"
 #endif
 
-#define STACK_SIZE 1024
+#define STACK_SIZE 1024 + CONFIG_TEST_EXTRA_STACK_SIZE
 
 #define NUM_THREADS 6
 
diff --git a/tests/kernel/threads/dynamic_thread_stack/prj.conf b/tests/kernel/threads/dynamic_thread_stack/prj.conf
index b9c4f491ee7c2..92a5f6a29eb7c 100644
--- a/tests/kernel/threads/dynamic_thread_stack/prj.conf
+++ b/tests/kernel/threads/dynamic_thread_stack/prj.conf
@@ -5,8 +5,8 @@ CONFIG_MAX_THREAD_BYTES=6
 CONFIG_DYNAMIC_THREAD=y
 CONFIG_DYNAMIC_THREAD_POOL_SIZE=2
 CONFIG_DYNAMIC_THREAD_ALLOC=y
-CONFIG_ZTEST_STACK_SIZE=2048
-CONFIG_MAIN_STACK_SIZE=2048
+CONFIG_ZTEST_STACK_SIZE=4096
+CONFIG_MAIN_STACK_SIZE=4096
 
 CONFIG_HW_STACK_PROTECTION=n
 CONFIG_TEST_HW_STACK_PROTECTION=n
diff --git a/tests/kernel/threads/tls/src/main.c b/tests/kernel/threads/tls/src/main.c
index da2486ea1a8e9..ad01745c2bb7a 100644
--- a/tests/kernel/threads/tls/src/main.c
+++ b/tests/kernel/threads/tls/src/main.c
@@ -12,7 +12,7 @@
 #include <zephyr/sys/util.h>
 
 #define NUM_THREADS	3
-#define STACK_SIZE	(512 + CONFIG_TEST_EXTRA_STACK_SIZE)
+#define STACK_SIZE	(2048 + CONFIG_TEST_EXTRA_STACK_SIZE)
 
 #define STATIC_DATA8	0x7FU
 #define STATIC_DATA32	0xABCDEF00U
diff --git a/tests/kernel/workq/work_queue/src/main.c b/tests/kernel/workq/work_queue/src/main.c
index f97f202bcee9f..7c4b25d0a4eba 100644
--- a/tests/kernel/workq/work_queue/src/main.c
+++ b/tests/kernel/workq/work_queue/src/main.c
@@ -63,8 +63,8 @@ static int results[NUM_TEST_ITEMS];
 static int num_results;
 static int expected_poll_result;
 
-#define MSG_PROVIDER_THREAD_STACK_SIZE 0x400U
-#define MSG_CONSUMER_WORKQ_STACK_SIZE 0x400U
+#define MSG_PROVIDER_THREAD_STACK_SIZE 2048
+#define MSG_CONSUMER_WORKQ_STACK_SIZE 2048
 
 #define MSG_PROVIDER_THREAD_PRIO K_PRIO_PREEMPT(8)
 #define MSG_CONSUMER_WORKQ_PRIO K_PRIO_COOP(7)
diff --git a/tests/lib/net_buf/buf/src/main.c b/tests/lib/net_buf/buf/src/main.c
index 0d9f679408704..fcb91da73c70a 100644
--- a/tests/lib/net_buf/buf/src/main.c
+++ b/tests/lib/net_buf/buf/src/main.c
@@ -206,7 +206,7 @@ static void test_3_thread(void *arg1, void *arg2, void *arg3)
 	k_sem_give(sema);
 }
 
-static K_THREAD_STACK_DEFINE(test_3_thread_stack, 1024);
+static K_THREAD_STACK_DEFINE(test_3_thread_stack, 1024 + CONFIG_TEST_EXTRA_STACK_SIZE);
 
 ZTEST(net_buf_tests, test_net_buf_3)
 {
diff --git a/tests/net/socket/net_mgmt/src/main.c b/tests/net/socket/net_mgmt/src/main.c
index 22ccf6419ddb9..9bd094742952f 100644
--- a/tests/net/socket/net_mgmt/src/main.c
+++ b/tests/net/socket/net_mgmt/src/main.c
@@ -17,7 +17,7 @@ LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
 #include <zephyr/net/ethernet_mgmt.h>
 
 #define MAX_BUF_LEN 64
-#define STACK_SIZE 1024
+#define STACK_SIZE 1024 + CONFIG_TEST_EXTRA_STACK_SIZE
 #define THREAD_PRIORITY K_PRIO_COOP(8)
 
 /* Use a base value for socket options that are not implemented.