WebSVN – HelenOS – Path Comparison – / – /branches/network/kernel/generic/ Rev 4152 and /branches/network/kernel/generic/ Rev 4153

Ignore whitespace Rev 4152 → Rev 4153

 /branches/network/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/network/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/network/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/network/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/network/kernel/generic/include/symtab.h
 ,15 → 44,20
     char symbol_name[MAX_SYMBOL_NAME];
 };
-extern char * get_symtab_entry(unative_t addr);
-extern uintptr_t get_symbol_addr(const char *name);
+extern int symtab_name_lookup(unative_t addr, char **name);
+extern char *symtab_fmt_name_lookup(unative_t addr);
+extern int symtab_addr_lookup(const char *name, uintptr_t *addr);
 extern void symtab_print_search(const char *name);
 extern int symtab_compl(char *name);
+#ifdef CONFIG_SYMTAB
 /* Symtable linked together by build process */
 extern struct symtab_entry symbol_table[];
 #endif
+#endif
 /** @}
  */

 /branches/network/kernel/generic/include/config.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,13 → 38,16
 #include <arch/types.h>
 #include <arch/mm/page.h>
-#define STACK_SIZE      PAGE_SIZE
+#define STACK_SIZE  PAGE_SIZE
-#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/network/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/network/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;
 ,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/network/kernel/generic/include/proc/program.h
 ,12 → 52,14
 extern void *program_loader;
-extern void program_create(as_t *as, uintptr_t entry_addr, program_t *p);
-extern int program_create_from_image(void *image_addr, program_t *p);
-extern int program_create_loader(program_t *p);
+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(int *uspace_phone_id);
+extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len);
 #endif

 /branches/network/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/network/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/network/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/network/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/network/kernel/generic/include/debug.h
 ,21 → 57,21
 #ifdef CONFIG_DEBUG
 #   define ASSERT(expr) \
         if (!(expr)) { \
-            panic("assertion failed (%s), caller=%p\n", #expr, CALLER); \
+            panic("Assertion failed (%s), caller=%p.", #expr, CALLER); \
         }
 #else
 #   define ASSERT(expr)
 #endif
-/** Extensive debugging output macro
+/** Extensive logging output macro
  *
- * If CONFIG_EDEBUG is set, the LOG() macro
+ * If CONFIG_LOG is set, the LOG() macro
  * will print whatever message is indicated plus
  * an information about the location.
  *
  */
-#ifdef CONFIG_EDEBUG
+#ifdef CONFIG_LOG
 #   define LOG(format, ...) \
         printf("%s() at %s:%u: " format "\n", __func__, __FILE__, \
             __LINE__, ##__VA_ARGS__);
 ,15 → 79,15
 #   define LOG(format, ...)
 #endif
-/** Extensive debugging execute macro
+/** Extensive logging execute macro
  *
- * If CONFIG_EDEBUG is set, the LOG_EXEC() macro
+ * If CONFIG_LOG is set, the LOG_EXEC() macro
  * will print an information about calling a given
  * function and call it.
  *
  */
-#ifdef CONFIG_EDEBUG
+#ifdef CONFIG_LOG
 #   define LOG_EXEC(fnc) \
         { \
             printf("%s() at %s:%u: " #fnc "\n", __func__, __FILE__, \

 /branches/network/kernel/generic/include/panic.h
 ,11 → 37,11
 #ifdef CONFIG_DEBUG
 #   define panic(format, ...) \
-        panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \
-        __FILE__, __LINE__, ##__VA_ARGS__);
+        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__);
+        panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__);
 #endif
 extern void panic_printf(char *fmt, ...) __attribute__((noreturn));

 /branches/network/kernel/generic/include/interrupt.h
 ,12 → 44,12
 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; \
-        printf("Task %" PRIu64 " killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \
-        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/network/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/network/kernel/generic/include/synch/spinlock.h
36,6 → 36,7
#define KERN_SPINLOCK_H_

#include <arch/types.h>
#include <arch/barrier.h>
#include <preemption.h>
#include <atomic.h>
#include <debug.h>

 /branches/network/kernel/generic/include/memstr.h
 ,7 → 44,7
 extern void *_memcpy(void *dst, const void *src, size_t cnt);
 extern void _memsetb(void *dst, size_t cnt, uint8_t x);
 extern void _memsetw(void *dst, size_t cnt, uint16_t x);
-extern char *strcpy(char *dest, const char *src);
+extern void *memmove(void *dst, const void *src, size_t cnt);
 #endif

 /branches/network/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/network/kernel/generic/include/ddi/device.h
39,6 → 39,7
#include <typedefs.h>

extern devno_t device_assign_devno(void);
extern unative_t sys_device_assign_devno(void);

#endif

 /branches/network/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/network/kernel/generic/include/console/chardev.h
 ,41 → 39,60
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
-#define CHARDEV_BUFLEN 512
+#define INDEV_BUFLEN  512
-struct chardev;
+struct indev;
-/* Character device operations interface. */
+/* Input character device operations interface. */
 typedef struct {
-    /** Suspend pushing characters. */
-    void (* suspend)(struct chardev *);
-    /** Resume pushing characters. */
-    void (* resume)(struct chardev *);
-    /** Write character to stream. */
-    void (* write)(struct chardev *, char c);
     /** Read character directly from device, assume interrupts disabled. */
-    char (* read)(struct chardev *);
-} chardev_operations_t;
+    char (* poll)(struct indev *);
+} indev_operations_t;
 /** Character input device. */
-typedef struct chardev {
+typedef struct indev {
     char *name;
+    waitq_t wq;
-    waitq_t wq;
     /** Protects everything below. */
-    SPINLOCK_DECLARE(lock);
-    uint8_t buffer[CHARDEV_BUFLEN];
+    SPINLOCK_DECLARE(lock);
+    uint8_t buffer[INDEV_BUFLEN];
     count_t counter;
-    /** Implementation of chardev operations. */
-    chardev_operations_t *op;
+    /** Implementation of indev operations. */
+    indev_operations_t *op;
     index_t index;
     void *data;
-} chardev_t;
+} indev_t;
-extern void chardev_initialize(char *name, chardev_t *chardev,
-    chardev_operations_t *op);
-extern void chardev_push_character(chardev_t *chardev, uint8_t ch);
+struct outdev;
+/* Output character device operations interface. */
+typedef struct {
+    /** Write character to output. */
+    void (* write)(struct outdev *, char c, bool silent);
+} outdev_operations_t;
+/** Character input device. */
+typedef struct outdev {
+    char *name;
+    /** Protects everything below. */
+    SPINLOCK_DECLARE(lock);
+    /** Implementation of outdev operations. */
+    outdev_operations_t *op;
+    void *data;
+} outdev_t;
+extern void indev_initialize(char *name, indev_t *indev,
+    indev_operations_t *op);
+extern void indev_push_character(indev_t *indev, uint8_t ch);
+extern void outdev_initialize(char *name, outdev_t *outdev,
+    outdev_operations_t *op);
 #endif /* KERN_CHARDEV_H_ */
 /** @}

 /branches/network/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,17
     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 bool kconsole_check_poll(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/network/kernel/generic/include/console/console.h
 ,17 → 38,29
 #include <arch/types.h>
 #include <console/chardev.h>
-extern chardev_t *stdin;
-extern chardev_t *stdout;
+extern indev_t *stdin;
+extern outdev_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 count_t gets(chardev_t *chardev, char *buf, size_t buflen);
+extern bool check_poll(indev_t *indev);
+extern uint8_t getc(indev_t *indev);
+extern uint8_t _getc(indev_t *indev);
+extern count_t gets(indev_t *indev, char *buf, size_t buflen);
 extern void putchar(char c);
+extern unative_t sys_klog(int fd, const void * buf, size_t count);
+extern void grab_console(void);
+extern void release_console(void);
+extern unative_t sys_debug_enable_console(void);
+extern unative_t sys_debug_disable_console(void);
 extern void arch_grab_console(void);
 extern void arch_release_console(void);

 /branches/network/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/network/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/network/kernel/generic/include/mm/frame.h
 ,34 → 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
-/** Convert the frame address to kernel va. */
-#define FRAME_KA        0x1
+typedef uint8_t frame_flags_t;
+/** 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
-/** Do not allocate above 4 GiB. */
-#define FRAME_LOW_4_GiB     0x8
+#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)     \
+static inline bool zone_flags_available(zone_flags_t flags)
+{
+    return ((flags & (ZONE_RESERVED | ZONE_FIRMWARE)) == 0);
+}
+#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)
+#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)       \
+#define frame_alloc(order, flags) \
     frame_alloc_generic(order, flags, NULL)
 extern void frame_init(void);
-extern void *frame_alloc_generic(uint8_t, int, unsigned int *);
+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, count_t, pfn_t, int);
-extern void *frame_get_parent(pfn_t, unsigned int);
-extern void frame_set_parent(pfn_t, void *, unsigned int);
+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 void zone_merge(unsigned int, unsigned int);
+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);
+extern void zone_print_one(count_t);
 #endif

 /branches/network/kernel/generic/include/mm/page.h
 ,7 → 42,7
 /** 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/network/kernel/generic/include/mm/slab.h
 ,7 → 59,7
 /* 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 */

 /branches/network/kernel/generic/include/mm/buddy.h
 ,7 → 82,7
 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(int);
+extern size_t buddy_conf_size(size_t);
 extern link_t *buddy_system_alloc_block(buddy_system_t *, link_t *);
 #endif

 /branches/network/kernel/generic/include/typedefs.h
 ,6 → 51,10
 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/network/kernel/generic/include/macros.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,47 → 35,66
 #ifndef KERN_MACROS_H_
 #define KERN_MACROS_H_
+#ifndef __ASM__
 #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 min(a,b)    ((a) < (b) ? (a) : (b))
-#define max(a,b)    ((a) > (b) ? (a) : (b))
 /** Return true if the intervals overlap.
  *
- * @param s1        Start address of the first interval.
- * @param sz1       Size of the first interval.
- * @param s2        Start address of the second interval.
- * @param sz2       Size of the second 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 sz2 Size of the second interval.
  */
 static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2)
 {
     uintptr_t e1 = s1 + sz1;
     uintptr_t e2 = s2 + sz2;
-    return (s1 < e2) && (s2 < e1);
+    return ((s1 < e2) && (s2 < e1));
 }
+#endif /* __ASM__ */
+#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 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)))
 /* Compute overlapping of physical addresses */
-#define PA_overlaps(x, szx, 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 KB2SIZE(kb) ((kb) << 10)
-#define MB2SIZE(mb) ((mb) << 20)
+#define KB2SIZE(kb)  ((kb) << 10)
+#define MB2SIZE(mb)  ((mb) << 20)
-#define STRING(arg) STRING_ARG(arg)
-#define STRING_ARG(arg) #arg
+#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/network/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/network/kernel/generic/include/syscall/syscall.h
44,6 → 44,7
SYS_THREAD_GET_ID,

SYS_TASK_GET_ID,
SYS_TASK_SET_NAME,
SYS_PROGRAM_SPAWN_LOADER,

SYS_FUTEX_SLEEP,
62,6 → 63,7
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,
70,6 → 72,7
SYS_CAP_GRANT,
SYS_CAP_REVOKE,

SYS_DEVICE_ASSIGN_DEVNO,
SYS_PHYSMEM_MAP,
SYS_IOSPACE_ENABLE,
SYS_PREEMPT_CONTROL,
78,6 → 81,8
SYS_SYSINFO_VALUE,

SYS_DEBUG_ENABLE_CONSOLE,
SYS_DEBUG_DISABLE_CONSOLE,
SYS_IPC_CONNECT_KBOX,
SYSCALL_END
} syscall_t;

 /branches/network/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/network/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
 ,12 → 266,6
 typedef struct {
     unative_t args[IPC_CALL_LEN];
     phone_t *phone;
-    /*
-     * 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;
 } ipc_data_t;
 typedef struct {
 ,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);
 ,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/network/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/network/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/network/kernel/generic/include/errno.h
 ,15 → 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 EINTR       -16 /* Operation was interrupted. */
+#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

 /branches/network/kernel/generic/src/synch/rwlock.c
 ,10 → 231,10
             interrupts_restore(ipl);
             break;
         case ESYNCH_OK_ATOMIC:
-            panic("_mutex_lock_timeout() == ESYNCH_OK_ATOMIC\n");
+            panic("_mutex_lock_timeout() == ESYNCH_OK_ATOMIC.");
             break;
         default:
-            panic("invalid ESYNCH\n");
+            panic("Invalid ESYNCH.");
             break;
         }
         return rc;

 /branches/network/kernel/generic/src/synch/spinlock.c
 ,7 → 76,6
 void spinlock_lock_debug(spinlock_t *sl)
 {
     count_t i = 0;
-    char *symbol;
     bool deadlock_reported = false;
     preemption_disable();
 ,12 → 105,10
             continue;
 #endif
         if (i++ > DEADLOCK_THRESHOLD) {
-            printf("cpu%u: looping on spinlock %" PRIp ":%s, caller=%" PRIp,
-                CPU->id, sl, sl->name, CALLER);
-            symbol = get_symtab_entry(CALLER);
-            if (symbol)
-                printf("(%s)", symbol);
-            printf("\n");
+            printf("cpu%u: looping on spinlock %" PRIp ":%s, "
+                "caller=%" PRIp "(%s)", CPU->id, sl, sl->name,
+                CALLER, symtab_fmt_name_lookup(CALLER));
             i = 0;
             deadlock_reported = true;
         }

 /branches/network/kernel/generic/src/synch/futex.c
 ,6 → 115,7
     uintptr_t paddr;
     pte_t *t;
     ipl_t ipl;
+    int rc;
     ipl = interrupts_disable();
 ,9 → 135,17
     interrupts_restore(ipl);
     futex = futex_find(paddr);
-    return (unative_t) waitq_sleep_timeout(&futex->wq, usec, flags |
+#ifdef CONFIG_UDEBUG
+    udebug_stoppable_begin();
+#endif
+    rc = waitq_sleep_timeout(&futex->wq, usec, flags |
         SYNCH_FLAGS_INTERRUPTIBLE);
+#ifdef CONFIG_UDEBUG
+    udebug_stoppable_end();
+#endif
+    return (unative_t) rc;
 }
 /** Wakeup one thread waiting in futex wait queue.

 /branches/network/kernel/generic/src/main/kinit.c
 ,7 → 32,7
 /**
  * @file
- * @brief   Kernel initialization thread.
+ * @brief Kernel initialization thread.
  *
  * This file contains kinit kernel thread which carries out
  * high level system initialization.
 ,6 → 64,8
 #include <security/cap.h>
 #include <lib/rd.h>
 #include <ipc/ipc.h>
+#include <debug.h>
+#include <string.h>
 #ifdef CONFIG_SMP
 #include <smp/smp.h>
 ,6 → 74,15
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
+#define ALIVE_CHARS  4
+#ifdef CONFIG_KCONSOLE
+static char alive[ALIVE_CHARS] = "-\\|/";
+#endif
+#define INIT_PREFIX      "init:"
+#define INIT_PREFIX_LEN  5
 /** Kernel initialization thread.
  *
  * kinit takes care of higher level kernel
 ,16 → 93,19
  */
 void kinit(void *arg)
 {
-    thread_t *t;
+#if defined(CONFIG_SMP) || defined(CONFIG_KCONSOLE)
+    thread_t *thread;
+#endif
     /*
      * Detach kinit as nobody will call thread_join_timeout() on it.
      */
     thread_detach(THREAD);
     interrupts_disable();
-#ifdef CONFIG_SMP
+#ifdef CONFIG_SMP
     if (config.cpu_count > 1) {
         waitq_initialize(&ap_completion_wq);
         /*
 ,24 → 114,18
          * not mess together with kcpulb threads.
          * Just a beautification.
          */
-        if ((t = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED,
-            "kmp", true))) {
-            spinlock_lock(&t->lock);
-            t->cpu = &cpus[0];
-            spinlock_unlock(&t->lock);
-            thread_ready(t);
+        thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
+        if (thread != NULL) {
+            spinlock_lock(&thread->lock);
+            thread->cpu = &cpus[0];
+            spinlock_unlock(&thread->lock);
+            thread_ready(thread);
         } else
-            panic("thread_create/kmp\n");
-        thread_join(t);
-        thread_detach(t);
+            panic("Unable to create kmp thread.");
+        thread_join(thread);
+        thread_detach(thread);
     }
-#endif /* CONFIG_SMP */
-    /*
-     * Now that all CPUs are up, we can report what we've found.
-     */
-    cpu_list();
-#ifdef CONFIG_SMP
     if (config.cpu_count > 1) {
         count_t i;
 ,35 → 133,36
          * For each CPU, create its load balancing thread.
          */
         for (i = 0; i < config.cpu_count; i++) {
-            if ((t = thread_create(kcpulb, NULL, TASK,
-                THREAD_FLAG_WIRED, "kcpulb", true))) {
-                spinlock_lock(&t->lock);
-                t->cpu = &cpus[i];
-                spinlock_unlock(&t->lock);
-                thread_ready(t);
+            thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
+            if (thread != NULL) {
+                spinlock_lock(&thread->lock);
+                thread->cpu = &cpus[i];
+                spinlock_unlock(&thread->lock);
+                thread_ready(thread);
             } else
-                panic("thread_create/kcpulb\n");
+                printf("Unable to create kcpulb thread for cpu" PRIc "\n", i);
         }
     }
 #endif /* CONFIG_SMP */
     /*
      * At this point SMP, if present, is configured.
      */
     arch_post_smp_init();
-    /*
-     * Create kernel console.
-     */
-    t = thread_create(kconsole, (void *) "kconsole", TASK, 0, "kconsole",
-        false);
-    if (t)
-        thread_ready(t);
-    else
-        panic("thread_create/kconsole\n");
+#ifdef CONFIG_KCONSOLE
+    if (stdin) {
+        /*
+         * Create kernel console.
+         */
+        thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
+        if (thread != NULL)
+            thread_ready(thread);
+        else
+            printf("Unable to create kconsole thread\n");
+    }
+#endif /* CONFIG_KCONSOLE */
     interrupts_enable();
     /*
 ,14 → 173,31
     for (i = 0; i < init.cnt; i++) {
         if (init.tasks[i].addr % FRAME_SIZE) {
-            printf("init[%" PRIc "].addr is not frame aligned", i);
+            printf("init[%" PRIc "].addr is not frame aligned\n", i);
             continue;
         }
+        /*
+         * Construct task name from the 'init:' prefix and the
+         * name stored in the init structure (if any).
+         */
+        char namebuf[TASK_NAME_BUFLEN];
+        char *name;
+        name = init.tasks[i].name;
+        if (name[0] == '\0')
+            name = "<unknown>";
+        ASSERT(TASK_NAME_BUFLEN >= INIT_PREFIX_LEN);
+        strncpy(namebuf, INIT_PREFIX, TASK_NAME_BUFLEN);
+        strncpy(namebuf + INIT_PREFIX_LEN, name,
+            TASK_NAME_BUFLEN - INIT_PREFIX_LEN);
         int rc = program_create_from_image((void *) init.tasks[i].addr,
-            &programs[i]);
-        if (rc == 0 && programs[i].task != NULL) {
+            namebuf, &programs[i]);
+        if ((rc == 0) && (programs[i].task != NULL)) {
             /*
              * Set capabilities to init userspace tasks.
              */
 ,31 → 210,42
             /* It was the program loader and was registered */
         } else {
             /* RAM disk image */
-            int rd = init_rd((rd_header_t *) init.tasks[i].addr,
-                init.tasks[i].size);
+            int rd = init_rd((rd_header_t *) init.tasks[i].addr, init.tasks[i].size);
             if (rd != RE_OK)
-                printf("Init binary %" PRIc " not used, error "
-                    "code %d.\n", i, rd);
+                printf("Init binary %" PRIc " not used (error %d)\n", i, rd);
         }
     }
     /*
-     * Run user tasks with reasonable delays
+     * Run user tasks with small delays
+     * to avoid intermixed klog output.
+     *
+     * TODO: This certainly does not guarantee
+     *       anything, it just works in most of the
+     *       cases. Some better way how to achieve
+     *       nice klog output should be found.
      */
     for (i = 0; i < init.cnt; i++) {
         if (programs[i].task != NULL) {
-            thread_usleep(50000);
             program_ready(&programs[i]);
+            thread_usleep(10000);
         }
     }
+#ifdef CONFIG_KCONSOLE
     if (!stdin) {
-        while (1) {
+        thread_sleep(10);
+        printf("kinit: No stdin\nKernel alive: .");
+        unsigned int i = 0;
+        while (true) {
+            printf("\b%c", alive[i % ALIVE_CHARS]);
             thread_sleep(1);
-            printf("kinit... ");
+            i++;
         }
     }
+#endif /* CONFIG_KCONSOLE */
 }
 /** @}

 /branches/network/kernel/generic/src/main/main.c
 ,8 → 81,8
 #include <adt/btree.h>
 #include <smp/smp.h>
 #include <ddi/ddi.h>
+#include <main/main.h>
 /** Global configuration structure. */
 config_t config;
 ,18 → 105,15
  * appropriate sizes and addresses.
  */
-/**< Virtual address of where the kernel is loaded. */
+/** Virtual address of where the kernel is loaded. */
 uintptr_t hardcoded_load_address = 0;
-/**< Size of the kernel code in bytes. */
+/** Size of the kernel code in bytes. */
 size_t hardcoded_ktext_size = 0;
-/**< Size of the kernel data in bytes. */
+/** Size of the kernel data in bytes. */
 size_t hardcoded_kdata_size = 0;
-/**< Lowest safe stack virtual address. */
+/** Lowest safe stack virtual address. */
 uintptr_t stack_safe = 0;
-void main_bsp(void);
-void main_ap(void);
 /*
  * These two functions prevent stack from underflowing during the
  * kernel boot phase when SP is set to the very top of the reserved
 ,8 → 188,6
 {
     /* Keep this the first thing. */
     the_initialize(THE);
-    LOG();
     version_print();
 ,7 → 196,7
         config.base, config.kernel_size, config.stack_base,
         config.stack_size);
+#ifdef CONFIG_KCONSOLE
     /*
      * kconsole data structures must be initialized very early
      * because other subsystems will register their respective
 ,6 → 203,7
      * commands.
      */
     LOG_EXEC(kconsole_init());
+#endif
     /*
      * Exception handler initialization, before architecture
 ,7 → 210,7
      * starts adding its own handlers
      */
     LOG_EXEC(exc_init());
     /*
      * Memory management subsystems initialization.
      */
 ,7 → 248,7
     if (init.cnt > 0) {
         count_t i;
         for (i = 0; i < init.cnt; i++)
-            printf("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
+            LOG("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
                 "].size=%#" PRIs "\n", i, init.tasks[i].addr, i,
                 init.tasks[i].size);
     } else
 ,21 → 256,25
     LOG_EXEC(ipc_init());
     LOG_EXEC(klog_init());
+#ifdef CONFIG_KCONSOLE
+    LOG_EXEC(kconsole_notify_init());
+#endif
     /*
      * Create kernel task.
      */
     task_t *kernel = task_create(AS_KERNEL, "kernel");
     if (!kernel)
-        panic("Can't create kernel task\n");
+        panic("Cannot create kernel task.");
     /*
      * Create the first thread.
      */
-    thread_t *kinit_thread = thread_create(kinit, NULL, kernel, 0, "kinit",
-        true);
+    thread_t *kinit_thread
+        = thread_create(kinit, NULL, kernel, 0, "kinit", true);
     if (!kinit_thread)
-        panic("Can't create kinit thread\n");
+        panic("Cannot create kinit thread.");
     LOG_EXEC(thread_ready(kinit_thread));
     /*
 ,6 → 328,7
      * collide with another CPU coming up. To prevent this, we
      * switch to this cpu's private stack prior to waking kmp up.
      */
+    context_save(&CPU->saved_context);
     context_set(&CPU->saved_context, FADDR(main_ap_separated_stack),
         (uintptr_t) CPU->stack, CPU_STACK_SIZE);
     context_restore(&CPU->saved_context);

 /branches/network/kernel/generic/src/main/version.c
 ,21 → 34,22
 #include <main/version.h>
 #include <print.h>
+#include <macros.h>
 char *project = "SPARTAN kernel";
-char *copyright = "Copyright (c) 2001-2008 HelenOS project";
-char *release = RELEASE;
-char *name = NAME;
-char *arch = ARCH;
+char *copyright = "Copyright (c) 2001-2009 HelenOS project";
+char *release = STRING(RELEASE);
+char *name = STRING(NAME);
+char *arch = STRING(KARCH);
 #ifdef REVISION
-    char *revision = ", revision " REVISION;
+    char *revision = ", revision " STRING(REVISION);
 #else
     char *revision = "";
 #endif
 #ifdef TIMESTAMP
-    char *timestamp = " on " TIMESTAMP;
+    char *timestamp = " on " STRING(TIMESTAMP);
 #else
     char *timestamp = "";
 #endif

 /branches/network/kernel/generic/src/main/uinit.c
 ,7 → 46,9
 #include <userspace.h>
 #include <mm/slab.h>
 #include <arch.h>
+#include <udebug/udebug.h>
 /** Thread used to bring up userspace thread.
  *
  * @param arg Pointer to structure containing userspace entry and stack
 ,6 → 67,10
      * deployed for the event of forceful task termination.
      */
     thread_detach(THREAD);
+#ifdef CONFIG_UDEBUG
+    udebug_stoppable_end();
+#endif
     uarg.uspace_entry = ((uspace_arg_t *) arg)->uspace_entry;
     uarg.uspace_stack = ((uspace_arg_t *) arg)->uspace_stack;

 /branches/network/kernel/generic/src/debug/symtab.c
 ,22 → 37,23
 #include <symtab.h>
 #include <byteorder.h>
-#include <func.h>
+#include <string.h>
 #include <print.h>
 #include <arch/types.h>
 #include <typedefs.h>
+#include <errno.h>
-/** Return entry that seems most likely to correspond to argument.
+/** Get name of symbol that seems most likely to correspond to address.
  *
- * Return entry that seems most likely to correspond
- * to address passed in the argument.
+ * @param addr  Address.
+ * @param name  Place to store pointer to the symbol name.
  *
- * @param addr Address.
- *
- * @return Pointer to respective symbol string on success, NULL otherwise.
+ * @return  Zero on success or negative error code, ENOENT if not found,
+ *      ENOTSUP if symbol table not available.
  */
-char * get_symtab_entry(unative_t addr)
+int symtab_name_lookup(unative_t addr, char **name)
 {
+#ifdef CONFIG_SYMTAB
     count_t i;
     for (i = 1; symbol_table[i].address_le; ++i) {
 ,11 → 60,44
         if (addr < uint64_t_le2host(symbol_table[i].address_le))
             break;
     }
-    if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le))
-        return symbol_table[i - 1].symbol_name;
-    return NULL;
+    if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le)) {
+        *name = symbol_table[i - 1].symbol_name;
+        return EOK;
+    }
+    *name = NULL;
+    return ENOENT;
+#else
+    *name = NULL;
+    return ENOTSUP;
+#endif
 }
+/** Lookup symbol by address and format for display.
+ *
+ * Returns name of closest corresponding symbol, "Not found" if none exists
+ * or "N/A" if no symbol information is available.
+ *
+ * @param addr  Address.
+ * @param name  Place to store pointer to the symbol name.
+ *
+ * @return  Pointer to a human-readable string.
+ */
+char *symtab_fmt_name_lookup(unative_t addr)
+{
+    int rc;
+    char *name;
+    rc = symtab_name_lookup(addr, &name);
+    switch (rc) {
+    case EOK: return name;
+    case ENOENT: return "Not found";
+    default: return "N/A";
+    }
+}
+#ifdef CONFIG_SYMTAB
 /** Find symbols that match the parameter forward and print them.
  *
  * @param name - search string
 ,17 → 136,22
     return NULL;
 }
+#endif
 /** Return address that corresponds to the entry
  *
  * Search symbol table, and if there is one match, return it
  *
- * @param name Name of the symbol
- * @return 0 - Not found, -1 - Duplicate symbol, other - address of symbol
+ * @param name  Name of the symbol
+ * @param addr  Place to store symbol address
+ *
+ * @return  Zero on success, ENOENT - not found, EOVERFLOW - duplicate
+ *      symbol, ENOTSUP - no symbol information available.
  */
-uintptr_t get_symbol_addr(const char *name)
+int symtab_addr_lookup(const char *name, uintptr_t *addr)
 {
+#ifdef CONFIG_SYMTAB
     count_t found = 0;
-    uintptr_t addr = NULL;
     char *hint;
     int i;
 ,19 → 158,25
     i = 0;
     while ((hint = symtab_search_one(name, &i))) {
         if (!strlen(hint)) {
-            addr =  uint64_t_le2host(symbol_table[i].address_le);
+            *addr =  uint64_t_le2host(symbol_table[i].address_le);
             found++;
         }
         i++;
     }
     if (found > 1)
-        return ((uintptr_t) -1);
-    return addr;
+        return EOVERFLOW;
+    if (found < 1)
+        return ENOENT;
+    return EOK;
+#else
+    return ENOTSUP;
+#endif
 }
 /** Find symbols that match parameter and prints them */
 void symtab_print_search(const char *name)
 {
+#ifdef CONFIG_SYMTAB
     int i;
     uintptr_t addr;
     char *realname;
 ,6 → 189,9
         printf("%p: %s\n", addr, realname);
         i++;
     }
+#else
+    printf("No symbol information available.\n");
+#endif
 }
 /** Symtab completion
 ,6 → 201,7
  */
 int symtab_compl(char *input)
 {
+#ifdef CONFIG_SYMTAB
     char output[MAX_SYMBOL_NAME + 1];
     int startpos = 0;
     char *foundtxt;
 ,7 → 245,9
     }
     strncpy(input, output, MAX_SYMBOL_NAME);
     return found;
+#else
+    return 0;
+#endif
 }
 /** @}

 /branches/network/kernel/generic/src/cpu/cpu.c
 ,7 → 64,7
         cpus = (cpu_t *) malloc(sizeof(cpu_t) * config.cpu_count,
                     FRAME_ATOMIC);
         if (!cpus)
-            panic("malloc/cpus");
+            panic("Cannot allocate CPU structures.");
         /* initialize everything */
         memsetb(cpus, sizeof(cpu_t) * config.cpu_count, 0);
 ,7 → 86,7
     }
 #endif /* CONFIG_SMP */
-    CPU = &cpus[config.cpu_active-1];
+    CPU = &cpus[config.cpu_active - 1];
     CPU->active = 1;
     CPU->tlb_active = 1;

 /branches/network/kernel/generic/src/sysinfo/sysinfo.c
 ,7 → 163,8
             i = 0;
         }
     }
-    panic("Not reached\n");
+    panic("Not reached.");
     return NULL;
 }

 /branches/network/kernel/generic/src/interrupt/interrupt.c
 ,7 → 42,6
 #include <debug.h>
 #include <console/kconsole.h>
 #include <console/console.h>
-#include <console/chardev.h>
 #include <console/cmd.h>
 #include <panic.h>
 #include <print.h>
 ,13 → 67,13
     iroutine old;
     spinlock_lock(&exctbl_lock);
     old = exc_table[n].f;
     exc_table[n].f = f;
     exc_table[n].name = name;
-    spinlock_unlock(&exctbl_lock);
+    spinlock_unlock(&exctbl_lock);
     return old;
 }
 ,8 → 85,17
 void exc_dispatch(int n, istate_t *istate)
 {
     ASSERT(n < IVT_ITEMS);
+#ifdef CONFIG_UDEBUG
+    if (THREAD) THREAD->udebug.uspace_state = istate;
+#endif
     exc_table[n].f(n + IVT_FIRST, istate);
+#ifdef CONFIG_UDEBUG
+    if (THREAD) THREAD->udebug.uspace_state = NULL;
+#endif
     /* This is a safe place to exit exiting thread */
     if (THREAD && THREAD->interrupted && istate_from_uspace(istate))
         thread_exit();
 ,8 → 108,10
     panic("Unhandled exception %d.", n);
 }
+#ifdef CONFIG_KCONSOLE
 /** kconsole cmd - print all exceptions */
-static int exc_print_cmd(cmd_arg_t *argv)
+static int cmd_exc_print(cmd_arg_t *argv)
 {
 #if (IVT_ITEMS > 0)
     unsigned int i;
 ,9 → 130,7
 #endif
     for (i = 0; i < IVT_ITEMS; i++) {
-        symbol = get_symtab_entry((unative_t) exc_table[i].f);
-        if (!symbol)
-            symbol = "not found";
+        symbol = symtab_fmt_name_lookup((unative_t) exc_table[i].f);
 #ifdef __32_BITS__
         printf("%-3u %-20s %10p %s\n", i + IVT_FIRST, exc_table[i].name,
 ,7 → 145,7
         if (((i + 1) % 20) == 0) {
             printf(" -- Press any key to continue -- ");
             spinlock_unlock(&exctbl_lock);
-            getc(stdin);
+            _getc(stdin);
             spinlock_lock(&exctbl_lock);
             printf("\n");
         }
 ,15 → 157,18
     return 1;
 }
 static cmd_info_t exc_info = {
     .name = "exc",
     .description = "Print exception table.",
-    .func = exc_print_cmd,
+    .func = cmd_exc_print,
     .help = NULL,
     .argc = 0,
     .argv = NULL
 };
+#endif
 /** Initialize generic exception handling support */
 void exc_init(void)
 {
 ,9 → 177,11
     for (i = 0; i < IVT_ITEMS; i++)
         exc_register(i, "undef", (iroutine) exc_undef);
+#ifdef CONFIG_KCONSOLE
     cmd_initialize(&exc_info);
     if (!cmd_register(&exc_info))
-        panic("could not register command %s\n", exc_info.name);
+        printf("Cannot register command %s\n", exc_info.name);
+#endif
 }
 /** @}

 /branches/network/kernel/generic/src/time/timeout.c
 ,7 → 113,7
     spinlock_lock(&t->lock);
     if (t->cpu)
-        panic("t->cpu != 0");
+        panic("Unexpected: t->cpu != 0.");
     t->cpu = CPU;
     t->ticks = us2ticks(time);

 /branches/network/kernel/generic/src/time/clock.c
 ,7 → 79,7
     faddr = frame_alloc(ONE_FRAME, FRAME_ATOMIC);
     if (!faddr)
-        panic("Cannot allocate page for clock");
+        panic("Cannot allocate page for clock.");
     uptime = (uptime_t *) PA2KA(faddr);
 ,9 → 88,7
     uptime->useconds = 0;
     clock_parea.pbase = (uintptr_t) faddr;
-    clock_parea.vbase = (uintptr_t) uptime;
     clock_parea.frames = 1;
-    clock_parea.cacheable = true;
     ddi_parea_register(&clock_parea);
     /*
 ,7 → 187,19
         spinlock_unlock(&THREAD->lock);
         if (!ticks && !PREEMPTION_DISABLED) {
+#ifdef CONFIG_UDEBUG
+            istate_t *istate;
+#endif
             scheduler();
+#ifdef CONFIG_UDEBUG
+            /*
+             * Give udebug chance to stop the thread
+             * before it begins executing userspace code.
+             */
+            istate = THREAD->udebug.uspace_state;
+            if (istate && istate_from_uspace(istate))
+                udebug_before_thread_runs();
+#endif
         }
     }

 /branches/network/kernel/generic/src/ddi/device.c
 ,7 → 31,7
  */
 /**
  * @file
- * @brief   Device numbers.
+ * @brief Device numbers.
  */
 #include <arch/types.h>
 ,13 → 47,16
  */
 devno_t device_assign_devno(void)
 {
-    devno_t devno;
-    devno = (devno_t) atomic_postinc(&last);
+    devno_t devno = (devno_t) atomic_postinc(&last);
     ASSERT(devno >= 0);
     return devno;
 }
+unative_t sys_device_assign_devno(void)
+{
+    return (unative_t) device_assign_devno();
+}
 /** @}
  */

 /branches/network/kernel/generic/src/ddi/ddi.c
 ,10 → 29,10
 /** @addtogroup genericddi
  * @{
  */
 /**
  * @file
- * @brief   Device Driver Interface functions.
+ * @brief Device Driver Interface functions.
  *
  * This file contains functions that comprise the Device Driver Interface.
  * These are the functions for mapping physical memory and enabling I/O
 ,82 → 68,100
  *
  * @param parea Pointer to physical area structure.
  *
- * @todo This function doesn't check for overlaps. It depends on the kernel to
- * create disjunct physical memory areas.
  */
 void ddi_parea_register(parea_t *parea)
 {
-    ipl_t ipl;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&parea_lock);
     /*
-     * TODO: we should really check for overlaps here.
-     * However, we should be safe because the kernel is pretty sane and
-     * memory of different devices doesn't overlap.
+     * We don't check for overlaps here as the kernel is pretty sane.
      */
     btree_insert(&parea_btree, (btree_key_t) parea->pbase, parea, NULL);
     spinlock_unlock(&parea_lock);
-    interrupts_restore(ipl);
+    interrupts_restore(ipl);
 }
 /** Map piece of physical memory into virtual address space of current task.
  *
- * @param pf Physical address of the starting frame.
- * @param vp Virtual address of the starting page.
+ * @param pf    Physical address of the starting frame.
+ * @param vp    Virtual address of the starting page.
  * @param pages Number of pages to map.
  * @param flags Address space area flags for the mapping.
  *
  * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *  syscall, ENOENT if there is no task matching the specified ID or the
- *  physical address space is not enabled for mapping and ENOMEM if there
- *  was a problem in creating address space area.
+ *         syscall, EBADMEM if pf or vf is not page aligned, ENOENT if there
+ *         is no task matching the specified ID or the physical address space
+ *         is not enabled for mapping and ENOMEM if there was a problem in
+ *         creating address space area.
+ *
  */
 static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
 {
-    ipl_t ipl;
-    cap_t caps;
-    mem_backend_data_t backend_data;
-    backend_data.base = pf;
-    backend_data.frames = pages;
+    ASSERT(TASK);
+    ASSERT((pf % FRAME_SIZE) == 0);
+    ASSERT((vp % PAGE_SIZE) == 0);
     /*
      * Make sure the caller is authorised to make this syscall.
      */
-    caps = cap_get(TASK);
+    cap_t caps = cap_get(TASK);
     if (!(caps & CAP_MEM_MANAGER))
         return EPERM;
-    ipl = interrupts_disable();
-    /*
-     * Check if the physical memory area is enabled for mapping.
-     * If the architecture supports virtually indexed caches, intercept
-     * attempts to create an illegal address alias.
-     */
-    spinlock_lock(&parea_lock);
-    parea_t *parea;
-    btree_node_t *nodep;
-    parea = (parea_t *) btree_search(&parea_btree, (btree_key_t) pf, &nodep);
-    if (!parea || parea->frames < pages || ((flags & AS_AREA_CACHEABLE) &&
-        !parea->cacheable) || (!(flags & AS_AREA_CACHEABLE) &&
-        parea->cacheable)) {
-        /*
-         * This physical memory area cannot be mapped.
+    mem_backend_data_t backend_data;
+    backend_data.base = pf;
+    backend_data.frames = pages;
+    ipl_t ipl = interrupts_disable();
+    /* Find the zone of the physical memory */
+    spinlock_lock(&zones.lock);
+    count_t znum = find_zone(ADDR2PFN(pf), pages, 0);
+    if (znum == (count_t) -1) {
+        /* Frames not found in any zones
+         * -> assume it is hardware device and allow mapping
          */
+        spinlock_unlock(&zones.lock);
+        goto map;
+    }
+    if (zones.info[znum].flags & ZONE_FIRMWARE) {
+        /* Frames are part of firmware */
+        spinlock_unlock(&zones.lock);
+        goto map;
+    }
+    if (zone_flags_available(zones.info[znum].flags)) {
+        /* Frames are part of physical memory, check if the memory
+         * region is enabled for mapping.
+         */
+        spinlock_unlock(&zones.lock);
+        spinlock_lock(&parea_lock);
+        btree_node_t *nodep;
+        parea_t *parea = (parea_t *) btree_search(&parea_btree,
+            (btree_key_t) pf, &nodep);
+        if ((!parea) || (parea->frames < pages))
+            goto err;
         spinlock_unlock(&parea_lock);
-        interrupts_restore(ipl);
-        return ENOENT;
+        goto map;
     }
-    spinlock_unlock(&parea_lock);
+err:
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
+    return ENOENT;
+map:
     spinlock_lock(&TASK->lock);
-    if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp, AS_AREA_ATTR_NONE,
-        &phys_backend, &backend_data)) {
+    if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp,
+        AS_AREA_ATTR_NONE, &phys_backend, &backend_data)) {
         /*
          * The address space area could not have been created.
          * We report it using ENOMEM.
 ,28 → 187,24
  * @param size Size of the enabled I/O space..
  *
  * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *  syscall, ENOENT if there is no task matching the specified ID.
+ *           syscall, ENOENT if there is no task matching the specified ID.
+ *
  */
 static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
-    ipl_t ipl;
-    cap_t caps;
-    task_t *t;
-    int rc;
     /*
      * Make sure the caller is authorised to make this syscall.
      */
-    caps = cap_get(TASK);
+    cap_t caps = cap_get(TASK);
     if (!(caps & CAP_IO_MANAGER))
         return EPERM;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&tasks_lock);
-    t = task_find_by_id(id);
+    task_t *task = task_find_by_id(id);
-    if ((!t) || (!context_check(CONTEXT, t->context))) {
+    if ((!task) || (!context_check(CONTEXT, task->context))) {
         /*
          * There is no task with the specified ID
          * or the task belongs to a different security
 ,15 → 214,16
         interrupts_restore(ipl);
         return ENOENT;
     }
     /* Lock the task and release the lock protecting tasks_btree. */
-    spinlock_lock(&t->lock);
+    spinlock_lock(&task->lock);
     spinlock_unlock(&tasks_lock);
-    rc = ddi_iospace_enable_arch(t, ioaddr, size);
-    spinlock_unlock(&t->lock);
+    int rc = ddi_iospace_enable_arch(task, ioaddr, size);
+    spinlock_unlock(&task->lock);
     interrupts_restore(ipl);
     return rc;
 }
 ,7 → 235,8
  * @param flags Flags of newly mapped pages
  *
  * @return 0 on success, otherwise it returns error code found in errno.h
- */
+ *
+ */
 unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base,
     unative_t pages, unative_t flags)
 {
 ,16 → 250,15
  * @param uspace_io_arg User space address of DDI argument structure.
  *
  * @return 0 on success, otherwise it returns error code found in errno.h
- */
+ *
+ */
 unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
 {
     ddi_ioarg_t arg;
-    int rc;
-    rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
+    int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
     if (rc != 0)
         return (unative_t) rc;
     return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id,
         (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 ,20 → 266,24
 /** Disable or enable preemption.
  *
  * @param enable If non-zero, the preemption counter will be decremented,
- *  leading to potential enabling of preemption. Otherwise the preemption
- *  counter will be incremented, preventing preemption from occurring.
+ *               leading to potential enabling of preemption. Otherwise
+ *               the preemption counter will be incremented, preventing
+ *               preemption from occurring.
  *
  * @return Zero on success or EPERM if callers capabilities are not sufficient.
- */
+ *
+ */
 unative_t sys_preempt_control(int enable)
 {
-        if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
-                return EPERM;
-        if (enable)
-                preemption_enable();
-        else
-                preemption_disable();
-        return 0;
+    if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
+        return EPERM;
+    if (enable)
+        preemption_enable();
+    else
+        preemption_disable();
+    return 0;
 }
 /** @}

 /branches/network/kernel/generic/src/ddi/irq.c
 ,7 → 39,8
  *
  * This code is designed to support:
  * - multiple devices sharing single IRQ
- * - multiple IRQs per signle device
+ * - multiple IRQs per single device
+ * - multiple instances of the same device
  *
  *
  * Note about architectures.
 ,8 → 69,11
 #include <ddi/irq.h>
 #include <adt/hash_table.h>
+#include <mm/slab.h>
 #include <arch/types.h>
 #include <synch/spinlock.h>
+#include <console/console.h>
+#include <memstr.h>
 #include <arch.h>
 #define KEY_INR     0
 ,13 → 80,22
 #define KEY_DEVNO   1
 /**
- * Spinlock protecting the hash table.
+ * Spinlock protecting the kernel IRQ hash table.
  * This lock must be taken only when interrupts are disabled.
  */
-SPINLOCK_INITIALIZE(irq_hash_table_lock);
-static hash_table_t irq_hash_table;
+SPINLOCK_INITIALIZE(irq_kernel_hash_table_lock);
+/** The kernel IRQ hash table. */
+static hash_table_t irq_kernel_hash_table;
 /**
+ * Spinlock protecting the uspace IRQ hash table.
+ * This lock must be taken only when interrupts are disabled.
+ */
+SPINLOCK_INITIALIZE(irq_uspace_hash_table_lock);
+/** The uspace IRQ hash table. */
+hash_table_t irq_uspace_hash_table;
+/**
  * Hash table operations for cases when we know that
  * there will be collisions between different keys.
  */
 ,6 → 123,9
     .remove_callback = NULL     /* not used */
 };
+/** Number of buckets in either of the hash tables. */
+static count_t buckets;
 /** Initialize IRQ subsystem.
  *
  * @param inrs Numbers of unique IRQ numbers or INRs.
 ,6 → 133,7
  */
 void irq_init(count_t inrs, count_t chains)
 {
+    buckets = chains;
     /*
      * Be smart about the choice of the hash table operations.
      * In cases in which inrs equals the requested number of
 ,10 → 140,17
      * chains (i.e. where there is no collision between
      * different keys), we can use optimized set of operations.
      */
-    if (inrs == chains)
-        hash_table_create(&irq_hash_table, chains, 2, &irq_lin_ops);
-    else
-        hash_table_create(&irq_hash_table, chains, 2, &irq_ht_ops);
+    if (inrs == chains) {
+        hash_table_create(&irq_uspace_hash_table, chains, 2,
+            &irq_lin_ops);
+        hash_table_create(&irq_kernel_hash_table, chains, 2,
+            &irq_lin_ops);
+    } else {
+        hash_table_create(&irq_uspace_hash_table, chains, 2,
+            &irq_ht_ops);
+        hash_table_create(&irq_kernel_hash_table, chains, 2,
+            &irq_ht_ops);
+    }
 }
 /** Initialize one IRQ structure.
 ,21 → 160,12
  */
 void irq_initialize(irq_t *irq)
 {
+    memsetb(irq, sizeof(irq_t), 0);
     link_initialize(&irq->link);
     spinlock_initialize(&irq->lock, "irq.lock");
-    irq->preack = false;
+    link_initialize(&irq->notif_cfg.link);
     irq->inr = -1;
     irq->devno = -1;
-    irq->trigger = (irq_trigger_t) 0;
-    irq->claim = NULL;
-    irq->handler = NULL;
-    irq->arg = NULL;
-    irq->notif_cfg.notify = false;
-    irq->notif_cfg.answerbox = NULL;
-    irq->notif_cfg.code = NULL;
-    irq->notif_cfg.method = 0;
-    irq->notif_cfg.counter = 0;
-    link_initialize(&irq->notif_cfg.link);
 }
 /** Register IRQ for device.
 ,9 → 172,10
  *
  * The irq structure must be filled with information
  * about the interrupt source and with the claim()
- * function pointer and irq_handler() function pointer.
+ * function pointer and handler() function pointer.
  *
- * @param irq IRQ structure belonging to a device.
+ * @param irq       IRQ structure belonging to a device.
+ * @return      True on success, false on failure.
  */
 void irq_register(irq_t *irq)
 {
 ,88 → 186,101
     };
     ipl = interrupts_disable();
-    spinlock_lock(&irq_hash_table_lock);
-    hash_table_insert(&irq_hash_table, key, &irq->link);
-    spinlock_unlock(&irq_hash_table_lock);
+    spinlock_lock(&irq_kernel_hash_table_lock);
+    spinlock_lock(&irq->lock);
+    hash_table_insert(&irq_kernel_hash_table, key, &irq->link);
+    spinlock_unlock(&irq->lock);
+    spinlock_unlock(&irq_kernel_hash_table_lock);
     interrupts_restore(ipl);
 }
-/** Dispatch the IRQ.
+/** Search and lock the uspace IRQ hash table.
  *
- * We assume this function is only called from interrupt
- * context (i.e. that interrupts are disabled prior to
- * this call).
- *
- * This function attempts to lookup a fitting IRQ
- * structure. In case of success, return with interrupts
- * disabled and holding the respective structure.
- *
- * @param inr Interrupt number (aka inr or irq).
- *
- * @return IRQ structure of the respective device or NULL.
  */
-irq_t *irq_dispatch_and_lock(inr_t inr)
+static irq_t *irq_dispatch_and_lock_uspace(inr_t inr)
 {
     link_t *lnk;
     unative_t key[] = {
         (unative_t) inr,
-        (unative_t) -1      /* search will use claim() instead of devno */
+        (unative_t) -1    /* search will use claim() instead of devno */
     };
-    spinlock_lock(&irq_hash_table_lock);
-    lnk = hash_table_find(&irq_hash_table, key);
+    spinlock_lock(&irq_uspace_hash_table_lock);
+    lnk = hash_table_find(&irq_uspace_hash_table, key);
     if (lnk) {
         irq_t *irq;
         irq = hash_table_get_instance(lnk, irq_t, link);
-        spinlock_unlock(&irq_hash_table_lock);
+        spinlock_unlock(&irq_uspace_hash_table_lock);
         return irq;
     }
+    spinlock_unlock(&irq_uspace_hash_table_lock);
-    spinlock_unlock(&irq_hash_table_lock);
-    return NULL;
+    return NULL;
 }
-/** Find the IRQ structure corresponding to inr and devno.
+/** Search and lock the kernel IRQ hash table.
  *
- * This functions attempts to lookup the IRQ structure
- * corresponding to its arguments. On success, this
- * function returns with interrups disabled, holding
- * the lock of the respective IRQ structure.
- *
- * This function assumes interrupts are already disabled.
- *
- * @param inr INR being looked up.
- * @param devno Devno being looked up.
- *
- * @return Locked IRQ structure on success or NULL on failure.
  */
-irq_t *irq_find_and_lock(inr_t inr, devno_t devno)
+static irq_t *irq_dispatch_and_lock_kernel(inr_t inr)
 {
     link_t *lnk;
-    unative_t keys[] = {
+    unative_t key[] = {
         (unative_t) inr,
-        (unative_t) devno
+        (unative_t) -1    /* search will use claim() instead of devno */
     };
-    spinlock_lock(&irq_hash_table_lock);
-    lnk = hash_table_find(&irq_hash_table, keys);
+    spinlock_lock(&irq_kernel_hash_table_lock);
+    lnk = hash_table_find(&irq_kernel_hash_table, key);
     if (lnk) {
         irq_t *irq;
         irq = hash_table_get_instance(lnk, irq_t, link);
-        spinlock_unlock(&irq_hash_table_lock);
+        spinlock_unlock(&irq_kernel_hash_table_lock);
         return irq;
     }
+    spinlock_unlock(&irq_kernel_hash_table_lock);
-    spinlock_unlock(&irq_hash_table_lock);
+    return NULL;
+}
-    return NULL;
+/** Dispatch the IRQ.
+ *
+ * We assume this function is only called from interrupt
+ * context (i.e. that interrupts are disabled prior to
+ * this call).
+ *
+ * This function attempts to lookup a fitting IRQ
+ * structure. In case of success, return with interrupts
+ * disabled and holding the respective structure.
+ *
+ * @param inr Interrupt number (aka inr or irq).
+ *
+ * @return IRQ structure of the respective device or NULL.
+ */
+irq_t *irq_dispatch_and_lock(inr_t inr)
+{
+    irq_t *irq;
+    /*
+     * If the kernel console is silenced,
+     * then try first the uspace handlers,
+     * eventually fall back to kernel handlers.
+     *
+     * If the kernel console is active,
+     * then do it the other way around.
+     */
+    if (silent) {
+        irq = irq_dispatch_and_lock_uspace(inr);
+        if (irq)
+            return irq;
+        return irq_dispatch_and_lock_kernel(inr);
+    }
+    irq = irq_dispatch_and_lock_kernel(inr);
+    if (irq)
+        return irq;
+    return irq_dispatch_and_lock_uspace(inr);
 }
 /** Compute hash index for the key.
 ,7 → 299,7
 index_t irq_ht_hash(unative_t key[])
 {
     inr_t inr = (inr_t) key[KEY_INR];
-    return inr % irq_hash_table.entries;
+    return inr % buckets;
 }
 /** Compare hash table element with a key.
 ,7 → 333,8
     spinlock_lock(&irq->lock);
     if (devno == -1) {
         /* Invoked by irq_dispatch_and_lock(). */
-        rv = ((irq->inr == inr) && (irq->claim() == IRQ_ACCEPT));
+        rv = ((irq->inr == inr) &&
+            (irq->claim(irq) == IRQ_ACCEPT));
     } else {
         /* Invoked by irq_find_and_lock(). */
         rv = ((irq->inr == inr) && (irq->devno == devno));
 ,7 → 393,7
     spinlock_lock(&irq->lock);
     if (devno == -1) {
         /* Invoked by irq_dispatch_and_lock() */
-        rv = (irq->claim() == IRQ_ACCEPT);
+        rv = (irq->claim(irq) == IRQ_ACCEPT);
     } else {
         /* Invoked by irq_find_and_lock() */
         rv = (irq->devno == devno);

 /branches/network/kernel/generic/src/printf/vprintf.c
 ,13 → 62,13
 {
     struct printf_spec ps = {(int(*)(void *, size_t, void *)) vprintf_write, NULL};
-    int irqpri = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&printf_lock);
     int ret = printf_core(fmt, &ps, ap);
     spinlock_unlock(&printf_lock);
-    interrupts_restore(irqpri);
+    interrupts_restore(ipl);
     return ret;
 }

 /branches/network/kernel/generic/src/printf/printf_core.c
 ,7 → 40,7
 #include <print.h>
 #include <arch/arg.h>
 #include <macros.h>
-#include <func.h>
+#include <string.h>
 #include <arch.h>
 /** show prefixes 0x or 0 */

 /branches/network/kernel/generic/src/console/console.c
 ,7 → 39,6
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
 #include <arch/types.h>
-#include <ddi/device.h>
 #include <ddi/irq.h>
 #include <ddi/ddi.h>
 #include <ipc/irq.h>
 ,71 → 46,45
 #include <func.h>
 #include <print.h>
 #include <atomic.h>
+#include <syscall/copy.h>
+#include <errno.h>
 #define KLOG_SIZE PAGE_SIZE
 #define KLOG_LATENCY 8
-/**< Kernel log cyclic buffer */
+/** Kernel log cyclic buffer */
 static char klog[KLOG_SIZE] __attribute__ ((aligned (PAGE_SIZE)));
-/**< Kernel log initialized */
+/** Kernel log initialized */
 static bool klog_inited = false;
-/**< First kernel log characters */
+/** First kernel log characters */
 static index_t klog_start = 0;
-/**< Number of valid kernel log characters */
+/** Number of valid kernel log characters */
 static size_t klog_len = 0;
-/**< Number of stored (not printed) kernel log characters */
+/** Number of stored (not printed) kernel log characters */
 static size_t klog_stored = 0;
-/**< Number of stored kernel log characters for uspace */
+/** Number of stored kernel log characters for uspace */
 static size_t klog_uspace = 0;
-/**< Kernel log spinlock */
+/** Silence output */
+bool silent = false;
+/** Kernel log spinlock */
 SPINLOCK_INITIALIZE(klog_lock);
 /** Physical memory area used for klog buffer */
 static parea_t klog_parea;
-/*
- * For now, we use 0 as INR.
- * However, it is therefore desirable to have architecture specific
- * definition of KLOG_VIRT_INR in the future.
- */
-#define KLOG_VIRT_INR   0
-static irq_t klog_irq;
+/** Standard input and output character devices */
+indev_t *stdin = NULL;
+outdev_t *stdout = NULL;
-static chardev_operations_t null_stdout_ops = {
-    .suspend = NULL,
-    .resume = NULL,
-    .write = NULL,
-    .read = NULL
-};
-chardev_t null_stdout = {
-    .name = "null",
-    .op = &null_stdout_ops
-};
-/** Allways refuse IRQ ownership.
- *
- * This is not a real IRQ, so we always decline.
- *
- * @return Always returns IRQ_DECLINE.
- */
-static irq_ownership_t klog_claim(void)
-{
-    return IRQ_DECLINE;
-}
-/** Standard input character device */
-chardev_t *stdin = NULL;
-chardev_t *stdout = &null_stdout;
 /** Initialize kernel logging facility
  *
  * The shared area contains kernel cyclic buffer. Userspace application may
  * be notified on new data with indication of position and size
  * of the data within the circular buffer.
+ *
  */
 void klog_init(void)
 {
 ,89 → 92,122
     ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
     ASSERT(KLOG_SIZE % FRAME_SIZE == 0);
-    devno_t devno = device_assign_devno();
     klog_parea.pbase = (uintptr_t) faddr;
-    klog_parea.vbase = (uintptr_t) klog;
     klog_parea.frames = SIZE2FRAMES(KLOG_SIZE);
-    klog_parea.cacheable = true;
     ddi_parea_register(&klog_parea);
     sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
     sysinfo_set_item_val("klog.pages", NULL, SIZE2FRAMES(KLOG_SIZE));
-    sysinfo_set_item_val("klog.devno", NULL, devno);
-    sysinfo_set_item_val("klog.inr", NULL, KLOG_VIRT_INR);
-    irq_initialize(&klog_irq);
-    klog_irq.devno = devno;
-    klog_irq.inr = KLOG_VIRT_INR;
-    klog_irq.claim = klog_claim;
-    irq_register(&klog_irq);
+    //irq_initialize(&klog_irq);
+    //klog_irq.devno = devno;
+    //klog_irq.inr = KLOG_VIRT_INR;
+    //klog_irq.claim = klog_claim;
+    //irq_register(&klog_irq);
     spinlock_lock(&klog_lock);
     klog_inited = true;
     spinlock_unlock(&klog_lock);
 }
-/** Get character from character device. Do not echo character.
+void grab_console(void)
+{
+    silent = false;
+    arch_grab_console();
+}
+void release_console(void)
+{
+    silent = true;
+    arch_release_console();
+}
+/** Tell kernel to get keyboard/console access again */
+unative_t sys_debug_enable_console(void)
+{
+#ifdef CONFIG_KCONSOLE
+    grab_console();
+    return true;
+#else
+    return false;
+#endif
+}
+/** Tell kernel to relinquish keyboard/console access */
+unative_t sys_debug_disable_console(void)
+{
+    release_console();
+    return true;
+}
+bool check_poll(indev_t *indev)
+{
+    if (indev == NULL)
+        return false;
+    if (indev->op == NULL)
+        return false;
+    return (indev->op->poll != NULL);
+}
+/** Get character from input character device. Do not echo character.
  *
- * @param chardev Character device.
+ * @param indev Input character device.
+ * @return Character read.
  *
- * @return Character read.
  */
-uint8_t _getc(chardev_t *chardev)
+uint8_t _getc(indev_t *indev)
 {
-    uint8_t ch;
-    ipl_t ipl;
     if (atomic_get(&haltstate)) {
-        /* If we are here, we are hopefully on the processor, that
+        /* If we are here, we are hopefully on the processor that
          * issued the 'halt' command, so proceed to read the character
          * directly from input
          */
-        if (chardev->op->read)
-            return chardev->op->read(chardev);
-        /* no other way of interacting with user, halt */
+        if (check_poll(indev))
+            return indev->op->poll(indev);
+        /* No other way of interacting with user */
+        interrupts_disable();
         if (CPU)
             printf("cpu%u: ", CPU->id);
         else
             printf("cpu: ");
-        printf("halted - no kconsole\n");
+        printf("halted (no polling input)\n");
         cpu_halt();
     }
-    waitq_sleep(&chardev->wq);
-    ipl = interrupts_disable();
-    spinlock_lock(&chardev->lock);
-    ch = chardev->buffer[(chardev->index - chardev->counter) % CHARDEV_BUFLEN];
-    chardev->counter--;
-    spinlock_unlock(&chardev->lock);
+    waitq_sleep(&indev->wq);
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&indev->lock);
+    uint8_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
+    indev->counter--;
+    spinlock_unlock(&indev->lock);
     interrupts_restore(ipl);
-    chardev->op->resume(chardev);
     return ch;
 }
-/** Get string from character device.
+/** Get string from input character device.
  *
- * Read characters from character device until first occurrence
+ * Read characters from input character device until first occurrence
  * of newline character.
  *
- * @param chardev Character device.
- * @param buf Buffer where to store string terminated by '\0'.
+ * @param indev  Input character device.
+ * @param buf    Buffer where to store string terminated by '\0'.
  * @param buflen Size of the buffer.
  *
  * @return Number of characters read.
+ *
  */
-count_t gets(chardev_t *chardev, char *buf, size_t buflen)
+count_t gets(indev_t *indev, char *buf, size_t buflen)
 {
     index_t index = 0;
-    char ch;
     while (index < buflen) {
-        ch = _getc(chardev);
+        char ch = _getc(indev);
         if (ch == '\b') {
             if (index > 0) {
                 index--;
 ,7 → 219,7
             continue;
         }
         putchar(ch);
         if (ch == '\n') { /* end of string => write 0, return */
             buf[index] = '\0';
             return (count_t) index;
 ,15 → 226,14
         }
         buf[index++] = ch;
     }
     return (count_t) index;
 }
-/** Get character from device & echo it to screen */
-uint8_t getc(chardev_t *chardev)
+/** Get character from input device & echo it to screen */
+uint8_t getc(indev_t *indev)
 {
-    uint8_t ch;
-    ch = _getc(chardev);
+    uint8_t ch = _getc(indev);
     putchar(ch);
     return ch;
 }
 ,10 → 242,10
 {
     spinlock_lock(&klog_lock);
-    if ((klog_inited) && (klog_irq.notif_cfg.notify) && (klog_uspace > 0)) {
-        ipc_irq_send_msg_3(&klog_irq, klog_start, klog_len, klog_uspace);
-        klog_uspace = 0;
-    }
+//  if ((klog_inited) && (klog_irq.notif_cfg.notify) && (klog_uspace > 0)) {
+//      ipc_irq_send_msg_3(&klog_irq, klog_start, klog_len, klog_uspace);
+//      klog_uspace = 0;
+//  }
     spinlock_unlock(&klog_lock);
 }
 ,11 → 254,11
 {
     spinlock_lock(&klog_lock);
-    if ((klog_stored > 0) && (stdout->op->write)) {
+    if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
         /* Print charaters stored in kernel log */
         index_t i;
         for (i = klog_len - klog_stored; i < klog_len; i++)
-            stdout->op->write(stdout, klog[(klog_start + i) % KLOG_SIZE]);
+            stdout->op->write(stdout, klog[(klog_start + i) % KLOG_SIZE], silent);
         klog_stored = 0;
     }
 ,8 → 269,8
     else
         klog_start = (klog_start + 1) % KLOG_SIZE;
-    if (stdout->op->write)
-        stdout->op->write(stdout, c);
+    if ((stdout) && (stdout->op->write))
+        stdout->op->write(stdout, c, silent);
     else {
         /* The character is just in the kernel log */
         if (klog_stored < klog_len)
 ,5 → 294,38
         klog_update();
 }
+/** Print using kernel facility
+ *
+ * Print to kernel log.
+ *
+ */
+unative_t sys_klog(int fd, const void * buf, size_t count)
+{
+    char *data;
+    int rc;
+    if (count > PAGE_SIZE)
+        return ELIMIT;
+    if (count > 0) {
+        data = (char *) malloc(count + 1, 0);
+        if (!data)
+            return ENOMEM;
+        rc = copy_from_uspace(data, buf, count);
+        if (rc) {
+            free(data);
+            return rc;
+        }
+        data[count] = 0;
+        printf("%s", data);
+        free(data);
+    } else
+        klog_update();
+    return count;
+}
 /** @}
  */

 /branches/network/kernel/generic/src/console/cmd.c
 ,9 → 50,9
 #include <arch.h>
 #include <config.h>
 #include <func.h>
+#include <string.h>
 #include <macros.h>
 #include <debug.h>
-#include <symtab.h>
 #include <cpu.h>
 #include <mm/tlb.h>
 #include <arch/mm/tlb.h>
 ,6 → 64,8
 #include <proc/task.h>
 #include <ipc/ipc.h>
 #include <ipc/irq.h>
+#include <symtab.h>
+#include <errno.h>
 #ifdef CONFIG_TEST
 #include <test.h>
 ,12 → 80,6
     .argc = 0
 };
-static cmd_info_t exit_info = {
-    .name = "exit",
-    .description = "Exit kconsole.",
-    .argc = 0
-};
 static int cmd_reboot(cmd_arg_t *argv);
 static cmd_info_t reboot_info = {
     .name = "reboot",
 ,17 → 394,17
     .argc = 0
 };
-/* Data and methods for 'ipc_task' command */
-static int cmd_ipc_task(cmd_arg_t *argv);
-static cmd_arg_t ipc_task_argv = {
+/* Data and methods for 'ipc' command */
+static int cmd_ipc(cmd_arg_t *argv);
+static cmd_arg_t ipc_argv = {
     .type = ARG_TYPE_INT,
 };
-static cmd_info_t ipc_task_info = {
-    .name = "ipc_task",
-    .description = "ipc_task <taskid> Show IPC information of given task.",
-    .func = cmd_ipc_task,
+static cmd_info_t ipc_info = {
+    .name = "ipc",
+    .description = "ipc <taskid> Show IPC information of given task.",
+    .func = cmd_ipc,
     .argc = 1,
-    .argv = &ipc_task_argv
+    .argv = &ipc_argv
 };
 /* Data and methods for 'zone' command */
 ,12 → 452,11
     &continue_info,
     &cpus_info,
     &desc_info,
-    &exit_info,
     &reboot_info,
     &uptime_info,
     &halt_info,
     &help_info,
-    &ipc_task_info,
+    &ipc_info,
     &set4_info,
     &slabs_info,
     &symaddr_info,
 ,7 → 496,7
     for (i = 0; basic_commands[i]; i++) {
         cmd_initialize(basic_commands[i]);
         if (!cmd_register(basic_commands[i]))
-            panic("could not register command %s\n", basic_commands[i]->name);
+            printf("Cannot register command %s\n", basic_commands[i]->name);
     }
 }
 ,23 → 509,31
  */
 int cmd_help(cmd_arg_t *argv)
 {
-    link_t *cur;
     spinlock_lock(&cmd_lock);
+    link_t *cur;
+    size_t len = 0;
     for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
         cmd_info_t *hlp;
+        hlp = list_get_instance(cur, cmd_info_t, link);
+        spinlock_lock(&hlp->lock);
+        if (strlen(hlp->name) > len)
+            len = strlen(hlp->name);
+        spinlock_unlock(&hlp->lock);
+    }
+    for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
+        cmd_info_t *hlp;
         hlp = list_get_instance(cur, cmd_info_t, link);
         spinlock_lock(&hlp->lock);
-        printf("%s - %s\n", hlp->name, hlp->description);
+        printf("%-*s %s\n", len, hlp->name, hlp->description);
         spinlock_unlock(&hlp->lock);
     }
-    spinlock_unlock(&cmd_lock);
+    spinlock_unlock(&cmd_lock);
     return 1;
 }
 ,33 → 619,26
 {
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(void);
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
-    } fptr;
-#endif
+    unative_t (*fnc)(void);
+    fncptr_t fptr;
+    int rc;
-    symaddr = get_symbol_addr((char *) argv->buffer);
-    if (!symaddr)
-        printf("Symbol %s not found.\n", argv->buffer);
-    else if (symaddr == (uintptr_t) -1) {
-        symtab_print_search((char *) argv->buffer);
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
+    if (rc == ENOENT)
+        printf("Symbol %s not found.\n", symbol);
+    else if (rc == EOVERFLOW) {
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
+    } else if (rc == EOK) {
+        fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
+            (void *) symaddr, (void *) cmd_call0);
+        printf("Calling %s() (%p)\n", symbol, symaddr);
+        printf("Result: %#" PRIxn "\n", fnc());
     } else {
-        symbol = get_symtab_entry(symaddr);
-        printf("Calling %s() (%p)\n", symbol, symaddr);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
-        f =  (unative_t (*)(void)) &fptr;
-#else
-        f =  (unative_t (*)(void)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f());
+        printf("No symbol information available.\n");
     }
     return 1;
 }
 ,35 → 676,27
 {
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(unative_t,...);
+    unative_t (*fnc)(unative_t, ...);
     unative_t arg1 = argv[1].intval;
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
-    } fptr;
-#endif
+    fncptr_t fptr;
+    int rc;
-    symaddr = get_symbol_addr((char *) argv->buffer);
-    if (!symaddr)
-        printf("Symbol %s not found.\n", argv->buffer);
-    else if (symaddr == (uintptr_t) -1) {
-        symtab_print_search((char *) argv->buffer);
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
+    if (rc == ENOENT) {
+        printf("Symbol %s not found.\n", symbol);
+    } else if (rc == EOVERFLOW) {
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
+    } else if (rc == EOK) {
+        fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
+        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
+        printf("Result: %#" PRIxn "\n", fnc(arg1));
     } else {
-        symbol = get_symtab_entry(symaddr);
+        printf("No symbol information available.\n");
+    }
-        printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
-        f =  (unative_t (*)(unative_t,...)) &fptr;
-#else
-        f =  (unative_t (*)(unative_t,...)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f(arg1));
-    }
     return 1;
 }
 ,36 → 705,28
 {
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(unative_t,unative_t,...);
+    unative_t (*fnc)(unative_t, unative_t, ...);
     unative_t arg1 = argv[1].intval;
     unative_t arg2 = argv[2].intval;
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
-    }fptr;
-#endif
+    fncptr_t fptr;
+    int rc;
-    symaddr = get_symbol_addr((char *) argv->buffer);
-    if (!symaddr)
-        printf("Symbol %s not found.\n", argv->buffer);
-    else if (symaddr == (uintptr_t) -1) {
-        symtab_print_search((char *) argv->buffer);
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
+    if (rc == ENOENT) {
+        printf("Symbol %s not found.\n", symbol);
+    } else if (rc == EOVERFLOW) {
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
-        symbol = get_symtab_entry(symaddr);
+    } else if (rc == EOK) {
+        fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
         printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
                arg1, arg2, symaddr, symbol);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
-        f =  (unative_t (*)(unative_t,unative_t,...)) &fptr;
-#else
-        f =  (unative_t (*)(unative_t,unative_t,...)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f(arg1, arg2));
+        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
+    } else {
+        printf("No symbol information available.\n");
     }
     return 1;
 }
 ,37 → 735,29
 {
     uintptr_t symaddr;
     char *symbol;
-    unative_t (*f)(unative_t,unative_t,unative_t,...);
+    unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
     unative_t arg1 = argv[1].intval;
     unative_t arg2 = argv[2].intval;
     unative_t arg3 = argv[3].intval;
-#ifdef ia64
-    struct {
-        unative_t f;
-        unative_t gp;
-    }fptr;
-#endif
+    fncptr_t fptr;
+    int rc;
+    symbol = (char *) argv->buffer;
+    rc = symtab_addr_lookup(symbol, &symaddr);
-    symaddr = get_symbol_addr((char *) argv->buffer);
-    if (!symaddr)
-        printf("Symbol %s not found.\n", argv->buffer);
-    else if (symaddr == (uintptr_t) -1) {
-        symtab_print_search((char *) argv->buffer);
+    if (rc == ENOENT) {
+        printf("Symbol %s not found.\n", symbol);
+    } else if (rc == EOVERFLOW) {
+        symtab_print_search(symbol);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
-        symbol = get_symtab_entry(symaddr);
+    } else if (rc == EOK) {
+        fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
         printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
                arg1, arg2, arg3, symaddr, symbol);
-#ifdef ia64
-        fptr.f = symaddr;
-        fptr.gp = ((unative_t *)cmd_call2)[1];
-        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
-#else
-        f =  (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
-#endif
-        printf("Result: %#" PRIxn "\n", f(arg1, arg2, arg3));
+        printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
+    } else {
+        printf("No symbol information available.\n");
     }
     return 1;
 }
 ,30 → 807,34
 /** Write 4 byte value to address */
 int cmd_set4(cmd_arg_t *argv)
 {
-    uint32_t *addr;
+    uintptr_t addr;
     uint32_t arg1 = argv[1].intval;
     bool pointer = false;
+    int rc;
     if (((char *)argv->buffer)[0] == '*') {
-        addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
+        rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
         pointer = true;
     } else if (((char *) argv->buffer)[0] >= '0' &&
-           ((char *)argv->buffer)[0] <= '9')
-        addr = (uint32_t *)atoi((char *)argv->buffer);
-    else
-        addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
+           ((char *)argv->buffer)[0] <= '9') {
+        rc = EOK;
+        addr = atoi((char *)argv->buffer);
+    } else {
+        rc = symtab_addr_lookup((char *) argv->buffer, &addr);
+    }
-    if (!addr)
+    if (rc == ENOENT)
         printf("Symbol %s not found.\n", argv->buffer);
-    else if (addr == (uint32_t *) -1) {
+    else if (rc == EOVERFLOW) {
         symtab_print_search((char *) argv->buffer);
         printf("Duplicate symbol, be more specific.\n");
-    } else {
+    } else if (rc == EOK) {
         if (pointer)
-            addr = (uint32_t *)(*(unative_t *)addr);
+            addr = *(uintptr_t *) addr;
         printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
-        *addr = arg1;
+        *(uint32_t *) addr = arg1;
+    } else {
+        printf("No symbol information available.\n");
     }
     return 1;
 ,7 → 913,7
  *
  * return Always 1
  */
-int cmd_ipc_task(cmd_arg_t * argv) {
+int cmd_ipc(cmd_arg_t * argv) {
     ipc_print_task(argv[0].intval);
     return 1;
 }
 ,8 → 952,11
 int cmd_continue(cmd_arg_t *argv)
 {
     printf("The kernel will now relinquish the console.\n");
-    printf("Use userspace controls to redraw the screen.\n");
-    arch_release_console();
+    release_console();
+    if ((kconsole_notify) && (kconsole_irq.notif_cfg.notify))
+        ipc_irq_send_msg_0(&kconsole_irq);
     return 1;
 }
 ,18 → 969,23
  */
 int cmd_tests(cmd_arg_t *argv)
 {
+    size_t len = 0;
     test_t *test;
+    for (test = tests; test->name != NULL; test++) {
+        if (strlen(test->name) > len)
+            len = strlen(test->name);
+    }
     for (test = tests; test->name != NULL; test++)
-        printf("%s\t\t%s%s\n", test->name, test->desc, (test->safe ? "" : " (unsafe)"));
+        printf("%-*s %s%s\n", len, test->name, test->desc, (test->safe ? "" : " (unsafe)"));
-    printf("*\t\tRun all safe tests\n");
+    printf("%-*s Run all safe tests\n", len, "*");
     return 1;
 }
 static bool run_test(const test_t *test)
 {
-    printf("%s\t\t%s\n", test->name, test->desc);
+    printf("%s (%s)\n", test->name, test->desc);
     /* Update and read thread accounting
        for benchmarking */

 /branches/network/kernel/generic/src/console/chardev.c
 ,42 → 37,62
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
-/** Initialize character device.
+/** Initialize input character device.
  *
- * @param chardev Character device.
- * @param op Implementation of character device operations.
+ * @param indev Input character device.
+ * @param op    Implementation of input character device operations.
+ *
  */
-void chardev_initialize(char *name, chardev_t *chardev,
-            chardev_operations_t *op)
+void indev_initialize(char *name, indev_t *indev,
+    indev_operations_t *op)
 {
-    chardev->name = name;
-    waitq_initialize(&chardev->wq);
-    spinlock_initialize(&chardev->lock, "chardev");
-    chardev->counter = 0;
-    chardev->index = 0;
-    chardev->op = op;
+    indev->name = name;
+    waitq_initialize(&indev->wq);
+    spinlock_initialize(&indev->lock, "indev");
+    indev->counter = 0;
+    indev->index = 0;
+    indev->op = op;
 }
 /** Push character read from input character device.
  *
- * @param chardev Character device.
- * @param ch Character being pushed.
+ * @param indev Input character device.
+ * @param ch    Character being pushed.
+ *
  */
-void chardev_push_character(chardev_t *chardev, uint8_t ch)
+void indev_push_character(indev_t *indev, uint8_t ch)
 {
-    spinlock_lock(&chardev->lock);
-    chardev->counter++;
-    if (chardev->counter == CHARDEV_BUFLEN - 1) {
-        /* buffer full => disable device interrupt */
-        chardev->op->suspend(chardev);
+    ASSERT(indev);
+    spinlock_lock(&indev->lock);
+    if (indev->counter == INDEV_BUFLEN - 1) {
+        /* Buffer full */
+        spinlock_unlock(&indev->lock);
+        return;
     }
-    chardev->buffer[chardev->index++] = ch;
-    chardev->index = chardev->index % CHARDEV_BUFLEN; /* index modulo size of buffer */
-    waitq_wakeup(&chardev->wq, WAKEUP_FIRST);
-    spinlock_unlock(&chardev->lock);
+    indev->counter++;
+    indev->buffer[indev->index++] = ch;
+    /* Index modulo size of buffer */
+    indev->index = indev->index % INDEV_BUFLEN;
+    waitq_wakeup(&indev->wq, WAKEUP_FIRST);
+    spinlock_unlock(&indev->lock);
 }
+/** Initialize output character device.
+ *
+ * @param outdev Output character device.
+ * @param op     Implementation of output character device operations.
+ *
+ */
+void outdev_initialize(char *name, outdev_t *outdev,
+    outdev_operations_t *op)
+{
+    outdev->name = name;
+    spinlock_initialize(&outdev->lock, "outdev");
+    outdev->op = op;
+}
 /** @}
  */

 /branches/network/kernel/generic/src/console/kconsole.c
 ,8 → 49,12
 #include <macros.h>
 #include <debug.h>
 #include <func.h>
+#include <string.h>
+#include <macros.h>
+#include <sysinfo/sysinfo.h>
+#include <ddi/device.h>
 #include <symtab.h>
-#include <macros.h>
+#include <errno.h>
 /** Simple kernel console.
  *
 ,10 → 87,39
     index_t *end);
 static char history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
-/** Initialize kconsole data structures. */
+/*
+ * For now, we use 0 as INR.
+ * However, it is therefore desirable to have architecture specific
+ * definition of KCONSOLE_VIRT_INR in the future.
+ */
+#define KCONSOLE_VIRT_INR  0
+bool kconsole_notify = false;
+irq_t kconsole_irq;
+/** Allways refuse IRQ ownership.
+ *
+ * This is not a real IRQ, so we always decline.
+ *
+ * @return Always returns IRQ_DECLINE.
+ *
+ */
+static irq_ownership_t kconsole_claim(irq_t *irq)
+{
+    return IRQ_DECLINE;
+}
+/** Initialize kconsole data structures
+ *
+ * This is the most basic initialization, almost no
+ * other kernel subsystem is ready yet.
+ *
+ */
 void kconsole_init(void)
 {
-    int i;
+    unsigned int i;
     cmd_init();
     for (i = 0; i < KCONSOLE_HISTORY; i++)
 ,6 → 127,26
 }
+/** Initialize kconsole notification mechanism
+ *
+ * Initialize the virtual IRQ notification mechanism.
+ *
+ */
+void kconsole_notify_init(void)
+{
+    sysinfo_set_item_val("kconsole.present", NULL, true);
+    sysinfo_set_item_val("kconsole.inr", NULL, KCONSOLE_VIRT_INR);
+    irq_initialize(&kconsole_irq);
+    kconsole_irq.devno = device_assign_devno();
+    kconsole_irq.inr = KCONSOLE_VIRT_INR;
+    kconsole_irq.claim = kconsole_claim;
+    irq_register(&kconsole_irq);
+    kconsole_notify = true;
+}
 /** Register kconsole command.
  *
  * @param cmd Structure describing the command.
 ,7 → 256,7
  */
 static int cmdtab_compl(char *name)
 {
-    static char output[MAX_SYMBOL_NAME + 1];
+    static char output[/*MAX_SYMBOL_NAME*/128 + 1];
     link_t *startpos = NULL;
     const char *foundtxt;
     int found = 0;
 ,12 → 288,11
             startpos = startpos->next;
         }
     }
-    strncpy(name, output, MAX_SYMBOL_NAME);
+    strncpy(name, output, 128/*MAX_SYMBOL_NAME*/);
     return found;
 }
-static char *clever_readline(const char *prompt, chardev_t *input)
+static char *clever_readline(const char *prompt, indev_t *input)
 {
     static int histposition = 0;
 ,42 → 453,71
     return current;
 }
-/** Kernel console managing thread.
+bool kconsole_check_poll(void)
+{
+    return check_poll(stdin);
+}
+/** Kernel console prompt.
  *
  * @param prompt Kernel console prompt (e.g kconsole/panic).
+ * @param msg    Message to display in the beginning.
+ * @param kcon   Wait for keypress to show the prompt
+ *               and never exit.
+ *
  */
-void kconsole(void *prompt)
+void kconsole(char *prompt, char *msg, bool kcon)
 {
     cmd_info_t *cmd_info;
     count_t len;
     char *cmdline;
     if (!stdin) {
-        printf("%s: no stdin\n", __func__);
+        LOG("No stdin for kernel console");
         return;
     }
+    if (msg)
+        printf("%s", msg);
+    if (kcon)
+        _getc(stdin);
+    else
+        printf("Type \"exit\" to leave the console.\n");
     while (true) {
         cmdline = clever_readline((char *) prompt, stdin);
         len = strlen(cmdline);
         if (!len)
             continue;
+        if ((!kcon) && (len == 4) && (strncmp(cmdline, "exit", 4) == 0))
+            break;
         cmd_info = parse_cmdline(cmdline, len);
         if (!cmd_info)
             continue;
-        if (strncmp(cmd_info->name, "exit",
-            min(strlen(cmd_info->name), 5)) == 0)
-            break;
         (void) cmd_info->func(cmd_info->argv);
     }
 }
+/** Kernel console managing thread.
+ *
+ */
+void kconsole_thread(void *data)
+{
+    kconsole("kconsole", "Kernel console ready (press any key to activate)\n", true);
+}
 static int parse_int_arg(char *text, size_t len, unative_t *result)
 {
-    static char symname[MAX_SYMBOL_NAME];
     uintptr_t symaddr;
     bool isaddr = false;
     bool isptr = false;
+    int rc;
+    static char symname[MAX_SYMBOL_NAME];
     /* If we get a name, try to find it in symbol table */
     if (text[0] == '&') {
 ,16 → 531,20
     }
     if (text[0] < '0' || text[0] > '9') {
         strncpy(symname, text, min(len + 1, MAX_SYMBOL_NAME));
-        symaddr = get_symbol_addr(symname);
-        if (!symaddr) {
+        rc = symtab_addr_lookup(symname, &symaddr);
+        switch (rc) {
+        case ENOENT:
             printf("Symbol %s not found.\n", symname);
             return -1;
-        }
-        if (symaddr == (uintptr_t) -1) {
+        case EOVERFLOW:
             printf("Duplicate symbol %s.\n", symname);
             symtab_print_search(symname);
             return -1;
+        default:
+            printf("No symbol information available.\n");
+            return -1;
         }
         if (isaddr)
             *result = (unative_t)symaddr;
         else if (isptr)

 /branches/network/kernel/generic/src/proc/scheduler.c
 ,7 → 451,7
             /*
              * Entering state is unexpected.
              */
-            panic("tid%" PRIu64 ": unexpected state %s\n",
+            panic("tid%" PRIu64 ": unexpected state %s.",
                 THREAD->tid, thread_states[THREAD->state]);
             break;
         }

 /branches/network/kernel/generic/src/proc/task.c
 ,6 → 52,7
 #include <print.h>
 #include <errno.h>
 #include <func.h>
+#include <string.h>
 #include <syscall/copy.h>
 /** Spinlock protecting the tasks_tree AVL tree. */
 ,7 → 131,7
 /** Create new task with no threads.
  *
  * @param as        Task's address space.
- * @param name      Symbolic name.
+ * @param name      Symbolic name (a copy is made).
  *
  * @return      New task's structure.
  *
 ,7 → 149,10
     spinlock_initialize(&ta->lock, "task_ta_lock");
     list_initialize(&ta->th_head);
     ta->as = as;
-    ta->name = name;
+    memcpy(ta->name, name, TASK_NAME_BUFLEN);
+    ta->name[TASK_NAME_BUFLEN - 1] = '\0';
     atomic_set(&ta->refcount, 0);
     atomic_set(&ta->lifecount, 0);
     ta->context = CONTEXT;
 ,7 → 159,18
     ta->capabilities = 0;
     ta->cycles = 0;
+#ifdef CONFIG_UDEBUG
+    /* Init debugging stuff */
+    udebug_task_init(&ta->udebug);
+    /* Init kbox stuff */
+    ipc_answerbox_init(&ta->kb.box, ta);
+    ta->kb.thread = NULL;
+    mutex_initialize(&ta->kb.cleanup_lock, MUTEX_PASSIVE);
+    ta->kb.finished = false;
+#endif
     ipc_answerbox_init(&ta->answerbox, ta);
     for (i = 0; i < IPC_MAX_PHONES; i++)
         ipc_phone_init(&ta->phones[i]);
 ,6 → 250,35
         sizeof(TASK->taskid));
 }
+/** Syscall for setting the task name.
+ *
+ * The name simplifies identifying the task in the task list.
+ *
+ * @param name  The new name for the task. (typically the same
+ *      as the command used to execute it).
+ *
+ * @return 0 on success or an error code from @ref errno.h.
+ */
+unative_t sys_task_set_name(const char *uspace_name, size_t name_len)
+{
+    int rc;
+    char namebuf[TASK_NAME_BUFLEN];
+    /* Cap length of name and copy it from userspace. */
+    if (name_len > TASK_NAME_BUFLEN - 1)
+        name_len = TASK_NAME_BUFLEN - 1;
+    rc = copy_from_uspace(namebuf, uspace_name, name_len);
+    if (rc != 0)
+        return (unative_t) rc;
+    namebuf[name_len] = '\0';
+    strncpy(TASK->name, namebuf, TASK_NAME_BUFLEN);
+    return EOK;
+}
 /** Find task structure corresponding to task ID.
  *
  * The tasks_lock must be already held by the caller of this function and
 ,7 → 369,7
         bool sleeping = false;
         thr = list_get_instance(cur, thread_t, th_link);
         spinlock_lock(&thr->lock);
         thr->interrupted = true;
         if (thr->state == Sleeping)
 ,13 → 397,13
     order(task_get_accounting(t), &cycles, &suffix);
 #ifdef __32_BITS__
-    printf("%-6" PRIu64 " %-10s %-3" PRIu32 " %10p %10p %9" PRIu64
+    printf("%-6" PRIu64 " %-12s %-3" PRIu32 " %10p %10p %9" PRIu64
         "%c %7ld %6ld", t->taskid, t->name, t->context, t, t->as, cycles,
         suffix, atomic_get(&t->refcount), atomic_get(&t->active_calls));
 #endif
 #ifdef __64_BITS__
-    printf("%-6" PRIu64 " %-10s %-3" PRIu32 " %18p %18p %9" PRIu64
+    printf("%-6" PRIu64 " %-12s %-3" PRIu32 " %18p %18p %9" PRIu64
         "%c %7ld %6ld", t->taskid, t->name, t->context, t, t->as, cycles,
         suffix, atomic_get(&t->refcount), atomic_get(&t->active_calls));
 #endif
 ,16 → 428,16
     spinlock_lock(&tasks_lock);
 #ifdef __32_BITS__
-    printf("taskid name       ctx address    as         "
+    printf("taskid name         ctx address    as         "
         "cycles     threads calls  callee\n");
-    printf("------ ---------- --- ---------- ---------- "
+    printf("------ ------------ --- ---------- ---------- "
         "---------- ------- ------ ------>\n");
 #endif
 #ifdef __64_BITS__
-    printf("taskid name       ctx address            as                 "
+    printf("taskid name         ctx address            as                 "
         "cycles     threads calls  callee\n");
-    printf("------ ---------- --- ------------------ ------------------ "
+    printf("------ ------------ --- ------------------ ------------------ "
         "---------- ------- ------ ------>\n");
 #endif

 /branches/network/kernel/generic/src/proc/program.c
 ,9 → 67,10
  *
  * @param as        Address space containing a binary program image.
  * @param entry_addr    Program entry-point address in program address space.
+ * @param name      Name to set for the program's task.
  * @param p     Buffer for storing program information.
  */
-void program_create(as_t *as, uintptr_t entry_addr, program_t *p)
+void program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *p)
 {
     as_area_t *a;
     uspace_arg_t *kernel_uarg;
 ,7 → 82,7
     kernel_uarg->uspace_thread_arg = NULL;
     kernel_uarg->uspace_uarg = NULL;
-    p->task = task_create(as, "app");
+    p->task = task_create(as, name);
     ASSERT(p->task);
     /*
 ,6 → 107,7
  * executable image. The task is returned in *task.
  *
  * @param image_addr    Address of an executable program image.
+ * @param name      Name to set for the program's task.
  * @param p     Buffer for storing program info. If image_addr
  *          points to a loader image, p->task will be set to
  *          NULL and EOK will be returned.
 ,7 → 114,7
  *
  * @return EOK on success or negative error code.
  */
-int program_create_from_image(void *image_addr, program_t *p)
+int program_create_from_image(void *image_addr, char *name, program_t *p)
 {
     as_t *as;
     unsigned int rc;
 ,7 → 138,7
         return EOK;
     }
-    program_create(as, ((elf_header_t *) image_addr)->e_entry, p);
+    program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);
     return EOK;
 }
 ,10 → 145,12
 /** Create a task from the program loader image.
  *
- * @param p Buffer for storing program info.
+ * @param p Buffer for storing program info.
+ * @param name  Name to set for the program's task.
+ *
  * @return EOK on success or negative error code.
  */
-int program_create_loader(program_t *p)
+int program_create_loader(program_t *p, char *name)
 {
     as_t *as;
     unsigned int rc;
 ,7 → 171,8
         return ENOENT;
     }
-    program_create(as, ((elf_header_t *) program_loader)->e_entry, p);
+    program_create(as, ((elf_header_t *) program_loader)->e_entry,
+        name, p);
     return EOK;
 }
 ,48 → 190,37
 /** Syscall for creating a new loader instance from userspace.
  *
- * Creates a new task from the program loader image, connects a phone
- * to it and stores the phone id into the provided buffer.
+ * Creates a new task from the program loader image and sets
+ * the task name.
  *
- * @param uspace_phone_id Userspace address where to store the phone id.
+ * @param name          Name to set on the new task (typically the same
+ *              as the command used to execute it).
  *
  * @return 0 on success or an error code from @ref errno.h.
  */
-unative_t sys_program_spawn_loader(int *uspace_phone_id)
+unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
 {
     program_t p;
-    int fake_id;
     int rc;
-    int phone_id;
+    char namebuf[TASK_NAME_BUFLEN];
-    fake_id = 0;
+    /* Cap length of name and copy it from userspace. */
-    /* Before we even try creating the task, see if we can write the id */
-    rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id,
-        sizeof(fake_id));
+    if (name_len > TASK_NAME_BUFLEN - 1)
+        name_len = TASK_NAME_BUFLEN - 1;
+    rc = copy_from_uspace(namebuf, uspace_name, name_len);
     if (rc != 0)
-        return rc;
+        return (unative_t) rc;
-    phone_id = phone_alloc();
-    if (phone_id < 0)
-        return ELIMIT;
+    namebuf[name_len] = '\0';
-    rc = program_create_loader(&p);
+    /* Spawn the new task. */
+    rc = program_create_loader(&p, namebuf);
     if (rc != 0)
         return rc;
-    phone_connect(phone_id, &p.task->answerbox);
-    /* No need to aquire lock before task_ready() */
-    rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id,
-        sizeof(phone_id));
-    if (rc != 0) {
-        /* Ooops */
-        ipc_phone_hangup(&TASK->phones[phone_id]);
-        task_kill(p.task->taskid);
-        return rc;
-    }
     // FIXME: control the capabilities
     cap_set(p.task, cap_get(TASK));

 /branches/network/kernel/generic/src/proc/tasklet.c
 ,7 → 51,7
     tasklet_list = malloc(sizeof(tasklet_descriptor_t *) * config.cpu_count, 0);
     if (!tasklet_list)
-        panic("Error initializing tasklets");
+        panic("Error initializing tasklets.");
     for (i = 0; i < config.cpu_count; i++)
         tasklet_list[i] = NULL;

 /branches/network/kernel/generic/src/proc/thread.c
 ,7 → 102,7
 thread_id_t last_tid = 0;
 static slab_cache_t *thread_slab;
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
 slab_cache_t *fpu_context_slab;
 #endif
 ,7 → 161,7
     /* call the architecture-specific part of the constructor */
     thr_constructor_arch(t);
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
 #ifdef CONFIG_FPU_LAZY
     t->saved_fpu_context = NULL;
 #else
 ,11 → 169,11
     if (!t->saved_fpu_context)
         return -1;
 #endif
-#endif
+#endif
     t->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
     if (!t->kstack) {
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
         if (t->saved_fpu_context)
             slab_free(fpu_context_slab, t->saved_fpu_context);
 #endif
 ,6 → 180,10
         return -1;
     }
+#ifdef CONFIG_UDEBUG
+    mutex_initialize(&t->udebug.lock, MUTEX_PASSIVE);
+#endif
     return 0;
 }
 ,7 → 196,7
     thr_destructor_arch(t);
     frame_free(KA2PA(t->kstack));
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
     if (t->saved_fpu_context)
         slab_free(fpu_context_slab, t->saved_fpu_context);
 #endif
 ,11 → 211,11
 void thread_init(void)
 {
     THREAD = NULL;
-    atomic_set(&nrdy,0);
+    atomic_set(&nrdy, 0);
     thread_slab = slab_cache_create("thread_slab", sizeof(thread_t), 0,
         thr_constructor, thr_destructor, 0);
-#ifdef ARCH_HAS_FPU
+#ifdef CONFIG_FPU
     fpu_context_slab = slab_cache_create("fpu_slab", sizeof(fpu_context_t),
         FPU_CONTEXT_ALIGN, NULL, NULL, 0);
 #endif
 ,7 → 279,7
  *          guarantee that the task won't cease to exist during the
  *          call. The task's lock may not be held.
  * @param flags     Thread flags.
- * @param name      Symbolic name.
+ * @param name      Symbolic name (a copy is made).
  * @param uncounted Thread's accounting doesn't affect accumulated task
  *          accounting.
  *
 ,6 → 316,7
     interrupts_restore(ipl);
     memcpy(t->name, name, THREAD_NAME_BUFLEN);
+    t->name[THREAD_NAME_BUFLEN - 1] = '\0';
     t->thread_code = func;
     t->thread_arg = arg;
 ,6 → 352,11
     avltree_node_initialize(&t->threads_tree_node);
     t->threads_tree_node.key = (uintptr_t) t;
+#ifdef CONFIG_UDEBUG
+    /* Init debugging stuff */
+    udebug_thread_initialize(&t->udebug);
+#endif
     /* might depend on previous initialization */
     thread_create_arch(t);
 ,12 → 419,17
     ipl_t ipl;
     /*
-     * Attach to the current task.
+     * Attach to the specified task.
      */
     ipl = interrupts_disable();
     spinlock_lock(&task->lock);
     atomic_inc(&task->refcount);
-    atomic_inc(&task->lifecount);
+    /* Must not count kbox thread into lifecount */
+    if (t->flags & THREAD_FLAG_USPACE)
+        atomic_inc(&task->lifecount);
     list_append(&t->th_link, &task->th_head);
     spinlock_unlock(&task->lock);
 ,14 → 452,19
 {
     ipl_t ipl;
-    if (atomic_predec(&TASK->lifecount) == 0) {
-        /*
-         * We are the last thread in the task that still has not exited.
-         * With the exception of the moment the task was created, new
-         * threads can only be created by threads of the same task.
-         * We are safe to perform cleanup.
-         */
-        if (THREAD->flags & THREAD_FLAG_USPACE) {
+    if (THREAD->flags & THREAD_FLAG_USPACE) {
+#ifdef CONFIG_UDEBUG
+        /* Generate udebug THREAD_E event */
+        udebug_thread_e_event();
+#endif
+        if (atomic_predec(&TASK->lifecount) == 0) {
+            /*
+             * We are the last userspace thread in the task that
+             * still has not exited. With the exception of the
+             * moment the task was created, new userspace threads
+             * can only be created by threads of the same task.
+             * We are safe to perform cleanup.
+             */
             ipc_cleanup();
             futex_cleanup();
             LOG("Cleanup of task %" PRIu64" completed.", TASK->taskid);
 ,7 → 709,7
  *
  */
 unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
-    thread_id_t *uspace_thread_id)
+    size_t name_len, thread_id_t *uspace_thread_id)
 {
     thread_t *t;
     char namebuf[THREAD_NAME_BUFLEN];
 ,10 → 716,15
     uspace_arg_t *kernel_uarg;
     int rc;
-    rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
+    if (name_len > THREAD_NAME_BUFLEN - 1)
+        name_len = THREAD_NAME_BUFLEN - 1;
+    rc = copy_from_uspace(namebuf, uspace_name, name_len);
     if (rc != 0)
         return (unative_t) rc;
+    namebuf[name_len] = '\0';
     /*
      * In case of failure, kernel_uarg will be deallocated in this function.
      * In case of success, kernel_uarg will be freed in uinit().
 ,7 → 763,18
                 return (unative_t) rc;
              }
         }
+#ifdef CONFIG_UDEBUG
+        /*
+         * Generate udebug THREAD_B event and attach the thread.
+         * This must be done atomically (with the debug locks held),
+         * otherwise we would either miss some thread or receive
+         * THREAD_B events for threads that already existed
+         * and could be detected with THREAD_READ before.
+         */
+        udebug_thread_b_event_attach(t, TASK);
+#else
         thread_attach(t, TASK);
+#endif
         thread_ready(t);
         return 0;

 /branches/network/kernel/generic/src/lib/rd.c
 ,9 → 88,7
     rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
         FRAME_SIZE);
-    rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
     rd_parea.frames = SIZE2FRAMES(dsize);
-    rd_parea.cacheable = true;
     ddi_parea_register(&rd_parea);
     sysinfo_set_item_val("rd", NULL, true);

 /branches/network/kernel/generic/src/lib/string.c
 ,0 → 1,170
+/*
+ * 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
+ * @brief Miscellaneous functions.
+ */
+#include <string.h>
+#include <print.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <console/kconsole.h>
+/** Return number of characters in a string.
+ *
+ * @param str NULL terminated string.
+ *
+ * @return Number of characters in str.
+ *
+ */
+size_t strlen(const char *str)
+{
+    int i;
+    for (i = 0; str[i]; i++);
+    return i;
+}
+/** Compare two NULL terminated strings
+ *
+ * Do a char-by-char comparison of two NULL terminated strings.
+ * The strings are considered equal iff they consist of the same
+ * characters on the minimum of their lengths.
+ *
+ * @param src First string to compare.
+ * @param dst Second string to compare.
+ *
+ * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
+ *
+ */
+int strcmp(const char *src, const char *dst)
+{
+    for (; *src && *dst; src++, dst++) {
+        if (*src < *dst)
+            return -1;
+        if (*src > *dst)
+            return 1;
+    }
+    if (*src == *dst)
+        return 0;
+    if (!*src)
+        return -1;
+    return 1;
+}
+/** Compare two NULL terminated strings
+ *
+ * Do a char-by-char comparison of two NULL terminated strings.
+ * The strings are considered equal iff they consist of the same
+ * characters on the minimum of their lengths and specified maximal
+ * length.
+ *
+ * @param src First string to compare.
+ * @param dst Second string to compare.
+ * @param len Maximal length for comparison.
+ *
+ * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
+ *
+ */
+int strncmp(const char *src, const char *dst, size_t len)
+{
+    unsigned int i;
+    for (i = 0; (*src) && (*dst) && (i < len); src++, dst++, i++) {
+        if (*src < *dst)
+            return -1;
+        if (*src > *dst)
+            return 1;
+    }
+    if (i == len || *src == *dst)
+        return 0;
+    if (!*src)
+        return -1;
+    return 1;
+}
+/** Copy NULL terminated string.
+ *
+ * Copy at most 'len' characters from string 'src' to 'dest'.
+ * If 'src' is shorter than 'len', '\0' is inserted behind the
+ * last copied character.
+ *
+ * @param src  Source string.
+ * @param dest Destination buffer.
+ * @param len  Size of destination buffer.
+ *
+ */
+void strncpy(char *dest, const char *src, size_t len)
+{
+    unsigned int i;
+    for (i = 0; i < len; i++) {
+        if (!(dest[i] = src[i]))
+            return;
+    }
+    dest[i - 1] = '\0';
+}
+/** Find first occurence of character in string.
+ *
+ * @param s String to search.
+ * @param i Character to look for.
+ *
+ * @return Pointer to character in @a s or NULL if not found.
+ */
+extern char *strchr(const char *s, int i)
+{
+    while (*s != '\0') {
+        if (*s == i)
+            return (char *) s;
+        ++s;
+    }
+    return NULL;
+}
+/** @}
+ */

 /branches/network/kernel/generic/src/lib/memstr.c
 ,5 → 1,6
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,12 → 35,10
  * @file
  * @brief   Memory string operations.
  *
- * This file provides architecture independent functions
- * to manipulate blocks of memory. These functions
- * are optimized as much as generic functions of
- * this type can be. However, architectures are
- * free to provide even more optimized versions of these
- * functions.
+ * This file provides architecture independent functions to manipulate blocks of
+ * memory. These functions are optimized as much as generic functions of this
+ * type can be. However, architectures are free to provide even more optimized
+ * versions of these functions.
  */
 #include <memstr.h>
 ,45 → 45,91
 #include <arch/types.h>
 #include <align.h>
-/** Copy block of memory
+/** Copy block of memory.
  *
- * Copy cnt bytes from src address to dst address.
- * The copying is done word-by-word and then byte-by-byte.
- * The source and destination memory areas cannot overlap.
+ * Copy cnt bytes from src address to dst address.  The copying is done
+ * word-by-word and then byte-by-byte.  The source and destination memory areas
+ * cannot overlap.
  *
- * @param src Origin address to copy from.
- * @param dst Origin address to copy to.
- * @param cnt Number of bytes to copy.
+ * @param src       Source address to copy from.
+ * @param dst       Destination address to copy to.
+ * @param cnt       Number of bytes to copy.
  *
+ * @return      Destination address.
  */
-void *_memcpy(void * dst, const void *src, size_t cnt)
+void *_memcpy(void *dst, const void *src, size_t cnt)
 {
     unsigned int i, j;
     if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
-        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
+        ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
         for (i = 0; i < cnt; i++)
             ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
     } else {
         for (i = 0; i < cnt / sizeof(unative_t); i++)
             ((unative_t *) dst)[i] = ((unative_t *) src)[i];
         for (j = 0; j < cnt % sizeof(unative_t); j++)
-            ((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
+            ((uint8_t *)(((unative_t *) dst) + i))[j] =
+                ((uint8_t *)(((unative_t *) src) + i))[j];
     }
     return (char *) dst;
 }
+/** Move memory block with possible overlapping.
+ *
+ * Copy cnt bytes from src address to dst address. The source and destination
+ * memory areas may overlap.
+ *
+ * @param src       Source address to copy from.
+ * @param dst       Destination address to copy to.
+ * @param cnt       Number of bytes to copy.
+ *
+ * @return      Destination address.
+ */
+void *memmove(void *dst, const void *src, size_t n)
+{
+    const uint8_t *sp;
+    uint8_t *dp;
+    /* Nothing to do? */
+    if (src == dst)
+        return dst;
+    /* Non-overlapping? */
+    if (dst >= src + n || src >= dst + n) {
+        return memcpy(dst, src, n);
+    }
+    /* Which direction? */
+    if (src > dst) {
+        /* Forwards. */
+        sp = src;
+        dp = dst;
+        while (n-- != 0)
+            *dp++ = *sp++;
+    } else {
+        /* Backwards. */
+        sp = src + (n - 1);
+        dp = dst + (n - 1);
+        while (n-- != 0)
+            *dp-- = *sp--;
+    }
+    return dst;
+}
 /** Fill block of memory
  *
- * Fill cnt bytes at dst address with the value x.
- * The filling is done byte-by-byte.
+ * Fill cnt bytes at dst address with the value x.  The filling is done
+ * byte-by-byte.
  *
- * @param dst Origin address to fill.
- * @param cnt Number of bytes to fill.
- * @param x   Value to fill.
+ * @param dst       Destination address to fill.
+ * @param cnt       Number of bytes to fill.
+ * @param x     Value to fill.
  *
  */
 void _memsetb(void *dst, size_t cnt, uint8_t x)
 ,14 → 141,14
         p[i] = x;
 }
-/** Fill block of memory
+/** Fill block of memory.
  *
- * Fill cnt words at dst address with the value x.
- * The filling is done word-by-word.
+ * Fill cnt words at dst address with the value x.  The filling is done
+ * word-by-word.
  *
- * @param dst Origin address to fill.
- * @param cnt Number of words to fill.
- * @param x   Value to fill.
+ * @param dst       Destination address to fill.
+ * @param cnt       Number of words to fill.
+ * @param x     Value to fill.
  *
  */
 void _memsetw(void *dst, size_t cnt, uint16_t x)
 ,25 → 160,5
         p[i] = x;
 }
-/** Copy string
- *
- * Copy string from src address to dst address.
- * The copying is done char-by-char until the null
- * character. The source and destination memory areas
- * cannot overlap.
- *
- * @param src Origin string to copy from.
- * @param dst Origin string to copy to.
- *
- */
-char *strcpy(char *dest, const char *src)
-{
-    char *orig = dest;
-    while ((*(dest++) = *(src++)))
-        ;
-    return orig;
-}
 /** @}
  */

 /branches/network/kernel/generic/src/lib/func.c
 ,7 → 47,7
 /** Halt wrapper
  *
- * Set halt flag and halt the cpu.
+ * Set halt flag and halt the CPU.
  *
  */
 void halt()
 ,9 → 54,7
 {
 #ifdef CONFIG_DEBUG
     bool rundebugger = false;
-//      TODO test_and_set not defined on all arches
-//  if (!test_and_set(&haltstate))
     if (!atomic_get(&haltstate)) {
         atomic_set(&haltstate, 1);
         rundebugger = true;
 ,118 → 62,22
 #else
     atomic_set(&haltstate, 1);
 #endif
     interrupts_disable();
-#ifdef CONFIG_DEBUG
-    if (rundebugger) {
-        printf("\n");
-        kconsole("panic"); /* Run kconsole as a last resort to user */
-    }
-#endif
+#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
+    if ((rundebugger) && (kconsole_check_poll()))
+        kconsole("panic", "\nLast resort kernel console ready.\n", false);
+#endif
     if (CPU)
         printf("cpu%u: halted\n", CPU->id);
     else
         printf("cpu: halted\n");
     cpu_halt();
 }
-/** Return number of characters in a string.
- *
- * @param str NULL terminated string.
- *
- * @return Number of characters in str.
- */
-size_t strlen(const char *str)
-{
-    int i;
-    for (i = 0; str[i]; i++)
-        ;
-    return i;
-}
-/** Compare two NULL terminated strings
- *
- * Do a char-by-char comparison of two NULL terminated strings.
- * The strings are considered equal iff they consist of the same
- * characters on the minimum of their lengths.
- *
- * @param src First string to compare.
- * @param dst Second string to compare.
- *
- * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
- *
- */
-int strcmp(const char *src, const char *dst)
-{
-    for (; *src && *dst; src++, dst++) {
-        if (*src < *dst)
-            return -1;
-        if (*src > *dst)
-            return 1;
-    }
-    if (*src == *dst)
-        return 0;
-    if (!*src)
-        return -1;
-    return 1;
-}
-/** Compare two NULL terminated strings
- *
- * Do a char-by-char comparison of two NULL terminated strings.
- * The strings are considered equal iff they consist of the same
- * characters on the minimum of their lengths and specified maximal
- * length.
- *
- * @param src First string to compare.
- * @param dst Second string to compare.
- * @param len Maximal length for comparison.
- *
- * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
- *
- */
-int strncmp(const char *src, const char *dst, size_t len)
-{
-    unsigned int i;
-    for (i = 0; (*src) && (*dst) && (i < len); src++, dst++, i++) {
-        if (*src < *dst)
-            return -1;
-        if (*src > *dst)
-            return 1;
-    }
-    if (i == len || *src == *dst)
-        return 0;
-    if (!*src)
-        return -1;
-    return 1;
-}
-/** Copy NULL terminated string.
- *
- * Copy at most 'len' characters from string 'src' to 'dest'.
- * If 'src' is shorter than 'len', '\0' is inserted behind the
- * last copied character.
- *
- * @param src Source string.
- * @param dest Destination buffer.
- * @param len Size of destination buffer.
- */
-void strncpy(char *dest, const char *src, size_t len)
-{
-    unsigned int i;
-    for (i = 0; i < len; i++) {
-        if (!(dest[i] = src[i]))
-            return;
-    }
-    dest[i-1] = '\0';
-}
 /** Convert ascii representation to unative_t
  *
  * Supports 0x for hexa & 0 for octal notation.

 /branches/network/kernel/generic/src/adt/btree.c
 ,7 → 124,7
     lnode = leaf_node;
     if (!lnode) {
         if (btree_search(t, key, &lnode)) {
-            panic("B-tree %p already contains key %" PRIu64 "\n", t, key);
+            panic("B-tree %p already contains key %" PRIu64 ".", t, key);
         }
     }
 ,7 → 224,7
     lnode = leaf_node;
     if (!lnode) {
         if (!btree_search(t, key, &lnode)) {
-            panic("B-tree %p does not contain key %" PRIu64 "\n", t, key);
+            panic("B-tree %p does not contain key %" PRIu64 ".", t, key);
         }
     }
 ,7 → 524,7
             return;
         }
     }
-    panic("node %p does not contain key %" PRIu64 "\n", node, key);
+    panic("Node %p does not contain key %" PRIu64 ".", node, key);
 }
 /** Remove key and its right subtree pointer from B-tree node.
 ,7 → 551,7
             return;
         }
     }
-    panic("node %p does not contain key %" PRIu64 "\n", node, key);
+    panic("Node %p does not contain key %" PRIu64 ".", node, key);
 }
 /** Split full B-tree node and insert new key-value-right-subtree triplet.
 ,7 → 693,7
         if (subtree == node->subtree[i])
             return i - (int) (right != false);
     }
-    panic("node %p does not contain subtree %p\n", node, subtree);
+    panic("Node %p does not contain subtree %p.", node, subtree);
 }
 /** Rotate one key-value-rsubtree triplet from the left sibling to the right sibling.

 /branches/network/kernel/generic/src/adt/avl.c
 ,7 → 43,7
  *
  * Every node has a pointer to its parent which allows insertion of multiple
  * identical keys into the tree.
- *
+ *
  * Be careful when using this tree because of the base atribute which is added
  * to every inserted node key. There is no rule in which order nodes with the
  * same key are visited.

 /branches/network/kernel/generic/src/adt/hash_table.c
 ,7 → 61,7
     h->entry = (link_t *) malloc(m * sizeof(link_t), 0);
     if (!h->entry) {
-        panic("cannot allocate memory for hash table\n");
+        panic("Cannot allocate memory for hash table.");
     }
     memsetb(h->entry, m * sizeof(link_t), 0);

 /branches/network/kernel/generic/src/mm/slab.c
 ,7 → 173,7
     slab_t *slab;
     size_t fsize;
     unsigned int i;
-    unsigned int zone = 0;
+    count_t zone = 0;
     data = frame_alloc_generic(cache->order, FRAME_KA | flags, &zone);
     if (!data) {

 /branches/network/kernel/generic/src/mm/tlb.c
 ,7 → 173,7
             tlb_invalidate_pages(asid, page, count);
             break;
         default:
-            panic("unknown type (%d)\n", type);
+            panic("Unknown type (%d).", type);
             break;
         }
         if (type == TLB_INVL_ALL)

 /branches/network/kernel/generic/src/mm/backend_anon.c
 ,7 → 152,7
      */
     page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
     if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
-        panic("Could not insert used space.\n");
+        panic("Cannot insert used space.");
     return AS_PF_OK;
 }

 /branches/network/kernel/generic/src/mm/as.c
 ,7 → 122,7
     int rc;
     link_initialize(&as->inactive_as_with_asid_link);
-    mutex_initialize(&as->lock, MUTEX_PASSIVE);
+    mutex_initialize(&as->lock, MUTEX_PASSIVE);
     rc = as_constructor_arch(as, flags);
 ,8 → 146,12
     AS_KERNEL = as_create(FLAG_AS_KERNEL);
     if (!AS_KERNEL)
-        panic("can't create kernel address space\n");
+        panic("Cannot create kernel address space.");
+    /* Make sure the kernel address space
+     * reference count never drops to zero.
+     */
+    atomic_set(&AS_KERNEL->refcount, 1);
 }
 /** Create address space.
 ,7 → 180,7
 #else
     page_table_create(flags);
 #endif
     return as;
 }
 ,7 → 389,7
     if (pages < area->pages) {
         bool cond;
-        uintptr_t start_free = area->base + pages*PAGE_SIZE;
+        uintptr_t start_free = area->base + pages * PAGE_SIZE;
         /*
          * Shrinking the area.
 ,7 → 399,7
         /*
          * Start TLB shootdown sequence.
          */
-        tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base +
+        tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base +
             pages * PAGE_SIZE, area->pages - pages);
         /*
 ,8 → 444,8
                     i = (start_free - b) >> PAGE_WIDTH;
                     if (!used_space_remove(area, start_free,
                         c - i))
-                        panic("Could not remove used "
-                            "space.\n");
+                        panic("Cannot remove used "
+                            "space.");
                 } else {
                     /*
                      * The interval of used space can be
 ,8 → 452,8
                      * completely removed.
                      */
                     if (!used_space_remove(area, b, c))
-                        panic("Could not remove used "
-                            "space.\n");
+                        panic("Cannot remove used "
+                            "space.");
                 }
                 for (; i < c; i++) {
 ,11 → 773,12
  * In order for this to work properly, this may copy the data
  * into private anonymous memory (unless it's already there).
  *
- * @param as        Address space.
- * @param flags     Flags of the area memory.
- * @param address   Address withing the area to be changed.
+ * @param as      Address space.
+ * @param flags   Flags of the area memory.
+ * @param address Address within the area to be changed.
  *
- * @return      Zero on success or a value from @ref errno.h on failure.
+ * @return Zero on success or a value from @ref errno.h on failure.
+ *
  */
 int as_area_change_flags(as_t *as, int flags, uintptr_t address)
 {
 ,7 → 790,7
     uintptr_t *old_frame;
     index_t frame_idx;
     count_t used_pages;
     /* Flags for the new memory mapping */
     page_flags = area_flags_to_page_flags(flags);
 ,7 → 804,7
         return ENOENT;
     }
-    if (area->sh_info || area->backend != &anon_backend) {
+    if ((area->sh_info) || (area->backend != &anon_backend)) {
         /* Copying shared areas not supported yet */
         /* Copying non-anonymous memory not supported yet */
         mutex_unlock(&area->lock);
 ,6 → 875,7
      */
     tlb_invalidate_pages(as->asid, area->base, area->pages);
     /*
      * Invalidate potential software translation caches (e.g. TSB on
      * sparc64).
 ,7 → 1666,7
     }
     panic("Inconsistency detected while adding %" PRIc " pages of used "
-        "space at %p.\n", count, page);
+        "space at %p.", count, page);
 }
 /** Mark portion of address space area as unused.
 ,7 → 1845,7
 error:
     panic("Inconsistency detected while removing %" PRIc " pages of used "
-        "space from %p.\n", count, page);
+        "space from %p.", count, page);
 }
 /** Remove reference to address space area share info.

 /branches/network/kernel/generic/src/mm/buddy.c
 ,7 → 46,7
 #include <macros.h>
 /** Return size needed for the buddy configuration data. */
-size_t buddy_conf_size(int max_order)
+size_t buddy_conf_size(size_t max_order)
 {
     return sizeof(buddy_system_t) + (max_order + 1) * sizeof(link_t);
 }

 /branches/network/kernel/generic/src/mm/backend_phys.c
 ,7 → 77,7
     page_mapping_insert(AS, addr, base + (addr - area->base),
         as_area_get_flags(area));
         if (!used_space_insert(area, ALIGN_DOWN(addr, PAGE_SIZE), 1))
-                panic("Could not insert used space.\n");
+                panic("Cannot insert used space.");
     return AS_PF_OK;
 }

 /branches/network/kernel/generic/src/mm/frame.c
 ,6 → 1,7
 /*
  * Copyright (c) 2001-2005 Jakub Jermar
  * Copyright (c) 2005 Sergey Bondari
+ * Copyright (c) 2009 Martin Decky
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,7 → 34,7
 /**
  * @file
- * @brief   Physical frame allocator.
+ * @brief Physical frame allocator.
  *
  * This file contains the physical frame allocator and memory zone management.
  * The frame allocator is built on top of the buddy allocator.
 ,16 → 42,6
  * @see buddy.c
  */
-/*
- * Locking order
- *
- * In order to access particular zone, the process must first lock
- * the zones.lock, then lock the zone and then unlock the zones.lock.
- * This insures, that we can fiddle with the zones in runtime without
- * affecting the processes.
- *
- */
 #include <arch/types.h>
 #include <mm/frame.h>
 #include <mm/as.h>
 ,7 → 48,6
 #include <panic.h>
 #include <debug.h>
 #include <adt/list.h>
-#include <synch/spinlock.h>
 #include <synch/mutex.h>
 #include <synch/condvar.h>
 #include <arch/asm.h>
 ,50 → 59,16
 #include <macros.h>
 #include <config.h>
-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;
+zones_t zones;
-typedef struct {
-    SPINLOCK_DECLARE(lock); /**< this lock protects everything below */
-    pfn_t base;     /**< frame_no of the first frame in the frames
-                     array */
-    count_t count;          /**< Size of zone */
-    frame_t *frames;    /**< array of frame_t structures in this
-                     zone */
-    count_t free_count; /**< number of free frame_t structures */
-    count_t busy_count; /**< number of busy frame_t structures */
-    buddy_system_t *buddy_system; /**< buddy system for the zone */
-    int flags;
-} 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);
-    unsigned int count;
-    zone_t *info[ZONES_MAX];
-} zones_t;
-static zones_t zones;
-/*
  * Synchronization primitives used to sleep when there is no memory
  * available.
  */
 mutex_t mem_avail_mtx;
 condvar_t mem_avail_cv;
-unsigned long mem_avail_frames = 0; /**< Number of available frames. */
-unsigned long mem_avail_gen = 0;    /**< Generation counter. */
+count_t mem_avail_req = 0;  /**< Number of frames requested. */
+count_t mem_avail_gen = 0;  /**< Generation counter. */
 /********************/
 /* Helper functions */
 ,13 → 84,12
     return (index_t) (frame - zone->frames) + zone->base;
 }
-static inline int frame_index_valid(zone_t *zone, index_t index)
+static inline bool frame_index_valid(zone_t *zone, index_t index)
 {
     return (index < zone->count);
 }
-/** Compute pfn_t from frame_t pointer & zone pointer */
-static index_t make_frame_index(zone_t *zone, frame_t *frame)
+static inline index_t make_frame_index(zone_t *zone, frame_t *frame)
 {
     return (frame - zone->frames);
 }
 ,7 → 96,8
 /** Initialize frame structure.
  *
- * @param frame     Frame structure to be initialized.
+ * @param frame Frame structure to be initialized.
+ *
  */
 static void frame_initialize(frame_t *frame)
 {
 ,153 → 105,145
     frame->buddy_order = 0;
 }
-/**********************/
-/* Zoneinfo functions */
-/**********************/
+/*******************/
+/* Zones functions */
+/*******************/
 /** Insert-sort zone into zones list.
  *
- * @param newzone   New zone to be inserted into zone list.
- * @return      Zone number on success, -1 on error.
+ * Assume interrupts are disabled and zones lock is
+ * locked.
+ *
+ * @param base  Base frame of the newly inserted zone.
+ * @param count Number of frames of the newly inserted zone.
+ *
+ * @return Zone number on success, -1 on error.
+ *
  */
-static int zones_add_zone(zone_t *newzone)
+static count_t zones_insert_zone(pfn_t base, count_t count)
 {
-    unsigned int i, j;
-    ipl_t ipl;
-    zone_t *z;
-    ipl = interrupts_disable();
-    spinlock_lock(&zones.lock);
-    /* Try to merge */
     if (zones.count + 1 == ZONES_MAX) {
         printf("Maximum zone count %u exceeded!\n", ZONES_MAX);
-        spinlock_unlock(&zones.lock);
-        interrupts_restore(ipl);
-        return -1;
+        return (count_t) -1;
     }
+    count_t i;
     for (i = 0; i < zones.count; i++) {
-        /* Check for overflow */
-        z = zones.info[i];
-        if (overlaps(newzone->base, newzone->count, z->base,
-            z->count)) {
+        /* Check for overlap */
+        if (overlaps(base, count,
+            zones.info[i].base, zones.info[i].count)) {
             printf("Zones overlap!\n");
-            return -1;
+            return (count_t) -1;
         }
-        if (newzone->base < z->base)
+        if (base < zones.info[i].base)
             break;
     }
     /* Move other zones up */
-    for (j = i; j < zones.count; j++)
-        zones.info[j + 1] = zones.info[j];
+    count_t j;
+    for (j = zones.count; j > i; j--) {
+        zones.info[j] = zones.info[j - 1];
+        zones.info[j].buddy_system->data =
+            (void *) &zones.info[j - 1];
+    }
-    zones.info[i] = newzone;
     zones.count++;
-    spinlock_unlock(&zones.lock);
-    interrupts_restore(ipl);
     return i;
 }
-/** Try to find a zone where can we find the frame.
+/** Get total available frames.
  *
- * Assume interrupts are disabled.
+ * Assume interrupts are disabled and zones lock is
+ * locked.
  *
- * @param frame     Frame number contained in zone.
- * @param pzone     If not null, it is used as zone hint. Zone index is
- *          filled into the variable on success.
- * @return      Pointer to locked zone containing frame.
+ * @return Total number of available frames.
+ *
  */
-static zone_t *find_zone_and_lock(pfn_t frame, unsigned int *pzone)
+#ifdef CONFIG_DEBUG
+static count_t total_frames_free(void)
 {
-    unsigned int i;
-    unsigned int hint = pzone ? *pzone : 0;
-    zone_t *z;
+    count_t total = 0;
+    count_t i;
+    for (i = 0; i < zones.count; i++)
+        total += zones.info[i].free_count;
-    spinlock_lock(&zones.lock);
+    return total;
+}
+#endif
+/** Find a zone with a given frames.
+ *
+ * Assume interrupts are disabled and zones lock is
+ * locked.
+ *
+ * @param frame Frame number contained in zone.
+ * @param count Number of frames to look for.
+ * @param hint  Used as zone hint.
+ *
+ * @return Zone index or -1 if not found.
+ *
+ */
+count_t find_zone(pfn_t frame, count_t count, count_t hint)
+{
     if (hint >= zones.count)
         hint = 0;
-    i = hint;
+    count_t i = hint;
     do {
-        z = zones.info[i];
-        spinlock_lock(&z->lock);
-        if (z->base <= frame && z->base + z->count > frame) {
-            /* Unlock the global lock */
-            spinlock_unlock(&zones.lock);
-            if (pzone)
-                *pzone = i;
-            return z;
-        }
-        spinlock_unlock(&z->lock);
+        if ((zones.info[i].base <= frame)
+            && (zones.info[i].base + zones.info[i].count >= frame + count))
+            return i;
         i++;
         if (i >= zones.count)
             i = 0;
     } while (i != hint);
-    spinlock_unlock(&zones.lock);
-    return NULL;
+    return (count_t) -1;
 }
 /** @return True if zone can allocate specified order */
-static int zone_can_alloc(zone_t *z, uint8_t order)
+static bool zone_can_alloc(zone_t *zone, uint8_t order)
 {
-    return buddy_system_can_alloc(z->buddy_system, order);
+    return (zone_flags_available(zone->flags)
+        && buddy_system_can_alloc(zone->buddy_system, order));
 }
-/** Find and lock zone that can allocate order frames.
+/** Find a zone that can allocate order frames.
  *
- * Assume interrupts are disabled.
+ * Assume interrupts are disabled and zones lock is
+ * locked.
  *
- * @param order     Size (2^order) of free space we are trying to find.
- * @param flags     Required flags of the target zone.
- * @param pzone     Pointer to preferred zone or NULL, on return contains
- *          zone number.
+ * @param order Size (2^order) of free space we are trying to find.
+ * @param flags Required flags of the target zone.
+ * @param hind  Preferred zone.
+ *
  */
-static zone_t *
-find_free_zone_and_lock(uint8_t order, int flags, unsigned int *pzone)
+static count_t find_free_zone(uint8_t order, zone_flags_t flags, count_t hint)
 {
-    unsigned int i;
-    zone_t *z;
-    unsigned int hint = pzone ? *pzone : 0;
-    /* Mask off flags that are not applicable. */
-    flags &= FRAME_LOW_4_GiB;
-    spinlock_lock(&zones.lock);
     if (hint >= zones.count)
         hint = 0;
-    i = hint;
+    count_t i = hint;
     do {
-        z = zones.info[i];
-        spinlock_lock(&z->lock);
         /*
          * Check whether the zone meets the search criteria.
          */
-        if ((z->flags & flags) == flags) {
+        if ((zones.info[i].flags & flags) == flags) {
             /*
              * Check if the zone has 2^order frames area available.
              */
-            if (zone_can_alloc(z, order)) {
-                spinlock_unlock(&zones.lock);
-                if (pzone)
-                    *pzone = i;
-                return z;
-            }
+            if (zone_can_alloc(&zones.info[i], order))
+                return i;
         }
-        spinlock_unlock(&z->lock);
-        if (++i >= zones.count)
+        i++;
+        if (i >= zones.count)
             i = 0;
     } while (i != hint);
-    spinlock_unlock(&zones.lock);
-    return NULL;
+    return (count_t) -1;
 }
 /**************************/
 ,82 → 255,73
  * Find block that is parent of current list.
  * That means go to lower addresses, until such block is found
  *
- * @param order     Order of parent must be different then this
- *          parameter!!
+ * @param order Order of parent must be different then this
+ *              parameter!!
+ *
  */
-static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
+static link_t *zone_buddy_find_block(buddy_system_t *buddy, link_t *child,
     uint8_t order)
 {
-    frame_t *frame;
-    zone_t *zone;
-    index_t index;
+    frame_t *frame = list_get_instance(child, frame_t, buddy_link);
+    zone_t *zone = (zone_t *) buddy->data;
-    frame = list_get_instance(child, frame_t, buddy_link);
-    zone = (zone_t *) b->data;
-    index = frame_index(zone, frame);
+    index_t index = frame_index(zone, frame);
     do {
-        if (zone->frames[index].buddy_order != order) {
+        if (zone->frames[index].buddy_order != order)
             return &zone->frames[index].buddy_link;
-        }
-    } while(index-- > 0);
+    } while (index-- > 0);
     return NULL;
 }
 /** Buddy system find_buddy implementation.
  *
- * @param b     Buddy system.
- * @param block     Block for which buddy should be found.
+ * @param buddy Buddy system.
+ * @param block Block for which buddy should be found.
  *
- * @return      Buddy for given block if found.
+ * @return Buddy for given block if found.
+ *
  */
-static link_t *zone_buddy_find_buddy(buddy_system_t *b, link_t *block)
+static link_t *zone_buddy_find_buddy(buddy_system_t *buddy, link_t *block)
 {
-    frame_t *frame;
-    zone_t *zone;
-    index_t index;
-    bool is_left, is_right;
-    frame = list_get_instance(block, frame_t, buddy_link);
-    zone = (zone_t *) b->data;
+    frame_t *frame = list_get_instance(block, frame_t, buddy_link);
+    zone_t *zone = (zone_t *) buddy->data;
     ASSERT(IS_BUDDY_ORDER_OK(frame_index_abs(zone, frame),
         frame->buddy_order));
-    is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
-    is_right = IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame);
-    ASSERT(is_left ^ is_right);
+    bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
+    index_t index;
     if (is_left) {
         index = (frame_index(zone, frame)) +
             (1 << frame->buddy_order);
-    } else {    /* if (is_right) */
+    } else {    /* is_right */
         index = (frame_index(zone, frame)) -
             (1 << frame->buddy_order);
     }
     if (frame_index_valid(zone, index)) {
-        if (zone->frames[index].buddy_order == frame->buddy_order &&
-            zone->frames[index].refcount == 0) {
+        if ((zone->frames[index].buddy_order == frame->buddy_order) &&
+            (zone->frames[index].refcount == 0)) {
             return &zone->frames[index].buddy_link;
         }
     }
-    return NULL;
+    return NULL;
 }
 /** Buddy system bisect implementation.
  *
- * @param b     Buddy system.
- * @param block     Block to bisect.
+ * @param buddy Buddy system.
+ * @param block Block to bisect.
  *
- * @return      Right block.
+ * @return Right block.
+ *
  */
-static link_t *zone_buddy_bisect(buddy_system_t *b, link_t *block)
+static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
 {
-    frame_t *frame_l, *frame_r;
-    frame_l = list_get_instance(block, frame_t, buddy_link);
-    frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));
+    frame_t *frame_l = list_get_instance(block, frame_t, buddy_link);
+    frame_t *frame_r = (frame_l + (1 << (frame_l->buddy_order - 1)));
     return &frame_r->buddy_link;
 }
 ,75 → 328,68
 /** Buddy system coalesce implementation.
  *
- * @param b     Buddy system.
- * @param block_1   First block.
- * @param block_2   First block's buddy.
+ * @param buddy   Buddy system.
+ * @param block_1 First block.
+ * @param block_2 First block's buddy.
  *
- * @return      Coalesced block (actually block that represents lower
- *          address).
+ * @return Coalesced block (actually block that represents lower
+ *         address).
+ *
  */
-static link_t *zone_buddy_coalesce(buddy_system_t *b, link_t *block_1,
-    link_t *block_2)
+static link_t *zone_buddy_coalesce(buddy_system_t *buddy, link_t *block_1,
+    link_t *block_2)
 {
-    frame_t *frame1, *frame2;
+    frame_t *frame1 = list_get_instance(block_1, frame_t, buddy_link);
+    frame_t *frame2 = list_get_instance(block_2, frame_t, buddy_link);
-    frame1 = list_get_instance(block_1, frame_t, buddy_link);
-    frame2 = list_get_instance(block_2, frame_t, buddy_link);
-    return frame1 < frame2 ? block_1 : block_2;
+    return ((frame1 < frame2) ? block_1 : block_2);
 }
 /** Buddy system set_order implementation.
  *
- * @param b     Buddy system.
- * @param block     Buddy system block.
- * @param order     Order to set.
+ * @param buddy Buddy system.
+ * @param block Buddy system block.
+ * @param order Order to set.
+ *
  */
-static void zone_buddy_set_order(buddy_system_t *b, link_t *block,
+static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
     uint8_t order)
 {
-    frame_t *frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
-    frame->buddy_order = order;
+    list_get_instance(block, frame_t, buddy_link)->buddy_order = order;
 }
 /** Buddy system get_order implementation.
  *
- * @param b     Buddy system.
- * @param block     Buddy system block.
+ * @param buddy Buddy system.
+ * @param block Buddy system block.
  *
- * @return      Order of block.
+ * @return Order of block.
+ *
  */
-static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t *block)
+static uint8_t zone_buddy_get_order(buddy_system_t *buddy, link_t *block)
 {
-    frame_t *frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
-    return frame->buddy_order;
+    return list_get_instance(block, frame_t, buddy_link)->buddy_order;
 }
 /** Buddy system mark_busy implementation.
  *
- * @param b     Buddy system.
- * @param block     Buddy system block.
+ * @param buddy Buddy system.
+ * @param block Buddy system block.
+ *
  */
-static void zone_buddy_mark_busy(buddy_system_t *b, link_t * block)
+static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t * block)
 {
-    frame_t * frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
-    frame->refcount = 1;
+    list_get_instance(block, frame_t, buddy_link)->refcount = 1;
 }
 /** Buddy system mark_available implementation.
  *
- * @param b     Buddy system.
- * @param block     Buddy system block.
+ * @param buddy Buddy system.
+ * @param block Buddy system block.
  */
-static void zone_buddy_mark_available(buddy_system_t *b, link_t *block)
+static void zone_buddy_mark_available(buddy_system_t *buddy, link_t *block)
 {
-    frame_t *frame;
-    frame = list_get_instance(block, frame_t, buddy_link);
-    frame->refcount = 0;
+    list_get_instance(block, frame_t, buddy_link)->refcount = 0;
 }
 static buddy_system_operations_t zone_buddy_system_operations = {
 ,60 → 409,57
 /** Allocate frame in particular zone.
  *
- * Assume zone is locked.
+ * Assume zone is locked and is available for allocation.
  * Panics if allocation is impossible.
  *
- * @param zone      Zone to allocate from.
- * @param order     Allocate exactly 2^order frames.
+ * @param zone  Zone to allocate from.
+ * @param order Allocate exactly 2^order frames.
  *
- * @return      Frame index in zone.
+ * @return Frame index in zone.
  *
  */
 static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
 {
-    pfn_t v;
-    link_t *tmp;
-    frame_t *frame;
+    ASSERT(zone_flags_available(zone->flags));
     /* Allocate frames from zone buddy system */
-    tmp = buddy_system_alloc(zone->buddy_system, order);
+    link_t *link = buddy_system_alloc(zone->buddy_system, order);
-    ASSERT(tmp);
+    ASSERT(link);
     /* Update zone information. */
     zone->free_count -= (1 << order);
     zone->busy_count += (1 << order);
     /* Frame will be actually a first frame of the block. */
-    frame = list_get_instance(tmp, frame_t, buddy_link);
+    frame_t *frame = list_get_instance(link, frame_t, buddy_link);
-    /* get frame address */
-    v = make_frame_index(zone, frame);
-    return v;
+    /* Get frame address */
+    return make_frame_index(zone, frame);
 }
 /** Free frame from zone.
  *
- * Assume zone is locked.
+ * Assume zone is locked and is available for deallocation.
  *
- * @param zone      Pointer to zone from which the frame is to be freed.
- * @param frame_idx Frame index relative to zone.
+ * @param zone      Pointer to zone from which the frame is to be freed.
+ * @param frame_idx Frame index relative to zone.
+ *
  */
 static void zone_frame_free(zone_t *zone, index_t frame_idx)
 {
-    frame_t *frame;
-    uint8_t order;
-    frame = &zone->frames[frame_idx];
+    ASSERT(zone_flags_available(zone->flags));
-    /* remember frame order */
-    order = frame->buddy_order;
+    frame_t *frame = &zone->frames[frame_idx];
+    /* Remember frame order */
+    uint8_t order = frame->buddy_order;
     ASSERT(frame->refcount);
     if (!--frame->refcount) {
         buddy_system_free(zone->buddy_system, &frame->buddy_link);
         /* Update zone information. */
         zone->free_count += (1 << order);
         zone->busy_count -= (1 << order);
 ,567 → 476,633
 /** Mark frame in zone unavailable to allocation. */
 static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)
 {
-    frame_t *frame;
-    link_t *link;
-    frame = zone_get_frame(zone, frame_idx);
+    ASSERT(zone_flags_available(zone->flags));
+    frame_t *frame = zone_get_frame(zone, frame_idx);
     if (frame->refcount)
         return;
+    link_t *link __attribute__ ((unused));
     link = buddy_system_alloc_block(zone->buddy_system,
         &frame->buddy_link);
     ASSERT(link);
     zone->free_count--;
-    mutex_lock(&mem_avail_mtx);
-    mem_avail_frames--;
-    mutex_unlock(&mem_avail_mtx);
 }
-/** Join two zones.
+/** Merge two zones.
  *
- * Expect zone_t *z to point to space at least zone_conf_size large.
+ * Expect buddy to point to space at least zone_conf_size large.
+ * Assume z1 & z2 are locked and compatible and zones lock is
+ * locked.
  *
- * Assume z1 & z2 are locked.
+ * @param z1     First zone to merge.
+ * @param z2     Second zone to merge.
+ * @param old_z1 Original date of the first zone.
+ * @param buddy  Merged zone buddy.
  *
- * @param z     Target zone structure pointer.
- * @param z1        Zone to merge.
- * @param z2        Zone to merge.
  */
-static void _zone_merge(zone_t *z, zone_t *z1, zone_t *z2)
+static void zone_merge_internal(count_t z1, count_t z2, zone_t *old_z1, buddy_system_t *buddy)
 {
-    uint8_t max_order;
-    unsigned int i;
-    int z2idx;
-    pfn_t frame_idx;
-    frame_t *frame;
-    ASSERT(!overlaps(z1->base, z1->count, z2->base, z2->count));
-    ASSERT(z1->base < z2->base);
-    spinlock_initialize(&z->lock, "zone_lock");
-    z->base = z1->base;
-    z->count = z2->base + z2->count - z1->base;
-    z->flags = z1->flags & z2->flags;
-    z->free_count = z1->free_count + z2->free_count;
-    z->busy_count = z1->busy_count + z2->busy_count;
+    ASSERT(zone_flags_available(zones.info[z1].flags));
+    ASSERT(zone_flags_available(zones.info[z2].flags));
+    ASSERT(zones.info[z1].flags == zones.info[z2].flags);
+    ASSERT(zones.info[z1].base < zones.info[z2].base);
+    ASSERT(!overlaps(zones.info[z1].base, zones.info[z1].count,
+        zones.info[z2].base, zones.info[z2].count));
-    max_order = fnzb(z->count);
-    z->buddy_system = (buddy_system_t *) &z[1];
-    buddy_system_create(z->buddy_system, max_order,
-        &zone_buddy_system_operations, (void *) z);
-    z->frames = (frame_t *)((uint8_t *) z->buddy_system +
-        buddy_conf_size(max_order));
-    for (i = 0; i < z->count; i++) {
-        /* This marks all frames busy */
-        frame_initialize(&z->frames[i]);
-    }
+    /* Difference between zone bases */
+    pfn_t base_diff = zones.info[z2].base - zones.info[z1].base;
+    zones.info[z1].count = base_diff + zones.info[z2].count;
+    zones.info[z1].free_count += zones.info[z2].free_count;
+    zones.info[z1].busy_count += zones.info[z2].busy_count;
+    zones.info[z1].buddy_system = buddy;
+    uint8_t order = fnzb(zones.info[z1].count);
+    buddy_system_create(zones.info[z1].buddy_system, order,
+        &zone_buddy_system_operations, (void *) &zones.info[z1]);
+    zones.info[z1].frames =
+        (frame_t *) ((uint8_t *) zones.info[z1].buddy_system
+        + buddy_conf_size(order));
+    /* This marks all frames busy */
+    count_t i;
+    for (i = 0; i < zones.info[z1].count; i++)
+        frame_initialize(&zones.info[z1].frames[i]);
     /* Copy frames from both zones to preserve full frame orders,
-     * parents etc. Set all free frames with refcount=0 to 1, because
-     * we add all free frames to buddy allocator later again, clear
-     * order to 0. Don't set busy frames with refcount=0, as they
+     * parents etc. Set all free frames with refcount = 0 to 1, because
+     * we add all free frames to buddy allocator later again, clearing
+     * order to 0. Don't set busy frames with refcount = 0, as they
      * will not be reallocated during merge and it would make later
      * problems with allocation/free.
      */
-    for (i = 0; i < z1->count; i++)
-        z->frames[i] = z1->frames[i];
-    for (i = 0; i < z2->count; i++) {
-        z2idx = i + (z2->base - z1->base);
-        z->frames[z2idx] = z2->frames[i];
-    }
+    for (i = 0; i < old_z1->count; i++)
+        zones.info[z1].frames[i] = old_z1->frames[i];
+    for (i = 0; i < zones.info[z2].count; i++)
+        zones.info[z1].frames[base_diff + i]
+            = zones.info[z2].frames[i];
     i = 0;
-    while (i < z->count) {
-        if (z->frames[i].refcount) {
-            /* skip busy frames */
-            i += 1 << z->frames[i].buddy_order;
-        } else { /* Free frames, set refcount=1 */
-            /* All free frames have refcount=0, we need not
-             * to check the order */
-            z->frames[i].refcount = 1;
-            z->frames[i].buddy_order = 0;
+    while (i < zones.info[z1].count) {
+        if (zones.info[z1].frames[i].refcount) {
+            /* Skip busy frames */
+            i += 1 << zones.info[z1].frames[i].buddy_order;
+        } else {
+            /* Free frames, set refcount = 1
+             * (all free frames have refcount == 0, we need not
+             * to check the order)
+             */
+            zones.info[z1].frames[i].refcount = 1;
+            zones.info[z1].frames[i].buddy_order = 0;
             i++;
         }
     }
-    /* Add free blocks from the 2 original zones */
-    while (zone_can_alloc(z1, 0)) {
-        frame_idx = zone_frame_alloc(z1, 0);
-        frame = &z->frames[frame_idx];
+    /* Add free blocks from the original zone z1 */
+    while (zone_can_alloc(old_z1, 0)) {
+        /* Allocate from the original zone */
+        pfn_t frame_idx = zone_frame_alloc(old_z1, 0);
+        /* Free the frame from the merged zone */
+        frame_t *frame = &zones.info[z1].frames[frame_idx];
         frame->refcount = 0;
-        buddy_system_free(z->buddy_system, &frame->buddy_link);
+        buddy_system_free(zones.info[z1].buddy_system, &frame->buddy_link);
     }
-    while (zone_can_alloc(z2, 0)) {
-        frame_idx = zone_frame_alloc(z2, 0);
-        frame = &z->frames[frame_idx + (z2->base - z1->base)];
+    /* Add free blocks from the original zone z2 */
+    while (zone_can_alloc(&zones.info[z2], 0)) {
+        /* Allocate from the original zone */
+        pfn_t frame_idx = zone_frame_alloc(&zones.info[z2], 0);
+        /* Free the frame from the merged zone */
+        frame_t *frame = &zones.info[z1].frames[base_diff + frame_idx];
         frame->refcount = 0;
-        buddy_system_free(z->buddy_system, &frame->buddy_link);
+        buddy_system_free(zones.info[z1].buddy_system, &frame->buddy_link);
     }
 }
 /** Return old configuration frames into the zone.
  *
- * We have several cases
- * - the conf. data is outside of zone -> exit, shall we call frame_free??
- * - the conf. data was created by zone_create or
- *   updated with reduce_region -> free every frame
+ * We have two cases:
+ * - The configuration data is outside the zone
+ *   -> do nothing (perhaps call frame_free?)
+ * - The configuration data was created by zone_create
+ *   or updated by reduce_region -> free every frame
  *
- * @param newzone   The actual zone where freeing should occur.
- * @param oldzone   Pointer to old zone configuration data that should
- *          be freed from new zone.
+ * @param znum  The actual zone where freeing should occur.
+ * @param pfn   Old zone configuration frame.
+ * @param count Old zone frame count.
+ *
  */
-static void return_config_frames(zone_t *newzone, zone_t *oldzone)
+static void return_config_frames(count_t znum, pfn_t pfn, count_t count)
 {
-    pfn_t pfn;
-    frame_t *frame;
-    count_t cframes;
-    unsigned int i;
-    pfn = ADDR2PFN((uintptr_t)KA2PA(oldzone));
-    cframes = SIZE2FRAMES(zone_conf_size(oldzone->count));
+    ASSERT(zone_flags_available(zones.info[znum].flags));
-    if (pfn < newzone->base || pfn >= newzone->base + newzone->count)
+    count_t cframes = SIZE2FRAMES(zone_conf_size(count));
+    if ((pfn < zones.info[znum].base)
+        || (pfn >= zones.info[znum].base + zones.info[znum].count))
         return;
+    frame_t *frame __attribute__ ((unused));
-    frame = &newzone->frames[pfn - newzone->base];
+    frame = &zones.info[znum].frames[pfn - zones.info[znum].base];
     ASSERT(!frame->buddy_order);
+    count_t i;
     for (i = 0; i < cframes; i++) {
-        newzone->busy_count++;
-        zone_frame_free(newzone, pfn+i-newzone->base);
+        zones.info[znum].busy_count++;
+        zone_frame_free(&zones.info[znum],
+            pfn - zones.info[znum].base + i);
     }
 }
 /** Reduce allocated block to count of order 0 frames.
  *
- * The allocated block need 2^order frames of space. Reduce all frames
- * in block to order 0 and free the unneeded frames. This means, that
- * when freeing the previously allocated block starting with frame_idx,
+ * The allocated block needs 2^order frames. Reduce all frames
+ * in the block to order 0 and free the unneeded frames. This means that
+ * when freeing the previously allocated block starting with frame_idx,
  * you have to free every frame.
  *
- * @param zone
- * @param frame_idx     Index to block.
- * @param count         Allocated space in block.
+ * @param znum      Zone.
+ * @param frame_idx Index the first frame of the block.
+ * @param count     Allocated frames in block.
+ *
  */
-static void zone_reduce_region(zone_t *zone, pfn_t frame_idx, count_t count)
+static void zone_reduce_region(count_t znum, pfn_t frame_idx, count_t count)
 {
-    count_t i;
-    uint8_t order;
-    frame_t *frame;
+    ASSERT(zone_flags_available(zones.info[znum].flags));
+    ASSERT(frame_idx + count < zones.info[znum].count);
-    ASSERT(frame_idx + count < zone->count);
-    order = zone->frames[frame_idx].buddy_order;
+    uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;
     ASSERT((count_t) (1 << order) >= count);
     /* Reduce all blocks to order 0 */
+    count_t i;
     for (i = 0; i < (count_t) (1 << order); i++) {
-        frame = &zone->frames[i + frame_idx];
+        frame_t *frame = &zones.info[znum].frames[i + frame_idx];
         frame->buddy_order = 0;
         if (!frame->refcount)
             frame->refcount = 1;
         ASSERT(frame->refcount == 1);
     }
     /* Free unneeded frames */
-    for (i = count; i < (count_t) (1 << order); i++) {
-        zone_frame_free(zone, i + frame_idx);
-    }
+    for (i = count; i < (count_t) (1 << order); i++)
+        zone_frame_free(&zones.info[znum], i + frame_idx);
 }
 /** Merge zones z1 and z2.
  *
- * - the zones must be 2 zones with no zone existing in between,
- *   which means that z2 = z1+1
+ * The merged zones must be 2 zones with no zone existing in between
+ * (which means that z2 = z1 + 1). Both zones must be available zones
+ * with the same flags.
  *
- * - When you create a new zone, the frame allocator configuration does
- *   not to be 2^order size. Once the allocator is running it is no longer
- *   possible, merged configuration data occupies more space :-/
+ * When you create a new zone, the frame allocator configuration does
+ * not to be 2^order size. Once the allocator is running it is no longer
+ * possible, merged configuration data occupies more space :-/
+ *
+ * The function uses
+ *
  */
-void zone_merge(unsigned int z1, unsigned int z2)
+bool zone_merge(count_t z1, count_t z2)
 {
-    ipl_t ipl;
-    zone_t *zone1, *zone2, *newzone;
-    unsigned int cframes;
-    uint8_t order;
-    unsigned int i;
-    pfn_t pfn;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
-    if ((z1 >= zones.count) || (z2 >= zones.count))
+    bool ret = true;
+    /* We can join only 2 zones with none existing inbetween,
+     * the zones have to be available and with the same
+     * set of flags
+     */
+    if ((z1 >= zones.count) || (z2 >= zones.count)
+        || (z2 - z1 != 1)
+        || (!zone_flags_available(zones.info[z1].flags))
+        || (!zone_flags_available(zones.info[z2].flags))
+        || (zones.info[z1].flags != zones.info[z2].flags)) {
+        ret = false;
         goto errout;
-    /* We can join only 2 zones with none existing inbetween */
-    if (z2 - z1 != 1)
-        goto errout;
-    zone1 = zones.info[z1];
-    zone2 = zones.info[z2];
-    spinlock_lock(&zone1->lock);
-    spinlock_lock(&zone2->lock);
-    cframes = SIZE2FRAMES(zone_conf_size(zone2->base + zone2->count -
-        zone1->base));
+    }
+    pfn_t cframes = SIZE2FRAMES(zone_conf_size(
+        zones.info[z2].base - zones.info[z1].base
+        + zones.info[z2].count));
+    uint8_t order;
     if (cframes == 1)
         order = 0;
-    else
+    else
         order = fnzb(cframes - 1) + 1;
-    /* Allocate zonedata inside one of the zones */
-    if (zone_can_alloc(zone1, order))
-        pfn = zone1->base + zone_frame_alloc(zone1, order);
-    else if (zone_can_alloc(zone2, order))
-        pfn = zone2->base + zone_frame_alloc(zone2, order);
-    else
-        goto errout2;
-    newzone = (zone_t *) PA2KA(PFN2ADDR(pfn));
-    _zone_merge(newzone, zone1, zone2);
+    /* Allocate merged zone data inside one of the zones */
+    pfn_t pfn;
+    if (zone_can_alloc(&zones.info[z1], order)) {
+        pfn = zones.info[z1].base + zone_frame_alloc(&zones.info[z1], order);
+    } else if (zone_can_alloc(&zones.info[z2], order)) {
+        pfn = zones.info[z2].base + zone_frame_alloc(&zones.info[z2], order);
+    } else {
+        ret = false;
+        goto errout;
+    }
+    /* Preserve original data from z1 */
+    zone_t old_z1 = zones.info[z1];
+    old_z1.buddy_system->data = (void *) &old_z1;
+    /* Do zone merging */
+    buddy_system_t *buddy = (buddy_system_t *) PA2KA(PFN2ADDR(pfn));
+    zone_merge_internal(z1, z2, &old_z1, buddy);
     /* Free unneeded config frames */
-    zone_reduce_region(newzone, pfn - newzone->base,  cframes);
+    zone_reduce_region(z1, pfn - zones.info[z1].base, cframes);
     /* Subtract zone information from busy frames */
-    newzone->busy_count -= cframes;
-    /* Replace existing zones in zoneinfo list */
-    zones.info[z1] = newzone;
-    for (i = z2 + 1; i < zones.count; i++)
+    zones.info[z1].busy_count -= cframes;
+    /* Free old zone information */
+    return_config_frames(z1,
+        ADDR2PFN(KA2PA((uintptr_t) old_z1.frames)), old_z1.count);
+    return_config_frames(z1,
+        ADDR2PFN(KA2PA((uintptr_t) zones.info[z2].frames)),
+        zones.info[z2].count);
+    /* Move zones down */
+    count_t i;
+    for (i = z2 + 1; i < zones.count; i++) {
         zones.info[i - 1] = zones.info[i];
+        zones.info[i - 1].buddy_system->data =
+            (void *) &zones.info[i - 1];
+    }
     zones.count--;
-    /* Free old zone information */
-    return_config_frames(newzone, zone1);
-    return_config_frames(newzone, zone2);
-errout2:
-    /* Nobody is allowed to enter to zone, so we are safe
-     * to touch the spinlocks last time */
-    spinlock_unlock(&zone1->lock);
-    spinlock_unlock(&zone2->lock);
 errout:
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    return ret;
 }
-/** Merge all zones into one big zone.
+/** Merge all mergeable zones into one big zone.
  *
- * It is reasonable to do this on systems whose bios reports parts in chunks,
- * so that we could have 1 zone (it's faster).
+ * It is reasonable to do this on systems where
+ * BIOS reports parts in chunks, so that we could
+ * have 1 zone (it's faster).
+ *
  */
 void zone_merge_all(void)
 {
-    int count = zones.count;
-    while (zones.count > 1 && --count) {
-        zone_merge(0, 1);
-        break;
+    count_t i = 0;
+    while (i < zones.count) {
+        if (!zone_merge(i, i + 1))
+            i++;
     }
 }
 /** Create new frame zone.
  *
- * @param start     Physical address of the first frame within the zone.
- * @param count     Count of frames in zone.
- * @param z     Address of configuration information of zone.
- * @param flags     Zone flags.
+ * @param zone  Zone to construct.
+ * @param buddy Address of buddy system configuration information.
+ * @param start Physical address of the first frame within the zone.
+ * @param count Count of frames in zone.
+ * @param flags Zone flags.
  *
- * @return      Initialized zone.
+ * @return Initialized zone.
+ *
  */
-static void zone_construct(pfn_t start, count_t count, zone_t *z, int flags)
+static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, count_t count, zone_flags_t flags)
 {
-    unsigned int i;
-    uint8_t max_order;
-    spinlock_initialize(&z->lock, "zone_lock");
-    z->base = start;
-    z->count = count;
-    /* Mask off flags that are calculated automatically. */
-    flags &= ~FRAME_LOW_4_GiB;
-    /* Determine calculated flags. */
-    if (z->base + count < (1ULL << (32 - FRAME_WIDTH))) /* 4 GiB */
-        flags |= FRAME_LOW_4_GiB;
-    z->flags = flags;
-    z->free_count = count;
-    z->busy_count = 0;
-    /*
-     * Compute order for buddy system, initialize
-     */
-    max_order = fnzb(count);
-    z->buddy_system = (buddy_system_t *)&z[1];
+    zone->base = start;
+    zone->count = count;
+    zone->flags = flags;
+    zone->free_count = count;
+    zone->busy_count = 0;
+    zone->buddy_system = buddy;
-    buddy_system_create(z->buddy_system, max_order,
-        &zone_buddy_system_operations, (void *) z);
-    /* Allocate frames _after_ the conframe */
-    /* Check sizes */
-    z->frames = (frame_t *)((uint8_t *) z->buddy_system +
-        buddy_conf_size(max_order));
-    for (i = 0; i < count; i++) {
-        frame_initialize(&z->frames[i]);
-    }
-    /* Stuffing frames */
-    for (i = 0; i < count; i++) {
-        z->frames[i].refcount = 0;
-        buddy_system_free(z->buddy_system, &z->frames[i].buddy_link);
-    }
+    if (zone_flags_available(flags)) {
+        /*
+         * Compute order for buddy system and initialize
+         */
+        uint8_t order = fnzb(count);
+        buddy_system_create(zone->buddy_system, order,
+            &zone_buddy_system_operations, (void *) zone);
+        /* Allocate frames _after_ the confframe */
+        /* Check sizes */
+        zone->frames = (frame_t *) ((uint8_t *) zone->buddy_system +
+            buddy_conf_size(order));
+        count_t i;
+        for (i = 0; i < count; i++)
+            frame_initialize(&zone->frames[i]);
+        /* Stuffing frames */
+        for (i = 0; i < count; i++) {
+            zone->frames[i].refcount = 0;
+            buddy_system_free(zone->buddy_system, &zone->frames[i].buddy_link);
+        }
+    } else
+        zone->frames = NULL;
 }
 /** Compute configuration data size for zone.
  *
- * @param count     Size of zone in frames.
- * @return      Size of zone configuration info (in bytes).
+ * @param count Size of zone in frames.
+ *
+ * @return Size of zone configuration info (in bytes).
+ *
  */
 uintptr_t zone_conf_size(count_t count)
 {
-    int size = sizeof(zone_t) + count * sizeof(frame_t);
-    int max_order;
-    max_order = fnzb(count);
-    size += buddy_conf_size(max_order);
-    return size;
+    return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
 }
 /** Create and add zone to system.
  *
- * @param start     First frame number (absolute).
- * @param count     Size of zone in frames.
- * @param confframe Where configuration frames are supposed to be.
- *          Automatically checks, that we will not disturb the
- *          kernel and possibly init.  If confframe is given
- *          _outside_ this zone, it is expected, that the area is
- *          already marked BUSY and big enough to contain
- *          zone_conf_size() amount of data.  If the confframe is
- *          inside the area, the zone free frame information is
- *          modified not to include it.
+ * @param start     First frame number (absolute).
+ * @param count     Size of zone in frames.
+ * @param confframe Where configuration frames are supposed to be.
+ *                  Automatically checks, that we will not disturb the
+ *                  kernel and possibly init. If confframe is given
+ *                  _outside_ this zone, it is expected, that the area is
+ *                  already marked BUSY and big enough to contain
+ *                  zone_conf_size() amount of data. If the confframe is
+ *                  inside the area, the zone free frame information is
+ *                  modified not to include it.
  *
- * @return      Zone number or -1 on error.
+ * @return Zone number or -1 on error.
+ *
  */
-int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags)
+count_t zone_create(pfn_t start, count_t count, pfn_t confframe, zone_flags_t flags)
 {
-    zone_t *z;
-    uintptr_t addr;
-    count_t confcount;
-    unsigned int i;
-    int znum;
-    /* Theoretically we could have here 0, practically make sure
-     * nobody tries to do that. If some platform requires, remove
-     * the assert
-     */
-    ASSERT(confframe);
-    /* If conframe is supposed to be inside our zone, then make sure
-     * it does not span kernel & init
-     */
-    confcount = SIZE2FRAMES(zone_conf_size(count));
-    if (confframe >= start && confframe < start + count) {
-        for (; confframe < start + count; confframe++) {
-            addr = PFN2ADDR(confframe);
-            if (overlaps(addr, PFN2ADDR(confcount),
-                KA2PA(config.base), config.kernel_size))
-                continue;
-            if (overlaps(addr, PFN2ADDR(confcount),
-                KA2PA(config.stack_base), config.stack_size))
-                continue;
-            bool overlap = false;
-            count_t i;
-            for (i = 0; i < init.cnt; i++)
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
+    if (zone_flags_available(flags)) {  /* Create available zone */
+        /* Theoretically we could have NULL here, practically make sure
+         * nobody tries to do that. If some platform requires, remove
+         * the assert
+         */
+        ASSERT(confframe != NULL);
+        /* If confframe is supposed to be inside our zone, then make sure
+         * it does not span kernel & init
+         */
+        count_t confcount = SIZE2FRAMES(zone_conf_size(count));
+        if ((confframe >= start) && (confframe < start + count)) {
+            for (; confframe < start + count; confframe++) {
+                uintptr_t addr = PFN2ADDR(confframe);
                 if (overlaps(addr, PFN2ADDR(confcount),
-                    KA2PA(init.tasks[i].addr),
-                    init.tasks[i].size)) {
-                    overlap = true;
-                    break;
-                }
-            if (overlap)
-                continue;
+                    KA2PA(config.base), config.kernel_size))
+                    continue;
+                if (overlaps(addr, PFN2ADDR(confcount),
+                    KA2PA(config.stack_base), config.stack_size))
+                    continue;
+                bool overlap = false;
+                count_t i;
+                for (i = 0; i < init.cnt; i++)
+                    if (overlaps(addr, PFN2ADDR(confcount),
+                        KA2PA(init.tasks[i].addr),
+                        init.tasks[i].size)) {
+                        overlap = true;
+                        break;
+                    }
+                if (overlap)
+                    continue;
+                break;
+            }
-            break;
+            if (confframe >= start + count)
+                panic("Cannot find configuration data for zone.");
         }
-        if (confframe >= start + count)
-            panic("Cannot find configuration data for zone.");
+        count_t znum = zones_insert_zone(start, count);
+        if (znum == (count_t) -1) {
+            spinlock_unlock(&zones.lock);
+            interrupts_restore(ipl);
+            return (count_t) -1;
+        }
+        buddy_system_t *buddy = (buddy_system_t *) PA2KA(PFN2ADDR(confframe));
+        zone_construct(&zones.info[znum], buddy, start, count, flags);
+        /* If confdata in zone, mark as unavailable */
+        if ((confframe >= start) && (confframe < start + count)) {
+            count_t i;
+            for (i = confframe; i < confframe + confcount; i++)
+                zone_mark_unavailable(&zones.info[znum],
+                    i - zones.info[znum].base);
+        }
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        return znum;
     }
-    z = (zone_t *) PA2KA(PFN2ADDR(confframe));
-    zone_construct(start, count, z, flags);
-    znum = zones_add_zone(z);
-    if (znum == -1)
-        return -1;
-    mutex_lock(&mem_avail_mtx);
-    mem_avail_frames += count;
-    mutex_unlock(&mem_avail_mtx);
-    /* If confdata in zone, mark as unavailable */
-    if (confframe >= start && confframe < start + count)
-        for (i = confframe; i < confframe + confcount; i++) {
-            zone_mark_unavailable(z, i - z->base);
-        }
+    /* Non-available zone */
+    count_t znum = zones_insert_zone(start, count);
+    if (znum == (count_t) -1) {
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        return (count_t) -1;
+    }
+    zone_construct(&zones.info[znum], NULL, start, count, flags);
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
     return znum;
 }
-/***************************************/
+/*******************/
 /* Frame functions */
+/*******************/
 /** Set parent of frame. */
-void frame_set_parent(pfn_t pfn, void *data, unsigned int hint)
+void frame_set_parent(pfn_t pfn, void *data, count_t hint)
 {
-    zone_t *zone = find_zone_and_lock(pfn, &hint);
-    ASSERT(zone);
-    zone_get_frame(zone, pfn - zone->base)->parent = data;
-    spinlock_unlock(&zone->lock);
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
+    count_t znum = find_zone(pfn, 1, hint);
+    ASSERT(znum != (count_t) -1);
+    zone_get_frame(&zones.info[znum],
+        pfn - zones.info[znum].base)->parent = data;
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
 }
-void *frame_get_parent(pfn_t pfn, unsigned int hint)
+void *frame_get_parent(pfn_t pfn, count_t hint)
 {
-    zone_t *zone = find_zone_and_lock(pfn, &hint);
-    void *res;
-    ASSERT(zone);
-    res = zone_get_frame(zone, pfn - zone->base)->parent;
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
-    spinlock_unlock(&zone->lock);
+    count_t znum = find_zone(pfn, 1, hint);
+    ASSERT(znum != (count_t) -1);
+    void *res = zone_get_frame(&zones.info[znum],
+        pfn - zones.info[znum].base)->parent;
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
     return res;
 }
 /** Allocate power-of-two frames of physical memory.
  *
- * @param order     Allocate exactly 2^order frames.
- * @param flags     Flags for host zone selection and address processing.
- * @param pzone     Preferred zone.
+ * @param order Allocate exactly 2^order frames.
+ * @param flags Flags for host zone selection and address processing.
+ * @param pzone Preferred zone.
  *
- * @return      Physical address of the allocated frame.
+ * @return Physical address of the allocated frame.
  *
  */
-void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone)
+void *frame_alloc_generic(uint8_t order, frame_flags_t flags, count_t *pzone)
 {
+    count_t size = ((count_t) 1) << order;
     ipl_t ipl;
-    int freed;
-    pfn_t v;
-    zone_t *zone;
-    unsigned long gen = 0;
+    count_t hint = pzone ? (*pzone) : 0;
 loop:
     ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
     /*
      * First, find suitable frame zone.
      */
-    zone = find_free_zone_and_lock(order, flags, pzone);
+    count_t znum = find_free_zone(order,
+        FRAME_TO_ZONE_FLAGS(flags), hint);
     /* If no memory, reclaim some slab memory,
        if it does not help, reclaim all */
-    if (!zone && !(flags & FRAME_NO_RECLAIM)) {
-        freed = slab_reclaim(0);
-        if (freed)
-            zone = find_free_zone_and_lock(order, flags, pzone);
-        if (!zone) {
+    if ((znum == (count_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
+        count_t freed = slab_reclaim(0);
+        if (freed > 0)
+            znum = find_free_zone(order,
+                FRAME_TO_ZONE_FLAGS(flags), hint);
+        if (znum == (count_t) -1) {
             freed = slab_reclaim(SLAB_RECLAIM_ALL);
-            if (freed)
-                zone = find_free_zone_and_lock(order, flags,
-                    pzone);
+            if (freed > 0)
+                znum = find_free_zone(order,
+                    FRAME_TO_ZONE_FLAGS(flags), hint);
         }
     }
-    if (!zone) {
-        /*
-         * Sleep until some frames are available again.
-         */
+    if (znum == (count_t) -1) {
         if (flags & FRAME_ATOMIC) {
+            spinlock_unlock(&zones.lock);
             interrupts_restore(ipl);
-            return 0;
+            return NULL;
         }
 #ifdef CONFIG_DEBUG
-        unsigned long avail;
-        mutex_lock(&mem_avail_mtx);
-        avail = mem_avail_frames;
-        mutex_unlock(&mem_avail_mtx);
-        printf("Thread %" PRIu64 " waiting for %u frames, "
-            "%u available.\n", THREAD->tid, 1ULL << order, avail);
+        count_t avail = total_frames_free();
 #endif
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        /*
+         * Sleep until some frames are available again.
+         */
+#ifdef CONFIG_DEBUG
+        printf("Thread %" PRIu64 " waiting for %" PRIc " frames, "
+            "%" PRIc " available.\n", THREAD->tid, size, avail);
+#endif
         mutex_lock(&mem_avail_mtx);
-        while ((mem_avail_frames < (1ULL << order)) ||
-            gen == mem_avail_gen)
+        if (mem_avail_req > 0)
+            mem_avail_req = min(mem_avail_req, size);
+        else
+            mem_avail_req = size;
+        count_t gen = mem_avail_gen;
+        while (gen == mem_avail_gen)
             condvar_wait(&mem_avail_cv, &mem_avail_mtx);
-        gen = mem_avail_gen;
         mutex_unlock(&mem_avail_mtx);
 #ifdef CONFIG_DEBUG
-        mutex_lock(&mem_avail_mtx);
-        avail = mem_avail_frames;
-        mutex_unlock(&mem_avail_mtx);
-        printf("Thread %" PRIu64 " woken up, %u frames available.\n",
-            THREAD->tid, avail);
+        printf("Thread %" PRIu64 " woken up.\n", THREAD->tid);
 #endif
-        interrupts_restore(ipl);
         goto loop;
     }
-    v = zone_frame_alloc(zone, order);
-    v += zone->base;
-    spinlock_unlock(&zone->lock);
+    pfn_t pfn = zone_frame_alloc(&zones.info[znum], order)
+        + zones.info[znum].base;
-    mutex_lock(&mem_avail_mtx);
-    mem_avail_frames -= (1ULL << order);
-    mutex_unlock(&mem_avail_mtx);
+    spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    if (pzone)
+        *pzone = znum;
     if (flags & FRAME_KA)
-        return (void *)PA2KA(PFN2ADDR(v));
-    return (void *)PFN2ADDR(v);
+        return (void *) PA2KA(PFN2ADDR(pfn));
+    return (void *) PFN2ADDR(pfn);
 }
 /** Free a frame.
  *
  * Find respective frame structure for supplied physical frame address.
- * Decrement frame reference count.
- * If it drops to zero, move the frame structure to free list.
+ * Decrement frame reference count. If it drops to zero, move the frame
+ * structure to free list.
  *
- * @param frame     Physical Address of of the frame to be freed.
+ * @param frame Physical Address of of the frame to be freed.
+ *
  */
 void frame_free(uintptr_t frame)
 {
-    ipl_t ipl;
-    zone_t *zone;
-    pfn_t pfn = ADDR2PFN(frame);
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
     /*
      * First, find host frame zone for addr.
      */
-    zone = find_zone_and_lock(pfn, NULL);
-    ASSERT(zone);
+    pfn_t pfn = ADDR2PFN(frame);
+    count_t znum = find_zone(pfn, 1, NULL);
-    zone_frame_free(zone, pfn - zone->base);
+    ASSERT(znum != (count_t) -1);
-    spinlock_unlock(&zone->lock);
+    zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
     /*
      * Signal that some memory has been freed.
      */
     mutex_lock(&mem_avail_mtx);
-    mem_avail_frames++;
-    mem_avail_gen++;
-    condvar_broadcast(&mem_avail_cv);
+    if (mem_avail_req > 0)
+        mem_avail_req--;
+    if (mem_avail_req == 0) {
+        mem_avail_gen++;
+        condvar_broadcast(&mem_avail_cv);
+    }
     mutex_unlock(&mem_avail_mtx);
-    interrupts_restore(ipl);
 }
 /** Add reference to frame.
 ,26 → 1110,24
  * Find respective frame structure for supplied PFN and
  * increment frame reference count.
  *
- * @param pfn       Frame number of the frame to be freed.
+ * @param pfn Frame number of the frame to be freed.
+ *
  */
 void frame_reference_add(pfn_t pfn)
 {
-    ipl_t ipl;
-    zone_t *zone;
-    frame_t *frame;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
     /*
      * First, find host frame zone for addr.
      */
-    zone = find_zone_and_lock(pfn, NULL);
-    ASSERT(zone);
+    count_t znum = find_zone(pfn, 1, NULL);
-    frame = &zone->frames[pfn - zone->base];
-    frame->refcount++;
+    ASSERT(znum != (count_t) -1);
-    spinlock_unlock(&zone->lock);
+    zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
+    spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
 }
 ,18 → 1134,21
 /** Mark given range unavailable in frame zones. */
 void frame_mark_unavailable(pfn_t start, count_t count)
 {
-    unsigned int i;
-    zone_t *zone;
-    unsigned int prefzone = 0;
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&zones.lock);
+    count_t i;
     for (i = 0; i < count; i++) {
-        zone = find_zone_and_lock(start + i, &prefzone);
-        if (!zone) /* PFN not found */
+        count_t znum = find_zone(start + i, 1, 0);
+        if (znum == (count_t) -1)  /* PFN not found */
             continue;
-        zone_mark_unavailable(zone, start + i - zone->base);
-        spinlock_unlock(&zone->lock);
+        zone_mark_unavailable(&zones.info[znum],
+            start + i - zones.info[znum].base);
     }
+    spinlock_unlock(&zones.lock);
+    interrupts_restore(ipl);
 }
 /** Initialize physical memory management. */
 ,6 → 1160,7
         mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
         condvar_initialize(&mem_avail_cv);
     }
     /* Tell the architecture to create some memory */
     frame_arch_init();
     if (config.cpu_active == 1) {
 ,35 → 1175,28
             frame_mark_unavailable(pfn,
                 SIZE2FRAMES(init.tasks[i].size));
         }
         if (ballocs.size)
             frame_mark_unavailable(ADDR2PFN(KA2PA(ballocs.base)),
                 SIZE2FRAMES(ballocs.size));
         /* Black list first frame, as allocating NULL would
-         * fail in some places */
+         * fail in some places
+         */
         frame_mark_unavailable(0, 1);
     }
 }
 /** Return total size of all zones. */
 uint64_t zone_total_size(void)
 {
-    zone_t *zone = NULL;
-    unsigned int i;
-    ipl_t ipl;
-    uint64_t total = 0;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
-    for (i = 0; i < zones.count; i++) {
-        zone = zones.info[i];
-        spinlock_lock(&zone->lock);
-        total += (uint64_t) FRAMES2SIZE(zone->count);
-        spinlock_unlock(&zone->lock);
-    }
+    uint64_t total = 0;
+    count_t i;
+    for (i = 0; i < zones.count; i++)
+        total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
 ,18 → 1207,14
 /** Prints list of zones. */
 void zone_print_list(void)
 {
-    zone_t *zone = NULL;
-    unsigned int i;
-    ipl_t ipl;
-#ifdef __32_BITS__
-    printf("#  base address free frames  busy frames\n");
-    printf("-- ------------ ------------ ------------\n");
+#ifdef __32_BITS__
+    printf("#  base address frames       flags    free frames  busy frames\n");
+    printf("-- ------------ ------------ -------- ------------ ------------\n");
 #endif
 #ifdef __64_BITS__
-    printf("#  base address         free frames  busy frames\n");
-    printf("-- -------------------- ------------ ------------\n");
+    printf("#  base address          frames      flags    free frames  busy frames\n");
+    printf("-- -------------------- ------------ -------- ------------ ------------\n");
 #endif
     /*
 ,13 → 1227,10
      * we may end up with inaccurate output (e.g. a zone being skipped from
      * the listing).
      */
-    for (i = 0; ; i++) {
-        uintptr_t base;
-        count_t free_count;
-        count_t busy_count;
-        ipl = interrupts_disable();
+    count_t i;
+    for (i = 0;; i++) {
+        ipl_t ipl = interrupts_disable();
         spinlock_lock(&zones.lock);
         if (i >= zones.count) {
 ,56 → 1238,61
             interrupts_restore(ipl);
             break;
         }
-        zone = zones.info[i];
-        spinlock_lock(&zone->lock);
-        base = PFN2ADDR(zone->base);
-        free_count = zone->free_count;
-        busy_count = zone->busy_count;
-        spinlock_unlock(&zone->lock);
+        uintptr_t base = PFN2ADDR(zones.info[i].base);
+        count_t count = zones.info[i].count;
+        zone_flags_t flags = zones.info[i].flags;
+        count_t free_count = zones.info[i].free_count;
+        count_t busy_count = zones.info[i].busy_count;
         spinlock_unlock(&zones.lock);
         interrupts_restore(ipl);
+        bool available = zone_flags_available(flags);
+        printf("%-2" PRIc, i);
 #ifdef __32_BITS__
-        printf("%-2u   %10p %12" PRIc " %12" PRIc "\n", i, base,
-            free_count, busy_count);
+        printf("   %10p", base);
 #endif
 #ifdef __64_BITS__
-        printf("%-2u   %18p %12" PRIc " %12" PRIc "\n", i, base,
-            free_count, busy_count);
+        printf("   %18p", base);
 #endif
+        printf(" %12" PRIc " %c%c%c      ", count,
+            available ? 'A' : ' ',
+            (flags & ZONE_RESERVED) ? 'R' : ' ',
+            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+        if (available)
+            printf("%12" PRIc " %12" PRIc,
+                free_count, busy_count);
+        printf("\n");
     }
 }
 /** Prints zone details.
  *
- * @param num       Zone base address or zone number.
+ * @param num Zone base address or zone number.
+ *
  */
-void zone_print_one(unsigned int num)
+void zone_print_one(count_t num)
 {
-    zone_t *zone = NULL;
-    ipl_t ipl;
-    unsigned int i;
-    uintptr_t base;
-    count_t count;
-    count_t busy_count;
-    count_t free_count;
-    ipl = interrupts_disable();
+    ipl_t ipl = interrupts_disable();
     spinlock_lock(&zones.lock);
+    count_t znum = (count_t) -1;
+    count_t i;
     for (i = 0; i < zones.count; i++) {
-        if ((i == num) || (PFN2ADDR(zones.info[i]->base) == num)) {
-            zone = zones.info[i];
+        if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) {
+            znum = i;
             break;
         }
     }
-    if (!zone) {
+    if (znum == (count_t) -1) {
         spinlock_unlock(&zones.lock);
         interrupts_restore(ipl);
         printf("Zone not found.\n");
 ,24 → 1299,33
         return;
     }
-    spinlock_lock(&zone->lock);
-    base = PFN2ADDR(zone->base);
-    count = zone->count;
-    busy_count = zone->busy_count;
-    free_count = zone->free_count;
-    spinlock_unlock(&zone->lock);
+    uintptr_t base = PFN2ADDR(zones.info[i].base);
+    zone_flags_t flags = zones.info[i].flags;
+    count_t count = zones.info[i].count;
+    count_t free_count = zones.info[i].free_count;
+    count_t busy_count = zones.info[i].busy_count;
     spinlock_unlock(&zones.lock);
     interrupts_restore(ipl);
+    bool available = zone_flags_available(flags);
+    printf("Zone number:       %" PRIc "\n", znum);
     printf("Zone base address: %p\n", base);
-    printf("Zone size: %" PRIc " frames (%" PRIs " KiB)\n", count,
+    printf("Zone size:         %" PRIc " frames (%" PRIs " KiB)\n", count,
         SIZE2KB(FRAMES2SIZE(count)));
-    printf("Allocated space: %" PRIc " frames (%" PRIs " KiB)\n",
-        busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
-    printf("Available space: %" PRIc " frames (%" PRIs " KiB)\n",
-        free_count, SIZE2KB(FRAMES2SIZE(free_count)));
+    printf("Zone flags:        %c%c%c\n",
+        available ? 'A' : ' ',
+        (flags & ZONE_RESERVED) ? 'R' : ' ',
+        (flags & ZONE_FIRMWARE) ? 'F' : ' ');
+    if (available) {
+        printf("Allocated space:   %" PRIc " frames (%" PRIs " KiB)\n",
+            busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
+        printf("Available space:   %" PRIc " frames (%" PRIs " KiB)\n",
+            free_count, SIZE2KB(FRAMES2SIZE(free_count)));
+    }
 }
 /** @}
  */

 /branches/network/kernel/generic/src/mm/backend_elf.c
 ,7 → 129,7
             page_mapping_insert(AS, addr, frame,
                 as_area_get_flags(area));
             if (!used_space_insert(area, page, 1))
-                panic("Could not insert used space.\n");
+                panic("Cannot insert used space.");
             mutex_unlock(&area->sh_info->lock);
             return AS_PF_OK;
         }
 ,7 → 214,7
     page_mapping_insert(AS, addr, frame, as_area_get_flags(area));
     if (!used_space_insert(area, page, 1))
-        panic("Could not insert used space.\n");
+        panic("Cannot insert used space.");
     return AS_PF_OK;
 }

 /branches/network/kernel/generic/src/syscall/syscall.c
 ,9 → 32,9
 /**
  * @file
- * @brief   Syscall table and syscall wrappers.
+ * @brief Syscall table and syscall wrappers.
  */
 #include <syscall/syscall.h>
 #include <proc/thread.h>
 #include <proc/task.h>
 ,76 → 42,50
 #include <mm/as.h>
 #include <print.h>
 #include <putchar.h>
-#include <errno.h>
 #include <arch.h>
 #include <debug.h>
+#include <ddi/device.h>
 #include <ipc/sysipc.h>
 #include <synch/futex.h>
 #include <synch/smc.h>
 #include <ddi/ddi.h>
 #include <security/cap.h>
-#include <syscall/copy.h>
 #include <sysinfo/sysinfo.h>
 #include <console/console.h>
+#include <udebug/udebug.h>
-/** Print using kernel facility
- *
- * Print to kernel log.
- *
- */
-static unative_t sys_klog(int fd, const void * buf, size_t count)
-{
-    size_t i;
-    char *data;
-    int rc;
-    if (count > PAGE_SIZE)
-        return ELIMIT;
-    if (count > 0) {
-        data = (char *) malloc(count, 0);
-        if (!data)
-            return ENOMEM;
-        rc = copy_from_uspace(data, buf, count);
-        if (rc) {
-            free(data);
-            return rc;
-        }
-        for (i = 0; i < count; i++)
-            putchar(data[i]);
-        free(data);
-    } else
-        klog_update();
-    return count;
-}
-/** Tell kernel to get keyboard/console access again */
-static unative_t sys_debug_enable_console(void)
-{
-    arch_grab_console();
-    return 0;
-}
 /** Dispatch system call */
 unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
     unative_t a4, unative_t a5, unative_t a6, unative_t id)
 {
     unative_t rc;
-    if (id < SYSCALL_END)
+#ifdef CONFIG_UDEBUG
+    udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
+#endif
+    if (id < SYSCALL_END) {
         rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
-    else {
+    } else {
         printf("Task %" PRIu64": Unknown syscall %#" PRIxn, TASK->taskid, id);
         task_kill(TASK->taskid);
         thread_exit();
     }
     if (THREAD->interrupted)
         thread_exit();
+#ifdef CONFIG_UDEBUG
+    udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, rc, true);
+    /*
+     * Stopping point needed for tasks that only invoke non-blocking
+     * system calls.
+     */
+    udebug_stoppable_begin();
+    udebug_stoppable_end();
+#endif
     return rc;
 }
 ,6 → 99,7
     (syshandler_t) sys_thread_get_id,
     (syshandler_t) sys_task_get_id,
+    (syshandler_t) sys_task_set_name,
     (syshandler_t) sys_program_spawn_loader,
     /* Synchronization related syscalls. */
 ,6 → 121,7
     (syshandler_t) sys_ipc_answer_fast,
     (syshandler_t) sys_ipc_answer_slow,
     (syshandler_t) sys_ipc_forward_fast,
+    (syshandler_t) sys_ipc_forward_slow,
     (syshandler_t) sys_ipc_wait_for_call,
     (syshandler_t) sys_ipc_hangup,
     (syshandler_t) sys_ipc_register_irq,
 ,6 → 132,7
     (syshandler_t) sys_cap_revoke,
     /* DDI related syscalls. */
+    (syshandler_t) sys_device_assign_devno,
     (syshandler_t) sys_physmem_map,
     (syshandler_t) sys_iospace_enable,
     (syshandler_t) sys_preempt_control,
 ,7 → 142,10
     (syshandler_t) sys_sysinfo_value,
     /* Debug calls */
-    (syshandler_t) sys_debug_enable_console
+    (syshandler_t) sys_debug_enable_console,
+    (syshandler_t) sys_debug_disable_console,
+    (syshandler_t) sys_ipc_connect_kbox
 };
 /** @}

 /branches/network/kernel/generic/src/ipc/kbox.c
 ,0 → 1,284
+/*
+ * 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
+ */
+#include <synch/synch.h>
+#include <synch/spinlock.h>
+#include <synch/mutex.h>
+#include <ipc/ipc.h>
+#include <ipc/ipcrsc.h>
+#include <arch.h>
+#include <errno.h>
+#include <debug.h>
+#include <udebug/udebug_ipc.h>
+#include <ipc/kbox.h>
+#include <print.h>
+void ipc_kbox_cleanup(void)
+{
+    ipl_t ipl;
+    bool have_kb_thread;
+    /*
+     * Only hold kb.cleanup_lock while setting kb.finished -
+     * this is enough.
+     */
+    mutex_lock(&TASK->kb.cleanup_lock);
+    TASK->kb.finished = true;
+    mutex_unlock(&TASK->kb.cleanup_lock);
+    have_kb_thread = (TASK->kb.thread != NULL);
+    /*
+     * From now on nobody will try to connect phones or attach
+     * kbox threads
+     */
+    /*
+     * Disconnect all phones connected to our kbox. Passing true for
+     * notify_box causes a HANGUP message to be inserted for each
+     * disconnected phone. This ensures the kbox thread is going to
+     * wake up and terminate.
+     */
+    ipc_answerbox_slam_phones(&TASK->kb.box, have_kb_thread);
+    /*
+     * If the task was being debugged, clean up debugging session.
+     * This is necessarry as slamming the phones won't force
+     * kbox thread to clean it up since sender != debugger.
+     */
+    ipl = interrupts_disable();
+    spinlock_lock(&TASK->lock);
+    udebug_task_cleanup(TASK);
+    spinlock_unlock(&TASK->lock);
+    interrupts_restore(ipl);
+    if (have_kb_thread) {
+        LOG("join kb.thread..\n");
+        thread_join(TASK->kb.thread);
+        thread_detach(TASK->kb.thread);
+        LOG("join done\n");
+        TASK->kb.thread = NULL;
+    }
+    /* Answer all messages in 'calls' and 'dispatched_calls' queues. */
+    spinlock_lock(&TASK->kb.box.lock);
+    ipc_cleanup_call_list(&TASK->kb.box.dispatched_calls);
+    ipc_cleanup_call_list(&TASK->kb.box.calls);
+    spinlock_unlock(&TASK->kb.box.lock);
+}
+/** Handle hangup message in kbox.
+ *
+ * @param call  The IPC_M_PHONE_HUNGUP call structure.
+ * @param last  Output, the function stores @c true here if
+ *      this was the last phone, @c false otherwise.
+ **/
+static void kbox_proc_phone_hungup(call_t *call, bool *last)
+{
+    ipl_t ipl;
+    LOG("kbox_proc_phone_hungup()\n");
+    /* Was it our debugger, who hung up? */
+    if (call->sender == TASK->udebug.debugger) {
+        /* Terminate debugging session (if any). */
+        LOG("kbox: terminate debug session\n");
+        ipl = interrupts_disable();
+        spinlock_lock(&TASK->lock);
+        udebug_task_cleanup(TASK);
+        spinlock_unlock(&TASK->lock);
+        interrupts_restore(ipl);
+    } else {
+        LOG("kbox: was not debugger\n");
+    }
+    LOG("kbox: continue with hangup message\n");
+    IPC_SET_RETVAL(call->data, 0);
+    ipc_answer(&TASK->kb.box, call);
+    ipl = interrupts_disable();
+    spinlock_lock(&TASK->lock);
+    spinlock_lock(&TASK->kb.box.lock);
+    if (list_empty(&TASK->kb.box.connected_phones)) {
+        /*
+         * Last phone has been disconnected. Detach this thread so it
+         * gets freed and signal to the caller.
+         */
+        /* Only detach kbox thread unless already terminating. */
+        mutex_lock(&TASK->kb.cleanup_lock);
+        if (&TASK->kb.finished == false) {
+            /* Detach kbox thread so it gets freed from memory. */
+            thread_detach(TASK->kb.thread);
+            TASK->kb.thread = NULL;
+        }
+        mutex_unlock(&TASK->kb.cleanup_lock);
+        LOG("phone list is empty\n");
+        *last = true;
+    } else {
+        *last = false;
+    }
+    spinlock_unlock(&TASK->kb.box.lock);
+    spinlock_unlock(&TASK->lock);
+    interrupts_restore(ipl);
+}
+/** Implementing function for the kbox thread.
+ *
+ * This function listens for debug requests. It terminates
+ * when all phones are disconnected from the kbox.
+ *
+ * @param arg   Ignored.
+ */
+static void kbox_thread_proc(void *arg)
+{
+    call_t *call;
+    bool done;
+    (void)arg;
+    LOG("kbox_thread_proc()\n");
+    done = false;
+    while (!done) {
+        call = ipc_wait_for_call(&TASK->kb.box, SYNCH_NO_TIMEOUT,
+            SYNCH_FLAGS_NONE);
+        if (call == NULL)
+            continue;   /* Try again. */
+        switch (IPC_GET_METHOD(call->data)) {
+        case IPC_M_DEBUG_ALL:
+            /* Handle debug call. */
+            udebug_call_receive(call);
+            break;
+        case IPC_M_PHONE_HUNGUP:
+            /*
+             * Process the hangup call. If this was the last
+             * phone, done will be set to true and the
+             * while loop will terminate.
+             */
+            kbox_proc_phone_hungup(call, &done);
+            break;
+        default:
+            /* Ignore */
+            break;
+        }
+    }
+    LOG("kbox: finished\n");
+}
+/**
+ * Connect phone to a task kernel-box specified by id.
+ *
+ * Note that this is not completely atomic. For optimisation reasons, the task
+ * might start cleaning up kbox after the phone has been connected and before
+ * a kbox thread has been created. This must be taken into account in the
+ * cleanup code.
+ *
+ * @return      Phone id on success, or negative error code.
+ */
+int ipc_connect_kbox(task_id_t taskid)
+{
+    int newphid;
+    task_t *ta;
+    thread_t *kb_thread;
+    ipl_t ipl;
+    ipl = interrupts_disable();
+    spinlock_lock(&tasks_lock);
+    ta = task_find_by_id(taskid);
+    if (ta == NULL) {
+        spinlock_unlock(&tasks_lock);
+        interrupts_restore(ipl);
+        return ENOENT;
+    }
+    atomic_inc(&ta->refcount);
+    spinlock_unlock(&tasks_lock);
+    interrupts_restore(ipl);
+    mutex_lock(&ta->kb.cleanup_lock);
+    if (atomic_predec(&ta->refcount) == 0) {
+        mutex_unlock(&ta->kb.cleanup_lock);
+        task_destroy(ta);
+        return ENOENT;
+    }
+    if (ta->kb.finished != false) {
+        mutex_unlock(&ta->kb.cleanup_lock);
+        return EINVAL;
+    }
+    newphid = phone_alloc();
+    if (newphid < 0) {
+        mutex_unlock(&ta->kb.cleanup_lock);
+        return ELIMIT;
+    }
+    /* Connect the newly allocated phone to the kbox */
+    ipc_phone_connect(&TASK->phones[newphid], &ta->kb.box);
+    if (ta->kb.thread != NULL) {
+        mutex_unlock(&ta->kb.cleanup_lock);
+        return newphid;
+    }
+    /* Create a kbox thread */
+    kb_thread = thread_create(kbox_thread_proc, NULL, ta, 0,
+        "kbox", false);
+    if (!kb_thread) {
+        mutex_unlock(&ta->kb.cleanup_lock);
+        return ENOMEM;
+    }
+    ta->kb.thread = kb_thread;
+    thread_ready(kb_thread);
+    mutex_unlock(&ta->kb.cleanup_lock);
+    return newphid;
+}
+/** @}
+ */

 /branches/network/kernel/generic/src/ipc/sysipc.c
 ,8 → 42,9
 #include <ipc/sysipc.h>
 #include <ipc/irq.h>
 #include <ipc/ipcrsc.h>
+#include <ipc/kbox.h>
+#include <udebug/udebug_ipc.h>
 #include <arch/interrupt.h>
-#include <print.h>
 #include <syscall/copy.h>
 #include <security/cap.h>
 #include <mm/as.h>
 ,10 → 296,11
 /** Called before the request is sent.
  *
  * @param call      Call structure with the request.
+ * @param phone     Phone that the call will be sent through.
  *
  * @return      Return 0 on success, ELIMIT or EPERM on error.
  */
-static int request_preprocess(call_t *call)
+static int request_preprocess(call_t *call, phone_t *phone)
 {
     int newphid;
     size_t size;
 ,6 → 342,10
             return rc;
         }
         break;
+#ifdef CONFIG_UDEBUG
+    case IPC_M_DEBUG_ALL:
+        return udebug_request_preprocess(call, phone);
+#endif
     default:
         break;
     }
 ,6 → 375,7
     if (call->buffer) {
         /* This must be an affirmative answer to IPC_M_DATA_READ. */
+        /* or IPC_M_DEBUG_ALL/UDEBUG_M_MEM_READ... */
         uintptr_t dst = IPC_GET_ARG1(call->data);
         size_t size = IPC_GET_ARG2(call->data);
         int rc = copy_to_uspace((void *) dst, call->buffer, size);
 ,7 → 406,13
             return -1;
         }
         IPC_SET_ARG5(call->data, phoneid);
-    }
+    }
+    switch (IPC_GET_METHOD(call->data)) {
+    case IPC_M_DEBUG_ALL:
+        return -1;
+    default:
+        break;
+    }
     return 0;
 }
 ,11 → 454,18
     IPC_SET_ARG4(call.data, 0);
     IPC_SET_ARG5(call.data, 0);
-    if (!(res = request_preprocess(&call))) {
+    if (!(res = request_preprocess(&call, phone))) {
+#ifdef CONFIG_UDEBUG
+        udebug_stoppable_begin();
+#endif
         rc = ipc_call_sync(phone, &call);
+#ifdef CONFIG_UDEBUG
+        udebug_stoppable_end();
+#endif
         if (rc != EOK)
             return rc;
         process_answer(&call);
     } else {
         IPC_SET_RETVAL(call.data, res);
     }
 ,8 → 501,14
     GET_CHECK_PHONE(phone, phoneid, return ENOENT);
-    if (!(res = request_preprocess(&call))) {
+    if (!(res = request_preprocess(&call, phone))) {
+#ifdef CONFIG_UDEBUG
+        udebug_stoppable_begin();
+#endif
         rc = ipc_call_sync(phone, &call);
+#ifdef CONFIG_UDEBUG
+        udebug_stoppable_end();
+#endif
         if (rc != EOK)
             return rc;
         process_answer(&call);
 ,7 → 576,7
      */
     IPC_SET_ARG5(call->data, 0);
-    if (!(res = request_preprocess(call)))
+    if (!(res = request_preprocess(call, phone)))
         ipc_call(phone, call);
     else
         ipc_backsend_err(phone, call, res);
 ,7 → 610,7
         ipc_call_free(call);
         return (unative_t) rc;
     }
-    if (!(res = request_preprocess(call)))
+    if (!(res = request_preprocess(call, phone)))
         ipc_call(phone, call);
     else
         ipc_backsend_err(phone, call, res);
 ,7 → 618,8
     return (unative_t) call;
 }
-/** Forward a received call to another destination.
+/** Forward a received call to another destination - common code for both the
+ * fast and the slow version.
  *
  * @param callid    Hash of the call to forward.
  * @param phoneid   Phone handle to use for forwarding.
 ,23 → 626,21
  * @param method    New method to use for the forwarded call.
  * @param arg1      New value of the first argument for the forwarded call.
  * @param arg2      New value of the second argument for the forwarded call.
+ * @param arg3      New value of the third argument for the forwarded call.
+ * @param arg4      New value of the fourth argument for the forwarded call.
+ * @param arg5      New value of the fifth argument for the forwarded call.
  * @param mode      Flags that specify mode of the forward operation.
+ * @param slow      If true, arg3, arg4 and arg5 are considered. Otherwise
+ *          the function considers only the fast version arguments:
+ *          i.e. arg1 and arg2.
  *
  * @return      Return 0 on succes, otherwise return an error code.
  *
- * In case the original method is a system method, ARG1, ARG2 and ARG3 are
- * overwritten in the forwarded message with the new method and the new arg1 and
- * arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are rewritten with
- * the new method, arg1 and arg2, respectively. Also note there is a set of
- * immutable methods, for which the new method and argument is not set and
- * these values are ignored.
- *
- * Warning: When implementing support for changing additional payload
- *      arguments, make sure that ARG5 is not rewritten for certain
- *      system IPC
+ * Warning: Make sure that ARG5 is not rewritten for certain system IPC
  */
-unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
-    unative_t method, unative_t arg1, unative_t arg2, int mode)
+static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
+    unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
+    unative_t arg4, unative_t arg5, int mode, bool slow)
 {
     call_t *call;
     phone_t *phone;
 ,7 → 648,7
     call = get_call(callid);
     if (!call)
         return ENOENT;
     call->flags |= IPC_CALL_FORWARDED;
     GET_CHECK_PHONE(phone, phoneid, {
 ,8 → 665,8
     /*
      * Userspace is not allowed to change method of system methods on
-     * forward, allow changing ARG1, ARG2 and ARG3 by means of method,
-     * arg1 and arg2.
+     * forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
+     * arg1, arg2 and arg3.
      * If the method is immutable, don't change anything.
      */
     if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
 ,10 → 677,22
             IPC_SET_ARG1(call->data, method);
             IPC_SET_ARG2(call->data, arg1);
             IPC_SET_ARG3(call->data, arg2);
+            if (slow) {
+                IPC_SET_ARG4(call->data, arg3);
+                /*
+                 * For system methods we deliberately don't
+                 * overwrite ARG5.
+                 */
+            }
         } else {
             IPC_SET_METHOD(call->data, method);
             IPC_SET_ARG1(call->data, arg1);
             IPC_SET_ARG2(call->data, arg2);
+            if (slow) {
+                IPC_SET_ARG3(call->data, arg3);
+                IPC_SET_ARG4(call->data, arg4);
+                IPC_SET_ARG5(call->data, arg5);
+            }
         }
     }
 ,6 → 699,64
     return ipc_forward(call, phone, &TASK->answerbox, mode);
 }
+/** Forward a received call to another destination - fast version.
+ *
+ * @param callid    Hash of the call to forward.
+ * @param phoneid   Phone handle to use for forwarding.
+ * @param method    New method to use for the forwarded call.
+ * @param arg1      New value of the first argument for the forwarded call.
+ * @param arg2      New value of the second argument for the forwarded call.
+ * @param mode      Flags that specify mode of the forward operation.
+ *
+ * @return      Return 0 on succes, otherwise return an error code.
+ *
+ * In case the original method is a system method, ARG1, ARG2 and ARG3 are
+ * overwritten in the forwarded message with the new method and the new
+ * arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
+ * rewritten with the new method, arg1 and arg2, respectively. Also note there
+ * is a set of immutable methods, for which the new method and arguments are not
+ * set and these values are ignored.
+ */
+unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
+    unative_t method, unative_t arg1, unative_t arg2, int mode)
+{
+    return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
+, mode, false);
+}
+/** Forward a received call to another destination - slow version.
+ *
+ * @param callid    Hash of the call to forward.
+ * @param phoneid   Phone handle to use for forwarding.
+ * @param data      Userspace address of the new IPC data.
+ * @param mode      Flags that specify mode of the forward operation.
+ *
+ * @return      Return 0 on succes, otherwise return an error code.
+ *
+ * This function is the slow verision of the sys_ipc_forward_fast interface.
+ * It can copy all five new arguments and the new method from the userspace.
+ * It naturally extends the functionality of the fast version. For system
+ * methods, it additionally stores the new value of arg3 to ARG4. For non-system
+ * methods, it additionally stores the new value of arg3, arg4 and arg5,
+ * respectively, to ARG3, ARG4 and ARG5, respectively.
+ */
+unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+    ipc_data_t *data, int mode)
+{
+    ipc_data_t newdata;
+    int rc;
+    rc = copy_from_uspace(&newdata.args, &data->args,
+        sizeof(newdata.args));
+    if (rc != 0)
+        return (unative_t) rc;
+    return sys_ipc_forward_common(callid, phoneid,
+        IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
+        IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
+        IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true);
+}
 /** Answer an IPC call - fast version.
  *
  * This function can handle only two return arguments of payload, but is faster
 ,9 → 880,17
 {
     call_t *call;
-restart:
+restart:
+#ifdef CONFIG_UDEBUG
+    udebug_stoppable_begin();
+#endif
     call = ipc_wait_for_call(&TASK->answerbox, usec,
         flags | SYNCH_FLAGS_INTERRUPTIBLE);
+#ifdef CONFIG_UDEBUG
+    udebug_stoppable_end();
+#endif
     if (!call)
         return 0;
 ,11 → 912,16
         ASSERT(! (call->flags & IPC_CALL_STATIC_ALLOC));
-        atomic_dec(&TASK->active_calls);
         if (call->flags & IPC_CALL_DISCARD_ANSWER) {
             ipc_call_free(call);
             goto restart;
+        } else {
+            /*
+             * Decrement the counter of active calls only if the
+             * call is not an answer to IPC_M_PHONE_HUNGUP,
+             * which doesn't contribute to the counter.
+             */
+            atomic_dec(&TASK->active_calls);
         }
         STRUCT_TO_USPACE(&calldata->args, &call->data.args);
 ,6 → 936,21
     /* Include phone address('id') of the caller in the request,
      * copy whole call->data, not only call->data.args */
     if (STRUCT_TO_USPACE(calldata, &call->data)) {
+        /*
+         * The callee will not receive this call and no one else has
+         * a chance to answer it. Reply with the EPARTY error code.
+         */
+        ipc_data_t saved_data;
+        int saveddata = 0;
+        if (answer_need_old(call)) {
+            memcpy(&saved_data, &call->data, sizeof(call->data));
+            saveddata = 1;
+        }
+        IPC_SET_RETVAL(call->data, EPARTY);
+        (void) answer_preprocess(call, saveddata ? &saved_data : NULL);
+        ipc_answer(&TASK->answerbox, call);
         return 0;
     }
     return (unative_t)call;
 ,5 → 991,30
     return 0;
 }
+#include <console/console.h>
+/**
+ * Syscall connect to a task by id.
+ *
+ * @return      Phone id on success, or negative error code.
+ */
+unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
+{
+#ifdef CONFIG_UDEBUG
+    sysarg64_t taskid_arg;
+    int rc;
+    rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
+    if (rc != 0)
+        return (unative_t) rc;
+    LOG("sys_ipc_connect_kbox(%" PRIu64 ")\n", taskid_arg.value);
+    return ipc_connect_kbox(taskid_arg.value);
+#else
+    return (unative_t) ENOTSUP;
+#endif
+}
 /** @}
  */

 /branches/network/kernel/generic/src/ipc/ipc.c
 ,6 → 43,7
 #include <synch/waitq.h>
 #include <synch/synch.h>
 #include <ipc/ipc.h>
+#include <ipc/kbox.h>
 #include <errno.h>
 #include <mm/slab.h>
 #include <arch.h>
 ,6 → 52,7
 #include <debug.h>
 #include <print.h>
+#include <console/console.h>
 #include <proc/thread.h>
 #include <arch/interrupt.h>
 #include <ipc/irq.h>
 ,9 → 203,9
     call->flags |= IPC_CALL_ANSWERED;
     if (call->flags & IPC_CALL_FORWARDED) {
-        if (call->data.caller_phone) {
+        if (call->caller_phone) {
             /* Demasquerade the caller phone. */
-            call->data.phone = call->data.caller_phone;
+            call->data.phone = call->caller_phone;
         }
     }
 ,8 → 362,8
     spinlock_unlock(&oldbox->lock);
     if (mode & IPC_FF_ROUTE_FROM_ME) {
-        if (!call->data.caller_phone)
-            call->data.caller_phone = call->data.phone;
+        if (!call->caller_phone)
+            call->caller_phone = call->data.phone;
         call->data.phone = newphone;
     }
 ,7 → 429,7
  *
  * @param lst       Head of the list to be cleaned up.
  */
-static void ipc_cleanup_call_list(link_t *lst)
+void ipc_cleanup_call_list(link_t *lst)
 {
     call_t *call;
 ,33 → 444,31
     }
 }
-/** Cleans up all IPC communication of the current task.
+/** Disconnects all phones connected to an answerbox.
  *
- * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
- * have to change it as well if you want to cleanup other tasks than TASK.
+ * @param box       Answerbox to disconnect phones from.
+ * @param notify_box    If true, the answerbox will get a hangup message for
+ *          each disconnected phone.
  */
-void ipc_cleanup(void)
+void ipc_answerbox_slam_phones(answerbox_t *box, bool notify_box)
 {
-    int i;
-    call_t *call;
     phone_t *phone;
     DEADLOCK_PROBE_INIT(p_phonelck);
+    ipl_t ipl;
+    call_t *call;
-    /* Disconnect all our phones ('ipc_phone_hangup') */
-    for (i = 0; i < IPC_MAX_PHONES; i++)
-        ipc_phone_hangup(&TASK->phones[i]);
+    call = notify_box ? ipc_call_alloc(0) : NULL;
-    /* Disconnect all connected irqs */
-    ipc_irq_cleanup(&TASK->answerbox);
     /* Disconnect all phones connected to our answerbox */
 restart_phones:
-    spinlock_lock(&TASK->answerbox.lock);
-    while (!list_empty(&TASK->answerbox.connected_phones)) {
-        phone = list_get_instance(TASK->answerbox.connected_phones.next,
+    ipl = interrupts_disable();
+    spinlock_lock(&box->lock);
+    while (!list_empty(&box->connected_phones)) {
+        phone = list_get_instance(box->connected_phones.next,
             phone_t, link);
         if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
-            spinlock_unlock(&TASK->answerbox.lock);
+            spinlock_unlock(&box->lock);
+            interrupts_restore(ipl);
             DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
             goto restart_phones;
         }
 ,13 → 475,70
         /* Disconnect phone */
         ASSERT(phone->state == IPC_PHONE_CONNECTED);
+        list_remove(&phone->link);
         phone->state = IPC_PHONE_SLAMMED;
-        list_remove(&phone->link);
+        if (notify_box) {
+            mutex_unlock(&phone->lock);
+            spinlock_unlock(&box->lock);
+            interrupts_restore(ipl);
+            /*
+             * Send one message to the answerbox for each
+             * phone. Used to make sure the kbox thread
+             * wakes up after the last phone has been
+             * disconnected.
+             */
+            IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
+            call->flags |= IPC_CALL_DISCARD_ANSWER;
+            _ipc_call(phone, box, call);
+            /* Allocate another call in advance */
+            call = ipc_call_alloc(0);
+            /* Must start again */
+            goto restart_phones;
+        }
         mutex_unlock(&phone->lock);
     }
+    spinlock_unlock(&box->lock);
+    interrupts_restore(ipl);
+    /* Free unused call */
+    if (call)
+        ipc_call_free(call);
+}
+/** Cleans up all IPC communication of the current task.
+ *
+ * Note: ipc_hangup sets returning answerbox to TASK->answerbox, you
+ * have to change it as well if you want to cleanup other tasks than TASK.
+ */
+void ipc_cleanup(void)
+{
+    int i;
+    call_t *call;
+    /* Disconnect all our phones ('ipc_phone_hangup') */
+    for (i = 0; i < IPC_MAX_PHONES; i++)
+        ipc_phone_hangup(&TASK->phones[i]);
+    /* Disconnect all connected irqs */
+    ipc_irq_cleanup(&TASK->answerbox);
+    /* Disconnect all phones connected to our regular answerbox */
+    ipc_answerbox_slam_phones(&TASK->answerbox, false);
+#ifdef CONFIG_UDEBUG
+    /* Clean up kbox thread and communications */
+    ipc_kbox_cleanup();
+#endif
     /* Answer all messages in 'calls' and 'dispatched_calls' queues */
+    spinlock_lock(&TASK->answerbox.lock);
     ipc_cleanup_call_list(&TASK->answerbox.dispatched_calls);
     ipc_cleanup_call_list(&TASK->answerbox.calls);
     spinlock_unlock(&TASK->answerbox.lock);
 ,7 → 574,13
             (call->flags & IPC_CALL_NOTIF));
         ASSERT(!(call->flags & IPC_CALL_STATIC_ALLOC));
-        atomic_dec(&TASK->active_calls);
+        /*
+         * Record the receipt of this call in the current task's counter
+         * of active calls. IPC_M_PHONE_HUNGUP calls do not contribute
+         * to this counter so do not record answers to them either.
+         */
+        if (!(call->flags & IPC_CALL_DISCARD_ANSWER))
+            atomic_dec(&TASK->active_calls);
         ipc_call_free(call);
     }
 }
 ,8 → 655,9
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
+            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
+            call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
 ,8 → 670,9
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid: %p Srctask:%" PRIu64 " M:%" PRIun
-            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
-            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call, call->sender->taskid,
+            " A1:%" PRIun " A2:%" PRIun " A3:%" PRIun
+            " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
+            call->sender->taskid,
             IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
 ,11 → 680,12
     }
     /* Print answerbox - calls */
     printf("ABOX - ANSWERS:\n");
-    for (tmp = task->answerbox.answers.next; tmp != &task->answerbox.answers;
+    for (tmp = task->answerbox.answers.next;
+        tmp != &task->answerbox.answers;
         tmp = tmp->next) {
         call = list_get_instance(tmp, call_t, link);
         printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
-            " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
+            " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
             call, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
             IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
             IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),

 /branches/network/kernel/generic/src/ipc/irq.c
 ,8 → 44,28
  * - ARG1: payload modified by a 'top-half' handler
  * - ARG2: payload modified by a 'top-half' handler
  * - ARG3: payload modified by a 'top-half' handler
+ * - ARG4: payload modified by a 'top-half' handler
+ * - ARG5: payload modified by a 'top-half' handler
  * - in_phone_hash: interrupt counter (may be needed to assure correct order
  *         in multithreaded drivers)
+ *
+ * Note on synchronization for ipc_irq_register(), ipc_irq_unregister(),
+ * ipc_irq_cleanup() and IRQ handlers:
+ *
+ *   By always taking all of the uspace IRQ hash table lock, IRQ structure lock
+ *   and answerbox lock, we can rule out race conditions between the
+ *   registration functions and also the cleanup function. Thus the observer can
+ *   either see the IRQ structure present in both the hash table and the
+ *   answerbox list or absent in both. Views in which the IRQ structure would be
+ *   linked in the hash table but not in the answerbox list, or vice versa, are
+ *   not possible.
+ *
+ *   By always taking the hash table lock and the IRQ structure lock, we can
+ *   rule out a scenario in which we would free up an IRQ structure, which is
+ *   still referenced by, for example, an IRQ handler. The locking scheme forces
+ *   us to lock the IRQ structure only after any progressing IRQs on that
+ *   structure are finished. Because we hold the hash table lock, we prevent new
+ *   IRQs from taking new references to the IRQ structure.
  */
 #include <arch.h>
 ,78 → 78,8
 #include <console/console.h>
 #include <print.h>
-/** Execute code associated with IRQ notification.
+/** Free the top-half pseudocode.
  *
- * @param call      Notification call.
- * @param code      Top-half pseudocode.
- */
-static void code_execute(call_t *call, irq_code_t *code)
-{
-    unsigned int i;
-    unative_t dstval = 0;
-    if (!code)
-        return;
-    for (i = 0; i < code->cmdcount; i++) {
-        switch (code->cmds[i].cmd) {
-        case CMD_MEM_READ_1:
-            dstval = *((uint8_t *) code->cmds[i].addr);
-            break;
-        case CMD_MEM_READ_2:
-            dstval = *((uint16_t *) code->cmds[i].addr);
-            break;
-        case CMD_MEM_READ_4:
-            dstval = *((uint32_t *) code->cmds[i].addr);
-            break;
-        case CMD_MEM_READ_8:
-            dstval = *((uint64_t *) code->cmds[i].addr);
-            break;
-        case CMD_MEM_WRITE_1:
-            *((uint8_t *) code->cmds[i].addr) = code->cmds[i].value;
-            break;
-        case CMD_MEM_WRITE_2:
-            *((uint16_t *) code->cmds[i].addr) =
-                code->cmds[i].value;
-            break;
-        case CMD_MEM_WRITE_4:
-            *((uint32_t *) code->cmds[i].addr) =
-                code->cmds[i].value;
-            break;
-        case CMD_MEM_WRITE_8:
-            *((uint64_t *) code->cmds[i].addr) =
-                code->cmds[i].value;
-            break;
-#if defined(ia32) || defined(amd64)
-        case CMD_PORT_READ_1:
-            dstval = inb((long) code->cmds[i].addr);
-            break;
-        case CMD_PORT_WRITE_1:
-            outb((long) code->cmds[i].addr, code->cmds[i].value);
-            break;
-#endif
-#if defined(ia64) && defined(SKI)
-        case CMD_IA64_GETCHAR:
-            dstval = _getc(&ski_uconsole);
-            break;
-#endif
-#if defined(ppc32)
-        case CMD_PPC32_GETCHAR:
-            dstval = cuda_get_scancode();
-            break;
-#endif
-        default:
-            break;
-        }
-        if (code->cmds[i].dstarg && code->cmds[i].dstarg <
-            IPC_CALL_LEN) {
-            call->data.args[code->cmds[i].dstarg] = dstval;
-        }
-    }
-}
-/** Free top-half pseudocode.
- *
  * @param code      Pointer to the top-half pseudocode.
  */
 static void code_free(irq_code_t *code)
 ,7 → 90,7
     }
 }
-/** Copy top-half pseudocode from userspace into the kernel.
+/** Copy the top-half pseudocode from userspace into the kernel.
  *
  * @param ucode     Userspace address of the top-half pseudocode.
  *
 ,38 → 126,6
     return code;
 }
-/** Unregister task from IRQ notification.
- *
- * @param box       Answerbox associated with the notification.
- * @param inr       IRQ number.
- * @param devno     Device number.
- */
-void ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
-{
-    ipl_t ipl;
-    irq_t *irq;
-    ipl = interrupts_disable();
-    irq = irq_find_and_lock(inr, devno);
-    if (irq) {
-        if (irq->notif_cfg.answerbox == box) {
-            code_free(irq->notif_cfg.code);
-            irq->notif_cfg.notify = false;
-            irq->notif_cfg.answerbox = NULL;
-            irq->notif_cfg.code = NULL;
-            irq->notif_cfg.method = 0;
-            irq->notif_cfg.counter = 0;
-            spinlock_lock(&box->irq_lock);
-            list_remove(&irq->notif_cfg.link);
-            spinlock_unlock(&box->irq_lock);
-            spinlock_unlock(&irq->lock);
-        }
-    }
-    interrupts_restore(ipl);
-}
 /** Register an answerbox as a receiving end for IRQ notifications.
  *
  * @param box       Receiving answerbox.
 ,6 → 142,10
     ipl_t ipl;
     irq_code_t *code;
     irq_t *irq;
+    unative_t key[] = {
+        (unative_t) inr,
+        (unative_t) devno
+    };
     if (ucode) {
         code = code_from_uspace(ucode);
 ,21 → 155,15
         code = NULL;
     }
-    ipl = interrupts_disable();
-    irq = irq_find_and_lock(inr, devno);
-    if (!irq) {
-        interrupts_restore(ipl);
-        code_free(code);
-        return ENOENT;
-    }
-    if (irq->notif_cfg.answerbox) {
-        spinlock_unlock(&irq->lock);
-        interrupts_restore(ipl);
-        code_free(code);
-        return EEXISTS;
-    }
+    /*
+     * Allocate and populate the IRQ structure.
+     */
+    irq = malloc(sizeof(irq_t), 0);
+    irq_initialize(irq);
+    irq->devno = devno;
+    irq->inr = inr;
+    irq->claim = ipc_irq_top_half_claim;
+    irq->handler = ipc_irq_top_half_handler;
     irq->notif_cfg.notify = true;
     irq->notif_cfg.answerbox = box;
     irq->notif_cfg.method = method;
 ,14 → 170,140
     irq->notif_cfg.code = code;
     irq->notif_cfg.counter = 0;
+    /*
+     * Enlist the IRQ structure in the uspace IRQ hash table and the
+     * answerbox's list.
+     */
+    ipl = interrupts_disable();
+    spinlock_lock(&irq_uspace_hash_table_lock);
+    spinlock_lock(&irq->lock);
     spinlock_lock(&box->irq_lock);
+    if (hash_table_find(&irq_uspace_hash_table, key)) {
+        code_free(code);
+        spinlock_unlock(&box->irq_lock);
+        spinlock_unlock(&irq->lock);
+        spinlock_unlock(&irq_uspace_hash_table_lock);
+        free(irq);
+        interrupts_restore(ipl);
+        return EEXISTS;
+    }
+    hash_table_insert(&irq_uspace_hash_table, key, &irq->link);
     list_append(&irq->notif_cfg.link, &box->irq_head);
     spinlock_unlock(&box->irq_lock);
+    spinlock_unlock(&irq->lock);
+    spinlock_unlock(&irq_uspace_hash_table_lock);
+    interrupts_restore(ipl);
+    return EOK;
+}
+/** Unregister task from IRQ notification.
+ *
+ * @param box       Answerbox associated with the notification.
+ * @param inr       IRQ number.
+ * @param devno     Device number.
+ */
+int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
+{
+    ipl_t ipl;
+    unative_t key[] = {
+        (unative_t) inr,
+        (unative_t) devno
+    };
+    link_t *lnk;
+    irq_t *irq;
+    ipl = interrupts_disable();
+    spinlock_lock(&irq_uspace_hash_table_lock);
+    lnk = hash_table_find(&irq_uspace_hash_table, key);
+    if (!lnk) {
+        spinlock_unlock(&irq_uspace_hash_table_lock);
+        interrupts_restore(ipl);
+        return ENOENT;
+    }
+    irq = hash_table_get_instance(lnk, irq_t, link);
+    spinlock_lock(&irq->lock);
+    spinlock_lock(&box->irq_lock);
+    ASSERT(irq->notif_cfg.answerbox == box);
+    /* Free up the pseudo code and associated structures. */
+    code_free(irq->notif_cfg.code);
+    /* Remove the IRQ from the answerbox's list. */
+    list_remove(&irq->notif_cfg.link);
+    /* Remove the IRQ from the uspace IRQ hash table. */
+    hash_table_remove(&irq_uspace_hash_table, key, 2);
+    spinlock_unlock(&irq_uspace_hash_table_lock);
     spinlock_unlock(&irq->lock);
+    spinlock_unlock(&box->irq_lock);
+    /* Free up the IRQ structure. */
+    free(irq);
     interrupts_restore(ipl);
+    return EOK;
+}
-    return 0;
+/** Disconnect all IRQ notifications from an answerbox.
+ *
+ * This function is effective because the answerbox contains
+ * list of all irq_t structures that are registered to
+ * send notifications to it.
+ *
+ * @param box       Answerbox for which we want to carry out the cleanup.
+ */
+void ipc_irq_cleanup(answerbox_t *box)
+{
+    ipl_t ipl;
+loop:
+    ipl = interrupts_disable();
+    spinlock_lock(&irq_uspace_hash_table_lock);
+    spinlock_lock(&box->irq_lock);
+    while (box->irq_head.next != &box->irq_head) {
+        link_t *cur = box->irq_head.next;
+        irq_t *irq;
+        DEADLOCK_PROBE_INIT(p_irqlock);
+        unative_t key[2];
+        irq = list_get_instance(cur, irq_t, notif_cfg.link);
+        if (!spinlock_trylock(&irq->lock)) {
+            /*
+             * Avoid deadlock by trying again.
+             */
+            spinlock_unlock(&box->irq_lock);
+            spinlock_unlock(&irq_uspace_hash_table_lock);
+            interrupts_restore(ipl);
+            DEADLOCK_PROBE(p_irqlock, DEADLOCK_THRESHOLD);
+            goto loop;
+        }
+        key[0] = irq->inr;
+        key[1] = irq->devno;
+        ASSERT(irq->notif_cfg.answerbox == box);
+        /* Unlist from the answerbox. */
+        list_remove(&irq->notif_cfg.link);
+        /* Remove from the hash table. */
+        hash_table_remove(&irq_uspace_hash_table, key, 2);
+        /* Free up the pseudo code and associated structures. */
+        code_free(irq->notif_cfg.code);
+        spinlock_unlock(&irq->lock);
+        free(irq);
+    }
+    spinlock_unlock(&box->irq_lock);
+    spinlock_unlock(&irq_uspace_hash_table_lock);
+    interrupts_restore(ipl);
 }
 /** Add a call to the proper answerbox queue.
 ,125 → 322,158
     waitq_wakeup(&irq->notif_cfg.answerbox->wq, WAKEUP_FIRST);
 }
-/** Send notification message.
+/** Apply the top-half pseudo code to find out whether to accept the IRQ or not.
  *
  * @param irq       IRQ structure.
- * @param a1        Driver-specific payload argument.
- * @param a2        Driver-specific payload argument.
- * @param a3        Driver-specific payload argument.
- * @param a4        Driver-specific payload argument.
- * @param a5        Driver-specific payload argument.
+ *
+ * @return      IRQ_ACCEPT if the interrupt is accepted by the
+ *          pseudocode. IRQ_DECLINE otherwise.
  */
-void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3,
-    unative_t a4, unative_t a5)
+irq_ownership_t ipc_irq_top_half_claim(irq_t *irq)
 {
-    call_t *call;
+    unsigned int i;
+    unative_t dstval;
+    irq_code_t *code = irq->notif_cfg.code;
+    unative_t *scratch = irq->notif_cfg.scratch;
-    spinlock_lock(&irq->lock);
-    if (irq->notif_cfg.answerbox) {
-        call = ipc_call_alloc(FRAME_ATOMIC);
-        if (!call) {
-            spinlock_unlock(&irq->lock);
-            return;
+    if (!irq->notif_cfg.notify)
+        return IRQ_DECLINE;
+    if (!code)
+        return IRQ_DECLINE;
+    for (i = 0; i < code->cmdcount; i++) {
+        unsigned int srcarg = code->cmds[i].srcarg;
+        unsigned int dstarg = code->cmds[i].dstarg;
+        if (srcarg >= IPC_CALL_LEN)
+            break;
+        if (dstarg >= IPC_CALL_LEN)
+            break;
+        switch (code->cmds[i].cmd) {
+        case CMD_PIO_READ_8:
+            dstval = pio_read_8((ioport8_t *) code->cmds[i].addr);
+            if (dstarg)
+                scratch[dstarg] = dstval;
+            break;
+        case CMD_PIO_READ_16:
+            dstval = pio_read_16((ioport16_t *) code->cmds[i].addr);
+            if (dstarg)
+                scratch[dstarg] = dstval;
+            break;
+        case CMD_PIO_READ_32:
+            dstval = pio_read_32((ioport32_t *) code->cmds[i].addr);
+            if (dstarg)
+                scratch[dstarg] = dstval;
+            break;
+        case CMD_PIO_WRITE_8:
+            pio_write_8((ioport8_t *) code->cmds[i].addr,
+                (uint8_t) code->cmds[i].value);
+            break;
+        case CMD_PIO_WRITE_16:
+            pio_write_16((ioport16_t *) code->cmds[i].addr,
+                (uint16_t) code->cmds[i].value);
+            break;
+        case CMD_PIO_WRITE_32:
+            pio_write_32((ioport32_t *) code->cmds[i].addr,
+                (uint32_t) code->cmds[i].value);
+            break;
+        case CMD_BTEST:
+            if (srcarg && dstarg) {
+                dstval = scratch[srcarg] & code->cmds[i].value;
+                scratch[dstarg] = dstval;
+            }
+            break;
+        case CMD_PREDICATE:
+            if (srcarg && !scratch[srcarg]) {
+                i += code->cmds[i].value;
+                continue;
+            }
+            break;
+        case CMD_ACCEPT:
+            return IRQ_ACCEPT;
+            break;
+        case CMD_DECLINE:
+        default:
+            return IRQ_DECLINE;
         }
-        call->flags |= IPC_CALL_NOTIF;
-        IPC_SET_METHOD(call->data, irq->notif_cfg.method);
-        IPC_SET_ARG1(call->data, a1);
-        IPC_SET_ARG2(call->data, a2);
-        IPC_SET_ARG3(call->data, a3);
-        IPC_SET_ARG4(call->data, a4);
-        IPC_SET_ARG5(call->data, a5);
-        /* Put a counter to the message */
-        call->priv = ++irq->notif_cfg.counter;
-        send_call(irq, call);
     }
-    spinlock_unlock(&irq->lock);
+    return IRQ_DECLINE;
 }
-/** Notify a task that an IRQ had occurred.
+/* IRQ top-half handler.
  *
  * We expect interrupts to be disabled and the irq->lock already held.
  *
  * @param irq       IRQ structure.
  */
-void ipc_irq_send_notif(irq_t *irq)
+void ipc_irq_top_half_handler(irq_t *irq)
 {
-    call_t *call;
     ASSERT(irq);
     if (irq->notif_cfg.answerbox) {
+        call_t *call;
         call = ipc_call_alloc(FRAME_ATOMIC);
-        if (!call) {
+        if (!call)
             return;
-        }
         call->flags |= IPC_CALL_NOTIF;
         /* Put a counter to the message */
         call->priv = ++irq->notif_cfg.counter;
         /* Set up args */
         IPC_SET_METHOD(call->data, irq->notif_cfg.method);
+        IPC_SET_ARG1(call->data, irq->notif_cfg.scratch[1]);
+        IPC_SET_ARG2(call->data, irq->notif_cfg.scratch[2]);
+        IPC_SET_ARG3(call->data, irq->notif_cfg.scratch[3]);
+        IPC_SET_ARG4(call->data, irq->notif_cfg.scratch[4]);
+        IPC_SET_ARG5(call->data, irq->notif_cfg.scratch[5]);
-        /* Execute code to handle irq */
-        code_execute(call, irq->notif_cfg.code);
         send_call(irq, call);
     }
 }
-/** Disconnect all IRQ notifications from an answerbox.
+/** Send notification message.
  *
- * This function is effective because the answerbox contains
- * list of all irq_t structures that are registered to
- * send notifications to it.
- *
- * @param box       Answerbox for which we want to carry out the cleanup.
+ * @param irq       IRQ structure.
+ * @param a1        Driver-specific payload argument.
+ * @param a2        Driver-specific payload argument.
+ * @param a3        Driver-specific payload argument.
+ * @param a4        Driver-specific payload argument.
+ * @param a5        Driver-specific payload argument.
  */
-void ipc_irq_cleanup(answerbox_t *box)
+void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3,
+    unative_t a4, unative_t a5)
 {
-    ipl_t ipl;
-loop:
-    ipl = interrupts_disable();
-    spinlock_lock(&box->irq_lock);
-    while (box->irq_head.next != &box->irq_head) {
-        link_t *cur = box->irq_head.next;
-        irq_t *irq;
-        DEADLOCK_PROBE_INIT(p_irqlock);
-        irq = list_get_instance(cur, irq_t, notif_cfg.link);
-        if (!spinlock_trylock(&irq->lock)) {
-            /*
-             * Avoid deadlock by trying again.
-             */
-            spinlock_unlock(&box->irq_lock);
-            interrupts_restore(ipl);
-            DEADLOCK_PROBE(p_irqlock, DEADLOCK_THRESHOLD);
-            goto loop;
+    call_t *call;
+    spinlock_lock(&irq->lock);
+    if (irq->notif_cfg.answerbox) {
+        call = ipc_call_alloc(FRAME_ATOMIC);
+        if (!call) {
+            spinlock_unlock(&irq->lock);
+            return;
         }
+        call->flags |= IPC_CALL_NOTIF;
+        /* Put a counter to the message */
+        call->priv = ++irq->notif_cfg.counter;
+        IPC_SET_METHOD(call->data, irq->notif_cfg.method);
+        IPC_SET_ARG1(call->data, a1);
+        IPC_SET_ARG2(call->data, a2);
+        IPC_SET_ARG3(call->data, a3);
+        IPC_SET_ARG4(call->data, a4);
+        IPC_SET_ARG5(call->data, a5);
-        ASSERT(irq->notif_cfg.answerbox == box);
-        list_remove(&irq->notif_cfg.link);
-        /*
-         * Don't forget to free any top-half pseudocode.
-         */
-        code_free(irq->notif_cfg.code);
-        irq->notif_cfg.notify = false;
-        irq->notif_cfg.answerbox = NULL;
-        irq->notif_cfg.code = NULL;
-        irq->notif_cfg.method = 0;
-        irq->notif_cfg.counter = 0;
-        spinlock_unlock(&irq->lock);
+        send_call(irq, call);
     }
-    spinlock_unlock(&box->irq_lock);
-    interrupts_restore(ipl);
+    spinlock_unlock(&irq->lock);
 }
 /** @}

 /branches/network/kernel/generic/src/udebug/udebug.c
 ,0 → 1,504
+/*
+ * 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
+ * @brief   Udebug hooks and data structure management.
+ *
+ * Udebug is an interface that makes userspace debuggers possible.
+ */
+#include <synch/waitq.h>
+#include <debug.h>
+#include <udebug/udebug.h>
+#include <errno.h>
+#include <print.h>
+#include <arch.h>
+/** Initialize udebug part of task structure.
+ *
+ * Called as part of task structure initialization.
+ * @param ut    Pointer to the structure to initialize.
+ */
+void udebug_task_init(udebug_task_t *ut)
+{
+    mutex_initialize(&ut->lock, MUTEX_PASSIVE);
+    ut->dt_state = UDEBUG_TS_INACTIVE;
+    ut->begin_call = NULL;
+    ut->not_stoppable_count = 0;
+    ut->evmask = 0;
+}
+/** Initialize udebug part of thread structure.
+ *
+ * Called as part of thread structure initialization.
+ * @param ut    Pointer to the structure to initialize.
+ */
+void udebug_thread_initialize(udebug_thread_t *ut)
+{
+    mutex_initialize(&ut->lock, MUTEX_PASSIVE);
+    waitq_initialize(&ut->go_wq);
+    ut->go_call = NULL;
+    ut->uspace_state = NULL;
+    ut->go = false;
+    ut->stoppable = true;
+    ut->active = false;
+    ut->cur_event = 0; /* none */
+}
+/** Wait for a GO message.
+ *
+ * When a debugging event occurs in a thread or the thread is stopped,
+ * this function is called to block the thread until a GO message
+ * is received.
+ *
+ * @param wq    The wait queue used by the thread to wait for GO messages.
+ */
+static void udebug_wait_for_go(waitq_t *wq)
+{
+    int rc;
+    ipl_t ipl;
+    ipl = waitq_sleep_prepare(wq);
+    wq->missed_wakeups = 0; /* Enforce blocking. */
+    rc = waitq_sleep_timeout_unsafe(wq, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
+    waitq_sleep_finish(wq, rc, ipl);
+}
+/** Do a preliminary check that a debugging session is in progress.
+ *
+ * This only requires the THREAD->udebug.lock mutex (and not TASK->udebug.lock
+ * mutex). For an undebugged task, this will never block (while there could be
+ * collisions by different threads on the TASK mutex), thus improving SMP
+ * perormance for undebugged tasks.
+ *
+ * @return  True if the thread was in a debugging session when the function
+ *      checked, false otherwise.
+ */
+static bool udebug_thread_precheck(void)
+{
+    bool res;
+    mutex_lock(&THREAD->udebug.lock);
+    res = THREAD->udebug.active;
+    mutex_unlock(&THREAD->udebug.lock);
+    return res;
+}
+/** Start of stoppable section.
+ *
+ * A stoppable section is a section of code where if the thread can be stoped. In other words,
+ * if a STOP operation is issued, the thread is guaranteed not to execute
+ * any userspace instructions until the thread is resumed.
+ *
+ * Having stoppable sections is better than having stopping points, since
+ * a thread can be stopped even when it is blocked indefinitely in a system
+ * call (whereas it would not reach any stopping point).
+ */
+void udebug_stoppable_begin(void)
+{
+    int nsc;
+    call_t *db_call, *go_call;
+    ASSERT(THREAD);
+    ASSERT(TASK);
+    /* Early check for undebugged tasks */
+    if (!udebug_thread_precheck()) {
+        return;
+    }
+    mutex_lock(&TASK->udebug.lock);
+    nsc = --TASK->udebug.not_stoppable_count;
+    /* Lock order OK, THREAD->udebug.lock is after TASK->udebug.lock */
+    mutex_lock(&THREAD->udebug.lock);
+    ASSERT(THREAD->udebug.stoppable == false);
+    THREAD->udebug.stoppable = true;
+    if (TASK->udebug.dt_state == UDEBUG_TS_BEGINNING && nsc == 0) {
+        /*
+         * This was the last non-stoppable thread. Reply to
+         * DEBUG_BEGIN call.
+         */
+        db_call = TASK->udebug.begin_call;
+        ASSERT(db_call);
+        TASK->udebug.dt_state = UDEBUG_TS_ACTIVE;
+        TASK->udebug.begin_call = NULL;
+        IPC_SET_RETVAL(db_call->data, 0);
+        ipc_answer(&TASK->answerbox, db_call);
+    } else if (TASK->udebug.dt_state == UDEBUG_TS_ACTIVE) {
+        /*
+         * Active debugging session
+         */
+        if (THREAD->udebug.active == true &&
+            THREAD->udebug.go == false) {
+            /*
+             * Thread was requested to stop - answer go call
+             */
+            /* Make sure nobody takes this call away from us */
+            go_call = THREAD->udebug.go_call;
+            THREAD->udebug.go_call = NULL;
+            ASSERT(go_call);
+            IPC_SET_RETVAL(go_call->data, 0);
+            IPC_SET_ARG1(go_call->data, UDEBUG_EVENT_STOP);
+            THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
+                ipc_answer(&TASK->answerbox, go_call);
+        }
+    }
+    mutex_unlock(&THREAD->udebug.lock);
+        mutex_unlock(&TASK->udebug.lock);
+}
+/** End of a stoppable section.
+ *
+ * This is the point where the thread will block if it is stopped.
+ * (As, by definition, a stopped thread must not leave its stoppable section).
+ */
+void udebug_stoppable_end(void)
+{
+    /* Early check for undebugged tasks */
+    if (!udebug_thread_precheck()) {
+        return;
+    }
+restart:
+    mutex_lock(&TASK->udebug.lock);
+    mutex_lock(&THREAD->udebug.lock);
+    if (THREAD->udebug.active && THREAD->udebug.go == false) {
+        TASK->udebug.begin_call = NULL;
+        mutex_unlock(&THREAD->udebug.lock);
+        mutex_unlock(&TASK->udebug.lock);
+        udebug_wait_for_go(&THREAD->udebug.go_wq);
+        goto restart;
+        /* Must try again - have to lose stoppability atomically. */
+    } else {
+        ++TASK->udebug.not_stoppable_count;
+        ASSERT(THREAD->udebug.stoppable == true);
+        THREAD->udebug.stoppable = false;
+        mutex_unlock(&THREAD->udebug.lock);
+        mutex_unlock(&TASK->udebug.lock);
+    }
+}
+/** Upon being scheduled to run, check if the current thread should stop.
+ *
+ * This function is called from clock().
+ */
+void udebug_before_thread_runs(void)
+{
+    /* Check if we're supposed to stop */
+    udebug_stoppable_begin();
+    udebug_stoppable_end();
+}
+/** Syscall event hook.
+ *
+ * Must be called before and after servicing a system call. This generates
+ * a SYSCALL_B or SYSCALL_E event, depending on the value of @a end_variant.
+ */
+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)
+{
+    call_t *call;
+    udebug_event_t etype;
+    etype = end_variant ? UDEBUG_EVENT_SYSCALL_E : UDEBUG_EVENT_SYSCALL_B;
+    /* Early check for undebugged tasks */
+    if (!udebug_thread_precheck()) {
+        return;
+    }
+    mutex_lock(&TASK->udebug.lock);
+    mutex_lock(&THREAD->udebug.lock);
+    /* Must only generate events when in debugging session and is go. */
+    if (THREAD->udebug.active != true || THREAD->udebug.go == false ||
+        (TASK->udebug.evmask & UDEBUG_EVMASK(etype)) == 0) {
+        mutex_unlock(&THREAD->udebug.lock);
+        mutex_unlock(&TASK->udebug.lock);
+        return;
+    }
+    //printf("udebug_syscall_event\n");
+    call = THREAD->udebug.go_call;
+    THREAD->udebug.go_call = NULL;
+    IPC_SET_RETVAL(call->data, 0);
+    IPC_SET_ARG1(call->data, etype);
+    IPC_SET_ARG2(call->data, id);
+    IPC_SET_ARG3(call->data, rc);
+    //printf("udebug_syscall_event/ipc_answer\n");
+    THREAD->udebug.syscall_args[0] = a1;
+    THREAD->udebug.syscall_args[1] = a2;
+    THREAD->udebug.syscall_args[2] = a3;
+    THREAD->udebug.syscall_args[3] = a4;
+    THREAD->udebug.syscall_args[4] = a5;
+    THREAD->udebug.syscall_args[5] = a6;
+    /*
+     * Make sure udebug.go is false when going to sleep
+     * in case we get woken up by DEBUG_END. (At which
+     * point it must be back to the initial true value).
+     */
+    THREAD->udebug.go = false;
+    THREAD->udebug.cur_event = etype;
+    ipc_answer(&TASK->answerbox, call);
+    mutex_unlock(&THREAD->udebug.lock);
+    mutex_unlock(&TASK->udebug.lock);
+    udebug_wait_for_go(&THREAD->udebug.go_wq);
+}
+/** Thread-creation event hook combined with attaching the thread.
+ *
+ * Must be called when a new userspace thread is created in the debugged
+ * task. Generates a THREAD_B event. Also attaches the thread @a t
+ * to the task @a ta.
+ *
+ * This is necessary to avoid a race condition where the BEGIN and THREAD_READ
+ * requests would be handled inbetween attaching the thread and checking it
+ * for being in a debugging session to send the THREAD_B event. We could then
+ * either miss threads or get some threads both in the thread list
+ * and get a THREAD_B event for them.
+ *
+ * @param t Structure of the thread being created. Not locked, as the
+ *      thread is not executing yet.
+ * @param ta    Task to which the thread should be attached.
+ */
+void udebug_thread_b_event_attach(struct thread *t, struct task *ta)
+{
+    call_t *call;
+    mutex_lock(&TASK->udebug.lock);
+    mutex_lock(&THREAD->udebug.lock);
+    thread_attach(t, ta);
+    LOG("udebug_thread_b_event\n");
+    LOG("- check state\n");
+    /* Must only generate events when in debugging session */
+    if (THREAD->udebug.active != true) {
+        LOG("- udebug.active: %s, udebug.go: %s\n",
+            THREAD->udebug.active ? "yes(+)" : "no(-)",
+            THREAD->udebug.go ? "yes(-)" : "no(+)");
+        mutex_unlock(&THREAD->udebug.lock);
+        mutex_unlock(&TASK->udebug.lock);
+        return;
+    }
+    LOG("- trigger event\n");
+    call = THREAD->udebug.go_call;
+    THREAD->udebug.go_call = NULL;
+    IPC_SET_RETVAL(call->data, 0);
+    IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_B);
+    IPC_SET_ARG2(call->data, (unative_t)t);
+    /*
+     * Make sure udebug.go is false when going to sleep
+     * in case we get woken up by DEBUG_END. (At which
+     * point it must be back to the initial true value).
+     */
+    THREAD->udebug.go = false;
+    THREAD->udebug.cur_event = UDEBUG_EVENT_THREAD_B;
+    ipc_answer(&TASK->answerbox, call);
+    mutex_unlock(&THREAD->udebug.lock);
+    mutex_unlock(&TASK->udebug.lock);
+    LOG("- sleep\n");
+    udebug_wait_for_go(&THREAD->udebug.go_wq);
+}
+/** Thread-termination event hook.
+ *
+ * Must be called when the current thread is terminating.
+ * Generates a THREAD_E event.
+ */
+void udebug_thread_e_event(void)
+{
+    call_t *call;
+    mutex_lock(&TASK->udebug.lock);
+    mutex_lock(&THREAD->udebug.lock);
+    LOG("udebug_thread_e_event\n");
+    LOG("- check state\n");
+    /* Must only generate events when in debugging session. */
+    if (THREAD->udebug.active != true) {
+/*      printf("- udebug.active: %s, udebug.go: %s\n",
+            THREAD->udebug.active ? "yes(+)" : "no(-)",
+            THREAD->udebug.go ? "yes(-)" : "no(+)");*/
+        mutex_unlock(&THREAD->udebug.lock);
+        mutex_unlock(&TASK->udebug.lock);
+        return;
+    }
+    LOG("- trigger event\n");
+    call = THREAD->udebug.go_call;
+    THREAD->udebug.go_call = NULL;
+    IPC_SET_RETVAL(call->data, 0);
+    IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_E);
+    /* Prevent any further debug activity in thread. */
+    THREAD->udebug.active = false;
+    THREAD->udebug.cur_event = 0;       /* none */
+    THREAD->udebug.go = false;  /* set to initial value */
+    ipc_answer(&TASK->answerbox, call);
+    mutex_unlock(&THREAD->udebug.lock);
+    mutex_unlock(&TASK->udebug.lock);
+    /*
+     * This event does not sleep - debugging has finished
+     * in this thread.
+     */
+}
+/**
+ * Terminate task debugging session.
+ *
+ * Gracefully terminates the debugging session for a task. If the debugger
+ * is still waiting for events on some threads, it will receive a
+ * FINISHED event for each of them.
+ *
+ * @param ta    Task structure. ta->udebug.lock must be already locked.
+ * @return  Zero on success or negative error code.
+ */
+int udebug_task_cleanup(struct task *ta)
+{
+    thread_t *t;
+    link_t *cur;
+    int flags;
+    ipl_t ipl;
+    LOG("udebug_task_cleanup()\n");
+    LOG("task %" PRIu64 "\n", ta->taskid);
+    if (ta->udebug.dt_state != UDEBUG_TS_BEGINNING &&
+        ta->udebug.dt_state != UDEBUG_TS_ACTIVE) {
+        LOG("udebug_task_cleanup(): task not being debugged\n");
+        return EINVAL;
+    }
+    /* Finish debugging of all userspace threads */
+    for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
+        t = list_get_instance(cur, thread_t, th_link);
+        mutex_lock(&t->udebug.lock);
+        ipl = interrupts_disable();
+        spinlock_lock(&t->lock);
+        flags = t->flags;
+        spinlock_unlock(&t->lock);
+        interrupts_restore(ipl);
+        /* Only process userspace threads. */
+        if ((flags & THREAD_FLAG_USPACE) != 0) {
+            /* Prevent any further debug activity in thread. */
+            t->udebug.active = false;
+            t->udebug.cur_event = 0;    /* none */
+            /* Is the thread still go? */
+            if (t->udebug.go == true) {
+                /*
+                * Yes, so clear go. As active == false,
+                 * this doesn't affect anything.
+                 */
+                t->udebug.go = false;
+                /* Answer GO call */
+                LOG("answer GO call with EVENT_FINISHED\n");
+                IPC_SET_RETVAL(t->udebug.go_call->data, 0);
+                IPC_SET_ARG1(t->udebug.go_call->data,
+                    UDEBUG_EVENT_FINISHED);
+                ipc_answer(&ta->answerbox, t->udebug.go_call);
+                t->udebug.go_call = NULL;
+            } else {
+                /*
+                 * Debug_stop is already at initial value.
+                 * Yet this means the thread needs waking up.
+                 */
+                /*
+                 * t's lock must not be held when calling
+                 * waitq_wakeup.
+                 */
+                waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
+            }
+        }
+        mutex_unlock(&t->udebug.lock);
+    }
+    ta->udebug.dt_state = UDEBUG_TS_INACTIVE;
+    ta->udebug.debugger = NULL;
+    return 0;
+}
+/** @}
+ */

 /branches/network/kernel/generic/src/udebug/udebug_ops.c
 ,0 → 1,524
+/*
+ * 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
+ * @brief   Udebug operations.
+ *
+ * Udebug operations on tasks and threads are implemented here. The
+ * functions defined here are called from the udebug_ipc module
+ * when servicing udebug IPC messages.
+ */
+#include <debug.h>
+#include <proc/task.h>
+#include <proc/thread.h>
+#include <arch.h>
+#include <errno.h>
+#include <print.h>
+#include <syscall/copy.h>
+#include <ipc/ipc.h>
+#include <udebug/udebug.h>
+#include <udebug/udebug_ops.h>
+/**
+ * Prepare a thread for a debugging operation.
+ *
+ * Simply put, return thread t with t->udebug.lock held,
+ * but only if it verifies all conditions.
+ *
+ * Specifically, verifies that thread t exists, is a userspace thread,
+ * and belongs to the current task (TASK). Verifies, that the thread
+ * is (or is not) go according to being_go (typically false).
+ * It also locks t->udebug.lock, making sure that t->udebug.active
+ * is true - that the thread is in a valid debugging session.
+ *
+ * With this verified and the t->udebug.lock mutex held, it is ensured
+ * that the thread cannot leave the debugging session, let alone cease
+ * to exist.
+ *
+ * In this function, holding the TASK->udebug.lock mutex prevents the
+ * thread from leaving the debugging session, while relaxing from
+ * the t->lock spinlock to the t->udebug.lock mutex.
+ *
+ * @param t     Pointer, need not at all be valid.
+ * @param being_go  Required thread state.
+ *
+ * Returns EOK if all went well, or an error code otherwise.
+ */
+static int _thread_op_begin(thread_t *t, bool being_go)
+{
+    task_id_t taskid;
+    ipl_t ipl;
+    taskid = TASK->taskid;
+    mutex_lock(&TASK->udebug.lock);
+    /* thread_exists() must be called with threads_lock held */
+    ipl = interrupts_disable();
+    spinlock_lock(&threads_lock);
+    if (!thread_exists(t)) {
+        spinlock_unlock(&threads_lock);
+        interrupts_restore(ipl);
+        mutex_unlock(&TASK->udebug.lock);
+        return ENOENT;
+    }
+    /* t->lock is enough to ensure the thread's existence */
+    spinlock_lock(&t->lock);
+    spinlock_unlock(&threads_lock);
+    /* Verify that 't' is a userspace thread. */
+    if ((t->flags & THREAD_FLAG_USPACE) == 0) {
+        /* It's not, deny its existence */
+        spinlock_unlock(&t->lock);
+        interrupts_restore(ipl);
+        mutex_unlock(&TASK->udebug.lock);
+        return ENOENT;
+    }
+    /* Verify debugging state. */
+    if (t->udebug.active != true) {
+        /* Not in debugging session or undesired GO state */
+        spinlock_unlock(&t->lock);
+        interrupts_restore(ipl);
+        mutex_unlock(&TASK->udebug.lock);
+        return ENOENT;
+    }
+    /*
+     * Since the thread has active == true, TASK->udebug.lock
+     * is enough to ensure its existence and that active remains
+     * true.
+     */
+    spinlock_unlock(&t->lock);
+    interrupts_restore(ipl);
+    /* Only mutex TASK->udebug.lock left. */
+    /* Now verify that the thread belongs to the current task. */
+    if (t->task != TASK) {
+        /* No such thread belonging this task*/
+        mutex_unlock(&TASK->udebug.lock);
+        return ENOENT;
+    }
+    /*
+     * Now we need to grab the thread's debug lock for synchronization
+     * of the threads stoppability/stop state.
+     */
+    mutex_lock(&t->udebug.lock);
+    /* The big task mutex is no longer needed. */
+    mutex_unlock(&TASK->udebug.lock);
+    if (t->udebug.go != being_go) {
+        /* Not in debugging session or undesired GO state. */
+        mutex_unlock(&t->udebug.lock);
+        return EINVAL;
+    }
+    /* Only t->udebug.lock left. */
+    return EOK; /* All went well. */
+}
+/** End debugging operation on a thread. */
+static void _thread_op_end(thread_t *t)
+{
+    mutex_unlock(&t->udebug.lock);
+}
+/** Begin debugging the current task.
+ *
+ * Initiates a debugging session for the current task (and its threads).
+ * When the debugging session has started a reply will be sent to the
+ * UDEBUG_BEGIN call. This may happen immediately in this function if
+ * all the threads in this task are stoppable at the moment and in this
+ * case the function returns 1.
+ *
+ * Otherwise the function returns 0 and the reply will be sent as soon as
+ * all the threads become stoppable (i.e. they can be considered stopped).
+ *
+ * @param call  The BEGIN call we are servicing.
+ * @return  0 (OK, but not done yet), 1 (done) or negative error code.
+ */
+int udebug_begin(call_t *call)
+{
+    int reply;
+    thread_t *t;
+    link_t *cur;
+    LOG("udebug_begin()\n");
+    mutex_lock(&TASK->udebug.lock);
+    LOG("debugging task %llu\n", TASK->taskid);
+    if (TASK->udebug.dt_state != UDEBUG_TS_INACTIVE) {
+        mutex_unlock(&TASK->udebug.lock);
+        LOG("udebug_begin(): busy error\n");
+        return EBUSY;
+    }
+    TASK->udebug.dt_state = UDEBUG_TS_BEGINNING;
+    TASK->udebug.begin_call = call;
+    TASK->udebug.debugger = call->sender;
+    if (TASK->udebug.not_stoppable_count == 0) {
+        TASK->udebug.dt_state = UDEBUG_TS_ACTIVE;
+        TASK->udebug.begin_call = NULL;
+        reply = 1; /* immediate reply */
+    } else {
+        reply = 0; /* no reply */
+    }
+    /* Set udebug.active on all of the task's userspace threads. */
+    for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
+        t = list_get_instance(cur, thread_t, th_link);
+        mutex_lock(&t->udebug.lock);
+        if ((t->flags & THREAD_FLAG_USPACE) != 0)
+            t->udebug.active = true;
+        mutex_unlock(&t->udebug.lock);
+    }
+    mutex_unlock(&TASK->udebug.lock);
+    LOG("udebug_begin() done (%s)\n",
+        reply ? "reply" : "stoppability wait");
+    return reply;
+}
+/** Finish debugging the current task.
+ *
+ * Closes the debugging session for the current task.
+ * @return Zero on success or negative error code.
+ */
+int udebug_end(void)
+{
+    int rc;
+    LOG("udebug_end()\n");
+    mutex_lock(&TASK->udebug.lock);
+    LOG("task %" PRIu64 "\n", TASK->taskid);
+    rc = udebug_task_cleanup(TASK);
+    mutex_unlock(&TASK->udebug.lock);
+    return rc;
+}
+/** Set the event mask.
+ *
+ * Sets the event mask that determines which events are enabled.
+ *
+ * @param mask  Or combination of events that should be enabled.
+ * @return  Zero on success or negative error code.
+ */
+int udebug_set_evmask(udebug_evmask_t mask)
+{
+    LOG("udebug_set_mask()\n");
+    mutex_lock(&TASK->udebug.lock);
+    if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
+        mutex_unlock(&TASK->udebug.lock);
+        LOG("udebug_set_mask(): not active debuging session\n");
+        return EINVAL;
+    }
+    TASK->udebug.evmask = mask;
+    mutex_unlock(&TASK->udebug.lock);
+    return 0;
+}
+/** Give thread GO.
+ *
+ * Upon recieving a go message, the thread is given GO. Being GO
+ * means the thread is allowed to execute userspace code (until
+ * a debugging event or STOP occurs, at which point the thread loses GO.
+ *
+ * @param t The thread to operate on (unlocked and need not be valid).
+ * @param call  The GO call that we are servicing.
+ */
+int udebug_go(thread_t *t, call_t *call)
+{
+    int rc;
+    /* On success, this will lock t->udebug.lock. */
+    rc = _thread_op_begin(t, false);
+    if (rc != EOK) {
+        return rc;
+    }
+    t->udebug.go_call = call;
+    t->udebug.go = true;
+    t->udebug.cur_event = 0;    /* none */
+    /*
+     * Neither t's lock nor threads_lock may be held during wakeup.
+     */
+    waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
+    _thread_op_end(t);
+    return 0;
+}
+/** Stop a thread (i.e. take its GO away)
+ *
+ * Generates a STOP event as soon as the thread becomes stoppable (i.e.
+ * can be considered stopped).
+ *
+ * @param t The thread to operate on (unlocked and need not be valid).
+ * @param call  The GO call that we are servicing.
+ */
+int udebug_stop(thread_t *t, call_t *call)
+{
+    int rc;
+    LOG("udebug_stop()\n");
+    /*
+     * On success, this will lock t->udebug.lock. Note that this makes sure
+     * the thread is not stopped.
+     */
+    rc = _thread_op_begin(t, true);
+    if (rc != EOK) {
+        return rc;
+    }
+    /* Take GO away from the thread. */
+    t->udebug.go = false;
+    if (t->udebug.stoppable != true) {
+        /* Answer will be sent when the thread becomes stoppable. */
+        _thread_op_end(t);
+        return 0;
+    }
+    /*
+     * Answer GO call.
+     */
+    LOG("udebug_stop - answering go call\n");
+    /* Make sure nobody takes this call away from us. */
+    call = t->udebug.go_call;
+    t->udebug.go_call = NULL;
+    IPC_SET_RETVAL(call->data, 0);
+    IPC_SET_ARG1(call->data, UDEBUG_EVENT_STOP);
+    LOG("udebug_stop/ipc_answer\n");
+    THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
+    _thread_op_end(t);
+    mutex_lock(&TASK->udebug.lock);
+    ipc_answer(&TASK->answerbox, call);
+    mutex_unlock(&TASK->udebug.lock);
+    LOG("udebog_stop/done\n");
+    return 0;
+}
+/** Read the list of userspace threads in the current task.
+ *
+ * The list takes the form of a sequence of thread hashes (i.e. the pointers
+ * to thread structures). A buffer of size @a buf_size is allocated and
+ * a pointer to it written to @a buffer. The sequence of hashes is written
+ * into this buffer.
+ *
+ * If the sequence is longer than @a buf_size bytes, only as much hashes
+ * as can fit are copied. The number of thread hashes copied is stored
+ * in @a n.
+ *
+ * The rationale for having @a buf_size is that this function is only
+ * used for servicing the THREAD_READ message, which always specifies
+ * a maximum size for the userspace buffer.
+ *
+ * @param buffer    The buffer for storing thread hashes.
+ * @param buf_size  Buffer size in bytes.
+ * @param n     The actual number of hashes copied will be stored here.
+ */
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *n)
+{
+    thread_t *t;
+    link_t *cur;
+    unative_t tid;
+    unsigned copied_ids;
+    ipl_t ipl;
+    unative_t *id_buffer;
+    int flags;
+    size_t max_ids;
+    LOG("udebug_thread_read()\n");
+    /* Allocate a buffer to hold thread IDs */
+    id_buffer = malloc(buf_size, 0);
+    mutex_lock(&TASK->udebug.lock);
+    /* Verify task state */
+    if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
+        mutex_unlock(&TASK->udebug.lock);
+        return EINVAL;
+    }
+    ipl = interrupts_disable();
+    spinlock_lock(&TASK->lock);
+    /* Copy down the thread IDs */
+    max_ids = buf_size / sizeof(unative_t);
+    copied_ids = 0;
+    /* FIXME: make sure the thread isn't past debug shutdown... */
+    for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
+        /* Do not write past end of buffer */
+        if (copied_ids >= max_ids) break;
+        t = list_get_instance(cur, thread_t, th_link);
+        spinlock_lock(&t->lock);
+        flags = t->flags;
+        spinlock_unlock(&t->lock);
+        /* Not interested in kernel threads. */
+        if ((flags & THREAD_FLAG_USPACE) != 0) {
+            /* Using thread struct pointer as identification hash */
+            tid = (unative_t) t;
+            id_buffer[copied_ids++] = tid;
+        }
+    }
+    spinlock_unlock(&TASK->lock);
+    interrupts_restore(ipl);
+    mutex_unlock(&TASK->udebug.lock);
+    *buffer = id_buffer;
+    *n = copied_ids * sizeof(unative_t);
+    return 0;
+}
+/** Read the arguments of a system call.
+ *
+ * The arguments of the system call being being executed are copied
+ * to an allocated buffer and a pointer to it is written to @a buffer.
+ * The size of the buffer is exactly such that it can hold the maximum number
+ * of system-call arguments.
+ *
+ * Unless the thread is currently blocked in a SYSCALL_B or SYSCALL_E event,
+ * this function will fail with an EINVAL error code.
+ *
+ * @param buffer    The buffer for storing thread hashes.
+ */
+int udebug_args_read(thread_t *t, void **buffer)
+{
+    int rc;
+    unative_t *arg_buffer;
+    /* Prepare a buffer to hold the arguments. */
+    arg_buffer = malloc(6 * sizeof(unative_t), 0);
+    /* On success, this will lock t->udebug.lock. */
+    rc = _thread_op_begin(t, false);
+    if (rc != EOK) {
+        return rc;
+    }
+    /* Additionally we need to verify that we are inside a syscall. */
+    if (t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_B &&
+        t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_E) {
+        _thread_op_end(t);
+        return EINVAL;
+    }
+    /* Copy to a local buffer before releasing the lock. */
+    memcpy(arg_buffer, t->udebug.syscall_args, 6 * sizeof(unative_t));
+    _thread_op_end(t);
+    *buffer = arg_buffer;
+    return 0;
+}
+/** Read the memory of the debugged task.
+ *
+ * Reads @a n bytes from the address space of the debugged task, starting
+ * from @a uspace_addr. The bytes are copied into an allocated buffer
+ * and a pointer to it is written into @a buffer.
+ *
+ * @param uspace_addr   Address from where to start reading.
+ * @param n     Number of bytes to read.
+ * @param buffer    For storing a pointer to the allocated buffer.
+ */
+int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer)
+{
+    void *data_buffer;
+    int rc;
+    /* Verify task state */
+    mutex_lock(&TASK->udebug.lock);
+    if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
+        mutex_unlock(&TASK->udebug.lock);
+        return EBUSY;
+    }
+    data_buffer = malloc(n, 0);
+    /* NOTE: this is not strictly from a syscall... but that shouldn't
+     * be a problem */
+    rc = copy_from_uspace(data_buffer, (void *)uspace_addr, n);
+    mutex_unlock(&TASK->udebug.lock);
+    if (rc != 0) return rc;
+    *buffer = data_buffer;
+    return 0;
+}
+/** @}
+ */

 /branches/network/kernel/generic/src/udebug/udebug_ipc.c
 ,0 → 1,343
+/*
+ * 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
+ * @brief   Udebug IPC message handling.
+ *
+ * This module handles udebug IPC messages and calls the appropriate
+ * functions from the udebug_ops module which implement them.
+ */
+#include <proc/task.h>
+#include <proc/thread.h>
+#include <arch.h>
+#include <errno.h>
+#include <ipc/ipc.h>
+#include <syscall/copy.h>
+#include <udebug/udebug.h>
+#include <udebug/udebug_ops.h>
+#include <udebug/udebug_ipc.h>
+int udebug_request_preprocess(call_t *call, phone_t *phone)
+{
+    switch (IPC_GET_ARG1(call->data)) {
+    /* future UDEBUG_M_REGS_WRITE, UDEBUG_M_MEM_WRITE: */
+    default:
+        break;
+    }
+    return 0;
+}
+/** Process a BEGIN call.
+ *
+ * Initiates a debugging session for the current task. The reply
+ * to this call may or may not be sent before this function returns.
+ *
+ * @param call  The call structure.
+ */
+static void udebug_receive_begin(call_t *call)
+{
+    int rc;
+    rc = udebug_begin(call);
+    if (rc < 0) {
+        IPC_SET_RETVAL(call->data, rc);
+        ipc_answer(&TASK->kb.box, call);
+        return;
+    }
+    /*
+     * If the initialization of the debugging session has finished,
+     * send a reply.
+     */
+    if (rc != 0) {
+        IPC_SET_RETVAL(call->data, 0);
+        ipc_answer(&TASK->kb.box, call);
+    }
+}
+/** Process an END call.
+ *
+ * Terminates the debugging session for the current task.
+ * @param call  The call structure.
+ */
+static void udebug_receive_end(call_t *call)
+{
+    int rc;
+    rc = udebug_end();
+    IPC_SET_RETVAL(call->data, rc);
+    ipc_answer(&TASK->kb.box, call);
+}
+/** Process a SET_EVMASK call.
+ *
+ * Sets an event mask for the current debugging session.
+ * @param call  The call structure.
+ */
+static void udebug_receive_set_evmask(call_t *call)
+{
+    int rc;
+    udebug_evmask_t mask;
+    mask = IPC_GET_ARG2(call->data);
+    rc = udebug_set_evmask(mask);
+    IPC_SET_RETVAL(call->data, rc);
+    ipc_answer(&TASK->kb.box, call);
+}
+/** Process a GO call.
+ *
+ * Resumes execution of the specified thread.
+ * @param call  The call structure.
+ */
+static void udebug_receive_go(call_t *call)
+{
+    thread_t *t;
+    int rc;
+    t = (thread_t *)IPC_GET_ARG2(call->data);
+    rc = udebug_go(t, call);
+    if (rc < 0) {
+        IPC_SET_RETVAL(call->data, rc);
+        ipc_answer(&TASK->kb.box, call);
+        return;
+    }
+}
+/** Process a STOP call.
+ *
+ * Suspends execution of the specified thread.
+ * @param call  The call structure.
+ */
+static void udebug_receive_stop(call_t *call)
+{
+    thread_t *t;
+    int rc;
+    t = (thread_t *)IPC_GET_ARG2(call->data);
+    rc = udebug_stop(t, call);
+    IPC_SET_RETVAL(call->data, rc);
+    ipc_answer(&TASK->kb.box, call);
+}
+/** Process a THREAD_READ call.
+ *
+ * Reads the list of hashes of the (userspace) threads in the current task.
+ * @param call  The call structure.
+ */
+static void udebug_receive_thread_read(call_t *call)
+{
+    unative_t uspace_addr;
+    unative_t to_copy;
+    unsigned total_bytes;
+    unsigned buf_size;
+    void *buffer;
+    size_t n;
+    int rc;
+    uspace_addr = IPC_GET_ARG2(call->data); /* Destination address */
+    buf_size = IPC_GET_ARG3(call->data);    /* Dest. buffer size */
+    /*
+     * Read thread list. Variable n will be filled with actual number
+     * of threads times thread-id size.
+     */
+    rc = udebug_thread_read(&buffer, buf_size, &n);
+    if (rc < 0) {
+        IPC_SET_RETVAL(call->data, rc);
+        ipc_answer(&TASK->kb.box, call);
+        return;
+    }
+    total_bytes = n;
+    /* Copy MAX(buf_size, total_bytes) bytes */
+    if (buf_size > total_bytes)
+        to_copy = total_bytes;
+    else
+        to_copy = buf_size;
+    /*
+     * Make use of call->buffer to transfer data to caller's userspace
+     */
+    IPC_SET_RETVAL(call->data, 0);
+    /* ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
+       same code in process_answer() can be used
+       (no way to distinguish method in answer) */
+    IPC_SET_ARG1(call->data, uspace_addr);
+    IPC_SET_ARG2(call->data, to_copy);
+    IPC_SET_ARG3(call->data, total_bytes);
+    call->buffer = buffer;
+    ipc_answer(&TASK->kb.box, call);
+}
+/** Process an ARGS_READ call.
+ *
+ * Reads the argument of a current syscall event (SYSCALL_B or SYSCALL_E).
+ * @param call  The call structure.
+ */
+static void udebug_receive_args_read(call_t *call)
+{
+    thread_t *t;
+    unative_t uspace_addr;
+    int rc;
+    void *buffer;
+    t = (thread_t *)IPC_GET_ARG2(call->data);
+    rc = udebug_args_read(t, &buffer);
+    if (rc != EOK) {
+        IPC_SET_RETVAL(call->data, rc);
+        ipc_answer(&TASK->kb.box, call);
+        return;
+    }
+    /*
+     * Make use of call->buffer to transfer data to caller's userspace
+     */
+    uspace_addr = IPC_GET_ARG3(call->data);
+    IPC_SET_RETVAL(call->data, 0);
+    /* ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
+       same code in process_answer() can be used
+       (no way to distinguish method in answer) */
+    IPC_SET_ARG1(call->data, uspace_addr);
+    IPC_SET_ARG2(call->data, 6 * sizeof(unative_t));
+    call->buffer = buffer;
+    ipc_answer(&TASK->kb.box, call);
+}
+/** Process an MEM_READ call.
+ *
+ * Reads memory of the current (debugged) task.
+ * @param call  The call structure.
+ */
+static void udebug_receive_mem_read(call_t *call)
+{
+    unative_t uspace_dst;
+    unative_t uspace_src;
+    unsigned size;
+    void *buffer;
+    int rc;
+    uspace_dst = IPC_GET_ARG2(call->data);
+    uspace_src = IPC_GET_ARG3(call->data);
+    size = IPC_GET_ARG4(call->data);
+    rc = udebug_mem_read(uspace_src, size, &buffer);
+    if (rc < 0) {
+        IPC_SET_RETVAL(call->data, rc);
+        ipc_answer(&TASK->kb.box, call);
+        return;
+    }
+    IPC_SET_RETVAL(call->data, 0);
+    /* ARG1=dest, ARG2=size as in IPC_M_DATA_READ so that
+       same code in process_answer() can be used
+       (no way to distinguish method in answer) */
+    IPC_SET_ARG1(call->data, uspace_dst);
+    IPC_SET_ARG2(call->data, size);
+    call->buffer = buffer;
+    ipc_answer(&TASK->kb.box, call);
+}
+/** Handle a debug call received on the kernel answerbox.
+ *
+ * This is called by the kbox servicing thread. Verifies that the sender
+ * is indeed the debugger and calls the appropriate processing function.
+ */
+void udebug_call_receive(call_t *call)
+{
+    int debug_method;
+    debug_method = IPC_GET_ARG1(call->data);
+    if (debug_method != UDEBUG_M_BEGIN) {
+        /*
+         * Verify that the sender is this task's debugger.
+         * Note that this is the only thread that could change
+         * TASK->debugger. Therefore no locking is necessary
+         * and the sender can be safely considered valid until
+         * control exits this function.
+         */
+        if (TASK->udebug.debugger != call->sender) {
+            IPC_SET_RETVAL(call->data, EINVAL);
+            ipc_answer(&TASK->kb.box, call);
+            return;
+        }
+    }
+    switch (debug_method) {
+    case UDEBUG_M_BEGIN:
+        udebug_receive_begin(call);
+        break;
+    case UDEBUG_M_END:
+        udebug_receive_end(call);
+        break;
+    case UDEBUG_M_SET_EVMASK:
+        udebug_receive_set_evmask(call);
+        break;
+    case UDEBUG_M_GO:
+        udebug_receive_go(call);
+        break;
+    case UDEBUG_M_STOP:
+        udebug_receive_stop(call);
+        break;
+    case UDEBUG_M_THREAD_READ:
+        udebug_receive_thread_read(call);
+        break;
+    case UDEBUG_M_ARGS_READ:
+        udebug_receive_args_read(call);
+        break;
+    case UDEBUG_M_MEM_READ:
+        udebug_receive_mem_read(call);
+        break;
+    }
+}
+/** @}
+ */

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4152 → Rev 4153