History

netfilter: nftables: add catch-all set element support

This patch extends the set infrastructure to add a special catch-all set element. If the lookup fails to find an element (or range) in the set, then the catch-all element is selected. Users can specify a mapping, expression(s) and timeout to be attached to the catch-all element. This patch adds a catchall list to the set, this list might contain more than one single catch-all element (e.g. in case that the catch-all element is removed and a new one is added in the same transaction). However, most of the time, there will be either one element or no elements at all in this list. The catch-all element is identified via NFT_SET_ELEM_CATCHALL flag and such special element has no NFTA_SET_ELEM_KEY attribute. There is a new nft_set_elem_catchall object that stores a reference to the dummy catch-all element (catchall->elem) whose layout is the same of the set element type to reuse the existing set element codebase. The set size does not apply to the catch-all element, users can define a catch-all element even if the set is full. The check for valid set element flags hava been updates to report EOPNOTSUPP in case userspace requests flags that are not supported when using new userspace nftables and old kernel.

Pablo Neira Ayuso committed 5 years ago

Commit aaa31041 parent 97c976d8 files · +465 −63Browse files

Unified · Split

8 files
  1. include/net/netfilter/nf_tables.h +5 −0
  2. include/uapi/linux/netfilter/nf_tables.h +2 −0
  3. net/netfilter/nf_tables_api.c +426 −54
  4. net/netfilter/nft_lookup.c +8 −4
  5. net/netfilter/nft_objref.c +7 −4
  6. net/netfilter/nft_set_hash.c +6 −0
  7. net/netfilter/nft_set_pipapo.c +5 −1
  8. net/netfilter/nft_set_rbtree.c +6 −0
include/net/netfilter/nf_tables.h+5−0
@@ -497,6 +497,7 @@ struct nft_set { · 496 unmodified lines
497497 u8 dlen;
498498 u8 num_exprs;
499499 struct nft_expr *exprs[NFT_SET_EXPR_MAX];
500+ struct list_head catchall_list;
500501 unsigned char data[]
501502 __attribute__((aligned(__alignof__(u64))));
502503 };
@@ -522,6 +523,10 @@ struct nft_set *nft_set_lookup_global(const struct net *net, · 19 unmodified lines
522523 const struct nlattr *nla_set_id,
523524 u8 genmask);
524525
526+struct nft_set_ext *nft_set_catchall_lookup(const struct net *net,
527+ const struct nft_set *set);
528+void *nft_set_catchall_gc(const struct nft_set *set);
529+
525530 static inline unsigned long nft_set_gc_interval(const struct nft_set *set)
526531 {
527532 return set->gc_int ? msecs_to_jiffies(set->gc_int) : HZ;
include/uapi/linux/netfilter/nf_tables.h+2−0
@@ -398,9 +398,11 @@ enum nft_set_attributes { · 397 unmodified lines
398398 * enum nft_set_elem_flags - nf_tables set element flags
399399 *
400400 * @NFT_SET_ELEM_INTERVAL_END: element ends the previous interval
401+ * @NFT_SET_ELEM_CATCHALL: special catch-all element
401402 */
402403 enum nft_set_elem_flags {
403404 NFT_SET_ELEM_INTERVAL_END = 0x1,
405+ NFT_SET_ELEM_CATCHALL = 0x2,
404406 };
405407
406408 /**
net/netfilter/nf_tables_api.c+426−54
@@ -4389,6 +4389,7 @@ static int nf_tables_newset(struct sk_buff *skb, const struct nfnl_info *info, · 4388 unmodified lines
43894389 }
43904390
43914391 INIT_LIST_HEAD(&set->bindings);
4392+ INIT_LIST_HEAD(&set->catchall_list);
43924393 set->table = table;
43934394 write_pnet(&set->net, net);
43944395 set->ops = ops;
@@ -4434,6 +4435,24 @@ err_set_name: · 39 unmodified lines
44344435 return err;
44354436 }
44364437
4438+struct nft_set_elem_catchall {
4439+ struct list_head list;
4440+ struct rcu_head rcu;
4441+ void *elem;
4442+};
4443+
4444+static void nft_set_catchall_destroy(const struct nft_ctx *ctx,
4445+ struct nft_set *set)
4446+{
4447+ struct nft_set_elem_catchall *catchall;
4448+
4449+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
4450+ list_del_rcu(&catchall->list);
4451+ nft_set_elem_destroy(set, catchall->elem, true);
4452+ kfree_rcu(catchall);
4453+ }
4454+}
4455+
44374456 static void nft_set_destroy(const struct nft_ctx *ctx, struct nft_set *set)
44384457 {
44394458 int i;
@@ -4445,6 +4464,7 @@ static void nft_set_destroy(const struct nft_ctx *ctx, struct nft_set *set) · 5 unmodified lines
44454464 nft_expr_destroy(ctx, set->exprs[i]);
44464465
44474466 set->ops->destroy(set);
4467+ nft_set_catchall_destroy(ctx, set);
44484468 kfree(set->name);
44494469 kvfree(set);
44504470 }
@@ -4521,6 +4541,29 @@ static int nf_tables_bind_check_setelem(const struct nft_ctx *ctx, · 70 unmodified lines
45214541 return nft_setelem_data_validate(ctx, set, elem);
45224542 }
45234543
4544+static int nft_set_catchall_bind_check(const struct nft_ctx *ctx,
4545+ struct nft_set *set)
4546+{
4547+ u8 genmask = nft_genmask_next(ctx->net);
4548+ struct nft_set_elem_catchall *catchall;
4549+ struct nft_set_elem elem;
4550+ struct nft_set_ext *ext;
4551+ int ret = 0;
4552+
4553+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
4554+ ext = nft_set_elem_ext(set, catchall->elem);
4555+ if (!nft_set_elem_active(ext, genmask))
4556+ continue;
4557+
4558+ elem.priv = catchall->elem;
4559+ ret = nft_setelem_data_validate(ctx, set, &elem);
4560+ if (ret < 0)
4561+ break;
4562+ }
4563+
4564+ return ret;
4565+}
4566+
45244567 int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set,
45254568 struct nft_set_binding *binding)
45264569 {
@@ -4550,6 +4593,9 @@ int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set, · 23 unmodified lines
45504593 iter.fn = nf_tables_bind_check_setelem;
45514594
45524595 set->ops->walk(ctx, set, &iter);
4596+ if (!iter.err)
4597+ iter.err = nft_set_catchall_bind_check(ctx, set);
4598+
45534599 if (iter.err < 0)
45544600 return iter.err;
45554601 }
@@ -4736,7 +4782,8 @@ static int nf_tables_fill_setelem(struct sk_buff *skb, · 180 unmodified lines
47364782 if (nest == NULL)
47374783 goto nla_put_failure;
47384784
4739− if (nft_data_dump(skb, NFTA_SET_ELEM_KEY, nft_set_ext_key(ext),
4785+ if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY) &&
4786+ nft_data_dump(skb, NFTA_SET_ELEM_KEY, nft_set_ext_key(ext),
47404787 NFT_DATA_VALUE, set->klen) < 0)
47414788 goto nla_put_failure;
47424789
@@ -4825,6 +4872,29 @@ struct nft_set_dump_ctx { · 82 unmodified lines
48254872 struct nft_ctx ctx;
48264873 };
48274874
4875+static int nft_set_catchall_dump(struct net *net, struct sk_buff *skb,
4876+ const struct nft_set *set)
4877+{
4878+ struct nft_set_elem_catchall *catchall;
4879+ u8 genmask = nft_genmask_cur(net);
4880+ struct nft_set_elem elem;
4881+ struct nft_set_ext *ext;
4882+ int ret = 0;
4883+
4884+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
4885+ ext = nft_set_elem_ext(set, catchall->elem);
4886+ if (!nft_set_elem_active(ext, genmask) ||
4887+ nft_set_elem_expired(ext))
4888+ continue;
4889+
4890+ elem.priv = catchall->elem;
4891+ ret = nf_tables_fill_setelem(skb, set, &elem);
4892+ break;
4893+ }
4894+
4895+ return ret;
4896+}
4897+
48284898 static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb)
48294899 {
48304900 struct nft_set_dump_ctx *dump_ctx = cb->data;
@@ -4889,6 +4959,9 @@ static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb) · 58 unmodified lines
48894959 args.iter.err = 0;
48904960 args.iter.fn = nf_tables_dump_setelem;
48914961 set->ops->walk(&dump_ctx->ctx, set, &args.iter);
4962+
4963+ if (!args.iter.err && args.iter.count == cb->args[0])
4964+ args.iter.err = nft_set_catchall_dump(net, skb, set);
48924965 rcu_read_unlock();
48934966
48944967 nla_nest_end(skb, nest);
@@ -4968,8 +5041,8 @@ static int nft_setelem_parse_flags(const struct nft_set *set, · 73 unmodified lines
49685041 return 0;
49695042
49705043 *flags = ntohl(nla_get_be32(attr));
4971− if (*flags & ~NFT_SET_ELEM_INTERVAL_END)
4972− return -EINVAL;
5044+ if (*flags & ~(NFT_SET_ELEM_INTERVAL_END | NFT_SET_ELEM_CATCHALL))
5045+ return -EOPNOTSUPP;
49735046 if (!(set->flags & NFT_SET_INTERVAL) &&
49745047 *flags & NFT_SET_ELEM_INTERVAL_END)
49755048 return -EINVAL;
@@ -5014,6 +5087,46 @@ static int nft_setelem_parse_data(struct nft_ctx *ctx, struct nft_set *set, · 38 unmodified lines
50145087 return 0;
50155088 }
50165089
5090+static void *nft_setelem_catchall_get(const struct net *net,
5091+ const struct nft_set *set)
5092+{
5093+ struct nft_set_elem_catchall *catchall;
5094+ u8 genmask = nft_genmask_cur(net);
5095+ struct nft_set_ext *ext;
5096+ void *priv = NULL;
5097+
5098+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
5099+ ext = nft_set_elem_ext(set, catchall->elem);
5100+ if (!nft_set_elem_active(ext, genmask) ||
5101+ nft_set_elem_expired(ext))
5102+ continue;
5103+
5104+ priv = catchall->elem;
5105+ break;
5106+ }
5107+
5108+ return priv;
5109+}
5110+
5111+static int nft_setelem_get(struct nft_ctx *ctx, struct nft_set *set,
5112+ struct nft_set_elem *elem, u32 flags)
5113+{
5114+ void *priv;
5115+
5116+ if (!(flags & NFT_SET_ELEM_CATCHALL)) {
5117+ priv = set->ops->get(ctx->net, set, elem, flags);
5118+ if (IS_ERR(priv))
5119+ return PTR_ERR(priv);
5120+ } else {
5121+ priv = nft_setelem_catchall_get(ctx->net, set);
5122+ if (!priv)
5123+ return -ENOENT;
5124+ }
5125+ elem->priv = priv;
5126+
5127+ return 0;
5128+}
5129+
50175130 static int nft_get_set_elem(struct nft_ctx *ctx, struct nft_set *set,
50185131 const struct nlattr *attr)
50195132 {
@@ -5021,7 +5134,6 @@ static int nft_get_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 1 unmodified line
50215134 struct nft_set_elem elem;
50225135 struct sk_buff *skb;
50235136 uint32_t flags = 0;
5024− void *priv;
50255137 int err;
50265138
50275139 err = nla_parse_nested_deprecated(nla, NFTA_SET_ELEM_MAX, attr,
@@ -5029,17 +5141,19 @@ static int nft_get_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 1 unmodified line
50295141 if (err < 0)
50305142 return err;
50315143
5032− if (!nla[NFTA_SET_ELEM_KEY])
5033− return -EINVAL;
5034−
50355144 err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
50365145 if (err < 0)
50375146 return err;
50385147
5039− err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5040− nla[NFTA_SET_ELEM_KEY]);
5041− if (err < 0)
5042− return err;
5148+ if (!nla[NFTA_SET_ELEM_KEY] && !(flags & NFT_SET_ELEM_CATCHALL))
5149+ return -EINVAL;
5150+
5151+ if (nla[NFTA_SET_ELEM_KEY]) {
5152+ err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5153+ nla[NFTA_SET_ELEM_KEY]);
5154+ if (err < 0)
5155+ return err;
5156+ }
50435157
50445158 if (nla[NFTA_SET_ELEM_KEY_END]) {
50455159 err = nft_setelem_parse_key(ctx, set, &elem.key_end.val,
@@ -5048,11 +5162,9 @@ static int nft_get_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 2 unmodified lines
50485162 return err;
50495163 }
50505164
5051− priv = set->ops->get(ctx->net, set, &elem, flags);
5052− if (IS_ERR(priv))
5053− return PTR_ERR(priv);
5054−
5055− elem.priv = priv;
5165+ err = nft_setelem_get(ctx, set, &elem, flags);
5166+ if (err < 0)
5167+ return err;
50565168
50575169 err = -ENOMEM;
50585170 skb = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
@@ -5212,7 +5324,8 @@ void *nft_set_elem_init(const struct nft_set *set, · 153 unmodified lines
52125324 ext = nft_set_elem_ext(set, elem);
52135325 nft_set_ext_init(ext, tmpl);
52145326
5215− memcpy(nft_set_ext_key(ext), key, set->klen);
5327+ if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY))
5328+ memcpy(nft_set_ext_key(ext), key, set->klen);
52165329 if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY_END))
52175330 memcpy(nft_set_ext_key_end(ext), key_end, set->klen);
52185331 if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
@@ -5343,6 +5456,192 @@ err_elem_expr_setup: · 124 unmodified lines
53435456 return -ENOMEM;
53445457 }
53455458
5459+struct nft_set_ext *nft_set_catchall_lookup(const struct net *net,
5460+ const struct nft_set *set)
5461+{
5462+ struct nft_set_elem_catchall *catchall;
5463+ u8 genmask = nft_genmask_cur(net);
5464+ struct nft_set_ext *ext;
5465+
5466+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
5467+ ext = nft_set_elem_ext(set, catchall->elem);
5468+ if (nft_set_elem_active(ext, genmask) &&
5469+ !nft_set_elem_expired(ext))
5470+ return ext;
5471+ }
5472+
5473+ return NULL;
5474+}
5475+EXPORT_SYMBOL_GPL(nft_set_catchall_lookup);
5476+
5477+void *nft_set_catchall_gc(const struct nft_set *set)
5478+{
5479+ struct nft_set_elem_catchall *catchall, *next;
5480+ struct nft_set_ext *ext;
5481+ void *elem = NULL;
5482+
5483+ list_for_each_entry_safe(catchall, next, &set->catchall_list, list) {
5484+ ext = nft_set_elem_ext(set, catchall->elem);
5485+
5486+ if (!nft_set_elem_expired(ext) ||
5487+ nft_set_elem_mark_busy(ext))
5488+ continue;
5489+
5490+ elem = catchall->elem;
5491+ list_del_rcu(&catchall->list);
5492+ kfree_rcu(catchall, rcu);
5493+ break;
5494+ }
5495+
5496+ return elem;
5497+}
5498+EXPORT_SYMBOL_GPL(nft_set_catchall_gc);
5499+
5500+static int nft_setelem_catchall_insert(const struct net *net,
5501+ struct nft_set *set,
5502+ const struct nft_set_elem *elem,
5503+ struct nft_set_ext **pext)
5504+{
5505+ struct nft_set_elem_catchall *catchall;
5506+ u8 genmask = nft_genmask_next(net);
5507+ struct nft_set_ext *ext;
5508+
5509+ list_for_each_entry(catchall, &set->catchall_list, list) {
5510+ ext = nft_set_elem_ext(set, catchall->elem);
5511+ if (nft_set_elem_active(ext, genmask)) {
5512+ *pext = ext;
5513+ return -EEXIST;
5514+ }
5515+ }
5516+
5517+ catchall = kmalloc(sizeof(*catchall), GFP_KERNEL);
5518+ if (!catchall)
5519+ return -ENOMEM;
5520+
5521+ catchall->elem = elem->priv;
5522+ list_add_tail_rcu(&catchall->list, &set->catchall_list);
5523+
5524+ return 0;
5525+}
5526+
5527+static int nft_setelem_insert(const struct net *net,
5528+ struct nft_set *set,
5529+ const struct nft_set_elem *elem,
5530+ struct nft_set_ext **ext, unsigned int flags)
5531+{
5532+ int ret;
5533+
5534+ if (flags & NFT_SET_ELEM_CATCHALL)
5535+ ret = nft_setelem_catchall_insert(net, set, elem, ext);
5536+ else
5537+ ret = set->ops->insert(net, set, elem, ext);
5538+
5539+ return ret;
5540+}
5541+
5542+static bool nft_setelem_is_catchall(const struct nft_set *set,
5543+ const struct nft_set_elem *elem)
5544+{
5545+ struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
5546+
5547+ if (nft_set_ext_exists(ext, NFT_SET_EXT_FLAGS) &&
5548+ *nft_set_ext_flags(ext) & NFT_SET_ELEM_CATCHALL)
5549+ return true;
5550+
5551+ return false;
5552+}
5553+
5554+static void nft_setelem_activate(struct net *net, struct nft_set *set,
5555+ struct nft_set_elem *elem)
5556+{
5557+ struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
5558+
5559+ if (nft_setelem_is_catchall(set, elem)) {
5560+ nft_set_elem_change_active(net, set, ext);
5561+ nft_set_elem_clear_busy(ext);
5562+ } else {
5563+ set->ops->activate(net, set, elem);
5564+ }
5565+}
5566+
5567+static int nft_setelem_catchall_deactivate(const struct net *net,
5568+ struct nft_set *set,
5569+ struct nft_set_elem *elem)
5570+{
5571+ struct nft_set_elem_catchall *catchall;
5572+ struct nft_set_ext *ext;
5573+
5574+ list_for_each_entry(catchall, &set->catchall_list, list) {
5575+ ext = nft_set_elem_ext(set, catchall->elem);
5576+ if (!nft_is_active(net, ext) ||
5577+ nft_set_elem_mark_busy(ext))
5578+ continue;
5579+
5580+ kfree(elem->priv);
5581+ elem->priv = catchall->elem;
5582+ nft_set_elem_change_active(net, set, ext);
5583+ return 0;
5584+ }
5585+
5586+ return -ENOENT;
5587+}
5588+
5589+static int __nft_setelem_deactivate(const struct net *net,
5590+ struct nft_set *set,
5591+ struct nft_set_elem *elem)
5592+{
5593+ void *priv;
5594+
5595+ priv = set->ops->deactivate(net, set, elem);
5596+ if (!priv)
5597+ return -ENOENT;
5598+
5599+ kfree(elem->priv);
5600+ elem->priv = priv;
5601+ set->ndeact++;
5602+
5603+ return 0;
5604+}
5605+
5606+static int nft_setelem_deactivate(const struct net *net,
5607+ struct nft_set *set,
5608+ struct nft_set_elem *elem, u32 flags)
5609+{
5610+ int ret;
5611+
5612+ if (flags & NFT_SET_ELEM_CATCHALL)
5613+ ret = nft_setelem_catchall_deactivate(net, set, elem);
5614+ else
5615+ ret = __nft_setelem_deactivate(net, set, elem);
5616+
5617+ return ret;
5618+}
5619+
5620+static void nft_setelem_catchall_remove(const struct net *net,
5621+ const struct nft_set *set,
5622+ const struct nft_set_elem *elem)
5623+{
5624+ struct nft_set_elem_catchall *catchall, *next;
5625+
5626+ list_for_each_entry_safe(catchall, next, &set->catchall_list, list) {
5627+ if (catchall->elem == elem->priv) {
5628+ list_del_rcu(&catchall->list);
5629+ kfree_rcu(catchall);
5630+ break;
5631+ }
5632+ }
5633+}
5634+
5635+static void nft_setelem_remove(const struct net *net,
5636+ const struct nft_set *set,
5637+ const struct nft_set_elem *elem)
5638+{
5639+ if (nft_setelem_is_catchall(set, elem))
5640+ nft_setelem_catchall_remove(net, set, elem);
5641+ else
5642+ set->ops->remove(net, set, elem);
5643+}
5644+
53465645 static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set,
53475646 const struct nlattr *attr, u32 nlmsg_flags)
53485647 {
@@ -5369,14 +5668,15 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 20 unmodified lines
53695668 if (err < 0)
53705669 return err;
53715670
5372− if (nla[NFTA_SET_ELEM_KEY] == NULL)
5373− return -EINVAL;
5374−
53755671 nft_set_ext_prepare(&tmpl);
53765672
53775673 err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
53785674 if (err < 0)
53795675 return err;
5676+
5677+ if (!nla[NFTA_SET_ELEM_KEY] && !(flags & NFT_SET_ELEM_CATCHALL))
5678+ return -EINVAL;
5679+
53805680 if (flags != 0)
53815681 nft_set_ext_add(&tmpl, NFT_SET_EXT_FLAGS);
53825682
@@ -5481,12 +5781,14 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 98 unmodified lines
54815781 num_exprs = set->num_exprs;
54825782 }
54835783
5484− err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5485− nla[NFTA_SET_ELEM_KEY]);
5486− if (err < 0)
5487− goto err_set_elem_expr;
5784+ if (nla[NFTA_SET_ELEM_KEY]) {
5785+ err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5786+ nla[NFTA_SET_ELEM_KEY]);
5787+ if (err < 0)
5788+ goto err_set_elem_expr;
54885789
5489− nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
5790+ nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
5791+ }
54905792
54915793 if (nla[NFTA_SET_ELEM_KEY_END]) {
54925794 err = nft_setelem_parse_key(ctx, set, &elem.key_end.val,
@@ -5603,7 +5905,8 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 110 unmodified lines
56035905 }
56045906
56055907 ext->genmask = nft_genmask_cur(ctx->net) | NFT_SET_ELEM_BUSY_MASK;
5606− err = set->ops->insert(ctx->net, set, &elem, &ext2);
5908+
5909+ err = nft_setelem_insert(ctx->net, set, &elem, &ext2, flags);
56075910 if (err) {
56085911 if (err == -EEXIST) {
56095912 if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA) ^
@@ -5630,7 +5933,7 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 20 unmodified lines
56305933 goto err_element_clash;
56315934 }
56325935
5633− if (set->size &&
5936+ if (!(flags & NFT_SET_ELEM_CATCHALL) && set->size &&
56345937 !atomic_add_unless(&set->nelems, 1, set->size + set->ndeact)) {
56355938 err = -ENFILE;
56365939 goto err_set_full;
@@ -5641,7 +5944,7 @@ static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set, · 4 unmodified lines
56415944 return 0;
56425945
56435946 err_set_full:
5644− set->ops->remove(ctx->net, set, &elem);
5947+ nft_setelem_remove(ctx->net, set, &elem);
56455948 err_element_clash:
56465949 kfree(trans);
56475950 err_elem_expr:
@@ -5773,7 +6076,6 @@ static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set, · 125 unmodified lines
57736076 struct nft_set_ext *ext;
57746077 struct nft_trans *trans;
57756078 u32 flags = 0;
5776− void *priv;
57776079 int err;
57786080
57796081 err = nla_parse_nested_deprecated(nla, NFTA_SET_ELEM_MAX, attr,
@@ -5781,23 +6083,26 @@ static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set, · 1 unmodified line
57816083 if (err < 0)
57826084 return err;
57836085
5784− if (nla[NFTA_SET_ELEM_KEY] == NULL)
6086+ err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
6087+ if (err < 0)
6088+ return err;
6089+
6090+ if (!nla[NFTA_SET_ELEM_KEY] && !(flags & NFT_SET_ELEM_CATCHALL))
57856091 return -EINVAL;
57866092
57876093 nft_set_ext_prepare(&tmpl);
57886094
5789− err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
5790− if (err < 0)
5791− return err;
57926095 if (flags != 0)
57936096 nft_set_ext_add(&tmpl, NFT_SET_EXT_FLAGS);
57946097
5795− err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5796− nla[NFTA_SET_ELEM_KEY]);
5797− if (err < 0)
5798− return err;
6098+ if (nla[NFTA_SET_ELEM_KEY]) {
6099+ err = nft_setelem_parse_key(ctx, set, &elem.key.val,
6100+ nla[NFTA_SET_ELEM_KEY]);
6101+ if (err < 0)
6102+ return err;
57996103
5800− nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
6104+ nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
6105+ }
58016106
58026107 if (nla[NFTA_SET_ELEM_KEY_END]) {
58036108 err = nft_setelem_parse_key(ctx, set, &elem.key_end.val,
@@ -5823,13 +6128,9 @@ static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set, · 19 unmodified lines
58236128 if (trans == NULL)
58246129 goto fail_trans;
58256130
5826− priv = set->ops->deactivate(ctx->net, set, &elem);
5827− if (priv == NULL) {
5828− err = -ENOENT;
6131+ err = nft_setelem_deactivate(ctx->net, set, &elem, flags);
6132+ if (err < 0)
58296133 goto fail_ops;
5830− }
5831− kfree(elem.priv);
5832− elem.priv = priv;
58336134
58346135 nft_setelem_data_deactivate(ctx->net, set, &elem);
58356136
@@ -5876,6 +6177,49 @@ err1: · 40 unmodified lines
58766177 return err;
58776178 }
58786179
6180+static int __nft_set_catchall_flush(const struct nft_ctx *ctx,
6181+ struct nft_set *set,
6182+ struct nft_set_elem *elem)
6183+{
6184+ struct nft_trans *trans;
6185+
6186+ trans = nft_trans_alloc_gfp(ctx, NFT_MSG_DELSETELEM,
6187+ sizeof(struct nft_trans_elem), GFP_KERNEL);
6188+ if (!trans)
6189+ return -ENOMEM;
6190+
6191+ nft_setelem_data_deactivate(ctx->net, set, elem);
6192+ nft_trans_elem_set(trans) = set;
6193+ nft_trans_elem(trans) = *elem;
6194+ nft_trans_commit_list_add_tail(ctx->net, trans);
6195+
6196+ return 0;
6197+}
6198+
6199+static int nft_set_catchall_flush(const struct nft_ctx *ctx,
6200+ struct nft_set *set)
6201+{
6202+ u8 genmask = nft_genmask_next(ctx->net);
6203+ struct nft_set_elem_catchall *catchall;
6204+ struct nft_set_elem elem;
6205+ struct nft_set_ext *ext;
6206+ int ret = 0;
6207+
6208+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
6209+ ext = nft_set_elem_ext(set, catchall->elem);
6210+ if (!nft_set_elem_active(ext, genmask) ||
6211+ nft_set_elem_mark_busy(ext))
6212+ continue;
6213+
6214+ elem.priv = catchall->elem;
6215+ ret = __nft_set_catchall_flush(ctx, set, &elem);
6216+ if (ret < 0)
6217+ break;
6218+ }
6219+
6220+ return ret;
6221+}
6222+
58796223 static int nft_set_flush(struct nft_ctx *ctx, struct nft_set *set, u8 genmask)
58806224 {
58816225 struct nft_set_iter iter = {
@@ -5884,6 +6228,8 @@ static int nft_set_flush(struct nft_ctx *ctx, struct nft_set *set, u8 genmask) · 2 unmodified lines
58846228 };
58856229
58866230 set->ops->walk(ctx, set, &iter);
6231+ if (!iter.err)
6232+ iter.err = nft_set_catchall_flush(ctx, set);
58876233
58886234 return iter.err;
58896235 }
@@ -5918,8 +6264,6 @@ static int nf_tables_delsetelem(struct sk_buff *skb, · 28 unmodified lines
59186264 err = nft_del_setelem(&ctx, set, attr);
59196265 if (err < 0)
59206266 break;
5921−
5922− set->ndeact++;
59236267 }
59246268 return err;
59256269 }
@@ -8270,7 +8614,7 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb) · 2344 unmodified lines
82708614 case NFT_MSG_NEWSETELEM:
82718615 te = (struct nft_trans_elem *)trans->data;
82728616
8273− te->set->ops->activate(net, te->set, &te->elem);
8617+ nft_setelem_activate(net, te->set, &te->elem);
82748618 nf_tables_setelem_notify(&trans->ctx, te->set,
82758619 &te->elem,
82768620 NFT_MSG_NEWSETELEM, 0);
@@ -8282,9 +8626,11 @@ static int nf_tables_commit(struct net *net, struct sk_buff *skb) · 5 unmodified lines
82828626 nf_tables_setelem_notify(&trans->ctx, te->set,
82838627 &te->elem,
82848628 NFT_MSG_DELSETELEM, 0);
8285− te->set->ops->remove(net, te->set, &te->elem);
8286− atomic_dec(&te->set->nelems);
8287− te->set->ndeact--;
8629+ nft_setelem_remove(net, te->set, &te->elem);
8630+ if (!nft_setelem_is_catchall(te->set, &te->elem)) {
8631+ atomic_dec(&te->set->nelems);
8632+ te->set->ndeact--;
8633+ }
82888634 break;
82898635 case NFT_MSG_NEWOBJ:
82908636 if (nft_trans_obj_update(trans)) {
@@ -8485,15 +8831,17 @@ static int __nf_tables_abort(struct net *net, enum nfnl_abort_action action) · 194 unmodified lines
84858831 break;
84868832 }
84878833 te = (struct nft_trans_elem *)trans->data;
8488− te->set->ops->remove(net, te->set, &te->elem);
8489− atomic_dec(&te->set->nelems);
8834+ nft_setelem_remove(net, te->set, &te->elem);
8835+ if (!nft_setelem_is_catchall(te->set, &te->elem))
8836+ atomic_dec(&te->set->nelems);
84908837 break;
84918838 case NFT_MSG_DELSETELEM:
84928839 te = (struct nft_trans_elem *)trans->data;
84938840
84948841 nft_setelem_data_activate(net, te->set, &te->elem);
8495− te->set->ops->activate(net, te->set, &te->elem);
8496− te->set->ndeact--;
8842+ nft_setelem_activate(net, te->set, &te->elem);
8843+ if (!nft_setelem_is_catchall(te->set, &te->elem))
8844+ te->set->ndeact--;
84978845
84988846 nft_trans_destroy(trans);
84998847 break;
@@ -8672,6 +9020,27 @@ static int nf_tables_loop_check_setelem(const struct nft_ctx *ctx, · 172 unmodified lines
86729020 return nft_check_loops(ctx, ext);
86739021 }
86749022
9023+static int nft_set_catchall_loops(const struct nft_ctx *ctx,
9024+ struct nft_set *set)
9025+{
9026+ u8 genmask = nft_genmask_next(ctx->net);
9027+ struct nft_set_elem_catchall *catchall;
9028+ struct nft_set_ext *ext;
9029+ int ret = 0;
9030+
9031+ list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
9032+ ext = nft_set_elem_ext(set, catchall->elem);
9033+ if (!nft_set_elem_active(ext, genmask))
9034+ continue;
9035+
9036+ ret = nft_check_loops(ctx, ext);
9037+ if (ret < 0)
9038+ return ret;
9039+ }
9040+
9041+ return ret;
9042+}
9043+
86759044 static int nf_tables_check_loops(const struct nft_ctx *ctx,
86769045 const struct nft_chain *chain)
86779046 {
@@ -8731,6 +9100,9 @@ static int nf_tables_check_loops(const struct nft_ctx *ctx, · 53 unmodified lines
87319100 iter.fn = nf_tables_loop_check_setelem;
87329101
87339102 set->ops->walk(ctx, set, &iter);
9103+ if (!iter.err)
9104+ iter.err = nft_set_catchall_loops(ctx, set);
9105+
87349106 if (iter.err < 0)
87359107 return iter.err;
87369108 }
net/netfilter/nft_lookup.c+8−4
@@ -30,13 +30,17 @@ void nft_lookup_eval(const struct nft_expr *expr, · 29 unmodified lines
3030 const struct nft_lookup *priv = nft_expr_priv(expr);
3131 const struct nft_set *set = priv->set;
3232 const struct nft_set_ext *ext = NULL;
33+ const struct net *net = nft_net(pkt);
3334 bool found;
3435
35− found = set->ops->lookup(nft_net(pkt), set, &regs->data[priv->sreg],
36− &ext) ^ priv->invert;
36+ found = set->ops->lookup(net, set, &regs->data[priv->sreg], &ext) ^
37+ priv->invert;
3738 if (!found) {
38− regs->verdict.code = NFT_BREAK;
39− return;
39+ ext = nft_set_catchall_lookup(net, set);
40+ if (!ext) {
41+ regs->verdict.code = NFT_BREAK;
42+ return;
43+ }
4044 }
4145
4246 if (ext) {
net/netfilter/nft_objref.c+7−4
@@ -105,15 +105,18 @@ static void nft_objref_map_eval(const struct nft_expr *expr, · 104 unmodified lines
105105 {
106106 struct nft_objref_map *priv = nft_expr_priv(expr);
107107 const struct nft_set *set = priv->set;
108+ struct net *net = nft_net(pkt);
108109 const struct nft_set_ext *ext;
109110 struct nft_object *obj;
110111 bool found;
111112
112− found = set->ops->lookup(nft_net(pkt), set, &regs->data[priv->sreg],
113− &ext);
113+ found = set->ops->lookup(net, set, &regs->data[priv->sreg], &ext);
114114 if (!found) {
115− regs->verdict.code = NFT_BREAK;
116− return;
115+ ext = nft_set_catchall_lookup(net, set);
116+ if (!ext) {
117+ regs->verdict.code = NFT_BREAK;
118+ return;
119+ }
117120 }
118121 obj = *nft_set_ext_obj(ext);
119122 obj->ops->eval(obj, regs, pkt);
net/netfilter/nft_set_hash.c+6−0
@@ -350,6 +350,12 @@ needs_gc_run: · 349 unmodified lines
350350 rhashtable_walk_stop(&hti);
351351 rhashtable_walk_exit(&hti);
352352
353+ he = nft_set_catchall_gc(set);
354+ if (he) {
355+ gcb = nft_set_gc_batch_check(set, gcb, GFP_ATOMIC);
356+ if (gcb)
357+ nft_set_gc_batch_add(gcb, he);
358+ }
353359 nft_set_gc_batch_complete(gcb);
354360 queue_delayed_work(system_power_efficient_wq, &priv->gc_work,
355361 nft_set_gc_interval(set));
net/netfilter/nft_set_pipapo.c+5−1
@@ -1529,11 +1529,11 @@ static void pipapo_gc(const struct nft_set *set, struct nft_pipapo_match *m) · 1528 unmodified lines
15291529 {
15301530 struct nft_pipapo *priv = nft_set_priv(set);
15311531 int rules_f0, first_rule = 0;
1532+ struct nft_pipapo_elem *e;
15321533
15331534 while ((rules_f0 = pipapo_rules_same_key(m->f, first_rule))) {
15341535 union nft_pipapo_map_bucket rulemap[NFT_PIPAPO_MAX_FIELDS];
15351536 struct nft_pipapo_field *f;
1536− struct nft_pipapo_elem *e;
15371537 int i, start, rules_fx;
15381538
15391539 start = first_rule;
@@ -1569,6 +1569,10 @@ static void pipapo_gc(const struct nft_set *set, struct nft_pipapo_match *m) · 29 unmodified lines
15691569 }
15701570 }
15711571
1572+ e = nft_set_catchall_gc(set);
1573+ if (e)
1574+ nft_set_elem_destroy(set, e, true);
1575+
15721576 priv->last_gc = jiffies;
15731577 }
15741578
net/netfilter/nft_set_rbtree.c+6−0
@@ -541,6 +541,12 @@ static void nft_rbtree_gc(struct work_struct *work) · 540 unmodified lines
541541 write_seqcount_end(&priv->count);
542542 write_unlock_bh(&priv->lock);
543543
544+ rbe = nft_set_catchall_gc(set);
545+ if (rbe) {
546+ gcb = nft_set_gc_batch_check(set, gcb, GFP_ATOMIC);
547+ if (gcb)
548+ nft_set_gc_batch_add(gcb, rbe);
549+ }
544550 nft_set_gc_batch_complete(gcb);
545551
546552 queue_delayed_work(system_power_efficient_wq, &priv->gc_work,

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t