5.10-stable patches

added patches:
	bpf-add-selftests-to-cover-packet-access-corner-cases.patch
	doc-gcc-plugins-update-gcc-plugins.rst.patch
	documentation-kbuild-remove-references-to-gcc-plugin.sh.patch
	kbuild-simplify-gcc_plugins-enablement-in-dummy-tools-gcc.patch
	maintainers-adjust-gcc-plugins-after-gcc-plugin.sh-removal.patch

diff --git a/queue-5.10/bpf-add-selftests-to-cover-packet-access-corner-cases.patch b/queue-5.10/bpf-add-selftests-to-cover-packet-access-corner-cases.patch
new file mode 100644 (file)
index 0000000..a33b995
--- /dev/null
+++ b/queue-5.10/bpf-add-selftests-to-cover-packet-access-corner-cases.patch
@@ -0,0 +1,809 @@
+From b560b21f71eb4ef9dfc7c8ec1d0e4d7f9aa54b51 Mon Sep 17 00:00:00 2001
+From: Maxim Mikityanskiy <maximmi@nvidia.com>
+Date: Tue, 7 Dec 2021 10:15:21 +0200
+Subject: bpf: Add selftests to cover packet access corner cases
+
+From: Maxim Mikityanskiy <maximmi@nvidia.com>
+
+commit b560b21f71eb4ef9dfc7c8ec1d0e4d7f9aa54b51 upstream.
+
+This commit adds BPF verifier selftests that cover all corner cases by
+packet boundary checks. Specifically, 8-byte packet reads are tested at
+the beginning of data and at the beginning of data_meta, using all kinds
+of boundary checks (all comparison operators: <, >, <=, >=; both
+permutations of operands: data + length compared to end, end compared to
+data + length). For each case there are three tests:
+
+1. Length is just enough for an 8-byte read. Length is either 7 or 8,
+   depending on the comparison.
+
+2. Length is increased by 1 - should still pass the verifier. These
+   cases are useful, because they failed before commit 2fa7d94afc1a
+   ("bpf: Fix the off-by-two error in range markings").
+
+3. Length is decreased by 1 - should be rejected by the verifier.
+
+Some existing tests are just renamed to avoid duplication.
+
+Signed-off-by: Maxim Mikityanskiy <maximmi@nvidia.com>
+Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
+Link: https://lore.kernel.org/bpf/20211207081521.41923-1-maximmi@nvidia.com
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ tools/testing/selftests/bpf/verifier/xdp_direct_packet_access.c |  600 +++++++++-
+ 1 file changed, 584 insertions(+), 16 deletions(-)
+
+--- a/tools/testing/selftests/bpf/verifier/xdp_direct_packet_access.c
++++ b/tools/testing/selftests/bpf/verifier/xdp_direct_packet_access.c
+@@ -35,7 +35,7 @@
+       .prog_type = BPF_PROG_TYPE_XDP,
+ },
+ {
+-      "XDP pkt read, pkt_data' > pkt_end, good access",
++      "XDP pkt read, pkt_data' > pkt_end, corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -88,6 +88,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_data' > pkt_end, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data' > pkt_end, corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_end > pkt_data', good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+@@ -106,7 +141,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_end > pkt_data', bad access 1",
++      "XDP pkt read, pkt_end > pkt_data', corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -143,6 +178,42 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_end > pkt_data', corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_end > pkt_data', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_data' < pkt_end, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+@@ -161,7 +232,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data' < pkt_end, bad access 1",
++      "XDP pkt read, pkt_data' < pkt_end, corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -198,7 +269,43 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_end < pkt_data', good access",
++      "XDP pkt read, pkt_data' < pkt_end, corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data' < pkt_end, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_end < pkt_data', corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -251,6 +358,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_end < pkt_data', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_end < pkt_data', corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_data' >= pkt_end, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+@@ -268,7 +410,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data' >= pkt_end, bad access 1",
++      "XDP pkt read, pkt_data' >= pkt_end, corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -304,7 +446,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_end >= pkt_data', good access",
++      "XDP pkt read, pkt_data' >= pkt_end, corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data' >= pkt_end, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_end >= pkt_data', corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -359,7 +535,44 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data' <= pkt_end, good access",
++      "XDP pkt read, pkt_end >= pkt_data', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_end >= pkt_data', corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data' <= pkt_end, corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -414,6 +627,43 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_data' <= pkt_end, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data' <= pkt_end, corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_end <= pkt_data', good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+@@ -431,7 +681,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_end <= pkt_data', bad access 1",
++      "XDP pkt read, pkt_end <= pkt_data', corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+@@ -467,7 +717,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_meta' > pkt_data, good access",
++      "XDP pkt read, pkt_end <= pkt_data', corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_end <= pkt_data', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
++                  offsetof(struct xdp_md, data_end)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_meta' > pkt_data, corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -520,6 +804,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_meta' > pkt_data, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_meta' > pkt_data, corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_data > pkt_meta', good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+@@ -538,7 +857,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data > pkt_meta', bad access 1",
++      "XDP pkt read, pkt_data > pkt_meta', corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -575,6 +894,42 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_data > pkt_meta', corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data > pkt_meta', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_meta' < pkt_data, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+@@ -593,7 +948,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_meta' < pkt_data, bad access 1",
++      "XDP pkt read, pkt_meta' < pkt_data, corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -630,7 +985,43 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data < pkt_meta', good access",
++      "XDP pkt read, pkt_meta' < pkt_data, corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_meta' < pkt_data, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data < pkt_meta', corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -683,6 +1074,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_data < pkt_meta', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data < pkt_meta', corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_meta' >= pkt_data, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+@@ -700,7 +1126,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_meta' >= pkt_data, bad access 1",
++      "XDP pkt read, pkt_meta' >= pkt_data, corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -736,7 +1162,41 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data >= pkt_meta', good access",
++      "XDP pkt read, pkt_meta' >= pkt_data, corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_meta' >= pkt_data, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data >= pkt_meta', corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -791,7 +1251,44 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_meta' <= pkt_data, good access",
++      "XDP pkt read, pkt_data >= pkt_meta', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data >= pkt_meta', corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_meta' <= pkt_data, corner case, good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -846,6 +1343,43 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
++      "XDP pkt read, pkt_meta' <= pkt_data, corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_meta' <= pkt_data, corner case -1, bad access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
++      BPF_JMP_IMM(BPF_JA, 0, 0, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .errstr = "R1 offset is outside of the packet",
++      .result = REJECT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
+       "XDP pkt read, pkt_data <= pkt_meta', good access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+@@ -863,7 +1397,7 @@
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
+ {
+-      "XDP pkt read, pkt_data <= pkt_meta', bad access 1",
++      "XDP pkt read, pkt_data <= pkt_meta', corner case -1, bad access",
+       .insns = {
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                   offsetof(struct xdp_md, data_meta)),
+@@ -898,3 +1432,37 @@
+       .prog_type = BPF_PROG_TYPE_XDP,
+       .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+ },
++{
++      "XDP pkt read, pkt_data <= pkt_meta', corner case, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},
++{
++      "XDP pkt read, pkt_data <= pkt_meta', corner case +1, good access",
++      .insns = {
++      BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
++                  offsetof(struct xdp_md, data_meta)),
++      BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
++      BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
++      BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
++      BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
++      BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
++      BPF_MOV64_IMM(BPF_REG_0, 0),
++      BPF_EXIT_INSN(),
++      },
++      .result = ACCEPT,
++      .prog_type = BPF_PROG_TYPE_XDP,
++      .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
++},

diff --git a/queue-5.10/doc-gcc-plugins-update-gcc-plugins.rst.patch b/queue-5.10/doc-gcc-plugins-update-gcc-plugins.rst.patch
new file mode 100644 (file)
index 0000000..63db517
--- /dev/null
+++ b/queue-5.10/doc-gcc-plugins-update-gcc-plugins.rst.patch
@@ -0,0 +1,148 @@
+From 9b6164342e981d751e69f5a165dd596ffcdfd6fe Mon Sep 17 00:00:00 2001
+From: Masahiro Yamada <masahiroy@kernel.org>
+Date: Sat, 23 Jan 2021 22:33:33 +0900
+Subject: doc: gcc-plugins: update gcc-plugins.rst
+
+From: Masahiro Yamada <masahiroy@kernel.org>
+
+commit 9b6164342e981d751e69f5a165dd596ffcdfd6fe upstream.
+
+This document was written a long time ago. Update it.
+
+[1] Drop the version information
+
+The range of the supported GCC versions are always changing. The
+current minimal GCC version is 4.9, and commit 1e860048c53e
+("gcc-plugins: simplify GCC plugin-dev capability test") removed the
+old code accordingly.
+
+We do not need to mention specific version ranges like "all gcc versions
+from 4.5 to 6.0" since we forget to update the documentation when we
+raise the minimal compiler version.
+
+[2] Drop the C compiler statements
+
+Since commit 77342a02ff6e ("gcc-plugins: drop support for GCC <= 4.7")
+the GCC plugin infrastructure only supports g++.
+
+[3] Drop supported architectures
+
+As of v5.11-rc4, the infrastructure supports more architectures;
+arm, arm64, mips, powerpc, riscv, s390, um, and x86. (just grep
+"select HAVE_GCC_PLUGINS") Again, we miss to update this document when a
+new architecture is supported. Let's just say "only some architectures".
+
+[4] Update the apt-get example
+
+We are now discussing to bump the minimal version to GCC 5. The GCC 4.9
+support will be removed sooner or later. Change the package example to
+gcc-10-plugin-dev while we are here.
+
+[5] Update the build target
+
+Since commit ce2fd53a10c7 ("kbuild: descend into scripts/gcc-plugins/
+via scripts/Makefile"), "make gcc-plugins" is not supported.
+"make scripts" builds all the enabled plugins, including some other
+tools.
+
+[6] Update the steps for adding a new plugin
+
+At first, all CONFIG options for GCC plugins were located in arch/Kconfig.
+After commit 45332b1bdfdc ("gcc-plugins: split out Kconfig entries to
+scripts/gcc-plugins/Kconfig"), scripts/gcc-plugins/Kconfig became the
+central place to collect plugin CONFIG options. In my understanding,
+this requirement no longer exists because commit 9f671e58159a ("security:
+Create "kernel hardening" config area") moved some of plugin CONFIG
+options to another file. Find an appropriate place to add the new CONFIG.
+
+The sub-directory support was never used by anyone, and removed by
+commit c17d6179ad5a ("gcc-plugins: remove unused GCC_PLUGIN_SUBDIR").
+
+Remove the useless $(src)/ prefix.
+
+Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ Documentation/kbuild/gcc-plugins.rst |   43 +++++++++++++++++------------------
+ 1 file changed, 22 insertions(+), 21 deletions(-)
+
+--- a/Documentation/kbuild/gcc-plugins.rst
++++ b/Documentation/kbuild/gcc-plugins.rst
+@@ -11,16 +11,13 @@ compiler [1]_. They are useful for runti
+ We can analyse, change and add further code during compilation via
+ callbacks [2]_, GIMPLE [3]_, IPA [4]_ and RTL passes [5]_.
+ 
+-The GCC plugin infrastructure of the kernel supports all gcc versions from
+-4.5 to 6.0, building out-of-tree modules, cross-compilation and building in a
+-separate directory.
+-Plugin source files have to be compilable by both a C and a C++ compiler as well
+-because gcc versions 4.5 and 4.6 are compiled by a C compiler,
+-gcc-4.7 can be compiled by a C or a C++ compiler,
+-and versions 4.8+ can only be compiled by a C++ compiler.
+-
+-Currently the GCC plugin infrastructure supports only the x86, arm, arm64 and
+-powerpc architectures.
++The GCC plugin infrastructure of the kernel supports building out-of-tree
++modules, cross-compilation and building in a separate directory.
++Plugin source files have to be compilable by a C++ compiler.
++
++Currently the GCC plugin infrastructure supports only some architectures.
++Grep "select HAVE_GCC_PLUGINS" to find out which architectures support
++GCC plugins.
+ 
+ This infrastructure was ported from grsecurity [6]_ and PaX [7]_.
+ 
+@@ -59,8 +56,7 @@ $(src)/scripts/gcc-plugins/gcc-generate-
+ $(src)/scripts/gcc-plugins/gcc-generate-rtl-pass.h**
+ 
+       These headers automatically generate the registration structures for
+-      GIMPLE, SIMPLE_IPA, IPA and RTL passes. They support all gcc versions
+-      from 4.5 to 6.0.
++      GIMPLE, SIMPLE_IPA, IPA and RTL passes.
+       They should be preferred to creating the structures by hand.
+ 
+ 
+@@ -68,21 +64,25 @@ Usage
+ =====
+ 
+ You must install the gcc plugin headers for your gcc version,
+-e.g., on Ubuntu for gcc-4.9::
++e.g., on Ubuntu for gcc-10::
+ 
+-      apt-get install gcc-4.9-plugin-dev
++      apt-get install gcc-10-plugin-dev
+ 
+ Or on Fedora::
+ 
+       dnf install gcc-plugin-devel
+ 
+-Enable a GCC plugin based feature in the kernel config::
++Enable the GCC plugin infrastructure and some plugin(s) you want to use
++in the kernel config::
+ 
+-      CONFIG_GCC_PLUGIN_CYC_COMPLEXITY = y
++      CONFIG_GCC_PLUGINS=y
++      CONFIG_GCC_PLUGIN_CYC_COMPLEXITY=y
++      CONFIG_GCC_PLUGIN_LATENT_ENTROPY=y
++      ...
+ 
+-To compile only the plugin(s)::
++To compile the minimum tool set including the plugin(s)::
+ 
+-      make gcc-plugins
++      make scripts
+ 
+ or just run the kernel make and compile the whole kernel with
+ the cyclomatic complexity GCC plugin.
+@@ -91,7 +91,8 @@ the cyclomatic complexity GCC plugin.
+ 4. How to add a new GCC plugin
+ ==============================
+ 
+-The GCC plugins are in $(src)/scripts/gcc-plugins/. You can use a file or a directory
+-here. It must be added to $(src)/scripts/gcc-plugins/Makefile,
+-$(src)/scripts/Makefile.gcc-plugins and $(src)/arch/Kconfig.
++The GCC plugins are in scripts/gcc-plugins/. You need to put plugin source files
++right under scripts/gcc-plugins/. Creating subdirectories is not supported.
++It must be added to scripts/gcc-plugins/Makefile, scripts/Makefile.gcc-plugins
++and a relevant Kconfig file.
+ See the cyc_complexity_plugin.c (CONFIG_GCC_PLUGIN_CYC_COMPLEXITY) GCC plugin.

diff --git a/queue-5.10/documentation-kbuild-remove-references-to-gcc-plugin.sh.patch b/queue-5.10/documentation-kbuild-remove-references-to-gcc-plugin.sh.patch
new file mode 100644 (file)
index 0000000..daeb509
--- /dev/null
+++ b/queue-5.10/documentation-kbuild-remove-references-to-gcc-plugin.sh.patch
@@ -0,0 +1,35 @@
+From 1cabe74f148f7b99d9f08274a62467f96c870f07 Mon Sep 17 00:00:00 2001
+From: Robert Karszniewicz <r.karszniewicz@phytec.de>
+Date: Fri, 22 Jan 2021 19:04:13 +0100
+Subject: Documentation/Kbuild: Remove references to gcc-plugin.sh
+
+From: Robert Karszniewicz <r.karszniewicz@phytec.de>
+
+commit 1cabe74f148f7b99d9f08274a62467f96c870f07 upstream.
+
+gcc-plugin.sh has been removed in commit
+1e860048c53e ("gcc-plugins: simplify GCC plugin-dev capability test").
+
+Signed-off-by: Robert Karszniewicz <r.karszniewicz@phytec.de>
+Reviewed-by: Kees Cook <keescook@chromium.org>
+Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ Documentation/kbuild/gcc-plugins.rst |    6 ------
+ 1 file changed, 6 deletions(-)
+
+--- a/Documentation/kbuild/gcc-plugins.rst
++++ b/Documentation/kbuild/gcc-plugins.rst
+@@ -44,12 +44,6 @@ Files
+       This is a compatibility header for GCC plugins.
+       It should be always included instead of individual gcc headers.
+ 
+-**$(src)/scripts/gcc-plugin.sh**
+-
+-      This script checks the availability of the included headers in
+-      gcc-common.h and chooses the proper host compiler to build the plugins
+-      (gcc-4.7 can be built by either gcc or g++).
+-
+ **$(src)/scripts/gcc-plugins/gcc-generate-gimple-pass.h,
+ $(src)/scripts/gcc-plugins/gcc-generate-ipa-pass.h,
+ $(src)/scripts/gcc-plugins/gcc-generate-simple_ipa-pass.h,

diff --git a/queue-5.10/kbuild-simplify-gcc_plugins-enablement-in-dummy-tools-gcc.patch b/queue-5.10/kbuild-simplify-gcc_plugins-enablement-in-dummy-tools-gcc.patch
new file mode 100644 (file)
index 0000000..83c6270
--- /dev/null
+++ b/queue-5.10/kbuild-simplify-gcc_plugins-enablement-in-dummy-tools-gcc.patch
@@ -0,0 +1,41 @@
+From f4c3b83b75b91c5059726cb91e3165cc01764ce7 Mon Sep 17 00:00:00 2001
+From: Masahiro Yamada <masahiroy@kernel.org>
+Date: Sat, 23 Jan 2021 18:16:30 +0900
+Subject: kbuild: simplify GCC_PLUGINS enablement in dummy-tools/gcc
+
+From: Masahiro Yamada <masahiroy@kernel.org>
+
+commit f4c3b83b75b91c5059726cb91e3165cc01764ce7 upstream.
+
+With commit 1e860048c53e ("gcc-plugins: simplify GCC plugin-dev
+capability test") applied, this hunk can be way simplified because
+now scripts/gcc-plugins/Kconfig only checks plugin-version.h
+
+Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ scripts/dummy-tools/gcc |   10 +++-------
+ 1 file changed, 3 insertions(+), 7 deletions(-)
+
+--- a/scripts/dummy-tools/gcc
++++ b/scripts/dummy-tools/gcc
+@@ -75,16 +75,12 @@ if arg_contain -S "$@"; then
+       fi
+ fi
+ 
+-# For scripts/gcc-plugin.sh
++# To set GCC_PLUGINS
+ if arg_contain -print-file-name=plugin "$@"; then
+       plugin_dir=$(mktemp -d)
+ 
+-      sed -n 's/.*#include "\(.*\)"/\1/p' $(dirname $0)/../gcc-plugins/gcc-common.h |
+-      while read header
+-      do
+-              mkdir -p $plugin_dir/include/$(dirname $header)
+-              touch $plugin_dir/include/$header
+-      done
++      mkdir -p $plugin_dir/include
++      touch $plugin_dir/include/plugin-version.h
+ 
+       echo $plugin_dir
+       exit 0

diff --git a/queue-5.10/maintainers-adjust-gcc-plugins-after-gcc-plugin.sh-removal.patch b/queue-5.10/maintainers-adjust-gcc-plugins-after-gcc-plugin.sh-removal.patch
new file mode 100644 (file)
index 0000000..5de03ec
--- /dev/null
+++ b/queue-5.10/maintainers-adjust-gcc-plugins-after-gcc-plugin.sh-removal.patch
@@ -0,0 +1,35 @@
+From 5136bb8c8b5872676f397b27f93a30568baf3a25 Mon Sep 17 00:00:00 2001
+From: Lukas Bulwahn <lukas.bulwahn@gmail.com>
+Date: Sat, 19 Dec 2020 17:24:56 +0100
+Subject: MAINTAINERS: adjust GCC PLUGINS after gcc-plugin.sh removal
+
+From: Lukas Bulwahn <lukas.bulwahn@gmail.com>
+
+commit 5136bb8c8b5872676f397b27f93a30568baf3a25 upstream.
+
+Commit 1e860048c53e ("gcc-plugins: simplify GCC plugin-dev capability test")
+removed ./scripts/gcc-plugin.sh, but missed to adjust MAINTAINERS.
+
+Hence, ./scripts/get_maintainers.pl --self-test=patterns warns:
+
+  warning: no file matches    F:    scripts/gcc-plugin.sh
+
+Adjust entries in GGC PLUGINS section after this file removal.
+
+Signed-off-by: Lukas Bulwahn <lukas.bulwahn@gmail.com>
+Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ MAINTAINERS |    1 -
+ 1 file changed, 1 deletion(-)
+
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -7310,7 +7310,6 @@ L:       linux-hardening@vger.kernel.org
+ S:    Maintained
+ F:    Documentation/kbuild/gcc-plugins.rst
+ F:    scripts/Makefile.gcc-plugins
+-F:    scripts/gcc-plugin.sh
+ F:    scripts/gcc-plugins/
+ 
+ GCOV BASED KERNEL PROFILING

diff --git a/queue-5.10/series b/queue-5.10/series
index 414e279b6703c12d57480f25378756a2cfed509b..1ff89303c076d9f9f922cebaf272c5b64eeca6bd 100644 (file)
--- a/queue-5.10/series
+++ b/queue-5.10/series
@@ -125,3 +125,8 @@ irqchip-armada-370-xp-fix-support-for-multi-msi-interrupts.patch
 irqchip-irq-gic-v3-its.c-force-synchronisation-when-issuing-invall.patch
 irqchip-nvic-fix-offset-for-interrupt-priority-offsets.patch
 misc-fastrpc-fix-improper-packet-size-calculation.patch
+bpf-add-selftests-to-cover-packet-access-corner-cases.patch
+kbuild-simplify-gcc_plugins-enablement-in-dummy-tools-gcc.patch
+doc-gcc-plugins-update-gcc-plugins.rst.patch
+maintainers-adjust-gcc-plugins-after-gcc-plugin.sh-removal.patch
+documentation-kbuild-remove-references-to-gcc-plugin.sh.patch