core.c 45 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * This is the linux wireless configuration interface.
  4. *
  5. * Copyright 2006-2010 Johannes Berg <[email protected]>
  6. * Copyright 2013-2014 Intel Mobile Communications GmbH
  7. * Copyright 2015-2017 Intel Deutschland GmbH
  8. * Copyright (C) 2018-2022 Intel Corporation
  9. */
  10. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11. #include <linux/if.h>
  12. #include <linux/module.h>
  13. #include <linux/err.h>
  14. #include <linux/list.h>
  15. #include <linux/slab.h>
  16. #include <linux/nl80211.h>
  17. #include <linux/debugfs.h>
  18. #include <linux/notifier.h>
  19. #include <linux/device.h>
  20. #include <linux/etherdevice.h>
  21. #include <linux/rtnetlink.h>
  22. #include <linux/sched.h>
  23. #include <net/genetlink.h>
  24. #include <net/cfg80211.h>
  25. #include "nl80211.h"
  26. #include "core.h"
  27. #include "sysfs.h"
  28. #include "debugfs.h"
  29. #include "wext-compat.h"
  30. #include "rdev-ops.h"
  31. /* name for sysfs, %d is appended */
  32. #define PHY_NAME "phy"
  33. MODULE_AUTHOR("Johannes Berg");
  34. MODULE_LICENSE("GPL");
  35. MODULE_DESCRIPTION("wireless configuration support");
  36. MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
  37. /* RCU-protected (and RTNL for writers) */
  38. LIST_HEAD(cfg80211_rdev_list);
  39. int cfg80211_rdev_list_generation;
  40. /* for debugfs */
  41. static struct dentry *ieee80211_debugfs_dir;
  42. /* for the cleanup, scan and event works */
  43. struct workqueue_struct *cfg80211_wq;
  44. static bool cfg80211_disable_40mhz_24ghz;
  45. module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
  46. MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
  47. "Disable 40MHz support in the 2.4GHz band");
  48. struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
  49. {
  50. struct cfg80211_registered_device *result = NULL, *rdev;
  51. ASSERT_RTNL();
  52. list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
  53. if (rdev->wiphy_idx == wiphy_idx) {
  54. result = rdev;
  55. break;
  56. }
  57. }
  58. return result;
  59. }
  60. int get_wiphy_idx(struct wiphy *wiphy)
  61. {
  62. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  63. return rdev->wiphy_idx;
  64. }
  65. struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
  66. {
  67. struct cfg80211_registered_device *rdev;
  68. ASSERT_RTNL();
  69. rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
  70. if (!rdev)
  71. return NULL;
  72. return &rdev->wiphy;
  73. }
  74. static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
  75. const char *newname)
  76. {
  77. struct cfg80211_registered_device *rdev2;
  78. int wiphy_idx, taken = -1, digits;
  79. ASSERT_RTNL();
  80. if (strlen(newname) > NL80211_WIPHY_NAME_MAXLEN)
  81. return -EINVAL;
  82. /* prohibit calling the thing phy%d when %d is not its number */
  83. sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
  84. if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
  85. /* count number of places needed to print wiphy_idx */
  86. digits = 1;
  87. while (wiphy_idx /= 10)
  88. digits++;
  89. /*
  90. * deny the name if it is phy<idx> where <idx> is printed
  91. * without leading zeroes. taken == strlen(newname) here
  92. */
  93. if (taken == strlen(PHY_NAME) + digits)
  94. return -EINVAL;
  95. }
  96. /* Ensure another device does not already have this name. */
  97. list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
  98. if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
  99. return -EINVAL;
  100. return 0;
  101. }
  102. int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
  103. char *newname)
  104. {
  105. int result;
  106. ASSERT_RTNL();
  107. /* Ignore nop renames */
  108. if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
  109. return 0;
  110. result = cfg80211_dev_check_name(rdev, newname);
  111. if (result < 0)
  112. return result;
  113. result = device_rename(&rdev->wiphy.dev, newname);
  114. if (result)
  115. return result;
  116. if (!IS_ERR_OR_NULL(rdev->wiphy.debugfsdir))
  117. debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
  118. rdev->wiphy.debugfsdir,
  119. rdev->wiphy.debugfsdir->d_parent, newname);
  120. nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
  121. return 0;
  122. }
  123. int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
  124. struct net *net)
  125. {
  126. struct wireless_dev *wdev;
  127. int err = 0;
  128. if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
  129. return -EOPNOTSUPP;
  130. list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
  131. if (!wdev->netdev)
  132. continue;
  133. wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
  134. err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
  135. if (err)
  136. break;
  137. wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
  138. }
  139. if (err) {
  140. /* failed -- clean up to old netns */
  141. net = wiphy_net(&rdev->wiphy);
  142. list_for_each_entry_continue_reverse(wdev,
  143. &rdev->wiphy.wdev_list,
  144. list) {
  145. if (!wdev->netdev)
  146. continue;
  147. wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
  148. err = dev_change_net_namespace(wdev->netdev, net,
  149. "wlan%d");
  150. WARN_ON(err);
  151. wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
  152. }
  153. return err;
  154. }
  155. list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
  156. if (!wdev->netdev)
  157. continue;
  158. nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
  159. }
  160. nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
  161. wiphy_net_set(&rdev->wiphy, net);
  162. err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
  163. WARN_ON(err);
  164. nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
  165. list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
  166. if (!wdev->netdev)
  167. continue;
  168. nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
  169. }
  170. return 0;
  171. }
  172. static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
  173. {
  174. struct cfg80211_registered_device *rdev = data;
  175. rdev_rfkill_poll(rdev);
  176. }
  177. void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
  178. struct wireless_dev *wdev)
  179. {
  180. lockdep_assert_held(&rdev->wiphy.mtx);
  181. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
  182. return;
  183. if (!wdev_running(wdev))
  184. return;
  185. rdev_stop_p2p_device(rdev, wdev);
  186. wdev->is_running = false;
  187. rdev->opencount--;
  188. if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
  189. if (WARN_ON(!rdev->scan_req->notified &&
  190. (!rdev->int_scan_req ||
  191. !rdev->int_scan_req->notified)))
  192. rdev->scan_req->info.aborted = true;
  193. ___cfg80211_scan_done(rdev, false);
  194. }
  195. }
  196. void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
  197. struct wireless_dev *wdev)
  198. {
  199. lockdep_assert_held(&rdev->wiphy.mtx);
  200. if (WARN_ON(wdev->iftype != NL80211_IFTYPE_NAN))
  201. return;
  202. if (!wdev_running(wdev))
  203. return;
  204. rdev_stop_nan(rdev, wdev);
  205. wdev->is_running = false;
  206. rdev->opencount--;
  207. }
  208. void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
  209. {
  210. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  211. struct wireless_dev *wdev;
  212. ASSERT_RTNL();
  213. list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
  214. if (wdev->netdev) {
  215. dev_close(wdev->netdev);
  216. continue;
  217. }
  218. /* otherwise, check iftype */
  219. wiphy_lock(wiphy);
  220. switch (wdev->iftype) {
  221. case NL80211_IFTYPE_P2P_DEVICE:
  222. cfg80211_stop_p2p_device(rdev, wdev);
  223. break;
  224. case NL80211_IFTYPE_NAN:
  225. cfg80211_stop_nan(rdev, wdev);
  226. break;
  227. default:
  228. break;
  229. }
  230. wiphy_unlock(wiphy);
  231. }
  232. }
  233. EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
  234. static int cfg80211_rfkill_set_block(void *data, bool blocked)
  235. {
  236. struct cfg80211_registered_device *rdev = data;
  237. if (!blocked)
  238. return 0;
  239. rtnl_lock();
  240. cfg80211_shutdown_all_interfaces(&rdev->wiphy);
  241. rtnl_unlock();
  242. return 0;
  243. }
  244. static void cfg80211_rfkill_block_work(struct work_struct *work)
  245. {
  246. struct cfg80211_registered_device *rdev;
  247. rdev = container_of(work, struct cfg80211_registered_device,
  248. rfkill_block);
  249. cfg80211_rfkill_set_block(rdev, true);
  250. }
  251. static void cfg80211_event_work(struct work_struct *work)
  252. {
  253. struct cfg80211_registered_device *rdev;
  254. rdev = container_of(work, struct cfg80211_registered_device,
  255. event_work);
  256. wiphy_lock(&rdev->wiphy);
  257. cfg80211_process_rdev_events(rdev);
  258. wiphy_unlock(&rdev->wiphy);
  259. }
  260. void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
  261. {
  262. struct wireless_dev *wdev, *tmp;
  263. ASSERT_RTNL();
  264. list_for_each_entry_safe(wdev, tmp, &rdev->wiphy.wdev_list, list) {
  265. if (wdev->nl_owner_dead) {
  266. if (wdev->netdev)
  267. dev_close(wdev->netdev);
  268. wiphy_lock(&rdev->wiphy);
  269. cfg80211_leave(rdev, wdev);
  270. cfg80211_remove_virtual_intf(rdev, wdev);
  271. wiphy_unlock(&rdev->wiphy);
  272. }
  273. }
  274. }
  275. static void cfg80211_destroy_iface_wk(struct work_struct *work)
  276. {
  277. struct cfg80211_registered_device *rdev;
  278. rdev = container_of(work, struct cfg80211_registered_device,
  279. destroy_work);
  280. rtnl_lock();
  281. cfg80211_destroy_ifaces(rdev);
  282. rtnl_unlock();
  283. }
  284. static void cfg80211_sched_scan_stop_wk(struct work_struct *work)
  285. {
  286. struct cfg80211_registered_device *rdev;
  287. struct cfg80211_sched_scan_request *req, *tmp;
  288. rdev = container_of(work, struct cfg80211_registered_device,
  289. sched_scan_stop_wk);
  290. wiphy_lock(&rdev->wiphy);
  291. list_for_each_entry_safe(req, tmp, &rdev->sched_scan_req_list, list) {
  292. if (req->nl_owner_dead)
  293. cfg80211_stop_sched_scan_req(rdev, req, false);
  294. }
  295. wiphy_unlock(&rdev->wiphy);
  296. }
  297. static void cfg80211_propagate_radar_detect_wk(struct work_struct *work)
  298. {
  299. struct cfg80211_registered_device *rdev;
  300. rdev = container_of(work, struct cfg80211_registered_device,
  301. propagate_radar_detect_wk);
  302. rtnl_lock();
  303. regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->radar_chandef,
  304. NL80211_DFS_UNAVAILABLE,
  305. NL80211_RADAR_DETECTED);
  306. rtnl_unlock();
  307. }
  308. static void cfg80211_propagate_cac_done_wk(struct work_struct *work)
  309. {
  310. struct cfg80211_registered_device *rdev;
  311. rdev = container_of(work, struct cfg80211_registered_device,
  312. propagate_cac_done_wk);
  313. rtnl_lock();
  314. regulatory_propagate_dfs_state(&rdev->wiphy, &rdev->cac_done_chandef,
  315. NL80211_DFS_AVAILABLE,
  316. NL80211_RADAR_CAC_FINISHED);
  317. rtnl_unlock();
  318. }
  319. static void cfg80211_wiphy_work(struct work_struct *work)
  320. {
  321. struct cfg80211_registered_device *rdev;
  322. struct wiphy_work *wk;
  323. rdev = container_of(work, struct cfg80211_registered_device, wiphy_work);
  324. wiphy_lock(&rdev->wiphy);
  325. if (rdev->suspended)
  326. goto out;
  327. spin_lock_irq(&rdev->wiphy_work_lock);
  328. wk = list_first_entry_or_null(&rdev->wiphy_work_list,
  329. struct wiphy_work, entry);
  330. if (wk) {
  331. list_del_init(&wk->entry);
  332. if (!list_empty(&rdev->wiphy_work_list))
  333. schedule_work(work);
  334. spin_unlock_irq(&rdev->wiphy_work_lock);
  335. wk->func(&rdev->wiphy, wk);
  336. } else {
  337. spin_unlock_irq(&rdev->wiphy_work_lock);
  338. }
  339. out:
  340. wiphy_unlock(&rdev->wiphy);
  341. }
  342. /* exported functions */
  343. struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
  344. const char *requested_name)
  345. {
  346. static atomic_t wiphy_counter = ATOMIC_INIT(0);
  347. struct cfg80211_registered_device *rdev;
  348. int alloc_size;
  349. WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
  350. WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
  351. WARN_ON(ops->connect && !ops->disconnect);
  352. WARN_ON(ops->join_ibss && !ops->leave_ibss);
  353. WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
  354. WARN_ON(ops->add_station && !ops->del_station);
  355. WARN_ON(ops->add_mpath && !ops->del_mpath);
  356. WARN_ON(ops->join_mesh && !ops->leave_mesh);
  357. WARN_ON(ops->start_p2p_device && !ops->stop_p2p_device);
  358. WARN_ON(ops->start_ap && !ops->stop_ap);
  359. WARN_ON(ops->join_ocb && !ops->leave_ocb);
  360. WARN_ON(ops->suspend && !ops->resume);
  361. WARN_ON(ops->sched_scan_start && !ops->sched_scan_stop);
  362. WARN_ON(ops->remain_on_channel && !ops->cancel_remain_on_channel);
  363. WARN_ON(ops->tdls_channel_switch && !ops->tdls_cancel_channel_switch);
  364. WARN_ON(ops->add_tx_ts && !ops->del_tx_ts);
  365. alloc_size = sizeof(*rdev) + sizeof_priv;
  366. rdev = kzalloc(alloc_size, GFP_KERNEL);
  367. if (!rdev)
  368. return NULL;
  369. rdev->ops = ops;
  370. rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
  371. if (unlikely(rdev->wiphy_idx < 0)) {
  372. /* ugh, wrapped! */
  373. atomic_dec(&wiphy_counter);
  374. kfree(rdev);
  375. return NULL;
  376. }
  377. /* atomic_inc_return makes it start at 1, make it start at 0 */
  378. rdev->wiphy_idx--;
  379. /* give it a proper name */
  380. if (requested_name && requested_name[0]) {
  381. int rv;
  382. rtnl_lock();
  383. rv = cfg80211_dev_check_name(rdev, requested_name);
  384. if (rv < 0) {
  385. rtnl_unlock();
  386. goto use_default_name;
  387. }
  388. rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
  389. rtnl_unlock();
  390. if (rv)
  391. goto use_default_name;
  392. } else {
  393. int rv;
  394. use_default_name:
  395. /* NOTE: This is *probably* safe w/out holding rtnl because of
  396. * the restrictions on phy names. Probably this call could
  397. * fail if some other part of the kernel (re)named a device
  398. * phyX. But, might should add some locking and check return
  399. * value, and use a different name if this one exists?
  400. */
  401. rv = dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
  402. if (rv < 0) {
  403. kfree(rdev);
  404. return NULL;
  405. }
  406. }
  407. mutex_init(&rdev->wiphy.mtx);
  408. INIT_LIST_HEAD(&rdev->wiphy.wdev_list);
  409. INIT_LIST_HEAD(&rdev->beacon_registrations);
  410. spin_lock_init(&rdev->beacon_registrations_lock);
  411. spin_lock_init(&rdev->bss_lock);
  412. INIT_LIST_HEAD(&rdev->bss_list);
  413. INIT_LIST_HEAD(&rdev->sched_scan_req_list);
  414. INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
  415. INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
  416. cfg80211_dfs_channels_update_work);
  417. #ifdef CONFIG_CFG80211_WEXT
  418. rdev->wiphy.wext = &cfg80211_wext_handler;
  419. #endif
  420. device_initialize(&rdev->wiphy.dev);
  421. rdev->wiphy.dev.class = &ieee80211_class;
  422. rdev->wiphy.dev.platform_data = rdev;
  423. device_enable_async_suspend(&rdev->wiphy.dev);
  424. INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
  425. INIT_WORK(&rdev->sched_scan_stop_wk, cfg80211_sched_scan_stop_wk);
  426. INIT_WORK(&rdev->sched_scan_res_wk, cfg80211_sched_scan_results_wk);
  427. INIT_WORK(&rdev->propagate_radar_detect_wk,
  428. cfg80211_propagate_radar_detect_wk);
  429. INIT_WORK(&rdev->propagate_cac_done_wk, cfg80211_propagate_cac_done_wk);
  430. INIT_WORK(&rdev->mgmt_registrations_update_wk,
  431. cfg80211_mgmt_registrations_update_wk);
  432. spin_lock_init(&rdev->mgmt_registrations_lock);
  433. #ifdef CONFIG_CFG80211_DEFAULT_PS
  434. rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
  435. #endif
  436. wiphy_net_set(&rdev->wiphy, &init_net);
  437. rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
  438. rdev->wiphy.rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
  439. &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
  440. &rdev->rfkill_ops, rdev);
  441. if (!rdev->wiphy.rfkill) {
  442. wiphy_free(&rdev->wiphy);
  443. return NULL;
  444. }
  445. INIT_WORK(&rdev->wiphy_work, cfg80211_wiphy_work);
  446. INIT_LIST_HEAD(&rdev->wiphy_work_list);
  447. spin_lock_init(&rdev->wiphy_work_lock);
  448. INIT_WORK(&rdev->rfkill_block, cfg80211_rfkill_block_work);
  449. INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
  450. INIT_WORK(&rdev->event_work, cfg80211_event_work);
  451. INIT_WORK(&rdev->background_cac_abort_wk,
  452. cfg80211_background_cac_abort_wk);
  453. INIT_DELAYED_WORK(&rdev->background_cac_done_wk,
  454. cfg80211_background_cac_done_wk);
  455. init_waitqueue_head(&rdev->dev_wait);
  456. /*
  457. * Initialize wiphy parameters to IEEE 802.11 MIB default values.
  458. * Fragmentation and RTS threshold are disabled by default with the
  459. * special -1 value.
  460. */
  461. rdev->wiphy.retry_short = 7;
  462. rdev->wiphy.retry_long = 4;
  463. rdev->wiphy.frag_threshold = (u32) -1;
  464. rdev->wiphy.rts_threshold = (u32) -1;
  465. rdev->wiphy.coverage_class = 0;
  466. rdev->wiphy.max_num_csa_counters = 1;
  467. rdev->wiphy.max_sched_scan_plans = 1;
  468. rdev->wiphy.max_sched_scan_plan_interval = U32_MAX;
  469. return &rdev->wiphy;
  470. }
  471. EXPORT_SYMBOL(wiphy_new_nm);
  472. static int wiphy_verify_combinations(struct wiphy *wiphy)
  473. {
  474. const struct ieee80211_iface_combination *c;
  475. int i, j;
  476. for (i = 0; i < wiphy->n_iface_combinations; i++) {
  477. u32 cnt = 0;
  478. u16 all_iftypes = 0;
  479. c = &wiphy->iface_combinations[i];
  480. /*
  481. * Combinations with just one interface aren't real,
  482. * however we make an exception for DFS.
  483. */
  484. if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
  485. return -EINVAL;
  486. /* Need at least one channel */
  487. if (WARN_ON(!c->num_different_channels))
  488. return -EINVAL;
  489. /* DFS only works on one channel. */
  490. if (WARN_ON(c->radar_detect_widths &&
  491. (c->num_different_channels > 1)))
  492. return -EINVAL;
  493. if (WARN_ON(!c->n_limits))
  494. return -EINVAL;
  495. for (j = 0; j < c->n_limits; j++) {
  496. u16 types = c->limits[j].types;
  497. /* interface types shouldn't overlap */
  498. if (WARN_ON(types & all_iftypes))
  499. return -EINVAL;
  500. all_iftypes |= types;
  501. if (WARN_ON(!c->limits[j].max))
  502. return -EINVAL;
  503. /* Shouldn't list software iftypes in combinations! */
  504. if (WARN_ON(wiphy->software_iftypes & types))
  505. return -EINVAL;
  506. /* Only a single P2P_DEVICE can be allowed */
  507. if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
  508. c->limits[j].max > 1))
  509. return -EINVAL;
  510. /* Only a single NAN can be allowed */
  511. if (WARN_ON(types & BIT(NL80211_IFTYPE_NAN) &&
  512. c->limits[j].max > 1))
  513. return -EINVAL;
  514. /*
  515. * This isn't well-defined right now. If you have an
  516. * IBSS interface, then its beacon interval may change
  517. * by joining other networks, and nothing prevents it
  518. * from doing that.
  519. * So technically we probably shouldn't even allow AP
  520. * and IBSS in the same interface, but it seems that
  521. * some drivers support that, possibly only with fixed
  522. * beacon intervals for IBSS.
  523. */
  524. if (WARN_ON(types & BIT(NL80211_IFTYPE_ADHOC) &&
  525. c->beacon_int_min_gcd)) {
  526. return -EINVAL;
  527. }
  528. cnt += c->limits[j].max;
  529. /*
  530. * Don't advertise an unsupported type
  531. * in a combination.
  532. */
  533. if (WARN_ON((wiphy->interface_modes & types) != types))
  534. return -EINVAL;
  535. }
  536. if (WARN_ON(all_iftypes & BIT(NL80211_IFTYPE_WDS)))
  537. return -EINVAL;
  538. /* You can't even choose that many! */
  539. if (WARN_ON(cnt < c->max_interfaces))
  540. return -EINVAL;
  541. }
  542. return 0;
  543. }
  544. int wiphy_register(struct wiphy *wiphy)
  545. {
  546. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  547. int res;
  548. enum nl80211_band band;
  549. struct ieee80211_supported_band *sband;
  550. bool have_band = false;
  551. int i;
  552. u16 ifmodes = wiphy->interface_modes;
  553. #ifdef CONFIG_PM
  554. if (WARN_ON(wiphy->wowlan &&
  555. (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
  556. !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
  557. return -EINVAL;
  558. if (WARN_ON(wiphy->wowlan &&
  559. !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
  560. !wiphy->wowlan->tcp))
  561. return -EINVAL;
  562. #endif
  563. if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
  564. (!rdev->ops->tdls_channel_switch ||
  565. !rdev->ops->tdls_cancel_channel_switch)))
  566. return -EINVAL;
  567. if (WARN_ON((wiphy->interface_modes & BIT(NL80211_IFTYPE_NAN)) &&
  568. (!rdev->ops->start_nan || !rdev->ops->stop_nan ||
  569. !rdev->ops->add_nan_func || !rdev->ops->del_nan_func ||
  570. !(wiphy->nan_supported_bands & BIT(NL80211_BAND_2GHZ)))))
  571. return -EINVAL;
  572. if (WARN_ON(wiphy->interface_modes & BIT(NL80211_IFTYPE_WDS)))
  573. return -EINVAL;
  574. if (WARN_ON(wiphy->pmsr_capa && !wiphy->pmsr_capa->ftm.supported))
  575. return -EINVAL;
  576. if (wiphy->pmsr_capa && wiphy->pmsr_capa->ftm.supported) {
  577. if (WARN_ON(!wiphy->pmsr_capa->ftm.asap &&
  578. !wiphy->pmsr_capa->ftm.non_asap))
  579. return -EINVAL;
  580. if (WARN_ON(!wiphy->pmsr_capa->ftm.preambles ||
  581. !wiphy->pmsr_capa->ftm.bandwidths))
  582. return -EINVAL;
  583. if (WARN_ON(wiphy->pmsr_capa->ftm.preambles &
  584. ~(BIT(NL80211_PREAMBLE_LEGACY) |
  585. BIT(NL80211_PREAMBLE_HT) |
  586. BIT(NL80211_PREAMBLE_VHT) |
  587. BIT(NL80211_PREAMBLE_HE) |
  588. BIT(NL80211_PREAMBLE_DMG))))
  589. return -EINVAL;
  590. if (WARN_ON((wiphy->pmsr_capa->ftm.trigger_based ||
  591. wiphy->pmsr_capa->ftm.non_trigger_based) &&
  592. !(wiphy->pmsr_capa->ftm.preambles &
  593. BIT(NL80211_PREAMBLE_HE))))
  594. return -EINVAL;
  595. if (WARN_ON(wiphy->pmsr_capa->ftm.bandwidths &
  596. ~(BIT(NL80211_CHAN_WIDTH_20_NOHT) |
  597. BIT(NL80211_CHAN_WIDTH_20) |
  598. BIT(NL80211_CHAN_WIDTH_40) |
  599. BIT(NL80211_CHAN_WIDTH_80) |
  600. BIT(NL80211_CHAN_WIDTH_80P80) |
  601. BIT(NL80211_CHAN_WIDTH_160) |
  602. BIT(NL80211_CHAN_WIDTH_5) |
  603. BIT(NL80211_CHAN_WIDTH_10))))
  604. return -EINVAL;
  605. }
  606. if (WARN_ON((wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) &&
  607. (wiphy->regulatory_flags &
  608. (REGULATORY_CUSTOM_REG |
  609. REGULATORY_STRICT_REG |
  610. REGULATORY_COUNTRY_IE_FOLLOW_POWER |
  611. REGULATORY_COUNTRY_IE_IGNORE))))
  612. return -EINVAL;
  613. if (WARN_ON(wiphy->coalesce &&
  614. (!wiphy->coalesce->n_rules ||
  615. !wiphy->coalesce->n_patterns) &&
  616. (!wiphy->coalesce->pattern_min_len ||
  617. wiphy->coalesce->pattern_min_len >
  618. wiphy->coalesce->pattern_max_len)))
  619. return -EINVAL;
  620. if (WARN_ON(wiphy->ap_sme_capa &&
  621. !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
  622. return -EINVAL;
  623. if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
  624. return -EINVAL;
  625. if (WARN_ON(wiphy->addresses &&
  626. !is_zero_ether_addr(wiphy->perm_addr) &&
  627. memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
  628. ETH_ALEN)))
  629. return -EINVAL;
  630. if (WARN_ON(wiphy->max_acl_mac_addrs &&
  631. (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
  632. !rdev->ops->set_mac_acl)))
  633. return -EINVAL;
  634. /* assure only valid behaviours are flagged by driver
  635. * hence subtract 2 as bit 0 is invalid.
  636. */
  637. if (WARN_ON(wiphy->bss_select_support &&
  638. (wiphy->bss_select_support & ~(BIT(__NL80211_BSS_SELECT_ATTR_AFTER_LAST) - 2))))
  639. return -EINVAL;
  640. if (WARN_ON(wiphy_ext_feature_isset(&rdev->wiphy,
  641. NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X) &&
  642. (!rdev->ops->set_pmk || !rdev->ops->del_pmk)))
  643. return -EINVAL;
  644. if (WARN_ON(!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
  645. rdev->ops->update_connect_params))
  646. return -EINVAL;
  647. if (wiphy->addresses)
  648. memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
  649. /* sanity check ifmodes */
  650. WARN_ON(!ifmodes);
  651. ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
  652. if (WARN_ON(ifmodes != wiphy->interface_modes))
  653. wiphy->interface_modes = ifmodes;
  654. res = wiphy_verify_combinations(wiphy);
  655. if (res)
  656. return res;
  657. /* sanity check supported bands/channels */
  658. for (band = 0; band < NUM_NL80211_BANDS; band++) {
  659. u16 types = 0;
  660. bool have_he = false;
  661. sband = wiphy->bands[band];
  662. if (!sband)
  663. continue;
  664. sband->band = band;
  665. if (WARN_ON(!sband->n_channels))
  666. return -EINVAL;
  667. /*
  668. * on 60GHz or sub-1Ghz band, there are no legacy rates, so
  669. * n_bitrates is 0
  670. */
  671. if (WARN_ON((band != NL80211_BAND_60GHZ &&
  672. band != NL80211_BAND_S1GHZ) &&
  673. !sband->n_bitrates))
  674. return -EINVAL;
  675. if (WARN_ON(band == NL80211_BAND_6GHZ &&
  676. (sband->ht_cap.ht_supported ||
  677. sband->vht_cap.vht_supported)))
  678. return -EINVAL;
  679. /*
  680. * Since cfg80211_disable_40mhz_24ghz is global, we can
  681. * modify the sband's ht data even if the driver uses a
  682. * global structure for that.
  683. */
  684. if (cfg80211_disable_40mhz_24ghz &&
  685. band == NL80211_BAND_2GHZ &&
  686. sband->ht_cap.ht_supported) {
  687. sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  688. sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
  689. }
  690. /*
  691. * Since we use a u32 for rate bitmaps in
  692. * ieee80211_get_response_rate, we cannot
  693. * have more than 32 legacy rates.
  694. */
  695. if (WARN_ON(sband->n_bitrates > 32))
  696. return -EINVAL;
  697. for (i = 0; i < sband->n_channels; i++) {
  698. sband->channels[i].orig_flags =
  699. sband->channels[i].flags;
  700. sband->channels[i].orig_mag = INT_MAX;
  701. sband->channels[i].orig_mpwr =
  702. sband->channels[i].max_power;
  703. sband->channels[i].band = band;
  704. if (WARN_ON(sband->channels[i].freq_offset >= 1000))
  705. return -EINVAL;
  706. }
  707. for (i = 0; i < sband->n_iftype_data; i++) {
  708. const struct ieee80211_sband_iftype_data *iftd;
  709. bool has_ap, has_non_ap;
  710. u32 ap_bits = BIT(NL80211_IFTYPE_AP) |
  711. BIT(NL80211_IFTYPE_P2P_GO);
  712. iftd = &sband->iftype_data[i];
  713. if (WARN_ON(!iftd->types_mask))
  714. return -EINVAL;
  715. if (WARN_ON(types & iftd->types_mask))
  716. return -EINVAL;
  717. /* at least one piece of information must be present */
  718. if (WARN_ON(!iftd->he_cap.has_he))
  719. return -EINVAL;
  720. types |= iftd->types_mask;
  721. if (i == 0)
  722. have_he = iftd->he_cap.has_he;
  723. else
  724. have_he = have_he &&
  725. iftd->he_cap.has_he;
  726. has_ap = iftd->types_mask & ap_bits;
  727. has_non_ap = iftd->types_mask & ~ap_bits;
  728. /*
  729. * For EHT 20 MHz STA, the capabilities format differs
  730. * but to simplify, don't check 20 MHz but rather check
  731. * only if AP and non-AP were mentioned at the same time,
  732. * reject if so.
  733. */
  734. if (WARN_ON(iftd->eht_cap.has_eht &&
  735. has_ap && has_non_ap))
  736. return -EINVAL;
  737. }
  738. if (WARN_ON(!have_he && band == NL80211_BAND_6GHZ))
  739. return -EINVAL;
  740. have_band = true;
  741. }
  742. if (!have_band) {
  743. WARN_ON(1);
  744. return -EINVAL;
  745. }
  746. for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
  747. /*
  748. * Validate we have a policy (can be explicitly set to
  749. * VENDOR_CMD_RAW_DATA which is non-NULL) and also that
  750. * we have at least one of doit/dumpit.
  751. */
  752. if (WARN_ON(!rdev->wiphy.vendor_commands[i].policy))
  753. return -EINVAL;
  754. if (WARN_ON(!rdev->wiphy.vendor_commands[i].doit &&
  755. !rdev->wiphy.vendor_commands[i].dumpit))
  756. return -EINVAL;
  757. }
  758. #ifdef CONFIG_PM
  759. if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
  760. (!rdev->wiphy.wowlan->pattern_min_len ||
  761. rdev->wiphy.wowlan->pattern_min_len >
  762. rdev->wiphy.wowlan->pattern_max_len)))
  763. return -EINVAL;
  764. #endif
  765. if (!wiphy->max_num_akm_suites)
  766. wiphy->max_num_akm_suites = NL80211_MAX_NR_AKM_SUITES;
  767. else if (wiphy->max_num_akm_suites < NL80211_MAX_NR_AKM_SUITES ||
  768. wiphy->max_num_akm_suites > CFG80211_MAX_NUM_AKM_SUITES)
  769. return -EINVAL;
  770. /* check and set up bitrates */
  771. ieee80211_set_bitrate_flags(wiphy);
  772. rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
  773. rtnl_lock();
  774. res = device_add(&rdev->wiphy.dev);
  775. if (res) {
  776. rtnl_unlock();
  777. return res;
  778. }
  779. list_add_rcu(&rdev->list, &cfg80211_rdev_list);
  780. cfg80211_rdev_list_generation++;
  781. /* add to debugfs */
  782. rdev->wiphy.debugfsdir = debugfs_create_dir(wiphy_name(&rdev->wiphy),
  783. ieee80211_debugfs_dir);
  784. cfg80211_debugfs_rdev_add(rdev);
  785. nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
  786. /* set up regulatory info */
  787. wiphy_regulatory_register(wiphy);
  788. if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
  789. struct regulatory_request request;
  790. request.wiphy_idx = get_wiphy_idx(wiphy);
  791. request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
  792. request.alpha2[0] = '9';
  793. request.alpha2[1] = '9';
  794. nl80211_send_reg_change_event(&request);
  795. }
  796. /* Check that nobody globally advertises any capabilities they do not
  797. * advertise on all possible interface types.
  798. */
  799. if (wiphy->extended_capabilities_len &&
  800. wiphy->num_iftype_ext_capab &&
  801. wiphy->iftype_ext_capab) {
  802. u8 supported_on_all, j;
  803. const struct wiphy_iftype_ext_capab *capab;
  804. capab = wiphy->iftype_ext_capab;
  805. for (j = 0; j < wiphy->extended_capabilities_len; j++) {
  806. if (capab[0].extended_capabilities_len > j)
  807. supported_on_all =
  808. capab[0].extended_capabilities[j];
  809. else
  810. supported_on_all = 0x00;
  811. for (i = 1; i < wiphy->num_iftype_ext_capab; i++) {
  812. if (j >= capab[i].extended_capabilities_len) {
  813. supported_on_all = 0x00;
  814. break;
  815. }
  816. supported_on_all &=
  817. capab[i].extended_capabilities[j];
  818. }
  819. if (WARN_ON(wiphy->extended_capabilities[j] &
  820. ~supported_on_all))
  821. break;
  822. }
  823. }
  824. rdev->wiphy.registered = true;
  825. rtnl_unlock();
  826. res = rfkill_register(rdev->wiphy.rfkill);
  827. if (res) {
  828. rfkill_destroy(rdev->wiphy.rfkill);
  829. rdev->wiphy.rfkill = NULL;
  830. wiphy_unregister(&rdev->wiphy);
  831. return res;
  832. }
  833. return 0;
  834. }
  835. EXPORT_SYMBOL(wiphy_register);
  836. void wiphy_rfkill_start_polling(struct wiphy *wiphy)
  837. {
  838. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  839. if (!rdev->ops->rfkill_poll)
  840. return;
  841. rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
  842. rfkill_resume_polling(wiphy->rfkill);
  843. }
  844. EXPORT_SYMBOL(wiphy_rfkill_start_polling);
  845. void cfg80211_process_wiphy_works(struct cfg80211_registered_device *rdev,
  846. struct wiphy_work *end)
  847. {
  848. unsigned int runaway_limit = 100;
  849. unsigned long flags;
  850. lockdep_assert_held(&rdev->wiphy.mtx);
  851. spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
  852. while (!list_empty(&rdev->wiphy_work_list)) {
  853. struct wiphy_work *wk;
  854. wk = list_first_entry(&rdev->wiphy_work_list,
  855. struct wiphy_work, entry);
  856. list_del_init(&wk->entry);
  857. spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
  858. wk->func(&rdev->wiphy, wk);
  859. spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
  860. if (wk == end)
  861. break;
  862. if (WARN_ON(--runaway_limit == 0))
  863. INIT_LIST_HEAD(&rdev->wiphy_work_list);
  864. }
  865. spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
  866. }
  867. void wiphy_unregister(struct wiphy *wiphy)
  868. {
  869. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  870. wait_event(rdev->dev_wait, ({
  871. int __count;
  872. wiphy_lock(&rdev->wiphy);
  873. __count = rdev->opencount;
  874. wiphy_unlock(&rdev->wiphy);
  875. __count == 0; }));
  876. if (rdev->wiphy.rfkill)
  877. rfkill_unregister(rdev->wiphy.rfkill);
  878. rtnl_lock();
  879. wiphy_lock(&rdev->wiphy);
  880. nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
  881. rdev->wiphy.registered = false;
  882. WARN_ON(!list_empty(&rdev->wiphy.wdev_list));
  883. /*
  884. * First remove the hardware from everywhere, this makes
  885. * it impossible to find from userspace.
  886. */
  887. debugfs_remove_recursive(rdev->wiphy.debugfsdir);
  888. list_del_rcu(&rdev->list);
  889. synchronize_rcu();
  890. /*
  891. * If this device got a regulatory hint tell core its
  892. * free to listen now to a new shiny device regulatory hint
  893. */
  894. wiphy_regulatory_deregister(wiphy);
  895. cfg80211_rdev_list_generation++;
  896. device_del(&rdev->wiphy.dev);
  897. #ifdef CONFIG_PM
  898. if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
  899. rdev_set_wakeup(rdev, false);
  900. #endif
  901. /* surely nothing is reachable now, clean up work */
  902. cfg80211_process_wiphy_works(rdev, NULL);
  903. wiphy_unlock(&rdev->wiphy);
  904. rtnl_unlock();
  905. /* this has nothing to do now but make sure it's gone */
  906. cancel_work_sync(&rdev->wiphy_work);
  907. flush_work(&rdev->scan_done_wk);
  908. cancel_work_sync(&rdev->conn_work);
  909. flush_work(&rdev->event_work);
  910. cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
  911. cancel_delayed_work_sync(&rdev->background_cac_done_wk);
  912. flush_work(&rdev->destroy_work);
  913. flush_work(&rdev->sched_scan_stop_wk);
  914. flush_work(&rdev->propagate_radar_detect_wk);
  915. flush_work(&rdev->propagate_cac_done_wk);
  916. flush_work(&rdev->mgmt_registrations_update_wk);
  917. flush_work(&rdev->background_cac_abort_wk);
  918. cfg80211_rdev_free_wowlan(rdev);
  919. cfg80211_rdev_free_coalesce(rdev);
  920. }
  921. EXPORT_SYMBOL(wiphy_unregister);
  922. void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
  923. {
  924. struct cfg80211_internal_bss *scan, *tmp;
  925. struct cfg80211_beacon_registration *reg, *treg;
  926. rfkill_destroy(rdev->wiphy.rfkill);
  927. list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
  928. list_del(&reg->list);
  929. kfree(reg);
  930. }
  931. list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
  932. cfg80211_put_bss(&rdev->wiphy, &scan->pub);
  933. mutex_destroy(&rdev->wiphy.mtx);
  934. /*
  935. * The 'regd' can only be non-NULL if we never finished
  936. * initializing the wiphy and thus never went through the
  937. * unregister path - e.g. in failure scenarios. Thus, it
  938. * cannot have been visible to anyone if non-NULL, so we
  939. * can just free it here.
  940. */
  941. kfree(rcu_dereference_raw(rdev->wiphy.regd));
  942. kfree(rdev);
  943. }
  944. void wiphy_free(struct wiphy *wiphy)
  945. {
  946. put_device(&wiphy->dev);
  947. }
  948. EXPORT_SYMBOL(wiphy_free);
  949. void wiphy_rfkill_set_hw_state_reason(struct wiphy *wiphy, bool blocked,
  950. enum rfkill_hard_block_reasons reason)
  951. {
  952. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  953. if (rfkill_set_hw_state_reason(wiphy->rfkill, blocked, reason))
  954. schedule_work(&rdev->rfkill_block);
  955. }
  956. EXPORT_SYMBOL(wiphy_rfkill_set_hw_state_reason);
  957. void cfg80211_cqm_config_free(struct wireless_dev *wdev)
  958. {
  959. kfree(wdev->cqm_config);
  960. wdev->cqm_config = NULL;
  961. }
  962. static void _cfg80211_unregister_wdev(struct wireless_dev *wdev,
  963. bool unregister_netdev)
  964. {
  965. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  966. unsigned int link_id;
  967. ASSERT_RTNL();
  968. lockdep_assert_held(&rdev->wiphy.mtx);
  969. flush_work(&wdev->pmsr_free_wk);
  970. nl80211_notify_iface(rdev, wdev, NL80211_CMD_DEL_INTERFACE);
  971. wdev->registered = false;
  972. if (wdev->netdev) {
  973. sysfs_remove_link(&wdev->netdev->dev.kobj, "phy80211");
  974. if (unregister_netdev)
  975. unregister_netdevice(wdev->netdev);
  976. }
  977. list_del_rcu(&wdev->list);
  978. synchronize_net();
  979. rdev->devlist_generation++;
  980. cfg80211_mlme_purge_registrations(wdev);
  981. switch (wdev->iftype) {
  982. case NL80211_IFTYPE_P2P_DEVICE:
  983. cfg80211_stop_p2p_device(rdev, wdev);
  984. break;
  985. case NL80211_IFTYPE_NAN:
  986. cfg80211_stop_nan(rdev, wdev);
  987. break;
  988. default:
  989. break;
  990. }
  991. #ifdef CONFIG_CFG80211_WEXT
  992. kfree_sensitive(wdev->wext.keys);
  993. wdev->wext.keys = NULL;
  994. #endif
  995. cfg80211_cqm_config_free(wdev);
  996. /*
  997. * Ensure that all events have been processed and
  998. * freed.
  999. */
  1000. cfg80211_process_wdev_events(wdev);
  1001. if (wdev->iftype == NL80211_IFTYPE_STATION ||
  1002. wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) {
  1003. for (link_id = 0; link_id < ARRAY_SIZE(wdev->links); link_id++) {
  1004. struct cfg80211_internal_bss *curbss;
  1005. curbss = wdev->links[link_id].client.current_bss;
  1006. if (WARN_ON(curbss)) {
  1007. cfg80211_unhold_bss(curbss);
  1008. cfg80211_put_bss(wdev->wiphy, &curbss->pub);
  1009. wdev->links[link_id].client.current_bss = NULL;
  1010. }
  1011. }
  1012. }
  1013. wdev->connected = false;
  1014. }
  1015. void cfg80211_unregister_wdev(struct wireless_dev *wdev)
  1016. {
  1017. _cfg80211_unregister_wdev(wdev, true);
  1018. }
  1019. EXPORT_SYMBOL(cfg80211_unregister_wdev);
  1020. static const struct device_type wiphy_type = {
  1021. .name = "wlan",
  1022. };
  1023. void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
  1024. enum nl80211_iftype iftype, int num)
  1025. {
  1026. lockdep_assert_held(&rdev->wiphy.mtx);
  1027. rdev->num_running_ifaces += num;
  1028. if (iftype == NL80211_IFTYPE_MONITOR)
  1029. rdev->num_running_monitor_ifaces += num;
  1030. }
  1031. void __cfg80211_leave(struct cfg80211_registered_device *rdev,
  1032. struct wireless_dev *wdev)
  1033. {
  1034. struct net_device *dev = wdev->netdev;
  1035. struct cfg80211_sched_scan_request *pos, *tmp;
  1036. lockdep_assert_held(&rdev->wiphy.mtx);
  1037. ASSERT_WDEV_LOCK(wdev);
  1038. cfg80211_pmsr_wdev_down(wdev);
  1039. cfg80211_stop_background_radar_detection(wdev);
  1040. switch (wdev->iftype) {
  1041. case NL80211_IFTYPE_ADHOC:
  1042. __cfg80211_leave_ibss(rdev, dev, true);
  1043. break;
  1044. case NL80211_IFTYPE_P2P_CLIENT:
  1045. case NL80211_IFTYPE_STATION:
  1046. list_for_each_entry_safe(pos, tmp, &rdev->sched_scan_req_list,
  1047. list) {
  1048. if (dev == pos->dev)
  1049. cfg80211_stop_sched_scan_req(rdev, pos, false);
  1050. }
  1051. #ifdef CONFIG_CFG80211_WEXT
  1052. kfree(wdev->wext.ie);
  1053. wdev->wext.ie = NULL;
  1054. wdev->wext.ie_len = 0;
  1055. wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
  1056. #endif
  1057. cfg80211_disconnect(rdev, dev,
  1058. WLAN_REASON_DEAUTH_LEAVING, true);
  1059. break;
  1060. case NL80211_IFTYPE_MESH_POINT:
  1061. __cfg80211_leave_mesh(rdev, dev);
  1062. break;
  1063. case NL80211_IFTYPE_AP:
  1064. case NL80211_IFTYPE_P2P_GO:
  1065. __cfg80211_stop_ap(rdev, dev, -1, true);
  1066. break;
  1067. case NL80211_IFTYPE_OCB:
  1068. __cfg80211_leave_ocb(rdev, dev);
  1069. break;
  1070. case NL80211_IFTYPE_P2P_DEVICE:
  1071. case NL80211_IFTYPE_NAN:
  1072. /* cannot happen, has no netdev */
  1073. break;
  1074. case NL80211_IFTYPE_AP_VLAN:
  1075. case NL80211_IFTYPE_MONITOR:
  1076. /* nothing to do */
  1077. break;
  1078. case NL80211_IFTYPE_UNSPECIFIED:
  1079. case NL80211_IFTYPE_WDS:
  1080. case NUM_NL80211_IFTYPES:
  1081. /* invalid */
  1082. break;
  1083. }
  1084. }
  1085. void cfg80211_leave(struct cfg80211_registered_device *rdev,
  1086. struct wireless_dev *wdev)
  1087. {
  1088. wdev_lock(wdev);
  1089. __cfg80211_leave(rdev, wdev);
  1090. wdev_unlock(wdev);
  1091. }
  1092. void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
  1093. gfp_t gfp)
  1094. {
  1095. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  1096. struct cfg80211_event *ev;
  1097. unsigned long flags;
  1098. trace_cfg80211_stop_iface(wiphy, wdev);
  1099. ev = kzalloc(sizeof(*ev), gfp);
  1100. if (!ev)
  1101. return;
  1102. ev->type = EVENT_STOPPED;
  1103. spin_lock_irqsave(&wdev->event_lock, flags);
  1104. list_add_tail(&ev->list, &wdev->event_list);
  1105. spin_unlock_irqrestore(&wdev->event_lock, flags);
  1106. queue_work(cfg80211_wq, &rdev->event_work);
  1107. }
  1108. EXPORT_SYMBOL(cfg80211_stop_iface);
  1109. void cfg80211_init_wdev(struct wireless_dev *wdev)
  1110. {
  1111. mutex_init(&wdev->mtx);
  1112. INIT_LIST_HEAD(&wdev->event_list);
  1113. spin_lock_init(&wdev->event_lock);
  1114. INIT_LIST_HEAD(&wdev->mgmt_registrations);
  1115. INIT_LIST_HEAD(&wdev->pmsr_list);
  1116. spin_lock_init(&wdev->pmsr_lock);
  1117. INIT_WORK(&wdev->pmsr_free_wk, cfg80211_pmsr_free_wk);
  1118. #ifdef CONFIG_CFG80211_WEXT
  1119. wdev->wext.default_key = -1;
  1120. wdev->wext.default_mgmt_key = -1;
  1121. wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
  1122. #endif
  1123. if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
  1124. wdev->ps = true;
  1125. else
  1126. wdev->ps = false;
  1127. /* allow mac80211 to determine the timeout */
  1128. wdev->ps_timeout = -1;
  1129. if ((wdev->iftype == NL80211_IFTYPE_STATION ||
  1130. wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
  1131. wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
  1132. wdev->netdev->priv_flags |= IFF_DONT_BRIDGE;
  1133. INIT_WORK(&wdev->disconnect_wk, cfg80211_autodisconnect_wk);
  1134. }
  1135. void cfg80211_register_wdev(struct cfg80211_registered_device *rdev,
  1136. struct wireless_dev *wdev)
  1137. {
  1138. ASSERT_RTNL();
  1139. lockdep_assert_held(&rdev->wiphy.mtx);
  1140. /*
  1141. * We get here also when the interface changes network namespaces,
  1142. * as it's registered into the new one, but we don't want it to
  1143. * change ID in that case. Checking if the ID is already assigned
  1144. * works, because 0 isn't considered a valid ID and the memory is
  1145. * 0-initialized.
  1146. */
  1147. if (!wdev->identifier)
  1148. wdev->identifier = ++rdev->wdev_id;
  1149. list_add_rcu(&wdev->list, &rdev->wiphy.wdev_list);
  1150. rdev->devlist_generation++;
  1151. wdev->registered = true;
  1152. if (wdev->netdev &&
  1153. sysfs_create_link(&wdev->netdev->dev.kobj, &rdev->wiphy.dev.kobj,
  1154. "phy80211"))
  1155. pr_err("failed to add phy80211 symlink to netdev!\n");
  1156. nl80211_notify_iface(rdev, wdev, NL80211_CMD_NEW_INTERFACE);
  1157. }
  1158. int cfg80211_register_netdevice(struct net_device *dev)
  1159. {
  1160. struct wireless_dev *wdev = dev->ieee80211_ptr;
  1161. struct cfg80211_registered_device *rdev;
  1162. int ret;
  1163. ASSERT_RTNL();
  1164. if (WARN_ON(!wdev))
  1165. return -EINVAL;
  1166. rdev = wiphy_to_rdev(wdev->wiphy);
  1167. lockdep_assert_held(&rdev->wiphy.mtx);
  1168. /* we'll take care of this */
  1169. wdev->registered = true;
  1170. wdev->registering = true;
  1171. ret = register_netdevice(dev);
  1172. if (ret)
  1173. goto out;
  1174. cfg80211_register_wdev(rdev, wdev);
  1175. ret = 0;
  1176. out:
  1177. wdev->registering = false;
  1178. if (ret)
  1179. wdev->registered = false;
  1180. return ret;
  1181. }
  1182. EXPORT_SYMBOL(cfg80211_register_netdevice);
  1183. static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
  1184. unsigned long state, void *ptr)
  1185. {
  1186. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  1187. struct wireless_dev *wdev = dev->ieee80211_ptr;
  1188. struct cfg80211_registered_device *rdev;
  1189. struct cfg80211_sched_scan_request *pos, *tmp;
  1190. if (!wdev)
  1191. return NOTIFY_DONE;
  1192. rdev = wiphy_to_rdev(wdev->wiphy);
  1193. WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
  1194. switch (state) {
  1195. case NETDEV_POST_INIT:
  1196. SET_NETDEV_DEVTYPE(dev, &wiphy_type);
  1197. wdev->netdev = dev;
  1198. /* can only change netns with wiphy */
  1199. dev->features |= NETIF_F_NETNS_LOCAL;
  1200. cfg80211_init_wdev(wdev);
  1201. break;
  1202. case NETDEV_REGISTER:
  1203. if (!wdev->registered) {
  1204. wiphy_lock(&rdev->wiphy);
  1205. cfg80211_register_wdev(rdev, wdev);
  1206. wiphy_unlock(&rdev->wiphy);
  1207. }
  1208. break;
  1209. case NETDEV_UNREGISTER:
  1210. /*
  1211. * It is possible to get NETDEV_UNREGISTER multiple times,
  1212. * so check wdev->registered.
  1213. */
  1214. if (wdev->registered && !wdev->registering) {
  1215. wiphy_lock(&rdev->wiphy);
  1216. _cfg80211_unregister_wdev(wdev, false);
  1217. wiphy_unlock(&rdev->wiphy);
  1218. }
  1219. break;
  1220. case NETDEV_GOING_DOWN:
  1221. wiphy_lock(&rdev->wiphy);
  1222. cfg80211_leave(rdev, wdev);
  1223. cfg80211_remove_links(wdev);
  1224. wiphy_unlock(&rdev->wiphy);
  1225. /* since we just did cfg80211_leave() nothing to do there */
  1226. cancel_work_sync(&wdev->disconnect_wk);
  1227. break;
  1228. case NETDEV_DOWN:
  1229. wiphy_lock(&rdev->wiphy);
  1230. cfg80211_update_iface_num(rdev, wdev->iftype, -1);
  1231. if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
  1232. if (WARN_ON(!rdev->scan_req->notified &&
  1233. (!rdev->int_scan_req ||
  1234. !rdev->int_scan_req->notified)))
  1235. rdev->scan_req->info.aborted = true;
  1236. ___cfg80211_scan_done(rdev, false);
  1237. }
  1238. list_for_each_entry_safe(pos, tmp,
  1239. &rdev->sched_scan_req_list, list) {
  1240. if (WARN_ON(pos->dev == wdev->netdev))
  1241. cfg80211_stop_sched_scan_req(rdev, pos, false);
  1242. }
  1243. rdev->opencount--;
  1244. wiphy_unlock(&rdev->wiphy);
  1245. wake_up(&rdev->dev_wait);
  1246. break;
  1247. case NETDEV_UP:
  1248. wiphy_lock(&rdev->wiphy);
  1249. cfg80211_update_iface_num(rdev, wdev->iftype, 1);
  1250. wdev_lock(wdev);
  1251. switch (wdev->iftype) {
  1252. #ifdef CONFIG_CFG80211_WEXT
  1253. case NL80211_IFTYPE_ADHOC:
  1254. cfg80211_ibss_wext_join(rdev, wdev);
  1255. break;
  1256. case NL80211_IFTYPE_STATION:
  1257. cfg80211_mgd_wext_connect(rdev, wdev);
  1258. break;
  1259. #endif
  1260. #ifdef CONFIG_MAC80211_MESH
  1261. case NL80211_IFTYPE_MESH_POINT:
  1262. {
  1263. /* backward compat code... */
  1264. struct mesh_setup setup;
  1265. memcpy(&setup, &default_mesh_setup,
  1266. sizeof(setup));
  1267. /* back compat only needed for mesh_id */
  1268. setup.mesh_id = wdev->u.mesh.id;
  1269. setup.mesh_id_len = wdev->u.mesh.id_up_len;
  1270. if (wdev->u.mesh.id_up_len)
  1271. __cfg80211_join_mesh(rdev, dev,
  1272. &setup,
  1273. &default_mesh_config);
  1274. break;
  1275. }
  1276. #endif
  1277. default:
  1278. break;
  1279. }
  1280. wdev_unlock(wdev);
  1281. rdev->opencount++;
  1282. /*
  1283. * Configure power management to the driver here so that its
  1284. * correctly set also after interface type changes etc.
  1285. */
  1286. if ((wdev->iftype == NL80211_IFTYPE_STATION ||
  1287. wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
  1288. rdev->ops->set_power_mgmt &&
  1289. rdev_set_power_mgmt(rdev, dev, wdev->ps,
  1290. wdev->ps_timeout)) {
  1291. /* assume this means it's off */
  1292. wdev->ps = false;
  1293. }
  1294. wiphy_unlock(&rdev->wiphy);
  1295. break;
  1296. case NETDEV_PRE_UP:
  1297. if (!cfg80211_iftype_allowed(wdev->wiphy, wdev->iftype,
  1298. wdev->use_4addr, 0))
  1299. return notifier_from_errno(-EOPNOTSUPP);
  1300. if (rfkill_blocked(rdev->wiphy.rfkill))
  1301. return notifier_from_errno(-ERFKILL);
  1302. break;
  1303. default:
  1304. return NOTIFY_DONE;
  1305. }
  1306. wireless_nlevent_flush();
  1307. return NOTIFY_OK;
  1308. }
  1309. static struct notifier_block cfg80211_netdev_notifier = {
  1310. .notifier_call = cfg80211_netdev_notifier_call,
  1311. };
  1312. static void __net_exit cfg80211_pernet_exit(struct net *net)
  1313. {
  1314. struct cfg80211_registered_device *rdev;
  1315. rtnl_lock();
  1316. list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
  1317. if (net_eq(wiphy_net(&rdev->wiphy), net))
  1318. WARN_ON(cfg80211_switch_netns(rdev, &init_net));
  1319. }
  1320. rtnl_unlock();
  1321. }
  1322. static struct pernet_operations cfg80211_pernet_ops = {
  1323. .exit = cfg80211_pernet_exit,
  1324. };
  1325. void wiphy_work_queue(struct wiphy *wiphy, struct wiphy_work *work)
  1326. {
  1327. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  1328. unsigned long flags;
  1329. spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
  1330. if (list_empty(&work->entry))
  1331. list_add_tail(&work->entry, &rdev->wiphy_work_list);
  1332. spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
  1333. queue_work(system_unbound_wq, &rdev->wiphy_work);
  1334. }
  1335. EXPORT_SYMBOL_GPL(wiphy_work_queue);
  1336. void wiphy_work_cancel(struct wiphy *wiphy, struct wiphy_work *work)
  1337. {
  1338. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  1339. unsigned long flags;
  1340. lockdep_assert_held(&wiphy->mtx);
  1341. spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
  1342. if (!list_empty(&work->entry))
  1343. list_del_init(&work->entry);
  1344. spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
  1345. }
  1346. EXPORT_SYMBOL_GPL(wiphy_work_cancel);
  1347. void wiphy_work_flush(struct wiphy *wiphy, struct wiphy_work *work)
  1348. {
  1349. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
  1350. unsigned long flags;
  1351. bool run;
  1352. spin_lock_irqsave(&rdev->wiphy_work_lock, flags);
  1353. run = !work || !list_empty(&work->entry);
  1354. spin_unlock_irqrestore(&rdev->wiphy_work_lock, flags);
  1355. if (run)
  1356. cfg80211_process_wiphy_works(rdev, work);
  1357. }
  1358. EXPORT_SYMBOL_GPL(wiphy_work_flush);
  1359. void wiphy_delayed_work_timer(struct timer_list *t)
  1360. {
  1361. struct wiphy_delayed_work *dwork = from_timer(dwork, t, timer);
  1362. wiphy_work_queue(dwork->wiphy, &dwork->work);
  1363. }
  1364. EXPORT_SYMBOL(wiphy_delayed_work_timer);
  1365. void wiphy_delayed_work_queue(struct wiphy *wiphy,
  1366. struct wiphy_delayed_work *dwork,
  1367. unsigned long delay)
  1368. {
  1369. if (!delay) {
  1370. wiphy_work_queue(wiphy, &dwork->work);
  1371. return;
  1372. }
  1373. dwork->wiphy = wiphy;
  1374. mod_timer(&dwork->timer, jiffies + delay);
  1375. }
  1376. EXPORT_SYMBOL_GPL(wiphy_delayed_work_queue);
  1377. void wiphy_delayed_work_cancel(struct wiphy *wiphy,
  1378. struct wiphy_delayed_work *dwork)
  1379. {
  1380. lockdep_assert_held(&wiphy->mtx);
  1381. del_timer_sync(&dwork->timer);
  1382. wiphy_work_cancel(wiphy, &dwork->work);
  1383. }
  1384. EXPORT_SYMBOL_GPL(wiphy_delayed_work_cancel);
  1385. void wiphy_delayed_work_flush(struct wiphy *wiphy,
  1386. struct wiphy_delayed_work *dwork)
  1387. {
  1388. lockdep_assert_held(&wiphy->mtx);
  1389. del_timer_sync(&dwork->timer);
  1390. wiphy_work_flush(wiphy, &dwork->work);
  1391. }
  1392. EXPORT_SYMBOL_GPL(wiphy_delayed_work_flush);
  1393. static int __init cfg80211_init(void)
  1394. {
  1395. int err;
  1396. err = register_pernet_device(&cfg80211_pernet_ops);
  1397. if (err)
  1398. goto out_fail_pernet;
  1399. err = wiphy_sysfs_init();
  1400. if (err)
  1401. goto out_fail_sysfs;
  1402. err = register_netdevice_notifier(&cfg80211_netdev_notifier);
  1403. if (err)
  1404. goto out_fail_notifier;
  1405. err = nl80211_init();
  1406. if (err)
  1407. goto out_fail_nl80211;
  1408. ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
  1409. err = regulatory_init();
  1410. if (err)
  1411. goto out_fail_reg;
  1412. cfg80211_wq = alloc_ordered_workqueue("cfg80211", WQ_MEM_RECLAIM);
  1413. if (!cfg80211_wq) {
  1414. err = -ENOMEM;
  1415. goto out_fail_wq;
  1416. }
  1417. return 0;
  1418. out_fail_wq:
  1419. regulatory_exit();
  1420. out_fail_reg:
  1421. debugfs_remove(ieee80211_debugfs_dir);
  1422. nl80211_exit();
  1423. out_fail_nl80211:
  1424. unregister_netdevice_notifier(&cfg80211_netdev_notifier);
  1425. out_fail_notifier:
  1426. wiphy_sysfs_exit();
  1427. out_fail_sysfs:
  1428. unregister_pernet_device(&cfg80211_pernet_ops);
  1429. out_fail_pernet:
  1430. return err;
  1431. }
  1432. fs_initcall(cfg80211_init);
  1433. static void __exit cfg80211_exit(void)
  1434. {
  1435. debugfs_remove(ieee80211_debugfs_dir);
  1436. nl80211_exit();
  1437. unregister_netdevice_notifier(&cfg80211_netdev_notifier);
  1438. wiphy_sysfs_exit();
  1439. regulatory_exit();
  1440. unregister_pernet_device(&cfg80211_pernet_ops);
  1441. destroy_workqueue(cfg80211_wq);
  1442. }
  1443. module_exit(cfg80211_exit);