One less copy when sending LE CoC data. am: 1c4a3f8014 (47e539cf) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_jv_api.h

+4 −10

Original line number	Diff line number	Diff line
		@@ -678,8 +678,7 @@ tBTA_JV_STATUS BTA_JvL2capReady(uint32_t handle, uint32_t* p_data_size);
		* BTA_JV_FAILURE, otherwise.
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id,
		uint8_t* p_data, uint16_t len,
		tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, BT_HDR* msg,
		uint32_t user_id);

		/*******************************************************************************
		@@ -691,15 +690,10 @@ tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id,
		* called with BTA_JV_L2CAP_WRITE_FIXED_EVT. Works for
		* fixed-channel connections
		*
		* Returns BTA_JV_SUCCESS, if the request is being processed.
		* BTA_JV_FAILURE, otherwise.
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capWriteFixed(uint16_t channel, const RawAddress& addr,
		uint32_t req_id,
		tBTA_JV_L2CAP_CBACK* p_cback,
		uint8_t* p_data, uint16_t len,
		uint32_t user_id);
		void BTA_JvL2capWriteFixed(uint16_t channel, const RawAddress& addr,
		uint32_t req_id, tBTA_JV_L2CAP_CBACK* p_cback,
		BT_HDR* msg, uint32_t user_id);

		/*******************************************************************************
		*

system/bta/jv/bta_jv_act.cc

+12 −23

Original line number	Diff line number	Diff line
		@@ -1138,8 +1138,8 @@ void bta_jv_l2cap_stop_server(uint16_t local_psm, uint32_t l2cap_socket_id) {
		}

		/* Write data to an L2CAP connection */
		void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, uint8_t* p_data,
		uint16_t len, uint32_t user_id, tBTA_JV_L2C_CB* p_cb) {
		void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, BT_HDR* msg,
		uint32_t user_id, tBTA_JV_L2C_CB* p_cb) {
		/* As we check this callback exists before the tBTA_JV_API_L2CAP_WRITE can be
		* send through the API this check should not be needed. But the API is not
		* designed to be used (safely at least) in a multi-threaded scheduler, hence
		@@ -1160,7 +1160,7 @@ void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, uint8_t* p_data,
		* channel is disconnected after the API function is called, but before the
		* message is handled. */
		LOG(ERROR) << __func__ << ": p_cb->p_cback == NULL";
		osi_free(p_data);
		osi_free(msg);
		return;
		}

		@@ -1169,24 +1169,20 @@ void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, uint8_t* p_data,
		evt_data.handle = handle;
		evt_data.req_id = req_id;
		evt_data.cong = p_cb->cong;
		evt_data.len = len;
		evt_data.len = msg->len;

		bta_jv_pm_conn_busy(p_cb->p_pm_cb);

		if (!evt_data.cong) {
		BT_HDR* msg = (BT_HDR*)osi_malloc(BT_HDR_SIZE + L2CAP_MIN_OFFSET + len +
		L2CAP_FCS_LENGTH);
		msg->offset = L2CAP_MIN_OFFSET;
		msg->len = len;
		memcpy((uint8_t*)(msg) + BT_HDR_SIZE + msg->offset, p_data, msg->len);
		// TODO: this was set only for non-fixed channel packets. Get rid of it.
		// TODO: this was set only for non-fixed channel packets. Is that needed ?
		msg->event = BT_EVT_TO_BTU_SP_DATA;

		if (evt_data.cong) {
		osi_free(msg);
		} else {
		if (GAP_ConnWriteData(handle, msg) == BT_PASS)
		evt_data.status = BTA_JV_SUCCESS;
		}

		osi_free(p_data);

		tBTA_JV bta_jv;
		bta_jv.l2c_write = evt_data;
		p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, &bta_jv, user_id);
		@@ -1194,8 +1190,8 @@ void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, uint8_t* p_data,

		/* Write data to an L2CAP connection using Fixed channels */
		void bta_jv_l2cap_write_fixed(uint16_t channel, const RawAddress& addr,
		uint32_t req_id, uint8_t* p_data, uint16_t len,
		uint32_t user_id, tBTA_JV_L2CAP_CBACK* p_cback) {
		uint32_t req_id, BT_HDR* msg, uint32_t user_id,
		tBTA_JV_L2CAP_CBACK* p_cback) {
		tBTA_JV_L2CAP_WRITE_FIXED evt_data;
		evt_data.status = BTA_JV_FAILURE;
		evt_data.channel = channel;
		@@ -1203,13 +1199,6 @@ void bta_jv_l2cap_write_fixed(uint16_t channel, const RawAddress& addr,
		evt_data.req_id = req_id;
		evt_data.len = 0;

		BT_HDR* msg = (BT_HDR*)osi_malloc(sizeof(BT_HDR) + len + L2CAP_MIN_OFFSET);
		msg->offset = L2CAP_MIN_OFFSET;
		msg->len = len;
		memcpy((uint8_t*)(msg) + BT_HDR_SIZE + msg->offset, p_data, msg->len);

		osi_free(p_data);

		L2CA_SendFixedChnlData(channel, addr, msg);

		tBTA_JV bta_jv;

system/bta/jv/bta_jv_api.cc

+8 −15

Original line number	Diff line number	Diff line
		@@ -514,18 +514,17 @@ tBTA_JV_STATUS BTA_JvL2capReady(uint32_t handle, uint32_t* p_data_size) {
		* BTA_JV_FAILURE, otherwise.
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id,
		uint8_t* p_data, uint16_t len,
		tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id, BT_HDR* msg,
		uint32_t user_id) {
		VLOG(2) << __func__;

		if (handle >= BTA_JV_MAX_L2C_CONN \|\| !bta_jv_cb.l2c_cb[handle].p_cback) {
		osi_free(p_data);
		osi_free(msg);
		return BTA_JV_FAILURE;
		}

		do_in_bta_thread(FROM_HERE, Bind(&bta_jv_l2cap_write, handle, req_id, p_data,
		len, user_id, &bta_jv_cb.l2c_cb[handle]));
		do_in_bta_thread(FROM_HERE, Bind(&bta_jv_l2cap_write, handle, req_id, msg,
		user_id, &bta_jv_cb.l2c_cb[handle]));
		return BTA_JV_SUCCESS;
		}

		@@ -539,20 +538,14 @@ tBTA_JV_STATUS BTA_JvL2capWrite(uint32_t handle, uint32_t req_id,
		* fixed-channel connections. This function takes ownership of
		* p_data, and will osi_free it.
		*
		* Returns BTA_JV_SUCCESS, if the request is being processed.
		* BTA_JV_FAILURE, otherwise.
		*
		******************************************************************************/
		tBTA_JV_STATUS BTA_JvL2capWriteFixed(uint16_t channel, const RawAddress& addr,
		uint32_t req_id,
		tBTA_JV_L2CAP_CBACK* p_cback,
		uint8_t* p_data, uint16_t len,
		uint32_t user_id) {
		void BTA_JvL2capWriteFixed(uint16_t channel, const RawAddress& addr,
		uint32_t req_id, tBTA_JV_L2CAP_CBACK* p_cback,
		BT_HDR* msg, uint32_t user_id) {
		VLOG(2) << __func__;

		do_in_bta_thread(FROM_HERE, Bind(&bta_jv_l2cap_write_fixed, channel, addr,
		req_id, p_data, len, user_id, p_cback));
		return BTA_JV_SUCCESS;
		req_id, msg, user_id, p_cback));
		}

		/*******************************************************************************

system/bta/jv/bta_jv_int.h

+4 −5

Original line number	Diff line number	Diff line
		@@ -166,9 +166,8 @@ extern void bta_jv_l2cap_start_server(
		uint32_t l2cap_socket_id);
		extern void bta_jv_l2cap_stop_server(uint16_t local_psm,
		uint32_t l2cap_socket_id);
		extern void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id,
		uint8_t* p_data, uint16_t len, uint32_t user_id,
		tBTA_JV_L2C_CB* p_cb);
		extern void bta_jv_l2cap_write(uint32_t handle, uint32_t req_id, BT_HDR* msg,
		uint32_t user_id, tBTA_JV_L2C_CB* p_cb);
		extern void bta_jv_rfcomm_connect(tBTA_SEC sec_mask, tBTA_JV_ROLE role,
		uint8_t remote_scn,
		const RawAddress& peer_bd_addr,
		@@ -193,8 +192,8 @@ extern void bta_jv_l2cap_start_server_le(uint16_t local_chan,
		uint32_t l2cap_socket_id);
		extern void bta_jv_l2cap_stop_server_le(uint16_t local_chan);
		extern void bta_jv_l2cap_write_fixed(uint16_t channel, const RawAddress& addr,
		uint32_t req_id, uint8_t* p_data,
		uint16_t len, uint32_t user_id,
		uint32_t req_id, BT_HDR* msg,
		uint32_t user_id,
		tBTA_JV_L2CAP_CBACK* p_cback);
		extern void bta_jv_l2cap_close_fixed(uint32_t handle);

system/btif/src/btif_sock_l2cap.cc

+17 −5

Original line number	Diff line number	Diff line
		@@ -961,6 +961,19 @@ static bool flush_incoming_que_on_wr_signal_l(l2cap_socket* sock) {
		return false;
		}

		inline BT_HDR* malloc_l2cap_buf(uint16_t len) {
		// We need FCS only for L2CAP_FCR_ERTM_MODE, but it's just 2 bytes so it's ok
		BT_HDR* msg = (BT_HDR*)osi_malloc(BT_HDR_SIZE + L2CAP_MIN_OFFSET + len +
		L2CAP_FCS_LENGTH);
		msg->offset = L2CAP_MIN_OFFSET;
		msg->len = len;
		return msg;
		}

		inline uint8_t* get_l2cap_sdu_start_ptr(BT_HDR* msg) {
		return (uint8_t*)(msg) + BT_HDR_SIZE + msg->offset;
		}

		void btsock_l2cap_signaled(int fd, int flags, uint32_t user_id) {
		char drop_it = false;

		@@ -984,11 +997,11 @@ void btsock_l2cap_signaled(int fd, int flags, uint32_t user_id) {
		by BT spec). */
		size = std::min(size, (int)sock->mps);

		uint8_t* buffer = (uint8_t*)osi_malloc(size);
		BT_HDR* buffer = malloc_l2cap_buf(size);
		/* The socket is created with SOCK_SEQPACKET, hence we read one message
		* at the time. */
		ssize_t count;
		OSI_NO_INTR(count = recv(fd, buffer, size,
		OSI_NO_INTR(count = recv(fd, get_l2cap_sdu_start_ptr(buffer), size,
		MSG_NOSIGNAL \| MSG_DONTWAIT \| MSG_TRUNC));
		if (count > L2CAP_LE_MAX_MPS) {
		/* This can't happen thanks to check in BluetoothSocket.java but leave
		@@ -1002,11 +1015,10 @@ void btsock_l2cap_signaled(int fd, int flags, uint32_t user_id) {
		if (sock->fixed_chan) {
		// will take care of freeing buffer
		BTA_JvL2capWriteFixed(sock->channel, sock->addr, PTR_TO_UINT(buffer),
		btsock_l2cap_cbk, buffer, count, user_id);
		btsock_l2cap_cbk, buffer, user_id);
		} else {
		// will take care of freeing buffer
		BTA_JvL2capWrite(sock->handle, PTR_TO_UINT(buffer), buffer, count,
		user_id);
		BTA_JvL2capWrite(sock->handle, PTR_TO_UINT(buffer), buffer, user_id);
		}
		}
		} else