tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'loongarch-fixes-6.6-1' of git://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson

Pull LoongArch fixes from Huacai Chen:
"Fix lockdep, fix a boot failure, fix some build warnings, fix document
links, and some cleanups"

* tag 'loongarch-fixes-6.6-1' of git://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson:
docs/zh_CN/LoongArch: Update the links of ABI
docs/LoongArch: Update the links of ABI
LoongArch: Don't inline kasan_mem_to_shadow()/kasan_shadow_to_mem()
kasan: Cleanup the __HAVE_ARCH_SHADOW_MAP usage
LoongArch: Set all reserved memblocks on Node#0 at initialization
LoongArch: Remove dead code in relocate_new_kernel
LoongArch: Use _UL() and _ULL()
LoongArch: Fix some build warnings with W=1
LoongArch: Fix lockdep static memory detection

Linus Torvalds 93397d3a 2e3d3911

+178 -135
+2 -2
Documentation/arch/loongarch/introduction.rst
··· 381 381 382 382 Documentation of LoongArch ELF psABI: 383 383 384 - https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-CN.pdf (in Chinese) 384 + https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-CN.pdf (in Chinese) 385 385 386 - https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-EN.pdf (in English) 386 + https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-EN.pdf (in English) 387 387 388 388 Linux kernel repository of Loongson and LoongArch: 389 389
+2 -2
Documentation/translations/zh_CN/arch/loongarch/introduction.rst
··· 344 344 345 345 LoongArch的ELF psABI文档： 346 346 347 - https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-CN.pdf （中文版） 347 + https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-CN.pdf （中文版） 348 348 349 - https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.00-EN.pdf （英文版） 349 + https://github.com/loongson/LoongArch-Documentation/releases/latest/download/LoongArch-ELF-ABI-v2.01-EN.pdf （英文版） 350 350 351 351 Loongson与LoongArch的Linux内核源码仓库： 352 352
+7 -7
arch/loongarch/include/asm/addrspace.h
··· 19 19 */ 20 20 #ifndef __ASSEMBLY__ 21 21 #ifndef PHYS_OFFSET 22 - #define PHYS_OFFSET _AC(0, UL) 22 + #define PHYS_OFFSET _UL(0) 23 23 #endif 24 24 extern unsigned long vm_map_base; 25 25 #endif /* __ASSEMBLY__ */ ··· 43 43 * Memory above this physical address will be considered highmem. 44 44 */ 45 45 #ifndef HIGHMEM_START 46 - #define HIGHMEM_START (_AC(1, UL) << _AC(DMW_PABITS, UL)) 46 + #define HIGHMEM_START (_UL(1) << _UL(DMW_PABITS)) 47 47 #endif 48 48 49 49 #define TO_PHYS(x) ( ((x) & TO_PHYS_MASK)) ··· 65 65 #define _ATYPE_ 66 66 #define _ATYPE32_ 67 67 #define _ATYPE64_ 68 - #define _CONST64_(x) x 69 68 #else 70 69 #define _ATYPE_ __PTRDIFF_TYPE__ 71 70 #define _ATYPE32_ int 72 71 #define _ATYPE64_ __s64 73 - #ifdef CONFIG_64BIT 74 - #define _CONST64_(x) x ## UL 75 - #else 76 - #define _CONST64_(x) x ## ULL 77 72 #endif 73 + 74 + #ifdef CONFIG_64BIT 75 + #define _CONST64_(x) _UL(x) 76 + #else 77 + #define _CONST64_(x) _ULL(x) 78 78 #endif 79 79 80 80 /*
+45
arch/loongarch/include/asm/exception.h
··· 1 + /* SPDX-License-Identifier: GPL-2.0-only */ 2 + 3 + #ifndef __ASM_EXCEPTION_H 4 + #define __ASM_EXCEPTION_H 5 + 6 + #include <asm/ptrace.h> 7 + #include <linux/kprobes.h> 8 + 9 + void show_registers(struct pt_regs *regs); 10 + 11 + asmlinkage void cache_parity_error(void); 12 + asmlinkage void noinstr do_ade(struct pt_regs *regs); 13 + asmlinkage void noinstr do_ale(struct pt_regs *regs); 14 + asmlinkage void noinstr do_bce(struct pt_regs *regs); 15 + asmlinkage void noinstr do_bp(struct pt_regs *regs); 16 + asmlinkage void noinstr do_ri(struct pt_regs *regs); 17 + asmlinkage void noinstr do_fpu(struct pt_regs *regs); 18 + asmlinkage void noinstr do_fpe(struct pt_regs *regs, unsigned long fcsr); 19 + asmlinkage void noinstr do_lsx(struct pt_regs *regs); 20 + asmlinkage void noinstr do_lasx(struct pt_regs *regs); 21 + asmlinkage void noinstr do_lbt(struct pt_regs *regs); 22 + asmlinkage void noinstr do_watch(struct pt_regs *regs); 23 + asmlinkage void noinstr do_syscall(struct pt_regs *regs); 24 + asmlinkage void noinstr do_reserved(struct pt_regs *regs); 25 + asmlinkage void noinstr do_vint(struct pt_regs *regs, unsigned long sp); 26 + asmlinkage void __kprobes do_page_fault(struct pt_regs *regs, 27 + unsigned long write, unsigned long address); 28 + 29 + asmlinkage void handle_ade(void); 30 + asmlinkage void handle_ale(void); 31 + asmlinkage void handle_bce(void); 32 + asmlinkage void handle_sys(void); 33 + asmlinkage void handle_bp(void); 34 + asmlinkage void handle_ri(void); 35 + asmlinkage void handle_fpu(void); 36 + asmlinkage void handle_fpe(void); 37 + asmlinkage void handle_lsx(void); 38 + asmlinkage void handle_lasx(void); 39 + asmlinkage void handle_lbt(void); 40 + asmlinkage void handle_watch(void); 41 + asmlinkage void handle_reserved(void); 42 + asmlinkage void handle_vint(void); 43 + asmlinkage void noinstr handle_loongarch_irq(struct pt_regs *regs); 44 + 45 + #endif /* __ASM_EXCEPTION_H */
+9 -50
arch/loongarch/include/asm/kasan.h
··· 10 10 #include <asm/io.h> 11 11 #include <asm/pgtable.h> 12 12 13 - #define __HAVE_ARCH_SHADOW_MAP 14 - 15 13 #define KASAN_SHADOW_SCALE_SHIFT 3 16 14 #define KASAN_SHADOW_OFFSET _AC(CONFIG_KASAN_SHADOW_OFFSET, UL) 17 15 ··· 60 62 extern bool kasan_early_stage; 61 63 extern unsigned char kasan_early_shadow_page[PAGE_SIZE]; 62 64 65 + #define kasan_mem_to_shadow kasan_mem_to_shadow 66 + void *kasan_mem_to_shadow(const void *addr); 67 + 68 + #define kasan_shadow_to_mem kasan_shadow_to_mem 69 + const void *kasan_shadow_to_mem(const void *shadow_addr); 70 + 63 71 #define kasan_arch_is_ready kasan_arch_is_ready 64 72 static __always_inline bool kasan_arch_is_ready(void) 65 73 { 66 74 return !kasan_early_stage; 67 75 } 68 76 69 - static inline void *kasan_mem_to_shadow(const void *addr) 77 + #define addr_has_metadata addr_has_metadata 78 + static __always_inline bool addr_has_metadata(const void *addr) 70 79 { 71 - if (!kasan_arch_is_ready()) { 72 - return (void *)(kasan_early_shadow_page); 73 - } else { 74 - unsigned long maddr = (unsigned long)addr; 75 - unsigned long xrange = (maddr >> XRANGE_SHIFT) & 0xffff; 76 - unsigned long offset = 0; 77 - 78 - maddr &= XRANGE_SHADOW_MASK; 79 - switch (xrange) { 80 - case XKPRANGE_CC_SEG: 81 - offset = XKPRANGE_CC_SHADOW_OFFSET; 82 - break; 83 - case XKPRANGE_UC_SEG: 84 - offset = XKPRANGE_UC_SHADOW_OFFSET; 85 - break; 86 - case XKVRANGE_VC_SEG: 87 - offset = XKVRANGE_VC_SHADOW_OFFSET; 88 - break; 89 - default: 90 - WARN_ON(1); 91 - return NULL; 92 - } 93 - 94 - return (void *)((maddr >> KASAN_SHADOW_SCALE_SHIFT) + offset); 95 - } 96 - } 97 - 98 - static inline const void *kasan_shadow_to_mem(const void *shadow_addr) 99 - { 100 - unsigned long addr = (unsigned long)shadow_addr; 101 - 102 - if (unlikely(addr > KASAN_SHADOW_END) || 103 - unlikely(addr < KASAN_SHADOW_START)) { 104 - WARN_ON(1); 105 - return NULL; 106 - } 107 - 108 - if (addr >= XKVRANGE_VC_SHADOW_OFFSET) 109 - return (void *)(((addr - XKVRANGE_VC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKVRANGE_VC_START); 110 - else if (addr >= XKPRANGE_UC_SHADOW_OFFSET) 111 - return (void *)(((addr - XKPRANGE_UC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_UC_START); 112 - else if (addr >= XKPRANGE_CC_SHADOW_OFFSET) 113 - return (void *)(((addr - XKPRANGE_CC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_CC_START); 114 - else { 115 - WARN_ON(1); 116 - return NULL; 117 - } 80 + return (kasan_mem_to_shadow((void *)addr) != NULL); 118 81 } 119 82 120 83 void kasan_init(void);
+1
arch/loongarch/include/asm/smp.h
··· 70 70 extern struct secondary_data cpuboot_data; 71 71 72 72 extern asmlinkage void smpboot_entry(void); 73 + extern asmlinkage void start_secondary(void); 73 74 74 75 extern void calculate_cpu_foreign_map(void); 75 76
+4
arch/loongarch/kernel/Makefile
··· 19 19 20 20 obj-$(CONFIG_ARCH_STRICT_ALIGN) += unaligned.o 21 21 22 + CFLAGS_module.o += $(call cc-option,-Wno-override-init,) 23 + CFLAGS_syscall.o += $(call cc-option,-Wno-override-init,) 24 + CFLAGS_perf_event.o += $(call cc-option,-Wno-override-init,) 25 + 22 26 ifdef CONFIG_FUNCTION_TRACER 23 27 ifndef CONFIG_DYNAMIC_FTRACE 24 28 obj-y += mcount.o ftrace.o
-1
arch/loongarch/kernel/acpi.c
··· 281 281 pr_info("SRAT: PXM %u -> CPU 0x%02x -> Node %u\n", pxm, pa->apic_id, node); 282 282 } 283 283 284 - void __init acpi_numa_arch_fixup(void) {} 285 284 #endif 286 285 287 286 void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)
+3 -1
arch/loongarch/kernel/mem.c
··· 50 50 } 51 51 52 52 memblock_set_current_limit(PFN_PHYS(max_low_pfn)); 53 - memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0); 54 53 55 54 /* Reserve the first 2MB */ 56 55 memblock_reserve(PHYS_OFFSET, 0x200000); ··· 57 58 /* Reserve the kernel text/data/bss */ 58 59 memblock_reserve(__pa_symbol(&_text), 59 60 __pa_symbol(&_end) - __pa_symbol(&_text)); 61 + 62 + memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0); 63 + memblock_set_node(0, PHYS_ADDR_MAX, &memblock.reserved, 0); 60 64 }
+1
arch/loongarch/kernel/module-sections.c
··· 6 6 #include <linux/elf.h> 7 7 #include <linux/kernel.h> 8 8 #include <linux/module.h> 9 + #include <linux/moduleloader.h> 9 10 #include <linux/ftrace.h> 10 11 11 12 Elf_Addr module_emit_got_entry(struct module *mod, Elf_Shdr *sechdrs, Elf_Addr val)
+1
arch/loongarch/kernel/process.c
··· 37 37 #include <asm/bootinfo.h> 38 38 #include <asm/cpu.h> 39 39 #include <asm/elf.h> 40 + #include <asm/exec.h> 40 41 #include <asm/fpu.h> 41 42 #include <asm/lbt.h> 42 43 #include <asm/io.h>
-1
arch/loongarch/kernel/relocate_kernel.S
··· 72 72 LONG_ADDI s5, s5, -1 73 73 beqz s5, process_entry 74 74 b copy_word 75 - b process_entry 76 75 77 76 done: 78 77 ibar 0
+4 -3
arch/loongarch/kernel/signal.c
··· 13 13 #include <linux/audit.h> 14 14 #include <linux/cache.h> 15 15 #include <linux/context_tracking.h> 16 + #include <linux/entry-common.h> 16 17 #include <linux/irqflags.h> 17 18 #include <linux/sched.h> 18 19 #include <linux/mm.h> ··· 892 891 return new_sp; 893 892 } 894 893 895 - void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, 896 - struct extctx_layout *extctx) 894 + static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, 895 + struct extctx_layout *extctx) 897 896 { 898 897 unsigned long sp; 899 898 ··· 923 922 * Atomically swap in the new signal mask, and wait for a signal. 924 923 */ 925 924 926 - asmlinkage long sys_rt_sigreturn(void) 925 + SYSCALL_DEFINE0(rt_sigreturn) 927 926 { 928 927 int sig; 929 928 sigset_t set;
+3
arch/loongarch/kernel/smp.c
··· 13 13 #include <linux/cpumask.h> 14 14 #include <linux/init.h> 15 15 #include <linux/interrupt.h> 16 + #include <linux/profile.h> 16 17 #include <linux/seq_file.h> 17 18 #include <linux/smp.h> 18 19 #include <linux/threads.h> ··· 557 556 smp_call_function(stop_this_cpu, NULL, 0); 558 557 } 559 558 559 + #ifdef CONFIG_PROFILING 560 560 int setup_profiling_timer(unsigned int multiplier) 561 561 { 562 562 return 0; 563 563 } 564 + #endif 564 565 565 566 static void flush_tlb_all_ipi(void *info) 566 567 {
+1
arch/loongarch/kernel/syscall.c
··· 13 13 #include <linux/unistd.h> 14 14 15 15 #include <asm/asm.h> 16 + #include <asm/exception.h> 16 17 #include <asm/signal.h> 17 18 #include <asm/switch_to.h> 18 19 #include <asm-generic/syscalls.h>
+1 -1
arch/loongarch/kernel/time.c
··· 29 29 { 30 30 } 31 31 32 - irqreturn_t constant_timer_interrupt(int irq, void *data) 32 + static irqreturn_t constant_timer_interrupt(int irq, void *data) 33 33 { 34 34 int cpu = smp_processor_id(); 35 35 struct clock_event_device *cd;
+3
arch/loongarch/kernel/topology.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0 2 + #include <linux/acpi.h> 2 3 #include <linux/cpu.h> 3 4 #include <linux/cpumask.h> 4 5 #include <linux/init.h> ··· 7 6 #include <linux/nodemask.h> 8 7 #include <linux/percpu.h> 9 8 #include <asm/bootinfo.h> 9 + 10 + #include <acpi/processor.h> 10 11 11 12 static DEFINE_PER_CPU(struct cpu, cpu_devices); 12 13
+5 -20
arch/loongarch/kernel/traps.c
··· 25 25 #include <linux/ptrace.h> 26 26 #include <linux/kgdb.h> 27 27 #include <linux/kdebug.h> 28 - #include <linux/kprobes.h> 29 28 #include <linux/notifier.h> 30 29 #include <linux/irq.h> 31 30 #include <linux/perf_event.h> ··· 34 35 #include <asm/branch.h> 35 36 #include <asm/break.h> 36 37 #include <asm/cpu.h> 38 + #include <asm/exception.h> 37 39 #include <asm/fpu.h> 38 40 #include <asm/lbt.h> 39 41 #include <asm/inst.h> ··· 52 52 #include <asm/uprobes.h> 53 53 54 54 #include "access-helper.h" 55 - 56 - extern asmlinkage void handle_ade(void); 57 - extern asmlinkage void handle_ale(void); 58 - extern asmlinkage void handle_bce(void); 59 - extern asmlinkage void handle_sys(void); 60 - extern asmlinkage void handle_bp(void); 61 - extern asmlinkage void handle_ri(void); 62 - extern asmlinkage void handle_fpu(void); 63 - extern asmlinkage void handle_fpe(void); 64 - extern asmlinkage void handle_lbt(void); 65 - extern asmlinkage void handle_lsx(void); 66 - extern asmlinkage void handle_lasx(void); 67 - extern asmlinkage void handle_reserved(void); 68 - extern asmlinkage void handle_watch(void); 69 - extern asmlinkage void handle_vint(void); 70 55 71 56 static void show_backtrace(struct task_struct *task, const struct pt_regs *regs, 72 57 const char *loglvl, bool user) ··· 424 439 * happen together with Overflow or Underflow, and `ptrace' can set 425 440 * any bits. 426 441 */ 427 - void force_fcsr_sig(unsigned long fcsr, void __user *fault_addr, 428 - struct task_struct *tsk) 442 + static void force_fcsr_sig(unsigned long fcsr, 443 + void __user *fault_addr, struct task_struct *tsk) 429 444 { 430 445 int si_code = FPE_FLTUNK; 431 446 ··· 443 458 force_sig_fault(SIGFPE, si_code, fault_addr); 444 459 } 445 460 446 - int process_fpemu_return(int sig, void __user *fault_addr, unsigned long fcsr) 461 + static int process_fpemu_return(int sig, void __user *fault_addr, unsigned long fcsr) 447 462 { 448 463 int si_code; 449 464 ··· 809 824 asmlinkage void noinstr do_ri(struct pt_regs *regs) 810 825 { 811 826 int status = SIGILL; 812 - unsigned int opcode = 0; 827 + unsigned int __maybe_unused opcode; 813 828 unsigned int __user *era = (unsigned int __user *)exception_era(regs); 814 829 irqentry_state_t state = irqentry_enter(regs); 815 830
+28 -27
arch/loongarch/kernel/vmlinux.lds.S
··· 53 53 . = ALIGN(PECOFF_SEGMENT_ALIGN); 54 54 _etext = .; 55 55 56 - /* 57 - * struct alt_inst entries. From the header (alternative.h): 58 - * "Alternative instructions for different CPU types or capabilities" 59 - * Think locking instructions on spinlocks. 60 - */ 61 - . = ALIGN(4); 62 - .altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) { 63 - __alt_instructions = .; 64 - *(.altinstructions) 65 - __alt_instructions_end = .; 66 - } 67 - 68 - #ifdef CONFIG_RELOCATABLE 69 - . = ALIGN(8); 70 - .la_abs : AT(ADDR(.la_abs) - LOAD_OFFSET) { 71 - __la_abs_begin = .; 72 - *(.la_abs) 73 - __la_abs_end = .; 74 - } 75 - #endif 76 - 77 - .got : ALIGN(16) { *(.got) } 78 - .plt : ALIGN(16) { *(.plt) } 79 - .got.plt : ALIGN(16) { *(.got.plt) } 80 - 81 - .data.rel : { *(.data.rel*) } 82 - 83 56 . = ALIGN(PECOFF_SEGMENT_ALIGN); 84 57 __init_begin = .; 85 58 __inittext_begin = .; ··· 66 93 __inittext_end = .; 67 94 68 95 __initdata_begin = .; 96 + 97 + /* 98 + * struct alt_inst entries. From the header (alternative.h): 99 + * "Alternative instructions for different CPU types or capabilities" 100 + * Think locking instructions on spinlocks. 101 + */ 102 + . = ALIGN(4); 103 + .altinstructions : AT(ADDR(.altinstructions) - LOAD_OFFSET) { 104 + __alt_instructions = .; 105 + *(.altinstructions) 106 + __alt_instructions_end = .; 107 + } 69 108 70 109 INIT_DATA_SECTION(16) 71 110 .exit.data : { ··· 98 113 99 114 _sdata = .; 100 115 RO_DATA(4096) 116 + 117 + .got : ALIGN(16) { *(.got) } 118 + .plt : ALIGN(16) { *(.plt) } 119 + .got.plt : ALIGN(16) { *(.got.plt) } 120 + 101 121 RW_DATA(1 << CONFIG_L1_CACHE_SHIFT, PAGE_SIZE, THREAD_SIZE) 102 122 103 123 .rela.dyn : ALIGN(8) { ··· 110 120 *(.rela.dyn) *(.rela*) 111 121 __rela_dyn_end = .; 112 122 } 123 + 124 + .data.rel : { *(.data.rel*) } 125 + 126 + #ifdef CONFIG_RELOCATABLE 127 + . = ALIGN(8); 128 + .la_abs : AT(ADDR(.la_abs) - LOAD_OFFSET) { 129 + __la_abs_begin = .; 130 + *(.la_abs) 131 + __la_abs_end = .; 132 + } 133 + #endif 113 134 114 135 .sdata : { 115 136 *(.sdata)
+1 -1
arch/loongarch/mm/fault.c
··· 20 20 #include <linux/mm.h> 21 21 #include <linux/smp.h> 22 22 #include <linux/kdebug.h> 23 - #include <linux/kprobes.h> 24 23 #include <linux/perf_event.h> 25 24 #include <linux/uaccess.h> 26 25 #include <linux/kfence.h> 27 26 28 27 #include <asm/branch.h> 28 + #include <asm/exception.h> 29 29 #include <asm/mmu_context.h> 30 30 #include <asm/ptrace.h> 31 31
-12
arch/loongarch/mm/hugetlbpage.c
··· 50 50 return (pte_t *) pmd; 51 51 } 52 52 53 - /* 54 - * This function checks for proper alignment of input addr and len parameters. 55 - */ 56 - int is_aligned_hugepage_range(unsigned long addr, unsigned long len) 57 - { 58 - if (len & ~HPAGE_MASK) 59 - return -EINVAL; 60 - if (addr & ~HPAGE_MASK) 61 - return -EINVAL; 62 - return 0; 63 - } 64 - 65 53 int pmd_huge(pmd_t pmd) 66 54 { 67 55 return (pmd_val(pmd) & _PAGE_HUGE) != 0;
+1
arch/loongarch/mm/ioremap.c
··· 4 4 */ 5 5 6 6 #include <asm/io.h> 7 + #include <asm-generic/early_ioremap.h> 7 8 8 9 void __init __iomem *early_ioremap(u64 phys_addr, unsigned long size) 9 10 {
+51
arch/loongarch/mm/kasan_init.c
··· 35 35 36 36 bool kasan_early_stage = true; 37 37 38 + void *kasan_mem_to_shadow(const void *addr) 39 + { 40 + if (!kasan_arch_is_ready()) { 41 + return (void *)(kasan_early_shadow_page); 42 + } else { 43 + unsigned long maddr = (unsigned long)addr; 44 + unsigned long xrange = (maddr >> XRANGE_SHIFT) & 0xffff; 45 + unsigned long offset = 0; 46 + 47 + maddr &= XRANGE_SHADOW_MASK; 48 + switch (xrange) { 49 + case XKPRANGE_CC_SEG: 50 + offset = XKPRANGE_CC_SHADOW_OFFSET; 51 + break; 52 + case XKPRANGE_UC_SEG: 53 + offset = XKPRANGE_UC_SHADOW_OFFSET; 54 + break; 55 + case XKVRANGE_VC_SEG: 56 + offset = XKVRANGE_VC_SHADOW_OFFSET; 57 + break; 58 + default: 59 + WARN_ON(1); 60 + return NULL; 61 + } 62 + 63 + return (void *)((maddr >> KASAN_SHADOW_SCALE_SHIFT) + offset); 64 + } 65 + } 66 + 67 + const void *kasan_shadow_to_mem(const void *shadow_addr) 68 + { 69 + unsigned long addr = (unsigned long)shadow_addr; 70 + 71 + if (unlikely(addr > KASAN_SHADOW_END) || 72 + unlikely(addr < KASAN_SHADOW_START)) { 73 + WARN_ON(1); 74 + return NULL; 75 + } 76 + 77 + if (addr >= XKVRANGE_VC_SHADOW_OFFSET) 78 + return (void *)(((addr - XKVRANGE_VC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKVRANGE_VC_START); 79 + else if (addr >= XKPRANGE_UC_SHADOW_OFFSET) 80 + return (void *)(((addr - XKPRANGE_UC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_UC_START); 81 + else if (addr >= XKPRANGE_CC_SHADOW_OFFSET) 82 + return (void *)(((addr - XKPRANGE_CC_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT) + XKPRANGE_CC_START); 83 + else { 84 + WARN_ON(1); 85 + return NULL; 86 + } 87 + } 88 + 38 89 /* 39 90 * Alloc memory for shadow memory page table. 40 91 */
+1 -1
arch/loongarch/mm/tlb.c
··· 261 261 #endif 262 262 extern long exception_handlers[VECSIZE * 128 / sizeof(long)]; 263 263 264 - void setup_tlb_handler(int cpu) 264 + static void setup_tlb_handler(int cpu) 265 265 { 266 266 setup_ptwalker(); 267 267 local_flush_tlb_all();
+1 -1
include/linux/kasan.h
··· 54 54 int kasan_populate_early_shadow(const void *shadow_start, 55 55 const void *shadow_end); 56 56 57 - #ifndef __HAVE_ARCH_SHADOW_MAP 57 + #ifndef kasan_mem_to_shadow 58 58 static inline void *kasan_mem_to_shadow(const void *addr) 59 59 { 60 60 return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)
+3 -5
mm/kasan/kasan.h
··· 291 291 292 292 #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS) 293 293 294 - #ifndef __HAVE_ARCH_SHADOW_MAP 294 + #ifndef kasan_shadow_to_mem 295 295 static inline const void *kasan_shadow_to_mem(const void *shadow_addr) 296 296 { 297 297 return (void *)(((unsigned long)shadow_addr - KASAN_SHADOW_OFFSET) ··· 299 299 } 300 300 #endif 301 301 302 + #ifndef addr_has_metadata 302 303 static __always_inline bool addr_has_metadata(const void *addr) 303 304 { 304 - #ifdef __HAVE_ARCH_SHADOW_MAP 305 - return (kasan_mem_to_shadow((void *)addr) != NULL); 306 - #else 307 305 return (kasan_reset_tag(addr) >= 308 306 kasan_shadow_to_mem((void *)KASAN_SHADOW_START)); 309 - #endif 310 307 } 308 + #endif 311 309 312 310 /** 313 311 * kasan_check_range - Check memory region, and report if invalid access.