HelenOS-historicHelenOSHelenOS-doc

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /kernel/trunk/generic @ 1767

  → /kernel/trunk/generic @ 1780

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Ignore whitespace Rev 1767 → Rev 1780

/kernel/trunk/generic/include/func.h
46,7 → 46,7
extern size_t strlen(const char *str);
extern int strncmp(const char *src, const char *dst, size_t len);
extern void strncpy(char *dest, const char *src, size_t len);
extern __native atoi(const char *text);
extern unative_t atoi(const char *text);
#endif

/kernel/trunk/generic/include/stackarg.h
45,12 → 45,12
typedef struct va_list {
int pos;
__u8 *last;
uint8_t *last;
} va_list;
#define va_start(ap, lst) \
(ap).pos = sizeof(lst); \
(ap).last = (__u8 *) &(lst)
(ap).last = (uint8_t *) &(lst)
#define va_arg(ap, type) \
(*((type *)((ap).last + ((ap).pos += sizeof(type) ) - sizeof(type))))

/kernel/trunk/generic/include/byteorder.h
35,7 → 35,7
#ifndef __BYTEORDER_H__
#define __BYTEORDER_H__
static inline __u64 __u64_byteorder_swap(__u64 n)
static inline uint64_t uint64_t_byteorder_swap(uint64_t n)
{
return ((n & 0xff) << 56) |
((n & 0xff00) << 40) |
47,7 → 47,7
((n & 0xff00000000000000LL) >> 56);
}
static inline __u32 __u32_byteorder_swap(__u32 n)
static inline uint32_t uint32_t_byteorder_swap(uint32_t n)
{
return ((n & 0xff) << 24) |
((n & 0xff00) << 8) |

/kernel/trunk/generic/include/symtab.h
40,12 → 40,12
#define MAX_SYMBOL_NAME 64
struct symtab_entry {
__u64 address_le;
uint64_t address_le;
char symbol_name[MAX_SYMBOL_NAME];
};
extern char * get_symtab_entry(__native addr);
extern __address get_symbol_addr(const char *name);
extern char * get_symtab_entry(unative_t addr);
extern uintptr_t get_symbol_addr(const char *name);
extern void symtab_print_search(const char *name);
extern int symtab_compl(char *name);

/kernel/trunk/generic/include/sysinfo/sysinfo.h
36,7 → 36,7
typedef union sysinfo_item_val
{
__native val;
unative_t val;
void *fn;
}sysinfo_item_val_t;
45,7 → 45,7
char *name;
union
{
__native val;
unative_t val;
void *fn;
}val;
69,16 → 69,16
#define SYSINFO_SUBINFO_FUNCTION 2
typedef __native (*sysinfo_val_fn_t)(sysinfo_item_t *root);
typedef __native (*sysinfo_subinfo_fn_t)(const char *subname);
typedef unative_t (*sysinfo_val_fn_t)(sysinfo_item_t *root);
typedef unative_t (*sysinfo_subinfo_fn_t)(const char *subname);
typedef struct sysinfo_rettype
{
__native val;
__native valid;
unative_t val;
unative_t valid;
}sysinfo_rettype_t;
void sysinfo_set_item_val(const char *name,sysinfo_item_t **root,__native val);
void sysinfo_set_item_val(const char *name,sysinfo_item_t **root,unative_t val);
void sysinfo_dump(sysinfo_item_t **root,int depth);
void sysinfo_set_item_function(const char *name,sysinfo_item_t **root,sysinfo_val_fn_t fn);
void sysinfo_set_item_undefined(const char *name,sysinfo_item_t **root);
85,8 → 85,8
sysinfo_rettype_t sysinfo_get_val(const char *name,sysinfo_item_t **root);
__native sys_sysinfo_valid(__native ptr,__native len);
__native sys_sysinfo_value(__native ptr,__native len);
unative_t sys_sysinfo_valid(unative_t ptr,unative_t len);
unative_t sys_sysinfo_value(unative_t ptr,unative_t len);

/kernel/trunk/generic/include/config.h
46,7 → 46,7
#define CONFIG_INIT_TASKS 32
typedef struct {
__address addr;
uintptr_t addr;
size_t size;
} init_task_t;
59,7 → 59,7
count_t cpu_count; /**< Number of processors detected. */
volatile count_t cpu_active; /**< Number of processors that are up and running. */
__address base;
uintptr_t base;
size_t memory_size; /**< Size of detected memory in bytes. */
size_t kernel_size; /**< Size of memory in bytes taken by kernel and stack */
} config_t;

/kernel/trunk/generic/include/elf.h
193,11 → 193,11
* ELF object file specifications. They are the only types used
* in ELF header.
*/
typedef __u64 elf_xword;
typedef __s64 elf_sxword;
typedef __u32 elf_word;
typedef __s32 elf_sword;
typedef __u16 elf_half;
typedef uint64_t elf_xword;
typedef int64_t elf_sxword;
typedef uint32_t elf_word;
typedef int32_t elf_sword;
typedef uint16_t elf_half;
/**
* 32-bit ELF data types.
204,8 → 204,8
*
* These types are specific for 32-bit format.
*/
typedef __u32 elf32_addr;
typedef __u32 elf32_off;
typedef uint32_t elf32_addr;
typedef uint32_t elf32_off;
/**
* 64-bit ELF data types.
212,12 → 212,12
*
* These types are specific for 64-bit format.
*/
typedef __u64 elf64_addr;
typedef __u64 elf64_off;
typedef uint64_t elf64_addr;
typedef uint64_t elf64_off;
/** ELF header */
struct elf32_header {
__u8 e_ident[EI_NIDENT];
uint8_t e_ident[EI_NIDENT];
elf_half e_type;
elf_half e_machine;
elf_word e_version;
233,7 → 233,7
elf_half e_shstrndx;
};
struct elf64_header {
__u8 e_ident[EI_NIDENT];
uint8_t e_ident[EI_NIDENT];
elf_half e_type;
elf_half e_machine;
elf_word e_version;
309,14 → 309,14
elf_word st_name;
elf32_addr st_value;
elf_word st_size;
__u8 st_info;
__u8 st_other;
uint8_t st_info;
uint8_t st_other;
elf_half st_shndx;
};
struct elf64_symbol {
elf_word st_name;
__u8 st_info;
__u8 st_other;
uint8_t st_info;
uint8_t st_other;
elf_half st_shndx;
elf64_addr st_value;
elf_xword st_size;

/kernel/trunk/generic/include/time/delay.h
37,7 → 37,7
#include <arch/types.h>
extern void delay(__u32 microseconds);
extern void delay(uint32_t microseconds);
#endif

/kernel/trunk/generic/include/time/timeout.h
40,7 → 40,7
#include <synch/spinlock.h>
#include <adt/list.h>
#define us2ticks(us) ((__u64)(((__u32) (us)/(1000000/HZ))))
#define us2ticks(us) ((uint64_t)(((uint32_t) (us)/(1000000/HZ))))
typedef void (* timeout_handler_t)(void *arg);
49,7 → 49,7
link_t link; /**< Link to the list of active timeouts on THE->cpu */
__u64 ticks; /**< Timeout will be activated in this amount of clock() ticks. */
uint64_t ticks; /**< Timeout will be activated in this amount of clock() ticks. */
timeout_handler_t handler; /**< Function that will be called on timeout activation. */
void *arg; /**< Argument to be passed to handler() function. */
60,7 → 60,7
extern void timeout_init(void);
extern void timeout_initialize(timeout_t *t);
extern void timeout_reinitialize(timeout_t *t);
extern void timeout_register(timeout_t *t, __u64 usec, timeout_handler_t f, void *arg);
extern void timeout_register(timeout_t *t, uint64_t usec, timeout_handler_t f, void *arg);
extern bool timeout_unregister(timeout_t *t);
#endif

/kernel/trunk/generic/include/proc/task.h
102,7 → 102,7
extern void task_destroy_arch(task_t *t);
#endif
extern __native sys_task_get_id(task_id_t *uspace_task_id);
extern unative_t sys_task_get_id(task_id_t *uspace_task_id);
#endif

/kernel/trunk/generic/include/proc/thread.h
142,14 → 142,14
cpu_t *cpu; /**< Thread's CPU. */
task_t *task; /**< Containing task. */
__u64 ticks; /**< Ticks before preemption. */
uint64_t ticks; /**< Ticks before preemption. */
int priority; /**< Thread's priority. Implemented as index to CPU->rq */
__u32 tid; /**< Thread ID. */
uint32_t tid; /**< Thread ID. */
thread_arch_t arch; /**< Architecture-specific data. */
__u8 *kstack; /**< Thread's kernel stack. */
uint8_t *kstack; /**< Thread's kernel stack. */
};
/** Thread list lock.
171,11 → 171,11
extern void thread_create_arch(thread_t *t);
#endif
extern void thread_sleep(__u32 sec);
extern void thread_usleep(__u32 usec);
extern void thread_sleep(uint32_t sec);
extern void thread_usleep(uint32_t usec);
#define thread_join(t) thread_join_timeout((t), SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE)
extern int thread_join_timeout(thread_t *t, __u32 usec, int flags);
extern int thread_join_timeout(thread_t *t, uint32_t usec, int flags);
extern void thread_detach(thread_t *t);
extern void thread_register_call_me(void (* call_me)(void *), void *call_me_with);
187,8 → 187,8
extern slab_cache_t *fpu_context_slab;
/** Thread syscall prototypes. */
__native sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name);
__native sys_thread_exit(int uspace_status);
unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name);
unative_t sys_thread_exit(int uspace_status);
#endif

/kernel/trunk/generic/include/debug.h
38,11 → 38,11
#include <panic.h>
#include <arch/debug.h>
#define CALLER ((__address)__builtin_return_address(0))
#define CALLER ((uintptr_t)__builtin_return_address(0))
#ifndef HERE
/** Current Instruction Pointer address */
# define HERE ((__address *)0)
# define HERE ((uintptr_t *)0)
#endif
/** Debugging ASSERT macro
55,7 → 55,7
*
*/
#ifdef CONFIG_DEBUG
# define ASSERT(expr) if (!(expr)) { panic("assertion failed (%s), caller=%.*p\n", #expr, sizeof(__address) * 2, CALLER); }
# define ASSERT(expr) if (!(expr)) { panic("assertion failed (%s), caller=%.*p\n", #expr, sizeof(uintptr_t) * 2, CALLER); }
#else
# define ASSERT(expr)
#endif

/kernel/trunk/generic/include/cpu.h
80,8 → 80,8
int active;
int tlb_active;
__u16 frequency_mhz;
__u32 delay_loop_const;
uint16_t frequency_mhz;
uint32_t delay_loop_const;
cpu_arch_t arch;
90,7 → 90,7
/**
* Stack used by scheduler when there is no running thread.
*/
__u8 *stack;
uint8_t *stack;
};
extern cpu_t *cpus;

/kernel/trunk/generic/include/synch/futex.h
26,7 → 26,7
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup sync
/** @addtogroup sync
* @{
*/
/** @file
43,7 → 43,7
/** Kernel-side futex structure. */
struct futex {
__address paddr; /**< Physical address of the status variable. */
uintptr_t paddr; /**< Physical address of the status variable. */
waitq_t wq; /**< Wait queue for threads waiting for futex availability. */
link_t ht_link; /**< Futex hash table link. */
count_t refcount; /**< Number of tasks that reference this futex. */
50,13 → 50,13
};
extern void futex_init(void);
extern __native sys_futex_sleep_timeout(__address uaddr, __u32 usec, int flags);
extern __native sys_futex_wakeup(__address uaddr);
extern unative_t sys_futex_sleep_timeout(uintptr_t uaddr, uint32_t usec, int flags);
extern unative_t sys_futex_wakeup(uintptr_t uaddr);
extern void futex_cleanup(void);
#endif
/** @}
/** @}
*/

/kernel/trunk/generic/include/synch/condvar.h
52,7 → 52,7
extern void condvar_initialize(condvar_t *cv);
extern void condvar_signal(condvar_t *cv);
extern void condvar_broadcast(condvar_t *cv);
extern int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, __u32 usec, int flags);
extern int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags);
#endif

/kernel/trunk/generic/include/synch/rwlock.h
69,8 → 69,8
extern void rwlock_initialize(rwlock_t *rwl);
extern void rwlock_read_unlock(rwlock_t *rwl);
extern void rwlock_write_unlock(rwlock_t *rwl);
extern int _rwlock_read_lock_timeout(rwlock_t *rwl, __u32 usec, int flags);
extern int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int flags);
extern int _rwlock_read_lock_timeout(rwlock_t *rwl, uint32_t usec, int flags);
extern int _rwlock_write_lock_timeout(rwlock_t *rwl, uint32_t usec, int flags);
#endif

/kernel/trunk/generic/include/synch/mutex.h
54,7 → 54,7
while (mutex_trylock((mtx)) != ESYNCH_OK_ATOMIC)
extern void mutex_initialize(mutex_t *mtx);
extern int _mutex_lock_timeout(mutex_t *mtx, __u32 usec, int flags);
extern int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags);
extern void mutex_unlock(mutex_t *mtx);
#endif

/kernel/trunk/generic/include/synch/semaphore.h
53,7 → 53,7
_semaphore_down_timeout((s),(usec),SYNCH_FLAGS_NONE)
extern void semaphore_initialize(semaphore_t *s, int val);
extern int _semaphore_down_timeout(semaphore_t *s, __u32 usec, int flags);
extern int _semaphore_down_timeout(semaphore_t *s, uint32_t usec, int flags);
extern void semaphore_up(semaphore_t *s);
#endif

/kernel/trunk/generic/include/synch/waitq.h
61,9 → 61,9
waitq_sleep_timeout((wq),SYNCH_NO_TIMEOUT,SYNCH_FLAGS_NONE)
extern void waitq_initialize(waitq_t *wq);
extern int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int flags);
extern int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, int flags);
extern ipl_t waitq_sleep_prepare(waitq_t *wq);
extern int waitq_sleep_timeout_unsafe(waitq_t *wq, __u32 usec, int flags);
extern int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, int flags);
extern void waitq_sleep_finish(waitq_t *wq, int rc, ipl_t ipl);
extern void waitq_wakeup(waitq_t *wq, bool all);
extern void _waitq_wakeup_unsafe(waitq_t *wq, bool all);

/kernel/trunk/generic/include/bitops.h
42,7 → 42,7
*
* If number is zero, it returns 0
*/
static inline int fnzb32(__u32 arg)
static inline int fnzb32(uint32_t arg)
{
int n = 0;
54,12 → 54,12
return n;
}
static inline int fnzb64(__u64 arg)
static inline int fnzb64(uint64_t arg)
{
int n = 0;
if (arg >> 32) { arg >>= 32;n += 32;}
return n + fnzb32((__u32) arg);
return n + fnzb32((uint32_t) arg);
}
#define fnzb(x) fnzb32(x)

/kernel/trunk/generic/include/memstr.h
43,8 → 43,8
* Architecture independent variants.
*/
extern void *_memcpy(void *dst, const void *src, size_t cnt);
extern void _memsetb(__address dst, size_t cnt, __u8 x);
extern void _memsetw(__address dst, size_t cnt, __u16 x);
extern void _memsetb(uintptr_t dst, size_t cnt, uint8_t x);
extern void _memsetw(uintptr_t dst, size_t cnt, uint16_t x);
#endif

/kernel/trunk/generic/include/ddi/ddi.h
39,15 → 39,15
#include <arch/types.h>
#include <typedefs.h>
__native sys_physmem_map(__native phys_base, __native virt_base, __native pages,
__native flags);
extern __native sys_iospace_enable(ddi_ioarg_t *uspace_io_arg);
extern __native sys_preempt_control(int enable);
unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base, unative_t pages,
unative_t flags);
extern unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg);
extern unative_t sys_preempt_control(int enable);
/*
* Interface to be implemented by all architectures.
*/
extern int ddi_iospace_enable_arch(task_t *task, __address ioaddr, size_t size);
extern int ddi_iospace_enable_arch(task_t *task, uintptr_t ioaddr, size_t size);
#endif

/kernel/trunk/generic/include/console/chardev.h
59,7 → 59,7
waitq_t wq;
SPINLOCK_DECLARE(lock); /**< Protects everything below. */
__u8 buffer[CHARDEV_BUFLEN];
uint8_t buffer[CHARDEV_BUFLEN];
count_t counter;
chardev_operations_t *op; /**< Implementation of chardev operations. */
index_t index;
69,7 → 69,7
extern void chardev_initialize(char *name,
chardev_t *chardev,
chardev_operations_t *op);
extern void chardev_push_character(chardev_t *chardev, __u8 ch);
extern void chardev_push_character(chardev_t *chardev, uint8_t ch);
#endif /* __CHARDEV_H__ */

/kernel/trunk/generic/include/console/kconsole.h
54,7 → 54,7
cmd_arg_type_t type; /**< Type descriptor. */
void *buffer; /**< Buffer where to store data. */
size_t len; /**< Size of the buffer. */
__native intval; /**< Integer value */
unative_t intval; /**< Integer value */
cmd_arg_type_t vartype; /**< Resulting type of variable arg */
};

/kernel/trunk/generic/include/console/console.h
41,8 → 41,8
extern chardev_t *stdin;
extern chardev_t *stdout;
extern __u8 getc(chardev_t *chardev);
__u8 _getc(chardev_t *chardev);
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);

/kernel/trunk/generic/include/security/cap.h
79,13 → 79,13
*/
#define CAP_IRQ_REG (1<<4)
typedef __u32 cap_t;
typedef uint32_t cap_t;
extern void cap_set(task_t *t, cap_t caps);
extern cap_t cap_get(task_t *t);
extern __native sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps);
extern __native sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps);
extern unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps);
extern unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps);
#endif

/kernel/trunk/generic/include/adt/hash_table.h
55,7 → 55,7
*
* @return Index into hash table.
*/
index_t (* hash)(__native key[]);
index_t (* hash)(unative_t key[]);
/** Hash table item comparison function.
*
63,7 → 63,7
*
* @return true if the keys match, false otherwise.
*/
bool (*compare)(__native key[], count_t keys, link_t *item);
bool (*compare)(unative_t key[], count_t keys, link_t *item);
/** Hash table item removal callback.
*
75,9 → 75,9
#define hash_table_get_instance(item, type, member) list_get_instance((item), type, member)
extern void hash_table_create(hash_table_t *h, count_t m, count_t max_keys, hash_table_operations_t *op);
extern void hash_table_insert(hash_table_t *h, __native key[], link_t *item);
extern link_t *hash_table_find(hash_table_t *h, __native key[]);
extern void hash_table_remove(hash_table_t *h, __native key[], count_t keys);
extern void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item);
extern link_t *hash_table_find(hash_table_t *h, unative_t key[]);
extern void hash_table_remove(hash_table_t *h, unative_t key[], count_t keys);
#endif

/kernel/trunk/generic/include/adt/list.h
175,7 → 175,7
headless_list_split_or_concat(part1, part2);
}
#define list_get_instance(link,type,member) (type *)(((__u8*)(link))-((__u8*)&(((type *)NULL)->member)))
#define list_get_instance(link,type,member) (type *)(((uint8_t*)(link))-((uint8_t*)&(((type *)NULL)->member)))
extern bool list_member(const link_t *link, const link_t *head);
extern void list_concat(link_t *head1, link_t *head2);

/kernel/trunk/generic/include/adt/bitmap.h
41,11 → 41,11
#define BITS2BYTES(bits) (bits ? ((((bits)-1)>>3)+1) : 0)
typedef struct {
__u8 *map;
uint8_t *map;
count_t bits;
} bitmap_t;
extern void bitmap_initialize(bitmap_t *bitmap, __u8 *map, count_t bits);
extern void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, count_t bits);
extern void bitmap_set_range(bitmap_t *bitmap, index_t start, count_t bits);
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);

/kernel/trunk/generic/include/adt/btree.h
42,7 → 42,7
#define BTREE_M 5
#define BTREE_MAX_KEYS (BTREE_M - 1)
typedef __u64 btree_key_t;
typedef uint64_t btree_key_t;
/** B-tree node structure. */
struct btree_node {

/kernel/trunk/generic/include/mm/frame.h
65,12 → 65,12
#define FRAME_NO_MEMORY 1 /* frame_alloc return status */
#define FRAME_ERROR 2 /* frame_alloc return status */
static inline __address PFN2ADDR(pfn_t frame)
static inline uintptr_t PFN2ADDR(pfn_t frame)
{
return (__address)(frame << FRAME_WIDTH);
return (uintptr_t)(frame << FRAME_WIDTH);
}
static inline pfn_t ADDR2PFN(__address addr)
static inline pfn_t ADDR2PFN(uintptr_t addr)
{
return (pfn_t)(addr >> FRAME_WIDTH);
}
82,7 → 82,7
return (count_t)((size-1) >> FRAME_WIDTH)+1;
}
#define IS_BUDDY_ORDER_OK(index, order) ((~(((__native) -1) << (order)) & (index)) == 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)
91,8 → 91,8
#define frame_alloc(order, flags) frame_alloc_generic(order, flags, NULL)
extern void frame_init(void);
extern void * frame_alloc_generic(__u8 order, int flags, int *pzone);
extern void frame_free(__address frame);
extern void * frame_alloc_generic(uint8_t order, int flags, int *pzone);
extern void frame_free(uintptr_t frame);
extern void frame_reference_add(pfn_t pfn);
extern int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags);
99,7 → 99,7
void * frame_get_parent(pfn_t frame, int hint);
void frame_set_parent(pfn_t frame, void *data, int hint);
void frame_mark_unavailable(pfn_t start, count_t count);
__address zone_conf_size(count_t count);
uintptr_t zone_conf_size(count_t count);
void zone_merge(int z1, int z2);
void zone_merge_all(void);

/kernel/trunk/generic/include/mm/page.h
76,9 → 76,9
/** Operations to manipulate page mappings. */
struct page_mapping_operations {
void (* mapping_insert)(as_t *as, __address page, __address frame, int flags);
void (* mapping_remove)(as_t *as, __address page);
pte_t *(* mapping_find)(as_t *as, __address page);
void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame, int flags);
void (* mapping_remove)(as_t *as, uintptr_t page);
pte_t *(* mapping_find)(as_t *as, uintptr_t page);
};
typedef struct page_mapping_operations page_mapping_operations_t;
87,13 → 87,13
extern void page_init(void);
extern void page_table_lock(as_t *as, bool lock);
extern void page_table_unlock(as_t *as, bool unlock);
extern void page_mapping_insert(as_t *as, __address page, __address frame, int flags);
extern void page_mapping_remove(as_t *as, __address page);
extern pte_t *page_mapping_find(as_t *as, __address page);
extern void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags);
extern void page_mapping_remove(as_t *as, uintptr_t page);
extern pte_t *page_mapping_find(as_t *as, uintptr_t page);
extern pte_t *page_table_create(int flags);
extern void page_table_destroy(pte_t *page_table);
extern void map_structure(__address s, size_t size);
extern __address hw_map(__address physaddr, size_t size);
extern void map_structure(uintptr_t s, size_t size);
extern uintptr_t hw_map(uintptr_t physaddr, size_t size);
#endif

/kernel/trunk/generic/include/mm/slab.h
90,7 → 90,7
int flags; /**< Flags changing behaviour of cache */
/* Computed values */
__u8 order; /**< Order of frames to be allocated */
uint8_t order; /**< Order of frames to be allocated */
int objects; /**< Number of objects that fit in */
/* Statistics */

/kernel/trunk/generic/include/mm/tlb.h
58,7 → 58,7
struct tlb_shootdown_msg {
tlb_invalidate_type_t type; /**< Message type. */
asid_t asid; /**< Address space identifier. */
__address page; /**< Page address. */
uintptr_t page; /**< Page address. */
count_t count; /**< Number of pages to invalidate. */
};
typedef struct tlb_shootdown_msg tlb_shootdown_msg_t;
66,7 → 66,7
extern void tlb_init(void);
#ifdef CONFIG_SMP
extern void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, __address page, count_t count);
extern void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, uintptr_t page, count_t count);
extern void tlb_shootdown_finalize(void);
extern void tlb_shootdown_ipi_recv(void);
#else
83,7 → 83,7
extern void tlb_invalidate_all(void);
extern void tlb_invalidate_asid(asid_t asid);
extern void tlb_invalidate_pages(asid_t asid, __address page, count_t cnt);
extern void tlb_invalidate_pages(asid_t asid, uintptr_t page, count_t cnt);
#endif
/** @}

/kernel/trunk/generic/include/mm/as.h
123,8 → 123,8
/** Address space area backend structure. */
typedef struct {
int (* page_fault)(as_area_t *area, __address addr, pf_access_t access);
void (* frame_free)(as_area_t *area, __address page, __address frame);
int (* page_fault)(as_area_t *area, uintptr_t addr, pf_access_t access);
void (* frame_free)(as_area_t *area, uintptr_t page, uintptr_t frame);
void (* share)(as_area_t *area);
} mem_backend_t;
135,7 → 135,7
elf_segment_header_t *segment;
};
struct { /**< phys_backend members */
__address base;
uintptr_t base;
count_t frames;
};
} mem_backend_data_t;
151,7 → 151,7
int flags; /**< Flags related to the memory represented by the address space area. */
int attributes; /**< Attributes related to the address space area itself. */
count_t pages; /**< Size of this area in multiples of PAGE_SIZE. */
__address base; /**< Base address of this area. */
uintptr_t base; /**< Base address of this area. */
btree_t used_space; /**< Map of used space. */
share_info_t *sh_info; /**< If the address space area has been shared, this pointer will
reference the share info structure. */
172,20 → 172,20
extern as_t *as_create(int flags);
extern void as_destroy(as_t *as);
extern void as_switch(as_t *old, as_t *new);
extern int as_page_fault(__address page, pf_access_t access, istate_t *istate);
extern int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate);
extern as_area_t *as_area_create(as_t *as, int flags, size_t size, __address base, int attrs,
extern as_area_t *as_area_create(as_t *as, int flags, size_t size, uintptr_t base, int attrs,
mem_backend_t *backend, mem_backend_data_t *backend_data);
extern int as_area_destroy(as_t *as, __address address);
extern int as_area_resize(as_t *as, __address address, size_t size, int flags);
int as_area_share(as_t *src_as, __address src_base, size_t acc_size,
as_t *dst_as, __address dst_base, int dst_flags_mask);
extern int as_area_destroy(as_t *as, uintptr_t address);
extern int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags);
int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
as_t *dst_as, uintptr_t dst_base, int dst_flags_mask);
extern int as_area_get_flags(as_area_t *area);
extern bool as_area_check_access(as_area_t *area, pf_access_t access);
extern size_t as_get_size(__address base);
extern int used_space_insert(as_area_t *a, __address page, count_t count);
extern int used_space_remove(as_area_t *a, __address page, count_t count);
extern size_t as_get_size(uintptr_t base);
extern int used_space_insert(as_area_t *a, uintptr_t page, count_t count);
extern int used_space_remove(as_area_t *a, uintptr_t page, count_t count);
/* Interface to be implemented by architectures. */
#ifndef as_install_arch
198,9 → 198,9
extern mem_backend_t phys_backend;
/* Address space area related syscalls. */
extern __native sys_as_area_create(__address address, size_t size, int flags);
extern __native sys_as_area_resize(__address address, size_t size, int flags);
extern __native sys_as_area_destroy(__address address);
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_destroy(uintptr_t address);
#endif /* KERNEL */

/kernel/trunk/generic/include/mm/buddy.h
45,17 → 45,17
link_t *(* find_buddy)(buddy_system_t *, link_t *); /**< Return pointer to left-side or right-side buddy for block passed as argument. */
link_t *(* bisect)(buddy_system_t *, link_t *); /**< Bisect the block passed as argument and return pointer to the new right-side buddy. */
link_t *(* coalesce)(buddy_system_t *, link_t *, link_t *); /**< Coalesce two buddies into a bigger block. */
void (*set_order)(buddy_system_t *, link_t *, __u8); /**< Set order of block passed as argument. */
__u8 (*get_order)(buddy_system_t *, link_t *); /**< Return order of block passed as argument. */
void (*set_order)(buddy_system_t *, link_t *, uint8_t); /**< Set order of block passed as argument. */
uint8_t (*get_order)(buddy_system_t *, link_t *); /**< Return order of block passed as argument. */
void (*mark_busy)(buddy_system_t *, link_t *); /**< Mark block as busy. */
void (*mark_available)(buddy_system_t *, link_t *); /**< Mark block as available. */
/** Find parent of block that has given order */
link_t *(* find_block)(buddy_system_t *, link_t *, __u8);
link_t *(* find_block)(buddy_system_t *, link_t *, uint8_t);
void (* print_id)(buddy_system_t *, link_t *);
};
struct buddy_system {
__u8 max_order; /**< Maximal order of block which can be stored by buddy system. */
uint8_t max_order; /**< Maximal order of block which can be stored by buddy system. */
link_t *order;
buddy_system_operations_t *op;
void *data; /**< Pointer to be used by the implementation. */
62,10 → 62,10
};
extern void buddy_system_create(buddy_system_t *b,
__u8 max_order,
uint8_t max_order,
buddy_system_operations_t *op, void *data);
extern link_t *buddy_system_alloc(buddy_system_t *b, __u8 i);
extern bool buddy_system_can_alloc(buddy_system_t *b, __u8 order);
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);

/kernel/trunk/generic/include/macros.h
46,10 → 46,10
#define max(a,b) ((a)>(b)?(a):(b))
/** Return true if the interlvals overlap. */
static inline int overlaps(__address s1, size_t sz1, __address s2, size_t sz2)
static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2)
{
__address e1 = s1+sz1;
__address e2 = s2+sz2;
uintptr_t e1 = s1+sz1;
uintptr_t e2 = s2+sz2;
return s1 < e2 && s2 < e1;
}

/kernel/trunk/generic/include/context.h
42,8 → 42,8
#ifndef context_set
#define context_set(c, _pc, stack, size) \
(c)->pc = (__address) (_pc); \
(c)->sp = ((__address) (stack)) + (size) - SP_DELTA;
(c)->pc = (uintptr_t) (_pc); \
(c)->sp = ((uintptr_t) (stack)) + (size) - SP_DELTA;
#endif /* context_set */
extern int context_save_arch(context_t *c);

/kernel/trunk/generic/include/syscall/syscall.h
73,12 → 73,12
#include <arch/types.h>
#include <typedefs.h>
typedef __native (*syshandler_t)();
typedef unative_t (*syshandler_t)();
extern syshandler_t syscall_table[SYSCALL_END];
extern __native syscall_handler(__native a1, __native a2, __native a3,
__native a4, __native id);
extern __native sys_tls_set(__native addr);
extern unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
unative_t a4, unative_t id);
extern unative_t sys_tls_set(unative_t addr);
#endif

/kernel/trunk/generic/include/ipc/sysipc.h
39,22 → 39,22
#include <ipc/irq.h>
#include <arch/types.h>
__native sys_ipc_call_sync_fast(__native phoneid, __native method,
__native arg1, ipc_data_t *data);
__native sys_ipc_call_sync(__native phoneid, ipc_data_t *question,
unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
unative_t arg1, ipc_data_t *data);
unative_t sys_ipc_call_sync(unative_t phoneid, ipc_data_t *question,
ipc_data_t *reply);
__native sys_ipc_call_async_fast(__native phoneid, __native method,
__native arg1, __native arg2);
__native sys_ipc_call_async(__native phoneid, ipc_data_t *data);
__native sys_ipc_answer_fast(__native callid, __native retval,
__native arg1, __native arg2);
__native sys_ipc_answer(__native callid, ipc_data_t *data);
__native sys_ipc_wait_for_call(ipc_data_t *calldata, __u32 usec, int nonblocking);
__native sys_ipc_forward_fast(__native callid, __native phoneid,
__native method, __native arg1);
__native sys_ipc_hangup(int phoneid);
__native sys_ipc_register_irq(int irq, irq_code_t *ucode);
__native sys_ipc_unregister_irq(int irq);
unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
unative_t arg1, unative_t arg2);
unative_t sys_ipc_call_async(unative_t phoneid, ipc_data_t *data);
unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
unative_t arg1, unative_t arg2);
unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data);
unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int nonblocking);
unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
unative_t method, unative_t arg1);
unative_t sys_ipc_hangup(int phoneid);
unative_t sys_ipc_register_irq(int irq, irq_code_t *ucode);
unative_t sys_ipc_unregister_irq(int irq);
#endif

/kernel/trunk/generic/include/ipc/ipc.h
164,7 → 164,7
typedef struct answerbox_s answerbox_t;
typedef struct phone_s phone_t;
typedef struct {
__native args[IPC_CALL_LEN];
unative_t args[IPC_CALL_LEN];
phone_t *phone;
}ipc_data_t;
214,13 → 214,13
*/
answerbox_t *callerbox;
__native private; /**< Private data to internal IPC */
unative_t private; /**< Private data to internal IPC */
ipc_data_t data; /**< Data passed from/to userspace */
}call_t;
extern void ipc_init(void);
extern call_t * ipc_wait_for_call(answerbox_t *box, __u32 usec, int flags);
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);
234,7 → 234,7
extern int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox);
void ipc_cleanup(void);
int ipc_phone_hangup(phone_t *phone);
extern void ipc_backsend_err(phone_t *phone, call_t *call, __native err);
extern void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err);
extern void ipc_print_task(task_id_t taskid);
extern answerbox_t *ipc_phone_0;

/kernel/trunk/generic/include/ipc/irq.h
79,9 → 79,9
extern void ipc_irq_make_table(int irqcount);
extern int ipc_irq_register(answerbox_t *box, int irq, irq_code_t *ucode);
extern void ipc_irq_send_notif(int irq);
extern void ipc_irq_send_msg(int irq, __native a1, __native a2, __native a3);
extern void ipc_irq_send_msg(int irq, unative_t a1, unative_t a2, unative_t a3);
extern void ipc_irq_unregister(answerbox_t *box, int irq);
extern void irq_ipc_bind_arch(__native irq);
extern void irq_ipc_bind_arch(unative_t irq);
extern void ipc_irq_cleanup(answerbox_t *box);
#endif

/kernel/trunk/generic/include/ipc/ipcrsc.h
35,7 → 35,7
#ifndef __IPCRSC_H__
#define __IPCRSC_H__
call_t * get_call(__native callid);
call_t * get_call(unative_t callid);
int phone_alloc(void);
void phone_connect(int phoneid, answerbox_t *box);
void phone_dealloc(int phoneid);

/kernel/trunk/generic/include/sort.h
47,9 → 47,9
* default sorting comparators
*/
extern int int_cmp(void * a, void * b);
extern int __u32_cmp(void * a, void * b);
extern int __u16_cmp(void * a, void * b);
extern int __u8_cmp(void * a, void * b);
extern int uint32_t_cmp(void * a, void * b);
extern int uint16_t_cmp(void * a, void * b);
extern int uint8_t_cmp(void * a, void * b);
#endif

/kernel/trunk/generic/src/synch/rwlock.c
101,7 → 101,7
*
* @return See comment for waitq_sleep_timeout().
*/
int _rwlock_write_lock_timeout(rwlock_t *rwl, __u32 usec, int flags)
int _rwlock_write_lock_timeout(rwlock_t *rwl, uint32_t usec, int flags)
{
ipl_t ipl;
int rc;
155,7 → 155,7
*
* @return See comment for waitq_sleep_timeout().
*/
int _rwlock_read_lock_timeout(rwlock_t *rwl, __u32 usec, int flags)
int _rwlock_read_lock_timeout(rwlock_t *rwl, uint32_t usec, int flags)
{
int rc;
ipl_t ipl;

/kernel/trunk/generic/src/synch/mutex.c
64,7 → 64,7
*
* @return See comment for waitq_sleep_timeout().
*/
int _mutex_lock_timeout(mutex_t *mtx, __u32 usec, int flags)
int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, int flags)
{
return _semaphore_down_timeout(&mtx->sem, usec, flags);
}

/kernel/trunk/generic/src/synch/spinlock.c
108,7 → 108,7
#endif
if (i++ > DEADLOCK_THRESHOLD) {
printf("cpu%d: looping on spinlock %.*p:%s, caller=%.*p",
CPU->id, sizeof(__address) * 2, sl, sl->name, sizeof(__address) * 2, CALLER);
CPU->id, sizeof(uintptr_t) * 2, sl, sl->name, sizeof(uintptr_t) * 2, CALLER);
symbol = get_symtab_entry(CALLER);
if (symbol)
printf("(%s)", symbol);

/kernel/trunk/generic/src/synch/semaphore.c
78,7 → 78,7
*
* @return See comment for waitq_sleep_timeout().
*/
int _semaphore_down_timeout(semaphore_t *s, __u32 usec, int flags)
int _semaphore_down_timeout(semaphore_t *s, uint32_t usec, int flags)
{
return waitq_sleep_timeout(&s->wq, usec, flags);
}

/kernel/trunk/generic/src/synch/waitq.c
214,7 → 214,7
* @li ESYNCH_OK_BLOCKED means that the sleep succeeded; the full sleep was
* attempted.
*/
int waitq_sleep_timeout(waitq_t *wq, __u32 usec, int flags)
int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, int flags)
{
ipl_t ipl;
int rc;
297,7 → 297,7
*
* @return See waitq_sleep_timeout().
*/
int waitq_sleep_timeout_unsafe(waitq_t *wq, __u32 usec, int flags)
int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, int flags)
{
/* checks whether to go to sleep at all */
if (wq->missed_wakeups) {
351,7 → 351,7
return ESYNCH_TIMEOUT;
}
THREAD->timeout_pending = true;
timeout_register(&THREAD->sleep_timeout, (__u64) usec, waitq_timeouted_sleep, THREAD);
timeout_register(&THREAD->sleep_timeout, (uint64_t) usec, waitq_timeouted_sleep, THREAD);
}
list_append(&THREAD->wq_link, &wq->head);

/kernel/trunk/generic/src/synch/futex.c
58,9 → 58,9
static void futex_initialize(futex_t *futex);
static futex_t *futex_find(__address paddr);
static index_t futex_ht_hash(__native *key);
static bool futex_ht_compare(__native *key, count_t keys, link_t *item);
static futex_t *futex_find(uintptr_t paddr);
static index_t futex_ht_hash(unative_t *key);
static bool futex_ht_compare(unative_t *key, count_t keys, link_t *item);
static void futex_ht_remove_callback(link_t *item);
/**
108,10 → 108,10
* @return One of ESYNCH_TIMEOUT, ESYNCH_OK_ATOMIC and ESYNCH_OK_BLOCKED. See synch.h.
* If there is no physical mapping for uaddr ENOENT is returned.
*/
__native sys_futex_sleep_timeout(__address uaddr, __u32 usec, int flags)
unative_t sys_futex_sleep_timeout(uintptr_t uaddr, uint32_t usec, int flags)
{
futex_t *futex;
__address paddr;
uintptr_t paddr;
pte_t *t;
ipl_t ipl;
125,7 → 125,7
if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
page_table_unlock(AS, true);
interrupts_restore(ipl);
return (__native) ENOENT;
return (unative_t) ENOENT;
}
paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
page_table_unlock(AS, true);
134,7 → 134,7
futex = futex_find(paddr);
return (__native) waitq_sleep_timeout(&futex->wq, usec, flags | SYNCH_FLAGS_INTERRUPTIBLE);
return (unative_t) waitq_sleep_timeout(&futex->wq, usec, flags | SYNCH_FLAGS_INTERRUPTIBLE);
}
/** Wakeup one thread waiting in futex wait queue.
143,10 → 143,10
*
* @return ENOENT if there is no physical mapping for uaddr.
*/
__native sys_futex_wakeup(__address uaddr)
unative_t sys_futex_wakeup(uintptr_t uaddr)
{
futex_t *futex;
__address paddr;
uintptr_t paddr;
pte_t *t;
ipl_t ipl;
160,7 → 160,7
if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
page_table_unlock(AS, true);
interrupts_restore(ipl);
return (__native) ENOENT;
return (unative_t) ENOENT;
}
paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
page_table_unlock(AS, true);
182,7 → 182,7
*
* @return Address of the kernel futex structure.
*/
futex_t *futex_find(__address paddr)
futex_t *futex_find(uintptr_t paddr)
{
link_t *item;
futex_t *futex;
275,7 → 275,7
*
* @return Index into futex hash table.
*/
index_t futex_ht_hash(__native *key)
index_t futex_ht_hash(unative_t *key)
{
return *key & (FUTEX_HT_SIZE-1);
}
286,7 → 286,7
*
* @return True if the item matches the key. False otherwise.
*/
bool futex_ht_compare(__native *key, count_t keys, link_t *item)
bool futex_ht_compare(unative_t *key, count_t keys, link_t *item)
{
futex_t *futex;
323,7 → 323,7
node = list_get_instance(cur, btree_node_t, leaf_link);
for (i = 0; i < node->keys; i++) {
futex_t *ftx;
__address paddr = node->key[i];
uintptr_t paddr = node->key[i];
ftx = (futex_t *) node->value[i];
if (--ftx->refcount == 0)

/kernel/trunk/generic/src/synch/condvar.c
87,7 → 87,7
*
* @return See comment for waitq_sleep_timeout().
*/
int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, __u32 usec, int flags)
int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
{
int rc;
ipl_t ipl;

/kernel/trunk/generic/src/main/main.c
101,7 → 101,7
* the linker or the low level assembler code with
* appropriate sizes and addresses.
*/
__address hardcoded_load_address = 0; /**< Virtual address of where the kernel is loaded. */
uintptr_t hardcoded_load_address = 0; /**< Virtual address of where the kernel is loaded. */
size_t hardcoded_ktext_size = 0; /**< Size of the kernel code in bytes. */
size_t hardcoded_kdata_size = 0; /**< Size of the kernel data in bytes. */
132,7 → 132,7
*/
void main_bsp(void)
{
__address stackaddr;
uintptr_t stackaddr;
config.cpu_count = 1;
config.cpu_active = 1;
202,7 → 202,7
arch_post_mm_init();
version_print();
printf("%.*p: hardcoded_ktext_size=%zdK, hardcoded_kdata_size=%zdK\n", sizeof(__address) * 2, config.base, hardcoded_ktext_size >> 10, hardcoded_kdata_size >> 10);
printf("%.*p: hardcoded_ktext_size=%zdK, hardcoded_kdata_size=%zdK\n", sizeof(uintptr_t) * 2, config.base, hardcoded_ktext_size >> 10, hardcoded_kdata_size >> 10);
arch_pre_smp_init();
smp_init();
223,7 → 223,7
klog_init();
for (i = 0; i < init.cnt; i++)
printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i, sizeof(__address) * 2, init.tasks[i].addr, i, init.tasks[i].size);
printf("init[%zd].addr=%.*p, init[%zd].size=%zd\n", i, sizeof(uintptr_t) * 2, init.tasks[i].addr, i, init.tasks[i].size);
ipc_init();
297,7 → 297,7
* collide with another CPU coming up. To prevent this, we
* switch to this cpu's private stack prior to waking kmp up.
*/
context_set(&CPU->saved_context, FADDR(main_ap_separated_stack), (__address) CPU->stack, CPU_STACK_SIZE);
context_set(&CPU->saved_context, FADDR(main_ap_separated_stack), (uintptr_t) CPU->stack, CPU_STACK_SIZE);
context_restore(&CPU->saved_context);
/* not reached */
}

/kernel/trunk/generic/src/debug/symtab.c
50,15 → 50,15
*
* @return Pointer to respective symbol string on success, NULL otherwise.
*/
char * get_symtab_entry(__native addr)
char * get_symtab_entry(unative_t addr)
{
count_t i;
for (i=1;symbol_table[i].address_le;++i) {
if (addr < __u64_le2host(symbol_table[i].address_le))
if (addr < uint64_t_le2host(symbol_table[i].address_le))
break;
}
if (addr >= __u64_le2host(symbol_table[i-1].address_le))
if (addr >= uint64_t_le2host(symbol_table[i-1].address_le))
return symbol_table[i-1].symbol_name;
return NULL;
}
108,10 → 108,10
* @param name Name of the symbol
* @return 0 - Not found, -1 - Duplicate symbol, other - address of symbol
*/
__address get_symbol_addr(const char *name)
uintptr_t get_symbol_addr(const char *name)
{
count_t found = 0;
__address addr = NULL;
uintptr_t addr = NULL;
char *hint;
int i;
118,13 → 118,13
i = 0;
while ((hint=symtab_search_one(name, &i))) {
if (!strlen(hint)) {
addr = __u64_le2host(symbol_table[i].address_le);
addr = uint64_t_le2host(symbol_table[i].address_le);
found++;
}
i++;
}
if (found > 1)
return ((__address) -1);
return ((uintptr_t) -1);
return addr;
}
132,15 → 132,15
void symtab_print_search(const char *name)
{
int i;
__address addr;
uintptr_t addr;
char *realname;
i = 0;
while (symtab_search_one(name, &i)) {
addr = __u64_le2host(symbol_table[i].address_le);
addr = uint64_t_le2host(symbol_table[i].address_le);
realname = symbol_table[i].symbol_name;
printf("%.*p: %s\n", sizeof(__address) * 2, addr, realname);
printf("%.*p: %s\n", sizeof(uintptr_t) * 2, addr, realname);
i++;
}
}

/kernel/trunk/generic/src/cpu/cpu.c
68,10 → 68,10
panic("malloc/cpus");
/* initialize everything */
memsetb((__address) cpus, sizeof(cpu_t) * config.cpu_count, 0);
memsetb((uintptr_t) cpus, sizeof(cpu_t) * config.cpu_count, 0);
for (i=0; i < config.cpu_count; i++) {
cpus[i].stack = (__u8 *) frame_alloc(STACK_FRAMES, FRAME_KA | FRAME_ATOMIC);
cpus[i].stack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | FRAME_ATOMIC);
cpus[i].id = i;

/kernel/trunk/generic/src/sysinfo/sysinfo.c
167,7 → 167,7
return NULL;
}
void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, __native val)
void sysinfo_set_item_val(const char *name, sysinfo_item_t **root, unative_t val)
{
if (root == NULL)
root = &_root;
222,7 → 222,7
while (root != NULL) {
int i;
__native val = 0;
unative_t val = 0;
char *vtype = NULL;
278,7 → 278,7
return ret;
}
__native sys_sysinfo_valid(__native ptr, __native len)
unative_t sys_sysinfo_valid(unative_t ptr, unative_t len)
{
char *str;
sysinfo_rettype_t ret = {0, 0};
292,7 → 292,7
return ret.valid;
}
__native sys_sysinfo_value(__native ptr, __native len)
unative_t sys_sysinfo_value(unative_t ptr, unative_t len)
{
char *str;
sysinfo_rettype_t ret = {0, 0};

/kernel/trunk/generic/src/interrupt/interrupt.c
109,11 → 109,11
spinlock_lock(&exctbl_lock);
printf("Exc Description Handler\n");
for (i=0; i < IVT_ITEMS; i++) {
symbol = get_symtab_entry((__native)exc_table[i].f);
symbol = get_symtab_entry((unative_t)exc_table[i].f);
if (!symbol)
symbol = "not found";
printf("%d %s %.*p(%s)\n", i + IVT_FIRST, exc_table[i].name,
sizeof(__address) * 2, exc_table[i].f,symbol);
sizeof(uintptr_t) * 2, exc_table[i].f,symbol);
if (!((i+1) % 20)) {
printf("Press any key to continue.");
spinlock_unlock(&exctbl_lock);

/kernel/trunk/generic/src/time/delay.c
49,7 → 49,7
*
* @param usec Number of microseconds to sleep.
*/
void delay(__u32 usec)
void delay(uint32_t usec)
{
ipl_t ipl;

/kernel/trunk/generic/src/time/timeout.c
103,12 → 103,12
* @param arg Timeout handler argument.
*
*/
void timeout_register(timeout_t *t, __u64 time, timeout_handler_t f, void *arg)
void timeout_register(timeout_t *t, uint64_t time, timeout_handler_t f, void *arg)
{
timeout_t *hlp = NULL;
link_t *l, *m;
ipl_t ipl;
__u64 sum;
uint64_t sum;
ipl = interrupts_disable();
spinlock_lock(&CPU->timeoutlock);

/kernel/trunk/generic/src/time/clock.c
57,15 → 57,15
/* Pointers to public variables with time */
struct ptime {
__native seconds1;
__native useconds;
__native seconds2;
unative_t seconds1;
unative_t useconds;
unative_t seconds2;
};
struct ptime *public_time;
/* Variable holding fragment of second, so that we would update
* seconds correctly
*/
static __native secfrag = 0;
static unative_t secfrag = 0;
/** Initialize realtime clock counter
*
90,7 → 90,7
public_time->seconds2 = 0;
public_time->useconds = 0;
sysinfo_set_item_val("clock.faddr", NULL, (__native)faddr);
sysinfo_set_item_val("clock.faddr", NULL, (unative_t)faddr);
}
165,7 → 165,7
*/
if (THREAD) {
__u64 ticks;
uint64_t ticks;
spinlock_lock(&CPU->lock);
CPU->needs_relink += 1 + missed_clock_ticks;

/kernel/trunk/generic/src/ddi/ddi.c
62,7 → 62,7
* ENOENT if there is no task matching the specified ID and ENOMEM if
* there was a problem in creating address space area.
*/
static int ddi_physmem_map(__address pf, __address vp, count_t pages, int flags)
static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
{
ipl_t ipl;
cap_t caps;
110,7 → 110,7
* @return 0 on success, EPERM if the caller lacks capabilities to use this syscall,
* ENOENT if there is no task matching the specified ID.
*/
static int ddi_iospace_enable(task_id_t id, __address ioaddr, size_t size)
static int ddi_iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
{
ipl_t ipl;
cap_t caps;
158,11 → 158,11
*
* @return 0 on success, otherwise it returns error code found in errno.h
*/
__native sys_physmem_map(__native phys_base, __native virt_base, __native pages,
__native flags)
unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base, unative_t pages,
unative_t flags)
{
return (__native) ddi_physmem_map(ALIGN_DOWN((__address) phys_base, FRAME_SIZE),
ALIGN_DOWN((__address) virt_base, PAGE_SIZE), (count_t) pages,
return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base, FRAME_SIZE),
ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE), (count_t) pages,
(int) flags);
}
172,7 → 172,7
*
* @return 0 on success, otherwise it returns error code found in errno.h
*/
__native sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
{
ddi_ioarg_t arg;
int rc;
179,9 → 179,9
rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
if (rc != 0)
return (__native) rc;
return (unative_t) rc;
return (__native) ddi_iospace_enable((task_id_t) arg.task_id, (__address) arg.ioaddr, (size_t) arg.size);
return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id, (uintptr_t) arg.ioaddr, (size_t) arg.size);
}
/** Disable or enable preemption.
192,7 → 192,7
*
* @return Zero on success or EPERM if callers capabilities are not sufficient.
*/
__native sys_preempt_control(int enable)
unative_t sys_preempt_control(int enable)
{
if (! cap_get(TASK) & CAP_PREEMPT_CONTROL)
return EPERM;

/kernel/trunk/generic/src/printf/printf_core.c
88,9 → 88,9
* @param str Pointer to valid string.
* @return string length without trailing zero.
*/
static __native strlen(const char *str)
static unative_t strlen(const char *str)
{
__native counter = 0;
unative_t counter = 0;
while (str[counter] != 0) {
counter++;
146,7 → 146,7
* @param flags
* @return number of printed characters, negative value on fail
*/
static int print_char(char c, int width, __u64 flags, struct printf_spec *ps)
static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
{
int counter = 0;
176,7 → 176,7
* @return number of printed characters or negative value on fail
*/
static int print_string(char *s, int width, int precision, __u64 flags, struct printf_spec *ps)
static int print_string(char *s, int width, int precision, uint64_t flags, struct printf_spec *ps)
{
int counter = 0;
size_t size;
236,7 → 236,7
* @return number of written characters or EOF
*
*/
static int print_number(__u64 num, int width, int precision, int base , __u64 flags, struct printf_spec *ps)
static int print_number(uint64_t num, int width, int precision, int base , uint64_t flags, struct printf_spec *ps)
{
char *digits = digits_small;
char d[PRINT_NUMBER_BUFFER_SIZE]; /* this is good enough even for base == 2, prefix and sign */
427,7 → 427,7
* - "" Signed or usigned int (default value).@n
* - "l" Signed or usigned long int.@n
* - "ll" Signed or usigned long long int.@n
* - "z" __native (non-standard extension).@n
* - "z" unative_t (non-standard extension).@n
*
*
* CONVERSION:@n
466,10 → 466,10
char c;
qualifier_t qualifier; /* type of argument */
int base; /**< base in which will be parameter (numbers only) printed */
__u64 number; /**< argument value */
uint64_t number; /**< argument value */
size_t size; /**< byte size of integer parameter */
int width, precision;
__u64 flags;
uint64_t flags;
counter = 0;
562,7 → 562,7
qualifier = PrintfQualifierLongLong;
}
break;
case 'z': /* __native */
case 'z': /* unative_t */
qualifier = PrintfQualifierNative;
break;
default:
644,31 → 644,31
switch (qualifier) {
case PrintfQualifierByte:
size = sizeof(unsigned char);
number = (__u64)va_arg(ap, unsigned int);
number = (uint64_t)va_arg(ap, unsigned int);
break;
case PrintfQualifierShort:
size = sizeof(unsigned short);
number = (__u64)va_arg(ap, unsigned int);
number = (uint64_t)va_arg(ap, unsigned int);
break;
case PrintfQualifierInt:
size = sizeof(unsigned int);
number = (__u64)va_arg(ap, unsigned int);
number = (uint64_t)va_arg(ap, unsigned int);
break;
case PrintfQualifierLong:
size = sizeof(unsigned long);
number = (__u64)va_arg(ap, unsigned long);
number = (uint64_t)va_arg(ap, unsigned long);
break;
case PrintfQualifierLongLong:
size = sizeof(unsigned long long);
number = (__u64)va_arg(ap, unsigned long long);
number = (uint64_t)va_arg(ap, unsigned long long);
break;
case PrintfQualifierPointer:
size = sizeof(void *);
number = (__u64)(unsigned long)va_arg(ap, void *);
number = (uint64_t)(unsigned long)va_arg(ap, void *);
break;
case PrintfQualifierNative:
size = sizeof(__native);
number = (__u64)va_arg(ap, __native);
size = sizeof(unative_t);
number = (uint64_t)va_arg(ap, unative_t);
break;
default: /* Unknown qualifier */
counter = -counter;
679,8 → 679,8
if (number & (0x1 << (size*8 - 1))) {
flags |= __PRINTF_FLAG_NEGATIVE;
if (size == sizeof(__u64)) {
number = -((__s64)number);
if (size == sizeof(uint64_t)) {
number = -((int64_t)number);
} else {
number = ~number;
number &= (~((0xFFFFFFFFFFFFFFFFll) << (size * 8)));
703,7 → 703,7
}
if (i > j) {
if ((retval = printf_putnchars(&fmt[j], (__native)(i - j), ps)) < 0) { /* error */
if ((retval = printf_putnchars(&fmt[j], (unative_t)(i - j), ps)) < 0) { /* error */
counter = -counter;
goto out;

/kernel/trunk/generic/src/console/console.c
76,9 → 76,9
*
* @return Character read.
*/
__u8 _getc(chardev_t *chardev)
uint8_t _getc(chardev_t *chardev)
{
__u8 ch;
uint8_t ch;
ipl_t ipl;
if (atomic_get(&haltstate)) {
150,9 → 150,9
}
/** Get character from device & echo it to screen */
__u8 getc(chardev_t *chardev)
uint8_t getc(chardev_t *chardev)
{
__u8 ch;
uint8_t ch;
ch = _getc(chardev);
putchar(ch);

/kernel/trunk/generic/src/console/cmd.c
479,13 → 479,13
/** Call function with zero parameters */
int cmd_call0(cmd_arg_t *argv)
{
__address symaddr;
uintptr_t symaddr;
char *symbol;
__native (*f)(void);
unative_t (*f)(void);
#ifdef ia64
struct {
__native f;
__native gp;
unative_t f;
unative_t gp;
}fptr;
#endif
492,18 → 492,18
symaddr = get_symbol_addr(argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (__address) -1) {
else if (symaddr == (uintptr_t) -1) {
symtab_print_search(argv->buffer);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
printf("Calling f(): %.*p: %s\n", sizeof(__address) * 2, symaddr, symbol);
printf("Calling f(): %.*p: %s\n", sizeof(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
fptr.f = symaddr;
fptr.gp = ((__native *)cmd_call2)[1];
f = (__native (*)(void)) &fptr;
fptr.gp = ((unative_t *)cmd_call2)[1];
f = (unative_t (*)(void)) &fptr;
#else
f = (__native (*)(void)) symaddr;
f = (unative_t (*)(void)) symaddr;
#endif
printf("Result: %#zx\n", f());
}
514,14 → 514,14
/** Call function with one parameter */
int cmd_call1(cmd_arg_t *argv)
{
__address symaddr;
uintptr_t symaddr;
char *symbol;
__native (*f)(__native,...);
__native arg1 = argv[1].intval;
unative_t (*f)(unative_t,...);
unative_t arg1 = argv[1].intval;
#ifdef ia64
struct {
__native f;
__native gp;
unative_t f;
unative_t gp;
}fptr;
#endif
528,19 → 528,19
symaddr = get_symbol_addr(argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (__address) -1) {
else if (symaddr == (uintptr_t) -1) {
symtab_print_search(argv->buffer);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(__address) * 2, symaddr, symbol);
printf("Calling f(%#zx): %.*p: %s\n", arg1, sizeof(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
fptr.f = symaddr;
fptr.gp = ((__native *)cmd_call2)[1];
f = (__native (*)(__native,...)) &fptr;
fptr.gp = ((unative_t *)cmd_call2)[1];
f = (unative_t (*)(unative_t,...)) &fptr;
#else
f = (__native (*)(__native,...)) symaddr;
f = (unative_t (*)(unative_t,...)) symaddr;
#endif
printf("Result: %#zx\n", f(arg1));
}
551,15 → 551,15
/** Call function with two parameters */
int cmd_call2(cmd_arg_t *argv)
{
__address symaddr;
uintptr_t symaddr;
char *symbol;
__native (*f)(__native,__native,...);
__native arg1 = argv[1].intval;
__native arg2 = argv[2].intval;
unative_t (*f)(unative_t,unative_t,...);
unative_t arg1 = argv[1].intval;
unative_t arg2 = argv[2].intval;
#ifdef ia64
struct {
__native f;
__native gp;
unative_t f;
unative_t gp;
}fptr;
#endif
566,19 → 566,19
symaddr = get_symbol_addr(argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (__address) -1) {
else if (symaddr == (uintptr_t) -1) {
symtab_print_search(argv->buffer);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
printf("Calling f(0x%zx,0x%zx): %.*p: %s\n",
arg1, arg2, sizeof(__address) * 2, symaddr, symbol);
arg1, arg2, sizeof(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
fptr.f = symaddr;
fptr.gp = ((__native *)cmd_call2)[1];
f = (__native (*)(__native,__native,...)) &fptr;
fptr.gp = ((unative_t *)cmd_call2)[1];
f = (unative_t (*)(unative_t,unative_t,...)) &fptr;
#else
f = (__native (*)(__native,__native,...)) symaddr;
f = (unative_t (*)(unative_t,unative_t,...)) symaddr;
#endif
printf("Result: %#zx\n", f(arg1, arg2));
}
589,16 → 589,16
/** Call function with three parameters */
int cmd_call3(cmd_arg_t *argv)
{
__address symaddr;
uintptr_t symaddr;
char *symbol;
__native (*f)(__native,__native,__native,...);
__native arg1 = argv[1].intval;
__native arg2 = argv[2].intval;
__native arg3 = argv[3].intval;
unative_t (*f)(unative_t,unative_t,unative_t,...);
unative_t arg1 = argv[1].intval;
unative_t arg2 = argv[2].intval;
unative_t arg3 = argv[3].intval;
#ifdef ia64
struct {
__native f;
__native gp;
unative_t f;
unative_t gp;
}fptr;
#endif
605,19 → 605,19
symaddr = get_symbol_addr(argv->buffer);
if (!symaddr)
printf("Symbol %s not found.\n", argv->buffer);
else if (symaddr == (__address) -1) {
else if (symaddr == (uintptr_t) -1) {
symtab_print_search(argv->buffer);
printf("Duplicate symbol, be more specific.\n");
} else {
symbol = get_symtab_entry(symaddr);
printf("Calling f(0x%zx,0x%zx, 0x%zx): %.*p: %s\n",
arg1, arg2, arg3, sizeof(__address) * 2, symaddr, symbol);
arg1, arg2, arg3, sizeof(uintptr_t) * 2, symaddr, symbol);
#ifdef ia64
fptr.f = symaddr;
fptr.gp = ((__native *)cmd_call2)[1];
f = (__native (*)(__native,__native,__native,...)) &fptr;
fptr.gp = ((unative_t *)cmd_call2)[1];
f = (unative_t (*)(unative_t,unative_t,unative_t,...)) &fptr;
#else
f = (__native (*)(__native,__native,__native,...)) symaddr;
f = (unative_t (*)(unative_t,unative_t,unative_t,...)) symaddr;
#endif
printf("Result: %#zx\n", f(arg1, arg2, arg3));
}
659,28 → 659,28
/** Write 4 byte value to address */
int cmd_set4(cmd_arg_t *argv)
{
__u32 *addr ;
__u32 arg1 = argv[1].intval;
uint32_t *addr ;
uint32_t arg1 = argv[1].intval;
bool pointer = false;
if (((char *)argv->buffer)[0] == '*') {
addr = (__u32 *) get_symbol_addr(argv->buffer+1);
addr = (uint32_t *) get_symbol_addr(argv->buffer+1);
pointer = true;
} else if (((char *)argv->buffer)[0] >= '0' &&
((char *)argv->buffer)[0] <= '9')
addr = (__u32 *)atoi((char *)argv->buffer);
addr = (uint32_t *)atoi((char *)argv->buffer);
else
addr = (__u32 *)get_symbol_addr(argv->buffer);
addr = (uint32_t *)get_symbol_addr(argv->buffer);
if (!addr)
printf("Symbol %s not found.\n", argv->buffer);
else if (addr == (__u32 *) -1) {
else if (addr == (uint32_t *) -1) {
symtab_print_search(argv->buffer);
printf("Duplicate symbol, be more specific.\n");
} else {
if (pointer)
addr = (__u32 *)(*(__native *)addr);
printf("Writing 0x%x -> %.*p\n", arg1, sizeof(__address) * 2, addr);
addr = (uint32_t *)(*(unative_t *)addr);
printf("Writing 0x%x -> %.*p\n", arg1, sizeof(uintptr_t) * 2, addr);
*addr = arg1;
}

/kernel/trunk/generic/src/console/chardev.c
59,7 → 59,7
* @param chardev Character device.
* @param ch Character being pushed.
*/
void chardev_push_character(chardev_t *chardev, __u8 ch)
void chardev_push_character(chardev_t *chardev, uint8_t ch)
{
spinlock_lock(&chardev->lock);
chardev->counter++;

/kernel/trunk/generic/src/console/klog.c
63,7 → 63,7
panic("Cannot allocate page for klog");
klog = (char *)PA2KA(faddr);
sysinfo_set_item_val("klog.faddr", NULL, (__native)faddr);
sysinfo_set_item_val("klog.faddr", NULL, (unative_t)faddr);
sysinfo_set_item_val("klog.pages", NULL, 1 << KLOG_ORDER);
klogsize = PAGE_SIZE << KLOG_ORDER;

/kernel/trunk/generic/src/console/kconsole.c
431,10 → 431,10
}
}
static int parse_int_arg(char *text, size_t len, __native *result)
static int parse_int_arg(char *text, size_t len, unative_t *result)
{
char symname[MAX_SYMBOL_NAME];
__address symaddr;
uintptr_t symaddr;
bool isaddr = false;
bool isptr = false;
453,21 → 453,21
printf("Symbol %s not found.\n",symname);
return -1;
}
if (symaddr == (__address) -1) {
if (symaddr == (uintptr_t) -1) {
printf("Duplicate symbol %s.\n",symname);
symtab_print_search(symname);
return -1;
}
if (isaddr)
*result = (__native)symaddr;
*result = (unative_t)symaddr;
else if (isptr)
*result = **((__native **)symaddr);
*result = **((unative_t **)symaddr);
else
*result = *((__native *)symaddr);
*result = *((unative_t *)symaddr);
} else { /* It's a number - convert it */
*result = atoi(text);
if (isptr)
*result = *((__native *)*result);
*result = *((unative_t *)*result);
}
return 0;
554,7 → 554,7
strncpy(buf, (const char *) &cmdline[start+1],
min((end-start), cmd->argv[i].len));
buf[min((end - start), cmd->argv[i].len - 1)] = '\0';
cmd->argv[i].intval = (__native) buf;
cmd->argv[i].intval = (unative_t) buf;
cmd->argv[i].vartype = ARG_TYPE_STRING;
} else if (!parse_int_arg(cmdline+start, end-start+1,
&cmd->argv[i].intval))

/kernel/trunk/generic/src/proc/scheduler.c
349,7 → 349,7
* scheduler_separated_stack().
*/
context_save(&CPU->saved_context);
context_set(&CPU->saved_context, FADDR(scheduler_separated_stack), (__address) CPU->stack, CPU_STACK_SIZE);
context_set(&CPU->saved_context, FADDR(scheduler_separated_stack), (uintptr_t) CPU->stack, CPU_STACK_SIZE);
context_restore(&CPU->saved_context);
/* not reached */
}

/kernel/trunk/generic/src/proc/task.c
240,13 → 240,13
*
* @return 0 on success or an error code from @ref errno.h.
*/
__native sys_task_get_id(task_id_t *uspace_task_id)
unative_t sys_task_get_id(task_id_t *uspace_task_id)
{
/*
* No need to acquire lock on TASK because taskid
* remains constant for the lifespan of the task.
*/
return (__native) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid, sizeof(TASK->taskid));
}
/** Find task structure corresponding to task ID.

/kernel/trunk/generic/src/proc/thread.c
90,7 → 90,7
btree_t threads_btree;
SPINLOCK_INITIALIZE(tidlock);
__u32 last_tid = 0;
uint32_t last_tid = 0;
static slab_cache_t *thread_slab;
#ifdef ARCH_HAS_FPU
254,7 → 254,7
spinlock_unlock(&t->lock);
spinlock_lock(&threads_lock);
btree_remove(&threads_btree, (btree_key_t) ((__address ) t), NULL);
btree_remove(&threads_btree, (btree_key_t) ((uintptr_t ) t), NULL);
spinlock_unlock(&threads_lock);
/*
299,7 → 299,7
thread_create_arch(t);
/* Not needed, but good for debugging */
memsetb((__address)t->kstack, THREAD_STACK_SIZE * 1<<STACK_FRAMES, 0);
memsetb((uintptr_t)t->kstack, THREAD_STACK_SIZE * 1<<STACK_FRAMES, 0);
ipl = interrupts_disable();
spinlock_lock(&tidlock);
308,7 → 308,7
interrupts_restore(ipl);
context_save(&t->saved_context);
context_set(&t->saved_context, FADDR(cushion), (__address) t->kstack, THREAD_STACK_SIZE);
context_set(&t->saved_context, FADDR(cushion), (uintptr_t) t->kstack, THREAD_STACK_SIZE);
the_initialize((the_t *) t->kstack);
368,7 → 368,7
* Register this thread in the system-wide list.
*/
spinlock_lock(&threads_lock);
btree_insert(&threads_btree, (btree_key_t) ((__address) t), (void *) t, NULL);
btree_insert(&threads_btree, (btree_key_t) ((uintptr_t) t), (void *) t, NULL);
spinlock_unlock(&threads_lock);
interrupts_restore(ipl);
411,7 → 411,7
* @param sec Number of seconds to sleep.
*
*/
void thread_sleep(__u32 sec)
void thread_sleep(uint32_t sec)
{
thread_usleep(sec*1000000);
}
424,7 → 424,7
*
* @return An error code from errno.h or an error code from synch.h.
*/
int thread_join_timeout(thread_t *t, __u32 usec, int flags)
int thread_join_timeout(thread_t *t, uint32_t usec, int flags)
{
ipl_t ipl;
int rc;
484,7 → 484,7
* @param usec Number of microseconds to sleep.
*
*/
void thread_usleep(__u32 usec)
void thread_usleep(uint32_t usec)
{
waitq_t wq;
564,46 → 564,46
{
btree_node_t *leaf;
return btree_search(&threads_btree, (btree_key_t) ((__address) t), &leaf) != NULL;
return btree_search(&threads_btree, (btree_key_t) ((uintptr_t) t), &leaf) != NULL;
}
/** Process syscall to create new thread.
*
*/
__native sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
{
thread_t *t;
char namebuf[THREAD_NAME_BUFLEN];
uspace_arg_t *kernel_uarg;
__u32 tid;
uint32_t tid;
int rc;
rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
if (rc != 0)
return (__native) rc;
return (unative_t) rc;
kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
rc = copy_from_uspace(kernel_uarg, uspace_uarg, sizeof(uspace_arg_t));
if (rc != 0) {
free(kernel_uarg);
return (__native) rc;
return (unative_t) rc;
}
if ((t = thread_create(uinit, kernel_uarg, TASK, 0, namebuf))) {
tid = t->tid;
thread_ready(t);
return (__native) tid;
return (unative_t) tid;
} else {
free(kernel_uarg);
}
return (__native) ENOMEM;
return (unative_t) ENOMEM;
}
/** Process syscall to terminate thread.
*
*/
__native sys_thread_exit(int uspace_status)
unative_t sys_thread_exit(int uspace_status)
{
thread_exit();
/* Unreachable */

/kernel/trunk/generic/src/lib/elf.c
96,7 → 96,7
/* Walk through all segment headers and process them. */
for (i = 0; i < header->e_phnum; i++) {
rc = segment_header(&((elf_segment_header_t *)(((__u8 *) header) + header->e_phoff))[i], header, as);
rc = segment_header(&((elf_segment_header_t *)(((uint8_t *) header) + header->e_phoff))[i], header, as);
if (rc != EE_OK)
return rc;
}
103,7 → 103,7
/* Inspect all section headers and proccess them. */
for (i = 0; i < header->e_shnum; i++) {
rc = section_header(&((elf_section_header_t *)(((__u8 *) header) + header->e_shoff))[i], header, as);
rc = section_header(&((elf_section_header_t *)(((uint8_t *) header) + header->e_shoff))[i], header, as);
if (rc != EE_OK)
return rc;
}

/kernel/trunk/generic/src/lib/memstr.c
61,17 → 61,17
{
int i, j;
if (ALIGN_UP((__address) src, sizeof(__native)) != (__address) src ||
ALIGN_UP((__address) dst, sizeof(__native)) != (__address) dst) {
if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
for (i = 0; i < cnt; i++)
((__u8 *) dst)[i] = ((__u8 *) src)[i];
((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
} else {
for (i = 0; i < cnt/sizeof(__native); i++)
((__native *) dst)[i] = ((__native *) src)[i];
for (i = 0; i < cnt/sizeof(unative_t); i++)
((unative_t *) dst)[i] = ((unative_t *) src)[i];
for (j = 0; j < cnt%sizeof(__native); j++)
((__u8 *)(((__native *) dst) + i))[j] = ((__u8 *)(((__native *) src) + i))[j];
for (j = 0; j < cnt%sizeof(unative_t); j++)
((uint8_t *)(((unative_t *) dst) + i))[j] = ((uint8_t *)(((unative_t *) src) + i))[j];
}
return (char *)src;
87,10 → 87,10
* @param x Value to fill.
*
*/
void _memsetb(__address dst, size_t cnt, __u8 x)
void _memsetb(uintptr_t dst, size_t cnt, uint8_t x)
{
int i;
__u8 *p = (__u8 *) dst;
uint8_t *p = (uint8_t *) dst;
for(i=0; i<cnt; i++)
p[i] = x;
106,10 → 106,10
* @param x Value to fill.
*
*/
void _memsetw(__address dst, size_t cnt, __u16 x)
void _memsetw(uintptr_t dst, size_t cnt, uint16_t x)
{
int i;
__u16 *p = (__u16 *) dst;
uint16_t *p = (uint16_t *) dst;
for(i=0; i<cnt; i++)
p[i] = x;

/kernel/trunk/generic/src/lib/sort.c
63,8 → 63,8
*/
void qsort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b))
{
__u8 buf_tmp[EBUFSIZE];
__u8 buf_pivot[EBUFSIZE];
uint8_t buf_tmp[EBUFSIZE];
uint8_t buf_pivot[EBUFSIZE];
void * tmp = buf_tmp;
void * pivot = buf_pivot;
132,7 → 132,7
*/
void bubblesort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b))
{
__u8 buf_slot[EBUFSIZE];
uint8_t buf_slot[EBUFSIZE];
void * slot = buf_slot;
if (e_size > EBUFSIZE) {
184,19 → 184,19
return (* (int *) a > * (int*)b) ? 1 : (*(int *)a < * (int *)b) ? -1 : 0;
}
int __u8_cmp(void * a, void * b)
int uint8_t_cmp(void * a, void * b)
{
return (* (__u8 *) a > * (__u8 *)b) ? 1 : (*(__u8 *)a < * (__u8 *)b) ? -1 : 0;
return (* (uint8_t *) a > * (uint8_t *)b) ? 1 : (*(uint8_t *)a < * (uint8_t *)b) ? -1 : 0;
}
int __u16_cmp(void * a, void * b)
int uint16_t_cmp(void * a, void * b)
{
return (* (__u16 *) a > * (__u16 *)b) ? 1 : (*(__u16 *)a < * (__u16 *)b) ? -1 : 0;
return (* (uint16_t *) a > * (uint16_t *)b) ? 1 : (*(uint16_t *)a < * (uint16_t *)b) ? -1 : 0;
}
int __u32_cmp(void * a, void * b)
int uint32_t_cmp(void * a, void * b)
{
return (* (__u32 *) a > * (__u32 *)b) ? 1 : (*(__u32 *)a < * (__u32 *)b) ? -1 : 0;
return (* (uint32_t *) a > * (uint32_t *)b) ? 1 : (*(uint32_t *)a < * (uint32_t *)b) ? -1 : 0;
}
/** @}

/kernel/trunk/generic/src/lib/func.c
148,7 → 148,7
dest[i-1] = '\0';
}
/** Convert ascii representation to __native
/** Convert ascii representation to unative_t
*
* Supports 0x for hexa & 0 for octal notation.
* Does not check for overflows, does not support negative numbers
156,10 → 156,10
* @param text Textual representation of number
* @return Converted number or 0 if no valid number ofund
*/
__native atoi(const char *text)
unative_t atoi(const char *text)
{
int base = 10;
__native result = 0;
unative_t result = 0;
if (text[0] == '0' && text[1] == 'x') {
base = 16;

/kernel/trunk/generic/src/security/cap.c
94,7 → 94,7
*
* @return Zero on success or an error code from @ref errno.h.
*/
__native sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
{
sysarg64_t taskid_arg;
task_t *t;
102,11 → 102,11
int rc;
if (!(cap_get(TASK) & CAP_CAP))
return (__native) EPERM;
return (unative_t) EPERM;
rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
if (rc != 0)
return (__native) rc;
return (unative_t) rc;
ipl = interrupts_disable();
spinlock_lock(&tasks_lock);
114,7 → 114,7
if (!t) {
spinlock_unlock(&tasks_lock);
interrupts_restore(ipl);
return (__native) ENOENT;
return (unative_t) ENOENT;
}
spinlock_lock(&t->lock);
139,7 → 139,7
*
* @return Zero on success or an error code from @ref errno.h.
*/
__native sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
{
sysarg64_t taskid_arg;
task_t *t;
148,7 → 148,7
rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
if (rc != 0)
return (__native) rc;
return (unative_t) rc;
ipl = interrupts_disable();
spinlock_lock(&tasks_lock);
156,7 → 156,7
if (!t) {
spinlock_unlock(&tasks_lock);
interrupts_restore(ipl);
return (__native) ENOENT;
return (unative_t) ENOENT;
}
/*
167,7 → 167,7
if (!(cap_get(TASK) & CAP_CAP) || !(t == TASK)) {
spinlock_unlock(&tasks_lock);
interrupts_restore(ipl);
return (__native) EPERM;
return (unative_t) EPERM;
}
spinlock_lock(&t->lock);

/kernel/trunk/generic/src/adt/hash_table.c
64,7 → 64,7
if (!h->entry) {
panic("cannot allocate memory for hash table\n");
}
memsetb((__address) h->entry, m * sizeof(link_t), 0);
memsetb((uintptr_t) h->entry, m * sizeof(link_t), 0);
for (i = 0; i < m; i++)
list_initialize(&h->entry[i]);
80,7 → 80,7
* @param key Array of all keys necessary to compute hash index.
* @param item Item to be inserted into the hash table.
*/
void hash_table_insert(hash_table_t *h, __native key[], link_t *item)
void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)
{
index_t chain;
100,7 → 100,7
*
* @return Matching item on success, NULL if there is no such item.
*/
link_t *hash_table_find(hash_table_t *h, __native key[])
link_t *hash_table_find(hash_table_t *h, unative_t key[])
{
link_t *cur;
index_t chain;
130,7 → 130,7
* @param key Array of keys that will be compared against items of the hash table.
* @param keys Number of keys in the key array.
*/
void hash_table_remove(hash_table_t *h, __native key[], count_t keys)
void hash_table_remove(hash_table_t *h, unative_t key[], count_t keys)
{
index_t chain;
link_t *cur;

/kernel/trunk/generic/src/adt/bitmap.c
55,7 → 55,7
* @param map Address of the memory used to hold the map.
* @param bits Number of bits stored in bitmap.
*/
void bitmap_initialize(bitmap_t *bitmap, __u8 *map, count_t bits)
void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, count_t bits)
{
bitmap->map = map;
bitmap->bits = bits;

/kernel/trunk/generic/src/mm/slab.c
549,7 → 549,7
cache->mag_cache = malloc(sizeof(slab_mag_cache_t)*config.cpu_count,0);
for (i=0; i < config.cpu_count; i++) {
memsetb((__address)&cache->mag_cache[i],
memsetb((uintptr_t)&cache->mag_cache[i],
sizeof(cache->mag_cache[i]), 0);
spinlock_initialize(&cache->mag_cache[i].lock,
"slab_maglock_cpu");
569,11 → 569,11
int pages;
ipl_t ipl;
memsetb((__address)cache, sizeof(*cache), 0);
memsetb((uintptr_t)cache, sizeof(*cache), 0);
cache->name = name;
if (align < sizeof(__native))
align = sizeof(__native);
if (align < sizeof(unative_t))
align = sizeof(unative_t);
size = ALIGN_UP(size, align);
cache->size = size;
820,7 → 820,7
_slab_cache_create(&mag_cache,
"slab_magazine",
sizeof(slab_magazine_t)+SLAB_MAG_SIZE*sizeof(void*),
sizeof(__address),
sizeof(uintptr_t),
NULL, NULL,
SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
/* Initialize slab_cache cache */
827,7 → 827,7
_slab_cache_create(&slab_cache_cache,
"slab_cache",
sizeof(slab_cache_cache),
sizeof(__address),
sizeof(uintptr_t),
NULL, NULL,
SLAB_CACHE_NOMAGAZINE | SLAB_CACHE_SLINSIDE);
/* Initialize external slab cache */

/kernel/trunk/generic/src/mm/tlb.c
78,7 → 78,7
* @param page Virtual page address, if required by type.
* @param count Number of pages, if required by type.
*/
void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, __address page, count_t count)
void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid, uintptr_t page, count_t count)
{
int i;
141,7 → 141,7
{
tlb_invalidate_type_t type;
asid_t asid;
__address page;
uintptr_t page;
count_t count;
int i;

/kernel/trunk/generic/src/mm/backend_anon.c
51,8 → 51,8
#include <align.h>
#include <arch.h>
static int anon_page_fault(as_area_t *area, __address addr, pf_access_t access);
static void anon_frame_free(as_area_t *area, __address page, __address frame);
static int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
static void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
static void anon_share(as_area_t *area);
mem_backend_t anon_backend = {
71,9 → 71,9
*
* @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
*/
int anon_page_fault(as_area_t *area, __address addr, pf_access_t access)
int anon_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
{
__address frame;
uintptr_t frame;
if (!as_area_check_access(area, access))
return AS_PF_FAULT;
88,7 → 88,7
* mapping, a new frame is allocated and the mapping is created.
*/
mutex_lock(&area->sh_info->lock);
frame = (__address) btree_search(&area->sh_info->pagemap,
frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
if (!frame) {
bool allocate = true;
105,7 → 105,7
}
}
if (allocate) {
frame = (__address) frame_alloc(ONE_FRAME, 0);
frame = (uintptr_t) frame_alloc(ONE_FRAME, 0);
memsetb(PA2KA(frame), FRAME_SIZE, 0);
/*
132,7 → 132,7
* do not forget to distinguish between
* the different causes
*/
frame = (__address)frame_alloc(ONE_FRAME, 0);
frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
memsetb(PA2KA(frame), FRAME_SIZE, 0);
}
156,7 → 156,7
* @param page Ignored.
* @param frame Frame to be released.
*/
void anon_frame_free(as_area_t *area, __address page, __address frame)
void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
{
frame_free(frame);
}
184,7 → 184,7
node = list_get_instance(cur, btree_node_t, leaf_link);
for (i = 0; i < node->keys; i++) {
__address base = node->key[i];
uintptr_t base = node->key[i];
count_t count = (count_t) node->value[i];
int j;

/kernel/trunk/generic/src/mm/as.c
97,8 → 97,8
as_t *AS_KERNEL = NULL;
static int area_flags_to_page_flags(int aflags);
static as_area_t *find_area_and_lock(as_t *as, __address va);
static bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area);
static as_area_t *find_area_and_lock(as_t *as, uintptr_t va);
static bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area);
static void sh_info_remove_reference(share_info_t *sh_info);
/** Initialize address space subsystem. */
199,7 → 199,7
*
* @return Address space area on success or NULL on failure.
*/
as_area_t *as_area_create(as_t *as, int flags, size_t size, __address base, int attrs,
as_area_t *as_area_create(as_t *as, int flags, size_t size, uintptr_t base, int attrs,
mem_backend_t *backend, mem_backend_data_t *backend_data)
{
ipl_t ipl;
238,7 → 238,7
if (backend_data)
a->backend_data = *backend_data;
else
memsetb((__address) &a->backend_data, sizeof(a->backend_data), 0);
memsetb((uintptr_t) &a->backend_data, sizeof(a->backend_data), 0);
btree_create(&a->used_space);
259,7 → 259,7
*
* @return Zero on success or a value from @ref errno.h otherwise.
*/
int as_area_resize(as_t *as, __address address, size_t size, int flags)
int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags)
{
as_area_t *area;
ipl_t ipl;
312,7 → 312,7
if (pages < area->pages) {
bool cond;
__address start_free = area->base + pages*PAGE_SIZE;
uintptr_t start_free = area->base + pages*PAGE_SIZE;
/*
* Shrinking the area.
337,7 → 337,7
ASSERT(!list_empty(&area->used_space.leaf_head));
node = list_get_instance(area->used_space.leaf_head.prev, btree_node_t, leaf_link);
if ((cond = (bool) node->keys)) {
__address b = node->key[node->keys - 1];
uintptr_t b = node->key[node->keys - 1];
count_t c = (count_t) node->value[node->keys - 1];
int i = 0;
418,10 → 418,10
*
* @return Zero on success or a value from @ref errno.h on failure.
*/
int as_area_destroy(as_t *as, __address address)
int as_area_destroy(as_t *as, uintptr_t address)
{
as_area_t *area;
__address base;
uintptr_t base;
link_t *cur;
ipl_t ipl;
451,7 → 451,7
node = list_get_instance(cur, btree_node_t, leaf_link);
for (i = 0; i < node->keys; i++) {
__address b = node->key[i];
uintptr_t b = node->key[i];
count_t j;
pte_t *pte;
518,8 → 518,8
* address space area. ENOTSUP is returned if an attempt
* to share non-anonymous address space area is detected.
*/
int as_area_share(as_t *src_as, __address src_base, size_t acc_size,
as_t *dst_as, __address dst_base, int dst_flags_mask)
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)
{
ipl_t ipl;
int src_flags;
665,7 → 665,7
* @return AS_PF_FAULT on page fault, AS_PF_OK on success or AS_PF_DEFER if the
* fault was caused by copy_to_uspace() or copy_from_uspace().
*/
int as_page_fault(__address page, pf_access_t access, istate_t *istate)
int as_page_fault(uintptr_t page, pf_access_t access, istate_t *istate)
{
pte_t *pte;
as_area_t *area;
744,10 → 744,10
page_fault:
if (THREAD->in_copy_from_uspace) {
THREAD->in_copy_from_uspace = false;
istate_set_retaddr(istate, (__address) &memcpy_from_uspace_failover_address);
istate_set_retaddr(istate, (uintptr_t) &memcpy_from_uspace_failover_address);
} else if (THREAD->in_copy_to_uspace) {
THREAD->in_copy_to_uspace = false;
istate_set_retaddr(istate, (__address) &memcpy_to_uspace_failover_address);
istate_set_retaddr(istate, (uintptr_t) &memcpy_to_uspace_failover_address);
} else {
return AS_PF_FAULT;
}
942,7 → 942,7
*
* @return Locked address space area containing va on success or NULL on failure.
*/
as_area_t *find_area_and_lock(as_t *as, __address va)
as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
{
as_area_t *a;
btree_node_t *leaf, *lnode;
998,7 → 998,7
*
* @return True if there is no conflict, false otherwise.
*/
bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area)
bool check_area_conflicts(as_t *as, uintptr_t va, size_t size, as_area_t *avoid_area)
{
as_area_t *a;
btree_node_t *leaf, *node;
1071,7 → 1071,7
}
/** Return size of the address space area with given base. */
size_t as_get_size(__address base)
size_t as_get_size(uintptr_t base)
{
ipl_t ipl;
as_area_t *src_area;
1099,7 → 1099,7
*
* @return 0 on failure and 1 on success.
*/
int used_space_insert(as_area_t *a, __address page, count_t count)
int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
{
btree_node_t *leaf, *node;
count_t pages;
1123,7 → 1123,7
node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
if (node) {
__address left_pg = node->key[node->keys - 1], right_pg = leaf->key[0];
uintptr_t left_pg = node->key[node->keys - 1], right_pg = leaf->key[0];
count_t left_cnt = (count_t) node->value[node->keys - 1], right_cnt = (count_t) leaf->value[0];
/*
1166,7 → 1166,7
return 1;
}
} else if (page < leaf->key[0]) {
__address right_pg = leaf->key[0];
uintptr_t right_pg = leaf->key[0];
count_t right_cnt = (count_t) leaf->value[0];
/*
1197,7 → 1197,7
node = btree_leaf_node_right_neighbour(&a->used_space, leaf);
if (node) {
__address left_pg = leaf->key[leaf->keys - 1], right_pg = node->key[0];
uintptr_t left_pg = leaf->key[leaf->keys - 1], right_pg = node->key[0];
count_t left_cnt = (count_t) leaf->value[leaf->keys - 1], right_cnt = (count_t) node->value[0];
/*
1240,7 → 1240,7
return 1;
}
} else if (page >= leaf->key[leaf->keys - 1]) {
__address left_pg = leaf->key[leaf->keys - 1];
uintptr_t left_pg = leaf->key[leaf->keys - 1];
count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
/*
1272,7 → 1272,7
*/
for (i = 1; i < leaf->keys; i++) {
if (page < leaf->key[i]) {
__address left_pg = leaf->key[i - 1], right_pg = leaf->key[i];
uintptr_t left_pg = leaf->key[i - 1], right_pg = leaf->key[i];
count_t left_cnt = (count_t) leaf->value[i - 1], right_cnt = (count_t) leaf->value[i];
/*
1326,7 → 1326,7
*
* @return 0 on failure and 1 on success.
*/
int used_space_remove(as_area_t *a, __address page, count_t count)
int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
{
btree_node_t *leaf, *node;
count_t pages;
1363,7 → 1363,7
node = btree_leaf_node_left_neighbour(&a->used_space, leaf);
if (node && page < leaf->key[0]) {
__address left_pg = node->key[node->keys - 1];
uintptr_t left_pg = node->key[node->keys - 1];
count_t left_cnt = (count_t) node->value[node->keys - 1];
if (overlaps(left_pg, left_cnt*PAGE_SIZE, page, count*PAGE_SIZE)) {
1396,7 → 1396,7
}
if (page > leaf->key[leaf->keys - 1]) {
__address left_pg = leaf->key[leaf->keys - 1];
uintptr_t left_pg = leaf->key[leaf->keys - 1];
count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
if (overlaps(left_pg, left_cnt*PAGE_SIZE, page, count*PAGE_SIZE)) {
1432,7 → 1432,7
*/
for (i = 1; i < leaf->keys - 1; i++) {
if (page < leaf->key[i]) {
__address left_pg = leaf->key[i - 1];
uintptr_t left_pg = leaf->key[i - 1];
count_t left_cnt = (count_t) leaf->value[i - 1];
/*
1496,7 → 1496,7
node = list_get_instance(cur, btree_node_t, leaf_link);
for (i = 0; i < node->keys; i++)
frame_free((__address) node->value[i]);
frame_free((uintptr_t) node->value[i]);
}
}
1513,24 → 1513,24
*/
/** Wrapper for as_area_create(). */
__native sys_as_area_create(__address address, size_t size, int flags)
unative_t sys_as_area_create(uintptr_t address, size_t size, int flags)
{
if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address, AS_AREA_ATTR_NONE, &anon_backend, NULL))
return (__native) address;
return (unative_t) address;
else
return (__native) -1;
return (unative_t) -1;
}
/** Wrapper for as_area_resize. */
__native sys_as_area_resize(__address address, size_t size, int flags)
unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags)
{
return (__native) as_area_resize(AS, address, size, 0);
return (unative_t) as_area_resize(AS, address, size, 0);
}
/** Wrapper for as_area_destroy. */
__native sys_as_area_destroy(__address address)
unative_t sys_as_area_destroy(uintptr_t address)
{
return (__native) as_area_destroy(AS, address);
return (unative_t) as_area_destroy(AS, address);
}
/** @}

/kernel/trunk/generic/src/mm/buddy.c
66,7 → 66,7
* @return New buddy system.
*/
void buddy_system_create(buddy_system_t *b,
__u8 max_order,
uint8_t max_order,
buddy_system_operations_t *op,
void *data)
{
101,8 → 101,8
*
* @return True if block can be allocated
*/
bool buddy_system_can_alloc(buddy_system_t *b, __u8 i) {
__u8 k;
bool buddy_system_can_alloc(buddy_system_t *b, uint8_t i) {
uint8_t k;
/*
* If requested block is greater then maximal block
130,7 → 130,7
link_t *buddy_system_alloc_block(buddy_system_t *b, link_t *block)
{
link_t *left,*right, *tmp;
__u8 order;
uint8_t order;
left = b->op->find_block(b, block, BUDDY_SYSTEM_INNER_BLOCK);
ASSERT(left);
167,7 → 167,7
*
* @return Block of data represented by link_t.
*/
link_t *buddy_system_alloc(buddy_system_t *b, __u8 i)
link_t *buddy_system_alloc(buddy_system_t *b, uint8_t i)
{
link_t *res, *hlp;
230,7 → 230,7
void buddy_system_free(buddy_system_t *b, link_t *block)
{
link_t *buddy, *hlp;
__u8 i;
uint8_t i;
/*
* Determine block's order.

/kernel/trunk/generic/src/mm/backend_phys.c
46,7 → 46,7
#include <arch.h>
#include <align.h>
static int phys_page_fault(as_area_t *area, __address addr, pf_access_t access);
static int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
static void phys_share(as_area_t *area);
mem_backend_t phys_backend = {
65,9 → 65,9
*
* @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
*/
int phys_page_fault(as_area_t *area, __address addr, pf_access_t access)
int phys_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
{
__address base = area->backend_data.base;
uintptr_t base = area->backend_data.base;
if (!as_area_check_access(area, access))
return AS_PF_FAULT;

/kernel/trunk/generic/src/mm/frame.c
69,7 → 69,7
typedef struct {
count_t refcount; /**< tracking of shared frames */
__u8 buddy_order; /**< buddy system block order */
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;
217,7 → 217,7
}
/** @return True if zone can allocate specified order */
static int zone_can_alloc(zone_t *z, __u8 order)
static int zone_can_alloc(zone_t *z, uint8_t order)
{
return buddy_system_can_alloc(z->buddy_system, order);
}
230,7 → 230,7
* @param order Size (2^order) of free space we are trying to find
* @param pzone Pointer to preferred zone or NULL, on return contains zone number
*/
static zone_t * find_free_zone_lock(__u8 order, int *pzone)
static zone_t * find_free_zone_lock(uint8_t order, int *pzone)
{
int i;
zone_t *z;
271,7 → 271,7
* @param order - Order of parent must be different then this parameter!!
*/
static link_t *zone_buddy_find_block(buddy_system_t *b, link_t *child,
__u8 order)
uint8_t order)
{
frame_t * frame;
zone_t * zone;
380,7 → 380,7
* @param block Buddy system block
* @param order Order to set
*/
static void zone_buddy_set_order(buddy_system_t *b, link_t * block, __u8 order) {
static void zone_buddy_set_order(buddy_system_t *b, link_t * block, uint8_t order) {
frame_t * frame;
frame = list_get_instance(block, frame_t, buddy_link);
frame->buddy_order = order;
393,7 → 393,7
*
* @return Order of block
*/
static __u8 zone_buddy_get_order(buddy_system_t *b, link_t * block) {
static uint8_t zone_buddy_get_order(buddy_system_t *b, link_t * block) {
frame_t * frame;
frame = list_get_instance(block, frame_t, buddy_link);
return frame->buddy_order;
450,7 → 450,7
* @return Frame index in zone
*
*/
static pfn_t zone_frame_alloc(zone_t *zone, __u8 order)
static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
{
pfn_t v;
link_t *tmp;
483,7 → 483,7
static void zone_frame_free(zone_t *zone, index_t frame_idx)
{
frame_t *frame;
__u8 order;
uint8_t order;
frame = &zone->frames[frame_idx];
537,7 → 537,7
static void _zone_merge(zone_t *z, zone_t *z1, zone_t *z2)
{
__u8 max_order;
uint8_t max_order;
int i, z2idx;
pfn_t frame_idx;
frame_t *frame;
624,7 → 624,7
count_t cframes;
int i;
pfn = ADDR2PFN((__address)KA2PA(oldzone));
pfn = ADDR2PFN((uintptr_t)KA2PA(oldzone));
cframes = SIZE2FRAMES(zone_conf_size(oldzone->count));
if (pfn < newzone->base || pfn >= newzone->base + newzone->count)
653,7 → 653,7
static void zone_reduce_region(zone_t *zone, pfn_t frame_idx, count_t count)
{
count_t i;
__u8 order;
uint8_t order;
frame_t *frame;
ASSERT(frame_idx+count < zone->count);
689,7 → 689,7
ipl_t ipl;
zone_t *zone1, *zone2, *newzone;
int cframes;
__u8 order;
uint8_t order;
int i;
pfn_t pfn;
779,7 → 779,7
static void zone_construct(pfn_t start, count_t count, zone_t *z, int flags)
{
int i;
__u8 max_order;
uint8_t max_order;
spinlock_initialize(&z->lock, "zone_lock");
z->base = start;
817,7 → 817,7
* @param count Size of zone in frames
* @return Size of zone configuration info (in bytes)
*/
__address zone_conf_size(count_t count)
uintptr_t zone_conf_size(count_t count)
{
int size = sizeof(zone_t) + count*sizeof(frame_t);
int max_order;
845,7 → 845,7
int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags)
{
zone_t *z;
__address addr;
uintptr_t addr;
count_t confcount;
int i;
int znum;
931,7 → 931,7
* @return Physical address of the allocated frame.
*
*/
void * frame_alloc_generic(__u8 order, int flags, int *pzone)
void * frame_alloc_generic(uint8_t order, int flags, int *pzone)
{
ipl_t ipl;
int freed;
990,7 → 990,7
*
* @param Frame Physical Address of of the frame to be freed.
*/
void frame_free(__address frame)
void frame_free(uintptr_t frame)
{
ipl_t ipl;
zone_t *zone;
1099,7 → 1099,7
for (i = 0; i < zones.count; i++) {
zone = zones.info[i];
spinlock_lock(&zone->lock);
printf("%d: %.*p \t%10zd\t%10zd\n", i, sizeof(__address) * 2, PFN2ADDR(zone->base), zone->free_count, zone->busy_count);
printf("%d: %.*p \t%10zd\t%10zd\n", i, sizeof(uintptr_t) * 2, PFN2ADDR(zone->base), zone->free_count, zone->busy_count);
spinlock_unlock(&zone->lock);
}
spinlock_unlock(&zones.lock);
1131,7 → 1131,7
spinlock_lock(&zone->lock);
printf("Memory zone information\n");
printf("Zone base address: %#.*p\n", sizeof(__address) * 2, PFN2ADDR(zone->base));
printf("Zone base address: %#.*p\n", sizeof(uintptr_t) * 2, PFN2ADDR(zone->base));
printf("Zone size: %zd frames (%zdK)\n", zone->count, ((zone->count) * FRAME_SIZE) >> 10);
printf("Allocated space: %zd frames (%zdK)\n", zone->busy_count, (zone->busy_count * FRAME_SIZE) >> 10);
printf("Available space: %zd (%zdK)\n", zone->free_count, (zone->free_count * FRAME_SIZE) >> 10);

/kernel/trunk/generic/src/mm/page.c
69,7 → 69,7
* @param s Address of the structure.
* @param size Size of the structure.
*/
void map_structure(__address s, size_t size)
void map_structure(uintptr_t s, size_t size)
{
int i, cnt, length;
93,7 → 93,7
* @param frame Physical address of memory frame to which the mapping is done.
* @param flags Flags to be used for mapping.
*/
void page_mapping_insert(as_t *as, __address page, __address frame, int flags)
void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
{
ASSERT(page_mapping_operations);
ASSERT(page_mapping_operations->mapping_insert);
112,7 → 112,7
* @param as Address space to wich page belongs.
* @param page Virtual address of the page to be demapped.
*/
void page_mapping_remove(as_t *as, __address page)
void page_mapping_remove(as_t *as, uintptr_t page)
{
ASSERT(page_mapping_operations);
ASSERT(page_mapping_operations->mapping_remove);
131,7 → 131,7
*
* @return NULL if there is no such mapping; requested mapping otherwise.
*/
pte_t *page_mapping_find(as_t *as, __address page)
pte_t *page_mapping_find(as_t *as, uintptr_t page)
{
ASSERT(page_mapping_operations);
ASSERT(page_mapping_operations->mapping_find);

/kernel/trunk/generic/src/mm/backend_elf.c
50,8 → 50,8
#include <macros.h>
#include <arch.h>
static int elf_page_fault(as_area_t *area, __address addr, pf_access_t access);
static void elf_frame_free(as_area_t *area, __address page, __address frame);
static int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access);
static void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame);
static void elf_share(as_area_t *area);
mem_backend_t elf_backend = {
70,12 → 70,12
*
* @return AS_PF_FAULT on failure (i.e. page fault) or AS_PF_OK on success (i.e. serviced).
*/
int elf_page_fault(as_area_t *area, __address addr, pf_access_t access)
int elf_page_fault(as_area_t *area, uintptr_t addr, pf_access_t access)
{
elf_header_t *elf = area->backend_data.elf;
elf_segment_header_t *entry = area->backend_data.segment;
btree_node_t *leaf;
__address base, frame;
uintptr_t base, frame;
index_t i;
if (!as_area_check_access(area, access))
83,7 → 83,7
ASSERT((addr >= entry->p_vaddr) && (addr < entry->p_vaddr + entry->p_memsz));
i = (addr - entry->p_vaddr) >> PAGE_WIDTH;
base = (__address) (((void *) elf) + entry->p_offset);
base = (uintptr_t) (((void *) elf) + entry->p_offset);
ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
if (area->sh_info) {
94,7 → 94,7
*/
mutex_lock(&area->sh_info->lock);
frame = (__address) btree_search(&area->sh_info->pagemap,
frame = (uintptr_t) btree_search(&area->sh_info->pagemap,
ALIGN_DOWN(addr, PAGE_SIZE) - area->base, &leaf);
if (!frame) {
int i;
134,7 → 134,7
* as COW.
*/
if (entry->p_flags & PF_W) {
frame = (__address)frame_alloc(ONE_FRAME, 0);
frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), FRAME_SIZE);
if (area->sh_info) {
153,7 → 153,7
* To resolve the situation, a frame must be allocated
* and cleared.
*/
frame = (__address)frame_alloc(ONE_FRAME, 0);
frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
memsetb(PA2KA(frame), FRAME_SIZE, 0);
if (area->sh_info) {
170,7 → 170,7
* the upper part is anonymous memory.
*/
size = entry->p_filesz - (i<<PAGE_WIDTH);
frame = (__address)frame_alloc(ONE_FRAME, 0);
frame = (uintptr_t)frame_alloc(ONE_FRAME, 0);
memsetb(PA2KA(frame) + size, FRAME_SIZE - size, 0);
memcpy((void *) PA2KA(frame), (void *) (base + i*FRAME_SIZE), size);
201,16 → 201,16
* @param frame Frame to be released.
*
*/
void elf_frame_free(as_area_t *area, __address page, __address frame)
void elf_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
{
elf_header_t *elf = area->backend_data.elf;
elf_segment_header_t *entry = area->backend_data.segment;
__address base;
uintptr_t base;
index_t i;
ASSERT((page >= entry->p_vaddr) && (page < entry->p_vaddr + entry->p_memsz));
i = (page - entry->p_vaddr) >> PAGE_WIDTH;
base = (__address) (((void *) elf) + entry->p_offset);
base = (uintptr_t) (((void *) elf) + entry->p_offset);
ASSERT(ALIGN_UP(base, FRAME_SIZE) == base);
if (page + PAGE_SIZE < ALIGN_UP(entry->p_vaddr + entry->p_filesz, PAGE_SIZE)) {
245,7 → 245,7
elf_segment_header_t *entry = area->backend_data.segment;
link_t *cur;
btree_node_t *leaf, *node;
__address start_anon = entry->p_vaddr + entry->p_filesz;
uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
/*
* Find the node in which to start linear search.
269,7 → 269,7
node = list_get_instance(cur, btree_node_t, leaf_link);
for (i = 0; i < node->keys; i++) {
__address base = node->key[i];
uintptr_t base = node->key[i];
count_t count = (count_t) node->value[i];
int j;

/kernel/trunk/generic/src/syscall/copy.c
67,7 → 67,7
ASSERT(!THREAD->in_copy_from_uspace);
if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
if (overlaps((__address) uspace_src, size,
if (overlaps((uintptr_t) uspace_src, size,
KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START)) {
/*
* The userspace source block conflicts with kernel address space.
108,7 → 108,7
ASSERT(!THREAD->in_copy_from_uspace);
if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
if (overlaps((__address) uspace_dst, size,
if (overlaps((uintptr_t) uspace_dst, size,
KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START)) {
/*
* The userspace destination block conflicts with kernel address space.

/kernel/trunk/generic/src/syscall/syscall.c
58,7 → 58,7
* Some simulators can print only through kernel. Userspace can use
* this syscall to facilitate it.
*/
static __native sys_io(int fd, const void * buf, size_t count)
static unative_t sys_io(int fd, const void * buf, size_t count)
{
size_t i;
char *data;
85,7 → 85,7
}
/** Tell kernel to get keyboard/console access again */
static __native sys_debug_enable_console(void)
static unative_t sys_debug_enable_console(void)
{
arch_grab_console();
return 0;
92,10 → 92,10
}
/** Dispatch system call */
__native syscall_handler(__native a1, __native a2, __native a3,
__native a4, __native id)
unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
unative_t a4, unative_t id)
{
__native rc;
unative_t rc;
if (id < SYSCALL_END)
rc = syscall_table[id](a1,a2,a3,a4);

/kernel/trunk/generic/src/ipc/ipcrsc.c
138,7 → 138,7
* TODO: Some speedup (hash table?)
* @return NULL on not found, otherwise pointer to call structure
*/
call_t * get_call(__native callid)
call_t * get_call(unative_t callid)
{
link_t *lst;
call_t *call, *result = NULL;
147,7 → 147,7
for (lst = TASK->answerbox.dispatched_calls.next;
lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
call = list_get_instance(lst, call_t, link);
if ((__native)call == callid) {
if ((unative_t)call == callid) {
result = call;
break;
}

/kernel/trunk/generic/src/ipc/sysipc.c
56,7 → 56,7
#define STRUCT_TO_USPACE(dst,src) copy_to_uspace(dst,src,sizeof(*(src)))
/** Return true if the method is a system method */
static inline int is_system_method(__native method)
static inline int is_system_method(unative_t method)
{
if (method <= IPC_M_LAST_SYSTEM)
return 1;
68,7 → 68,7
* - some system messages may be forwarded, for some of them
* it is useless
*/
static inline int is_forwardable(__native method)
static inline int is_forwardable(unative_t method)
{
if (method == IPC_M_PHONE_HUNGUP || method == IPC_M_AS_AREA_SEND \
|| method == IPC_M_AS_AREA_RECV)
131,7 → 131,7
/* The connection was accepted */
phone_connect(phoneid,&answer->sender->answerbox);
/* Set 'phone identification' as arg3 of response */
IPC_SET_ARG3(answer->data, (__native)&TASK->phones[phoneid]);
IPC_SET_ARG3(answer->data, (unative_t)&TASK->phones[phoneid]);
}
} else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
/* If the users accepted call, connect */
191,7 → 191,7
if (newphid < 0)
return ELIMIT;
/* Set arg3 for server */
IPC_SET_ARG3(call->data, (__native)&TASK->phones[newphid]);
IPC_SET_ARG3(call->data, (unative_t)&TASK->phones[newphid]);
call->flags |= IPC_CALL_CONN_ME_TO;
call->private = newphid;
break;
253,8 → 253,8
* @return Call identification, returns -1 on fatal error,
-2 on 'Too many async request, handle answers first
*/
__native sys_ipc_call_sync_fast(__native phoneid, __native method,
__native arg1, ipc_data_t *data)
unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
unative_t arg1, ipc_data_t *data)
{
call_t call;
phone_t *phone;
277,7 → 277,7
}
/** Synchronous IPC call allowing to send whole message */
__native sys_ipc_call_sync(__native phoneid, ipc_data_t *question,
unative_t sys_ipc_call_sync(unative_t phoneid, ipc_data_t *question,
ipc_data_t *reply)
{
call_t call;
288,7 → 288,7
ipc_call_static_init(&call);
rc = copy_from_uspace(&call.data.args, &question->args, sizeof(call.data.args));
if (rc != 0)
return (__native) rc;
return (unative_t) rc;
GET_CHECK_PHONE(phone, phoneid, return ENOENT);
323,8 → 323,8
* @return Call identification, returns -1 on fatal error,
-2 on 'Too many async request, handle answers first
*/
__native sys_ipc_call_async_fast(__native phoneid, __native method,
__native arg1, __native arg2)
unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
unative_t arg1, unative_t arg2)
{
call_t *call;
phone_t *phone;
346,7 → 346,7
else
ipc_backsend_err(phone, call, res);
return (__native) call;
return (unative_t) call;
}
/** Synchronous IPC call allowing to send whole message
353,7 → 353,7
*
* @return The same as sys_ipc_call_async
*/
__native sys_ipc_call_async(__native phoneid, ipc_data_t *data)
unative_t sys_ipc_call_async(unative_t phoneid, ipc_data_t *data)
{
call_t *call;
phone_t *phone;
369,7 → 369,7
rc = copy_from_uspace(&call->data.args, &data->args, sizeof(call->data.args));
if (rc != 0) {
ipc_call_free(call);
return (__native) rc;
return (unative_t) rc;
}
if (!(res=request_preprocess(call)))
ipc_call(phone, call);
376,7 → 376,7
else
ipc_backsend_err(phone, call, res);
return (__native) call;
return (unative_t) call;
}
/** Forward received call to another destination
386,8 → 386,8
* Warning: If implementing non-fast version, make sure that
* arg3 is not rewritten for certain system IPC
*/
__native sys_ipc_forward_fast(__native callid, __native phoneid,
__native method, __native arg1)
unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
unative_t method, unative_t arg1)
{
call_t *call;
phone_t *phone;
428,8 → 428,8
}
/** Send IPC answer */
__native sys_ipc_answer_fast(__native callid, __native retval,
__native arg1, __native arg2)
unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
unative_t arg1, unative_t arg2)
{
call_t *call;
ipc_data_t saved_data;
459,7 → 459,7
}
/** Send IPC answer */
__native sys_ipc_answer(__native callid, ipc_data_t *data)
unative_t sys_ipc_answer(unative_t callid, ipc_data_t *data)
{
call_t *call;
ipc_data_t saved_data;
493,7 → 493,7
/** Hang up the phone
*
*/
__native sys_ipc_hangup(int phoneid)
unative_t sys_ipc_hangup(int phoneid)
{
phone_t *phone;
513,7 → 513,7
*
* @return Callid, if callid & 1, then the call is answer
*/
__native sys_ipc_wait_for_call(ipc_data_t *calldata, __u32 usec, int flags)
unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec, int flags)
{
call_t *call;
532,7 → 532,7
ipc_call_free(call);
return ((__native)call) | IPC_CALLID_NOTIFICATION;
return ((unative_t)call) | IPC_CALLID_NOTIFICATION;
}
if (call->flags & IPC_CALL_ANSWERED) {
550,7 → 550,7
STRUCT_TO_USPACE(&calldata->args, &call->data.args);
ipc_call_free(call);
return ((__native)call) | IPC_CALLID_ANSWERED;
return ((unative_t)call) | IPC_CALLID_ANSWERED;
}
if (process_request(&TASK->answerbox, call))
561,17 → 561,17
if (STRUCT_TO_USPACE(calldata, &call->data)) {
return 0;
}
return (__native)call;
return (unative_t)call;
}
/** Connect irq handler to task */
__native sys_ipc_register_irq(int irq, irq_code_t *ucode)
unative_t sys_ipc_register_irq(int irq, irq_code_t *ucode)
{
if (!(cap_get(TASK) & CAP_IRQ_REG))
return EPERM;
if (irq >= IRQ_COUNT || irq <= -IPC_IRQ_RESERVED_VIRTUAL)
return (__native) ELIMIT;
return (unative_t) ELIMIT;
irq_ipc_bind_arch(irq);
579,13 → 579,13
}
/* Disconnect irq handler from task */
__native sys_ipc_unregister_irq(int irq)
unative_t sys_ipc_unregister_irq(int irq)
{
if (!(cap_get(TASK) & CAP_IRQ_REG))
return EPERM;
if (irq >= IRQ_COUNT || irq <= -IPC_IRQ_RESERVED_VIRTUAL)
return (__native) ELIMIT;
return (unative_t) ELIMIT;
ipc_irq_unregister(&TASK->answerbox, irq);

/kernel/trunk/generic/src/ipc/ipc.c
61,7 → 61,7
/* Initialize new call */
static void _ipc_call_init(call_t *call)
{
memsetb((__address)call, sizeof(*call), 0);
memsetb((uintptr_t)call, sizeof(*call), 0);
call->callerbox = &TASK->answerbox;
call->sender = TASK;
}
185,7 → 185,7
* Most errors are better handled by forming a normal backward
* message and sending it as a normal answer.
*/
void ipc_backsend_err(phone_t *phone, call_t *call, __native err)
void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)
{
call->data.phone = phone;
atomic_inc(&phone->active_calls);
308,7 → 308,7
* @return Recived message address
* - to distinguish between call and answer, look at call->flags
*/
call_t * ipc_wait_for_call(answerbox_t *box, __u32 usec, int flags)
call_t * ipc_wait_for_call(answerbox_t *box, uint32_t usec, int flags)
{
call_t *request;
ipl_t ipl;

/kernel/trunk/generic/src/ipc/irq.c
72,7 → 72,7
static void code_execute(call_t *call, irq_code_t *code)
{
int i;
__native dstval = 0;
unative_t dstval = 0;
if (!code)
return;
80,28 → 80,28
for (i=0; i < code->cmdcount;i++) {
switch (code->cmds[i].cmd) {
case CMD_MEM_READ_1:
dstval = *((__u8 *)code->cmds[i].addr);
dstval = *((uint8_t *)code->cmds[i].addr);
break;
case CMD_MEM_READ_2:
dstval = *((__u16 *)code->cmds[i].addr);
dstval = *((uint16_t *)code->cmds[i].addr);
break;
case CMD_MEM_READ_4:
dstval = *((__u32 *)code->cmds[i].addr);
dstval = *((uint32_t *)code->cmds[i].addr);
break;
case CMD_MEM_READ_8:
dstval = *((__u64 *)code->cmds[i].addr);
dstval = *((uint64_t *)code->cmds[i].addr);
break;
case CMD_MEM_WRITE_1:
*((__u8 *)code->cmds[i].addr) = code->cmds[i].value;
*((uint8_t *)code->cmds[i].addr) = code->cmds[i].value;
break;
case CMD_MEM_WRITE_2:
*((__u16 *)code->cmds[i].addr) = code->cmds[i].value;
*((uint16_t *)code->cmds[i].addr) = code->cmds[i].value;
break;
case CMD_MEM_WRITE_4:
*((__u32 *)code->cmds[i].addr) = code->cmds[i].value;
*((uint32_t *)code->cmds[i].addr) = code->cmds[i].value;
break;
case CMD_MEM_WRITE_8:
*((__u64 *)code->cmds[i].addr) = code->cmds[i].value;
*((uint64_t *)code->cmds[i].addr) = code->cmds[i].value;
break;
#if defined(ia32) || defined(amd64)
case CMD_PORT_READ_1:
234,7 → 234,7
/** Send notification message
*
*/
void ipc_irq_send_msg(int irq, __native a1, __native a2, __native a3)
void ipc_irq_send_msg(int irq, unative_t a1, unative_t a2, unative_t a3)
{
call_t *call;
int mq = irq + IPC_IRQ_RESERVED_VIRTUAL;