virt_wifi.c

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