bpf: change parameters of call/branch offset adjustment

In preparation for code removal change parameters to branch
and call adjustment functions to be more universal.  The
current parameters assume we are patching a single instruction
with a longer set.

A diagram may help reading the change, this is for the patch
single case, patching instruction 1 with a replacement of 4:
   ____
0 |____|
1 |____| <-- pos                ^
2 |    | <-- end old  ^         |
3 |    |              |  delta  |  len
4 |____|              |         |  (patch region)
5 |    | <-- end new  v         v
6 |____|

end_old = pos + 1
end_new = pos + delta + 1

If we are before the patch region - curr variable and the target
are fully in old coordinates (hence comparing against end_old).
If we are after the region curr is in new coordinates (hence
the comparison to end_new) but target is in mixed coordinates,
so we just check if it falls before end_new, and if so it needs
the adjustment.

Note that we will not fix up branches which land in removed region
in case of removal, which should be okay, as we are only going to
remove dead code.

Signed-off-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Acked-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index f908b9356025d27da489b7a1ceaac302169a1c98..ad08ba341197da18088bad68ca4367c8fd6d4ba6 100644 (file)
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -307,15 +307,16 @@ int bpf_prog_calc_tag(struct bpf_prog *fp)
        return 0;
 }
 
-static int bpf_adj_delta_to_imm(struct bpf_insn *insn, u32 pos, u32 delta,
-                               u32 curr, const bool probe_pass)
+static int bpf_adj_delta_to_imm(struct bpf_insn *insn, u32 pos, s32 end_old,
+                               s32 end_new, u32 curr, const bool probe_pass)
 {
        const s64 imm_min = S32_MIN, imm_max = S32_MAX;
+       s32 delta = end_new - end_old;
        s64 imm = insn->imm;
 
-       if (curr < pos && curr + imm + 1 > pos)
+       if (curr < pos && curr + imm + 1 >= end_old)
                imm += delta;
-       else if (curr > pos + delta && curr + imm + 1 <= pos + delta)
+       else if (curr >= end_new && curr + imm + 1 < end_new)
                imm -= delta;
        if (imm < imm_min || imm > imm_max)
                return -ERANGE;
@@ -324,15 +325,16 @@ static int bpf_adj_delta_to_imm(struct bpf_insn *insn, u32 pos, u32 delta,
        return 0;
 }
 
-static int bpf_adj_delta_to_off(struct bpf_insn *insn, u32 pos, u32 delta,
-                               u32 curr, const bool probe_pass)
+static int bpf_adj_delta_to_off(struct bpf_insn *insn, u32 pos, s32 end_old,
+                               s32 end_new, u32 curr, const bool probe_pass)
 {
        const s32 off_min = S16_MIN, off_max = S16_MAX;
+       s32 delta = end_new - end_old;
        s32 off = insn->off;
 
-       if (curr < pos && curr + off + 1 > pos)
+       if (curr < pos && curr + off + 1 >= end_old)
                off += delta;
-       else if (curr > pos + delta && curr + off + 1 <= pos + delta)
+       else if (curr >= end_new && curr + off + 1 < end_new)
                off -= delta;
        if (off < off_min || off > off_max)
                return -ERANGE;
@@ -341,10 +343,10 @@ static int bpf_adj_delta_to_off(struct bpf_insn *insn, u32 pos, u32 delta,
        return 0;
 }
 
-static int bpf_adj_branches(struct bpf_prog *prog, u32 pos, u32 delta,
-                           const bool probe_pass)
+static int bpf_adj_branches(struct bpf_prog *prog, u32 pos, s32 end_old,
+                           s32 end_new, const bool probe_pass)
 {
-       u32 i, insn_cnt = prog->len + (probe_pass ? delta : 0);
+       u32 i, insn_cnt = prog->len + (probe_pass ? end_new - end_old : 0);
        struct bpf_insn *insn = prog->insnsi;
        int ret = 0;
 
@@ -356,8 +358,8 @@ static int bpf_adj_branches(struct bpf_prog *prog, u32 pos, u32 delta,
                 * do any other adjustments. Therefore skip the patchlet.
                 */
                if (probe_pass && i == pos) {
-                       i += delta + 1;
-                       insn++;
+                       i = end_new;
+                       insn = prog->insnsi + end_old;
                }
                code = insn->code;
                if (BPF_CLASS(code) != BPF_JMP ||
@@ -367,11 +369,11 @@ static int bpf_adj_branches(struct bpf_prog *prog, u32 pos, u32 delta,
                if (BPF_OP(code) == BPF_CALL) {
                        if (insn->src_reg != BPF_PSEUDO_CALL)
                                continue;
-                       ret = bpf_adj_delta_to_imm(insn, pos, delta, i,
-                                                  probe_pass);
+                       ret = bpf_adj_delta_to_imm(insn, pos, end_old,
+                                                  end_new, i, probe_pass);
                } else {
-                       ret = bpf_adj_delta_to_off(insn, pos, delta, i,
-                                                  probe_pass);
+                       ret = bpf_adj_delta_to_off(insn, pos, end_old,
+                                                  end_new, i, probe_pass);
                }
                if (ret)
                        break;
@@ -421,7 +423,7 @@ struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
         * we afterwards may not fail anymore.
         */
        if (insn_adj_cnt > cnt_max &&
-           bpf_adj_branches(prog, off, insn_delta, true))
+           bpf_adj_branches(prog, off, off + 1, off + len, true))
                return NULL;
 
        /* Several new instructions need to be inserted. Make room
@@ -453,7 +455,7 @@ struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
         * the ship has sailed to reverse to the original state. An
         * overflow cannot happen at this point.
         */
-       BUG_ON(bpf_adj_branches(prog_adj, off, insn_delta, false));
+       BUG_ON(bpf_adj_branches(prog_adj, off, off + 1, off + len, false));
 
        bpf_adj_linfo(prog_adj, off, insn_delta);