nommu UML
Subsystems (7)
v13 cover nommu UML
This patchset is another spin of nommu mode addition to UML. It would be nice to hear about your opinions on that.
There are still several limitations/issues which we already found; here is the list of those issues.
- memory mapped by loadable modules are not distinguished from userspace memory.
- CONFIG_SMP is disabled as host_fs handling doesn't work with thread local storage.
-- Hajime
v13:
- rebase with the latest uml/next branch, fixing a conflict ([06/13])
v12:
- rebase with the latest uml/next branch
- disable SMP and tls as those doesn't work with host_fs handling ([11/13])
- https://lore.kernel.org/all/[email protected]/
v11:
- clean up userspace return routine and integrate to userspace() ([04/13])
- fix direction flag issue on using nolibc memcpy ([04/13])
- fix a crash issue when using usermode helper ([06/13])
- test with out-of-tree kunit-uapi patches (which uses umh)
- https://lore.kernel.org/all/[email protected]/
- https://lore.kernel.org/all/[email protected]/
- https://lore.kernel.org/all/[email protected]/
v10:
- fix wrong comment on gs register handling ([09/13])
- remove unnecessary code of early syscall implementation ([04/13])
- https://lore.kernel.org/all/[email protected]/
v9:
- rebase with the latest uml/next branch
- add performance numbers of new SECCOMP mode, and update results ([12/13])
- add a workaround for upstream change on MMU depedency to PCI drivers ([10/13])
- https://lore.kernel.org/all/[email protected]/
v8:
- rebase with the latest uml/next branch
- clean up segv_handler to align with the latest uml ([9/12])
- https://lore.kernel.org/all/[email protected]/
v7:
- properly handle FP register upon signal delivery [10/13]
- update benchmark result with new FP register handling [12/13]
- fix arch_has_single_step() for !MMU case [07/13]
- revert stack alignment as it is in uml/fixes tree [10/13]
- https://lore.kernel.org/all/[email protected]/
v6:
- rebase to the latest uml/next tree
- more clean up on mmu/nommu for signal handling [10/13]
- rename functions of mcontext routines [06,10/13]
- added Acked-by tag for binfmt_elf_fdpic [02/13]
- https://lore.kernel.org/linux-um/[email protected]/
v5:
- clean up stack manipulation code [05,06,07,10/13]
- https://lore.kernel.org/linux-um/[email protected]/
v4:
- add arch/um/nommu, arch/x86/um/nommu to contain !MMU specific codes
- remove zpoline patch
- drop binfmt_elf_fdpic patch
- reduce ifndef CONFIG_MMU if possible
- split to elf header cleanup patch [01/13]
- fix kernel test robot warnings [06/13]
- fix coding styles [07/13]
- move task_top_of_stack definition [05/13]
- https://lore.kernel.org/linux-um/[email protected]/
v3:
- https://lore.kernel.org/linux-um/[email protected]/
- add seccomp-based syscall hook in addition to zpoline [06/13]
- remove RFC, add a line to MAINTAINERS file
- fix kernel test robot warnings [02/13,08/13,10/13]
- add base-commit tag to cover letter
- pull the latest uml/next
- clean up SIGSEGV handling [10/13]
- detect fsgsbase availability with elf aux vector [08/13]
- simplify vdso code with macros [09/13]
RFC v2:
- https://lore.kernel.org/linux-um/[email protected]/
- base branch is now uml/linux.git instead of torvalds/linux.git.
- reorganize the patch series to clean up
- fixed various coding styles issues
- clean up exec code path [07/13]
- fixed the crash/SIGSEGV case on userspace programs [10/13]
- add seccomp filter to limit syscall caller address [06/13]
- detect fsgsbase availability with sigsetjmp/siglongjmp [08/13]
- removes unrelated changes
- removes unneeded ifndef CONFIG_MMU
- convert UML_CONFIG_MMU to CONFIG_MMU as using uml/linux.git
- proposed a patch of maple-tree issue (resolving a limitation in RFC v1)
https://lore.kernel.org/linux-mm/[email protected]/
RFC:
- https://lore.kernel.org/linux-um/[email protected]/
Hajime Tazaki (13):
x86/um: nommu: elf loader for fdpic
um: decouple MMU specific code from the common part
um: nommu: memory handling
x86/um: nommu: syscall handling
um: nommu: seccomp syscalls hook
x86/um: nommu: process/thread handling
um: nommu: configure fs register on host syscall invocation x86/um/vdso: nommu: vdso memory update
x86/um: nommu: signal handling
um: change machine name for uname output
um: nommu: disable SMP on nommu UML
um: nommu: add documentation of nommu UML
um: nommu: plug nommu code into build system
Documentation/virt/uml/nommu-uml.rst | 180 ++++++++++++++++++++++ MAINTAINERS | 1 + arch/um/Kconfig | 14 +- arch/um/Makefile | 10 ++ arch/um/configs/x86_64_nommu_defconfig | 54 +++++++ arch/um/include/asm/futex.h | 4 + arch/um/include/asm/mmu.h | 8 + arch/um/include/asm/mmu_context.h | 2 + arch/um/include/asm/ptrace-generic.h | 8 +- arch/um/include/asm/uaccess.h | 7 +- arch/um/include/shared/kern_util.h | 6 + arch/um/include/shared/os.h | 16 ++ arch/um/kernel/Makefile | 5 +- arch/um/kernel/mem-pgtable.c | 55 +++++++ arch/um/kernel/mem.c | 38 +---- arch/um/kernel/process.c | 38 +++++ arch/um/kernel/skas/process.c | 37 ----- arch/um/kernel/um_arch.c | 3 + arch/um/nommu/Makefile | 3 + arch/um/nommu/os-Linux/Makefile | 7 + arch/um/nommu/os-Linux/seccomp.c | 87 +++++++++++ arch/um/nommu/os-Linux/signal.c | 24 +++ arch/um/nommu/trap.c | 201 +++++++++++++++++++++++++ arch/um/os-Linux/Makefile | 3 +- arch/um/os-Linux/internal.h | 8 + arch/um/os-Linux/mem.c | 4 + arch/um/os-Linux/process.c | 139 ++++++++++++++++- arch/um/os-Linux/signal.c | 11 +- arch/um/os-Linux/skas/process.c | 127 ---------------- arch/um/os-Linux/start_up.c | 25 ++- arch/um/os-Linux/util.c | 3 +- arch/x86/um/Kconfig | 2 +- arch/x86/um/Makefile | 7 +- arch/x86/um/asm/elf.h | 8 +- arch/x86/um/asm/syscall.h | 6 + arch/x86/um/nommu/Makefile | 8 + arch/x86/um/nommu/do_syscall_64.c | 75 +++++++++ arch/x86/um/nommu/entry_64.S | 114 ++++++++++++++ arch/x86/um/nommu/os-Linux/Makefile | 6 + arch/x86/um/nommu/os-Linux/mcontext.c | 26 ++++ arch/x86/um/nommu/syscalls.h | 18 +++ arch/x86/um/nommu/syscalls_64.c | 121 +++++++++++++++ arch/x86/um/shared/sysdep/mcontext.h | 5 + arch/x86/um/shared/sysdep/ptrace.h | 2 +- arch/x86/um/vdso/vma.c | 17 ++- fs/Kconfig.binfmt | 2 +- 46 files changed, 1322 insertions(+), 223 deletions(-) create mode 100644 Documentation/virt/uml/nommu-uml.rst create mode 100644 arch/um/configs/x86_64_nommu_defconfig create mode 100644 arch/um/kernel/mem-pgtable.c create mode 100644 arch/um/nommu/Makefile create mode 100644 arch/um/nommu/os-Linux/Makefile create mode 100644 arch/um/nommu/os-Linux/seccomp.c create mode 100644 arch/um/nommu/os-Linux/signal.c create mode 100644 arch/um/nommu/trap.c create mode 100644 arch/x86/um/nommu/Makefile create mode 100644 arch/x86/um/nommu/do_syscall_64.c create mode 100644 arch/x86/um/nommu/entry_64.S create mode 100644 arch/x86/um/nommu/os-Linux/Makefile create mode 100644 arch/x86/um/nommu/os-Linux/mcontext.c create mode 100644 arch/x86/um/nommu/syscalls.h create mode 100644 arch/x86/um/nommu/syscalls_64.c
base-commit: 293f71435d14f5b5c46fc3398695fa265c69363d
Signature · 1 line
2.43.0
PATCH v13 1/13 x86/um: nommu: elf loader for fdpic
As UML supports CONFIG_MMU=n case, it has to use an alternate ELF loader, FDPIC ELF loader. In this commit, we added necessary definitions in the arch, as UML has not been used so far. It also updates Kconfig file to use BINFMT_ELF_FDPIC under !MMU environment.
--- arch/um/include/asm/mmu.h | 5 +++++ arch/um/include/asm/ptrace-generic.h | 6 ++++++ arch/x86/um/asm/elf.h | 8 ++++++-- fs/Kconfig.binfmt | 2 +- 4 files changed, 18 insertions(+), 3 deletions(-)
arch/um/include/asm/mmu.h +5 -0
@@ -21,6 +21,11 @@ typedef struct mm_context {spinlock_t sync_tlb_lock;unsigned long sync_tlb_range_from;unsigned long sync_tlb_range_to; + +#ifdef CONFIG_BINFMT_ELF_FDPIC +unsigned long exec_fdpic_loadmap; +unsigned long interp_fdpic_loadmap; +#endif } mm_context_t;#define INIT_MM_CONTEXT (mm) \
arch/um/include/asm/ptrace-generic.h +6 -0
@@ -29,6 +29,12 @@ struct pt_regs {#define PTRACE_OLDSETOPTIONS 21 +#ifdef CONFIG_BINFMT_ELF_FDPIC +#define PTRACE_GETFDPIC 31 +#define PTRACE_GETFDPIC_EXEC 0 +#define PTRACE_GETFDPIC_INTERP 1 +#endif +struct task_struct ; extern long subarch_ptrace(struct task_struct *child, long request,
arch/x86/um/asm/elf.h +6 -2
@@ -9,6 +9,7 @@#include <skas.h> #define CORE_DUMP_USE_REGSET +#define ELF_FDPIC_CORE_EFLAGS 0#ifdef CONFIG_X86_32
@@ -158,8 +159,11 @@ extern int arch_setup_additional_pages(struct linux_binprm *bprm,extern unsigned long um_vdso_addr;#define AT_SYSINFO_EHDR 33 -#define ARCH_DLINFO NEW_AUX_ENT(AT_SYSINFO_EHDR, um_vdso_addr) - +#define ARCH_DLINFO \ +do { \ + NEW_AUX_ENT(AT_SYSINFO_EHDR, um_vdso_addr); \ + NEW_AUX_ENT(AT_MINSIGSTKSZ, 0); \ +} while (0)#endif typedef unsigned long elf_greg_t ;
fs/Kconfig.binfmt +1 -1
@@ -58,7 +58,7 @@ config ARCH_USE_GNU_PROPERTY config BINFMT_ELF_FDPIC bool "Kernel support for FDPIC ELF binaries" default y if !BINFMT_ELF - depends on ARM || ((M68K || RISCV || SUPERH || XTENSA) && !MMU) + depends on ARM || ((M68K || RISCV || SUPERH || UML || XTENSA) && !MMU) select ELFCORE help ELF FDPIC binaries are based on ELF, but allow the individual load
Signature · 1 line
2.43.0
PATCH v13 2/13 um: decouple MMU specific code from the common part
In reply to Hajime TazakiThis splits the memory, process related code with common and MMU specific parts in order to avoid ifdefs in .c file and duplication between MMU and !MMU.
--- arch/um/kernel/Makefile | 5 +- arch/um/kernel/mem-pgtable.c | 55 ++++++++++++++ arch/um/kernel/mem.c | 35 --------- arch/um/kernel/process.c | 38 ++++++++++ arch/um/kernel/skas/process.c | 37 --------- arch/um/os-Linux/Makefile | 3 +- arch/um/os-Linux/process.c | 129 ++++++++++++++++++++++++++++++++ arch/um/os-Linux/skas/process.c | 127 ------------------------------- 8 files changed, 227 insertions(+), 202 deletions(-) create mode 100644 arch/um/kernel/mem-pgtable.c
arch/um/kernel/Makefile +3 -2
@@ -16,9 +16,10 @@ always-$(KBUILD_BUILTIN) := vmlinux.lds obj-y = config.o exec.o exitcode.o irq.o ksyms.o mem.o \ physmem.o process.o ptrace.o reboot.o sigio.o \ - signal.o sysrq.o time.o tlb.o trap.o \ - um_arch.o umid.o kmsg_dump.o capflags.o skas/ + signal.o sysrq.o time.o \ + um_arch.o umid.o kmsg_dump.o capflags.o obj-y += load_file.o +obj-$(CONFIG_MMU) += mem-pgtable.o tlb.o trap.o skas/ obj-$(CONFIG_BLK_DEV_INITRD) += initrd.o obj-$(CONFIG_GPROF) += gprof_syms.o
arch/um/kernel/mem-pgtable.c new file +55 -0
55 lines not on this page · raw message
arch/um/kernel/mem.c +0 -35
@@ -6,7 +6,6 @@#include <linux/stddef.h> #include <linux/module.h> #include <linux/memblock.h> -#include <linux/mm.h> #include <linux/swap.h> #include <linux/slab.h> #include <linux/init.h>
@@ -107,45 +106,11 @@ void free_initmem(void) { } -/* Allocate and free page tables. */ - -pgd_t *pgd_alloc (struct mm_struct *mm) -{ -pgd_t *pgd =__pgd_alloc (mm,0 ); - -if (pgd) -memcpy (pgd +USER_PTRS_PER_PGD , - swapper_pg_dir +USER_PTRS_PER_PGD , - (PTRS_PER_PGD -USER_PTRS_PER_PGD ) *sizeof (pgd_t)); - -return pgd; -} -void *uml_kmalloc (int size,int flags) {return kmalloc (size, flags); } -static const pgprot_t protection_map[16 ] = { - [VM_NONE ] =PAGE_NONE , - [VM_READ ] =PAGE_READONLY , - [VM_WRITE ] =PAGE_COPY , - [VM_WRITE |VM_READ ] =PAGE_COPY , - [VM_EXEC ] =PAGE_READONLY , - [VM_EXEC |VM_READ ] =PAGE_READONLY , - [VM_EXEC |VM_WRITE ] =PAGE_COPY , - [VM_EXEC |VM_WRITE |VM_READ ] =PAGE_COPY , - [VM_SHARED ] =PAGE_NONE , - [VM_SHARED |VM_READ ] =PAGE_READONLY , - [VM_SHARED |VM_WRITE ] =PAGE_SHARED , - [VM_SHARED |VM_WRITE |VM_READ ] =PAGE_SHARED , - [VM_SHARED |VM_EXEC ] =PAGE_READONLY , - [VM_SHARED |VM_EXEC |VM_READ ] =PAGE_READONLY , - [VM_SHARED |VM_EXEC |VM_WRITE ] =PAGE_SHARED , - [VM_SHARED |VM_EXEC |VM_WRITE |VM_READ ] =PAGE_SHARED -}; -DECLARE_VM_GET_PAGE_PROT -void mark_rodata_ro (void ) {unsigned long rodata_start =PFN_ALIGN (__start_rodata);
arch/um/kernel/process.c +38 -0
@@ -25,6 +25,7 @@#include <linux/tick.h> #include <linux/threads.h> #include <linux/resume_user_mode.h> +#include <linux/start_kernel.h> #include <asm/current.h> #include <asm/mmu_context.h> #include <asm/switch_to.h>
@@ -307,3 +308,40 @@ unsigned long __get_wchan(struct task_struct *p)return 0 ; } + +extern void start_kernel (void ); + +static int __init start_kernel_proc (void *unused) +{ +block_signals_trace (); + +start_kernel (); +return 0 ; +} + +char cpu_irqstacks[NR_CPUS ][THREAD_SIZE ]__aligned(THREAD_SIZE) ; + +int __init start_uml (void ) +{ +stack_protections ((unsigned long ) &cpu_irqstacks[0 ]); +set_sigstack (cpu_irqstacks[0 ],THREAD_SIZE ); + +init_new_thread_signals (); + + init_task.thread.request.thread.proc = start_kernel_proc; + init_task.thread.request.thread.arg =NULL ; +return start_idle_thread (task_stack_page (&init_task), + &init_task.thread.switch_buf); +} + +static DEFINE_SPINLOCK (initial_jmpbuf_spinlock); + +void initial_jmpbuf_lock (void ) +{ +spin_lock_irq (&initial_jmpbuf_spinlock); +} + +void initial_jmpbuf_unlock (void ) +{ +spin_unlock_irq (&initial_jmpbuf_spinlock); +}
arch/um/kernel/skas/process.c +0 -37
@@ -17,31 +17,6 @@#include <skas.h> #include <kern_util.h> -extern void start_kernel (void ); - -static int __init start_kernel_proc (void *unused) -{ -block_signals_trace (); - -start_kernel (); -return 0 ; -} - -char cpu_irqstacks[NR_CPUS ][THREAD_SIZE ]__aligned(THREAD_SIZE) ; - -int __init start_uml (void ) -{ -stack_protections ((unsigned long ) &cpu_irqstacks[0 ]); -set_sigstack (cpu_irqstacks[0 ],THREAD_SIZE ); - -init_new_thread_signals (); - - init_task.thread.request.thread.proc = start_kernel_proc; - init_task.thread.request.thread.arg =NULL ; -return start_idle_thread (task_stack_page (&init_task), - &init_task.thread.switch_buf); -} -unsigned long current_stub_stack (void ) {if (current->mm ==NULL )
@@ -65,15 +40,3 @@ void current_mm_sync(void)um_tlb_sync (current->mm); } - -static DEFINE_SPINLOCK (initial_jmpbuf_spinlock); - -void initial_jmpbuf_lock (void ) -{ -spin_lock_irq (&initial_jmpbuf_spinlock); -} - -void initial_jmpbuf_unlock (void ) -{ -spin_unlock_irq (&initial_jmpbuf_spinlock); -}
arch/um/os-Linux/Makefile +2 -1
@@ -8,7 +8,8 @@ KCOV_INSTRUMENT := n obj-y = elf_aux.o execvp.o file.o helper.o irq.o main.o mem.o process.o \ registers.o sigio.o signal.o start_up.o time.o tty.o \ - umid.o user_syms.o util.o skas/ + umid.o user_syms.o util.o +obj-$(CONFIG_MMU) += skas/ CFLAGS_signal.o += -Wframe-larger-than=4096
arch/um/os-Linux/process.c +129 -0
148 lines not on this page · raw message
arch/um/os-Linux/skas/process.c +0 -127
158 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v13 3/13 um: nommu: memory handling
In reply to Hajime TazakiThis commit adds memory operations on UML under !MMU environment.
Some part of the original UML code relying on CONFIG_MMU are excluded from compilation when !CONFIG_MMU. Additionally, generic functions such as uaccess, futex, memcpy/strnlen/strncpy can be used as user- and kernel-space share the address space in !CONFIG_MMU mode.
--- arch/um/Makefile | 4 ++++ arch/um/include/asm/futex.h | 4 ++++ arch/um/include/asm/mmu.h | 3 +++ arch/um/include/asm/mmu_context.h | 2 ++ arch/um/include/asm/uaccess.h | 7 ++++--- arch/um/kernel/mem.c | 3 ++- arch/um/os-Linux/mem.c | 4 ++++ arch/um/os-Linux/process.c | 4 ++-- 8 files changed, 25 insertions(+), 6 deletions(-)
arch/um/Makefile +4 -0
@@ -46,6 +46,10 @@ ARCH_INCLUDE := -I$(srctree)/$(SHARED_HEADERS) ARCH_INCLUDE += -I$(srctree)/$(HOST_DIR)/um/shared KBUILD_CPPFLAGS += -I$(srctree)/$(HOST_DIR)/um +ifneq ($(CONFIG_MMU),y) +core-y += $(ARCH_DIR)/nommu/ +endif + # -Dvmap=kernel_vmap prevents anything from referencing the libpcap.o symbol so # named - it's a common symbol in libpcap, so we get a binary which crashes. #
arch/um/include/asm/futex.h +4 -0
@@ -7,8 +7,12 @@#include <asm/errno.h> +#ifdef CONFIG_MMU int arch_futex_atomic_op_inuser (int op,u32 oparg,int *oval,u32 __user *uaddr);int futex_atomic_cmpxchg_inatomic (u32 *uval,u32 __user *uaddr,u32 oldval,u32 newval); +#else +#include <asm-generic/futex.h> +#endif #endif
arch/um/include/asm/mmu.h +3 -0
@@ -22,10 +22,13 @@ typedef struct mm_context {unsigned long sync_tlb_range_from;unsigned long sync_tlb_range_to; +#ifndef CONFIG_MMU +unsigned long end_brk;#ifdef CONFIG_BINFMT_ELF_FDPIC unsigned long exec_fdpic_loadmap;unsigned long interp_fdpic_loadmap;#endif +#endif /* !CONFIG_MMU */ } mm_context_t;#define INIT_MM_CONTEXT (mm) \
arch/um/include/asm/mmu_context.h +2 -0
@@ -18,11 +18,13 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, { } +#ifdef CONFIG_MMU #define init_new_context init_new_contextextern int init_new_context (struct task_struct *task,struct mm_struct *mm);#define destroy_context destroy_contextextern void destroy_context (struct mm_struct *mm); +#endif #include <asm-generic/mmu_context.h>
arch/um/include/asm/uaccess.h +4 -3
@@ -18,6 +18,7 @@#define __addr_range_nowrap (addr, size) \ ((unsigned long) (addr) <= ((unsigned long) (addr) + (size))) +#ifdef CONFIG_MMU extern unsigned long raw_copy_from_user (void *to,const void __user *from,unsigned long n);extern unsigned long raw_copy_to_user (void __user *to,const void *from,unsigned long n);extern unsigned long __clear_user (void __user *mem,unsigned long len);
@@ -29,9 +30,6 @@ static inline int __access_ok(const void __user *ptr, unsigned long size);#define INLINE_COPY_FROM_USER #define INLINE_COPY_TO_USER - -#include <asm-generic/uaccess.h> -static inline int __access_ok (const void __user *ptr,unsigned long size) {unsigned long addr = (unsigned long )ptr;
@@ -63,5 +61,8 @@ do { \barrier (); \ current->thread.segv_continue =NULL ; \ } while (0) +#endif + +#include <asm-generic/uaccess.h> #endif
arch/um/kernel/mem.c +2 -1
@@ -71,7 +71,8 @@ void __init arch_mm_preinit(void)* to be turned on. */ brk_end =PAGE_ALIGN ((unsigned long )sbrk (0 )); -map_memory (brk_end,__pa (brk_end), uml_reserved - brk_end,1 ,1 ,0 ); +map_memory (brk_end,__pa (brk_end), uml_reserved - brk_end,1 ,1 , + !IS_ENABLED (CONFIG_MMU ));memblock_free ((void *)brk_end, uml_reserved - brk_end); uml_reserved = brk_end; min_low_pfn =PFN_UP (__pa (uml_reserved));
arch/um/os-Linux/mem.c +4 -0
@@ -213,6 +213,10 @@ int __init create_mem_file(unsigned long long len) {int err, fd; +/* NOMMU kernel uses -1 as a fd for further use (e.g., mmap) */ +if (!IS_ENABLED (CONFIG_MMU )) +return -1 ; + fd =create_tmp_file (len); err =os_set_exec_close (fd);
arch/um/os-Linux/process.c +2 -2
@@ -100,8 +100,8 @@ int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len, prot = (r ?PROT_READ :0 ) | (w ?PROT_WRITE :0 ) | (x ?PROT_EXEC :0 ); - loc =mmap64 ((void *) virt, len, prot,MAP_SHARED |MAP_FIXED , - fd, off); + loc =mmap64 ((void *) virt, len, prot,MAP_SHARED |MAP_FIXED | + (!IS_ENABLED (CONFIG_MMU ) ?MAP_ANONYMOUS :0 ), fd, off);if (loc ==MAP_FAILED )return -errno;return 0 ;
Signature · 1 line
2.43.0
PATCH v13 4/13 x86/um: nommu: syscall handling
In reply to Hajime TazakiThis commit introduces an entry point of syscall interface for !MMU mode. It uses an entry function, __kernel_vsyscall, a kernel-wide global symbol accessible from any locations.
Although it isn't in the scope of this commit, it can be also exposed via vdso image which is directly accessible from userspace. A standard library (i.e., libc) can utilize this entry point to implement syscall wrapper; we can also use this by hooking syscall for unmodified userspace applications/libraries, which will be implemented in the subsequent commit.
This only supports 64-bit mode of x86 architecture.
--- arch/x86/um/Makefile | 4 ++ arch/x86/um/asm/syscall.h | 6 ++ arch/x86/um/nommu/Makefile | 8 +++ arch/x86/um/nommu/do_syscall_64.c | 32 +++++++++ arch/x86/um/nommu/entry_64.S | 112 ++++++++++++++++++++++++++++++ arch/x86/um/nommu/syscalls.h | 16 +++++ 6 files changed, 178 insertions(+) create mode 100644 arch/x86/um/nommu/Makefile create mode 100644 arch/x86/um/nommu/do_syscall_64.c create mode 100644 arch/x86/um/nommu/entry_64.S create mode 100644 arch/x86/um/nommu/syscalls.h
arch/x86/um/Makefile +4 -0
@@ -31,6 +31,10 @@ obj-y += mem_64.o syscalls_64.o vdso/ subarch-y = ../lib/csum-partial_64.o ../lib/memcpy_64.o \ ../lib/memmove_64.o ../lib/memset_64.o +ifneq ($(CONFIG_MMU),y) +obj-y += nommu/ +endif + endif subarch-$(CONFIG_MODULES) += ../kernel/module.o
arch/x86/um/asm/syscall.h +6 -0
@@ -20,4 +20,10 @@ static inline int syscall_get_arch(struct task_struct *task) #endif } +#ifndef CONFIG_MMU +extern void do_syscall_64 (struct pt_regs *regs); +extern long __kernel_vsyscall (int64_t a0,int64_t a1,int64_t a2,int64_t a3, +int64_t a4,int64_t a5,int64_t a6); +#endif +#endif /* __UM_ASM_SYSCALL_H */
arch/x86/um/nommu/Makefile new file +8 -0
@@ -0,0 +1,8 @@ +# SPDX-License-Identifier: GPL-2.0 +ifeq ($(CONFIG_X86_32),y) + BITS := 32 +else + BITS := 64 +endif + +obj-y = do_syscall_$(BITS).o entry_$(BITS).o
arch/x86/um/nommu/do_syscall_64.c new file +32 -0
@@ -0,0 +1,32 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/kernel.h> +#include <linux/ptrace.h> +#include <kern_util.h> +#include <asm/syscall.h> +#include <os.h> + +__visible void do_syscall_64(struct pt_regs *regs) +{ +int syscall; + + syscall =PT_SYSCALL_NR (regs->regs.gp); +UPT_SYSCALL_NR (®s->regs) = syscall; + +if (likely (syscall < NR_syscalls)) { +unsigned long ret; + + ret = (*sys_call_table[syscall])(UPT_SYSCALL_ARG1 (®s->regs), +UPT_SYSCALL_ARG2 (®s->regs), +UPT_SYSCALL_ARG3 (®s->regs), +UPT_SYSCALL_ARG4 (®s->regs), +UPT_SYSCALL_ARG5 (®s->regs), +UPT_SYSCALL_ARG6 (®s->regs)); +PT_REGS_SET_SYSCALL_RETURN (regs, ret); + } + +PT_REGS_SYSCALL_RET (regs) = regs->regs.gp[HOST_AX ]; + +/* handle tasks and signals at the end */ +interrupt_end (); +}
arch/x86/um/nommu/entry_64.S new file +112 -0
112 lines not on this page · raw message
arch/x86/um/nommu/syscalls.h new file +16 -0
@@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __UM_NOMMU_SYSCALLS_H +#define __UM_NOMMU_SYSCALLS_H + + +#define task_top_of_stack (task) \ +({ \ + unsigned long __ptr = (unsigned long)task->stack; \ + __ptr += THREAD_SIZE; \ + __ptr; \ +}) + +extern long current_top_of_stack; +extern long current_ptregs; + +#endif
Signature · 1 line
2.43.0
PATCH v13 5/13 um: nommu: seccomp syscalls hook
In reply to Hajime TazakiThis commit adds syscall hook with seccomp.
Using seccomp raises SIGSYS to UML process, which is captured in the (UML) kernel, then jumps to the syscall entry point, __kernel_vsyscall, to hook the original syscall instructions.
The SIGSYS signal is raised upon the execution from uml_reserved and high_physmem, which locates userspace memory.
It also renames existing static function, sigsys_handler(), in start_up.c to avoid name conflicts between them.
--- arch/um/include/shared/kern_util.h | 2 + arch/um/include/shared/os.h | 10 +++ arch/um/kernel/um_arch.c | 3 + arch/um/nommu/Makefile | 3 + arch/um/nommu/os-Linux/Makefile | 7 +++ arch/um/nommu/os-Linux/seccomp.c | 87 +++++++++++++++++++++++++++ arch/um/nommu/os-Linux/signal.c | 16 +++++ arch/um/os-Linux/signal.c | 8 +++ arch/um/os-Linux/start_up.c | 4 +- arch/x86/um/nommu/Makefile | 2 +- arch/x86/um/nommu/os-Linux/Makefile | 6 ++ arch/x86/um/nommu/os-Linux/mcontext.c | 15 +++++ arch/x86/um/shared/sysdep/mcontext.h | 4 ++ 13 files changed, 164 insertions(+), 3 deletions(-) create mode 100644 arch/um/nommu/Makefile create mode 100644 arch/um/nommu/os-Linux/Makefile create mode 100644 arch/um/nommu/os-Linux/seccomp.c create mode 100644 arch/um/nommu/os-Linux/signal.c create mode 100644 arch/x86/um/nommu/os-Linux/Makefile create mode 100644 arch/x86/um/nommu/os-Linux/mcontext.c
arch/um/include/shared/kern_util.h +2 -0
@@ -63,6 +63,8 @@ extern void segv_handler(int sig, struct siginfo *unused_si, struct uml_pt_regsextern void winch (int sig,struct siginfo *unused_si,struct uml_pt_regs *regs,void *mc);extern void fatal_sigsegv (void ) __attribute__ ((noreturn)); +extern void sigsys_handler (int sig,struct siginfo *si,struct uml_pt_regs *regs, +void *mc);void um_idle_sleep (void );
arch/um/include/shared/os.h +10 -0
@@ -356,4 +356,14 @@ static inline void os_local_ipi_enable(void) { }static inline void os_local_ipi_disable (void ) { }#endif /* CONFIG_SMP */ +/* seccomp.c */ +#ifdef CONFIG_MMU +static inline int os_setup_seccomp (void ) +{ +return 0 ; +} +#else +extern int os_setup_seccomp (void ); +#endif +#endif
arch/um/kernel/um_arch.c +3 -0
@@ -423,6 +423,9 @@ void __init setup_arch(char **cmdline_p)add_bootloader_randomness (rng_seed,sizeof (rng_seed));memzero_explicit (rng_seed,sizeof (rng_seed)); } + +/* install seccomp filter */ +os_setup_seccomp (); }void __init arch_cpu_finalize_init (void )
arch/um/nommu/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-y := os-Linux/
arch/um/nommu/os-Linux/Makefile new file +7 -0
@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-y := seccomp.o signal.o +USER_OBJS := $(obj-y) + +include $(srctree)/arch/um/scripts/Makefile.rules +USER_CFLAGS+=-I$(srctree)/arch/um/os-Linux
arch/um/nommu/os-Linux/seccomp.c new file +87 -0
87 lines not on this page · raw message
arch/um/nommu/os-Linux/signal.c new file +16 -0
@@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <signal.h> +#include <kern_util.h> +#include <os.h> +#include <sysdep/mcontext.h> +#include <sys/ucontext.h> + +void sigsys_handler (int sig,struct siginfo *si, +struct uml_pt_regs *regs,void *ptr) +{ +mcontext_t *mc = (mcontext_t *) ptr; + +/* hook syscall via SIGSYS */ +set_mc_sigsys_hook (mc); +}
arch/um/os-Linux/signal.c +8 -0
@@ -20,6 +20,7 @@#include <um_malloc.h> #include <sys/ucontext.h> #include <timetravel.h> +#include <linux/compiler_attributes.h> #include "internal.h" void (*sig_info[NSIG ])(int ,struct siginfo *,struct uml_pt_regs *,void *mc) = {
@@ -31,6 +32,7 @@ void (*sig_info[NSIG])(int, struct siginfo *, struct uml_pt_regs *, void *mc) = [SIGSEGV] = segv_handler, [SIGIO] = sigio_handler, [SIGCHLD] = sigchld_handler, + [SIGSYS] = sigsys_handler, };static void sig_handler_common (int sig,struct siginfo *si,mcontext_t *mc)
@@ -182,6 +184,11 @@ static void sigusr1_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)uml_pm_wake (); } +__weak void sigsys_handler (int sig,struct siginfo *unused_si, +struct uml_pt_regs *regs,void *mc) +{ +} +void register_pm_wake_signal (void ) {set_handler (SIGUSR1 );
@@ -193,6 +200,7 @@ static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) = { [SIGILL] = sig_handler, [SIGFPE] = sig_handler, [SIGTRAP] = sig_handler, + [SIGSYS] = sig_handler, [SIGIO] = sig_handler, [SIGWINCH] = sig_handler,
arch/um/os-Linux/start_up.c +2 -2
@@ -239,7 +239,7 @@ extern unsigned long *exec_fp_regs;__initdata static struct stub_data *seccomp_test_stub_data; -static void __init sigsys_handler (int sig,siginfo_t *info,void *p) +static void __init _sigsys_handler (int sig,siginfo_t *info,void *p) {ucontext_t *uc = p;
@@ -274,7 +274,7 @@ static int __init seccomp_helper(void *data) sizeof(seccomp_test_stub_data->sigstack)); sa.sa_flags =SA_ONSTACK |SA_NODEFER |SA_SIGINFO ; - sa.sa_sigaction = (void *) sigsys_handler; + sa.sa_sigaction = (void *) _sigsys_handler; sa.sa_restorer =NULL ;if (sigaction (SIGSYS , &sa,NULL ) <0 )exit (2 );
arch/x86/um/nommu/Makefile +1 -1
@@ -5,4 +5,4 @@ else BITS := 64 endif -obj-y = do_syscall_$(BITS).o entry_$(BITS).o +obj-y = do_syscall_$(BITS).o entry_$(BITS).o os-Linux/
arch/x86/um/nommu/os-Linux/Makefile new file +6 -0
@@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-y = mcontext.o +USER_OBJS := mcontext.o + +include $(srctree)/arch/um/scripts/Makefile.rules
arch/x86/um/nommu/os-Linux/mcontext.c new file +15 -0
@@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <sys/ucontext.h> +#define __FRAME_OFFSETS +#include <asm/ptrace.h> +#include <sysdep/ptrace.h> +#include <sysdep/mcontext.h> + +extern long __kernel_vsyscall (int64_t a0,int64_t a1,int64_t a2,int64_t a3, +int64_t a4,int64_t a5,int64_t a6); + +void set_mc_sigsys_hook (mcontext_t *mc) +{ + mc->gregs[REG_RCX ] = mc->gregs[REG_RIP ]; + mc->gregs[REG_RIP ] = (unsigned long ) __kernel_vsyscall; +}
arch/x86/um/shared/sysdep/mcontext.h +4 -0
@@ -17,6 +17,10 @@ extern int get_stub_state(struct uml_pt_regs *regs, struct stub_data *data,extern int set_stub_state (struct uml_pt_regs *regs,struct stub_data *data,int single_stepping); +#ifndef CONFIG_MMU +extern void set_mc_sigsys_hook (mcontext_t *mc); +#endif +#ifdef __i386__#define GET_FAULTINFO_FROM_MC (fi, mc) \
Signature · 1 line
2.43.0
PATCH v13 6/13 x86/um: nommu: process/thread handling
In reply to Hajime TazakiSince ptrace facility isn't used under !MMU of UML, there is different code path to invoke processes/threads; there are no external process used, and need to properly configure some of registers (fs segment register for TLS, etc) on every context switch, etc.
Signals aren't delivered in non-ptrace syscall entry/leave so, we also need to handle pending signal by ourselves.
ptrace related syscalls are not tested yet so, marked arch_has_single_step() unsupported in !MMU environment.
--- arch/um/include/asm/ptrace-generic.h | 2 +- arch/x86/um/Makefile | 3 +- arch/x86/um/nommu/Makefile | 2 +- arch/x86/um/nommu/entry_64.S | 2 ++ arch/x86/um/nommu/syscalls.h | 2 ++ arch/x86/um/nommu/syscalls_64.c | 50 ++++++++++++++++++++++++++++ 6 files changed, 58 insertions(+), 3 deletions(-) create mode 100644 arch/x86/um/nommu/syscalls_64.c
arch/um/include/asm/ptrace-generic.h +1 -1
@@ -14,7 +14,7 @@ struct pt_regs {struct uml_pt_regs regs; }; -#define arch_has_single_step () (1) +#define arch_has_single_step () (IS_ENABLED(CONFIG_MMU))#define EMPTY_REGS { .regs = EMPTY_UML_PT_REGS }
arch/x86/um/Makefile +2 -1
@@ -26,7 +26,8 @@ subarch-y += ../kernel/sys_ia32.o else -obj-y += mem_64.o syscalls_64.o vdso/ +obj-y += mem_64.o vdso/ +obj-$(CONFIG_MMU) += syscalls_64.o subarch-y = ../lib/csum-partial_64.o ../lib/memcpy_64.o \ ../lib/memmove_64.o ../lib/memset_64.o
arch/x86/um/nommu/Makefile +1 -1
@@ -5,4 +5,4 @@ else BITS := 64 endif -obj-y = do_syscall_$(BITS).o entry_$(BITS).o os-Linux/ +obj-y = do_syscall_$(BITS).o entry_$(BITS).o syscalls_$(BITS).o os-Linux/
arch/x86/um/nommu/entry_64.S +2 -0
@@ -86,6 +86,8 @@ END(__kernel_vsyscall) */ ENTRY(userspace) + /* set stack and pt_regs to the current task */ + call arch_set_stack_to_current /* clear direction flag to meet ABI */ cld /* align the stack for x86_64 ABI */
arch/x86/um/nommu/syscalls.h +2 -0
@@ -13,4 +13,6 @@extern long current_top_of_stack;extern long current_ptregs; +void arch_set_stack_to_current (void ); +#endif
arch/x86/um/nommu/syscalls_64.c new file +50 -0
50 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v13 7/13 um: nommu: configure fs register on host syscall invocation
In reply to Hajime TazakiAs userspace on UML/!MMU also need to configure %fs register when it is running to correctly access thread structure, host syscalls implemented in os-Linux drivers may be puzzled when they are called. Thus it has to configure %fs register via arch_prctl(SET_FS) on every host syscalls.
--- arch/um/include/shared/os.h | 6 +++ arch/um/os-Linux/process.c | 6 +++ arch/um/os-Linux/start_up.c | 21 +++++++++ arch/x86/um/nommu/do_syscall_64.c | 37 ++++++++++++++++ arch/x86/um/nommu/syscalls_64.c | 71 +++++++++++++++++++++++++++++++ 5 files changed, 141 insertions(+)
arch/um/include/shared/os.h +6 -0
@@ -189,6 +189,7 @@ extern void check_host_supports_tls(int *supports_tls, int *tls_min);extern void get_host_cpu_features (void (*flags_helper_func)(char *line),void (*cache_helper_func)(char *line)); +extern int host_has_fsgsbase;/* mem.c */ extern int create_mem_file (unsigned long long len);
@@ -213,6 +214,11 @@ extern int os_protect_memory(void *addr, unsigned long len,extern int os_unmap_memory (void *addr,int len);extern int os_drop_memory (void *addr,int length);extern int can_drop_memory (void ); +extern int os_arch_prctl (int pid,int option,unsigned long *arg); +#ifndef CONFIG_MMU +extern long long host_fs; +#endif +void os_set_pdeathsig (void );
arch/um/os-Linux/process.c +6 -0
@@ -18,6 +18,7 @@#include <sys/prctl.h> #include <sys/wait.h> #include <asm/unistd.h> +#include <sys/syscall.h> /* For SYS_xxx definitions */ #include <linux/threads.h> #include <init.h> #include <longjmp.h>
@@ -179,6 +180,11 @@ int __init can_drop_memory(void)return ok; } +int os_arch_prctl (int pid,int option,unsigned long *arg2) +{ +return syscall (SYS_arch_prctl, option, arg2); +} +void init_new_thread_signals (void ) {set_handler (SIGSEGV );
arch/um/os-Linux/start_up.c +21 -0
@@ -20,6 +20,8 @@#include <sys/resource.h> #include <asm/ldt.h> #include <asm/unistd.h> +#include <sys/auxv.h> +#include <asm/hwcap2.h> #include <init.h> #include <os.h> #include <smp.h>
@@ -37,6 +39,8 @@#include <skas.h> #include "internal.h" +int host_has_fsgsbase; +static void ptrace_child (void ) {int ret;
@@ -460,6 +464,20 @@ __uml_setup("seccomp=", uml_seccomp_config," This is insecure and should only be used with a trusted userspace\n\n" ); +static void __init check_fsgsbase (void ) +{ +unsigned long auxv =getauxval (AT_HWCAP2 ); + +os_info ("Checking FSGSBASE instructions..." ); +if (auxv &HWCAP2_FSGSBASE ) { + host_has_fsgsbase =1 ; +os_info ("OK\n" ); + }else { + host_has_fsgsbase =0 ; +os_info ("disabled\n" ); + } +} +void __init os_early_checks (void ) {int pid;
@@ -488,6 +506,9 @@ void __init os_early_checks(void) using_seccomp =0 ;check_ptrace (); +/* probe fsgsbase instruction */ +check_fsgsbase (); + pid =start_ptraced_child ();if (init_pid_registers (pid))fatal ("Failed to initialize default registers" );
arch/x86/um/nommu/do_syscall_64.c +37 -0
@@ -2,10 +2,38 @@#include <linux/kernel.h> #include <linux/ptrace.h> +#include <asm/fsgsbase.h> +#include <asm/prctl.h> #include <kern_util.h> #include <asm/syscall.h> #include <os.h> +static int os_x86_arch_prctl (int pid,int option,unsigned long *arg2) +{ +if (!host_has_fsgsbase) +return os_arch_prctl (pid, option, arg2); + +switch (option) { +case ARCH_SET_FS : +wrfsbase (*arg2); +break ; +case ARCH_SET_GS : +wrgsbase (*arg2); +break ; +case ARCH_GET_FS : + *arg2 =rdfsbase (); +break ; +case ARCH_GET_GS : + *arg2 =rdgsbase (); +break ; +default : +pr_warn ("%s: unsupported option: 0x%x" , __func__, option); +break ; + } + +return 0 ; +} + __visible void do_syscall_64(struct pt_regs *regs) {int syscall;
@@ -13,6 +41,9 @@ __visible void do_syscall_64(struct pt_regs *regs) syscall =PT_SYSCALL_NR (regs->regs.gp);UPT_SYSCALL_NR (®s->regs) = syscall; +/* set fs register to the original host one */ +os_x86_arch_prctl (0 ,ARCH_SET_FS , (void *)host_fs); +if (likely (syscall < NR_syscalls)) {unsigned long ret;
@@ -29,4 +60,10 @@ __visible void do_syscall_64(struct pt_regs *regs)/* handle tasks and signals at the end */ interrupt_end (); + +/* restore back fs register to userspace configured one */ +os_x86_arch_prctl (0 ,ARCH_SET_FS , + (void *)(current->thread.regs.regs.gp[FS_BASE + /sizeof (unsigned long )])); + }
arch/x86/um/nommu/syscalls_64.c +71 -0
82 lines not on this page · raw message
Signature · 1 line
2.43.0
PATCH v13 8/13 x86/um/vdso: nommu: vdso memory update
In reply to Hajime TazakiOn !MMU mode, the address of vdso is accessible from userspace. This commit implements the entry point by pointing a block of page address.
This commit also add memory permission configuration of vdso page to be executable.
--- arch/x86/um/vdso/vma.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)
arch/x86/um/vdso/vma.c +15 -2
@@ -9,6 +9,7 @@#include <asm/page.h> #include <asm/elf.h> #include <linux/init.h> +#include <os.h> unsigned long um_vdso_addr;static struct page *um_vdso;
@@ -20,18 +21,29 @@ static int __init init_vdso(void) {BUG_ON (vdso_end - vdso_start >PAGE_SIZE ); - um_vdso_addr = task_size -PAGE_SIZE ; - um_vdso =alloc_page (GFP_KERNEL );if (!um_vdso)panic ("Cannot allocate vdso\n" );copy_page (page_address (um_vdso), vdso_start); +#ifdef CONFIG_MMU + um_vdso_addr = task_size -PAGE_SIZE ; +#else +/* this is fine with NOMMU as everything is accessible */ + um_vdso_addr = (unsigned long )page_address (um_vdso); +os_protect_memory ((void *)um_vdso_addr, vdso_end - vdso_start,1 ,0 ,1 ); +#endif + +pr_info ("vdso_start=%lx um_vdso_addr=%lx pg_um_vdso=%lx" , + (unsigned long )vdso_start, um_vdso_addr, + (unsigned long )page_address (um_vdso)); +return 0 ; }subsys_initcall (init_vdso); +#ifdef CONFIG_MMU int arch_setup_additional_pages (struct linux_binprm *bprm,int uses_interp) {struct vm_area_struct *vma;
@@ -53,3 +65,4 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) return IS_ERR(vma) ? PTR_ERR(vma) : 0; } +#endif
Signature · 1 line
2.43.0
PATCH v13 9/13 x86/um: nommu: signal handling
In reply to Hajime TazakiThis commit updates the behavior of signal handling under !MMU environment. It adds the alignment code for signal frame as the frame is used in userspace as-is.
floating point register is carefully handling upon entry/leave of syscall routine so that signal handlers can read/write the contents of the register.
It also adds the follow up routine for SIGSEGV as a signal delivery runs in the same stack frame while we have to avoid endless SIGSEGV.
--- arch/um/include/shared/kern_util.h | 4 + arch/um/nommu/Makefile | 2 +- arch/um/nommu/os-Linux/signal.c | 8 + arch/um/nommu/trap.c | 201 ++++++++++++++++++++++++++ arch/um/os-Linux/signal.c | 3 +- arch/x86/um/nommu/do_syscall_64.c | 6 + arch/x86/um/nommu/os-Linux/mcontext.c | 11 ++ arch/x86/um/shared/sysdep/mcontext.h | 1 + arch/x86/um/shared/sysdep/ptrace.h | 2 +- 9 files changed, 235 insertions(+), 3 deletions(-) create mode 100644 arch/um/nommu/trap.c
arch/um/include/shared/kern_util.h +4 -0
@@ -70,4 +70,8 @@ void um_idle_sleep(void);void kasan_map_memory (void *start,size_t len); +#ifndef CONFIG_MMU +extern void nommu_relay_signal (void *ptr); +#endif +#endif
arch/um/nommu/Makefile +1 -1
@@ -1,3 +1,3 @@ # SPDX-License-Identifier: GPL-2.0 -obj-y := os-Linux/ +obj-y := trap.o os-Linux/
arch/um/nommu/os-Linux/signal.c +8 -0
@@ -5,6 +5,7 @@#include <os.h> #include <sysdep/mcontext.h> #include <sys/ucontext.h> +#include <as-layout.h> void sigsys_handler (int sig,struct siginfo *si,struct uml_pt_regs *regs,void *ptr)
@@ -14,3 +15,10 @@ void sigsys_handler(int sig, struct siginfo *si,/* hook syscall via SIGSYS */ set_mc_sigsys_hook (mc); } + +void nommu_relay_signal (void *ptr) +{ +mcontext_t *mc = (mcontext_t *) ptr; + +set_mc_relay_signal (mc); +}
arch/um/nommu/trap.c new file +201 -0
201 lines not on this page · raw message
arch/um/os-Linux/signal.c +2 -1
@@ -41,9 +41,10 @@ static void sig_handler_common(int sig, struct siginfo *si, mcontext_t *mc)int save_errno = errno; r.is_user =0 ; +if (mc) +get_regs_from_mc (&r, mc);if (sig ==SIGSEGV ) {/* For segfaults, we want the data from the sigcontext. */ -get_regs_from_mc (&r, mc);GET_FAULTINFO_FROM_MC (r.faultinfo, mc); }
arch/x86/um/nommu/do_syscall_64.c +6 -0
@@ -44,6 +44,9 @@ __visible void do_syscall_64(struct pt_regs *regs)/* set fs register to the original host one */ os_x86_arch_prctl (0 ,ARCH_SET_FS , (void *)host_fs); +/* save fp registers */ + asmvolatile ("fxsaveq %0" :"=m" (*(struct _xstate *)regs->regs.fp)); +if (likely (syscall < NR_syscalls)) {unsigned long ret;
@@ -61,6 +64,9 @@ __visible void do_syscall_64(struct pt_regs *regs)/* handle tasks and signals at the end */ interrupt_end (); +/* restore fp registers */ + asmvolatile ("fxrstorq %0" : :"m" ((current->thread.regs.regs.fp))); +/* restore back fs register to userspace configured one */ os_x86_arch_prctl(0, ARCH_SET_FS, (void *)(current->thread.regs.regs.gp[FS_BASE
arch/x86/um/nommu/os-Linux/mcontext.c +11 -0
@@ -4,10 +4,21 @@#include <asm/ptrace.h> #include <sysdep/ptrace.h> #include <sysdep/mcontext.h> +#include <os.h> +#include "../syscalls.h" extern long __kernel_vsyscall (int64_t a0,int64_t a1,int64_t a2,int64_t a3,int64_t a4,int64_t a5,int64_t a6); +void set_mc_relay_signal (mcontext_t *mc) +{ +/* configure stack and userspace returning routine as +* instruction pointer +*/ + mc->gregs[REG_RSP ] = (unsigned long ) current_top_of_stack; + mc->gregs[REG_RIP ] = (unsigned long ) userspace; +} +void set_mc_sigsys_hook (mcontext_t *mc) { mc->gregs[REG_RCX ] = mc->gregs[REG_RIP ];
arch/x86/um/shared/sysdep/mcontext.h +1 -0
@@ -19,6 +19,7 @@ extern int set_stub_state(struct uml_pt_regs *regs, struct stub_data *data,#ifndef CONFIG_MMU extern void set_mc_sigsys_hook (mcontext_t *mc); +extern void set_mc_relay_signal (mcontext_t *mc);#endif #ifdef __i386__
arch/x86/um/shared/sysdep/ptrace.h +1 -1
@@ -53,7 +53,7 @@ struct uml_pt_regs {int is_user;/* Dynamically sized FP registers (holds an XSTATE) */ -unsigned long fp[]; + unsigned long fp[] __attribute__((aligned(16))); };#define EMPTY_UML_PT_REGS { }
Signature · 1 line
2.43.0
PATCH v13 10/13 um: change machine name for uname output
In reply to Hajime TazakiThis commit tries to display MMU/!MMU mode from the output of uname(2) so that users can distinguish which mode of UML is running right now.
--- arch/um/Makefile | 6 ++++++ arch/um/os-Linux/util.c | 3 ++- 2 files changed, 8 insertions(+), 1 deletion(-)
arch/um/Makefile +6 -0
@@ -153,6 +153,12 @@ export CFLAGS_vmlinux := $(LINK-y) $(LINK_WRAPS) $(LD_FLAGS_CMDLINE) $(CC_FLAGS_ CLEAN_FILES += linux x.i gmon.out MRPROPER_FILES += $(HOST_DIR)/include/generated +ifeq ($(CONFIG_MMU),y) +UTS_MACHINE := "um" +else +UTS_MACHINE := "um\(nommu\)" +endif + archclean: @find . \( -name '*.bb' -o -name '*.bbg' -o -name '*.da' \ -o -name '*.gcov' \) -type f -print | xargs rm -f
arch/um/os-Linux/util.c +2 -1
@@ -64,7 +64,8 @@ void setup_machinename(char *machine_out) }# endif #endif -strcpy (machine_out, host.machine); +strcat (machine_out,"/" ); +strcat (machine_out, host.machine); }void setup_hostinfo (char *buf,int len)
Signature · 1 line
2.43.0
PATCH v13 11/13 um: nommu: disable SMP on nommu UML
In reply to Hajime TazakiCONFIG_SMP doesn't work with nommu UML since fs register handling of host does conflict with thread local storage (more specifically, the variable signals_enabled).
Thus this commit disables the CONFIG option and the TLS variables.
--- arch/um/os-Linux/internal.h | 8 ++++++++ arch/x86/um/Kconfig | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-)
arch/um/os-Linux/internal.h +8 -0
@@ -6,6 +6,14 @@#include <stub-data.h> #include <signal.h> +/* NOMMU doesn't work with thread-local storage used in CONFIG_SMP, +* due to the dependency on host_fs variable switch upon user/kernel +* context so, disable TLS until NOMMU supports SMP. +*/ +#ifndef CONFIG_MMU +#define __thread +#endif +/* * elf_aux.c */
arch/x86/um/Kconfig +1 -1
@@ -12,7 +12,7 @@ config UML_X86 select ARCH_USE_QUEUED_SPINLOCKS select DCACHE_WORD_ACCESS select HAVE_EFFICIENT_UNALIGNED_ACCESS - select UML_SUBARCH_SUPPORTS_SMP if X86_CX8 + select UML_SUBARCH_SUPPORTS_SMP if X86_CX8 && MMU config 64BIT bool "64-bit kernel" if "$(SUBARCH)" = "x86"
Signature · 1 line
2.43.0
PATCH v13 12/13 um: nommu: add documentation of nommu UML
In reply to Hajime TazakiThis commit adds an initial documentation for !MMU mode of UML.
--- Documentation/virt/uml/nommu-uml.rst | 180 +++++++++++++++++++++++++++ MAINTAINERS | 1 + 2 files changed, 181 insertions(+) create mode 100644 Documentation/virt/uml/nommu-uml.rst
Documentation/virt/uml/nommu-uml.rst new file +180 -0
@@ -0,0 +1,180 @@ +.. SPDX-License-Identifier: GPL-2.0 + +UML has been built with CONFIG_MMU since day 0. The patchset +introduces the nommu mode on UML in a different angle from what Linux +Kernel Library tried. + +.. contents:: :local: + +What is it for ? +================ + +- Alleviate syscall hook overhead implemented with ptrace(2) +- To exercises nommu code over UML (and over KUnit) +- Less dependency to host facilities + + +How it works ? +============== + +To illustrate how this feature works, the below shows how syscalls are +called under nommu/UML environment. + +- boot kernel, install seccomp filter if ``syscall`` instructions are + called from userspace memory based on the address of instruction + pointer +- (userspace starts) +- calls ``vfork``/``execve`` syscalls +- ``SIGSYS`` signal raised, handler calls syscall entry point ``__kernel_vsyscall`` +- call handler function in ``sys_call_table[]`` and follow how UML syscall + works. +- return to userspace + + +What are the differences from MMU-full UML ? +============================================ + +The current nommu implementation adds 3 different functions which +MMU-full UML doesn't have: + +- kernel address space can directly be accessible from userspace + - so, ``uaccess()`` always returns 1 + - generic implementation of memcpy/strcpy/futex is also used +- alternate syscall entrypoint without ptrace +- alternate syscall hook + - hook syscall by seccomp filter + +With those modifications, it allows us to use unmodified userspace +binaries with nommu UML. + + +History +======= + +This feature was originally introduced by Ricardo Koller at Open +Source Summit NA 2020, then integrated with the syscall translation +functionality with the clean up to the original code. + +Building and run +================ + +:: + + make ARCH=um x86_64_nommu_defconfig + make ARCH=um + +will build UML with ``CONFIG_MMU=n`` applied. + +Kunit tests can run with the following command:: + + ./tools/testing/kunit/kunit.py run --kconfig_add CONFIG_MMU=n + +To run a typical Linux distribution, we need nommu-aware userspace. +We can use a stock version of Alpine Linux with nommu-built version of +busybox and musl-libc. + + +Preparing root filesystem +========================= + +nommu UML requires to use a specific standard library which is aware +of nommu kernel. We have tested custom-build musl-libc and busybox, +both of which have built-in support for nommu kernels. + +There are no available Linux distributions for nommu under x86_64 +architecture, so we need to prepare our own image for the root +filesystem. We use Alpine Linux as a base distribution and replace +busybox and musl-libc on top of that. The following are the step to +prepare the filesystem for the quick start:: + + container_id=$(docker create ghcr.io/thehajime/alpine:3.20.3-um-nommu) + docker start $container_id + docker wait $container_id + docker export $container_id > alpine.tar + docker rm $container_id + + mnt=$(mktemp -d) + dd if=/dev/zero of=alpine.ext4 bs=1 count=0 seek=1G + sudo chmod og+wr "alpine.ext4" + yes 2>/dev/null | mkfs.ext4 "alpine.ext4" || true + sudo mount "alpine.ext4" $mnt + sudo tar -xf alpine.tar -C $mnt + sudo umount $mnt + +This will create a file image, ``alpine.ext4``, which contains busybox +and musl with nommu build on the Alpine Linux root filesystem. The +file can be specified to the argument ``ubd0=`` to the UML command line:: + + ./vmlinux ubd0=./alpine.ext4 rw mem=1024m loglevel=8 init=/sbin/init + +We plan to upstream apk packages for busybox and musl so that we can +follow the proper procedure to set up the root filesystem. + + +Quick start with docker +======================= + +There is a docker image that you can quickly start with a simple step:: + + docker run -it -v /dev/shm:/dev/shm --rm ghcr.io/thehajime/alpine:3.20.3-um-nommu + +This will launch a UML instance with an pre-configured root filesystem. + +Benchmark +========= + +The below shows an example of performance measurement conducted with +lmbench and (self-crafted) getpid benchmark (with v6.17-rc5 uml/next +tree). + +.. csv-table:: lmbench (usec) + :header: ,native,um,um-mmu(s),um-nommu(s) + + select-10 ,0.5319,36.1214,24.2795,2.9174 + select-100 ,1.6019,34.6049,28.8865,3.8080 + select-1000 ,12.2588,43.6838,48.7438,12.7872 + syscall ,0.1644,35.0321,53.2119,2.5981 + read ,0.3055,31.5509,45.8538,2.7068 + write ,0.2512,31.3609,29.2636,2.6948 + stat ,1.8894,43.8477,49.6121,3.1908 + open/close ,3.2973,77.5123,68.9431,6.2575 + fork+sh ,1110.3000,7359.5000,4618.6667,439.4615 + fork+execve ,510.8182,2834.0000,2461.1667,139.7848 + +.. csv-table:: do_getpid bench (nsec) + :header: ,native,um,um-mmu(s),um-nommu(s) + + getpid , 161 , 34477 , 26242 , 2599 + +(um-nommu(s) is with seccomp syscall hook, um-mmu(s) is SECCOMP mode, +respectively) + +Limitations +=========== + +generic nommu limitations +------------------------- +Since this port is a kernel of nommu architecture so, the +implementation inherits the characteristics of other nommu kernels +(riscv, arm, etc), described below. + +- vfork(2) should be used instead of fork(2) +- ELF loader only loads PIE (position independent executable) binaries +- processes share the address space among others +- mmap(2) offers a subset of functionalities (e.g., unsupported + MMAP_FIXED) + +Thus, we have limited options to userspace programs. We have tested +Alpine Linux with musl-libc, which has a support nommu kernel. + +supported architecture +---------------------- +The current implementation of nommu UML only works on x86_64 SUBARCH. +We have not tested with 32-bit environment. + + +Further readings about NOMMU UML +================================ + +- NOMMU UML (original code by Ricardo Koller) + - https://static.sched.com/hosted_files/ossna2020/ec/kollerr_linux_um_nommu.pdf
MAINTAINERS +1 -0
@@ -26764,6 +26764,7 @@ USER-MODE LINUX (UML) M: Richard Weinberger <[email protected]> M: Anton Ivanov <[email protected]> M: Johannes Berg <[email protected]> +M: Hajime Tazaki <[email protected]> L: [email protected] S: Maintained W: http://user-mode-linux.sourceforge.net
Signature · 1 line
2.43.0
PATCH v13 13/13 um: nommu: plug nommu code into build system
In reply to Hajime TazakiAdd nommu kernel for um build. defconfig is also provided.
--- arch/um/Kconfig | 14 ++++++- arch/um/configs/x86_64_nommu_defconfig | 54 ++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 2 deletions(-) create mode 100644 arch/um/configs/x86_64_nommu_defconfig
arch/um/Kconfig +12 -2
@@ -34,16 +34,19 @@ config UML select ARCH_SUPPORTS_LTO_CLANG_THIN select TRACE_IRQFLAGS_SUPPORT select TTY # Needed for line.c - select HAVE_ARCH_VMAP_STACK + select HAVE_ARCH_VMAP_STACK if MMU select HAVE_RUST select ARCH_HAS_UBSAN select HAVE_ARCH_TRACEHOOK select HAVE_SYSCALL_TRACEPOINTS select THREAD_INFO_IN_TASK select SPARSE_IRQ + select UACCESS_MEMCPY if !MMU + select GENERIC_STRNLEN_USER if !MMU + select GENERIC_STRNCPY_FROM_USER if !MMU config MMU - bool + bool "MMU-based Paged Memory Management Support" if 64BIT default y config UML_DMA_EMULATION
@@ -225,8 +228,15 @@ config MAGIC_SYSRQ The keys are documented in <file:Documentation/admin-guide/sysrq.rst>. Don't say Y unless you really know what this hack does. +config ARCH_FORCE_MAX_ORDER + int "Order of maximal physically contiguous allocations" if EXPERT + default "10" if MMU + default "16" if !MMU + config KERNEL_STACK_ORDER int "Kernel stack size order" + default 3 if !MMU + range 3 10 if !MMU default 2 if 64BIT range 2 10 if 64BIT default 1 if !64BIT
arch/um/configs/x86_64_nommu_defconfig new file +54 -0
54 lines not on this page · raw message
Signature · 1 line
2.43.0
Quoted 2 lines · Hajime Tazaki
This patchset is another spin of nommu mode addition to UML. It would be nice to hear about your opinions on that.
I've not seen any explanation of the use case and/or benefits anywhere in this cover letter or the patches. Without that it's usually pretty hard to get maintainers and reviewers excited.
Hello,
Quoted 8 lines · Christoph Hellwig
Quoted 2 lines · Hajime Tazaki
This patchset is another spin of nommu mode addition to UML. It would be nice to hear about your opinions on that.
I've not seen any explanation of the use case and/or benefits anywhere in this cover letter or the patches. Without that it's usually pretty hard to get maintainers and reviewers excited.
thank you for the comment. I tried to include this explanation in the document patch [12/13], which I copied from the text below.
What is it for ?
================
- Alleviate syscall hook overhead implemented with ptrace(2)
- To exercises nommu code over UML (and over KUnit)
- Less dependency to host facilities
the first item is for speed up, the second item is for more testing, the last item is for more extensibility in the future.
Early version of this patchset included this information as well as the whole documentation, but I removed it as the versions grow. But I can revert it to the cover letter if it helps.
-- Hajime
Johannes Berg
maintainerQuoted 7 lines · Hajime Tazaki
What is it for ?
================- Alleviate syscall hook overhead implemented with ptrace(2)
- To exercises nommu code over UML (and over KUnit)
- Less dependency to host facilities
FWIW, in some way, this order of priorities is exactly why this hasn't been going anywhere, and every time I looked at it I got somewhat annoyed by what seems to me like choices made to support especially the first bullet.
I suspect that the first and third bullet are not even really true any more, since you moved to seccomp (per our request), yet I think design choices influenced by them persist.
People are definitely interested in the second bullet, mostly for kunit, and I'd be willing to support them in that to some extent.
However, I'm not yet convinced that all of the complexities presented in this patchset (such as completely separate seccomp implementation) are actually necessary in support of _just_ the second bullet. These seem to me like design choices necessary to support the _first_ bullet [1].
[1] and then I suppose the third, which I'm reading as "doesn't need seccomp or ptrace", but I'm not really quite sure what you meant
I've thought about what would happen if we stuck to creating a (single) separate process on the host to execute userspace, and just used CLONE_VM for it. That way, it's still no-MMU with full memory access, but there's some implicit isolation between the kernel and userspace processes which will likely remove complexities around FP/SSE/AVX handling, may completely remove the need for a separate seccomp implementation, etc.
It would, on the other hand, make it completely non-viable to achieve the first and third bullets, so given your pursuit of those, one some level I understand the design right now. I'm yet to be convinced, however, that those are even worthy goals for (upstream) UML, what use case would that enable that we really need? Especially considering that over a longer perspective, NOMMU architectures _are_ on their way out, and UML will certainly follow once that happens, it won't be the last remaining NOMMU architecture.
So the only value I see in this is for testing over the net couple of years, which really doesn't need any sort of significant optimisation or less reliance on host facilities.
Where do you see this differently?
johannes
Quoted 6 lines · Johannes Berg
Quoted 4 lines · Hajime Tazaki
What is it for ?
================
Quoted 8 lines
Quoted 3 lines
- Alleviate syscall hook overhead implemented with ptrace(2)
- To exercises nommu code over UML (and over KUnit)
- Less dependency to host facilitiesFWIW, in some way, this order of priorities is exactly why this hasn't been going anywhere, and every time I looked at it I got somewhat annoyed by what seems to me like choices made to support especially the first bullet.
over the past versions, I've been emphasized that the 2nd bullet (testing) is the primary usecase as I saw several actually cases from mm folks,
https://lists.infradead.org/pipermail/maple-tree/2024-November/003775.html
https://lore.kernel.org/all/[email protected]/
and I think this is not limited to mm code.
other 2 bullets are additional benefits which we observed in a comment, and our experience.
https://lore.kernel.org/all/[email protected]/
[2] https://static.sched.com/hosted_files/ossna2020/ec/kollerr_linux_um_nommu.pdf
but those are not the primary goal, so I'm not pushing this aspect with usecases.
Quoted 3 lines
I suspect that the first and third bullet are not even really true any more, since you moved to seccomp (per our request), yet I think design choices influenced by them persist.
this observation is not true; the first bullet is still true even using seccomp. please look at the benchmark result in the patch [12/13], quoted below.
summary: most of tests show that um-nommu+seccomp is x4 to x20 faster than um-mmu+seccomp (and ptrace).
.. csv-table:: lmbench (usec)
:header: ,native,um,um-mmu(s),um-nommu(s)
select-10 ,0.5319,36.1214,24.2795,2.9174 select-100 ,1.6019,34.6049,28.8865,3.8080 select-1000 ,12.2588,43.6838,48.7438,12.7872 syscall ,0.1644,35.0321,53.2119,2.5981 read ,0.3055,31.5509,45.8538,2.7068 write ,0.2512,31.3609,29.2636,2.6948 stat ,1.8894,43.8477,49.6121,3.1908 open/close ,3.2973,77.5123,68.9431,6.2575 fork+sh ,1110.3000,7359.5000,4618.6667,439.4615 fork+execve ,510.8182,2834.0000,2461.1667,139.7848
.. csv-table:: do_getpid bench (nsec)
:header: ,native,um,um-mmu(s),um-nommu(s)
getpid , 161 , 34477 , 26242 , 2599
the 1st bullet saying ptrace(2) is somehow misleading now. this might be rephrased with "a separate process handling userspace", instead of "ptrace".
# when I started this patchset, the seccomp patch wasn't in upstream. saying ptrace(2) wasn't not that much wrong.
Quoted 2 lines
People are definitely interested in the second bullet, mostly for kunit, and I'd be willing to support them in that to some extent.
so (again) the 2nd bullet is the primary use case at this stage.
Quoted 4 lines
However, I'm not yet convinced that all of the complexities presented in this patchset (such as completely separate seccomp implementation) are actually necessary in support of _just_ the second bullet. These seem to me like design choices necessary to support the _first_ bullet [1].
separate seccomp implementation is indeed needed due to the design choice we made, to use a single process to host a (um) userspace. I think there is no reason to unify the seccomp part because the signal handlers and filter installation do the different jobs.
I don't see why you see this as a _complexity_, as functionally both seccomp handling don't interfere each other. we have prepared separate sub-directories for nommu to avoid unnecessary if/else clauses in .c/.h files. we haven't seen any functional regressions since this RFC version (which was 6.12 kernel).
Quoted 10 lines
[1] and then I suppose the third, which I'm reading as "doesn't need seccomp or ptrace", but I'm not really quite sure what you meant
I've thought about what would happen if we stuck to creating a (single) separate process on the host to execute userspace, and just used
CLONE_VMfor it. That way, it's still no-MMU with full memory access, but there's some implicit isolation between the kernel and userspace processes which will likely remove complexities around FP/SSE/AVX handling, may completely remove the need for a separate seccomp implementation, etc.
this would be doable I think, but we went the different way, as using separate host processes (with ptrace/seccomp) is slow and add complexity by the synchronization between processes, which we think it's not easy to maintain in the future.
this was natural for us (not sure for maintainers) when we add a new functionality, consider several options to implement, and took one of the option which is faster, simpler, and having less cost to maintain.
the avoidance of separate processes is probably the core of our design choice we made for nommu UML. I'm not strongly pushing the benefits of 1st/3rd bullets, but I thought describing the characteristics of what _this_ patchset can should be useful. thus in the document.
additionally, if the design choice we made introduces any breakages on existing code, or maintenance burdens, I would understand your concern on the complexity, but I don't think this is the case.
Quoted 5 lines
It would, on the other hand, make it completely non-viable to achieve the first and third bullets, so given your pursuit of those, one some level I understand the design right now. I'm yet to be convinced, however, that those are even worthy goals for (upstream) UML, what use case would that enable that we really need?
the usecase for those are inherited from the original implementation,
[2] above, which is running UML on containers with less host dependency and speedups. but again, this is not the primary goal at this stage.
if you think that the document should not describe the potential benefits/usecases which are not related to the primary goal of the functionality, I'd agree to remove those descriptions.
Quoted 4 lines
Especially considering that
over a longer perspective, NOMMU architectures _are_ on their way out, and UML will certainly follow once that happens, it won't be the last remaining NOMMU architecture.
I'm aware of this nommu removal discussion, but also saw there are expressions not to support this direction. This patchset is still useful even now.
Quoted 3 lines
So the only value I see in this is for testing over the net couple of years, which really doesn't need any sort of significant optimisation or less reliance on host facilities.
I agree the former, but not the latter.
- there is a value with a real usecase,
- there are different ways to implement it but this went with the one with potential (additional) benefits,
- without breakages to the exising (MMU) uml code.
with that, we're proposing this patchset.
Quoted 1 line
Where do you see this differently?
thanks for the careful prompt for me.
I hope my answer clarifies your concerns.
I also wish to understand concerns of maintainers, due to the single process design of nommu for um userspace, and the codebase is still young so may have unexpected influence to others. but this is exactly the reason why I also put myself to MAINTAINERS in order to take care of this patchset even it is small (1.3k loc).
-- Hajime
On Wed, 12 Nov 2025 17:52:56 +0900, Hajime Tazaki wrote:
[...]
Quoted 10 lines
Quoted 4 lines
However, I'm not yet convinced that all of the complexities presented in this patchset (such as completely separate seccomp implementation) are actually necessary in support of _just_ the second bullet. These seem to me like design choices necessary to support the _first_ bullet [1].
separate seccomp implementation is indeed needed due to the design choice we made, to use a single process to host a (um) userspace. I think there is no reason to unify the seccomp part because the signal handlers and filter installation do the different jobs.
Quoted 4 lines
I don't see why you see this as a _complexity_, as functionally both seccomp handling don't interfere each other. we have prepared separate sub-directories for nommu to avoid unnecessary if/else clauses in .c/.h files.
I have the same concern about the complexities introduced by this patch set. The new processing paths it introduces (such as the separate handling for FP/SSE/AVX, FS, signal, syscall, ...) add a lot of unnecessary complexities. I think Johannes's suggestion is a great idea.
Quoted 2 lines
we haven't seen any functional regressions
since this RFC version (which was 6.12 kernel).
I took a quick look at the code. It appears that patch 02/13 will break the mmu build when UML_TIME_TRAVEL_SUPPORT is enabled.
Regards,
Tiwei
Quoted 5 lines · Tiwei Bie
Quoted 2 lines
we haven't seen any functional regressions
since this RFC version (which was 6.12 kernel).I took a quick look at the code. It appears that patch 02/13 will break the mmu build when
UML_TIME_TRAVEL_SUPPORTis enabled.
thanks, it is my bad on the move the chunk.
will fix it and added to my local test.
-- Hajime
Johannes Berg
maintainerQuoted 12 lines · Hajime Tazaki
Quoted 11 lines
Quoted 6 lines
What is it for ?
================- Alleviate syscall hook overhead implemented with ptrace(2)
- To exercises nommu code over UML (and over KUnit)
- Less dependency to host facilitiesFWIW, in some way, this order of priorities is exactly why this hasn't been going anywhere, and every time I looked at it I got somewhat annoyed by what seems to me like choices made to support especially the first bullet.
Quoted 7 lines
over the past versions, I've been emphasized that the 2nd bullet (testing) is the primary usecase as I saw several actually cases from mm folks,
https://lists.infradead.org/pipermail/maple-tree/2024-November/003775.html
https://lore.kernel.org/all/[email protected]/and I think this is not limited to mm code.
Not sure there's much value in testing much else in no-MMU, but sure, I'll give you that it's useful for testing.
Quoted 2 lines
other 2 bullets are additional benefits which we observed in a comment, and our experience.
But are they really _worthwhile_ benefits? A lot of this design adds additional complexity, and it doesn't really seem necessary for the testing use case. Making it faster is nice, but it's not like the speedup really is 20x for arbitrary tests, that's just for corner cases like "sit in a loop of gettimeofday()". And for kunit there's no syscall boundary at all, so there's no speedup.
Quoted 9 lines
Quoted 3 lines
I suspect that the first and third bullet are not even really true any more, since you moved to seccomp (per our request), yet I think design choices influenced by them persist.
this observation is not true; the first bullet is still true even using seccomp. please look at the benchmark result in the patch [12/13], quoted below.
[snip]
So thanks for the correction. If that's the case, however, it means the speedup can't be due to the syscall boundary itself (seccomp) but must rather be due to some pagefault/mapping handling issue? Which would be inherent in no-MMU, even taking an approach of using two host processes rather than embedding everything into one.
Quoted 7 lines
Quoted 4 lines
However, I'm not yet convinced that all of the complexities presented in this patchset (such as completely separate seccomp implementation) are actually necessary in support of _just_ the second bullet. These seem to me like design choices necessary to support the _first_ bullet [1].
separate seccomp implementation is indeed needed due to the design choice we made, to use a single process to host a (um) userspace.
That sounds misleading or even wrong to me, I'd say it's due to putting the (um) userspace in the same host process as the kernel space?
Quoted 2 lines
I don't see why you see this as a _complexity_, as functionally both seccomp handling don't interfere each other.
The complexity isn't so much in the separate code, which is a small factor, but in the "put everything into the same process" aspect of it. That has consequences around the host context state handling, things we didn't really need to consider before suddenly become crucially important. In the current (with-MMU) design, we only need to worry about being able to correctly switch between userspace tasks/threads within a userspace mm (host) process. With the no-MMU design you propose, we also need to be able to correctly switch between kernel and userspace tasks within the same single (host) process.
I think this is a pretty significant difference, and saying "there's no complexity here" is simply pretending it isn't a relevant difference. I believe you're not even handling this correctly right now in this patch set, specifically wrt. the GS register which has been pointed out before, but I wouldn't say that I even have a complete picture in my head over what state handling would be necessary and sufficient.
So yeah, I think this warrants taking another look as to whether or not the approach of putting everything into the same host process is even worth it. I tend to believe that it isn't, given the use cases. And if you say the speedup still is with seccomp, that kills the speed argument too.
Quoted 8 lines
Quoted 7 lines
I've thought about what would happen if we stuck to creating a (single) separate process on the host to execute userspace, and just used
CLONE_VMfor it. That way, it's still no-MMU with full memory access, but there's some implicit isolation between the kernel and userspace processes which will likely remove complexities around FP/SSE/AVX handling, may completely remove the need for a separate seccomp implementation, etc.
Quoted 4 lines
this would be doable I think, but we went the different way, as using separate host processes (with ptrace/seccomp) is slow and add complexity by the synchronization between processes, which we think it's not easy to maintain in the future.
Which one is it then, slow or not? Not sure I follow. You just said you do have seccomp when comparing speeds, so that in itself doesn't make it slow. What synchronization? It'd (have to) be CLONE_VM, but that actually _simplifies_ state transfer/synchronization, and we already have (to have) state transfer between different userspace threads in the same host process for the with-MMU case.
johannes
Quoted 17 lines · Johannes Berg
Quoted 15 lines · Hajime Tazaki
Quoted 11 lines
Quoted 6 lines
What is it for ?
================- Alleviate syscall hook overhead implemented with ptrace(2)
- To exercises nommu code over UML (and over KUnit)
- Less dependency to host facilitiesFWIW, in some way, this order of priorities is exactly why this hasn't been going anywhere, and every time I looked at it I got somewhat annoyed by what seems to me like choices made to support especially the first bullet.
over the past versions, I've been emphasized that the 2nd bullet (testing) is the primary usecase as I saw several actually cases from mm folks,
Quoted 7 lines
Quoted 4 lines
https://lists.infradead.org/pipermail/maple-tree/2024-November/003775.html
https://lore.kernel.org/all/[email protected]/and I think this is not limited to mm code.
Not sure there's much value in testing much else in no-MMU, but sure, I'll give you that it's useful for testing.
under the tree,
% global -xr CONFIG_MMU | grep ifndef | grep -v -E "arch/|mm/" | wc -l 45
this is a rough picture but there are places to be tested other than mm codebase.
Quoted 9 lines
Quoted 2 lines
other 2 bullets are additional benefits which we observed in a comment, and our experience.
But are they really _worthwhile_ benefits? A lot of this design adds additional complexity, and it doesn't really seem necessary for the testing use case. Making it faster is nice, but it's not like the speedup really is 20x for arbitrary tests, that's just for corner cases like "sit in a loop of
gettimeofday()". And for kunit there's no syscall boundary at all, so there's no speedup.
I agree and as I said the reason to take a single-host-process approach is from the speed and simplicity of removing interaction between host processes.
I have never claimed that tests should execute fast.
and agree that kunit doesn't benefit from speed as there is no syscall (unless kunit-uapi patch will be in).
Quoted 8 lines
Quoted 7 lines
Quoted 3 lines
I suspect that the first and third bullet are not even really true any more, since you moved to seccomp (per our request), yet I think design choices influenced by them persist.
this observation is not true; the first bullet is still true even using seccomp. please look at the benchmark result in the patch [12/13], quoted below.
Quoted 7 lines
Quoted 1 line
[snip]
So thanks for the correction. If that's the case, however, it means the speedup can't be due to the syscall boundary itself (seccomp) but must rather be due to some pagefault/mapping handling issue? Which would be inherent in no-MMU, even taking an approach of using two host processes rather than embedding everything into one.
I'll explain this later in this email.
# nommu doesn't have page fault as there are only physical address.
Quoted 10 lines
Quoted 7 lines
Quoted 4 lines
However, I'm not yet convinced that all of the complexities presented in this patchset (such as completely separate seccomp implementation) are actually necessary in support of _just_ the second bullet. These seem to me like design choices necessary to support the _first_ bullet [1].
separate seccomp implementation is indeed needed due to the design choice we made, to use a single process to host a (um) userspace.
That sounds misleading or even wrong to me, I'd say it's due to putting the (um) userspace in the same host process as the kernel space?
not sure if this is different from my explanation...
Quoted 20 lines
Quoted 2 lines
I don't see why you see this as a _complexity_, as functionally both seccomp handling don't interfere each other.
The complexity isn't so much in the separate code, which is a small factor, but in the "put everything into the same process" aspect of it. That has consequences around the host context state handling, things we didn't really need to consider before suddenly become crucially important. In the current (with-MMU) design, we only need to worry about being able to correctly switch between userspace tasks/threads within a userspace mm (host) process. With the no-MMU design you propose, we also need to be able to correctly switch between kernel and userspace tasks within the same single (host) process.
I think this is a pretty significant difference, and saying "there's no complexity here" is simply pretending it isn't a relevant difference. I believe you're not even handling this correctly right now in this patch set, specifically wrt. the GS register which has been pointed out before, but I wouldn't say that I even have a complete picture in my head over what state handling would be necessary and sufficient.
Quoted 5 lines
So yeah, I think this warrants taking another look as to whether or not the approach of putting everything into the same host process is even worth it. I tend to believe that it isn't, given the use cases. And if you say the speedup still is with seccomp, that kills the speed argument too.
I understand your concern on complexity, thanks for the detail.
the host context state handling is indeed new thing. we've only verified a limited set of code path, with a basic operation with um + drivers and some userspace programs. this should not be perfect at this moment but can be improved.
Quoted 13 lines
Quoted 8 lines
Quoted 7 lines
I've thought about what would happen if we stuck to creating a (single) separate process on the host to execute userspace, and just used
CLONE_VMfor it. That way, it's still no-MMU with full memory access, but there's some implicit isolation between the kernel and userspace processes which will likely remove complexities around FP/SSE/AVX handling, may completely remove the need for a separate seccomp implementation, etc.Quoted 4 lines
this would be doable I think, but we went the different way, as using separate host processes (with ptrace/seccomp) is slow and add complexity by the synchronization between processes, which we think it's not easy to maintain in the future.
Quoted 6 lines
Which one is it then, slow or not? Not sure I follow. You just said you do have seccomp when comparing speeds, so that in itself doesn't make it slow. What synchronization? It'd (have to) be
CLONE_VM, but that actually _simplifies_ state transfer/synchronization, and we already have (to have) state transfer between different userspace threads in the same host process for the with-MMU case.
Since I included speed characteristics in the document, I should explain more on the impact of this, compared to the existing design/implementation of uml.
many documents, articles said uml is slow (uml document in tree also mentioned a bit), but cannot find detailed analysis, so I look closely at how nommu (w/ seccomp) and mmu w/ seccomp behave.
suppose we have a userspace program running under uml (on seccomp-mmu, seccomp-nommu).
struct timespec ts1, ts2; clock_gettime(CLOCK_REALTIME, &ts1); // 1) getpid() // 2) clock_gettime(CLOCK_REALTIME, &ts2); // 3)
# this is a chunk from the benchmark program used in the document.
then collected several events (sched_switch, signal_generate, and sys_enter_futex) via ftrace.
looking at 3 SIGSYS (sig=31) signals on above code, and below is the output of the trace-cmd report.
- frace seecomp-mmu, 2)-3)= 11 usec
uml-userspace-3092637 [002] 1749286.670199: signal_generate: sig=31 errno=0 code=1 comm=uml-userspace pid=3092637 grp=0 res=0 => 1)
uml-userspace-3092637 [002] 1749286.670200: sys_enter_futex: op=FUTEX_WAKE uaddr=0x7fffffffdf8c val=1
uml-userspace-3092637 [002] 1749286.670201: sys_enter_futex: op=FUTEX_WAIT uaddr=0x7fffffffdf8c val=0x00000001 utime=0x00000000
uml-userspace-3092637 [002] 1749286.670202: sched_switch: uml-userspace:3092637 [120] S ==> swapper/2:0 [120]
<idle>-0 [028] 1749286.670203: sched_switch: swapper/28:0 [120] R ==> vmlinux:3092631 [120]
vmlinux-3092631 [028] 1749286.670205: sys_enter_futex: op=FUTEX_WAKE uaddr=0x60b64f8c val=1
vmlinux-3092631 [028] 1749286.670206: sys_enter_futex: op=FUTEX_WAIT uaddr=0x60b64f8c val=0x00000000 utime=0x00000000
vmlinux-3092631 [028] 1749286.670207: sched_switch: vmlinux:3092631 [120] S ==> swapper/28:0 [120]
<idle>-0 [002] 1749286.670209: sched_switch: swapper/2:0 [120] R ==> uml-userspace:3092637 [120]
uml-userspace-3092637 [002] 1749286.670211: signal_generate: sig=31 errno=0 code=1 comm=uml-userspace pid=3092637 grp=0 res=0 => 2)
uml-userspace-3092637 [002] 1749286.670212: sys_enter_futex: op=FUTEX_WAKE uaddr=0x7fffffffdf8c val=1
uml-userspace-3092637 [002] 1749286.670213: sys_enter_futex: op=FUTEX_WAIT uaddr=0x7fffffffdf8c val=0x00000001 utime=0x00000000
uml-userspace-3092637 [002] 1749286.670214: sched_switch: uml-userspace:3092637 [120] S ==> swapper/2:0 [120]
<idle>-0 [028] 1749286.670215: sched_switch: swapper/28:0 [120] R ==> vmlinux:3092631 [120]
vmlinux-3092631 [028] 1749286.670216: sys_enter_futex: op=FUTEX_WAKE uaddr=0x60b64f8c val=1
vmlinux-3092631 [028] 1749286.670217: sys_enter_futex: op=FUTEX_WAIT uaddr=0x60b64f8c val=0x00000000 utime=0x00000000
vmlinux-3092631 [028] 1749286.670218: sched_switch: vmlinux:3092631 [120] S ==> swapper/28:0 [120]
<idle>-0 [002] 1749286.670220: sched_switch: swapper/2:0 [120] R ==> uml-userspace:3092637 [120]
uml-userspace-3092637 [002] 1749286.670222: signal_generate: sig=31 errno=0 code=1 comm=uml-userspace pid=3092637 grp=0 res=0 => 3)- ftrace seccomp-nommu, 2)-3) = 3 usec
vmlinux-3092542 [006] 1749158.829292: signal_generate: sig=31 errno=0 code=1 comm=vmlinux pid=3092542 grp=0 res=0 => 1)
vmlinux-3092542 [006] 1749158.829294: signal_generate: sig=31 errno=0 code=1 comm=vmlinux pid=3092542 grp=0 res=0 => 2)
vmlinux-3092542 [006] 1749158.829297: signal_generate: sig=31 errno=0 code=1 comm=vmlinux pid=3092542 grp=0 res=0 => 3)with seccomp-mmu, a host process for userspace (uml-userspace) is notified with SIGSYS (sig=31) upon syscall from userspace, and switched task (of host) to vmlinux (um kernel), with the wake/wait synchronization (which I meant synchronization in my previous email), and switch back to uml-userspace to continue the userspace process.
so, at least 4 host sched_switch-es per single um syscall.
with current nommu using a single host process, notifications via SIGSYS is same as seccomp-mmu, but after that there is no context switch upon syscall issued by a userspace, in the same context to the next syscall.
nommu implementation with CLONE_VM (btw, the host process, uml-userspace is already created with CLONE_VM flag IIUC) might face the similar situation as seccomp-mmu, seeing the same switches between processes.
this becomes the difference between the benchmark results of getpid, which um-mmu (seccomp)/um-nommu (seccomp) is mostly x10 (26.242 and 2.599 usec) (this was described as an example of benchmark in the patchset).
I didn't look at ptrace mode of MMU, but expect to see the similar (or more) duration on a single syscall.
in addition to this ftrace measurement above, I conducted more practical benchmark with iperf3 (forward/reverse path) and netperf (TCP_STREAM/MAERTS), which aren't corner cases I believe, and below is the result.
all use the vector driver with gro on via host tap devices. iperf3/netperf server run on a host and client runs inside uml.
# I can give a complete script to reproduce this if needed.
- iperf3 (Mbps)
um-mmu(seccomp) um-nommu(seccomp)
--------------------------------------------------
iperf3(f) 7984 13152 iperf3(r) 8009 14363
- netperf (Mbps, bufsize=65507bytes)
um-mmu(seccomp) um-nommu(seccomp)
--------------------------------------------------
netperf(STREAM) 5912.93 10792.02
netperf(MAERTS) 29263.53 33970.06
not significant different as we saw with simple syscall benchmark with getpid(2), but still see an impact with difference.
I would say these results only show partial cases of what UML can do, different workloads may show different result, but it is still valuable to present one of the benefits to see the nature of the feature (of what single process design can do).
Of course, nommu will come with various limitations as I described in the document; like applications should be aware of the kernel is nommu (i.e., need to use vfork, PIE binaries, etc). So traditional uml is more generic and has broader usage, but with this characteristic of speed with nommu, I think it is worthwhile and users benefit from this if they need speed.
I hope this clarifies a bit.
-- Hajime