Commit 87e389b4 authored Jun 04, 2019 by Florian Westphal Committed by Pablo Neira Ayuso Jun 17, 2019

netfilter: conntrack: small conntrack lookup optimization



____nf_conntrack_find() performs checks on the conntrack objects in
this order:

1. if (nf_ct_is_expired(ct))

This fetches ct->timeout, in third cache line.

The hnnode that is used to store the list pointers resides in the first
(origin) or second (reply tuple) cache lines.

This test rarely passes, but its necessary to reap obsolete entries.

2. if (nf_ct_is_dying(ct))

This fetches ct->status, also in third cache line.

The test is useless, and can be removed:
  Consider:
     cpu0                                           cpu1
    ct = ____nf_conntrack_find()
    atomic_inc_not_zero(ct) -> ok
    nf_ct_key_equal -> ok
    is_dying -> DYING bit not set, ok
                                                    set_bit(ct, DYING);
						    ... unhash ... etc.
    return ct
    -> returning a ct with dying bit set, despite
    having a test for it.

This (unlikely) case is fine - refcount prevents ct from getting free'd.

3. if (nf_ct_key_equal(h, tuple, zone, net))

nf_ct_key_equal checks in following order:

1. Tuple equal (first or second cacheline)
2. Zone equal (third cacheline)
3. confirmed bit set (->status, third cacheline)
4. net namespace match (third cacheline).

Swapping "timeout" and "cpu" places timeout in the first cacheline.
This has two advantages:

1. For a conntrack that won't even match the original tuple,
   we will now only fetch the first and maybe the second cacheline
   instead of always accessing the 3rd one as well.

2.  in case of TCP ct->timeout changes frequently because we
    reduce/increase it when there are packets outstanding in the network.

The first cacheline contains both the reference count and the ct spinlock,
i.e. moving timeout there avoids writes to 3rd cacheline.

The restart sequence in __nf_conntrack_find() is removed, if we found a
candidate, but then fail to increment the refcount or discover the tuple
has changed (object recycling), just pretend we did not find an entry.

A second lookup won't find anything until another CPU adds a new conntrack
with identical tuple into the hash table, which is very unlikely.

We have the confirmation-time checks (when we hold hash lock) that deal
with identical entries and even perform clash resolution in some cases.

Signed-off-by: Florian Westphal <fw@strlen.de>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

parent 857b4602

include/net/netfilter/nf_conntrack.h

+3 −4

Original line number	Diff line number	Diff line
		@@ -70,7 +70,8 @@ struct nf_conn {
		struct nf_conntrack ct_general;

		spinlock_t lock;
		u16 cpu;
		/* jiffies32 when this ct is considered dead */
		u32 timeout;

		#ifdef CONFIG_NF_CONNTRACK_ZONES
		struct nf_conntrack_zone zone;
		@@ -82,9 +83,7 @@ struct nf_conn {
		/* Have we seen traffic both ways yet? (bitset) */
		unsigned long status;

		/* jiffies32 when this ct is considered dead */
		u32 timeout;

		u16 cpu;
		possible_net_t ct_net;

		#if IS_ENABLED(CONFIG_NF_NAT)

net/netfilter/nf_conntrack_core.c

+13 −12

Original line number	Diff line number	Diff line
		@@ -752,9 +752,6 @@ ____nf_conntrack_find(struct net net, const struct nf_conntrack_zone zone,
		continue;
		}

		if (nf_ct_is_dying(ct))
		continue;

		if (nf_ct_key_equal(h, tuple, zone, net))
		return h;
		}
		@@ -780,20 +777,24 @@ __nf_conntrack_find_get(struct net net, const struct nf_conntrack_zone zone,
		struct nf_conn *ct;

		rcu_read_lock();
		begin:

		h = ____nf_conntrack_find(net, zone, tuple, hash);
		if (h) {
		/* We have a candidate that matches the tuple we're interested
		* in, try to obtain a reference and re-check tuple
		*/
		ct = nf_ct_tuplehash_to_ctrack(h);
		if (unlikely(nf_ct_is_dying(ct) \|\|
		!atomic_inc_not_zero(&ct->ct_general.use)))
		h = NULL;
		else {
		if (unlikely(!nf_ct_key_equal(h, tuple, zone, net))) {
		if (likely(atomic_inc_not_zero(&ct->ct_general.use))) {
		if (likely(nf_ct_key_equal(h, tuple, zone, net)))
		goto found;

		/* TYPESAFE_BY_RCU recycled the candidate */
		nf_ct_put(ct);
		goto begin;
		}
		}

		h = NULL;
		}
		found:
		rcu_read_unlock();

		return h;