Skip to contentSkip to conversation

nommu UML

PATCH Superseded Hajime Tazaki 2 participants 18 messages Jan 14, 2025 – Jan 16, 2025

Subsystems (7)

v6 of 14 Superseded Latest is v14 →

lore
Share & tools
lore
#0 lore raw

v6 cover nommu UML

This patchset is another spin of nommu mode addition to UML. It doesn't change a lot since the last version (v5), but contain clean ups. 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.

-- Hajime

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]

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: clean up elf specific definitions
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: add documentation of nommu UML
um: nommu: plug nommu code into build system

 Documentation/virt/uml/nommu-uml.rst    | 177 ++++++++++++++++++++++
 MAINTAINERS                             |   1 +
 arch/um/Kconfig                         |  14 +-
 arch/um/Makefile                        |  10 ++
 arch/um/configs/x86_64_nommu_defconfig  |  64 ++++++++
 arch/um/include/asm/Kbuild              |   1 +
 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    |   6 +
 arch/um/include/asm/uaccess.h           |   7 +-
 arch/um/include/shared/kern_util.h      |  12 ++
 arch/um/include/shared/os.h             |  16 ++
 arch/um/kernel/Makefile                 |   5 +-
 arch/um/kernel/mem-pgtable.c            |  55 +++++++
 arch/um/kernel/mem.c                    |  39 +----
 arch/um/kernel/process.c                |  25 ++++
 arch/um/kernel/skas/process.c           |  27 ----
 arch/um/kernel/um_arch.c                |   3 +
 arch/um/nommu/Makefile                  |   3 +
 arch/um/nommu/os-Linux/Makefile         |   7 +
 arch/um/nommu/os-Linux/signal.c         |  28 ++++
 arch/um/nommu/trap.c                    | 188 ++++++++++++++++++++++++
 arch/um/os-Linux/Makefile               |   8 +-
 arch/um/os-Linux/internal.h             |   5 +
 arch/um/os-Linux/mem.c                  |   4 +
 arch/um/os-Linux/process.c              | 149 ++++++++++++++++++-
 arch/um/os-Linux/seccomp.c              |  87 +++++++++++
 arch/um/os-Linux/signal.c               |  31 +++-
 arch/um/os-Linux/skas/process.c         | 132 -----------------
 arch/um/os-Linux/start_up.c             |  20 +++
 arch/um/os-Linux/util.c                 |   3 +-
 arch/x86/um/Makefile                    |   7 +-
 arch/x86/um/asm/elf.h                   |   8 +-
 arch/x86/um/asm/module.h                |  24 ---
 arch/x86/um/nommu/Makefile              |   8 +
 arch/x86/um/nommu/do_syscall_64.c       |  74 ++++++++++
 arch/x86/um/nommu/entry_64.S            | 113 ++++++++++++++
 arch/x86/um/nommu/os-Linux/Makefile     |   6 +
 arch/x86/um/nommu/os-Linux/mcontext.c   |  24 +++
 arch/x86/um/nommu/syscalls.h            |  16 ++
 arch/x86/um/nommu/syscalls_64.c         | 115 +++++++++++++++
 arch/x86/um/shared/sysdep/mcontext.h    |   4 +
 arch/x86/um/shared/sysdep/syscalls_64.h |   6 +
 arch/x86/um/signal.c                    |   7 +
 arch/x86/um/vdso/vma.c                  |  17 ++-
 fs/Kconfig.binfmt                       |   2 +-
 47 files changed, 1328 insertions(+), 244 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/signal.c
 create mode 100644 arch/um/nommu/trap.c
 create mode 100644 arch/um/os-Linux/seccomp.c
 delete mode 100644 arch/x86/um/asm/module.h
 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: 2d2b61ae38bd91217ea7cc5bc700a2b9e75b3937

Signature · 1 line
2.43.0
#1 lore raw

PATCH v6 1/13 x86/um: clean up elf specific definitions

The file arch/x86/um/asm/module.h is equivalent to the definition of asm-generic. Thus this commit cleans up to use it.

---
 arch/um/include/asm/Kbuild |  1 +
 arch/x86/um/asm/module.h   | 24 ------------------------
 2 files changed, 1 insertion(+), 24 deletions(-)
 delete mode 100644 arch/x86/um/asm/module.h
arch/um/include/asm/Kbuild +1 -0
index 428f2c5158c2..04ab3b653a48 100644
@@ -13,6 +13,7 @@ generic-y += irq_work.h
 generic-y += kdebug.h
 generic-y += mcs_spinlock.h
 generic-y += mmiowb.h
+generic-y += module.h
 generic-y += module.lds.h
 generic-y += param.h
 generic-y += parport.h
arch/x86/um/asm/module.h deleted +0 -24
deleted file mode 100644
index a3b061d66082..000000000000
@@ -1,24 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef __UM_MODULE_H
-#define __UM_MODULE_H
-
-/* UML is simple */
-struct mod_arch_specific
-{
-};
-
-#ifdef CONFIG_X86_32
-
-#define Elf_Shdr Elf32_Shdr
-#define Elf_Sym Elf32_Sym
-#define Elf_Ehdr Elf32_Ehdr
-
-#else
-
-#define Elf_Shdr Elf64_Shdr
-#define Elf_Sym Elf64_Sym
-#define Elf_Ehdr Elf64_Ehdr
-
-#endif
-
-#endif
Signature · 1 line
2.43.0
#2 lore raw

PATCH v6 2/13 x86/um: nommu: elf loader for fdpic

In reply to Hajime Tazaki

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
index a3eaca41ff61..01422b761aa0 100644
@@ -14,6 +14,11 @@ typedef struct mm_context {
 	/* Address range in need of a TLB sync */
 	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;
 
 #endif
arch/um/include/asm/ptrace-generic.h +6 -0
index 4696f24d1492..4ff844bcb1cd 100644
@@ -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
index 62ed5d68a978..33f69f1eac10 100644
@@ -9,6 +9,7 @@
 #include <skas.h>
 
 #define CORE_DUMP_USE_REGSET
+#define ELF_FDPIC_CORE_EFLAGS  0
 
 #ifdef CONFIG_X86_32
 
@@ -190,8 +191,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
index bd2f530e5740..419ba0282806 100644
@@ -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
#3 lore raw

PATCH v6 3/13 um: decouple MMU specific code from the common part

In reply to Hajime Tazaki

This 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            |  36 ---------
 arch/um/kernel/process.c        |  25 ++++++
 arch/um/kernel/skas/process.c   |  27 -------
 arch/um/os-Linux/Makefile       |   3 +-
 arch/um/os-Linux/internal.h     |   5 ++
 arch/um/os-Linux/process.c      | 133 ++++++++++++++++++++++++++++++++
 arch/um/os-Linux/skas/process.c | 132 -------------------------------
 9 files changed, 223 insertions(+), 198 deletions(-)
 create mode 100644 arch/um/kernel/mem-pgtable.c
arch/um/kernel/Makefile +3 -2
index f8567b933ffa..eec6682812ce 100644
@@ -16,9 +16,10 @@ extra-y := 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 maccess.o kmsg_dump.o capflags.o skas/
+	signal.o sysrq.o time.o \
+	um_arch.o umid.o maccess.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 -36
index 8a0e74ad00d1..767b9b05d6bb 100644
@@ -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 <asm/page.h>
@@ -203,42 +202,7 @@ void free_initmem(void)
 {
 }
 
-/* Allocate and free page tables. */
-
-pgd_t *pgd_alloc(struct mm_struct *mm)
-{
-	pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);
-
-	if (pgd) {
-		memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
-		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
arch/um/kernel/process.c +25 -0
index e5a2d4d897e0..2f191daed532 100644
@@ -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>
@@ -46,6 +47,8 @@
 struct task_struct *cpu_tasks[NR_CPUS];
 EXPORT_SYMBOL(cpu_tasks);
 
+static char cpu0_irqstack[THREAD_SIZE] __aligned(THREAD_SIZE);
+
 void free_stack(unsigned long stack, int order)
 {
 	free_pages(stack, order);
@@ -287,3 +290,25 @@ unsigned long __get_wchan(struct task_struct *p)
 
 	return 0;
 }
+
+
+static int __init start_kernel_proc(void *unused)
+{
+	block_signals_trace();
+
+	start_kernel();
+	return 0;
+}
+
+int __init start_uml(void)
+{
+	stack_protections((unsigned long) &cpu0_irqstack);
+	set_sigstack(cpu0_irqstack, 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);
+}
arch/um/kernel/skas/process.c +0 -27
index 05dcdc057af9..5247121d3419 100644
@@ -16,33 +16,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;
-}
-
-extern int userspace_pid[];
-
-static char cpu0_irqstack[THREAD_SIZE] __aligned(THREAD_SIZE);
-
-int __init start_uml(void)
-{
-	stack_protections((unsigned long) &cpu0_irqstack);
-	set_sigstack(cpu0_irqstack, 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)
arch/um/os-Linux/Makefile +2 -1
index 049dfa5bc9c6..331564888400 100644
@@ -8,7 +8,8 @@ KCOV_INSTRUMENT                := n
 
 obj-y = 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 drivers/ skas/
+	umid.o user_syms.o util.o drivers/
+obj-$(CONFIG_MMU) += skas/
 
 CFLAGS_signal.o += -Wframe-larger-than=4096
 
arch/um/os-Linux/internal.h +5 -0
index 317fca190c2b..bcbf64ce8cd1 100644
@@ -2,6 +2,11 @@
 #ifndef __UM_OS_LINUX_INTERNAL_H
 #define __UM_OS_LINUX_INTERNAL_H
 
+/*
+ * process.c
+ */
+extern int userspace_pid[];
+
 /*
  * elf_aux.c
  */
arch/um/os-Linux/process.c +133 -0

151 lines not on this page · raw message

arch/um/os-Linux/skas/process.c +0 -132

168 lines not on this page · raw message

Signature · 1 line
2.43.0
#4 lore raw

PATCH v6 4/13 um: nommu: memory handling

In reply to Hajime Tazaki

This 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
index 1d36a613aad8..fcf4bb915a31 100644
@@ -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
index 780aa6bfc050..785fd6649aa2 100644
@@ -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
index 01422b761aa0..d4087f9499e2 100644
@@ -15,10 +15,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;
 
 #endif
arch/um/include/asm/mmu_context.h +2 -0
index 23dcc914d44e..033a70166066 100644
@@ -36,11 +36,13 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 	}
 }
 
+#ifdef CONFIG_MMU
 #define init_new_context init_new_context
 extern int init_new_context(struct task_struct *task, struct mm_struct *mm);
 
 #define destroy_context destroy_context
 extern void destroy_context(struct mm_struct *mm);
+#endif
 
 #include <asm-generic/mmu_context.h>
 
arch/um/include/asm/uaccess.h +4 -3
index 1d4b6bbc1b65..9bfee12cb6b7 100644
@@ -22,6 +22,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);
@@ -33,9 +34,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;
@@ -43,6 +41,9 @@ static inline int __access_ok(const void __user *ptr, unsigned long size)
 		(__under_task_size(addr, size) ||
 		 __access_ok_vsyscall(addr, size));
 }
+#endif
+
+#include <asm-generic/uaccess.h>
 
 /* no pagefaults for kernel addresses in um */
 #define __get_kernel_nofault(dst, src, type, err_label)			\
arch/um/kernel/mem.c +2 -1
index 767b9b05d6bb..beab40bc9f30 100644
@@ -62,7 +62,8 @@ void __init mem_init(void)
 	 * to be turned on.
 	 */
 	brk_end = (unsigned long) UML_ROUND_UP(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;
 
arch/um/os-Linux/mem.c +4 -0
index 72f302f4d197..4f5d9a94f8e2 100644
@@ -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
index 6df378639880..e2dc00fc84c0 100644
@@ -70,8 +70,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
#5 lore raw

PATCH v6 5/13 x86/um: nommu: syscall handling

In reply to Hajime Tazaki

This 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/nommu/Makefile              |  8 +++
 arch/x86/um/nommu/do_syscall_64.c       | 37 ++++++++++
 arch/x86/um/nommu/entry_64.S            | 91 +++++++++++++++++++++++++
 arch/x86/um/nommu/syscalls.h            | 16 +++++
 arch/x86/um/shared/sysdep/syscalls_64.h |  6 ++
 6 files changed, 162 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
index b42c31cd2390..227af2a987e2 100644
@@ -32,6 +32,10 @@ obj-y += 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/nommu/Makefile new file +8 -0
new file mode 100644
index 000000000000..d72c63afffa5
@@ -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 +37 -0
new file mode 100644
index 000000000000..5d0fa83e7fdc
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/kernel.h>
+#include <linux/ptrace.h>
+#include <kern_util.h>
+#include <sysdep/syscalls.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(&regs->regs) = syscall;
+
+	pr_debug("syscall(%d) (current=%lx) (fn=%lx)\n",
+		 syscall, (unsigned long)current,
+		 (unsigned long)sys_call_table[syscall]);
+
+	if (likely(syscall < NR_syscalls)) {
+		PT_REGS_SET_SYSCALL_RETURN(regs,
+				EXECUTE_SYSCALL(syscall, regs));
+	}
+
+	pr_debug("syscall(%d) --> %lx\n", syscall,
+		regs->regs.gp[HOST_AX]);
+
+	PT_REGS_SYSCALL_RET(regs) = regs->regs.gp[HOST_AX];
+
+	/* execve succeeded */
+	if (syscall == __NR_execve && regs->regs.gp[HOST_AX] == 0)
+		userspace(&current->thread.regs.regs);
+
+	/* force do_signal() --> is_syscall() */
+	set_thread_flag(TIF_SIGPENDING);
+	interrupt_end();
+}
arch/x86/um/nommu/entry_64.S new file +91 -0

91 lines not on this page · raw message

arch/x86/um/nommu/syscalls.h new file +16 -0
new file mode 100644
index 000000000000..a2433756b1fc
@@ -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
arch/x86/um/shared/sysdep/syscalls_64.h +6 -0
index b6b997225841..ffd80ee3b9dc 100644
@@ -25,4 +25,10 @@ extern syscall_handler_t *sys_call_table[];
 extern syscall_handler_t sys_modify_ldt;
 extern syscall_handler_t sys_arch_prctl;
 
+#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
Signature · 1 line
2.43.0
#6 lore raw

PATCH v6 6/13 um: nommu: seccomp syscalls hook

In reply to Hajime Tazaki

This 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.

---
 arch/um/include/shared/kern_util.h    |  8 +++
 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/signal.c       | 15 +++++
 arch/um/os-Linux/Makefile             |  5 ++
 arch/um/os-Linux/seccomp.c            | 87 +++++++++++++++++++++++++++
 arch/um/os-Linux/signal.c             |  6 ++
 arch/x86/um/nommu/Makefile            |  2 +-
 arch/x86/um/nommu/os-Linux/Makefile   |  6 ++
 arch/x86/um/nommu/os-Linux/mcontext.c | 13 ++++
 arch/x86/um/shared/sysdep/mcontext.h  |  3 +
 13 files changed, 167 insertions(+), 1 deletion(-)
 create mode 100644 arch/um/nommu/Makefile
 create mode 100644 arch/um/nommu/os-Linux/Makefile
 create mode 100644 arch/um/nommu/os-Linux/signal.c
 create mode 100644 arch/um/os-Linux/seccomp.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 +8 -0
index f21dc8517538..1dd3d02c4e39 100644
@@ -67,4 +67,12 @@ void um_idle_sleep(void);
 
 void kasan_map_memory(void *start, size_t len);
 
+#ifdef CONFIG_MMU
+static inline void arch_sigsys_handler(int sig, struct siginfo *si, void *mc)
+{
+}
+#else
+extern void arch_sigsys_handler(int sig, struct siginfo *si, void *mc);
+#endif
+
 #endif
arch/um/include/shared/os.h +10 -0
index 5babad8c5f75..d29b967a009e 100644
@@ -334,4 +334,14 @@ extern void um_trace_signals_off(void);
 /* time-travel */
 extern void deliver_time_travel_irqs(void);
 
+/* 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
index 79ea97d4797e..dc7efccbcb63 100644
@@ -432,6 +432,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
new file mode 100644
index 000000000000..baab7c2f57c2
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: GPL-2.0
+
+obj-y := os-Linux/
arch/um/nommu/os-Linux/Makefile new file +7 -0
new file mode 100644
index 000000000000..68833c576437
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: GPL-2.0
+
+obj-y := 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/signal.c new file +15 -0
new file mode 100644
index 000000000000..1674962e509d
@@ -0,0 +1,15 @@
+// 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 arch_sigsys_handler(int sig, struct siginfo *si, void *ptr)
+{
+	mcontext_t *mc = (mcontext_t *) ptr;
+
+	/* hook syscall via SIGSYS */
+	set_mc_sigsys_hook(mc);
+}
arch/um/os-Linux/Makefile +5 -0
index 331564888400..6bfdfec8cbcc 100644
@@ -21,4 +21,9 @@ USER_OBJS := $(user-objs-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 util.o
 
+ifneq ($(CONFIG_MMU),y)
+obj-y += seccomp.o
+USER_OBJS += seccomp.o
+endif
+
 include $(srctree)/arch/um/scripts/Makefile.rules
arch/um/os-Linux/seccomp.c new file +87 -0

87 lines not on this page · raw message

arch/um/os-Linux/signal.c +6 -0
index 9ea7269ffb77..97efdabe1e45 100644
@@ -172,12 +172,18 @@ void register_pm_wake_signal(void)
 	set_handler(SIGUSR1);
 }
 
+static void sigsys_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)
+{
+	arch_sigsys_handler(sig, unused_si, mc);
+}
+
 static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) = {
 	[SIGSEGV] = sig_handler,
 	[SIGBUS] = sig_handler,
 	[SIGILL] = sig_handler,
 	[SIGFPE] = sig_handler,
 	[SIGTRAP] = sig_handler,
+	[SIGSYS] = sigsys_handler,
 
 	[SIGIO] = sig_handler,
 	[SIGWINCH] = sig_handler,
arch/x86/um/nommu/Makefile +1 -1
index d72c63afffa5..ebe47d4836f4 100644
@@ -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
new file mode 100644
index 000000000000..4571e403a6ff
@@ -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 +13 -0
new file mode 100644
index 000000000000..c4ef877d5ea0
@@ -0,0 +1,13 @@
+// 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>
+#include <sysdep/syscalls.h>
+
+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 +3 -0
index b724c54da316..15e9ff287021 100644
@@ -7,6 +7,9 @@
 #define __SYS_SIGCONTEXT_X86_H
 
 extern void get_regs_from_mc(struct uml_pt_regs *, mcontext_t *);
+#ifndef CONFIG_MMU
+extern void set_mc_sigsys_hook(mcontext_t *mc);
+#endif
 
 #ifdef __i386__
 
Signature · 1 line
2.43.0
#7 lore raw

PATCH v6 7/13 x86/um: nommu: process/thread handling

In reply to Hajime Tazaki

Since 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.

---
 arch/um/os-Linux/process.c      |  6 +++++
 arch/x86/um/Makefile            |  3 ++-
 arch/x86/um/nommu/Makefile      |  2 +-
 arch/x86/um/nommu/entry_64.S    | 22 +++++++++++++++++
 arch/x86/um/nommu/syscalls_64.c | 44 +++++++++++++++++++++++++++++++++
 5 files changed, 75 insertions(+), 2 deletions(-)
 create mode 100644 arch/x86/um/nommu/syscalls_64.c
arch/um/os-Linux/process.c +6 -0
index e2dc00fc84c0..49aa8e92205e 100644
@@ -28,6 +28,9 @@ int unscheduled_userspace_iterations;
 
 void os_alarm_process(int pid)
 {
+	if (pid <= 0)
+		return;
+
 	kill(pid, SIGALRM);
 }
 
@@ -45,6 +48,9 @@ void os_kill_process(int pid, int reap_child)
 
 void os_kill_ptraced_process(int pid, int reap_child)
 {
+	if (pid <= 0)
+		return;
+
 	kill(pid, SIGKILL);
 	ptrace(PTRACE_KILL, pid);
 	ptrace(PTRACE_CONT, pid);
arch/x86/um/Makefile +2 -1
index 227af2a987e2..53c9ebb3c41c 100644
@@ -27,7 +27,8 @@ subarch-y += ../kernel/sys_ia32.o
 
 else
 
-obj-y += syscalls_64.o vdso/
+obj-y += 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
index ebe47d4836f4..4018d9e0aba0 100644
@@ -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 +22 -0
index e9bfc7b93c84..950447dfa66b 100644
@@ -89,3 +89,25 @@ ENTRY(__kernel_vsyscall)
 	jmp	*%rcx
 
 END(__kernel_vsyscall)
+
+// void userspace(struct uml_pt_regs *regs)
+ENTRY(userspace)
+
+	/* align the stack for x86_64 ABI */
+	and     $-0x10, %rsp
+	/* Handle any immediate reschedules or signals */
+	call	interrupt_end
+
+	movq	current_ptregs, %rsp
+
+	POP_REGS
+
+	addq	$8, %rsp	/* skip orig_ax */
+	popq	%r11		/* pt_regs->ip */
+	addq	$8, %rsp	/* skip cs */
+	addq	$8, %rsp	/* skip flags */
+	popq	%rsp
+
+	jmp	*%r11
+
+END(userspace)
arch/x86/um/nommu/syscalls_64.c new file +44 -0

44 lines not on this page · raw message

Signature · 1 line
2.43.0
#8 lore raw

PATCH v6 8/13 um: nommu: configure fs register on host syscall invocation

In reply to Hajime Tazaki

As 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       | 20 +++++++++
 arch/x86/um/nommu/do_syscall_64.c | 37 ++++++++++++++++
 arch/x86/um/nommu/syscalls_64.c   | 71 +++++++++++++++++++++++++++++++
 5 files changed, 140 insertions(+)
arch/um/include/shared/os.h +6 -0
index d29b967a009e..abb6f03414c5 100644
@@ -190,6 +190,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);
@@ -214,6 +215,11 @@ 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_mincore(void *addr, unsigned long len);
+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
index 49aa8e92205e..9acb865e2399 100644
@@ -16,6 +16,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>
@@ -206,6 +207,11 @@ int os_mincore(void *addr, unsigned long len)
 	return ret;
 }
 
+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 +20 -0
index 93fc82c01aba..dbab091892b3 100644
@@ -19,6 +19,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 <kern_util.h>
@@ -28,6 +30,8 @@
 #include <skas.h>
 #include "internal.h"
 
+int host_has_fsgsbase;
+
 static void ptrace_child(void)
 {
 	int ret;
@@ -278,6 +282,19 @@ void  __init get_host_cpu_features(
 	}
 }
 
+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)
 {
@@ -293,6 +310,9 @@ void __init os_early_checks(void)
 	 */
 	check_tmpexec();
 
+	/* 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
index 5d0fa83e7fdc..796beb0089fc 100644
@@ -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 <sysdep/syscalls.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;
@@ -17,6 +45,9 @@ __visible void do_syscall_64(struct pt_regs *regs)
 		 syscall, (unsigned long)current,
 		 (unsigned long)sys_call_table[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)) {
 		PT_REGS_SET_SYSCALL_RETURN(regs,
 				EXECUTE_SYSCALL(syscall, regs));
@@ -34,4 +65,10 @@ __visible void do_syscall_64(struct pt_regs *regs)
 	/* force do_signal() --> is_syscall() */
 	set_thread_flag(TIF_SIGPENDING);
 	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
#9 lore raw

PATCH v6 9/13 x86/um/vdso: nommu: vdso memory update

In reply to Hajime Tazaki

On !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
index f238f7b33cdd..2dc38cd77f23 100644
@@ -9,6 +9,7 @@
 #include <asm/page.h>
 #include <asm/elf.h>
 #include <linux/init.h>
+#include <os.h>
 
 static unsigned int __read_mostly vdso_enabled = 1;
 unsigned long um_vdso_addr;
@@ -24,8 +25,6 @@ static int __init init_vdso(void)
 
 	BUG_ON(vdso_end - vdso_start > PAGE_SIZE);
 
-	um_vdso_addr = task_size - PAGE_SIZE;
-
 	vdsop = kmalloc(sizeof(struct page *), GFP_KERNEL);
 	if (!vdsop)
 		goto oom;
@@ -40,6 +39,18 @@ static int __init init_vdso(void)
 	copy_page(page_address(um_vdso), vdso_start);
 	*vdsop = um_vdso;
 
+#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;
 
 oom:
@@ -50,6 +61,7 @@ static int __init init_vdso(void)
 }
 subsys_initcall(init_vdso);
 
+#ifdef CONFIG_MMU
 int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
 {
 	struct vm_area_struct *vma;
@@ -74,3 +86,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
#10 lore raw

PATCH v6 10/13 x86/um: nommu: signal handling

In reply to Hajime Tazaki

This 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.

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       |  13 ++
 arch/um/nommu/trap.c                  | 188 ++++++++++++++++++++++++++
 arch/um/os-Linux/signal.c             |  25 +++-
 arch/x86/um/nommu/os-Linux/mcontext.c |  11 ++
 arch/x86/um/shared/sysdep/mcontext.h  |   1 +
 arch/x86/um/signal.c                  |   7 +
 8 files changed, 243 insertions(+), 8 deletions(-)
 create mode 100644 arch/um/nommu/trap.c
arch/um/include/shared/kern_util.h +4 -0
index 1dd3d02c4e39..3569ca1603a8 100644
@@ -71,8 +71,12 @@ void kasan_map_memory(void *start, size_t len);
 static inline void arch_sigsys_handler(int sig, struct siginfo *si, void *mc)
 {
 }
+static inline void arch_sigsegv_handler(int sig, struct siginfo *unused_si, void *mc)
+{
+}
 #else
 extern void arch_sigsys_handler(int sig, struct siginfo *si, void *mc);
+extern void arch_sigsegv_handler(int sig, struct siginfo *si, void *mc);
 #endif
 
 #endif
arch/um/nommu/Makefile +1 -1
index baab7c2f57c2..096221590cfd 100644
@@ -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 +13 -0
index 1674962e509d..b9e3070f2c36 100644
@@ -5,6 +5,7 @@
 #include <os.h>
 #include <sysdep/mcontext.h>
 #include <sys/ucontext.h>
+#include <as-layout.h>
 
 void arch_sigsys_handler(int sig, struct siginfo *si, void *ptr)
 {
@@ -13,3 +14,15 @@ void arch_sigsys_handler(int sig, struct siginfo *si, void *ptr)
 	/* hook syscall via SIGSYS */
 	set_mc_sigsys_hook(mc);
 }
+
+void arch_sigsegv_handler(int sig, struct siginfo *si, void *ptr)
+{
+	mcontext_t *mc = (mcontext_t *) ptr;
+
+	/* !MMU specific part; detection of userspace */
+	if (mc->gregs[REG_RIP] > uml_reserved &&
+	    mc->gregs[REG_RIP] < high_physmem) {
+		/* !MMU: force handle signals after rt_sigreturn() */
+		set_mc_userspace_relay_signal(mc);
+	}
+}
arch/um/nommu/trap.c new file +188 -0

188 lines not on this page · raw message

arch/um/os-Linux/signal.c +18 -7
index 97efdabe1e45..3997d827bf4c 100644
@@ -37,12 +37,6 @@ static void sig_handler_common(int sig, struct siginfo *si, mcontext_t *mc)
 	int save_errno = errno;
 
 	r.is_user = 0;
-	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);
-	}
-
 	/* enable signals if sig isn't IRQ signal */
 	if ((sig != SIGIO) && (sig != SIGWINCH))
 		unblock_signals_trace();
@@ -177,8 +171,25 @@ static void sigsys_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)
 	arch_sigsys_handler(sig, unused_si, mc);
 }
 
+static void sigsegv_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)
+{
+	struct uml_pt_regs r;
+	int save_errno = errno;
+
+	r.is_user = 0;
+
+	/* For segfaults, we want the data from the sigcontext. */
+	get_regs_from_mc(&r, mc);
+	GET_FAULTINFO_FROM_MC(r.faultinfo, mc);
+
+	segv_handler(sig, unused_si, &r);
+	arch_sigsegv_handler(sig, unused_si, mc);
+
+	errno = save_errno;
+}
+
 static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) = {
-	[SIGSEGV] = sig_handler,
+	[SIGSEGV] = sigsegv_handler,
 	[SIGBUS] = sig_handler,
 	[SIGILL] = sig_handler,
 	[SIGFPE] = sig_handler,
arch/x86/um/nommu/os-Linux/mcontext.c +11 -0
index c4ef877d5ea0..955e7d9f4765 100644
@@ -6,6 +6,17 @@
 #include <sysdep/mcontext.h>
 #include <sysdep/syscalls.h>
 
+static void __userspace_relay_signal(void)
+{
+	/* XXX: dummy syscall */
+	__asm__ volatile("call *%0" : : "r"(__kernel_vsyscall), "a"(39) :);
+}
+
+void set_mc_userspace_relay_signal(mcontext_t *mc)
+{
+	mc->gregs[REG_RIP] = (unsigned long) __userspace_relay_signal;
+}
+
 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
index 15e9ff287021..0efe5ddf95af 100644
@@ -9,6 +9,7 @@
 extern void get_regs_from_mc(struct uml_pt_regs *, mcontext_t *);
 #ifndef CONFIG_MMU
 extern void set_mc_sigsys_hook(mcontext_t *mc);
+extern void set_mc_userspace_relay_signal(mcontext_t *mc);
 #endif
 
 #ifdef __i386__
arch/x86/um/signal.c +7 -0
index 75087e85b6fd..ea6b408e37d2 100644
@@ -370,6 +370,13 @@ int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig,
 	frame = (struct rt_sigframe __user *)
 		round_down(stack_top - sizeof(struct rt_sigframe), 16);
 
+#ifndef CONFIG_MMU
+	/*
+	 * the sig_frame on !MMU needs be aligned for SSE as
+	 * the frame is used as-is.
+	 */
+	math_size = round_down(math_size, 16);
+#endif
 	/* Add required space for math frame */
 	frame = (struct rt_sigframe __user *)((unsigned long)frame - math_size);
 
Signature · 1 line
2.43.0
#11 lore raw

PATCH v6 11/13 um: change machine name for uname output

In reply to Hajime Tazaki

This 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
index fcf4bb915a31..722a3bd03f24 100644
@@ -155,6 +155,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
index 4193e04d7e4a..20421e9f0f77 100644
@@ -65,7 +65,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
#12 lore raw

PATCH v6 12/13 um: nommu: add documentation of nommu UML

In reply to Hajime Tazaki

This commit adds an initial documentation for !MMU mode of UML.

---
 Documentation/virt/uml/nommu-uml.rst | 177 +++++++++++++++++++++++++++
 MAINTAINERS                          |   1 +
 2 files changed, 178 insertions(+)
 create mode 100644 Documentation/virt/uml/nommu-uml.rst
Documentation/virt/uml/nommu-uml.rst new file +177 -0
new file mode 100644
index 000000000000..a98bfd9d2f38
@@ -0,0 +1,177 @@
+.. 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.12-rc2 uml/next
+tree).
+
+.. csv-table:: lmbench (usec)
+  :header: ,native,um,um-nommu(s)
+
+  select-10    ,0.5544,29.7143,2.8920
+  select-100   ,2.3992,27.7262,3.7794
+  select-1000  ,20.4708,42.0885,12.6920
+  syscall      ,0.1734,26.2471,2.6070
+  read         ,0.3433,29.8828,2.6923
+  write        ,0.2866,25.9753,2.6925
+  stat         ,1.9195,40.1164,3.1813
+  open/close   ,3.8657,63.4730,6.2049
+  fork+sh      ,1161.1111,5216.5000,462.3077
+  fork+execve  ,536.5263,2117.0000,131.0633
+
+.. csv-table:: do_getpid bench (nsec)
+  :header: ,native,um,um-nommu(s)
+
+  getpid,  172 , 26807 , 2614
+
+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
index 910305c11e8a..fc5473fd528b 100644
@@ -24470,6 +24470,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
#13 lore raw

PATCH v6 13/13 um: nommu: plug nommu code into build system

In reply to Hajime Tazaki

Add nommu kernel for um build. defconfig is also provided.

---
 arch/um/Kconfig                        | 14 +++++-
 arch/um/configs/x86_64_nommu_defconfig | 64 ++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 2 deletions(-)
 create mode 100644 arch/um/configs/x86_64_nommu_defconfig
arch/um/Kconfig +12 -2
index 18051b1cfce0..2fc5a91c90a7 100644
@@ -30,14 +30,17 @@ 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 THREAD_INFO_IN_TASK
+	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
@@ -190,8 +193,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 +64 -0

64 lines not on this page · raw message

Signature · 1 line
2.43.0
#14 lore raw
In reply to Hajime Tazaki

Hi,

Quoted 9 lines · Hajime Tazaki

This patchset is another spin of nommu mode addition to UML.  It doesn't change a lot since the last version (v5), but contain clean ups.  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.

Maybe I am missing it, but I do not yet see proper FP register handling. This will be needed for task/thread switches and also signal emission/sigreturn. I am attaching the test program that I used to verify the correct behaviour when dealing with the recent changes to FP register handling in UML.

Benjamin

Quoted 142 lines

-- Hajime

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]

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: clean up elf specific definitions
  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: add documentation of nommu UML
  um: nommu: plug nommu code into build system

 Documentation/virt/uml/nommu-uml.rst    | 177 ++++++++++++++++++++++ MAINTAINERS                             |   1 + arch/um/Kconfig                         |  14 +- arch/um/Makefile                        |  10 ++ arch/um/configs/x86_64_nommu_defconfig  |  64 ++++++++ arch/um/include/asm/Kbuild              |   1 + 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    |   6 + arch/um/include/asm/uaccess.h           |   7 +- arch/um/include/shared/kern_util.h      |  12 ++ arch/um/include/shared/os.h             |  16 ++ arch/um/kernel/Makefile                 |   5 +- arch/um/kernel/mem-pgtable.c            |  55 +++++++ arch/um/kernel/mem.c                    |  39 +---- arch/um/kernel/process.c                |  25 ++++ arch/um/kernel/skas/process.c           |  27 ---- arch/um/kernel/um_arch.c                |   3 + arch/um/nommu/Makefile                  |   3 + arch/um/nommu/os-Linux/Makefile         |   7 + arch/um/nommu/os-Linux/signal.c         |  28 ++++ arch/um/nommu/trap.c                    | 188
++++++++++++++++++++++++
 arch/um/os-Linux/Makefile               |   8 +- arch/um/os-Linux/internal.h             |   5 + arch/um/os-Linux/mem.c                  |   4 + arch/um/os-Linux/process.c              | 149 ++++++++++++++++++- arch/um/os-Linux/seccomp.c              |  87 +++++++++++ arch/um/os-Linux/signal.c               |  31 +++- arch/um/os-Linux/skas/process.c         | 132 ----------------- arch/um/os-Linux/start_up.c             |  20 +++ arch/um/os-Linux/util.c                 |   3 +- arch/x86/um/Makefile                    |   7 +- arch/x86/um/asm/elf.h                   |   8 +- arch/x86/um/asm/module.h                |  24 --- arch/x86/um/nommu/Makefile              |   8 + arch/x86/um/nommu/do_syscall_64.c       |  74 ++++++++++ arch/x86/um/nommu/entry_64.S            | 113 ++++++++++++++ arch/x86/um/nommu/os-Linux/Makefile     |   6 + arch/x86/um/nommu/os-Linux/mcontext.c   |  24 +++ arch/x86/um/nommu/syscalls.h            |  16 ++ arch/x86/um/nommu/syscalls_64.c         | 115 +++++++++++++++ arch/x86/um/shared/sysdep/mcontext.h    |   4 + arch/x86/um/shared/sysdep/syscalls_64.h |   6 + arch/x86/um/signal.c                    |   7 + arch/x86/um/vdso/vma.c                  |  17 ++- fs/Kconfig.binfmt                       |   2 +-

 47 files changed, 1328 insertions(+), 244 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/signal.c create mode 100644 arch/um/nommu/trap.c
 create mode 100644 arch/um/os-Linux/seccomp.c delete mode 100644 arch/x86/um/asm/module.h 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

Quoted 1 line

base-commit: 2d2b61ae38bd91217ea7cc5bc700a2b9e75b3937

/*
* gcc test-signal-restore.c -o test-signal-restore-amd64
* gcc -m32 -march=i686 -lm test-signal-restore.c -o test-signal-restore-i386 */

/* Is there a better way to *not* include bits/sigcontext.h? */ #include <features.h>
#undef __USE_MISC
#include <asm/sigcontext.h>

#include <elf.h>
#include <math.h>
#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <errno.h>
#include <unistd.h>
#include <sys/ptrace.h>
#include <sys/user.h>
#include <sys/uio.h>
#include <asm/unistd.h>

#define ST0_EXP_ADD 10

void *scratch_page;

void sighandler(int sig, siginfo_t *info, void *p)

{
	ucontext_t *uc = p;

	printf("sighandler: extended_size: %d, xstate_size: %d\n",
	       ((struct _fpstate *)uc->uc_mcontext.__fpregs)->sw_reserved.extended_size,
	        ((struct _fpstate *)uc->uc_mcontext.__fpregs)->sw_reserved.xstate_size);

	uc->uc_mcontext.__fpregs->_st[0].__exponent += ST0_EXP_ADD;
}

int test_fp()

{
	double num = 0.5;
	long ret;

	printf("pre-signal: %g\n", num);
	/*
	 * This does kill(getpid(), SIGUSR1); with "num" being passed in AND
	 * out of the floating point stack. We can therefore modify num by
	 * changing st[0] when handling the signal.
	 */
#ifdef __i386__
	asm volatile (
		"int $0x80;"
		: "=t" (num), "=a" (ret)
		: "0" (num), "1" (__NR_kill), "b" (getpid()), "c" (SIGUSR1) : );
#else
	asm volatile (
		"syscall;"
		: "=t" (num), "=a" (ret)
		: "0" (num), "1" (__NR_kill), "D" (getpid()), "S" (SIGUSR1) : "r11", "rcx");
#endif
	printf("post-signal: %g\n", num);

	if (num != pow(2, ST0_EXP_ADD - 1)) {
		printf("floating point register was not manipulated\n");
		return 1;
	}

	return 0;
}

enum source {
S_FPREGS = 0,
S_FPXREGS = 1,
S_GETREGS_FPREGS = 2,
S_GETREGS_XFPREGS = 3,
S_GETREGS_XSTATE = 4,
};

int test_fp_ptrace(enum source source)

{
	int pid, status, ret;

	pid = fork();
	if (pid < 0)
		return 127;

	if (pid == 0) {
		/* child */
		ptrace(PTRACE_TRACEME, 0, 0, 0);
		kill(getpid(), SIGSTOP);
		
		if (test_fp())
			exit(1);

		exit(0);
	}

	/* Wait for child to stop itself */
	do {
		ret = waitpid(pid, &status, 0);
	} while (ret < 0 && errno == EINTR);
	if (!WIFSTOPPED(status))
		return 127;

	/* Continue until SIGUSR1 to self */
	ptrace(PTRACE_CONT, pid, NULL, 0);
	do {
		ret = waitpid(pid, &status, 0);
	} while (ret < 0 && errno == EINTR);
	if (!WIFSTOPPED(status))
		return 127;

	if (source == S_FPXREGS || source == S_GETREGS_XFPREGS) {
#ifdef __i386__
		struct user_fpxregs_struct *fpstate;
		struct iovec iov = {
			.iov_len = sizeof(*fpstate),
		};
		int ret;

		fpstate = scratch_page + 4096 - iov.iov_len;
		iov.iov_base = fpstate;

		if (source == S_GETREGS_XFPREGS)
			ret = ptrace(PTRACE_GETREGSET, pid, NT_PRXFPREG, &iov);
		else
			ret = ptrace(PTRACE_GETFPXREGS, pid, NULL, fpstate);

		if (ret) {
			kill(pid, SIGKILL);
			if (errno == EINVAL) {
				printf("Getting FPX regs not supported\n");
				return 0;
			} else {
				printf("Error getting FPX regs: %d\n", errno);
				return 127;
			}
		}
		((struct _fpxreg*)&fpstate->st_space[0])->exponent += ST0_EXP_ADD;

		if (source == S_GETREGS_XFPREGS)
			ret = ptrace(PTRACE_SETREGSET, pid, NT_PRXFPREG, &iov);
		else
			ret = ptrace(PTRACE_SETFPXREGS, pid, NULL, fpstate);
		if (ret)
			return -127;
#else
		printf("No FPXREGS on x86_64\n");
		kill(pid, SIGKILL);
		return 127;
#endif
	} else if (source == S_FPREGS || source == S_GETREGS_FPREGS) {
		struct _fpstate *fpstate;
		struct iovec iov = {
			.iov_len = sizeof(*fpstate),
		};

		fpstate = scratch_page; // + 4096 - sizeof(*fpstate);
		iov.iov_base = fpstate;

		if (source == S_GETREGS_FPREGS)
			ret = ptrace(PTRACE_GETREGSET, pid, NT_PRFPREG, &iov);
		else
			ret = ptrace(PTRACE_GETFPREGS, pid, NULL, fpstate);


		if (ret) {
			kill(pid, SIGKILL);
			if (errno == EINVAL) {
				printf("Getting FP regs not supported\n");
				return 0;
			} else {
				printf("Error getting FPX regs: %d\n", errno);
				return 127;
			}
		}
#ifdef __i386__
		((struct _fpreg*) &fpstate->_st[0])->exponent += ST0_EXP_ADD;
#else
		((struct _fpxreg*) &fpstate->st_space[0])->exponent += ST0_EXP_ADD;

#endif

		if (source == S_GETREGS_FPREGS)
			ret = ptrace(PTRACE_SETREGSET, pid, NT_PRFPREG, &iov);
		else
			ret = ptrace(PTRACE_SETFPREGS, pid, NULL, fpstate);

		if (ret)
			return 127;
	} else if (source == S_GETREGS_XSTATE) {
#ifdef __i386__
		struct user_fpxregs_struct *fpstate;
#else
		struct user_fpregs_struct *fpstate;
#endif
		struct iovec iov = {
			.iov_len = 4096,
		};

		fpstate = scratch_page + 4096 - iov.iov_len;
		iov.iov_base = fpstate;

		ret = ptrace(PTRACE_GETREGSET, pid, NT_X86_XSTATE, &iov);
		if (ret) {
			kill(pid, SIGKILL);
			if (errno == EINVAL) {
				printf("Getting XSTATE not supported\n");
				return 0;
			} else {
				printf("Error getting XSTATE size: %d\n", errno);
				return 127;
			}
		}

		printf("host xstate size: %ld\n", iov.iov_len);

		/* Second time with the exact length (to test the kernel) */
		fpstate = scratch_page + 4096 - iov.iov_len;
		iov.iov_base = fpstate;

		ret = ptrace(PTRACE_GETREGSET, pid, NT_X86_XSTATE, &iov);
		if (ret) {
			printf("Error getting XSTATE: %d\n", errno);
			return 127;
		}

		fpstate = scratch_page + 4096 - iov.iov_len;
		iov.iov_base = fpstate;

		ret = ptrace(PTRACE_GETREGSET, pid, NT_X86_XSTATE, &iov);
		if (ret) {
			kill(pid, SIGKILL);
			printf("Error getting XSTATE (with correct size): %d\n", errno);
			return 127;
		}
#ifdef __i386__
		((struct _fpxreg *)&fpstate->st_space[0])->exponent += ST0_EXP_ADD;
#else
		((struct _fpxreg *)&fpstate->st_space[0])->exponent += ST0_EXP_ADD;

#endif

		ret = ptrace(PTRACE_SETREGSET, pid, NT_X86_XSTATE, &iov);
		if (ret) {
			printf("Failed to set XSTATE: %d\n", errno);
			return 127;
		}

	} else {
		return 127;
	}

	/* Run until completion (without handling the signal) */
	ptrace(PTRACE_CONT, pid, NULL, 0);
	do {
		ret = waitpid(pid, &status, 0);
	} while (ret < 0 && errno == EINTR);

	if (!WIFEXITED(status))
		return 127;

	return WEXITSTATUS(status);
}

int main()

{
	struct sigaction sa = {
		.sa_flags = SA_SIGINFO,
		.sa_handler = (void (*)(int))sighandler,
	};
	int ret;

	scratch_page = mmap(NULL, 8192, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	munmap(scratch_page + 4096, 4096);

	sigaction(SIGUSR1, &sa, NULL);

	if (test_fp())
		return 1;

	sa.sa_handler = SIG_DFL;
	sigaction(SIGUSR1, &sa, NULL);

	printf("\nmodify using ptrace PTRACE_SETFPREGS instead of sighandler:\n");
	ret = test_fp_ptrace(S_FPREGS);
	if (ret)
		return ret;
#ifdef __i386__
	printf("\nmodify using ptrace PTRACE_SETFPXREGS instead of sighandler:\n");
	ret = test_fp_ptrace(S_FPXREGS);
	if (ret)
		return ret;

#endif

	printf("\nmodify using ptrace PTRACE_SETREGSET, via NT_PRFPREG instead of sighandler:\n");
	ret = test_fp_ptrace(S_GETREGS_FPREGS);
	if (ret)
		return ret;
#ifdef __i386__
	printf("\nmodify using ptrace PTRACE_SETREGSET, via NT_XFPREGS instead of sighandler:\n");
	ret = test_fp_ptrace(S_GETREGS_XFPREGS);
	if (ret)
		return ret;

#endif

	printf("\nmodify using ptrace PTRACE_SETREGSET, via NT_X86_XSTATE instead of sighandler:\n");
	ret = test_fp_ptrace(S_GETREGS_XSTATE);
	if (ret)
		return ret;

	return 0;
}
#15 lore raw

Hello,

Quoted 9 lines · Benjamin Berg
Quoted 7 lines · Hajime Tazaki

This patchset is another spin of nommu mode addition to UML.  It doesn't change a lot since the last version (v5), but contain clean ups.  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.

Quoted 8 lines
Quoted 2 lines

- memory mapped by loadable modules are not distinguished from userspace memory.

Maybe I am missing it, but I do not yet see proper FP register handling. This will be needed for task/thread switches and also signal emission/sigreturn. I am attaching the test program that I used to verify the correct behaviour when dealing with the recent changes to FP register handling in UML.

thanks for the test program.

I didn't address your comment on FP register handling as I couldn't see any reproducer that causes the issue you raised (and maybe didn't understand well the problem) so, the attached program helps a lot.

Though nommu code only works with musl-libc, which I cannot use that as-is, now I see what you meant with the first function, test_fp().

(none):/# /root/test-signal-restore
pre-signal: 0.5
post-signal: 0.5
floating point register was not manipulated

Tests on task switch (test_fp_ptrace) might need more work for me as nommu only works with vfork(2) and vfork without exec(2) may not test well on the implementation.

and also I'm wishing to have this kind of useful tests as a reusable way; as now I'm going to add a new configuration for UML, you're also going for another SECCOMP mode over MMU, we may have at least 3 running modes for UML, which I think we should share the test framework that we should pass. Not sure how it should be but using Kunit is the first thing in my mind.

I'd like to work on such things once I've done this initial part for nommu.

thanks, will get back here once I could see the right way to fix it.

-- Hajime

#16 lore raw

Hi,

Quoted 20 lines · Hajime Tazaki
Quoted 9 lines · Benjamin Berg
Quoted 7 lines · Hajime Tazaki

This patchset is another spin of nommu mode addition to UML.  It doesn't change a lot since the last version (v5), but contain clean ups.  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.

Quoted 8 lines
Quoted 2 lines

- memory mapped by loadable modules are not distinguished from userspace memory.

Maybe I am missing it, but I do not yet see proper FP register handling. This will be needed for task/thread switches and also signal emission/sigreturn. I am attaching the test program that I used to verify the correct behaviour when dealing with the recent changes to FP register handling in UML.

Quoted 5 lines

thanks for the test program.

I didn't address your comment on FP register handling as I couldn't see any reproducer that causes the issue you raised (and maybe didn't understand well the problem) so, the attached program helps a lot.

Note that it doesn't directly test task/thread switches which only happen due to normal scheduling (i.e. via SIGALRM). So, it doesn't cover everything, but syscalls and signals are quite important by themselves. For normal UML both cases hit the same codepath, but I think in your case the SIGALRM entry point differs and should be tested separately.

Quoted 11 lines

Though nommu code only works with musl-libc, which I cannot use that as-is, now I see what you meant with the first function, test_fp().

(none):/# /root/test-signal-restore
pre-signal: 0.5
post-signal: 0.5
floating point register was not manipulated

Tests on task switch (test_fp_ptrace) might need more work for me as nommu only works with vfork(2) and vfork without exec(2) may not test well on the implementation.

Not sure you even have a working ptrace in nommu?

That reminds me. Please set arch_has_single_step to zero for nommu mode. If you figure out how to set the appropriate bit in EFLAGS when returning to userspace, then that would also work.

Quoted 6 lines

and also I'm wishing to have this kind of useful tests as a reusable way; as now I'm going to add a new configuration for UML, you're also going for another SECCOMP mode over MMU, we may have at least 3 running modes for UML, which I think we should share the test framework that we should pass.  Not sure how it should be but using Kunit is the first thing in my mind.

My problem was, that I didn't know of a good place to put it. We could probably drop this test into tools/testing/selftests/x86, but how is it run then?
As for kunit, that would be neat, but I it seems a bit more complicated to run userspace code from within the kernel.

Benjamin

Quoted 8 lines

I'd like to work on such things once I've done this initial part for nommu.

thanks, will get back here once I could see the right way to fix it.

-- Hajime

#17 lore raw

Hello,

Quoted 12 lines · Benjamin Berg
Quoted 11 lines
Quoted 5 lines

Maybe I am missing it, but I do not yet see proper FP register handling. This will be needed for task/thread switches and also signal emission/sigreturn. I am attaching the test program that I used to verify the correct behaviour when dealing with the recent changes to FP register handling in UML.

thanks for the test program.

I didn't address your comment on FP register handling as I couldn't see any reproducer that causes the issue you raised (and maybe didn't understand well the problem) so, the attached program helps a lot.

Quoted 6 lines

Note that it doesn't directly test task/thread switches which only happen due to normal scheduling (i.e. via SIGALRM). So, it doesn't cover everything, but syscalls and signals are quite important by themselves. For normal UML both cases hit the same codepath, but I think in your case the SIGALRM entry point differs and should be tested separately.

indeed, scheduling works a different in nommu from normal UML.

Quoted 8 lines
Quoted 8 lines

Though nommu code only works with musl-libc, which I cannot use that as-is, now I see what you meant with the first function, test_fp().

(none):/# /root/test-signal-restore
pre-signal: 0.5
post-signal: 0.5
floating point register was not manipulated
Quoted 5 lines
Quoted 3 lines

Tests on task switch (test_fp_ptrace) might need more work for me as nommu only works with vfork(2) and vfork without exec(2) may not test well on the implementation.

Not sure you even have a working ptrace in nommu?

I don't think so.

Quoted 3 lines

That reminds me. Please set arch_has_single_step to zero for nommu mode. If you figure out how to set the appropriate bit in EFLAGS when returning to userspace, then that would also work.

thanks, I'll fix this in the next revision.

Quoted 7 lines
Quoted 6 lines

and also I'm wishing to have this kind of useful tests as a reusable way; as now I'm going to add a new configuration for UML, you're also going for another SECCOMP mode over MMU, we may have at least 3 running modes for UML, which I think we should share the test framework that we should pass.  Not sure how it should be but using Kunit is the first thing in my mind.

Quoted 5 lines

My problem was, that I didn't know of a good place to put it. We could probably drop this test into tools/testing/selftests/x86, but how is it run then?
As for kunit, that would be neat, but I it seems a bit more complicated to run userspace code from within the kernel.

thanks for sharing your experience.
I'll look for some nice place; for the moment, I would work with a private/local environment.

for the fp register handling on syscall/signal, it is going to be like this, not fully tested/verified yet though. with this, single syscall adds 80 nsec delay (in my environment), which seems reasonable to me.

arch/x86/um/nommu/do_syscall_64.c +6 -0
index 796beb0089fc..48b3d29e2db1 100644
@@ -48,6 +48,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 */
+       asm volatile("fxsaveq %0" : "=m"(*(struct _xstate *)regs->regs.fp));
+
        if (likely(syscall < NR_syscalls)) {
                PT_REGS_SET_SYSCALL_RETURN(regs,
                                EXECUTE_SYSCALL(syscall, regs));
@@ -66,6 +69,9 @@ __visible void do_syscall_64(struct pt_regs *regs)
        set_thread_flag(TIF_SIGPENDING);
        interrupt_end();
 
+       /* restore fp registers */
+       asm volatile("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/shared/sysdep/ptrace.h +1 -1
index 8f7476ff6e95..7d553d9f05be 100644
@@ -65,7 +65,7 @@ struct uml_pt_regs {
        int is_user;
 
        /* Dynamically sized FP registers (holds an XSTATE) */
-       unsigned long fp[];
+       unsigned long fp[] __attribute__((aligned(16)));
 };
 
 

-- Hajime