drivers/net/wireless/virtual/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
  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
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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
 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 READ_ONCE(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. */
 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. */
 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 */
 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. */
 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. */
 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
 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
 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. */
 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. */
 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");