Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/net/mac80211/iface.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us