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 		0;
32 }
33 
34 static int bond_fill_slave_info(struct sk_buff *skb,
35 				const struct net_device *bond_dev,
36 				const struct net_device *slave_dev)
37 {
38 	struct slave *slave = bond_slave_get_rtnl(slave_dev);
39 
40 	if (nla_put_u8(skb, IFLA_BOND_SLAVE_STATE, bond_slave_state(slave)))
41 		goto nla_put_failure;
42 
43 	if (nla_put_u8(skb, IFLA_BOND_SLAVE_MII_STATUS, slave->link))
44 		goto nla_put_failure;
45 
46 	if (nla_put_u32(skb, IFLA_BOND_SLAVE_LINK_FAILURE_COUNT,
47 			slave->link_failure_count))
48 		goto nla_put_failure;
49 
50 	if (nla_put(skb, IFLA_BOND_SLAVE_PERM_HWADDR,
51 		    slave_dev->addr_len, slave->perm_hwaddr))
52 		goto nla_put_failure;
53 
54 	if (nla_put_u16(skb, IFLA_BOND_SLAVE_QUEUE_ID, slave->queue_id))
55 		goto nla_put_failure;
56 
57 	if (BOND_MODE(slave->bond) == BOND_MODE_8023AD) {
58 		const struct aggregator *agg;
59 
60 		agg = SLAVE_AD_INFO(slave)->port.aggregator;
61 		if (agg)
62 			if (nla_put_u16(skb, IFLA_BOND_SLAVE_AD_AGGREGATOR_ID,
63 					agg->aggregator_identifier))
64 				goto nla_put_failure;
65 	}
66 
67 	return 0;
68 
69 nla_put_failure:
70 	return -EMSGSIZE;
71 }
72 
73 static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = {
74 	[IFLA_BOND_MODE]		= { .type = NLA_U8 },
75 	[IFLA_BOND_ACTIVE_SLAVE]	= { .type = NLA_U32 },
76 	[IFLA_BOND_MIIMON]		= { .type = NLA_U32 },
77 	[IFLA_BOND_UPDELAY]		= { .type = NLA_U32 },
78 	[IFLA_BOND_DOWNDELAY]		= { .type = NLA_U32 },
79 	[IFLA_BOND_USE_CARRIER]		= { .type = NLA_U8 },
80 	[IFLA_BOND_ARP_INTERVAL]	= { .type = NLA_U32 },
81 	[IFLA_BOND_ARP_IP_TARGET]	= { .type = NLA_NESTED },
82 	[IFLA_BOND_ARP_VALIDATE]	= { .type = NLA_U32 },
83 	[IFLA_BOND_ARP_ALL_TARGETS]	= { .type = NLA_U32 },
84 	[IFLA_BOND_PRIMARY]		= { .type = NLA_U32 },
85 	[IFLA_BOND_PRIMARY_RESELECT]	= { .type = NLA_U8 },
86 	[IFLA_BOND_FAIL_OVER_MAC]	= { .type = NLA_U8 },
87 	[IFLA_BOND_XMIT_HASH_POLICY]	= { .type = NLA_U8 },
88 	[IFLA_BOND_RESEND_IGMP]		= { .type = NLA_U32 },
89 	[IFLA_BOND_NUM_PEER_NOTIF]	= { .type = NLA_U8 },
90 	[IFLA_BOND_ALL_SLAVES_ACTIVE]	= { .type = NLA_U8 },
91 	[IFLA_BOND_MIN_LINKS]		= { .type = NLA_U32 },
92 	[IFLA_BOND_LP_INTERVAL]		= { .type = NLA_U32 },
93 	[IFLA_BOND_PACKETS_PER_SLAVE]	= { .type = NLA_U32 },
94 	[IFLA_BOND_AD_LACP_RATE]	= { .type = NLA_U8 },
95 	[IFLA_BOND_AD_SELECT]		= { .type = NLA_U8 },
96 	[IFLA_BOND_AD_INFO]		= { .type = NLA_NESTED },
97 };
98 
99 static const struct nla_policy bond_slave_policy[IFLA_BOND_SLAVE_MAX + 1] = {
100 	[IFLA_BOND_SLAVE_QUEUE_ID]	= { .type = NLA_U16 },
101 };
102 
103 static int bond_validate(struct nlattr *tb[], struct nlattr *data[])
104 {
105 	if (tb[IFLA_ADDRESS]) {
106 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
107 			return -EINVAL;
108 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
109 			return -EADDRNOTAVAIL;
110 	}
111 	return 0;
112 }
113 
114 static int bond_slave_changelink(struct net_device *bond_dev,
115 				 struct net_device *slave_dev,
116 				 struct nlattr *tb[], struct nlattr *data[])
117 {
118 	struct bonding *bond = netdev_priv(bond_dev);
119 	struct bond_opt_value newval;
120 	int err;
121 
122 	if (!data)
123 		return 0;
124 
125 	if (data[IFLA_BOND_SLAVE_QUEUE_ID]) {
126 		u16 queue_id = nla_get_u16(data[IFLA_BOND_SLAVE_QUEUE_ID]);
127 		char queue_id_str[IFNAMSIZ + 7];
128 
129 		/* queue_id option setting expects slave_name:queue_id */
130 		snprintf(queue_id_str, sizeof(queue_id_str), "%s:%u\n",
131 			 slave_dev->name, queue_id);
132 		bond_opt_initstr(&newval, queue_id_str);
133 		err = __bond_opt_set(bond, BOND_OPT_QUEUE_ID, &newval);
134 		if (err)
135 			return err;
136 	}
137 
138 	return 0;
139 }
140 
141 static int bond_changelink(struct net_device *bond_dev,
142 			   struct nlattr *tb[], struct nlattr *data[])
143 {
144 	struct bonding *bond = netdev_priv(bond_dev);
145 	struct bond_opt_value newval;
146 	int miimon = 0;
147 	int err;
148 
149 	if (!data)
150 		return 0;
151 
152 	if (data[IFLA_BOND_MODE]) {
153 		int mode = nla_get_u8(data[IFLA_BOND_MODE]);
154 
155 		bond_opt_initval(&newval, mode);
156 		err = __bond_opt_set(bond, BOND_OPT_MODE, &newval);
157 		if (err)
158 			return err;
159 	}
160 	if (data[IFLA_BOND_ACTIVE_SLAVE]) {
161 		int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]);
162 		struct net_device *slave_dev;
163 		char *active_slave = "";
164 
165 		if (ifindex != 0) {
166 			slave_dev = __dev_get_by_index(dev_net(bond_dev),
167 						       ifindex);
168 			if (!slave_dev)
169 				return -ENODEV;
170 			active_slave = slave_dev->name;
171 		}
172 		bond_opt_initstr(&newval, active_slave);
173 		err = __bond_opt_set(bond, BOND_OPT_ACTIVE_SLAVE, &newval);
174 		if (err)
175 			return err;
176 	}
177 	if (data[IFLA_BOND_MIIMON]) {
178 		miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);
179 
180 		bond_opt_initval(&newval, miimon);
181 		err = __bond_opt_set(bond, BOND_OPT_MIIMON, &newval);
182 		if (err)
183 			return err;
184 	}
185 	if (data[IFLA_BOND_UPDELAY]) {
186 		int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);
187 
188 		bond_opt_initval(&newval, updelay);
189 		err = __bond_opt_set(bond, BOND_OPT_UPDELAY, &newval);
190 		if (err)
191 			return err;
192 	}
193 	if (data[IFLA_BOND_DOWNDELAY]) {
194 		int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);
195 
196 		bond_opt_initval(&newval, downdelay);
197 		err = __bond_opt_set(bond, BOND_OPT_DOWNDELAY, &newval);
198 		if (err)
199 			return err;
200 	}
201 	if (data[IFLA_BOND_USE_CARRIER]) {
202 		int use_carrier = nla_get_u8(data[IFLA_BOND_USE_CARRIER]);
203 
204 		bond_opt_initval(&newval, use_carrier);
205 		err = __bond_opt_set(bond, BOND_OPT_USE_CARRIER, &newval);
206 		if (err)
207 			return err;
208 	}
209 	if (data[IFLA_BOND_ARP_INTERVAL]) {
210 		int arp_interval = nla_get_u32(data[IFLA_BOND_ARP_INTERVAL]);
211 
212 		if (arp_interval && miimon) {
213 			netdev_err(bond->dev, "ARP monitoring cannot be used with MII monitoring\n");
214 			return -EINVAL;
215 		}
216 
217 		bond_opt_initval(&newval, arp_interval);
218 		err = __bond_opt_set(bond, BOND_OPT_ARP_INTERVAL, &newval);
219 		if (err)
220 			return err;
221 	}
222 	if (data[IFLA_BOND_ARP_IP_TARGET]) {
223 		struct nlattr *attr;
224 		int i = 0, rem;
225 
226 		bond_option_arp_ip_targets_clear(bond);
227 		nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
228 			__be32 target;
229 
230 			if (nla_len(attr) < sizeof(target))
231 				return -EINVAL;
232 
233 			target = nla_get_be32(attr);
234 
235 			bond_opt_initval(&newval, (__force u64)target);
236 			err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
237 					     &newval);
238 			if (err)
239 				break;
240 			i++;
241 		}
242 		if (i == 0 && bond->params.arp_interval)
243 			netdev_warn(bond->dev, "Removing last arp target with arp_interval on\n");
244 		if (err)
245 			return err;
246 	}
247 	if (data[IFLA_BOND_ARP_VALIDATE]) {
248 		int arp_validate = nla_get_u32(data[IFLA_BOND_ARP_VALIDATE]);
249 
250 		if (arp_validate && miimon) {
251 			netdev_err(bond->dev, "ARP validating cannot be used with MII monitoring\n");
252 			return -EINVAL;
253 		}
254 
255 		bond_opt_initval(&newval, arp_validate);
256 		err = __bond_opt_set(bond, BOND_OPT_ARP_VALIDATE, &newval);
257 		if (err)
258 			return err;
259 	}
260 	if (data[IFLA_BOND_ARP_ALL_TARGETS]) {
261 		int arp_all_targets =
262 			nla_get_u32(data[IFLA_BOND_ARP_ALL_TARGETS]);
263 
264 		bond_opt_initval(&newval, arp_all_targets);
265 		err = __bond_opt_set(bond, BOND_OPT_ARP_ALL_TARGETS, &newval);
266 		if (err)
267 			return err;
268 	}
269 	if (data[IFLA_BOND_PRIMARY]) {
270 		int ifindex = nla_get_u32(data[IFLA_BOND_PRIMARY]);
271 		struct net_device *dev;
272 		char *primary = "";
273 
274 		dev = __dev_get_by_index(dev_net(bond_dev), ifindex);
275 		if (dev)
276 			primary = dev->name;
277 
278 		bond_opt_initstr(&newval, primary);
279 		err = __bond_opt_set(bond, BOND_OPT_PRIMARY, &newval);
280 		if (err)
281 			return err;
282 	}
283 	if (data[IFLA_BOND_PRIMARY_RESELECT]) {
284 		int primary_reselect =
285 			nla_get_u8(data[IFLA_BOND_PRIMARY_RESELECT]);
286 
287 		bond_opt_initval(&newval, primary_reselect);
288 		err = __bond_opt_set(bond, BOND_OPT_PRIMARY_RESELECT, &newval);
289 		if (err)
290 			return err;
291 	}
292 	if (data[IFLA_BOND_FAIL_OVER_MAC]) {
293 		int fail_over_mac =
294 			nla_get_u8(data[IFLA_BOND_FAIL_OVER_MAC]);
295 
296 		bond_opt_initval(&newval, fail_over_mac);
297 		err = __bond_opt_set(bond, BOND_OPT_FAIL_OVER_MAC, &newval);
298 		if (err)
299 			return err;
300 	}
301 	if (data[IFLA_BOND_XMIT_HASH_POLICY]) {
302 		int xmit_hash_policy =
303 			nla_get_u8(data[IFLA_BOND_XMIT_HASH_POLICY]);
304 
305 		bond_opt_initval(&newval, xmit_hash_policy);
306 		err = __bond_opt_set(bond, BOND_OPT_XMIT_HASH, &newval);
307 		if (err)
308 			return err;
309 	}
310 	if (data[IFLA_BOND_RESEND_IGMP]) {
311 		int resend_igmp =
312 			nla_get_u32(data[IFLA_BOND_RESEND_IGMP]);
313 
314 		bond_opt_initval(&newval, resend_igmp);
315 		err = __bond_opt_set(bond, BOND_OPT_RESEND_IGMP, &newval);
316 		if (err)
317 			return err;
318 	}
319 	if (data[IFLA_BOND_NUM_PEER_NOTIF]) {
320 		int num_peer_notif =
321 			nla_get_u8(data[IFLA_BOND_NUM_PEER_NOTIF]);
322 
323 		bond_opt_initval(&newval, num_peer_notif);
324 		err = __bond_opt_set(bond, BOND_OPT_NUM_PEER_NOTIF, &newval);
325 		if (err)
326 			return err;
327 	}
328 	if (data[IFLA_BOND_ALL_SLAVES_ACTIVE]) {
329 		int all_slaves_active =
330 			nla_get_u8(data[IFLA_BOND_ALL_SLAVES_ACTIVE]);
331 
332 		bond_opt_initval(&newval, all_slaves_active);
333 		err = __bond_opt_set(bond, BOND_OPT_ALL_SLAVES_ACTIVE, &newval);
334 		if (err)
335 			return err;
336 	}
337 	if (data[IFLA_BOND_MIN_LINKS]) {
338 		int min_links =
339 			nla_get_u32(data[IFLA_BOND_MIN_LINKS]);
340 
341 		bond_opt_initval(&newval, min_links);
342 		err = __bond_opt_set(bond, BOND_OPT_MINLINKS, &newval);
343 		if (err)
344 			return err;
345 	}
346 	if (data[IFLA_BOND_LP_INTERVAL]) {
347 		int lp_interval =
348 			nla_get_u32(data[IFLA_BOND_LP_INTERVAL]);
349 
350 		bond_opt_initval(&newval, lp_interval);
351 		err = __bond_opt_set(bond, BOND_OPT_LP_INTERVAL, &newval);
352 		if (err)
353 			return err;
354 	}
355 	if (data[IFLA_BOND_PACKETS_PER_SLAVE]) {
356 		int packets_per_slave =
357 			nla_get_u32(data[IFLA_BOND_PACKETS_PER_SLAVE]);
358 
359 		bond_opt_initval(&newval, packets_per_slave);
360 		err = __bond_opt_set(bond, BOND_OPT_PACKETS_PER_SLAVE, &newval);
361 		if (err)
362 			return err;
363 	}
364 	if (data[IFLA_BOND_AD_LACP_RATE]) {
365 		int lacp_rate =
366 			nla_get_u8(data[IFLA_BOND_AD_LACP_RATE]);
367 
368 		bond_opt_initval(&newval, lacp_rate);
369 		err = __bond_opt_set(bond, BOND_OPT_LACP_RATE, &newval);
370 		if (err)
371 			return err;
372 	}
373 	if (data[IFLA_BOND_AD_SELECT]) {
374 		int ad_select =
375 			nla_get_u8(data[IFLA_BOND_AD_SELECT]);
376 
377 		bond_opt_initval(&newval, ad_select);
378 		err = __bond_opt_set(bond, BOND_OPT_AD_SELECT, &newval);
379 		if (err)
380 			return err;
381 	}
382 	return 0;
383 }
384 
385 static int bond_newlink(struct net *src_net, struct net_device *bond_dev,
386 			struct nlattr *tb[], struct nlattr *data[])
387 {
388 	int err;
389 
390 	err = bond_changelink(bond_dev, tb, data);
391 	if (err < 0)
392 		return err;
393 
394 	return register_netdevice(bond_dev);
395 }
396 
397 static size_t bond_get_size(const struct net_device *bond_dev)
398 {
399 	return nla_total_size(sizeof(u8)) +	/* IFLA_BOND_MODE */
400 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ACTIVE_SLAVE */
401 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_MIIMON */
402 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_UPDELAY */
403 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_DOWNDELAY */
404 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_USE_CARRIER */
405 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_INTERVAL */
406 						/* IFLA_BOND_ARP_IP_TARGET */
407 		nla_total_size(sizeof(struct nlattr)) +
408 		nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS +
409 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_VALIDATE */
410 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_ALL_TARGETS */
411 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_PRIMARY */
412 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_PRIMARY_RESELECT */
413 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_FAIL_OVER_MAC */
414 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_XMIT_HASH_POLICY */
415 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_RESEND_IGMP */
416 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_NUM_PEER_NOTIF */
417 		nla_total_size(sizeof(u8)) +   /* IFLA_BOND_ALL_SLAVES_ACTIVE */
418 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_MIN_LINKS */
419 		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_LP_INTERVAL */
420 		nla_total_size(sizeof(u32)) +  /* IFLA_BOND_PACKETS_PER_SLAVE */
421 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_AD_LACP_RATE */
422 		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_AD_SELECT */
423 		nla_total_size(sizeof(struct nlattr)) + /* IFLA_BOND_AD_INFO */
424 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_AGGREGATOR */
425 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_NUM_PORTS */
426 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_ACTOR_KEY */
427 		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_PARTNER_KEY*/
428 		nla_total_size(ETH_ALEN) +    /* IFLA_BOND_AD_INFO_PARTNER_MAC*/
429 		0;
430 }
431 
432 static int bond_option_active_slave_get_ifindex(struct bonding *bond)
433 {
434 	const struct net_device *slave;
435 	int ifindex;
436 
437 	rcu_read_lock();
438 	slave = bond_option_active_slave_get_rcu(bond);
439 	ifindex = slave ? slave->ifindex : 0;
440 	rcu_read_unlock();
441 	return ifindex;
442 }
443 
444 static int bond_fill_info(struct sk_buff *skb,
445 			  const struct net_device *bond_dev)
446 {
447 	struct bonding *bond = netdev_priv(bond_dev);
448 	unsigned int packets_per_slave;
449 	int ifindex, i, targets_added;
450 	struct nlattr *targets;
451 	struct slave *primary;
452 
453 	if (nla_put_u8(skb, IFLA_BOND_MODE, BOND_MODE(bond)))
454 		goto nla_put_failure;
455 
456 	ifindex = bond_option_active_slave_get_ifindex(bond);
457 	if (ifindex && nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, ifindex))
458 		goto nla_put_failure;
459 
460 	if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
461 		goto nla_put_failure;
462 
463 	if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
464 			bond->params.updelay * bond->params.miimon))
465 		goto nla_put_failure;
466 
467 	if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
468 			bond->params.downdelay * bond->params.miimon))
469 		goto nla_put_failure;
470 
471 	if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier))
472 		goto nla_put_failure;
473 
474 	if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval))
475 		goto nla_put_failure;
476 
477 	targets = nla_nest_start(skb, IFLA_BOND_ARP_IP_TARGET);
478 	if (!targets)
479 		goto nla_put_failure;
480 
481 	targets_added = 0;
482 	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
483 		if (bond->params.arp_targets[i]) {
484 			nla_put_be32(skb, i, bond->params.arp_targets[i]);
485 			targets_added = 1;
486 		}
487 	}
488 
489 	if (targets_added)
490 		nla_nest_end(skb, targets);
491 	else
492 		nla_nest_cancel(skb, targets);
493 
494 	if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate))
495 		goto nla_put_failure;
496 
497 	if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS,
498 			bond->params.arp_all_targets))
499 		goto nla_put_failure;
500 
501 	primary = rtnl_dereference(bond->primary_slave);
502 	if (primary &&
503 	    nla_put_u32(skb, IFLA_BOND_PRIMARY, primary->dev->ifindex))
504 		goto nla_put_failure;
505 
506 	if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT,
507 		       bond->params.primary_reselect))
508 		goto nla_put_failure;
509 
510 	if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC,
511 		       bond->params.fail_over_mac))
512 		goto nla_put_failure;
513 
514 	if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY,
515 		       bond->params.xmit_policy))
516 		goto nla_put_failure;
517 
518 	if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP,
519 		        bond->params.resend_igmp))
520 		goto nla_put_failure;
521 
522 	if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF,
523 		       bond->params.num_peer_notif))
524 		goto nla_put_failure;
525 
526 	if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE,
527 		       bond->params.all_slaves_active))
528 		goto nla_put_failure;
529 
530 	if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS,
531 			bond->params.min_links))
532 		goto nla_put_failure;
533 
534 	if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL,
535 			bond->params.lp_interval))
536 		goto nla_put_failure;
537 
538 	packets_per_slave = bond->params.packets_per_slave;
539 	if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE,
540 			packets_per_slave))
541 		goto nla_put_failure;
542 
543 	if (nla_put_u8(skb, IFLA_BOND_AD_LACP_RATE,
544 		       bond->params.lacp_fast))
545 		goto nla_put_failure;
546 
547 	if (nla_put_u8(skb, IFLA_BOND_AD_SELECT,
548 		       bond->params.ad_select))
549 		goto nla_put_failure;
550 
551 	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
552 		struct ad_info info;
553 
554 		if (!bond_3ad_get_active_agg_info(bond, &info)) {
555 			struct nlattr *nest;
556 
557 			nest = nla_nest_start(skb, IFLA_BOND_AD_INFO);
558 			if (!nest)
559 				goto nla_put_failure;
560 
561 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_AGGREGATOR,
562 					info.aggregator_id))
563 				goto nla_put_failure;
564 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_NUM_PORTS,
565 					info.ports))
566 				goto nla_put_failure;
567 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_ACTOR_KEY,
568 					info.actor_key))
569 				goto nla_put_failure;
570 			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_PARTNER_KEY,
571 					info.partner_key))
572 				goto nla_put_failure;
573 			if (nla_put(skb, IFLA_BOND_AD_INFO_PARTNER_MAC,
574 				    sizeof(info.partner_system),
575 				    &info.partner_system))
576 				goto nla_put_failure;
577 
578 			nla_nest_end(skb, nest);
579 		}
580 	}
581 
582 	return 0;
583 
584 nla_put_failure:
585 	return -EMSGSIZE;
586 }
587 
588 struct rtnl_link_ops bond_link_ops __read_mostly = {
589 	.kind			= "bond",
590 	.priv_size		= sizeof(struct bonding),
591 	.setup			= bond_setup,
592 	.maxtype		= IFLA_BOND_MAX,
593 	.policy			= bond_policy,
594 	.validate		= bond_validate,
595 	.newlink		= bond_newlink,
596 	.changelink		= bond_changelink,
597 	.get_size		= bond_get_size,
598 	.fill_info		= bond_fill_info,
599 	.get_num_tx_queues	= bond_get_num_tx_queues,
600 	.get_num_rx_queues	= bond_get_num_tx_queues, /* Use the same number
601 							     as for TX queues */
602 	.slave_maxtype		= IFLA_BOND_SLAVE_MAX,
603 	.slave_policy		= bond_slave_policy,
604 	.slave_changelink	= bond_slave_changelink,
605 	.get_slave_size		= bond_get_slave_size,
606 	.fill_slave_info	= bond_fill_slave_info,
607 };
608 
609 int __init bond_netlink_init(void)
610 {
611 	return rtnl_link_register(&bond_link_ops);
612 }
613 
614 void bond_netlink_fini(void)
615 {
616 	rtnl_link_unregister(&bond_link_ops);
617 }
618 
619 MODULE_ALIAS_RTNL_LINK("bond");
620