cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

virt_wifi.c (18185B)


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