nijinlong1
/
sledge-serverles-framwork
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: wasm_memory

Browse Source
master
Sean McBride 3 years ago
parent 4b1f9914f7
commit 3cf4580b5d
11 changed files with 245 additions and 121 deletions
Show Stats Download Patch File Download Diff File

86
runtime/compiletime/memory_instructions.c
Unescape View File

@ -1,48 +1,60 @@
#include <assert.h>
#include "wasm_module_instance.h"
#include "current_wasm_module_instance.h"
INLINE uint32_t
instruction_memory_size()
{
return wasm_memory_get_page_count(current_wasm_module_instance.memory);
return (uint32_t)(current_wasm_module_instance.memory.size / WASM_PAGE_SIZE);
}
// All of these are pretty generic
// These functions are equivalent to those in wasm_memory.h, but they minimize pointer dereferencing
INLINE float
get_f32(uint32_t offset)
{
return wasm_memory_get_f32(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(float) <= current_wasm_module_instance.memory.size);
return *(float *)&current_wasm_module_instance.memory.buffer[offset];
}
INLINE double
get_f64(uint32_t offset)
{
return wasm_memory_get_f64(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(double) <= current_wasm_module_instance.memory.size);
return *(double *)&current_wasm_module_instance.memory.buffer[offset];
}
INLINE int8_t
get_i8(uint32_t offset)
{
return wasm_memory_get_i8(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int8_t) <= current_wasm_module_instance.memory.size);
return *(int8_t *)&current_wasm_module_instance.memory.buffer[offset];
}
INLINE int16_t
get_i16(uint32_t offset)
{
return wasm_memory_get_i16(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int16_t) <= current_wasm_module_instance.memory.size);
return *(int16_t *)&current_wasm_module_instance.memory.buffer[offset];
}
INLINE int32_t
get_i32(uint32_t offset)
{
return wasm_memory_get_i32(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int32_t) <= current_wasm_module_instance.memory.size);
return *(int32_t *)&current_wasm_module_instance.memory.buffer[offset];
}
INLINE int64_t
get_i64(uint32_t offset)
{
return wasm_memory_get_i64(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int64_t) <= current_wasm_module_instance.memory.size);
return *(int64_t *)&current_wasm_module_instance.memory.buffer[offset];
}
INLINE int32_t
@ -59,51 +71,65 @@ get_global_i64(uint32_t offset)
// Now setting routines
INLINE void
set_f32(uint32_t offset, float v)
set_f32(uint32_t offset, float value)
{
wasm_memory_set_f32(current_wasm_module_instance.memory, offset, v);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(float) <= current_wasm_module_instance.memory.size);
*(float *)&current_wasm_module_instance.memory.buffer[offset] = value;
}
INLINE void
set_f64(uint32_t offset, double v)
set_f64(uint32_t offset, double value)
{
wasm_memory_set_f64(current_wasm_module_instance.memory, offset, v);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(double) <= current_wasm_module_instance.memory.size);
*(double *)&current_wasm_module_instance.memory.buffer[offset] = value;
}
INLINE void
set_i8(uint32_t offset, int8_t v)
set_i8(uint32_t offset, int8_t value)
{
wasm_memory_set_i8(current_wasm_module_instance.memory, offset, v);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int8_t) <= current_wasm_module_instance.memory.size);
*(int8_t *)&current_wasm_module_instance.memory.buffer[offset] = value;
}
INLINE void
set_i16(uint32_t offset, int16_t v)
set_i16(uint32_t offset, int16_t value)
{
wasm_memory_set_i16(current_wasm_module_instance.memory, offset, v);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int16_t) <= current_wasm_module_instance.memory.size);
*(int16_t *)&current_wasm_module_instance.memory.buffer[offset] = value;
}
INLINE void
set_i32(uint32_t offset, int32_t v)
set_i32(uint32_t offset, int32_t value)
{
wasm_memory_set_i32(current_wasm_module_instance.memory, offset, v);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int32_t) <= current_wasm_module_instance.memory.size);
*(int32_t *)&current_wasm_module_instance.memory.buffer[offset] = value;
}
INLINE void
set_i64(uint32_t offset, int64_t v)
set_i64(uint32_t offset, int64_t value)
{
wasm_memory_set_i64(current_wasm_module_instance.memory, offset, v);
assert(current_wasm_module_instance.memory.buffer != NULL);
assert(offset + sizeof(int64_t) <= current_wasm_module_instance.memory.size);
*(int64_t *)&current_wasm_module_instance.memory.buffer[offset] = value;
}
INLINE void
set_global_i32(uint32_t offset, int32_t v)
set_global_i32(uint32_t offset, int32_t value)
{
set_i32(offset, v);
set_i32(offset, value);
}
INLINE void
set_global_i64(uint32_t offset, int64_t v)
set_global_i64(uint32_t offset, int64_t value)
{
set_i64(offset, v);
set_i64(offset, value);
}
/**
@ -115,12 +141,15 @@ set_global_i64(uint32_t offset, int64_t v)
INLINE int32_t
instruction_memory_grow(uint32_t count)
{
int old_page_count = current_wasm_module_instance.memory->size / WASM_PAGE_SIZE;
int old_page_count = current_wasm_module_instance.memory.size / WASM_PAGE_SIZE;
/* Return -1 if we've hit the linear memory max */
int rc = wasm_memory_expand(current_wasm_module_instance.memory, WASM_PAGE_SIZE * count);
int rc = wasm_memory_expand(&current_wasm_module_instance.memory, WASM_PAGE_SIZE * count);
if (unlikely(rc == -1)) return -1;
/* We updated "forked state" in current_wasm_module_instance.memory. We need to write this back to persist */
current_wasm_module_instance_memory_writeback();
#ifdef LOG_SANDBOX_MEMORY_PROFILE
// Cache the runtime of the first N page allocations
for (int i = 0; i < count; i++) {
@ -131,7 +160,6 @@ instruction_memory_grow(uint32_t count)
}
}
#endif
return rc;
}
@ -139,5 +167,5 @@ instruction_memory_grow(uint32_t count)
INLINE void
initialize_region(uint32_t offset, uint32_t region_size, uint8_t region[region_size])
{
wasm_memory_initialize_region(current_wasm_module_instance.memory, offset, region_size, region);
wasm_memory_initialize_region(&current_wasm_module_instance.memory, offset, region_size, region);
}

28
runtime/include/current_sandbox.h
Unescape View File

@ -3,7 +3,7 @@
#include <threads.h>
#include "sandbox_types.h"
#include "wasm_module_instance.h"
#include "current_wasm_module_instance.h"
/* current sandbox that is active.. */
extern thread_local struct sandbox *worker_thread_current_sandbox;
@ -30,16 +30,20 @@ current_sandbox_set(struct sandbox *sandbox)
/* Unpack hierarchy to avoid pointer chasing */
if (sandbox == NULL) {
current_wasm_module_instance = (struct wasm_module_instance){
.memory = NULL,
.table = NULL,
.memory =
(struct wasm_memory){
.size = 0,
.capacity = 0,
.max = 0,
.buffer = NULL,
},
.table = NULL,
};
worker_thread_current_sandbox = NULL;
runtime_worker_threads_deadline[worker_thread_idx] = UINT64_MAX;
} else {
current_wasm_module_instance = (struct wasm_module_instance){
.memory = sandbox->memory,
.table = sandbox->module->indirect_table,
};
memcpy(&current_wasm_module_instance.memory, sandbox->memory, sizeof(struct wasm_memory));
current_wasm_module_instance.table = sandbox->module->indirect_table,
worker_thread_current_sandbox = sandbox;
runtime_worker_threads_deadline[worker_thread_idx] = sandbox->absolute_deadline;
}
@ -51,19 +55,19 @@ extern void current_sandbox_sleep();
static inline void *
current_sandbox_get_ptr_void(uint32_t offset, uint32_t bounds_check)
{
assert(current_wasm_module_instance.memory != NULL);
return wasm_memory_get_ptr_void(current_wasm_module_instance.memory, offset, bounds_check);
assert(current_wasm_module_instance.memory.capacity > 0);
return wasm_memory_get_ptr_void(&current_wasm_module_instance.memory, offset, bounds_check);
}
static inline char
current_sandbox_get_char(uint32_t offset)
{
assert(current_wasm_module_instance.memory != NULL);
return wasm_memory_get_char(current_wasm_module_instance.memory, offset);
assert(current_wasm_module_instance.memory.capacity > 0);
return wasm_memory_get_char(&current_wasm_module_instance.memory, offset);
}
static inline char *
current_sandbox_get_string(uint32_t offset, uint32_t size)
{
return wasm_memory_get_string(current_wasm_module_instance.memory, offset, size);
return wasm_memory_get_string(&current_wasm_module_instance.memory, offset, size);
}

7
runtime/include/current_wasm_module_instance.h
Unescape View File

@ -0,0 +1,7 @@
#pragma once
#include "wasm_module_instance.h"
extern thread_local struct wasm_module_instance current_wasm_module_instance;
extern void current_wasm_module_instance_memory_writeback(void);

2
runtime/include/sandbox_functions.h
Unescape View File

@ -36,7 +36,7 @@ sandbox_close_http(struct sandbox *sandbox)
static inline void
sandbox_free_linear_memory(struct sandbox *sandbox)
{
wasm_memory_free(sandbox->memory);
wasm_memory_delete(sandbox->memory);
sandbox->memory = NULL;
}

7
runtime/include/sandbox_setup_arguments.h
Unescape View File

@ -22,8 +22,13 @@ sandbox_setup_arguments(struct sandbox *sandbox)
* WASI, so not worth fixing*/
sandbox->arguments_offset = wasm_memory_get_size(sandbox->memory);
int rc = wasm_memory_expand(sandbox->memory, WASM_PAGE_SIZE);
/* Assumption: we can fit the arguments in a single wasm page */
int rc = wasm_memory_expand(sandbox->memory, WASM_PAGE_SIZE);
assert(rc == 0);
/* We have to update our cache here */
memcpy(&current_wasm_module_instance.memory, sandbox->memory, sizeof(struct wasm_memory));
stub_init(sandbox->arguments_offset);
}

181
runtime/include/wasm_memory.h
Unescape View File

@ -10,62 +10,113 @@
#include "types.h" /* PAGE_SIZE */
#include "wasm_types.h"
#define WASM_MEMORY_MAX (size_t) UINT32_MAX + 1
#define WASM_MEMORY_MAX (size_t) UINT32_MAX + 1
#define WASM_MEMORY_SIZE_TO_ALLOC ((size_t)WASM_MEMORY_MAX + /* guard page */ PAGE_SIZE)
struct wasm_memory {
size_t size; /* Initial Size in bytes */
size_t capacity; /* Size backed by actual pages */
size_t max; /* Soft cap in bytes. Defaults to 4GB */
uint8_t data[];
size_t size; /* Initial Size in bytes */
size_t capacity; /* Size backed by actual pages */
size_t max; /* Soft cap in bytes. Defaults to 4GB */
uint8_t *buffer;
};
static INLINE struct wasm_memory *wasm_memory_alloc(void);
static INLINE int wasm_memory_init(struct wasm_memory *self, size_t initial, size_t max);
static INLINE struct wasm_memory *wasm_memory_new(size_t initial, size_t max);
static INLINE void wasm_memory_deinit(struct wasm_memory *self);
static INLINE void wasm_memory_free(struct wasm_memory *self);
static INLINE void wasm_memory_delete(struct wasm_memory *self);
static INLINE struct wasm_memory *
wasm_memory_allocate(size_t initial, size_t max)
wasm_memory_alloc(void)
{
return malloc(sizeof(struct wasm_memory));
}
static INLINE int
wasm_memory_init(struct wasm_memory *self, size_t initial, size_t max)
{
assert(self != NULL);
/* We assume WASI modules, which are required to declare and export a linear memory with a non-zero size to
* allow a standard lib to initialize. Technically, a WebAssembly module that exports pure functions may not use
* a linear memory */
assert(initial > 0);
assert(initial <= (size_t)UINT32_MAX + 1);
assert(max > 0);
assert(max <= (size_t)UINT32_MAX + 1);
/* Allocate contiguous virtual addresses for struct, full linear memory, and guard page */
size_t size_to_alloc = sizeof(struct wasm_memory) + WASM_MEMORY_MAX + /* guard page */ PAGE_SIZE;
void * temp = mmap(NULL, size_to_alloc, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (temp == MAP_FAILED) {
fprintf(stderr, "wasm_memory_allocate - allocation failed, (size: %lu) %s\n", size_to_alloc,
strerror(errno));
return NULL;
}
struct wasm_memory *self = (struct wasm_memory *)temp;
/* Set the struct and initial pages to read / write */
size_t size_to_read_write = sizeof(struct wasm_memory) + initial;
/* Allocate buffer of contiguous virtual addresses for full wasm32 linear memory and guard page */
self->buffer = mmap(NULL, WASM_MEMORY_SIZE_TO_ALLOC, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (self->buffer == MAP_FAILED) return -1;
int rc = mprotect(self, size_to_read_write, PROT_READ | PROT_WRITE);
/* Set the initial bytes to read / write */
int rc = mprotect(self->buffer, initial, PROT_READ | PROT_WRITE);
if (rc != 0) {
perror("wasm_memory_allocate - prot r/w failed");
munmap(self, size_to_alloc);
assert(0);
return NULL;
munmap(self->buffer, WASM_MEMORY_SIZE_TO_ALLOC);
return -1;
}
self->size = initial;
self->capacity = initial;
self->max = max;
return 0;
}
static INLINE struct wasm_memory *
wasm_memory_new(size_t initial, size_t max)
{
struct wasm_memory *self = wasm_memory_alloc();
if (self == NULL) return self;
int rc = wasm_memory_init(self, initial, max);
if (rc < 0) {
assert(0);
wasm_memory_free(self);
return NULL;
}
return self;
}
static INLINE void
wasm_memory_deinit(struct wasm_memory *self)
{
assert(self != NULL);
assert(self->buffer != NULL);
munmap(self->buffer, WASM_MEMORY_SIZE_TO_ALLOC);
self->buffer = NULL;
self->size = 0;
self->capacity = 0;
self->max = 0;
}
static INLINE void
wasm_memory_free(struct wasm_memory *self)
{
size_t size_to_free = sizeof(struct wasm_memory) + WASM_MEMORY_MAX + /* guard page */ PAGE_SIZE;
munmap(self, size_to_free);
assert(self != NULL);
/* Assume prior deinitialization so we don't leak buffers */
assert(self->buffer == NULL);
free(self);
}
static INLINE void
wasm_memory_delete(struct wasm_memory *self)
{
assert(self != NULL);
wasm_memory_deinit(self);
wasm_memory_free(self);
}
static INLINE void
wasm_memory_wipe(struct wasm_memory *self)
{
memset(self->data, 0, self->size);
memset(self->buffer, 0, self->size);
}
static INLINE int
@ -77,8 +128,13 @@ wasm_memory_expand(struct wasm_memory *self, size_t size_to_expand)
return -1;
}
/* If recycling a wasm_memory from an object pool, a previous execution may have already expanded to or what
* beyond what we need. The capacity represents the "high water mark" of previous executions. If the desired
* size is less than this "high water mark," we just need to update size for accounting purposes. Otherwise, we
* need to actually issue an mprotect syscall. The goal of these optimizations is to reduce mmap and demand
* paging overhead for repeated instantiations of a WebAssembly module. */
if (target_size > self->capacity) {
int rc = mprotect(self, sizeof(struct wasm_memory) + target_size, PROT_READ | PROT_WRITE);
int rc = mprotect(self->buffer, target_size, PROT_READ | PROT_WRITE);
if (rc != 0) {
perror("wasm_memory_expand mprotect");
return -1;
@ -91,6 +147,28 @@ wasm_memory_expand(struct wasm_memory *self, size_t size_to_expand)
return 0;
}
static INLINE void
wasm_memory_set_size(struct wasm_memory *self, size_t size)
{
self->size = size;
}
static INLINE size_t
wasm_memory_get_size(struct wasm_memory *self)
{
return self->size;
}
static INLINE void
wasm_memory_initialize_region(struct wasm_memory *self, uint32_t offset, uint32_t region_size, uint8_t region[])
{
assert((size_t)offset + region_size <= self->size);
memcpy(&self->buffer[offset], region, region_size);
}
/* NOTE: These wasm_memory functions require pointer dereferencing. For this reason, they are not directly by wasm32
* instructions. These functions are intended to be used by the runtime to interacts with linear memories. */
/**
* Translates WASM offsets into runtime VM pointers
* @param offset an offset into the WebAssembly linear memory
@ -101,7 +179,7 @@ static INLINE void *
wasm_memory_get_ptr_void(struct wasm_memory *self, uint32_t offset, uint32_t size)
{
assert(offset + size <= self->size);
return (void *)&self->data[offset];
return (void *)&self->buffer[offset];
}
/**
@ -113,7 +191,7 @@ static INLINE char
wasm_memory_get_char(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(char) <= self->size);
return *(char *)&self->data[offset];
return *(char *)&self->buffer[offset];
}
/**
@ -125,7 +203,7 @@ static INLINE float
wasm_memory_get_f32(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(float) <= self->size);
return *(float *)&self->data[offset];
return *(float *)&self->buffer[offset];
}
/**
@ -137,7 +215,7 @@ static INLINE double
wasm_memory_get_f64(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(double) <= self->size);
return *(double *)&self->data[offset];
return *(double *)&self->buffer[offset];
}
/**
@ -149,7 +227,7 @@ static INLINE int8_t
wasm_memory_get_i8(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(int8_t) <= self->size);
return *(int8_t *)&self->data[offset];
return *(int8_t *)&self->buffer[offset];
}
/**
@ -161,7 +239,7 @@ static INLINE int16_t
wasm_memory_get_i16(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(int16_t) <= self->size);
return *(int16_t *)&self->data[offset];
return *(int16_t *)&self->buffer[offset];
}
/**
@ -173,7 +251,7 @@ static INLINE int32_t
wasm_memory_get_i32(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(int32_t) <= self->size);
return *(int32_t *)&self->data[offset];
return *(int32_t *)&self->buffer[offset];
}
/**
@ -185,7 +263,7 @@ static INLINE int64_t
wasm_memory_get_i64(struct wasm_memory *self, uint32_t offset)
{
assert(offset + sizeof(int64_t) <= self->size);
return *(int64_t *)&self->data[offset];
return *(int64_t *)&self->buffer[offset];
}
static INLINE uint32_t
@ -206,7 +284,7 @@ wasm_memory_get_string(struct wasm_memory *self, uint32_t offset, uint32_t size)
assert(offset + (sizeof(char) * size) <= self->size);
for (uint32_t i = 0; i < size; i++) {
if (self->data[offset + i] == '\0') return (char *)&self->data[offset];
if (self->buffer[offset + i] == '\0') return (char *)&self->buffer[offset];
}
return NULL;
}
@ -220,7 +298,7 @@ static INLINE void
wasm_memory_set_f32(struct wasm_memory *self, uint32_t offset, float value)
{
assert(offset + sizeof(float) <= self->size);
*(float *)&self->data[offset] = value;
*(float *)&self->buffer[offset] = value;
}
/**
@ -232,7 +310,7 @@ static INLINE void
wasm_memory_set_f64(struct wasm_memory *self, uint32_t offset, double value)
{
assert(offset + sizeof(double) <= self->size);
*(double *)&self->data[offset] = value;
*(double *)&self->buffer[offset] = value;
}
/**
@ -244,7 +322,7 @@ static INLINE void
wasm_memory_set_i8(struct wasm_memory *self, uint32_t offset, int8_t value)
{
assert(offset + sizeof(int8_t) <= self->size);
*(int8_t *)&self->data[offset] = value;
*(int8_t *)&self->buffer[offset] = value;
}
/**
@ -256,7 +334,7 @@ static INLINE void
wasm_memory_set_i16(struct wasm_memory *self, uint32_t offset, int16_t value)
{
assert(offset + sizeof(int16_t) <= self->size);
*(int16_t *)&self->data[offset] = value;
*(int16_t *)&self->buffer[offset] = value;
}
/**
@ -268,7 +346,7 @@ static INLINE void
wasm_memory_set_i32(struct wasm_memory *self, uint32_t offset, int32_t value)
{
assert(offset + sizeof(int32_t) <= self->size);
*(int32_t *)&self->data[offset] = value;
*(int32_t *)&self->buffer[offset] = value;
}
/**
@ -280,24 +358,5 @@ static INLINE void
wasm_memory_set_i64(struct wasm_memory *self, uint64_t offset, int64_t value)
{
assert(offset + sizeof(int64_t) <= self->size);
*(int64_t *)&self->data[offset] = value;
}
static INLINE void
wasm_memory_set_size(struct wasm_memory *self, size_t size)
{
self->size = size;
}
static INLINE size_t
wasm_memory_get_size(struct wasm_memory *self)
{
return self->size;
}
static INLINE void
wasm_memory_initialize_region(struct wasm_memory *self, uint32_t offset, uint32_t region_size, uint8_t region[])
{
assert((size_t)offset + region_size <= self->size);
memcpy(&self->data[offset], region, region_size);
*(int64_t *)&self->buffer[offset] = value;
}

6
runtime/include/wasm_module_instance.h
Unescape View File

@ -7,8 +7,6 @@
* entities https://webassembly.github.io/spec/core/exec/runtime.html#module-instances
*/
struct wasm_module_instance {
struct wasm_memory *memory;
struct wasm_table * table;
struct wasm_memory memory;
struct wasm_table *table;
};
extern thread_local struct wasm_module_instance current_wasm_module_instance;

5
runtime/src/current_sandbox.c
Unescape View File

@ -16,11 +16,6 @@
thread_local struct sandbox *worker_thread_current_sandbox = NULL;
thread_local struct wasm_module_instance current_wasm_module_instance = {
.memory = NULL,
.table = NULL,
};
/**
* @brief Switches from an executing sandbox to the worker thread base context
*

28
runtime/src/current_wasm_module_instance.c
Unescape View File

@ -0,0 +1,28 @@
#include <stdlib.h>
#include "current_sandbox.h"
#include "wasm_module_instance.h"
#include "wasm_memory.h"
thread_local struct wasm_module_instance current_wasm_module_instance = {
.memory =
(struct wasm_memory){
.size = 0,
.max = 0,
.capacity = 0,
.buffer = NULL,
},
.table = NULL,
};
/**
* Because we copy the members of a sandbox when it is set to current_sandbox, current_wasm_module_instance acts as a
* cache. If we change state by doing something like expanding a member, we have to perform writeback on the sandbox
* member that we copied from.
*/
void
current_wasm_module_instance_memory_writeback(void)
{
struct sandbox *current_sandbox = current_sandbox_get();
memcpy(current_sandbox->memory, &current_wasm_module_instance.memory, sizeof(struct wasm_memory));
}

14
runtime/src/libc/syscall.c
Unescape View File

@ -223,8 +223,8 @@ wasm_mmap(int32_t addr, int32_t len, int32_t prot, int32_t flags, int32_t fd, in
assert(len % WASM_PAGE_SIZE == 0);
int32_t result = wasm_memory_get_size(current_wasm_module_instance.memory);
if (wasm_memory_expand(current_wasm_module_instance.memory, len) == -1) { result = (uint32_t)-1; }
int32_t result = wasm_memory_get_size(&current_wasm_module_instance.memory);
if (wasm_memory_expand(&current_wasm_module_instance.memory, len) == -1) { result = (uint32_t)-1; }
return result;
}
@ -321,18 +321,18 @@ wasm_mremap(int32_t offset, int32_t old_size, int32_t new_size, int32_t flags)
if (new_size <= old_size) return offset;
// If at end of linear memory, just expand and return same address
if (offset + old_size == current_wasm_module_instance.memory->size) {
if (offset + old_size == current_wasm_module_instance.memory.size) {
int32_t amount_to_expand = new_size - old_size;
wasm_memory_expand(current_wasm_module_instance.memory, amount_to_expand);
wasm_memory_expand(&current_wasm_module_instance.memory, amount_to_expand);
return offset;
}
// Otherwise allocate at end of address space and copy
int32_t new_offset = current_wasm_module_instance.memory->size;
wasm_memory_expand(current_wasm_module_instance.memory, new_size);
int32_t new_offset = current_wasm_module_instance.memory.size;
wasm_memory_expand(&current_wasm_module_instance.memory, new_size);
// Get pointer of old offset and pointer of new offset
uint8_t *linear_mem = current_wasm_module_instance.memory->data;
uint8_t *linear_mem = current_wasm_module_instance.memory.buffer;
uint8_t *src = &linear_mem[offset];
uint8_t *dest = &linear_mem[new_offset];

2
runtime/src/sandbox.c
Unescape View File

@ -43,7 +43,7 @@ sandbox_allocate_linear_memory(struct sandbox *sandbox)
assert(initial <= (size_t)UINT32_MAX + 1);
assert(max <= (size_t)UINT32_MAX + 1);
sandbox->memory = wasm_memory_allocate(initial, max);
sandbox->memory = wasm_memory_new(initial, max);
if (unlikely(sandbox->memory == NULL)) return -1;
return 0;

Write Preview
Loading…
Cancel
Save