iris/kernel.hhp

#pypp 0
// Iris: micro-kernel for a capability-based operating system.
// kernel.hhp: Header for all kernel sources.
// Copyright 2009 Bas Wijnen <wijnen@debian.org>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef _KERNEL_HH
#define _KERNEL_HH

// Include definitions which are shared with user space.
#define __KERNEL
#include "iris.hh"

// Normally define all variables in this file as extern.
// Exactly once (in data.ccp), EXTERN is predefined empty.
// That results in space being allocated in its object file.
#ifndef EXTERN
#define EXTERN extern
#endif

struct kPage
struct kThread
struct kMessage
struct kReceiver
struct kCapability
struct kCaps
struct kMemory

typedef kPage *kPageP
typedef kThread *kThreadP
typedef kMessage *kMessageP
typedef kReceiver *kReceiverP
typedef kCapability *kCapabilityP
typedef kCaps *kCapsP
typedef kMemory *kMemoryP
typedef void *kPointer

struct kCapRef:
	kCapsP caps
	unsigned index
	inline kCapability *deref ()
	bool valid ():
		return deref () != NULL
	kCapability *operator-> ():
		return deref ()
	void reset ():
		caps = NULL
	kCapRef (kCapsP c, unsigned i) : caps (c), index (i):
	kCapRef () : caps (NULL), index (~0):
	inline void clone (kCapRef source, bool copy)
	inline void set (kReceiver *target, Num pdata, kCapRef parent, kCapRef *parent_ptr = NULL)

struct kObject:
	kCapRef refs
	kMemoryP address_space
	// Next and previous object of the same type in any page.
	kPointer prev, next
	inline bool is_free ()

struct kFree : public kObject:
	// This marker is ~0.  No other kernel structure may allow this value
	// at this point.  It is used to recognize free chunks.
	unsigned marker

bool kObject::is_free ():
	return ((kFree *)this)->marker == ~0

// Include architecture-specific parts.
#include "arch.hh"

struct kMessage : public kObject:
	Num cap_protected
	Num data[2]
	kCapsP caps

struct kCapability : public kObject:
	struct Context:
		Num data[2]
		kCaps *caps
	kReceiverP target
	kCapRef parent
	kCapRef children
	kCapRef sibling_prev, sibling_next
	Num cap_protected
	inline void invoke (kCapability::Context *c)
	void invalidate ()

struct kThread : public kObject:
	kReceiverP receivers
	unsigned pc, sp
	kThread_arch arch
	unsigned flags
	kThreadP schedule_prev, schedule_next
	unsigned recv_slot
	// caps is an array of slots pointers to kCapses.
	unsigned slots
	// TODO: handle freeing of capses which are in use.
	kCapsP caps[1]
	void raise (unsigned code, unsigned data)
	void run ()
	void unrun ()
	void wait ()
	void unwait ()
	bool is_waiting ():
		return flags & Thread::WAITING
	kCapRef find_capability (unsigned code, bool *copy)
	void fill_slot (unsigned slot, kCaps *new_caps)

struct kReceiver : public kObject:
	kThreadP owner
	kReceiverP prev_owned, next_owned
	kReceiverP prev_alarm, next_alarm
	unsigned alarm_count
	// random is used like the tlb random register to find invalid caps to store the message to.
	unsigned random
	kCapsP caps
	// These are capabilities which call this receiver on invoke.
	kCapRef capabilities
	// The message queue.  kMessages are added at the tail, and removed at the front.
	kMessageP messages
	kMessageP last_message
	Num recv_protected
	Num reply_protected_data
	bool protected_only
	// This limit is for messages stored in its address space.  There is unlimited space if senders provide it.
	unsigned queue_limit
	void own (kThreadP o)
	void orphan ()
	bool try_deliver ()
	bool send_message (Num cap_protected, kCapability::Context *c)

struct kPage : public kObject:
	unsigned frame
	unsigned flags
	kPageP share_first
	kPageP share_prev, share_next
	kPage_arch arch
	void forget ()

struct kCaps : public kObject:
	unsigned size
	kCapability caps[1]
	kCapability *cap (unsigned idx):
		return &caps[idx]
	void set (unsigned index, kReceiver *target, Num pdata, kCapRef parent, kCapRef *parent_ptr = NULL)
	void clone (unsigned index, kCapRef source, bool copy)

struct kMemory : public kObject:
	kFree *frees
	kPageP pages
	kThreadP threads
	kReceiverP receivers
	kCapsP capses
	kMemoryP memories
	unsigned limit, used
	kMemory_arch arch

	inline bool map (kPage *page, unsigned address, bool readonly)
	inline void unmap (kPage *page, unsigned address)
	inline kPage *get_mapping (unsigned address, bool *readonly)

	// Allocation of pages.
	bool use (unsigned num = 1)
	void unuse (unsigned num = 1)
	unsigned palloc ()
	unsigned zalloc ()
	void pfree (unsigned page)
	void zfree (unsigned page)

	// Allocation routines for kernel structures
	void *search_free (unsigned size, void **first)
	kPage *alloc_page ()
	kThread *alloc_thread (unsigned size)
	kMessage *alloc_message (kReceiver *target)
	kReceiver *alloc_receiver ()
	kCaps *alloc_caps (unsigned size)
	kMemory *alloc_memory ()

	void free_page (kPage *page)
	void free_thread (kThread *thread)
	void free_message (kReceiver *owner, kMessage *message)
	void free_receiver (kReceiver *receiver)
	void free_caps (kCaps *page)
	void free_memory (kMemory *mem)

	void free_obj (kObject *obj, void **first)

// Functions which can be called from assembly must not be mangled.
extern "C":
	// Panic.  n is sent over caps led.  message is sent to dbg_caps (when in use).
	#define panic(n, m) panic_impl ((n), __LINE__, __PRETTY_FUNCTION__, (m))
	void panic_impl (unsigned n, unsigned line, char const *name, char const *message = "")
	#ifndef NDEBUG
	EXTERN Num dbg_code
	EXTERN kCapRef dbg_cap
	void dbg_log_char (unsigned ch)
	void dbg_log (char const *str)
	void dbg_log_num (unsigned num)
	void dbg_send (unsigned num, unsigned bits)
	void check (unsigned num, char const *msg)
	#define dpanic(n, msg) panic (n, msg)
	#else
	#define dbg_log_char(x) do {} while (0)
	#define dbg_log(x) do {} while (0)
	#define dbg_log_num(n) do {} while (0)
	#define dbg_send(n, m) do {} while (0)
	#define check (n, x) do {} while (0)
	#define dpanic(n, x) do {} while (0)
	#endif

/// Defined in schedule.ccp
void schedule ()
void timer_interrupt ()

EXTERN kMemory top_memory
EXTERN kReceiverP first_alarm
EXTERN kThread idle
EXTERN kMemory idle_memory
EXTERN kPage idle_page
EXTERN kThreadP first_scheduled
EXTERN kThreadP current, old_current
EXTERN bool do_schedule, must_wait

// Defined in memory.ccp
unsigned init_memory (unsigned mem)
unsigned raw_zalloc ()
void raw_pfree (unsigned page)
unsigned phys_alloc (unsigned num)
void phys_free (unsigned page, unsigned num)

// Defind in invoke.ccp
void invoke (kReceiverP target, Num cap_protected, kCapability::Context *c, kCapability *self)

// Defined by architecture-specific files.
void kThread_arch_init (kThread *thread)
void kThread_arch_receive (kThread *thread, Num cap_protected, Num recv_protected, Num *data)
unsigned *kThread_arch_info (kThread *thread, unsigned num)
void kMemory_arch_init (kMemory *mem)
void kMemory_arch_free (kMemory *mem)
bool kMemory_arch_map (kMemory *mem, kPage *page, unsigned address, bool write)
void kMemory_arch_unmap (kMemory *mem, kPage *page, unsigned address)
kPage *kMemory_arch_get_mapping (kMemory *mem, unsigned address, bool *readonly)
void kPage_arch_update_mapping (kPage *page)
void arch_register_interrupt (unsigned num, kReceiverP r)

bool kMemory::map (kPage *page, unsigned address, bool readonly = false):
	return kMemory_arch_map (this, page, address, readonly)
void kMemory::unmap (kPage *page, unsigned address):
	kMemory_arch_unmap (this, page, address)
kPage *kMemory::get_mapping (unsigned address, bool *readonly):
	return kMemory_arch_get_mapping (this, address, readonly)
kCapability *kCapRef::deref ():
	return caps ? caps->cap (index) : NULL
void kCapRef::clone (kCapRef source, bool copy):
	caps->clone (index, source, copy)
void kCapRef::set (kReceiver *target, Num pdata, kCapRef parent, kCapRef *parent_ptr):
	caps->set (index, target, pdata, parent, parent_ptr)
void kCapability::invoke (kCapability::Context *c):
	::invoke (target, cap_protected, c, this)

#define assert(x) do { if (!(x)) panic (__LINE__, "assertion failed"); } while (0)

#endif