1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/kernel.h>
14#include <linux/slab.h>
15#include <linux/etherdevice.h>
16#include <net/rtnetlink.h>
17#include <net/net_namespace.h>
18#include <net/sock.h>
19
20#include "br_private.h"
21#include "br_private_stp.h"
22
23static inline size_t br_nlmsg_size(void)
24{
25 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
26 + nla_total_size(IFNAMSIZ)
27 + nla_total_size(MAX_ADDR_LEN)
28 + nla_total_size(4)
29 + nla_total_size(4)
30 + nla_total_size(4)
31 + nla_total_size(1)
32 + nla_total_size(1);
33}
34
35
36
37
38
39static int br_fill_ifinfo(struct sk_buff *skb, const struct net_bridge_port *port,
40 u32 pid, u32 seq, int event, unsigned int flags)
41{
42 const struct net_bridge *br = port->br;
43 const struct net_device *dev = port->dev;
44 struct ifinfomsg *hdr;
45 struct nlmsghdr *nlh;
46 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
47
48 br_debug(br, "br_fill_info event %d port %s master %s\n",
49 event, dev->name, br->dev->name);
50
51 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
52 if (nlh == NULL)
53 return -EMSGSIZE;
54
55 hdr = nlmsg_data(nlh);
56 hdr->ifi_family = AF_BRIDGE;
57 hdr->__ifi_pad = 0;
58 hdr->ifi_type = dev->type;
59 hdr->ifi_index = dev->ifindex;
60 hdr->ifi_flags = dev_get_flags(dev);
61 hdr->ifi_change = 0;
62
63 NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
64 NLA_PUT_U32(skb, IFLA_MASTER, br->dev->ifindex);
65 NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);
66 NLA_PUT_U8(skb, IFLA_OPERSTATE, operstate);
67
68 if (dev->addr_len)
69 NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
70
71 if (dev->ifindex != dev->iflink)
72 NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);
73
74 if (event == RTM_NEWLINK)
75 NLA_PUT_U8(skb, IFLA_PROTINFO, port->state);
76
77 return nlmsg_end(skb, nlh);
78
79nla_put_failure:
80 nlmsg_cancel(skb, nlh);
81 return -EMSGSIZE;
82}
83
84
85
86
87void br_ifinfo_notify(int event, struct net_bridge_port *port)
88{
89 struct net *net = dev_net(port->dev);
90 struct sk_buff *skb;
91 int err = -ENOBUFS;
92
93 br_debug(port->br, "port %u(%s) event %d\n",
94 (unsigned)port->port_no, port->dev->name, event);
95
96 skb = nlmsg_new(br_nlmsg_size(), GFP_ATOMIC);
97 if (skb == NULL)
98 goto errout;
99
100 err = br_fill_ifinfo(skb, port, 0, 0, event, 0);
101 if (err < 0) {
102
103 WARN_ON(err == -EMSGSIZE);
104 kfree_skb(skb);
105 goto errout;
106 }
107 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
108 return;
109errout:
110 if (err < 0)
111 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
112}
113
114
115
116
117static int br_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
118{
119 struct net *net = sock_net(skb->sk);
120 struct net_device *dev;
121 int idx;
122
123 idx = 0;
124 rcu_read_lock();
125 for_each_netdev_rcu(net, dev) {
126 struct net_bridge_port *port = br_port_get_rcu(dev);
127
128
129 if (!port || idx < cb->args[0])
130 goto skip;
131
132 if (br_fill_ifinfo(skb, port,
133 NETLINK_CB(cb->skb).pid,
134 cb->nlh->nlmsg_seq, RTM_NEWLINK,
135 NLM_F_MULTI) < 0)
136 break;
137skip:
138 ++idx;
139 }
140 rcu_read_unlock();
141 cb->args[0] = idx;
142
143 return skb->len;
144}
145
146
147
148
149
150static int br_rtm_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
151{
152 struct net *net = sock_net(skb->sk);
153 struct ifinfomsg *ifm;
154 struct nlattr *protinfo;
155 struct net_device *dev;
156 struct net_bridge_port *p;
157 u8 new_state;
158
159 if (nlmsg_len(nlh) < sizeof(*ifm))
160 return -EINVAL;
161
162 ifm = nlmsg_data(nlh);
163 if (ifm->ifi_family != AF_BRIDGE)
164 return -EPFNOSUPPORT;
165
166 protinfo = nlmsg_find_attr(nlh, sizeof(*ifm), IFLA_PROTINFO);
167 if (!protinfo || nla_len(protinfo) < sizeof(u8))
168 return -EINVAL;
169
170 new_state = nla_get_u8(protinfo);
171 if (new_state > BR_STATE_BLOCKING)
172 return -EINVAL;
173
174 dev = __dev_get_by_index(net, ifm->ifi_index);
175 if (!dev)
176 return -ENODEV;
177
178 p = br_port_get_rtnl(dev);
179 if (!p)
180 return -EINVAL;
181
182
183 if (p->br->stp_enabled == BR_KERNEL_STP)
184 return -EBUSY;
185
186 if (!netif_running(dev) ||
187 (!netif_carrier_ok(dev) && new_state != BR_STATE_DISABLED))
188 return -ENETDOWN;
189
190 p->state = new_state;
191 br_log_state(p);
192
193 spin_lock_bh(&p->br->lock);
194 br_port_state_selection(p->br);
195 spin_unlock_bh(&p->br->lock);
196
197 br_ifinfo_notify(RTM_NEWLINK, p);
198
199 return 0;
200}
201
202static int br_validate(struct nlattr *tb[], struct nlattr *data[])
203{
204 if (tb[IFLA_ADDRESS]) {
205 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
206 return -EINVAL;
207 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
208 return -EADDRNOTAVAIL;
209 }
210
211 return 0;
212}
213
214static struct rtnl_link_ops br_link_ops __read_mostly = {
215 .kind = "bridge",
216 .priv_size = sizeof(struct net_bridge),
217 .setup = br_dev_setup,
218 .validate = br_validate,
219 .dellink = br_dev_delete,
220};
221
222int __init br_netlink_init(void)
223{
224 int err;
225
226 err = rtnl_link_register(&br_link_ops);
227 if (err < 0)
228 goto err1;
229
230 err = __rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL,
231 br_dump_ifinfo, NULL);
232 if (err)
233 goto err2;
234 err = __rtnl_register(PF_BRIDGE, RTM_SETLINK,
235 br_rtm_setlink, NULL, NULL);
236 if (err)
237 goto err3;
238 err = __rtnl_register(PF_BRIDGE, RTM_NEWNEIGH,
239 br_fdb_add, NULL, NULL);
240 if (err)
241 goto err3;
242 err = __rtnl_register(PF_BRIDGE, RTM_DELNEIGH,
243 br_fdb_delete, NULL, NULL);
244 if (err)
245 goto err3;
246 err = __rtnl_register(PF_BRIDGE, RTM_GETNEIGH,
247 NULL, br_fdb_dump, NULL);
248 if (err)
249 goto err3;
250
251 return 0;
252
253err3:
254 rtnl_unregister_all(PF_BRIDGE);
255err2:
256 rtnl_link_unregister(&br_link_ops);
257err1:
258 return err;
259}
260
261void __exit br_netlink_fini(void)
262{
263 rtnl_link_unregister(&br_link_ops);
264 rtnl_unregister_all(PF_BRIDGE);
265}
266
