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 <linux/rtnetlink.h> 15 #include "br_private.h" 16 17 /* 18 * Create one netlink message for one interface 19 * Contains port and master info as well as carrier and bridge state. 20 */ 21 static int br_fill_ifinfo(struct sk_buff *skb, const struct net_bridge_port *port, 22 u32 pid, u32 seq, int event, unsigned int flags) 23 { 24 const struct net_bridge *br = port->br; 25 const struct net_device *dev = port->dev; 26 struct ifinfomsg *r; 27 struct nlmsghdr *nlh; 28 unsigned char *b = skb->tail; 29 u32 mtu = dev->mtu; 30 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN; 31 u8 portstate = port->state; 32 33 pr_debug("br_fill_info event %d port %s master %s\n", 34 event, dev->name, br->dev->name); 35 36 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*r), flags); 37 r = NLMSG_DATA(nlh); 38 r->ifi_family = AF_BRIDGE; 39 r->__ifi_pad = 0; 40 r->ifi_type = dev->type; 41 r->ifi_index = dev->ifindex; 42 r->ifi_flags = dev_get_flags(dev); 43 r->ifi_change = 0; 44 45 RTA_PUT(skb, IFLA_IFNAME, strlen(dev->name)+1, dev->name); 46 47 RTA_PUT(skb, IFLA_MASTER, sizeof(int), &br->dev->ifindex); 48 49 if (dev->addr_len) 50 RTA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); 51 52 RTA_PUT(skb, IFLA_MTU, sizeof(mtu), &mtu); 53 if (dev->ifindex != dev->iflink) 54 RTA_PUT(skb, IFLA_LINK, sizeof(int), &dev->iflink); 55 56 57 RTA_PUT(skb, IFLA_OPERSTATE, sizeof(operstate), &operstate); 58 59 if (event == RTM_NEWLINK) 60 RTA_PUT(skb, IFLA_PROTINFO, sizeof(portstate), &portstate); 61 62 nlh->nlmsg_len = skb->tail - b; 63 64 return skb->len; 65 66 nlmsg_failure: 67 rtattr_failure: 68 69 skb_trim(skb, b - skb->data); 70 return -EINVAL; 71 } 72 73 /* 74 * Notify listeners of a change in port information 75 */ 76 void br_ifinfo_notify(int event, struct net_bridge_port *port) 77 { 78 struct sk_buff *skb; 79 int err = -ENOMEM; 80 81 pr_debug("bridge notify event=%d\n", event); 82 skb = alloc_skb(NLMSG_SPACE(sizeof(struct ifinfomsg) + 128), 83 GFP_ATOMIC); 84 if (!skb) 85 goto err_out; 86 87 err = br_fill_ifinfo(skb, port, current->pid, 0, event, 0); 88 if (err) 89 goto err_kfree; 90 91 NETLINK_CB(skb).dst_group = RTNLGRP_LINK; 92 netlink_broadcast(rtnl, skb, 0, RTNLGRP_LINK, GFP_ATOMIC); 93 return; 94 95 err_kfree: 96 kfree_skb(skb); 97 err_out: 98 netlink_set_err(rtnl, 0, RTNLGRP_LINK, err); 99 } 100 101 /* 102 * Dump information about all ports, in response to GETLINK 103 */ 104 static int br_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 105 { 106 struct net_device *dev; 107 int idx; 108 int s_idx = cb->args[0]; 109 int err = 0; 110 111 read_lock(&dev_base_lock); 112 for (dev = dev_base, idx = 0; dev; dev = dev->next) { 113 struct net_bridge_port *p = dev->br_port; 114 115 /* not a bridge port */ 116 if (!p) 117 continue; 118 119 if (idx < s_idx) 120 continue; 121 122 err = br_fill_ifinfo(skb, p, NETLINK_CB(cb->skb).pid, 123 cb->nlh->nlmsg_seq, RTM_NEWLINK, NLM_F_MULTI); 124 if (err <= 0) 125 break; 126 ++idx; 127 } 128 read_unlock(&dev_base_lock); 129 130 cb->args[0] = idx; 131 132 return skb->len; 133 } 134 135 /* 136 * Change state of port (ie from forwarding to blocking etc) 137 * Used by spanning tree in user space. 138 */ 139 static int br_rtm_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 140 { 141 struct rtattr **rta = arg; 142 struct ifinfomsg *ifm = NLMSG_DATA(nlh); 143 struct net_device *dev; 144 struct net_bridge_port *p; 145 u8 new_state; 146 147 if (ifm->ifi_family != AF_BRIDGE) 148 return -EPFNOSUPPORT; 149 150 /* Must pass valid state as PROTINFO */ 151 if (rta[IFLA_PROTINFO-1]) { 152 u8 *pstate = RTA_DATA(rta[IFLA_PROTINFO-1]); 153 new_state = *pstate; 154 } else 155 return -EINVAL; 156 157 if (new_state > BR_STATE_BLOCKING) 158 return -EINVAL; 159 160 /* Find bridge port */ 161 dev = __dev_get_by_index(ifm->ifi_index); 162 if (!dev) 163 return -ENODEV; 164 165 p = dev->br_port; 166 if (!p) 167 return -EINVAL; 168 169 /* if kernel STP is running, don't allow changes */ 170 if (p->br->stp_enabled) 171 return -EBUSY; 172 173 if (!netif_running(dev)) 174 return -ENETDOWN; 175 176 if (!netif_carrier_ok(dev) && new_state != BR_STATE_DISABLED) 177 return -ENETDOWN; 178 179 p->state = new_state; 180 br_log_state(p); 181 return 0; 182 } 183 184 185 static struct rtnetlink_link bridge_rtnetlink_table[RTM_NR_MSGTYPES] = { 186 [RTM_GETLINK - RTM_BASE] = { .dumpit = br_dump_ifinfo, }, 187 [RTM_SETLINK - RTM_BASE] = { .doit = br_rtm_setlink, }, 188 }; 189 190 void __init br_netlink_init(void) 191 { 192 rtnetlink_links[PF_BRIDGE] = bridge_rtnetlink_table; 193 } 194 195 void __exit br_netlink_fini(void) 196 { 197 rtnetlink_links[PF_BRIDGE] = NULL; 198 } 199 200