slave_dev->flags |= IFF_SLAVE;
 
        /* open the slave since the application closed it */
-       res = dev_open(slave_dev);
+       res = dev_open(slave_dev, extack);
        if (res) {
                netdev_dbg(bond_dev, "Opening slave %s failed\n", slave_dev->name);
                goto err_restore_mac;
 
                }
        }
        if (ndev_running)
-               err = dev_open(ndev);
+               err = dev_open(ndev, NULL);
 
 err_exit:
        return err;
 
        }
        enic_init_vnic_resources(enic);
        if (running) {
-               err = dev_open(netdev);
+               err = dev_open(netdev, NULL);
                if (err)
                        goto err_out;
        }
 
                clear_bit(NIC_STATE_TESTING, &priv->state);
 
                if (if_running)
-                       (void)dev_open(ndev);
+                       (void)dev_open(ndev, NULL);
        }
        /* Online tests aren't run; pass by default */
 
 
        }
 
        if (if_running)
-               ret = dev_open(ndev);
+               ret = dev_open(ndev, NULL);
 
        return ret;
 }
 
        /* We need rx buffers and interrupts. */
        already_up = (efx->net_dev->flags & IFF_UP);
        if (!already_up) {
-               rc = dev_open(efx->net_dev);
+               rc = dev_open(efx->net_dev, NULL);
                if (rc) {
                        netif_err(efx, drv, efx->net_dev,
                                  "failed opening device.\n");
 
        /* We need rx buffers and interrupts. */
        already_up = (efx->net_dev->flags & IFF_UP);
        if (!already_up) {
-               rc = dev_open(efx->net_dev);
+               rc = dev_open(efx->net_dev, NULL);
                if (rc) {
                        netif_err(efx, drv, efx->net_dev,
                                  "failed opening device.\n");
 
 
        set_bit(STMMAC_DOWN, &priv->state);
        dev_close(priv->dev);
-       dev_open(priv->dev);
+       dev_open(priv->dev, NULL);
        clear_bit(STMMAC_DOWN, &priv->state);
        clear_bit(STMMAC_RESETING, &priv->state);
        rtnl_unlock();
 
                 * slave as up. If open fails, then slave will be
                 * still be offline (and not used).
                 */
-               ret = dev_open(vf_netdev);
+               ret = dev_open(vf_netdev, NULL);
                if (ret)
                        netdev_warn(net,
                                    "unable to open slave: %s: %d\n",
        netif_addr_unlock_bh(ndev);
 
        if (netif_running(ndev)) {
-               ret = dev_open(vf_netdev);
+               ret = dev_open(vf_netdev, NULL);
                if (ret)
                        netdev_warn(vf_netdev,
                                    "unable to open: %d\n", ret);
 
 
        primary_dev = rtnl_dereference(nfo_info->primary_dev);
        if (primary_dev) {
-               err = dev_open(primary_dev);
+               err = dev_open(primary_dev, NULL);
                if (err)
                        goto err_primary_open;
        }
 
        standby_dev = rtnl_dereference(nfo_info->standby_dev);
        if (standby_dev) {
-               err = dev_open(standby_dev);
+               err = dev_open(standby_dev, NULL);
                if (err)
                        goto err_standby_open;
        }
        dev_hold(slave_dev);
 
        if (netif_running(failover_dev)) {
-               err = dev_open(slave_dev);
+               err = dev_open(slave_dev, NULL);
                if (err && (err != -EBUSY)) {
                        netdev_err(failover_dev, "Opening slave %s failed err:%d\n",
                                   slave_dev->name, err);
        /* We need to bring up the slave after the rename by udev in case
         * open failed with EBUSY when it was registered.
         */
-       dev_open(slave_dev);
+       dev_open(slave_dev, NULL);
 
        return 0;
 }
 
                goto err_port_enter;
        }
 
-       err = dev_open(port_dev);
+       err = dev_open(port_dev, extack);
        if (err) {
                netdev_dbg(dev, "Device %s opening failed\n",
                           portname);
 
                /* Master radio interface is needed for all operation, so open
                 * it automatically when any virtual net_device is opened. */
                local->master_dev_auto_open = 1;
-               dev_open(local->dev);
+               dev_open(local->dev, NULL);
        }
 
        netif_device_attach(dev);
 
                        qeth_l2_set_rx_mode(card->dev);
                } else {
                        rtnl_lock();
-                       dev_open(card->dev);
+                       dev_open(card->dev, NULL);
                        rtnl_unlock();
                }
        }
 
                        __qeth_l3_open(card->dev);
                        qeth_l3_set_rx_mode(card->dev);
                } else {
-                       dev_open(card->dev);
+                       dev_open(card->dev, NULL);
                }
                rtnl_unlock();
        }
 
 
        for (i = 0; i < ethsw->sw_attr.num_ifs; i++) {
                port_priv = ethsw->ports[i];
-               err = dev_open(port_priv->netdev);
+               err = dev_open(port_priv->netdev, NULL);
                if (err) {
                        netdev_err(port_priv->netdev, "dev_open err %d\n", err);
                        return err;
 
        mod_timer(&devdata->irq_poll_timer, msecs_to_jiffies(2));
 
        rtnl_lock();
-       dev_open(netdev);
+       dev_open(netdev, NULL);
        rtnl_unlock();
 
        complete_func(dev, 0);
 
 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
 struct net_device *__dev_get_by_name(struct net *net, const char *name);
 int dev_alloc_name(struct net_device *dev, const char *name);
-int dev_open(struct net_device *dev);
+int dev_open(struct net_device *dev, struct netlink_ext_ack *extack);
 void dev_close(struct net_device *dev);
 void dev_close_many(struct list_head *head, bool unlink);
 void dev_disable_lro(struct net_device *dev);
 
        int err;
 
        rtnl_lock();
-       err = dev_open(netdev);
+       err = dev_open(netdev, NULL);
        if (err < 0)
                BT_INFO("iface %s cannot be opened (%d)", netdev->name, err);
        rtnl_unlock();
 
 
 /**
  *     dev_open        - prepare an interface for use.
- *     @dev:   device to open
+ *     @dev: device to open
+ *     @extack: netlink extended ack
  *
  *     Takes a device from down to up state. The device's private open
  *     function is invoked and then the multicast lists are loaded. Finally
  *     Calling this function on an active interface is a nop. On a failure
  *     a negative errno code is returned.
  */
-int dev_open(struct net_device *dev)
+int dev_open(struct net_device *dev, struct netlink_ext_ack *extack)
 {
        int ret;
 
 
 
                np_info(np, "device %s not up yet, forcing it\n", np->dev_name);
 
-               err = dev_open(ndev);
+               err = dev_open(ndev, NULL);
 
                if (err) {
                        np_err(np, "failed to open %s\n", ndev->name);
 
                        dev->flags |= IFF_MULTICAST;
                        if (!ipmr_init_vif_indev(dev))
                                goto failure;
-                       if (dev_open(dev))
+                       if (dev_open(dev, NULL))
                                goto failure;
                        dev_hold(dev);
                }
 
        if (!ipmr_init_vif_indev(dev))
                goto failure;
-       if (dev_open(dev))
+       if (dev_open(dev, NULL))
                goto failure;
 
        dev_hold(dev);
 
                        dev = __dev_get_by_name(net, p.name);
                        if (!dev)
                                goto err_exit;
-                       err = dev_open(dev);
+                       err = dev_open(dev, NULL);
                }
        }
 #endif
 
                return NULL;
        }
 
-       if (dev_open(dev))
+       if (dev_open(dev, NULL))
                goto failure;
 
        dev_hold(dev);