Changeset 04803bf for kernel/generic/include – HelenOS

kernel/generic/include/adt/avl.h

-              rb50b5af2
+              r04803bf
 #ifndef KERN_AVLTREE_H_
 #define KERN_AVLTREE_H_
+#define KERN_AVLTREE_H_
-#include <arch/types.h>
 #include <typedefs.h>
+#include <trace.h>
 /**
 …
  * @param t AVL tree.
  */
 static inline void avltree_create(avltree_t *t)
+NO_TRACE static inline void avltree_create(avltree_t *t)
+{
         t->root = NULL;
 …
  * @param node Node which is initialized.
  */
 static inline void avltree_node_initialize(avltree_node_t *node)
+NO_TRACE static inline void avltree_node_initialize(avltree_node_t *node)
+{
         node->key = 0;

kernel/generic/include/adt/bitmap.h

rb50b5af2	r04803bf
36	36	#define KERN_BITMAP_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39
40	40	#define BITS2BYTES(bits) (bits ? ((((bits)-1)>>3)+1) : 0)

kernel/generic/include/adt/btree.h

rb50b5af2	r04803bf
36	36	#define KERN_BTREE_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39	#include <adt/list.h>
40	40

kernel/generic/include/adt/hash_table.h

-              rb50b5af2
+              r04803bf
 #include <adt/list.h>
 #include <arch/types.h>
+#include <typedefs.h>
 /** Set of operations for hash table. */
 …
          * @return Index into hash table.
          */
         size_t (* hash)(unative_t key[]);
+        size_t (* hash)(sysarg_t key[]);
         /** Hash table item comparison function.
 …
          * @return true if the keys match, false otherwise.
          */
         bool (*compare)(unative_t key[], size_t keys, link_t *item);
+        bool (*compare)(sysarg_t key[], size_t keys, link_t *item);
         /** Hash table item removal callback.
 …
 extern void hash_table_create(hash_table_t *h, size_t m, size_t max_keys,
     hash_table_operations_t *op);
 extern void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item);
 extern link_t *hash_table_find(hash_table_t *h, unative_t key[]);
 extern void hash_table_remove(hash_table_t *h, unative_t key[], size_t keys);
+extern void hash_table_insert(hash_table_t *h, sysarg_t key[], link_t *item);
+extern link_t *hash_table_find(hash_table_t *h, sysarg_t key[]);
+extern void hash_table_remove(hash_table_t *h, sysarg_t key[], size_t keys);
 #endif

kernel/generic/include/adt/list.h

-              rb50b5af2
+              r04803bf
 #define KERN_LIST_H_
-#include <arch/types.h>
 #include <typedefs.h>
+#include <trace.h>
 /** Doubly linked list head and link type. */
 …
  * @param link Pointer to link_t structure to be initialized.
  */
 static inline void link_initialize(link_t *link)
+NO_TRACE static inline void link_initialize(link_t *link)
+{
         link->prev = NULL;
 …
  * @param head Pointer to link_t structure representing head of the list.
  */
 static inline void list_initialize(link_t *head)
+NO_TRACE static inline void list_initialize(link_t *head)
+{
         head->prev = head;
 …
  * @param head Pointer to link_t structure representing head of the list.
  */
 static inline void list_prepend(link_t *link, link_t *head)
+NO_TRACE static inline void list_prepend(link_t *link, link_t *head)
+{
         link->next = head->next;
 …
  * @param head Pointer to link_t structure representing head of the list.
  */
 static inline void list_append(link_t *link, link_t *head)
+NO_TRACE static inline void list_append(link_t *link, link_t *head)
+{
         link->prev = head->prev;
 …
  *              contained in.
  */
 static inline void list_remove(link_t *link)
+NO_TRACE static inline void list_remove(link_t *link)
+{
         link->next->prev = link->prev;
 …
  * @param head Pointer to link_t structure representing head of the list.
  */
 static inline bool list_empty(link_t *head)
+NO_TRACE static inline bool list_empty(link_t *head)
+{
         return head->next == head ? true : false;
 …
  *              headless) list.
  */
 static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
+NO_TRACE static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
+{
         link_t *hlp;
 …
  *              headless list.
  */
 static inline void headless_list_split(link_t *part1, link_t *part2)
+NO_TRACE static inline void headless_list_split(link_t *part1, link_t *part2)
+{
         headless_list_split_or_concat(part1, part2);
 …
  * @param part2 Pointer to link_t structure leading the second headless list.
  */
 static inline void headless_list_concat(link_t *part1, link_t *part2)
+NO_TRACE static inline void headless_list_concat(link_t *part1, link_t *part2)
+{
         headless_list_split_or_concat(part1, part2);

kernel/generic/include/arch.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #include <proc/thread.h>
 #include <proc/task.h>
+#include <mm/as.h>
 #define DEFAULT_CONTEXT         0
+#define DEFAULT_CONTEXT  0
 #define CPU                     THE->cpu
 #define THREAD                  THE->thread
 #define TASK                    THE->task
 #define AS                      THE->as
 #define CONTEXT         (THE->task ? THE->task->context : DEFAULT_CONTEXT)
 #define PREEMPTION_DISABLED     THE->preemption_disabled
+#define CPU                  THE->cpu
+#define THREAD               THE->thread
+#define TASK                 THE->task
+#define AS                   THE->as
+#define CONTEXT              (THE->task ? THE->task->context : DEFAULT_CONTEXT)
+#define PREEMPTION_DISABLED  THE->preemption_disabled
 #define context_check(ctx1, ctx2)       ((ctx1) == (ctx2))
+#define context_check(ctx1, ctx2)  ((ctx1) == (ctx2))
 /**
 …
  */
 typedef struct {
         size_t preemption_disabled;     /**< Preemption disabled counter. */
         thread_t *thread;               /**< Current thread. */
         task_t *task;                   /**< Current task. */
         cpu_t *cpu;                     /**< Executing cpu. */
         as_t *as;                       /**< Current address space. */
+        size_t preemption_disabled;  /**< Preemption disabled counter. */
+        thread_t *thread;            /**< Current thread. */
+        task_t *task;                /**< Current task. */
+        cpu_t *cpu;                  /**< Executing cpu. */
+        as_t *as;                    /**< Current address space. */
 } the_t;
+/*
+ * THE is not an abbreviation, but the English definite article written in
+ * capital letters. It means the current pointer to something, e.g. thread,
+ * processor or address space. Kind reader of this comment shall appreciate
+ * the wit of constructs like THE->thread and similar.
+ */
 #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 the_initialize(the_t *);
+extern void the_copy(the_t *, the_t *);
 extern void arch_pre_mm_init(void);
 …
 extern void reboot(void);
 extern void arch_reboot(void);
 extern void *arch_construct_function(fncptr_t *fptr, void *addr, void *caller);
+extern void *arch_construct_function(fncptr_t *, void *, void *);
 #endif

kernel/generic/include/atomic.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_ATOMIC_H_
+typedef struct atomic {
+        volatile long count;
+} atomic_t;
+#include <typedefs.h>
+#include <arch/atomic.h>
+#include <verify.h>
+#include <arch/atomic.h>
 static inline void atomic_set(atomic_t *val, long i)
+NO_TRACE ATOMIC static inline void atomic_set(atomic_t *val, atomic_count_t i)
+    WRITES(&val->count)
+    REQUIRES_EXTENT_MUTABLE(val)
+{
         val->count = i;
+}
+static inline long atomic_get(atomic_t *val)
+NO_TRACE ATOMIC static inline atomic_count_t atomic_get(atomic_t *val)
+    REQUIRES_EXTENT_MUTABLE(val)
+{
         return val->count;

kernel/generic/include/bitops.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_BITOPS_H_
+#include <trace.h>
+/** Return position of first non-zero bit from left (i.e. [log_2(arg)]).
+#ifdef __32_BITS__
+        #define fnzb(arg)  fnzb32(arg)
+#endif
+#ifdef __64_BITS__
+        #define fnzb(arg)  fnzb64(arg)
+#endif
+/** Return position of first non-zero bit from left (32b variant).
+ *
+ * If number is zero, it returns 0
+ * @return 0 (if the number is zero) or [log_2(arg)].
+ *
  */
 static inline int fnzb32(uint32_t arg)
+NO_TRACE static inline uint8_t fnzb32(uint32_t arg)
+{
         int n = 0;
+        uint8_t n = 0;
         if (arg >> 16) {
                 arg >>= 16;
 …
+        }
+        if (arg >> 1) {
+                arg >>= 1;
+        if (arg >> 1)
                 n += 1;
+        }
         return n;
+}
+static inline int fnzb64(uint64_t arg)
+/** Return position of first non-zero bit from left (64b variant).
+ *
+ * @return 0 (if the number is zero) or [log_2(arg)].
+ *
+ */
+NO_TRACE static inline uint8_t fnzb64(uint64_t arg)
+{
         int n = 0;
+        uint8_t n = 0;
         if (arg >> 32) {
                 arg >>= 32;
 …
+}
-#define fnzb(x) fnzb32(x)
 #endif

kernel/generic/include/byteorder.h

rb50b5af2	r04803bf
36	36	#define KERN_BYTEORDER_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39
40	40	#if !(defined(__BE__) ^ defined(__LE__))

kernel/generic/include/config.h

-              rb50b5af2
+              r04803bf
 #define KERN_CONFIG_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <arch/mm/page.h>
 …
 typedef struct {
         size_t cpu_count;            /**< Number of processors detected. */
+        unsigned int cpu_count;      /**< Number of processors detected. */
         volatile size_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;

kernel/generic/include/console/chardev.h

-              rb50b5af2
+              r04803bf
 #include <adt/list.h>
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
 …
 /** Character input device. */
 typedef struct indev {
         char *name;
+        const char *name;
         waitq_t wq;
         /** Protects everything below. */
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         wchar_t buffer[INDEV_BUFLEN];
         size_t counter;
 …
 /** Character output device. */
 typedef struct outdev {
         char *name;
+        const char *name;
         /** Protects everything below. */
 …
 } 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 indev_initialize(const char *, indev_t *,
+    indev_operations_t *);
+extern void indev_push_character(indev_t *, wchar_t);
+extern wchar_t indev_pop_character(indev_t *);
 extern void outdev_initialize(char *name, outdev_t *outdev,
     outdev_operations_t *op);
+extern void outdev_initialize(const char *, outdev_t *,
+    outdev_operations_t *);
 extern bool check_poll(indev_t *indev);
+extern bool check_poll(indev_t *);
 #endif /* KERN_CHARDEV_H_ */

kernel/generic/include/console/console.h

-              rb50b5af2
+              r04803bf
 #define KERN_CONSOLE_H_
+#include <arch/types.h>
+#include <typedefs.h>
+#include <print.h>
 #include <console/chardev.h>
+#define PAGING(counter, increment, before, after) \
+        do { \
+                (counter) += (increment); \
+                if ((counter) > 23) { \
+                        before; \
+                        printf(" -- Press any key to continue -- "); \
+                        indev_pop_character(stdin); \
+                        after; \
+                        printf("\n"); \
+                        (counter) = 0; \
+                } \
+        } while (0)
 extern indev_t *stdin;
 extern outdev_t *stdout;
+extern bool silent;
+extern void early_putchar(wchar_t);
 extern indev_t *stdin_wire(void);
 …
 extern wchar_t getc(indev_t *indev);
 extern size_t gets(indev_t *indev, char *buf, size_t buflen);
 extern unative_t sys_klog(int fd, const void *buf, size_t size);
+extern sysarg_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 sysarg_t sys_debug_enable_console(void);
+extern sysarg_t sys_debug_disable_console(void);
 #endif /* KERN_CONSOLE_H_ */

kernel/generic/include/console/kconsole.h

-              rb50b5af2
+              r04803bf
         ARG_TYPE_INT,
         ARG_TYPE_STRING,
+        /** Optional string */
+        ARG_TYPE_STRING_OPTIONAL,
         /** Variable type - either symbol or string. */
         ARG_TYPE_VAR
 …
         size_t len;
         /** Integer value. */
         unative_t intval;
+        sysarg_t intval;
         /** Resulting type of variable arg */
         cmd_arg_type_t vartype;
 …
 extern void kconsole_notify_init(void);
 extern bool kconsole_check_poll(void);
 extern void kconsole(char *prompt, char *msg, bool kcon);
+extern void kconsole(const char *prompt, const char *msg, bool kcon);
 extern void kconsole_thread(void *data);

kernel/generic/include/context.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_CONTEXT_H_
+#include <arch/types.h>
+#include <typedefs.h>
+#include <trace.h>
 #include <arch/context.h>
+#define context_set_generic(ctx, _pc, stack, size) \
+        (ctx)->pc = (uintptr_t) (_pc); \
+        (ctx)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
+#ifndef context_set
+#define context_set(c, _pc, stack, size)        \
+        (c)->pc = (uintptr_t) (_pc);            \
+        (c)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
+#endif /* context_set */
+extern int context_save_arch(context_t *c) __attribute__ ((returns_twice));
+extern void context_restore_arch(context_t *c) __attribute__ ((noreturn));
+extern int context_save_arch(context_t *ctx) __attribute__((returns_twice));
+extern void context_restore_arch(context_t *ctx) __attribute__((noreturn));
 /** Save register context.
+ *
+ * Save current register context (including stack pointers)
+ * to context structure.
+ *
+ * Note that call to context_restore() will return at the same
+ * Save the current register context (including stack pointer) to a context
+ * structure. A subsequent call to context_restore() will return to the same
  * address as the corresponding call to context_save().
+ *
+ * This MUST be a macro, gcc -O0 does not inline functions even
+ * if they are marked inline and context_save_arch must be called
+ * from level <= that when context_restore is called.
+ * Note that context_save_arch() must reuse the stack frame of the function
+ * which called context_save(). We guarantee this by:
+ *
+ * @param c Context structure.
+ *   a) implementing context_save_arch() in assembly so that it does not create
+ *      its own stack frame, and by
+ *   b) defining context_save() as a macro because the inline keyword is just a
+ *      hint for the compiler, not a real constraint; the application of a macro
+ *      will definitely not create a stack frame either.
+ *
+ * To imagine what could happen if there were some extra stack frames created
+ * either by context_save() or context_save_arch(), we need to realize that the
+ * sp saved in the contex_t structure points to the current stack frame as it
+ * existed when context_save_arch() was executing. After the return from
+ * context_save_arch() and context_save(), any extra stack frames created by
+ * these functions will be destroyed and their contents sooner or later
+ * overwritten by functions called next. Any attempt to restore to a context
+ * saved like that would therefore lead to a disaster.
+ *
+ * @param ctx Context structure.
+ *
  * @return context_save() returns 1, context_restore() returns 0.
+ *
  */
 #define context_save(c)   context_save_arch(c)
+#define context_save(ctx)  context_save_arch(ctx)
 /** Restore register context.
+ *
  * Restore previously saved register context (including stack pointers)
  * from context structure.
+ * Restore a previously saved register context (including stack pointer) from
+ * a context structure.
+ *
+ * Note that this function does not normally return.
+ * Instead, it returns at the same address as the
+ * corresponding call to context_save(), the only
+ * difference being return value.
+ * Note that this function does not normally return.  Instead, it returns to the
+ * same address as the corresponding call to context_save(), the only difference
+ * being return value.
+ *
+ * @param c Context structure.
+ * @param ctx Context structure.
+ *
  */
 static inline void context_restore(context_t *c)
+NO_TRACE static inline void context_restore(context_t *ctx)
+{
         context_restore_arch(c);
+        context_restore_arch(ctx);
+}

kernel/generic/include/cpu.h

-              rb50b5af2
+              r04803bf
 #include <arch/context.h>
 #define CPU_STACK_SIZE  STACK_SIZE
+#define CPU_STACK_SIZE  STACK_SIZE
 /** CPU structure.
 …
  * There is one structure like this for every processor.
  */
 typedef struct {
         SPINLOCK_DECLARE(lock);
+typedef struct cpu {
+        IRQ_SPINLOCK_DECLARE(lock);
         tlb_shootdown_msg_t tlb_messages[TLB_MESSAGE_QUEUE_LEN];
         size_t tlb_messages_count;
         context_t saved_context;
         atomic_t nrdy;
         runq_t rq[RQ_COUNT];
         volatile size_t needs_relink;
         SPINLOCK_DECLARE(timeoutlock);
+        IRQ_SPINLOCK_DECLARE(timeoutlock);
         link_t timeout_active_head;
+        size_t missed_clock_ticks;      /**< When system clock loses a tick, it is recorded here
+                                             so that clock() can react. This variable is
+                                             CPU-local and can be only accessed when interrupts
+                                             are disabled. */
+        /**
+         * When system clock loses a tick, it is
+         * recorded here so that clock() can react.
+         * This variable is CPU-local and can be
+         * only accessed when interrupts are
+         * disabled.
+         */
+        size_t missed_clock_ticks;
+        /**
+         * Processor cycle accounting.
+         */
+        bool idle;
+        uint64_t last_cycle;
+        uint64_t idle_cycles;
+        uint64_t busy_cycles;
         /**
          * Processor ID assigned by kernel.
 …
         unsigned int id;
         int active;
         int tlb_active;
+        bool active;
+        bool tlb_active;
         uint16_t frequency_mhz;
         uint32_t delay_loop_const;
         cpu_arch_t arch;
         struct thread *fpu_owner;
 …
 extern void cpu_arch_init(void);
 extern void cpu_identify(void);
 extern void cpu_print_report(cpu_t *m);
+extern void cpu_print_report(cpu_t *);
 #endif

kernel/generic/include/ddi/ddi.h

-              rb50b5af2
+              r04803bf
 #include <ddi/ddi_arg.h>
 #include <arch/types.h>
+#include <typedefs.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. */
+        pfn_t frames;       /**< Number of frames in the area. */
+        link_t link;      /**< Linked list link */
+        link_t link;        /**< Linked list link */
+        uintptr_t pbase;  /**< Physical base of the area. */
+        pfn_t frames;     /**< Number of frames in the area. */
+        bool unpriv;      /**< Allow mapping by unprivileged tasks. */
 } parea_t;
 extern void ddi_init(void);
 extern void ddi_parea_register(parea_t *parea);
+extern void ddi_parea_register(parea_t *);
+extern unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base,
+        unative_t pages, unative_t flags);
+extern unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg);
+extern unative_t sys_preempt_control(int enable);
+extern sysarg_t sys_physmem_map(sysarg_t, sysarg_t, sysarg_t, sysarg_t);
+extern sysarg_t sys_iospace_enable(ddi_ioarg_t *);
 /*
  * Interface to be implemented by all architectures.
  */
 extern int ddi_iospace_enable_arch(task_t *task, uintptr_t ioaddr, size_t size);
+extern int ddi_iospace_enable_arch(task_t *, uintptr_t, size_t);
 #endif

kernel/generic/include/ddi/ddi_arg.h

-              rb50b5af2
+              r04803bf
 #define KERN_DDI_ARG_H_
+#ifdef KERNEL
+#include <typedefs.h>
+#endif /* KERNEL */
 /** Structure encapsulating arguments for SYS_PHYSMEM_MAP syscall. */
 typedef struct {
         /** ID of the destination task. */
         unsigned long long task_id;
+        uint64_t task_id;
         /** Physical address of starting frame. */
         void *phys_base;
 …
         void *virt_base;
         /** Number of pages to map. */
         unsigned long pages;
+        size_t pages;
         /** Address space area flags for the mapping. */
         int flags;
+        unsigned int flags;
 } ddi_memarg_t;
 /** Structure encapsulating arguments for SYS_ENABLE_IOSPACE syscall. */
 typedef struct {
         unsigned long long task_id;     /**< ID of the destination task. */
         void *ioaddr;                   /**< Starting I/O space address. */
         unsigned long size;             /**< Number of bytes. */
+        uint64_t task_id;  /**< ID of the destination task. */
+        void *ioaddr;      /**< Starting I/O space address. */
+        size_t size;       /**< Number of bytes. */
 } ddi_ioarg_t;

kernel/generic/include/ddi/device.h

-              rb50b5af2
+              r04803bf
 #define KERN_DEVICE_H_
-#include <arch/types.h>
 #include <typedefs.h>
 extern devno_t device_assign_devno(void);
 extern unative_t sys_device_assign_devno(void);
+extern sysarg_t sys_device_assign_devno(void);
 #endif

kernel/generic/include/ddi/irq.h

-              rb50b5af2
+              r04803bf
 #define KERN_IRQ_H_
-typedef enum {
-        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;
-typedef struct {
-        irq_cmd_type cmd;
-        void *addr;
-        unsigned long long value;
-        unsigned int srcarg;
-        unsigned int dstarg;
-} irq_cmd_t;
-typedef struct {
-        unsigned int cmdcount;
-        irq_cmd_t *cmds;
-} irq_code_t;
 #ifdef KERNEL
 #include <arch/types.h>
+#include <typedefs.h>
 #include <adt/list.h>
 #include <adt/hash_table.h>
 …
 #include <ipc/ipc.h>
+#endif /* KERNEL */
 typedef enum {
+        IRQ_DECLINE,            /**< Decline to service. */
+        IRQ_ACCEPT              /**< Accept to service. */
+        /** Read 1 byte from the I/O space. */
+        CMD_PIO_READ_8 = 1,
+        /** Read 2 bytes from the I/O space. */
+        CMD_PIO_READ_16,
+        /** Read 4 bytes from the I/O space. */
+        CMD_PIO_READ_32,
+        /** Write 1 byte to the I/O space. */
+        CMD_PIO_WRITE_8,
+        /** Write 2 bytes to the I/O space. */
+        CMD_PIO_WRITE_16,
+        /** Write 4 bytes to the I/O space. */
+        CMD_PIO_WRITE_32,
+        /**
+         * Write 1 byte from the source argument
+         * to the I/O space.
+         */
+        CMD_PIO_WRITE_A_8,
+        /**
+         * Write 2 bytes from the source argument
+         * to the I/O space.
+         */
+        CMD_PIO_WRITE_A_16,
+        /**
+         * Write 4 bytes from the source argument
+         * to the I/O space.
+         */
+        CMD_PIO_WRITE_A_32,
+        /**
+         * Perform a bit masking on the source argument
+         * and store the result into the destination argument.
+         */
+        CMD_BTEST,
+        /**
+         * Predicate the execution of the following
+         * N commands by the boolean value of the source
+         * argument.
+         */
+        CMD_PREDICATE,
+        /** Accept the interrupt. */
+        CMD_ACCEPT,
+        /** Decline the interrupt. */
+        CMD_DECLINE,
+        CMD_LAST
+} irq_cmd_type;
+typedef struct {
+        irq_cmd_type cmd;
+        void *addr;
+        uint32_t value;
+        uintptr_t srcarg;
+        uintptr_t dstarg;
+} irq_cmd_t;
+typedef struct {
+        size_t cmdcount;
+        irq_cmd_t *cmds;
+} irq_code_t;
+#ifdef KERNEL
+typedef enum {
+        IRQ_DECLINE,  /**< Decline to service. */
+        IRQ_ACCEPT    /**< Accept to service. */
 } irq_ownership_t;
 …
  * Primarily, this structure is encapsulated in the irq_t structure.
  * It is protected by irq_t::lock.
+ *
  */
 typedef struct {
 …
         /** Answerbox for notifications. */
         answerbox_t *answerbox;
         /** Method to be used for the notification. */
         unative_t method;
+        /** Interface and method to be used for the notification. */
+        sysarg_t imethod;
         /** Arguments that will be sent if the IRQ is claimed. */
         unative_t scratch[IPC_CALL_LEN];
+        uint32_t scratch[IPC_CALL_LEN];
         /** Top-half pseudocode. */
         irq_code_t *code;
         /** Counter. */
         size_t counter;
         /**
          * Link between IRQs that are notifying the same answerbox. The list is
 …
  * If one device has multiple interrupts, there will be multiple irq_t
  * instantions with the same devno.
+ *
  */
 typedef struct irq {
         /** Hash table link. */
         link_t link;
         /** Lock protecting everything in this structure
          *  except the link member. When both the IRQ
 …
          *  this lock must not be taken first.
          */
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         /** Send EOI before processing the interrupt.
 …
          */
         bool preack;
         /** Unique device number. -1 if not yet assigned. */
         devno_t devno;
         /** Actual IRQ number. -1 if not yet assigned. */
         inr_t inr;
 …
         /** Instance argument for the handler and the claim function. */
         void *instance;
         /** Clear interrupt routine. */
         cir_t cir;
         /** First argument to the clear interrupt routine. */
         void *cir_arg;
         /** Notification configuration structure. */
         ipc_notif_cfg_t notif_cfg;
 } irq_t;
 SPINLOCK_EXTERN(irq_uspace_hash_table_lock);
+IRQ_SPINLOCK_EXTERN(irq_uspace_hash_table_lock);
 extern hash_table_t irq_uspace_hash_table;
+extern inr_t last_inr;
 extern void irq_init(size_t, size_t);
 …
 extern irq_t *irq_dispatch_and_lock(inr_t);
+#endif /* KERNEL */
 #endif
-#endif
 /** @}
  */

kernel/generic/include/debug.h

-              rb50b5af2
+              r04803bf
 #include <panic.h>
 #include <arch/debug.h>
+#include <symtab.h>
 #define CALLER ((uintptr_t) __builtin_return_address(0))
+#define CALLER  ((uintptr_t) __builtin_return_address(0))
+#ifndef HERE
+/** Current Instruction Pointer address */
+#       define HERE ((uintptr_t *) 0)
+#endif
+#ifdef CONFIG_DEBUG
 /** Debugging ASSERT macro
 …
+ *
  */
+#ifdef CONFIG_DEBUG
+#       define ASSERT(expr) \
+                if (!(expr)) { \
+                        panic("Assertion failed (%s), caller=%p.", #expr, CALLER); \
+                }
+#else
+#       define ASSERT(expr)
+#endif
+#define ASSERT(expr) \
+        do { \
+                if (!(expr)) \
+                        panic_assert("%s() at %s:%u:\n%s", \
+                            __func__, __FILE__, __LINE__, #expr); \
+        } while (0)
+/** Debugging verbose ASSERT macro
+ *
+ * If CONFIG_DEBUG is set, the ASSERT() macro
+ * evaluates expr and if it is false raises
+ * kernel panic. The panic message contains also
+ * the supplied message.
+ *
+ * @param expr Expression which is expected to be true.
+ * @param msg  Additional message to show (string).
+ *
+ */
+#define ASSERT_VERBOSE(expr, msg) \
+        do { \
+                if (!(expr)) \
+                        panic_assert("%s() at %s:%u:\n%s, %s", \
+                            __func__, __FILE__, __LINE__, #expr, msg); \
+        } while (0)
+#else /* CONFIG_DEBUG */
+#define ASSERT(expr)
+#define ASSERT_VERBOSE(expr, msg)
+#endif /* CONFIG_DEBUG */
+#ifdef CONFIG_LOG
 /** Extensive logging output macro
 …
+ *
  */
+#define LOG(format, ...) \
+        do { \
+                printf("%s() from %s at %s:%u: " format "\n", __func__, \
+                    symtab_fmt_name_lookup(CALLER), __FILE__, __LINE__, \
+                    ##__VA_ARGS__); \
+        } while (0)
+#ifdef CONFIG_LOG
+#       define LOG(format, ...) \
+                printf("%s() at %s:%u: " format "\n", __func__, __FILE__, \
+                        __LINE__, ##__VA_ARGS__);
+#else
+#       define LOG(format, ...)
+#endif
+#else /* CONFIG_LOG */
+/** Extensive logging execute macro
+ *
+ * If CONFIG_LOG is set, the LOG_EXEC() macro
+ * will print an information about calling a given
+ * function and call it.
+ *
+ */
+#define LOG(format, ...)
+#ifdef CONFIG_LOG
+#       define LOG_EXEC(fnc) \
+                { \
+                        printf("%s() at %s:%u: " #fnc "\n", __func__, __FILE__, \
+                        __LINE__); \
+                        fnc; \
+                }
+#else
+#       define LOG_EXEC(fnc) fnc
+#endif
+#endif /* CONFIG_LOG */
+#ifdef CONFIG_TRACE
+extern void __cyg_profile_func_enter(void *, void *);
+extern void __cyg_profile_func_exit(void *, void *);
+#endif /* CONFIG_TRACE */
 #endif

kernel/generic/include/func.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_FUNC_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <atomic.h>
 extern atomic_t haltstate;
+extern void halt(void);
+extern unative_t atoi(const char *text);
+extern void order(const uint64_t val, uint64_t *rv, char *suffix);
+extern void halt(void) __attribute__((noreturn));
 #endif

kernel/generic/include/interrupt.h

-              rb50b5af2
+              r04803bf
 #include <arch/interrupt.h>
+#include <arch/types.h>
+#include <print.h>
+#include <typedefs.h>
 #include <proc/task.h>
 #include <proc/thread.h>
 #include <arch.h>
 #include <ddi/irq.h>
+#include <stacktrace.h>
 typedef void (* iroutine)(int n, istate_t *istate);
+typedef void (* iroutine_t)(unsigned int, istate_t *);
+#define fault_if_from_uspace(istate, fmt, ...) \
+{ \
+        if (istate_from_uspace(istate)) { \
+                task_t *task = TASK; \
+                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(); \
+        } \
+}
+typedef struct {
+        const char *name;
+        bool hot;
+        iroutine_t handler;
+        uint64_t cycles;
+        uint64_t count;
+} exc_table_t;
+extern iroutine exc_register(int n, const char *name, iroutine f);
+extern void exc_dispatch(int n, istate_t *t);
+void exc_init(void);
+IRQ_SPINLOCK_EXTERN(exctbl_lock);
+extern exc_table_t exc_table[];
+extern void fault_if_from_uspace(istate_t *, const char *, ...)
+    PRINTF_ATTRIBUTE(2, 3);
+extern istate_t *istate_get(thread_t *);
+extern iroutine_t exc_register(unsigned int, const char *, bool, iroutine_t);
+extern void exc_dispatch(unsigned int, istate_t *);
+extern void exc_init(void);
+extern void irq_initialize_arch(irq_t *);
+extern void istate_decode(istate_t *);
 #endif

kernel/generic/include/ipc/event.h

-              rb50b5af2
+              r04803bf
 #include <ipc/event_types.h>
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/spinlock.h>
 #include <ipc/ipc.h>
 …
         /** Answerbox for notifications. */
         answerbox_t *answerbox;
         /** Method to be used for the notification. */
         unative_t method;
+        /** Interface and method to be used for the notification. */
+        sysarg_t imethod;
         /** Counter. */
         size_t counter;
 …
 extern void event_init(void);
 extern unative_t sys_event_subscribe(unative_t, unative_t);
+extern sysarg_t sys_event_subscribe(sysarg_t, sysarg_t);
 extern bool event_is_subscribed(event_type_t);
 extern void event_cleanup_answerbox(answerbox_t *);
 …
         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);
+extern void event_notify(event_type_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t);
 #endif

kernel/generic/include/ipc/event_types.h

-              rb50b5af2
+              r04803bf
 typedef enum event_type {
+        /** New data available in kernel log */
         EVENT_KLOG = 0,
+        /** Returning from kernel console to userspace */
         EVENT_KCONSOLE,
+        /** A task/thread has faulted and will be terminated */
+        EVENT_FAULT,
         EVENT_END
 } event_type_t;

kernel/generic/include/ipc/ipc.h

-              rb50b5af2
+              r04803bf
 #define KERN_IPC_H_
+/* Length of data being transfered with IPC call */
+/* - the uspace may not be able to utilize full length */
+#define IPC_CALL_LEN            6
+/** Maximum active async calls per thread */
+#ifdef CONFIG_DEBUG
+#define IPC_MAX_ASYNC_CALLS     4
+#else
+#define IPC_MAX_ASYNC_CALLS     4000
+#endif
+/** Length of data being transfered with IPC call
+ *
+ * The uspace may not be able to utilize full length
+ *
+ */
+#define IPC_CALL_LEN  6
+/** Maximum active async calls per phone */
+#define IPC_MAX_ASYNC_CALLS  4
 /* Flags for calls */
 /** This is answer to a call */
+#define IPC_CALL_ANSWERED       (1 << 0)
+/** This call will not be freed on error */
+#define IPC_CALL_STATIC_ALLOC   (1 << 1)
+#define IPC_CALL_ANSWERED  (1 << 0)
 /** Answer will not be passed to userspace, will be discarded */
+#define IPC_CALL_DISCARD_ANSWER (1 << 2)
+#define IPC_CALL_DISCARD_ANSWER  (1 << 1)
 /** Call was forwarded */
+#define IPC_CALL_FORWARDED      (1 << 3)
+#define IPC_CALL_FORWARDED  (1 << 2)
 /** Identify connect_me_to answer */
+#define IPC_CALL_CONN_ME_TO     (1 << 4)
+#define IPC_CALL_CONN_ME_TO  (1 << 3)
 /** Interrupt notification */
+#define IPC_CALL_NOTIF          (1 << 5)
+/*
+ * Bits used in call hashes.
+#define IPC_CALL_NOTIF  (1 << 4)
+/** Bits used in call hashes.
+ *
  * The addresses are aligned at least to 4 that is why we can use the 2 least
  * significant bits of the call address.
+ */
+ *
+ */
 /** Type of this call is 'answer' */
+#define IPC_CALLID_ANSWERED     1
+#define IPC_CALLID_ANSWERED  1
 /** Type of this call is 'notification' */
 #define IPC_CALLID_NOTIFICATION 2
+#define IPC_CALLID_NOTIFICATION  2
 /* Return values from sys_ipc_call_async(). */
 #define IPC_CALLRET_FATAL       -1
 #define IPC_CALLRET_TEMPORARY   -2
+#define IPC_CALLRET_FATAL      -1
+#define IPC_CALLRET_TEMPORARY  -2
 /* Macros for manipulating calling data */
 #define IPC_SET_RETVAL(data, retval)    ((data).args[0] = (retval))
 #define IPC_SET_METHOD(data, val)       ((data).args[0] = (val))
 #define IPC_SET_ARG1(data, val)         ((data).args[1] = (val))
 #define IPC_SET_ARG2(data, val)         ((data).args[2] = (val))
 #define IPC_SET_ARG3(data, val)         ((data).args[3] = (val))
 #define IPC_SET_ARG4(data, val)         ((data).args[4] = (val))
 #define IPC_SET_ARG5(data, val)         ((data).args[5] = (val))
 #define IPC_GET_METHOD(data)            ((data).args[0])
 #define IPC_GET_RETVAL(data)            ((data).args[0])
 #define IPC_GET_ARG1(data)              ((data).args[1])
 #define IPC_GET_ARG2(data)              ((data).args[2])
 #define IPC_GET_ARG3(data)              ((data).args[3])
 #define IPC_GET_ARG4(data)              ((data).args[4])
 #define IPC_GET_ARG5(data)              ((data).args[5])
+#define IPC_SET_RETVAL(data, retval)  ((data).args[0] = (retval))
+#define IPC_SET_IMETHOD(data, val)    ((data).args[0] = (val))
+#define IPC_SET_ARG1(data, val)       ((data).args[1] = (val))
+#define IPC_SET_ARG2(data, val)       ((data).args[2] = (val))
+#define IPC_SET_ARG3(data, val)       ((data).args[3] = (val))
+#define IPC_SET_ARG4(data, val)       ((data).args[4] = (val))
+#define IPC_SET_ARG5(data, val)       ((data).args[5] = (val))
+#define IPC_GET_IMETHOD(data)  ((data).args[0])
+#define IPC_GET_RETVAL(data)   ((data).args[0])
+#define IPC_GET_ARG1(data)  ((data).args[1])
+#define IPC_GET_ARG2(data)  ((data).args[2])
+#define IPC_GET_ARG3(data)  ((data).args[3])
+#define IPC_GET_ARG4(data)  ((data).args[4])
+#define IPC_GET_ARG5(data)  ((data).args[5])
 /* Well known phone descriptors */
 #define PHONE_NS        0
+#define PHONE_NS  0
 /* Forwarding flags. */
+#define IPC_FF_NONE             0
+#define IPC_FF_NONE  0
 /**
  * The call will be routed as though it was initially sent via the phone used to
 …
  * calls that were initially sent by the forwarder to the same destination. This
  * flag has no imapct on routing replies.
+ */
+#define IPC_FF_ROUTE_FROM_ME    (1 << 0)
+/* System-specific methods - only through special syscalls
+ * These methods have special behaviour
+ */
+ *
+ */
+#define IPC_FF_ROUTE_FROM_ME  (1 << 0)
+/** Kernel IPC interfaces
+ *
+ */
+#define IPC_IF_KERNEL  0
+/** System-specific methods - only through special syscalls
+ *
+ * These methods have special behaviour. These methods also
+ * have the implicit kernel interface 0.
+ *
+ */
 /** Clone connection.
+ *
 …
+ *
  * - ARG1 - The caller sets ARG1 to the phone of the cloned connection.
+ *        - The callee gets the new phone from ARG1.
+ *        - The callee gets the new phone from ARG1.
+ *
  * - on answer, the callee acknowledges the new connection by sending EOK back
  *   or the kernel closes it
+ */
+#define IPC_M_CONNECTION_CLONE  1
+ *
+ */
+#define IPC_M_CONNECTION_CLONE  1
 /** Protocol for CONNECT - ME
+ *
  * Through this call, the recipient learns about the new cloned connection.
+ *
+ *
  * - ARG5 - the kernel sets ARG5 to contain the hash of the used phone
  * - on asnwer, the callee acknowledges the new connection by sending EOK back
  *   or the kernel closes it
+ */
+#define IPC_M_CONNECT_ME        2
+/** Protocol for CONNECT - TO - ME
+ *
+ */
+#define IPC_M_CONNECT_ME  2
+/** Protocol for CONNECT - TO - ME
+ *
  * Calling process asks the callee to create a callback connection,
 …
  *                       error is sent back to caller. Otherwise
  *                       the call is accepted and the response is sent back.
+ *                     - the allocated phoneid is passed to userspace
+ *                     - the hash of the client task is passed to userspace
+ *                       (on the receiving side) as ARG4 of the call.
+ *                     - the hash of the allocated phone is passed to userspace
  *                       (on the receiving side) as ARG5 of the call.
+ */
+#define IPC_M_CONNECT_TO_ME     3
+ *
+ */
+#define IPC_M_CONNECT_TO_ME  3
 /** Protocol for CONNECT - ME - TO
+ *
 …
+ *
  */
+#define IPC_M_CONNECT_ME_TO     4
+/** This message is sent to answerbox when the phone
+ * is hung up
+ */
+#define IPC_M_PHONE_HUNGUP      5
+#define IPC_M_CONNECT_ME_TO  4
+/** This message is sent to answerbox when the phone is hung up
+ *
+ */
+#define IPC_M_PHONE_HUNGUP  5
 /** Send as_area over IPC.
 …
  * - ARG2 - size of source as_area (filled automatically by kernel)
  * - ARG3 - flags of the as_area being sent
+ *
+ *
  * on answer, the recipient must set:
  * - ARG1 - dst as_area base adress
+ */
+#define IPC_M_SHARE_OUT         6
+ *
+ */
+#define IPC_M_SHARE_OUT  6
 /** Receive as_area over IPC.
 …
  * - ARG2 - destination as_area size
  * - ARG3 - user defined argument
+ *
+ *
  * on answer, the recipient must set:
+ *
  * - ARG1 - source as_area base address
  * - ARG2 - flags that will be used for sharing
+ */
+#define IPC_M_SHARE_IN          7
+ *
+ */
+#define IPC_M_SHARE_IN  7
 /** Send data to another address space over IPC.
 …
  * - ARG1 - final destination address space virtual address
  * - ARG2 - final size of data to be copied
+ */
+#define IPC_M_DATA_WRITE        8
+ *
+ */
+#define IPC_M_DATA_WRITE  8
 /** Receive data from another address space over IPC.
 …
  * - ARG1 - source virtual address in the destination address space
  * - ARG2 - final size of data to be copied
+ */
+#define IPC_M_DATA_READ         9
+ *
+ */
+#define IPC_M_DATA_READ  9
 /** Debug the recipient.
  * - ARG1 - specifies the debug method (from udebug_method_t)
  * - other arguments are specific to the debug method
+ */
+#define IPC_M_DEBUG_ALL         10
+ *
+ */
+#define IPC_M_DEBUG_ALL  10
 /* Well-known methods */
+#define IPC_M_LAST_SYSTEM       511
+#define IPC_M_PING              512
+#define IPC_M_LAST_SYSTEM  511
+#define IPC_M_PING         512
 /* User methods */
 #define IPC_FIRST_USER_METHOD   1024
+#define IPC_FIRST_USER_METHOD  1024
 #ifdef KERNEL
 #define IPC_MAX_PHONES  16
+#define IPC_MAX_PHONES  32
 #include <synch/spinlock.h>
 …
 typedef struct answerbox {
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         struct task *task;
         waitq_t wq;
+        /** Linkage for the list of task's synchronous answerboxes. */
+        link_t sync_box_link;
         /** Phones connected to this answerbox. */
         link_t connected_phones;
         /** Received calls. */
         link_t calls;
         link_t dispatched_calls;        /* Should be hash table in the future */
+        link_t calls;
+        link_t dispatched_calls;  /* Should be hash table in the future */
         /** Answered calls. */
         link_t answers;
+        SPINLOCK_DECLARE(irq_lock);
+        IRQ_SPINLOCK_DECLARE(irq_lock);
         /** Notifications from IRQ handlers. */
         link_t irq_notifs;
 …
 typedef struct {
+        unative_t args[IPC_CALL_LEN];
+        sysarg_t args[IPC_CALL_LEN];
+        /** Task which made or forwarded the call with IPC_FF_ROUTE_FROM_ME. */
+        struct task *task;
+        /** Phone which made or last masqueraded this call. */
         phone_t *phone;
 } ipc_data_t;
 …
 typedef struct {
         link_t link;
         int flags;
+        unsigned int flags;
         /** Identification of the caller. */
         struct task *sender;
+        /** The caller box is different from sender->answerbox for synchronous
+         *  calls. */
+        /*
+         * The caller box is different from sender->answerbox
+         * for synchronous calls.
+         */
         answerbox_t *callerbox;
         /** Private data to internal IPC. */
         unative_t priv;
+        sysarg_t priv;
         /** Data passed from/to userspace. */
         ipc_data_t data;
         /** Buffer for IPC_M_DATA_WRITE and IPC_M_DATA_READ. */
         uint8_t *buffer;
         /*
          * The forward operation can masquerade the caller phone. For those
 …
 } call_t;
+extern answerbox_t *ipc_phone_0;
 extern void ipc_init(void);
+extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, int);
+extern void ipc_answer(answerbox_t *, call_t *);
+extern call_t *ipc_call_alloc(unsigned int);
+extern void ipc_call_free(call_t *);
 extern int ipc_call(phone_t *, call_t *);
 extern int ipc_call_sync(phone_t *, call_t *);
+extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, unsigned int);
+extern int ipc_forward(call_t *, phone_t *, answerbox_t *, unsigned int);
+extern void ipc_answer(answerbox_t *, call_t *);
 extern void ipc_phone_init(phone_t *);
 extern void ipc_phone_connect(phone_t *, answerbox_t *);
 extern void ipc_call_free(call_t *);
+extern call_t * ipc_call_alloc(int);
+extern int ipc_phone_hangup(phone_t *);
 extern void ipc_answerbox_init(answerbox_t *, struct task *);
+extern void ipc_call_static_init(call_t *);
+extern void task_print_list(void);
+extern int ipc_forward(call_t *, phone_t *, answerbox_t *, int);
 extern void ipc_cleanup(void);
+extern int ipc_phone_hangup(phone_t *);
+extern void ipc_backsend_err(phone_t *, call_t *, unative_t);
+extern void ipc_print_task(task_id_t);
+extern void ipc_backsend_err(phone_t *, call_t *, sysarg_t);
 extern void ipc_answerbox_slam_phones(answerbox_t *, bool);
 extern void ipc_cleanup_call_list(link_t *);
+extern answerbox_t *ipc_phone_0;
+extern void ipc_print_task(task_id_t);
+#endif /* KERNEL */
 #endif
-#endif
 /** @}
  */

kernel/generic/include/ipc/ipcrsc.h

rb50b5af2	r04803bf
39	39	#include <ipc/ipc.h>
40	40
41		extern call_t * get_call(~~unative~~_t callid);
	41	extern call_t * get_call(sysarg_t callid);
42	42	extern int phone_alloc(task_t *t);
43	43	extern void phone_connect(int phoneid, answerbox_t *box);

kernel/generic/include/ipc/irq.h

-              rb50b5af2
+              r04803bf
 /** Maximum length of IPC IRQ program */
 #define IRQ_MAX_PROG_SIZE       20
+#define IRQ_MAX_PROG_SIZE  20
 #include <ipc/ipc.h>
 #include <ddi/irq.h>
 #include <arch/types.h>
+#include <typedefs.h>
 #include <adt/list.h>
 extern int ipc_irq_register(answerbox_t *, inr_t, devno_t, unative_t,
+extern int ipc_irq_register(answerbox_t *, inr_t, devno_t, sysarg_t,
     irq_code_t *);
 …
  */
 #define ipc_irq_send_msg_0(irq) \
+    ipc_irq_send_msg((irq), 0, 0, 0, 0, 0)
+        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)
+        ipc_irq_send_msg((irq), (a1), 0, 0, 0, 0)
 #define ipc_irq_send_msg_2(irq, a1, a2) \
+    ipc_irq_send_msg((irq), (a1), (a2), 0, 0, 0)
+        ipc_irq_send_msg((irq), (a1), (a2), 0, 0, 0)
 #define ipc_irq_send_msg_3(irq, a1, a2, a3) \
+    ipc_irq_send_msg((irq), (a1), (a2), (a3), 0, 0)
+        ipc_irq_send_msg((irq), (a1), (a2), (a3), 0, 0)
 #define ipc_irq_send_msg_4(irq, a1, a2, a3, a4) \
+    ipc_irq_send_msg((irq), (a1), (a2), (a3), (a4), 0)
+        ipc_irq_send_msg((irq), (a1), (a2), (a3), (a4), 0)
 #define ipc_irq_send_msg_5(irq, a1, a2, a3, a4, a5) \
     ipc_irq_send_msg((irq), (a1), (a2), (a3), (a4), (a5))
+        ipc_irq_send_msg((irq), (a1), (a2), (a3), (a4), (a5))
 extern void ipc_irq_send_msg(irq_t *, unative_t, unative_t, unative_t, unative_t,
     unative_t);
+extern void ipc_irq_send_msg(irq_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t);
 #endif

kernel/generic/include/ipc/sysipc.h

-              rb50b5af2
+              r04803bf
 #include <ipc/ipc.h>
 #include <ipc/irq.h>
 #include <arch/types.h>
+#include <typedefs.h>
+unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
+    unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data);
+unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
+    ipc_data_t *reply);
+unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
+    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4);
+unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data);
+unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
+    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4);
+unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data);
+unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
+    int nonblocking);
+unative_t sys_ipc_poke(void);
+unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
+    unative_t method, unative_t arg1, unative_t arg2, int mode);
+unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+    ipc_data_t *data, int mode);
+unative_t sys_ipc_hangup(int phoneid);
+unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
+    irq_code_t *ucode);
+unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno);
+unative_t sys_ipc_connect_kbox(sysarg64_t *task_id);
+extern sysarg_t sys_ipc_call_sync_fast(sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, ipc_data_t *);
+extern sysarg_t sys_ipc_call_sync_slow(sysarg_t, ipc_data_t *, ipc_data_t *);
+extern sysarg_t sys_ipc_call_async_fast(sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t);
+extern sysarg_t sys_ipc_call_async_slow(sysarg_t, ipc_data_t *);
+extern sysarg_t sys_ipc_answer_fast(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t);
+extern sysarg_t sys_ipc_answer_slow(sysarg_t, ipc_data_t *);
+extern sysarg_t sys_ipc_wait_for_call(ipc_data_t *, uint32_t, unsigned int);
+extern sysarg_t sys_ipc_poke(void);
+extern sysarg_t sys_ipc_forward_fast(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, unsigned int);
+extern sysarg_t sys_ipc_forward_slow(sysarg_t, sysarg_t, ipc_data_t *,
+    unsigned int);
+extern sysarg_t sys_ipc_hangup(sysarg_t);
+extern sysarg_t sys_register_irq(inr_t, devno_t, sysarg_t, irq_code_t *);
+extern sysarg_t sys_unregister_irq(inr_t, devno_t);
+#ifdef __32_BITS__
+extern sysarg_t sys_ipc_connect_kbox(sysarg64_t *);
+#endif  /* __32_BITS__ */
+#ifdef __64_BITS__
+extern sysarg_t sys_ipc_connect_kbox(sysarg_t);
+#endif  /* __64_BITS__ */
 #endif

kernel/generic/include/lib/elf.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #include <arch/elf.h>
 #include <arch/types.h>
+#include <typedefs.h>
 /**
  * current ELF version
  */
 #define EV_CURRENT      1
 /**
  * ELF types
  */
 #define ET_NONE         0       /* No type */
 #define ET_REL          1       /* Relocatable file */
 #define ET_EXEC         2       /* Executable */
 #define ET_DYN          3       /* Shared object */
 #define ET_CORE         4       /* Core */
 #define ET_LOPROC       0xff00  /* Processor specific */
 #define ET_HIPROC       0xffff  /* Processor specific */
 /**
+#define EV_CURRENT  1
+/**
+ * ELF types
+ */
+#define ET_NONE    0       /* No type */
+#define ET_REL     1       /* Relocatable file */
+#define ET_EXEC    2       /* Executable */
+#define ET_DYN     3       /* Shared object */
+#define ET_CORE    4       /* Core */
+#define ET_LOPROC  0xff00  /* Processor specific */
+#define ET_HIPROC  0xffff  /* Processor specific */
+/**
  * ELF machine types
  */
 #define EM_NO           0       /* No machine */
 #define EM_SPARC        2       /* SPARC */
 #define EM_386          3       /* i386 */
 #define EM_MIPS         8       /* MIPS RS3000 */
 #define EM_MIPS_RS3_LE  10      /* MIPS RS3000 LE */
 #define EM_PPC          20      /* PPC32 */
 #define EM_PPC64        21      /* PPC64 */
 #define EM_ARM          40      /* ARM */
 #define EM_SPARCV9      43      /* SPARC64 */
 #define EM_IA_64        50      /* IA-64 */
 #define EM_X86_64       62      /* AMD64/EMT64 */
+#define EM_NO           0   /* No machine */
+#define EM_SPARC        2   /* SPARC */
+#define EM_386          3   /* i386 */
+#define EM_MIPS         8   /* MIPS RS3000 */
+#define EM_MIPS_RS3_LE  10  /* MIPS RS3000 LE */
+#define EM_PPC          20  /* PPC32 */
+#define EM_PPC64        21  /* PPC64 */
+#define EM_ARM          40  /* ARM */
+#define EM_SPARCV9      43  /* SPARC64 */
+#define EM_IA_64        50  /* IA-64 */
+#define EM_X86_64       62  /* AMD64/EMT64 */
 /**
  * ELF identification indexes
  */
 #define EI_MAG0         0
 #define EI_MAG1         1
 #define EI_MAG2         2
 #define EI_MAG3         3
 #define EI_CLASS        4               /* File class */
 #define EI_DATA         5               /* Data encoding */
 #define EI_VERSION      6               /* File version */
 #define EI_OSABI        7
 #define EI_ABIVERSION   8
 #define EI_PAD          9               /* Start of padding bytes */
 #define EI_NIDENT       16              /* ELF identification table size */
+#define EI_MAG0        0
+#define EI_MAG1        1
+#define EI_MAG2        2
+#define EI_MAG3        3
+#define EI_CLASS       4   /* File class */
+#define EI_DATA        5   /* Data encoding */
+#define EI_VERSION     6   /* File version */
+#define EI_OSABI       7
+#define EI_ABIVERSION  8
+#define EI_PAD         9   /* Start of padding bytes */
+#define EI_NIDENT      16  /* ELF identification table size */
 /**
  * ELF magic number
  */
 #define ELFMAG0         0x7f
 #define ELFMAG1         'E'
 #define ELFMAG2         'L'
 #define ELFMAG3         'F'
+#define ELFMAG0  0x7f
+#define ELFMAG1  'E'
+#define ELFMAG2  'L'
+#define ELFMAG3  'F'
 /**
  * ELF file classes
  */
 #define ELFCLASSNONE    0
 #define ELFCLASS32      1
 #define ELFCLASS64      2
+#define ELFCLASSNONE  0
+#define ELFCLASS32    1
+#define ELFCLASS64    2
 /**
  * ELF data encoding types
  */
 #define ELFDATANONE     0
 #define ELFDATA2LSB     1               /* Least significant byte first (little endian) */
 #define ELFDATA2MSB     2               /* Most signigicant byte first (big endian) */
+#define ELFDATANONE  0
+#define ELFDATA2LSB  1  /* Least significant byte first (little endian) */
+#define ELFDATA2MSB  2  /* Most signigicant byte first (big endian) */
 /**
  * ELF error return codes
  */
 #define EE_OK                   0       /* No error */
 #define EE_INVALID              1       /* Invalid ELF image */
 #define EE_MEMORY               2       /* Cannot allocate address space */
 #define EE_INCOMPATIBLE         3       /* ELF image is not compatible with current architecture */
 #define EE_UNSUPPORTED          4       /* Non-supported ELF (e.g. dynamic ELFs) */
 #define EE_LOADER               5       /* The image is actually a program loader */
 #define EE_IRRECOVERABLE        6
+#define EE_OK             0  /* No error */
+#define EE_INVALID        1  /* Invalid ELF image */
+#define EE_MEMORY         2  /* Cannot allocate address space */
+#define EE_INCOMPATIBLE   3  /* ELF image is not compatible with current architecture */
+#define EE_UNSUPPORTED    4  /* Non-supported ELF (e.g. dynamic ELFs) */
+#define EE_LOADER         5  /* The image is actually a program loader */
+#define EE_IRRECOVERABLE  6
 /**
  * ELF section types
  */
 #define SHT_NULL                0
 #define SHT_PROGBITS            1
 #define SHT_SYMTAB              2
 #define SHT_STRTAB              3
 #define SHT_RELA                4
 #define SHT_HASH                5
 #define SHT_DYNAMIC             6
 #define SHT_NOTE                7
 #define SHT_NOBITS              8
 #define SHT_REL                 9
 #define SHT_SHLIB               10
 #define SHT_DYNSYM              11
 #define SHT_LOOS                0x60000000
 #define SHT_HIOS                0x6fffffff
 #define SHT_LOPROC              0x70000000
 #define SHT_HIPROC              0x7fffffff
 #define SHT_LOUSER              0x80000000
 #define SHT_HIUSER              0xffffffff
+#define SHT_NULL      0
+#define SHT_PROGBITS  1
+#define SHT_SYMTAB    2
+#define SHT_STRTAB    3
+#define SHT_RELA      4
+#define SHT_HASH      5
+#define SHT_DYNAMIC   6
+#define SHT_NOTE      7
+#define SHT_NOBITS    8
+#define SHT_REL       9
+#define SHT_SHLIB     10
+#define SHT_DYNSYM    11
+#define SHT_LOOS      0x60000000
+#define SHT_HIOS      0x6fffffff
+#define SHT_LOPROC    0x70000000
+#define SHT_HIPROC    0x7fffffff
+#define SHT_LOUSER    0x80000000
+#define SHT_HIUSER    0xffffffff
 /**
  * ELF section flags
  */
 #define SHF_WRITE               0x1
 #define SHF_ALLOC               0x2
 #define SHF_EXECINSTR           0x4
 #define SHF_TLS                 0x400
 #define SHF_MASKPROC            0xf0000000
+#define SHF_WRITE      0x1
+#define SHF_ALLOC      0x2
+#define SHF_EXECINSTR  0x4
+#define SHF_TLS        0x400
+#define SHF_MASKPROC   0xf0000000
 /**
  * Symbol binding
  */
 #define STB_LOCAL               0
 #define STB_GLOBAL              1
 #define STB_WEAK                2
 #define STB_LOPROC              13
 #define STB_HIPROC              15
+#define STB_LOCAL   0
+#define STB_GLOBAL  1
+#define STB_WEAK    2
+#define STB_LOPROC  13
+#define STB_HIPROC  15
 /**
  * Symbol types
  */
 #define STT_NOTYPE              0
 #define STT_OBJECT              1
 #define STT_FUNC                2
 #define STT_SECTION             3
 #define STT_FILE                4
 #define STT_LOPROC              13
 #define STT_HIPROC              15
+#define STT_NOTYPE   0
+#define STT_OBJECT   1
+#define STT_FUNC     2
+#define STT_SECTION  3
+#define STT_FILE     4
+#define STT_LOPROC   13
+#define STT_HIPROC   15
 /**
  * Program segment types
  */
 #define PT_NULL                 0
 #define PT_LOAD                 1
 #define PT_DYNAMIC              2
 #define PT_INTERP               3
 #define PT_NOTE                 4
 #define PT_SHLIB                5
 #define PT_PHDR                 6
 #define PT_LOPROC               0x70000000
 #define PT_HIPROC               0x7fffffff
+#define PT_NULL     0
+#define PT_LOAD     1
+#define PT_DYNAMIC  2
+#define PT_INTERP   3
+#define PT_NOTE     4
+#define PT_SHLIB    5
+#define PT_PHDR     6
+#define PT_LOPROC   0x70000000
+#define PT_HIPROC   0x7fffffff
 /**
  * Program segment attributes.
  */
 #define PF_X    1
 #define PF_W    2
 #define PF_R    4
+#define PF_X  1
+#define PF_W  2
+#define PF_R  4
 /**
 …
  * ELF object file specifications. They are the only types used
  * in ELF header.
+ *
  */
 typedef uint64_t elf_xword;
 …
+ *
  * These types are specific for 32-bit format.
+ *
  */
 typedef uint32_t elf32_addr;
 …
+ *
  * These types are specific for 64-bit format.
+ *
  */
 typedef uint64_t elf64_addr;
 …
         elf_half e_shstrndx;
 };
 struct elf64_header {
         uint8_t e_ident[EI_NIDENT];
 …
 };
 /*
+/**
  * ELF segment header.
  * Segments headers are also known as program headers.
 …
         elf_word p_align;
 };
 struct elf64_segment_header {
         elf_word p_type;
 …
 };
 /*
+/**
  * ELF section header
  */
 …
         elf_word sh_entsize;
 };
 struct elf64_section_header {
         elf_word sh_name;
 …
 };
 /*
+/**
  * ELF symbol table entry
  */
 …
         elf_half st_shndx;
 };
 struct elf64_symbol {
         elf_word st_name;
 …
 };
 #ifdef __32_BITS__
+#ifdef __32_BITS__
 typedef struct elf32_header elf_header_t;
 typedef struct elf32_segment_header elf_segment_header_t;
 …
 typedef struct elf32_symbol elf_symbol_t;
 #endif
 #ifdef __64_BITS__
 typedef struct elf64_header elf_header_t;
 …
 #endif
 extern char *elf_error(unsigned int rc);
 /* Interpreter string used to recognize the program loader */
 #define ELF_INTERP_ZSTR "kernel"
+extern const char *elf_error(unsigned int rc);
+/** Interpreter string used to recognize the program loader */
+#define ELF_INTERP_ZSTR  "kernel"
 #define ELF_INTERP_ZLEN  sizeof(ELF_INTERP_ZSTR)

kernel/generic/include/lib/rd.h

-              rb50b5af2
+              r04803bf
 #define KERN_RD_H_
 #include <arch/types.h>
+#include <typedefs.h>
 /**
  * RAM disk version
  */
 #define RD_VERSION      1
+#define RD_VERSION      1
 /**

kernel/generic/include/macros.h

-              rb50b5af2
+              r04803bf
 #ifndef __ASM__
+#include <arch/types.h>
+#include <typedefs.h>
+#include <trace.h>
 /** Return true if the intervals overlap.
 …
  * @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)
+NO_TRACE static inline int overlaps(uint64_t s1, uint64_t sz1, uint64_t s2,
+    uint64_t sz2)
+{
         uintptr_t e1 = s1 + sz1;
         uintptr_t e2 = s2 + sz2;
+        uint64_t e1 = s1 + sz1;
+        uint64_t e2 = s2 + sz2;
         return ((s1 < e2) && (s2 < e1));
+}
+/** Return true if the second interval is within the first interval.
+ *
+ * @param s1  Start address of the first interval.
+ * @param sz1 Size of the first interval.
+ * @param s2  Start address of the second interval.
+ * @param sz2 Size of the second interval.
+ *
+ */
+NO_TRACE static inline int iswithin(uint64_t s1, uint64_t sz1, uint64_t s2,
+    uint64_t sz2)
+{
+        uint64_t e1 = s1 + sz1;
+        uint64_t e2 = s2 + sz2;
+        return ((s1 <= s2) && (e1 >= e2));
+}
 …
 /* 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 STRING_ARG(arg)  #arg
 #define LOWER32(arg)  ((arg) & 0xffffffff)
 #define UPPER32(arg)  (((arg) >> 32) & 0xffffffff)
+#define LOWER32(arg)  (((uint64_t) (arg)) & UINT32_C(0xffffffff))
+#define UPPER32(arg)  (((((uint64_t) arg)) >> 32) & UINT32_C(0xffffffff))
 #define MERGE_LOUP32(lo, up) \
         ((((uint64_t) (lo)) & 0xffffffff) \
             | ((((uint64_t) (up)) & 0xffffffff) << 32))
+        ((((uint64_t) (lo)) & UINT32_C(0xffffffff)) \
+            | ((((uint64_t) (up)) & UINT32_C(0xffffffff)) << 32))
 /** Pseudorandom generator

kernel/generic/include/main/main.h

-              rb50b5af2
+              r04803bf
 /** @file
  */
 #ifndef KERN_MAIN_H_
 #define KERN_MAIN_H_
 #include <arch/types.h>
+#include <typedefs.h>
+extern size_t hardcoded_kdata_size;
+extern size_t hardcoded_ktext_size;
+extern uintptr_t hardcoded_load_address;
 extern uintptr_t stack_safe;

kernel/generic/include/main/uinit.h

rb50b5af2	r04803bf
36	36	#define KERN_UINIT_H_
37	37
38		~~#include <arch/types.h>~~
39
40	38	extern void uinit(void *arg);
41	39

kernel/generic/include/main/version.h

rb50b5af2	r04803bf
42	42	/** @}
43	43	*/
44

kernel/generic/include/memstr.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_MEMSTR_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <arch/memstr.h>

kernel/generic/include/mm/as.h

-              rb50b5af2
+              r04803bf
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
+ *
 …
 #define KERN_AS_H_
+#ifdef KERNEL
+        #include <typedefs.h>
+#else
+        #include <sys/types.h>
+#endif
 /** Address space area flags. */
+#define AS_AREA_READ            1
+#define AS_AREA_WRITE           2
+#define AS_AREA_EXEC            4
+#define AS_AREA_CACHEABLE       8
+#define AS_AREA_READ       1
+#define AS_AREA_WRITE      2
+#define AS_AREA_EXEC       4
+#define AS_AREA_CACHEABLE  8
+/** Address space area info exported to userspace. */
+typedef struct {
+        /** Starting address */
+        uintptr_t start_addr;
+        /** Area size */
+        size_t size;
+        /** Area flags */
+        unsigned int flags;
+} as_area_info_t;
 #ifdef KERNEL
 …
 #include <arch/mm/as.h>
 #include <arch/mm/asid.h>
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/spinlock.h>
 #include <synch/mutex.h>
 …
  * Defined to be true if user address space and kernel address space shadow each
  * other.
+ */
+#define KERNEL_ADDRESS_SPACE_SHADOWED   KERNEL_ADDRESS_SPACE_SHADOWED_ARCH
+#define KERNEL_ADDRESS_SPACE_START      KERNEL_ADDRESS_SPACE_START_ARCH
+#define KERNEL_ADDRESS_SPACE_END        KERNEL_ADDRESS_SPACE_END_ARCH
+#define USER_ADDRESS_SPACE_START        USER_ADDRESS_SPACE_START_ARCH
+#define USER_ADDRESS_SPACE_END          USER_ADDRESS_SPACE_END_ARCH
+#define USTACK_ADDRESS                  USTACK_ADDRESS_ARCH
+ *
+ */
+#define KERNEL_ADDRESS_SPACE_SHADOWED  KERNEL_ADDRESS_SPACE_SHADOWED_ARCH
+#define KERNEL_ADDRESS_SPACE_START  KERNEL_ADDRESS_SPACE_START_ARCH
+#define KERNEL_ADDRESS_SPACE_END    KERNEL_ADDRESS_SPACE_END_ARCH
+#define USER_ADDRESS_SPACE_START    USER_ADDRESS_SPACE_START_ARCH
+#define USER_ADDRESS_SPACE_END      USER_ADDRESS_SPACE_END_ARCH
+#define USTACK_ADDRESS  USTACK_ADDRESS_ARCH
 /** Kernel address space. */
 #define FLAG_AS_KERNEL                  (1 << 0)
+#define FLAG_AS_KERNEL  (1 << 0)
 /* Address space area attributes. */
 #define AS_AREA_ATTR_NONE       0
 #define AS_AREA_ATTR_PARTIAL    1       /**< Not fully initialized area. */
+#define AS_AREA_ATTR_NONE     0
+#define AS_AREA_ATTR_PARTIAL  1  /**< Not fully initialized area. */
 /** The page fault was not resolved by as_page_fault(). */
+#define AS_PF_FAULT             0
+#define AS_PF_FAULT  0
 /** The page fault was resolved by as_page_fault(). */
+#define AS_PF_OK                1
+#define AS_PF_OK  1
 /** The page fault was caused by memcpy_from_uspace() or memcpy_to_uspace(). */
 #define AS_PF_DEFER             2
+#define AS_PF_DEFER  2
 /** Address space structure.
 …
  * supposed to figure in the list as they are shared by all tasks and
  * set up during system initialization.
+ *
  */
 typedef struct as {
         /** Protected by asidlock. */
         link_t inactive_as_with_asid_link;
         /**
+         * Number of processors on wich is this address space active.
+         * Protected by asidlock.
+         * Number of processors on which this
+         * address space is active. Protected by
+         * asidlock.
          */
         size_t cpu_refcount;
+        /**
+         * Address space identifier.
+         * Constant on architectures that do not support ASIDs.
+         * Protected by asidlock.
+        /** Address space identifier.
+         *
+         * Constant on architectures that do not
+         * support ASIDs. Protected by asidlock.
+         *
          */
         asid_t asid;
         /** Number of references (i.e tasks that reference this as). */
+        /** Number of references (i.e. tasks that reference this as). */
         atomic_t refcount;
         mutex_t lock;
         /** B+tree of address space areas. */
         btree_t as_area_btree;
 …
         /** Non-generic content. */
         as_genarch_t genarch;
         /** Architecture specific content. */
         as_arch_t arch;
 …
 typedef struct {
+        pte_t *(* page_table_create)(int flags);
+        void (* page_table_destroy)(pte_t *page_table);
+        void (* page_table_lock)(as_t *as, bool lock);
+        void (* page_table_unlock)(as_t *as, bool unlock);
+        pte_t *(* page_table_create)(unsigned int);
+        void (* page_table_destroy)(pte_t *);
+        void (* page_table_lock)(as_t *, bool);
+        void (* page_table_unlock)(as_t *, bool);
+        bool (* page_table_locked)(as_t *);
 } as_operations_t;
 …
  * This structure contains information associated with the shared address space
  * area.
+ *
  */
 typedef struct {
         /** This lock must be acquired only when the as_area lock is held. */
         mutex_t lock;
+        mutex_t lock;
         /** This structure can be deallocated if refcount drops to 0. */
         size_t refcount;
         /**
          * B+tree containing complete map of anonymous pages of the shared area.
 …
         PF_ACCESS_READ,
         PF_ACCESS_WRITE,
+        PF_ACCESS_EXEC
+        PF_ACCESS_EXEC,
+        PF_ACCESS_UNKNOWN
 } pf_access_t;
 …
 /** Backend data stored in address space area. */
 typedef union mem_backend_data {
+        struct {        /**< elf_backend members */
+        /** elf_backend members */
+        struct {
                 elf_header_t *elf;
                 elf_segment_header_t *segment;
         };
+        struct {        /**< phys_backend members */
+        /** phys_backend members */
+        struct {
                 uintptr_t base;
                 size_t frames;
 …
+ *
  * Each as_area_t structure describes one contiguous area of virtual memory.
+ *
  */
 typedef struct {
         mutex_t lock;
         /** Containing address space. */
+        as_t *as;
+        /**
+         * Flags related to the memory represented by the address space area.
+         */
+        int flags;
+        /** Attributes related to the address space area itself. */
+        int attributes;
+        /** Size of this area in multiples of PAGE_SIZE. */
+        as_t *as;
+        /** Memory flags. */
+        unsigned int flags;
+        /** Address space area attributes. */
+        unsigned int attributes;
+        /** Number of pages in the area. */
         size_t pages;
+        /** Number of resident pages in the area. */
+        size_t resident;
         /** Base address of this area. */
         uintptr_t base;
         /** Map of used space. */
         btree_t used_space;
         /**
          * If the address space area has been shared, this pointer will
          * reference the share info structure.
+         * If the address space area is shared. this is
+         * a reference to the share info structure.
          */
         share_info_t *sh_info;
         /** Memory backend backing this address space area. */
         struct mem_backend *backend;
         /** Data to be used by the backend. */
         mem_backend_data_t backend_data;
 …
 /** Address space area backend structure. */
 typedef struct mem_backend {
         int (* page_fault)(as_area_t *area, uintptr_t addr, pf_access_t access);
         void (* frame_free)(as_area_t *area, uintptr_t page, uintptr_t frame);
         void (* share)(as_area_t *area);
+        int (* page_fault)(as_area_t *, uintptr_t, pf_access_t);
+        void (* frame_free)(as_area_t *, uintptr_t, uintptr_t);
+        void (* share)(as_area_t *);
 } mem_backend_t;
 …
 extern void as_init(void);
 extern as_t *as_create(int flags);
 extern void as_destroy(as_t *as);
 extern void as_switch(as_t *old_as, as_t *new_as);
 extern int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate);
 extern as_area_t *as_area_create(as_t *as, int flags, size_t size,
+    uintptr_t base, int attrs, mem_backend_t *backend,
+    mem_backend_data_t *backend_data);
+extern int as_area_destroy(as_t *as, uintptr_t address);
 extern int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags);
+int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
+    as_t *dst_as, uintptr_t dst_base, int dst_flags_mask);
 extern int as_area_change_flags(as_t *as, int flags, uintptr_t address);
+extern int as_area_get_flags(as_area_t *area);
 extern bool as_area_check_access(as_area_t *area, pf_access_t access);
 extern size_t as_area_get_size(uintptr_t base);
 extern int used_space_insert(as_area_t *a, uintptr_t page, size_t count);
 extern int used_space_remove(as_area_t *a, uintptr_t page, size_t count);
+extern as_t *as_create(unsigned int);
+extern void as_destroy(as_t *);
+extern void as_hold(as_t *);
+extern void as_release(as_t *);
+extern void as_switch(as_t *, as_t *);
+extern int as_page_fault(uintptr_t, pf_access_t, istate_t *);
+extern as_area_t *as_area_create(as_t *, unsigned int, size_t, uintptr_t,
+    unsigned int, mem_backend_t *, mem_backend_data_t *);
+extern int as_area_destroy(as_t *, uintptr_t);
+extern int as_area_resize(as_t *, uintptr_t, size_t, unsigned int);
+extern int as_area_share(as_t *, uintptr_t, size_t, as_t *, uintptr_t,
+    unsigned int);
+extern int as_area_change_flags(as_t *, unsigned int, uintptr_t);
+extern unsigned int as_area_get_flags(as_area_t *);
+extern bool as_area_check_access(as_area_t *, pf_access_t);
+extern size_t as_area_get_size(uintptr_t);
+extern bool used_space_insert(as_area_t *, uintptr_t, size_t);
+extern bool used_space_remove(as_area_t *, uintptr_t, size_t);
 /* Interface to be implemented by architectures. */
 #ifndef as_constructor_arch
 extern int as_constructor_arch(as_t *as, int flags);
+extern int as_constructor_arch(as_t *, unsigned int);
 #endif /* !def as_constructor_arch */
 #ifndef as_destructor_arch
 extern int as_destructor_arch(as_t *as);
+extern int as_destructor_arch(as_t *);
 #endif /* !def as_destructor_arch */
 #ifndef as_create_arch
 extern int as_create_arch(as_t *as, int flags);
+extern int as_create_arch(as_t *, unsigned int);
 #endif /* !def as_create_arch */
 #ifndef as_install_arch
 extern void as_install_arch(as_t *as);
+extern void as_install_arch(as_t *);
 #endif /* !def as_install_arch */
 #ifndef as_deinstall_arch
 extern void as_deinstall_arch(as_t *as);
+extern void as_deinstall_arch(as_t *);
 #endif /* !def as_deinstall_arch */
 …
 extern mem_backend_t phys_backend;
 /**
+/**
  * This flags is passed when running the loader, otherwise elf_load()
  * would return with a EE_LOADER error code.
+ */
+#define ELD_F_NONE      0
+#define ELD_F_LOADER    1
+extern unsigned int elf_load(elf_header_t *header, as_t *as, int flags);
+ *
+ */
+#define ELD_F_NONE    0
+#define ELD_F_LOADER  1
+extern unsigned int elf_load(elf_header_t *, as_t *, unsigned int);
 /* Address space area related syscalls. */
+extern unative_t sys_as_area_create(uintptr_t address, size_t size, int flags);
+extern unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags);
+extern unative_t sys_as_area_change_flags(uintptr_t address, int flags);
+extern unative_t sys_as_area_destroy(uintptr_t address);
+extern sysarg_t sys_as_area_create(uintptr_t, size_t, unsigned int);
+extern sysarg_t sys_as_area_resize(uintptr_t, size_t, unsigned int);
+extern sysarg_t sys_as_area_change_flags(uintptr_t, unsigned int);
+extern sysarg_t sys_as_area_destroy(uintptr_t);
+extern sysarg_t sys_as_get_unmapped_area(uintptr_t, size_t);
 /* Introspection functions. */
+extern void as_print(as_t *as);
+extern void as_get_area_info(as_t *, as_area_info_t **, size_t *);
+extern void as_print(as_t *);
 #endif /* KERNEL */

kernel/generic/include/mm/buddy.h

rb50b5af2	r04803bf
36	36	#define KERN_BUDDY_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39	#include <adt/list.h>
40	40

kernel/generic/include/mm/frame.h

-              rb50b5af2
+              r04803bf
 #define KERN_FRAME_H_
+#include <arch/types.h>
+#include <typedefs.h>
+#include <trace.h>
 #include <adt/list.h>
 #include <mm/buddy.h>
 …
 typedef struct {
         size_t refcount;     /**< Tracking of shared frames */
+        size_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
 …
         pfn_t base;                    /**< Frame_no of the first frame
                                         in the frames array */
         size_t count;                 /**< Size of zone */
         size_t free_count;            /**< Number of free frame_t
+        size_t count;                  /**< Size of zone */
+        size_t free_count;             /**< Number of free frame_t
                                         structures */
         size_t busy_count;            /**< Number of busy frame_t
+        size_t busy_count;             /**< Number of busy frame_t
                                         structures */
         zone_flags_t flags;            /**< Type of the zone */
 …
  */
 typedef struct {
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         size_t count;
         zone_t info[ZONES_MAX];
 …
 extern zones_t zones;
 static inline uintptr_t PFN2ADDR(pfn_t frame)
+NO_TRACE static inline uintptr_t PFN2ADDR(pfn_t frame)
+{
         return (uintptr_t) (frame << FRAME_WIDTH);
+}
 static inline pfn_t ADDR2PFN(uintptr_t addr)
+NO_TRACE static inline pfn_t ADDR2PFN(uintptr_t addr)
+{
         return (pfn_t) (addr >> FRAME_WIDTH);
+}
 static inline size_t SIZE2FRAMES(size_t size)
+NO_TRACE static inline size_t SIZE2FRAMES(size_t size)
+{
         if (!size)
 …
+}
 static inline size_t FRAMES2SIZE(size_t frames)
+NO_TRACE static inline size_t FRAMES2SIZE(size_t frames)
+{
         return (size_t) (frames << FRAME_WIDTH);
+}
 static inline bool zone_flags_available(zone_flags_t flags)
+NO_TRACE 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)
+    ((~(((sysarg_t) -1) << (order)) & (index)) == 0)
 #define IS_BUDDY_LEFT_BLOCK(zone, frame) \
     (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x01) == 0)
 …
 extern void frame_set_parent(pfn_t, void *, size_t);
 extern void frame_mark_unavailable(pfn_t, size_t);
 extern uintptr_t zone_conf_size(size_t);
+extern size_t zone_conf_size(size_t);
 extern bool zone_merge(size_t, size_t);
 extern void zone_merge_all(void);
+extern uint64_t zone_total_size(void);
+extern uint64_t zones_total_size(void);
+extern void zones_stats(uint64_t *, uint64_t *, uint64_t *, uint64_t *);
 /*
  * Console functions
  */
 extern void zone_print_list(void);
+extern void zones_print_list(void);
 extern void zone_print_one(size_t);

kernel/generic/include/mm/page.h

-              rb50b5af2
+              r04803bf
 #define KERN_PAGE_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <mm/as.h>
 #include <memstr.h>
 …
 /** Operations to manipulate page mappings. */
 typedef struct {
+        void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame,
+            int flags);
+        void (* mapping_remove)(as_t *as, uintptr_t page);
+        pte_t *(* mapping_find)(as_t *as, uintptr_t page);
+        void (* mapping_insert)(as_t *, uintptr_t, uintptr_t, unsigned int);
+        void (* mapping_remove)(as_t *, uintptr_t);
+        pte_t *(* mapping_find)(as_t *, uintptr_t);
 } page_mapping_operations_t;
 …
 extern void page_init(void);
 extern void page_table_lock(as_t *as, bool lock);
 extern void page_table_unlock(as_t *as, bool unlock);
 extern void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame,
     int flags);
 extern void page_mapping_remove(as_t *as, uintptr_t page);
 extern pte_t *page_mapping_find(as_t *as, uintptr_t page);
 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 void page_table_lock(as_t *, bool);
+extern void page_table_unlock(as_t *, bool);
+extern bool page_table_locked(as_t *);
+extern void page_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
+extern void page_mapping_remove(as_t *, uintptr_t);
+extern pte_t *page_mapping_find(as_t *, uintptr_t);
+extern pte_t *page_table_create(unsigned int);
+extern void page_table_destroy(pte_t *);
+extern void map_structure(uintptr_t, size_t);
 extern uintptr_t hw_map(uintptr_t physaddr, size_t size);
+extern uintptr_t hw_map(uintptr_t, size_t);
 #endif

kernel/generic/include/mm/slab.h

-              rb50b5af2
+              r04803bf
 } slab_mag_cache_t;
 typedef struct {
         char *name;
+        const char *name;
         link_t link;
 …
         size_t size;
         int (*constructor)(void *obj, int kmflag);
         int (*destructor)(void *obj);
+        int (*constructor)(void *obj, unsigned int kmflag);
+        size_t (*destructor)(void *obj);
         /** Flags changing behaviour of cache */
         int flags;
+        unsigned 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 */
+        size_t objects;  /**< Number of objects that fit in */
         /* Statistics */
 …
         atomic_t cached_objs;
         /** How many magazines in magazines list */
         atomic_t magazine_counter;
+        atomic_t magazine_counter;
         /* Slabs */
 …
 } slab_cache_t;
 extern slab_cache_t *slab_cache_create(char *, size_t, size_t,
     int (*)(void *, int), int (*)(void *), int);
+extern slab_cache_t *slab_cache_create(const char *, size_t, size_t,
+    int (*)(void *, unsigned int), size_t (*)(void *), unsigned int);
 extern void slab_cache_destroy(slab_cache_t *);
+extern void * slab_alloc(slab_cache_t *, int);
+extern void *slab_alloc(slab_cache_t *, unsigned int)
+    __attribute__((malloc));
 extern void slab_free(slab_cache_t *, void *);
 extern size_t slab_reclaim(int);
+extern size_t slab_reclaim(unsigned int);
 /* slab subsytem initialization */
 …
 /* malloc support */
+extern void *malloc(unsigned int, int);
+extern void *realloc(void *, unsigned int, int);
+extern void *malloc(size_t, unsigned int)
+    __attribute__((malloc));
+extern void *realloc(void *, size_t, unsigned int);
 extern void free(void *);

kernel/generic/include/mm/tlb.h

-              rb50b5af2
+              r04803bf
 #include <arch/mm/asid.h>
 #include <arch/types.h>
+#include <typedefs.h>
 /**
 …
 #ifdef CONFIG_SMP
 extern void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid,
     uintptr_t page, size_t count);
 extern void tlb_shootdown_finalize(void);
+extern ipl_t tlb_shootdown_start(tlb_invalidate_type_t, asid_t, uintptr_t,
+    size_t);
+extern void tlb_shootdown_finalize(ipl_t);
 extern void tlb_shootdown_ipi_recv(void);
 #else
 #define tlb_shootdown_start(w, x, y, z)
 #define tlb_shootdown_finalize()
+#define tlb_shootdown_start(w, x, y, z) (0)
+#define tlb_shootdown_finalize(i)       ((i) = (i));
 #define tlb_shootdown_ipi_recv()
 #endif /* CONFIG_SMP */
 …
 extern void tlb_invalidate_all(void);
 extern void tlb_invalidate_asid(asid_t asid);
 extern void tlb_invalidate_pages(asid_t asid, uintptr_t page, size_t cnt);
+extern void tlb_invalidate_asid(asid_t);
+extern void tlb_invalidate_pages(asid_t, uintptr_t, size_t);
 #endif

kernel/generic/include/panic.h

-              rb50b5af2
+              r04803bf
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_PANIC_H_
+#ifdef CONFIG_DEBUG
+#       define panic(format, ...) \
+                panic_printf("Kernel panic in %s() at %s:%u: " format "\n", \
+                __func__, __FILE__, __LINE__, ##__VA_ARGS__);
+#else
+#       define panic(format, ...) \
+                panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__);
+#endif
+#include <typedefs.h>
+#include <print.h>
+extern void panic_printf(char *fmt, ...) __attribute__((noreturn));
+#define panic(fmt, ...) \
+        panic_common(PANIC_OTHER, NULL, 0, 0, fmt, ##__VA_ARGS__)
+#define panic_assert(fmt, ...) \
+        panic_common(PANIC_ASSERT, NULL, 0, 0, fmt, ##__VA_ARGS__)
+#define panic_badtrap(istate, n, fmt, ...) \
+        panic_common(PANIC_BADTRAP, istate, 0, n, fmt, ##__VA_ARGS__)
+#define panic_memtrap(istate, access, addr, fmt, ...) \
+        panic_common(PANIC_MEMTRAP, istate, access, addr, fmt, ##__VA_ARGS__)
+typedef enum {
+        PANIC_OTHER,
+        PANIC_ASSERT,
+        PANIC_BADTRAP,
+        PANIC_MEMTRAP
+} panic_category_t;
+struct istate;
+extern bool silent;
+extern void panic_common(panic_category_t, struct istate *, int,
+    uintptr_t, const char *, ...) __attribute__ ((noreturn))
+    PRINTF_ATTRIBUTE(5, 6);
 #endif

kernel/generic/include/preemption.h

rb50b5af2	r04803bf
27	27	*/
28	28
29		/** @addtogroup generic
	29	/** @addtogroup generic
30	30	* @{
31	31	*/

kernel/generic/include/print.h

-              rb50b5af2
+              r04803bf
 #define KERN_PRINT_H_
 #include <arch/types.h>
 #include <arch/arg.h>
+#include <typedefs.h>
+#include <stdarg.h>
+#define EOF (-1)
+#ifndef NVERIFY_PRINTF
+#define PRINTF_ATTRIBUTE(start, end) \
+        __attribute__((format(gnu_printf, start, end)))
+#else /* NVERIFY_PRINTF */
+#define PRINTF_ATTRIBUTE(start, end)
+#endif /* NVERIFY_PRINTF */
+#define EOF  (-1)
 extern int puts(const char *s);
+extern int printf(const char *fmt, ...);
+extern int snprintf(char *str, size_t size, const char *fmt, ...);
+extern int printf(const char *fmt, ...)
+    PRINTF_ATTRIBUTE(1, 2);
+extern int snprintf(char *str, size_t size, const char *fmt, ...)
+    PRINTF_ATTRIBUTE(3, 4);
 extern int vprintf(const char *fmt, va_list ap);

kernel/generic/include/printf/printf_core.h

-              rb50b5af2
+              r04803bf
 #include <typedefs.h>
 #include <arch/arg.h>
+#include <stdarg.h>
 /** Structure for specifying output methods for different printf clones. */
 …
 } printf_spec_t;
 int printf_core(const char *fmt, printf_spec_t *ps, va_list ap);
+extern int printf_core(const char *fmt, printf_spec_t *ps, va_list ap);
 #endif

kernel/generic/include/proc/program.h

-              rb50b5af2
+              r04803bf
 #define KERN_PROGRAM_H_
 #include <arch/types.h>
+#include <typedefs.h>
 struct task;
 …
  * A program is an abstraction of a freshly created (not yet running)
  * userspace task containing a main thread along with its userspace stack.
+ *
  */
 typedef struct program {
         struct task *task;              /**< Program task */
         struct thread *main_thread;     /**< Program main thread */
+        struct task *task;           /**< Program task */
+        struct thread *main_thread;  /**< Program main thread */
 } program_t;
 extern void *program_loader;
+extern void program_create(as_t *as, uintptr_t entry_addr, char *name,
+    program_t *p);
+extern int program_create_from_image(void *image_addr, char *name,
+    program_t *p);
+extern int program_create_loader(program_t *p, char *name);
+extern void program_ready(program_t *p);
+extern int program_create(as_t *, uintptr_t, char *, program_t *);
+extern int program_create_from_image(void *, char *, program_t *);
+extern int program_create_loader(program_t *, char *);
+extern void program_ready(program_t *);
 extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len);
+extern sysarg_t sys_program_spawn_loader(char *, size_t);
 #endif

kernel/generic/include/proc/scheduler.h

-              rb50b5af2
+              r04803bf
 #include <synch/spinlock.h>
+#include <time/clock.h>         /* HZ */
+#include <time/clock.h>
+#include <typedefs.h>
 #include <atomic.h>
 #include <adt/list.h>
 #define RQ_COUNT                16
 #define NEEDS_RELINK_MAX        (HZ)
+#define RQ_COUNT          16
+#define NEEDS_RELINK_MAX  (HZ)
 /** Scheduler run queue structure. */
 typedef struct {
         SPINLOCK_DECLARE(lock);
         link_t rq_head;         /**< List of ready threads. */
         size_t n;               /**< Number of threads in rq_ready. */
+        IRQ_SPINLOCK_DECLARE(lock);
+        link_t rq_head;              /**< List of ready threads. */
+        size_t n;                    /**< Number of threads in rq_ready. */
 } runq_t;
 …
 /*
  * To be defined by architectures:
+ * To be defined by architectures.
  */
 extern void before_task_runs_arch(void);

kernel/generic/include/proc/task.h

-              rb50b5af2
+              r04803bf
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2010 Jakub Jermar
  * All rights reserved.
+ *
 …
 #include <synch/spinlock.h>
 #include <synch/mutex.h>
-#include <synch/rwlock.h>
 #include <synch/futex.h>
 #include <adt/avl.h>
 …
 #include <udebug/udebug.h>
 #include <ipc/kbox.h>
 #define TASK_NAME_BUFLEN        20
+#include <mm/as.h>
+#include <sysinfo/abi.h>
 struct thread;
 …
          * threads.
          */
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         char name[TASK_NAME_BUFLEN];
         /** List of threads contained in this task. */
 …
         task_id_t taskid;
         /** Task security context. */
         context_id_t context;
+        context_id_t context;
         /** Number of references (i.e. threads). */
         atomic_t refcount;
         /** Number of threads that haven't exited yet. */
         atomic_t lifecount;
         /** Task capabilities. */
         cap_t capabilities;
+        cap_t capabilities;
         /* IPC stuff */
         answerbox_t answerbox;  /**< Communication endpoint */
         phone_t phones[IPC_MAX_PHONES];
+        /**
+         * Active asynchronous messages. It is used for limiting uspace to
+         * certain extent.
+         */
+        atomic_t active_calls;
+        stats_ipc_t ipc_info;   /**< IPC statistics */
+        /** List of synchronous answerboxes. */
+        link_t sync_box_head;
 #ifdef CONFIG_UDEBUG
         /** Debugging stuff. */
         udebug_task_t udebug;
         /** Kernel answerbox. */
         kbox_t kb;
 #endif
+#endif /* CONFIG_UDEBUG */
         /** Architecture specific task data. */
         task_arch_t arch;
 …
         mutex_t futexes_lock;
         /** B+tree of futexes referenced by this task. */
         btree_t futexes;
+        btree_t futexes;
         /** Accumulated accounting. */
+        uint64_t cycles;
+        uint64_t ucycles;
+        uint64_t kcycles;
 } task_t;
 SPINLOCK_EXTERN(tasks_lock);
+IRQ_SPINLOCK_EXTERN(tasks_lock);
 extern avltree_t tasks_tree;
 extern void task_init(void);
 extern void task_done(void);
+extern task_t *task_create(as_t *as, char *name);
+extern void task_destroy(task_t *t);
+extern task_t *task_find_by_id(task_id_t id);
+extern int task_kill(task_id_t id);
+extern uint64_t task_get_accounting(task_t *t);
+extern task_t *task_create(as_t *, const char *);
+extern void task_destroy(task_t *);
+extern void task_hold(task_t *);
+extern void task_release(task_t *);
+extern task_t *task_find_by_id(task_id_t);
+extern int task_kill(task_id_t);
+extern void task_kill_self(bool) __attribute__((noreturn));
+extern void task_get_accounting(task_t *, uint64_t *, uint64_t *);
+extern void task_print_list(bool);
 extern void cap_set(task_t *t, cap_t caps);
 extern cap_t cap_get(task_t *t);
+extern void cap_set(task_t *, cap_t);
+extern cap_t cap_get(task_t *);
 #ifndef task_create_arch
 extern void task_create_arch(task_t *t);
+extern void task_create_arch(task_t *);
 #endif
 #ifndef task_destroy_arch
 extern void task_destroy_arch(task_t *t);
+extern void task_destroy_arch(task_t *);
 #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);
+#ifdef __32_BITS__
+extern sysarg_t sys_task_get_id(sysarg64_t *);
+#endif
+#ifdef __64_BITS__
+extern sysarg_t sys_task_get_id(void);
+#endif
+extern sysarg_t sys_task_set_name(const char *, size_t);
+extern sysarg_t sys_task_kill(task_id_t *);
+extern sysarg_t sys_task_exit(sysarg_t);
 #endif

kernel/generic/include/proc/thread.h

-              rb50b5af2
+              r04803bf
 #include <time/timeout.h>
 #include <cpu.h>
-#include <synch/rwlock.h>
 #include <synch/spinlock.h>
 #include <adt/avl.h>
 …
 #include <proc/uarg.h>
 #include <udebug/udebug.h>
+#define THREAD_STACK_SIZE       STACK_SIZE
+#define THREAD_NAME_BUFLEN      20
+extern char *thread_states[];
+#include <sysinfo/abi.h>
+#define THREAD_STACK_SIZE   STACK_SIZE
+#define THREAD_NAME_BUFLEN  20
+extern const char *thread_states[];
 /* Thread flags */
 …
  * When using this flag, the caller must set cpu in the thread_t
  * structure manually before calling thread_ready (even on uniprocessor).
+ */
+#define THREAD_FLAG_WIRED       (1 << 0)
+ *
+ */
+#define THREAD_FLAG_WIRED  (1 << 0)
 /** Thread was migrated to another CPU and has not run yet. */
+#define THREAD_FLAG_STOLEN      (1 << 1)
+#define THREAD_FLAG_STOLEN  (1 << 1)
 /** Thread executes in userspace. */
+#define THREAD_FLAG_USPACE      (1 << 2)
+#define THREAD_FLAG_USPACE  (1 << 2)
 /** Thread will be attached by the caller. */
+#define THREAD_FLAG_NOATTACH    (1 << 3)
+/** Thread states. */
+typedef enum {
+        /** It is an error, if thread is found in this state. */
+        Invalid,
+        /** State of a thread that is currently executing on some CPU. */
+        Running,
+        /** Thread in this state is waiting for an event. */
+        Sleeping,
+        /** State of threads in a run queue. */
+        Ready,
+        /** Threads are in this state before they are first readied. */
+        Entering,
+        /** After a thread calls thread_exit(), it is put into Exiting state. */
+        Exiting,
+        /** Threads that were not detached but exited are Lingering. */
+        Lingering
+} state_t;
+#define THREAD_FLAG_NOATTACH  (1 << 3)
 /** Thread structure. There is one per thread. */
 typedef struct thread {
         link_t rq_link;         /**< Run queue link. */
         link_t wq_link;         /**< Wait queue link. */
         link_t th_link;         /**< Links to threads within containing task. */
+        link_t rq_link;  /**< Run queue link. */
+        link_t wq_link;  /**< Wait queue link. */
+        link_t th_link;  /**< Links to threads within containing task. */
         /** Threads linkage to the threads_tree. */
         avltree_node_t threads_tree_node;
 …
          * Protects the whole thread structure except list links above.
          */
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         char name[THREAD_NAME_BUFLEN];
         /** Function implementing the thread. */
         void (* thread_code)(void *);
+        void (*thread_code)(void *);
         /** Argument passed to thread_code() function. */
         void *thread_arg;
         /**
          * From here, the stored context is restored when the thread is
          * scheduled.
+        /**
+         * From here, the stored context is restored
+         * when the thread is scheduled.
          */
         context_t saved_context;
+        /**
+         * From here, the stored timeout context is restored when sleep times
+         * out.
+        /**
+         * From here, the stored timeout context
+         * is restored when sleep times out.
          */
         context_t sleep_timeout_context;
+        /**
+         * From here, the stored interruption context is restored when sleep is
+         * interrupted.
+        /**
+         * From here, the stored interruption context
+         * is restored when sleep is interrupted.
          */
         context_t sleep_interruption_context;
         /** If true, the thread can be interrupted from sleep. */
         bool sleep_interruptible;
 …
         timeout_t sleep_timeout;
         /** Flag signalling sleep timeout in progress. */
         volatile int timeout_pending;
+        volatile bool timeout_pending;
         /**
          * True if this thread is executing copy_from_uspace().
 …
          */
         bool in_copy_from_uspace;
         /**
          * True if this thread is executing copy_to_uspace().
 …
          * thread_exit() before returning to userspace.
          */
         bool interrupted;
+        bool interrupted;
         /** If true, thread_join_timeout() cannot be used on this thread. */
 …
         /** Link used in the joiner_head list. */
         link_t joiner_link;
         fpu_context_t *saved_fpu_context;
         int fpu_context_exists;
         /*
          * Defined only if thread doesn't run.
 …
          */
         int fpu_context_engaged;
+        rwlock_type_t rwlock_holder_type;
+        /** Callback fired in scheduler before the thread is put asleep. */
+        void (* call_me)(void *);
+        /** Argument passed to call_me(). */
+        void *call_me_with;
         /** Thread's state. */
         state_t state;
         /** Thread's flags. */
         int flags;
+        unsigned int flags;
         /** Thread's CPU. */
 …
         /** Containing task. */
         task_t *task;
         /** Ticks before preemption. */
         uint64_t ticks;
         /** Thread accounting. */
+        uint64_t cycles;
+        uint64_t ucycles;
+        uint64_t kcycles;
         /** Last sampled cycle. */
         uint64_t last_cycle;
         /** Thread doesn't affect accumulated accounting. */
+        /** Thread doesn't affect accumulated accounting. */
         bool uncounted;
         /** Thread's priority. Implemented as index to CPU->rq */
         int priority;
 …
         /** Architecture-specific data. */
         thread_arch_t arch;
         /** Thread's kernel stack. */
         uint8_t *kstack;
 #ifdef CONFIG_UDEBUG
+        /**
+         * If true, the scheduler will print a stack trace
+         * to the kernel console upon scheduling this thread.
+         */
+        bool btrace;
         /** Debugging stuff */
         udebug_thread_t udebug;
+#endif
+#endif /* CONFIG_UDEBUG */
 } thread_t;
 …
+ *
  */
 SPINLOCK_EXTERN(threads_lock);
+IRQ_SPINLOCK_EXTERN(threads_lock);
 /** AVL tree containing all threads. */
 …
 extern void thread_init(void);
 extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task,
     int flags, char *name, bool uncounted);
 extern void thread_attach(thread_t *t, task_t *task);
 extern void thread_ready(thread_t *t);
+extern thread_t *thread_create(void (*)(void *), void *, task_t *,
+    unsigned int, const char *, bool);
+extern void thread_attach(thread_t *, task_t *);
+extern void thread_ready(thread_t *);
 extern void thread_exit(void) __attribute__((noreturn));
 #ifndef thread_create_arch
+extern void thread_create_arch(thread_t *t);
+#endif
+extern void thread_create_arch(thread_t *);
+#endif
 #ifndef thr_constructor_arch
+extern void thr_constructor_arch(thread_t *t);
+#endif
+extern void thr_constructor_arch(thread_t *);
+#endif
 #ifndef thr_destructor_arch
 extern void thr_destructor_arch(thread_t *t);
 #endif
 extern void thread_sleep(uint32_t sec);
 extern void thread_usleep(uint32_t usec);
+extern void thr_destructor_arch(thread_t *);
+#endif
+extern void thread_sleep(uint32_t);
+extern void thread_usleep(uint32_t);
 #define thread_join(t) \
         thread_join_timeout((t), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
+extern int thread_join_timeout(thread_t *t, uint32_t usec, int flags);
+extern void thread_detach(thread_t *t);
+extern void thread_register_call_me(void (* call_me)(void *),
+    void *call_me_with);
+extern void thread_print_list(void);
+extern void thread_destroy(thread_t *t);
+extern void thread_update_accounting(void);
+extern bool thread_exists(thread_t *t);
+extern int thread_join_timeout(thread_t *, uint32_t, unsigned int);
+extern void thread_detach(thread_t *);
+extern void thread_print_list(bool);
+extern void thread_destroy(thread_t *, bool);
+extern thread_t *thread_find_by_id(thread_id_t);
+extern void thread_update_accounting(bool);
+extern bool thread_exists(thread_t *);
+#ifdef CONFIG_UDEBUG
+extern void thread_stack_trace(thread_id_t);
+#endif
 /** Fpu context slab cache. */
 …
 /* Thread syscall prototypes. */
+extern unative_t sys_thread_create(uspace_arg_t *uspace_uarg,
+    char *uspace_name, size_t name_len, thread_id_t *uspace_thread_id);
+extern unative_t sys_thread_exit(int uspace_status);
+extern unative_t sys_thread_get_id(thread_id_t *uspace_thread_id);
+extern sysarg_t sys_thread_create(uspace_arg_t *, char *, size_t,
+    thread_id_t *);
+extern sysarg_t sys_thread_exit(int);
+extern sysarg_t sys_thread_get_id(thread_id_t *);
+extern sysarg_t sys_thread_usleep(uint32_t);
 #endif

kernel/generic/include/security/cap.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 /**
  * @file
  * @brief       Capabilities definitions.
+ * @brief Capabilities definitions.
+ *
  * Capabilities represent virtual rights that entitle their
 …
 #define __CAP_H__
+#include <syscall/sysarg64.h>
+#include <arch/types.h>
+#include <typedefs.h>
 /**
 …
  * privilege to/from other tasks.
  */
 #define CAP_CAP                 (1<<0)
+#define CAP_CAP  (1 << 0)
 /**
 …
  * to other tasks.
  */
 #define CAP_MEM_MANAGER         (1<<1)
+#define CAP_MEM_MANAGER  (1 << 1)
 /**
 …
  * to other tasks.
  */
+#define CAP_IO_MANAGER          (1<<2)
+/**
+ * CAP_PREEMPT_CONTROL allows its holder to disable/enable preemption.
+ */
+#define CAP_PREEMPT_CONTROL     (1<<3)
+#define CAP_IO_MANAGER  (1 << 2)
 /**
  * CAP_IRQ_REG entitles its holder to register IRQ handlers.
  */
 #define CAP_IRQ_REG             (1<<4)
+#define CAP_IRQ_REG  (1 << 3)
 typedef uint32_t cap_t;
+extern unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps);
+extern unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps);
+#ifdef __32_BITS__
+extern sysarg_t sys_cap_grant(sysarg64_t *, cap_t);
+extern sysarg_t sys_cap_revoke(sysarg64_t *, cap_t);
+#endif  /* __32_BITS__ */
+#ifdef __64_BITS__
+extern sysarg_t sys_cap_grant(sysarg_t, cap_t);
+extern sysarg_t sys_cap_revoke(sysarg_t, cap_t);
+#endif  /* __64_BITS__ */
 #endif

kernel/generic/include/smp/ipi.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #ifdef CONFIG_SMP
+extern void ipi_broadcast(int ipi);
+extern void ipi_broadcast_arch(int ipi);
+extern void ipi_broadcast(int);
+extern void ipi_broadcast_arch(int);
 #else
+#define ipi_broadcast(x)        ;
+#define ipi_broadcast(ipi)
 #endif /* CONFIG_SMP */

kernel/generic/include/smp/smp.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #ifdef CONFIG_SMP
 extern void smp_init(void);
 extern void kmp(void *arg);
+#else
+#else /* CONFIG_SMP */
 #define smp_init()
 #endif /* CONFIG_SMP */

kernel/generic/include/sort.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_SORT_H_
 #include <arch/types.h>
+#include <typedefs.h>
+/*
+ * sorting routines
+ */
+extern void bubblesort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b));
+extern void qsort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b));
+typedef int (* sort_cmp_t)(void *, void *, void *);
+/*
+ * default sorting comparators
+ */
+extern int int_cmp(void * a, void * b);
+extern int uint32_t_cmp(void * a, void * b);
+extern int uint16_t_cmp(void * a, void * b);
+extern int uint8_t_cmp(void * a, void * b);
+extern bool gsort(void *, size_t, size_t, sort_cmp_t, void *);
+extern bool qsort(void *, size_t, size_t, sort_cmp_t, void *);
 #endif

kernel/generic/include/stdarg.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
  * for all architectures with compiler support for __builtin_va_*.
  */
 #ifndef KERN_STDARG_H_
 #define KERN_STDARG_H_
 …
 typedef __builtin_va_list va_list;
 #define va_start(ap, last)              __builtin_va_start(ap, last)
 #define va_arg(ap, type)                __builtin_va_arg(ap, type)
 #define va_end(ap)                      __builtin_va_end(ap)
 #define va_copy(dst, src)               __builtin_va_copy(dst, src)
+#define va_start(ap, last)  __builtin_va_start(ap, last)
+#define va_arg(ap, type)    __builtin_va_arg(ap, type)
+#define va_end(ap)          __builtin_va_end(ap)
+#define va_copy(dst, src)   __builtin_va_copy(dst, src)
 #endif

kernel/generic/include/str.h

-              rb50b5af2
+              r04803bf
  */
 #ifndef KERN_STRING_H_
 #define KERN_STRING_H_
+#ifndef KERN_STR_H_
+#define KERN_STR_H_
 #include <typedefs.h>
 …
 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 void wstr_to_str(char *dest, size_t size, const wchar_t *src);
+extern char *str_dup(const char *src);
+extern char *str_ndup(const char *src, size_t n);
 extern char *str_chr(const char *str, wchar_t ch);
 …
 extern bool wstr_remove(wchar_t *str, size_t pos);
+extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
+extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
 #endif

kernel/generic/include/symtab.h

-              rb50b5af2
+              r04803bf
 #define KERN_SYMTAB_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #define MAX_SYMBOL_NAME 64
+#define MAX_SYMBOL_NAME  64
 struct symtab_entry {
 …
 };
 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 *input, size_t size);
+extern int symtab_name_lookup(uintptr_t, const char **, uintptr_t *);
+extern const char *symtab_fmt_name_lookup(uintptr_t);
+extern int symtab_addr_lookup(const char *, uintptr_t *);
+extern void symtab_print_search(const char *);
+extern int symtab_compl(char *, size_t);
 #ifdef CONFIG_SYMTAB
+/* Symtable linked together by build process */
+/** Symtable linked together by build process
+ *
+ */
 extern struct symtab_entry symbol_table[];
 #endif
+#endif /* CONFIG_SYMTAB */
 #endif

kernel/generic/include/synch/condvar.h

rb50b5af2	r04803bf
36	36	#define KERN_CONDVAR_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39	#include <synch/waitq.h>
40	40	#include <synch/mutex.h>

kernel/generic/include/synch/futex.h

-              rb50b5af2
+              r04803bf
 #define KERN_FUTEX_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/waitq.h>
-#include <genarch/mm/page_ht.h>
-#include <genarch/mm/page_pt.h>
 /** Kernel-side futex structure. */
 …
 extern void futex_init(void);
+extern unative_t sys_futex_sleep_timeout(uintptr_t uaddr, uint32_t usec,
+    int flags);
+extern unative_t sys_futex_wakeup(uintptr_t uaddr);
+extern sysarg_t sys_futex_sleep(uintptr_t);
+extern sysarg_t sys_futex_wakeup(uintptr_t);
 extern void futex_cleanup(void);

kernel/generic/include/synch/mutex.h

-              rb50b5af2
+              r04803bf
 #define KERN_MUTEX_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/semaphore.h>
 #include <synch/synch.h>
 …
 } mutex_t;
 #define mutex_lock(mtx)                 \
+#define mutex_lock(mtx) \
         _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
+#define mutex_trylock(mtx)              \
+#define mutex_trylock(mtx) \
         _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
+#define mutex_lock_timeout(mtx, usec)   \
+#define mutex_lock_timeout(mtx, usec) \
         _mutex_lock_timeout((mtx), (usec), SYNCH_FLAGS_NON_BLOCKING)
 extern void mutex_initialize(mutex_t *, mutex_type_t);
+extern int _mutex_lock_timeout(mutex_t *, uint32_t, int);
+extern bool mutex_locked(mutex_t *);
+extern int _mutex_lock_timeout(mutex_t *, uint32_t, unsigned int);
 extern void mutex_unlock(mutex_t *);

kernel/generic/include/synch/semaphore.h

-              rb50b5af2
+              r04803bf
 #define KERN_SEMAPHORE_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/waitq.h>
 #include <synch/synch.h>
 …
 #define semaphore_down(s) \
         _semaphore_down_timeout((s), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
 #define semaphore_trydown(s) \
         _semaphore_down_timeout((s), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING)
 #define semaphore_down_timeout(s, usec) \
         _semaphore_down_timeout((s), (usec), SYNCH_FLAGS_NONE)
+extern void semaphore_initialize(semaphore_t *s, int val);
+extern int _semaphore_down_timeout(semaphore_t *s, uint32_t usec, int flags);
+extern void semaphore_up(semaphore_t *s);
+extern void semaphore_initialize(semaphore_t *, int);
+extern int _semaphore_down_timeout(semaphore_t *, uint32_t, unsigned int);
+extern void semaphore_up(semaphore_t *);
+extern int semaphore_count_get(semaphore_t *);
 #endif

kernel/generic/include/synch/smc.h

rb50b5af2	r04803bf
36	36	#define KERN_SMC_H_
37	37
38		extern ~~unative~~_t sys_smc_coherence(uintptr_t va, size_t size);
	38	extern sysarg_t sys_smc_coherence(uintptr_t va, size_t size);
39	39
40	40	#endif

kernel/generic/include/synch/spinlock.h

-              rb50b5af2
+              r04803bf
 #define KERN_SPINLOCK_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <arch/barrier.h>
 #include <preemption.h>
 #include <atomic.h>
 #include <debug.h>
+#include <arch/asm.h>
 #ifdef CONFIG_SMP
 …
 #ifdef CONFIG_DEBUG_SPINLOCK
         char *name;
 #endif
+        const char *name;
+#endif /* CONFIG_DEBUG_SPINLOCK */
 } spinlock_t;
 …
 /*
+ * SPINLOCK_INITIALIZE is to be used for statically allocated spinlocks.
+ * It declares and initializes the lock.
+ * SPINLOCK_INITIALIZE and SPINLOCK_STATIC_INITIALIZE are to be used
+ * for statically allocated spinlocks. They declare (either as global
+ * or static) symbol and initialize the lock.
  */
 #ifdef CONFIG_DEBUG_SPINLOCK
 …
+        }
+#define spinlock_lock(lock)  spinlock_lock_debug(lock)
+#else
+#define ASSERT_SPINLOCK(expr, lock) \
+        ASSERT_VERBOSE(expr, (lock)->name)
+#define spinlock_lock(lock)    spinlock_lock_debug((lock))
+#define spinlock_unlock(lock)  spinlock_unlock_debug((lock))
+#else /* CONFIG_DEBUG_SPINLOCK */
 #define SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \
 …
+        }
+#define spinlock_lock(lock)  atomic_lock_arch(&(lock)->val)
+#endif
+#define ASSERT_SPINLOCK(expr, lock) \
+        ASSERT(expr)
+#define spinlock_lock(lock)    atomic_lock_arch(&(lock)->val)
+#define spinlock_unlock(lock)  spinlock_unlock_nondebug((lock))
+#endif /* CONFIG_DEBUG_SPINLOCK */
 #define SPINLOCK_INITIALIZE(lock_name) \
 …
         SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, #lock_name)
+extern void spinlock_initialize(spinlock_t *lock, char *name);
+extern int spinlock_trylock(spinlock_t *lock);
+extern void spinlock_lock_debug(spinlock_t *lock);
+extern void spinlock_initialize(spinlock_t *, const char *);
+extern int spinlock_trylock(spinlock_t *);
+extern void spinlock_lock_debug(spinlock_t *);
+extern void spinlock_unlock_debug(spinlock_t *);
+extern bool spinlock_locked(spinlock_t *);
 /** Unlock spinlock
+ *
  * Unlock spinlock.
+ * Unlock spinlock for non-debug kernels.
+ *
  * @param sl Pointer to spinlock_t structure.
+ */
+static inline void spinlock_unlock(spinlock_t *lock)
+ *
+ */
+NO_TRACE static inline void spinlock_unlock_nondebug(spinlock_t *lock)
+{
-        ASSERT(atomic_get(&lock->val) != 0);
         /*
          * Prevent critical section code from bleeding out this way down.
 …
         if ((pname)++ > (value)) { \
                 (pname) = 0; \
                 printf("Deadlock probe %s: exceeded threshold %u\n", \
+                printf("Deadlock probe %s: exceeded threshold %u\n" \
                     "cpu%u: function=%s, line=%u\n", \
                     #pname, (value), CPU->id, __func__, __LINE__); \
+        }
 #else
+#else /* CONFIG_DEBUG_SPINLOCK */
 #define DEADLOCK_PROBE_INIT(pname)
 #define DEADLOCK_PROBE(pname, value)
 #endif
+#endif /* CONFIG_DEBUG_SPINLOCK */
 #else /* CONFIG_SMP */
 …
 #define SPINLOCK_INITIALIZE_NAME(name, desc_name)
 #define SPINLOCK_STATIC_INITIALIZE_NAME(name, desc_name)
+#define ASSERT_SPINLOCK(expr, lock)  ASSERT(expr)
 #define spinlock_initialize(lock, name)
 …
 #define spinlock_trylock(lock)  (preemption_disable(), 1)
 #define spinlock_unlock(lock)   preemption_enable()
+#define spinlock_locked(lock)   1
+#define spinlock_unlocked(lock) 1
 #define DEADLOCK_PROBE_INIT(pname)
 #define DEADLOCK_PROBE(pname, value)
+#endif /* CONFIG_SMP */
+typedef struct {
+        SPINLOCK_DECLARE(lock);  /**< Spinlock */
+        bool guard;              /**< Flag whether ipl is valid */
+        ipl_t ipl;               /**< Original interrupt level */
+} irq_spinlock_t;
+#define IRQ_SPINLOCK_DECLARE(lock_name)  irq_spinlock_t lock_name
+#define IRQ_SPINLOCK_EXTERN(lock_name)   extern irq_spinlock_t lock_name
+#ifdef CONFIG_SMP
+#define ASSERT_IRQ_SPINLOCK(expr, irq_lock) \
+        ASSERT_SPINLOCK(expr, &((irq_lock)->lock))
+/*
+ * IRQ_SPINLOCK_INITIALIZE and IRQ_SPINLOCK_STATIC_INITIALIZE are to be used
+ * for statically allocated interrupts-disabled spinlocks. They declare (either
+ * as global or static symbol) and initialize the lock.
+ */
+#ifdef CONFIG_DEBUG_SPINLOCK
+#define IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \
+        irq_spinlock_t lock_name = { \
+                .lock = { \
+                        .name = desc_name, \
+                        .val = { 0 } \
+                }, \
+                .guard = false, \
+                .ipl = 0 \
+        }
+#define IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \
+        static irq_spinlock_t lock_name = { \
+                .lock = { \
+                        .name = desc_name, \
+                        .val = { 0 } \
+                }, \
+                .guard = false, \
+                .ipl = 0 \
+        }
+#else /* CONFIG_DEBUG_SPINLOCK */
+#define IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \
+        irq_spinlock_t lock_name = { \
+                .lock = { \
+                        .val = { 0 } \
+                }, \
+                .guard = false, \
+                .ipl = 0 \
+        }
+#define IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \
+        static irq_spinlock_t lock_name = { \
+                .lock = { \
+                        .val = { 0 } \
+                }, \
+                .guard = false, \
+                .ipl = 0 \
+        }
+#endif /* CONFIG_DEBUG_SPINLOCK */
+#else /* CONFIG_SMP */
+/*
+ * Since the spinlocks are void on UP systems, we also need
+ * to have a special variant of interrupts-disabled spinlock
+ * macros which take this into account.
+ */
+#define ASSERT_IRQ_SPINLOCK(expr, irq_lock) \
+        ASSERT_SPINLOCK(expr, NULL)
+#define IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, desc_name) \
+        irq_spinlock_t lock_name = { \
+                .guard = false, \
+                .ipl = 0 \
+        }
+#define IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, desc_name) \
+        static irq_spinlock_t lock_name = { \
+                .guard = false, \
+                .ipl = 0 \
+        }
+#endif /* CONFIG_SMP */
+#define IRQ_SPINLOCK_INITIALIZE(lock_name) \
+        IRQ_SPINLOCK_INITIALIZE_NAME(lock_name, #lock_name)
+#define IRQ_SPINLOCK_STATIC_INITIALIZE(lock_name) \
+        IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(lock_name, #lock_name)
+extern void irq_spinlock_initialize(irq_spinlock_t *, const char *);
+extern void irq_spinlock_lock(irq_spinlock_t *, bool);
+extern void irq_spinlock_unlock(irq_spinlock_t *, bool);
+extern int irq_spinlock_trylock(irq_spinlock_t *);
+extern void irq_spinlock_pass(irq_spinlock_t *, irq_spinlock_t *);
+extern void irq_spinlock_exchange(irq_spinlock_t *, irq_spinlock_t *);
+extern bool irq_spinlock_locked(irq_spinlock_t *);
 #endif
-#endif
 /** @}
  */

kernel/generic/include/synch/waitq.h

-              rb50b5af2
+              r04803bf
 #define KERN_WAITQ_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <synch/spinlock.h>
 #include <synch/synch.h>
 …
 } wakeup_mode_t;
+/** Wait queue structure. */
+/** Wait queue structure.
+ *
+ */
 typedef struct {
         /** Lock protecting wait queue structure.
+         *
          * Must be acquired before T.lock for each T of type thread_t.
          */
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         /**
          * Number of waitq_wakeup() calls that didn't find a thread to wake up.
+         *
          */
         int missed_wakeups;
         /** List of sleeping threads for wich there was no missed_wakeup. */
         link_t head;
 …
 extern void waitq_initialize(waitq_t *);
 extern int waitq_sleep_timeout(waitq_t *, uint32_t, int);
+extern int waitq_sleep_timeout(waitq_t *, uint32_t, unsigned int);
 extern ipl_t waitq_sleep_prepare(waitq_t *);
 extern int waitq_sleep_timeout_unsafe(waitq_t *, uint32_t, int);
+extern int waitq_sleep_timeout_unsafe(waitq_t *, uint32_t, unsigned int);
 extern void waitq_sleep_finish(waitq_t *, int, ipl_t);
 extern void waitq_wakeup(waitq_t *, wakeup_mode_t);
 …
 extern void waitq_interrupt_sleep(struct thread *);
 extern void waitq_unsleep(waitq_t *);
+extern int waitq_count_get(waitq_t *);
+extern void waitq_count_set(waitq_t *, int val);
 #endif

kernel/generic/include/syscall/copy.h

rb50b5af2	r04803bf
36	36	#define KERN_COPY_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39
40	40	/** Label within memcpy_from_uspace() that contains return -1. */

kernel/generic/include/syscall/syscall.h

-              rb50b5af2
+              r04803bf
 typedef enum {
         SYS_KLOG = 0,
         SYS_TLS_SET = 1, /* Hardcoded in AMD64, IA32 uspace - fibril.S */
+        SYS_TLS_SET = 1,  /* Hardcoded for AMD64, IA-32 (fibril.S in uspace) */
         SYS_THREAD_CREATE,
         SYS_THREAD_EXIT,
         SYS_THREAD_GET_ID,
+        SYS_THREAD_USLEEP,
         SYS_TASK_GET_ID,
         SYS_TASK_SET_NAME,
+        SYS_TASK_KILL,
+        SYS_TASK_EXIT,
         SYS_PROGRAM_SPAWN_LOADER,
 …
         SYS_AS_AREA_CHANGE_FLAGS,
         SYS_AS_AREA_DESTROY,
+        SYS_AS_GET_UNMAPPED_AREA,
         SYS_IPC_CALL_SYNC_FAST,
 …
         SYS_IPC_POKE,
         SYS_IPC_HANGUP,
+        SYS_IPC_REGISTER_IRQ,
+        SYS_IPC_UNREGISTER_IRQ,
+        SYS_IPC_CONNECT_KBOX,
         SYS_EVENT_SUBSCRIBE,
 …
         SYS_PHYSMEM_MAP,
         SYS_IOSPACE_ENABLE,
+        SYS_PREEMPT_CONTROL,
+        SYS_REGISTER_IRQ,
+        SYS_UNREGISTER_IRQ,
+        SYS_SYSINFO_VALID,
+        SYS_SYSINFO_VALUE,
+        SYS_SYSINFO_GET_TAG,
+        SYS_SYSINFO_GET_VALUE,
+        SYS_SYSINFO_GET_DATA_SIZE,
+        SYS_SYSINFO_GET_DATA,
         SYS_DEBUG_PUTINT,
         SYS_DEBUG_ENABLE_CONSOLE,
         SYS_DEBUG_DISABLE_CONSOLE,
         SYS_IPC_CONNECT_KBOX,
         SYSCALL_END
 } syscall_t;
 …
 #ifdef KERNEL
 #include <arch/types.h>
+#include <typedefs.h>
 typedef unative_t (*syshandler_t)(unative_t, unative_t, unative_t, unative_t,
     unative_t, unative_t);
+typedef sysarg_t (*syshandler_t)(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t);
 extern syshandler_t syscall_table[SYSCALL_END];
 extern unative_t syscall_handler(unative_t, unative_t, unative_t, unative_t,
     unative_t, unative_t, unative_t);
 extern unative_t sys_tls_set(unative_t);
+extern sysarg_t syscall_handler(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t);
+extern sysarg_t sys_tls_set(sysarg_t);
 #endif

kernel/generic/include/sysinfo/sysinfo.h

-              rb50b5af2
+              r04803bf
 #define KERN_SYSINFO_H_
 #include <arch/types.h>
 #include <string.h>
+#include <typedefs.h>
+#include <str.h>
+/** Framebuffer info exported flags */
 extern bool fb_exported;
+typedef union sysinfo_item_val {
+        unative_t val;
+        void *fn;
+/** Item value type
+ *
+ */
+typedef enum {
+        SYSINFO_VAL_UNDEFINED = 0,     /**< Undefined value */
+        SYSINFO_VAL_VAL = 1,           /**< Constant numeric value */
+        SYSINFO_VAL_DATA = 2,          /**< Constant binary data */
+        SYSINFO_VAL_FUNCTION_VAL = 3,  /**< Generated numeric value */
+        SYSINFO_VAL_FUNCTION_DATA = 4  /**< Generated binary data */
+} sysinfo_item_val_type_t;
+/** Subtree type
+ *
+ */
+typedef enum {
+        SYSINFO_SUBTREE_NONE = 0,     /**< No subtree (leaf item) */
+        SYSINFO_SUBTREE_TABLE = 1,    /**< Fixed subtree */
+        SYSINFO_SUBTREE_FUNCTION = 2  /**< Generated subtree */
+} sysinfo_subtree_type_t;
+struct sysinfo_item;
+/** Gerated numeric value function */
+typedef sysarg_t (*sysinfo_fn_val_t)(struct sysinfo_item *);
+/** Generated binary data function */
+typedef void *(*sysinfo_fn_data_t)(struct sysinfo_item *, size_t *, bool);
+/** Sysinfo item binary data
+ *
+ */
+typedef struct {
+        void *data;   /**< Data */
+        size_t size;  /**< Size (bytes) */
+} sysinfo_data_t;
+/** Sysinfo item value (union)
+ *
+ */
+typedef union {
+        sysarg_t val;               /**< Constant numberic value */
+        sysinfo_fn_val_t fn_val;    /**< Generated numeric value function */
+        sysinfo_fn_data_t fn_data;  /**< Generated binary data function */
+        sysinfo_data_t data;        /**< Constant binary data */
 } sysinfo_item_val_t;
+/** Sysinfo return holder
+ *
+ * This structure is generated from the constant
+ * items or by the generating functions. Note that
+ * the validity of the data is limited by the scope
+ * of single sysinfo invocation guarded by sysinfo_lock.
+ *
+ */
+typedef struct {
+        sysinfo_item_val_type_t tag;  /**< Return value type */
+        union {
+                sysarg_t val;             /**< Numberic value */
+                sysinfo_data_t data;      /**< Binary data */
+        };
+} sysinfo_return_t;
+/** Generated subtree function */
+typedef sysinfo_return_t (*sysinfo_fn_subtree_t)(const char *, bool);
+/** Sysinfo subtree (union)
+ *
+ */
+typedef union {
+        struct sysinfo_item *table;     /**< Fixed subtree (list of subitems) */
+        sysinfo_fn_subtree_t get_data;  /**< Generated subtree function */
+} sysinfo_subtree_t;
+/** Sysinfo item
+ *
+ */
 typedef struct sysinfo_item {
+        char *name;
+        union {
+                unative_t val;
+                void *fn;
+        } val;
+        union {
+                struct sysinfo_item *table;
+                void *fn;
+        } subinfo;
+        struct sysinfo_item *next;
+        int val_type;
+        int subinfo_type;
+        char *name;                           /**< Item name */
+        sysinfo_item_val_type_t val_type;     /**< Item value type */
+        sysinfo_item_val_t val;               /**< Item value */
+        sysinfo_subtree_type_t subtree_type;  /**< Subtree type */
+        sysinfo_subtree_t subtree;            /**< Subtree */
+        struct sysinfo_item *next;            /**< Sibling item */
 } sysinfo_item_t;
+#define SYSINFO_VAL_VAL        0
+#define SYSINFO_VAL_FUNCTION   1
+#define SYSINFO_VAL_UNDEFINED  U_SPECIAL
+extern void sysinfo_set_item_val(const char *, sysinfo_item_t **, sysarg_t);
+extern void sysinfo_set_item_data(const char *, sysinfo_item_t **, void *,
+    size_t);
+extern void sysinfo_set_item_fn_val(const char *, sysinfo_item_t **,
+    sysinfo_fn_val_t);
+extern void sysinfo_set_item_fn_data(const char *, sysinfo_item_t **,
+    sysinfo_fn_data_t);
+extern void sysinfo_set_item_undefined(const char *, sysinfo_item_t **);
+#define SYSINFO_SUBINFO_NONE      0
+#define SYSINFO_SUBINFO_TABLE     1
+#define SYSINFO_SUBINFO_FUNCTION  2
+extern void sysinfo_set_subtree_fn(const char *, sysinfo_item_t **,
+    sysinfo_fn_subtree_t);
 typedef unative_t (*sysinfo_val_fn_t)(sysinfo_item_t *root);
 typedef unative_t (*sysinfo_subinfo_fn_t)(const char *subname);
+extern void sysinfo_init(void);
+extern void sysinfo_dump(sysinfo_item_t *);
+typedef struct sysinfo_rettype {
+        unative_t val;
+        unative_t valid;
+} sysinfo_rettype_t;
+void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, unative_t val);
+void sysinfo_dump(sysinfo_item_t **root, int depth);
+void sysinfo_set_item_function(const char *name, sysinfo_item_t **root, sysinfo_val_fn_t fn);
+void sysinfo_set_item_undefined(const char *name, sysinfo_item_t **root);
+sysinfo_rettype_t sysinfo_get_val(const char *name, sysinfo_item_t **root);
+unative_t sys_sysinfo_valid(unative_t ptr, unative_t len);
+unative_t sys_sysinfo_value(unative_t ptr, unative_t len);
+extern sysarg_t sys_sysinfo_get_tag(void *, size_t);
+extern sysarg_t sys_sysinfo_get_value(void *, size_t, void *);
+extern sysarg_t sys_sysinfo_get_data_size(void *, size_t, void *);
+extern sysarg_t sys_sysinfo_get_data(void *, size_t, void *, size_t, size_t *);
 #endif

kernel/generic/include/time/clock.h

-              rb50b5af2
+              r04803bf
 #define KERN_CLOCK_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #define HZ              100
+#define HZ  100
 /** Uptime structure */
 typedef struct {
         unative_t seconds1;
         unative_t useconds;
         unative_t seconds2;
+        sysarg_t seconds1;
+        sysarg_t useconds;
+        sysarg_t seconds2;
 } uptime_t;

kernel/generic/include/time/delay.h

rb50b5af2	r04803bf
36	36	#define KERN_DELAY_H_
37	37
38		#include <~~arch/type~~s.h>
	38	#include <typedefs.h>
39	39
40	40	extern void delay(uint32_t microseconds);

kernel/generic/include/time/timeout.h

-              rb50b5af2
+              r04803bf
 #define KERN_TIMEOUT_H_
 #include <arch/types.h>
+#include <typedefs.h>
 #include <adt/list.h>
 #include <cpu.h>
 …
 typedef struct {
         SPINLOCK_DECLARE(lock);
+        IRQ_SPINLOCK_DECLARE(lock);
         /** Link to the list of active timeouts on THE->cpu */
         link_t link;
         /** Timeout will be activated in this amount of clock() ticks. */
+        /** Timeout will be activated in this amount of clock() ticks. */
         uint64_t ticks;
         /** Function that will be called on timeout activation. */
 …
 } timeout_t;
 #define us2ticks(us)    ((uint64_t) (((uint32_t) (us) / (1000000 / HZ))))
+#define us2ticks(us)  ((uint64_t) (((uint32_t) (us) / (1000000 / HZ))))
 extern void timeout_init(void);
+extern void timeout_initialize(timeout_t *t);
+extern void timeout_reinitialize(timeout_t *t);
+extern void timeout_register(timeout_t *t, uint64_t usec, timeout_handler_t f,
+    void *arg);
+extern bool timeout_unregister(timeout_t *t);
+extern void timeout_initialize(timeout_t *);
+extern void timeout_reinitialize(timeout_t *);
+extern void timeout_register(timeout_t *, uint64_t, timeout_handler_t, void *);
+extern bool timeout_unregister(timeout_t *);
 #endif

kernel/generic/include/typedefs.h

-              rb50b5af2
+              r04803bf
 #define KERN_TYPEDEFS_H_
+#include <stdint.h>
+#include <arch/common.h>
 #include <arch/types.h>
+#define NULL 0
+#define false 0
+#define true 1
+#define NULL  ((void *) 0)
+#define false  0
+#define true   1
+typedef struct {
+        uint64_t lo;
+        int64_t hi;
+} int128_t;
+typedef struct {
+        uint64_t lo;
+        uint64_t hi;
+} uint128_t;
+typedef struct {
+        volatile atomic_count_t count;
+} atomic_t;
 typedef void (* function)();
 …
 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;
+#ifdef __32_BITS__
+/** Explicit 64-bit arguments passed to syscalls. */
+typedef uint64_t sysarg64_t;
+#endif /* __32_BITS__ */
 #endif

kernel/generic/include/udebug/udebug.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #define KERN_UDEBUG_H_
+#define UDEBUG_EVMASK(event)  (1 << ((event) - 1))
+typedef enum { /* udebug_method_t */
+        /** Start debugging the recipient.
+         *
+         * Causes all threads in the receiving task to stop. When they
+         * are all stoped, an answer with retval 0 is generated.
+         *
+         */
+        UDEBUG_M_BEGIN = 1,
+        /** Finish debugging the recipient.
+         *
+         * Answers all pending GO and GUARD messages.
+         *
+         */
+        UDEBUG_M_END,
+        /** Set which events should be captured. */
+        UDEBUG_M_SET_EVMASK,
+        /** Make sure the debugged task is still there.
+         *
+         * This message is answered when the debugged task dies
+         * or the debugging session ends.
+         *
+         */
+        UDEBUG_M_GUARD,
+        /** Run a thread until a debugging event occurs.
+         *
+         * This message is answered when the thread stops
+         * in a debugging event.
+         *
+         * - ARG2 - id of the thread to run
+         *
+         */
+        UDEBUG_M_GO,
+        /** Stop a thread being debugged.
+         *
+         * Creates a special STOP event in the thread, causing
+         * it to answer a pending GO message (if any).
+         *
+         */
+        UDEBUG_M_STOP,
+        /** Read arguments of a syscall.
+         *
+         * - ARG2 - thread identification
+         * - ARG3 - destination address in the caller's address space
+         *
+         */
+        UDEBUG_M_ARGS_READ,
+        /** Read thread's userspace register state (istate_t).
+         *
+         * - ARG2 - thread identification
+         * - ARG3 - destination address in the caller's address space
+         *
+         * or, on error, retval will be
+         * - ENOENT - thread does not exist
+         * - EBUSY - register state not available
+         */
+        UDEBUG_M_REGS_READ,
+        /** Read the list of the debugged tasks's threads.
+         *
+         * - ARG2 - destination address in the caller's address space
+         * - ARG3 - size of receiving buffer in bytes
+         *
+         * The kernel fills the buffer with a series of sysarg_t values
+         * (thread ids). On answer, the kernel will set:
+         *
+         * - ARG2 - number of bytes that were actually copied
+         * - ARG3 - number of bytes of the complete data
+         *
+         */
+        UDEBUG_M_THREAD_READ,
+        /** Read the name of the debugged task.
+         *
+         * - ARG2 - destination address in the caller's address space
+         * - ARG3 - size of receiving buffer in bytes
+         *
+         * The kernel fills the buffer with a non-terminated string.
+         *
+         * - ARG2 - number of bytes that were actually copied
+         * - ARG3 - number of bytes of the complete data
+         *
+         */
+        UDEBUG_M_NAME_READ,
+        /** Read the list of the debugged task's address space areas.
+         *
+         * - ARG2 - destination address in the caller's address space
+         * - ARG3 - size of receiving buffer in bytes
+         *
+         * The kernel fills the buffer with a series of as_area_info_t structures.
+         * Upon answer, the kernel will set:
+         *
+         * - ARG2 - number of bytes that were actually copied
+         * - ARG3 - number of bytes of the complete data
+         *
+         */
+        UDEBUG_M_AREAS_READ,
+        /** Read the debugged tasks's memory.
+         *
+         * - ARG2 - destination address in the caller's address space
+         * - ARG3 - source address in the recipient's address space
+         * - ARG4 - size of receiving buffer in bytes
+         *
+         */
+        UDEBUG_M_MEM_READ
+} udebug_method_t;
+typedef enum {
+        UDEBUG_EVENT_FINISHED = 1,  /**< Debuging session has finished */
+        UDEBUG_EVENT_STOP,          /**< Stopped on DEBUG_STOP request */
+        UDEBUG_EVENT_SYSCALL_B,     /**< Before beginning syscall execution */
+        UDEBUG_EVENT_SYSCALL_E,     /**< After finishing syscall execution */
+        UDEBUG_EVENT_THREAD_B,      /**< The task created a new thread */
+        UDEBUG_EVENT_THREAD_E       /**< A thread exited */
+} udebug_event_t;
+typedef enum {
+        UDEBUG_EM_FINISHED = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED),
+        UDEBUG_EM_STOP = UDEBUG_EVMASK(UDEBUG_EVENT_STOP),
+        UDEBUG_EM_SYSCALL_B = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B),
+        UDEBUG_EM_SYSCALL_E = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E),
+        UDEBUG_EM_THREAD_B = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B),
+        UDEBUG_EM_THREAD_E = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E),
+        UDEBUG_EM_ALL =
+            (UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) |
+            UDEBUG_EVMASK(UDEBUG_EVENT_STOP) |
+            UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) |
+            UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) |
+            UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) |
+            UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E))
+} udebug_evmask_t;
+#ifdef KERNEL
 #include <ipc/ipc.h>
-typedef enum { /* udebug_method_t */
-/** Start debugging the recipient.
- * Causes all threads in the receiving task to stop. When they
- * are all stoped, an answer with retval 0 is generated.
- */
-UDEBUG_M_BEGIN = 1,
-/** Finish debugging the recipient.
- * Answers all pending GO and GUARD messages.
- */
-UDEBUG_M_END,
-/** Set which events should be captured.
- */
-UDEBUG_M_SET_EVMASK,
-/** Make sure the debugged task is still there.
- * This message is answered when the debugged task dies
- * or the debugging session ends.
- */
-UDEBUG_M_GUARD,
-/** Run a thread until a debugging event occurs.
- * This message is answered when the thread stops
- * in a debugging event.
+ *
- * - ARG2 - id of the thread to run
- */
-UDEBUG_M_GO,
-/** Stop a thread being debugged.
- * Creates a special STOP event in the thread, causing
- * it to answer a pending GO message (if any).
- */
-UDEBUG_M_STOP,
-/** Read arguments of a syscall.
+ *
- * - ARG2 - thread identification
- * - ARG3 - destination address in the caller's address space
+ *
- */
-UDEBUG_M_ARGS_READ,
-/** Read the list of the debugged tasks's threads.
+ *
- * - ARG2 - destination address in the caller's address space
- * - ARG3 - size of receiving buffer in bytes
+ *
- * The kernel fills the buffer with a series of sysarg_t values
- * (thread ids). On answer, the kernel will set:
+ *
- * - ARG2 - number of bytes that were actually copied
- * - ARG3 - number of bytes of the complete data
+ *
- */
-UDEBUG_M_THREAD_READ,
-/** Read the debugged tasks's memory.
+ *
- * - ARG2 - destination address in the caller's address space
- * - ARG3 - source address in the recipient's address space
- * - ARG4 - size of receiving buffer in bytes
+ *
- */
-UDEBUG_M_MEM_READ,
-} udebug_method_t;
-typedef enum {
-        UDEBUG_EVENT_FINISHED = 1,      /**< Debuging session has finished */
-        UDEBUG_EVENT_STOP,              /**< Stopped on DEBUG_STOP request */
-        UDEBUG_EVENT_SYSCALL_B,         /**< Before beginning syscall execution */
-        UDEBUG_EVENT_SYSCALL_E,         /**< After finishing syscall execution */
-        UDEBUG_EVENT_THREAD_B,          /**< The task created a new thread */
-        UDEBUG_EVENT_THREAD_E           /**< A thread exited */
-} udebug_event_t;
-#define UDEBUG_EVMASK(event) (1 << ((event) - 1))
-typedef enum {
-        UDEBUG_EM_FINISHED      = UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED),
-        UDEBUG_EM_STOP          = UDEBUG_EVMASK(UDEBUG_EVENT_STOP),
-        UDEBUG_EM_SYSCALL_B     = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B),
-        UDEBUG_EM_SYSCALL_E     = UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E),
-        UDEBUG_EM_THREAD_B      = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B),
-        UDEBUG_EM_THREAD_E      = UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E),
-        UDEBUG_EM_ALL           =
-                UDEBUG_EVMASK(UDEBUG_EVENT_FINISHED) |
-                UDEBUG_EVMASK(UDEBUG_EVENT_STOP) |
-                UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_B) |
-                UDEBUG_EVMASK(UDEBUG_EVENT_SYSCALL_E) |
-                UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_B) |
-                UDEBUG_EVMASK(UDEBUG_EVENT_THREAD_E)
-} udebug_evmask_t;
-#ifdef KERNEL
 #include <synch/mutex.h>
+#include <synch/condvar.h>
 #include <arch/interrupt.h>
 #include <atomic.h>
 …
         mutex_t lock;
         char *lock_owner;
         udebug_task_state_t dt_state;
         call_t *begin_call;
 …
         /** Synchronize debug ops on this thread / access to this structure. */
         mutex_t lock;
         waitq_t go_wq;
         call_t *go_call;
         unative_t syscall_args[6];
+        sysarg_t syscall_args[6];
         istate_t *uspace_state;
         /** What type of event are we stopped in or 0 if none. */
         udebug_event_t cur_event;
+        bool go;                /**< thread is GO */
+        bool stoppable;         /**< thread is stoppable */
+        bool active;            /**< thread is in a debugging session */
+        bool go;         /**< Thread is GO */
+        bool stoppable;  /**< Thread is stoppable */
+        bool active;     /**< Thread is in a debugging session */
+        condvar_t active_cv;
 } udebug_thread_t;
 …
 struct thread;
+void udebug_task_init(udebug_task_t *ut);
+void udebug_thread_initialize(udebug_thread_t *ut);
+void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
+    unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
+    bool end_variant);
+void udebug_thread_b_event_attach(struct thread *t, struct task *ta);
+void udebug_task_init(udebug_task_t *);
+void udebug_thread_initialize(udebug_thread_t *);
+void udebug_syscall_event(sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t, bool);
+void udebug_thread_b_event_attach(struct thread *, struct task *);
 void udebug_thread_e_event(void);
 …
 void udebug_before_thread_runs(void);
+int udebug_task_cleanup(struct task *ta);
+int udebug_task_cleanup(struct task *);
+void udebug_thread_fault(void);
 #endif

kernel/generic/include/udebug/udebug_ipc.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 void udebug_call_receive(call_t *call);
 #endif

kernel/generic/include/udebug/udebug_ops.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 int udebug_stop(thread_t *t, call_t *call);
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *n);
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *stored,
+    size_t *needed);
+int udebug_name_read(char **data, size_t *data_size);
 int udebug_args_read(thread_t *t, void **buffer);
+int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer);
+int udebug_regs_read(thread_t *t, void **buffer);
+int udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer);
 #endif

kernel/generic/include/userspace.h

-              rb50b5af2
+              r04803bf
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #include <proc/thread.h>
 #include <arch/types.h>
+#include <typedefs.h>
 /** Switch to user-space (CPU user priviledge level) */

Context Navigation

Changeset 04803bf in mainline for kernel/generic/include

Legend:

Download in other formats: