Patched in Tegra support.

1 files changed, 108 insertions, 168 deletions

diff --git a/net/bridge/br_netlink.c b/net/bridge/br_netlink.c
index 5dc66abcc9e..e5f9ece3c9a 100644
--- a/net/bridge/br_netlink.c
+++ b/net/bridge/br_netlink.c
@@ -18,46 +18,17 @@
 #include <net/sock.h>
 
 #include "br_private.h"
-#include "br_private_stp.h"
-
-static inline size_t br_port_info_size(void)
-{
-        return nla_total_size(1)        /* IFLA_BRPORT_STATE  */
-                + nla_total_size(2)     /* IFLA_BRPORT_PRIORITY */
-                + nla_total_size(4)     /* IFLA_BRPORT_COST */
-                + nla_total_size(1)     /* IFLA_BRPORT_MODE */
-                + nla_total_size(1)     /* IFLA_BRPORT_GUARD */
-                + nla_total_size(1)     /* IFLA_BRPORT_PROTECT */
-                + 0;
-}
 
 static inline size_t br_nlmsg_size(void)
 {
         return NLMSG_ALIGN(sizeof(struct ifinfomsg))
-                + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
-                + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
-                + nla_total_size(4) /* IFLA_MASTER */
-                + nla_total_size(4) /* IFLA_MTU */
-                + nla_total_size(4) /* IFLA_LINK */
-                + nla_total_size(1) /* IFLA_OPERSTATE */
-                + nla_total_size(br_port_info_size()); /* IFLA_PROTINFO */
-}
-
-static int br_port_fill_attrs(struct sk_buff *skb,
-                              const struct net_bridge_port *p)
-{
-        u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
-
-        if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
-            nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
-            nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
-            nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
-            nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
-            nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
-            nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)))
-                return -EMSGSIZE;
-
-        return 0;
+               + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
+               + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
+               + nla_total_size(4) /* IFLA_MASTER */
+               + nla_total_size(4) /* IFLA_MTU */
+               + nla_total_size(4) /* IFLA_LINK */
+               + nla_total_size(1) /* IFLA_OPERSTATE */
+               + nla_total_size(1); /* IFLA_PROTINFO */
 }
 
 /*
@@ -88,24 +59,19 @@ static int br_fill_ifinfo(struct sk_buff *skb, const struct net_bridge_port *por
         hdr->ifi_flags = dev_get_flags(dev);
         hdr->ifi_change = 0;
 
-        if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
-            nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
-            nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
-            nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
-            (dev->addr_len &&
-             nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
-            (dev->ifindex != dev->iflink &&
-             nla_put_u32(skb, IFLA_LINK, dev->iflink)))
-                goto nla_put_failure;
-
-        if (event == RTM_NEWLINK) {
-                struct nlattr *nest
-                        = nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
-
-                if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
-                        goto nla_put_failure;
-                nla_nest_end(skb, nest);
-        }
+        NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
+        NLA_PUT_U32(skb, IFLA_MASTER, br->dev->ifindex);
+        NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);
+        NLA_PUT_U8(skb, IFLA_OPERSTATE, operstate);
+
+        if (dev->addr_len)
+                NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
+
+        if (dev->ifindex != dev->iflink)
+                NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);
+
+        if (event == RTM_NEWLINK)
+                NLA_PUT_U8(skb, IFLA_PROTINFO, port->state);
 
         return nlmsg_end(skb, nlh);
 
@@ -124,7 +90,7 @@ void br_ifinfo_notify(int event, struct net_bridge_port *port)
         int err = -ENOBUFS;
 
         br_debug(port->br, "port %u(%s) event %d\n",
-                 (unsigned int)port->port_no, port->dev->name, event);
+                 (unsigned)port->port_no, port->dev->name, event);
 
         skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC);
         if (skb == NULL)
@@ -147,134 +113,84 @@ errout:
 /*
  * Dump information about all ports, in response to GETLINK
  */
-int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
-               struct net_device *dev)
-{
-        int err = 0;
-        struct net_bridge_port *port = br_port_get_rcu(dev);
-
-        /* not a bridge port */
-        if (!port)
-                goto out;
-
-        err = br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, NLM_F_MULTI);
-out:
-        return err;
-}
-
-static const struct nla_policy ifla_brport_policy[IFLA_BRPORT_MAX + 1] = {
-        [IFLA_BRPORT_STATE]     = { .type = NLA_U8 },
-        [IFLA_BRPORT_COST]      = { .type = NLA_U32 },
-        [IFLA_BRPORT_PRIORITY]  = { .type = NLA_U16 },
-        [IFLA_BRPORT_MODE]      = { .type = NLA_U8 },
-        [IFLA_BRPORT_GUARD]     = { .type = NLA_U8 },
-        [IFLA_BRPORT_PROTECT]   = { .type = NLA_U8 },
-};
-
-/* Change the state of the port and notify spanning tree */
-static int br_set_port_state(struct net_bridge_port *p, u8 state)
-{
-        if (state > BR_STATE_BLOCKING)
-                return -EINVAL;
-
-        /* if kernel STP is running, don't allow changes */
-        if (p->br->stp_enabled == BR_KERNEL_STP)
-                return -EBUSY;
-
-        if (!netif_running(p->dev) ||
-            (!netif_carrier_ok(p->dev) && state != BR_STATE_DISABLED))
-                return -ENETDOWN;
-
-        p->state = state;
-        br_log_state(p);
-        br_port_state_selection(p->br);
-        return 0;
-}
-
-/* Set/clear or port flags based on attribute */
-static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
-                           int attrtype, unsigned long mask)
+static int br_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
 {
-        if (tb[attrtype]) {
-                u8 flag = nla_get_u8(tb[attrtype]);
-                if (flag)
-                        p->flags |= mask;
-                else
-                        p->flags &= ~mask;
+        struct net *net = sock_net(skb->sk);
+        struct net_device *dev;
+        int idx;
+
+        idx = 0;
+        rcu_read_lock();
+        for_each_netdev_rcu(net, dev) {
+                struct net_bridge_port *port = br_port_get_rcu(dev);
+
+                /* not a bridge port */
+                if (!port || idx < cb->args[0])
+                        goto skip;
+
+                if (br_fill_ifinfo(skb, port,
+                                   NETLINK_CB(cb->skb).pid,
+                                   cb->nlh->nlmsg_seq, RTM_NEWLINK,
+                                   NLM_F_MULTI) < 0)
+                        break;
+skip:
+                ++idx;
         }
-}
+        rcu_read_unlock();
+        cb->args[0] = idx;
 
-/* Process bridge protocol info on port */
-static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
-{
-        int err;
-
-        br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
-        br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
-        br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
-
-        if (tb[IFLA_BRPORT_COST]) {
-                err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
-                if (err)
-                        return err;
-        }
-
-        if (tb[IFLA_BRPORT_PRIORITY]) {
-                err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
-                if (err)
-                        return err;
-        }
-
-        if (tb[IFLA_BRPORT_STATE]) {
-                err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
-                if (err)
-                        return err;
-        }
-        return 0;
+        return skb->len;
 }
 
-/* Change state and parameters on port. */
-int br_setlink(struct net_device *dev, struct nlmsghdr *nlh)
+/*
+ * Change state of port (ie from forwarding to blocking etc)
+ * Used by spanning tree in user space.
+ */
+static int br_rtm_setlink(struct sk_buff *skb,  struct nlmsghdr *nlh, void *arg)
 {
+        struct net *net = sock_net(skb->sk);
         struct ifinfomsg *ifm;
         struct nlattr *protinfo;
+        struct net_device *dev;
         struct net_bridge_port *p;
-        struct nlattr *tb[IFLA_BRPORT_MAX + 1];
-        int err;
+        u8 new_state;
+
+        if (nlmsg_len(nlh) < sizeof(*ifm))
+                return -EINVAL;
 
         ifm = nlmsg_data(nlh);
+        if (ifm->ifi_family != AF_BRIDGE)
+                return -EPFNOSUPPORT;
 
         protinfo = nlmsg_find_attr(nlh, sizeof(*ifm), IFLA_PROTINFO);
-        if (!protinfo)
-                return 0;
+        if (!protinfo || nla_len(protinfo) < sizeof(u8))
+                return -EINVAL;
+
+        new_state = nla_get_u8(protinfo);
+        if (new_state > BR_STATE_BLOCKING)
+                return -EINVAL;
+
+        dev = __dev_get_by_index(net, ifm->ifi_index);
+        if (!dev)
+                return -ENODEV;
 
         p = br_port_get_rtnl(dev);
         if (!p)
                 return -EINVAL;
 
-        if (protinfo->nla_type & NLA_F_NESTED) {
-                err = nla_parse_nested(tb, IFLA_BRPORT_MAX,
-                                       protinfo, ifla_brport_policy);
-                if (err)
-                        return err;
-
-                spin_lock_bh(&p->br->lock);
-                err = br_setport(p, tb);
-                spin_unlock_bh(&p->br->lock);
-        } else {
-                /* Binary compatability with old RSTP */
-                if (nla_len(protinfo) < sizeof(u8))
-                        return -EINVAL;
+        /* if kernel STP is running, don't allow changes */
+        if (p->br->stp_enabled == BR_KERNEL_STP)
+                return -EBUSY;
 
-                spin_lock_bh(&p->br->lock);
-                err = br_set_port_state(p, nla_get_u8(protinfo));
-                spin_unlock_bh(&p->br->lock);
-        }
+        if (!netif_running(dev) ||
+            (!netif_carrier_ok(dev) && new_state != BR_STATE_DISABLED))
+                return -ENETDOWN;
 
-        if (err == 0)
-                br_ifinfo_notify(RTM_NEWLINK, p);
+        p->state = new_state;
+        br_log_state(p);
+        br_ifinfo_notify(RTM_NEWLINK, p);
 
-        return err;
+        return 0;
 }
 
 static int br_validate(struct nlattr *tb[], struct nlattr *data[])
@@ -289,7 +205,7 @@ static int br_validate(struct nlattr *tb[], struct nlattr *data[])
         return 0;
 }
 
-struct rtnl_link_ops br_link_ops __read_mostly = {
+static struct rtnl_link_ops br_link_ops __read_mostly = {
         .kind           = "bridge",
         .priv_size      = sizeof(struct net_bridge),
         .setup          = br_dev_setup,
@@ -301,19 +217,43 @@ int __init br_netlink_init(void)
 {
         int err;
 
-        br_mdb_init();
         err = rtnl_link_register(&br_link_ops);
+        if (err < 0)
+                goto err1;
+
+        err = __rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL,
+                              br_dump_ifinfo, NULL);
+        if (err)
+                goto err2;
+        err = __rtnl_register(PF_BRIDGE, RTM_SETLINK,
+                              br_rtm_setlink, NULL, NULL);
+        if (err)
+                goto err3;
+        err = __rtnl_register(PF_BRIDGE, RTM_NEWNEIGH,
+                              br_fdb_add, NULL, NULL);
         if (err)
-                goto out;
+                goto err3;
+        err = __rtnl_register(PF_BRIDGE, RTM_DELNEIGH,
+                              br_fdb_delete, NULL, NULL);
+        if (err)
+                goto err3;
+        err = __rtnl_register(PF_BRIDGE, RTM_GETNEIGH,
+                              NULL, br_fdb_dump, NULL);
+        if (err)
+                goto err3;
 
         return 0;
-out:
-        br_mdb_uninit();
+
+err3:
+        rtnl_unregister_all(PF_BRIDGE);
+err2:
+        rtnl_link_unregister(&br_link_ops);
+err1:
         return err;
 }
 
 void __exit br_netlink_fini(void)
 {
-        br_mdb_uninit();
         rtnl_link_unregister(&br_link_ops);
+        rtnl_unregister_all(PF_BRIDGE);
 }