netfilter: nf_tables: extend tracing infrastructure

nft monitor mode can then decode and display this trace data.

Parts of LL/Network/Transport headers are provided as separate
attributes.

Otherwise, printing IP address data becomes virtually impossible
for userspace since in the case of the netdev family we really don't
want userspace to have to know all the possible link layer types
and/or sizes just to display/print an ip address.

We also don't want userspace to have to follow ipv6 header chains
to get the s/dport info, the kernel already did this work for us.

To avoid bloating nft_do_chain all data required for tracing is
encapsulated in nft_traceinfo.

The structure is initialized unconditionally(!) for each nft_do_chain
invocation.

This unconditionall call will be moved under a static key in a
followup patch.

With lots of help from Patrick McHardy and Pablo Neira.

Signed-off-by: Florian Westphal <fw@strlen.de>
Acked-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

5 files changed, 312 insertions, 19 deletions

diff --git a/net/netfilter/Makefile b/net/netfilter/Makefile
index 7638c36b498c..22934846b5d1 100644
--- a/net/netfilter/Makefile
+++ b/net/netfilter/Makefile
@@ -67,7 +67,7 @@ obj-$(CONFIG_NF_NAT_TFTP) += nf_nat_tftp.o
 obj-$(CONFIG_NETFILTER_SYNPROXY) += nf_synproxy_core.o
 
 # nf_tables
-nf_tables-objs += nf_tables_core.o nf_tables_api.o
+nf_tables-objs += nf_tables_core.o nf_tables_api.o nf_tables_trace.o
 nf_tables-objs += nft_immediate.o nft_cmp.o nft_lookup.o nft_dynset.o
 nf_tables-objs += nft_bitwise.o nft_byteorder.o nft_payload.o
 
diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 93cc4737018f..c4969a0d54ba 100644
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -4446,22 +4446,22 @@ static void nft_verdict_uninit(const struct nft_data *data)
         }
 }
 
-static int nft_verdict_dump(struct sk_buff *skb, const struct nft_data *data)
+int nft_verdict_dump(struct sk_buff *skb, int type, const struct nft_verdict *v)
 {
         struct nlattr *nest;
 
-        nest = nla_nest_start(skb, NFTA_DATA_VERDICT);
+        nest = nla_nest_start(skb, type);
         if (!nest)
                 goto nla_put_failure;
 
-        if (nla_put_be32(skb, NFTA_VERDICT_CODE, htonl(data->verdict.code)))
+        if (nla_put_be32(skb, NFTA_VERDICT_CODE, htonl(v->code)))
                 goto nla_put_failure;
 
-        switch (data->verdict.code) {
+        switch (v->code) {
         case NFT_JUMP:
         case NFT_GOTO:
                 if (nla_put_string(skb, NFTA_VERDICT_CHAIN,
-                                   data->verdict.chain->name))
+                                   v->chain->name))
                         goto nla_put_failure;
         }
         nla_nest_end(skb, nest);
@@ -4572,7 +4572,7 @@ int nft_data_dump(struct sk_buff *skb, int attr, const struct nft_data *data,
                 err = nft_value_dump(skb, data, len);
                 break;
         case NFT_DATA_VERDICT:
-                err = nft_verdict_dump(skb, data);
+                err = nft_verdict_dump(skb, NFTA_DATA_VERDICT, &data->verdict);
                 break;
         default:
                 err = -EINVAL;
diff --git a/net/netfilter/nf_tables_core.c b/net/netfilter/nf_tables_core.c
index f3695a497408..2395de7c8ab2 100644
--- a/net/netfilter/nf_tables_core.c
+++ b/net/netfilter/nf_tables_core.c
@@ -44,22 +44,36 @@ static struct nf_loginfo trace_loginfo = {
         },
 };
 
-static void __nft_trace_packet(const struct nft_pktinfo *pkt,
-                               const struct nft_chain *chain,
-                               int rulenum, enum nft_trace type)
+static noinline void __nft_trace_packet(struct nft_traceinfo *info,
+                                        const struct nft_chain *chain,
+                                        int rulenum, enum nft_trace type)
 {
+        const struct nft_pktinfo *pkt = info->pkt;
+
+        if (!pkt->skb->nf_trace)
+                return;
+
+        info->chain = chain;
+        info->type = type;
+
+        nft_trace_notify(info);
+
         nf_log_trace(pkt->net, pkt->pf, pkt->hook, pkt->skb, pkt->in,
                      pkt->out, &trace_loginfo, "TRACE: %s:%s:%s:%u ",
                      chain->table->name, chain->name, comments[type],
                      rulenum);
 }
 
-static inline void nft_trace_packet(const struct nft_pktinfo *pkt,
+static inline void nft_trace_packet(struct nft_traceinfo *info,
                                     const struct nft_chain *chain,
-                                    int rulenum, enum nft_trace type)
+                                    const struct nft_rule *rule,
+                                    int rulenum,
+                                    enum nft_trace_types type)
 {
-        if (unlikely(pkt->skb->nf_trace))
-                __nft_trace_packet(pkt, chain, rulenum, type);
+        if (unlikely(info->trace)) {
+                info->rule = rule;
+                __nft_trace_packet(info, chain, rulenum, type);
+        }
 }
 
 static void nft_cmp_fast_eval(const struct nft_expr *expr,
@@ -121,7 +135,9 @@ nft_do_chain(struct nft_pktinfo *pkt, void *priv)
         struct nft_stats *stats;
         int rulenum;
         unsigned int gencursor = nft_genmask_cur(net);
+        struct nft_traceinfo info;
 
+        nft_trace_init(&info, pkt, &regs.verdict, basechain);
 do_chain:
         rulenum = 0;
         rule = list_entry(&chain->rules, struct nft_rule, list);
@@ -151,7 +167,8 @@ next_rule:
                         regs.verdict.code = NFT_CONTINUE;
                         continue;
                 case NFT_CONTINUE:
-                        nft_trace_packet(pkt, chain, rulenum, NFT_TRACE_RULE);
+                        nft_trace_packet(&info, chain, rule,
+                                         rulenum, NFT_TRACETYPE_RULE);
                         continue;
                 }
                 break;
@@ -161,7 +178,8 @@ next_rule:
         case NF_ACCEPT:
         case NF_DROP:
         case NF_QUEUE:
-                nft_trace_packet(pkt, chain, rulenum, NFT_TRACE_RULE);
+                nft_trace_packet(&info, chain, rule,
+                                 rulenum, NFT_TRACETYPE_RULE);
                 return regs.verdict.code;
         }
 
@@ -174,7 +192,8 @@ next_rule:
                 stackptr++;
                 /* fall through */
         case NFT_GOTO:
-                nft_trace_packet(pkt, chain, rulenum, NFT_TRACE_RULE);
+                nft_trace_packet(&info, chain, rule,
+                                 rulenum, NFT_TRACETYPE_RULE);
 
                 chain = regs.verdict.chain;
                 goto do_chain;
@@ -182,7 +201,8 @@ next_rule:
                 rulenum++;
                 /* fall through */
         case NFT_RETURN:
-                nft_trace_packet(pkt, chain, rulenum, NFT_TRACE_RETURN);
+                nft_trace_packet(&info, chain, rule,
+                                 rulenum, NFT_TRACETYPE_RETURN);
                 break;
         default:
                 WARN_ON(1);
@@ -196,7 +216,8 @@ next_rule:
                 goto next_rule;
         }
 
-        nft_trace_packet(pkt, basechain, -1, NFT_TRACE_POLICY);
+        nft_trace_packet(&info, basechain, NULL, -1,
+                         NFT_TRACETYPE_POLICY);
 
         rcu_read_lock_bh();
         stats = this_cpu_ptr(rcu_dereference(nft_base_chain(basechain)->stats));
diff --git a/net/netfilter/nf_tables_trace.c b/net/netfilter/nf_tables_trace.c
new file mode 100644
index 000000000000..36fd7ad6729a
--- /dev/null
+++ b/net/netfilter/nf_tables_trace.c
@@ -0,0 +1,271 @@
+/*
+ * (C) 2015 Red Hat GmbH
+ * Author: Florian Westphal <fw@strlen.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/hash.h>
+#include <linux/jhash.h>
+#include <linux/if_vlan.h>
+#include <linux/init.h>
+#include <linux/skbuff.h>
+#include <linux/netlink.h>
+#include <linux/netfilter.h>
+#include <linux/netfilter/nfnetlink.h>
+#include <linux/netfilter/nf_tables.h>
+#include <net/netfilter/nf_tables_core.h>
+#include <net/netfilter/nf_tables.h>
+
+#define NFT_TRACETYPE_LL_HSIZE          20
+#define NFT_TRACETYPE_NETWORK_HSIZE     40
+#define NFT_TRACETYPE_TRANSPORT_HSIZE   20
+
+static int trace_fill_id(struct sk_buff *nlskb, struct sk_buff *skb)
+{
+        __be32 id;
+
+        /* using skb address as ID results in a limited number of
+         * values (and quick reuse).
+         *
+         * So we attempt to use as many skb members that will not
+         * change while skb is with netfilter.
+         */
+        id = (__be32)jhash_2words(hash32_ptr(skb), skb_get_hash(skb),
+                                  skb->skb_iif);
+
+        return nla_put_be32(nlskb, NFTA_TRACE_ID, id);
+}
+
+static int trace_fill_header(struct sk_buff *nlskb, u16 type,
+                             const struct sk_buff *skb,
+                             int off, unsigned int len)
+{
+        struct nlattr *nla;
+
+        if (len == 0)
+                return 0;
+
+        nla = nla_reserve(nlskb, type, len);
+        if (!nla || skb_copy_bits(skb, off, nla_data(nla), len))
+                return -1;
+
+        return 0;
+}
+
+static int nf_trace_fill_ll_header(struct sk_buff *nlskb,
+                                   const struct sk_buff *skb)
+{
+        struct vlan_ethhdr veth;
+        int off;
+
+        BUILD_BUG_ON(sizeof(veth) > NFT_TRACETYPE_LL_HSIZE);
+
+        off = skb_mac_header(skb) - skb->data;
+        if (off != -ETH_HLEN)
+                return -1;
+
+        if (skb_copy_bits(skb, off, &veth, ETH_HLEN))
+                return -1;
+
+        veth.h_vlan_proto = skb->vlan_proto;
+        veth.h_vlan_TCI = htons(skb_vlan_tag_get(skb));
+        veth.h_vlan_encapsulated_proto = skb->protocol;
+
+        return nla_put(nlskb, NFTA_TRACE_LL_HEADER, sizeof(veth), &veth);
+}
+
+static int nf_trace_fill_dev_info(struct sk_buff *nlskb,
+                                  const struct net_device *indev,
+                                  const struct net_device *outdev)
+{
+        if (indev) {
+                if (nla_put_be32(nlskb, NFTA_TRACE_IIF,
+                                 htonl(indev->ifindex)))
+                        return -1;
+
+                if (nla_put_be16(nlskb, NFTA_TRACE_IIFTYPE,
+                                 htons(indev->type)))
+                        return -1;
+        }
+
+        if (outdev) {
+                if (nla_put_be32(nlskb, NFTA_TRACE_OIF,
+                                 htonl(outdev->ifindex)))
+                        return -1;
+
+                if (nla_put_be16(nlskb, NFTA_TRACE_OIFTYPE,
+                                 htons(outdev->type)))
+                        return -1;
+        }
+
+        return 0;
+}
+
+static int nf_trace_fill_pkt_info(struct sk_buff *nlskb,
+                                  const struct nft_pktinfo *pkt)
+{
+        const struct sk_buff *skb = pkt->skb;
+        unsigned int len = min_t(unsigned int,
+                                 pkt->xt.thoff - skb_network_offset(skb),
+                                 NFT_TRACETYPE_NETWORK_HSIZE);
+        int off = skb_network_offset(skb);
+
+        if (trace_fill_header(nlskb, NFTA_TRACE_NETWORK_HEADER, skb, off, len))
+                return -1;
+
+        len = min_t(unsigned int, skb->len - pkt->xt.thoff,
+                    NFT_TRACETYPE_TRANSPORT_HSIZE);
+
+        if (trace_fill_header(nlskb, NFTA_TRACE_TRANSPORT_HEADER, skb,
+                              pkt->xt.thoff, len))
+                return -1;
+
+        if (!skb_mac_header_was_set(skb))
+                return 0;
+
+        if (skb_vlan_tag_get(skb))
+                return nf_trace_fill_ll_header(nlskb, skb);
+
+        off = skb_mac_header(skb) - skb->data;
+        len = min_t(unsigned int, -off, NFT_TRACETYPE_LL_HSIZE);
+        return trace_fill_header(nlskb, NFTA_TRACE_LL_HEADER,
+                                 skb, off, len);
+}
+
+static int nf_trace_fill_rule_info(struct sk_buff *nlskb,
+                                   const struct nft_traceinfo *info)
+{
+        if (!info->rule)
+                return 0;
+
+        /* a continue verdict with ->type == RETURN means that this is
+         * an implicit return (end of chain reached).
+         *
+         * Since no rule matched, the ->rule pointer is invalid.
+         */
+        if (info->type == NFT_TRACETYPE_RETURN &&
+            info->verdict->code == NFT_CONTINUE)
+                return 0;
+
+        return nla_put_be64(nlskb, NFTA_TRACE_RULE_HANDLE,
+                            cpu_to_be64(info->rule->handle));
+}
+
+void nft_trace_notify(struct nft_traceinfo *info)
+{
+        const struct nft_pktinfo *pkt = info->pkt;
+        struct nfgenmsg *nfmsg;
+        struct nlmsghdr *nlh;
+        struct sk_buff *skb;
+        unsigned int size;
+        int event = (NFNL_SUBSYS_NFTABLES << 8) | NFT_MSG_TRACE;
+
+        if (!nfnetlink_has_listeners(pkt->net, NFNLGRP_NFTRACE))
+                return;
+
+        size = nlmsg_total_size(sizeof(struct nfgenmsg)) +
+                nla_total_size(NFT_TABLE_MAXNAMELEN) +
+                nla_total_size(NFT_CHAIN_MAXNAMELEN) +
+                nla_total_size(sizeof(__be64)) +        /* rule handle */
+                nla_total_size(sizeof(__be32)) +        /* trace type */
+                nla_total_size(0) +                     /* VERDICT, nested */
+                        nla_total_size(sizeof(u32)) +   /* verdict code */
+                        nla_total_size(NFT_CHAIN_MAXNAMELEN) + /* jump target */
+                nla_total_size(sizeof(u32)) +           /* id */
+                nla_total_size(NFT_TRACETYPE_LL_HSIZE) +
+                nla_total_size(NFT_TRACETYPE_NETWORK_HSIZE) +
+                nla_total_size(NFT_TRACETYPE_TRANSPORT_HSIZE) +
+                nla_total_size(sizeof(u32)) +           /* iif */
+                nla_total_size(sizeof(__be16)) +        /* iiftype */
+                nla_total_size(sizeof(u32)) +           /* oif */
+                nla_total_size(sizeof(__be16)) +        /* oiftype */
+                nla_total_size(sizeof(u32)) +           /* mark */
+                nla_total_size(sizeof(u32)) +           /* nfproto */
+                nla_total_size(sizeof(u32));            /* policy */
+
+        skb = nlmsg_new(size, GFP_ATOMIC);
+        if (!skb)
+                return;
+
+        nlh = nlmsg_put(skb, 0, 0, event, sizeof(struct nfgenmsg), 0);
+        if (!nlh)
+                goto nla_put_failure;
+
+        nfmsg = nlmsg_data(nlh);
+        nfmsg->nfgen_family     = info->basechain->type->family;
+        nfmsg->version          = NFNETLINK_V0;
+        nfmsg->res_id           = 0;
+
+        if (nla_put_be32(skb, NFTA_TRACE_NFPROTO, htonl(pkt->pf)))
+                goto nla_put_failure;
+
+        if (nla_put_be32(skb, NFTA_TRACE_TYPE, htonl(info->type)))
+                goto nla_put_failure;
+
+        if (trace_fill_id(skb, pkt->skb))
+                goto nla_put_failure;
+
+        if (info->chain) {
+                if (nla_put_string(skb, NFTA_TRACE_CHAIN,
+                                   info->chain->name))
+                        goto nla_put_failure;
+                if (nla_put_string(skb, NFTA_TRACE_TABLE,
+                                   info->chain->table->name))
+                        goto nla_put_failure;
+        }
+
+        if (nf_trace_fill_rule_info(skb, info))
+                goto nla_put_failure;
+
+        switch (info->type) {
+        case NFT_TRACETYPE_UNSPEC:
+        case __NFT_TRACETYPE_MAX:
+                break;
+        case NFT_TRACETYPE_RETURN:
+        case NFT_TRACETYPE_RULE:
+                if (nft_verdict_dump(skb, NFTA_TRACE_VERDICT, info->verdict))
+                        goto nla_put_failure;
+                break;
+        case NFT_TRACETYPE_POLICY:
+                if (nla_put_be32(skb, NFTA_TRACE_POLICY,
+                                 info->basechain->policy))
+                        goto nla_put_failure;
+                break;
+        }
+
+        if (pkt->skb->mark &&
+            nla_put_be32(skb, NFTA_TRACE_MARK, htonl(pkt->skb->mark)))
+                goto nla_put_failure;
+
+        if (!info->packet_dumped) {
+                if (nf_trace_fill_dev_info(skb, pkt->in, pkt->out))
+                        goto nla_put_failure;
+
+                if (nf_trace_fill_pkt_info(skb, pkt))
+                        goto nla_put_failure;
+                info->packet_dumped = true;
+        }
+
+        nlmsg_end(skb, nlh);
+        nfnetlink_send(skb, pkt->net, 0, NFNLGRP_NFTRACE, 0, GFP_ATOMIC);
+        return;
+
+ nla_put_failure:
+        WARN_ON_ONCE(1);
+        kfree_skb(skb);
+}
+
+void nft_trace_init(struct nft_traceinfo *info, const struct nft_pktinfo *pkt,
+                    const struct nft_verdict *verdict,
+                    const struct nft_chain *chain)
+{
+        info->basechain = nft_base_chain(chain);
+        info->trace = true;
+        info->packet_dumped = false;
+        info->pkt = pkt;
+        info->verdict = verdict;
+}
diff --git a/net/netfilter/nfnetlink.c b/net/netfilter/nfnetlink.c
index 46453ab318db..28591fa94ba5 100644
--- a/net/netfilter/nfnetlink.c
+++ b/net/netfilter/nfnetlink.c
@@ -49,6 +49,7 @@ static const int nfnl_group2type[NFNLGRP_MAX+1] = {
         [NFNLGRP_CONNTRACK_EXP_DESTROY] = NFNL_SUBSYS_CTNETLINK_EXP,
         [NFNLGRP_NFTABLES]              = NFNL_SUBSYS_NFTABLES,
         [NFNLGRP_ACCT_QUOTA]            = NFNL_SUBSYS_ACCT,
+        [NFNLGRP_NFTRACE]               = NFNL_SUBSYS_NFTABLES,
 };
 
 void nfnl_lock(__u8 subsys_id)