haiwan
/
sledge
0
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: refactor out i32

Browse Source
main
Sean McBride 4 years ago
parent ec3b489b21
commit 213c558a75
11 changed files with 161 additions and 159 deletions
Show Stats Download Patch File Download Diff File

16
runtime/compiletime/instr.c
Unescape View File

@ -66,15 +66,15 @@ u32_rem(uint32_t a, uint32_t b)
return a % b;
}
INLINE i32
i32_div(i32 a, i32 b)
INLINE int32_t
i32_div(int32_t a, int32_t b)
{
assert(b && (a != INT32_MIN || b != -1));
return a / b;
}
INLINE i32
i32_rem(i32 a, i32 b)
INLINE int32_t
i32_rem(int32_t a, int32_t b)
{
assert(b && (a != INT32_MIN || b != -1));
return a % b;
@ -118,11 +118,11 @@ u32_trunc_f32(float f)
return (uint32_t)f;
}
i32
int32_t
i32_trunc_f32(float f)
{
assert(INT32_MIN <= f && f <= INT32_MAX);
return (i32)f;
return (int32_t)f;
}
uint32_t
@ -132,11 +132,11 @@ u32_trunc_f64(double f)
return (uint32_t)f;
}
i32
int32_t
i32_trunc_f64(double f)
{
assert(INT32_MIN <= f && f <= INT32_MAX);
return (i32)f;
return (int32_t)f;
}
uint64_t

44
runtime/compiletime/memory/64bit_nix.c
Unescape View File

@ -5,7 +5,7 @@
// All of these are pretty generic
INLINE float
get_f32(i32 offset)
get_f32(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -14,7 +14,7 @@ get_f32(i32 offset)
}
INLINE double
get_f64(i32 offset)
get_f64(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -23,7 +23,7 @@ get_f64(i32 offset)
}
INLINE i8
get_i8(i32 offset)
get_i8(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -32,7 +32,7 @@ get_i8(i32 offset)
}
INLINE i16
get_i16(i32 offset)
get_i16(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -40,17 +40,17 @@ get_i16(i32 offset)
return *(i16 *)address;
}
INLINE i32
get_i32(i32 offset)
INLINE int32_t
get_i32(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
return *(i32 *)address;
return *(int32_t *)address;
}
INLINE int64_t
get_i64(i32 offset)
get_i64(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -58,17 +58,17 @@ get_i64(i32 offset)
return *(int64_t *)address;
}
INLINE i32
get_global_i32(i32 offset)
INLINE int32_t
get_global_i32(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
return *(i32 *)address;
return *(int32_t *)address;
}
INLINE int64_t
get_global_i64(i32 offset)
get_global_i64(int32_t offset)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -78,7 +78,7 @@ get_global_i64(i32 offset)
// Now setting routines
INLINE void
set_f32(i32 offset, float v)
set_f32(int32_t offset, float v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -87,7 +87,7 @@ set_f32(i32 offset, float v)
}
INLINE void
set_f64(i32 offset, double v)
set_f64(int32_t offset, double v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -96,7 +96,7 @@ set_f64(i32 offset, double v)
}
INLINE void
set_i8(i32 offset, i8 v)
set_i8(int32_t offset, i8 v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -105,7 +105,7 @@ set_i8(i32 offset, i8 v)
}
INLINE void
set_i16(i32 offset, i16 v)
set_i16(int32_t offset, i16 v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -114,16 +114,16 @@ set_i16(i32 offset, i16 v)
}
INLINE void
set_i32(i32 offset, i32 v)
set_i32(int32_t offset, int32_t v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
*(i32 *)address = v;
*(int32_t *)address = v;
}
INLINE void
set_i64(i32 offset, int64_t v)
set_i64(int32_t offset, int64_t v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
@ -132,16 +132,16 @@ set_i64(i32 offset, int64_t v)
}
INLINE void
set_global_i32(i32 offset, i32 v)
set_global_i32(int32_t offset, int32_t v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];
*(i32 *)address = v;
*(int32_t *)address = v;
}
INLINE void
set_global_i64(i32 offset, int64_t v)
set_global_i64(int32_t offset, int64_t v)
{
char *mem_as_chars = (char *)local_sandbox_context_cache.linear_memory_start;
void *address = &mem_as_chars[offset];

12
runtime/include/module.h
Unescape View File

@ -8,7 +8,7 @@ struct module {
char name[MODULE_MAX_NAME_LENGTH];
char path[MODULE_MAX_PATH_LENGTH];
void * dynamic_library_handle; /* Handle to the *.so of the serverless function */
i32 argument_count;
int32_t argument_count;
uint32_t stack_size; /* a specification? */
uint64_t max_memory; /* perhaps a specification of the module. (max 4GB) */
uint32_t relative_deadline_us;
@ -72,7 +72,7 @@ module_acquire(struct module *module)
* @param module
* @returns the number of arguments
*/
static inline i32
static inline int32_t
module_get_argument_count(struct module *module)
{
return module->argument_count;
@ -107,7 +107,7 @@ module_initialize_table(struct module *module)
* @param arguments - address?
*/
static inline void
module_initialize_libc(struct module *module, i32 env, i32 arguments)
module_initialize_libc(struct module *module, int32_t env, int32_t arguments)
{
/* called in a sandbox. */
module->initialize_libc(env, arguments);
@ -142,8 +142,8 @@ module_is_valid(struct module *module)
* @param argv standard UNIX vector of arguments
* @return return code of module's main function
*/
static inline i32
module_main(struct module *module, i32 argc, i32 argv)
static inline int32_t
module_main(struct module *module, int32_t argc, int32_t argv)
{
return module->main(argc, argv);
}
@ -186,6 +186,6 @@ module_set_http_info(struct module *module, int request_count, char *request_hea
*******************************/
void module_free(struct module *module);
struct module *module_new(char *mod_name, char *mod_path, i32 argument_count, uint32_t stack_sz, uint32_t max_heap,
struct module *module_new(char *mod_name, char *mod_path, int32_t argument_count, uint32_t stack_sz, uint32_t max_heap,
uint32_t relative_deadline_us, int port, int req_sz, int resp_sz);
int module_new_from_json(char *filename);

2
runtime/include/runtime.h
Unescape View File

@ -12,6 +12,6 @@ INLINE char *get_function_from_table(uint32_t idx, uint32_t type_id);
INLINE char *get_memory_ptr_for_runtime(uint32_t offset, uint32_t bounds_check);
void runtime_initialize(void);
void listener_thread_initialize(void);
void stub_init(i32 offset);
void stub_init(int32_t offset);
unsigned long long __getcycles(void);

6
runtime/include/sandbox.h
Unescape View File

@ -50,9 +50,9 @@ struct sandbox {
struct module *module; /* the module this is an instance of */
i32 arguments_offset; /* actual placement of arguments in the sandbox. */
void *arguments; /* arguments from request, must be of module->argument_count size. */
i32 return_value;
int32_t arguments_offset; /* actual placement of arguments in the sandbox. */
void * arguments; /* arguments from request, must be of module->argument_count size. */
int32_t return_value;
struct sandbox_io_handle io_handles[SANDBOX_MAX_IO_HANDLE_COUNT];
struct sockaddr client_address; /* client requesting connection! */

7
runtime/include/types.h
Unescape View File

@ -40,7 +40,6 @@ typedef signed char i8;
typedef unsigned char u8;
typedef int16_t i16;
typedef uint16_t u16;
typedef int32_t i32;
/* FIXME: per-module configuration? */
#define WASM_PAGE_SIZE (1024 * 64) /* 64KB */
@ -79,14 +78,14 @@ struct sandbox_context_cache {
extern __thread struct sandbox_context_cache local_sandbox_context_cache;
/* TODO: LOG_TO_FILE logic is untested */
extern i32 runtime_log_file_descriptor;
extern int32_t runtime_log_file_descriptor;
/* functions in the module to lookup and call per sandbox. */
typedef i32 (*mod_main_fn_t)(i32 a, i32 b);
typedef int32_t (*mod_main_fn_t)(int32_t a, int32_t b);
typedef void (*mod_glb_fn_t)(void);
typedef void (*mod_mem_fn_t)(void);
typedef void (*mod_tbl_fn_t)(void);
typedef void (*mod_libc_fn_t)(i32, i32);
typedef void (*mod_libc_fn_t)(int32_t, int32_t);
/**
* debuglog is a macro that behaves based on the macros DEBUG and LOG_TO_FILE

74
runtime/src/env.c
Unescape View File

@ -4,18 +4,18 @@
#include "runtime.h"
#include "worker_thread.h"
extern i32 inner_syscall_handler(i32 n, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f);
extern int32_t inner_syscall_handler(int32_t n, int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f);
i32
env_syscall_handler(i32 n, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f)
int32_t
env_syscall_handler(int32_t n, int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f)
{
i32 i = inner_syscall_handler(n, a, b, c, d, e, f);
int32_t i = inner_syscall_handler(n, a, b, c, d, e, f);
return i;
}
i32
env___syscall(i32 n, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f)
int32_t
env___syscall(int32_t n, int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f)
{
return env_syscall_handler(n, a, b, c, d, e, f);
}
@ -26,49 +26,49 @@ env___unmapself(uint32_t base, uint32_t size)
/* Just do some no op */
}
i32
int32_t
env_a_ctz_64(uint64_t x)
{
return __builtin_ctzll(x);
}
INLINE void
env_a_and_64(i32 p_off, uint64_t v)
env_a_and_64(int32_t p_off, uint64_t v)
{
uint64_t *p = worker_thread_get_memory_ptr_void(p_off, sizeof(uint64_t));
ck_pr_and_64(p, v);
}
INLINE void
env_a_or_64(i32 p_off, int64_t v)
env_a_or_64(int32_t p_off, int64_t v)
{
assert(sizeof(int64_t) == sizeof(uint64_t));
uint64_t *p = worker_thread_get_memory_ptr_void(p_off, sizeof(int64_t));
ck_pr_or_64(p, v);
}
i32
env_a_cas(i32 p_off, i32 t, i32 s)
int32_t
env_a_cas(int32_t p_off, int32_t t, int32_t s)
{
assert(sizeof(i32) == sizeof(volatile int));
int *p = worker_thread_get_memory_ptr_void(p_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *p = worker_thread_get_memory_ptr_void(p_off, sizeof(int32_t));
return ck_pr_cas_int(p, t, s);
}
void
env_a_or(i32 p_off, i32 v)
env_a_or(int32_t p_off, int32_t v)
{
assert(sizeof(i32) == sizeof(volatile int));
int *p = worker_thread_get_memory_ptr_void(p_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *p = worker_thread_get_memory_ptr_void(p_off, sizeof(int32_t));
ck_pr_or_int(p, v);
}
i32
env_a_swap(i32 x_off, i32 v)
int32_t
env_a_swap(int32_t x_off, int32_t v)
{
assert(sizeof(i32) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(int32_t));
int p;
do {
@ -79,59 +79,59 @@ env_a_swap(i32 x_off, i32 v)
return v;
}
i32
env_a_fetch_add(i32 x_off, i32 v)
int32_t
env_a_fetch_add(int32_t x_off, int32_t v)
{
assert(sizeof(i32) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(int32_t));
return ck_pr_faa_int(x, v);
}
void
env_a_inc(i32 x_off)
env_a_inc(int32_t x_off)
{
assert(sizeof(i32) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(int32_t));
ck_pr_inc_int(x);
}
void
env_a_dec(i32 x_off)
env_a_dec(int32_t x_off)
{
assert(sizeof(i32) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *x = worker_thread_get_memory_ptr_void(x_off, sizeof(int32_t));
ck_pr_dec_int(x);
}
void
env_a_store(i32 p_off, i32 x)
env_a_store(int32_t p_off, int32_t x)
{
assert(sizeof(i32) == sizeof(volatile int));
int *p = worker_thread_get_memory_ptr_void(p_off, sizeof(i32));
assert(sizeof(int32_t) == sizeof(volatile int));
int *p = worker_thread_get_memory_ptr_void(p_off, sizeof(int32_t));
ck_pr_store_int(p, x);
}
int
env_a_ctz_32(i32 x)
env_a_ctz_32(int32_t x)
{
return __builtin_ctz(x);
}
void
env_do_spin(i32 i)
env_do_spin(int32_t i)
{
ck_pr_stall();
}
void
env_do_crash(i32 i)
env_do_crash(int32_t i)
{
printf("crashing: %d\n", i);
assert(0);
}
void
env_do_barrier(i32 x)
env_do_barrier(int32_t x)
{
ck_pr_barrier();
}

134
runtime/src/libc/uvio.c
Unescape View File

@ -35,18 +35,18 @@
// offset = a WASM ptr to memory the runtime can use
void
stub_init(i32 offset)
stub_init(int32_t offset)
{
// What program name will we put in the auxiliary vectors
char *program_name = current_sandbox_get()->module->name;
// Copy the program name into WASM accessible memory
i32 program_name_offset = offset;
int32_t program_name_offset = offset;
strcpy(get_memory_ptr_for_runtime(offset, sizeof(program_name)), program_name);
offset += sizeof(program_name);
// The construction of this is:
// evn1, env2, ..., NULL, auxv_n1, auxv_1, auxv_n2, auxv_2 ..., NULL
i32 env_vec[] = {
int32_t env_vec[] = {
// Env variables would live here, but we don't supply any
0,
// We supply only the bare minimum AUX vectors
@ -63,10 +63,10 @@ stub_init(i32 offset)
AT_SECURE,
0,
AT_RANDOM,
(i32)rand(), // It's pretty stupid to use rand here, but w/e
(int32_t)rand(), // It's pretty stupid to use rand here, but w/e
0,
};
i32 env_vec_offset = offset;
int32_t env_vec_offset = offset;
memcpy(get_memory_ptr_for_runtime(env_vec_offset, sizeof(env_vec)), env_vec, sizeof(env_vec));
module_initialize_libc(current_sandbox_get()->module, env_vec_offset, program_name_offset);
@ -106,7 +106,7 @@ wasm_fs_callback(uv_fs_t *req)
// We define our own syscall numbers, because WASM uses x86_64 values even on systems that are not x86_64
#define SYS_READ 0
uint32_t
wasm_read(i32 filedes, i32 buf_offset, i32 nbyte)
wasm_read(int32_t filedes, int32_t buf_offset, int32_t nbyte)
{
if (filedes == 0) {
char * buffer = worker_thread_get_memory_ptr_void(buf_offset, nbyte);
@ -137,8 +137,8 @@ wasm_read(i32 filedes, i32 buf_offset, i32 nbyte)
}
#define SYS_WRITE 1
i32
wasm_write(i32 file_descriptor, i32 buf_offset, i32 buf_size)
int32_t
wasm_write(int32_t file_descriptor, int32_t buf_offset, int32_t buf_size)
{
if (file_descriptor == 1 || file_descriptor == 2) {
char * buffer = worker_thread_get_memory_ptr_void(buf_offset, buf_size);
@ -183,15 +183,15 @@ wasm_write(i32 file_descriptor, i32 buf_offset, i32 buf_size)
#define WO_CLOEXEC 02000000
#define SYS_OPEN 2
i32
wasm_open(i32 path_off, i32 flags, i32 mode)
int32_t
wasm_open(int32_t path_off, int32_t flags, int32_t mode)
{
uv_fs_t req = UV_FS_REQ_INIT();
char * path = worker_thread_get_memory_string(path_off, MODULE_MAX_PATH_LENGTH);
int iofd = current_sandbox_initialize_io_handle();
if (iofd < 0) return -1;
i32 modified_flags = 0;
int32_t modified_flags = 0;
if (flags & WO_RDONLY) modified_flags |= O_RDONLY;
if (flags & WO_WRONLY) modified_flags |= O_WRONLY;
if (flags & WO_RDWR) modified_flags |= O_RDWR;
@ -215,8 +215,8 @@ wasm_open(i32 path_off, i32 flags, i32 mode)
}
#define SYS_CLOSE 3
i32
wasm_close(i32 file_descriptor)
int32_t
wasm_close(int32_t file_descriptor)
{
if (file_descriptor >= 0 && file_descriptor <= 2) { return 0; }
struct sandbox * c = current_sandbox_get();
@ -259,22 +259,22 @@ struct wasm_stat {
uint32_t __pad0;
uint64_t st_rdev;
uint64_t st_size;
i32 st_blksize;
int32_t st_blksize;
int64_t st_blocks;
struct {
i32 tv_sec;
i32 tv_nsec;
int32_t tv_sec;
int32_t tv_nsec;
} st_atim;
struct {
i32 tv_sec;
i32 tv_nsec;
int32_t tv_sec;
int32_t tv_nsec;
} st_mtim;
struct {
i32 tv_sec;
i32 tv_nsec;
int32_t tv_sec;
int32_t tv_nsec;
} st_ctim;
i32 __pad1[3];
int32_t __pad1[3];
};
#define SYS_STAT 4
@ -297,14 +297,14 @@ struct wasm_stat {
// u_long st_gen; /* file generation number */
// };
i32
wasm_stat(uint32_t path_str_offset, i32 stat_offset)
int32_t
wasm_stat(uint32_t path_str_offset, int32_t stat_offset)
{
char * path = worker_thread_get_memory_string(path_str_offset, MODULE_MAX_PATH_LENGTH);
struct wasm_stat *stat_ptr = worker_thread_get_memory_ptr_void(stat_offset, sizeof(struct wasm_stat));
struct stat stat;
i32 res = lstat(path, &stat);
int32_t res = lstat(path, &stat);
if (res == -1) return -errno;
*stat_ptr = (struct wasm_stat){
@ -343,14 +343,14 @@ wasm_stat(uint32_t path_str_offset, i32 stat_offset)
}
#define SYS_FSTAT 5
i32
wasm_fstat(i32 filedes, i32 stat_offset)
int32_t
wasm_fstat(int32_t filedes, int32_t stat_offset)
{
struct wasm_stat *stat_ptr = worker_thread_get_memory_ptr_void(stat_offset, sizeof(struct wasm_stat));
struct stat stat;
int d = current_sandbox_get_file_descriptor(filedes);
i32 res = fstat(d, &stat);
int32_t res = fstat(d, &stat);
if (res == -1) return -errno;
*stat_ptr = (struct wasm_stat){
@ -389,14 +389,14 @@ wasm_fstat(i32 filedes, i32 stat_offset)
}
#define SYS_LSTAT 6
i32
wasm_lstat(i32 path_str_offset, i32 stat_offset)
int32_t
wasm_lstat(int32_t path_str_offset, int32_t stat_offset)
{
char * path = worker_thread_get_memory_string(path_str_offset, MODULE_MAX_PATH_LENGTH);
struct wasm_stat *stat_ptr = worker_thread_get_memory_ptr_void(stat_offset, sizeof(struct wasm_stat));
struct stat stat;
i32 res = lstat(path, &stat);
int32_t res = lstat(path, &stat);
if (res == -1) return -errno;
*stat_ptr = (struct wasm_stat){
@ -436,11 +436,11 @@ wasm_lstat(i32 path_str_offset, i32 stat_offset)
#define SYS_LSEEK 8
i32
wasm_lseek(i32 filedes, i32 file_offset, i32 whence)
int32_t
wasm_lseek(int32_t filedes, int32_t file_offset, int32_t whence)
{
int d = current_sandbox_get_file_descriptor(filedes);
i32 res = (i32)lseek(d, file_offset, whence);
int32_t res = (int32_t)lseek(d, file_offset, whence);
if (res == -1) return -errno;
@ -449,7 +449,7 @@ wasm_lseek(i32 filedes, i32 file_offset, i32 whence)
#define SYS_MMAP 9
uint32_t
wasm_mmap(i32 addr, i32 len, i32 prot, i32 flags, i32 file_descriptor, i32 offset)
wasm_mmap(int32_t addr, int32_t len, int32_t prot, int32_t flags, int32_t file_descriptor, int32_t offset)
{
int d = current_sandbox_get_file_descriptor(file_descriptor);
if (file_descriptor >= 0) assert(d >= 0);
@ -458,7 +458,7 @@ wasm_mmap(i32 addr, i32 len, i32 prot, i32 flags, i32 file_descriptor, i32 offse
assert(len % WASM_PAGE_SIZE == 0);
i32 result = local_sandbox_context_cache.linear_memory_size;
int32_t result = local_sandbox_context_cache.linear_memory_size;
for (int i = 0; i < len / WASM_PAGE_SIZE; i++) { expand_memory(); }
return result;
@ -473,8 +473,8 @@ wasm_mmap(i32 addr, i32 len, i32 prot, i32 flags, i32 file_descriptor, i32 offse
#define SYS_RT_SIGPROGMASK 14
#define SYS_IOCTL 16
i32
wasm_ioctl(i32 file_descriptor, i32 request, i32 data_offet)
int32_t
wasm_ioctl(int32_t file_descriptor, int32_t request, int32_t data_offet)
{
// int d = current_sandbox_get_file_descriptor(file_descriptor);
// musl libc does some ioctls to stdout, so just allow these to silently go through
@ -485,12 +485,12 @@ wasm_ioctl(i32 file_descriptor, i32 request, i32 data_offet)
#define SYS_READV 19
struct wasm_iovec {
i32 base_offset;
i32 len;
int32_t base_offset;
int32_t len;
};
i32
wasm_readv(i32 file_descriptor, i32 iov_offset, i32 iovcnt)
int32_t
wasm_readv(int32_t file_descriptor, int32_t iov_offset, int32_t iovcnt)
{
if (file_descriptor == 0) {
// both 1 and 2 go to client.
@ -543,8 +543,8 @@ wasm_readv(i32 file_descriptor, i32 iov_offset, i32 iovcnt)
}
#define SYS_WRITEV 20
i32
wasm_writev(i32 file_descriptor, i32 iov_offset, i32 iovcnt)
int32_t
wasm_writev(int32_t file_descriptor, int32_t iov_offset, int32_t iovcnt)
{
struct sandbox *c = current_sandbox_get();
if (file_descriptor == 1 || file_descriptor == 2) {
@ -693,8 +693,8 @@ struct wasm_time_spec {
uint32_t nanosec;
};
i32
wasm_get_time(i32 clock_id, i32 timespec_off)
int32_t
wasm_get_time(int32_t clock_id, int32_t timespec_off)
{
clockid_t real_clock;
switch (clock_id) {
@ -725,16 +725,16 @@ wasm_get_time(i32 clock_id, i32 timespec_off)
}
#define SYS_EXIT_GROUP 231
i32
wasm_exit_group(i32 status)
int32_t
wasm_exit_group(int32_t status)
{
exit(status);
return 0;
}
#define SYS_FCHOWN 93
i32
wasm_fchown(i32 file_descriptor, uint32_t owner, uint32_t group)
int32_t
wasm_fchown(int32_t file_descriptor, uint32_t owner, uint32_t group)
{
int d = current_sandbox_get_file_descriptor(file_descriptor);
uv_fs_t req = UV_FS_REQ_INIT();
@ -775,8 +775,8 @@ wasm_connect_callback(uv_connect_t *req, int status)
worker_thread_wakeup_sandbox(s);
}
i32
wasm_socket(i32 domain, i32 type, i32 protocol)
int32_t
wasm_socket(int32_t domain, int32_t type, int32_t protocol)
{
struct sandbox *c = current_sandbox_get();
int pfd = current_sandbox_initialize_io_handle(), file_descriptor = -1;
@ -802,8 +802,8 @@ wasm_socket(i32 domain, i32 type, i32 protocol)
return pfd;
}
i32
wasm_connect(i32 sockfd, i32 sockaddr_offset, i32 addrlen)
int32_t
wasm_connect(int32_t sockfd, int32_t sockaddr_offset, int32_t addrlen)
{
struct sandbox *c = current_sandbox_get();
int file_descriptor = current_sandbox_get_file_descriptor(sockfd);
@ -830,8 +830,8 @@ wasm_connect(i32 sockfd, i32 sockaddr_offset, i32 addrlen)
return -1;
}
i32
wasm_accept(i32 sockfd, i32 sockaddr_offset, i32 addrlen_offset)
int32_t
wasm_accept(int32_t sockfd, int32_t sockaddr_offset, int32_t addrlen_offset)
{
// what do we do with the sockaddr TODO: ????
socklen_t * addrlen = worker_thread_get_memory_ptr_void(addrlen_offset, sizeof(socklen_t));
@ -862,8 +862,8 @@ wasm_accept(i32 sockfd, i32 sockaddr_offset, i32 addrlen_offset)
return cfd;
}
i32
wasm_bind(i32 sockfd, i32 sockaddr_offset, i32 addrlen)
int32_t
wasm_bind(int32_t sockfd, int32_t sockaddr_offset, int32_t addrlen)
{
struct sandbox *c = current_sandbox_get();
int file_descriptor = current_sandbox_get_file_descriptor(sockfd);
@ -899,8 +899,8 @@ wasm_bind(i32 sockfd, i32 sockaddr_offset, i32 addrlen)
return -1;
}
i32
wasm_listen(i32 sockfd, i32 backlog)
int32_t
wasm_listen(int32_t sockfd, int32_t backlog)
{
struct sandbox * c = current_sandbox_get();
union uv_any_handle *h = current_sandbox_get_libuv_handle(sockfd);
@ -968,8 +968,9 @@ wasm_udp_send_callback(uv_udp_send_t *req, int status)
worker_thread_wakeup_sandbox(c);
}
i32
wasm_sendto(i32 file_descriptor, i32 buff_offset, i32 len, i32 flags, i32 sockaddr_offset, i32 sockaddr_len)
int32_t
wasm_sendto(int32_t file_descriptor, int32_t buff_offset, int32_t len, int32_t flags, int32_t sockaddr_offset,
int32_t sockaddr_len)
{
char *buffer = worker_thread_get_memory_ptr_void(buff_offset, len);
// TODO: only support "send" api for now
@ -1018,8 +1019,9 @@ wasm_alloc_callback(uv_handle_t *h, size_t suggested, uv_buf_t *buffer)
buffer->len = s->read_size;
}
i32
wasm_recvfrom(i32 file_descriptor, i32 buff_offset, i32 size, i32 flags, i32 sockaddr_offset, i32 socklen_offset)
int32_t
wasm_recvfrom(int32_t file_descriptor, int32_t buff_offset, int32_t size, int32_t flags, int32_t sockaddr_offset,
int32_t socklen_offset)
{
char * buffer = worker_thread_get_memory_ptr_void(buff_offset, size);
socklen_t *len = worker_thread_get_memory_ptr_void(socklen_offset, sizeof(socklen_t));
@ -1068,10 +1070,10 @@ wasm_recvfrom(i32 file_descriptor, i32 buff_offset, i32 size, i32 flags, i32 soc
return 0;
}
i32
inner_syscall_handler(i32 n, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f)
int32_t
inner_syscall_handler(int32_t n, int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f)
{
i32 res;
int32_t res;
switch (n) {
case SYS_READ:
return wasm_read(a, b, c);

2
runtime/src/main.c
Unescape View File

@ -17,7 +17,7 @@
/* Conditionally used by debuglog when DEBUG is set */
#ifdef DEBUG
i32 runtime_log_file_descriptor = -1;
int32_t runtime_log_file_descriptor = -1;
#endif
float runtime_processor_speed_MHz = 0;

12
runtime/src/module.c
Unescape View File

@ -103,7 +103,7 @@ module_free(struct module *module)
*/
struct module *
module_new(char *name, char *path, i32 argument_count, uint32_t stack_size, uint32_t max_memory,
module_new(char *name, char *path, int32_t argument_count, uint32_t stack_size, uint32_t max_memory,
uint32_t relative_deadline_us, int port, int request_size, int response_size)
{
errno = 0;
@ -316,14 +316,14 @@ module_new_from_json(char *file_name)
}
memset(reponse_headers, 0, HTTP_MAX_HEADER_LENGTH * HTTP_MAX_HEADER_COUNT);
i32 request_size = 0;
i32 response_size = 0;
i32 argument_count = 0;
int32_t request_size = 0;
int32_t response_size = 0;
int32_t argument_count = 0;
uint32_t port = 0;
uint32_t relative_deadline_us = 0;
bool is_active = false;
i32 request_count = 0;
i32 response_count = 0;
int32_t request_count = 0;
int32_t response_count = 0;
int j = 1;
int ntoks = 2 * tokens[i].size;
char request_content_type[HTTP_MAX_HEADER_VALUE_LENGTH] = { 0 };

9
runtime/src/sandbox.c
Unescape View File

@ -20,16 +20,17 @@ static inline void
sandbox_setup_arguments(struct sandbox *sandbox)
{
assert(sandbox != NULL);
char *arguments = sandbox_get_arguments(sandbox);
i32 argument_count = module_get_argument_count(sandbox->module);
char * arguments = sandbox_get_arguments(sandbox);
int32_t argument_count = module_get_argument_count(sandbox->module);
/* whatever gregor has, to be able to pass arguments to a module! */
sandbox->arguments_offset = local_sandbox_context_cache.linear_memory_size;
assert(local_sandbox_context_cache.linear_memory_start == sandbox->linear_memory_start);
expand_memory();
i32 *array_ptr = worker_thread_get_memory_ptr_void(sandbox->arguments_offset, argument_count * sizeof(i32));
i32 string_off = sandbox->arguments_offset + (argument_count * sizeof(i32));
int32_t *array_ptr = worker_thread_get_memory_ptr_void(sandbox->arguments_offset,
argument_count * sizeof(int32_t));
int32_t string_off = sandbox->arguments_offset + (argument_count * sizeof(int32_t));
for (int i = 0; i < argument_count; i++) {
char * arg = arguments + (i * MODULE_MAX_ARGUMENT_SIZE);

Write Preview
Loading…
Cancel
Save