Initial commit

include/l4/generic/irq.h

@@ -0,0 +1,80 @@
+/*
+ * Generic irq handling definitions.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#ifndef __GENERIC_IRQ_H__
+#define __GENERIC_IRQ_H__
+
+#include <l4/lib/string.h>
+#include INC_PLAT(irq.h)
+
+/* Represents none or spurious irq */
+#define IRQ_NIL					(-1)
+
+/* Successful irq handling state */
+#define IRQ_HANDLED				0
+
+typedef void (*irq_op_t)(int irq);
+struct irq_chip_ops {
+	void (*init)(void);
+	int (*read_irq)(void);
+	irq_op_t ack_and_mask;
+	irq_op_t unmask;
+};
+
+struct irq_chip {
+	char name[32];
+	int level;		/* Cascading level */
+	int cascade;		/* The irq that lower chip uses on this chip */
+	int offset;		/* The global offset for this irq chip */
+	struct irq_chip_ops ops;
+};
+
+typedef int (*irq_handler_t)(void);
+struct irq_desc {
+	char name[8];
+	struct irq_chip *chip;
+
+	/* TODO: This could be a list for multiple handlers */
+	irq_handler_t handler;
+};
+
+extern struct irq_desc irq_desc_array[];
+extern struct irq_chip irq_chip_array[];
+
+static inline void irq_enable(int irq_index)
+{
+	struct irq_desc *this_irq = irq_desc_array + irq_index;
+	struct irq_chip *this_chip = this_irq->chip;
+
+	this_chip->ops.unmask(irq_index - this_chip->offset);
+}
+
+static inline void irq_disable(int irq_index)
+{
+	struct irq_desc *this_irq = irq_desc_array + irq_index;
+	struct irq_chip *this_chip = this_irq->chip;
+
+	this_chip->ops.ack_and_mask(irq_index - this_chip->offset);
+}
+
+static inline void register_irq(char *name, int irq_index, irq_handler_t handler)
+{
+	struct irq_desc *this_desc = irq_desc_array + irq_index;
+	struct irq_chip *current_chip = irq_chip_array;
+
+	strncpy(&this_desc->name[0], name, sizeof(this_desc->name));
+
+	for (int i = 0; i < IRQ_CHIPS_MAX; i++)
+		if (irq_index <= current_chip->offset) {
+			this_desc->chip = current_chip;
+			break;
+		}
+	this_desc->handler = handler;
+}
+
+void do_irq(void);
+void irq_controllers_init(void);
+
+#endif /* __GENERIC_IRQ_H__ */

include/l4/generic/kmalloc.h

@@ -0,0 +1,9 @@
+#ifndef __KMALLOC_H__
+#define __KMALLOC_H__
+
+void *kmalloc(int size);
+int kfree(void *p);
+void *kzalloc(int size);
+void init_kmalloc();
+
+#endif

include/l4/generic/pgalloc.h

@@ -0,0 +1,15 @@
+#ifndef __PGALLOC_H__
+#define __PGALLOC_H__
+
+void *zalloc_page(void);
+void *alloc_page(void);
+void *alloc_pmd(void);
+void *alloc_pgd(void);
+int free_page(void *);
+int free_pmd(void *);
+int free_pgd(void *);
+
+int pgalloc_add_new_grant(unsigned long pfn, int npages);
+void init_pgalloc();
+
+#endif /* __PGALLOC_H__ */

include/l4/generic/physmem.h

@@ -0,0 +1,45 @@
+/*
+ * Boot time memory initialisation and memory allocator interface.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ *
+ */
+#ifndef __GENERIC_PHYSMEM_H__
+#define __GENERIC_PHYSMEM_H__
+
+#include <l4/lib/list.h>
+#include INC_PLAT(offsets.h)
+#include INC_GLUE(memory.h)
+
+#define PHYSMEM_TOTAL_PAGES	((PHYS_MEM_END - PHYS_MEM_START) >> PAGE_BITS)
+
+/* A compact memory descriptor to determine used/unused pages in the system */
+struct page_bitmap {
+	unsigned long pfn_start;
+	unsigned long pfn_end;
+	unsigned int map[PHYSMEM_TOTAL_PAGES >> 5];
+};
+
+/* Describes a portion of physical memory. */
+struct memdesc {
+	unsigned int start;
+	unsigned int end;
+	unsigned int free_cur;
+	unsigned int free_end;
+	unsigned int numpages;
+};
+
+#if defined(__KERNEL__)
+/* Describes bitmap of used/unused state for all physical pages */
+extern struct page_bitmap page_map;
+extern struct memdesc physmem;
+#endif
+
+/* Sets the global page map as used/unused. Aligns input when needed. */
+int set_page_map(unsigned long start, int numpages, int val);
+
+/* Memory allocator interface */
+void physmem_init(void);
+void memory_init(void);
+
+#endif /* __GENERIC_PHYSMEM_H__ */

include/l4/generic/platform.h

@@ -0,0 +1,22 @@
+#ifndef __PLATFORM_H__
+#define __PLATFORM_H__
+/*
+ * Generic functions to be provided by every platform.
+ */
+
+void platform_init(void);
+
+/* Uart APIs */
+void uart_init(void);
+void uart_putc(char c);
+
+/* Timer APIs */
+void timer_init(void);
+void timer_start(void);
+
+/* IRQ controller */
+void irq_controller_init(void);
+void platform_irq_enable(int irq);
+void platform_irq_disable(int irq);
+
+#endif /* __PLATFORM_H__ */

include/l4/generic/preempt.h

@@ -0,0 +1,12 @@
+/*
+ * Kernel preemption functions.
+ */
+#ifndef __PREEMPT_H__
+#define __PREEMPT_H__
+
+void preempt_enable(void);
+void preempt_disable(void);
+int preemptive(void);
+int preempt_count(void);
+
+#endif /* __PREEMPT_H__ */

include/l4/generic/scheduler.h

@@ -0,0 +1,55 @@
+/*
+ * Scheduler and runqueue API definitions.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#ifndef __SCHEDULER_H__
+#define __SCHEDULER_H__
+
+#include <l4/generic/tcb.h>
+#include INC_SUBARCH(mm.h)
+#include INC_GLUE(memory.h)
+
+/* Ticks per second */
+#define HZ					1000
+#define	TASK_TIMESLICE_DEFAULT			1
+/* #define	TASK_TIMESLICE_DEFAULT			(HZ/100)*/
+
+static inline struct ktcb *current_task(void)
+{
+	register u32 stack asm("sp");
+	return (struct ktcb *)(stack & (~PAGE_MASK));
+}
+
+#define current			current_task()
+#define need_resched		(current->ts_need_resched)
+
+/* Flags set by kernel to direct the scheduler about future task state. */
+#define __SCHED_FL_SUSPEND		1
+#define SCHED_FL_SUSPEND		(1 << __SCHED_FL_SUSPEND)
+#define __SCHED_FL_RESUME		2
+#define SCHED_FL_RESUME			(1 << __SCHED_FL_RESUME)
+#define __SCHED_FL_SLEEP		3
+#define SCHED_FL_SLEEP			(1 << __SCHED_FL_SLEEP)
+#define SCHED_FL_MASK			(SCHED_FL_SLEEP | SCHED_FL_RESUME \
+					 | SCHED_FL_SUSPEND)
+
+#define __IPC_FL_WAIT			4
+#define IPC_FL_WAIT			(1 << __IPC_FL_WAIT)
+#define IPC_FL_MASK			IPC_FL_WAIT
+
+void sched_runqueue_init(void);
+void sched_start_task(struct ktcb *task);
+void sched_resume_task(struct ktcb *task);
+void sched_suspend_task(struct ktcb *task);
+void sched_process_post_ipc(struct ktcb *, struct ktcb *);
+void sched_tell(struct ktcb *task, unsigned int flags);
+void scheduler_start(void);
+void sched_yield(void);
+void schedule(void);
+/* Asynchronous notifications to scheduler */
+void sched_notify_resume(struct ktcb *task);
+void sched_notify_sleep(struct ktcb *task);
+void sched_notify_suspend(struct ktcb *task);
+
+#endif /* __SCHEDULER_H__ */

include/l4/generic/space.h

@@ -0,0 +1,21 @@
+/*
+ * Generic address space related information.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#ifndef __SPACE_H__
+#define __SPACE_H__
+
+/* The flags not embedded in the name behave as expected. E.g USR_RW is also */
+#define MAP_USR_RW_FLAGS	0	/* CB as one would expect */
+#define MAP_USR_RO_FLAGS	1	/* CB as one would expect */
+#define MAP_SVC_RW_FLAGS	2	/* CB as one would expect */
+#define MAP_USR_IO_FLAGS	3	/* Non-CB, RW */
+#define MAP_SVC_IO_FLAGS	4	/* Non-CB, RW */
+
+/* Some default aliases */
+#define	MAP_USR_DEFAULT_FLAGS	MAP_USR_RW_FLAGS
+#define MAP_SVC_DEFAULT_FLAGS	MAP_SVC_RW_FLAGS
+#define MAP_IO_DEFAULT_FLAGS	MAP_SVC_IO_FLAGS
+
+#endif /* __SPACE_H__ */

include/l4/generic/tcb.h

@@ -0,0 +1,154 @@
+/*
+ * Thread Control Block, kernel portion.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#ifndef __TCB_H__
+#define __TCB_H__
+
+#include <l4/lib/list.h>
+#include <l4/lib/mutex.h>
+#include <l4/generic/scheduler.h>
+#include <l4/generic/pgalloc.h>
+#include INC_GLUE(memory.h)
+#include INC_GLUE(syscall.h)
+#include INC_GLUE(utcb.h)
+#include INC_SUBARCH(mm.h)
+
+enum task_state {
+	TASK_INACTIVE	= 0,
+	TASK_SLEEPING	= 1,
+	TASK_RUNNABLE	= 2,
+};
+
+/*
+ * This describes the user space register context of each task. Simply set them
+ * as regular structure fields, and they'll be copied onto real registers upon
+ * a context switch. In the ARM case, they're copied from memory to userspace
+ * registers using the LDM instruction with ^, no-pc flavor. See ARMARM.
+ */
+typedef struct arm_context {
+	u32 spsr;	/* 0x0 */
+	u32 r0;		/* 0x4 */
+	u32 r1;		/* 0x8 */
+	u32 r2;		/* 0xC */
+	u32 r3;		/* 0x10 */
+	u32 r4;		/* 0x14 */
+	u32 r5;		/* 0x18 */
+	u32 r6; 	/* 0x1C */
+	u32 r7;		/* 0x20 */
+	u32 r8;		/* 0x24 */
+	u32 r9;		/* 0x28 */
+	u32 r10;	/* 0x2C */
+	u32 r11;	/* 0x30 */
+	u32 r12;	/* 0x34 */
+	u32 sp;		/* 0x38 */
+	u32 lr;		/* 0x3C */
+	u32 pc;		/* 0x40 */
+} __attribute__((__packed__)) task_context_t;
+
+#define TASK_ID_INVALID			-1
+struct task_ids {
+	l4id_t tid;
+	l4id_t spid;
+};
+
+struct ktcb {
+	/* User context */
+	task_context_t context;
+
+	/* Reference to syscall saved context */
+	syscall_args_t *syscall_regs;
+
+	/* Runqueue related */
+	struct list_head rq_list;
+	struct runqueue *rq;
+
+	/* Thread information */
+	l4id_t tid;		/* Global thread id */
+	l4id_t spid;		/* Global space id */
+
+	/* Flags to hint scheduler on future task state */
+	unsigned int schedfl;
+	unsigned int flags;
+
+	/* Other related threads */
+	l4id_t pagerid;
+
+	u32 ts_need_resched;	/* Scheduling flag */
+	enum task_state state;
+	struct list_head task_list; /* Global task list. */
+	struct utcb *utcb;	/* Reference to task's utcb area */
+
+	/* Thread times */
+	u32 kernel_time;	/* Ticks spent in kernel */
+	u32 user_time;		/* Ticks spent in userland */
+	u32 ticks_left;		/* Ticks left for reschedule */
+
+	/* Page table information */
+	pgd_table_t *pgd;
+
+	/* Fields for ipc rendezvous */
+	struct waitqueue_head wqh_recv;
+	struct waitqueue_head wqh_send;
+
+	/* Fields for checking parties blocked from doing ipc */
+	struct spinlock ipc_block_lock;
+	struct list_head ipc_block_list;
+
+	l4id_t senderid;	/* Sender checks this for ipc */
+};
+
+/* Per thread kernel stack unified on a single page. */
+union ktcb_union {
+	struct ktcb ktcb;
+	char kstack[PAGE_SIZE];
+};
+
+/* For traversing global task list */
+extern struct list_head global_task_list;
+static inline struct ktcb *find_task(l4id_t tid)
+{
+	struct ktcb *task;
+
+	list_for_each_entry(task, &global_task_list, task_list)
+		if (task->tid == tid)
+			return task;
+	return 0;
+}
+
+static inline int add_task_global(struct ktcb *new)
+{
+	INIT_LIST_HEAD(&new->task_list);
+	list_add(&new->task_list, &global_task_list);
+	return 0;
+}
+
+
+static inline void set_task_flags(struct ktcb *task, unsigned int fl)
+{
+	task->flags |= fl;
+}
+
+/*
+ * Each task is allocated a unique global id. A thread group can only belong to
+ * a single leader, and every thread can only belong to a single thread group.
+ * These rules allow the fact that every global id can be used to define a
+ * unique thread group id. Thread local ids are used as an index into the thread
+ * group's utcb area to discover the per-thread utcb structure.
+ */
+static inline void set_task_ids(struct ktcb *task, struct task_ids *ids)
+{
+	task->tid = ids->tid;
+	task->spid = ids->spid;
+}
+
+#define THREAD_IDS_MAX		1024
+#define SPACE_IDS_MAX		1024
+
+
+extern struct id_pool *thread_id_pool;
+extern struct id_pool *space_id_pool;
+
+#endif /* __TCB_H__ */
+

include/l4/generic/thread.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#ifndef __THREAD_H__
+#define __THREAD_H__
+
+
+/* Thread id creation and deleting */
+void thread_id_pool_init(void);
+int thread_id_new(void);
+int thread_id_del(int tid);
+
+
+#endif /* __THREAD_H__ */

include/l4/generic/time.h

@@ -0,0 +1,14 @@
+/*
+ * System time keeping definitions
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+
+#ifndef __GENERIC_TIMER_H__
+#define __GENERIC_TIMER_H__
+
+extern volatile u32 jiffies;
+
+int do_timer_irq(void);
+
+#endif /* __GENERIC_TIMER_H__ */