Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 94a5e7f7 authored by Michael Sun's avatar Michael Sun Committed by Automerger Merge Worker
Browse files

Merge "btaa: fix static packed BtaaHciPacket struct" am: d6a2bfdf 

Original change: https://android-review.googlesource.com/c/platform/system/bt/+/1694045

Change-Id: Iaa2309c5371be5122bbebbcd386626e2cdf30d78
parents e60acd87 d6a2bfdf

system/gd/btaa/hci_processor.h

+47 −1
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#pragma once



#include "btaa/activity_attribution.h"

#include "btaa/cmd_evt_classification.h"

#include "hal/snoop_logger.h"

#include "hci/address.h"
@@ -27,14 +28,59 @@ struct BtaaHciPacket { 
  Activity activity;

  hci::Address address;

  uint16_t byte_count;



  BtaaHciPacket() {}

  BtaaHciPacket(Activity activity, hci::Address address, uint16_t byte_count)

      : activity(activity), address(address), byte_count(byte_count) {}

} __attribute__((__packed__));

};



class DeviceParser {

 public:

  void match_handle_with_address(uint16_t connection_handle, hci::Address& address);



 private:

  std::map<uint16_t, hci::Address> connection_lookup_table_;

};



struct PendingCommand {

  hci::OpCode opcode;

  BtaaHciPacket btaa_hci_packet;

};



class HciProcessor {

 public:

  std::vector<BtaaHciPacket> OnHciPacket(hal::HciPacket packet, hal::SnoopLogger::PacketType type, uint16_t length);



 private:

  void process_le_event(std::vector<BtaaHciPacket>& btaa_hci_packets, int16_t byte_count, hci::EventView& event);

  void process_special_event(

      std::vector<BtaaHciPacket>& btaa_hci_packets,

      hci::EventCode event_code,

      uint16_t byte_count,

      hci::EventView& event);

  void process_command(

      std::vector<BtaaHciPacket>& btaa_hci_packets,

      packet::PacketView<packet::kLittleEndian>& packet_view,

      uint16_t byte_count);

  void process_event(

      std::vector<BtaaHciPacket>& btaa_hci_packets,

      packet::PacketView<packet::kLittleEndian>& packet_view,

      uint16_t byte_count);

  void process_acl(

      std::vector<BtaaHciPacket>& btaa_hci_packets,

      packet::PacketView<packet::kLittleEndian>& packet_view,

      uint16_t byte_count);

  void process_sco(

      std::vector<BtaaHciPacket>& btaa_hci_packets,

      packet::PacketView<packet::kLittleEndian>& packet_view,

      uint16_t byte_count);

  void process_iso(

      std::vector<BtaaHciPacket>& btaa_hci_packets,

      packet::PacketView<packet::kLittleEndian>& packet_view,

      uint16_t byte_count);



  DeviceParser device_parser_;

  PendingCommand pending_command_;

};



}  // namespace activity_attribution

system/gd/btaa/linux_generic/hci_processor.cc

+30 −44
Original line number Diff line number Diff line
@@ -16,37 +16,23 @@ 


#include "btaa/hci_processor.h"



#include "btaa/cmd_evt_classification.h"

#include "os/log.h"



namespace bluetooth {

namespace activity_attribution {



class DeviceParser {

 public:

  void match_handle_with_address(uint16_t connection_handle, hci::Address& address) {

void DeviceParser::match_handle_with_address(uint16_t connection_handle, hci::Address& address) {

  if (connection_handle && !address.IsEmpty()) {

      connection_lookup_table[connection_handle] = address;

    connection_lookup_table_[connection_handle] = address;

  } else if (connection_handle) {

      if (connection_lookup_table.find(connection_handle) != connection_lookup_table.end()) {

        address = connection_lookup_table[connection_handle];

    if (connection_lookup_table_.find(connection_handle) != connection_lookup_table_.end()) {

      address = connection_lookup_table_[connection_handle];

    }

  }

}



 private:

  std::map<uint16_t, hci::Address> connection_lookup_table;

};



struct PendingCommand {

  hci::OpCode opcode;

  BtaaHciPacket btaa_hci_packet;

};



static DeviceParser device_parser;

static PendingCommand pending_command;



static void process_le_event(std::vector<BtaaHciPacket>& btaa_hci_packets, int16_t byte_count, hci::EventView& event) {

void HciProcessor::process_le_event(

    std::vector<BtaaHciPacket>& btaa_hci_packets, int16_t byte_count, hci::EventView& event) {

  uint16_t connection_handle_value = 0;

  hci::Address address_value;
@@ -68,12 +54,12 @@ static void process_le_event(std::vector<BtaaHciPacket>& btaa_hci_packets, int16 
      auto address_value_it = event.begin() + le_event_info.address_pos;

      address_value = address_value_it.extract<hci::Address>();

    }

    device_parser.match_handle_with_address(connection_handle_value, address_value);

    device_parser_.match_handle_with_address(connection_handle_value, address_value);

    btaa_hci_packets.push_back(BtaaHciPacket(le_event_info.activity, address_value, byte_count));

  }

}



static void process_special_event(

void HciProcessor::process_special_event(

    std::vector<BtaaHciPacket>& btaa_hci_packets,

    hci::EventCode event_code,

    uint16_t byte_count,
@@ -103,7 +89,7 @@ static void process_special_event( 
      auto completed_packets = packet_view.GetCompletedPackets();

      avg_byte_count = byte_count / completed_packets.size();

      for (auto& completed_packet : completed_packets) {

        device_parser.match_handle_with_address(completed_packet.connection_handle_, address_value);

        device_parser_.match_handle_with_address(completed_packet.connection_handle_, address_value);

        btaa_hci_packets.push_back(BtaaHciPacket(Activity::CONNECT, address_value, avg_byte_count));

      }

    } break;
@@ -126,7 +112,7 @@ static void process_special_event( 
  }

}



static void process_command(

void HciProcessor::process_command(

    std::vector<BtaaHciPacket>& btaa_hci_packets,

    packet::PacketView<packet::kLittleEndian>& packet_view,

    uint16_t byte_count) {
@@ -148,13 +134,13 @@ static void process_command( 
    auto address_value_it = command.begin() + cmd_info.address_pos;

    address_value = address_value_it.extract<hci::Address>();

  }

  device_parser.match_handle_with_address(connection_handle_value, address_value);

  pending_command.btaa_hci_packet = BtaaHciPacket(cmd_info.activity, address_value, byte_count);

  device_parser_.match_handle_with_address(connection_handle_value, address_value);

  pending_command_.btaa_hci_packet = BtaaHciPacket(cmd_info.activity, address_value, byte_count);



  pending_command.opcode = opcode;

  pending_command_.opcode = opcode;

}



static void process_event(

void HciProcessor::process_event(

    std::vector<BtaaHciPacket>& btaa_hci_packets,

    packet::PacketView<packet::kLittleEndian>& packet_view,

    uint16_t byte_count) {
@@ -178,25 +164,25 @@ static void process_event( 
      auto address_value_it = event.begin() + event_info.address_pos;

      address_value = address_value_it.extract<hci::Address>();

    }

    device_parser.match_handle_with_address(connection_handle_value, address_value);

    device_parser_.match_handle_with_address(connection_handle_value, address_value);

    btaa_hci_packets.push_back(BtaaHciPacket(event_info.activity, address_value, byte_count));

  } else {

    // The event requires additional processing.

    switch (event_code) {

      case hci::EventCode::COMMAND_COMPLETE: {

        auto packet_view = hci::CommandCompleteView::Create(event);

        if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command.opcode) {

          pending_command.btaa_hci_packet.byte_count += byte_count;

          btaa_hci_packets.push_back(std::move(pending_command.btaa_hci_packet));

        if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command_.opcode) {

          pending_command_.btaa_hci_packet.byte_count += byte_count;

          btaa_hci_packets.push_back(std::move(pending_command_.btaa_hci_packet));

        } else {

          btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));

        }

      } break;

      case hci::EventCode::COMMAND_STATUS: {

        auto packet_view = hci::CommandStatusView::Create(event);

        if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command.opcode) {

          pending_command.btaa_hci_packet.byte_count += byte_count;

          btaa_hci_packets.push_back(std::move(pending_command.btaa_hci_packet));

        if (packet_view.IsValid() && packet_view.GetCommandOpCode() == pending_command_.opcode) {

          pending_command_.btaa_hci_packet.byte_count += byte_count;

          btaa_hci_packets.push_back(std::move(pending_command_.btaa_hci_packet));

        } else {

          btaa_hci_packets.push_back(BtaaHciPacket(Activity::UNKNOWN, address_value, byte_count));

        }
@@ -215,7 +201,7 @@ static void process_event( 
  }

}



static void process_acl(

void HciProcessor::process_acl(

    std::vector<BtaaHciPacket>& btaa_hci_packets,

    packet::PacketView<packet::kLittleEndian>& packet_view,

    uint16_t byte_count) {
@@ -224,11 +210,11 @@ static void process_acl( 
  // Connection handle is extracted from the 12 least significant bit.

  uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;

  hci::Address address_value;

  device_parser.match_handle_with_address(connection_handle_value, address_value);

  device_parser_.match_handle_with_address(connection_handle_value, address_value);

  btaa_hci_packets.push_back(BtaaHciPacket(Activity::ACL, address_value, byte_count));

}



static void process_sco(

void HciProcessor::process_sco(

    std::vector<BtaaHciPacket>& btaa_hci_packets,

    packet::PacketView<packet::kLittleEndian>& packet_view,

    uint16_t byte_count) {
@@ -237,11 +223,11 @@ static void process_sco( 
  // Connection handle is extracted from the 12 least significant bit.

  uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;

  hci::Address address_value;

  device_parser.match_handle_with_address(connection_handle_value, address_value);

  device_parser_.match_handle_with_address(connection_handle_value, address_value);

  btaa_hci_packets.push_back(BtaaHciPacket(Activity::HFP, address_value, byte_count));

}



static void process_iso(

void HciProcessor::process_iso(

    std::vector<BtaaHciPacket>& btaa_hci_packets,

    packet::PacketView<packet::kLittleEndian>& packet_view,

    uint16_t byte_count) {
@@ -250,7 +236,7 @@ static void process_iso( 
  // Connection handle is extracted from the 12 least significant bit.

  uint16_t connection_handle_value = connection_handle.extract<uint16_t>() & 0xfff;

  hci::Address address_value;

  device_parser.match_handle_with_address(connection_handle_value, address_value);

  device_parser_.match_handle_with_address(connection_handle_value, address_value);

  btaa_hci_packets.push_back(BtaaHciPacket(Activity::ISO, address_value, byte_count));

}