bpf: centre subprog information fields

It is better to centre all subprog information fields into one structure.
This structure could later serve as function node in call graph.

Signed-off-by: Jiong Wang <jiong.wang@netronome.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index f655b926e4325038dd4e79444b9d59d4425bb472..8f70dc181e23495995dcd73bcd6ef414ba30ba34 100644 (file)
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -173,6 +173,11 @@ static inline bool bpf_verifier_log_needed(const struct bpf_verifier_log *log)
 
 #define BPF_MAX_SUBPROGS 256
 
+struct bpf_subprog_info {
+       u32 start; /* insn idx of function entry point */
+       u16 stack_depth; /* max. stack depth used by this function */
+};
+
 /* single container for all structs
  * one verifier_env per bpf_check() call
  */
@@ -191,9 +196,7 @@ struct bpf_verifier_env {
        bool seen_direct_write;
        struct bpf_insn_aux_data *insn_aux_data; /* array of per-insn state */
        struct bpf_verifier_log log;
-       u32 subprog_starts[BPF_MAX_SUBPROGS + 1];
-       /* computes the stack depth of each bpf function */
-       u16 subprog_stack_depth[BPF_MAX_SUBPROGS + 1];
+       struct bpf_subprog_info subprog_info[BPF_MAX_SUBPROGS + 1];
        u32 subprog_cnt;
 };
 

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 8e8e582a7c03d2dd2f31ceac1b9331853c82bd1f..5b293b4abb70d1837b65f01d759fa09e42f97e8a 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -741,18 +741,19 @@ enum reg_arg_type {
 
 static int cmp_subprogs(const void *a, const void *b)
 {
-       return *(int *)a - *(int *)b;
+       return ((struct bpf_subprog_info *)a)->start -
+              ((struct bpf_subprog_info *)b)->start;
 }
 
 static int find_subprog(struct bpf_verifier_env *env, int off)
 {
-       u32 *p;
+       struct bpf_subprog_info *p;
 
-       p = bsearch(&off, env->subprog_starts, env->subprog_cnt,
-                   sizeof(env->subprog_starts[0]), cmp_subprogs);
+       p = bsearch(&off, env->subprog_info, env->subprog_cnt,
+                   sizeof(env->subprog_info[0]), cmp_subprogs);
        if (!p)
                return -ENOENT;
-       return p - env->subprog_starts;
+       return p - env->subprog_info;
 
 }
 
@@ -772,15 +773,16 @@ static int add_subprog(struct bpf_verifier_env *env, int off)
                verbose(env, "too many subprograms\n");
                return -E2BIG;
        }
-       env->subprog_starts[env->subprog_cnt++] = off;
-       sort(env->subprog_starts, env->subprog_cnt,
-            sizeof(env->subprog_starts[0]), cmp_subprogs, NULL);
+       env->subprog_info[env->subprog_cnt++].start = off;
+       sort(env->subprog_info, env->subprog_cnt,
+            sizeof(env->subprog_info[0]), cmp_subprogs, NULL);
        return 0;
 }
 
 static int check_subprogs(struct bpf_verifier_env *env)
 {
        int i, ret, subprog_start, subprog_end, off, cur_subprog = 0;
+       struct bpf_subprog_info *subprog = env->subprog_info;
        struct bpf_insn *insn = env->prog->insnsi;
        int insn_cnt = env->prog->len;
 
@@ -810,14 +812,14 @@ static int check_subprogs(struct bpf_verifier_env *env)
 
        if (env->log.level > 1)
                for (i = 0; i < env->subprog_cnt; i++)
-                       verbose(env, "func#%d @%d\n", i, env->subprog_starts[i]);
+                       verbose(env, "func#%d @%d\n", i, subprog[i].start);
 
        /* now check that all jumps are within the same subprog */
        subprog_start = 0;
        if (env->subprog_cnt == cur_subprog + 1)
                subprog_end = insn_cnt;
        else
-               subprog_end = env->subprog_starts[cur_subprog + 1];
+               subprog_end = subprog[cur_subprog + 1].start;
        for (i = 0; i < insn_cnt; i++) {
                u8 code = insn[i].code;
 
@@ -846,8 +848,7 @@ static int check_subprogs(struct bpf_verifier_env *env)
                        if (env->subprog_cnt == cur_subprog + 1)
                                subprog_end = insn_cnt;
                        else
-                               subprog_end =
-                                       env->subprog_starts[cur_subprog + 1];
+                               subprog_end = subprog[cur_subprog + 1].start;
                }
        }
        return 0;
@@ -1480,13 +1481,13 @@ static int update_stack_depth(struct bpf_verifier_env *env,
                              const struct bpf_func_state *func,
                              int off)
 {
-       u16 stack = env->subprog_stack_depth[func->subprogno];
+       u16 stack = env->subprog_info[func->subprogno].stack_depth;
 
        if (stack >= -off)
                return 0;
 
        /* update known max for given subprogram */
-       env->subprog_stack_depth[func->subprogno] = -off;
+       env->subprog_info[func->subprogno].stack_depth = -off;
        return 0;
 }
 
@@ -1498,7 +1499,8 @@ static int update_stack_depth(struct bpf_verifier_env *env,
  */
 static int check_max_stack_depth(struct bpf_verifier_env *env)
 {
-       int depth = 0, frame = 0, subprog = 0, i = 0, subprog_end;
+       int depth = 0, frame = 0, idx = 0, i = 0, subprog_end;
+       struct bpf_subprog_info *subprog = env->subprog_info;
        struct bpf_insn *insn = env->prog->insnsi;
        int insn_cnt = env->prog->len;
        int ret_insn[MAX_CALL_FRAMES];
@@ -1508,17 +1510,17 @@ static int check_max_stack_depth(struct bpf_verifier_env *env)
        /* round up to 32-bytes, since this is granularity
         * of interpreter stack size
         */
-       depth += round_up(max_t(u32, env->subprog_stack_depth[subprog], 1), 32);
+       depth += round_up(max_t(u32, subprog[idx].stack_depth, 1), 32);
        if (depth > MAX_BPF_STACK) {
                verbose(env, "combined stack size of %d calls is %d. Too large\n",
                        frame + 1, depth);
                return -EACCES;
        }
 continue_func:
-       if (env->subprog_cnt == subprog + 1)
+       if (env->subprog_cnt == idx + 1)
                subprog_end = insn_cnt;
        else
-               subprog_end = env->subprog_starts[subprog + 1];
+               subprog_end = subprog[idx + 1].start;
        for (; i < subprog_end; i++) {
                if (insn[i].code != (BPF_JMP | BPF_CALL))
                        continue;
@@ -1526,12 +1528,12 @@ static int check_max_stack_depth(struct bpf_verifier_env *env)
                        continue;
                /* remember insn and function to return to */
                ret_insn[frame] = i + 1;
-               ret_prog[frame] = subprog;
+               ret_prog[frame] = idx;
 
                /* find the callee */
                i = i + insn[i].imm + 1;
-               subprog = find_subprog(env, i);
-               if (subprog < 0) {
+               idx = find_subprog(env, i);
+               if (idx < 0) {
                        WARN_ONCE(1, "verifier bug. No program starts at insn %d\n",
                                  i);
                        return -EFAULT;
@@ -1548,10 +1550,10 @@ static int check_max_stack_depth(struct bpf_verifier_env *env)
         */
        if (frame == 0)
                return 0;
-       depth -= round_up(max_t(u32, env->subprog_stack_depth[subprog], 1), 32);
+       depth -= round_up(max_t(u32, subprog[idx].stack_depth, 1), 32);
        frame--;
        i = ret_insn[frame];
-       subprog = ret_prog[frame];
+       idx = ret_prog[frame];
        goto continue_func;
 }
 
@@ -1567,7 +1569,7 @@ static int get_callee_stack_depth(struct bpf_verifier_env *env,
                          start);
                return -EFAULT;
        }
-       return env->subprog_stack_depth[subprog];
+       return env->subprog_info[subprog].stack_depth;
 }
 #endif
 
@@ -4926,14 +4928,14 @@ static int do_check(struct bpf_verifier_env *env)
        verbose(env, "processed %d insns (limit %d), stack depth ",
                insn_processed, BPF_COMPLEXITY_LIMIT_INSNS);
        for (i = 0; i < env->subprog_cnt; i++) {
-               u32 depth = env->subprog_stack_depth[i];
+               u32 depth = env->subprog_info[i].stack_depth;
 
                verbose(env, "%d", depth);
                if (i + 1 < env->subprog_cnt)
                        verbose(env, "+");
        }
        verbose(env, "\n");
-       env->prog->aux->stack_depth = env->subprog_stack_depth[0];
+       env->prog->aux->stack_depth = env->subprog_info[0].stack_depth;
        return 0;
 }
 
@@ -5140,9 +5142,9 @@ static void adjust_subprog_starts(struct bpf_verifier_env *env, u32 off, u32 len
        if (len == 1)
                return;
        for (i = 0; i < env->subprog_cnt; i++) {
-               if (env->subprog_starts[i] < off)
+               if (env->subprog_info[i].start < off)
                        continue;
-               env->subprog_starts[i] += len - 1;
+               env->subprog_info[i].start += len - 1;
        }
 }
 
@@ -5340,7 +5342,7 @@ static int jit_subprogs(struct bpf_verifier_env *env)
                if (env->subprog_cnt == i + 1)
                        subprog_end = prog->len;
                else
-                       subprog_end = env->subprog_starts[i + 1];
+                       subprog_end = env->subprog_info[i + 1].start;
 
                len = subprog_end - subprog_start;
                func[i] = bpf_prog_alloc(bpf_prog_size(len), GFP_USER);
@@ -5357,7 +5359,7 @@ static int jit_subprogs(struct bpf_verifier_env *env)
                 * Long term would need debug info to populate names
                 */
                func[i]->aux->name[0] = 'F';
-               func[i]->aux->stack_depth = env->subprog_stack_depth[i];
+               func[i]->aux->stack_depth = env->subprog_info[i].stack_depth;
                func[i]->jit_requested = 1;
                func[i] = bpf_int_jit_compile(func[i]);
                if (!func[i]->jited) {