korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-11 12:28:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

Bluetooth: Break add adv into two mgmt commands

Browse Source 
This patch adds support for the new advertising add interface, with the
first command setting advertising parameters and the second to set
advertising data. The set parameters command allows the caller to leave
some fields "unset", with a params bitfield defining which params were
purposefully set. Unset parameters will be given defaults when calling
hci_add_adv_instance. The data passed to the param mgmt command is
allowed to be flexible, so in the future if bluetoothd passes a larger
structure with new params, the mgmt command will ignore the unknown
members at the end.

This change has been validated on both hatch (extended advertising) and
kukui (no extended advertising) chromebooks running bluetoothd that
support this new interface. I ran the following manual tests:
- Set several (3) advertisements using modified test_advertisement.py
- For each, validate correct data and parameters in btmon trace
- Verified both for software rotation and extended adv

Automatic test suite also run, testing many (25) scenarios of single and
multi-advertising for data/parameter correctness.

Reviewed-by: Sonny Sasaka <sonnysasaka@chromium.org>
Signed-off-by: Daniel Winkler <danielwinkler@google.com>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>
Signed-off-by: Johan Hedberg <johan.hedberg@intel.com>
This commit is contained in:
Daniel Winkler 2020-12-03 12:12:49 -08:00 committed by Johan Hedberg
parent 31aab5c22e
commit 1241057283
4 changed files with 407 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/net/bluetooth/hci_core.h
View File

@ -238,6 +238,8 @@ struct adv_info {
#define HCI_MAX_ADV_INSTANCES 5
#define HCI_DEFAULT_ADV_DURATION 2
#define HCI_ADV_TX_POWER_NO_PREFERENCE 0x7F
struct adv_pattern {
struct list_head list;
__u8 ad_type;

34
include/net/bluetooth/mgmt.h
View File

@ -574,6 +574,10 @@ struct mgmt_rp_add_advertising {
#define MGMT_ADV_FLAG_SEC_CODED BIT(9)
#define MGMT_ADV_FLAG_CAN_SET_TX_POWER BIT(10)
#define MGMT_ADV_FLAG_HW_OFFLOAD BIT(11)
#define MGMT_ADV_PARAM_DURATION BIT(12)
#define MGMT_ADV_PARAM_TIMEOUT BIT(13)
#define MGMT_ADV_PARAM_INTERVALS BIT(14)
#define MGMT_ADV_PARAM_TX_POWER BIT(15)
#define MGMT_ADV_FLAG_SEC_MASK (MGMT_ADV_FLAG_SEC_1M | MGMT_ADV_FLAG_SEC_2M | \
MGMT_ADV_FLAG_SEC_CODED)
@ -782,6 +786,36 @@ struct mgmt_rp_remove_adv_monitor {
__le16 monitor_handle;
} __packed;
#define MGMT_OP_ADD_EXT_ADV_PARAMS 0x0054
struct mgmt_cp_add_ext_adv_params {
__u8 instance;
__le32 flags;
__le16 duration;
__le16 timeout;
__le32 min_interval;
__le32 max_interval;
__s8 tx_power;
} __packed;
#define MGMT_ADD_EXT_ADV_PARAMS_MIN_SIZE 18
struct mgmt_rp_add_ext_adv_params {
__u8 instance;
__s8 tx_power;
__u8 max_adv_data_len;
__u8 max_scan_rsp_len;
} __packed;
#define MGMT_OP_ADD_EXT_ADV_DATA 0x0055
struct mgmt_cp_add_ext_adv_data {
__u8 instance;
__u8 adv_data_len;
__u8 scan_rsp_len;
__u8 data[];
} __packed;
#define MGMT_ADD_EXT_ADV_DATA_SIZE 3
struct mgmt_rp_add_ext_adv_data {
__u8 instance;
} __packed;
#define MGMT_EV_CMD_COMPLETE 0x0001
struct mgmt_ev_cmd_complete {
__le16 opcode;

1
net/bluetooth/hci_event.c
View File

@ -1752,6 +1752,7 @@ static void hci_cc_set_ext_adv_param(struct hci_dev *hdev, struct sk_buff *skb)
}
/* Update adv data as tx power is known now */
hci_req_update_adv_data(hdev, hdev->cur_adv_instance);
hci_dev_unlock(hdev);
}

381
net/bluetooth/mgmt.c
View File

@ -122,6 +122,8 @@ static const u16 mgmt_commands[] = {
MGMT_OP_READ_ADV_MONITOR_FEATURES,
MGMT_OP_ADD_ADV_PATTERNS_MONITOR,
MGMT_OP_REMOVE_ADV_MONITOR,
MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_OP_ADD_EXT_ADV_DATA,
};
static const u16 mgmt_events[] = {
@ -7203,6 +7205,10 @@ static u32 get_supported_adv_flags(struct hci_dev *hdev)
flags |= MGMT_ADV_FLAG_MANAGED_FLAGS;
flags |= MGMT_ADV_FLAG_APPEARANCE;
flags |= MGMT_ADV_FLAG_LOCAL_NAME;
flags |= MGMT_ADV_PARAM_DURATION;
flags |= MGMT_ADV_PARAM_TIMEOUT;
flags |= MGMT_ADV_PARAM_INTERVALS;
flags |= MGMT_ADV_PARAM_TX_POWER;
/* In extended adv TX_POWER returned from Set Adv Param
* will be always valid.
@ -7377,6 +7383,31 @@ static bool tlv_data_is_valid(struct hci_dev *hdev, u32 adv_flags, u8 *data,
return true;
}
static bool requested_adv_flags_are_valid(struct hci_dev *hdev, u32 adv_flags)
{
u32 supported_flags, phy_flags;
/* The current implementation only supports a subset of the specified
* flags. Also need to check mutual exclusiveness of sec flags.
*/
supported_flags = get_supported_adv_flags(hdev);
phy_flags = adv_flags & MGMT_ADV_FLAG_SEC_MASK;
if (adv_flags & ~supported_flags ||
((phy_flags && (phy_flags ^ (phy_flags & -phy_flags)))))
return false;
return true;
}
static bool adv_busy(struct hci_dev *hdev)
{
return (pending_find(MGMT_OP_ADD_ADVERTISING, hdev) ||
pending_find(MGMT_OP_REMOVE_ADVERTISING, hdev) ||
pending_find(MGMT_OP_SET_LE, hdev) ||
pending_find(MGMT_OP_ADD_EXT_ADV_PARAMS, hdev) ||
pending_find(MGMT_OP_ADD_EXT_ADV_DATA, hdev));
}
static void add_advertising_complete(struct hci_dev *hdev, u8 status,
u16 opcode)
{
@ -7391,6 +7422,8 @@ static void add_advertising_complete(struct hci_dev *hdev, u8 status,
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_instance, n, &hdev->adv_instances, list) {
if (!adv_instance->pending)
@ -7435,7 +7468,6 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev,
struct mgmt_cp_add_advertising *cp = data;
struct mgmt_rp_add_advertising rp;
u32 flags;
u32 supported_flags, phy_flags;
u8 status;
u16 timeout, duration;
unsigned int prev_instance_cnt = hdev->adv_instance_cnt;
@ -7471,13 +7503,7 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev,
timeout = __le16_to_cpu(cp->timeout);
duration = __le16_to_cpu(cp->duration);
/* The current implementation only supports a subset of the specified
* flags. Also need to check mutual exclusiveness of sec flags.
*/
supported_flags = get_supported_adv_flags(hdev);
phy_flags = flags & MGMT_ADV_FLAG_SEC_MASK;
if (flags & ~supported_flags ||
((phy_flags && (phy_flags ^ (phy_flags & -phy_flags)))))
if (!requested_adv_flags_are_valid(hdev, flags))
return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
MGMT_STATUS_INVALID_PARAMS);
@ -7489,9 +7515,7 @@ static int add_advertising(struct sock *sk, struct hci_dev *hdev,
goto unlock;
}
if (pending_find(MGMT_OP_ADD_ADVERTISING, hdev) ||
pending_find(MGMT_OP_REMOVE_ADVERTISING, hdev) ||
pending_find(MGMT_OP_SET_LE, hdev)) {
if (adv_busy(hdev)) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
MGMT_STATUS_BUSY);
goto unlock;
@ -7582,6 +7606,337 @@ unlock:
return err;
}
static void add_ext_adv_params_complete(struct hci_dev *hdev, u8 status,
u16 opcode)
{
struct mgmt_pending_cmd *cmd;
struct mgmt_cp_add_ext_adv_params *cp;
struct mgmt_rp_add_ext_adv_params rp;
struct adv_info *adv_instance;
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)
goto unlock;
rp.instance = cp->instance;
rp.tx_power = adv_instance->tx_power;
/* While we're at it, inform userspace of the available space for this
* advertisement, given the flags that will be used.
*/
flags = __le32_to_cpu(cp->flags);
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 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)
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));
} else {
mgmt_cmd_complete(cmd->sk, cmd->index, cmd->opcode,
mgmt_status(status), &rp, sizeof(rp));
}
unlock:
if (cmd)
mgmt_pending_remove(cmd);
hci_dev_unlock(hdev);
}
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;
s8 tx_power;
int err;
BT_DBG("%s", hdev->name);
status = mgmt_le_support(hdev);
if (status)
return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
status);
if (cp->instance < 1 || cp->instance > hdev->le_num_of_adv_sets)
return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_STATUS_INVALID_PARAMS);
/* The purpose of breaking add_advertising into two separate MGMT calls
* for params and data is to allow more parameters to be added to this
* structure in the future. For this reason, we verify that we have the
* bare minimum structure we know of when the interface was defined. Any
* extra parameters we don't know about will be ignored in this request.
*/
if (data_len < MGMT_ADD_EXT_ADV_PARAMS_MIN_SIZE)
return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_ADVERTISING,
MGMT_STATUS_INVALID_PARAMS);
flags = __le32_to_cpu(cp->flags);
if (!requested_adv_flags_are_valid(hdev, flags))
return mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_STATUS_INVALID_PARAMS);
hci_dev_lock(hdev);
/* In new interface, we require that we are powered to register */
if (!hdev_is_powered(hdev)) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_STATUS_REJECTED);
goto unlock;
}
if (adv_busy(hdev)) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_STATUS_BUSY);
goto unlock;
}
/* Parse defined parameters from request, use defaults otherwise */
timeout = (flags & MGMT_ADV_PARAM_TIMEOUT) ?
__le16_to_cpu(cp->timeout) : 0;
duration = (flags & MGMT_ADV_PARAM_DURATION) ?
__le16_to_cpu(cp->duration) :
hdev->def_multi_adv_rotation_duration;
min_interval = (flags & MGMT_ADV_PARAM_INTERVALS) ?
__le32_to_cpu(cp->min_interval) :
hdev->le_adv_min_interval;
max_interval = (flags & MGMT_ADV_PARAM_INTERVALS) ?
__le32_to_cpu(cp->max_interval) :
hdev->le_adv_max_interval;
tx_power = (flags & MGMT_ADV_PARAM_TX_POWER) ?
cp->tx_power :
HCI_ADV_TX_POWER_NO_PREFERENCE;
/* Create advertising instance with no advertising or response data */
err = hci_add_adv_instance(hdev, cp->instance, flags,
0, NULL, 0, NULL, timeout, duration);
if (err < 0) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_STATUS_FAILED);
goto unlock;
}
hdev->cur_adv_instance = cp->instance;
/* 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);
if (!cmd) {
err = -ENOMEM;
hci_remove_adv_instance(hdev, cp->instance);
goto unlock;
}
} else {
rp.instance = cp->instance;
rp.tx_power = HCI_ADV_TX_POWER_NO_PREFERENCE;
rp.max_adv_data_len = tlv_data_max_len(hdev, flags, true);
rp.max_scan_rsp_len = tlv_data_max_len(hdev, flags, false);
err = mgmt_cmd_complete(sk, hdev->id,
MGMT_OP_ADD_EXT_ADV_PARAMS,
MGMT_STATUS_SUCCESS, &rp, sizeof(rp));
}
unlock:
hci_dev_unlock(hdev);
return err;
}
static int add_ext_adv_data(struct sock *sk, struct hci_dev *hdev, void *data,
u16 data_len)
{
struct mgmt_cp_add_ext_adv_data *cp = data;
struct mgmt_rp_add_ext_adv_data rp;
u8 schedule_instance = 0;
struct adv_info *next_instance;
struct adv_info *adv_instance;
int err = 0;
struct mgmt_pending_cmd *cmd;
struct hci_request req;
BT_DBG("%s", hdev->name);
hci_dev_lock(hdev);
adv_instance = hci_find_adv_instance(hdev, cp->instance);
if (!adv_instance) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_INVALID_PARAMS);
goto unlock;
}
/* In new interface, we require that we are powered to register */
if (!hdev_is_powered(hdev)) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_REJECTED);
goto clear_new_instance;
}
if (adv_busy(hdev)) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_BUSY);
goto clear_new_instance;
}
/* Validate new data */
if (!tlv_data_is_valid(hdev, adv_instance->flags, cp->data,
cp->adv_data_len, true) ||
!tlv_data_is_valid(hdev, adv_instance->flags, cp->data +
cp->adv_data_len, cp->scan_rsp_len, false)) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_INVALID_PARAMS);
goto clear_new_instance;
}
/* Set the data in the advertising instance */
hci_set_adv_instance_data(hdev, cp->instance, cp->adv_data_len,
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
* next instance. If there is only one instance then the
* overridden advertising data will be visible right
* away
*/
cancel_adv_timeout(hdev);
next_instance = hci_get_next_instance(hdev,
cp->instance);
if (next_instance)
schedule_instance = next_instance->instance;
} else if (!hdev->adv_instance_timeout) {
/* Immediately advertise the new instance if no other
* instance is currently being advertised.
*/
schedule_instance = cp->instance;
}
/* If the HCI_ADVERTISING flag is set or there is no instance to
* be advertised then we have no HCI communication to make.
* Simply return.
*/
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));
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,
data_len);
if (!cmd) {
err = -ENOMEM;
goto clear_new_instance;
}
if (!err)
err = hci_req_run(&req, add_advertising_complete);
if (err < 0) {
err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ADD_EXT_ADV_DATA,
MGMT_STATUS_FAILED);
mgmt_pending_remove(cmd);
goto clear_new_instance;
}
/* We were successful in updating data, so trigger advertising_added
* event if this is an instance that wasn't previously advertising. If
* a failure occurs in the requests we initiated, we will remove the
* instance again in add_advertising_complete
*/
if (adv_instance->pending)
mgmt_advertising_added(sk, hdev, cp->instance);
goto unlock;
clear_new_instance:
hci_remove_adv_instance(hdev, cp->instance);
unlock:
hci_dev_unlock(hdev);
return err;
}
static void remove_advertising_complete(struct hci_dev *hdev, u8 status,
u16 opcode)
{
@ -7856,6 +8211,10 @@ static const struct hci_mgmt_handler mgmt_handlers[] = {
{ add_adv_patterns_monitor,MGMT_ADD_ADV_PATTERNS_MONITOR_SIZE,
HCI_MGMT_VAR_LEN },
{ remove_adv_monitor, MGMT_REMOVE_ADV_MONITOR_SIZE },
{ add_ext_adv_params, MGMT_ADD_EXT_ADV_PARAMS_MIN_SIZE,
HCI_MGMT_VAR_LEN },
{ add_ext_adv_data, MGMT_ADD_EXT_ADV_DATA_SIZE,
HCI_MGMT_VAR_LEN },
};
void mgmt_index_added(struct hci_dev *hdev)