[mirror_ubuntu-eoan-kernel.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"

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 },
};

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);
	int err;

	if (!data)
		return 0;

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

		err = bond_option_mode_set(bond, mode);
		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;

		if (ifindex == 0) {
			slave_dev = NULL;
		} else {
			slave_dev = __dev_get_by_index(dev_net(bond_dev),
						       ifindex);
			if (!slave_dev)
				return -ENODEV;
		}
		err = bond_option_active_slave_set(bond, slave_dev);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_MIIMON]) {
		int miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);

		err = bond_option_miimon_set(bond, miimon);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_UPDELAY]) {
		int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);

		err = bond_option_updelay_set(bond, updelay);
		if (err)
			return err;
	}
	if (data[IFLA_BOND_DOWNDELAY]) {
		int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);

		err = bond_option_downdelay_set(bond, downdelay);
		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 */
		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);

	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;

	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
90af2311 JP	24	static const struct nla_policy bond_policy[IFLA_BOND_MAX + 1] = {
90af2311 JP	25	[IFLA_BOND_MODE] = { .type = NLA_U8 },
ec76aa49	26	[IFLA_BOND_ACTIVE_SLAVE] = { .type = NLA_U32 },
eecdaa6e	27	[IFLA_BOND_MIIMON] = { .type = NLA_U32 },
25852e29	28	[IFLA_BOND_UPDELAY] = { .type = NLA_U32 },
c7461f9b	29	[IFLA_BOND_DOWNDELAY] = { .type = NLA_U32 },
90af2311 JP	30	};
90af2311 JP	31
0a2a78c4 JP	32	static int bond_validate(struct nlattr tb[], struct nlattr data[])
	33	{
	34	if (tb[IFLA_ADDRESS]) {
	35	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	36	return -EINVAL;
	37	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	38	return -EADDRNOTAVAIL;
	39	}
	40	return 0;
	41	}
	42
90af2311 JP	43	static int bond_changelink(struct net_device *bond_dev,
	44	struct nlattr tb[], struct nlattr data[])
	45	{
	46	struct bonding *bond = netdev_priv(bond_dev);
	47	int err;
	48
eecdaa6e	49	if (!data)
	50	return 0;
	51
	52	if (data[IFLA_BOND_MODE]) {
90af2311 JP	53	int mode = nla_get_u8(data[IFLA_BOND_MODE]);
	54
	55	err = bond_option_mode_set(bond, mode);
	56	if (err)
	57	return err;
	58	}
eecdaa6e	59	if (data[IFLA_BOND_ACTIVE_SLAVE]) {
ec76aa49 JP	60	int ifindex = nla_get_u32(data[IFLA_BOND_ACTIVE_SLAVE]);
	61	struct net_device *slave_dev;
	62
	63	if (ifindex == 0) {
	64	slave_dev = NULL;
	65	} else {
	66	slave_dev = __dev_get_by_index(dev_net(bond_dev),
	67	ifindex);
	68	if (!slave_dev)
	69	return -ENODEV;
	70	}
	71	err = bond_option_active_slave_set(bond, slave_dev);
	72	if (err)
	73	return err;
	74	}
eecdaa6e	75	if (data[IFLA_BOND_MIIMON]) {
	76	int miimon = nla_get_u32(data[IFLA_BOND_MIIMON]);
	77
	78	err = bond_option_miimon_set(bond, miimon);
	79	if (err)
	80	return err;
	81	}
25852e29	82	if (data[IFLA_BOND_UPDELAY]) {
	83	int updelay = nla_get_u32(data[IFLA_BOND_UPDELAY]);
	84
	85	err = bond_option_updelay_set(bond, updelay);
	86	if (err)
	87	return err;
	88	}
c7461f9b	89	if (data[IFLA_BOND_DOWNDELAY]) {
	90	int downdelay = nla_get_u32(data[IFLA_BOND_DOWNDELAY]);
	91
	92	err = bond_option_downdelay_set(bond, downdelay);
	93	if (err)
	94	return err;
	95	}
90af2311 JP	96	return 0;
	97	}
	98
	99	static int bond_newlink(struct net src_net, struct net_device bond_dev,
	100	struct nlattr tb[], struct nlattr data[])
	101	{
	102	int err;
	103
	104	err = bond_changelink(bond_dev, tb, data);
	105	if (err < 0)
	106	return err;
	107
	108	return register_netdevice(bond_dev);
	109	}
	110
	111	static size_t bond_get_size(const struct net_device *bond_dev)
	112	{
e139862e	113	return nla_total_size(sizeof(u8)) + /* IFLA_BOND_MODE */
eecdaa6e	114	nla_total_size(sizeof(u32)) + /* IFLA_BOND_ACTIVE_SLAVE */
eecdaa6e	115	nla_total_size(sizeof(u32)) + /* IFLA_BOND_MIIMON */
25852e29	116	nla_total_size(sizeof(u32)) + /* IFLA_BOND_UPDELAY */
c7461f9b	117	nla_total_size(sizeof(u32)) + /* IFLA_BOND_DOWNDELAY */
eecdaa6e	118	0;
90af2311 JP	119	}
	120
	121	static int bond_fill_info(struct sk_buff *skb,
	122	const struct net_device *bond_dev)
	123	{
	124	struct bonding *bond = netdev_priv(bond_dev);
ec76aa49	125	struct net_device *slave_dev = bond_option_active_slave_get(bond);
90af2311	126
eecdaa6e	127	if (nla_put_u8(skb, IFLA_BOND_MODE, bond->params.mode))
90af2311	128	goto nla_put_failure;
eecdaa6e	129
	130	if (slave_dev &&
	131	nla_put_u32(skb, IFLA_BOND_ACTIVE_SLAVE, slave_dev->ifindex))
	132	goto nla_put_failure;
	133
	134	if (nla_put_u32(skb, IFLA_BOND_MIIMON, bond->params.miimon))
	135	goto nla_put_failure;
	136
25852e29	137	if (nla_put_u32(skb, IFLA_BOND_UPDELAY,
	138	bond->params.updelay * bond->params.miimon))
	139	goto nla_put_failure;
	140
c7461f9b	141	if (nla_put_u32(skb, IFLA_BOND_DOWNDELAY,
	142	bond->params.downdelay * bond->params.miimon))
	143	goto nla_put_failure;
	144
90af2311 JP	145	return 0;
	146
	147	nla_put_failure:
	148	return -EMSGSIZE;
	149	}
	150
0a2a78c4 JP	151	struct rtnl_link_ops bond_link_ops __read_mostly = {
	152	.kind = "bond",
	153	.priv_size = sizeof(struct bonding),
	154	.setup = bond_setup,
90af2311 JP	155	.maxtype = IFLA_BOND_MAX,
90af2311 JP	156	.policy = bond_policy,
0a2a78c4	157	.validate = bond_validate,
90af2311 JP	158	.newlink = bond_newlink,
	159	.changelink = bond_changelink,
	160	.get_size = bond_get_size,
	161	.fill_info = bond_fill_info,
0a2a78c4 JP	162	.get_num_tx_queues = bond_get_num_tx_queues,
	163	.get_num_rx_queues = bond_get_num_tx_queues, /* Use the same number
	164	as for TX queues */
	165	};
	166
	167	int __init bond_netlink_init(void)
	168	{
	169	return rtnl_link_register(&bond_link_ops);
	170	}
	171
a729e83a	172	void bond_netlink_fini(void)
0a2a78c4 JP	173	{
	174	rtnl_link_unregister(&bond_link_ops);
	175	}
	176
	177	MODULE_ALIAS_RTNL_LINK("bond");