[linux-2.6-block.git] / drivers / net / wireless / virt_wifi.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/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 = {};

/* 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 {
		u8 tag;
		u8 len;
		u8 ssid[8];
	} __packed ssid = {
		.tag = WLAN_EID_SSID, .len = 8, .ssid = "VirtWifi",
	};
	struct cfg80211_bss *informed_bss;
	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 };

	informed_bss = cfg80211_inform_bss(wiphy, &channel_5ghz,
					   CFG80211_BSS_FTYPE_PRESP,
					   fake_router_bssid,
					   ktime_get_boottime_ns(),
					   WLAN_CAPABILITY_ESS, 0,
					   (void *)&ssid, sizeof(ssid),
					   DBM_TO_MBM(-50), GFP_KERNEL);
	cfg80211_put_bss(wiphy, informed_bss);

	/* 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
		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 has_addr = !is_zero_ether_addr(requested_bss);
	bool right_addr = ether_addr_equal(requested_bss, fake_router_bssid);
	u16 status = WLAN_STATUS_SUCCESS;

	if (!priv->is_up || (has_addr && !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 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,
};

/* 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;
	free_netdev(dev);
}

/* No lock interaction. */
static void virt_wifi_setup(struct net_device *dev)
{
	ether_setup(dev);
	dev->netdev_ops = &virt_wifi_ops;
	dev->priv_destructor = virt_wifi_net_device_destructor;
}

/* 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;
	}

	priv->being_deleted = false;
	priv->is_connected = false;
	priv->is_up = false;
	INIT_DELAYED_WORK(&priv->connect, virt_wifi_connect_complete);

	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);

	/* 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),
};

/* 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);

	common_wiphy = virt_wifi_make_wiphy();
	if (!common_wiphy)
		return -ENOMEM;

	err = rtnl_link_register(&virt_wifi_link_ops);
	if (err)
		virt_wifi_destroy_wiphy(common_wiphy);

	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);
}

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");
Commit	Line	Data
c7cdba31 CS	1	// SPDX-License-Identifier: GPL-2.0
	2	/* drivers/net/wireless/virt_wifi.c
	3	*
	4	* A fake implementation of cfg80211_ops that can be tacked on to an ethernet
	5	* net_device to make it appear as a wireless connection.
	6	*
	7	* Copyright (C) 2018 Google, Inc.
	8	*
	9	* Author: schuffelen@google.com
	10	*/
	11
	12	#include <net/cfg80211.h>
c7cdba31 CS	13	#include <net/rtnetlink.h>
	14	#include <linux/etherdevice.h>
	15	#include <linux/module.h>
	16
	17	static struct wiphy *common_wiphy;
	18
	19	struct virt_wifi_wiphy_priv {
	20	struct delayed_work scan_result;
	21	struct cfg80211_scan_request *scan_request;
	22	bool being_deleted;
	23	};
	24
	25	static struct ieee80211_channel channel_2ghz = {
	26	.band = NL80211_BAND_2GHZ,
	27	.center_freq = 2432,
	28	.hw_value = 2432,
	29	.max_power = 20,
	30	};
	31
	32	static struct ieee80211_rate bitrates_2ghz[] = {
	33	{ .bitrate = 10 },
	34	{ .bitrate = 20 },
	35	{ .bitrate = 55 },
	36	{ .bitrate = 110 },
	37	{ .bitrate = 60 },
	38	{ .bitrate = 120 },
	39	{ .bitrate = 240 },
	40	};
	41
	42	static struct ieee80211_supported_band band_2ghz = {
	43	.channels = &channel_2ghz,
	44	.bitrates = bitrates_2ghz,
	45	.band = NL80211_BAND_2GHZ,
	46	.n_channels = 1,
	47	.n_bitrates = ARRAY_SIZE(bitrates_2ghz),
	48	.ht_cap = {
	49	.ht_supported = true,
	50	.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 \|
	51	IEEE80211_HT_CAP_GRN_FLD \|
	52	IEEE80211_HT_CAP_SGI_20 \|
	53	IEEE80211_HT_CAP_SGI_40 \|
	54	IEEE80211_HT_CAP_DSSSCCK40,
	55	.ampdu_factor = 0x3,
	56	.ampdu_density = 0x6,
	57	.mcs = {
	58	.rx_mask = {0xff, 0xff},
	59	.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
	60	},
	61	},
	62	};
	63
	64	static struct ieee80211_channel channel_5ghz = {
	65	.band = NL80211_BAND_5GHZ,
	66	.center_freq = 5240,
	67	.hw_value = 5240,
	68	.max_power = 20,
	69	};
	70
	71	static struct ieee80211_rate bitrates_5ghz[] = {
	72	{ .bitrate = 60 },
	73	{ .bitrate = 120 },
	74	{ .bitrate = 240 },
	75	};
	76
77	#define RX_MCS_MAP (IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 \| \
78	IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 \| \
79	IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 \| \
80	IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 \| \
81	IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 \| \
82	IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 \| \
83	IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 \| \
84	IEEE80211_VHT_MCS_SUPPORT_0_9 << 14)
85
86	#define TX_MCS_MAP (IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 \| \
87	IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 \| \
88	IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 \| \
89	IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 \| \
90	IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 \| \
91	IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 \| \
92	IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 \| \
93	IEEE80211_VHT_MCS_SUPPORT_0_9 << 14)
94
95	static struct ieee80211_supported_band band_5ghz = {
96	.channels = &channel_5ghz,
97	.bitrates = bitrates_5ghz,
98	.band = NL80211_BAND_5GHZ,
99	.n_channels = 1,
100	.n_bitrates = ARRAY_SIZE(bitrates_5ghz),
101	.ht_cap = {
102	.ht_supported = true,
103	.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 \|
104	IEEE80211_HT_CAP_GRN_FLD \|
105	IEEE80211_HT_CAP_SGI_20 \|
106	IEEE80211_HT_CAP_SGI_40 \|
107	IEEE80211_HT_CAP_DSSSCCK40,
108	.ampdu_factor = 0x3,
109	.ampdu_density = 0x6,
110	.mcs = {
111	.rx_mask = {0xff, 0xff},
112	.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
113	},
114	},
115	.vht_cap = {
116	.vht_supported = true,
117	.cap = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 \|
118	IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ \|
119	IEEE80211_VHT_CAP_RXLDPC \|
120	IEEE80211_VHT_CAP_SHORT_GI_80 \|
121	IEEE80211_VHT_CAP_SHORT_GI_160 \|
122	IEEE80211_VHT_CAP_TXSTBC \|
123	IEEE80211_VHT_CAP_RXSTBC_1 \|
124	IEEE80211_VHT_CAP_RXSTBC_2 \|
125	IEEE80211_VHT_CAP_RXSTBC_3 \|
126	IEEE80211_VHT_CAP_RXSTBC_4 \|
127	IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
128	.vht_mcs = {
129	.rx_mcs_map = cpu_to_le16(RX_MCS_MAP),
130	.tx_mcs_map = cpu_to_le16(TX_MCS_MAP),
131	}
132	},
133	};
134
135	/* Assigned at module init. Guaranteed locally-administered and unicast. */
136	static u8 fake_router_bssid[ETH_ALEN] __ro_after_init = {};
137
138	/* Called with the rtnl lock held. */
139	static int virt_wifi_scan(struct wiphy *wiphy,
140	struct cfg80211_scan_request *request)
141	{
142	struct virt_wifi_wiphy_priv *priv = wiphy_priv(wiphy);
143
144	wiphy_debug(wiphy, "scan\n");
145
146	if (priv->scan_request \|\| priv->being_deleted)
147	return -EBUSY;
148
149	priv->scan_request = request;
150	schedule_delayed_work(&priv->scan_result, HZ * 2);
151
152	return 0;
153	}
154
155	/* Acquires and releases the rdev BSS lock. */
156	static void virt_wifi_scan_result(struct work_struct *work)
157	{
158	struct {
159	u8 tag;
160	u8 len;
161	u8 ssid[8];
162	} __packed ssid = {
163	.tag = WLAN_EID_SSID, .len = 8, .ssid = "VirtWifi",
164	};
165	struct cfg80211_bss *informed_bss;
166	struct virt_wifi_wiphy_priv *priv =
167	container_of(work, struct virt_wifi_wiphy_priv,
168	scan_result.work);
169	struct wiphy *wiphy = priv_to_wiphy(priv);
170	struct cfg80211_scan_info scan_info = { .aborted = false };
171
172	informed_bss = cfg80211_inform_bss(wiphy, &channel_5ghz,
173	CFG80211_BSS_FTYPE_PRESP,
174	fake_router_bssid,
9285ec4c	175	ktime_get_boottime_ns(),
c7cdba31 CS	176	WLAN_CAPABILITY_ESS, 0,
	177	(void *)&ssid, sizeof(ssid),
	178	DBM_TO_MBM(-50), GFP_KERNEL);
	179	cfg80211_put_bss(wiphy, informed_bss);
	180
	181	/* Schedules work which acquires and releases the rtnl lock. */
	182	cfg80211_scan_done(priv->scan_request, &scan_info);
	183	priv->scan_request = NULL;
	184	}
	185
	186	/* May acquire and release the rdev BSS lock. */
	187	static void virt_wifi_cancel_scan(struct wiphy *wiphy)
	188	{
	189	struct virt_wifi_wiphy_priv *priv = wiphy_priv(wiphy);
	190
	191	cancel_delayed_work_sync(&priv->scan_result);
	192	/* Clean up dangling callbacks if necessary. */
	193	if (priv->scan_request) {
	194	struct cfg80211_scan_info scan_info = { .aborted = true };
	195	/* Schedules work which acquires and releases the rtnl lock. */
	196	cfg80211_scan_done(priv->scan_request, &scan_info);
	197	priv->scan_request = NULL;
	198	}
	199	}
	200
	201	struct virt_wifi_netdev_priv {
	202	struct delayed_work connect;
	203	struct net_device *lowerdev;
	204	struct net_device *upperdev;
	205	u32 tx_packets;
	206	u32 tx_failed;
	207	u8 connect_requested_bss[ETH_ALEN];
	208	bool is_up;
	209	bool is_connected;
	210	bool being_deleted;
	211	};
	212
	213	/* Called with the rtnl lock held. */
	214	static int virt_wifi_connect(struct wiphy wiphy, struct net_device netdev,
	215	struct cfg80211_connect_params *sme)
	216	{
	217	struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
	218	bool could_schedule;
	219
	220	if (priv->being_deleted \|\| !priv->is_up)
	221	return -EBUSY;
	222
	223	could_schedule = schedule_delayed_work(&priv->connect, HZ * 2);
	224	if (!could_schedule)
	225	return -EBUSY;
	226
	227	if (sme->bssid)
	228	ether_addr_copy(priv->connect_requested_bss, sme->bssid);
	229	else
	230	eth_zero_addr(priv->connect_requested_bss);
	231
	232	wiphy_debug(wiphy, "connect\n");
	233
	234	return 0;
	235	}
	236
	237	/* Acquires and releases the rdev event lock. */
	238	static void virt_wifi_connect_complete(struct work_struct *work)
	239	{
240	struct virt_wifi_netdev_priv *priv =
241	container_of(work, struct virt_wifi_netdev_priv, connect.work);
242	u8 *requested_bss = priv->connect_requested_bss;
243	bool has_addr = !is_zero_ether_addr(requested_bss);
244	bool right_addr = ether_addr_equal(requested_bss, fake_router_bssid);
245	u16 status = WLAN_STATUS_SUCCESS;
246
247	if (!priv->is_up \|\| (has_addr && !right_addr))
248	status = WLAN_STATUS_UNSPECIFIED_FAILURE;
249	else
250	priv->is_connected = true;
251
252	/* Schedules an event that acquires the rtnl lock. */
253	cfg80211_connect_result(priv->upperdev, requested_bss, NULL, 0, NULL, 0,
254	status, GFP_KERNEL);
255	netif_carrier_on(priv->upperdev);
256	}
257
258	/* May acquire and release the rdev event lock. */
259	static void virt_wifi_cancel_connect(struct net_device *netdev)
260	{
261	struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
262
263	/* If there is work pending, clean up dangling callbacks. */
264	if (cancel_delayed_work_sync(&priv->connect)) {
265	/* Schedules an event that acquires the rtnl lock. */
266	cfg80211_connect_result(priv->upperdev,
267	priv->connect_requested_bss, NULL, 0,
268	NULL, 0,
269	WLAN_STATUS_UNSPECIFIED_FAILURE,
270	GFP_KERNEL);
271	}
272	}
273
274	/* Called with the rtnl lock held. Acquires the rdev event lock. */
275	static int virt_wifi_disconnect(struct wiphy wiphy, struct net_device netdev,
276	u16 reason_code)
277	{
278	struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
279
280	if (priv->being_deleted)
281	return -EBUSY;
282
283	wiphy_debug(wiphy, "disconnect\n");
284	virt_wifi_cancel_connect(netdev);
285
286	cfg80211_disconnected(netdev, reason_code, NULL, 0, true, GFP_KERNEL);
287	priv->is_connected = false;
288	netif_carrier_off(netdev);
289
290	return 0;
291	}
292
293	/* Called with the rtnl lock held. */
294	static int virt_wifi_get_station(struct wiphy wiphy, struct net_device dev,
295	const u8 mac, struct station_info sinfo)
296	{
297	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
298
299	wiphy_debug(wiphy, "get_station\n");
300
301	if (!priv->is_connected \|\| !ether_addr_equal(mac, fake_router_bssid))
302	return -ENOENT;
303
304	sinfo->filled = BIT_ULL(NL80211_STA_INFO_TX_PACKETS) \|
305	BIT_ULL(NL80211_STA_INFO_TX_FAILED) \|
306	BIT_ULL(NL80211_STA_INFO_SIGNAL) \|
307	BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
308	sinfo->tx_packets = priv->tx_packets;
309	sinfo->tx_failed = priv->tx_failed;
310	/* For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_ */
311	sinfo->signal = -50;
312	sinfo->txrate = (struct rate_info) {
313	.legacy = 10, /* units are 100kbit/s */
314	};
315	return 0;
316	}
317
318	/* Called with the rtnl lock held. */
319	static int virt_wifi_dump_station(struct wiphy wiphy, struct net_device dev,
320	int idx, u8 mac, struct station_info sinfo)
321	{
322	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
323
324	wiphy_debug(wiphy, "dump_station\n");
325
326	if (idx != 0 \|\| !priv->is_connected)
327	return -ENOENT;
328
329	ether_addr_copy(mac, fake_router_bssid);
330	return virt_wifi_get_station(wiphy, dev, fake_router_bssid, sinfo);
331	}
332
333	static const struct cfg80211_ops virt_wifi_cfg80211_ops = {
334	.scan = virt_wifi_scan,
335
336	.connect = virt_wifi_connect,
337	.disconnect = virt_wifi_disconnect,
338
339	.get_station = virt_wifi_get_station,
340	.dump_station = virt_wifi_dump_station,
341	};
342
343	/* Acquires and releases the rtnl lock. */
344	static struct wiphy *virt_wifi_make_wiphy(void)
345	{
346	struct wiphy *wiphy;
347	struct virt_wifi_wiphy_priv *priv;
348	int err;
349
350	wiphy = wiphy_new(&virt_wifi_cfg80211_ops, sizeof(*priv));
351
352	if (!wiphy)
353	return NULL;
354
355	wiphy->max_scan_ssids = 4;
356	wiphy->max_scan_ie_len = 1000;
357	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
358
359	wiphy->bands[NL80211_BAND_2GHZ] = &band_2ghz;
360	wiphy->bands[NL80211_BAND_5GHZ] = &band_5ghz;
361	wiphy->bands[NL80211_BAND_60GHZ] = NULL;
362
c7cdba31 CS	363	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
	364
	365	priv = wiphy_priv(wiphy);
	366	priv->being_deleted = false;
	367	priv->scan_request = NULL;
	368	INIT_DELAYED_WORK(&priv->scan_result, virt_wifi_scan_result);
	369
	370	err = wiphy_register(wiphy);
	371	if (err < 0) {
	372	wiphy_free(wiphy);
	373	return NULL;
	374	}
	375
	376	return wiphy;
	377	}
	378
	379	/* Acquires and releases the rtnl lock. */
	380	static void virt_wifi_destroy_wiphy(struct wiphy *wiphy)
	381	{
	382	struct virt_wifi_wiphy_priv *priv;
	383
	384	WARN(!wiphy, "%s called with null wiphy", __func__);
	385	if (!wiphy)
	386	return;
	387
	388	priv = wiphy_priv(wiphy);
	389	priv->being_deleted = true;
	390	virt_wifi_cancel_scan(wiphy);
	391
	392	if (wiphy->registered)
	393	wiphy_unregister(wiphy);
	394	wiphy_free(wiphy);
	395	}
	396
	397	/* Enters and exits a RCU-bh critical section. */
	398	static netdev_tx_t virt_wifi_start_xmit(struct sk_buff *skb,
	399	struct net_device *dev)
	400	{
	401	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
	402
	403	priv->tx_packets++;
	404	if (!priv->is_connected) {
	405	priv->tx_failed++;
	406	return NET_XMIT_DROP;
	407	}
	408
	409	skb->dev = priv->lowerdev;
	410	return dev_queue_xmit(skb);
	411	}
	412
	413	/* Called with rtnl lock held. */
	414	static int virt_wifi_net_device_open(struct net_device *dev)
	415	{
	416	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
	417
	418	priv->is_up = true;
	419	return 0;
	420	}
	421
	422	/* Called with rtnl lock held. */
	423	static int virt_wifi_net_device_stop(struct net_device *dev)
	424	{
	425	struct virt_wifi_netdev_priv *n_priv = netdev_priv(dev);
c7cdba31 CS	426
	427	n_priv->is_up = false;
	428
	429	if (!dev->ieee80211_ptr)
	430	return 0;
c7cdba31 CS	431
	432	virt_wifi_cancel_scan(dev->ieee80211_ptr->wiphy);
	433	virt_wifi_cancel_connect(dev);
	434	netif_carrier_off(dev);
	435
	436	return 0;
	437	}
	438
	439	static const struct net_device_ops virt_wifi_ops = {
	440	.ndo_start_xmit = virt_wifi_start_xmit,
	441	.ndo_open = virt_wifi_net_device_open,
	442	.ndo_stop = virt_wifi_net_device_stop,
	443	};
	444
	445	/* Invoked as part of rtnl lock release. */
	446	static void virt_wifi_net_device_destructor(struct net_device *dev)
	447	{
	448	/* Delayed past dellink to allow nl80211 to react to the device being
	449	* deleted.
	450	*/
	451	kfree(dev->ieee80211_ptr);
	452	dev->ieee80211_ptr = NULL;
	453	free_netdev(dev);
	454	}
	455
	456	/* No lock interaction. */
	457	static void virt_wifi_setup(struct net_device *dev)
	458	{
	459	ether_setup(dev);
	460	dev->netdev_ops = &virt_wifi_ops;
	461	dev->priv_destructor = virt_wifi_net_device_destructor;
	462	}
	463
	464	/* Called in a RCU read critical section from netif_receive_skb */
	465	static rx_handler_result_t virt_wifi_rx_handler(struct sk_buff **pskb)
	466	{
	467	struct sk_buff skb = pskb;
	468	struct virt_wifi_netdev_priv *priv =
	469	rcu_dereference(skb->dev->rx_handler_data);
	470
	471	if (!priv->is_connected)
	472	return RX_HANDLER_PASS;
	473
	474	/* GFP_ATOMIC because this is a packet interrupt handler. */
	475	skb = skb_share_check(skb, GFP_ATOMIC);
	476	if (!skb) {
	477	dev_err(&priv->upperdev->dev, "can't skb_share_check\n");
	478	return RX_HANDLER_CONSUMED;
	479	}
	480
	481	*pskb = skb;
	482	skb->dev = priv->upperdev;
	483	skb->pkt_type = PACKET_HOST;
	484	return RX_HANDLER_ANOTHER;
	485	}
	486
	487	/* Called with rtnl lock held. */
	488	static int virt_wifi_newlink(struct net src_net, struct net_device dev,
	489	struct nlattr tb[], struct nlattr data[],
	490	struct netlink_ext_ack *extack)
	491	{
	492	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
	493	int err;
	494
495	if (!tb[IFLA_LINK])
496	return -EINVAL;
497
498	netif_carrier_off(dev);
499
500	priv->upperdev = dev;
501	priv->lowerdev = __dev_get_by_index(src_net,
502	nla_get_u32(tb[IFLA_LINK]));
503
504	if (!priv->lowerdev)
505	return -ENODEV;
506	if (!tb[IFLA_MTU])
507	dev->mtu = priv->lowerdev->mtu;
508	else if (dev->mtu > priv->lowerdev->mtu)
509	return -EINVAL;
510
511	err = netdev_rx_handler_register(priv->lowerdev, virt_wifi_rx_handler,
512	priv);
513	if (err) {
514	dev_err(&priv->lowerdev->dev,
515	"can't netdev_rx_handler_register: %d\n", err);
516	return err;
517	}
518
519	eth_hw_addr_inherit(dev, priv->lowerdev);
520	netif_stacked_transfer_operstate(priv->lowerdev, dev);
521
522	SET_NETDEV_DEV(dev, &priv->lowerdev->dev);
523	dev->ieee80211_ptr = kzalloc(sizeof(*dev->ieee80211_ptr), GFP_KERNEL);
524
f9d672f1 WY	525	if (!dev->ieee80211_ptr) {
f9d672f1 WY	526	err = -ENOMEM;
c7cdba31	527	goto remove_handler;
f9d672f1	528	}
c7cdba31 CS	529
	530	dev->ieee80211_ptr->iftype = NL80211_IFTYPE_STATION;
	531	dev->ieee80211_ptr->wiphy = common_wiphy;
	532
	533	err = register_netdevice(dev);
	534	if (err) {
	535	dev_err(&priv->lowerdev->dev, "can't register_netdevice: %d\n",
	536	err);
	537	goto free_wireless_dev;
	538	}
	539
	540	err = netdev_upper_dev_link(priv->lowerdev, dev, extack);
	541	if (err) {
	542	dev_err(&priv->lowerdev->dev, "can't netdev_upper_dev_link: %d\n",
	543	err);
	544	goto unregister_netdev;
	545	}
	546
	547	priv->being_deleted = false;
	548	priv->is_connected = false;
	549	priv->is_up = false;
	550	INIT_DELAYED_WORK(&priv->connect, virt_wifi_connect_complete);
	551
	552	return 0;
	553	unregister_netdev:
	554	unregister_netdevice(dev);
	555	free_wireless_dev:
	556	kfree(dev->ieee80211_ptr);
	557	dev->ieee80211_ptr = NULL;
	558	remove_handler:
	559	netdev_rx_handler_unregister(priv->lowerdev);
	560
	561	return err;
	562	}
	563
	564	/* Called with rtnl lock held. */
	565	static void virt_wifi_dellink(struct net_device *dev,
	566	struct list_head *head)
	567	{
	568	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
	569
	570	if (dev->ieee80211_ptr)
	571	virt_wifi_cancel_scan(dev->ieee80211_ptr->wiphy);
	572
	573	priv->being_deleted = true;
	574	virt_wifi_cancel_connect(dev);
	575	netif_carrier_off(dev);
	576
	577	netdev_rx_handler_unregister(priv->lowerdev);
	578	netdev_upper_dev_unlink(priv->lowerdev, dev);
	579
	580	unregister_netdevice_queue(dev, head);
	581
	582	/* Deleting the wiphy is handled in the module destructor. */
	583	}
	584
	585	static struct rtnl_link_ops virt_wifi_link_ops = {
	586	.kind = "virt_wifi",
	587	.setup = virt_wifi_setup,
	588	.newlink = virt_wifi_newlink,
	589	.dellink = virt_wifi_dellink,
	590	.priv_size = sizeof(struct virt_wifi_netdev_priv),
	591	};
	592
593	/* Acquires and releases the rtnl lock. */
594	static int __init virt_wifi_init_module(void)
595	{
596	int err;
597
598	/* Guaranteed to be locallly-administered and not multicast. */
599	eth_random_addr(fake_router_bssid);
600
601	common_wiphy = virt_wifi_make_wiphy();
602	if (!common_wiphy)
603	return -ENOMEM;
604
605	err = rtnl_link_register(&virt_wifi_link_ops);
606	if (err)
607	virt_wifi_destroy_wiphy(common_wiphy);
608
609	return err;
610	}
611
612	/* Acquires and releases the rtnl lock. */
613	static void __exit virt_wifi_cleanup_module(void)
614	{
615	/* Will delete any devices that depend on the wiphy. */
616	rtnl_link_unregister(&virt_wifi_link_ops);
617	virt_wifi_destroy_wiphy(common_wiphy);
618	}
619
620	module_init(virt_wifi_init_module);
621	module_exit(virt_wifi_cleanup_module);
622
623	MODULE_LICENSE("GPL v2");
624	MODULE_AUTHOR("Cody Schuffelen <schuffelen@google.com>");
625	MODULE_DESCRIPTION("Driver for a wireless wrapper of ethernet devices");
626	MODULE_ALIAS_RTNL_LINK("virt_wifi");