projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bridge: mrp: Integrate MRP into the bridge
[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;
6cbdceeb
VY		 456 nla_nest_end(skb, af);
457 }
458
459done:
053c095a
JB		 460 nlmsg_end(skb, nlh);
461 return 0;
11dc1f36 462
74685962 463nla_put_failure:
26932566
PM		 464 nlmsg_cancel(skb, nlh);
465 return -EMSGSIZE;
11dc1f36
SH		 466}
467
92899063
NA		 468/* Notify listeners of a change in bridge or port information */
469void br_ifinfo_notify(int event, const struct net_bridge *br,
470 const struct net_bridge_port *port)
11dc1f36 471{
92899063
NA		 472 u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;
473 struct net_device *dev;
11dc1f36 474 struct sk_buff *skb;
280a306c 475 int err = -ENOBUFS;
92899063
NA		 476 struct net *net;
477 u16 port_no = 0;
11dc1f36 478
92899063 479 if (WARN_ON(!port && !br))
407af329
VY		 480 return;
481
92899063
NA		 482 if (port) {
483 dev = port->dev;
484 br = port->br;
485 port_no = port->port_no;
486 } else {
487 dev = br->dev;
488 }
489
490 net = dev_net(dev);
491 br_debug(br, "port %u(%s) event %d\n", port_no, dev->name, event);
28a16c97 492
92899063 493 skb = nlmsg_new(br_nlmsg_size(dev, filter), GFP_ATOMIC);
280a306c
TG		 494 if (skb == NULL)
495 goto errout;
496
92899063 497 err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, dev);
26932566
PM		 498 if (err < 0) {
499 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
500 WARN_ON(err == -EMSGSIZE);
501 kfree_skb(skb);
502 goto errout;
503 }
1ce85fe4
PNA		 504 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
505 return;
280a306c 506errout:
87e823b3 507 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
11dc1f36
SH		 508}
509
510/*
511 * Dump information about all ports, in response to GETLINK
512 */
e5a55a89 513int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
46c264da 514 struct net_device *dev, u32 filter_mask, int nlflags)
11dc1f36 515{
1fb1754a 516 struct net_bridge_port *port = br_port_get_rtnl(dev);
e5a55a89 517
36cd0ffb
RP		 518 if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
519 !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
1b846f92 520 return 0;
11dc1f36 521
46c264da 522 return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, nlflags,
1b846f92 523 filter_mask, dev);
11dc1f36
SH		 524}
525
bdced7ef 526static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
169327d5
PM		 527 int cmd, struct bridge_vlan_info *vinfo, bool *changed,
528 struct netlink_ext_ack *extack)
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 539 err = nbp_vlan_add(p, vinfo->vid, vinfo->flags,
169327d5 540 &curr_change, extack);
bdced7ef 541 } else {
2594e906 542 vinfo->flags |= BRIDGE_VLAN_INFO_BRENTRY;
f418af63 543 err = br_vlan_add(br, vinfo->vid, vinfo->flags,
169327d5 544 &curr_change, extack);
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
f26b2965
NA		 567int br_process_vlan_info(struct net_bridge *br,
568 struct net_bridge_port *p, int cmd,
569 struct bridge_vlan_info *vinfo_curr,
570 struct bridge_vlan_info **vinfo_last,
571 bool *changed,
572 struct netlink_ext_ack *extack)
efa5356b 573{
f545923b
NA		 574 int err, rtm_cmd;
575
8f4cc940 576 if (!br_vlan_valid_id(vinfo_curr->vid, extack))
efa5356b
RP		 577 return -EINVAL;
578
f545923b
NA		 579 /* needed for vlan-only NEWVLAN/DELVLAN notifications */
580 rtm_cmd = br_afspec_cmd_to_rtm(cmd);
581
efa5356b 582 if (vinfo_curr->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
8f4cc940 583 if (!br_vlan_valid_range(vinfo_curr, *vinfo_last, extack))
efa5356b
RP		 584 return -EINVAL;
585 *vinfo_last = vinfo_curr;
efa5356b
RP		 586 return 0;
587 }
588
589 if (*vinfo_last) {
590 struct bridge_vlan_info tmp_vinfo;
f545923b 591 int v, v_change_start = 0;
efa5356b 592
8f4cc940 593 if (!br_vlan_valid_range(vinfo_curr, *vinfo_last, extack))
efa5356b
RP		 594 return -EINVAL;
595
596 memcpy(&tmp_vinfo, *vinfo_last,
597 sizeof(struct bridge_vlan_info));
598 for (v = (*vinfo_last)->vid; v <= vinfo_curr->vid; v++) {
f545923b
NA		 599 bool curr_change = false;
600
efa5356b 601 tmp_vinfo.vid = v;
f545923b 602 err = br_vlan_info(br, p, cmd, &tmp_vinfo, &curr_change,
169327d5 603 extack);
efa5356b
RP		 604 if (err)
605 break;
f545923b
NA		 606 if (curr_change) {
607 *changed = curr_change;
608 if (!v_change_start)
609 v_change_start = v;
610 } else {
611 /* nothing to notify yet */
612 if (!v_change_start)
613 continue;
614 br_vlan_notify(br, p, v_change_start,
615 v - 1, rtm_cmd);
616 v_change_start = 0;
617 }
efa5356b 618 }
f545923b
NA		 619 /* v_change_start is set only if the last/whole range changed */
620 if (v_change_start)
621 br_vlan_notify(br, p, v_change_start,
622 v - 1, rtm_cmd);
623
efa5356b
RP		 624 *vinfo_last = NULL;
625
66c54517 626 return err;
efa5356b
RP		 627 }
628
f545923b
NA		 629 err = br_vlan_info(br, p, cmd, vinfo_curr, changed, extack);
630 if (*changed)
631 br_vlan_notify(br, p, vinfo_curr->vid, 0, rtm_cmd);
632
633 return err;
efa5356b
RP		 634}
635
407af329
VY		 636static int br_afspec(struct net_bridge *br,
637 struct net_bridge_port *p,
638 struct nlattr *af_spec,
169327d5
PM		 639 int cmd, bool *changed,
640 struct netlink_ext_ack *extack)
407af329 641{
efa5356b
RP		 642 struct bridge_vlan_info *vinfo_curr = NULL;
643 struct bridge_vlan_info *vinfo_last = NULL;
bdced7ef 644 struct nlattr *attr;
efa5356b
RP		 645 struct vtunnel_info tinfo_last = {};
646 struct vtunnel_info tinfo_curr = {};
647 int err = 0, rem;
407af329 648
bdced7ef 649 nla_for_each_nested(attr, af_spec, rem) {
efa5356b
RP		 650 err = 0;
651 switch (nla_type(attr)) {
652 case IFLA_BRIDGE_VLAN_TUNNEL_INFO:
1020ce31 653 if (!p || !(p->flags & BR_VLAN_TUNNEL))
bdced7ef 654 return -EINVAL;
efa5356b
RP		 655 err = br_parse_vlan_tunnel_info(attr, &tinfo_curr);
656 if (err)
657 return err;
658 err = br_process_vlan_tunnel_info(br, p, cmd,
659 &tinfo_curr,
e19b42a1
NA		 660 &tinfo_last,
661 changed);
efa5356b
RP		 662 if (err)
663 return err;
664 break;
665 case IFLA_BRIDGE_VLAN_INFO:
666 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
6623c60d 667 return -EINVAL;
efa5356b
RP		 668 vinfo_curr = nla_data(attr);
669 err = br_process_vlan_info(br, p, cmd, vinfo_curr,
169327d5
PM		 670 &vinfo_last, changed,
671 extack);
efa5356b
RP		 672 if (err)
673 return err;
674 break;
65369933
HV		 675 case IFLA_BRIDGE_MRP:
676 err = br_mrp_parse(br, p, attr, cmd, extack);
677 if (err)
678 return err;
679 break;
bdced7ef 680 }
407af329
VY		 681 }
682
683 return err;
684}
685
3ac636b8 686static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
25c71c75 687 [IFLA_BRPORT_STATE] = { .type = NLA_U8 },
688 [IFLA_BRPORT_COST] = { .type = NLA_U32 },
689 [IFLA_BRPORT_PRIORITY] = { .type = NLA_U16 },
690 [IFLA_BRPORT_MODE] = { .type = NLA_U8 },
a2e01a65 691 [IFLA_BRPORT_GUARD] = { .type = NLA_U8 },
1007dd1a 692 [IFLA_BRPORT_PROTECT] = { .type = NLA_U8 },
6f705d8c 693 [IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
9ba18891 694 [IFLA_BRPORT_LEARNING] = { .type = NLA_U8 },
867a5943 695 [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
355b9f9d 696 [IFLA_BRPORT_PROXYARP] = { .type = NLA_U8 },
786c2077 697 [IFLA_BRPORT_PROXYARP_WIFI] = { .type = NLA_U8 },
5d6ae479 698 [IFLA_BRPORT_MULTICAST_ROUTER] = { .type = NLA_U8 },
6db6f0ea 699 [IFLA_BRPORT_MCAST_TO_UCAST] = { .type = NLA_U8 },
9051247d
TK		 700 [IFLA_BRPORT_MCAST_FLOOD] = { .type = NLA_U8 },
701 [IFLA_BRPORT_BCAST_FLOOD] = { .type = NLA_U8 },
fbec443b 702 [IFLA_BRPORT_VLAN_TUNNEL] = { .type = NLA_U8 },
5af48b59 703 [IFLA_BRPORT_GROUP_FWD_MASK] = { .type = NLA_U16 },
1a3fbd3f 704 [IFLA_BRPORT_NEIGH_SUPPRESS] = { .type = NLA_U8 },
7d850abd 705 [IFLA_BRPORT_ISOLATED] = { .type = NLA_U8 },
2756f68c 706 [IFLA_BRPORT_BACKUP_PORT] = { .type = NLA_U32 },
25c71c75 707};
708
709/* Change the state of the port and notify spanning tree */
710static int br_set_port_state(struct net_bridge_port *p, u8 state)
711{
712 if (state > BR_STATE_BLOCKING)
713 return -EINVAL;
714
715 /* if kernel STP is running, don't allow changes */
716 if (p->br->stp_enabled == BR_KERNEL_STP)
717 return -EBUSY;
718
576eb625 719 /* if device is not up, change is not allowed
720 * if link is not present, only allowable state is disabled
721 */
25c71c75 722 if (!netif_running(p->dev) ||
576eb625 723 (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
25c71c75 724 return -ENETDOWN;
725
775dd692 726 br_set_state(p, state);
25c71c75 727 br_port_state_selection(p->br);
728 return 0;
729}
730
731/* Set/clear or port flags based on attribute */
3922285d
AS		 732static int br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
733 int attrtype, unsigned long mask)
25c71c75 734{
3922285d
AS		 735 unsigned long flags;
736 int err;
737
738 if (!tb[attrtype])
739 return 0;
740
741 if (nla_get_u8(tb[attrtype]))
742 flags = p->flags | mask;
743 else
744 flags = p->flags & ~mask;
745
746 err = br_switchdev_set_port_flag(p, flags, mask);
747 if (err)
748 return err;
749
750 p->flags = flags;
751 return 0;
25c71c75 752}
753
754/* Process bridge protocol info on port */
755static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
756{
e028e4b8 757 unsigned long old_flags = p->flags;
efa5356b
RP		 758 bool br_vlan_tunnel_old = false;
759 int err;
25c71c75 760
3922285d
AS		 761 err = br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
762 if (err)
763 return err;
764
765 err = br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
766 if (err)
767 return err;
768
769 err = br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
770 if (err)
771 return err;
772
773 err = br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
774 if (err)
775 return err;
776
777 err = br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
778 if (err)
779 return err;
780
781 err = br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
782 if (err)
783 return err;
784
785 err = br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD);
786 if (err)
787 return err;
788
789 err = br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_TO_UCAST, BR_MULTICAST_TO_UNICAST);
790 if (err)
791 return err;
792
793 err = br_set_port_flag(p, tb, IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD);
794 if (err)
795 return err;
796
797 err = br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
798 if (err)
799 return err;
800
801 err = br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);
802 if (err)
803 return err;
25c71c75 804
efa5356b 805 br_vlan_tunnel_old = (p->flags & BR_VLAN_TUNNEL) ? true : false;
3922285d
AS		 806 err = br_set_port_flag(p, tb, IFLA_BRPORT_VLAN_TUNNEL, BR_VLAN_TUNNEL);
807 if (err)
808 return err;
809
efa5356b
RP		 810 if (br_vlan_tunnel_old && !(p->flags & BR_VLAN_TUNNEL))
811 nbp_vlan_tunnel_info_flush(p);
812
25c71c75 813 if (tb[IFLA_BRPORT_COST]) {
814 err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
815 if (err)
816 return err;
817 }
818
819 if (tb[IFLA_BRPORT_PRIORITY]) {
820 err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
821 if (err)
822 return err;
823 }
824
825 if (tb[IFLA_BRPORT_STATE]) {
826 err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
827 if (err)
828 return err;
829 }
e028e4b8 830
9b0c6e4d
NA		 831 if (tb[IFLA_BRPORT_FLUSH])
832 br_fdb_delete_by_port(p->br, p, 0, 0);
833
5d6ae479
NA		 834#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
835 if (tb[IFLA_BRPORT_MULTICAST_ROUTER]) {
836 u8 mcast_router = nla_get_u8(tb[IFLA_BRPORT_MULTICAST_ROUTER]);
837
838 err = br_multicast_set_port_router(p, mcast_router);
839 if (err)
840 return err;
841 }
842#endif
5af48b59
NA		 843
844 if (tb[IFLA_BRPORT_GROUP_FWD_MASK]) {
845 u16 fwd_mask = nla_get_u16(tb[IFLA_BRPORT_GROUP_FWD_MASK]);
846
847 if (fwd_mask & BR_GROUPFWD_MACPAUSE)
848 return -EINVAL;
849 p->group_fwd_mask = fwd_mask;
850 }
851
821f1b21
RP		 852 err = br_set_port_flag(p, tb, IFLA_BRPORT_NEIGH_SUPPRESS,
853 BR_NEIGH_SUPPRESS);
854 if (err)
855 return err;
856
7d850abd
NA		 857 err = br_set_port_flag(p, tb, IFLA_BRPORT_ISOLATED, BR_ISOLATED);
858 if (err)
859 return err;
860
2756f68c
NA		 861 if (tb[IFLA_BRPORT_BACKUP_PORT]) {
862 struct net_device *backup_dev = NULL;
863 u32 backup_ifindex;
864
865 backup_ifindex = nla_get_u32(tb[IFLA_BRPORT_BACKUP_PORT]);
866 if (backup_ifindex) {
867 backup_dev = __dev_get_by_index(dev_net(p->dev),
868 backup_ifindex);
869 if (!backup_dev)
870 return -ENOENT;
871 }
872
873 err = nbp_backup_change(p, backup_dev);
874 if (err)
875 return err;
876 }
877
e028e4b8 878 br_port_flags_change(p, old_flags ^ p->flags);
25c71c75 879 return 0;
880}
881
882/* Change state and parameters on port. */
2fd527b7
PM		 883int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags,
884 struct netlink_ext_ack *extack)
11dc1f36 885{
92899063
NA		 886 struct net_bridge *br = (struct net_bridge *)netdev_priv(dev);
887 struct nlattr *tb[IFLA_BRPORT_MAX + 1];
888 struct net_bridge_port *p;
74685962 889 struct nlattr *protinfo;
407af329 890 struct nlattr *afspec;
e19b42a1 891 bool changed = false;
41c498b9 892 int err = 0;
11dc1f36 893
c60ee67f
H		 894 protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
895 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
407af329 896 if (!protinfo && !afspec)
25c71c75 897 return 0;
11dc1f36 898
ec1e5610 899 p = br_port_get_rtnl(dev);
407af329 900 /* We want to accept dev as bridge itself if the AF_SPEC
8e3bff96 901 * is set to see if someone is setting vlan info on the bridge
407af329 902 */
7b99a993 903 if (!p && !afspec)
b5ed54e9 904 return -EINVAL;
11dc1f36 905
407af329
VY		 906 if (p && protinfo) {
907 if (protinfo->nla_type & NLA_F_NESTED) {
8cb08174
JB		 908 err = nla_parse_nested_deprecated(tb, IFLA_BRPORT_MAX,
909 protinfo,
910 br_port_policy,
911 NULL);
407af329
VY		 912 if (err)
913 return err;
914
915 spin_lock_bh(&p->br->lock);
916 err = br_setport(p, tb);
917 spin_unlock_bh(&p->br->lock);
918 } else {
8e3bff96 919 /* Binary compatibility with old RSTP */
407af329
VY		 920 if (nla_len(protinfo) < sizeof(u8))
921 return -EINVAL;
922
923 spin_lock_bh(&p->br->lock);
924 err = br_set_port_state(p, nla_get_u8(protinfo));
925 spin_unlock_bh(&p->br->lock);
926 }
25c71c75 927 if (err)
407af329 928 goto out;
e19b42a1 929 changed = true;
407af329 930 }
11dc1f36 931
92899063 932 if (afspec)
169327d5 933 err = br_afspec(br, p, afspec, RTM_SETLINK, &changed, extack);
b03b6dd5 934
e19b42a1 935 if (changed)
92899063 936 br_ifinfo_notify(RTM_NEWLINK, br, p);
407af329 937out:
25c71c75 938 return err;
11dc1f36
SH		 939}
940
407af329 941/* Delete port information */
add511b3 942int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
407af329 943{
92899063 944 struct net_bridge *br = (struct net_bridge *)netdev_priv(dev);
407af329 945 struct net_bridge_port *p;
92899063 946 struct nlattr *afspec;
e19b42a1 947 bool changed = false;
8508025c 948 int err = 0;
407af329 949
c60ee67f 950 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
407af329
VY		 951 if (!afspec)
952 return 0;
953
954 p = br_port_get_rtnl(dev);
955 /* We want to accept dev as bridge itself as well */
956 if (!p && !(dev->priv_flags & IFF_EBRIDGE))
957 return -EINVAL;
958
169327d5 959 err = br_afspec(br, p, afspec, RTM_DELLINK, &changed, NULL);
e19b42a1 960 if (changed)
02dba438
RP		 961 /* Send RTM_NEWLINK because userspace
962 * expects RTM_NEWLINK for vlan dels
963 */
92899063 964 br_ifinfo_notify(RTM_NEWLINK, br, p);
407af329
VY		 965
966 return err;
967}
a8b8a889
MS		 968
969static int br_validate(struct nlattr *tb[], struct nlattr *data[],
970 struct netlink_ext_ack *extack)
bb900b27 971{
972 if (tb[IFLA_ADDRESS]) {
973 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
974 return -EINVAL;
975 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
976 return -EADDRNOTAVAIL;
977 }
978
d2d427b3
TM		 979 if (!data)
980 return 0;
981
982#ifdef CONFIG_BRIDGE_VLAN_FILTERING
983 if (data[IFLA_BR_VLAN_PROTOCOL]) {
984 switch (nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL])) {
985 case htons(ETH_P_8021Q):
986 case htons(ETH_P_8021AD):
987 break;
988 default:
989 return -EPROTONOSUPPORT;
990 }
991 }
a2858602
TJ		 992
993 if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
994 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
995
996 if (defpvid >= VLAN_VID_MASK)
997 return -EINVAL;
998 }
d2d427b3
TM		 999#endif
1000
bb900b27 1001 return 0;
1002}
1003
3ac636b8
JP		 1004static int br_port_slave_changelink(struct net_device *brdev,
1005 struct net_device *dev,
1006 struct nlattr *tb[],
17dd0ec4
MS		 1007 struct nlattr *data[],
1008 struct netlink_ext_ack *extack)
3ac636b8 1009{
963ad948
NA		 1010 struct net_bridge *br = netdev_priv(brdev);
1011 int ret;
1012
3ac636b8
JP		 1013 if (!data)
1014 return 0;
963ad948
NA		 1015
1016 spin_lock_bh(&br->lock);
1017 ret = br_setport(br_port_get_rtnl(dev), data);
1018 spin_unlock_bh(&br->lock);
1019
1020 return ret;
3ac636b8
JP		 1021}
1022
ced8283f
JP		 1023static int br_port_fill_slave_info(struct sk_buff *skb,
1024 const struct net_device *brdev,
1025 const struct net_device *dev)
1026{
1027 return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
1028}
1029
1030static size_t br_port_get_slave_size(const struct net_device *brdev,
1031 const struct net_device *dev)
1032{
1033 return br_port_info_size();
1034}
1035
13323516
JP		 1036static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
1037 [IFLA_BR_FORWARD_DELAY] = { .type = NLA_U32 },
1038 [IFLA_BR_HELLO_TIME] = { .type = NLA_U32 },
1039 [IFLA_BR_MAX_AGE] = { .type = NLA_U32 },
af615762
JT		 1040 [IFLA_BR_AGEING_TIME] = { .type = NLA_U32 },
1041 [IFLA_BR_STP_STATE] = { .type = NLA_U32 },
1042 [IFLA_BR_PRIORITY] = { .type = NLA_U16 },
a7854037 1043 [IFLA_BR_VLAN_FILTERING] = { .type = NLA_U8 },
d2d427b3 1044 [IFLA_BR_VLAN_PROTOCOL] = { .type = NLA_U16 },
7910228b 1045 [IFLA_BR_GROUP_FWD_MASK] = { .type = NLA_U16 },
111189ab
NA		 1046 [IFLA_BR_GROUP_ADDR] = { .type = NLA_BINARY,
1047 .len = ETH_ALEN },
a9a6bc70 1048 [IFLA_BR_MCAST_ROUTER] = { .type = NLA_U8 },
89126327 1049 [IFLA_BR_MCAST_SNOOPING] = { .type = NLA_U8 },
295141d9 1050 [IFLA_BR_MCAST_QUERY_USE_IFADDR] = { .type = NLA_U8 },
ba062d7c 1051 [IFLA_BR_MCAST_QUERIER] = { .type = NLA_U8 },
431db3c0 1052 [IFLA_BR_MCAST_HASH_ELASTICITY] = { .type = NLA_U32 },
858079fd 1053 [IFLA_BR_MCAST_HASH_MAX] = { .type = NLA_U32 },
79b859f5 1054 [IFLA_BR_MCAST_LAST_MEMBER_CNT] = { .type = NLA_U32 },
b89e6bab 1055 [IFLA_BR_MCAST_STARTUP_QUERY_CNT] = { .type = NLA_U32 },
7e4df51e
NA		 1056 [IFLA_BR_MCAST_LAST_MEMBER_INTVL] = { .type = NLA_U64 },
1057 [IFLA_BR_MCAST_MEMBERSHIP_INTVL] = { .type = NLA_U64 },
1058 [IFLA_BR_MCAST_QUERIER_INTVL] = { .type = NLA_U64 },
1059 [IFLA_BR_MCAST_QUERY_INTVL] = { .type = NLA_U64 },
1060 [IFLA_BR_MCAST_QUERY_RESPONSE_INTVL] = { .type = NLA_U64 },
1061 [IFLA_BR_MCAST_STARTUP_QUERY_INTVL] = { .type = NLA_U64 },
93870cc0
NA		 1062 [IFLA_BR_NF_CALL_IPTABLES] = { .type = NLA_U8 },
1063 [IFLA_BR_NF_CALL_IP6TABLES] = { .type = NLA_U8 },
1064 [IFLA_BR_NF_CALL_ARPTABLES] = { .type = NLA_U8 },
0f963b75 1065 [IFLA_BR_VLAN_DEFAULT_PVID] = { .type = NLA_U16 },
6dada9b1 1066 [IFLA_BR_VLAN_STATS_ENABLED] = { .type = NLA_U8 },
1080ab95 1067 [IFLA_BR_MCAST_STATS_ENABLED] = { .type = NLA_U8 },
5e923585 1068 [IFLA_BR_MCAST_IGMP_VERSION] = { .type = NLA_U8 },
aa2ae3e7 1069 [IFLA_BR_MCAST_MLD_VERSION] = { .type = NLA_U8 },
9163a0fc 1070 [IFLA_BR_VLAN_STATS_PER_PORT] = { .type = NLA_U8 },
a428afe8
NA		 1071 [IFLA_BR_MULTI_BOOLOPT] = { .type = NLA_EXACT_LEN,
1072 .len = sizeof(struct br_boolopt_multi) },
13323516
JP		 1073};
1074
1075static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
ad744b22
MS		 1076 struct nlattr *data[],
1077 struct netlink_ext_ack *extack)
13323516
JP		 1078{
1079 struct net_bridge *br = netdev_priv(brdev);
1080 int err;
1081
1082 if (!data)
1083 return 0;
1084
1085 if (data[IFLA_BR_FORWARD_DELAY]) {
1086 err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
1087 if (err)
1088 return err;
1089 }
1090
1091 if (data[IFLA_BR_HELLO_TIME]) {
1092 err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
1093 if (err)
1094 return err;
1095 }
1096
1097 if (data[IFLA_BR_MAX_AGE]) {
1098 err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
1099 if (err)
1100 return err;
1101 }
1102
af615762 1103 if (data[IFLA_BR_AGEING_TIME]) {
c62987bb
SF		 1104 err = br_set_ageing_time(br, nla_get_u32(data[IFLA_BR_AGEING_TIME]));
1105 if (err)
1106 return err;
af615762
JT		 1107 }
1108
1109 if (data[IFLA_BR_STP_STATE]) {
1110 u32 stp_enabled = nla_get_u32(data[IFLA_BR_STP_STATE]);
1111
1112 br_stp_set_enabled(br, stp_enabled);
1113 }
1114
1115 if (data[IFLA_BR_PRIORITY]) {
1116 u32 priority = nla_get_u16(data[IFLA_BR_PRIORITY]);
1117
1118 br_stp_set_bridge_priority(br, priority);
1119 }
1120
a7854037
NA		 1121 if (data[IFLA_BR_VLAN_FILTERING]) {
1122 u8 vlan_filter = nla_get_u8(data[IFLA_BR_VLAN_FILTERING]);
1123
1124 err = __br_vlan_filter_toggle(br, vlan_filter);
1125 if (err)
1126 return err;
1127 }
1128
d2d427b3
TM		 1129#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1130 if (data[IFLA_BR_VLAN_PROTOCOL]) {
1131 __be16 vlan_proto = nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL]);
1132
1133 err = __br_vlan_set_proto(br, vlan_proto);
1134 if (err)
1135 return err;
1136 }
0f963b75
NA		 1137
1138 if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
1139 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
1140
169327d5 1141 err = __br_vlan_set_default_pvid(br, defpvid, extack);
0f963b75
NA		 1142 if (err)
1143 return err;
1144 }
6dada9b1
NA		 1145
1146 if (data[IFLA_BR_VLAN_STATS_ENABLED]) {
1147 __u8 vlan_stats = nla_get_u8(data[IFLA_BR_VLAN_STATS_ENABLED]);
1148
1149 err = br_vlan_set_stats(br, vlan_stats);
1150 if (err)
1151 return err;
1152 }
9163a0fc
NA		 1153
1154 if (data[IFLA_BR_VLAN_STATS_PER_PORT]) {
1155 __u8 per_port = nla_get_u8(data[IFLA_BR_VLAN_STATS_PER_PORT]);
1156
1157 err = br_vlan_set_stats_per_port(br, per_port);
1158 if (err)
1159 return err;
1160 }
d2d427b3
TM		 1161#endif
1162
7910228b
NA		 1163 if (data[IFLA_BR_GROUP_FWD_MASK]) {
1164 u16 fwd_mask = nla_get_u16(data[IFLA_BR_GROUP_FWD_MASK]);
1165
1166 if (fwd_mask & BR_GROUPFWD_RESTRICTED)
1167 return -EINVAL;
1168 br->group_fwd_mask = fwd_mask;
1169 }
1170
111189ab
NA		 1171 if (data[IFLA_BR_GROUP_ADDR]) {
1172 u8 new_addr[ETH_ALEN];
1173
1174 if (nla_len(data[IFLA_BR_GROUP_ADDR]) != ETH_ALEN)
1175 return -EINVAL;
1176 memcpy(new_addr, nla_data(data[IFLA_BR_GROUP_ADDR]), ETH_ALEN);
1177 if (!is_link_local_ether_addr(new_addr))
1178 return -EINVAL;
1179 if (new_addr[5] == 1 || /* 802.3x Pause address */
1180 new_addr[5] == 2 || /* 802.3ad Slow protocols */
1181 new_addr[5] == 3) /* 802.1X PAE address */
1182 return -EINVAL;
1183 spin_lock_bh(&br->lock);
1184 memcpy(br->group_addr, new_addr, sizeof(br->group_addr));
1185 spin_unlock_bh(&br->lock);
be3664a0 1186 br_opt_toggle(br, BROPT_GROUP_ADDR_SET, true);
111189ab
NA		 1187 br_recalculate_fwd_mask(br);
1188 }
1189
150217c6
NA		 1190 if (data[IFLA_BR_FDB_FLUSH])
1191 br_fdb_flush(br);
1192
a9a6bc70
NA		 1193#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1194 if (data[IFLA_BR_MCAST_ROUTER]) {
1195 u8 multicast_router = nla_get_u8(data[IFLA_BR_MCAST_ROUTER]);
1196
1197 err = br_multicast_set_router(br, multicast_router);
1198 if (err)
1199 return err;
1200 }
89126327
NA		 1201
1202 if (data[IFLA_BR_MCAST_SNOOPING]) {
1203 u8 mcast_snooping = nla_get_u8(data[IFLA_BR_MCAST_SNOOPING]);
1204
a26d94bf 1205 br_multicast_toggle(br, mcast_snooping);
89126327 1206 }
295141d9
NA		 1207
1208 if (data[IFLA_BR_MCAST_QUERY_USE_IFADDR]) {
1209 u8 val;
1210
1211 val = nla_get_u8(data[IFLA_BR_MCAST_QUERY_USE_IFADDR]);
675779ad 1212 br_opt_toggle(br, BROPT_MULTICAST_QUERY_USE_IFADDR, !!val);
295141d9 1213 }
ba062d7c
NA		 1214
1215 if (data[IFLA_BR_MCAST_QUERIER]) {
1216 u8 mcast_querier = nla_get_u8(data[IFLA_BR_MCAST_QUERIER]);
1217
1218 err = br_multicast_set_querier(br, mcast_querier);
1219 if (err)
1220 return err;
1221 }
431db3c0 1222
cf332bca
NA		 1223 if (data[IFLA_BR_MCAST_HASH_ELASTICITY])
1224 br_warn(br, "the hash_elasticity option has been deprecated and is always %u\n",
1225 RHT_ELASTICITY);
858079fd 1226
19e3a9c9
NA		 1227 if (data[IFLA_BR_MCAST_HASH_MAX])
1228 br->hash_max = nla_get_u32(data[IFLA_BR_MCAST_HASH_MAX]);
79b859f5
NA		 1229
1230 if (data[IFLA_BR_MCAST_LAST_MEMBER_CNT]) {
1231 u32 val = nla_get_u32(data[IFLA_BR_MCAST_LAST_MEMBER_CNT]);
1232
1233 br->multicast_last_member_count = val;
1234 }
b89e6bab
NA		 1235
1236 if (data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]) {
1237 u32 val = nla_get_u32(data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]);
1238
1239 br->multicast_startup_query_count = val;
1240 }
7e4df51e
NA		 1241
1242 if (data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]) {
1243 u64 val = nla_get_u64(data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]);
1244
1245 br->multicast_last_member_interval = clock_t_to_jiffies(val);
1246 }
1247
1248 if (data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]) {
1249 u64 val = nla_get_u64(data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]);
1250
1251 br->multicast_membership_interval = clock_t_to_jiffies(val);
1252 }
1253
1254 if (data[IFLA_BR_MCAST_QUERIER_INTVL]) {
1255 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERIER_INTVL]);
1256
1257 br->multicast_querier_interval = clock_t_to_jiffies(val);
1258 }
1259
1260 if (data[IFLA_BR_MCAST_QUERY_INTVL]) {
1261 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_INTVL]);
1262
1263 br->multicast_query_interval = clock_t_to_jiffies(val);
1264 }
1265
1266 if (data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]) {
1267 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]);
1268
1269 br->multicast_query_response_interval = clock_t_to_jiffies(val);
1270 }
1271
1272 if (data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]) {
1273 u64 val = nla_get_u64(data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]);
1274
1275 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
1276 }
1080ab95
NA		 1277
1278 if (data[IFLA_BR_MCAST_STATS_ENABLED]) {
1279 __u8 mcast_stats;
1280
1281 mcast_stats = nla_get_u8(data[IFLA_BR_MCAST_STATS_ENABLED]);
675779ad 1282 br_opt_toggle(br, BROPT_MULTICAST_STATS_ENABLED, !!mcast_stats);
1080ab95 1283 }
5e923585
NA		 1284
1285 if (data[IFLA_BR_MCAST_IGMP_VERSION]) {
1286 __u8 igmp_version;
1287
1288 igmp_version = nla_get_u8(data[IFLA_BR_MCAST_IGMP_VERSION]);
1289 err = br_multicast_set_igmp_version(br, igmp_version);
1290 if (err)
1291 return err;
1292 }
aa2ae3e7
NA		 1293
1294#if IS_ENABLED(CONFIG_IPV6)
1295 if (data[IFLA_BR_MCAST_MLD_VERSION]) {
1296 __u8 mld_version;
1297
1298 mld_version = nla_get_u8(data[IFLA_BR_MCAST_MLD_VERSION]);
1299 err = br_multicast_set_mld_version(br, mld_version);
1300 if (err)
1301 return err;
1302 }
1303#endif
a9a6bc70 1304#endif
93870cc0
NA		 1305#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1306 if (data[IFLA_BR_NF_CALL_IPTABLES]) {
1307 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IPTABLES]);
1308
8df3510f 1309 br_opt_toggle(br, BROPT_NF_CALL_IPTABLES, !!val);
93870cc0
NA		 1310 }
1311
1312 if (data[IFLA_BR_NF_CALL_IP6TABLES]) {
1313 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IP6TABLES]);
1314
8df3510f 1315 br_opt_toggle(br, BROPT_NF_CALL_IP6TABLES, !!val);
93870cc0
NA		 1316 }
1317
1318 if (data[IFLA_BR_NF_CALL_ARPTABLES]) {
1319 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_ARPTABLES]);
1320
8df3510f 1321 br_opt_toggle(br, BROPT_NF_CALL_ARPTABLES, !!val);
93870cc0
NA		 1322 }
1323#endif
a9a6bc70 1324
a428afe8
NA		 1325 if (data[IFLA_BR_MULTI_BOOLOPT]) {
1326 struct br_boolopt_multi *bm;
1327
1328 bm = nla_data(data[IFLA_BR_MULTI_BOOLOPT]);
1329 err = br_boolopt_multi_toggle(br, bm, extack);
1330 if (err)
1331 return err;
1332 }
1333
13323516
JP		 1334 return 0;
1335}
1336
b6677449 1337static int br_dev_newlink(struct net *src_net, struct net_device *dev,
7a3f4a18
MS		 1338 struct nlattr *tb[], struct nlattr *data[],
1339 struct netlink_ext_ack *extack)
b6677449
IV		 1340{
1341 struct net_bridge *br = netdev_priv(dev);
1342 int err;
1343
84aeb437
NA		 1344 err = register_netdevice(dev);
1345 if (err)
1346 return err;
1347
b6677449
IV		 1348 if (tb[IFLA_ADDRESS]) {
1349 spin_lock_bh(&br->lock);
1350 br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
1351 spin_unlock_bh(&br->lock);
1352 }
1353
ad744b22 1354 err = br_changelink(dev, tb, data, extack);
5b8d5429 1355 if (err)
84aeb437
NA		 1356 br_dev_delete(dev, NULL);
1357
5b8d5429 1358 return err;
b6677449
IV		 1359}
1360
e5c3ea5c
JP		 1361static size_t br_get_size(const struct net_device *brdev)
1362{
1363 return nla_total_size(sizeof(u32)) + /* IFLA_BR_FORWARD_DELAY */
1364 nla_total_size(sizeof(u32)) + /* IFLA_BR_HELLO_TIME */
1365 nla_total_size(sizeof(u32)) + /* IFLA_BR_MAX_AGE */
af615762
JT		 1366 nla_total_size(sizeof(u32)) + /* IFLA_BR_AGEING_TIME */
1367 nla_total_size(sizeof(u32)) + /* IFLA_BR_STP_STATE */
1368 nla_total_size(sizeof(u16)) + /* IFLA_BR_PRIORITY */
a7854037 1369 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_FILTERING */
d2d427b3
TM		 1370#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1371 nla_total_size(sizeof(__be16)) + /* IFLA_BR_VLAN_PROTOCOL */
0f963b75 1372 nla_total_size(sizeof(u16)) + /* IFLA_BR_VLAN_DEFAULT_PVID */
6dada9b1 1373 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_STATS_ENABLED */
9163a0fc 1374 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_STATS_PER_PORT */
d2d427b3 1375#endif
7910228b 1376 nla_total_size(sizeof(u16)) + /* IFLA_BR_GROUP_FWD_MASK */
5127c81f 1377 nla_total_size(sizeof(struct ifla_bridge_id)) + /* IFLA_BR_ROOT_ID */
7599a220 1378 nla_total_size(sizeof(struct ifla_bridge_id)) + /* IFLA_BR_BRIDGE_ID */
8762ba68 1379 nla_total_size(sizeof(u16)) + /* IFLA_BR_ROOT_PORT */
684dd248 1380 nla_total_size(sizeof(u32)) + /* IFLA_BR_ROOT_PATH_COST */
b89e6bab
NA		 1381 nla_total_size(sizeof(u8)) + /* IFLA_BR_TOPOLOGY_CHANGE */
1382 nla_total_size(sizeof(u8)) + /* IFLA_BR_TOPOLOGY_CHANGE_DETECTED */
12a0faa3
ND		 1383 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_HELLO_TIMER */
1384 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TCN_TIMER */
1385 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TOPOLOGY_CHANGE_TIMER */
1386 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_GC_TIMER */
111189ab 1387 nla_total_size(ETH_ALEN) + /* IFLA_BR_GROUP_ADDR */
a9a6bc70
NA		 1388#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1389 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_ROUTER */
89126327 1390 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_SNOOPING */
295141d9 1391 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_QUERY_USE_IFADDR */
ba062d7c 1392 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_QUERIER */
1080ab95 1393 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_STATS_ENABLED */
b89e6bab
NA		 1394 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_HASH_ELASTICITY */
1395 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_HASH_MAX */
1396 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_LAST_MEMBER_CNT */
1397 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_STARTUP_QUERY_CNT */
12a0faa3
ND		 1398 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_LAST_MEMBER_INTVL */
1399 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_MEMBERSHIP_INTVL */
1400 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERIER_INTVL */
1401 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_INTVL */
1402 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_RESPONSE_INTVL */
1403 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_STARTUP_QUERY_INTVL */
5e923585 1404 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_IGMP_VERSION */
aa2ae3e7 1405 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_MLD_VERSION */
93870cc0
NA		 1406#endif
1407#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1408 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_IPTABLES */
1409 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_IP6TABLES */
1410 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_ARPTABLES */
a9a6bc70 1411#endif
a428afe8 1412 nla_total_size(sizeof(struct br_boolopt_multi)) + /* IFLA_BR_MULTI_BOOLOPT */
e5c3ea5c
JP		 1413 0;
1414}
1415
1416static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
1417{
1418 struct net_bridge *br = netdev_priv(brdev);
1419 u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
1420 u32 hello_time = jiffies_to_clock_t(br->hello_time);
1421 u32 age_time = jiffies_to_clock_t(br->max_age);
af615762
JT		 1422 u32 ageing_time = jiffies_to_clock_t(br->ageing_time);
1423 u32 stp_enabled = br->stp_enabled;
1424 u16 priority = (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1];
1f51445a 1425 u8 vlan_enabled = br_vlan_enabled(br->dev);
a428afe8 1426 struct br_boolopt_multi bm;
4917a154
NA		 1427 u64 clockval;
1428
1429 clockval = br_timer_value(&br->hello_timer);
12a0faa3 1430 if (nla_put_u64_64bit(skb, IFLA_BR_HELLO_TIMER, clockval, IFLA_BR_PAD))
4917a154
NA		 1431 return -EMSGSIZE;
1432 clockval = br_timer_value(&br->tcn_timer);
12a0faa3 1433 if (nla_put_u64_64bit(skb, IFLA_BR_TCN_TIMER, clockval, IFLA_BR_PAD))
4917a154
NA		 1434 return -EMSGSIZE;
1435 clockval = br_timer_value(&br->topology_change_timer);
12a0faa3
ND		 1436 if (nla_put_u64_64bit(skb, IFLA_BR_TOPOLOGY_CHANGE_TIMER, clockval,
1437 IFLA_BR_PAD))
4917a154 1438 return -EMSGSIZE;
f7cdee8a 1439 clockval = br_timer_value(&br->gc_work.timer);
12a0faa3 1440 if (nla_put_u64_64bit(skb, IFLA_BR_GC_TIMER, clockval, IFLA_BR_PAD))
4917a154 1441 return -EMSGSIZE;
e5c3ea5c 1442
a428afe8 1443 br_boolopt_multi_get(br, &bm);
e5c3ea5c
JP		 1444 if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
1445 nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
af615762
JT		 1446 nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time) ||
1447 nla_put_u32(skb, IFLA_BR_AGEING_TIME, ageing_time) ||
1448 nla_put_u32(skb, IFLA_BR_STP_STATE, stp_enabled) ||
a7854037 1449 nla_put_u16(skb, IFLA_BR_PRIORITY, priority) ||
7910228b 1450 nla_put_u8(skb, IFLA_BR_VLAN_FILTERING, vlan_enabled) ||
4917a154
NA		 1451 nla_put_u16(skb, IFLA_BR_GROUP_FWD_MASK, br->group_fwd_mask) ||
1452 nla_put(skb, IFLA_BR_BRIDGE_ID, sizeof(struct ifla_bridge_id),
1453 &br->bridge_id) ||
1454 nla_put(skb, IFLA_BR_ROOT_ID, sizeof(struct ifla_bridge_id),
1455 &br->designated_root) ||
684dd248 1456 nla_put_u16(skb, IFLA_BR_ROOT_PORT, br->root_port) ||
ed416309
NA		 1457 nla_put_u32(skb, IFLA_BR_ROOT_PATH_COST, br->root_path_cost) ||
1458 nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE, br->topology_change) ||
1459 nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
d76bd14e 1460 br->topology_change_detected) ||
a428afe8
NA		 1461 nla_put(skb, IFLA_BR_GROUP_ADDR, ETH_ALEN, br->group_addr) ||
1462 nla_put(skb, IFLA_BR_MULTI_BOOLOPT, sizeof(bm), &bm))
e5c3ea5c
JP		 1463 return -EMSGSIZE;
1464
d2d427b3 1465#ifdef CONFIG_BRIDGE_VLAN_FILTERING
0f963b75 1466 if (nla_put_be16(skb, IFLA_BR_VLAN_PROTOCOL, br->vlan_proto) ||
6dada9b1 1467 nla_put_u16(skb, IFLA_BR_VLAN_DEFAULT_PVID, br->default_pvid) ||
ae75767e 1468 nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED,
9163a0fc
NA		 1469 br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) ||
1470 nla_put_u8(skb, IFLA_BR_VLAN_STATS_PER_PORT,
600bea7d 1471 br_opt_get(br, BROPT_VLAN_STATS_PER_PORT)))
d2d427b3
TM		 1472 return -EMSGSIZE;
1473#endif
a9a6bc70 1474#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
89126327 1475 if (nla_put_u8(skb, IFLA_BR_MCAST_ROUTER, br->multicast_router) ||
13cefad2
NA		 1476 nla_put_u8(skb, IFLA_BR_MCAST_SNOOPING,
1477 br_opt_get(br, BROPT_MULTICAST_ENABLED)) ||
295141d9 1478 nla_put_u8(skb, IFLA_BR_MCAST_QUERY_USE_IFADDR,
675779ad
NA		 1479 br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR)) ||
1480 nla_put_u8(skb, IFLA_BR_MCAST_QUERIER,
1481 br_opt_get(br, BROPT_MULTICAST_QUERIER)) ||
1080ab95 1482 nla_put_u8(skb, IFLA_BR_MCAST_STATS_ENABLED,
675779ad 1483 br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) ||
cf332bca 1484 nla_put_u32(skb, IFLA_BR_MCAST_HASH_ELASTICITY, RHT_ELASTICITY) ||
79b859f5
NA		 1485 nla_put_u32(skb, IFLA_BR_MCAST_HASH_MAX, br->hash_max) ||
1486 nla_put_u32(skb, IFLA_BR_MCAST_LAST_MEMBER_CNT,
b89e6bab
NA		 1487 br->multicast_last_member_count) ||
1488 nla_put_u32(skb, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
5e923585
NA		 1489 br->multicast_startup_query_count) ||
1490 nla_put_u8(skb, IFLA_BR_MCAST_IGMP_VERSION,
1491 br->multicast_igmp_version))
a9a6bc70 1492 return -EMSGSIZE;
aa2ae3e7
NA		 1493#if IS_ENABLED(CONFIG_IPV6)
1494 if (nla_put_u8(skb, IFLA_BR_MCAST_MLD_VERSION,
1495 br->multicast_mld_version))
1496 return -EMSGSIZE;
1497#endif
7e4df51e 1498 clockval = jiffies_to_clock_t(br->multicast_last_member_interval);
12a0faa3
ND		 1499 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_LAST_MEMBER_INTVL, clockval,
1500 IFLA_BR_PAD))
7e4df51e
NA		 1501 return -EMSGSIZE;
1502 clockval = jiffies_to_clock_t(br->multicast_membership_interval);
12a0faa3
ND		 1503 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_MEMBERSHIP_INTVL, clockval,
1504 IFLA_BR_PAD))
7e4df51e
NA		 1505 return -EMSGSIZE;
1506 clockval = jiffies_to_clock_t(br->multicast_querier_interval);
12a0faa3
ND		 1507 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERIER_INTVL, clockval,
1508 IFLA_BR_PAD))
7e4df51e
NA		 1509 return -EMSGSIZE;
1510 clockval = jiffies_to_clock_t(br->multicast_query_interval);
12a0faa3
ND		 1511 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_INTVL, clockval,
1512 IFLA_BR_PAD))
7e4df51e
NA		 1513 return -EMSGSIZE;
1514 clockval = jiffies_to_clock_t(br->multicast_query_response_interval);
12a0faa3
ND		 1515 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, clockval,
1516 IFLA_BR_PAD))
7e4df51e
NA		 1517 return -EMSGSIZE;
1518 clockval = jiffies_to_clock_t(br->multicast_startup_query_interval);
12a0faa3
ND		 1519 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_STARTUP_QUERY_INTVL, clockval,
1520 IFLA_BR_PAD))
7e4df51e 1521 return -EMSGSIZE;
a9a6bc70 1522#endif
93870cc0
NA		 1523#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1524 if (nla_put_u8(skb, IFLA_BR_NF_CALL_IPTABLES,
8df3510f 1525 br_opt_get(br, BROPT_NF_CALL_IPTABLES) ? 1 : 0) ||
93870cc0 1526 nla_put_u8(skb, IFLA_BR_NF_CALL_IP6TABLES,
8df3510f 1527 br_opt_get(br, BROPT_NF_CALL_IP6TABLES) ? 1 : 0) ||
93870cc0 1528 nla_put_u8(skb, IFLA_BR_NF_CALL_ARPTABLES,
8df3510f 1529 br_opt_get(br, BROPT_NF_CALL_ARPTABLES) ? 1 : 0))
93870cc0
NA		 1530 return -EMSGSIZE;
1531#endif
a9a6bc70 1532
e5c3ea5c
JP		 1533 return 0;
1534}
1535
d5ff8c41 1536static size_t br_get_linkxstats_size(const struct net_device *dev, int attr)
a60c0903 1537{
d5ff8c41 1538 struct net_bridge_port *p = NULL;
a60c0903
NA		 1539 struct net_bridge_vlan_group *vg;
1540 struct net_bridge_vlan *v;
d5ff8c41 1541 struct net_bridge *br;
a60c0903
NA		 1542 int numvls = 0;
1543
d5ff8c41
NA		 1544 switch (attr) {
1545 case IFLA_STATS_LINK_XSTATS:
1546 br = netdev_priv(dev);
1547 vg = br_vlan_group(br);
1548 break;
1549 case IFLA_STATS_LINK_XSTATS_SLAVE:
1550 p = br_port_get_rtnl(dev);
1551 if (!p)
1552 return 0;
1553 br = p->br;
1554 vg = nbp_vlan_group(p);
1555 break;
1556 default:
1557 return 0;
1558 }
1559
1080ab95
NA		 1560 if (vg) {
1561 /* we need to count all, even placeholder entries */
1562 list_for_each_entry(v, &vg->vlan_list, vlist)
1563 numvls++;
1564 }
a60c0903 1565
a60c0903 1566 return numvls * nla_total_size(sizeof(struct bridge_vlan_xstats)) +
1080ab95 1567 nla_total_size(sizeof(struct br_mcast_stats)) +
a60c0903
NA		 1568 nla_total_size(0);
1569}
1570
d5ff8c41
NA		 1571static int br_fill_linkxstats(struct sk_buff *skb,
1572 const struct net_device *dev,
1573 int *prividx, int attr)
80e73cc5 1574{
d5ff8c41
NA		 1575 struct nlattr *nla __maybe_unused;
1576 struct net_bridge_port *p = NULL;
1577 struct net_bridge_vlan_group *vg;
1578 struct net_bridge_vlan *v;
1579 struct net_bridge *br;
1580 struct nlattr *nest;
1581 int vl_idx = 0;
80e73cc5
NA		 1582
1583 switch (attr) {
1584 case IFLA_STATS_LINK_XSTATS:
d5ff8c41
NA		 1585 br = netdev_priv(dev);
1586 vg = br_vlan_group(br);
80e73cc5
NA		 1587 break;
1588 case IFLA_STATS_LINK_XSTATS_SLAVE:
d5ff8c41
NA		 1589 p = br_port_get_rtnl(dev);
1590 if (!p)
1591 return 0;
1592 br = p->br;
1593 vg = nbp_vlan_group(p);
80e73cc5 1594 break;
d5ff8c41
NA		 1595 default:
1596 return -EINVAL;
80e73cc5
NA		 1597 }
1598
ae0be8de 1599 nest = nla_nest_start_noflag(skb, LINK_XSTATS_TYPE_BRIDGE);
a60c0903
NA		 1600 if (!nest)
1601 return -EMSGSIZE;
a60c0903 1602
1080ab95 1603 if (vg) {
72f4af4e
NA		 1604 u16 pvid;
1605
1606 pvid = br_get_pvid(vg);
1080ab95
NA		 1607 list_for_each_entry(v, &vg->vlan_list, vlist) {
1608 struct bridge_vlan_xstats vxi;
1609 struct br_vlan_stats stats;
1610
1611 if (++vl_idx < *prividx)
1612 continue;
1613 memset(&vxi, 0, sizeof(vxi));
1614 vxi.vid = v->vid;
61ba1a2d 1615 vxi.flags = v->flags;
72f4af4e
NA		 1616 if (v->vid == pvid)
1617 vxi.flags |= BRIDGE_VLAN_INFO_PVID;
1080ab95
NA		 1618 br_vlan_get_stats(v, &stats);
1619 vxi.rx_bytes = stats.rx_bytes;
1620 vxi.rx_packets = stats.rx_packets;
1621 vxi.tx_bytes = stats.tx_bytes;
1622 vxi.tx_packets = stats.tx_packets;
1623
1624 if (nla_put(skb, BRIDGE_XSTATS_VLAN, sizeof(vxi), &vxi))
1625 goto nla_put_failure;
1626 }
1627 }
1628
1629#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1630 if (++vl_idx >= *prividx) {
1631 nla = nla_reserve_64bit(skb, BRIDGE_XSTATS_MCAST,
1632 sizeof(struct br_mcast_stats),
1633 BRIDGE_XSTATS_PAD);
1634 if (!nla)
a60c0903 1635 goto nla_put_failure;
d5ff8c41 1636 br_multicast_get_stats(br, p, nla_data(nla));
a60c0903 1637 }
1080ab95 1638#endif
de179966
VD		 1639
1640 if (p) {
1641 nla = nla_reserve_64bit(skb, BRIDGE_XSTATS_STP,
1642 sizeof(p->stp_xstats),
1643 BRIDGE_XSTATS_PAD);
1644 if (!nla)
1645 goto nla_put_failure;
1646
1647 spin_lock_bh(&br->lock);
1648 memcpy(nla_data(nla), &p->stp_xstats, sizeof(p->stp_xstats));
1649 spin_unlock_bh(&br->lock);
1650 }
1651
a60c0903
NA		 1652 nla_nest_end(skb, nest);
1653 *prividx = 0;
1080ab95 1654
a60c0903
NA		 1655 return 0;
1656
1657nla_put_failure:
1658 nla_nest_end(skb, nest);
1659 *prividx = vl_idx;
1660
1661 return -EMSGSIZE;
1662}
fed0a159 1663
207895fd 1664static struct rtnl_af_ops br_af_ops __read_mostly = {
6cbdceeb 1665 .family = AF_BRIDGE,
b1974ed0 1666 .get_link_af_size = br_get_link_af_size_filtered,
6cbdceeb
VY		 1667};
1668
149ddd83 1669struct rtnl_link_ops br_link_ops __read_mostly = {
ced8283f
JP		 1670 .kind = "bridge",
1671 .priv_size = sizeof(struct net_bridge),
1672 .setup = br_dev_setup,
eb4cb851 1673 .maxtype = IFLA_BR_MAX,
13323516 1674 .policy = br_policy,
ced8283f
JP		 1675 .validate = br_validate,
1676 .newlink = br_dev_newlink,
13323516 1677 .changelink = br_changelink,
ced8283f 1678 .dellink = br_dev_delete,
e5c3ea5c
JP		 1679 .get_size = br_get_size,
1680 .fill_info = br_fill_info,
a60c0903
NA		 1681 .fill_linkxstats = br_fill_linkxstats,
1682 .get_linkxstats_size = br_get_linkxstats_size,
3ac636b8
JP		 1683
1684 .slave_maxtype = IFLA_BRPORT_MAX,
1685 .slave_policy = br_port_policy,
1686 .slave_changelink = br_port_slave_changelink,
ced8283f
JP		 1687 .get_slave_size = br_port_get_slave_size,
1688 .fill_slave_info = br_port_fill_slave_info,
bb900b27 1689};
11dc1f36 1690
32fe21c0 1691int __init br_netlink_init(void)
11dc1f36 1692{
3ec8e9f0
VY		 1693 int err;
1694
1695 br_mdb_init();
8dcea187 1696 br_vlan_rtnl_init();
3678a9d8 1697 rtnl_af_register(&br_af_ops);
3ec8e9f0 1698
6cbdceeb
VY		 1699 err = rtnl_link_register(&br_link_ops);
1700 if (err)
1701 goto out_af;
1702
3ec8e9f0 1703 return 0;
6cbdceeb
VY		 1704
1705out_af:
1706 rtnl_af_unregister(&br_af_ops);
3ec8e9f0
VY		 1707 br_mdb_uninit();
1708 return err;
11dc1f36
SH		 1709}
1710
34666d46 1711void br_netlink_fini(void)
11dc1f36 1712{
3ec8e9f0 1713 br_mdb_uninit();
8dcea187 1714 br_vlan_rtnl_uninit();
6cbdceeb 1715 rtnl_af_unregister(&br_af_ops);
bb900b27 1716 rtnl_link_unregister(&br_link_ops);
11dc1f36 1717}
Linux 6.x block layer and io_uring tree(s)