Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d671965b authored by David S. Miller's avatar David S. Miller
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next 



Daniel Borkmann says:

====================
pull-request: bpf-next 2017-12-03

The following pull-request contains BPF updates for your *net-next* tree.

The main changes are:

1) Addition of a software model for BPF offloads in order to ease
   testing code changes in that area and make semantics more clear.
   This is implemented in a new driver called netdevsim, which can
   later also be extended for other offloads. SR-IOV support is added
   as well to netdevsim. BPF kernel selftests for offloading are
   added so we can track basic functionality as well as exercising
   all corner cases around BPF offloading, from Jakub.

2) Today drivers have to drop the reference on BPF progs they hold
   due to XDP on device teardown themselves. Change this in order
   to make XDP handling inside the drivers less error prone, and
   move disabling XDP to the core instead, also from Jakub.

3) Misc set of BPF verifier improvements and cleanups as preparatory
   work for upcoming BPF-to-BPF calls. Among others, this set also
   improves liveness marking such that pruning can be slightly more
   effective. Register and stack liveness information is now included
   in the verifier log as well, from Alexei.

4) nfp JIT improvements in order to identify load/store sequences in
   the BPF prog e.g. coming from memcpy lowering and optimizing them
   through the NPU's command push pull (CPP) instruction, from Jiong.

5) Cleanups to test_cgrp2_attach2.c BPF sample code in oder to remove
   bpf_prog_attach() magic values and replacing them with actual proper
   attach flag instead, from David.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents f4d4c49b 6720f108

MAINTAINERS

+5 −0
Original line number Diff line number Diff line
@@ -9599,6 +9599,11 @@ NETWORKING [WIRELESS] 
L:	linux-wireless@vger.kernel.org

Q:	http://patchwork.kernel.org/project/linux-wireless/list/



NETDEVSIM

M:	Jakub Kicinski <jakub.kicinski@netronome.com>

S:	Maintained

F:	drivers/net/netdevsim/*



NETXEN (1/10) GbE SUPPORT

M:	Manish Chopra <manish.chopra@cavium.com>

M:	Rahul Verma <rahul.verma@cavium.com>

drivers/net/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -497,4 +497,15 @@ config THUNDERBOLT_NET 


source "drivers/net/hyperv/Kconfig"



config NETDEVSIM

	tristate "Simulated networking device"

	depends on DEBUG_FS

	help

	  This driver is a developer testing tool and software model that can

	  be used to test various control path networking APIs, especially

	  HW-offload related.



	  To compile this driver as a module, choose M here: the module

	  will be called netdevsim.



endif # NETDEVICES

drivers/net/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -78,3 +78,4 @@ obj-$(CONFIG_FUJITSU_ES) += fjes/ 


thunderbolt-net-y += thunderbolt.o

obj-$(CONFIG_THUNDERBOLT_NET) += thunderbolt-net.o

obj-$(CONFIG_NETDEVSIM) += netdevsim/

drivers/net/dummy.c

+1 −214
Original line number Diff line number Diff line
@@ -42,48 +42,7 @@ 
#define DRV_NAME	"dummy"

#define DRV_VERSION	"1.0"



#undef pr_fmt

#define pr_fmt(fmt) DRV_NAME ": " fmt



static int numdummies = 1;

static int num_vfs;



struct vf_data_storage {

	u8	vf_mac[ETH_ALEN];

	u16	pf_vlan; /* When set, guest VLAN config not allowed. */

	u16	pf_qos;

	__be16	vlan_proto;

	u16	min_tx_rate;

	u16	max_tx_rate;

	u8	spoofchk_enabled;

	bool	rss_query_enabled;

	u8	trusted;

	int	link_state;

};



struct dummy_priv {

	struct vf_data_storage	*vfinfo;

};



static int dummy_num_vf(struct device *dev)

{

	return num_vfs;

}



static struct bus_type dummy_bus = {

	.name	= "dummy",

	.num_vf	= dummy_num_vf,

};



static void release_dummy_parent(struct device *dev)

{

}



static struct device dummy_parent = {

	.init_name	= "dummy",

	.bus		= &dummy_bus,

	.release	= release_dummy_parent,

};



/* fake multicast ability */

static void set_multicast_list(struct net_device *dev)
@@ -133,25 +92,10 @@ static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev) 


static int dummy_dev_init(struct net_device *dev)

{

	struct dummy_priv *priv = netdev_priv(dev);



	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);

	if (!dev->dstats)

		return -ENOMEM;



	priv->vfinfo = NULL;



	if (!num_vfs)

		return 0;



	dev->dev.parent = &dummy_parent;

	priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),

			       GFP_KERNEL);

	if (!priv->vfinfo) {

		free_percpu(dev->dstats);

		return -ENOMEM;

	}



	return 0;

}
@@ -169,117 +113,6 @@ static int dummy_change_carrier(struct net_device *dev, bool new_carrier) 
	return 0;

}



static int dummy_set_vf_mac(struct net_device *dev, int vf, u8 *mac)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (!is_valid_ether_addr(mac) || (vf >= num_vfs))

		return -EINVAL;



	memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);



	return 0;

}



static int dummy_set_vf_vlan(struct net_device *dev, int vf,

			     u16 vlan, u8 qos, __be16 vlan_proto)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if ((vf >= num_vfs) || (vlan > 4095) || (qos > 7))

		return -EINVAL;



	priv->vfinfo[vf].pf_vlan = vlan;

	priv->vfinfo[vf].pf_qos = qos;

	priv->vfinfo[vf].vlan_proto = vlan_proto;



	return 0;

}



static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (vf >= num_vfs)

		return -EINVAL;



	priv->vfinfo[vf].min_tx_rate = min;

	priv->vfinfo[vf].max_tx_rate = max;



	return 0;

}



static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (vf >= num_vfs)

		return -EINVAL;



	priv->vfinfo[vf].spoofchk_enabled = val;



	return 0;

}



static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (vf >= num_vfs)

		return -EINVAL;



	priv->vfinfo[vf].rss_query_enabled = val;



	return 0;

}



static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (vf >= num_vfs)

		return -EINVAL;



	priv->vfinfo[vf].trusted = val;



	return 0;

}



static int dummy_get_vf_config(struct net_device *dev,

			       int vf, struct ifla_vf_info *ivi)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (vf >= num_vfs)

		return -EINVAL;



	ivi->vf = vf;

	memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);

	ivi->vlan = priv->vfinfo[vf].pf_vlan;

	ivi->qos = priv->vfinfo[vf].pf_qos;

	ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;

	ivi->linkstate = priv->vfinfo[vf].link_state;

	ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;

	ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;

	ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;

	ivi->trusted = priv->vfinfo[vf].trusted;

	ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;



	return 0;

}



static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)

{

	struct dummy_priv *priv = netdev_priv(dev);



	if (vf >= num_vfs)

		return -EINVAL;



	priv->vfinfo[vf].link_state = state;



	return 0;

}



static const struct net_device_ops dummy_netdev_ops = {

	.ndo_init		= dummy_dev_init,

	.ndo_uninit		= dummy_dev_uninit,
@@ -289,14 +122,6 @@ static const struct net_device_ops dummy_netdev_ops = { 
	.ndo_set_mac_address	= eth_mac_addr,

	.ndo_get_stats64	= dummy_get_stats64,

	.ndo_change_carrier	= dummy_change_carrier,

	.ndo_set_vf_mac		= dummy_set_vf_mac,

	.ndo_set_vf_vlan	= dummy_set_vf_vlan,

	.ndo_set_vf_rate	= dummy_set_vf_rate,

	.ndo_set_vf_spoofchk	= dummy_set_vf_spoofchk,

	.ndo_set_vf_trust	= dummy_set_vf_trust,

	.ndo_get_vf_config	= dummy_get_vf_config,

	.ndo_set_vf_link_state	= dummy_set_vf_link_state,

	.ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,

};



static void dummy_get_drvinfo(struct net_device *dev,
@@ -323,13 +148,6 @@ static const struct ethtool_ops dummy_ethtool_ops = { 
	.get_ts_info		= dummy_get_ts_info,

};



static void dummy_free_netdev(struct net_device *dev)

{

	struct dummy_priv *priv = netdev_priv(dev);



	kfree(priv->vfinfo);

}



static void dummy_setup(struct net_device *dev)

{

	ether_setup(dev);
@@ -338,7 +156,6 @@ static void dummy_setup(struct net_device *dev) 
	dev->netdev_ops = &dummy_netdev_ops;

	dev->ethtool_ops = &dummy_ethtool_ops;

	dev->needs_free_netdev = true;

	dev->priv_destructor = dummy_free_netdev;



	/* Fill in device structure with ethernet-generic values. */

	dev->flags |= IFF_NOARP;
@@ -370,7 +187,6 @@ static int dummy_validate(struct nlattr *tb[], struct nlattr *data[], 


static struct rtnl_link_ops dummy_link_ops __read_mostly = {

	.kind		= DRV_NAME,

	.priv_size	= sizeof(struct dummy_priv),

	.setup		= dummy_setup,

	.validate	= dummy_validate,

};
@@ -379,16 +195,12 @@ static struct rtnl_link_ops dummy_link_ops __read_mostly = { 
module_param(numdummies, int, 0);

MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");



module_param(num_vfs, int, 0);

MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");



static int __init dummy_init_one(void)

{

	struct net_device *dev_dummy;

	int err;



	dev_dummy = alloc_netdev(sizeof(struct dummy_priv),

				 "dummy%d", NET_NAME_ENUM, dummy_setup);

	dev_dummy = alloc_netdev(0, "dummy%d", NET_NAME_ENUM, dummy_setup);

	if (!dev_dummy)

		return -ENOMEM;
@@ -407,21 +219,6 @@ static int __init dummy_init_module(void) 
{

	int i, err = 0;



	if (num_vfs) {

		err = bus_register(&dummy_bus);

		if (err < 0) {

			pr_err("registering dummy bus failed\n");

			return err;

		}



		err = device_register(&dummy_parent);

		if (err < 0) {

			pr_err("registering dummy parent device failed\n");

			bus_unregister(&dummy_bus);

			return err;

		}

	}



	rtnl_lock();

	err = __rtnl_link_register(&dummy_link_ops);

	if (err < 0)
@@ -437,22 +234,12 @@ static int __init dummy_init_module(void) 
out:

	rtnl_unlock();



	if (err && num_vfs) {

		device_unregister(&dummy_parent);

		bus_unregister(&dummy_bus);

	}



	return err;

}



static void __exit dummy_cleanup_module(void)

{

	rtnl_link_unregister(&dummy_link_ops);



	if (num_vfs) {

		device_unregister(&dummy_parent);

		bus_unregister(&dummy_bus);

	}

}



module_init(dummy_init_module);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

+0 −2
Original line number Diff line number Diff line
@@ -7800,8 +7800,6 @@ static void bnxt_remove_one(struct pci_dev *pdev) 
	bnxt_dcb_free(bp);

	kfree(bp->edev);

	bp->edev = NULL;

	if (bp->xdp_prog)

		bpf_prog_put(bp->xdp_prog);

	bnxt_cleanup_pci(bp);

	free_netdev(dev);

}