]> git.ipfire.org Git - thirdparty/kernel/linux.git/blame - net/bridge/br_netlink.c
projects / thirdparty / kernel / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: bridge: convert multicast to generic rhashtable
[thirdparty/kernel/linux.git] / net / bridge / br_netlink.c
CommitLineData
11dc1f36
SH		 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>
5a0e3ad6 14#include <linux/slab.h>
bb900b27 15#include <linux/etherdevice.h>
32fe21c0 16#include <net/rtnetlink.h>
881d966b 17#include <net/net_namespace.h>
b854272b 18#include <net/sock.h>
407af329 19#include <uapi/linux/if_bridge.h>
bb900b27 20
11dc1f36 21#include "br_private.h"
b03b6dd5 22#include "br_private_stp.h"
efa5356b 23#include "br_private_tunnel.h"
11dc1f36 24
2594e906 25static int __get_num_vlan_infos(struct net_bridge_vlan_group *vg,
77751ee8 26 u32 filter_mask)
fed0a159 27{
2594e906
NA		 28 struct net_bridge_vlan *v;
29 u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
77751ee8 30 u16 flags, pvid;
fed0a159
RP		 31 int num_vlans = 0;
32
fed0a159
RP		 33 if (!(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
34 return 0;
35
77751ee8 36 pvid = br_get_pvid(vg);
2594e906 37 /* Count number of vlan infos */
586c2b57 38 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
fed0a159 39 flags = 0;
2594e906
NA		 40 /* only a context, bridge vlan not activated */
41 if (!br_vlan_should_use(v))
42 continue;
43 if (v->vid == pvid)
fed0a159
RP		 44 flags |= BRIDGE_VLAN_INFO_PVID;
45
2594e906 46 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
fed0a159
RP		 47 flags |= BRIDGE_VLAN_INFO_UNTAGGED;
48
49 if (vid_range_start == 0) {
50 goto initvars;
2594e906 51 } else if ((v->vid - vid_range_end) == 1 &&
fed0a159 52 flags == vid_range_flags) {
2594e906 53 vid_range_end = v->vid;
fed0a159
RP		 54 continue;
55 } else {
56 if ((vid_range_end - vid_range_start) > 0)
57 num_vlans += 2;
58 else
59 num_vlans += 1;
60 }
61initvars:
2594e906
NA		 62 vid_range_start = v->vid;
63 vid_range_end = v->vid;
fed0a159
RP		 64 vid_range_flags = flags;
65 }
66
67 if (vid_range_start != 0) {
68 if ((vid_range_end - vid_range_start) > 0)
69 num_vlans += 2;
70 else
71 num_vlans += 1;
72 }
73
74 return num_vlans;
75}
76
2594e906 77static int br_get_num_vlan_infos(struct net_bridge_vlan_group *vg,
77751ee8 78 u32 filter_mask)
2594e906 79{
586c2b57
NA		 80 int num_vlans;
81
2594e906
NA		 82 if (!vg)
83 return 0;
84
85 if (filter_mask & RTEXT_FILTER_BRVLAN)
86 return vg->num_vlans;
87
586c2b57
NA		 88 rcu_read_lock();
89 num_vlans = __get_num_vlan_infos(vg, filter_mask);
90 rcu_read_unlock();
91
92 return num_vlans;
2594e906
NA		 93}
94
fed0a159
RP		 95static size_t br_get_link_af_size_filtered(const struct net_device *dev,
96 u32 filter_mask)
b7853d73 97{
2594e906 98 struct net_bridge_vlan_group *vg = NULL;
efa5356b 99 struct net_bridge_port *p = NULL;
2594e906 100 struct net_bridge *br;
fed0a159 101 int num_vlan_infos;
efa5356b 102 size_t vinfo_sz = 0;
b7853d73 103
2f56f6be 104 rcu_read_lock();
2594e906
NA		 105 if (br_port_exists(dev)) {
106 p = br_port_get_rcu(dev);
907b1e6e 107 vg = nbp_vlan_group_rcu(p);
2594e906
NA		 108 } else if (dev->priv_flags & IFF_EBRIDGE) {
109 br = netdev_priv(dev);
907b1e6e 110 vg = br_vlan_group_rcu(br);
2594e906 111 }
77751ee8 112 num_vlan_infos = br_get_num_vlan_infos(vg, filter_mask);
2f56f6be 113 rcu_read_unlock();
b7853d73 114
efa5356b
RP		 115 if (p && (p->flags & BR_VLAN_TUNNEL))
116 vinfo_sz += br_get_vlan_tunnel_info_size(vg);
117
b7853d73 118 /* Each VLAN is returned in bridge_vlan_info along with flags */
efa5356b
RP		 119 vinfo_sz += num_vlan_infos * nla_total_size(sizeof(struct bridge_vlan_info));
120
121 return vinfo_sz;
b7853d73
RP		 122}
123
25c71c75 124static inline size_t br_port_info_size(void)
125{
126 return nla_total_size(1) /* IFLA_BRPORT_STATE */
127 + nla_total_size(2) /* IFLA_BRPORT_PRIORITY */
128 + nla_total_size(4) /* IFLA_BRPORT_COST */
129 + nla_total_size(1) /* IFLA_BRPORT_MODE */
a2e01a65 130 + nla_total_size(1) /* IFLA_BRPORT_GUARD */
1007dd1a 131 + nla_total_size(1) /* IFLA_BRPORT_PROTECT */
3da889b6 132 + nla_total_size(1) /* IFLA_BRPORT_FAST_LEAVE */
6db6f0ea 133 + nla_total_size(1) /* IFLA_BRPORT_MCAST_TO_UCAST */
9ba18891 134 + nla_total_size(1) /* IFLA_BRPORT_LEARNING */
867a5943 135 + nla_total_size(1) /* IFLA_BRPORT_UNICAST_FLOOD */
9051247d
TK		 136 + nla_total_size(1) /* IFLA_BRPORT_MCAST_FLOOD */
137 + nla_total_size(1) /* IFLA_BRPORT_BCAST_FLOOD */
355b9f9d 138 + nla_total_size(1) /* IFLA_BRPORT_PROXYARP */
786c2077 139 + nla_total_size(1) /* IFLA_BRPORT_PROXYARP_WIFI */
efa5356b 140 + nla_total_size(1) /* IFLA_BRPORT_VLAN_TUNNEL */
821f1b21 141 + nla_total_size(1) /* IFLA_BRPORT_NEIGH_SUPPRESS */
7d850abd 142 + nla_total_size(1) /* IFLA_BRPORT_ISOLATED */
4ebc7660 143 + nla_total_size(sizeof(struct ifla_bridge_id)) /* IFLA_BRPORT_ROOT_ID */
80df9a26 144 + nla_total_size(sizeof(struct ifla_bridge_id)) /* IFLA_BRPORT_BRIDGE_ID */
96f94e7f
NA		 145 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_DESIGNATED_PORT */
146 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_DESIGNATED_COST */
42d452c4
NA		 147 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_ID */
148 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_NO */
e08e838a
NA		 149 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_TOPOLOGY_CHANGE_ACK */
150 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_CONFIG_PENDING */
12a0faa3
ND		 151 + nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_MESSAGE_AGE_TIMER */
152 + nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_FORWARD_DELAY_TIMER */
153 + nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_HOLD_TIMER */
5d6ae479
NA		 154#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
155 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_MULTICAST_ROUTER */
156#endif
5af48b59 157 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_GROUP_FWD_MASK */
25c71c75 158 + 0;
159}
160
fed0a159 161static inline size_t br_nlmsg_size(struct net_device *dev, u32 filter_mask)
339bf98f
TG		 162{
163 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
25c71c75 164 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
165 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
166 + nla_total_size(4) /* IFLA_MASTER */
167 + nla_total_size(4) /* IFLA_MTU */
168 + nla_total_size(4) /* IFLA_LINK */
169 + nla_total_size(1) /* IFLA_OPERSTATE */
b7853d73 170 + nla_total_size(br_port_info_size()) /* IFLA_PROTINFO */
fed0a159 171 + nla_total_size(br_get_link_af_size_filtered(dev,
2756f68c
NA		 172 filter_mask)) /* IFLA_AF_SPEC */
173 + nla_total_size(4); /* IFLA_BRPORT_BACKUP_PORT */
25c71c75 174}
175
176static int br_port_fill_attrs(struct sk_buff *skb,
177 const struct net_bridge_port *p)
178{
179 u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
2756f68c 180 struct net_bridge_port *backup_p;
61c0a9a8 181 u64 timerval;
25c71c75 182
183 if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
184 nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
185 nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
a2e01a65 186 nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
1007dd1a 187 nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
b6cb5ac8
NA		 188 nla_put_u8(skb, IFLA_BRPORT_PROTECT,
189 !!(p->flags & BR_ROOT_BLOCK)) ||
190 nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE,
191 !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
6db6f0ea
FF		 192 nla_put_u8(skb, IFLA_BRPORT_MCAST_TO_UCAST,
193 !!(p->flags & BR_MULTICAST_TO_UNICAST)) ||
867a5943 194 nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
b6cb5ac8
NA		 195 nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD,
196 !!(p->flags & BR_FLOOD)) ||
197 nla_put_u8(skb, IFLA_BRPORT_MCAST_FLOOD,
198 !!(p->flags & BR_MCAST_FLOOD)) ||
99f906e9
MM		 199 nla_put_u8(skb, IFLA_BRPORT_BCAST_FLOOD,
200 !!(p->flags & BR_BCAST_FLOOD)) ||
842a9ae0
JM		 201 nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)) ||
202 nla_put_u8(skb, IFLA_BRPORT_PROXYARP_WIFI,
4ebc7660
NA		 203 !!(p->flags & BR_PROXYARP_WIFI)) ||
204 nla_put(skb, IFLA_BRPORT_ROOT_ID, sizeof(struct ifla_bridge_id),
80df9a26
NA		 205 &p->designated_root) ||
206 nla_put(skb, IFLA_BRPORT_BRIDGE_ID, sizeof(struct ifla_bridge_id),
96f94e7f
NA		 207 &p->designated_bridge) ||
208 nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_PORT, p->designated_port) ||
42d452c4
NA		 209 nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_COST, p->designated_cost) ||
210 nla_put_u16(skb, IFLA_BRPORT_ID, p->port_id) ||
e08e838a
NA		 211 nla_put_u16(skb, IFLA_BRPORT_NO, p->port_no) ||
212 nla_put_u8(skb, IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
213 p->topology_change_ack) ||
efa5356b
RP		 214 nla_put_u8(skb, IFLA_BRPORT_CONFIG_PENDING, p->config_pending) ||
215 nla_put_u8(skb, IFLA_BRPORT_VLAN_TUNNEL, !!(p->flags &
5af48b59 216 BR_VLAN_TUNNEL)) ||
821f1b21
RP		 217 nla_put_u16(skb, IFLA_BRPORT_GROUP_FWD_MASK, p->group_fwd_mask) ||
218 nla_put_u8(skb, IFLA_BRPORT_NEIGH_SUPPRESS,
7d850abd
NA		 219 !!(p->flags & BR_NEIGH_SUPPRESS)) ||
220 nla_put_u8(skb, IFLA_BRPORT_ISOLATED, !!(p->flags & BR_ISOLATED)))
25c71c75 221 return -EMSGSIZE;
222
61c0a9a8 223 timerval = br_timer_value(&p->message_age_timer);
12a0faa3
ND		 224 if (nla_put_u64_64bit(skb, IFLA_BRPORT_MESSAGE_AGE_TIMER, timerval,
225 IFLA_BRPORT_PAD))
61c0a9a8
NA		 226 return -EMSGSIZE;
227 timerval = br_timer_value(&p->forward_delay_timer);
12a0faa3
ND		 228 if (nla_put_u64_64bit(skb, IFLA_BRPORT_FORWARD_DELAY_TIMER, timerval,
229 IFLA_BRPORT_PAD))
61c0a9a8
NA		 230 return -EMSGSIZE;
231 timerval = br_timer_value(&p->hold_timer);
12a0faa3
ND		 232 if (nla_put_u64_64bit(skb, IFLA_BRPORT_HOLD_TIMER, timerval,
233 IFLA_BRPORT_PAD))
61c0a9a8
NA		 234 return -EMSGSIZE;
235
5d6ae479
NA		 236#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
237 if (nla_put_u8(skb, IFLA_BRPORT_MULTICAST_ROUTER,
238 p->multicast_router))
239 return -EMSGSIZE;
240#endif
241
2756f68c
NA		 242 /* we might be called only with br->lock */
243 rcu_read_lock();
244 backup_p = rcu_dereference(p->backup_port);
245 if (backup_p)
246 nla_put_u32(skb, IFLA_BRPORT_BACKUP_PORT,
247 backup_p->dev->ifindex);
248 rcu_read_unlock();
249
25c71c75 250 return 0;
339bf98f
TG		 251}
252
36cd0ffb
RP		 253static int br_fill_ifvlaninfo_range(struct sk_buff *skb, u16 vid_start,
254 u16 vid_end, u16 flags)
255{
256 struct bridge_vlan_info vinfo;
257
258 if ((vid_end - vid_start) > 0) {
259 /* add range to skb */
260 vinfo.vid = vid_start;
261 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_BEGIN;
262 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
263 sizeof(vinfo), &vinfo))
264 goto nla_put_failure;
265
36cd0ffb
RP		 266 vinfo.vid = vid_end;
267 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_END;
268 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
269 sizeof(vinfo), &vinfo))
270 goto nla_put_failure;
271 } else {
272 vinfo.vid = vid_start;
273 vinfo.flags = flags;
274 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
275 sizeof(vinfo), &vinfo))
276 goto nla_put_failure;
277 }
278
279 return 0;
280
281nla_put_failure:
282 return -EMSGSIZE;
283}
284
285static int br_fill_ifvlaninfo_compressed(struct sk_buff *skb,
77751ee8 286 struct net_bridge_vlan_group *vg)
36cd0ffb 287{
2594e906
NA		 288 struct net_bridge_vlan *v;
289 u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
77751ee8 290 u16 flags, pvid;
36cd0ffb
RP		 291 int err = 0;
292
293 /* Pack IFLA_BRIDGE_VLAN_INFO's for every vlan
294 * and mark vlan info with begin and end flags
295 * if vlaninfo represents a range
296 */
77751ee8 297 pvid = br_get_pvid(vg);
e9c953ef 298 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
36cd0ffb 299 flags = 0;
2594e906
NA		 300 if (!br_vlan_should_use(v))
301 continue;
302 if (v->vid == pvid)
36cd0ffb
RP		 303 flags |= BRIDGE_VLAN_INFO_PVID;
304
2594e906 305 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
36cd0ffb
RP		 306 flags |= BRIDGE_VLAN_INFO_UNTAGGED;
307
308 if (vid_range_start == 0) {
309 goto initvars;
2594e906 310 } else if ((v->vid - vid_range_end) == 1 &&
36cd0ffb 311 flags == vid_range_flags) {
2594e906 312 vid_range_end = v->vid;
36cd0ffb
RP		 313 continue;
314 } else {
315 err = br_fill_ifvlaninfo_range(skb, vid_range_start,
316 vid_range_end,
317 vid_range_flags);
318 if (err)
319 return err;
320 }
321
322initvars:
2594e906
NA		 323 vid_range_start = v->vid;
324 vid_range_end = v->vid;
36cd0ffb
RP		 325 vid_range_flags = flags;
326 }
327
0fe6de49
RP		 328 if (vid_range_start != 0) {
329 /* Call it once more to send any left over vlans */
330 err = br_fill_ifvlaninfo_range(skb, vid_range_start,
331 vid_range_end,
332 vid_range_flags);
333 if (err)
334 return err;
335 }
36cd0ffb
RP		 336
337 return 0;
338}
339
340static int br_fill_ifvlaninfo(struct sk_buff *skb,
77751ee8 341 struct net_bridge_vlan_group *vg)
36cd0ffb
RP		 342{
343 struct bridge_vlan_info vinfo;
2594e906 344 struct net_bridge_vlan *v;
77751ee8 345 u16 pvid;
36cd0ffb 346
77751ee8 347 pvid = br_get_pvid(vg);
e9c953ef 348 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
2594e906
NA		 349 if (!br_vlan_should_use(v))
350 continue;
351
352 vinfo.vid = v->vid;
36cd0ffb 353 vinfo.flags = 0;
2594e906 354 if (v->vid == pvid)
36cd0ffb
RP		 355 vinfo.flags |= BRIDGE_VLAN_INFO_PVID;
356
2594e906 357 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
36cd0ffb
RP		 358 vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
359
360 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
361 sizeof(vinfo), &vinfo))
362 goto nla_put_failure;
363 }
364
365 return 0;
366
367nla_put_failure:
368 return -EMSGSIZE;
369}
370
11dc1f36
SH		 371/*
372 * Create one netlink message for one interface
373 * Contains port and master info as well as carrier and bridge state.
374 */
6cbdceeb 375static int br_fill_ifinfo(struct sk_buff *skb,
92899063 376 const struct net_bridge_port *port,
6cbdceeb
VY		 377 u32 pid, u32 seq, int event, unsigned int flags,
378 u32 filter_mask, const struct net_device *dev)
11dc1f36 379{
92899063 380 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
2594e906 381 struct net_bridge *br;
74685962 382 struct ifinfomsg *hdr;
11dc1f36 383 struct nlmsghdr *nlh;
11dc1f36 384
6cbdceeb
VY		 385 if (port)
386 br = port->br;
387 else
388 br = netdev_priv(dev);
389
28a16c97 390 br_debug(br, "br_fill_info event %d port %s master %s\n",
391 event, dev->name, br->dev->name);
11dc1f36 392
74685962
TG		 393 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
394 if (nlh == NULL)
26932566 395 return -EMSGSIZE;
11dc1f36 396
74685962
TG		 397 hdr = nlmsg_data(nlh);
398 hdr->ifi_family = AF_BRIDGE;
399 hdr->__ifi_pad = 0;
400 hdr->ifi_type = dev->type;
401 hdr->ifi_index = dev->ifindex;
402 hdr->ifi_flags = dev_get_flags(dev);
403 hdr->ifi_change = 0;
11dc1f36 404
2eb812e6
DM		 405 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
406 nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
407 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
408 nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
409 (dev->addr_len &&
410 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
a54acb3a
ND		 411 (dev->ifindex != dev_get_iflink(dev) &&
412 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
2eb812e6 413 goto nla_put_failure;
25c71c75 414
6cbdceeb 415 if (event == RTM_NEWLINK && port) {
25c71c75 416 struct nlattr *nest
417 = nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
418
419 if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
420 goto nla_put_failure;
421 nla_nest_end(skb, nest);
422 }
423
6cbdceeb 424 /* Check if the VID information is requested */
36cd0ffb
RP		 425 if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
426 (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
2594e906 427 struct net_bridge_vlan_group *vg;
36cd0ffb
RP		 428 struct nlattr *af;
429 int err;
6cbdceeb 430
e9c953ef
NA		 431 /* RCU needed because of the VLAN locking rules (rcu || rtnl) */
432 rcu_read_lock();
77751ee8 433 if (port)
e9c953ef 434 vg = nbp_vlan_group_rcu(port);
77751ee8 435 else
e9c953ef 436 vg = br_vlan_group_rcu(br);
6cbdceeb 437
e9c953ef
NA		 438 if (!vg || !vg->num_vlans) {
439 rcu_read_unlock();
6cbdceeb 440 goto done;
e9c953ef 441 }
6cbdceeb 442 af = nla_nest_start(skb, IFLA_AF_SPEC);
e9c953ef
NA		 443 if (!af) {
444 rcu_read_unlock();
6cbdceeb 445 goto nla_put_failure;
e9c953ef 446 }
36cd0ffb 447 if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
77751ee8 448 err = br_fill_ifvlaninfo_compressed(skb, vg);
36cd0ffb 449 else
77751ee8 450 err = br_fill_ifvlaninfo(skb, vg);
efa5356b
RP		 451
452 if (port && (port->flags & BR_VLAN_TUNNEL))
453 err = br_fill_vlan_tunnel_info(skb, vg);
e9c953ef 454 rcu_read_unlock();
36cd0ffb
RP		 455 if (err)
456 goto nla_put_failure;
6cbdceeb
VY		 457 nla_nest_end(skb, af);
458 }
459
460done:
053c095a
JB		 461 nlmsg_end(skb, nlh);
462 return 0;
11dc1f36 463
74685962 464nla_put_failure:
26932566
PM		 465 nlmsg_cancel(skb, nlh);
466 return -EMSGSIZE;
11dc1f36
SH		 467}
468
92899063
NA		 469/* Notify listeners of a change in bridge or port information */
470void br_ifinfo_notify(int event, const struct net_bridge *br,
471 const struct net_bridge_port *port)
11dc1f36 472{
92899063
NA		 473 u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;
474 struct net_device *dev;
11dc1f36 475 struct sk_buff *skb;
280a306c 476 int err = -ENOBUFS;
92899063
NA		 477 struct net *net;
478 u16 port_no = 0;
11dc1f36 479
92899063 480 if (WARN_ON(!port && !br))
407af329
VY		 481 return;
482
92899063
NA		 483 if (port) {
484 dev = port->dev;
485 br = port->br;
486 port_no = port->port_no;
487 } else {
488 dev = br->dev;
489 }
490
491 net = dev_net(dev);
492 br_debug(br, "port %u(%s) event %d\n", port_no, dev->name, event);
28a16c97 493
92899063 494 skb = nlmsg_new(br_nlmsg_size(dev, filter), GFP_ATOMIC);
280a306c
TG		 495 if (skb == NULL)
496 goto errout;
497
92899063 498 err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, dev);
26932566
PM		 499 if (err < 0) {
500 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
501 WARN_ON(err == -EMSGSIZE);
502 kfree_skb(skb);
503 goto errout;
504 }
1ce85fe4
PNA		 505 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
506 return;
280a306c 507errout:
87e823b3 508 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
11dc1f36
SH		 509}
510
511/*
512 * Dump information about all ports, in response to GETLINK
513 */
e5a55a89 514int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
46c264da 515 struct net_device *dev, u32 filter_mask, int nlflags)
11dc1f36 516{
1fb1754a 517 struct net_bridge_port *port = br_port_get_rtnl(dev);
e5a55a89 518
36cd0ffb
RP		 519 if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
520 !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
1b846f92 521 return 0;
11dc1f36 522
46c264da 523 return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, nlflags,
1b846f92 524 filter_mask, dev);
11dc1f36
SH		 525}
526
bdced7ef 527static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
e19b42a1 528 int cmd, struct bridge_vlan_info *vinfo, bool *changed)
bdced7ef 529{
f418af63 530 bool curr_change;
bdced7ef
RP		 531 int err = 0;
532
533 switch (cmd) {
534 case RTM_SETLINK:
535 if (p) {
2594e906
NA		 536 /* if the MASTER flag is set this will act on the global
537 * per-VLAN entry as well
538 */
f418af63
NA		 539 err = nbp_vlan_add(p, vinfo->vid, vinfo->flags,
540 &curr_change);
bdced7ef 541 } else {
2594e906 542 vinfo->flags |= BRIDGE_VLAN_INFO_BRENTRY;
f418af63
NA		 543 err = br_vlan_add(br, vinfo->vid, vinfo->flags,
544 &curr_change);
bdced7ef 545 }
f418af63 546 if (curr_change)
e19b42a1 547 *changed = true;
bdced7ef
RP		 548 break;
549
550 case RTM_DELLINK:
551 if (p) {
e19b42a1
NA		 552 if (!nbp_vlan_delete(p, vinfo->vid))
553 *changed = true;
554
555 if ((vinfo->flags & BRIDGE_VLAN_INFO_MASTER) &&
556 !br_vlan_delete(p->br, vinfo->vid))
557 *changed = true;
558 } else if (!br_vlan_delete(br, vinfo->vid)) {
559 *changed = true;
bdced7ef
RP		 560 }
561 break;
562 }
563
564 return err;
565}
407af329 566
efa5356b
RP		 567static int br_process_vlan_info(struct net_bridge *br,
568 struct net_bridge_port *p, int cmd,
569 struct bridge_vlan_info *vinfo_curr,
e19b42a1
NA		 570 struct bridge_vlan_info **vinfo_last,
571 bool *changed)
efa5356b
RP		 572{
573 if (!vinfo_curr->vid || vinfo_curr->vid >= VLAN_VID_MASK)
574 return -EINVAL;
575
576 if (vinfo_curr->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
577 /* check if we are already processing a range */
578 if (*vinfo_last)
579 return -EINVAL;
580 *vinfo_last = vinfo_curr;
581 /* don't allow range of pvids */
582 if ((*vinfo_last)->flags & BRIDGE_VLAN_INFO_PVID)
583 return -EINVAL;
584 return 0;
585 }
586
587 if (*vinfo_last) {
588 struct bridge_vlan_info tmp_vinfo;
589 int v, err;
590
591 if (!(vinfo_curr->flags & BRIDGE_VLAN_INFO_RANGE_END))
592 return -EINVAL;
593
594 if (vinfo_curr->vid <= (*vinfo_last)->vid)
595 return -EINVAL;
596
597 memcpy(&tmp_vinfo, *vinfo_last,
598 sizeof(struct bridge_vlan_info));
599 for (v = (*vinfo_last)->vid; v <= vinfo_curr->vid; v++) {
600 tmp_vinfo.vid = v;
e19b42a1 601 err = br_vlan_info(br, p, cmd, &tmp_vinfo, changed);
efa5356b
RP		 602 if (err)
603 break;
604 }
605 *vinfo_last = NULL;
606
66c54517 607 return err;
efa5356b
RP		 608 }
609
e19b42a1 610 return br_vlan_info(br, p, cmd, vinfo_curr, changed);
efa5356b
RP		 611}
612
407af329
VY		 613static int br_afspec(struct net_bridge *br,
614 struct net_bridge_port *p,
615 struct nlattr *af_spec,
e19b42a1 616 int cmd, bool *changed)
407af329 617{
efa5356b
RP		 618 struct bridge_vlan_info *vinfo_curr = NULL;
619 struct bridge_vlan_info *vinfo_last = NULL;
bdced7ef 620 struct nlattr *attr;
efa5356b
RP		 621 struct vtunnel_info tinfo_last = {};
622 struct vtunnel_info tinfo_curr = {};
623 int err = 0, rem;
407af329 624
bdced7ef 625 nla_for_each_nested(attr, af_spec, rem) {
efa5356b
RP		 626 err = 0;
627 switch (nla_type(attr)) {
628 case IFLA_BRIDGE_VLAN_TUNNEL_INFO:
1020ce31 629 if (!p || !(p->flags & BR_VLAN_TUNNEL))
bdced7ef 630 return -EINVAL;
efa5356b
RP		 631 err = br_parse_vlan_tunnel_info(attr, &tinfo_curr);
632 if (err)
633 return err;
634 err = br_process_vlan_tunnel_info(br, p, cmd,
635 &tinfo_curr,
e19b42a1
NA		 636 &tinfo_last,
637 changed);
efa5356b
RP		 638 if (err)
639 return err;
640 break;
641 case IFLA_BRIDGE_VLAN_INFO:
642 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
6623c60d 643 return -EINVAL;
efa5356b
RP		 644 vinfo_curr = nla_data(attr);
645 err = br_process_vlan_info(br, p, cmd, vinfo_curr,
e19b42a1 646 &vinfo_last, changed);
efa5356b
RP		 647 if (err)
648 return err;
649 break;
bdced7ef 650 }
407af329
VY		 651 }
652
653 return err;
654}
655
3ac636b8 656static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
25c71c75 657 [IFLA_BRPORT_STATE] = { .type = NLA_U8 },
658 [IFLA_BRPORT_COST] = { .type = NLA_U32 },
659 [IFLA_BRPORT_PRIORITY] = { .type = NLA_U16 },
660 [IFLA_BRPORT_MODE] = { .type = NLA_U8 },
a2e01a65 661 [IFLA_BRPORT_GUARD] = { .type = NLA_U8 },
1007dd1a 662 [IFLA_BRPORT_PROTECT] = { .type = NLA_U8 },
6f705d8c 663 [IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
9ba18891 664 [IFLA_BRPORT_LEARNING] = { .type = NLA_U8 },
867a5943 665 [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
355b9f9d 666 [IFLA_BRPORT_PROXYARP] = { .type = NLA_U8 },
786c2077 667 [IFLA_BRPORT_PROXYARP_WIFI] = { .type = NLA_U8 },
5d6ae479 668 [IFLA_BRPORT_MULTICAST_ROUTER] = { .type = NLA_U8 },
6db6f0ea 669 [IFLA_BRPORT_MCAST_TO_UCAST] = { .type = NLA_U8 },
9051247d
TK		 670 [IFLA_BRPORT_MCAST_FLOOD] = { .type = NLA_U8 },
671 [IFLA_BRPORT_BCAST_FLOOD] = { .type = NLA_U8 },
fbec443b 672 [IFLA_BRPORT_VLAN_TUNNEL] = { .type = NLA_U8 },
5af48b59 673 [IFLA_BRPORT_GROUP_FWD_MASK] = { .type = NLA_U16 },
1a3fbd3f 674 [IFLA_BRPORT_NEIGH_SUPPRESS] = { .type = NLA_U8 },
7d850abd 675 [IFLA_BRPORT_ISOLATED] = { .type = NLA_U8 },
2756f68c 676 [IFLA_BRPORT_BACKUP_PORT] = { .type = NLA_U32 },
25c71c75 677};
678
679/* Change the state of the port and notify spanning tree */
680static int br_set_port_state(struct net_bridge_port *p, u8 state)
681{
682 if (state > BR_STATE_BLOCKING)
683 return -EINVAL;
684
685 /* if kernel STP is running, don't allow changes */
686 if (p->br->stp_enabled == BR_KERNEL_STP)
687 return -EBUSY;
688
576eb625 689 /* if device is not up, change is not allowed
690 * if link is not present, only allowable state is disabled
691 */
25c71c75 692 if (!netif_running(p->dev) ||
576eb625 693 (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
25c71c75 694 return -ENETDOWN;
695
775dd692 696 br_set_state(p, state);
25c71c75 697 br_port_state_selection(p->br);
698 return 0;
699}
700
701/* Set/clear or port flags based on attribute */
3922285d
AS		 702static int br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
703 int attrtype, unsigned long mask)
25c71c75 704{
3922285d
AS		 705 unsigned long flags;
706 int err;
707
708 if (!tb[attrtype])
709 return 0;
710
711 if (nla_get_u8(tb[attrtype]))
712 flags = p->flags | mask;
713 else
714 flags = p->flags & ~mask;
715
716 err = br_switchdev_set_port_flag(p, flags, mask);
717 if (err)
718 return err;
719
720 p->flags = flags;
721 return 0;
25c71c75 722}
723
724/* Process bridge protocol info on port */
725static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
726{
e028e4b8 727 unsigned long old_flags = p->flags;
efa5356b
RP		 728 bool br_vlan_tunnel_old = false;
729 int err;
25c71c75 730
3922285d
AS		 731 err = br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
732 if (err)
733 return err;
734
735 err = br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
736 if (err)
737 return err;
738
739 err = br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
740 if (err)
741 return err;
742
743 err = br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
744 if (err)
745 return err;
746
747 err = br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
748 if (err)
749 return err;
750
751 err = br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
752 if (err)
753 return err;
754
755 err = br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD);
756 if (err)
757 return err;
758
759 err = br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_TO_UCAST, BR_MULTICAST_TO_UNICAST);
760 if (err)
761 return err;
762
763 err = br_set_port_flag(p, tb, IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD);
764 if (err)
765 return err;
766
767 err = br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
768 if (err)
769 return err;
770
771 err = br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);
772 if (err)
773 return err;
25c71c75 774
efa5356b 775 br_vlan_tunnel_old = (p->flags & BR_VLAN_TUNNEL) ? true : false;
3922285d
AS		 776 err = br_set_port_flag(p, tb, IFLA_BRPORT_VLAN_TUNNEL, BR_VLAN_TUNNEL);
777 if (err)
778 return err;
779
efa5356b
RP		 780 if (br_vlan_tunnel_old && !(p->flags & BR_VLAN_TUNNEL))
781 nbp_vlan_tunnel_info_flush(p);
782
25c71c75 783 if (tb[IFLA_BRPORT_COST]) {
784 err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
785 if (err)
786 return err;
787 }
788
789 if (tb[IFLA_BRPORT_PRIORITY]) {
790 err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
791 if (err)
792 return err;
793 }
794
795 if (tb[IFLA_BRPORT_STATE]) {
796 err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
797 if (err)
798 return err;
799 }
e028e4b8 800
9b0c6e4d
NA		 801 if (tb[IFLA_BRPORT_FLUSH])
802 br_fdb_delete_by_port(p->br, p, 0, 0);
803
5d6ae479
NA		 804#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
805 if (tb[IFLA_BRPORT_MULTICAST_ROUTER]) {
806 u8 mcast_router = nla_get_u8(tb[IFLA_BRPORT_MULTICAST_ROUTER]);
807
808 err = br_multicast_set_port_router(p, mcast_router);
809 if (err)
810 return err;
811 }
812#endif
5af48b59
NA		 813
814 if (tb[IFLA_BRPORT_GROUP_FWD_MASK]) {
815 u16 fwd_mask = nla_get_u16(tb[IFLA_BRPORT_GROUP_FWD_MASK]);
816
817 if (fwd_mask & BR_GROUPFWD_MACPAUSE)
818 return -EINVAL;
819 p->group_fwd_mask = fwd_mask;
820 }
821
821f1b21
RP		 822 err = br_set_port_flag(p, tb, IFLA_BRPORT_NEIGH_SUPPRESS,
823 BR_NEIGH_SUPPRESS);
824 if (err)
825 return err;
826
7d850abd
NA		 827 err = br_set_port_flag(p, tb, IFLA_BRPORT_ISOLATED, BR_ISOLATED);
828 if (err)
829 return err;
830
2756f68c
NA		 831 if (tb[IFLA_BRPORT_BACKUP_PORT]) {
832 struct net_device *backup_dev = NULL;
833 u32 backup_ifindex;
834
835 backup_ifindex = nla_get_u32(tb[IFLA_BRPORT_BACKUP_PORT]);
836 if (backup_ifindex) {
837 backup_dev = __dev_get_by_index(dev_net(p->dev),
838 backup_ifindex);
839 if (!backup_dev)
840 return -ENOENT;
841 }
842
843 err = nbp_backup_change(p, backup_dev);
844 if (err)
845 return err;
846 }
847
e028e4b8 848 br_port_flags_change(p, old_flags ^ p->flags);
25c71c75 849 return 0;
850}
851
852/* Change state and parameters on port. */
add511b3 853int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
11dc1f36 854{
92899063
NA		 855 struct net_bridge *br = (struct net_bridge *)netdev_priv(dev);
856 struct nlattr *tb[IFLA_BRPORT_MAX + 1];
857 struct net_bridge_port *p;
74685962 858 struct nlattr *protinfo;
407af329 859 struct nlattr *afspec;
e19b42a1 860 bool changed = false;
41c498b9 861 int err = 0;
11dc1f36 862
c60ee67f
H		 863 protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
864 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
407af329 865 if (!protinfo && !afspec)
25c71c75 866 return 0;
11dc1f36 867
ec1e5610 868 p = br_port_get_rtnl(dev);
407af329 869 /* We want to accept dev as bridge itself if the AF_SPEC
8e3bff96 870 * is set to see if someone is setting vlan info on the bridge
407af329 871 */
7b99a993 872 if (!p && !afspec)
b5ed54e9 873 return -EINVAL;
11dc1f36 874
407af329
VY		 875 if (p && protinfo) {
876 if (protinfo->nla_type & NLA_F_NESTED) {
fceb6435
JB		 877 err = nla_parse_nested(tb, IFLA_BRPORT_MAX, protinfo,
878 br_port_policy, NULL);
407af329
VY		 879 if (err)
880 return err;
881
882 spin_lock_bh(&p->br->lock);
883 err = br_setport(p, tb);
884 spin_unlock_bh(&p->br->lock);
885 } else {
8e3bff96 886 /* Binary compatibility with old RSTP */
407af329
VY		 887 if (nla_len(protinfo) < sizeof(u8))
888 return -EINVAL;
889
890 spin_lock_bh(&p->br->lock);
891 err = br_set_port_state(p, nla_get_u8(protinfo));
892 spin_unlock_bh(&p->br->lock);
893 }
25c71c75 894 if (err)
407af329 895 goto out;
e19b42a1 896 changed = true;
407af329 897 }
11dc1f36 898
92899063
NA		 899 if (afspec)
900 err = br_afspec(br, p, afspec, RTM_SETLINK, &changed);
b03b6dd5 901
e19b42a1 902 if (changed)
92899063 903 br_ifinfo_notify(RTM_NEWLINK, br, p);
407af329 904out:
25c71c75 905 return err;
11dc1f36
SH		 906}
907
407af329 908/* Delete port information */
add511b3 909int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
407af329 910{
92899063 911 struct net_bridge *br = (struct net_bridge *)netdev_priv(dev);
407af329 912 struct net_bridge_port *p;
92899063 913 struct nlattr *afspec;
e19b42a1 914 bool changed = false;
8508025c 915 int err = 0;
407af329 916
c60ee67f 917 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
407af329
VY		 918 if (!afspec)
919 return 0;
920
921 p = br_port_get_rtnl(dev);
922 /* We want to accept dev as bridge itself as well */
923 if (!p && !(dev->priv_flags & IFF_EBRIDGE))
924 return -EINVAL;
925
92899063 926 err = br_afspec(br, p, afspec, RTM_DELLINK, &changed);
e19b42a1 927 if (changed)
02dba438
RP		 928 /* Send RTM_NEWLINK because userspace
929 * expects RTM_NEWLINK for vlan dels
930 */
92899063 931 br_ifinfo_notify(RTM_NEWLINK, br, p);
407af329
VY		 932
933 return err;
934}
a8b8a889
MS		 935
936static int br_validate(struct nlattr *tb[], struct nlattr *data[],
937 struct netlink_ext_ack *extack)
bb900b27 938{
939 if (tb[IFLA_ADDRESS]) {
940 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
941 return -EINVAL;
942 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
943 return -EADDRNOTAVAIL;
944 }
945
d2d427b3
TM		 946 if (!data)
947 return 0;
948
949#ifdef CONFIG_BRIDGE_VLAN_FILTERING
950 if (data[IFLA_BR_VLAN_PROTOCOL]) {
951 switch (nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL])) {
952 case htons(ETH_P_8021Q):
953 case htons(ETH_P_8021AD):
954 break;
955 default:
956 return -EPROTONOSUPPORT;
957 }
958 }
a2858602
TJ		 959
960 if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
961 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
962
963 if (defpvid >= VLAN_VID_MASK)
964 return -EINVAL;
965 }
d2d427b3
TM		 966#endif
967
bb900b27 968 return 0;
969}
970
3ac636b8
JP		 971static int br_port_slave_changelink(struct net_device *brdev,
972 struct net_device *dev,
973 struct nlattr *tb[],
17dd0ec4
MS		 974 struct nlattr *data[],
975 struct netlink_ext_ack *extack)
3ac636b8 976{
963ad948
NA		 977 struct net_bridge *br = netdev_priv(brdev);
978 int ret;
979
3ac636b8
JP		 980 if (!data)
981 return 0;
963ad948
NA		 982
983 spin_lock_bh(&br->lock);
984 ret = br_setport(br_port_get_rtnl(dev), data);
985 spin_unlock_bh(&br->lock);
986
987 return ret;
3ac636b8
JP		 988}
989
ced8283f
JP		 990static int br_port_fill_slave_info(struct sk_buff *skb,
991 const struct net_device *brdev,
992 const struct net_device *dev)
993{
994 return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
995}
996
997static size_t br_port_get_slave_size(const struct net_device *brdev,
998 const struct net_device *dev)
999{
1000 return br_port_info_size();
1001}
1002
13323516
JP		 1003static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
1004 [IFLA_BR_FORWARD_DELAY] = { .type = NLA_U32 },
1005 [IFLA_BR_HELLO_TIME] = { .type = NLA_U32 },
1006 [IFLA_BR_MAX_AGE] = { .type = NLA_U32 },
af615762
JT		 1007 [IFLA_BR_AGEING_TIME] = { .type = NLA_U32 },
1008 [IFLA_BR_STP_STATE] = { .type = NLA_U32 },
1009 [IFLA_BR_PRIORITY] = { .type = NLA_U16 },
a7854037 1010 [IFLA_BR_VLAN_FILTERING] = { .type = NLA_U8 },
d2d427b3 1011 [IFLA_BR_VLAN_PROTOCOL] = { .type = NLA_U16 },
7910228b 1012 [IFLA_BR_GROUP_FWD_MASK] = { .type = NLA_U16 },
111189ab
NA		 1013 [IFLA_BR_GROUP_ADDR] = { .type = NLA_BINARY,
1014 .len = ETH_ALEN },
a9a6bc70 1015 [IFLA_BR_MCAST_ROUTER] = { .type = NLA_U8 },
89126327 1016 [IFLA_BR_MCAST_SNOOPING] = { .type = NLA_U8 },
295141d9 1017 [IFLA_BR_MCAST_QUERY_USE_IFADDR] = { .type = NLA_U8 },
ba062d7c 1018 [IFLA_BR_MCAST_QUERIER] = { .type = NLA_U8 },
431db3c0 1019 [IFLA_BR_MCAST_HASH_ELASTICITY] = { .type = NLA_U32 },
858079fd 1020 [IFLA_BR_MCAST_HASH_MAX] = { .type = NLA_U32 },
79b859f5 1021 [IFLA_BR_MCAST_LAST_MEMBER_CNT] = { .type = NLA_U32 },
b89e6bab 1022 [IFLA_BR_MCAST_STARTUP_QUERY_CNT] = { .type = NLA_U32 },
7e4df51e
NA		 1023 [IFLA_BR_MCAST_LAST_MEMBER_INTVL] = { .type = NLA_U64 },
1024 [IFLA_BR_MCAST_MEMBERSHIP_INTVL] = { .type = NLA_U64 },
1025 [IFLA_BR_MCAST_QUERIER_INTVL] = { .type = NLA_U64 },
1026 [IFLA_BR_MCAST_QUERY_INTVL] = { .type = NLA_U64 },
1027 [IFLA_BR_MCAST_QUERY_RESPONSE_INTVL] = { .type = NLA_U64 },
1028 [IFLA_BR_MCAST_STARTUP_QUERY_INTVL] = { .type = NLA_U64 },
93870cc0
NA		 1029 [IFLA_BR_NF_CALL_IPTABLES] = { .type = NLA_U8 },
1030 [IFLA_BR_NF_CALL_IP6TABLES] = { .type = NLA_U8 },
1031 [IFLA_BR_NF_CALL_ARPTABLES] = { .type = NLA_U8 },
0f963b75 1032 [IFLA_BR_VLAN_DEFAULT_PVID] = { .type = NLA_U16 },
6dada9b1 1033 [IFLA_BR_VLAN_STATS_ENABLED] = { .type = NLA_U8 },
1080ab95 1034 [IFLA_BR_MCAST_STATS_ENABLED] = { .type = NLA_U8 },
5e923585 1035 [IFLA_BR_MCAST_IGMP_VERSION] = { .type = NLA_U8 },
aa2ae3e7 1036 [IFLA_BR_MCAST_MLD_VERSION] = { .type = NLA_U8 },
9163a0fc 1037 [IFLA_BR_VLAN_STATS_PER_PORT] = { .type = NLA_U8 },
a428afe8
NA		 1038 [IFLA_BR_MULTI_BOOLOPT] = { .type = NLA_EXACT_LEN,
1039 .len = sizeof(struct br_boolopt_multi) },
13323516
JP		 1040};
1041
1042static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
ad744b22
MS		 1043 struct nlattr *data[],
1044 struct netlink_ext_ack *extack)
13323516
JP		 1045{
1046 struct net_bridge *br = netdev_priv(brdev);
1047 int err;
1048
1049 if (!data)
1050 return 0;
1051
1052 if (data[IFLA_BR_FORWARD_DELAY]) {
1053 err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
1054 if (err)
1055 return err;
1056 }
1057
1058 if (data[IFLA_BR_HELLO_TIME]) {
1059 err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
1060 if (err)
1061 return err;
1062 }
1063
1064 if (data[IFLA_BR_MAX_AGE]) {
1065 err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
1066 if (err)
1067 return err;
1068 }
1069
af615762 1070 if (data[IFLA_BR_AGEING_TIME]) {
c62987bb
SF		 1071 err = br_set_ageing_time(br, nla_get_u32(data[IFLA_BR_AGEING_TIME]));
1072 if (err)
1073 return err;
af615762
JT		 1074 }
1075
1076 if (data[IFLA_BR_STP_STATE]) {
1077 u32 stp_enabled = nla_get_u32(data[IFLA_BR_STP_STATE]);
1078
1079 br_stp_set_enabled(br, stp_enabled);
1080 }
1081
1082 if (data[IFLA_BR_PRIORITY]) {
1083 u32 priority = nla_get_u16(data[IFLA_BR_PRIORITY]);
1084
1085 br_stp_set_bridge_priority(br, priority);
1086 }
1087
a7854037
NA		 1088 if (data[IFLA_BR_VLAN_FILTERING]) {
1089 u8 vlan_filter = nla_get_u8(data[IFLA_BR_VLAN_FILTERING]);
1090
1091 err = __br_vlan_filter_toggle(br, vlan_filter);
1092 if (err)
1093 return err;
1094 }
1095
d2d427b3
TM		 1096#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1097 if (data[IFLA_BR_VLAN_PROTOCOL]) {
1098 __be16 vlan_proto = nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL]);
1099
1100 err = __br_vlan_set_proto(br, vlan_proto);
1101 if (err)
1102 return err;
1103 }
0f963b75
NA		 1104
1105 if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
1106 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
1107
1108 err = __br_vlan_set_default_pvid(br, defpvid);
1109 if (err)
1110 return err;
1111 }
6dada9b1
NA		 1112
1113 if (data[IFLA_BR_VLAN_STATS_ENABLED]) {
1114 __u8 vlan_stats = nla_get_u8(data[IFLA_BR_VLAN_STATS_ENABLED]);
1115
1116 err = br_vlan_set_stats(br, vlan_stats);
1117 if (err)
1118 return err;
1119 }
9163a0fc
NA		 1120
1121 if (data[IFLA_BR_VLAN_STATS_PER_PORT]) {
1122 __u8 per_port = nla_get_u8(data[IFLA_BR_VLAN_STATS_PER_PORT]);
1123
1124 err = br_vlan_set_stats_per_port(br, per_port);
1125 if (err)
1126 return err;
1127 }
d2d427b3
TM		 1128#endif
1129
7910228b
NA		 1130 if (data[IFLA_BR_GROUP_FWD_MASK]) {
1131 u16 fwd_mask = nla_get_u16(data[IFLA_BR_GROUP_FWD_MASK]);
1132
1133 if (fwd_mask & BR_GROUPFWD_RESTRICTED)
1134 return -EINVAL;
1135 br->group_fwd_mask = fwd_mask;
1136 }
1137
111189ab
NA		 1138 if (data[IFLA_BR_GROUP_ADDR]) {
1139 u8 new_addr[ETH_ALEN];
1140
1141 if (nla_len(data[IFLA_BR_GROUP_ADDR]) != ETH_ALEN)
1142 return -EINVAL;
1143 memcpy(new_addr, nla_data(data[IFLA_BR_GROUP_ADDR]), ETH_ALEN);
1144 if (!is_link_local_ether_addr(new_addr))
1145 return -EINVAL;
1146 if (new_addr[5] == 1 || /* 802.3x Pause address */
1147 new_addr[5] == 2 || /* 802.3ad Slow protocols */
1148 new_addr[5] == 3) /* 802.1X PAE address */
1149 return -EINVAL;
1150 spin_lock_bh(&br->lock);
1151 memcpy(br->group_addr, new_addr, sizeof(br->group_addr));
1152 spin_unlock_bh(&br->lock);
be3664a0 1153 br_opt_toggle(br, BROPT_GROUP_ADDR_SET, true);
111189ab
NA		 1154 br_recalculate_fwd_mask(br);
1155 }
1156
150217c6
NA		 1157 if (data[IFLA_BR_FDB_FLUSH])
1158 br_fdb_flush(br);
1159
a9a6bc70
NA		 1160#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1161 if (data[IFLA_BR_MCAST_ROUTER]) {
1162 u8 multicast_router = nla_get_u8(data[IFLA_BR_MCAST_ROUTER]);
1163
1164 err = br_multicast_set_router(br, multicast_router);
1165 if (err)
1166 return err;
1167 }
89126327
NA		 1168
1169 if (data[IFLA_BR_MCAST_SNOOPING]) {
1170 u8 mcast_snooping = nla_get_u8(data[IFLA_BR_MCAST_SNOOPING]);
1171
1172 err = br_multicast_toggle(br, mcast_snooping);
1173 if (err)
1174 return err;
1175 }
295141d9
NA		 1176
1177 if (data[IFLA_BR_MCAST_QUERY_USE_IFADDR]) {
1178 u8 val;
1179
1180 val = nla_get_u8(data[IFLA_BR_MCAST_QUERY_USE_IFADDR]);
675779ad 1181 br_opt_toggle(br, BROPT_MULTICAST_QUERY_USE_IFADDR, !!val);
295141d9 1182 }
ba062d7c
NA		 1183
1184 if (data[IFLA_BR_MCAST_QUERIER]) {
1185 u8 mcast_querier = nla_get_u8(data[IFLA_BR_MCAST_QUERIER]);
1186
1187 err = br_multicast_set_querier(br, mcast_querier);
1188 if (err)
1189 return err;
1190 }
431db3c0
NA		 1191
1192 if (data[IFLA_BR_MCAST_HASH_ELASTICITY]) {
1193 u32 val = nla_get_u32(data[IFLA_BR_MCAST_HASH_ELASTICITY]);
1194
1195 br->hash_elasticity = val;
1196 }
858079fd 1197
19e3a9c9
NA		 1198 if (data[IFLA_BR_MCAST_HASH_MAX])
1199 br->hash_max = nla_get_u32(data[IFLA_BR_MCAST_HASH_MAX]);
79b859f5
NA		 1200
1201 if (data[IFLA_BR_MCAST_LAST_MEMBER_CNT]) {
1202 u32 val = nla_get_u32(data[IFLA_BR_MCAST_LAST_MEMBER_CNT]);
1203
1204 br->multicast_last_member_count = val;
1205 }
b89e6bab
NA		 1206
1207 if (data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]) {
1208 u32 val = nla_get_u32(data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]);
1209
1210 br->multicast_startup_query_count = val;
1211 }
7e4df51e
NA		 1212
1213 if (data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]) {
1214 u64 val = nla_get_u64(data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]);
1215
1216 br->multicast_last_member_interval = clock_t_to_jiffies(val);
1217 }
1218
1219 if (data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]) {
1220 u64 val = nla_get_u64(data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]);
1221
1222 br->multicast_membership_interval = clock_t_to_jiffies(val);
1223 }
1224
1225 if (data[IFLA_BR_MCAST_QUERIER_INTVL]) {
1226 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERIER_INTVL]);
1227
1228 br->multicast_querier_interval = clock_t_to_jiffies(val);
1229 }
1230
1231 if (data[IFLA_BR_MCAST_QUERY_INTVL]) {
1232 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_INTVL]);
1233
1234 br->multicast_query_interval = clock_t_to_jiffies(val);
1235 }
1236
1237 if (data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]) {
1238 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]);
1239
1240 br->multicast_query_response_interval = clock_t_to_jiffies(val);
1241 }
1242
1243 if (data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]) {
1244 u64 val = nla_get_u64(data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]);
1245
1246 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
1247 }
1080ab95
NA		 1248
1249 if (data[IFLA_BR_MCAST_STATS_ENABLED]) {
1250 __u8 mcast_stats;
1251
1252 mcast_stats = nla_get_u8(data[IFLA_BR_MCAST_STATS_ENABLED]);
675779ad 1253 br_opt_toggle(br, BROPT_MULTICAST_STATS_ENABLED, !!mcast_stats);
1080ab95 1254 }
5e923585
NA		 1255
1256 if (data[IFLA_BR_MCAST_IGMP_VERSION]) {
1257 __u8 igmp_version;
1258
1259 igmp_version = nla_get_u8(data[IFLA_BR_MCAST_IGMP_VERSION]);
1260 err = br_multicast_set_igmp_version(br, igmp_version);
1261 if (err)
1262 return err;
1263 }
aa2ae3e7
NA		 1264
1265#if IS_ENABLED(CONFIG_IPV6)
1266 if (data[IFLA_BR_MCAST_MLD_VERSION]) {
1267 __u8 mld_version;
1268
1269 mld_version = nla_get_u8(data[IFLA_BR_MCAST_MLD_VERSION]);
1270 err = br_multicast_set_mld_version(br, mld_version);
1271 if (err)
1272 return err;
1273 }
1274#endif
a9a6bc70 1275#endif
93870cc0
NA		 1276#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1277 if (data[IFLA_BR_NF_CALL_IPTABLES]) {
1278 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IPTABLES]);
1279
8df3510f 1280 br_opt_toggle(br, BROPT_NF_CALL_IPTABLES, !!val);
93870cc0
NA		 1281 }
1282
1283 if (data[IFLA_BR_NF_CALL_IP6TABLES]) {
1284 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IP6TABLES]);
1285
8df3510f 1286 br_opt_toggle(br, BROPT_NF_CALL_IP6TABLES, !!val);
93870cc0
NA		 1287 }
1288
1289 if (data[IFLA_BR_NF_CALL_ARPTABLES]) {
1290 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_ARPTABLES]);
1291
8df3510f 1292 br_opt_toggle(br, BROPT_NF_CALL_ARPTABLES, !!val);
93870cc0
NA		 1293 }
1294#endif
a9a6bc70 1295
a428afe8
NA		 1296 if (data[IFLA_BR_MULTI_BOOLOPT]) {
1297 struct br_boolopt_multi *bm;
1298
1299 bm = nla_data(data[IFLA_BR_MULTI_BOOLOPT]);
1300 err = br_boolopt_multi_toggle(br, bm, extack);
1301 if (err)
1302 return err;
1303 }
1304
13323516
JP		 1305 return 0;
1306}
1307
b6677449 1308static int br_dev_newlink(struct net *src_net, struct net_device *dev,
7a3f4a18
MS		 1309 struct nlattr *tb[], struct nlattr *data[],
1310 struct netlink_ext_ack *extack)
b6677449
IV		 1311{
1312 struct net_bridge *br = netdev_priv(dev);
1313 int err;
1314
84aeb437
NA		 1315 err = register_netdevice(dev);
1316 if (err)
1317 return err;
1318
b6677449
IV		 1319 if (tb[IFLA_ADDRESS]) {
1320 spin_lock_bh(&br->lock);
1321 br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
1322 spin_unlock_bh(&br->lock);
1323 }
1324
ad744b22 1325 err = br_changelink(dev, tb, data, extack);
5b8d5429 1326 if (err)
84aeb437
NA		 1327 br_dev_delete(dev, NULL);
1328
5b8d5429 1329 return err;
b6677449
IV		 1330}
1331
e5c3ea5c
JP		 1332static size_t br_get_size(const struct net_device *brdev)
1333{
1334 return nla_total_size(sizeof(u32)) + /* IFLA_BR_FORWARD_DELAY */
1335 nla_total_size(sizeof(u32)) + /* IFLA_BR_HELLO_TIME */
1336 nla_total_size(sizeof(u32)) + /* IFLA_BR_MAX_AGE */
af615762
JT		 1337 nla_total_size(sizeof(u32)) + /* IFLA_BR_AGEING_TIME */
1338 nla_total_size(sizeof(u32)) + /* IFLA_BR_STP_STATE */
1339 nla_total_size(sizeof(u16)) + /* IFLA_BR_PRIORITY */
a7854037 1340 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_FILTERING */
d2d427b3
TM		 1341#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1342 nla_total_size(sizeof(__be16)) + /* IFLA_BR_VLAN_PROTOCOL */
0f963b75 1343 nla_total_size(sizeof(u16)) + /* IFLA_BR_VLAN_DEFAULT_PVID */
6dada9b1 1344 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_STATS_ENABLED */
9163a0fc 1345 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_STATS_PER_PORT */
d2d427b3 1346#endif
7910228b 1347 nla_total_size(sizeof(u16)) + /* IFLA_BR_GROUP_FWD_MASK */
5127c81f 1348 nla_total_size(sizeof(struct ifla_bridge_id)) + /* IFLA_BR_ROOT_ID */
7599a220 1349 nla_total_size(sizeof(struct ifla_bridge_id)) + /* IFLA_BR_BRIDGE_ID */
8762ba68 1350 nla_total_size(sizeof(u16)) + /* IFLA_BR_ROOT_PORT */
684dd248 1351 nla_total_size(sizeof(u32)) + /* IFLA_BR_ROOT_PATH_COST */
b89e6bab
NA		 1352 nla_total_size(sizeof(u8)) + /* IFLA_BR_TOPOLOGY_CHANGE */
1353 nla_total_size(sizeof(u8)) + /* IFLA_BR_TOPOLOGY_CHANGE_DETECTED */
12a0faa3
ND		 1354 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_HELLO_TIMER */
1355 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TCN_TIMER */
1356 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TOPOLOGY_CHANGE_TIMER */
1357 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_GC_TIMER */
111189ab 1358 nla_total_size(ETH_ALEN) + /* IFLA_BR_GROUP_ADDR */
a9a6bc70
NA		 1359#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1360 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_ROUTER */
89126327 1361 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_SNOOPING */
295141d9 1362 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_QUERY_USE_IFADDR */
ba062d7c 1363 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_QUERIER */
1080ab95 1364 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_STATS_ENABLED */
b89e6bab
NA		 1365 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_HASH_ELASTICITY */
1366 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_HASH_MAX */
1367 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_LAST_MEMBER_CNT */
1368 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_STARTUP_QUERY_CNT */
12a0faa3
ND		 1369 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_LAST_MEMBER_INTVL */
1370 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_MEMBERSHIP_INTVL */
1371 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERIER_INTVL */
1372 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_INTVL */
1373 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_RESPONSE_INTVL */
1374 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_STARTUP_QUERY_INTVL */
5e923585 1375 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_IGMP_VERSION */
aa2ae3e7 1376 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_MLD_VERSION */
93870cc0
NA		 1377#endif
1378#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1379 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_IPTABLES */
1380 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_IP6TABLES */
1381 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_ARPTABLES */
a9a6bc70 1382#endif
a428afe8 1383 nla_total_size(sizeof(struct br_boolopt_multi)) + /* IFLA_BR_MULTI_BOOLOPT */
e5c3ea5c
JP		 1384 0;
1385}
1386
1387static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
1388{
1389 struct net_bridge *br = netdev_priv(brdev);
1390 u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
1391 u32 hello_time = jiffies_to_clock_t(br->hello_time);
1392 u32 age_time = jiffies_to_clock_t(br->max_age);
af615762
JT		 1393 u32 ageing_time = jiffies_to_clock_t(br->ageing_time);
1394 u32 stp_enabled = br->stp_enabled;
1395 u16 priority = (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1];
1f51445a 1396 u8 vlan_enabled = br_vlan_enabled(br->dev);
a428afe8 1397 struct br_boolopt_multi bm;
4917a154
NA		 1398 u64 clockval;
1399
1400 clockval = br_timer_value(&br->hello_timer);
12a0faa3 1401 if (nla_put_u64_64bit(skb, IFLA_BR_HELLO_TIMER, clockval, IFLA_BR_PAD))
4917a154
NA		 1402 return -EMSGSIZE;
1403 clockval = br_timer_value(&br->tcn_timer);
12a0faa3 1404 if (nla_put_u64_64bit(skb, IFLA_BR_TCN_TIMER, clockval, IFLA_BR_PAD))
4917a154
NA		 1405 return -EMSGSIZE;
1406 clockval = br_timer_value(&br->topology_change_timer);
12a0faa3
ND		 1407 if (nla_put_u64_64bit(skb, IFLA_BR_TOPOLOGY_CHANGE_TIMER, clockval,
1408 IFLA_BR_PAD))
4917a154 1409 return -EMSGSIZE;
f7cdee8a 1410 clockval = br_timer_value(&br->gc_work.timer);
12a0faa3 1411 if (nla_put_u64_64bit(skb, IFLA_BR_GC_TIMER, clockval, IFLA_BR_PAD))
4917a154 1412 return -EMSGSIZE;
e5c3ea5c 1413
a428afe8 1414 br_boolopt_multi_get(br, &bm);
e5c3ea5c
JP		 1415 if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
1416 nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
af615762
JT		 1417 nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time) ||
1418 nla_put_u32(skb, IFLA_BR_AGEING_TIME, ageing_time) ||
1419 nla_put_u32(skb, IFLA_BR_STP_STATE, stp_enabled) ||
a7854037 1420 nla_put_u16(skb, IFLA_BR_PRIORITY, priority) ||
7910228b 1421 nla_put_u8(skb, IFLA_BR_VLAN_FILTERING, vlan_enabled) ||
4917a154
NA		 1422 nla_put_u16(skb, IFLA_BR_GROUP_FWD_MASK, br->group_fwd_mask) ||
1423 nla_put(skb, IFLA_BR_BRIDGE_ID, sizeof(struct ifla_bridge_id),
1424 &br->bridge_id) ||
1425 nla_put(skb, IFLA_BR_ROOT_ID, sizeof(struct ifla_bridge_id),
1426 &br->designated_root) ||
684dd248 1427 nla_put_u16(skb, IFLA_BR_ROOT_PORT, br->root_port) ||
ed416309
NA		 1428 nla_put_u32(skb, IFLA_BR_ROOT_PATH_COST, br->root_path_cost) ||
1429 nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE, br->topology_change) ||
1430 nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
d76bd14e 1431 br->topology_change_detected) ||
a428afe8
NA		 1432 nla_put(skb, IFLA_BR_GROUP_ADDR, ETH_ALEN, br->group_addr) ||
1433 nla_put(skb, IFLA_BR_MULTI_BOOLOPT, sizeof(bm), &bm))
e5c3ea5c
JP		 1434 return -EMSGSIZE;
1435
d2d427b3 1436#ifdef CONFIG_BRIDGE_VLAN_FILTERING
0f963b75 1437 if (nla_put_be16(skb, IFLA_BR_VLAN_PROTOCOL, br->vlan_proto) ||
6dada9b1 1438 nla_put_u16(skb, IFLA_BR_VLAN_DEFAULT_PVID, br->default_pvid) ||
ae75767e 1439 nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED,
9163a0fc
NA		 1440 br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) ||
1441 nla_put_u8(skb, IFLA_BR_VLAN_STATS_PER_PORT,
1442 br_opt_get(br, IFLA_BR_VLAN_STATS_PER_PORT)))
d2d427b3
TM		 1443 return -EMSGSIZE;
1444#endif
a9a6bc70 1445#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
89126327 1446 if (nla_put_u8(skb, IFLA_BR_MCAST_ROUTER, br->multicast_router) ||
13cefad2
NA		 1447 nla_put_u8(skb, IFLA_BR_MCAST_SNOOPING,
1448 br_opt_get(br, BROPT_MULTICAST_ENABLED)) ||
295141d9 1449 nla_put_u8(skb, IFLA_BR_MCAST_QUERY_USE_IFADDR,
675779ad
NA		 1450 br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR)) ||
1451 nla_put_u8(skb, IFLA_BR_MCAST_QUERIER,
1452 br_opt_get(br, BROPT_MULTICAST_QUERIER)) ||
1080ab95 1453 nla_put_u8(skb, IFLA_BR_MCAST_STATS_ENABLED,
675779ad 1454 br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) ||
431db3c0 1455 nla_put_u32(skb, IFLA_BR_MCAST_HASH_ELASTICITY,
858079fd 1456 br->hash_elasticity) ||
79b859f5
NA		 1457 nla_put_u32(skb, IFLA_BR_MCAST_HASH_MAX, br->hash_max) ||
1458 nla_put_u32(skb, IFLA_BR_MCAST_LAST_MEMBER_CNT,
b89e6bab
NA		 1459 br->multicast_last_member_count) ||
1460 nla_put_u32(skb, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
5e923585
NA		 1461 br->multicast_startup_query_count) ||
1462 nla_put_u8(skb, IFLA_BR_MCAST_IGMP_VERSION,
1463 br->multicast_igmp_version))
a9a6bc70 1464 return -EMSGSIZE;
aa2ae3e7
NA		 1465#if IS_ENABLED(CONFIG_IPV6)
1466 if (nla_put_u8(skb, IFLA_BR_MCAST_MLD_VERSION,
1467 br->multicast_mld_version))
1468 return -EMSGSIZE;
1469#endif
7e4df51e 1470 clockval = jiffies_to_clock_t(br->multicast_last_member_interval);
12a0faa3
ND		 1471 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_LAST_MEMBER_INTVL, clockval,
1472 IFLA_BR_PAD))
7e4df51e
NA		 1473 return -EMSGSIZE;
1474 clockval = jiffies_to_clock_t(br->multicast_membership_interval);
12a0faa3
ND		 1475 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_MEMBERSHIP_INTVL, clockval,
1476 IFLA_BR_PAD))
7e4df51e
NA		 1477 return -EMSGSIZE;
1478 clockval = jiffies_to_clock_t(br->multicast_querier_interval);
12a0faa3
ND		 1479 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERIER_INTVL, clockval,
1480 IFLA_BR_PAD))
7e4df51e
NA		 1481 return -EMSGSIZE;
1482 clockval = jiffies_to_clock_t(br->multicast_query_interval);
12a0faa3
ND		 1483 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_INTVL, clockval,
1484 IFLA_BR_PAD))
7e4df51e
NA		 1485 return -EMSGSIZE;
1486 clockval = jiffies_to_clock_t(br->multicast_query_response_interval);
12a0faa3
ND		 1487 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, clockval,
1488 IFLA_BR_PAD))
7e4df51e
NA		 1489 return -EMSGSIZE;
1490 clockval = jiffies_to_clock_t(br->multicast_startup_query_interval);
12a0faa3
ND		 1491 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_STARTUP_QUERY_INTVL, clockval,
1492 IFLA_BR_PAD))
7e4df51e 1493 return -EMSGSIZE;
a9a6bc70 1494#endif
93870cc0
NA		 1495#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1496 if (nla_put_u8(skb, IFLA_BR_NF_CALL_IPTABLES,
8df3510f 1497 br_opt_get(br, BROPT_NF_CALL_IPTABLES) ? 1 : 0) ||
93870cc0 1498 nla_put_u8(skb, IFLA_BR_NF_CALL_IP6TABLES,
8df3510f 1499 br_opt_get(br, BROPT_NF_CALL_IP6TABLES) ? 1 : 0) ||
93870cc0 1500 nla_put_u8(skb, IFLA_BR_NF_CALL_ARPTABLES,
8df3510f 1501 br_opt_get(br, BROPT_NF_CALL_ARPTABLES) ? 1 : 0))
93870cc0
NA		 1502 return -EMSGSIZE;
1503#endif
a9a6bc70 1504
e5c3ea5c
JP		 1505 return 0;
1506}
1507
d5ff8c41 1508static size_t br_get_linkxstats_size(const struct net_device *dev, int attr)
a60c0903 1509{
d5ff8c41 1510 struct net_bridge_port *p = NULL;
a60c0903
NA		 1511 struct net_bridge_vlan_group *vg;
1512 struct net_bridge_vlan *v;
d5ff8c41 1513 struct net_bridge *br;
a60c0903
NA		 1514 int numvls = 0;
1515
d5ff8c41
NA		 1516 switch (attr) {
1517 case IFLA_STATS_LINK_XSTATS:
1518 br = netdev_priv(dev);
1519 vg = br_vlan_group(br);
1520 break;
1521 case IFLA_STATS_LINK_XSTATS_SLAVE:
1522 p = br_port_get_rtnl(dev);
1523 if (!p)
1524 return 0;
1525 br = p->br;
1526 vg = nbp_vlan_group(p);
1527 break;
1528 default:
1529 return 0;
1530 }
1531
1080ab95
NA		 1532 if (vg) {
1533 /* we need to count all, even placeholder entries */
1534 list_for_each_entry(v, &vg->vlan_list, vlist)
1535 numvls++;
1536 }
a60c0903 1537
a60c0903 1538 return numvls * nla_total_size(sizeof(struct bridge_vlan_xstats)) +
1080ab95 1539 nla_total_size(sizeof(struct br_mcast_stats)) +
a60c0903
NA		 1540 nla_total_size(0);
1541}
1542
d5ff8c41
NA		 1543static int br_fill_linkxstats(struct sk_buff *skb,
1544 const struct net_device *dev,
1545 int *prividx, int attr)
80e73cc5 1546{
d5ff8c41
NA		 1547 struct nlattr *nla __maybe_unused;
1548 struct net_bridge_port *p = NULL;
1549 struct net_bridge_vlan_group *vg;
1550 struct net_bridge_vlan *v;
1551 struct net_bridge *br;
1552 struct nlattr *nest;
1553 int vl_idx = 0;
80e73cc5
NA		 1554
1555 switch (attr) {
1556 case IFLA_STATS_LINK_XSTATS:
d5ff8c41
NA		 1557 br = netdev_priv(dev);
1558 vg = br_vlan_group(br);
80e73cc5
NA		 1559 break;
1560 case IFLA_STATS_LINK_XSTATS_SLAVE:
d5ff8c41
NA		 1561 p = br_port_get_rtnl(dev);
1562 if (!p)
1563 return 0;
1564 br = p->br;
1565 vg = nbp_vlan_group(p);
80e73cc5 1566 break;
d5ff8c41
NA		 1567 default:
1568 return -EINVAL;
80e73cc5
NA		 1569 }
1570
a60c0903
NA		 1571 nest = nla_nest_start(skb, LINK_XSTATS_TYPE_BRIDGE);
1572 if (!nest)
1573 return -EMSGSIZE;
a60c0903 1574
1080ab95 1575 if (vg) {
72f4af4e
NA		 1576 u16 pvid;
1577
1578 pvid = br_get_pvid(vg);
1080ab95
NA		 1579 list_for_each_entry(v, &vg->vlan_list, vlist) {
1580 struct bridge_vlan_xstats vxi;
1581 struct br_vlan_stats stats;
1582
1583 if (++vl_idx < *prividx)
1584 continue;
1585 memset(&vxi, 0, sizeof(vxi));
1586 vxi.vid = v->vid;
61ba1a2d 1587 vxi.flags = v->flags;
72f4af4e
NA		 1588 if (v->vid == pvid)
1589 vxi.flags |= BRIDGE_VLAN_INFO_PVID;
1080ab95
NA		 1590 br_vlan_get_stats(v, &stats);
1591 vxi.rx_bytes = stats.rx_bytes;
1592 vxi.rx_packets = stats.rx_packets;
1593 vxi.tx_bytes = stats.tx_bytes;
1594 vxi.tx_packets = stats.tx_packets;
1595
1596 if (nla_put(skb, BRIDGE_XSTATS_VLAN, sizeof(vxi), &vxi))
1597 goto nla_put_failure;
1598 }
1599 }
1600
1601#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1602 if (++vl_idx >= *prividx) {
1603 nla = nla_reserve_64bit(skb, BRIDGE_XSTATS_MCAST,
1604 sizeof(struct br_mcast_stats),
1605 BRIDGE_XSTATS_PAD);
1606 if (!nla)
a60c0903 1607 goto nla_put_failure;
d5ff8c41 1608 br_multicast_get_stats(br, p, nla_data(nla));
a60c0903 1609 }
1080ab95 1610#endif
a60c0903
NA		 1611 nla_nest_end(skb, nest);
1612 *prividx = 0;
1080ab95 1613
a60c0903
NA		 1614 return 0;
1615
1616nla_put_failure:
1617 nla_nest_end(skb, nest);
1618 *prividx = vl_idx;
1619
1620 return -EMSGSIZE;
1621}
fed0a159 1622
207895fd 1623static struct rtnl_af_ops br_af_ops __read_mostly = {
6cbdceeb 1624 .family = AF_BRIDGE,
b1974ed0 1625 .get_link_af_size = br_get_link_af_size_filtered,
6cbdceeb
VY		 1626};
1627
149ddd83 1628struct rtnl_link_ops br_link_ops __read_mostly = {
ced8283f
JP		 1629 .kind = "bridge",
1630 .priv_size = sizeof(struct net_bridge),
1631 .setup = br_dev_setup,
eb4cb851 1632 .maxtype = IFLA_BR_MAX,
13323516 1633 .policy = br_policy,
ced8283f
JP		 1634 .validate = br_validate,
1635 .newlink = br_dev_newlink,
13323516 1636 .changelink = br_changelink,
ced8283f 1637 .dellink = br_dev_delete,
e5c3ea5c
JP		 1638 .get_size = br_get_size,
1639 .fill_info = br_fill_info,
a60c0903
NA		 1640 .fill_linkxstats = br_fill_linkxstats,
1641 .get_linkxstats_size = br_get_linkxstats_size,
3ac636b8
JP		 1642
1643 .slave_maxtype = IFLA_BRPORT_MAX,
1644 .slave_policy = br_port_policy,
1645 .slave_changelink = br_port_slave_changelink,
ced8283f
JP		 1646 .get_slave_size = br_port_get_slave_size,
1647 .fill_slave_info = br_port_fill_slave_info,
bb900b27 1648};
11dc1f36 1649
32fe21c0 1650int __init br_netlink_init(void)
11dc1f36 1651{
3ec8e9f0
VY		 1652 int err;
1653
1654 br_mdb_init();
3678a9d8 1655 rtnl_af_register(&br_af_ops);
3ec8e9f0 1656
6cbdceeb
VY		 1657 err = rtnl_link_register(&br_link_ops);
1658 if (err)
1659 goto out_af;
1660
3ec8e9f0 1661 return 0;
6cbdceeb
VY		 1662
1663out_af:
1664 rtnl_af_unregister(&br_af_ops);
3ec8e9f0
VY		 1665 br_mdb_uninit();
1666 return err;
11dc1f36
SH		 1667}
1668
34666d46 1669void br_netlink_fini(void)
11dc1f36 1670{
3ec8e9f0 1671 br_mdb_uninit();
6cbdceeb 1672 rtnl_af_unregister(&br_af_ops);
bb900b27 1673 rtnl_link_unregister(&br_link_ops);
11dc1f36 1674}
A mirror of Linus' kernel repository