| /branches/tracing/kernel/generic/include/align.h |
|---|
| 26,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_ |
| 43,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. |
| 51,7 → 51,7 |
| * @param s Address or size to be aligned. |
| * @param a Size of alignment, must be power of 2. |
| */ |
| #define ALIGN_UP(s, a) (((s) + ((a) - 1)) & ~((a) - 1)) |
| #define ALIGN_UP(s, a) (((s) + ((a) - 1)) & ~((a) - 1)) |
| #endif |
| /branches/tracing/kernel/generic/include/func.h |
|---|
| 41,11 → 41,6 |
| extern atomic_t haltstate; |
| extern void halt(void); |
| extern size_t strlen(const char *str); |
| extern int strcmp(const char *src, const char *dst); |
| extern int strncmp(const char *src, const char *dst, size_t len); |
| extern void strncpy(char *dest, const char *src, size_t len); |
| extern unative_t atoi(const char *text); |
| extern void order(const uint64_t val, uint64_t *rv, char *suffix); |
| /branches/tracing/kernel/generic/include/print.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 46,11 → 46,9 |
| extern int puts(const char *s); |
| extern int printf(const char *fmt, ...); |
| extern int sprintf(char *str, const char *fmt, ...); |
| extern int snprintf(char *str, size_t size, const char *fmt, ...); |
| extern int vprintf(const char *fmt, va_list ap); |
| extern int vsprintf(char *str, const char *fmt, va_list ap); |
| extern int vsnprintf(char *str, size_t size, const char *fmt, va_list ap); |
| #endif |
| /branches/tracing/kernel/generic/include/fpu_context.h |
|---|
| 37,10 → 37,6 |
| #include <arch/fpu_context.h> |
| #if defined(CONFIG_FPU_LAZY) && !defined(ARCH_HAS_FPU) |
| # error "CONFIG_FPU_LAZY defined, but no ARCH_HAS_FPU" |
| #endif |
| extern void fpu_context_save(fpu_context_t *); |
| extern void fpu_context_restore(fpu_context_t *); |
| extern void fpu_init(void); |
| /branches/tracing/kernel/generic/include/byteorder.h |
|---|
| 36,6 → 36,7 |
| #define KERN_BYTEORDER_H_ |
| #include <arch/byteorder.h> |
| #include <arch/types.h> |
| #if !(defined(ARCH_IS_BIG_ENDIAN) ^ defined(ARCH_IS_LITTLE_ENDIAN)) |
| #error The architecture must be either big-endian or little-endian. |
| /branches/tracing/kernel/generic/include/symtab.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 44,15 → 44,20 |
| char symbol_name[MAX_SYMBOL_NAME]; |
| }; |
| extern char * get_symtab_entry(unative_t addr); |
| extern uintptr_t get_symbol_addr(const char *name); |
| extern int symtab_name_lookup(unative_t addr, char **name); |
| extern char *symtab_fmt_name_lookup(unative_t addr); |
| extern int symtab_addr_lookup(const char *name, uintptr_t *addr); |
| extern void symtab_print_search(const char *name); |
| extern int symtab_compl(char *name); |
| extern int symtab_compl(char *input, count_t size); |
| #ifdef CONFIG_SYMTAB |
| /* Symtable linked together by build process */ |
| extern struct symtab_entry symbol_table[]; |
| #endif |
| #endif |
| /** @} |
| */ |
| /branches/tracing/kernel/generic/include/sysinfo/sysinfo.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 36,6 → 36,7 |
| #define KERN_SYSINFO_H_ |
| #include <arch/types.h> |
| #include <string.h> |
| typedef union sysinfo_item_val { |
| unative_t val; |
| 59,13 → 60,13 |
| int subinfo_type; |
| } sysinfo_item_t; |
| #define SYSINFO_VAL_VAL 0 |
| #define SYSINFO_VAL_FUNCTION 1 |
| #define SYSINFO_VAL_UNDEFINED '?' |
| #define SYSINFO_VAL_VAL 0 |
| #define SYSINFO_VAL_FUNCTION 1 |
| #define SYSINFO_VAL_UNDEFINED U_SPECIAL |
| #define SYSINFO_SUBINFO_NONE 0 |
| #define SYSINFO_SUBINFO_TABLE 1 |
| #define SYSINFO_SUBINFO_FUNCTION 2 |
| #define SYSINFO_SUBINFO_NONE 0 |
| #define SYSINFO_SUBINFO_TABLE 1 |
| #define SYSINFO_SUBINFO_FUNCTION 2 |
| typedef unative_t (*sysinfo_val_fn_t)(sysinfo_item_t *root); |
| typedef unative_t (*sysinfo_subinfo_fn_t)(const char *subname); |
| /branches/tracing/kernel/generic/include/config.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 38,13 → 38,15 |
| #include <arch/types.h> |
| #include <arch/mm/page.h> |
| #define STACK_SIZE PAGE_SIZE |
| #define STACK_SIZE PAGE_SIZE |
| #define CONFIG_INIT_TASKS 32 |
| #define CONFIG_INIT_TASKS 32 |
| #define CONFIG_TASK_NAME_BUFLEN 32 |
| typedef struct { |
| uintptr_t addr; |
| size_t size; |
| char name[CONFIG_TASK_NAME_BUFLEN]; |
| } init_task_t; |
| typedef struct { |
| 63,14 → 65,14 |
| } ballocs_t; |
| typedef struct { |
| count_t cpu_count; /**< Number of processors detected. */ |
| volatile count_t cpu_active; /**< Number of processors that are up and running. */ |
| count_t cpu_count; /**< Number of processors detected. */ |
| volatile count_t cpu_active; /**< Number of processors that are up and running. */ |
| uintptr_t base; |
| size_t kernel_size; /**< Size of memory in bytes taken by kernel and stack */ |
| size_t kernel_size; /**< Size of memory in bytes taken by kernel and stack */ |
| uintptr_t stack_base; /**< Base adddress of initial stack */ |
| size_t stack_size; /**< Size of initial stack */ |
| uintptr_t stack_base; /**< Base adddress of initial stack */ |
| size_t stack_size; /**< Size of initial stack */ |
| } config_t; |
| extern config_t config; |
| /branches/tracing/kernel/generic/include/string.h |
|---|
| 0,0 → 1,101 |
| /* |
| * Copyright (c) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef KERN_STRING_H_ |
| #define KERN_STRING_H_ |
| #include <typedefs.h> |
| /**< Common Unicode characters */ |
| #define U_SPECIAL '?' |
| #define U_LEFT_ARROW 0x2190 |
| #define U_UP_ARROW 0x2191 |
| #define U_RIGHT_ARROW 0x2192 |
| #define U_DOWN_ARROW 0x2193 |
| #define U_PAGE_UP 0x21de |
| #define U_PAGE_DOWN 0x21df |
| #define U_HOME_ARROW 0x21f1 |
| #define U_END_ARROW 0x21f2 |
| #define U_NULL 0x2400 |
| #define U_ESCAPE 0x241b |
| #define U_DELETE 0x2421 |
| #define U_CURSOR 0x2588 |
| #define U_BOM 0xfeff |
| /**< No size limit constant */ |
| #define STR_NO_LIMIT ((size_t) -1) |
| /**< Maximum size of a string containing cnt characters */ |
| #define STR_BOUNDS(cnt) (cnt << 2) |
| extern wchar_t str_decode(const char *str, size_t *offset, size_t sz); |
| extern int chr_encode(wchar_t ch, char *str, size_t *offset, size_t sz); |
| extern size_t str_size(const char *str); |
| extern size_t wstr_size(const wchar_t *str); |
| extern size_t str_lsize(const char *str, count_t max_len); |
| extern size_t wstr_lsize(const wchar_t *str, count_t max_len); |
| extern count_t str_length(const char *str); |
| extern count_t wstr_length(const wchar_t *wstr); |
| extern count_t str_nlength(const char *str, size_t size); |
| extern count_t wstr_nlength(const wchar_t *str, size_t size); |
| extern bool ascii_check(wchar_t ch); |
| extern bool chr_check(wchar_t ch); |
| extern int str_cmp(const char *s1, const char *s2); |
| extern int str_lcmp(const char *s1, const char *s2, count_t max_len); |
| extern void str_cpy(char *dest, size_t size, const char *src); |
| extern void str_ncpy(char *dest, size_t size, const char *src, size_t n); |
| extern void wstr_nstr(char *dst, const wchar_t *src, size_t size); |
| extern const char *str_chr(const char *str, wchar_t ch); |
| extern bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos); |
| extern bool wstr_remove(wchar_t *str, count_t pos); |
| #endif |
| /** @} |
| */ |
| /branches/tracing/kernel/generic/include/proc/task.h |
|---|
| 144,6 → 144,7 |
| #endif |
| extern unative_t sys_task_get_id(task_id_t *uspace_task_id); |
| extern unative_t sys_task_set_name(const char *uspace_name, size_t name_len); |
| #endif |
| /branches/tracing/kernel/generic/include/proc/program.h |
|---|
| 59,8 → 59,7 |
| extern int program_create_loader(program_t *p, char *name); |
| extern void program_ready(program_t *p); |
| extern unative_t sys_program_spawn_loader(int *uspace_phone_id, |
| char *uspace_name, size_t name_len); |
| extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len); |
| #endif |
| /branches/tracing/kernel/generic/include/debug.h |
|---|
| 57,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__); |
| 79,15 → 79,15 |
| # define LOG(format, ...) |
| #endif |
| /** Extensive debugging execute macro |
| /** Extensive logging execute macro |
| * |
| * If CONFIG_EDEBUG is set, the LOG_EXEC() macro |
| * If CONFIG_LOG is set, the LOG_EXEC() macro |
| * will print an information about calling a given |
| * function and call it. |
| * |
| */ |
| #ifdef CONFIG_EDEBUG |
| #ifdef CONFIG_LOG |
| # define LOG_EXEC(fnc) \ |
| { \ |
| printf("%s() at %s:%u: " #fnc "\n", __func__, __FILE__, \ |
| /branches/tracing/kernel/generic/include/panic.h |
|---|
| 37,11 → 37,11 |
| #ifdef CONFIG_DEBUG |
| # define panic(format, ...) \ |
| panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \ |
| __FILE__, __LINE__, ##__VA_ARGS__); |
| panic_printf("Kernel panic in %s() at %s:%u: " format "\n", \ |
| __func__, __FILE__, __LINE__, ##__VA_ARGS__); |
| #else |
| # define panic(format, ...) \ |
| panic_printf("Kernel panic: " format, ##__VA_ARGS__); |
| panic_printf("Kernel panic: " format "\n", ##__VA_ARGS__); |
| #endif |
| extern void panic_printf(char *fmt, ...) __attribute__((noreturn)); |
| /branches/tracing/kernel/generic/include/interrupt.h |
|---|
| 44,12 → 44,12 |
| typedef void (* iroutine)(int n, istate_t *istate); |
| #define fault_if_from_uspace(istate, cmd, ...) \ |
| #define fault_if_from_uspace(istate, fmt, ...) \ |
| { \ |
| if (istate_from_uspace(istate)) { \ |
| task_t *task = TASK; \ |
| printf("Task %" PRIu64 " killed due to an exception at %p.", task->taskid, istate_get_pc(istate)); \ |
| printf(" " cmd, ##__VA_ARGS__); \ |
| printf("Task %s (%" PRIu64 ") killed due to an exception at %p: ", task->name, task->taskid, istate_get_pc(istate)); \ |
| printf(fmt "\n", ##__VA_ARGS__); \ |
| task_kill(task->taskid); \ |
| thread_exit(); \ |
| } \ |
| /branches/tracing/kernel/generic/include/main/main.h |
|---|
| 35,8 → 35,13 |
| #ifndef KERN_MAIN_H_ |
| #define KERN_MAIN_H_ |
| #include <arch/types.h> |
| extern uintptr_t stack_safe; |
| extern void main_bsp(void); |
| extern void main_ap(void); |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/putchar.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 35,7 → 35,7 |
| #ifndef KERN_PUTCHAR_H_ |
| #define KERN_PUTCHAR_H_ |
| extern void putchar(const char ch); |
| extern void putchar(const wchar_t ch); |
| #endif |
| /branches/tracing/kernel/generic/include/memstr.h |
|---|
| 44,7 → 44,7 |
| extern void *_memcpy(void *dst, const void *src, size_t cnt); |
| extern void _memsetb(void *dst, size_t cnt, uint8_t x); |
| extern void _memsetw(void *dst, size_t cnt, uint16_t x); |
| extern char *strcpy(char *dest, const char *src); |
| extern void *memmove(void *dst, const void *src, size_t cnt); |
| #endif |
| /branches/tracing/kernel/generic/include/ddi/irq.h |
|---|
| 36,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; |
| 54,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 { |
| 67,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. */ |
| 81,10 → 82,10 |
| } irq_trigger_t; |
| struct irq; |
| typedef void (* irq_handler_t)(struct irq *irq, void *arg, ...); |
| typedef void (* irq_handler_t)(struct irq *); |
| /** Type for function used to clear the interrupt. */ |
| typedef void (* cir_t)(void *arg, inr_t inr); |
| typedef void (* cir_t)(void *, inr_t); |
| /** IPC notification config structure. |
| * |
| 98,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. */ |
| 141,11 → 144,11 |
| /** Trigger level of the IRQ. */ |
| irq_trigger_t trigger; |
| /** Claim ownership of the IRQ. */ |
| irq_ownership_t (* claim)(void); |
| irq_ownership_t (* claim)(struct irq *); |
| /** Handler for this IRQ and device. */ |
| irq_handler_t handler; |
| /** Argument for the handler. */ |
| void *arg; |
| /** Instance argument for the handler and the claim function. */ |
| void *instance; |
| /** Clear interrupt routine. */ |
| cir_t cir; |
| 156,12 → 159,14 |
| ipc_notif_cfg_t notif_cfg; |
| } irq_t; |
| extern void irq_init(count_t inrs, count_t chains); |
| extern void irq_initialize(irq_t *irq); |
| extern void irq_register(irq_t *irq); |
| extern irq_t *irq_dispatch_and_lock(inr_t inr); |
| extern irq_t *irq_find_and_lock(inr_t inr, devno_t devno); |
| SPINLOCK_EXTERN(irq_uspace_hash_table_lock); |
| extern hash_table_t irq_uspace_hash_table; |
| extern void irq_init(count_t, count_t); |
| extern void irq_initialize(irq_t *); |
| extern void irq_register(irq_t *); |
| extern irq_t *irq_dispatch_and_lock(inr_t); |
| #endif |
| #endif |
| /branches/tracing/kernel/generic/include/ddi/device.h |
|---|
| 39,6 → 39,7 |
| #include <typedefs.h> |
| extern devno_t device_assign_devno(void); |
| extern unative_t sys_device_assign_devno(void); |
| #endif |
| /branches/tracing/kernel/generic/include/ddi/ddi.h |
|---|
| 38,13 → 38,14 |
| #include <ddi/ddi_arg.h> |
| #include <arch/types.h> |
| #include <proc/task.h> |
| #include <adt/list.h> |
| /** Structure representing contiguous physical memory area. */ |
| typedef struct { |
| uintptr_t pbase; /**< Physical base of the area. */ |
| uintptr_t vbase; /**< Virtual base of the area. */ |
| count_t frames; /**< Number of frames in the area. */ |
| bool cacheable; /**< Cacheability. */ |
| uintptr_t pbase; /**< Physical base of the area. */ |
| pfn_t frames; /**< Number of frames in the area. */ |
| link_t link; /**< Linked list link */ |
| } parea_t; |
| extern void ddi_init(void); |
| /branches/tracing/kernel/generic/include/console/chardev.h |
|---|
| 39,41 → 39,63 |
| #include <synch/waitq.h> |
| #include <synch/spinlock.h> |
| #define CHARDEV_BUFLEN 512 |
| #define INDEV_BUFLEN 512 |
| struct chardev; |
| struct indev; |
| /* Character device operations interface. */ |
| /* Input character device operations interface. */ |
| typedef struct { |
| /** Suspend pushing characters. */ |
| void (* suspend)(struct chardev *); |
| /** Resume pushing characters. */ |
| void (* resume)(struct chardev *); |
| /** Write character to stream. */ |
| void (* write)(struct chardev *, char c); |
| /** Read character directly from device, assume interrupts disabled. */ |
| char (* read)(struct chardev *); |
| } chardev_operations_t; |
| wchar_t (* poll)(struct indev *); |
| } indev_operations_t; |
| /** Character input device. */ |
| typedef struct chardev { |
| typedef struct indev { |
| char *name; |
| waitq_t wq; |
| waitq_t wq; |
| /** Protects everything below. */ |
| SPINLOCK_DECLARE(lock); |
| uint8_t buffer[CHARDEV_BUFLEN]; |
| SPINLOCK_DECLARE(lock); |
| wchar_t buffer[INDEV_BUFLEN]; |
| count_t counter; |
| /** Implementation of chardev operations. */ |
| chardev_operations_t *op; |
| /** Implementation of indev operations. */ |
| indev_operations_t *op; |
| index_t index; |
| void *data; |
| } chardev_t; |
| } indev_t; |
| extern void chardev_initialize(char *name, chardev_t *chardev, |
| chardev_operations_t *op); |
| extern void chardev_push_character(chardev_t *chardev, uint8_t ch); |
| struct outdev; |
| /* Output character device operations interface. */ |
| typedef struct { |
| /** Write character to output. */ |
| void (* write)(struct outdev *, wchar_t, bool); |
| } outdev_operations_t; |
| /** Character input device. */ |
| typedef struct outdev { |
| char *name; |
| /** Protects everything below. */ |
| SPINLOCK_DECLARE(lock); |
| /** Implementation of outdev operations. */ |
| outdev_operations_t *op; |
| void *data; |
| } outdev_t; |
| extern void indev_initialize(char *name, indev_t *indev, |
| indev_operations_t *op); |
| extern void indev_push_character(indev_t *indev, wchar_t ch); |
| extern wchar_t indev_pop_character(indev_t *indev); |
| extern void outdev_initialize(char *name, outdev_t *outdev, |
| outdev_operations_t *op); |
| extern bool check_poll(indev_t *indev); |
| #endif /* KERN_CHARDEV_H_ */ |
| /** @} |
| /branches/tracing/kernel/generic/include/console/kconsole.h |
|---|
| 37,9 → 37,10 |
| #include <adt/list.h> |
| #include <synch/spinlock.h> |
| #include <ipc/irq.h> |
| #define MAX_CMDLINE 256 |
| #define KCONSOLE_HISTORY 10 |
| #define MAX_CMDLINE 256 |
| #define KCONSOLE_HISTORY 10 |
| typedef enum { |
| ARG_TYPE_INVALID = 0, |
| 46,7 → 47,7 |
| ARG_TYPE_INT, |
| ARG_TYPE_STRING, |
| /** Variable type - either symbol or string. */ |
| ARG_TYPE_VAR |
| ARG_TYPE_VAR |
| } cmd_arg_type_t; |
| /** Structure representing one argument of kconsole command line. */ |
| 83,13 → 84,19 |
| void (* help)(void); |
| } cmd_info_t; |
| extern bool kconsole_notify; |
| extern irq_t kconsole_irq; |
| SPINLOCK_EXTERN(cmd_lock); |
| extern link_t cmd_head; |
| extern void kconsole_init(void); |
| extern void kconsole(void *prompt); |
| extern void kconsole_notify_init(void); |
| extern bool kconsole_check_poll(void); |
| extern void kconsole(char *prompt, char *msg, bool kcon); |
| extern void kconsole_thread(void *data); |
| extern int cmd_register(cmd_info_t *cmd); |
| extern bool cmd_register(cmd_info_t *cmd); |
| #endif |
| /branches/tracing/kernel/generic/include/console/console.h |
|---|
| 38,17 → 38,26 |
| #include <arch/types.h> |
| #include <console/chardev.h> |
| extern chardev_t *stdin; |
| extern chardev_t *stdout; |
| extern indev_t *stdin; |
| extern outdev_t *stdout; |
| extern bool silent; |
| extern indev_t *stdin_wire(void); |
| extern void console_init(void); |
| extern void klog_init(void); |
| extern void klog_update(void); |
| extern uint8_t getc(chardev_t *chardev); |
| uint8_t _getc(chardev_t *chardev); |
| extern count_t gets(chardev_t *chardev, char *buf, size_t buflen); |
| extern void putchar(char c); |
| extern wchar_t getc(indev_t *indev); |
| extern count_t gets(indev_t *indev, char *buf, size_t buflen); |
| extern unative_t sys_klog(int fd, const void *buf, size_t size); |
| extern void grab_console(void); |
| extern void release_console(void); |
| extern unative_t sys_debug_enable_console(void); |
| extern unative_t sys_debug_disable_console(void); |
| extern void arch_grab_console(void); |
| extern void arch_release_console(void); |
| /branches/tracing/kernel/generic/include/printf/printf_core.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 35,20 → 35,23 |
| #ifndef KERN_PRINTF_CORE_H_ |
| #define KERN_PRINTF_CORE_H_ |
| #include <arch/types.h> |
| #include <typedefs.h> |
| #include <arch/arg.h> |
| /** Structure for specifying output methods for different printf clones. */ |
| struct printf_spec { |
| /* Output function, returns count of printed characters or EOF */ |
| int (*write)(void *, size_t, void *); |
| /* Support data - output stream specification, its state, locks,... */ |
| typedef struct { |
| /* String output function, returns number of printed characters or EOF */ |
| int (*str_write)(const char *, size_t, void *); |
| /* Wide string output function, returns number of printed characters or EOF */ |
| int (*wstr_write)(const wchar_t *, size_t, void *); |
| /* User data - output stream specification, state, locks, etc. */ |
| void *data; |
| } printf_spec_t; |
| }; |
| int printf_core(const char *fmt, printf_spec_t *ps, va_list ap); |
| int printf_core(const char *fmt, struct printf_spec *ps, va_list ap); |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/arch.h |
|---|
| 63,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); |
| 79,6 → 78,7 |
| extern void reboot(void); |
| extern void arch_reboot(void); |
| extern void *arch_construct_function(fncptr_t *fptr, void *addr, void *caller); |
| #endif |
| /branches/tracing/kernel/generic/include/mm/frame.h |
|---|
| 38,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); |
| 88,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); |
| 120,7 → 174,7 |
| * Console functions |
| */ |
| extern void zone_print_list(void); |
| extern void zone_print_one(unsigned int); |
| extern void zone_print_one(count_t); |
| #endif |
| /branches/tracing/kernel/generic/include/mm/page.h |
|---|
| 42,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; |
| 59,6 → 59,7 |
| extern pte_t *page_table_create(int flags); |
| extern void page_table_destroy(pte_t *page_table); |
| extern void map_structure(uintptr_t s, size_t size); |
| extern uintptr_t hw_map(uintptr_t physaddr, size_t size); |
| #endif |
| /branches/tracing/kernel/generic/include/mm/slab.h |
|---|
| 41,40 → 41,40 |
| #include <mm/frame.h> |
| /** Minimum size to be allocated by malloc */ |
| #define SLAB_MIN_MALLOC_W 4 |
| #define SLAB_MIN_MALLOC_W 4 |
| /** Maximum size to be allocated by malloc */ |
| #define SLAB_MAX_MALLOC_W 18 |
| #define SLAB_MAX_MALLOC_W 22 |
| /** Initial Magazine size (TODO: dynamically growing magazines) */ |
| #define SLAB_MAG_SIZE 4 |
| /** If object size is less, store control structure inside SLAB */ |
| #define SLAB_INSIDE_SIZE (PAGE_SIZE >> 3) |
| #define SLAB_INSIDE_SIZE (PAGE_SIZE >> 3) |
| /** Maximum wasted space we allow for cache */ |
| #define SLAB_MAX_BADNESS(cache) \ |
| #define SLAB_MAX_BADNESS(cache) \ |
| (((unsigned int) PAGE_SIZE << (cache)->order) >> 2) |
| /* slab_reclaim constants */ |
| /** Reclaim all possible memory, because we are in memory stress */ |
| #define SLAB_RECLAIM_ALL 0x1 |
| #define SLAB_RECLAIM_ALL 0x01 |
| /* cache_create flags */ |
| /** Do not use per-cpu cache */ |
| #define SLAB_CACHE_NOMAGAZINE 0x1 |
| #define SLAB_CACHE_NOMAGAZINE 0x01 |
| /** Have control structure inside SLAB */ |
| #define SLAB_CACHE_SLINSIDE 0x2 |
| #define SLAB_CACHE_SLINSIDE 0x02 |
| /** We add magazine cache later, if we have this flag */ |
| #define SLAB_CACHE_MAGDEFERRED (0x4 | SLAB_CACHE_NOMAGAZINE) |
| #define SLAB_CACHE_MAGDEFERRED (0x04 | SLAB_CACHE_NOMAGAZINE) |
| typedef struct { |
| link_t link; |
| count_t busy; /**< Count of full slots in magazine */ |
| count_t size; /**< Number of slots in magazine */ |
| void *objs[]; /**< Slots in magazine */ |
| count_t busy; /**< Count of full slots in magazine */ |
| count_t size; /**< Number of slots in magazine */ |
| void *objs[]; /**< Slots in magazine */ |
| } slab_magazine_t; |
| typedef struct { |
| 86,23 → 86,23 |
| typedef struct { |
| char *name; |
| link_t link; |
| /* Configuration */ |
| /** Size of slab position - align_up(sizeof(obj)) */ |
| size_t size; |
| int (*constructor)(void *obj, int kmflag); |
| int (*destructor)(void *obj); |
| /** Flags changing behaviour of cache */ |
| int flags; |
| /* Computed values */ |
| uint8_t order; /**< Order of frames to be allocated */ |
| unsigned int objects; /**< Number of objects that fit in */ |
| uint8_t order; /**< Order of frames to be allocated */ |
| unsigned int objects; /**< Number of objects that fit in */ |
| /* Statistics */ |
| atomic_t allocated_slabs; |
| atomic_t allocated_objs; |
| 109,15 → 109,15 |
| atomic_t cached_objs; |
| /** How many magazines in magazines list */ |
| atomic_t magazine_counter; |
| /* Slabs */ |
| link_t full_slabs; /**< List of full slabs */ |
| link_t partial_slabs; /**< List of partial slabs */ |
| link_t full_slabs; /**< List of full slabs */ |
| link_t partial_slabs; /**< List of partial slabs */ |
| SPINLOCK_DECLARE(slablock); |
| /* Magazines */ |
| link_t magazines; /**< List o full magazines */ |
| /* Magazines */ |
| link_t magazines; /**< List o full magazines */ |
| SPINLOCK_DECLARE(maglock); |
| /** CPU cache */ |
| slab_mag_cache_t *mag_cache; |
| } slab_cache_t; |
| 141,6 → 141,7 |
| extern void *malloc(unsigned int, int); |
| extern void *realloc(void *, unsigned int, int); |
| extern void free(void *); |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/mm/buddy.h |
|---|
| 82,7 → 82,7 |
| extern link_t *buddy_system_alloc(buddy_system_t *, uint8_t); |
| extern bool buddy_system_can_alloc(buddy_system_t *, uint8_t); |
| extern void buddy_system_free(buddy_system_t *, link_t *); |
| extern size_t buddy_conf_size(int); |
| extern size_t buddy_conf_size(size_t); |
| extern link_t *buddy_system_alloc_block(buddy_system_t *, link_t *); |
| #endif |
| /branches/tracing/kernel/generic/include/typedefs.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 51,6 → 51,12 |
| typedef int32_t inr_t; |
| typedef int32_t devno_t; |
| typedef int32_t wchar_t; |
| typedef volatile uint8_t ioport8_t; |
| typedef volatile uint16_t ioport16_t; |
| typedef volatile uint32_t ioport32_t; |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/macros.h |
|---|
| 26,7 → 26,7 |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| 35,47 → 35,66 |
| #ifndef KERN_MACROS_H_ |
| #define KERN_MACROS_H_ |
| #ifndef __ASM__ |
| #include <arch/types.h> |
| #define isdigit(d) (((d) >= '0') && ((d) <= '9')) |
| #define islower(c) (((c) >= 'a') && ((c) <= 'z')) |
| #define isupper(c) (((c) >= 'A') && ((c) <= 'Z')) |
| #define isalpha(c) (is_lower((c)) || is_upper((c))) |
| #define isalphanum(c) (is_alpha((c)) || is_digit((c))) |
| #define isspace(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || \ |
| ((c) == '\r')) |
| #define min(a,b) ((a) < (b) ? (a) : (b)) |
| #define max(a,b) ((a) > (b) ? (a) : (b)) |
| /** Return true if the intervals overlap. |
| * |
| * @param s1 Start address of the first interval. |
| * @param sz1 Size of the first interval. |
| * @param s2 Start address of the second interval. |
| * @param sz2 Size of the second interval. |
| * @param s1 Start address of the first interval. |
| * @param sz1 Size of the first interval. |
| * @param s2 Start address of the second interval. |
| * @param sz2 Size of the second interval. |
| */ |
| static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2) |
| { |
| uintptr_t e1 = s1 + sz1; |
| uintptr_t e2 = s2 + sz2; |
| return (s1 < e2) && (s2 < e1); |
| return ((s1 < e2) && (s2 < e1)); |
| } |
| #endif /* __ASM__ */ |
| #define isdigit(d) (((d) >= '0') && ((d) <= '9')) |
| #define islower(c) (((c) >= 'a') && ((c) <= 'z')) |
| #define isupper(c) (((c) >= 'A') && ((c) <= 'Z')) |
| #define isalpha(c) (is_lower((c)) || is_upper((c))) |
| #define isalphanum(c) (is_alpha((c)) || is_digit((c))) |
| #define isspace(c) \ |
| (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r')) |
| #define min(a, b) ((a) < (b) ? (a) : (b)) |
| #define max(a, b) ((a) > (b) ? (a) : (b)) |
| #define min3(a, b, c) ((a) < (b) ? (min(a, c)) : (min(b, c))) |
| #define max3(a, b, c) ((a) > (b) ? (max(a, c)) : (max(b, c))) |
| /* Compute overlapping of physical addresses */ |
| #define PA_overlaps(x, szx, y, szy) \ |
| #define PA_overlaps(x, szx, y, szy) \ |
| overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy)) |
| #define SIZE2KB(size) ((size) >> 10) |
| #define SIZE2MB(size) ((size) >> 20) |
| #define SIZE2KB(size) ((size) >> 10) |
| #define SIZE2MB(size) ((size) >> 20) |
| #define KB2SIZE(kb) ((kb) << 10) |
| #define MB2SIZE(mb) ((mb) << 20) |
| #define KB2SIZE(kb) ((kb) << 10) |
| #define MB2SIZE(mb) ((mb) << 20) |
| #define STRING(arg) STRING_ARG(arg) |
| #define STRING_ARG(arg) #arg |
| #define STRING(arg) STRING_ARG(arg) |
| #define STRING_ARG(arg) #arg |
| /** Pseudorandom generator |
| * |
| * A pretty standard linear congruential pseudorandom |
| * number generator (m = 2^32 or 2^64 depending on architecture). |
| * |
| */ |
| #define RANDI(seed) \ |
| ({ \ |
| (seed) = 1103515245 * (seed) + 12345; \ |
| (seed); \ |
| }) |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/syscall/syscall.h |
|---|
| 44,6 → 44,7 |
| SYS_THREAD_GET_ID, |
| SYS_TASK_GET_ID, |
| SYS_TASK_SET_NAME, |
| SYS_PROGRAM_SPAWN_LOADER, |
| SYS_FUTEX_SLEEP, |
| 62,14 → 63,18 |
| SYS_IPC_ANSWER_FAST, |
| SYS_IPC_ANSWER_SLOW, |
| SYS_IPC_FORWARD_FAST, |
| SYS_IPC_FORWARD_SLOW, |
| SYS_IPC_WAIT, |
| SYS_IPC_HANGUP, |
| SYS_IPC_REGISTER_IRQ, |
| SYS_IPC_UNREGISTER_IRQ, |
| SYS_EVENT_SUBSCRIBE, |
| SYS_CAP_GRANT, |
| SYS_CAP_REVOKE, |
| SYS_DEVICE_ASSIGN_DEVNO, |
| SYS_PHYSMEM_MAP, |
| SYS_IOSPACE_ENABLE, |
| SYS_PREEMPT_CONTROL, |
| 78,6 → 83,7 |
| SYS_SYSINFO_VALUE, |
| SYS_DEBUG_ENABLE_CONSOLE, |
| SYS_DEBUG_DISABLE_CONSOLE, |
| SYS_IPC_CONNECT_KBOX, |
| SYSCALL_END |
| } syscall_t; |
| /branches/tracing/kernel/generic/include/ipc/sysipc.h |
|---|
| 53,6 → 53,8 |
| int nonblocking); |
| unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid, |
| unative_t method, unative_t arg1, unative_t arg2, int mode); |
| unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid, |
| ipc_data_t *data, int mode); |
| unative_t sys_ipc_hangup(int phoneid); |
| unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method, |
| irq_code_t *ucode); |
| /branches/tracing/kernel/generic/include/ipc/irq.h |
|---|
| 36,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> |
| 43,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) \ |
| 64,8 → 69,8 |
| #define ipc_irq_send_msg_5(irq, a1, a2, a3, a4, a5) \ |
| ipc_irq_send_msg((irq), (a1), (a2), (a3), (a4), (a5)) |
| extern void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, |
| unative_t a3, unative_t a4, unative_t a5); |
| extern void ipc_irq_send_msg(irq_t *, unative_t, unative_t, unative_t, unative_t, |
| unative_t); |
| #endif |
| /branches/tracing/kernel/generic/include/ipc/event.h |
|---|
| 0,0 → 1,79 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef KERN_EVENT_H_ |
| #define KERN_EVENT_H_ |
| #include <ipc/event_types.h> |
| #include <arch/types.h> |
| #include <synch/spinlock.h> |
| #include <ipc/ipc.h> |
| /** Event notification structure. */ |
| typedef struct { |
| SPINLOCK_DECLARE(lock); |
| /** Answerbox for notifications. */ |
| answerbox_t *answerbox; |
| /** Method to be used for the notification. */ |
| unative_t method; |
| /** Counter. */ |
| count_t counter; |
| } event_t; |
| extern void event_init(void); |
| extern unative_t sys_event_subscribe(unative_t, unative_t); |
| extern bool event_is_subscribed(event_type_t); |
| extern void event_cleanup_answerbox(answerbox_t *); |
| #define event_notify_0(e) \ |
| event_notify((e), 0, 0, 0, 0, 0) |
| #define event_notify_1(e, a1) \ |
| event_notify((e), (a1), 0, 0, 0, 0) |
| #define event_notify_2(e, a1, a2) \ |
| event_notify((e), (a1), (a2), 0, 0, 0) |
| #define event_notify_3(e, a1, a2, a3) \ |
| event_notify((e), (a1), (a2), (a3), 0, 0) |
| #define event_notify_4(e, a1, a2, a3, a4) \ |
| event_notify((e), (a1), (a2), (a3), (a4), 0) |
| #define event_notify_5(e, a1, a2, a3, a4, a5) \ |
| event_notify((e), (a1), (a2), (a3), (a4), (a5)) |
| extern void event_notify(event_type_t, unative_t, unative_t, unative_t, |
| unative_t, unative_t); |
| #endif |
| /** @} |
| */ |
| /branches/tracing/kernel/generic/include/ipc/event_types.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Copyright (c) 2009 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /** @addtogroup generic |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef KERN_EVENT_TYPES_H_ |
| #define KERN_EVENT_TYPES_H_ |
| typedef enum event_type { |
| EVENT_KLOG = 0, |
| EVENT_KCONSOLE, |
| EVENT_END |
| } event_type_t; |
| #endif |
| /** @} |
| */ |
| /branches/tracing/kernel/generic/include/errno.h |
|---|
| 48,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 |