WebSVN – HelenOS – Path Comparison – / – /branches/tracing/kernel/generic/ Rev 4376 and /branches/tracing/kernel/generic/ Rev 4377

Ignore whitespace Rev 4376 → Rev 4377

 /branches/tracing/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/tracing/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/tracing/kernel/generic/include/print.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,11 → 46,9
 extern int puts(const char *s);
 extern int printf(const char *fmt, ...);
-extern int sprintf(char *str, const char *fmt, ...);
 extern int snprintf(char *str, size_t size, const char *fmt, ...);
 extern int vprintf(const char *fmt, va_list ap);
-extern int vsprintf(char *str, const char *fmt, va_list ap);
 extern int vsnprintf(char *str, size_t size, const char *fmt, va_list ap);
 #endif

 /branches/tracing/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/tracing/kernel/generic/include/byteorder.h
36,6 → 36,7
#define KERN_BYTEORDER_H_

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

#if !(defined(ARCH_IS_BIG_ENDIAN) ^ defined(ARCH_IS_LITTLE_ENDIAN))
#error The architecture must be either big-endian or little-endian.

 /branches/tracing/kernel/generic/include/symtab.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,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);
+extern int symtab_compl(char *input, count_t size);
+#ifdef CONFIG_SYMTAB
 /* Symtable linked together by build process */
 extern struct symtab_entry symbol_table[];
 #endif
+#endif
 /** @}
  */

 /branches/tracing/kernel/generic/include/sysinfo/sysinfo.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,6 → 36,7
 #define KERN_SYSINFO_H_
 #include <arch/types.h>
+#include <string.h>
 typedef union sysinfo_item_val {
     unative_t val;
 ,13 → 60,13
     int subinfo_type;
 } sysinfo_item_t;
-#define SYSINFO_VAL_VAL 0
-#define SYSINFO_VAL_FUNCTION 1
-#define SYSINFO_VAL_UNDEFINED '?'
+#define SYSINFO_VAL_VAL        0
+#define SYSINFO_VAL_FUNCTION   1
+#define SYSINFO_VAL_UNDEFINED  U_SPECIAL
-#define SYSINFO_SUBINFO_NONE 0
-#define SYSINFO_SUBINFO_TABLE 1
-#define SYSINFO_SUBINFO_FUNCTION 2
+#define SYSINFO_SUBINFO_NONE      0
+#define SYSINFO_SUBINFO_TABLE     1
+#define SYSINFO_SUBINFO_FUNCTION  2
 typedef unative_t (*sysinfo_val_fn_t)(sysinfo_item_t *root);
 typedef unative_t (*sysinfo_subinfo_fn_t)(const char *subname);

 /branches/tracing/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,15
 #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 → 65,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/tracing/kernel/generic/include/string.h
 ,0 → 1,101
+/*
+ * 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 <typedefs.h>
+/**< Common Unicode characters */
+#define U_SPECIAL      '?'
+#define U_LEFT_ARROW   0x2190
+#define U_UP_ARROW     0x2191
+#define U_RIGHT_ARROW  0x2192
+#define U_DOWN_ARROW   0x2193
+#define U_PAGE_UP      0x21de
+#define U_PAGE_DOWN    0x21df
+#define U_HOME_ARROW   0x21f1
+#define U_END_ARROW    0x21f2
+#define U_NULL         0x2400
+#define U_ESCAPE       0x241b
+#define U_DELETE       0x2421
+#define U_CURSOR       0x2588
+#define U_BOM          0xfeff
+/**< No size limit constant */
+#define STR_NO_LIMIT  ((size_t) -1)
+/**< Maximum size of a string containing cnt characters */
+#define STR_BOUNDS(cnt)  (cnt << 2)
+extern wchar_t str_decode(const char *str, size_t *offset, size_t sz);
+extern int chr_encode(wchar_t ch, char *str, size_t *offset, size_t sz);
+extern size_t str_size(const char *str);
+extern size_t wstr_size(const wchar_t *str);
+extern size_t str_lsize(const char *str, count_t max_len);
+extern size_t wstr_lsize(const wchar_t *str, count_t max_len);
+extern count_t str_length(const char *str);
+extern count_t wstr_length(const wchar_t *wstr);
+extern count_t str_nlength(const char *str, size_t size);
+extern count_t wstr_nlength(const wchar_t *str, size_t size);
+extern bool ascii_check(wchar_t ch);
+extern bool chr_check(wchar_t ch);
+extern int str_cmp(const char *s1, const char *s2);
+extern int str_lcmp(const char *s1, const char *s2, count_t max_len);
+extern void str_cpy(char *dest, size_t size, const char *src);
+extern void str_ncpy(char *dest, size_t size, const char *src, size_t n);
+extern void wstr_nstr(char *dst, const wchar_t *src, size_t size);
+extern const char *str_chr(const char *str, wchar_t ch);
+extern bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos);
+extern bool wstr_remove(wchar_t *str, count_t pos);
+#endif
+/** @}
+ */

/branches/tracing/kernel/generic/include/proc/task.h
144,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/tracing/kernel/generic/include/proc/program.h
 ,8 → 59,7
 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,
-    char *uspace_name, size_t name_len);
+extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len);
 #endif

 /branches/tracing/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/tracing/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/tracing/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/tracing/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/tracing/kernel/generic/include/putchar.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,7 → 35,7
 #ifndef KERN_PUTCHAR_H_
 #define KERN_PUTCHAR_H_
-extern void putchar(const char ch);
+extern void putchar(const wchar_t ch);
 #endif

 /branches/tracing/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/tracing/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. */
 ,10 → 82,10
 } 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 *arg, inr_t inr);
+typedef void (* cir_t)(void *, inr_t);
 /** IPC notification config 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. */
 ,11 → 144,11
     /** 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;
 ,12 → 159,14
     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/tracing/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/tracing/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/tracing/kernel/generic/include/console/chardev.h
 ,41 → 39,63
 #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;
+    wchar_t (* 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);
+    wchar_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 *, wchar_t, bool);
+} 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, wchar_t ch);
+extern wchar_t indev_pop_character(indev_t *indev);
+extern void outdev_initialize(char *name, outdev_t *outdev,
+    outdev_operations_t *op);
+extern bool check_poll(indev_t *indev);
 #endif /* KERN_CHARDEV_H_ */
 /** @}

 /branches/tracing/kernel/generic/include/console/kconsole.h
 ,9 → 37,10
 #include <adt/list.h>
 #include <synch/spinlock.h>
+#include <ipc/irq.h>
-#define MAX_CMDLINE     256
-#define KCONSOLE_HISTORY 10
+#define MAX_CMDLINE       256
+#define KCONSOLE_HISTORY  10
 typedef enum {
     ARG_TYPE_INVALID = 0,
 ,7 → 47,7
     ARG_TYPE_INT,
     ARG_TYPE_STRING,
     /** Variable type - either symbol or string. */
-    ARG_TYPE_VAR
+    ARG_TYPE_VAR
 } cmd_arg_type_t;
 /** Structure representing one argument of kconsole command line. */
 ,13 → 84,19
     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);
+extern bool cmd_register(cmd_info_t *cmd);
 #endif

 /branches/tracing/kernel/generic/include/console/console.h
 ,17 → 38,26
 #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 indev_t *stdin_wire(void);
+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 void putchar(char c);
+extern wchar_t getc(indev_t *indev);
+extern count_t gets(indev_t *indev, char *buf, size_t buflen);
+extern unative_t sys_klog(int fd, const void *buf, size_t size);
+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/tracing/kernel/generic/include/printf/printf_core.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,20 → 35,23
 #ifndef KERN_PRINTF_CORE_H_
 #define KERN_PRINTF_CORE_H_
-#include <arch/types.h>
+#include <typedefs.h>
 #include <arch/arg.h>
 /** Structure for specifying output methods for different printf clones. */
-struct printf_spec {
-    /* Output function, returns count of printed characters or EOF */
-    int (*write)(void *, size_t, void *);
-    /* Support data - output stream specification, its state, locks,... */
+typedef struct {
+    /* String output function, returns number of printed characters or EOF */
+    int (*str_write)(const char *, size_t, void *);
+    /* Wide string output function, returns number of printed characters or EOF */
+    int (*wstr_write)(const wchar_t *, size_t, void *);
+    /* User data - output stream specification, state, locks, etc. */
     void *data;
+} printf_spec_t;
-};
+int printf_core(const char *fmt, printf_spec_t *ps, va_list ap);
-int printf_core(const char *fmt, struct printf_spec *ps, va_list ap);
 #endif
 /** @}

 /branches/tracing/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/tracing/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/tracing/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/tracing/kernel/generic/include/mm/slab.h
 ,40 → 41,40
 #include <mm/frame.h>
 /** Minimum size to be allocated by malloc */
-#define SLAB_MIN_MALLOC_W 4
+#define SLAB_MIN_MALLOC_W  4
 /** Maximum size to be allocated by malloc */
-#define SLAB_MAX_MALLOC_W 18
+#define SLAB_MAX_MALLOC_W  22
 /** Initial Magazine size (TODO: dynamically growing magazines) */
 #define SLAB_MAG_SIZE  4
 /** If object size is less, store control structure inside SLAB */
-#define SLAB_INSIDE_SIZE   (PAGE_SIZE >> 3)
+#define SLAB_INSIDE_SIZE  (PAGE_SIZE >> 3)
 /** Maximum wasted space we allow for cache */
-#define SLAB_MAX_BADNESS(cache) \
+#define SLAB_MAX_BADNESS(cache) \
     (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
 /* slab_reclaim constants */
 /** Reclaim all possible memory, because we are in memory stress */
-#define SLAB_RECLAIM_ALL  0x1
+#define SLAB_RECLAIM_ALL  0x01
 /* cache_create flags */
 /** Do not use per-cpu cache */
-#define SLAB_CACHE_NOMAGAZINE 0x1
+#define SLAB_CACHE_NOMAGAZINE   0x01
 /** Have control structure inside SLAB */
-#define SLAB_CACHE_SLINSIDE   0x2
+#define SLAB_CACHE_SLINSIDE     0x02
 /** We add magazine cache later, if we have this flag */
-#define SLAB_CACHE_MAGDEFERRED (0x4 | SLAB_CACHE_NOMAGAZINE)
+#define SLAB_CACHE_MAGDEFERRED  (0x04 | SLAB_CACHE_NOMAGAZINE)
 typedef struct {
     link_t link;
-    count_t busy;   /**< Count of full slots in magazine */
-    count_t size;   /**< Number of slots in magazine */
-    void *objs[];   /**< Slots in magazine */
+    count_t busy;  /**< Count of full slots in magazine */
+    count_t size;  /**< Number of slots in magazine */
+    void *objs[];  /**< Slots in magazine */
 } slab_magazine_t;
 typedef struct {
 ,23 → 86,23
 typedef struct {
     char *name;
     link_t link;
     /* Configuration */
     /** Size of slab position - align_up(sizeof(obj)) */
     size_t size;
     int (*constructor)(void *obj, int kmflag);
     int (*destructor)(void *obj);
     /** Flags changing behaviour of cache */
     int flags;
     /* Computed values */
-    uint8_t order;          /**< Order of frames to be allocated */
-    unsigned int objects;       /**< Number of objects that fit in */
+    uint8_t order;         /**< Order of frames to be allocated */
+    unsigned int objects;  /**< Number of objects that fit in */
     /* Statistics */
     atomic_t allocated_slabs;
     atomic_t allocated_objs;
 ,15 → 109,15
     atomic_t cached_objs;
     /** How many magazines in magazines list */
     atomic_t magazine_counter;
     /* Slabs */
-    link_t full_slabs;  /**< List of full slabs */
-    link_t partial_slabs;   /**< List of partial slabs */
+    link_t full_slabs;     /**< List of full slabs */
+    link_t partial_slabs;  /**< List of partial slabs */
     SPINLOCK_DECLARE(slablock);
-    /* Magazines  */
-    link_t magazines;   /**< List o full magazines */
+    /* Magazines */
+    link_t magazines;  /**< List o full magazines */
     SPINLOCK_DECLARE(maglock);
     /** CPU cache */
     slab_mag_cache_t *mag_cache;
 } slab_cache_t;
 ,6 → 141,7
 extern void *malloc(unsigned int, int);
 extern void *realloc(void *, unsigned int, int);
 extern void free(void *);
 #endif
 /** @}

 /branches/tracing/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/tracing/kernel/generic/include/typedefs.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,6 → 51,12
 typedef int32_t inr_t;
 typedef int32_t devno_t;
+typedef int32_t wchar_t;
+typedef volatile uint8_t ioport8_t;
+typedef volatile uint16_t ioport16_t;
+typedef volatile uint32_t ioport32_t;
 #endif
 /** @}

 /branches/tracing/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/tracing/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,14 → 63,18
SYS_IPC_ANSWER_FAST,
SYS_IPC_ANSWER_SLOW,
SYS_IPC_FORWARD_FAST,
SYS_IPC_FORWARD_SLOW,
SYS_IPC_WAIT,
SYS_IPC_HANGUP,
SYS_IPC_REGISTER_IRQ,
SYS_IPC_UNREGISTER_IRQ,

SYS_EVENT_SUBSCRIBE,

SYS_CAP_GRANT,
SYS_CAP_REVOKE,

SYS_DEVICE_ASSIGN_DEVNO,
SYS_PHYSMEM_MAP,
SYS_IOSPACE_ENABLE,
SYS_PREEMPT_CONTROL,
78,6 → 83,7
SYS_SYSINFO_VALUE,

SYS_DEBUG_ENABLE_CONSOLE,
SYS_DEBUG_DISABLE_CONSOLE,
SYS_IPC_CONNECT_KBOX,
SYSCALL_END
} syscall_t;

 /branches/tracing/kernel/generic/include/ipc/sysipc.h
 ,6 → 53,8
     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);

 /branches/tracing/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/tracing/kernel/generic/include/ipc/event.h
 ,0 → 1,79
+/*
+ * Copyright (c) 2009 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_EVENT_H_
+#define KERN_EVENT_H_
+#include <ipc/event_types.h>
+#include <arch/types.h>
+#include <synch/spinlock.h>
+#include <ipc/ipc.h>
+/** Event notification structure. */
+typedef struct {
+    SPINLOCK_DECLARE(lock);
+    /** Answerbox for notifications. */
+    answerbox_t *answerbox;
+    /** Method to be used for the notification. */
+    unative_t method;
+    /** Counter. */
+    count_t counter;
+} event_t;
+extern void event_init(void);
+extern unative_t sys_event_subscribe(unative_t, unative_t);
+extern bool event_is_subscribed(event_type_t);
+extern void event_cleanup_answerbox(answerbox_t *);
+#define event_notify_0(e) \
+    event_notify((e), 0, 0, 0, 0, 0)
+#define event_notify_1(e, a1) \
+    event_notify((e), (a1), 0, 0, 0, 0)
+#define event_notify_2(e, a1, a2) \
+    event_notify((e), (a1), (a2), 0, 0, 0)
+#define event_notify_3(e, a1, a2, a3) \
+    event_notify((e), (a1), (a2), (a3), 0, 0)
+#define event_notify_4(e, a1, a2, a3, a4) \
+    event_notify((e), (a1), (a2), (a3), (a4), 0)
+#define event_notify_5(e, a1, a2, a3, a4, a5) \
+    event_notify((e), (a1), (a2), (a3), (a4), (a5))
+extern void event_notify(event_type_t, unative_t, unative_t, unative_t,
+    unative_t, unative_t);
+#endif
+/** @}
+ */

 /branches/tracing/kernel/generic/include/ipc/event_types.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2009 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_EVENT_TYPES_H_
+#define KERN_EVENT_TYPES_H_
+typedef enum event_type {
+    EVENT_KLOG = 0,
+    EVENT_KCONSOLE,
+    EVENT_END
+} event_type_t;
+#endif
+/** @}
+ */

 /branches/tracing/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/tracing/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);
+        str_cpy(namebuf, TASK_NAME_BUFLEN, INIT_PREFIX);
+        str_cpy(namebuf + INIT_PREFIX_LEN,
+            TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name);
         int rc = program_create_from_image((void *) init.tasks[i].addr,
-            "init-bin", &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,34
             /* 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.
      */
     for (i = 0; i < init.cnt; i++) {
-        if (programs[i].task != NULL) {
-            thread_usleep(50000);
+        if (programs[i].task != NULL)
             program_ready(&programs[i]);
-        }
     }
+#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/tracing/kernel/generic/src/main/main.c
 ,7 → 32,7
 /**
  * @file
- * @brief   Main initialization kernel function for all processors.
+ * @brief Main initialization kernel function for all processors.
  *
  * During kernel boot, all processors, after architecture dependent
  * initialization, start executing code found in this file. After
 ,8 → 81,9
 #include <adt/btree.h>
 #include <smp/smp.h>
 #include <ddi/ddi.h>
+#include <main/main.h>
+#include <ipc/event.h>
 /** Global configuration structure. */
 config_t config;
 ,18 → 106,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 → 189,6
 {
     /* Keep this the first thing. */
     the_initialize(THE);
-    LOG();
     version_print();
 ,7 → 197,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 → 204,7
      * commands.
      */
     LOG_EXEC(kconsole_init());
+#endif
     /*
      * Exception handler initialization, before architecture
 ,7 → 211,7
      * starts adding its own handlers
      */
     LOG_EXEC(exc_init());
     /*
      * Memory management subsystems initialization.
      */
 ,7 → 249,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
 ,22 → 256,23
         printf("No init binaries found\n");
     LOG_EXEC(ipc_init());
+    LOG_EXEC(event_init());
     LOG_EXEC(klog_init());
     /*
      * 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));
     /*

 /branches/tracing/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/tracing/kernel/generic/src/main/shutdown.c
 ,10 → 32,11
 /**
  * @file
- * @brief   Shutdown procedures.
+ * @brief Shutdown procedures.
  */
 #include <arch.h>
+#include <func.h>
 #include <print.h>
 void reboot(void)
 ,6 → 48,7
 #endif
     arch_reboot();
+    halt();
 }
 /** @}

 /branches/tracing/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/tracing/kernel/generic/src/synch/spinlock.c
 ,9 → 32,9
 /**
  * @file
- * @brief   Spinlocks.
+ * @brief Spinlocks.
  */
 #include <synch/spinlock.h>
 #include <atomic.h>
 #include <arch/barrier.h>
 ,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)\n", CPU->id, sl, sl->name,
+                CALLER, symtab_fmt_name_lookup(CALLER));
             i = 0;
             deadlock_reported = true;
         }

 /branches/tracing/kernel/generic/src/debug/symtab.c
 ,171 → 32,222
 /**
  * @file
- * @brief   Kernel symbol resolver.
+ * @brief Kernel symbol resolver.
  */
 #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 a 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.
  *
- * @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) {
+    for (i = 1; symbol_table[i].address_le; i++) {
         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
 }
-/** Find symbols that match the parameter forward and print them.
+/** Lookup symbol by address and format for display.
  *
- * @param name - search string
- * @param startpos - starting position, changes to found position
- * @return Pointer to the part of string that should be completed or NULL
+ * 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.
+ *
  */
-static char * symtab_search_one(const char *name, int *startpos)
+char *symtab_fmt_name_lookup(unative_t addr)
 {
-    unsigned int namelen = strlen(name);
-    char *curname;
-    int i, j;
-    int colonoffset = -1;
+    char *name;
+    int rc = symtab_name_lookup(addr, &name);
+    switch (rc) {
+    case EOK:
+        return name;
+    case ENOENT:
+        return "Not found";
+    default:
+        return "N/A";
+    }
+}
-    for (i = 0; name[i]; i++)
-        if (name[i] == ':') {
-            colonoffset = i;
-            break;
-        }
+#ifdef CONFIG_SYMTAB
-    for (i = *startpos; symbol_table[i].address_le; ++i) {
-        /* Find a ':' in name */
-        curname = symbol_table[i].symbol_name;
-        for (j = 0; curname[j] && curname[j] != ':'; j++)
-            ;
-        if (!curname[j])
+/** Find symbols that match the parameter forward and print them.
+ *
+ * @param name     Search string
+ * @param startpos Starting position, changes to found position
+ *
+ * @return Pointer to the part of string that should be completed or NULL.
+ *
+ */
+static const char *symtab_search_one(const char *name, count_t *startpos)
+{
+    count_t namelen = str_length(name);
+    count_t pos;
+    for (pos = *startpos; symbol_table[pos].address_le; pos++) {
+        const char *curname = symbol_table[pos].symbol_name;
+        /* Find a ':' in curname */
+        const char *colon = str_chr(curname, ':');
+        if (colon == NULL)
             continue;
-        j -= colonoffset;
-        curname += j;
-        if (strlen(curname) < namelen)
+        if (str_length(curname) < namelen)
             continue;
-        if (strncmp(curname, name, namelen) == 0) {
-            *startpos = i;
-            return curname + namelen;
+        if (str_lcmp(name, curname, namelen) == 0) {
+            *startpos = pos;
+            return (curname + str_lsize(curname, namelen));
         }
     }
     return NULL;
 }
-/** Return address that corresponds to the entry
+#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 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;
-    i = 0;
-    while ((hint = symtab_search_one(name, &i))) {
-        if (!strlen(hint)) {
-            addr =  uint64_t_le2host(symbol_table[i].address_le);
+    count_t pos = 0;
+    const char *hint;
+    while ((hint = symtab_search_one(name, &pos))) {
+        if (str_length(hint) == 0) {
+            *addr = uint64_t_le2host(symbol_table[pos].address_le);
             found++;
         }
-        i++;
+        pos++;
     }
     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 */
+/** Find symbols that match parameter and print them */
 void symtab_print_search(const char *name)
 {
-    int i;
-    uintptr_t addr;
-    char *realname;
-    i = 0;
-    while (symtab_search_one(name, &i)) {
-        addr =  uint64_t_le2host(symbol_table[i].address_le);
-        realname = symbol_table[i].symbol_name;
+#ifdef CONFIG_SYMTAB
+    count_t pos = 0;
+    while (symtab_search_one(name, &pos)) {
+        uintptr_t addr = uint64_t_le2host(symbol_table[pos].address_le);
+        char *realname = symbol_table[pos].symbol_name;
         printf("%p: %s\n", addr, realname);
-        i++;
+        pos++;
     }
+#else
+    printf("No symbol information available.\n");
+#endif
 }
 /** Symtab completion
  *
- * @param input - Search string, completes to symbol name
- * @returns - 0 - nothing found, 1 - success, >1 print duplicates
+ * @param input Search string, completes to symbol name
+ * @param size  Input buffer size
+ *
+ * @return 0 - nothing found, 1 - success, >1 print duplicates
+ *
  */
-int symtab_compl(char *input)
+int symtab_compl(char *input, count_t size)
 {
-    char output[MAX_SYMBOL_NAME + 1];
-    int startpos = 0;
-    char *foundtxt;
-    int found = 0;
-    int i;
-    char *name = input;
-    /* Allow completion of pointers  */
-    if (name[0] == '*' || name[0] == '&')
+#ifdef CONFIG_SYMTAB
+    const char *name = input;
+    /* Allow completion of pointers */
+    if ((name[0] == '*') || (name[0] == '&'))
         name++;
-    /* Do not print everything */
-    if (!strlen(name))
+    /* Do not print all symbols */
+    if (str_length(name) == 0)
         return 0;
-    output[0] = '\0';
-    while ((foundtxt = symtab_search_one(name, &startpos))) {
-        startpos++;
-        if (!found)
-            strncpy(output, foundtxt, strlen(foundtxt) + 1);
-        else {
-            for (i = 0; output[i] && foundtxt[i] &&
-                 output[i] == foundtxt[i]; i++)
-                ;
-            output[i] = '\0';
-        }
+    count_t found = 0;
+    count_t pos = 0;
+    const char *hint;
+    char output[MAX_SYMBOL_NAME];
+    output[0] = 0;
+    while ((hint = symtab_search_one(name, &pos))) {
+        if ((found == 0) || (str_length(output) > str_length(hint)))
+            str_cpy(output, MAX_SYMBOL_NAME, hint);
+        pos++;
         found++;
     }
-    if (!found)
-        return 0;
-    if (found > 1 && !strlen(output)) {
+    if ((found > 1) && (str_length(output) != 0)) {
         printf("\n");
-        startpos = 0;
-        while ((foundtxt = symtab_search_one(name, &startpos))) {
-            printf("%s\n", symbol_table[startpos].symbol_name);
-            startpos++;
+        pos = 0;
+        while ((hint = symtab_search_one(name, &pos))) {
+            printf("%s\n", symbol_table[pos].symbol_name);
+            pos++;
         }
     }
-    strncpy(input, output, MAX_SYMBOL_NAME);
+    if (found > 0)
+        str_cpy(input, size, output);
     return found;
+#else
+    return 0;
+#endif
 }
 /** @}

 /branches/tracing/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/tracing/kernel/generic/src/sysinfo/sysinfo.c
 ,7 → 163,8
             i = 0;
         }
     }
-    panic("Not reached\n");
+    panic("Not reached.");
     return NULL;
 }

 /branches/tracing/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 → 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);
+            indev_pop_character(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/tracing/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/tracing/kernel/generic/src/time/clock.c
 ,7 → 81,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 → 90,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);
     /*

 /branches/tracing/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/tracing/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/tracing/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
 ,23 → 80,33
 #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.
  */
 static index_t irq_ht_hash(unative_t *key);
 static bool irq_ht_compare(unative_t *key, count_t keys, link_t *item);
+static void irq_ht_remove(link_t *item);
 static hash_table_operations_t irq_ht_ops = {
     .hash = irq_ht_hash,
     .compare = irq_ht_compare,
-    .remove_callback = NULL     /* not used */
+    .remove_callback = irq_ht_remove,
 };
 /**
 ,13 → 117,17
  */
 static index_t irq_lin_hash(unative_t *key);
 static bool irq_lin_compare(unative_t *key, count_t keys, link_t *item);
+static void irq_lin_remove(link_t *item);
 static hash_table_operations_t irq_lin_ops = {
     .hash = irq_lin_hash,
     .compare = irq_lin_compare,
-    .remove_callback = NULL     /* not used */
+    .remove_callback = irq_lin_remove,
 };
+/** 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 → 135,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 → 142,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.
 ,23 → 162,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->cir = NULL;
-    irq->cir_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 → 174,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 → 188,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 → 301,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 → 335,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));
 ,6 → 349,17
     return rv;
 }
+/** Unlock IRQ structure after hash_table_remove().
+ *
+ * @param lnk Link in the removed and locked IRQ structure.
+ */
+void irq_ht_remove(link_t *lnk)
+{
+    irq_t *irq __attribute__((unused))
+        = hash_table_get_instance(lnk, irq_t, link);
+    spinlock_unlock(&irq->lock);
+}
 /** Compute hash index for the key.
  *
  * This function computes hash index into
 ,7 → 406,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);
 ,5 → 419,16
     return rv;
 }
+/** Unlock IRQ structure after hash_table_remove().
+ *
+ * @param lnk       Link in the removed and locked IRQ structure.
+ */
+void irq_lin_remove(link_t *lnk)
+{
+    irq_t *irq __attribute__((unused))
+        = hash_table_get_instance(lnk, irq_t, link);
+    spinlock_unlock(&irq->lock);
+}
 /** @}
  */

 /branches/tracing/kernel/generic/src/console/console.c
 ,79 → 39,70
 #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/event.h>
 #include <ipc/irq.h>
 #include <arch.h>
-#include <func.h>
 #include <print.h>
+#include <putchar.h>
 #include <atomic.h>
+#include <syscall/copy.h>
+#include <errno.h>
+#include <string.h>
-#define KLOG_SIZE PAGE_SIZE
-#define KLOG_LATENCY 8
+#define KLOG_PAGES    4
+#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
+#define KLOG_LATENCY  8
-/**< Kernel log cyclic buffer */
-static char klog[KLOG_SIZE] __attribute__ ((aligned (PAGE_SIZE)));
+/** Kernel log cyclic buffer */
+static wchar_t klog[KLOG_LENGTH] __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 */
+/** 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;
-static chardev_operations_t null_stdout_ops = {
-    .suspend = NULL,
-    .resume = NULL,
-    .write = NULL,
-    .read = NULL
+static indev_operations_t stdin_ops = {
+    .poll = NULL
 };
-chardev_t null_stdout = {
-    .name = "null",
-    .op = &null_stdout_ops
-};
+/** Silence output */
+bool silent = false;
-/** 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)
+/** Standard input and output character devices */
+indev_t *stdin = NULL;
+outdev_t *stdout = NULL;
+indev_t *stdin_wire(void)
 {
-    return IRQ_DECLINE;
+    if (stdin == NULL) {
+        stdin = malloc(sizeof(indev_t), FRAME_ATOMIC);
+        if (stdin != NULL)
+            indev_initialize("stdin", stdin, &stdin_ops);
+    }
+    return stdin;
 }
-/** 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)
 {
 ,26 → 109,13
     void *faddr = (void *) KA2PA(klog);
     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;
+    klog_parea.frames = SIZE2FRAMES(sizeof(klog));
     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);
+    sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
     spinlock_lock(&klog_lock);
     klog_inited = true;
 ,91 → 122,88
     spinlock_unlock(&klog_lock);
 }
-/** Get character from character device. Do not echo character.
- *
- * @param chardev Character device.
- *
- * @return Character read.
- */
-uint8_t _getc(chardev_t *chardev)
+void grab_console(void)
 {
-    uint8_t ch;
-    ipl_t ipl;
+    bool prev = silent;
+    silent = false;
+    arch_grab_console();
+    /* Force the console to print the prompt */
+    if ((stdin) && (prev))
+        indev_push_character(stdin, '\n');
+}
-    if (atomic_get(&haltstate)) {
-        /* 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 (CPU)
-            printf("cpu%u: ", CPU->id);
-        else
-            printf("cpu: ");
-        printf("halted - no kconsole\n");
-        cpu_halt();
-    }
+void release_console(void)
+{
+    silent = true;
+    arch_release_console();
+}
-    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);
-    interrupts_restore(ipl);
+/** 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
+}
-    chardev->op->resume(chardev);
-    return ch;
+/** Tell kernel to relinquish keyboard/console access */
+unative_t sys_debug_disable_console(void)
+{
+    release_console();
+    return true;
 }
-/** 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 NULL.
  * @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);
+    size_t offset = 0;
+    count_t count = 0;
+    buf[offset] = 0;
+    wchar_t ch;
+    while ((ch = indev_pop_character(indev)) != '\n') {
         if (ch == '\b') {
-            if (index > 0) {
-                index--;
-                /* Space backspace, space */
+            if (count > 0) {
+                /* Space, backspace, space */
                 putchar('\b');
                 putchar(' ');
                 putchar('\b');
+                count--;
+                offset = str_lsize(buf, count);
+                buf[offset] = 0;
             }
-            continue;
-        }
-        putchar(ch);
-        if (ch == '\n') { /* end of string => write 0, return */
-            buf[index] = '\0';
-            return (count_t) index;
         }
-        buf[index++] = ch;
+        if (chr_encode(ch, buf, &offset, buflen - 1) == EOK) {
+            putchar(ch);
+            count++;
+            buf[offset] = 0;
+        }
     }
-    return (count_t) index;
+    return count;
 }
-/** Get character from device & echo it to screen */
-uint8_t getc(chardev_t *chardev)
+/** Get character from input device & echo it to screen */
+wchar_t getc(indev_t *indev)
 {
-    uint8_t ch;
-    ch = _getc(chardev);
+    wchar_t ch = indev_pop_character(indev);
     putchar(ch);
     return ch;
 }
 ,8 → 212,8
 {
     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);
+    if ((klog_inited) && (event_is_subscribed(EVENT_KLOG)) && (klog_uspace > 0)) {
+        event_notify_3(EVENT_KLOG, klog_start, klog_len, klog_uspace);
         klog_uspace = 0;
     }
 ,27 → 220,27
     spinlock_unlock(&klog_lock);
 }
-void putchar(char c)
+void putchar(const wchar_t ch)
 {
     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_LENGTH], silent);
         klog_stored = 0;
     }
     /* Store character in the cyclic kernel log */
-    klog[(klog_start + klog_len) % KLOG_SIZE] = c;
-    if (klog_len < KLOG_SIZE)
+    klog[(klog_start + klog_len) % KLOG_LENGTH] = ch;
+    if (klog_len < KLOG_LENGTH)
         klog_len++;
     else
-        klog_start = (klog_start + 1) % KLOG_SIZE;
+        klog_start = (klog_start + 1) % KLOG_LENGTH;
-    if (stdout->op->write)
-        stdout->op->write(stdout, c);
+    if ((stdout) && (stdout->op->write))
+        stdout->op->write(stdout, ch, silent);
     else {
         /* The character is just in the kernel log */
         if (klog_stored < klog_len)
 ,7 → 253,7
     /* Check notify uspace to update */
     bool update;
-    if ((klog_uspace > KLOG_LATENCY) || (c == '\n'))
+    if ((klog_uspace > KLOG_LATENCY) || (ch == '\n'))
         update = true;
     else
         update = false;
 ,5 → 264,38
         klog_update();
 }
+/** Print using kernel facility
+ *
+ * Print to kernel log.
+ *
+ */
+unative_t sys_klog(int fd, const void *buf, size_t size)
+{
+    char *data;
+    int rc;
+    if (size > PAGE_SIZE)
+        return ELIMIT;
+    if (size > 0) {
+        data = (char *) malloc(size + 1, 0);
+        if (!data)
+            return ENOMEM;
+        rc = copy_from_uspace(data, buf, size);
+        if (rc) {
+            free(data);
+            return rc;
+        }
+        data[size] = 0;
+        printf("%s", data);
+        free(data);
+    } else
+        klog_update();
+    return size;
+}
 /** @}
  */

 /branches/tracing/kernel/generic/src/console/cmd.c
 ,8 → 31,8
  */
 /**
- * @file    cmd.c
- * @brief   Kernel console command wrappers.
+ * @file  cmd.c
+ * @brief Kernel console command wrappers.
  *
  * This file is meant to contain all wrapper functions for
  * all kconsole commands. The point is in separating
 ,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,9
 #include <proc/task.h>
 #include <ipc/ipc.h>
 #include <ipc/irq.h>
+#include <ipc/event.h>
+#include <symtab.h>
+#include <errno.h>
 #ifdef CONFIG_TEST
 #include <test.h>
 ,12 → 81,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",
 ,7 → 453,6
     &continue_info,
     &cpus_info,
     &desc_info,
-    &exit_info,
     &reboot_info,
     &uptime_info,
     &halt_info,
 ,7 → 497,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 → 510,31
  */
 int cmd_help(cmd_arg_t *argv)
 {
-    link_t *cur;
     spinlock_lock(&cmd_lock);
+    link_t *cur;
+    count_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 (str_length(hlp->name) > len)
+            len = str_length(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;
 }
 ,7 → 582,7
 int cmd_desc(cmd_arg_t *argv)
 {
     link_t *cur;
     spinlock_lock(&cmd_lock);
     for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
 ,8 → 590,8
         hlp = list_get_instance(cur, cmd_info_t, link);
         spinlock_lock(&hlp->lock);
-        if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
+        if (str_lcmp(hlp->name, (const char *) argv->buffer, str_length(hlp->name)) == 0) {
             printf("%s - %s\n", hlp->name, hlp->description);
             if (hlp->help)
                 hlp->help();
 ,12 → 598,12
             spinlock_unlock(&hlp->lock);
             break;
         }
         spinlock_unlock(&hlp->lock);
     }
     spinlock_unlock(&cmd_lock);
     return 1;
 }
 ,33 → 620,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 → 677,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 → 706,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 → 736,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 → 808,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;
 ,8 → 953,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();
+    event_notify_0(EVENT_KCONSOLE);
+    indev_pop_character(stdin);
     return 1;
 }
 ,18 → 970,23
  */
 int cmd_tests(cmd_arg_t *argv)
 {
+    count_t len = 0;
     test_t *test;
+    for (test = tests; test->name != NULL; test++) {
+        if (str_length(test->name) > len)
+            len = str_length(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 */
 ,7 → 997,8
     interrupts_restore(ipl);
     /* Execute the test */
-    char * ret = test->entry(false);
+    test_quiet = false;
+    char *ret = test->entry();
     /* Update and read thread accounting */
     ipl = interrupts_disable();
 ,7 → 1050,8
         interrupts_restore(ipl);
         /* Execute the test */
-        char * ret = test->entry(true);
+        test_quiet = true;
+        char * ret = test->entry();
         /* Update and read thread accounting */
         ipl = interrupts_disable();
 ,7 → 1099,7
 {
     test_t *test;
-    if (strcmp((char *) argv->buffer, "*") == 0) {
+    if (str_cmp((char *) argv->buffer, "*") == 0) {
         for (test = tests; test->name != NULL; test++) {
             if (test->safe) {
                 printf("\n");
 ,7 → 1111,7
         bool fnd = false;
         for (test = tests; test->name != NULL; test++) {
-            if (strcmp(test->name, (char *) argv->buffer) == 0) {
+            if (str_cmp(test->name, (char *) argv->buffer) == 0) {
                 fnd = true;
                 run_test(test);
                 break;
 ,24 → 1136,33
     test_t *test;
     uint32_t cnt = argv[1].intval;
-    bool fnd = false;
-    for (test = tests; test->name != NULL; test++) {
-        if (strcmp(test->name, (char *) argv->buffer) == 0) {
-            fnd = true;
-            if (test->safe)
-                run_bench(test, cnt);
-            else
-                printf("Unsafe test\n");
-            break;
+    if (str_cmp((char *) argv->buffer, "*") == 0) {
+        for (test = tests; test->name != NULL; test++) {
+            if (test->safe) {
+                if (!run_bench(test, cnt))
+                    break;
+            }
         }
+    } else {
+        bool fnd = false;
+        for (test = tests; test->name != NULL; test++) {
+            if (str_cmp(test->name, (char *) argv->buffer) == 0) {
+                fnd = true;
+                if (test->safe)
+                    run_bench(test, cnt);
+                else
+                    printf("Unsafe test\n");
+                break;
+            }
+        }
+        if (!fnd)
+            printf("Unknown test\n");
     }
-    if (!fnd)
-        printf("Unknown test\n");
     return 1;
 }

 /branches/tracing/kernel/generic/src/console/chardev.c
 ,46 → 33,119
  */
 #include <console/chardev.h>
-#include <putchar.h>
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
+#include <print.h>
+#include <func.h>
+#include <arch.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, wchar_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);
 }
+/** Pop character from input character device.
+ *
+ * @param indev Input character device.
+ *
+ * @return Character read.
+ *
+ */
+wchar_t indev_pop_character(indev_t *indev)
+{
+    if (atomic_get(&haltstate)) {
+        /* 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 (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 polling input)\n");
+        cpu_halt();
+    }
+    waitq_sleep(&indev->wq);
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&indev->lock);
+    wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
+    indev->counter--;
+    spinlock_unlock(&indev->lock);
+    interrupts_restore(ipl);
+    return ch;
+}
+/** 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;
+}
+bool check_poll(indev_t *indev)
+{
+    if (indev == NULL)
+        return false;
+    if (indev->op == NULL)
+        return false;
+    return (indev->op->poll != NULL);
+}
 /** @}
  */

 /branches/tracing/kernel/generic/src/console/kconsole.c
 ,10 → 31,11
  */
 /**
- * @file    kconsole.c
- * @brief   Kernel console.
+ * @file  kconsole.c
+ * @brief Kernel console.
  *
  * This file contains kernel thread managing the kernel console.
+ *
  */
 #include <console/kconsole.h>
 ,8 → 50,14
 #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>
+#include <putchar.h>
+#include <string.h>
 /** Simple kernel console.
  *
 ,7 → 66,7
  * but makes it possible for other kernel subsystems to
  * register their own commands.
  */
 /** Locking.
  *
  * There is a list of cmd_info_t structures. This list
 ,33 → 81,36
  * When locking two cmd info structures, structure with
  * lower address must be locked first.
  */
-SPINLOCK_INITIALIZE(cmd_lock);  /**< Lock protecting command list. */
-LIST_INITIALIZE(cmd_head);  /**< Command list. */
-static cmd_info_t *parse_cmdline(char *cmdline, size_t len);
-static bool parse_argument(char *cmdline, size_t len, index_t *start,
-    index_t *end);
-static char history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
+SPINLOCK_INITIALIZE(cmd_lock);  /**< Lock protecting command list. */
+LIST_INITIALIZE(cmd_head);      /**< Command list. */
-/** Initialize kconsole data structures. */
+static wchar_t history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
+static count_t history_pos = 0;
+/** 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++)
-        history[i][0] = '\0';
+        history[i][0] = 0;
 }
 /** Register kconsole command.
  *
  * @param cmd Structure describing the command.
  *
- * @return 0 on failure, 1 on success.
+ * @return False on failure, true on success.
+ *
  */
-int cmd_register(cmd_info_t *cmd)
+bool cmd_register(cmd_info_t *cmd)
 {
     link_t *cur;
 ,16 → 120,14
      * Make sure the command is not already listed.
      */
     for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
-        cmd_info_t *hlp;
+        cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
-        hlp = list_get_instance(cur, cmd_info_t, link);
         if (hlp == cmd) {
             /* The command is already there. */
             spinlock_unlock(&cmd_lock);
-            return 0;
+            return false;
         }
         /* Avoid deadlock. */
         if (hlp < cmd) {
             spinlock_lock(&hlp->lock);
 ,13 → 136,13
             spinlock_lock(&cmd->lock);
             spinlock_lock(&hlp->lock);
         }
-        if ((strncmp(hlp->name, cmd->name, max(strlen(cmd->name),
-            strlen(hlp->name))) == 0)) {
+        if (str_cmp(hlp->name, cmd->name) == 0) {
             /* The command is already there. */
             spinlock_unlock(&hlp->lock);
             spinlock_unlock(&cmd->lock);
             spinlock_unlock(&cmd_lock);
-            return 0;
+            return false;
         }
         spinlock_unlock(&hlp->lock);
 ,294 → 155,274
     list_append(&cmd->link, &cmd_head);
     spinlock_unlock(&cmd_lock);
-    return 1;
+    return true;
 }
 /** Print count times a character */
-static void rdln_print_c(char ch, int count)
+static void print_cc(wchar_t ch, count_t count)
 {
-    int i;
+    count_t i;
     for (i = 0; i < count; i++)
         putchar(ch);
 }
-/** Insert character to string */
-static void insert_char(char *str, char ch, int pos)
+/** Try to find a command beginning with prefix */
+static const char *cmdtab_search_one(const char *name, link_t **startpos)
 {
-    int i;
+    count_t namelen = str_length(name);
-    for (i = strlen(str); i > pos; i--)
-        str[i] = str[i - 1];
-    str[pos] = ch;
-}
-/** Try to find a command beginning with prefix */
-static const char *cmdtab_search_one(const char *name,link_t **startpos)
-{
-    size_t namelen = strlen(name);
-    const char *curname;
     spinlock_lock(&cmd_lock);
-    if (!*startpos)
+    if (*startpos == NULL)
         *startpos = cmd_head.next;
     for (; *startpos != &cmd_head; *startpos = (*startpos)->next) {
-        cmd_info_t *hlp;
-        hlp = list_get_instance(*startpos, cmd_info_t, link);
-        curname = hlp->name;
-        if (strlen(curname) < namelen)
+        cmd_info_t *hlp = list_get_instance(*startpos, cmd_info_t, link);
+        const char *curname = hlp->name;
+        if (str_length(curname) < namelen)
             continue;
-        if (strncmp(curname, name, namelen) == 0) {
-            spinlock_unlock(&cmd_lock);
-            return curname+namelen;
+        if (str_lcmp(curname, name, namelen) == 0) {
+            spinlock_unlock(&cmd_lock);
+            return (curname + str_lsize(curname, namelen));
         }
     }
-    spinlock_unlock(&cmd_lock);
+    spinlock_unlock(&cmd_lock);
     return NULL;
 }
-/** Command completion of the commands
+/** Command completion of the commands
  *
- * @param name - string to match, changed to hint on exit
- * @return number of found matches
+ * @param name String to match, changed to hint on exit
+ * @param size Input buffer size
+ *
+ * @return Number of found matches
+ *
  */
-static int cmdtab_compl(char *name)
+static int cmdtab_compl(char *input, size_t size)
 {
-    static char output[MAX_SYMBOL_NAME + 1];
-    link_t *startpos = NULL;
-    const char *foundtxt;
-    int found = 0;
-    int i;
-    output[0] = '\0';
-    while ((foundtxt = cmdtab_search_one(name, &startpos))) {
-        startpos = startpos->next;
-        if (!found)
-            strncpy(output, foundtxt, strlen(foundtxt) + 1);
-        else {
-            for (i = 0; output[i] && foundtxt[i] &&
-                output[i] == foundtxt[i]; i++)
-                ;
-            output[i] = '\0';
-        }
+    const char *name = input;
+    count_t found = 0;
+    link_t *pos = NULL;
+    const char *hint;
+    char output[MAX_CMDLINE];
+    output[0] = 0;
+    while ((hint = cmdtab_search_one(name, &pos))) {
+        if ((found == 0) || (str_length(output) > str_length(hint)))
+            str_cpy(output, MAX_CMDLINE, hint);
+        pos = pos->next;
         found++;
     }
-    if (!found)
-        return 0;
-    if (found > 1 && !strlen(output)) {
+    if ((found > 1) && (str_length(output) != 0)) {
         printf("\n");
-        startpos = NULL;
-        while ((foundtxt = cmdtab_search_one(name, &startpos))) {
-            cmd_info_t *hlp;
-            hlp = list_get_instance(startpos, cmd_info_t, link);
-            printf("%s - %s\n", hlp->name, hlp->description);
-            startpos = startpos->next;
+        pos = NULL;
+        while ((hint = cmdtab_search_one(name, &pos))) {
+            cmd_info_t *hlp = list_get_instance(pos, cmd_info_t, link);
+            printf("%s (%s)\n", hlp->name, hlp->description);
+            pos = pos->next;
         }
     }
-    strncpy(name, output, MAX_SYMBOL_NAME);
+    if (found > 0)
+        str_cpy(input, size, output);
     return found;
 }
-static char *clever_readline(const char *prompt, chardev_t *input)
+static wchar_t *clever_readline(const char *prompt, indev_t *indev)
 {
-    static int histposition = 0;
-    static char tmp[MAX_CMDLINE + 1];
-    int curlen = 0, position = 0;
-    char *current = history[histposition];
-    int i;
-    char mod; /* Command Modifier */
-    char c;
     printf("%s> ", prompt);
-    while (1) {
-        c = _getc(input);
-        if (c == '\n') {
-            putchar(c);
+    count_t position = 0;
+    wchar_t *current = history[history_pos];
+    current[0] = 0;
+    while (true) {
+        wchar_t ch = indev_pop_character(indev);
+        if (ch == '\n') {
+            /* Enter */
+            putchar(ch);
             break;
         }
-        if (c == '\b') { /* Backspace */
+        if (ch == '\b') {
+            /* Backspace */
             if (position == 0)
                 continue;
-            for (i = position; i < curlen; i++)
-                current[i - 1] = current[i];
-            curlen--;
-            position--;
-            putchar('\b');
-            for (i = position; i < curlen; i++)
-                putchar(current[i]);
-            putchar(' ');
-            rdln_print_c('\b', curlen - position + 1);
-            continue;
+            if (wstr_remove(current, position - 1)) {
+                position--;
+                putchar('\b');
+                printf("%ls ", current + position);
+                print_cc('\b', wstr_length(current) - position + 1);
+                continue;
+            }
         }
-        if (c == '\t') { /* Tabulator */
-            int found;
+        if (ch == '\t') {
+            /* Tab completion */
             /* Move to the end of the word */
-            for (; position < curlen && current[position] != ' ';
+            for (; (current[position] != 0) && (!isspace(current[position]));
                 position++)
                 putchar(current[position]);
-            /* Copy to tmp last word */
-            for (i = position - 1; i >= 0 && current[i] != ' '; i--)
-                ;
-            /* If word begins with * or &, skip it */
-            if (tmp[0] == '*' || tmp[0] == '&')
-                for (i = 1; tmp[i]; i++)
-                    tmp[i - 1] = tmp[i];
-            i++; /* I is at the start of the word */
-            strncpy(tmp, current + i, position - i + 1);
-            if (i == 0) { /* Command completion */
-                found = cmdtab_compl(tmp);
-            } else { /* Symtab completion */
-                found = symtab_compl(tmp);
+            if (position == 0)
+                continue;
+            /* Find the beginning of the word
+               and copy it to tmp */
+            count_t beg;
+            for (beg = position - 1; (beg > 0) && (!isspace(current[beg]));
+                beg--);
+            if (isspace(current[beg]))
+                beg++;
+            char tmp[STR_BOUNDS(MAX_CMDLINE)];
+            wstr_nstr(tmp, current + beg, position - beg + 1);
+            int found;
+            if (beg == 0) {
+                /* Command completion */
+                found = cmdtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE));
+            } else {
+                /* Symbol completion */
+                found = symtab_compl(tmp, STR_BOUNDS(MAX_CMDLINE));
             }
-            if (found == 0)
+            if (found == 0)
                 continue;
-            for (i = 0; tmp[i] && curlen < MAX_CMDLINE;
-                i++, curlen++)
-                insert_char(current, tmp[i], i + position);
-            if (strlen(tmp) || found == 1) { /* If we have a hint */
-                for (i = position; i < curlen; i++)
-                    putchar(current[i]);
-                position += strlen(tmp);
-                /* Add space to end */
-                if (found == 1 && position == curlen &&
-                    curlen < MAX_CMDLINE) {
-                    current[position] = ' ';
-                    curlen++;
+            if (found > 1) {
+                /* No unique hint, list was printed */
+                printf("%s> ", prompt);
+                printf("%ls", current);
+                print_cc('\b', wstr_length(current) - position);
+                continue;
+            }
+            /* We have a hint */
+            size_t off = 0;
+            count_t i = 0;
+            while ((ch = str_decode(tmp, &off, STR_NO_LIMIT)) != 0) {
+                if (!wstr_linsert(current, ch, position + i, MAX_CMDLINE))
+                    break;
+                i++;
+            }
+            printf("%ls", current + position);
+            position += str_length(tmp);
+            print_cc('\b', wstr_length(current) - position);
+            if (position == wstr_length(current)) {
+                /* Insert a space after the last completed argument */
+                if (wstr_linsert(current, ' ', position, MAX_CMDLINE)) {
+                    printf("%ls", current + position);
                     position++;
-                    putchar(' ');
                 }
-            } else { /* No hint, table was printed */
-                printf("%s> ", prompt);
-                for (i = 0; i < curlen; i++)
-                    putchar(current[i]);
-                position += strlen(tmp);
             }
-            rdln_print_c('\b', curlen - position);
             continue;
         }
-        if (c == 0x1b) { /* Special command */
-            mod = _getc(input);
-            c = _getc(input);
-            if (mod != 0x5b && mod != 0x4f)
-                continue;
-            if (c == 0x33 && _getc(input) == 0x7e) {
-                /* Delete */
-                if (position == curlen)
-                    continue;
-                for (i = position + 1; i < curlen; i++) {
-                    putchar(current[i]);
-                    current[i - 1] = current[i];
-                }
-                putchar(' ');
-                rdln_print_c('\b', curlen - position);
-                curlen--;
-            } else if (c == 0x48) { /* Home */
-                rdln_print_c('\b', position);
-                position = 0;
-            } else if (c == 0x46) {  /* End */
-                for (i = position; i < curlen; i++)
-                    putchar(current[i]);
-                position = curlen;
-            } else if (c == 0x44) { /* Left */
-                if (position > 0) {
-                    putchar('\b');
-                    position--;
-                }
-                continue;
-            } else if (c == 0x43) { /* Right */
-                if (position < curlen) {
-                    putchar(current[position]);
-                    position++;
-                }
-                continue;
-            } else if (c == 0x41 || c == 0x42) {
-                                /* Up, down */
-                rdln_print_c('\b', position);
-                rdln_print_c(' ', curlen);
-                rdln_print_c('\b', curlen);
-                if (c == 0x41) /* Up */
-                    histposition--;
+        if (ch == U_LEFT_ARROW) {
+            /* Left */
+            if (position > 0) {
+                putchar('\b');
+                position--;
+            }
+            continue;
+        }
+        if (ch == U_RIGHT_ARROW) {
+            /* Right */
+            if (position < wstr_length(current)) {
+                putchar(current[position]);
+                position++;
+            }
+            continue;
+        }
+        if ((ch == U_UP_ARROW) || (ch == U_DOWN_ARROW)) {
+            /* Up, down */
+            print_cc('\b', position);
+            print_cc(' ', wstr_length(current));
+            print_cc('\b', wstr_length(current));
+            if (ch == U_UP_ARROW) {
+                /* Up */
+                if (history_pos == 0)
+                    history_pos = KCONSOLE_HISTORY - 1;
                 else
-                    histposition++;
-                if (histposition < 0) {
-                    histposition = KCONSOLE_HISTORY - 1;
-                } else {
-                    histposition =
-                        histposition % KCONSOLE_HISTORY;
-                }
-                current = history[histposition];
-                printf("%s", current);
-                curlen = strlen(current);
-                position = curlen;
+                    history_pos--;
+            } else {
+                /* Down */
+                history_pos++;
+                history_pos = history_pos % KCONSOLE_HISTORY;
+            }
+            current = history[history_pos];
+            printf("%ls", current);
+            position = wstr_length(current);
+            continue;
+        }
+        if (ch == U_HOME_ARROW) {
+            /* Home */
+            print_cc('\b', position);
+            position = 0;
+            continue;
+        }
+        if (ch == U_END_ARROW) {
+            /* End */
+            printf("%ls", current + position);
+            position = wstr_length(current);
+            continue;
+        }
+        if (ch == U_DELETE) {
+            /* Delete */
+            if (position == wstr_length(current))
                 continue;
+            if (wstr_remove(current, position)) {
+                printf("%ls ", current + position);
+                print_cc('\b', wstr_length(current) - position + 1);
             }
             continue;
         }
-        if (curlen >= MAX_CMDLINE)
-            continue;
-        insert_char(current, c, position);
-        curlen++;
-        for (i = position; i < curlen; i++)
-            putchar(current[i]);
-        position++;
-        rdln_print_c('\b',curlen - position);
-    }
-    if (curlen) {
-        histposition++;
-        histposition = histposition % KCONSOLE_HISTORY;
+        if (wstr_linsert(current, ch, position, MAX_CMDLINE)) {
+            printf("%ls", current + position);
+            position++;
+            print_cc('\b', wstr_length(current) - position);
+        }
     }
-    current[curlen] = '\0';
+    if (wstr_length(current) > 0) {
+        history_pos++;
+        history_pos = history_pos % KCONSOLE_HISTORY;
+    }
     return current;
 }
-/** Kernel console managing thread.
- *
- * @param prompt Kernel console prompt (e.g kconsole/panic).
- */
-void kconsole(void *prompt)
+bool kconsole_check_poll(void)
 {
-    cmd_info_t *cmd_info;
-    count_t len;
-    char *cmdline;
-    if (!stdin) {
-        printf("%s: no stdin\n", __func__);
-        return;
-    }
-    while (true) {
-        cmdline = clever_readline((char *) prompt, stdin);
-        len = strlen(cmdline);
-        if (!len)
-            continue;
-        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);
-    }
+    return check_poll(stdin);
 }
-static int parse_int_arg(char *text, size_t len, unative_t *result)
+static bool parse_int_arg(const char *text, size_t len, unative_t *result)
 {
-    static char symname[MAX_SYMBOL_NAME];
-    uintptr_t symaddr;
     bool isaddr = false;
     bool isptr = false;
 ,63 → 436,113
         text++;
         len--;
     }
-    if (text[0] < '0' || text[0] > '9') {
-        strncpy(symname, text, min(len + 1, MAX_SYMBOL_NAME));
-        symaddr = get_symbol_addr(symname);
-        if (!symaddr) {
+    if ((text[0] < '0') || (text[0] > '9')) {
+        char symname[MAX_SYMBOL_NAME];
+        str_ncpy(symname, MAX_SYMBOL_NAME, text, len + 1);
+        uintptr_t symaddr;
+        int rc = symtab_addr_lookup(symname, &symaddr);
+        switch (rc) {
+        case ENOENT:
             printf("Symbol %s not found.\n", symname);
-            return -1;
-        }
-        if (symaddr == (uintptr_t) -1) {
+            return false;
+        case EOVERFLOW:
             printf("Duplicate symbol %s.\n", symname);
             symtab_print_search(symname);
-            return -1;
+            return false;
+        case ENOTSUP:
+            printf("No symbol information available.\n");
+            return false;
         }
         if (isaddr)
-            *result = (unative_t)symaddr;
+            *result = (unative_t) symaddr;
         else if (isptr)
-            *result = **((unative_t **)symaddr);
+            *result = **((unative_t **) symaddr);
         else
-            *result = *((unative_t *)symaddr);
-    } else { /* It's a number - convert it */
+            *result = *((unative_t *) symaddr);
+    } else {
+        /* It's a number - convert it */
         *result = atoi(text);
         if (isptr)
-            *result = *((unative_t *)*result);
+            *result = *((unative_t *) *result);
     }
+    return true;
+}
-    return 0;
+/** Parse argument.
+ *
+ * Find start and end positions of command line argument.
+ *
+ * @param cmdline Command line as read from the input device.
+ * @param size    Size (in bytes) of the string.
+ * @param start   On entry, 'start' contains pointer to the offset
+ *                of the first unprocessed character of cmdline.
+ *                On successful exit, it marks beginning of the next argument.
+ * @param end     Undefined on entry. On exit, 'end' is the offset of the first
+ *                character behind the next argument.
+ *
+ * @return False on failure, true on success.
+ *
+ */
+static bool parse_argument(const char *cmdline, size_t size, size_t *start, size_t *end)
+{
+    ASSERT(start != NULL);
+    ASSERT(end != NULL);
+    bool found_start = false;
+    size_t offset = *start;
+    size_t prev = *start;
+    wchar_t ch;
+    while ((ch = str_decode(cmdline, &offset, size)) != 0) {
+        if (!found_start) {
+            if (!isspace(ch)) {
+                *start = prev;
+                found_start = true;
+            }
+        } else {
+            if (isspace(ch))
+                break;
+        }
+        prev = offset;
+    }
+    *end = prev;
+    return found_start;
 }
 /** Parse command line.
  *
- * @param cmdline Command line as read from input device.
- * @param len Command line length.
+ * @param cmdline Command line as read from input device.
+ * @param size    Size (in bytes) of the string.
  *
  * @return Structure describing the command.
+ *
  */
-cmd_info_t *parse_cmdline(char *cmdline, size_t len)
+static cmd_info_t *parse_cmdline(const char *cmdline, size_t size)
 {
-    index_t start = 0, end = 0;
-    cmd_info_t *cmd = NULL;
-    link_t *cur;
-    count_t i;
-    int error = 0;
-    if (!parse_argument(cmdline, len, &start, &end)) {
+    size_t start = 0;
+    size_t end = 0;
+    if (!parse_argument(cmdline, size, &start, &end)) {
         /* Command line did not contain alphanumeric word. */
         return NULL;
     }
     spinlock_lock(&cmd_lock);
+    cmd_info_t *cmd = NULL;
+    link_t *cur;
     for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
-        cmd_info_t *hlp;
-        hlp = list_get_instance(cur, cmd_info_t, link);
+        cmd_info_t *hlp = list_get_instance(cur, cmd_info_t, link);
         spinlock_lock(&hlp->lock);
-        if (strncmp(hlp->name, &cmdline[start], max(strlen(hlp->name),
-            end - start + 1)) == 0) {
+        if (str_lcmp(hlp->name, cmdline + start,
+            max(str_length(hlp->name),
+            str_nlength(cmdline + start, (count_t) (end - start) - 1))) == 0) {
             cmd = hlp;
             break;
         }
 ,7 → 550,7
         spinlock_unlock(&hlp->lock);
     }
-    spinlock_unlock(&cmd_lock);
+    spinlock_unlock(&cmd_lock);
     if (!cmd) {
         /* Unknown command. */
 ,7 → 557,7
         printf("Unknown command.\n");
         return NULL;
     }
     /* cmd == hlp is locked */
     /*
 ,52 → 566,54
      * converted to those specified in the cmd info
      * structure.
      */
+    bool error = false;
+    count_t i;
     for (i = 0; i < cmd->argc; i++) {
-        char *buf;
-        start = end + 1;
-        if (!parse_argument(cmdline, len, &start, &end)) {
+        start = end;
+        if (!parse_argument(cmdline, size, &start, &end)) {
             printf("Too few arguments.\n");
             spinlock_unlock(&cmd->lock);
             return NULL;
         }
-        error = 0;
+        char *buf;
         switch (cmd->argv[i].type) {
         case ARG_TYPE_STRING:
             buf = (char *) cmd->argv[i].buffer;
-            strncpy(buf, (const char *) &cmdline[start],
-                min((end - start) + 2, cmd->argv[i].len));
-            buf[min((end - start) + 1, cmd->argv[i].len - 1)] =
-                '\0';
+            str_ncpy(buf, cmd->argv[i].len, cmdline + start,
+                end - start);
             break;
-        case ARG_TYPE_INT:
-            if (parse_int_arg(cmdline + start, end - start + 1,
+        case ARG_TYPE_INT:
+            if (!parse_int_arg(cmdline + start, end - start,
                 &cmd->argv[i].intval))
-                error = 1;
+                error = true;
             break;
         case ARG_TYPE_VAR:
-            if (start != end && cmdline[start] == '"' &&
-                cmdline[end] == '"') {
-                buf = (char *) cmd->argv[i].buffer;
-                strncpy(buf, (const char *) &cmdline[start + 1],
-                    min((end-start), cmd->argv[i].len));
-                buf[min((end - start), cmd->argv[i].len - 1)] =
-                    '\0';
-                cmd->argv[i].intval = (unative_t) buf;
-                cmd->argv[i].vartype = ARG_TYPE_STRING;
-            } else if (!parse_int_arg(cmdline + start,
-                end - start + 1, &cmd->argv[i].intval)) {
+            if ((start < end - 1) && (cmdline[start] == '"')) {
+                if (cmdline[end - 1] == '"') {
+                    buf = (char *) cmd->argv[i].buffer;
+                    str_ncpy(buf, cmd->argv[i].len,
+                        cmdline + start + 1,
+                        (end - start) - 1);
+                    cmd->argv[i].intval = (unative_t) buf;
+                    cmd->argv[i].vartype = ARG_TYPE_STRING;
+                } else {
+                    printf("Wrong synxtax.\n");
+                    error = true;
+                }
+            } else if (parse_int_arg(cmdline + start,
+                end - start, &cmd->argv[i].intval)) {
                 cmd->argv[i].vartype = ARG_TYPE_INT;
             } else {
                 printf("Unrecognized variable argument.\n");
-                error = 1;
+                error = true;
             }
             break;
         case ARG_TYPE_INVALID:
         default:
-            printf("invalid argument type\n");
-            error = 1;
+            printf("Invalid argument type\n");
+            error = true;
             break;
         }
     }
 ,8 → 623,8
         return NULL;
     }
-    start = end + 1;
-    if (parse_argument(cmdline, len, &start, &end)) {
+    start = end;
+    if (parse_argument(cmdline, size, &start, &end)) {
         printf("Too many arguments.\n");
         spinlock_unlock(&cmd->lock);
         return NULL;
 ,42 → 634,55
     return cmd;
 }
-/** Parse argument.
+/** Kernel console prompt.
  *
- * Find start and end positions of command line argument.
+ * @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.
  *
- * @param cmdline Command line as read from the input device.
- * @param len Number of characters in cmdline.
- * @param start On entry, 'start' contains pointer to the index
- *        of first unprocessed character of cmdline.
- *        On successful exit, it marks beginning of the next argument.
- * @param end Undefined on entry. On exit, 'end' points to the last character
- *        of the next argument.
- *
- * @return false on failure, true on success.
  */
-bool parse_argument(char *cmdline, size_t len, index_t *start, index_t *end)
+void kconsole(char *prompt, char *msg, bool kcon)
 {
-    index_t i;
-    bool found_start = false;
+    if (!stdin) {
+        LOG("No stdin for kernel console");
+        return;
+    }
-    ASSERT(start != NULL);
-    ASSERT(end != NULL);
+    if (msg)
+        printf("%s", msg);
-    for (i = *start; i < len; i++) {
-        if (!found_start) {
-            if (isspace(cmdline[i]))
-                (*start)++;
-            else
-                found_start = true;
-        } else {
-            if (isspace(cmdline[i]))
-                break;
-        }
+    if (kcon)
+        indev_pop_character(stdin);
+    else
+        printf("Type \"exit\" to leave the console.\n");
+    while (true) {
+        wchar_t *tmp = clever_readline((char *) prompt, stdin);
+        count_t len = wstr_length(tmp);
+        if (!len)
+            continue;
+        char cmdline[STR_BOUNDS(MAX_CMDLINE)];
+        wstr_nstr(cmdline, tmp, STR_BOUNDS(MAX_CMDLINE));
+        if ((!kcon) && (len == 4) && (str_lcmp(cmdline, "exit", 4) == 0))
+            break;
+        cmd_info_t *cmd_info = parse_cmdline(cmdline, STR_BOUNDS(MAX_CMDLINE));
+        if (!cmd_info)
+            continue;
+        (void) cmd_info->func(cmd_info->argv);
     }
-    *end = i - 1;
+}
-    return found_start;
+/** Kernel console managing thread.
+ *
+ */
+void kconsole_thread(void *data)
+{
+    kconsole("kconsole", "Kernel console ready (press any key to activate)\n", true);
 }
 /** @}

 /branches/tracing/kernel/generic/src/printf/printf.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,19 → 33,18
  */
 #include <print.h>
-int printf(const char *fmt, ...);
 int printf(const char *fmt, ...)
 {
     int ret;
     va_list args;
     va_start(args, fmt);
     ret = vprintf(fmt, args);
     va_end(args);
     return ret;
 }

 /branches/tracing/kernel/generic/src/printf/snprintf.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,9 → 42,9
     va_start(args, fmt);
     ret = vsnprintf(str, size, fmt, args);
     va_end(args);
     return ret;
 }

 /branches/tracing/kernel/generic/src/printf/vprintf.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,36 → 39,66
 #include <arch/asm.h>
 #include <arch/types.h>
 #include <typedefs.h>
+#include <string.h>
-SPINLOCK_INITIALIZE(printf_lock);           /**< vprintf spinlock */
+SPINLOCK_INITIALIZE(printf_lock);  /**< vprintf spinlock */
-static int vprintf_write(const char *str, size_t count, void *unused)
+static int vprintf_str_write(const char *str, size_t size, void *data)
 {
-    size_t i;
-    for (i = 0; i < count; i++)
-        putchar(str[i]);
-    return i;
+    size_t offset = 0;
+    count_t chars = 0;
+    while (offset < size) {
+        putchar(str_decode(str, &offset, size));
+        chars++;
+    }
+    return chars;
 }
-int puts(const char *s)
+static int vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
 {
-    size_t i;
-    for (i = 0; s[i] != 0; i++)
-        putchar(s[i]);
-    return i;
+    size_t offset = 0;
+    count_t chars = 0;
+    while (offset < size) {
+        putchar(str[chars]);
+        chars++;
+        offset += sizeof(wchar_t);
+    }
+    return chars;
 }
+int puts(const char *str)
+{
+    size_t offset = 0;
+    count_t chars = 0;
+    wchar_t uc;
+    while ((uc = str_decode(str, &offset, STR_NO_LIMIT)) != 0) {
+        putchar(uc);
+        chars++;
+    }
+    return chars;
+}
 int vprintf(const char *fmt, va_list ap)
 {
-    struct printf_spec ps = {(int(*)(void *, size_t, void *)) vprintf_write, NULL};
+    printf_spec_t ps = {
+        vprintf_str_write,
+        vprintf_wstr_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/tracing/kernel/generic/src/printf/vsnprintf.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,62 → 34,146
 #include <print.h>
 #include <printf/printf_core.h>
+#include <string.h>
 #include <memstr.h>
+#include <errno.h>
-struct vsnprintf_data {
-    size_t size; /* total space for string */
-    size_t len; /* count of currently used characters */
-    char *string; /* destination string */
-};
+typedef struct {
+    size_t size;    /* Total size of the buffer (in bytes) */
+    size_t len;     /* Number of already used bytes */
+    char *dst;      /* Destination */
+} vsnprintf_data_t;
 /** Write string to given buffer.
- * Write at most data->size characters including trailing zero. According to C99, snprintf() has to return number
- * of characters that would have been written if enough space had been available. Hence the return value is not
- * number of really printed characters but size of the input string. Number of really used characters
- * is stored in data->len.
- * @param str source string to print
- * @param count size of source string
- * @param data structure with destination string, counter of used space and total string size.
- * @return number of characters to print (not characters really printed!)
+ *
+ * Write at most data->size plain characters including trailing zero.
+ * According to C99, snprintf() has to return number of characters that
+ * would have been written if enough space had been available. Hence
+ * the return value is not the number of actually printed characters
+ * but size of the input string.
+ *
+ * @param str  Source string to print.
+ * @param size Number of plain characters in str.
+ * @param data Structure describing destination string, counter
+ *             of used space and total string size.
+ *
+ * @return Number of characters to print (not characters actually
+ *         printed).
+ *
  */
-static int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
+static int vsnprintf_str_write(const char *str, size_t size, vsnprintf_data_t *data)
 {
-    size_t i;
-    i = data->size - data->len;
-    if (i == 0) {
-        return count;
-    }
+    size_t left = data->size - data->len;
-    if (i == 1) {
-        /* We have only one free byte left in buffer => write there trailing zero */
-        data->string[data->size - 1] = 0;
+    if (left == 0)
+        return ((int) size);
+    if (left == 1) {
+        /* We have only one free byte left in buffer
+         * -> store trailing zero
+         */
+        data->dst[data->size - 1] = 0;
         data->len = data->size;
-        return count;
+        return ((int) size);
     }
-    if (i <= count) {
-        /* We have not enought space for whole string with the trailing zero => print only a part of string */
-            memcpy((void *)(data->string + data->len), (void *)str, i - 1);
-            data->string[data->size - 1] = 0;
+    if (left <= size) {
+        /* We do not have enough space for the whole string
+         * with the trailing zero => print only a part
+         * of string
+         */
+        index_t index = 0;
+        while (index < size) {
+            wchar_t uc = str_decode(str, &index, size);
+            if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK)
+                break;
+        }
+        /* Put trailing zero at end, but not count it
+         * into data->len so it could be rewritten next time
+         */
+        data->dst[data->len] = 0;
+        return ((int) size);
+    }
+    /* Buffer is big enought to print the whole string */
+    memcpy((void *)(data->dst + data->len), (void *) str, size);
+    data->len += size;
+    /* Put trailing zero at end, but not count it
+     * into data->len so it could be rewritten next time
+     */
+    data->dst[data->len] = 0;
+    return ((int) size);
+}
+/** Write wide string to given buffer.
+ *
+ * Write at most data->size plain characters including trailing zero.
+ * According to C99, snprintf() has to return number of characters that
+ * would have been written if enough space had been available. Hence
+ * the return value is not the number of actually printed characters
+ * but size of the input string.
+ *
+ * @param str  Source wide string to print.
+ * @param size Number of bytes in str.
+ * @param data Structure describing destination string, counter
+ *             of used space and total string size.
+ *
+ * @return Number of wide characters to print (not characters actually
+ *         printed).
+ *
+ */
+static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
+{
+    index_t index = 0;
+    while (index < (size / sizeof(wchar_t))) {
+        size_t left = data->size - data->len;
+        if (left == 0)
+            return ((int) size);
+        if (left == 1) {
+            /* We have only one free byte left in buffer
+             * -> store trailing zero
+             */
+            data->dst[data->size - 1] = 0;
             data->len = data->size;
-            return count;
+            return ((int) size);
+        }
+        if (chr_encode(str[index], data->dst, &data->len, data->size - 1) != EOK)
+            break;
+        index++;
     }
-    /* Buffer is big enought to print whole string */
-    memcpy((void *)(data->string + data->len), (void *)str, count);
-    data->len += count;
-    /* Put trailing zero at end, but not count it into data->len so it could be rewritten next time */
-    data->string[data->len] = 0;
-    return count;
+    /* Put trailing zero at end, but not count it
+     * into data->len so it could be rewritten next time
+     */
+    data->dst[data->len] = 0;
+    return ((int) size);
 }
 int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
 {
-    struct vsnprintf_data data = {size, 0, str};
-    struct printf_spec ps = {(int(*)(void *, size_t, void *))vsnprintf_write, &data};
+    vsnprintf_data_t data = {
+        size,
+,
+        str
+    };
+    printf_spec_t ps = {
+        (int(*) (const char *, size_t, void *)) vsnprintf_str_write,
+        (int(*) (const wchar_t *, size_t, void *)) vsnprintf_wstr_write,
+        &data
+    };
     /* Print 0 at end of string - fix the case that nothing will be printed */
     if (size > 0)
         str[0] = 0;

 /branches/tracing/kernel/generic/src/printf/printf_core.c
 ,6 → 1,7
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
  * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2009 Martin Decky
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 ,38 → 28,37
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /**
  * @file
- * @brief   Printing functions.
+ * @brief Printing functions.
  */
 #include <printf/printf_core.h>
-#include <putchar.h>
 #include <print.h>
 #include <arch/arg.h>
 #include <macros.h>
-#include <func.h>
+#include <string.h>
 #include <arch.h>
 /** show prefixes 0x or 0 */
-#define __PRINTF_FLAG_PREFIX        0x00000001
+#define __PRINTF_FLAG_PREFIX       0x00000001
 /** signed / unsigned number */
-#define __PRINTF_FLAG_SIGNED        0x00000002
+#define __PRINTF_FLAG_SIGNED       0x00000002
 /** print leading zeroes */
-#define __PRINTF_FLAG_ZEROPADDED    0x00000004
+#define __PRINTF_FLAG_ZEROPADDED   0x00000004
 /** align to left */
-#define __PRINTF_FLAG_LEFTALIGNED   0x00000010
+#define __PRINTF_FLAG_LEFTALIGNED  0x00000010
 /** always show + sign */
-#define __PRINTF_FLAG_SHOWPLUS      0x00000020
+#define __PRINTF_FLAG_SHOWPLUS     0x00000020
 /** print space instead of plus */
-#define __PRINTF_FLAG_SPACESIGN     0x00000040
+#define __PRINTF_FLAG_SPACESIGN    0x00000040
 /** show big characters */
-#define __PRINTF_FLAG_BIGCHARS      0x00000080
+#define __PRINTF_FLAG_BIGCHARS     0x00000080
 /** number has - sign */
-#define __PRINTF_FLAG_NEGATIVE      0x00000100
+#define __PRINTF_FLAG_NEGATIVE     0x00000100
 /**
  * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0
 ,7 → 65,7
  * to terminate string... (last one is only for better testing end of buffer by
  * zero-filling subroutine)
  */
-#define PRINT_NUMBER_BUFFER_SIZE    (64 + 5)
+#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
 /** Enumeration of possible arguments types.
  */
 ,69 → 78,103
     PrintfQualifierPointer
 } qualifier_t;
+static char nullstr[] = "(NULL)";
 static char digits_small[] = "0123456789abcdef";
 static char digits_big[] = "0123456789ABCDEF";
+static char invalch = U_SPECIAL;
 /** Print one or more characters without adding newline.
  *
- * @param buf       Buffer with size at least count bytes. NULL pointer is
- *          not allowed!
- * @param count     Number of characters to print.
- * @param ps        Output method and its data.
- * @return      Number of characters printed.
+ * @param buf  Buffer holding characters with size of
+ *             at least size bytes. NULL is not allowed!
+ * @param size Size of the buffer in bytes.
+ * @param ps   Output method and its data.
+ *
+ * @return Number of characters printed.
+ *
  */
-static int printf_putnchars(const char * buf, size_t count,
-    struct printf_spec *ps)
+static int printf_putnchars(const char *buf, size_t size,
+    printf_spec_t *ps)
 {
-    return ps->write((void *) buf, count, ps->data);
+    return ps->str_write((void *) buf, size, ps->data);
 }
-/** Print a string without adding a newline.
+/** Print one or more wide characters without adding newline.
  *
- * @param str       String to print.
- * @param ps        Write function specification and support data.
- * @return      Number of characters printed.
+ * @param buf  Buffer holding wide characters with size of
+ *             at least size bytes. NULL is not allowed!
+ * @param size Size of the buffer in bytes.
+ * @param ps   Output method and its data.
+ *
+ * @return Number of wide characters printed.
+ *
  */
-static int printf_putstr(const char * str, struct printf_spec *ps)
+static int printf_wputnchars(const wchar_t *buf, size_t size,
+    printf_spec_t *ps)
 {
-    size_t count;
+    return ps->wstr_write((void *) buf, size, ps->data);
+}
+/** Print string without adding a newline.
+ *
+ * @param str String to print.
+ * @param ps  Write function specification and support data.
+ *
+ * @return Number of characters printed.
+ *
+ */
+static int printf_putstr(const char *str, printf_spec_t *ps)
+{
+    if (str == NULL)
+        return printf_putnchars(nullstr, str_size(nullstr), ps);
-    if (str == NULL) {
-        char *nullstr = "(NULL)";
-        return printf_putnchars(nullstr, strlen(nullstr), ps);
-    }
+    return ps->str_write((void *) str, str_size(str), ps->data);
+}
-    count = strlen(str);
-    return ps->write((void *) str, count, ps->data);
+/** Print one ASCII character.
+ *
+ * @param c  ASCII character to be printed.
+ * @param ps Output method.
+ *
+ * @return Number of characters printed.
+ *
+ */
+static int printf_putchar(const char ch, printf_spec_t *ps)
+{
+    if (!ascii_check(ch))
+        return ps->str_write((void *) &invalch, 1, ps->data);
+    return ps->str_write(&ch, 1, ps->data);
 }
-/** Print one character.
+/** Print one wide character.
  *
- * @param c     Character to be printed.
- * @param ps        Output method.
+ * @param c  Wide character to be printed.
+ * @param ps Output method.
  *
- * @return      Number of characters printed.
+ * @return Number of characters printed.
+ *
  */
-static int printf_putchar(int c, struct printf_spec *ps)
+static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
 {
-    unsigned char ch = c;
+    if (!chr_check(ch))
+        return ps->str_write((void *) &invalch, 1, ps->data);
-    return ps->write((void *) &ch, 1, ps->data);
+    return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
 }
-/** Print one formatted character.
+/** Print one formatted ASCII character.
  *
- * @param c     Character to print.
- * @param width     Width modifier.
- * @param flags     Flags that change the way the character is printed.
+ * @param ch    Character to print.
+ * @param width Width modifier.
+ * @param flags Flags that change the way the character is printed.
  *
- * @return      Number of characters printed, negative value on failure.
+ * @return Number of characters printed, negative value on failure.
+ *
  */
-static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
+static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
 {
-    int counter = 0;
+    count_t counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (--width > 0) {
             /*
 ,106 → 181,193
              * One space is consumed by the character itself, hence
              * the predecrement.
              */
-            if (printf_putchar(' ', ps) > 0)
-                ++counter;
+            if (printf_putchar(' ', ps) > 0)
+                counter++;
         }
     }
-    if (printf_putchar(c, ps) > 0)
+    if (printf_putchar(ch, ps) > 0)
         counter++;
+    while (--width > 0) {
+        /*
+         * One space is consumed by the character itself, hence
+         * the predecrement.
+         */
+        if (printf_putchar(' ', ps) > 0)
+            counter++;
+    }
+    return (int) (counter + 1);
+}
-    while (--width > 0) {
+/** Print one formatted wide character.
+ *
+ * @param ch    Character to print.
+ * @param width Width modifier.
+ * @param flags Flags that change the way the character is printed.
+ *
+ * @return Number of characters printed, negative value on failure.
+ *
+ */
+static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
+{
+    count_t counter = 0;
+    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+        while (--width > 0) {
             /*
              * One space is consumed by the character itself, hence
              * the predecrement.
              */
+            if (printf_putchar(' ', ps) > 0)
+                counter++;
+        }
+    }
+    if (printf_putwchar(ch, ps) > 0)
+        counter++;
+    while (--width > 0) {
+        /*
+         * One space is consumed by the character itself, hence
+         * the predecrement.
+         */
         if (printf_putchar(' ', ps) > 0)
-            ++counter;
+            counter++;
     }
-    return ++counter;
+    return (int) (counter + 1);
 }
 /** Print string.
  *
- * @param s     String to be printed.
- * @param width     Width modifier.
- * @param precision Precision modifier.
- * @param flags     Flags that modify the way the string is printed.
+ * @param str       String to be printed.
+ * @param width     Width modifier.
+ * @param precision Precision modifier.
+ * @param flags     Flags that modify the way the string is printed.
  *
- * @return      Number of characters printed, negative value on failure.
- */
-static int print_string(char *s, int width, unsigned int precision,
-    uint64_t flags, struct printf_spec *ps)
+ * @return Number of characters printed, negative value on failure.
+ */
+static int print_str(char *str, int width, unsigned int precision,
+    uint32_t flags, printf_spec_t *ps)
 {
-    int counter = 0;
-    size_t size;
+    if (str == NULL)
+        return printf_putstr(nullstr, ps);
+    /* Print leading spaces. */
+    count_t strw = str_length(str);
+    if (precision == 0)
+        precision = strw;
+    /* Left padding */
+    count_t counter = 0;
+    width -= precision;
+    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+        while (width-- > 0) {
+            if (printf_putchar(' ', ps) == 1)
+                counter++;
+        }
+    }
+    /* Part of @a str fitting into the alloted space. */
     int retval;
+    size_t size = str_lsize(str, precision);
+    if ((retval = printf_putnchars(str, size, ps)) < 0)
+        return -counter;
-    if (s == NULL) {
-        return printf_putstr("(NULL)", ps);
+    counter += retval;
+    /* Right padding */
+    while (width-- > 0) {
+        if (printf_putchar(' ', ps) == 1)
+            counter++;
     }
-    size = strlen(s);
-    /* print leading spaces */
+    return ((int) counter);
-    if (precision == 0)
-        precision = size;
+}
+/** Print wide string.
+ *
+ * @param str       Wide string to be printed.
+ * @param width     Width modifier.
+ * @param precision Precision modifier.
+ * @param flags     Flags that modify the way the string is printed.
+ *
+ * @return Number of wide characters printed, negative value on failure.
+ */
+static int print_wstr(wchar_t *str, int width, unsigned int precision,
+    uint32_t flags, printf_spec_t *ps)
+{
+    if (str == NULL)
+        return printf_putstr(nullstr, ps);
+    if (*str == U_BOM)
+        str++;
+    /* Print leading spaces. */
+    size_t strw = wstr_length(str);
+    if (precision == 0)
+        precision = strw;
+    /* Left padding */
+    count_t counter = 0;
     width -= precision;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
-        while (width-- > 0) {
-            if (printf_putchar(' ', ps) == 1)
+        while (width-- > 0) {
+            if (printf_putchar(' ', ps) == 1)
                 counter++;
         }
     }
-    if ((retval = printf_putnchars(s, min(size, precision), ps)) < 0) {
+    /* Part of @a wstr fitting into the alloted space. */
+    int retval;
+    size_t size = wstr_lsize(str, precision);
+    if ((retval = printf_wputnchars(str, size, ps)) < 0)
         return -counter;
+    counter += retval;
+    /* Right padding */
+    while (width-- > 0) {
+        if (printf_putchar(' ', ps) == 1)
+            counter++;
     }
-    counter += retval;
-    while (width-- > 0) {
-        if (printf_putchar(' ', ps) == 1)
-            ++counter;
-    }
-    return counter;
+    return ((int) counter);
 }
 /** Print a number in a given base.
  *
  * Print significant digits of a number in given base.
  *
- * @param num       Number to print.
- * @param widt      Width modifier.h
- * @param precision Precision modifier.
- * @param base      Base to print the number in (must be between 2 and 16).
- * @param flags     Flags that modify the way the number is printed.
+ * @param num       Number to print.
+ * @param width     Width modifier.
+ * @param precision Precision modifier.
+ * @param base      Base to print the number in (must be between 2 and 16).
+ * @param flags     Flags that modify the way the number is printed.
  *
- * @return      Number of characters printed.
+ * @return Number of characters printed.
  *
  */
 static int print_number(uint64_t num, int width, int precision, int base,
-    uint64_t flags, struct printf_spec *ps)
+    uint32_t flags, printf_spec_t *ps)
 {
-    char *digits = digits_small;
-    char d[PRINT_NUMBER_BUFFER_SIZE];
-    char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
-    int size = 0;       /* size of number with all prefixes and signs */
-    int number_size;    /* size of plain number */
-    char sgn;
-    int retval;
-    int counter = 0;
+    char *digits;
+    if (flags & __PRINTF_FLAG_BIGCHARS)
+        digits = digits_big;
+    else
+        digits = digits_small;
-    if (flags & __PRINTF_FLAG_BIGCHARS)
-        digits = digits_big;
+    char data[PRINT_NUMBER_BUFFER_SIZE];
+    char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
-    *ptr-- = 0; /* Put zero at end of string */
+    /* Size of number with all prefixes and signs */
+    int size = 0;
+    /* Put zero at end of string */
+    *ptr-- = 0;
     if (num == 0) {
         *ptr-- = '0';
         size++;
 ,15 → 378,17
         } while (num /= base);
     }
-    number_size = size;
+    /* Size of plain number */
+    int number_size = size;
     /*
-     * Collect the sum of all prefixes/signs/... to calculate padding and
+     * Collect the sum of all prefixes/signs/etc. to calculate padding and
      * leading zeroes.
      */
     if (flags & __PRINTF_FLAG_PREFIX) {
         switch(base) {
-        case 2: /* Binary formating is not standard, but usefull */
+        case 2:
+            /* Binary formating is not standard, but usefull */
             size += 2;
             break;
         case 8:
 ,8 → 399,8
             break;
         }
     }
-    sgn = 0;
+    char sgn = 0;
     if (flags & __PRINTF_FLAG_SIGNED) {
         if (flags & __PRINTF_FLAG_NEGATIVE) {
             sgn = '-';
 ,48 → 413,46
             size++;
         }
     }
-    if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+    if (flags & __PRINTF_FLAG_LEFTALIGNED)
         flags &= ~__PRINTF_FLAG_ZEROPADDED;
-    }
     /*
-     * If the number is leftaligned or precision is specified then
-     * zeropadding is ignored.
+     * If the number is left-aligned or precision is specified then
+     * padding with zeros is ignored.
      */
     if (flags & __PRINTF_FLAG_ZEROPADDED) {
-        if ((precision == 0) && (width > size)) {
+        if ((precision == 0) && (width > size))
             precision = width - size + number_size;
-        }
     }
-    /* print leading spaces */
+    /* Print leading spaces */
     if (number_size > precision) {
-        /* print the whole number not only a part */
+        /* Print the whole number, not only a part */
         precision = number_size;
     }
     width -= precision + size - number_size;
+    count_t counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
-        while (width-- > 0) {
-            if (printf_putchar(' ', ps) == 1)
+        while (width-- > 0) {
+            if (printf_putchar(' ', ps) == 1)
                 counter++;
         }
     }
-    /* print sign */
+    /* Print sign */
     if (sgn) {
         if (printf_putchar(sgn, ps) == 1)
             counter++;
     }
-    /* print prefix */
+    /* Print prefix */
     if (flags & __PRINTF_FLAG_PREFIX) {
         switch(base) {
-        case 2: /* Binary formating is not standard, but usefull */
+        case 2:
+            /* Binary formating is not standard, but usefull */
             if (printf_putchar('0', ps) == 1)
                 counter++;
             if (flags & __PRINTF_FLAG_BIGCHARS) {
 ,150 → 480,154
             break;
         }
     }
-    /* print leading zeroes */
+    /* Print leading zeroes */
     precision -= number_size;
-    while (precision-- > 0) {
+    while (precision-- > 0) {
         if (printf_putchar('0', ps) == 1)
             counter++;
     }
-    /* print number itself */
-    if ((retval = printf_putstr(++ptr, ps)) > 0) {
+    /* Print the number itself */
+    int retval;
+    if ((retval = printf_putstr(++ptr, ps)) > 0)
         counter += retval;
-    }
-    /* print ending spaces */
+    /* Print tailing spaces */
-    while (width-- > 0) {
-        if (printf_putchar(' ', ps) == 1)
+    while (width-- > 0) {
+        if (printf_putchar(' ', ps) == 1)
             counter++;
     }
-    return counter;
+    return ((int) counter);
 }
 /** Print formatted string.
  *
  * Print string formatted according to the fmt parameter and variadic arguments.
  * Each formatting directive must have the following form:
- *
- *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
  *
+ *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
+ *
  * FLAGS:@n
- *  - "#"   Force to print prefix.For \%o conversion, the prefix is 0, for
- *      \%x and \%X prefixes are 0x and 0X and for conversion \%b the
- *      prefix is 0b.
+ *  - "#" Force to print prefix. For \%o conversion, the prefix is 0, for
+ *        \%x and \%X prefixes are 0x and 0X and for conversion \%b the
+ *        prefix is 0b.
  *
- *  - "-"   Align to left.
+ *  - "-" Align to left.
  *
- *  - "+"   Print positive sign just as negative.
+ *  - "+" Print positive sign just as negative.
  *
- *  - " "   If the printed number is positive and "+" flag is not set,
- *      print space in place of sign.
+ *  - " " If the printed number is positive and "+" flag is not set,
+ *        print space in place of sign.
  *
- *  - "0"    Print 0 as padding instead of spaces. Zeroes are placed between
- *      sign and the rest of the number. This flag is ignored if "-"
- *      flag is specified.
- *
+ *  - "0" Print 0 as padding instead of spaces. Zeroes are placed between
+ *        sign and the rest of the number. This flag is ignored if "-"
+ *        flag is specified.
+ *
  * WIDTH:@n
- *  - Specify the minimal width of a printed argument. If it is bigger,
- *  width is ignored. If width is specified with a "*" character instead of
- *  number, width is taken from parameter list. And integer parameter is
- *  expected before parameter for processed conversion specification. If
- *  this value is negative its absolute value is taken and the "-" flag is
- *  set.
+ *  - Specify the minimal width of a printed argument. If it is bigger,
+ *    width is ignored. If width is specified with a "*" character instead of
+ *    number, width is taken from parameter list. And integer parameter is
+ *    expected before parameter for processed conversion specification. If
+ *    this value is negative its absolute value is taken and the "-" flag is
+ *    set.
  *
  * PRECISION:@n
- *  - Value precision. For numbers it specifies minimum valid numbers.
- *  Smaller numbers are printed with leading zeroes. Bigger numbers are not
- *  affected. Strings with more than precision characters are cut off. Just
- *  as with width, an "*" can be used used instead of a number. An integer
- *  value is then expected in parameters. When both width and precision are
- *  specified using "*", the first parameter is used for width and the
- *  second one for precision.
- *
+ *  - Value precision. For numbers it specifies minimum valid numbers.
+ *    Smaller numbers are printed with leading zeroes. Bigger numbers are not
+ *    affected. Strings with more than precision characters are cut off. Just
+ *    as with width, an "*" can be used used instead of a number. An integer
+ *    value is then expected in parameters. When both width and precision are
+ *    specified using "*", the first parameter is used for width and the
+ *    second one for precision.
+ *
  * TYPE:@n
- *  - "hh"  Signed or unsigned char.@n
- *  - "h"   Signed or unsigned short.@n
- *  - ""    Signed or unsigned int (default value).@n
- *  - "l"   Signed or unsigned long int.@n
- *  - "ll"  Signed or unsigned long long int.@n
- *
- *
+ *  - "hh" Signed or unsigned char.@n
+ *  - "h"  Signed or unsigned short.@n
+ *  - ""   Signed or unsigned int (default value).@n
+ *  - "l"  Signed or unsigned long int.@n
+ *         If conversion is "c", the character is wchar_t (wide character).@n
+ *         If conversion is "s", the string is wchar_t * (wide string).@n
+ *  - "ll" Signed or unsigned long long int.@n
+ *
  * CONVERSION:@n
- *  - % Print percentile character itself.
+ *  - % Print percentile character itself.
  *
- *  - c Print single character.
+ *  - c Print single character. The character is expected to be plain
+ *      ASCII (e.g. only values 0 .. 127 are valid).@n
+ *      If type is "l", then the character is expected to be wide character
+ *      (e.g. values 0 .. 0x10ffff are valid).
  *
- *  - s Print zero terminated string. If a NULL value is passed as
- *      value, "(NULL)" is printed instead.
- *
- *  - P, p  Print value of a pointer. Void * value is expected and it is
- *      printed in hexadecimal notation with prefix (as with \%#X / \%#x
- *      for 32-bit or \%#X / \%#x for 64-bit long pointers).
+ *  - s Print zero terminated string. If a NULL value is passed as
+ *      value, "(NULL)" is printed instead.@n
+ *      If type is "l", then the string is expected to be wide string.
  *
- *  - b Print value as unsigned binary number. Prefix is not printed by
- *      default. (Nonstandard extension.)
- *
- *  - o Print value as unsigned octal number. Prefix is not printed by
- *      default.
+ *  - P, p Print value of a pointer. Void * value is expected and it is
+ *         printed in hexadecimal notation with prefix (as with \%#X / \%#x
+ *         for 32-bit or \%#X / \%#x for 64-bit long pointers).
  *
- *  - d, i  Print signed decimal number. There is no difference between d
- *      and i conversion.
+ *  - b Print value as unsigned binary number. Prefix is not printed by
+ *      default. (Nonstandard extension.)
  *
- *  - u Print unsigned decimal number.
+ *  - o Print value as unsigned octal number. Prefix is not printed by
+ *      default.
  *
- *  - X, x  Print hexadecimal number with upper- or lower-case. Prefix is
- *      not printed by default.
- *
- * All other characters from fmt except the formatting directives are printed in
+ *  - d, i Print signed decimal number. There is no difference between d
+ *         and i conversion.
+ *
+ *  - u Print unsigned decimal number.
+ *
+ *  - X, x Print hexadecimal number with upper- or lower-case. Prefix is
+ *         not printed by default.
+ *
+ * All other characters from fmt except the formatting directives are printed
  * verbatim.
  *
- * @param fmt       Formatting NULL terminated string.
- * @return      Number of characters printed, negative value on failure.
+ * @param fmt Format NULL-terminated string.
+ *
+ * @return Number of characters printed, negative value on failure.
+ *
  */
-int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
+int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
 {
-    int i = 0; /* index of the currently processed char from fmt */
-    int j = 0; /* index to the first not printed nonformating character */
-    int end;
-    int counter; /* counter of printed characters */
-    int retval; /* used to store return values from called functions */
-    char c;
-    qualifier_t qualifier; /* type of argument */
-    int base; /* base in which a numeric parameter will be printed */
-    uint64_t number; /* argument value */
-    size_t  size; /* byte size of integer parameter */
-    int width, precision;
-    uint64_t flags;
+    size_t i;        /* Index of the currently processed character from fmt */
+    size_t nxt = 0;  /* Index of the next character from fmt */
+    size_t j = 0;    /* Index to the first not printed nonformating character */
-    counter = 0;
+    count_t counter = 0;  /* Number of characters printed */
+    int retval;           /* Return values from nested functions */
+    while (true) {
+        i = nxt;
+        wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-    while ((c = fmt[i])) {
-        /* control character */
-        if (c == '%') {
-            /* print common characters if any processed */
+        if (uc == 0)
+            break;
+        /* Control character */
+        if (uc == '%') {
+            /* Print common characters if any processed */
             if (i > j) {
-                if ((retval = printf_putnchars(&fmt[j],
-                    (size_t)(i - j), ps)) < 0) { /* error */
+                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
+                    /* Error */
                     counter = -counter;
                     goto out;
                 }
                 counter += retval;
             }
             j = i;
-            /* parse modifiers */
-            flags = 0;
-            end = 0;
+            /* Parse modifiers */
+            uint32_t flags = 0;
+            bool end = false;
             do {
-                ++i;
-                switch (c = fmt[i]) {
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                switch (uc) {
                 case '#':
                     flags |= __PRINTF_FLAG_PREFIX;
                     break;
 ,116 → 644,145
                     flags |= __PRINTF_FLAG_ZEROPADDED;
                     break;
                 default:
-                    end = 1;
-                };
-            } while (end == 0);
+                    end = true;
+                };
+            } while (!end);
-            /* width & '*' operator */
-            width = 0;
-            if (isdigit(fmt[i])) {
-                while (isdigit(fmt[i])) {
+            /* Width & '*' operator */
+            int width = 0;
+            if (isdigit(uc)) {
+                while (true) {
                     width *= 10;
-                    width += fmt[i++] - '0';
+                    width += uc - '0';
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                    if (uc == 0)
+                        break;
+                    if (!isdigit(uc))
+                        break;
                 }
-            } else if (fmt[i] == '*') {
-                /* get width value from argument list */
-                i++;
+            } else if (uc == '*') {
+                /* Get width value from argument list */
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                 width = (int) va_arg(ap, int);
                 if (width < 0) {
-                    /* negative width sets '-' flag */
+                    /* Negative width sets '-' flag */
                     width *= -1;
                     flags |= __PRINTF_FLAG_LEFTALIGNED;
                 }
             }
-            /* precision and '*' operator */
-            precision = 0;
-            if (fmt[i] == '.') {
-                ++i;
-                if (isdigit(fmt[i])) {
-                    while (isdigit(fmt[i])) {
+            /* Precision and '*' operator */
+            int precision = 0;
+            if (uc == '.') {
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                if (isdigit(uc)) {
+                    while (true) {
                         precision *= 10;
-                        precision += fmt[i++] - '0';
+                        precision += uc - '0';
+                        i = nxt;
+                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                        if (uc == 0)
+                            break;
+                        if (!isdigit(uc))
+                            break;
                     }
-                } else if (fmt[i] == '*') {
-                    /*
-                     * Get precision value from the argument
-                     * list.
-                     */
-                    i++;
+                } else if (uc == '*') {
+                    /* Get precision value from the argument list */
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                     precision = (int) va_arg(ap, int);
                     if (precision < 0) {
-                        /* ignore negative precision */
+                        /* Ignore negative precision */
                         precision = 0;
                     }
                 }
             }
-            switch (fmt[i++]) {
-            /** @todo unimplemented qualifiers:
-             * t ptrdiff_t - ISO C 99
+            qualifier_t qualifier;
+            switch (uc) {
+            /** @todo Unimplemented qualifiers:
+             *        t ptrdiff_t - ISO C 99
              */
-            case 'h':   /* char or short */
+            case 'h':
+                /* Char or short */
                 qualifier = PrintfQualifierShort;
-                if (fmt[i] == 'h') {
-                    i++;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                if (uc == 'h') {
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                     qualifier = PrintfQualifierByte;
                 }
                 break;
-            case 'l':   /* long or long long*/
+            case 'l':
+                /* Long or long long */
                 qualifier = PrintfQualifierLong;
-                if (fmt[i] == 'l') {
-                    i++;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                if (uc == 'l') {
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                     qualifier = PrintfQualifierLongLong;
                 }
                 break;
             default:
-                /* default type */
-                qualifier = PrintfQualifierInt;
-                --i;
-            }
+                /* Default type */
+                qualifier = PrintfQualifierInt;
+            }
-            base = 10;
-            switch (c = fmt[i]) {
+            unsigned int base = 10;
+            switch (uc) {
             /*
-            * String and character conversions.
-            */
+             * String and character conversions.
+             */
             case 's':
-                if ((retval = print_string(va_arg(ap, char *),
-                    width, precision, flags, ps)) < 0) {
+                if (qualifier == PrintfQualifierLong)
+                    retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
+                else
+                    retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
+                if (retval < 0) {
                     counter = -counter;
                     goto out;
-                };
+                }
                 counter += retval;
-                j = i + 1;
+                j = nxt;
                 goto next_char;
             case 'c':
-                c = va_arg(ap, unsigned int);
-                retval = print_char(c, width, flags, ps);
+                if (qualifier == PrintfQualifierLong)
+                    retval = print_wchar(va_arg(ap, wchar_t), width, flags, ps);
+                else
+                    retval = print_char(va_arg(ap, unsigned int), width, flags, ps);
                 if (retval < 0) {
                     counter = -counter;
                     goto out;
                 };
                 counter += retval;
-                j = i + 1;
+                j = nxt;
                 goto next_char;
-            /*
+            /*
              * Integer values
              */
-            case 'P': /* pointer */
+            case 'P':
+                /* Pointer */
                 flags |= __PRINTF_FLAG_BIGCHARS;
             case 'p':
                 flags |= __PRINTF_FLAG_PREFIX;
                 base = 16;
                 qualifier = PrintfQualifierPointer;
-                break;
-            case 'b':
+                break;
+            case 'b':
                 base = 2;
                 break;
             case 'o':
 ,7 → 790,7
                 break;
             case 'd':
             case 'i':
-                flags |= __PRINTF_FLAG_SIGNED;
+                flags |= __PRINTF_FLAG_SIGNED;
             case 'u':
                 break;
             case 'X':
 ,10 → 798,12
             case 'x':
                 base = 16;
                 break;
-            /* percentile itself */
-            case '%':
+            /* Percentile itself */
+            case '%':
                 j = i;
                 goto next_char;
             /*
              * Bad formatting.
              */
 ,12 → 812,12
                  * Unknown format. Now, j is the index of '%'
                  * so we will print whole bad format sequence.
                  */
-                goto next_char;
+                goto next_char;
             }
-        /* Print integers */
-            /* print number */
+            /* Print integers */
+            size_t size;
+            uint64_t number;
             switch (qualifier) {
             case PrintfQualifierByte:
                 size = sizeof(unsigned char);
 ,7 → 843,8
                 size = sizeof(void *);
                 number = (uint64_t) (unsigned long) va_arg(ap, void *);
                 break;
-            default: /* Unknown qualifier */
+            default:
+                /* Unknown qualifier */
                 counter = -counter;
                 goto out;
             }
 ,7 → 852,7
             if (flags & __PRINTF_FLAG_SIGNED) {
                 if (number & (0x1 << (size * 8 - 1))) {
                     flags |= __PRINTF_FLAG_NEGATIVE;
                     if (size == sizeof(uint64_t)) {
                         number = -((int64_t) number);
                     } else {
 ,33 → 864,31
                     }
                 }
             }
             if ((retval = print_number(number, width, precision,
                 base, flags, ps)) < 0) {
                 counter = -counter;
                 goto out;
             }
             counter += retval;
-            j = i + 1;
-        }
+            j = nxt;
+        }
 next_char:
-        ++i;
+        ;
     }
     if (i > j) {
-        if ((retval = printf_putnchars(&fmt[j], (unative_t) (i - j),
-            ps)) < 0) { /* error */
+        if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
+            /* Error */
             counter = -counter;
             goto out;
         }
         counter += retval;
     }
 out:
-    return counter;
+    return ((int) counter);
 }
 /** @}

 /branches/tracing/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/tracing/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 → 151,7
     ta->as = as;
     memcpy(ta->name, name, TASK_NAME_BUFLEN);
-    ta->name[TASK_NAME_BUFLEN - 1] = '\0';
+    ta->name[TASK_NAME_BUFLEN - 1] = 0;
     atomic_set(&ta->refcount, 0);
     atomic_set(&ta->lifecount, 0);
 ,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';
+    str_cpy(TASK->name, TASK_NAME_BUFLEN, namebuf);
+    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/tracing/kernel/generic/src/proc/program.c
 ,7 → 133,7
         /* Register image as the program loader */
         ASSERT(program_loader == NULL);
         program_loader = image_addr;
-        printf("Registered program loader at 0x%" PRIp "\n",
+        LOG("Registered program loader at 0x%" PRIp "\n",
             image_addr);
         return EOK;
     }
 ,49 → 190,31
 /** 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, char *uspace_name,
-    size_t name_len)
+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;
-    /* 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 (rc != 0)
-        return rc;
     /* Cap length of name and copy it from userspace. */
-    if (name_len > THREAD_NAME_BUFLEN - 1)
-        name_len = THREAD_NAME_BUFLEN - 1;
+    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';
+    namebuf[name_len] = 0;
-    /* Allocate the phone for communicating with the new task. */
-    phone_id = phone_alloc();
-    if (phone_id < 0)
-        return ELIMIT;
     /* Spawn the new task. */
     rc = program_create_loader(&p, namebuf);
 ,18 → 221,6
     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/tracing/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/tracing/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
 ,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 → 316,7
     interrupts_restore(ipl);
     memcpy(t->name, name, THREAD_NAME_BUFLEN);
-    t->name[THREAD_NAME_BUFLEN - 1] = '\0';
+    t->name[THREAD_NAME_BUFLEN - 1] = 0;
     t->thread_code = func;
     t->thread_arg = arg;
 ,7 → 723,7
     if (rc != 0)
         return (unative_t) rc;
-    namebuf[name_len] = '\0';
+    namebuf[name_len] = 0;
     /*
      * In case of failure, kernel_uarg will be deallocated in this function.

 /branches/tracing/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/tracing/kernel/generic/src/lib/string.c
 ,0 → 1,712
+/*
+ * 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 String functions.
+ *
+ * Strings and characters use the Universal Character Set (UCS). The standard
+ * strings, called just strings are encoded in UTF-8. Wide strings (encoded
+ * in UTF-32) are supported to a limited degree. A single character is
+ * represented as wchar_t.@n
+ *
+ * Overview of the terminology:@n
+ *
+ *  Term                  Meaning
+ *  --------------------  ----------------------------------------------------
+ *  byte                  8 bits stored in uint8_t (unsigned 8 bit integer)
+ *
+ *  character             UTF-32 encoded Unicode character, stored in wchar_t
+ *                        (signed 32 bit integer), code points 0 .. 1114111
+ *                        are valid
+ *
+ *  ASCII character       7 bit encoded ASCII character, stored in char
+ *                        (usually signed 8 bit integer), code points 0 .. 127
+ *                        are valid
+ *
+ *  string                UTF-8 encoded NULL-terminated Unicode string, char *
+ *
+ *  wide string           UTF-32 encoded NULL-terminated Unicode string,
+ *                        wchar_t *
+ *
+ *  [wide] string size    number of BYTES in a [wide] string (excluding
+ *                        the NULL-terminator), size_t
+ *
+ *  [wide] string length  number of CHARACTERS in a [wide] string (excluding
+ *                        the NULL-terminator), count_t
+ *
+ *  [wide] string width   number of display cells on a monospace display taken
+ *                        by a [wide] string, count_t
+ *
+ *
+ * Overview of string metrics:@n
+ *
+ *  Metric  Abbrev.  Type     Meaning
+ *  ------  ------   ------   -------------------------------------------------
+ *  size    n        size_t   number of BYTES in a string (excluding the
+ *                            NULL-terminator)
+ *
+ *  length  l        count_t  number of CHARACTERS in a string (excluding the
+ *                            null terminator)
+ *
+ *  width  w         count_t  number of display cells on a monospace display
+ *                            taken by a string
+ *
+ *
+ * Function naming prefixes:@n
+ *
+ *  chr_    operate on characters
+ *  ascii_  operate on ASCII characters
+ *  str_    operate on strings
+ *  wstr_   operate on wide strings
+ *
+ *  [w]str_[n|l|w]  operate on a prefix limited by size, length
+ *                  or width
+ *
+ *
+ * A specific character inside a [wide] string can be referred to by:@n
+ *
+ *  pointer (char *, wchar_t *)
+ *  byte offset (size_t)
+ *  character index (count_t)
+ *
+ */
+#include <string.h>
+#include <print.h>
+#include <cpu.h>
+#include <arch/asm.h>
+#include <arch.h>
+#include <errno.h>
+#include <align.h>
+#include <debug.h>
+/** Byte mask consisting of lowest @n bits (out of 8) */
+#define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
+/** Byte mask consisting of lowest @n bits (out of 32) */
+#define LO_MASK_32(n)  ((uint32_t) ((1 << (n)) - 1))
+/** Byte mask consisting of highest @n bits (out of 8) */
+#define HI_MASK_8(n)  (~LO_MASK_8(8 - (n)))
+/** Number of data bits in a UTF-8 continuation byte */
+#define CONT_BITS  6
+/** Decode a single character from a string.
+ *
+ * Decode a single character from a string of size @a size. Decoding starts
+ * at @a offset and this offset is moved to the beginning of the next
+ * character. In case of decoding error, offset generally advances at least
+ * by one. However, offset is never moved beyond size.
+ *
+ * @param str    String (not necessarily NULL-terminated).
+ * @param offset Byte offset in string where to start decoding.
+ * @param size   Size of the string (in bytes).
+ *
+ * @return Value of decoded character, U_SPECIAL on decoding error or
+ *         NULL if attempt to decode beyond @a size.
+ *
+ */
+wchar_t str_decode(const char *str, size_t *offset, size_t size)
+{
+    if (*offset + 1 > size)
+        return 0;
+    /* First byte read from string */
+    uint8_t b0 = (uint8_t) str[(*offset)++];
+    /* Determine code length */
+    unsigned int b0_bits;  /* Data bits in first byte */
+    unsigned int cbytes;   /* Number of continuation bytes */
+    if ((b0 & 0x80) == 0) {
+        /* 0xxxxxxx (Plain ASCII) */
+        b0_bits = 7;
+        cbytes = 0;
+    } else if ((b0 & 0xe0) == 0xc0) {
+        /* 110xxxxx 10xxxxxx */
+        b0_bits = 5;
+        cbytes = 1;
+    } else if ((b0 & 0xf0) == 0xe0) {
+        /* 1110xxxx 10xxxxxx 10xxxxxx */
+        b0_bits = 4;
+        cbytes = 2;
+    } else if ((b0 & 0xf8) == 0xf0) {
+        /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+        b0_bits = 3;
+        cbytes = 3;
+    } else {
+        /* 10xxxxxx -- unexpected continuation byte */
+        return U_SPECIAL;
+    }
+    if (*offset + cbytes > size)
+        return U_SPECIAL;
+    wchar_t ch = b0 & LO_MASK_8(b0_bits);
+    /* Decode continuation bytes */
+    while (cbytes > 0) {
+        uint8_t b = (uint8_t) str[(*offset)++];
+        /* Must be 10xxxxxx */
+        if ((b & 0xc0) != 0x80)
+            return U_SPECIAL;
+        /* Shift data bits to ch */
+        ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
+        cbytes--;
+    }
+    return ch;
+}
+/** Encode a single character to string representation.
+ *
+ * Encode a single character to string representation (i.e. UTF-8) and store
+ * it into a buffer at @a offset. Encoding starts at @a offset and this offset
+ * is moved to the position where the next character can be written to.
+ *
+ * @param ch     Input character.
+ * @param str    Output buffer.
+ * @param offset Byte offset where to start writing.
+ * @param size   Size of the output buffer (in bytes).
+ *
+ * @return EOK if the character was encoded successfully, EOVERFLOW if there
+ *     was not enough space in the output buffer or EINVAL if the character
+ *     code was invalid.
+ */
+int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
+{
+    if (*offset >= size)
+        return EOVERFLOW;
+    if (!chr_check(ch))
+        return EINVAL;
+    /* Unsigned version of ch (bit operations should only be done
+       on unsigned types). */
+    uint32_t cc = (uint32_t) ch;
+    /* Determine how many continuation bytes are needed */
+    unsigned int b0_bits;  /* Data bits in first byte */
+    unsigned int cbytes;   /* Number of continuation bytes */
+    if ((cc & ~LO_MASK_32(7)) == 0) {
+        b0_bits = 7;
+        cbytes = 0;
+    } else if ((cc & ~LO_MASK_32(11)) == 0) {
+        b0_bits = 5;
+        cbytes = 1;
+    } else if ((cc & ~LO_MASK_32(16)) == 0) {
+        b0_bits = 4;
+        cbytes = 2;
+    } else if ((cc & ~LO_MASK_32(21)) == 0) {
+        b0_bits = 3;
+        cbytes = 3;
+    } else {
+        /* Codes longer than 21 bits are not supported */
+        return EINVAL;
+    }
+    /* Check for available space in buffer */
+    if (*offset + cbytes >= size)
+        return EOVERFLOW;
+    /* Encode continuation bytes */
+    unsigned int i;
+    for (i = cbytes; i > 0; i--) {
+        str[*offset + i] = 0x80 | (cc & LO_MASK_32(CONT_BITS));
+        cc = cc >> CONT_BITS;
+    }
+    /* Encode first byte */
+    str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
+    /* Advance offset */
+    *offset += cbytes + 1;
+    return EOK;
+}
+/** Get size of string.
+ *
+ * Get the number of bytes which are used by the string @a str (excluding the
+ * NULL-terminator).
+ *
+ * @param str String to consider.
+ *
+ * @return Number of bytes used by the string
+ *
+ */
+size_t str_size(const char *str)
+{
+    size_t size = 0;
+    while (*str++ != 0)
+        size++;
+    return size;
+}
+/** Get size of wide string.
+ *
+ * Get the number of bytes which are used by the wide string @a str (excluding the
+ * NULL-terminator).
+ *
+ * @param str Wide string to consider.
+ *
+ * @return Number of bytes used by the wide string
+ *
+ */
+size_t wstr_size(const wchar_t *str)
+{
+    return (wstr_length(str) * sizeof(wchar_t));
+}
+/** Get size of string with length limit.
+ *
+ * Get the number of bytes which are used by up to @a max_len first
+ * characters in the string @a str. If @a max_len is greater than
+ * the length of @a str, the entire string is measured (excluding the
+ * NULL-terminator).
+ *
+ * @param str     String to consider.
+ * @param max_len Maximum number of characters to measure.
+ *
+ * @return Number of bytes used by the characters.
+ *
+ */
+size_t str_lsize(const char *str, count_t max_len)
+{
+    count_t len = 0;
+    size_t offset = 0;
+    while (len < max_len) {
+        if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
+            break;
+        len++;
+    }
+    return offset;
+}
+/** Get size of wide string with length limit.
+ *
+ * Get the number of bytes which are used by up to @a max_len first
+ * wide characters in the wide string @a str. If @a max_len is greater than
+ * the length of @a str, the entire wide string is measured (excluding the
+ * NULL-terminator).
+ *
+ * @param str     Wide string to consider.
+ * @param max_len Maximum number of wide characters to measure.
+ *
+ * @return Number of bytes used by the wide characters.
+ *
+ */
+size_t wstr_lsize(const wchar_t *str, count_t max_len)
+{
+    return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
+}
+/** Get number of characters in a string.
+ *
+ * @param str NULL-terminated string.
+ *
+ * @return Number of characters in string.
+ *
+ */
+count_t str_length(const char *str)
+{
+    count_t len = 0;
+    size_t offset = 0;
+    while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
+        len++;
+    return len;
+}
+/** Get number of characters in a wide string.
+ *
+ * @param str NULL-terminated wide string.
+ *
+ * @return Number of characters in @a str.
+ *
+ */
+count_t wstr_length(const wchar_t *wstr)
+{
+    count_t len = 0;
+    while (*wstr++ != 0)
+        len++;
+    return len;
+}
+/** Get number of characters in a string with size limit.
+ *
+ * @param str  NULL-terminated string.
+ * @param size Maximum number of bytes to consider.
+ *
+ * @return Number of characters in string.
+ *
+ */
+count_t str_nlength(const char *str, size_t size)
+{
+    count_t len = 0;
+    size_t offset = 0;
+    while (str_decode(str, &offset, size) != 0)
+        len++;
+    return len;
+}
+/** Get number of characters in a string with size limit.
+ *
+ * @param str  NULL-terminated string.
+ * @param size Maximum number of bytes to consider.
+ *
+ * @return Number of characters in string.
+ *
+ */
+count_t wstr_nlength(const wchar_t *str, size_t size)
+{
+    count_t len = 0;
+    count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
+    count_t offset = 0;
+    while ((offset < limit) && (*str++ != 0)) {
+        len++;
+        offset += sizeof(wchar_t);
+    }
+    return len;
+}
+/** Check whether character is plain ASCII.
+ *
+ * @return True if character is plain ASCII.
+ *
+ */
+bool ascii_check(wchar_t ch)
+{
+    if ((ch >= 0) && (ch <= 127))
+        return true;
+    return false;
+}
+/** Check whether character is valid
+ *
+ * @return True if character is a valid Unicode code point.
+ *
+ */
+bool chr_check(wchar_t ch)
+{
+    if ((ch >= 0) && (ch <= 1114111))
+        return true;
+    return false;
+}
+/** 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 s1 First string to compare.
+ * @param s2 Second string to compare.
+ *
+ * @return 0 if the strings are equal, -1 if first is smaller,
+ *         1 if second smaller.
+ *
+ */
+int str_cmp(const char *s1, const char *s2)
+{
+    wchar_t c1 = 0;
+    wchar_t c2 = 0;
+    size_t off1 = 0;
+    size_t off2 = 0;
+    while (true) {
+        c1 = str_decode(s1, &off1, STR_NO_LIMIT);
+        c2 = str_decode(s2, &off2, STR_NO_LIMIT);
+        if (c1 < c2)
+            return -1;
+        if (c1 > c2)
+            return 1;
+        if (c1 == 0 || c2 == 0)
+            break;
+    }
+    return 0;
+}
+/** Compare two NULL terminated strings with length limit.
+ *
+ * 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 the length limit.
+ *
+ * @param s1      First string to compare.
+ * @param s2      Second string to compare.
+ * @param max_len Maximum number of characters to consider.
+ *
+ * @return 0 if the strings are equal, -1 if first is smaller,
+ *         1 if second smaller.
+ *
+ */
+int str_lcmp(const char *s1, const char *s2, count_t max_len)
+{
+    wchar_t c1 = 0;
+    wchar_t c2 = 0;
+    size_t off1 = 0;
+    size_t off2 = 0;
+    count_t len = 0;
+    while (true) {
+        if (len >= max_len)
+            break;
+        c1 = str_decode(s1, &off1, STR_NO_LIMIT);
+        c2 = str_decode(s2, &off2, STR_NO_LIMIT);
+        if (c1 < c2)
+            return -1;
+        if (c1 > c2)
+            return 1;
+        if (c1 == 0 || c2 == 0)
+            break;
+        ++len;
+    }
+    return 0;
+}
+/** Copy string.
+ *
+ * Copy source string @a src to destination buffer @a dest.
+ * No more than @a size bytes are written. If the size of the output buffer
+ * is at least one byte, the output string will always be well-formed, i.e.
+ * null-terminated and containing only complete characters.
+ *
+ * @param dst   Destination buffer.
+ * @param count Size of the destination buffer (must be > 0).
+ * @param src   Source string.
+ */
+void str_cpy(char *dest, size_t size, const char *src)
+{
+    wchar_t ch;
+    size_t src_off;
+    size_t dest_off;
+    /* There must be space for a null terminator in the buffer. */
+    ASSERT(size > 0);
+    src_off = 0;
+    dest_off = 0;
+    while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
+        if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
+            break;
+    }
+    dest[dest_off] = '\0';
+}
+/** Copy size-limited substring.
+ *
+ * Copy prefix of string @a src of max. size @a size to destination buffer
+ * @a dest. No more than @a size bytes are written. The output string will
+ * always be well-formed, i.e. null-terminated and containing only complete
+ * characters.
+ *
+ * No more than @a n bytes are read from the input string, so it does not
+ * have to be null-terminated.
+ *
+ * @param dst   Destination buffer.
+ * @param count Size of the destination buffer (must be > 0).
+ * @param src   Source string.
+ * @param n Maximum number of bytes to read from @a src.
+ */
+void str_ncpy(char *dest, size_t size, const char *src, size_t n)
+{
+    wchar_t ch;
+    size_t src_off;
+    size_t dest_off;
+    /* There must be space for a null terminator in the buffer. */
+    ASSERT(size > 0);
+    src_off = 0;
+    dest_off = 0;
+    while ((ch = str_decode(src, &src_off, n)) != 0) {
+        if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
+            break;
+    }
+    dest[dest_off] = '\0';
+}
+/** Copy NULL-terminated wide string to string
+ *
+ * Copy source wide string @a src to destination buffer @a dst.
+ * No more than @a size bytes are written. NULL-terminator is always
+ * written after the last succesfully copied character (i.e. if the
+ * destination buffer is has at least 1 byte, it will be always
+ * NULL-terminated).
+ *
+ * @param src   Source wide string.
+ * @param dst   Destination buffer.
+ * @param count Size of the destination buffer.
+ *
+ */
+void wstr_nstr(char *dst, const wchar_t *src, size_t size)
+{
+    /* No space for the NULL-terminator in the buffer */
+    if (size == 0)
+        return;
+    wchar_t ch;
+    count_t src_idx = 0;
+    size_t dst_off = 0;
+    while ((ch = src[src_idx++]) != 0) {
+        if (chr_encode(ch, dst, &dst_off, size) != EOK)
+            break;
+    }
+    if (dst_off >= size)
+        dst[size - 1] = 0;
+    else
+        dst[dst_off] = 0;
+}
+/** Find first occurence of character in string.
+ *
+ * @param str String to search.
+ * @param ch  Character to look for.
+ *
+ * @return Pointer to character in @a str or NULL if not found.
+ *
+ */
+const char *str_chr(const char *str, wchar_t ch)
+{
+    wchar_t acc;
+    size_t off = 0;
+    size_t last = 0;
+    while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
+        if (acc == ch)
+            return (str + last);
+        last = off;
+    }
+    return NULL;
+}
+/** Insert a wide character into a wide string.
+ *
+ * Insert a wide character into a wide string at position
+ * @a pos. The characters after the position are shifted.
+ *
+ * @param str     String to insert to.
+ * @param ch      Character to insert to.
+ * @param pos     Character index where to insert.
+ @ @param max_pos Characters in the buffer.
+ *
+ * @return True if the insertion was sucessful, false if the position
+ *         is out of bounds.
+ *
+ */
+bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos)
+{
+    count_t len = wstr_length(str);
+    if ((pos > len) || (pos + 1 > max_pos))
+        return false;
+    count_t i;
+    for (i = len; i + 1 > pos; i--)
+        str[i + 1] = str[i];
+    str[pos] = ch;
+    return true;
+}
+/** Remove a wide character from a wide string.
+ *
+ * Remove a wide character from a wide string at position
+ * @a pos. The characters after the position are shifted.
+ *
+ * @param str String to remove from.
+ * @param pos Character index to remove.
+ *
+ * @return True if the removal was sucessful, false if the position
+ *         is out of bounds.
+ *
+ */
+bool wstr_remove(wchar_t *str, count_t pos)
+{
+    count_t len = wstr_length(str);
+    if (pos >= len)
+        return false;
+    count_t i;
+    for (i = pos + 1; i <= len; i++)
+        str[i - 1] = str[i];
+    return true;
+}
+/** @}
+ */

 /branches/tracing/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
 ,6 → 77,51
     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
 ,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       Source string to copy from.
- * @param dst       Destination string to copy to.
- *
- * @return      Address of the destination string.
- */
-char *strcpy(char *dest, const char *src)
-{
-    char *orig = dest;
-    while ((*(dest++) = *(src++)))
-        ;
-    return orig;
-}
 /** @}
  */

 /branches/tracing/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/tracing/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/tracing/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/tracing/kernel/generic/src/adt/hash_table.c
 ,7 → 32,7
 /**
  * @file
- * @brief   Implementation of generic chained hash table.
+ * @brief Implementation of generic chained hash table.
  *
  * This file contains implementation of generic chained hash table.
  */
 ,13 → 56,15
     index_t i;
     ASSERT(h);
-    ASSERT(op && op->hash && op->compare);
+    ASSERT(op);
+    ASSERT(op->hash);
+    ASSERT(op->compare);
     ASSERT(max_keys > 0);
     h->entry = (link_t *) malloc(m * sizeof(link_t), 0);
-    if (!h->entry) {
-        panic("cannot allocate memory for hash table\n");
-    }
+    if (!h->entry)
+        panic("Cannot allocate memory for hash table.");
     memsetb(h->entry, m * sizeof(link_t), 0);
     for (i = 0; i < m; i++)
 ,10 → 84,13
 void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)
 {
     index_t chain;
     ASSERT(item);
-    ASSERT(h && h->op && h->op->hash && h->op->compare);
+    ASSERT(h);
+    ASSERT(h->op);
+    ASSERT(h->op->hash);
+    ASSERT(h->op->compare);
     chain = h->op->hash(key);
     ASSERT(chain < h->entries);
 ,9 → 108,12
 {
     link_t *cur;
     index_t chain;
-    ASSERT(h && h->op && h->op->hash && h->op->compare);
+    ASSERT(h);
+    ASSERT(h->op);
+    ASSERT(h->op->hash);
+    ASSERT(h->op->compare);
     chain = h->op->hash(key);
     ASSERT(chain < h->entries);
 ,7 → 131,7
 /** Remove all matching items from hash table.
  *
- * For each removed item, h->remove_callback() is called.
+ * For each removed item, h->remove_callback() is called (if not NULL).
  *
  * @param h Hash table.
  * @param key Array of keys that will be compared against items of the hash table.
 ,12 → 141,15
 {
     index_t chain;
     link_t *cur;
-    ASSERT(h && h->op && h->op->hash && h->op->compare && h->op->remove_callback);
+    ASSERT(h);
+    ASSERT(h->op);
+    ASSERT(h->op->hash);
+    ASSERT(h->op->compare);
     ASSERT(keys <= h->max_keys);
     if (keys == h->max_keys) {
         /*
          * All keys are known, hash_table_find() can be used to find the entry.
          */
 ,7 → 157,8
         cur = hash_table_find(h, key);
         if (cur) {
             list_remove(cur);
-            h->op->remove_callback(cur);
+            if (h->op->remove_callback)
+                h->op->remove_callback(cur);
         }
         return;
     }
 ,7 → 176,8
                 cur = cur->prev;
                 list_remove(hlp);
-                h->op->remove_callback(hlp);
+                if (h->op->remove_callback)
+                    h->op->remove_callback(hlp);
                 continue;
             }

 /branches/tracing/kernel/generic/src/mm/slab.c
 ,7 → 129,7
 static slab_cache_t *slab_extern_cache;
 /** Caches for malloc */
 static slab_cache_t *malloc_caches[SLAB_MAX_MALLOC_W - SLAB_MIN_MALLOC_W + 1];
-char *malloc_names[] =  {
+static char *malloc_names[] =  {
     "malloc-16",
     "malloc-32",
     "malloc-64",
 ,7 → 144,11
     "malloc-32K",
     "malloc-64K",
     "malloc-128K",
-    "malloc-256K"
+    "malloc-256K",
+    "malloc-512K",
+    "malloc-1M",
+    "malloc-2M",
+    "malloc-4M"
 };
 /** Slab descriptor */
 ,7 → 177,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) {
 ,7 → 936,7
 void *malloc(unsigned int size, int flags)
 {
     ASSERT(_slab_initialized);
-    ASSERT(size && size <= (1 << SLAB_MAX_MALLOC_W));
+    ASSERT(size <= (1 << SLAB_MAX_MALLOC_W));
     if (size < (1 << SLAB_MIN_MALLOC_W))
         size = (1 << SLAB_MIN_MALLOC_W);

 /branches/tracing/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/tracing/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/tracing/kernel/generic/src/mm/as.c
 ,7 → 121,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 → 145,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 → 179,7
 #else
     page_table_create(flags);
 #endif
     return as;
 }
 ,8 → 443,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 → 451,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 → 772,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 → 789,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 → 803,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 → 874,7
      */
     tlb_invalidate_pages(as->asid, area->base, area->pages);
     /*
      * Invalidate potential software translation caches (e.g. TSB on
      * sparc64).
 ,7 → 1665,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 → 1844,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/tracing/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/tracing/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/tracing/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,646
 /** 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))) {
+        spinlock_unlock(&zones.lock);
+        interrupts_restore(ipl);
+        count_t freed = slab_reclaim(0);
+        ipl = interrupts_disable();
+        spinlock_lock(&zones.lock);
+        if (freed > 0)
+            znum = find_free_zone(order,
+                FRAME_TO_ZONE_FLAGS(flags), hint);
+        if (znum == (count_t) -1) {
+            spinlock_unlock(&zones.lock);
+            interrupts_restore(ipl);
             freed = slab_reclaim(SLAB_RECLAIM_ALL);
-            if (freed)
-                zone = find_free_zone_and_lock(order, flags,
-                    pzone);
+            ipl = interrupts_disable();
+            spinlock_lock(&zones.lock);
+            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 → 1123,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 → 1147,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 → 1173,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 → 1188,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 → 1220,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 → 1240,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 → 1251,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 → 1312,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/tracing/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/tracing/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>
 ,72 → 41,31
 #include <proc/program.h>
 #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 <ipc/event.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;
 #ifdef CONFIG_UDEBUG
     THREAD->udebug.uspace_state = NULL;
     udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
 #endif
-    if (id < SYSCALL_END) {
+    if (id < SYSCALL_END) {
         rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
     } else {
         printf("Task %" PRIu64": Unknown syscall %#" PRIxn, TASK->taskid, id);
 ,13 → 72,13
         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.
 ,7 → 85,8
      */
     udebug_stoppable_begin();
     udebug_stoppable_end();
-#endif
+#endif
     return rc;
 }
 ,6 → 100,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. */
 ,10 → 122,14
     (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,
     (syshandler_t) sys_ipc_unregister_irq,
+    /* Event notification syscalls. */
+    (syshandler_t) sys_event_subscribe,
     /* Capabilities related syscalls. */
     (syshandler_t) sys_cap_grant,
 ,6 → 136,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 → 147,8
     /* Debug calls */
     (syshandler_t) sys_debug_enable_console,
+    (syshandler_t) sys_debug_disable_console,
     (syshandler_t) sys_ipc_connect_kbox
 };

 /branches/tracing/kernel/generic/src/ipc/event.c
 ,0 → 1,155
+/*
+ * Copyright (c) 2009 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 Kernel event notifications.
+ */
+#include <ipc/event.h>
+#include <ipc/event_types.h>
+#include <mm/slab.h>
+#include <arch/types.h>
+#include <synch/spinlock.h>
+#include <console/console.h>
+#include <memstr.h>
+#include <errno.h>
+#include <arch.h>
+/**
+ * The events array.
+ * Arranging the events in this two-dimensional array should decrease the
+ * likelyhood of cacheline ping-pong.
+ */
+static event_t events[EVENT_END];
+/** Initialize kernel events. */
+void event_init(void)
+{
+    unsigned int i;
+    for (i = 0; i < EVENT_END; i++) {
+        spinlock_initialize(&events[i].lock, "event.lock");
+        events[i].answerbox = NULL;
+        events[i].counter = 0;
+        events[i].method = 0;
+    }
+}
+static int
+event_subscribe(event_type_t evno, unative_t method, answerbox_t *answerbox)
+{
+    if (evno >= EVENT_END)
+        return ELIMIT;
+    spinlock_lock(&events[evno].lock);
+    int res;
+    if (events[evno].answerbox == NULL) {
+        events[evno].answerbox = answerbox;
+        events[evno].method = method;
+        events[evno].counter = 0;
+        res = EOK;
+    } else
+        res = EEXISTS;
+    spinlock_unlock(&events[evno].lock);
+    return res;
+}
+unative_t sys_event_subscribe(unative_t evno, unative_t method)
+{
+    return (unative_t) event_subscribe((event_type_t) evno, (unative_t)
+        method, &TASK->answerbox);
+}
+bool event_is_subscribed(event_type_t evno)
+{
+    bool res;
+    ASSERT(evno < EVENT_END);
+    spinlock_lock(&events[evno].lock);
+    res = events[evno].answerbox != NULL;
+    spinlock_unlock(&events[evno].lock);
+    return res;
+}
+void event_cleanup_answerbox(answerbox_t *answerbox)
+{
+    unsigned int i;
+    for (i = 0; i < EVENT_END; i++) {
+        spinlock_lock(&events[i].lock);
+        if (events[i].answerbox == answerbox) {
+            events[i].answerbox = NULL;
+            events[i].counter = 0;
+            events[i].method = 0;
+        }
+        spinlock_unlock(&events[i].lock);
+    }
+}
+void
+event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,
+    unative_t a4, unative_t a5)
+{
+    ASSERT(evno < EVENT_END);
+    spinlock_lock(&events[evno].lock);
+    if (events[evno].answerbox != NULL) {
+        call_t *call = ipc_call_alloc(FRAME_ATOMIC);
+        if (call) {
+            call->flags |= IPC_CALL_NOTIF;
+            call->priv = ++events[evno].counter;
+            IPC_SET_METHOD(call->data, events[evno].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);
+            spinlock_lock(&events[evno].answerbox->irq_lock);
+            list_append(&call->link, &events[evno].answerbox->irq_notifs);
+            spinlock_unlock(&events[evno].answerbox->irq_lock);
+            waitq_wakeup(&events[evno].answerbox->wq, WAKEUP_FIRST);
+        }
+    }
+    spinlock_unlock(&events[evno].lock);
+}
+/** @}
+ */

 /branches/tracing/kernel/generic/src/ipc/kbox.c
 ,6 → 42,7
 #include <debug.h>
 #include <udebug/udebug_ipc.h>
 #include <ipc/kbox.h>
+#include <print.h>
 void ipc_kbox_cleanup(void)
 {
 ,8 → 129,8
     ipl = interrupts_disable();
     spinlock_lock(&TASK->lock);
-    spinlock_lock(&TASK->answerbox.lock);
-    if (list_empty(&TASK->answerbox.connected_phones)) {
+    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.
 ,7 → 151,7
         *last = false;
     }
-    spinlock_unlock(&TASK->answerbox.lock);
+    spinlock_unlock(&TASK->kb.box.lock);
     spinlock_unlock(&TASK->lock);
     interrupts_restore(ipl);
 }

 /branches/tracing/kernel/generic/src/ipc/sysipc.c
 ,7 → 332,7
         src = IPC_GET_ARG1(call->data);
         size = IPC_GET_ARG2(call->data);
-        if ((size <= 0) || (size > DATA_XFER_LIMIT))
+        if (size > DATA_XFER_LIMIT)
             return ELIMIT;
         call->buffer = (uint8_t *) malloc(size, 0);
 ,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
 ,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;

 /branches/tracing/kernel/generic/src/ipc/ipc.c
 ,6 → 44,7
 #include <synch/synch.h>
 #include <ipc/ipc.h>
 #include <ipc/kbox.h>
+#include <ipc/event.h>
 #include <errno.h>
 #include <mm/slab.h>
 #include <arch.h>
 ,7 → 51,6
 #include <proc/task.h>
 #include <memstr.h>
 #include <debug.h>
 #include <print.h>
 #include <console/console.h>
 #include <proc/thread.h>
 ,6 → 526,9
     for (i = 0; i < IPC_MAX_PHONES; i++)
         ipc_phone_hangup(&TASK->phones[i]);
+    /* Unsubscribe from any event notifications. */
+    event_cleanup_answerbox(&TASK->answerbox);
     /* Disconnect all connected irqs */
     ipc_irq_cleanup(&TASK->answerbox);

 /branches/tracing/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) || defined(ia64)
-        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.
  *
 ,47 → 126,16
     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.
- * @param inr       IRQ number.
- * @param devno     Device number.
- * @param method    Method to be associated with the notification.
- * @param ucode     Uspace pointer to top-half pseudocode.
+ * @param box    Receiving answerbox.
+ * @param inr    IRQ number.
+ * @param devno  Device number.
+ * @param method Method to be associated with the notification.
+ * @param ucode  Uspace pointer to top-half pseudocode.
  *
- * @return      EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
+ * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
+ *
  */
 int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
     unative_t method, irq_code_t *ucode)
 ,7 → 143,12
     ipl_t ipl;
     irq_code_t *code;
     irq_t *irq;
+    link_t *hlp;
+    unative_t key[] = {
+        (unative_t) inr,
+        (unative_t) devno
+    };
     if (ucode) {
         code = code_from_uspace(ucode);
         if (!code)
 ,36 → 156,177
     } else {
         code = NULL;
     }
+    /*
+     * 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;
+    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();
-    irq = irq_find_and_lock(inr, devno);
-    if (!irq) {
-        interrupts_restore(ipl);
+    spinlock_lock(&irq_uspace_hash_table_lock);
+    hlp = hash_table_find(&irq_uspace_hash_table, key);
+    if (hlp) {
+        irq_t *hirq __attribute__((unused))
+            = hash_table_get_instance(hlp, irq_t, link);
+        /* hirq is locked */
+        spinlock_unlock(&hirq->lock);
         code_free(code);
-        return ENOENT;
-    }
-    if (irq->notif_cfg.answerbox) {
-        spinlock_unlock(&irq->lock);
+        spinlock_unlock(&irq_uspace_hash_table_lock);
+        free(irq);
         interrupts_restore(ipl);
-        code_free(code);
         return EEXISTS;
     }
-    irq->notif_cfg.notify = true;
-    irq->notif_cfg.answerbox = box;
-    irq->notif_cfg.method = method;
-    irq->notif_cfg.code = code;
-    irq->notif_cfg.counter = 0;
+    spinlock_lock(&irq->lock);  /* Not really necessary, but paranoid */
     spinlock_lock(&box->irq_lock);
+    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);
+    /* irq is locked */
+    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);
+    /*
+     * We need to drop the IRQ lock now because hash_table_remove() will try
+     * to reacquire it. That basically violates the natural locking order,
+     * but a deadlock in hash_table_remove() is prevented by the fact that
+     * we already held the IRQ lock and didn't drop the hash table lock in
+     * the meantime.
+     */
     spinlock_unlock(&irq->lock);
+    /* 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(&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);
+        /* Free up the pseudo code and associated structures. */
+        code_free(irq->notif_cfg.code);
+        /*
+         * We need to drop the IRQ lock now because hash_table_remove()
+         * will try to reacquire it. That basically violates the natural
+         * locking order, but a deadlock in hash_table_remove() is
+         * prevented by the fact that we already held the IRQ lock and
+         * didn't drop the hash table lock in the meantime.
+         */
+        spinlock_unlock(&irq->lock);
+        /* Remove from the hash table. */
+        hash_table_remove(&irq_uspace_hash_table, key, 2);
+        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 → 345,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/tracing/kernel/generic/src/udebug/udebug.c
41,6 → 41,7
#include <debug.h>
#include <udebug/udebug.h>
#include <errno.h>
#include <print.h>
#include <arch.h>

/branches/tracing/kernel/generic/src/udebug/udebug_ops.c
44,6 → 44,7
#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>

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4376 → Rev 4377