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