1 /*
2  * drivers/net/bond/bond_netlink.c - Netlink interface for bonding
3  * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
4  * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  */
11 
12 #include <linux/module.h>
13 #include <linux/errno.h>
14 #include <linux/netdevice.h>
15 #include <linux/etherdevice.h>
16 #include <linux/if_link.h>
17 #include <linux/if_ether.h>
18 #include <net/netlink.h>
19 #include <net/rtnetlink.h>
20 #include <net/bonding.h>
21 
22 static size_t bond_get_slave_size(const struct net_device *bond_dev,
23 				  const struct net_device *slave_dev)
24 {
25 	return nla_total_size(sizeof(u8)) +	/* IFLA_BOND_SLAVE_STATE */
26 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_SLAVE_MII_STATUS */
27 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_SLAVE_LINK_FAILURE_COUNT */
28 		nla_total_size(MAX_ADDR_LEN) +	/* IFLA_BOND_SLAVE_PERM_HWADDR */
29 		nla_total_size(sizeof(u16)) +	/* IFLA_BOND_SLAVE_QUEUE_ID */
30 		nla_total_size(sizeof(u16)) +	/* IFLA_BOND_SLAVE_AD_AGGREGATOR_ID */
31 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE */
32 		nla_total_size(sizeof(u16)) +	/* IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE */
33 		0;
34 }
35 
36 static int bond_fill_slave_info(struct sk_buff *skb,
37 				const struct net_device *bond_dev,
38 				const struct net_device *slave_dev)
39 {
40 	struct slave *slave = bond_slave_get_rtnl(slave_dev);
41 
42 	if (nla_put_u8(skb, IFLA_BOND_SLAVE_STATE, bond_slave_state(slave)))
43 		goto nla_put_failure;
44 
45 	if (nla_put_u8(skb, IFLA_BOND_SLAVE_MII_STATUS, slave->link))
46 		goto nla_put_failure;
47 
48 	if (nla_put_u32(skb, IFLA_BOND_SLAVE_LINK_FAILURE_COUNT,
49 			slave->link_failure_count))
50 		goto nla_put_failure;
51 
52 	if (nla_put(skb, IFLA_BOND_SLAVE_PERM_HWADDR,
53 		    slave_dev->addr_len, slave->perm_hwaddr))
54 		goto nla_put_failure;
55 
56 	if (nla_put_u16(skb, IFLA_BOND_SLAVE_QUEUE_ID, slave->queue_id))
57 		goto nla_put_failure;
58 
59 	if (BOND_MODE(slave->bond) == BOND_MODE_8023AD) {
60 		const struct aggregator *agg;
61 		const struct port *ad_port;
62 
63 		ad_port = &SLAVE_AD_INFO(slave)->port;
64 		agg = SLAVE_AD_INFO(slave)->port.aggregator;
65 		if (agg) {
66 			if (nla_put_u16(skb, IFLA_BOND_SLAVE_AD_AGGREGATOR_ID,
67 					agg->aggregator_identifier))
68 				goto nla_put_failure;
69 			if (nla_put_u8(skb,
70 				       IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE,
71 				       ad_port->actor_oper_port_state))
72 				goto nla_put_failure;
73 			if (nla_put_u16(skb,
74 					IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE,
75 					ad_port->partner_oper.port_state))
76 				goto nla_put_failure;
77 		}
78 	}
79 
80 	return 0;
81 
82 nla_put_failure:
83 	return -EMSGSIZE;
84 }
85 
86 static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = {
87 	[IFLA_BOND_MODE]		= { .type = NLA_U8 },
88 	[IFLA_BOND_ACTIVE_SLAVE]	= { .type = NLA_U32 },
89 	[IFLA_BOND_MIIMON]		= { .type = NLA_U32 },
90 	[IFLA_BOND_UPDELAY]		= { .type = NLA_U32 },
91 	[IFLA_BOND_DOWNDELAY]		= { .type = NLA_U32 },
92 	[IFLA_BOND_USE_CARRIER]		= { .type = NLA_U8 },
93 	[IFLA_BOND_ARP_INTERVAL]	= { .type = NLA_U32 },
94 	[IFLA_BOND_ARP_IP_TARGET]	= { .type = NLA_NESTED },
95 	[IFLA_BOND_ARP_VALIDATE]	= { .type = NLA_U32 },
96 	[IFLA_BOND_ARP_ALL_TARGETS]	= { .type = NLA_U32 },
97 	[IFLA_BOND_PRIMARY]		= { .type = NLA_U32 },
98 	[IFLA_BOND_PRIMARY_RESELECT]	= { .type = NLA_U8 },
99 	[IFLA_BOND_FAIL_OVER_MAC]	= { .type = NLA_U8 },
100 	[IFLA_BOND_XMIT_HASH_POLICY]	= { .type = NLA_U8 },
101 	[IFLA_BOND_RESEND_IGMP]		= { .type = NLA_U32 },
102 	[IFLA_BOND_NUM_PEER_NOTIF]	= { .type = NLA_U8 },
103 	[IFLA_BOND_ALL_SLAVES_ACTIVE]	= { .type = NLA_U8 },
104 	[IFLA_BOND_MIN_LINKS]		= { .type = NLA_U32 },
105 	[IFLA_BOND_LP_INTERVAL]		= { .type = NLA_U32 },
106 	[IFLA_BOND_PACKETS_PER_SLAVE]	= { .type = NLA_U32 },
107 	[IFLA_BOND_AD_LACP_RATE]	= { .type = NLA_U8 },
108 	[IFLA_BOND_AD_SELECT]		= { .type = NLA_U8 },
109 	[IFLA_BOND_AD_INFO]		= { .type = NLA_NESTED },
110 	[IFLA_BOND_AD_ACTOR_SYS_PRIO]	= { .type = NLA_U16 },
111 	[IFLA_BOND_AD_USER_PORT_KEY]	= { .type = NLA_U16 },
112 	[IFLA_BOND_AD_ACTOR_SYSTEM]	= { .type = NLA_BINARY,
113 					    .len  = ETH_ALEN },
114 	[IFLA_BOND_TLB_DYNAMIC_LB]	= { .type = NLA_U8 },
115 };
116 
117 static const struct nla_policy bond_slave_policy[IFLA_BOND_SLAVE_MAX + 1] = {
118 	[IFLA_BOND_SLAVE_QUEUE_ID]	= { .type = NLA_U16 },
119 };
120 
121 static int bond_validate(struct nlattr *tb[], struct nlattr *data[],
122 			 struct netlink_ext_ack *extack)
123 {
124 	if (tb[IFLA_ADDRESS]) {
125 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
126 			return -EINVAL;
127 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
128 			return -EADDRNOTAVAIL;
129 	}
130 	return 0;
131 }
132 
133 static int bond_slave_changelink(struct net_device *bond_dev,
134 				 struct net_device *slave_dev,
135 				 struct nlattr *tb[], struct nlattr *data[],
136 				 struct netlink_ext_ack *extack)
137 {
138 	struct bonding *bond = netdev_priv(bond_dev);
139 	struct bond_opt_value newval;
140 	int err;
141 
142 	if (!data)
143 		return 0;
144 
145 	if (data[IFLA_BOND_SLAVE_QUEUE_ID]) {
146 		u16 queue_id = nla_get_u16(data[IFLA_BOND_SLAVE_QUEUE_ID]);
147 		char queue_id_str[IFNAMSIZ + 7];
148 
149 		/* queue_id option setting expects slave_name:queue_id */
150 		snprintf(queue_id_str, sizeof(queue_id_str), "%s:%u\n",
151 			 slave_dev->name, queue_id);
152 		bond_opt_initstr(&newval, queue_id_str);
153 		err = __bond_opt_set(bond, BOND_OPT_QUEUE_ID, &newval);
154 		if (err)
155 			return err;
156 	}
157 
158 	return 0;
159 }
160 
161 static int bond_changelink(struct net_device *bond_dev, struct nlattr *tb[],
162 			   struct nlattr *data[],
163 			   struct netlink_ext_ack *extack)
164 {
165 	struct bonding *bond = netdev_priv(bond_dev);
166 	struct bond_opt_value newval;
167 	int miimon = 0;
168 	int err;
169 
170 	if (!data)
171 		return 0;
172 
173 	if (data[IFLA_BOND_MODE]) {
174 		int mode = nla_get_u8(data[IFLA_BOND_MODE]);
175 
176 		bond_opt_initval(&newval, mode);
177 		err = __bond_opt_set(bond, BOND_OPT_MODE, &newval);
178 		if (err)
179 			return err;
180 	}
181 	if (data[IFLA_BOND_ACTIVE_SLAVE]) {
182 		int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]);
183 		struct net_device *slave_dev;
184 		char *active_slave = "";
185 
186 		if (ifindex != 0) {
187 			slave_dev = __dev_get_by_index(dev_net(bond_dev),
188 						       ifindex);
189 			if (!slave_dev)
190 				return -ENODEV;
191 			active_slave = slave_dev->name;
192 		}
193 		bond_opt_initstr(&newval, active_slave);
194 		err = __bond_opt_set(bond, BOND_OPT_ACTIVE_SLAVE, &newval);
195 		if (err)
196 			return err;
197 	}
198 	if (data[IFLA_BOND_MIIMON]) {
199 		miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);
200 
201 		bond_opt_initval(&newval, miimon);
202 		err = __bond_opt_set(bond, BOND_OPT_MIIMON, &newval);
203 		if (err)
204 			return err;
205 	}
206 	if (data[IFLA_BOND_UPDELAY]) {
207 		int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);
208 
209 		bond_opt_initval(&newval, updelay);
210 		err = __bond_opt_set(bond, BOND_OPT_UPDELAY, &newval);
211 		if (err)
212 			return err;
213 	}
214 	if (data[IFLA_BOND_DOWNDELAY]) {
215 		int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);
216 
217 		bond_opt_initval(&newval, downdelay);
218 		err = __bond_opt_set(bond, BOND_OPT_DOWNDELAY, &newval);
219 		if (err)
220 			return err;
221 	}
222 	if (data[IFLA_BOND_USE_CARRIER]) {
223 		int use_carrier = nla_get_u8(data[IFLA_BOND_USE_CARRIER]);
224 
225 		bond_opt_initval(&newval, use_carrier);
226 		err = __bond_opt_set(bond, BOND_OPT_USE_CARRIER, &newval);
227 		if (err)
228 			return err;
229 	}
230 	if (data[IFLA_BOND_ARP_INTERVAL]) {
231 		int arp_interval = nla_get_u32(data[IFLA_BOND_ARP_INTERVAL]);
232 
233 		if (arp_interval && miimon) {
234 			netdev_err(bond->dev, "ARP monitoring cannot be used with MII monitoring\n");
235 			return -EINVAL;
236 		}
237 
238 		bond_opt_initval(&newval, arp_interval);
239 		err = __bond_opt_set(bond, BOND_OPT_ARP_INTERVAL, &newval);
240 		if (err)
241 			return err;
242 	}
243 	if (data[IFLA_BOND_ARP_IP_TARGET]) {
244 		struct nlattr *attr;
245 		int i = 0, rem;
246 
247 		bond_option_arp_ip_targets_clear(bond);
248 		nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
249 			__be32 target;
250 
251 			if (nla_len(attr) < sizeof(target))
252 				return -EINVAL;
253 
254 			target = nla_get_be32(attr);
255 
256 			bond_opt_initval(&newval, (__force u64)target);
257 			err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
258 					     &newval);
259 			if (err)
260 				break;
261 			i++;
262 		}
263 		if (i == 0 && bond->params.arp_interval)
264 			netdev_warn(bond->dev, "Removing last arp target with arp_interval on\n");
265 		if (err)
266 			return err;
267 	}
268 	if (data[IFLA_BOND_ARP_VALIDATE]) {
269 		int arp_validate = nla_get_u32(data[IFLA_BOND_ARP_VALIDATE]);
270 
271 		if (arp_validate && miimon) {
272 			netdev_err(bond->dev, "ARP validating cannot be used with MII monitoring\n");
273 			return -EINVAL;
274 		}
275 
276 		bond_opt_initval(&newval, arp_validate);
277 		err = __bond_opt_set(bond, BOND_OPT_ARP_VALIDATE, &newval);
278 		if (err)
279 			return err;
280 	}
281 	if (data[IFLA_BOND_ARP_ALL_TARGETS]) {
282 		int arp_all_targets =
283 			nla_get_u32(data[IFLA_BOND_ARP_ALL_TARGETS]);
284 
285 		bond_opt_initval(&newval, arp_all_targets);
286 		err = __bond_opt_set(bond, BOND_OPT_ARP_ALL_TARGETS, &newval);
287 		if (err)
288 			return err;
289 	}
290 	if (data[IFLA_BOND_PRIMARY]) {
291 		int ifindex = nla_get_u32(data[IFLA_BOND_PRIMARY]);
292 		struct net_device *dev;
293 		char *primary = "";
294 
295 		dev = __dev_get_by_index(dev_net(bond_dev), ifindex);
296 		if (dev)
297 			primary = dev->name;
298 
299 		bond_opt_initstr(&newval, primary);
300 		err = __bond_opt_set(bond, BOND_OPT_PRIMARY, &newval);
301 		if (err)
302 			return err;
303 	}
304 	if (data[IFLA_BOND_PRIMARY_RESELECT]) {
305 		int primary_reselect =
306 			nla_get_u8(data[IFLA_BOND_PRIMARY_RESELECT]);
307 
308 		bond_opt_initval(&newval, primary_reselect);
309 		err = __bond_opt_set(bond, BOND_OPT_PRIMARY_RESELECT, &newval);
310 		if (err)
311 			return err;
312 	}
313 	if (data[IFLA_BOND_FAIL_OVER_MAC]) {
314 		int fail_over_mac =
315 			nla_get_u8(data[IFLA_BOND_FAIL_OVER_MAC]);
316 
317 		bond_opt_initval(&newval, fail_over_mac);
318 		err = __bond_opt_set(bond, BOND_OPT_FAIL_OVER_MAC, &newval);
319 		if (err)
320 			return err;
321 	}
322 	if (data[IFLA_BOND_XMIT_HASH_POLICY]) {
323 		int xmit_hash_policy =
324 			nla_get_u8(data[IFLA_BOND_XMIT_HASH_POLICY]);
325 
326 		bond_opt_initval(&newval, xmit_hash_policy);
327 		err = __bond_opt_set(bond, BOND_OPT_XMIT_HASH, &newval);
328 		if (err)
329 			return err;
330 	}
331 	if (data[IFLA_BOND_RESEND_IGMP]) {
332 		int resend_igmp =
333 			nla_get_u32(data[IFLA_BOND_RESEND_IGMP]);
334 
335 		bond_opt_initval(&newval, resend_igmp);
336 		err = __bond_opt_set(bond, BOND_OPT_RESEND_IGMP, &newval);
337 		if (err)
338 			return err;
339 	}
340 	if (data[IFLA_BOND_NUM_PEER_NOTIF]) {
341 		int num_peer_notif =
342 			nla_get_u8(data[IFLA_BOND_NUM_PEER_NOTIF]);
343 
344 		bond_opt_initval(&newval, num_peer_notif);
345 		err = __bond_opt_set(bond, BOND_OPT_NUM_PEER_NOTIF, &newval);
346 		if (err)
347 			return err;
348 	}
349 	if (data[IFLA_BOND_ALL_SLAVES_ACTIVE]) {
350 		int all_slaves_active =
351 			nla_get_u8(data[IFLA_BOND_ALL_SLAVES_ACTIVE]);
352 
353 		bond_opt_initval(&newval, all_slaves_active);
354 		err = __bond_opt_set(bond, BOND_OPT_ALL_SLAVES_ACTIVE, &newval);
355 		if (err)
356 			return err;
357 	}
358 	if (data[IFLA_BOND_MIN_LINKS]) {
359 		int min_links =
360 			nla_get_u32(data[IFLA_BOND_MIN_LINKS]);
361 
362 		bond_opt_initval(&newval, min_links);
363 		err = __bond_opt_set(bond, BOND_OPT_MINLINKS, &newval);
364 		if (err)
365 			return err;
366 	}
367 	if (data[IFLA_BOND_LP_INTERVAL]) {
368 		int lp_interval =
369 			nla_get_u32(data[IFLA_BOND_LP_INTERVAL]);
370 
371 		bond_opt_initval(&newval, lp_interval);
372 		err = __bond_opt_set(bond, BOND_OPT_LP_INTERVAL, &newval);
373 		if (err)
374 			return err;
375 	}
376 	if (data[IFLA_BOND_PACKETS_PER_SLAVE]) {
377 		int packets_per_slave =
378 			nla_get_u32(data[IFLA_BOND_PACKETS_PER_SLAVE]);
379 
380 		bond_opt_initval(&newval, packets_per_slave);
381 		err = __bond_opt_set(bond, BOND_OPT_PACKETS_PER_SLAVE, &newval);
382 		if (err)
383 			return err;
384 	}
385 	if (data[IFLA_BOND_AD_LACP_RATE]) {
386 		int lacp_rate =
387 			nla_get_u8(data[IFLA_BOND_AD_LACP_RATE]);
388 
389 		bond_opt_initval(&newval, lacp_rate);
390 		err = __bond_opt_set(bond, BOND_OPT_LACP_RATE, &newval);
391 		if (err)
392 			return err;
393 	}
394 	if (data[IFLA_BOND_AD_SELECT]) {
395 		int ad_select =
396 			nla_get_u8(data[IFLA_BOND_AD_SELECT]);
397 
398 		bond_opt_initval(&newval, ad_select);
399 		err = __bond_opt_set(bond, BOND_OPT_AD_SELECT, &newval);
400 		if (err)
401 			return err;
402 	}
403 	if (data[IFLA_BOND_AD_ACTOR_SYS_PRIO]) {
404 		int actor_sys_prio =
405 			nla_get_u16(data[IFLA_BOND_AD_ACTOR_SYS_PRIO]);
406 
407 		bond_opt_initval(&newval, actor_sys_prio);
408 		err = __bond_opt_set(bond, BOND_OPT_AD_ACTOR_SYS_PRIO, &newval);
409 		if (err)
410 			return err;
411 	}
412 	if (data[IFLA_BOND_AD_USER_PORT_KEY]) {
413 		int port_key =
414 			nla_get_u16(data[IFLA_BOND_AD_USER_PORT_KEY]);
415 
416 		bond_opt_initval(&newval, port_key);
417 		err = __bond_opt_set(bond, BOND_OPT_AD_USER_PORT_KEY, &newval);
418 		if (err)
419 			return err;
420 	}
421 	if (data[IFLA_BOND_AD_ACTOR_SYSTEM]) {
422 		if (nla_len(data[IFLA_BOND_AD_ACTOR_SYSTEM]) != ETH_ALEN)
423 			return -EINVAL;
424 
425 		bond_opt_initval(&newval,
426 				 nla_get_u64(data[IFLA_BOND_AD_ACTOR_SYSTEM]));
427 		err = __bond_opt_set(bond, BOND_OPT_AD_ACTOR_SYSTEM, &newval);
428 		if (err)
429 			return err;
430 	}
431 	if (data[IFLA_BOND_TLB_DYNAMIC_LB]) {
432 		int dynamic_lb = nla_get_u8(data[IFLA_BOND_TLB_DYNAMIC_LB]);
433 
434 		bond_opt_initval(&newval, dynamic_lb);
435 		err = __bond_opt_set(bond, BOND_OPT_TLB_DYNAMIC_LB, &newval);
436 		if (err)
437 			return err;
438 	}
439 
440 	return 0;
441 }
442 
443 static int bond_newlink(struct net *src_net, struct net_device *bond_dev,
444 			struct nlattr *tb[], struct nlattr *data[],
445 			struct netlink_ext_ack *extack)
446 {
447 	int err;
448 
449 	err = bond_changelink(bond_dev, tb, data, extack);
450 	if (err < 0)
451 		return err;
452 
453 	err = register_netdevice(bond_dev);
454 
455 	netif_carrier_off(bond_dev);
456 	if (!err) {
457 		struct bonding *bond = netdev_priv(bond_dev);
458 
459 		bond_work_init_all(bond);
460 	}
461 
462 	return err;
463 }
464 
465 static size_t bond_get_size(const struct net_device *bond_dev)
466 {
467 	return nla_total_size(sizeof(u8)) +	/* IFLA_BOND_MODE */
468 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ACTIVE_SLAVE */
469 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_MIIMON */
470 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_UPDELAY */
471 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_DOWNDELAY */
472 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_USE_CARRIER */
473 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_INTERVAL */
474 						/* IFLA_BOND_ARP_IP_TARGET */
475 		nla_total_size(sizeof(struct nlattr)) +
476 		nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS +
477 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_VALIDATE */
478 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_ALL_TARGETS */
479 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_PRIMARY */
480 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_PRIMARY_RESELECT */
481 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_FAIL_OVER_MAC */
482 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_XMIT_HASH_POLICY */
483 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_RESEND_IGMP */
484 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_NUM_PEER_NOTIF */
485 		nla_total_size(sizeof(u8)) +   /* IFLA_BOND_ALL_SLAVES_ACTIVE */
486 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_MIN_LINKS */
487 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_LP_INTERVAL */
488 		nla_total_size(sizeof(u32)) +  /* IFLA_BOND_PACKETS_PER_SLAVE */
489 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_AD_LACP_RATE */
490 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_AD_SELECT */
491 		nla_total_size(sizeof(struct nlattr)) + /* IFLA_BOND_AD_INFO */
492 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_AGGREGATOR */
493 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_NUM_PORTS */
494 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_ACTOR_KEY */
495 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_PARTNER_KEY*/
496 		nla_total_size(ETH_ALEN) +    /* IFLA_BOND_AD_INFO_PARTNER_MAC*/
497 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_ACTOR_SYS_PRIO */
498 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_USER_PORT_KEY */
499 		nla_total_size(ETH_ALEN) + /* IFLA_BOND_AD_ACTOR_SYSTEM */
500 		nla_total_size(sizeof(u8)) + /* IFLA_BOND_TLB_DYNAMIC_LB */
501 		0;
502 }
503 
504 static int bond_option_active_slave_get_ifindex(struct bonding *bond)
505 {
506 	const struct net_device *slave;
507 	int ifindex;
508 
509 	rcu_read_lock();
510 	slave = bond_option_active_slave_get_rcu(bond);
511 	ifindex = slave ? slave->ifindex : 0;
512 	rcu_read_unlock();
513 	return ifindex;
514 }
515 
516 static int bond_fill_info(struct sk_buff *skb,
517 			  const struct net_device *bond_dev)
518 {
519 	struct bonding *bond = netdev_priv(bond_dev);
520 	unsigned int packets_per_slave;
521 	int ifindex, i, targets_added;
522 	struct nlattr *targets;
523 	struct slave *primary;
524 
525 	if (nla_put_u8(skb, IFLA_BOND_MODE, BOND_MODE(bond)))
526 		goto nla_put_failure;
527 
528 	ifindex = bond_option_active_slave_get_ifindex(bond);
529 	if (ifindex && nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, ifindex))
530 		goto nla_put_failure;
531 
532 	if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
533 		goto nla_put_failure;
534 
535 	if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
536 			bond->params.updelay * bond->params.miimon))
537 		goto nla_put_failure;
538 
539 	if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
540 			bond->params.downdelay * bond->params.miimon))
541 		goto nla_put_failure;
542 
543 	if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier))
544 		goto nla_put_failure;
545 
546 	if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval))
547 		goto nla_put_failure;
548 
549 	targets = nla_nest_start(skb, IFLA_BOND_ARP_IP_TARGET);
550 	if (!targets)
551 		goto nla_put_failure;
552 
553 	targets_added = 0;
554 	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
555 		if (bond->params.arp_targets[i]) {
556 			if (nla_put_be32(skb, i, bond->params.arp_targets[i]))
557 				goto nla_put_failure;
558 			targets_added = 1;
559 		}
560 	}
561 
562 	if (targets_added)
563 		nla_nest_end(skb, targets);
564 	else
565 		nla_nest_cancel(skb, targets);
566 
567 	if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate))
568 		goto nla_put_failure;
569 
570 	if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS,
571 			bond->params.arp_all_targets))
572 		goto nla_put_failure;
573 
574 	primary = rtnl_dereference(bond->primary_slave);
575 	if (primary &&
576 	    nla_put_u32(skb, IFLA_BOND_PRIMARY, primary->dev->ifindex))
577 		goto nla_put_failure;
578 
579 	if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT,
580 		       bond->params.primary_reselect))
581 		goto nla_put_failure;
582 
583 	if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC,
584 		       bond->params.fail_over_mac))
585 		goto nla_put_failure;
586 
587 	if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY,
588 		       bond->params.xmit_policy))
589 		goto nla_put_failure;
590 
591 	if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP,
592 		        bond->params.resend_igmp))
593 		goto nla_put_failure;
594 
595 	if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF,
596 		       bond->params.num_peer_notif))
597 		goto nla_put_failure;
598 
599 	if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE,
600 		       bond->params.all_slaves_active))
601 		goto nla_put_failure;
602 
603 	if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS,
604 			bond->params.min_links))
605 		goto nla_put_failure;
606 
607 	if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL,
608 			bond->params.lp_interval))
609 		goto nla_put_failure;
610 
611 	packets_per_slave = bond->params.packets_per_slave;
612 	if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE,
613 			packets_per_slave))
614 		goto nla_put_failure;
615 
616 	if (nla_put_u8(skb, IFLA_BOND_AD_LACP_RATE,
617 		       bond->params.lacp_fast))
618 		goto nla_put_failure;
619 
620 	if (nla_put_u8(skb, IFLA_BOND_AD_SELECT,
621 		       bond->params.ad_select))
622 		goto nla_put_failure;
623 
624 	if (nla_put_u8(skb, IFLA_BOND_TLB_DYNAMIC_LB,
625 		       bond->params.tlb_dynamic_lb))
626 		goto nla_put_failure;
627 
628 	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
629 		struct ad_info info;
630 
631 		if (capable(CAP_NET_ADMIN)) {
632 			if (nla_put_u16(skb, IFLA_BOND_AD_ACTOR_SYS_PRIO,
633 					bond->params.ad_actor_sys_prio))
634 				goto nla_put_failure;
635 
636 			if (nla_put_u16(skb, IFLA_BOND_AD_USER_PORT_KEY,
637 					bond->params.ad_user_port_key))
638 				goto nla_put_failure;
639 
640 			if (nla_put(skb, IFLA_BOND_AD_ACTOR_SYSTEM,
641 				    ETH_ALEN, &bond->params.ad_actor_system))
642 				goto nla_put_failure;
643 		}
644 		if (!bond_3ad_get_active_agg_info(bond, &info)) {
645 			struct nlattr *nest;
646 
647 			nest = nla_nest_start(skb, IFLA_BOND_AD_INFO);
648 			if (!nest)
649 				goto nla_put_failure;
650 
651 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_AGGREGATOR,
652 					info.aggregator_id))
653 				goto nla_put_failure;
654 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_NUM_PORTS,
655 					info.ports))
656 				goto nla_put_failure;
657 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_ACTOR_KEY,
658 					info.actor_key))
659 				goto nla_put_failure;
660 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_PARTNER_KEY,
661 					info.partner_key))
662 				goto nla_put_failure;
663 			if (nla_put(skb, IFLA_BOND_AD_INFO_PARTNER_MAC,
664 				    sizeof(info.partner_system),
665 				    &info.partner_system))
666 				goto nla_put_failure;
667 
668 			nla_nest_end(skb, nest);
669 		}
670 	}
671 
672 	return 0;
673 
674 nla_put_failure:
675 	return -EMSGSIZE;
676 }
677 
678 static size_t bond_get_linkxstats_size(const struct net_device *dev, int attr)
679 {
680 	switch (attr) {
681 	case IFLA_STATS_LINK_XSTATS:
682 	case IFLA_STATS_LINK_XSTATS_SLAVE:
683 		break;
684 	default:
685 		return 0;
686 	}
687 
688 	return bond_3ad_stats_size() + nla_total_size(0);
689 }
690 
691 static int bond_fill_linkxstats(struct sk_buff *skb,
692 				const struct net_device *dev,
693 				int *prividx, int attr)
694 {
695 	struct nlattr *nla __maybe_unused;
696 	struct slave *slave = NULL;
697 	struct nlattr *nest, *nest2;
698 	struct bonding *bond;
699 
700 	switch (attr) {
701 	case IFLA_STATS_LINK_XSTATS:
702 		bond = netdev_priv(dev);
703 		break;
704 	case IFLA_STATS_LINK_XSTATS_SLAVE:
705 		slave = bond_slave_get_rtnl(dev);
706 		if (!slave)
707 			return 0;
708 		bond = slave->bond;
709 		break;
710 	default:
711 		return -EINVAL;
712 	}
713 
714 	nest = nla_nest_start(skb, LINK_XSTATS_TYPE_BOND);
715 	if (!nest)
716 		return -EMSGSIZE;
717 	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
718 		struct bond_3ad_stats *stats;
719 
720 		if (slave)
721 			stats = &SLAVE_AD_INFO(slave)->stats;
722 		else
723 			stats = &BOND_AD_INFO(bond).stats;
724 
725 		nest2 = nla_nest_start(skb, BOND_XSTATS_3AD);
726 		if (!nest2) {
727 			nla_nest_end(skb, nest);
728 			return -EMSGSIZE;
729 		}
730 
731 		if (bond_3ad_stats_fill(skb, stats)) {
732 			nla_nest_cancel(skb, nest2);
733 			nla_nest_end(skb, nest);
734 			return -EMSGSIZE;
735 		}
736 		nla_nest_end(skb, nest2);
737 	}
738 	nla_nest_end(skb, nest);
739 
740 	return 0;
741 }
742 
743 struct rtnl_link_ops bond_link_ops __read_mostly = {
744 	.kind			= "bond",
745 	.priv_size		= sizeof(struct bonding),
746 	.setup			= bond_setup,
747 	.maxtype		= IFLA_BOND_MAX,
748 	.policy			= bond_policy,
749 	.validate		= bond_validate,
750 	.newlink		= bond_newlink,
751 	.changelink		= bond_changelink,
752 	.get_size		= bond_get_size,
753 	.fill_info		= bond_fill_info,
754 	.get_num_tx_queues	= bond_get_num_tx_queues,
755 	.get_num_rx_queues	= bond_get_num_tx_queues, /* Use the same number
756 							     as for TX queues */
757 	.fill_linkxstats        = bond_fill_linkxstats,
758 	.get_linkxstats_size    = bond_get_linkxstats_size,
759 	.slave_maxtype		= IFLA_BOND_SLAVE_MAX,
760 	.slave_policy		= bond_slave_policy,
761 	.slave_changelink	= bond_slave_changelink,
762 	.get_slave_size		= bond_get_slave_size,
763 	.fill_slave_info	= bond_fill_slave_info,
764 };
765 
766 int __init bond_netlink_init(void)
767 {
768 	return rtnl_link_register(&bond_link_ops);
769 }
770 
771 void bond_netlink_fini(void)
772 {
773 	rtnl_link_unregister(&bond_link_ops);
774 }
775 
776 MODULE_ALIAS_RTNL_LINK("bond");
777