Commit 102740bd authored by Jakub Kicinski's avatar Jakub Kicinski Committed by David S. Miller
Browse files

cls_bpf: fix offload assumptions after callback conversion 



cls_bpf used to take care of tracking what offload state a filter
is in, i.e. it would track if offload request succeeded or not.
This information would then be used to issue correct requests to
the driver, e.g. requests for statistics only on offloaded filters,
removing only filters which were offloaded, using add instead of
replace if previous filter was not added etc.

This tracking of offload state no longer functions with the new
callback infrastructure.  There could be multiple entities trying
to offload the same filter.

Throw out all the tracking and corresponding commands and simply
pass to the drivers both old and new bpf program.  Drivers will
have to deal with offload state tracking by themselves.

Fixes: 3f7889c4 ("net: sched: cls_bpf: call block callbacks for offload")
Signed-off-by: default avatarJakub Kicinski <jakub.kicinski@netronome.com>
Acked-by: default avatarJiri Pirko <jiri@mellanox.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 21b59443

drivers/net/ethernet/netronome/nfp/bpf/main.c

+3 −9
Original line number Original line Diff line number Diff line
@@ -110,16 +110,10 @@ static int nfp_bpf_setup_tc_block_cb(enum tc_setup_type type, 
		return -EOPNOTSUPP;

		return -EOPNOTSUPP;

	}

	}





	switch (cls_bpf->command) {

	if (cls_bpf->command != TC_CLSBPF_OFFLOAD)

	case TC_CLSBPF_REPLACE:

		return nfp_net_bpf_offload(nn, cls_bpf->prog, true);

	case TC_CLSBPF_ADD:

		return nfp_net_bpf_offload(nn, cls_bpf->prog, false);

	case TC_CLSBPF_DESTROY:

		return nfp_net_bpf_offload(nn, NULL, true);

	default:

		return -EOPNOTSUPP;

		return -EOPNOTSUPP;

	}



	return nfp_net_bpf_offload(nn, cls_bpf->prog, cls_bpf->oldprog);

}

}





static int nfp_bpf_setup_tc_block(struct net_device *netdev,

static int nfp_bpf_setup_tc_block(struct net_device *netdev,

include/net/pkt_cls.h

+2 −3
Original line number Original line Diff line number Diff line
@@ -694,9 +694,7 @@ struct tc_cls_matchall_offload { 
};

};





enum tc_clsbpf_command {

enum tc_clsbpf_command {

	TC_CLSBPF_ADD,

	TC_CLSBPF_OFFLOAD,

	TC_CLSBPF_REPLACE,

	TC_CLSBPF_DESTROY,

	TC_CLSBPF_STATS,

	TC_CLSBPF_STATS,

};

};
@@ -705,6 +703,7 @@ struct tc_cls_bpf_offload { 
	enum tc_clsbpf_command command;

	enum tc_clsbpf_command command;

	struct tcf_exts *exts;

	struct tcf_exts *exts;

	struct bpf_prog *prog;

	struct bpf_prog *prog;

	struct bpf_prog *oldprog;

	const char *name;

	const char *name;

	bool exts_integrated;

	bool exts_integrated;

	u32 gen_flags;

	u32 gen_flags;

net/sched/cls_bpf.c

+38 −55
Original line number Original line Diff line number Diff line
@@ -42,7 +42,6 @@ struct cls_bpf_prog { 
	struct list_head link;

	struct list_head link;

	struct tcf_result res;

	struct tcf_result res;

	bool exts_integrated;

	bool exts_integrated;

	bool offloaded;

	u32 gen_flags;

	u32 gen_flags;

	struct tcf_exts exts;

	struct tcf_exts exts;

	u32 handle;

	u32 handle;
@@ -148,33 +147,37 @@ static bool cls_bpf_is_ebpf(const struct cls_bpf_prog *prog) 
}

}





static int cls_bpf_offload_cmd(struct tcf_proto *tp, struct cls_bpf_prog *prog,

static int cls_bpf_offload_cmd(struct tcf_proto *tp, struct cls_bpf_prog *prog,

			       enum tc_clsbpf_command cmd)

			       struct cls_bpf_prog *oldprog)

{

{

	bool addorrep = cmd == TC_CLSBPF_ADD || cmd == TC_CLSBPF_REPLACE;

	struct tcf_block *block = tp->chain->block;

	struct tcf_block *block = tp->chain->block;

	bool skip_sw = tc_skip_sw(prog->gen_flags);

	struct tc_cls_bpf_offload cls_bpf = {};

	struct tc_cls_bpf_offload cls_bpf = {};

	struct cls_bpf_prog *obj;

	bool skip_sw;

	int err;

	int err;





	skip_sw = prog && tc_skip_sw(prog->gen_flags);

	obj = prog ?: oldprog;



	tc_cls_common_offload_init(&cls_bpf.common, tp);

	tc_cls_common_offload_init(&cls_bpf.common, tp);

	cls_bpf.command = cmd;

	cls_bpf.command = TC_CLSBPF_OFFLOAD;

	cls_bpf.exts = &prog->exts;

	cls_bpf.exts = &obj->exts;

	cls_bpf.prog = prog->filter;

	cls_bpf.prog = prog ? prog->filter : NULL;

	cls_bpf.name = prog->bpf_name;

	cls_bpf.oldprog = oldprog ? oldprog->filter : NULL;

	cls_bpf.exts_integrated = prog->exts_integrated;

	cls_bpf.name = obj->bpf_name;

	cls_bpf.gen_flags = prog->gen_flags;

	cls_bpf.exts_integrated = obj->exts_integrated;

	cls_bpf.gen_flags = obj->gen_flags;





	err = tc_setup_cb_call(block, NULL, TC_SETUP_CLSBPF, &cls_bpf, skip_sw);

	err = tc_setup_cb_call(block, NULL, TC_SETUP_CLSBPF, &cls_bpf, skip_sw);

	if (addorrep) {

	if (prog) {

		if (err < 0) {

		if (err < 0) {

			cls_bpf_offload_cmd(tp, prog, TC_CLSBPF_DESTROY);

			cls_bpf_offload_cmd(tp, oldprog, prog);

			return err;

			return err;

		} else if (err > 0) {

		} else if (err > 0) {

			prog->gen_flags |= TCA_CLS_FLAGS_IN_HW;

			prog->gen_flags |= TCA_CLS_FLAGS_IN_HW;

		}

		}

	}

	}





	if (addorrep && skip_sw && !(prog->gen_flags & TCA_CLS_FLAGS_IN_HW))

	if (prog && skip_sw && !(prog->gen_flags & TCA_CLS_FLAGS_IN_HW))

		return -EINVAL;

		return -EINVAL;





	return 0;

	return 0;
@@ -183,38 +186,17 @@ static int cls_bpf_offload_cmd(struct tcf_proto *tp, struct cls_bpf_prog *prog, 
static int cls_bpf_offload(struct tcf_proto *tp, struct cls_bpf_prog *prog,

static int cls_bpf_offload(struct tcf_proto *tp, struct cls_bpf_prog *prog,

			   struct cls_bpf_prog *oldprog)

			   struct cls_bpf_prog *oldprog)

{

{

	struct cls_bpf_prog *obj = prog;

	if (prog && oldprog && prog->gen_flags != oldprog->gen_flags)

	enum tc_clsbpf_command cmd;

	bool skip_sw;

	int ret;



	skip_sw = tc_skip_sw(prog->gen_flags) ||

		(oldprog && tc_skip_sw(oldprog->gen_flags));



	if (oldprog && oldprog->offloaded) {

		if (!tc_skip_hw(prog->gen_flags)) {

			cmd = TC_CLSBPF_REPLACE;

		} else if (!tc_skip_sw(prog->gen_flags)) {

			obj = oldprog;

			cmd = TC_CLSBPF_DESTROY;

		} else {

		return -EINVAL;

		return -EINVAL;

		}

	} else {

		if (tc_skip_hw(prog->gen_flags))

			return skip_sw ? -EINVAL : 0;

		cmd = TC_CLSBPF_ADD;

	}



	ret = cls_bpf_offload_cmd(tp, obj, cmd);

	if (ret)

		return ret;



	obj->offloaded = true;

	if (oldprog)

		oldprog->offloaded = false;





	if (prog && tc_skip_hw(prog->gen_flags))

		prog = NULL;

	if (oldprog && tc_skip_hw(oldprog->gen_flags))

		oldprog = NULL;

	if (!prog && !oldprog)

		return 0;

		return 0;



	return cls_bpf_offload_cmd(tp, prog, oldprog);

}

}





static void cls_bpf_stop_offload(struct tcf_proto *tp,

static void cls_bpf_stop_offload(struct tcf_proto *tp,
@@ -222,25 +204,26 @@ static void cls_bpf_stop_offload(struct tcf_proto *tp, 
{

{

	int err;

	int err;





	if (!prog->offloaded)

	err = cls_bpf_offload_cmd(tp, NULL, prog);

		return;

	if (err)



	err = cls_bpf_offload_cmd(tp, prog, TC_CLSBPF_DESTROY);

	if (err) {

		pr_err("Stopping hardware offload failed: %d\n", err);

		pr_err("Stopping hardware offload failed: %d\n", err);

		return;

	}



	prog->offloaded = false;

}

}





static void cls_bpf_offload_update_stats(struct tcf_proto *tp,

static void cls_bpf_offload_update_stats(struct tcf_proto *tp,

					 struct cls_bpf_prog *prog)

					 struct cls_bpf_prog *prog)

{

{

	if (!prog->offloaded)

	struct tcf_block *block = tp->chain->block;

		return;

	struct tc_cls_bpf_offload cls_bpf = {};



	tc_cls_common_offload_init(&cls_bpf.common, tp);

	cls_bpf.command = TC_CLSBPF_STATS;

	cls_bpf.exts = &prog->exts;

	cls_bpf.prog = prog->filter;

	cls_bpf.name = prog->bpf_name;

	cls_bpf.exts_integrated = prog->exts_integrated;

	cls_bpf.gen_flags = prog->gen_flags;





	cls_bpf_offload_cmd(tp, prog, TC_CLSBPF_STATS);

	tc_setup_cb_call(block, NULL, TC_SETUP_CLSBPF, &cls_bpf, false);

}

}





static int cls_bpf_init(struct tcf_proto *tp)

static int cls_bpf_init(struct tcf_proto *tp)

CRA Git | Maintained and supported by SUSTech CRA and CCSE