Skip to contentSkip to conversation

src: remove useless parameter from cache_flush()

PATCH Superseded Pablo Neira Ayuso 2 participants 16 messages Jun 17, 2019 netfilter

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Pablo Neira Ayuso

author maintainer
#0 lore raw

PATCH 1/5 src: remove useless parameter from cache_flush()

Command type is never used in cache_flush().

---
 include/rule.h | 3 +--
 src/evaluate.c | 2 +-
 src/rule.c     | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)
include/rule.h +1 -2
index b41825d000d6..299485ffeeaa 100644
@@ -639,8 +639,7 @@ extern int do_command(struct netlink_ctx *ctx, struct cmd *cmd);
 extern int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds);
 extern int cache_update(struct nft_ctx *ctx, enum cmd_ops cmd,
 			struct list_head *msgs);
-extern void cache_flush(struct nft_ctx *ctx, enum cmd_ops cmd,
-			struct list_head *msgs);
+extern void cache_flush(struct nft_ctx *ctx, struct list_head *msgs);
 extern void cache_release(struct nft_cache *cache);
 extern bool cache_is_complete(struct nft_cache *cache, enum cmd_ops cmd);
 
src/evaluate.c +1 -1
index 70c7e597f3b0..73a4be339ce1 100644
@@ -3682,7 +3682,7 @@ static int cmd_evaluate_flush(struct eval_ctx *ctx, struct cmd *cmd)
 
 	switch (cmd->obj) {
 	case CMD_OBJ_RULESET:
-		cache_flush(ctx->nft, cmd->op, ctx->msgs);
+		cache_flush(ctx->nft, ctx->msgs);
 		break;
 	case CMD_OBJ_TABLE:
 		/* Flushing a table does not empty the sets in the table nor remove
src/rule.c +1 -1
index 0c0fd07ec70c..4407b0b0ceaa 100644
@@ -297,7 +297,7 @@ static void __cache_flush(struct list_head *table_list)
 	}
 }
 
-void cache_flush(struct nft_ctx *nft, enum cmd_ops cmd, struct list_head *msgs)
+void cache_flush(struct nft_ctx *nft, struct list_head *msgs)
 {
 	struct netlink_ctx ctx = {
 		.list		= LIST_HEAD_INIT(ctx.list),
Signature · 1 line
2.11.0
author maintainer
#1 lore raw

PATCH 2/5 tests: shell: cannot use handle for non-existing rule in kernel

This test invokes the 'replace rule ... handle 2' command. However, there are no rules in the kernel, therefore it always fails.

---
 tests/shell/testcases/nft-f/0006action_object_0 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/shell/testcases/nft-f/0006action_object_0 +1 -1
index ffa6c9bda973..fab3070f493f 100755
@@ -16,7 +16,7 @@ generate1()
 	add set $family t s {type inet_service;}
 	add element $family t s {8080}
 	insert rule $family t c meta l4proto tcp tcp dport @s accept
-	replace rule $family t c handle 2 meta l4proto tcp tcp dport {9090, 8080}
+	add rule $family t c meta l4proto tcp tcp dport {9090, 8080}
 	add map $family t m {type inet_service:verdict;}
 	add element $family t m {10080:drop}
 	insert rule $family t c meta l4proto tcp tcp dport vmap @m
Signature · 1 line
2.11.0
reviewer
#2 lore raw

Re: [PATCH nft 2/5] tests: shell: cannot use handle for non-existing rule in kernel

Hi,

Quoted 2 lines · Pablo Neira Ayuso

This test invokes the 'replace rule ... handle 2' command. However, there are no rules in the kernel, therefore it always fails.

This guesses the previously inserted rule's handle. Does this start failing with your flags conversion in place? My initial implementation of intra-transaction rule references made this handle guessing impossible, but your single point cache fetching still allowed for it (hence why I dropped my patch with a similar change).

Cheers, Phil

author maintainer
#3 lore raw

Re: [PATCH nft 2/5] tests: shell: cannot use handle for non-existing rule in kernel

Hi Phil,

Quoted 8 lines · Phil Sutter

Hi,

Quoted 2 lines · Pablo Neira Ayuso

This test invokes the 'replace rule ... handle 2' command. However, there are no rules in the kernel, therefore it always fails.

This guesses the previously inserted rule's handle. Does this start failing with your flags conversion in place?

Yes.

Quoted 4 lines

My initial implementation of intra-transaction rule references made this handle guessing impossible, but your single point cache fetching still allowed for it (hence why I dropped my patch with a similar change).

Hm. I think we should not guess the handle that the kernel assigns.

In a batch, handles do not exist. We could expose the intra-transaction index if needed to the user. But I don't see a use-case for this.

I think we should leave the handle as a reference to already existing rules in the kernel.

reviewer
#4 lore raw

Re: [PATCH nft 2/5] tests: shell: cannot use handle for non-existing rule in kernel

Hi Pablo,

Quoted 1 line · Pablo Neira Ayuso

On Mon, Jun 17, 2019 at 06:00:30PM +0200, Phil Sutter wrote:

[...]

Quoted 5 lines
Quoted 4 lines

My initial implementation of intra-transaction rule references made this handle guessing impossible, but your single point cache fetching still allowed for it (hence why I dropped my patch with a similar change).

Quoted 8 lines

Hm. I think we should not guess the handle that the kernel assigns.

In a batch, handles do not exist. We could expose the intra-transaction index if needed to the user. But I don't see a use-case for this.

I think we should leave the handle as a reference to already existing rules in the kernel.

Yes, it's an ugly hack that should never have worked in the first place, I fully agree. Yet that it stops working indicates user space starts doing more than it has to - IMHO relying upon the kernel verifier is desirable. At least it allows for much better handling of large rulesets.

Cheers, Phil

author maintainer
#5 lore raw

PATCH 3/5 src: add cache level flags

In reply to Pablo Neira Ayuso

The score approach based on command type is confusing.

This patch introduces cache level flags, each flag specifies what kind of object type is needed. These flags are set on/off depending on the list of commands coming in this batch.

cache_is_complete() now checks if the cache contains the objects that are needed in the cache through these new flags.

---
 include/cache.h    |  22 +++++++++++
 include/nftables.h |   2 +-
 include/rule.h     |   3 +-
 src/cache.c        |  95 +++++++++++++++++++++++++++--------------------
 src/evaluate.c     |   1 +
 src/libnftables.c  |   6 +--
 src/rule.c         | 107 +++++++++++++++++++++++------------------------------
 7 files changed, 129 insertions(+), 107 deletions(-)
 create mode 100644 include/cache.h
include/cache.h new file +22 -0
new file mode 100644
index 000000000000..9bf4a2a79eeb
@@ -0,0 +1,22 @@
+#ifndef _NFT_CACHE_H_
+#define _NFT_CACHE_H_
+
+enum cache_level_flags {
+	NFT_CACHE_EMPTY		= 0,
+	NFT_CACHE_TABLE		= (1 << 0),
+	NFT_CACHE_CHAIN 	= (1 << 1),
+	NFT_CACHE_SET 		= (1 << 2),
+	NFT_CACHE_FLOWTABLE	= (1 << 3),
+	NFT_CACHE_OBJECT	= (1 << 4),
+	NFT_CACHE_SETELEM 	= (1 << 5),
+	NFT_CACHE_RULE		= (1 << 6),
+	NFT_CACHE_FULL		= (NFT_CACHE_TABLE	|
+				   NFT_CACHE_CHAIN	|
+				   NFT_CACHE_SET	|
+				   NFT_CACHE_FLOWTABLE	|
+				   NFT_CACHE_OBJECT	|
+				   NFT_CACHE_SETELEM	|
+				   NFT_CACHE_RULE),
+};
+
+#endif /* _NFT_CACHE_H_ */
include/nftables.h +1 -1
index b7c78572da77..ed446e2d16cf 100644
@@ -81,7 +81,7 @@ struct nft_cache {
 	uint32_t		genid;
 	struct list_head	list;
 	uint32_t		seqnum;
-	uint32_t		cmd;
+	uint32_t		flags;
 };
 
 struct mnl_socket;
include/rule.h +1 -2
index 299485ffeeaa..aefb24d95163 100644
@@ -462,7 +462,6 @@ enum cmd_ops {
 	CMD_EXPORT,
 	CMD_MONITOR,
 	CMD_DESCRIBE,
-	__CMD_FLUSH_RULESET,
 };
 
 /**
@@ -636,7 +635,7 @@ extern struct error_record *rule_postprocess(struct rule *rule);
 struct netlink_ctx;
 extern int do_command(struct netlink_ctx *ctx, struct cmd *cmd);
 
-extern int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds);
+extern unsigned int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds);
 extern int cache_update(struct nft_ctx *ctx, enum cmd_ops cmd,
 			struct list_head *msgs);
 extern void cache_flush(struct nft_ctx *ctx, struct list_head *msgs);
src/cache.c +54 -41

171 lines not on this page · raw message

src/evaluate.c +1 -0
index 73a4be339ce1..ff0888d0c784 100644
@@ -29,6 +29,7 @@
 #include <netlink.h>
 #include <time.h>
 #include <rule.h>
+#include <cache.h>
 #include <erec.h>
 #include <gmputil.h>
 #include <utils.h>
src/libnftables.c +3 -3
index abd133bee127..dccb8ab4da42 100644
@@ -381,11 +381,11 @@ static int nft_parse_bison_filename(struct nft_ctx *nft, const char *filename,
 static int nft_evaluate(struct nft_ctx *nft, struct list_head *msgs,
 			struct list_head *cmds)
 {
-	unsigned int completeness;
+	unsigned int flags;
 	struct cmd *cmd;
 
-	completeness = cache_evaluate(nft, cmds);
-	if (cache_update(nft, completeness, msgs) < 0)
+	flags = cache_evaluate(nft, cmds);
+	if (cache_update(nft, flags, msgs) < 0)
 		return -1;
 
 	list_for_each_entry(cmd, cmds, list) {
src/rule.c +47 -60

193 lines not on this page · raw message

Signature · 1 line
2.11.0
reviewer
#6 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Hi,

Quoted 8 lines · Pablo Neira Ayuso

The score approach based on command type is confusing.

This patch introduces cache level flags, each flag specifies what kind of object type is needed. These flags are set on/off depending on the list of commands coming in this batch.

cache_is_complete() now checks if the cache contains the objects that are needed in the cache through these new flags.

Thanks for committing to getting the cache stuff right!

[...]

Quoted 7 lines
include/cache.h new file +7 -0
+enum cache_level_flags {
+	NFT_CACHE_EMPTY		= 0,
+	NFT_CACHE_TABLE		= (1 << 0),
+	NFT_CACHE_CHAIN 	= (1 << 1),
+	NFT_CACHE_SET 		= (1 << 2),
+	NFT_CACHE_FLOWTABLE	= (1 << 3),
+	NFT_CACHE_OBJECT	= (1 << 4),

include/cache.h line 20

Quoted 10 lines
include/cache.h new file +10 -0
+	NFT_CACHE_SETELEM 	= (1 << 5),
+	NFT_CACHE_RULE		= (1 << 6),
+	NFT_CACHE_FULL		= (NFT_CACHE_TABLE	|
+				   NFT_CACHE_CHAIN	|
+				   NFT_CACHE_SET	|
+				   NFT_CACHE_FLOWTABLE	|
+				   NFT_CACHE_OBJECT	|
+				   NFT_CACHE_SETELEM	|
+				   NFT_CACHE_RULE),
+};

I think we can do this in a way which reflects the implicit dependencies when fetching ruleset elements. I think of something like:

| enum nft_cache_bits {
| 	NFT_CACHE_TABLE_BIT	= (1 << 0),
| 	NFT_CACHE_CHAIN_BIT	= (1 << 1),
| 	NFT_CACHE_SET_BIT	= (1 << 2),
| 	NFT_CACHE_FLOWTABLE_BIT	= (1 << 3),
| 	NFT_CACHE_OBJECT_BIT	= (1 << 4),
| 	NFT_CACHE_SETELEM_BIT	= (1 << 5),
| 	NFT_CACHE_RULE_BIT	= (1 << 6),
| 	__NFT_CACHE_MAX_BIT	= (1 << 7),
| };
| 
| enum cache_level_flags {
| 	NFT_CACHE_EMPTY		= 0,
| 	NFT_CACHE_TABLE		= NFT_CACHE_TABLE_BIT,
| 	NFT_CACHE_CHAIN		= NFT_CACHE_TABLE_BIT
| 				| NFT_CACHE_CHAIN_BIT,
| 	NFT_CACHE_SET		= NFT_CACHE_TABLE_BIT
| 				| NFT_CACHE_SET_BIT,
| 	NFT_CACHE_FLOWTABLE	= NFT_CACHE_TABLE_BIT
| 				| NFT_CACHE_FLOWTABLE_BIT,
| 	NFT_CACHE_OBJECT	= NFT_CACHE_TABLE_BIT
| 				| NFT_CACHE_OBJECT_BIT,
| 	NFT_CACHE_SETELEM	= NFT_CACHE_TABLE_BIT
| 				| NFT_CACHE_SET_BIT
| 				| NFT_CACHE_SETELEM_BIT,
| 	NFT_CACHE_RULE		= NFT_CACHE_TABLE_BIT
| 				| NFT_CACHE_CHAIN_BIT
| 				| NFT_CACHE_SETELEM_BIT
| 				| NFT_CACHE_RULE_BIT,
| 	NFT_CACHE_FULL		= __NFT_CACHE_MAX_BIT - 1,
| };

This removes these dependency details from cache_evaluate() functions. What do you think?

Cheers, Phil

reviewer
#7 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

In reply to Pablo Neira Ayuso

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:
[...]

Quoted 11 lines
src/cache.c +2 -3
-int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds)
+unsigned int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds)
 {
-	unsigned int echo_completeness = CMD_INVALID;
-	unsigned int completeness = CMD_INVALID;
+	unsigned int flags = NFT_CACHE_EMPTY;
 	struct cmd *cmd;
 
 	list_for_each_entry(cmd, cmds, list) {
 		switch (cmd->op) {
 		case CMD_ADD:

src/cache.c line 98

Quoted 10 lines
src/cache.c +5 -4
 		case CMD_INSERT:
-		case CMD_REPLACE:
-			if (nft_output_echo(&nft->output))
-				echo_completeness = cmd->op;
-
+			flags |= NFT_CACHE_TABLE |
+				 NFT_CACHE_CHAIN |
+				 NFT_CACHE_SET |
+				 NFT_CACHE_FLOWTABLE |
+				 NFT_CACHE_OBJECT;

This means we start fetching the cache for simple 'add rule' commands again, right?

This should be the reason why that test case started failing for you.

Quoted 11 lines
src/cache.c +8 -1
+
+			if (nft_output_echo(&nft->output)) {
+				flags |= NFT_CACHE_SETELEM |
+					 NFT_CACHE_RULE;
+				break;
+			}
 			/* Fall through */
 		case CMD_CREATE:
-			completeness = evaluate_cache_add(cmd);
+			flags = evaluate_cache_add(cmd, flags);
+			break;

src/cache.c line 117

Quoted 10 lines
src/cache.c +7 -1
+		case CMD_REPLACE:
+			flags |= NFT_CACHE_FULL;
 			break;
 		case CMD_DELETE:
-			completeness = evaluate_cache_del(cmd);
+			flags |= NFT_CACHE_TABLE |
+				 NFT_CACHE_CHAIN |
+				 NFT_CACHE_SET |
+				 NFT_CACHE_FLOWTABLE |
+				 NFT_CACHE_OBJECT;

Same here, I guess: Single 'delete rule' command causes fetching of above ruleset items (unless I miss something).

Cheers, Phil

author maintainer
#8 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Quoted 12 lines · Phil Sutter

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:
[...]

Quoted 8 lines
src/cache.c +2 -3
-int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds)
+unsigned int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds)
 {
-	unsigned int echo_completeness = CMD_INVALID;
-	unsigned int completeness = CMD_INVALID;
+	unsigned int flags = NFT_CACHE_EMPTY;
 	struct cmd *cmd;
Quoted 16 lines

src/cache.c line 98

Quoted 13 lines
src/cache.c +5 -4
 	list_for_each_entry(cmd, cmds, list) {
 		switch (cmd->op) {
 		case CMD_ADD:
 		case CMD_INSERT:
-		case CMD_REPLACE:
-			if (nft_output_echo(&nft->output))
-				echo_completeness = cmd->op;
-
+			flags |= NFT_CACHE_TABLE |
+				 NFT_CACHE_CHAIN |
+				 NFT_CACHE_SET |
+				 NFT_CACHE_FLOWTABLE |
+				 NFT_CACHE_OBJECT;

This means we start fetching the cache for simple 'add rule' commands again, right?

We need these for references to sets, eg.

add rule x y ip saddr @x

same for other flowtable and object.

We should not use NFT_CACHE_RULE in this case, if this is what you suggest.

reviewer
#9 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Quoted 30 lines · Pablo Neira Ayuso
Quoted 12 lines · Phil Sutter

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:
[...]

Quoted 8 lines
src/cache.c +2 -3
-int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds)
+unsigned int cache_evaluate(struct nft_ctx *nft, struct list_head *cmds)
 {
-	unsigned int echo_completeness = CMD_INVALID;
-	unsigned int completeness = CMD_INVALID;
+	unsigned int flags = NFT_CACHE_EMPTY;
 	struct cmd *cmd;
Quoted 16 lines

src/cache.c line 98

Quoted 13 lines
src/cache.c +5 -4
 	list_for_each_entry(cmd, cmds, list) {
 		switch (cmd->op) {
 		case CMD_ADD:
 		case CMD_INSERT:
-		case CMD_REPLACE:
-			if (nft_output_echo(&nft->output))
-				echo_completeness = cmd->op;
-
+			flags |= NFT_CACHE_TABLE |
+				 NFT_CACHE_CHAIN |
+				 NFT_CACHE_SET |
+				 NFT_CACHE_FLOWTABLE |
+				 NFT_CACHE_OBJECT;

This means we start fetching the cache for simple 'add rule' commands again, right?

Quoted 5 lines

We need these for references to sets, eg.

add rule x y ip saddr @x

same for other flowtable and object.

Oh, right. I got that wrong - old code is always fetching the above items unless there's no ruleset in kernel (i.e., returned genid is 0).

I confused that with fetching rules which at some point started to happen by accident with my changes.

Quoted 2 lines

We should not use NFT_CACHE_RULE in this case, if this is what you suggest.

No, quite the opposite: I thought we could get by without fetching anything from kernel at all.

Yet now I wonder why the handle guessing stops working, because the above can't be the cause of it.

Cheers, Phil

author maintainer
#10 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Quoted 5 lines · Phil Sutter
Quoted 4 lines · Pablo Neira Ayuso
Quoted 3 lines · Phil Sutter

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:

[...]

Quoted 13 lines
Quoted 6 lines

We need these for references to sets, eg.

add rule x y ip saddr @x

same for other flowtable and object.

Oh, right. I got that wrong - old code is always fetching the above items unless there's no ruleset in kernel (i.e., returned genid is 0).

I confused that with fetching rules which at some point started to happen by accident with my changes.

Quoted 8 lines
Quoted 2 lines

We should not use NFT_CACHE_RULE in this case, if this is what you suggest.

No, quite the opposite: I thought we could get by without fetching anything from kernel at all.

Yet now I wonder why the handle guessing stops working, because the above can't be the cause of it.

I think we should partial revert the changes that are doing the handle guessing, would you submit a patch for this?

Thanks!

reviewer
#11 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Quoted 23 lines · Pablo Neira Ayuso
Quoted 5 lines · Phil Sutter
Quoted 4 lines · Pablo Neira Ayuso
Quoted 3 lines · Phil Sutter

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:

[...]

Quoted 16 lines
Quoted 6 lines

We need these for references to sets, eg.

add rule x y ip saddr @x

same for other flowtable and object.

Oh, right. I got that wrong - old code is always fetching the above items unless there's no ruleset in kernel (i.e., returned genid is 0).

I confused that with fetching rules which at some point started to happen by accident with my changes.

Quoted 2 lines

We should not use NFT_CACHE_RULE in this case, if this is what you suggest.

Quoted 8 lines
Quoted 5 lines

No, quite the opposite: I thought we could get by without fetching anything from kernel at all.

Yet now I wonder why the handle guessing stops working, because the above can't be the cause of it.

I think we should partial revert the changes that are doing the handle guessing, would you submit a patch for this?

There are no explicit changes allowing for it. The reason it works is because user space doesn't care to check the given handle for existence and in kernel space it is valid already.

Cheers, Phil

author maintainer
#12 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Quoted 30 lines · Phil Sutter
Quoted 29 lines · Pablo Neira Ayuso
Quoted 5 lines · Phil Sutter
Quoted 4 lines · Pablo Neira Ayuso
Quoted 3 lines · Phil Sutter

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:

[...]

Quoted 21 lines
Quoted 6 lines

We need these for references to sets, eg.

add rule x y ip saddr @x

same for other flowtable and object.

Oh, right. I got that wrong - old code is always fetching the above items unless there's no ruleset in kernel (i.e., returned genid is 0).

I confused that with fetching rules which at some point started to happen by accident with my changes.

Quoted 2 lines

We should not use NFT_CACHE_RULE in this case, if this is what you suggest.

No, quite the opposite: I thought we could get by without fetching anything from kernel at all.

Yet now I wonder why the handle guessing stops working, because the above can't be the cause of it.

Quoted 6 lines
Quoted 2 lines

I think we should partial revert the changes that are doing the handle guessing, would you submit a patch for this?

There are no explicit changes allowing for it. The reason it works is because user space doesn't care to check the given handle for existence and in kernel space it is valid already.

OK, but this test just works because we are being lucky in guessing, right? I don't think we should not have a test for handles from the batch, for an unexisting rule in the kernel.

reviewer
#13 lore raw

Re: [PATCH nft 3/5] src: add cache level flags

Quoted 34 lines · Pablo Neira Ayuso
Quoted 33 lines · Phil Sutter
Quoted 31 lines · Pablo Neira Ayuso
Quoted 5 lines · Phil Sutter
Quoted 4 lines · Pablo Neira Ayuso
Quoted 3 lines · Phil Sutter

Hi,

On Mon, Jun 17, 2019 at 02:25:16PM +0200, Pablo Neira Ayuso wrote:

[...]

Quoted 13 lines
Quoted 6 lines

We need these for references to sets, eg.

add rule x y ip saddr @x

same for other flowtable and object.

Oh, right. I got that wrong - old code is always fetching the above items unless there's no ruleset in kernel (i.e., returned genid is 0).

I confused that with fetching rules which at some point started to happen by accident with my changes.

Quoted 8 lines
Quoted 2 lines

We should not use NFT_CACHE_RULE in this case, if this is what you suggest.

No, quite the opposite: I thought we could get by without fetching anything from kernel at all.

Yet now I wonder why the handle guessing stops working, because the above can't be the cause of it.

I think we should partial revert the changes that are doing the handle guessing, would you submit a patch for this?

Quoted 7 lines
Quoted 3 lines

There are no explicit changes allowing for it. The reason it works is because user space doesn't care to check the given handle for existence and in kernel space it is valid already.

OK, but this test just works because we are being lucky in guessing, right? I don't think we should not have a test for handles from the batch, for an unexisting rule in the kernel.

Yes, that's right. The test in question was added back in 2016 to make sure the separate commands syntax works with 'nft -f'. I guess it was simply convenient to add all the different commands to the same transaction.

Cheers, Phil

author maintainer
#14 lore raw

PATCH 4/5 rule: skip cache population from do_command_monitor()

In reply to Pablo Neira Ayuso

nft_evaluate() already populates the cache before running the monitor command. Remove this code.

Fixes 7df42800cf89 ("src: single cache_update() call to build cache before evaluation")
---
 src/rule.c | 32 --------------------------------
 1 file changed, 32 deletions(-)
src/rule.c +0 -32
index 782253b81589..732de2874877 100644
@@ -2414,8 +2414,6 @@ static bool need_cache(const struct cmd *cmd)
 
 static int do_command_monitor(struct netlink_ctx *ctx, struct cmd *cmd)
 {
-	struct table *t;
-	struct set *s;
 	struct netlink_mon_handler monhandler = {
 		.monitor_flags	= cmd->monitor->flags,
 		.format		= cmd->monitor->format,
@@ -2429,36 +2427,6 @@ static int do_command_monitor(struct netlink_ctx *ctx, struct cmd *cmd)
 		monhandler.format = NFTNL_OUTPUT_JSON;
 
 	monhandler.cache_needed = need_cache(cmd);
-	if (monhandler.cache_needed) {
-		struct rule *rule, *nrule;
-		struct chain *chain;
-		int ret;
-
-		list_for_each_entry(t, &ctx->nft->cache.list, list) {
-			list_for_each_entry(s, &t->sets, list)
-				s->init = set_expr_alloc(&cmd->location, s);
-
-			if (!(cmd->monitor->flags & (1 << NFT_MSG_TRACE)))
-				continue;
-
-			/* When tracing we'd like to translate the rule handle
-			 * we receive in the trace messages to the actual rule
-			 * struct to print that out.  Populate rule cache now.
-			 */
-			ret = netlink_list_table(ctx, &t->handle);
-
-			if (ret != 0)
-				/* Shouldn't happen and doesn't break things
-				 * too badly
-				 */
-				continue;
-
-			list_for_each_entry_safe(rule, nrule, &ctx->list, list) {
-				chain = chain_lookup(t, &rule->handle);
-				list_move_tail(&rule->list, &chain->rules);
-			}
-		}
-	}
 
 	return netlink_monitor(&monhandler, ctx->nft->nf_sock);
 }
Signature · 1 line
2.11.0
author maintainer
#15 lore raw

PATCH 5/5 netlink: remove netlink_list_table()

In reply to Pablo Neira Ayuso

Remove this wrapper, call netlink_list_rules() instead.

---
 include/netlink.h | 2 +-
 src/netlink.c     | 7 +------
 src/rule.c        | 2 +-
 3 files changed, 3 insertions(+), 8 deletions(-)
include/netlink.h +1 -1
index 0c08b1abbf6a..279723f33d31 100644
@@ -104,6 +104,7 @@ extern struct expr *netlink_alloc_data(const struct location *loc,
 				       const struct nft_data_delinearize *nld,
 				       enum nft_registers dreg);
 
+extern int netlink_list_rules(struct netlink_ctx *ctx, const struct handle *h);
 extern void netlink_linearize_rule(struct netlink_ctx *ctx,
 				   struct nftnl_rule *nlr,
 				   const struct rule *rule);
@@ -115,7 +116,6 @@ extern struct chain *netlink_delinearize_chain(struct netlink_ctx *ctx,
 					       const struct nftnl_chain *nlc);
 
 extern int netlink_list_tables(struct netlink_ctx *ctx, const struct handle *h);
-extern int netlink_list_table(struct netlink_ctx *ctx, const struct handle *h);
 extern struct table *netlink_delinearize_table(struct netlink_ctx *ctx,
 					       const struct nftnl_table *nlt);
 
src/netlink.c +1 -6
index a6d81b4f6424..24d8f03ae4be 100644
@@ -333,7 +333,7 @@ static int list_rule_cb(struct nftnl_rule *nlr, void *arg)
 	return 0;
 }
 
-static int netlink_list_rules(struct netlink_ctx *ctx, const struct handle *h)
+int netlink_list_rules(struct netlink_ctx *ctx, const struct handle *h)
 {
 	struct nftnl_rule_list *rule_cache;
 
@@ -485,11 +485,6 @@ int netlink_list_tables(struct netlink_ctx *ctx, const struct handle *h)
 	return 0;
 }
 
-int netlink_list_table(struct netlink_ctx *ctx, const struct handle *h)
-{
-	return netlink_list_rules(ctx, h);
-}
-
 enum nft_data_types dtype_map_to_kernel(const struct datatype *dtype)
 {
 	switch (dtype->type) {
src/rule.c +1 -1
index 732de2874877..2d42a0328b66 100644
@@ -190,7 +190,7 @@ static int cache_init_objects(struct netlink_ctx *ctx, unsigned int flags)
 			list_splice_tail_init(&ctx->list, &table->objs);
 		}
 		if (flags & NFT_CACHE_RULE) {
-			ret = netlink_list_table(ctx, &table->handle);
+			ret = netlink_list_rules(ctx, &table->handle);
 			list_for_each_entry_safe(rule, nrule, &ctx->list, list) {
 				chain = chain_lookup(table, &rule->handle);
 				list_move_tail(&rule->list, &chain->rules);
Signature · 1 line
2.11.0