In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
Inthe Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
Inthe Linux kernel,the following vulnerabilityhas been resolved:riscv, bpf:Fix out-of-bounds issue when preparing trampoline imageWegetthe size of the trampoline image duringthedryrun phase andallocate memory based on that size.The allocated image will then bepopulated with instructions duringthe real patch phase.But aftercommit 26ef208c209a ("bpf:Use arch_bpf_trampoline_size"),the `im`argument is inconsistent inthedryrunand real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generatingthe 'im' address, potentially causing out-of-boundsissues. Let's emitthe maximum number of instructionsforthe "im"address duringdryrun tofix this problem.The Linux kernelCVE teamhas assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
IntheLinux kernel, thefollowing vulnerability hasbeen resolved:riscv, bpf: Fixout-of-bounds issue when preparing trampoline imageWe getthesize of the trampoline image during thedryrunphase andallocate memory based on that size. Theallocated image will then bepopulated with instructions during thereal patch phase. Butaftercommit 26ef208c209a ("bpf: Usearch_bpf_trampoline_size"), the`im`argument is inconsistent in thedryrunandreal patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the'im' address, potentially causing out-of-boundsissues. Let's emit themaximum number of instructions forthe"im"address during dryrunto fixthis problem.The Linux kernel CVEteam hasassigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate adifferent number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generatea different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
| linux | | https://git.kernel.org/linus/9f1e16fb1fc9826001c69e0551d51fbbcd2d74e9 | https://git.kernel.org/linus/26ef208c209a0e6eed8942a5d191b39dccfa6e38 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ("bpf: Use arch_bpf_trampoline_size"), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the 'im' address, potentially causing out-of-boundsissues. Let's emit the maximum number of instructions for the "im"address during dry run to fix this problem.The Linux kernel CVE team has assigned CVE-2024-43843 to this issue.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
In the Linux kernel, the following vulnerability has been resolved:riscv, bpf: Fix out-of-bounds issue when preparing trampoline imageWe get the size of the trampoline image during the dry run phase andallocate memory based on that size. The allocated image will then bepopulated with instructions during the real patch phase. But aftercommit 26ef208c209a ( bpf: Use arch_bpf_trampoline_size ), the `im`argument is inconsistent in the dry run and real patch phase. This maycause emit_imm in RV64 to generate a different number of instructionswhen generating the im address, potentially causing out-of-boundsissues. Let s emit the maximum number of instructions for the im address during dry run to fix this problem.
