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.c395
1 files changed, 175 insertions, 220 deletions
diff --git a/net/mac80211/iface.c b/net/mac80211/iface.c
index 80954a512185..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,137 +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
41/* Must be called with rtnl lock held. */
42int ieee80211_if_add(struct net_device *dev, const char *name,
43 struct net_device **new_dev, int type,
44 struct vif_params *params)
45{
46 struct net_device *ndev;
47 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
48 struct ieee80211_sub_if_data *sdata = NULL;
49 int ret;
50
51 ASSERT_RTNL();
52 ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size,
53 name, ieee80211_if_setup);
54 if (!ndev)
55 return -ENOMEM;
56
57 ret = dev_alloc_name(ndev, ndev->name);
58 if (ret < 0)
59 goto fail;
60
61 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
62 ndev->base_addr = dev->base_addr;
63 ndev->irq = dev->irq;
64 ndev->mem_start = dev->mem_start;
65 ndev->mem_end = dev->mem_end;
66 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
67
68 sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
69 ndev->ieee80211_ptr = &sdata->wdev;
70 sdata->wdev.wiphy = local->hw.wiphy;
71 sdata->vif.type = IEEE80211_IF_TYPE_AP;
72 sdata->dev = ndev;
73 sdata->local = local;
74 ieee80211_if_sdata_init(sdata);
75 42
76 ret = register_netdevice(ndev); 43 switch (sdata->vif.type) {
77 if (ret) 44 case IEEE80211_IF_TYPE_AP:
78 goto fail; 45 beacon = sdata->u.ap.beacon;
79 46 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
80 ieee80211_debugfs_add_netdev(sdata); 47 synchronize_rcu();
81 ieee80211_if_set_type(ndev, type); 48 kfree(beacon);
82 49
83 if (ieee80211_vif_is_mesh(&sdata->vif) && 50 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
84 params && params->mesh_id_len) 51 local->total_ps_buffered--;
85 ieee80211_if_sta_set_mesh_id(&sdata->u.sta, 52 dev_kfree_skb(skb);
86 params->mesh_id_len, 53 }
87 params->mesh_id);
88 54
89 /* we're under RTNL so all this is fine */ 55 break;
90 if (unlikely(local->reg_state == IEEE80211_DEV_UNREGISTERED)) { 56 case IEEE80211_IF_TYPE_MESH_POINT:
91 __ieee80211_if_del(local, sdata); 57 /* Allow compiler to elide mesh_rmc_free call. */
92 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;
93 } 75 }
94 list_add_tail_rcu(&sdata->list, &local->interfaces);
95
96 if (new_dev)
97 *new_dev = ndev;
98 76
99 return 0; 77 flushed = sta_info_flush(local, sdata);
100 78 WARN_ON(flushed);
101fail:
102 free_netdev(ndev);
103 return ret;
104} 79}
105 80
106void 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)
107{ 86{
108 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 87 struct ieee80211_if_sta *ifsta;
109 int oldtype = sdata->vif.type;
110
111 /*
112 * We need to call this function on the master interface
113 * which already has a hard_start_xmit routine assigned
114 * which must not be changed.
115 */
116 if (dev != sdata->local->mdev)
117 dev->hard_start_xmit = ieee80211_subif_start_xmit;
118 88
119 /* 89 /* clear type-dependent union */
120 * Called even when register_netdevice fails, it would 90 memset(&sdata->u, 0, sizeof(sdata->u));
121 * oops if assigned before initialising the rest.
122 */
123 dev->uninit = ieee80211_if_reinit;
124 91
125 /* most have no BSS pointer */ 92 /* and set some type-dependent values */
126 sdata->bss = NULL;
127 sdata->vif.type = type; 93 sdata->vif.type = type;
128 94
129 sdata->basic_rates = 0; 95 /* only monitor differs */
96 sdata->dev->type = ARPHRD_ETHER;
130 97
131 switch (type) { 98 switch (type) {
132 case IEEE80211_IF_TYPE_WDS:
133 /* nothing special */
134 break;
135 case IEEE80211_IF_TYPE_VLAN:
136 sdata->u.vlan.ap = NULL;
137 break;
138 case IEEE80211_IF_TYPE_AP: 99 case IEEE80211_IF_TYPE_AP:
139 sdata->u.ap.force_unicast_rateidx = -1;
140 sdata->u.ap.max_ratectrl_rateidx = -1;
141 skb_queue_head_init(&sdata->u.ap.ps_bc_buf); 100 skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
142 sdata->bss = &sdata->u.ap;
143 INIT_LIST_HEAD(&sdata->u.ap.vlans); 101 INIT_LIST_HEAD(&sdata->u.ap.vlans);
144 break; 102 break;
145 case IEEE80211_IF_TYPE_MESH_POINT: 103 case IEEE80211_IF_TYPE_MESH_POINT:
146 case IEEE80211_IF_TYPE_STA: 104 case IEEE80211_IF_TYPE_STA:
147 case IEEE80211_IF_TYPE_IBSS: { 105 case IEEE80211_IF_TYPE_IBSS:
148 struct ieee80211_sub_if_data *msdata;
149 struct ieee80211_if_sta *ifsta;
150
151 ifsta = &sdata->u.sta; 106 ifsta = &sdata->u.sta;
152 INIT_WORK(&ifsta->work, ieee80211_sta_work); 107 INIT_WORK(&ifsta->work, ieee80211_sta_work);
153 setup_timer(&ifsta->timer, ieee80211_sta_timer, 108 setup_timer(&ifsta->timer, ieee80211_sta_timer,
@@ -158,157 +113,157 @@ void ieee80211_if_set_type(struct net_device *dev, int type)
158 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN | 113 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN |
159 IEEE80211_AUTH_ALG_SHARED_KEY; 114 IEEE80211_AUTH_ALG_SHARED_KEY;
160 ifsta->flags |= IEEE80211_STA_CREATE_IBSS | 115 ifsta->flags |= IEEE80211_STA_CREATE_IBSS |
161 IEEE80211_STA_WMM_ENABLED |
162 IEEE80211_STA_AUTO_BSSID_SEL | 116 IEEE80211_STA_AUTO_BSSID_SEL |
163 IEEE80211_STA_AUTO_CHANNEL_SEL; 117 IEEE80211_STA_AUTO_CHANNEL_SEL;
164 118 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4)
165 msdata = IEEE80211_DEV_TO_SUB_IF(sdata->local->mdev); 119 ifsta->flags |= IEEE80211_STA_WMM_ENABLED;
166 sdata->bss = &msdata->u.ap;
167 120
168 if (ieee80211_vif_is_mesh(&sdata->vif)) 121 if (ieee80211_vif_is_mesh(&sdata->vif))
169 ieee80211_mesh_init_sdata(sdata); 122 ieee80211_mesh_init_sdata(sdata);
170 break; 123 break;
171 }
172 case IEEE80211_IF_TYPE_MNTR: 124 case IEEE80211_IF_TYPE_MNTR:
173 dev->type = ARPHRD_IEEE80211_RADIOTAP; 125 sdata->dev->type = ARPHRD_IEEE80211_RADIOTAP;
174 dev->hard_start_xmit = ieee80211_monitor_start_xmit; 126 sdata->dev->hard_start_xmit = ieee80211_monitor_start_xmit;
175 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL | 127 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
176 MONITOR_FLAG_OTHER_BSS; 128 MONITOR_FLAG_OTHER_BSS;
177 break; 129 break;
178 default: 130 case IEEE80211_IF_TYPE_WDS:
179 printk(KERN_WARNING "%s: %s: Unknown interface type 0x%x", 131 case IEEE80211_IF_TYPE_VLAN:
180 dev->name, __func__, type); 132 break;
133 case IEEE80211_IF_TYPE_INVALID:
134 BUG();
135 break;
181 } 136 }
182 ieee80211_debugfs_change_if_type(sdata, oldtype); 137
138 ieee80211_debugfs_add_netdev(sdata);
183} 139}
184 140
185/* Must be called with rtnl lock held. */ 141int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
186void ieee80211_if_reinit(struct net_device *dev) 142 enum ieee80211_if_types type)
187{ 143{
188 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 144 ASSERT_RTNL();
189 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 145
190 struct sk_buff *skb; 146 if (type == sdata->vif.type)
191 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;
192 176
193 ASSERT_RTNL(); 177 ASSERT_RTNL();
194 178
195 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;
196 183
197 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;
198 192
199 /* Need to handle mesh specially to allow eliding the function call */ 193 ret = dev_alloc_name(ndev, ndev->name);
200 if (ieee80211_vif_is_mesh(&sdata->vif)) 194 if (ret < 0)
201 mesh_rmc_free(dev); 195 goto fail;
202 196
203 switch (sdata->vif.type) { 197 memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
204 case IEEE80211_IF_TYPE_INVALID: 198 SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
205 /* cannot happen */
206 WARN_ON(1);
207 break;
208 case IEEE80211_IF_TYPE_AP: {
209 /* Remove all virtual interfaces that use this BSS
210 * as their sdata->bss */
211 struct ieee80211_sub_if_data *tsdata, *n;
212 struct beacon_data *beacon;
213
214 list_for_each_entry_safe(tsdata, n, &local->interfaces, list) {
215 if (tsdata != sdata && tsdata->bss == &sdata->u.ap) {
216 printk(KERN_DEBUG "%s: removing virtual "
217 "interface %s because its BSS interface"
218 " is being removed\n",
219 sdata->dev->name, tsdata->dev->name);
220 list_del_rcu(&tsdata->list);
221 /*
222 * We have lots of time and can afford
223 * to sync for each interface
224 */
225 synchronize_rcu();
226 __ieee80211_if_del(local, tsdata);
227 }
228 }
229 199
230 beacon = sdata->u.ap.beacon; 200 /* don't use IEEE80211_DEV_TO_SUB_IF because it checks too much */
231 rcu_assign_pointer(sdata->u.ap.beacon, NULL); 201 sdata = netdev_priv(ndev);
232 synchronize_rcu(); 202 ndev->ieee80211_ptr = &sdata->wdev;
233 kfree(beacon);
234 203
235 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) { 204 /* initialise type-independent data */
236 local->total_ps_buffered--; 205 sdata->wdev.wiphy = local->hw.wiphy;
237 dev_kfree_skb(skb); 206 sdata->local = local;
238 } 207 sdata->dev = ndev;
239 208
240 break; 209 for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
241 } 210 skb_queue_head_init(&sdata->fragments[i].skb_list);
242 case IEEE80211_IF_TYPE_WDS:
243 /* nothing to do */
244 break;
245 case IEEE80211_IF_TYPE_MESH_POINT:
246 case IEEE80211_IF_TYPE_STA:
247 case IEEE80211_IF_TYPE_IBSS:
248 kfree(sdata->u.sta.extra_ie);
249 sdata->u.sta.extra_ie = NULL;
250 kfree(sdata->u.sta.assocreq_ies);
251 sdata->u.sta.assocreq_ies = NULL;
252 kfree(sdata->u.sta.assocresp_ies);
253 sdata->u.sta.assocresp_ies = NULL;
254 if (sdata->u.sta.probe_resp) {
255 dev_kfree_skb(sdata->u.sta.probe_resp);
256 sdata->u.sta.probe_resp = NULL;
257 }
258 211
259 break; 212 INIT_LIST_HEAD(&sdata->key_list);
260 case IEEE80211_IF_TYPE_MNTR:
261 dev->type = ARPHRD_ETHER;
262 break;
263 case IEEE80211_IF_TYPE_VLAN:
264 sdata->u.vlan.ap = NULL;
265 break;
266 }
267 213
268 flushed = sta_info_flush(local, sdata); 214 sdata->force_unicast_rateidx = -1;
269 WARN_ON(flushed); 215 sdata->max_ratectrl_rateidx = -1;
270 216
271 memset(&sdata->u, 0, sizeof(sdata->u)); 217 /* setup type-dependent data */
272 ieee80211_if_sdata_init(sdata); 218 ieee80211_setup_sdata(sdata, type);
273}
274 219
275/* Must be called with rtnl lock held. */ 220 ret = register_netdevice(ndev);
276void __ieee80211_if_del(struct ieee80211_local *local, 221 if (ret)
277 struct ieee80211_sub_if_data *sdata) 222 goto fail;
278{
279 struct net_device *dev = sdata->dev;
280 223
281 ieee80211_debugfs_remove_netdev(sdata); 224 ndev->uninit = ieee80211_teardown_sdata;
282 unregister_netdevice(dev); 225
283 /* Except master interface, the net_device will be freed by 226 if (ieee80211_vif_is_mesh(&sdata->vif) &&
284 * 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;
285} 242}
286 243
287/* Must be called with rtnl lock held. */ 244void ieee80211_if_remove(struct net_device *dev)
288int ieee80211_if_remove(struct net_device *dev, const char *name, int id)
289{ 245{
290 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 246 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
291 struct ieee80211_sub_if_data *sdata, *n;
292 247
293 ASSERT_RTNL(); 248 ASSERT_RTNL();
294 249
295 list_for_each_entry_safe(sdata, n, &local->interfaces, list) { 250 list_del_rcu(&sdata->list);
296 if ((sdata->vif.type == id || id == -1) && 251 synchronize_rcu();
297 strcmp(name, sdata->dev->name) == 0 && 252 unregister_netdevice(dev);
298 sdata->dev != local->mdev) {
299 list_del_rcu(&sdata->list);
300 synchronize_rcu();
301 __ieee80211_if_del(local, sdata);
302 return 0;
303 }
304 }
305 return -ENODEV;
306} 253}
307 254
308void 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)
309{ 260{
310 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); 261 struct ieee80211_sub_if_data *sdata, *tmp;
311 262
312 ieee80211_if_sdata_deinit(sdata); 263 ASSERT_RTNL();
313 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 }
314} 269}
generated by cgit v1.2.2 (git 2.25.0) at 2026-04-27 08:48:22 -0400