aboutsummaryrefslogtreecommitdiffstats
path: root/net/mac80211/iface.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/mac80211/iface.c')
-rw-r--r--net/mac80211/iface.c392
1 files changed, 169 insertions, 223 deletions
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index eeb16926aa7d..610ed1d9893a 100644
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
@@ -2,6 +2,7 @@
2 * Copyright 2002-2005, Instant802 Networks, Inc. 2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz> 4 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
5 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
5 * 6 *
6 * This program is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as 8 * it under the terms of the GNU General Public License version 2 as
@@ -17,145 +18,91 @@
17#include "debugfs_netdev.h" 18#include "debugfs_netdev.h"
18#include "mesh.h" 19#include "mesh.h"
19 20
20void ieee80211_if_sdata_init(struct ieee80211_sub_if_data *sdata) 21/*
22 * Called when the netdev is removed or, by the code below, before
23 * the interface type changes.
24 */
25static void ieee80211_teardown_sdata(struct net_device *dev)
21{ 26{
27 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
28 struct ieee80211_local *local = sdata->local;
29 struct beacon_data *beacon;
30 struct sk_buff *skb;
31 int flushed;
22 int i; 32 int i;
23 33
24 /* Default values for sub-interface parameters */ 34 ieee80211_debugfs_remove_netdev(sdata);
25 sdata->drop_unencrypted = 0;
26 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
27 skb_queue_head_init(&sdata->fragments[i].skb_list);
28
29 INIT_LIST_HEAD(&sdata->key_list);
30}
31 35
32static void ieee80211_if_sdata_deinit(struct ieee80211_sub_if_data *sdata) 36 /* free extra data */
33{ 37 ieee80211_free_keys(sdata);
34 int i;
35 38
36 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) 39 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
37 __skb_queue_purge(&sdata->fragments[i].skb_list); 40 __skb_queue_purge(&sdata->fragments[i].skb_list);
38} 41 sdata->fragment_next = 0;
39
40/* Must be called with rtnl lock held. */
41int ieee80211_if_add(struct net_device *dev, const char *name,
42 struct net_device **new_dev, int type,
43 struct vif_params *params)
44{
45 struct net_device *ndev;
46 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
47 struct ieee80211_sub_if_data *sdata = NULL;
48 int ret;
49
50 ASSERT_RTNL();
51 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size,
52 name, ieee80211_if_setup);
53 if (!ndev)
54 return -ENOMEM;
55 42
56 ndev->needed_headroom = local->tx_headroom + 43 switch (sdata->vif.type) {
57 4*6 /* four MAC addresses */ 44 case IEEE80211_IF_TYPE_AP:
58 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */ 45 beacon = sdata->u.ap.beacon;
59 + 6 /* mesh */ 46 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
60 + 8 /* rfc1042/bridge tunnel */ 47 synchronize_rcu();
61 - ETH_HLEN /* ethernet hard_header_len */ 48 kfree(beacon);
62 + IEEE80211_ENCRYPT_HEADROOM;
63 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
64
65 ret = dev_alloc_name(ndev, ndev->name);
66 if (ret < 0)
67 goto fail;
68
69 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
70 ndev->base_addr = dev->base_addr;
71 ndev->irq = dev->irq;
72 ndev->mem_start = dev->mem_start;
73 ndev->mem_end = dev->mem_end;
74 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
75
76 sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
77 ndev->ieee80211_ptr = &sdata->wdev;
78 sdata->wdev.wiphy = local->hw.wiphy;
79 sdata->vif.type = IEEE80211_IF_TYPE_AP;
80 sdata->dev = ndev;
81 sdata->local = local;
82 ieee80211_if_sdata_init(sdata);
83
84 ret = register_netdevice(ndev);
85 if (ret)
86 goto fail;
87
88 ieee80211_debugfs_add_netdev(sdata);
89 ieee80211_if_set_type(ndev, type);
90 49
91 if (ieee80211_vif_is_mesh(&sdata->vif) && 50 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
92 params && params->mesh_id_len) 51 local->total_ps_buffered--;
93 ieee80211_if_sta_set_mesh_id(&sdata->u.sta, 52 dev_kfree_skb(skb);
94 params->mesh_id_len, 53 }
95 params->mesh_id);
96 54
97 /* we're under RTNL so all this is fine */ 55 break;
98 if (unlikely(local->reg_state == IEEE80211_DEV_UNREGISTERED)) { 56 case IEEE80211_IF_TYPE_MESH_POINT:
99 __ieee80211_if_del(local, sdata); 57 /* Allow compiler to elide mesh_rmc_free call. */
100 return -ENODEV; 58 if (ieee80211_vif_is_mesh(&sdata->vif))
59 mesh_rmc_free(dev);
60 /* fall through */
61 case IEEE80211_IF_TYPE_STA:
62 case IEEE80211_IF_TYPE_IBSS:
63 kfree(sdata->u.sta.extra_ie);
64 kfree(sdata->u.sta.assocreq_ies);
65 kfree(sdata->u.sta.assocresp_ies);
66 kfree_skb(sdata->u.sta.probe_resp);
67 break;
68 case IEEE80211_IF_TYPE_WDS:
69 case IEEE80211_IF_TYPE_VLAN:
70 case IEEE80211_IF_TYPE_MNTR:
71 break;
72 case IEEE80211_IF_TYPE_INVALID:
73 BUG();
74 break;
101 } 75 }
102 list_add_tail_rcu(&sdata->list, &local->interfaces);
103 76
104 if (new_dev) 77 flushed = sta_info_flush(local, sdata);
105 *new_dev = ndev; 78 WARN_ON(flushed);
106
107 return 0;
108
109fail:
110 free_netdev(ndev);
111 return ret;
112} 79}
113 80
114void ieee80211_if_set_type(struct net_device *dev, int type) 81/*
82 * Helper function to initialise an interface to a specific type.
83 */
84static void ieee80211_setup_sdata(struct ieee80211_sub_if_data *sdata,
85 enum ieee80211_if_types type)
115{ 86{
116 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 87 struct ieee80211_if_sta *ifsta;
117 int oldtype = sdata->vif.type;
118
119 /*
120 * We need to call this function on the master interface
121 * which already has a hard_start_xmit routine assigned
122 * which must not be changed.
123 */
124 if (dev != sdata->local->mdev)
125 dev->hard_start_xmit = ieee80211_subif_start_xmit;
126 88
127 /* 89 /* clear type-dependent union */
128 * Called even when register_netdevice fails, it would 90 memset(&sdata->u, 0, sizeof(sdata->u));
129 * oops if assigned before initialising the rest.
130 */
131 dev->uninit = ieee80211_if_reinit;
132 91
133 /* most have no BSS pointer */ 92 /* and set some type-dependent values */
134 sdata->bss = NULL;
135 sdata->vif.type = type; 93 sdata->vif.type = type;
136 94
137 sdata->basic_rates = 0; 95 /* only monitor differs */
96 sdata->dev->type = ARPHRD_ETHER;
138 97
139 switch (type) { 98 switch (type) {
140 case IEEE80211_IF_TYPE_WDS:
141 /* nothing special */
142 break;
143 case IEEE80211_IF_TYPE_VLAN:
144 sdata->u.vlan.ap = NULL;
145 break;
146 case IEEE80211_IF_TYPE_AP: 99 case IEEE80211_IF_TYPE_AP:
147 sdata->u.ap.force_unicast_rateidx = -1;
148 sdata->u.ap.max_ratectrl_rateidx = -1;
149 skb_queue_head_init(&sdata->u.ap.ps_bc_buf); 100 skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
150 sdata->bss = &sdata->u.ap;
151 INIT_LIST_HEAD(&sdata->u.ap.vlans); 101 INIT_LIST_HEAD(&sdata->u.ap.vlans);
152 break; 102 break;
153 case IEEE80211_IF_TYPE_MESH_POINT: 103 case IEEE80211_IF_TYPE_MESH_POINT:
154 case IEEE80211_IF_TYPE_STA: 104 case IEEE80211_IF_TYPE_STA:
155 case IEEE80211_IF_TYPE_IBSS: { 105 case IEEE80211_IF_TYPE_IBSS:
156 struct ieee80211_sub_if_data *msdata;
157 struct ieee80211_if_sta *ifsta;
158
159 ifsta = &sdata->u.sta; 106 ifsta = &sdata->u.sta;
160 INIT_WORK(&ifsta->work, ieee80211_sta_work); 107 INIT_WORK(&ifsta->work, ieee80211_sta_work);
161 setup_timer(&ifsta->timer, ieee80211_sta_timer, 108 setup_timer(&ifsta->timer, ieee80211_sta_timer,
@@ -171,153 +118,152 @@ void ieee80211_if_set_type(struct net_device *dev, int type)
171 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4) 118 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4)
172 ifsta->flags |= IEEE80211_STA_WMM_ENABLED; 119 ifsta->flags |= IEEE80211_STA_WMM_ENABLED;
173 120
174 msdata = IEEE80211_DEV_TO_SUB_IF(sdata->local->mdev);
175 sdata->bss = &msdata->u.ap;
176
177 if (ieee80211_vif_is_mesh(&sdata->vif)) 121 if (ieee80211_vif_is_mesh(&sdata->vif))
178 ieee80211_mesh_init_sdata(sdata); 122 ieee80211_mesh_init_sdata(sdata);
179 break; 123 break;
180 }
181 case IEEE80211_IF_TYPE_MNTR: 124 case IEEE80211_IF_TYPE_MNTR:
182 dev->type = ARPHRD_IEEE80211_RADIOTAP; 125 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
183 dev->hard_start_xmit = ieee80211_monitor_start_xmit; 126 sdata->dev->hard_start_xmit = ieee80211_monitor_start_xmit;
184 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | 127 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
185 MONITOR_FLAG_OTHER_BSS; 128 MONITOR_FLAG_OTHER_BSS;
186 break; 129 break;
130 case IEEE80211_IF_TYPE_WDS:
131 case IEEE80211_IF_TYPE_VLAN:
132 break;
187 case IEEE80211_IF_TYPE_INVALID: 133 case IEEE80211_IF_TYPE_INVALID:
188 BUG(); 134 BUG();
189 break; 135 break;
190 } 136 }
191 ieee80211_debugfs_change_if_type(sdata, oldtype); 137
138 ieee80211_debugfs_add_netdev(sdata);
192} 139}
193 140
194/* Must be called with rtnl lock held. */ 141int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
195void ieee80211_if_reinit(struct net_device *dev) 142 enum ieee80211_if_types type)
196{ 143{
197 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 144 ASSERT_RTNL();
198 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 145
199 struct sk_buff *skb; 146 if (type == sdata->vif.type)
200 int flushed; 147 return 0;
148
149 /*
150 * We could, here, on changes between IBSS/STA/MESH modes,
151 * invoke an MLME function instead that disassociates etc.
152 * and goes into the requested mode.
153 */
154
155 if (netif_running(sdata->dev))
156 return -EBUSY;
157
158 /* Purge and reset type-dependent state. */
159 ieee80211_teardown_sdata(sdata->dev);
160 ieee80211_setup_sdata(sdata, type);
161
162 /* reset some values that shouldn't be kept across type changes */
163 sdata->basic_rates = 0;
164 sdata->drop_unencrypted = 0;
165
166 return 0;
167}
168
169int ieee80211_if_add(struct ieee80211_local *local, const char *name,
170 struct net_device **new_dev, enum ieee80211_if_types type,
171 struct vif_params *params)
172{
173 struct net_device *ndev;
174 struct ieee80211_sub_if_data *sdata = NULL;
175 int ret, i;
201 176
202 ASSERT_RTNL(); 177 ASSERT_RTNL();
203 178
204 ieee80211_free_keys(sdata); 179 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size,
180 name, ieee80211_if_setup);
181 if (!ndev)
182 return -ENOMEM;
205 183
206 ieee80211_if_sdata_deinit(sdata); 184 ndev->needed_headroom = local->tx_headroom +
185 4*6 /* four MAC addresses */
186 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
187 + 6 /* mesh */
188 + 8 /* rfc1042/bridge tunnel */
189 - ETH_HLEN /* ethernet hard_header_len */
190 + IEEE80211_ENCRYPT_HEADROOM;
191 ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
207 192
208 /* Need to handle mesh specially to allow eliding the function call */ 193 ret = dev_alloc_name(ndev, ndev->name);
209 if (ieee80211_vif_is_mesh(&sdata->vif)) 194 if (ret < 0)
210 mesh_rmc_free(dev); 195 goto fail;
211 196
212 switch (sdata->vif.type) { 197 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
213 case IEEE80211_IF_TYPE_INVALID: 198 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
214 /* cannot happen */
215 WARN_ON(1);
216 break;
217 case IEEE80211_IF_TYPE_AP: {
218 /* Remove all virtual interfaces that use this BSS
219 * as their sdata->bss */
220 struct ieee80211_sub_if_data *tsdata, *n;
221 struct beacon_data *beacon;
222
223 list_for_each_entry_safe(tsdata, n, &local->interfaces, list) {
224 if (tsdata != sdata && tsdata->bss == &sdata->u.ap) {
225 printk(KERN_DEBUG "%s: removing virtual "
226 "interface %s because its BSS interface"
227 " is being removed\n",
228 sdata->dev->name, tsdata->dev->name);
229 list_del_rcu(&tsdata->list);
230 /*
231 * We have lots of time and can afford
232 * to sync for each interface
233 */
234 synchronize_rcu();
235 __ieee80211_if_del(local, tsdata);
236 }
237 }
238 199
239 beacon = sdata->u.ap.beacon; 200 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
240 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 201 sdata = netdev_priv(ndev);
241 synchronize_rcu(); 202 ndev->ieee80211_ptr = &sdata->wdev;
242 kfree(beacon);
243 203
244 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) { 204 /* initialise type-independent data */
245 local->total_ps_buffered--; 205 sdata->wdev.wiphy = local->hw.wiphy;
246 dev_kfree_skb(skb); 206 sdata->local = local;
247 } 207 sdata->dev = ndev;
248 208
249 break; 209 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
250 } 210 skb_queue_head_init(&sdata->fragments[i].skb_list);
251 case IEEE80211_IF_TYPE_WDS:
252 /* nothing to do */
253 break;
254 case IEEE80211_IF_TYPE_MESH_POINT:
255 case IEEE80211_IF_TYPE_STA:
256 case IEEE80211_IF_TYPE_IBSS:
257 kfree(sdata->u.sta.extra_ie);
258 sdata->u.sta.extra_ie = NULL;
259 kfree(sdata->u.sta.assocreq_ies);
260 sdata->u.sta.assocreq_ies = NULL;
261 kfree(sdata->u.sta.assocresp_ies);
262 sdata->u.sta.assocresp_ies = NULL;
263 if (sdata->u.sta.probe_resp) {
264 dev_kfree_skb(sdata->u.sta.probe_resp);
265 sdata->u.sta.probe_resp = NULL;
266 }
267 211
268 break; 212 INIT_LIST_HEAD(&sdata->key_list);
269 case IEEE80211_IF_TYPE_MNTR:
270 dev->type = ARPHRD_ETHER;
271 break;
272 case IEEE80211_IF_TYPE_VLAN:
273 sdata->u.vlan.ap = NULL;
274 break;
275 }
276 213
277 flushed = sta_info_flush(local, sdata); 214 sdata->force_unicast_rateidx = -1;
278 WARN_ON(flushed); 215 sdata->max_ratectrl_rateidx = -1;
279 216
280 memset(&sdata->u, 0, sizeof(sdata->u)); 217 /* setup type-dependent data */
281 ieee80211_if_sdata_init(sdata); 218 ieee80211_setup_sdata(sdata, type);
282}
283 219
284/* Must be called with rtnl lock held. */ 220 ret = register_netdevice(ndev);
285void __ieee80211_if_del(struct ieee80211_local *local, 221 if (ret)
286 struct ieee80211_sub_if_data *sdata) 222 goto fail;
287{
288 struct net_device *dev = sdata->dev;
289 223
290 ieee80211_debugfs_remove_netdev(sdata); 224 ndev->uninit = ieee80211_teardown_sdata;
291 unregister_netdevice(dev); 225
292 /* Except master interface, the net_device will be freed by 226 if (ieee80211_vif_is_mesh(&sdata->vif) &&
293 * net_device->destructor (i. e. ieee80211_if_free). */ 227 params && params->mesh_id_len)
228 ieee80211_if_sta_set_mesh_id(&sdata->u.sta,
229 params->mesh_id_len,
230 params->mesh_id);
231
232 list_add_tail_rcu(&sdata->list, &local->interfaces);
233
234 if (new_dev)
235 *new_dev = ndev;
236
237 return 0;
238
239 fail:
240 free_netdev(ndev);
241 return ret;
294} 242}
295 243
296/* Must be called with rtnl lock held. */ 244void ieee80211_if_remove(struct net_device *dev)
297int ieee80211_if_remove(struct net_device *dev, const char *name, int id)
298{ 245{
299 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 246 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
300 struct ieee80211_sub_if_data *sdata, *n;
301 247
302 ASSERT_RTNL(); 248 ASSERT_RTNL();
303 249
304 list_for_each_entry_safe(sdata, n, &local->interfaces, list) { 250 list_del_rcu(&sdata->list);
305 if ((sdata->vif.type == id || id == -1) && 251 synchronize_rcu();
306 strcmp(name, sdata->dev->name) == 0 && 252 unregister_netdevice(dev);
307 sdata->dev != local->mdev) {
308 list_del_rcu(&sdata->list);
309 synchronize_rcu();
310 __ieee80211_if_del(local, sdata);
311 return 0;
312 }
313 }
314 return -ENODEV;
315} 253}
316 254
317void ieee80211_if_free(struct net_device *dev) 255/*
256 * Remove all interfaces, may only be called at hardware unregistration
257 * time because it doesn't do RCU-safe list removals.
258 */
259void ieee80211_remove_interfaces(struct ieee80211_local *local)
318{ 260{
319 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 261 struct ieee80211_sub_if_data *sdata, *tmp;
320 262
321 ieee80211_if_sdata_deinit(sdata); 263 ASSERT_RTNL();
322 free_netdev(dev); 264
265 list_for_each_entry_safe(sdata, tmp, &local->interfaces, list) {
266 list_del(&sdata->list);
267 unregister_netdevice(sdata->dev);
268 }
323} 269}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-19 13:34:06 -0500