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         for (dev = dev_base, idx = 0; dev; dev = dev->next) {
 113                 /* not a bridge port */
 114                 if (dev->br_port == NULL || idx < cb->args[0])
 115                         goto skip;
 116
 117                 if (br_fill_ifinfo(skb, dev->br_port, NETLINK_CB(cb->skb).pid,
 118                                    cb->nlh->nlmsg_seq, RTM_NEWLINK,
 119                                    NLM_F_MULTI) < 0)
 120                         break;
 121 skip:
 122                 ++idx;
 123         }
 124
 125         cb->args[0] = idx;
 126
 127         return skb->len;
 128 }
 129
 130 /*
 131  * Change state of port (ie from forwarding to blocking etc)
 132  * Used by spanning tree in user space.
 133  */
 134 static int br_rtm_setlink(struct sk_buff *skb,  struct nlmsghdr *nlh, void *arg)
 135 {
 136         struct ifinfomsg *ifm;
 137         struct nlattr *protinfo;
 138         struct net_device *dev;
 139         struct net_bridge_port *p;
 140         u8 new_state;
 141
 142         if (nlmsg_len(nlh) < sizeof(*ifm))
 143                 return -EINVAL;
 144
 145         ifm = nlmsg_data(nlh);
 146         if (ifm->ifi_family != AF_BRIDGE)
 147                 return -EPFNOSUPPORT;
 148
 149         protinfo = nlmsg_find_attr(nlh, sizeof(*ifm), IFLA_PROTINFO);
 150         if (!protinfo || nla_len(protinfo) < sizeof(u8))
 151                 return -EINVAL;
 152
 153         new_state = nla_get_u8(protinfo);
 154         if (new_state > BR_STATE_BLOCKING)
 155                 return -EINVAL;
 156
 157         dev = __dev_get_by_index(ifm->ifi_index);
 158         if (!dev)
 159                 return -ENODEV;
 160
 161         p = dev->br_port;
 162         if (!p)
 163                 return -EINVAL;
 164
 165         /* if kernel STP is running, don't allow changes */
 166         if (p->br->stp_enabled == BR_KERNEL_STP)
 167                 return -EBUSY;
 168
 169         if (!netif_running(dev) ||
 170             (!netif_carrier_ok(dev) && new_state != BR_STATE_DISABLED))
 171                 return -ENETDOWN;
 172
 173         p->state = new_state;
 174         br_log_state(p);
 175         return 0;
 176 }
 177
 178
 179 int __init br_netlink_init(void)
 180 {
 181         if (__rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, br_dump_ifinfo))
 182                 return -ENOBUFS;
 183
 184         /* Only the first call to __rtnl_register can fail */
 185         __rtnl_register(PF_BRIDGE, RTM_SETLINK, br_rtm_setlink, NULL);
 186
 187         return 0;
 188 }
 189
 190 void __exit br_netlink_fini(void)
 191 {
 192         rtnl_unregister_all(PF_BRIDGE);
 193 }
 194