[deliverable/linux.git] / drivers / net / bonding / bond_netlink.c

/*
 * drivers/net/bond/bond_netlink.c - Netlink interface for bonding
 * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
 * Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if_link.h>
#include <linux/if_ether.h>
#include <net/netlink.h>
#include <net/rtnetlink.h>
#include "bonding.h"

int bond_get_slave(struct net_device *slave_dev, struct sk_buff *skb)
{
	struct slave *slave = bond_slave_get_rtnl(slave_dev);
	const struct aggregator *agg;

	if (nla_put_u8(skb, IFLA_SLAVE_STATE, bond_slave_state(slave)))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_SLAVE_MII_STATUS, slave->link))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_SLAVE_LINK_FAILURE_COUNT,
			slave->link_failure_count))
		goto nla_put_failure;

	if (nla_put(skb, IFLA_SLAVE_PERM_HWADDR,
		    slave_dev->addr_len, slave->perm_hwaddr))
		goto nla_put_failure;

	if (nla_put_u16(skb, IFLA_SLAVE_QUEUE_ID, slave->queue_id))
		goto nla_put_failure;

	if (slave->bond->params.mode == BOND_MODE_8023AD) {
		agg = SLAVE_AD_INFO(slave).port.aggregator;
		if (agg)
			if (nla_put_u16(skb, IFLA_SLAVE_AD_AGGREGATOR_ID,
					agg->aggregator_identifier))
				goto nla_put_failure;
	}

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = {
	[IFLA_BOND_MODE]		= { .type = NLA_U8 },
	[IFLA_BOND_ACTIVE_SLAVE]	= { .type = NLA_U32 },
	[IFLA_BOND_MIIMON]		= { .type = NLA_U32 },
	[IFLA_BOND_UPDELAY]		= { .type = NLA_U32 },
	[IFLA_BOND_DOWNDELAY]		= { .type = NLA_U32 },
	[IFLA_BOND_USE_CARRIER]		= { .type = NLA_U8 },
	[IFLA_BOND_ARP_INTERVAL]	= { .type = NLA_U32 },
	[IFLA_BOND_ARP_IP_TARGET]	= { .type = NLA_NESTED },
	[IFLA_BOND_ARP_VALIDATE]	= { .type = NLA_U32 },
	[IFLA_BOND_ARP_ALL_TARGETS]	= { .type = NLA_U32 },
	[IFLA_BOND_PRIMARY]		= { .type = NLA_U32 },
	[IFLA_BOND_PRIMARY_RESELECT]	= { .type = NLA_U8 },
	[IFLA_BOND_FAIL_OVER_MAC]	= { .type = NLA_U8 },
	[IFLA_BOND_XMIT_HASH_POLICY]	= { .type = NLA_U8 },
	[IFLA_BOND_RESEND_IGMP]		= { .type = NLA_U32 },
	[IFLA_BOND_NUM_PEER_NOTIF]	= { .type = NLA_U8 },
	[IFLA_BOND_ALL_SLAVES_ACTIVE]	= { .type = NLA_U8 },
	[IFLA_BOND_MIN_LINKS]		= { .type = NLA_U32 },
	[IFLA_BOND_LP_INTERVAL]		= { .type = NLA_U32 },
	[IFLA_BOND_PACKETS_PER_SLAVE]	= { .type = NLA_U32 },
	[IFLA_BOND_AD_LACP_RATE]	= { .type = NLA_U8 },
	[IFLA_BOND_AD_SELECT]		= { .type = NLA_U8 },
	[IFLA_BOND_AD_INFO]		= { .type = NLA_NESTED },
};

static int bond_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
	return 0;
}

static int bond_changelink(struct net_device *bond_dev,
			   struct nlattr *tb[], struct nlattr *data[])
{
	struct bonding *bond = netdev_priv(bond_dev);
	struct bond_opt_value newval;
	int miimon = 0;
	int err;

	if (!data)
		return 0;

	if (data[IFLA_BOND_MODE]) {
		int mode = nla_get_u8(data[IFLA_BOND_MODE]);

		bond_opt_initval(&newval, mode);
		err = __bond_opt_set(bond, BOND_OPT_MODE, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_ACTIVE_SLAVE]) {
		int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]);
		struct net_device *slave_dev;
		char *active_slave = "";

		if (ifindex != 0) {
			slave_dev = __dev_get_by_index(dev_net(bond_dev),
						       ifindex);
			if (!slave_dev)
				return -ENODEV;
			active_slave = slave_dev->name;
		}
		bond_opt_initstr(&newval, active_slave);
		err = __bond_opt_set(bond, BOND_OPT_ACTIVE_SLAVE, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_MIIMON]) {
		miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);

		bond_opt_initval(&newval, miimon);
		err = __bond_opt_set(bond, BOND_OPT_MIIMON, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_UPDELAY]) {
		int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);

		bond_opt_initval(&newval, updelay);
		err = __bond_opt_set(bond, BOND_OPT_UPDELAY, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_DOWNDELAY]) {
		int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);

		bond_opt_initval(&newval, downdelay);
		err = __bond_opt_set(bond, BOND_OPT_DOWNDELAY, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_USE_CARRIER]) {
		int use_carrier = nla_get_u8(data[IFLA_BOND_USE_CARRIER]);

		bond_opt_initval(&newval, use_carrier);
		err = __bond_opt_set(bond, BOND_OPT_USE_CARRIER, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_ARP_INTERVAL]) {
		int arp_interval = nla_get_u32(data[IFLA_BOND_ARP_INTERVAL]);

		if (arp_interval && miimon) {
			pr_err("%s: ARP monitoring cannot be used with MII monitoring.\n",
			       bond->dev->name);
			return -EINVAL;
		}

		bond_opt_initval(&newval, arp_interval);
		err = __bond_opt_set(bond, BOND_OPT_ARP_INTERVAL, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_ARP_IP_TARGET]) {
		struct nlattr *attr;
		int i = 0, rem;

		bond_option_arp_ip_targets_clear(bond);
		nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
			__be32 target = nla_get_be32(attr);

			bond_opt_initval(&newval, target);
			err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
					     &newval);
			if (err)
				break;
			i++;
		}
		if (i == 0 && bond->params.arp_interval)
			pr_warn("%s: removing last arp target with arp_interval on\n",
				bond->dev->name);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_ARP_VALIDATE]) {
		int arp_validate = nla_get_u32(data[IFLA_BOND_ARP_VALIDATE]);

		if (arp_validate && miimon) {
			pr_err("%s: ARP validating cannot be used with MII monitoring.\n",
			       bond->dev->name);
			return -EINVAL;
		}

		bond_opt_initval(&newval, arp_validate);
		err = __bond_opt_set(bond, BOND_OPT_ARP_VALIDATE, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_ARP_ALL_TARGETS]) {
		int arp_all_targets =
			nla_get_u32(data[IFLA_BOND_ARP_ALL_TARGETS]);

		bond_opt_initval(&newval, arp_all_targets);
		err = __bond_opt_set(bond, BOND_OPT_ARP_ALL_TARGETS, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_PRIMARY]) {
		int ifindex = nla_get_u32(data[IFLA_BOND_PRIMARY]);
		struct net_device *dev;
		char *primary = "";

		dev = __dev_get_by_index(dev_net(bond_dev), ifindex);
		if (dev)
			primary = dev->name;

		bond_opt_initstr(&newval, primary);
		err = __bond_opt_set(bond, BOND_OPT_PRIMARY, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_PRIMARY_RESELECT]) {
		int primary_reselect =
			nla_get_u8(data[IFLA_BOND_PRIMARY_RESELECT]);

		bond_opt_initval(&newval, primary_reselect);
		err = __bond_opt_set(bond, BOND_OPT_PRIMARY_RESELECT, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_FAIL_OVER_MAC]) {
		int fail_over_mac =
			nla_get_u8(data[IFLA_BOND_FAIL_OVER_MAC]);

		bond_opt_initval(&newval, fail_over_mac);
		err = __bond_opt_set(bond, BOND_OPT_FAIL_OVER_MAC, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_XMIT_HASH_POLICY]) {
		int xmit_hash_policy =
			nla_get_u8(data[IFLA_BOND_XMIT_HASH_POLICY]);

		bond_opt_initval(&newval, xmit_hash_policy);
		err = __bond_opt_set(bond, BOND_OPT_XMIT_HASH, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_RESEND_IGMP]) {
		int resend_igmp =
			nla_get_u32(data[IFLA_BOND_RESEND_IGMP]);

		err = bond_option_resend_igmp_set(bond, resend_igmp);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_NUM_PEER_NOTIF]) {
		int num_peer_notif =
			nla_get_u8(data[IFLA_BOND_NUM_PEER_NOTIF]);

		bond_opt_initval(&newval, num_peer_notif);
		err = __bond_opt_set(bond, BOND_OPT_NUM_PEER_NOTIF, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_ALL_SLAVES_ACTIVE]) {
		int all_slaves_active =
			nla_get_u8(data[IFLA_BOND_ALL_SLAVES_ACTIVE]);

		err = bond_option_all_slaves_active_set(bond,
							all_slaves_active);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_MIN_LINKS]) {
		int min_links =
			nla_get_u32(data[IFLA_BOND_MIN_LINKS]);

		bond_opt_initval(&newval, min_links);
		err = __bond_opt_set(bond, BOND_OPT_MINLINKS, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_LP_INTERVAL]) {
		int lp_interval =
			nla_get_u32(data[IFLA_BOND_LP_INTERVAL]);

		err = bond_option_lp_interval_set(bond, lp_interval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_PACKETS_PER_SLAVE]) {
		int packets_per_slave =
			nla_get_u32(data[IFLA_BOND_PACKETS_PER_SLAVE]);

		bond_opt_initval(&newval, packets_per_slave);
		err = __bond_opt_set(bond, BOND_OPT_PACKETS_PER_SLAVE, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_AD_LACP_RATE]) {
		int lacp_rate =
			nla_get_u8(data[IFLA_BOND_AD_LACP_RATE]);

		bond_opt_initval(&newval, lacp_rate);
		err = __bond_opt_set(bond, BOND_OPT_LACP_RATE, &newval);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_AD_SELECT]) {
		int ad_select =
			nla_get_u8(data[IFLA_BOND_AD_SELECT]);

		bond_opt_initval(&newval, ad_select);
		err = __bond_opt_set(bond, BOND_OPT_AD_SELECT, &newval);
		if (err)
			return err;
	}
	return 0;
}

static int bond_newlink(struct net *src_net, struct net_device *bond_dev,
			struct nlattr *tb[], struct nlattr *data[])
{
	int err;

	err = bond_changelink(bond_dev, tb, data);
	if (err < 0)
		return err;

	return register_netdevice(bond_dev);
}

static size_t bond_get_size(const struct net_device *bond_dev)
{
	return nla_total_size(sizeof(u8)) +	/* IFLA_BOND_MODE */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ACTIVE_SLAVE */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_MIIMON */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_UPDELAY */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_DOWNDELAY */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_USE_CARRIER */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_INTERVAL */
						/* IFLA_BOND_ARP_IP_TARGET */
		nla_total_size(sizeof(struct nlattr)) +
		nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS +
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_VALIDATE */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_ARP_ALL_TARGETS */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_PRIMARY */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_PRIMARY_RESELECT */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_FAIL_OVER_MAC */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_XMIT_HASH_POLICY */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_RESEND_IGMP */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_NUM_PEER_NOTIF */
		nla_total_size(sizeof(u8)) +   /* IFLA_BOND_ALL_SLAVES_ACTIVE */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_MIN_LINKS */
		nla_total_size(sizeof(u32)) +	/* IFLA_BOND_LP_INTERVAL */
		nla_total_size(sizeof(u32)) +  /* IFLA_BOND_PACKETS_PER_SLAVE */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_AD_LACP_RATE */
		nla_total_size(sizeof(u8)) +	/* IFLA_BOND_AD_SELECT */
		nla_total_size(sizeof(struct nlattr)) + /* IFLA_BOND_AD_INFO */
		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_AGGREGATOR */
		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_NUM_PORTS */
		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_ACTOR_KEY */
		nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_PARTNER_KEY*/
		nla_total_size(ETH_ALEN) +    /* IFLA_BOND_AD_INFO_PARTNER_MAC*/
		0;
}

static int bond_fill_info(struct sk_buff *skb,
			  const struct net_device *bond_dev)
{
	struct bonding *bond = netdev_priv(bond_dev);
	struct net_device *slave_dev = bond_option_active_slave_get(bond);
	struct nlattr *targets;
	unsigned int packets_per_slave;
	int i, targets_added;

	if (nla_put_u8(skb, IFLA_BOND_MODE, bond->params.mode))
		goto nla_put_failure;

	if (slave_dev &&
	    nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, slave_dev->ifindex))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
			bond->params.updelay * bond->params.miimon))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
			bond->params.downdelay * bond->params.miimon))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval))
		goto nla_put_failure;

	targets = nla_nest_start(skb, IFLA_BOND_ARP_IP_TARGET);
	if (!targets)
		goto nla_put_failure;

	targets_added = 0;
	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
		if (bond->params.arp_targets[i]) {
			nla_put_be32(skb, i, bond->params.arp_targets[i]);
			targets_added = 1;
		}
	}

	if (targets_added)
		nla_nest_end(skb, targets);
	else
		nla_nest_cancel(skb, targets);

	if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS,
			bond->params.arp_all_targets))
		goto nla_put_failure;

	if (bond->primary_slave &&
	    nla_put_u32(skb, IFLA_BOND_PRIMARY,
			bond->primary_slave->dev->ifindex))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT,
		       bond->params.primary_reselect))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC,
		       bond->params.fail_over_mac))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY,
		       bond->params.xmit_policy))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP,
		        bond->params.resend_igmp))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF,
		       bond->params.num_peer_notif))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE,
		       bond->params.all_slaves_active))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS,
			bond->params.min_links))
		goto nla_put_failure;

	if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL,
			bond->params.lp_interval))
		goto nla_put_failure;

	packets_per_slave = bond->params.packets_per_slave;
	if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE,
			packets_per_slave))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_AD_LACP_RATE,
		       bond->params.lacp_fast))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_BOND_AD_SELECT,
		       bond->params.ad_select))
		goto nla_put_failure;

	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info info;

		if (!bond_3ad_get_active_agg_info(bond, &info)) {
			struct nlattr *nest;

			nest = nla_nest_start(skb, IFLA_BOND_AD_INFO);
			if (!nest)
				goto nla_put_failure;

			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_AGGREGATOR,
					info.aggregator_id))
				goto nla_put_failure;
			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_NUM_PORTS,
					info.ports))
				goto nla_put_failure;
			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_ACTOR_KEY,
					info.actor_key))
				goto nla_put_failure;
			if (nla_put_u16(skb, IFLA_BOND_AD_INFO_PARTNER_KEY,
					info.partner_key))
				goto nla_put_failure;
			if (nla_put(skb, IFLA_BOND_AD_INFO_PARTNER_MAC,
				    sizeof(info.partner_system),
				    &info.partner_system))
				goto nla_put_failure;

			nla_nest_end(skb, nest);
		}
	}

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

struct rtnl_link_ops bond_link_ops __read_mostly = {
	.kind			= "bond",
	.priv_size		= sizeof(struct bonding),
	.setup			= bond_setup,
	.maxtype		= IFLA_BOND_MAX,
	.policy			= bond_policy,
	.validate		= bond_validate,
	.newlink		= bond_newlink,
	.changelink		= bond_changelink,
	.get_size		= bond_get_size,
	.fill_info		= bond_fill_info,
	.get_num_tx_queues	= bond_get_num_tx_queues,
	.get_num_rx_queues	= bond_get_num_tx_queues, /* Use the same number
							     as for TX queues */
};

int __init bond_netlink_init(void)
{
	return rtnl_link_register(&bond_link_ops);
}

void bond_netlink_fini(void)
{
	rtnl_link_unregister(&bond_link_ops);
}

MODULE_ALIAS_RTNL_LINK("bond");
Commit	Line	Data
0a2a78c4 JP	1	/*
	2	* drivers/net/bond/bond_netlink.c - Netlink interface for bonding
	3	* Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
eecdaa6e	4	* Copyright (c) 2013 Scott Feldman <sfeldma@cumulusnetworks.com>
0a2a78c4 JP	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	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	13
	14	#include <linux/module.h>
	15	#include <linux/errno.h>
	16	#include <linux/netdevice.h>
	17	#include <linux/etherdevice.h>
	18	#include <linux/if_link.h>
	19	#include <linux/if_ether.h>
	20	#include <net/netlink.h>
	21	#include <net/rtnetlink.h>
	22	#include "bonding.h"
	23
1d3ee88a	24	int bond_get_slave(struct net_device slave_dev, struct sk_buff skb)
	25	{
	26	struct slave *slave = bond_slave_get_rtnl(slave_dev);
	27	const struct aggregator *agg;
	28
	29	if (nla_put_u8(skb, IFLA_SLAVE_STATE, bond_slave_state(slave)))
	30	goto nla_put_failure;
	31
	32	if (nla_put_u8(skb, IFLA_SLAVE_MII_STATUS, slave->link))
	33	goto nla_put_failure;
	34
	35	if (nla_put_u32(skb, IFLA_SLAVE_LINK_FAILURE_COUNT,
	36	slave->link_failure_count))
	37	goto nla_put_failure;
	38
	39	if (nla_put(skb, IFLA_SLAVE_PERM_HWADDR,
	40	slave_dev->addr_len, slave->perm_hwaddr))
	41	goto nla_put_failure;
	42
	43	if (nla_put_u16(skb, IFLA_SLAVE_QUEUE_ID, slave->queue_id))
	44	goto nla_put_failure;
	45
	46	if (slave->bond->params.mode == BOND_MODE_8023AD) {
	47	agg = SLAVE_AD_INFO(slave).port.aggregator;
	48	if (agg)
	49	if (nla_put_u16(skb, IFLA_SLAVE_AD_AGGREGATOR_ID,
	50	agg->aggregator_identifier))
	51	goto nla_put_failure;
	52	}
	53
	54	return 0;
	55
	56	nla_put_failure:
	57	return -EMSGSIZE;
	58	}
	59
90af2311 JP	60	static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = {
90af2311 JP	61	[IFLA_BOND_MODE] = { .type = NLA_U8 },
ec76aa49	62	[IFLA_BOND_ACTIVE_SLAVE] = { .type = NLA_U32 },
eecdaa6e	63	[IFLA_BOND_MIIMON] = { .type = NLA_U32 },
25852e29	64	[IFLA_BOND_UPDELAY] = { .type = NLA_U32 },
c7461f9b	65	[IFLA_BOND_DOWNDELAY] = { .type = NLA_U32 },
9f53e14e	66	[IFLA_BOND_USE_CARRIER] = { .type = NLA_U8 },
06151dbc	67	[IFLA_BOND_ARP_INTERVAL] = { .type = NLA_U32 },
7f28fa10	68	[IFLA_BOND_ARP_IP_TARGET] = { .type = NLA_NESTED },
29c49482	69	[IFLA_BOND_ARP_VALIDATE] = { .type = NLA_U32 },
d5c84254	70	[IFLA_BOND_ARP_ALL_TARGETS] = { .type = NLA_U32 },
0a98a0d1	71	[IFLA_BOND_PRIMARY] = { .type = NLA_U32 },
8a41ae44	72	[IFLA_BOND_PRIMARY_RESELECT] = { .type = NLA_U8 },
89901972	73	[IFLA_BOND_FAIL_OVER_MAC] = { .type = NLA_U8 },
f70161c6	74	[IFLA_BOND_XMIT_HASH_POLICY] = { .type = NLA_U8 },
d8838de7	75	[IFLA_BOND_RESEND_IGMP] = { .type = NLA_U32 },
2c9839c1	76	[IFLA_BOND_NUM_PEER_NOTIF] = { .type = NLA_U8 },
1cc0b1e3	77	[IFLA_BOND_ALL_SLAVES_ACTIVE] = { .type = NLA_U8 },
7d101008	78	[IFLA_BOND_MIN_LINKS] = { .type = NLA_U32 },
8d836d09	79	[IFLA_BOND_LP_INTERVAL] = { .type = NLA_U32 },
c13ab3ff	80	[IFLA_BOND_PACKETS_PER_SLAVE] = { .type = NLA_U32 },
998e40bb	81	[IFLA_BOND_AD_LACP_RATE] = { .type = NLA_U8 },
ec029fac	82	[IFLA_BOND_AD_SELECT] = { .type = NLA_U8 },
4ee7ac75	83	[IFLA_BOND_AD_INFO] = { .type = NLA_NESTED },
90af2311 JP	84	};
90af2311 JP	85
0a2a78c4 JP	86	static int bond_validate(struct nlattr tb[], struct nlattr data[])
	87	{
	88	if (tb[IFLA_ADDRESS]) {
	89	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	90	return -EINVAL;
	91	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	92	return -EADDRNOTAVAIL;
	93	}
	94	return 0;
	95	}
	96
90af2311 JP	97	static int bond_changelink(struct net_device *bond_dev,
	98	struct nlattr tb[], struct nlattr data[])
	99	{
	100	struct bonding *bond = netdev_priv(bond_dev);
2b3798d5	101	struct bond_opt_value newval;
06151dbc	102	int miimon = 0;
90af2311 JP	103	int err;
90af2311 JP	104
eecdaa6e	105	if (!data)
	106	return 0;
	107
	108	if (data[IFLA_BOND_MODE]) {
90af2311 JP	109	int mode = nla_get_u8(data[IFLA_BOND_MODE]);
90af2311 JP	110
2b3798d5 NA	111	bond_opt_initval(&newval, mode);
2b3798d5 NA	112	err = __bond_opt_set(bond, BOND_OPT_MODE, &newval);
90af2311 JP	113	if (err)
	114	return err;
	115	}
eecdaa6e	116	if (data[IFLA_BOND_ACTIVE_SLAVE]) {
ec76aa49 JP	117	int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]);
ec76aa49 JP	118	struct net_device *slave_dev;
d1fbd3ed	119	char *active_slave = "";
ec76aa49	120
d1fbd3ed	121	if (ifindex != 0) {
ec76aa49 JP	122	slave_dev = __dev_get_by_index(dev_net(bond_dev),
	123	ifindex);
	124	if (!slave_dev)
	125	return -ENODEV;
d1fbd3ed	126	active_slave = slave_dev->name;
ec76aa49	127	}
d1fbd3ed NA	128	bond_opt_initstr(&newval, active_slave);
d1fbd3ed NA	129	err = __bond_opt_set(bond, BOND_OPT_ACTIVE_SLAVE, &newval);
ec76aa49 JP	130	if (err)
	131	return err;
	132	}
eecdaa6e	133	if (data[IFLA_BOND_MIIMON]) {
06151dbc	134	miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);
eecdaa6e	135
b98d9c66 NA	136	bond_opt_initval(&newval, miimon);
b98d9c66 NA	137	err = __bond_opt_set(bond, BOND_OPT_MIIMON, &newval);
eecdaa6e	138	if (err)
	139	return err;
	140	}
25852e29	141	if (data[IFLA_BOND_UPDELAY]) {
	142	int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);
	143
e4994612 NA	144	bond_opt_initval(&newval, updelay);
e4994612 NA	145	err = __bond_opt_set(bond, BOND_OPT_UPDELAY, &newval);
25852e29	146	if (err)
	147	return err;
	148	}
c7461f9b	149	if (data[IFLA_BOND_DOWNDELAY]) {
	150	int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);
	151
25a9b54a NA	152	bond_opt_initval(&newval, downdelay);
25a9b54a NA	153	err = __bond_opt_set(bond, BOND_OPT_DOWNDELAY, &newval);
c7461f9b	154	if (err)
	155	return err;
	156	}
9f53e14e	157	if (data[IFLA_BOND_USE_CARRIER]) {
	158	int use_carrier = nla_get_u8(data[IFLA_BOND_USE_CARRIER]);
	159
0fff0608 NA	160	bond_opt_initval(&newval, use_carrier);
0fff0608 NA	161	err = __bond_opt_set(bond, BOND_OPT_USE_CARRIER, &newval);
9f53e14e	162	if (err)
	163	return err;
	164	}
06151dbc	165	if (data[IFLA_BOND_ARP_INTERVAL]) {
	166	int arp_interval = nla_get_u32(data[IFLA_BOND_ARP_INTERVAL]);
	167
	168	if (arp_interval && miimon) {
	169	pr_err("%s: ARP monitoring cannot be used with MII monitoring.\n",
	170	bond->dev->name);
	171	return -EINVAL;
	172	}
	173
7bdb04ed NA	174	bond_opt_initval(&newval, arp_interval);
7bdb04ed NA	175	err = __bond_opt_set(bond, BOND_OPT_ARP_INTERVAL, &newval);
06151dbc	176	if (err)
	177	return err;
	178	}
7f28fa10	179	if (data[IFLA_BOND_ARP_IP_TARGET]) {
7f28fa10	180	struct nlattr *attr;
	181	int i = 0, rem;
	182
4fb0ef58	183	bond_option_arp_ip_targets_clear(bond);
7f28fa10	184	nla_for_each_nested(attr, data[IFLA_BOND_ARP_IP_TARGET], rem) {
e7ef941d	185	__be32 target = nla_get_be32(attr);
7f28fa10	186
4fb0ef58 NA	187	bond_opt_initval(&newval, target);
	188	err = __bond_opt_set(bond, BOND_OPT_ARP_TARGETS,
	189	&newval);
	190	if (err)
	191	break;
	192	i++;
	193	}
	194	if (i == 0 && bond->params.arp_interval)
	195	pr_warn("%s: removing last arp target with arp_interval on\n",
	196	bond->dev->name);
7f28fa10	197	if (err)
	198	return err;
	199	}
29c49482	200	if (data[IFLA_BOND_ARP_VALIDATE]) {
	201	int arp_validate = nla_get_u32(data[IFLA_BOND_ARP_VALIDATE]);
	202
	203	if (arp_validate && miimon) {
	204	pr_err("%s: ARP validating cannot be used with MII monitoring.\n",
	205	bond->dev->name);
	206	return -EINVAL;
	207	}
	208
16228881 NA	209	bond_opt_initval(&newval, arp_validate);
16228881 NA	210	err = __bond_opt_set(bond, BOND_OPT_ARP_VALIDATE, &newval);
29c49482	211	if (err)
	212	return err;
	213	}
d5c84254	214	if (data[IFLA_BOND_ARP_ALL_TARGETS]) {
	215	int arp_all_targets =
	216	nla_get_u32(data[IFLA_BOND_ARP_ALL_TARGETS]);
	217
edf36b24 NA	218	bond_opt_initval(&newval, arp_all_targets);
edf36b24 NA	219	err = __bond_opt_set(bond, BOND_OPT_ARP_ALL_TARGETS, &newval);
d5c84254	220	if (err)
	221	return err;
	222	}
0a98a0d1	223	if (data[IFLA_BOND_PRIMARY]) {
	224	int ifindex = nla_get_u32(data[IFLA_BOND_PRIMARY]);
	225	struct net_device *dev;
	226	char *primary = "";
	227
	228	dev = __dev_get_by_index(dev_net(bond_dev), ifindex);
	229	if (dev)
	230	primary = dev->name;
	231
180222f0 NA	232	bond_opt_initstr(&newval, primary);
180222f0 NA	233	err = __bond_opt_set(bond, BOND_OPT_PRIMARY, &newval);
0a98a0d1	234	if (err)
	235	return err;
	236	}
8a41ae44	237	if (data[IFLA_BOND_PRIMARY_RESELECT]) {
	238	int primary_reselect =
	239	nla_get_u8(data[IFLA_BOND_PRIMARY_RESELECT]);
	240
388d3a6d NA	241	bond_opt_initval(&newval, primary_reselect);
388d3a6d NA	242	err = __bond_opt_set(bond, BOND_OPT_PRIMARY_RESELECT, &newval);
8a41ae44	243	if (err)
	244	return err;
	245	}
89901972	246	if (data[IFLA_BOND_FAIL_OVER_MAC]) {
	247	int fail_over_mac =
	248	nla_get_u8(data[IFLA_BOND_FAIL_OVER_MAC]);
	249
1df6b6aa NA	250	bond_opt_initval(&newval, fail_over_mac);
1df6b6aa NA	251	err = __bond_opt_set(bond, BOND_OPT_FAIL_OVER_MAC, &newval);
89901972	252	if (err)
	253	return err;
	254	}
f70161c6	255	if (data[IFLA_BOND_XMIT_HASH_POLICY]) {
	256	int xmit_hash_policy =
	257	nla_get_u8(data[IFLA_BOND_XMIT_HASH_POLICY]);
	258
a4b32ce7 NA	259	bond_opt_initval(&newval, xmit_hash_policy);
a4b32ce7 NA	260	err = __bond_opt_set(bond, BOND_OPT_XMIT_HASH, &newval);
f70161c6	261	if (err)
	262	return err;
	263	}
d8838de7	264	if (data[IFLA_BOND_RESEND_IGMP]) {
	265	int resend_igmp =
	266	nla_get_u32(data[IFLA_BOND_RESEND_IGMP]);
	267
	268	err = bond_option_resend_igmp_set(bond, resend_igmp);
	269	if (err)
	270	return err;
	271	}
2c9839c1	272	if (data[IFLA_BOND_NUM_PEER_NOTIF]) {
	273	int num_peer_notif =
	274	nla_get_u8(data[IFLA_BOND_NUM_PEER_NOTIF]);
	275
ef56becb NA	276	bond_opt_initval(&newval, num_peer_notif);
ef56becb NA	277	err = __bond_opt_set(bond, BOND_OPT_NUM_PEER_NOTIF, &newval);
2c9839c1	278	if (err)
	279	return err;
	280	}
1cc0b1e3	281	if (data[IFLA_BOND_ALL_SLAVES_ACTIVE]) {
	282	int all_slaves_active =
	283	nla_get_u8(data[IFLA_BOND_ALL_SLAVES_ACTIVE]);
	284
	285	err = bond_option_all_slaves_active_set(bond,
	286	all_slaves_active);
	287	if (err)
	288	return err;
	289	}
7d101008	290	if (data[IFLA_BOND_MIN_LINKS]) {
	291	int min_links =
	292	nla_get_u32(data[IFLA_BOND_MIN_LINKS]);
	293
633ddc9e NA	294	bond_opt_initval(&newval, min_links);
633ddc9e NA	295	err = __bond_opt_set(bond, BOND_OPT_MINLINKS, &newval);
7d101008	296	if (err)
	297	return err;
	298	}
8d836d09	299	if (data[IFLA_BOND_LP_INTERVAL]) {
	300	int lp_interval =
	301	nla_get_u32(data[IFLA_BOND_LP_INTERVAL]);
	302
	303	err = bond_option_lp_interval_set(bond, lp_interval);
	304	if (err)
	305	return err;
	306	}
c13ab3ff	307	if (data[IFLA_BOND_PACKETS_PER_SLAVE]) {
	308	int packets_per_slave =
	309	nla_get_u32(data[IFLA_BOND_PACKETS_PER_SLAVE]);
	310
aa59d851 NA	311	bond_opt_initval(&newval, packets_per_slave);
aa59d851 NA	312	err = __bond_opt_set(bond, BOND_OPT_PACKETS_PER_SLAVE, &newval);
c13ab3ff	313	if (err)
	314	return err;
	315	}
998e40bb	316	if (data[IFLA_BOND_AD_LACP_RATE]) {
	317	int lacp_rate =
	318	nla_get_u8(data[IFLA_BOND_AD_LACP_RATE]);
	319
d3131de7 NA	320	bond_opt_initval(&newval, lacp_rate);
d3131de7 NA	321	err = __bond_opt_set(bond, BOND_OPT_LACP_RATE, &newval);
998e40bb	322	if (err)
	323	return err;
	324	}
ec029fac	325	if (data[IFLA_BOND_AD_SELECT]) {
	326	int ad_select =
	327	nla_get_u8(data[IFLA_BOND_AD_SELECT]);
	328
9e5f5eeb NA	329	bond_opt_initval(&newval, ad_select);
9e5f5eeb NA	330	err = __bond_opt_set(bond, BOND_OPT_AD_SELECT, &newval);
ec029fac	331	if (err)
	332	return err;
	333	}
90af2311 JP	334	return 0;
	335	}
	336
	337	static int bond_newlink(struct net src_net, struct net_device bond_dev,
	338	struct nlattr tb[], struct nlattr data[])
	339	{
	340	int err;
	341
	342	err = bond_changelink(bond_dev, tb, data);
	343	if (err < 0)
	344	return err;
	345
	346	return register_netdevice(bond_dev);
	347	}
	348
	349	static size_t bond_get_size(const struct net_device *bond_dev)
	350	{
e139862e	351	return nla_total_size(sizeof(u8)) + /* IFLA_BOND_MODE */
eecdaa6e	352	nla_total_size(sizeof(u32)) + /* IFLA_BOND_ACTIVE_SLAVE */
eecdaa6e	353	nla_total_size(sizeof(u32)) + /* IFLA_BOND_MIIMON */
25852e29	354	nla_total_size(sizeof(u32)) + /* IFLA_BOND_UPDELAY */
c7461f9b	355	nla_total_size(sizeof(u32)) + /* IFLA_BOND_DOWNDELAY */
9f53e14e	356	nla_total_size(sizeof(u8)) + /* IFLA_BOND_USE_CARRIER */
06151dbc	357	nla_total_size(sizeof(u32)) + /* IFLA_BOND_ARP_INTERVAL */
7f28fa10	358	/* IFLA_BOND_ARP_IP_TARGET */
288db0aa	359	nla_total_size(sizeof(struct nlattr)) +
7f28fa10	360	nla_total_size(sizeof(u32)) * BOND_MAX_ARP_TARGETS +
29c49482	361	nla_total_size(sizeof(u32)) + /* IFLA_BOND_ARP_VALIDATE */
d5c84254	362	nla_total_size(sizeof(u32)) + /* IFLA_BOND_ARP_ALL_TARGETS */
0a98a0d1	363	nla_total_size(sizeof(u32)) + /* IFLA_BOND_PRIMARY */
8a41ae44	364	nla_total_size(sizeof(u8)) + /* IFLA_BOND_PRIMARY_RESELECT */
89901972	365	nla_total_size(sizeof(u8)) + /* IFLA_BOND_FAIL_OVER_MAC */
f70161c6	366	nla_total_size(sizeof(u8)) + /* IFLA_BOND_XMIT_HASH_POLICY */
d8838de7	367	nla_total_size(sizeof(u32)) + /* IFLA_BOND_RESEND_IGMP */
2c9839c1	368	nla_total_size(sizeof(u8)) + /* IFLA_BOND_NUM_PEER_NOTIF */
1cc0b1e3	369	nla_total_size(sizeof(u8)) + /* IFLA_BOND_ALL_SLAVES_ACTIVE */
7d101008	370	nla_total_size(sizeof(u32)) + /* IFLA_BOND_MIN_LINKS */
8d836d09	371	nla_total_size(sizeof(u32)) + /* IFLA_BOND_LP_INTERVAL */
c13ab3ff	372	nla_total_size(sizeof(u32)) + /* IFLA_BOND_PACKETS_PER_SLAVE */
998e40bb	373	nla_total_size(sizeof(u8)) + /* IFLA_BOND_AD_LACP_RATE */
ec029fac	374	nla_total_size(sizeof(u8)) + /* IFLA_BOND_AD_SELECT */
4ee7ac75	375	nla_total_size(sizeof(struct nlattr)) + /* IFLA_BOND_AD_INFO */
	376	nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_AGGREGATOR */
	377	nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_NUM_PORTS */
	378	nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_ACTOR_KEY */
	379	nla_total_size(sizeof(u16)) + /* IFLA_BOND_AD_INFO_PARTNER_KEY*/
	380	nla_total_size(ETH_ALEN) + /* IFLA_BOND_AD_INFO_PARTNER_MAC*/
eecdaa6e	381	0;
90af2311 JP	382	}
	383
	384	static int bond_fill_info(struct sk_buff *skb,
	385	const struct net_device *bond_dev)
	386	{
	387	struct bonding *bond = netdev_priv(bond_dev);
ec76aa49	388	struct net_device *slave_dev = bond_option_active_slave_get(bond);
7f28fa10	389	struct nlattr *targets;
c13ab3ff	390	unsigned int packets_per_slave;
7f28fa10	391	int i, targets_added;
90af2311	392
eecdaa6e	393	if (nla_put_u8(skb, IFLA_BOND_MODE, bond->params.mode))
90af2311	394	goto nla_put_failure;
eecdaa6e	395
	396	if (slave_dev &&
	397	nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, slave_dev->ifindex))
	398	goto nla_put_failure;
	399
	400	if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
	401	goto nla_put_failure;
	402
25852e29	403	if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
	404	bond->params.updelay * bond->params.miimon))
	405	goto nla_put_failure;
	406
c7461f9b	407	if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
	408	bond->params.downdelay * bond->params.miimon))
	409	goto nla_put_failure;
	410
9f53e14e	411	if (nla_put_u8(skb, IFLA_BOND_USE_CARRIER, bond->params.use_carrier))
	412	goto nla_put_failure;
	413
06151dbc	414	if (nla_put_u32(skb, IFLA_BOND_ARP_INTERVAL, bond->params.arp_interval))
	415	goto nla_put_failure;
	416
7f28fa10	417	targets = nla_nest_start(skb, IFLA_BOND_ARP_IP_TARGET);
	418	if (!targets)
	419	goto nla_put_failure;
	420
	421	targets_added = 0;
	422	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
	423	if (bond->params.arp_targets[i]) {
e7ef941d	424	nla_put_be32(skb, i, bond->params.arp_targets[i]);
7f28fa10	425	targets_added = 1;
	426	}
	427	}
	428
	429	if (targets_added)
	430	nla_nest_end(skb, targets);
	431	else
	432	nla_nest_cancel(skb, targets);
	433
29c49482	434	if (nla_put_u32(skb, IFLA_BOND_ARP_VALIDATE, bond->params.arp_validate))
	435	goto nla_put_failure;
	436
d5c84254	437	if (nla_put_u32(skb, IFLA_BOND_ARP_ALL_TARGETS,
	438	bond->params.arp_all_targets))
	439	goto nla_put_failure;
	440
0a98a0d1	441	if (bond->primary_slave &&
	442	nla_put_u32(skb, IFLA_BOND_PRIMARY,
	443	bond->primary_slave->dev->ifindex))
	444	goto nla_put_failure;
	445
8a41ae44	446	if (nla_put_u8(skb, IFLA_BOND_PRIMARY_RESELECT,
	447	bond->params.primary_reselect))
	448	goto nla_put_failure;
	449
89901972	450	if (nla_put_u8(skb, IFLA_BOND_FAIL_OVER_MAC,
	451	bond->params.fail_over_mac))
	452	goto nla_put_failure;
	453
f70161c6	454	if (nla_put_u8(skb, IFLA_BOND_XMIT_HASH_POLICY,
	455	bond->params.xmit_policy))
	456	goto nla_put_failure;
	457
d8838de7	458	if (nla_put_u32(skb, IFLA_BOND_RESEND_IGMP,
	459	bond->params.resend_igmp))
	460	goto nla_put_failure;
	461
2c9839c1	462	if (nla_put_u8(skb, IFLA_BOND_NUM_PEER_NOTIF,
	463	bond->params.num_peer_notif))
	464	goto nla_put_failure;
	465
1cc0b1e3	466	if (nla_put_u8(skb, IFLA_BOND_ALL_SLAVES_ACTIVE,
	467	bond->params.all_slaves_active))
	468	goto nla_put_failure;
	469
7d101008	470	if (nla_put_u32(skb, IFLA_BOND_MIN_LINKS,
	471	bond->params.min_links))
	472	goto nla_put_failure;
	473
8d836d09	474	if (nla_put_u32(skb, IFLA_BOND_LP_INTERVAL,
	475	bond->params.lp_interval))
	476	goto nla_put_failure;
	477
c13ab3ff	478	packets_per_slave = bond->params.packets_per_slave;
c13ab3ff	479	if (nla_put_u32(skb, IFLA_BOND_PACKETS_PER_SLAVE,
	480	packets_per_slave))
	481	goto nla_put_failure;
	482
998e40bb	483	if (nla_put_u8(skb, IFLA_BOND_AD_LACP_RATE,
	484	bond->params.lacp_fast))
	485	goto nla_put_failure;
	486
ec029fac	487	if (nla_put_u8(skb, IFLA_BOND_AD_SELECT,
	488	bond->params.ad_select))
	489	goto nla_put_failure;
	490
4ee7ac75	491	if (bond->params.mode == BOND_MODE_8023AD) {
	492	struct ad_info info;
	493
	494	if (!bond_3ad_get_active_agg_info(bond, &info)) {
	495	struct nlattr *nest;
	496
	497	nest = nla_nest_start(skb, IFLA_BOND_AD_INFO);
	498	if (!nest)
	499	goto nla_put_failure;
	500
	501	if (nla_put_u16(skb, IFLA_BOND_AD_INFO_AGGREGATOR,
	502	info.aggregator_id))
	503	goto nla_put_failure;
	504	if (nla_put_u16(skb, IFLA_BOND_AD_INFO_NUM_PORTS,
	505	info.ports))
	506	goto nla_put_failure;
	507	if (nla_put_u16(skb, IFLA_BOND_AD_INFO_ACTOR_KEY,
	508	info.actor_key))
	509	goto nla_put_failure;
	510	if (nla_put_u16(skb, IFLA_BOND_AD_INFO_PARTNER_KEY,
	511	info.partner_key))
	512	goto nla_put_failure;
	513	if (nla_put(skb, IFLA_BOND_AD_INFO_PARTNER_MAC,
	514	sizeof(info.partner_system),
	515	&info.partner_system))
	516	goto nla_put_failure;
	517
	518	nla_nest_end(skb, nest);
	519	}
	520	}
	521
90af2311 JP	522	return 0;
	523
	524	nla_put_failure:
	525	return -EMSGSIZE;
	526	}
	527
0a2a78c4 JP	528	struct rtnl_link_ops bond_link_ops __read_mostly = {
	529	.kind = "bond",
	530	.priv_size = sizeof(struct bonding),
	531	.setup = bond_setup,
90af2311 JP	532	.maxtype = IFLA_BOND_MAX,
90af2311 JP	533	.policy = bond_policy,
0a2a78c4	534	.validate = bond_validate,
90af2311 JP	535	.newlink = bond_newlink,
	536	.changelink = bond_changelink,
	537	.get_size = bond_get_size,
	538	.fill_info = bond_fill_info,
0a2a78c4 JP	539	.get_num_tx_queues = bond_get_num_tx_queues,
	540	.get_num_rx_queues = bond_get_num_tx_queues, /* Use the same number
	541	as for TX queues */
	542	};
	543
	544	int __init bond_netlink_init(void)
	545	{
	546	return rtnl_link_register(&bond_link_ops);
	547	}
	548
a729e83a	549	void bond_netlink_fini(void)
0a2a78c4 JP	550	{
	551	rtnl_link_unregister(&bond_link_ops);
	552	}
	553
	554	MODULE_ALIAS_RTNL_LINK("bond");