netfilter: add hardware offload infrastructure
Subsystems (9)
Pablo Neira Ayuso
maintainercover netfilter: add hardware offload infrastructure
Hi,
This patchset adds initial hardware offload support for nftables through the existing netdev_ops->ndo_setup_tc() interface, the TC_SETUP_CLSFLOWER classifier and the flow rule API.
Patch 1 move the flow block callback infrastructure to
net/core/flow_offload.c. More structure and enumeration definitions currently in include/net/pkt_cls.h can be also there to reuse this from the netfilter codebase.
Patch 2 adds hardware offload support for nftables.
This patchset depends on a previous patchset:
[PATCH net-next,RFC 0/9] net: sched: prepare to reuse per-block callbacks from netfilter
More information at: https://marc.info/?l=netfilter-devel&m=155623884016026&w=2
Comments welcome, thanks.
Pablo Neira Ayuso (2):
net: flow_offload: add flow_block_cb API
netfilter: nf_tables: add hardware offload support
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | 22 +-- drivers/net/ethernet/mellanox/mlxsw/spectrum.c | 54 +++--- drivers/net/ethernet/netronome/nfp/abm/cls.c | 2 +- drivers/net/ethernet/netronome/nfp/abm/main.h | 2 +- .../net/ethernet/netronome/nfp/flower/offload.c | 18 +- include/net/flow_offload.h | 48 +++++ include/net/netfilter/nf_tables.h | 13 ++ include/net/netfilter/nf_tables_offload.h | 76 ++++++++ include/net/pkt_cls.h | 40 +--- include/uapi/linux/netfilter/nf_tables.h | 2 + net/core/flow_offload.c | 77 ++++++++ net/dsa/slave.c | 2 +- net/netfilter/Makefile | 2 +- net/netfilter/nf_tables_api.c | 16 +- net/netfilter/nf_tables_offload.c | 216 +++++++++++++++++++++ net/netfilter/nft_cmp.c | 53 +++++ net/netfilter/nft_immediate.c | 31 +++ net/netfilter/nft_meta.c | 27 +++ net/netfilter/nft_payload.c | 187 ++++++++++++++++++ net/sched/cls_api.c | 140 +++---------- 20 files changed, 827 insertions(+), 201 deletions(-) create mode 100644 include/net/netfilter/nf_tables_offload.h create mode 100644 net/netfilter/nf_tables_offload.c
Signature · 1 line
2.11.0
Pablo Neira Ayuso
maintainerRFC PATCH 1/2 net: flow_offload: add flow_block_cb API
This patch renames:
* struct tcf_block_cb to flow_block_cb.
* struct tc_block_offload to flow_block_offload.
And it exposes the flow_block_cb API through net/flow_offload.h. This renames the existing codebase to adapt it to this name.
--- drivers/net/ethernet/mellanox/mlx5/core/en_rep.c | 22 ++-- drivers/net/ethernet/mellanox/mlxsw/spectrum.c | 54 ++++---- drivers/net/ethernet/netronome/nfp/abm/cls.c | 2 +- drivers/net/ethernet/netronome/nfp/abm/main.h | 2 +- .../net/ethernet/netronome/nfp/flower/offload.c | 18 +-- include/net/flow_offload.h | 48 +++++++ include/net/pkt_cls.h | 40 +----- net/core/flow_offload.c | 77 ++++++++++++ net/dsa/slave.c | 2 +- net/sched/cls_api.c | 140 +++++---------------- 10 files changed, 207 insertions(+), 198 deletions(-)
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +11 -11
@@ -708,10 +708,10 @@ static void mlx5e_rep_indr_tc_block_unbind(void *cb_priv)static int mlx5e_rep_indr_setup_tc_block (struct net_device *netdev,struct mlx5e_rep_priv *rpriv, -struct tc_block_offload *f) +struct flow_block_offload *f) {struct mlx5e_rep_indr_block_priv *indr_priv; -struct tcf_block_cb *block_cb; +struct flow_block_cb *block_cb;if (f->binder_type !=TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS )return -EOPNOTSUPP ;
@@ -731,15 +731,15 @@ mlx5e_rep_indr_setup_tc_block(struct net_device *netdev,list_add (&indr_priv->list, &rpriv->uplink_priv.tc_indr_block_priv_list); - block_cb =tcf_block_cb_alloc (f->block_index, - mlx5e_rep_indr_setup_block_cb, - indr_priv, indr_priv, - mlx5e_rep_indr_tc_block_unbind); + block_cb =flow_block_cb_alloc (f->block_index, + mlx5e_rep_indr_setup_block_cb, + indr_priv, indr_priv, + mlx5e_rep_indr_tc_block_unbind);if (!block_cb) {list_del (&indr_priv->list);kfree (indr_priv); } -tcf_block_cb_add (block_cb, f); +flow_block_cb_add (block_cb, f);return 0 ;case TC_BLOCK_UNBIND :
@@ -747,13 +747,13 @@ mlx5e_rep_indr_setup_tc_block(struct net_device *netdev,if (!indr_priv)return -ENOENT ; - block_cb =tcf_block_cb_lookup (f->block_index, - mlx5e_rep_indr_setup_block_cb, - indr_priv); + block_cb =flow_block_cb_lookup (f->block_index, + mlx5e_rep_indr_setup_block_cb, + indr_priv);if (!block_cb)return -ENOENT ; -tcf_block_cb_remove (block_cb, f); +flow_block_cb_remove (block_cb, f);return 0 ;default :return -EOPNOTSUPP ;
drivers/net/ethernet/mellanox/mlxsw/spectrum.c +28 -26
129 lines not on this page · raw message
drivers/net/ethernet/netronome/nfp/abm/cls.c +1 -1
@@ -263,7 +263,7 @@ static int nfp_abm_setup_tc_block_cb(enum tc_setup_type type, }int nfp_abm_setup_cls_block (struct net_device *netdev,struct nfp_repr *repr, -struct tc_block_offload *f) +struct flow_block_offload *f) {return tcf_setup_block_offload (f, nfp_abm_setup_tc_block_cb, repr, repr, true);
drivers/net/ethernet/netronome/nfp/abm/main.h +1 -1
@@ -247,7 +247,7 @@ int nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink,int nfp_abm_setup_tc_gred (struct net_device *netdev,struct nfp_abm_link *alink,struct tc_gred_qopt_offload *opt);int nfp_abm_setup_cls_block (struct net_device *netdev,struct nfp_repr *repr, -struct tc_block_offload *opt); +struct flow_block_offload *opt);int nfp_abm_ctrl_read_params (struct nfp_abm_link *alink);int nfp_abm_ctrl_find_addrs (struct nfp_abm *abm);
drivers/net/ethernet/netronome/nfp/flower/offload.c +9 -9
@@ -1256,11 +1256,11 @@ static void nfp_flower_setup_indr_tc_release(void *cb_priv)static int nfp_flower_setup_indr_tc_block (struct net_device *netdev,struct nfp_app *app, -struct tc_block_offload *f) +struct flow_block_offload *f) {struct nfp_flower_indr_block_cb_priv *cb_priv;struct nfp_flower_priv *priv = app->priv; -struct tcf_block_cb *block_cb; +struct flow_block_cb *block_cb; if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS && !(f->binder_type == TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS &&
@@ -1277,29 +1277,29 @@ nfp_flower_setup_indr_tc_block(struct net_device *netdev, struct nfp_app *app, cb_priv->app = app;list_add (&cb_priv->list, &priv->indr_block_cb_priv); - block_cb =tcf_block_cb_alloc (f->block_index, - nfp_flower_setup_indr_block_cb, - cb_priv, cb_priv, - nfp_flower_setup_indr_tc_release); + block_cb =flow_block_cb_alloc (f->block_index, + nfp_flower_setup_indr_block_cb, + cb_priv, cb_priv, + nfp_flower_setup_indr_tc_release);if (!block_cb) {list_del (&cb_priv->list);kfree (cb_priv); } -tcf_block_cb_add (block_cb, f); +flow_block_cb_add (block_cb, f);return 0 ;case TC_BLOCK_UNBIND : cb_priv =nfp_flower_indr_block_cb_priv_lookup (app, netdev);if (!cb_priv)return -ENOENT ; - block_cb =tcf_block_cb_lookup (f->block_index, + block_cb =flow_block_cb_lookup (f->block_index, nfp_flower_setup_indr_block_cb, cb_priv);if (!block_cb)return -ENOENT ; -tcf_block_cb_remove (block_cb, f); +flow_block_cb_remove (block_cb, f);return 0 ;default :return -EOPNOTSUPP ;
include/net/flow_offload.h +48 -0
52 lines not on this page · raw message
include/net/pkt_cls.h +3 -37
@@ -25,14 +25,8 @@ struct tcf_walker {int register_tcf_proto_ops (struct tcf_proto_ops *ops);int unregister_tcf_proto_ops (struct tcf_proto_ops *ops); -enum tcf_block_binder_type { -TCF_BLOCK_BINDER_TYPE_UNSPEC , -TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS , -TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS , -}; -struct tcf_block_ext_info { -enum tcf_block_binder_type binder_type; +enum flow_block_binder_type binder_type;tcf_chain_head_change_t *chain_head_change;void *chain_head_change_priv;u32 block_index;
@@ -71,23 +65,6 @@ static inline struct Qdisc *tcf_block_q(struct tcf_block *block)return block->q; } -struct tcf_block_cb *tcf_block_cb_alloc (u32 block_index,tc_setup_cb_t *cb, -void *cb_ident,void *cb_priv, -void (*release)(void *cb_priv)); -void tcf_block_cb_free (struct tcf_block_cb *block_cb); - -struct tc_block_offload ; -void tcf_block_cb_add (struct tcf_block_cb *block_cb, -struct tc_block_offload *offload); -void tcf_block_cb_remove (struct tcf_block_cb *block_cb, -struct tc_block_offload *offload); - -void *tcf_block_cb_priv (struct tcf_block_cb *block_cb); -struct tcf_block_cb *tcf_block_cb_lookup (u32 block_index,tc_setup_cb_t *cb, -void *cb_ident); -void tcf_block_cb_incref (struct tcf_block_cb *block_cb); -unsigned int tcf_block_cb_decref (struct tcf_block_cb *block_cb); -int __tc_indr_block_cb_register (struct net_device *dev,void *cb_priv,tc_indr_block_bind_cb_t *cb,void *cb_ident); int tc_indr_block_cb_register(struct net_device *dev, void *cb_priv,
@@ -633,20 +610,9 @@ int tc_setup_cb_call(struct tcf_block *block, enum tc_setup_type type, void *type_data, bool err_stop);unsigned int tcf_exts_num_actions (struct tcf_exts *exts); -enum tc_block_command { -TC_BLOCK_BIND , -TC_BLOCK_UNBIND , -}; - -struct tc_block_offload { -enum tc_block_command command; -enum tcf_block_binder_type binder_type; -struct list_head cb_list; -u32 block_index; -struct netlink_ext_ack *extack; -}; +struct flow_block_offload ; -int tcf_setup_block_offload (struct tc_block_offload *f,tc_setup_cb_t *cb, +int tcf_setup_block_offload (struct flow_block_offload *f,tc_setup_cb_t *cb,void *cb_ident,void *cb_priv,bool ingress_only);struct tc_cls_common_offload {
net/core/flow_offload.c +77 -0
80 lines not on this page · raw message
net/dsa/slave.c +1 -1
@@ -900,7 +900,7 @@ static int dsa_slave_setup_tc_block_cb_eg(enum tc_setup_type type, }static int dsa_slave_setup_tc_block (struct net_device *dev, -struct tc_block_offload *f) +struct flow_block_offload *f) {struct tcf_block_cb *block_cb;tc_setup_cb_t *cb;
net/sched/cls_api.c +28 -112
251 lines not on this page · raw message
Signature · 1 line
2.11.0
Jiri Pirko
maintainerRe: [PATCH net-next,RFC 1/2] net: flow_offload: add flow_block_cb API
Quoted 9 lines · Thu, May 09, 2019 at 06:39:50PM CEST, [email protected] wrote:
This patch renames:
* struct
tcf_block_cbtoflow_block_cb.
* structtc_block_offloadtoflow_block_offload.And it exposes the
flow_block_cbAPI throughnet/flow_offload.h. This renames the existing codebase to adapt it to this name.Signed-off-by Pablo Neira Ayuso <[email protected]>
[...]
net/core/flow_offload.c void flow_rule_match_enc_opts(const struct flow_rule *rule, · line 162
Quoted 9 lines
net/core/flow_offload.c +9
-0+ +void *flow_block_cb_priv (struct flow_block_cb *block_cb) +{ +return block_cb->cb_priv; +} +EXPORT_SYMBOL (flow_block_cb_priv); + +LIST_HEAD (flow_block_cb_list); +EXPORT_SYMBOL (flow_block_cb_list);
I don't understand, why is this exported?
net/core/flow_offload.c void flow_rule_match_enc_opts(const struct flow_rule *rule, · line 165
Quoted 3 lines
net/core/flow_offload.c +3
-0+ +struct flow_block_cb *flow_block_cb_lookup (u32 block_index,tc_setup_cb_t *cb, +void *cb_ident)
2 namespaces may have the same block_index, yet it is completely unrelated block. The cb_ident
Quoted 10 lines
net/core/flow_offload.c +10
-0+{struct flow_block_cb *block_cb; + +list_for_each_entry (block_cb, &flow_block_cb_list, list) +if (block_cb->block_index == block_index && + block_cb->cb == cb && + block_cb->cb_ident == cb_ident) +return block_cb; +return NULL ; +} +EXPORT_SYMBOL (flow_block_cb_lookup);
[...]
Pablo Neira Ayuso
maintainerRe: [PATCH net-next,RFC 1/2] net: flow_offload: add flow_block_cb API
Quoted 14 lines · Jiri Pirko
Quoted 9 lines · Thu, May 09, 2019 at 06:39:50PM CEST, [email protected] wrote:
This patch renames:
* struct
tcf_block_cbtoflow_block_cb.
* structtc_block_offloadtoflow_block_offload.And it exposes the
flow_block_cbAPI throughnet/flow_offload.h. This renames the existing codebase to adapt it to this name.Signed-off-by Pablo Neira Ayuso <[email protected]>[...]
Quoted 11 lines
net/core/flow_offload.c void flow_rule_match_enc_opts(const struct flow_rule *rule, · line 162
Quoted 9 lines
net/core/flow_offload.c +9
-0+ +void *flow_block_cb_priv (struct flow_block_cb *block_cb) +{ +return block_cb->cb_priv; +} +EXPORT_SYMBOL (flow_block_cb_priv); + +LIST_HEAD (flow_block_cb_list); +EXPORT_SYMBOL (flow_block_cb_list);I don't understand, why is this exported?
Will stop exposing this in the next patchset version.
Quoted 6 lines
net/core/flow_offload.c void flow_rule_match_enc_opts(const struct flow_rule *rule, · line 165
Quoted 3 lines
net/core/flow_offload.c +3
-0+ +struct flow_block_cb *flow_block_cb_lookup (u32 block_index,tc_setup_cb_t *cb, +void *cb_ident)2 namespaces may have the same
block_index, yet it is completely unrelated block. Thecb_ident
Yes, a struct netns parameter here for flow_block_cb_lookup() is needed. I will also add a possible_net_t field to store this in the flow_block_cb object so we can just stay with one single list for all net namespaces by now.
Thanks.
Quoted 12 lines
Quoted 10 lines
net/core/flow_offload.c +10
-0+{struct flow_block_cb *block_cb; + +list_for_each_entry (block_cb, &flow_block_cb_list, list) +if (block_cb->block_index == block_index && + block_cb->cb == cb && + block_cb->cb_ident == cb_ident) +return block_cb; +return NULL ; +} +EXPORT_SYMBOL (flow_block_cb_lookup);[...]
Pablo Neira Ayuso
maintainerRFC PATCH 2/2 netfilter: nf_tables: add hardware offload support
In reply to Pablo Neira AyusoThis patch adds hardware offload support for nftables through the existing netdev_ops->ndo_setup_tc() interface, the TC_SETUP_CLSFLOWER classifier and the flow rule API. This hardware offload support is available for the NFPROTO_NETDEV family and the ingress hook.
Each nftables expression has a new ->offload interface, that is used to populate the flow rule object that is attached to the transaction object.
There is a new per-table NFT_TABLE_F_HW flag, that is set on to offload an entire table, including all of its chains.
This patch supports for basic metadata (layer 3 and 4 protocol numbers), 5-tuple payload matching and the accept/drop actions; this also includes basechain hardware offload only.
--- include/net/netfilter/nf_tables.h | 13 ++ include/net/netfilter/nf_tables_offload.h | 76 +++++++++++ include/uapi/linux/netfilter/nf_tables.h | 2 + net/netfilter/Makefile | 2 +- net/netfilter/nf_tables_api.c | 16 ++- net/netfilter/nf_tables_offload.c | 216 ++++++++++++++++++++++++++++++ net/netfilter/nft_cmp.c | 53 ++++++++ net/netfilter/nft_immediate.c | 31 +++++ net/netfilter/nft_meta.c | 27 ++++ net/netfilter/nft_payload.c | 187 ++++++++++++++++++++++++++ 10 files changed, 620 insertions(+), 3 deletions(-) create mode 100644 include/net/netfilter/nf_tables_offload.h create mode 100644 net/netfilter/nf_tables_offload.c
include/net/netfilter/nf_tables.h +13 -0
@@ -160,6 +160,7 @@ struct nft_ctx {const struct nlattr *const *nla;u32 portid;u32 seq; +u16 flags;u8 family;u8 level;bool report;
@@ -734,6 +735,9 @@ enum nft_trans_phase { NFT_TRANS_RELEASE }; +struct nft_flow_rule ; +struct nft_offload_ctx ; +/** * struct nft_expr_ops - nf_tables expression operations *
@@ -776,6 +780,10 @@ struct nft_expr_ops { const struct nft_data **data);bool (*gc)(struct net *net,const struct nft_expr *expr); +int (*offload)(struct nft_offload_ctx *ctx, +struct nft_flow_rule *flow, +const struct nft_expr *expr); +u32 offload_flags;const struct nft_expr_type *type;void *data; };
@@ -958,6 +966,7 @@ struct nft_stats {* @stats: per-cpu chain stats * @chain: the chain * @dev_name: device name that this base chain is attached to (if any) +* @cb_list: list of flow block callbacks (for hardware offload) */ struct nft_base_chain {struct nf_hook_ops ops;
@@ -967,6 +976,7 @@ struct nft_base_chain {struct nft_stats __percpu *stats;struct nft_chain chain;char dev_name[IFNAMSIZ ]; +struct list_head cb_list; };static inline struct nft_base_chain *nft_base_chain (const struct nft_chain *chain)
@@ -1338,11 +1348,14 @@ struct nft_trans {struct nft_trans_rule {struct nft_rule *rule; +struct nft_flow_rule *flow;u32 rule_id; };#define nft_trans_rule (trans) \ (((struct nft_trans_rule *)trans->data)->rule) +#define nft_trans_flow_rule (trans) \ + (((struct nft_trans_rule *)trans->data)->flow)#define nft_trans_rule_id (trans) \ (((struct nft_trans_rule *)trans->data)->rule_id)
include/net/netfilter/nf_tables_offload.h new file +76 -0
76 lines not on this page · raw message
include/uapi/linux/netfilter/nf_tables.h +2 -0
@@ -158,9 +158,11 @@ enum nft_hook_attributes {* enum nft_table_flags - nf_tables table flags * * @NFT_TABLE_F_DORMANT: this table is not active +* @NFT_TABLE_F_HW_OFFLOAD: enable hardware offload */ enum nft_table_flags {NFT_TABLE_F_DORMANT =0x1 , +NFT_TABLE_F_HW_OFFLOAD =0x2 , };/**
net/netfilter/Makefile +1 -1
@@ -78,7 +78,7 @@ nf_tables-objs := nf_tables_core.o nf_tables_api.o nft_chain_filter.o \ nf_tables_trace.o nft_immediate.o nft_cmp.o nft_range.o \ nft_bitwise.o nft_byteorder.o nft_payload.o nft_lookup.o \ nft_dynset.o nft_meta.o nft_rt.o nft_exthdr.o \ - nft_chain_route.o + nft_chain_route.o nf_tables_offload.o nf_tables_set-objs := nf_tables_set_core.o \ nft_set_hash.o nft_set_bitmap.o nft_set_rbtree.o
net/netfilter/nf_tables_api.c +14 -2
@@ -21,6 +21,7 @@#include <net/netfilter/nf_flow_table.h> #include <net/netfilter/nf_tables_core.h> #include <net/netfilter/nf_tables.h> +#include <net/netfilter/nf_tables_offload.h> #include <net/net_namespace.h> #include <net/sock.h>
@@ -100,6 +101,7 @@ static void nft_ctx_init(struct nft_ctx *ctx, ctx->nla = nla; ctx->portid =NETLINK_CB (skb).portid; ctx->report =nlmsg_report (nlh); + ctx->flags = nlh->nlmsg_flags; ctx->seq = nlh->nlmsg_seq; }
@@ -899,7 +901,7 @@ static int nf_tables_newtable(struct net *net, struct sock *nlsk,if (nla[NFTA_TABLE_FLAGS ]) { flags =ntohl (nla_get_be32 (nla[NFTA_TABLE_FLAGS ])); -if (flags & ~NFT_TABLE_F_DORMANT ) +if (flags & ~(NFT_TABLE_F_DORMANT |NFT_TABLE_F_HW_OFFLOAD ))return -EINVAL ; }
@@ -1662,6 +1664,7 @@ static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask, chain->flags |=NFT_BASE_CHAIN ; basechain->policy = policy; +INIT_LIST_HEAD (&basechain->cb_list); }else { chain =kzalloc (sizeof (*chain),GFP_KERNEL );if (chain ==NULL )
@@ -2631,6 +2634,7 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,u8 genmask =nft_genmask_next (net);struct nft_expr_info *info =NULL ;int family = nfmsg->nfgen_family; +struct nft_flow_rule *flow;struct nft_table *table;struct nft_chain *chain;struct nft_rule *rule, *old_rule =NULL ;
@@ -2777,7 +2781,8 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,list_add_tail_rcu (&rule->list, &old_rule->list); }else { -if (nft_trans_rule_add (&ctx,NFT_MSG_NEWRULE , rule) ==NULL ) { + trans =nft_trans_rule_add (&ctx,NFT_MSG_NEWRULE , rule); +if (!trans) { err = -ENOMEM ; goto err2; }
@@ -2800,6 +2805,11 @@ static int nf_tables_newrule(struct net *net, struct sock *nlsk,if (net->nft.validate_state ==NFT_VALIDATE_DO )return nft_table_validate (net, table); + flow =nft_flow_rule_create (rule); +if (IS_ERR (flow)) +return PTR_ERR (flow); + +nft_trans_flow_rule (trans) = flow;return 0 ; err2:nf_tables_rule_release (&ctx, rule);
@@ -6571,6 +6581,8 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb)if (nf_tables_validate (net) <0 )return -EAGAIN ; +nft_flow_rule_offload_commit (net); +/* 1. Allocate space for next generation rules_gen_X[] */ list_for_each_entry_safe (trans, next, &net->nft.commit_list, list) {int ret;
net/netfilter/nf_tables_offload.c new file +216 -0
216 lines not on this page · raw message
net/netfilter/nft_cmp.c +53 -0
83 lines not on this page · raw message
net/netfilter/nft_immediate.c +31 -0
@@ -16,6 +16,7 @@#include <linux/netfilter/nf_tables.h> #include <net/netfilter/nf_tables_core.h> #include <net/netfilter/nf_tables.h> +#include <net/netfilter/nf_tables_offload.h> void nft_immediate_eval(const struct nft_expr *expr, struct nft_regs *regs,
@@ -127,6 +128,34 @@ static int nft_immediate_validate(const struct nft_ctx *ctx,return 0 ; } +static int nft_immediate_offload (struct nft_offload_ctx *ctx, +struct nft_flow_rule *flow, +const struct nft_expr *expr) +{ +const struct nft_immediate_expr *priv =nft_expr_priv (expr); +struct flow_action_entry *entry; +const struct nft_data *data; + +if (priv->dreg !=NFT_REG_VERDICT ) +return -EOPNOTSUPP ; + + entry = &flow->rule->action.entries[ctx->num_actions++]; + + data = &priv->data; +switch (data->verdict.code) { +case NF_ACCEPT : + entry->id =FLOW_ACTION_ACCEPT ; +break ; +case NF_DROP : + entry->id =FLOW_ACTION_DROP ; +break ; +default : +return -EOPNOTSUPP ; + } + +return 0 ; +} +static const struct nft_expr_ops nft_imm_ops = { .type = &nft_imm_type, .size =NFT_EXPR_SIZE (sizeof (struct nft_immediate_expr )),
@@ -136,6 +165,8 @@ static const struct nft_expr_ops nft_imm_ops = { .deactivate = nft_immediate_deactivate, .dump = nft_immediate_dump, .validate = nft_immediate_validate, + .offload = nft_immediate_offload, + .offload_flags = NFT_OFFLOAD_F_ACTION, };struct nft_expr_type nft_imm_type__read_mostly = {
net/netfilter/nft_meta.c +27 -0
@@ -24,6 +24,7 @@#include <net/tcp_states.h> /* for TCP_TIME_WAIT */ #include <net/netfilter/nf_tables.h> #include <net/netfilter/nf_tables_core.h> +#include <net/netfilter/nf_tables_offload.h> #include <uapi/linux/netfilter_bridge.h> /* NF_BR_PRE_ROUTING */
@@ -518,6 +519,31 @@ static void nft_meta_set_destroy(const struct nft_ctx *ctx,static_branch_dec (&nft_trace_enabled); } +static int nft_meta_get_offload (struct nft_offload_ctx *ctx, +struct nft_flow_rule *flow, +const struct nft_expr *expr) +{ +const struct nft_meta *priv =nft_expr_priv (expr); +struct nft_offload_reg *reg = &ctx->regs[priv->dreg]; + +switch (priv->key) { +case NFT_META_PROTOCOL : +NFT_OFFLOAD_MATCH (FLOW_DISSECTOR_KEY_BASIC , basic, n_proto, +sizeof (__u16), reg); +nft_offload_set_dependency (ctx,NFT_OFFLOAD_DEP_NETWORK ); +break ; +case NFT_META_L4PROTO : +NFT_OFFLOAD_MATCH (FLOW_DISSECTOR_KEY_BASIC , basic, ip_proto, +sizeof (__u8), reg); +nft_offload_set_dependency (ctx,NFT_OFFLOAD_DEP_TRANSPORT ); +break ; +default : +return -EOPNOTSUPP ; + } + +return 0 ; +} +static const struct nft_expr_ops nft_meta_get_ops = { .type = &nft_meta_type, .size =NFT_EXPR_SIZE (sizeof (struct nft_meta )),
@@ -525,6 +551,7 @@ static const struct nft_expr_ops nft_meta_get_ops = { .init = nft_meta_get_init, .dump = nft_meta_get_dump, .validate = nft_meta_get_validate, + .offload = nft_meta_get_offload, };static const struct nft_expr_ops nft_meta_set_ops = {
net/netfilter/nft_payload.c +187 -0
215 lines not on this page · raw message
Signature · 1 line
2.11.0
Jiri Pirko
maintainerRe: [PATCH net-next,RFC 2/2] netfilter: nf_tables: add hardware offload support
Quoted 17 lines · Thu, May 09, 2019 at 06:39:51PM CEST, [email protected] wrote:
This patch adds hardware offload support for nftables through the existing
netdev_ops->ndo_setup_tc()interface, theTC_SETUP_CLSFLOWERclassifier and the flow rule API. This hardware offload support is available for theNFPROTO_NETDEVfamily and the ingress hook.Each nftables expression has a new ->offload interface, that is used to populate the flow rule object that is attached to the transaction object.
There is a new per-table
NFT_TABLE_F_HWflag, that is set on to offload an entire table, including all of its chains.This patch supports for basic metadata (layer 3 and 4 protocol numbers), 5-tuple payload matching and the accept/drop actions; this also includes basechain hardware offload only.
Signed-off-by Pablo Neira Ayuso <[email protected]>
[...]
Quoted 15 lines
net/netfilter/nf_tables_offload.c new file +15
-0+static int nft_flow_offload_chain (struct nft_trans *trans, +enum flow_block_command cmd) +{ +struct nft_chain *chain = trans->ctx.chain; +struct netlink_ext_ack extack = {}; +struct flow_block_offload bo = {}; +struct nft_base_chain *basechain; +struct net_device *dev; +int err; + +if (!nft_is_base_chain (chain)) +return -EOPNOTSUPP ; + + basechain =nft_base_chain (chain); + dev = basechain->ops.dev;
net/netfilter/nf_tables_offload.c line 171
Quoted 10 lines
net/netfilter/nf_tables_offload.c new file +10
-0+if (!dev) +return -EOPNOTSUPP ; + + bo.command = cmd; + bo.binder_type =TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS ; + bo.block_index = (u32 )trans->ctx.chain->handle; + bo.extack = &extack; +INIT_LIST_HEAD (&bo.cb_list); + + err = dev->netdev_ops->ndo_setup_tc (dev,TC_SETUP_BLOCK , &bo);
Okay, so you pretend to be clsact-ingress-flower. That looks fine. But how do you ensure that the real one does not bind a block on the same device too?
Quoted 7 lines
net/netfilter/nf_tables_offload.c new file +7
-0+if (err <0 ) +return err; + +list_splice (&bo.cb_list, &basechain->cb_list); +return 0 ; +} +
[...]
Pablo Neira Ayuso
maintainerRe: [PATCH net-next,RFC 2/2] netfilter: nf_tables: add hardware offload support
Quoted 42 lines · Jiri Pirko
Quoted 17 lines · Thu, May 09, 2019 at 06:39:51PM CEST, [email protected] wrote:
This patch adds hardware offload support for nftables through the existing
netdev_ops->ndo_setup_tc()interface, theTC_SETUP_CLSFLOWERclassifier and the flow rule API. This hardware offload support is available for theNFPROTO_NETDEVfamily and the ingress hook.Each nftables expression has a new ->offload interface, that is used to populate the flow rule object that is attached to the transaction object.
There is a new per-table
NFT_TABLE_F_HWflag, that is set on to offload an entire table, including all of its chains.This patch supports for basic metadata (layer 3 and 4 protocol numbers), 5-tuple payload matching and the accept/drop actions; this also includes basechain hardware offload only.
Signed-off-by Pablo Neira Ayuso <[email protected]>[...]
Quoted 21 lines
net/netfilter/nf_tables_offload.c new file +21
-0+static int nft_flow_offload_chain (struct nft_trans *trans, +enum flow_block_command cmd) +{ +struct nft_chain *chain = trans->ctx.chain; +struct netlink_ext_ack extack = {}; +struct flow_block_offload bo = {}; +struct nft_base_chain *basechain; +struct net_device *dev; +int err; + +if (!nft_is_base_chain (chain)) +return -EOPNOTSUPP ; + + basechain =nft_base_chain (chain); + dev = basechain->ops.dev; +if (!dev) +return -EOPNOTSUPP ; + + bo.command = cmd; + bo.binder_type =TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS ; + bo.block_index = (u32 )trans->ctx.chain->handle;
Quoted 8 lines
net/netfilter/nf_tables_offload.c line 171
Quoted 4 lines
net/netfilter/nf_tables_offload.c new file +4
-0+ bo.extack = &extack; +INIT_LIST_HEAD (&bo.cb_list); + + err = dev->netdev_ops->ndo_setup_tc (dev,TC_SETUP_BLOCK , &bo);Okay, so you pretend to be clsact-ingress-flower. That looks fine. But how do you ensure that the real one does not bind a block on the same device too?
I could store the interface index in the block_cb object, then use the tuple [ cb, cb_ident, ifindex ] to check if the block is already bound by when flow_block_cb_alloc() is called.
Thanks.
Pablo Neira Ayuso
maintainerRe: [PATCH net-next,RFC 2/2] netfilter: nf_tables: add hardware offload support
Quoted 52 lines · Pablo Neira Ayuso
Quoted 42 lines · Jiri Pirko
Quoted 17 lines · Thu, May 09, 2019 at 06:39:51PM CEST, [email protected] wrote:
This patch adds hardware offload support for nftables through the existing
netdev_ops->ndo_setup_tc()interface, theTC_SETUP_CLSFLOWERclassifier and the flow rule API. This hardware offload support is available for theNFPROTO_NETDEVfamily and the ingress hook.Each nftables expression has a new ->offload interface, that is used to populate the flow rule object that is attached to the transaction object.
There is a new per-table
NFT_TABLE_F_HWflag, that is set on to offload an entire table, including all of its chains.This patch supports for basic metadata (layer 3 and 4 protocol numbers), 5-tuple payload matching and the accept/drop actions; this also includes basechain hardware offload only.
Signed-off-by Pablo Neira Ayuso <[email protected]>[...]
Quoted 21 lines
(quoted diff) +21
-0+static int nft_flow_offload_chain(struct nft_trans *trans, + enum flow_block_command cmd) +{ + struct nft_chain *chain = trans->ctx.chain; + struct netlink_ext_ack extack = {}; + struct flow_block_offload bo = {}; + struct nft_base_chain *basechain; + struct net_device *dev; + int err; + + if (!nft_is_base_chain(chain)) + return -EOPNOTSUPP; + + basechain = nft_base_chain(chain); + dev = basechain->ops.dev; + if (!dev) + return -EOPNOTSUPP; + + bo.command = cmd; + bo.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS; + bo.block_index = (u32)trans->ctx.chain->handle;Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ bo.extack = &extack; + INIT_LIST_HEAD(&bo.cb_list); + + err = dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_BLOCK, &bo);Okay, so you pretend to be clsact-ingress-flower. That looks fine. But how do you ensure that the real one does not bind a block on the same device too?
Quoted 3 lines
I could store the interface index in the
block_cbobject, then use the tuple [ cb,cb_ident, ifindex ] to check if the block is already bound by whenflow_block_cb_alloc()is called.
Actually cb_ident would be sufficient. One possibility would be to extend flow_block_cb_alloc() to check for an existing binding.
net/core/flow_offload.c +7 -1
@@ -193,9 +193,15 @@ struct flow_block_cb *flow_block_cb_alloc(u32 block_index, tc_setup_cb_t *cb, {struct flow_block_cb *block_cb; +list_for_each_entry (block_cb, &flow_block_cb_list, list) { +if (block_cb->cb == cb && + block_cb->cb_ident == cb_ident) +return ERR_PTR (-EBUSY ); + } + block_cb =kzalloc (sizeof (*block_cb),GFP_KERNEL );if (!block_cb) -return NULL ; +return ERR_PTR (-ENOMEM ); block_cb->cb = cb; block_cb->cb_ident = cb_ident;
Thanks.
Jiri Pirko
maintainerRe: [PATCH net-next,RFC 2/2] netfilter: nf_tables: add hardware offload support
Quoted 53 lines · Wed, May 15, 2019 at 11:13:26AM CEST, [email protected] wrote:
Quoted 52 lines · Pablo Neira Ayuso
Quoted 50 lines · Jiri Pirko
Quoted 17 lines · Thu, May 09, 2019 at 06:39:51PM CEST, [email protected] wrote:
This patch adds hardware offload support for nftables through the existing
netdev_ops->ndo_setup_tc()interface, theTC_SETUP_CLSFLOWERclassifier and the flow rule API. This hardware offload support is available for theNFPROTO_NETDEVfamily and the ingress hook.Each nftables expression has a new ->offload interface, that is used to populate the flow rule object that is attached to the transaction object.
There is a new per-table
NFT_TABLE_F_HWflag, that is set on to offload an entire table, including all of its chains.This patch supports for basic metadata (layer 3 and 4 protocol numbers), 5-tuple payload matching and the accept/drop actions; this also includes basechain hardware offload only.
Signed-off-by Pablo Neira Ayuso <[email protected]>[...]
Quoted 15 lines
(quoted diff) +15
-0+static int nft_flow_offload_chain(struct nft_trans *trans, + enum flow_block_command cmd) +{ + struct nft_chain *chain = trans->ctx.chain; + struct netlink_ext_ack extack = {}; + struct flow_block_offload bo = {}; + struct nft_base_chain *basechain; + struct net_device *dev; + int err; + + if (!nft_is_base_chain(chain)) + return -EOPNOTSUPP; + + basechain = nft_base_chain(chain); + dev = basechain->ops.dev;Review
Quoted 10 lines
(quoted diff) +10
-0+ if (!dev) + return -EOPNOTSUPP; + + bo.command = cmd; + bo.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS; + bo.block_index = (u32)trans->ctx.chain->handle; + bo.extack = &extack; + INIT_LIST_HEAD(&bo.cb_list); + + err = dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_BLOCK, &bo);Okay, so you pretend to be clsact-ingress-flower. That looks fine. But how do you ensure that the real one does not bind a block on the same device too?
Quoted 5 lines
Quoted 3 lines
I could store the interface index in the
block_cbobject, then use the tuple [ cb,cb_ident, ifindex ] to check if the block is already bound by whenflow_block_cb_alloc()is called.Actually
cb_identwould be sufficient. One possibility would be to
That is what I wrote :)
Quoted 25 lines
extend
flow_block_cb_alloc()to check for an existing binding.net/core/flow_offload.c +7
-1@@ -193,9 +193,15 @@ struct flow_block_cb *flow_block_cb_alloc(u32 block_index, tc_setup_cb_t *cb, {struct flow_block_cb *block_cb; +list_for_each_entry (block_cb, &flow_block_cb_list, list) { +if (block_cb->cb == cb && + block_cb->cb_ident == cb_ident) +return ERR_PTR (-EBUSY ); + } + block_cb =kzalloc (sizeof (*block_cb),GFP_KERNEL );if (!block_cb) -return NULL ; +return ERR_PTR (-ENOMEM ); block_cb->cb = cb; block_cb->cb_ident = cb_ident;Thanks.
Quoted 13 lines · Pablo Neira Ayuso
Hi,
This patchset adds initial hardware offload support for nftables through the existing
netdev_ops->ndo_setup_tc()interface, theTC_SETUP_CLSFLOWERclassifier and the flow rule API.Patch 1 move the flow block callback infrastructure to
net/core/flow_offload.c. More structure and enumeration definitions currently ininclude/net/pkt_cls.hcan be also there to reuse this from the netfilter codebase.Patch 2 adds hardware offload support for nftables.
Quoted 7 lines
This patchset depends on a previous patchset:
[PATCH net-next,RFC 0/9] net: sched: prepare to reuse per-block callbacks from netfilter
More information at: https://marc.info/?l=netfilter-devel&m=155623884016026&w=2
Comments welcome, thanks.
Jiri requested the drivers remember the block info, so we can't have multiple block binds right now, unless we fix drivers. See:
commit d6787147e15d ("net/sched: remove block pointer from common offload structure")
for example.