Netfilter/IPVS updates for net-next
Subsystems (4)
Pablo Neira Ayuso
maintainercover Netfilter/IPVS updates for net-next
Hi David,
The following patchset contains Netfilter/IPVS updates for net-next, they are:
1) Count pre-established connections as active in "least connection" schedulers such that pre-established connections to avoid overloading backend servers on peak demands, from Michal Kubecek via Simon Horman.
2) Address a race condition when resizing the conntrack table by caching the bucket size when fulling iterating over the hashtable in these three possible scenarios: 1) dump via /proc/net/nf_conntrack,
2) unlinking userspace helper and 3) unlinking custom conntrack timeout. From Liping Zhang.
3) Revisit early_drop() path to perform lockless traversal on conntrack eviction under stress, use del_timer() as synchronization point to avoid two CPUs evicting the same entry, from Florian Westphal.
4) Move NAT hlist_head to nf_conn object, this simplifies the existing NAT extension and it doesn't increase size since recent patches to align nf_conn, from Florian.
5) Use rhashtable for the by-source NAT hashtable, also from Florian.
6) Don't allow --physdev-is-out from OUTPUT chain, just like --physdev-out is not either, from Hangbin Liu.
7) Automagically set on nf_conntrack counters if the user tries to match ct bytes/packets from nftables, from Liping Zhang.
8) Remove possible_net_t fields in nf_tables set objects since we just simply pass the net pointer to the backend set type implementations.
9) Fix possible off-by-one in h323, from Toby DiPasquale.
10) early_drop() may be called from ctnetlink patch, so we must hold rcu read size lock from them too, this amends Florian's patch #3 coming in this batch, from Liping Zhang.
11) Use binary search to validate jump offset in x_tables, this addresses the O(n!) validation that was introduced recently resolve security issues with unpriviledge namespaces, from Florian.
12) Fix reference leak to connlabel in error path of nft_ct, from Zhang.
13) Three updates for nft_log: Fix log prefix leak in error path. Bail out on loglevel larger than debug in nft_log and set on the new NF_LOG_F_COPY_LEN flag when snaplen is specified. Again from Zhang.
14) Allow to filter rule dumps in nf_tables based on table and chain names.
15) Simplify connlabel to always use 128 bits to store labels and get rid of unused function in xt_connlabel, from Florian.
16) Replace set_expect_timeout() by mod_timer() from the h323 conntrack helper, by Gao Feng.
17) Put back x_tables module reference in nft_compat on error, from Liping Zhang.
18) Add a reference count to the x_tables extensions cache in nft_compat, so we can remove them when unused and avoid a crash if the extensions are rmmod, again from Zhang.
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next.git
Thanks!
----------------------------------------------------------------
The following changes since commit a90a6e55f34f28190e4dc2a6a3660ef157827a8f:
Merge tag 'mac80211-next-for-davem-2016-07-06' of git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211-next (2016-07-06 22:32:15 -0700)
are available in the git repository at:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next.git HEAD
for you to fetch changes up to 4b512e1c1f8de6b9ceb796ecef8658e0a083cab7:
netfilter: nft_compat: fix crash when related match/target module is removed (2016-07-23 12:25:00 +0200)
----------------------------------------------------------------
Florian Westphal (7):
netfilter: conntrack: simplify early_drop
netfilter: move nat hlist_head to nf_conn
netfilter: nat: convert nat bysrc hash to rhashtable
netfilter: constify arg to is_dying/confirmed
netfilter: x_tables: speed up jump target validation
netfilter: conntrack: support a fixed size of 128 distinct labels
netfilter: connlabels: move set helper to xt_connlabel
Gao Feng (2):
netfilter: Add helper array register/unregister functions
netfilter: h323: Use mod_timer instead of set_expect_timeout
Hangbin Liu (1):
netfilter: physdev: physdev-is-out should not work with OUTPUT chain
Liping Zhang (11):
netfilter: conntrack: fix race between nf_conntrack proc read and hash resize
netfilter: cttimeout: unlink timeout obj again when hash resize happen
netfilter: nf_ct_helper: unlink helper again when hash resize happen
netfilter: nft_ct: make byte/packet expr more friendly
netfilter: conntrack: protect early_drop by rcu read lock
netfilter: nft_ct: fix unpaired nf_connlabels_get/put call
netfilter: nft_log: fix possible memory leak if log expr init fail
netfilter: nft_log: check the validity of log level
netfilter: nft_log: fix snaplen does not truncate packets
netfilter: nft_compat: put back match/target module if init fail
netfilter: nft_compat: fix crash when related match/target module is removed
Michal Kubecek (1):
ipvs: count pre-established TCP states as active
Pablo Neira Ayuso (3):
netfilter: nf_tables: get rid of possible_net_t from set and basechain Merge tag 'ipvs-for-v4.8' of https://git.kernel.org/.../horms/ipvs-next
netfilter: nf_tables: allow to filter out rules by table and chain
Toby DiPasquale (1):
netfilter: nf_conntrack_h323: fix off-by-one in DecodeQ931
include/linux/netfilter/x_tables.h | 4 + include/net/netfilter/nf_conntrack.h | 9 +- include/net/netfilter/nf_conntrack_core.h | 2 + include/net/netfilter/nf_conntrack_extend.h | 3 - include/net/netfilter/nf_conntrack_helper.h | 15 +++ include/net/netfilter/nf_conntrack_labels.h | 18 +-- include/net/netfilter/nf_nat.h | 3 +- include/net/netfilter/nf_tables.h | 21 +-- net/ipv4/netfilter/arp_tables.c | 47 ++++--- net/ipv4/netfilter/ip_tables.c | 45 ++++--- .../netfilter/nf_conntrack_l3proto_ipv4_compat.c | 14 +- net/ipv6/netfilter/ip6_tables.c | 45 ++++--- net/netfilter/ipvs/ip_vs_proto_tcp.c | 25 +++- net/netfilter/nf_conntrack_core.c | 115 +++++++++------- net/netfilter/nf_conntrack_extend.c | 15 +-- net/netfilter/nf_conntrack_ftp.c | 58 +++----- net/netfilter/nf_conntrack_h323_asn1.c | 3 +- net/netfilter/nf_conntrack_h323_main.c | 15 +-- net/netfilter/nf_conntrack_helper.c | 76 ++++++++++- net/netfilter/nf_conntrack_irc.c | 36 ++--- net/netfilter/nf_conntrack_labels.c | 28 +--- net/netfilter/nf_conntrack_netlink.c | 10 +- net/netfilter/nf_conntrack_sane.c | 57 +++----- net/netfilter/nf_conntrack_sip.c | 75 ++++------- net/netfilter/nf_conntrack_standalone.c | 14 +- net/netfilter/nf_conntrack_tftp.c | 48 +++---- net/netfilter/nf_nat_core.c | 149 ++++++++++----------- net/netfilter/nf_tables_api.c | 48 ++++++- net/netfilter/nfnetlink_cttimeout.c | 20 ++- net/netfilter/nft_compat.c | 75 ++++++----- net/netfilter/nft_ct.c | 41 +++--- net/netfilter/nft_hash.c | 20 +-- net/netfilter/nft_log.c | 34 +++-- net/netfilter/nft_lookup.c | 2 +- net/netfilter/nft_rbtree.c | 26 ++-- net/netfilter/x_tables.c | 50 +++++++ net/netfilter/xt_connlabel.c | 29 ++-- net/netfilter/xt_physdev.c | 8 +- net/openvswitch/conntrack.c | 4 +- 39 files changed, 718 insertions(+), 589 deletions(-)
Pablo Neira Ayuso
maintainerPATCH 1/25 ipvs: count pre-established TCP states as active
From: Michal Kubecek <[email protected]>
Some users observed that "least connection" distribution algorithm doesn't handle well bursts of TCP connections from reconnecting clients after a node or network failure.
This is because the algorithm counts active connection as worth 256 inactive ones where for TCP, "active" only means TCP connections in ESTABLISHED state. In case of a connection burst, new connections are handled before previous ones have finished the three way handshaking so that all are still counted as "inactive", i.e. cheap ones. The become "active" quickly but at that time, all of them are already assigned to one real server (or few), resulting in highly unbalanced distribution.
Address this by counting the "pre-established" states as "active".
--- net/netfilter/ipvs/ip_vs_proto_tcp.c | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-)
net/netfilter/ipvs/ip_vs_proto_tcp.c +23 -2
@@ -395,6 +395,20 @@ static const char *const tcp_state_name_table[IP_VS_TCP_S_LAST+1] = { [IP_VS_TCP_S_LAST] = "BUG!", }; +static const bool tcp_state_active_table[IP_VS_TCP_S_LAST ] = { + [IP_VS_TCP_S_NONE ] = false, + [IP_VS_TCP_S_ESTABLISHED ] = true, + [IP_VS_TCP_S_SYN_SENT ] = true, + [IP_VS_TCP_S_SYN_RECV ] = true, + [IP_VS_TCP_S_FIN_WAIT ] = false, + [IP_VS_TCP_S_TIME_WAIT ] = false, + [IP_VS_TCP_S_CLOSE ] = false, + [IP_VS_TCP_S_CLOSE_WAIT ] = false, + [IP_VS_TCP_S_LAST_ACK ] = false, + [IP_VS_TCP_S_LISTEN ] = false, + [IP_VS_TCP_S_SYNACK ] = true, +}; +#define sNO IP_VS_TCP_S_NONE#define sES IP_VS_TCP_S_ESTABLISHED#define sSS IP_VS_TCP_S_SYN_SENT
@@ -418,6 +432,13 @@ static const char * tcp_state_name(int state)return tcp_state_name_table[state] ? tcp_state_name_table[state] :"?" ; } +static bool tcp_state_active (int state) +{ +if (state >=IP_VS_TCP_S_LAST ) +return false; +return tcp_state_active_table[state]; +} +static struct tcp_states_t tcp_states [] = {/* INPUT */ /* sNO, sES, sSS, sSR, sFW, sTW, sCL, sCW, sLA, sLI, sSA */
@@ -540,12 +561,12 @@ set_tcp_state(struct ip_vs_proto_data *pd, struct ip_vs_conn *cp,if (dest) {if (!(cp->flags &IP_VS_CONN_F_INACTIVE ) && - (new_state !=IP_VS_TCP_S_ESTABLISHED )) { + !tcp_state_active (new_state)) {atomic_dec (&dest->activeconns);atomic_inc (&dest->inactconns); cp->flags |=IP_VS_CONN_F_INACTIVE ; }else if ((cp->flags &IP_VS_CONN_F_INACTIVE ) && - (new_state ==IP_VS_TCP_S_ESTABLISHED )) { +tcp_state_active (new_state)) {atomic_inc (&dest->activeconns);atomic_dec (&dest->inactconns); cp->flags &= ~IP_VS_CONN_F_INACTIVE ;
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 2/25 netfilter: conntrack: fix race between nf_conntrack proc read and hash resize
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
When we do "cat /proc/net/nf_conntrack", and meanwhile resize the conntrack hash table via /sys/module/nf_conntrack/parameters/hashsize, race will happen, because reader can observe a newly allocated hash but the old size (or vice versa). So oops will happen like follows:
BUG: unable to handle kernel NULL pointer dereference at 0000000000000017 IP: [<ffffffffa0418e21>] seq_print_acct+0x11/0x50 [nf_conntrack] Call Trace: [<ffffffffa0412f4e>] ? ct_seq_show+0x14e/0x340 [nf_conntrack] [<ffffffff81261a1c>] seq_read+0x2cc/0x390 [<ffffffff812a8d62>] proc_reg_read+0x42/0x70 [<ffffffff8123bee7>] __vfs_read+0x37/0x130 [<ffffffff81347980>] ? security_file_permission+0xa0/0xc0 [<ffffffff8123cf75>] vfs_read+0x95/0x140 [<ffffffff8123e475>] SyS_read+0x55/0xc0 [<ffffffff817c2572>] entry_SYSCALL_64_fastpath+0x1a/0xa4
It is very easy to reproduce this kernel crash.
1. open one shell and input the following cmds:
while : ; do
echo $RANDOM > /sys/module/nf_conntrack/parameters/hashsize
done
2. open more shells and input the following cmds:
while : ; do
cat /proc/net/nf_conntrack
done
3. just wait a monent, oops will happen soon.
The solution in this patch is based on Florian's Commit 5e3c61f98175 ("netfilter: conntrack: fix lookup race during hash resize"). And add a wrapper function nf_conntrack_get_ht to get hash and hsize suggested by Florian Westphal.
--- include/net/netfilter/nf_conntrack_core.h | 2 ++ net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c | 14 ++++++++++---- net/netfilter/nf_conntrack_core.c | 17 +++++++++++++++++ net/netfilter/nf_conntrack_standalone.c | 14 +++++++++----- 4 files changed, 38 insertions(+), 9 deletions(-)
include/net/netfilter/nf_conntrack_core.h +2 -0
@@ -51,6 +51,8 @@ bool nf_ct_invert_tuple(struct nf_conntrack_tuple *inverse,const struct nf_conntrack_l3proto *l3proto, const struct nf_conntrack_l4proto *l4proto); +void nf_conntrack_get_ht (struct hlist_nulls_head **hash,unsigned int *hsize); +/* Find a connection corresponding to a tuple. */ struct nf_conntrack_tuple_hash * nf_conntrack_find_get(struct net *net,
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4_compat.c +10 -4
@@ -26,6 +26,8 @@struct ct_iter_state {struct seq_net_private p; +struct hlist_nulls_head *hash; +unsigned int htable_size;unsigned int bucket; };
@@ -35,10 +37,10 @@ static struct hlist_nulls_node *ct_get_first(struct seq_file *seq)struct hlist_nulls_node *n;for (st->bucket =0 ; - st->bucket < nf_conntrack_htable_size; + st->bucket < st->htable_size; st->bucket++) { n =rcu_dereference ( -hlist_nulls_first_rcu (&nf_conntrack_hash[st->bucket])); +hlist_nulls_first_rcu (&st->hash[st->bucket]));if (!is_a_nulls (n))return n; }
@@ -53,11 +55,11 @@ static struct hlist_nulls_node *ct_get_next(struct seq_file *seq, head =rcu_dereference (hlist_nulls_next_rcu (head));while (is_a_nulls (head)) {if (likely (get_nulls_value (head) == st->bucket)) { -if (++st->bucket >= nf_conntrack_htable_size) +if (++st->bucket >= st->htable_size)return NULL ; } head =rcu_dereference ( -hlist_nulls_first_rcu (&nf_conntrack_hash[st->bucket])); +hlist_nulls_first_rcu (&st->hash[st->bucket])); }return head; }
@@ -75,7 +77,11 @@ static struct hlist_nulls_node *ct_get_idx(struct seq_file *seq, loff_t pos)static void *ct_seq_start (struct seq_file *seq,loff_t *pos)__acquires (RCU ) { +struct ct_iter_state *st = seq->private; +rcu_read_lock (); + +nf_conntrack_get_ht (&st->hash, &st->htable_size);return ct_get_idx (seq, *pos); }
net/netfilter/nf_conntrack_core.c +17 -0
@@ -460,6 +460,23 @@ nf_ct_key_equal(struct nf_conntrack_tuple_hash *h,net_eq (net,nf_ct_net (ct)); } +/* must be called with rcu read lock held */ +void nf_conntrack_get_ht (struct hlist_nulls_head **hash,unsigned int *hsize) +{ +struct hlist_nulls_head *hptr; +unsigned int sequence, hsz; + +do { + sequence =read_seqcount_begin (&nf_conntrack_generation); + hsz = nf_conntrack_htable_size; + hptr = nf_conntrack_hash; + }while (read_seqcount_retry (&nf_conntrack_generation, sequence)); + + *hash = hptr; + *hsize = hsz; +} +EXPORT_SYMBOL_GPL (nf_conntrack_get_ht); +/* * Warning : * - Caller must take a reference on returned object
net/netfilter/nf_conntrack_standalone.c +9 -5
@@ -48,6 +48,8 @@ EXPORT_SYMBOL_GPL(print_tuple);struct ct_iter_state {struct seq_net_private p; +struct hlist_nulls_head *hash; +unsigned int htable_size;unsigned int bucket;u_int64_t time_now; };
@@ -58,9 +60,10 @@ static struct hlist_nulls_node *ct_get_first(struct seq_file *seq)struct hlist_nulls_node *n;for (st->bucket =0 ; - st->bucket < nf_conntrack_htable_size; + st->bucket < st->htable_size; st->bucket++) { - n =rcu_dereference (hlist_nulls_first_rcu (&nf_conntrack_hash[st->bucket])); + n =rcu_dereference ( +hlist_nulls_first_rcu (&st->hash[st->bucket]));if (!is_a_nulls (n))return n; }
@@ -75,12 +78,11 @@ static struct hlist_nulls_node *ct_get_next(struct seq_file *seq, head =rcu_dereference (hlist_nulls_next_rcu (head));while (is_a_nulls (head)) {if (likely (get_nulls_value (head) == st->bucket)) { -if (++st->bucket >= nf_conntrack_htable_size) +if (++st->bucket >= st->htable_size)return NULL ; } head =rcu_dereference ( -hlist_nulls_first_rcu ( - &nf_conntrack_hash[st->bucket])); +hlist_nulls_first_rcu (&st->hash[st->bucket])); }return head; }
@@ -102,6 +104,8 @@ static void *ct_seq_start(struct seq_file *seq, loff_t *pos) st->time_now =ktime_get_real_ns ();rcu_read_lock (); + +nf_conntrack_get_ht (&st->hash, &st->htable_size);return ct_get_idx (seq, *pos); }
Signature · 6 lines
2.1.4 -- To unsubscribe from this list: send the line "unsubscribe netfilter-devel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Pablo Neira Ayuso
maintainerPATCH 3/25 netfilter: cttimeout: unlink timeout obj again when hash resize happen
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
Imagine such situation, nf_conntrack_htable_size now is 4096, we are doing ctnl_untimeout, and iterate on 3000# bucket.
Meanwhile, another user try to reduce hash size to 2048, then all nf_conn are removed to the new hashtable. When this hash resize operation finished, we still try to itreate ct begin from 3000# bucket, find nothing to do and just return.
We may miss unlinking some timeout objects. And later we will end up with invalid references to timeout object that are already gone.
So when we find that hash resize happened, try to unlink timeout objects from the 0# bucket again.
--- net/netfilter/nfnetlink_cttimeout.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-)
net/netfilter/nfnetlink_cttimeout.c +14 -6
@@ -303,16 +303,24 @@ static void ctnl_untimeout(struct net *net, struct ctnl_timeout *timeout) {struct nf_conntrack_tuple_hash *h;const struct hlist_nulls_node *nn; +unsigned int last_hsize; +spinlock_t *lock;int i;local_bh_disable (); -for (i =0 ; i < nf_conntrack_htable_size; i++) { -nf_conntrack_lock (&nf_conntrack_locks[i %CONNTRACK_LOCKS ]); -if (i < nf_conntrack_htable_size) { -hlist_nulls_for_each_entry (h, nn, &nf_conntrack_hash[i], hnnode) -untimeout (h, timeout); +restart: + last_hsize = nf_conntrack_htable_size; +for (i =0 ; i < last_hsize; i++) { + lock = &nf_conntrack_locks[i %CONNTRACK_LOCKS ]; +nf_conntrack_lock (lock); +if (last_hsize != nf_conntrack_htable_size) { +spin_unlock (lock); + goto restart; } -spin_unlock (&nf_conntrack_locks[i %CONNTRACK_LOCKS ]); + +hlist_nulls_for_each_entry (h, nn, &nf_conntrack_hash[i], hnnode) +untimeout (h, timeout); +spin_unlock (lock); }local_bh_enable (); }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 4/25 netfilter: nf_ct_helper: unlink helper again when hash resize happen
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
From: Liping Zhang <[email protected]>
Similar to ctnl_untimeout, when hash resize happened, we should try to do unhelp from the 0# bucket again.
--- net/netfilter/nf_conntrack_helper.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)
net/netfilter/nf_conntrack_helper.c +13 -6
@@ -409,6 +409,8 @@ void nf_conntrack_helper_unregister(struct nf_conntrack_helper *me)struct nf_conntrack_expect *exp;const struct hlist_node *next;const struct hlist_nulls_node *nn; +unsigned int last_hsize; +spinlock_t *lock;struct net *net;unsigned int i;
@@ -446,13 +448,18 @@ void nf_conntrack_helper_unregister(struct nf_conntrack_helper *me)rtnl_unlock ();local_bh_disable (); -for (i =0 ; i < nf_conntrack_htable_size; i++) { -nf_conntrack_lock (&nf_conntrack_locks[i %CONNTRACK_LOCKS ]); -if (i < nf_conntrack_htable_size) { -hlist_nulls_for_each_entry (h, nn, &nf_conntrack_hash[i], hnnode) -unhelp (h, me); +restart: + last_hsize = nf_conntrack_htable_size; +for (i =0 ; i < last_hsize; i++) { + lock = &nf_conntrack_locks[i %CONNTRACK_LOCKS ]; +nf_conntrack_lock (lock); +if (last_hsize != nf_conntrack_htable_size) { +spin_unlock (lock); + goto restart; } -spin_unlock (&nf_conntrack_locks[i %CONNTRACK_LOCKS ]); +hlist_nulls_for_each_entry (h, nn, &nf_conntrack_hash[i], hnnode) +unhelp (h, me); +spin_unlock (lock); }local_bh_enable (); }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 5/25 netfilter: conntrack: simplify early_drop
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
We don't need to acquire the bucket lock during early drop, we can use lockless traveral just like ____nf_conntrack_find.
The timer deletion serves as synchronization point, if another cpu attempts to evict same entry, only one will succeed with timer deletion.
--- include/net/netfilter/nf_conntrack.h | 1 + net/netfilter/nf_conntrack_core.c | 95 ++++++++++++++++++------------------ 2 files changed, 48 insertions(+), 48 deletions(-)
include/net/netfilter/nf_conntrack.h +1 -0
@@ -301,6 +301,7 @@ void nf_ct_tmpl_free(struct nf_conn *tmpl);#define NF_CT_STAT_INC (net, count) __this_cpu_inc((net)->ct.stat->count)#define NF_CT_STAT_INC_ATOMIC (net, count) this_cpu_inc((net)->ct.stat->count) +#define NF_CT_STAT_ADD_ATOMIC (net, count, v) this_cpu_add((net)->ct.stat->count, (v))#define MODULE_ALIAS_NFCT_HELPER (helper) \ MODULE_ALIAS("nfct-helper-" helper)
net/netfilter/nf_conntrack_core.c +47 -48
114 lines not on this page · raw message
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 6/25 netfilter: move nat hlist_head to nf_conn
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
The nat extension structure is 32bytes in size on x86_64:
struct nf_conn_nat {
struct hlist_node bysource; /* 0 16 */
struct nf_conn * ct; /* 16 8 */
union nf_conntrack_nat_help help; /* 24 4 */
int masq_index; /* 28 4 */
/* size: 32, cachelines: 1, members: 4 */
/* last cacheline: 32 bytes */
};The hlist is needed to quickly check for possible tuple collisions when installing a new nat binding. Storing this in the extension area has two drawbacks:
1. We need ct backpointer to get the conntrack struct from the extension.
2. When reallocation of extension area occurs we need to fixup the bysource hash head via hlist_replace_rcu.
We can avoid both by placing the hlist_head in nf_conn and place nf_conn in the bysource hash rather than the extenstion.
We can also remove the ->move support; no other extension needs it.
Moving the entire nat extension into nf_conn would be possible as well but then we have to add yet another callback for deletion from the bysource hash table rather than just using nat extension ->destroy hook for this.
nf_conn size doesn't increase due to aligment, followup patch replaces hlist_node with single pointer.
--- include/net/netfilter/nf_conntrack.h | 3 +++ include/net/netfilter/nf_conntrack_extend.h | 3 --- include/net/netfilter/nf_nat.h | 2 -- net/netfilter/nf_conntrack_extend.c | 15 ++----------- net/netfilter/nf_nat_core.c | 33 ++++++----------------------- 5 files changed, 12 insertions(+), 44 deletions(-)
include/net/netfilter/nf_conntrack.h +3 -0
@@ -117,6 +117,9 @@ struct nf_conn {/* Extensions */ struct nf_ct_ext *ext; +#if IS_ENABLED (CONFIG_NF_NAT ) +struct hlist_node nat_bysource; +#endif /* Storage reserved for other modules, must be the last member */ union nf_conntrack_proto proto; };
include/net/netfilter/nf_conntrack_extend.h +0 -3
@@ -99,9 +99,6 @@ void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id,struct nf_ct_ext_type {/* Destroys relationships (can be NULL). */ void (*destroy)(struct nf_conn *ct); -/* Called when realloacted (can be NULL). -Contents has already been moved. */ -void (*move)(void *new,void *old);enum nf_ct_ext_id id;
include/net/netfilter/nf_nat.h +0 -2
@@ -29,8 +29,6 @@ struct nf_conn;/* The structure embedded in the conntrack structure. */ struct nf_conn_nat { -struct hlist_node bysource; -struct nf_conn *ct;union nf_conntrack_nat_help help;#if IS_ENABLED (CONFIG_NF_NAT_MASQUERADE_IPV4 ) || \IS_ENABLED (CONFIG_NF_NAT_MASQUERADE_IPV6 )
net/netfilter/nf_conntrack_extend.c +2 -13
@@ -73,7 +73,7 @@ void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id, size_t var_alloc_len, gfp_t gfp) {struct nf_ct_ext *old, *new; -int i, newlen, newoff; +int newlen, newoff;struct nf_ct_ext_type *t;/* Conntrack must not be confirmed to avoid races on reallocation. */
@@ -99,19 +99,8 @@ void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id,return NULL ;if (new != old) { -for (i =0 ; i <NF_CT_EXT_NUM ; i++) { -if (!__nf_ct_ext_exist (old, i)) -continue ; - -rcu_read_lock (); - t =rcu_dereference (nf_ct_ext_types[i]); -if (t && t->move) - t->move ((void *)new + new->offset[i], - (void *)old + old->offset[i]); -rcu_read_unlock (); - }kfree_rcu (old, rcu); - ct->ext = new; +rcu_assign_pointer (ct->ext, new); } new->offset[id] = newoff;
net/netfilter/nf_nat_core.c +7 -26
@@ -198,11 +198,9 @@ find_appropriate_src(struct net *net, const struct nf_nat_range *range) {unsigned int h =hash_by_src (net, tuple); -const struct nf_conn_nat *nat;const struct nf_conn *ct; -hlist_for_each_entry_rcu (nat, &nf_nat_bysource[h], bysource) { - ct = nat->ct; +hlist_for_each_entry_rcu (ct, &nf_nat_bysource[h], nat_bysource) {if (same_src (ct, tuple) &&net_eq (net,nf_ct_net (ct)) &&nf_ct_zone_equal (ct, zone,IP_CT_DIR_ORIGINAL )) {
@@ -435,8 +433,7 @@ nf_nat_setup_info(struct nf_conn *ct,spin_lock_bh (&nf_nat_lock);/* nf_conntrack_alter_reply might re-allocate extension aera */ nat =nfct_nat (ct); - nat->ct = ct; -hlist_add_head_rcu (&nat->bysource, +hlist_add_head_rcu (&ct->nat_bysource, &nf_nat_bysource[srchash]);spin_unlock_bh (&nf_nat_lock); }
@@ -543,7 +540,7 @@ static int nf_nat_proto_clean(struct nf_conn *ct, void *data)if (nf_nat_proto_remove (ct, data))return 1 ; -if (!nat || !nat->ct) +if (!nat)return 0 ;/* This netns is being destroyed, and conntrack has nat null binding.
@@ -556,9 +553,8 @@ static int nf_nat_proto_clean(struct nf_conn *ct, void *data)return 1 ;spin_lock_bh (&nf_nat_lock); -hlist_del_rcu (&nat->bysource); +hlist_del_rcu (&ct->nat_bysource); ct->status &= ~IPS_NAT_DONE_MASK ; - nat->ct =NULL ;spin_unlock_bh (&nf_nat_lock);add_timer (&ct->timeout);
@@ -688,27 +684,13 @@ static void nf_nat_cleanup_conntrack(struct nf_conn *ct) {struct nf_conn_nat *nat =nf_ct_ext_find (ct,NF_CT_EXT_NAT ); -if (nat ==NULL || nat->ct ==NULL ) +if (!nat)return ; -NF_CT_ASSERT (nat->ct->status &IPS_SRC_NAT_DONE ); - -spin_lock_bh (&nf_nat_lock); -hlist_del_rcu (&nat->bysource); -spin_unlock_bh (&nf_nat_lock); -} - -static void nf_nat_move_storage (void *new,void *old) -{ -struct nf_conn_nat *new_nat = new; -struct nf_conn_nat *old_nat = old; -struct nf_conn *ct = old_nat->ct; - -if (!ct || !(ct->status &IPS_SRC_NAT_DONE )) -return ; +NF_CT_ASSERT (ct->status &IPS_SRC_NAT_DONE );spin_lock_bh (&nf_nat_lock); -hlist_replace_rcu (&old_nat->bysource, &new_nat->bysource); +hlist_del_rcu (&ct->nat_bysource);spin_unlock_bh (&nf_nat_lock); }
@@ -716,7 +698,6 @@ static struct nf_ct_ext_type nat_extend __read_mostly = { .len = sizeof(struct nf_conn_nat), .align = __alignof__(struct nf_conn_nat), .destroy = nf_nat_cleanup_conntrack, - .move = nf_nat_move_storage, .id = NF_CT_EXT_NAT, .flags = NF_CT_EXT_F_PREALLOC, };
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 7/25 netfilter: nat: convert nat bysrc hash to rhashtable
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
It did use a fixed-size bucket list plus single lock to protect add/del.
Unlike the main conntrack table we only need to add and remove keys. Convert it to rhashtable to get table autosizing and per-bucket locking.
The maximum number of entries is -- as before -- tied to the number of conntracks so we do not need another upperlimit.
The change does not handle rhashtable_remove_fast error, only possible "error" is -ENOENT, and that is something that can happen legitimetely, e.g. because nat module was inserted at a later time and no src manip took place yet.
Tested with http-client-benchmark + httpterm with DNAT and SNAT rules in place.
--- include/net/netfilter/nf_conntrack.h | 3 +- include/net/netfilter/nf_nat.h | 1 + net/netfilter/nf_nat_core.c | 126 +++++++++++++++++++---------------- 3 files changed, 71 insertions(+), 59 deletions(-)
include/net/netfilter/nf_conntrack.h +2 -1
@@ -17,6 +17,7 @@#include <linux/bitops.h> #include <linux/compiler.h> #include <linux/atomic.h> +#include <linux/rhashtable.h> #include <linux/netfilter/nf_conntrack_tcp.h> #include <linux/netfilter/nf_conntrack_dccp.h>
@@ -118,7 +119,7 @@ struct nf_conn {struct nf_ct_ext *ext;#if IS_ENABLED (CONFIG_NF_NAT ) -struct hlist_node nat_bysource; +struct rhash_head nat_bysource;#endif /* Storage reserved for other modules, must be the last member */ union nf_conntrack_proto proto;
include/net/netfilter/nf_nat.h +1 -0
@@ -1,5 +1,6 @@#ifndef _NF_NAT_H#define _NF_NAT_H +#include <linux/rhashtable.h> #include <linux/netfilter_ipv4.h> #include <linux/netfilter/nf_nat.h> #include <net/netfilter/nf_conntrack_tuple.h>
net/netfilter/nf_nat_core.c +68 -58
208 lines not on this page · raw message
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 8/25 netfilter: physdev: physdev-is-out should not work with OUTPUT chain
In reply to Pablo Neira AyusoFrom: Hangbin Liu <[email protected]>
physdev_mt() will check skb->nf_bridge first, which was alloced in br_nf_pre_routing. So if we want to use --physdev-out and physdev-is-out, we need to match it in FORWARD or POSTROUTING chain. physdev_mt_check() only checked physdev-out and missed physdev-is-out. Fix it and update the debug message to make it clearer.
--- net/netfilter/xt_physdev.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
net/netfilter/xt_physdev.c +4 -4
@@ -102,14 +102,14 @@ static int physdev_mt_check(const struct xt_mtchk_param *par)if (!(info->bitmask &XT_PHYSDEV_OP_MASK ) || info->bitmask & ~XT_PHYSDEV_OP_MASK )return -EINVAL ; -if (info->bitmask &XT_PHYSDEV_OP_OUT && +if (info->bitmask & (XT_PHYSDEV_OP_OUT |XT_PHYSDEV_OP_ISOUT ) && (!(info->bitmask &XT_PHYSDEV_OP_BRIDGED ) || info->invert &XT_PHYSDEV_OP_BRIDGED ) && par->hook_mask & ((1 <<NF_INET_LOCAL_OUT ) | (1 <<NF_INET_FORWARD ) | (1 <<NF_INET_POST_ROUTING ))) { -pr_info ("using --physdev-out in the OUTPUT, FORWARD and " -"POSTROUTING chains for non-bridged traffic is not " -"supported anymore.\n" ); +pr_info ("using --physdev-out and --physdev-is-out are only" +"supported in the FORWARD and POSTROUTING chains with" +"bridged traffic.\n" );if (par->hook_mask & (1 <<NF_INET_LOCAL_OUT ))return -EINVAL ; }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 9/25 netfilter: nft_ct: make byte/packet expr more friendly
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
If we want to use ct packets expr, and add a rule like follows:
# nft add rule filter input ct packets gt 1 counter
We will find that no packets will hit it, because nf_conntrack_acct is disabled by default. So It will not work until we enable it manually via "echo 1 > /proc/sys/net/netfilter/nf_conntrack_acct".
This is not friendly, so like xt_connbytes do, if the user want to use ct byte/packet expr, enable nf_conntrack_acct automatically.
--- net/netfilter/nft_ct.c | 3 +++ 1 file changed, 3 insertions(+)
net/netfilter/nft_ct.c +3 -0
@@ -355,6 +355,9 @@ static int nft_ct_get_init(const struct nft_ctx *ctx,if (err <0 )return err; +if (priv->key ==NFT_CT_BYTES || priv->key ==NFT_CT_PKTS ) +nf_ct_set_acct (ctx->net, true); +return 0 ; }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 10/25 netfilter: constify arg to is_dying/confirmed
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
--- include/net/netfilter/nf_conntrack.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
include/net/netfilter/nf_conntrack.h +2 -2
@@ -270,12 +270,12 @@ static inline int nf_ct_is_template(const struct nf_conn *ct) }/* It's confirmed if it is, or has been in the hash table. */ -static inline int nf_ct_is_confirmed (struct nf_conn *ct) +static inline int nf_ct_is_confirmed (const struct nf_conn *ct) {return test_bit (IPS_CONFIRMED_BIT , &ct->status); } -static inline int nf_ct_is_dying (struct nf_conn *ct) +static inline int nf_ct_is_dying (const struct nf_conn *ct) {return test_bit (IPS_DYING_BIT , &ct->status); }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 11/25 netfilter: nf_tables: get rid of possible_net_t from set and basechain
In reply to Pablo Neira AyusoWe can pass the netns pointer as parameter to the functions that need to gain access to it. From basechains, I didn't find any client for this field anymore so let's remove this too.
--- include/net/netfilter/nf_tables.h | 21 +++++++++++---------- net/netfilter/nf_tables_api.c | 10 ++++------ net/netfilter/nft_hash.c | 20 ++++++++++---------- net/netfilter/nft_lookup.c | 2 +- net/netfilter/nft_rbtree.c | 26 ++++++++++++++------------ 5 files changed, 40 insertions(+), 39 deletions(-)
include/net/netfilter/nf_tables.h +11 -10
@@ -236,7 +236,8 @@ struct nft_expr;* @features: features supported by the implementation */ struct nft_set_ops { -bool (*lookup)(const struct nft_set *set, +bool (*lookup)(const struct net *net, +const struct nft_set *set,const u32 *key,const struct nft_set_ext **ext); bool (*update)(struct nft_set *set,
@@ -248,11 +249,14 @@ struct nft_set_ops {struct nft_regs *regs, const struct nft_set_ext **ext); -int (*insert)(const struct nft_set *set, +int (*insert)(const struct net *net, +const struct nft_set *set,const struct nft_set_elem *elem); -void (*activate)(const struct nft_set *set, +void (*activate)(const struct net *net, +const struct nft_set *set,const struct nft_set_elem *elem); -void * (*deactivate)(const struct nft_set *set, +void * (*deactivate)(const struct net *net, +const struct nft_set *set,const struct nft_set_elem *elem);void (*remove)(const struct nft_set *set,const struct nft_set_elem *elem);
@@ -295,7 +299,6 @@ void nft_unregister_set(struct nft_set_ops *ops);* @udlen: user data length * @udata: user data * @ops: set ops -* @pnet: network namespace * @flags: set flags * @genmask: generation mask * @klen: key length
@@ -318,7 +321,6 @@ struct nft_set {unsigned char *udata;/* runtime data below here */ const struct nft_set_ops *ops____cacheline_aligned ; -possible_net_t pnet; u16 flags:14, genmask:2;u8 klen;
@@ -804,7 +806,6 @@ struct nft_stats {* struct nft_base_chain - nf_tables base chain * * @ops: netfilter hook ops -* @pnet: net namespace that this chain belongs to * @type: chain type * @policy: default policy * @stats: per-cpu chain stats
@@ -813,7 +814,6 @@ struct nft_stats {*/ struct nft_base_chain {struct nf_hook_ops ops[NFT_HOOK_OPS_MAX ]; -possible_net_t pnet;const struct nf_chain_type *type;u8 policy;u8 flags;
@@ -1009,10 +1009,11 @@ static inline bool nft_set_elem_active(const struct nft_set_ext *ext,return !(ext->genmask & genmask); } -static inline void nft_set_elem_change_active (const struct nft_set *set, +static inline void nft_set_elem_change_active (const struct net *net, +const struct nft_set *set,struct nft_set_ext *ext) { - ext->genmask ^=nft_genmask_next (read_pnet (&set->pnet)); + ext->genmask ^=nft_genmask_next (net); }/*
net/netfilter/nf_tables_api.c +4 -6
@@ -1405,7 +1405,6 @@ static int nf_tables_newchain(struct net *net, struct sock *nlsk,rcu_assign_pointer (basechain->stats, stats); } -write_pnet (&basechain->pnet, net); basechain->type = type; chain = &basechain->chain;
@@ -2841,7 +2840,6 @@ static int nf_tables_newset(struct net *net, struct sock *nlsk, }INIT_LIST_HEAD (&set->bindings); -write_pnet (&set->pnet, net); set->ops = ops; set->ktype = ktype; set->klen = desc.klen;
@@ -3520,7 +3518,7 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, goto err4; ext->genmask =nft_genmask_cur (ctx->net) |NFT_SET_ELEM_BUSY_MASK ; - err = set->ops->insert (set, &elem); + err = set->ops->insert (ctx->net, set, &elem);if (err <0 ) goto err5;
@@ -3644,7 +3642,7 @@ static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set, goto err3; } - priv = set->ops->deactivate (set, &elem); + priv = set->ops->deactivate (ctx->net, set, &elem);if (priv ==NULL ) { err = -ENOENT ; goto err4;
@@ -4018,7 +4016,7 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb)case NFT_MSG_NEWSETELEM : te = (struct nft_trans_elem *)trans->data; - te->set->ops->activate (te->set, &te->elem); + te->set->ops->activate (net, te->set, &te->elem);nf_tables_setelem_notify (&trans->ctx, te->set, &te->elem,NFT_MSG_NEWSETELEM ,0 );
@@ -4143,7 +4141,7 @@ static int nf_tables_abort(struct net *net, struct sk_buff *skb)case NFT_MSG_DELSETELEM : te = (struct nft_trans_elem *)trans->data; - te->set->ops->activate (te->set, &te->elem); + te->set->ops->activate (net, te->set, &te->elem); te->set->ndeact--;nft_trans_destroy (trans);
net/netfilter/nft_hash.c +10 -10
@@ -71,13 +71,13 @@ static inline int nft_hash_cmp(struct rhashtable_compare_arg *arg,return 0 ; } -static bool nft_hash_lookup (const struct nft_set *set,const u32 *key, -const struct nft_set_ext **ext) +static bool nft_hash_lookup (const struct net *net,const struct nft_set *set, +const u32 *key,const struct nft_set_ext **ext) {struct nft_hash *priv =nft_set_priv (set);const struct nft_hash_elem *he;struct nft_hash_cmp_arg arg = { - .genmask =nft_genmask_cur (read_pnet (&set->pnet)), + .genmask =nft_genmask_cur (net), .set = set, .key = key, };
@@ -125,13 +125,13 @@ err1:return false; } -static int nft_hash_insert (const struct nft_set *set, +static int nft_hash_insert (const struct net *net,const struct nft_set *set,const struct nft_set_elem *elem) {struct nft_hash *priv =nft_set_priv (set);struct nft_hash_elem *he = elem->priv;struct nft_hash_cmp_arg arg = { - .genmask =nft_genmask_next (read_pnet (&set->pnet)), + .genmask =nft_genmask_next (net), .set = set, .key = elem->key.val.data, };
@@ -140,20 +140,20 @@ static int nft_hash_insert(const struct nft_set *set, nft_hash_params); } -static void nft_hash_activate (const struct nft_set *set, +static void nft_hash_activate (const struct net *net,const struct nft_set *set,const struct nft_set_elem *elem) {struct nft_hash_elem *he = elem->priv; -nft_set_elem_change_active (set, &he->ext); +nft_set_elem_change_active (net, set, &he->ext);nft_set_elem_clear_busy (&he->ext); } -static void *nft_hash_deactivate (const struct nft_set *set, +static void *nft_hash_deactivate (const struct net *net, +const struct nft_set *set,const struct nft_set_elem *elem) {struct nft_hash *priv =nft_set_priv (set); -struct net *net =read_pnet (&set->pnet);struct nft_hash_elem *he;struct nft_hash_cmp_arg arg = { .genmask =nft_genmask_next (net),
@@ -166,7 +166,7 @@ static void *nft_hash_deactivate(const struct nft_set *set,if (he !=NULL ) {if (!nft_set_elem_mark_busy (&he->ext) || !nft_is_active (net, &he->ext)) -nft_set_elem_change_active (set, &he->ext); +nft_set_elem_change_active (net, set, &he->ext);else he =NULL ; }
net/netfilter/nft_lookup.c +1 -1
@@ -35,7 +35,7 @@ static void nft_lookup_eval(const struct nft_expr *expr,const struct nft_set_ext *ext;bool found; - found = set->ops->lookup (set, ®s->data[priv->sreg], &ext) ^ + found = set->ops->lookup (pkt->net, set, ®s->data[priv->sreg], &ext) ^ priv->invert;if (!found) {
net/netfilter/nft_rbtree.c +14 -12
@@ -41,13 +41,13 @@ static bool nft_rbtree_equal(const struct nft_set *set, const void *this,return memcmp (this,nft_set_ext_key (&interval->ext), set->klen) ==0 ; } -static bool nft_rbtree_lookup (const struct nft_set *set,const u32 *key, -const struct nft_set_ext **ext) +static bool nft_rbtree_lookup (const struct net *net,const struct nft_set *set, +const u32 *key,const struct nft_set_ext **ext) {const struct nft_rbtree *priv =nft_set_priv (set);const struct nft_rbtree_elem *rbe, *interval =NULL ; +u8 genmask =nft_genmask_cur (net);const struct rb_node *parent; -u8 genmask =nft_genmask_cur (read_pnet (&set->pnet));const void *this;int d;
@@ -93,13 +93,13 @@ out:return false; } -static int __nft_rbtree_insert (const struct nft_set *set, +static int __nft_rbtree_insert (const struct net *net,const struct nft_set *set,struct nft_rbtree_elem *new) {struct nft_rbtree *priv =nft_set_priv (set); +u8 genmask =nft_genmask_next (net);struct nft_rbtree_elem *rbe;struct rb_node *parent, **p; -u8 genmask =nft_genmask_next (read_pnet (&set->pnet));int d; parent =NULL ;
@@ -132,14 +132,14 @@ static int __nft_rbtree_insert(const struct nft_set *set,return 0 ; } -static int nft_rbtree_insert (const struct nft_set *set, +static int nft_rbtree_insert (const struct net *net,const struct nft_set *set,const struct nft_set_elem *elem) {struct nft_rbtree_elem *rbe = elem->priv;int err;spin_lock_bh (&nft_rbtree_lock); - err =__nft_rbtree_insert (set, rbe); + err =__nft_rbtree_insert (net, set, rbe);spin_unlock_bh (&nft_rbtree_lock);return err;
@@ -156,21 +156,23 @@ static void nft_rbtree_remove(const struct nft_set *set,spin_unlock_bh (&nft_rbtree_lock); } -static void nft_rbtree_activate (const struct nft_set *set, +static void nft_rbtree_activate (const struct net *net, +const struct nft_set *set,const struct nft_set_elem *elem) {struct nft_rbtree_elem *rbe = elem->priv; -nft_set_elem_change_active (set, &rbe->ext); +nft_set_elem_change_active (net, set, &rbe->ext); } -static void *nft_rbtree_deactivate (const struct nft_set *set, +static void *nft_rbtree_deactivate (const struct net *net, +const struct nft_set *set,const struct nft_set_elem *elem) {const struct nft_rbtree *priv =nft_set_priv (set);const struct rb_node *parent = priv->root.rb_node;struct nft_rbtree_elem *rbe, *this = elem->priv; -u8 genmask =nft_genmask_next (read_pnet (&set->pnet)); +u8 genmask =nft_genmask_next (net);int d;while (parent !=NULL ) {
@@ -196,7 +198,7 @@ static void *nft_rbtree_deactivate(const struct nft_set *set, parent = parent->rb_right;continue ; } -nft_set_elem_change_active (set, &rbe->ext); +nft_set_elem_change_active (net, set, &rbe->ext);return rbe; } }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 12/25 netfilter: nf_conntrack_h323: fix off-by-one in DecodeQ931
In reply to Pablo Neira AyusoFrom: Toby DiPasquale <[email protected]>
This patch corrects an off-by-one error in the DecodeQ931 function in the nf_conntrack_h323 module. This error could result in reading off the end of a Q.931 frame.
--- net/netfilter/nf_conntrack_h323_asn1.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
net/netfilter/nf_conntrack_h323_asn1.c +2 -1
@@ -846,9 +846,10 @@ int DecodeQ931(unsigned char *buf, size_t sz, Q931 *q931) sz -= len;/* Message Type */ -if (sz <1 ) +if (sz <2 )return H323_ERROR_BOUND ; q931->MessageType = *p++; + sz--;"MessageType = %02X\n" , q931->MessageType);if (*p &0x80 ) { p++;
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 13/25 netfilter: conntrack: protect early_drop by rcu read lock
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
User can add ct entry via nfnetlink(IPCTNL_MSG_CT_NEW), and if the total number reach the nf_conntrack_max, we will try to drop some ct entries.
But in this case(the main function call path is ctnetlink_create_conntrack -> nf_conntrack_alloc -> early_drop), rcu_read_lock is not held, so race with hash resize will happen.
--- net/netfilter/nf_conntrack_core.c | 3 +++ 1 file changed, 3 insertions(+)
net/netfilter/nf_conntrack_core.c +3 -0
@@ -880,6 +880,7 @@ static noinline int early_drop(struct net *net, unsigned int _hash)struct hlist_nulls_head *ct_hash;unsigned hash, sequence, drops; +rcu_read_lock (); do { sequence = read_seqcount_begin(&nf_conntrack_generation); hash = scale_hash(_hash++);
@@ -887,6 +888,8 @@ static noinline int early_drop(struct net *net, unsigned int _hash) }while (read_seqcount_retry (&nf_conntrack_generation, sequence)); drops =early_drop_list (net, &ct_hash[hash]); +rcu_read_unlock (); +if (drops) {NF_CT_STAT_ADD_ATOMIC (net, early_drop, drops);return true;
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 14/25 netfilter: x_tables: speed up jump target validation
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
The dummy ruleset I used to test the original validation change was broken, most rules were unreachable and were not tested by mark_source_chains().
In some cases rulesets that used to load in a few seconds now require several minutes.
sample ruleset that shows the behaviour:
echo "*filter"
for i in $(seq 0 100000);do
printf ":chain_%06x - [0:0]\n" $i
done
for i in $(seq 0 100000);do
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
printf -- "-A INPUT -j chain_%06x\n" $i
done
echo COMMIT
[ pipe result into iptables-restore ]
This ruleset will be about 74mbyte in size, with ~500k searches though all 500k[1] rule entries. iptables-restore will take forever (gave up after 10 minutes)
Instead of always searching the entire blob for a match, fill an array with the start offsets of every single ipt_entry struct, then do a binary search to check if the jump target is present or not.
After this change ruleset restore times get again close to what one gets when reverting 36472341017529e (~3 seconds on my workstation).
[1] every user-defined rule gets an implicit RETURN, so we get 300k jumps + 100k userchains + 100k returns -> 500k rule entries
--- include/linux/netfilter/x_tables.h | 4 +++ net/ipv4/netfilter/arp_tables.c | 47 ++++++++++++++++++----------------- net/ipv4/netfilter/ip_tables.c | 45 ++++++++++++++++++---------------- net/ipv6/netfilter/ip6_tables.c | 45 ++++++++++++++++++---------------- net/netfilter/x_tables.c | 50 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 127 insertions(+), 64 deletions(-)
include/linux/netfilter/x_tables.h +4 -0
@@ -250,6 +250,10 @@ int xt_check_entry_offsets(const void *base, const char *elems,unsigned int target_offset, unsigned int next_offset); +unsigned int *xt_alloc_entry_offsets (unsigned int size); +bool xt_find_jump_offset (const unsigned int *offsets, +unsigned int target,unsigned int size); +int xt_check_match (struct xt_mtchk_param *,unsigned int size,u_int8_t proto,bool inv_proto); int xt_check_target(struct xt_tgchk_param *, unsigned int size, u_int8_t proto,
net/ipv4/netfilter/arp_tables.c +25 -22
106 lines not on this page · raw message
net/ipv4/netfilter/ip_tables.c +24 -21
103 lines not on this page · raw message
net/ipv6/netfilter/ip6_tables.c +24 -21
103 lines not on this page · raw message
net/netfilter/x_tables.c +50 -0
56 lines not on this page · raw message
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 15/25 netfilter: nft_ct: fix unpaired nf_connlabels_get/put call
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
We only get nf_connlabels if the user add ct label set expr successfully, but we will also put nf_connlabels if the user delete ct lable get expr. This is mismathced, and will cause ct label expr cannot work properly.
Also, if we init something fail, we should put nf_connlabels back. Otherwise, we may waste to alloc the memory that will never be used.
--- net/netfilter/nft_ct.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)
net/netfilter/nft_ct.c +19 -6
@@ -366,6 +366,7 @@ static int nft_ct_set_init(const struct nft_ctx *ctx, const struct nlattr * const tb[]) {struct nft_ct *priv =nft_expr_priv (expr); +bool label_got = false;unsigned int len;int err;
@@ -384,6 +385,7 @@ static int nft_ct_set_init(const struct nft_ctx *ctx, err =nf_connlabels_get (ctx->net, (len *BITS_PER_BYTE ) -1 );if (err)return err; + label_got = true;break ;#endif default :
@@ -393,17 +395,28 @@ static int nft_ct_set_init(const struct nft_ctx *ctx, priv->sreg =nft_parse_register (tb[NFTA_CT_SREG ]); err =nft_validate_register_load (priv->sreg, len);if (err <0 ) -return err; + goto err1; err =nft_ct_l3proto_try_module_get (ctx->afi->family);if (err <0 ) -return err; + goto err1;return 0 ; + +err1: +if (label_got) +nf_connlabels_put (ctx->net); +return err; +} + +static void nft_ct_get_destroy (const struct nft_ctx *ctx, +const struct nft_expr *expr) +{ +nft_ct_l3proto_module_put (ctx->afi->family); } -static void nft_ct_destroy (const struct nft_ctx *ctx, -const struct nft_expr *expr) +static void nft_ct_set_destroy (const struct nft_ctx *ctx, +const struct nft_expr *expr) {struct nft_ct *priv =nft_expr_priv (expr);
@@ -475,7 +488,7 @@ static const struct nft_expr_ops nft_ct_get_ops = { .size = NFT_EXPR_SIZE(sizeof(struct nft_ct)), .eval = nft_ct_get_eval, .init = nft_ct_get_init, - .destroy = nft_ct_destroy, + .destroy = nft_ct_get_destroy, .dump = nft_ct_get_dump, };
@@ -484,7 +497,7 @@ static const struct nft_expr_ops nft_ct_set_ops = { .size = NFT_EXPR_SIZE(sizeof(struct nft_ct)), .eval = nft_ct_set_eval, .init = nft_ct_set_init, - .destroy = nft_ct_destroy, + .destroy = nft_ct_set_destroy, .dump = nft_ct_set_dump, };
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 16/25 netfilter: Add helper array register/unregister functions
In reply to Pablo Neira AyusoFrom: Gao Feng <[email protected]>
Add nf_ct_helper_init(), nf_conntrack_helpers_register() and nf_conntrack_helpers_unregister() functions to avoid repetitive opencoded initialization in helpers.
This patch keeps an id parameter for nf_ct_helper_init() not to break helper matching by name that has been inconsistently exposed to userspace through ports, eg. ftp-2121, and through an incremental id, eg. tftp-1.
--- include/net/netfilter/nf_conntrack_helper.h | 15 ++++++ net/netfilter/nf_conntrack_ftp.c | 58 +++++++--------------- net/netfilter/nf_conntrack_helper.c | 57 ++++++++++++++++++++++ net/netfilter/nf_conntrack_irc.c | 36 +++++--------- net/netfilter/nf_conntrack_sane.c | 57 ++++++++-------------- net/netfilter/nf_conntrack_sip.c | 75 +++++++++++------------------ net/netfilter/nf_conntrack_tftp.c | 48 ++++++------------ 7 files changed, 165 insertions(+), 181 deletions(-)
include/net/netfilter/nf_conntrack_helper.h +15 -0
@@ -58,10 +58,25 @@ struct nf_conntrack_helper *__nf_conntrack_helper_find(const char *name,struct nf_conntrack_helper *nf_conntrack_helper_try_module_get (const char *name,u16 l3num,u8 protonum); +void nf_ct_helper_init (struct nf_conntrack_helper *helper, +u16 l3num,u16 protonum,const char *name, +u16 default_port,u16 spec_port,u32 id, +const struct nf_conntrack_expect_policy *exp_pol, +u32 expect_class_max,u32 data_len, +int (*help)(struct sk_buff *skb,unsigned int protoff, +struct nf_conn *ct, +enum ip_conntrack_info ctinfo), +int (*from_nlattr)(struct nlattr *attr, +struct nf_conn *ct), +struct module *module);int nf_conntrack_helper_register (struct nf_conntrack_helper *);void nf_conntrack_helper_unregister (struct nf_conntrack_helper *); +int nf_conntrack_helpers_register (struct nf_conntrack_helper *,unsigned int ); +void nf_conntrack_helpers_unregister (struct nf_conntrack_helper *, +unsigned int ); +struct nf_conn_help *nf_ct_helper_ext_add (struct nf_conn *ct,struct nf_conntrack_helper *helper,gfp_t gfp);
net/netfilter/nf_conntrack_ftp.c +18 -40
81 lines not on this page · raw message
net/netfilter/nf_conntrack_helper.c +57 -0
63 lines not on this page · raw message
net/netfilter/nf_conntrack_irc.c +12 -24
@@ -255,27 +255,18 @@ static int __init nf_conntrack_irc_init(void) ports[ports_c++] =IRC_PORT ;for (i =0 ; i < ports_c; i++) { - irc[i].tuple.src.l3num =AF_INET ; - irc[i].tuple.src.u.tcp.port =htons (ports[i]); - irc[i].tuple.dst.protonum =IPPROTO_TCP ; - irc[i].expect_policy = &irc_exp_policy; - irc[i].me =THIS_MODULE ; - irc[i].help = help; - -if (ports[i] ==IRC_PORT ) -sprintf (irc[i].name,"irc" ); -else -sprintf (irc[i].name,"irc-%u" , i); - - ret =nf_conntrack_helper_register (&irc[i]); -if (ret) { -pr_err ("failed to register helper for pf: %u port: %u\n" , - irc[i].tuple.src.l3num, ports[i]); - ports_c = i; -nf_conntrack_irc_fini (); -return ret; - } +nf_ct_helper_init (&irc[i],AF_INET ,IPPROTO_TCP ,"irc" , +IRC_PORT , ports[i], i, &irc_exp_policy, +0 ,0 , help,NULL ,THIS_MODULE ); + } + + ret =nf_conntrack_helpers_register (&irc[0 ], ports_c); +if (ret) { +pr_err ("failed to register helpers\n" ); +kfree (irc_buffer); +return ret; } +return 0 ; }
@@ -283,10 +274,7 @@ static int __init nf_conntrack_irc_init(void)* it is needed by the init function */ static void nf_conntrack_irc_fini (void ) { -int i; - -for (i =0 ; i < ports_c; i++) -nf_conntrack_helper_unregister (&irc[i]); +nf_conntrack_helpers_unregister (irc, ports_c);kfree (irc_buffer); }
net/netfilter/nf_conntrack_sane.c +20 -37
80 lines not on this page · raw message
net/netfilter/nf_conntrack_sip.c +28 -47
98 lines not on this page · raw message
net/netfilter/nf_conntrack_tftp.c +15 -33
69 lines not on this page · raw message
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 17/25 netfilter: nft_log: fix possible memory leak if log expr init fail
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
Suppose that we specify the NFTA_LOG_PREFIX, then NFTA_LOG_LEVEL and NFTA_LOG_GROUP are specified together or nf_logger_find_get call returns fail, i.e. expr init fail, memory leak will happen.
--- net/netfilter/nft_log.c | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-)
net/netfilter/nft_log.c +18 -8
@@ -52,6 +52,14 @@ static int nft_log_init(const struct nft_ctx *ctx,struct nft_log *priv =nft_expr_priv (expr);struct nf_loginfo *li = &priv->loginfo;const struct nlattr *nla; +int err; + + li->type =NF_LOG_TYPE_LOG ; +if (tb[NFTA_LOG_LEVEL ] !=NULL && + tb[NFTA_LOG_GROUP ] !=NULL ) +return -EINVAL ; +if (tb[NFTA_LOG_GROUP ] !=NULL ) + li->type =NF_LOG_TYPE_ULOG ; nla = tb[NFTA_LOG_PREFIX ];if (nla !=NULL ) {
@@ -63,13 +71,6 @@ static int nft_log_init(const struct nft_ctx *ctx, priv->prefix = (char *)nft_log_null_prefix; } - li->type =NF_LOG_TYPE_LOG ; -if (tb[NFTA_LOG_LEVEL ] !=NULL && - tb[NFTA_LOG_GROUP ] !=NULL ) -return -EINVAL ; -if (tb[NFTA_LOG_GROUP ] !=NULL ) - li->type =NF_LOG_TYPE_ULOG ; -switch (li->type) {case NF_LOG_TYPE_LOG :if (tb[NFTA_LOG_LEVEL ] !=NULL ) {
@@ -96,7 +97,16 @@ static int nft_log_init(const struct nft_ctx *ctx,break ; } -return nf_logger_find_get (ctx->afi->family, li->type); + err =nf_logger_find_get (ctx->afi->family, li->type); +if (err <0 ) + goto err1; + +return 0 ; + +err1: +if (priv->prefix != nft_log_null_prefix) +kfree (priv->prefix); +return err; } static void nft_log_destroy(const struct nft_ctx *ctx,
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 18/25 netfilter: nft_log: check the validity of log level
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
User can specify the log level larger than 7(debug level) via nfnetlink, this is invalid. So in this case, we should report EINVAL to the userspace.
--- net/netfilter/nft_log.c | 5 +++++ 1 file changed, 5 insertions(+)
net/netfilter/nft_log.c +5 -0
@@ -79,6 +79,11 @@ static int nft_log_init(const struct nft_ctx *ctx, }else { li->u.log.level =LOGLEVEL_WARNING ; } +if (li->u.log.level >LOGLEVEL_DEBUG ) { + err = -EINVAL ; + goto err1; + } +if (tb[NFTA_LOG_FLAGS ] !=NULL ) { li->u.log.logflags =ntohl (nla_get_be32 (tb[NFTA_LOG_FLAGS ]));
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 19/25 netfilter: nft_log: fix snaplen does not truncate packets
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
There's a similar problem in xt_NFLOG, and was fixed by commit 7643507fe8b5 ("netfilter: xt_NFLOG: nflog-range does not truncate packets"). Only set copy_len here does not work, so we should enable NF_LOG_F_COPY_LEN also.
--- net/netfilter/nft_log.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
net/netfilter/nft_log.c +2 -1
@@ -92,6 +92,7 @@ static int nft_log_init(const struct nft_ctx *ctx,case NF_LOG_TYPE_ULOG : li->u.ulog.group =ntohs (nla_get_be16 (tb[NFTA_LOG_GROUP ]));if (tb[NFTA_LOG_SNAPLEN ] !=NULL ) { + li->u.ulog.flags |=NF_LOG_F_COPY_LEN ; li->u.ulog.copy_len =ntohl (nla_get_be32 (tb[NFTA_LOG_SNAPLEN ])); }
@@ -149,7 +150,7 @@ static int nft_log_dump(struct sk_buff *skb, const struct nft_expr *expr)if (nla_put_be16 (skb,NFTA_LOG_GROUP ,htons (li->u.ulog.group))) goto nla_put_failure; -if (li->u.ulog.copy_len) { +if (li->u.ulog.flags &NF_LOG_F_COPY_LEN ) {if (nla_put_be32 (skb,NFTA_LOG_SNAPLEN ,htonl (li->u.ulog.copy_len))) goto nla_put_failure;
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 20/25 netfilter: nf_tables: allow to filter out rules by table and chain
In reply to Pablo Neira AyusoIf the table and/or chain attributes are set in a rule dump request, we filter out the rules based on this selection.
--- net/netfilter/nf_tables_api.c | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+)
net/netfilter/nf_tables_api.c +38 -0
@@ -1857,10 +1857,16 @@ err:return err; } +struct nft_rule_dump_ctx { +char table[NFT_TABLE_MAXNAMELEN ]; +char chain[NFT_CHAIN_MAXNAMELEN ]; +}; +static int nf_tables_dump_rules (struct sk_buff *skb,struct netlink_callback *cb) {const struct nfgenmsg *nfmsg =nlmsg_data (cb->nlh); +const struct nft_rule_dump_ctx *ctx = cb->data;const struct nft_af_info *afi;const struct nft_table *table;const struct nft_chain *chain;
@@ -1877,7 +1883,15 @@ static int nf_tables_dump_rules(struct sk_buff *skb,continue ;list_for_each_entry_rcu (table, &afi->tables, list) { +if (ctx && ctx->table[0 ] && +strcmp (ctx->table, table->name) !=0 ) +continue ; +list_for_each_entry_rcu (chain, &table->chains, list) { +if (ctx && ctx->chain[0 ] && +strcmp (ctx->chain, chain->name) !=0 ) +continue ; +list_for_each_entry_rcu (rule, &chain->rules, list) {if (!nft_is_active (net, rule)) goto cont;
@@ -1907,6 +1921,12 @@ done:return skb->len; } +static int nf_tables_dump_rules_done (struct netlink_callback *cb) +{ +kfree (cb->data); +return 0 ; +} +static int nf_tables_getrule (struct net *net,struct sock *nlsk,struct sk_buff *skb,const struct nlmsghdr *nlh,const struct nlattr *const nla[])
@@ -1924,7 +1944,25 @@ static int nf_tables_getrule(struct net *net, struct sock *nlsk,if (nlh->nlmsg_flags &NLM_F_DUMP ) {struct netlink_dump_control c = { .dump = nf_tables_dump_rules, + .done = nf_tables_dump_rules_done, }; + +if (nla[NFTA_RULE_TABLE ] || nla[NFTA_RULE_CHAIN ]) { +struct nft_rule_dump_ctx *ctx; + + ctx =kzalloc (sizeof (*ctx),GFP_KERNEL ); +if (!ctx) +return -ENOMEM ; + +if (nla[NFTA_RULE_TABLE ]) +nla_strlcpy (ctx->table, nla[NFTA_RULE_TABLE ], +sizeof (ctx->table)); +if (nla[NFTA_RULE_CHAIN ]) +nla_strlcpy (ctx->chain, nla[NFTA_RULE_CHAIN ], +sizeof (ctx->chain)); + c.data = ctx; + } +return netlink_dump_start (nlsk, skb, nlh, &c); }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 21/25 netfilter: conntrack: support a fixed size of 128 distinct labels
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
The conntrack label extension is currently variable-sized, e.g. if only 2 labels are used by iptables rules then the labels->bits[] array will only contain one element.
We track size of each label storage area in the 'words' member.
But in nftables and openvswitch we always have to ask for worst-case since we don't know what bit will be used at configuration time.
As most arches are 64bit we need to allocate 24 bytes in this case:
struct nf_conn_labels {
u8 words; /* 0 1 */
/* XXX 7 bytes hole, try to pack */
long unsigned bits[2]; /* 8 24 */Make bits a fixed size and drop the words member, it simplifies the code and only increases memory requirements on x86 when less than 64bit labels are required.
We still only allocate the extension if its needed.
--- include/net/netfilter/nf_conntrack_labels.h | 16 ++++------------ net/netfilter/nf_conntrack_labels.c | 13 +++---------- net/netfilter/nf_conntrack_netlink.c | 10 +++++----- net/netfilter/nft_ct.c | 13 +++---------- net/netfilter/xt_connlabel.c | 2 +- net/openvswitch/conntrack.c | 4 ++-- 6 files changed, 18 insertions(+), 40 deletions(-)
include/net/netfilter/nf_conntrack_labels.h +4 -12
@@ -10,8 +10,7 @@#define NF_CT_LABELS_MAX_SIZE ((XT_CONNLABEL_MAXBIT + 1) / BITS_PER_BYTE)struct nf_conn_labels { -u8 words; -unsigned long bits[]; +unsigned long bits[NF_CT_LABELS_MAX_SIZE /sizeof (long )]; };static inline struct nf_conn_labels *nf_ct_labels_find (const struct nf_conn *ct)
@@ -26,20 +25,13 @@ static inline struct nf_conn_labels *nf_ct_labels_find(const struct nf_conn *ct)static inline struct nf_conn_labels *nf_ct_labels_ext_add (struct nf_conn *ct) {#ifdef CONFIG_NF_CONNTRACK_LABELS -struct nf_conn_labels *cl_ext;struct net *net =nf_ct_net (ct); -u8 words; - words =ACCESS_ONCE (net->ct.label_words); -if (words ==0 ) +if (net->ct.labels_used ==0 )return NULL ; - cl_ext =nf_ct_ext_add_length (ct,NF_CT_EXT_LABELS , - words *sizeof (long ),GFP_ATOMIC ); -if (cl_ext !=NULL ) - cl_ext->words = words; - -return cl_ext; +return nf_ct_ext_add_length (ct,NF_CT_EXT_LABELS , +sizeof (struct nf_conn_labels ),GFP_ATOMIC );#else return NULL ;#endif
net/netfilter/nf_conntrack_labels.c +3 -10
@@ -20,7 +20,7 @@ int nf_connlabel_set(struct nf_conn *ct, u16 bit) {struct nf_conn_labels *labels =nf_ct_labels_find (ct); -if (!labels ||BIT_WORD (bit) >= labels->words) +if (!labels)return -ENOSPC ;if (test_bit (bit, labels->bits))
@@ -60,7 +60,7 @@ int nf_connlabels_replace(struct nf_conn *ct,if (!labels)return -ENOSPC ; - size = labels->words *sizeof (long ); + size =sizeof (labels->bits);if (size < (words32 *sizeof (u32))) words32 = size /sizeof (u32);
@@ -80,16 +80,11 @@ EXPORT_SYMBOL_GPL(nf_connlabels_replace);int nf_connlabels_get (struct net *net,unsigned int bits) { -size_t words; - - words =BIT_WORD (bits) +1 ; -if (words >NF_CT_LABELS_MAX_SIZE /sizeof (long )) +if (BIT_WORD (bits) >=NF_CT_LABELS_MAX_SIZE /sizeof (long ))return -ERANGE ;spin_lock (&nf_connlabels_lock); net->ct.labels_used++; -if (words > net->ct.label_words) - net->ct.label_words = words;spin_unlock (&nf_connlabels_lock);return 0 ;
@@ -100,8 +95,6 @@ void nf_connlabels_put(struct net *net) {spin_lock (&nf_connlabels_lock); net->ct.labels_used--; -if (net->ct.labels_used ==0 ) - net->ct.label_words =0 ;spin_unlock (&nf_connlabels_lock); }EXPORT_SYMBOL_GPL (nf_connlabels_put);
net/netfilter/nf_conntrack_netlink.c +5 -5
@@ -346,25 +346,25 @@ static inline int ctnetlink_label_size(const struct nf_conn *ct)if (!labels)return 0 ; -return nla_total_size (labels->words *sizeof (long )); +return nla_total_size (sizeof (labels->bits)); }static int ctnetlink_dump_labels (struct sk_buff *skb,const struct nf_conn *ct) {struct nf_conn_labels *labels =nf_ct_labels_find (ct); -unsigned int len, i; +unsigned int i;if (!labels)return 0 ; - len = labels->words *sizeof (long ); i =0 ;do {if (labels->bits[i] !=0 ) -return nla_put (skb,CTA_LABELS , len, labels->bits); +return nla_put (skb,CTA_LABELS ,sizeof (labels->bits), + labels->bits); i++; - }while (i < labels->words); + }while (i <ARRAY_SIZE (labels->bits));return 0 ; }
net/netfilter/nft_ct.c +3 -10
@@ -113,18 +113,11 @@ static void nft_ct_get_eval(const struct nft_expr *expr,#ifdef CONFIG_NF_CONNTRACK_LABELS case NFT_CT_LABELS : {struct nf_conn_labels *labels =nf_ct_labels_find (ct); -unsigned int size; -if (!labels) { +if (labels) +memcpy (dest, labels->bits,NF_CT_LABELS_MAX_SIZE ); +else memset (dest,0 ,NF_CT_LABELS_MAX_SIZE ); -return ; - } - - size = labels->words *sizeof (long ); -memcpy (dest, labels->bits, size); -if (size <NF_CT_LABELS_MAX_SIZE ) -memset (((char *) dest) + size,0 , -NF_CT_LABELS_MAX_SIZE - size);return ; }#endif
net/netfilter/xt_connlabel.c +1 -1
@@ -25,7 +25,7 @@ static bool connlabel_match(const struct nf_conn *ct, u16 bit)if (!labels)return false; -return BIT_WORD (bit) < labels->words &&test_bit (bit, labels->bits); +return test_bit (bit, labels->bits); } static bool
net/openvswitch/conntrack.c +2 -2
@@ -135,7 +135,7 @@ static void ovs_ct_get_labels(const struct nf_conn *ct,struct nf_conn_labels *cl = ct ?nf_ct_labels_find (ct) :NULL ;if (cl) { -size_t len = cl->words *sizeof (long ); +size_t len =sizeof (cl->bits);if (len >OVS_CT_LABELS_LEN ) len =OVS_CT_LABELS_LEN ;
@@ -274,7 +274,7 @@ static int ovs_ct_set_labels(struct sk_buff *skb, struct sw_flow_key *key,nf_ct_labels_ext_add (ct); cl =nf_ct_labels_find (ct); } -if (!cl || cl->words *sizeof (long ) <OVS_CT_LABELS_LEN ) +if (!cl ||sizeof (cl->bits) <OVS_CT_LABELS_LEN )return -ENOSPC ; err = nf_connlabels_replace(ct, (u32 *)labels, (u32 *)mask,
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 22/25 netfilter: connlabels: move set helper to xt_connlabel
In reply to Pablo Neira AyusoFrom: Florian Westphal <[email protected]>
xt_connlabel is the only user so move it.
--- include/net/netfilter/nf_conntrack_labels.h | 2 -- net/netfilter/nf_conntrack_labels.c | 17 ----------------- net/netfilter/xt_connlabel.c | 29 ++++++++++++++++------------- 3 files changed, 16 insertions(+), 32 deletions(-)
include/net/netfilter/nf_conntrack_labels.h +0 -2
@@ -37,8 +37,6 @@ static inline struct nf_conn_labels *nf_ct_labels_ext_add(struct nf_conn *ct)#endif } -int nf_connlabel_set (struct nf_conn *ct,u16 bit); -int nf_connlabels_replace (struct nf_conn *ct,const u32 *data,const u32 *mask,unsigned int words);
net/netfilter/nf_conntrack_labels.c +0 -17
@@ -16,23 +16,6 @@static spinlock_t nf_connlabels_lock; -int nf_connlabel_set (struct nf_conn *ct,u16 bit) -{ -struct nf_conn_labels *labels =nf_ct_labels_find (ct); - -if (!labels) -return -ENOSPC ; - -if (test_bit (bit, labels->bits)) -return 0 ; - -if (!test_and_set_bit (bit, labels->bits)) -nf_conntrack_event_cache (IPCT_LABEL , ct); - -return 0 ; -} -EXPORT_SYMBOL_GPL (nf_connlabel_set); -static int replace_u32 (u32 *address,u32 mask,u32 new) {u32 old, tmp;
net/netfilter/xt_connlabel.c +16 -13
@@ -9,6 +9,7 @@#include <linux/module.h> #include <linux/skbuff.h> #include <net/netfilter/nf_conntrack.h> +#include <net/netfilter/nf_conntrack_ecache.h> #include <net/netfilter/nf_conntrack_labels.h> #include <linux/netfilter/x_tables.h>
@@ -18,21 +19,12 @@ MODULE_DESCRIPTION("Xtables: add/match connection trackling labels");MODULE_ALIAS ("ipt_connlabel" );MODULE_ALIAS ("ip6t_connlabel" ); -static bool connlabel_match (const struct nf_conn *ct,u16 bit) -{ -struct nf_conn_labels *labels =nf_ct_labels_find (ct); - -if (!labels) -return false; - -return test_bit (bit, labels->bits); -} -static bool connlabel_mt (const struct sk_buff *skb,struct xt_action_param *par) {const struct xt_connlabel_mtinfo *info = par->matchinfo;enum ip_conntrack_info ctinfo; +struct nf_conn_labels *labels;struct nf_conn *ct;bool invert = info->options &XT_CONNLABEL_OP_INVERT ;
@@ -40,10 +32,21 @@ connlabel_mt(const struct sk_buff *skb, struct xt_action_param *par)if (ct ==NULL ||nf_ct_is_untracked (ct))return invert; -if (info->options &XT_CONNLABEL_OP_SET ) -return (nf_connlabel_set (ct, info->bit) ==0 ) ^ invert; + labels =nf_ct_labels_find (ct); +if (!labels) +return invert; + +if (test_bit (info->bit, labels->bits)) +return !invert; + +if (info->options &XT_CONNLABEL_OP_SET ) { +if (!test_and_set_bit (info->bit, labels->bits)) +nf_conntrack_event_cache (IPCT_LABEL , ct); + +return !invert; + } -return connlabel_match (ct, info->bit) ^ invert; +return invert; }static int connlabel_mt_check (const struct xt_mtchk_param *par)
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 23/25 netfilter: h323: Use mod_timer instead of set_expect_timeout
In reply to Pablo Neira AyusoFrom: Gao Feng <[email protected]>
Simplify the code without any side effect. The set_expect_timeout is used to modify the timer expired time. It tries to delete timer, and add it again. So we could use mod_timer directly.
--- net/netfilter/nf_conntrack_h323_main.c | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-)
net/netfilter/nf_conntrack_h323_main.c +1 -14
@@ -1273,19 +1273,6 @@ static struct nf_conntrack_expect *find_expect(struct nf_conn *ct, }/****************************************************************************/ -static int set_expect_timeout (struct nf_conntrack_expect *exp, -unsigned int timeout) -{ -if (!exp || !del_timer (&exp->timeout)) -return 0 ; - - exp->timeout.expires = jiffies + timeout *HZ ; -add_timer (&exp->timeout); - -return 1 ; -} - -/****************************************************************************/ static int expect_q931(struct sk_buff *skb, struct nf_conn *ct, enum ip_conntrack_info ctinfo, unsigned int protoff, unsigned char **data,
@@ -1486,7 +1473,7 @@ static int process_rcf(struct sk_buff *skb, struct nf_conn *ct,"timeout to %u seconds for" , info->timeout);nf_ct_dump_tuple (&exp->tuple); -set_expect_timeout (exp, info->timeout); +mod_timer (&exp->timeout, jiffies + info->timeout *HZ ); }spin_unlock_bh (&nf_conntrack_expect_lock); }
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 24/25 netfilter: nft_compat: put back match/target module if init fail
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
If the user specify the invalid NFTA_MATCH_INFO/NFTA_TARGET_INFO attr or memory alloc fail, we should call module_put to the related match or target. Otherwise, we cannot remove the module even nobody use it.
--- net/netfilter/nft_compat.c | 32 ++++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-)
net/netfilter/nft_compat.c +24 -8
@@ -634,6 +634,7 @@ nft_match_select_ops(const struct nft_ctx *ctx,struct xt_match *match;char *mt_name;u32 rev, family; +int err; if (tb[NFTA_MATCH_NAME] == NULL || tb[NFTA_MATCH_REV] == NULL ||
@@ -660,13 +661,17 @@ nft_match_select_ops(const struct nft_ctx *ctx,if (IS_ERR (match))return ERR_PTR (-ENOENT ); -if (match->matchsize >nla_len (tb[NFTA_MATCH_INFO ])) -return ERR_PTR (-EINVAL ); +if (match->matchsize >nla_len (tb[NFTA_MATCH_INFO ])) { + err = -EINVAL ; + goto err; + }/* This is the first time we use this match, allocate operations */ nft_match =kzalloc (sizeof (struct nft_xt ),GFP_KERNEL ); -if (nft_match ==NULL ) -return ERR_PTR (-ENOMEM ); +if (nft_match ==NULL ) { + err = -ENOMEM ; + goto err; + } nft_match->ops.type = &nft_match_type; nft_match->ops.size =NFT_EXPR_SIZE (XT_ALIGN (match->matchsize));
@@ -680,6 +685,9 @@ nft_match_select_ops(const struct nft_ctx *ctx,list_add (&nft_match->head, &nft_match_list);return &nft_match->ops; +err: +module_put (match->me); +return ERR_PTR (err); }static void nft_match_release (void )
@@ -717,6 +725,7 @@ nft_target_select_ops(const struct nft_ctx *ctx,struct xt_target *target;char *tg_name;u32 rev, family; +int err; if (tb[NFTA_TARGET_NAME] == NULL || tb[NFTA_TARGET_REV] == NULL ||
@@ -743,13 +752,17 @@ nft_target_select_ops(const struct nft_ctx *ctx,if (IS_ERR (target))return ERR_PTR (-ENOENT ); -if (target->targetsize >nla_len (tb[NFTA_TARGET_INFO ])) -return ERR_PTR (-EINVAL ); +if (target->targetsize >nla_len (tb[NFTA_TARGET_INFO ])) { + err = -EINVAL ; + goto err; + }/* This is the first time we use this target, allocate operations */ nft_target =kzalloc (sizeof (struct nft_xt ),GFP_KERNEL ); -if (nft_target ==NULL ) -return ERR_PTR (-ENOMEM ); +if (nft_target ==NULL ) { + err = -ENOMEM ; + goto err; + } nft_target->ops.type = &nft_target_type; nft_target->ops.size =NFT_EXPR_SIZE (XT_ALIGN (target->targetsize));
@@ -767,6 +780,9 @@ nft_target_select_ops(const struct nft_ctx *ctx,list_add (&nft_target->head, &nft_target_list);return &nft_target->ops; +err: +module_put (target->me); +return ERR_PTR (err); }static void nft_target_release (void )
Signature · 1 line
2.1.4
Pablo Neira Ayuso
maintainerPATCH 25/25 netfilter: nft_compat: fix crash when related match/target module is removed
In reply to Pablo Neira AyusoFrom: Liping Zhang <[email protected]>
We "cache" the loaded match/target modules and reuse them, but when the modules are removed, we still point to them. Then we may end up with invalid memory references when using iptables-compat to add rules later.
Input the following commands will reproduce the kernel crash:
# iptables-compat -A INPUT -j LOG # iptables-compat -D INPUT -j LOG # rmmod xt_LOG # iptables-compat -A INPUT -j LOG BUG: unable to handle kernel paging request at ffffffffa05a9010 IP: [<ffffffff813f783e>] strcmp+0xe/0x30 Call Trace: [<ffffffffa05acc43>] nft_target_select_ops+0x83/0x1f0 [nft_compat] [<ffffffffa058a177>] nf_tables_expr_parse+0x147/0x1f0 [nf_tables] [<ffffffffa058e541>] nf_tables_newrule+0x301/0x810 [nf_tables] [<ffffffff8141ca00>] ? nla_parse+0x20/0x100 [<ffffffffa057fa8f>] nfnetlink_rcv+0x33f/0x53d [nfnetlink] [<ffffffffa057f94b>] ? nfnetlink_rcv+0x1fb/0x53d [nfnetlink] [<ffffffff817116b8>] netlink_unicast+0x178/0x220 [<ffffffff81711a5b>] netlink_sendmsg+0x2fb/0x3a0 [<ffffffff816b7fc8>] sock_sendmsg+0x38/0x50 [<ffffffff816b8a7e>] ___sys_sendmsg+0x28e/0x2a0 [<ffffffff816bcb7e>] ? release_sock+0x1e/0xb0 [<ffffffff81804ac5>] ? _raw_spin_unlock_bh+0x35/0x40 [<ffffffff816bcbe2>] ? release_sock+0x82/0xb0 [<ffffffff816b93d4>] __sys_sendmsg+0x54/0x90 [<ffffffff816b9422>] SyS_sendmsg+0x12/0x20 [<ffffffff81805172>] entry_SYSCALL_64_fastpath+0x1a/0xa9
So when nobody use the related match/target module, there's no need to "cache" it. And nft_[match|target]_release are useless anymore, remove them.
--- net/netfilter/nft_compat.c | 43 ++++++++++++++++++++----------------------- 1 file changed, 20 insertions(+), 23 deletions(-)
net/netfilter/nft_compat.c +20 -23
@@ -23,6 +23,20 @@#include <linux/netfilter_arp/arp_tables.h> #include <net/netfilter/nf_tables.h> +struct nft_xt { +struct list_head head; +struct nft_expr_ops ops; +unsigned int refcnt; +}; + +static void nft_xt_put (struct nft_xt *xt) +{ +if (--xt->refcnt ==0 ) { +list_del (&xt->head); +kfree (xt); + } +} +static int nft_compat_chain_validate_dependency (const char *tablename,const struct nft_chain *chain) {
@@ -260,6 +274,7 @@ nft_target_destroy(const struct nft_ctx *ctx, const struct nft_expr *expr)if (par.target->destroy !=NULL ) par.target->destroy (&par); + nft_xt_put(container_of(expr->ops, struct nft_xt, ops));module_put (target->me); }
@@ -442,6 +457,7 @@ nft_match_destroy(const struct nft_ctx *ctx, const struct nft_expr *expr)if (par.match->destroy !=NULL ) par.match->destroy (&par); + nft_xt_put(container_of(expr->ops, struct nft_xt, ops));module_put (match->me); }
@@ -612,11 +628,6 @@ static const struct nfnetlink_subsystem nfnl_compat_subsys = {static LIST_HEAD (nft_match_list); -struct nft_xt { -struct list_head head; -struct nft_expr_ops ops; -}; -static struct nft_expr_type nft_match_type; static bool nft_match_cmp(const struct xt_match *match,
@@ -653,6 +664,7 @@ nft_match_select_ops(const struct nft_ctx *ctx,if (!try_module_get (match->me))return ERR_PTR (-ENOENT ); + nft_match->refcnt++;return &nft_match->ops; } }
@@ -673,6 +685,7 @@ nft_match_select_ops(const struct nft_ctx *ctx, goto err; } + nft_match->refcnt =1 ; nft_match->ops.type = &nft_match_type; nft_match->ops.size =NFT_EXPR_SIZE (XT_ALIGN (match->matchsize)); nft_match->ops.eval = nft_match_eval;
@@ -690,14 +703,6 @@ err:return ERR_PTR (err); } -static void nft_match_release (void ) -{ -struct nft_xt *nft_match, *tmp; - -list_for_each_entry_safe (nft_match, tmp, &nft_match_list, head) -kfree (nft_match); -} -static struct nft_expr_type nft_match_type__read_mostly = { .name ="match" , .select_ops = nft_match_select_ops,
@@ -744,6 +749,7 @@ nft_target_select_ops(const struct nft_ctx *ctx,if (!try_module_get (target->me))return ERR_PTR (-ENOENT ); + nft_target->refcnt++;return &nft_target->ops; } }
@@ -764,6 +770,7 @@ nft_target_select_ops(const struct nft_ctx *ctx, goto err; } + nft_target->refcnt =1 ; nft_target->ops.type = &nft_target_type; nft_target->ops.size =NFT_EXPR_SIZE (XT_ALIGN (target->targetsize)); nft_target->ops.init = nft_target_init;
@@ -785,14 +792,6 @@ err:return ERR_PTR (err); } -static void nft_target_release (void ) -{ -struct nft_xt *nft_target, *tmp; - -list_for_each_entry_safe (nft_target, tmp, &nft_target_list, head) -kfree (nft_target); -} -static struct nft_expr_type nft_target_type__read_mostly = { .name ="target" , .select_ops = nft_target_select_ops,
@@ -835,8 +834,6 @@ static void __exit nft_compat_module_exit(void)nfnetlink_subsys_unregister (&nfnl_compat_subsys);nft_unregister_expr (&nft_target_type);nft_unregister_expr (&nft_match_type); -nft_match_release (); -nft_target_release (); }MODULE_ALIAS_NFNL_SUBSYS (NFNL_SUBSYS_NFT_COMPAT );
Signature · 1 line
2.1.4
David Miller
maintainerFrom: Pablo Neira Ayuso <[email protected]>
Date: Sat, 23 Jul 2016 13:02:00 +0200
Quoted 2 lines
The following patchset contains Netfilter/IPVS updates for net-next, they are:
...
Quoted 3 lines
You can pull these changes from:
git://git.kernel.org/pub/scm/linux/kernel/git/pablo/nf-next.git
Pulled, thanks Pablo.