Very basic thread switching.

- Kernel spawns two threads that run in userland and it switches by turns.
- Add a DELAY function.

Author: tuxillo

Makefile

@@ -28,14 +28,18 @@ OBJFILES+= startup.o
 OBJFILES+= exception.o
 OBJFILES+= subr_prf.o
 OBJFILES+= user.o
+OBJFILES+= thread.o
+OBJFILES+= syscalls.o
 
 boot.bin: boot.elf
 	$(OBJCOPY) -O binary boot.elf boot.bin
 
 boot.elf: clean subr_prf.o boot.o startup.o user.o
 	$(CC) -c subr_prf.c $(CFLAGS)
 	$(CC) -c user.c $(CFLAGS)
-	$(CC) -c boot.c $(CFLAGS) boot.c
+	$(CC) -c boot.c $(CFLAGS)
+	$(CC) -c thread.c $(CFLAGS)
+	$(CC) -c syscalls.c $(CFLAGS)
 	$(AS) startup.S -o startup.o
 	$(AS) exception.S -o exception.o
 	$(LD) -T boot.ld -nodefaultlibs -nostdlib \

boot.c

@@ -30,12 +30,15 @@
 #include <types.h>
 #include <subr.h>
 #include <cpufunc.h>
+#include <syscalls.h>
+#include <thread.h>
 
 extern unsigned int *__bss_start;
 extern unsigned int *__bss_end;
 
 void kern_boot(void);
 void clearbss(void);
+void usermode(void);
 
 void clearbss(void)
 {
@@ -49,6 +52,30 @@ void clearbss(void)
 
 }
 
+int
+proc1(void *arg)
+{
+	for(;;) {
+		kprintf("[usr] running process 1\n");
+		DELAY(500000);
+		syscall_entry(SYS_YIELD, NULL);
+		kprintf("[usr] again process 1\n");
+	}
+	return 0;
+}
+
+int
+proc2(void *arg)
+{
+	for(;;) {
+		kprintf("[usr] running process 2\n");
+		DELAY(500000);
+		syscall_entry(SYS_YIELD, NULL);
+		kprintf("[usr] again process 2\n");
+	}
+	return 0;
+}
+
 void
 kern_boot(void)
 {
@@ -58,6 +85,12 @@ kern_boot(void)
 	/* Startup */
 	clearbss();
 
-	/* Switch to user mode */
-	_gouser();
+	thread_create(proc1);
+	thread_create(proc2);
+
+	/* Run all user mode threads */
+	run_threads();
+
+	/* Loop forever */
+	for (;;);
 }

cpufunc.h

@@ -43,9 +43,18 @@ _read_cpsr(void)
 }
 
 static __inline void
-syscall_entry(int syscall)
+syscall_entry(int syscall, void *arg)
 {
 	__asm __volatile("svc #0x0");
 }
 
+static void
+DELAY(uint32_t usec)
+{
+	int counts;
+	for (; usec > 0; usec--)
+		for (counts = 200; counts > 0; counts--)
+			;
+}
+
 #endif /* _CPUFUNC_H_ */

exception.S

@@ -35,13 +35,22 @@
 	.global _e_fiq
 
 _e_undef:
+	ldr r0, =undef_text
+	bl kprintf
 	bl .
 
 _e_svc:
-	mov r1, r0		@ Move syscall no. to r1
-	ldr r0, =syscall_text	@ Load format string
-	bl kprintf
-	bl .
+	msr cpsr_c, #0x1f	@ Switch to system mode
+	mov r5, lr		@ Save LR of the user thread
+	msr cpsr_c, #0xd3
+	bl  syscall_handler
+	cmp r0, #1
+	beq ret_svc
+	mov lr, r5
+	subs pc, lr, #0
+ret_svc:
+	ldmfd sp!, {r0-r11, ip,lr}
+	bx lr
 
 _e_pref_abort:
 	bl .
@@ -57,3 +66,6 @@ _e_fiq:
 
 syscall_text:
 	.asciz "[svc] Syscall %d used!\n"
+
+undef_text:
+	.asciz "[und] Undefined exception %p\n"

startup.S

@@ -84,11 +84,23 @@ _gouser:
 	 *
 	 * Since System mode doesn't have its own registers for
 	 * SP, LR it shares them with User mode.
-	 */
-	msr spsr_cxsf, #0	@ Reset SPSR
+	*/
+	stmfd sp!, {r0-r11,ip,lr}
+
 	msr cpsr_c, #0x1f	@ Switch to System mode
+	cmp r1, #0		@ Check if stack passed
+	bne _load_custom_stack	@ Set another stack if one is passed
 	ldr sp, =usrstack_top	@ Set stack for user/sys mode
+	bl  _swi
+
+_load_custom_stack:
+	mov sp, r1		@ Set a thread stack
+
+_swi:
 	msr cpsr_c, #0xd3	@ Switch to svc mode
+	mrs r4, cpsr		@ For saving SPSR
+	msr spsr, r4		@ Read in CSPR to SPSR for manipulation
 	msr spsr_c, #0x10	@ User mode for the exception return
-	ldr lr, =usermode	@ Userland function to switch to
+	mov lr, r0		@ Userland function to switch to
 	subs pc, lr, #0		@ Exception return
+

syscalls.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2016, Antonio Huete Jimenez <[email protected]>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ;
+ * LOSS OF USE, DATA, OR PROFITS ; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those
+ * of the authors and should not be interpreted as representing official policies,
+ * either expressed or implied, of the author.
+ */
+
+#include <types.h>
+#include <cpufunc.h>
+#include <syscalls.h>
+#include <subr.h>
+
+int
+syscall_handler(int syscall, void *arg)
+{
+	static int cycle = 0;
+
+	switch(syscall) {
+	case SYS_RET:
+		run_threads();
+		break;
+	case SYS_DUMMY:
+		kprintf("[svc] Called SYS_DUMMY\n");
+		break;
+	case SYS_THREAD:
+		thread_create(arg);
+		break;
+	case SYS_YIELD:
+		if (cycle == 0)
+			return cycle++;
+		else if (cycle == 1)
+			return cycle--;
+		break;
+	default:
+		kprintf("[svc] Invalid syscall %d\n", syscall);
+		break;
+	}
+
+	return 0;
+}

syscalls.h

@@ -32,6 +32,9 @@
 
 #include <types.h>
 
-#define SYSCALL_DUMMY	0x1
+#define SYS_RET		0x0
+#define SYS_DUMMY	0x1
+#define SYS_THREAD	0x2
+#define SYS_YIELD	0x3
 
 #endif /* _SYSCALLS_H_ */

thread.c

@@ -0,0 +1,47 @@
+#include <cpufunc.h>
+#include <thread.h>
+
+int nthreads;
+unsigned char thread_stack[MAXTHREADS][STACKSIZE];
+struct thread threads[MAXTHREADS];
+
+struct thread *
+thread_create(int(*func)(void *))
+{
+	int current = nthreads;
+
+	if (nthreads >= MAXTHREADS) {
+		kprintf("Maximum number of threads reached\n");
+		return NULL;
+	}
+
+	threads[current].tid = current;
+	threads[current].stack = thread_stack[current] + STACKSIZE - 1;
+	threads[current].func = func;
+	nthreads++;
+
+	kprintf("[svc] Created thread %d\n", current);
+
+	return &threads[current];
+}
+
+void
+thread_destroy(struct thread *t)
+{
+}
+
+void
+run_threads(void)
+{
+	int current;
+
+	if (nthreads == 0)
+		return;
+
+	for (;;) {
+		for (current = 0; current < nthreads; current++) {
+			/* Run thread function */
+			_gouser(threads[current].func, threads[current].stack);
+		}
+	}
+}

thread.h

@@ -0,0 +1,16 @@
+#ifndef _THREAD_H_
+#define _THREAD_H_
+
+#define MAXTHREADS	16
+#define STACKSIZE	4096
+extern int nthreads;
+
+struct thread *thread_create(int(*func)(void *));
+
+struct thread {
+	int tid;
+	unsigned char *stack;
+	int (*func)(void *);
+};
+
+#endif /* _THREAD_H_ */

user.c

@@ -31,10 +31,15 @@
 #include <cpufunc.h>
 #include <syscalls.h>
 #include <subr.h>
+#include <thread.h>
 
 void
 usermode(void)
 {
-	kprintf("[usr] calling svc with syscall %d\n", SYSCALL_DUMMY);
-	syscall_entry(SYSCALL_DUMMY);
+	kprintf("[usr] calling svc with syscall %d\n", SYS_DUMMY);
+/*	syscall_entry(SYS_DUMMY, NULL);
+	syscall_entry(SYS_THREAD, proc1);
+	syscall_entry(SYS_THREAD, proc2);
+	syscall_entry(SYS_RET, NULL);
+*/
 }