32/64/128-bits word addressing in nf_tables
Subsystems (2)
Pablo Neira Ayuso
maintainercover 32/64/128-bits word addressing in nf_tables
This is a preliminary patchset to allow nf_tables to address registers at 32/64/128 bits word size. This is something that Patrick and I have been discussing for a while.
The proposed approach in this patchset adds the new register addressing to the nf_tables core, the overlapping register approach describe in patch 1/2 is backward compatible.
Still missing a kernel patch to allow set elements higher than 128 bits, so we can have concatenations including IPv6 addresses, but that limitation should be easy to remove. Explicit set type selection is also required, currently, it is selecting the rb-tree set type here, which is suboptimal.
Comments welcome.
Pablo Neira Ayuso (2):
netfilter: nf_tables: allow 32/64/128-bits register addressing
netfilter: nf_tables: round to 32 bits in payload operations
include/net/netfilter/nf_tables.h | 16 +++++- include/uapi/linux/netfilter/nf_tables.h | 35 ++++++++++++- net/netfilter/nf_tables_api.c | 4 +- net/netfilter/nf_tables_core.c | 81 +++++++++++++++++++++++------- net/netfilter/nft_bitwise.c | 10 ++-- net/netfilter/nft_byteorder.c | 10 ++-- net/netfilter/nft_cmp.c | 8 +-- net/netfilter/nft_compat.c | 16 +++--- net/netfilter/nft_ct.c | 35 +++++++------ net/netfilter/nft_exthdr.c | 9 ++-- net/netfilter/nft_hash.c | 13 +++-- net/netfilter/nft_immediate.c | 5 +- net/netfilter/nft_limit.c | 5 +- net/netfilter/nft_log.c | 3 +- net/netfilter/nft_lookup.c | 9 ++-- net/netfilter/nft_meta.c | 37 +++++++------- net/netfilter/nft_nat.c | 27 +++++----- net/netfilter/nft_payload.c | 9 ++-- net/netfilter/nft_rbtree.c | 5 +- 19 files changed, 207 insertions(+), 130 deletions(-)
Signature · 1 line
1.7.10.4
Pablo Neira Ayuso
maintainerRFC PATCH 1/2 netfilter: nf_tables: allow 32/64/128-bits register addressing
This patch allows 32/64/128-bits register addressing to nf_tables. So far it was only possible to address registers using 128-bits word size. This is problematic for set elements that are composed of several tuples, ie. concatenations, as each tuple needs to be aligned to the 128-bits word size of nf_tables.
With this patch, a simple concatenation like 'ip saddr . ip daddr' is represented in the following way:
ip filter output 10 0
[ payload load 4b @ network header + 12 => reg 19 ] [ payload load 4b @ network header + 16 => reg 20 ] [ lookup reg 19 set set0 dreg 0 ]
[ counter pkts 0 bytes 0 ]
Thus, two IPv4 addresses are squashed in 8 bytes. With the previous approach, we need 32 bytes for this.
This patch adds overlapping registers that allows us to address register at different offset, there's a mapping between the register and the byte offset:
int reg_to_offset[NFT_REG_ADDR_MAX] = {
/* 128-bits addressing */
[NFT_REG_VERDICT] = 0,
[NFT_REG_1] = 4,
[NFT_REG_2] = 8,
[NFT_REG_3] = 12,
[NFT_REG_4] = 16,
/* 64-bits addressing */
[NFT_REG_5] = 0, /* NFT_REG_VERDICT */
[NFT_REG_6] = 2, /* NFT_REG_VERDICT */
[NFT_REG_7] = 4,
[NFT_REG_8] = 6,
[NFT_REG_9] = 8,
[NFT_REG_10] = 10,
[NFT_REG_11] = 12,
[NFT_REG_12] = 14,
[NFT_REG_13] = 16,
[NFT_REG_14] = 18,
/* 32-bits addressing */
[NFT_REG_15] = 0, /* NFT_REG_VERDICT */
[NFT_REG_16] = 1, /* NFT_REG_VERDICT */
[NFT_REG_17] = 2, /* NFT_REG_VERDICT */
[NFT_REG_18] = 3, /* NFT_REG_VERDICT */
[NFT_REG_19] = 4,
[NFT_REG_20] = 5,
[NFT_REG_21] = 6,
[NFT_REG_22] = 7,
[NFT_REG_23] = 8,
[NFT_REG_24] = 9,
[NFT_REG_25] = 10,
[NFT_REG_26] = 11,
[NFT_REG_27] = 12,
[NFT_REG_28] = 13,
[NFT_REG_29] = 14,
[NFT_REG_30] = 15,
[NFT_REG_31] = 16,
[NFT_REG_32] = 17,
[NFT_REG_33] = 18,
[NFT_REG_34] = 19,
};There's some extra runtime overhead which involves the translation from register to byte offset. In user-space, there's some extra complexity in the register allocation as we have to explicitly request to enter 32-bits addressing, and go back to default 128-bits when needed.
--- include/net/netfilter/nf_tables.h | 16 +++++- include/uapi/linux/netfilter/nf_tables.h | 35 ++++++++++++- net/netfilter/nf_tables_api.c | 4 +- net/netfilter/nf_tables_core.c | 81 +++++++++++++++++++++++------- net/netfilter/nft_bitwise.c | 10 ++-- net/netfilter/nft_byteorder.c | 10 ++-- net/netfilter/nft_cmp.c | 8 +-- net/netfilter/nft_compat.c | 16 +++--- net/netfilter/nft_ct.c | 35 +++++++------ net/netfilter/nft_exthdr.c | 9 ++-- net/netfilter/nft_hash.c | 13 +++-- net/netfilter/nft_immediate.c | 5 +- net/netfilter/nft_limit.c | 5 +- net/netfilter/nft_log.c | 3 +- net/netfilter/nft_lookup.c | 9 ++-- net/netfilter/nft_meta.c | 37 +++++++------- net/netfilter/nft_nat.c | 27 +++++----- net/netfilter/nft_payload.c | 9 ++-- net/netfilter/nft_rbtree.c | 5 +- 19 files changed, 207 insertions(+), 130 deletions(-)
include/net/netfilter/nf_tables.h +14 -2
@@ -65,6 +65,18 @@ static inline void nft_data_debug(const struct nft_data *data) data->data[2], data->data[3]); } +union nft_regset { +struct nft_data data[NFT_REG_MAX +1 ]; +u32 word[(NFT_REG_MAX +1 ) *sizeof (u32)]; +}; + +extern int reg_to_offset[]; + +static inline u32 *get_reg_offset (union nft_regset *rs,u32 regnum) +{ +return &rs->word[reg_to_offset[regnum]]; +} +/** * struct nft_ctx - nf_tables rule/set context *
@@ -161,7 +173,7 @@ struct nft_set_iter {*/ struct nft_set_ops {bool (*lookup)(const struct nft_set *set, -const struct nft_data *key, +const u32 *key,struct nft_data *data);int (*get)(const struct nft_set *set,struct nft_set_elem *elem);
@@ -280,7 +292,7 @@ struct nft_expr_type {struct nft_expr ;struct nft_expr_ops {void (*eval)(const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +union nft_regset *rs,const struct nft_pktinfo *pkt);unsigned int size;
include/uapi/linux/netfilter/nf_tables.h +34 -1
@@ -9,7 +9,40 @@ enum nft_registers {NFT_REG_2 ,NFT_REG_3 ,NFT_REG_4 , - __NFT_REG_MAX + __NFT_REG_MAX, +/* 64 bits addressing */ +NFT_REG_5 = __NFT_REG_MAX, +NFT_REG_6 , +NFT_REG_7 , +NFT_REG_8 , +NFT_REG_9 , +NFT_REG_10 , +NFT_REG_11 , +NFT_REG_12 , +NFT_REG_13 , +NFT_REG_14 , +/* 32 bits addressing */ +NFT_REG_15 , +NFT_REG_16 , +NFT_REG_17 , +NFT_REG_18 , +NFT_REG_19 , +NFT_REG_20 , +NFT_REG_21 , +NFT_REG_22 , +NFT_REG_23 , +NFT_REG_24 , +NFT_REG_25 , +NFT_REG_26 , +NFT_REG_27 , +NFT_REG_28 , +NFT_REG_29 , +NFT_REG_30 , +NFT_REG_31 , +NFT_REG_32 , +NFT_REG_33 , +NFT_REG_34 , + NFT_REG_ADDR_MAX, };#define NFT_REG_MAX (__NFT_REG_MAX - 1)
net/netfilter/nf_tables_api.c +2 -2
@@ -2953,7 +2953,7 @@ int nft_validate_input_register(enum nft_registers reg) {if (reg <=NFT_REG_VERDICT )return -EINVAL ; -if (reg >NFT_REG_MAX ) +if (reg >NFT_REG_ADDR_MAX )return -ERANGE ;return 0 ; }
@@ -2971,7 +2971,7 @@ int nft_validate_output_register(enum nft_registers reg) {if (reg <NFT_REG_VERDICT )return -EINVAL ; -if (reg >NFT_REG_MAX ) +if (reg >NFT_REG_ADDR_MAX )return -ERANGE ;return 0 ; }
net/netfilter/nf_tables_core.c +62 -19
156 lines not on this page · raw message
net/netfilter/nft_bitwise.c +4 -6
@@ -25,18 +25,16 @@ struct nft_bitwise {struct nft_data xor; }; -static void nft_bitwise_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_bitwise_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_bitwise *priv =nft_expr_priv (expr); -const struct nft_data *src = &data[priv->sreg]; -struct nft_data *dst = &data[priv->dreg]; +const u32 *src =get_reg_offset (rs, priv->sreg); +u32 *dst =get_reg_offset (rs, priv->dreg);unsigned int i;for (i =0 ; i <DIV_ROUND_UP (priv->len,4 ); i++) { - dst->data[i] = (src->data[i] & priv->mask.data[i]) ^ - priv->xor.data[i]; + dst[i] = (src[i] & priv->mask.data[i]) ^ priv->xor.data[i]; } }
net/netfilter/nft_byteorder.c +4 -6
@@ -26,17 +26,15 @@ struct nft_byteorder { };static void nft_byteorder_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_byteorder *priv =nft_expr_priv (expr); -struct nft_data *src = &data[priv->sreg], *dst = &data[priv->dreg]; -union {u32 u32;u16 u16; } *s, *d; +u32 *src =get_reg_offset (rs, priv->sreg); +u32 *dst =get_reg_offset (rs, priv->dreg); +union {u32 u32;u16 u16; } *s = (void *)src, *d = (void *)dst;unsigned int i; - s = (void *)src->data; - d = (void *)dst->data; -switch (priv->size) {case 4 :switch (priv->op) {
net/netfilter/nft_cmp.c +4 -4
@@ -24,14 +24,14 @@ struct nft_cmp_expr { enum nft_cmp_ops op:8; }; -static void nft_cmp_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_cmp_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_cmp_expr *priv =nft_expr_priv (expr); +u32 *src =get_reg_offset (rs, priv->sreg);int d; - d =nft_data_cmp (&data[priv->sreg], &priv->data, priv->len); + d =memcmp (src, &priv->data, priv->len);switch (priv->op) {case NFT_CMP_EQ :if (d !=0 )
@@ -59,7 +59,7 @@ static void nft_cmp_eval(const struct nft_expr *expr,return ; mismatch: - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_cmp_policy[NFTA_CMP_MAX +1 ] = {
net/netfilter/nft_compat.c +7 -9
@@ -35,8 +35,7 @@ nft_compat_set_par(struct xt_action_param *par, void *xt, const void *xt_info) par->hotdrop = false; } -static void nft_target_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_target_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {void *info =nft_expr_priv (expr);
@@ -53,10 +52,10 @@ static void nft_target_eval(const struct nft_expr *expr,switch (ret) {case XT_CONTINUE : - data[NFT_REG_VERDICT ].verdict =NFT_CONTINUE ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_CONTINUE ;break ;default : - data[NFT_REG_VERDICT ].verdict = ret; + rs->data[NFT_REG_VERDICT ].verdict = ret;break ; }return ;
@@ -261,8 +260,7 @@ static int nft_target_validate(const struct nft_ctx *ctx,return 0 ; } -static void nft_match_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_match_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {void *info =nft_expr_priv (expr);
@@ -275,16 +273,16 @@ static void nft_match_eval(const struct nft_expr *expr, ret = match->match (skb, (struct xt_action_param *)&pkt->xt);if (pkt->xt.hotdrop) { - data[NFT_REG_VERDICT ].verdict =NF_DROP ; + rs->data[NFT_REG_VERDICT ].verdict =NF_DROP ;return ; }switch (ret) {case true: - data[NFT_REG_VERDICT ].verdict =NFT_CONTINUE ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_CONTINUE ;break ;case false: - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ;break ; } }
net/netfilter/nft_ct.c +17 -18
@@ -26,12 +26,11 @@ struct nft_ct {uint8_t family; }; -static void nft_ct_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_ct_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_ct *priv =nft_expr_priv (expr); -struct nft_data *dest = &data[priv->dreg]; +u32 *dest =get_reg_offset (rs, priv->dreg);enum ip_conntrack_info ctinfo;const struct nf_conn *ct;const struct nf_conn_help *help;
@@ -50,7 +49,7 @@ static void nft_ct_eval(const struct nft_expr *expr, state =NF_CT_STATE_UNTRACKED_BIT ; else state =NF_CT_STATE_BIT (ctinfo); - dest->data[0 ] = state; + dest[0 ] = state;return ; }
@@ -59,26 +58,26 @@ static void nft_ct_eval(const struct nft_expr *expr,switch (priv->key) {case NFT_CT_DIRECTION : - dest->data[0 ] =CTINFO2DIR (ctinfo); + dest[0 ] =CTINFO2DIR (ctinfo);return ;case NFT_CT_STATUS : - dest->data[0 ] = ct->status; + dest[0 ] = ct->status;return ;#ifdef CONFIG_NF_CONNTRACK_MARK case NFT_CT_MARK : - dest->data[0 ] = ct->mark; + dest[0 ] = ct->mark;return ;#endif #ifdef CONFIG_NF_CONNTRACK_SECMARK case NFT_CT_SECMARK : - dest->data[0 ] = ct->secmark; + dest[0 ] = ct->secmark;return ;#endif case NFT_CT_EXPIRATION : diff = (long )jiffies - (long )ct->timeout.expires;if (diff <0 ) diff =0 ; - dest->data[0 ] =jiffies_to_msecs (diff); + dest[0 ] =jiffies_to_msecs (diff);return ;case NFT_CT_HELPER :if (ct->master ==NULL )
@@ -89,38 +88,38 @@ static void nft_ct_eval(const struct nft_expr *expr, helper =rcu_dereference (help->helper);if (helper ==NULL ) goto err; -if (strlen (helper->name) >=sizeof (dest->data)) +if (strlen (helper->name) >=sizeof (struct nft_data )) goto err; -strncpy ((char *)dest->data, helper->name,sizeof (dest->data)); +strncpy ((char *)dest, helper->name,sizeof (struct nft_data ));return ; } tuple = &ct->tuplehash[priv->dir].tuple;switch (priv->key) {case NFT_CT_L3PROTOCOL : - dest->data[0 ] =nf_ct_l3num (ct); + dest[0 ] =nf_ct_l3num (ct);return ;case NFT_CT_SRC : -memcpy (dest->data, tuple->src.u3.all, +memcpy (dest, tuple->src.u3.all,nf_ct_l3num (ct) ==NFPROTO_IPV4 ?4 :16 );return ;case NFT_CT_DST : -memcpy (dest->data, tuple->dst.u3.all, +memcpy (dest, tuple->dst.u3.all,nf_ct_l3num (ct) ==NFPROTO_IPV4 ?4 :16 );return ;case NFT_CT_PROTOCOL : - dest->data[0 ] =nf_ct_protonum (ct); + dest[0 ] =nf_ct_protonum (ct);return ;case NFT_CT_PROTO_SRC : - dest->data[0 ] = (__force __u16 )tuple->src.u.all; + dest[0 ] = (__force __u16 )tuple->src.u.all;return ;case NFT_CT_PROTO_DST : - dest->data[0 ] = (__force __u16 )tuple->dst.u.all; + dest[0 ] = (__force __u16 )tuple->dst.u.all;return ; }return ; err: - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_ct_policy[NFTA_CT_MAX +1 ] = {
net/netfilter/nft_exthdr.c +4 -5
@@ -25,12 +25,11 @@ struct nft_exthdr { enum nft_registers dreg:8; }; -static void nft_exthdr_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_exthdr_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {struct nft_exthdr *priv =nft_expr_priv (expr); -struct nft_data *dest = &data[priv->dreg]; +u32 *dest =get_reg_offset (rs, priv->dreg);unsigned int offset;int err;
@@ -39,11 +38,11 @@ static void nft_exthdr_eval(const struct nft_expr *expr, goto err; offset += priv->offset; -if (skb_copy_bits (pkt->skb, offset, dest->data, priv->len) <0 ) +if (skb_copy_bits (pkt->skb, offset, dest, priv->len) <0 ) goto err;return ; err: - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_exthdr_policy[NFTA_EXTHDR_MAX +1 ] = {
net/netfilter/nft_hash.c +6 -7
@@ -32,18 +32,17 @@ struct nft_hash_elem {static u32 nft_hash_rnd__read_mostly ;static bool nft_hash_rnd_initted__read_mostly ; -static unsigned int nft_hash_data (const struct nft_data *data, +static unsigned int nft_hash_data (const u32 *data,unsigned int hsize,unsigned int len) {unsigned int h; - h =jhash (data->data, len, nft_hash_rnd); + h =jhash (data, len, nft_hash_rnd);return ((u64 )h * hsize) >>32 ; }static bool nft_hash_lookup (const struct nft_set *set, -const struct nft_data *key, -struct nft_data *data) +const u32 *key,struct nft_data *data) {const struct nft_hash *priv =nft_set_priv (set);const struct nft_hash_elem *he;
@@ -51,7 +50,7 @@ static bool nft_hash_lookup(const struct nft_set *set, h =nft_hash_data (key, priv->hsize, set->klen);hlist_for_each_entry (he, &priv->hash[h], hnode) { -if (nft_data_cmp (&he->key, key, set->klen)) +if (memcmp (&he->key, key, set->klen) !=0 )continue ;if (set->flags &NFT_SET_MAP )nft_data_copy (data, he->data);
@@ -91,7 +90,7 @@ static int nft_hash_insert(const struct nft_set *set,if (set->flags &NFT_SET_MAP )nft_data_copy (he->data, &elem->data); - h =nft_hash_data (&he->key, priv->hsize, set->klen); + h =nft_hash_data ((u32 *)&he->key, priv->hsize, set->klen);hlist_add_head_rcu (&he->hnode, &priv->hash[h]);return 0 ; }
@@ -111,7 +110,7 @@ static int nft_hash_get(const struct nft_set *set, struct nft_set_elem *elem)struct nft_hash_elem *he;unsigned int h; - h =nft_hash_data (&elem->key, priv->hsize, set->klen); + h =nft_hash_data ((u32 *)&elem->key, priv->hsize, set->klen);hlist_for_each_entry (he, &priv->hash[h], hnode) {if (nft_data_cmp (&he->key, &elem->key, set->klen))continue ;
net/netfilter/nft_immediate.c +3 -2
@@ -24,12 +24,13 @@ struct nft_immediate_expr { };static void nft_immediate_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_immediate_expr *priv =nft_expr_priv (expr); +u32 *dest =get_reg_offset (rs, priv->dreg); -nft_data_copy (&data[priv->dreg], &priv->data); +memcpy (dest, &priv->data,sizeof (struct nft_data )); }static const struct nla_policy nft_immediate_policy[NFTA_IMMEDIATE_MAX +1 ] = {
net/netfilter/nft_limit.c +2 -3
@@ -26,8 +26,7 @@ struct nft_limit {unsigned long stamp; }; -static void nft_limit_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_limit_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {struct nft_limit *priv =nft_expr_priv (expr);
@@ -45,7 +44,7 @@ static void nft_limit_eval(const struct nft_expr *expr, }spin_unlock_bh (&limit_lock); - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_limit_policy[NFTA_LIMIT_MAX +1 ] = {
net/netfilter/nft_log.c +1 -2
@@ -26,8 +26,7 @@ struct nft_log {int family; }; -static void nft_log_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_log_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_log *priv =nft_expr_priv (expr);
net/netfilter/nft_lookup.c +5 -4
@@ -24,16 +24,17 @@ struct nft_lookup {struct nft_set_binding binding; }; -static void nft_lookup_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_lookup_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_lookup *priv =nft_expr_priv (expr);const struct nft_set *set = priv->set; +u32 *src =get_reg_offset (rs, priv->sreg); +u32 *dst =get_reg_offset (rs, priv->dreg); -if (set->ops->lookup (set, &data[priv->sreg], &data[priv->dreg])) +if (set->ops->lookup (set, src, (struct nft_data *)dst))return ; - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_lookup_policy[NFTA_LOOKUP_MAX +1 ] = {
net/netfilter/nft_meta.c +17 -20
@@ -25,56 +25,55 @@ struct nft_meta { };static void nft_meta_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], -const struct nft_pktinfo *pkt) +union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_meta *priv =nft_expr_priv (expr);const struct sk_buff *skb = pkt->skb;const struct net_device *in = pkt->in, *out = pkt->out; -struct nft_data *dest = &data[priv->dreg]; +u32 *dest =get_reg_offset (rs, priv->dreg);switch (priv->key) {case NFT_META_LEN : - dest->data[0 ] = skb->len; + dest[0 ] = skb->len;break ;case NFT_META_PROTOCOL : - *(__be16 *)dest->data = skb->protocol; + *(__be16 *)dest = skb->protocol;break ;case NFT_META_PRIORITY : - dest->data[0 ] = skb->priority; + dest[0 ] = skb->priority;break ;case NFT_META_MARK : - dest->data[0 ] = skb->mark; + dest[0 ] = skb->mark;break ;case NFT_META_IIF :if (in ==NULL ) goto err; - dest->data[0 ] = in->ifindex; + dest[0 ] = in->ifindex;break ;case NFT_META_OIF :if (out ==NULL ) goto err; - dest->data[0 ] = out->ifindex; + dest[0 ] = out->ifindex;break ;case NFT_META_IIFNAME :if (in ==NULL ) goto err; -strncpy ((char *)dest->data, in->name,sizeof (dest->data)); +strncpy ((char *)dest, in->name,sizeof (struct nft_data ));break ;case NFT_META_OIFNAME :if (out ==NULL ) goto err; -strncpy ((char *)dest->data, out->name,sizeof (dest->data)); +strncpy ((char *)dest, out->name,sizeof (struct nft_data ));break ;case NFT_META_IIFTYPE :if (in ==NULL ) goto err; - *(u16 *)dest->data = in->type; + *(u16 *)dest = in->type;break ;case NFT_META_OIFTYPE :if (out ==NULL ) goto err; - *(u16 *)dest->data = out->type; + *(u16 *)dest = out->type;break ;case NFT_META_SKUID :if (skb->sk ==NULL || skb->sk->sk_state ==TCP_TIME_WAIT )
@@ -87,8 +86,7 @@ static void nft_meta_eval(const struct nft_expr *expr, goto err; } - dest->data[0 ] = -from_kuid_munged (&init_user_ns, + dest[0 ] =from_kuid_munged (&init_user_ns, skb->sk->sk_socket->file->f_cred->fsuid);read_unlock_bh (&skb->sk->sk_callback_lock);break ;
@@ -102,8 +100,7 @@ static void nft_meta_eval(const struct nft_expr *expr,read_unlock_bh (&skb->sk->sk_callback_lock); goto err; } - dest->data[0 ] = -from_kgid_munged (&init_user_ns, + dest[0 ] =from_kgid_munged (&init_user_ns, skb->sk->sk_socket->file->f_cred->fsgid);read_unlock_bh (&skb->sk->sk_callback_lock);break ;
@@ -113,13 +110,13 @@ static void nft_meta_eval(const struct nft_expr *expr,if (dst ==NULL ) goto err; - dest->data[0 ] = dst->tclassid; + dest[0 ] = dst->tclassid; break; }#endif #ifdef CONFIG_NETWORK_SECMARK case NFT_META_SECMARK : - dest->data[0 ] = skb->secmark; + dest[0 ] = skb->secmark;break ;#endif default :
@@ -129,7 +126,7 @@ static void nft_meta_eval(const struct nft_expr *expr,return ; err: - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_meta_policy[NFTA_META_MAX +1 ] = {
net/netfilter/nft_nat.c +15 -12
@@ -1,6 +1,6 @@/* * Copyright (c) 2008-2009 Patrick McHardy <[email protected]> -* Copyright (c) 2012 Pablo Neira Ayuso <[email protected]> +* Copyright (c) 2012-2013 Pablo Neira Ayuso <[email protected]> * Copyright (c) 2012 Intel Corporation * * This program is free software; you can redistribute it and/or modify it
@@ -36,8 +36,7 @@ struct nft_nat { };static void nft_nat_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], -const struct nft_pktinfo *pkt) +union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_nat *priv =nft_expr_priv (expr);enum ip_conntrack_info ctinfo;
@@ -46,28 +45,32 @@ static void nft_nat_eval(const struct nft_expr *expr,memset (&range,0 ,sizeof (range));if (priv->sreg_addr_min) { +u32 *addr_min =get_reg_offset (rs, priv->sreg_addr_min), + *addr_max =get_reg_offset (rs, priv->sreg_addr_max); +if (priv->family ==AF_INET ) { - range.min_addr.ip = data[priv->sreg_addr_min].data[0 ]; - range.max_addr.ip = data[priv->sreg_addr_max].data[0 ]; + range.min_addr.ip = addr_min[0 ]; + range.max_addr.ip = addr_max[0 ]; }else { -memcpy (range.min_addr.ip6, - data[priv->sreg_addr_min].data, +memcpy (range.min_addr.ip6, addr_min,sizeof (struct nft_data )); -memcpy (range.max_addr.ip6, - data[priv->sreg_addr_max].data, +memcpy (range.max_addr.ip6, addr_max,sizeof (struct nft_data )); } range.flags |=NF_NAT_RANGE_MAP_IPS ; }if (priv->sreg_proto_min) { - range.min_proto.all = data[priv->sreg_proto_min].data[0 ]; - range.max_proto.all = data[priv->sreg_proto_max].data[0 ]; +u32 *proto_min =get_reg_offset (rs, priv->sreg_proto_min), + *proto_max =get_reg_offset (rs, priv->sreg_proto_max); + + range.min_proto.all = proto_min[0 ]; + range.max_proto.all = proto_max[0 ]; range.flags |=NF_NAT_RANGE_PROTO_SPECIFIED ; } - data[NFT_REG_VERDICT ].verdict = + rs->data[NFT_REG_VERDICT ].verdict =nf_nat_setup_info (ct, &range, priv->type); }
net/netfilter/nft_payload.c +4 -5
@@ -17,13 +17,12 @@#include <net/netfilter/nf_tables_core.h> #include <net/netfilter/nf_tables.h> -static void nft_payload_eval (const struct nft_expr *expr, -struct nft_data data[NFT_REG_MAX +1 ], +static void nft_payload_eval (const struct nft_expr *expr,union nft_regset *rs,const struct nft_pktinfo *pkt) {const struct nft_payload *priv =nft_expr_priv (expr);const struct sk_buff *skb = pkt->skb; -struct nft_data *dest = &data[priv->dreg]; +u32 *dest =get_reg_offset (rs, priv->dreg);int offset;switch (priv->base) {
@@ -43,11 +42,11 @@ static void nft_payload_eval(const struct nft_expr *expr, } offset += priv->offset; -if (skb_copy_bits (skb, offset, dest->data, priv->len) <0 ) +if (skb_copy_bits (skb, offset, dest, priv->len) <0 ) goto err;return ; err: - data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; + rs->data[NFT_REG_VERDICT ].verdict =NFT_BREAK ; }static const struct nla_policy nft_payload_policy[NFTA_PAYLOAD_MAX +1 ] = {
net/netfilter/nft_rbtree.c +2 -3
@@ -30,8 +30,7 @@ struct nft_rbtree_elem { };static bool nft_rbtree_lookup (const struct nft_set *set, -const struct nft_data *key, -struct nft_data *data) +const u32 *key,struct nft_data *data) {const struct nft_rbtree *priv =nft_set_priv (set);const struct nft_rbtree_elem *rbe, *interval =NULL ;
@@ -41,7 +40,7 @@ static bool nft_rbtree_lookup(const struct nft_set *set,while (parent !=NULL ) { rbe = rb_entry(parent, struct nft_rbtree_elem, node); - d =nft_data_cmp (&rbe->key, key, set->klen); + d =memcmp (&rbe->key, key, set->klen);if (d <0 ) { parent = parent->rb_left; interval = rbe;
Signature · 1 line
1.7.10.4
Pablo Neira Ayuso
maintainerRFC PATCH 2/2 netfilter: nf_tables: round to 32 bits in payload operations
In reply to Pablo Neira AyusoIf you need to fetch less than 32 bits, round it up to 32 bits to make sure that it zeroes the remaining part of the register.
This changes is required by concatenations.
--- net/netfilter/nf_tables_core.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
net/netfilter/nf_tables_core.c +3 -3
@@ -54,11 +54,11 @@ static bool nft_payload_fast_eval(const struct nft_expr *expr,return false;if (priv->len ==2 ) - *(u16 *)dest = *(u16 *)ptr; + *dest = *(u16 *)ptr;else if (priv->len ==4 ) - *(u32 *)dest = *(u32 *)ptr; + *dest = *(u32 *)ptr;else - *(u8 *)dest = *(u8 *)ptr; + *dest = *(u8 *)ptr;return true; }
Signature · 1 line
1.7.10.4
Pablo Neira Ayuso
maintainerRFC PATCH 1/1 src: finish concatenation support using the set infrastructure
In reply to Pablo Neira AyusoThis patch finished the concatenation support using the set infrastructure, eg.
nft add rule ip filter output ip saddr . ip daddr { 192.168.1.128 . 8.8.8.8 } counter nft add rule ip filter output ip saddr . tcp dport { 192.168.1.128 . 80 } counter
You can basically use any combination of existing selectors that are offered by nft.
NOTE: This patch is incomplete, as map and mappings are not yet supported. This also requires the 32/64/128 bits registerd addressing.
--- include/linux/netfilter/nf_tables.h | 35 ++++++++- include/utils.h | 2 + src/evaluate.c | 7 +- src/netlink.c | 15 +++- src/netlink_linearize.c | 140 +++++++++++++++++++++++++++++++++-- 5 files changed, 190 insertions(+), 9 deletions(-)
include/linux/netfilter/nf_tables.h +34 -1
@@ -9,7 +9,40 @@ enum nft_registers {NFT_REG_2 ,NFT_REG_3 ,NFT_REG_4 , - __NFT_REG_MAX + __NFT_REG_MAX, +/* 64 bits addressing */ +NFT_REG_5 = __NFT_REG_MAX, +NFT_REG_6 , +NFT_REG_7 , +NFT_REG_8 , +NFT_REG_9 , +NFT_REG_10 , +NFT_REG_11 , +NFT_REG_12 , +NFT_REG_13 , +NFT_REG_14 , +/* 32 bits addressing */ +NFT_REG_15 , +NFT_REG_16 , +NFT_REG_17 , +NFT_REG_18 , +NFT_REG_19 , +NFT_REG_20 , +NFT_REG_21 , +NFT_REG_22 , +NFT_REG_23 , +NFT_REG_24 , +NFT_REG_25 , +NFT_REG_26 , +NFT_REG_27 , +NFT_REG_28 , +NFT_REG_29 , +NFT_REG_30 , +NFT_REG_31 , +NFT_REG_32 , +NFT_REG_33 , +NFT_REG_34 , + NFT_REG_ADDR_MAX, };#define NFT_REG_MAX (__NFT_REG_MAX - 1)
include/utils.h +2 -0
@@ -62,6 +62,8 @@ (void ) (&_max1 == &_max2); \ _max1 > _max2 ? _max1 : _max2; }) +#define ALIGN (len, x) ( ((len)+(x)-1) & ~((x)-1) ) +extern void memory_allocation_error (void )__noreturn ;extern void xfree (const void *ptr);
src/evaluate.c +6 -1
@@ -585,11 +585,13 @@ static int list_member_evaluate(struct eval_ctx *ctx, struct expr **expr)return err; } +#define ALIGN (len, x) ( ((len)+(x)-1) & ~((x)-1) ) +static int expr_evaluate_concat (struct eval_ctx *ctx,struct expr **expr) {const struct datatype *dtype = ctx->ectx.dtype, *tmp;unsigned int type = dtype ? dtype->type :0 ; -int off = dtype ? dtype->size:0 ; +int off = dtype ? dtype->size:0 , len =0 ;unsigned int flags =EXPR_F_CONSTANT |EXPR_F_SINGLETON ;struct expr *i, *next;unsigned int n;
@@ -606,6 +608,8 @@ static int expr_evaluate_concat(struct eval_ctx *ctx, struct expr **expr)if (list_member_evaluate (ctx, &i) <0 )return -1 ; + + len +=ALIGN (i->dtype->size,32 ); flags &= i->flags; n++;
@@ -613,6 +617,7 @@ static int expr_evaluate_concat(struct eval_ctx *ctx, struct expr **expr) (*expr)->flags |= flags; (*expr)->dtype =concat_type_alloc (*expr); + (*expr)->len = len;if (off >0 ) return expr_error(ctx, *expr,
src/netlink.c +13 -2
@@ -151,8 +151,19 @@ static struct nft_set_elem *alloc_nft_setelem(const struct expr *expr)netlink_gen_data (expr, &nld);nft_set_elem_attr_set (nlse,NFT_SET_ELEM_ATTR_KEY , &nld.value, nld.len); - }else { -assert (expr->ops->type ==EXPR_MAPPING ); + }else if (expr->ops->type ==EXPR_CONCAT ) { +struct expr *i; +struct nft_data_linearize nld2 = {}; + +list_for_each_entry (i, &expr->expressions, list) { +struct nft_data_linearize nld = {}; +netlink_gen_data (i, &nld); + nld2.len +=ALIGN (nld.len,4 ); +memcpy (&nld2.value[div_round_up (nld2.len,4 ) -1 ], nld.value, nld.len); + } +nft_set_elem_attr_set (nlse,NFT_SET_ELEM_ATTR_KEY , + &nld2.value, nld2.len); + }else if (expr->ops->type ==EXPR_MAPPING ) {netlink_gen_data (expr->left, &nld);nft_set_elem_attr_set (nlse,NFT_SET_ELEM_ATTR_KEY , &nld.value, nld.len);
src/netlink_linearize.c +135 -5
194 lines not on this page · raw message
Signature · 1 line
1.7.10.4
Quoted 8 lines · Pablo Neira Ayuso
This is a preliminary patchset to allow
nf_tablesto address registers at 32/64/128 bits word size. This is something that Patrick and I have been discussing for a while.The proposed approach in this patchset adds the new register addressing to the
nf_tablescore, the overlapping register approach describe in patch 1/2 is backward compatible.
Quoted 6 lines
Still missing a kernel patch to allow set elements higher than 128 bits, so we can have concatenations including IPv6 addresses, but that limitation should be easy to remove. Explicit set type selection is also required, currently, it is selecting the rb-tree set type here, which is suboptimal.
Comments welcome.
Thanks for looking into this. I'll review them tonight.