[linux-2.6-block.git] / drivers / net / netdevsim / netdev.c

/*
 * Copyright (C) 2017 Netronome Systems, Inc.
 *
 * This software is licensed under the GNU General License Version 2,
 * June 1991 as shown in the file COPYING in the top-level directory of this
 * source tree.
 *
 * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
 * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
 * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
 * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
 */

#include <linux/debugfs.h>
#include <linux/etherdevice.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/slab.h>
#include <net/netlink.h>
#include <net/pkt_cls.h>
#include <net/rtnetlink.h>

#include "netdevsim.h"

static netdev_tx_t nsim_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct netdevsim *ns = netdev_priv(dev);

	if (!nsim_ipsec_tx(ns, skb))
		goto out;

	u64_stats_update_begin(&ns->syncp);
	ns->tx_packets++;
	ns->tx_bytes += skb->len;
	u64_stats_update_end(&ns->syncp);

out:
	dev_kfree_skb(skb);

	return NETDEV_TX_OK;
}

static void nsim_set_rx_mode(struct net_device *dev)
{
}

static int nsim_change_mtu(struct net_device *dev, int new_mtu)
{
	struct netdevsim *ns = netdev_priv(dev);

	if (ns->xdp.prog && new_mtu > NSIM_XDP_MAX_MTU)
		return -EBUSY;

	dev->mtu = new_mtu;

	return 0;
}

static void
nsim_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
{
	struct netdevsim *ns = netdev_priv(dev);
	unsigned int start;

	do {
		start = u64_stats_fetch_begin(&ns->syncp);
		stats->tx_bytes = ns->tx_bytes;
		stats->tx_packets = ns->tx_packets;
	} while (u64_stats_fetch_retry(&ns->syncp, start));
}

static int
nsim_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv)
{
	return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
}

static int nsim_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	/* Only refuse multicast addresses, zero address can mean unset/any. */
	if (vf >= nsim_bus_dev->num_vfs || is_multicast_ether_addr(mac))
		return -EINVAL;
	memcpy(nsim_bus_dev->vfconfigs[vf].vf_mac, mac, ETH_ALEN);

	return 0;
}

static int nsim_set_vf_vlan(struct net_device *dev, int vf,
			    u16 vlan, u8 qos, __be16 vlan_proto)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs || vlan > 4095 || qos > 7)
		return -EINVAL;

	nsim_bus_dev->vfconfigs[vf].vlan = vlan;
	nsim_bus_dev->vfconfigs[vf].qos = qos;
	nsim_bus_dev->vfconfigs[vf].vlan_proto = vlan_proto;

	return 0;
}

static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs)
		return -EINVAL;

	nsim_bus_dev->vfconfigs[vf].min_tx_rate = min;
	nsim_bus_dev->vfconfigs[vf].max_tx_rate = max;

	return 0;
}

static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs)
		return -EINVAL;
	nsim_bus_dev->vfconfigs[vf].spoofchk_enabled = val;

	return 0;
}

static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs)
		return -EINVAL;
	nsim_bus_dev->vfconfigs[vf].rss_query_enabled = val;

	return 0;
}

static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs)
		return -EINVAL;
	nsim_bus_dev->vfconfigs[vf].trusted = val;

	return 0;
}

static int
nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs)
		return -EINVAL;

	ivi->vf = vf;
	ivi->linkstate = nsim_bus_dev->vfconfigs[vf].link_state;
	ivi->min_tx_rate = nsim_bus_dev->vfconfigs[vf].min_tx_rate;
	ivi->max_tx_rate = nsim_bus_dev->vfconfigs[vf].max_tx_rate;
	ivi->vlan = nsim_bus_dev->vfconfigs[vf].vlan;
	ivi->vlan_proto = nsim_bus_dev->vfconfigs[vf].vlan_proto;
	ivi->qos = nsim_bus_dev->vfconfigs[vf].qos;
	memcpy(&ivi->mac, nsim_bus_dev->vfconfigs[vf].vf_mac, ETH_ALEN);
	ivi->spoofchk = nsim_bus_dev->vfconfigs[vf].spoofchk_enabled;
	ivi->trusted = nsim_bus_dev->vfconfigs[vf].trusted;
	ivi->rss_query_en = nsim_bus_dev->vfconfigs[vf].rss_query_enabled;

	return 0;
}

static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;

	if (vf >= nsim_bus_dev->num_vfs)
		return -EINVAL;

	switch (state) {
	case IFLA_VF_LINK_STATE_AUTO:
	case IFLA_VF_LINK_STATE_ENABLE:
	case IFLA_VF_LINK_STATE_DISABLE:
		break;
	default:
		return -EINVAL;
	}

	nsim_bus_dev->vfconfigs[vf].link_state = state;

	return 0;
}

static LIST_HEAD(nsim_block_cb_list);

static int
nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
{
	struct netdevsim *ns = netdev_priv(dev);

	switch (type) {
	case TC_SETUP_BLOCK:
		return flow_block_cb_setup_simple(type_data,
						  &nsim_block_cb_list,
						  nsim_setup_tc_block_cb,
						  ns, ns, true);
	default:
		return -EOPNOTSUPP;
	}
}

static int
nsim_set_features(struct net_device *dev, netdev_features_t features)
{
	struct netdevsim *ns = netdev_priv(dev);

	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
		return nsim_bpf_disable_tc(ns);

	return 0;
}

static struct devlink_port *nsim_get_devlink_port(struct net_device *dev)
{
	struct netdevsim *ns = netdev_priv(dev);

	return &ns->nsim_dev_port->devlink_port;
}

static const struct net_device_ops nsim_netdev_ops = {
	.ndo_start_xmit		= nsim_start_xmit,
	.ndo_set_rx_mode	= nsim_set_rx_mode,
	.ndo_set_mac_address	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_change_mtu		= nsim_change_mtu,
	.ndo_get_stats64	= nsim_get_stats64,
	.ndo_set_vf_mac		= nsim_set_vf_mac,
	.ndo_set_vf_vlan	= nsim_set_vf_vlan,
	.ndo_set_vf_rate	= nsim_set_vf_rate,
	.ndo_set_vf_spoofchk	= nsim_set_vf_spoofchk,
	.ndo_set_vf_trust	= nsim_set_vf_trust,
	.ndo_get_vf_config	= nsim_get_vf_config,
	.ndo_set_vf_link_state	= nsim_set_vf_link_state,
	.ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
	.ndo_setup_tc		= nsim_setup_tc,
	.ndo_set_features	= nsim_set_features,
	.ndo_bpf		= nsim_bpf,
	.ndo_get_devlink_port	= nsim_get_devlink_port,
};

static void nsim_setup(struct net_device *dev)
{
	ether_setup(dev);
	eth_hw_addr_random(dev);

	dev->tx_queue_len = 0;
	dev->flags |= IFF_NOARP;
	dev->flags &= ~IFF_MULTICAST;
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
			   IFF_NO_QUEUE;
	dev->features |= NETIF_F_HIGHDMA |
			 NETIF_F_SG |
			 NETIF_F_FRAGLIST |
			 NETIF_F_HW_CSUM |
			 NETIF_F_TSO;
	dev->hw_features |= NETIF_F_HW_TC;
	dev->max_mtu = ETH_MAX_MTU;
}

struct netdevsim *
nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port)
{
	struct net_device *dev;
	struct netdevsim *ns;
	int err;

	dev = alloc_netdev(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup);
	if (!dev)
		return ERR_PTR(-ENOMEM);

	ns = netdev_priv(dev);
	ns->netdev = dev;
	ns->nsim_dev = nsim_dev;
	ns->nsim_dev_port = nsim_dev_port;
	ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
	SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
	dev->netdev_ops = &nsim_netdev_ops;

	rtnl_lock();
	err = nsim_bpf_init(ns);
	if (err)
		goto err_free_netdev;

	nsim_ipsec_init(ns);

	err = register_netdevice(dev);
	if (err)
		goto err_ipsec_teardown;
	rtnl_unlock();

	return ns;

err_ipsec_teardown:
	nsim_ipsec_teardown(ns);
	nsim_bpf_uninit(ns);
	rtnl_unlock();
err_free_netdev:
	free_netdev(dev);
	return ERR_PTR(err);
}

void nsim_destroy(struct netdevsim *ns)
{
	struct net_device *dev = ns->netdev;

	rtnl_lock();
	unregister_netdevice(dev);
	nsim_ipsec_teardown(ns);
	nsim_bpf_uninit(ns);
	rtnl_unlock();
	free_netdev(dev);
}

static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
			 struct netlink_ext_ack *extack)
{
	NL_SET_ERR_MSG_MOD(extack, "Please use: echo \"[ID] [PORT_COUNT]\" > /sys/bus/netdevsim/new_device");
	return -EOPNOTSUPP;
}

static struct rtnl_link_ops nsim_link_ops __read_mostly = {
	.kind		= DRV_NAME,
	.validate	= nsim_validate,
};

static int __init nsim_module_init(void)
{
	int err;

	err = nsim_dev_init();
	if (err)
		return err;

	err = nsim_bus_init();
	if (err)
		goto err_dev_exit;

	err = nsim_fib_init();
	if (err)
		goto err_bus_exit;

	err = rtnl_link_register(&nsim_link_ops);
	if (err)
		goto err_fib_exit;

	return 0;

err_fib_exit:
	nsim_fib_exit();
err_bus_exit:
	nsim_bus_exit();
err_dev_exit:
	nsim_dev_exit();
	return err;
}

static void __exit nsim_module_exit(void)
{
	rtnl_link_unregister(&nsim_link_ops);
	nsim_fib_exit();
	nsim_bus_exit();
	nsim_dev_exit();
}

module_init(nsim_module_init);
module_exit(nsim_module_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS_RTNL_LINK(DRV_NAME);
Commit	Line	Data
83c9e13a JK	1	/*
	2	* Copyright (C) 2017 Netronome Systems, Inc.
	3	*
	4	* This software is licensed under the GNU General License Version 2,
	5	* June 1991 as shown in the file COPYING in the top-level directory of this
	6	* source tree.
	7	*
	8	* THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
	9	* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
	10	* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	11	* FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
	12	* OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
	13	* THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
	14	*/
	15
31d3ad83	16	#include <linux/debugfs.h>
83c9e13a JK	17	#include <linux/etherdevice.h>
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/netdevice.h>
	21	#include <linux/slab.h>
	22	#include <net/netlink.h>
31d3ad83	23	#include <net/pkt_cls.h>
83c9e13a JK	24	#include <net/rtnetlink.h>
	25
	26	#include "netdevsim.h"
	27
	28	static netdev_tx_t nsim_start_xmit(struct sk_buff skb, struct net_device dev)
	29	{
	30	struct netdevsim *ns = netdev_priv(dev);
	31
7699353d SN	32	if (!nsim_ipsec_tx(ns, skb))
	33	goto out;
	34
83c9e13a JK	35	u64_stats_update_begin(&ns->syncp);
	36	ns->tx_packets++;
	37	ns->tx_bytes += skb->len;
	38	u64_stats_update_end(&ns->syncp);
	39
7699353d	40	out:
83c9e13a JK	41	dev_kfree_skb(skb);
	42
	43	return NETDEV_TX_OK;
	44	}
	45
	46	static void nsim_set_rx_mode(struct net_device *dev)
	47	{
	48	}
	49
31d3ad83 JK	50	static int nsim_change_mtu(struct net_device *dev, int new_mtu)
	51	{
	52	struct netdevsim *ns = netdev_priv(dev);
	53
799e173d	54	if (ns->xdp.prog && new_mtu > NSIM_XDP_MAX_MTU)
31d3ad83 JK	55	return -EBUSY;
	56
	57	dev->mtu = new_mtu;
	58
	59	return 0;
	60	}
	61
83c9e13a JK	62	static void
	63	nsim_get_stats64(struct net_device dev, struct rtnl_link_stats64 stats)
	64	{
	65	struct netdevsim *ns = netdev_priv(dev);
	66	unsigned int start;
	67
	68	do {
	69	start = u64_stats_fetch_begin(&ns->syncp);
	70	stats->tx_bytes = ns->tx_bytes;
	71	stats->tx_packets = ns->tx_packets;
	72	} while (u64_stats_fetch_retry(&ns->syncp, start));
	73	}
	74
31d3ad83 JK	75	static int
	76	nsim_setup_tc_block_cb(enum tc_setup_type type, void type_data, void cb_priv)
	77	{
	78	return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
	79	}
	80
79579220 JK	81	static int nsim_set_vf_mac(struct net_device dev, int vf, u8 mac)
	82	{
	83	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	84	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220 JK	85
79579220 JK	86	/* Only refuse multicast addresses, zero address can mean unset/any. */
40e4fe4c	87	if (vf >= nsim_bus_dev->num_vfs \|\| is_multicast_ether_addr(mac))
79579220	88	return -EINVAL;
40e4fe4c	89	memcpy(nsim_bus_dev->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
79579220 JK	90
	91	return 0;
	92	}
	93
	94	static int nsim_set_vf_vlan(struct net_device *dev, int vf,
	95	u16 vlan, u8 qos, __be16 vlan_proto)
	96	{
	97	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	98	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	99
40e4fe4c	100	if (vf >= nsim_bus_dev->num_vfs \|\| vlan > 4095 \|\| qos > 7)
79579220 JK	101	return -EINVAL;
79579220 JK	102
40e4fe4c JP	103	nsim_bus_dev->vfconfigs[vf].vlan = vlan;
	104	nsim_bus_dev->vfconfigs[vf].qos = qos;
	105	nsim_bus_dev->vfconfigs[vf].vlan_proto = vlan_proto;
79579220 JK	106
	107	return 0;
	108	}
	109
	110	static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
	111	{
	112	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	113	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	114
40e4fe4c	115	if (vf >= nsim_bus_dev->num_vfs)
79579220 JK	116	return -EINVAL;
79579220 JK	117
40e4fe4c JP	118	nsim_bus_dev->vfconfigs[vf].min_tx_rate = min;
40e4fe4c JP	119	nsim_bus_dev->vfconfigs[vf].max_tx_rate = max;
79579220 JK	120
	121	return 0;
	122	}
	123
	124	static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
	125	{
	126	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	127	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	128
40e4fe4c	129	if (vf >= nsim_bus_dev->num_vfs)
79579220	130	return -EINVAL;
40e4fe4c	131	nsim_bus_dev->vfconfigs[vf].spoofchk_enabled = val;
79579220 JK	132
	133	return 0;
	134	}
	135
	136	static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
	137	{
	138	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	139	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	140
40e4fe4c	141	if (vf >= nsim_bus_dev->num_vfs)
79579220	142	return -EINVAL;
40e4fe4c	143	nsim_bus_dev->vfconfigs[vf].rss_query_enabled = val;
79579220 JK	144
	145	return 0;
	146	}
	147
	148	static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
	149	{
	150	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	151	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	152
40e4fe4c	153	if (vf >= nsim_bus_dev->num_vfs)
79579220	154	return -EINVAL;
40e4fe4c	155	nsim_bus_dev->vfconfigs[vf].trusted = val;
79579220 JK	156
	157	return 0;
	158	}
	159
	160	static int
	161	nsim_get_vf_config(struct net_device dev, int vf, struct ifla_vf_info ivi)
	162	{
	163	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	164	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	165
40e4fe4c	166	if (vf >= nsim_bus_dev->num_vfs)
79579220 JK	167	return -EINVAL;
	168
	169	ivi->vf = vf;
40e4fe4c JP	170	ivi->linkstate = nsim_bus_dev->vfconfigs[vf].link_state;
	171	ivi->min_tx_rate = nsim_bus_dev->vfconfigs[vf].min_tx_rate;
	172	ivi->max_tx_rate = nsim_bus_dev->vfconfigs[vf].max_tx_rate;
	173	ivi->vlan = nsim_bus_dev->vfconfigs[vf].vlan;
	174	ivi->vlan_proto = nsim_bus_dev->vfconfigs[vf].vlan_proto;
	175	ivi->qos = nsim_bus_dev->vfconfigs[vf].qos;
	176	memcpy(&ivi->mac, nsim_bus_dev->vfconfigs[vf].vf_mac, ETH_ALEN);
	177	ivi->spoofchk = nsim_bus_dev->vfconfigs[vf].spoofchk_enabled;
	178	ivi->trusted = nsim_bus_dev->vfconfigs[vf].trusted;
	179	ivi->rss_query_en = nsim_bus_dev->vfconfigs[vf].rss_query_enabled;
79579220 JK	180
	181	return 0;
	182	}
	183
	184	static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
	185	{
	186	struct netdevsim *ns = netdev_priv(dev);
40e4fe4c	187	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
79579220	188
40e4fe4c	189	if (vf >= nsim_bus_dev->num_vfs)
79579220 JK	190	return -EINVAL;
	191
	192	switch (state) {
	193	case IFLA_VF_LINK_STATE_AUTO:
	194	case IFLA_VF_LINK_STATE_ENABLE:
	195	case IFLA_VF_LINK_STATE_DISABLE:
	196	break;
	197	default:
	198	return -EINVAL;
	199	}
	200
40e4fe4c	201	nsim_bus_dev->vfconfigs[vf].link_state = state;
79579220 JK	202
	203	return 0;
	204	}
	205
955bcb6e PNA	206	static LIST_HEAD(nsim_block_cb_list);
955bcb6e PNA	207
31d3ad83 JK	208	static int
	209	nsim_setup_tc(struct net_device dev, enum tc_setup_type type, void type_data)
	210	{
4e95bc26 PNA	211	struct netdevsim *ns = netdev_priv(dev);
4e95bc26 PNA	212
31d3ad83 JK	213	switch (type) {
31d3ad83 JK	214	case TC_SETUP_BLOCK:
955bcb6e PNA	215	return flow_block_cb_setup_simple(type_data,
955bcb6e PNA	216	&nsim_block_cb_list,
4e95bc26 PNA	217	nsim_setup_tc_block_cb,
4e95bc26 PNA	218	ns, ns, true);
31d3ad83 JK	219	default:
	220	return -EOPNOTSUPP;
	221	}
	222	}
	223
	224	static int
	225	nsim_set_features(struct net_device *dev, netdev_features_t features)
	226	{
	227	struct netdevsim *ns = netdev_priv(dev);
	228
	229	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
	230	return nsim_bpf_disable_tc(ns);
	231
	232	return 0;
	233	}
	234
a62fdbbe JP	235	static struct devlink_port nsim_get_devlink_port(struct net_device dev)
	236	{
	237	struct netdevsim *ns = netdev_priv(dev);
	238
	239	return &ns->nsim_dev_port->devlink_port;
	240	}
	241
83c9e13a JK	242	static const struct net_device_ops nsim_netdev_ops = {
	243	.ndo_start_xmit = nsim_start_xmit,
	244	.ndo_set_rx_mode = nsim_set_rx_mode,
	245	.ndo_set_mac_address = eth_mac_addr,
	246	.ndo_validate_addr = eth_validate_addr,
31d3ad83	247	.ndo_change_mtu = nsim_change_mtu,
83c9e13a	248	.ndo_get_stats64 = nsim_get_stats64,
79579220 JK	249	.ndo_set_vf_mac = nsim_set_vf_mac,
	250	.ndo_set_vf_vlan = nsim_set_vf_vlan,
	251	.ndo_set_vf_rate = nsim_set_vf_rate,
	252	.ndo_set_vf_spoofchk = nsim_set_vf_spoofchk,
	253	.ndo_set_vf_trust = nsim_set_vf_trust,
	254	.ndo_get_vf_config = nsim_get_vf_config,
	255	.ndo_set_vf_link_state = nsim_set_vf_link_state,
	256	.ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
31d3ad83 JK	257	.ndo_setup_tc = nsim_setup_tc,
	258	.ndo_set_features = nsim_set_features,
	259	.ndo_bpf = nsim_bpf,
a62fdbbe	260	.ndo_get_devlink_port = nsim_get_devlink_port,
83c9e13a JK	261	};
	262
	263	static void nsim_setup(struct net_device *dev)
	264	{
	265	ether_setup(dev);
	266	eth_hw_addr_random(dev);
	267
83c9e13a JK	268	dev->tx_queue_len = 0;
	269	dev->flags \|= IFF_NOARP;
	270	dev->flags &= ~IFF_MULTICAST;
	271	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE \|
	272	IFF_NO_QUEUE;
	273	dev->features \|= NETIF_F_HIGHDMA \|
	274	NETIF_F_SG \|
	275	NETIF_F_FRAGLIST \|
	276	NETIF_F_HW_CSUM \|
	277	NETIF_F_TSO;
31d3ad83	278	dev->hw_features \|= NETIF_F_HW_TC;
83c9e13a JK	279	dev->max_mtu = ETH_MAX_MTU;
	280	}
	281
e05b2d14 JP	282	struct netdevsim *
e05b2d14 JP	283	nsim_create(struct nsim_dev nsim_dev, struct nsim_dev_port nsim_dev_port)
eeeaaf18	284	{
e05b2d14 JP	285	struct net_device *dev;
e05b2d14 JP	286	struct netdevsim *ns;
af9095f0	287	int err;
eeeaaf18	288
e05b2d14 JP	289	dev = alloc_netdev(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup);
	290	if (!dev)
	291	return ERR_PTR(-ENOMEM);
1daf36c0	292
e05b2d14 JP	293	ns = netdev_priv(dev);
	294	ns->netdev = dev;
	295	ns->nsim_dev = nsim_dev;
	296	ns->nsim_dev_port = nsim_dev_port;
	297	ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
40e4fe4c	298	SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
e05b2d14	299	dev->netdev_ops = &nsim_netdev_ops;
1daf36c0	300
e05b2d14 JP	301	rtnl_lock();
	302	err = nsim_bpf_init(ns);
	303	if (err)
	304	goto err_free_netdev;
	305
	306	nsim_ipsec_init(ns);
5fc49422 JP	307
	308	err = register_netdevice(dev);
	309	if (err)
e05b2d14 JP	310	goto err_ipsec_teardown;
e05b2d14 JP	311	rtnl_unlock();
af9095f0	312
e05b2d14 JP	313	return ns;
	314
	315	err_ipsec_teardown:
	316	nsim_ipsec_teardown(ns);
	317	nsim_bpf_uninit(ns);
	318	rtnl_unlock();
	319	err_free_netdev:
	320	free_netdev(dev);
	321	return ERR_PTR(err);
	322	}
	323
	324	void nsim_destroy(struct netdevsim *ns)
	325	{
	326	struct net_device *dev = ns->netdev;
	327
	328	rtnl_lock();
	329	unregister_netdevice(dev);
	330	nsim_ipsec_teardown(ns);
	331	nsim_bpf_uninit(ns);
	332	rtnl_unlock();
	333	free_netdev(dev);
	334	}
	335
	336	static int nsim_validate(struct nlattr tb[], struct nlattr data[],
	337	struct netlink_ext_ack *extack)
	338	{
	339	NL_SET_ERR_MSG_MOD(extack, "Please use: echo \"[ID] [PORT_COUNT]\" > /sys/bus/netdevsim/new_device");
	340	return -EOPNOTSUPP;
eeeaaf18 JK	341	}
eeeaaf18 JK	342
83c9e13a JK	343	static struct rtnl_link_ops nsim_link_ops __read_mostly = {
83c9e13a JK	344	.kind = DRV_NAME,
83c9e13a JK	345	.validate = nsim_validate,
	346	};
	347
	348	static int __init nsim_module_init(void)
	349	{
31d3ad83 JK	350	int err;
31d3ad83 JK	351
d514f41e	352	err = nsim_dev_init();
af9095f0	353	if (err)
ab1d0cc0	354	return err;
eeeaaf18	355
925f5afe	356	err = nsim_bus_init();
31d3ad83	357	if (err)
d514f41e	358	goto err_dev_exit;
31d3ad83	359
59c84b9f	360	err = nsim_fib_init();
37923ed6	361	if (err)
925f5afe	362	goto err_bus_exit;
37923ed6	363
59c84b9f DA	364	err = rtnl_link_register(&nsim_link_ops);
	365	if (err)
	366	goto err_fib_exit;
	367
31d3ad83 JK	368	return 0;
31d3ad83 JK	369
59c84b9f DA	370	err_fib_exit:
59c84b9f DA	371	nsim_fib_exit();
925f5afe JP	372	err_bus_exit:
925f5afe JP	373	nsim_bus_exit();
d514f41e JP	374	err_dev_exit:
d514f41e JP	375	nsim_dev_exit();
31d3ad83	376	return err;
83c9e13a JK	377	}
	378
	379	static void __exit nsim_module_exit(void)
	380	{
	381	rtnl_link_unregister(&nsim_link_ops);
59c84b9f	382	nsim_fib_exit();
925f5afe	383	nsim_bus_exit();
d514f41e	384	nsim_dev_exit();
83c9e13a JK	385	}
	386
	387	module_init(nsim_module_init);
	388	module_exit(nsim_module_exit);
	389	MODULE_LICENSE("GPL");
	390	MODULE_ALIAS_RTNL_LINK(DRV_NAME);