bpf: Remove unused arguments from btf_struct_access().

Remove unused arguments from btf_struct_access() callback.

Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Acked-by: David Vernet <void@manifault.com>
Link: https://lore.kernel.org/bpf/20230404045029.82870-3-alexei.starovoitov@gmail.com

diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 2d8f3f6..4f689dd 100644 (file)
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -893,8 +893,7 @@ struct bpf_verifier_ops {
                                  struct bpf_prog *prog, u32 *target_size);
        int (*btf_struct_access)(struct bpf_verifier_log *log,
                                 const struct bpf_reg_state *reg,
-                                int off, int size, enum bpf_access_type atype,
-                                u32 *next_btf_id, enum bpf_type_flag *flag);
+                                int off, int size);
 };
 
 struct bpf_prog_offload_ops {

diff --git a/include/linux/filter.h b/include/linux/filter.h
index 23c08c3..5364b0c 100644 (file)
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -571,8 +571,7 @@ DECLARE_STATIC_KEY_FALSE(bpf_stats_enabled_key);
 extern struct mutex nf_conn_btf_access_lock;
 extern int (*nfct_btf_struct_access)(struct bpf_verifier_log *log,
                                     const struct bpf_reg_state *reg,
-                                    int off, int size, enum bpf_access_type atype,
-                                    u32 *next_btf_id, enum bpf_type_flag *flag);
+                                    int off, int size);
 
 typedef unsigned int (*bpf_dispatcher_fn)(const void *ctx,
                                          const struct bpf_insn *insnsi,

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 8398456..5ca520e 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -5459,7 +5459,7 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env,
        const struct btf_type *t = btf_type_by_id(reg->btf, reg->btf_id);
        const char *tname = btf_name_by_offset(reg->btf, t->name_off);
        enum bpf_type_flag flag = 0;
-       u32 btf_id;
+       u32 btf_id = 0;
        int ret;
 
        if (!env->allow_ptr_leaks) {
@@ -5509,7 +5509,7 @@ static int check_ptr_to_btf_access(struct bpf_verifier_env *env,
                        verbose(env, "verifier internal error: reg->btf must be kernel btf\n");
                        return -EFAULT;
                }
-               ret = env->ops->btf_struct_access(&env->log, reg, off, size, atype, &btf_id, &flag);
+               ret = env->ops->btf_struct_access(&env->log, reg, off, size);
        } else {
                /* Writes are permitted with default btf_struct_access for
                 * program allocated objects (which always have ref_obj_id > 0),

diff --git a/net/bpf/bpf_dummy_struct_ops.c b/net/bpf/bpf_dummy_struct_ops.c
index 9535c85..5918d1b 100644 (file)
--- a/net/bpf/bpf_dummy_struct_ops.c
+++ b/net/bpf/bpf_dummy_struct_ops.c
@@ -173,14 +173,11 @@ static int bpf_dummy_ops_check_member(const struct btf_type *t,
 
 static int bpf_dummy_ops_btf_struct_access(struct bpf_verifier_log *log,
                                           const struct bpf_reg_state *reg,
-                                          int off, int size, enum bpf_access_type atype,
-                                          u32 *next_btf_id,
-                                          enum bpf_type_flag *flag)
+                                          int off, int size)
 {
        const struct btf_type *state;
        const struct btf_type *t;
        s32 type_id;
-       int err;
 
        type_id = btf_find_by_name_kind(reg->btf, "bpf_dummy_ops_state",
                                        BTF_KIND_STRUCT);
@@ -194,9 +191,10 @@ static int bpf_dummy_ops_btf_struct_access(struct bpf_verifier_log *log,
                return -EACCES;
        }
 
-       err = btf_struct_access(log, reg, off, size, atype, next_btf_id, flag);
-       if (err < 0)
-               return err;
+       if (off + size > sizeof(struct bpf_dummy_ops_state)) {
+               bpf_log(log, "write access at off %d with size %d\n", off, size);
+               return -EACCES;
+       }
 
        return NOT_INIT;
 }

diff --git a/net/core/filter.c b/net/core/filter.c
index 8b9f409..1f2abf0 100644 (file)
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -8742,20 +8742,18 @@ EXPORT_SYMBOL_GPL(nf_conn_btf_access_lock);
 
 int (*nfct_btf_struct_access)(struct bpf_verifier_log *log,
                              const struct bpf_reg_state *reg,
-                             int off, int size, enum bpf_access_type atype,
-                             u32 *next_btf_id, enum bpf_type_flag *flag);
+                             int off, int size);
 EXPORT_SYMBOL_GPL(nfct_btf_struct_access);
 
 static int tc_cls_act_btf_struct_access(struct bpf_verifier_log *log,
                                        const struct bpf_reg_state *reg,
-                                       int off, int size, enum bpf_access_type atype,
-                                       u32 *next_btf_id, enum bpf_type_flag *flag)
+                                       int off, int size)
 {
        int ret = -EACCES;
 
        mutex_lock(&nf_conn_btf_access_lock);
        if (nfct_btf_struct_access)
-               ret = nfct_btf_struct_access(log, reg, off, size, atype, next_btf_id, flag);
+               ret = nfct_btf_struct_access(log, reg, off, size);
        mutex_unlock(&nf_conn_btf_access_lock);
 
        return ret;
@@ -8822,14 +8820,13 @@ EXPORT_SYMBOL_GPL(bpf_warn_invalid_xdp_action);
 
 static int xdp_btf_struct_access(struct bpf_verifier_log *log,
                                 const struct bpf_reg_state *reg,
-                                int off, int size, enum bpf_access_type atype,
-                                u32 *next_btf_id, enum bpf_type_flag *flag)
+                                int off, int size)
 {
        int ret = -EACCES;
 
        mutex_lock(&nf_conn_btf_access_lock);
        if (nfct_btf_struct_access)
-               ret = nfct_btf_struct_access(log, reg, off, size, atype, next_btf_id, flag);
+               ret = nfct_btf_struct_access(log, reg, off, size);
        mutex_unlock(&nf_conn_btf_access_lock);
 
        return ret;

diff --git a/net/ipv4/bpf_tcp_ca.c b/net/ipv4/bpf_tcp_ca.c
index d646587..4406d79 100644 (file)
--- a/net/ipv4/bpf_tcp_ca.c
+++ b/net/ipv4/bpf_tcp_ca.c
@@ -72,8 +72,7 @@ static bool bpf_tcp_ca_is_valid_access(int off, int size,
 
 static int bpf_tcp_ca_btf_struct_access(struct bpf_verifier_log *log,
                                        const struct bpf_reg_state *reg,
-                                       int off, int size, enum bpf_access_type atype,
-                                       u32 *next_btf_id, enum bpf_type_flag *flag)
+                                       int off, int size)
 {
        const struct btf_type *t;
        size_t end;

diff --git a/net/netfilter/nf_conntrack_bpf.c b/net/netfilter/nf_conntrack_bpf.c
index 002e9d2..3f821b7 100644 (file)
--- a/net/netfilter/nf_conntrack_bpf.c
+++ b/net/netfilter/nf_conntrack_bpf.c
@@ -192,8 +192,7 @@ BTF_ID(struct, nf_conn___init)
 /* Check writes into `struct nf_conn` */
 static int _nf_conntrack_btf_struct_access(struct bpf_verifier_log *log,
                                           const struct bpf_reg_state *reg,
-                                          int off, int size, enum bpf_access_type atype,
-                                          u32 *next_btf_id, enum bpf_type_flag *flag)
+                                          int off, int size)
 {
        const struct btf_type *ncit, *nct, *t;
        size_t end;