netfilter: nftables: counter hardware offload support

This patch adds the .offload_stats operation to synchronize hardware
stats with the expression data. Update the counter expression to use
this new interface. The hardware stats are retrieved from the netlink
dump path via FLOW_CLS_STATS command to the driver.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index f0f7a3c5da6ad077e2fa3fb24aea8f50d79447f1..4a75da2a2e1de79b1e0ccb051dff038748bc7d67 100644 (file)
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -867,6 +867,8 @@ struct nft_expr_ops {
        int                             (*offload)(struct nft_offload_ctx *ctx,
                                                   struct nft_flow_rule *flow,
                                                   const struct nft_expr *expr);
+       void                            (*offload_stats)(struct nft_expr *expr,
+                                                        const struct flow_stats *stats);
        u32                             offload_flags;
        const struct nft_expr_type      *type;
        void                            *data;

diff --git a/include/net/netfilter/nf_tables_offload.h b/include/net/netfilter/nf_tables_offload.h
index 434a6158852f366c5f5e9bb6899bfe9823e9a8ec..f9d95ff82df834a257296285488835cf8271743e 100644 (file)
--- a/include/net/netfilter/nf_tables_offload.h
+++ b/include/net/netfilter/nf_tables_offload.h
@@ -74,6 +74,7 @@ void nft_flow_rule_set_addr_type(struct nft_flow_rule *flow,
 
 struct nft_rule;
 struct nft_flow_rule *nft_flow_rule_create(struct net *net, const struct nft_rule *rule);
+int nft_flow_rule_stats(const struct nft_chain *chain, const struct nft_rule *rule);
 void nft_flow_rule_destroy(struct nft_flow_rule *flow);
 int nft_flow_rule_offload_commit(struct net *net);
 

diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 1b881a84bd01a008677e4494e4d88e56eb4c02ca..37e9accd9aeb1eb42042314c51e7b2d1845528a2 100644 (file)
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -2878,6 +2878,9 @@ static int nf_tables_fill_rule_info(struct sk_buff *skb, struct net *net,
                        goto nla_put_failure;
        }
 
+       if (chain->flags & NFT_CHAIN_HW_OFFLOAD)
+               nft_flow_rule_stats(chain, rule);
+
        list = nla_nest_start_noflag(skb, NFTA_RULE_EXPRESSIONS);
        if (list == NULL)
                goto nla_put_failure;

diff --git a/net/netfilter/nf_tables_offload.c b/net/netfilter/nf_tables_offload.c
index 1d428792018fe87e59b05f0316d59e6dd1c6b57b..19215e81dd66ebc700bcbd1387ac4c2a8b5cc95f 100644 (file)
--- a/net/netfilter/nf_tables_offload.c
+++ b/net/netfilter/nf_tables_offload.c
@@ -243,26 +243,56 @@ static void nft_flow_cls_offload_setup(struct flow_cls_offload *cls_flow,
                cls_flow->rule = flow->rule;
 }
 
-static int nft_flow_offload_rule(struct nft_chain *chain,
-                                struct nft_rule *rule,
-                                struct nft_flow_rule *flow,
-                                enum flow_cls_command command)
+static int nft_flow_offload_cmd(const struct nft_chain *chain,
+                               const struct nft_rule *rule,
+                               struct nft_flow_rule *flow,
+                               enum flow_cls_command command,
+                               struct flow_cls_offload *cls_flow)
 {
        struct netlink_ext_ack extack = {};
-       struct flow_cls_offload cls_flow;
        struct nft_base_chain *basechain;
 
        if (!nft_is_base_chain(chain))
                return -EOPNOTSUPP;
 
        basechain = nft_base_chain(chain);
-       nft_flow_cls_offload_setup(&cls_flow, basechain, rule, flow, &extack,
+       nft_flow_cls_offload_setup(cls_flow, basechain, rule, flow, &extack,
                                   command);
 
-       return nft_setup_cb_call(TC_SETUP_CLSFLOWER, &cls_flow,
+       return nft_setup_cb_call(TC_SETUP_CLSFLOWER, cls_flow,
                                 &basechain->flow_block.cb_list);
 }
 
+static int nft_flow_offload_rule(const struct nft_chain *chain,
+                                struct nft_rule *rule,
+                                struct nft_flow_rule *flow,
+                                enum flow_cls_command command)
+{
+       struct flow_cls_offload cls_flow;
+
+       return nft_flow_offload_cmd(chain, rule, flow, command, &cls_flow);
+}
+
+int nft_flow_rule_stats(const struct nft_chain *chain,
+                       const struct nft_rule *rule)
+{
+       struct flow_cls_offload cls_flow = {};
+       struct nft_expr *expr, *next;
+       int err;
+
+       err = nft_flow_offload_cmd(chain, rule, NULL, FLOW_CLS_STATS,
+                                  &cls_flow);
+       if (err < 0)
+               return err;
+
+       nft_rule_for_each_expr(expr, next, rule) {
+               if (expr->ops->offload_stats)
+                       expr->ops->offload_stats(expr, &cls_flow.stats);
+       }
+
+       return 0;
+}
+
 static int nft_flow_offload_bind(struct flow_block_offload *bo,
                                 struct nft_base_chain *basechain)
 {

diff --git a/net/netfilter/nft_counter.c b/net/netfilter/nft_counter.c
index 85ed461ec24e851fdb7a9914804c68a5d4ce65fb..8edd3b3c173d7dc647e041f436d2e3fa657815c7 100644 (file)
--- a/net/netfilter/nft_counter.c
+++ b/net/netfilter/nft_counter.c
@@ -13,6 +13,7 @@
 #include <linux/netfilter.h>
 #include <linux/netfilter/nf_tables.h>
 #include <net/netfilter/nf_tables.h>
+#include <net/netfilter/nf_tables_offload.h>
 
 struct nft_counter {
        s64             bytes;
@@ -248,6 +249,32 @@ static int nft_counter_clone(struct nft_expr *dst, const struct nft_expr *src)
        return 0;
 }
 
+static int nft_counter_offload(struct nft_offload_ctx *ctx,
+                              struct nft_flow_rule *flow,
+                              const struct nft_expr *expr)
+{
+       /* No specific offload action is needed, but report success. */
+       return 0;
+}
+
+static void nft_counter_offload_stats(struct nft_expr *expr,
+                                     const struct flow_stats *stats)
+{
+       struct nft_counter_percpu_priv *priv = nft_expr_priv(expr);
+       struct nft_counter *this_cpu;
+       seqcount_t *myseq;
+
+       preempt_disable();
+       this_cpu = this_cpu_ptr(priv->counter);
+       myseq = this_cpu_ptr(&nft_counter_seq);
+
+       write_seqcount_begin(myseq);
+       this_cpu->packets += stats->pkts;
+       this_cpu->bytes += stats->bytes;
+       write_seqcount_end(myseq);
+       preempt_enable();
+}
+
 static struct nft_expr_type nft_counter_type;
 static const struct nft_expr_ops nft_counter_ops = {
        .type           = &nft_counter_type,
@@ -258,6 +285,8 @@ static const struct nft_expr_ops nft_counter_ops = {
        .destroy_clone  = nft_counter_destroy,
        .dump           = nft_counter_dump,
        .clone          = nft_counter_clone,
+       .offload        = nft_counter_offload,
+       .offload_stats  = nft_counter_offload_stats,
 };
 
 static struct nft_expr_type nft_counter_type __read_mostly = {