net/bridge/br_netlink.c

   1 /*
   2  *      Bridge netlink control interface
   3  *
   4  *      Authors:
   5  *      Stephen Hemminger               <shemminger@osdl.org>
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version
  10  *      2 of the License, or (at your option) any later version.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <net/rtnetlink.h>
  15 #include "br_private.h"
  16
  17 static inline size_t br_nlmsg_size(void)
  18 {
  19         return NLMSG_ALIGN(sizeof(struct ifinfomsg))
  20                + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
  21                + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
  22                + nla_total_size(4) /* IFLA_MASTER */
  23                + nla_total_size(4) /* IFLA_MTU */
  24                + nla_total_size(4) /* IFLA_LINK */
  25                + nla_total_size(1) /* IFLA_OPERSTATE */
  26                + nla_total_size(1); /* IFLA_PROTINFO */
  27 }
  28
  29 /*
  30  * Create one netlink message for one interface
  31  * Contains port and master info as well as carrier and bridge state.
  32  */
  33 static int br_fill_ifinfo(struct sk_buff *skb, const struct net_bridge_port *port,
  34                           u32 pid, u32 seq, int event, unsigned int flags)
  35 {
  36         const struct net_bridge *br = port->br;
  37         const struct net_device *dev = port->dev;
  38         struct ifinfomsg *hdr;
  39         struct nlmsghdr *nlh;
  40         u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
  41
  42         pr_debug("br_fill_info event %d port %s master %s\n",
  43                  event, dev->name, br->dev->name);
  44
  45         nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
  46         if (nlh == NULL)
  47                 return -EMSGSIZE;
  48
  49         hdr = nlmsg_data(nlh);
  50         hdr->ifi_family = AF_BRIDGE;
  51         hdr->__ifi_pad = 0;
  52         hdr->ifi_type = dev->type;
  53         hdr->ifi_index = dev->ifindex;
  54         hdr->ifi_flags = dev_get_flags(dev);
  55         hdr->ifi_change = 0;
  56
  57         NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
  58         NLA_PUT_U32(skb, IFLA_MASTER, br->dev->ifindex);
  59         NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);
  60         NLA_PUT_U8(skb, IFLA_OPERSTATE, operstate);
  61
  62         if (dev->addr_len)
  63                 NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
  64
  65         if (dev->ifindex != dev->iflink)
  66                 NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);
  67
  68         if (event == RTM_NEWLINK)
  69                 NLA_PUT_U8(skb, IFLA_PROTINFO, port->state);
  70
  71         return nlmsg_end(skb, nlh);
  72
  73 nla_put_failure:
  74         nlmsg_cancel(skb, nlh);
  75         return -EMSGSIZE;
  76 }
  77
  78 /*
  79  * Notify listeners of a change in port information
  80  */
  81 void br_ifinfo_notify(int event, struct net_bridge_port *port)
  82 {
  83         struct sk_buff *skb;
  84         int err = -ENOBUFS;
  85
  86         pr_debug("bridge notify event=%d\n", event);
  87         skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC);
  88         if (skb == NULL)
  89                 goto errout;
  90
  91         err = br_fill_ifinfo(skb, port, 0, 0, event, 0);
  92         if (err < 0) {
  93                 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
  94                 WARN_ON(err == -EMSGSIZE);
  95                 kfree_skb(skb);
  96                 goto errout;
  97         }
  98         err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
  99 errout:
 100         if (err < 0)
 101                 rtnl_set_sk_err(RTNLGRP_LINK, err);
 102 }
 103
 104 /*
 105  * Dump information about all ports, in response to GETLINK
 106  */
 107 static int br_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
 108 {
 109         struct net_device *dev;
 110         int idx;
 111
 112         idx = 0;
 113         for_each_netdev(dev) {
 114                 /* not a bridge port */
 115                 if (dev->br_port == NULL || idx < cb->args[0])
 116                         goto skip;
 117
 118                 if (br_fill_ifinfo(skb, dev->br_port, NETLINK_CB(cb->skb).pid,
 119                                    cb->nlh->nlmsg_seq, RTM_NEWLINK,
 120                                    NLM_F_MULTI) < 0)
 121                         break;
 122 skip:
 123                 ++idx;
 124         }
 125
 126         cb->args[0] = idx;
 127
 128         return skb->len;
 129 }
 130
 131 /*
 132  * Change state of port (ie from forwarding to blocking etc)
 133  * Used by spanning tree in user space.
 134  */
 135 static int br_rtm_setlink(struct sk_buff *skb,  struct nlmsghdr *nlh, void *arg)
 136 {
 137         struct ifinfomsg *ifm;
 138         struct nlattr *protinfo;
 139         struct net_device *dev;
 140         struct net_bridge_port *p;
 141         u8 new_state;
 142
 143         if (nlmsg_len(nlh) < sizeof(*ifm))
 144                 return -EINVAL;
 145
 146         ifm = nlmsg_data(nlh);
 147         if (ifm->ifi_family != AF_BRIDGE)
 148                 return -EPFNOSUPPORT;
 149
 150         protinfo = nlmsg_find_attr(nlh, sizeof(*ifm), IFLA_PROTINFO);
 151         if (!protinfo || nla_len(protinfo) < sizeof(u8))
 152                 return -EINVAL;
 153
 154         new_state = nla_get_u8(protinfo);
 155         if (new_state > BR_STATE_BLOCKING)
 156                 return -EINVAL;
 157
 158         dev = __dev_get_by_index(ifm->ifi_index);
 159         if (!dev)
 160                 return -ENODEV;
 161
 162         p = dev->br_port;
 163         if (!p)
 164                 return -EINVAL;
 165
 166         /* if kernel STP is running, don't allow changes */
 167         if (p->br->stp_enabled == BR_KERNEL_STP)
 168                 return -EBUSY;
 169
 170         if (!netif_running(dev) ||
 171             (!netif_carrier_ok(dev) && new_state != BR_STATE_DISABLED))
 172                 return -ENETDOWN;
 173
 174         p->state = new_state;
 175         br_log_state(p);
 176         return 0;
 177 }
 178
 179
 180 int __init br_netlink_init(void)
 181 {
 182         if (__rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, br_dump_ifinfo))
 183                 return -ENOBUFS;
 184
 185         /* Only the first call to __rtnl_register can fail */
 186         __rtnl_register(PF_BRIDGE, RTM_SETLINK, br_rtm_setlink, NULL);
 187
 188         return 0;
 189 }
 190
 191 void __exit br_netlink_fini(void)
 192 {
 193         rtnl_unregister_all(PF_BRIDGE);
 194 }
 195