mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 01:41:39 +00:00
![Matteo Croce](/assets/img/avatar_default.png)
When connecting without first doing a scan, the BSS list is empty and __cfg80211_connect_result() generates this warning: $ iw dev wlan0 connect -w VirtWifi [ 15.371989] ------------[ cut here ]------------ [ 15.372179] WARNING: CPU: 0 PID: 92 at net/wireless/sme.c:756 __cfg80211_connect_result+0x402/0x440 [ 15.372383] CPU: 0 PID: 92 Comm: kworker/u2:2 Not tainted 5.13.0-kvm #444 [ 15.372512] Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.14.0-3.fc34 04/01/2014 [ 15.372597] Workqueue: cfg80211 cfg80211_event_work [ 15.372756] RIP: 0010:__cfg80211_connect_result+0x402/0x440 [ 15.372818] Code: 48 2b 04 25 28 00 00 00 75 59 48 8b 3b 48 8b 76 10 48 8d 65 e0 5b 41 5c 41 5d 41 5e 5d 49 8d 65 f0 41 5d e9 d0 d4 fd ff 0f 0b <0f> 0b e9 f6 fd ff ff e8 f2 4a b4 ff e9 ec fd ff ff 0f 0b e9 19 fd [ 15.372966] RSP: 0018:ffffc900005cbdc0 EFLAGS: 00010246 [ 15.373022] RAX: 0000000000000000 RBX: ffff8880028e2400 RCX: ffff8880028e2472 [ 15.373088] RDX: 0000000000000002 RSI: 00000000fffffe01 RDI: ffffffff815335ba [ 15.373149] RBP: ffffc900005cbe00 R08: 0000000000000008 R09: ffff888002bdf8b8 [ 15.373209] R10: ffff88803ec208f0 R11: ffffffffffffe9ae R12: ffff88801d687d98 [ 15.373280] R13: ffff88801b5fe000 R14: ffffc900005cbdc0 R15: dead000000000100 [ 15.373330] FS: 0000000000000000(0000) GS:ffff88803ec00000(0000) knlGS:0000000000000000 [ 15.373382] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.373425] CR2: 000056421c468958 CR3: 000000001b458001 CR4: 0000000000170eb0 [ 15.373478] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 15.373529] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 15.373580] Call Trace: [ 15.373611] ? cfg80211_process_wdev_events+0x10e/0x170 [ 15.373743] cfg80211_process_wdev_events+0x10e/0x170 [ 15.373783] cfg80211_process_rdev_events+0x21/0x40 [ 15.373846] cfg80211_event_work+0x20/0x30 [ 15.373892] process_one_work+0x1e9/0x340 [ 15.373956] worker_thread+0x4b/0x3f0 [ 15.374017] ? process_one_work+0x340/0x340 [ 15.374053] kthread+0x11f/0x140 [ 15.374089] ? set_kthread_struct+0x30/0x30 [ 15.374153] ret_from_fork+0x1f/0x30 [ 15.374187] ---[ end trace 321ef0cb7e9c0be1 ]--- wlan0 (phy #0): connected to 00:00:00:00:00:00 Add the fake bss just before the connect so that cfg80211_get_bss() finds the virtual network. As some code was duplicated, move it in a common function. Signed-off-by: Matteo Croce <mcroce@microsoft.com> Link: https://lore.kernel.org/r/20210706154423.11065-1-mcroce@linux.microsoft.com Signed-off-by: Johannes Berg <johannes.berg@intel.com>
697 lines
18 KiB
C
697 lines
18 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* drivers/net/wireless/virt_wifi.c
|
|
*
|
|
* A fake implementation of cfg80211_ops that can be tacked on to an ethernet
|
|
* net_device to make it appear as a wireless connection.
|
|
*
|
|
* Copyright (C) 2018 Google, Inc.
|
|
*
|
|
* Author: schuffelen@google.com
|
|
*/
|
|
|
|
#include <net/cfg80211.h>
|
|
#include <net/rtnetlink.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/math64.h>
|
|
#include <linux/module.h>
|
|
|
|
static struct wiphy *common_wiphy;
|
|
|
|
struct virt_wifi_wiphy_priv {
|
|
struct delayed_work scan_result;
|
|
struct cfg80211_scan_request *scan_request;
|
|
bool being_deleted;
|
|
};
|
|
|
|
static struct ieee80211_channel channel_2ghz = {
|
|
.band = NL80211_BAND_2GHZ,
|
|
.center_freq = 2432,
|
|
.hw_value = 2432,
|
|
.max_power = 20,
|
|
};
|
|
|
|
static struct ieee80211_rate bitrates_2ghz[] = {
|
|
{ .bitrate = 10 },
|
|
{ .bitrate = 20 },
|
|
{ .bitrate = 55 },
|
|
{ .bitrate = 110 },
|
|
{ .bitrate = 60 },
|
|
{ .bitrate = 120 },
|
|
{ .bitrate = 240 },
|
|
};
|
|
|
|
static struct ieee80211_supported_band band_2ghz = {
|
|
.channels = &channel_2ghz,
|
|
.bitrates = bitrates_2ghz,
|
|
.band = NL80211_BAND_2GHZ,
|
|
.n_channels = 1,
|
|
.n_bitrates = ARRAY_SIZE(bitrates_2ghz),
|
|
.ht_cap = {
|
|
.ht_supported = true,
|
|
.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
|
|
IEEE80211_HT_CAP_GRN_FLD |
|
|
IEEE80211_HT_CAP_SGI_20 |
|
|
IEEE80211_HT_CAP_SGI_40 |
|
|
IEEE80211_HT_CAP_DSSSCCK40,
|
|
.ampdu_factor = 0x3,
|
|
.ampdu_density = 0x6,
|
|
.mcs = {
|
|
.rx_mask = {0xff, 0xff},
|
|
.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
|
|
},
|
|
},
|
|
};
|
|
|
|
static struct ieee80211_channel channel_5ghz = {
|
|
.band = NL80211_BAND_5GHZ,
|
|
.center_freq = 5240,
|
|
.hw_value = 5240,
|
|
.max_power = 20,
|
|
};
|
|
|
|
static struct ieee80211_rate bitrates_5ghz[] = {
|
|
{ .bitrate = 60 },
|
|
{ .bitrate = 120 },
|
|
{ .bitrate = 240 },
|
|
};
|
|
|
|
#define RX_MCS_MAP (IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 14)
|
|
|
|
#define TX_MCS_MAP (IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 | \
|
|
IEEE80211_VHT_MCS_SUPPORT_0_9 << 14)
|
|
|
|
static struct ieee80211_supported_band band_5ghz = {
|
|
.channels = &channel_5ghz,
|
|
.bitrates = bitrates_5ghz,
|
|
.band = NL80211_BAND_5GHZ,
|
|
.n_channels = 1,
|
|
.n_bitrates = ARRAY_SIZE(bitrates_5ghz),
|
|
.ht_cap = {
|
|
.ht_supported = true,
|
|
.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
|
|
IEEE80211_HT_CAP_GRN_FLD |
|
|
IEEE80211_HT_CAP_SGI_20 |
|
|
IEEE80211_HT_CAP_SGI_40 |
|
|
IEEE80211_HT_CAP_DSSSCCK40,
|
|
.ampdu_factor = 0x3,
|
|
.ampdu_density = 0x6,
|
|
.mcs = {
|
|
.rx_mask = {0xff, 0xff},
|
|
.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
|
|
},
|
|
},
|
|
.vht_cap = {
|
|
.vht_supported = true,
|
|
.cap = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
|
|
IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ |
|
|
IEEE80211_VHT_CAP_RXLDPC |
|
|
IEEE80211_VHT_CAP_SHORT_GI_80 |
|
|
IEEE80211_VHT_CAP_SHORT_GI_160 |
|
|
IEEE80211_VHT_CAP_TXSTBC |
|
|
IEEE80211_VHT_CAP_RXSTBC_1 |
|
|
IEEE80211_VHT_CAP_RXSTBC_2 |
|
|
IEEE80211_VHT_CAP_RXSTBC_3 |
|
|
IEEE80211_VHT_CAP_RXSTBC_4 |
|
|
IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
|
|
.vht_mcs = {
|
|
.rx_mcs_map = cpu_to_le16(RX_MCS_MAP),
|
|
.tx_mcs_map = cpu_to_le16(TX_MCS_MAP),
|
|
}
|
|
},
|
|
};
|
|
|
|
/* Assigned at module init. Guaranteed locally-administered and unicast. */
|
|
static u8 fake_router_bssid[ETH_ALEN] __ro_after_init = {};
|
|
|
|
static void virt_wifi_inform_bss(struct wiphy *wiphy)
|
|
{
|
|
u64 tsf = div_u64(ktime_get_boottime_ns(), 1000);
|
|
struct cfg80211_bss *informed_bss;
|
|
static const struct {
|
|
u8 tag;
|
|
u8 len;
|
|
u8 ssid[8];
|
|
} __packed ssid = {
|
|
.tag = WLAN_EID_SSID,
|
|
.len = 8,
|
|
.ssid = "VirtWifi",
|
|
};
|
|
|
|
informed_bss = cfg80211_inform_bss(wiphy, &channel_5ghz,
|
|
CFG80211_BSS_FTYPE_PRESP,
|
|
fake_router_bssid, tsf,
|
|
WLAN_CAPABILITY_ESS, 0,
|
|
(void *)&ssid, sizeof(ssid),
|
|
DBM_TO_MBM(-50), GFP_KERNEL);
|
|
cfg80211_put_bss(wiphy, informed_bss);
|
|
}
|
|
|
|
/* Called with the rtnl lock held. */
|
|
static int virt_wifi_scan(struct wiphy *wiphy,
|
|
struct cfg80211_scan_request *request)
|
|
{
|
|
struct virt_wifi_wiphy_priv *priv = wiphy_priv(wiphy);
|
|
|
|
wiphy_debug(wiphy, "scan\n");
|
|
|
|
if (priv->scan_request || priv->being_deleted)
|
|
return -EBUSY;
|
|
|
|
priv->scan_request = request;
|
|
schedule_delayed_work(&priv->scan_result, HZ * 2);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Acquires and releases the rdev BSS lock. */
|
|
static void virt_wifi_scan_result(struct work_struct *work)
|
|
{
|
|
struct virt_wifi_wiphy_priv *priv =
|
|
container_of(work, struct virt_wifi_wiphy_priv,
|
|
scan_result.work);
|
|
struct wiphy *wiphy = priv_to_wiphy(priv);
|
|
struct cfg80211_scan_info scan_info = { .aborted = false };
|
|
|
|
virt_wifi_inform_bss(wiphy);
|
|
|
|
/* Schedules work which acquires and releases the rtnl lock. */
|
|
cfg80211_scan_done(priv->scan_request, &scan_info);
|
|
priv->scan_request = NULL;
|
|
}
|
|
|
|
/* May acquire and release the rdev BSS lock. */
|
|
static void virt_wifi_cancel_scan(struct wiphy *wiphy)
|
|
{
|
|
struct virt_wifi_wiphy_priv *priv = wiphy_priv(wiphy);
|
|
|
|
cancel_delayed_work_sync(&priv->scan_result);
|
|
/* Clean up dangling callbacks if necessary. */
|
|
if (priv->scan_request) {
|
|
struct cfg80211_scan_info scan_info = { .aborted = true };
|
|
/* Schedules work which acquires and releases the rtnl lock. */
|
|
cfg80211_scan_done(priv->scan_request, &scan_info);
|
|
priv->scan_request = NULL;
|
|
}
|
|
}
|
|
|
|
struct virt_wifi_netdev_priv {
|
|
struct delayed_work connect;
|
|
struct net_device *lowerdev;
|
|
struct net_device *upperdev;
|
|
u32 tx_packets;
|
|
u32 tx_failed;
|
|
u8 connect_requested_bss[ETH_ALEN];
|
|
bool is_up;
|
|
bool is_connected;
|
|
bool being_deleted;
|
|
};
|
|
|
|
/* Called with the rtnl lock held. */
|
|
static int virt_wifi_connect(struct wiphy *wiphy, struct net_device *netdev,
|
|
struct cfg80211_connect_params *sme)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
|
|
bool could_schedule;
|
|
|
|
if (priv->being_deleted || !priv->is_up)
|
|
return -EBUSY;
|
|
|
|
could_schedule = schedule_delayed_work(&priv->connect, HZ * 2);
|
|
if (!could_schedule)
|
|
return -EBUSY;
|
|
|
|
if (sme->bssid) {
|
|
ether_addr_copy(priv->connect_requested_bss, sme->bssid);
|
|
} else {
|
|
virt_wifi_inform_bss(wiphy);
|
|
eth_zero_addr(priv->connect_requested_bss);
|
|
}
|
|
|
|
wiphy_debug(wiphy, "connect\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Acquires and releases the rdev event lock. */
|
|
static void virt_wifi_connect_complete(struct work_struct *work)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv =
|
|
container_of(work, struct virt_wifi_netdev_priv, connect.work);
|
|
u8 *requested_bss = priv->connect_requested_bss;
|
|
bool right_addr = ether_addr_equal(requested_bss, fake_router_bssid);
|
|
u16 status = WLAN_STATUS_SUCCESS;
|
|
|
|
if (is_zero_ether_addr(requested_bss))
|
|
requested_bss = NULL;
|
|
|
|
if (!priv->is_up || (requested_bss && !right_addr))
|
|
status = WLAN_STATUS_UNSPECIFIED_FAILURE;
|
|
else
|
|
priv->is_connected = true;
|
|
|
|
/* Schedules an event that acquires the rtnl lock. */
|
|
cfg80211_connect_result(priv->upperdev, requested_bss, NULL, 0, NULL, 0,
|
|
status, GFP_KERNEL);
|
|
netif_carrier_on(priv->upperdev);
|
|
}
|
|
|
|
/* May acquire and release the rdev event lock. */
|
|
static void virt_wifi_cancel_connect(struct net_device *netdev)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
|
|
|
|
/* If there is work pending, clean up dangling callbacks. */
|
|
if (cancel_delayed_work_sync(&priv->connect)) {
|
|
/* Schedules an event that acquires the rtnl lock. */
|
|
cfg80211_connect_result(priv->upperdev,
|
|
priv->connect_requested_bss, NULL, 0,
|
|
NULL, 0,
|
|
WLAN_STATUS_UNSPECIFIED_FAILURE,
|
|
GFP_KERNEL);
|
|
}
|
|
}
|
|
|
|
/* Called with the rtnl lock held. Acquires the rdev event lock. */
|
|
static int virt_wifi_disconnect(struct wiphy *wiphy, struct net_device *netdev,
|
|
u16 reason_code)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
|
|
|
|
if (priv->being_deleted)
|
|
return -EBUSY;
|
|
|
|
wiphy_debug(wiphy, "disconnect\n");
|
|
virt_wifi_cancel_connect(netdev);
|
|
|
|
cfg80211_disconnected(netdev, reason_code, NULL, 0, true, GFP_KERNEL);
|
|
priv->is_connected = false;
|
|
netif_carrier_off(netdev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Called with the rtnl lock held. */
|
|
static int virt_wifi_get_station(struct wiphy *wiphy, struct net_device *dev,
|
|
const u8 *mac, struct station_info *sinfo)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
|
|
wiphy_debug(wiphy, "get_station\n");
|
|
|
|
if (!priv->is_connected || !ether_addr_equal(mac, fake_router_bssid))
|
|
return -ENOENT;
|
|
|
|
sinfo->filled = BIT_ULL(NL80211_STA_INFO_TX_PACKETS) |
|
|
BIT_ULL(NL80211_STA_INFO_TX_FAILED) |
|
|
BIT_ULL(NL80211_STA_INFO_SIGNAL) |
|
|
BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
|
|
sinfo->tx_packets = priv->tx_packets;
|
|
sinfo->tx_failed = priv->tx_failed;
|
|
/* For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_ */
|
|
sinfo->signal = -50;
|
|
sinfo->txrate = (struct rate_info) {
|
|
.legacy = 10, /* units are 100kbit/s */
|
|
};
|
|
return 0;
|
|
}
|
|
|
|
/* Called with the rtnl lock held. */
|
|
static int virt_wifi_dump_station(struct wiphy *wiphy, struct net_device *dev,
|
|
int idx, u8 *mac, struct station_info *sinfo)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
|
|
wiphy_debug(wiphy, "dump_station\n");
|
|
|
|
if (idx != 0 || !priv->is_connected)
|
|
return -ENOENT;
|
|
|
|
ether_addr_copy(mac, fake_router_bssid);
|
|
return virt_wifi_get_station(wiphy, dev, fake_router_bssid, sinfo);
|
|
}
|
|
|
|
static const struct cfg80211_ops virt_wifi_cfg80211_ops = {
|
|
.scan = virt_wifi_scan,
|
|
|
|
.connect = virt_wifi_connect,
|
|
.disconnect = virt_wifi_disconnect,
|
|
|
|
.get_station = virt_wifi_get_station,
|
|
.dump_station = virt_wifi_dump_station,
|
|
};
|
|
|
|
/* Acquires and releases the rtnl lock. */
|
|
static struct wiphy *virt_wifi_make_wiphy(void)
|
|
{
|
|
struct wiphy *wiphy;
|
|
struct virt_wifi_wiphy_priv *priv;
|
|
int err;
|
|
|
|
wiphy = wiphy_new(&virt_wifi_cfg80211_ops, sizeof(*priv));
|
|
|
|
if (!wiphy)
|
|
return NULL;
|
|
|
|
wiphy->max_scan_ssids = 4;
|
|
wiphy->max_scan_ie_len = 1000;
|
|
wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
|
|
|
|
wiphy->bands[NL80211_BAND_2GHZ] = &band_2ghz;
|
|
wiphy->bands[NL80211_BAND_5GHZ] = &band_5ghz;
|
|
wiphy->bands[NL80211_BAND_60GHZ] = NULL;
|
|
|
|
wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
|
|
|
|
priv = wiphy_priv(wiphy);
|
|
priv->being_deleted = false;
|
|
priv->scan_request = NULL;
|
|
INIT_DELAYED_WORK(&priv->scan_result, virt_wifi_scan_result);
|
|
|
|
err = wiphy_register(wiphy);
|
|
if (err < 0) {
|
|
wiphy_free(wiphy);
|
|
return NULL;
|
|
}
|
|
|
|
return wiphy;
|
|
}
|
|
|
|
/* Acquires and releases the rtnl lock. */
|
|
static void virt_wifi_destroy_wiphy(struct wiphy *wiphy)
|
|
{
|
|
struct virt_wifi_wiphy_priv *priv;
|
|
|
|
WARN(!wiphy, "%s called with null wiphy", __func__);
|
|
if (!wiphy)
|
|
return;
|
|
|
|
priv = wiphy_priv(wiphy);
|
|
priv->being_deleted = true;
|
|
virt_wifi_cancel_scan(wiphy);
|
|
|
|
if (wiphy->registered)
|
|
wiphy_unregister(wiphy);
|
|
wiphy_free(wiphy);
|
|
}
|
|
|
|
/* Enters and exits a RCU-bh critical section. */
|
|
static netdev_tx_t virt_wifi_start_xmit(struct sk_buff *skb,
|
|
struct net_device *dev)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
|
|
priv->tx_packets++;
|
|
if (!priv->is_connected) {
|
|
priv->tx_failed++;
|
|
return NET_XMIT_DROP;
|
|
}
|
|
|
|
skb->dev = priv->lowerdev;
|
|
return dev_queue_xmit(skb);
|
|
}
|
|
|
|
/* Called with rtnl lock held. */
|
|
static int virt_wifi_net_device_open(struct net_device *dev)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
|
|
priv->is_up = true;
|
|
return 0;
|
|
}
|
|
|
|
/* Called with rtnl lock held. */
|
|
static int virt_wifi_net_device_stop(struct net_device *dev)
|
|
{
|
|
struct virt_wifi_netdev_priv *n_priv = netdev_priv(dev);
|
|
|
|
n_priv->is_up = false;
|
|
|
|
if (!dev->ieee80211_ptr)
|
|
return 0;
|
|
|
|
virt_wifi_cancel_scan(dev->ieee80211_ptr->wiphy);
|
|
virt_wifi_cancel_connect(dev);
|
|
netif_carrier_off(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int virt_wifi_net_device_get_iflink(const struct net_device *dev)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
|
|
return priv->lowerdev->ifindex;
|
|
}
|
|
|
|
static const struct net_device_ops virt_wifi_ops = {
|
|
.ndo_start_xmit = virt_wifi_start_xmit,
|
|
.ndo_open = virt_wifi_net_device_open,
|
|
.ndo_stop = virt_wifi_net_device_stop,
|
|
.ndo_get_iflink = virt_wifi_net_device_get_iflink,
|
|
};
|
|
|
|
/* Invoked as part of rtnl lock release. */
|
|
static void virt_wifi_net_device_destructor(struct net_device *dev)
|
|
{
|
|
/* Delayed past dellink to allow nl80211 to react to the device being
|
|
* deleted.
|
|
*/
|
|
kfree(dev->ieee80211_ptr);
|
|
dev->ieee80211_ptr = NULL;
|
|
}
|
|
|
|
/* No lock interaction. */
|
|
static void virt_wifi_setup(struct net_device *dev)
|
|
{
|
|
ether_setup(dev);
|
|
dev->netdev_ops = &virt_wifi_ops;
|
|
dev->needs_free_netdev = true;
|
|
}
|
|
|
|
/* Called in a RCU read critical section from netif_receive_skb */
|
|
static rx_handler_result_t virt_wifi_rx_handler(struct sk_buff **pskb)
|
|
{
|
|
struct sk_buff *skb = *pskb;
|
|
struct virt_wifi_netdev_priv *priv =
|
|
rcu_dereference(skb->dev->rx_handler_data);
|
|
|
|
if (!priv->is_connected)
|
|
return RX_HANDLER_PASS;
|
|
|
|
/* GFP_ATOMIC because this is a packet interrupt handler. */
|
|
skb = skb_share_check(skb, GFP_ATOMIC);
|
|
if (!skb) {
|
|
dev_err(&priv->upperdev->dev, "can't skb_share_check\n");
|
|
return RX_HANDLER_CONSUMED;
|
|
}
|
|
|
|
*pskb = skb;
|
|
skb->dev = priv->upperdev;
|
|
skb->pkt_type = PACKET_HOST;
|
|
return RX_HANDLER_ANOTHER;
|
|
}
|
|
|
|
/* Called with rtnl lock held. */
|
|
static int virt_wifi_newlink(struct net *src_net, struct net_device *dev,
|
|
struct nlattr *tb[], struct nlattr *data[],
|
|
struct netlink_ext_ack *extack)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
int err;
|
|
|
|
if (!tb[IFLA_LINK])
|
|
return -EINVAL;
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
priv->upperdev = dev;
|
|
priv->lowerdev = __dev_get_by_index(src_net,
|
|
nla_get_u32(tb[IFLA_LINK]));
|
|
|
|
if (!priv->lowerdev)
|
|
return -ENODEV;
|
|
if (!tb[IFLA_MTU])
|
|
dev->mtu = priv->lowerdev->mtu;
|
|
else if (dev->mtu > priv->lowerdev->mtu)
|
|
return -EINVAL;
|
|
|
|
err = netdev_rx_handler_register(priv->lowerdev, virt_wifi_rx_handler,
|
|
priv);
|
|
if (err) {
|
|
dev_err(&priv->lowerdev->dev,
|
|
"can't netdev_rx_handler_register: %d\n", err);
|
|
return err;
|
|
}
|
|
|
|
eth_hw_addr_inherit(dev, priv->lowerdev);
|
|
netif_stacked_transfer_operstate(priv->lowerdev, dev);
|
|
|
|
SET_NETDEV_DEV(dev, &priv->lowerdev->dev);
|
|
dev->ieee80211_ptr = kzalloc(sizeof(*dev->ieee80211_ptr), GFP_KERNEL);
|
|
|
|
if (!dev->ieee80211_ptr) {
|
|
err = -ENOMEM;
|
|
goto remove_handler;
|
|
}
|
|
|
|
dev->ieee80211_ptr->iftype = NL80211_IFTYPE_STATION;
|
|
dev->ieee80211_ptr->wiphy = common_wiphy;
|
|
|
|
err = register_netdevice(dev);
|
|
if (err) {
|
|
dev_err(&priv->lowerdev->dev, "can't register_netdevice: %d\n",
|
|
err);
|
|
goto free_wireless_dev;
|
|
}
|
|
|
|
err = netdev_upper_dev_link(priv->lowerdev, dev, extack);
|
|
if (err) {
|
|
dev_err(&priv->lowerdev->dev, "can't netdev_upper_dev_link: %d\n",
|
|
err);
|
|
goto unregister_netdev;
|
|
}
|
|
|
|
dev->priv_destructor = virt_wifi_net_device_destructor;
|
|
priv->being_deleted = false;
|
|
priv->is_connected = false;
|
|
priv->is_up = false;
|
|
INIT_DELAYED_WORK(&priv->connect, virt_wifi_connect_complete);
|
|
__module_get(THIS_MODULE);
|
|
|
|
return 0;
|
|
unregister_netdev:
|
|
unregister_netdevice(dev);
|
|
free_wireless_dev:
|
|
kfree(dev->ieee80211_ptr);
|
|
dev->ieee80211_ptr = NULL;
|
|
remove_handler:
|
|
netdev_rx_handler_unregister(priv->lowerdev);
|
|
|
|
return err;
|
|
}
|
|
|
|
/* Called with rtnl lock held. */
|
|
static void virt_wifi_dellink(struct net_device *dev,
|
|
struct list_head *head)
|
|
{
|
|
struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
|
|
|
|
if (dev->ieee80211_ptr)
|
|
virt_wifi_cancel_scan(dev->ieee80211_ptr->wiphy);
|
|
|
|
priv->being_deleted = true;
|
|
virt_wifi_cancel_connect(dev);
|
|
netif_carrier_off(dev);
|
|
|
|
netdev_rx_handler_unregister(priv->lowerdev);
|
|
netdev_upper_dev_unlink(priv->lowerdev, dev);
|
|
|
|
unregister_netdevice_queue(dev, head);
|
|
module_put(THIS_MODULE);
|
|
|
|
/* Deleting the wiphy is handled in the module destructor. */
|
|
}
|
|
|
|
static struct rtnl_link_ops virt_wifi_link_ops = {
|
|
.kind = "virt_wifi",
|
|
.setup = virt_wifi_setup,
|
|
.newlink = virt_wifi_newlink,
|
|
.dellink = virt_wifi_dellink,
|
|
.priv_size = sizeof(struct virt_wifi_netdev_priv),
|
|
};
|
|
|
|
static bool netif_is_virt_wifi_dev(const struct net_device *dev)
|
|
{
|
|
return rcu_access_pointer(dev->rx_handler) == virt_wifi_rx_handler;
|
|
}
|
|
|
|
static int virt_wifi_event(struct notifier_block *this, unsigned long event,
|
|
void *ptr)
|
|
{
|
|
struct net_device *lower_dev = netdev_notifier_info_to_dev(ptr);
|
|
struct virt_wifi_netdev_priv *priv;
|
|
struct net_device *upper_dev;
|
|
LIST_HEAD(list_kill);
|
|
|
|
if (!netif_is_virt_wifi_dev(lower_dev))
|
|
return NOTIFY_DONE;
|
|
|
|
switch (event) {
|
|
case NETDEV_UNREGISTER:
|
|
priv = rtnl_dereference(lower_dev->rx_handler_data);
|
|
if (!priv)
|
|
return NOTIFY_DONE;
|
|
|
|
upper_dev = priv->upperdev;
|
|
|
|
upper_dev->rtnl_link_ops->dellink(upper_dev, &list_kill);
|
|
unregister_netdevice_many(&list_kill);
|
|
break;
|
|
}
|
|
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static struct notifier_block virt_wifi_notifier = {
|
|
.notifier_call = virt_wifi_event,
|
|
};
|
|
|
|
/* Acquires and releases the rtnl lock. */
|
|
static int __init virt_wifi_init_module(void)
|
|
{
|
|
int err;
|
|
|
|
/* Guaranteed to be locallly-administered and not multicast. */
|
|
eth_random_addr(fake_router_bssid);
|
|
|
|
err = register_netdevice_notifier(&virt_wifi_notifier);
|
|
if (err)
|
|
return err;
|
|
|
|
err = -ENOMEM;
|
|
common_wiphy = virt_wifi_make_wiphy();
|
|
if (!common_wiphy)
|
|
goto notifier;
|
|
|
|
err = rtnl_link_register(&virt_wifi_link_ops);
|
|
if (err)
|
|
goto destroy_wiphy;
|
|
|
|
return 0;
|
|
|
|
destroy_wiphy:
|
|
virt_wifi_destroy_wiphy(common_wiphy);
|
|
notifier:
|
|
unregister_netdevice_notifier(&virt_wifi_notifier);
|
|
return err;
|
|
}
|
|
|
|
/* Acquires and releases the rtnl lock. */
|
|
static void __exit virt_wifi_cleanup_module(void)
|
|
{
|
|
/* Will delete any devices that depend on the wiphy. */
|
|
rtnl_link_unregister(&virt_wifi_link_ops);
|
|
virt_wifi_destroy_wiphy(common_wiphy);
|
|
unregister_netdevice_notifier(&virt_wifi_notifier);
|
|
}
|
|
|
|
module_init(virt_wifi_init_module);
|
|
module_exit(virt_wifi_cleanup_module);
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_AUTHOR("Cody Schuffelen <schuffelen@google.com>");
|
|
MODULE_DESCRIPTION("Driver for a wireless wrapper of ethernet devices");
|
|
MODULE_ALIAS_RTNL_LINK("virt_wifi");
|