[net-next,v5,17/21] lib/bitmap: add tests for IP tunnel flags conversion helpers

Message ID 20240201122216.2634007-18-aleksander.lobakin@intel.com
State New
Headers
Series ice: add PFCP filter support |

Commit Message

Alexander Lobakin Feb. 1, 2024, 12:22 p.m. UTC
  Now that there are helpers for converting IP tunnel flags between the
old __be16 format and the bitmap format, make sure they work as expected
by adding a couple of tests to the bitmap testing suite. The helpers are
all inline, so no dependencies on the related CONFIG_* (or a standalone
module) are needed.

Cover three possible cases:

1. No bits past BIT(15) are set, VTI/SIT bits are not set. This
   conversion is almost a direct assignment.
2. No bits past BIT(15) are set, but VTI/SIT bit is set. During the
   conversion, it must be transformed into BIT(16) in the bitmap,
   but still compatible with the __be16 format.
3. The bitmap has bits past BIT(15) set (not the VTI/SIT one). The
   result will be truncated.
   Note that currently __IP_TUNNEL_FLAG_NUM is 17 (incl. special),
   which means that the result of this case is currently
   semi-false-positive. When BIT(17) is finally here, it will be
   adjusted accordingly.

Signed-off-by: Alexander Lobakin <aleksander.lobakin@intel.com>
---
 lib/test_bitmap.c | 105 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)
  

Comments

Yury Norov Feb. 28, 2024, 4:38 p.m. UTC | #1
On Thu, Feb 01, 2024 at 01:22:12PM +0100, Alexander Lobakin wrote:
> Now that there are helpers for converting IP tunnel flags between the
> old __be16 format and the bitmap format, make sure they work as expected
> by adding a couple of tests to the bitmap testing suite. The helpers are
> all inline, so no dependencies on the related CONFIG_* (or a standalone
> module) are needed.
> 
> Cover three possible cases:
> 
> 1. No bits past BIT(15) are set, VTI/SIT bits are not set. This
>    conversion is almost a direct assignment.
> 2. No bits past BIT(15) are set, but VTI/SIT bit is set. During the
>    conversion, it must be transformed into BIT(16) in the bitmap,
>    but still compatible with the __be16 format.
> 3. The bitmap has bits past BIT(15) set (not the VTI/SIT one). The
>    result will be truncated.
>    Note that currently __IP_TUNNEL_FLAG_NUM is 17 (incl. special),
>    which means that the result of this case is currently
>    semi-false-positive. When BIT(17) is finally here, it will be
>    adjusted accordingly.
> 
> Signed-off-by: Alexander Lobakin <aleksander.lobakin@intel.com>

So why testing IP tunnels stuff in lib/test_bitmap? I think it should
go with the rest of networking code.

> ---
>  lib/test_bitmap.c | 105 ++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 105 insertions(+)
> 
> diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
> index 4ee1f8ceb51d..270afc0cba5c 100644
> --- a/lib/test_bitmap.c
> +++ b/lib/test_bitmap.c
> @@ -14,6 +14,8 @@
>  #include <linux/string.h>
>  #include <linux/uaccess.h>
>  
> +#include <net/ip_tunnels.h>
> +
>  #include "../tools/testing/selftests/kselftest_module.h"
>  
>  #define EXP1_IN_BITS	(sizeof(exp1) * 8)
> @@ -1409,6 +1411,108 @@ static void __init test_bitmap_write_perf(void)
>  
>  #undef TEST_BIT_LEN
>  
> +struct ip_tunnel_flags_test {
> +	const u16	*src_bits;
> +	const u16	*exp_bits;
> +	u8		src_num;
> +	u8		exp_num;
> +	__be16		exp_val;
> +	bool		exp_comp:1;
> +};
> +
> +#define IP_TUNNEL_FLAGS_TEST(src, comp, eval, exp) {	\
> +	.src_bits	= (src),			\
> +	.src_num	= ARRAY_SIZE(src),		\
> +	.exp_comp	= (comp),			\
> +	.exp_val	= (eval),			\
> +	.exp_bits	= (exp),			\
> +	.exp_num	= ARRAY_SIZE(exp),		\
> +}
> +
> +/* These are __be16-compatible and can be compared as is */
> +static const u16 ip_tunnel_flags_1[] __initconst = {
> +	IP_TUNNEL_KEY_BIT,
> +	IP_TUNNEL_STRICT_BIT,
> +	IP_TUNNEL_ERSPAN_OPT_BIT,
> +};
> +
> +/*
> + * Due to the previous flags design limitation, setting either
> + * ``IP_TUNNEL_CSUM_BIT`` (on Big Endian) or ``IP_TUNNEL_DONT_FRAGMENT_BIT``
> + * (on Little) also sets VTI/ISATAP bit. In the bitmap implementation, they
> + * correspond to ``BIT(16)``, which is bigger than ``U16_MAX``, but still is
> + * backward-compatible.
> + */
> +#ifdef __BIG_ENDIAN
> +#define IP_TUNNEL_CONFLICT_BIT	IP_TUNNEL_CSUM_BIT
> +#else
> +#define IP_TUNNEL_CONFLICT_BIT	IP_TUNNEL_DONT_FRAGMENT_BIT
> +#endif
> +
> +static const u16 ip_tunnel_flags_2_src[] __initconst = {
> +	IP_TUNNEL_CONFLICT_BIT,
> +};
> +
> +static const u16 ip_tunnel_flags_2_exp[] __initconst = {
> +	IP_TUNNEL_CONFLICT_BIT,
> +	IP_TUNNEL_SIT_ISATAP_BIT,
> +};
> +
> +/* Bits 17 and higher are not compatible with __be16 flags */
> +static const u16 ip_tunnel_flags_3_src[] __initconst = {
> +	IP_TUNNEL_VXLAN_OPT_BIT,
> +	17,
> +	18,
> +	20,
> +};
> +
> +static const u16 ip_tunnel_flags_3_exp[] __initconst = {
> +	IP_TUNNEL_VXLAN_OPT_BIT,
> +};
> +
> +static const struct ip_tunnel_flags_test ip_tunnel_flags_test[] __initconst = {
> +	IP_TUNNEL_FLAGS_TEST(ip_tunnel_flags_1, true,
> +			     cpu_to_be16(BIT(IP_TUNNEL_KEY_BIT) |
> +					 BIT(IP_TUNNEL_STRICT_BIT) |
> +					 BIT(IP_TUNNEL_ERSPAN_OPT_BIT)),
> +			     ip_tunnel_flags_1),
> +	IP_TUNNEL_FLAGS_TEST(ip_tunnel_flags_2_src, true, VTI_ISVTI,
> +			     ip_tunnel_flags_2_exp),
> +	IP_TUNNEL_FLAGS_TEST(ip_tunnel_flags_3_src,
> +			     /*
> +			      * This must be set to ``false`` once
> +			      * ``__IP_TUNNEL_FLAG_NUM`` goes above 17.
> +			      */
> +			     true,
> +			     cpu_to_be16(BIT(IP_TUNNEL_VXLAN_OPT_BIT)),
> +			     ip_tunnel_flags_3_exp),
> +};
> +
> +static void __init test_ip_tunnel_flags(void)
> +{
> +	for (u32 i = 0; i < ARRAY_SIZE(ip_tunnel_flags_test); i++) {
> +		typeof(*ip_tunnel_flags_test) *test = &ip_tunnel_flags_test[i];
> +		IP_TUNNEL_DECLARE_FLAGS(src) = { };
> +		IP_TUNNEL_DECLARE_FLAGS(exp) = { };
> +		IP_TUNNEL_DECLARE_FLAGS(out);
> +
> +		for (u32 j = 0; j < test->src_num; j++)
> +			__set_bit(test->src_bits[j], src);
> +
> +		for (u32 j = 0; j < test->exp_num; j++)
> +			__set_bit(test->exp_bits[j], exp);
> +
> +		ip_tunnel_flags_from_be16(out, test->exp_val);
> +
> +		expect_eq_uint(test->exp_comp,
> +			       ip_tunnel_flags_is_be16_compat(src));
> +		expect_eq_uint((__force u16)test->exp_val,
> +			       (__force u16)ip_tunnel_flags_to_be16(src));
> +
> +		__ipt_flag_op(expect_eq_bitmap, exp, out);
> +	}
> +}
> +
>  static void __init selftest(void)
>  {
>  	test_zero_clear();
> @@ -1428,6 +1532,7 @@ static void __init selftest(void)
>  	test_bitmap_read_write();
>  	test_bitmap_read_perf();
>  	test_bitmap_write_perf();
> +	test_ip_tunnel_flags();
>  
>  	test_find_nth_bit();
>  	test_for_each_set_bit();
> -- 
> 2.43.0
  

Patch

diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
index 4ee1f8ceb51d..270afc0cba5c 100644
--- a/lib/test_bitmap.c
+++ b/lib/test_bitmap.c
@@ -14,6 +14,8 @@ 
 #include <linux/string.h>
 #include <linux/uaccess.h>
 
+#include <net/ip_tunnels.h>
+
 #include "../tools/testing/selftests/kselftest_module.h"
 
 #define EXP1_IN_BITS	(sizeof(exp1) * 8)
@@ -1409,6 +1411,108 @@  static void __init test_bitmap_write_perf(void)
 
 #undef TEST_BIT_LEN
 
+struct ip_tunnel_flags_test {
+	const u16	*src_bits;
+	const u16	*exp_bits;
+	u8		src_num;
+	u8		exp_num;
+	__be16		exp_val;
+	bool		exp_comp:1;
+};
+
+#define IP_TUNNEL_FLAGS_TEST(src, comp, eval, exp) {	\
+	.src_bits	= (src),			\
+	.src_num	= ARRAY_SIZE(src),		\
+	.exp_comp	= (comp),			\
+	.exp_val	= (eval),			\
+	.exp_bits	= (exp),			\
+	.exp_num	= ARRAY_SIZE(exp),		\
+}
+
+/* These are __be16-compatible and can be compared as is */
+static const u16 ip_tunnel_flags_1[] __initconst = {
+	IP_TUNNEL_KEY_BIT,
+	IP_TUNNEL_STRICT_BIT,
+	IP_TUNNEL_ERSPAN_OPT_BIT,
+};
+
+/*
+ * Due to the previous flags design limitation, setting either
+ * ``IP_TUNNEL_CSUM_BIT`` (on Big Endian) or ``IP_TUNNEL_DONT_FRAGMENT_BIT``
+ * (on Little) also sets VTI/ISATAP bit. In the bitmap implementation, they
+ * correspond to ``BIT(16)``, which is bigger than ``U16_MAX``, but still is
+ * backward-compatible.
+ */
+#ifdef __BIG_ENDIAN
+#define IP_TUNNEL_CONFLICT_BIT	IP_TUNNEL_CSUM_BIT
+#else
+#define IP_TUNNEL_CONFLICT_BIT	IP_TUNNEL_DONT_FRAGMENT_BIT
+#endif
+
+static const u16 ip_tunnel_flags_2_src[] __initconst = {
+	IP_TUNNEL_CONFLICT_BIT,
+};
+
+static const u16 ip_tunnel_flags_2_exp[] __initconst = {
+	IP_TUNNEL_CONFLICT_BIT,
+	IP_TUNNEL_SIT_ISATAP_BIT,
+};
+
+/* Bits 17 and higher are not compatible with __be16 flags */
+static const u16 ip_tunnel_flags_3_src[] __initconst = {
+	IP_TUNNEL_VXLAN_OPT_BIT,
+	17,
+	18,
+	20,
+};
+
+static const u16 ip_tunnel_flags_3_exp[] __initconst = {
+	IP_TUNNEL_VXLAN_OPT_BIT,
+};
+
+static const struct ip_tunnel_flags_test ip_tunnel_flags_test[] __initconst = {
+	IP_TUNNEL_FLAGS_TEST(ip_tunnel_flags_1, true,
+			     cpu_to_be16(BIT(IP_TUNNEL_KEY_BIT) |
+					 BIT(IP_TUNNEL_STRICT_BIT) |
+					 BIT(IP_TUNNEL_ERSPAN_OPT_BIT)),
+			     ip_tunnel_flags_1),
+	IP_TUNNEL_FLAGS_TEST(ip_tunnel_flags_2_src, true, VTI_ISVTI,
+			     ip_tunnel_flags_2_exp),
+	IP_TUNNEL_FLAGS_TEST(ip_tunnel_flags_3_src,
+			     /*
+			      * This must be set to ``false`` once
+			      * ``__IP_TUNNEL_FLAG_NUM`` goes above 17.
+			      */
+			     true,
+			     cpu_to_be16(BIT(IP_TUNNEL_VXLAN_OPT_BIT)),
+			     ip_tunnel_flags_3_exp),
+};
+
+static void __init test_ip_tunnel_flags(void)
+{
+	for (u32 i = 0; i < ARRAY_SIZE(ip_tunnel_flags_test); i++) {
+		typeof(*ip_tunnel_flags_test) *test = &ip_tunnel_flags_test[i];
+		IP_TUNNEL_DECLARE_FLAGS(src) = { };
+		IP_TUNNEL_DECLARE_FLAGS(exp) = { };
+		IP_TUNNEL_DECLARE_FLAGS(out);
+
+		for (u32 j = 0; j < test->src_num; j++)
+			__set_bit(test->src_bits[j], src);
+
+		for (u32 j = 0; j < test->exp_num; j++)
+			__set_bit(test->exp_bits[j], exp);
+
+		ip_tunnel_flags_from_be16(out, test->exp_val);
+
+		expect_eq_uint(test->exp_comp,
+			       ip_tunnel_flags_is_be16_compat(src));
+		expect_eq_uint((__force u16)test->exp_val,
+			       (__force u16)ip_tunnel_flags_to_be16(src));
+
+		__ipt_flag_op(expect_eq_bitmap, exp, out);
+	}
+}
+
 static void __init selftest(void)
 {
 	test_zero_clear();
@@ -1428,6 +1532,7 @@  static void __init selftest(void)
 	test_bitmap_read_write();
 	test_bitmap_read_perf();
 	test_bitmap_write_perf();
+	test_ip_tunnel_flags();
 
 	test_find_nth_bit();
 	test_for_each_set_bit();