WebSVN – HelenOS – Path Comparison – / – /branches/dd/kernel/generic/include Rev 3022 and /branches/dd/kernel/generic/include Rev 4055

Ignore whitespace Rev 3022 → Rev 4055

 /branches/dd/kernel/generic/include/align.h
 ,13 → 26,13
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @ingroup others
  * @{
  */
 /**
  * @file
- * @brief   Macros for making values and addresses aligned.
+ * @brief Macros for making values and addresses aligned.
  */
 #ifndef KERN_ALIGN_H_
 ,7 → 43,7
  * @param s Address or size to be aligned.
  * @param a Size of alignment, must be power of 2.
  */
-#define ALIGN_DOWN(s, a)    ((s) & ~((a) - 1))
+#define ALIGN_DOWN(s, a)  ((s) & ~((a) - 1))
 /** Align to the nearest higher address.
 ,7 → 51,7
  * @param s Address or size to be aligned.
  * @param a Size of alignment, must be power of 2.
  */
-#define ALIGN_UP(s, a)      (((s) + ((a) - 1)) & ~((a) - 1))
+#define ALIGN_UP(s, a)  (((s) + ((a) - 1)) & ~((a) - 1))
 #endif

 /branches/dd/kernel/generic/include/func.h
 ,11 → 41,6
 extern atomic_t haltstate;
 extern void halt(void);
-extern size_t strlen(const char *str);
-extern int strcmp(const char *src, const char *dst);
-extern int strncmp(const char *src, const char *dst, size_t len);
-extern void strncpy(char *dest, const char *src, size_t len);
 extern unative_t atoi(const char *text);
 extern void order(const uint64_t val, uint64_t *rv, char *suffix);

 /branches/dd/kernel/generic/include/fpu_context.h
 ,10 → 37,6
 #include <arch/fpu_context.h>
-#if defined(CONFIG_FPU_LAZY) && !defined(ARCH_HAS_FPU)
-# error "CONFIG_FPU_LAZY defined, but no ARCH_HAS_FPU"
-#endif
 extern void fpu_context_save(fpu_context_t *);
 extern void fpu_context_restore(fpu_context_t *);
 extern void fpu_init(void);

 /branches/dd/kernel/generic/include/stackarg.h
 ,9 → 52,9
     (ap).last = (uint8_t *) &(lst)
 #define va_arg(ap, type)        \
-    (*((type *)((ap).last + ((ap).pos  += sizeof(type) ) - sizeof(type))))
+    (*((type *)((ap).last + ((ap).pos += sizeof(type)) - sizeof(type))))
-#define va_copy(dst,src)       dst=src
+#define va_copy(dst, src) dst = src
 #define va_end(ap)

 /branches/dd/kernel/generic/include/byteorder.h
 ,6 → 51,14
 #define uint32_t_be2host(n)     (n)
 #define uint64_t_be2host(n)     (n)
+#define host2uint16_t_le(n)     uint16_t_byteorder_swap(n)
+#define host2uint32_t_le(n)     uint32_t_byteorder_swap(n)
+#define host2uint64_t_le(n)     uint64_t_byteorder_swap(n)
+#define host2uint16_t_be(n)     (n)
+#define host2uint32_t_be(n)     (n)
+#define host2uint64_t_be(n)     (n)
 #else
 #define uint16_t_le2host(n)     (n)
 ,6 → 69,14
 #define uint32_t_be2host(n)     uint32_t_byteorder_swap(n)
 #define uint64_t_be2host(n)     uint64_t_byteorder_swap(n)
+#define host2uint16_t_le(n)     (n)
+#define host2uint32_t_le(n)     (n)
+#define host2uint64_t_le(n)     (n)
+#define host2uint16_t_be(n)     uint16_t_byteorder_swap(n)
+#define host2uint32_t_be(n)     uint32_t_byteorder_swap(n)
+#define host2uint64_t_be(n)     uint64_t_byteorder_swap(n)
 #endif
 static inline uint64_t uint64_t_byteorder_swap(uint64_t n)

 /branches/dd/kernel/generic/include/config.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,15 → 38,16
 #include <arch/types.h>
 #include <arch/mm/page.h>
-#define STACK_SIZE      PAGE_SIZE
+#define STACK_SIZE  PAGE_SIZE
-#define CONFIG_MEMORY_SIZE  (8 * 1024 * 1024)
+#define CONFIG_INIT_TASKS   32
-#define CONFIG_INIT_TASKS   32
+#define CONFIG_TASK_NAME_BUFLEN 32
 typedef struct {
     uintptr_t addr;
     size_t size;
+    char name[CONFIG_TASK_NAME_BUFLEN];
 } init_task_t;
 typedef struct {
 ,14 → 66,14
 } ballocs_t;
 typedef struct {
-    count_t cpu_count;      /**< Number of processors detected. */
-    volatile count_t cpu_active;    /**< Number of processors that are up and running. */
+    count_t cpu_count;            /**< Number of processors detected. */
+    volatile count_t cpu_active;  /**< Number of processors that are up and running. */
     uintptr_t base;
-    size_t kernel_size;     /**< Size of memory in bytes taken by kernel and stack */
+    size_t kernel_size;           /**< Size of memory in bytes taken by kernel and stack */
-    uintptr_t stack_base;       /**< Base adddress of initial stack */
-    size_t stack_size;      /**< Size of initial stack */
+    uintptr_t stack_base;         /**< Base adddress of initial stack */
+    size_t stack_size;            /**< Size of initial stack */
 } config_t;
 extern config_t config;

 /branches/dd/kernel/generic/include/string.h
 ,0 → 1,50
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_STRING_H_
+#define KERN_STRING_H_
+#include <arch/types.h>
+extern size_t strlen(const char *str);
+extern int strcmp(const char *src, const char *dst);
+extern int strncmp(const char *src, const char *dst, size_t len);
+extern void strncpy(char *dest, const char *src, size_t len);
+extern char *strchr(const char *s, int i);
+#endif
+/** @}
+ */

 /branches/dd/kernel/generic/include/proc/task.h
 ,7 → 52,11
 #include <arch/cpu.h>
 #include <mm/tlb.h>
 #include <proc/scheduler.h>
+#include <udebug/udebug.h>
+#include <ipc/kbox.h>
+#define TASK_NAME_BUFLEN    20
 struct thread;
 /** Task structure. */
 ,8 → 70,8
      * threads.
      */
     SPINLOCK_DECLARE(lock);
-    char *name;
+    char name[TASK_NAME_BUFLEN];
     /** List of threads contained in this task. */
     link_t th_head;
     /** Address space. */
 ,7 → 97,15
      * certain extent.
      */
     atomic_t active_calls;
+#ifdef CONFIG_UDEBUG
+    /** Debugging stuff. */
+    udebug_task_t udebug;
+    /** Kernel answerbox. */
+    kbox_t kb;
+#endif
     /** Architecture specific task data. */
     task_arch_t arch;
 ,7 → 128,6
 extern void task_done(void);
 extern task_t *task_create(as_t *as, char *name);
 extern void task_destroy(task_t *t);
-extern task_t *task_run_program(void *program_addr, char *name);
 extern task_t *task_find_by_id(task_id_t id);
 extern int task_kill(task_id_t id);
 extern uint64_t task_get_accounting(task_t *t);
 ,6 → 144,7
 #endif
 extern unative_t sys_task_get_id(task_id_t *uspace_task_id);
+extern unative_t sys_task_set_name(const char *uspace_name, size_t name_len);
 #endif

 /branches/dd/kernel/generic/include/proc/thread.h
 ,6 → 46,7
 #include <arch/cpu.h>
 #include <mm/tlb.h>
 #include <proc/uarg.h>
+#include <udebug/udebug.h>
 #define THREAD_STACK_SIZE   STACK_SIZE
 #define THREAD_NAME_BUFLEN  20
 ,6 → 204,12
     /** Thread's kernel stack. */
     uint8_t *kstack;
+#ifdef CONFIG_UDEBUG
+    /** Debugging stuff */
+    udebug_thread_t udebug;
+#endif
 } thread_t;
 /** Thread list lock.
 ,7 → 259,8
 extern slab_cache_t *fpu_context_slab;
 /* Thread syscall prototypes. */
-extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id);
+extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg,
+    char *uspace_name, size_t name_len, thread_id_t *uspace_thread_id);
 extern unative_t sys_thread_exit(int uspace_status);
 extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);

 /branches/dd/kernel/generic/include/proc/program.h
 ,0 → 1,67
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup genericproc
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_PROGRAM_H_
+#define KERN_PROGRAM_H_
+#include <arch/types.h>
+struct task;
+struct thread;
+/** Program info structure.
+ *
+ * A program is an abstraction of a freshly created (not yet running)
+ * userspace task containing a main thread along with its userspace stack.
+ */
+typedef struct program {
+    struct task *task;      /**< Program task */
+    struct thread *main_thread; /**< Program main thread */
+} program_t;
+extern void *program_loader;
+extern void program_create(as_t *as, uintptr_t entry_addr, char *name,
+    program_t *p);
+extern int program_create_from_image(void *image_addr, char *name,
+    program_t *p);
+extern int program_create_loader(program_t *p, char *name);
+extern void program_ready(program_t *p);
+extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len);
+#endif
+/** @}
+ */

/branches/dd/kernel/generic/include/lib/objc_ext.h
File deleted

/branches/dd/kernel/generic/include/lib/objc.h
File deleted

 /branches/dd/kernel/generic/include/lib/rd.h
 ,16 → 66,18
 #define RE_UNSUPPORTED      2   /* Non-supported image (e.g. wrong version) */
 /** RAM disk header */
-typedef struct {
+struct rd_header {
     uint8_t magic[RD_MAGIC_SIZE];
     uint8_t version;
     uint8_t data_type;
     uint32_t header_size;
     uint64_t data_size;
-} rd_header;
+} __attribute__ ((packed));
-extern int init_rd(rd_header * addr, size_t size);
+typedef struct rd_header rd_header_t;
+extern int init_rd(rd_header_t *addr, size_t size);
 #endif
 /** @}

 /branches/dd/kernel/generic/include/lib/elf.h
 ,7 → 114,8
 #define EE_MEMORY       2   /* Cannot allocate address space */
 #define EE_INCOMPATIBLE     3   /* ELF image is not compatible with current architecture */
 #define EE_UNSUPPORTED      4   /* Non-supported ELF (e.g. dynamic ELFs) */
-#define EE_IRRECOVERABLE    5
+#define EE_LOADER       5   /* The image is actually a program loader */
+#define EE_IRRECOVERABLE    6
 /**
  * ELF section types
 ,6 → 339,10
 extern char *elf_error(unsigned int rc);
+/* Interpreter string used to recognize the program loader */
+#define ELF_INTERP_ZSTR "kernel"
+#define ELF_INTERP_ZLEN  sizeof(ELF_INTERP_ZSTR)
 #endif
 /** @}

 /branches/dd/kernel/generic/include/udebug/udebug.h
 ,0 → 1,210
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_UDEBUG_H_
+#define KERN_UDEBUG_H_
+#include <ipc/ipc.h>
+typedef enum { /* udebug_method_t */
+/** Start debugging the recipient.
+ * Causes all threads in the receiving task to stop. When they
+ * are all stoped, an answer with retval 0 is generated.
+ */
+UDEBUG_M_BEGIN = 1,
+/** Finish debugging the recipient.
+ * Answers all pending GO and GUARD messages.
+ */
+UDEBUG_M_END,
+/** Set which events should be captured.
+ */
+UDEBUG_M_SET_EVMASK,
+/** Make sure the debugged task is still there.
+ * This message is answered when the debugged task dies
+ * or the debugging session ends.
+ */
+UDEBUG_M_GUARD,
+/** Run a thread until a debugging event occurs.
+ * This message is answered when the thread stops
+ * in a debugging event.
+ *
+ * - ARG2 - id of the thread to run
+ */
+UDEBUG_M_GO,
+/** Stop a thread being debugged.
+ * Creates a special STOP event in the thread, causing
+ * it to answer a pending GO message (if any).
+ */
+UDEBUG_M_STOP,
+/** Read arguments of a syscall.
+ *
+ * - ARG2 - thread identification
+ * - ARG3 - destination address in the caller's address space
+ *
+ */
+UDEBUG_M_ARGS_READ,
+/** Read the list of the debugged tasks's threads.
+ *
+ * - ARG2 - destination address in the caller's address space
+ * - ARG3 - size of receiving buffer in bytes
+ *
+ * The kernel fills the buffer with a series of sysarg_t values
+ * (thread ids). On answer, the kernel will set:
+ *
+ * - ARG2 - number of bytes that were actually copied
+ * - ARG3 - number of bytes of the complete data
+ *
+ */
+UDEBUG_M_THREAD_READ,
+/** Read the debugged tasks's memory.
+ *
+ * - ARG2 - destination address in the caller's address space
+ * - ARG3 - source address in the recipient's address space
+ * - ARG4 - size of receiving buffer in bytes
+ *
+ */
+UDEBUG_M_MEM_READ,
+} udebug_method_t;
+typedef enum {
+    UDEBUG_EVENT_FINISHED = 1,  /**< Debuging session has finished */
+    UDEBUG_EVENT_STOP,      /**< Stopped on DEBUG_STOP request */
+    UDEBUG_EVENT_SYSCALL_B,     /**< Before beginning syscall execution */
+    UDEBUG_EVENT_SYSCALL_E,     /**< After finishing syscall execution */
+    UDEBUG_EVENT_THREAD_B,      /**< The task created a new thread */
+    UDEBUG_EVENT_THREAD_E       /**< A thread exited */
+} udebug_event_t;
+#define UDEBUG_EVMASK(event) (1 << ((event) - 1))
+typedef enum {
+    UDEBUG_EM_FINISHED  = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED),
+    UDEBUG_EM_STOP      = UDEBUG_EVMASK(UDEBUG_EVENT_STOP),
+    UDEBUG_EM_SYSCALL_B = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B),
+    UDEBUG_EM_SYSCALL_E = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E),
+    UDEBUG_EM_THREAD_B  = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B),
+    UDEBUG_EM_THREAD_E  = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E),
+    UDEBUG_EM_ALL       =
+        UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) |
+        UDEBUG_EVMASK(UDEBUG_EVENT_STOP) |
+        UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) |
+        UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) |
+        UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) |
+        UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E)
+} udebug_evmask_t;
+#ifdef KERNEL
+#include <synch/mutex.h>
+#include <arch/interrupt.h>
+#include <atomic.h>
+typedef enum {
+    /** Task is not being debugged */
+    UDEBUG_TS_INACTIVE,
+    /** BEGIN operation in progress (waiting for threads to stop) */
+    UDEBUG_TS_BEGINNING,
+    /** Debugger fully connected */
+    UDEBUG_TS_ACTIVE
+} udebug_task_state_t;
+/** Debugging part of task_t structure.
+ */
+typedef struct {
+    /** Synchronize debug ops on this task / access to this structure */
+    mutex_t lock;
+    char *lock_owner;
+    udebug_task_state_t dt_state;
+    call_t *begin_call;
+    int not_stoppable_count;
+    struct task *debugger;
+    udebug_evmask_t evmask;
+} udebug_task_t;
+/** Debugging part of thread_t structure.
+ */
+typedef struct {
+    /** Synchronize debug ops on this thread / access to this structure. */
+    mutex_t lock;
+    waitq_t go_wq;
+    call_t *go_call;
+    unative_t syscall_args[6];
+    istate_t *uspace_state;
+    /** What type of event are we stopped in or 0 if none. */
+    udebug_event_t cur_event;
+    bool go;        /**< thread is GO */
+    bool stoppable;     /**< thread is stoppable */
+    bool active;        /**< thread is in a debugging session */
+} udebug_thread_t;
+struct task;
+struct thread;
+void udebug_task_init(udebug_task_t *ut);
+void udebug_thread_initialize(udebug_thread_t *ut);
+void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
+    unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
+    bool end_variant);
+void udebug_thread_b_event_attach(struct thread *t, struct task *ta);
+void udebug_thread_e_event(void);
+void udebug_stoppable_begin(void);
+void udebug_stoppable_end(void);
+void udebug_before_thread_runs(void);
+int udebug_task_cleanup(struct task *ta);
+#endif
+#endif
+/** @}
+ */

 /branches/dd/kernel/generic/include/udebug/udebug_ops.h
 ,0 → 1,55
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_UDEBUG_OPS_H_
+#define KERN_UDEBUG_OPS_H_
+#include <ipc/ipc.h>
+int udebug_begin(call_t *call);
+int udebug_end(void);
+int udebug_set_evmask(udebug_evmask_t mask);
+int udebug_go(thread_t *t, call_t *call);
+int udebug_stop(thread_t *t, call_t *call);
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *n);
+int udebug_args_read(thread_t *t, void **buffer);
+int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer);
+#endif
+/** @}
+ */

 /branches/dd/kernel/generic/include/udebug/udebug_ipc.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_UDEBUG_IPC_H_
+#define KERN_UDEBUG_IPC_H_
+#include <ipc/ipc.h>
+int udebug_request_preprocess(call_t *call, phone_t *phone);
+void udebug_call_receive(call_t *call);
+#endif
+/** @}
+ */

 /branches/dd/kernel/generic/include/debug.h
 ,11 → 38,11
 #include <panic.h>
 #include <arch/debug.h>
-#define CALLER       ((uintptr_t)__builtin_return_address(0))
+#define CALLER ((uintptr_t) __builtin_return_address(0))
 #ifndef HERE
 /** Current Instruction Pointer address */
-#  define HERE ((uintptr_t *) 0)
+#   define HERE ((uintptr_t *) 0)
 #endif
 /** Debugging ASSERT macro
 ,12 → 55,51
  *
  */
 #ifdef CONFIG_DEBUG
-#   define ASSERT(expr) if (!(expr)) { panic("assertion failed (%s), caller=%.*p\n", #expr, sizeof(uintptr_t) * 2, CALLER); }
+#   define ASSERT(expr) \
+        if (!(expr)) { \
+            panic("Assertion failed (%s), caller=%p.", #expr, CALLER); \
+        }
 #else
 #   define ASSERT(expr)
 #endif
+/** Extensive logging output macro
+ *
+ * If CONFIG_LOG is set, the LOG() macro
+ * will print whatever message is indicated plus
+ * an information about the location.
+ *
+ */
+#ifdef CONFIG_LOG
+#   define LOG(format, ...) \
+        printf("%s() at %s:%u: " format "\n", __func__, __FILE__, \
+            __LINE__, ##__VA_ARGS__);
+#else
+#   define LOG(format, ...)
 #endif
+/** Extensive logging execute macro
+ *
+ * If CONFIG_LOG is set, the LOG_EXEC() macro
+ * will print an information about calling a given
+ * function and call it.
+ *
+ */
+#ifdef CONFIG_LOG
+#   define LOG_EXEC(fnc) \
+        { \
+            printf("%s() at %s:%u: " #fnc "\n", __func__, __FILE__, \
+            __LINE__); \
+            fnc; \
+        }
+#else
+#   define LOG_EXEC(fnc) fnc
+#endif
+#endif
 /** @}
  */

 /branches/dd/kernel/generic/include/panic.h
 ,15 → 36,15
 #define KERN_PANIC_H_
 #ifdef CONFIG_DEBUG
-#define panic(format, ...) \
-    panic_printf("Kernel panic in %s() at %s on line %d: " format, __func__, \
-    __FILE__, __LINE__, ##__VA_ARGS__);
+#   define panic(format, ...) \
+        panic_printf("Kernel panic in %s() at %s:%u: " format "\n", \
+        __func__, __FILE__, __LINE__, ##__VA_ARGS__);
 #else
-#define panic(format, ...) \
-    panic_printf("Kernel panic: " format, ##__VA_ARGS__);
+#   define panic(format, ...) \
+        panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__);
 #endif
-extern void panic_printf(char *fmt, ...) __attribute__((noreturn)) ;
+extern void panic_printf(char *fmt, ...) __attribute__((noreturn));
 #endif

 /branches/dd/kernel/generic/include/interrupt.h
 ,17 → 40,16
 #include <proc/task.h>
 #include <proc/thread.h>
 #include <arch.h>
-#include <console/klog.h>
 #include <ddi/irq.h>
 typedef void (* iroutine)(int n, istate_t *istate);
-#define fault_if_from_uspace(istate, cmd, ...) \
+#define fault_if_from_uspace(istate, fmt, ...) \
 { \
     if (istate_from_uspace(istate)) { \
         task_t *task = TASK; \
-        klog_printf("Task %llu killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \
-        klog_printf("  " cmd, ##__VA_ARGS__); \
+        printf("Task %s (%" PRIu64 ") killed due to an exception at %p: ", task->name, task->taskid, istate_get_pc(istate)); \
+        printf(fmt "\n", ##__VA_ARGS__); \
         task_kill(task->taskid); \
         thread_exit(); \
     } \

 /branches/dd/kernel/generic/include/main/main.h
 ,8 → 35,13
 #ifndef KERN_MAIN_H_
 #define KERN_MAIN_H_
+#include <arch/types.h>
 extern uintptr_t stack_safe;
+extern void main_bsp(void);
+extern void main_ap(void);
 #endif
 /** @}

 /branches/dd/kernel/generic/include/synch/mutex.h
 ,20 → 39,26
 #include <synch/semaphore.h>
 #include <synch/synch.h>
+typedef enum {
+    MUTEX_PASSIVE,
+    MUTEX_ACTIVE
+} mutex_type_t;
 typedef struct {
+    mutex_type_t type;
     semaphore_t sem;
 } mutex_t;
-#define mutex_lock(mtx) \
+#define mutex_lock(mtx)         \
     _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
-#define mutex_trylock(mtx) \
+#define mutex_trylock(mtx)      \
     _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
-#define mutex_lock_timeout(mtx, usec) \
+#define mutex_lock_timeout(mtx, usec)   \
     _mutex_lock_timeout((mtx), (usec), SYNCH_FLAGS_NON_BLOCKING)
-extern void mutex_initialize(mutex_t *mtx);
-extern int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags);
-extern void mutex_unlock(mutex_t *mtx);
+extern void mutex_initialize(mutex_t *, mutex_type_t);
+extern int _mutex_lock_timeout(mutex_t *, uint32_t, int);
+extern void mutex_unlock(mutex_t *);
 #endif

 /branches/dd/kernel/generic/include/synch/spinlock.h
 ,6 → 36,7
 #define KERN_SPINLOCK_H_
 #include <arch/types.h>
+#include <arch/barrier.h>
 #include <preemption.h>
 #include <atomic.h>
 #include <debug.h>
 ,8 → 111,8
 #define DEADLOCK_PROBE(pname, value)                    \
     if ((pname)++ > (value)) {                  \
         (pname) = 0;                        \
-        printf("Deadlock probe %s: exceeded threshold %d\n",    \
-            "cpu%d: function=%s, line=%d\n",            \
+        printf("Deadlock probe %s: exceeded threshold %u\n",    \
+            "cpu%u: function=%s, line=%u\n",            \
             #pname, (value), CPU->id, __func__, __LINE__);  \
     }
 #else

 /branches/dd/kernel/generic/include/synch/smc.h
 ,0 → 1,43
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup sync
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_SMC_H_
+#define KERN_SMC_H_
+extern unative_t sys_smc_coherence(uintptr_t va, size_t size);
+#endif
+/** @}
+ */

 /branches/dd/kernel/generic/include/memstr.h
 ,9 → 42,9
  * Architecture independent variants.
  */
 extern void *_memcpy(void *dst, const void *src, size_t cnt);
-extern void _memsetb(uintptr_t dst, size_t cnt, uint8_t x);
-extern void _memsetw(uintptr_t dst, size_t cnt, uint16_t x);
-extern char *strcpy(char *dest, const char *src);
+extern void _memsetb(void *dst, size_t cnt, uint8_t x);
+extern void _memsetw(void *dst, size_t cnt, uint16_t x);
+extern void *memmove(void *dst, const void *src, size_t cnt);
 #endif

 /branches/dd/kernel/generic/include/ddi/irq.h
 ,18 → 36,16
 #define KERN_IRQ_H_
 typedef enum {
-    CMD_MEM_READ_1 = 0,
-    CMD_MEM_READ_2,
-    CMD_MEM_READ_4,
-    CMD_MEM_READ_8,
-    CMD_MEM_WRITE_1,
-    CMD_MEM_WRITE_2,
-    CMD_MEM_WRITE_4,
-    CMD_MEM_WRITE_8,
-    CMD_PORT_READ_1,
-    CMD_PORT_WRITE_1,
-    CMD_IA64_GETCHAR,
-    CMD_PPC32_GETCHAR,
+    CMD_PIO_READ_8 = 1,
+    CMD_PIO_READ_16,
+    CMD_PIO_READ_32,
+    CMD_PIO_WRITE_8,
+    CMD_PIO_WRITE_16,
+    CMD_PIO_WRITE_32,
+    CMD_BTEST,
+    CMD_PREDICATE,
+    CMD_ACCEPT,
+    CMD_DECLINE,
     CMD_LAST
 } irq_cmd_type;
 ,8 → 52,9
 typedef struct {
     irq_cmd_type cmd;
     void *addr;
-    unsigned long long value;
-    int dstarg;
+    unsigned long long value;
+    unsigned int srcarg;
+    unsigned int dstarg;
 } irq_cmd_t;
 typedef struct {
 ,8 → 66,10
 #include <arch/types.h>
 #include <adt/list.h>
+#include <adt/hash_table.h>
 #include <synch/spinlock.h>
 #include <proc/task.h>
+#include <ipc/ipc.h>
 typedef enum {
     IRQ_DECLINE,        /**< Decline to service. */
 ,8 → 82,11
 } irq_trigger_t;
 struct irq;
-typedef void (* irq_handler_t)(struct irq *irq, void *arg, ...);
+typedef void (* irq_handler_t)(struct irq *);
+/** Type for function used to clear the interrupt. */
+typedef void (* cir_t)(void *, inr_t);
 /** IPC notification config structure.
  *
  * Primarily, this structure is encapsulated in the irq_t structure.
 ,6 → 99,8
     answerbox_t *answerbox;
     /** Method to be used for the notification. */
     unative_t method;
+    /** Arguments that will be sent if the IRQ is claimed. */
+    unative_t scratch[IPC_CALL_LEN];
     /** Top-half pseudocode. */
     irq_code_t *code;
     /** Counter. */
 ,22 → 144,29
     /** Trigger level of the IRQ. */
     irq_trigger_t trigger;
     /** Claim ownership of the IRQ. */
-    irq_ownership_t (* claim)(void);
+    irq_ownership_t (* claim)(struct irq *);
     /** Handler for this IRQ and device. */
     irq_handler_t handler;
-    /** Argument for the handler. */
-    void *arg;
+    /** Instance argument for the handler and the claim function. */
+    void *instance;
+    /** Clear interrupt routine. */
+    cir_t cir;
+    /** First argument to the clear interrupt routine. */
+    void *cir_arg;
     /** Notification configuration structure. */
     ipc_notif_cfg_t notif_cfg;
 } irq_t;
-extern void irq_init(count_t inrs, count_t chains);
-extern void irq_initialize(irq_t *irq);
-extern void irq_register(irq_t *irq);
-extern irq_t *irq_dispatch_and_lock(inr_t inr);
-extern irq_t *irq_find_and_lock(inr_t inr, devno_t devno);
+SPINLOCK_EXTERN(irq_uspace_hash_table_lock);
+extern hash_table_t irq_uspace_hash_table;
+extern void irq_init(count_t, count_t);
+extern void irq_initialize(irq_t *);
+extern void irq_register(irq_t *);
+extern irq_t *irq_dispatch_and_lock(inr_t);
 #endif
 #endif

 /branches/dd/kernel/generic/include/ddi/device.h
 ,6 → 35,9
 #ifndef KERN_DEVICE_H_
 #define KERN_DEVICE_H_
+#include <arch/types.h>
+#include <typedefs.h>
 extern devno_t device_assign_devno(void);
 #endif

 /branches/dd/kernel/generic/include/ddi/ddi.h
 ,13 → 38,14
 #include <ddi/ddi_arg.h>
 #include <arch/types.h>
 #include <proc/task.h>
+#include <adt/list.h>
 /** Structure representing contiguous physical memory area. */
 typedef struct {
-    uintptr_t pbase;    /**< Physical base of the area. */
-    uintptr_t vbase;    /**< Virtual base of the area. */
-    count_t frames;     /**< Number of frames in the area. */
-    bool cacheable;     /**< Cacheability. */
+    uintptr_t pbase;    /**< Physical base of the area. */
+    pfn_t frames;       /**< Number of frames in the area. */
+    link_t link;        /**< Linked list link */
 } parea_t;
 extern void ddi_init(void);

/branches/dd/kernel/generic/include/console/klog.h
File deleted

 /branches/dd/kernel/generic/include/console/chardev.h
 ,7 → 50,7
     /** Resume pushing characters. */
     void (* resume)(struct chardev *);
     /** Write character to stream. */
-    void (* write)(struct chardev *, char c);
+    void (* write)(struct chardev *, char c, bool silent);
     /** Read character directly from device, assume interrupts disabled. */
     char (* read)(struct chardev *);
 } chardev_operations_t;

 /branches/dd/kernel/generic/include/console/kconsole.h
 ,6 → 37,7
 #include <adt/list.h>
 #include <synch/spinlock.h>
+#include <ipc/irq.h>
 #define MAX_CMDLINE     256
 #define KCONSOLE_HISTORY 10
 ,11 → 84,16
     void (* help)(void);
 } cmd_info_t;
+extern bool kconsole_notify;
+extern irq_t kconsole_irq;
 SPINLOCK_EXTERN(cmd_lock);
 extern link_t cmd_head;
 extern void kconsole_init(void);
-extern void kconsole(void *prompt);
+extern void kconsole_notify_init(void);
+extern void kconsole(char *prompt, char *msg, bool kcon);
+extern void kconsole_thread(void *data);
 extern int cmd_register(cmd_info_t *cmd);

 /branches/dd/kernel/generic/include/console/console.h
 ,11 → 41,21
 extern chardev_t *stdin;
 extern chardev_t *stdout;
+extern bool silent;
+extern void console_init(void);
+extern void klog_init(void);
+extern void klog_update(void);
 extern uint8_t getc(chardev_t *chardev);
-uint8_t _getc(chardev_t *chardev);
+extern uint8_t _getc(chardev_t *chardev);
 extern count_t gets(chardev_t *chardev, char *buf, size_t buflen);
 extern void putchar(char c);
+extern void grab_console(void);
+extern void release_console(void);
 extern void arch_grab_console(void);
 extern void arch_release_console(void);

 /branches/dd/kernel/generic/include/arch.h
 ,12 → 63,11
     as_t *as;           /**< Current address space. */
 } the_t;
-#define THE     ((the_t *)(get_stack_base()))
+#define THE  ((the_t * )(get_stack_base()))
 extern void the_initialize(the_t *the);
 extern void the_copy(the_t *src, the_t *dst);
-extern void arch_pre_main(void);
 extern void arch_pre_mm_init(void);
 extern void arch_post_mm_init(void);
 extern void arch_post_cpu_init(void);
 ,6 → 78,7
 extern void reboot(void);
 extern void arch_reboot(void);
+extern void *arch_construct_function(fncptr_t *fptr, void *addr, void *caller);
 #endif

/branches/dd/kernel/generic/include/adt/list.h
36,6 → 36,7
#define KERN_LIST_H_

#include <arch/types.h>
#include <typedefs.h>

/** Doubly linked list head and link type. */
typedef struct link {

 /branches/dd/kernel/generic/include/adt/bitmap.h
 ,6 → 49,14
 extern void bitmap_clear_range(bitmap_t *bitmap, index_t start, count_t bits);
 extern void bitmap_copy(bitmap_t *dst, bitmap_t *src, count_t bits);
+static inline int bitmap_get(bitmap_t *bitmap,index_t bit)
+{
+    if(bit >= bitmap->bits)
+        return 0;
+    return !! ((bitmap->map)[bit/8] & (1 << (bit & 7)));
+}
 #endif
 /** @}

/branches/dd/kernel/generic/include/adt/avl.h
36,6 → 36,7
#define KERN_AVLTREE_H_

#include <arch/types.h>
#include <typedefs.h>

/**
* Macro for getting a pointer to the structure which contains the avltree

 /branches/dd/kernel/generic/include/mm/frame.h
 ,35 → 38,82
 #include <arch/types.h>
 #include <adt/list.h>
+#include <mm/buddy.h>
 #include <synch/spinlock.h>
-#include <mm/buddy.h>
 #include <arch/mm/page.h>
 #include <arch/mm/frame.h>
-#define ONE_FRAME   0
-#define TWO_FRAMES  1
-#define FOUR_FRAMES 2
+#define ONE_FRAME    0
+#define TWO_FRAMES   1
+#define FOUR_FRAMES  2
 #ifdef ARCH_STACK_FRAMES
-#define STACK_FRAMES ARCH_STACK_FRAMES
+    #define STACK_FRAMES  ARCH_STACK_FRAMES
 #else
-#define STACK_FRAMES ONE_FRAME
+    #define STACK_FRAMES  ONE_FRAME
 #endif
-/** Maximum number of zones in system. */
-#define ZONES_MAX           16
+/** Maximum number of zones in the system. */
+#define ZONES_MAX  32
-/** If possible, merge with neighbouring zones. */
-#define ZONE_JOIN           0x1
+typedef uint8_t frame_flags_t;
-/** Convert the frame address to kernel va. */
-#define FRAME_KA        0x1
+/** Convert the frame address to kernel VA. */
+#define FRAME_KA          0x01
 /** Do not panic and do not sleep on failure. */
-#define FRAME_ATOMIC            0x2
+#define FRAME_ATOMIC      0x02
 /** Do not start reclaiming when no free memory. */
-#define FRAME_NO_RECLAIM        0x4
+#define FRAME_NO_RECLAIM  0x04
+typedef uint8_t zone_flags_t;
+/** Available zone (free for allocation) */
+#define ZONE_AVAILABLE  0x00
+/** Zone is reserved (not available for allocation) */
+#define ZONE_RESERVED   0x08
+/** Zone is used by firmware (not available for allocation) */
+#define ZONE_FIRMWARE   0x10
+/** Currently there is no equivalent zone flags
+    for frame flags */
+#define FRAME_TO_ZONE_FLAGS(frame_flags)  0
+typedef struct {
+    count_t refcount;     /**< Tracking of shared frames */
+    uint8_t buddy_order;  /**< Buddy system block order */
+    link_t buddy_link;    /**< Link to the next free block inside
+                               one order */
+    void *parent;         /**< If allocated by slab, this points there */
+} frame_t;
+typedef struct {
+    pfn_t base;                    /**< Frame_no of the first frame
+                                        in the frames array */
+    count_t count;                 /**< Size of zone */
+    count_t free_count;            /**< Number of free frame_t
+                                        structures */
+    count_t busy_count;            /**< Number of busy frame_t
+                                        structures */
+    zone_flags_t flags;            /**< Type of the zone */
+    frame_t *frames;               /**< Array of frame_t structures
+                                        in this zone */
+    buddy_system_t *buddy_system;  /**< Buddy system for the zone */
+} zone_t;
+/*
+ * The zoneinfo.lock must be locked when accessing zoneinfo structure.
+ * Some of the attributes in zone_t structures are 'read-only'
+ */
+typedef struct {
+    SPINLOCK_DECLARE(lock);
+    count_t count;
+    zone_t info[ZONES_MAX];
+} zones_t;
+extern zones_t zones;
 static inline uintptr_t PFN2ADDR(pfn_t frame)
 {
     return (uintptr_t) (frame << FRAME_WIDTH);
 ,31 → 136,37
     return (size_t) (frames << FRAME_WIDTH);
 }
-#define IS_BUDDY_ORDER_OK(index, order)     \
-    ((~(((unative_t) -1) << (order)) & (index)) == 0)
-#define IS_BUDDY_LEFT_BLOCK(zone, frame)    \
-    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
-#define IS_BUDDY_RIGHT_BLOCK(zone, frame)   \
-    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
-#define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame)    \
-    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
-#define IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame)   \
-    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
+static inline bool zone_flags_available(zone_flags_t flags)
+{
+    return ((flags & (ZONE_RESERVED | ZONE_FIRMWARE)) == 0);
+}
-#define frame_alloc(order, flags)       \
-    frame_alloc_generic(order, flags, NULL)
+#define IS_BUDDY_ORDER_OK(index, order) \
+    ((~(((unative_t) -1) << (order)) & (index)) == 0)
+#define IS_BUDDY_LEFT_BLOCK(zone, frame) \
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 0)
+#define IS_BUDDY_RIGHT_BLOCK(zone, frame) \
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 1)
+#define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame) \
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 0)
+#define IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame) \
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 1)
+#define frame_alloc(order, flags) \
+    frame_alloc_generic(order, flags, NULL)
 extern void frame_init(void);
-extern void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone);
-extern void frame_free(uintptr_t frame);
-extern void frame_reference_add(pfn_t pfn);
+extern void *frame_alloc_generic(uint8_t, frame_flags_t, count_t *);
+extern void frame_free(uintptr_t);
+extern void frame_reference_add(pfn_t);
-extern int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags);
-extern void *frame_get_parent(pfn_t frame, unsigned int hint);
-extern void frame_set_parent(pfn_t frame, void *data, unsigned int hint);
-extern void frame_mark_unavailable(pfn_t start, count_t count);
-extern uintptr_t zone_conf_size(count_t count);
-extern void zone_merge(unsigned int z1, unsigned int z2);
+extern count_t find_zone(pfn_t frame, count_t count, count_t hint);
+extern count_t zone_create(pfn_t, count_t, pfn_t, zone_flags_t);
+extern void *frame_get_parent(pfn_t, count_t);
+extern void frame_set_parent(pfn_t, void *, count_t);
+extern void frame_mark_unavailable(pfn_t, count_t);
+extern uintptr_t zone_conf_size(count_t);
+extern bool zone_merge(count_t, count_t);
 extern void zone_merge_all(void);
 extern uint64_t zone_total_size(void);
 ,7 → 174,7
  * Console functions
  */
 extern void zone_print_list(void);
-extern void zone_print_one(unsigned int znum);
+extern void zone_print_one(count_t);
 #endif

 /branches/dd/kernel/generic/include/mm/page.h
 ,15 → 39,10
 #include <mm/as.h>
 #include <memstr.h>
-/**
- * Macro for computing page color.
- */
-#define PAGE_COLOR(va)  (((va) >> PAGE_WIDTH) & ((1 << PAGE_COLOR_BITS) - 1))
 /** Operations to manipulate page mappings. */
 typedef struct {
     void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame,
-        int flags);
+        int flags);
     void (* mapping_remove)(as_t *as, uintptr_t page);
     pte_t *(* mapping_find)(as_t *as, uintptr_t page);
 } page_mapping_operations_t;
 ,6 → 59,7
 extern pte_t *page_table_create(int flags);
 extern void page_table_destroy(pte_t *page_table);
 extern void map_structure(uintptr_t s, size_t size);
 extern uintptr_t hw_map(uintptr_t physaddr, size_t size);
 #endif

 /branches/dd/kernel/generic/include/mm/slab.h
 ,12 → 53,13
 #define SLAB_INSIDE_SIZE   (PAGE_SIZE >> 3)
 /** Maximum wasted space we allow for cache */
-#define SLAB_MAX_BADNESS(cache)   (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
+#define SLAB_MAX_BADNESS(cache) \
+    (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
 /* slab_reclaim constants */
 /** Reclaim all possible memory, because we are in memory stress */
-#define SLAB_RECLAIM_ALL  0x1
+#define SLAB_RECLAIM_ALL  0x01
 /* cache_create flags */
 ,7 → 100,7
     int flags;
     /* Computed values */
-    uint8_t order;              /**< Order of frames to be allocated */
+    uint8_t order;          /**< Order of frames to be allocated */
     unsigned int objects;       /**< Number of objects that fit in */
     /* Statistics */
 ,14 → 122,13
     slab_mag_cache_t *mag_cache;
 } slab_cache_t;
-extern slab_cache_t * slab_cache_create(char *name, size_t size, size_t align,
-    int (*constructor)(void *obj, int kmflag), int (*destructor)(void *obj),
-    int flags);
-extern void slab_cache_destroy(slab_cache_t *cache);
+extern slab_cache_t *slab_cache_create(char *, size_t, size_t,
+    int (*)(void *, int), int (*)(void *), int);
+extern void slab_cache_destroy(slab_cache_t *);
-extern void * slab_alloc(slab_cache_t *cache, int flags);
-extern void slab_free(slab_cache_t *cache, void *obj);
-extern count_t slab_reclaim(int flags);
+extern void * slab_alloc(slab_cache_t *, int);
+extern void slab_free(slab_cache_t *, void *);
+extern count_t slab_reclaim(int);
 /* slab subsytem initialization */
 extern void slab_cache_init(void);
 ,9 → 138,9
 extern void slab_print_list(void);
 /* malloc support */
-extern void * malloc(unsigned int size, int flags);
-extern void * realloc(void *ptr, unsigned int size, int flags);
-extern void free(void *ptr);
+extern void *malloc(unsigned int, int);
+extern void *realloc(void *, unsigned int, int);
+extern void free(void *);
 #endif
 /** @}

 /branches/dd/kernel/generic/include/mm/as.h
 ,10 → 53,6
 #include <adt/btree.h>
 #include <lib/elf.h>
-#ifdef __OBJC__
-#include <lib/objc.h>
-#endif
 /**
  * Defined to be true if user address space and kernel address space shadow each
  * other.
 ,47 → 80,6
 /** The page fault was caused by memcpy_from_uspace() or memcpy_to_uspace(). */
 #define AS_PF_DEFER     2
-#ifdef __OBJC__
-@interface as_t : base_t {
-    @public
-        /** Protected by asidlock. */
-        link_t inactive_as_with_asid_link;
-        /**
-         * Number of processors on wich is this address space active.
-         * Protected by asidlock.
-         */
-        count_t cpu_refcount;
-        /**
-         * Address space identifier.
-         * Constant on architectures that do not support ASIDs.
-         * Protected by asidlock.
-         */
-        asid_t asid;
-        /** Number of references (i.e tasks that reference this as). */
-        atomic_t refcount;
-        mutex_t lock;
-        /** B+tree of address space areas. */
-        btree_t as_area_btree;
-        /** Non-generic content. */
-        as_genarch_t genarch;
-        /** Architecture specific content. */
-        as_arch_t arch;
-}
-+ (pte_t *) page_table_create: (int) flags;
-+ (void) page_table_destroy: (pte_t *) page_table;
-- (void) page_table_lock: (bool) _lock;
-- (void) page_table_unlock: (bool) unlock;
-@end
-#else
 /** Address space structure.
  *
  * as_t contains the list of as_areas of userspace accessible
 ,7 → 123,6
     void (* page_table_lock)(as_t *as, bool lock);
     void (* page_table_unlock)(as_t *as, bool unlock);
 } as_operations_t;
-#endif
 /**
  * This structure contains information associated with the shared address space
 ,10 → 203,7
 extern as_t *AS_KERNEL;
-#ifndef __OBJC__
 extern as_operations_t *as_operations;
-#endif
 extern link_t inactive_as_with_asid_head;
 extern void as_init(void);
 ,6 → 220,7
 extern int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags);
 int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
     as_t *dst_as, uintptr_t dst_base, int dst_flags_mask);
+extern int as_area_change_flags(as_t *as, int flags, uintptr_t address);
 extern int as_area_get_flags(as_area_t *area);
 extern bool as_area_check_access(as_area_t *area, pf_access_t access);
 ,11 → 251,19
 extern mem_backend_t elf_backend;
 extern mem_backend_t phys_backend;
-extern unsigned int elf_load(elf_header_t *header, as_t *as);
+/**
+ * This flags is passed when running the loader, otherwise elf_load()
+ * would return with a EE_LOADER error code.
+ */
+#define ELD_F_NONE  0
+#define ELD_F_LOADER    1
+extern unsigned int elf_load(elf_header_t *header, as_t *as, int flags);
 /* Address space area related syscalls. */
 extern unative_t sys_as_area_create(uintptr_t address, size_t size, int flags);
 extern unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags);
+extern unative_t sys_as_area_change_flags(uintptr_t address, int flags);
 extern unative_t sys_as_area_destroy(uintptr_t address);
 /* Introspection functions. */

 /branches/dd/kernel/generic/include/mm/buddy.h
 ,7 → 66,6
     void (*mark_available)(struct buddy_system *, link_t *);
     /** Find parent of block that has given order  */
     link_t *(* find_block)(struct buddy_system *, link_t *, uint8_t);
-    void (* print_id)(struct buddy_system *, link_t *);
 } buddy_system_operations_t;
 typedef struct buddy_system {
 ,14 → 77,13
     void *data;
 } buddy_system_t;
-extern void buddy_system_create(buddy_system_t *b, uint8_t max_order,
-    buddy_system_operations_t *op, void *data);
-extern link_t *buddy_system_alloc(buddy_system_t *b, uint8_t i);
-extern bool buddy_system_can_alloc(buddy_system_t *b, uint8_t order);
-extern void buddy_system_free(buddy_system_t *b, link_t *block);
-extern void buddy_system_structure_print(buddy_system_t *b, size_t elem_size);
-extern size_t buddy_conf_size(int max_order);
-extern link_t *buddy_system_alloc_block(buddy_system_t *b, link_t *block);
+extern void buddy_system_create(buddy_system_t *, uint8_t,
+    buddy_system_operations_t *, void *);
+extern link_t *buddy_system_alloc(buddy_system_t *, uint8_t);
+extern bool buddy_system_can_alloc(buddy_system_t *, uint8_t);
+extern void buddy_system_free(buddy_system_t *, link_t *);
+extern size_t buddy_conf_size(size_t);
+extern link_t *buddy_system_alloc_block(buddy_system_t *, link_t *);
 #endif

 /branches/dd/kernel/generic/include/typedefs.h
 ,8 → 35,26
 #ifndef KERN_TYPEDEFS_H_
 #define KERN_TYPEDEFS_H_
+#include <arch/types.h>
+#define NULL 0
+#define false 0
+#define true 1
 typedef void (* function)();
+typedef uint8_t bool;
+typedef uint64_t thread_id_t;
+typedef uint64_t task_id_t;
+typedef uint32_t context_id_t;
+typedef int32_t inr_t;
+typedef int32_t devno_t;
+typedef volatile uint8_t ioport8_t;
+typedef volatile uint16_t ioport16_t;
+typedef volatile uint32_t ioport32_t;
 #endif
 /** @}

 /branches/dd/kernel/generic/include/macros.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,22 → 37,25
 #include <arch/types.h>
-#define isdigit(d)  (((d) >= '0') && ((d) <= '9'))
-#define islower(c)  (((c) >= 'a') && ((c) <= 'z'))
-#define isupper(c)  (((c) >= 'A') && ((c) <= 'Z'))
-#define isalpha(c)  (is_lower(c) || is_upper(c))
-#define isalphanum(c)   (is_alpha(c) || is_digit(c))
-#define isspace(c)  (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || \
-                ((c) == '\r'))
+#define isdigit(d)     (((d) >= '0') && ((d) <= '9'))
+#define islower(c)     (((c) >= 'a') && ((c) <= 'z'))
+#define isupper(c)     (((c) >= 'A') && ((c) <= 'Z'))
+#define isalpha(c)     (is_lower((c)) || is_upper((c)))
+#define isalphanum(c)  (is_alpha((c)) || is_digit((c)))
+#define isspace(c) \
+    (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
-#define min(a,b)    ((a) < (b) ? (a) : (b))
-#define max(a,b)    ((a) > (b) ? (a) : (b))
+#define min(a, b)  ((a) < (b) ? (a) : (b))
+#define max(a, b)  ((a) > (b) ? (a) : (b))
-/** Return true if the interlvals overlap.
+#define min3(a, b, c)  ((a) < (b) ? (min(a, c)) : (min(b, c)))
+#define max3(a, b, c)  ((a) > (b) ? (max(a, c)) : (max(b, c)))
+/** Return true if the intervals overlap.
  *
- * @param s1 Start address of the first interval.
+ * @param s1  Start address of the first interval.
  * @param sz1 Size of the first interval.
- * @param s2 Start address of the second interval.
+ * @param s2  Start address of the second interval.
  * @param sz2 Size of the second interval.
  */
 static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2)
 ,19 → 62,35
 {
     uintptr_t e1 = s1 + sz1;
     uintptr_t e2 = s2 + sz2;
-    return (s1 < e2) && (s2 < e1);
+    return ((s1 < e2) && (s2 < e1));
 }
 /* Compute overlapping of physical addresses */
-#define PA_overlaps(x, szx, y, szy) overlaps(KA2PA(x), szx, KA2PA(y), szy)
+#define PA_overlaps(x, szx, y, szy) \
+    overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
-#define SIZE2KB(size) (size >> 10)
-#define SIZE2MB(size) (size >> 20)
+#define SIZE2KB(size)  ((size) >> 10)
+#define SIZE2MB(size)  ((size) >> 20)
-#define STRING(arg) STRING_ARG(arg)
-#define STRING_ARG(arg) #arg
+#define KB2SIZE(kb)  ((kb) << 10)
+#define MB2SIZE(mb)  ((mb) << 20)
+#define STRING(arg)      STRING_ARG(arg)
+#define STRING_ARG(arg)  #arg
+/** Pseudorandom generator
+ *
+ * A pretty standard linear congruential pseudorandom
+ * number generator (m = 2^32 or 2^64 depending on architecture).
+ *
+ */
+#define RANDI(seed) \
+    ({ \
+        (seed) = 1103515245 * (seed) + 12345; \
+        (seed); \
+    })
 #endif
 /** @}

 /branches/dd/kernel/generic/include/stdarg.h
 ,7 → 45,7
 #define va_start(ap, last)      __builtin_va_start(ap, last)
 #define va_arg(ap, type)        __builtin_va_arg(ap, type)
 #define va_end(ap)          __builtin_va_end(ap)
-#define va_copy(dst,src)        __builtin_va_copy(dst,src)
+#define va_copy(dst, src)       __builtin_va_copy(dst, src)
 #endif

 /branches/dd/kernel/generic/include/syscall/syscall.h
 ,17 → 36,26
 #define KERN_SYSCALL_H_
 typedef enum {
-    SYS_IO = 0,
+    SYS_KLOG = 0,
     SYS_TLS_SET = 1, /* Hardcoded in AMD64, IA32 uspace - fibril.S */
     SYS_THREAD_CREATE,
     SYS_THREAD_EXIT,
     SYS_THREAD_GET_ID,
     SYS_TASK_GET_ID,
+    SYS_TASK_SET_NAME,
+    SYS_PROGRAM_SPAWN_LOADER,
     SYS_FUTEX_SLEEP,
     SYS_FUTEX_WAKEUP,
+    SYS_SMC_COHERENCE,
     SYS_AS_AREA_CREATE,
     SYS_AS_AREA_RESIZE,
+    SYS_AS_AREA_CHANGE_FLAGS,
     SYS_AS_AREA_DESTROY,
     SYS_IPC_CALL_SYNC_FAST,
     SYS_IPC_CALL_SYNC_SLOW,
     SYS_IPC_CALL_ASYNC_FAST,
 ,18 → 63,25
     SYS_IPC_ANSWER_FAST,
     SYS_IPC_ANSWER_SLOW,
     SYS_IPC_FORWARD_FAST,
+    SYS_IPC_FORWARD_SLOW,
     SYS_IPC_WAIT,
     SYS_IPC_HANGUP,
     SYS_IPC_REGISTER_IRQ,
     SYS_IPC_UNREGISTER_IRQ,
     SYS_CAP_GRANT,
     SYS_CAP_REVOKE,
     SYS_PHYSMEM_MAP,
     SYS_IOSPACE_ENABLE,
     SYS_PREEMPT_CONTROL,
     SYS_SYSINFO_VALID,
     SYS_SYSINFO_VALUE,
     SYS_DEBUG_ENABLE_CONSOLE,
+    SYS_DEBUG_DISABLE_CONSOLE,
+    SYS_IPC_CONNECT_KBOX,
     SYSCALL_END
 } syscall_t;

 /branches/dd/kernel/generic/include/ipc/sysipc.h
 ,10 → 53,13
     int nonblocking);
 unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
     unative_t method, unative_t arg1, unative_t arg2, int mode);
+unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+    ipc_data_t *data, int mode);
 unative_t sys_ipc_hangup(int phoneid);
 unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
     irq_code_t *ucode);
 unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno);
+unative_t sys_ipc_connect_kbox(sysarg64_t *task_id);
 #endif

 /branches/dd/kernel/generic/include/ipc/ipc.h
 ,6 → 195,12
  */
 #define IPC_M_DATA_READ     7
+/** Debug the recipient.
+ * - ARG1 - specifies the debug method (from udebug_method_t)
+ * - other arguments are specific to the debug method
+ */
+#define IPC_M_DEBUG_ALL     8
 /* Well-known methods */
 #define IPC_M_LAST_SYSTEM   511
 #define IPC_M_PING      512
 ,6 → 287,13
     /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */
     uint8_t *buffer;
+    /*
+     * The forward operation can masquerade the caller phone. For those
+     * cases, we must keep it aside so that the answer is processed
+     * correctly.
+     */
+    phone_t *caller_phone;
 } call_t;
 extern void ipc_init(void);
 ,7 → 300,7
 extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, int);
 extern void ipc_answer(answerbox_t *, call_t *);
 extern int ipc_call(phone_t *, call_t *);
-extern void ipc_call_sync(phone_t *, call_t *);
+extern int ipc_call_sync(phone_t *, call_t *);
 extern void ipc_phone_init(phone_t *);
 extern void ipc_phone_connect(phone_t *, answerbox_t *);
 extern void ipc_call_free(call_t *);
 ,6 → 313,8
 extern int ipc_phone_hangup(phone_t *);
 extern void ipc_backsend_err(phone_t *, call_t *, unative_t);
 extern void ipc_print_task(task_id_t);
+extern void ipc_answerbox_slam_phones(answerbox_t *, bool);
+extern void ipc_cleanup_call_list(link_t *);
 extern answerbox_t *ipc_phone_0;

 /branches/dd/kernel/generic/include/ipc/irq.h
 ,7 → 36,7
 #define KERN_IPC_IRQ_H_
 /** Maximum length of IPC IRQ program */
-#define IRQ_MAX_PROG_SIZE   10
+#define IRQ_MAX_PROG_SIZE   20
 #include <ipc/ipc.h>
 #include <ddi/irq.h>
 ,16 → 43,21
 #include <arch/types.h>
 #include <adt/list.h>
-extern int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
-    unative_t method, irq_code_t *ucode);
-extern void ipc_irq_send_notif(irq_t *irq);
-extern void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno);
-extern void ipc_irq_cleanup(answerbox_t *box);
+extern int ipc_irq_register(answerbox_t *, inr_t, devno_t, unative_t,
+    irq_code_t *);
+extern irq_ownership_t ipc_irq_top_half_claim(irq_t *);
+extern void ipc_irq_top_half_handler(irq_t *);
+extern int ipc_irq_unregister(answerbox_t *, inr_t, devno_t);
+extern void ipc_irq_cleanup(answerbox_t *);
 /*
  * User friendly wrappers for ipc_irq_send_msg(). They are in the form
  * ipc_irq_send_msg_m(), where m is the number of payload arguments.
  */
+#define ipc_irq_send_msg_0(irq) \
+    ipc_irq_send_msg((irq), 0, 0, 0, 0, 0)
 #define ipc_irq_send_msg_1(irq, a1) \
     ipc_irq_send_msg((irq), (a1), 0, 0, 0, 0)
 #define ipc_irq_send_msg_2(irq, a1, a2) \
 ,8 → 69,8
 #define ipc_irq_send_msg_5(irq, a1, a2, a3, a4, a5) \
     ipc_irq_send_msg((irq), (a1), (a2), (a3), (a4), (a5))
-extern void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2,
-    unative_t a3, unative_t a4, unative_t a5);
+extern void ipc_irq_send_msg(irq_t *, unative_t, unative_t, unative_t, unative_t,
+    unative_t);
 #endif

 /branches/dd/kernel/generic/include/ipc/kbox.h
 ,0 → 1,58
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+/** @addtogroup genericipc
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_IPC_KBOX_H_
+#define KERN_IPC_KBOX_H_
+#include <typedefs.h>
+/** Kernel answerbox structure. */
+typedef struct kbox {
+    /** The answerbox itself. */
+    answerbox_t box;
+    /** Thread used to service the answerbox. */
+    struct thread *thread;
+    /** Kbox thread creation vs. begin of cleanup mutual exclusion. */
+    mutex_t cleanup_lock;
+    /** True if cleanup of kbox has already started. */
+    bool finished;
+} kbox_t;
+extern int ipc_connect_kbox(task_id_t);
+extern void ipc_kbox_cleanup(void);
+#endif
+/** @}
+ */

 /branches/dd/kernel/generic/include/errno.h
 ,14 → 48,18
                  * sys_ipc_hangup() to close the connection.
                  * Used by answerbox to close the connection.
                  */
-#define EEXISTS     -8  /* Entry already exists */
-#define EBADMEM     -9  /* Bad memory pointer */
-#define ENOTSUP     -10 /* Not supported */
-#define EADDRNOTAVAIL   -11 /* Address not available. */
-#define ETIMEOUT        -12     /* Timeout expired */
-#define EINVAL          -13     /* Invalid value */
-#define EBUSY           -14     /* Resource is busy */
-#define EOVERFLOW   -15 /* The result does not fit its size. */
+#define EPARTY      -8  /* The other party encountered an error when
+                 * receiving the call.
+                 */
+#define EEXISTS     -9  /* Entry already exists */
+#define EBADMEM     -10 /* Bad memory pointer */
+#define ENOTSUP     -11 /* Not supported */
+#define EADDRNOTAVAIL   -12 /* Address not available. */
+#define ETIMEOUT        -13     /* Timeout expired */
+#define EINVAL          -14     /* Invalid value */
+#define EBUSY           -15     /* Resource is busy */
+#define EOVERFLOW   -16 /* The result does not fit its size. */
+#define EINTR       -17 /* Operation was interrupted. */
 #endif

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3022 → Rev 4055