xref: /openbmc/linux/net/bridge/br_netlink.c (revision 4f205687)
1 /*
2  *	Bridge netlink control interface
3  *
4  *	Authors:
5  *	Stephen Hemminger		<shemminger@osdl.org>
6  *
7  *	This program is free software; you can redistribute it and/or
8  *	modify it under the terms of the GNU General Public License
9  *	as published by the Free Software Foundation; either version
10  *	2 of the License, or (at your option) any later version.
11  */
12 
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/etherdevice.h>
16 #include <net/rtnetlink.h>
17 #include <net/net_namespace.h>
18 #include <net/sock.h>
19 #include <uapi/linux/if_bridge.h>
20 
21 #include "br_private.h"
22 #include "br_private_stp.h"
23 
24 static int __get_num_vlan_infos(struct net_bridge_vlan_group *vg,
25 				u32 filter_mask)
26 {
27 	struct net_bridge_vlan *v;
28 	u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
29 	u16 flags, pvid;
30 	int num_vlans = 0;
31 
32 	if (!(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
33 		return 0;
34 
35 	pvid = br_get_pvid(vg);
36 	/* Count number of vlan infos */
37 	list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
38 		flags = 0;
39 		/* only a context, bridge vlan not activated */
40 		if (!br_vlan_should_use(v))
41 			continue;
42 		if (v->vid == pvid)
43 			flags |= BRIDGE_VLAN_INFO_PVID;
44 
45 		if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
46 			flags |= BRIDGE_VLAN_INFO_UNTAGGED;
47 
48 		if (vid_range_start == 0) {
49 			goto initvars;
50 		} else if ((v->vid - vid_range_end) == 1 &&
51 			flags == vid_range_flags) {
52 			vid_range_end = v->vid;
53 			continue;
54 		} else {
55 			if ((vid_range_end - vid_range_start) > 0)
56 				num_vlans += 2;
57 			else
58 				num_vlans += 1;
59 		}
60 initvars:
61 		vid_range_start = v->vid;
62 		vid_range_end = v->vid;
63 		vid_range_flags = flags;
64 	}
65 
66 	if (vid_range_start != 0) {
67 		if ((vid_range_end - vid_range_start) > 0)
68 			num_vlans += 2;
69 		else
70 			num_vlans += 1;
71 	}
72 
73 	return num_vlans;
74 }
75 
76 static int br_get_num_vlan_infos(struct net_bridge_vlan_group *vg,
77 				 u32 filter_mask)
78 {
79 	int num_vlans;
80 
81 	if (!vg)
82 		return 0;
83 
84 	if (filter_mask & RTEXT_FILTER_BRVLAN)
85 		return vg->num_vlans;
86 
87 	rcu_read_lock();
88 	num_vlans = __get_num_vlan_infos(vg, filter_mask);
89 	rcu_read_unlock();
90 
91 	return num_vlans;
92 }
93 
94 static size_t br_get_link_af_size_filtered(const struct net_device *dev,
95 					   u32 filter_mask)
96 {
97 	struct net_bridge_vlan_group *vg = NULL;
98 	struct net_bridge_port *p;
99 	struct net_bridge *br;
100 	int num_vlan_infos;
101 
102 	rcu_read_lock();
103 	if (br_port_exists(dev)) {
104 		p = br_port_get_rcu(dev);
105 		vg = nbp_vlan_group_rcu(p);
106 	} else if (dev->priv_flags & IFF_EBRIDGE) {
107 		br = netdev_priv(dev);
108 		vg = br_vlan_group_rcu(br);
109 	}
110 	num_vlan_infos = br_get_num_vlan_infos(vg, filter_mask);
111 	rcu_read_unlock();
112 
113 	/* Each VLAN is returned in bridge_vlan_info along with flags */
114 	return num_vlan_infos * nla_total_size(sizeof(struct bridge_vlan_info));
115 }
116 
117 static inline size_t br_port_info_size(void)
118 {
119 	return nla_total_size(1)	/* IFLA_BRPORT_STATE  */
120 		+ nla_total_size(2)	/* IFLA_BRPORT_PRIORITY */
121 		+ nla_total_size(4)	/* IFLA_BRPORT_COST */
122 		+ nla_total_size(1)	/* IFLA_BRPORT_MODE */
123 		+ nla_total_size(1)	/* IFLA_BRPORT_GUARD */
124 		+ nla_total_size(1)	/* IFLA_BRPORT_PROTECT */
125 		+ nla_total_size(1)	/* IFLA_BRPORT_FAST_LEAVE */
126 		+ nla_total_size(1)	/* IFLA_BRPORT_LEARNING */
127 		+ nla_total_size(1)	/* IFLA_BRPORT_UNICAST_FLOOD */
128 		+ nla_total_size(1)	/* IFLA_BRPORT_PROXYARP */
129 		+ nla_total_size(1)	/* IFLA_BRPORT_PROXYARP_WIFI */
130 		+ nla_total_size(sizeof(struct ifla_bridge_id))	/* IFLA_BRPORT_ROOT_ID */
131 		+ nla_total_size(sizeof(struct ifla_bridge_id))	/* IFLA_BRPORT_BRIDGE_ID */
132 		+ nla_total_size(sizeof(u16))	/* IFLA_BRPORT_DESIGNATED_PORT */
133 		+ nla_total_size(sizeof(u16))	/* IFLA_BRPORT_DESIGNATED_COST */
134 		+ nla_total_size(sizeof(u16))	/* IFLA_BRPORT_ID */
135 		+ nla_total_size(sizeof(u16))	/* IFLA_BRPORT_NO */
136 		+ nla_total_size(sizeof(u8))	/* IFLA_BRPORT_TOPOLOGY_CHANGE_ACK */
137 		+ nla_total_size(sizeof(u8))	/* IFLA_BRPORT_CONFIG_PENDING */
138 		+ nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_MESSAGE_AGE_TIMER */
139 		+ nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_FORWARD_DELAY_TIMER */
140 		+ nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_HOLD_TIMER */
141 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
142 		+ nla_total_size(sizeof(u8))	/* IFLA_BRPORT_MULTICAST_ROUTER */
143 #endif
144 		+ 0;
145 }
146 
147 static inline size_t br_nlmsg_size(struct net_device *dev, u32 filter_mask)
148 {
149 	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
150 		+ nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
151 		+ nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
152 		+ nla_total_size(4) /* IFLA_MASTER */
153 		+ nla_total_size(4) /* IFLA_MTU */
154 		+ nla_total_size(4) /* IFLA_LINK */
155 		+ nla_total_size(1) /* IFLA_OPERSTATE */
156 		+ nla_total_size(br_port_info_size()) /* IFLA_PROTINFO */
157 		+ nla_total_size(br_get_link_af_size_filtered(dev,
158 				 filter_mask)); /* IFLA_AF_SPEC */
159 }
160 
161 static int br_port_fill_attrs(struct sk_buff *skb,
162 			      const struct net_bridge_port *p)
163 {
164 	u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
165 	u64 timerval;
166 
167 	if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
168 	    nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
169 	    nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
170 	    nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
171 	    nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
172 	    nla_put_u8(skb, IFLA_BRPORT_PROTECT, !!(p->flags & BR_ROOT_BLOCK)) ||
173 	    nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE, !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
174 	    nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
175 	    nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD, !!(p->flags & BR_FLOOD)) ||
176 	    nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)) ||
177 	    nla_put_u8(skb, IFLA_BRPORT_PROXYARP_WIFI,
178 		       !!(p->flags & BR_PROXYARP_WIFI)) ||
179 	    nla_put(skb, IFLA_BRPORT_ROOT_ID, sizeof(struct ifla_bridge_id),
180 		    &p->designated_root) ||
181 	    nla_put(skb, IFLA_BRPORT_BRIDGE_ID, sizeof(struct ifla_bridge_id),
182 		    &p->designated_bridge) ||
183 	    nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_PORT, p->designated_port) ||
184 	    nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_COST, p->designated_cost) ||
185 	    nla_put_u16(skb, IFLA_BRPORT_ID, p->port_id) ||
186 	    nla_put_u16(skb, IFLA_BRPORT_NO, p->port_no) ||
187 	    nla_put_u8(skb, IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
188 		       p->topology_change_ack) ||
189 	    nla_put_u8(skb, IFLA_BRPORT_CONFIG_PENDING, p->config_pending))
190 		return -EMSGSIZE;
191 
192 	timerval = br_timer_value(&p->message_age_timer);
193 	if (nla_put_u64_64bit(skb, IFLA_BRPORT_MESSAGE_AGE_TIMER, timerval,
194 			      IFLA_BRPORT_PAD))
195 		return -EMSGSIZE;
196 	timerval = br_timer_value(&p->forward_delay_timer);
197 	if (nla_put_u64_64bit(skb, IFLA_BRPORT_FORWARD_DELAY_TIMER, timerval,
198 			      IFLA_BRPORT_PAD))
199 		return -EMSGSIZE;
200 	timerval = br_timer_value(&p->hold_timer);
201 	if (nla_put_u64_64bit(skb, IFLA_BRPORT_HOLD_TIMER, timerval,
202 			      IFLA_BRPORT_PAD))
203 		return -EMSGSIZE;
204 
205 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
206 	if (nla_put_u8(skb, IFLA_BRPORT_MULTICAST_ROUTER,
207 		       p->multicast_router))
208 		return -EMSGSIZE;
209 #endif
210 
211 	return 0;
212 }
213 
214 static int br_fill_ifvlaninfo_range(struct sk_buff *skb, u16 vid_start,
215 				    u16 vid_end, u16 flags)
216 {
217 	struct  bridge_vlan_info vinfo;
218 
219 	if ((vid_end - vid_start) > 0) {
220 		/* add range to skb */
221 		vinfo.vid = vid_start;
222 		vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_BEGIN;
223 		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
224 			    sizeof(vinfo), &vinfo))
225 			goto nla_put_failure;
226 
227 		vinfo.vid = vid_end;
228 		vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_END;
229 		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
230 			    sizeof(vinfo), &vinfo))
231 			goto nla_put_failure;
232 	} else {
233 		vinfo.vid = vid_start;
234 		vinfo.flags = flags;
235 		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
236 			    sizeof(vinfo), &vinfo))
237 			goto nla_put_failure;
238 	}
239 
240 	return 0;
241 
242 nla_put_failure:
243 	return -EMSGSIZE;
244 }
245 
246 static int br_fill_ifvlaninfo_compressed(struct sk_buff *skb,
247 					 struct net_bridge_vlan_group *vg)
248 {
249 	struct net_bridge_vlan *v;
250 	u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
251 	u16 flags, pvid;
252 	int err = 0;
253 
254 	/* Pack IFLA_BRIDGE_VLAN_INFO's for every vlan
255 	 * and mark vlan info with begin and end flags
256 	 * if vlaninfo represents a range
257 	 */
258 	pvid = br_get_pvid(vg);
259 	list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
260 		flags = 0;
261 		if (!br_vlan_should_use(v))
262 			continue;
263 		if (v->vid == pvid)
264 			flags |= BRIDGE_VLAN_INFO_PVID;
265 
266 		if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
267 			flags |= BRIDGE_VLAN_INFO_UNTAGGED;
268 
269 		if (vid_range_start == 0) {
270 			goto initvars;
271 		} else if ((v->vid - vid_range_end) == 1 &&
272 			flags == vid_range_flags) {
273 			vid_range_end = v->vid;
274 			continue;
275 		} else {
276 			err = br_fill_ifvlaninfo_range(skb, vid_range_start,
277 						       vid_range_end,
278 						       vid_range_flags);
279 			if (err)
280 				return err;
281 		}
282 
283 initvars:
284 		vid_range_start = v->vid;
285 		vid_range_end = v->vid;
286 		vid_range_flags = flags;
287 	}
288 
289 	if (vid_range_start != 0) {
290 		/* Call it once more to send any left over vlans */
291 		err = br_fill_ifvlaninfo_range(skb, vid_range_start,
292 					       vid_range_end,
293 					       vid_range_flags);
294 		if (err)
295 			return err;
296 	}
297 
298 	return 0;
299 }
300 
301 static int br_fill_ifvlaninfo(struct sk_buff *skb,
302 			      struct net_bridge_vlan_group *vg)
303 {
304 	struct bridge_vlan_info vinfo;
305 	struct net_bridge_vlan *v;
306 	u16 pvid;
307 
308 	pvid = br_get_pvid(vg);
309 	list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
310 		if (!br_vlan_should_use(v))
311 			continue;
312 
313 		vinfo.vid = v->vid;
314 		vinfo.flags = 0;
315 		if (v->vid == pvid)
316 			vinfo.flags |= BRIDGE_VLAN_INFO_PVID;
317 
318 		if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
319 			vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
320 
321 		if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
322 			    sizeof(vinfo), &vinfo))
323 			goto nla_put_failure;
324 	}
325 
326 	return 0;
327 
328 nla_put_failure:
329 	return -EMSGSIZE;
330 }
331 
332 /*
333  * Create one netlink message for one interface
334  * Contains port and master info as well as carrier and bridge state.
335  */
336 static int br_fill_ifinfo(struct sk_buff *skb,
337 			  struct net_bridge_port *port,
338 			  u32 pid, u32 seq, int event, unsigned int flags,
339 			  u32 filter_mask, const struct net_device *dev)
340 {
341 	struct net_bridge *br;
342 	struct ifinfomsg *hdr;
343 	struct nlmsghdr *nlh;
344 	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
345 
346 	if (port)
347 		br = port->br;
348 	else
349 		br = netdev_priv(dev);
350 
351 	br_debug(br, "br_fill_info event %d port %s master %s\n",
352 		     event, dev->name, br->dev->name);
353 
354 	nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
355 	if (nlh == NULL)
356 		return -EMSGSIZE;
357 
358 	hdr = nlmsg_data(nlh);
359 	hdr->ifi_family = AF_BRIDGE;
360 	hdr->__ifi_pad = 0;
361 	hdr->ifi_type = dev->type;
362 	hdr->ifi_index = dev->ifindex;
363 	hdr->ifi_flags = dev_get_flags(dev);
364 	hdr->ifi_change = 0;
365 
366 	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
367 	    nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
368 	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
369 	    nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
370 	    (dev->addr_len &&
371 	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
372 	    (dev->ifindex != dev_get_iflink(dev) &&
373 	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
374 		goto nla_put_failure;
375 
376 	if (event == RTM_NEWLINK && port) {
377 		struct nlattr *nest
378 			= nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
379 
380 		if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
381 			goto nla_put_failure;
382 		nla_nest_end(skb, nest);
383 	}
384 
385 	/* Check if  the VID information is requested */
386 	if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
387 	    (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
388 		struct net_bridge_vlan_group *vg;
389 		struct nlattr *af;
390 		int err;
391 
392 		/* RCU needed because of the VLAN locking rules (rcu || rtnl) */
393 		rcu_read_lock();
394 		if (port)
395 			vg = nbp_vlan_group_rcu(port);
396 		else
397 			vg = br_vlan_group_rcu(br);
398 
399 		if (!vg || !vg->num_vlans) {
400 			rcu_read_unlock();
401 			goto done;
402 		}
403 		af = nla_nest_start(skb, IFLA_AF_SPEC);
404 		if (!af) {
405 			rcu_read_unlock();
406 			goto nla_put_failure;
407 		}
408 		if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
409 			err = br_fill_ifvlaninfo_compressed(skb, vg);
410 		else
411 			err = br_fill_ifvlaninfo(skb, vg);
412 		rcu_read_unlock();
413 		if (err)
414 			goto nla_put_failure;
415 		nla_nest_end(skb, af);
416 	}
417 
418 done:
419 	nlmsg_end(skb, nlh);
420 	return 0;
421 
422 nla_put_failure:
423 	nlmsg_cancel(skb, nlh);
424 	return -EMSGSIZE;
425 }
426 
427 /*
428  * Notify listeners of a change in port information
429  */
430 void br_ifinfo_notify(int event, struct net_bridge_port *port)
431 {
432 	struct net *net;
433 	struct sk_buff *skb;
434 	int err = -ENOBUFS;
435 	u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;
436 
437 	if (!port)
438 		return;
439 
440 	net = dev_net(port->dev);
441 	br_debug(port->br, "port %u(%s) event %d\n",
442 		 (unsigned int)port->port_no, port->dev->name, event);
443 
444 	skb = nlmsg_new(br_nlmsg_size(port->dev, filter), GFP_ATOMIC);
445 	if (skb == NULL)
446 		goto errout;
447 
448 	err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, port->dev);
449 	if (err < 0) {
450 		/* -EMSGSIZE implies BUG in br_nlmsg_size() */
451 		WARN_ON(err == -EMSGSIZE);
452 		kfree_skb(skb);
453 		goto errout;
454 	}
455 	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
456 	return;
457 errout:
458 	rtnl_set_sk_err(net, RTNLGRP_LINK, err);
459 }
460 
461 
462 /*
463  * Dump information about all ports, in response to GETLINK
464  */
465 int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
466 	       struct net_device *dev, u32 filter_mask, int nlflags)
467 {
468 	struct net_bridge_port *port = br_port_get_rtnl(dev);
469 
470 	if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
471 	    !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
472 		return 0;
473 
474 	return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, nlflags,
475 			      filter_mask, dev);
476 }
477 
478 static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
479 			int cmd, struct bridge_vlan_info *vinfo)
480 {
481 	int err = 0;
482 
483 	switch (cmd) {
484 	case RTM_SETLINK:
485 		if (p) {
486 			/* if the MASTER flag is set this will act on the global
487 			 * per-VLAN entry as well
488 			 */
489 			err = nbp_vlan_add(p, vinfo->vid, vinfo->flags);
490 			if (err)
491 				break;
492 		} else {
493 			vinfo->flags |= BRIDGE_VLAN_INFO_BRENTRY;
494 			err = br_vlan_add(br, vinfo->vid, vinfo->flags);
495 		}
496 		break;
497 
498 	case RTM_DELLINK:
499 		if (p) {
500 			nbp_vlan_delete(p, vinfo->vid);
501 			if (vinfo->flags & BRIDGE_VLAN_INFO_MASTER)
502 				br_vlan_delete(p->br, vinfo->vid);
503 		} else {
504 			br_vlan_delete(br, vinfo->vid);
505 		}
506 		break;
507 	}
508 
509 	return err;
510 }
511 
512 static int br_afspec(struct net_bridge *br,
513 		     struct net_bridge_port *p,
514 		     struct nlattr *af_spec,
515 		     int cmd)
516 {
517 	struct bridge_vlan_info *vinfo_start = NULL;
518 	struct bridge_vlan_info *vinfo = NULL;
519 	struct nlattr *attr;
520 	int err = 0;
521 	int rem;
522 
523 	nla_for_each_nested(attr, af_spec, rem) {
524 		if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
525 			continue;
526 		if (nla_len(attr) != sizeof(struct bridge_vlan_info))
527 			return -EINVAL;
528 		vinfo = nla_data(attr);
529 		if (!vinfo->vid || vinfo->vid >= VLAN_VID_MASK)
530 			return -EINVAL;
531 		if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
532 			if (vinfo_start)
533 				return -EINVAL;
534 			vinfo_start = vinfo;
535 			/* don't allow range of pvids */
536 			if (vinfo_start->flags & BRIDGE_VLAN_INFO_PVID)
537 				return -EINVAL;
538 			continue;
539 		}
540 
541 		if (vinfo_start) {
542 			struct bridge_vlan_info tmp_vinfo;
543 			int v;
544 
545 			if (!(vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END))
546 				return -EINVAL;
547 
548 			if (vinfo->vid <= vinfo_start->vid)
549 				return -EINVAL;
550 
551 			memcpy(&tmp_vinfo, vinfo_start,
552 			       sizeof(struct bridge_vlan_info));
553 
554 			for (v = vinfo_start->vid; v <= vinfo->vid; v++) {
555 				tmp_vinfo.vid = v;
556 				err = br_vlan_info(br, p, cmd, &tmp_vinfo);
557 				if (err)
558 					break;
559 			}
560 			vinfo_start = NULL;
561 		} else {
562 			err = br_vlan_info(br, p, cmd, vinfo);
563 		}
564 		if (err)
565 			break;
566 	}
567 
568 	return err;
569 }
570 
571 static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
572 	[IFLA_BRPORT_STATE]	= { .type = NLA_U8 },
573 	[IFLA_BRPORT_COST]	= { .type = NLA_U32 },
574 	[IFLA_BRPORT_PRIORITY]	= { .type = NLA_U16 },
575 	[IFLA_BRPORT_MODE]	= { .type = NLA_U8 },
576 	[IFLA_BRPORT_GUARD]	= { .type = NLA_U8 },
577 	[IFLA_BRPORT_PROTECT]	= { .type = NLA_U8 },
578 	[IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
579 	[IFLA_BRPORT_LEARNING]	= { .type = NLA_U8 },
580 	[IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
581 	[IFLA_BRPORT_PROXYARP]	= { .type = NLA_U8 },
582 	[IFLA_BRPORT_PROXYARP_WIFI] = { .type = NLA_U8 },
583 	[IFLA_BRPORT_MULTICAST_ROUTER] = { .type = NLA_U8 },
584 };
585 
586 /* Change the state of the port and notify spanning tree */
587 static int br_set_port_state(struct net_bridge_port *p, u8 state)
588 {
589 	if (state > BR_STATE_BLOCKING)
590 		return -EINVAL;
591 
592 	/* if kernel STP is running, don't allow changes */
593 	if (p->br->stp_enabled == BR_KERNEL_STP)
594 		return -EBUSY;
595 
596 	/* if device is not up, change is not allowed
597 	 * if link is not present, only allowable state is disabled
598 	 */
599 	if (!netif_running(p->dev) ||
600 	    (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
601 		return -ENETDOWN;
602 
603 	br_set_state(p, state);
604 	br_port_state_selection(p->br);
605 	return 0;
606 }
607 
608 /* Set/clear or port flags based on attribute */
609 static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
610 			   int attrtype, unsigned long mask)
611 {
612 	if (tb[attrtype]) {
613 		u8 flag = nla_get_u8(tb[attrtype]);
614 		if (flag)
615 			p->flags |= mask;
616 		else
617 			p->flags &= ~mask;
618 	}
619 }
620 
621 /* Process bridge protocol info on port */
622 static int br_setport(struct net_bridge_port *p, struct nlattr *tb[])
623 {
624 	int err;
625 	unsigned long old_flags = p->flags;
626 
627 	br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
628 	br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
629 	br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE, BR_MULTICAST_FAST_LEAVE);
630 	br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
631 	br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
632 	br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
633 	br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
634 	br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);
635 
636 	if (tb[IFLA_BRPORT_COST]) {
637 		err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
638 		if (err)
639 			return err;
640 	}
641 
642 	if (tb[IFLA_BRPORT_PRIORITY]) {
643 		err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
644 		if (err)
645 			return err;
646 	}
647 
648 	if (tb[IFLA_BRPORT_STATE]) {
649 		err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
650 		if (err)
651 			return err;
652 	}
653 
654 	if (tb[IFLA_BRPORT_FLUSH])
655 		br_fdb_delete_by_port(p->br, p, 0, 0);
656 
657 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
658 	if (tb[IFLA_BRPORT_MULTICAST_ROUTER]) {
659 		u8 mcast_router = nla_get_u8(tb[IFLA_BRPORT_MULTICAST_ROUTER]);
660 
661 		err = br_multicast_set_port_router(p, mcast_router);
662 		if (err)
663 			return err;
664 	}
665 #endif
666 	br_port_flags_change(p, old_flags ^ p->flags);
667 	return 0;
668 }
669 
670 /* Change state and parameters on port. */
671 int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
672 {
673 	struct nlattr *protinfo;
674 	struct nlattr *afspec;
675 	struct net_bridge_port *p;
676 	struct nlattr *tb[IFLA_BRPORT_MAX + 1];
677 	int err = 0;
678 
679 	protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
680 	afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
681 	if (!protinfo && !afspec)
682 		return 0;
683 
684 	p = br_port_get_rtnl(dev);
685 	/* We want to accept dev as bridge itself if the AF_SPEC
686 	 * is set to see if someone is setting vlan info on the bridge
687 	 */
688 	if (!p && !afspec)
689 		return -EINVAL;
690 
691 	if (p && protinfo) {
692 		if (protinfo->nla_type & NLA_F_NESTED) {
693 			err = nla_parse_nested(tb, IFLA_BRPORT_MAX,
694 					       protinfo, br_port_policy);
695 			if (err)
696 				return err;
697 
698 			spin_lock_bh(&p->br->lock);
699 			err = br_setport(p, tb);
700 			spin_unlock_bh(&p->br->lock);
701 		} else {
702 			/* Binary compatibility with old RSTP */
703 			if (nla_len(protinfo) < sizeof(u8))
704 				return -EINVAL;
705 
706 			spin_lock_bh(&p->br->lock);
707 			err = br_set_port_state(p, nla_get_u8(protinfo));
708 			spin_unlock_bh(&p->br->lock);
709 		}
710 		if (err)
711 			goto out;
712 	}
713 
714 	if (afspec) {
715 		err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
716 				afspec, RTM_SETLINK);
717 	}
718 
719 	if (err == 0)
720 		br_ifinfo_notify(RTM_NEWLINK, p);
721 out:
722 	return err;
723 }
724 
725 /* Delete port information */
726 int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
727 {
728 	struct nlattr *afspec;
729 	struct net_bridge_port *p;
730 	int err = 0;
731 
732 	afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
733 	if (!afspec)
734 		return 0;
735 
736 	p = br_port_get_rtnl(dev);
737 	/* We want to accept dev as bridge itself as well */
738 	if (!p && !(dev->priv_flags & IFF_EBRIDGE))
739 		return -EINVAL;
740 
741 	err = br_afspec((struct net_bridge *)netdev_priv(dev), p,
742 			afspec, RTM_DELLINK);
743 	if (err == 0)
744 		/* Send RTM_NEWLINK because userspace
745 		 * expects RTM_NEWLINK for vlan dels
746 		 */
747 		br_ifinfo_notify(RTM_NEWLINK, p);
748 
749 	return err;
750 }
751 static int br_validate(struct nlattr *tb[], struct nlattr *data[])
752 {
753 	if (tb[IFLA_ADDRESS]) {
754 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
755 			return -EINVAL;
756 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
757 			return -EADDRNOTAVAIL;
758 	}
759 
760 	if (!data)
761 		return 0;
762 
763 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
764 	if (data[IFLA_BR_VLAN_PROTOCOL]) {
765 		switch (nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL])) {
766 		case htons(ETH_P_8021Q):
767 		case htons(ETH_P_8021AD):
768 			break;
769 		default:
770 			return -EPROTONOSUPPORT;
771 		}
772 	}
773 #endif
774 
775 	return 0;
776 }
777 
778 static int br_dev_newlink(struct net *src_net, struct net_device *dev,
779 			  struct nlattr *tb[], struct nlattr *data[])
780 {
781 	struct net_bridge *br = netdev_priv(dev);
782 
783 	if (tb[IFLA_ADDRESS]) {
784 		spin_lock_bh(&br->lock);
785 		br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
786 		spin_unlock_bh(&br->lock);
787 	}
788 
789 	return register_netdevice(dev);
790 }
791 
792 static int br_port_slave_changelink(struct net_device *brdev,
793 				    struct net_device *dev,
794 				    struct nlattr *tb[],
795 				    struct nlattr *data[])
796 {
797 	struct net_bridge *br = netdev_priv(brdev);
798 	int ret;
799 
800 	if (!data)
801 		return 0;
802 
803 	spin_lock_bh(&br->lock);
804 	ret = br_setport(br_port_get_rtnl(dev), data);
805 	spin_unlock_bh(&br->lock);
806 
807 	return ret;
808 }
809 
810 static int br_port_fill_slave_info(struct sk_buff *skb,
811 				   const struct net_device *brdev,
812 				   const struct net_device *dev)
813 {
814 	return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
815 }
816 
817 static size_t br_port_get_slave_size(const struct net_device *brdev,
818 				     const struct net_device *dev)
819 {
820 	return br_port_info_size();
821 }
822 
823 static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
824 	[IFLA_BR_FORWARD_DELAY]	= { .type = NLA_U32 },
825 	[IFLA_BR_HELLO_TIME]	= { .type = NLA_U32 },
826 	[IFLA_BR_MAX_AGE]	= { .type = NLA_U32 },
827 	[IFLA_BR_AGEING_TIME] = { .type = NLA_U32 },
828 	[IFLA_BR_STP_STATE] = { .type = NLA_U32 },
829 	[IFLA_BR_PRIORITY] = { .type = NLA_U16 },
830 	[IFLA_BR_VLAN_FILTERING] = { .type = NLA_U8 },
831 	[IFLA_BR_VLAN_PROTOCOL] = { .type = NLA_U16 },
832 	[IFLA_BR_GROUP_FWD_MASK] = { .type = NLA_U16 },
833 	[IFLA_BR_GROUP_ADDR] = { .type = NLA_BINARY,
834 				 .len  = ETH_ALEN },
835 	[IFLA_BR_MCAST_ROUTER] = { .type = NLA_U8 },
836 	[IFLA_BR_MCAST_SNOOPING] = { .type = NLA_U8 },
837 	[IFLA_BR_MCAST_QUERY_USE_IFADDR] = { .type = NLA_U8 },
838 	[IFLA_BR_MCAST_QUERIER] = { .type = NLA_U8 },
839 	[IFLA_BR_MCAST_HASH_ELASTICITY] = { .type = NLA_U32 },
840 	[IFLA_BR_MCAST_HASH_MAX] = { .type = NLA_U32 },
841 	[IFLA_BR_MCAST_LAST_MEMBER_CNT] = { .type = NLA_U32 },
842 	[IFLA_BR_MCAST_STARTUP_QUERY_CNT] = { .type = NLA_U32 },
843 	[IFLA_BR_MCAST_LAST_MEMBER_INTVL] = { .type = NLA_U64 },
844 	[IFLA_BR_MCAST_MEMBERSHIP_INTVL] = { .type = NLA_U64 },
845 	[IFLA_BR_MCAST_QUERIER_INTVL] = { .type = NLA_U64 },
846 	[IFLA_BR_MCAST_QUERY_INTVL] = { .type = NLA_U64 },
847 	[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL] = { .type = NLA_U64 },
848 	[IFLA_BR_MCAST_STARTUP_QUERY_INTVL] = { .type = NLA_U64 },
849 	[IFLA_BR_NF_CALL_IPTABLES] = { .type = NLA_U8 },
850 	[IFLA_BR_NF_CALL_IP6TABLES] = { .type = NLA_U8 },
851 	[IFLA_BR_NF_CALL_ARPTABLES] = { .type = NLA_U8 },
852 	[IFLA_BR_VLAN_DEFAULT_PVID] = { .type = NLA_U16 },
853 	[IFLA_BR_VLAN_STATS_ENABLED] = { .type = NLA_U8 },
854 };
855 
856 static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
857 			 struct nlattr *data[])
858 {
859 	struct net_bridge *br = netdev_priv(brdev);
860 	int err;
861 
862 	if (!data)
863 		return 0;
864 
865 	if (data[IFLA_BR_FORWARD_DELAY]) {
866 		err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
867 		if (err)
868 			return err;
869 	}
870 
871 	if (data[IFLA_BR_HELLO_TIME]) {
872 		err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
873 		if (err)
874 			return err;
875 	}
876 
877 	if (data[IFLA_BR_MAX_AGE]) {
878 		err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
879 		if (err)
880 			return err;
881 	}
882 
883 	if (data[IFLA_BR_AGEING_TIME]) {
884 		err = br_set_ageing_time(br, nla_get_u32(data[IFLA_BR_AGEING_TIME]));
885 		if (err)
886 			return err;
887 	}
888 
889 	if (data[IFLA_BR_STP_STATE]) {
890 		u32 stp_enabled = nla_get_u32(data[IFLA_BR_STP_STATE]);
891 
892 		br_stp_set_enabled(br, stp_enabled);
893 	}
894 
895 	if (data[IFLA_BR_PRIORITY]) {
896 		u32 priority = nla_get_u16(data[IFLA_BR_PRIORITY]);
897 
898 		br_stp_set_bridge_priority(br, priority);
899 	}
900 
901 	if (data[IFLA_BR_VLAN_FILTERING]) {
902 		u8 vlan_filter = nla_get_u8(data[IFLA_BR_VLAN_FILTERING]);
903 
904 		err = __br_vlan_filter_toggle(br, vlan_filter);
905 		if (err)
906 			return err;
907 	}
908 
909 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
910 	if (data[IFLA_BR_VLAN_PROTOCOL]) {
911 		__be16 vlan_proto = nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL]);
912 
913 		err = __br_vlan_set_proto(br, vlan_proto);
914 		if (err)
915 			return err;
916 	}
917 
918 	if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
919 		__u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
920 
921 		err = __br_vlan_set_default_pvid(br, defpvid);
922 		if (err)
923 			return err;
924 	}
925 
926 	if (data[IFLA_BR_VLAN_STATS_ENABLED]) {
927 		__u8 vlan_stats = nla_get_u8(data[IFLA_BR_VLAN_STATS_ENABLED]);
928 
929 		err = br_vlan_set_stats(br, vlan_stats);
930 		if (err)
931 			return err;
932 	}
933 #endif
934 
935 	if (data[IFLA_BR_GROUP_FWD_MASK]) {
936 		u16 fwd_mask = nla_get_u16(data[IFLA_BR_GROUP_FWD_MASK]);
937 
938 		if (fwd_mask & BR_GROUPFWD_RESTRICTED)
939 			return -EINVAL;
940 		br->group_fwd_mask = fwd_mask;
941 	}
942 
943 	if (data[IFLA_BR_GROUP_ADDR]) {
944 		u8 new_addr[ETH_ALEN];
945 
946 		if (nla_len(data[IFLA_BR_GROUP_ADDR]) != ETH_ALEN)
947 			return -EINVAL;
948 		memcpy(new_addr, nla_data(data[IFLA_BR_GROUP_ADDR]), ETH_ALEN);
949 		if (!is_link_local_ether_addr(new_addr))
950 			return -EINVAL;
951 		if (new_addr[5] == 1 ||		/* 802.3x Pause address */
952 		    new_addr[5] == 2 ||		/* 802.3ad Slow protocols */
953 		    new_addr[5] == 3)		/* 802.1X PAE address */
954 			return -EINVAL;
955 		spin_lock_bh(&br->lock);
956 		memcpy(br->group_addr, new_addr, sizeof(br->group_addr));
957 		spin_unlock_bh(&br->lock);
958 		br->group_addr_set = true;
959 		br_recalculate_fwd_mask(br);
960 	}
961 
962 	if (data[IFLA_BR_FDB_FLUSH])
963 		br_fdb_flush(br);
964 
965 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
966 	if (data[IFLA_BR_MCAST_ROUTER]) {
967 		u8 multicast_router = nla_get_u8(data[IFLA_BR_MCAST_ROUTER]);
968 
969 		err = br_multicast_set_router(br, multicast_router);
970 		if (err)
971 			return err;
972 	}
973 
974 	if (data[IFLA_BR_MCAST_SNOOPING]) {
975 		u8 mcast_snooping = nla_get_u8(data[IFLA_BR_MCAST_SNOOPING]);
976 
977 		err = br_multicast_toggle(br, mcast_snooping);
978 		if (err)
979 			return err;
980 	}
981 
982 	if (data[IFLA_BR_MCAST_QUERY_USE_IFADDR]) {
983 		u8 val;
984 
985 		val = nla_get_u8(data[IFLA_BR_MCAST_QUERY_USE_IFADDR]);
986 		br->multicast_query_use_ifaddr = !!val;
987 	}
988 
989 	if (data[IFLA_BR_MCAST_QUERIER]) {
990 		u8 mcast_querier = nla_get_u8(data[IFLA_BR_MCAST_QUERIER]);
991 
992 		err = br_multicast_set_querier(br, mcast_querier);
993 		if (err)
994 			return err;
995 	}
996 
997 	if (data[IFLA_BR_MCAST_HASH_ELASTICITY]) {
998 		u32 val = nla_get_u32(data[IFLA_BR_MCAST_HASH_ELASTICITY]);
999 
1000 		br->hash_elasticity = val;
1001 	}
1002 
1003 	if (data[IFLA_BR_MCAST_HASH_MAX]) {
1004 		u32 hash_max = nla_get_u32(data[IFLA_BR_MCAST_HASH_MAX]);
1005 
1006 		err = br_multicast_set_hash_max(br, hash_max);
1007 		if (err)
1008 			return err;
1009 	}
1010 
1011 	if (data[IFLA_BR_MCAST_LAST_MEMBER_CNT]) {
1012 		u32 val = nla_get_u32(data[IFLA_BR_MCAST_LAST_MEMBER_CNT]);
1013 
1014 		br->multicast_last_member_count = val;
1015 	}
1016 
1017 	if (data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]) {
1018 		u32 val = nla_get_u32(data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]);
1019 
1020 		br->multicast_startup_query_count = val;
1021 	}
1022 
1023 	if (data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]) {
1024 		u64 val = nla_get_u64(data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]);
1025 
1026 		br->multicast_last_member_interval = clock_t_to_jiffies(val);
1027 	}
1028 
1029 	if (data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]) {
1030 		u64 val = nla_get_u64(data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]);
1031 
1032 		br->multicast_membership_interval = clock_t_to_jiffies(val);
1033 	}
1034 
1035 	if (data[IFLA_BR_MCAST_QUERIER_INTVL]) {
1036 		u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERIER_INTVL]);
1037 
1038 		br->multicast_querier_interval = clock_t_to_jiffies(val);
1039 	}
1040 
1041 	if (data[IFLA_BR_MCAST_QUERY_INTVL]) {
1042 		u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_INTVL]);
1043 
1044 		br->multicast_query_interval = clock_t_to_jiffies(val);
1045 	}
1046 
1047 	if (data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]) {
1048 		u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]);
1049 
1050 		br->multicast_query_response_interval = clock_t_to_jiffies(val);
1051 	}
1052 
1053 	if (data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]) {
1054 		u64 val = nla_get_u64(data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]);
1055 
1056 		br->multicast_startup_query_interval = clock_t_to_jiffies(val);
1057 	}
1058 #endif
1059 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1060 	if (data[IFLA_BR_NF_CALL_IPTABLES]) {
1061 		u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IPTABLES]);
1062 
1063 		br->nf_call_iptables = val ? true : false;
1064 	}
1065 
1066 	if (data[IFLA_BR_NF_CALL_IP6TABLES]) {
1067 		u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IP6TABLES]);
1068 
1069 		br->nf_call_ip6tables = val ? true : false;
1070 	}
1071 
1072 	if (data[IFLA_BR_NF_CALL_ARPTABLES]) {
1073 		u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_ARPTABLES]);
1074 
1075 		br->nf_call_arptables = val ? true : false;
1076 	}
1077 #endif
1078 
1079 	return 0;
1080 }
1081 
1082 static size_t br_get_size(const struct net_device *brdev)
1083 {
1084 	return nla_total_size(sizeof(u32)) +	/* IFLA_BR_FORWARD_DELAY  */
1085 	       nla_total_size(sizeof(u32)) +	/* IFLA_BR_HELLO_TIME */
1086 	       nla_total_size(sizeof(u32)) +	/* IFLA_BR_MAX_AGE */
1087 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_AGEING_TIME */
1088 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_STP_STATE */
1089 	       nla_total_size(sizeof(u16)) +    /* IFLA_BR_PRIORITY */
1090 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_VLAN_FILTERING */
1091 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
1092 	       nla_total_size(sizeof(__be16)) +	/* IFLA_BR_VLAN_PROTOCOL */
1093 	       nla_total_size(sizeof(u16)) +    /* IFLA_BR_VLAN_DEFAULT_PVID */
1094 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_VLAN_STATS_ENABLED */
1095 #endif
1096 	       nla_total_size(sizeof(u16)) +    /* IFLA_BR_GROUP_FWD_MASK */
1097 	       nla_total_size(sizeof(struct ifla_bridge_id)) +   /* IFLA_BR_ROOT_ID */
1098 	       nla_total_size(sizeof(struct ifla_bridge_id)) +   /* IFLA_BR_BRIDGE_ID */
1099 	       nla_total_size(sizeof(u16)) +    /* IFLA_BR_ROOT_PORT */
1100 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_ROOT_PATH_COST */
1101 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_TOPOLOGY_CHANGE */
1102 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_TOPOLOGY_CHANGE_DETECTED */
1103 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_HELLO_TIMER */
1104 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TCN_TIMER */
1105 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TOPOLOGY_CHANGE_TIMER */
1106 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_GC_TIMER */
1107 	       nla_total_size(ETH_ALEN) +       /* IFLA_BR_GROUP_ADDR */
1108 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1109 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_ROUTER */
1110 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_SNOOPING */
1111 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_QUERY_USE_IFADDR */
1112 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_MCAST_QUERIER */
1113 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_HASH_ELASTICITY */
1114 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_HASH_MAX */
1115 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_LAST_MEMBER_CNT */
1116 	       nla_total_size(sizeof(u32)) +    /* IFLA_BR_MCAST_STARTUP_QUERY_CNT */
1117 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_LAST_MEMBER_INTVL */
1118 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_MEMBERSHIP_INTVL */
1119 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERIER_INTVL */
1120 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_INTVL */
1121 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_RESPONSE_INTVL */
1122 	       nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_STARTUP_QUERY_INTVL */
1123 #endif
1124 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1125 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_NF_CALL_IPTABLES */
1126 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_NF_CALL_IP6TABLES */
1127 	       nla_total_size(sizeof(u8)) +     /* IFLA_BR_NF_CALL_ARPTABLES */
1128 #endif
1129 	       0;
1130 }
1131 
1132 static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
1133 {
1134 	struct net_bridge *br = netdev_priv(brdev);
1135 	u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
1136 	u32 hello_time = jiffies_to_clock_t(br->hello_time);
1137 	u32 age_time = jiffies_to_clock_t(br->max_age);
1138 	u32 ageing_time = jiffies_to_clock_t(br->ageing_time);
1139 	u32 stp_enabled = br->stp_enabled;
1140 	u16 priority = (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1];
1141 	u8 vlan_enabled = br_vlan_enabled(br);
1142 	u64 clockval;
1143 
1144 	clockval = br_timer_value(&br->hello_timer);
1145 	if (nla_put_u64_64bit(skb, IFLA_BR_HELLO_TIMER, clockval, IFLA_BR_PAD))
1146 		return -EMSGSIZE;
1147 	clockval = br_timer_value(&br->tcn_timer);
1148 	if (nla_put_u64_64bit(skb, IFLA_BR_TCN_TIMER, clockval, IFLA_BR_PAD))
1149 		return -EMSGSIZE;
1150 	clockval = br_timer_value(&br->topology_change_timer);
1151 	if (nla_put_u64_64bit(skb, IFLA_BR_TOPOLOGY_CHANGE_TIMER, clockval,
1152 			      IFLA_BR_PAD))
1153 		return -EMSGSIZE;
1154 	clockval = br_timer_value(&br->gc_timer);
1155 	if (nla_put_u64_64bit(skb, IFLA_BR_GC_TIMER, clockval, IFLA_BR_PAD))
1156 		return -EMSGSIZE;
1157 
1158 	if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
1159 	    nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
1160 	    nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time) ||
1161 	    nla_put_u32(skb, IFLA_BR_AGEING_TIME, ageing_time) ||
1162 	    nla_put_u32(skb, IFLA_BR_STP_STATE, stp_enabled) ||
1163 	    nla_put_u16(skb, IFLA_BR_PRIORITY, priority) ||
1164 	    nla_put_u8(skb, IFLA_BR_VLAN_FILTERING, vlan_enabled) ||
1165 	    nla_put_u16(skb, IFLA_BR_GROUP_FWD_MASK, br->group_fwd_mask) ||
1166 	    nla_put(skb, IFLA_BR_BRIDGE_ID, sizeof(struct ifla_bridge_id),
1167 		    &br->bridge_id) ||
1168 	    nla_put(skb, IFLA_BR_ROOT_ID, sizeof(struct ifla_bridge_id),
1169 		    &br->designated_root) ||
1170 	    nla_put_u16(skb, IFLA_BR_ROOT_PORT, br->root_port) ||
1171 	    nla_put_u32(skb, IFLA_BR_ROOT_PATH_COST, br->root_path_cost) ||
1172 	    nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE, br->topology_change) ||
1173 	    nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
1174 		       br->topology_change_detected) ||
1175 	    nla_put(skb, IFLA_BR_GROUP_ADDR, ETH_ALEN, br->group_addr))
1176 		return -EMSGSIZE;
1177 
1178 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
1179 	if (nla_put_be16(skb, IFLA_BR_VLAN_PROTOCOL, br->vlan_proto) ||
1180 	    nla_put_u16(skb, IFLA_BR_VLAN_DEFAULT_PVID, br->default_pvid) ||
1181 	    nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED, br->vlan_stats_enabled))
1182 		return -EMSGSIZE;
1183 #endif
1184 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1185 	if (nla_put_u8(skb, IFLA_BR_MCAST_ROUTER, br->multicast_router) ||
1186 	    nla_put_u8(skb, IFLA_BR_MCAST_SNOOPING, !br->multicast_disabled) ||
1187 	    nla_put_u8(skb, IFLA_BR_MCAST_QUERY_USE_IFADDR,
1188 		       br->multicast_query_use_ifaddr) ||
1189 	    nla_put_u8(skb, IFLA_BR_MCAST_QUERIER, br->multicast_querier) ||
1190 	    nla_put_u32(skb, IFLA_BR_MCAST_HASH_ELASTICITY,
1191 			br->hash_elasticity) ||
1192 	    nla_put_u32(skb, IFLA_BR_MCAST_HASH_MAX, br->hash_max) ||
1193 	    nla_put_u32(skb, IFLA_BR_MCAST_LAST_MEMBER_CNT,
1194 			br->multicast_last_member_count) ||
1195 	    nla_put_u32(skb, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
1196 			br->multicast_startup_query_count))
1197 		return -EMSGSIZE;
1198 
1199 	clockval = jiffies_to_clock_t(br->multicast_last_member_interval);
1200 	if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_LAST_MEMBER_INTVL, clockval,
1201 			      IFLA_BR_PAD))
1202 		return -EMSGSIZE;
1203 	clockval = jiffies_to_clock_t(br->multicast_membership_interval);
1204 	if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_MEMBERSHIP_INTVL, clockval,
1205 			      IFLA_BR_PAD))
1206 		return -EMSGSIZE;
1207 	clockval = jiffies_to_clock_t(br->multicast_querier_interval);
1208 	if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERIER_INTVL, clockval,
1209 			      IFLA_BR_PAD))
1210 		return -EMSGSIZE;
1211 	clockval = jiffies_to_clock_t(br->multicast_query_interval);
1212 	if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_INTVL, clockval,
1213 			      IFLA_BR_PAD))
1214 		return -EMSGSIZE;
1215 	clockval = jiffies_to_clock_t(br->multicast_query_response_interval);
1216 	if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, clockval,
1217 			      IFLA_BR_PAD))
1218 		return -EMSGSIZE;
1219 	clockval = jiffies_to_clock_t(br->multicast_startup_query_interval);
1220 	if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_STARTUP_QUERY_INTVL, clockval,
1221 			      IFLA_BR_PAD))
1222 		return -EMSGSIZE;
1223 #endif
1224 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1225 	if (nla_put_u8(skb, IFLA_BR_NF_CALL_IPTABLES,
1226 		       br->nf_call_iptables ? 1 : 0) ||
1227 	    nla_put_u8(skb, IFLA_BR_NF_CALL_IP6TABLES,
1228 		       br->nf_call_ip6tables ? 1 : 0) ||
1229 	    nla_put_u8(skb, IFLA_BR_NF_CALL_ARPTABLES,
1230 		       br->nf_call_arptables ? 1 : 0))
1231 		return -EMSGSIZE;
1232 #endif
1233 
1234 	return 0;
1235 }
1236 
1237 static size_t br_get_linkxstats_size(const struct net_device *dev)
1238 {
1239 	struct net_bridge *br = netdev_priv(dev);
1240 	struct net_bridge_vlan_group *vg;
1241 	struct net_bridge_vlan *v;
1242 	int numvls = 0;
1243 
1244 	vg = br_vlan_group(br);
1245 	if (!vg)
1246 		return 0;
1247 
1248 	/* we need to count all, even placeholder entries */
1249 	list_for_each_entry(v, &vg->vlan_list, vlist)
1250 		numvls++;
1251 
1252 	/* account for the vlans and the link xstats type nest attribute */
1253 	return numvls * nla_total_size(sizeof(struct bridge_vlan_xstats)) +
1254 	       nla_total_size(0);
1255 }
1256 
1257 static int br_fill_linkxstats(struct sk_buff *skb, const struct net_device *dev,
1258 			      int *prividx)
1259 {
1260 	struct net_bridge *br = netdev_priv(dev);
1261 	struct net_bridge_vlan_group *vg;
1262 	struct net_bridge_vlan *v;
1263 	struct nlattr *nest;
1264 	int vl_idx = 0;
1265 
1266 	vg = br_vlan_group(br);
1267 	if (!vg)
1268 		goto out;
1269 	nest = nla_nest_start(skb, LINK_XSTATS_TYPE_BRIDGE);
1270 	if (!nest)
1271 		return -EMSGSIZE;
1272 	list_for_each_entry(v, &vg->vlan_list, vlist) {
1273 		struct bridge_vlan_xstats vxi;
1274 		struct br_vlan_stats stats;
1275 
1276 		if (++vl_idx < *prividx)
1277 			continue;
1278 		memset(&vxi, 0, sizeof(vxi));
1279 		vxi.vid = v->vid;
1280 		br_vlan_get_stats(v, &stats);
1281 		vxi.rx_bytes = stats.rx_bytes;
1282 		vxi.rx_packets = stats.rx_packets;
1283 		vxi.tx_bytes = stats.tx_bytes;
1284 		vxi.tx_packets = stats.tx_packets;
1285 
1286 		if (nla_put(skb, BRIDGE_XSTATS_VLAN, sizeof(vxi), &vxi))
1287 			goto nla_put_failure;
1288 	}
1289 	nla_nest_end(skb, nest);
1290 	*prividx = 0;
1291 out:
1292 	return 0;
1293 
1294 nla_put_failure:
1295 	nla_nest_end(skb, nest);
1296 	*prividx = vl_idx;
1297 
1298 	return -EMSGSIZE;
1299 }
1300 
1301 static struct rtnl_af_ops br_af_ops __read_mostly = {
1302 	.family			= AF_BRIDGE,
1303 	.get_link_af_size	= br_get_link_af_size_filtered,
1304 };
1305 
1306 struct rtnl_link_ops br_link_ops __read_mostly = {
1307 	.kind			= "bridge",
1308 	.priv_size		= sizeof(struct net_bridge),
1309 	.setup			= br_dev_setup,
1310 	.maxtype		= IFLA_BR_MAX,
1311 	.policy			= br_policy,
1312 	.validate		= br_validate,
1313 	.newlink		= br_dev_newlink,
1314 	.changelink		= br_changelink,
1315 	.dellink		= br_dev_delete,
1316 	.get_size		= br_get_size,
1317 	.fill_info		= br_fill_info,
1318 	.fill_linkxstats	= br_fill_linkxstats,
1319 	.get_linkxstats_size	= br_get_linkxstats_size,
1320 
1321 	.slave_maxtype		= IFLA_BRPORT_MAX,
1322 	.slave_policy		= br_port_policy,
1323 	.slave_changelink	= br_port_slave_changelink,
1324 	.get_slave_size		= br_port_get_slave_size,
1325 	.fill_slave_info	= br_port_fill_slave_info,
1326 };
1327 
1328 int __init br_netlink_init(void)
1329 {
1330 	int err;
1331 
1332 	br_mdb_init();
1333 	rtnl_af_register(&br_af_ops);
1334 
1335 	err = rtnl_link_register(&br_link_ops);
1336 	if (err)
1337 		goto out_af;
1338 
1339 	return 0;
1340 
1341 out_af:
1342 	rtnl_af_unregister(&br_af_ops);
1343 	br_mdb_uninit();
1344 	return err;
1345 }
1346 
1347 void br_netlink_fini(void)
1348 {
1349 	br_mdb_uninit();
1350 	rtnl_af_unregister(&br_af_ops);
1351 	rtnl_link_unregister(&br_link_ops);
1352 }
1353