projects / deliverable / linux.git / blob
? search:


4910758baab11be4a318fd34a626b7d6bb90c9f3
[deliverable/linux.git] / net / wireless / core.c
1 /*
2 * This is the linux wireless configuration interface.
3 *
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2013-2014 Intel Mobile Communications GmbH
6 */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/if.h>
11 #include <linux/module.h>
12 #include <linux/err.h>
13 #include <linux/list.h>
14 #include <linux/slab.h>
15 #include <linux/nl80211.h>
16 #include <linux/debugfs.h>
17 #include <linux/notifier.h>
18 #include <linux/device.h>
19 #include <linux/etherdevice.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/sched.h>
22 #include <net/genetlink.h>
23 #include <net/cfg80211.h>
24 #include <net/rtnetlink.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
32 /* name for sysfs, %d is appended */
33 #define PHY_NAME "phy"
34
35 MODULE_AUTHOR("Johannes Berg");
36 MODULE_LICENSE("GPL");
37 MODULE_DESCRIPTION("wireless configuration support");
38 MODULE_ALIAS_GENL_FAMILY(NL80211_GENL_NAME);
39
40 /* RCU-protected (and RTNL for writers) */
41 LIST_HEAD(cfg80211_rdev_list);
42 int cfg80211_rdev_list_generation;
43
44 /* for debugfs */
45 static struct dentry *ieee80211_debugfs_dir;
46
47 /* for the cleanup, scan and event works */
48 struct workqueue_struct *cfg80211_wq;
49
50 static bool cfg80211_disable_40mhz_24ghz;
51 module_param(cfg80211_disable_40mhz_24ghz, bool, 0644);
52 MODULE_PARM_DESC(cfg80211_disable_40mhz_24ghz,
53 "Disable 40MHz support in the 2.4GHz band");
54
55 struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx)
56 {
57 struct cfg80211_registered_device *result = NULL, *rdev;
58
59 ASSERT_RTNL();
60
61 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
62 if (rdev->wiphy_idx == wiphy_idx) {
63 result = rdev;
64 break;
65 }
66 }
67
68 return result;
69 }
70
71 int get_wiphy_idx(struct wiphy *wiphy)
72 {
73 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
74
75 return rdev->wiphy_idx;
76 }
77
78 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
79 {
80 struct cfg80211_registered_device *rdev;
81
82 ASSERT_RTNL();
83
84 rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx);
85 if (!rdev)
86 return NULL;
87 return &rdev->wiphy;
88 }
89
90 static int cfg80211_dev_check_name(struct cfg80211_registered_device *rdev,
91 const char *newname)
92 {
93 struct cfg80211_registered_device *rdev2;
94 int wiphy_idx, taken = -1, digits;
95
96 ASSERT_RTNL();
97
98 /* prohibit calling the thing phy%d when %d is not its number */
99 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
100 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
101 /* count number of places needed to print wiphy_idx */
102 digits = 1;
103 while (wiphy_idx /= 10)
104 digits++;
105 /*
106 * deny the name if it is phy<idx> where <idx> is printed
107 * without leading zeroes. taken == strlen(newname) here
108 */
109 if (taken == strlen(PHY_NAME) + digits)
110 return -EINVAL;
111 }
112
113 /* Ensure another device does not already have this name. */
114 list_for_each_entry(rdev2, &cfg80211_rdev_list, list)
115 if (strcmp(newname, wiphy_name(&rdev2->wiphy)) == 0)
116 return -EINVAL;
117
118 return 0;
119 }
120
121 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
122 char *newname)
123 {
124 int result;
125
126 ASSERT_RTNL();
127
128 /* Ignore nop renames */
129 if (strcmp(newname, wiphy_name(&rdev->wiphy)) == 0)
130 return 0;
131
132 result = cfg80211_dev_check_name(rdev, newname);
133 if (result < 0)
134 return result;
135
136 result = device_rename(&rdev->wiphy.dev, newname);
137 if (result)
138 return result;
139
140 if (rdev->wiphy.debugfsdir &&
141 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
142 rdev->wiphy.debugfsdir,
143 rdev->wiphy.debugfsdir->d_parent,
144 newname))
145 pr_err("failed to rename debugfs dir to %s!\n", newname);
146
147 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
148
149 return 0;
150 }
151
152 int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
153 struct net *net)
154 {
155 struct wireless_dev *wdev;
156 int err = 0;
157
158 if (!(rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK))
159 return -EOPNOTSUPP;
160
161 list_for_each_entry(wdev, &rdev->wdev_list, list) {
162 if (!wdev->netdev)
163 continue;
164 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
165 err = dev_change_net_namespace(wdev->netdev, net, "wlan%d");
166 if (err)
167 break;
168 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
169 }
170
171 if (err) {
172 /* failed -- clean up to old netns */
173 net = wiphy_net(&rdev->wiphy);
174
175 list_for_each_entry_continue_reverse(wdev, &rdev->wdev_list,
176 list) {
177 if (!wdev->netdev)
178 continue;
179 wdev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
180 err = dev_change_net_namespace(wdev->netdev, net,
181 "wlan%d");
182 WARN_ON(err);
183 wdev->netdev->features |= NETIF_F_NETNS_LOCAL;
184 }
185
186 return err;
187 }
188
189 wiphy_net_set(&rdev->wiphy, net);
190
191 err = device_rename(&rdev->wiphy.dev, dev_name(&rdev->wiphy.dev));
192 WARN_ON(err);
193
194 return 0;
195 }
196
197 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
198 {
199 struct cfg80211_registered_device *rdev = data;
200
201 rdev_rfkill_poll(rdev);
202 }
203
204 void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
205 struct wireless_dev *wdev)
206 {
207 ASSERT_RTNL();
208
209 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_P2P_DEVICE))
210 return;
211
212 if (!wdev->p2p_started)
213 return;
214
215 rdev_stop_p2p_device(rdev, wdev);
216 wdev->p2p_started = false;
217
218 rdev->opencount--;
219
220 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
221 if (WARN_ON(!rdev->scan_req->notified))
222 rdev->scan_req->aborted = true;
223 ___cfg80211_scan_done(rdev, false);
224 }
225 }
226
227 void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy)
228 {
229 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
230 struct wireless_dev *wdev;
231
232 ASSERT_RTNL();
233
234 list_for_each_entry(wdev, &rdev->wdev_list, list) {
235 if (wdev->netdev) {
236 dev_close(wdev->netdev);
237 continue;
238 }
239 /* otherwise, check iftype */
240 switch (wdev->iftype) {
241 case NL80211_IFTYPE_P2P_DEVICE:
242 cfg80211_stop_p2p_device(rdev, wdev);
243 break;
244 default:
245 break;
246 }
247 }
248 }
249 EXPORT_SYMBOL_GPL(cfg80211_shutdown_all_interfaces);
250
251 static int cfg80211_rfkill_set_block(void *data, bool blocked)
252 {
253 struct cfg80211_registered_device *rdev = data;
254
255 if (!blocked)
256 return 0;
257
258 rtnl_lock();
259 cfg80211_shutdown_all_interfaces(&rdev->wiphy);
260 rtnl_unlock();
261
262 return 0;
263 }
264
265 static void cfg80211_rfkill_sync_work(struct work_struct *work)
266 {
267 struct cfg80211_registered_device *rdev;
268
269 rdev = container_of(work, struct cfg80211_registered_device, rfkill_sync);
270 cfg80211_rfkill_set_block(rdev, rfkill_blocked(rdev->rfkill));
271 }
272
273 static void cfg80211_event_work(struct work_struct *work)
274 {
275 struct cfg80211_registered_device *rdev;
276
277 rdev = container_of(work, struct cfg80211_registered_device,
278 event_work);
279
280 rtnl_lock();
281 cfg80211_process_rdev_events(rdev);
282 rtnl_unlock();
283 }
284
285 void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev)
286 {
287 struct cfg80211_iface_destroy *item;
288
289 ASSERT_RTNL();
290
291 spin_lock_irq(&rdev->destroy_list_lock);
292 while ((item = list_first_entry_or_null(&rdev->destroy_list,
293 struct cfg80211_iface_destroy,
294 list))) {
295 struct wireless_dev *wdev, *tmp;
296 u32 nlportid = item->nlportid;
297
298 list_del(&item->list);
299 kfree(item);
300 spin_unlock_irq(&rdev->destroy_list_lock);
301
302 list_for_each_entry_safe(wdev, tmp, &rdev->wdev_list, list) {
303 if (nlportid == wdev->owner_nlportid)
304 rdev_del_virtual_intf(rdev, wdev);
305 }
306
307 spin_lock_irq(&rdev->destroy_list_lock);
308 }
309 spin_unlock_irq(&rdev->destroy_list_lock);
310 }
311
312 static void cfg80211_destroy_iface_wk(struct work_struct *work)
313 {
314 struct cfg80211_registered_device *rdev;
315
316 rdev = container_of(work, struct cfg80211_registered_device,
317 destroy_work);
318
319 rtnl_lock();
320 cfg80211_destroy_ifaces(rdev);
321 rtnl_unlock();
322 }
323
324 /* exported functions */
325
326 struct wiphy *wiphy_new_nm(const struct cfg80211_ops *ops, int sizeof_priv,
327 const char *requested_name)
328 {
329 static atomic_t wiphy_counter = ATOMIC_INIT(0);
330
331 struct cfg80211_registered_device *rdev;
332 int alloc_size;
333
334 WARN_ON(ops->add_key && (!ops->del_key || !ops->set_default_key));
335 WARN_ON(ops->auth && (!ops->assoc || !ops->deauth || !ops->disassoc));
336 WARN_ON(ops->connect && !ops->disconnect);
337 WARN_ON(ops->join_ibss && !ops->leave_ibss);
338 WARN_ON(ops->add_virtual_intf && !ops->del_virtual_intf);
339 WARN_ON(ops->add_station && !ops->del_station);
340 WARN_ON(ops->add_mpath && !ops->del_mpath);
341 WARN_ON(ops->join_mesh && !ops->leave_mesh);
342
343 alloc_size = sizeof(*rdev) + sizeof_priv;
344
345 rdev = kzalloc(alloc_size, GFP_KERNEL);
346 if (!rdev)
347 return NULL;
348
349 rdev->ops = ops;
350
351 rdev->wiphy_idx = atomic_inc_return(&wiphy_counter);
352
353 if (unlikely(rdev->wiphy_idx < 0)) {
354 /* ugh, wrapped! */
355 atomic_dec(&wiphy_counter);
356 kfree(rdev);
357 return NULL;
358 }
359
360 /* atomic_inc_return makes it start at 1, make it start at 0 */
361 rdev->wiphy_idx--;
362
363 /* give it a proper name */
364 if (requested_name && requested_name[0]) {
365 int rv;
366
367 rtnl_lock();
368 rv = cfg80211_dev_check_name(rdev, requested_name);
369
370 if (rv < 0) {
371 rtnl_unlock();
372 goto use_default_name;
373 }
374
375 rv = dev_set_name(&rdev->wiphy.dev, "%s", requested_name);
376 rtnl_unlock();
377 if (rv)
378 goto use_default_name;
379 } else {
380 use_default_name:
381 /* NOTE: This is *probably* safe w/out holding rtnl because of
382 * the restrictions on phy names. Probably this call could
383 * fail if some other part of the kernel (re)named a device
384 * phyX. But, might should add some locking and check return
385 * value, and use a different name if this one exists?
386 */
387 dev_set_name(&rdev->wiphy.dev, PHY_NAME "%d", rdev->wiphy_idx);
388 }
389
390 INIT_LIST_HEAD(&rdev->wdev_list);
391 INIT_LIST_HEAD(&rdev->beacon_registrations);
392 spin_lock_init(&rdev->beacon_registrations_lock);
393 spin_lock_init(&rdev->bss_lock);
394 INIT_LIST_HEAD(&rdev->bss_list);
395 INIT_WORK(&rdev->scan_done_wk, __cfg80211_scan_done);
396 INIT_WORK(&rdev->sched_scan_results_wk, __cfg80211_sched_scan_results);
397 INIT_DELAYED_WORK(&rdev->dfs_update_channels_wk,
398 cfg80211_dfs_channels_update_work);
399 #ifdef CONFIG_CFG80211_WEXT
400 rdev->wiphy.wext = &cfg80211_wext_handler;
401 #endif
402
403 device_initialize(&rdev->wiphy.dev);
404 rdev->wiphy.dev.class = &ieee80211_class;
405 rdev->wiphy.dev.platform_data = rdev;
406
407 INIT_LIST_HEAD(&rdev->destroy_list);
408 spin_lock_init(&rdev->destroy_list_lock);
409 INIT_WORK(&rdev->destroy_work, cfg80211_destroy_iface_wk);
410
411 #ifdef CONFIG_CFG80211_DEFAULT_PS
412 rdev->wiphy.flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
413 #endif
414
415 wiphy_net_set(&rdev->wiphy, &init_net);
416
417 rdev->rfkill_ops.set_block = cfg80211_rfkill_set_block;
418 rdev->rfkill = rfkill_alloc(dev_name(&rdev->wiphy.dev),
419 &rdev->wiphy.dev, RFKILL_TYPE_WLAN,
420 &rdev->rfkill_ops, rdev);
421
422 if (!rdev->rfkill) {
423 kfree(rdev);
424 return NULL;
425 }
426
427 INIT_WORK(&rdev->rfkill_sync, cfg80211_rfkill_sync_work);
428 INIT_WORK(&rdev->conn_work, cfg80211_conn_work);
429 INIT_WORK(&rdev->event_work, cfg80211_event_work);
430
431 init_waitqueue_head(&rdev->dev_wait);
432
433 /*
434 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
435 * Fragmentation and RTS threshold are disabled by default with the
436 * special -1 value.
437 */
438 rdev->wiphy.retry_short = 7;
439 rdev->wiphy.retry_long = 4;
440 rdev->wiphy.frag_threshold = (u32) -1;
441 rdev->wiphy.rts_threshold = (u32) -1;
442 rdev->wiphy.coverage_class = 0;
443
444 rdev->wiphy.max_num_csa_counters = 1;
445
446 return &rdev->wiphy;
447 }
448 EXPORT_SYMBOL(wiphy_new_nm);
449
450 static int wiphy_verify_combinations(struct wiphy *wiphy)
451 {
452 const struct ieee80211_iface_combination *c;
453 int i, j;
454
455 for (i = 0; i < wiphy->n_iface_combinations; i++) {
456 u32 cnt = 0;
457 u16 all_iftypes = 0;
458
459 c = &wiphy->iface_combinations[i];
460
461 /*
462 * Combinations with just one interface aren't real,
463 * however we make an exception for DFS.
464 */
465 if (WARN_ON((c->max_interfaces < 2) && !c->radar_detect_widths))
466 return -EINVAL;
467
468 /* Need at least one channel */
469 if (WARN_ON(!c->num_different_channels))
470 return -EINVAL;
471
472 /*
473 * Put a sane limit on maximum number of different
474 * channels to simplify channel accounting code.
475 */
476 if (WARN_ON(c->num_different_channels >
477 CFG80211_MAX_NUM_DIFFERENT_CHANNELS))
478 return -EINVAL;
479
480 /* DFS only works on one channel. */
481 if (WARN_ON(c->radar_detect_widths &&
482 (c->num_different_channels > 1)))
483 return -EINVAL;
484
485 if (WARN_ON(!c->n_limits))
486 return -EINVAL;
487
488 for (j = 0; j < c->n_limits; j++) {
489 u16 types = c->limits[j].types;
490
491 /* interface types shouldn't overlap */
492 if (WARN_ON(types & all_iftypes))
493 return -EINVAL;
494 all_iftypes |= types;
495
496 if (WARN_ON(!c->limits[j].max))
497 return -EINVAL;
498
499 /* Shouldn't list software iftypes in combinations! */
500 if (WARN_ON(wiphy->software_iftypes & types))
501 return -EINVAL;
502
503 /* Only a single P2P_DEVICE can be allowed */
504 if (WARN_ON(types & BIT(NL80211_IFTYPE_P2P_DEVICE) &&
505 c->limits[j].max > 1))
506 return -EINVAL;
507
508 cnt += c->limits[j].max;
509 /*
510 * Don't advertise an unsupported type
511 * in a combination.
512 */
513 if (WARN_ON((wiphy->interface_modes & types) != types))
514 return -EINVAL;
515 }
516
517 /* You can't even choose that many! */
518 if (WARN_ON(cnt < c->max_interfaces))
519 return -EINVAL;
520 }
521
522 return 0;
523 }
524
525 int wiphy_register(struct wiphy *wiphy)
526 {
527 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
528 int res;
529 enum ieee80211_band band;
530 struct ieee80211_supported_band *sband;
531 bool have_band = false;
532 int i;
533 u16 ifmodes = wiphy->interface_modes;
534
535 #ifdef CONFIG_PM
536 if (WARN_ON(wiphy->wowlan &&
537 (wiphy->wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
538 !(wiphy->wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY)))
539 return -EINVAL;
540 if (WARN_ON(wiphy->wowlan &&
541 !wiphy->wowlan->flags && !wiphy->wowlan->n_patterns &&
542 !wiphy->wowlan->tcp))
543 return -EINVAL;
544 #endif
545 if (WARN_ON((wiphy->features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH) &&
546 (!rdev->ops->tdls_channel_switch ||
547 !rdev->ops->tdls_cancel_channel_switch)))
548 return -EINVAL;
549
550 /*
551 * if a wiphy has unsupported modes for regulatory channel enforcement,
552 * opt-out of enforcement checking
553 */
554 if (wiphy->interface_modes & ~(BIT(NL80211_IFTYPE_STATION) |
555 BIT(NL80211_IFTYPE_P2P_CLIENT) |
556 BIT(NL80211_IFTYPE_AP) |
557 BIT(NL80211_IFTYPE_P2P_GO) |
558 BIT(NL80211_IFTYPE_ADHOC) |
559 BIT(NL80211_IFTYPE_P2P_DEVICE) |
560 BIT(NL80211_IFTYPE_AP_VLAN) |
561 BIT(NL80211_IFTYPE_MONITOR)))
562 wiphy->regulatory_flags |= REGULATORY_IGNORE_STALE_KICKOFF;
563
564 if (WARN_ON(wiphy->coalesce &&
565 (!wiphy->coalesce->n_rules ||
566 !wiphy->coalesce->n_patterns) &&
567 (!wiphy->coalesce->pattern_min_len ||
568 wiphy->coalesce->pattern_min_len >
569 wiphy->coalesce->pattern_max_len)))
570 return -EINVAL;
571
572 if (WARN_ON(wiphy->ap_sme_capa &&
573 !(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME)))
574 return -EINVAL;
575
576 if (WARN_ON(wiphy->addresses && !wiphy->n_addresses))
577 return -EINVAL;
578
579 if (WARN_ON(wiphy->addresses &&
580 !is_zero_ether_addr(wiphy->perm_addr) &&
581 memcmp(wiphy->perm_addr, wiphy->addresses[0].addr,
582 ETH_ALEN)))
583 return -EINVAL;
584
585 if (WARN_ON(wiphy->max_acl_mac_addrs &&
586 (!(wiphy->flags & WIPHY_FLAG_HAVE_AP_SME) ||
587 !rdev->ops->set_mac_acl)))
588 return -EINVAL;
589
590 if (wiphy->addresses)
591 memcpy(wiphy->perm_addr, wiphy->addresses[0].addr, ETH_ALEN);
592
593 /* sanity check ifmodes */
594 WARN_ON(!ifmodes);
595 ifmodes &= ((1 << NUM_NL80211_IFTYPES) - 1) & ~1;
596 if (WARN_ON(ifmodes != wiphy->interface_modes))
597 wiphy->interface_modes = ifmodes;
598
599 res = wiphy_verify_combinations(wiphy);
600 if (res)
601 return res;
602
603 /* sanity check supported bands/channels */
604 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
605 sband = wiphy->bands[band];
606 if (!sband)
607 continue;
608
609 sband->band = band;
610 if (WARN_ON(!sband->n_channels))
611 return -EINVAL;
612 /*
613 * on 60gHz band, there are no legacy rates, so
614 * n_bitrates is 0
615 */
616 if (WARN_ON(band != IEEE80211_BAND_60GHZ &&
617 !sband->n_bitrates))
618 return -EINVAL;
619
620 /*
621 * Since cfg80211_disable_40mhz_24ghz is global, we can
622 * modify the sband's ht data even if the driver uses a
623 * global structure for that.
624 */
625 if (cfg80211_disable_40mhz_24ghz &&
626 band == IEEE80211_BAND_2GHZ &&
627 sband->ht_cap.ht_supported) {
628 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
629 sband->ht_cap.cap &= ~IEEE80211_HT_CAP_SGI_40;
630 }
631
632 /*
633 * Since we use a u32 for rate bitmaps in
634 * ieee80211_get_response_rate, we cannot
635 * have more than 32 legacy rates.
636 */
637 if (WARN_ON(sband->n_bitrates > 32))
638 return -EINVAL;
639
640 for (i = 0; i < sband->n_channels; i++) {
641 sband->channels[i].orig_flags =
642 sband->channels[i].flags;
643 sband->channels[i].orig_mag = INT_MAX;
644 sband->channels[i].orig_mpwr =
645 sband->channels[i].max_power;
646 sband->channels[i].band = band;
647 }
648
649 have_band = true;
650 }
651
652 if (!have_band) {
653 WARN_ON(1);
654 return -EINVAL;
655 }
656
657 #ifdef CONFIG_PM
658 if (WARN_ON(rdev->wiphy.wowlan && rdev->wiphy.wowlan->n_patterns &&
659 (!rdev->wiphy.wowlan->pattern_min_len ||
660 rdev->wiphy.wowlan->pattern_min_len >
661 rdev->wiphy.wowlan->pattern_max_len)))
662 return -EINVAL;
663 #endif
664
665 /* check and set up bitrates */
666 ieee80211_set_bitrate_flags(wiphy);
667
668 rdev->wiphy.features |= NL80211_FEATURE_SCAN_FLUSH;
669
670 rtnl_lock();
671 res = device_add(&rdev->wiphy.dev);
672 if (res) {
673 rtnl_unlock();
674 return res;
675 }
676
677 /* set up regulatory info */
678 wiphy_regulatory_register(wiphy);
679
680 list_add_rcu(&rdev->list, &cfg80211_rdev_list);
681 cfg80211_rdev_list_generation++;
682
683 /* add to debugfs */
684 rdev->wiphy.debugfsdir =
685 debugfs_create_dir(wiphy_name(&rdev->wiphy),
686 ieee80211_debugfs_dir);
687 if (IS_ERR(rdev->wiphy.debugfsdir))
688 rdev->wiphy.debugfsdir = NULL;
689
690 cfg80211_debugfs_rdev_add(rdev);
691 nl80211_notify_wiphy(rdev, NL80211_CMD_NEW_WIPHY);
692
693 if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
694 struct regulatory_request request;
695
696 request.wiphy_idx = get_wiphy_idx(wiphy);
697 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
698 request.alpha2[0] = '9';
699 request.alpha2[1] = '9';
700
701 nl80211_send_reg_change_event(&request);
702 }
703
704 rdev->wiphy.registered = true;
705 rtnl_unlock();
706
707 res = rfkill_register(rdev->rfkill);
708 if (res) {
709 rfkill_destroy(rdev->rfkill);
710 rdev->rfkill = NULL;
711 wiphy_unregister(&rdev->wiphy);
712 return res;
713 }
714
715 return 0;
716 }
717 EXPORT_SYMBOL(wiphy_register);
718
719 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
720 {
721 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
722
723 if (!rdev->ops->rfkill_poll)
724 return;
725 rdev->rfkill_ops.poll = cfg80211_rfkill_poll;
726 rfkill_resume_polling(rdev->rfkill);
727 }
728 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
729
730 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
731 {
732 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
733
734 rfkill_pause_polling(rdev->rfkill);
735 }
736 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
737
738 void wiphy_unregister(struct wiphy *wiphy)
739 {
740 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
741
742 wait_event(rdev->dev_wait, ({
743 int __count;
744 rtnl_lock();
745 __count = rdev->opencount;
746 rtnl_unlock();
747 __count == 0; }));
748
749 if (rdev->rfkill)
750 rfkill_unregister(rdev->rfkill);
751
752 rtnl_lock();
753 nl80211_notify_wiphy(rdev, NL80211_CMD_DEL_WIPHY);
754 rdev->wiphy.registered = false;
755
756 WARN_ON(!list_empty(&rdev->wdev_list));
757
758 /*
759 * First remove the hardware from everywhere, this makes
760 * it impossible to find from userspace.
761 */
762 debugfs_remove_recursive(rdev->wiphy.debugfsdir);
763 list_del_rcu(&rdev->list);
764 synchronize_rcu();
765
766 /*
767 * If this device got a regulatory hint tell core its
768 * free to listen now to a new shiny device regulatory hint
769 */
770 wiphy_regulatory_deregister(wiphy);
771
772 cfg80211_rdev_list_generation++;
773 device_del(&rdev->wiphy.dev);
774
775 rtnl_unlock();
776
777 flush_work(&rdev->scan_done_wk);
778 cancel_work_sync(&rdev->conn_work);
779 flush_work(&rdev->event_work);
780 cancel_delayed_work_sync(&rdev->dfs_update_channels_wk);
781 flush_work(&rdev->destroy_work);
782
783 #ifdef CONFIG_PM
784 if (rdev->wiphy.wowlan_config && rdev->ops->set_wakeup)
785 rdev_set_wakeup(rdev, false);
786 #endif
787 cfg80211_rdev_free_wowlan(rdev);
788 cfg80211_rdev_free_coalesce(rdev);
789 }
790 EXPORT_SYMBOL(wiphy_unregister);
791
792 void cfg80211_dev_free(struct cfg80211_registered_device *rdev)
793 {
794 struct cfg80211_internal_bss *scan, *tmp;
795 struct cfg80211_beacon_registration *reg, *treg;
796 rfkill_destroy(rdev->rfkill);
797 list_for_each_entry_safe(reg, treg, &rdev->beacon_registrations, list) {
798 list_del(&reg->list);
799 kfree(reg);
800 }
801 list_for_each_entry_safe(scan, tmp, &rdev->bss_list, list)
802 cfg80211_put_bss(&rdev->wiphy, &scan->pub);
803 kfree(rdev);
804 }
805
806 void wiphy_free(struct wiphy *wiphy)
807 {
808 put_device(&wiphy->dev);
809 }
810 EXPORT_SYMBOL(wiphy_free);
811
812 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
813 {
814 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
815
816 if (rfkill_set_hw_state(rdev->rfkill, blocked))
817 schedule_work(&rdev->rfkill_sync);
818 }
819 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
820
821 void cfg80211_unregister_wdev(struct wireless_dev *wdev)
822 {
823 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
824
825 ASSERT_RTNL();
826
827 if (WARN_ON(wdev->netdev))
828 return;
829
830 list_del_rcu(&wdev->list);
831 rdev->devlist_generation++;
832
833 switch (wdev->iftype) {
834 case NL80211_IFTYPE_P2P_DEVICE:
835 cfg80211_stop_p2p_device(rdev, wdev);
836 break;
837 default:
838 WARN_ON_ONCE(1);
839 break;
840 }
841 }
842 EXPORT_SYMBOL(cfg80211_unregister_wdev);
843
844 static const struct device_type wiphy_type = {
845 .name = "wlan",
846 };
847
848 void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
849 enum nl80211_iftype iftype, int num)
850 {
851 ASSERT_RTNL();
852
853 rdev->num_running_ifaces += num;
854 if (iftype == NL80211_IFTYPE_MONITOR)
855 rdev->num_running_monitor_ifaces += num;
856 }
857
858 void __cfg80211_leave(struct cfg80211_registered_device *rdev,
859 struct wireless_dev *wdev)
860 {
861 struct net_device *dev = wdev->netdev;
862
863 ASSERT_RTNL();
864 ASSERT_WDEV_LOCK(wdev);
865
866 switch (wdev->iftype) {
867 case NL80211_IFTYPE_ADHOC:
868 __cfg80211_leave_ibss(rdev, dev, true);
869 break;
870 case NL80211_IFTYPE_P2P_CLIENT:
871 case NL80211_IFTYPE_STATION:
872 if (rdev->sched_scan_req && dev == rdev->sched_scan_req->dev)
873 __cfg80211_stop_sched_scan(rdev, false);
874
875 #ifdef CONFIG_CFG80211_WEXT
876 kfree(wdev->wext.ie);
877 wdev->wext.ie = NULL;
878 wdev->wext.ie_len = 0;
879 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
880 #endif
881 cfg80211_disconnect(rdev, dev,
882 WLAN_REASON_DEAUTH_LEAVING, true);
883 break;
884 case NL80211_IFTYPE_MESH_POINT:
885 __cfg80211_leave_mesh(rdev, dev);
886 break;
887 case NL80211_IFTYPE_AP:
888 case NL80211_IFTYPE_P2P_GO:
889 __cfg80211_stop_ap(rdev, dev, true);
890 break;
891 case NL80211_IFTYPE_OCB:
892 __cfg80211_leave_ocb(rdev, dev);
893 break;
894 case NL80211_IFTYPE_WDS:
895 /* must be handled by mac80211/driver, has no APIs */
896 break;
897 case NL80211_IFTYPE_P2P_DEVICE:
898 /* cannot happen, has no netdev */
899 break;
900 case NL80211_IFTYPE_AP_VLAN:
901 case NL80211_IFTYPE_MONITOR:
902 /* nothing to do */
903 break;
904 case NL80211_IFTYPE_UNSPECIFIED:
905 case NUM_NL80211_IFTYPES:
906 /* invalid */
907 break;
908 }
909 }
910
911 void cfg80211_leave(struct cfg80211_registered_device *rdev,
912 struct wireless_dev *wdev)
913 {
914 wdev_lock(wdev);
915 __cfg80211_leave(rdev, wdev);
916 wdev_unlock(wdev);
917 }
918
919 void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
920 gfp_t gfp)
921 {
922 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
923 struct cfg80211_event *ev;
924 unsigned long flags;
925
926 trace_cfg80211_stop_iface(wiphy, wdev);
927
928 ev = kzalloc(sizeof(*ev), gfp);
929 if (!ev)
930 return;
931
932 ev->type = EVENT_STOPPED;
933
934 spin_lock_irqsave(&wdev->event_lock, flags);
935 list_add_tail(&ev->list, &wdev->event_list);
936 spin_unlock_irqrestore(&wdev->event_lock, flags);
937 queue_work(cfg80211_wq, &rdev->event_work);
938 }
939 EXPORT_SYMBOL(cfg80211_stop_iface);
940
941 static const struct rtnl_link_ops wireless_link_ops = {
942 .kind = "wlan",
943 };
944
945 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
946 unsigned long state, void *ptr)
947 {
948 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
949 struct wireless_dev *wdev = dev->ieee80211_ptr;
950 struct cfg80211_registered_device *rdev;
951
952 if (!wdev)
953 return NOTIFY_DONE;
954
955 rdev = wiphy_to_rdev(wdev->wiphy);
956
957 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
958
959 switch (state) {
960 case NETDEV_POST_INIT:
961 SET_NETDEV_DEVTYPE(dev, &wiphy_type);
962 dev->rtnl_link_ops = &wireless_link_ops;
963 break;
964 case NETDEV_REGISTER:
965 /*
966 * NB: cannot take rdev->mtx here because this may be
967 * called within code protected by it when interfaces
968 * are added with nl80211.
969 */
970 mutex_init(&wdev->mtx);
971 INIT_LIST_HEAD(&wdev->event_list);
972 spin_lock_init(&wdev->event_lock);
973 INIT_LIST_HEAD(&wdev->mgmt_registrations);
974 spin_lock_init(&wdev->mgmt_registrations_lock);
975
976 wdev->identifier = ++rdev->wdev_id;
977 list_add_rcu(&wdev->list, &rdev->wdev_list);
978 rdev->devlist_generation++;
979 /* can only change netns with wiphy */
980 dev->features |= NETIF_F_NETNS_LOCAL;
981
982 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
983 "phy80211")) {
984 pr_err("failed to add phy80211 symlink to netdev!\n");
985 }
986 wdev->netdev = dev;
987 #ifdef CONFIG_CFG80211_WEXT
988 wdev->wext.default_key = -1;
989 wdev->wext.default_mgmt_key = -1;
990 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
991 #endif
992
993 if (wdev->wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT)
994 wdev->ps = true;
995 else
996 wdev->ps = false;
997 /* allow mac80211 to determine the timeout */
998 wdev->ps_timeout = -1;
999
1000 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1001 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT ||
1002 wdev->iftype == NL80211_IFTYPE_ADHOC) && !wdev->use_4addr)
1003 dev->priv_flags |= IFF_DONT_BRIDGE;
1004 break;
1005 case NETDEV_GOING_DOWN:
1006 cfg80211_leave(rdev, wdev);
1007 break;
1008 case NETDEV_DOWN:
1009 cfg80211_update_iface_num(rdev, wdev->iftype, -1);
1010 if (rdev->scan_req && rdev->scan_req->wdev == wdev) {
1011 if (WARN_ON(!rdev->scan_req->notified))
1012 rdev->scan_req->aborted = true;
1013 ___cfg80211_scan_done(rdev, false);
1014 }
1015
1016 if (WARN_ON(rdev->sched_scan_req &&
1017 rdev->sched_scan_req->dev == wdev->netdev)) {
1018 __cfg80211_stop_sched_scan(rdev, false);
1019 }
1020
1021 rdev->opencount--;
1022 wake_up(&rdev->dev_wait);
1023 break;
1024 case NETDEV_UP:
1025 cfg80211_update_iface_num(rdev, wdev->iftype, 1);
1026 wdev_lock(wdev);
1027 switch (wdev->iftype) {
1028 #ifdef CONFIG_CFG80211_WEXT
1029 case NL80211_IFTYPE_ADHOC:
1030 cfg80211_ibss_wext_join(rdev, wdev);
1031 break;
1032 case NL80211_IFTYPE_STATION:
1033 cfg80211_mgd_wext_connect(rdev, wdev);
1034 break;
1035 #endif
1036 #ifdef CONFIG_MAC80211_MESH
1037 case NL80211_IFTYPE_MESH_POINT:
1038 {
1039 /* backward compat code... */
1040 struct mesh_setup setup;
1041 memcpy(&setup, &default_mesh_setup,
1042 sizeof(setup));
1043 /* back compat only needed for mesh_id */
1044 setup.mesh_id = wdev->ssid;
1045 setup.mesh_id_len = wdev->mesh_id_up_len;
1046 if (wdev->mesh_id_up_len)
1047 __cfg80211_join_mesh(rdev, dev,
1048 &setup,
1049 &default_mesh_config);
1050 break;
1051 }
1052 #endif
1053 default:
1054 break;
1055 }
1056 wdev_unlock(wdev);
1057 rdev->opencount++;
1058
1059 /*
1060 * Configure power management to the driver here so that its
1061 * correctly set also after interface type changes etc.
1062 */
1063 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
1064 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
1065 rdev->ops->set_power_mgmt)
1066 if (rdev_set_power_mgmt(rdev, dev, wdev->ps,
1067 wdev->ps_timeout)) {
1068 /* assume this means it's off */
1069 wdev->ps = false;
1070 }
1071 break;
1072 case NETDEV_UNREGISTER:
1073 /*
1074 * It is possible to get NETDEV_UNREGISTER
1075 * multiple times. To detect that, check
1076 * that the interface is still on the list
1077 * of registered interfaces, and only then
1078 * remove and clean it up.
1079 */
1080 if (!list_empty(&wdev->list)) {
1081 sysfs_remove_link(&dev->dev.kobj, "phy80211");
1082 list_del_rcu(&wdev->list);
1083 rdev->devlist_generation++;
1084 cfg80211_mlme_purge_registrations(wdev);
1085 #ifdef CONFIG_CFG80211_WEXT
1086 kzfree(wdev->wext.keys);
1087 #endif
1088 }
1089 /*
1090 * synchronise (so that we won't find this netdev
1091 * from other code any more) and then clear the list
1092 * head so that the above code can safely check for
1093 * !list_empty() to avoid double-cleanup.
1094 */
1095 synchronize_rcu();
1096 INIT_LIST_HEAD(&wdev->list);
1097 /*
1098 * Ensure that all events have been processed and
1099 * freed.
1100 */
1101 cfg80211_process_wdev_events(wdev);
1102
1103 if (WARN_ON(wdev->current_bss)) {
1104 cfg80211_unhold_bss(wdev->current_bss);
1105 cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
1106 wdev->current_bss = NULL;
1107 }
1108 break;
1109 case NETDEV_PRE_UP:
1110 if (!(wdev->wiphy->interface_modes & BIT(wdev->iftype)))
1111 return notifier_from_errno(-EOPNOTSUPP);
1112 if (rfkill_blocked(rdev->rfkill))
1113 return notifier_from_errno(-ERFKILL);
1114 break;
1115 default:
1116 return NOTIFY_DONE;
1117 }
1118
1119 return NOTIFY_OK;
1120 }
1121
1122 static struct notifier_block cfg80211_netdev_notifier = {
1123 .notifier_call = cfg80211_netdev_notifier_call,
1124 };
1125
1126 static void __net_exit cfg80211_pernet_exit(struct net *net)
1127 {
1128 struct cfg80211_registered_device *rdev;
1129
1130 rtnl_lock();
1131 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1132 if (net_eq(wiphy_net(&rdev->wiphy), net))
1133 WARN_ON(cfg80211_switch_netns(rdev, &init_net));
1134 }
1135 rtnl_unlock();
1136 }
1137
1138 static struct pernet_operations cfg80211_pernet_ops = {
1139 .exit = cfg80211_pernet_exit,
1140 };
1141
1142 static int __init cfg80211_init(void)
1143 {
1144 int err;
1145
1146 err = register_pernet_device(&cfg80211_pernet_ops);
1147 if (err)
1148 goto out_fail_pernet;
1149
1150 err = wiphy_sysfs_init();
1151 if (err)
1152 goto out_fail_sysfs;
1153
1154 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
1155 if (err)
1156 goto out_fail_notifier;
1157
1158 err = nl80211_init();
1159 if (err)
1160 goto out_fail_nl80211;
1161
1162 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
1163
1164 err = regulatory_init();
1165 if (err)
1166 goto out_fail_reg;
1167
1168 cfg80211_wq = create_singlethread_workqueue("cfg80211");
1169 if (!cfg80211_wq) {
1170 err = -ENOMEM;
1171 goto out_fail_wq;
1172 }
1173
1174 return 0;
1175
1176 out_fail_wq:
1177 regulatory_exit();
1178 out_fail_reg:
1179 debugfs_remove(ieee80211_debugfs_dir);
1180 out_fail_nl80211:
1181 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1182 out_fail_notifier:
1183 wiphy_sysfs_exit();
1184 out_fail_sysfs:
1185 unregister_pernet_device(&cfg80211_pernet_ops);
1186 out_fail_pernet:
1187 return err;
1188 }
1189 subsys_initcall(cfg80211_init);
1190
1191 static void __exit cfg80211_exit(void)
1192 {
1193 debugfs_remove(ieee80211_debugfs_dir);
1194 nl80211_exit();
1195 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
1196 wiphy_sysfs_exit();
1197 regulatory_exit();
1198 unregister_pernet_device(&cfg80211_pernet_ops);
1199 destroy_workqueue(cfg80211_wq);
1200 }
1201 module_exit(cfg80211_exit);
Linux kernel - Deliverables
This page took 0.056044 seconds and 4 git commands to generate.