rtnl_unlock();
                        return -ENOLINK;
                }
-               ret = dev_set_mac_address(tap->dev, &sa, NULL);
+               ret = dev_set_mac_address_user(tap->dev, &sa, NULL);
                tap_put_tap_dev(tap);
                rtnl_unlock();
                return ret;
 
 
        case SIOCSIFHWADDR:
                /* Set hw address */
-               ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr, NULL);
+               ret = dev_set_mac_address_user(tun->dev, &ifr.ifr_hwaddr, NULL);
                break;
 
        case TUNGETSNDBUF:
 
         *
         * Protects:
         *      @gro_flush_timeout, @napi_defer_hard_irqs, @napi_list,
-        *      @net_shaper_hierarchy, @reg_state, @threaded, @dev_addr
+        *      @net_shaper_hierarchy, @reg_state, @threaded
         *
         * Partially protects (writers must hold both @lock and rtnl_lock):
         *      @up
                          struct netlink_ext_ack *extack);
 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
                        struct netlink_ext_ack *extack);
+int netif_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
+                              struct netlink_ext_ack *extack);
+int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
+                            struct netlink_ext_ack *extack);
 int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name);
 int dev_get_port_parent_id(struct net_device *dev,
                           struct netdev_phys_item_id *ppid, bool recurse);
 
        return __netdev_put_lock(dev);
 }
 
-/**
- * netdev_get_by_name_lock() - find a device by its name
- * @net: the applicable net namespace
- * @name: name of device
- *
- * Search for an interface by name. If a valid device
- * with @name is found it will be returned with netdev->lock held.
- * netdev_unlock() must be called to release it.
- *
- * Return: pointer to a device with lock held, NULL if not found.
- */
-struct net_device *netdev_get_by_name_lock(struct net *net, const char *name)
-{
-       struct net_device *dev;
-
-       dev = dev_get_by_name(net, name);
-       if (!dev)
-               return NULL;
-
-       return __netdev_put_lock(dev);
-}
-
 struct net_device *
 netdev_xa_find_lock(struct net *net, struct net_device *dev,
                    unsigned long *index)
        return 0;
 }
 
+DECLARE_RWSEM(dev_addr_sem);
+
+int netif_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
+                              struct netlink_ext_ack *extack)
+{
+       int ret;
+
+       down_write(&dev_addr_sem);
+       ret = netif_set_mac_address(dev, sa, extack);
+       up_write(&dev_addr_sem);
+       return ret;
+}
+
 int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name)
 {
        size_t size = sizeof(sa->sa_data_min);
        struct net_device *dev;
+       int ret = 0;
 
-       dev = netdev_get_by_name_lock(net, dev_name);
-       if (!dev)
-               return -ENODEV;
+       down_read(&dev_addr_sem);
+       rcu_read_lock();
 
+       dev = dev_get_by_name_rcu(net, dev_name);
+       if (!dev) {
+               ret = -ENODEV;
+               goto unlock;
+       }
        if (!dev->addr_len)
                memset(sa->sa_data, 0, size);
        else
                memcpy(sa->sa_data, dev->dev_addr,
                       min_t(size_t, size, dev->addr_len));
        sa->sa_family = dev->type;
-       netdev_unlock(dev);
 
-       return 0;
+unlock:
+       rcu_read_unlock();
+       up_read(&dev_addr_sem);
+       return ret;
 }
 EXPORT_SYMBOL(dev_get_mac_address);
 
 
 struct net_device *dev_get_by_napi_id(unsigned int napi_id);
 
 struct net_device *netdev_get_by_index_lock(struct net *net, int ifindex);
-struct net_device *netdev_get_by_name_lock(struct net *net, const char *name);
 struct net_device *__netdev_put_lock(struct net_device *dev);
 struct net_device *
 netdev_xa_find_lock(struct net *net, struct net_device *dev,
 extern int             dev_weight_rx_bias;
 extern int             dev_weight_tx_bias;
 
+extern struct rw_semaphore dev_addr_sem;
+
 /* rtnl helpers */
 extern struct list_head net_todo_list;
 void netdev_run_todo(void);
 
        netdev_unlock_ops(dev);
 }
 
+int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
+                            struct netlink_ext_ack *extack)
+{
+       int ret;
+
+       netdev_lock_ops(dev);
+       ret = netif_set_mac_address_user(dev, sa, extack);
+       netdev_unlock_ops(dev);
+
+       return ret;
+}
+EXPORT_SYMBOL(dev_set_mac_address_user);
+
 /**
  * dev_change_net_namespace() - move device to different nethost namespace
  * @dev: device
 {
        int ret;
 
-       netdev_lock(dev);
+       netdev_lock_ops(dev);
        ret = netif_set_mac_address(dev, sa, extack);
-       netdev_unlock(dev);
+       netdev_unlock_ops(dev);
 
        return ret;
 }
 
        case SIOCSIFHWADDR:
                if (dev->addr_len > sizeof(struct sockaddr))
                        return -EINVAL;
-               return dev_set_mac_address(dev, &ifr->ifr_hwaddr, NULL);
+               return dev_set_mac_address_user(dev, &ifr->ifr_hwaddr, NULL);
 
        case SIOCSIFHWBROADCAST:
                if (ifr->ifr_hwaddr.sa_family != dev->type)
 
        struct net_device *ndev = to_net_dev(dev);
        ssize_t ret = -EINVAL;
 
-       netdev_lock(ndev);
+       down_read(&dev_addr_sem);
+
+       rcu_read_lock();
        if (dev_isalive(ndev))
                ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
-       netdev_unlock(ndev);
+       rcu_read_unlock();
 
+       up_read(&dev_addr_sem);
        return ret;
 }
 static DEVICE_ATTR_RO(address);
 
                sa->sa_family = dev->type;
                memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
                       dev->addr_len);
-               if (!netdev_need_ops_lock(dev))
-                       netdev_lock(dev);
-               err = netif_set_mac_address(dev, sa, extack);
-               if (!netdev_need_ops_lock(dev))
-                       netdev_unlock(dev);
+               err = netif_set_mac_address_user(dev, sa, extack);
                kfree(sa);
                if (err)
                        goto errout;