we spawn threads (they don't work)

Author: tombl

arch/wasm/Kconfig

@@ -2,18 +2,16 @@ config WASM
 	def_bool y
 	depends on !BINFMT_ELF && !SMP && !MMU && !MODULES && !COREDUMP && !SECCOMP && !UPROBES && !COMPAT
 	select ARCH_HAS_BINFMT_WASM
+	select ARCH_HAS_CURRENT_STACK_POINTER
 	select ARCH_HAS_SYSCALL_WRAPPER
 	select ARCH_NO_SWAP
 	select ARCH_USE_QUEUED_RWLOCKS
 	select ARCH_USE_QUEUED_SPINLOCKS
-	# select ARCH_SUPPORTS_LTO_CLANG
-	# select ARCH_SUPPORTS_LTO_CLANG_THIN
 	select BUG
 	select FLATMEM
 	select GENERIC_ATOMIC64
 	select GENERIC_CSUM
 	select GENERIC_HWEIGHT
-	select HAS_CURRENT_STACK_POINTER
 	select OF
 	select OF_EARLY_FLATTREE
 	select PAGE_SIZE_64KB
@@ -44,7 +42,8 @@ config SMP
 
 config NR_CPUS
 	int
-	default 1
+	default 1 if !SMP
+	default 64 if SMP
 
 config HZ
 	int

arch/wasm/include/asm/current.h

@@ -1,8 +1,8 @@
 #ifndef _WASM_CURRENT_H
 #define _WASM_CURRENT_H
 
-#include <asm/wasm_imports.h>
+struct task_struct;
 
-extern _Thread_local struct task_struct *current;
+extern _Thread_local struct task_struct * current;
 
 #endif

arch/wasm/include/asm/irqflags.h

@@ -3,30 +3,12 @@
 
 #include <asm/wasm_imports.h>
 
-#define arch_local_irq_save arch_local_irq_save
-static inline unsigned long arch_local_irq_save(void)
-{
-	return wasm_get_irq_enabled();
-}
-
 #define arch_local_irq_restore arch_local_irq_restore
 static inline void arch_local_irq_restore(unsigned long flags)
 {
 	wasm_set_irq_enabled(flags);
 }
 
-#define arch_local_irq_enable arch_local_irq_enable
-static inline void arch_local_irq_enable(void)
-{
-	wasm_set_irq_enabled(1);
-}
-
-#define arch_local_irq_disable arch_local_irq_disable
-static inline void arch_local_irq_disable(void)
-{
-	wasm_set_irq_enabled(0);
-}
-
 #define arch_local_save_flags arch_local_save_flags
 static inline unsigned long arch_local_save_flags(void)
 {

arch/wasm/include/asm/page.h

@@ -60,6 +60,10 @@ typedef struct page *pgtable_t;
 
 #define pfn_valid(pfn) ((pfn) < max_mapnr)
 
+struct page;
+void arch_alloc_page(struct page *page, int order);
+#define HAVE_ARCH_ALLOC_PAGE
+
 #include <asm-generic/getorder.h>
 
 #endif

arch/wasm/include/asm/percpu.h

@@ -0,0 +1,10 @@
+#ifndef _WASM_PERCPU_H
+#define _WASM_PERCPU_H
+
+#ifdef CONFIG_SMP
+#define PER_CPU_ATTRIBUTES _Thread_local
+#endif
+
+#include <asm-generic/percpu.h>
+
+#endif

arch/wasm/include/asm/processor.h

@@ -5,8 +5,7 @@
 
 struct task_struct;
 
-static inline void cpu_relax(void)
-{
+static inline void cpu_relax(void) {
 	wasm_relax();
 }
 
@@ -36,9 +35,12 @@ struct thread_struct {};
 	{           \
 	}
 
-#define task_pt_regs(tsk) (struct pt_regs *)(NULL)
+#define task_pt_regs(task) \
+	((struct pt_regs *)(task->stack + THREAD_SIZE) - 1)
+
+// I believe this is unreferenced in nommu:
+#define TASK_SIZE (__builtin_trap(),U32_MAX)
 
-#define TASK_SIZE U32_MAX
 #define TASK_UNMAPPED_BASE 0
 
 #define KSTK_EIP(tsk) (0)

arch/wasm/include/asm/sigcontext.h

@@ -1,7 +1,9 @@
 #ifndef _WASM_SIGCONTEXT_H
 #define _WASM_SIGCONTEXT_H
 
-struct pt_regs {};
+struct pt_regs {
+	void* stack_pointer;
+};
 
 struct sigcontext {
 	struct pt_regs regs;

arch/wasm/include/asm/smp.h

@@ -3,6 +3,7 @@
 
 #define raw_smp_processor_id() (current_thread_info()->cpu)
 
+struct cpumask;
 void arch_send_call_function_ipi_mask(const struct cpumask *mask);
 void arch_send_call_function_single_ipi(int cpu);
 

arch/wasm/include/asm/thread_info.h

@@ -11,63 +11,31 @@ struct thread_info {
 	struct task_struct *task;
 	unsigned long flags;
 	int preempt_count;
-	unsigned int worker;
+	struct task_struct *from_sched;
+#ifdef CONFIG_SMP
+	unsigned int cpu;
+#endif
 };
 
-#define INIT_THREAD_INFO(tsk)                                 \
-	{                                                     \
-		.task = &tsk, .flags = 0, .preempt_count = 1, \
+#define INIT_THREAD_INFO(tsk)                                                  \
+	{                                                                      \
+		.task = &tsk, .flags = 0, .preempt_count = INIT_PREEMPT_COUNT, \
 	}
 
 extern unsigned long *__stack_pointer;
 #define current_stack_pointer __stack_pointer
 
 #define TIF_SYSCALL_TRACE 0 /* syscall trace active */
-#define TIF_NOTIFY_RESUME 1 /* callback before returning to user */
+#define TIF_NOTIFY_RESUME 1 /* resumption notification requested */
 #define TIF_SIGPENDING 2 /* signal pending */
 #define TIF_NEED_RESCHED 3 /* rescheduling necessary */
-#define TIF_SINGLESTEP 4 /* reenable singlestep on user return*/
-#define TIF_SSBD 5 /* Speculative store bypass disable */
-#define TIF_SPEC_IB 9 /* Indirect branch speculation mitigation */
-#define TIF_SPEC_L1D_FLUSH 10 /* Flush L1D on mm switches (processes) */
-#define TIF_USER_RETURN_NOTIFY 11 /* notify kernel of userspace return */
-#define TIF_UPROBE 12 /* breakpointed or singlestepping */
-#define TIF_PATCH_PENDING 13 /* pending live patching update */
-#define TIF_NEED_FPU_LOAD 14 /* load FPU on return to userspace */
-#define TIF_NOCPUID 15 /* CPUID is not accessible in userland */
-#define TIF_NOTSC 16 /* TSC is not accessible in userland */
-#define TIF_NOTIFY_SIGNAL 17 /* signal notifications exist */
-#define TIF_MEMDIE 20 /* is terminating due to OOM killer */
-#define TIF_POLLING_NRFLAG 21 /* idle is polling for TIF_NEED_RESCHED */
-#define TIF_IO_BITMAP 22 /* uses I/O bitmap */
-#define TIF_SPEC_FORCE_UPDATE \
-	23 /* Force speculation MSR update in context switch */
-#define TIF_FORCED_TF 24 /* true if TF in eflags artificially */
-#define TIF_BLOCKSTEP 25 /* set when we want DEBUGCTLMSR_BTF */
-#define TIF_LAZY_MMU_UPDATES 27 /* task is updating the mmu lazily */
-#define TIF_ADDR32 29 /* 32-bit address space on 64 bits */
+#define TIF_NOTIFY_SIGNAL 7 /* signal notifications exist */
+#define TIF_MEMDIE 17 /* OOM killer killed process */
 
 #define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)
 #define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME)
 #define _TIF_SIGPENDING (1 << TIF_SIGPENDING)
 #define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)
-#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP)
-#define _TIF_SSBD (1 << TIF_SSBD)
-#define _TIF_SPEC_IB (1 << TIF_SPEC_IB)
-#define _TIF_SPEC_L1D_FLUSH (1 << TIF_SPEC_L1D_FLUSH)
-#define _TIF_USER_RETURN_NOTIFY (1 << TIF_USER_RETURN_NOTIFY)
-#define _TIF_UPROBE (1 << TIF_UPROBE)
-#define _TIF_PATCH_PENDING (1 << TIF_PATCH_PENDING)
-#define _TIF_NEED_FPU_LOAD (1 << TIF_NEED_FPU_LOAD)
-#define _TIF_NOCPUID (1 << TIF_NOCPUID)
-#define _TIF_NOTSC (1 << TIF_NOTSC)
 #define _TIF_NOTIFY_SIGNAL (1 << TIF_NOTIFY_SIGNAL)
-#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)
-#define _TIF_IO_BITMAP (1 << TIF_IO_BITMAP)
-#define _TIF_SPEC_FORCE_UPDATE (1 << TIF_SPEC_FORCE_UPDATE)
-#define _TIF_FORCED_TF (1 << TIF_FORCED_TF)
-#define _TIF_BLOCKSTEP (1 << TIF_BLOCKSTEP)
-#define _TIF_LAZY_MMU_UPDATES (1 << TIF_LAZY_MMU_UPDATES)
-#define _TIF_ADDR32 (1 << TIF_ADDR32)
 
 #endif

arch/wasm/include/asm/timex.h

@@ -9,12 +9,4 @@ static inline cycles_t get_cycles(void)
 	return wasm_get_now_nsec();
 }
 
-#define ARCH_HAS_READ_CURRENT_TIMER
-static inline int read_current_timer(unsigned long *timer_val)
-{
-	__builtin_trap();
-	*timer_val = wasm_get_now_nsec();
-	return 0;
-}
-
 #endif

arch/wasm/include/asm/wasm_imports.h

@@ -18,14 +18,17 @@ import("get_irq_enabled") int wasm_get_irq_enabled(void);
 import("return_address") void *wasm_return_address(int level);
 
 import("relax") void wasm_relax(void);
+import("idle") void wasm_idle(void);
+
 import("restart") void wasm_restart(void);
 
 import("get_dt") void wasm_get_dt(char *buf, size_t size);
 
 import("get_now_nsec") unsigned long long wasm_get_now_nsec(void);
 
-import("spawn_worker") unsigned int wasm_spawn_worker(unsigned int worker);
-import("start_worker") void wasm_start_worker(unsigned int worker);
+import("get_stacktrace") void wasm_get_stacktrace(char *buf, size_t size);
+
+import("new_worker") void wasm_new_worker(void* arg, char name[16]);
 
 #undef import
 

arch/wasm/kernel/process.c

@@ -1,12 +1,75 @@
+#include <asm/sysmem.h>
+#include <asm/wasm_imports.h>
+#include <linux/printk.h>
+#include <linux/ptrace.h>
 #include <linux/sched.h>
+#include <linux/sched/task_stack.h>
 #include <linux/sched/task.h>
 
-void *__switch_to(struct task_struct *from, struct task_struct *to)
+void arch_cpu_idle(void)
 {
-	__builtin_trap();
+	wasm_idle();
 }
 
+struct task_struct *__switch_to(struct task_struct *from,
+				struct task_struct *to)
+{
+	struct thread_info *from_info = task_thread_info(from);
+	struct thread_info *to_info = task_thread_info(to);
+
+	to_info->from_sched = from;
+
+	pr_info("context switch: %u -> %u\n", from->pid, to->pid);
+
+	current = to;
+	current_stack_pointer = task_pt_regs(to)->stack_pointer;
+
+	return from;
+}
+
+struct entry_arg {
+	struct thread_info *thread_info;
+	int (*fn)(void *);
+	void *fn_arg;
+};
+void show_stack(struct task_struct *task, unsigned long *sp,
+		const char *loglvl);
+
 int copy_thread(struct task_struct *p, const struct kernel_clone_args *args)
 {
-	__builtin_trap();
-}
+	struct entry_arg *entry;
+
+	if (!args->fn) {
+		panic("can't copy userspace thread");
+	}
+
+	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
+	if (!entry) return -ENOMEM;
+
+	entry->fn = args->fn;
+	entry->fn_arg = args->fn_arg;
+	entry->thread_info = task_thread_info(p);
+
+	pr_info("spawning: %p %p\n", entry, entry->fn);
+	wasm_new_worker(entry, p->comm);
+
+	return 0;
+}
+
+__attribute__((export_name("task_entry"))) void __init task_entry(struct entry_arg *entry)
+{
+	int (*fn)(void *) = entry->fn;
+	void *fn_arg = entry->fn_arg;
+	struct thread_info *thread_info = entry->thread_info;
+
+	tls_init();
+	current = thread_info->from_sched;
+
+	kfree(entry);
+
+	if (thread_info->from_sched)
+		schedule_tail(thread_info->from_sched);
+
+	fn(fn_arg);
+	do_exit(0);
+}

arch/wasm/kernel/setup.c

@@ -17,8 +17,7 @@ unsigned long volatile jiffies = INITIAL_JIFFIES;
 
 char __init_begin[0], __init_end[0];
 
-#undef current
-_Thread_local struct task_struct *current = { 0 };
+_Thread_local struct task_struct *current = &init_task;
 
 unsigned long init_stack[THREAD_SIZE / sizeof(unsigned long)];
 unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] = { 0 };
@@ -40,16 +39,18 @@ extern void __heap_base;
 extern void __heap_end;
 
 int __init setup_early_printk(char *buf);
-
-static char wasm_dt[1024];
+void __init smp_init_cpus(void);
 
 __attribute__((export_name("start"))) void __init _start(void)
 {
+	static char wasm_dt[1024];
 	__wasm_call_ctors();
 
 	setup_early_printk(NULL);
+
 	wasm_get_dt(wasm_dt, ARRAY_SIZE(wasm_dt));
 	early_init_dt_scan(wasm_dt);
+	early_init_fdt_scan_reserved_mem();
 
 	memblock_reserve(0, (phys_addr_t)&__heap_base);
 
@@ -95,12 +96,3 @@ void machine_power_off(void)
 	pr_info("poweroff\n");
 	__builtin_trap();
 }
-
-__attribute__((export_name("thread_entry"))) void __init
-_thread_entry(unsigned int worker)
-{
-	early_printk("thread entry = %u\n", current_thread_info()->worker);
-	current_thread_info()->worker = worker;
-	early_printk("             = %u\n", current_thread_info()->worker);
-	pr_info("entered new thread!\n");
-}