pmsr.c 17 KB

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