redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

replace net_device arguments with ieee80211_{local,sub_if_data} as appropriate 

This patch replaces net_device arguments to mac80211 internal functions
with ieee80211_{local,sub_if_data} as appropriate.

It also does the same for many 802.11s mesh functions, and changes the
mesh path table to be indexed on sub_if_data rather than net_device.

If the mesh part needs to be a separate patch let me know, but since
mesh uses a lot of mac80211 functions which were being converted anyway,
the changes go hand-in-hand somewhat.

This patch probably does not convert all the functions which could be
converted, but it is a large chunk and followup patches will be
provided.

Signed-off-by: Jasper Bryant-Greene <jasper@amiton.co.nz>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
hifive-unleashed-5.1
Jasper Bryant-Greene 2008-08-03 12:04:37 +12:00 committed by John W. Linville
parent fef1643bf0
commit f698d856f6
16 changed files with 546 additions and 609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
net/mac80211/cfg.c
View File

@ -66,13 +66,16 @@ static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex) static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex)
{ {
struct net_device *dev; struct net_device *dev;
struct ieee80211_sub_if_data *sdata;
/* we're under RTNL */ /* we're under RTNL */
dev = __dev_get_by_index(&init_net, ifindex); dev = __dev_get_by_index(&init_net, ifindex);
if (!dev) if (!dev)
return -ENODEV; return -ENODEV;
ieee80211_if_remove(dev); sdata = IEEE80211_DEV_TO_SUB_IF(dev);
ieee80211_if_remove(sdata);
return 0; return 0;
} }
@ -842,13 +845,13 @@ static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
return -ENOENT; return -ENOENT;
} }
err = mesh_path_add(dst, dev); err = mesh_path_add(dst, sdata);
if (err) { if (err) {
rcu_read_unlock(); rcu_read_unlock();
return err; return err;
} }
mpath = mesh_path_lookup(dst, dev); mpath = mesh_path_lookup(dst, sdata);
if (!mpath) { if (!mpath) {
rcu_read_unlock(); rcu_read_unlock();
return -ENXIO; return -ENXIO;
@ -862,10 +865,12 @@ static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev, static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
u8 *dst) u8 *dst)
{ {
if (dst) struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
return mesh_path_del(dst, dev);
mesh_path_flush(dev); if (dst)
return mesh_path_del(dst, sdata);
mesh_path_flush(sdata);
return 0; return 0;
} }
@ -897,7 +902,7 @@ static int ieee80211_change_mpath(struct wiphy *wiphy,
return -ENOENT; return -ENOENT;
} }
mpath = mesh_path_lookup(dst, dev); mpath = mesh_path_lookup(dst, sdata);
if (!mpath) { if (!mpath) {
rcu_read_unlock(); rcu_read_unlock();
return -ENOENT; return -ENOENT;
@ -965,7 +970,7 @@ static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
return -ENOTSUPP; return -ENOTSUPP;
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup(dst, dev); mpath = mesh_path_lookup(dst, sdata);
if (!mpath) { if (!mpath) {
rcu_read_unlock(); rcu_read_unlock();
return -ENOENT; return -ENOENT;
@ -993,7 +998,7 @@ static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
return -ENOTSUPP; return -ENOTSUPP;
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup_by_idx(idx, dev); mpath = mesh_path_lookup_by_idx(idx, sdata);
if (!mpath) { if (!mpath) {
rcu_read_unlock(); rcu_read_unlock();
return -ENOENT; return -ENOENT;

2
net/mac80211/debugfs_sta.c
View File

@ -201,7 +201,7 @@ static ssize_t sta_agg_status_write(struct file *file,
tid_num = tid_num - 100; tid_num = tid_num - 100;
if (tid_static_rx[tid_num] == 1) { if (tid_static_rx[tid_num] == 1) {
strcpy(state, "off "); strcpy(state, "off ");
ieee80211_sta_stop_rx_ba_session(dev, da, tid_num, 0, ieee80211_sta_stop_rx_ba_session(sta->sdata, da, tid_num, 0,
WLAN_REASON_QSTA_REQUIRE_SETUP); WLAN_REASON_QSTA_REQUIRE_SETUP);
sta->ampdu_mlme.tid_state_rx[tid_num] |= sta->ampdu_mlme.tid_state_rx[tid_num] |=
HT_AGG_STATE_DEBUGFS_CTL; HT_AGG_STATE_DEBUGFS_CTL;

5
net/mac80211/event.c
View File

@ -8,7 +8,6 @@
* mac80211 - events * mac80211 - events
*/ */
#include <linux/netdevice.h>
#include <net/iw_handler.h> #include <net/iw_handler.h>
#include "ieee80211_i.h" #include "ieee80211_i.h"
@ -17,7 +16,7 @@
* (in the variable hdr) must be long enough to extract the TKIP * (in the variable hdr) must be long enough to extract the TKIP
* fields like TSC * fields like TSC
*/ */
void mac80211_ev_michael_mic_failure(struct net_device *dev, int keyidx, void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
struct ieee80211_hdr *hdr) struct ieee80211_hdr *hdr)
{ {
union iwreq_data wrqu; union iwreq_data wrqu;
@ -32,7 +31,7 @@ void mac80211_ev_michael_mic_failure(struct net_device *dev, int keyidx,
print_mac(mac, hdr->addr2)); print_mac(mac, hdr->addr2));
memset(&wrqu, 0, sizeof(wrqu)); memset(&wrqu, 0, sizeof(wrqu));
wrqu.data.length = strlen(buf); wrqu.data.length = strlen(buf);
wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf); wireless_send_event(sdata->dev, IWEVCUSTOM, &wrqu, buf);
kfree(buf); kfree(buf);
} }

48
net/mac80211/ieee80211_i.h
View File

@ -851,65 +851,65 @@ u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht,
/* ieee80211_ioctl.c */ /* ieee80211_ioctl.c */
extern const struct iw_handler_def ieee80211_iw_handler_def; extern const struct iw_handler_def ieee80211_iw_handler_def;
int ieee80211_set_freq(struct net_device *dev, int freq); int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freq);
/* ieee80211_sta.c */ /* ieee80211_sta.c */
void ieee80211_sta_timer(unsigned long data); void ieee80211_sta_timer(unsigned long data);
void ieee80211_sta_work(struct work_struct *work); void ieee80211_sta_work(struct work_struct *work);
void ieee80211_sta_scan_work(struct work_struct *work); void ieee80211_sta_scan_work(struct work_struct *work);
void ieee80211_sta_rx_mgmt(struct net_device *dev, struct sk_buff *skb, void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
struct ieee80211_rx_status *rx_status); struct ieee80211_rx_status *rx_status);
int ieee80211_sta_set_ssid(struct net_device *dev, char *ssid, size_t len); int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len);
int ieee80211_sta_get_ssid(struct net_device *dev, char *ssid, size_t *len); int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len);
int ieee80211_sta_set_bssid(struct net_device *dev, u8 *bssid); int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid);
int ieee80211_sta_req_scan(struct net_device *dev, u8 *ssid, size_t ssid_len); int ieee80211_sta_req_scan(struct ieee80211_sub_if_data *sdata, u8 *ssid, size_t ssid_len);
void ieee80211_sta_req_auth(struct net_device *dev, void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata,
struct ieee80211_if_sta *ifsta); struct ieee80211_if_sta *ifsta);
int ieee80211_sta_scan_results(struct net_device *dev, int ieee80211_sta_scan_results(struct ieee80211_local *local,
struct iw_request_info *info, struct iw_request_info *info,
char *buf, size_t len); char *buf, size_t len);
ieee80211_rx_result ieee80211_sta_rx_scan( ieee80211_rx_result ieee80211_sta_rx_scan(
struct net_device *dev, struct sk_buff *skb, struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
struct ieee80211_rx_status *rx_status); struct ieee80211_rx_status *rx_status);
void ieee80211_rx_bss_list_init(struct ieee80211_local *local); void ieee80211_rx_bss_list_init(struct ieee80211_local *local);
void ieee80211_rx_bss_list_deinit(struct ieee80211_local *local); void ieee80211_rx_bss_list_deinit(struct ieee80211_local *local);
int ieee80211_sta_set_extra_ie(struct net_device *dev, char *ie, size_t len); int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len);
struct sta_info *ieee80211_ibss_add_sta(struct net_device *dev, struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
struct sk_buff *skb, u8 *bssid, struct sk_buff *skb, u8 *bssid,
u8 *addr, u64 supp_rates); u8 *addr, u64 supp_rates);
int ieee80211_sta_deauthenticate(struct net_device *dev, u16 reason); int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason);
int ieee80211_sta_disassociate(struct net_device *dev, u16 reason); int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason);
void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
u32 changed); u32 changed);
u32 ieee80211_reset_erp_info(struct net_device *dev); u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie, int ieee80211_ht_cap_ie_to_ht_info(struct ieee80211_ht_cap *ht_cap_ie,
struct ieee80211_ht_info *ht_info); struct ieee80211_ht_info *ht_info);
int ieee80211_ht_addt_info_ie_to_ht_bss_info( int ieee80211_ht_addt_info_ie_to_ht_bss_info(
struct ieee80211_ht_addt_info *ht_add_info_ie, struct ieee80211_ht_addt_info *ht_add_info_ie,
struct ieee80211_ht_bss_info *bss_info); struct ieee80211_ht_bss_info *bss_info);
void ieee80211_send_addba_request(struct net_device *dev, const u8 *da, void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata, const u8 *da,
u16 tid, u8 dialog_token, u16 start_seq_num, u16 tid, u8 dialog_token, u16 start_seq_num,
u16 agg_size, u16 timeout); u16 agg_size, u16 timeout);
void ieee80211_send_delba(struct net_device *dev, const u8 *da, u16 tid, void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata, const u8 *da, u16 tid,
u16 initiator, u16 reason_code); u16 initiator, u16 reason_code);
void ieee80211_send_bar(struct net_device *dev, u8 *ra, u16 tid, u16 ssn); void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn);
void ieee80211_sta_stop_rx_ba_session(struct net_device *dev, u8 *da, void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data *sdata, u8 *da,
u16 tid, u16 initiator, u16 reason); u16 tid, u16 initiator, u16 reason);
void sta_addba_resp_timer_expired(unsigned long data); void sta_addba_resp_timer_expired(unsigned long data);
void ieee80211_sta_tear_down_BA_sessions(struct net_device *dev, u8 *addr); void ieee80211_sta_tear_down_BA_sessions(struct ieee80211_sub_if_data *sdata, u8 *addr);
u64 ieee80211_sta_get_rates(struct ieee80211_local *local, u64 ieee80211_sta_get_rates(struct ieee80211_local *local,
struct ieee802_11_elems *elems, struct ieee802_11_elems *elems,
enum ieee80211_band band); enum ieee80211_band band);
void ieee80211_sta_tx(struct net_device *dev, struct sk_buff *skb, void ieee80211_sta_tx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
int encrypt); int encrypt);
void ieee802_11_parse_elems(u8 *start, size_t len, void ieee802_11_parse_elems(u8 *start, size_t len,
struct ieee802_11_elems *elems); struct ieee802_11_elems *elems);
#ifdef CONFIG_MAC80211_MESH #ifdef CONFIG_MAC80211_MESH
void ieee80211_start_mesh(struct net_device *dev); void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata);
#else #else
static inline void ieee80211_start_mesh(struct net_device *dev) static inline void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
{} {}
#endif #endif
@ -920,7 +920,7 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
struct vif_params *params); struct vif_params *params);
int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata, int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
enum ieee80211_if_types type); enum ieee80211_if_types type);
void ieee80211_if_remove(struct net_device *dev); void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
void ieee80211_remove_interfaces(struct ieee80211_local *local); void ieee80211_remove_interfaces(struct ieee80211_local *local);
/* tx handling */ /* tx handling */
@ -938,7 +938,7 @@ u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
enum ieee80211_if_types type); enum ieee80211_if_types type);
int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
int rate, int erp, int short_preamble); int rate, int erp, int short_preamble);
void mac80211_ev_michael_mic_failure(struct net_device *dev, int keyidx, void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
struct ieee80211_hdr *hdr); struct ieee80211_hdr *hdr);
#ifdef CONFIG_MAC80211_NOINLINE #ifdef CONFIG_MAC80211_NOINLINE

8
net/mac80211/iface.c
View File

@ -56,7 +56,7 @@ static void ieee80211_teardown_sdata(struct net_device *dev)
case IEEE80211_IF_TYPE_MESH_POINT: case IEEE80211_IF_TYPE_MESH_POINT:
/* Allow compiler to elide mesh_rmc_free call. */ /* Allow compiler to elide mesh_rmc_free call. */
if (ieee80211_vif_is_mesh(&sdata->vif)) if (ieee80211_vif_is_mesh(&sdata->vif))
mesh_rmc_free(dev); mesh_rmc_free(sdata);
/* fall through */ /* fall through */
case IEEE80211_IF_TYPE_STA: case IEEE80211_IF_TYPE_STA:
case IEEE80211_IF_TYPE_IBSS: case IEEE80211_IF_TYPE_IBSS:
@ -241,15 +241,13 @@ int ieee80211_if_add(struct ieee80211_local *local, const char *name,
return ret; return ret;
} }
void ieee80211_if_remove(struct net_device *dev) void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
ASSERT_RTNL(); ASSERT_RTNL();
list_del_rcu(&sdata->list); list_del_rcu(&sdata->list);
synchronize_rcu(); synchronize_rcu();
unregister_netdevice(dev); unregister_netdevice(sdata->dev);
} }
/* /*

16
net/mac80211/main.c
View File

@ -347,8 +347,8 @@ static int ieee80211_open(struct net_device *dev)
goto err_stop; goto err_stop;
if (ieee80211_vif_is_mesh(&sdata->vif)) if (ieee80211_vif_is_mesh(&sdata->vif))
ieee80211_start_mesh(sdata->dev); ieee80211_start_mesh(sdata);
changed |= ieee80211_reset_erp_info(dev); changed |= ieee80211_reset_erp_info(sdata);
ieee80211_bss_info_change_notify(sdata, changed); ieee80211_bss_info_change_notify(sdata, changed);
ieee80211_enable_keys(sdata); ieee80211_enable_keys(sdata);
@ -448,7 +448,7 @@ static int ieee80211_stop(struct net_device *dev)
list_for_each_entry_rcu(sta, &local->sta_list, list) { list_for_each_entry_rcu(sta, &local->sta_list, list) {
if (sta->sdata == sdata) if (sta->sdata == sdata)
ieee80211_sta_tear_down_BA_sessions(dev, sta->addr); ieee80211_sta_tear_down_BA_sessions(sdata, sta->addr);
} }
rcu_read_unlock(); rcu_read_unlock();
@ -706,7 +706,7 @@ int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid)
sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num; sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num;
ieee80211_send_addba_request(sta->sdata->dev, ra, tid, ieee80211_send_addba_request(sta->sdata, ra, tid,
sta->ampdu_mlme.tid_tx[tid]->dialog_token, sta->ampdu_mlme.tid_tx[tid]->dialog_token,
sta->ampdu_mlme.tid_tx[tid]->ssn, sta->ampdu_mlme.tid_tx[tid]->ssn,
0x40, 5000); 0x40, 5000);
@ -889,7 +889,7 @@ void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid)
} }
if (*state & HT_AGG_STATE_INITIATOR_MSK) if (*state & HT_AGG_STATE_INITIATOR_MSK)
ieee80211_send_delba(sta->sdata->dev, ra, tid, ieee80211_send_delba(sta->sdata, ra, tid,
WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE); WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
agg_queue = sta->tid_to_tx_q[tid]; agg_queue = sta->tid_to_tx_q[tid];
@ -1200,10 +1200,8 @@ void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
changed); changed);
} }
u32 ieee80211_reset_erp_info(struct net_device *dev) u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
sdata->bss_conf.use_cts_prot = 0; sdata->bss_conf.use_cts_prot = 0;
sdata->bss_conf.use_short_preamble = 0; sdata->bss_conf.use_short_preamble = 0;
return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE; return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE;
@ -1438,7 +1436,7 @@ void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
tid = qc[0] & 0xf; tid = qc[0] & 0xf;
ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10) ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
& IEEE80211_SCTL_SEQ); & IEEE80211_SCTL_SEQ);
ieee80211_send_bar(sta->sdata->dev, hdr->addr1, ieee80211_send_bar(sta->sdata, hdr->addr1,
tid, ssn); tid, ssn);
} }
} }

29
net/mac80211/mesh.c
View File

@ -39,14 +39,13 @@ void ieee80211s_stop(void)
* mesh_matches_local - check if the config of a mesh point matches ours * mesh_matches_local - check if the config of a mesh point matches ours
* *
* @ie: information elements of a management frame from the mesh peer * @ie: information elements of a management frame from the mesh peer
* @dev: local mesh interface * @sdata: local mesh subif
* *
* This function checks if the mesh configuration of a mesh point matches the * This function checks if the mesh configuration of a mesh point matches the
* local mesh configuration, i.e. if both nodes belong to the same mesh network. * local mesh configuration, i.e. if both nodes belong to the same mesh network.
*/ */
bool mesh_matches_local(struct ieee802_11_elems *ie, struct net_device *dev) bool mesh_matches_local(struct ieee802_11_elems *ie, struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_if_sta *sta = &sdata->u.sta; struct ieee80211_if_sta *sta = &sdata->u.sta;
/* /*
@ -73,10 +72,8 @@ bool mesh_matches_local(struct ieee802_11_elems *ie, struct net_device *dev)
* mesh_peer_accepts_plinks - check if an mp is willing to establish peer links * mesh_peer_accepts_plinks - check if an mp is willing to establish peer links
* *
* @ie: information elements of a management frame from the mesh peer * @ie: information elements of a management frame from the mesh peer
* @dev: local mesh interface
*/ */
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie, bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie)
struct net_device *dev)
{ {
return (*(ie->mesh_config + CAPAB_OFFSET) & ACCEPT_PLINKS) != 0; return (*(ie->mesh_config + CAPAB_OFFSET) & ACCEPT_PLINKS) != 0;
} }
@ -111,9 +108,8 @@ void mesh_ids_set_default(struct ieee80211_if_sta *sta)
memcpy(sta->mesh_cc_id, def_id, 4); memcpy(sta->mesh_cc_id, def_id, 4);
} }
int mesh_rmc_init(struct net_device *dev) int mesh_rmc_init(struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
int i; int i;
sdata->u.sta.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL); sdata->u.sta.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL);
@ -125,9 +121,8 @@ int mesh_rmc_init(struct net_device *dev)
return 0; return 0;
} }
void mesh_rmc_free(struct net_device *dev) void mesh_rmc_free(struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct mesh_rmc *rmc = sdata->u.sta.rmc; struct mesh_rmc *rmc = sdata->u.sta.rmc;
struct rmc_entry *p, *n; struct rmc_entry *p, *n;
int i; int i;
@ -158,9 +153,8 @@ void mesh_rmc_free(struct net_device *dev)
* it. * it.
*/ */
int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr, int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
struct net_device *dev) struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct mesh_rmc *rmc = sdata->u.sta.rmc; struct mesh_rmc *rmc = sdata->u.sta.rmc;
u32 seqnum = 0; u32 seqnum = 0;
int entries = 0; int entries = 0;
@ -194,10 +188,9 @@ int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
return 0; return 0;
} }
void mesh_mgmt_ies_add(struct sk_buff *skb, struct net_device *dev) void mesh_mgmt_ies_add(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_supported_band *sband; struct ieee80211_supported_band *sband;
u8 *pos; u8 *pos;
int len, i, rate; int len, i, rate;
@ -262,10 +255,10 @@ void mesh_mgmt_ies_add(struct sk_buff *skb, struct net_device *dev)
return; return;
} }
u32 mesh_table_hash(u8 *addr, struct net_device *dev, struct mesh_table *tbl) u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata, struct mesh_table *tbl)
{ {
/* Use last four bytes of hw addr and interface index as hash index */ /* Use last four bytes of hw addr and interface index as hash index */
return jhash_2words(*(u32 *)(addr+2), dev->ifindex, tbl->hash_rnd) return jhash_2words(*(u32 *)(addr+2), sdata->dev->ifindex, tbl->hash_rnd)
& tbl->hash_mask; & tbl->hash_mask;
} }
@ -434,7 +427,7 @@ void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
ifsta->preq_id = 0; ifsta->preq_id = 0;
ifsta->dsn = 0; ifsta->dsn = 0;
atomic_set(&ifsta->mpaths, 0); atomic_set(&ifsta->mpaths, 0);
mesh_rmc_init(sdata->dev); mesh_rmc_init(sdata);
ifsta->last_preq = jiffies; ifsta->last_preq = jiffies;
/* Allocate all mesh structures when creating the first mesh interface. */ /* Allocate all mesh structures when creating the first mesh interface. */
if (!mesh_allocated) if (!mesh_allocated)

61
net/mac80211/mesh.h
View File

@ -47,7 +47,7 @@ enum mesh_path_flags {
* struct mesh_path - mac80211 mesh path structure * struct mesh_path - mac80211 mesh path structure
* *
* @dst: mesh path destination mac address * @dst: mesh path destination mac address
* @dev: mesh path device * @sdata: mesh subif
* @next_hop: mesh neighbor to which frames for this destination will be * @next_hop: mesh neighbor to which frames for this destination will be
* forwarded * forwarded
* @timer: mesh path discovery timer * @timer: mesh path discovery timer
@ -64,14 +64,14 @@ enum mesh_path_flags {
* @state_lock: mesh pat state lock * @state_lock: mesh pat state lock
* *
* *
* The combination of dst and dev is unique in the mesh path table. Since the * The combination of dst and sdata is unique in the mesh path table. Since the
* next_hop STA is only protected by RCU as well, deleting the STA must also * next_hop STA is only protected by RCU as well, deleting the STA must also
* remove/substitute the mesh_path structure and wait until that is no longer * remove/substitute the mesh_path structure and wait until that is no longer
* reachable before destroying the STA completely. * reachable before destroying the STA completely.
*/ */
struct mesh_path { struct mesh_path {
u8 dst[ETH_ALEN]; u8 dst[ETH_ALEN];
struct net_device *dev; struct ieee80211_sub_if_data *sdata;
struct sta_info *next_hop; struct sta_info *next_hop;
struct timer_list timer; struct timer_list timer;
struct sk_buff_head frame_queue; struct sk_buff_head frame_queue;
@ -203,59 +203,66 @@ int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr);
int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr, int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr,
struct ieee80211_sub_if_data *sdata); struct ieee80211_sub_if_data *sdata);
int mesh_rmc_check(u8 *addr, struct ieee80211s_hdr *mesh_hdr, int mesh_rmc_check(u8 *addr, struct ieee80211s_hdr *mesh_hdr,
struct net_device *dev); struct ieee80211_sub_if_data *sdata);
bool mesh_matches_local(struct ieee802_11_elems *ie, struct net_device *dev); bool mesh_matches_local(struct ieee802_11_elems *ie,
struct ieee80211_sub_if_data *sdata);
void mesh_ids_set_default(struct ieee80211_if_sta *sta); void mesh_ids_set_default(struct ieee80211_if_sta *sta);
void mesh_mgmt_ies_add(struct sk_buff *skb, struct net_device *dev); void mesh_mgmt_ies_add(struct sk_buff *skb,
void mesh_rmc_free(struct net_device *dev); struct ieee80211_sub_if_data *sdata);
int mesh_rmc_init(struct net_device *dev); void mesh_rmc_free(struct ieee80211_sub_if_data *sdata);
int mesh_rmc_init(struct ieee80211_sub_if_data *sdata);
void ieee80211s_init(void); void ieee80211s_init(void);
void ieee80211s_stop(void); void ieee80211s_stop(void);
void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata); void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata);
/* Mesh paths */ /* Mesh paths */
int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev); int mesh_nexthop_lookup(struct sk_buff *skb,
void mesh_path_start_discovery(struct net_device *dev); struct ieee80211_sub_if_data *sdata);
struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev); void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata);
struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev); struct mesh_path *mesh_path_lookup(u8 *dst,
struct ieee80211_sub_if_data *sdata);
struct mesh_path *mesh_path_lookup_by_idx(int idx,
struct ieee80211_sub_if_data *sdata);
void mesh_path_fix_nexthop(struct mesh_path *mpath, struct sta_info *next_hop); void mesh_path_fix_nexthop(struct mesh_path *mpath, struct sta_info *next_hop);
void mesh_path_expire(struct net_device *dev); void mesh_path_expire(struct ieee80211_sub_if_data *sdata);
void mesh_path_flush(struct net_device *dev); void mesh_path_flush(struct ieee80211_sub_if_data *sdata);
void mesh_rx_path_sel_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt, void mesh_rx_path_sel_frame(struct ieee80211_sub_if_data *sdata,
size_t len); struct ieee80211_mgmt *mgmt, size_t len);
int mesh_path_add(u8 *dst, struct net_device *dev); int mesh_path_add(u8 *dst, struct ieee80211_sub_if_data *sdata);
/* Mesh plinks */ /* Mesh plinks */
void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct net_device *dev, void mesh_neighbour_update(u8 *hw_addr, u64 rates,
bool add); struct ieee80211_sub_if_data *sdata, bool add);
bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie, bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie);
struct net_device *dev);
void mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata); void mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata);
void mesh_plink_broken(struct sta_info *sta); void mesh_plink_broken(struct sta_info *sta);
void mesh_plink_deactivate(struct sta_info *sta); void mesh_plink_deactivate(struct sta_info *sta);
int mesh_plink_open(struct sta_info *sta); int mesh_plink_open(struct sta_info *sta);
int mesh_plink_close(struct sta_info *sta); int mesh_plink_close(struct sta_info *sta);
void mesh_plink_block(struct sta_info *sta); void mesh_plink_block(struct sta_info *sta);
void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt, void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
size_t len, struct ieee80211_rx_status *rx_status); struct ieee80211_mgmt *mgmt, size_t len,
struct ieee80211_rx_status *rx_status);
/* Private interfaces */ /* Private interfaces */
/* Mesh tables */ /* Mesh tables */
struct mesh_table *mesh_table_alloc(int size_order); struct mesh_table *mesh_table_alloc(int size_order);
void mesh_table_free(struct mesh_table *tbl, bool free_leafs); void mesh_table_free(struct mesh_table *tbl, bool free_leafs);
struct mesh_table *mesh_table_grow(struct mesh_table *tbl); struct mesh_table *mesh_table_grow(struct mesh_table *tbl);
u32 mesh_table_hash(u8 *addr, struct net_device *dev, struct mesh_table *tbl); u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata,
struct mesh_table *tbl);
/* Mesh paths */ /* Mesh paths */
int mesh_path_error_tx(u8 *dest, __le32 dest_dsn, u8 *ra, int mesh_path_error_tx(u8 *dest, __le32 dest_dsn, u8 *ra,
struct net_device *dev); struct ieee80211_sub_if_data *sdata);
void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta); void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta);
void mesh_path_flush_pending(struct mesh_path *mpath); void mesh_path_flush_pending(struct mesh_path *mpath);
void mesh_path_tx_pending(struct mesh_path *mpath); void mesh_path_tx_pending(struct mesh_path *mpath);
int mesh_pathtbl_init(void); int mesh_pathtbl_init(void);
void mesh_pathtbl_unregister(void); void mesh_pathtbl_unregister(void);
int mesh_path_del(u8 *addr, struct net_device *dev); int mesh_path_del(u8 *addr, struct ieee80211_sub_if_data *sdata);
void mesh_path_timer(unsigned long data); void mesh_path_timer(unsigned long data);
void mesh_path_flush_by_nexthop(struct sta_info *sta); void mesh_path_flush_by_nexthop(struct sta_info *sta);
void mesh_path_discard_frame(struct sk_buff *skb, struct net_device *dev); void mesh_path_discard_frame(struct sk_buff *skb,
struct ieee80211_sub_if_data *sdata);
#ifdef CONFIG_MAC80211_MESH #ifdef CONFIG_MAC80211_MESH
extern int mesh_allocated; extern int mesh_allocated;

112
net/mac80211/mesh_hwmp.c
View File

@ -82,9 +82,9 @@ enum mpath_frame_type {
static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags, static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
u8 *orig_addr, __le32 orig_dsn, u8 dst_flags, u8 *dst, u8 *orig_addr, __le32 orig_dsn, u8 dst_flags, u8 *dst,
__le32 dst_dsn, u8 *da, u8 hop_count, u8 ttl, __le32 lifetime, __le32 dst_dsn, u8 *da, u8 hop_count, u8 ttl, __le32 lifetime,
__le32 metric, __le32 preq_id, struct net_device *dev) __le32 metric, __le32 preq_id, struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400); struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
struct ieee80211_mgmt *mgmt; struct ieee80211_mgmt *mgmt;
u8 *pos; u8 *pos;
@ -103,7 +103,7 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
IEEE80211_STYPE_ACTION); IEEE80211_STYPE_ACTION);
memcpy(mgmt->da, da, ETH_ALEN); memcpy(mgmt->da, da, ETH_ALEN);
memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN); memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
/* BSSID is left zeroed, wildcard value */ /* BSSID is left zeroed, wildcard value */
mgmt->u.action.category = MESH_PATH_SEL_CATEGORY; mgmt->u.action.category = MESH_PATH_SEL_CATEGORY;
mgmt->u.action.u.mesh_action.action_code = action; mgmt->u.action.u.mesh_action.action_code = action;
@ -149,7 +149,7 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
pos += ETH_ALEN; pos += ETH_ALEN;
memcpy(pos, &dst_dsn, 4); memcpy(pos, &dst_dsn, 4);
ieee80211_sta_tx(dev, skb, 0); ieee80211_sta_tx(sdata, skb, 0);
return 0; return 0;
} }
@ -161,9 +161,9 @@ static int mesh_path_sel_frame_tx(enum mpath_frame_type action, u8 flags,
* @ra: node this frame is addressed to * @ra: node this frame is addressed to
*/ */
int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra, int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra,
struct net_device *dev) struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400); struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
struct ieee80211_mgmt *mgmt; struct ieee80211_mgmt *mgmt;
u8 *pos; u8 *pos;
@ -182,7 +182,7 @@ int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra,
IEEE80211_STYPE_ACTION); IEEE80211_STYPE_ACTION);
memcpy(mgmt->da, ra, ETH_ALEN); memcpy(mgmt->da, ra, ETH_ALEN);
memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN); memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
/* BSSID is left zeroed, wildcard value */ /* BSSID is left zeroed, wildcard value */
mgmt->u.action.category = MESH_PATH_SEL_CATEGORY; mgmt->u.action.category = MESH_PATH_SEL_CATEGORY;
mgmt->u.action.u.mesh_action.action_code = MPATH_PERR; mgmt->u.action.u.mesh_action.action_code = MPATH_PERR;
@ -198,7 +198,7 @@ int mesh_path_error_tx(u8 *dst, __le32 dst_dsn, u8 *ra,
pos += ETH_ALEN; pos += ETH_ALEN;
memcpy(pos, &dst_dsn, 4); memcpy(pos, &dst_dsn, 4);
ieee80211_sta_tx(dev, skb, 0); ieee80211_sta_tx(sdata, skb, 0);
return 0; return 0;
} }
@ -233,7 +233,7 @@ static u32 airtime_link_metric_get(struct ieee80211_local *local,
/** /**
* hwmp_route_info_get - Update routing info to originator and transmitter * hwmp_route_info_get - Update routing info to originator and transmitter
* *
* @dev: local mesh interface * @sdata: local mesh subif
* @mgmt: mesh management frame * @mgmt: mesh management frame
* @hwmp_ie: hwmp information element (PREP or PREQ) * @hwmp_ie: hwmp information element (PREP or PREQ)
* *
@ -246,11 +246,11 @@ static u32 airtime_link_metric_get(struct ieee80211_local *local,
* Notes: this function is the only place (besides user-provided info) where * Notes: this function is the only place (besides user-provided info) where
* path routing information is updated. * path routing information is updated.
*/ */
static u32 hwmp_route_info_get(struct net_device *dev, static u32 hwmp_route_info_get(struct ieee80211_sub_if_data *sdata,
struct ieee80211_mgmt *mgmt, struct ieee80211_mgmt *mgmt,
u8 *hwmp_ie) u8 *hwmp_ie)
{ {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct mesh_path *mpath; struct mesh_path *mpath;
struct sta_info *sta; struct sta_info *sta;
bool fresh_info; bool fresh_info;
@ -301,14 +301,14 @@ static u32 hwmp_route_info_get(struct net_device *dev,
new_metric = MAX_METRIC; new_metric = MAX_METRIC;
exp_time = TU_TO_EXP_TIME(orig_lifetime); exp_time = TU_TO_EXP_TIME(orig_lifetime);
if (memcmp(orig_addr, dev->dev_addr, ETH_ALEN) == 0) { if (memcmp(orig_addr, sdata->dev->dev_addr, ETH_ALEN) == 0) {
/* This MP is the originator, we are not interested in this /* This MP is the originator, we are not interested in this
* frame, except for updating transmitter's path info. * frame, except for updating transmitter's path info.
*/ */
process = false; process = false;
fresh_info = false; fresh_info = false;
} else { } else {
mpath = mesh_path_lookup(orig_addr, dev); mpath = mesh_path_lookup(orig_addr, sdata);
if (mpath) { if (mpath) {
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
if (mpath->flags & MESH_PATH_FIXED) if (mpath->flags & MESH_PATH_FIXED)
@ -324,8 +324,8 @@ static u32 hwmp_route_info_get(struct net_device *dev,
} }
} }
} else { } else {
mesh_path_add(orig_addr, dev); mesh_path_add(orig_addr, sdata);
mpath = mesh_path_lookup(orig_addr, dev); mpath = mesh_path_lookup(orig_addr, sdata);
if (!mpath) { if (!mpath) {
rcu_read_unlock(); rcu_read_unlock();
return 0; return 0;
@ -357,7 +357,7 @@ static u32 hwmp_route_info_get(struct net_device *dev,
else { else {
fresh_info = true; fresh_info = true;
mpath = mesh_path_lookup(ta, dev); mpath = mesh_path_lookup(ta, sdata);
if (mpath) { if (mpath) {
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
if ((mpath->flags & MESH_PATH_FIXED) || if ((mpath->flags & MESH_PATH_FIXED) ||
@ -365,8 +365,8 @@ static u32 hwmp_route_info_get(struct net_device *dev,
(last_hop_metric > mpath->metric))) (last_hop_metric > mpath->metric)))
fresh_info = false; fresh_info = false;
} else { } else {
mesh_path_add(ta, dev); mesh_path_add(ta, sdata);
mpath = mesh_path_lookup(ta, dev); mpath = mesh_path_lookup(ta, sdata);
if (!mpath) { if (!mpath) {
rcu_read_unlock(); rcu_read_unlock();
return 0; return 0;
@ -392,10 +392,9 @@ static u32 hwmp_route_info_get(struct net_device *dev,
return process ? new_metric : 0; return process ? new_metric : 0;
} }
static void hwmp_preq_frame_process(struct net_device *dev, static void hwmp_preq_frame_process(struct ieee80211_sub_if_data *sdata,
struct ieee80211_mgmt *mgmt, struct ieee80211_mgmt *mgmt,
u8 *preq_elem, u32 metric) { u8 *preq_elem, u32 metric) {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_if_sta *ifsta = &sdata->u.sta; struct ieee80211_if_sta *ifsta = &sdata->u.sta;
struct mesh_path *mpath; struct mesh_path *mpath;
u8 *dst_addr, *orig_addr; u8 *dst_addr, *orig_addr;
@ -411,7 +410,7 @@ static void hwmp_preq_frame_process(struct net_device *dev,
orig_dsn = PREQ_IE_ORIG_DSN(preq_elem); orig_dsn = PREQ_IE_ORIG_DSN(preq_elem);
dst_flags = PREQ_IE_DST_F(preq_elem); dst_flags = PREQ_IE_DST_F(preq_elem);
if (memcmp(dst_addr, dev->dev_addr, ETH_ALEN) == 0) { if (memcmp(dst_addr, sdata->dev->dev_addr, ETH_ALEN) == 0) {
forward = false; forward = false;
reply = true; reply = true;
metric = 0; metric = 0;
@ -423,7 +422,7 @@ static void hwmp_preq_frame_process(struct net_device *dev,
} }
} else { } else {
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup(dst_addr, dev); mpath = mesh_path_lookup(dst_addr, sdata);
if (mpath) { if (mpath) {
if ((!(mpath->flags & MESH_PATH_DSN_VALID)) || if ((!(mpath->flags & MESH_PATH_DSN_VALID)) ||
DSN_LT(mpath->dsn, dst_dsn)) { DSN_LT(mpath->dsn, dst_dsn)) {
@ -451,7 +450,7 @@ static void hwmp_preq_frame_process(struct net_device *dev,
cpu_to_le32(dst_dsn), 0, orig_addr, cpu_to_le32(dst_dsn), 0, orig_addr,
cpu_to_le32(orig_dsn), mgmt->sa, 0, ttl, cpu_to_le32(orig_dsn), mgmt->sa, 0, ttl,
cpu_to_le32(lifetime), cpu_to_le32(metric), cpu_to_le32(lifetime), cpu_to_le32(metric),
0, dev); 0, sdata);
else else
ifsta->mshstats.dropped_frames_ttl++; ifsta->mshstats.dropped_frames_ttl++;
} }
@ -472,20 +471,19 @@ static void hwmp_preq_frame_process(struct net_device *dev,
hopcount = PREQ_IE_HOPCOUNT(preq_elem) + 1; hopcount = PREQ_IE_HOPCOUNT(preq_elem) + 1;
mesh_path_sel_frame_tx(MPATH_PREQ, flags, orig_addr, mesh_path_sel_frame_tx(MPATH_PREQ, flags, orig_addr,
cpu_to_le32(orig_dsn), dst_flags, dst_addr, cpu_to_le32(orig_dsn), dst_flags, dst_addr,
cpu_to_le32(dst_dsn), dev->broadcast, cpu_to_le32(dst_dsn), sdata->dev->broadcast,
hopcount, ttl, cpu_to_le32(lifetime), hopcount, ttl, cpu_to_le32(lifetime),
cpu_to_le32(metric), cpu_to_le32(preq_id), cpu_to_le32(metric), cpu_to_le32(preq_id),
dev); sdata);
ifsta->mshstats.fwded_frames++; ifsta->mshstats.fwded_frames++;
} }
} }
static void hwmp_prep_frame_process(struct net_device *dev, static void hwmp_prep_frame_process(struct ieee80211_sub_if_data *sdata,
struct ieee80211_mgmt *mgmt, struct ieee80211_mgmt *mgmt,
u8 *prep_elem, u32 metric) u8 *prep_elem, u32 metric)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct mesh_path *mpath; struct mesh_path *mpath;
u8 *dst_addr, *orig_addr; u8 *dst_addr, *orig_addr;
u8 ttl, hopcount, flags; u8 ttl, hopcount, flags;
@ -499,7 +497,7 @@ static void hwmp_prep_frame_process(struct net_device *dev,
* replies * replies
*/ */
dst_addr = PREP_IE_DST_ADDR(prep_elem); dst_addr = PREP_IE_DST_ADDR(prep_elem);
if (memcmp(dst_addr, dev->dev_addr, ETH_ALEN) == 0) if (memcmp(dst_addr, sdata->dev->dev_addr, ETH_ALEN) == 0)
/* destination, no forwarding required */ /* destination, no forwarding required */
return; return;
@ -510,7 +508,7 @@ static void hwmp_prep_frame_process(struct net_device *dev,
} }
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup(dst_addr, dev); mpath = mesh_path_lookup(dst_addr, sdata);
if (mpath) if (mpath)
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
else else
@ -533,7 +531,7 @@ static void hwmp_prep_frame_process(struct net_device *dev,
cpu_to_le32(orig_dsn), 0, dst_addr, cpu_to_le32(orig_dsn), 0, dst_addr,
cpu_to_le32(dst_dsn), mpath->next_hop->addr, hopcount, ttl, cpu_to_le32(dst_dsn), mpath->next_hop->addr, hopcount, ttl,
cpu_to_le32(lifetime), cpu_to_le32(metric), cpu_to_le32(lifetime), cpu_to_le32(metric),
0, dev); 0, sdata);
rcu_read_unlock(); rcu_read_unlock();
sdata->u.sta.mshstats.fwded_frames++; sdata->u.sta.mshstats.fwded_frames++;
return; return;
@ -544,7 +542,7 @@ fail:
return; return;
} }
static void hwmp_perr_frame_process(struct net_device *dev, static void hwmp_perr_frame_process(struct ieee80211_sub_if_data *sdata,
struct ieee80211_mgmt *mgmt, u8 *perr_elem) struct ieee80211_mgmt *mgmt, u8 *perr_elem)
{ {
struct mesh_path *mpath; struct mesh_path *mpath;
@ -555,7 +553,7 @@ static void hwmp_perr_frame_process(struct net_device *dev,
dst_addr = PERR_IE_DST_ADDR(perr_elem); dst_addr = PERR_IE_DST_ADDR(perr_elem);
dst_dsn = PERR_IE_DST_DSN(perr_elem); dst_dsn = PERR_IE_DST_DSN(perr_elem);
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup(dst_addr, dev); mpath = mesh_path_lookup(dst_addr, sdata);
if (mpath) { if (mpath) {
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
if (mpath->flags & MESH_PATH_ACTIVE && if (mpath->flags & MESH_PATH_ACTIVE &&
@ -566,7 +564,7 @@ static void hwmp_perr_frame_process(struct net_device *dev,
mpath->dsn = dst_dsn; mpath->dsn = dst_dsn;
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
mesh_path_error_tx(dst_addr, cpu_to_le32(dst_dsn), mesh_path_error_tx(dst_addr, cpu_to_le32(dst_dsn),
dev->broadcast, dev); sdata->dev->broadcast, sdata);
} else } else
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
} }
@ -575,7 +573,7 @@ static void hwmp_perr_frame_process(struct net_device *dev,
void mesh_rx_path_sel_frame(struct net_device *dev, void mesh_rx_path_sel_frame(struct ieee80211_sub_if_data *sdata,
struct ieee80211_mgmt *mgmt, struct ieee80211_mgmt *mgmt,
size_t len) size_t len)
{ {
@ -592,25 +590,25 @@ void mesh_rx_path_sel_frame(struct net_device *dev,
if (!elems.preq || elems.preq_len != 37) if (!elems.preq || elems.preq_len != 37)
/* Right now we support just 1 destination and no AE */ /* Right now we support just 1 destination and no AE */
return; return;
last_hop_metric = hwmp_route_info_get(dev, mgmt, elems.preq); last_hop_metric = hwmp_route_info_get(sdata, mgmt, elems.preq);
if (!last_hop_metric) if (!last_hop_metric)
return; return;
hwmp_preq_frame_process(dev, mgmt, elems.preq, last_hop_metric); hwmp_preq_frame_process(sdata, mgmt, elems.preq, last_hop_metric);
break; break;
case MPATH_PREP: case MPATH_PREP:
if (!elems.prep || elems.prep_len != 31) if (!elems.prep || elems.prep_len != 31)
/* Right now we support no AE */ /* Right now we support no AE */
return; return;
last_hop_metric = hwmp_route_info_get(dev, mgmt, elems.prep); last_hop_metric = hwmp_route_info_get(sdata, mgmt, elems.prep);
if (!last_hop_metric) if (!last_hop_metric)
return; return;
hwmp_prep_frame_process(dev, mgmt, elems.prep, last_hop_metric); hwmp_prep_frame_process(sdata, mgmt, elems.prep, last_hop_metric);
break; break;
case MPATH_PERR: case MPATH_PERR:
if (!elems.perr || elems.perr_len != 12) if (!elems.perr || elems.perr_len != 12)
/* Right now we support only one destination per PERR */ /* Right now we support only one destination per PERR */
return; return;
hwmp_perr_frame_process(dev, mgmt, elems.perr); hwmp_perr_frame_process(sdata, mgmt, elems.perr);
default: default:
return; return;
} }
@ -628,8 +626,7 @@ void mesh_rx_path_sel_frame(struct net_device *dev,
*/ */
static void mesh_queue_preq(struct mesh_path *mpath, u8 flags) static void mesh_queue_preq(struct mesh_path *mpath, u8 flags)
{ {
struct ieee80211_sub_if_data *sdata = struct ieee80211_sub_if_data *sdata = mpath->sdata;
IEEE80211_DEV_TO_SUB_IF(mpath->dev);
struct ieee80211_if_sta *ifsta = &sdata->u.sta; struct ieee80211_if_sta *ifsta = &sdata->u.sta;
struct mesh_preq_queue *preq_node; struct mesh_preq_queue *preq_node;
@ -672,12 +669,10 @@ static void mesh_queue_preq(struct mesh_path *mpath, u8 flags)
/** /**
* mesh_path_start_discovery - launch a path discovery from the PREQ queue * mesh_path_start_discovery - launch a path discovery from the PREQ queue
* *
* @dev: local mesh interface * @sdata: local mesh subif
*/ */
void mesh_path_start_discovery(struct net_device *dev) void mesh_path_start_discovery(struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata =
IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_if_sta *ifsta = &sdata->u.sta; struct ieee80211_if_sta *ifsta = &sdata->u.sta;
struct mesh_preq_queue *preq_node; struct mesh_preq_queue *preq_node;
struct mesh_path *mpath; struct mesh_path *mpath;
@ -699,7 +694,7 @@ void mesh_path_start_discovery(struct net_device *dev)
spin_unlock(&ifsta->mesh_preq_queue_lock); spin_unlock(&ifsta->mesh_preq_queue_lock);
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup(preq_node->dst, dev); mpath = mesh_path_lookup(preq_node->dst, sdata);
if (!mpath) if (!mpath)
goto enddiscovery; goto enddiscovery;
@ -743,11 +738,11 @@ void mesh_path_start_discovery(struct net_device *dev)
dst_flags = MP_F_RF; dst_flags = MP_F_RF;
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
mesh_path_sel_frame_tx(MPATH_PREQ, 0, dev->dev_addr, mesh_path_sel_frame_tx(MPATH_PREQ, 0, sdata->dev->dev_addr,
cpu_to_le32(ifsta->dsn), dst_flags, mpath->dst, cpu_to_le32(ifsta->dsn), dst_flags, mpath->dst,
cpu_to_le32(mpath->dsn), dev->broadcast, 0, cpu_to_le32(mpath->dsn), sdata->dev->broadcast, 0,
ttl, cpu_to_le32(lifetime), 0, ttl, cpu_to_le32(lifetime), 0,
cpu_to_le32(ifsta->preq_id++), dev); cpu_to_le32(ifsta->preq_id++), sdata);
mod_timer(&mpath->timer, jiffies + mpath->discovery_timeout); mod_timer(&mpath->timer, jiffies + mpath->discovery_timeout);
enddiscovery: enddiscovery:
@ -759,7 +754,7 @@ enddiscovery:
* ieee80211s_lookup_nexthop - put the appropriate next hop on a mesh frame * ieee80211s_lookup_nexthop - put the appropriate next hop on a mesh frame
* *
* @skb: 802.11 frame to be sent * @skb: 802.11 frame to be sent
* @dev: network device the frame will be sent through * @sdata: network subif the frame will be sent through
* @fwd_frame: true if this frame was originally from a different host * @fwd_frame: true if this frame was originally from a different host
* *
* Returns: 0 if the next hop was found. Nonzero otherwise. If no next hop is * Returns: 0 if the next hop was found. Nonzero otherwise. If no next hop is
@ -767,9 +762,9 @@ enddiscovery:
* sent when the path is resolved. This means the caller must not free the skb * sent when the path is resolved. This means the caller must not free the skb
* in this case. * in this case.
*/ */
int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev) int mesh_nexthop_lookup(struct sk_buff *skb,
struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct sk_buff *skb_to_free = NULL; struct sk_buff *skb_to_free = NULL;
struct mesh_path *mpath; struct mesh_path *mpath;
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
@ -777,11 +772,11 @@ int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
int err = 0; int err = 0;
rcu_read_lock(); rcu_read_lock();
mpath = mesh_path_lookup(dst_addr, dev); mpath = mesh_path_lookup(dst_addr, sdata);
if (!mpath) { if (!mpath) {
mesh_path_add(dst_addr, dev); mesh_path_add(dst_addr, sdata);
mpath = mesh_path_lookup(dst_addr, dev); mpath = mesh_path_lookup(dst_addr, sdata);
if (!mpath) { if (!mpath) {
dev_kfree_skb(skb); dev_kfree_skb(skb);
sdata->u.sta.mshstats.dropped_frames_no_route++; sdata->u.sta.mshstats.dropped_frames_no_route++;
@ -793,7 +788,8 @@ int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
if (mpath->flags & MESH_PATH_ACTIVE) { if (mpath->flags & MESH_PATH_ACTIVE) {
if (time_after(jiffies, mpath->exp_time - if (time_after(jiffies, mpath->exp_time -
msecs_to_jiffies(sdata->u.sta.mshcfg.path_refresh_time)) msecs_to_jiffies(sdata->u.sta.mshcfg.path_refresh_time))
&& !memcmp(dev->dev_addr, hdr->addr4, ETH_ALEN) && !memcmp(sdata->dev->dev_addr, hdr->addr4,
ETH_ALEN)
&& !(mpath->flags & MESH_PATH_RESOLVING) && !(mpath->flags & MESH_PATH_RESOLVING)
&& !(mpath->flags & MESH_PATH_FIXED)) { && !(mpath->flags & MESH_PATH_FIXED)) {
mesh_queue_preq(mpath, mesh_queue_preq(mpath,
@ -815,7 +811,7 @@ int mesh_nexthop_lookup(struct sk_buff *skb, struct net_device *dev)
skb_queue_tail(&mpath->frame_queue, skb); skb_queue_tail(&mpath->frame_queue, skb);
if (skb_to_free) if (skb_to_free)
mesh_path_discard_frame(skb_to_free, dev); mesh_path_discard_frame(skb_to_free, sdata);
err = -ENOENT; err = -ENOENT;
} }
@ -835,7 +831,7 @@ void mesh_path_timer(unsigned long data)
if (!mpath) if (!mpath)
goto endmpathtimer; goto endmpathtimer;
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
sdata = IEEE80211_DEV_TO_SUB_IF(mpath->dev); sdata = mpath->sdata;
if (mpath->flags & MESH_PATH_RESOLVED || if (mpath->flags & MESH_PATH_RESOLVED ||
(!(mpath->flags & MESH_PATH_RESOLVING))) (!(mpath->flags & MESH_PATH_RESOLVING)))
mpath->flags &= ~(MESH_PATH_RESOLVING | MESH_PATH_RESOLVED); mpath->flags &= ~(MESH_PATH_RESOLVING | MESH_PATH_RESOLVED);

76
net/mac80211/mesh_pathtbl.c
View File

@ -9,7 +9,6 @@
#include <linux/etherdevice.h> #include <linux/etherdevice.h>
#include <linux/list.h> #include <linux/list.h>
#include <linux/netdevice.h>
#include <linux/random.h> #include <linux/random.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <linux/string.h> #include <linux/string.h>
@ -62,13 +61,13 @@ void mesh_path_assign_nexthop(struct mesh_path *mpath, struct sta_info *sta)
/** /**
* mesh_path_lookup - look up a path in the mesh path table * mesh_path_lookup - look up a path in the mesh path table
* @dst: hardware address (ETH_ALEN length) of destination * @dst: hardware address (ETH_ALEN length) of destination
* @dev: local interface * @sdata: local subif
* *
* Returns: pointer to the mesh path structure, or NULL if not found * Returns: pointer to the mesh path structure, or NULL if not found
* *
* Locking: must be called within a read rcu section. * Locking: must be called within a read rcu section.
*/ */
struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev) struct mesh_path *mesh_path_lookup(u8 *dst, struct ieee80211_sub_if_data *sdata)
{ {
struct mesh_path *mpath; struct mesh_path *mpath;
struct hlist_node *n; struct hlist_node *n;
@ -78,10 +77,10 @@ struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev)
tbl = rcu_dereference(mesh_paths); tbl = rcu_dereference(mesh_paths);
bucket = &tbl->hash_buckets[mesh_table_hash(dst, dev, tbl)]; bucket = &tbl->hash_buckets[mesh_table_hash(dst, sdata, tbl)];
hlist_for_each_entry_rcu(node, n, bucket, list) { hlist_for_each_entry_rcu(node, n, bucket, list) {
mpath = node->mpath; mpath = node->mpath;
if (mpath->dev == dev && if (mpath->sdata == sdata &&
memcmp(dst, mpath->dst, ETH_ALEN) == 0) { memcmp(dst, mpath->dst, ETH_ALEN) == 0) {
if (MPATH_EXPIRED(mpath)) { if (MPATH_EXPIRED(mpath)) {
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
@ -98,13 +97,13 @@ struct mesh_path *mesh_path_lookup(u8 *dst, struct net_device *dev)
/** /**
* mesh_path_lookup_by_idx - look up a path in the mesh path table by its index * mesh_path_lookup_by_idx - look up a path in the mesh path table by its index
* @idx: index * @idx: index
* @dev: local interface, or NULL for all entries * @sdata: local subif, or NULL for all entries
* *
* Returns: pointer to the mesh path structure, or NULL if not found. * Returns: pointer to the mesh path structure, or NULL if not found.
* *
* Locking: must be called within a read rcu section. * Locking: must be called within a read rcu section.
*/ */
struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev) struct mesh_path *mesh_path_lookup_by_idx(int idx, struct ieee80211_sub_if_data *sdata)
{ {
struct mpath_node *node; struct mpath_node *node;
struct hlist_node *p; struct hlist_node *p;
@ -112,7 +111,7 @@ struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev)
int j = 0; int j = 0;
for_each_mesh_entry(mesh_paths, p, node, i) { for_each_mesh_entry(mesh_paths, p, node, i) {
if (dev && node->mpath->dev != dev) if (sdata && node->mpath->sdata != sdata)
continue; continue;
if (j++ == idx) { if (j++ == idx) {
if (MPATH_EXPIRED(node->mpath)) { if (MPATH_EXPIRED(node->mpath)) {
@ -131,15 +130,14 @@ struct mesh_path *mesh_path_lookup_by_idx(int idx, struct net_device *dev)
/** /**
* mesh_path_add - allocate and add a new path to the mesh path table * mesh_path_add - allocate and add a new path to the mesh path table
* @addr: destination address of the path (ETH_ALEN length) * @addr: destination address of the path (ETH_ALEN length)
* @dev: local interface * @sdata: local subif
* *
* Returns: 0 on sucess * Returns: 0 on sucess
* *
* State: the initial state of the new path is set to 0 * State: the initial state of the new path is set to 0
*/ */
int mesh_path_add(u8 *dst, struct net_device *dev) int mesh_path_add(u8 *dst, struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct mesh_path *mpath, *new_mpath; struct mesh_path *mpath, *new_mpath;
struct mpath_node *node, *new_node; struct mpath_node *node, *new_node;
struct hlist_head *bucket; struct hlist_head *bucket;
@ -148,7 +146,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
int err = 0; int err = 0;
u32 hash_idx; u32 hash_idx;
if (memcmp(dst, dev->dev_addr, ETH_ALEN) == 0) if (memcmp(dst, sdata->dev->dev_addr, ETH_ALEN) == 0)
/* never add ourselves as neighbours */ /* never add ourselves as neighbours */
return -ENOTSUPP; return -ENOTSUPP;
@ -169,7 +167,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
read_lock(&pathtbl_resize_lock); read_lock(&pathtbl_resize_lock);
memcpy(new_mpath->dst, dst, ETH_ALEN); memcpy(new_mpath->dst, dst, ETH_ALEN);
new_mpath->dev = dev; new_mpath->sdata = sdata;
new_mpath->flags = 0; new_mpath->flags = 0;
skb_queue_head_init(&new_mpath->frame_queue); skb_queue_head_init(&new_mpath->frame_queue);
new_node->mpath = new_mpath; new_node->mpath = new_mpath;
@ -179,7 +177,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
spin_lock_init(&new_mpath->state_lock); spin_lock_init(&new_mpath->state_lock);
init_timer(&new_mpath->timer); init_timer(&new_mpath->timer);
hash_idx = mesh_table_hash(dst, dev, mesh_paths); hash_idx = mesh_table_hash(dst, sdata, mesh_paths);
bucket = &mesh_paths->hash_buckets[hash_idx]; bucket = &mesh_paths->hash_buckets[hash_idx];
spin_lock(&mesh_paths->hashwlock[hash_idx]); spin_lock(&mesh_paths->hashwlock[hash_idx]);
@ -187,7 +185,7 @@ int mesh_path_add(u8 *dst, struct net_device *dev)
err = -EEXIST; err = -EEXIST;
hlist_for_each_entry(node, n, bucket, list) { hlist_for_each_entry(node, n, bucket, list) {
mpath = node->mpath; mpath = node->mpath;
if (mpath->dev == dev && memcmp(dst, mpath->dst, ETH_ALEN) == 0) if (mpath->sdata == sdata && memcmp(dst, mpath->dst, ETH_ALEN) == 0)
goto err_exists; goto err_exists;
} }
@ -241,7 +239,7 @@ void mesh_plink_broken(struct sta_info *sta)
struct mesh_path *mpath; struct mesh_path *mpath;
struct mpath_node *node; struct mpath_node *node;
struct hlist_node *p; struct hlist_node *p;
struct net_device *dev = sta->sdata->dev; struct ieee80211_sub_if_data *sdata = sta->sdata;
int i; int i;
rcu_read_lock(); rcu_read_lock();
@ -256,7 +254,7 @@ void mesh_plink_broken(struct sta_info *sta)
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
mesh_path_error_tx(mpath->dst, mesh_path_error_tx(mpath->dst,
cpu_to_le32(mpath->dsn), cpu_to_le32(mpath->dsn),
dev->broadcast, dev); sdata->dev->broadcast, sdata);
} else } else
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
} }
@ -284,11 +282,11 @@ void mesh_path_flush_by_nexthop(struct sta_info *sta)
for_each_mesh_entry(mesh_paths, p, node, i) { for_each_mesh_entry(mesh_paths, p, node, i) {
mpath = node->mpath; mpath = node->mpath;
if (mpath->next_hop == sta) if (mpath->next_hop == sta)
mesh_path_del(mpath->dst, mpath->dev); mesh_path_del(mpath->dst, mpath->sdata);
} }
} }
void mesh_path_flush(struct net_device *dev) void mesh_path_flush(struct ieee80211_sub_if_data *sdata)
{ {
struct mesh_path *mpath; struct mesh_path *mpath;
struct mpath_node *node; struct mpath_node *node;
@ -297,16 +295,15 @@ void mesh_path_flush(struct net_device *dev)
for_each_mesh_entry(mesh_paths, p, node, i) { for_each_mesh_entry(mesh_paths, p, node, i) {
mpath = node->mpath; mpath = node->mpath;
if (mpath->dev == dev) if (mpath->sdata == sdata)
mesh_path_del(mpath->dst, mpath->dev); mesh_path_del(mpath->dst, mpath->sdata);
} }
} }
static void mesh_path_node_reclaim(struct rcu_head *rp) static void mesh_path_node_reclaim(struct rcu_head *rp)
{ {
struct mpath_node *node = container_of(rp, struct mpath_node, rcu); struct mpath_node *node = container_of(rp, struct mpath_node, rcu);
struct ieee80211_sub_if_data *sdata = struct ieee80211_sub_if_data *sdata = node->mpath->sdata;
IEEE80211_DEV_TO_SUB_IF(node->mpath->dev);
del_timer_sync(&node->mpath->timer); del_timer_sync(&node->mpath->timer);
atomic_dec(&sdata->u.sta.mpaths); atomic_dec(&sdata->u.sta.mpaths);
@ -318,11 +315,11 @@ static void mesh_path_node_reclaim(struct rcu_head *rp)
* mesh_path_del - delete a mesh path from the table * mesh_path_del - delete a mesh path from the table
* *
* @addr: dst address (ETH_ALEN length) * @addr: dst address (ETH_ALEN length)
* @dev: local interface * @sdata: local subif
* *
* Returns: 0 if succesful * Returns: 0 if succesful
*/ */
int mesh_path_del(u8 *addr, struct net_device *dev) int mesh_path_del(u8 *addr, struct ieee80211_sub_if_data *sdata)
{ {
struct mesh_path *mpath; struct mesh_path *mpath;
struct mpath_node *node; struct mpath_node *node;
@ -332,13 +329,13 @@ int mesh_path_del(u8 *addr, struct net_device *dev)
int err = 0; int err = 0;
read_lock(&pathtbl_resize_lock); read_lock(&pathtbl_resize_lock);
hash_idx = mesh_table_hash(addr, dev, mesh_paths); hash_idx = mesh_table_hash(addr, sdata, mesh_paths);
bucket = &mesh_paths->hash_buckets[hash_idx]; bucket = &mesh_paths->hash_buckets[hash_idx];
spin_lock(&mesh_paths->hashwlock[hash_idx]); spin_lock(&mesh_paths->hashwlock[hash_idx]);
hlist_for_each_entry(node, n, bucket, list) { hlist_for_each_entry(node, n, bucket, list) {
mpath = node->mpath; mpath = node->mpath;
if (mpath->dev == dev && if (mpath->sdata == sdata &&
memcmp(addr, mpath->dst, ETH_ALEN) == 0) { memcmp(addr, mpath->dst, ETH_ALEN) == 0) {
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
mpath->flags |= MESH_PATH_RESOLVING; mpath->flags |= MESH_PATH_RESOLVING;
@ -378,29 +375,29 @@ void mesh_path_tx_pending(struct mesh_path *mpath)
* mesh_path_discard_frame - discard a frame whose path could not be resolved * mesh_path_discard_frame - discard a frame whose path could not be resolved
* *
* @skb: frame to discard * @skb: frame to discard
* @dev: network device the frame was to be sent through * @sdata: network subif the frame was to be sent through
* *
* If the frame was beign forwarded from another MP, a PERR frame will be sent * If the frame was beign forwarded from another MP, a PERR frame will be sent
* to the precursor. * to the precursor.
* *
* Locking: the function must me called within a rcu_read_lock region * Locking: the function must me called within a rcu_read_lock region
*/ */
void mesh_path_discard_frame(struct sk_buff *skb, struct net_device *dev) void mesh_path_discard_frame(struct sk_buff *skb,
struct ieee80211_sub_if_data *sdata)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
struct mesh_path *mpath; struct mesh_path *mpath;
u32 dsn = 0; u32 dsn = 0;
if (memcmp(hdr->addr4, dev->dev_addr, ETH_ALEN) != 0) { if (memcmp(hdr->addr4, sdata->dev->dev_addr, ETH_ALEN) != 0) {
u8 *ra, *da; u8 *ra, *da;
da = hdr->addr3; da = hdr->addr3;
ra = hdr->addr2; ra = hdr->addr2;
mpath = mesh_path_lookup(da, dev); mpath = mesh_path_lookup(da, sdata);
if (mpath) if (mpath)
dsn = ++mpath->dsn; dsn = ++mpath->dsn;
mesh_path_error_tx(skb->data, cpu_to_le32(dsn), ra, dev); mesh_path_error_tx(skb->data, cpu_to_le32(dsn), ra, sdata);
} }
kfree_skb(skb); kfree_skb(skb);
@ -416,14 +413,11 @@ void mesh_path_discard_frame(struct sk_buff *skb, struct net_device *dev)
*/ */
void mesh_path_flush_pending(struct mesh_path *mpath) void mesh_path_flush_pending(struct mesh_path *mpath)
{ {
struct ieee80211_sub_if_data *sdata;
struct sk_buff *skb; struct sk_buff *skb;
sdata = IEEE80211_DEV_TO_SUB_IF(mpath->dev);
while ((skb = skb_dequeue(&mpath->frame_queue)) && while ((skb = skb_dequeue(&mpath->frame_queue)) &&
(mpath->flags & MESH_PATH_ACTIVE)) (mpath->flags & MESH_PATH_ACTIVE))
mesh_path_discard_frame(skb, mpath->dev); mesh_path_discard_frame(skb, mpath->sdata);
} }
/** /**
@ -472,7 +466,7 @@ static int mesh_path_node_copy(struct hlist_node *p, struct mesh_table *newtbl)
node = hlist_entry(p, struct mpath_node, list); node = hlist_entry(p, struct mpath_node, list);
mpath = node->mpath; mpath = node->mpath;
new_node->mpath = mpath; new_node->mpath = mpath;
hash_idx = mesh_table_hash(mpath->dst, mpath->dev, newtbl); hash_idx = mesh_table_hash(mpath->dst, mpath->sdata, newtbl);
hlist_add_head(&new_node->list, hlist_add_head(&new_node->list,
&newtbl->hash_buckets[hash_idx]); &newtbl->hash_buckets[hash_idx]);
return 0; return 0;
@ -489,7 +483,7 @@ int mesh_pathtbl_init(void)
return 0; return 0;
} }
void mesh_path_expire(struct net_device *dev) void mesh_path_expire(struct ieee80211_sub_if_data *sdata)
{ {
struct mesh_path *mpath; struct mesh_path *mpath;
struct mpath_node *node; struct mpath_node *node;
@ -498,7 +492,7 @@ void mesh_path_expire(struct net_device *dev)
read_lock(&pathtbl_resize_lock); read_lock(&pathtbl_resize_lock);
for_each_mesh_entry(mesh_paths, p, node, i) { for_each_mesh_entry(mesh_paths, p, node, i) {
if (node->mpath->dev != dev) if (node->mpath->sdata != sdata)
continue; continue;
mpath = node->mpath; mpath = node->mpath;
spin_lock_bh(&mpath->state_lock); spin_lock_bh(&mpath->state_lock);
@ -507,7 +501,7 @@ void mesh_path_expire(struct net_device *dev)
time_after(jiffies, time_after(jiffies,
mpath->exp_time + MESH_PATH_EXPIRE)) { mpath->exp_time + MESH_PATH_EXPIRE)) {
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
mesh_path_del(mpath->dst, mpath->dev); mesh_path_del(mpath->dst, mpath->sdata);
} else } else
spin_unlock_bh(&mpath->state_lock); spin_unlock_bh(&mpath->state_lock);
} }

52
net/mac80211/mesh_plink.c
View File

@ -144,10 +144,10 @@ void mesh_plink_deactivate(struct sta_info *sta)
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
} }
static int mesh_plink_frame_tx(struct net_device *dev, static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid, enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid,
__le16 reason) { __le16 reason) {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400); struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
struct ieee80211_mgmt *mgmt; struct ieee80211_mgmt *mgmt;
bool include_plid = false; bool include_plid = false;
@ -166,7 +166,7 @@ static int mesh_plink_frame_tx(struct net_device *dev,
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
IEEE80211_STYPE_ACTION); IEEE80211_STYPE_ACTION);
memcpy(mgmt->da, da, ETH_ALEN); memcpy(mgmt->da, da, ETH_ALEN);
memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN); memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
/* BSSID is left zeroed, wildcard value */ /* BSSID is left zeroed, wildcard value */
mgmt->u.action.category = PLINK_CATEGORY; mgmt->u.action.category = PLINK_CATEGORY;
mgmt->u.action.u.plink_action.action_code = action; mgmt->u.action.u.plink_action.action_code = action;
@ -180,7 +180,7 @@ static int mesh_plink_frame_tx(struct net_device *dev,
/* two-byte status code followed by two-byte AID */ /* two-byte status code followed by two-byte AID */
memset(pos, 0, 4); memset(pos, 0, 4);
} }
mesh_mgmt_ies_add(skb, dev); mesh_mgmt_ies_add(skb, sdata);
} }
/* Add Peer Link Management element */ /* Add Peer Link Management element */
@ -217,15 +217,14 @@ static int mesh_plink_frame_tx(struct net_device *dev,
memcpy(pos, &reason, 2); memcpy(pos, &reason, 2);
} }
ieee80211_sta_tx(dev, skb, 0); ieee80211_sta_tx(sdata, skb, 0);
return 0; return 0;
} }
void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct net_device *dev, void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct ieee80211_sub_if_data *sdata,
bool peer_accepting_plinks) bool peer_accepting_plinks)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); struct ieee80211_local *local = sdata->local;
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct sta_info *sta; struct sta_info *sta;
rcu_read_lock(); rcu_read_lock();
@ -257,7 +256,6 @@ static void mesh_plink_timer(unsigned long data)
{ {
struct sta_info *sta; struct sta_info *sta;
__le16 llid, plid, reason; __le16 llid, plid, reason;
struct net_device *dev = NULL;
struct ieee80211_sub_if_data *sdata; struct ieee80211_sub_if_data *sdata;
#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
DECLARE_MAC_BUF(mac); DECLARE_MAC_BUF(mac);
@ -282,7 +280,6 @@ static void mesh_plink_timer(unsigned long data)
llid = sta->llid; llid = sta->llid;
plid = sta->plid; plid = sta->plid;
sdata = sta->sdata; sdata = sta->sdata;
dev = sdata->dev;
switch (sta->plink_state) { switch (sta->plink_state) {
case PLINK_OPN_RCVD: case PLINK_OPN_RCVD:
@ -299,7 +296,7 @@ static void mesh_plink_timer(unsigned long data)
++sta->plink_retries; ++sta->plink_retries;
mod_plink_timer(sta, sta->plink_timeout); mod_plink_timer(sta, sta->plink_timeout);
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->addr, llid,
0, 0); 0, 0);
break; break;
} }
@ -312,7 +309,7 @@ static void mesh_plink_timer(unsigned long data)
sta->plink_state = PLINK_HOLDING; sta->plink_state = PLINK_HOLDING;
mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)); mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, plid, mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid, plid,
reason); reason);
break; break;
case PLINK_HOLDING: case PLINK_HOLDING:
@ -357,7 +354,7 @@ int mesh_plink_open(struct sta_info *sta)
mpl_dbg("Mesh plink: starting establishment with %s\n", mpl_dbg("Mesh plink: starting establishment with %s\n",
print_mac(mac, sta->addr)); print_mac(mac, sta->addr));
return mesh_plink_frame_tx(sdata->dev, PLINK_OPEN, return mesh_plink_frame_tx(sdata, PLINK_OPEN,
sta->addr, llid, 0, 0); sta->addr, llid, 0, 0);
} }
@ -403,15 +400,14 @@ int mesh_plink_close(struct sta_info *sta)
llid = sta->llid; llid = sta->llid;
plid = sta->plid; plid = sta->plid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(sta->sdata->dev, PLINK_CLOSE, sta->addr, llid, mesh_plink_frame_tx(sta->sdata, PLINK_CLOSE, sta->addr, llid,
plid, reason); plid, reason);
return 0; return 0;
} }
void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt, void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
size_t len, struct ieee80211_rx_status *rx_status) size_t len, struct ieee80211_rx_status *rx_status)
{ {
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_local *local = sdata->local; struct ieee80211_local *local = sdata->local;
struct ieee802_11_elems elems; struct ieee802_11_elems elems;
struct sta_info *sta; struct sta_info *sta;
@ -478,7 +474,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
/* Now we will figure out the appropriate event... */ /* Now we will figure out the appropriate event... */
event = PLINK_UNDEFINED; event = PLINK_UNDEFINED;
if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, dev))) { if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, sdata))) {
switch (ftype) { switch (ftype) {
case PLINK_OPEN: case PLINK_OPEN:
event = OPN_RJCT; event = OPN_RJCT;
@ -577,9 +573,9 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
sta->llid = llid; sta->llid = llid;
mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata)); mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->addr, llid,
0, 0); 0, 0);
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr,
llid, plid, 0); llid, plid, 0);
break; break;
default: default:
@ -604,7 +600,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
llid = sta->llid; llid = sta->llid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
plid, reason); plid, reason);
break; break;
case OPN_ACPT: case OPN_ACPT:
@ -613,7 +609,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
sta->plid = plid; sta->plid = plid;
llid = sta->llid; llid = sta->llid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
plid, 0); plid, 0);
break; break;
case CNF_ACPT: case CNF_ACPT:
@ -646,13 +642,13 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
llid = sta->llid; llid = sta->llid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
plid, reason); plid, reason);
break; break;
case OPN_ACPT: case OPN_ACPT:
llid = sta->llid; llid = sta->llid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
plid, 0); plid, 0);
break; break;
case CNF_ACPT: case CNF_ACPT:
@ -685,7 +681,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
llid = sta->llid; llid = sta->llid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
plid, reason); plid, reason);
break; break;
case OPN_ACPT: case OPN_ACPT:
@ -695,7 +691,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mpl_dbg("Mesh plink with %s ESTABLISHED\n", mpl_dbg("Mesh plink with %s ESTABLISHED\n",
print_mac(mac, sta->addr)); print_mac(mac, sta->addr));
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
plid, 0); plid, 0);
break; break;
default: default:
@ -714,13 +710,13 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
llid = sta->llid; llid = sta->llid;
mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)); mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
plid, reason); plid, reason);
break; break;
case OPN_ACPT: case OPN_ACPT:
llid = sta->llid; llid = sta->llid;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->addr, llid,
plid, 0); plid, 0);
break; break;
default: default:
@ -743,7 +739,7 @@ void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
llid = sta->llid; llid = sta->llid;
reason = sta->reason; reason = sta->reason;
spin_unlock_bh(&sta->lock); spin_unlock_bh(&sta->lock);
mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->addr, llid,
plid, reason); plid, reason);
break; break;
default: default:

652
net/mac80211/mlme.c
View File

File diff suppressed because it is too large Load Diff

16
net/mac80211/rx.c
View File

@ -404,11 +404,11 @@ ieee80211_rx_h_passive_scan(struct ieee80211_rx_data *rx)
struct sk_buff *skb = rx->skb; struct sk_buff *skb = rx->skb;
if (unlikely(local->sta_hw_scanning)) if (unlikely(local->sta_hw_scanning))
return ieee80211_sta_rx_scan(rx->dev, skb, rx->status); return ieee80211_sta_rx_scan(rx->sdata, skb, rx->status);
if (unlikely(local->sta_sw_scanning)) { if (unlikely(local->sta_sw_scanning)) {
/* drop all the other packets during a software scan anyway */ /* drop all the other packets during a software scan anyway */
if (ieee80211_sta_rx_scan(rx->dev, skb, rx->status) if (ieee80211_sta_rx_scan(rx->sdata, skb, rx->status)
!= RX_QUEUED) != RX_QUEUED)
dev_kfree_skb(skb); dev_kfree_skb(skb);
return RX_QUEUED; return RX_QUEUED;
@ -466,7 +466,7 @@ ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
if (ieee80211_is_data(hdr->frame_control) && if (ieee80211_is_data(hdr->frame_control) &&
is_multicast_ether_addr(hdr->addr1) && is_multicast_ether_addr(hdr->addr1) &&
mesh_rmc_check(hdr->addr4, msh_h_get(hdr, hdrlen), rx->dev)) mesh_rmc_check(hdr->addr4, msh_h_get(hdr, hdrlen), rx->sdata))
return RX_DROP_MONITOR; return RX_DROP_MONITOR;
#undef msh_h_get #undef msh_h_get
@ -1523,7 +1523,7 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
sdata->vif.type == IEEE80211_IF_TYPE_IBSS || sdata->vif.type == IEEE80211_IF_TYPE_IBSS ||
sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT) && sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT) &&
!(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME)) !(sdata->flags & IEEE80211_SDATA_USERSPACE_MLME))
ieee80211_sta_rx_mgmt(rx->dev, rx->skb, rx->status); ieee80211_sta_rx_mgmt(sdata, rx->skb, rx->status);
else else
return RX_DROP_MONITOR; return RX_DROP_MONITOR;
@ -1570,7 +1570,7 @@ static void ieee80211_rx_michael_mic_report(struct net_device *dev,
!ieee80211_is_auth(hdr->frame_control)) !ieee80211_is_auth(hdr->frame_control))
goto ignore; goto ignore;
mac80211_ev_michael_mic_failure(rx->dev, keyidx, hdr); mac80211_ev_michael_mic_failure(rx->sdata, keyidx, hdr);
ignore: ignore:
dev_kfree_skb(rx->skb); dev_kfree_skb(rx->skb);
rx->skb = NULL; rx->skb = NULL;
@ -1744,7 +1744,7 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
return 0; return 0;
if (ieee80211_is_beacon(hdr->frame_control)) { if (ieee80211_is_beacon(hdr->frame_control)) {
if (!rx->sta) if (!rx->sta)
rx->sta = ieee80211_ibss_add_sta(sdata->dev, rx->sta = ieee80211_ibss_add_sta(sdata,
rx->skb, bssid, hdr->addr2, rx->skb, bssid, hdr->addr2,
BIT(rx->status->rate_idx)); BIT(rx->status->rate_idx));
return 1; return 1;
@ -1760,7 +1760,7 @@ static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
return 0; return 0;
rx->flags &= ~IEEE80211_RX_RA_MATCH; rx->flags &= ~IEEE80211_RX_RA_MATCH;
} else if (!rx->sta) } else if (!rx->sta)
rx->sta = ieee80211_ibss_add_sta(sdata->dev, rx->skb, rx->sta = ieee80211_ibss_add_sta(sdata, rx->skb,
bssid, hdr->addr2, bssid, hdr->addr2,
BIT(rx->status->rate_idx)); BIT(rx->status->rate_idx));
break; break;
@ -2066,7 +2066,7 @@ static u8 ieee80211_rx_reorder_ampdu(struct ieee80211_local *local,
/* if this mpdu is fragmented - terminate rx aggregation session */ /* if this mpdu is fragmented - terminate rx aggregation session */
sc = le16_to_cpu(hdr->seq_ctrl); sc = le16_to_cpu(hdr->seq_ctrl);
if (sc & IEEE80211_SCTL_FRAG) { if (sc & IEEE80211_SCTL_FRAG) {
ieee80211_sta_stop_rx_ba_session(sta->sdata->dev, sta->addr, ieee80211_sta_stop_rx_ba_session(sta->sdata, sta->addr,
tid, 0, WLAN_REASON_QSTA_REQUIRE_SETUP); tid, 0, WLAN_REASON_QSTA_REQUIRE_SETUP);
ret = 1; ret = 1;
goto end_reorder; goto end_reorder;

4
net/mac80211/tx.c
View File

@ -1327,7 +1327,7 @@ int ieee80211_master_start_xmit(struct sk_buff *skb,
if (is_multicast_ether_addr(hdr->addr3)) if (is_multicast_ether_addr(hdr->addr3))
memcpy(hdr->addr1, hdr->addr3, ETH_ALEN); memcpy(hdr->addr1, hdr->addr3, ETH_ALEN);
else else
if (mesh_nexthop_lookup(skb, odev)) if (mesh_nexthop_lookup(skb, osdata))
return 0; return 0;
if (memcmp(odev->dev_addr, hdr->addr4, ETH_ALEN) != 0) if (memcmp(odev->dev_addr, hdr->addr4, ETH_ALEN) != 0)
IEEE80211_IFSTA_MESH_CTR_INC(&osdata->u.sta, IEEE80211_IFSTA_MESH_CTR_INC(&osdata->u.sta,
@ -1908,7 +1908,7 @@ struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
*pos++ = WLAN_EID_SSID; *pos++ = WLAN_EID_SSID;
*pos++ = 0x0; *pos++ = 0x0;
mesh_mgmt_ies_add(skb, sdata->dev); mesh_mgmt_ies_add(skb, sdata);
num_beacons = &sdata->u.sta.num_beacons; num_beacons = &sdata->u.sta.num_beacons;
} else { } else {

49
net/mac80211/wext.c
View File

@ -27,22 +27,19 @@
#include "aes_ccm.h" #include "aes_ccm.h"
static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr, static int ieee80211_set_encryption(struct ieee80211_sub_if_data *sdata, u8 *sta_addr,
int idx, int alg, int remove, int idx, int alg, int remove,
int set_tx_key, const u8 *_key, int set_tx_key, const u8 *_key,
size_t key_len) size_t key_len)
{ {
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct sta_info *sta; struct sta_info *sta;
struct ieee80211_key *key; struct ieee80211_key *key;
struct ieee80211_sub_if_data *sdata;
int err; int err;
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
if (idx < 0 || idx >= NUM_DEFAULT_KEYS) { if (idx < 0 || idx >= NUM_DEFAULT_KEYS) {
printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n", printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
dev->name, idx); sdata->dev->name, idx);
return -EINVAL; return -EINVAL;
} }
@ -127,11 +124,11 @@ static int ieee80211_ioctl_siwgenie(struct net_device *dev,
if (sdata->vif.type == IEEE80211_IF_TYPE_STA || if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
sdata->vif.type == IEEE80211_IF_TYPE_IBSS) { sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length); int ret = ieee80211_sta_set_extra_ie(sdata, extra, data->length);
if (ret) if (ret)
return ret; return ret;
sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL; sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
ieee80211_sta_req_auth(dev, &sdata->u.sta); ieee80211_sta_req_auth(sdata, &sdata->u.sta);
return 0; return 0;
} }
@ -333,12 +330,11 @@ static int ieee80211_ioctl_giwmode(struct net_device *dev,
return 0; return 0;
} }
int ieee80211_set_freq(struct net_device *dev, int freqMHz) int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freqMHz)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct ieee80211_channel *chan; struct ieee80211_channel *chan;
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = sdata->local;
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
chan = ieee80211_get_channel(local->hw.wiphy, freqMHz); chan = ieee80211_get_channel(local->hw.wiphy, freqMHz);
@ -346,7 +342,7 @@ int ieee80211_set_freq(struct net_device *dev, int freqMHz)
if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS && if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS &&
chan->flags & IEEE80211_CHAN_NO_IBSS) { chan->flags & IEEE80211_CHAN_NO_IBSS) {
printk(KERN_DEBUG "%s: IBSS not allowed on frequency " printk(KERN_DEBUG "%s: IBSS not allowed on frequency "
"%d MHz\n", dev->name, chan->center_freq); "%d MHz\n", sdata->dev->name, chan->center_freq);
return ret; return ret;
} }
local->oper_channel = chan; local->oper_channel = chan;
@ -379,14 +375,14 @@ static int ieee80211_ioctl_siwfreq(struct net_device *dev,
IEEE80211_STA_AUTO_CHANNEL_SEL; IEEE80211_STA_AUTO_CHANNEL_SEL;
return 0; return 0;
} else } else
return ieee80211_set_freq(dev, return ieee80211_set_freq(sdata,
ieee80211_channel_to_frequency(freq->m)); ieee80211_channel_to_frequency(freq->m));
} else { } else {
int i, div = 1000000; int i, div = 1000000;
for (i = 0; i < freq->e; i++) for (i = 0; i < freq->e; i++)
div /= 10; div /= 10;
if (div > 0) if (div > 0)
return ieee80211_set_freq(dev, freq->m / div); return ieee80211_set_freq(sdata, freq->m / div);
else else
return -EINVAL; return -EINVAL;
} }
@ -432,10 +428,10 @@ static int ieee80211_ioctl_siwessid(struct net_device *dev,
sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL; sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
else else
sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL; sdata->u.sta.flags |= IEEE80211_STA_AUTO_SSID_SEL;
ret = ieee80211_sta_set_ssid(dev, ssid, len); ret = ieee80211_sta_set_ssid(sdata, ssid, len);
if (ret) if (ret)
return ret; return ret;
ieee80211_sta_req_auth(dev, &sdata->u.sta); ieee80211_sta_req_auth(sdata, &sdata->u.sta);
return 0; return 0;
} }
@ -460,7 +456,7 @@ static int ieee80211_ioctl_giwessid(struct net_device *dev,
sdata = IEEE80211_DEV_TO_SUB_IF(dev); sdata = IEEE80211_DEV_TO_SUB_IF(dev);
if (sdata->vif.type == IEEE80211_IF_TYPE_STA || if (sdata->vif.type == IEEE80211_IF_TYPE_STA ||
sdata->vif.type == IEEE80211_IF_TYPE_IBSS) { sdata->vif.type == IEEE80211_IF_TYPE_IBSS) {
int res = ieee80211_sta_get_ssid(dev, ssid, &len); int res = ieee80211_sta_get_ssid(sdata, ssid, &len);
if (res == 0) { if (res == 0) {
data->length = len; data->length = len;
data->flags = 1; data->flags = 1;
@ -504,10 +500,10 @@ static int ieee80211_ioctl_siwap(struct net_device *dev,
sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL; sdata->u.sta.flags |= IEEE80211_STA_AUTO_BSSID_SEL;
else else
sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL; sdata->u.sta.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data); ret = ieee80211_sta_set_bssid(sdata, (u8 *) &ap_addr->sa_data);
if (ret) if (ret)
return ret; return ret;
ieee80211_sta_req_auth(dev, &sdata->u.sta); ieee80211_sta_req_auth(sdata, &sdata->u.sta);
return 0; return 0;
} else if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) { } else if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) {
/* /*
@ -584,7 +580,7 @@ static int ieee80211_ioctl_siwscan(struct net_device *dev,
ssid_len = req->essid_len; ssid_len = req->essid_len;
} }
return ieee80211_sta_req_scan(dev, ssid, ssid_len); return ieee80211_sta_req_scan(sdata, ssid, ssid_len);
} }
@ -594,11 +590,14 @@ static int ieee80211_ioctl_giwscan(struct net_device *dev,
{ {
int res; int res;
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sub_if_data *sdata;
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
if (local->sta_sw_scanning || local->sta_hw_scanning) if (local->sta_sw_scanning || local->sta_hw_scanning)
return -EAGAIN; return -EAGAIN;
res = ieee80211_sta_scan_results(dev, info, extra, data->length); res = ieee80211_sta_scan_results(local, info, extra, data->length);
if (res >= 0) { if (res >= 0) {
data->length = res; data->length = res;
return 0; return 0;
@ -894,10 +893,10 @@ static int ieee80211_ioctl_siwmlme(struct net_device *dev,
switch (mlme->cmd) { switch (mlme->cmd) {
case IW_MLME_DEAUTH: case IW_MLME_DEAUTH:
/* TODO: mlme->addr.sa_data */ /* TODO: mlme->addr.sa_data */
return ieee80211_sta_deauthenticate(dev, mlme->reason_code); return ieee80211_sta_deauthenticate(sdata, mlme->reason_code);
case IW_MLME_DISASSOC: case IW_MLME_DISASSOC:
/* TODO: mlme->addr.sa_data */ /* TODO: mlme->addr.sa_data */
return ieee80211_sta_disassociate(dev, mlme->reason_code); return ieee80211_sta_disassociate(sdata, mlme->reason_code);
default: default:
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
@ -938,7 +937,7 @@ static int ieee80211_ioctl_siwencode(struct net_device *dev,
} }
return ieee80211_set_encryption( return ieee80211_set_encryption(
dev, bcaddr, sdata, bcaddr,
idx, alg, remove, idx, alg, remove,
!sdata->default_key, !sdata->default_key,
keybuf, erq->length); keybuf, erq->length);
@ -1184,7 +1183,7 @@ static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
} else } else
idx--; idx--;
return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg, return ieee80211_set_encryption(sdata, ext->addr.sa_data, idx, alg,
remove, remove,
ext->ext_flags & ext->ext_flags &
IW_ENCODE_EXT_SET_TX_KEY, IW_ENCODE_EXT_SET_TX_KEY,

2
net/mac80211/wpa.c
View File

@ -127,7 +127,7 @@ ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
if (!(rx->flags & IEEE80211_RX_RA_MATCH)) if (!(rx->flags & IEEE80211_RX_RA_MATCH))
return RX_DROP_UNUSABLE; return RX_DROP_UNUSABLE;
mac80211_ev_michael_mic_failure(rx->dev, rx->key->conf.keyidx, mac80211_ev_michael_mic_failure(rx->sdata, rx->key->conf.keyidx,
(void *) skb->data); (void *) skb->data);
return RX_DROP_UNUSABLE; return RX_DROP_UNUSABLE;
} }