tests: bluetooth: mesh: bsim test to check memory leak after suspending

Commit adds mesh bsim test to check adv pool memory leakage
after mesh has been suspended.

Signed-off-by: Aleksandr Khromykh <[email protected]>

Author: alxelax

tests/bsim/bluetooth/mesh/src/test_advertiser.c

@@ -19,6 +19,12 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, LOG_LEVEL_INF);
 
 #define WAIT_TIME 60 /*seconds*/
 
+enum suspending_ctx {
+	NOT_SUSPENDED,
+	SUSPENDED_IN_CTX,
+	SUSPENDED_IN_CB
+};
+
 extern const struct bt_mesh_comp comp;
 
 static uint8_t test_prov_uuid[16] = { 0x6c, 0x69, 0x6e, 0x67, 0x61, 0xaa };
@@ -796,7 +802,7 @@ static void adv_resume(void)
 }
 
 struct adv_suspend_ctx {
-	bool suspend;
+	enum suspending_ctx suspend;
 	int instance_idx;
 };
 
@@ -812,7 +818,7 @@ static void adv_send_end(int err, void *cb_data)
 
 	ASSERT_EQUAL(err, 0);
 
-	if (adv_data->suspend) {
+	if (adv_data->suspend != NOT_SUSPENDED) {
 		/* When suspending, the end callback will be called only for the first adv, because
 		 * it was already scheduled.
 		 */
@@ -831,8 +837,8 @@ static void adv_send_start(uint16_t duration, int err, void *cb_data)
 	LOG_DBG("start(): err (%d), suspend (%d), i (%d)", err, adv_data->suspend,
 		adv_data->instance_idx);
 
-	if (adv_data->suspend) {
-		if (adv_data->instance_idx == 0) {
+	if (adv_data->suspend != NOT_SUSPENDED) {
+		if (adv_data->instance_idx == 0 && adv_data->suspend == SUSPENDED_IN_CB) {
 			ASSERT_EQUAL(err, 0);
 			adv_suspend();
 		} else {
@@ -851,7 +857,8 @@ static void adv_send_start(uint16_t duration, int err, void *cb_data)
 	}
 }
 
-static void adv_create_and_send(bool suspend, uint8_t first_byte, struct adv_suspend_ctx *adv_data)
+static void adv_create_and_send(enum suspending_ctx suspend, uint8_t first_byte,
+				struct adv_suspend_ctx *adv_data)
 {
 	struct bt_mesh_adv *advs[CONFIG_BT_MESH_ADV_BUF_COUNT];
 	static const struct bt_mesh_send_cb send_cb = {
@@ -864,7 +871,7 @@ static void adv_create_and_send(bool suspend, uint8_t first_byte, struct adv_sus
 		adv_data[i].instance_idx = i;
 
 		advs[i] = bt_mesh_adv_create(BT_MESH_ADV_DATA, BT_MESH_ADV_TAG_LOCAL,
-					    BT_MESH_TRANSMIT(2, 20), K_NO_WAIT);
+					     BT_MESH_TRANSMIT(2, 20), K_NO_WAIT);
 		ASSERT_FALSE_MSG(!advs[i], "Out of advs\n");
 
 		net_buf_simple_add_u8(&advs[i]->b, first_byte);
@@ -877,29 +884,41 @@ static void adv_create_and_send(bool suspend, uint8_t first_byte, struct adv_sus
 	}
 }
 
-static void test_tx_disable(void)
+static void check_suspending(void)
 {
-	struct adv_suspend_ctx adv_data[CONFIG_BT_MESH_ADV_BUF_COUNT];
 	struct bt_mesh_adv *extra_adv;
 	int err;
 
-	bt_init();
-	adv_init();
-
-	/* Fill up the adv pool and suspend the advertiser in the first start callback call. */
-	adv_create_and_send(true, 0xAA, adv_data);
-
 	err = k_sem_take(&adv_suspended_sem, K_SECONDS(10));
 	ASSERT_OK_MSG(err, "Not all advs were sent");
 
 	extra_adv = bt_mesh_adv_create(BT_MESH_ADV_DATA, BT_MESH_ADV_TAG_LOCAL,
 				       BT_MESH_TRANSMIT(2, 20), K_NO_WAIT);
 	ASSERT_TRUE_MSG(!extra_adv, "Created adv while suspended");
+}
+
+static void test_tx_disable(void)
+{
+	struct adv_suspend_ctx adv_data[CONFIG_BT_MESH_ADV_BUF_COUNT];
+	int err;
+
+	bt_init();
+	adv_init();
+
+	LOG_INF("Fill up the adv pool and suspend the advertiser right after in the same context.");
+	adv_create_and_send(SUSPENDED_IN_CTX, 0xAA, adv_data);
+	adv_suspend();
+	check_suspending();
+	adv_resume();
 
+	LOG_INF("Fill up the adv pool and suspend the advertiser in the first start callback "
+		"call.");
+	adv_create_and_send(SUSPENDED_IN_CB, 0xAA, adv_data);
+	check_suspending();
 	adv_resume();
 
-	/* Fill up the adv pool and suspend the advertiser and let it send all advs. */
-	adv_create_and_send(false, 0xBB, adv_data);
+	LOG_INF("Fill up the adv pool and suspend the advertiser and let it send all advs");
+	adv_create_and_send(NOT_SUSPENDED, 0xBB, adv_data);
 
 	err = k_sem_take(&adv_sent_sem, K_SECONDS(10));
 	ASSERT_OK_MSG(err, "Not all advs were sent");

tests/bsim/bluetooth/mesh/src/test_suspend.c

@@ -464,6 +464,34 @@ static void test_tester_gatt(void)
 	PASS();
 }
 
+static void test_dut_suspend_resume_unref(void)
+{
+	const struct bt_mesh_test_cfg tx_cfg = {
+		.addr = 0x0001,
+		.dev_key = {0x01},
+	};
+
+	bt_mesh_test_cfg_set(&tx_cfg, 2 * WAIT_TIME);
+	bt_mesh_test_setup();
+
+	for (uint16_t count = 0; count < 2 * CONFIG_BT_MESH_ADV_BUF_COUNT; count++) {
+		LOG_DBG("Step %d", count);
+
+		ASSERT_OK_MSG(bt_mesh_test_send_data(BT_MESH_ADDR_ALL_NODES, NULL,
+						     (uint8_t *)&count, sizeof(count), NULL, NULL),
+			      "Cannot send data");
+		ASSERT_OK_MSG(bt_mesh_test_send_data(BT_MESH_ADDR_ALL_NODES, NULL,
+						     (uint8_t *)&count, sizeof(count), NULL, NULL),
+			      "Cannot send data");
+
+		ASSERT_OK_MSG(bt_mesh_suspend(), "Failed to suspend Mesh.");
+		k_sleep(K_MSEC(500));
+		ASSERT_OK_MSG(bt_mesh_resume(), "Failed to resume Mesh.");
+	}
+
+	PASS();
+}
+
 #define TEST_CASE(role, name, description)                                                         \
 	{                                                                                          \
 		.test_id = "suspend_" #role "_" #name, .test_descr = description,                  \
@@ -479,6 +507,8 @@ static const struct bst_test_instance test_suspend[] = {
 			 "Suspend and resume Mesh with GATT proxy advs"),
 	TEST_CASE(dut, gatt_suspend_disable_resume,
 			 "Suspend and resume Mesh (and disable/enable BT) with GATT proxy advs"),
+	TEST_CASE(dut, suspend_resume_unref,
+			 "Suspend and resume Mesh twice adv more than advertiser pool size times"),
 
 	TEST_CASE(tester, pub, "Scan and verify behavior of periodic publishing adv"),
 	TEST_CASE(tester, gatt, "Scan and verify behavior of GATT proxy adv"),

tests/bsim/bluetooth/mesh/tests_scripts/advertiser/disable.sh

@@ -17,15 +17,18 @@ source $(dirname "${BASH_SOURCE[0]}")/../../_mesh_test.sh
 # 1. Tx device creates `CONFIG_BT_MESH_ADV_BUF_COUNT` advertisements, setting the first byte of the
 # PDU to 0xAA and the second byte of the PDU to the advertisement order number
 # 2. Tx devices pushes all created advs to the pool by calling `bt_mesh_adv_send` function
-# 3. When the `bt_mesh_send_cb.start` callback is called for the first adv, the tx device submits
-#    a work item which suspends the advertiser by calling `bt_mesh_adv_disable`.
+# 3. After calling sending function Tx device immediately suspends the advertiser.
 # 4. Tx device checks that for the first adv the `bt_mesh_send_cb.end` callback is called with the
 #    error code `0`.
 # 5. Tx device checks that for the consecutive advs the `bt_mesh_send_cb.start` is called with error
 #    `-ENODEV`.
 # 6. Tx device checks that no more advs can be created using `bt_mesh_adv_create` function.
 # 7. Tx device resumes the advertiser and repeats steps 1 and 2.
-# 8. Tx device expects that all advs are sent.
+# 8. When the `bt_mesh_send_cb.start` callback is called for the first adv, the tx device submits
+#    a work item which suspends the advertiser by calling `bt_mesh_adv_disable`.
+# 9. Tx device repeats steps 4-6.
+# 10. Tx device resumes the advertiser and repeats steps 1 and 2.
+# 11. Tx device expects that all advs are sent.
 #
 # Rx device procedure:
 # 1. Rx devices listens all the time while tx device sends advs and ensure that no new advs were
@@ -35,7 +38,7 @@ RunTest mesh_adv_disable adv_tx_disable adv_rx_disable
 
 # Low latency overlay uses legacy advertiser
 overlay=overlay_low_lat_conf
-RunTest mesh_adv_disable adv_tx_disable adv_rx_disable
+RunTest mesh_adv_disable_low_lat adv_tx_disable adv_rx_disable
 
 overlay=overlay_workq_sys_conf
 RunTest mesh_adv_disable_workq adv_tx_disable adv_rx_disable

tests/bsim/bluetooth/mesh/tests_scripts/suspend/suspend_resume_unref.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Copyright 2025 Nordic Semiconductor
+# SPDX-License-Identifier: Apache-2.0
+
+source $(dirname "${BASH_SOURCE[0]}")/../../_mesh_test.sh
+
+# Test that initiates a broadcasting of the test model command and immediately suspends device.
+# After a short pause, the device is resumed and attempt of broadcasting is repeated.
+# This is repeated twice more time than allocated advertiser pool size to be sure in that
+# device unreferences allocated advertiser from the pool back if it is suspended.
+#
+# Test procedure:
+# 0. Provisioning and setup.
+# 1. Send test model command twice to check that all allocated advertisers are freed.
+# 2. Suspend Mesh.
+# 3. Resume Mesh.
+# 4. Repeat steps 1-3 twice more than allocated advertiser pool size.
+overlay="overlay_psa_conf"
+RunTest mesh_suspend_resume_unref suspend_dut_suspend_resume_unref
+
+overlay="overlay_low_lat_conf_overlay_psa_conf"
+RunTest mesh_suspend_resume_unref_low_lat suspend_dut_suspend_resume_unref