1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2018 - 2021 Intel Corporation 4 */ 5 #ifndef __PMSR_H 6 #define __PMSR_H 7 #include <net/cfg80211.h> 8 #include "core.h" 9 #include "nl80211.h" 10 #include "rdev-ops.h" 11 12 static int pmsr_parse_ftm(struct cfg80211_registered_device *rdev, 13 struct nlattr *ftmreq, 14 struct cfg80211_pmsr_request_peer *out, 15 struct genl_info *info) 16 { 17 const struct cfg80211_pmsr_capabilities *capa = rdev->wiphy.pmsr_capa; 18 struct nlattr *tb[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1]; 19 u32 preamble = NL80211_PREAMBLE_DMG; /* only optional in DMG */ 20 21 /* validate existing data */ 22 if (!(rdev->wiphy.pmsr_capa->ftm.bandwidths & BIT(out->chandef.width))) { 23 NL_SET_ERR_MSG(info->extack, "FTM: unsupported bandwidth"); 24 return -EINVAL; 25 } 26 27 /* no validation needed - was already done via nested policy */ 28 nla_parse_nested_deprecated(tb, NL80211_PMSR_FTM_REQ_ATTR_MAX, ftmreq, 29 NULL, NULL); 30 31 if (tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) 32 preamble = nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]); 33 34 /* set up values - struct is 0-initialized */ 35 out->ftm.requested = true; 36 37 switch (out->chandef.chan->band) { 38 case NL80211_BAND_60GHZ: 39 /* optional */ 40 break; 41 default: 42 if (!tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) { 43 NL_SET_ERR_MSG(info->extack, 44 "FTM: must specify preamble"); 45 return -EINVAL; 46 } 47 } 48 49 if (!(capa->ftm.preambles & BIT(preamble))) { 50 NL_SET_ERR_MSG_ATTR(info->extack, 51 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 52 "FTM: invalid preamble"); 53 return -EINVAL; 54 } 55 56 out->ftm.preamble = preamble; 57 58 out->ftm.burst_period = 0; 59 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]) 60 out->ftm.burst_period = 61 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]); 62 63 out->ftm.asap = !!tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP]; 64 if (out->ftm.asap && !capa->ftm.asap) { 65 NL_SET_ERR_MSG_ATTR(info->extack, 66 tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP], 67 "FTM: ASAP mode not supported"); 68 return -EINVAL; 69 } 70 71 if (!out->ftm.asap && !capa->ftm.non_asap) { 72 NL_SET_ERR_MSG(info->extack, 73 "FTM: non-ASAP mode not supported"); 74 return -EINVAL; 75 } 76 77 out->ftm.num_bursts_exp = 0; 78 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]) 79 out->ftm.num_bursts_exp = 80 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]); 81 82 if (capa->ftm.max_bursts_exponent >= 0 && 83 out->ftm.num_bursts_exp > capa->ftm.max_bursts_exponent) { 84 NL_SET_ERR_MSG_ATTR(info->extack, 85 tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP], 86 "FTM: max NUM_BURSTS_EXP must be set lower than the device limit"); 87 return -EINVAL; 88 } 89 90 out->ftm.burst_duration = 15; 91 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]) 92 out->ftm.burst_duration = 93 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]); 94 95 out->ftm.ftms_per_burst = 0; 96 if (tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]) 97 out->ftm.ftms_per_burst = 98 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]); 99 100 if (capa->ftm.max_ftms_per_burst && 101 (out->ftm.ftms_per_burst > capa->ftm.max_ftms_per_burst || 102 out->ftm.ftms_per_burst == 0)) { 103 NL_SET_ERR_MSG_ATTR(info->extack, 104 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 105 "FTM: FTMs per burst must be set lower than the device limit but non-zero"); 106 return -EINVAL; 107 } 108 109 out->ftm.ftmr_retries = 3; 110 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]) 111 out->ftm.ftmr_retries = 112 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]); 113 114 out->ftm.request_lci = !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI]; 115 if (out->ftm.request_lci && !capa->ftm.request_lci) { 116 NL_SET_ERR_MSG_ATTR(info->extack, 117 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI], 118 "FTM: LCI request not supported"); 119 } 120 121 out->ftm.request_civicloc = 122 !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC]; 123 if (out->ftm.request_civicloc && !capa->ftm.request_civicloc) { 124 NL_SET_ERR_MSG_ATTR(info->extack, 125 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC], 126 "FTM: civic location request not supported"); 127 } 128 129 out->ftm.trigger_based = 130 !!tb[NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED]; 131 if (out->ftm.trigger_based && !capa->ftm.trigger_based) { 132 NL_SET_ERR_MSG_ATTR(info->extack, 133 tb[NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED], 134 "FTM: trigger based ranging is not supported"); 135 return -EINVAL; 136 } 137 138 out->ftm.non_trigger_based = 139 !!tb[NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED]; 140 if (out->ftm.non_trigger_based && !capa->ftm.non_trigger_based) { 141 NL_SET_ERR_MSG_ATTR(info->extack, 142 tb[NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED], 143 "FTM: trigger based ranging is not supported"); 144 return -EINVAL; 145 } 146 147 if (out->ftm.trigger_based && out->ftm.non_trigger_based) { 148 NL_SET_ERR_MSG(info->extack, 149 "FTM: can't set both trigger based and non trigger based"); 150 return -EINVAL; 151 } 152 153 if ((out->ftm.trigger_based || out->ftm.non_trigger_based) && 154 out->ftm.preamble != NL80211_PREAMBLE_HE) { 155 NL_SET_ERR_MSG_ATTR(info->extack, 156 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 157 "FTM: non EDCA based ranging must use HE preamble"); 158 return -EINVAL; 159 } 160 161 out->ftm.lmr_feedback = 162 !!tb[NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK]; 163 if (!out->ftm.trigger_based && !out->ftm.non_trigger_based && 164 out->ftm.lmr_feedback) { 165 NL_SET_ERR_MSG_ATTR(info->extack, 166 tb[NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK], 167 "FTM: LMR feedback set for EDCA based ranging"); 168 return -EINVAL; 169 } 170 171 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR]) { 172 if (!out->ftm.non_trigger_based && !out->ftm.trigger_based) { 173 NL_SET_ERR_MSG_ATTR(info->extack, 174 tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR], 175 "FTM: BSS color set for EDCA based ranging"); 176 return -EINVAL; 177 } 178 179 out->ftm.bss_color = 180 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR]); 181 } 182 183 return 0; 184 } 185 186 static int pmsr_parse_peer(struct cfg80211_registered_device *rdev, 187 struct nlattr *peer, 188 struct cfg80211_pmsr_request_peer *out, 189 struct genl_info *info) 190 { 191 struct nlattr *tb[NL80211_PMSR_PEER_ATTR_MAX + 1]; 192 struct nlattr *req[NL80211_PMSR_REQ_ATTR_MAX + 1]; 193 struct nlattr *treq; 194 int err, rem; 195 196 /* no validation needed - was already done via nested policy */ 197 nla_parse_nested_deprecated(tb, NL80211_PMSR_PEER_ATTR_MAX, peer, 198 NULL, NULL); 199 200 if (!tb[NL80211_PMSR_PEER_ATTR_ADDR] || 201 !tb[NL80211_PMSR_PEER_ATTR_CHAN] || 202 !tb[NL80211_PMSR_PEER_ATTR_REQ]) { 203 NL_SET_ERR_MSG_ATTR(info->extack, peer, 204 "insufficient peer data"); 205 return -EINVAL; 206 } 207 208 memcpy(out->addr, nla_data(tb[NL80211_PMSR_PEER_ATTR_ADDR]), ETH_ALEN); 209 210 /* reuse info->attrs */ 211 memset(info->attrs, 0, sizeof(*info->attrs) * (NL80211_ATTR_MAX + 1)); 212 err = nla_parse_nested_deprecated(info->attrs, NL80211_ATTR_MAX, 213 tb[NL80211_PMSR_PEER_ATTR_CHAN], 214 NULL, info->extack); 215 if (err) 216 return err; 217 218 err = nl80211_parse_chandef(rdev, info, &out->chandef); 219 if (err) 220 return err; 221 222 /* no validation needed - was already done via nested policy */ 223 nla_parse_nested_deprecated(req, NL80211_PMSR_REQ_ATTR_MAX, 224 tb[NL80211_PMSR_PEER_ATTR_REQ], NULL, 225 NULL); 226 227 if (!req[NL80211_PMSR_REQ_ATTR_DATA]) { 228 NL_SET_ERR_MSG_ATTR(info->extack, 229 tb[NL80211_PMSR_PEER_ATTR_REQ], 230 "missing request type/data"); 231 return -EINVAL; 232 } 233 234 if (req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF]) 235 out->report_ap_tsf = true; 236 237 if (out->report_ap_tsf && !rdev->wiphy.pmsr_capa->report_ap_tsf) { 238 NL_SET_ERR_MSG_ATTR(info->extack, 239 req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF], 240 "reporting AP TSF is not supported"); 241 return -EINVAL; 242 } 243 244 nla_for_each_nested(treq, req[NL80211_PMSR_REQ_ATTR_DATA], rem) { 245 switch (nla_type(treq)) { 246 case NL80211_PMSR_TYPE_FTM: 247 err = pmsr_parse_ftm(rdev, treq, out, info); 248 break; 249 default: 250 NL_SET_ERR_MSG_ATTR(info->extack, treq, 251 "unsupported measurement type"); 252 err = -EINVAL; 253 } 254 } 255 256 if (err) 257 return err; 258 259 return 0; 260 } 261 262 int nl80211_pmsr_start(struct sk_buff *skb, struct genl_info *info) 263 { 264 struct nlattr *reqattr = info->attrs[NL80211_ATTR_PEER_MEASUREMENTS]; 265 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 266 struct wireless_dev *wdev = info->user_ptr[1]; 267 struct cfg80211_pmsr_request *req; 268 struct nlattr *peers, *peer; 269 int count, rem, err, idx; 270 271 if (!rdev->wiphy.pmsr_capa) 272 return -EOPNOTSUPP; 273 274 if (!reqattr) 275 return -EINVAL; 276 277 peers = nla_find(nla_data(reqattr), nla_len(reqattr), 278 NL80211_PMSR_ATTR_PEERS); 279 if (!peers) 280 return -EINVAL; 281 282 count = 0; 283 nla_for_each_nested(peer, peers, rem) { 284 count++; 285 286 if (count > rdev->wiphy.pmsr_capa->max_peers) { 287 NL_SET_ERR_MSG_ATTR(info->extack, peer, 288 "Too many peers used"); 289 return -EINVAL; 290 } 291 } 292 293 req = kzalloc(struct_size(req, peers, count), GFP_KERNEL); 294 if (!req) 295 return -ENOMEM; 296 297 if (info->attrs[NL80211_ATTR_TIMEOUT]) 298 req->timeout = nla_get_u32(info->attrs[NL80211_ATTR_TIMEOUT]); 299 300 if (info->attrs[NL80211_ATTR_MAC]) { 301 if (!rdev->wiphy.pmsr_capa->randomize_mac_addr) { 302 NL_SET_ERR_MSG_ATTR(info->extack, 303 info->attrs[NL80211_ATTR_MAC], 304 "device cannot randomize MAC address"); 305 err = -EINVAL; 306 goto out_err; 307 } 308 309 err = nl80211_parse_random_mac(info->attrs, req->mac_addr, 310 req->mac_addr_mask); 311 if (err) 312 goto out_err; 313 } else { 314 memcpy(req->mac_addr, wdev_address(wdev), ETH_ALEN); 315 eth_broadcast_addr(req->mac_addr_mask); 316 } 317 318 idx = 0; 319 nla_for_each_nested(peer, peers, rem) { 320 /* NB: this reuses info->attrs, but we no longer need it */ 321 err = pmsr_parse_peer(rdev, peer, &req->peers[idx], info); 322 if (err) 323 goto out_err; 324 idx++; 325 } 326 327 req->n_peers = count; 328 req->cookie = cfg80211_assign_cookie(rdev); 329 req->nl_portid = info->snd_portid; 330 331 err = rdev_start_pmsr(rdev, wdev, req); 332 if (err) 333 goto out_err; 334 335 list_add_tail(&req->list, &wdev->pmsr_list); 336 337 nl_set_extack_cookie_u64(info->extack, req->cookie); 338 return 0; 339 out_err: 340 kfree(req); 341 return err; 342 } 343 344 void cfg80211_pmsr_complete(struct wireless_dev *wdev, 345 struct cfg80211_pmsr_request *req, 346 gfp_t gfp) 347 { 348 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 349 struct cfg80211_pmsr_request *tmp, *prev, *to_free = NULL; 350 struct sk_buff *msg; 351 void *hdr; 352 353 trace_cfg80211_pmsr_complete(wdev->wiphy, wdev, req->cookie); 354 355 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 356 if (!msg) 357 goto free_request; 358 359 hdr = nl80211hdr_put(msg, 0, 0, 0, 360 NL80211_CMD_PEER_MEASUREMENT_COMPLETE); 361 if (!hdr) 362 goto free_msg; 363 364 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 365 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 366 NL80211_ATTR_PAD)) 367 goto free_msg; 368 369 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie, 370 NL80211_ATTR_PAD)) 371 goto free_msg; 372 373 genlmsg_end(msg, hdr); 374 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid); 375 goto free_request; 376 free_msg: 377 nlmsg_free(msg); 378 free_request: 379 spin_lock_bh(&wdev->pmsr_lock); 380 /* 381 * cfg80211_pmsr_process_abort() may have already moved this request 382 * to the free list, and will free it later. In this case, don't free 383 * it here. 384 */ 385 list_for_each_entry_safe(tmp, prev, &wdev->pmsr_list, list) { 386 if (tmp == req) { 387 list_del(&req->list); 388 to_free = req; 389 break; 390 } 391 } 392 spin_unlock_bh(&wdev->pmsr_lock); 393 kfree(to_free); 394 } 395 EXPORT_SYMBOL_GPL(cfg80211_pmsr_complete); 396 397 static int nl80211_pmsr_send_ftm_res(struct sk_buff *msg, 398 struct cfg80211_pmsr_result *res) 399 { 400 if (res->status == NL80211_PMSR_STATUS_FAILURE) { 401 if (nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON, 402 res->ftm.failure_reason)) 403 goto error; 404 405 if (res->ftm.failure_reason == 406 NL80211_PMSR_FTM_FAILURE_PEER_BUSY && 407 res->ftm.busy_retry_time && 408 nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME, 409 res->ftm.busy_retry_time)) 410 goto error; 411 412 return 0; 413 } 414 415 #define PUT(tp, attr, val) \ 416 do { \ 417 if (nla_put_##tp(msg, \ 418 NL80211_PMSR_FTM_RESP_ATTR_##attr, \ 419 res->ftm.val)) \ 420 goto error; \ 421 } while (0) 422 423 #define PUTOPT(tp, attr, val) \ 424 do { \ 425 if (res->ftm.val##_valid) \ 426 PUT(tp, attr, val); \ 427 } while (0) 428 429 #define PUT_U64(attr, val) \ 430 do { \ 431 if (nla_put_u64_64bit(msg, \ 432 NL80211_PMSR_FTM_RESP_ATTR_##attr,\ 433 res->ftm.val, \ 434 NL80211_PMSR_FTM_RESP_ATTR_PAD)) \ 435 goto error; \ 436 } while (0) 437 438 #define PUTOPT_U64(attr, val) \ 439 do { \ 440 if (res->ftm.val##_valid) \ 441 PUT_U64(attr, val); \ 442 } while (0) 443 444 if (res->ftm.burst_index >= 0) 445 PUT(u32, BURST_INDEX, burst_index); 446 PUTOPT(u32, NUM_FTMR_ATTEMPTS, num_ftmr_attempts); 447 PUTOPT(u32, NUM_FTMR_SUCCESSES, num_ftmr_successes); 448 PUT(u8, NUM_BURSTS_EXP, num_bursts_exp); 449 PUT(u8, BURST_DURATION, burst_duration); 450 PUT(u8, FTMS_PER_BURST, ftms_per_burst); 451 PUTOPT(s32, RSSI_AVG, rssi_avg); 452 PUTOPT(s32, RSSI_SPREAD, rssi_spread); 453 if (res->ftm.tx_rate_valid && 454 !nl80211_put_sta_rate(msg, &res->ftm.tx_rate, 455 NL80211_PMSR_FTM_RESP_ATTR_TX_RATE)) 456 goto error; 457 if (res->ftm.rx_rate_valid && 458 !nl80211_put_sta_rate(msg, &res->ftm.rx_rate, 459 NL80211_PMSR_FTM_RESP_ATTR_RX_RATE)) 460 goto error; 461 PUTOPT_U64(RTT_AVG, rtt_avg); 462 PUTOPT_U64(RTT_VARIANCE, rtt_variance); 463 PUTOPT_U64(RTT_SPREAD, rtt_spread); 464 PUTOPT_U64(DIST_AVG, dist_avg); 465 PUTOPT_U64(DIST_VARIANCE, dist_variance); 466 PUTOPT_U64(DIST_SPREAD, dist_spread); 467 if (res->ftm.lci && res->ftm.lci_len && 468 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_LCI, 469 res->ftm.lci_len, res->ftm.lci)) 470 goto error; 471 if (res->ftm.civicloc && res->ftm.civicloc_len && 472 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC, 473 res->ftm.civicloc_len, res->ftm.civicloc)) 474 goto error; 475 #undef PUT 476 #undef PUTOPT 477 #undef PUT_U64 478 #undef PUTOPT_U64 479 480 return 0; 481 error: 482 return -ENOSPC; 483 } 484 485 static int nl80211_pmsr_send_result(struct sk_buff *msg, 486 struct cfg80211_pmsr_result *res) 487 { 488 struct nlattr *pmsr, *peers, *peer, *resp, *data, *typedata; 489 490 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS); 491 if (!pmsr) 492 goto error; 493 494 peers = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_PEERS); 495 if (!peers) 496 goto error; 497 498 peer = nla_nest_start_noflag(msg, 1); 499 if (!peer) 500 goto error; 501 502 if (nla_put(msg, NL80211_PMSR_PEER_ATTR_ADDR, ETH_ALEN, res->addr)) 503 goto error; 504 505 resp = nla_nest_start_noflag(msg, NL80211_PMSR_PEER_ATTR_RESP); 506 if (!resp) 507 goto error; 508 509 if (nla_put_u32(msg, NL80211_PMSR_RESP_ATTR_STATUS, res->status) || 510 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_HOST_TIME, 511 res->host_time, NL80211_PMSR_RESP_ATTR_PAD)) 512 goto error; 513 514 if (res->ap_tsf_valid && 515 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_AP_TSF, 516 res->ap_tsf, NL80211_PMSR_RESP_ATTR_PAD)) 517 goto error; 518 519 if (res->final && nla_put_flag(msg, NL80211_PMSR_RESP_ATTR_FINAL)) 520 goto error; 521 522 data = nla_nest_start_noflag(msg, NL80211_PMSR_RESP_ATTR_DATA); 523 if (!data) 524 goto error; 525 526 typedata = nla_nest_start_noflag(msg, res->type); 527 if (!typedata) 528 goto error; 529 530 switch (res->type) { 531 case NL80211_PMSR_TYPE_FTM: 532 if (nl80211_pmsr_send_ftm_res(msg, res)) 533 goto error; 534 break; 535 default: 536 WARN_ON(1); 537 } 538 539 nla_nest_end(msg, typedata); 540 nla_nest_end(msg, data); 541 nla_nest_end(msg, resp); 542 nla_nest_end(msg, peer); 543 nla_nest_end(msg, peers); 544 nla_nest_end(msg, pmsr); 545 546 return 0; 547 error: 548 return -ENOSPC; 549 } 550 551 void cfg80211_pmsr_report(struct wireless_dev *wdev, 552 struct cfg80211_pmsr_request *req, 553 struct cfg80211_pmsr_result *result, 554 gfp_t gfp) 555 { 556 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 557 struct sk_buff *msg; 558 void *hdr; 559 int err; 560 561 trace_cfg80211_pmsr_report(wdev->wiphy, wdev, req->cookie, 562 result->addr); 563 564 /* 565 * Currently, only variable items are LCI and civic location, 566 * both of which are reasonably short so we don't need to 567 * worry about them here for the allocation. 568 */ 569 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 570 if (!msg) 571 return; 572 573 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PEER_MEASUREMENT_RESULT); 574 if (!hdr) 575 goto free; 576 577 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 578 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 579 NL80211_ATTR_PAD)) 580 goto free; 581 582 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie, 583 NL80211_ATTR_PAD)) 584 goto free; 585 586 err = nl80211_pmsr_send_result(msg, result); 587 if (err) { 588 pr_err_ratelimited("peer measurement result: message didn't fit!"); 589 goto free; 590 } 591 592 genlmsg_end(msg, hdr); 593 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid); 594 return; 595 free: 596 nlmsg_free(msg); 597 } 598 EXPORT_SYMBOL_GPL(cfg80211_pmsr_report); 599 600 static void cfg80211_pmsr_process_abort(struct wireless_dev *wdev) 601 { 602 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 603 struct cfg80211_pmsr_request *req, *tmp; 604 LIST_HEAD(free_list); 605 606 lockdep_assert_held(&wdev->mtx); 607 608 spin_lock_bh(&wdev->pmsr_lock); 609 list_for_each_entry_safe(req, tmp, &wdev->pmsr_list, list) { 610 if (req->nl_portid) 611 continue; 612 list_move_tail(&req->list, &free_list); 613 } 614 spin_unlock_bh(&wdev->pmsr_lock); 615 616 list_for_each_entry_safe(req, tmp, &free_list, list) { 617 rdev_abort_pmsr(rdev, wdev, req); 618 619 kfree(req); 620 } 621 } 622 623 void cfg80211_pmsr_free_wk(struct work_struct *work) 624 { 625 struct wireless_dev *wdev = container_of(work, struct wireless_dev, 626 pmsr_free_wk); 627 628 wdev_lock(wdev); 629 cfg80211_pmsr_process_abort(wdev); 630 wdev_unlock(wdev); 631 } 632 633 void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev) 634 { 635 struct cfg80211_pmsr_request *req; 636 bool found = false; 637 638 spin_lock_bh(&wdev->pmsr_lock); 639 list_for_each_entry(req, &wdev->pmsr_list, list) { 640 found = true; 641 req->nl_portid = 0; 642 } 643 spin_unlock_bh(&wdev->pmsr_lock); 644 645 if (found) 646 cfg80211_pmsr_process_abort(wdev); 647 648 WARN_ON(!list_empty(&wdev->pmsr_list)); 649 } 650 651 void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid) 652 { 653 struct cfg80211_pmsr_request *req; 654 655 spin_lock_bh(&wdev->pmsr_lock); 656 list_for_each_entry(req, &wdev->pmsr_list, list) { 657 if (req->nl_portid == portid) { 658 req->nl_portid = 0; 659 schedule_work(&wdev->pmsr_free_wk); 660 } 661 } 662 spin_unlock_bh(&wdev->pmsr_lock); 663 } 664 665 #endif /* __PMSR_H */ 666