bpf, selftests: use bpf_tail_call_static where appropriate

borkmann · kernel-patches-bot · commit 54a47d1a32b6 · 2020-09-28T17:37:48.000-07:00
For those locations where we use an immediate tail call map index use the
newly added bpf_tail_call_static() helper.

Signed-off-by: Daniel Borkmann &lt;daniel@iogearbox.net&gt;
diff --git a/samples/bpf/sockex3_kern.c b/samples/bpf/sockex3_kern.c
@@ -31,28 +31,30 @@ struct {
 #define PARSE_IP 3
 #define PARSE_IPV6 4
 
-/* protocol dispatch routine.
- * It tail-calls next BPF program depending on eth proto
- * Note, we could have used:
- * bpf_tail_call(skb, &jmp_table, proto);
- * but it would need large prog_array
+/* Protocol dispatch routine. It tail-calls next BPF program depending
+ * on eth proto. Note, we could have used ...
+ *
+ *   bpf_tail_call(skb, &jmp_table, proto);
+ *
+ * ... but it would need large prog_array and cannot be optimised given
+ * the map key is not static.
  */
 static inline void parse_eth_proto(struct __sk_buff *skb, u32 proto)
 {
 	switch (proto) {
 	case ETH_P_8021Q:
 	case ETH_P_8021AD:
-		bpf_tail_call(skb, &jmp_table, PARSE_VLAN);
+		bpf_tail_call_static(skb, &jmp_table, PARSE_VLAN);
 		break;
 	case ETH_P_MPLS_UC:
 	case ETH_P_MPLS_MC:
-		bpf_tail_call(skb, &jmp_table, PARSE_MPLS);
+		bpf_tail_call_static(skb, &jmp_table, PARSE_MPLS);
 		break;
 	case ETH_P_IP:
-		bpf_tail_call(skb, &jmp_table, PARSE_IP);
+		bpf_tail_call_static(skb, &jmp_table, PARSE_IP);
 		break;
 	case ETH_P_IPV6:
-		bpf_tail_call(skb, &jmp_table, PARSE_IPV6);
+		bpf_tail_call_static(skb, &jmp_table, PARSE_IPV6);
 		break;
 	}
 }
diff --git a/tools/testing/selftests/bpf/progs/bpf_flow.c b/tools/testing/selftests/bpf/progs/bpf_flow.c
@@ -118,18 +118,18 @@ static __always_inline int parse_eth_proto(struct __sk_buff *skb, __be16 proto)
 
 	switch (proto) {
 	case bpf_htons(ETH_P_IP):
-		bpf_tail_call(skb, &jmp_table, IP);
+		bpf_tail_call_static(skb, &jmp_table, IP);
 		break;
 	case bpf_htons(ETH_P_IPV6):
-		bpf_tail_call(skb, &jmp_table, IPV6);
+		bpf_tail_call_static(skb, &jmp_table, IPV6);
 		break;
 	case bpf_htons(ETH_P_MPLS_MC):
 	case bpf_htons(ETH_P_MPLS_UC):
-		bpf_tail_call(skb, &jmp_table, MPLS);
+		bpf_tail_call_static(skb, &jmp_table, MPLS);
 		break;
 	case bpf_htons(ETH_P_8021Q):
 	case bpf_htons(ETH_P_8021AD):
-		bpf_tail_call(skb, &jmp_table, VLAN);
+		bpf_tail_call_static(skb, &jmp_table, VLAN);
 		break;
 	default:
 		/* Protocol not supported */
@@ -246,10 +246,10 @@ static __always_inline int parse_ipv6_proto(struct __sk_buff *skb, __u8 nexthdr)
 	switch (nexthdr) {
 	case IPPROTO_HOPOPTS:
 	case IPPROTO_DSTOPTS:
-		bpf_tail_call(skb, &jmp_table, IPV6OP);
+		bpf_tail_call_static(skb, &jmp_table, IPV6OP);
 		break;
 	case IPPROTO_FRAGMENT:
-		bpf_tail_call(skb, &jmp_table, IPV6FR);
+		bpf_tail_call_static(skb, &jmp_table, IPV6FR);
 		break;
 	default:
 		return parse_ip_proto(skb, nexthdr);
diff --git a/tools/testing/selftests/bpf/progs/tailcall1.c b/tools/testing/selftests/bpf/progs/tailcall1.c
@@ -26,20 +26,20 @@ int entry(struct __sk_buff *skb)
 	/* Multiple locations to make sure we patch
 	 * all of them.
 	 */
-	bpf_tail_call(skb, &jmp_table, 0);
-	bpf_tail_call(skb, &jmp_table, 0);
-	bpf_tail_call(skb, &jmp_table, 0);
-	bpf_tail_call(skb, &jmp_table, 0);
-
-	bpf_tail_call(skb, &jmp_table, 1);
-	bpf_tail_call(skb, &jmp_table, 1);
-	bpf_tail_call(skb, &jmp_table, 1);
-	bpf_tail_call(skb, &jmp_table, 1);
-
-	bpf_tail_call(skb, &jmp_table, 2);
-	bpf_tail_call(skb, &jmp_table, 2);
-	bpf_tail_call(skb, &jmp_table, 2);
-	bpf_tail_call(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
+
+	bpf_tail_call_static(skb, &jmp_table, 1);
+	bpf_tail_call_static(skb, &jmp_table, 1);
+	bpf_tail_call_static(skb, &jmp_table, 1);
+	bpf_tail_call_static(skb, &jmp_table, 1);
+
+	bpf_tail_call_static(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 2);
 
 	return 3;
 }
diff --git a/tools/testing/selftests/bpf/progs/tailcall2.c b/tools/testing/selftests/bpf/progs/tailcall2.c
@@ -13,14 +13,14 @@ struct {
 SEC("classifier/0")
 int bpf_func_0(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 1);
+	bpf_tail_call_static(skb, &jmp_table, 1);
 	return 0;
 }
 
 SEC("classifier/1")
 int bpf_func_1(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 2);
 	return 1;
 }
 
@@ -33,25 +33,25 @@ int bpf_func_2(struct __sk_buff *skb)
 SEC("classifier/3")
 int bpf_func_3(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 4);
+	bpf_tail_call_static(skb, &jmp_table, 4);
 	return 3;
 }
 
 SEC("classifier/4")
 int bpf_func_4(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 3);
+	bpf_tail_call_static(skb, &jmp_table, 3);
 	return 4;
 }
 
 SEC("classifier")
 int entry(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 	/* Check multi-prog update. */
-	bpf_tail_call(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 2);
 	/* Check tail call limit. */
-	bpf_tail_call(skb, &jmp_table, 3);
+	bpf_tail_call_static(skb, &jmp_table, 3);
 	return 3;
 }
 
diff --git a/tools/testing/selftests/bpf/progs/tailcall3.c b/tools/testing/selftests/bpf/progs/tailcall3.c
@@ -16,14 +16,14 @@ SEC("classifier/0")
 int bpf_func_0(struct __sk_buff *skb)
 {
 	count++;
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 	return 1;
 }
 
 SEC("classifier")
 int entry(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 	return 0;
 }
 
diff --git a/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf1.c b/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf1.c
@@ -21,15 +21,15 @@ TAIL_FUNC(1)
 static __noinline
 int subprog_tail(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 
 	return skb->len * 2;
 }
 
 SEC("classifier")
 int entry(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 1);
+	bpf_tail_call_static(skb, &jmp_table, 1);
 
 	return subprog_tail(skb);
 }
diff --git a/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf2.c b/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf2.c
@@ -14,9 +14,9 @@ static __noinline
 int subprog_tail(struct __sk_buff *skb)
 {
 	if (load_byte(skb, 0))
-		bpf_tail_call(skb, &jmp_table, 1);
+		bpf_tail_call_static(skb, &jmp_table, 1);
 	else
-		bpf_tail_call(skb, &jmp_table, 0);
+		bpf_tail_call_static(skb, &jmp_table, 0);
 	return 1;
 }
 
@@ -32,7 +32,7 @@ int bpf_func_0(struct __sk_buff *skb)
 SEC("classifier")
 int entry(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 
 	return 0;
 }
diff --git a/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf3.c b/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf3.c
@@ -16,9 +16,9 @@ int subprog_tail2(struct __sk_buff *skb)
 	volatile char arr[64] = {};
 
 	if (load_word(skb, 0) || load_half(skb, 0))
-		bpf_tail_call(skb, &jmp_table, 10);
+		bpf_tail_call_static(skb, &jmp_table, 10);
 	else
-		bpf_tail_call(skb, &jmp_table, 1);
+		bpf_tail_call_static(skb, &jmp_table, 1);
 
 	return skb->len;
 }
@@ -28,7 +28,7 @@ int subprog_tail(struct __sk_buff *skb)
 {
 	volatile char arr[64] = {};
 
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 
 	return skb->len * 2;
 }
diff --git a/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf4.c b/tools/testing/selftests/bpf/progs/tailcall_bpf2bpf4.c
@@ -14,21 +14,21 @@ static volatile int count;
 __noinline
 int subprog_tail_2(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 2);
+	bpf_tail_call_static(skb, &jmp_table, 2);
 	return skb->len * 3;
 }
 
 __noinline
 int subprog_tail_1(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 1);
+	bpf_tail_call_static(skb, &jmp_table, 1);
 	return skb->len * 2;
 }
 
 __noinline
 int subprog_tail(struct __sk_buff *skb)
 {
-	bpf_tail_call(skb, &jmp_table, 0);
+	bpf_tail_call_static(skb, &jmp_table, 0);
 	return skb->len;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,14 @@ struct {`
`13`	`13`	`SEC("classifier/0")`
`14`	`14`	`int bpf_func_0(struct __sk_buff *skb)`
`15`	`15`	`{`
`16`		`- bpf_tail_call(skb, &jmp_table, 1);`
	`16`	`+ bpf_tail_call_static(skb, &jmp_table, 1);`
`17`	`17`	`return 0;`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`SEC("classifier/1")`
`21`	`21`	`int bpf_func_1(struct __sk_buff *skb)`
`22`	`22`	`{`
`23`		`- bpf_tail_call(skb, &jmp_table, 2);`
	`23`	`+ bpf_tail_call_static(skb, &jmp_table, 2);`
`24`	`24`	`return 1;`
`25`	`25`	`}`
`26`	`26`
`@@ -33,25 +33,25 @@ int bpf_func_2(struct __sk_buff *skb)`
`33`	`33`	`SEC("classifier/3")`
`34`	`34`	`int bpf_func_3(struct __sk_buff *skb)`
`35`	`35`	`{`
`36`		`- bpf_tail_call(skb, &jmp_table, 4);`
	`36`	`+ bpf_tail_call_static(skb, &jmp_table, 4);`
`37`	`37`	`return 3;`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`SEC("classifier/4")`
`41`	`41`	`int bpf_func_4(struct __sk_buff *skb)`
`42`	`42`	`{`
`43`		`- bpf_tail_call(skb, &jmp_table, 3);`
	`43`	`+ bpf_tail_call_static(skb, &jmp_table, 3);`
`44`	`44`	`return 4;`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`SEC("classifier")`
`48`	`48`	`int entry(struct __sk_buff *skb)`
`49`	`49`	`{`
`50`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`50`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`51`	`51`	`/* Check multi-prog update. */`
`52`		`- bpf_tail_call(skb, &jmp_table, 2);`
	`52`	`+ bpf_tail_call_static(skb, &jmp_table, 2);`
`53`	`53`	`/* Check tail call limit. */`
`54`		`- bpf_tail_call(skb, &jmp_table, 3);`
	`54`	`+ bpf_tail_call_static(skb, &jmp_table, 3);`
`55`	`55`	`return 3;`
`56`	`56`	`}`
`57`	`57`
Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,14 @@ SEC("classifier/0")`
`16`	`16`	`int bpf_func_0(struct __sk_buff *skb)`
`17`	`17`	`{`
`18`	`18`	`count++;`
`19`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`19`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`20`	`20`	`return 1;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`SEC("classifier")`
`24`	`24`	`int entry(struct __sk_buff *skb)`
`25`	`25`	`{`
`26`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`26`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`27`	`27`	`return 0;`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -21,15 +21,15 @@ TAIL_FUNC(1)`
`21`	`21`	`static __noinline`
`22`	`22`	`int subprog_tail(struct __sk_buff *skb)`
`23`	`23`	`{`
`24`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`24`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`25`	`25`
`26`	`26`	`return skb->len * 2;`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`SEC("classifier")`
`30`	`30`	`int entry(struct __sk_buff *skb)`
`31`	`31`	`{`
`32`		`- bpf_tail_call(skb, &jmp_table, 1);`
	`32`	`+ bpf_tail_call_static(skb, &jmp_table, 1);`
`33`	`33`
`34`	`34`	`return subprog_tail(skb);`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,9 @@ static __noinline`
`14`	`14`	`int subprog_tail(struct __sk_buff *skb)`
`15`	`15`	`{`
`16`	`16`	`if (load_byte(skb, 0))`
`17`		`- bpf_tail_call(skb, &jmp_table, 1);`
	`17`	`+ bpf_tail_call_static(skb, &jmp_table, 1);`
`18`	`18`	`else`
`19`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`19`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`20`	`20`	`return 1;`
`21`	`21`	`}`
`22`	`22`
`@@ -32,7 +32,7 @@ int bpf_func_0(struct __sk_buff *skb)`
`32`	`32`	`SEC("classifier")`
`33`	`33`	`int entry(struct __sk_buff *skb)`
`34`	`34`	`{`
`35`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`35`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`36`	`36`
`37`	`37`	`return 0;`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,9 +16,9 @@ int subprog_tail2(struct __sk_buff *skb)`
`16`	`16`	`volatile char arr[64] = {};`
`17`	`17`
`18`	`18`	`if (load_word(skb, 0) \|\| load_half(skb, 0))`
`19`		`- bpf_tail_call(skb, &jmp_table, 10);`
	`19`	`+ bpf_tail_call_static(skb, &jmp_table, 10);`
`20`	`20`	`else`
`21`		`- bpf_tail_call(skb, &jmp_table, 1);`
	`21`	`+ bpf_tail_call_static(skb, &jmp_table, 1);`
`22`	`22`
`23`	`23`	`return skb->len;`
`24`	`24`	`}`
`@@ -28,7 +28,7 @@ int subprog_tail(struct __sk_buff *skb)`
`28`	`28`	`{`
`29`	`29`	`volatile char arr[64] = {};`
`30`	`30`
`31`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`31`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`32`	`32`
`33`	`33`	`return skb->len * 2;`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,21 +14,21 @@ static volatile int count;`
`14`	`14`	`__noinline`
`15`	`15`	`int subprog_tail_2(struct __sk_buff *skb)`
`16`	`16`	`{`
`17`		`- bpf_tail_call(skb, &jmp_table, 2);`
	`17`	`+ bpf_tail_call_static(skb, &jmp_table, 2);`
`18`	`18`	`return skb->len * 3;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`__noinline`
`22`	`22`	`int subprog_tail_1(struct __sk_buff *skb)`
`23`	`23`	`{`
`24`		`- bpf_tail_call(skb, &jmp_table, 1);`
	`24`	`+ bpf_tail_call_static(skb, &jmp_table, 1);`
`25`	`25`	`return skb->len * 2;`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`__noinline`
`29`	`29`	`int subprog_tail(struct __sk_buff *skb)`
`30`	`30`	`{`
`31`		`- bpf_tail_call(skb, &jmp_table, 0);`
	`31`	`+ bpf_tail_call_static(skb, &jmp_table, 0);`
`32`	`32`	`return skb->len;`
`33`	`33`	`}`
`34`	`34`