Imported Genode release 11.11

base-codezero/include/base/ipc_msgbuf.h

@@ -0,0 +1,63 @@
+/*
+ * \brief  IPC message buffer
+ * \author Norman Feske
+ * \date   2009-10-02
+ */
+
+/*
+ * Copyright (C) 2009-2011 Genode Labs GmbH
+ *
+ * This file is part of the Genode OS framework, which is distributed
+ * under the terms of the GNU General Public License version 2.
+ */
+
+#ifndef _INCLUDE__BASE__IPC_MSGBUF_H_
+#define _INCLUDE__BASE__IPC_MSGBUF_H_
+
+namespace Genode {
+
+	/**
+	 * IPC message buffer layout
+	 */
+	class Msgbuf_base
+	{
+		protected:
+
+			size_t _size;
+			char   _msg_start[];  /* symbol marks start of message */
+
+		public:
+
+			/*
+			 * Begin of actual message buffer
+			 */
+			char buf[];
+
+			/**
+			 * Return size of message buffer
+			 */
+			inline size_t size() const { return _size; };
+
+			/**
+			 * Return address of message buffer
+			 */
+			inline void *addr() { return &_msg_start[0]; };
+
+	} __attribute__((aligned(4)));
+
+	/**
+	 * Instance of IPC message buffer with specified buffer size
+	 */
+	template <unsigned BUF_SIZE>
+	class Msgbuf : public Msgbuf_base
+	{
+		public:
+
+			char buf[BUF_SIZE];
+
+			Msgbuf() { _size = BUF_SIZE; }
+
+	} __attribute__((aligned(4)));
+}
+
+#endif /* _INCLUDE__BASE__IPC_MSGBUF_H_ */

base-codezero/include/base/ipc_pager.h

@@ -0,0 +1,169 @@
+/*
+ * \brief  Dummy pager support for Genode
+ * \author Norman Feske
+ * \date   2009-10-02
+ */
+
+/*
+ * Copyright (C) 2009-2011 Genode Labs GmbH
+ *
+ * This file is part of the Genode OS framework, which is distributed
+ * under the terms of the GNU General Public License version 2.
+ */
+
+#ifndef _INCLUDE__BASE__IPC_PAGER_H_
+#define _INCLUDE__BASE__IPC_PAGER_H_
+
+#include <base/ipc.h>
+#include <base/stdint.h>
+#include <base/native_types.h>
+
+namespace Genode {
+
+	class Mapping
+	{
+		private:
+
+			addr_t _from_phys_addr;
+			addr_t _to_virt_addr;
+			size_t _num_pages;
+			bool   _writeable;
+
+			enum { PAGE_SIZE_LOG2 = 12 };
+
+		public:
+
+			/**
+			 * Constructor
+			 */
+			Mapping(addr_t dst_addr, addr_t src_addr,
+			        bool write_combined, unsigned l2size = PAGE_SIZE_LOG2,
+			        bool rw = true)
+			:
+				_from_phys_addr(src_addr),
+				_to_virt_addr(dst_addr),
+				_num_pages(1 << (l2size - PAGE_SIZE_LOG2)),
+				_writeable(rw)
+			{ }
+
+			/**
+			 * Construct invalid mapping
+			 */
+			Mapping() : _num_pages(0) { }
+
+			/**
+			 * Prepare map operation
+			 *
+			 * No preparations are needed on Codezero because all mapping
+			 * originate from the physical address space.
+			 */
+			void prepare_map_operation() { }
+
+			addr_t from_phys() const { return _from_phys_addr; }
+			addr_t to_virt()   const { return _to_virt_addr; }
+			size_t num_pages() const { return _num_pages; }
+			bool   writeable() const { return _writeable; }
+	};
+
+
+	/**
+	 * Special paging server class
+	 */
+	class Ipc_pager : public Native_capability
+	{
+		private:
+
+			Native_thread_id _last;      /* faulted thread                 */
+			addr_t           _pf_addr;   /* page-fault address             */
+			addr_t           _pf_ip;     /* instruction pointer of faulter */
+			bool             _pf_write;  /* true on write fault            */
+
+			Mapping _reply_mapping;
+
+//		protected:
+//
+//			/**
+//			 * Wait for pagefault
+//			 */
+//			void _wait();
+//
+//			/**
+//			 * Send page-fault reply and wait for next page fault
+//			 */
+//			void _reply_and_wait();
+
+		public:
+
+			/**
+			 * Constructor
+			 */
+			Ipc_pager();
+
+			/**
+			 * Wait for a new page fault received as short message IPC
+			 */
+			void wait_for_fault();
+
+			/**
+			 * Reply current page-fault and wait for a new one
+			 */
+			void reply_and_wait_for_fault();
+
+			/**
+			 * Request instruction pointer of current page fault
+			 */
+			addr_t fault_ip() { return _pf_ip; }
+
+			/**
+			 * Request fault address of current page fault
+			 */
+			addr_t fault_addr() { return _pf_addr; }
+
+			/**
+			 * Set parameters for next reply
+			 */
+			void set_reply_mapping(Mapping m) { _reply_mapping = m; }
+
+			/**
+			 * Set destination for next reply
+			 */
+			void set_reply_dst(Native_capability pager_object) {
+				_last = pager_object.local_name(); }
+
+			/**
+			 * Answer call without sending a mapping
+			 *
+			 * This function is used to acknowledge local calls from one of
+			 * core's region-manager sessions.
+			 */
+			void acknowledge_wakeup();
+
+			/**
+			 * Return thread ID of last faulter
+			 */
+			Native_thread_id last() const { return _last; }
+
+			/**
+			 * Return badge for faulting thread
+			 */
+			unsigned long badge() const { return _last.tid; }
+
+			/**
+			 * Return true if page fault was a write fault
+			 */
+			bool is_write_fault() const { return _pf_write; }
+
+			/**
+			 * Return true if last fault was an exception
+			 */
+			bool is_exception() const
+			{
+				/*
+				 * Reflection of exceptions is not supported on this platform.
+				 */
+				return false;
+			}
+	};
+}
+
+#endif /* _INCLUDE__BASE__IPC_PAGER_H_ */

base-codezero/include/base/native_types.h

@@ -0,0 +1,143 @@
+/*
+ * \brief  Dummy definitions for native types used for compiling unit tests
+ * \author Norman Feske
+ * \date   2009-10-02
+ */
+
+/*
+ * Copyright (C) 2009-2011 Genode Labs GmbH
+ *
+ * This file is part of the Genode OS framework, which is distributed
+ * under the terms of the GNU General Public License version 2.
+ */
+
+#ifndef _INCLUDE__BASE__NATIVE_TYPES_H_
+#define _INCLUDE__BASE__NATIVE_TYPES_H_
+
+namespace Codezero {
+
+	struct l4_mutex;
+
+	enum { NILTHREAD = -1 };
+}
+
+namespace Genode {
+
+	class Platform_thread;
+
+	struct Native_thread_id
+	{
+		int tid;
+
+		/**
+		 * Pointer to thread's running lock
+		 *
+		 * Once initialized (see 'lock_helper.h'), it will point to the
+		 * '_running_lock' field of the thread's 'Native_thread' structure,
+		 * which is part of the thread context. This member variable is
+		 * used by the lock implementation only.
+		 */
+		struct Codezero::l4_mutex *running_lock;
+
+		Native_thread_id() { }
+
+		/**
+		 * Constructor (used as implicit constructor)
+		 */
+		Native_thread_id(int l4id) : tid(l4id), running_lock(0) { }
+
+		Native_thread_id(int l4id, Codezero::l4_mutex *rl) : tid(l4id), running_lock(rl) { }
+	};
+
+	struct Native_thread
+	{
+		Native_thread_id l4id;
+
+		/**
+		 * Only used in core
+		 *
+		 * For 'Thread' objects created within core, 'pt' points to the
+		 * physical thread object, which is going to be destroyed on
+		 * destruction of the 'Thread'.
+		 */
+		Platform_thread *pt;
+	};
+
+	/**
+	 * Empty UTCB type expected by the thread library
+	 *
+	 * On this kernel, UTCBs are not placed within the the context area. Each
+	 * thread can request its own UTCB pointer using the kernel interface.
+	 * However, we use the 'Native_utcb' member of the thread context to
+	 * hold thread-specific data, i.e. the running lock used by the lock
+	 * implementation.
+	 */
+	struct Native_utcb
+	{
+		private:
+
+			/**
+			 * Prevent construction
+			 *
+			 * A UTCB is never constructed, it is backed by zero-initialized memory.
+			 */
+			Native_utcb();
+
+			/**
+			 * Backing store for per-thread running lock
+			 *
+			 * The size of this member must equal 'sizeof(Codezero::l4_mutex)'.
+			 * Unfortunately, we cannot include the Codezero headers here.
+			 */
+			int _running_lock;
+
+		public:
+
+			Codezero::l4_mutex *running_lock() {
+				return (Codezero::l4_mutex *)&_running_lock; }
+	};
+
+	inline bool operator == (Native_thread_id t1, Native_thread_id t2) { return t1.tid == t2.tid; }
+	inline bool operator != (Native_thread_id t1, Native_thread_id t2) { return t1.tid != t2.tid; }
+
+	/*
+	 * Because Codezero does not support local names for capabilities, a Genode
+	 * capability consists of the global thread ID and a global object ID, not
+	 * protected by the kernel when transmitted as IPC payloads.
+	 */
+	class Native_capability
+	{
+		private:
+
+			Native_thread_id _tid;  /* global thread ID */
+			int _local_name;        /* global unique object ID */
+
+		public:
+
+			/**
+			 * Default constructor creates invalid capability
+			 */
+			Native_capability()
+			: _local_name(0) { _tid.tid = Codezero::NILTHREAD; }
+
+			/**
+			 * Constructor for hand-crafting capabilities
+			 *
+			 * This constructor is only used internally be the framework.
+			 */
+			Native_capability(Native_thread_id tid, int local_name)
+			: _tid(tid), _local_name(local_name) { }
+
+			bool valid() const { return _tid.tid != Codezero::NILTHREAD; }
+
+			int local_name() const { return _local_name; }
+			int dst() const { return _tid.tid; }
+
+			Native_thread_id tid() const { return _tid; }
+	};
+
+	typedef int Native_connection_state;
+}
+
+
+#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */