Merge "ProfileConnectionFailureReason: Log HIDD and HIDH failures with counter metrics" (1cc672ee) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/hd/bta_hd_act.cc

+6 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		* This file contains the HID device action functions.
		*
		******************************************************************************/
		#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>

		#include <cstdint>
		#include <string>
		@@ -32,6 +33,7 @@

		#include "bta/hd/bta_hd_int.h"
		#include "include/hardware/bt_hd.h"
		#include "main/shim/metrics_api.h"
		#include "osi/include/allocator.h"
		#include "osi/include/log.h"
		#include "stack/include/bt_hdr.h"
		@@ -172,6 +174,10 @@ void bta_hd_register_act(tBTA_HD_DATA* p_data) {
		APPL_TRACE_ERROR("%s: Descriptor is too long or malformed", __func__);
		ret.reg_status.status = BTA_HD_ERROR;
		(*bta_hd_cb.p_cback)(BTA_HD_REGISTER_APP_EVT, &ret);
		bluetooth::shim::CountCounterMetrics(
		android::bluetooth::CodePathCounterKeyEnum::
		HIDD_REGISTER_DESCRIPTOR_MALFORMED,
		1);
		return;
		}

system/stack/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -912,6 +912,7 @@ cc_test {
		":TestMockStackL2cap",
		":TestMockStackSdp",
		":TestMockStackBtm",
		":TestMockStackMetrics",
		":TestStubLegacyTrace",
		"hid/hidd_api.cc",
		"hid/hidd_conn.cc",

system/stack/hid/hidd_api.cc

+57 −5

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@

		#include "hidd_api.h"

		#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		@@ -35,6 +36,7 @@
		#include "osi/include/allocator.h"
		#include "stack/btm/btm_sec.h"
		#include "stack/include/bt_types.h"
		#include "stack/include/stack_metrics_logging.h"
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		@@ -89,9 +91,19 @@ tHID_STATUS HID_DevRegister(tHID_DEV_HOST_CALLBACK* host_cback) {

		HIDD_TRACE_API("%s", __func__);

		if (hd_cb.reg_flag) return HID_ERR_ALREADY_REGISTERED;
		if (hd_cb.reg_flag) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_ALREADY_REGISTERED,
		1);
		return HID_ERR_ALREADY_REGISTERED;
		}

		if (host_cback == NULL) return HID_ERR_INVALID_PARAM;
		if (host_cback == NULL) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_HOST_CALLBACK_NULL,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		/* Register with L2CAP */
		st = hidd_conn_reg();
		@@ -120,7 +132,12 @@ tHID_STATUS HID_DevRegister(tHID_DEV_HOST_CALLBACK* host_cback) {
		tHID_STATUS HID_DevDeregister(void) {
		HIDD_TRACE_API("%s", __func__);

		if (!hd_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);
		if (!hd_cb.reg_flag) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_AT_DEREGISTER,
		1);
		return (HID_ERR_NOT_REGISTERED);
		}

		hidd_conn_dereg();

		@@ -256,6 +273,10 @@ tHID_STATUS HID_DevAddRecord(uint32_t handle, char* p_name, char* p_description,
		if (desc_len > HIDD_APP_DESCRIPTOR_LEN) {
		HIDD_TRACE_ERROR("%s: descriptor length = %d, larger than max %d",
		__func__, desc_len, HIDD_APP_DESCRIPTOR_LEN);
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_DUE_TO_DESCRIPTOR_LENGTH,
		1);
		return HID_ERR_NOT_REGISTERED;
		};

		@@ -264,6 +285,10 @@ tHID_STATUS HID_DevAddRecord(uint32_t handle, char* p_name, char* p_description,
		if (p_buf == NULL) {
		HIDD_TRACE_ERROR("%s: Buffer allocation failure for size = 2048 ",
		__func__);
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_DUE_TO_BUFFER_ALLOCATION,
		1);
		return HID_ERR_NOT_REGISTERED;
		}

		@@ -328,7 +353,9 @@ tHID_STATUS HID_DevAddRecord(uint32_t handle, char* p_name, char* p_description,

		if (!result) {
		HIDD_TRACE_ERROR("%s: failed to complete SDP record", __func__);

		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_AT_SDP,
		1);
		return HID_ERR_NOT_REGISTERED;
		}

		@@ -359,7 +386,9 @@ tHID_STATUS HID_DevSendReport(uint8_t channel, uint8_t type, uint8_t id,
		return hidd_conn_send_data(HID_CHANNEL_INTR, HID_TRANS_DATA,
		HID_PAR_REP_TYPE_INPUT, id, len, p_data);
		}

		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_INVALID_PARAM_SEND_REPORT,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		@@ -426,14 +455,22 @@ tHID_STATUS HID_DevUnplugDevice(const RawAddress& addr) {
		******************************************************************************/
		tHID_STATUS HID_DevConnect(void) {
		if (!hd_cb.reg_flag) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_AT_CONNECT,
		1);
		return HID_ERR_NOT_REGISTERED;
		}

		if (!hd_cb.device.in_use) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_DEVICE_NOT_IN_USE_AT_CONNECT,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		if (hd_cb.device.state != HIDD_DEV_NO_CONN) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_ALREADY_CONN, 1);
		return HID_ERR_ALREADY_CONN;
		}

		@@ -451,10 +488,16 @@ tHID_STATUS HID_DevConnect(void) {
		******************************************************************************/
		tHID_STATUS HID_DevDisconnect(void) {
		if (!hd_cb.reg_flag) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_AT_DISCONNECT,
		1);
		return HID_ERR_NOT_REGISTERED;
		}

		if (!hd_cb.device.in_use) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_DEVICE_NOT_IN_USE_AT_DISCONNECT,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		@@ -465,8 +508,14 @@ tHID_STATUS HID_DevDisconnect(void) {
		hd_cb.device.conn.conn_state = HID_CONN_STATE_UNUSED;
		hd_cb.callback(hd_cb.device.addr, HID_DHOST_EVT_CLOSE,
		HID_ERR_DISCONNECTING, NULL);
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_DISCONNECTING,
		1);
		return ret;
		}
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NO_CONNECTION_AT_DISCONNECT,
		1);
		return HID_ERR_NO_CONNECTION;
		}

		@@ -536,6 +585,9 @@ tHID_STATUS HID_DevGetDevice(RawAddress* addr) {
		if (hd_cb.device.in_use) {
		*addr = hd_cb.device.addr;
		} else {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_AT_GET_DEVICE,
		1);
		return HID_ERR_NOT_REGISTERED;
		}

system/stack/hid/hidd_conn.cc

+42 −5

Original line number	Diff line number	Diff line
		@@ -23,6 +23,9 @@
		*
		******************************************************************************/

		#include <base/logging.h>
		#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>

		#include <cstdint>

		#include "bta/include/bta_api.h"
		@@ -31,10 +34,9 @@
		#include "stack/hid/hidd_int.h"
		#include "stack/include/bt_hdr.h"
		#include "stack/include/bt_types.h"
		#include "stack/include/stack_metrics_logging.h"
		#include "types/raw_address.h"

		#include <base/logging.h>

		static void hidd_l2cif_connect_ind(const RawAddress& bd_addr, uint16_t cid,
		uint16_t psm, uint8_t id);
		static void hidd_l2cif_connect_cfm(uint16_t cid, uint16_t result);
		@@ -288,6 +290,9 @@ static void hidd_l2cif_config_cfm(uint16_t cid, uint16_t initiator,
		__func__);
		hd_cb.callback(hd_cb.device.addr, HID_DHOST_EVT_CLOSE,
		HID_ERR_L2CAP_FAILED, NULL);
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_L2CAP_NOT_STARTED_INCOMING,
		1);
		return;
		} else {
		p_hcon->conn_state = HID_CONN_STATE_CONNECTING_INTR;
		@@ -574,6 +579,9 @@ tHID_STATUS hidd_conn_reg(void) {
		nullptr, HID_DEV_MTU_SIZE, 0,
		BTA_SEC_AUTHENTICATE \| BTA_SEC_ENCRYPT)) {
		HIDD_TRACE_ERROR("HID Control (device) registration failed");
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_L2CAP_FAILED_CONTROL,
		1);
		return (HID_ERR_L2CAP_FAILED);
		}

		@@ -582,6 +590,9 @@ tHID_STATUS hidd_conn_reg(void) {
		BTA_SEC_AUTHENTICATE \| BTA_SEC_ENCRYPT)) {
		L2CA_Deregister(HID_PSM_CONTROL);
		HIDD_TRACE_ERROR("HID Interrupt (device) registration failed");
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_L2CAP_FAILED_INTERRUPT,
		1);
		return (HID_ERR_L2CAP_FAILED);
		}

		@@ -620,11 +631,17 @@ tHID_STATUS hidd_conn_initiate(void) {

		if (!p_dev->in_use) {
		HIDD_TRACE_WARNING("%s: no virtual cable established", __func__);
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NOT_REGISTERED_AT_INITIATE,
		1);
		return (HID_ERR_NOT_REGISTERED);
		}

		if (p_dev->conn.conn_state != HID_CONN_STATE_UNUSED) {
		HIDD_TRACE_WARNING("%s: connection already in progress", __func__);
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_CONN_IN_PROCESS,
		1);
		return (HID_ERR_CONN_IN_PROCESS);
		}

		@@ -641,6 +658,9 @@ tHID_STATUS hidd_conn_initiate(void) {
		HIDD_TRACE_WARNING("%s: could not start L2CAP connection", __func__);
		hd_cb.callback(hd_cb.device.addr, HID_DHOST_EVT_CLOSE, HID_ERR_L2CAP_FAILED,
		NULL);
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_L2CAP_FAILED_INITIATE,
		1);
		} else {
		p_dev->conn.conn_state = HID_CONN_STATE_CONNECTING_CTRL;
		}
		@@ -712,6 +732,9 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type,
		tHID_CONN* p_hcon = &hd_cb.device.conn;

		if (p_hcon->conn_flags & HID_CONN_FLAGS_CONGESTED) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_CONGESTED_AT_FLAG_CHECK,
		1);
		return HID_ERR_CONGESTED;
		}

		@@ -731,11 +754,18 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type,
		}
		break;
		default:
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_INVALID_PARAM,
		1);
		return (HID_ERR_INVALID_PARAM);
		}

		p_buf = (BT_HDR*)osi_malloc(buf_size);
		if (p_buf == NULL) return (HID_ERR_NO_RESOURCES);
		if (p_buf == NULL) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDD_ERR_NO_RESOURCES, 1);
		return (HID_ERR_NO_RESOURCES);
		}

		p_buf->offset = L2CAP_MIN_OFFSET;

		@@ -775,7 +805,9 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type,

		return HID_SUCCESS;
		}

		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_NO_CONNECTION_AT_SEND_DATA,
		1);
		return HID_ERR_NO_CONNECTION;
		}

		@@ -786,7 +818,12 @@ tHID_STATUS hidd_conn_send_data(uint8_t channel, uint8_t msg_type,
		#endif
		HIDD_TRACE_VERBOSE("%s: report sent", __func__);

		if (!L2CA_DataWrite(cid, p_buf)) return (HID_ERR_CONGESTED);
		if (!L2CA_DataWrite(cid, p_buf)) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDD_ERR_CONGESTED_AT_DATA_WRITE,
		1);
		return (HID_ERR_CONGESTED);
		}

		return (HID_SUCCESS);
		}

system/stack/hid/hidh_api.cc

+59 −11

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@

		#include "hidh_api.h"

		#include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		@@ -35,6 +36,7 @@
		#include "stack/btm/btm_dev.h"
		#include "stack/btm/btm_sec.h"
		#include "stack/include/bt_hdr.h"
		#include "stack/include/stack_metrics_logging.h"
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		@@ -56,8 +58,11 @@ static void hidh_search_callback(tSDP_RESULT sdp_result);
		tHID_STATUS HID_HostGetSDPRecord(const RawAddress& addr,
		tSDP_DISCOVERY_DB* p_db, uint32_t db_len,
		tHID_HOST_SDP_CALLBACK* sdp_cback) {

		if (hh_cb.sdp_busy) return HID_ERR_SDP_BUSY;
		if (hh_cb.sdp_busy) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_SDP_BUSY, 1);
		return HID_ERR_SDP_BUSY;
		}

		hh_cb.p_sdp_db = p_db;
		Uuid uuid_list = Uuid::From16Bit(UUID_SERVCLASS_HUMAN_INTERFACE);
		@@ -67,9 +72,13 @@ tHID_STATUS HID_HostGetSDPRecord(const RawAddress& addr,
		hh_cb.sdp_cback = sdp_cback;
		hh_cb.sdp_busy = true;
		return HID_SUCCESS;
		} else
		} else {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_NO_RESOURCES_SDP,
		1);
		return HID_ERR_NO_RESOURCES;
		}
		}

		void hidh_get_str_attr(tSDP_DISC_REC* p_rec, uint16_t attr_id, uint16_t max_len,
		char* str) {
		@@ -263,9 +272,19 @@ uint8_t HID_HostSetTraceLevel(uint8_t new_level) {
		tHID_STATUS HID_HostRegister(tHID_HOST_DEV_CALLBACK* dev_cback) {
		tHID_STATUS st;

		if (hh_cb.reg_flag) return HID_ERR_ALREADY_REGISTERED;
		if (hh_cb.reg_flag) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_ALREADY_REGISTERED,
		1);
		return HID_ERR_ALREADY_REGISTERED;
		}

		if (dev_cback == NULL) return HID_ERR_INVALID_PARAM;
		if (dev_cback == NULL) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_INVALID_PARAM_AT_HOST_REGISTER,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		/* Register with L2CAP */
		st = hidh_conn_reg();
		@@ -333,7 +352,12 @@ tHID_STATUS HID_HostAddDev(const RawAddress& addr, uint16_t attr_mask,
		}
		}

		if (i == HID_HOST_MAX_DEVICES) return HID_ERR_NO_RESOURCES;
		if (i == HID_HOST_MAX_DEVICES) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_NO_RESOURCES_ADD_DEVICE,
		1);
		return HID_ERR_NO_RESOURCES;
		}

		if (!hh_cb.devices[i].in_use) {
		hh_cb.devices[i].in_use = true;
		@@ -363,8 +387,12 @@ tHID_STATUS HID_HostRemoveDev(uint8_t dev_handle) {
		if (!hh_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);

		if ((dev_handle >= HID_HOST_MAX_DEVICES) \|\|
		(!hh_cb.devices[dev_handle].in_use))
		(!hh_cb.devices[dev_handle].in_use)) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_INVALID_PARAM_AT_HOST_REMOVE_DEV,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		HID_HostCloseDev(dev_handle);
		hh_cb.devices[dev_handle].in_use = false;
		@@ -390,10 +418,16 @@ tHID_STATUS HID_HostOpenDev(uint8_t dev_handle) {

		if ((dev_handle >= HID_HOST_MAX_DEVICES) \|\|
		(!hh_cb.devices[dev_handle].in_use))
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_INVALID_PARAM_AT_HOST_OPEN_DEV,
		1);
		return HID_ERR_INVALID_PARAM;

		if (hh_cb.devices[dev_handle].state != HID_DEV_NO_CONN)
		if (hh_cb.devices[dev_handle].state != HID_DEV_NO_CONN) {
		log_counter_metrics(
		android::bluetooth::CodePathCounterKeyEnum::HIDH_ERR_ALREADY_CONN, 1);
		return HID_ERR_ALREADY_CONN;
		}

		hh_cb.devices[dev_handle].conn_tries = 1;
		return hidh_conn_initiate(dev_handle);
		@@ -423,11 +457,17 @@ tHID_STATUS HID_HostWriteDev(uint8_t dev_handle, uint8_t t_type, uint8_t param,
		if ((dev_handle >= HID_HOST_MAX_DEVICES) \|\|
		(!hh_cb.devices[dev_handle].in_use)) {
		HIDH_TRACE_ERROR("HID_ERR_INVALID_PARAM");
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_INVALID_PARAM_AT_HOST_WRITE_DEV,
		1);
		status = HID_ERR_INVALID_PARAM;
		}

		else if (hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED) {
		HIDH_TRACE_ERROR("HID_ERR_NO_CONNECTION dev_handle %d", dev_handle);
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_NO_CONNECTION_AT_HOST_WRITE_DEV,
		1);
		status = HID_ERR_NO_CONNECTION;
		}

		@@ -453,11 +493,19 @@ tHID_STATUS HID_HostCloseDev(uint8_t dev_handle) {
		if (!hh_cb.reg_flag) return (HID_ERR_NOT_REGISTERED);

		if ((dev_handle >= HID_HOST_MAX_DEVICES) \|\|
		(!hh_cb.devices[dev_handle].in_use))
		(!hh_cb.devices[dev_handle].in_use)) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_INVALID_PARAM_AT_HOST_CLOSE_DEV,
		1);
		return HID_ERR_INVALID_PARAM;
		}

		if (hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED)
		if (hh_cb.devices[dev_handle].state != HID_DEV_CONNECTED) {
		log_counter_metrics(android::bluetooth::CodePathCounterKeyEnum::
		HIDH_ERR_NO_CONNECTION_AT_HOST_CLOSE_DEV,
		1);
		return HID_ERR_NO_CONNECTION;
		}

		alarm_cancel(hh_cb.devices[dev_handle].conn.process_repage_timer);
		hh_cb.devices[dev_handle].conn_tries = HID_HOST_MAX_CONN_RETRY + 1;