Merge branch 'sync_multiple'

Vlad Yasevich says:

====================
Current dev_[uc|mc]_addr_sync() API currently correctly syncs the
addresses to the first device.  Any subsequent calls to sync will
not do anything since the synched variable will be set.  This
variable is used as an optimization to skip over addresses that have
been synched.

There are some devices (ex: team) that attempt to do the above.  There
is other work in progress that needs to above to work corretly.

The short series introduces dev_[uc|mc]_addr_synch_multiple() that
allows multiple calls to sync to multiple different devices.  Original
API is left alone and still has the limitation.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

3 files changed, 173 insertions, 44 deletions

diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index 621c1bddeee9..9a31e8e50fac 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -1504,8 +1504,8 @@ static void team_set_rx_mode(struct net_device *dev)
 
         rcu_read_lock();
         list_for_each_entry_rcu(port, &team->port_list, list) {
-                dev_uc_sync(port->dev, dev);
-                dev_mc_sync(port->dev, dev);
+                dev_uc_sync_multiple(port->dev, dev);
+                dev_mc_sync_multiple(port->dev, dev);
         }
         rcu_read_unlock();
 }
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 53d3939358a7..623b57b52195 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -209,6 +209,7 @@ struct netdev_hw_addr {
 #define NETDEV_HW_ADDR_T_UNICAST        4
 #define NETDEV_HW_ADDR_T_MULTICAST      5
         bool                    global_use;
+        int                     sync_cnt;
         int                     refcount;
         int                     synced;
         struct rcu_head         rcu_head;
@@ -2627,6 +2628,7 @@ extern int dev_uc_add(struct net_device *dev, const unsigned char *addr);
 extern int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
 extern int dev_uc_del(struct net_device *dev, const unsigned char *addr);
 extern int dev_uc_sync(struct net_device *to, struct net_device *from);
+extern int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
 extern void dev_uc_unsync(struct net_device *to, struct net_device *from);
 extern void dev_uc_flush(struct net_device *dev);
 extern void dev_uc_init(struct net_device *dev);
@@ -2638,6 +2640,7 @@ extern int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
 extern int dev_mc_del(struct net_device *dev, const unsigned char *addr);
 extern int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
 extern int dev_mc_sync(struct net_device *to, struct net_device *from);
+extern int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
 extern void dev_mc_unsync(struct net_device *to, struct net_device *from);
 extern void dev_mc_flush(struct net_device *dev);
 extern void dev_mc_init(struct net_device *dev);
diff --git a/net/core/dev_addr_lists.c b/net/core/dev_addr_lists.c
index abdc9e6ef33e..c013f38482a1 100644
--- a/net/core/dev_addr_lists.c
+++ b/net/core/dev_addr_lists.c
@@ -22,7 +22,8 @@
 
 static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
                                const unsigned char *addr, int addr_len,
-                               unsigned char addr_type, bool global)
+                               unsigned char addr_type, bool global,
+                               bool sync)
 {
         struct netdev_hw_addr *ha;
         int alloc_size;
@@ -37,7 +38,7 @@ static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
         ha->type = addr_type;
         ha->refcount = 1;
         ha->global_use = global;
-        ha->synced = 0;
+        ha->synced = sync;
         list_add_tail_rcu(&ha->list, &list->list);
         list->count++;
 
@@ -46,7 +47,7 @@ static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
 
 static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
                             const unsigned char *addr, int addr_len,
-                            unsigned char addr_type, bool global)
+                            unsigned char addr_type, bool global, bool sync)
 {
         struct netdev_hw_addr *ha;
 
@@ -63,43 +64,62 @@ static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
                                 else
                                         ha->global_use = true;
                         }
+                        if (sync) {
+                                if (ha->synced)
+                                        return 0;
+                                else
+                                        ha->synced = true;
+                        }
                         ha->refcount++;
                         return 0;
                 }
         }
 
-        return __hw_addr_create_ex(list, addr, addr_len, addr_type, global);
+        return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
+                                   sync);
 }
 
 static int __hw_addr_add(struct netdev_hw_addr_list *list,
                          const unsigned char *addr, int addr_len,
                          unsigned char addr_type)
 {
-        return __hw_addr_add_ex(list, addr, addr_len, addr_type, false);
+        return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false);
+}
+
+static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
+                               struct netdev_hw_addr *ha, bool global,
+                               bool sync)
+{
+        if (global && !ha->global_use)
+                return -ENOENT;
+
+        if (sync && !ha->synced)
+                return -ENOENT;
+
+        if (global)
+                ha->global_use = false;
+
+        if (sync)
+                ha->synced = false;
+
+        if (--ha->refcount)
+                return 0;
+        list_del_rcu(&ha->list);
+        kfree_rcu(ha, rcu_head);
+        list->count--;
+        return 0;
 }
 
 static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
                             const unsigned char *addr, int addr_len,
-                            unsigned char addr_type, bool global)
+                            unsigned char addr_type, bool global, bool sync)
 {
         struct netdev_hw_addr *ha;
 
         list_for_each_entry(ha, &list->list, list) {
                 if (!memcmp(ha->addr, addr, addr_len) &&
-                    (ha->type == addr_type || !addr_type)) {
-                        if (global) {
-                                if (!ha->global_use)
-                                        break;
-                                else
-                                        ha->global_use = false;
-                        }
-                        if (--ha->refcount)
-                                return 0;
-                        list_del_rcu(&ha->list);
-                        kfree_rcu(ha, rcu_head);
-                        list->count--;
-                        return 0;
-                }
+                    (ha->type == addr_type || !addr_type))
+                        return __hw_addr_del_entry(list, ha, global, sync);
         }
         return -ENOENT;
 }
@@ -108,7 +128,57 @@ static int __hw_addr_del(struct netdev_hw_addr_list *list,
                          const unsigned char *addr, int addr_len,
                          unsigned char addr_type)
 {
-        return __hw_addr_del_ex(list, addr, addr_len, addr_type, false);
+        return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
+}
+
+static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
+                               struct netdev_hw_addr *ha,
+                               int addr_len)
+{
+        int err;
+
+        err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
+                               false, true);
+        if (err)
+                return err;
+        ha->sync_cnt++;
+        ha->refcount++;
+
+        return 0;
+}
+
+static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
+                                 struct netdev_hw_addr_list *from_list,
+                                 struct netdev_hw_addr *ha,
+                                 int addr_len)
+{
+        int err;
+
+        err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
+                               false, true);
+        if (err)
+                return;
+        ha->sync_cnt--;
+        __hw_addr_del_entry(from_list, ha, false, true);
+}
+
+static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
+                                   struct netdev_hw_addr_list *from_list,
+                                   int addr_len)
+{
+        int err = 0;
+        struct netdev_hw_addr *ha, *tmp;
+
+        list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
+                if (ha->sync_cnt == ha->refcount) {
+                        __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
+                } else {
+                        err = __hw_addr_sync_one(to_list, ha, addr_len);
+                        if (err)
+                                break;
+                }
+        }
+        return err;
 }
 
 int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
@@ -152,6 +222,11 @@ void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
 }
 EXPORT_SYMBOL(__hw_addr_del_multiple);
 
+/* This function only works where there is a strict 1-1 relationship
+ * between source and destionation of they synch. If you ever need to
+ * sync addresses to more then 1 destination, you need to use
+ * __hw_addr_sync_multiple().
+ */
 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
                    struct netdev_hw_addr_list *from_list,
                    int addr_len)
@@ -160,17 +235,12 @@ int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
         struct netdev_hw_addr *ha, *tmp;
 
         list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
-                if (!ha->synced) {
-                        err = __hw_addr_add(to_list, ha->addr,
-                                            addr_len, ha->type);
+                if (!ha->sync_cnt) {
+                        err = __hw_addr_sync_one(to_list, ha, addr_len);
                         if (err)
                                 break;
-                        ha->synced++;
-                        ha->refcount++;
-                } else if (ha->refcount == 1) {
-                        __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
-                        __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
-                }
+                } else if (ha->refcount == 1)
+                        __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
         }
         return err;
 }
@@ -183,13 +253,8 @@ void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
         struct netdev_hw_addr *ha, *tmp;
 
         list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
-                if (ha->synced) {
-                        __hw_addr_del(to_list, ha->addr,
-                                      addr_len, ha->type);
-                        ha->synced--;
-                        __hw_addr_del(from_list, ha->addr,
-                                      addr_len, ha->type);
-                }
+                if (ha->sync_cnt)
+                        __hw_addr_unsync_one(to_list, from_list, ha, addr_len);
         }
 }
 EXPORT_SYMBOL(__hw_addr_unsync);
@@ -406,7 +471,7 @@ int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
                 }
         }
         err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
-                                  NETDEV_HW_ADDR_T_UNICAST, true);
+                                  NETDEV_HW_ADDR_T_UNICAST, true, false);
         if (!err)
                 __dev_set_rx_mode(dev);
 out:
@@ -469,7 +534,8 @@ EXPORT_SYMBOL(dev_uc_del);
  *      locked by netif_addr_lock_bh.
  *
  *      This function is intended to be called from the dev->set_rx_mode
- *      function of layered software devices.
+ *      function of layered software devices.  This function assumes that
+ *      addresses will only ever be synced to the @to devices and no other.
  */
 int dev_uc_sync(struct net_device *to, struct net_device *from)
 {
@@ -488,6 +554,36 @@ int dev_uc_sync(struct net_device *to, struct net_device *from)
 EXPORT_SYMBOL(dev_uc_sync);
 
 /**
+ *      dev_uc_sync_multiple - Synchronize device's unicast list to another
+ *      device, but allow for multiple calls to sync to multiple devices.
+ *      @to: destination device
+ *      @from: source device
+ *
+ *      Add newly added addresses to the destination device and release
+ *      addresses that have been deleted from the source. The source device
+ *      must be locked by netif_addr_lock_bh.
+ *
+ *      This function is intended to be called from the dev->set_rx_mode
+ *      function of layered software devices.  It allows for a single source
+ *      device to be synced to multiple destination devices.
+ */
+int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
+{
+        int err = 0;
+
+        if (to->addr_len != from->addr_len)
+                return -EINVAL;
+
+        netif_addr_lock_nested(to);
+        err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
+        if (!err)
+                __dev_set_rx_mode(to);
+        netif_addr_unlock(to);
+        return err;
+}
+EXPORT_SYMBOL(dev_uc_sync_multiple);
+
+/**
  *      dev_uc_unsync - Remove synchronized addresses from the destination device
  *      @to: destination device
  *      @from: source device
@@ -559,7 +655,7 @@ int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
                 }
         }
         err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
-                                  NETDEV_HW_ADDR_T_MULTICAST, true);
+                                  NETDEV_HW_ADDR_T_MULTICAST, true, false);
         if (!err)
                 __dev_set_rx_mode(dev);
 out:
@@ -575,7 +671,7 @@ static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
 
         netif_addr_lock_bh(dev);
         err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
-                               NETDEV_HW_ADDR_T_MULTICAST, global);
+                               NETDEV_HW_ADDR_T_MULTICAST, global, false);
         if (!err)
                 __dev_set_rx_mode(dev);
         netif_addr_unlock_bh(dev);
@@ -615,7 +711,7 @@ static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
 
         netif_addr_lock_bh(dev);
         err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
-                               NETDEV_HW_ADDR_T_MULTICAST, global);
+                               NETDEV_HW_ADDR_T_MULTICAST, global, false);
         if (!err)
                 __dev_set_rx_mode(dev);
         netif_addr_unlock_bh(dev);
@@ -679,6 +775,36 @@ int dev_mc_sync(struct net_device *to, struct net_device *from)
 EXPORT_SYMBOL(dev_mc_sync);
 
 /**
+ *      dev_mc_sync_multiple - Synchronize device's unicast list to another
+ *      device, but allow for multiple calls to sync to multiple devices.
+ *      @to: destination device
+ *      @from: source device
+ *
+ *      Add newly added addresses to the destination device and release
+ *      addresses that have no users left. The source device must be
+ *      locked by netif_addr_lock_bh.
+ *
+ *      This function is intended to be called from the ndo_set_rx_mode
+ *      function of layered software devices.  It allows for a single
+ *      source device to be synced to multiple destination devices.
+ */
+int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
+{
+        int err = 0;
+
+        if (to->addr_len != from->addr_len)
+                return -EINVAL;
+
+        netif_addr_lock_nested(to);
+        err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
+        if (!err)
+                __dev_set_rx_mode(to);
+        netif_addr_unlock(to);
+        return err;
+}
+EXPORT_SYMBOL(dev_mc_sync_multiple);
+
+/**
  *      dev_mc_unsync - Remove synchronized addresses from the destination device
  *      @to: destination device
  *      @from: source device