blob: f2b1343f8332a1c42c097612ebf734a848ec8a99 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Stephen Hemminger11dc1f32006-05-25 16:00:12 -07002/*
3 * Bridge netlink control interface
4 *
5 * Authors:
6 * Stephen Hemminger <shemminger@osdl.org>
Stephen Hemminger11dc1f32006-05-25 16:00:12 -07007 */
8
9#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
stephen hemmingerbb900b22011-04-04 14:03:32 +000011#include <linux/etherdevice.h>
Thomas Graf32fe21c2007-03-22 11:59:03 -070012#include <net/rtnetlink.h>
Eric W. Biederman881d9662007-09-17 11:56:21 -070013#include <net/net_namespace.h>
Denis V. Lunevb8542722007-12-01 00:21:31 +110014#include <net/sock.h>
Vlad Yasevich407af322013-02-13 12:00:12 +000015#include <uapi/linux/if_bridge.h>
stephen hemmingerbb900b22011-04-04 14:03:32 +000016
Stephen Hemminger11dc1f32006-05-25 16:00:12 -070017#include "br_private.h"
Vitalii Demianetsb03b6dd2011-11-25 00:16:37 +000018#include "br_private_stp.h"
Henrik Bjoernlund5e312fc2020-10-27 10:02:49 +000019#include "br_private_cfm.h"
Roopa Prabhuefa53562017-01-31 22:59:54 -080020#include "br_private_tunnel.h"
Nikolay Aleksandrov2dba4072021-01-26 11:35:33 +020021#include "br_private_mcast_eht.h"
Stephen Hemminger11dc1f32006-05-25 16:00:12 -070022
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020023static int __get_num_vlan_infos(struct net_bridge_vlan_group *vg,
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +020024 u32 filter_mask)
Roopa Prabhufed0a152015-02-25 23:55:40 -080025{
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020026 struct net_bridge_vlan *v;
27 u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +020028 u16 flags, pvid;
Roopa Prabhufed0a152015-02-25 23:55:40 -080029 int num_vlans = 0;
30
Roopa Prabhufed0a152015-02-25 23:55:40 -080031 if (!(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED))
32 return 0;
33
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +020034 pvid = br_get_pvid(vg);
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020035 /* Count number of vlan infos */
Nikolay Aleksandrov586c2b52015-10-02 15:05:10 +020036 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
Roopa Prabhufed0a152015-02-25 23:55:40 -080037 flags = 0;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020038 /* only a context, bridge vlan not activated */
39 if (!br_vlan_should_use(v))
40 continue;
41 if (v->vid == pvid)
Roopa Prabhufed0a152015-02-25 23:55:40 -080042 flags |= BRIDGE_VLAN_INFO_PVID;
43
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020044 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
Roopa Prabhufed0a152015-02-25 23:55:40 -080045 flags |= BRIDGE_VLAN_INFO_UNTAGGED;
46
47 if (vid_range_start == 0) {
48 goto initvars;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020049 } else if ((v->vid - vid_range_end) == 1 &&
Roopa Prabhufed0a152015-02-25 23:55:40 -080050 flags == vid_range_flags) {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020051 vid_range_end = v->vid;
Roopa Prabhufed0a152015-02-25 23:55:40 -080052 continue;
53 } else {
54 if ((vid_range_end - vid_range_start) > 0)
55 num_vlans += 2;
56 else
57 num_vlans += 1;
58 }
59initvars:
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020060 vid_range_start = v->vid;
61 vid_range_end = v->vid;
Roopa Prabhufed0a152015-02-25 23:55:40 -080062 vid_range_flags = flags;
63 }
64
65 if (vid_range_start != 0) {
66 if ((vid_range_end - vid_range_start) > 0)
67 num_vlans += 2;
68 else
69 num_vlans += 1;
70 }
71
72 return num_vlans;
73}
74
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020075static int br_get_num_vlan_infos(struct net_bridge_vlan_group *vg,
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +020076 u32 filter_mask)
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020077{
Nikolay Aleksandrov586c2b52015-10-02 15:05:10 +020078 int num_vlans;
79
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020080 if (!vg)
81 return 0;
82
83 if (filter_mask & RTEXT_FILTER_BRVLAN)
84 return vg->num_vlans;
85
Nikolay Aleksandrov586c2b52015-10-02 15:05:10 +020086 rcu_read_lock();
87 num_vlans = __get_num_vlan_infos(vg, filter_mask);
88 rcu_read_unlock();
89
90 return num_vlans;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020091}
92
Roopa Prabhufed0a152015-02-25 23:55:40 -080093static size_t br_get_link_af_size_filtered(const struct net_device *dev,
94 u32 filter_mask)
Roopa Prabhub7853d72015-02-21 20:21:51 -080095{
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +020096 struct net_bridge_vlan_group *vg = NULL;
Roopa Prabhuefa53562017-01-31 22:59:54 -080097 struct net_bridge_port *p = NULL;
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +000098 struct net_bridge *br = NULL;
99 u32 num_cfm_peer_mep_infos;
100 u32 num_cfm_mep_infos;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800101 size_t vinfo_sz = 0;
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000102 int num_vlan_infos;
Roopa Prabhub7853d72015-02-21 20:21:51 -0800103
Johannes Berg2f56f6b2015-03-03 16:02:16 +0100104 rcu_read_lock();
Julian Wiedmann35f861e2019-03-29 14:38:19 +0100105 if (netif_is_bridge_port(dev)) {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200106 p = br_port_get_rcu(dev);
Nikolay Aleksandrov907b1e62015-10-12 21:47:02 +0200107 vg = nbp_vlan_group_rcu(p);
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200108 } else if (dev->priv_flags & IFF_EBRIDGE) {
109 br = netdev_priv(dev);
Nikolay Aleksandrov907b1e62015-10-12 21:47:02 +0200110 vg = br_vlan_group_rcu(br);
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200111 }
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200112 num_vlan_infos = br_get_num_vlan_infos(vg, filter_mask);
Johannes Berg2f56f6b2015-03-03 16:02:16 +0100113 rcu_read_unlock();
Roopa Prabhub7853d72015-02-21 20:21:51 -0800114
Roopa Prabhuefa53562017-01-31 22:59:54 -0800115 if (p && (p->flags & BR_VLAN_TUNNEL))
116 vinfo_sz += br_get_vlan_tunnel_info_size(vg);
117
Roopa Prabhub7853d72015-02-21 20:21:51 -0800118 /* Each VLAN is returned in bridge_vlan_info along with flags */
Roopa Prabhuefa53562017-01-31 22:59:54 -0800119 vinfo_sz += num_vlan_infos * nla_total_size(sizeof(struct bridge_vlan_info));
120
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000121 if (!(filter_mask & RTEXT_FILTER_CFM_STATUS))
122 return vinfo_sz;
123
124 if (!br)
125 return vinfo_sz;
126
127 /* CFM status info must be added */
128 br_cfm_mep_count(br, &num_cfm_mep_infos);
129 br_cfm_peer_mep_count(br, &num_cfm_peer_mep_infos);
130
131 vinfo_sz += nla_total_size(0); /* IFLA_BRIDGE_CFM */
132 /* For each status struct the MEP instance (u32) is added */
133 /* MEP instance (u32) + br_cfm_mep_status */
134 vinfo_sz += num_cfm_mep_infos *
135 /*IFLA_BRIDGE_CFM_MEP_STATUS_INSTANCE */
136 (nla_total_size(sizeof(u32))
137 /* IFLA_BRIDGE_CFM_MEP_STATUS_OPCODE_UNEXP_SEEN */
138 + nla_total_size(sizeof(u32))
139 /* IFLA_BRIDGE_CFM_MEP_STATUS_VERSION_UNEXP_SEEN */
140 + nla_total_size(sizeof(u32))
141 /* IFLA_BRIDGE_CFM_MEP_STATUS_RX_LEVEL_LOW_SEEN */
142 + nla_total_size(sizeof(u32)));
143 /* MEP instance (u32) + br_cfm_cc_peer_status */
144 vinfo_sz += num_cfm_peer_mep_infos *
145 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_INSTANCE */
146 (nla_total_size(sizeof(u32))
147 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_PEER_MEPID */
148 + nla_total_size(sizeof(u32))
149 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_CCM_DEFECT */
150 + nla_total_size(sizeof(u32))
151 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_RDI */
152 + nla_total_size(sizeof(u32))
153 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_PORT_TLV_VALUE */
154 + nla_total_size(sizeof(u8))
155 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_IF_TLV_VALUE */
156 + nla_total_size(sizeof(u8))
157 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_SEEN */
158 + nla_total_size(sizeof(u32))
159 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_TLV_SEEN */
160 + nla_total_size(sizeof(u32))
161 /* IFLA_BRIDGE_CFM_CC_PEER_STATUS_SEQ_UNEXP_SEEN */
162 + nla_total_size(sizeof(u32)));
163
Roopa Prabhuefa53562017-01-31 22:59:54 -0800164 return vinfo_sz;
Roopa Prabhub7853d72015-02-21 20:21:51 -0800165}
166
stephen hemminger25c71c72012-11-13 07:53:05 +0000167static inline size_t br_port_info_size(void)
168{
169 return nla_total_size(1) /* IFLA_BRPORT_STATE */
170 + nla_total_size(2) /* IFLA_BRPORT_PRIORITY */
171 + nla_total_size(4) /* IFLA_BRPORT_COST */
172 + nla_total_size(1) /* IFLA_BRPORT_MODE */
stephen hemmingera2e01a62012-11-13 07:53:07 +0000173 + nla_total_size(1) /* IFLA_BRPORT_GUARD */
stephen hemminger1007dd12012-11-13 07:53:08 +0000174 + nla_total_size(1) /* IFLA_BRPORT_PROTECT */
stephen hemminger3da889b2013-03-11 13:52:17 +0000175 + nla_total_size(1) /* IFLA_BRPORT_FAST_LEAVE */
Felix Fietkau6db6f0e2017-01-21 21:01:32 +0100176 + nla_total_size(1) /* IFLA_BRPORT_MCAST_TO_UCAST */
Vlad Yasevich9ba18892013-06-05 10:08:00 -0400177 + nla_total_size(1) /* IFLA_BRPORT_LEARNING */
Vlad Yasevich867a5942013-06-05 10:08:01 -0400178 + nla_total_size(1) /* IFLA_BRPORT_UNICAST_FLOOD */
Tobias Klauser90512472017-05-05 16:36:53 +0200179 + nla_total_size(1) /* IFLA_BRPORT_MCAST_FLOOD */
180 + nla_total_size(1) /* IFLA_BRPORT_BCAST_FLOOD */
Nikolay Aleksandrov355b9f92015-08-04 19:06:32 +0200181 + nla_total_size(1) /* IFLA_BRPORT_PROXYARP */
Nikolay Aleksandrov786c2072015-08-04 19:06:33 +0200182 + nla_total_size(1) /* IFLA_BRPORT_PROXYARP_WIFI */
Roopa Prabhuefa53562017-01-31 22:59:54 -0800183 + nla_total_size(1) /* IFLA_BRPORT_VLAN_TUNNEL */
Roopa Prabhu821f1b22017-10-06 22:12:37 -0700184 + nla_total_size(1) /* IFLA_BRPORT_NEIGH_SUPPRESS */
Nikolay Aleksandrov7d850ab2018-05-24 11:56:48 +0300185 + nla_total_size(1) /* IFLA_BRPORT_ISOLATED */
Nikolay Aleksandrov4ebc7662015-10-06 14:11:55 +0200186 + nla_total_size(sizeof(struct ifla_bridge_id)) /* IFLA_BRPORT_ROOT_ID */
Nikolay Aleksandrov80df9a22015-10-06 14:11:56 +0200187 + nla_total_size(sizeof(struct ifla_bridge_id)) /* IFLA_BRPORT_BRIDGE_ID */
Nikolay Aleksandrov96f94e72015-10-06 14:11:57 +0200188 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_DESIGNATED_PORT */
189 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_DESIGNATED_COST */
Nikolay Aleksandrov42d452c2015-10-06 14:11:58 +0200190 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_ID */
191 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_NO */
Nikolay Aleksandrove08e8382015-10-06 14:11:59 +0200192 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_TOPOLOGY_CHANGE_ACK */
193 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_CONFIG_PENDING */
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +0200194 + nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_MESSAGE_AGE_TIMER */
195 + nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_FORWARD_DELAY_TIMER */
196 + nla_total_size_64bit(sizeof(u64)) /* IFLA_BRPORT_HOLD_TIMER */
Nikolay Aleksandrov5d6ae472015-10-06 14:12:02 +0200197#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
198 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_MULTICAST_ROUTER */
199#endif
Nikolay Aleksandrov5af48b52017-09-27 16:12:44 +0300200 + nla_total_size(sizeof(u16)) /* IFLA_BRPORT_GROUP_FWD_MASK */
Horatiu Vultur3e544422020-04-26 15:22:01 +0200201 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_MRP_RING_OPEN */
Horatiu Vulturffb3adb2020-07-14 09:34:58 +0200202 + nla_total_size(sizeof(u8)) /* IFLA_BRPORT_MRP_IN_OPEN */
Nikolay Aleksandrov2dba4072021-01-26 11:35:33 +0200203 + nla_total_size(sizeof(u32)) /* IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT */
204 + nla_total_size(sizeof(u32)) /* IFLA_BRPORT_MCAST_EHT_HOSTS_CNT */
stephen hemminger25c71c72012-11-13 07:53:05 +0000205 + 0;
206}
207
Roopa Prabhufed0a152015-02-25 23:55:40 -0800208static inline size_t br_nlmsg_size(struct net_device *dev, u32 filter_mask)
Thomas Graf339bf982006-11-10 14:10:15 -0800209{
210 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
stephen hemminger25c71c72012-11-13 07:53:05 +0000211 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
212 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
213 + nla_total_size(4) /* IFLA_MASTER */
214 + nla_total_size(4) /* IFLA_MTU */
215 + nla_total_size(4) /* IFLA_LINK */
216 + nla_total_size(1) /* IFLA_OPERSTATE */
Roopa Prabhub7853d72015-02-21 20:21:51 -0800217 + nla_total_size(br_port_info_size()) /* IFLA_PROTINFO */
Roopa Prabhufed0a152015-02-25 23:55:40 -0800218 + nla_total_size(br_get_link_af_size_filtered(dev,
Nikolay Aleksandrov2756f682018-07-23 11:16:59 +0300219 filter_mask)) /* IFLA_AF_SPEC */
220 + nla_total_size(4); /* IFLA_BRPORT_BACKUP_PORT */
stephen hemminger25c71c72012-11-13 07:53:05 +0000221}
222
223static int br_port_fill_attrs(struct sk_buff *skb,
224 const struct net_bridge_port *p)
225{
226 u8 mode = !!(p->flags & BR_HAIRPIN_MODE);
Nikolay Aleksandrov2756f682018-07-23 11:16:59 +0300227 struct net_bridge_port *backup_p;
Nikolay Aleksandrov61c0a9a2015-10-06 14:12:00 +0200228 u64 timerval;
stephen hemminger25c71c72012-11-13 07:53:05 +0000229
230 if (nla_put_u8(skb, IFLA_BRPORT_STATE, p->state) ||
231 nla_put_u16(skb, IFLA_BRPORT_PRIORITY, p->priority) ||
232 nla_put_u32(skb, IFLA_BRPORT_COST, p->path_cost) ||
stephen hemmingera2e01a62012-11-13 07:53:07 +0000233 nla_put_u8(skb, IFLA_BRPORT_MODE, mode) ||
stephen hemminger1007dd12012-11-13 07:53:08 +0000234 nla_put_u8(skb, IFLA_BRPORT_GUARD, !!(p->flags & BR_BPDU_GUARD)) ||
Nikolay Aleksandrovb6cb5ac2016-08-31 15:36:52 +0200235 nla_put_u8(skb, IFLA_BRPORT_PROTECT,
236 !!(p->flags & BR_ROOT_BLOCK)) ||
237 nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE,
238 !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
Felix Fietkau6db6f0e2017-01-21 21:01:32 +0100239 nla_put_u8(skb, IFLA_BRPORT_MCAST_TO_UCAST,
240 !!(p->flags & BR_MULTICAST_TO_UNICAST)) ||
Vlad Yasevich867a5942013-06-05 10:08:01 -0400241 nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
Nikolay Aleksandrovb6cb5ac2016-08-31 15:36:52 +0200242 nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD,
243 !!(p->flags & BR_FLOOD)) ||
244 nla_put_u8(skb, IFLA_BRPORT_MCAST_FLOOD,
245 !!(p->flags & BR_MCAST_FLOOD)) ||
Mike Manning99f906e2017-04-26 14:48:09 +0100246 nla_put_u8(skb, IFLA_BRPORT_BCAST_FLOOD,
247 !!(p->flags & BR_BCAST_FLOOD)) ||
Jouni Malinen842a9ae2015-03-04 12:54:21 +0200248 nla_put_u8(skb, IFLA_BRPORT_PROXYARP, !!(p->flags & BR_PROXYARP)) ||
249 nla_put_u8(skb, IFLA_BRPORT_PROXYARP_WIFI,
Nikolay Aleksandrov4ebc7662015-10-06 14:11:55 +0200250 !!(p->flags & BR_PROXYARP_WIFI)) ||
251 nla_put(skb, IFLA_BRPORT_ROOT_ID, sizeof(struct ifla_bridge_id),
Nikolay Aleksandrov80df9a22015-10-06 14:11:56 +0200252 &p->designated_root) ||
253 nla_put(skb, IFLA_BRPORT_BRIDGE_ID, sizeof(struct ifla_bridge_id),
Nikolay Aleksandrov96f94e72015-10-06 14:11:57 +0200254 &p->designated_bridge) ||
255 nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_PORT, p->designated_port) ||
Nikolay Aleksandrov42d452c2015-10-06 14:11:58 +0200256 nla_put_u16(skb, IFLA_BRPORT_DESIGNATED_COST, p->designated_cost) ||
257 nla_put_u16(skb, IFLA_BRPORT_ID, p->port_id) ||
Nikolay Aleksandrove08e8382015-10-06 14:11:59 +0200258 nla_put_u16(skb, IFLA_BRPORT_NO, p->port_no) ||
259 nla_put_u8(skb, IFLA_BRPORT_TOPOLOGY_CHANGE_ACK,
260 p->topology_change_ack) ||
Roopa Prabhuefa53562017-01-31 22:59:54 -0800261 nla_put_u8(skb, IFLA_BRPORT_CONFIG_PENDING, p->config_pending) ||
262 nla_put_u8(skb, IFLA_BRPORT_VLAN_TUNNEL, !!(p->flags &
Nikolay Aleksandrov5af48b52017-09-27 16:12:44 +0300263 BR_VLAN_TUNNEL)) ||
Roopa Prabhu821f1b22017-10-06 22:12:37 -0700264 nla_put_u16(skb, IFLA_BRPORT_GROUP_FWD_MASK, p->group_fwd_mask) ||
265 nla_put_u8(skb, IFLA_BRPORT_NEIGH_SUPPRESS,
Nikolay Aleksandrov7d850ab2018-05-24 11:56:48 +0300266 !!(p->flags & BR_NEIGH_SUPPRESS)) ||
Horatiu Vultur3e544422020-04-26 15:22:01 +0200267 nla_put_u8(skb, IFLA_BRPORT_MRP_RING_OPEN, !!(p->flags &
268 BR_MRP_LOST_CONT)) ||
Horatiu Vulturffb3adb2020-07-14 09:34:58 +0200269 nla_put_u8(skb, IFLA_BRPORT_MRP_IN_OPEN,
270 !!(p->flags & BR_MRP_LOST_IN_CONT)) ||
Nikolay Aleksandrov7d850ab2018-05-24 11:56:48 +0300271 nla_put_u8(skb, IFLA_BRPORT_ISOLATED, !!(p->flags & BR_ISOLATED)))
stephen hemminger25c71c72012-11-13 07:53:05 +0000272 return -EMSGSIZE;
273
Nikolay Aleksandrov61c0a9a2015-10-06 14:12:00 +0200274 timerval = br_timer_value(&p->message_age_timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +0200275 if (nla_put_u64_64bit(skb, IFLA_BRPORT_MESSAGE_AGE_TIMER, timerval,
276 IFLA_BRPORT_PAD))
Nikolay Aleksandrov61c0a9a2015-10-06 14:12:00 +0200277 return -EMSGSIZE;
278 timerval = br_timer_value(&p->forward_delay_timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +0200279 if (nla_put_u64_64bit(skb, IFLA_BRPORT_FORWARD_DELAY_TIMER, timerval,
280 IFLA_BRPORT_PAD))
Nikolay Aleksandrov61c0a9a2015-10-06 14:12:00 +0200281 return -EMSGSIZE;
282 timerval = br_timer_value(&p->hold_timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +0200283 if (nla_put_u64_64bit(skb, IFLA_BRPORT_HOLD_TIMER, timerval,
284 IFLA_BRPORT_PAD))
Nikolay Aleksandrov61c0a9a2015-10-06 14:12:00 +0200285 return -EMSGSIZE;
286
Nikolay Aleksandrov5d6ae472015-10-06 14:12:02 +0200287#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
288 if (nla_put_u8(skb, IFLA_BRPORT_MULTICAST_ROUTER,
Nikolay Aleksandrov2dba4072021-01-26 11:35:33 +0200289 p->multicast_router) ||
290 nla_put_u32(skb, IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT,
291 p->multicast_eht_hosts_limit) ||
292 nla_put_u32(skb, IFLA_BRPORT_MCAST_EHT_HOSTS_CNT,
293 p->multicast_eht_hosts_cnt))
Nikolay Aleksandrov5d6ae472015-10-06 14:12:02 +0200294 return -EMSGSIZE;
295#endif
296
Nikolay Aleksandrov2756f682018-07-23 11:16:59 +0300297 /* we might be called only with br->lock */
298 rcu_read_lock();
299 backup_p = rcu_dereference(p->backup_port);
300 if (backup_p)
301 nla_put_u32(skb, IFLA_BRPORT_BACKUP_PORT,
302 backup_p->dev->ifindex);
303 rcu_read_unlock();
304
stephen hemminger25c71c72012-11-13 07:53:05 +0000305 return 0;
Thomas Graf339bf982006-11-10 14:10:15 -0800306}
307
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800308static int br_fill_ifvlaninfo_range(struct sk_buff *skb, u16 vid_start,
309 u16 vid_end, u16 flags)
310{
311 struct bridge_vlan_info vinfo;
312
313 if ((vid_end - vid_start) > 0) {
314 /* add range to skb */
315 vinfo.vid = vid_start;
316 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_BEGIN;
317 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
318 sizeof(vinfo), &vinfo))
319 goto nla_put_failure;
320
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800321 vinfo.vid = vid_end;
322 vinfo.flags = flags | BRIDGE_VLAN_INFO_RANGE_END;
323 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
324 sizeof(vinfo), &vinfo))
325 goto nla_put_failure;
326 } else {
327 vinfo.vid = vid_start;
328 vinfo.flags = flags;
329 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
330 sizeof(vinfo), &vinfo))
331 goto nla_put_failure;
332 }
333
334 return 0;
335
336nla_put_failure:
337 return -EMSGSIZE;
338}
339
340static int br_fill_ifvlaninfo_compressed(struct sk_buff *skb,
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200341 struct net_bridge_vlan_group *vg)
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800342{
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200343 struct net_bridge_vlan *v;
344 u16 vid_range_start = 0, vid_range_end = 0, vid_range_flags = 0;
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200345 u16 flags, pvid;
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800346 int err = 0;
347
348 /* Pack IFLA_BRIDGE_VLAN_INFO's for every vlan
349 * and mark vlan info with begin and end flags
350 * if vlaninfo represents a range
351 */
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200352 pvid = br_get_pvid(vg);
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200353 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800354 flags = 0;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200355 if (!br_vlan_should_use(v))
356 continue;
357 if (v->vid == pvid)
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800358 flags |= BRIDGE_VLAN_INFO_PVID;
359
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200360 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800361 flags |= BRIDGE_VLAN_INFO_UNTAGGED;
362
363 if (vid_range_start == 0) {
364 goto initvars;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200365 } else if ((v->vid - vid_range_end) == 1 &&
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800366 flags == vid_range_flags) {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200367 vid_range_end = v->vid;
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800368 continue;
369 } else {
370 err = br_fill_ifvlaninfo_range(skb, vid_range_start,
371 vid_range_end,
372 vid_range_flags);
373 if (err)
374 return err;
375 }
376
377initvars:
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200378 vid_range_start = v->vid;
379 vid_range_end = v->vid;
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800380 vid_range_flags = flags;
381 }
382
Roopa Prabhu0fe6de42015-01-12 16:25:28 -0800383 if (vid_range_start != 0) {
384 /* Call it once more to send any left over vlans */
385 err = br_fill_ifvlaninfo_range(skb, vid_range_start,
386 vid_range_end,
387 vid_range_flags);
388 if (err)
389 return err;
390 }
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800391
392 return 0;
393}
394
395static int br_fill_ifvlaninfo(struct sk_buff *skb,
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200396 struct net_bridge_vlan_group *vg)
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800397{
398 struct bridge_vlan_info vinfo;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200399 struct net_bridge_vlan *v;
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200400 u16 pvid;
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800401
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200402 pvid = br_get_pvid(vg);
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200403 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200404 if (!br_vlan_should_use(v))
405 continue;
406
407 vinfo.vid = v->vid;
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800408 vinfo.flags = 0;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200409 if (v->vid == pvid)
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800410 vinfo.flags |= BRIDGE_VLAN_INFO_PVID;
411
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200412 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800413 vinfo.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
414
415 if (nla_put(skb, IFLA_BRIDGE_VLAN_INFO,
416 sizeof(vinfo), &vinfo))
417 goto nla_put_failure;
418 }
419
420 return 0;
421
422nla_put_failure:
423 return -EMSGSIZE;
424}
425
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700426/*
427 * Create one netlink message for one interface
428 * Contains port and master info as well as carrier and bridge state.
429 */
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000430static int br_fill_ifinfo(struct sk_buff *skb,
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200431 const struct net_bridge_port *port,
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000432 u32 pid, u32 seq, int event, unsigned int flags,
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000433 u32 filter_mask, const struct net_device *dev,
434 bool getlink)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700435{
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200436 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
Henrik Bjoernlundb6c02ef2020-10-07 12:07:00 +0000437 struct nlattr *af = NULL;
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200438 struct net_bridge *br;
Thomas Graf74685962006-11-20 16:20:22 -0800439 struct ifinfomsg *hdr;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700440 struct nlmsghdr *nlh;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700441
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000442 if (port)
443 br = port->br;
444 else
445 br = netdev_priv(dev);
446
stephen hemminger28a16c92010-05-10 09:31:09 +0000447 br_debug(br, "br_fill_info event %d port %s master %s\n",
448 event, dev->name, br->dev->name);
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700449
Thomas Graf74685962006-11-20 16:20:22 -0800450 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*hdr), flags);
451 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -0800452 return -EMSGSIZE;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700453
Thomas Graf74685962006-11-20 16:20:22 -0800454 hdr = nlmsg_data(nlh);
455 hdr->ifi_family = AF_BRIDGE;
456 hdr->__ifi_pad = 0;
457 hdr->ifi_type = dev->type;
458 hdr->ifi_index = dev->ifindex;
459 hdr->ifi_flags = dev_get_flags(dev);
460 hdr->ifi_change = 0;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700461
David S. Miller2eb812e2012-04-01 20:49:54 -0400462 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
463 nla_put_u32(skb, IFLA_MASTER, br->dev->ifindex) ||
464 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
465 nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
466 (dev->addr_len &&
467 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
Nicolas Dichtela54acb32015-04-02 17:07:00 +0200468 (dev->ifindex != dev_get_iflink(dev) &&
469 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
David S. Miller2eb812e2012-04-01 20:49:54 -0400470 goto nla_put_failure;
stephen hemminger25c71c72012-11-13 07:53:05 +0000471
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000472 if (event == RTM_NEWLINK && port) {
Michal Kubecekf78c6032019-04-26 11:13:12 +0200473 struct nlattr *nest;
stephen hemminger25c71c72012-11-13 07:53:05 +0000474
Michal Kubecekf78c6032019-04-26 11:13:12 +0200475 nest = nla_nest_start(skb, IFLA_PROTINFO);
stephen hemminger25c71c72012-11-13 07:53:05 +0000476 if (nest == NULL || br_port_fill_attrs(skb, port) < 0)
477 goto nla_put_failure;
478 nla_nest_end(skb, nest);
479 }
480
Henrik Bjoernlundb6c02ef2020-10-07 12:07:00 +0000481 if (filter_mask & (RTEXT_FILTER_BRVLAN |
482 RTEXT_FILTER_BRVLAN_COMPRESSED |
Henrik Bjoernlund5e312fc2020-10-27 10:02:49 +0000483 RTEXT_FILTER_MRP |
Henrik Bjoernlunde77824d2020-10-27 10:02:50 +0000484 RTEXT_FILTER_CFM_CONFIG |
485 RTEXT_FILTER_CFM_STATUS)) {
Henrik Bjoernlundb6c02ef2020-10-07 12:07:00 +0000486 af = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
487 if (!af)
488 goto nla_put_failure;
489 }
490
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000491 /* Check if the VID information is requested */
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800492 if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
493 (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200494 struct net_bridge_vlan_group *vg;
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800495 int err;
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000496
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200497 /* RCU needed because of the VLAN locking rules (rcu || rtnl) */
498 rcu_read_lock();
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200499 if (port)
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200500 vg = nbp_vlan_group_rcu(port);
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200501 else
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200502 vg = br_vlan_group_rcu(br);
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000503
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200504 if (!vg || !vg->num_vlans) {
505 rcu_read_unlock();
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000506 goto done;
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200507 }
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800508 if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200509 err = br_fill_ifvlaninfo_compressed(skb, vg);
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800510 else
Nikolay Aleksandrov77751ee2015-09-30 20:16:53 +0200511 err = br_fill_ifvlaninfo(skb, vg);
Roopa Prabhuefa53562017-01-31 22:59:54 -0800512
513 if (port && (port->flags & BR_VLAN_TUNNEL))
514 err = br_fill_vlan_tunnel_info(skb, vg);
Nikolay Aleksandrove9c953e2015-10-12 21:47:03 +0200515 rcu_read_unlock();
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800516 if (err)
517 goto nla_put_failure;
Horatiu Vultur36a8e8e2020-07-02 10:13:07 +0200518 }
519
520 if (filter_mask & RTEXT_FILTER_MRP) {
Horatiu Vultur36a8e8e2020-07-02 10:13:07 +0200521 int err;
522
523 if (!br_mrp_enabled(br) || port)
524 goto done;
525
Horatiu Vultur36a8e8e2020-07-02 10:13:07 +0200526 rcu_read_lock();
527 err = br_mrp_fill_info(skb, br);
528 rcu_read_unlock();
529
530 if (err)
531 goto nla_put_failure;
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000532 }
533
Henrik Bjoernlunde77824d2020-10-27 10:02:50 +0000534 if (filter_mask & (RTEXT_FILTER_CFM_CONFIG | RTEXT_FILTER_CFM_STATUS)) {
Henrik Bjoernlund5e312fc2020-10-27 10:02:49 +0000535 struct nlattr *cfm_nest = NULL;
536 int err;
537
538 if (!br_cfm_created(br) || port)
539 goto done;
540
541 cfm_nest = nla_nest_start(skb, IFLA_BRIDGE_CFM);
542 if (!cfm_nest)
543 goto nla_put_failure;
544
545 if (filter_mask & RTEXT_FILTER_CFM_CONFIG) {
546 rcu_read_lock();
547 err = br_cfm_config_fill_info(skb, br);
548 rcu_read_unlock();
549 if (err)
550 goto nla_put_failure;
551 }
552
Henrik Bjoernlunde77824d2020-10-27 10:02:50 +0000553 if (filter_mask & RTEXT_FILTER_CFM_STATUS) {
554 rcu_read_lock();
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000555 err = br_cfm_status_fill_info(skb, br, getlink);
Henrik Bjoernlunde77824d2020-10-27 10:02:50 +0000556 rcu_read_unlock();
557 if (err)
558 goto nla_put_failure;
559 }
560
Henrik Bjoernlund5e312fc2020-10-27 10:02:49 +0000561 nla_nest_end(skb, cfm_nest);
562 }
563
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +0000564done:
Henrik Bjoernlundb6c02ef2020-10-07 12:07:00 +0000565 if (af)
566 nla_nest_end(skb, af);
Johannes Berg053c0952015-01-16 22:09:00 +0100567 nlmsg_end(skb, nlh);
568 return 0;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700569
Thomas Graf74685962006-11-20 16:20:22 -0800570nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -0800571 nlmsg_cancel(skb, nlh);
572 return -EMSGSIZE;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700573}
574
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000575void br_info_notify(int event, const struct net_bridge *br,
576 const struct net_bridge_port *port, u32 filter)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700577{
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200578 struct net_device *dev;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700579 struct sk_buff *skb;
Thomas Graf280a3062006-08-15 00:36:28 -0700580 int err = -ENOBUFS;
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200581 struct net *net;
582 u16 port_no = 0;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700583
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200584 if (WARN_ON(!port && !br))
Vlad Yasevich407af322013-02-13 12:00:12 +0000585 return;
586
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200587 if (port) {
588 dev = port->dev;
589 br = port->br;
590 port_no = port->port_no;
591 } else {
592 dev = br->dev;
593 }
stephen hemminger28a16c92010-05-10 09:31:09 +0000594
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200595 net = dev_net(dev);
596 br_debug(br, "port %u(%s) event %d\n", port_no, dev->name, event);
597
598 skb = nlmsg_new(br_nlmsg_size(dev, filter), GFP_ATOMIC);
Thomas Graf280a3062006-08-15 00:36:28 -0700599 if (skb == NULL)
600 goto errout;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700601
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000602 err = br_fill_ifinfo(skb, port, 0, 0, event, 0, filter, dev, false);
Patrick McHardy26932562007-01-31 23:16:40 -0800603 if (err < 0) {
604 /* -EMSGSIZE implies BUG in br_nlmsg_size() */
605 WARN_ON(err == -EMSGSIZE);
606 kfree_skb(skb);
607 goto errout;
608 }
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -0800609 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
610 return;
Thomas Graf280a3062006-08-15 00:36:28 -0700611errout:
tanxiaojun87e823b2013-12-19 13:28:10 +0800612 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700613}
614
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000615/* Notify listeners of a change in bridge or port information */
616void br_ifinfo_notify(int event, const struct net_bridge *br,
617 const struct net_bridge_port *port)
618{
619 u32 filter = RTEXT_FILTER_BRVLAN_COMPRESSED;
620
621 return br_info_notify(event, br, port, filter);
622}
623
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700624/*
625 * Dump information about all ports, in response to GETLINK
626 */
John Fastabende5a55a82012-10-24 08:12:57 +0000627int br_getlink(struct sk_buff *skb, u32 pid, u32 seq,
Nicolas Dichtel46c264d2015-04-28 18:33:49 +0200628 struct net_device *dev, u32 filter_mask, int nlflags)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700629{
Hong Zhiguo1fb17542013-09-14 22:42:27 +0800630 struct net_bridge_port *port = br_port_get_rtnl(dev);
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700631
Roopa Prabhu36cd0ff2015-01-10 07:31:14 -0800632 if (!port && !(filter_mask & RTEXT_FILTER_BRVLAN) &&
Horatiu Vultur36a8e8e2020-07-02 10:13:07 +0200633 !(filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED) &&
Henrik Bjoernlund5e312fc2020-10-27 10:02:49 +0000634 !(filter_mask & RTEXT_FILTER_MRP) &&
Henrik Bjoernlunde77824d2020-10-27 10:02:50 +0000635 !(filter_mask & RTEXT_FILTER_CFM_CONFIG) &&
636 !(filter_mask & RTEXT_FILTER_CFM_STATUS))
Dan Carpenter1b846f92015-01-21 12:22:35 +0300637 return 0;
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000638
Nicolas Dichtel46c264d2015-04-28 18:33:49 +0200639 return br_fill_ifinfo(skb, port, pid, seq, RTM_NEWLINK, nlflags,
Henrik Bjoernlundb6d04252020-10-27 10:02:51 +0000640 filter_mask, dev, true);
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700641}
642
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800643static int br_vlan_info(struct net_bridge *br, struct net_bridge_port *p,
Petr Machata169327d2018-12-12 17:02:50 +0000644 int cmd, struct bridge_vlan_info *vinfo, bool *changed,
645 struct netlink_ext_ack *extack)
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800646{
Nikolay Aleksandrovf418af62017-10-27 13:19:37 +0300647 bool curr_change;
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800648 int err = 0;
649
650 switch (cmd) {
651 case RTM_SETLINK:
652 if (p) {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200653 /* if the MASTER flag is set this will act on the global
654 * per-VLAN entry as well
655 */
Nikolay Aleksandrovf418af62017-10-27 13:19:37 +0300656 err = nbp_vlan_add(p, vinfo->vid, vinfo->flags,
Petr Machata169327d2018-12-12 17:02:50 +0000657 &curr_change, extack);
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800658 } else {
Nikolay Aleksandrov2594e9062015-09-25 19:00:11 +0200659 vinfo->flags |= BRIDGE_VLAN_INFO_BRENTRY;
Nikolay Aleksandrovf418af62017-10-27 13:19:37 +0300660 err = br_vlan_add(br, vinfo->vid, vinfo->flags,
Petr Machata169327d2018-12-12 17:02:50 +0000661 &curr_change, extack);
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800662 }
Nikolay Aleksandrovf418af62017-10-27 13:19:37 +0300663 if (curr_change)
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +0300664 *changed = true;
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800665 break;
666
667 case RTM_DELLINK:
668 if (p) {
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +0300669 if (!nbp_vlan_delete(p, vinfo->vid))
670 *changed = true;
671
672 if ((vinfo->flags & BRIDGE_VLAN_INFO_MASTER) &&
673 !br_vlan_delete(p->br, vinfo->vid))
674 *changed = true;
675 } else if (!br_vlan_delete(br, vinfo->vid)) {
676 *changed = true;
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800677 }
678 break;
679 }
680
681 return err;
682}
Vlad Yasevich407af322013-02-13 12:00:12 +0000683
Nikolay Aleksandrovf26b2962020-01-14 19:56:10 +0200684int br_process_vlan_info(struct net_bridge *br,
685 struct net_bridge_port *p, int cmd,
686 struct bridge_vlan_info *vinfo_curr,
687 struct bridge_vlan_info **vinfo_last,
688 bool *changed,
689 struct netlink_ext_ack *extack)
Roopa Prabhuefa53562017-01-31 22:59:54 -0800690{
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200691 int err, rtm_cmd;
692
Nikolay Aleksandrov8f4cc942020-01-14 19:56:08 +0200693 if (!br_vlan_valid_id(vinfo_curr->vid, extack))
Roopa Prabhuefa53562017-01-31 22:59:54 -0800694 return -EINVAL;
695
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200696 /* needed for vlan-only NEWVLAN/DELVLAN notifications */
697 rtm_cmd = br_afspec_cmd_to_rtm(cmd);
698
Roopa Prabhuefa53562017-01-31 22:59:54 -0800699 if (vinfo_curr->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
Nikolay Aleksandrov8f4cc942020-01-14 19:56:08 +0200700 if (!br_vlan_valid_range(vinfo_curr, *vinfo_last, extack))
Roopa Prabhuefa53562017-01-31 22:59:54 -0800701 return -EINVAL;
702 *vinfo_last = vinfo_curr;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800703 return 0;
704 }
705
706 if (*vinfo_last) {
707 struct bridge_vlan_info tmp_vinfo;
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200708 int v, v_change_start = 0;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800709
Nikolay Aleksandrov8f4cc942020-01-14 19:56:08 +0200710 if (!br_vlan_valid_range(vinfo_curr, *vinfo_last, extack))
Roopa Prabhuefa53562017-01-31 22:59:54 -0800711 return -EINVAL;
712
713 memcpy(&tmp_vinfo, *vinfo_last,
714 sizeof(struct bridge_vlan_info));
715 for (v = (*vinfo_last)->vid; v <= vinfo_curr->vid; v++) {
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200716 bool curr_change = false;
717
Roopa Prabhuefa53562017-01-31 22:59:54 -0800718 tmp_vinfo.vid = v;
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200719 err = br_vlan_info(br, p, cmd, &tmp_vinfo, &curr_change,
Petr Machata169327d2018-12-12 17:02:50 +0000720 extack);
Roopa Prabhuefa53562017-01-31 22:59:54 -0800721 if (err)
722 break;
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200723 if (curr_change) {
724 *changed = curr_change;
725 if (!v_change_start)
726 v_change_start = v;
727 } else {
728 /* nothing to notify yet */
729 if (!v_change_start)
730 continue;
731 br_vlan_notify(br, p, v_change_start,
732 v - 1, rtm_cmd);
733 v_change_start = 0;
734 }
Ido Schimmel79794572020-04-30 22:38:45 +0300735 cond_resched();
Roopa Prabhuefa53562017-01-31 22:59:54 -0800736 }
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200737 /* v_change_start is set only if the last/whole range changed */
738 if (v_change_start)
739 br_vlan_notify(br, p, v_change_start,
740 v - 1, rtm_cmd);
741
Roopa Prabhuefa53562017-01-31 22:59:54 -0800742 *vinfo_last = NULL;
743
Nikolay Aleksandrov66c54512017-10-19 20:17:32 +0300744 return err;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800745 }
746
Nikolay Aleksandrovf5459232020-01-14 19:56:14 +0200747 err = br_vlan_info(br, p, cmd, vinfo_curr, changed, extack);
748 if (*changed)
749 br_vlan_notify(br, p, vinfo_curr->vid, 0, rtm_cmd);
750
751 return err;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800752}
753
Vlad Yasevich407af322013-02-13 12:00:12 +0000754static int br_afspec(struct net_bridge *br,
755 struct net_bridge_port *p,
756 struct nlattr *af_spec,
Petr Machata169327d2018-12-12 17:02:50 +0000757 int cmd, bool *changed,
758 struct netlink_ext_ack *extack)
Vlad Yasevich407af322013-02-13 12:00:12 +0000759{
Roopa Prabhuefa53562017-01-31 22:59:54 -0800760 struct bridge_vlan_info *vinfo_curr = NULL;
761 struct bridge_vlan_info *vinfo_last = NULL;
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800762 struct nlattr *attr;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800763 struct vtunnel_info tinfo_last = {};
764 struct vtunnel_info tinfo_curr = {};
765 int err = 0, rem;
Vlad Yasevich407af322013-02-13 12:00:12 +0000766
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800767 nla_for_each_nested(attr, af_spec, rem) {
Roopa Prabhuefa53562017-01-31 22:59:54 -0800768 err = 0;
769 switch (nla_type(attr)) {
770 case IFLA_BRIDGE_VLAN_TUNNEL_INFO:
Nikolay Aleksandrov1020ce32017-06-06 01:26:24 +0300771 if (!p || !(p->flags & BR_VLAN_TUNNEL))
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800772 return -EINVAL;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800773 err = br_parse_vlan_tunnel_info(attr, &tinfo_curr);
774 if (err)
775 return err;
776 err = br_process_vlan_tunnel_info(br, p, cmd,
777 &tinfo_curr,
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +0300778 &tinfo_last,
779 changed);
Roopa Prabhuefa53562017-01-31 22:59:54 -0800780 if (err)
781 return err;
Roopa Prabhubdced7e2015-01-10 07:31:12 -0800782 break;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800783 case IFLA_BRIDGE_VLAN_INFO:
784 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
785 return -EINVAL;
786 vinfo_curr = nla_data(attr);
787 err = br_process_vlan_info(br, p, cmd, vinfo_curr,
Petr Machata169327d2018-12-12 17:02:50 +0000788 &vinfo_last, changed,
789 extack);
Roopa Prabhuefa53562017-01-31 22:59:54 -0800790 if (err)
791 return err;
792 break;
Horatiu Vultur65369932020-04-26 15:22:07 +0200793 case IFLA_BRIDGE_MRP:
794 err = br_mrp_parse(br, p, attr, cmd, extack);
795 if (err)
796 return err;
797 break;
Henrik Bjoernlund2be665c2020-10-27 10:02:48 +0000798 case IFLA_BRIDGE_CFM:
799 err = br_cfm_parse(br, p, attr, cmd, extack);
800 if (err)
801 return err;
802 break;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800803 }
Vlad Yasevich407af322013-02-13 12:00:12 +0000804 }
805
806 return err;
807}
808
Jiri Pirko3ac636b2014-09-05 15:51:30 +0200809static const struct nla_policy br_port_policy[IFLA_BRPORT_MAX + 1] = {
stephen hemminger25c71c72012-11-13 07:53:05 +0000810 [IFLA_BRPORT_STATE] = { .type = NLA_U8 },
811 [IFLA_BRPORT_COST] = { .type = NLA_U32 },
812 [IFLA_BRPORT_PRIORITY] = { .type = NLA_U16 },
813 [IFLA_BRPORT_MODE] = { .type = NLA_U8 },
stephen hemmingera2e01a62012-11-13 07:53:07 +0000814 [IFLA_BRPORT_GUARD] = { .type = NLA_U8 },
stephen hemminger1007dd12012-11-13 07:53:08 +0000815 [IFLA_BRPORT_PROTECT] = { .type = NLA_U8 },
Thomas Graf6f705d82014-11-26 13:42:19 +0100816 [IFLA_BRPORT_FAST_LEAVE]= { .type = NLA_U8 },
Vlad Yasevich9ba18892013-06-05 10:08:00 -0400817 [IFLA_BRPORT_LEARNING] = { .type = NLA_U8 },
Vlad Yasevich867a5942013-06-05 10:08:01 -0400818 [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
Nikolay Aleksandrov355b9f92015-08-04 19:06:32 +0200819 [IFLA_BRPORT_PROXYARP] = { .type = NLA_U8 },
Nikolay Aleksandrov786c2072015-08-04 19:06:33 +0200820 [IFLA_BRPORT_PROXYARP_WIFI] = { .type = NLA_U8 },
Nikolay Aleksandrov5d6ae472015-10-06 14:12:02 +0200821 [IFLA_BRPORT_MULTICAST_ROUTER] = { .type = NLA_U8 },
Felix Fietkau6db6f0e2017-01-21 21:01:32 +0100822 [IFLA_BRPORT_MCAST_TO_UCAST] = { .type = NLA_U8 },
Tobias Klauser90512472017-05-05 16:36:53 +0200823 [IFLA_BRPORT_MCAST_FLOOD] = { .type = NLA_U8 },
824 [IFLA_BRPORT_BCAST_FLOOD] = { .type = NLA_U8 },
Nikolay Aleksandrovfbec4432017-11-13 18:30:55 +0200825 [IFLA_BRPORT_VLAN_TUNNEL] = { .type = NLA_U8 },
Nikolay Aleksandrov5af48b52017-09-27 16:12:44 +0300826 [IFLA_BRPORT_GROUP_FWD_MASK] = { .type = NLA_U16 },
Nikolay Aleksandrov1a3fbd32017-10-30 12:56:33 +0200827 [IFLA_BRPORT_NEIGH_SUPPRESS] = { .type = NLA_U8 },
Nikolay Aleksandrov7d850ab2018-05-24 11:56:48 +0300828 [IFLA_BRPORT_ISOLATED] = { .type = NLA_U8 },
Nikolay Aleksandrov2756f682018-07-23 11:16:59 +0300829 [IFLA_BRPORT_BACKUP_PORT] = { .type = NLA_U32 },
Nikolay Aleksandrov2dba4072021-01-26 11:35:33 +0200830 [IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT] = { .type = NLA_U32 },
stephen hemminger25c71c72012-11-13 07:53:05 +0000831};
832
833/* Change the state of the port and notify spanning tree */
834static int br_set_port_state(struct net_bridge_port *p, u8 state)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700835{
stephen hemminger25c71c72012-11-13 07:53:05 +0000836 if (state > BR_STATE_BLOCKING)
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000837 return -EINVAL;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700838
839 /* if kernel STP is running, don't allow changes */
Stephen Hemminger9cde0702007-03-21 14:22:44 -0700840 if (p->br->stp_enabled == BR_KERNEL_STP)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700841 return -EBUSY;
842
stephen hemminger576eb622012-12-28 18:15:22 +0000843 /* if device is not up, change is not allowed
844 * if link is not present, only allowable state is disabled
845 */
stephen hemminger25c71c72012-11-13 07:53:05 +0000846 if (!netif_running(p->dev) ||
stephen hemminger576eb622012-12-28 18:15:22 +0000847 (!netif_oper_up(p->dev) && state != BR_STATE_DISABLED))
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700848 return -ENETDOWN;
849
Florian Fainelli775dd692014-09-30 16:13:19 -0700850 br_set_state(p, state);
Vitalii Demianetsb03b6dd2011-11-25 00:16:37 +0000851 br_port_state_selection(p->br);
Stephen Hemminger11dc1f32006-05-25 16:00:12 -0700852 return 0;
853}
854
stephen hemminger25c71c72012-11-13 07:53:05 +0000855/* Set/clear or port flags based on attribute */
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200856static void br_set_port_flag(struct net_bridge_port *p, struct nlattr *tb[],
857 int attrtype, unsigned long mask)
stephen hemminger25c71c72012-11-13 07:53:05 +0000858{
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200859 if (!tb[attrtype])
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200860 return;
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200861
862 if (nla_get_u8(tb[attrtype]))
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200863 p->flags |= mask;
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200864 else
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200865 p->flags &= ~mask;
stephen hemminger25c71c72012-11-13 07:53:05 +0000866}
867
868/* Process bridge protocol info on port */
Vladimir Oltean078bbb82021-02-12 17:15:53 +0200869static int br_setport(struct net_bridge_port *p, struct nlattr *tb[],
870 struct netlink_ext_ack *extack)
stephen hemminger25c71c72012-11-13 07:53:05 +0000871{
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200872 unsigned long old_flags, changed_mask;
873 bool br_vlan_tunnel_old;
Roopa Prabhuefa53562017-01-31 22:59:54 -0800874 int err;
stephen hemminger25c71c72012-11-13 07:53:05 +0000875
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200876 old_flags = p->flags;
877 br_vlan_tunnel_old = (old_flags & BR_VLAN_TUNNEL) ? true : false;
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200878
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200879 br_set_port_flag(p, tb, IFLA_BRPORT_MODE, BR_HAIRPIN_MODE);
880 br_set_port_flag(p, tb, IFLA_BRPORT_GUARD, BR_BPDU_GUARD);
881 br_set_port_flag(p, tb, IFLA_BRPORT_FAST_LEAVE,
882 BR_MULTICAST_FAST_LEAVE);
883 br_set_port_flag(p, tb, IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK);
884 br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
885 br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
886 br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD);
887 br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_TO_UCAST,
888 BR_MULTICAST_TO_UNICAST);
889 br_set_port_flag(p, tb, IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD);
890 br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
891 br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);
892 br_set_port_flag(p, tb, IFLA_BRPORT_VLAN_TUNNEL, BR_VLAN_TUNNEL);
893 br_set_port_flag(p, tb, IFLA_BRPORT_NEIGH_SUPPRESS, BR_NEIGH_SUPPRESS);
894 br_set_port_flag(p, tb, IFLA_BRPORT_ISOLATED, BR_ISOLATED);
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200895
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200896 changed_mask = old_flags ^ p->flags;
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200897
Vladimir Oltean078bbb82021-02-12 17:15:53 +0200898 err = br_switchdev_set_port_flag(p, p->flags, changed_mask, extack);
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200899 if (err) {
900 p->flags = old_flags;
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200901 return err;
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200902 }
Arkadi Sharshevsky39222852017-06-08 08:44:11 +0200903
Roopa Prabhuefa53562017-01-31 22:59:54 -0800904 if (br_vlan_tunnel_old && !(p->flags & BR_VLAN_TUNNEL))
905 nbp_vlan_tunnel_info_flush(p);
906
Vladimir Oltean304ae3b2021-02-12 17:15:52 +0200907 br_port_flags_change(p, changed_mask);
908
stephen hemminger25c71c72012-11-13 07:53:05 +0000909 if (tb[IFLA_BRPORT_COST]) {
910 err = br_stp_set_path_cost(p, nla_get_u32(tb[IFLA_BRPORT_COST]));
911 if (err)
912 return err;
913 }
914
915 if (tb[IFLA_BRPORT_PRIORITY]) {
916 err = br_stp_set_port_priority(p, nla_get_u16(tb[IFLA_BRPORT_PRIORITY]));
917 if (err)
918 return err;
919 }
920
921 if (tb[IFLA_BRPORT_STATE]) {
922 err = br_set_port_state(p, nla_get_u8(tb[IFLA_BRPORT_STATE]));
923 if (err)
924 return err;
925 }
Vlad Yaseviche028e4b2014-05-16 09:59:16 -0400926
Nikolay Aleksandrov9b0c6e42015-10-06 14:12:01 +0200927 if (tb[IFLA_BRPORT_FLUSH])
928 br_fdb_delete_by_port(p->br, p, 0, 0);
929
Nikolay Aleksandrov5d6ae472015-10-06 14:12:02 +0200930#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
931 if (tb[IFLA_BRPORT_MULTICAST_ROUTER]) {
932 u8 mcast_router = nla_get_u8(tb[IFLA_BRPORT_MULTICAST_ROUTER]);
933
934 err = br_multicast_set_port_router(p, mcast_router);
935 if (err)
936 return err;
937 }
Nikolay Aleksandrov2dba4072021-01-26 11:35:33 +0200938
939 if (tb[IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT]) {
940 u32 hlimit;
941
942 hlimit = nla_get_u32(tb[IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT]);
943 err = br_multicast_eht_set_hosts_limit(p, hlimit);
944 if (err)
945 return err;
946 }
Nikolay Aleksandrov5d6ae472015-10-06 14:12:02 +0200947#endif
Nikolay Aleksandrov5af48b52017-09-27 16:12:44 +0300948
949 if (tb[IFLA_BRPORT_GROUP_FWD_MASK]) {
950 u16 fwd_mask = nla_get_u16(tb[IFLA_BRPORT_GROUP_FWD_MASK]);
951
952 if (fwd_mask & BR_GROUPFWD_MACPAUSE)
953 return -EINVAL;
954 p->group_fwd_mask = fwd_mask;
955 }
956
Nikolay Aleksandrov2756f682018-07-23 11:16:59 +0300957 if (tb[IFLA_BRPORT_BACKUP_PORT]) {
958 struct net_device *backup_dev = NULL;
959 u32 backup_ifindex;
960
961 backup_ifindex = nla_get_u32(tb[IFLA_BRPORT_BACKUP_PORT]);
962 if (backup_ifindex) {
963 backup_dev = __dev_get_by_index(dev_net(p->dev),
964 backup_ifindex);
965 if (!backup_dev)
966 return -ENOENT;
967 }
968
969 err = nbp_backup_change(p, backup_dev);
970 if (err)
971 return err;
972 }
973
stephen hemminger25c71c72012-11-13 07:53:05 +0000974 return 0;
975}
976
977/* Change state and parameters on port. */
Petr Machata2fd527b2018-12-12 17:02:48 +0000978int br_setlink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags,
979 struct netlink_ext_ack *extack)
stephen hemminger25c71c72012-11-13 07:53:05 +0000980{
Nikolay Aleksandrov92899062017-11-01 12:18:13 +0200981 struct net_bridge *br = (struct net_bridge *)netdev_priv(dev);
982 struct nlattr *tb[IFLA_BRPORT_MAX + 1];
983 struct net_bridge_port *p;
stephen hemminger25c71c72012-11-13 07:53:05 +0000984 struct nlattr *protinfo;
Vlad Yasevich407af322013-02-13 12:00:12 +0000985 struct nlattr *afspec;
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +0300986 bool changed = false;
Scott Feldman41c498b2015-05-10 09:47:59 -0700987 int err = 0;
stephen hemminger25c71c72012-11-13 07:53:05 +0000988
Hong zhi guoc60ee672013-03-28 06:21:22 +0000989 protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_PROTINFO);
990 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
Vlad Yasevich407af322013-02-13 12:00:12 +0000991 if (!protinfo && !afspec)
stephen hemminger25c71c72012-11-13 07:53:05 +0000992 return 0;
993
994 p = br_port_get_rtnl(dev);
Vlad Yasevich407af322013-02-13 12:00:12 +0000995 /* We want to accept dev as bridge itself if the AF_SPEC
stephen hemminger8e3bff92013-12-08 12:15:44 -0800996 * is set to see if someone is setting vlan info on the bridge
Vlad Yasevich407af322013-02-13 12:00:12 +0000997 */
Hong zhi guo7b99a992013-03-24 03:26:47 +0000998 if (!p && !afspec)
stephen hemminger25c71c72012-11-13 07:53:05 +0000999 return -EINVAL;
1000
Vlad Yasevich407af322013-02-13 12:00:12 +00001001 if (p && protinfo) {
1002 if (protinfo->nla_type & NLA_F_NESTED) {
Johannes Berg8cb08172019-04-26 14:07:28 +02001003 err = nla_parse_nested_deprecated(tb, IFLA_BRPORT_MAX,
1004 protinfo,
1005 br_port_policy,
1006 NULL);
Vlad Yasevich407af322013-02-13 12:00:12 +00001007 if (err)
1008 return err;
1009
1010 spin_lock_bh(&p->br->lock);
Vladimir Oltean078bbb82021-02-12 17:15:53 +02001011 err = br_setport(p, tb, extack);
Vlad Yasevich407af322013-02-13 12:00:12 +00001012 spin_unlock_bh(&p->br->lock);
1013 } else {
stephen hemminger8e3bff92013-12-08 12:15:44 -08001014 /* Binary compatibility with old RSTP */
Vlad Yasevich407af322013-02-13 12:00:12 +00001015 if (nla_len(protinfo) < sizeof(u8))
1016 return -EINVAL;
1017
1018 spin_lock_bh(&p->br->lock);
1019 err = br_set_port_state(p, nla_get_u8(protinfo));
1020 spin_unlock_bh(&p->br->lock);
1021 }
stephen hemminger25c71c72012-11-13 07:53:05 +00001022 if (err)
Vlad Yasevich407af322013-02-13 12:00:12 +00001023 goto out;
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +03001024 changed = true;
Vlad Yasevich407af322013-02-13 12:00:12 +00001025 }
stephen hemminger25c71c72012-11-13 07:53:05 +00001026
Nikolay Aleksandrov92899062017-11-01 12:18:13 +02001027 if (afspec)
Petr Machata169327d2018-12-12 17:02:50 +00001028 err = br_afspec(br, p, afspec, RTM_SETLINK, &changed, extack);
stephen hemminger25c71c72012-11-13 07:53:05 +00001029
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +03001030 if (changed)
Nikolay Aleksandrov92899062017-11-01 12:18:13 +02001031 br_ifinfo_notify(RTM_NEWLINK, br, p);
Vlad Yasevich407af322013-02-13 12:00:12 +00001032out:
stephen hemminger25c71c72012-11-13 07:53:05 +00001033 return err;
1034}
1035
Vlad Yasevich407af322013-02-13 12:00:12 +00001036/* Delete port information */
Roopa Prabhuadd511b2015-01-29 22:40:12 -08001037int br_dellink(struct net_device *dev, struct nlmsghdr *nlh, u16 flags)
Vlad Yasevich407af322013-02-13 12:00:12 +00001038{
Nikolay Aleksandrov92899062017-11-01 12:18:13 +02001039 struct net_bridge *br = (struct net_bridge *)netdev_priv(dev);
Vlad Yasevich407af322013-02-13 12:00:12 +00001040 struct net_bridge_port *p;
Nikolay Aleksandrov92899062017-11-01 12:18:13 +02001041 struct nlattr *afspec;
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +03001042 bool changed = false;
Scott Feldman85080252015-05-10 09:48:03 -07001043 int err = 0;
Vlad Yasevich407af322013-02-13 12:00:12 +00001044
Hong zhi guoc60ee672013-03-28 06:21:22 +00001045 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
Vlad Yasevich407af322013-02-13 12:00:12 +00001046 if (!afspec)
1047 return 0;
1048
1049 p = br_port_get_rtnl(dev);
1050 /* We want to accept dev as bridge itself as well */
1051 if (!p && !(dev->priv_flags & IFF_EBRIDGE))
1052 return -EINVAL;
1053
Petr Machata169327d2018-12-12 17:02:50 +00001054 err = br_afspec(br, p, afspec, RTM_DELLINK, &changed, NULL);
Nikolay Aleksandrove19b42a2017-10-27 13:19:36 +03001055 if (changed)
Roopa Prabhu02dba432015-01-14 20:02:25 -08001056 /* Send RTM_NEWLINK because userspace
1057 * expects RTM_NEWLINK for vlan dels
1058 */
Nikolay Aleksandrov92899062017-11-01 12:18:13 +02001059 br_ifinfo_notify(RTM_NEWLINK, br, p);
Vlad Yasevich407af322013-02-13 12:00:12 +00001060
1061 return err;
1062}
Matthias Schiffera8b8a8892017-06-25 23:56:01 +02001063
1064static int br_validate(struct nlattr *tb[], struct nlattr *data[],
1065 struct netlink_ext_ack *extack)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -07001066{
stephen hemmingerbb900b22011-04-04 14:03:32 +00001067 if (tb[IFLA_ADDRESS]) {
1068 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1069 return -EINVAL;
1070 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1071 return -EADDRNOTAVAIL;
1072 }
Thomas Graf32fe21c2007-03-22 11:59:03 -07001073
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001074 if (!data)
1075 return 0;
1076
1077#ifdef CONFIG_BRIDGE_VLAN_FILTERING
Menglong Donga98c0c42021-01-17 16:09:50 +08001078 if (data[IFLA_BR_VLAN_PROTOCOL] &&
1079 !eth_type_vlan(nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL])))
1080 return -EPROTONOSUPPORT;
Tobias Jungela2858602017-05-17 09:29:12 +02001081
1082 if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
1083 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
1084
1085 if (defpvid >= VLAN_VID_MASK)
1086 return -EINVAL;
1087 }
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001088#endif
1089
Thomas Graf32fe21c2007-03-22 11:59:03 -07001090 return 0;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -07001091}
1092
Jiri Pirko3ac636b2014-09-05 15:51:30 +02001093static int br_port_slave_changelink(struct net_device *brdev,
1094 struct net_device *dev,
1095 struct nlattr *tb[],
Matthias Schiffer17dd0ec2017-06-25 23:56:02 +02001096 struct nlattr *data[],
1097 struct netlink_ext_ack *extack)
Jiri Pirko3ac636b2014-09-05 15:51:30 +02001098{
Nikolay Aleksandrov963ad942015-07-22 13:03:40 +02001099 struct net_bridge *br = netdev_priv(brdev);
1100 int ret;
1101
Jiri Pirko3ac636b2014-09-05 15:51:30 +02001102 if (!data)
1103 return 0;
Nikolay Aleksandrov963ad942015-07-22 13:03:40 +02001104
1105 spin_lock_bh(&br->lock);
Vladimir Oltean078bbb82021-02-12 17:15:53 +02001106 ret = br_setport(br_port_get_rtnl(dev), data, extack);
Nikolay Aleksandrov963ad942015-07-22 13:03:40 +02001107 spin_unlock_bh(&br->lock);
1108
1109 return ret;
Jiri Pirko3ac636b2014-09-05 15:51:30 +02001110}
1111
Jiri Pirkoced82832014-09-05 15:51:29 +02001112static int br_port_fill_slave_info(struct sk_buff *skb,
1113 const struct net_device *brdev,
1114 const struct net_device *dev)
1115{
1116 return br_port_fill_attrs(skb, br_port_get_rtnl(dev));
1117}
1118
1119static size_t br_port_get_slave_size(const struct net_device *brdev,
1120 const struct net_device *dev)
1121{
1122 return br_port_info_size();
1123}
1124
Jiri Pirko13323512014-09-05 15:51:32 +02001125static const struct nla_policy br_policy[IFLA_BR_MAX + 1] = {
1126 [IFLA_BR_FORWARD_DELAY] = { .type = NLA_U32 },
1127 [IFLA_BR_HELLO_TIME] = { .type = NLA_U32 },
1128 [IFLA_BR_MAX_AGE] = { .type = NLA_U32 },
Jörg Thalheimaf615762015-03-18 10:06:58 +01001129 [IFLA_BR_AGEING_TIME] = { .type = NLA_U32 },
1130 [IFLA_BR_STP_STATE] = { .type = NLA_U32 },
1131 [IFLA_BR_PRIORITY] = { .type = NLA_U16 },
Nikolay Aleksandrova7854032015-08-07 19:40:45 +03001132 [IFLA_BR_VLAN_FILTERING] = { .type = NLA_U8 },
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001133 [IFLA_BR_VLAN_PROTOCOL] = { .type = NLA_U16 },
Nikolay Aleksandrov79102282015-10-04 14:23:28 +02001134 [IFLA_BR_GROUP_FWD_MASK] = { .type = NLA_U16 },
Nikolay Aleksandrov111189a2015-10-04 14:23:35 +02001135 [IFLA_BR_GROUP_ADDR] = { .type = NLA_BINARY,
1136 .len = ETH_ALEN },
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001137 [IFLA_BR_MCAST_ROUTER] = { .type = NLA_U8 },
Nikolay Aleksandrov89126322015-10-04 14:23:38 +02001138 [IFLA_BR_MCAST_SNOOPING] = { .type = NLA_U8 },
Nikolay Aleksandrov295141d2015-10-04 14:23:39 +02001139 [IFLA_BR_MCAST_QUERY_USE_IFADDR] = { .type = NLA_U8 },
Nikolay Aleksandrovba062d7c2015-10-04 14:23:40 +02001140 [IFLA_BR_MCAST_QUERIER] = { .type = NLA_U8 },
Nikolay Aleksandrov431db3c2015-10-04 14:23:41 +02001141 [IFLA_BR_MCAST_HASH_ELASTICITY] = { .type = NLA_U32 },
Nikolay Aleksandrov858079f2015-10-04 14:23:42 +02001142 [IFLA_BR_MCAST_HASH_MAX] = { .type = NLA_U32 },
Nikolay Aleksandrov79b859f2015-10-04 14:23:43 +02001143 [IFLA_BR_MCAST_LAST_MEMBER_CNT] = { .type = NLA_U32 },
Nikolay Aleksandrovb89e6ba2015-10-04 14:23:44 +02001144 [IFLA_BR_MCAST_STARTUP_QUERY_CNT] = { .type = NLA_U32 },
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001145 [IFLA_BR_MCAST_LAST_MEMBER_INTVL] = { .type = NLA_U64 },
1146 [IFLA_BR_MCAST_MEMBERSHIP_INTVL] = { .type = NLA_U64 },
1147 [IFLA_BR_MCAST_QUERIER_INTVL] = { .type = NLA_U64 },
1148 [IFLA_BR_MCAST_QUERY_INTVL] = { .type = NLA_U64 },
1149 [IFLA_BR_MCAST_QUERY_RESPONSE_INTVL] = { .type = NLA_U64 },
1150 [IFLA_BR_MCAST_STARTUP_QUERY_INTVL] = { .type = NLA_U64 },
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001151 [IFLA_BR_NF_CALL_IPTABLES] = { .type = NLA_U8 },
1152 [IFLA_BR_NF_CALL_IP6TABLES] = { .type = NLA_U8 },
1153 [IFLA_BR_NF_CALL_ARPTABLES] = { .type = NLA_U8 },
Nikolay Aleksandrov0f963b72015-10-04 14:23:47 +02001154 [IFLA_BR_VLAN_DEFAULT_PVID] = { .type = NLA_U16 },
Nikolay Aleksandrov6dada9b2016-04-30 10:25:28 +02001155 [IFLA_BR_VLAN_STATS_ENABLED] = { .type = NLA_U8 },
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001156 [IFLA_BR_MCAST_STATS_ENABLED] = { .type = NLA_U8 },
Nikolay Aleksandrov5e923582016-11-21 13:03:24 +01001157 [IFLA_BR_MCAST_IGMP_VERSION] = { .type = NLA_U8 },
Nikolay Aleksandrovaa2ae3e2016-11-21 13:03:25 +01001158 [IFLA_BR_MCAST_MLD_VERSION] = { .type = NLA_U8 },
Nikolay Aleksandrov9163a0f2018-10-12 13:41:16 +03001159 [IFLA_BR_VLAN_STATS_PER_PORT] = { .type = NLA_U8 },
Johannes Berg81408602020-08-18 10:17:31 +02001160 [IFLA_BR_MULTI_BOOLOPT] =
1161 NLA_POLICY_EXACT_LEN(sizeof(struct br_boolopt_multi)),
Jiri Pirko13323512014-09-05 15:51:32 +02001162};
1163
1164static int br_changelink(struct net_device *brdev, struct nlattr *tb[],
Matthias Schifferad744b22017-06-25 23:56:00 +02001165 struct nlattr *data[],
1166 struct netlink_ext_ack *extack)
Jiri Pirko13323512014-09-05 15:51:32 +02001167{
1168 struct net_bridge *br = netdev_priv(brdev);
1169 int err;
1170
1171 if (!data)
1172 return 0;
1173
1174 if (data[IFLA_BR_FORWARD_DELAY]) {
1175 err = br_set_forward_delay(br, nla_get_u32(data[IFLA_BR_FORWARD_DELAY]));
1176 if (err)
1177 return err;
1178 }
1179
1180 if (data[IFLA_BR_HELLO_TIME]) {
1181 err = br_set_hello_time(br, nla_get_u32(data[IFLA_BR_HELLO_TIME]));
1182 if (err)
1183 return err;
1184 }
1185
1186 if (data[IFLA_BR_MAX_AGE]) {
1187 err = br_set_max_age(br, nla_get_u32(data[IFLA_BR_MAX_AGE]));
1188 if (err)
1189 return err;
1190 }
1191
Jörg Thalheimaf615762015-03-18 10:06:58 +01001192 if (data[IFLA_BR_AGEING_TIME]) {
Scott Feldmanc62987b2015-10-08 19:23:19 -07001193 err = br_set_ageing_time(br, nla_get_u32(data[IFLA_BR_AGEING_TIME]));
1194 if (err)
1195 return err;
Jörg Thalheimaf615762015-03-18 10:06:58 +01001196 }
1197
1198 if (data[IFLA_BR_STP_STATE]) {
1199 u32 stp_enabled = nla_get_u32(data[IFLA_BR_STP_STATE]);
1200
Horatiu Vultur419dba8a2020-04-26 15:22:08 +02001201 err = br_stp_set_enabled(br, stp_enabled, extack);
1202 if (err)
1203 return err;
Jörg Thalheimaf615762015-03-18 10:06:58 +01001204 }
1205
1206 if (data[IFLA_BR_PRIORITY]) {
1207 u32 priority = nla_get_u16(data[IFLA_BR_PRIORITY]);
1208
1209 br_stp_set_bridge_priority(br, priority);
1210 }
1211
Nikolay Aleksandrova7854032015-08-07 19:40:45 +03001212 if (data[IFLA_BR_VLAN_FILTERING]) {
1213 u8 vlan_filter = nla_get_u8(data[IFLA_BR_VLAN_FILTERING]);
1214
Vladimir Oltean9e781402021-02-13 22:43:16 +02001215 err = br_vlan_filter_toggle(br, vlan_filter, extack);
Nikolay Aleksandrova7854032015-08-07 19:40:45 +03001216 if (err)
1217 return err;
1218 }
1219
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001220#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1221 if (data[IFLA_BR_VLAN_PROTOCOL]) {
1222 __be16 vlan_proto = nla_get_be16(data[IFLA_BR_VLAN_PROTOCOL]);
1223
Vladimir Olteandcbdf132021-02-13 22:43:17 +02001224 err = __br_vlan_set_proto(br, vlan_proto, extack);
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001225 if (err)
1226 return err;
1227 }
Nikolay Aleksandrov0f963b72015-10-04 14:23:47 +02001228
1229 if (data[IFLA_BR_VLAN_DEFAULT_PVID]) {
1230 __u16 defpvid = nla_get_u16(data[IFLA_BR_VLAN_DEFAULT_PVID]);
1231
Petr Machata169327d2018-12-12 17:02:50 +00001232 err = __br_vlan_set_default_pvid(br, defpvid, extack);
Nikolay Aleksandrov0f963b72015-10-04 14:23:47 +02001233 if (err)
1234 return err;
1235 }
Nikolay Aleksandrov6dada9b2016-04-30 10:25:28 +02001236
1237 if (data[IFLA_BR_VLAN_STATS_ENABLED]) {
1238 __u8 vlan_stats = nla_get_u8(data[IFLA_BR_VLAN_STATS_ENABLED]);
1239
1240 err = br_vlan_set_stats(br, vlan_stats);
1241 if (err)
1242 return err;
1243 }
Nikolay Aleksandrov9163a0f2018-10-12 13:41:16 +03001244
1245 if (data[IFLA_BR_VLAN_STATS_PER_PORT]) {
1246 __u8 per_port = nla_get_u8(data[IFLA_BR_VLAN_STATS_PER_PORT]);
1247
1248 err = br_vlan_set_stats_per_port(br, per_port);
1249 if (err)
1250 return err;
1251 }
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001252#endif
1253
Nikolay Aleksandrov79102282015-10-04 14:23:28 +02001254 if (data[IFLA_BR_GROUP_FWD_MASK]) {
1255 u16 fwd_mask = nla_get_u16(data[IFLA_BR_GROUP_FWD_MASK]);
1256
1257 if (fwd_mask & BR_GROUPFWD_RESTRICTED)
1258 return -EINVAL;
1259 br->group_fwd_mask = fwd_mask;
1260 }
1261
Nikolay Aleksandrov111189a2015-10-04 14:23:35 +02001262 if (data[IFLA_BR_GROUP_ADDR]) {
1263 u8 new_addr[ETH_ALEN];
1264
1265 if (nla_len(data[IFLA_BR_GROUP_ADDR]) != ETH_ALEN)
1266 return -EINVAL;
1267 memcpy(new_addr, nla_data(data[IFLA_BR_GROUP_ADDR]), ETH_ALEN);
1268 if (!is_link_local_ether_addr(new_addr))
1269 return -EINVAL;
1270 if (new_addr[5] == 1 || /* 802.3x Pause address */
1271 new_addr[5] == 2 || /* 802.3ad Slow protocols */
1272 new_addr[5] == 3) /* 802.1X PAE address */
1273 return -EINVAL;
1274 spin_lock_bh(&br->lock);
1275 memcpy(br->group_addr, new_addr, sizeof(br->group_addr));
1276 spin_unlock_bh(&br->lock);
Nikolay Aleksandrovbe3664a2018-09-26 17:01:02 +03001277 br_opt_toggle(br, BROPT_GROUP_ADDR_SET, true);
Nikolay Aleksandrov111189a2015-10-04 14:23:35 +02001278 br_recalculate_fwd_mask(br);
1279 }
1280
Nikolay Aleksandrov150217c2015-10-04 14:23:36 +02001281 if (data[IFLA_BR_FDB_FLUSH])
1282 br_fdb_flush(br);
1283
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001284#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1285 if (data[IFLA_BR_MCAST_ROUTER]) {
1286 u8 multicast_router = nla_get_u8(data[IFLA_BR_MCAST_ROUTER]);
1287
1288 err = br_multicast_set_router(br, multicast_router);
1289 if (err)
1290 return err;
1291 }
Nikolay Aleksandrov89126322015-10-04 14:23:38 +02001292
1293 if (data[IFLA_BR_MCAST_SNOOPING]) {
1294 u8 mcast_snooping = nla_get_u8(data[IFLA_BR_MCAST_SNOOPING]);
1295
YueHaibinga26d94b2018-12-17 17:46:23 +08001296 br_multicast_toggle(br, mcast_snooping);
Nikolay Aleksandrov89126322015-10-04 14:23:38 +02001297 }
Nikolay Aleksandrov295141d2015-10-04 14:23:39 +02001298
1299 if (data[IFLA_BR_MCAST_QUERY_USE_IFADDR]) {
1300 u8 val;
1301
1302 val = nla_get_u8(data[IFLA_BR_MCAST_QUERY_USE_IFADDR]);
Nikolay Aleksandrov675779a2018-09-26 17:01:04 +03001303 br_opt_toggle(br, BROPT_MULTICAST_QUERY_USE_IFADDR, !!val);
Nikolay Aleksandrov295141d2015-10-04 14:23:39 +02001304 }
Nikolay Aleksandrovba062d7c2015-10-04 14:23:40 +02001305
1306 if (data[IFLA_BR_MCAST_QUERIER]) {
1307 u8 mcast_querier = nla_get_u8(data[IFLA_BR_MCAST_QUERIER]);
1308
1309 err = br_multicast_set_querier(br, mcast_querier);
1310 if (err)
1311 return err;
1312 }
Nikolay Aleksandrov431db3c2015-10-04 14:23:41 +02001313
Nikolay Aleksandrovcf332bca2018-12-05 15:14:26 +02001314 if (data[IFLA_BR_MCAST_HASH_ELASTICITY])
1315 br_warn(br, "the hash_elasticity option has been deprecated and is always %u\n",
1316 RHT_ELASTICITY);
Nikolay Aleksandrov858079f2015-10-04 14:23:42 +02001317
Nikolay Aleksandrov19e3a9c2018-12-05 15:14:24 +02001318 if (data[IFLA_BR_MCAST_HASH_MAX])
1319 br->hash_max = nla_get_u32(data[IFLA_BR_MCAST_HASH_MAX]);
Nikolay Aleksandrov79b859f2015-10-04 14:23:43 +02001320
1321 if (data[IFLA_BR_MCAST_LAST_MEMBER_CNT]) {
1322 u32 val = nla_get_u32(data[IFLA_BR_MCAST_LAST_MEMBER_CNT]);
1323
1324 br->multicast_last_member_count = val;
1325 }
Nikolay Aleksandrovb89e6ba2015-10-04 14:23:44 +02001326
1327 if (data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]) {
1328 u32 val = nla_get_u32(data[IFLA_BR_MCAST_STARTUP_QUERY_CNT]);
1329
1330 br->multicast_startup_query_count = val;
1331 }
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001332
1333 if (data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]) {
1334 u64 val = nla_get_u64(data[IFLA_BR_MCAST_LAST_MEMBER_INTVL]);
1335
1336 br->multicast_last_member_interval = clock_t_to_jiffies(val);
1337 }
1338
1339 if (data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]) {
1340 u64 val = nla_get_u64(data[IFLA_BR_MCAST_MEMBERSHIP_INTVL]);
1341
1342 br->multicast_membership_interval = clock_t_to_jiffies(val);
1343 }
1344
1345 if (data[IFLA_BR_MCAST_QUERIER_INTVL]) {
1346 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERIER_INTVL]);
1347
1348 br->multicast_querier_interval = clock_t_to_jiffies(val);
1349 }
1350
1351 if (data[IFLA_BR_MCAST_QUERY_INTVL]) {
1352 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_INTVL]);
1353
1354 br->multicast_query_interval = clock_t_to_jiffies(val);
1355 }
1356
1357 if (data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]) {
1358 u64 val = nla_get_u64(data[IFLA_BR_MCAST_QUERY_RESPONSE_INTVL]);
1359
1360 br->multicast_query_response_interval = clock_t_to_jiffies(val);
1361 }
1362
1363 if (data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]) {
1364 u64 val = nla_get_u64(data[IFLA_BR_MCAST_STARTUP_QUERY_INTVL]);
1365
1366 br->multicast_startup_query_interval = clock_t_to_jiffies(val);
1367 }
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001368
1369 if (data[IFLA_BR_MCAST_STATS_ENABLED]) {
1370 __u8 mcast_stats;
1371
1372 mcast_stats = nla_get_u8(data[IFLA_BR_MCAST_STATS_ENABLED]);
Nikolay Aleksandrov675779a2018-09-26 17:01:04 +03001373 br_opt_toggle(br, BROPT_MULTICAST_STATS_ENABLED, !!mcast_stats);
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001374 }
Nikolay Aleksandrov5e923582016-11-21 13:03:24 +01001375
1376 if (data[IFLA_BR_MCAST_IGMP_VERSION]) {
1377 __u8 igmp_version;
1378
1379 igmp_version = nla_get_u8(data[IFLA_BR_MCAST_IGMP_VERSION]);
1380 err = br_multicast_set_igmp_version(br, igmp_version);
1381 if (err)
1382 return err;
1383 }
Nikolay Aleksandrovaa2ae3e2016-11-21 13:03:25 +01001384
1385#if IS_ENABLED(CONFIG_IPV6)
1386 if (data[IFLA_BR_MCAST_MLD_VERSION]) {
1387 __u8 mld_version;
1388
1389 mld_version = nla_get_u8(data[IFLA_BR_MCAST_MLD_VERSION]);
1390 err = br_multicast_set_mld_version(br, mld_version);
1391 if (err)
1392 return err;
1393 }
1394#endif
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001395#endif
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001396#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1397 if (data[IFLA_BR_NF_CALL_IPTABLES]) {
1398 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IPTABLES]);
1399
Nikolay Aleksandrov8df35102018-09-26 17:01:01 +03001400 br_opt_toggle(br, BROPT_NF_CALL_IPTABLES, !!val);
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001401 }
1402
1403 if (data[IFLA_BR_NF_CALL_IP6TABLES]) {
1404 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_IP6TABLES]);
1405
Nikolay Aleksandrov8df35102018-09-26 17:01:01 +03001406 br_opt_toggle(br, BROPT_NF_CALL_IP6TABLES, !!val);
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001407 }
1408
1409 if (data[IFLA_BR_NF_CALL_ARPTABLES]) {
1410 u8 val = nla_get_u8(data[IFLA_BR_NF_CALL_ARPTABLES]);
1411
Nikolay Aleksandrov8df35102018-09-26 17:01:01 +03001412 br_opt_toggle(br, BROPT_NF_CALL_ARPTABLES, !!val);
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001413 }
1414#endif
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001415
Nikolay Aleksandrova428afe2018-11-24 04:34:20 +02001416 if (data[IFLA_BR_MULTI_BOOLOPT]) {
1417 struct br_boolopt_multi *bm;
1418
1419 bm = nla_data(data[IFLA_BR_MULTI_BOOLOPT]);
1420 err = br_boolopt_multi_toggle(br, bm, extack);
1421 if (err)
1422 return err;
1423 }
1424
Jiri Pirko13323512014-09-05 15:51:32 +02001425 return 0;
1426}
1427
Ivan Vecerab6677442017-01-20 18:12:17 +01001428static int br_dev_newlink(struct net *src_net, struct net_device *dev,
Matthias Schiffer7a3f4a12017-06-25 23:55:59 +02001429 struct nlattr *tb[], struct nlattr *data[],
1430 struct netlink_ext_ack *extack)
Ivan Vecerab6677442017-01-20 18:12:17 +01001431{
1432 struct net_bridge *br = netdev_priv(dev);
1433 int err;
1434
Nikolay Aleksandrov84aeb432017-12-18 17:35:09 +02001435 err = register_netdevice(dev);
1436 if (err)
1437 return err;
1438
Ivan Vecerab6677442017-01-20 18:12:17 +01001439 if (tb[IFLA_ADDRESS]) {
1440 spin_lock_bh(&br->lock);
1441 br_stp_change_bridge_id(br, nla_data(tb[IFLA_ADDRESS]));
1442 spin_unlock_bh(&br->lock);
1443 }
1444
Matthias Schifferad744b22017-06-25 23:56:00 +02001445 err = br_changelink(dev, tb, data, extack);
Ido Schimmel5b8d5422017-04-10 14:59:28 +03001446 if (err)
Nikolay Aleksandrov84aeb432017-12-18 17:35:09 +02001447 br_dev_delete(dev, NULL);
1448
Ido Schimmel5b8d5422017-04-10 14:59:28 +03001449 return err;
Ivan Vecerab6677442017-01-20 18:12:17 +01001450}
1451
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001452static size_t br_get_size(const struct net_device *brdev)
1453{
1454 return nla_total_size(sizeof(u32)) + /* IFLA_BR_FORWARD_DELAY */
1455 nla_total_size(sizeof(u32)) + /* IFLA_BR_HELLO_TIME */
1456 nla_total_size(sizeof(u32)) + /* IFLA_BR_MAX_AGE */
Jörg Thalheimaf615762015-03-18 10:06:58 +01001457 nla_total_size(sizeof(u32)) + /* IFLA_BR_AGEING_TIME */
1458 nla_total_size(sizeof(u32)) + /* IFLA_BR_STP_STATE */
1459 nla_total_size(sizeof(u16)) + /* IFLA_BR_PRIORITY */
Nikolay Aleksandrova7854032015-08-07 19:40:45 +03001460 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_FILTERING */
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001461#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1462 nla_total_size(sizeof(__be16)) + /* IFLA_BR_VLAN_PROTOCOL */
Nikolay Aleksandrov0f963b72015-10-04 14:23:47 +02001463 nla_total_size(sizeof(u16)) + /* IFLA_BR_VLAN_DEFAULT_PVID */
Nikolay Aleksandrov6dada9b2016-04-30 10:25:28 +02001464 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_STATS_ENABLED */
Nikolay Aleksandrov9163a0f2018-10-12 13:41:16 +03001465 nla_total_size(sizeof(u8)) + /* IFLA_BR_VLAN_STATS_PER_PORT */
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001466#endif
Nikolay Aleksandrov79102282015-10-04 14:23:28 +02001467 nla_total_size(sizeof(u16)) + /* IFLA_BR_GROUP_FWD_MASK */
Nikolay Aleksandrov5127c812015-10-04 14:23:29 +02001468 nla_total_size(sizeof(struct ifla_bridge_id)) + /* IFLA_BR_ROOT_ID */
Nikolay Aleksandrov7599a222015-10-04 14:23:30 +02001469 nla_total_size(sizeof(struct ifla_bridge_id)) + /* IFLA_BR_BRIDGE_ID */
Nikolay Aleksandrov8762ba62015-10-04 14:23:31 +02001470 nla_total_size(sizeof(u16)) + /* IFLA_BR_ROOT_PORT */
Nikolay Aleksandrov684dd242015-10-04 14:23:32 +02001471 nla_total_size(sizeof(u32)) + /* IFLA_BR_ROOT_PATH_COST */
Nikolay Aleksandrovb89e6ba2015-10-04 14:23:44 +02001472 nla_total_size(sizeof(u8)) + /* IFLA_BR_TOPOLOGY_CHANGE */
1473 nla_total_size(sizeof(u8)) + /* IFLA_BR_TOPOLOGY_CHANGE_DETECTED */
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001474 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_HELLO_TIMER */
1475 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TCN_TIMER */
1476 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_TOPOLOGY_CHANGE_TIMER */
1477 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_GC_TIMER */
Nikolay Aleksandrov111189a2015-10-04 14:23:35 +02001478 nla_total_size(ETH_ALEN) + /* IFLA_BR_GROUP_ADDR */
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001479#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1480 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_ROUTER */
Nikolay Aleksandrov89126322015-10-04 14:23:38 +02001481 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_SNOOPING */
Nikolay Aleksandrov295141d2015-10-04 14:23:39 +02001482 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_QUERY_USE_IFADDR */
Nikolay Aleksandrovba062d7c2015-10-04 14:23:40 +02001483 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_QUERIER */
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001484 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_STATS_ENABLED */
Nikolay Aleksandrovb89e6ba2015-10-04 14:23:44 +02001485 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_HASH_ELASTICITY */
1486 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_HASH_MAX */
1487 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_LAST_MEMBER_CNT */
1488 nla_total_size(sizeof(u32)) + /* IFLA_BR_MCAST_STARTUP_QUERY_CNT */
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001489 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_LAST_MEMBER_INTVL */
1490 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_MEMBERSHIP_INTVL */
1491 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERIER_INTVL */
1492 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_INTVL */
1493 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_QUERY_RESPONSE_INTVL */
1494 nla_total_size_64bit(sizeof(u64)) + /* IFLA_BR_MCAST_STARTUP_QUERY_INTVL */
Nikolay Aleksandrov5e923582016-11-21 13:03:24 +01001495 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_IGMP_VERSION */
Nikolay Aleksandrovaa2ae3e2016-11-21 13:03:25 +01001496 nla_total_size(sizeof(u8)) + /* IFLA_BR_MCAST_MLD_VERSION */
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001497#endif
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001498#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1499 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_IPTABLES */
1500 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_IP6TABLES */
1501 nla_total_size(sizeof(u8)) + /* IFLA_BR_NF_CALL_ARPTABLES */
1502#endif
Nikolay Aleksandrova428afe2018-11-24 04:34:20 +02001503 nla_total_size(sizeof(struct br_boolopt_multi)) + /* IFLA_BR_MULTI_BOOLOPT */
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001504 0;
1505}
1506
1507static int br_fill_info(struct sk_buff *skb, const struct net_device *brdev)
1508{
1509 struct net_bridge *br = netdev_priv(brdev);
1510 u32 forward_delay = jiffies_to_clock_t(br->forward_delay);
1511 u32 hello_time = jiffies_to_clock_t(br->hello_time);
1512 u32 age_time = jiffies_to_clock_t(br->max_age);
Jörg Thalheimaf615762015-03-18 10:06:58 +01001513 u32 ageing_time = jiffies_to_clock_t(br->ageing_time);
1514 u32 stp_enabled = br->stp_enabled;
1515 u16 priority = (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1];
Ido Schimmel1f514452017-05-26 08:37:23 +02001516 u8 vlan_enabled = br_vlan_enabled(br->dev);
Nikolay Aleksandrova428afe2018-11-24 04:34:20 +02001517 struct br_boolopt_multi bm;
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001518 u64 clockval;
Nikolay Aleksandrov5127c812015-10-04 14:23:29 +02001519
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001520 clockval = br_timer_value(&br->hello_timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001521 if (nla_put_u64_64bit(skb, IFLA_BR_HELLO_TIMER, clockval, IFLA_BR_PAD))
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001522 return -EMSGSIZE;
1523 clockval = br_timer_value(&br->tcn_timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001524 if (nla_put_u64_64bit(skb, IFLA_BR_TCN_TIMER, clockval, IFLA_BR_PAD))
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001525 return -EMSGSIZE;
1526 clockval = br_timer_value(&br->topology_change_timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001527 if (nla_put_u64_64bit(skb, IFLA_BR_TOPOLOGY_CHANGE_TIMER, clockval,
1528 IFLA_BR_PAD))
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001529 return -EMSGSIZE;
Nikolay Aleksandrovf7cdee82017-02-04 18:05:07 +01001530 clockval = br_timer_value(&br->gc_work.timer);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001531 if (nla_put_u64_64bit(skb, IFLA_BR_GC_TIMER, clockval, IFLA_BR_PAD))
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001532 return -EMSGSIZE;
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001533
Nikolay Aleksandrova428afe2018-11-24 04:34:20 +02001534 br_boolopt_multi_get(br, &bm);
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001535 if (nla_put_u32(skb, IFLA_BR_FORWARD_DELAY, forward_delay) ||
1536 nla_put_u32(skb, IFLA_BR_HELLO_TIME, hello_time) ||
Jörg Thalheimaf615762015-03-18 10:06:58 +01001537 nla_put_u32(skb, IFLA_BR_MAX_AGE, age_time) ||
1538 nla_put_u32(skb, IFLA_BR_AGEING_TIME, ageing_time) ||
1539 nla_put_u32(skb, IFLA_BR_STP_STATE, stp_enabled) ||
Nikolay Aleksandrova7854032015-08-07 19:40:45 +03001540 nla_put_u16(skb, IFLA_BR_PRIORITY, priority) ||
Nikolay Aleksandrov79102282015-10-04 14:23:28 +02001541 nla_put_u8(skb, IFLA_BR_VLAN_FILTERING, vlan_enabled) ||
Nikolay Aleksandrov4917a152015-10-05 12:11:21 +02001542 nla_put_u16(skb, IFLA_BR_GROUP_FWD_MASK, br->group_fwd_mask) ||
1543 nla_put(skb, IFLA_BR_BRIDGE_ID, sizeof(struct ifla_bridge_id),
1544 &br->bridge_id) ||
1545 nla_put(skb, IFLA_BR_ROOT_ID, sizeof(struct ifla_bridge_id),
1546 &br->designated_root) ||
Nikolay Aleksandrov684dd242015-10-04 14:23:32 +02001547 nla_put_u16(skb, IFLA_BR_ROOT_PORT, br->root_port) ||
Nikolay Aleksandroved416302015-10-04 14:23:33 +02001548 nla_put_u32(skb, IFLA_BR_ROOT_PATH_COST, br->root_path_cost) ||
1549 nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE, br->topology_change) ||
1550 nla_put_u8(skb, IFLA_BR_TOPOLOGY_CHANGE_DETECTED,
Nikolay Aleksandrovd76bd142015-10-04 14:23:34 +02001551 br->topology_change_detected) ||
Nikolay Aleksandrova428afe2018-11-24 04:34:20 +02001552 nla_put(skb, IFLA_BR_GROUP_ADDR, ETH_ALEN, br->group_addr) ||
1553 nla_put(skb, IFLA_BR_MULTI_BOOLOPT, sizeof(bm), &bm))
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001554 return -EMSGSIZE;
1555
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001556#ifdef CONFIG_BRIDGE_VLAN_FILTERING
Nikolay Aleksandrov0f963b72015-10-04 14:23:47 +02001557 if (nla_put_be16(skb, IFLA_BR_VLAN_PROTOCOL, br->vlan_proto) ||
Nikolay Aleksandrov6dada9b2016-04-30 10:25:28 +02001558 nla_put_u16(skb, IFLA_BR_VLAN_DEFAULT_PVID, br->default_pvid) ||
Nikolay Aleksandrovae757672018-09-26 17:01:00 +03001559 nla_put_u8(skb, IFLA_BR_VLAN_STATS_ENABLED,
Nikolay Aleksandrov9163a0f2018-10-12 13:41:16 +03001560 br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) ||
1561 nla_put_u8(skb, IFLA_BR_VLAN_STATS_PER_PORT,
Nikolay Aleksandrov600bea72019-04-16 16:15:56 +03001562 br_opt_get(br, BROPT_VLAN_STATS_PER_PORT)))
Toshiaki Makitad2d427b2015-08-27 15:32:26 +09001563 return -EMSGSIZE;
1564#endif
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001565#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
Nikolay Aleksandrov89126322015-10-04 14:23:38 +02001566 if (nla_put_u8(skb, IFLA_BR_MCAST_ROUTER, br->multicast_router) ||
Nikolay Aleksandrov13cefad2018-09-26 17:01:03 +03001567 nla_put_u8(skb, IFLA_BR_MCAST_SNOOPING,
1568 br_opt_get(br, BROPT_MULTICAST_ENABLED)) ||
Nikolay Aleksandrov295141d2015-10-04 14:23:39 +02001569 nla_put_u8(skb, IFLA_BR_MCAST_QUERY_USE_IFADDR,
Nikolay Aleksandrov675779a2018-09-26 17:01:04 +03001570 br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR)) ||
1571 nla_put_u8(skb, IFLA_BR_MCAST_QUERIER,
1572 br_opt_get(br, BROPT_MULTICAST_QUERIER)) ||
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001573 nla_put_u8(skb, IFLA_BR_MCAST_STATS_ENABLED,
Nikolay Aleksandrov675779a2018-09-26 17:01:04 +03001574 br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)) ||
Nikolay Aleksandrovcf332bca2018-12-05 15:14:26 +02001575 nla_put_u32(skb, IFLA_BR_MCAST_HASH_ELASTICITY, RHT_ELASTICITY) ||
Nikolay Aleksandrov79b859f2015-10-04 14:23:43 +02001576 nla_put_u32(skb, IFLA_BR_MCAST_HASH_MAX, br->hash_max) ||
1577 nla_put_u32(skb, IFLA_BR_MCAST_LAST_MEMBER_CNT,
Nikolay Aleksandrovb89e6ba2015-10-04 14:23:44 +02001578 br->multicast_last_member_count) ||
1579 nla_put_u32(skb, IFLA_BR_MCAST_STARTUP_QUERY_CNT,
Nikolay Aleksandrov5e923582016-11-21 13:03:24 +01001580 br->multicast_startup_query_count) ||
1581 nla_put_u8(skb, IFLA_BR_MCAST_IGMP_VERSION,
1582 br->multicast_igmp_version))
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001583 return -EMSGSIZE;
Nikolay Aleksandrovaa2ae3e2016-11-21 13:03:25 +01001584#if IS_ENABLED(CONFIG_IPV6)
1585 if (nla_put_u8(skb, IFLA_BR_MCAST_MLD_VERSION,
1586 br->multicast_mld_version))
1587 return -EMSGSIZE;
1588#endif
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001589 clockval = jiffies_to_clock_t(br->multicast_last_member_interval);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001590 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_LAST_MEMBER_INTVL, clockval,
1591 IFLA_BR_PAD))
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001592 return -EMSGSIZE;
1593 clockval = jiffies_to_clock_t(br->multicast_membership_interval);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001594 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_MEMBERSHIP_INTVL, clockval,
1595 IFLA_BR_PAD))
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001596 return -EMSGSIZE;
1597 clockval = jiffies_to_clock_t(br->multicast_querier_interval);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001598 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERIER_INTVL, clockval,
1599 IFLA_BR_PAD))
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001600 return -EMSGSIZE;
1601 clockval = jiffies_to_clock_t(br->multicast_query_interval);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001602 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_INTVL, clockval,
1603 IFLA_BR_PAD))
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001604 return -EMSGSIZE;
1605 clockval = jiffies_to_clock_t(br->multicast_query_response_interval);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001606 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, clockval,
1607 IFLA_BR_PAD))
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001608 return -EMSGSIZE;
1609 clockval = jiffies_to_clock_t(br->multicast_startup_query_interval);
Nicolas Dichtel12a0faa2016-04-25 10:25:18 +02001610 if (nla_put_u64_64bit(skb, IFLA_BR_MCAST_STARTUP_QUERY_INTVL, clockval,
1611 IFLA_BR_PAD))
Nikolay Aleksandrov7e4df512015-10-04 14:23:45 +02001612 return -EMSGSIZE;
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001613#endif
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001614#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1615 if (nla_put_u8(skb, IFLA_BR_NF_CALL_IPTABLES,
Nikolay Aleksandrov8df35102018-09-26 17:01:01 +03001616 br_opt_get(br, BROPT_NF_CALL_IPTABLES) ? 1 : 0) ||
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001617 nla_put_u8(skb, IFLA_BR_NF_CALL_IP6TABLES,
Nikolay Aleksandrov8df35102018-09-26 17:01:01 +03001618 br_opt_get(br, BROPT_NF_CALL_IP6TABLES) ? 1 : 0) ||
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001619 nla_put_u8(skb, IFLA_BR_NF_CALL_ARPTABLES,
Nikolay Aleksandrov8df35102018-09-26 17:01:01 +03001620 br_opt_get(br, BROPT_NF_CALL_ARPTABLES) ? 1 : 0))
Nikolay Aleksandrov93870cc2015-10-04 14:23:46 +02001621 return -EMSGSIZE;
1622#endif
Nikolay Aleksandrova9a6bc72015-10-04 14:23:37 +02001623
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001624 return 0;
1625}
1626
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001627static size_t br_get_linkxstats_size(const struct net_device *dev, int attr)
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001628{
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001629 struct net_bridge_port *p = NULL;
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001630 struct net_bridge_vlan_group *vg;
1631 struct net_bridge_vlan *v;
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001632 struct net_bridge *br;
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001633 int numvls = 0;
1634
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001635 switch (attr) {
1636 case IFLA_STATS_LINK_XSTATS:
1637 br = netdev_priv(dev);
1638 vg = br_vlan_group(br);
1639 break;
1640 case IFLA_STATS_LINK_XSTATS_SLAVE:
1641 p = br_port_get_rtnl(dev);
1642 if (!p)
1643 return 0;
1644 br = p->br;
1645 vg = nbp_vlan_group(p);
1646 break;
1647 default:
1648 return 0;
1649 }
1650
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001651 if (vg) {
1652 /* we need to count all, even placeholder entries */
1653 list_for_each_entry(v, &vg->vlan_list, vlist)
1654 numvls++;
1655 }
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001656
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001657 return numvls * nla_total_size(sizeof(struct bridge_vlan_xstats)) +
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001658 nla_total_size(sizeof(struct br_mcast_stats)) +
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001659 nla_total_size(0);
1660}
1661
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001662static int br_fill_linkxstats(struct sk_buff *skb,
1663 const struct net_device *dev,
1664 int *prividx, int attr)
Nikolay Aleksandrov80e73cc2016-06-28 16:57:05 +02001665{
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001666 struct nlattr *nla __maybe_unused;
1667 struct net_bridge_port *p = NULL;
1668 struct net_bridge_vlan_group *vg;
1669 struct net_bridge_vlan *v;
1670 struct net_bridge *br;
1671 struct nlattr *nest;
1672 int vl_idx = 0;
Nikolay Aleksandrov80e73cc2016-06-28 16:57:05 +02001673
1674 switch (attr) {
1675 case IFLA_STATS_LINK_XSTATS:
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001676 br = netdev_priv(dev);
1677 vg = br_vlan_group(br);
Nikolay Aleksandrov80e73cc2016-06-28 16:57:05 +02001678 break;
1679 case IFLA_STATS_LINK_XSTATS_SLAVE:
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001680 p = br_port_get_rtnl(dev);
1681 if (!p)
1682 return 0;
1683 br = p->br;
1684 vg = nbp_vlan_group(p);
Nikolay Aleksandrov80e73cc2016-06-28 16:57:05 +02001685 break;
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001686 default:
1687 return -EINVAL;
Nikolay Aleksandrov80e73cc2016-06-28 16:57:05 +02001688 }
1689
Michal Kubecekae0be8d2019-04-26 11:13:06 +02001690 nest = nla_nest_start_noflag(skb, LINK_XSTATS_TYPE_BRIDGE);
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001691 if (!nest)
1692 return -EMSGSIZE;
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001693
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001694 if (vg) {
Nikolay Aleksandrov72f4af42016-08-25 14:27:51 +02001695 u16 pvid;
1696
1697 pvid = br_get_pvid(vg);
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001698 list_for_each_entry(v, &vg->vlan_list, vlist) {
1699 struct bridge_vlan_xstats vxi;
Heiner Kallweit281cc282020-11-17 21:25:42 +01001700 struct pcpu_sw_netstats stats;
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001701
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001702 if (++vl_idx < *prividx)
1703 continue;
1704 memset(&vxi, 0, sizeof(vxi));
1705 vxi.vid = v->vid;
Nikolay Aleksandrov61ba1a22016-08-17 12:53:10 +02001706 vxi.flags = v->flags;
Nikolay Aleksandrov72f4af42016-08-25 14:27:51 +02001707 if (v->vid == pvid)
1708 vxi.flags |= BRIDGE_VLAN_INFO_PVID;
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001709 br_vlan_get_stats(v, &stats);
1710 vxi.rx_bytes = stats.rx_bytes;
1711 vxi.rx_packets = stats.rx_packets;
1712 vxi.tx_bytes = stats.tx_bytes;
1713 vxi.tx_packets = stats.tx_packets;
1714
1715 if (nla_put(skb, BRIDGE_XSTATS_VLAN, sizeof(vxi), &vxi))
1716 goto nla_put_failure;
1717 }
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001718 }
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001719
1720#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
1721 if (++vl_idx >= *prividx) {
1722 nla = nla_reserve_64bit(skb, BRIDGE_XSTATS_MCAST,
1723 sizeof(struct br_mcast_stats),
1724 BRIDGE_XSTATS_PAD);
1725 if (!nla)
1726 goto nla_put_failure;
Nikolay Aleksandrovd5ff8c42016-08-17 12:53:09 +02001727 br_multicast_get_stats(br, p, nla_data(nla));
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001728 }
1729#endif
Vivien Didelotde179962019-12-11 20:07:10 -05001730
1731 if (p) {
1732 nla = nla_reserve_64bit(skb, BRIDGE_XSTATS_STP,
1733 sizeof(p->stp_xstats),
1734 BRIDGE_XSTATS_PAD);
1735 if (!nla)
1736 goto nla_put_failure;
1737
1738 spin_lock_bh(&br->lock);
1739 memcpy(nla_data(nla), &p->stp_xstats, sizeof(p->stp_xstats));
1740 spin_unlock_bh(&br->lock);
1741 }
1742
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001743 nla_nest_end(skb, nest);
1744 *prividx = 0;
Nikolay Aleksandrov1080ab92016-06-28 16:57:06 +02001745
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001746 return 0;
1747
1748nla_put_failure:
1749 nla_nest_end(skb, nest);
1750 *prividx = vl_idx;
1751
1752 return -EMSGSIZE;
1753}
Roopa Prabhufed0a152015-02-25 23:55:40 -08001754
Daniel Borkmann207895fd32015-01-29 12:15:03 +01001755static struct rtnl_af_ops br_af_ops __read_mostly = {
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +00001756 .family = AF_BRIDGE,
Arad, Ronenb1974ed2015-10-19 09:23:28 -07001757 .get_link_af_size = br_get_link_af_size_filtered,
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +00001758};
1759
stephen hemminger149ddd82012-06-26 05:48:45 +00001760struct rtnl_link_ops br_link_ops __read_mostly = {
Jiri Pirkoced82832014-09-05 15:51:29 +02001761 .kind = "bridge",
1762 .priv_size = sizeof(struct net_bridge),
1763 .setup = br_dev_setup,
Scott Feldmaneb4cb852015-08-19 11:29:35 -07001764 .maxtype = IFLA_BR_MAX,
Jiri Pirko13323512014-09-05 15:51:32 +02001765 .policy = br_policy,
Jiri Pirkoced82832014-09-05 15:51:29 +02001766 .validate = br_validate,
1767 .newlink = br_dev_newlink,
Jiri Pirko13323512014-09-05 15:51:32 +02001768 .changelink = br_changelink,
Jiri Pirkoced82832014-09-05 15:51:29 +02001769 .dellink = br_dev_delete,
Jiri Pirkoe5c3ea52014-09-05 15:51:31 +02001770 .get_size = br_get_size,
1771 .fill_info = br_fill_info,
Nikolay Aleksandrova60c0902016-04-30 10:25:29 +02001772 .fill_linkxstats = br_fill_linkxstats,
1773 .get_linkxstats_size = br_get_linkxstats_size,
Jiri Pirko3ac636b2014-09-05 15:51:30 +02001774
1775 .slave_maxtype = IFLA_BRPORT_MAX,
1776 .slave_policy = br_port_policy,
1777 .slave_changelink = br_port_slave_changelink,
Jiri Pirkoced82832014-09-05 15:51:29 +02001778 .get_slave_size = br_port_get_slave_size,
1779 .fill_slave_info = br_port_fill_slave_info,
stephen hemmingerbb900b22011-04-04 14:03:32 +00001780};
1781
1782int __init br_netlink_init(void)
Stephen Hemminger11dc1f32006-05-25 16:00:12 -07001783{
Vlad Yasevich3ec8e9f2013-01-02 09:41:25 +00001784 int err;
1785
1786 br_mdb_init();
Nikolay Aleksandrov8dcea182020-01-14 19:56:09 +02001787 br_vlan_rtnl_init();
stephen hemminger3678a9d2013-12-30 10:41:32 -08001788 rtnl_af_register(&br_af_ops);
Vlad Yasevich3ec8e9f2013-01-02 09:41:25 +00001789
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +00001790 err = rtnl_link_register(&br_link_ops);
1791 if (err)
1792 goto out_af;
1793
Vlad Yasevich3ec8e9f2013-01-02 09:41:25 +00001794 return 0;
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +00001795
1796out_af:
1797 rtnl_af_unregister(&br_af_ops);
Vlad Yasevich3ec8e9f2013-01-02 09:41:25 +00001798 br_mdb_uninit();
1799 return err;
Stephen Hemminger11dc1f32006-05-25 16:00:12 -07001800}
1801
Pablo Neira Ayuso34666d42014-09-18 11:29:03 +02001802void br_netlink_fini(void)
stephen hemmingerbb900b22011-04-04 14:03:32 +00001803{
Vlad Yasevich3ec8e9f2013-01-02 09:41:25 +00001804 br_mdb_uninit();
Nikolay Aleksandrov8dcea182020-01-14 19:56:09 +02001805 br_vlan_rtnl_uninit();
Vlad Yasevich6cbdcee2013-02-13 12:00:13 +00001806 rtnl_af_unregister(&br_af_ops);
stephen hemmingerbb900b22011-04-04 14:03:32 +00001807 rtnl_link_unregister(&br_link_ops);
stephen hemmingerbb900b22011-04-04 14:03:32 +00001808}