Add stack protection and memory usage

Add stack protection by explicit stack setting
Dump memory usage(heap/stack) via macro

Makefile

@@ -30,7 +30,9 @@ CFLAGS += -Wno-incompatible-library-redeclaration -Wno-implicit-const-int-float-
 
 CFLAGS += -DCKB_DECLARATION_ONLY
 CFLAGS += -D__BYTE_ORDER=1234 -D__LITTLE_ENDIAN=1234 -D__ISO_C_VISIBLE=1999 -D__GNU_VISIBLE
-CFLAGS += -DCKB_MALLOC_DECLARATION_ONLY -DCKB_PRINTF_DECLARATION_ONLY -DCONFIG_BIGNUM
+CFLAGS += -DCKB_MALLOC_DECLARATION_ONLY -DCKB_PRINTF_DECLARATION_ONLY -DCONFIG_BIGNUM -DCONFIG_STACK_CHECK 
+# uncomment to dump memory usage
+# CFLAGS += -DMEMORY_USAGE
 
 LDFLAGS := -static --gc-sections
 LDFLAGS += -Ldeps/compiler-rt-builtins-riscv/build -lcompiler-rt

include/c-stdlib/my_malloc.h

@@ -0,0 +1,10 @@
+#ifndef _STDLIB_MALLOC_H_
+#define _STDLIB_MALLOC_H_
+
+#include <stdint.h>
+
+size_t malloc_usable_size(void *ptr);
+void malloc_config(uintptr_t min, uintptr_t max);
+size_t malloc_usage();
+
+#endif  // _STDLIB_MALLOC_H_

include/c-stdlib/src/malloc_impl.c

@@ -59,6 +59,12 @@ void malloc_config(uintptr_t min, uintptr_t max) {
     s_program_break = 0;
 }
 
+size_t malloc_usage() {
+    size_t high = (size_t)s_program_break;
+    size_t low = (size_t)s_brk_min;
+    return high - low;
+}
+
 void *_sbrk(uintptr_t incr) {
     if (!s_program_break) {
         s_program_break = s_brk_min;
@@ -385,3 +391,8 @@ void free(void *p) {
     struct chunk *self = CKB_MEM_TO_CHUNK(p);
     __bin_chunk(self);
 }
+
+size_t malloc_usable_size(void *ptr) {
+    struct chunk *c = CKB_MEM_TO_CHUNK(ptr);
+    return CKB_CHUNK_PSIZE(c);
+}

quickjs/qjs.c

@@ -30,6 +30,7 @@
 #include <string.h>
 #include <stddef.h>
 #include <stdbool.h>
+#include "my_malloc.h"
 #include "cutils.h"
 #include "std_module.h"
 #include "ckb_module.h"
@@ -290,7 +291,7 @@ int main(int argc, const char **argv) {
     JSRuntime *rt = NULL;
     JSContext *ctx = NULL;
     size_t memory_limit = 0;
-    size_t stack_size = 0;
+    size_t stack_size = 1024 * 1020;
     size_t optind = 1;
     RunJSType type = parse_args(argc, argv);
     if (type == RunJsError) {
@@ -355,6 +356,14 @@ int main(int argc, const char **argv) {
             return -1;
     }
     CHECK(err);
+
+#ifdef MEMORY_USAGE
+    size_t heap_usage = malloc_usage();
+    printf("Total bytes used by allocator(malloc/realloc) is %d K", heap_usage / 1024);
+    size_t stack_usage = JS_GetStackPeak();
+    printf("Total bytes used by stack(peak value) is %d K", (4 * 1024 * 1024 - stack_usage) / 1024);
+#endif
+
 exit:
     // No cleanup is needed.
     // js_std_free_handlers(rt);

quickjs/quickjs.c

@@ -1589,6 +1589,7 @@ static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
     return FALSE;
 }
 #else
+uintptr_t s_stack_peak = 4*1024*1024;
 /* Note: OS and CPU dependent */
 static inline uintptr_t js_get_stack_pointer(void)
 {
@@ -1598,9 +1599,18 @@ static inline uintptr_t js_get_stack_pointer(void)
 static inline BOOL js_check_stack_overflow(JSRuntime *rt, size_t alloca_size)
 {
     uintptr_t sp;
-    sp = js_get_stack_pointer() - alloca_size;
+    uintptr_t stack = js_get_stack_pointer();
+    if (stack < s_stack_peak) {
+        s_stack_peak = stack;
+    }
+    sp = stack - alloca_size;
     return unlikely(sp < rt->stack_limit);
 }
+
+uintptr_t JS_GetStackPeak() {
+    return s_stack_peak;
+}
+
 #endif
 
 JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)

quickjs/quickjs.h

@@ -1051,6 +1051,7 @@ int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
                        JSValue val);
 int JS_SetModuleExportList(JSContext *ctx, JSModuleDef *m,
                            const JSCFunctionListEntry *tab, int len);
+uintptr_t JS_GetStackPeak();
 
 #undef js_unlikely
 #undef js_force_inline

tests/ckb_js_tests/test_data/simple_udt.js

@@ -111,4 +111,7 @@ function main() {
     return 0;
 }
 
-ckb.exit(main());
+let exit_code = main();
+if (exit_code != 0) {
+    ckb.exit(exit_code);
+}