Hi Archie, > This patch replaces some non-inclusive terms based on the appropriate > language mapping table compiled by the Bluetooth SIG: > https://specificationrefs.bluetooth.com/language-mapping/Appropriate_Language_Mapping_Table.pdf > > Specifically, these terms are replaced: > blacklist -> reject list > whitelist -> accept list > > Signed-off-by: Archie Pusaka <apusaka@xxxxxxxxxxxx> > Reviewed-by: Miao-chen Chou <mcchou@xxxxxxxxxxxx> > > --- > > Changes in v2: > * Add details in commit message > * Was actually two patches, squashed together > > include/net/bluetooth/hci.h | 16 +++--- > include/net/bluetooth/hci_core.h | 8 +-- > net/bluetooth/hci_core.c | 24 ++++----- > net/bluetooth/hci_debugfs.c | 8 +-- > net/bluetooth/hci_event.c | 70 ++++++++++++------------- > net/bluetooth/hci_request.c | 89 ++++++++++++++++---------------- > net/bluetooth/hci_sock.c | 12 ++--- > net/bluetooth/l2cap_core.c | 4 +- > net/bluetooth/mgmt.c | 24 +++++---- > 9 files changed, 129 insertions(+), 126 deletions(-) > > diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h > index 441125f6b616..e6801ed7ad6e 100644 > --- a/include/net/bluetooth/hci.h > +++ b/include/net/bluetooth/hci.h > @@ -1505,7 +1505,7 @@ struct hci_cp_le_set_scan_enable { > } __packed; > > #define HCI_LE_USE_PEER_ADDR 0x00 > -#define HCI_LE_USE_WHITELIST 0x01 > +#define HCI_LE_USE_ACCEPT_LIST 0x01 > > #define HCI_OP_LE_CREATE_CONN 0x200d > struct hci_cp_le_create_conn { > @@ -1525,22 +1525,22 @@ struct hci_cp_le_create_conn { > > #define HCI_OP_LE_CREATE_CONN_CANCEL 0x200e > > -#define HCI_OP_LE_READ_WHITE_LIST_SIZE 0x200f > -struct hci_rp_le_read_white_list_size { > +#define HCI_OP_LE_READ_ACCEPT_LIST_SIZE 0x200f > +struct hci_rp_le_read_accept_list_size { > __u8 status; > __u8 size; > } __packed; > > -#define HCI_OP_LE_CLEAR_WHITE_LIST 0x2010 > +#define HCI_OP_LE_CLEAR_ACCEPT_LIST 0x2010 > > -#define HCI_OP_LE_ADD_TO_WHITE_LIST 0x2011 > -struct hci_cp_le_add_to_white_list { > +#define HCI_OP_LE_ADD_TO_ACCEPT_LIST 0x2011 > +struct hci_cp_le_add_to_accept_list { > __u8 bdaddr_type; > bdaddr_t bdaddr; > } __packed; > > -#define HCI_OP_LE_DEL_FROM_WHITE_LIST 0x2012 > -struct hci_cp_le_del_from_white_list { > +#define HCI_OP_LE_DEL_FROM_ACCEPT_LIST 0x2012 > +struct hci_cp_le_del_from_accept_list { > __u8 bdaddr_type; > bdaddr_t bdaddr; > } __packed; > diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h > index cfe2ada49ca2..163caeac46a5 100644 > --- a/include/net/bluetooth/hci_core.h > +++ b/include/net/bluetooth/hci_core.h > @@ -327,7 +327,7 @@ struct hci_dev { > __u8 max_page; > __u8 features[HCI_MAX_PAGES][8]; > __u8 le_features[8]; > - __u8 le_white_list_size; > + __u8 le_accept_list_size; > __u8 le_resolv_list_size; > __u8 le_num_of_adv_sets; > __u8 le_states[8]; > @@ -522,14 +522,14 @@ struct hci_dev { > struct hci_conn_hash conn_hash; > > struct list_head mgmt_pending; > - struct list_head blacklist; > - struct list_head whitelist; > + struct list_head reject_list; > + struct list_head accept_list; > struct list_head uuids; > struct list_head link_keys; > struct list_head long_term_keys; > struct list_head identity_resolving_keys; > struct list_head remote_oob_data; > - struct list_head le_white_list; > + struct list_head le_accept_list; > struct list_head le_resolv_list; > struct list_head le_conn_params; > struct list_head pend_le_conns; > diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c > index b9ebad0f8fb9..8cf1c0068d11 100644 > --- a/net/bluetooth/hci_core.c > +++ b/net/bluetooth/hci_core.c > @@ -749,14 +749,14 @@ static int hci_init3_req(struct hci_request *req, unsigned long opt) > } > > if (hdev->commands[26] & 0x40) { > - /* Read LE White List Size */ > - hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, > + /* Read LE Accept List Size */ > + hci_req_add(req, HCI_OP_LE_READ_ACCEPT_LIST_SIZE, > 0, NULL); > } > > if (hdev->commands[26] & 0x80) { > - /* Clear LE White List */ > - hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); > + /* Clear LE Accept List */ > + hci_req_add(req, HCI_OP_LE_CLEAR_ACCEPT_LIST, 0, NULL); > } > > if (hdev->commands[34] & 0x40) { > @@ -3708,13 +3708,13 @@ static int hci_suspend_notifier(struct notifier_block *nb, unsigned long action, > /* Suspend consists of two actions: > * - First, disconnect everything and make the controller not > * connectable (disabling scanning) > - * - Second, program event filter/whitelist and enable scan > + * - Second, program event filter/accept list and enable scan > */ > ret = hci_change_suspend_state(hdev, BT_SUSPEND_DISCONNECT); > if (!ret) > state = BT_SUSPEND_DISCONNECT; > > - /* Only configure whitelist if disconnect succeeded and wake > + /* Only configure accept list if disconnect succeeded and wake > * isn't being prevented. > */ > if (!ret && !(hdev->prevent_wake && hdev->prevent_wake(hdev))) { > @@ -3822,14 +3822,14 @@ struct hci_dev *hci_alloc_dev(void) > mutex_init(&hdev->req_lock); > > INIT_LIST_HEAD(&hdev->mgmt_pending); > - INIT_LIST_HEAD(&hdev->blacklist); > - INIT_LIST_HEAD(&hdev->whitelist); > + INIT_LIST_HEAD(&hdev->reject_list); > + INIT_LIST_HEAD(&hdev->accept_list); > INIT_LIST_HEAD(&hdev->uuids); > INIT_LIST_HEAD(&hdev->link_keys); > INIT_LIST_HEAD(&hdev->long_term_keys); > INIT_LIST_HEAD(&hdev->identity_resolving_keys); > INIT_LIST_HEAD(&hdev->remote_oob_data); > - INIT_LIST_HEAD(&hdev->le_white_list); > + INIT_LIST_HEAD(&hdev->le_accept_list); > INIT_LIST_HEAD(&hdev->le_resolv_list); > INIT_LIST_HEAD(&hdev->le_conn_params); > INIT_LIST_HEAD(&hdev->pend_le_conns); > @@ -4042,8 +4042,8 @@ void hci_unregister_dev(struct hci_dev *hdev) > destroy_workqueue(hdev->req_workqueue); > > hci_dev_lock(hdev); > - hci_bdaddr_list_clear(&hdev->blacklist); > - hci_bdaddr_list_clear(&hdev->whitelist); > + hci_bdaddr_list_clear(&hdev->reject_list); > + hci_bdaddr_list_clear(&hdev->accept_list); > hci_uuids_clear(hdev); > hci_link_keys_clear(hdev); > hci_smp_ltks_clear(hdev); > @@ -4051,7 +4051,7 @@ void hci_unregister_dev(struct hci_dev *hdev) > hci_remote_oob_data_clear(hdev); > hci_adv_instances_clear(hdev); > hci_adv_monitors_clear(hdev); > - hci_bdaddr_list_clear(&hdev->le_white_list); > + hci_bdaddr_list_clear(&hdev->le_accept_list); > hci_bdaddr_list_clear(&hdev->le_resolv_list); > hci_conn_params_clear_all(hdev); > hci_discovery_filter_clear(hdev); > diff --git a/net/bluetooth/hci_debugfs.c b/net/bluetooth/hci_debugfs.c > index 47f4f21fbc1a..841393389f7b 100644 > --- a/net/bluetooth/hci_debugfs.c > +++ b/net/bluetooth/hci_debugfs.c > @@ -125,7 +125,7 @@ static int device_list_show(struct seq_file *f, void *ptr) > struct bdaddr_list *b; > > hci_dev_lock(hdev); > - list_for_each_entry(b, &hdev->whitelist, list) > + list_for_each_entry(b, &hdev->accept_list, list) > seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); > list_for_each_entry(p, &hdev->le_conn_params, list) { > seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type, > @@ -144,7 +144,7 @@ static int blacklist_show(struct seq_file *f, void *p) > struct bdaddr_list *b; > > hci_dev_lock(hdev); > - list_for_each_entry(b, &hdev->blacklist, list) > + list_for_each_entry(b, &hdev->reject_list, list) > seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); > hci_dev_unlock(hdev); > > @@ -784,7 +784,7 @@ static int white_list_show(struct seq_file *f, void *ptr) > struct bdaddr_list *b; > > hci_dev_lock(hdev); > - list_for_each_entry(b, &hdev->le_white_list, list) > + list_for_each_entry(b, &hdev->le_accept_list, list) > seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); > hci_dev_unlock(hdev); > > @@ -1195,7 +1195,7 @@ void hci_debugfs_create_le(struct hci_dev *hdev) > &force_static_address_fops); > > debugfs_create_u8("white_list_size", 0444, hdev->debugfs, > - &hdev->le_white_list_size); > + &hdev->le_accept_list_size); > debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, > &white_list_fops); > debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs, > diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c > index c5871c2a16ba..760e8e14e0f2 100644 > --- a/net/bluetooth/hci_event.c > +++ b/net/bluetooth/hci_event.c > @@ -236,7 +236,7 @@ static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb) > > hdev->ssp_debug_mode = 0; > > - hci_bdaddr_list_clear(&hdev->le_white_list); > + hci_bdaddr_list_clear(&hdev->le_accept_list); > hci_bdaddr_list_clear(&hdev->le_resolv_list); > } > > @@ -1492,21 +1492,21 @@ static void hci_cc_le_read_num_adv_sets(struct hci_dev *hdev, > hdev->le_num_of_adv_sets = rp->num_of_sets; > } > > -static void hci_cc_le_read_white_list_size(struct hci_dev *hdev, > - struct sk_buff *skb) > +static void hci_cc_le_read_accept_list_size(struct hci_dev *hdev, > + struct sk_buff *skb) > { > - struct hci_rp_le_read_white_list_size *rp = (void *) skb->data; > + struct hci_rp_le_read_accept_list_size *rp = (void *)skb->data; > > BT_DBG("%s status 0x%2.2x size %u", hdev->name, rp->status, rp->size); > > if (rp->status) > return; > > - hdev->le_white_list_size = rp->size; > + hdev->le_accept_list_size = rp->size; > } > > -static void hci_cc_le_clear_white_list(struct hci_dev *hdev, > - struct sk_buff *skb) > +static void hci_cc_le_clear_accept_list(struct hci_dev *hdev, > + struct sk_buff *skb) > { > __u8 status = *((__u8 *) skb->data); > > @@ -1515,13 +1515,13 @@ static void hci_cc_le_clear_white_list(struct hci_dev *hdev, > if (status) > return; > > - hci_bdaddr_list_clear(&hdev->le_white_list); > + hci_bdaddr_list_clear(&hdev->le_accept_list); > } > > -static void hci_cc_le_add_to_white_list(struct hci_dev *hdev, > - struct sk_buff *skb) > +static void hci_cc_le_add_to_accept_list(struct hci_dev *hdev, > + struct sk_buff *skb) > { > - struct hci_cp_le_add_to_white_list *sent; > + struct hci_cp_le_add_to_accept_list *sent; > __u8 status = *((__u8 *) skb->data); > > BT_DBG("%s status 0x%2.2x", hdev->name, status); > @@ -1529,18 +1529,18 @@ static void hci_cc_le_add_to_white_list(struct hci_dev *hdev, > if (status) > return; > > - sent = hci_sent_cmd_data(hdev, HCI_OP_LE_ADD_TO_WHITE_LIST); > + sent = hci_sent_cmd_data(hdev, HCI_OP_LE_ADD_TO_ACCEPT_LIST); > if (!sent) > return; > > - hci_bdaddr_list_add(&hdev->le_white_list, &sent->bdaddr, > - sent->bdaddr_type); > + hci_bdaddr_list_add(&hdev->le_accept_list, &sent->bdaddr, > + sent->bdaddr_type); > } > > -static void hci_cc_le_del_from_white_list(struct hci_dev *hdev, > - struct sk_buff *skb) > +static void hci_cc_le_del_from_accept_list(struct hci_dev *hdev, > + struct sk_buff *skb) > { > - struct hci_cp_le_del_from_white_list *sent; > + struct hci_cp_le_del_from_accept_list *sent; > __u8 status = *((__u8 *) skb->data); > > BT_DBG("%s status 0x%2.2x", hdev->name, status); > @@ -1548,11 +1548,11 @@ static void hci_cc_le_del_from_white_list(struct hci_dev *hdev, > if (status) > return; > > - sent = hci_sent_cmd_data(hdev, HCI_OP_LE_DEL_FROM_WHITE_LIST); > + sent = hci_sent_cmd_data(hdev, HCI_OP_LE_DEL_FROM_ACCEPT_LIST); > if (!sent) > return; > > - hci_bdaddr_list_del(&hdev->le_white_list, &sent->bdaddr, > + hci_bdaddr_list_del(&hdev->le_accept_list, &sent->bdaddr, > sent->bdaddr_type); > } > > @@ -2367,7 +2367,7 @@ static void cs_le_create_conn(struct hci_dev *hdev, bdaddr_t *peer_addr, > /* We don't want the connection attempt to stick around > * indefinitely since LE doesn't have a page timeout concept > * like BR/EDR. Set a timer for any connection that doesn't use > - * the white list for connecting. > + * the accept list for connecting. > */ > if (filter_policy == HCI_LE_USE_PEER_ADDR) > queue_delayed_work(conn->hdev->workqueue, > @@ -2623,7 +2623,7 @@ static void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) > * only used during suspend. > */ > if (ev->link_type == ACL_LINK && > - hci_bdaddr_list_lookup_with_flags(&hdev->whitelist, > + hci_bdaddr_list_lookup_with_flags(&hdev->accept_list, > &ev->bdaddr, > BDADDR_BREDR)) { > conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr, > @@ -2745,19 +2745,19 @@ static void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb) > return; > } > > - if (hci_bdaddr_list_lookup(&hdev->blacklist, &ev->bdaddr, > + if (hci_bdaddr_list_lookup(&hdev->reject_list, &ev->bdaddr, > BDADDR_BREDR)) { > hci_reject_conn(hdev, &ev->bdaddr); > return; > } > > - /* Require HCI_CONNECTABLE or a whitelist entry to accept the > + /* Require HCI_CONNECTABLE or an accept list entry to accept the > * connection. These features are only touched through mgmt so > * only do the checks if HCI_MGMT is set. > */ > if (hci_dev_test_flag(hdev, HCI_MGMT) && > !hci_dev_test_flag(hdev, HCI_CONNECTABLE) && > - !hci_bdaddr_list_lookup_with_flags(&hdev->whitelist, &ev->bdaddr, > + !hci_bdaddr_list_lookup_with_flags(&hdev->accept_list, &ev->bdaddr, > BDADDR_BREDR)) { > hci_reject_conn(hdev, &ev->bdaddr); > return; > @@ -3538,20 +3538,20 @@ static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb, > hci_cc_le_set_scan_enable(hdev, skb); > break; > > - case HCI_OP_LE_READ_WHITE_LIST_SIZE: > - hci_cc_le_read_white_list_size(hdev, skb); > + case HCI_OP_LE_READ_ACCEPT_LIST_SIZE: > + hci_cc_le_read_accept_list_size(hdev, skb); > break; > > - case HCI_OP_LE_CLEAR_WHITE_LIST: > - hci_cc_le_clear_white_list(hdev, skb); > + case HCI_OP_LE_CLEAR_ACCEPT_LIST: > + hci_cc_le_clear_accept_list(hdev, skb); > break; > > - case HCI_OP_LE_ADD_TO_WHITE_LIST: > - hci_cc_le_add_to_white_list(hdev, skb); > + case HCI_OP_LE_ADD_TO_ACCEPT_LIST: > + hci_cc_le_add_to_accept_list(hdev, skb); > break; > > - case HCI_OP_LE_DEL_FROM_WHITE_LIST: > - hci_cc_le_del_from_white_list(hdev, skb); > + case HCI_OP_LE_DEL_FROM_ACCEPT_LIST: > + hci_cc_le_del_from_accept_list(hdev, skb); > break; > > case HCI_OP_LE_READ_SUPPORTED_STATES: > @@ -5132,7 +5132,7 @@ static void le_conn_complete_evt(struct hci_dev *hdev, u8 status, > > /* If we didn't have a hci_conn object previously > * but we're in central role this must be something > - * initiated using a white list. Since white list based > + * initiated using an accept list. Since accept list based > * connections are not "first class citizens" we don't > * have full tracking of them. Therefore, we go ahead > * with a "best effort" approach of determining the > @@ -5224,7 +5224,7 @@ static void le_conn_complete_evt(struct hci_dev *hdev, u8 status, > addr_type = BDADDR_LE_RANDOM; > > /* Drop the connection if the device is blocked */ > - if (hci_bdaddr_list_lookup(&hdev->blacklist, &conn->dst, addr_type)) { > + if (hci_bdaddr_list_lookup(&hdev->reject_list, &conn->dst, addr_type)) { > hci_conn_drop(conn); > goto unlock; > } > @@ -5380,7 +5380,7 @@ static struct hci_conn *check_pending_le_conn(struct hci_dev *hdev, > return NULL; > > /* Ignore if the device is blocked */ > - if (hci_bdaddr_list_lookup(&hdev->blacklist, addr, addr_type)) > + if (hci_bdaddr_list_lookup(&hdev->reject_list, addr, addr_type)) > return NULL; > > /* Most controller will fail if we try to create new connections > diff --git a/net/bluetooth/hci_request.c b/net/bluetooth/hci_request.c > index a5d55175176e..f7a9d97f3e84 100644 > --- a/net/bluetooth/hci_request.c > +++ b/net/bluetooth/hci_request.c > @@ -745,17 +745,17 @@ void hci_req_add_le_scan_disable(struct hci_request *req, bool rpa_le_conn) > } > } > > -static void del_from_white_list(struct hci_request *req, bdaddr_t *bdaddr, > - u8 bdaddr_type) > +static void del_from_accept_list(struct hci_request *req, bdaddr_t *bdaddr, > + u8 bdaddr_type) > { > - struct hci_cp_le_del_from_white_list cp; > + struct hci_cp_le_del_from_accept_list cp; > > cp.bdaddr_type = bdaddr_type; > bacpy(&cp.bdaddr, bdaddr); > > - bt_dev_dbg(req->hdev, "Remove %pMR (0x%x) from whitelist", &cp.bdaddr, > + bt_dev_dbg(req->hdev, "Remove %pMR (0x%x) from accept list", &cp.bdaddr, > cp.bdaddr_type); > - hci_req_add(req, HCI_OP_LE_DEL_FROM_WHITE_LIST, sizeof(cp), &cp); > + hci_req_add(req, HCI_OP_LE_DEL_FROM_ACCEPT_LIST, sizeof(cp), &cp); > > if (use_ll_privacy(req->hdev) && > hci_dev_test_flag(req->hdev, HCI_ENABLE_LL_PRIVACY)) { > @@ -774,31 +774,31 @@ static void del_from_white_list(struct hci_request *req, bdaddr_t *bdaddr, > } > } > > -/* Adds connection to white list if needed. On error, returns -1. */ > -static int add_to_white_list(struct hci_request *req, > - struct hci_conn_params *params, u8 *num_entries, > - bool allow_rpa) > +/* Adds connection to accept list if needed. On error, returns -1. */ > +static int add_to_accept_list(struct hci_request *req, > + struct hci_conn_params *params, u8 *num_entries, > + bool allow_rpa) > { > - struct hci_cp_le_add_to_white_list cp; > + struct hci_cp_le_add_to_accept_list cp; > struct hci_dev *hdev = req->hdev; > > - /* Already in white list */ > - if (hci_bdaddr_list_lookup(&hdev->le_white_list, ¶ms->addr, > + /* Already in accept list */ > + if (hci_bdaddr_list_lookup(&hdev->le_accept_list, ¶ms->addr, > params->addr_type)) > return 0; > > /* Select filter policy to accept all advertising */ > - if (*num_entries >= hdev->le_white_list_size) > + if (*num_entries >= hdev->le_accept_list_size) > return -1; > > - /* White list can not be used with RPAs */ > + /* Accept list can not be used with RPAs */ > if (!allow_rpa && > !hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY) && > hci_find_irk_by_addr(hdev, ¶ms->addr, params->addr_type)) { > return -1; > } > > - /* During suspend, only wakeable devices can be in whitelist */ > + /* During suspend, only wakeable devices can be in accept list */ > if (hdev->suspended && !hci_conn_test_flag(HCI_CONN_FLAG_REMOTE_WAKEUP, > params->current_flags)) > return 0; > @@ -807,9 +807,9 @@ static int add_to_white_list(struct hci_request *req, > cp.bdaddr_type = params->addr_type; > bacpy(&cp.bdaddr, ¶ms->addr); > > - bt_dev_dbg(hdev, "Add %pMR (0x%x) to whitelist", &cp.bdaddr, > + bt_dev_dbg(hdev, "Add %pMR (0x%x) to accept list", &cp.bdaddr, > cp.bdaddr_type); > - hci_req_add(req, HCI_OP_LE_ADD_TO_WHITE_LIST, sizeof(cp), &cp); > + hci_req_add(req, HCI_OP_LE_ADD_TO_ACCEPT_LIST, sizeof(cp), &cp); > > if (use_ll_privacy(hdev) && > hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY)) { > @@ -837,15 +837,15 @@ static int add_to_white_list(struct hci_request *req, > return 0; > } > > -static u8 update_white_list(struct hci_request *req) > +static u8 update_accept_list(struct hci_request *req) > { > struct hci_dev *hdev = req->hdev; > struct hci_conn_params *params; > struct bdaddr_list *b; > u8 num_entries = 0; > bool pend_conn, pend_report; > - /* We allow whitelisting even with RPAs in suspend. In the worst case, > - * we won't be able to wake from devices that use the privacy1.2 > + /* We allow usage of accept list even with RPAs in suspend. In the worst > + * case, we won't be able to wake from devices that use the privacy1.2 > * features. Additionally, once we support privacy1.2 and IRK > * offloading, we can update this to also check for those conditions. > */ > @@ -855,13 +855,13 @@ static u8 update_white_list(struct hci_request *req) > hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY)) > allow_rpa = true; > > - /* Go through the current white list programmed into the > + /* Go through the current accept list programmed into the > * controller one by one and check if that address is still > * in the list of pending connections or list of devices to > * report. If not present in either list, then queue the > * command to remove it from the controller. > */ > - list_for_each_entry(b, &hdev->le_white_list, list) { > + list_for_each_entry(b, &hdev->le_accept_list, list) { > pend_conn = hci_pend_le_action_lookup(&hdev->pend_le_conns, > &b->bdaddr, > b->bdaddr_type); > @@ -870,14 +870,14 @@ static u8 update_white_list(struct hci_request *req) > b->bdaddr_type); > > /* If the device is not likely to connect or report, > - * remove it from the whitelist. > + * remove it from the accept list. > */ > if (!pend_conn && !pend_report) { > - del_from_white_list(req, &b->bdaddr, b->bdaddr_type); > + del_from_accept_list(req, &b->bdaddr, b->bdaddr_type); > continue; > } > > - /* White list can not be used with RPAs */ > + /* Accept list can not be used with RPAs */ > if (!allow_rpa && > !hci_dev_test_flag(hdev, HCI_ENABLE_LL_PRIVACY) && > hci_find_irk_by_addr(hdev, &b->bdaddr, b->bdaddr_type)) { > @@ -887,27 +887,27 @@ static u8 update_white_list(struct hci_request *req) > num_entries++; > } > > - /* Since all no longer valid white list entries have been > + /* Since all no longer valid accept list entries have been > * removed, walk through the list of pending connections > * and ensure that any new device gets programmed into > * the controller. > * > * If the list of the devices is larger than the list of > - * available white list entries in the controller, then > + * available accept list entries in the controller, then > * just abort and return filer policy value to not use the > - * white list. > + * accept list. > */ > list_for_each_entry(params, &hdev->pend_le_conns, action) { > - if (add_to_white_list(req, params, &num_entries, allow_rpa)) > + if (add_to_accept_list(req, params, &num_entries, allow_rpa)) > return 0x00; > } > > /* After adding all new pending connections, walk through > * the list of pending reports and also add these to the > - * white list if there is still space. Abort if space runs out. > + * accept list if there is still space. Abort if space runs out. > */ > list_for_each_entry(params, &hdev->pend_le_reports, action) { > - if (add_to_white_list(req, params, &num_entries, allow_rpa)) > + if (add_to_accept_list(req, params, &num_entries, allow_rpa)) > return 0x00; > } > > @@ -921,7 +921,7 @@ static u8 update_white_list(struct hci_request *req) > hdev->interleave_scan_state != INTERLEAVE_SCAN_ALLOWLIST) > return 0x00; > > - /* Select filter policy to use white list */ > + /* Select filter policy to use accept list */ > return 0x01; > } > > @@ -1078,20 +1078,20 @@ void hci_req_add_le_passive_scan(struct hci_request *req) > return; > > bt_dev_dbg(hdev, "interleave state %d", hdev->interleave_scan_state); > - /* Adding or removing entries from the white list must > + /* Adding or removing entries from the accept list must > * happen before enabling scanning. The controller does > - * not allow white list modification while scanning. > + * not allow accept list modification while scanning. > */ > - filter_policy = update_white_list(req); > + filter_policy = update_accept_list(req); > > /* When the controller is using random resolvable addresses and > * with that having LE privacy enabled, then controllers with > * Extended Scanner Filter Policies support can now enable support > * for handling directed advertising. > * > - * So instead of using filter polices 0x00 (no whitelist) > - * and 0x01 (whitelist enabled) use the new filter policies > - * 0x02 (no whitelist) and 0x03 (whitelist enabled). > + * So instead of using filter polices 0x00 (no accept list) > + * and 0x01 (accept list enabled) use the new filter policies > + * 0x02 (no accept list) and 0x03 (accept list enabled). > */ > if (hci_dev_test_flag(hdev, HCI_PRIVACY) && > (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY)) > @@ -1127,7 +1127,8 @@ void hci_req_add_le_passive_scan(struct hci_request *req) > interval = hdev->le_scan_interval; > } > > - bt_dev_dbg(hdev, "LE passive scan with whitelist = %d", filter_policy); > + bt_dev_dbg(hdev, "LE passive scan with accept list = %d", > + filter_policy); > hci_req_start_scan(req, LE_SCAN_PASSIVE, interval, window, > own_addr_type, filter_policy, filter_dup, > addr_resolv); > @@ -1180,7 +1181,7 @@ static void hci_req_set_event_filter(struct hci_request *req) > /* Always clear event filter when starting */ > hci_req_clear_event_filter(req); > > - list_for_each_entry(b, &hdev->whitelist, list) { > + list_for_each_entry(b, &hdev->accept_list, list) { > if (!hci_conn_test_flag(HCI_CONN_FLAG_REMOTE_WAKEUP, > b->current_flags)) > continue; > @@ -2623,11 +2624,11 @@ int hci_update_random_address(struct hci_request *req, bool require_privacy, > return 0; > } > > -static bool disconnected_whitelist_entries(struct hci_dev *hdev) > +static bool disconnected_accept_list_entries(struct hci_dev *hdev) > { > struct bdaddr_list *b; > > - list_for_each_entry(b, &hdev->whitelist, list) { > + list_for_each_entry(b, &hdev->accept_list, list) { > struct hci_conn *conn; > > conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &b->bdaddr); > @@ -2659,7 +2660,7 @@ void __hci_req_update_scan(struct hci_request *req) > return; > > if (hci_dev_test_flag(hdev, HCI_CONNECTABLE) || > - disconnected_whitelist_entries(hdev)) > + disconnected_accept_list_entries(hdev)) > scan = SCAN_PAGE; > else > scan = SCAN_DISABLED; > @@ -3151,7 +3152,7 @@ static int active_scan(struct hci_request *req, unsigned long opt) > uint16_t interval = opt; > struct hci_dev *hdev = req->hdev; > u8 own_addr_type; > - /* White list is not used for discovery */ > + /* Accept list is not used for discovery */ > u8 filter_policy = 0x00; > /* Default is to enable duplicates filter */ > u8 filter_dup = LE_SCAN_FILTER_DUP_ENABLE; > diff --git a/net/bluetooth/hci_sock.c b/net/bluetooth/hci_sock.c > index 251b9128f530..26d794b164f1 100644 > --- a/net/bluetooth/hci_sock.c > +++ b/net/bluetooth/hci_sock.c > @@ -892,7 +892,7 @@ static int hci_sock_release(struct socket *sock) > return 0; > } > > -static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg) > +static int hci_sock_reject_list_add(struct hci_dev *hdev, void __user *arg) > { > bdaddr_t bdaddr; > int err; > @@ -902,14 +902,14 @@ static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg) > > hci_dev_lock(hdev); > > - err = hci_bdaddr_list_add(&hdev->blacklist, &bdaddr, BDADDR_BREDR); > + err = hci_bdaddr_list_add(&hdev->reject_list, &bdaddr, BDADDR_BREDR); > > hci_dev_unlock(hdev); > > return err; > } > > -static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg) > +static int hci_sock_reject_list_del(struct hci_dev *hdev, void __user *arg) > { > bdaddr_t bdaddr; > int err; > @@ -919,7 +919,7 @@ static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg) > > hci_dev_lock(hdev); > > - err = hci_bdaddr_list_del(&hdev->blacklist, &bdaddr, BDADDR_BREDR); > + err = hci_bdaddr_list_del(&hdev->reject_list, &bdaddr, BDADDR_BREDR); > > hci_dev_unlock(hdev); > > @@ -959,12 +959,12 @@ static int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, > case HCIBLOCKADDR: > if (!capable(CAP_NET_ADMIN)) > return -EPERM; > - return hci_sock_blacklist_add(hdev, (void __user *)arg); > + return hci_sock_reject_list_add(hdev, (void __user *)arg); > > case HCIUNBLOCKADDR: > if (!capable(CAP_NET_ADMIN)) > return -EPERM; > - return hci_sock_blacklist_del(hdev, (void __user *)arg); > + return hci_sock_reject_list_del(hdev, (void __user *)arg); > } > > return -ENOIOCTLCMD; > diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c > index c10a45368ec2..6b0f8f7867bc 100644 > --- a/net/bluetooth/l2cap_core.c > +++ b/net/bluetooth/l2cap_core.c > @@ -7662,7 +7662,7 @@ static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb) > * at least ensure that we ignore incoming data from them. > */ > if (hcon->type == LE_LINK && > - hci_bdaddr_list_lookup(&hcon->hdev->blacklist, &hcon->dst, > + hci_bdaddr_list_lookup(&hcon->hdev->reject_list, &hcon->dst, > bdaddr_dst_type(hcon))) { > kfree_skb(skb); > return; > @@ -8119,7 +8119,7 @@ static void l2cap_connect_cfm(struct hci_conn *hcon, u8 status) > dst_type = bdaddr_dst_type(hcon); > > /* If device is blocked, do not create channels for it */ > - if (hci_bdaddr_list_lookup(&hdev->blacklist, &hcon->dst, dst_type)) > + if (hci_bdaddr_list_lookup(&hdev->reject_list, &hcon->dst, dst_type)) > return; > > /* Find fixed channels and notify them of the new connection. We > diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c > index 6adee6de1e03..f0e4ebed72b8 100644 > --- a/net/bluetooth/mgmt.c > +++ b/net/bluetooth/mgmt.c > @@ -4064,9 +4064,10 @@ static int get_device_flags(struct sock *sk, struct hci_dev *hdev, void *data, > memset(&rp, 0, sizeof(rp)); > > if (cp->addr.type == BDADDR_BREDR) { > - br_params = hci_bdaddr_list_lookup_with_flags(&hdev->whitelist, > - &cp->addr.bdaddr, > - cp->addr.type); > + br_params = > + hci_bdaddr_list_lookup_with_flags(&hdev->accept_list, > + &cp->addr.bdaddr, > + cp->addr.type); break the 80 columns rule here. > if (!br_params) > goto done; > > @@ -4132,9 +4133,10 @@ static int set_device_flags(struct sock *sk, struct hci_dev *hdev, void *data, > hci_dev_lock(hdev); > > if (cp->addr.type == BDADDR_BREDR) { > - br_params = hci_bdaddr_list_lookup_with_flags(&hdev->whitelist, > - &cp->addr.bdaddr, > - cp->addr.type); > + br_params = > + hci_bdaddr_list_lookup_with_flags(&hdev->accept_list, > + &cp->addr.bdaddr, > + cp->addr.type); And here as well. Regards Marcel
