]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame_incremental - net/mac80211/iface.c
projects / mirror_ubuntu-artful-kernel.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
mac80211: convert to channel definition struct
[mirror_ubuntu-artful-kernel.git] / net / mac80211 / iface.c
... / ...
CommitLineData
1/*
2 * Interface handling (except master interface)
3 *
4 * Copyright 2002-2005, Instant802 Networks, Inc.
5 * Copyright 2005-2006, Devicescape Software, Inc.
6 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
7 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13#include <linux/slab.h>
14#include <linux/kernel.h>
15#include <linux/if_arp.h>
16#include <linux/netdevice.h>
17#include <linux/rtnetlink.h>
18#include <net/mac80211.h>
19#include <net/ieee80211_radiotap.h>
20#include "ieee80211_i.h"
21#include "sta_info.h"
22#include "debugfs_netdev.h"
23#include "mesh.h"
24#include "led.h"
25#include "driver-ops.h"
26#include "wme.h"
27#include "rate.h"
28
29/**
30 * DOC: Interface list locking
31 *
32 * The interface list in each struct ieee80211_local is protected
33 * three-fold:
34 *
35 * (1) modifications may only be done under the RTNL
36 * (2) modifications and readers are protected against each other by
37 * the iflist_mtx.
38 * (3) modifications are done in an RCU manner so atomic readers
39 * can traverse the list in RCU-safe blocks.
40 *
41 * As a consequence, reads (traversals) of the list can be protected
42 * by either the RTNL, the iflist_mtx or RCU.
43 */
44
45bool __ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
46{
47 struct ieee80211_chanctx_conf *chanctx_conf;
48 int power;
49
50 rcu_read_lock();
51 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
52 if (!chanctx_conf) {
53 rcu_read_unlock();
54 return false;
55 }
56
57 power = chanctx_conf->def.chan->max_power;
58 rcu_read_unlock();
59
60 if (sdata->user_power_level != IEEE80211_UNSET_POWER_LEVEL)
61 power = min(power, sdata->user_power_level);
62
63 if (sdata->ap_power_level != IEEE80211_UNSET_POWER_LEVEL)
64 power = min(power, sdata->ap_power_level);
65
66 if (power != sdata->vif.bss_conf.txpower) {
67 sdata->vif.bss_conf.txpower = power;
68 ieee80211_hw_config(sdata->local, 0);
69 return true;
70 }
71
72 return false;
73}
74
75void ieee80211_recalc_txpower(struct ieee80211_sub_if_data *sdata)
76{
77 if (__ieee80211_recalc_txpower(sdata))
78 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
79}
80
81static u32 ieee80211_idle_off(struct ieee80211_local *local,
82 const char *reason)
83{
84 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
85 return 0;
86
87 local->hw.conf.flags &= ~IEEE80211_CONF_IDLE;
88 return IEEE80211_CONF_CHANGE_IDLE;
89}
90
91static u32 ieee80211_idle_on(struct ieee80211_local *local)
92{
93 if (local->hw.conf.flags & IEEE80211_CONF_IDLE)
94 return 0;
95
96 drv_flush(local, false);
97
98 local->hw.conf.flags |= IEEE80211_CONF_IDLE;
99 return IEEE80211_CONF_CHANGE_IDLE;
100}
101
102static u32 __ieee80211_recalc_idle(struct ieee80211_local *local)
103{
104 struct ieee80211_sub_if_data *sdata;
105 int count = 0;
106 bool working = false, scanning = false;
107 unsigned int led_trig_start = 0, led_trig_stop = 0;
108 struct ieee80211_roc_work *roc;
109
110#ifdef CONFIG_PROVE_LOCKING
111 WARN_ON(debug_locks && !lockdep_rtnl_is_held() &&
112 !lockdep_is_held(&local->iflist_mtx));
113#endif
114 lockdep_assert_held(&local->mtx);
115
116 list_for_each_entry(sdata, &local->interfaces, list) {
117 if (!ieee80211_sdata_running(sdata)) {
118 sdata->vif.bss_conf.idle = true;
119 continue;
120 }
121
122 sdata->old_idle = sdata->vif.bss_conf.idle;
123
124 /* do not count disabled managed interfaces */
125 if (sdata->vif.type == NL80211_IFTYPE_STATION &&
126 !sdata->u.mgd.associated &&
127 !sdata->u.mgd.auth_data &&
128 !sdata->u.mgd.assoc_data) {
129 sdata->vif.bss_conf.idle = true;
130 continue;
131 }
132 /* do not count unused IBSS interfaces */
133 if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
134 !sdata->u.ibss.ssid_len) {
135 sdata->vif.bss_conf.idle = true;
136 continue;
137 }
138
139 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
140 continue;
141
142 /* count everything else */
143 sdata->vif.bss_conf.idle = false;
144 count++;
145 }
146
147 if (!local->ops->remain_on_channel) {
148 list_for_each_entry(roc, &local->roc_list, list) {
149 working = true;
150 roc->sdata->vif.bss_conf.idle = false;
151 }
152 }
153
154 sdata = rcu_dereference_protected(local->scan_sdata,
155 lockdep_is_held(&local->mtx));
156 if (sdata && !(local->hw.flags & IEEE80211_HW_SCAN_WHILE_IDLE)) {
157 scanning = true;
158 sdata->vif.bss_conf.idle = false;
159 }
160
161 list_for_each_entry(sdata, &local->interfaces, list) {
162 if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
163 sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
164 sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
165 continue;
166 if (sdata->old_idle == sdata->vif.bss_conf.idle)
167 continue;
168 if (!ieee80211_sdata_running(sdata))
169 continue;
170 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_IDLE);
171 }
172
173 if (working || scanning)
174 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_WORK;
175 else
176 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_WORK;
177
178 if (count)
179 led_trig_start |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
180 else
181 led_trig_stop |= IEEE80211_TPT_LEDTRIG_FL_CONNECTED;
182
183 ieee80211_mod_tpt_led_trig(local, led_trig_start, led_trig_stop);
184
185 if (working)
186 return ieee80211_idle_off(local, "working");
187 if (scanning)
188 return ieee80211_idle_off(local, "scanning");
189 if (!count)
190 return ieee80211_idle_on(local);
191 else
192 return ieee80211_idle_off(local, "in use");
193
194 return 0;
195}
196
197void ieee80211_recalc_idle(struct ieee80211_local *local)
198{
199 u32 chg;
200
201 mutex_lock(&local->iflist_mtx);
202 chg = __ieee80211_recalc_idle(local);
203 mutex_unlock(&local->iflist_mtx);
204 if (chg)
205 ieee80211_hw_config(local, chg);
206}
207
208static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
209{
210 int meshhdrlen;
211 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
212
213 meshhdrlen = (sdata->vif.type == NL80211_IFTYPE_MESH_POINT) ? 5 : 0;
214
215 /* FIX: what would be proper limits for MTU?
216 * This interface uses 802.3 frames. */
217 if (new_mtu < 256 ||
218 new_mtu > IEEE80211_MAX_DATA_LEN - 24 - 6 - meshhdrlen) {
219 return -EINVAL;
220 }
221
222 dev->mtu = new_mtu;
223 return 0;
224}
225
226static int ieee80211_change_mac(struct net_device *dev, void *addr)
227{
228 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
229 struct sockaddr *sa = addr;
230 int ret;
231
232 if (ieee80211_sdata_running(sdata))
233 return -EBUSY;
234
235 ret = eth_mac_addr(dev, sa);
236
237 if (ret == 0)
238 memcpy(sdata->vif.addr, sa->sa_data, ETH_ALEN);
239
240 return ret;
241}
242
243static inline int identical_mac_addr_allowed(int type1, int type2)
244{
245 return type1 == NL80211_IFTYPE_MONITOR ||
246 type2 == NL80211_IFTYPE_MONITOR ||
247 type1 == NL80211_IFTYPE_P2P_DEVICE ||
248 type2 == NL80211_IFTYPE_P2P_DEVICE ||
249 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_WDS) ||
250 (type1 == NL80211_IFTYPE_WDS &&
251 (type2 == NL80211_IFTYPE_WDS ||
252 type2 == NL80211_IFTYPE_AP)) ||
253 (type1 == NL80211_IFTYPE_AP && type2 == NL80211_IFTYPE_AP_VLAN) ||
254 (type1 == NL80211_IFTYPE_AP_VLAN &&
255 (type2 == NL80211_IFTYPE_AP ||
256 type2 == NL80211_IFTYPE_AP_VLAN));
257}
258
259static int ieee80211_check_concurrent_iface(struct ieee80211_sub_if_data *sdata,
260 enum nl80211_iftype iftype)
261{
262 struct ieee80211_local *local = sdata->local;
263 struct ieee80211_sub_if_data *nsdata;
264
265 ASSERT_RTNL();
266
267 /* we hold the RTNL here so can safely walk the list */
268 list_for_each_entry(nsdata, &local->interfaces, list) {
269 if (nsdata != sdata && ieee80211_sdata_running(nsdata)) {
270 /*
271 * Allow only a single IBSS interface to be up at any
272 * time. This is restricted because beacon distribution
273 * cannot work properly if both are in the same IBSS.
274 *
275 * To remove this restriction we'd have to disallow them
276 * from setting the same SSID on different IBSS interfaces
277 * belonging to the same hardware. Then, however, we're
278 * faced with having to adopt two different TSF timers...
279 */
280 if (iftype == NL80211_IFTYPE_ADHOC &&
281 nsdata->vif.type == NL80211_IFTYPE_ADHOC)
282 return -EBUSY;
283
284 /*
285 * The remaining checks are only performed for interfaces
286 * with the same MAC address.
287 */
288 if (!ether_addr_equal(sdata->vif.addr,
289 nsdata->vif.addr))
290 continue;
291
292 /*
293 * check whether it may have the same address
294 */
295 if (!identical_mac_addr_allowed(iftype,
296 nsdata->vif.type))
297 return -ENOTUNIQ;
298
299 /*
300 * can only add VLANs to enabled APs
301 */
302 if (iftype == NL80211_IFTYPE_AP_VLAN &&
303 nsdata->vif.type == NL80211_IFTYPE_AP)
304 sdata->bss = &nsdata->u.ap;
305 }
306 }
307
308 return 0;
309}
310
311static int ieee80211_check_queues(struct ieee80211_sub_if_data *sdata)
312{
313 int n_queues = sdata->local->hw.queues;
314 int i;
315
316 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE) {
317 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
318 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] ==
319 IEEE80211_INVAL_HW_QUEUE))
320 return -EINVAL;
321 if (WARN_ON_ONCE(sdata->vif.hw_queue[i] >=
322 n_queues))
323 return -EINVAL;
324 }
325 }
326
327 if ((sdata->vif.type != NL80211_IFTYPE_AP) ||
328 !(sdata->local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)) {
329 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
330 return 0;
331 }
332
333 if (WARN_ON_ONCE(sdata->vif.cab_queue == IEEE80211_INVAL_HW_QUEUE))
334 return -EINVAL;
335
336 if (WARN_ON_ONCE(sdata->vif.cab_queue >= n_queues))
337 return -EINVAL;
338
339 return 0;
340}
341
342void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
343 const int offset)
344{
345 struct ieee80211_local *local = sdata->local;
346 u32 flags = sdata->u.mntr_flags;
347
348#define ADJUST(_f, _s) do { \
349 if (flags & MONITOR_FLAG_##_f) \
350 local->fif_##_s += offset; \
351 } while (0)
352
353 ADJUST(FCSFAIL, fcsfail);
354 ADJUST(PLCPFAIL, plcpfail);
355 ADJUST(CONTROL, control);
356 ADJUST(CONTROL, pspoll);
357 ADJUST(OTHER_BSS, other_bss);
358
359#undef ADJUST
360}
361
362static void ieee80211_set_default_queues(struct ieee80211_sub_if_data *sdata)
363{
364 struct ieee80211_local *local = sdata->local;
365 int i;
366
367 for (i = 0; i < IEEE80211_NUM_ACS; i++) {
368 if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
369 sdata->vif.hw_queue[i] = IEEE80211_INVAL_HW_QUEUE;
370 else if (local->hw.queues >= IEEE80211_NUM_ACS)
371 sdata->vif.hw_queue[i] = i;
372 else
373 sdata->vif.hw_queue[i] = 0;
374 }
375 sdata->vif.cab_queue = IEEE80211_INVAL_HW_QUEUE;
376}
377
378static int ieee80211_add_virtual_monitor(struct ieee80211_local *local)
379{
380 struct ieee80211_sub_if_data *sdata;
381 int ret = 0;
382
383 if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
384 return 0;
385
386 mutex_lock(&local->iflist_mtx);
387
388 if (local->monitor_sdata)
389 goto out_unlock;
390
391 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size, GFP_KERNEL);
392 if (!sdata) {
393 ret = -ENOMEM;
394 goto out_unlock;
395 }
396
397 /* set up data */
398 sdata->local = local;
399 sdata->vif.type = NL80211_IFTYPE_MONITOR;
400 snprintf(sdata->name, IFNAMSIZ, "%s-monitor",
401 wiphy_name(local->hw.wiphy));
402
403 ieee80211_set_default_queues(sdata);
404
405 ret = drv_add_interface(local, sdata);
406 if (WARN_ON(ret)) {
407 /* ok .. stupid driver, it asked for this! */
408 kfree(sdata);
409 goto out_unlock;
410 }
411
412 ret = ieee80211_check_queues(sdata);
413 if (ret) {
414 kfree(sdata);
415 goto out_unlock;
416 }
417
418 ret = ieee80211_vif_use_channel(sdata, &local->monitor_chandef,
419 IEEE80211_CHANCTX_EXCLUSIVE);
420 if (ret) {
421 drv_remove_interface(local, sdata);
422 kfree(sdata);
423 goto out_unlock;
424 }
425
426 rcu_assign_pointer(local->monitor_sdata, sdata);
427 out_unlock:
428 mutex_unlock(&local->iflist_mtx);
429 return ret;
430}
431
432static void ieee80211_del_virtual_monitor(struct ieee80211_local *local)
433{
434 struct ieee80211_sub_if_data *sdata;
435
436 if (!(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF))
437 return;
438
439 mutex_lock(&local->iflist_mtx);
440
441 sdata = rcu_dereference_protected(local->monitor_sdata,
442 lockdep_is_held(&local->iflist_mtx));
443 if (!sdata)
444 goto out_unlock;
445
446 rcu_assign_pointer(local->monitor_sdata, NULL);
447 synchronize_net();
448
449 ieee80211_vif_release_channel(sdata);
450
451 drv_remove_interface(local, sdata);
452
453 kfree(sdata);
454 out_unlock:
455 mutex_unlock(&local->iflist_mtx);
456}
457
458/*
459 * NOTE: Be very careful when changing this function, it must NOT return
460 * an error on interface type changes that have been pre-checked, so most
461 * checks should be in ieee80211_check_concurrent_iface.
462 */
463int ieee80211_do_open(struct wireless_dev *wdev, bool coming_up)
464{
465 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
466 struct net_device *dev = wdev->netdev;
467 struct ieee80211_local *local = sdata->local;
468 struct sta_info *sta;
469 u32 changed = 0;
470 int res;
471 u32 hw_reconf_flags = 0;
472
473 switch (sdata->vif.type) {
474 case NL80211_IFTYPE_WDS:
475 if (!is_valid_ether_addr(sdata->u.wds.remote_addr))
476 return -ENOLINK;
477 break;
478 case NL80211_IFTYPE_AP_VLAN: {
479 struct ieee80211_sub_if_data *master;
480
481 if (!sdata->bss)
482 return -ENOLINK;
483
484 list_add(&sdata->u.vlan.list, &sdata->bss->vlans);
485
486 master = container_of(sdata->bss,
487 struct ieee80211_sub_if_data, u.ap);
488 sdata->control_port_protocol =
489 master->control_port_protocol;
490 sdata->control_port_no_encrypt =
491 master->control_port_no_encrypt;
492 break;
493 }
494 case NL80211_IFTYPE_AP:
495 sdata->bss = &sdata->u.ap;
496 break;
497 case NL80211_IFTYPE_MESH_POINT:
498 case NL80211_IFTYPE_STATION:
499 case NL80211_IFTYPE_MONITOR:
500 case NL80211_IFTYPE_ADHOC:
501 case NL80211_IFTYPE_P2P_DEVICE:
502 /* no special treatment */
503 break;
504 case NL80211_IFTYPE_UNSPECIFIED:
505 case NUM_NL80211_IFTYPES:
506 case NL80211_IFTYPE_P2P_CLIENT:
507 case NL80211_IFTYPE_P2P_GO:
508 /* cannot happen */
509 WARN_ON(1);
510 break;
511 }
512
513 if (local->open_count == 0) {
514 res = drv_start(local);
515 if (res)
516 goto err_del_bss;
517 if (local->ops->napi_poll)
518 napi_enable(&local->napi);
519 /* we're brought up, everything changes */
520 hw_reconf_flags = ~0;
521 ieee80211_led_radio(local, true);
522 ieee80211_mod_tpt_led_trig(local,
523 IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
524 }
525
526 /*
527 * Copy the hopefully now-present MAC address to
528 * this interface, if it has the special null one.
529 */
530 if (dev && is_zero_ether_addr(dev->dev_addr)) {
531 memcpy(dev->dev_addr,
532 local->hw.wiphy->perm_addr,
533 ETH_ALEN);
534 memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
535
536 if (!is_valid_ether_addr(dev->dev_addr)) {
537 res = -EADDRNOTAVAIL;
538 goto err_stop;
539 }
540 }
541
542 switch (sdata->vif.type) {
543 case NL80211_IFTYPE_AP_VLAN:
544 /* no need to tell driver, but set carrier */
545 if (rtnl_dereference(sdata->bss->beacon))
546 netif_carrier_on(dev);
547 else
548 netif_carrier_off(dev);
549 break;
550 case NL80211_IFTYPE_MONITOR:
551 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
552 local->cooked_mntrs++;
553 break;
554 }
555
556 if (local->monitors == 0 && local->open_count == 0) {
557 res = ieee80211_add_virtual_monitor(local);
558 if (res)
559 goto err_stop;
560 }
561
562 /* must be before the call to ieee80211_configure_filter */
563 local->monitors++;
564 if (local->monitors == 1) {
565 local->hw.conf.flags |= IEEE80211_CONF_MONITOR;
566 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
567 }
568
569 ieee80211_adjust_monitor_flags(sdata, 1);
570 ieee80211_configure_filter(local);
571
572 netif_carrier_on(dev);
573 break;
574 default:
575 if (coming_up) {
576 ieee80211_del_virtual_monitor(local);
577
578 res = drv_add_interface(local, sdata);
579 if (res)
580 goto err_stop;
581 res = ieee80211_check_queues(sdata);
582 if (res)
583 goto err_del_interface;
584 }
585
586 if (sdata->vif.type == NL80211_IFTYPE_AP) {
587 local->fif_pspoll++;
588 local->fif_probe_req++;
589
590 ieee80211_configure_filter(local);
591 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
592 local->fif_probe_req++;
593 }
594
595 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
596 changed |= ieee80211_reset_erp_info(sdata);
597 ieee80211_bss_info_change_notify(sdata, changed);
598
599 switch (sdata->vif.type) {
600 case NL80211_IFTYPE_STATION:
601 case NL80211_IFTYPE_ADHOC:
602 case NL80211_IFTYPE_AP:
603 case NL80211_IFTYPE_MESH_POINT:
604 netif_carrier_off(dev);
605 break;
606 case NL80211_IFTYPE_WDS:
607 case NL80211_IFTYPE_P2P_DEVICE:
608 break;
609 default:
610 netif_carrier_on(dev);
611 }
612
613 /*
614 * set default queue parameters so drivers don't
615 * need to initialise the hardware if the hardware
616 * doesn't start up with sane defaults
617 */
618 ieee80211_set_wmm_default(sdata, true);
619 }
620
621 set_bit(SDATA_STATE_RUNNING, &sdata->state);
622
623 if (sdata->vif.type == NL80211_IFTYPE_WDS) {
624 /* Create STA entry for the WDS peer */
625 sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
626 GFP_KERNEL);
627 if (!sta) {
628 res = -ENOMEM;
629 goto err_del_interface;
630 }
631
632 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
633 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
634 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
635
636 res = sta_info_insert(sta);
637 if (res) {
638 /* STA has been freed */
639 goto err_del_interface;
640 }
641
642 rate_control_rate_init(sta);
643 netif_carrier_on(dev);
644 } else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
645 rcu_assign_pointer(local->p2p_sdata, sdata);
646 }
647
648 /*
649 * set_multicast_list will be invoked by the networking core
650 * which will check whether any increments here were done in
651 * error and sync them down to the hardware as filter flags.
652 */
653 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
654 atomic_inc(&local->iff_allmultis);
655
656 if (sdata->flags & IEEE80211_SDATA_PROMISC)
657 atomic_inc(&local->iff_promiscs);
658
659 mutex_lock(&local->mtx);
660 hw_reconf_flags |= __ieee80211_recalc_idle(local);
661 mutex_unlock(&local->mtx);
662
663 if (coming_up)
664 local->open_count++;
665
666 if (hw_reconf_flags)
667 ieee80211_hw_config(local, hw_reconf_flags);
668
669 ieee80211_recalc_ps(local, -1);
670
671 if (dev)
672 netif_tx_start_all_queues(dev);
673
674 return 0;
675 err_del_interface:
676 drv_remove_interface(local, sdata);
677 err_stop:
678 if (!local->open_count)
679 drv_stop(local);
680 err_del_bss:
681 sdata->bss = NULL;
682 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
683 list_del(&sdata->u.vlan.list);
684 /* might already be clear but that doesn't matter */
685 clear_bit(SDATA_STATE_RUNNING, &sdata->state);
686 return res;
687}
688
689static int ieee80211_open(struct net_device *dev)
690{
691 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
692 int err;
693
694 /* fail early if user set an invalid address */
695 if (!is_valid_ether_addr(dev->dev_addr))
696 return -EADDRNOTAVAIL;
697
698 err = ieee80211_check_concurrent_iface(sdata, sdata->vif.type);
699 if (err)
700 return err;
701
702 return ieee80211_do_open(&sdata->wdev, true);
703}
704
705static void ieee80211_do_stop(struct ieee80211_sub_if_data *sdata,
706 bool going_down)
707{
708 struct ieee80211_local *local = sdata->local;
709 unsigned long flags;
710 struct sk_buff *skb, *tmp;
711 u32 hw_reconf_flags = 0;
712 int i;
713
714 clear_bit(SDATA_STATE_RUNNING, &sdata->state);
715
716 if (rcu_access_pointer(local->scan_sdata) == sdata)
717 ieee80211_scan_cancel(local);
718
719 /*
720 * Stop TX on this interface first.
721 */
722 if (sdata->dev)
723 netif_tx_stop_all_queues(sdata->dev);
724
725 ieee80211_roc_purge(sdata);
726
727 /*
728 * Remove all stations associated with this interface.
729 *
730 * This must be done before calling ops->remove_interface()
731 * because otherwise we can later invoke ops->sta_notify()
732 * whenever the STAs are removed, and that invalidates driver
733 * assumptions about always getting a vif pointer that is valid
734 * (because if we remove a STA after ops->remove_interface()
735 * the driver will have removed the vif info already!)
736 *
737 * This is relevant only in AP, WDS and mesh modes, since in
738 * all other modes we've already removed all stations when
739 * disconnecting etc.
740 */
741 sta_info_flush(local, sdata);
742
743 /*
744 * Don't count this interface for promisc/allmulti while it
745 * is down. dev_mc_unsync() will invoke set_multicast_list
746 * on the master interface which will sync these down to the
747 * hardware as filter flags.
748 */
749 if (sdata->flags & IEEE80211_SDATA_ALLMULTI)
750 atomic_dec(&local->iff_allmultis);
751
752 if (sdata->flags & IEEE80211_SDATA_PROMISC)
753 atomic_dec(&local->iff_promiscs);
754
755 if (sdata->vif.type == NL80211_IFTYPE_AP) {
756 local->fif_pspoll--;
757 local->fif_probe_req--;
758 } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
759 local->fif_probe_req--;
760 }
761
762 if (sdata->dev) {
763 netif_addr_lock_bh(sdata->dev);
764 spin_lock_bh(&local->filter_lock);
765 __hw_addr_unsync(&local->mc_list, &sdata->dev->mc,
766 sdata->dev->addr_len);
767 spin_unlock_bh(&local->filter_lock);
768 netif_addr_unlock_bh(sdata->dev);
769
770 ieee80211_configure_filter(local);
771 }
772
773 del_timer_sync(&local->dynamic_ps_timer);
774 cancel_work_sync(&local->dynamic_ps_enable_work);
775
776 cancel_work_sync(&sdata->recalc_smps);
777
778 /* APs need special treatment */
779 if (sdata->vif.type == NL80211_IFTYPE_AP) {
780 struct ieee80211_sub_if_data *vlan, *tmpsdata;
781
782 /* down all dependent devices, that is VLANs */
783 list_for_each_entry_safe(vlan, tmpsdata, &sdata->u.ap.vlans,
784 u.vlan.list)
785 dev_close(vlan->dev);
786 WARN_ON(!list_empty(&sdata->u.ap.vlans));
787 } else if (sdata->vif.type == NL80211_IFTYPE_STATION) {
788 ieee80211_mgd_stop(sdata);
789 }
790
791 if (going_down)
792 local->open_count--;
793
794 switch (sdata->vif.type) {
795 case NL80211_IFTYPE_AP_VLAN:
796 list_del(&sdata->u.vlan.list);
797 /* no need to tell driver */
798 break;
799 case NL80211_IFTYPE_MONITOR:
800 if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) {
801 local->cooked_mntrs--;
802 break;
803 }
804
805 local->monitors--;
806 if (local->monitors == 0) {
807 local->hw.conf.flags &= ~IEEE80211_CONF_MONITOR;
808 hw_reconf_flags |= IEEE80211_CONF_CHANGE_MONITOR;
809 ieee80211_del_virtual_monitor(local);
810 }
811
812 ieee80211_adjust_monitor_flags(sdata, -1);
813 ieee80211_configure_filter(local);
814 break;
815 case NL80211_IFTYPE_P2P_DEVICE:
816 /* relies on synchronize_rcu() below */
817 rcu_assign_pointer(local->p2p_sdata, NULL);
818 /* fall through */
819 default:
820 flush_work(&sdata->work);
821 /*
822 * When we get here, the interface is marked down.
823 * Call rcu_barrier() to wait both for the RX path
824 * should it be using the interface and enqueuing
825 * frames at this very time on another CPU, and
826 * for the sta free call_rcu callbacks.
827 */
828 rcu_barrier();
829
830 /*
831 * free_sta_rcu() enqueues a work for the actual
832 * sta cleanup, so we need to flush it while
833 * sdata is still valid.
834 */
835 flush_workqueue(local->workqueue);
836
837 skb_queue_purge(&sdata->skb_queue);
838
839 /*
840 * Free all remaining keys, there shouldn't be any,
841 * except maybe group keys in AP more or WDS?
842 */
843 ieee80211_free_keys(sdata);
844
845 if (going_down)
846 drv_remove_interface(local, sdata);
847 }
848
849 sdata->bss = NULL;
850
851 mutex_lock(&local->mtx);
852 hw_reconf_flags |= __ieee80211_recalc_idle(local);
853 mutex_unlock(&local->mtx);
854
855 ieee80211_recalc_ps(local, -1);
856
857 if (local->open_count == 0) {
858 if (local->ops->napi_poll)
859 napi_disable(&local->napi);
860 ieee80211_clear_tx_pending(local);
861 ieee80211_stop_device(local);
862
863 /* no reconfiguring after stop! */
864 hw_reconf_flags = 0;
865 }
866
867 /* do after stop to avoid reconfiguring when we stop anyway */
868 if (hw_reconf_flags)
869 ieee80211_hw_config(local, hw_reconf_flags);
870
871 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
872 for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
873 skb_queue_walk_safe(&local->pending[i], skb, tmp) {
874 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
875 if (info->control.vif == &sdata->vif) {
876 __skb_unlink(skb, &local->pending[i]);
877 ieee80211_free_txskb(&local->hw, skb);
878 }
879 }
880 }
881 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
882
883 if (local->monitors == local->open_count && local->monitors > 0)
884 ieee80211_add_virtual_monitor(local);
885}
886
887static int ieee80211_stop(struct net_device *dev)
888{
889 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
890
891 ieee80211_do_stop(sdata, true);
892
893 return 0;
894}
895
896static void ieee80211_set_multicast_list(struct net_device *dev)
897{
898 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
899 struct ieee80211_local *local = sdata->local;
900 int allmulti, promisc, sdata_allmulti, sdata_promisc;
901
902 allmulti = !!(dev->flags & IFF_ALLMULTI);
903 promisc = !!(dev->flags & IFF_PROMISC);
904 sdata_allmulti = !!(sdata->flags & IEEE80211_SDATA_ALLMULTI);
905 sdata_promisc = !!(sdata->flags & IEEE80211_SDATA_PROMISC);
906
907 if (allmulti != sdata_allmulti) {
908 if (dev->flags & IFF_ALLMULTI)
909 atomic_inc(&local->iff_allmultis);
910 else
911 atomic_dec(&local->iff_allmultis);
912 sdata->flags ^= IEEE80211_SDATA_ALLMULTI;
913 }
914
915 if (promisc != sdata_promisc) {
916 if (dev->flags & IFF_PROMISC)
917 atomic_inc(&local->iff_promiscs);
918 else
919 atomic_dec(&local->iff_promiscs);
920 sdata->flags ^= IEEE80211_SDATA_PROMISC;
921 }
922 spin_lock_bh(&local->filter_lock);
923 __hw_addr_sync(&local->mc_list, &dev->mc, dev->addr_len);
924 spin_unlock_bh(&local->filter_lock);
925 ieee80211_queue_work(&local->hw, &local->reconfig_filter);
926}
927
928/*
929 * Called when the netdev is removed or, by the code below, before
930 * the interface type changes.
931 */
932static void ieee80211_teardown_sdata(struct ieee80211_sub_if_data *sdata)
933{
934 struct ieee80211_local *local = sdata->local;
935 int flushed;
936 int i;
937
938 /* free extra data */
939 ieee80211_free_keys(sdata);
940
941 ieee80211_debugfs_remove_netdev(sdata);
942
943 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
944 __skb_queue_purge(&sdata->fragments[i].skb_list);
945 sdata->fragment_next = 0;
946
947 if (ieee80211_vif_is_mesh(&sdata->vif))
948 mesh_rmc_free(sdata);
949
950 flushed = sta_info_flush(local, sdata);
951 WARN_ON(flushed);
952}
953
954static void ieee80211_uninit(struct net_device *dev)
955{
956 ieee80211_teardown_sdata(IEEE80211_DEV_TO_SUB_IF(dev));
957}
958
959static u16 ieee80211_netdev_select_queue(struct net_device *dev,
960 struct sk_buff *skb)
961{
962 return ieee80211_select_queue(IEEE80211_DEV_TO_SUB_IF(dev), skb);
963}
964
965static const struct net_device_ops ieee80211_dataif_ops = {
966 .ndo_open = ieee80211_open,
967 .ndo_stop = ieee80211_stop,
968 .ndo_uninit = ieee80211_uninit,
969 .ndo_start_xmit = ieee80211_subif_start_xmit,
970 .ndo_set_rx_mode = ieee80211_set_multicast_list,
971 .ndo_change_mtu = ieee80211_change_mtu,
972 .ndo_set_mac_address = ieee80211_change_mac,
973 .ndo_select_queue = ieee80211_netdev_select_queue,
974};
975
976static u16 ieee80211_monitor_select_queue(struct net_device *dev,
977 struct sk_buff *skb)
978{
979 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
980 struct ieee80211_local *local = sdata->local;
981 struct ieee80211_hdr *hdr;
982 struct ieee80211_radiotap_header *rtap = (void *)skb->data;
983
984 if (local->hw.queues < IEEE80211_NUM_ACS)
985 return 0;
986
987 if (skb->len < 4 ||
988 skb->len < le16_to_cpu(rtap->it_len) + 2 /* frame control */)
989 return 0; /* doesn't matter, frame will be dropped */
990
991 hdr = (void *)((u8 *)skb->data + le16_to_cpu(rtap->it_len));
992
993 return ieee80211_select_queue_80211(sdata, skb, hdr);
994}
995
996static const struct net_device_ops ieee80211_monitorif_ops = {
997 .ndo_open = ieee80211_open,
998 .ndo_stop = ieee80211_stop,
999 .ndo_uninit = ieee80211_uninit,
1000 .ndo_start_xmit = ieee80211_monitor_start_xmit,
1001 .ndo_set_rx_mode = ieee80211_set_multicast_list,
1002 .ndo_change_mtu = ieee80211_change_mtu,
1003 .ndo_set_mac_address = eth_mac_addr,
1004 .ndo_select_queue = ieee80211_monitor_select_queue,
1005};
1006
1007static void ieee80211_if_setup(struct net_device *dev)
1008{
1009 ether_setup(dev);
1010 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1011 dev->netdev_ops = &ieee80211_dataif_ops;
1012 dev->destructor = free_netdev;
1013}
1014
1015static void ieee80211_iface_work(struct work_struct *work)
1016{
1017 struct ieee80211_sub_if_data *sdata =
1018 container_of(work, struct ieee80211_sub_if_data, work);
1019 struct ieee80211_local *local = sdata->local;
1020 struct sk_buff *skb;
1021 struct sta_info *sta;
1022 struct ieee80211_ra_tid *ra_tid;
1023
1024 if (!ieee80211_sdata_running(sdata))
1025 return;
1026
1027 if (local->scanning)
1028 return;
1029
1030 /*
1031 * ieee80211_queue_work() should have picked up most cases,
1032 * here we'll pick the rest.
1033 */
1034 if (WARN(local->suspended,
1035 "interface work scheduled while going to suspend\n"))
1036 return;
1037
1038 /* first process frames */
1039 while ((skb = skb_dequeue(&sdata->skb_queue))) {
1040 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1041
1042 if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_START) {
1043 ra_tid = (void *)&skb->cb;
1044 ieee80211_start_tx_ba_cb(&sdata->vif, ra_tid->ra,
1045 ra_tid->tid);
1046 } else if (skb->pkt_type == IEEE80211_SDATA_QUEUE_AGG_STOP) {
1047 ra_tid = (void *)&skb->cb;
1048 ieee80211_stop_tx_ba_cb(&sdata->vif, ra_tid->ra,
1049 ra_tid->tid);
1050 } else if (ieee80211_is_action(mgmt->frame_control) &&
1051 mgmt->u.action.category == WLAN_CATEGORY_BACK) {
1052 int len = skb->len;
1053
1054 mutex_lock(&local->sta_mtx);
1055 sta = sta_info_get_bss(sdata, mgmt->sa);
1056 if (sta) {
1057 switch (mgmt->u.action.u.addba_req.action_code) {
1058 case WLAN_ACTION_ADDBA_REQ:
1059 ieee80211_process_addba_request(
1060 local, sta, mgmt, len);
1061 break;
1062 case WLAN_ACTION_ADDBA_RESP:
1063 ieee80211_process_addba_resp(local, sta,
1064 mgmt, len);
1065 break;
1066 case WLAN_ACTION_DELBA:
1067 ieee80211_process_delba(sdata, sta,
1068 mgmt, len);
1069 break;
1070 default:
1071 WARN_ON(1);
1072 break;
1073 }
1074 }
1075 mutex_unlock(&local->sta_mtx);
1076 } else if (ieee80211_is_data_qos(mgmt->frame_control)) {
1077 struct ieee80211_hdr *hdr = (void *)mgmt;
1078 /*
1079 * So the frame isn't mgmt, but frame_control
1080 * is at the right place anyway, of course, so
1081 * the if statement is correct.
1082 *
1083 * Warn if we have other data frame types here,
1084 * they must not get here.
1085 */
1086 WARN_ON(hdr->frame_control &
1087 cpu_to_le16(IEEE80211_STYPE_NULLFUNC));
1088 WARN_ON(!(hdr->seq_ctrl &
1089 cpu_to_le16(IEEE80211_SCTL_FRAG)));
1090 /*
1091 * This was a fragment of a frame, received while
1092 * a block-ack session was active. That cannot be
1093 * right, so terminate the session.
1094 */
1095 mutex_lock(&local->sta_mtx);
1096 sta = sta_info_get_bss(sdata, mgmt->sa);
1097 if (sta) {
1098 u16 tid = *ieee80211_get_qos_ctl(hdr) &
1099 IEEE80211_QOS_CTL_TID_MASK;
1100
1101 __ieee80211_stop_rx_ba_session(
1102 sta, tid, WLAN_BACK_RECIPIENT,
1103 WLAN_REASON_QSTA_REQUIRE_SETUP,
1104 true);
1105 }
1106 mutex_unlock(&local->sta_mtx);
1107 } else switch (sdata->vif.type) {
1108 case NL80211_IFTYPE_STATION:
1109 ieee80211_sta_rx_queued_mgmt(sdata, skb);
1110 break;
1111 case NL80211_IFTYPE_ADHOC:
1112 ieee80211_ibss_rx_queued_mgmt(sdata, skb);
1113 break;
1114 case NL80211_IFTYPE_MESH_POINT:
1115 if (!ieee80211_vif_is_mesh(&sdata->vif))
1116 break;
1117 ieee80211_mesh_rx_queued_mgmt(sdata, skb);
1118 break;
1119 default:
1120 WARN(1, "frame for unexpected interface type");
1121 break;
1122 }
1123
1124 kfree_skb(skb);
1125 }
1126
1127 /* then other type-dependent work */
1128 switch (sdata->vif.type) {
1129 case NL80211_IFTYPE_STATION:
1130 ieee80211_sta_work(sdata);
1131 break;
1132 case NL80211_IFTYPE_ADHOC:
1133 ieee80211_ibss_work(sdata);
1134 break;
1135 case NL80211_IFTYPE_MESH_POINT:
1136 if (!ieee80211_vif_is_mesh(&sdata->vif))
1137 break;
1138 ieee80211_mesh_work(sdata);
1139 break;
1140 default:
1141 break;
1142 }
1143}
1144
1145static void ieee80211_recalc_smps_work(struct work_struct *work)
1146{
1147 struct ieee80211_sub_if_data *sdata =
1148 container_of(work, struct ieee80211_sub_if_data, recalc_smps);
1149
1150 ieee80211_recalc_smps(sdata);
1151}
1152
1153/*
1154 * Helper function to initialise an interface to a specific type.
1155 */
1156static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
1157 enum nl80211_iftype type)
1158{
1159 /* clear type-dependent union */
1160 memset(&sdata->u, 0, sizeof(sdata->u));
1161
1162 /* and set some type-dependent values */
1163 sdata->vif.type = type;
1164 sdata->vif.p2p = false;
1165 sdata->wdev.iftype = type;
1166
1167 sdata->control_port_protocol = cpu_to_be16(ETH_P_PAE);
1168 sdata->control_port_no_encrypt = false;
1169
1170 sdata->noack_map = 0;
1171
1172 /* only monitor/p2p-device differ */
1173 if (sdata->dev) {
1174 sdata->dev->netdev_ops = &ieee80211_dataif_ops;
1175 sdata->dev->type = ARPHRD_ETHER;
1176 }
1177
1178 skb_queue_head_init(&sdata->skb_queue);
1179 INIT_WORK(&sdata->work, ieee80211_iface_work);
1180 INIT_WORK(&sdata->recalc_smps, ieee80211_recalc_smps_work);
1181
1182 switch (type) {
1183 case NL80211_IFTYPE_P2P_GO:
1184 type = NL80211_IFTYPE_AP;
1185 sdata->vif.type = type;
1186 sdata->vif.p2p = true;
1187 /* fall through */
1188 case NL80211_IFTYPE_AP:
1189 skb_queue_head_init(&sdata->u.ap.ps.bc_buf);
1190 INIT_LIST_HEAD(&sdata->u.ap.vlans);
1191 break;
1192 case NL80211_IFTYPE_P2P_CLIENT:
1193 type = NL80211_IFTYPE_STATION;
1194 sdata->vif.type = type;
1195 sdata->vif.p2p = true;
1196 /* fall through */
1197 case NL80211_IFTYPE_STATION:
1198 ieee80211_sta_setup_sdata(sdata);
1199 break;
1200 case NL80211_IFTYPE_ADHOC:
1201 ieee80211_ibss_setup_sdata(sdata);
1202 break;
1203 case NL80211_IFTYPE_MESH_POINT:
1204 if (ieee80211_vif_is_mesh(&sdata->vif))
1205 ieee80211_mesh_init_sdata(sdata);
1206 break;
1207 case NL80211_IFTYPE_MONITOR:
1208 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
1209 sdata->dev->netdev_ops = &ieee80211_monitorif_ops;
1210 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
1211 MONITOR_FLAG_OTHER_BSS;
1212 break;
1213 case NL80211_IFTYPE_WDS:
1214 case NL80211_IFTYPE_AP_VLAN:
1215 case NL80211_IFTYPE_P2P_DEVICE:
1216 break;
1217 case NL80211_IFTYPE_UNSPECIFIED:
1218 case NUM_NL80211_IFTYPES:
1219 BUG();
1220 break;
1221 }
1222
1223 ieee80211_debugfs_add_netdev(sdata);
1224}
1225
1226static int ieee80211_runtime_change_iftype(struct ieee80211_sub_if_data *sdata,
1227 enum nl80211_iftype type)
1228{
1229 struct ieee80211_local *local = sdata->local;
1230 int ret, err;
1231 enum nl80211_iftype internal_type = type;
1232 bool p2p = false;
1233
1234 ASSERT_RTNL();
1235
1236 if (!local->ops->change_interface)
1237 return -EBUSY;
1238
1239 switch (sdata->vif.type) {
1240 case NL80211_IFTYPE_AP:
1241 case NL80211_IFTYPE_STATION:
1242 case NL80211_IFTYPE_ADHOC:
1243 /*
1244 * Could maybe also all others here?
1245 * Just not sure how that interacts
1246 * with the RX/config path e.g. for
1247 * mesh.
1248 */
1249 break;
1250 default:
1251 return -EBUSY;
1252 }
1253
1254 switch (type) {
1255 case NL80211_IFTYPE_AP:
1256 case NL80211_IFTYPE_STATION:
1257 case NL80211_IFTYPE_ADHOC:
1258 /*
1259 * Could probably support everything
1260 * but WDS here (WDS do_open can fail
1261 * under memory pressure, which this
1262 * code isn't prepared to handle).
1263 */
1264 break;
1265 case NL80211_IFTYPE_P2P_CLIENT:
1266 p2p = true;
1267 internal_type = NL80211_IFTYPE_STATION;
1268 break;
1269 case NL80211_IFTYPE_P2P_GO:
1270 p2p = true;
1271 internal_type = NL80211_IFTYPE_AP;
1272 break;
1273 default:
1274 return -EBUSY;
1275 }
1276
1277 ret = ieee80211_check_concurrent_iface(sdata, internal_type);
1278 if (ret)
1279 return ret;
1280
1281 ieee80211_do_stop(sdata, false);
1282
1283 ieee80211_teardown_sdata(sdata);
1284
1285 ret = drv_change_interface(local, sdata, internal_type, p2p);
1286 if (ret)
1287 type = sdata->vif.type;
1288
1289 /*
1290 * Ignore return value here, there's not much we can do since
1291 * the driver changed the interface type internally already.
1292 * The warnings will hopefully make driver authors fix it :-)
1293 */
1294 ieee80211_check_queues(sdata);
1295
1296 ieee80211_setup_sdata(sdata, type);
1297
1298 err = ieee80211_do_open(&sdata->wdev, false);
1299 WARN(err, "type change: do_open returned %d", err);
1300
1301 return ret;
1302}
1303
1304int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
1305 enum nl80211_iftype type)
1306{
1307 int ret;
1308
1309 ASSERT_RTNL();
1310
1311 if (type == ieee80211_vif_type_p2p(&sdata->vif))
1312 return 0;
1313
1314 if (ieee80211_sdata_running(sdata)) {
1315 ret = ieee80211_runtime_change_iftype(sdata, type);
1316 if (ret)
1317 return ret;
1318 } else {
1319 /* Purge and reset type-dependent state. */
1320 ieee80211_teardown_sdata(sdata);
1321 ieee80211_setup_sdata(sdata, type);
1322 }
1323
1324 /* reset some values that shouldn't be kept across type changes */
1325 sdata->drop_unencrypted = 0;
1326 if (type == NL80211_IFTYPE_STATION)
1327 sdata->u.mgd.use_4addr = false;
1328
1329 return 0;
1330}
1331
1332static void ieee80211_assign_perm_addr(struct ieee80211_local *local,
1333 u8 *perm_addr, enum nl80211_iftype type)
1334{
1335 struct ieee80211_sub_if_data *sdata;
1336 u64 mask, start, addr, val, inc;
1337 u8 *m;
1338 u8 tmp_addr[ETH_ALEN];
1339 int i;
1340
1341 /* default ... something at least */
1342 memcpy(perm_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
1343
1344 if (is_zero_ether_addr(local->hw.wiphy->addr_mask) &&
1345 local->hw.wiphy->n_addresses <= 1)
1346 return;
1347
1348 mutex_lock(&local->iflist_mtx);
1349
1350 switch (type) {
1351 case NL80211_IFTYPE_MONITOR:
1352 /* doesn't matter */
1353 break;
1354 case NL80211_IFTYPE_WDS:
1355 case NL80211_IFTYPE_AP_VLAN:
1356 /* match up with an AP interface */
1357 list_for_each_entry(sdata, &local->interfaces, list) {
1358 if (sdata->vif.type != NL80211_IFTYPE_AP)
1359 continue;
1360 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1361 break;
1362 }
1363 /* keep default if no AP interface present */
1364 break;
1365 case NL80211_IFTYPE_P2P_CLIENT:
1366 case NL80211_IFTYPE_P2P_GO:
1367 if (local->hw.flags & IEEE80211_HW_P2P_DEV_ADDR_FOR_INTF) {
1368 list_for_each_entry(sdata, &local->interfaces, list) {
1369 if (sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE)
1370 continue;
1371 if (!ieee80211_sdata_running(sdata))
1372 continue;
1373 memcpy(perm_addr, sdata->vif.addr, ETH_ALEN);
1374 goto out_unlock;
1375 }
1376 }
1377 /* otherwise fall through */
1378 default:
1379 /* assign a new address if possible -- try n_addresses first */
1380 for (i = 0; i < local->hw.wiphy->n_addresses; i++) {
1381 bool used = false;
1382
1383 list_for_each_entry(sdata, &local->interfaces, list) {
1384 if (memcmp(local->hw.wiphy->addresses[i].addr,
1385 sdata->vif.addr, ETH_ALEN) == 0) {
1386 used = true;
1387 break;
1388 }
1389 }
1390
1391 if (!used) {
1392 memcpy(perm_addr,
1393 local->hw.wiphy->addresses[i].addr,
1394 ETH_ALEN);
1395 break;
1396 }
1397 }
1398
1399 /* try mask if available */
1400 if (is_zero_ether_addr(local->hw.wiphy->addr_mask))
1401 break;
1402
1403 m = local->hw.wiphy->addr_mask;
1404 mask = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1405 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1406 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1407
1408 if (__ffs64(mask) + hweight64(mask) != fls64(mask)) {
1409 /* not a contiguous mask ... not handled now! */
1410 pr_info("not contiguous\n");
1411 break;
1412 }
1413
1414 m = local->hw.wiphy->perm_addr;
1415 start = ((u64)m[0] << 5*8) | ((u64)m[1] << 4*8) |
1416 ((u64)m[2] << 3*8) | ((u64)m[3] << 2*8) |
1417 ((u64)m[4] << 1*8) | ((u64)m[5] << 0*8);
1418
1419 inc = 1ULL<<__ffs64(mask);
1420 val = (start & mask);
1421 addr = (start & ~mask) | (val & mask);
1422 do {
1423 bool used = false;
1424
1425 tmp_addr[5] = addr >> 0*8;
1426 tmp_addr[4] = addr >> 1*8;
1427 tmp_addr[3] = addr >> 2*8;
1428 tmp_addr[2] = addr >> 3*8;
1429 tmp_addr[1] = addr >> 4*8;
1430 tmp_addr[0] = addr >> 5*8;
1431
1432 val += inc;
1433
1434 list_for_each_entry(sdata, &local->interfaces, list) {
1435 if (memcmp(tmp_addr, sdata->vif.addr,
1436 ETH_ALEN) == 0) {
1437 used = true;
1438 break;
1439 }
1440 }
1441
1442 if (!used) {
1443 memcpy(perm_addr, tmp_addr, ETH_ALEN);
1444 break;
1445 }
1446 addr = (start & ~mask) | (val & mask);
1447 } while (addr != start);
1448
1449 break;
1450 }
1451
1452 out_unlock:
1453 mutex_unlock(&local->iflist_mtx);
1454}
1455
1456int ieee80211_if_add(struct ieee80211_local *local, const char *name,
1457 struct wireless_dev **new_wdev, enum nl80211_iftype type,
1458 struct vif_params *params)
1459{
1460 struct net_device *ndev = NULL;
1461 struct ieee80211_sub_if_data *sdata = NULL;
1462 int ret, i;
1463 int txqs = 1;
1464
1465 ASSERT_RTNL();
1466
1467 if (type == NL80211_IFTYPE_P2P_DEVICE) {
1468 struct wireless_dev *wdev;
1469
1470 sdata = kzalloc(sizeof(*sdata) + local->hw.vif_data_size,
1471 GFP_KERNEL);
1472 if (!sdata)
1473 return -ENOMEM;
1474 wdev = &sdata->wdev;
1475
1476 sdata->dev = NULL;
1477 strlcpy(sdata->name, name, IFNAMSIZ);
1478 ieee80211_assign_perm_addr(local, wdev->address, type);
1479 memcpy(sdata->vif.addr, wdev->address, ETH_ALEN);
1480 } else {
1481 if (local->hw.queues >= IEEE80211_NUM_ACS)
1482 txqs = IEEE80211_NUM_ACS;
1483
1484 ndev = alloc_netdev_mqs(sizeof(*sdata) +
1485 local->hw.vif_data_size,
1486 name, ieee80211_if_setup, txqs, 1);
1487 if (!ndev)
1488 return -ENOMEM;
1489 dev_net_set(ndev, wiphy_net(local->hw.wiphy));
1490
1491 ndev->needed_headroom = local->tx_headroom +
1492 4*6 /* four MAC addresses */
1493 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
1494 + 6 /* mesh */
1495 + 8 /* rfc1042/bridge tunnel */
1496 - ETH_HLEN /* ethernet hard_header_len */
1497 + IEEE80211_ENCRYPT_HEADROOM;
1498 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
1499
1500 ret = dev_alloc_name(ndev, ndev->name);
1501 if (ret < 0) {
1502 free_netdev(ndev);
1503 return ret;
1504 }
1505
1506 ieee80211_assign_perm_addr(local, ndev->perm_addr, type);
1507 memcpy(ndev->dev_addr, ndev->perm_addr, ETH_ALEN);
1508 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
1509
1510 /* don't use IEEE80211_DEV_TO_SUB_IF -- it checks too much */
1511 sdata = netdev_priv(ndev);
1512 ndev->ieee80211_ptr = &sdata->wdev;
1513 memcpy(sdata->vif.addr, ndev->dev_addr, ETH_ALEN);
1514 memcpy(sdata->name, ndev->name, IFNAMSIZ);
1515
1516 sdata->dev = ndev;
1517 }
1518
1519 /* initialise type-independent data */
1520 sdata->wdev.wiphy = local->hw.wiphy;
1521 sdata->local = local;
1522#ifdef CONFIG_INET
1523 sdata->arp_filter_state = true;
1524#endif
1525
1526 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
1527 skb_queue_head_init(&sdata->fragments[i].skb_list);
1528
1529 INIT_LIST_HEAD(&sdata->key_list);
1530
1531 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
1532 struct ieee80211_supported_band *sband;
1533 sband = local->hw.wiphy->bands[i];
1534 sdata->rc_rateidx_mask[i] =
1535 sband ? (1 << sband->n_bitrates) - 1 : 0;
1536 if (sband)
1537 memcpy(sdata->rc_rateidx_mcs_mask[i],
1538 sband->ht_cap.mcs.rx_mask,
1539 sizeof(sdata->rc_rateidx_mcs_mask[i]));
1540 else
1541 memset(sdata->rc_rateidx_mcs_mask[i], 0,
1542 sizeof(sdata->rc_rateidx_mcs_mask[i]));
1543 }
1544
1545 ieee80211_set_default_queues(sdata);
1546
1547 sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
1548 sdata->user_power_level = local->user_power_level;
1549
1550 /* setup type-dependent data */
1551 ieee80211_setup_sdata(sdata, type);
1552
1553 if (ndev) {
1554 if (params) {
1555 ndev->ieee80211_ptr->use_4addr = params->use_4addr;
1556 if (type == NL80211_IFTYPE_STATION)
1557 sdata->u.mgd.use_4addr = params->use_4addr;
1558 }
1559
1560 ndev->features |= local->hw.netdev_features;
1561
1562 ret = register_netdevice(ndev);
1563 if (ret) {
1564 free_netdev(ndev);
1565 return ret;
1566 }
1567 }
1568
1569 mutex_lock(&local->iflist_mtx);
1570 list_add_tail_rcu(&sdata->list, &local->interfaces);
1571 mutex_unlock(&local->iflist_mtx);
1572
1573 if (new_wdev)
1574 *new_wdev = &sdata->wdev;
1575
1576 return 0;
1577}
1578
1579void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
1580{
1581 ASSERT_RTNL();
1582
1583 mutex_lock(&sdata->local->iflist_mtx);
1584 list_del_rcu(&sdata->list);
1585 mutex_unlock(&sdata->local->iflist_mtx);
1586
1587 synchronize_rcu();
1588
1589 if (sdata->dev) {
1590 unregister_netdevice(sdata->dev);
1591 } else {
1592 cfg80211_unregister_wdev(&sdata->wdev);
1593 kfree(sdata);
1594 }
1595}
1596
1597void ieee80211_sdata_stop(struct ieee80211_sub_if_data *sdata)
1598{
1599 if (WARN_ON_ONCE(!test_bit(SDATA_STATE_RUNNING, &sdata->state)))
1600 return;
1601 ieee80211_do_stop(sdata, true);
1602 ieee80211_teardown_sdata(sdata);
1603}
1604
1605/*
1606 * Remove all interfaces, may only be called at hardware unregistration
1607 * time because it doesn't do RCU-safe list removals.
1608 */
1609void ieee80211_remove_interfaces(struct ieee80211_local *local)
1610{
1611 struct ieee80211_sub_if_data *sdata, *tmp;
1612 LIST_HEAD(unreg_list);
1613 LIST_HEAD(wdev_list);
1614
1615 ASSERT_RTNL();
1616
1617 mutex_lock(&local->iflist_mtx);
1618 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
1619 list_del(&sdata->list);
1620
1621 if (sdata->dev)
1622 unregister_netdevice_queue(sdata->dev, &unreg_list);
1623 else
1624 list_add(&sdata->list, &wdev_list);
1625 }
1626 mutex_unlock(&local->iflist_mtx);
1627 unregister_netdevice_many(&unreg_list);
1628 list_del(&unreg_list);
1629
1630 list_for_each_entry_safe(sdata, tmp, &wdev_list, list) {
1631 list_del(&sdata->list);
1632 cfg80211_unregister_wdev(&sdata->wdev);
1633 kfree(sdata);
1634 }
1635}
1636
1637static int netdev_notify(struct notifier_block *nb,
1638 unsigned long state,
1639 void *ndev)
1640{
1641 struct net_device *dev = ndev;
1642 struct ieee80211_sub_if_data *sdata;
1643
1644 if (state != NETDEV_CHANGENAME)
1645 return 0;
1646
1647 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
1648 return 0;
1649
1650 if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
1651 return 0;
1652
1653 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1654
1655 memcpy(sdata->name, dev->name, IFNAMSIZ);
1656
1657 ieee80211_debugfs_rename_netdev(sdata);
1658 return 0;
1659}
1660
1661static struct notifier_block mac80211_netdev_notifier = {
1662 .notifier_call = netdev_notify,
1663};
1664
1665int ieee80211_iface_init(void)
1666{
1667 return register_netdevice_notifier(&mac80211_netdev_notifier);
1668}
1669
1670void ieee80211_iface_exit(void)
1671{
1672 unregister_netdevice_notifier(&mac80211_netdev_notifier);
1673}
Ubuntu Artful kernel mirror