| /branches/tracing/kernel/generic/include/config.h |
|---|
| 40,8 → 40,6 |
| #define STACK_SIZE PAGE_SIZE |
| #define CONFIG_MEMORY_SIZE (8 * 1024 * 1024) |
| #define CONFIG_INIT_TASKS 32 |
| typedef struct { |
| /branches/tracing/kernel/generic/include/proc/task.h |
|---|
| 145,7 → 145,6 |
| #endif |
| extern unative_t sys_task_get_id(task_id_t *uspace_task_id); |
| extern unative_t sys_task_spawn(void *image, size_t size); |
| #endif |
| /branches/tracing/kernel/generic/include/proc/thread.h |
|---|
| 252,8 → 252,6 |
| extern void thread_update_accounting(void); |
| extern bool thread_exists(thread_t *t); |
| extern thread_t *thread_create_program(void *program_addr, char *name); |
| /** Fpu context slab cache. */ |
| extern slab_cache_t *fpu_context_slab; |
| /branches/tracing/kernel/generic/include/proc/program.h |
|---|
| 0,0 → 1,65 |
| /* |
| * 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 genericproc |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef KERN_PROGRAM_H_ |
| #define KERN_PROGRAM_H_ |
| #include <arch/types.h> |
| struct task; |
| struct thread; |
| /** Program info structure. |
| * |
| * A program is an abstraction of a freshly created (not yet running) |
| * userspace task containing a main thread along with its userspace stack. |
| */ |
| typedef struct program { |
| struct task *task; /**< Program task */ |
| struct thread *main_thread; /**< Program main thread */ |
| } program_t; |
| 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_ready(program_t *p); |
| extern unative_t sys_program_spawn_loader(int *uspace_phone_id); |
| #endif |
| /** @} |
| */ |
| /branches/tracing/kernel/generic/include/lib/objc_ext.h |
|---|
| File deleted |
| /branches/tracing/kernel/generic/include/lib/objc.h |
|---|
| File deleted |
| /branches/tracing/kernel/generic/include/lib/elf.h |
|---|
| 114,7 → 114,8 |
| #define EE_MEMORY 2 /* Cannot allocate address space */ |
| #define EE_INCOMPATIBLE 3 /* ELF image is not compatible with current architecture */ |
| #define EE_UNSUPPORTED 4 /* Non-supported ELF (e.g. dynamic ELFs) */ |
| #define EE_IRRECOVERABLE 5 |
| #define EE_LOADER 5 /* The image is actually a program loader */ |
| #define EE_IRRECOVERABLE 6 |
| /** |
| * ELF section types |
| 338,6 → 339,10 |
| extern char *elf_error(unsigned int rc); |
| /* Interpreter string used to recognize the program loader */ |
| #define ELF_INTERP_ZSTR "kernel" |
| #define ELF_INTERP_ZLEN sizeof(ELF_INTERP_ZSTR) |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/synch/mutex.h |
|---|
| 39,20 → 39,26 |
| #include <synch/semaphore.h> |
| #include <synch/synch.h> |
| typedef enum { |
| MUTEX_PASSIVE, |
| MUTEX_ACTIVE |
| } mutex_type_t; |
| typedef struct { |
| mutex_type_t type; |
| semaphore_t sem; |
| } mutex_t; |
| #define mutex_lock(mtx) \ |
| #define mutex_lock(mtx) \ |
| _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE) |
| #define mutex_trylock(mtx) \ |
| #define mutex_trylock(mtx) \ |
| _mutex_lock_timeout((mtx), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING) |
| #define mutex_lock_timeout(mtx, usec) \ |
| #define mutex_lock_timeout(mtx, usec) \ |
| _mutex_lock_timeout((mtx), (usec), SYNCH_FLAGS_NON_BLOCKING) |
| extern void mutex_initialize(mutex_t *mtx); |
| extern int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags); |
| extern void mutex_unlock(mutex_t *mtx); |
| extern void mutex_initialize(mutex_t *, mutex_type_t); |
| extern int _mutex_lock_timeout(mutex_t *, uint32_t, int); |
| extern void mutex_unlock(mutex_t *); |
| #endif |
| /branches/tracing/kernel/generic/include/synch/smc.h |
|---|
| 0,0 → 1,43 |
| /* |
| * 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 sync |
| * @{ |
| */ |
| /** @file |
| */ |
| #ifndef KERN_SMC_H_ |
| #define KERN_SMC_H_ |
| extern unative_t sys_smc_coherence(uintptr_t va, size_t size); |
| #endif |
| /** @} |
| */ |
| /branches/tracing/kernel/generic/include/mm/frame.h |
|---|
| 57,15 → 57,14 |
| /** Maximum number of zones in system. */ |
| #define ZONES_MAX 16 |
| /** If possible, merge with neighbouring zones. */ |
| #define ZONE_JOIN 0x1 |
| /** Convert the frame address to kernel va. */ |
| #define FRAME_KA 0x1 |
| /** Do not panic and do not sleep on failure. */ |
| #define FRAME_ATOMIC 0x2 |
| #define FRAME_ATOMIC 0x2 |
| /** Do not start reclaiming when no free memory. */ |
| #define FRAME_NO_RECLAIM 0x4 |
| #define FRAME_NO_RECLAIM 0x4 |
| /** Do not allocate above 4 GiB. */ |
| #define FRAME_LOW_4_GiB 0x8 |
| static inline uintptr_t PFN2ADDR(pfn_t frame) |
| { |
| 90,30 → 89,30 |
| } |
| #define IS_BUDDY_ORDER_OK(index, order) \ |
| ((~(((unative_t) -1) << (order)) & (index)) == 0) |
| ((~(((unative_t) -1) << (order)) & (index)) == 0) |
| #define IS_BUDDY_LEFT_BLOCK(zone, frame) \ |
| (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0) |
| (((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) |
| (((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) |
| (((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) |
| (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1) |
| #define frame_alloc(order, flags) \ |
| frame_alloc_generic(order, flags, NULL) |
| frame_alloc_generic(order, flags, NULL) |
| extern void frame_init(void); |
| extern void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone); |
| extern void frame_free(uintptr_t frame); |
| extern void frame_reference_add(pfn_t pfn); |
| extern void *frame_alloc_generic(uint8_t, int, unsigned int *); |
| extern void frame_free(uintptr_t); |
| extern void frame_reference_add(pfn_t); |
| extern int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags); |
| extern void *frame_get_parent(pfn_t frame, unsigned int hint); |
| extern void frame_set_parent(pfn_t frame, void *data, unsigned int hint); |
| extern void frame_mark_unavailable(pfn_t start, count_t count); |
| extern uintptr_t zone_conf_size(count_t count); |
| extern void zone_merge(unsigned int z1, unsigned int z2); |
| 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 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 void zone_merge_all(void); |
| extern uint64_t zone_total_size(void); |
| 121,7 → 120,7 |
| * Console functions |
| */ |
| extern void zone_print_list(void); |
| extern void zone_print_one(unsigned int znum); |
| extern void zone_print_one(unsigned int); |
| #endif |
| /branches/tracing/kernel/generic/include/mm/page.h |
|---|
| 39,11 → 39,6 |
| #include <mm/as.h> |
| #include <memstr.h> |
| /** |
| * Macro for computing page color. |
| */ |
| #define PAGE_COLOR(va) (((va) >> PAGE_WIDTH) & ((1 << PAGE_COLOR_BITS) - 1)) |
| /** Operations to manipulate page mappings. */ |
| typedef struct { |
| void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame, |
| /branches/tracing/kernel/generic/include/mm/slab.h |
|---|
| 53,7 → 53,8 |
| #define SLAB_INSIDE_SIZE (PAGE_SIZE >> 3) |
| /** Maximum wasted space we allow for cache */ |
| #define SLAB_MAX_BADNESS(cache) (((unsigned int) PAGE_SIZE << (cache)->order) >> 2) |
| #define SLAB_MAX_BADNESS(cache) \ |
| (((unsigned int) PAGE_SIZE << (cache)->order) >> 2) |
| /* slab_reclaim constants */ |
| 99,7 → 100,7 |
| int flags; |
| /* Computed values */ |
| uint8_t order; /**< Order of frames to be allocated */ |
| uint8_t order; /**< Order of frames to be allocated */ |
| unsigned int objects; /**< Number of objects that fit in */ |
| /* Statistics */ |
| 121,14 → 122,13 |
| slab_mag_cache_t *mag_cache; |
| } slab_cache_t; |
| extern slab_cache_t * slab_cache_create(char *name, size_t size, size_t align, |
| int (*constructor)(void *obj, int kmflag), int (*destructor)(void *obj), |
| int flags); |
| extern void slab_cache_destroy(slab_cache_t *cache); |
| extern slab_cache_t *slab_cache_create(char *, size_t, size_t, |
| int (*)(void *, int), int (*)(void *), int); |
| extern void slab_cache_destroy(slab_cache_t *); |
| extern void * slab_alloc(slab_cache_t *cache, int flags); |
| extern void slab_free(slab_cache_t *cache, void *obj); |
| extern count_t slab_reclaim(int flags); |
| extern void * slab_alloc(slab_cache_t *, int); |
| extern void slab_free(slab_cache_t *, void *); |
| extern count_t slab_reclaim(int); |
| /* slab subsytem initialization */ |
| extern void slab_cache_init(void); |
| 138,9 → 138,9 |
| extern void slab_print_list(void); |
| /* malloc support */ |
| extern void * malloc(unsigned int size, int flags); |
| extern void * realloc(void *ptr, unsigned int size, int flags); |
| extern void free(void *ptr); |
| extern void *malloc(unsigned int, int); |
| extern void *realloc(void *, unsigned int, int); |
| extern void free(void *); |
| #endif |
| /** @} |
| /branches/tracing/kernel/generic/include/mm/as.h |
|---|
| 53,10 → 53,6 |
| #include <adt/btree.h> |
| #include <lib/elf.h> |
| #ifdef __OBJC__ |
| #include <lib/objc.h> |
| #endif |
| /** |
| * Defined to be true if user address space and kernel address space shadow each |
| * other. |
| 84,47 → 80,6 |
| /** The page fault was caused by memcpy_from_uspace() or memcpy_to_uspace(). */ |
| #define AS_PF_DEFER 2 |
| #ifdef __OBJC__ |
| @interface as_t : base_t { |
| @public |
| /** Protected by asidlock. */ |
| link_t inactive_as_with_asid_link; |
| /** |
| * Number of processors on wich is this address space active. |
| * Protected by asidlock. |
| */ |
| count_t cpu_refcount; |
| /** |
| * Address space identifier. |
| * Constant on architectures that do not support ASIDs. |
| * Protected by asidlock. |
| */ |
| asid_t asid; |
| /** Number of references (i.e tasks that reference this as). */ |
| atomic_t refcount; |
| mutex_t lock; |
| /** B+tree of address space areas. */ |
| btree_t as_area_btree; |
| /** Non-generic content. */ |
| as_genarch_t genarch; |
| /** Architecture specific content. */ |
| as_arch_t arch; |
| } |
| + (pte_t *) page_table_create: (int) flags; |
| + (void) page_table_destroy: (pte_t *) page_table; |
| - (void) page_table_lock: (bool) _lock; |
| - (void) page_table_unlock: (bool) unlock; |
| @end |
| #else |
| /** Address space structure. |
| * |
| * as_t contains the list of as_areas of userspace accessible |
| 168,7 → 123,6 |
| void (* page_table_lock)(as_t *as, bool lock); |
| void (* page_table_unlock)(as_t *as, bool unlock); |
| } as_operations_t; |
| #endif |
| /** |
| * This structure contains information associated with the shared address space |
| 249,10 → 203,7 |
| extern as_t *AS_KERNEL; |
| #ifndef __OBJC__ |
| extern as_operations_t *as_operations; |
| #endif |
| extern link_t inactive_as_with_asid_head; |
| extern void as_init(void); |
| 269,6 → 220,7 |
| extern int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags); |
| int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size, |
| as_t *dst_as, uintptr_t dst_base, int dst_flags_mask); |
| extern int as_area_change_flags(as_t *as, int flags, uintptr_t address); |
| extern int as_area_get_flags(as_area_t *area); |
| extern bool as_area_check_access(as_area_t *area, pf_access_t access); |
| 301,11 → 253,19 |
| extern mem_backend_t elf_backend; |
| extern mem_backend_t phys_backend; |
| extern unsigned int elf_load(elf_header_t *header, as_t *as); |
| /** |
| * This flags is passed when running the loader, otherwise elf_load() |
| * would return with a EE_LOADER error code. |
| */ |
| #define ELD_F_NONE 0 |
| #define ELD_F_LOADER 1 |
| extern unsigned int elf_load(elf_header_t *header, as_t *as, int flags); |
| /* Address space area related syscalls. */ |
| extern unative_t sys_as_area_create(uintptr_t address, size_t size, int flags); |
| extern unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags); |
| extern unative_t sys_as_area_change_flags(uintptr_t address, int flags); |
| extern unative_t sys_as_area_destroy(uintptr_t address); |
| /* Introspection functions. */ |
| /branches/tracing/kernel/generic/include/mm/buddy.h |
|---|
| 66,7 → 66,6 |
| void (*mark_available)(struct buddy_system *, link_t *); |
| /** Find parent of block that has given order */ |
| link_t *(* find_block)(struct buddy_system *, link_t *, uint8_t); |
| void (* print_id)(struct buddy_system *, link_t *); |
| } buddy_system_operations_t; |
| typedef struct buddy_system { |
| 78,14 → 77,13 |
| void *data; |
| } buddy_system_t; |
| extern void buddy_system_create(buddy_system_t *b, uint8_t max_order, |
| buddy_system_operations_t *op, void *data); |
| extern link_t *buddy_system_alloc(buddy_system_t *b, uint8_t i); |
| extern bool buddy_system_can_alloc(buddy_system_t *b, uint8_t order); |
| extern void buddy_system_free(buddy_system_t *b, link_t *block); |
| extern void buddy_system_structure_print(buddy_system_t *b, size_t elem_size); |
| extern size_t buddy_conf_size(int max_order); |
| extern link_t *buddy_system_alloc_block(buddy_system_t *b, link_t *block); |
| extern void buddy_system_create(buddy_system_t *, uint8_t, |
| buddy_system_operations_t *, void *); |
| 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 link_t *buddy_system_alloc_block(buddy_system_t *, link_t *); |
| #endif |
| /branches/tracing/kernel/generic/include/macros.h |
|---|
| 40,20 → 40,20 |
| #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 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')) |
| ((c) == '\r')) |
| #define min(a,b) ((a) < (b) ? (a) : (b)) |
| #define max(a,b) ((a) > (b) ? (a) : (b)) |
| /** Return true if the interlvals overlap. |
| /** 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) |
| { |
| 64,11 → 64,15 |
| } |
| /* Compute overlapping of physical addresses */ |
| #define PA_overlaps(x, szx, y, szy) overlaps(KA2PA(x), szx, KA2PA(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 STRING(arg) STRING_ARG(arg) |
| #define STRING_ARG(arg) #arg |
| /branches/tracing/kernel/generic/include/syscall/syscall.h |
|---|
| 44,13 → 44,15 |
| SYS_THREAD_GET_ID, |
| SYS_TASK_GET_ID, |
| SYS_TASK_SPAWN, |
| SYS_PROGRAM_SPAWN_LOADER, |
| SYS_FUTEX_SLEEP, |
| SYS_FUTEX_WAKEUP, |
| SYS_SMC_COHERENCE, |
| SYS_AS_AREA_CREATE, |
| SYS_AS_AREA_RESIZE, |
| SYS_AS_AREA_CHANGE_FLAGS, |
| SYS_AS_AREA_DESTROY, |
| SYS_IPC_CALL_SYNC_FAST, |
| /branches/tracing/kernel/generic/include/ipc/ipc.h |
|---|
| 287,27 → 287,33 |
| /** 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); |
| extern call_t * ipc_wait_for_call(answerbox_t *box, uint32_t usec, int flags); |
| extern void ipc_answer(answerbox_t *box, call_t *request); |
| extern int ipc_call(phone_t *phone, call_t *call); |
| extern void ipc_call_sync(phone_t *phone, call_t *request); |
| extern void ipc_phone_init(phone_t *phone); |
| extern void ipc_phone_connect(phone_t *phone, answerbox_t *box); |
| extern void ipc_call_free(call_t *call); |
| extern call_t * ipc_call_alloc(int flags); |
| extern void ipc_answerbox_init(answerbox_t *box, struct task *task); |
| extern void ipc_call_static_init(call_t *call); |
| extern call_t * ipc_wait_for_call(answerbox_t *, uint32_t, int); |
| extern void ipc_answer(answerbox_t *, call_t *); |
| extern int ipc_call(phone_t *, call_t *); |
| extern int ipc_call_sync(phone_t *, call_t *); |
| extern void ipc_phone_init(phone_t *); |
| extern void ipc_phone_connect(phone_t *, answerbox_t *); |
| extern void ipc_call_free(call_t *); |
| extern call_t * ipc_call_alloc(int); |
| extern void ipc_answerbox_init(answerbox_t *, struct task *); |
| extern void ipc_call_static_init(call_t *); |
| extern void task_print_list(void); |
| extern int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox, |
| int mode); |
| extern int ipc_forward(call_t *, phone_t *, answerbox_t *, int); |
| extern void ipc_cleanup(void); |
| extern int ipc_phone_hangup(phone_t *phone); |
| extern void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err); |
| extern void ipc_print_task(task_id_t taskid); |
| extern int ipc_connect_kbox(task_id_t taskid); |
| 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 int ipc_connect_kbox(task_id_t); |
| extern answerbox_t *ipc_phone_0; |
| /branches/tracing/kernel/generic/include/errno.h |
|---|
| 56,6 → 56,7 |
| #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. */ |
| #endif |