1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2018 - 2021, 2023 - 2026 Intel Corporation 4 */ 5 #include <net/cfg80211.h> 6 #include "core.h" 7 #include "nl80211.h" 8 #include "rdev-ops.h" 9 10 static int pmsr_parse_ftm(struct cfg80211_registered_device *rdev, 11 struct nlattr *ftmreq, 12 struct cfg80211_pmsr_request_peer *out, 13 struct genl_info *info) 14 { 15 const struct cfg80211_pmsr_capabilities *capa = rdev->wiphy.pmsr_capa; 16 struct nlattr *tb[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1]; 17 u32 preamble = NL80211_PREAMBLE_DMG; /* only optional in DMG */ 18 19 /* validate existing data */ 20 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_INFRA && 21 !(capa->ftm.bandwidths & BIT(out->chandef.width))) { 22 NL_SET_ERR_MSG(info->extack, "FTM: unsupported bandwidth"); 23 return -EINVAL; 24 } 25 26 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 27 !(capa->ftm.pd_bandwidths & BIT(out->chandef.width))) { 28 NL_SET_ERR_MSG(info->extack, 29 "FTM: unsupported bandwidth for PD request"); 30 return -EINVAL; 31 } 32 33 /* no validation needed - was already done via nested policy */ 34 nla_parse_nested_deprecated(tb, NL80211_PMSR_FTM_REQ_ATTR_MAX, ftmreq, 35 NULL, NULL); 36 37 if (tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) 38 preamble = nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]); 39 40 /* set up values - struct is 0-initialized */ 41 out->ftm.requested = true; 42 43 switch (out->chandef.chan->band) { 44 case NL80211_BAND_60GHZ: 45 /* optional */ 46 break; 47 default: 48 if (!tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) { 49 NL_SET_ERR_MSG(info->extack, 50 "FTM: must specify preamble"); 51 return -EINVAL; 52 } 53 } 54 55 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_INFRA && 56 !(capa->ftm.preambles & BIT(preamble))) { 57 NL_SET_ERR_MSG_ATTR(info->extack, 58 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 59 "FTM: invalid preamble"); 60 return -EINVAL; 61 } 62 63 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 64 !(capa->ftm.pd_preambles & BIT(preamble))) { 65 NL_SET_ERR_MSG_ATTR(info->extack, 66 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 67 "FTM: invalid preamble for PD request"); 68 return -EINVAL; 69 } 70 71 out->ftm.preamble = preamble; 72 73 out->ftm.burst_period = 0; 74 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]) 75 out->ftm.burst_period = 76 nla_get_u16(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]); 77 78 out->ftm.asap = !!tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP]; 79 if (out->ftm.asap && !capa->ftm.asap) { 80 NL_SET_ERR_MSG_ATTR(info->extack, 81 tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP], 82 "FTM: ASAP mode not supported"); 83 return -EINVAL; 84 } 85 86 if (!out->ftm.asap && !capa->ftm.non_asap) { 87 NL_SET_ERR_MSG(info->extack, 88 "FTM: non-ASAP mode not supported"); 89 return -EINVAL; 90 } 91 92 out->ftm.num_bursts_exp = 0; 93 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]) 94 out->ftm.num_bursts_exp = 95 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]); 96 97 if (capa->ftm.max_bursts_exponent >= 0 && 98 out->ftm.num_bursts_exp > capa->ftm.max_bursts_exponent) { 99 NL_SET_ERR_MSG_ATTR(info->extack, 100 tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP], 101 "FTM: max NUM_BURSTS_EXP must be set lower than the device limit"); 102 return -EINVAL; 103 } 104 105 out->ftm.ftms_per_burst = 0; 106 if (tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]) 107 out->ftm.ftms_per_burst = 108 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]); 109 110 if (capa->ftm.max_ftms_per_burst && 111 out->ftm.ftms_per_burst > capa->ftm.max_ftms_per_burst) { 112 NL_SET_ERR_MSG_ATTR(info->extack, 113 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 114 "FTM: FTMs per burst must be set lower than the device limit"); 115 return -EINVAL; 116 } 117 118 out->ftm.ftmr_retries = 3; 119 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]) 120 out->ftm.ftmr_retries = 121 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]); 122 123 out->ftm.request_lci = !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI]; 124 if (out->ftm.request_lci && !capa->ftm.request_lci) { 125 NL_SET_ERR_MSG_ATTR(info->extack, 126 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI], 127 "FTM: LCI request not supported"); 128 return -EOPNOTSUPP; 129 } 130 131 out->ftm.request_civicloc = 132 !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC]; 133 if (out->ftm.request_civicloc && !capa->ftm.request_civicloc) { 134 NL_SET_ERR_MSG_ATTR(info->extack, 135 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC], 136 "FTM: civic location request not supported"); 137 return -EOPNOTSUPP; 138 } 139 140 out->ftm.trigger_based = 141 !!tb[NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED]; 142 if (out->ftm.trigger_based && !capa->ftm.trigger_based) { 143 NL_SET_ERR_MSG_ATTR(info->extack, 144 tb[NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED], 145 "FTM: trigger based ranging is not supported"); 146 return -EINVAL; 147 } 148 149 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 150 out->ftm.trigger_based) { 151 NL_SET_ERR_MSG_ATTR(info->extack, 152 ftmreq, 153 "FTM: TB ranging is not supported for PD request type"); 154 return -EINVAL; 155 } 156 157 out->ftm.non_trigger_based = 158 !!tb[NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED]; 159 if (out->ftm.non_trigger_based && !capa->ftm.non_trigger_based) { 160 NL_SET_ERR_MSG_ATTR(info->extack, 161 tb[NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED], 162 "FTM: trigger based ranging is not supported"); 163 return -EINVAL; 164 } 165 166 if (out->ftm.trigger_based && out->ftm.non_trigger_based) { 167 NL_SET_ERR_MSG(info->extack, 168 "FTM: can't set both trigger based and non trigger based"); 169 return -EINVAL; 170 } 171 172 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 173 out->ftm.non_trigger_based && out->ftm.ftms_per_burst > 4) { 174 NL_SET_ERR_MSG_ATTR(info->extack, 175 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 176 "FTM: FTMs per burst must not exceed 4 for PD NTB ranging"); 177 return -ERANGE; 178 } 179 180 if (out->ftm.ftms_per_burst > 31 && !out->ftm.non_trigger_based && 181 !out->ftm.trigger_based) { 182 NL_SET_ERR_MSG_ATTR(info->extack, 183 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 184 "FTM: FTMs per burst must be set lower than 31"); 185 return -ERANGE; 186 } 187 188 if ((out->ftm.trigger_based || out->ftm.non_trigger_based) && 189 out->ftm.preamble != NL80211_PREAMBLE_HE) { 190 NL_SET_ERR_MSG_ATTR(info->extack, 191 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 192 "FTM: non EDCA based ranging must use HE preamble"); 193 return -EINVAL; 194 } 195 196 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]) 197 out->ftm.burst_duration = 198 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]); 199 else if (!out->ftm.non_trigger_based && !out->ftm.trigger_based) 200 out->ftm.burst_duration = 15; 201 202 out->ftm.lmr_feedback = 203 !!tb[NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK]; 204 if (!out->ftm.trigger_based && !out->ftm.non_trigger_based && 205 out->ftm.lmr_feedback) { 206 NL_SET_ERR_MSG_ATTR(info->extack, 207 tb[NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK], 208 "FTM: LMR feedback set for EDCA based ranging"); 209 return -EINVAL; 210 } 211 212 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR]) { 213 if (!out->ftm.non_trigger_based && !out->ftm.trigger_based) { 214 NL_SET_ERR_MSG_ATTR(info->extack, 215 tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR], 216 "FTM: BSS color set for EDCA based ranging"); 217 return -EINVAL; 218 } 219 220 out->ftm.bss_color = 221 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR]); 222 } 223 224 out->ftm.rsta = !!tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA]; 225 if (out->ftm.rsta && out->ftm.non_trigger_based && 226 !capa->ftm.rsta.support_ntb) { 227 NL_SET_ERR_MSG_ATTR(info->extack, 228 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 229 "FTM: NTB RSTA not supported by device"); 230 return -EOPNOTSUPP; 231 } 232 233 if (out->ftm.rsta && out->ftm.trigger_based && 234 !capa->ftm.rsta.support_tb) { 235 NL_SET_ERR_MSG_ATTR(info->extack, 236 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 237 "FTM: TB RSTA not supported by device"); 238 return -EOPNOTSUPP; 239 } 240 241 if (out->ftm.rsta && !out->ftm.non_trigger_based && 242 !out->ftm.trigger_based && 243 !capa->ftm.rsta.support_edca) { 244 NL_SET_ERR_MSG_ATTR(info->extack, 245 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 246 "FTM: EDCA RSTA not supported by device"); 247 return -EOPNOTSUPP; 248 } 249 250 if (out->ftm.rsta && 251 (out->ftm.non_trigger_based || out->ftm.trigger_based) && 252 !out->ftm.lmr_feedback) { 253 NL_SET_ERR_MSG_ATTR(info->extack, 254 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 255 "FTM: RSTA set without LMR feedback"); 256 return -EINVAL; 257 } 258 259 if (out->ftm.non_trigger_based) { 260 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 261 !tb[NL80211_PMSR_FTM_REQ_ATTR_NOMINAL_TIME]) { 262 NL_SET_ERR_MSG(info->extack, 263 "FTM: nominal time is required for PD NTB ranging"); 264 return -EINVAL; 265 } 266 out->ftm.nominal_time = 267 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NOMINAL_TIME]); 268 269 if (tb[NL80211_PMSR_FTM_REQ_ATTR_MIN_TIME_BETWEEN_MEASUREMENTS]) 270 out->ftm.min_time_between_measurements = 271 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_MIN_TIME_BETWEEN_MEASUREMENTS]); 272 273 if (tb[NL80211_PMSR_FTM_REQ_ATTR_MAX_TIME_BETWEEN_MEASUREMENTS]) 274 out->ftm.max_time_between_measurements = 275 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_MAX_TIME_BETWEEN_MEASUREMENTS]); 276 277 if (tb[NL80211_PMSR_FTM_REQ_ATTR_AW_DURATION]) 278 out->ftm.availability_window = 279 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_AW_DURATION]); 280 281 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_MEASUREMENTS]) 282 out->ftm.num_measurements = 283 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_MEASUREMENTS]); 284 } 285 286 if (tb[NL80211_PMSR_FTM_REQ_ATTR_INGRESS]) 287 out->ftm.ingress_distance = 288 nla_get_u64(tb[NL80211_PMSR_FTM_REQ_ATTR_INGRESS]); 289 290 if (tb[NL80211_PMSR_FTM_REQ_ATTR_EGRESS]) 291 out->ftm.egress_distance = 292 nla_get_u64(tb[NL80211_PMSR_FTM_REQ_ATTR_EGRESS]); 293 294 out->ftm.pd_suppress_range_results = 295 nla_get_flag(tb[NL80211_PMSR_FTM_REQ_ATTR_PD_SUPPRESS_RESULTS]); 296 297 if (out->ftm.request_type != NL80211_PMSR_FTM_REQ_TYPE_PD && 298 out->ftm.pd_suppress_range_results) { 299 NL_SET_ERR_MSG_ATTR(info->extack, 300 tb[NL80211_PMSR_FTM_REQ_ATTR_PD_SUPPRESS_RESULTS], 301 "FTM: suppress range result flag only valid for PD requests"); 302 return -EINVAL; 303 } 304 305 return 0; 306 } 307 308 static int pmsr_parse_peer(struct cfg80211_registered_device *rdev, 309 struct nlattr *peer, 310 struct cfg80211_pmsr_request_peer *out, 311 struct genl_info *info) 312 { 313 struct nlattr *tb[NL80211_PMSR_PEER_ATTR_MAX + 1]; 314 struct nlattr *req[NL80211_PMSR_REQ_ATTR_MAX + 1]; 315 bool have_measurement_type = false; 316 struct nlattr *treq; 317 int err, rem; 318 319 /* no validation needed - was already done via nested policy */ 320 nla_parse_nested_deprecated(tb, NL80211_PMSR_PEER_ATTR_MAX, peer, 321 NULL, NULL); 322 323 if (!tb[NL80211_PMSR_PEER_ATTR_ADDR] || 324 !tb[NL80211_PMSR_PEER_ATTR_CHAN] || 325 !tb[NL80211_PMSR_PEER_ATTR_REQ]) { 326 NL_SET_ERR_MSG_ATTR(info->extack, peer, 327 "insufficient peer data"); 328 return -EINVAL; 329 } 330 331 memcpy(out->addr, nla_data(tb[NL80211_PMSR_PEER_ATTR_ADDR]), ETH_ALEN); 332 333 if (tb[NL80211_PMSR_PEER_ATTR_REQ_TYPE]) 334 out->ftm.request_type = 335 nla_get_u32(tb[NL80211_PMSR_PEER_ATTR_REQ_TYPE]); 336 else 337 out->ftm.request_type = NL80211_PMSR_FTM_REQ_TYPE_INFRA; 338 339 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 340 !rdev->wiphy.pmsr_capa->ftm.type.pd_support) { 341 NL_SET_ERR_MSG_ATTR(info->extack, 342 tb[NL80211_PMSR_PEER_ATTR_REQ_TYPE], 343 "FTM: PD request type not supported by device"); 344 return -EINVAL; 345 } 346 /* reuse info->attrs */ 347 memset(info->attrs, 0, sizeof(*info->attrs) * (NL80211_ATTR_MAX + 1)); 348 err = nla_parse_nested_deprecated(info->attrs, NL80211_ATTR_MAX, 349 tb[NL80211_PMSR_PEER_ATTR_CHAN], 350 NULL, info->extack); 351 if (err) 352 return err; 353 354 err = nl80211_parse_chandef(rdev, info->extack, info->attrs, 355 &out->chandef, false); 356 if (err) 357 return err; 358 359 /* no validation needed - was already done via nested policy */ 360 nla_parse_nested_deprecated(req, NL80211_PMSR_REQ_ATTR_MAX, 361 tb[NL80211_PMSR_PEER_ATTR_REQ], NULL, 362 NULL); 363 364 if (!req[NL80211_PMSR_REQ_ATTR_DATA]) { 365 NL_SET_ERR_MSG_ATTR(info->extack, 366 tb[NL80211_PMSR_PEER_ATTR_REQ], 367 "missing request type/data"); 368 return -EINVAL; 369 } 370 371 if (req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF]) 372 out->report_ap_tsf = true; 373 374 if (out->report_ap_tsf && !rdev->wiphy.pmsr_capa->report_ap_tsf) { 375 NL_SET_ERR_MSG_ATTR(info->extack, 376 req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF], 377 "reporting AP TSF is not supported"); 378 return -EINVAL; 379 } 380 381 nla_for_each_nested(treq, req[NL80211_PMSR_REQ_ATTR_DATA], rem) { 382 if (have_measurement_type) { 383 NL_SET_ERR_MSG_ATTR(info->extack, treq, 384 "multiple measurement types in request data"); 385 return -EINVAL; 386 } 387 388 have_measurement_type = true; 389 390 switch (nla_type(treq)) { 391 case NL80211_PMSR_TYPE_FTM: 392 err = pmsr_parse_ftm(rdev, treq, out, info); 393 break; 394 default: 395 NL_SET_ERR_MSG_ATTR(info->extack, treq, 396 "unsupported measurement type"); 397 err = -EINVAL; 398 } 399 if (err) 400 return err; 401 } 402 403 if (!have_measurement_type) { 404 NL_SET_ERR_MSG_ATTR(info->extack, 405 req[NL80211_PMSR_REQ_ATTR_DATA], 406 "missing measurement type in request data"); 407 return -EINVAL; 408 } 409 410 return 0; 411 } 412 413 int nl80211_pmsr_start(struct sk_buff *skb, struct genl_info *info) 414 { 415 struct nlattr *reqattr = info->attrs[NL80211_ATTR_PEER_MEASUREMENTS]; 416 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 417 int count, rem, err, idx, peer_count; 418 struct wireless_dev *wdev = info->user_ptr[1]; 419 const struct cfg80211_pmsr_capabilities *capa; 420 struct cfg80211_pmsr_request *req; 421 struct nlattr *peers, *peer; 422 423 capa = rdev->wiphy.pmsr_capa; 424 425 if (!capa) 426 return -EOPNOTSUPP; 427 428 if (!reqattr) 429 return -EINVAL; 430 431 peers = nla_find(nla_data(reqattr), nla_len(reqattr), 432 NL80211_PMSR_ATTR_PEERS); 433 if (!peers) 434 return -EINVAL; 435 436 count = 0; 437 nla_for_each_nested(peer, peers, rem) { 438 count++; 439 440 if (count > capa->max_peers) { 441 NL_SET_ERR_MSG_ATTR(info->extack, peer, 442 "Too many peers used"); 443 return -EINVAL; 444 } 445 } 446 447 if (!count) { 448 NL_SET_ERR_MSG_ATTR(info->extack, peers, "No peers specified"); 449 return -EINVAL; 450 } 451 452 req = kzalloc_flex(*req, peers, count); 453 if (!req) 454 return -ENOMEM; 455 req->n_peers = count; 456 457 if (info->attrs[NL80211_ATTR_TIMEOUT]) 458 req->timeout = nla_get_u32(info->attrs[NL80211_ATTR_TIMEOUT]); 459 460 if (info->attrs[NL80211_ATTR_MAC]) { 461 if (!capa->randomize_mac_addr) { 462 NL_SET_ERR_MSG_ATTR(info->extack, 463 info->attrs[NL80211_ATTR_MAC], 464 "device cannot randomize MAC address"); 465 err = -EINVAL; 466 goto out_err; 467 } 468 469 err = nl80211_parse_random_mac(info->attrs, req->mac_addr, 470 req->mac_addr_mask); 471 if (err) 472 goto out_err; 473 } else { 474 memcpy(req->mac_addr, wdev_address(wdev), ETH_ALEN); 475 eth_broadcast_addr(req->mac_addr_mask); 476 } 477 478 idx = 0; 479 nla_for_each_nested(peer, peers, rem) { 480 /* NB: this reuses info->attrs, but we no longer need it */ 481 err = pmsr_parse_peer(rdev, peer, &req->peers[idx], info); 482 if (err) 483 goto out_err; 484 idx++; 485 } 486 487 /* Validate per-role peer limits if advertised */ 488 if (capa->ftm.ista.max_peers) { 489 peer_count = 0; 490 491 for (idx = 0; idx < req->n_peers; idx++) { 492 if (!req->peers[idx].ftm.rsta) { 493 peer_count++; 494 495 if (peer_count > capa->ftm.ista.max_peers) { 496 NL_SET_ERR_MSG(info->extack, 497 "Too many ISTA peers for device limit"); 498 err = -EINVAL; 499 goto out_err; 500 } 501 } 502 } 503 } 504 505 if (capa->ftm.rsta.max_peers) { 506 peer_count = 0; 507 508 for (idx = 0; idx < req->n_peers; idx++) { 509 if (req->peers[idx].ftm.rsta) { 510 peer_count++; 511 512 if (peer_count > capa->ftm.rsta.max_peers) { 513 NL_SET_ERR_MSG(info->extack, 514 "Too many RSTA peers for device limit"); 515 err = -EINVAL; 516 goto out_err; 517 } 518 } 519 } 520 } 521 req->cookie = cfg80211_assign_cookie(rdev); 522 req->nl_portid = info->snd_portid; 523 524 err = rdev_start_pmsr(rdev, wdev, req); 525 if (err) 526 goto out_err; 527 528 list_add_tail(&req->list, &wdev->pmsr_list); 529 530 nl_set_extack_cookie_u64(info->extack, req->cookie); 531 return 0; 532 out_err: 533 kfree(req); 534 return err; 535 } 536 537 void cfg80211_pmsr_complete(struct wireless_dev *wdev, 538 struct cfg80211_pmsr_request *req, 539 gfp_t gfp) 540 { 541 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 542 struct cfg80211_pmsr_request *tmp, *prev, *to_free = NULL; 543 struct sk_buff *msg; 544 void *hdr; 545 546 trace_cfg80211_pmsr_complete(wdev->wiphy, wdev, req->cookie); 547 548 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 549 if (!msg) 550 goto free_request; 551 552 hdr = nl80211hdr_put(msg, 0, 0, 0, 553 NL80211_CMD_PEER_MEASUREMENT_COMPLETE); 554 if (!hdr) 555 goto free_msg; 556 557 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 558 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 559 NL80211_ATTR_PAD)) 560 goto free_msg; 561 562 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie, 563 NL80211_ATTR_PAD)) 564 goto free_msg; 565 566 genlmsg_end(msg, hdr); 567 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid); 568 goto free_request; 569 free_msg: 570 nlmsg_free(msg); 571 free_request: 572 spin_lock_bh(&wdev->pmsr_lock); 573 /* 574 * cfg80211_pmsr_process_abort() may have already moved this request 575 * to the free list, and will free it later. In this case, don't free 576 * it here. 577 */ 578 list_for_each_entry_safe(tmp, prev, &wdev->pmsr_list, list) { 579 if (tmp == req) { 580 list_del(&req->list); 581 to_free = req; 582 break; 583 } 584 } 585 spin_unlock_bh(&wdev->pmsr_lock); 586 kfree(to_free); 587 } 588 EXPORT_SYMBOL_GPL(cfg80211_pmsr_complete); 589 590 static int nl80211_pmsr_send_ftm_res(struct sk_buff *msg, 591 struct cfg80211_pmsr_result *res) 592 { 593 if (res->status == NL80211_PMSR_STATUS_FAILURE) { 594 if (nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON, 595 res->ftm.failure_reason)) 596 goto error; 597 598 if (res->ftm.failure_reason == 599 NL80211_PMSR_FTM_FAILURE_PEER_BUSY && 600 res->ftm.busy_retry_time && 601 nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME, 602 res->ftm.busy_retry_time)) 603 goto error; 604 605 return 0; 606 } 607 608 #define PUT(tp, attr, val) \ 609 do { \ 610 if (nla_put_##tp(msg, \ 611 NL80211_PMSR_FTM_RESP_ATTR_##attr, \ 612 res->ftm.val)) \ 613 goto error; \ 614 } while (0) 615 616 #define PUTOPT(tp, attr, val) \ 617 do { \ 618 if (res->ftm.val##_valid) \ 619 PUT(tp, attr, val); \ 620 } while (0) 621 622 #define PUT_U64(attr, val) \ 623 do { \ 624 if (nla_put_u64_64bit(msg, \ 625 NL80211_PMSR_FTM_RESP_ATTR_##attr,\ 626 res->ftm.val, \ 627 NL80211_PMSR_FTM_RESP_ATTR_PAD)) \ 628 goto error; \ 629 } while (0) 630 631 #define PUTOPT_U64(attr, val) \ 632 do { \ 633 if (res->ftm.val##_valid) \ 634 PUT_U64(attr, val); \ 635 } while (0) 636 637 if (res->ftm.burst_index >= 0) 638 PUT(u32, BURST_INDEX, burst_index); 639 PUTOPT(u32, NUM_FTMR_ATTEMPTS, num_ftmr_attempts); 640 PUTOPT(u32, NUM_FTMR_SUCCESSES, num_ftmr_successes); 641 PUT(u8, NUM_BURSTS_EXP, num_bursts_exp); 642 PUT(u8, BURST_DURATION, burst_duration); 643 PUT(u8, FTMS_PER_BURST, ftms_per_burst); 644 PUT(u16, BURST_PERIOD, burst_period); 645 PUTOPT(s32, RSSI_AVG, rssi_avg); 646 PUTOPT(s32, RSSI_SPREAD, rssi_spread); 647 if (res->ftm.tx_rate_valid && 648 !nl80211_put_sta_rate(msg, &res->ftm.tx_rate, 649 NL80211_PMSR_FTM_RESP_ATTR_TX_RATE)) 650 goto error; 651 if (res->ftm.rx_rate_valid && 652 !nl80211_put_sta_rate(msg, &res->ftm.rx_rate, 653 NL80211_PMSR_FTM_RESP_ATTR_RX_RATE)) 654 goto error; 655 PUTOPT_U64(RTT_AVG, rtt_avg); 656 PUTOPT_U64(RTT_VARIANCE, rtt_variance); 657 PUTOPT_U64(RTT_SPREAD, rtt_spread); 658 PUTOPT_U64(DIST_AVG, dist_avg); 659 PUTOPT_U64(DIST_VARIANCE, dist_variance); 660 PUTOPT_U64(DIST_SPREAD, dist_spread); 661 PUTOPT(u32, TX_LTF_REPETITION_COUNT, tx_ltf_repetition_count); 662 PUTOPT(u32, RX_LTF_REPETITION_COUNT, rx_ltf_repetition_count); 663 PUTOPT(u32, MAX_TIME_BETWEEN_MEASUREMENTS, 664 max_time_between_measurements); 665 PUTOPT(u32, MIN_TIME_BETWEEN_MEASUREMENTS, 666 min_time_between_measurements); 667 PUTOPT(u8, NUM_TX_SPATIAL_STREAMS, num_tx_spatial_streams); 668 PUTOPT(u8, NUM_RX_SPATIAL_STREAMS, num_rx_spatial_streams); 669 PUTOPT(u32, NOMINAL_TIME, nominal_time); 670 PUTOPT(u8, AVAILABILITY_WINDOW, availability_window); 671 PUTOPT(u32, CHANNEL_WIDTH, chan_width); 672 PUTOPT(u32, PREAMBLE, preamble); 673 if (res->ftm.is_delayed_lmr && 674 nla_put_flag(msg, NL80211_PMSR_FTM_RESP_ATTR_IS_DELAYED_LMR)) 675 goto error; 676 if (res->ftm.lci && res->ftm.lci_len && 677 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_LCI, 678 res->ftm.lci_len, res->ftm.lci)) 679 goto error; 680 if (res->ftm.civicloc && res->ftm.civicloc_len && 681 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC, 682 res->ftm.civicloc_len, res->ftm.civicloc)) 683 goto error; 684 #undef PUT 685 #undef PUTOPT 686 #undef PUT_U64 687 #undef PUTOPT_U64 688 689 return 0; 690 error: 691 return -ENOSPC; 692 } 693 694 static int nl80211_pmsr_send_result(struct sk_buff *msg, 695 struct cfg80211_pmsr_result *res) 696 { 697 struct nlattr *pmsr, *peers, *peer, *resp, *data, *typedata; 698 699 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS); 700 if (!pmsr) 701 goto error; 702 703 peers = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_PEERS); 704 if (!peers) 705 goto error; 706 707 peer = nla_nest_start_noflag(msg, 1); 708 if (!peer) 709 goto error; 710 711 if (nla_put(msg, NL80211_PMSR_PEER_ATTR_ADDR, ETH_ALEN, res->addr)) 712 goto error; 713 714 resp = nla_nest_start_noflag(msg, NL80211_PMSR_PEER_ATTR_RESP); 715 if (!resp) 716 goto error; 717 718 if (nla_put_u32(msg, NL80211_PMSR_RESP_ATTR_STATUS, res->status) || 719 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_HOST_TIME, 720 res->host_time, NL80211_PMSR_RESP_ATTR_PAD)) 721 goto error; 722 723 if (res->ap_tsf_valid && 724 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_AP_TSF, 725 res->ap_tsf, NL80211_PMSR_RESP_ATTR_PAD)) 726 goto error; 727 728 if (res->final && nla_put_flag(msg, NL80211_PMSR_RESP_ATTR_FINAL)) 729 goto error; 730 731 data = nla_nest_start_noflag(msg, NL80211_PMSR_RESP_ATTR_DATA); 732 if (!data) 733 goto error; 734 735 typedata = nla_nest_start_noflag(msg, res->type); 736 if (!typedata) 737 goto error; 738 739 switch (res->type) { 740 case NL80211_PMSR_TYPE_FTM: 741 if (nl80211_pmsr_send_ftm_res(msg, res)) 742 goto error; 743 break; 744 default: 745 WARN_ON(1); 746 } 747 748 nla_nest_end(msg, typedata); 749 nla_nest_end(msg, data); 750 nla_nest_end(msg, resp); 751 nla_nest_end(msg, peer); 752 nla_nest_end(msg, peers); 753 nla_nest_end(msg, pmsr); 754 755 return 0; 756 error: 757 return -ENOSPC; 758 } 759 760 void cfg80211_pmsr_report(struct wireless_dev *wdev, 761 struct cfg80211_pmsr_request *req, 762 struct cfg80211_pmsr_result *result, 763 gfp_t gfp) 764 { 765 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 766 struct sk_buff *msg; 767 void *hdr; 768 int err; 769 770 trace_cfg80211_pmsr_report(wdev->wiphy, wdev, req->cookie, 771 result->addr); 772 773 /* 774 * Currently, only variable items are LCI and civic location, 775 * both of which are reasonably short so we don't need to 776 * worry about them here for the allocation. 777 */ 778 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 779 if (!msg) 780 return; 781 782 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PEER_MEASUREMENT_RESULT); 783 if (!hdr) 784 goto free; 785 786 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 787 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 788 NL80211_ATTR_PAD)) 789 goto free; 790 791 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie, 792 NL80211_ATTR_PAD)) 793 goto free; 794 795 err = nl80211_pmsr_send_result(msg, result); 796 if (err) { 797 pr_err_ratelimited("peer measurement result: message didn't fit!"); 798 goto free; 799 } 800 801 genlmsg_end(msg, hdr); 802 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid); 803 return; 804 free: 805 nlmsg_free(msg); 806 } 807 EXPORT_SYMBOL_GPL(cfg80211_pmsr_report); 808 809 static void cfg80211_pmsr_process_abort(struct wireless_dev *wdev) 810 { 811 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 812 struct cfg80211_pmsr_request *req, *tmp; 813 LIST_HEAD(free_list); 814 815 lockdep_assert_wiphy(wdev->wiphy); 816 817 spin_lock_bh(&wdev->pmsr_lock); 818 list_for_each_entry_safe(req, tmp, &wdev->pmsr_list, list) { 819 if (req->nl_portid) 820 continue; 821 list_move_tail(&req->list, &free_list); 822 } 823 spin_unlock_bh(&wdev->pmsr_lock); 824 825 list_for_each_entry_safe(req, tmp, &free_list, list) { 826 rdev_abort_pmsr(rdev, wdev, req); 827 828 kfree(req); 829 } 830 } 831 832 void cfg80211_pmsr_free_wk(struct wiphy *wiphy, struct wiphy_work *work) 833 { 834 struct wireless_dev *wdev = container_of(work, struct wireless_dev, 835 pmsr_free_wk); 836 837 cfg80211_pmsr_process_abort(wdev); 838 } 839 840 void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev) 841 { 842 struct cfg80211_pmsr_request *req; 843 bool found = false; 844 845 spin_lock_bh(&wdev->pmsr_lock); 846 list_for_each_entry(req, &wdev->pmsr_list, list) { 847 found = true; 848 req->nl_portid = 0; 849 } 850 spin_unlock_bh(&wdev->pmsr_lock); 851 852 wiphy_work_cancel(wdev->wiphy, &wdev->pmsr_free_wk); 853 if (found) 854 cfg80211_pmsr_process_abort(wdev); 855 856 WARN_ON(!list_empty(&wdev->pmsr_list)); 857 } 858 859 void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid) 860 { 861 struct cfg80211_pmsr_request *req; 862 863 spin_lock_bh(&wdev->pmsr_lock); 864 list_for_each_entry(req, &wdev->pmsr_list, list) { 865 if (req->nl_portid == portid) { 866 req->nl_portid = 0; 867 wiphy_work_queue(wdev->wiphy, &wdev->pmsr_free_wk); 868 } 869 } 870 spin_unlock_bh(&wdev->pmsr_lock); 871 } 872