From e1f63c571c99d31c2713014f5d0912d615bc9d7c Mon Sep 17 00:00:00 2001 From: Igor Pecovnik Date: Fri, 28 May 2021 14:17:47 +0200 Subject: [PATCH] Add upstream patches and remove deprecated patch sunxi, odroidxu4 --- config/kernel/linux-sunxi-current.config | 2 +- config/kernel/linux-sunxi-edge.config | 2 +- config/kernel/linux-sunxi64-current.config | 2 +- config/kernel/linux-sunxi64-edge.config | 2 +- .../odroidxu4-5.4/patch-5.4.122-123.patch | 238 ++++++++++++ .../archive/sunxi-5.10/patch-5.10.40-41.patch | 344 ++++++++++++++++++ .../archive/sunxi-5.12/patch-5.12.7-8.patch | 288 +++++++++++++++ ...enable-audio-codec-bpim2ultra-kernel.patch | 50 --- 8 files changed, 874 insertions(+), 54 deletions(-) create mode 100644 patch/kernel/archive/odroidxu4-5.4/patch-5.4.122-123.patch create mode 100644 patch/kernel/archive/sunxi-5.10/patch-5.10.40-41.patch create mode 100644 patch/kernel/archive/sunxi-5.12/patch-5.12.7-8.patch delete mode 100644 patch/u-boot/u-boot-sunxi/enable-audio-codec-bpim2ultra-kernel.patch diff --git a/config/kernel/linux-sunxi-current.config b/config/kernel/linux-sunxi-current.config index ca596bb057..ecdd7312ca 100644 --- a/config/kernel/linux-sunxi-current.config +++ b/config/kernel/linux-sunxi-current.config @@ -1,6 +1,6 @@ # # Automatically generated file; DO NOT EDIT. -# Linux/arm 5.10.37 Kernel Configuration +# Linux/arm 5.10.41 Kernel Configuration # CONFIG_CC_VERSION_TEXT="arm-linux-gnueabihf-gcc (GNU Toolchain for the A-profile Architecture 8.3-2019.03 (arm-rel-8.36)) 8.3.0" CONFIG_CC_IS_GCC=y diff --git a/config/kernel/linux-sunxi-edge.config b/config/kernel/linux-sunxi-edge.config index 5784da7102..3eb698ac70 100644 --- a/config/kernel/linux-sunxi-edge.config +++ b/config/kernel/linux-sunxi-edge.config @@ -1,6 +1,6 @@ # # Automatically generated file; DO NOT EDIT. -# Linux/arm 5.12.4 Kernel Configuration +# Linux/arm 5.12.8 Kernel Configuration # CONFIG_CC_VERSION_TEXT="arm-linux-gnueabihf-gcc (GNU Toolchain for the A-profile Architecture 8.3-2019.03 (arm-rel-8.36)) 8.3.0" CONFIG_CC_IS_GCC=y diff --git a/config/kernel/linux-sunxi64-current.config b/config/kernel/linux-sunxi64-current.config index fbf07ce456..5db337254c 100644 --- a/config/kernel/linux-sunxi64-current.config +++ b/config/kernel/linux-sunxi64-current.config @@ -1,6 +1,6 @@ # # Automatically generated file; DO NOT EDIT. -# Linux/arm64 5.10.37 Kernel Configuration +# Linux/arm64 5.10.41 Kernel Configuration # CONFIG_CC_VERSION_TEXT="aarch64-linux-gnu-gcc (GNU Toolchain for the A-profile Architecture 8.3-2019.03 (arm-rel-8.36)) 8.3.0" CONFIG_CC_IS_GCC=y diff --git a/config/kernel/linux-sunxi64-edge.config b/config/kernel/linux-sunxi64-edge.config index 97db7ebf01..f65bebd031 100644 --- a/config/kernel/linux-sunxi64-edge.config +++ b/config/kernel/linux-sunxi64-edge.config @@ -1,6 +1,6 @@ # # Automatically generated file; DO NOT EDIT. -# Linux/arm64 5.12.3 Kernel Configuration +# Linux/arm64 5.12.8 Kernel Configuration # CONFIG_CC_VERSION_TEXT="aarch64-linux-gnu-gcc (GNU Toolchain for the A-profile Architecture 8.3-2019.03 (arm-rel-8.36)) 8.3.0" CONFIG_CC_IS_GCC=y diff --git a/patch/kernel/archive/odroidxu4-5.4/patch-5.4.122-123.patch b/patch/kernel/archive/odroidxu4-5.4/patch-5.4.122-123.patch new file mode 100644 index 0000000000..c62699e5c4 --- /dev/null +++ b/patch/kernel/archive/odroidxu4-5.4/patch-5.4.122-123.patch @@ -0,0 +1,238 @@ +diff --git a/Makefile b/Makefile +index 9b64ebcf45312..d3f7a032f080b 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 4 +-SUBLEVEL = 122 ++SUBLEVEL = 123 + EXTRAVERSION = + NAME = Kleptomaniac Octopus + +diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c +index 40fe856184efa..6145311a3855f 100644 +--- a/drivers/usb/dwc3/gadget.c ++++ b/drivers/usb/dwc3/gadget.c +@@ -2022,6 +2022,10 @@ static void dwc3_gadget_enable_irq(struct dwc3 *dwc) + if (dwc->revision < DWC3_REVISION_250A) + reg |= DWC3_DEVTEN_ULSTCNGEN; + ++ /* On 2.30a and above this bit enables U3/L2-L1 Suspend Events */ ++ if (dwc->revision >= DWC3_REVISION_230A) ++ reg |= DWC3_DEVTEN_EOPFEN; ++ + dwc3_writel(dwc->regs, DWC3_DEVTEN, reg); + } + +diff --git a/include/net/nfc/nci_core.h b/include/net/nfc/nci_core.h +index 43c9c5d2bedbd..33979017b7824 100644 +--- a/include/net/nfc/nci_core.h ++++ b/include/net/nfc/nci_core.h +@@ -298,6 +298,7 @@ int nci_nfcc_loopback(struct nci_dev *ndev, void *data, size_t data_len, + struct sk_buff **resp); + + struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev); ++void nci_hci_deallocate(struct nci_dev *ndev); + int nci_hci_send_event(struct nci_dev *ndev, u8 gate, u8 event, + const u8 *param, size_t param_len); + int nci_hci_send_cmd(struct nci_dev *ndev, u8 gate, +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index 11b217b0f4541..aefd947947968 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -4272,18 +4272,10 @@ enum { + }; + + static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg, +- const struct bpf_reg_state *off_reg, +- u32 *alu_limit, u8 opcode) ++ u32 *alu_limit, bool mask_to_left) + { +- bool off_is_neg = off_reg->smin_value < 0; +- bool mask_to_left = (opcode == BPF_ADD && off_is_neg) || +- (opcode == BPF_SUB && !off_is_neg); + u32 max = 0, ptr_limit = 0; + +- if (!tnum_is_const(off_reg->var_off) && +- (off_reg->smin_value < 0) != (off_reg->smax_value < 0)) +- return REASON_BOUNDS; +- + switch (ptr_reg->type) { + case PTR_TO_STACK: + /* Offset 0 is out-of-bounds, but acceptable start for the +@@ -4349,15 +4341,20 @@ static bool sanitize_needed(u8 opcode) + return opcode == BPF_ADD || opcode == BPF_SUB; + } + ++struct bpf_sanitize_info { ++ struct bpf_insn_aux_data aux; ++ bool mask_to_left; ++}; ++ + static int sanitize_ptr_alu(struct bpf_verifier_env *env, + struct bpf_insn *insn, + const struct bpf_reg_state *ptr_reg, + const struct bpf_reg_state *off_reg, + struct bpf_reg_state *dst_reg, +- struct bpf_insn_aux_data *tmp_aux, ++ struct bpf_sanitize_info *info, + const bool commit_window) + { +- struct bpf_insn_aux_data *aux = commit_window ? cur_aux(env) : tmp_aux; ++ struct bpf_insn_aux_data *aux = commit_window ? cur_aux(env) : &info->aux; + struct bpf_verifier_state *vstate = env->cur_state; + bool off_is_imm = tnum_is_const(off_reg->var_off); + bool off_is_neg = off_reg->smin_value < 0; +@@ -4378,7 +4375,16 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, + if (vstate->speculative) + goto do_sim; + +- err = retrieve_ptr_limit(ptr_reg, off_reg, &alu_limit, opcode); ++ if (!commit_window) { ++ if (!tnum_is_const(off_reg->var_off) && ++ (off_reg->smin_value < 0) != (off_reg->smax_value < 0)) ++ return REASON_BOUNDS; ++ ++ info->mask_to_left = (opcode == BPF_ADD && off_is_neg) || ++ (opcode == BPF_SUB && !off_is_neg); ++ } ++ ++ err = retrieve_ptr_limit(ptr_reg, &alu_limit, info->mask_to_left); + if (err < 0) + return err; + +@@ -4386,8 +4392,8 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, + /* In commit phase we narrow the masking window based on + * the observed pointer move after the simulated operation. + */ +- alu_state = tmp_aux->alu_state; +- alu_limit = abs(tmp_aux->alu_limit - alu_limit); ++ alu_state = info->aux.alu_state; ++ alu_limit = abs(info->aux.alu_limit - alu_limit); + } else { + alu_state = off_is_neg ? BPF_ALU_NEG_VALUE : 0; + alu_state |= off_is_imm ? BPF_ALU_IMMEDIATE : 0; +@@ -4402,8 +4408,12 @@ do_sim: + /* If we're in commit phase, we're done here given we already + * pushed the truncated dst_reg into the speculative verification + * stack. ++ * ++ * Also, when register is a known constant, we rewrite register-based ++ * operation to immediate-based, and thus do not need masking (and as ++ * a consequence, do not need to simulate the zero-truncation either). + */ +- if (commit_window) ++ if (commit_window || off_is_imm) + return 0; + + /* Simulate and find potential out-of-bounds access under +@@ -4517,7 +4527,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value; + u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value, + umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value; +- struct bpf_insn_aux_data tmp_aux = {}; ++ struct bpf_sanitize_info info = {}; + u8 opcode = BPF_OP(insn->code); + u32 dst = insn->dst_reg; + int ret; +@@ -4578,7 +4588,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + + if (sanitize_needed(opcode)) { + ret = sanitize_ptr_alu(env, insn, ptr_reg, off_reg, dst_reg, +- &tmp_aux, false); ++ &info, false); + if (ret < 0) + return sanitize_err(env, insn, ret, off_reg, dst_reg); + } +@@ -4719,7 +4729,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + return -EACCES; + if (sanitize_needed(opcode)) { + ret = sanitize_ptr_alu(env, insn, dst_reg, off_reg, dst_reg, +- &tmp_aux, true); ++ &info, true); + if (ret < 0) + return sanitize_err(env, insn, ret, off_reg, dst_reg); + } +diff --git a/net/nfc/nci/core.c b/net/nfc/nci/core.c +index 7cd5248843041..6a34a0a786eaa 100644 +--- a/net/nfc/nci/core.c ++++ b/net/nfc/nci/core.c +@@ -1175,6 +1175,7 @@ EXPORT_SYMBOL(nci_allocate_device); + void nci_free_device(struct nci_dev *ndev) + { + nfc_free_device(ndev->nfc_dev); ++ nci_hci_deallocate(ndev); + kfree(ndev); + } + EXPORT_SYMBOL(nci_free_device); +diff --git a/net/nfc/nci/hci.c b/net/nfc/nci/hci.c +index c18e76d6d8ba0..04e55ccb33836 100644 +--- a/net/nfc/nci/hci.c ++++ b/net/nfc/nci/hci.c +@@ -795,3 +795,8 @@ struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev) + + return hdev; + } ++ ++void nci_hci_deallocate(struct nci_dev *ndev) ++{ ++ kfree(ndev->hci_dev); ++} +diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c +index 15f6e46d71243..32b440631c29d 100644 +--- a/tools/perf/util/unwind-libdw.c ++++ b/tools/perf/util/unwind-libdw.c +@@ -20,10 +20,24 @@ + + static char *debuginfo_path; + ++static int __find_debuginfo(Dwfl_Module *mod __maybe_unused, void **userdata, ++ const char *modname __maybe_unused, Dwarf_Addr base __maybe_unused, ++ const char *file_name, const char *debuglink_file __maybe_unused, ++ GElf_Word debuglink_crc __maybe_unused, char **debuginfo_file_name) ++{ ++ const struct dso *dso = *userdata; ++ ++ assert(dso); ++ if (dso->symsrc_filename && strcmp (file_name, dso->symsrc_filename)) ++ *debuginfo_file_name = strdup(dso->symsrc_filename); ++ return -1; ++} ++ + static const Dwfl_Callbacks offline_callbacks = { +- .find_debuginfo = dwfl_standard_find_debuginfo, ++ .find_debuginfo = __find_debuginfo, + .debuginfo_path = &debuginfo_path, + .section_address = dwfl_offline_section_address, ++ // .find_elf is not set as we use dwfl_report_elf() instead. + }; + + static int __report_module(struct addr_location *al, u64 ip, +@@ -53,9 +67,22 @@ static int __report_module(struct addr_location *al, u64 ip, + } + + if (!mod) +- mod = dwfl_report_elf(ui->dwfl, dso->short_name, +- (dso->symsrc_filename ? dso->symsrc_filename : dso->long_name), -1, al->map->start - al->map->pgoff, +- false); ++ mod = dwfl_report_elf(ui->dwfl, dso->short_name, dso->long_name, -1, ++ al->map->start - al->map->pgoff, false); ++ if (!mod) { ++ char filename[PATH_MAX]; ++ ++ if (dso__build_id_filename(dso, filename, sizeof(filename), false)) ++ mod = dwfl_report_elf(ui->dwfl, dso->short_name, filename, -1, ++ al->map->start - al->map->pgoff, false); ++ } ++ ++ if (mod) { ++ void **userdatap; ++ ++ dwfl_module_info(mod, &userdatap, NULL, NULL, NULL, NULL, NULL, NULL); ++ *userdatap = dso; ++ } + + return mod && dwfl_addrmodule(ui->dwfl, ip) == mod ? 0 : -1; + } diff --git a/patch/kernel/archive/sunxi-5.10/patch-5.10.40-41.patch b/patch/kernel/archive/sunxi-5.10/patch-5.10.40-41.patch new file mode 100644 index 0000000000..9699d6ef23 --- /dev/null +++ b/patch/kernel/archive/sunxi-5.10/patch-5.10.40-41.patch @@ -0,0 +1,344 @@ +diff --git a/Makefile b/Makefile +index 42c915ccc5b80..81011c92dd46f 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 10 +-SUBLEVEL = 40 ++SUBLEVEL = 41 + EXTRAVERSION = + NAME = Dare mighty things + +diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c +index ca7a717477e70..9d4eb114613c2 100644 +--- a/arch/x86/kvm/svm/svm.c ++++ b/arch/x86/kvm/svm/svm.c +@@ -3532,15 +3532,15 @@ static noinstr void svm_vcpu_enter_exit(struct kvm_vcpu *vcpu, + * have them in state 'on' as recorded before entering guest mode. + * Same as enter_from_user_mode(). + * +- * guest_exit_irqoff() restores host context and reinstates RCU if +- * enabled and required. ++ * context_tracking_guest_exit() restores host context and reinstates ++ * RCU if enabled and required. + * + * This needs to be done before the below as native_read_msr() + * contains a tracepoint and x86_spec_ctrl_restore_host() calls + * into world and some more. + */ + lockdep_hardirqs_off(CALLER_ADDR0); +- guest_exit_irqoff(); ++ context_tracking_guest_exit(); + + instrumentation_begin(); + trace_hardirqs_off_finish(); +diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c +index d7f8d2167fda0..45877364e6829 100644 +--- a/arch/x86/kvm/vmx/vmx.c ++++ b/arch/x86/kvm/vmx/vmx.c +@@ -6640,15 +6640,15 @@ static noinstr void vmx_vcpu_enter_exit(struct kvm_vcpu *vcpu, + * have them in state 'on' as recorded before entering guest mode. + * Same as enter_from_user_mode(). + * +- * guest_exit_irqoff() restores host context and reinstates RCU if +- * enabled and required. ++ * context_tracking_guest_exit() restores host context and reinstates ++ * RCU if enabled and required. + * + * This needs to be done before the below as native_read_msr() + * contains a tracepoint and x86_spec_ctrl_restore_host() calls + * into world and some more. + */ + lockdep_hardirqs_off(CALLER_ADDR0); +- guest_exit_irqoff(); ++ context_tracking_guest_exit(); + + instrumentation_begin(); + trace_hardirqs_off_finish(); +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index c071a83d543ae..7f767d59b09d3 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -9063,6 +9063,15 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + local_irq_disable(); + kvm_after_interrupt(vcpu); + ++ /* ++ * Wait until after servicing IRQs to account guest time so that any ++ * ticks that occurred while running the guest are properly accounted ++ * to the guest. Waiting until IRQs are enabled degrades the accuracy ++ * of accounting via context tracking, but the loss of accuracy is ++ * acceptable for all known use cases. ++ */ ++ vtime_account_guest_exit(); ++ + if (lapic_in_kernel(vcpu)) { + s64 delta = vcpu->arch.apic->lapic_timer.advance_expire_delta; + if (delta != S64_MIN) { +diff --git a/include/linux/context_tracking.h b/include/linux/context_tracking.h +index d53cd331c4dd3..f5d127a5d819b 100644 +--- a/include/linux/context_tracking.h ++++ b/include/linux/context_tracking.h +@@ -129,16 +129,26 @@ static __always_inline void guest_enter_irqoff(void) + } + } + +-static __always_inline void guest_exit_irqoff(void) ++static __always_inline void context_tracking_guest_exit(void) + { + if (context_tracking_enabled()) + __context_tracking_exit(CONTEXT_GUEST); ++} + +- instrumentation_begin(); ++static __always_inline void vtime_account_guest_exit(void) ++{ + if (vtime_accounting_enabled_this_cpu()) + vtime_guest_exit(current); + else + current->flags &= ~PF_VCPU; ++} ++ ++static __always_inline void guest_exit_irqoff(void) ++{ ++ context_tracking_guest_exit(); ++ ++ instrumentation_begin(); ++ vtime_account_guest_exit(); + instrumentation_end(); + } + +@@ -157,12 +167,19 @@ static __always_inline void guest_enter_irqoff(void) + instrumentation_end(); + } + ++static __always_inline void context_tracking_guest_exit(void) { } ++ ++static __always_inline void vtime_account_guest_exit(void) ++{ ++ vtime_account_kernel(current); ++ current->flags &= ~PF_VCPU; ++} ++ + static __always_inline void guest_exit_irqoff(void) + { + instrumentation_begin(); + /* Flush the guest cputime we spent on the guest */ +- vtime_account_kernel(current); +- current->flags &= ~PF_VCPU; ++ vtime_account_guest_exit(); + instrumentation_end(); + } + #endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */ +diff --git a/include/net/nfc/nci_core.h b/include/net/nfc/nci_core.h +index 43c9c5d2bedbd..33979017b7824 100644 +--- a/include/net/nfc/nci_core.h ++++ b/include/net/nfc/nci_core.h +@@ -298,6 +298,7 @@ int nci_nfcc_loopback(struct nci_dev *ndev, void *data, size_t data_len, + struct sk_buff **resp); + + struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev); ++void nci_hci_deallocate(struct nci_dev *ndev); + int nci_hci_send_event(struct nci_dev *ndev, u8 gate, u8 event, + const u8 *param, size_t param_len); + int nci_hci_send_cmd(struct nci_dev *ndev, u8 gate, +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index 69730943eaf80..364b9760d1a73 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -5666,18 +5666,10 @@ enum { + }; + + static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg, +- const struct bpf_reg_state *off_reg, +- u32 *alu_limit, u8 opcode) ++ u32 *alu_limit, bool mask_to_left) + { +- bool off_is_neg = off_reg->smin_value < 0; +- bool mask_to_left = (opcode == BPF_ADD && off_is_neg) || +- (opcode == BPF_SUB && !off_is_neg); + u32 max = 0, ptr_limit = 0; + +- if (!tnum_is_const(off_reg->var_off) && +- (off_reg->smin_value < 0) != (off_reg->smax_value < 0)) +- return REASON_BOUNDS; +- + switch (ptr_reg->type) { + case PTR_TO_STACK: + /* Offset 0 is out-of-bounds, but acceptable start for the +@@ -5743,15 +5735,20 @@ static bool sanitize_needed(u8 opcode) + return opcode == BPF_ADD || opcode == BPF_SUB; + } + ++struct bpf_sanitize_info { ++ struct bpf_insn_aux_data aux; ++ bool mask_to_left; ++}; ++ + static int sanitize_ptr_alu(struct bpf_verifier_env *env, + struct bpf_insn *insn, + const struct bpf_reg_state *ptr_reg, + const struct bpf_reg_state *off_reg, + struct bpf_reg_state *dst_reg, +- struct bpf_insn_aux_data *tmp_aux, ++ struct bpf_sanitize_info *info, + const bool commit_window) + { +- struct bpf_insn_aux_data *aux = commit_window ? cur_aux(env) : tmp_aux; ++ struct bpf_insn_aux_data *aux = commit_window ? cur_aux(env) : &info->aux; + struct bpf_verifier_state *vstate = env->cur_state; + bool off_is_imm = tnum_is_const(off_reg->var_off); + bool off_is_neg = off_reg->smin_value < 0; +@@ -5772,7 +5769,16 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, + if (vstate->speculative) + goto do_sim; + +- err = retrieve_ptr_limit(ptr_reg, off_reg, &alu_limit, opcode); ++ if (!commit_window) { ++ if (!tnum_is_const(off_reg->var_off) && ++ (off_reg->smin_value < 0) != (off_reg->smax_value < 0)) ++ return REASON_BOUNDS; ++ ++ info->mask_to_left = (opcode == BPF_ADD && off_is_neg) || ++ (opcode == BPF_SUB && !off_is_neg); ++ } ++ ++ err = retrieve_ptr_limit(ptr_reg, &alu_limit, info->mask_to_left); + if (err < 0) + return err; + +@@ -5780,8 +5786,8 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, + /* In commit phase we narrow the masking window based on + * the observed pointer move after the simulated operation. + */ +- alu_state = tmp_aux->alu_state; +- alu_limit = abs(tmp_aux->alu_limit - alu_limit); ++ alu_state = info->aux.alu_state; ++ alu_limit = abs(info->aux.alu_limit - alu_limit); + } else { + alu_state = off_is_neg ? BPF_ALU_NEG_VALUE : 0; + alu_state |= off_is_imm ? BPF_ALU_IMMEDIATE : 0; +@@ -5796,8 +5802,12 @@ do_sim: + /* If we're in commit phase, we're done here given we already + * pushed the truncated dst_reg into the speculative verification + * stack. ++ * ++ * Also, when register is a known constant, we rewrite register-based ++ * operation to immediate-based, and thus do not need masking (and as ++ * a consequence, do not need to simulate the zero-truncation either). + */ +- if (commit_window) ++ if (commit_window || off_is_imm) + return 0; + + /* Simulate and find potential out-of-bounds access under +@@ -5942,7 +5952,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value; + u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value, + umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value; +- struct bpf_insn_aux_data tmp_aux = {}; ++ struct bpf_sanitize_info info = {}; + u8 opcode = BPF_OP(insn->code); + u32 dst = insn->dst_reg; + int ret; +@@ -6011,7 +6021,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + + if (sanitize_needed(opcode)) { + ret = sanitize_ptr_alu(env, insn, ptr_reg, off_reg, dst_reg, +- &tmp_aux, false); ++ &info, false); + if (ret < 0) + return sanitize_err(env, insn, ret, off_reg, dst_reg); + } +@@ -6152,7 +6162,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + return -EACCES; + if (sanitize_needed(opcode)) { + ret = sanitize_ptr_alu(env, insn, dst_reg, off_reg, dst_reg, +- &tmp_aux, true); ++ &info, true); + if (ret < 0) + return sanitize_err(env, insn, ret, off_reg, dst_reg); + } +diff --git a/net/nfc/nci/core.c b/net/nfc/nci/core.c +index 741da8f81c2b8..32e8154363cab 100644 +--- a/net/nfc/nci/core.c ++++ b/net/nfc/nci/core.c +@@ -1175,6 +1175,7 @@ EXPORT_SYMBOL(nci_allocate_device); + void nci_free_device(struct nci_dev *ndev) + { + nfc_free_device(ndev->nfc_dev); ++ nci_hci_deallocate(ndev); + kfree(ndev); + } + EXPORT_SYMBOL(nci_free_device); +diff --git a/net/nfc/nci/hci.c b/net/nfc/nci/hci.c +index c18e76d6d8ba0..04e55ccb33836 100644 +--- a/net/nfc/nci/hci.c ++++ b/net/nfc/nci/hci.c +@@ -795,3 +795,8 @@ struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev) + + return hdev; + } ++ ++void nci_hci_deallocate(struct nci_dev *ndev) ++{ ++ kfree(ndev->hci_dev); ++} +diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c +index 7a3dbc259cecc..a74b517f74974 100644 +--- a/tools/perf/util/unwind-libdw.c ++++ b/tools/perf/util/unwind-libdw.c +@@ -20,10 +20,24 @@ + + static char *debuginfo_path; + ++static int __find_debuginfo(Dwfl_Module *mod __maybe_unused, void **userdata, ++ const char *modname __maybe_unused, Dwarf_Addr base __maybe_unused, ++ const char *file_name, const char *debuglink_file __maybe_unused, ++ GElf_Word debuglink_crc __maybe_unused, char **debuginfo_file_name) ++{ ++ const struct dso *dso = *userdata; ++ ++ assert(dso); ++ if (dso->symsrc_filename && strcmp (file_name, dso->symsrc_filename)) ++ *debuginfo_file_name = strdup(dso->symsrc_filename); ++ return -1; ++} ++ + static const Dwfl_Callbacks offline_callbacks = { +- .find_debuginfo = dwfl_standard_find_debuginfo, ++ .find_debuginfo = __find_debuginfo, + .debuginfo_path = &debuginfo_path, + .section_address = dwfl_offline_section_address, ++ // .find_elf is not set as we use dwfl_report_elf() instead. + }; + + static int __report_module(struct addr_location *al, u64 ip, +@@ -53,9 +67,22 @@ static int __report_module(struct addr_location *al, u64 ip, + } + + if (!mod) +- mod = dwfl_report_elf(ui->dwfl, dso->short_name, +- (dso->symsrc_filename ? dso->symsrc_filename : dso->long_name), -1, al->map->start - al->map->pgoff, +- false); ++ mod = dwfl_report_elf(ui->dwfl, dso->short_name, dso->long_name, -1, ++ al->map->start - al->map->pgoff, false); ++ if (!mod) { ++ char filename[PATH_MAX]; ++ ++ if (dso__build_id_filename(dso, filename, sizeof(filename), false)) ++ mod = dwfl_report_elf(ui->dwfl, dso->short_name, filename, -1, ++ al->map->start - al->map->pgoff, false); ++ } ++ ++ if (mod) { ++ void **userdatap; ++ ++ dwfl_module_info(mod, &userdatap, NULL, NULL, NULL, NULL, NULL, NULL); ++ *userdatap = dso; ++ } + + return mod && dwfl_addrmodule(ui->dwfl, ip) == mod ? 0 : -1; + } diff --git a/patch/kernel/archive/sunxi-5.12/patch-5.12.7-8.patch b/patch/kernel/archive/sunxi-5.12/patch-5.12.7-8.patch new file mode 100644 index 0000000000..1cfbe69453 --- /dev/null +++ b/patch/kernel/archive/sunxi-5.12/patch-5.12.7-8.patch @@ -0,0 +1,288 @@ +diff --git a/Makefile b/Makefile +index 6a73dee7c2219..a20afcb7d2bf4 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 12 +-SUBLEVEL = 7 ++SUBLEVEL = 8 + EXTRAVERSION = + NAME = Frozen Wasteland + +diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c +index 48ee3deab64b1..9a6825feaf53f 100644 +--- a/arch/x86/kvm/svm/svm.c ++++ b/arch/x86/kvm/svm/svm.c +@@ -3815,15 +3815,15 @@ static noinstr void svm_vcpu_enter_exit(struct kvm_vcpu *vcpu, + * have them in state 'on' as recorded before entering guest mode. + * Same as enter_from_user_mode(). + * +- * guest_exit_irqoff() restores host context and reinstates RCU if +- * enabled and required. ++ * context_tracking_guest_exit() restores host context and reinstates ++ * RCU if enabled and required. + * + * This needs to be done before the below as native_read_msr() + * contains a tracepoint and x86_spec_ctrl_restore_host() calls + * into world and some more. + */ + lockdep_hardirqs_off(CALLER_ADDR0); +- guest_exit_irqoff(); ++ context_tracking_guest_exit(); + + instrumentation_begin(); + trace_hardirqs_off_finish(); +diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c +index f68ed9a1abcc9..ae63d59be38c7 100644 +--- a/arch/x86/kvm/vmx/vmx.c ++++ b/arch/x86/kvm/vmx/vmx.c +@@ -6701,15 +6701,15 @@ static noinstr void vmx_vcpu_enter_exit(struct kvm_vcpu *vcpu, + * have them in state 'on' as recorded before entering guest mode. + * Same as enter_from_user_mode(). + * +- * guest_exit_irqoff() restores host context and reinstates RCU if +- * enabled and required. ++ * context_tracking_guest_exit() restores host context and reinstates ++ * RCU if enabled and required. + * + * This needs to be done before the below as native_read_msr() + * contains a tracepoint and x86_spec_ctrl_restore_host() calls + * into world and some more. + */ + lockdep_hardirqs_off(CALLER_ADDR0); +- guest_exit_irqoff(); ++ context_tracking_guest_exit(); + + instrumentation_begin(); + trace_hardirqs_off_finish(); +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 87311d39f9145..86678f8b35020 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -9236,6 +9236,15 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + local_irq_disable(); + kvm_after_interrupt(vcpu); + ++ /* ++ * Wait until after servicing IRQs to account guest time so that any ++ * ticks that occurred while running the guest are properly accounted ++ * to the guest. Waiting until IRQs are enabled degrades the accuracy ++ * of accounting via context tracking, but the loss of accuracy is ++ * acceptable for all known use cases. ++ */ ++ vtime_account_guest_exit(); ++ + if (lapic_in_kernel(vcpu)) { + s64 delta = vcpu->arch.apic->lapic_timer.advance_expire_delta; + if (delta != S64_MIN) { +diff --git a/include/linux/context_tracking.h b/include/linux/context_tracking.h +index bceb064985214..4f4556232dcf7 100644 +--- a/include/linux/context_tracking.h ++++ b/include/linux/context_tracking.h +@@ -131,16 +131,26 @@ static __always_inline void guest_enter_irqoff(void) + } + } + +-static __always_inline void guest_exit_irqoff(void) ++static __always_inline void context_tracking_guest_exit(void) + { + if (context_tracking_enabled()) + __context_tracking_exit(CONTEXT_GUEST); ++} + +- instrumentation_begin(); ++static __always_inline void vtime_account_guest_exit(void) ++{ + if (vtime_accounting_enabled_this_cpu()) + vtime_guest_exit(current); + else + current->flags &= ~PF_VCPU; ++} ++ ++static __always_inline void guest_exit_irqoff(void) ++{ ++ context_tracking_guest_exit(); ++ ++ instrumentation_begin(); ++ vtime_account_guest_exit(); + instrumentation_end(); + } + +@@ -159,12 +169,19 @@ static __always_inline void guest_enter_irqoff(void) + instrumentation_end(); + } + ++static __always_inline void context_tracking_guest_exit(void) { } ++ ++static __always_inline void vtime_account_guest_exit(void) ++{ ++ vtime_account_kernel(current); ++ current->flags &= ~PF_VCPU; ++} ++ + static __always_inline void guest_exit_irqoff(void) + { + instrumentation_begin(); + /* Flush the guest cputime we spent on the guest */ +- vtime_account_kernel(current); +- current->flags &= ~PF_VCPU; ++ vtime_account_guest_exit(); + instrumentation_end(); + } + #endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */ +diff --git a/include/net/nfc/nci_core.h b/include/net/nfc/nci_core.h +index 43c9c5d2bedbd..33979017b7824 100644 +--- a/include/net/nfc/nci_core.h ++++ b/include/net/nfc/nci_core.h +@@ -298,6 +298,7 @@ int nci_nfcc_loopback(struct nci_dev *ndev, void *data, size_t data_len, + struct sk_buff **resp); + + struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev); ++void nci_hci_deallocate(struct nci_dev *ndev); + int nci_hci_send_event(struct nci_dev *ndev, u8 gate, u8 event, + const u8 *param, size_t param_len); + int nci_hci_send_cmd(struct nci_dev *ndev, u8 gate, +diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c +index 7fa6fc6bedf1f..21247e49fe82b 100644 +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -5863,18 +5863,10 @@ enum { + }; + + static int retrieve_ptr_limit(const struct bpf_reg_state *ptr_reg, +- const struct bpf_reg_state *off_reg, +- u32 *alu_limit, u8 opcode) ++ u32 *alu_limit, bool mask_to_left) + { +- bool off_is_neg = off_reg->smin_value < 0; +- bool mask_to_left = (opcode == BPF_ADD && off_is_neg) || +- (opcode == BPF_SUB && !off_is_neg); + u32 max = 0, ptr_limit = 0; + +- if (!tnum_is_const(off_reg->var_off) && +- (off_reg->smin_value < 0) != (off_reg->smax_value < 0)) +- return REASON_BOUNDS; +- + switch (ptr_reg->type) { + case PTR_TO_STACK: + /* Offset 0 is out-of-bounds, but acceptable start for the +@@ -5940,15 +5932,20 @@ static bool sanitize_needed(u8 opcode) + return opcode == BPF_ADD || opcode == BPF_SUB; + } + ++struct bpf_sanitize_info { ++ struct bpf_insn_aux_data aux; ++ bool mask_to_left; ++}; ++ + static int sanitize_ptr_alu(struct bpf_verifier_env *env, + struct bpf_insn *insn, + const struct bpf_reg_state *ptr_reg, + const struct bpf_reg_state *off_reg, + struct bpf_reg_state *dst_reg, +- struct bpf_insn_aux_data *tmp_aux, ++ struct bpf_sanitize_info *info, + const bool commit_window) + { +- struct bpf_insn_aux_data *aux = commit_window ? cur_aux(env) : tmp_aux; ++ struct bpf_insn_aux_data *aux = commit_window ? cur_aux(env) : &info->aux; + struct bpf_verifier_state *vstate = env->cur_state; + bool off_is_imm = tnum_is_const(off_reg->var_off); + bool off_is_neg = off_reg->smin_value < 0; +@@ -5969,7 +5966,16 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, + if (vstate->speculative) + goto do_sim; + +- err = retrieve_ptr_limit(ptr_reg, off_reg, &alu_limit, opcode); ++ if (!commit_window) { ++ if (!tnum_is_const(off_reg->var_off) && ++ (off_reg->smin_value < 0) != (off_reg->smax_value < 0)) ++ return REASON_BOUNDS; ++ ++ info->mask_to_left = (opcode == BPF_ADD && off_is_neg) || ++ (opcode == BPF_SUB && !off_is_neg); ++ } ++ ++ err = retrieve_ptr_limit(ptr_reg, &alu_limit, info->mask_to_left); + if (err < 0) + return err; + +@@ -5977,8 +5983,8 @@ static int sanitize_ptr_alu(struct bpf_verifier_env *env, + /* In commit phase we narrow the masking window based on + * the observed pointer move after the simulated operation. + */ +- alu_state = tmp_aux->alu_state; +- alu_limit = abs(tmp_aux->alu_limit - alu_limit); ++ alu_state = info->aux.alu_state; ++ alu_limit = abs(info->aux.alu_limit - alu_limit); + } else { + alu_state = off_is_neg ? BPF_ALU_NEG_VALUE : 0; + alu_state |= off_is_imm ? BPF_ALU_IMMEDIATE : 0; +@@ -5993,8 +5999,12 @@ do_sim: + /* If we're in commit phase, we're done here given we already + * pushed the truncated dst_reg into the speculative verification + * stack. ++ * ++ * Also, when register is a known constant, we rewrite register-based ++ * operation to immediate-based, and thus do not need masking (and as ++ * a consequence, do not need to simulate the zero-truncation either). + */ +- if (commit_window) ++ if (commit_window || off_is_imm) + return 0; + + /* Simulate and find potential out-of-bounds access under +@@ -6139,7 +6149,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value; + u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value, + umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value; +- struct bpf_insn_aux_data tmp_aux = {}; ++ struct bpf_sanitize_info info = {}; + u8 opcode = BPF_OP(insn->code); + u32 dst = insn->dst_reg; + int ret; +@@ -6208,7 +6218,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + + if (sanitize_needed(opcode)) { + ret = sanitize_ptr_alu(env, insn, ptr_reg, off_reg, dst_reg, +- &tmp_aux, false); ++ &info, false); + if (ret < 0) + return sanitize_err(env, insn, ret, off_reg, dst_reg); + } +@@ -6349,7 +6359,7 @@ static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, + return -EACCES; + if (sanitize_needed(opcode)) { + ret = sanitize_ptr_alu(env, insn, dst_reg, off_reg, dst_reg, +- &tmp_aux, true); ++ &info, true); + if (ret < 0) + return sanitize_err(env, insn, ret, off_reg, dst_reg); + } +diff --git a/net/nfc/nci/core.c b/net/nfc/nci/core.c +index 59257400697d1..142d71c8d6521 100644 +--- a/net/nfc/nci/core.c ++++ b/net/nfc/nci/core.c +@@ -1191,6 +1191,7 @@ EXPORT_SYMBOL(nci_allocate_device); + void nci_free_device(struct nci_dev *ndev) + { + nfc_free_device(ndev->nfc_dev); ++ nci_hci_deallocate(ndev); + kfree(ndev); + } + EXPORT_SYMBOL(nci_free_device); +diff --git a/net/nfc/nci/hci.c b/net/nfc/nci/hci.c +index 6b275a387a92a..96865142104f4 100644 +--- a/net/nfc/nci/hci.c ++++ b/net/nfc/nci/hci.c +@@ -792,3 +792,8 @@ struct nci_hci_dev *nci_hci_allocate(struct nci_dev *ndev) + + return hdev; + } ++ ++void nci_hci_deallocate(struct nci_dev *ndev) ++{ ++ kfree(ndev->hci_dev); ++} diff --git a/patch/u-boot/u-boot-sunxi/enable-audio-codec-bpim2ultra-kernel.patch b/patch/u-boot/u-boot-sunxi/enable-audio-codec-bpim2ultra-kernel.patch deleted file mode 100644 index c4ca221535..0000000000 --- a/patch/u-boot/u-boot-sunxi/enable-audio-codec-bpim2ultra-kernel.patch +++ /dev/null @@ -1,50 +0,0 @@ -diff --git a/arch/arm/boot/dts/sun8i-r40-bananapi-m2-ultra.dts b/arch/arm/boot/dts/sun8i-r40-bananapi-m2-ultra.dts -index a6a1087a0c9b..3ad67d12cb9f 100644 ---- a/arch/arm/boot/dts/sun8i-r40-bananapi-m2-ultra.dts -+++ b/arch/arm/boot/dts/sun8i-r40-bananapi-m2-ultra.dts -@@ -113,6 +113,16 @@ &ahci { - status = "okay"; - }; - -+&codec { -+ allwinner,audio-routing = -+ "Headphone", "HP", -+ "Headphone", "HPCOM", -+ "MIC1", "Mic", -+ "Mic", "MBIAS"; -+ allwinner,codec-analog-controls = <&codec_analog>; -+ status = "okay"; -+}; -+ - &de { - status = "okay"; - }; -diff --git a/arch/arm/boot/dts/sun8i-r40.dtsi b/arch/arm/boot/dts/sun8i-r40.dtsi -index 7907569e7b5c..63d531617f59 100644 ---- a/arch/arm/boot/dts/sun8i-r40.dtsi -+++ b/arch/arm/boot/dts/sun8i-r40.dtsi -@@ -672,6 +672,24 @@ ths: thermal-sensor@1c24c00 { - #thermal-sensor-cells = <1>; - }; - -+ codec: codec@1c22c00 { -+ #sound-dai-cells = <1>; -+ compatible = "allwinner,sun8i-h3-codec"; -+ reg = <0x01c22c00 0x300>; -+ interrupts = ; -+ clocks = <&ccu CLK_BUS_CODEC>, <&ccu CLK_CODEC>; -+ clock-names = "apb", "codec"; -+ resets = <&ccu RST_BUS_CODEC>; -+ dmas = <&dma 19>, <&dma 19>; -+ dma-names = "rx", "tx"; -+ status = "disabled"; -+ }; -+ -+ codec_analog: codec-analog@1c22f00 { -+ compatible = "allwinner,sun8i-a23-codec-analog"; -+ reg = <0x01c22f00 0x4>; -+ }; -+ - uart0: serial@1c28000 { - compatible = "snps,dw-apb-uart"; - reg = <0x01c28000 0x400>;