bpf: Enable annotating trusted nested pointers

In kfuncs, a "trusted" pointer is a pointer that the kfunc can assume is
safe, and which the verifier will allow to be passed to a
KF_TRUSTED_ARGS kfunc. Currently, a KF_TRUSTED_ARGS kfunc disallows any
pointer to be passed at a nonzero offset, but sometimes this is in fact
safe if the "nested" pointer's lifetime is inherited from its parent.
For example, the const cpumask_t *cpus_ptr field in a struct task_struct
will remain valid until the task itself is destroyed, and thus would
also be safe to pass to a KF_TRUSTED_ARGS kfunc.

While it would be conceptually simple to enable this by using BTF tags,
gcc unfortunately does not yet support this. In the interim, this patch
enables support for this by using a type-naming convention. A new
BTF_TYPE_SAFE_NESTED macro is defined in verifier.c which allows a
developer to specify the nested fields of a type which are considered
trusted if its parent is also trusted. The verifier is also updated to
account for this. A patch with selftests will be added in a follow-on
change, along with documentation for this feature.

Signed-off-by: David Vernet <void@manifault.com>
Link: https://lore.kernel.org/r/20230120192523.3650503-2-void@manifault.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index ad4bb36..982213d 100644 (file)
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -2187,6 +2187,10 @@ struct bpf_core_ctx {
        const struct btf *btf;
 };
 
+bool btf_nested_type_is_trusted(struct bpf_verifier_log *log,
+                               const struct bpf_reg_state *reg,
+                               int off);
+
 int bpf_core_apply(struct bpf_core_ctx *ctx, const struct bpf_core_relo *relo,
                   int relo_idx, void *insn);
 

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 4ba749f..dd05b5f 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -8227,3 +8227,64 @@ out:
        }
        return err;
 }
+
+bool btf_nested_type_is_trusted(struct bpf_verifier_log *log,
+                               const struct bpf_reg_state *reg,
+                               int off)
+{
+       struct btf *btf = reg->btf;
+       const struct btf_type *walk_type, *safe_type;
+       const char *tname;
+       char safe_tname[64];
+       long ret, safe_id;
+       const struct btf_member *member, *m_walk = NULL;
+       u32 i;
+       const char *walk_name;
+
+       walk_type = btf_type_by_id(btf, reg->btf_id);
+       if (!walk_type)
+               return false;
+
+       tname = btf_name_by_offset(btf, walk_type->name_off);
+
+       ret = snprintf(safe_tname, sizeof(safe_tname), "%s__safe_fields", tname);
+       if (ret < 0)
+               return false;
+
+       safe_id = btf_find_by_name_kind(btf, safe_tname, BTF_INFO_KIND(walk_type->info));
+       if (safe_id < 0)
+               return false;
+
+       safe_type = btf_type_by_id(btf, safe_id);
+       if (!safe_type)
+               return false;
+
+       for_each_member(i, walk_type, member) {
+               u32 moff;
+
+               /* We're looking for the PTR_TO_BTF_ID member in the struct
+                * type we're walking which matches the specified offset.
+                * Below, we'll iterate over the fields in the safe variant of
+                * the struct and see if any of them has a matching type /
+                * name.
+                */
+               moff = __btf_member_bit_offset(walk_type, member) / 8;
+               if (off == moff) {
+                       m_walk = member;
+                       break;
+               }
+       }
+       if (m_walk == NULL)
+               return false;
+
+       walk_name = __btf_name_by_offset(btf, m_walk->name_off);
+       for_each_member(i, safe_type, member) {
+               const char *m_name = __btf_name_by_offset(btf, member->name_off);
+
+               /* If we match on both type and name, the field is considered trusted. */
+               if (m_walk->type == member->type && !strcmp(walk_name, m_name))
+                       return true;
+       }
+
+       return false;
+}

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 8004882..bc24bda 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -4943,6 +4943,25 @@ static int bpf_map_direct_read(struct bpf_map *map, int off, int size, u64 *val)
        return 0;
 }
 
+#define BTF_TYPE_SAFE_NESTED(__type)  __PASTE(__type, __safe_fields)
+
+BTF_TYPE_SAFE_NESTED(struct task_struct) {
+       const cpumask_t *cpus_ptr;
+};
+
+static bool nested_ptr_is_trusted(struct bpf_verifier_env *env,
+                                 struct bpf_reg_state *reg,
+                                 int off)
+{
+       /* If its parent is not trusted, it can't regain its trusted status. */
+       if (!is_trusted_reg(reg))
+               return false;
+
+       BTF_TYPE_EMIT(BTF_TYPE_SAFE_NESTED(struct task_struct));
+
+       return btf_nested_type_is_trusted(&env->log, reg, off);
+}
+
 static int check_ptr_to_btf_access(struct bpf_verifier_env *env,
                                   struct bpf_reg_state *regs,
                                   int regno, int off, int size,
@@ -5031,10 +5050,17 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env,
        if (type_flag(reg->type) & PTR_UNTRUSTED)
                flag |= PTR_UNTRUSTED;
 
-       /* By default any pointer obtained from walking a trusted pointer is
-        * no longer trusted except the rcu case below.
+       /* By default any pointer obtained from walking a trusted pointer is no
+        * longer trusted, unless the field being accessed has explicitly been
+        * marked as inheriting its parent's state of trust.
+        *
+        * An RCU-protected pointer can also be deemed trusted if we are in an
+        * RCU read region. This case is handled below.
         */
-       flag &= ~PTR_TRUSTED;
+       if (nested_ptr_is_trusted(env, reg, off))
+               flag |= PTR_TRUSTED;
+       else
+               flag &= ~PTR_TRUSTED;
 
        if (flag & MEM_RCU) {
                /* Mark value register as MEM_RCU only if it is protected by