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

Ignore whitespace Rev 4152 → Rev 4153

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

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

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

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

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

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

 /branches/network/kernel/generic/include/string.h
 ,0 → 1,50
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_STRING_H_
+#define KERN_STRING_H_
+#include <arch/types.h>
+extern size_t strlen(const char *str);
+extern int strcmp(const char *src, const char *dst);
+extern int strncmp(const char *src, const char *dst, size_t len);
+extern void strncpy(char *dest, const char *src, size_t len);
+extern char *strchr(const char *s, int i);
+#endif
+/** @}
+ */

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

 /branches/network/kernel/generic/include/proc/program.h
 ,12 → 52,14
 extern void *program_loader;
-extern void program_create(as_t *as, uintptr_t entry_addr, program_t *p);
-extern int program_create_from_image(void *image_addr, program_t *p);
-extern int program_create_loader(program_t *p);
+extern void program_create(as_t *as, uintptr_t entry_addr, char *name,
+    program_t *p);
+extern int program_create_from_image(void *image_addr, char *name,
+    program_t *p);
+extern int program_create_loader(program_t *p, char *name);
 extern void program_ready(program_t *p);
-extern unative_t sys_program_spawn_loader(int *uspace_phone_id);
+extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len);
 #endif

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

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

 /branches/network/kernel/generic/include/udebug/udebug_ops.h
 ,0 → 1,55
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_UDEBUG_OPS_H_
+#define KERN_UDEBUG_OPS_H_
+#include <ipc/ipc.h>
+int udebug_begin(call_t *call);
+int udebug_end(void);
+int udebug_set_evmask(udebug_evmask_t mask);
+int udebug_go(thread_t *t, call_t *call);
+int udebug_stop(thread_t *t, call_t *call);
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *n);
+int udebug_args_read(thread_t *t, void **buffer);
+int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer);
+#endif
+/** @}
+ */

 /branches/network/kernel/generic/include/udebug/udebug_ipc.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup generic
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_UDEBUG_IPC_H_
+#define KERN_UDEBUG_IPC_H_
+#include <ipc/ipc.h>
+int udebug_request_preprocess(call_t *call, phone_t *phone);
+void udebug_call_receive(call_t *call);
+#endif
+/** @}
+ */

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

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

 /branches/network/kernel/generic/include/interrupt.h
 ,12 → 44,12
 typedef void (* iroutine)(int n, istate_t *istate);
-#define fault_if_from_uspace(istate, cmd, ...) \
+#define fault_if_from_uspace(istate, fmt, ...) \
 { \
     if (istate_from_uspace(istate)) { \
         task_t *task = TASK; \
-        printf("Task %" PRIu64 " killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \
-        printf("  " cmd, ##__VA_ARGS__); \
+        printf("Task %s (%" PRIu64 ") killed due to an exception at %p: ", task->name, task->taskid, istate_get_pc(istate)); \
+        printf(fmt "\n", ##__VA_ARGS__); \
         task_kill(task->taskid); \
         thread_exit(); \
     } \

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

/branches/network/kernel/generic/include/synch/spinlock.h
36,6 → 36,7
#define KERN_SPINLOCK_H_

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

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

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

/branches/network/kernel/generic/include/ddi/device.h
39,6 → 39,7
#include <typedefs.h>

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

#endif

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

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

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

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

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

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

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

 /branches/network/kernel/generic/include/mm/page.h
 ,7 → 42,7
 /** Operations to manipulate page mappings. */
 typedef struct {
     void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame,
-        int flags);
+        int flags);
     void (* mapping_remove)(as_t *as, uintptr_t page);
     pte_t *(* mapping_find)(as_t *as, uintptr_t page);
 } page_mapping_operations_t;
 ,6 → 59,7
 extern pte_t *page_table_create(int flags);
 extern void page_table_destroy(pte_t *page_table);
 extern void map_structure(uintptr_t s, size_t size);
 extern uintptr_t hw_map(uintptr_t physaddr, size_t size);
 #endif

 /branches/network/kernel/generic/include/mm/slab.h
 ,7 → 59,7
 /* slab_reclaim constants */
 /** Reclaim all possible memory, because we are in memory stress */
-#define SLAB_RECLAIM_ALL  0x1
+#define SLAB_RECLAIM_ALL  0x01
 /* cache_create flags */

 /branches/network/kernel/generic/include/mm/buddy.h
 ,7 → 82,7
 extern link_t *buddy_system_alloc(buddy_system_t *, uint8_t);
 extern bool buddy_system_can_alloc(buddy_system_t *, uint8_t);
 extern void buddy_system_free(buddy_system_t *, link_t *);
-extern size_t buddy_conf_size(int);
+extern size_t buddy_conf_size(size_t);
 extern link_t *buddy_system_alloc_block(buddy_system_t *, link_t *);
 #endif

 /branches/network/kernel/generic/include/typedefs.h
 ,6 → 51,10
 typedef int32_t inr_t;
 typedef int32_t devno_t;
+typedef volatile uint8_t ioport8_t;
+typedef volatile uint16_t ioport16_t;
+typedef volatile uint32_t ioport32_t;
 #endif
 /** @}

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

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

/branches/network/kernel/generic/include/syscall/syscall.h
44,6 → 44,7
SYS_THREAD_GET_ID,

SYS_TASK_GET_ID,
SYS_TASK_SET_NAME,
SYS_PROGRAM_SPAWN_LOADER,

SYS_FUTEX_SLEEP,
62,6 → 63,7
SYS_IPC_ANSWER_FAST,
SYS_IPC_ANSWER_SLOW,
SYS_IPC_FORWARD_FAST,
SYS_IPC_FORWARD_SLOW,
SYS_IPC_WAIT,
SYS_IPC_HANGUP,
SYS_IPC_REGISTER_IRQ,
70,6 → 72,7
SYS_CAP_GRANT,
SYS_CAP_REVOKE,

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

SYS_DEBUG_ENABLE_CONSOLE,
SYS_DEBUG_DISABLE_CONSOLE,
SYS_IPC_CONNECT_KBOX,
SYSCALL_END
} syscall_t;

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

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

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

 /branches/network/kernel/generic/include/ipc/kbox.h
 ,0 → 1,58
+/*
+ * Copyright (c) 2008 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup genericipc
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_IPC_KBOX_H_
+#define KERN_IPC_KBOX_H_
+#include <typedefs.h>
+/** Kernel answerbox structure. */
+typedef struct kbox {
+    /** The answerbox itself. */
+    answerbox_t box;
+    /** Thread used to service the answerbox. */
+    struct thread *thread;
+    /** Kbox thread creation vs. begin of cleanup mutual exclusion. */
+    mutex_t cleanup_lock;
+    /** True if cleanup of kbox has already started. */
+    bool finished;
+} kbox_t;
+extern int ipc_connect_kbox(task_id_t);
+extern void ipc_kbox_cleanup(void);
+#endif
+/** @}
+ */

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

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4152 → Rev 4153