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