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