Support strict kernel memory permissions for security
v3 cover Support strict kernel memory permissions for security
The main purpose of this patch series is changing the kernel mapping permission , make sure that code is not writeable, data is not executable, and read-only data is neither writable nor executable.
This patch series also supports the relevant implementations such as ARCH_HAS_SET_MEMORY, ARCH_HAS_SET_DIRECT_MAP, ARCH_SUPPORTS_DEBUG_PAGEALLOC and DEBUG_WX.
Changes in v3:
- Fix build error on nommu configuration. We already support nommu on RISC-V, so we should consider nommu case and test not only rv32/64, but also nommu.
Changes in v2:
- Use _data to specify the start of data section with write permission.
- Change ftrace patch text implementaion.
- Separate DEBUG_WX patch to another patchset.
Zong Li (9):
riscv: add ARCH_HAS_SET_MEMORY support
riscv: add ARCH_HAS_SET_DIRECT_MAP support
riscv: add ARCH_SUPPORTS_DEBUG_PAGEALLOC support
riscv: move exception table immediately after RO_DATA
riscv: add alignment for text, rodata and data sections
riscv: add STRICT_KERNEL_RWX support
riscv: add macro to get instruction length
riscv: introduce interfaces to patch kernel code
riscv: patch code by fixmap mapping
arch/riscv/Kconfig | 6 + arch/riscv/include/asm/bug.h | 8 ++ arch/riscv/include/asm/fixmap.h | 2 + arch/riscv/include/asm/patch.h | 12 ++ arch/riscv/include/asm/set_memory.h | 48 +++++++ arch/riscv/kernel/Makefile | 4 +- arch/riscv/kernel/ftrace.c | 13 +- arch/riscv/kernel/patch.c | 120 ++++++++++++++++++ arch/riscv/kernel/traps.c | 3 +- arch/riscv/kernel/vmlinux.lds.S | 11 +- arch/riscv/mm/Makefile | 2 +- arch/riscv/mm/init.c | 44 +++++++ arch/riscv/mm/pageattr.c | 187 ++++++++++++++++++++++++++++ 13 files changed, 445 insertions(+), 15 deletions(-) create mode 100644 arch/riscv/include/asm/patch.h create mode 100644 arch/riscv/include/asm/set_memory.h create mode 100644 arch/riscv/kernel/patch.c create mode 100644 arch/riscv/mm/pageattr.c
Signature · 1 line
2.25.1
PATCH v3 1/9 riscv: add ARCH_HAS_SET_MEMORY support
Add set_memory_ro/rw/x/nx architecture hooks to change the page attribution.
Use own set_memory.h rather than generic set_memory.h (i.e. include/asm-generic/set_memory.h), because we want to add other function prototypes here.
--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/set_memory.h | 24 +++++ arch/riscv/mm/Makefile | 2 +- arch/riscv/mm/pageattr.c | 150 ++++++++++++++++++++++++++++ 4 files changed, 176 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/include/asm/set_memory.h create mode 100644 arch/riscv/mm/pageattr.c
arch/riscv/Kconfig +1 -0
@@ -60,6 +60,7 @@ config RISCV select HAVE_EBPF_JIT if 64BIT select EDAC_SUPPORT select ARCH_HAS_GIGANTIC_PAGE + select ARCH_HAS_SET_MEMORY select ARCH_WANT_HUGE_PMD_SHARE if 64BIT select SPARSEMEM_STATIC if 32BIT select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU
arch/riscv/include/asm/set_memory.h new file +24 -0
@@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2019 SiFive +*/ + +#ifndef _ASM_RISCV_SET_MEMORY_H +#define _ASM_RISCV_SET_MEMORY_H + +/* +* Functions to change memory attributes. +*/ +#ifdef CONFIG_MMU +int set_memory_ro (unsigned long addr,int numpages); +int set_memory_rw (unsigned long addr,int numpages); +int set_memory_x (unsigned long addr,int numpages); +int set_memory_nx (unsigned long addr,int numpages); +#else +static inline int set_memory_ro (unsigned long addr,int numpages) {return 0 ; } +static inline int set_memory_rw (unsigned long addr,int numpages) {return 0 ; } +static inline int set_memory_x (unsigned long addr,int numpages) {return 0 ; } +static inline int set_memory_nx (unsigned long addr,int numpages) {return 0 ; } +#endif + +#endif /* _ASM_RISCV_SET_MEMORY_H */
arch/riscv/mm/Makefile +1 -1
@@ -7,7 +7,7 @@ endif obj-y += init.o obj-y += extable.o -obj-$(CONFIG_MMU) += fault.o +obj-$(CONFIG_MMU) += fault.o pageattr.o obj-y += cacheflush.o obj-y += context.o
arch/riscv/mm/pageattr.c new file +150 -0
150 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v3 2/9 riscv: add ARCH_HAS_SET_DIRECT_MAP support
In reply to Zong LiAdd set_direct_map_*() functions for setting the direct map alias for the page to its default permissions and to an invalid state that cannot be cached in a TLB. (See d253ca0c ("x86/mm/cpa: Add set_direct_map_*() functions")) Add a similar implementation for RISC-V.
--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/set_memory.h | 3 +++ arch/riscv/mm/pageattr.c | 24 ++++++++++++++++++++++++ 3 files changed, 28 insertions(+)
arch/riscv/Kconfig +1 -0
@@ -60,6 +60,7 @@ config RISCV select HAVE_EBPF_JIT if 64BIT select EDAC_SUPPORT select ARCH_HAS_GIGANTIC_PAGE + select ARCH_HAS_SET_DIRECT_MAP select ARCH_HAS_SET_MEMORY select ARCH_WANT_HUGE_PMD_SHARE if 64BIT select SPARSEMEM_STATIC if 32BIT
arch/riscv/include/asm/set_memory.h +3 -0
@@ -21,4 +21,7 @@ static inline int set_memory_x(unsigned long addr, int numpages) { return 0; }static inline int set_memory_nx (unsigned long addr,int numpages) {return 0 ; }#endif +int set_direct_map_invalid_noflush (struct page *page); +int set_direct_map_default_noflush (struct page *page); +#endif /* _ASM_RISCV_SET_MEMORY_H */
arch/riscv/mm/pageattr.c +24 -0
@@ -148,3 +148,27 @@ int set_memory_nx(unsigned long addr, int numpages) {return __set_memory (addr, numpages,__pgprot (0 ),__pgprot (_PAGE_EXEC)); } + +int set_direct_map_invalid_noflush (struct page *page) +{ +unsigned long start = (unsigned long )page_address (page); +unsigned long end = start +PAGE_SIZE ; +struct pageattr_masks masks = { + .set_mask =__pgprot (0 ), + .clear_mask =__pgprot (_PAGE_PRESENT) + }; + +return walk_page_range (&init_mm, start, end, &pageattr_ops, &masks); +} + +int set_direct_map_default_noflush (struct page *page) +{ +unsigned long start = (unsigned long )page_address (page); +unsigned long end = start +PAGE_SIZE ; +struct pageattr_masks masks = { + .set_mask =PAGE_KERNEL , + .clear_mask =__pgprot (0 ) + }; + +return walk_page_range (&init_mm, start, end, &pageattr_ops, &masks); +}
Signature · 1 line
2.25.1
PATCH v3 3/9 riscv: add ARCH_SUPPORTS_DEBUG_PAGEALLOC support
In reply to Zong LiARCH_SUPPORTS_DEBUG_PAGEALLOC provides a hook to map and unmap pages for debugging purposes. Implement the __kernel_map_pages functions to fill the poison pattern.
--- arch/riscv/Kconfig | 3 +++ arch/riscv/mm/pageattr.c | 13 +++++++++++++ 2 files changed, 16 insertions(+)
arch/riscv/Kconfig +3 -0
@@ -133,6 +133,9 @@ config ARCH_SELECT_MEMORY_MODEL config ARCH_WANT_GENERAL_HUGETLB def_bool y +config ARCH_SUPPORTS_DEBUG_PAGEALLOC + def_bool y + config SYS_SUPPORTS_HUGETLBFS def_bool y
arch/riscv/mm/pageattr.c +13 -0
@@ -172,3 +172,16 @@ int set_direct_map_default_noflush(struct page *page)return walk_page_range (&init_mm, start, end, &pageattr_ops, &masks); } + +void __kernel_map_pages (struct page *page,int numpages,int enable) +{ +if (!debug_pagealloc_enabled ()) +return ; + +if (enable) +__set_memory ((unsigned long )page_address (page), numpages, +__pgprot (_PAGE_PRESENT),__pgprot (0 )); +else +__set_memory ((unsigned long )page_address (page), numpages, +__pgprot (0 ),__pgprot (_PAGE_PRESENT)); +}
Signature · 1 line
2.25.1
PATCH v3 4/9 riscv: move exception table immediately after RO_DATA
In reply to Zong LiMove EXCEPTION_TABLE immediately after RO_DATA. Make it easy to set the attribution of the sections which should be read-only at a time. Add _data to specify the start of data section with write permission. This patch is prepared for STRICT_KERNEL_RWX support.
--- arch/riscv/kernel/vmlinux.lds.S | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
arch/riscv/kernel/vmlinux.lds.S +4 -2
@@ -58,6 +58,10 @@ SECTIONS *(.srodata*) } + EXCEPTION_TABLE(0x10) + + _data = .; + RW_DATA(L1_CACHE_BYTES, PAGE_SIZE, THREAD_SIZE) .sdata : { __global_pointer$ = . + 0x800;
@@ -69,8 +73,6 @@ SECTIONS BSS_SECTION(PAGE_SIZE, PAGE_SIZE, 0) - EXCEPTION_TABLE(0x10) - .rel.dyn : { *(.rel.dyn*) }
Signature · 1 line
2.25.1
PATCH v3 5/9 riscv: add alignment for text, rodata and data sections
In reply to Zong LiThe kernel mapping will tried to optimize its mapping by using bigger size. In rv64, it tries to use PMD_SIZE, and tryies to use PGDIR_SIZE in rv32. To ensure that the start address of these sections could fit the mapping entry size, make them align to the biggest alignment.
Define a macro SECTION_ALIGN because the HPAGE_SIZE or PMD_SIZE, etc., are invisible in linker script.
This patch is prepared for STRICT_KERNEL_RWX support.
--- arch/riscv/include/asm/set_memory.h | 13 +++++++++++++ arch/riscv/kernel/vmlinux.lds.S | 5 ++++- 2 files changed, 17 insertions(+), 1 deletion(-)
arch/riscv/include/asm/set_memory.h +13 -0
@@ -6,6 +6,7 @@#ifndef _ASM_RISCV_SET_MEMORY_H#define _ASM_RISCV_SET_MEMORY_H +#ifndef __ASSEMBLY__/* * Functions to change memory attributes. */
@@ -24,4 +25,16 @@ static inline int set_memory_nx(unsigned long addr, int numpages) { return 0; }int set_direct_map_invalid_noflush (struct page *page);int set_direct_map_default_noflush (struct page *page); +#endif /* __ASSEMBLY__ */ + +#ifdef CONFIG_ARCH_HAS_STRICT_KERNEL_RWX +#ifdef CONFIG_64BIT +#define SECTION_ALIGN (1 << 21) +#else +#define SECTION_ALIGN (1 << 22) +#endif +#else /* !CONFIG_ARCH_HAS_STRICT_KERNEL_RWX */ +#define SECTION_ALIGN L1_CACHE_BYTES +#endif /* CONFIG_ARCH_HAS_STRICT_KERNEL_RWX */ +#endif /* _ASM_RISCV_SET_MEMORY_H */
arch/riscv/kernel/vmlinux.lds.S +4 -1
@@ -9,6 +9,7 @@ #include <asm/page.h> #include <asm/cache.h> #include <asm/thread_info.h> +#include <asm/set_memory.h> OUTPUT_ARCH(riscv) ENTRY(_start)
@@ -36,6 +37,7 @@ SECTIONS PERCPU_SECTION(L1_CACHE_BYTES) __init_end = .; + . = ALIGN(SECTION_ALIGN); .text : { _text = .; _stext = .;
@@ -53,13 +55,14 @@ SECTIONS /* Start of data section */ _sdata = .; - RO_DATA(L1_CACHE_BYTES) + RO_DATA(SECTION_ALIGN) .srodata : { *(.srodata*) } EXCEPTION_TABLE(0x10) + . = ALIGN(SECTION_ALIGN); _data = .; RW_DATA(L1_CACHE_BYTES, PAGE_SIZE, THREAD_SIZE)
Signature · 1 line
2.25.1
PATCH v3 7/9 riscv: add macro to get instruction length
In reply to Zong LiExtract the calculation of instruction length for common use.
--- arch/riscv/include/asm/bug.h | 8 ++++++++ arch/riscv/kernel/traps.c | 3 ++- 2 files changed, 10 insertions(+), 1 deletion(-)
arch/riscv/include/asm/bug.h +8 -0
@@ -19,6 +19,14 @@#define __BUG_INSN_32 _UL(0x00100073)/* ebreak */ #define __BUG_INSN_16 _UL(0x9002)/* c.ebreak */ +#define GET_INSN_LENGTH (insn) \ +({ \ + unsigned long __len; \ + __len = ((insn & __INSN_LENGTH_MASK) == __INSN_LENGTH_32) ? \ + 4UL : 2UL; \ + __len; \ +}) +typedef u32 bug_insn_t ;#ifdef CONFIG_GENERIC_BUG_RELATIVE_POINTERS
arch/riscv/kernel/traps.c +2 -1
@@ -118,7 +118,8 @@ static inline unsigned long get_break_insn_length(unsigned long pc)if (probe_kernel_address ((bug_insn_t *)pc, insn))return 0 ; -return (((insn & __INSN_LENGTH_MASK) == __INSN_LENGTH_32) ?4UL :2UL ); + +return GET_INSN_LENGTH (insn); } asmlinkage __visible void do_trap_break(struct pt_regs *regs)
Signature · 1 line
2.25.1
PATCH v3 6/9 riscv: add STRICT_KERNEL_RWX support
In reply to Zong LiThe commit contains that make text section as non-writable, rodata section as read-only, and data section as non-executable.
The init section should be changed to non-executable.
--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/set_memory.h | 8 ++++++ arch/riscv/mm/init.c | 44 +++++++++++++++++++++++++++++ 3 files changed, 53 insertions(+)
arch/riscv/Kconfig +1 -0
@@ -62,6 +62,7 @@ config RISCV select ARCH_HAS_GIGANTIC_PAGE select ARCH_HAS_SET_DIRECT_MAP select ARCH_HAS_SET_MEMORY + select ARCH_HAS_STRICT_KERNEL_RWX select ARCH_WANT_HUGE_PMD_SHARE if 64BIT select SPARSEMEM_STATIC if 32BIT select ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT if MMU
arch/riscv/include/asm/set_memory.h +8 -0
@@ -22,6 +22,14 @@ static inline int set_memory_x(unsigned long addr, int numpages) { return 0; }static inline int set_memory_nx (unsigned long addr,int numpages) {return 0 ; }#endif +#ifdef CONFIG_STRICT_KERNEL_RWX +void set_kernel_text_ro (void ); +void set_kernel_text_rw (void ); +#else +static inline void set_kernel_text_ro (void ) { } +static inline void set_kernel_text_rw (void ) { } +#endif +int set_direct_map_invalid_noflush (struct page *page);int set_direct_map_default_noflush (struct page *page);
arch/riscv/mm/init.c +44 -0
62 lines not on this page · raw message
Signature · 1 line
2.25.1
PATCH v3 9/9 riscv: patch code by fixmap mapping
In reply to Zong LiOn strict kernel memory permission, the ftrace have to change the permission of text for dynamic patching the intructions. Use riscv_patch_text_nosync() to patch code instead of probe_kernel_write.
--- arch/riscv/kernel/ftrace.c | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-)
arch/riscv/kernel/ftrace.c +4 -9
@@ -8,6 +8,7 @@#include <linux/ftrace.h> #include <linux/uaccess.h> #include <asm/cacheflush.h> +#include <asm/patch.h> #ifdef CONFIG_DYNAMIC_FTRACE static int ftrace_check_current_call(unsigned long hook_pos,
@@ -46,20 +47,14 @@ static int __ftrace_modify_call(unsigned long hook_pos, unsigned long target, {unsigned int call[2 ];unsigned int nops[2 ] = {NOP4 ,NOP4 }; -int ret =0 ;make_call (hook_pos, target, call); -/* replace the auipc-jalr pair at once */ - ret =probe_kernel_write ((void *)hook_pos, enable ? call : nops, -MCOUNT_INSN_SIZE ); -/* return must be -EPERM on write error */ -if (ret) +/* Replace the auipc-jalr pair at once. Return -EPERM on write error. */ +if (riscv_patch_text_nosync + ((void *)hook_pos, enable ? call : nops,MCOUNT_INSN_SIZE ))return -EPERM ; -smp_mb (); -flush_icache_range ((void *)hook_pos, (void *)hook_pos +MCOUNT_INSN_SIZE ); -return 0 ; }
Signature · 1 line
2.25.1
PATCH v3 8/9 riscv: introduce interfaces to patch kernel code
In reply to Zong LiOn strict kernel memory permission, we couldn't patch code without writable permission. Preserve two holes in fixmap area, so we can map the kernel code temporarily to fixmap area, then patch the instructions.
We need two pages here because we support the compressed instruction, so the instruction might be align to 2 bytes. When patching the 32-bit length instruction which is 2 bytes alignment, it will across two pages.
Introduce two interfaces to patch kernel code:riscv_patch_text_nosync:
- patch code without synchronization, it's caller's responsibility to synchronize all CPUs if needed.riscv_patch_text:
- patch code and always synchronize with stop_machine()
--- arch/riscv/include/asm/fixmap.h | 2 + arch/riscv/include/asm/patch.h | 12 ++++ arch/riscv/kernel/Makefile | 4 +- arch/riscv/kernel/patch.c | 120 ++++++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/include/asm/patch.h create mode 100644 arch/riscv/kernel/patch.c
arch/riscv/include/asm/fixmap.h +2 -0
@@ -27,6 +27,8 @@ enum fixed_addresses {FIX_FDT =FIX_FDT_END +FIX_FDT_SIZE /PAGE_SIZE -1 ,FIX_PTE ,FIX_PMD , +FIX_TEXT_POKE1 , +FIX_TEXT_POKE0 ,FIX_EARLYCON_MEM_BASE , __end_of_fixed_addresses };
arch/riscv/include/asm/patch.h new file +12 -0
@@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2020 SiFive +*/ + +#ifndef _ASM_RISCV_PATCH_H +#define _ASM_RISCV_PATCH_H + +int riscv_patch_text_nosync (void *addr,const void *insns,size_t len); +int riscv_patch_text (void *addr,u32 insn); + +#endif /* _ASM_RISCV_PATCH_H */
arch/riscv/kernel/Makefile +3 -1
@@ -4,7 +4,8 @@ # ifdef CONFIG_FTRACE -CFLAGS_REMOVE_ftrace.o = -pg +CFLAGS_REMOVE_ftrace.o = -pg +CFLAGS_REMOVE_patch.o = -pg endif extra-y += head.o
@@ -26,6 +27,7 @@ obj-y += traps.o obj-y += riscv_ksyms.o obj-y += stacktrace.o obj-y += cacheinfo.o +obj-y += patch.o obj-$(CONFIG_MMU) += vdso.o vdso/ obj-$(CONFIG_RISCV_M_MODE) += clint.o
arch/riscv/kernel/patch.c new file +120 -0
120 lines not on this page · raw message
Signature · 1 line
2.25.1
Masami Hiramatsu
maintainerHi Zong,
Quoted 7 lines · On Tue, 10 Mar 2020 00:55:35 +0800 Zong Li <[email protected]> wrote:
The main purpose of this patch series is changing the kernel mapping permission , make sure that code is not writeable, data is not executable, and read-only data is neither writable nor executable.
This patch series also supports the relevant implementations such as
ARCH_HAS_SET_MEMORY,ARCH_HAS_SET_DIRECT_MAP,ARCH_SUPPORTS_DEBUG_PAGEALLOCandDEBUG_WX.
The order of the patches seems a bit strange. Since the first 7 patches makes kernel read-only, at that point ftrace is broken and it is fixed by the last 2 patches. That is not bisect-friendly. Can you move the last 2 patches to the top?
Thank you,
Quoted 44 lines
Changes in v3:
- Fix build error on nommu configuration. We already support nommu on RISC-V, so we should consider nommu case and test not only rv32/64, but also nommu.Changes in v2:
- Use_datato specify the start of data section with write permission.
- Change ftrace patch text implementaion.
- SeparateDEBUG_WXpatch to another patchset.Zong Li (9):
riscv: addARCH_HAS_SET_MEMORYsupport
riscv: addARCH_HAS_SET_DIRECT_MAPsupport
riscv: addARCH_SUPPORTS_DEBUG_PAGEALLOCsupport
riscv: move exception table immediately afterRO_DATA
riscv: add alignment for text, rodata and data sections
riscv: addSTRICT_KERNEL_RWXsupport
riscv: add macro to get instruction length
riscv: introduce interfaces to patch kernel code
riscv: patch code by fixmap mappingarch/riscv/Kconfig | 6 + arch/riscv/include/asm/bug.h | 8 ++ arch/riscv/include/asm/fixmap.h | 2 + arch/riscv/include/asm/patch.h | 12 ++ arch/riscv/include/asm/set_memory.h | 48 +++++++ arch/riscv/kernel/Makefile | 4 +- arch/riscv/kernel/ftrace.c | 13 +- arch/riscv/kernel/patch.c | 120 ++++++++++++++++++ arch/riscv/kernel/traps.c | 3 +- arch/riscv/kernel/vmlinux.lds.S | 11 +- arch/riscv/mm/Makefile | 2 +- arch/riscv/mm/init.c | 44 +++++++ arch/riscv/mm/pageattr.c | 187 ++++++++++++++++++++++++++++ 13 files changed, 445 insertions(+), 15 deletions(-) create mode 100644 arch/riscv/include/asm/patch.h create mode 100644 arch/riscv/include/asm/set_memory.h create mode 100644 arch/riscv/kernel/patch.c create mode 100644 arch/riscv/mm/pageattr.cSignature · 1 line
2.25.1
Signature · 1 line
Masami Hiramatsu <[email protected]>
Masami Hiramatsu
maintainerRe: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
In reply to Zong LiHi,
Quoted 97 lines · On Tue, 10 Mar 2020 00:55:43 +0800 Zong Li <[email protected]> wrote:
On strict kernel memory permission, we couldn't patch code without writable permission. Preserve two holes in fixmap area, so we can map the kernel code temporarily to fixmap area, then patch the instructions.
We need two pages here because we support the compressed instruction, so the instruction might be align to 2 bytes. When patching the 32-bit length instruction which is 2 bytes alignment, it will across two pages.
Introduce two interfaces to patch kernel code:
riscv_patch_text_nosync:
- patch code without synchronization, it's caller's responsibility to synchronize all CPUs if needed.riscv_patch_text:
- patch code and always synchronize withstop_machine()Signed-off-by Zong Li <[email protected]>--- arch/riscv/include/asm/fixmap.h | 2 + arch/riscv/include/asm/patch.h | 12 ++++ arch/riscv/kernel/Makefile | 4 +- arch/riscv/kernel/patch.c | 120 ++++++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/include/asm/patch.h create mode 100644 arch/riscv/kernel/patch.carch/riscv/include/asm/fixmap.h +2
-0@@ -27,6 +27,8 @@ enum fixed_addresses {FIX_FDT =FIX_FDT_END +FIX_FDT_SIZE /PAGE_SIZE -1 ,FIX_PTE ,FIX_PMD , +FIX_TEXT_POKE1 , +FIX_TEXT_POKE0 ,FIX_EARLYCON_MEM_BASE , __end_of_fixed_addresses };arch/riscv/include/asm/patch.h new file +12
-0@@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2020 SiFive +*/ + +#ifndef _ASM_RISCV_PATCH_H +#define _ASM_RISCV_PATCH_H + +int riscv_patch_text_nosync (void *addr,const void *insns,size_t len); +int riscv_patch_text (void *addr,u32 insn); + +#endif /* _ASM_RISCV_PATCH_H */ arch/riscv/kernel/Makefile +3
-1@@ -4,7 +4,8 @@ # ifdef CONFIG_FTRACE -CFLAGS_REMOVE_ftrace.o = -pg +CFLAGS_REMOVE_ftrace.o = -pg +CFLAGS_REMOVE_patch.o = -pg endif extra-y += head.o@@ -26,6 +27,7 @@ obj-y += traps.o obj-y += riscv_ksyms.o obj-y += stacktrace.o obj-y += cacheinfo.o +obj-y += patch.o obj-$(CONFIG_MMU) += vdso.o vdso/ obj-$(CONFIG_RISCV_M_MODE) += clint.oarch/riscv/kernel/patch.c new file +13
-0@@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Copyright (C) 2020 SiFive +*/ + +#include <linux/spinlock.h> +#include <linux/mm.h> +#include <linux/uaccess.h> +#include <linux/stop_machine.h> +#include <asm/kprobes.h> +#include <asm/cacheflush.h> +#include <asm/fixmap.h> +
arch/riscv/kernel/patch.c line 23
Quoted 10 lines
arch/riscv/kernel/patch.c new file +10
-0+struct riscv_insn_patch { +void *addr; +u32 insn; +atomic_t cpu_count; +}; + +#ifdef CONFIG_MMU +static DEFINE_RAW_SPINLOCK (patch_lock); + +static void __kprobes *patch_map (void *addr,int fixmap)
Please use NOKPROBE_SYMBOL() instead of __kprobes. __kprobes is old style.
Quoted 13 lines
arch/riscv/kernel/patch.c new file +13
-0+{ +uintptr_t uintaddr = (uintptr_t ) addr; +struct page *page; + +if (core_kernel_text (uintaddr)) + page =phys_to_page (__pa_symbol (addr)); +else if (IS_ENABLED (CONFIG_STRICT_MODULE_RWX )) + page =vmalloc_to_page (addr); +else +return addr; + +BUG_ON (!page); +
arch/riscv/kernel/patch.c line 46
Quoted 10 lines
arch/riscv/kernel/patch.c new file +10
-0+return (void *)set_fixmap_offset (fixmap,page_to_phys (page) + + (uintaddr & ~PAGE_MASK )); +} + +static void __kprobes patch_unmap (int fixmap) +{ +clear_fixmap (fixmap); +} + +static int __kprobes riscv_insn_write (void *addr,const void *insn,size_t len)
Why would you add "riscv_" prefix for those functions? It seems a bit odd.
arch/riscv/kernel/patch.c line 53
Quoted 7 lines
arch/riscv/kernel/patch.c new file +7
-0+{ +void *waddr = addr; +bool across_pages = (((uintptr_t ) addr & ~PAGE_MASK ) + len) >PAGE_SIZE ; +unsigned long flags =0 ; +int ret; + +raw_spin_lock_irqsave (&patch_lock, flags);
This looks a bit odd since stop_machine() is protected by its own mutex, and also the irq is already disabled here.
Thank you,
Quoted 70 lines
arch/riscv/kernel/patch.c new file +67
-0+ +if (across_pages) +patch_map (addr + len,FIX_TEXT_POKE1 ); + + waddr =patch_map (addr,FIX_TEXT_POKE0 ); + + ret =probe_kernel_write (waddr, insn, len); + +patch_unmap (FIX_TEXT_POKE0 ); + +if (across_pages) +patch_unmap (FIX_TEXT_POKE1 ); + +raw_spin_unlock_irqrestore (&patch_lock, flags); + +return ret; +} +#else +static int __kprobes riscv_insn_write (void *addr,const void *insn,size_t len) +{ +return probe_kernel_write (addr, insn, len); +} +#endif /* CONFIG_MMU */ + +int __kprobes riscv_patch_text_nosync (void *addr,const void *insns,size_t len) +{ +u32 *tp = addr; +int ret; + + ret =riscv_insn_write (tp, insns, len); + +if (!ret) +flush_icache_range ((uintptr_t ) tp, (uintptr_t ) tp + len); + +return ret; +} + +static int __kprobes riscv_patch_text_cb (void *data) +{ +struct riscv_insn_patch *patch = data; +int ret =0 ; + +if (atomic_inc_return (&patch->cpu_count) ==1 ) { + ret = +riscv_patch_text_nosync (patch->addr, &patch->insn, +GET_INSN_LENGTH (patch->insn)); +atomic_inc (&patch->cpu_count); + }else { +while (atomic_read (&patch->cpu_count) <=num_online_cpus ()) +cpu_relax (); +smp_mb (); + } + +return ret; +} + +int __kprobes riscv_patch_text (void *addr,u32 insn) +{ +struct riscv_insn_patch patch = { + .addr = addr, + .insn = insn, + .cpu_count =ATOMIC_INIT (0 ), + }; + +return stop_machine_cpuslocked (riscv_patch_text_cb, + &patch, cpu_online_mask); +}Signature · 1 line
2.25.1
Signature · 1 line
Masami Hiramatsu <[email protected]>
Quoted 10 lines · Masami Hiramatsu
Hi Zong,
Quoted 4 lines · On Tue, 10 Mar 2020 00:55:35 +0800 Zong Li <[email protected]> wrote:
The main purpose of this patch series is changing the kernel mapping permission , make sure that code is not writeable, data is not executable, and read-only data is neither writable nor executable.
Quoted 9 lines
Quoted 3 lines
This patch series also supports the relevant implementations such as
ARCH_HAS_SET_MEMORY,ARCH_HAS_SET_DIRECT_MAP,ARCH_SUPPORTS_DEBUG_PAGEALLOCandDEBUG_WX.The order of the patches seems a bit strange. Since the first 7 patches makes kernel read-only, at that point ftrace is broken and it is fixed by the last 2 patches. That is not bisect-friendly. Can you move the last 2 patches to the top?
OK. Let me rearrange the order. Thanks.
Quoted 50 lines
Thank you,
Quoted 41 lines
Changes in v3:
- Fix build error on nommu configuration. We already support nommu on RISC-V, so we should consider nommu case and test not only rv32/64, but also nommu.Changes in v2:
- Use_datato specify the start of data section with write permission.
- Change ftrace patch text implementaion.
- SeparateDEBUG_WXpatch to another patchset.Zong Li (9):
riscv: addARCH_HAS_SET_MEMORYsupport
riscv: addARCH_HAS_SET_DIRECT_MAPsupport
riscv: addARCH_SUPPORTS_DEBUG_PAGEALLOCsupport
riscv: move exception table immediately afterRO_DATA
riscv: add alignment for text, rodata and data sections
riscv: addSTRICT_KERNEL_RWXsupport
riscv: add macro to get instruction length
riscv: introduce interfaces to patch kernel code
riscv: patch code by fixmap mappingarch/riscv/Kconfig | 6 + arch/riscv/include/asm/bug.h | 8 ++ arch/riscv/include/asm/fixmap.h | 2 + arch/riscv/include/asm/patch.h | 12 ++ arch/riscv/include/asm/set_memory.h | 48 +++++++ arch/riscv/kernel/Makefile | 4 +- arch/riscv/kernel/ftrace.c | 13 +- arch/riscv/kernel/patch.c | 120 ++++++++++++++++++ arch/riscv/kernel/traps.c | 3 +- arch/riscv/kernel/vmlinux.lds.S | 11 +- arch/riscv/mm/Makefile | 2 +- arch/riscv/mm/init.c | 44 +++++++ arch/riscv/mm/pageattr.c | 187 ++++++++++++++++++++++++++++ 13 files changed, 445 insertions(+), 15 deletions(-) create mode 100644 arch/riscv/include/asm/patch.h create mode 100644 arch/riscv/include/asm/set_memory.h create mode 100644 arch/riscv/kernel/patch.c create mode 100644 arch/riscv/mm/pageattr.cQuoted 3 lines
--
2.25.1--
Masami Hiramatsu <[email protected]>
Re: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
In reply to Masami HiramatsuQuoted 133 lines · Masami Hiramatsu
Hi,
Quoted 97 lines · On Tue, 10 Mar 2020 00:55:43 +0800 Zong Li <[email protected]> wrote:
On strict kernel memory permission, we couldn't patch code without writable permission. Preserve two holes in fixmap area, so we can map the kernel code temporarily to fixmap area, then patch the instructions.
We need two pages here because we support the compressed instruction, so the instruction might be align to 2 bytes. When patching the 32-bit length instruction which is 2 bytes alignment, it will across two pages.
Introduce two interfaces to patch kernel code:
riscv_patch_text_nosync:
- patch code without synchronization, it's caller's responsibility to synchronize all CPUs if needed.riscv_patch_text:
- patch code and always synchronize withstop_machine()Signed-off-by Zong Li <[email protected]>--- arch/riscv/include/asm/fixmap.h | 2 + arch/riscv/include/asm/patch.h | 12 ++++ arch/riscv/kernel/Makefile | 4 +- arch/riscv/kernel/patch.c | 120 ++++++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 arch/riscv/include/asm/patch.h create mode 100644 arch/riscv/kernel/patch.carch/riscv/include/asm/fixmap.h +2
-0@@ -27,6 +27,8 @@ enum fixed_addresses {FIX_FDT =FIX_FDT_END +FIX_FDT_SIZE /PAGE_SIZE -1 ,FIX_PTE ,FIX_PMD , +FIX_TEXT_POKE1 , +FIX_TEXT_POKE0 ,FIX_EARLYCON_MEM_BASE , __end_of_fixed_addresses };arch/riscv/include/asm/patch.h new file +12
-0@@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2020 SiFive +*/ + +#ifndef _ASM_RISCV_PATCH_H +#define _ASM_RISCV_PATCH_H + +int riscv_patch_text_nosync (void *addr,const void *insns,size_t len); +int riscv_patch_text (void *addr,u32 insn); + +#endif /* _ASM_RISCV_PATCH_H */ arch/riscv/kernel/Makefile +3
-1@@ -4,7 +4,8 @@ # ifdef CONFIG_FTRACE -CFLAGS_REMOVE_ftrace.o = -pg +CFLAGS_REMOVE_ftrace.o = -pg +CFLAGS_REMOVE_patch.o = -pg endif extra-y += head.o@@ -26,6 +27,7 @@ obj-y += traps.o obj-y += riscv_ksyms.o obj-y += stacktrace.o obj-y += cacheinfo.o +obj-y += patch.o obj-$(CONFIG_MMU) += vdso.o vdso/ obj-$(CONFIG_RISCV_M_MODE) += clint.oarch/riscv/kernel/patch.c new file +13
-0@@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Copyright (C) 2020 SiFive +*/ + +#include <linux/spinlock.h> +#include <linux/mm.h> +#include <linux/uaccess.h> +#include <linux/stop_machine.h> +#include <asm/kprobes.h> +#include <asm/cacheflush.h> +#include <asm/fixmap.h> +arch/riscv/kernel/patch.c line 23
Quoted 10 lines
arch/riscv/kernel/patch.c new file +10
-0+struct riscv_insn_patch { +void *addr; +u32 insn; +atomic_t cpu_count; +}; + +#ifdef CONFIG_MMU +static DEFINE_RAW_SPINLOCK (patch_lock); + +static void __kprobes *patch_map (void *addr,int fixmap)Please use
NOKPROBE_SYMBOL()instead of__kprobes.__kprobesis old style.Quoted 17 lines
arch/riscv/kernel/patch.c new file +17
-0+{ +uintptr_t uintaddr = (uintptr_t ) addr; +struct page *page; + +if (core_kernel_text (uintaddr)) + page =phys_to_page (__pa_symbol (addr)); +else if (IS_ENABLED (CONFIG_STRICT_MODULE_RWX )) + page =vmalloc_to_page (addr); +else +return addr; + +BUG_ON (!page); + +return (void *)set_fixmap_offset (fixmap,page_to_phys (page) + + (uintaddr & ~PAGE_MASK )); +} +
Quoted 8 lines
arch/riscv/kernel/patch.c line 46
Quoted 6 lines
arch/riscv/kernel/patch.c new file +6
-0+static void __kprobes patch_unmap (int fixmap) +{ +clear_fixmap (fixmap); +} + +static int __kprobes riscv_insn_write (void *addr,const void *insn,size_t len)Why would you add "
riscv_" prefix for those functions? It seems a bit odd.
There is no particular reason, I just was used to adding a prefix for arch-related stuff. I have no preference here, it's OK to me to remove the prefix of these functions, do you think we need to remove them?
Quoted 11 lines
arch/riscv/kernel/patch.c line 53
Quoted 8 lines
arch/riscv/kernel/patch.c new file +7
-0+{ +void *waddr = addr; +bool across_pages = (((uintptr_t ) addr & ~PAGE_MASK ) + len) >PAGE_SIZE ; +unsigned long flags =0 ; +int ret; + +raw_spin_lock_irqsave (&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.
We need it because we don't always enter the riscv_patch_text_nosync() through stop_machine mechanism. If we call the riscv_patch_text_nosync() directly, we need a lock to protect the page.
Quoted 77 lines
Thank you,
Quoted 68 lines
arch/riscv/kernel/patch.c new file +67
-1+ +if (across_pages) +patch_map (addr + len,FIX_TEXT_POKE1 ); + + waddr =patch_map (addr,FIX_TEXT_POKE0 ); + + ret =probe_kernel_write (waddr, insn, len); + +patch_unmap (FIX_TEXT_POKE0 ); + +if (across_pages) +patch_unmap (FIX_TEXT_POKE1 ); + +raw_spin_unlock_irqrestore (&patch_lock, flags); + +return ret; +} +#else +static int __kprobes riscv_insn_write (void *addr,const void *insn,size_t len) +{ +return probe_kernel_write (addr, insn, len); +} +#endif /* CONFIG_MMU */ + +int __kprobes riscv_patch_text_nosync (void *addr,const void *insns,size_t len) +{ +u32 *tp = addr; +int ret; + + ret =riscv_insn_write (tp, insns, len); + +if (!ret) +flush_icache_range ((uintptr_t ) tp, (uintptr_t ) tp + len); + +return ret; +} + +static int __kprobes riscv_patch_text_cb (void *data) +{ +struct riscv_insn_patch *patch = data; +int ret =0 ; + +if (atomic_inc_return (&patch->cpu_count) ==1 ) { + ret = +riscv_patch_text_nosync (patch->addr, &patch->insn, +GET_INSN_LENGTH (patch->insn)); +atomic_inc (&patch->cpu_count); + }else { +while (atomic_read (&patch->cpu_count) <=num_online_cpus ()) +cpu_relax (); +smp_mb (); + } + +return ret; +} + +int __kprobes riscv_patch_text (void *addr,u32 insn) +{ +struct riscv_insn_patch patch = { + .addr = addr, + .insn = insn, + .cpu_count =ATOMIC_INIT (0 ), + }; + +return stop_machine_cpuslocked (riscv_patch_text_cb, + &patch, cpu_online_mask); +} --Quoted 2 lines
2.25.1
--
Masami Hiramatsu <[email protected]>
Masami Hiramatsu
maintainerRe: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Hi,
Quoted 8 lines · On Wed, 1 Apr 2020 15:42:30 +0800 Zong Li <[email protected]> wrote:
Quoted 4 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ +static int __kprobes riscv_insn_write(void *addr, const void *insn, size_t len)Why would you add "
riscv_" prefix for those functions? It seems a bit odd.There is no particular reason, I just was used to adding a prefix for arch-related stuff. I have no preference here, it's OK to me to remove the prefix of these functions, do you think we need to remove them?
Yeah, it will be better, unless it can mixed up with arch-independent functions.
Quoted 11 lines
Quoted 10 lines
arch/riscv/kernel/patch.c line 53
Quoted 7 lines
arch/riscv/kernel/patch.c new file +7
-0+{ +void *waddr = addr; +bool across_pages = (((uintptr_t ) addr & ~PAGE_MASK ) + len) >PAGE_SIZE ; +unsigned long flags =0 ; +int ret; + +raw_spin_lock_irqsave (&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.
Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call _nosync()" and add a comment on it.
Thank you,
Quoted 78 lines
Quoted 78 lines
Thank you,
Quoted 68 lines
arch/riscv/kernel/patch.c new file +67
-1+ +if (across_pages) +patch_map (addr + len,FIX_TEXT_POKE1 ); + + waddr =patch_map (addr,FIX_TEXT_POKE0 ); + + ret =probe_kernel_write (waddr, insn, len); + +patch_unmap (FIX_TEXT_POKE0 ); + +if (across_pages) +patch_unmap (FIX_TEXT_POKE1 ); + +raw_spin_unlock_irqrestore (&patch_lock, flags); + +return ret; +} +#else +static int __kprobes riscv_insn_write (void *addr,const void *insn,size_t len) +{ +return probe_kernel_write (addr, insn, len); +} +#endif /* CONFIG_MMU */ + +int __kprobes riscv_patch_text_nosync (void *addr,const void *insns,size_t len) +{ +u32 *tp = addr; +int ret; + + ret =riscv_insn_write (tp, insns, len); + +if (!ret) +flush_icache_range ((uintptr_t ) tp, (uintptr_t ) tp + len); + +return ret; +} + +static int __kprobes riscv_patch_text_cb (void *data) +{ +struct riscv_insn_patch *patch = data; +int ret =0 ; + +if (atomic_inc_return (&patch->cpu_count) ==1 ) { + ret = +riscv_patch_text_nosync (patch->addr, &patch->insn, +GET_INSN_LENGTH (patch->insn)); +atomic_inc (&patch->cpu_count); + }else { +while (atomic_read (&patch->cpu_count) <=num_online_cpus ()) +cpu_relax (); +smp_mb (); + } + +return ret; +} + +int __kprobes riscv_patch_text (void *addr,u32 insn) +{ +struct riscv_insn_patch patch = { + .addr = addr, + .insn = insn, + .cpu_count =ATOMIC_INIT (0 ), + }; + +return stop_machine_cpuslocked (riscv_patch_text_cb, + &patch, cpu_online_mask); +} --Quoted 2 lines
2.25.1
--
Masami Hiramatsu <[email protected]>
Signature · 1 line
Masami Hiramatsu <[email protected]>
Re: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Quoted 11 lines · Masami Hiramatsu
Hi,
Quoted 5 lines · On Wed, 1 Apr 2020 15:42:30 +0800 Zong Li <[email protected]> wrote:
Quoted 4 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ +static int __kprobes riscv_insn_write(void *addr, const void *insn, size_t len)Why would you add "
riscv_" prefix for those functions? It seems a bit odd.
Quoted 6 lines
Quoted 3 lines
There is no particular reason, I just was used to adding a prefix for arch-related stuff. I have no preference here, it's OK to me to remove the prefix of these functions, do you think we need to remove them?
Yeah, it will be better, unless it can mixed up with arch-independent functions.
OK. I'll remove it and use NOKPROBE_SYMBOL() instead of __kprobes annotation.
Quoted 17 lines
Quoted 12 lines
Quoted 11 lines
arch/riscv/kernel/patch.c line 53
Quoted 8 lines
arch/riscv/kernel/patch.c new file +7
-0+{ +void *waddr = addr; +bool across_pages = (((uintptr_t ) addr & ~PAGE_MASK ) + len) >PAGE_SIZE ; +unsigned long flags =0 ; +int ret; + +raw_spin_lock_irqsave (&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.
Quoted 4 lines
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call_nosync()" and add a comment on it.
The ftrace is one of the cases, as documentation of ftrace said, when dynamic ftrace is initialized, it calls kstop_machine to make the machine act like a uniprocessor so that it can freely modify code without worrying about other processors executing that same code. So the ftrace called the _nosync interface here directly.
Quoted 85 lines
Thank you,
Quoted 70 lines
Quoted 70 lines
Thank you,
Quoted 66 lines
arch/riscv/kernel/patch.c new file +66
-0+ +if (across_pages) +patch_map (addr + len,FIX_TEXT_POKE1 ); + + waddr =patch_map (addr,FIX_TEXT_POKE0 ); + + ret =probe_kernel_write (waddr, insn, len); + +patch_unmap (FIX_TEXT_POKE0 ); + +if (across_pages) +patch_unmap (FIX_TEXT_POKE1 ); + +raw_spin_unlock_irqrestore (&patch_lock, flags); + +return ret; +} +#else +static int __kprobes riscv_insn_write (void *addr,const void *insn,size_t len) +{ +return probe_kernel_write (addr, insn, len); +} +#endif /* CONFIG_MMU */ + +int __kprobes riscv_patch_text_nosync (void *addr,const void *insns,size_t len) +{ +u32 *tp = addr; +int ret; + + ret =riscv_insn_write (tp, insns, len); + +if (!ret) +flush_icache_range ((uintptr_t ) tp, (uintptr_t ) tp + len); + +return ret; +} + +static int __kprobes riscv_patch_text_cb (void *data) +{ +struct riscv_insn_patch *patch = data; +int ret =0 ; + +if (atomic_inc_return (&patch->cpu_count) ==1 ) { + ret = +riscv_patch_text_nosync (patch->addr, &patch->insn, +GET_INSN_LENGTH (patch->insn)); +atomic_inc (&patch->cpu_count); + }else { +while (atomic_read (&patch->cpu_count) <=num_online_cpus ()) +cpu_relax (); +smp_mb (); + } + +return ret; +} + +int __kprobes riscv_patch_text (void *addr,u32 insn) +{ +struct riscv_insn_patch patch = { + .addr = addr, + .insn = insn, + .cpu_count =ATOMIC_INIT (0 ), + }; + +return stop_machine_cpuslocked (riscv_patch_text_cb, + &patch, cpu_online_mask);Quoted 8 lines
Quoted 8 lines
Quoted 4 lines
+}
--
2.25.1--
Masami Hiramatsu <[email protected]>--
Masami Hiramatsu <[email protected]>
Masami Hiramatsu
maintainerRe: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Hi Zong,
Quoted 21 lines · On Fri, 3 Apr 2020 17:04:51 +0800 Zong Li <[email protected]> wrote:
Quoted 16 lines
Quoted 11 lines
Quoted 10 lines
arch/riscv/kernel/patch.c line 53
Quoted 7 lines
arch/riscv/kernel/patch.c new file +7
-0+{ +void *waddr = addr; +bool across_pages = (((uintptr_t ) addr & ~PAGE_MASK ) + len) >PAGE_SIZE ; +unsigned long flags =0 ; +int ret; + +raw_spin_lock_irqsave (&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.Quoted 4 lines
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call_nosync()" and add a comment on it.
Quoted 5 lines
The ftrace is one of the cases, as documentation of ftrace said, when dynamic ftrace is initialized, it calls
kstop_machineto make the machine act like a uniprocessor so that it can freely modify code without worrying about other processors executing that same code. So the ftrace called the_nosyncinterface here directly.
Hmm, even though, since it already running under kstop_machine(), no other thread will run.
Could you consider to use text_mutex instead of that? The text_mutex is already widely used in x86 and kernel/kprobes.c etc.
(Hmm, it seems except for x86, alternative code don't care about
racing...)
Thank you,
Signature · 1 line
Masami Hiramatsu <[email protected]>
Re: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Quoted 33 lines · Masami Hiramatsu
Hi Zong,
Quoted 21 lines · On Fri, 3 Apr 2020 17:04:51 +0800 Zong Li <[email protected]> wrote:
Quoted 16 lines
Quoted 11 lines
Quoted 10 lines
arch/riscv/kernel/patch.c line 53
Quoted 7 lines
arch/riscv/kernel/patch.c new file +7
-0+{ +void *waddr = addr; +bool across_pages = (((uintptr_t ) addr & ~PAGE_MASK ) + len) >PAGE_SIZE ; +unsigned long flags =0 ; +int ret; + +raw_spin_lock_irqsave (&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.Quoted 4 lines
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call_nosync()" and add a comment on it.Quoted 5 lines
The ftrace is one of the cases, as documentation of ftrace said, when dynamic ftrace is initialized, it calls
kstop_machineto make the machine act like a uniprocessor so that it can freely modify code without worrying about other processors executing that same code. So the ftrace called the_nosyncinterface here directly.
Quoted 8 lines
Hmm, even though, since it already running under
kstop_machine(), no other thread will run.
Could you consider to usetext_mutexinstead of that? Thetext_mutexis already widely used in x86 andkernel/kprobes.cetc.(Hmm, it seems except for x86, alternative code don't care about
racing...)
Yes, text_mutex seems to be great. I'll change to use text_mutex in the next version if it works fine after testing. Thanks.
Quoted 3 lines
Thank you,
--
Masami Hiramatsu <[email protected]>
Re: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Quoted 35 lines · Zong Li
Quoted 33 lines · Masami Hiramatsu
Hi Zong,
Quoted 26 lines · On Fri, 3 Apr 2020 17:04:51 +0800 Zong Li <[email protected]> wrote:
Quoted 16 lines
Quoted 11 lines
Quoted 10 lines
Review
Quoted 7 lines
(quoted diff) +7
-0+{ + void *waddr = addr; + bool across_pages = (((uintptr_t) addr & ~PAGE_MASK) + len) > PAGE_SIZE; + unsigned long flags = 0; + int ret; + + raw_spin_lock_irqsave(&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.Quoted 4 lines
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call_nosync()" and add a comment on it.The ftrace is one of the cases, as documentation of ftrace said, when dynamic ftrace is initialized, it calls
kstop_machineto make the machine act like a uniprocessor so that it can freely modify code without worrying about other processors executing that same code. So the ftrace called the_nosyncinterface here directly.
Quoted 8 lines
Quoted 8 lines
Hmm, even though, since it already running under
kstop_machine(), no other thread will run.
Could you consider to usetext_mutexinstead of that? Thetext_mutexis already widely used in x86 andkernel/kprobes.cetc.(Hmm, it seems except for x86, alternative code don't care about
racing...)
The mutex_lock doesn't seem to work in ftrace context, I think it might be the reason why other architectures didn't use text_mutex in somewhere.
# echo function > current_tracer [ 28.198070] BUG: sleeping function called from invalid context at kernel/locking/mutex.c:281 [ 28.198663] in_atomic(): 1, irqs_disabled(): 1, non_block: 0, pid: 11, name: migration/0 [ 28.199491] CPU: 0 PID: 11 Comm: migration/0 Not tainted 5.6.0-00012-gd6f56a7a4be2-dirty #10 [ 28.200330] Call Trace: [ 28.200798] [<ffffffe00060319a>] walk_stackframe+0x0/0xcc [ 28.201395] [<ffffffe000603442>] show_stack+0x3c/0x46 [ 28.200798] [<ffffffe00060319a>] walk_stackframe+0x0/0xcc [ 28.201395] [<ffffffe000603442>] show_stack+0x3c/0x46 [ 28.201898] [<ffffffe000d498b0>] dump_stack+0x76/0x90 [ 28.202329] [<ffffffe00062c3f0>] ___might_sleep+0x100/0x10e [ 28.202720] [<ffffffe00062c448>] __might_sleep+0x4a/0x78 [ 28.203033] [<ffffffe000d61622>] mutex_lock+0x2c/0x54 [ 28.203397] [<ffffffe00060393e>] patch_insn_write+0x32/0xd8 [ 28.203780] [<ffffffe000603a94>] patch_text_nosync+0x10/0x32 [ 28.204139] [<ffffffe0006051b0>] __ftrace_modify_call+0x5c/0x6c [ 28.204497] [<ffffffe0006052c6>] ftrace_update_ftrace_func+0x20/0x4a [ 28.204919] [<ffffffe000697742>] ftrace_modify_all_code+0xa0/0x148 [ 28.205378] [<ffffffe0006977fc>] __ftrace_modify_code+0x12/0x1c [ 28.205793] [<ffffffe0006924b6>] multi_cpu_stop+0xa2/0x158 [ 28.206147] [<ffffffe0006921b0>] cpu_stopper_thread+0xa4/0x13a [ 28.206510] [<ffffffe000629f38>] smpboot_thread_fn+0xf8/0x1da [ 28.206868] [<ffffffe000625f36>] kthread+0xfa/0x12a [ 28.207201] [<ffffffe0006017e2>] ret_from_exception+0x0/0xc
Quoted 7 lines
Yes,
text_mutexseems to be great. I'll change to usetext_mutexin the next version if it works fine after testing. Thanks.Quoted 3 lines
Thank you,
--
Masami Hiramatsu <[email protected]>
Masami Hiramatsu
maintainerRe: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Quoted 41 lines · On Mon, 6 Apr 2020 18:36:42 +0800 Zong Li <[email protected]> wrote:
Quoted 40 lines · Zong Li
Quoted 38 lines · Masami Hiramatsu
Hi Zong,
Quoted 21 lines · On Fri, 3 Apr 2020 17:04:51 +0800 Zong Li <[email protected]> wrote:
Quoted 16 lines
Quoted 11 lines
Quoted 10 lines
Review
Quoted 7 lines
(quoted diff) +7
-0+{ + void *waddr = addr; + bool across_pages = (((uintptr_t) addr & ~PAGE_MASK) + len) > PAGE_SIZE; + unsigned long flags = 0; + int ret; + + raw_spin_lock_irqsave(&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.Quoted 4 lines
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call_nosync()" and add a comment on it.Quoted 5 lines
The ftrace is one of the cases, as documentation of ftrace said, when dynamic ftrace is initialized, it calls
kstop_machineto make the machine act like a uniprocessor so that it can freely modify code without worrying about other processors executing that same code. So the ftrace called the_nosyncinterface here directly.Hmm, even though, since it already running under
kstop_machine(), no other thread will run.
Could you consider to usetext_mutexinstead of that? Thetext_mutexis already widely used in x86 andkernel/kprobes.cetc.
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
(Hmm, it seems except for x86, alternative code don't care about
racing...)The
mutex_lockdoesn't seem to work in ftrace context, I think it might be the reason why other architectures didn't usetext_mutexin somewhere.
Yes, you need to implement ftrace_arch_code_modify_prepare() and ftrace_arch_code_modify_post_process() in arch/riscv/kernel/ftrace.c. Please see arch/x86/kernel/ftrace.c.
Thank you,
Quoted 36 lines
# echo function > current_tracer [ 28.198070] BUG: sleeping function called from invalid context at kernel/locking/mutex.c:281 [ 28.198663] in_atomic(): 1, irqs_disabled(): 1, non_block: 0, pid: 11, name: migration/0 [ 28.199491] CPU: 0 PID: 11 Comm: migration/0 Not tainted 5.6.0-00012-gd6f56a7a4be2-dirty #10 [ 28.200330] Call Trace: [ 28.200798] [<ffffffe00060319a>] walk_stackframe+0x0/0xcc [ 28.201395] [<ffffffe000603442>] show_stack+0x3c/0x46 [ 28.200798] [<ffffffe00060319a>] walk_stackframe+0x0/0xcc [ 28.201395] [<ffffffe000603442>] show_stack+0x3c/0x46 [ 28.201898] [<ffffffe000d498b0>] dump_stack+0x76/0x90 [ 28.202329] [<ffffffe00062c3f0>] ___might_sleep+0x100/0x10e [ 28.202720] [<ffffffe00062c448>] __might_sleep+0x4a/0x78 [ 28.203033] [<ffffffe000d61622>] mutex_lock+0x2c/0x54 [ 28.203397] [<ffffffe00060393e>] patch_insn_write+0x32/0xd8 [ 28.203780] [<ffffffe000603a94>] patch_text_nosync+0x10/0x32 [ 28.204139] [<ffffffe0006051b0>] __ftrace_modify_call+0x5c/0x6c [ 28.204497] [<ffffffe0006052c6>] ftrace_update_ftrace_func+0x20/0x4a [ 28.204919] [<ffffffe000697742>] ftrace_modify_all_code+0xa0/0x148 [ 28.205378] [<ffffffe0006977fc>] __ftrace_modify_code+0x12/0x1c [ 28.205793] [<ffffffe0006924b6>] multi_cpu_stop+0xa2/0x158 [ 28.206147] [<ffffffe0006921b0>] cpu_stopper_thread+0xa4/0x13a [ 28.206510] [<ffffffe000629f38>] smpboot_thread_fn+0xf8/0x1da [ 28.206868] [<ffffffe000625f36>] kthread+0xfa/0x12a [ 28.207201] [<ffffffe0006017e2>] ret_from_exception+0x0/0xcQuoted 7 lines
Yes,
text_mutexseems to be great. I'll change to usetext_mutexin the next version if it works fine after testing. Thanks.Quoted 3 lines
Thank you,
--
Masami Hiramatsu <[email protected]>
Signature · 1 line
Masami Hiramatsu <[email protected]>
Re: [PATCH v3 8/9] riscv: introduce interfaces to patch kernel code
Quoted 49 lines · Masami Hiramatsu
Quoted 45 lines · On Mon, 6 Apr 2020 18:36:42 +0800 Zong Li <[email protected]> wrote:
Quoted 43 lines · Zong Li
Quoted 41 lines · Masami Hiramatsu
Hi Zong,
Quoted 21 lines · On Fri, 3 Apr 2020 17:04:51 +0800 Zong Li <[email protected]> wrote:
Quoted 16 lines
Quoted 11 lines
Quoted 10 lines
Review
Quoted 7 lines
(quoted diff) +7
-0+{ + void *waddr = addr; + bool across_pages = (((uintptr_t) addr & ~PAGE_MASK) + len) > PAGE_SIZE; + unsigned long flags = 0; + int ret; + + raw_spin_lock_irqsave(&patch_lock, flags);This looks a bit odd since
stop_machine()is protected by its own mutex, and also the irq is already disabled here.Quoted 4 lines
We need it because we don't always enter the
riscv_patch_text_nosync()throughstop_machinemechanism. If we call theriscv_patch_text_nosync()directly, we need a lock to protect the page.Quoted 4 lines
Oh, OK, but it leads another question. Is that safe to patch the text without sync? Would you use it for UP system?
I think it is better to clarify "in what case user can call_nosync()" and add a comment on it.Quoted 5 lines
The ftrace is one of the cases, as documentation of ftrace said, when dynamic ftrace is initialized, it calls
kstop_machineto make the machine act like a uniprocessor so that it can freely modify code without worrying about other processors executing that same code. So the ftrace called the_nosyncinterface here directly.Hmm, even though, since it already running under
kstop_machine(), no other thread will run.
Could you consider to usetext_mutexinstead of that? Thetext_mutexis already widely used in x86 andkernel/kprobes.cetc.(Hmm, it seems except for x86, alternative code don't care about
racing...)
Quoted 8 lines
Quoted 3 lines
The
mutex_lockdoesn't seem to work in ftrace context, I think it might be the reason why other architectures didn't usetext_mutexin somewhere.Yes, you need to implement
ftrace_arch_code_modify_prepare()andftrace_arch_code_modify_post_process()inarch/riscv/kernel/ftrace.c. Please seearch/x86/kernel/ftrace.c.
Oh ok, I misunderstood it before, I just use text_mutex instead of patch_lock in patch.c. Thanks.
Quoted 42 lines
Thank you,
Quoted 20 lines
# echo function > current_tracer [ 28.198070] BUG: sleeping function called from invalid context at kernel/locking/mutex.c:281 [ 28.198663] in_atomic(): 1, irqs_disabled(): 1, non_block: 0, pid: 11, name: migration/0 [ 28.199491] CPU: 0 PID: 11 Comm: migration/0 Not tainted 5.6.0-00012-gd6f56a7a4be2-dirty #10 [ 28.200330] Call Trace: [ 28.200798] [<ffffffe00060319a>] walk_stackframe+0x0/0xcc [ 28.201395] [<ffffffe000603442>] show_stack+0x3c/0x46 [ 28.200798] [<ffffffe00060319a>] walk_stackframe+0x0/0xcc [ 28.201395] [<ffffffe000603442>] show_stack+0x3c/0x46 [ 28.201898] [<ffffffe000d498b0>] dump_stack+0x76/0x90 [ 28.202329] [<ffffffe00062c3f0>] ___might_sleep+0x100/0x10e [ 28.202720] [<ffffffe00062c448>] __might_sleep+0x4a/0x78 [ 28.203033] [<ffffffe000d61622>] mutex_lock+0x2c/0x54 [ 28.203397] [<ffffffe00060393e>] patch_insn_write+0x32/0xd8 [ 28.203780] [<ffffffe000603a94>] patch_text_nosync+0x10/0x32 [ 28.204139] [<ffffffe0006051b0>] __ftrace_modify_call+0x5c/0x6cQuoted 16 lines
[ 28.204497] [<ffffffe0006052c6>] ftrace_update_ftrace_func+0x20/0x4a [ 28.204919] [<ffffffe000697742>] ftrace_modify_all_code+0xa0/0x148 [ 28.205378] [<ffffffe0006977fc>] __ftrace_modify_code+0x12/0x1c [ 28.205793] [<ffffffe0006924b6>] multi_cpu_stop+0xa2/0x158 [ 28.206147] [<ffffffe0006921b0>] cpu_stopper_thread+0xa4/0x13a [ 28.206510] [<ffffffe000629f38>] smpboot_thread_fn+0xf8/0x1da [ 28.206868] [<ffffffe000625f36>] kthread+0xfa/0x12a [ 28.207201] [<ffffffe0006017e2>] ret_from_exception+0x0/0xcQuoted 7 lines
Yes,
text_mutexseems to be great. I'll change to usetext_mutexin the next version if it works fine after testing. Thanks.Quoted 3 lines
Thank you,
--
Masami Hiramatsu <[email protected]>--
Masami Hiramatsu <[email protected]>