unified/arm: add unified kernel support for ARM arch

The ARM architecture port is fitted with support for the unified kernel,
namely:

- the interrupt/exception exit code now pends PendSV if the current
  thread is not a coop thread and if the scheduler is not locked

- fiber_abort is replaced by k_thread_abort(), which takes a thread ID
  as a parameter (i.e. does not only operate on the current thread)

- the _nanokernel.flags cache of _current.flags is not used anymore
  (could be a source of bugs) and is not needed in the scheduling algo

- there is no 'task' field in the _nanokernel anymore: PendSV not calls
  _get_next_ready_thread instead

- the _nanokernel.fiber field is replaced by a more sophisticated
  ready_q, based on the microkernel's priority-bitmap-based one

- thread initialization initializes new fields in the tcs, and does not
  initialize obsolete ones

- nano_private includes nano_internal.h from the unified directory

- The FIBER, TASK and PREEMPTIBLE flags do not exist anymore: the thread
  priority drives the behaviour

- the tcs uses a dlist for queuing in both ready and wait queues instead
  of a custom singly-linked list

- other new fields in the tcs include a schedule-lock count, a
  back-pointer to init data (when the task is static) and a pointer to
  swap data, needed when a thread pending on _Swap() must be passed more
  then just one value (e.g. k_stack_pop() needs an error code and data)

- the 'fiber' and 'task' fields of _nanokernel are replaced with an O(1)
  ready queue (taken from the microkernel)

- fiberRtnValueSet() is aliased to _set_thread_return_value since it
  also operates on preempt threads now

- _set_thread_return_value_with_data() sets the swap_data field in
  addition to a return value from _Swap()

- convenience aliases are created for shorter names:

  - _current is defined as _nanokernel.current
  - _ready_q is defined as _nanokernel.ready_q

- _Swap() sets the threads's return code to -EAGAIN before swapping out
  to prevent timeouts to have to set it (solves hard issues in some
  kernel objects).

Change-Id: I36c03c362bc2908dae064ec67e6b8469fc573983
Signed-off-by: Benjamin Walsh <benjamin.walsh@windriver.com>

arch/arm/core/Makefile

@@ -1,17 +1,27 @@
+ifeq ($(CONFIG_KERNEL_V2),y)
+ccflags-y += -I$(srctree)/kernel/unified/include
+else
 ccflags-y += -I$(srctree)/kernel/nanokernel/include
 ccflags-y += -I$(srctree)/kernel/microkernel/include
+endif
 
 asflags-y := ${ccflags-y}
 
 obj-y = exc_exit.o irq_init.o \
-	fiber_abort.o swap.o \
+	swap.o \
 	fault.o \
 	irq_manage.o thread.o cpu_idle.o \
 	fault_s.o isr_wrapper.o \
 	fatal.o sys_fatal_error_handler.o
 
+ifeq ($(CONFIG_KERNEL_V2),y)
+obj-y += thread_abort.o
+else
+obj-y += fiber_abort.o
+obj-$(CONFIG_MICROKERNEL) += task_abort.o
+endif
+
 obj-$(CONFIG_GDB_INFO) += gdb_stub_irq_vector_table.o gdb_stub.o
 obj-$(CONFIG_CPLUSPLUS) += __aeabi_atexit.o
-obj-$(CONFIG_MICROKERNEL) += task_abort.o
 obj-$(CONFIG_IRQ_OFFLOAD) += irq_offload.o
 obj-$(CONFIG_CPU_CORTEX_M) += cortex_m/

arch/arm/core/cortex_m/Makefile

@@ -1,6 +1,10 @@
 ccflags-y +=-I$(srctree)/include/drivers
 ccflags-y +=-I$(srctree)/arch/arm/soc/$(SOC_PATH)
+ifeq ($(CONFIG_KERNEL_V2),y)
+ccflags-y +=-I$(srctree)/kernel/unified/include
+else
 ccflags-y +=-I$(srctree)/kernel/nanokernel/include
+endif
 
 asflags-y = $(ccflags-y)
 

arch/arm/core/exc_exit.S

@@ -37,6 +37,10 @@ GTEXT(_ExcExit)
 GTEXT(_IntExit)
 GDATA(_nanokernel)
 
+#ifdef CONFIG_KERNEL_V2
+GTEXT(__must_switch_threads)
+#endif
+
 #if CONFIG_GDB_INFO
   #define _EXIT_EXC_IF_FIBER_PREEMPTED beq _ExcExitWithGdbStub
 #else
@@ -92,6 +96,31 @@ SECTION_SUBSEC_FUNC(TEXT, _HandlerModeExit, _ExcExit)
 
     ldr r1, =_nanokernel
 
+#ifdef CONFIG_KERNEL_V2
+	ldr r1, [r1, #__tNANO_current_OFFSET]
+
+	ldr r2, [r1, #__tTCS_prio_OFFSET]
+	ldr r3, [r1, #__tTCS_sched_locked_OFFSET]
+
+	/* coop thread ? do not schedule */
+	cmp r2, #0
+	it lt
+	  bxlt lr
+
+	/* scheduler locked ? do not schedule */
+	cmp r3, #0
+	it gt
+	  bxgt lr
+
+	push {lr}
+	blx __must_switch_threads
+	pop {lr}
+	cmp r0, #0
+	it eq
+	  bxeq lr
+
+#else
+
     /* is the current thread preemptible (task) ? */
     ldr r2, [r1, #__tNANO_flags_OFFSET]
     ands.w r2, #PREEMPTIBLE
@@ -102,6 +131,8 @@ SECTION_SUBSEC_FUNC(TEXT, _HandlerModeExit, _ExcExit)
     cmp r2, #0
     _EXIT_EXC_IF_FIBER_NOT_READY
 
+#endif
+
     /* context switch required, pend the PendSV exception */
     ldr r1, =_SCS_ICSR
     ldr r2, =_SCS_ICSR_PENDSV

arch/arm/core/offsets/offsets.c

@@ -39,7 +39,9 @@
 
 /* ARM-specific tNANO structure member offsets */
 
+#if !defined(CONFIG_KERNEL_V2)
 GEN_OFFSET_SYM(tNANO, flags);
+#endif
 #ifdef CONFIG_SYS_POWER_MANAGEMENT
 GEN_OFFSET_SYM(tNANO, idle);
 #endif

arch/arm/core/swap.S

@@ -34,6 +34,10 @@ _ASM_FILE_PROLOGUE
 GTEXT(_Swap)
 GTEXT(__svc)
 GTEXT(__pendsv)
+#ifdef CONFIG_KERNEL_V2
+GTEXT(_get_next_ready_thread)
+GDATA(_k_neg_eagain)
+#endif
 
 GDATA(_nanokernel)
 
@@ -97,6 +101,12 @@ SECTION_FUNC(TEXT, __pendsv)
 
     /* find out incoming thread (fiber or task) */
 
+#ifdef CONFIG_KERNEL_V2
+    push {lr}
+    blx _get_next_ready_thread
+    pop {lr}
+    movs.n r2, r0
+#else
     /* is there a fiber ready ? */
     ldr r2, [r1, #__tNANO_fiber_OFFSET]
     cmp r2, #0
@@ -109,10 +119,13 @@ SECTION_FUNC(TEXT, __pendsv)
 	ldrne.w r0, [r2, #__tTCS_link_OFFSET]   /* then */
 	strne.w r0, [r1, #__tNANO_fiber_OFFSET] /* then */
 	ldreq.w r2, [r1, #__tNANO_task_OFFSET]  /* else */
+#endif
 
     /* r2 contains the new thread */
+#if !defined(CONFIG_KERNEL_V2)
     ldr r0, [r2, #__tTCS_flags_OFFSET]
     str r0, [r1, #__tNANO_flags_OFFSET]
+#endif
     str r2, [r1, #__tNANO_current_OFFSET]
 
     /*
@@ -189,6 +202,18 @@ SECTION_FUNC(TEXT, __svc)
 _context_switch:
 #endif
 
+#if CONFIG_KERNEL_V2
+    /*
+     * Set _Swap()'s default return code to -EAGAIN. This eliminates the
+     * need for the timeout code to invoke fiberRtnValueSet().
+     */
+
+    mrs  r2, PSP   /* thread mode, stack frame is on PSP */
+    ldr  r3, =_k_neg_eagain
+    ldr  r3, [r3, #0]
+    str  r3, [r2, #__tESF_a1_OFFSET]
+#endif
+
     /*
      * Unlock interrupts:
      * - in a SVC call, so protected against context switches

arch/arm/core/sys_fatal_error_handler.c

@@ -26,6 +26,10 @@
 #include <toolchain.h>
 #include <sections.h>
 
+#ifdef CONFIG_KERNEL_V2
+#include <nano_private.h>
+#endif
+
 #ifdef CONFIG_PRINTK
 #include <misc/printk.h>
 #define PRINTK(...) printk(__VA_ARGS__)
@@ -34,11 +38,16 @@
 #endif
 
 #ifdef CONFIG_MICROKERNEL
-extern void _TaskAbort(void);
 static inline void nonEssentialTaskAbort(void)
 {
 	PRINTK("Fatal fault in task ! Aborting task.\n");
+
+#if defined(CONFIG_KERNEL_V2)
+	k_thread_abort(_current);
+#else
+	extern void _TaskAbort(void);
 	_TaskAbort();
+#endif
 }
 #define NON_ESSENTIAL_TASK_ABORT() nonEssentialTaskAbort()
 #else

arch/arm/core/thread.c

@@ -94,8 +94,8 @@ static ALWAYS_INLINE void _thread_monitor_init(struct tcs *tcs /* thread */
  * @param parameter1 entry point to the first param
  * @param parameter2 entry point to the second param
  * @param parameter3 entry point to the third param
- * @param priority thread priority (-1 for tasks)
+ * @param priority thread priority
- * @param misc options (future use)
+ * @param options thread options: ESSENTIAL, USE_FP
  *
  * @return N/A
  */
@@ -130,8 +130,18 @@ void _new_thread(char *pStackMem, unsigned stackSize,
 	pInitCtx->xpsr =
 		0x01000000UL; /* clear all, thumb bit is 1, even if RO */
 
+#ifdef CONFIG_KERNEL_V2
+	/* k_q_node initialized upon first insertion in a list */
+	tcs->flags = options | K_PRESTART;
+	tcs->sched_locked = 0;
+
+	/* static threads overwrite it afterwards with real value */
+	tcs->init_data = NULL;
+	tcs->fn_abort = NULL;
+#else
 	tcs->link = NULL;
 	tcs->flags = priority == -1 ? TASK | PREEMPTIBLE : FIBER;
+#endif
 	tcs->prio = priority;
 
 #ifdef CONFIG_THREAD_CUSTOM_DATA
@@ -148,7 +158,7 @@ void _new_thread(char *pStackMem, unsigned stackSize,
 	tcs->entry = (struct __thread_entry *)(pInitCtx);
 #endif
 
-#ifdef CONFIG_MICROKERNEL
+#if !defined(CONFIG_KERNEL_V2) && defined(CONFIG_MICROKERNEL)
 	tcs->uk_task_ptr = uk_task_ptr;
 #else
 	ARG_UNUSED(uk_task_ptr);

arch/arm/core/thread_abort.c

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016 Wind River Systems, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file
+ * @brief ARM Cortex-M k_thread_abort() routine
+ *
+ * The ARM Cortex-M architecture provides its own k_thread_abort() to deal
+ * with different CPU modes (handler vs thread) when a thread aborts. When its
+ * entry point returns or when it aborts itself, the CPU is in thread mode and
+ * must call _Swap() (which triggers a service call), but when in handler
+ * mode, the CPU must exit handler mode to cause the context switch, and thus
+ * must queue the PendSV exception.
+ */
+
+#include <kernel.h>
+#include <nano_private.h>
+#include <toolchain.h>
+#include <sections.h>
+#include <sched.h>
+#include <wait_q.h>
+
+extern void _k_thread_single_abort(struct tcs *thread);
+
+void k_thread_abort(k_tid_t thread)
+{
+	unsigned int key;
+
+	key = irq_lock();
+
+	_k_thread_single_abort(thread);
+
+	if (_current == thread) {
+		if (_ScbIsInThreadMode()) {
+			_Swap(key);
+			CODE_UNREACHABLE;
+		} else {
+			_ScbPendsvSet();
+		}
+	}
+
+	/* The abort handler might have altered the ready queue. */
+	_reschedule_threads(key);
+}

arch/arm/include/nano_private.h

@@ -39,9 +39,15 @@ extern "C" {
 #include <arch/cpu.h>
 
 #ifndef _ASMLANGUAGE
+#ifdef CONFIG_KERNEL_V2
+#include <kernel.h>
+#include <../../../kernel/unified/include/nano_internal.h>
+#else
 #include <../../../kernel/nanokernel/include/nano_internal.h>
+#endif
 #include <stdint.h>
 #include <misc/dlist.h>
+#include <atomic.h>
 #endif
 
 #ifndef _ASMLANGUAGE
@@ -93,17 +99,32 @@ typedef struct preempt tPreempt;
 
 /* Bitmask definitions for the struct tcs.flags bit field */
 
+#ifdef CONFIG_KERNEL_V2
+#define K_STATIC  0x00000800
+
+#define K_READY              0x00000000    /* Thread is ready to run */
+#define K_TIMING             0x00001000    /* Thread is waiting on a timeout */
+#define K_PENDING            0x00002000    /* Thread is waiting on an object */
+#define K_PRESTART           0x00004000    /* Thread has not yet started */
+#define K_DEAD               0x00008000    /* Thread has terminated */
+#define K_SUSPENDED          0x00010000    /* Thread is suspended */
+#define K_DUMMY              0x00020000    /* Not a real thread */
+#define K_EXECUTION_MASK    (K_TIMING | K_PENDING | K_PRESTART | \
+			     K_DEAD | K_SUSPENDED | K_DUMMY)
+#else
 #define FIBER 0x000
 #define TASK 0x001	   /* 1 = task, 0 = fiber   */
-#define INT_ACTIVE 0x002     /* 1 = executing context is interrupt handler */
+#define INT_ACTIVE 0x002     /* 1 = executino context is interrupt handler */
-#define EXC_ACTIVE 0x004     /* 1 = executing context is exception handler */
+#define EXC_ACTIVE 0x004     /* 1 = executino context is exception handler */
-#define USE_FP 0x010	 /* 1 = thread uses floating point unit */
 #define PREEMPTIBLE                                            \
 	0x020 /* 1 = preemptible thread                       \
 	       * NOTE: the value must be < 0x100 to be able to \
 	       *       use a small thumb instr with immediate  \
 	       *       when loading PREEMPTIBLE in a GPR       \
 	       */
+#endif
+
+#define USE_FP 0x010	 /* 1 = thread uses floating point unit */
 #define ESSENTIAL 0x200  /* 1 = system thread that must not abort */
 #define NO_METRICS 0x400 /* 1 = _Swap() not to update task metrics */
 
@@ -140,11 +161,28 @@ struct preemp_float {
 };
 #endif
 
+#if CONFIG_KERNEL_V2
+/* 'struct tcs_base' must match the beginning of 'struct tcs' */
+struct tcs_base {
+	sys_dnode_t  k_q_node;
+	uint32_t     flags;
+	int          prio;
+	void        *swap_data;
+};
+#endif
+
 struct tcs {
+#if CONFIG_KERNEL_V2
+	sys_dnode_t k_q_node;	/* node object in any kernel queue */
+	uint32_t    flags;
+	int         prio;
+	void       *swap_data;
+#else
 	struct tcs *link; /* singly-linked list in _nanokernel.fibers */
 	uint32_t flags;
-	uint32_t basepri;
 	int prio;
+#endif
+	uint32_t basepri;
 #ifdef CONFIG_THREAD_CUSTOM_DATA
 	void *custom_data;     /* available for custom use */
 #endif
@@ -154,15 +192,25 @@ struct tcs {
 	struct __thread_entry *entry; /* thread entry and parameters description */
 	struct tcs *next_thread; /* next item in list of ALL fiber+tasks */
 #endif
-#ifdef CONFIG_NANO_TIMEOUTS
+#if !defined(CONFIG_KERNEL_V2) && defined(CONFIG_NANO_TIMEOUTS)
 	struct _nano_timeout nano_timeout;
 #endif
 #ifdef CONFIG_ERRNO
 	int errno_var;
 #endif
+#if !defined(CONFIG_KERNEL_V2)
 #ifdef CONFIG_MICROKERNEL
 	void *uk_task_ptr;
 #endif
+#endif
+#ifdef CONFIG_KERNEL_V2
+#ifdef CONFIG_NANO_TIMEOUTS
+	struct _timeout timeout;
+#endif
+	atomic_t sched_locked;
+	void *init_data;
+	void (*fn_abort)(void);
+#endif
 #ifdef CONFIG_FLOAT
 	/*
 	 * No cooperative floating point register set structure exists for
@@ -173,11 +221,22 @@ struct tcs {
 #endif
 };
 
+#ifdef CONFIG_KERNEL_V2
+struct ready_q {
+	uint32_t prio_bmap[1];
+	sys_dlist_t q[K_NUM_PRIORITIES];
+};
+#endif
+
 struct s_NANO {
+#if !defined(CONFIG_KERNEL_V2)
 	struct tcs *fiber;   /* singly linked list of runnable fiber */
 	struct tcs *task;    /* pointer to runnable task */
+#endif
 	struct tcs *current; /* currently scheduled thread (fiber or task) */
+#if !defined(CONFIG_KERNEL_V2)
 	int flags;     /* struct tcs->flags of 'current' thread */
+#endif
 
 #if defined(CONFIG_THREAD_MONITOR)
 	struct tcs *threads; /* singly linked list of ALL fiber+tasks */
@@ -195,6 +254,9 @@ struct s_NANO {
 	sys_dlist_t timeout_q;
 	int32_t task_timeout;
 #endif
+#ifdef CONFIG_KERNEL_V2
+	struct ready_q ready_q;
+#endif
 };
 
 typedef struct s_NANO tNANO;
@@ -207,7 +269,9 @@ extern void _FaultInit(void);
 extern void _CpuIdleInit(void);
 static ALWAYS_INLINE void nanoArchInit(void)
 {
+#if !defined(CONFIG_KERNEL_V2)
 	_nanokernel.flags = FIBER;
+#endif
 	_InterruptStackSetup();
 	_ExcSetup();
 	_FaultInit();
@@ -235,9 +299,25 @@ static ALWAYS_INLINE void fiberRtnValueSet(struct tcs *fiber,
 	pEsf->a1 = value;
 }
 
+#ifdef CONFIG_KERNEL_V2
+	#define _current _nanokernel.current
+	#define _ready_q _nanokernel.ready_q
+	#define _timeout_q _nanokernel.timeout_q
+	#define _set_thread_return_value fiberRtnValueSet
+static ALWAYS_INLINE void
+_set_thread_return_value_with_data(struct k_thread *thread, unsigned int value,
+				   void *data)
+{
+	_set_thread_return_value(thread, value);
+	thread->swap_data = data;
+}
+	#define _IDLE_THREAD_PRIO (CONFIG_NUM_PREEMPT_PRIORITIES)
+#endif /* CONFIG_KERNEL_V2 */
+
 extern void nano_cpu_atomic_idle(unsigned int);
 
 #define _IS_IN_ISR() _IsInIsr()
+#define _is_in_isr() _IsInIsr()
 
 extern void _IntLibInit(void);