*/
        memcpy(ss.__data, addr, len);
        ss.ss_family = dev->type;
-       if (dev_set_mac_address(dev, (struct sockaddr *)&ss)) {
+       if (dev_set_mac_address(dev, (struct sockaddr *)&ss, NULL)) {
                netdev_err(slave->bond->dev, "dev_set_mac_address of dev %s failed! ALB mode requires that the base driver support setting the hw address also when the network device's interface is open\n",
                           dev->name);
                return -EOPNOTSUPP;
                bond_hw_addr_copy(tmp_addr, slave->dev->dev_addr,
                                  slave->dev->addr_len);
 
-               res = dev_set_mac_address(slave->dev, addr);
+               res = dev_set_mac_address(slave->dev, addr, NULL);
 
                /* restore net_device's hw address */
                bond_hw_addr_copy(slave->dev->dev_addr, tmp_addr,
                bond_hw_addr_copy(tmp_addr, rollback_slave->dev->dev_addr,
                                  rollback_slave->dev->addr_len);
                dev_set_mac_address(rollback_slave->dev,
-                                   (struct sockaddr *)&ss);
+                                   (struct sockaddr *)&ss, NULL);
                bond_hw_addr_copy(rollback_slave->dev->dev_addr, tmp_addr,
                                  rollback_slave->dev->addr_len);
        }
                                  bond->dev->addr_len);
                ss.ss_family = bond->dev->type;
                /* we don't care if it can't change its mac, best effort */
-               dev_set_mac_address(new_slave->dev, (struct sockaddr *)&ss);
+               dev_set_mac_address(new_slave->dev, (struct sockaddr *)&ss,
+                                   NULL);
 
                bond_hw_addr_copy(new_slave->dev->dev_addr, tmp_addr,
                                  new_slave->dev->addr_len);
 
                }
 
                rv = dev_set_mac_address(new_active->dev,
-                                        (struct sockaddr *)&ss);
+                                        (struct sockaddr *)&ss, NULL);
                if (rv) {
                        netdev_err(bond->dev, "Error %d setting MAC of slave %s\n",
                                   -rv, new_active->dev->name);
                ss.ss_family = old_active->dev->type;
 
                rv = dev_set_mac_address(old_active->dev,
-                                        (struct sockaddr *)&ss);
+                                        (struct sockaddr *)&ss, NULL);
                if (rv)
                        netdev_err(bond->dev, "Error %d setting MAC of slave %s\n",
                                   -rv, new_active->dev->name);
                 */
                memcpy(ss.__data, bond_dev->dev_addr, bond_dev->addr_len);
                ss.ss_family = slave_dev->type;
-               res = dev_set_mac_address(slave_dev, (struct sockaddr *)&ss);
+               res = dev_set_mac_address(slave_dev, (struct sockaddr *)&ss,
+                                         extack);
                if (res) {
                        netdev_dbg(bond_dev, "Error %d calling set_mac_address\n", res);
                        goto err_restore_mtu;
                bond_hw_addr_copy(ss.__data, new_slave->perm_hwaddr,
                                  new_slave->dev->addr_len);
                ss.ss_family = slave_dev->type;
-               dev_set_mac_address(slave_dev, (struct sockaddr *)&ss);
+               dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, NULL);
        }
 
 err_restore_mtu:
                bond_hw_addr_copy(ss.__data, slave->perm_hwaddr,
                                  slave->dev->addr_len);
                ss.ss_family = slave_dev->type;
-               dev_set_mac_address(slave_dev, (struct sockaddr *)&ss);
+               dev_set_mac_address(slave_dev, (struct sockaddr *)&ss, NULL);
        }
 
        if (unregister)
 
        bond_for_each_slave(bond, slave, iter) {
                netdev_dbg(bond_dev, "slave %p %s\n", slave, slave->dev->name);
-               res = dev_set_mac_address(slave->dev, addr);
+               res = dev_set_mac_address(slave->dev, addr, NULL);
                if (res) {
                        /* TODO: consider downing the slave
                         * and retry ?
                        break;
 
                tmp_res = dev_set_mac_address(rollback_slave->dev,
-                                             (struct sockaddr *)&tmp_ss);
+                                             (struct sockaddr *)&tmp_ss, NULL);
                if (tmp_res) {
                        netdev_dbg(bond_dev, "unwind err %d dev %s\n",
                                   tmp_res, rollback_slave->dev->name);
 
                return -ENODEV;
 
        if (vf_netdev) {
-               err = dev_set_mac_address(vf_netdev, addr);
+               err = dev_set_mac_address(vf_netdev, addr, NULL);
                if (err)
                        return err;
        }
        } else if (vf_netdev) {
                /* rollback change on VF */
                memcpy(addr->sa_data, ndev->dev_addr, ETH_ALEN);
-               dev_set_mac_address(vf_netdev, addr);
+               dev_set_mac_address(vf_netdev, addr, NULL);
        }
 
        return err;
 
 
        if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
                macvlan_set_addr_change(vlan->port);
-               return dev_set_mac_address(vlan->lowerdev, addr);
+               return dev_set_mac_address(vlan->lowerdev, addr, NULL);
        }
 
        if (macvlan_addr_busy(vlan->port, addr->sa_data))
 
                sa.sa_family = port->dev->type;
                memcpy(&sa.sa_data, port->perm_addr, port->dev->addr_len);
-               dev_set_mac_address(port->dev, &sa);
+               dev_set_mac_address(port->dev, &sa, NULL);
        }
 
        kfree(port);
 
                        rtnl_unlock();
                        return -ENOLINK;
                }
-               ret = dev_set_mac_address(tap->dev, &sa);
+               ret = dev_set_mac_address(tap->dev, &sa, NULL);
                tap_put_tap_dev(tap);
                rtnl_unlock();
                return ret;
 
 
        memcpy(addr.__data, dev_addr, port_dev->addr_len);
        addr.ss_family = port_dev->type;
-       return dev_set_mac_address(port_dev, (struct sockaddr *)&addr);
+       return dev_set_mac_address(port_dev, (struct sockaddr *)&addr, NULL);
 }
 
 static int team_port_set_orig_dev_addr(struct team_port *port)
 
                tun_debug(KERN_DEBUG, tun, "set hw address: %pM\n",
                          ifr.ifr_hwaddr.sa_data);
 
-               ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr);
+               ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr, NULL);
                break;
 
        case TUNGETSNDBUF:
 
        sa.sa_family = net->type;
        memcpy(sa.sa_data, dev->dev_mac, ETH_ALEN);
        rtnl_lock();
-       status = dev_set_mac_address(net, &sa);
+       status = dev_set_mac_address(net, &sa, NULL);
        rtnl_unlock();
        if (status)
                pr_warn("cannot set self ethernet address: %d\n", status);
 
 int dev_set_mtu(struct net_device *, int);
 int dev_change_tx_queue_len(struct net_device *, unsigned long);
 void dev_set_group(struct net_device *, int);
-int dev_set_mac_address(struct net_device *, struct sockaddr *);
+int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
+                       struct netlink_ext_ack *extack);
 int dev_change_carrier(struct net_device *, bool new_carrier);
 int dev_get_phys_port_id(struct net_device *dev,
                         struct netdev_phys_item_id *ppid);
 
  *     dev_set_mac_address - Change Media Access Control Address
  *     @dev: device
  *     @sa: new address
+ *     @extack: netlink extended ack
  *
  *     Change the hardware (MAC) address of the device
  */
-int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
+int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
+                       struct netlink_ext_ack *extack)
 {
        const struct net_device_ops *ops = dev->netdev_ops;
        int err;
 
        case SIOCSIFHWADDR:
                if (dev->addr_len > sizeof(struct sockaddr))
                        return -EINVAL;
-               return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
+               return dev_set_mac_address(dev, &ifr->ifr_hwaddr, NULL);
 
        case SIOCSIFHWBROADCAST:
                if (ifr->ifr_hwaddr.sa_family != dev->type)
 
                sa->sa_family = dev->type;
                memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
                       dev->addr_len);
-               err = dev_set_mac_address(dev, sa);
+               err = dev_set_mac_address(dev, sa, extack);
                kfree(sa);
                if (err)
                        goto errout;
 
                 * dev_set_mac_address require RTNL_LOCK
                 */
                rtnl_lock();
-               rc = dev_set_mac_address(dev, &addr);
+               rc = dev_set_mac_address(dev, &addr, NULL);
                rtnl_unlock();
                if (rc)
                        goto dev_unregister;