[linux.git] / drivers / net / netdevsim / bpf.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/bpf.h>
#include <linux/bpf_verifier.h>
#include <linux/debugfs.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/rtnetlink.h>
#include <net/pkt_cls.h>

#include "netdevsim.h"

#define pr_vlog(env, fmt, ...)	\
	bpf_verifier_log_write(env, "[netdevsim] " fmt, ##__VA_ARGS__)

struct nsim_bpf_bound_prog {
	struct netdevsim *ns;
	struct bpf_prog *prog;
	struct dentry *ddir;
	const char *state;
	bool is_loaded;
	struct list_head l;
};

#define NSIM_BPF_MAX_KEYS		2

struct nsim_bpf_bound_map {
	struct netdevsim *ns;
	struct bpf_offloaded_map *map;
	struct mutex mutex;
	struct nsim_map_entry {
		void *key;
		void *value;
	} entry[NSIM_BPF_MAX_KEYS];
	struct list_head l;
};

static int nsim_debugfs_bpf_string_read(struct seq_file *file, void *data)
{
	const char **str = file->private;

	if (*str)
		seq_printf(file, "%s\n", *str);

	return 0;
}

static int nsim_debugfs_bpf_string_open(struct inode *inode, struct file *f)
{
	return single_open(f, nsim_debugfs_bpf_string_read, inode->i_private);
}

static const struct file_operations nsim_bpf_string_fops = {
	.owner = THIS_MODULE,
	.open = nsim_debugfs_bpf_string_open,
	.release = single_release,
	.read = seq_read,
	.llseek = seq_lseek
};

static int
nsim_bpf_verify_insn(struct bpf_verifier_env *env, int insn_idx, int prev_insn)
{
	struct nsim_bpf_bound_prog *state;

	state = env->prog->aux->offload->dev_priv;
	if (state->ns->bpf_bind_verifier_delay && !insn_idx)
		msleep(state->ns->bpf_bind_verifier_delay);

	if (insn_idx == env->prog->len - 1)
		pr_vlog(env, "Hello from netdevsim!\n");

	return 0;
}

static int nsim_bpf_finalize(struct bpf_verifier_env *env)
{
	return 0;
}

static bool nsim_xdp_offload_active(struct netdevsim *ns)
{
	return ns->xdp_hw.prog;
}

static void nsim_prog_set_loaded(struct bpf_prog *prog, bool loaded)
{
	struct nsim_bpf_bound_prog *state;

	if (!prog || !prog->aux->offload)
		return;

	state = prog->aux->offload->dev_priv;
	state->is_loaded = loaded;
}

static int
nsim_bpf_offload(struct netdevsim *ns, struct bpf_prog *prog, bool oldprog)
{
	nsim_prog_set_loaded(ns->bpf_offloaded, false);

	WARN(!!ns->bpf_offloaded != oldprog,
	     "bad offload state, expected offload %sto be active",
	     oldprog ? "" : "not ");
	ns->bpf_offloaded = prog;
	ns->bpf_offloaded_id = prog ? prog->aux->id : 0;
	nsim_prog_set_loaded(prog, true);

	return 0;
}

int nsim_bpf_setup_tc_block_cb(enum tc_setup_type type,
			       void *type_data, void *cb_priv)
{
	struct tc_cls_bpf_offload *cls_bpf = type_data;
	struct bpf_prog *prog = cls_bpf->prog;
	struct netdevsim *ns = cb_priv;
	struct bpf_prog *oldprog;

	if (type != TC_SETUP_CLSBPF) {
		NSIM_EA(cls_bpf->common.extack,
			"only offload of BPF classifiers supported");
		return -EOPNOTSUPP;
	}

	if (!tc_cls_can_offload_and_chain0(ns->netdev, &cls_bpf->common))
		return -EOPNOTSUPP;

	if (cls_bpf->common.protocol != htons(ETH_P_ALL)) {
		NSIM_EA(cls_bpf->common.extack,
			"only ETH_P_ALL supported as filter protocol");
		return -EOPNOTSUPP;
	}

	if (!ns->bpf_tc_accept) {
		NSIM_EA(cls_bpf->common.extack,
			"netdevsim configured to reject BPF TC offload");
		return -EOPNOTSUPP;
	}
	/* Note: progs without skip_sw will probably not be dev bound */
	if (prog && !prog->aux->offload && !ns->bpf_tc_non_bound_accept) {
		NSIM_EA(cls_bpf->common.extack,
			"netdevsim configured to reject unbound programs");
		return -EOPNOTSUPP;
	}

	if (cls_bpf->command != TC_CLSBPF_OFFLOAD)
		return -EOPNOTSUPP;

	oldprog = cls_bpf->oldprog;

	/* Don't remove if oldprog doesn't match driver's state */
	if (ns->bpf_offloaded != oldprog) {
		oldprog = NULL;
		if (!cls_bpf->prog)
			return 0;
		if (ns->bpf_offloaded) {
			NSIM_EA(cls_bpf->common.extack,
				"driver and netdev offload states mismatch");
			return -EBUSY;
		}
	}

	return nsim_bpf_offload(ns, cls_bpf->prog, oldprog);
}

int nsim_bpf_disable_tc(struct netdevsim *ns)
{
	if (ns->bpf_offloaded && !nsim_xdp_offload_active(ns))
		return -EBUSY;
	return 0;
}

static int nsim_xdp_offload_prog(struct netdevsim *ns, struct netdev_bpf *bpf)
{
	if (!nsim_xdp_offload_active(ns) && !bpf->prog)
		return 0;
	if (!nsim_xdp_offload_active(ns) && bpf->prog && ns->bpf_offloaded) {
		NSIM_EA(bpf->extack, "TC program is already loaded");
		return -EBUSY;
	}

	return nsim_bpf_offload(ns, bpf->prog, nsim_xdp_offload_active(ns));
}

static int
nsim_xdp_set_prog(struct netdevsim *ns, struct netdev_bpf *bpf,
		  struct xdp_attachment_info *xdp)
{
	int err;

	if (!xdp_attachment_flags_ok(xdp, bpf))
		return -EBUSY;

	if (bpf->command == XDP_SETUP_PROG && !ns->bpf_xdpdrv_accept) {
		NSIM_EA(bpf->extack, "driver XDP disabled in DebugFS");
		return -EOPNOTSUPP;
	}
	if (bpf->command == XDP_SETUP_PROG_HW && !ns->bpf_xdpoffload_accept) {
		NSIM_EA(bpf->extack, "XDP offload disabled in DebugFS");
		return -EOPNOTSUPP;
	}

	if (bpf->command == XDP_SETUP_PROG_HW) {
		err = nsim_xdp_offload_prog(ns, bpf);
		if (err)
			return err;
	}

	xdp_attachment_setup(xdp, bpf);

	return 0;
}

static int nsim_bpf_create_prog(struct netdevsim *ns, struct bpf_prog *prog)
{
	struct nsim_bpf_bound_prog *state;
	char name[16];

	state = kzalloc(sizeof(*state), GFP_KERNEL);
	if (!state)
		return -ENOMEM;

	state->ns = ns;
	state->prog = prog;
	state->state = "verify";

	/* Program id is not populated yet when we create the state. */
	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;
	}

	debugfs_create_u32("id", 0400, state->ddir, &prog->aux->id);
	debugfs_create_file("state", 0400, state->ddir,
			    &state->state, &nsim_bpf_string_fops);
	debugfs_create_bool("loaded", 0400, state->ddir, &state->is_loaded);

	list_add_tail(&state->l, &ns->sdev->bpf_bound_progs);

	prog->aux->offload->dev_priv = state;

	return 0;
}

static int
nsim_bpf_verifier_prep(struct net_device *dev, struct bpf_verifier_env *env)
{
	struct netdevsim *ns = netdev_priv(dev);

	if (!ns->bpf_bind_accept)
		return -EOPNOTSUPP;

	return nsim_bpf_create_prog(ns, env->prog);
}

static int nsim_bpf_translate(struct net_device *dev, struct bpf_prog *prog)
{
	struct nsim_bpf_bound_prog *state = prog->aux->offload->dev_priv;

	state->state = "xlated";
	return 0;
}

static void nsim_bpf_destroy_prog(struct bpf_prog *prog)
{
	struct nsim_bpf_bound_prog *state;

	state = prog->aux->offload->dev_priv;
	WARN(state->is_loaded,
	     "offload state destroyed while program still bound");
	debugfs_remove_recursive(state->ddir);
	list_del(&state->l);
	kfree(state);
}

static const struct bpf_prog_offload_ops nsim_bpf_dev_ops = {
	.insn_hook	= nsim_bpf_verify_insn,
	.finalize	= nsim_bpf_finalize,
	.prepare	= nsim_bpf_verifier_prep,
	.translate	= nsim_bpf_translate,
	.destroy	= nsim_bpf_destroy_prog,
};

static int nsim_setup_prog_checks(struct netdevsim *ns, struct netdev_bpf *bpf)
{
	if (bpf->prog && bpf->prog->aux->offload) {
		NSIM_EA(bpf->extack, "attempt to load offloaded prog to drv");
		return -EINVAL;
	}
	if (ns->netdev->mtu > NSIM_XDP_MAX_MTU) {
		NSIM_EA(bpf->extack, "MTU too large w/ XDP enabled");
		return -EINVAL;
	}
	return 0;
}

static int
nsim_setup_prog_hw_checks(struct netdevsim *ns, struct netdev_bpf *bpf)
{
	struct nsim_bpf_bound_prog *state;

	if (!bpf->prog)
		return 0;

	if (!bpf->prog->aux->offload) {
		NSIM_EA(bpf->extack, "xdpoffload of non-bound program");
		return -EINVAL;
	}
	if (!bpf_offload_dev_match(bpf->prog, ns->netdev)) {
		NSIM_EA(bpf->extack, "program bound to different dev");
		return -EINVAL;
	}

	state = bpf->prog->aux->offload->dev_priv;
	if (WARN_ON(strcmp(state->state, "xlated"))) {
		NSIM_EA(bpf->extack, "offloading program in bad state");
		return -EINVAL;
	}
	return 0;
}

static bool
nsim_map_key_match(struct bpf_map *map, struct nsim_map_entry *e, void *key)
{
	return e->key && !memcmp(key, e->key, map->key_size);
}

static int nsim_map_key_find(struct bpf_offloaded_map *offmap, void *key)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(nmap->entry); i++)
		if (nsim_map_key_match(&offmap->map, &nmap->entry[i], key))
			return i;

	return -ENOENT;
}

static int
nsim_map_alloc_elem(struct bpf_offloaded_map *offmap, unsigned int idx)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;

	nmap->entry[idx].key = kmalloc(offmap->map.key_size, GFP_USER);
	if (!nmap->entry[idx].key)
		return -ENOMEM;
	nmap->entry[idx].value = kmalloc(offmap->map.value_size, GFP_USER);
	if (!nmap->entry[idx].value) {
		kfree(nmap->entry[idx].key);
		nmap->entry[idx].key = NULL;
		return -ENOMEM;
	}

	return 0;
}

static int
nsim_map_get_next_key(struct bpf_offloaded_map *offmap,
		      void *key, void *next_key)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	int idx = -ENOENT;

	mutex_lock(&nmap->mutex);

	if (key)
		idx = nsim_map_key_find(offmap, key);
	if (idx == -ENOENT)
		idx = 0;
	else
		idx++;

	for (; idx < ARRAY_SIZE(nmap->entry); idx++) {
		if (nmap->entry[idx].key) {
			memcpy(next_key, nmap->entry[idx].key,
			       offmap->map.key_size);
			break;
		}
	}

	mutex_unlock(&nmap->mutex);

	if (idx == ARRAY_SIZE(nmap->entry))
		return -ENOENT;
	return 0;
}

static int
nsim_map_lookup_elem(struct bpf_offloaded_map *offmap, void *key, void *value)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	int idx;

	mutex_lock(&nmap->mutex);

	idx = nsim_map_key_find(offmap, key);
	if (idx >= 0)
		memcpy(value, nmap->entry[idx].value, offmap->map.value_size);

	mutex_unlock(&nmap->mutex);

	return idx < 0 ? idx : 0;
}

static int
nsim_map_update_elem(struct bpf_offloaded_map *offmap,
		     void *key, void *value, u64 flags)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	int idx, err = 0;

	mutex_lock(&nmap->mutex);

	idx = nsim_map_key_find(offmap, key);
	if (idx < 0 && flags == BPF_EXIST) {
		err = idx;
		goto exit_unlock;
	}
	if (idx >= 0 && flags == BPF_NOEXIST) {
		err = -EEXIST;
		goto exit_unlock;
	}

	if (idx < 0) {
		for (idx = 0; idx < ARRAY_SIZE(nmap->entry); idx++)
			if (!nmap->entry[idx].key)
				break;
		if (idx == ARRAY_SIZE(nmap->entry)) {
			err = -E2BIG;
			goto exit_unlock;
		}

		err = nsim_map_alloc_elem(offmap, idx);
		if (err)
			goto exit_unlock;
	}

	memcpy(nmap->entry[idx].key, key, offmap->map.key_size);
	memcpy(nmap->entry[idx].value, value, offmap->map.value_size);
exit_unlock:
	mutex_unlock(&nmap->mutex);

	return err;
}

static int nsim_map_delete_elem(struct bpf_offloaded_map *offmap, void *key)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	int idx;

	if (offmap->map.map_type == BPF_MAP_TYPE_ARRAY)
		return -EINVAL;

	mutex_lock(&nmap->mutex);

	idx = nsim_map_key_find(offmap, key);
	if (idx >= 0) {
		kfree(nmap->entry[idx].key);
		kfree(nmap->entry[idx].value);
		memset(&nmap->entry[idx], 0, sizeof(nmap->entry[idx]));
	}

	mutex_unlock(&nmap->mutex);

	return idx < 0 ? idx : 0;
}

static const struct bpf_map_dev_ops nsim_bpf_map_ops = {
	.map_get_next_key	= nsim_map_get_next_key,
	.map_lookup_elem	= nsim_map_lookup_elem,
	.map_update_elem	= nsim_map_update_elem,
	.map_delete_elem	= nsim_map_delete_elem,
};

static int
nsim_bpf_map_alloc(struct netdevsim *ns, struct bpf_offloaded_map *offmap)
{
	struct nsim_bpf_bound_map *nmap;
	int i, err;

	if (WARN_ON(offmap->map.map_type != BPF_MAP_TYPE_ARRAY &&
		    offmap->map.map_type != BPF_MAP_TYPE_HASH))
		return -EINVAL;
	if (offmap->map.max_entries > NSIM_BPF_MAX_KEYS)
		return -ENOMEM;
	if (offmap->map.map_flags)
		return -EINVAL;

	nmap = kzalloc(sizeof(*nmap), GFP_USER);
	if (!nmap)
		return -ENOMEM;

	offmap->dev_priv = nmap;
	nmap->ns = ns;
	nmap->map = offmap;
	mutex_init(&nmap->mutex);

	if (offmap->map.map_type == BPF_MAP_TYPE_ARRAY) {
		for (i = 0; i < ARRAY_SIZE(nmap->entry); i++) {
			u32 *key;

			err = nsim_map_alloc_elem(offmap, i);
			if (err)
				goto err_free;
			key = nmap->entry[i].key;
			*key = i;
		}
	}

	offmap->dev_ops = &nsim_bpf_map_ops;
	list_add_tail(&nmap->l, &ns->sdev->bpf_bound_maps);

	return 0;

err_free:
	while (--i >= 0) {
		kfree(nmap->entry[i].key);
		kfree(nmap->entry[i].value);
	}
	kfree(nmap);
	return err;
}

static void nsim_bpf_map_free(struct bpf_offloaded_map *offmap)
{
	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(nmap->entry); i++) {
		kfree(nmap->entry[i].key);
		kfree(nmap->entry[i].value);
	}
	list_del_init(&nmap->l);
	mutex_destroy(&nmap->mutex);
	kfree(nmap);
}

int nsim_bpf(struct net_device *dev, struct netdev_bpf *bpf)
{
	struct netdevsim *ns = netdev_priv(dev);
	struct nsim_bpf_bound_prog *state;
	int err;

	ASSERT_RTNL();

	switch (bpf->command) {
	case XDP_QUERY_PROG:
		return xdp_attachment_query(&ns->xdp, bpf);
	case XDP_QUERY_PROG_HW:
		return xdp_attachment_query(&ns->xdp_hw, bpf);
	case XDP_SETUP_PROG:
		err = nsim_setup_prog_checks(ns, bpf);
		if (err)
			return err;

		return nsim_xdp_set_prog(ns, bpf, &ns->xdp);
	case XDP_SETUP_PROG_HW:
		err = nsim_setup_prog_hw_checks(ns, bpf);
		if (err)
			return err;

		return nsim_xdp_set_prog(ns, bpf, &ns->xdp_hw);
	case BPF_OFFLOAD_MAP_ALLOC:
		if (!ns->bpf_map_accept)
			return -EOPNOTSUPP;

		return nsim_bpf_map_alloc(ns, bpf->offmap);
	case BPF_OFFLOAD_MAP_FREE:
		nsim_bpf_map_free(bpf->offmap);
		return 0;
	default:
		return -EINVAL;
	}
}

int nsim_bpf_init(struct netdevsim *ns)
{
	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(&nsim_bpf_dev_ops);
		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);

	ns->bpf_bind_accept = true;
	debugfs_create_bool("bpf_bind_accept", 0600, ns->ddir,
			    &ns->bpf_bind_accept);
	debugfs_create_u32("bpf_bind_verifier_delay", 0600, ns->ddir,
			   &ns->bpf_bind_verifier_delay);

	ns->bpf_tc_accept = true;
	debugfs_create_bool("bpf_tc_accept", 0600, ns->ddir,
			    &ns->bpf_tc_accept);
	debugfs_create_bool("bpf_tc_non_bound_accept", 0600, ns->ddir,
			    &ns->bpf_tc_non_bound_accept);
	ns->bpf_xdpdrv_accept = true;
	debugfs_create_bool("bpf_xdpdrv_accept", 0600, ns->ddir,
			    &ns->bpf_xdpdrv_accept);
	ns->bpf_xdpoffload_accept = true;
	debugfs_create_bool("bpf_xdpoffload_accept", 0600, ns->ddir,
			    &ns->bpf_xdpoffload_accept);

	ns->bpf_map_accept = true;
	debugfs_create_bool("bpf_map_accept", 0600, ns->ddir,
			    &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(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);
	}
}
Commit	Line	Data
31d3ad83 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
	16	#include <linux/bpf.h>
	17	#include <linux/bpf_verifier.h>
	18	#include <linux/debugfs.h>
	19	#include <linux/kernel.h>
395cacb5	20	#include <linux/mutex.h>
31d3ad83 JK	21	#include <linux/rtnetlink.h>
	22	#include <net/pkt_cls.h>
	23
	24	#include "netdevsim.h"
	25
9045bdc8 QM	26	#define pr_vlog(env, fmt, ...) \
	27	bpf_verifier_log_write(env, "[netdevsim] " fmt, ##__VA_ARGS__)
	28
31d3ad83 JK	29	struct nsim_bpf_bound_prog {
	30	struct netdevsim *ns;
	31	struct bpf_prog *prog;
	32	struct dentry *ddir;
	33	const char *state;
	34	bool is_loaded;
	35	struct list_head l;
	36	};
	37
395cacb5 JK	38	#define NSIM_BPF_MAX_KEYS 2
	39
	40	struct nsim_bpf_bound_map {
	41	struct netdevsim *ns;
	42	struct bpf_offloaded_map *map;
	43	struct mutex mutex;
	44	struct nsim_map_entry {
	45	void *key;
	46	void *value;
	47	} entry[NSIM_BPF_MAX_KEYS];
	48	struct list_head l;
	49	};
	50
31d3ad83 JK	51	static int nsim_debugfs_bpf_string_read(struct seq_file file, void data)
	52	{
	53	const char **str = file->private;
	54
	55	if (*str)
	56	seq_printf(file, "%s\n", *str);
	57
	58	return 0;
	59	}
	60
	61	static int nsim_debugfs_bpf_string_open(struct inode inode, struct file f)
	62	{
	63	return single_open(f, nsim_debugfs_bpf_string_read, inode->i_private);
	64	}
	65
	66	static const struct file_operations nsim_bpf_string_fops = {
	67	.owner = THIS_MODULE,
	68	.open = nsim_debugfs_bpf_string_open,
	69	.release = single_release,
	70	.read = seq_read,
	71	.llseek = seq_lseek
	72	};
	73
	74	static int
	75	nsim_bpf_verify_insn(struct bpf_verifier_env *env, int insn_idx, int prev_insn)
	76	{
	77	struct nsim_bpf_bound_prog *state;
	78
	79	state = env->prog->aux->offload->dev_priv;
	80	if (state->ns->bpf_bind_verifier_delay && !insn_idx)
	81	msleep(state->ns->bpf_bind_verifier_delay);
	82
9045bdc8 QM	83	if (insn_idx == env->prog->len - 1)
	84	pr_vlog(env, "Hello from netdevsim!\n");
	85
31d3ad83 JK	86	return 0;
	87	}
	88
c941ce9c QM	89	static int nsim_bpf_finalize(struct bpf_verifier_env *env)
	90	{
	91	return 0;
	92	}
	93
31d3ad83 JK	94	static bool nsim_xdp_offload_active(struct netdevsim *ns)
31d3ad83 JK	95	{
799e173d	96	return ns->xdp_hw.prog;
31d3ad83 JK	97	}
	98
	99	static void nsim_prog_set_loaded(struct bpf_prog *prog, bool loaded)
	100	{
	101	struct nsim_bpf_bound_prog *state;
	102
	103	if (!prog \|\| !prog->aux->offload)
	104	return;
	105
	106	state = prog->aux->offload->dev_priv;
	107	state->is_loaded = loaded;
	108	}
	109
	110	static int
	111	nsim_bpf_offload(struct netdevsim ns, struct bpf_prog prog, bool oldprog)
	112	{
	113	nsim_prog_set_loaded(ns->bpf_offloaded, false);
	114
	115	WARN(!!ns->bpf_offloaded != oldprog,
	116	"bad offload state, expected offload %sto be active",
	117	oldprog ? "" : "not ");
	118	ns->bpf_offloaded = prog;
	119	ns->bpf_offloaded_id = prog ? prog->aux->id : 0;
	120	nsim_prog_set_loaded(prog, true);
	121
	122	return 0;
	123	}
	124
	125	int nsim_bpf_setup_tc_block_cb(enum tc_setup_type type,
	126	void type_data, void cb_priv)
	127	{
	128	struct tc_cls_bpf_offload *cls_bpf = type_data;
	129	struct bpf_prog *prog = cls_bpf->prog;
	130	struct netdevsim *ns = cb_priv;
fba961ab	131	struct bpf_prog *oldprog;
31d3ad83	132
728461f2 QM	133	if (type != TC_SETUP_CLSBPF) {
	134	NSIM_EA(cls_bpf->common.extack,
	135	"only offload of BPF classifiers supported");
	136	return -EOPNOTSUPP;
	137	}
	138
a2b212a5	139	if (!tc_cls_can_offload_and_chain0(ns->netdev, &cls_bpf->common))
728461f2 QM	140	return -EOPNOTSUPP;
	141
	142	if (cls_bpf->common.protocol != htons(ETH_P_ALL)) {
	143	NSIM_EA(cls_bpf->common.extack,
	144	"only ETH_P_ALL supported as filter protocol");
	145	return -EOPNOTSUPP;
	146	}
	147
728461f2 QM	148	if (!ns->bpf_tc_accept) {
	149	NSIM_EA(cls_bpf->common.extack,
	150	"netdevsim configured to reject BPF TC offload");
31d3ad83	151	return -EOPNOTSUPP;
728461f2	152	}
31d3ad83	153	/* Note: progs without skip_sw will probably not be dev bound */
728461f2 QM	154	if (prog && !prog->aux->offload && !ns->bpf_tc_non_bound_accept) {
	155	NSIM_EA(cls_bpf->common.extack,
	156	"netdevsim configured to reject unbound programs");
31d3ad83	157	return -EOPNOTSUPP;
728461f2	158	}
31d3ad83	159
fba961ab	160	if (cls_bpf->command != TC_CLSBPF_OFFLOAD)
31d3ad83	161	return -EOPNOTSUPP;
fba961ab DM	162
	163	oldprog = cls_bpf->oldprog;
	164
	165	/* Don't remove if oldprog doesn't match driver's state */
	166	if (ns->bpf_offloaded != oldprog) {
	167	oldprog = NULL;
	168	if (!cls_bpf->prog)
	169	return 0;
728461f2 QM	170	if (ns->bpf_offloaded) {
	171	NSIM_EA(cls_bpf->common.extack,
	172	"driver and netdev offload states mismatch");
fba961ab	173	return -EBUSY;
728461f2	174	}
31d3ad83	175	}
fba961ab DM	176
fba961ab DM	177	return nsim_bpf_offload(ns, cls_bpf->prog, oldprog);
31d3ad83 JK	178	}
	179
	180	int nsim_bpf_disable_tc(struct netdevsim *ns)
	181	{
	182	if (ns->bpf_offloaded && !nsim_xdp_offload_active(ns))
	183	return -EBUSY;
	184	return 0;
	185	}
	186
	187	static int nsim_xdp_offload_prog(struct netdevsim ns, struct netdev_bpf bpf)
	188	{
	189	if (!nsim_xdp_offload_active(ns) && !bpf->prog)
	190	return 0;
	191	if (!nsim_xdp_offload_active(ns) && bpf->prog && ns->bpf_offloaded) {
	192	NSIM_EA(bpf->extack, "TC program is already loaded");
	193	return -EBUSY;
	194	}
	195
	196	return nsim_bpf_offload(ns, bpf->prog, nsim_xdp_offload_active(ns));
	197	}
	198
799e173d JK	199	static int
	200	nsim_xdp_set_prog(struct netdevsim ns, struct netdev_bpf bpf,
	201	struct xdp_attachment_info *xdp)
31d3ad83 JK	202	{
	203	int err;
	204
799e173d	205	if (!xdp_attachment_flags_ok(xdp, bpf))
31d3ad83	206	return -EBUSY;
31d3ad83 JK	207
	208	if (bpf->command == XDP_SETUP_PROG && !ns->bpf_xdpdrv_accept) {
	209	NSIM_EA(bpf->extack, "driver XDP disabled in DebugFS");
	210	return -EOPNOTSUPP;
	211	}
	212	if (bpf->command == XDP_SETUP_PROG_HW && !ns->bpf_xdpoffload_accept) {
	213	NSIM_EA(bpf->extack, "XDP offload disabled in DebugFS");
	214	return -EOPNOTSUPP;
	215	}
	216
	217	if (bpf->command == XDP_SETUP_PROG_HW) {
	218	err = nsim_xdp_offload_prog(ns, bpf);
	219	if (err)
	220	return err;
	221	}
	222
799e173d	223	xdp_attachment_setup(xdp, bpf);
31d3ad83 JK	224
	225	return 0;
	226	}
	227
1dfc2663	228	static int nsim_bpf_create_prog(struct netdevsim ns, struct bpf_prog prog)
31d3ad83 JK	229	{
	230	struct nsim_bpf_bound_prog *state;
	231	char name[16];
31d3ad83 JK	232
	233	state = kzalloc(sizeof(*state), GFP_KERNEL);
	234	if (!state)
	235	return -ENOMEM;
	236
	237	state->ns = ns;
	238	state->prog = prog;
	239	state->state = "verify";
	240
	241	/* Program id is not populated yet when we create the state. */
d6d60713 JK	242	sprintf(name, "%u", ns->sdev->prog_id_gen++);
d6d60713 JK	243	state->ddir = debugfs_create_dir(name, ns->sdev->ddir_bpf_bound_progs);
9ee1942c	244	if (IS_ERR_OR_NULL(state->ddir)) {
31d3ad83	245	kfree(state);
9ee1942c	246	return -ENOMEM;
31d3ad83 JK	247	}
	248
	249	debugfs_create_u32("id", 0400, state->ddir, &prog->aux->id);
	250	debugfs_create_file("state", 0400, state->ddir,
	251	&state->state, &nsim_bpf_string_fops);
	252	debugfs_create_bool("loaded", 0400, state->ddir, &state->is_loaded);
	253
d6d60713	254	list_add_tail(&state->l, &ns->sdev->bpf_bound_progs);
31d3ad83 JK	255
	256	prog->aux->offload->dev_priv = state;
	257
	258	return 0;
	259	}
	260
00db12c3 QM	261	static int
	262	nsim_bpf_verifier_prep(struct net_device dev, struct bpf_verifier_env env)
	263	{
	264	struct netdevsim *ns = netdev_priv(dev);
	265
	266	if (!ns->bpf_bind_accept)
	267	return -EOPNOTSUPP;
	268
	269	return nsim_bpf_create_prog(ns, env->prog);
	270	}
	271
b07ade27 QM	272	static int nsim_bpf_translate(struct net_device dev, struct bpf_prog prog)
	273	{
	274	struct nsim_bpf_bound_prog *state = prog->aux->offload->dev_priv;
	275
	276	state->state = "xlated";
	277	return 0;
	278	}
	279
1dfc2663	280	static void nsim_bpf_destroy_prog(struct bpf_prog *prog)
31d3ad83 JK	281	{
	282	struct nsim_bpf_bound_prog *state;
	283
	284	state = prog->aux->offload->dev_priv;
	285	WARN(state->is_loaded,
	286	"offload state destroyed while program still bound");
	287	debugfs_remove_recursive(state->ddir);
	288	list_del(&state->l);
	289	kfree(state);
	290	}
	291
00db12c3 QM	292	static const struct bpf_prog_offload_ops nsim_bpf_dev_ops = {
	293	.insn_hook = nsim_bpf_verify_insn,
	294	.finalize = nsim_bpf_finalize,
	295	.prepare = nsim_bpf_verifier_prep,
b07ade27	296	.translate = nsim_bpf_translate,
eb911947	297	.destroy = nsim_bpf_destroy_prog,
00db12c3 QM	298	};
00db12c3 QM	299
31d3ad83 JK	300	static int nsim_setup_prog_checks(struct netdevsim ns, struct netdev_bpf bpf)
	301	{
	302	if (bpf->prog && bpf->prog->aux->offload) {
	303	NSIM_EA(bpf->extack, "attempt to load offloaded prog to drv");
	304	return -EINVAL;
	305	}
	306	if (ns->netdev->mtu > NSIM_XDP_MAX_MTU) {
	307	NSIM_EA(bpf->extack, "MTU too large w/ XDP enabled");
	308	return -EINVAL;
	309	}
31d3ad83 JK	310	return 0;
	311	}
	312
	313	static int
	314	nsim_setup_prog_hw_checks(struct netdevsim ns, struct netdev_bpf bpf)
	315	{
	316	struct nsim_bpf_bound_prog *state;
	317
	318	if (!bpf->prog)
	319	return 0;
	320
	321	if (!bpf->prog->aux->offload) {
	322	NSIM_EA(bpf->extack, "xdpoffload of non-bound program");
	323	return -EINVAL;
	324	}
9d1b66b8	325	if (!bpf_offload_dev_match(bpf->prog, ns->netdev)) {
31d3ad83 JK	326	NSIM_EA(bpf->extack, "program bound to different dev");
	327	return -EINVAL;
	328	}
	329
	330	state = bpf->prog->aux->offload->dev_priv;
	331	if (WARN_ON(strcmp(state->state, "xlated"))) {
	332	NSIM_EA(bpf->extack, "offloading program in bad state");
	333	return -EINVAL;
	334	}
	335	return 0;
	336	}
	337
395cacb5 JK	338	static bool
	339	nsim_map_key_match(struct bpf_map map, struct nsim_map_entry e, void *key)
	340	{
	341	return e->key && !memcmp(key, e->key, map->key_size);
	342	}
	343
	344	static int nsim_map_key_find(struct bpf_offloaded_map offmap, void key)
	345	{
	346	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	347	unsigned int i;
	348
	349	for (i = 0; i < ARRAY_SIZE(nmap->entry); i++)
	350	if (nsim_map_key_match(&offmap->map, &nmap->entry[i], key))
	351	return i;
	352
	353	return -ENOENT;
	354	}
	355
	356	static int
	357	nsim_map_alloc_elem(struct bpf_offloaded_map *offmap, unsigned int idx)
	358	{
	359	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	360
	361	nmap->entry[idx].key = kmalloc(offmap->map.key_size, GFP_USER);
	362	if (!nmap->entry[idx].key)
	363	return -ENOMEM;
	364	nmap->entry[idx].value = kmalloc(offmap->map.value_size, GFP_USER);
	365	if (!nmap->entry[idx].value) {
	366	kfree(nmap->entry[idx].key);
	367	nmap->entry[idx].key = NULL;
	368	return -ENOMEM;
	369	}
	370
	371	return 0;
	372	}
	373
	374	static int
	375	nsim_map_get_next_key(struct bpf_offloaded_map *offmap,
	376	void key, void next_key)
	377	{
	378	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	379	int idx = -ENOENT;
	380
	381	mutex_lock(&nmap->mutex);
	382
	383	if (key)
	384	idx = nsim_map_key_find(offmap, key);
	385	if (idx == -ENOENT)
	386	idx = 0;
	387	else
	388	idx++;
	389
	390	for (; idx < ARRAY_SIZE(nmap->entry); idx++) {
	391	if (nmap->entry[idx].key) {
	392	memcpy(next_key, nmap->entry[idx].key,
	393	offmap->map.key_size);
	394	break;
	395	}
	396	}
	397
	398	mutex_unlock(&nmap->mutex);
	399
	400	if (idx == ARRAY_SIZE(nmap->entry))
	401	return -ENOENT;
402	return 0;
403	}
404
405	static int
406	nsim_map_lookup_elem(struct bpf_offloaded_map offmap, void key, void *value)
407	{
408	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
409	int idx;
410
411	mutex_lock(&nmap->mutex);
412
413	idx = nsim_map_key_find(offmap, key);
414	if (idx >= 0)
415	memcpy(value, nmap->entry[idx].value, offmap->map.value_size);
416
417	mutex_unlock(&nmap->mutex);
418
419	return idx < 0 ? idx : 0;
420	}
421
422	static int
423	nsim_map_update_elem(struct bpf_offloaded_map *offmap,
424	void key, void value, u64 flags)
425	{
426	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
427	int idx, err = 0;
428
429	mutex_lock(&nmap->mutex);
430
431	idx = nsim_map_key_find(offmap, key);
432	if (idx < 0 && flags == BPF_EXIST) {
433	err = idx;
434	goto exit_unlock;
435	}
436	if (idx >= 0 && flags == BPF_NOEXIST) {
437	err = -EEXIST;
438	goto exit_unlock;
439	}
440
441	if (idx < 0) {
442	for (idx = 0; idx < ARRAY_SIZE(nmap->entry); idx++)
443	if (!nmap->entry[idx].key)
444	break;
445	if (idx == ARRAY_SIZE(nmap->entry)) {
446	err = -E2BIG;
447	goto exit_unlock;
448	}
449
450	err = nsim_map_alloc_elem(offmap, idx);
451	if (err)
452	goto exit_unlock;
453	}
454
455	memcpy(nmap->entry[idx].key, key, offmap->map.key_size);
456	memcpy(nmap->entry[idx].value, value, offmap->map.value_size);
457	exit_unlock:
458	mutex_unlock(&nmap->mutex);
459
460	return err;
461	}
462
463	static int nsim_map_delete_elem(struct bpf_offloaded_map offmap, void key)
464	{
465	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
466	int idx;
467
468	if (offmap->map.map_type == BPF_MAP_TYPE_ARRAY)
469	return -EINVAL;
470
471	mutex_lock(&nmap->mutex);
472
473	idx = nsim_map_key_find(offmap, key);
474	if (idx >= 0) {
475	kfree(nmap->entry[idx].key);
476	kfree(nmap->entry[idx].value);
477	memset(&nmap->entry[idx], 0, sizeof(nmap->entry[idx]));
478	}
479
480	mutex_unlock(&nmap->mutex);
481
482	return idx < 0 ? idx : 0;
483	}
484
485	static const struct bpf_map_dev_ops nsim_bpf_map_ops = {
486	.map_get_next_key = nsim_map_get_next_key,
487	.map_lookup_elem = nsim_map_lookup_elem,
488	.map_update_elem = nsim_map_update_elem,
489	.map_delete_elem = nsim_map_delete_elem,
490	};
491
492	static int
493	nsim_bpf_map_alloc(struct netdevsim ns, struct bpf_offloaded_map offmap)
494	{
495	struct nsim_bpf_bound_map *nmap;
e029f541	496	int i, err;
395cacb5 JK	497
	498	if (WARN_ON(offmap->map.map_type != BPF_MAP_TYPE_ARRAY &&
	499	offmap->map.map_type != BPF_MAP_TYPE_HASH))
	500	return -EINVAL;
	501	if (offmap->map.max_entries > NSIM_BPF_MAX_KEYS)
	502	return -ENOMEM;
	503	if (offmap->map.map_flags)
	504	return -EINVAL;
	505
	506	nmap = kzalloc(sizeof(*nmap), GFP_USER);
	507	if (!nmap)
	508	return -ENOMEM;
	509
	510	offmap->dev_priv = nmap;
	511	nmap->ns = ns;
	512	nmap->map = offmap;
	513	mutex_init(&nmap->mutex);
	514
	515	if (offmap->map.map_type == BPF_MAP_TYPE_ARRAY) {
	516	for (i = 0; i < ARRAY_SIZE(nmap->entry); i++) {
	517	u32 *key;
	518
	519	err = nsim_map_alloc_elem(offmap, i);
	520	if (err)
	521	goto err_free;
	522	key = nmap->entry[i].key;
	523	*key = i;
	524	}
	525	}
	526
	527	offmap->dev_ops = &nsim_bpf_map_ops;
d6d60713	528	list_add_tail(&nmap->l, &ns->sdev->bpf_bound_maps);
395cacb5 JK	529
	530	return 0;
	531
	532	err_free:
e029f541	533	while (--i >= 0) {
395cacb5 JK	534	kfree(nmap->entry[i].key);
	535	kfree(nmap->entry[i].value);
	536	}
	537	kfree(nmap);
	538	return err;
	539	}
	540
	541	static void nsim_bpf_map_free(struct bpf_offloaded_map *offmap)
	542	{
	543	struct nsim_bpf_bound_map *nmap = offmap->dev_priv;
	544	unsigned int i;
	545
	546	for (i = 0; i < ARRAY_SIZE(nmap->entry); i++) {
	547	kfree(nmap->entry[i].key);
	548	kfree(nmap->entry[i].value);
	549	}
	550	list_del_init(&nmap->l);
	551	mutex_destroy(&nmap->mutex);
	552	kfree(nmap);
	553	}
	554
31d3ad83 JK	555	int nsim_bpf(struct net_device dev, struct netdev_bpf bpf)
	556	{
	557	struct netdevsim *ns = netdev_priv(dev);
	558	struct nsim_bpf_bound_prog *state;
	559	int err;
	560
	561	ASSERT_RTNL();
	562
	563	switch (bpf->command) {
31d3ad83	564	case XDP_QUERY_PROG:
a25717d2 JK	565	return xdp_attachment_query(&ns->xdp, bpf);
a25717d2 JK	566	case XDP_QUERY_PROG_HW:
799e173d	567	return xdp_attachment_query(&ns->xdp_hw, bpf);
31d3ad83 JK	568	case XDP_SETUP_PROG:
	569	err = nsim_setup_prog_checks(ns, bpf);
	570	if (err)
	571	return err;
	572
799e173d	573	return nsim_xdp_set_prog(ns, bpf, &ns->xdp);
31d3ad83 JK	574	case XDP_SETUP_PROG_HW:
	575	err = nsim_setup_prog_hw_checks(ns, bpf);
	576	if (err)
	577	return err;
	578
799e173d	579	return nsim_xdp_set_prog(ns, bpf, &ns->xdp_hw);
395cacb5 JK	580	case BPF_OFFLOAD_MAP_ALLOC:
	581	if (!ns->bpf_map_accept)
	582	return -EOPNOTSUPP;
	583
	584	return nsim_bpf_map_alloc(ns, bpf->offmap);
	585	case BPF_OFFLOAD_MAP_FREE:
	586	nsim_bpf_map_free(bpf->offmap);
	587	return 0;
31d3ad83 JK	588	default:
	589	return -EINVAL;
	590	}
	591	}
	592
	593	int nsim_bpf_init(struct netdevsim *ns)
	594	{
9fd7c555 JK	595	int err;
9fd7c555 JK	596
d6d60713 JK	597	if (ns->sdev->refcnt == 1) {
	598	INIT_LIST_HEAD(&ns->sdev->bpf_bound_progs);
	599	INIT_LIST_HEAD(&ns->sdev->bpf_bound_maps);
	600
	601	ns->sdev->ddir_bpf_bound_progs =
	602	debugfs_create_dir("bpf_bound_progs", ns->sdev->ddir);
	603	if (IS_ERR_OR_NULL(ns->sdev->ddir_bpf_bound_progs))
	604	return -ENOMEM;
602144c2	605
1385d755	606	ns->sdev->bpf_dev = bpf_offload_dev_create(&nsim_bpf_dev_ops);
602144c2 JK	607	err = PTR_ERR_OR_ZERO(ns->sdev->bpf_dev);
	608	if (err)
	609	return err;
d6d60713	610	}
31d3ad83	611
602144c2	612	err = bpf_offload_dev_netdev_register(ns->sdev->bpf_dev, ns->netdev);
9fd7c555	613	if (err)
602144c2	614	goto err_destroy_bdev;
9fd7c555	615
31d3ad83 JK	616	debugfs_create_u32("bpf_offloaded_id", 0400, ns->ddir,
	617	&ns->bpf_offloaded_id);
	618
	619	ns->bpf_bind_accept = true;
	620	debugfs_create_bool("bpf_bind_accept", 0600, ns->ddir,
	621	&ns->bpf_bind_accept);
	622	debugfs_create_u32("bpf_bind_verifier_delay", 0600, ns->ddir,
	623	&ns->bpf_bind_verifier_delay);
31d3ad83 JK	624
	625	ns->bpf_tc_accept = true;
	626	debugfs_create_bool("bpf_tc_accept", 0600, ns->ddir,
	627	&ns->bpf_tc_accept);
	628	debugfs_create_bool("bpf_tc_non_bound_accept", 0600, ns->ddir,
	629	&ns->bpf_tc_non_bound_accept);
	630	ns->bpf_xdpdrv_accept = true;
	631	debugfs_create_bool("bpf_xdpdrv_accept", 0600, ns->ddir,
	632	&ns->bpf_xdpdrv_accept);
	633	ns->bpf_xdpoffload_accept = true;
	634	debugfs_create_bool("bpf_xdpoffload_accept", 0600, ns->ddir,
	635	&ns->bpf_xdpoffload_accept);
	636
395cacb5 JK	637	ns->bpf_map_accept = true;
	638	debugfs_create_bool("bpf_map_accept", 0600, ns->ddir,
	639	&ns->bpf_map_accept);
	640
31d3ad83	641	return 0;
602144c2 JK	642
	643	err_destroy_bdev:
	644	if (ns->sdev->refcnt == 1)
	645	bpf_offload_dev_destroy(ns->sdev->bpf_dev);
	646	return err;
31d3ad83 JK	647	}
	648
	649	void nsim_bpf_uninit(struct netdevsim *ns)
	650	{
05296620	651	WARN_ON(ns->xdp.prog);
799e173d	652	WARN_ON(ns->xdp_hw.prog);
31d3ad83	653	WARN_ON(ns->bpf_offloaded);
602144c2	654	bpf_offload_dev_netdev_unregister(ns->sdev->bpf_dev, ns->netdev);
d6d60713 JK	655
	656	if (ns->sdev->refcnt == 1) {
	657	WARN_ON(!list_empty(&ns->sdev->bpf_bound_progs));
	658	WARN_ON(!list_empty(&ns->sdev->bpf_bound_maps));
602144c2	659	bpf_offload_dev_destroy(ns->sdev->bpf_dev);
d6d60713	660	}
31d3ad83	661	}