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 
18 static struct wiphy *common_wiphy;
19 
20 struct virt_wifi_wiphy_priv {
21 	struct delayed_work scan_result;
22 	struct cfg80211_scan_request *scan_request;
23 	bool being_deleted;
24 };
25 
26 static struct ieee80211_channel channel_2ghz = {
27 	.band = NL80211_BAND_2GHZ,
28 	.center_freq = 2432,
29 	.hw_value = 2432,
30 	.max_power = 20,
31 };
32 
33 static 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 
43 static 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 
65 static struct ieee80211_channel channel_5ghz = {
66 	.band = NL80211_BAND_5GHZ,
67 	.center_freq = 5240,
68 	.hw_value = 5240,
69 	.max_power = 20,
70 };
71 
72 static 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 
96 static 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. */
137 static u8 fake_router_bssid[ETH_ALEN] __ro_after_init = {};
138 
139 #define VIRT_WIFI_SSID "VirtWifi"
140 #define VIRT_WIFI_SSID_LEN 8
141 
virt_wifi_inform_bss(struct wiphy * wiphy)142 static 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];
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. */
virt_wifi_scan(struct wiphy * wiphy,struct cfg80211_scan_request * request)166 static 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. */
virt_wifi_scan_result(struct work_struct * work)183 static 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. */
virt_wifi_cancel_scan(struct wiphy * wiphy)199 static 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 
213 struct 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. */
virt_wifi_connect(struct wiphy * wiphy,struct net_device * netdev,struct cfg80211_connect_params * sme)228 static 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. */
virt_wifi_connect_complete(struct work_struct * work)260 static 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, requested_bss, NULL, 0, NULL, 0,
281 				status, GFP_KERNEL);
282 	netif_carrier_on(priv->upperdev);
283 }
284 
285 /* May acquire and release the rdev event lock. */
virt_wifi_cancel_connect(struct net_device * netdev)286 static void virt_wifi_cancel_connect(struct net_device *netdev)
287 {
288 	struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
289 
290 	/* If there is work pending, clean up dangling callbacks. */
291 	if (cancel_delayed_work_sync(&priv->connect)) {
292 		/* Schedules an event that acquires the rtnl lock. */
293 		cfg80211_connect_result(priv->upperdev,
294 					priv->connect_requested_bss, NULL, 0,
295 					NULL, 0,
296 					WLAN_STATUS_UNSPECIFIED_FAILURE,
297 					GFP_KERNEL);
298 	}
299 }
300 
301 /* Called with the rtnl lock held. Acquires the rdev event lock. */
virt_wifi_disconnect(struct wiphy * wiphy,struct net_device * netdev,u16 reason_code)302 static int virt_wifi_disconnect(struct wiphy *wiphy, struct net_device *netdev,
303 				u16 reason_code)
304 {
305 	struct virt_wifi_netdev_priv *priv = netdev_priv(netdev);
306 
307 	if (priv->being_deleted)
308 		return -EBUSY;
309 
310 	wiphy_debug(wiphy, "disconnect\n");
311 	virt_wifi_cancel_connect(netdev);
312 
313 	cfg80211_disconnected(netdev, reason_code, NULL, 0, true, GFP_KERNEL);
314 	priv->is_connected = false;
315 	netif_carrier_off(netdev);
316 
317 	return 0;
318 }
319 
320 /* Called with the rtnl lock held. */
virt_wifi_get_station(struct wiphy * wiphy,struct net_device * dev,const u8 * mac,struct station_info * sinfo)321 static int virt_wifi_get_station(struct wiphy *wiphy, struct net_device *dev,
322 				 const u8 *mac, struct station_info *sinfo)
323 {
324 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
325 
326 	wiphy_debug(wiphy, "get_station\n");
327 
328 	if (!priv->is_connected || !ether_addr_equal(mac, fake_router_bssid))
329 		return -ENOENT;
330 
331 	sinfo->filled = BIT_ULL(NL80211_STA_INFO_TX_PACKETS) |
332 		BIT_ULL(NL80211_STA_INFO_TX_FAILED) |
333 		BIT_ULL(NL80211_STA_INFO_SIGNAL) |
334 		BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
335 	sinfo->tx_packets = priv->tx_packets;
336 	sinfo->tx_failed = priv->tx_failed;
337 	/* For CFG80211_SIGNAL_TYPE_MBM, value is expressed in _dBm_ */
338 	sinfo->signal = -50;
339 	sinfo->txrate = (struct rate_info) {
340 		.legacy = 10, /* units are 100kbit/s */
341 	};
342 	return 0;
343 }
344 
345 /* Called with the rtnl lock held. */
virt_wifi_dump_station(struct wiphy * wiphy,struct net_device * dev,int idx,u8 * mac,struct station_info * sinfo)346 static int virt_wifi_dump_station(struct wiphy *wiphy, struct net_device *dev,
347 				  int idx, u8 *mac, struct station_info *sinfo)
348 {
349 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
350 
351 	wiphy_debug(wiphy, "dump_station\n");
352 
353 	if (idx != 0 || !priv->is_connected)
354 		return -ENOENT;
355 
356 	ether_addr_copy(mac, fake_router_bssid);
357 	return virt_wifi_get_station(wiphy, dev, fake_router_bssid, sinfo);
358 }
359 
360 static const struct cfg80211_ops virt_wifi_cfg80211_ops = {
361 	.scan = virt_wifi_scan,
362 
363 	.connect = virt_wifi_connect,
364 	.disconnect = virt_wifi_disconnect,
365 
366 	.get_station = virt_wifi_get_station,
367 	.dump_station = virt_wifi_dump_station,
368 };
369 
370 /* Acquires and releases the rtnl lock. */
virt_wifi_make_wiphy(void)371 static struct wiphy *virt_wifi_make_wiphy(void)
372 {
373 	struct wiphy *wiphy;
374 	struct virt_wifi_wiphy_priv *priv;
375 	int err;
376 
377 	wiphy = wiphy_new(&virt_wifi_cfg80211_ops, sizeof(*priv));
378 
379 	if (!wiphy)
380 		return NULL;
381 
382 	wiphy->max_scan_ssids = 4;
383 	wiphy->max_scan_ie_len = 1000;
384 	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
385 
386 	wiphy->bands[NL80211_BAND_2GHZ] = &band_2ghz;
387 	wiphy->bands[NL80211_BAND_5GHZ] = &band_5ghz;
388 	wiphy->bands[NL80211_BAND_60GHZ] = NULL;
389 
390 	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
391 
392 	priv = wiphy_priv(wiphy);
393 	priv->being_deleted = false;
394 	priv->scan_request = NULL;
395 	INIT_DELAYED_WORK(&priv->scan_result, virt_wifi_scan_result);
396 
397 	err = wiphy_register(wiphy);
398 	if (err < 0) {
399 		wiphy_free(wiphy);
400 		return NULL;
401 	}
402 
403 	return wiphy;
404 }
405 
406 /* Acquires and releases the rtnl lock. */
virt_wifi_destroy_wiphy(struct wiphy * wiphy)407 static void virt_wifi_destroy_wiphy(struct wiphy *wiphy)
408 {
409 	struct virt_wifi_wiphy_priv *priv;
410 
411 	WARN(!wiphy, "%s called with null wiphy", __func__);
412 	if (!wiphy)
413 		return;
414 
415 	priv = wiphy_priv(wiphy);
416 	priv->being_deleted = true;
417 	virt_wifi_cancel_scan(wiphy);
418 
419 	if (wiphy->registered)
420 		wiphy_unregister(wiphy);
421 	wiphy_free(wiphy);
422 }
423 
424 /* Enters and exits a RCU-bh critical section. */
virt_wifi_start_xmit(struct sk_buff * skb,struct net_device * dev)425 static netdev_tx_t virt_wifi_start_xmit(struct sk_buff *skb,
426 					struct net_device *dev)
427 {
428 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
429 
430 	priv->tx_packets++;
431 	if (!priv->is_connected) {
432 		priv->tx_failed++;
433 		return NET_XMIT_DROP;
434 	}
435 
436 	skb->dev = priv->lowerdev;
437 	return dev_queue_xmit(skb);
438 }
439 
440 /* Called with rtnl lock held. */
virt_wifi_net_device_open(struct net_device * dev)441 static int virt_wifi_net_device_open(struct net_device *dev)
442 {
443 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
444 
445 	priv->is_up = true;
446 	return 0;
447 }
448 
449 /* Called with rtnl lock held. */
virt_wifi_net_device_stop(struct net_device * dev)450 static int virt_wifi_net_device_stop(struct net_device *dev)
451 {
452 	struct virt_wifi_netdev_priv *n_priv = netdev_priv(dev);
453 
454 	n_priv->is_up = false;
455 
456 	if (!dev->ieee80211_ptr)
457 		return 0;
458 
459 	virt_wifi_cancel_scan(dev->ieee80211_ptr->wiphy);
460 	virt_wifi_cancel_connect(dev);
461 	netif_carrier_off(dev);
462 
463 	return 0;
464 }
465 
virt_wifi_net_device_get_iflink(const struct net_device * dev)466 static int virt_wifi_net_device_get_iflink(const struct net_device *dev)
467 {
468 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
469 
470 	return priv->lowerdev->ifindex;
471 }
472 
473 static const struct net_device_ops virt_wifi_ops = {
474 	.ndo_start_xmit = virt_wifi_start_xmit,
475 	.ndo_open	= virt_wifi_net_device_open,
476 	.ndo_stop	= virt_wifi_net_device_stop,
477 	.ndo_get_iflink = virt_wifi_net_device_get_iflink,
478 };
479 
480 /* Invoked as part of rtnl lock release. */
virt_wifi_net_device_destructor(struct net_device * dev)481 static void virt_wifi_net_device_destructor(struct net_device *dev)
482 {
483 	/* Delayed past dellink to allow nl80211 to react to the device being
484 	 * deleted.
485 	 */
486 	kfree(dev->ieee80211_ptr);
487 	dev->ieee80211_ptr = NULL;
488 }
489 
490 /* No lock interaction. */
virt_wifi_setup(struct net_device * dev)491 static void virt_wifi_setup(struct net_device *dev)
492 {
493 	ether_setup(dev);
494 	dev->netdev_ops = &virt_wifi_ops;
495 	dev->needs_free_netdev  = true;
496 }
497 
498 /* Called in a RCU read critical section from netif_receive_skb */
virt_wifi_rx_handler(struct sk_buff ** pskb)499 static rx_handler_result_t virt_wifi_rx_handler(struct sk_buff **pskb)
500 {
501 	struct sk_buff *skb = *pskb;
502 	struct virt_wifi_netdev_priv *priv =
503 		rcu_dereference(skb->dev->rx_handler_data);
504 
505 	if (!priv->is_connected)
506 		return RX_HANDLER_PASS;
507 
508 	/* GFP_ATOMIC because this is a packet interrupt handler. */
509 	skb = skb_share_check(skb, GFP_ATOMIC);
510 	if (!skb) {
511 		dev_err(&priv->upperdev->dev, "can't skb_share_check\n");
512 		return RX_HANDLER_CONSUMED;
513 	}
514 
515 	*pskb = skb;
516 	skb->dev = priv->upperdev;
517 	skb->pkt_type = PACKET_HOST;
518 	return RX_HANDLER_ANOTHER;
519 }
520 
521 /* Called with rtnl lock held. */
virt_wifi_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)522 static int virt_wifi_newlink(struct net *src_net, struct net_device *dev,
523 			     struct nlattr *tb[], struct nlattr *data[],
524 			     struct netlink_ext_ack *extack)
525 {
526 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
527 	int err;
528 
529 	if (!tb[IFLA_LINK])
530 		return -EINVAL;
531 
532 	netif_carrier_off(dev);
533 
534 	priv->upperdev = dev;
535 	priv->lowerdev = __dev_get_by_index(src_net,
536 					    nla_get_u32(tb[IFLA_LINK]));
537 
538 	if (!priv->lowerdev)
539 		return -ENODEV;
540 	if (!tb[IFLA_MTU])
541 		dev->mtu = priv->lowerdev->mtu;
542 	else if (dev->mtu > priv->lowerdev->mtu)
543 		return -EINVAL;
544 
545 	err = netdev_rx_handler_register(priv->lowerdev, virt_wifi_rx_handler,
546 					 priv);
547 	if (err) {
548 		dev_err(&priv->lowerdev->dev,
549 			"can't netdev_rx_handler_register: %d\n", err);
550 		return err;
551 	}
552 
553 	eth_hw_addr_inherit(dev, priv->lowerdev);
554 	netif_stacked_transfer_operstate(priv->lowerdev, dev);
555 
556 	SET_NETDEV_DEV(dev, &priv->lowerdev->dev);
557 	dev->ieee80211_ptr = kzalloc(sizeof(*dev->ieee80211_ptr), GFP_KERNEL);
558 
559 	if (!dev->ieee80211_ptr) {
560 		err = -ENOMEM;
561 		goto remove_handler;
562 	}
563 
564 	dev->ieee80211_ptr->iftype = NL80211_IFTYPE_STATION;
565 	dev->ieee80211_ptr->wiphy = common_wiphy;
566 
567 	err = register_netdevice(dev);
568 	if (err) {
569 		dev_err(&priv->lowerdev->dev, "can't register_netdevice: %d\n",
570 			err);
571 		goto free_wireless_dev;
572 	}
573 
574 	err = netdev_upper_dev_link(priv->lowerdev, dev, extack);
575 	if (err) {
576 		dev_err(&priv->lowerdev->dev, "can't netdev_upper_dev_link: %d\n",
577 			err);
578 		goto unregister_netdev;
579 	}
580 
581 	dev->priv_destructor = virt_wifi_net_device_destructor;
582 	priv->being_deleted = false;
583 	priv->is_connected = false;
584 	priv->is_up = false;
585 	INIT_DELAYED_WORK(&priv->connect, virt_wifi_connect_complete);
586 	__module_get(THIS_MODULE);
587 
588 	return 0;
589 unregister_netdev:
590 	unregister_netdevice(dev);
591 free_wireless_dev:
592 	kfree(dev->ieee80211_ptr);
593 	dev->ieee80211_ptr = NULL;
594 remove_handler:
595 	netdev_rx_handler_unregister(priv->lowerdev);
596 
597 	return err;
598 }
599 
600 /* Called with rtnl lock held. */
virt_wifi_dellink(struct net_device * dev,struct list_head * head)601 static void virt_wifi_dellink(struct net_device *dev,
602 			      struct list_head *head)
603 {
604 	struct virt_wifi_netdev_priv *priv = netdev_priv(dev);
605 
606 	if (dev->ieee80211_ptr)
607 		virt_wifi_cancel_scan(dev->ieee80211_ptr->wiphy);
608 
609 	priv->being_deleted = true;
610 	virt_wifi_cancel_connect(dev);
611 	netif_carrier_off(dev);
612 
613 	netdev_rx_handler_unregister(priv->lowerdev);
614 	netdev_upper_dev_unlink(priv->lowerdev, dev);
615 
616 	unregister_netdevice_queue(dev, head);
617 	module_put(THIS_MODULE);
618 
619 	/* Deleting the wiphy is handled in the module destructor. */
620 }
621 
622 static struct rtnl_link_ops virt_wifi_link_ops = {
623 	.kind		= "virt_wifi",
624 	.setup		= virt_wifi_setup,
625 	.newlink	= virt_wifi_newlink,
626 	.dellink	= virt_wifi_dellink,
627 	.priv_size	= sizeof(struct virt_wifi_netdev_priv),
628 };
629 
netif_is_virt_wifi_dev(const struct net_device * dev)630 static bool netif_is_virt_wifi_dev(const struct net_device *dev)
631 {
632 	return rcu_access_pointer(dev->rx_handler) == virt_wifi_rx_handler;
633 }
634 
virt_wifi_event(struct notifier_block * this,unsigned long event,void * ptr)635 static int virt_wifi_event(struct notifier_block *this, unsigned long event,
636 			   void *ptr)
637 {
638 	struct net_device *lower_dev = netdev_notifier_info_to_dev(ptr);
639 	struct virt_wifi_netdev_priv *priv;
640 	struct net_device *upper_dev;
641 	LIST_HEAD(list_kill);
642 
643 	if (!netif_is_virt_wifi_dev(lower_dev))
644 		return NOTIFY_DONE;
645 
646 	switch (event) {
647 	case NETDEV_UNREGISTER:
648 		priv = rtnl_dereference(lower_dev->rx_handler_data);
649 		if (!priv)
650 			return NOTIFY_DONE;
651 
652 		upper_dev = priv->upperdev;
653 
654 		upper_dev->rtnl_link_ops->dellink(upper_dev, &list_kill);
655 		unregister_netdevice_many(&list_kill);
656 		break;
657 	}
658 
659 	return NOTIFY_DONE;
660 }
661 
662 static struct notifier_block virt_wifi_notifier = {
663 	.notifier_call = virt_wifi_event,
664 };
665 
666 /* Acquires and releases the rtnl lock. */
virt_wifi_init_module(void)667 static int __init virt_wifi_init_module(void)
668 {
669 	int err;
670 
671 	/* Guaranteed to be locally-administered and not multicast. */
672 	eth_random_addr(fake_router_bssid);
673 
674 	err = register_netdevice_notifier(&virt_wifi_notifier);
675 	if (err)
676 		return err;
677 
678 	err = -ENOMEM;
679 	common_wiphy = virt_wifi_make_wiphy();
680 	if (!common_wiphy)
681 		goto notifier;
682 
683 	err = rtnl_link_register(&virt_wifi_link_ops);
684 	if (err)
685 		goto destroy_wiphy;
686 
687 	return 0;
688 
689 destroy_wiphy:
690 	virt_wifi_destroy_wiphy(common_wiphy);
691 notifier:
692 	unregister_netdevice_notifier(&virt_wifi_notifier);
693 	return err;
694 }
695 
696 /* Acquires and releases the rtnl lock. */
virt_wifi_cleanup_module(void)697 static void __exit virt_wifi_cleanup_module(void)
698 {
699 	/* Will delete any devices that depend on the wiphy. */
700 	rtnl_link_unregister(&virt_wifi_link_ops);
701 	virt_wifi_destroy_wiphy(common_wiphy);
702 	unregister_netdevice_notifier(&virt_wifi_notifier);
703 }
704 
705 module_init(virt_wifi_init_module);
706 module_exit(virt_wifi_cleanup_module);
707 
708 MODULE_LICENSE("GPL v2");
709 MODULE_AUTHOR("Cody Schuffelen <schuffelen@google.com>");
710 MODULE_DESCRIPTION("Driver for a wireless wrapper of ethernet devices");
711 MODULE_ALIAS_RTNL_LINK("virt_wifi");
712