Linux bluetooth development
 help / color / mirror / Atom feed
From: Luiz Augusto von Dentz <luiz.dentz@gmail.com>
To: linux-bluetooth@vger.kernel.org
Subject: [PATCH BlueZ v4 18/18] shared/rap: Defer Ranging Data mode selection until Features is read
Date: Fri, 20 Nov 2026 11:55:08 -0500	[thread overview]
Message-ID: <20261120165510.1858959-19-luiz.dentz@gmail.com> (raw)
In-Reply-To: <20261120165510.1858959-1-luiz.dentz@gmail.com>

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

- Wait for the RAS Features read before choosing a mode in
  bt_rap_ensure_ranging_data(), since a zero value also means the read
  has not completed.
- Keep an explicit SetRangingDataMode(Disabled) instead of subscribing
  again on the next start.
- Forget a notification registration the peer rejected and drop its
  handler, so that a later start retries it.
- Arm the first Real-time data timeout when Real-time is enabled while a
  procedure is already running.

Assisted-by: Claude:claude-sonnet-5-5
---
 src/shared/rap.c | 100 ++++++++++++++++++++++++++++++++++++++++++++---
 unit/test-rap.c  |  97 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 191 insertions(+), 6 deletions(-)

diff --git a/src/shared/rap.c b/src/shared/rap.c
index d4ce1751f052..3aecd4d40231 100644
--- a/src/shared/rap.c
+++ b/src/shared/rap.c
@@ -480,6 +480,10 @@ struct bt_rap {
 	unsigned int ready_notify_id;
 	unsigned int overwritten_notify_id;
 	uint32_t ras_features;
+	bool features_read;	/* RAS Features read completed */
+	bool ensure_pending;	/* ensure_ranging_data() waits for it */
+	bool mode_selected;	/* SetRangingDataMode() called, even Disabled */
+	bool proc_enabled;	/* a CS procedure is running */
 
 	/* Responder role: Ranging Counters read back through Ranging Data
 	 * Ready and Overwritten, scoped to this connection (RAS v1.0, 3.4
@@ -999,6 +1003,10 @@ void bt_rap_detach(struct bt_rap *rap)
 	rap->cp_notify_id = 0;
 	rap->ready_notify_id = 0;
 	rap->overwritten_notify_id = 0;
+	rap->features_read = false;
+	rap->ensure_pending = false;
+	rap->mode_selected = false;
+	rap->proc_enabled = false;
 
 	bt_att_unregister_disconnect(rap->att, rap->disconn_id);
 	rap->att = NULL;
@@ -3357,7 +3365,9 @@ void bt_rap_hci_cs_procedure_enable_complete_callback(uint16_t length,
 	/* RAP v1.0 4.4.1.1: the first Real-time Ranging Data is due within
 	 * 5 seconds after the CS procedure starts.
 	 */
-	if (data->state == 0x01 && rap->realtime_notify_id)
+	rap->proc_enabled = data->state == 0x01;
+
+	if (rap->proc_enabled && rap->realtime_notify_id)
 		ras_realtime_arm_timeout(rap,
 					RAS_REALTIME_FIRST_SEGMENT_TIMEOUT);
 }
@@ -3530,14 +3540,68 @@ static void rap_read_value(struct bt_rap *rap, uint16_t value_handle,
 	queue_push_tail(rap->pending, pending);
 }
 
+static void rap_forget_notify(struct bt_rap *rap, unsigned int id)
+{
+	if (rap->realtime_notify_id == id)
+		rap->realtime_notify_id = 0;
+	if (rap->ondemand_notify_id == id)
+		rap->ondemand_notify_id = 0;
+	if (rap->cp_notify_id == id)
+		rap->cp_notify_id = 0;
+	if (rap->ready_notify_id == id)
+		rap->ready_notify_id = 0;
+	if (rap->overwritten_notify_id == id)
+		rap->overwritten_notify_id = 0;
+}
+
+struct rap_failed_notify {
+	struct bt_rap *rap;
+	unsigned int id;
+};
+
+static bool rap_failed_notify_cb(void *user_data)
+{
+	struct rap_failed_notify *failed = user_data;
+
+	if (failed->rap->client)
+		bt_gatt_client_unregister_notify(failed->rap->client,
+							failed->id);
+
+	return false;
+}
+
+static void rap_failed_notify_free(void *user_data)
+{
+	struct rap_failed_notify *failed = user_data;
+
+	bt_rap_unref(failed->rap);
+	free(failed);
+}
+
 static void ras_register(uint16_t att_ecode, void *user_data)
 {
 	struct bt_rap_notify *notify = user_data;
+	struct rap_failed_notify *failed;
+
+	if (!att_ecode)
+		return;
 
-	if (att_ecode)
-		DBG(notify->rap, "RAS register failed 0x%04x", att_ecode);
+	DBG(notify->rap, "RAS register failed 0x%04x", att_ecode);
 
-	(void)notify;
+	/* The ID only says the CCC write was queued. Forget it so a later
+	 * subscription retries, and drop the handler the client still holds;
+	 * that is done from the mainloop as the client is iterating its
+	 * registrations right now.
+	 */
+	rap_forget_notify(notify->rap, notify->id);
+
+	failed = new0(struct rap_failed_notify, 1);
+	failed->rap = bt_rap_ref(notify->rap);
+	failed->id = notify->id;
+
+	if (!timeout_add(0, rap_failed_notify_cb, failed,
+					rap_failed_notify_free))
+		rap_failed_notify_free(failed);
 }
 
 static void rap_notify(uint16_t value_handle, const uint8_t *value,
@@ -4651,6 +4715,14 @@ static bool rap_subscribe_ranging_data(struct bt_rap *rap,
 		rap->realtime_notify_id = bt_rap_register_notify(rap,
 				value_handle, rap->realtime_ccc_value,
 				ras_segment_notify_cb, "real-time");
+
+		/* Enabled while a procedure is already running: its start,
+		 * which arms the first data timeout, has been missed.
+		 */
+		if (rap->realtime_notify_id && rap->proc_enabled)
+			ras_realtime_arm_timeout(rap,
+					RAS_REALTIME_FIRST_SEGMENT_TIMEOUT);
+
 		return rap->realtime_notify_id != 0;
 	}
 
@@ -4695,7 +4767,7 @@ bool bt_rap_set_ranging_data_mode(struct bt_rap *rap,
 			enum bt_rap_ranging_data_mode mode,
 			enum bt_rap_ranging_transport transport)
 {
-	if (!rap || !rap->client || !rap->ras_features)
+	if (!rap || !rap->client || !rap->features_read)
 		return false;
 
 	if (mode == BT_RAP_RANGING_DATA_REALTIME &&
@@ -4713,6 +4785,7 @@ bool bt_rap_set_ranging_data_mode(struct bt_rap *rap,
 
 	rap->realtime_ccc_value = transport;
 	rap->ondemand_ccc_value = transport;
+	rap->mode_selected = true;
 
 	return rap_subscribe_ranging_data(rap, mode);
 }
@@ -4724,8 +4797,16 @@ bool bt_rap_ensure_ranging_data(struct bt_rap *rap)
 	if (!rap || !rap->client)
 		return false;
 
-	if (rap->realtime_notify_id || rap->ondemand_notify_id)
+	/* An explicit selection stands, Disabled included */
+	if (rap->mode_selected || rap->realtime_notify_id ||
+					rap->ondemand_notify_id)
+		return true;
+
+	/* Which mode the peer supports is only known once Features is read */
+	if (!rap->features_read) {
+		rap->ensure_pending = true;
 		return true;
+	}
 
 	/* The RREQ has to enable one of the two (RAP v1.0 4.4). Real-time
 	 * Ranging Data is optional for the RRSP, so fall back to On-demand
@@ -4785,6 +4866,7 @@ static void read_ras_features(struct bt_rap *rap, bool success,
 	if (ras)
 		ras->client.abort_operation = abort_operation;
 	rap->ras_features = features;
+	rap->features_read = true;
 
 	DBG(rap, "RAS Features - Real-time: %s, Retrieve Lost: %s, Abort: %s",
 	    supports_realtime ? "Yes" : "No",
@@ -4802,6 +4884,12 @@ static void read_ras_features(struct bt_rap *rap, bool success,
 			!rap_subscribe_ranging_data(rap,
 					BT_RAP_RANGING_DATA_ONDEMAND))
 		DBG(rap, "Failed to subscribe to requested Ranging Data mode");
+
+	/* StartMeasurement() arrived before the peer's features were known */
+	if (rap->ensure_pending) {
+		rap->ensure_pending = false;
+		bt_rap_ensure_ranging_data(rap);
+	}
 }
 
 static void foreach_rap_char(struct gatt_db_attribute *attr, void *user_data)
diff --git a/unit/test-rap.c b/unit/test-rap.c
index a1655640d41c..725aec7eee50 100644
--- a/unit/test-rap.c
+++ b/unit/test-rap.c
@@ -49,6 +49,8 @@ struct test_data_ras {
 struct test_config_rap {
 	const struct iovec *setup_data;
 	const size_t setup_data_len;
+	/* Run right after attaching, before RAS Features is read */
+	void (*early)(struct bt_rap *rap);
 	/* Run once the Requester is ready; when NULL the test passes there */
 	void (*action)(struct bt_rap *rap);
 	/* Called when the ATT script is exhausted; NULL leaves it to action */
@@ -467,6 +469,9 @@ static void test_client_rap(const void *user_data)
 	bt_rap_ready_register(data->rap, rap_client_ready_cb, data, NULL);
 
 	bt_rap_attach(data->rap, data->client);
+
+	if (data->cfg->early)
+		data->cfg->early(data->rap);
 }
 
 /*
@@ -1121,12 +1126,63 @@ static void action_ondemand_indicate(struct bt_rap *rap)
 	WRITE_CCCD(0x0f, 0x02), \
 	WRITE_CCCD(0x12, 0x02)
 
+/* StartMeasurement() before RAS Features was read waits for it, so the mode
+ * follows what the peer supports (Real-time here).
+ */
+static void early_ensure(struct bt_rap *rap)
+{
+	g_assert(bt_rap_ensure_ranging_data(rap));
+}
+
+/* An explicit Disabled selection is not overridden by StartMeasurement() */
+static void action_disabled_then_ensure(struct bt_rap *rap)
+{
+	g_assert(bt_rap_set_ranging_data_mode(rap,
+				BT_RAP_RANGING_DATA_DISABLED,
+				BT_RAP_RANGING_NOTIFY));
+	g_assert(bt_rap_ensure_ranging_data(rap));
+	g_timeout_add(300, idle_pass_cb, NULL);
+}
+
+static gboolean retry_ensure_cb(gpointer user_data)
+{
+	g_assert(bt_rap_ensure_ranging_data(user_data));
+	return FALSE;
+}
+
+/* The peer rejects the CCCD write: the next start has to retry it */
+static void action_ensure_retry(struct bt_rap *rap)
+{
+	g_assert(bt_rap_ensure_ranging_data(rap));
+	g_timeout_add(300, retry_ensure_cb, rap);
+}
+
 const struct test_config_rap cfg_rap_idle = {
 	.setup_data = cggit_setup_data,
 	.setup_data_len = ARRAY_SIZE(cggit_setup_data),
 	.action = action_idle,
 };
 
+const struct test_config_rap cfg_rap_early_ensure = {
+	.setup_data = cggit_setup_data,
+	.setup_data_len = ARRAY_SIZE(cggit_setup_data),
+	.early = early_ensure,
+	.action = action_idle,
+};
+
+const struct test_config_rap cfg_rap_disabled = {
+	.setup_data = cggit_setup_data,
+	.setup_data_len = ARRAY_SIZE(cggit_setup_data),
+	.action = action_disabled_then_ensure,
+};
+
+const struct test_config_rap cfg_rap_retry = {
+	.setup_data = cggit_setup_data,
+	.setup_data_len = ARRAY_SIZE(cggit_setup_data),
+	.action = action_ensure_retry,
+	.complete = test_complete_cb,
+};
+
 const struct test_config_rap cfg_rap_rt_notify = {
 	.setup_data = cggit_setup_data,
 	.setup_data_len = ARRAY_SIZE(cggit_setup_data),
@@ -1204,6 +1260,27 @@ const struct test_config_rap cfg_rap_rt_timeout = {
 	.complete = realtime_timeout_complete,
 };
 
+/*
+ * Real-time Ranging Data enabled while a procedure is already running arms
+ * the first data timeout as well.
+ */
+static void action_realtime_midproc(struct bt_rap *rap)
+{
+	proc_enable_time = g_get_monotonic_time();
+	inject_proc_enable(rap);
+
+	g_assert(bt_rap_set_ranging_data_mode(rap,
+				BT_RAP_RANGING_DATA_REALTIME,
+				BT_RAP_RANGING_NOTIFY));
+}
+
+const struct test_config_rap cfg_rap_rt_midproc = {
+	.setup_data = cggit_setup_data,
+	.setup_data_len = ARRAY_SIZE(cggit_setup_data),
+	.action = action_realtime_midproc,
+	.complete = realtime_timeout_complete,
+};
+
 /*
  * RAS Ranging Data Ready/Overwritten reads report the counters of the
  * connection they are read on (RAS v1.0, 3.4 and 3.5).
@@ -1497,6 +1574,26 @@ int main(int argc, char *argv[])
 			test_setup_rap, test_client_rap, &cfg_rap_ensure,
 			RAP_REQ_ORD_ROUND(0x01));
 
+	define_test_rap("RAP/REQ/RRD/BV-01-C [Subscribe on start before "
+				"Features read]",
+			test_setup_rap, test_client_rap, &cfg_rap_early_ensure,
+			ATTACH_FEATURES_REALTIME, WRITE_CCCD(0x06, 0x01));
+	define_test_rap("RAP/REQ/RRD/BV-01-C [Disabled mode kept on start]",
+			test_setup_rap, test_client_rap, &cfg_rap_disabled,
+			ATTACH_FEATURES_REALTIME);
+	define_test_rap("RAP/REQ/RRD/BV-01-C [Retry after rejected CCCD]",
+			test_setup_rap, test_client_rap, &cfg_rap_retry,
+			ATTACH_FEATURES_REALTIME,
+			IOV_DATA(0x12, 0x06, 0x00, 0x01, 0x00),
+			IOV_DATA(0x01, 0x12, 0x06, 0x00, 0x03),
+			WRITE_CCCD(0x06, 0x00),
+			WRITE_CCCD(0x06, 0x01));
+	define_test_rap("RAP/REQ/RRD/BV-01-C [Real-time timeout when enabled "
+				"mid-procedure]",
+			test_setup_rap, test_client_rap, &cfg_rap_rt_midproc,
+			ATTACH_FEATURES_REALTIME, WRITE_CCCD(0x06, 0x01),
+			WRITE_CCCD(0x06, 0x00));
+
 	/* RAS Ranging Counters are per connection */
 	tester_add("RAS/SR/RCO/Ranging Counters per connection", &cnt_data,
 			NULL, test_counters, cnt_teardown);
-- 
2.56.0


      parent reply	other threads:[~2026-11-20 16:55 UTC|newest]

Thread overview: 20+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20 16:54 [PATCH BlueZ v4 00/18] Channel Sounding and RAP fixes Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 01/18] gatt-database: Drop stale device state for removed bonds Luiz Augusto von Dentz
2026-11-20 22:32   ` Channel Sounding and RAP fixes bluez.test.bot
2026-11-20 16:54 ` [PATCH BlueZ v4 02/18] shared/rap: Reset the readable Ranging Counters per connection Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 03/18] shared/rap: Subscribe on-demand data with the requested transport Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 04/18] shared/rap: Subscribe to Ranging Data when a measurement starts Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 05/18] client/cs: Fix use-after-free in stop_measurement_reply Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 06/18] shared/hci: Look up the connection handle on the right link Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 07/18] profiles/ranging: Let the Reflector run the CS setup phase Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 08/18] profiles/ranging: Let StartMeasurement() pick the Initiator for Both Luiz Augusto von Dentz
2026-11-20 16:54 ` [PATCH BlueZ v4 09/18] profiles/ranging: Take the CS role from Config Complete Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 10/18] profiles/ranging: Act on a CS configuration created by the peer Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 11/18] profiles/ranging: Keep a peer-driven setup from being rewound Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 12/18] profiles/ranging: Defer CS Security Enable until the link is encrypted Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 13/18] profiles/ranging: Choose the CS antenna configuration from both ends Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 14/18] profiles/ranging: Do not start a procedure after StopMeasurement() Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 15/18] profiles/ranging: Keep CS sessions apart from stale and unrelated events Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 16/18] shared/rap: Start the Real-time timeout when the procedure starts Luiz Augusto von Dentz
2026-11-20 16:55 ` [PATCH BlueZ v4 17/18] unit/test-rap: Add tests for Ranging Data subscription and counters Luiz Augusto von Dentz
2026-11-20 16:55 ` Luiz Augusto von Dentz [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261120165510.1858959-19-luiz.dentz@gmail.com \
    --to=luiz.dentz@gmail.com \
    --cc=linux-bluetooth@vger.kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox