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

Daniel Borkmann says:

====================
pull-request: bpf-next 2018-07-20

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

The main changes are:

1) Add sharing of BPF objects within one ASIC: this allows for reuse of
   the same program on multiple ports of a device, and therefore gains
   better code store utilization. On top of that, this now also enables
   sharing of maps between programs attached to different ports of a
   device, from Jakub.

2) Cleanup in libbpf and bpftool's Makefile to reduce unneeded feature
   detections and unused variable exports, also from Jakub.

3) First batch of RCU annotation fixes in prog array handling, i.e.
   there are several __rcu markers which are not correct as well as
   some of the RCU handling, from Roman.

4) Two fixes in BPF sample files related to checking of the prog_cnt
   upper limit from sample loader, from Dan.

5) Minor cleanup in sockmap to remove a set but not used variable,
   from Colin.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

21 files changed, 555 insertions, 101 deletions

diff --git a/drivers/net/ethernet/netronome/nfp/bpf/main.c b/drivers/net/ethernet/netronome/nfp/bpf/main.c
index b95b94d008cf..458f49235d06 100644
--- a/drivers/net/ethernet/netronome/nfp/bpf/main.c
+++ b/drivers/net/ethernet/netronome/nfp/bpf/main.c
@@ -404,6 +404,20 @@ err_release_free:
         return -EINVAL;
 }
 
+static int nfp_bpf_ndo_init(struct nfp_app *app, struct net_device *netdev)
+{
+        struct nfp_app_bpf *bpf = app->priv;
+
+        return bpf_offload_dev_netdev_register(bpf->bpf_dev, netdev);
+}
+
+static void nfp_bpf_ndo_uninit(struct nfp_app *app, struct net_device *netdev)
+{
+        struct nfp_app_bpf *bpf = app->priv;
+
+        bpf_offload_dev_netdev_unregister(bpf->bpf_dev, netdev);
+}
+
 static int nfp_bpf_init(struct nfp_app *app)
 {
         struct nfp_app_bpf *bpf;
@@ -427,6 +441,11 @@ static int nfp_bpf_init(struct nfp_app *app)
         if (err)
                 goto err_free_neutral_maps;
 
+        bpf->bpf_dev = bpf_offload_dev_create();
+        err = PTR_ERR_OR_ZERO(bpf->bpf_dev);
+        if (err)
+                goto err_free_neutral_maps;
+
         return 0;
 
 err_free_neutral_maps:
@@ -445,6 +464,7 @@ static void nfp_bpf_clean(struct nfp_app *app)
 {
         struct nfp_app_bpf *bpf = app->priv;
 
+        bpf_offload_dev_destroy(bpf->bpf_dev);
         WARN_ON(!skb_queue_empty(&bpf->cmsg_replies));
         WARN_ON(!list_empty(&bpf->map_list));
         WARN_ON(bpf->maps_in_use || bpf->map_elems_in_use);
@@ -466,6 +486,9 @@ const struct nfp_app_type app_bpf = {
 
         .extra_cap      = nfp_bpf_extra_cap,
 
+        .ndo_init       = nfp_bpf_ndo_init,
+        .ndo_uninit     = nfp_bpf_ndo_uninit,
+
         .vnic_alloc     = nfp_bpf_vnic_alloc,
         .vnic_free      = nfp_bpf_vnic_free,
 
diff --git a/drivers/net/ethernet/netronome/nfp/bpf/main.h b/drivers/net/ethernet/netronome/nfp/bpf/main.h
index 9845c1a2d4c2..bec935468f90 100644
--- a/drivers/net/ethernet/netronome/nfp/bpf/main.h
+++ b/drivers/net/ethernet/netronome/nfp/bpf/main.h
@@ -110,6 +110,8 @@ enum pkt_vec {
  * struct nfp_app_bpf - bpf app priv structure
  * @app:                backpointer to the app
  *
+ * @bpf_dev:            BPF offload device handle
+ *
  * @tag_allocator:      bitmap of control message tags in use
  * @tag_alloc_next:     next tag bit to allocate
  * @tag_alloc_last:     next tag bit to be freed
@@ -150,6 +152,8 @@ enum pkt_vec {
 struct nfp_app_bpf {
         struct nfp_app *app;
 
+        struct bpf_offload_dev *bpf_dev;
+
         DECLARE_BITMAP(tag_allocator, U16_MAX + 1);
         u16 tag_alloc_next;
         u16 tag_alloc_last;
diff --git a/drivers/net/ethernet/netronome/nfp/bpf/offload.c b/drivers/net/ethernet/netronome/nfp/bpf/offload.c
index 78f44c4d95b4..49b03f7dbf46 100644
--- a/drivers/net/ethernet/netronome/nfp/bpf/offload.c
+++ b/drivers/net/ethernet/netronome/nfp/bpf/offload.c
@@ -566,14 +566,8 @@ int nfp_net_bpf_offload(struct nfp_net *nn, struct bpf_prog *prog,
 {
         int err;
 
-        if (prog) {
-                struct bpf_prog_offload *offload = prog->aux->offload;
-
-                if (!offload)
-                        return -EINVAL;
-                if (offload->netdev != nn->dp.netdev)
-                        return -EINVAL;
-        }
+        if (prog && !bpf_offload_dev_match(prog, nn->dp.netdev))
+                return -EINVAL;
 
         if (prog && old_prog) {
                 u8 cap;
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_app.c b/drivers/net/ethernet/netronome/nfp/nfp_app.c
index f28b244f4ee7..69d4ae7a61f3 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_app.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_app.c
@@ -86,6 +86,23 @@ const char *nfp_app_mip_name(struct nfp_app *app)
         return nfp_mip_name(app->pf->mip);
 }
 
+int nfp_app_ndo_init(struct net_device *netdev)
+{
+        struct nfp_app *app = nfp_app_from_netdev(netdev);
+
+        if (!app || !app->type->ndo_init)
+                return 0;
+        return app->type->ndo_init(app, netdev);
+}
+
+void nfp_app_ndo_uninit(struct net_device *netdev)
+{
+        struct nfp_app *app = nfp_app_from_netdev(netdev);
+
+        if (app && app->type->ndo_uninit)
+                app->type->ndo_uninit(app, netdev);
+}
+
 u64 *nfp_app_port_get_stats(struct nfp_port *port, u64 *data)
 {
         if (!port || !port->app || !port->app->type->port_get_stats)
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_app.h b/drivers/net/ethernet/netronome/nfp/nfp_app.h
index ee74caacb015..afbc19aa66a8 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_app.h
+++ b/drivers/net/ethernet/netronome/nfp/nfp_app.h
@@ -78,6 +78,8 @@ extern const struct nfp_app_type app_abm;
  * @init:       perform basic app checks and init
  * @clean:      clean app state
  * @extra_cap:  extra capabilities string
+ * @ndo_init:   vNIC and repr netdev .ndo_init
+ * @ndo_uninit: vNIC and repr netdev .ndo_unint
  * @vnic_alloc: allocate vNICs (assign port types, etc.)
  * @vnic_free:  free up app's vNIC state
  * @vnic_init:  vNIC netdev was registered
@@ -117,6 +119,9 @@ struct nfp_app_type {
 
         const char *(*extra_cap)(struct nfp_app *app, struct nfp_net *nn);
 
+        int (*ndo_init)(struct nfp_app *app, struct net_device *netdev);
+        void (*ndo_uninit)(struct nfp_app *app, struct net_device *netdev);
+
         int (*vnic_alloc)(struct nfp_app *app, struct nfp_net *nn,
                           unsigned int id);
         void (*vnic_free)(struct nfp_app *app, struct nfp_net *nn);
@@ -200,6 +205,9 @@ static inline void nfp_app_clean(struct nfp_app *app)
                 app->type->clean(app);
 }
 
+int nfp_app_ndo_init(struct net_device *netdev);
+void nfp_app_ndo_uninit(struct net_device *netdev);
+
 static inline int nfp_app_vnic_alloc(struct nfp_app *app, struct nfp_net *nn,
                                      unsigned int id)
 {
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index a712e83c3f0f..279b8ab8a17b 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -3480,6 +3480,8 @@ static int nfp_net_set_mac_address(struct net_device *netdev, void *addr)
 }
 
 const struct net_device_ops nfp_net_netdev_ops = {
+        .ndo_init               = nfp_app_ndo_init,
+        .ndo_uninit             = nfp_app_ndo_uninit,
         .ndo_open               = nfp_net_netdev_open,
         .ndo_stop               = nfp_net_netdev_close,
         .ndo_start_xmit         = nfp_net_tx,
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_repr.c b/drivers/net/ethernet/netronome/nfp/nfp_net_repr.c
index d7b712f6362f..18a09cdcd9c6 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_repr.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_repr.c
@@ -262,6 +262,8 @@ err_port_disable:
 }
 
 const struct net_device_ops nfp_repr_netdev_ops = {
+        .ndo_init               = nfp_app_ndo_init,
+        .ndo_uninit             = nfp_app_ndo_uninit,
         .ndo_open               = nfp_repr_open,
         .ndo_stop               = nfp_repr_stop,
         .ndo_start_xmit         = nfp_repr_xmit,
diff --git a/drivers/net/netdevsim/bpf.c b/drivers/net/netdevsim/bpf.c
index c36d2a768202..81444208b216 100644
--- a/drivers/net/netdevsim/bpf.c
+++ b/drivers/net/netdevsim/bpf.c
@@ -238,8 +238,8 @@ static int nsim_bpf_create_prog(struct netdevsim *ns, struct bpf_prog *prog)
         state->state = "verify";
 
         /* Program id is not populated yet when we create the state. */
-        sprintf(name, "%u", ns->prog_id_gen++);
-        state->ddir = debugfs_create_dir(name, ns->ddir_bpf_bound_progs);
+        sprintf(name, "%u", ns->sdev->prog_id_gen++);
+        state->ddir = debugfs_create_dir(name, ns->sdev->ddir_bpf_bound_progs);
         if (IS_ERR_OR_NULL(state->ddir)) {
                 kfree(state);
                 return -ENOMEM;
@@ -250,7 +250,7 @@ static int nsim_bpf_create_prog(struct netdevsim *ns, struct bpf_prog *prog)
                             &state->state, &nsim_bpf_string_fops);
         debugfs_create_bool("loaded", 0400, state->ddir, &state->is_loaded);
 
-        list_add_tail(&state->l, &ns->bpf_bound_progs);
+        list_add_tail(&state->l, &ns->sdev->bpf_bound_progs);
 
         prog->aux->offload->dev_priv = state;
 
@@ -294,7 +294,7 @@ nsim_setup_prog_hw_checks(struct netdevsim *ns, struct netdev_bpf *bpf)
                 NSIM_EA(bpf->extack, "xdpoffload of non-bound program");
                 return -EINVAL;
         }
-        if (bpf->prog->aux->offload->netdev != ns->netdev) {
+        if (!bpf_offload_dev_match(bpf->prog, ns->netdev)) {
                 NSIM_EA(bpf->extack, "program bound to different dev");
                 return -EINVAL;
         }
@@ -497,7 +497,7 @@ nsim_bpf_map_alloc(struct netdevsim *ns, struct bpf_offloaded_map *offmap)
         }
 
         offmap->dev_ops = &nsim_bpf_map_ops;
-        list_add_tail(&nmap->l, &ns->bpf_bound_maps);
+        list_add_tail(&nmap->l, &ns->sdev->bpf_bound_maps);
 
         return 0;
 
@@ -582,8 +582,26 @@ int nsim_bpf(struct net_device *dev, struct netdev_bpf *bpf)
 
 int nsim_bpf_init(struct netdevsim *ns)
 {
-        INIT_LIST_HEAD(&ns->bpf_bound_progs);
-        INIT_LIST_HEAD(&ns->bpf_bound_maps);
+        int err;
+
+        if (ns->sdev->refcnt == 1) {
+                INIT_LIST_HEAD(&ns->sdev->bpf_bound_progs);
+                INIT_LIST_HEAD(&ns->sdev->bpf_bound_maps);
+
+                ns->sdev->ddir_bpf_bound_progs =
+                        debugfs_create_dir("bpf_bound_progs", ns->sdev->ddir);
+                if (IS_ERR_OR_NULL(ns->sdev->ddir_bpf_bound_progs))
+                        return -ENOMEM;
+
+                ns->sdev->bpf_dev = bpf_offload_dev_create();
+                err = PTR_ERR_OR_ZERO(ns->sdev->bpf_dev);
+                if (err)
+                        return err;
+        }
+
+        err = bpf_offload_dev_netdev_register(ns->sdev->bpf_dev, ns->netdev);
+        if (err)
+                goto err_destroy_bdev;
 
         debugfs_create_u32("bpf_offloaded_id", 0400, ns->ddir,
                            &ns->bpf_offloaded_id);
@@ -593,10 +611,6 @@ int nsim_bpf_init(struct netdevsim *ns)
                             &ns->bpf_bind_accept);
         debugfs_create_u32("bpf_bind_verifier_delay", 0600, ns->ddir,
                            &ns->bpf_bind_verifier_delay);
-        ns->ddir_bpf_bound_progs =
-                debugfs_create_dir("bpf_bound_progs", ns->ddir);
-        if (IS_ERR_OR_NULL(ns->ddir_bpf_bound_progs))
-                return -ENOMEM;
 
         ns->bpf_tc_accept = true;
         debugfs_create_bool("bpf_tc_accept", 0600, ns->ddir,
@@ -615,13 +629,23 @@ int nsim_bpf_init(struct netdevsim *ns)
                             &ns->bpf_map_accept);
 
         return 0;
+
+err_destroy_bdev:
+        if (ns->sdev->refcnt == 1)
+                bpf_offload_dev_destroy(ns->sdev->bpf_dev);
+        return err;
 }
 
 void nsim_bpf_uninit(struct netdevsim *ns)
 {
-        WARN_ON(!list_empty(&ns->bpf_bound_progs));
-        WARN_ON(!list_empty(&ns->bpf_bound_maps));
         WARN_ON(ns->xdp.prog);
         WARN_ON(ns->xdp_hw.prog);
         WARN_ON(ns->bpf_offloaded);
+        bpf_offload_dev_netdev_unregister(ns->sdev->bpf_dev, ns->netdev);
+
+        if (ns->sdev->refcnt == 1) {
+                WARN_ON(!list_empty(&ns->sdev->bpf_bound_progs));
+                WARN_ON(!list_empty(&ns->sdev->bpf_bound_maps));
+                bpf_offload_dev_destroy(ns->sdev->bpf_dev);
+        }
 }
diff --git a/drivers/net/netdevsim/netdev.c b/drivers/net/netdevsim/netdev.c
index a7b179f0d954..2d244551298b 100644
--- a/drivers/net/netdevsim/netdev.c
+++ b/drivers/net/netdevsim/netdev.c
@@ -22,6 +22,7 @@
 #include <net/netlink.h>
 #include <net/pkt_cls.h>
 #include <net/rtnetlink.h>
+#include <net/switchdev.h>
 
 #include "netdevsim.h"
 
@@ -144,8 +145,29 @@ static struct device_type nsim_dev_type = {
         .release = nsim_dev_release,
 };
 
+static int
+nsim_port_attr_get(struct net_device *dev, struct switchdev_attr *attr)
+{
+        struct netdevsim *ns = netdev_priv(dev);
+
+        switch (attr->id) {
+        case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
+                attr->u.ppid.id_len = sizeof(ns->sdev->switch_id);
+                memcpy(&attr->u.ppid.id, &ns->sdev->switch_id,
+                       attr->u.ppid.id_len);
+                return 0;
+        default:
+                return -EOPNOTSUPP;
+        }
+}
+
+static const struct switchdev_ops nsim_switchdev_ops = {
+        .switchdev_port_attr_get        = nsim_port_attr_get,
+};
+
 static int nsim_init(struct net_device *dev)
 {
+        char sdev_ddir_name[10], sdev_link_name[32];
         struct netdevsim *ns = netdev_priv(dev);
         int err;
 
@@ -154,9 +176,32 @@ static int nsim_init(struct net_device *dev)
         if (IS_ERR_OR_NULL(ns->ddir))
                 return -ENOMEM;
 
+        if (!ns->sdev) {
+                ns->sdev = kzalloc(sizeof(*ns->sdev), GFP_KERNEL);
+                if (!ns->sdev) {
+                        err = -ENOMEM;
+                        goto err_debugfs_destroy;
+                }
+                ns->sdev->refcnt = 1;
+                ns->sdev->switch_id = nsim_dev_id;
+                sprintf(sdev_ddir_name, "%u", ns->sdev->switch_id);
+                ns->sdev->ddir = debugfs_create_dir(sdev_ddir_name,
+                                                    nsim_sdev_ddir);
+                if (IS_ERR_OR_NULL(ns->sdev->ddir)) {
+                        err = PTR_ERR_OR_ZERO(ns->sdev->ddir) ?: -EINVAL;
+                        goto err_sdev_free;
+                }
+        } else {
+                sprintf(sdev_ddir_name, "%u", ns->sdev->switch_id);
+                ns->sdev->refcnt++;
+        }
+
+        sprintf(sdev_link_name, "../../" DRV_NAME "_sdev/%s", sdev_ddir_name);
+        debugfs_create_symlink("sdev", ns->ddir, sdev_link_name);
+
         err = nsim_bpf_init(ns);
         if (err)
-                goto err_debugfs_destroy;
+                goto err_sdev_destroy;
 
         ns->dev.id = nsim_dev_id++;
         ns->dev.bus = &nsim_bus;
@@ -166,6 +211,7 @@ static int nsim_init(struct net_device *dev)
                 goto err_bpf_uninit;
 
         SET_NETDEV_DEV(dev, &ns->dev);
+        SWITCHDEV_SET_OPS(dev, &nsim_switchdev_ops);
 
         err = nsim_devlink_setup(ns);
         if (err)
@@ -179,6 +225,12 @@ err_unreg_dev:
         device_unregister(&ns->dev);
 err_bpf_uninit:
         nsim_bpf_uninit(ns);
+err_sdev_destroy:
+        if (!--ns->sdev->refcnt) {
+                debugfs_remove_recursive(ns->sdev->ddir);
+err_sdev_free:
+                kfree(ns->sdev);
+        }
 err_debugfs_destroy:
         debugfs_remove_recursive(ns->ddir);
         return err;
@@ -192,6 +244,10 @@ static void nsim_uninit(struct net_device *dev)
         nsim_devlink_teardown(ns);
         debugfs_remove_recursive(ns->ddir);
         nsim_bpf_uninit(ns);
+        if (!--ns->sdev->refcnt) {
+                debugfs_remove_recursive(ns->sdev->ddir);
+                kfree(ns->sdev);
+        }
 }
 
 static void nsim_free(struct net_device *dev)
@@ -470,14 +526,48 @@ static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
         return 0;
 }
 
+static int nsim_newlink(struct net *src_net, struct net_device *dev,
+                        struct nlattr *tb[], struct nlattr *data[],
+                        struct netlink_ext_ack *extack)
+{
+        struct netdevsim *ns = netdev_priv(dev);
+
+        if (tb[IFLA_LINK]) {
+                struct net_device *joindev;
+                struct netdevsim *joinns;
+
+                joindev = __dev_get_by_index(src_net,
+                                             nla_get_u32(tb[IFLA_LINK]));
+                if (!joindev)
+                        return -ENODEV;
+                if (joindev->netdev_ops != &nsim_netdev_ops)
+                        return -EINVAL;
+
+                joinns = netdev_priv(joindev);
+                if (!joinns->sdev || !joinns->sdev->refcnt)
+                        return -EINVAL;
+                ns->sdev = joinns->sdev;
+        }
+
+        return register_netdevice(dev);
+}
+
+static void nsim_dellink(struct net_device *dev, struct list_head *head)
+{
+        unregister_netdevice_queue(dev, head);
+}
+
 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
         .kind           = DRV_NAME,
         .priv_size      = sizeof(struct netdevsim),
         .setup          = nsim_setup,
         .validate       = nsim_validate,
+        .newlink        = nsim_newlink,
+        .dellink        = nsim_dellink,
 };
 
 struct dentry *nsim_ddir;
+struct dentry *nsim_sdev_ddir;
 
 static int __init nsim_module_init(void)
 {
@@ -487,9 +577,15 @@ static int __init nsim_module_init(void)
         if (IS_ERR_OR_NULL(nsim_ddir))
                 return -ENOMEM;
 
+        nsim_sdev_ddir = debugfs_create_dir(DRV_NAME "_sdev", NULL);
+        if (IS_ERR_OR_NULL(nsim_sdev_ddir)) {
+                err = -ENOMEM;
+                goto err_debugfs_destroy;
+        }
+
         err = bus_register(&nsim_bus);
         if (err)
-                goto err_debugfs_destroy;
+                goto err_sdir_destroy;
 
         err = nsim_devlink_init();
         if (err)
@@ -505,6 +601,8 @@ err_dl_fini:
         nsim_devlink_exit();
 err_unreg_bus:
         bus_unregister(&nsim_bus);
+err_sdir_destroy:
+        debugfs_remove_recursive(nsim_sdev_ddir);
 err_debugfs_destroy:
         debugfs_remove_recursive(nsim_ddir);
         return err;
@@ -515,6 +613,7 @@ static void __exit nsim_module_exit(void)
         rtnl_link_unregister(&nsim_link_ops);
         nsim_devlink_exit();
         bus_unregister(&nsim_bus);
+        debugfs_remove_recursive(nsim_sdev_ddir);
         debugfs_remove_recursive(nsim_ddir);
 }
 
diff --git a/drivers/net/netdevsim/netdevsim.h b/drivers/net/netdevsim/netdevsim.h
index 0aeabbe81cc6..02be199eb005 100644
--- a/drivers/net/netdevsim/netdevsim.h
+++ b/drivers/net/netdevsim/netdevsim.h
@@ -27,9 +27,25 @@
 #define NSIM_EA(extack, msg)    NL_SET_ERR_MSG_MOD((extack), msg)
 
 struct bpf_prog;
+struct bpf_offload_dev;
 struct dentry;
 struct nsim_vf_config;
 
+struct netdevsim_shared_dev {
+        unsigned int refcnt;
+        u32 switch_id;
+
+        struct dentry *ddir;
+
+        struct bpf_offload_dev *bpf_dev;
+
+        struct dentry *ddir_bpf_bound_progs;
+        u32 prog_id_gen;
+
+        struct list_head bpf_bound_progs;
+        struct list_head bpf_bound_maps;
+};
+
 #define NSIM_IPSEC_MAX_SA_COUNT         33
 #define NSIM_IPSEC_VALID                BIT(31)
 
@@ -59,6 +75,7 @@ struct netdevsim {
         struct u64_stats_sync syncp;
 
         struct device dev;
+        struct netdevsim_shared_dev *sdev;
 
         struct dentry *ddir;
 
@@ -71,12 +88,8 @@ struct netdevsim {
         struct xdp_attachment_info xdp;
         struct xdp_attachment_info xdp_hw;
 
-        u32 prog_id_gen;
-
         bool bpf_bind_accept;
         u32 bpf_bind_verifier_delay;
-        struct dentry *ddir_bpf_bound_progs;
-        struct list_head bpf_bound_progs;
 
         bool bpf_tc_accept;
         bool bpf_tc_non_bound_accept;
@@ -84,7 +97,6 @@ struct netdevsim {
         bool bpf_xdpoffload_accept;
 
         bool bpf_map_accept;
-        struct list_head bpf_bound_maps;
 #if IS_ENABLED(CONFIG_NET_DEVLINK)
         struct devlink *devlink;
 #endif
@@ -92,6 +104,7 @@ struct netdevsim {
 };
 
 extern struct dentry *nsim_ddir;
+extern struct dentry *nsim_sdev_ddir;
 
 #ifdef CONFIG_BPF_SYSCALL
 int nsim_bpf_init(struct netdevsim *ns);
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 8827e797ff97..5b5ad95cf339 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -85,6 +85,7 @@ struct bpf_map {
         char name[BPF_OBJ_NAME_LEN];
 };
 
+struct bpf_offload_dev;
 struct bpf_offloaded_map;
 
 struct bpf_map_dev_ops {
@@ -352,7 +353,7 @@ struct bpf_prog_array {
         struct bpf_prog *progs[0];
 };
 
-struct bpf_prog_array __rcu *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
+struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
 void bpf_prog_array_free(struct bpf_prog_array __rcu *progs);
 int bpf_prog_array_length(struct bpf_prog_array __rcu *progs);
 int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs,
@@ -648,7 +649,15 @@ int bpf_map_offload_delete_elem(struct bpf_map *map, void *key);
 int bpf_map_offload_get_next_key(struct bpf_map *map,
                                  void *key, void *next_key);
 
-bool bpf_offload_dev_match(struct bpf_prog *prog, struct bpf_map *map);
+bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map);
+
+struct bpf_offload_dev *bpf_offload_dev_create(void);
+void bpf_offload_dev_destroy(struct bpf_offload_dev *offdev);
+int bpf_offload_dev_netdev_register(struct bpf_offload_dev *offdev,
+                                    struct net_device *netdev);
+void bpf_offload_dev_netdev_unregister(struct bpf_offload_dev *offdev,
+                                       struct net_device *netdev);
+bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev);
 
 #if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL)
 int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr);
diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c
index 3d83ee7df381..badabb0b435c 100644
--- a/kernel/bpf/cgroup.c
+++ b/kernel/bpf/cgroup.c
@@ -95,7 +95,7 @@ static int compute_effective_progs(struct cgroup *cgrp,
                                    enum bpf_attach_type type,
                                    struct bpf_prog_array __rcu **array)
 {
-        struct bpf_prog_array __rcu *progs;
+        struct bpf_prog_array *progs;
         struct bpf_prog_list *pl;
         struct cgroup *p = cgrp;
         int cnt = 0;
@@ -120,13 +120,12 @@ static int compute_effective_progs(struct cgroup *cgrp,
                                             &p->bpf.progs[type], node) {
                                 if (!pl->prog)
                                         continue;
-                                rcu_dereference_protected(progs, 1)->
-                                        progs[cnt++] = pl->prog;
+                                progs->progs[cnt++] = pl->prog;
                         }
                 p = cgroup_parent(p);
         } while (p);
 
-        *array = progs;
+        rcu_assign_pointer(*array, progs);
         return 0;
 }
 
diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index 1e5625d46414..253aa8e79c7b 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -1538,7 +1538,7 @@ static struct {
         .null_prog = NULL,
 };
 
-struct bpf_prog_array __rcu *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags)
+struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags)
 {
         if (prog_cnt)
                 return kzalloc(sizeof(struct bpf_prog_array) +
diff --git a/kernel/bpf/offload.c b/kernel/bpf/offload.c
index ac747d5cf7c6..177a52436394 100644
--- a/kernel/bpf/offload.c
+++ b/kernel/bpf/offload.c
@@ -18,19 +18,43 @@
 #include <linux/bug.h>
 #include <linux/kdev_t.h>
 #include <linux/list.h>
+#include <linux/lockdep.h>
 #include <linux/netdevice.h>
 #include <linux/printk.h>
 #include <linux/proc_ns.h>
+#include <linux/rhashtable.h>
 #include <linux/rtnetlink.h>
 #include <linux/rwsem.h>
 
-/* Protects bpf_prog_offload_devs, bpf_map_offload_devs and offload members
+/* Protects offdevs, members of bpf_offload_netdev and offload members
  * of all progs.
  * RTNL lock cannot be taken when holding this lock.
  */
 static DECLARE_RWSEM(bpf_devs_lock);
-static LIST_HEAD(bpf_prog_offload_devs);
-static LIST_HEAD(bpf_map_offload_devs);
+
+struct bpf_offload_dev {
+        struct list_head netdevs;
+};
+
+struct bpf_offload_netdev {
+        struct rhash_head l;
+        struct net_device *netdev;
+        struct bpf_offload_dev *offdev;
+        struct list_head progs;
+        struct list_head maps;
+        struct list_head offdev_netdevs;
+};
+
+static const struct rhashtable_params offdevs_params = {
+        .nelem_hint             = 4,
+        .key_len                = sizeof(struct net_device *),
+        .key_offset             = offsetof(struct bpf_offload_netdev, netdev),
+        .head_offset            = offsetof(struct bpf_offload_netdev, l),
+        .automatic_shrinking    = true,
+};
+
+static struct rhashtable offdevs;
+static bool offdevs_inited;
 
 static int bpf_dev_offload_check(struct net_device *netdev)
 {
@@ -41,8 +65,19 @@ static int bpf_dev_offload_check(struct net_device *netdev)
         return 0;
 }
 
+static struct bpf_offload_netdev *
+bpf_offload_find_netdev(struct net_device *netdev)
+{
+        lockdep_assert_held(&bpf_devs_lock);
+
+        if (!offdevs_inited)
+                return NULL;
+        return rhashtable_lookup_fast(&offdevs, &netdev, offdevs_params);
+}
+
 int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr)
 {
+        struct bpf_offload_netdev *ondev;
         struct bpf_prog_offload *offload;
         int err;
 
@@ -66,12 +101,13 @@ int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr)
                 goto err_maybe_put;
 
         down_write(&bpf_devs_lock);
-        if (offload->netdev->reg_state != NETREG_REGISTERED) {
+        ondev = bpf_offload_find_netdev(offload->netdev);
+        if (!ondev) {
                 err = -EINVAL;
                 goto err_unlock;
         }
         prog->aux->offload = offload;
-        list_add_tail(&offload->offloads, &bpf_prog_offload_devs);
+        list_add_tail(&offload->offloads, &ondev->progs);
         dev_put(offload->netdev);
         up_write(&bpf_devs_lock);
 
@@ -294,6 +330,7 @@ static int bpf_map_offload_ndo(struct bpf_offloaded_map *offmap,
 struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr)
 {
         struct net *net = current->nsproxy->net_ns;
+        struct bpf_offload_netdev *ondev;
         struct bpf_offloaded_map *offmap;
         int err;
 
@@ -316,11 +353,17 @@ struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr)
         if (err)
                 goto err_unlock;
 
+        ondev = bpf_offload_find_netdev(offmap->netdev);
+        if (!ondev) {
+                err = -EINVAL;
+                goto err_unlock;
+        }
+
         err = bpf_map_offload_ndo(offmap, BPF_OFFLOAD_MAP_ALLOC);
         if (err)
                 goto err_unlock;
 
-        list_add_tail(&offmap->offloads, &bpf_map_offload_devs);
+        list_add_tail(&offmap->offloads, &ondev->maps);
         up_write(&bpf_devs_lock);
         rtnl_unlock();
 
@@ -468,77 +511,159 @@ int bpf_map_offload_info_fill(struct bpf_map_info *info, struct bpf_map *map)
         return 0;
 }
 
-bool bpf_offload_dev_match(struct bpf_prog *prog, struct bpf_map *map)
+static bool __bpf_offload_dev_match(struct bpf_prog *prog,
+                                    struct net_device *netdev)
 {
-        struct bpf_offloaded_map *offmap;
+        struct bpf_offload_netdev *ondev1, *ondev2;
         struct bpf_prog_offload *offload;
-        bool ret;
 
         if (!bpf_prog_is_dev_bound(prog->aux))
                 return false;
-        if (!bpf_map_is_dev_bound(map))
-                return bpf_map_offload_neutral(map);
 
-        down_read(&bpf_devs_lock);
         offload = prog->aux->offload;
-        offmap = map_to_offmap(map);
+        if (!offload)
+                return false;
+        if (offload->netdev == netdev)
+                return true;
 
-        ret = offload && offload->netdev == offmap->netdev;
+        ondev1 = bpf_offload_find_netdev(offload->netdev);
+        ondev2 = bpf_offload_find_netdev(netdev);
+
+        return ondev1 && ondev2 && ondev1->offdev == ondev2->offdev;
+}
+
+bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev)
+{
+        bool ret;
+
+        down_read(&bpf_devs_lock);
+        ret = __bpf_offload_dev_match(prog, netdev);
         up_read(&bpf_devs_lock);
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(bpf_offload_dev_match);
 
-static void bpf_offload_orphan_all_progs(struct net_device *netdev)
+bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map)
 {
-        struct bpf_prog_offload *offload, *tmp;
+        struct bpf_offloaded_map *offmap;
+        bool ret;
 
-        list_for_each_entry_safe(offload, tmp, &bpf_prog_offload_devs, offloads)
-                if (offload->netdev == netdev)
-                        __bpf_prog_offload_destroy(offload->prog);
+        if (!bpf_map_is_dev_bound(map))
+                return bpf_map_offload_neutral(map);
+        offmap = map_to_offmap(map);
+
+        down_read(&bpf_devs_lock);
+        ret = __bpf_offload_dev_match(prog, offmap->netdev);
+        up_read(&bpf_devs_lock);
+
+        return ret;
 }
 
-static void bpf_offload_orphan_all_maps(struct net_device *netdev)
+int bpf_offload_dev_netdev_register(struct bpf_offload_dev *offdev,
+                                    struct net_device *netdev)
 {
-        struct bpf_offloaded_map *offmap, *tmp;
+        struct bpf_offload_netdev *ondev;
+        int err;
 
-        list_for_each_entry_safe(offmap, tmp, &bpf_map_offload_devs, offloads)
-                if (offmap->netdev == netdev)
-                        __bpf_map_offload_destroy(offmap);
+        ondev = kzalloc(sizeof(*ondev), GFP_KERNEL);
+        if (!ondev)
+                return -ENOMEM;
+
+        ondev->netdev = netdev;
+        ondev->offdev = offdev;
+        INIT_LIST_HEAD(&ondev->progs);
+        INIT_LIST_HEAD(&ondev->maps);
+
+        down_write(&bpf_devs_lock);
+        err = rhashtable_insert_fast(&offdevs, &ondev->l, offdevs_params);
+        if (err) {
+                netdev_warn(netdev, "failed to register for BPF offload\n");
+                goto err_unlock_free;
+        }
+
+        list_add(&ondev->offdev_netdevs, &offdev->netdevs);
+        up_write(&bpf_devs_lock);
+        return 0;
+
+err_unlock_free:
+        up_write(&bpf_devs_lock);
+        kfree(ondev);
+        return err;
 }
+EXPORT_SYMBOL_GPL(bpf_offload_dev_netdev_register);
 
-static int bpf_offload_notification(struct notifier_block *notifier,
-                                    ulong event, void *ptr)
+void bpf_offload_dev_netdev_unregister(struct bpf_offload_dev *offdev,
+                                       struct net_device *netdev)
 {
-        struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
+        struct bpf_offload_netdev *ondev, *altdev;
+        struct bpf_offloaded_map *offmap, *mtmp;
+        struct bpf_prog_offload *offload, *ptmp;
 
         ASSERT_RTNL();
 
-        switch (event) {
-        case NETDEV_UNREGISTER:
-                /* ignore namespace changes */
-                if (netdev->reg_state != NETREG_UNREGISTERING)
-                        break;
-
-                down_write(&bpf_devs_lock);
-                bpf_offload_orphan_all_progs(netdev);
-                bpf_offload_orphan_all_maps(netdev);
-                up_write(&bpf_devs_lock);
-                break;
-        default:
-                break;
+        down_write(&bpf_devs_lock);
+        ondev = rhashtable_lookup_fast(&offdevs, &netdev, offdevs_params);
+        if (WARN_ON(!ondev))
+                goto unlock;
+
+        WARN_ON(rhashtable_remove_fast(&offdevs, &ondev->l, offdevs_params));
+        list_del(&ondev->offdev_netdevs);
+
+        /* Try to move the objects to another netdev of the device */
+        altdev = list_first_entry_or_null(&offdev->netdevs,
+                                          struct bpf_offload_netdev,
+                                          offdev_netdevs);
+        if (altdev) {
+                list_for_each_entry(offload, &ondev->progs, offloads)
+                        offload->netdev = altdev->netdev;
+                list_splice_init(&ondev->progs, &altdev->progs);
+
+                list_for_each_entry(offmap, &ondev->maps, offloads)
+                        offmap->netdev = altdev->netdev;
+                list_splice_init(&ondev->maps, &altdev->maps);
+        } else {
+                list_for_each_entry_safe(offload, ptmp, &ondev->progs, offloads)
+                        __bpf_prog_offload_destroy(offload->prog);
+                list_for_each_entry_safe(offmap, mtmp, &ondev->maps, offloads)
+                        __bpf_map_offload_destroy(offmap);
         }
-        return NOTIFY_OK;
-}
 
-static struct notifier_block bpf_offload_notifier = {
-        .notifier_call = bpf_offload_notification,
-};
+        WARN_ON(!list_empty(&ondev->progs));
+        WARN_ON(!list_empty(&ondev->maps));
+        kfree(ondev);
+unlock:
+        up_write(&bpf_devs_lock);
+}
+EXPORT_SYMBOL_GPL(bpf_offload_dev_netdev_unregister);
 
-static int __init bpf_offload_init(void)
+struct bpf_offload_dev *bpf_offload_dev_create(void)
 {
-        register_netdevice_notifier(&bpf_offload_notifier);
-        return 0;
+        struct bpf_offload_dev *offdev;
+        int err;
+
+        down_write(&bpf_devs_lock);
+        if (!offdevs_inited) {
+                err = rhashtable_init(&offdevs, &offdevs_params);
+                if (err)
+                        return ERR_PTR(err);
+                offdevs_inited = true;
+        }
+        up_write(&bpf_devs_lock);
+
+        offdev = kzalloc(sizeof(*offdev), GFP_KERNEL);
+        if (!offdev)
+                return ERR_PTR(-ENOMEM);
+
+        INIT_LIST_HEAD(&offdev->netdevs);
+
+        return offdev;
 }
+EXPORT_SYMBOL_GPL(bpf_offload_dev_create);
 
-subsys_initcall(bpf_offload_init);
+void bpf_offload_dev_destroy(struct bpf_offload_dev *offdev)
+{
+        WARN_ON(!list_empty(&offdev->netdevs));
+        kfree(offdev);
+}
+EXPORT_SYMBOL_GPL(bpf_offload_dev_destroy);
diff --git a/kernel/bpf/sockmap.c b/kernel/bpf/sockmap.c
index 98fb7938beea..0b38be5a955c 100644
--- a/kernel/bpf/sockmap.c
+++ b/kernel/bpf/sockmap.c
@@ -725,11 +725,8 @@ static int bpf_tcp_sendmsg_do_redirect(struct sock *sk, int send,
 {
         bool ingress = !!(md->flags & BPF_F_INGRESS);
         struct smap_psock *psock;
-        struct scatterlist *sg;
         int err = 0;
 
-        sg = md->sg_data;
-
         rcu_read_lock();
         psock = smap_psock_sk(sk);
         if (unlikely(!psock))
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 63aaac52a265..25e47c195874 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -5054,7 +5054,7 @@ static int check_map_prog_compatibility(struct bpf_verifier_env *env,
         }
 
         if ((bpf_prog_is_dev_bound(prog->aux) || bpf_map_is_dev_bound(map)) &&
-            !bpf_offload_dev_match(prog, map)) {
+            !bpf_offload_prog_map_match(prog, map)) {
                 verbose(env, "offload device mismatch between prog and map\n");
                 return -EINVAL;
         }
diff --git a/samples/bpf/bpf_load.c b/samples/bpf/bpf_load.c
index 89161c9ed466..904e775d1a44 100644
--- a/samples/bpf/bpf_load.c
+++ b/samples/bpf/bpf_load.c
@@ -107,6 +107,9 @@ static int load_and_attach(const char *event, struct bpf_insn *prog, int size)
                 return -1;
         }
 
+        if (prog_cnt == MAX_PROGS)
+                return -1;
+
         fd = bpf_load_program(prog_type, prog, insns_cnt, license, kern_version,
                               bpf_log_buf, BPF_LOG_BUF_SIZE);
         if (fd < 0) {
diff --git a/samples/bpf/test_cgrp2_sock2.c b/samples/bpf/test_cgrp2_sock2.c
index 3b5be2364975..a9277b118c33 100644
--- a/samples/bpf/test_cgrp2_sock2.c
+++ b/samples/bpf/test_cgrp2_sock2.c
@@ -51,7 +51,7 @@ int main(int argc, char **argv)
         if (argc > 3)
                 filter_id = atoi(argv[3]);
 
-        if (filter_id > prog_cnt) {
+        if (filter_id >= prog_cnt) {
                 printf("Invalid program id; program not found in file\n");
                 return EXIT_FAILURE;
         }
diff --git a/tools/bpf/bpftool/Makefile b/tools/bpf/bpftool/Makefile
index 6c4830e18879..74288a2197ab 100644
--- a/tools/bpf/bpftool/Makefile
+++ b/tools/bpf/bpftool/Makefile
@@ -26,7 +26,7 @@ LIBBPF = $(BPF_PATH)libbpf.a
 BPFTOOL_VERSION := $(shell make --no-print-directory -sC ../../.. kernelversion)
 
 $(LIBBPF): FORCE
-        $(Q)$(MAKE) -C $(BPF_DIR) OUTPUT=$(OUTPUT) $(OUTPUT)libbpf.a FEATURES_DUMP=$(FEATURE_DUMP_EXPORT)
+        $(Q)$(MAKE) -C $(BPF_DIR) OUTPUT=$(OUTPUT) $(OUTPUT)libbpf.a
 
 $(LIBBPF)-clean:
         $(call QUIET_CLEAN, libbpf)
diff --git a/tools/lib/bpf/Makefile b/tools/lib/bpf/Makefile
index 7a8e4c98ef1a..d49902e818b5 100644
--- a/tools/lib/bpf/Makefile
+++ b/tools/lib/bpf/Makefile
@@ -66,7 +66,7 @@ ifndef VERBOSE
 endif
 
 FEATURE_USER = .libbpf
-FEATURE_TESTS = libelf libelf-getphdrnum libelf-mmap bpf reallocarray
+FEATURE_TESTS = libelf libelf-mmap bpf reallocarray
 FEATURE_DISPLAY = libelf bpf
 
 INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi -I$(srctree)/tools/perf
@@ -116,10 +116,6 @@ ifeq ($(feature-libelf-mmap), 1)
   override CFLAGS += -DHAVE_LIBELF_MMAP_SUPPORT
 endif
 
-ifeq ($(feature-libelf-getphdrnum), 1)
-  override CFLAGS += -DHAVE_ELF_GETPHDRNUM_SUPPORT
-endif
-
 ifeq ($(feature-reallocarray), 0)
   override CFLAGS += -DCOMPAT_NEED_REALLOCARRAY
 endif
diff --git a/tools/testing/selftests/bpf/test_offload.py b/tools/testing/selftests/bpf/test_offload.py
index b746227eaff2..d59642e70f56 100755
--- a/tools/testing/selftests/bpf/test_offload.py
+++ b/tools/testing/selftests/bpf/test_offload.py
@@ -158,8 +158,9 @@ def tool(name, args, flags, JSON=True, ns="", fail=True, include_stderr=False):
     else:
         return ret, out
 
-def bpftool(args, JSON=True, ns="", fail=True):
-    return tool("bpftool", args, {"json":"-p"}, JSON=JSON, ns=ns, fail=fail)
+def bpftool(args, JSON=True, ns="", fail=True, include_stderr=False):
+    return tool("bpftool", args, {"json":"-p"}, JSON=JSON, ns=ns,
+                fail=fail, include_stderr=include_stderr)
 
 def bpftool_prog_list(expected=None, ns=""):
     _, progs = bpftool("prog show", JSON=True, ns=ns, fail=True)
@@ -201,6 +202,21 @@ def bpftool_map_list_wait(expected=0, n_retry=20):
         time.sleep(0.05)
     raise Exception("Time out waiting for map counts to stabilize want %d, have %d" % (expected, nmaps))
 
+def bpftool_prog_load(sample, file_name, maps=[], prog_type="xdp", dev=None,
+                      fail=True, include_stderr=False):
+    args = "prog load %s %s" % (os.path.join(bpf_test_dir, sample), file_name)
+    if prog_type is not None:
+        args += " type " + prog_type
+    if dev is not None:
+        args += " dev " + dev
+    if len(maps):
+        args += " map " + " map ".join(maps)
+
+    res = bpftool(args, fail=fail, include_stderr=include_stderr)
+    if res[0] == 0:
+        files.append(file_name)
+    return res
+
 def ip(args, force=False, JSON=True, ns="", fail=True, include_stderr=False):
     if force:
         args = "-force " + args
@@ -307,21 +323,25 @@ class NetdevSim:
     Class for netdevsim netdevice and its attributes.
     """
 
-    def __init__(self):
+    def __init__(self, link=None):
+        self.link = link
+
         self.dev = self._netdevsim_create()
         devs.append(self)
 
         self.ns = ""
 
         self.dfs_dir = '/sys/kernel/debug/netdevsim/%s' % (self.dev['ifname'])
+        self.sdev_dir = self.dfs_dir + '/sdev/'
         self.dfs_refresh()
 
     def __getitem__(self, key):
         return self.dev[key]
 
     def _netdevsim_create(self):
+        link = "" if self.link is None else "link " + self.link.dev['ifname']
         _, old  = ip("link show")
-        ip("link add sim%d type netdevsim")
+        ip("link add sim%d {link} type netdevsim".format(link=link))
         _, new  = ip("link show")
 
         for dev in new:
@@ -345,12 +365,12 @@ class NetdevSim:
         return data.strip()
 
     def dfs_num_bound_progs(self):
-        path = os.path.join(self.dfs_dir, "bpf_bound_progs")
+        path = os.path.join(self.sdev_dir, "bpf_bound_progs")
         _, progs = cmd('ls %s' % (path))
         return len(progs.split())
 
     def dfs_get_bound_progs(self, expected):
-        progs = DebugfsDir(os.path.join(self.dfs_dir, "bpf_bound_progs"))
+        progs = DebugfsDir(os.path.join(self.sdev_dir, "bpf_bound_progs"))
         if expected is not None:
             if len(progs) != expected:
                 fail(True, "%d BPF programs bound, expected %d" %
@@ -847,6 +867,25 @@ try:
     sim.set_mtu(1500)
 
     sim.wait_for_flush()
+    start_test("Test non-offload XDP attaching to HW...")
+    bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/nooffload")
+    nooffload = bpf_pinned("/sys/fs/bpf/nooffload")
+    ret, _, err = sim.set_xdp(nooffload, "offload",
+                              fail=False, include_stderr=True)
+    fail(ret == 0, "attached non-offloaded XDP program to HW")
+    check_extack_nsim(err, "xdpoffload of non-bound program.", args)
+    rm("/sys/fs/bpf/nooffload")
+
+    start_test("Test offload XDP attaching to drv...")
+    bpftool_prog_load("sample_ret0.o", "/sys/fs/bpf/offload",
+                      dev=sim['ifname'])
+    offload = bpf_pinned("/sys/fs/bpf/offload")
+    ret, _, err = sim.set_xdp(offload, "drv", fail=False, include_stderr=True)
+    fail(ret == 0, "attached offloaded XDP program to drv")
+    check_extack(err, "using device-bound program without HW_MODE flag is not supported.", args)
+    rm("/sys/fs/bpf/offload")
+    sim.wait_for_flush()
+
     start_test("Test XDP offload...")
     _, _, err = sim.set_xdp(obj, "offload", verbose=True, include_stderr=True)
     ipl = sim.ip_link_show(xdp=True)
@@ -1140,6 +1179,106 @@ try:
     fail(ret == 0,
          "netdevsim didn't refuse to create a map with offload disabled")
 
+    sim.remove()
+
+    start_test("Test multi-dev ASIC program reuse...")
+    simA = NetdevSim()
+    simB1 = NetdevSim()
+    simB2 = NetdevSim(link=simB1)
+    simB3 = NetdevSim(link=simB1)
+    sims = (simA, simB1, simB2, simB3)
+    simB = (simB1, simB2, simB3)
+
+    bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimA",
+                      dev=simA['ifname'])
+    progA = bpf_pinned("/sys/fs/bpf/nsimA")
+    bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB",
+                      dev=simB1['ifname'])
+    progB = bpf_pinned("/sys/fs/bpf/nsimB")
+
+    simA.set_xdp(progA, "offload", JSON=False)
+    for d in simB:
+        d.set_xdp(progB, "offload", JSON=False)
+
+    start_test("Test multi-dev ASIC cross-dev replace...")
+    ret, _ = simA.set_xdp(progB, "offload", force=True, JSON=False, fail=False)
+    fail(ret == 0, "cross-ASIC program allowed")
+    for d in simB:
+        ret, _ = d.set_xdp(progA, "offload", force=True, JSON=False, fail=False)
+        fail(ret == 0, "cross-ASIC program allowed")
+
+    start_test("Test multi-dev ASIC cross-dev install...")
+    for d in sims:
+        d.unset_xdp("offload")
+
+    ret, _, err = simA.set_xdp(progB, "offload", force=True, JSON=False,
+                               fail=False, include_stderr=True)
+    fail(ret == 0, "cross-ASIC program allowed")
+    check_extack_nsim(err, "program bound to different dev.", args)
+    for d in simB:
+        ret, _, err = d.set_xdp(progA, "offload", force=True, JSON=False,
+                                fail=False, include_stderr=True)
+        fail(ret == 0, "cross-ASIC program allowed")
+        check_extack_nsim(err, "program bound to different dev.", args)
+
+    start_test("Test multi-dev ASIC cross-dev map reuse...")
+
+    mapA = bpftool("prog show %s" % (progA))[1]["map_ids"][0]
+    mapB = bpftool("prog show %s" % (progB))[1]["map_ids"][0]
+
+    ret, _ = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB_",
+                               dev=simB3['ifname'],
+                               maps=["idx 0 id %d" % (mapB)],
+                               fail=False)
+    fail(ret != 0, "couldn't reuse a map on the same ASIC")
+    rm("/sys/fs/bpf/nsimB_")
+
+    ret, _, err = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimA_",
+                                    dev=simA['ifname'],
+                                    maps=["idx 0 id %d" % (mapB)],
+                                    fail=False, include_stderr=True)
+    fail(ret == 0, "could reuse a map on a different ASIC")
+    fail(err.count("offload device mismatch between prog and map") == 0,
+         "error message missing for cross-ASIC map")
+
+    ret, _, err = bpftool_prog_load("sample_map_ret0.o", "/sys/fs/bpf/nsimB_",
+                                    dev=simB1['ifname'],
+                                    maps=["idx 0 id %d" % (mapA)],
+                                    fail=False, include_stderr=True)
+    fail(ret == 0, "could reuse a map on a different ASIC")
+    fail(err.count("offload device mismatch between prog and map") == 0,
+         "error message missing for cross-ASIC map")
+
+    start_test("Test multi-dev ASIC cross-dev destruction...")
+    bpftool_prog_list_wait(expected=2)
+
+    simA.remove()
+    bpftool_prog_list_wait(expected=1)
+
+    ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"]
+    fail(ifnameB != simB1['ifname'], "program not bound to originial device")
+    simB1.remove()
+    bpftool_prog_list_wait(expected=1)
+
+    start_test("Test multi-dev ASIC cross-dev destruction - move...")
+    ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"]
+    fail(ifnameB not in (simB2['ifname'], simB3['ifname']),
+         "program not bound to remaining devices")
+
+    simB2.remove()
+    ifnameB = bpftool("prog show %s" % (progB))[1]["dev"]["ifname"]
+    fail(ifnameB != simB3['ifname'], "program not bound to remaining device")
+
+    simB3.remove()
+    bpftool_prog_list_wait(expected=0)
+
+    start_test("Test multi-dev ASIC cross-dev destruction - orphaned...")
+    ret, out = bpftool("prog show %s" % (progB), fail=False)
+    fail(ret == 0, "got information about orphaned program")
+    fail("error" not in out, "no error reported for get info on orphaned")
+    fail(out["error"] != "can't get prog info: No such device",
+         "wrong error for get info on orphaned")
+
     print("%s: OK" % (os.path.basename(__file__)))
 
 finally: