bpf: verifier: set reg_type on context accesses in second pass

Use a simplified is_valid_access() callback when verifier
is used for program analysis by non-host JITs.  This allows
us to teach the verifier about packet start and packet end
offsets for direct packet access.

We can extend the callback as needed but for most packet
processing needs there isn't much more the offloads may
require.

Signed-off-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Reviewed-by: Simon Horman <simon.horman@netronome.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 2cdbcc4f8f6b274ff3ca92de4b77c1955899cd17..9755279d94cb8756288089b54c029941ca8b43bd 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -813,6 +813,36 @@ static int check_packet_access(struct bpf_verifier_env *env, u32 regno, int off,
        return err;
 }
 
+static bool analyzer_is_valid_access(struct bpf_verifier_env *env, int off,
+                                    struct bpf_insn_access_aux *info)
+{
+       switch (env->prog->type) {
+       case BPF_PROG_TYPE_XDP:
+               switch (off) {
+               case offsetof(struct xdp_buff, data):
+                       info->reg_type = PTR_TO_PACKET;
+                       return true;
+               case offsetof(struct xdp_buff, data_end):
+                       info->reg_type = PTR_TO_PACKET_END;
+                       return true;
+               }
+               return false;
+       case BPF_PROG_TYPE_SCHED_CLS:
+               switch (off) {
+               case offsetof(struct sk_buff, data):
+                       info->reg_type = PTR_TO_PACKET;
+                       return true;
+               case offsetof(struct sk_buff, cb) +
+                    offsetof(struct bpf_skb_data_end, data_end):
+                       info->reg_type = PTR_TO_PACKET_END;
+                       return true;
+               }
+               return false;
+       default:
+               return false;
+       }
+}
+
 /* check access to 'struct bpf_context' fields.  Supports fixed offsets only */
 static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, int size,
                            enum bpf_access_type t, enum bpf_reg_type *reg_type)
@@ -821,12 +851,13 @@ static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off,
                .reg_type = *reg_type,
        };
 
-       /* for analyzer ctx accesses are already validated and converted */
-       if (env->analyzer_ops)
-               return 0;
-
-       if (env->prog->aux->ops->is_valid_access &&
-           env->prog->aux->ops->is_valid_access(off, size, t, &info)) {
+       if (env->analyzer_ops) {
+               if (analyzer_is_valid_access(env, off, &info)) {
+                       *reg_type = info.reg_type;
+                       return 0;
+               }
+       } else if (env->prog->aux->ops->is_valid_access &&
+                  env->prog->aux->ops->is_valid_access(off, size, t, &info)) {
                /* A non zero info.ctx_field_size indicates that this field is a
                 * candidate for later verifier transformation to load the whole
                 * field and then apply a mask when accessed with a narrower