bpf: allow wide (u64) aligned stores for some fields of bpf_sock_addr

Since commit cd17d7770578 ("bpf/tools: sync bpf.h") clang decided
that it can do a single u64 store into user_ip6[2] instead of two
separate u32 ones:

 #  17: (18) r2 = 0x100000000000000
 #  ; ctx->user_ip6[2] = bpf_htonl(DST_REWRITE_IP6_2);
 #  19: (7b) *(u64 *)(r1 +16) = r2
 #  invalid bpf_context access off=16 size=8

>From the compiler point of view it does look like a correct thing
to do, so let's support it on the kernel side.

Credit to Andrii Nakryiko for a proper implementation of
bpf_ctx_wide_store_ok.

Cc: Andrii Nakryiko <andriin@fb.com>
Cc: Yonghong Song <yhs@fb.com>
Fixes: cd17d7770578 ("bpf/tools: sync bpf.h")
Reported-by: kernel test robot <rong.a.chen@intel.com>
Acked-by: Yonghong Song <yhs@fb.com>
Acked-by: Andrii Nakryiko <andriin@fb.com>
Signed-off-by: Stanislav Fomichev <sdf@google.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/include/linux/filter.h b/include/linux/filter.h
index 1fe53e78c7e38ad52111a674fc876d5501c56768..6d944369ca876005021a1f010605a661acdc258d 100644 (file)
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -747,6 +747,12 @@ bpf_ctx_narrow_access_ok(u32 off, u32 size, u32 size_default)
        return size <= size_default && (size & (size - 1)) == 0;
 }
 
+#define bpf_ctx_wide_store_ok(off, size, type, field)                  \
+       (size == sizeof(__u64) &&                                       \
+       off >= offsetof(type, field) &&                                 \
+       off + sizeof(__u64) <= offsetofend(type, field) &&              \
+       off % sizeof(__u64) == 0)
+
 #define bpf_classic_proglen(fprog) (fprog->len * sizeof(fprog->filter[0]))
 
 static inline void bpf_prog_lock_ro(struct bpf_prog *fp)

diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index ead27aebf491fd8ad17792b7d35690fe8850b837..c318385aba510db30f3f496c5e003b0bd1440092 100644 (file)
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -3247,7 +3247,7 @@ struct bpf_sock_addr {
        __u32 user_ip4;         /* Allows 1,2,4-byte read and 4-byte write.
                                 * Stored in network byte order.
                                 */
-       __u32 user_ip6[4];      /* Allows 1,2,4-byte read an 4-byte write.
+       __u32 user_ip6[4];      /* Allows 1,2,4-byte read and 4,8-byte write.
                                 * Stored in network byte order.
                                 */
        __u32 user_port;        /* Allows 4-byte read and write.
@@ -3256,10 +3256,10 @@ struct bpf_sock_addr {
        __u32 family;           /* Allows 4-byte read, but no write */
        __u32 type;             /* Allows 4-byte read, but no write */
        __u32 protocol;         /* Allows 4-byte read, but no write */
-       __u32 msg_src_ip4;      /* Allows 1,2,4-byte read an 4-byte write.
+       __u32 msg_src_ip4;      /* Allows 1,2,4-byte read and 4-byte write.
                                 * Stored in network byte order.
                                 */
-       __u32 msg_src_ip6[4];   /* Allows 1,2,4-byte read an 4-byte write.
+       __u32 msg_src_ip6[4];   /* Allows 1,2,4-byte read and 4,8-byte write.
                                 * Stored in network byte order.
                                 */
        __bpf_md_ptr(struct bpf_sock *, sk);

diff --git a/net/core/filter.c b/net/core/filter.c
index 089aaea0ccc6186958797c5fd01ef3516406e741..4481e950f0201d5fc3026554d698eb43e3d119d7 100644 (file)
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -6890,6 +6890,16 @@ static bool sock_addr_is_valid_access(int off, int size,
                        if (!bpf_ctx_narrow_access_ok(off, size, size_default))
                                return false;
                } else {
+                       if (bpf_ctx_wide_store_ok(off, size,
+                                                 struct bpf_sock_addr,
+                                                 user_ip6))
+                               return true;
+
+                       if (bpf_ctx_wide_store_ok(off, size,
+                                                 struct bpf_sock_addr,
+                                                 msg_src_ip6))
+                               return true;
+
                        if (size != size_default)
                                return false;
                }
@@ -7730,9 +7740,6 @@ static u32 xdp_convert_ctx_access(enum bpf_access_type type,
 /* SOCK_ADDR_STORE_NESTED_FIELD_OFF() has semantic similar to
  * SOCK_ADDR_LOAD_NESTED_FIELD_SIZE_OFF() but for store operation.
  *
- * It doesn't support SIZE argument though since narrow stores are not
- * supported for now.
- *
  * In addition it uses Temporary Field TF (member of struct S) as the 3rd
  * "register" since two registers available in convert_ctx_access are not
  * enough: we can't override neither SRC, since it contains value to store, nor
@@ -7740,7 +7747,7 @@ static u32 xdp_convert_ctx_access(enum bpf_access_type type,
  * instructions. But we need a temporary place to save pointer to nested
  * structure whose field we want to store to.
  */
-#define SOCK_ADDR_STORE_NESTED_FIELD_OFF(S, NS, F, NF, OFF, TF)                       \
+#define SOCK_ADDR_STORE_NESTED_FIELD_OFF(S, NS, F, NF, SIZE, OFF, TF)         \
        do {                                                                   \
                int tmp_reg = BPF_REG_9;                                       \
                if (si->src_reg == tmp_reg || si->dst_reg == tmp_reg)          \
@@ -7751,8 +7758,7 @@ static u32 xdp_convert_ctx_access(enum bpf_access_type type,
                                      offsetof(S, TF));                        \
                *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(S, F), tmp_reg,         \
                                      si->dst_reg, offsetof(S, F));            \
-               *insn++ = BPF_STX_MEM(                                         \
-                       BPF_FIELD_SIZEOF(NS, NF), tmp_reg, si->src_reg,        \
+               *insn++ = BPF_STX_MEM(SIZE, tmp_reg, si->src_reg,              \
                        bpf_target_off(NS, NF, FIELD_SIZEOF(NS, NF),           \
                                       target_size)                            \
                                + OFF);                                        \
@@ -7764,8 +7770,8 @@ static u32 xdp_convert_ctx_access(enum bpf_access_type type,
                                                      TF)                      \
        do {                                                                   \
                if (type == BPF_WRITE) {                                       \
-                       SOCK_ADDR_STORE_NESTED_FIELD_OFF(S, NS, F, NF, OFF,    \
-                                                        TF);                  \
+                       SOCK_ADDR_STORE_NESTED_FIELD_OFF(S, NS, F, NF, SIZE,   \
+                                                        OFF, TF);             \
                } else {                                                       \
                        SOCK_ADDR_LOAD_NESTED_FIELD_SIZE_OFF(                  \
                                S, NS, F, NF, SIZE, OFF);  \