| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/connectivity/bluetooth/core/bt-host/transport/acl_data_channel.h" |
| |
| #include <lib/async/cpp/task.h> |
| #include <lib/fpromise/single_threaded_executor.h> |
| #include <lib/inspect/testing/cpp/inspect.h> |
| #include <zircon/assert.h> |
| |
| #include <unordered_map> |
| |
| #include <gmock/gmock.h> |
| |
| #include "src/connectivity/bluetooth/core/bt-host/common/byte_buffer.h" |
| #include "src/connectivity/bluetooth/core/bt-host/common/test_helpers.h" |
| #include "src/connectivity/bluetooth/core/bt-host/hci-spec/defaults.h" |
| #include "src/connectivity/bluetooth/core/bt-host/hci/connection.h" |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/l2cap_defs.h" |
| #include "src/connectivity/bluetooth/core/bt-host/testing/controller_test.h" |
| #include "src/connectivity/bluetooth/core/bt-host/testing/mock_controller.h" |
| #include "src/connectivity/bluetooth/core/bt-host/testing/test_packets.h" |
| #include "src/connectivity/bluetooth/core/bt-host/transport/link_type.h" |
| #include "src/connectivity/bluetooth/core/bt-host/transport/transport.h" |
| |
| namespace bt::hci { |
| namespace { |
| |
| constexpr hci_spec::ConnectionHandle kLinkHandle = 0x0001; |
| |
| using TestingBase = bt::testing::ControllerTest<bt::testing::MockController>; |
| |
| class ACLDataChannelTest : public TestingBase { |
| public: |
| ACLDataChannelTest() = default; |
| ~ACLDataChannelTest() override = default; |
| |
| protected: |
| // TestBase overrides: |
| void SetUp() override { |
| TestingBase::SetUp(); |
| StartTestDevice(); |
| } |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN_ALLOW_MOVE(ACLDataChannelTest); |
| }; |
| |
| using HCI_ACLDataChannelTest = ACLDataChannelTest; |
| |
| TEST_F(ACLDataChannelTest, VerifyMTUs) { |
| const DataBufferInfo kBREDRBufferInfo(1024, 50); |
| const DataBufferInfo kLEBufferInfo(64, 16); |
| |
| // BR/EDR buffer only. |
| InitializeACLDataChannel(kBREDRBufferInfo, DataBufferInfo()); |
| EXPECT_EQ(kBREDRBufferInfo, acl_data_channel()->GetBufferInfo()); |
| EXPECT_EQ(kBREDRBufferInfo, acl_data_channel()->GetLeBufferInfo()); |
| |
| TearDown(); |
| SetUp(); |
| |
| // LE buffer only. |
| InitializeACLDataChannel(DataBufferInfo(), kLEBufferInfo); |
| EXPECT_EQ(DataBufferInfo(), acl_data_channel()->GetBufferInfo()); |
| EXPECT_EQ(kLEBufferInfo, acl_data_channel()->GetLeBufferInfo()); |
| |
| TearDown(); |
| SetUp(); |
| |
| // Both buffers available. |
| InitializeACLDataChannel(kBREDRBufferInfo, kLEBufferInfo); |
| EXPECT_EQ(kBREDRBufferInfo, acl_data_channel()->GetBufferInfo()); |
| EXPECT_EQ(kLEBufferInfo, acl_data_channel()->GetLeBufferInfo()); |
| } |
| |
| // Test that SendPacket works using only the BR/EDR buffer. |
| TEST_F(ACLDataChannelTest, SendPacketBREDRBuffer) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kMaxNumPackets = 5; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| int handle0_packet_count = 0; |
| int handle1_packet_count = 0; |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Queue up 10 packets in total, distributed among the two connection handles. |
| async::PostTask(dispatcher(), [this] { |
| for (int i = 0; i < 10; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| }); |
| |
| RunLoopUntilIdle(); |
| |
| // kMaxNumPackets is 5. The controller should have received 3 packets on |
| // kHandle0 and 2 on kHandle1 |
| EXPECT_EQ(3, handle0_packet_count); |
| EXPECT_EQ(2, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x02, // Number of handles |
| 0x01, 0x00, 0x03, 0x00, // 3 packets on handle 0x0001 |
| 0x02, 0x00, 0x02, 0x00 // 2 packets on handle 0x0002 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(5, handle0_packet_count); |
| EXPECT_EQ(5, handle1_packet_count); |
| } |
| |
| inspect::Hierarchy ReadInspect(inspect::Inspector& inspector) { |
| fpromise::single_threaded_executor executor; |
| fpromise::result<inspect::Hierarchy> hierarchy; |
| executor.schedule_task(inspect::ReadFromInspector(inspector).then( |
| [&](fpromise::result<inspect::Hierarchy>& res) { hierarchy = std::move(res); })); |
| executor.run(); |
| ZX_ASSERT(hierarchy.is_ok()); |
| return hierarchy.take_value(); |
| } |
| |
| // Test that SendPacket works using the LE buffer when no BR/EDR buffer is |
| // available. |
| TEST_F(ACLDataChannelTest, SendPacketLEBuffer) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kTotalAttempts = 12; |
| constexpr size_t kTotalExpected = 6; |
| constexpr size_t kBufferNumPackets = 3; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(), DataBufferInfo(kMaxMTU, kBufferNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| // This should fail because the payload exceeds the MTU. |
| auto packet = ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU + 1); |
| EXPECT_FALSE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| |
| size_t handle0_packet_count = 0; |
| size_t handle1_packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Queue up 12 packets in total, distributed among the two connection handles |
| // and link types. Since the BR/EDR MTU is zero, we expect to only see LE |
| // packets transmitted. |
| async::PostTask(dispatcher(), [this] { |
| for (size_t i = 0; i < kTotalAttempts; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| if (i % 2) { |
| // ACL-U packets should fail due to 0 MTU size. |
| EXPECT_FALSE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } else { |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| } |
| }); |
| |
| RunLoopUntilIdle(); |
| |
| // The controller can buffer 3 packets. Since BR/EDR packets should have |
| // failed to go out, the controller should have received 3 packets on handle 0 |
| // and none on handle 1. |
| EXPECT_EQ(kTotalExpected / 2u, handle0_packet_count); |
| EXPECT_EQ(0u, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x05, // Event header |
| 0x01, // Number of handles |
| 0x01, 0x00, 0x03, |
| 0x00 // 3 packets on handle 0x0001 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(kTotalExpected, handle0_packet_count); |
| EXPECT_EQ(0u, handle1_packet_count); |
| } |
| |
| // Test that SendPacket works for LE packets when both buffer types are |
| // available. |
| TEST_F(ACLDataChannelTest, SendLEPacketBothBuffers) { |
| constexpr size_t kMaxMTU = 200; |
| constexpr size_t kMaxNumPackets = 50; |
| constexpr size_t kLEMaxMTU = 5; |
| constexpr size_t kLEMaxNumPackets = 5; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), |
| DataBufferInfo(kLEMaxMTU, kLEMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kLE); |
| |
| // This should fail because the payload exceeds the LE MTU. |
| auto packet = ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_FALSE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| |
| int handle0_packet_count = 0; |
| int handle1_packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Queue up 10 packets in total, distributed among the two connection handles. |
| async::PostTask(dispatcher(), [this] { |
| for (int i = 0; i < 10; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kLEMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| }); |
| |
| RunLoopUntilIdle(); |
| |
| // ACLDataChannel should be looking at kLEMaxNumPackets, which is 5. The |
| // controller should have received 3 packets on kHandle0 and 2 on kHandle1 |
| EXPECT_EQ(3, handle0_packet_count); |
| EXPECT_EQ(2, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x02, // Number of handles |
| 0x01, 0x00, 0x03, 0x00, // 3 packets on handle 0x0001 |
| 0x02, 0x00, 0x02, 0x00 // 2 packets on handle 0x0002 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(5, handle0_packet_count); |
| EXPECT_EQ(5, handle1_packet_count); |
| } |
| |
| // Test that SendPacket works for BR/EDR packets when both buffer types are |
| // available. |
| TEST_F(ACLDataChannelTest, SendBREDRPacketBothBuffers) { |
| constexpr size_t kLEMaxMTU = 200; |
| constexpr size_t kLEMaxNumPackets = 50; |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kMaxNumPackets = 5; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), |
| DataBufferInfo(kLEMaxMTU, kLEMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| // This should fail because the payload exceeds the ACL MTU. |
| auto packet = ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kLEMaxMTU); |
| EXPECT_FALSE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| |
| int handle0_packet_count = 0; |
| int handle1_packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Queue up 10 packets in total, distributed among the two connection handles. |
| async::PostTask(dispatcher(), [this] { |
| for (int i = 0; i < 10; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| }); |
| |
| RunLoopUntilIdle(); |
| |
| // ACLDataChannel should be looking at kLEMaxNumPackets, which is 5. The |
| // controller should have received 3 packets on kHandle0 and 2 on kHandle1 |
| EXPECT_EQ(3, handle0_packet_count); |
| EXPECT_EQ(2, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x02, // Number of handles |
| 0x01, 0x00, 0x03, 0x00, // 3 packets on handle 0x0001 |
| 0x02, 0x00, 0x02, 0x00 // 2 packets on handle 0x0002 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(5, handle0_packet_count); |
| EXPECT_EQ(5, handle1_packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, SendPacketsFailure) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr hci_spec::ConnectionHandle kHandle = 0x0001; |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, 100), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kACL); |
| |
| // Empty packet list. |
| EXPECT_FALSE(acl_data_channel()->SendPackets( |
| LinkedList<ACLDataPacket>(), l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| // Packet exceeds MTU |
| LinkedList<ACLDataPacket> packets; |
| packets.push_back(ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU + 1)); |
| EXPECT_FALSE(acl_data_channel()->SendPackets(std::move(packets), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| // Suffix DeathTest has GoogleTest-specific behavior |
| using ACLDataChannelDeathTest = HCI_ACLDataChannelTest; |
| |
| TEST_F(ACLDataChannelDeathTest, SendPacketsCrashesWithContinuingFragments) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr hci_spec::ConnectionHandle kHandle = 0x0001; |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, 100), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kACL); |
| |
| LinkedList<ACLDataPacket> packets; |
| packets.push_back(ACLDataPacket::New(kHandle, |
| hci_spec::ACLPacketBoundaryFlag::kContinuingFragment, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU)); |
| ASSERT_DEATH_IF_SUPPORTED( |
| acl_data_channel()->SendPackets(std::move(packets), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow), |
| "expected full PDU"); |
| } |
| |
| TEST_F(ACLDataChannelDeathTest, SendPacketsCrashesWithPacketsForMoreThanOneConnection) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, 100), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| // Packet exceeds MTU |
| LinkedList<ACLDataPacket> packets; |
| packets.push_back(ACLDataPacket::New(kHandle0, |
| hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU)); |
| packets.push_back(ACLDataPacket::New(kHandle1, |
| hci_spec::ACLPacketBoundaryFlag::kContinuingFragment, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU)); |
| ASSERT_DEATH_IF_SUPPORTED( |
| acl_data_channel()->SendPackets(std::move(packets), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow), |
| "expected only fragments for one connection"); |
| } |
| |
| // Tests sending multiple packets in a single call. |
| TEST_F(ACLDataChannelTest, SendPackets) { |
| constexpr int kExpectedPacketCount = 5; |
| constexpr hci_spec::ConnectionHandle kHandle = 0x0001; |
| |
| InitializeACLDataChannel(DataBufferInfo(1024, 100), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kLE); |
| |
| bool pass = true; |
| int seq_no = 0; |
| auto data_cb = [&pass, &seq_no](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| EXPECT_EQ(1u, packet.payload_size()); |
| |
| int cur_no = packet.payload_data().data()[0]; |
| if (cur_no != seq_no + 1) { |
| pass = false; |
| return; |
| } |
| |
| seq_no = cur_no; |
| }; |
| test_device()->SetDataCallback(data_cb, dispatcher()); |
| |
| LinkedList<ACLDataPacket> packets; |
| for (int i = 1; i <= kExpectedPacketCount; ++i) { |
| auto packet = ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1); |
| packet->mutable_view()->mutable_payload_bytes()[0] = i; |
| packets.push_back(std::move(packet)); |
| } |
| |
| EXPECT_TRUE(acl_data_channel()->SendPackets(std::move(packets), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_TRUE(pass); |
| EXPECT_EQ(kExpectedPacketCount, seq_no); |
| } |
| |
| TEST_F(ACLDataChannelTest, |
| UnregisterLinkDoesNotClearNumSentPacketsAndClearControllerPacketCountDoes) { |
| constexpr size_t kMaxMTU = 1024; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 1; |
| constexpr hci_spec::ConnectionHandle kHandle2 = 2; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle2, bt::LinkType::kLE); |
| |
| int packet_count = 0; |
| test_device()->SetDataCallback([&](const auto&) { packet_count++; }, dispatcher()); |
| |
| // Send 3 packets on two links. This is enough to fill up the data buffers. |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle2, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| // The third packet should have been queued. |
| ASSERT_EQ(2, packet_count); |
| |
| // UnregisterLink should not decrement sent packet count, |
| // so next packet should not be sent. |
| acl_data_channel()->UnregisterLink(kHandle2); |
| RunLoopUntilIdle(); |
| ASSERT_EQ(2, packet_count); |
| |
| // Clear the controller packet count for |kHandle2|. The next packet should go out. |
| acl_data_channel()->ClearControllerPacketCount(kHandle2); |
| RunLoopUntilIdle(); |
| ASSERT_EQ(3, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, SendingPacketsOnUnregisteredLinkDropsPackets) { |
| constexpr size_t kMaxMTU = 1024; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle = 1; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| int packet_count = 0; |
| test_device()->SetDataCallback([&](const auto&) { packet_count++; }, dispatcher()); |
| |
| // Send packet with unregistered handle. |
| ASSERT_FALSE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| // Packet should not have been sent. |
| ASSERT_EQ(0, packet_count); |
| |
| // Now register link. Packet should have been dropped and should still |
| // not be sent. |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kLE); |
| |
| RunLoopUntilIdle(); |
| |
| // Packet should not have been sent. |
| ASSERT_EQ(0, packet_count); |
| |
| // Unregister a link that has not been registered |
| acl_data_channel()->UnregisterLink(kHandle); |
| RunLoopUntilIdle(); |
| ASSERT_EQ(0, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, UnregisterLinkClearsPendingPackets) { |
| constexpr size_t kMaxMTU = 1024; |
| constexpr size_t kMaxNumPackets = 1; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 1; |
| constexpr hci_spec::ConnectionHandle kHandle2 = 2; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle2, bt::LinkType::kLE); |
| |
| int handle1_packet_count = 0; |
| int handle2_packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle1) { |
| handle1_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle2, connection_handle); |
| handle2_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Send 3 packets on two links. This is enough to fill up the data buffers. |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle2, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| // Only kHandle1 packet should have been sent |
| ASSERT_EQ(1, handle1_packet_count); |
| ASSERT_EQ(0, handle2_packet_count); |
| |
| // Clear pending packet for |kHandle2| |
| acl_data_channel()->UnregisterLink(kHandle2); |
| |
| // Notify the processed packet with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x05, // Event header |
| 0x01, // Number of handles |
| 0x01, 0x00, 0x01, 0x00 // 1 packet on handle 0x0001 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| // second |kHandle1| packet should have been sent |
| ASSERT_EQ(2, handle1_packet_count); |
| ASSERT_EQ(0, handle2_packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, PacketsQueuedByFlowControlAreNotSentAfterUnregisterLink) { |
| constexpr size_t kMaxMTU = 1024; |
| constexpr size_t kMaxNumPackets = 1; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 1; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kLE); |
| |
| int packet_count = 0; |
| test_device()->SetDataCallback([&](const auto&) { packet_count++; }, dispatcher()); |
| |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| // The second packet should have been queued. |
| ASSERT_EQ(1, packet_count); |
| |
| // Clear the packet count for |kHandle2|. The second packet should NOT go out. |
| acl_data_channel()->UnregisterLink(kHandle1); |
| |
| // Notify the processed packet with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x05, // Event header |
| 0x01, // Number of handles |
| 0x01, 0x00, 0x01, 0x00 // 1 packet on handle 0x0001 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| // The second packet should not have been sent |
| ASSERT_EQ(1, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, |
| StalePacketsBufferedBeforeFirstUnregisterAndBeforeSecondRegisterAreNotSent) { |
| constexpr size_t kMaxMTU = 1024; |
| constexpr size_t kMaxNumPackets = 1; |
| constexpr hci_spec::ConnectionHandle kHandle = 1; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kLE); |
| |
| // Unique packet to send to re-registered link with same handle. |
| const StaticByteBuffer kPacket( |
| // ACL data header (handle: 1, length 1) |
| 0x01, 0x00, 0x01, 0x00, |
| |
| // Unique payload to distinguish this packet from stale packet |
| 0x01); |
| |
| int data_cb_count = 0; |
| auto data_cb = [&](const ByteBuffer& packet) { |
| data_cb_count++; |
| if (data_cb_count == 2) { |
| EXPECT_TRUE(ContainersEqual(kPacket, packet)); |
| } |
| }; |
| test_device()->SetDataCallback(data_cb, dispatcher()); |
| |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| // The second packet should have been queued. |
| ASSERT_EQ(1, data_cb_count); |
| |
| // Clear the packet count for |kHandle2|. The second packet should NOT go out. |
| acl_data_channel()->UnregisterLink(kHandle); |
| |
| // Notify the processed packet with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x05, // Event header |
| 0x01, // Number of handles |
| 0x01, 0x00, 0x01, 0x00 // 1 packet on handle 0x0001 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| // The second packet should not have been sent |
| ASSERT_EQ(1, data_cb_count); |
| |
| // Re-Register same link handle |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kLE); |
| |
| auto packet = ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1); |
| packet->mutable_view()->mutable_payload_data().Fill(1); |
| |
| ASSERT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kInvalidChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| |
| // The new packet should have been sent to the MockController. |
| ASSERT_EQ(2, data_cb_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, UnregisterLinkDropsFutureSentPackets) { |
| constexpr size_t kMaxMTU = 1024; |
| constexpr size_t kMaxNumPackets = 1; |
| constexpr hci_spec::ConnectionHandle kHandle = 1; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle, bt::LinkType::kLE); |
| |
| int packet_count = 0; |
| test_device()->SetDataCallback([&](const auto&) { packet_count++; }, dispatcher()); |
| |
| ASSERT_TRUE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| ASSERT_EQ(1, packet_count); |
| |
| acl_data_channel()->UnregisterLink(kHandle); |
| |
| // attempt to send packet on unregistered link |
| ASSERT_FALSE(acl_data_channel()->SendPacket( |
| ACLDataPacket::New(kHandle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, 1), |
| l2cap::kInvalidChannelId, AclDataChannel::PacketPriority::kLow)); |
| |
| RunLoopUntilIdle(); |
| // second packet should not have been sent |
| ASSERT_EQ(1, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, ReceiveData) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kMaxNumPackets = 5; |
| |
| // It doesn't matter what we set the buffer values to since we're testing |
| // incoming packets. |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| constexpr size_t kExpectedPacketCount = 2u; |
| size_t num_rx_packets = 0u; |
| hci_spec::ConnectionHandle packet0_handle; |
| hci_spec::ConnectionHandle packet1_handle; |
| auto data_rx_cb = [&](ACLDataPacketPtr packet) { |
| num_rx_packets++; |
| if (num_rx_packets == 1) { |
| packet0_handle = packet->connection_handle(); |
| } else if (num_rx_packets == 2) { |
| packet1_handle = packet->connection_handle(); |
| } else { |
| ZX_PANIC("|num_rx_packets| has unexpected value: %zu", num_rx_packets); |
| } |
| }; |
| set_data_received_callback(std::move(data_rx_cb)); |
| |
| // Malformed packet: smaller than the ACL header. |
| StaticByteBuffer invalid0(0x01, 0x00, 0x00); |
| |
| // Malformed packet: the payload size given in the header doesn't match the |
| // actual payload size. |
| StaticByteBuffer invalid1(0x01, 0x00, 0x02, 0x00, 0x00); |
| |
| // Valid packet on handle 1. |
| StaticByteBuffer valid0(0x01, 0x00, 0x01, 0x00, 0x00); |
| |
| // Valid packet on handle 2. |
| StaticByteBuffer valid1(0x02, 0x00, 0x01, 0x00, 0x00); |
| |
| async::PostTask(dispatcher(), [&, this] { |
| test_device()->SendACLDataChannelPacket(invalid0); |
| test_device()->SendACLDataChannelPacket(invalid1); |
| test_device()->SendACLDataChannelPacket(valid0); |
| test_device()->SendACLDataChannelPacket(valid1); |
| }); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(kExpectedPacketCount, num_rx_packets); |
| EXPECT_EQ(0x0001, packet0_handle); |
| EXPECT_EQ(0x0002, packet1_handle); |
| } |
| |
| TEST_F(ACLDataChannelTest, TransportClosedCallbackBothChannels) { |
| InitializeACLDataChannel(DataBufferInfo(1u, 1u), DataBufferInfo(1u, 1u)); |
| |
| int closed_cb_count = 0; |
| auto closed_cb = [&closed_cb_count] { closed_cb_count++; }; |
| transport()->SetTransportClosedCallback(closed_cb); |
| |
| async::PostTask(dispatcher(), [this] { test_device()->Stop(ZX_ERR_PEER_CLOSED); }); |
| |
| RunLoopUntilIdle(); |
| EXPECT_EQ(1, closed_cb_count); |
| } |
| |
| // Make sure that a HCI "Number of completed packets" event received after shut |
| // down does not cause a crash. |
| TEST_F(ACLDataChannelTest, HciEventReceivedAfterShutDown) { |
| InitializeACLDataChannel(DataBufferInfo(1u, 1u), DataBufferInfo(1u, 1u)); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x02, // Number of handles |
| 0x01, 0x00, 0x03, 0x00, // 3 packets on handle 0x0001 |
| 0x02, 0x00, 0x02, 0x00 // 2 packets on handle 0x0002 |
| ); |
| |
| // Shuts down ACLDataChannel and CommandChannel. |
| DeleteTransport(); |
| |
| test_device()->SendCommandChannelPacket(event_buffer); |
| RunLoopUntilIdle(); |
| } |
| |
| TEST_F(ACLDataChannelTest, DropQueuedPacketsRemovesPacketsMatchingFilterFromQueue) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kMaxNumPackets = 5; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| constexpr l2cap::ChannelId kChanId0 = 0x40; |
| constexpr l2cap::ChannelId kChanId1 = 0x41; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| int handle0_packet_count = 0; |
| int handle1_packet_count = 0; |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Queue up 10 packets in total, distributed among the two connection handles. |
| for (size_t i = 0; i < 2 * kMaxNumPackets; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), (i % 2) ? kChanId1 : kChanId0, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| RunLoopUntilIdle(); |
| |
| // kMaxNumPackets is 5. The controller should have received 3 packets on |
| // kHandle0 and 2 on kHandle1 |
| EXPECT_EQ(3, handle0_packet_count); |
| EXPECT_EQ(2, handle1_packet_count); |
| |
| // Should remove 3 |kHandle1| packets from queue |
| size_t predicate_count = 0; |
| size_t predicate_true_count = 0; |
| acl_data_channel()->DropQueuedPackets([&](const ACLDataPacketPtr& packet, l2cap::ChannelId id) { |
| predicate_count++; |
| // Verify that correct channels are passed to filter lambda |
| if (packet->connection_handle() == kHandle0) { |
| EXPECT_EQ(id, kChanId0); |
| } else if (packet->connection_handle() == kHandle1) { |
| EXPECT_EQ(id, kChanId1); |
| } |
| |
| bool result = packet->connection_handle() == kHandle1; |
| if (result) { |
| predicate_true_count++; |
| } |
| return result; |
| }); |
| // Should be called for each packet in queue (2 |kHandle0| packets + 3 |kHandle1| packets) |
| EXPECT_EQ(predicate_count, 5u); |
| // 3 |kHandle1| packets |
| EXPECT_EQ(predicate_true_count, 3u); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x02, // Number of handles |
| 0x01, 0x00, 0x03, 0x00, // 3 packets on handle 0x0001 |
| 0x02, 0x00, 0x02, 0x00 // 2 packets on handle 0x0002 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(5, handle0_packet_count); |
| // Other 3 |kHandle1| packets should have been filtered out of queue |
| EXPECT_EQ(2, handle1_packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, HighPriorityPacketsQueuedAfterLowPriorityPacketsAreSentFirst) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kMaxNumPackets = 5; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| size_t handle0_packet_count = 0; |
| size_t handle1_packet_count = 0; |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Fill controller with |kMaxNumPackets| packets so queue can grow. |
| for (size_t i = 0; i < kMaxNumPackets; ++i) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(kMaxNumPackets, handle0_packet_count); |
| handle0_packet_count = 0; |
| |
| // Queue up 10 packets in total, distributed among the two connection handles. |
| for (size_t i = 0; i < 2 * kMaxNumPackets; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto priority = |
| (i % 2) ? AclDataChannel::PacketPriority::kLow : AclDataChannel::PacketPriority::kHigh; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE( |
| acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, priority)); |
| } |
| |
| RunLoopUntilIdle(); |
| |
| // No packets should have been sent because controller buffer is full. |
| EXPECT_EQ(0u, handle0_packet_count); |
| EXPECT_EQ(0u, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x05, // Event header |
| 0x01, // Number of handles |
| 0x01, 0x00, 0x05, 0x00 // 5 packets on handle 0x0001 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| |
| // Only high priority packets should have been sent. |
| EXPECT_EQ(5u, handle0_packet_count); |
| EXPECT_EQ(0u, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| test_device()->SendCommandChannelPacket(event_buffer); |
| |
| RunLoopUntilIdle(); |
| EXPECT_EQ(5u, handle0_packet_count); |
| // Now low priority packets should have been sent. |
| EXPECT_EQ(5u, handle1_packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, OutOfBoundsPacketCountsIgnored) { |
| constexpr size_t kMaxMTU = 5; |
| constexpr size_t kMaxNumPackets = 6; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMTU, kMaxNumPackets), DataBufferInfo()); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| size_t handle0_packet_count = 0; |
| size_t handle1_packet_count = 0; |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci_spec::ACLDataHeader)); |
| |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| if (connection_handle == kHandle0) { |
| handle0_packet_count++; |
| } else { |
| ASSERT_EQ(kHandle1, connection_handle); |
| handle1_packet_count++; |
| } |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Fill controller with |kMaxNumPackets| packets split evenly between the two handles. |
| for (size_t i = 0; i < kMaxNumPackets; ++i) { |
| hci_spec::ConnectionHandle handle = (i % 2) ? kHandle1 : kHandle0; |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(kMaxNumPackets / 2, handle0_packet_count); |
| EXPECT_EQ(kMaxNumPackets / 2, handle1_packet_count); |
| handle0_packet_count = 0; |
| handle1_packet_count = 0; |
| |
| // Queue up 3 packets for each handle, |
| for (size_t i = 0; i < kMaxNumPackets / 2; ++i) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| for (size_t i = 0; i < kMaxNumPackets / 2; ++i) { |
| auto packet = ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMTU); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| RunLoopUntilIdle(); |
| |
| // No packets should have been sent because controller buffer is full. |
| EXPECT_EQ(0u, handle0_packet_count); |
| EXPECT_EQ(0u, handle1_packet_count); |
| |
| // Notify the processed packets with a Number Of Completed Packet HCI event. |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x01, // Number of handles |
| 0x01, 0x00, 0x03, 0x00, // 3 packets on handle 0x0001 |
| 0x02, 0x00, 0x05, 0x00 // (ignored, not indicated in handle count) |
| ); |
| |
| test_device()->SendCommandChannelPacket(event_buffer); |
| RunLoopUntilIdle(); |
| |
| // Only packets on handle0 should have been sent. |
| EXPECT_EQ(3u, handle0_packet_count); |
| EXPECT_EQ(0u, handle1_packet_count); |
| |
| StaticByteBuffer short_buffer(0x13, 0x05, // Event header |
| 0x02, // Number of handles |
| 0x02, 0x00, 0x02, 0x00 // 2 packets on handle 0x0002 |
| // (missing second handle, should be ignored) |
| ); |
| |
| test_device()->SendCommandChannelPacket(short_buffer); |
| RunLoopUntilIdle(); |
| |
| // handle1 packets should have been sent anyway |
| EXPECT_EQ(3u, handle0_packet_count); |
| EXPECT_EQ(2u, handle1_packet_count); |
| } |
| |
| class AclPriorityTest : public HCI_ACLDataChannelTest, |
| public ::testing::WithParamInterface<std::pair<hci::AclPriority, bool>> {}; |
| TEST_P(AclPriorityTest, RequestAclPriority) { |
| const auto kPriority = GetParam().first; |
| const bool kExpectSuccess = GetParam().second; |
| |
| const DataBufferInfo kBREDRBufferInfo(1024, 50); |
| InitializeACLDataChannel(kBREDRBufferInfo, DataBufferInfo()); |
| |
| // Arbitrary command payload larger than hci_spec::CommandHeader. |
| const auto op_code = hci_spec::VendorOpCode(0x01); |
| const StaticByteBuffer kEncodedCommand(LowerBits(op_code), UpperBits(op_code), // op code |
| 0x04, // parameter size |
| 0x00, 0x01, 0x02, 0x03); // test parameter |
| |
| constexpr hci_spec::ConnectionHandle kLinkHandle = 0x0001; |
| |
| std::optional<hci_spec::ConnectionHandle> connection; |
| std::optional<hci::AclPriority> priority; |
| set_encode_acl_priority_command_cb( |
| [&](hci_spec::ConnectionHandle cb_connection, hci::AclPriority cb_priority) { |
| connection = cb_connection; |
| priority = cb_priority; |
| return fitx::ok(DynamicByteBuffer(kEncodedCommand)); |
| }); |
| |
| auto cmd_complete = bt::testing::CommandCompletePacket( |
| op_code, |
| kExpectSuccess ? hci_spec::StatusCode::kSuccess : hci_spec::StatusCode::kUnknownCommand); |
| EXPECT_CMD_PACKET_OUT(test_device(), kEncodedCommand, &cmd_complete); |
| |
| size_t request_cb_count = 0; |
| acl_data_channel()->RequestAclPriority(kPriority, kLinkHandle, [&](auto result) { |
| request_cb_count++; |
| EXPECT_EQ(kExpectSuccess, result.is_ok()); |
| }); |
| |
| RunLoopUntilIdle(); |
| EXPECT_EQ(request_cb_count, 1u); |
| ASSERT_TRUE(connection); |
| EXPECT_EQ(connection.value(), kLinkHandle); |
| ASSERT_TRUE(priority); |
| EXPECT_EQ(priority.value(), kPriority); |
| } |
| |
| const std::array<std::pair<hci::AclPriority, bool>, 4> kPriorityParams = { |
| {{hci::AclPriority::kSource, /*expect_success=*/false}, |
| {hci::AclPriority::kSource, true}, |
| {hci::AclPriority::kSink, true}, |
| {hci::AclPriority::kNormal, true}}}; |
| INSTANTIATE_TEST_SUITE_P(ACLDataChannelTest, AclPriorityTest, ::testing::ValuesIn(kPriorityParams)); |
| |
| TEST_F(ACLDataChannelTest, RequestAclPriorityEncodeFails) { |
| const DataBufferInfo kBREDRBufferInfo(1024, 50); |
| InitializeACLDataChannel(kBREDRBufferInfo, DataBufferInfo()); |
| |
| set_encode_acl_priority_command_cb([&](auto, auto) { return fitx::error(ZX_ERR_INTERNAL); }); |
| |
| size_t request_cb_count = 0; |
| acl_data_channel()->RequestAclPriority(hci::AclPriority::kSink, kLinkHandle, [&](auto result) { |
| request_cb_count++; |
| EXPECT_TRUE(result.is_error()); |
| }); |
| |
| RunLoopUntilIdle(); |
| EXPECT_EQ(request_cb_count, 1u); |
| } |
| |
| TEST_F(ACLDataChannelTest, RequestAclPriorityEncodeReturnsTooSmallBuffer) { |
| const DataBufferInfo kBREDRBufferInfo(1024, 50); |
| InitializeACLDataChannel(kBREDRBufferInfo, DataBufferInfo()); |
| |
| set_encode_acl_priority_command_cb( |
| [](auto, auto) { return fitx::ok(DynamicByteBuffer(StaticByteBuffer(0x00))); }); |
| |
| size_t request_cb_count = 0; |
| acl_data_channel()->RequestAclPriority(hci::AclPriority::kSink, kLinkHandle, [&](auto result) { |
| request_cb_count++; |
| EXPECT_TRUE(result.is_error()); |
| }); |
| |
| RunLoopUntilIdle(); |
| EXPECT_EQ(request_cb_count, 1u); |
| } |
| |
| TEST_F(ACLDataChannelTest, SetAutomaticFlushTimeout) { |
| const DataBufferInfo kBREDRBufferInfo(1024, 50); |
| InitializeACLDataChannel(kBREDRBufferInfo, DataBufferInfo()); |
| acl_data_channel()->RegisterLink(kLinkHandle, bt::LinkType::kACL); |
| |
| std::optional<Result<>> cb_status; |
| auto result_cb = [&](auto status) { cb_status = status; }; |
| |
| // Test command complete error |
| const auto kCommandCompleteError = bt::testing::CommandCompletePacket( |
| hci_spec::kWriteAutomaticFlushTimeout, hci_spec::StatusCode::kUnknownConnectionId); |
| EXPECT_CMD_PACKET_OUT(test_device(), |
| bt::testing::WriteAutomaticFlushTimeoutPacket(kLinkHandle, 0), |
| &kCommandCompleteError); |
| acl_data_channel()->SetBrEdrAutomaticFlushTimeout(zx::duration::infinite(), kLinkHandle, |
| result_cb); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(cb_status.has_value()); |
| ASSERT_TRUE(cb_status->is_error()); |
| EXPECT_EQ(ToResult(hci_spec::StatusCode::kUnknownConnectionId), *cb_status); |
| cb_status.reset(); |
| |
| // Test flush timeout = 0 (no command should be sent) |
| acl_data_channel()->SetBrEdrAutomaticFlushTimeout(zx::msec(0), kLinkHandle, result_cb); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(cb_status.has_value()); |
| EXPECT_TRUE(cb_status->is_error()); |
| EXPECT_EQ(ToResult(hci_spec::StatusCode::kInvalidHCICommandParameters), *cb_status); |
| |
| // Test infinite flush timeout (flush timeout of 0 should be sent). |
| const auto kCommandComplete = bt::testing::CommandCompletePacket( |
| hci_spec::kWriteAutomaticFlushTimeout, hci_spec::StatusCode::kSuccess); |
| EXPECT_CMD_PACKET_OUT(test_device(), |
| bt::testing::WriteAutomaticFlushTimeoutPacket(kLinkHandle, 0), |
| &kCommandComplete); |
| acl_data_channel()->SetBrEdrAutomaticFlushTimeout(zx::duration::infinite(), kLinkHandle, |
| result_cb); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(cb_status.has_value()); |
| EXPECT_EQ(fitx::ok(), *cb_status); |
| cb_status.reset(); |
| |
| // Test msec to parameter conversion (hci_spec::kMaxAutomaticFlushTimeoutDuration(1279) * |
| // conversion_factor(1.6) = 2046). |
| EXPECT_CMD_PACKET_OUT(test_device(), |
| bt::testing::WriteAutomaticFlushTimeoutPacket(kLinkHandle, 2046), |
| &kCommandComplete); |
| acl_data_channel()->SetBrEdrAutomaticFlushTimeout(hci_spec::kMaxAutomaticFlushTimeoutDuration, |
| kLinkHandle, result_cb); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(cb_status.has_value()); |
| EXPECT_EQ(fitx::ok(), *cb_status); |
| cb_status.reset(); |
| |
| // Test too large flush timeout (no command should be sent). |
| acl_data_channel()->SetBrEdrAutomaticFlushTimeout( |
| hci_spec::kMaxAutomaticFlushTimeoutDuration + zx::msec(1), kLinkHandle, result_cb); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(cb_status.has_value()); |
| EXPECT_TRUE(cb_status->is_error()); |
| EXPECT_EQ(ToResult(hci_spec::StatusCode::kInvalidHCICommandParameters), *cb_status); |
| } |
| |
| TEST_F(ACLDataChannelTest, |
| SendingLowPriorityBrEdrPacketsWhenTooManyAreQueuedDropsLeastRecentlySentPduOnSameChannel) { |
| constexpr size_t kMaxMtu = 4; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMtu, kMaxNumPackets), |
| DataBufferInfo(kMaxMtu, kMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| inspect::Inspector inspector; |
| acl_data_channel()->AttachInspect(inspector.GetRoot(), AclDataChannel::kInspectNodeName); |
| |
| // Fill up both LE and BR/EDR controller buffers |
| for (hci_spec::ConnectionHandle handle : {kHandle0, kHandle1}) { |
| for (size_t i = 0; i < kMaxNumPackets; ++i) { |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| } |
| RunLoopUntilIdle(); |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| size_t packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ASSERT_LE(sizeof(hci_spec::ACLDataHeader), bytes.size()); |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| // LE is still waiting for controller credits |
| EXPECT_EQ(kHandle1, connection_handle); |
| |
| if ((packet_count == 0) || (packet_count == 1)) { |
| // The first low-priority queued packet and its continuation packet were dropped so the first |
| // packets actually sent should be those for the second PDU |
| EXPECT_EQ(1u, packet.payload_data()[0]); |
| } |
| |
| packet_count++; |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Send enough data that the first PDU sent in this loop gets dropped |
| for (size_t i = 0; i < AclDataChannel::kMaxAclPacketsPerChannel + 1; ++i) { |
| // Send two fragments per PDU |
| LinkedList<ACLDataPacket> packets; |
| for (auto pbf : {hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLPacketBoundaryFlag::kContinuingFragment}) { |
| auto packet = |
| ACLDataPacket::New(kHandle1, pbf, hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| |
| // Write a sequence number into the payload, starting at 0 |
| packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(i); |
| packets.push_back(std::move(packet)); |
| } |
| EXPECT_TRUE(acl_data_channel()->SendPackets(std::move(packets), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| test_device()->SendCommandChannelPacket(bt::testing::NumberOfCompletedPacketsPacket(kHandle1, 2)); |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(2u, packet_count); |
| |
| using namespace ::inspect::testing; |
| auto adc_matcher = NodeMatches( |
| PropertyList(AllOf(Contains(UintIs("num_overflow_packets", packet_count)), |
| Contains(UintIs("num_recent_overflow_packets", packet_count))))); |
| |
| auto hierarchy = inspect::ReadFromVmo(inspector.DuplicateVmo()).take_value(); |
| EXPECT_THAT(hierarchy, ChildrenMatch(ElementsAre(adc_matcher))); |
| } |
| |
| TEST_F(ACLDataChannelTest, |
| SendingLowPriorityPacketsThatDropDoNotAffectDataOnSameLinkDifferentChannel) { |
| constexpr size_t kMaxMtu = 4; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr UniqueChannelId kChannelId0 = l2cap::kFirstDynamicChannelId; |
| constexpr UniqueChannelId kChannelId1 = l2cap::kFirstDynamicChannelId + 1; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMtu, kMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| |
| // Fill up controller buffers |
| for (size_t i = 0; i < kMaxNumPackets; ++i) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| RunLoopUntilIdle(); |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| size_t packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ASSERT_LT(sizeof(hci_spec::ACLDataHeader), bytes.size()); |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| |
| // The first packet should be left in the queue because it is for kChannelId0 but the second |
| // should be dropped as it was the least recently sent unsent packet for channel kChannelId1. |
| if (packet_count == 0) { |
| EXPECT_EQ(0u, packet.payload_data()[0]); |
| } else if (packet_count == 1) { |
| EXPECT_EQ(2u, packet.payload_data()[0]); |
| } |
| |
| packet_count++; |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Send one packet on kChannelId0 |
| { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| |
| // Write a sequence number into the payload, starting at 0 |
| packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(0); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), kChannelId0, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| // Send enough data on kChannel1 that the first PDU sent in this loop gets dropped |
| for (size_t i = 0; i < AclDataChannel::kMaxAclPacketsPerChannel + 1; i++) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| |
| // Write a sequence number into the payload, starting at 0 |
| packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(i + 1); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), kChannelId1, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| test_device()->SendCommandChannelPacket(bt::testing::NumberOfCompletedPacketsPacket(kHandle0, 2)); |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(2u, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, SendingLowPriorityPacketsThatDropDoNotAffectDataOnDifferentLink) { |
| constexpr size_t kMaxMtu = 4; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMtu, kMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| // Fill up controller buffers |
| for (size_t i = 0; i < kMaxNumPackets; ++i) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| RunLoopUntilIdle(); |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| size_t packet_count = 0; |
| auto data_callback = [&](const ByteBuffer& bytes) { |
| ASSERT_LT(sizeof(hci_spec::ACLDataHeader), bytes.size()); |
| PacketView<hci_spec::ACLDataHeader> packet(&bytes, |
| bytes.size() - sizeof(hci_spec::ACLDataHeader)); |
| hci_spec::ConnectionHandle connection_handle = |
| le16toh(packet.header().handle_and_flags) & 0xFFF; |
| |
| // First packet on kHandle0 doesn't get dropped, but first packet on kHandle1 does get dropped |
| // because there are too many queued for that channel on that link. |
| if (packet_count == 0) { |
| EXPECT_EQ(kHandle0, connection_handle); |
| EXPECT_EQ(0u, packet.payload_data()[0]); |
| } else if (packet_count == 1) { |
| EXPECT_EQ(kHandle1, connection_handle); |
| EXPECT_EQ(2u, packet.payload_data()[0]); |
| } |
| packet_count++; |
| }; |
| test_device()->SetDataCallback(data_callback, dispatcher()); |
| |
| // Send one data packet on kHandle0 |
| { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| |
| // Write a sequence number into the payload, starting at 0 |
| packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(0); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| // Send enough data on kHandle1 that the first PDU sent in this loop gets dropped |
| for (size_t i = 0; i < AclDataChannel::kMaxAclPacketsPerChannel + 1; i++) { |
| auto packet = ACLDataPacket::New(kHandle1, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| |
| // Write a sequence number into the payload, starting at 0 |
| packet->mutable_view()->mutable_payload_data()[0] = static_cast<uint8_t>(i + 1); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| |
| test_device()->SendCommandChannelPacket(bt::testing::NumberOfCompletedPacketsPacket(kHandle0, 2)); |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(2u, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, QueuedAclAndLePacketsAreSentUsingSeparateBufferCounts) { |
| constexpr size_t kMaxMtu = 4; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMtu, kMaxNumPackets), |
| DataBufferInfo(kMaxMtu, kMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| // Fill up both LE and BR/EDR controller buffers, leaving one additional packet in the queue of |
| // each type |
| for (hci_spec::ConnectionHandle handle : {kHandle0, kHandle1}) { |
| for (size_t i = 0; i < kMaxNumPackets + 1; ++i) { |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| } |
| RunLoopUntilIdle(); |
| |
| // Callback invoked by TestDevice when it receive a data packet from us. |
| size_t packet_count = 0; |
| test_device()->SetDataCallback([&](auto&) { packet_count++; }, dispatcher()); |
| |
| StaticByteBuffer event_buffer(0x13, 0x09, // Event header |
| 0x02, // Number of handles |
| LowerBits(kHandle0), UpperBits(kHandle0), LowerBits(uint16_t{1}), |
| UpperBits(uint16_t{1}), // 1 packets on kHandle0 |
| LowerBits(kHandle1), UpperBits(kHandle1), LowerBits(uint16_t{1}), |
| UpperBits(uint16_t{1}) // 1 packets on kHandle1 |
| ); |
| test_device()->SendCommandChannelPacket(event_buffer); |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(2u, packet_count); |
| } |
| |
| TEST_F(ACLDataChannelTest, InspectHierarchyContainsOutboundQueueState) { |
| constexpr size_t kMaxMtu = 4; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| constexpr hci_spec::ConnectionHandle kHandle1 = 0x0002; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMtu, kMaxNumPackets), |
| DataBufferInfo(kMaxMtu, kMaxNumPackets)); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kLE); |
| acl_data_channel()->RegisterLink(kHandle1, bt::LinkType::kACL); |
| |
| // Fill up both LE and BR/EDR controller buffers, leaving one additional packet in the queue of |
| // each type |
| for (hci_spec::ConnectionHandle handle : {kHandle0, kHandle1}) { |
| for (size_t i = 0; i < kMaxNumPackets + 1; ++i) { |
| auto packet = ACLDataPacket::New(handle, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| EXPECT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| } |
| RunLoopUntilIdle(); |
| |
| inspect::Inspector inspector; |
| const std::string kNodeName = "adc_node_name"; |
| acl_data_channel()->AttachInspect(inspector.GetRoot(), kNodeName); |
| |
| using namespace ::inspect::testing; |
| auto bredr_matcher = NodeMatches(AllOf( |
| NameMatches("bredr"), PropertyList(ElementsAre(UintIs("num_sent_packets", kMaxNumPackets))))); |
| |
| auto le_matcher = NodeMatches( |
| AllOf(NameMatches("le"), |
| PropertyList(UnorderedElementsAre(UintIs("num_sent_packets", kMaxNumPackets), |
| BoolIs("independent_from_bredr", true))))); |
| |
| auto send_latency_matcher = |
| NodeMatches(AllOf(NameMatches("send_latency"), |
| PropertyList(UnorderedElementsAre(IntIs("50th_percentile_us", 0), |
| IntIs("95th_percentile_us", 0), |
| IntIs("99th_percentile_us", 0))))); |
| |
| auto send_size_matcher = |
| NodeMatches(AllOf(NameMatches("send_size"), |
| PropertyList(UnorderedElementsAre(UintIs("10th_percentile_bytes", 0), |
| UintIs("50th_percentile_bytes", 0), |
| UintIs("90th_percentile_bytes", 0))))); |
| |
| auto metrics_matcher = |
| AllOf(NodeMatches(NameMatches("metrics")), |
| ChildrenMatch(UnorderedElementsAre(send_latency_matcher, send_size_matcher))); |
| |
| auto adc_matcher = AllOf( |
| NodeMatches(AllOf(NameMatches(kNodeName), |
| PropertyList(UnorderedElementsAre( |
| UintIs("num_queued_packets", 2), UintIs("num_overflow_packets", 0), |
| UintIs("num_recent_overflow_packets", 0))))), |
| ChildrenMatch(UnorderedElementsAre(bredr_matcher, le_matcher, metrics_matcher))); |
| |
| auto hierarchy = inspect::ReadFromVmo(inspector.DuplicateVmo()).take_value(); |
| EXPECT_THAT(hierarchy, ChildrenMatch(ElementsAre(adc_matcher))); |
| } |
| |
| TEST_F(ACLDataChannelTest, SendingPacketsUpdatesSendMetrics) { |
| constexpr size_t kMaxMtu = 4; |
| constexpr size_t kMaxNumPackets = 2; |
| constexpr hci_spec::ConnectionHandle kHandle0 = 0x0001; |
| |
| InitializeACLDataChannel(DataBufferInfo(kMaxMtu, kMaxNumPackets)); |
| |
| inspect::Inspector inspector; |
| acl_data_channel()->AttachInspect(inspector.GetRoot(), AclDataChannel::kInspectNodeName); |
| |
| acl_data_channel()->RegisterLink(kHandle0, bt::LinkType::kACL); |
| |
| // Fill up controller buffers |
| for (size_t i = 0; i < kMaxNumPackets; ++i) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| ASSERT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| } |
| RunLoopUntilIdle(); |
| |
| // Send enough data that metrics are exported |
| constexpr size_t kNumTestPackets = 256; |
| constexpr zx::duration kSendLatency = zx::msec(1); |
| for (size_t i = 0; i < kNumTestPackets; ++i) { |
| auto packet = ACLDataPacket::New(kHandle0, hci_spec::ACLPacketBoundaryFlag::kFirstNonFlushable, |
| hci_spec::ACLBroadcastFlag::kPointToPoint, kMaxMtu); |
| ASSERT_TRUE(acl_data_channel()->SendPacket(std::move(packet), l2cap::kFirstDynamicChannelId, |
| AclDataChannel::PacketPriority::kLow)); |
| RunLoopFor(kSendLatency); |
| test_device()->SendCommandChannelPacket( |
| bt::testing::NumberOfCompletedPacketsPacket(kHandle0, 1)); |
| RunLoopUntilIdle(); |
| } |
| |
| // Wait for the metric writing task to catch up |
| RunLoopRepeatedlyFor(zx::min(1)); |
| |
| inspect::Hierarchy hierarchy = ReadInspect(inspector); |
| const inspect::Hierarchy* const send_latency_node = |
| hierarchy.GetByPath({AclDataChannel::kInspectNodeName, "metrics", "send_latency"}); |
| ASSERT_TRUE(send_latency_node); |
| const auto* const send_latency_median_wrapped = |
| send_latency_node->node().get_property<inspect::IntPropertyValue>("50th_percentile_us"); |
| ASSERT_TRUE(send_latency_median_wrapped); |
| EXPECT_EQ(kSendLatency.to_usecs(), send_latency_median_wrapped->value()); |
| |
| const inspect::Hierarchy* const send_size_node = |
| hierarchy.GetByPath({AclDataChannel::kInspectNodeName, "metrics", "send_size"}); |
| ASSERT_TRUE(send_size_node); |
| const auto* const send_size_median_wrapped = |
| send_size_node->node().get_property<inspect::UintPropertyValue>("50th_percentile_bytes"); |
| ASSERT_TRUE(send_size_median_wrapped); |
| EXPECT_EQ(kMaxMtu, send_size_median_wrapped->value()); |
| } |
| |
| } // namespace |
| } // namespace bt::hci |
