Commit cba6b758 authored by Luiz Augusto von Dentz's avatar Luiz Augusto von Dentz Committed by Marcel Holtmann
Browse files

Bluetooth: hci_sync: Make use of hci_cmd_sync_queue set 2 



This make use of hci_cmd_sync_queue for the following MGMT commands:

Add Advertising
Remove Advertising
Add Extended Advertising Parameters
Add Extended Advertising Data

mgmt-tester -s "Add Advertising"

Test Summary
------------
Add Advertising - Failure: LE off                    Passed
Add Advertising - Invalid Params 1 (AD too long)     Passed
Add Advertising - Invalid Params 2 (Malformed len)   Passed
Add Advertising - Invalid Params 3 (Malformed len)   Passed
Add Advertising - Invalid Params 4 (Malformed len)   Passed
Add Advertising - Invalid Params 5 (AD too long)     Passed
Add Advertising - Invalid Params 6 (ScRsp too long)  Passed
Add Advertising - Invalid Params 7 (Malformed len)   Passed
Add Advertising - Invalid Params 8 (Malformed len)   Passed
Add Advertising - Invalid Params 9 (Malformed len)   Passed
Add Advertising - Invalid Params 10 (ScRsp too long) Passed
Add Advertising - Rejected (Timeout, !Powered)       Passed
Add Advertising - Success 1 (Powered, Add Adv Inst)  Passed
Add Advertising - Success 2 (!Powered, Add Adv Inst) Passed
Add Advertising - Success 3 (!Powered, Adv Enable)   Passed
Add Advertising - Success 4 (Set Adv on override)    Passed
Add Advertising - Success 5 (Set Adv off override)   Passed
Add Advertising - Success 6 (Scan Rsp Dta, Adv ok)   Passed
Add Advertising - Success 7 (Scan Rsp Dta, Scan ok)  Passed
Add Advertising - Success 8 (Connectable Flag)       Passed
Add Advertising - Success 9 (General Discov Flag)    Passed
Add Advertising - Success 10 (Limited Discov Flag)   Passed
Add Advertising - Success 11 (Managed Flags)         Passed
Add Advertising - Success 12 (TX Power Flag)         Passed
Add Advertising - Success 13 (ADV_SCAN_IND)          Passed
Add Advertising - Success 14 (ADV_NONCONN_IND)       Passed
Add Advertising - Success 15 (ADV_IND)               Passed
Add Advertising - Success 16 (Connectable -> on)     Passed
Add Advertising - Success 17 (Connectable -> off)    Passed
Add Advertising - Success 18 (Power -> off, Remove)  Passed
Add Advertising - Success 19 (Power -> off, Keep)    Passed
Add Advertising - Success 20 (Add Adv override)      Passed
Add Advertising - Success 21 (Timeout expires)       Passed
Add Advertising - Success 22 (LE -> off, Remove)     Passed
Add Advertising - Success (Empty ScRsp)              Passed
Add Advertising - Success (ScRsp only)               Passed
Add Advertising - Invalid Params (ScRsp too long)    Passed
Add Advertising - Success (ScRsp appear)             Passed
Add Advertising - Invalid Params (ScRsp appear long) Passed
Add Advertising - Success (Appear is null)           Passed
Add Advertising - Success (Name is null)             Passed
Add Advertising - Success (Complete name)            Passed
Add Advertising - Success (Shortened name)           Passed
Add Advertising - Success (Short name)               Passed
Add Advertising - Success (Name + data)              Passed
Add Advertising - Invalid Params (Name + data)       Passed
Add Advertising - Success (Name+data+appear)         Passed
Total: 47, Passed: 47 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 2.17 seconds

mgmt-tester -s "Remove Advertising"

Test Summary
------------
Remove Advertising - Invalid Params 1                Passed
Remove Advertising - Success 1                       Passed
Remove Advertising - Success 2                       Passed
Total: 3, Passed: 3 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 0.0585 seconds

mgmt-tester -s "Ext Adv MGMT Params"

Test Summary:
------------
Ext Adv MGMT Params - Unpowered                      Passed
Ext Adv MGMT Params - Invalid parameters             Passed
Ext Adv MGMT Params - Success                        Passed
Ext Adv MGMT Params - (5.0) Success                  Passed
Total: 4, Passed: 4 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 0.0746 seconds

mgmt-tester -s "Ext Adv MGMT -"

Test Summary
------------
Ext Adv MGMT - Data set without Params               Passed
Ext Adv MGMT - AD Data (5.0) Invalid parameters      Passed
Ext Adv MGMT - AD Data (5.0) Success                 Passed
Ext Adv MGMT - AD Scan Response (5.0) Success        Passed
Total: 4, Passed: 4 (100.0%), Failed: 0, Not Run: 0
Overall execution time: 0.0805 seconds

Signed-off-by: default avatarLuiz Augusto von Dentz <luiz.von.dentz@intel.com>
Signed-off-by: default avatarMarcel Holtmann <marcel@holtmann.org>
parent 161510cc

include/net/bluetooth/bluetooth.h

+2 −0
Original line number Diff line number Diff line
@@ -380,6 +380,7 @@ typedef void (*hci_req_complete_skb_t)(struct hci_dev *hdev, u8 status, 
#define HCI_REQ_SKB	BIT(1)



struct hci_ctrl {

	struct sock *sk;

	u16 opcode;

	u8 req_flags;

	u8 req_event;
@@ -405,6 +406,7 @@ struct bt_skb_cb { 
#define hci_skb_pkt_type(skb) bt_cb((skb))->pkt_type

#define hci_skb_expect(skb) bt_cb((skb))->expect

#define hci_skb_opcode(skb) bt_cb((skb))->hci.opcode

#define hci_skb_sk(skb) bt_cb((skb))->hci.sk



static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how)

{

include/net/bluetooth/hci_sync.h

+20 −0
Original line number Diff line number Diff line
@@ -43,3 +43,23 @@ int hci_cmd_sync_queue(struct hci_dev *hdev, hci_cmd_sync_work_func_t func, 


int hci_update_eir_sync(struct hci_dev *hdev);

int hci_update_class_sync(struct hci_dev *hdev);



int hci_update_eir_sync(struct hci_dev *hdev);

int hci_update_class_sync(struct hci_dev *hdev);



int hci_update_random_address_sync(struct hci_dev *hdev, bool require_privacy,

				   bool rpa, u8 *own_addr_type);



int hci_update_scan_rsp_data_sync(struct hci_dev *hdev, u8 instance);

int hci_update_adv_data_sync(struct hci_dev *hdev, u8 instance);

int hci_schedule_adv_instance_sync(struct hci_dev *hdev, u8 instance,

				   bool force);



int hci_setup_ext_adv_instance_sync(struct hci_dev *hdev, u8 instance);

int hci_start_ext_adv_sync(struct hci_dev *hdev, u8 instance);

int hci_enable_ext_advertising_sync(struct hci_dev *hdev, u8 instance);

int hci_enable_advertising_sync(struct hci_dev *hdev);



int hci_remove_advertising_sync(struct hci_dev *hdev, struct sock *sk,

				u8 instance, bool force);

int hci_disable_advertising_sync(struct hci_dev *hdev);

net/bluetooth/hci_event.c

+57 −0
Original line number Diff line number Diff line
@@ -1239,6 +1239,55 @@ static void hci_cc_le_set_adv_set_random_addr(struct hci_dev *hdev, 
	hci_dev_unlock(hdev);

}



static void hci_cc_le_remove_adv_set(struct hci_dev *hdev, struct sk_buff *skb)

{

	__u8 status = *((__u8 *)skb->data);

	u8 *instance;

	int err;



	if (status)

		return;



	instance = hci_sent_cmd_data(hdev, HCI_OP_LE_REMOVE_ADV_SET);

	if (!instance)

		return;



	hci_dev_lock(hdev);



	err = hci_remove_adv_instance(hdev, *instance);

	if (!err)

		mgmt_advertising_removed(hci_skb_sk(hdev->sent_cmd), hdev,

					 *instance);



	hci_dev_unlock(hdev);

}



static void hci_cc_le_clear_adv_sets(struct hci_dev *hdev, struct sk_buff *skb)

{

	__u8 status = *((__u8 *)skb->data);

	struct adv_info *adv, *n;

	int err;



	if (status)

		return;



	if (!hci_sent_cmd_data(hdev, HCI_OP_LE_CLEAR_ADV_SETS))

		return;



	hci_dev_lock(hdev);



	list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {

		u8 instance = adv->instance;



		err = hci_remove_adv_instance(hdev, instance);

		if (!err)

			mgmt_advertising_removed(hci_skb_sk(hdev->sent_cmd),

						 hdev, instance);

	}



	hci_dev_unlock(hdev);

}



static void hci_cc_le_read_transmit_power(struct hci_dev *hdev,

					  struct sk_buff *skb)

{
@@ -3725,6 +3774,14 @@ static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb, 
		hci_cc_le_set_adv_set_random_addr(hdev, skb);

		break;



	case HCI_OP_LE_REMOVE_ADV_SET:

		hci_cc_le_remove_adv_set(hdev, skb);

		break;



	case HCI_OP_LE_CLEAR_ADV_SETS:

		hci_cc_le_clear_adv_sets(hdev, skb);

		break;



	case HCI_OP_LE_READ_TRANSMIT_POWER:

		hci_cc_le_read_transmit_power(hdev, skb);

		break;

net/bluetooth/hci_sync.c

+890 −0

File changed.

Preview size limit exceeded, changes collapsed.

net/bluetooth/mgmt.c

+189 −202
Original line number Diff line number Diff line
@@ -999,11 +999,22 @@ static void service_cache_off(struct work_struct *work) 
	hci_cmd_sync_queue(hdev, service_cache_sync, NULL, NULL);

}



static int rpa_expired_sync(struct hci_dev *hdev, void *data)

{

	/* The generation of a new RPA and programming it into the

	 * controller happens in the hci_req_enable_advertising()

	 * function.

	 */

	if (ext_adv_capable(hdev))

		return hci_start_ext_adv_sync(hdev, hdev->cur_adv_instance);

	else

		return hci_enable_advertising_sync(hdev);

}



static void rpa_expired(struct work_struct *work)

{

	struct hci_dev *hdev = container_of(work, struct hci_dev,

					    rpa_expired.work);

	struct hci_request req;



	bt_dev_dbg(hdev, "");
@@ -1012,16 +1023,7 @@ static void rpa_expired(struct work_struct *work) 
	if (!hci_dev_test_flag(hdev, HCI_ADVERTISING))

		return;



	/* The generation of a new RPA and programming it into the

	 * controller happens in the hci_req_enable_advertising()

	 * function.

	 */

	hci_req_init(&req, hdev);

	if (ext_adv_capable(hdev))

		__hci_req_start_ext_adv(&req, hdev->cur_adv_instance);

	else

		__hci_req_enable_advertising(&req);

	hci_req_run(&req, NULL);

	hci_cmd_sync_queue(hdev, rpa_expired_sync, NULL, NULL);

}



static void mgmt_init_hdev(struct sock *sk, struct hci_dev *hdev)
@@ -7873,58 +7875,66 @@ static bool adv_busy(struct hci_dev *hdev) 
		pending_find(MGMT_OP_ADD_EXT_ADV_DATA, hdev));

}



static void add_advertising_complete(struct hci_dev *hdev, u8 status,

				     u16 opcode)

static void add_adv_complete(struct hci_dev *hdev, struct sock *sk, u8 instance,

			     int err)

{

	struct mgmt_pending_cmd *cmd;

	struct mgmt_cp_add_advertising *cp;

	struct mgmt_rp_add_advertising rp;

	struct adv_info *adv_instance, *n;

	u8 instance;

	struct adv_info *adv, *n;



	bt_dev_dbg(hdev, "status %u", status);

	bt_dev_dbg(hdev, "err %d", err);



	hci_dev_lock(hdev);



	cmd = pending_find(MGMT_OP_ADD_ADVERTISING, hdev);

	if (!cmd)

		cmd = pending_find(MGMT_OP_ADD_EXT_ADV_DATA, hdev);

	list_for_each_entry_safe(adv, n, &hdev->adv_instances, list) {

		u8 instance;



	list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) {

		if (!adv_instance->pending)

		if (!adv->pending)

			continue;



		if (!status) {

			adv_instance->pending = false;

		if (!err) {

			adv->pending = false;

			continue;

		}



		instance = adv_instance->instance;

		instance = adv->instance;



		if (hdev->cur_adv_instance == instance)

			cancel_adv_timeout(hdev);



		hci_remove_adv_instance(hdev, instance);

		mgmt_advertising_removed(cmd ? cmd->sk : NULL, hdev, instance);

		mgmt_advertising_removed(sk, hdev, instance);

	}



	if (!cmd)

		goto unlock;

	hci_dev_unlock(hdev);

}



static void add_advertising_complete(struct hci_dev *hdev, void *data, int err)

{

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_add_advertising *cp = cmd->param;

	struct mgmt_rp_add_advertising rp;



	memset(&rp, 0, sizeof(rp));



	cp = cmd->param;

	rp.instance = cp->instance;



	if (status)

	if (err)

		mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,

				mgmt_status(status));

				mgmt_status(err));

	else

		mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,

				  mgmt_status(status), &rp, sizeof(rp));

				  mgmt_status(err), &rp, sizeof(rp));



	mgmt_pending_remove(cmd);

	add_adv_complete(hdev, cmd->sk, cp->instance, err);



unlock:

	hci_dev_unlock(hdev);

	mgmt_pending_free(cmd);

}



static int add_advertising_sync(struct hci_dev *hdev, void *data)

{

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_add_advertising *cp = cmd->param;



	return hci_schedule_adv_instance_sync(hdev, cp->instance, true);

}



static int add_advertising(struct sock *sk, struct hci_dev *hdev,
@@ -7940,7 +7950,6 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev, 
	struct adv_info *next_instance;

	int err;

	struct mgmt_pending_cmd *cmd;

	struct hci_request req;



	bt_dev_dbg(hdev, "sock %p", sk);
@@ -8048,25 +8057,19 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev, 
	/* We're good to go, update advertising data, parameters, and start

	 * advertising.

	 */

	cmd = mgmt_pending_add(sk, MGMT_OP_ADD_ADVERTISING, hdev, data,

	cmd = mgmt_pending_new(sk, MGMT_OP_ADD_ADVERTISING, hdev, data,

			       data_len);

	if (!cmd) {

		err = -ENOMEM;

		goto unlock;

	}



	hci_req_init(&req, hdev);



	err = __hci_req_schedule_adv_instance(&req, schedule_instance, true);

	cp->instance = schedule_instance;



	if (!err)

		err = hci_req_run(&req, add_advertising_complete);



	if (err < 0) {

		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,

				      MGMT_STATUS_FAILED);

		mgmt_pending_remove(cmd);

	}

	err = hci_cmd_sync_queue(hdev, add_advertising_sync, cmd,

				 add_advertising_complete);

	if (err < 0)

		mgmt_pending_free(cmd);



unlock:

	hci_dev_unlock(hdev);
@@ -8074,30 +8077,25 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev, 
	return err;

}



static void add_ext_adv_params_complete(struct hci_dev *hdev, u8 status,

					u16 opcode)

static void add_ext_adv_params_complete(struct hci_dev *hdev, void *data,

					int err)

{

	struct mgmt_pending_cmd *cmd;

	struct mgmt_cp_add_ext_adv_params *cp;

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_add_ext_adv_params *cp = cmd->param;

	struct mgmt_rp_add_ext_adv_params rp;

	struct adv_info *adv_instance;

	struct adv_info *adv;

	u32 flags;



	BT_DBG("%s", hdev->name);



	hci_dev_lock(hdev);



	cmd = pending_find(MGMT_OP_ADD_EXT_ADV_PARAMS, hdev);

	if (!cmd)

		goto unlock;



	cp = cmd->param;

	adv_instance = hci_find_adv_instance(hdev, cp->instance);

	if (!adv_instance)

	adv = hci_find_adv_instance(hdev, cp->instance);

	if (!adv)

		goto unlock;



	rp.instance = cp->instance;

	rp.tx_power = adv_instance->tx_power;

	rp.tx_power = adv->tx_power;



	/* While we're at it, inform userspace of the available space for this

	 * advertisement, given the flags that will be used.
@@ -8106,39 +8104,44 @@ static void add_ext_adv_params_complete(struct hci_dev *hdev, u8 status, 
	rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);

	rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);



	if (status) {

	if (err) {

		/* If this advertisement was previously advertising and we

		 * failed to update it, we signal that it has been removed and

		 * delete its structure

		 */

		if (!adv_instance->pending)

		if (!adv->pending)

			mgmt_advertising_removed(cmd->sk, hdev, cp->instance);



		hci_remove_adv_instance(hdev, cp->instance);



		mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,

				mgmt_status(status));



				mgmt_status(err));

	} else {

		mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,

				  mgmt_status(status), &rp, sizeof(rp));

				  mgmt_status(err), &rp, sizeof(rp));

	}



unlock:

	if (cmd)

		mgmt_pending_remove(cmd);

		mgmt_pending_free(cmd);



	hci_dev_unlock(hdev);

}



static int add_ext_adv_params_sync(struct hci_dev *hdev, void *data)

{

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_add_ext_adv_params *cp = cmd->param;



	return hci_setup_ext_adv_instance_sync(hdev, cp->instance);

}



static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev,

			      void *data, u16 data_len)

{

	struct mgmt_cp_add_ext_adv_params *cp = data;

	struct mgmt_rp_add_ext_adv_params rp;

	struct mgmt_pending_cmd *cmd = NULL;

	struct adv_info *adv_instance;

	struct hci_request req;

	u32 flags, min_interval, max_interval;

	u16 timeout, duration;

	u8 status;
@@ -8220,29 +8223,18 @@ static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev, 


	/* Submit request for advertising params if ext adv available */

	if (ext_adv_capable(hdev)) {

		hci_req_init(&req, hdev);

		adv_instance = hci_find_adv_instance(hdev, cp->instance);



		/* Updating parameters of an active instance will return a

		 * Command Disallowed error, so we must first disable the

		 * instance if it is active.

		 */

		if (!adv_instance->pending)

			__hci_req_disable_ext_adv_instance(&req, cp->instance);



		__hci_req_setup_ext_adv_instance(&req, cp->instance);



		err = hci_req_run(&req, add_ext_adv_params_complete);



		if (!err)

			cmd = mgmt_pending_add(sk, MGMT_OP_ADD_EXT_ADV_PARAMS,

					       hdev, data, data_len);

		cmd = mgmt_pending_new(sk, MGMT_OP_ADD_EXT_ADV_PARAMS, hdev,

				       data, data_len);

		if (!cmd) {

			err = -ENOMEM;

			hci_remove_adv_instance(hdev, cp->instance);

			goto unlock;

		}



		err = hci_cmd_sync_queue(hdev, add_ext_adv_params_sync, cmd,

					 add_ext_adv_params_complete);

		if (err < 0)

			mgmt_pending_free(cmd);

	} else {

		rp.instance = cp->instance;

		rp.tx_power = HCI_ADV_TX_POWER_NO_PREFERENCE;
@@ -8259,6 +8251,49 @@ static int add_ext_adv_params(struct sock *sk, struct hci_dev *hdev, 
	return err;

}



static void add_ext_adv_data_complete(struct hci_dev *hdev, void *data, int err)

{

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_add_ext_adv_data *cp = cmd->param;

	struct mgmt_rp_add_advertising rp;



	add_adv_complete(hdev, cmd->sk, cp->instance, err);



	memset(&rp, 0, sizeof(rp));



	rp.instance = cp->instance;



	if (err)

		mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,

				mgmt_status(err));

	else

		mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,

				  mgmt_status(err), &rp, sizeof(rp));



	mgmt_pending_free(cmd);

}



static int add_ext_adv_data_sync(struct hci_dev *hdev, void *data)

{

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_add_ext_adv_data *cp = cmd->param;

	int err;



	if (ext_adv_capable(hdev)) {

		err = hci_update_adv_data_sync(hdev, cp->instance);

		if (err)

			return err;



		err = hci_update_scan_rsp_data_sync(hdev, cp->instance);

		if (err)

			return err;



		return hci_enable_ext_advertising_sync(hdev, cp->instance);

	}



	return hci_schedule_adv_instance_sync(hdev, cp->instance, true);

}



static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,

			    u16 data_len)

{
@@ -8269,7 +8304,6 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data, 
	struct adv_info *adv_instance;

	int err = 0;

	struct mgmt_pending_cmd *cmd;

	struct hci_request req;



	BT_DBG("%s", hdev->name);
@@ -8311,22 +8345,7 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data, 
				  cp->data, cp->scan_rsp_len,

				  cp->data + cp->adv_data_len);



	/* We're good to go, update advertising data, parameters, and start

	 * advertising.

	 */



	hci_req_init(&req, hdev);



	hci_req_add(&req, HCI_OP_READ_LOCAL_NAME, 0, NULL);



	if (ext_adv_capable(hdev)) {

		__hci_req_update_adv_data(&req, cp->instance);

		__hci_req_update_scan_rsp_data(&req, cp->instance);

		__hci_req_enable_ext_advertising(&req, cp->instance);



	} else {

	/* If using software rotation, determine next instance to use */



	if (hdev->cur_adv_instance == cp->instance) {

		/* If the currently advertised instance is being changed

		 * then cancel the current advertising and schedule the
@@ -8336,8 +8355,7 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data, 
		 */

		cancel_adv_timeout(hdev);



			next_instance = hci_get_next_instance(hdev,

							      cp->instance);

		next_instance = hci_get_next_instance(hdev, cp->instance);

		if (next_instance)

			schedule_instance = next_instance->instance;

	} else if (!hdev->adv_instance_timeout) {
@@ -8351,38 +8369,28 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data, 
	 * be advertised then we have no HCI communication to make.

	 * Simply return.

	 */

		if (hci_dev_test_flag(hdev, HCI_ADVERTISING) ||

		    !schedule_instance) {

	if (hci_dev_test_flag(hdev, HCI_ADVERTISING) || !schedule_instance) {

		if (adv_instance->pending) {

			mgmt_advertising_added(sk, hdev, cp->instance);

			adv_instance->pending = false;

		}

		rp.instance = cp->instance;

			err = mgmt_cmd_complete(sk, hdev->id,

						MGMT_OP_ADD_EXT_ADV_DATA,

						MGMT_STATUS_SUCCESS, &rp,

						sizeof(rp));

		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,

					MGMT_STATUS_SUCCESS, &rp, sizeof(rp));

		goto unlock;

	}



		err = __hci_req_schedule_adv_instance(&req, schedule_instance,

						      true);

	}



	cmd = mgmt_pending_add(sk, MGMT_OP_ADD_EXT_ADV_DATA, hdev, data,

	cmd = mgmt_pending_new(sk, MGMT_OP_ADD_EXT_ADV_DATA, hdev, data,

			       data_len);

	if (!cmd) {

		err = -ENOMEM;

		goto clear_new_instance;

	}



	if (!err)

		err = hci_req_run(&req, add_advertising_complete);



	err = hci_cmd_sync_queue(hdev, add_ext_adv_data_sync, cmd,

				 add_ext_adv_data_complete);

	if (err < 0) {

		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,

				      MGMT_STATUS_FAILED);

		mgmt_pending_remove(cmd);

		mgmt_pending_free(cmd);

		goto clear_new_instance;

	}
@@ -8405,43 +8413,49 @@ static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data, 
	return err;

}



static void remove_advertising_complete(struct hci_dev *hdev, u8 status,

					u16 opcode)

static void remove_advertising_complete(struct hci_dev *hdev, void *data,

					int err)

{

	struct mgmt_pending_cmd *cmd;

	struct mgmt_cp_remove_advertising *cp;

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_remove_advertising *cp = cmd->param;

	struct mgmt_rp_remove_advertising rp;



	bt_dev_dbg(hdev, "status %u", status);

	bt_dev_dbg(hdev, "err %d", err);



	hci_dev_lock(hdev);

	memset(&rp, 0, sizeof(rp));

	rp.instance = cp->instance;



	/* A failure status here only means that we failed to disable

	 * advertising. Otherwise, the advertising instance has been removed,

	 * so report success.

	 */

	cmd = pending_find(MGMT_OP_REMOVE_ADVERTISING, hdev);

	if (!cmd)

		goto unlock;

	if (err)

		mgmt_cmd_status(cmd->sk, cmd->index, cmd->opcode,

				mgmt_status(err));

	else

		mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,

				  MGMT_STATUS_SUCCESS, &rp, sizeof(rp));



	cp = cmd->param;

	rp.instance = cp->instance;

	mgmt_pending_free(cmd);

}



	mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode, MGMT_STATUS_SUCCESS,

			  &rp, sizeof(rp));

	mgmt_pending_remove(cmd);

static int remove_advertising_sync(struct hci_dev *hdev, void *data)

{

	struct mgmt_pending_cmd *cmd = data;

	struct mgmt_cp_remove_advertising *cp = cmd->param;

	int err;



unlock:

	hci_dev_unlock(hdev);

	err = hci_remove_advertising_sync(hdev, cmd->sk, cp->instance, true);

	if (err)

		return err;



	if (list_empty(&hdev->adv_instances))

		err = hci_disable_advertising_sync(hdev);



	return err;

}



static int remove_advertising(struct sock *sk, struct hci_dev *hdev,

			      void *data, u16 data_len)

{

	struct mgmt_cp_remove_advertising *cp = data;

	struct mgmt_rp_remove_advertising rp;

	struct mgmt_pending_cmd *cmd;

	struct hci_request req;

	int err;



	bt_dev_dbg(hdev, "sock %p", sk);
@@ -8476,44 +8490,17 @@ static int remove_advertising(struct sock *sk, struct hci_dev *hdev, 
		goto unlock;

	}



	hci_req_init(&req, hdev);



	/* If we use extended advertising, instance is disabled and removed */

	if (ext_adv_capable(hdev)) {

		__hci_req_disable_ext_adv_instance(&req, cp->instance);

		__hci_req_remove_ext_adv_instance(&req, cp->instance);

	}



	hci_req_clear_adv_instance(hdev, sk, &req, cp->instance, true);



	if (list_empty(&hdev->adv_instances))

		__hci_req_disable_advertising(&req);



	/* If no HCI commands have been collected so far or the HCI_ADVERTISING

	 * flag is set or the device isn't powered then we have no HCI

	 * communication to make. Simply return.

	 */

	if (skb_queue_empty(&req.cmd_q) ||

	    !hdev_is_powered(hdev) ||

	    hci_dev_test_flag(hdev, HCI_ADVERTISING)) {

		hci_req_purge(&req);

		rp.instance = cp->instance;

		err = mgmt_cmd_complete(sk, hdev->id,

					MGMT_OP_REMOVE_ADVERTISING,

					MGMT_STATUS_SUCCESS, &rp, sizeof(rp));

		goto unlock;

	}



	cmd = mgmt_pending_add(sk, MGMT_OP_REMOVE_ADVERTISING, hdev, data,

	cmd = mgmt_pending_new(sk, MGMT_OP_REMOVE_ADVERTISING, hdev, data,

			       data_len);

	if (!cmd) {

		err = -ENOMEM;

		goto unlock;

	}



	err = hci_req_run(&req, remove_advertising_complete);

	err = hci_cmd_sync_queue(hdev, remove_advertising_sync, cmd,

				 remove_advertising_complete);

	if (err < 0)

		mgmt_pending_remove(cmd);

		mgmt_pending_free(cmd);



unlock:

	hci_dev_unlock(hdev);