vlan: introduce vid list with reference counting

This allows to keep track of vids needed to be in rx vlan filters of
devices even if they are used in bond/team etc.

vlan_info as well as vlan_group previously was, is allocated when first
vid is added and dealocated whan last vid is deleted.

vlan_group definition is moved to private header.

Signed-off-by: Jiri Pirko <jpirko@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

3 files changed, 217 insertions, 71 deletions

diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c
index dd9aa400888b..efea35b02e7f 100644
--- a/net/8021q/vlan.c
+++ b/net/8021q/vlan.c
@@ -51,27 +51,6 @@ const char vlan_version[] = DRV_VERSION;
 
 /* End of global variables definitions. */
 
-static void vlan_group_free(struct vlan_group *grp)
-{
-        int i;
-
-        for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
-                kfree(grp->vlan_devices_arrays[i]);
-        kfree(grp);
-}
-
-static struct vlan_group *vlan_group_alloc(struct net_device *real_dev)
-{
-        struct vlan_group *grp;
-
-        grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
-        if (!grp)
-                return NULL;
-
-        grp->real_dev = real_dev;
-        return grp;
-}
-
 static int vlan_group_prealloc_vid(struct vlan_group *vg, u16 vlan_id)
 {
         struct net_device **array;
@@ -92,22 +71,20 @@ static int vlan_group_prealloc_vid(struct vlan_group *vg, u16 vlan_id)
         return 0;
 }
 
-static void vlan_rcu_free(struct rcu_head *rcu)
-{
-        vlan_group_free(container_of(rcu, struct vlan_group, rcu));
-}
-
 void unregister_vlan_dev(struct net_device *dev, struct list_head *head)
 {
         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
         struct net_device *real_dev = vlan->real_dev;
+        struct vlan_info *vlan_info;
         struct vlan_group *grp;
         u16 vlan_id = vlan->vlan_id;
 
         ASSERT_RTNL();
 
-        grp = rtnl_dereference(real_dev->vlgrp);
-        BUG_ON(!grp);
+        vlan_info = rtnl_dereference(real_dev->vlan_info);
+        BUG_ON(!vlan_info);
+
+        grp = &vlan_info->grp;
 
         /* Take it out of our own structures, but be sure to interlock with
          * HW accelerating devices or SW vlan input packet processing if
@@ -116,7 +93,7 @@ void unregister_vlan_dev(struct net_device *dev, struct list_head *head)
         if (vlan_id)
                 vlan_vid_del(real_dev, vlan_id);
 
-        grp->nr_vlans--;
+        grp->nr_vlan_devs--;
 
         if (vlan->flags & VLAN_FLAG_GVRP)
                 vlan_gvrp_request_leave(dev);
@@ -128,16 +105,9 @@ void unregister_vlan_dev(struct net_device *dev, struct list_head *head)
          */
         unregister_netdevice_queue(dev, head);
 
-        /* If the group is now empty, kill off the group. */
-        if (grp->nr_vlans == 0) {
+        if (grp->nr_vlan_devs == 0)
                 vlan_gvrp_uninit_applicant(real_dev);
 
-                RCU_INIT_POINTER(real_dev->vlgrp, NULL);
-
-                /* Free the group, after all cpu's are done. */
-                call_rcu(&grp->rcu, vlan_rcu_free);
-        }
-
         /* Get rid of the vlan's reference to real_dev */
         dev_put(real_dev);
 }
@@ -169,17 +139,23 @@ int register_vlan_dev(struct net_device *dev)
         struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
         struct net_device *real_dev = vlan->real_dev;
         u16 vlan_id = vlan->vlan_id;
-        struct vlan_group *grp, *ngrp = NULL;
+        struct vlan_info *vlan_info;
+        struct vlan_group *grp;
         int err;
 
-        grp = rtnl_dereference(real_dev->vlgrp);
-        if (!grp) {
-                ngrp = grp = vlan_group_alloc(real_dev);
-                if (!grp)
-                        return -ENOBUFS;
+        err = vlan_vid_add(real_dev, vlan_id);
+        if (err)
+                return err;
+
+        vlan_info = rtnl_dereference(real_dev->vlan_info);
+        /* vlan_info should be there now. vlan_vid_add took care of it */
+        BUG_ON(!vlan_info);
+
+        grp = &vlan_info->grp;
+        if (grp->nr_vlan_devs == 0) {
                 err = vlan_gvrp_init_applicant(real_dev);
                 if (err < 0)
-                        goto out_free_group;
+                        goto out_vid_del;
         }
 
         err = vlan_group_prealloc_vid(grp, vlan_id);
@@ -200,23 +176,15 @@ int register_vlan_dev(struct net_device *dev)
          * it into our local structure.
          */
         vlan_group_set_device(grp, vlan_id, dev);
-        grp->nr_vlans++;
-
-        if (ngrp) {
-                rcu_assign_pointer(real_dev->vlgrp, ngrp);
-        }
-        vlan_vid_add(real_dev, vlan_id);
+        grp->nr_vlan_devs++;
 
         return 0;
 
 out_uninit_applicant:
-        if (ngrp)
+        if (grp->nr_vlan_devs == 0)
                 vlan_gvrp_uninit_applicant(real_dev);
-out_free_group:
-        if (ngrp) {
-                /* Free the group, after all cpu's are done. */
-                call_rcu(&ngrp->rcu, vlan_rcu_free);
-        }
+out_vid_del:
+        vlan_vid_del(real_dev, vlan_id);
         return err;
 }
 
@@ -357,6 +325,7 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event,
 {
         struct net_device *dev = ptr;
         struct vlan_group *grp;
+        struct vlan_info *vlan_info;
         int i, flgs;
         struct net_device *vlandev;
         struct vlan_dev_priv *vlan;
@@ -372,9 +341,10 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event,
                 vlan_vid_add(dev, 0);
         }
 
-        grp = rtnl_dereference(dev->vlgrp);
-        if (!grp)
+        vlan_info = rtnl_dereference(dev->vlan_info);
+        if (!vlan_info)
                 goto out;
+        grp = &vlan_info->grp;
 
         /* It is OK that we do not hold the group lock right now,
          * as we run under the RTNL lock.
@@ -478,9 +448,9 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event,
                         if (!vlandev)
                                 continue;
 
-                        /* unregistration of last vlan destroys group, abort
+                        /* removal of last vid destroys vlan_info, abort
                          * afterwards */
-                        if (grp->nr_vlans == 1)
+                        if (vlan_info->nr_vids == 1)
                                 i = VLAN_N_VID;
 
                         unregister_vlan_dev(vlandev, &list);
diff --git a/net/8021q/vlan.h b/net/8021q/vlan.h
index d3c4ea4a3836..28d8dc20cb6d 100644
--- a/net/8021q/vlan.h
+++ b/net/8021q/vlan.h
@@ -3,6 +3,7 @@
 
 #include <linux/if_vlan.h>
 #include <linux/u64_stats_sync.h>
+#include <linux/list.h>
 
 
 /**
@@ -74,6 +75,29 @@ static inline struct vlan_dev_priv *vlan_dev_priv(const struct net_device *dev)
         return netdev_priv(dev);
 }
 
+/* if this changes, algorithm will have to be reworked because this
+ * depends on completely exhausting the VLAN identifier space.  Thus
+ * it gives constant time look-up, but in many cases it wastes memory.
+ */
+#define VLAN_GROUP_ARRAY_SPLIT_PARTS  8
+#define VLAN_GROUP_ARRAY_PART_LEN     (VLAN_N_VID/VLAN_GROUP_ARRAY_SPLIT_PARTS)
+
+struct vlan_group {
+        unsigned int            nr_vlan_devs;
+        struct hlist_node       hlist;  /* linked list */
+        struct net_device **vlan_devices_arrays[VLAN_GROUP_ARRAY_SPLIT_PARTS];
+};
+
+struct vlan_info {
+        struct net_device       *real_dev; /* The ethernet(like) device
+                                            * the vlan is attached to.
+                                            */
+        struct vlan_group       grp;
+        struct list_head        vid_list;
+        unsigned int            nr_vids;
+        struct rcu_head         rcu;
+};
+
 static inline struct net_device *vlan_group_get_device(struct vlan_group *vg,
                                                        u16 vlan_id)
 {
@@ -97,10 +121,10 @@ static inline void vlan_group_set_device(struct vlan_group *vg,
 static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
                                                u16 vlan_id)
 {
-        struct vlan_group *grp = rcu_dereference_rtnl(real_dev->vlgrp);
+        struct vlan_info *vlan_info = rcu_dereference_rtnl(real_dev->vlan_info);
 
-        if (grp)
-                return vlan_group_get_device(grp, vlan_id);
+        if (vlan_info)
+                return vlan_group_get_device(&vlan_info->grp, vlan_id);
 
         return NULL;
 }
diff --git a/net/8021q/vlan_core.c b/net/8021q/vlan_core.c
index 544f9cb9678c..329e0313e01f 100644
--- a/net/8021q/vlan_core.c
+++ b/net/8021q/vlan_core.c
@@ -71,10 +71,10 @@ bool vlan_do_receive(struct sk_buff **skbp, bool last_handler)
 struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
                                         u16 vlan_id)
 {
-        struct vlan_group *grp = rcu_dereference_rtnl(real_dev->vlgrp);
+        struct vlan_info *vlan_info = rcu_dereference_rtnl(real_dev->vlan_info);
 
-        if (grp) {
-                return vlan_group_get_device(grp, vlan_id);
+        if (vlan_info) {
+                return vlan_group_get_device(&vlan_info->grp, vlan_id);
         } else {
                 /*
                  * Bonding slaves do not have grp assigned to themselves.
@@ -147,25 +147,177 @@ err_free:
         return NULL;
 }
 
-int vlan_vid_add(struct net_device *dev, unsigned short vid)
+
+/*
+ * vlan info and vid list
+ */
+
+static void vlan_group_free(struct vlan_group *grp)
+{
+        int i;
+
+        for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
+                kfree(grp->vlan_devices_arrays[i]);
+}
+
+static void vlan_info_free(struct vlan_info *vlan_info)
+{
+        vlan_group_free(&vlan_info->grp);
+        kfree(vlan_info);
+}
+
+static void vlan_info_rcu_free(struct rcu_head *rcu)
+{
+        vlan_info_free(container_of(rcu, struct vlan_info, rcu));
+}
+
+static struct vlan_info *vlan_info_alloc(struct net_device *dev)
+{
+        struct vlan_info *vlan_info;
+
+        vlan_info = kzalloc(sizeof(struct vlan_info), GFP_KERNEL);
+        if (!vlan_info)
+                return NULL;
+
+        vlan_info->real_dev = dev;
+        INIT_LIST_HEAD(&vlan_info->vid_list);
+        return vlan_info;
+}
+
+struct vlan_vid_info {
+        struct list_head list;
+        unsigned short vid;
+        int refcount;
+};
+
+static struct vlan_vid_info *vlan_vid_info_get(struct vlan_info *vlan_info,
+                                               unsigned short vid)
+{
+        struct vlan_vid_info *vid_info;
+
+        list_for_each_entry(vid_info, &vlan_info->vid_list, list) {
+                if (vid_info->vid == vid)
+                        return vid_info;
+        }
+        return NULL;
+}
+
+static struct vlan_vid_info *vlan_vid_info_alloc(unsigned short vid)
+{
+        struct vlan_vid_info *vid_info;
+
+        vid_info = kzalloc(sizeof(struct vlan_vid_info), GFP_KERNEL);
+        if (!vid_info)
+                return NULL;
+        vid_info->vid = vid;
+
+        return vid_info;
+}
+
+static int __vlan_vid_add(struct vlan_info *vlan_info, unsigned short vid,
+                          struct vlan_vid_info **pvid_info)
 {
+        struct net_device *dev = vlan_info->real_dev;
         const struct net_device_ops *ops = dev->netdev_ops;
+        struct vlan_vid_info *vid_info;
+        int err;
+
+        vid_info = vlan_vid_info_alloc(vid);
+        if (!vid_info)
+                return -ENOMEM;
 
         if ((dev->features & NETIF_F_HW_VLAN_FILTER) &&
-             ops->ndo_vlan_rx_add_vid) {
-                return ops->ndo_vlan_rx_add_vid(dev, vid);
+            ops->ndo_vlan_rx_add_vid) {
+                err =  ops->ndo_vlan_rx_add_vid(dev, vid);
+                if (err) {
+                        kfree(vid_info);
+                        return err;
+                }
         }
+        list_add(&vid_info->list, &vlan_info->vid_list);
+        vlan_info->nr_vids++;
+        *pvid_info = vid_info;
         return 0;
 }
+
+int vlan_vid_add(struct net_device *dev, unsigned short vid)
+{
+        struct vlan_info *vlan_info;
+        struct vlan_vid_info *vid_info;
+        bool vlan_info_created = false;
+        int err;
+
+        ASSERT_RTNL();
+
+        vlan_info = rtnl_dereference(dev->vlan_info);
+        if (!vlan_info) {
+                vlan_info = vlan_info_alloc(dev);
+                if (!vlan_info)
+                        return -ENOMEM;
+                vlan_info_created = true;
+        }
+        vid_info = vlan_vid_info_get(vlan_info, vid);
+        if (!vid_info) {
+                err = __vlan_vid_add(vlan_info, vid, &vid_info);
+                if (err)
+                        goto out_free_vlan_info;
+        }
+        vid_info->refcount++;
+
+        if (vlan_info_created)
+                rcu_assign_pointer(dev->vlan_info, vlan_info);
+
+        return 0;
+
+out_free_vlan_info:
+        if (vlan_info_created)
+                kfree(vlan_info);
+        return err;
+}
 EXPORT_SYMBOL(vlan_vid_add);
 
-void vlan_vid_del(struct net_device *dev, unsigned short vid)
+static void __vlan_vid_del(struct vlan_info *vlan_info,
+                           struct vlan_vid_info *vid_info)
 {
+        struct net_device *dev = vlan_info->real_dev;
         const struct net_device_ops *ops = dev->netdev_ops;
+        unsigned short vid = vid_info->vid;
+        int err;
 
         if ((dev->features & NETIF_F_HW_VLAN_FILTER) &&
              ops->ndo_vlan_rx_kill_vid) {
-                ops->ndo_vlan_rx_kill_vid(dev, vid);
+                err = ops->ndo_vlan_rx_kill_vid(dev, vid);
+                if (err) {
+                        pr_warn("failed to kill vid %d for device %s\n",
+                                vid, dev->name);
+                }
+        }
+        list_del(&vid_info->list);
+        kfree(vid_info);
+        vlan_info->nr_vids--;
+}
+
+void vlan_vid_del(struct net_device *dev, unsigned short vid)
+{
+        struct vlan_info *vlan_info;
+        struct vlan_vid_info *vid_info;
+
+        ASSERT_RTNL();
+
+        vlan_info = rtnl_dereference(dev->vlan_info);
+        if (!vlan_info)
+                return;
+
+        vid_info = vlan_vid_info_get(vlan_info, vid);
+        if (!vid_info)
+                return;
+        vid_info->refcount--;
+        if (vid_info->refcount == 0) {
+                __vlan_vid_del(vlan_info, vid_info);
+                if (vlan_info->nr_vids == 0) {
+                        RCU_INIT_POINTER(dev->vlan_info, NULL);
+                        call_rcu(&vlan_info->rcu, vlan_info_rcu_free);
+                }
         }
 }
 EXPORT_SYMBOL(vlan_vid_del);