FAILED: patch "[PATCH] bpf: ensure main program has an extable" failed to apply to 5.15-stable tree
Subsystems (3)
[email protected]
maintainerThe patch below does not apply to the 5.15-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.15.y
git checkout FETCH_HEAD
git cherry-pick -x 0108a4e9f3584a7a2c026d1601b0682ff7335d95
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2023062341-reunite-senior-f0c0@gregkh' --subject-prefix 'PATCH 5.15.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 0108a4e9f3584a7a2c026d1601b0682ff7335d95 Mon Sep 17 00:00:00 2001
From: Krister Johansen <[email protected]>
Date: Mon, 12 Jun 2023 17:44:40 -0700
Subject: [PATCH] bpf: ensure main program has an extable
When subprograms are in use, the main program is not jit'd after the subprograms because jit_subprogs sets a value for prog->bpf_func upon success. Subsequent calls to the JIT are bypassed when this value is non-NULL. This leads to a situation where the main program and its func[0] counterpart are both in the bpf kallsyms tree, but only func[0] has an extable. Extables are only created during JIT. Now there are two nearly identical program ksym entries in the tree, but only one has an extable. Depending upon how the entries are placed, there's a chance that a fault will call search_extable on the aux with the NULL entry.
Since jit_subprogs already copies state from func[0] to the main program, include the extable pointer in this state duplication. Additionally, ensure that the copy of the main program in func[0] is not added to the bpf_prog_kallsyms table. Instead, let the main program get added later in bpf_prog_load(). This ensures there is only a single copy of the main program in the kallsyms table, and that its tag matches the tag observed by tooling like bpftool.
kernel/bpf/verifier.c +5 -2
@@ -17217,9 +17217,10 @@ static int jit_subprogs(struct bpf_verifier_env *env) }/* finally lock prog and jit images for all functions and -* populate kallsysm +* populate kallsysm. Begin at the first subprogram, since +* bpf_prog_load will add the kallsyms for the main program. */ -for (i =0 ; i < env->subprog_cnt; i++) { +for (i =1 ; i < env->subprog_cnt; i++) {bpf_prog_lock_ro (func[i]);bpf_prog_kallsyms_add (func[i]); }
@@ -17245,6 +17246,8 @@ static int jit_subprogs(struct bpf_verifier_env *env) prog->jited =1 ; prog->bpf_func = func[0 ]->bpf_func; prog->jited_len = func[0 ]->jited_len; + prog->aux->extable = func[0 ]->aux->extable; + prog->aux->num_exentries = func[0 ]->aux->num_exentries; prog->aux->func = func; prog->aux->func_cnt = env->subprog_cnt;bpf_prog_jit_attempt_done (prog);
PATCH 1/1 bpf: ensure main program has an extable
commit 0108a4e9f3584a7a2c026d1601b0682ff7335d95 upstream.
When subprograms are in use, the main program is not jit'd after the subprograms because jit_subprogs sets a value for prog->bpf_func upon success. Subsequent calls to the JIT are bypassed when this value is non-NULL. This leads to a situation where the main program and its func[0] counterpart are both in the bpf kallsyms tree, but only func[0] has an extable. Extables are only created during JIT. Now there are two nearly identical program ksym entries in the tree, but only one has an extable. Depending upon how the entries are placed, there's a chance that a fault will call search_extable on the aux with the NULL entry.
Since jit_subprogs already copies state from func[0] to the main program, include the extable pointer in this state duplication. Additionally, ensure that the copy of the main program in func[0] is not added to the bpf_prog_kallsyms table. Instead, let the main program get added later in bpf_prog_load(). This ensures there is only a single copy of the main program in the kallsyms table, and that its tag matches the tag observed by tooling like bpftool.
--- kernel/bpf/verifier.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +6 -2
@@ -12588,9 +12588,10 @@ static int jit_subprogs(struct bpf_verifier_env *env) }/* finally lock prog and jit images for all functions and -* populate kallsysm +* populate kallsysm. Begin at the first subprogram, since +* bpf_prog_load will add the kallsyms for the main program. */ -for (i =0 ; i < env->subprog_cnt; i++) { +for (i =1 ; i < env->subprog_cnt; i++) {bpf_prog_lock_ro (func[i]);bpf_prog_kallsyms_add (func[i]); }
@@ -12615,6 +12616,9 @@ static int jit_subprogs(struct bpf_verifier_env *env) prog->jited =1 ; prog->bpf_func = func[0 ]->bpf_func; + prog->jited_len = func[0 ]->jited_len; + prog->aux->extable = func[0 ]->aux->extable; + prog->aux->num_exentries = func[0 ]->aux->num_exentries; prog->aux->func = func; prog->aux->func_cnt = env->subprog_cnt;bpf_prog_jit_attempt_done (prog);
Signature · 1 line
2.25.1
Re: [PATCH 5.15.y] bpf: ensure main program has an extable
Quoted 51 lines · Krister Johansen
commit
0108a4e9f3584a7a2c026d1601b0682ff7335d95upstream.When subprograms are in use, the main program is not jit'd after the subprograms because
jit_subprogssets a value forprog->bpf_funcupon success. Subsequent calls to the JIT are bypassed when this value is non-NULL. This leads to a situation where the main program and its func[0] counterpart are both in the bpf kallsyms tree, but only func[0] has an extable. Extables are only created during JIT. Now there are two nearly identical program ksym entries in the tree, but only one has an extable. Depending upon how the entries are placed, there's a chance that a fault will callsearch_extableon the aux with the NULL entry.Since
jit_subprogsalready copies state from func[0] to the main program, include the extable pointer in this state duplication. Additionally, ensure that the copy of the main program in func[0] is not added to thebpf_prog_kallsymstable. Instead, let the main program get added later inbpf_prog_load(). This ensures there is only a single copy of the main program in the kallsyms table, and that its tag matches the tag observed by tooling like bpftool.Fixes 1c2a088a6626 ("bpf: x64: add JIT support for multi-function programs")Signed-off-by Krister Johansen <[email protected]>Acked-by Yonghong Song <[email protected]>Acked-by Ilya Leoshkevich <[email protected]>Tested-by Ilya Leoshkevich <[email protected]>Link https://lore.kernel.org/r/6de9b2f4b4724ef56efbb0339daaa66c8b68b1e7.1686616663.git.kjlx@templeofstupid.com open hereSigned-off-by Alexei Starovoitov <[email protected]>Signed-off-by Krister Johansen <[email protected]>--- kernel/bpf/verifier.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)kernel/bpf/verifier.c +3
-2@@ -12588,9 +12588,10 @@ static int jit_subprogs(struct bpf_verifier_env *env) }/* finally lock prog and jit images for all functions and -* populate kallsysm +* populate kallsysm. Begin at the first subprogram, since +* bpf_prog_load will add the kallsyms for the main program. */ -for (i =0 ; i < env->subprog_cnt; i++) { +for (i =1 ; i < env->subprog_cnt; i++) {bpf_prog_lock_ro (func[i]);bpf_prog_kallsyms_add (func[i]); }
kernel/bpf/verifier.c static int jit_subprogs(struct bpf_verifier_env *env) · line 12619
Quoted 4 lines
kernel/bpf/verifier.c +1
-0@@ -12615,6 +12616,9 @@ static int jit_subprogs(struct bpf_verifier_env *env) prog->jited =1 ; prog->bpf_func = func[0 ]->bpf_func; + prog->jited_len = func[0 ]->jited_len;
This 'prog->jited_len' line wasn't part of the original commit and appears to have snuck in during manual conflict resolution. Let me clean up and resubmit. Apologies.
kernel/bpf/verifier.c static int jit_subprogs(struct bpf_verifier_env *env) · line 12624
Quoted 5 lines
kernel/bpf/verifier.c +2
-0+ prog->aux->extable = func[0 ]->aux->extable; + prog->aux->num_exentries = func[0 ]->aux->num_exentries; prog->aux->func = func; prog->aux->func_cnt = env->subprog_cnt;bpf_prog_jit_attempt_done (prog);
-K
PATCH v2 1/1 bpf: ensure main program has an extable
In reply to Krister Johansencommit 0108a4e9f3584a7a2c026d1601b0682ff7335d95 upstream.
When subprograms are in use, the main program is not jit'd after the subprograms because jit_subprogs sets a value for prog->bpf_func upon success. Subsequent calls to the JIT are bypassed when this value is non-NULL. This leads to a situation where the main program and its func[0] counterpart are both in the bpf kallsyms tree, but only func[0] has an extable. Extables are only created during JIT. Now there are two nearly identical program ksym entries in the tree, but only one has an extable. Depending upon how the entries are placed, there's a chance that a fault will call search_extable on the aux with the NULL entry.
Since jit_subprogs already copies state from func[0] to the main program, include the extable pointer in this state duplication. Additionally, ensure that the copy of the main program in func[0] is not added to the bpf_prog_kallsyms table. Instead, let the main program get added later in bpf_prog_load(). This ensures there is only a single copy of the main program in the kallsyms table, and that its tag matches the tag observed by tooling like bpftool.
--- kernel/bpf/verifier.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +5 -2
@@ -12588,9 +12588,10 @@ static int jit_subprogs(struct bpf_verifier_env *env) }/* finally lock prog and jit images for all functions and -* populate kallsysm +* populate kallsysm. Begin at the first subprogram, since +* bpf_prog_load will add the kallsyms for the main program. */ -for (i =0 ; i < env->subprog_cnt; i++) { +for (i =1 ; i < env->subprog_cnt; i++) {bpf_prog_lock_ro (func[i]);bpf_prog_kallsyms_add (func[i]); }
@@ -12615,6 +12616,8 @@ static int jit_subprogs(struct bpf_verifier_env *env) prog->jited =1 ; prog->bpf_func = func[0 ]->bpf_func; + prog->aux->extable = func[0 ]->aux->extable; + prog->aux->num_exentries = func[0 ]->aux->num_exentries; prog->aux->func = func; prog->aux->func_cnt = env->subprog_cnt;bpf_prog_jit_attempt_done (prog);
Signature · 1 line
2.25.1
Greg Kroah-Hartman
maintainerRe: [PATCH 5.15.y v2] bpf: ensure main program has an extable
Quoted 29 lines · Krister Johansen
commit
0108a4e9f3584a7a2c026d1601b0682ff7335d95upstream.When subprograms are in use, the main program is not jit'd after the subprograms because
jit_subprogssets a value forprog->bpf_funcupon success. Subsequent calls to the JIT are bypassed when this value is non-NULL. This leads to a situation where the main program and its func[0] counterpart are both in the bpf kallsyms tree, but only func[0] has an extable. Extables are only created during JIT. Now there are two nearly identical program ksym entries in the tree, but only one has an extable. Depending upon how the entries are placed, there's a chance that a fault will callsearch_extableon the aux with the NULL entry.Since
jit_subprogsalready copies state from func[0] to the main program, include the extable pointer in this state duplication. Additionally, ensure that the copy of the main program in func[0] is not added to thebpf_prog_kallsymstable. Instead, let the main program get added later inbpf_prog_load(). This ensures there is only a single copy of the main program in the kallsyms table, and that its tag matches the tag observed by tooling like bpftool.Fixes 1c2a088a6626 ("bpf: x64: add JIT support for multi-function programs")Signed-off-by Krister Johansen <[email protected]>Acked-by Yonghong Song <[email protected]>Acked-by Ilya Leoshkevich <[email protected]>Tested-by Ilya Leoshkevich <[email protected]>Link https://lore.kernel.org/r/6de9b2f4b4724ef56efbb0339daaa66c8b68b1e7.1686616663.git.kjlx@templeofstupid.com open hereSigned-off-by Alexei Starovoitov <[email protected]>Signed-off-by Krister Johansen <[email protected]>
Quoted 3 lines
--- kernel/bpf/verifier.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
Now queued up, thanks.
greg k-h