net: dsa: introduce locking for the address lists on CPU and DSA ports

Now that the rtnl_mutex is going away for dsa_port_{host_,}fdb_{add,del},
no one is serializing access to the address lists that DSA keeps for the
purpose of reference counting on shared ports (CPU and cascade ports).

It can happen for one dsa_switch_do_fdb_del to do list_del on a dp->fdbs
element while another dsa_switch_do_fdb_{add,del} is traversing dp->fdbs.
We need to avoid that.

Currently dp->mdbs is not at risk, because dsa_switch_do_mdb_{add,del}
still runs under the rtnl_mutex. But it would be nice if it would not
depend on that being the case. So let's introduce a mutex per port (the
address lists are per port too) and share it between dp->mdbs and
dp->fdbs.

The place where we put the locking is interesting. It could be tempting
to put a DSA-level lock which still serializes calls to
.port_fdb_{add,del}, but it would still not avoid concurrency with other
driver code paths that are currently under rtnl_mutex (.port_fdb_dump,
.port_fast_age). So it would add a very false sense of security (and
adding a global switch-wide lock in DSA to resynchronize with the
rtnl_lock is also counterproductive and hard).

So the locking is intentionally done only where the dp->fdbs and dp->mdbs
lists are traversed. That means, from a driver perspective, that
.port_fdb_add will be called with the dp->addr_lists_lock mutex held on
the CPU port, but not held on user ports. This is done so that driver
writers are not encouraged to rely on any guarantee offered by
dp->addr_lists_lock.

Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/dsa.h b/include/net/dsa.h
index 1cd9c2461f0d9ee3c487bcc429908ac124fffd15..badd214f74700b58c44b09c1b329e855990c1737 100644 (file)
--- a/include/net/dsa.h
+++ b/include/net/dsa.h
@@ -287,6 +287,7 @@ struct dsa_port {
        /* List of MAC addresses that must be forwarded on this port.
         * These are only valid on CPU ports and DSA links.
         */
+       struct mutex            addr_lists_lock;
        struct list_head        fdbs;
        struct list_head        mdbs;
 

diff --git a/net/dsa/dsa2.c b/net/dsa/dsa2.c
index f5270114dcb8c36db002ed9becc2b7aefc73d8e8..826957b6442b06d1f026c58569ad3d859eeb7949 100644 (file)
--- a/net/dsa/dsa2.c
+++ b/net/dsa/dsa2.c
@@ -433,6 +433,7 @@ static int dsa_port_setup(struct dsa_port *dp)
        if (dp->setup)
                return 0;
 
+       mutex_init(&dp->addr_lists_lock);
        INIT_LIST_HEAD(&dp->fdbs);
        INIT_LIST_HEAD(&dp->mdbs);
 

diff --git a/net/dsa/switch.c b/net/dsa/switch.c
index 2b1b21bde830064f8a1825ff6b7c996a5219c276..6871e5f9b597a7afbda136f3c15f9e7811c633ae 100644 (file)
--- a/net/dsa/switch.c
+++ b/net/dsa/switch.c
@@ -215,26 +215,30 @@ static int dsa_port_do_mdb_add(struct dsa_port *dp,
        struct dsa_switch *ds = dp->ds;
        struct dsa_mac_addr *a;
        int port = dp->index;
-       int err;
+       int err = 0;
 
        /* No need to bother with refcounting for user ports */
        if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
                return ds->ops->port_mdb_add(ds, port, mdb);
 
+       mutex_lock(&dp->addr_lists_lock);
+
        a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid);
        if (a) {
                refcount_inc(&a->refcount);
-               return 0;
+               goto out;
        }
 
        a = kzalloc(sizeof(*a), GFP_KERNEL);
-       if (!a)
-               return -ENOMEM;
+       if (!a) {
+               err = -ENOMEM;
+               goto out;
+       }
 
        err = ds->ops->port_mdb_add(ds, port, mdb);
        if (err) {
                kfree(a);
-               return err;
+               goto out;
        }
 
        ether_addr_copy(a->addr, mdb->addr);
@@ -242,7 +246,10 @@ static int dsa_port_do_mdb_add(struct dsa_port *dp,
        refcount_set(&a->refcount, 1);
        list_add_tail(&a->list, &dp->mdbs);
 
-       return 0;
+out:
+       mutex_unlock(&dp->addr_lists_lock);
+
+       return err;
 }
 
 static int dsa_port_do_mdb_del(struct dsa_port *dp,
@@ -251,29 +258,36 @@ static int dsa_port_do_mdb_del(struct dsa_port *dp,
        struct dsa_switch *ds = dp->ds;
        struct dsa_mac_addr *a;
        int port = dp->index;
-       int err;
+       int err = 0;
 
        /* No need to bother with refcounting for user ports */
        if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
                return ds->ops->port_mdb_del(ds, port, mdb);
 
+       mutex_lock(&dp->addr_lists_lock);
+
        a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid);
-       if (!a)
-               return -ENOENT;
+       if (!a) {
+               err = -ENOENT;
+               goto out;
+       }
 
        if (!refcount_dec_and_test(&a->refcount))
-               return 0;
+               goto out;
 
        err = ds->ops->port_mdb_del(ds, port, mdb);
        if (err) {
                refcount_inc(&a->refcount);
-               return err;
+               goto out;
        }
 
        list_del(&a->list);
        kfree(a);
 
-       return 0;
+out:
+       mutex_unlock(&dp->addr_lists_lock);
+
+       return err;
 }
 
 static int dsa_port_do_fdb_add(struct dsa_port *dp, const unsigned char *addr,
@@ -282,26 +296,30 @@ static int dsa_port_do_fdb_add(struct dsa_port *dp, const unsigned char *addr,
        struct dsa_switch *ds = dp->ds;
        struct dsa_mac_addr *a;
        int port = dp->index;
-       int err;
+       int err = 0;
 
        /* No need to bother with refcounting for user ports */
        if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
                return ds->ops->port_fdb_add(ds, port, addr, vid);
 
+       mutex_lock(&dp->addr_lists_lock);
+
        a = dsa_mac_addr_find(&dp->fdbs, addr, vid);
        if (a) {
                refcount_inc(&a->refcount);
-               return 0;
+               goto out;
        }
 
        a = kzalloc(sizeof(*a), GFP_KERNEL);
-       if (!a)
-               return -ENOMEM;
+       if (!a) {
+               err = -ENOMEM;
+               goto out;
+       }
 
        err = ds->ops->port_fdb_add(ds, port, addr, vid);
        if (err) {
                kfree(a);
-               return err;
+               goto out;
        }
 
        ether_addr_copy(a->addr, addr);
@@ -309,7 +327,10 @@ static int dsa_port_do_fdb_add(struct dsa_port *dp, const unsigned char *addr,
        refcount_set(&a->refcount, 1);
        list_add_tail(&a->list, &dp->fdbs);
 
-       return 0;
+out:
+       mutex_unlock(&dp->addr_lists_lock);
+
+       return err;
 }
 
 static int dsa_port_do_fdb_del(struct dsa_port *dp, const unsigned char *addr,
@@ -318,29 +339,36 @@ static int dsa_port_do_fdb_del(struct dsa_port *dp, const unsigned char *addr,
        struct dsa_switch *ds = dp->ds;
        struct dsa_mac_addr *a;
        int port = dp->index;
-       int err;
+       int err = 0;
 
        /* No need to bother with refcounting for user ports */
        if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
                return ds->ops->port_fdb_del(ds, port, addr, vid);
 
+       mutex_lock(&dp->addr_lists_lock);
+
        a = dsa_mac_addr_find(&dp->fdbs, addr, vid);
-       if (!a)
-               return -ENOENT;
+       if (!a) {
+               err = -ENOENT;
+               goto out;
+       }
 
        if (!refcount_dec_and_test(&a->refcount))
-               return 0;
+               goto out;
 
        err = ds->ops->port_fdb_del(ds, port, addr, vid);
        if (err) {
                refcount_inc(&a->refcount);
-               return err;
+               goto out;
        }
 
        list_del(&a->list);
        kfree(a);
 
-       return 0;
+out:
+       mutex_unlock(&dp->addr_lists_lock);
+
+       return err;
 }
 
 static int dsa_switch_host_fdb_add(struct dsa_switch *ds,