nfp: bpf: require seamless reload for program replace (e4a91cd5) · Commits · e / devices / android_kernel_xiaomi_nabu

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

+4 −7

Original line number	Original line	Diff line number	Diff line
	@@ -68,7 +68,7 @@ nfp_bpf_xdp_offload(struct nfp_app app, struct nfp_net nn,
	if (prog && running && !xdp_running)		if (prog && running && !xdp_running)
	return -EBUSY;		return -EBUSY;

	ret = nfp_net_bpf_offload(nn, prog, running, true);		ret = nfp_net_bpf_offload(nn, prog, running);
	/* Stop offload if replace not possible */		/* Stop offload if replace not possible */
	if (ret && prog)		if (ret && prog)
	nfp_bpf_xdp_offload(app, nn, NULL);		nfp_bpf_xdp_offload(app, nn, NULL);
	@@ -93,7 +93,6 @@ static int nfp_bpf_setup_tc_block_cb(enum tc_setup_type type,
	{		{
	struct tc_cls_bpf_offload *cls_bpf = type_data;		struct tc_cls_bpf_offload *cls_bpf = type_data;
	struct nfp_net *nn = cb_priv;		struct nfp_net *nn = cb_priv;
	bool skip_sw;

	if (type != TC_SETUP_CLSBPF \|\|		if (type != TC_SETUP_CLSBPF \|\|
	!tc_can_offload(nn->dp.netdev) \|\|		!tc_can_offload(nn->dp.netdev) \|\|
	@@ -111,15 +110,13 @@ static int nfp_bpf_setup_tc_block_cb(enum tc_setup_type type,
	return -EOPNOTSUPP;		return -EOPNOTSUPP;
	}		}

	skip_sw = !!(cls_bpf->gen_flags & TCA_CLS_FLAGS_SKIP_SW);

	switch (cls_bpf->command) {		switch (cls_bpf->command) {
	case TC_CLSBPF_REPLACE:		case TC_CLSBPF_REPLACE:
	return nfp_net_bpf_offload(nn, cls_bpf->prog, true, !skip_sw);		return nfp_net_bpf_offload(nn, cls_bpf->prog, true);
	case TC_CLSBPF_ADD:		case TC_CLSBPF_ADD:
	return nfp_net_bpf_offload(nn, cls_bpf->prog, false, !skip_sw);		return nfp_net_bpf_offload(nn, cls_bpf->prog, false);
	case TC_CLSBPF_DESTROY:		case TC_CLSBPF_DESTROY:
	return nfp_net_bpf_offload(nn, NULL, true, !skip_sw);		return nfp_net_bpf_offload(nn, NULL, true);
	default:		default:
	return -EOPNOTSUPP;		return -EOPNOTSUPP;
	}		}

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

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -183,6 +183,6 @@ int nfp_prog_verify(struct nfp_prog nfp_prog, struct bpf_prog prog);
	struct nfp_net;		struct nfp_net;

	int nfp_net_bpf_offload(struct nfp_net nn, struct bpf_prog prog,		int nfp_net_bpf_offload(struct nfp_net nn, struct bpf_prog prog,
	bool old_prog, bool sw_fallback);		bool old_prog);

	#endif		#endif

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

+30 −32

Original line number	Original line	Diff line number	Diff line
	@@ -94,14 +94,11 @@ nfp_net_bpf_offload_prepare(struct nfp_net nn, struct bpf_prog prog,
	}		}

	static void		static void
	nfp_net_bpf_load_and_start(struct nfp_net *nn, bool sw_fallback,		nfp_net_bpf_load(struct nfp_net nn, void code, dma_addr_t dma_addr,
	void *code, dma_addr_t dma_addr,
	unsigned int code_sz, unsigned int n_instr)		unsigned int code_sz, unsigned int n_instr)
	{		{
	int err;		int err;

	nn->dp.bpf_offload_skip_sw = !sw_fallback;

	nn_writew(nn, NFP_NET_CFG_BPF_SIZE, n_instr);		nn_writew(nn, NFP_NET_CFG_BPF_SIZE, n_instr);
	nn_writeq(nn, NFP_NET_CFG_BPF_ADDR, dma_addr);		nn_writeq(nn, NFP_NET_CFG_BPF_ADDR, dma_addr);

	@@ -110,14 +107,19 @@ nfp_net_bpf_load_and_start(struct nfp_net *nn, bool sw_fallback,
	if (err)		if (err)
	nn_err(nn, "FW command error while loading BPF: %d\n", err);		nn_err(nn, "FW command error while loading BPF: %d\n", err);

			dma_free_coherent(nn->dp.dev, code_sz, code, dma_addr);
			}

			static void nfp_net_bpf_start(struct nfp_net *nn)
			{
			int err;

	/* Enable passing packets through BPF function */		/* Enable passing packets through BPF function */
	nn->dp.ctrl \|= NFP_NET_CFG_CTRL_BPF;		nn->dp.ctrl \|= NFP_NET_CFG_CTRL_BPF;
	nn_writel(nn, NFP_NET_CFG_CTRL, nn->dp.ctrl);		nn_writel(nn, NFP_NET_CFG_CTRL, nn->dp.ctrl);
	err = nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_GEN);		err = nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_GEN);
	if (err)		if (err)
	nn_err(nn, "FW command error while enabling BPF: %d\n", err);		nn_err(nn, "FW command error while enabling BPF: %d\n", err);

	dma_free_coherent(nn->dp.dev, code_sz, code, dma_addr);
	}		}

	static int nfp_net_bpf_stop(struct nfp_net *nn)		static int nfp_net_bpf_stop(struct nfp_net *nn)
	@@ -127,13 +129,12 @@ static int nfp_net_bpf_stop(struct nfp_net *nn)

	nn->dp.ctrl &= ~NFP_NET_CFG_CTRL_BPF;		nn->dp.ctrl &= ~NFP_NET_CFG_CTRL_BPF;
	nn_writel(nn, NFP_NET_CFG_CTRL, nn->dp.ctrl);		nn_writel(nn, NFP_NET_CFG_CTRL, nn->dp.ctrl);
	nn->dp.bpf_offload_skip_sw = 0;

	return nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_GEN);		return nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_GEN);
	}		}

	int nfp_net_bpf_offload(struct nfp_net nn, struct bpf_prog prog,		int nfp_net_bpf_offload(struct nfp_net nn, struct bpf_prog prog,
	bool old_prog, bool sw_fallback)		bool old_prog)
	{		{
	struct nfp_bpf_result res;		struct nfp_bpf_result res;
	dma_addr_t dma_addr;		dma_addr_t dma_addr;
	@@ -141,37 +142,34 @@ int nfp_net_bpf_offload(struct nfp_net nn, struct bpf_prog prog,
	void *code;		void *code;
	int err;		int err;

	/* There is nothing stopping us from implementing seamless		if (prog && old_prog) {
	* replace but the simple method of loading I adopted in		u8 cap;
	* the firmware does not handle atomic replace (i.e. we have to
	* stop the BPF offload and re-enable it). Leaking-in a few		cap = nn_readb(nn, NFP_NET_CFG_BPF_CAP);
	* frames which didn't have BPF applied in the hardware should		if (!(cap & NFP_NET_BPF_CAP_RELO)) {
	* be fine if software fallback is available, though.		nn_err(nn, "FW does not support live reload\n");
	*/
	if (prog && old_prog && nn->dp.bpf_offload_skip_sw)
	return -EBUSY;		return -EBUSY;
			}
			}

	/* Something else is loaded, different program type? */		/* Something else is loaded, different program type? */
	if (!old_prog && nn->dp.ctrl & NFP_NET_CFG_CTRL_BPF)		if (!old_prog && nn->dp.ctrl & NFP_NET_CFG_CTRL_BPF)
	return -EBUSY;		return -EBUSY;

			if (old_prog && !prog)
			return nfp_net_bpf_stop(nn);

	max_instr = nn_readw(nn, NFP_NET_CFG_BPF_MAX_LEN);		max_instr = nn_readw(nn, NFP_NET_CFG_BPF_MAX_LEN);
	code = NULL;

	if (prog) {		err = nfp_net_bpf_offload_prepare(nn, prog, &res, &code, &dma_addr,
	err = nfp_net_bpf_offload_prepare(nn, prog, &res, &code,		max_instr);
	&dma_addr, max_instr);
	if (err)		if (err)
	return err;		return err;
	}

	if (old_prog)
	nfp_net_bpf_stop(nn);

	if (prog)		nfp_net_bpf_load(nn, code, dma_addr, max_instr * sizeof(u64),
	nfp_net_bpf_load_and_start(nn, sw_fallback, code,
	dma_addr, max_instr * sizeof(u64),
	res.n_instr);		res.n_instr);
			if (!old_prog)
			nfp_net_bpf_start(nn);

	return 0;		return 0;
	}		}

drivers/net/ethernet/netronome/nfp/nfp_net.h

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -476,7 +476,6 @@ struct nfp_stat_pair {
	* @dev: Backpointer to struct device		* @dev: Backpointer to struct device
	* @netdev: Backpointer to net_device structure		* @netdev: Backpointer to net_device structure
	* @is_vf: Is the driver attached to a VF?		* @is_vf: Is the driver attached to a VF?
	* @bpf_offload_skip_sw: Offloaded BPF program will not be rerun by cls_bpf
	* @bpf_offload_xdp: Offloaded BPF program is XDP		* @bpf_offload_xdp: Offloaded BPF program is XDP
	* @chained_metadata_format: Firemware will use new metadata format		* @chained_metadata_format: Firemware will use new metadata format
	* @rx_dma_dir: Mapping direction for RX buffers		* @rx_dma_dir: Mapping direction for RX buffers
	@@ -502,7 +501,6 @@ struct nfp_net_dp {
	struct net_device *netdev;		struct net_device *netdev;

	u8 is_vf:1;		u8 is_vf:1;
	u8 bpf_offload_skip_sw:1;
	u8 bpf_offload_xdp:1;		u8 bpf_offload_xdp:1;
	u8 chained_metadata_format:1;		u8 chained_metadata_format:1;