diff --git a/core/client.js b/core/client.js index fc7a9596..22f35edc 100644 --- a/core/client.js +++ b/core/client.js @@ -432,9 +432,10 @@ function receive(message) { rpc_in: {group: 'rpc', name: 'in'}, rpc_out: {group: 'rpc', name: 'out'}, - memory_percent: {group: 'memory', name: 'total'}, js_malloc_percent: {group: 'memory', name: 'js'}, + memory_percent: {group: 'memory', name: 'total'}, sqlite3_memory_percent: {group: 'memory', name: 'sql'}, + tf_malloc_percent: {group: 'memory', name: 'tf'}, tls_malloc_percent: {group: 'memory', name: 'tls'}, uv_malloc_percent: {group: 'memory', name: 'uv'}, @@ -444,7 +445,7 @@ function receive(message) { import_count: {group: 'functions', name: 'imports'}, export_count: {group: 'functions', name: 'exports'}, }; - const k_colors = ['#0f0', '#88f', '#ff0', '#f0f', '#0ff']; + const k_colors = ['#0f0', '#88f', '#ff0', '#f0f', '#0ff', '#f00']; let graph_key = k_groups[key]?.group || key; let graph = gGraphs[graph_key]; if (!graph) { diff --git a/src/database.js.c b/src/database.js.c index b8c8a897..6d7ce329 100644 --- a/src/database.js.c +++ b/src/database.js.c @@ -1,7 +1,8 @@ #include "database.js.h" +#include "mem.h" + #include -#include #include #include #include @@ -62,7 +63,7 @@ static JSValue _database_create(JSContext* context, JSValueConst this_val, int a JS_ToInt64(context, &value, data[0]); sqlite3* db = (sqlite3*)(intptr_t)value; - database_t* database = malloc(sizeof(database_t)); + database_t* database = tf_malloc(sizeof(database_t)); *database = (database_t) { .task = JS_GetContextOpaque(context), @@ -71,7 +72,7 @@ static JSValue _database_create(JSContext* context, JSValueConst this_val, int a .db = db, }; const char* id = JS_ToCString(context, argv[0]); - database->id = strdup(id); + database->id = tf_strdup(id); JS_FreeCString(context, id); JS_SetOpaque(object, database); @@ -90,8 +91,8 @@ static void _database_finalizer(JSRuntime *runtime, JSValue value) database_t* database = JS_GetOpaque(value, _database_class_id); if (database) { - free((void*)database->id); - free(database); + tf_free((void*)database->id); + tf_free(database); } --_database_count; } diff --git a/src/file.js.c b/src/file.js.c index eb9e7244..2f2d01e3 100644 --- a/src/file.js.c +++ b/src/file.js.c @@ -1,9 +1,9 @@ #include "file.js.h" +#include "mem.h" #include "task.h" #include "util.js.h" -#include #include #include #include @@ -60,7 +60,7 @@ static const int k_file_read_max = 8 * 1024 * 1024; static void _file_async_close_callback(uv_fs_t* req) { uv_fs_req_cleanup(req); - free(req); + tf_free(req); } static void _file_read_read_callback(uv_fs_t* req) @@ -90,7 +90,7 @@ static void _file_read_read_callback(uv_fs_t* req) if (result < 0) { uv_fs_req_cleanup(req); - free(fsreq); + tf_free(fsreq); } } @@ -113,7 +113,7 @@ static void _file_read_open_callback(uv_fs_t* req) if (result < 0) { uv_fs_req_cleanup(req); - free(fsreq); + tf_free(fsreq); } } } @@ -121,7 +121,7 @@ static void _file_read_open_callback(uv_fs_t* req) { tf_task_reject_promise(task, promise, JS_ThrowInternalError(context, uv_strerror(req->result))); uv_fs_req_cleanup(req); - free(req); + tf_free(req); } } @@ -132,7 +132,7 @@ static JSValue _file_read_file(JSContext* context, JSValueConst this_val, int ar promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - fs_req_t* req = malloc(sizeof(fs_req_t) + k_file_read_max); + fs_req_t* req = tf_malloc(sizeof(fs_req_t) + k_file_read_max); *req = (fs_req_t) { .fs = @@ -146,7 +146,7 @@ static JSValue _file_read_file(JSContext* context, JSValueConst this_val, int ar { tf_task_reject_promise(task, promise, JS_ThrowInternalError(context, uv_strerror(result))); uv_fs_req_cleanup(&req->fs); - free(req); + tf_free(req); } JS_FreeCString(context, file_name); return promise_value; @@ -171,7 +171,7 @@ static void _file_write_write_callback(uv_fs_t* req) if (result < 0) { uv_fs_req_cleanup(req); - free(fsreq); + tf_free(fsreq); } } @@ -194,7 +194,7 @@ static void _file_write_open_callback(uv_fs_t* req) if (result < 0) { uv_fs_req_cleanup(req); - free(fsreq); + tf_free(fsreq); } } } @@ -202,7 +202,7 @@ static void _file_write_open_callback(uv_fs_t* req) { tf_task_reject_promise(task, promise, JS_ThrowInternalError(context, uv_strerror(req->result))); uv_fs_req_cleanup(req); - free(req); + tf_free(req); } } @@ -225,7 +225,7 @@ static JSValue _file_write_file(JSContext* context, JSValueConst this_val, int a promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - fs_req_t* req = malloc(sizeof(fs_req_t) + size); + fs_req_t* req = tf_malloc(sizeof(fs_req_t) + size); *req = (fs_req_t) { .fs = @@ -263,7 +263,7 @@ static void _file_async_callback(uv_fs_t* req) { tf_task_reject_promise(task, promise, JS_NewInt32(context, req->result)); } - free(req); + tf_free(req); } static JSValue _file_rename_file(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) @@ -273,7 +273,7 @@ static JSValue _file_rename_file(JSContext* context, JSValueConst this_val, int const char* new_name = JS_ToCString(context, argv[1]); promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - uv_fs_t* req = malloc(sizeof(uv_fs_t)); + uv_fs_t* req = tf_malloc(sizeof(uv_fs_t)); *req = (uv_fs_t) { .data = (void*)(intptr_t)promise, @@ -294,7 +294,7 @@ static JSValue _file_unlink_file(JSContext* context, JSValueConst this_val, int const char* file_name = JS_ToCString(context, argv[0]); promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - uv_fs_t* req = malloc(sizeof(uv_fs_t)); + uv_fs_t* req = tf_malloc(sizeof(uv_fs_t)); *req = (uv_fs_t) { .data = (void*)(intptr_t)promise, @@ -315,7 +315,7 @@ JSValue _file_make_directory(JSContext* context, JSValueConst this_val, int argc promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - uv_fs_t* req = malloc(sizeof(uv_fs_t)); + uv_fs_t* req = tf_malloc(sizeof(uv_fs_t)); *req = (uv_fs_t) { .data = (void*)(intptr_t)promise, @@ -336,7 +336,7 @@ JSValue _file_remove_directory(JSContext* context, JSValueConst this_val, int ar promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - uv_fs_t* req = malloc(sizeof(uv_fs_t)); + uv_fs_t* req = tf_malloc(sizeof(uv_fs_t)); *req = (uv_fs_t) { .data = (void*)(intptr_t)promise, @@ -357,7 +357,7 @@ JSValue _file_stat(JSContext* context, JSValueConst this_val, int argc, JSValueC promiseid_t promise = -1; JSValue promise_value = tf_task_allocate_promise(task, &promise); - file_stat_t* data = malloc(sizeof(file_stat_t)); + file_stat_t* data = tf_malloc(sizeof(file_stat_t)); data->_task = task; data->_promise = promise; data->_request.data = data; @@ -368,7 +368,7 @@ JSValue _file_stat(JSContext* context, JSValueConst this_val, int argc, JSValueC { tf_task_reject_promise(task, promise, JS_NewInt32(context, result)); uv_fs_req_cleanup(&data->_request); - free(data); + tf_free(data); } JS_FreeCString(context, path); return promise_value; @@ -399,5 +399,5 @@ static void _file_on_stat_complete(uv_fs_t* request) JS_FreeValue(context, result); } uv_fs_req_cleanup(request); - free(data); + tf_free(data); } diff --git a/src/main.c b/src/main.c index 42fa2f6a..593df6d4 100644 --- a/src/main.c +++ b/src/main.c @@ -1,3 +1,4 @@ +#include "mem.h" #include "ssb.h" #include "ssb.db.h" #include "ssb.import.h" @@ -431,8 +432,8 @@ static int _tf_command_run(const char* file, int argc, char* argv[]) } if (args.count > 1) { - uv_thread_t* threads = malloc(sizeof(uv_thread_t) * args.count); - tf_run_thread_data_t* data = malloc(sizeof(tf_run_thread_data_t) * args.count); + uv_thread_t* threads = tf_malloc(sizeof(uv_thread_t) * args.count); + tf_run_thread_data_t* data = tf_malloc(sizeof(tf_run_thread_data_t) * args.count); for (int i = 0 ; i < args.count; i++) { data[i] = (tf_run_thread_data_t) @@ -450,8 +451,8 @@ static int _tf_command_run(const char* file, int argc, char* argv[]) result = data[i].result; } } - free(data); - free(threads); + tf_free(data); + tf_free(threads); } return result; @@ -628,8 +629,8 @@ int main(int argc, char* argv[]) #if !defined(_WIN32) prctl(PR_SET_PDEATHSIG, SIGKILL); #endif - tf_util_replace_uv_allocator(); - tf_util_replace_tls_allocator(); + tf_mem_replace_uv_allocator(); + tf_mem_replace_tls_allocator(); uv_setup_args(argc, argv); tf_taskstub_startup(); diff --git a/src/mem.c b/src/mem.c new file mode 100644 index 00000000..8de2e97c --- /dev/null +++ b/src/mem.c @@ -0,0 +1,154 @@ +#include "mem.h" + +#include + +#include + +#include + +static int64_t s_tf_malloc_size; +static int64_t s_uv_malloc_size; +static int64_t s_tls_malloc_size; + +static void* _tf_alloc(int64_t* total, size_t size) +{ + void* ptr = malloc(size + sizeof(size_t)); + if (ptr) + { + __atomic_add_fetch(total, size, __ATOMIC_RELAXED); + memcpy(ptr, &size, sizeof(size_t)); + return (void*)((intptr_t)ptr + sizeof(size_t)); + } + else + { + return NULL; + } +} + +static void* _tf_realloc(int64_t* total, void* ptr, size_t size) +{ + void* old_ptr = ptr ? (void*)((intptr_t)ptr - sizeof(size_t)) : NULL; + size_t old_size = 0; + if (old_ptr) + { + memcpy(&old_size, old_ptr, sizeof(size_t)); + } + void* new_ptr = realloc(old_ptr, size + sizeof(size_t)); + if (new_ptr) + { + __atomic_add_fetch(total, (int64_t)size - (int64_t)old_size, __ATOMIC_RELAXED); + memcpy(new_ptr, &size, sizeof(size_t)); + return (void*)((intptr_t)new_ptr + sizeof(size_t)); + } + else + { + __atomic_sub_fetch(total, old_size, __ATOMIC_RELAXED); + return NULL; + } +} + +static void _tf_free(int64_t* total, void* ptr) +{ + if (ptr) + { + void* old_ptr = (void*)((intptr_t)ptr - sizeof(size_t)); + size_t size = 0; + memcpy(&size, old_ptr, sizeof(size_t)); + __atomic_sub_fetch(total, size, __ATOMIC_RELAXED); + free(old_ptr); + } +} + +static void* _tf_uv_alloc(size_t size) +{ + return _tf_alloc(&s_uv_malloc_size, size); +} + +static void* _tf_uv_realloc(void* ptr, size_t size) +{ + return _tf_realloc(&s_uv_malloc_size, ptr, size); +} + +static void* _tf_uv_calloc(size_t nmemb, size_t size) +{ + void* ptr = calloc(1, nmemb * size + sizeof(size_t)); + if (ptr) + { + size_t total_size = nmemb * size; + __atomic_add_fetch(&s_uv_malloc_size, total_size, __ATOMIC_RELAXED); + memcpy(ptr, &total_size, sizeof(size_t)); + return (void*)((intptr_t)ptr + sizeof(size_t)); + } + else + { + return NULL; + } +} + +static void _tf_uv_free(void* ptr) +{ + _tf_free(&s_uv_malloc_size, ptr); +} + +void tf_mem_replace_uv_allocator() +{ + uv_replace_allocator(_tf_uv_alloc, _tf_uv_realloc, _tf_uv_calloc, _tf_uv_free); +} + +size_t tf_mem_get_uv_malloc_size() +{ + return s_uv_malloc_size; +} + +void* _tf_tls_alloc(size_t size, const char* file, int line) +{ + return _tf_alloc(&s_tls_malloc_size, size); +} + +void* _tf_tls_realloc(void* ptr, size_t size, const char* file, int line) +{ + return _tf_realloc(&s_tls_malloc_size, ptr, size); +} + +void _tf_tls_free(void* ptr, const char* file, int line) +{ + _tf_free(&s_tls_malloc_size, ptr); +} + +void tf_mem_replace_tls_allocator() +{ + CRYPTO_set_mem_functions(_tf_tls_alloc, _tf_tls_realloc, _tf_tls_free); +} + +size_t tf_mem_get_tls_malloc_size() +{ + return s_tls_malloc_size; +} + +void* tf_malloc(size_t size) +{ + return _tf_alloc(&s_tf_malloc_size, size); +} + +void* tf_realloc(void* ptr, size_t size) +{ + return _tf_realloc(&s_tf_malloc_size, ptr, size); +} + +void tf_free(void* ptr) +{ + _tf_free(&s_tf_malloc_size, ptr); +} + +char* tf_strdup(const char* string) +{ + size_t len = strlen(string); + char* buffer = tf_malloc(len + 1); + memcpy(buffer, string, len + 1); + return buffer; +} + +size_t tf_mem_get_tf_malloc_size() +{ + return s_tf_malloc_size; +} diff --git a/src/mem.h b/src/mem.h new file mode 100644 index 00000000..bfb828a5 --- /dev/null +++ b/src/mem.h @@ -0,0 +1,16 @@ +#pragma once + +#include + +void tf_mem_replace_uv_allocator(); +size_t tf_mem_get_uv_malloc_size(); + +void tf_mem_replace_tls_allocator(); +size_t tf_mem_get_tls_malloc_size(); + +size_t tf_mem_get_tf_malloc_size(); + +void* tf_malloc(size_t size); +void* tf_realloc(void* ptr, size_t size); +void tf_free(void* ptr); +char* tf_strdup(const char* string); diff --git a/src/packetstream.c b/src/packetstream.c index 0f15b32d..58f40fae 100644 --- a/src/packetstream.c +++ b/src/packetstream.c @@ -1,8 +1,9 @@ #include "packetstream.h" +#include "mem.h" + #include -#include #include #include @@ -18,7 +19,7 @@ typedef struct _tf_packetstream_t { tf_packetstream_t* tf_packetstream_create() { - tf_packetstream_t* impl = malloc(sizeof(tf_packetstream_t)); + tf_packetstream_t* impl = tf_malloc(sizeof(tf_packetstream_t)); *impl = (tf_packetstream_t) { 0 }; return impl; } @@ -30,7 +31,7 @@ void tf_packetstream_destroy(tf_packetstream_t* stream) stream->destroyed = true; if (stream->buffer) { - free(stream->buffer); + tf_free(stream->buffer); stream->buffer = NULL; } if (stream->stream.data) @@ -39,13 +40,13 @@ void tf_packetstream_destroy(tf_packetstream_t* stream) } else { - free(stream); + tf_free(stream); } } static void _packetstream_allocate(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buffer) { - buffer->base = malloc(suggested_size); + buffer->base = tf_malloc(suggested_size); buffer->len = suggested_size; } @@ -93,7 +94,7 @@ static void _packetstream_on_read(uv_stream_t* handle, ssize_t count, const uv_b { stream->buffer_capacity *= 2; } - write_buffer = realloc(write_buffer, stream->buffer_capacity); + write_buffer = tf_realloc(write_buffer, stream->buffer_capacity); } if (write_buffer) { @@ -108,7 +109,7 @@ static void _packetstream_on_read(uv_stream_t* handle, ssize_t count, const uv_b { tf_packetstream_close(stream); } - free(buffer->base); + tf_free(buffer->base); } void tf_packetstream_start(tf_packetstream_t* stream) @@ -119,13 +120,13 @@ void tf_packetstream_start(tf_packetstream_t* stream) static void _packetstream_on_write(uv_write_t* request, int status) { - free(request); + tf_free(request); } void tf_packetstream_send(tf_packetstream_t* stream, int packet_type, const char* begin, size_t length) { size_t buffer_length = sizeof(uv_write_t) + sizeof(packet_type) + sizeof(length) + length; - uv_write_t* request = malloc(buffer_length); + uv_write_t* request = tf_malloc(buffer_length); memset(request, 0, sizeof(uv_write_t)); char* buffer = (char*)(request + 1); memcpy(buffer, &packet_type, sizeof(packet_type)); @@ -152,12 +153,12 @@ static void _tf_packetstream_handle_closed(uv_handle_t* handle) handle->data = NULL; if (packetstream->buffer) { - free(packetstream->buffer); + tf_free(packetstream->buffer); packetstream->buffer = NULL; } if (packetstream->destroyed) { - free(packetstream); + tf_free(packetstream); } } diff --git a/src/serialize.c b/src/serialize.c index 498bdaa0..801840d3 100644 --- a/src/serialize.c +++ b/src/serialize.c @@ -1,4 +1,6 @@ #include "serialize.h" + +#include "mem.h" #include "task.h" #include "taskstub.js.h" #include "util.js.h" @@ -53,7 +55,7 @@ void tf_serialize_store(tf_task_t* task, tf_taskstub_t* to, void** out_buffer, s { buffer_t tmp = { 0 }; _serialize_store(task, to, &tmp, value); - tmp.data = realloc(tmp.data, tmp.size); + tmp.data = tf_realloc(tmp.data, tmp.size); *out_buffer = tmp.data; *out_size = tmp.size; } @@ -68,7 +70,7 @@ static void _buffer_append(buffer_t* buffer, const void* data, size_t size) if (buffer->capacity < buffer->size + size) { size_t new_capacity = (size + buffer->capacity) * 2; - buffer->data = realloc(buffer->data, new_capacity); + buffer->data = tf_realloc(buffer->data, new_capacity); buffer->capacity = new_capacity; } memcpy((char*)buffer->data + buffer->size, data, size); diff --git a/src/socket.js.c b/src/socket.js.c index 5b4ff9aa..bb04bccf 100644 --- a/src/socket.js.c +++ b/src/socket.js.c @@ -1,4 +1,6 @@ #include "socket.js.h" + +#include "mem.h" #include "task.h" #include "tls.h" #include "tlscontext.js.h" @@ -150,7 +152,7 @@ typedef struct _socket_resolve_data_t { socket_t* _socket_create_internal(JSContext* context) { - socket_t* socket = malloc(sizeof(socket_t)); + socket_t* socket = tf_malloc(sizeof(socket_t)); memset(socket, 0, sizeof(*socket)); socket->_closePromise = -1; @@ -228,7 +230,7 @@ void _socket_close_internal(socket_t* socket) JS_IsUndefined(socket->_object)) { --_count; - free(socket); + tf_free(socket); } } @@ -345,7 +347,7 @@ bool _socket_processSomeOutgoingTls(socket_t* socket, promiseid_t promise, uv_wr int result = tf_tls_session_read_encrypted(socket->_tls, buffer, sizeof(buffer)); if (result > 0) { - char* request_buffer = malloc(sizeof(uv_write_t) + result); + char* request_buffer = tf_malloc(sizeof(uv_write_t) + result); uv_write_t* request = (uv_write_t*)request_buffer; memset(request, 0, sizeof(*request)); request->data = (void*)(intptr_t)(promise); @@ -361,7 +363,7 @@ bool _socket_processSomeOutgoingTls(socket_t* socket, promiseid_t promise, uv_wr int writeResult = uv_write(request, (uv_stream_t*)&socket->_socket, &writeBuffer, 1, callback); if (writeResult != 0) { - free(request_buffer); + tf_free(request_buffer); char error[256]; snprintf(error, sizeof(error), "uv_write: %s", uv_strerror(writeResult)); _socket_reportError(socket, error); @@ -387,7 +389,7 @@ JSValue _socket_bind(JSContext* context, JSValueConst this_val, int argc, JSValu const char* node = JS_ToCString(tf_task_get_context(socket->_task), argv[0]); const char* port = JS_ToCString(tf_task_get_context(socket->_task), argv[1]); - socket_resolve_data_t* data = malloc(sizeof(socket_resolve_data_t)); + socket_resolve_data_t* data = tf_malloc(sizeof(socket_resolve_data_t)); memset(data, 0, sizeof(*data)); struct addrinfo hints = { .ai_family = PF_INET, @@ -404,7 +406,7 @@ JSValue _socket_bind(JSContext* context, JSValueConst this_val, int argc, JSValu char error[256]; snprintf(error, sizeof(error), "uv_getaddrinfo: %s", uv_strerror(result)); tf_task_reject_promise(socket->_task, data->promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), error)); - free(data); + tf_free(data); } return promise; } @@ -432,7 +434,7 @@ void _socket_onResolvedForBind(uv_getaddrinfo_t* resolver, int status, struct ad tf_task_resolve_promise(data->socket->_task, data->promise, JS_UNDEFINED); } } - free(data); + tf_free(data); } JSValue _socket_connect(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) @@ -444,7 +446,7 @@ JSValue _socket_connect(JSContext* context, JSValueConst this_val, int argc, JSV strncpy(socket->_peerName, node, sizeof(socket->_peerName) - 1); - socket_resolve_data_t* data = malloc(sizeof(socket_resolve_data_t)); + socket_resolve_data_t* data = tf_malloc(sizeof(socket_resolve_data_t)); memset(data, 0, sizeof(*data)); struct addrinfo hints = { .ai_family = PF_INET, @@ -460,7 +462,7 @@ JSValue _socket_connect(JSContext* context, JSValueConst this_val, int argc, JSV char error[256]; snprintf(error, sizeof(error), "uv_getaddrinfo: %s", uv_strerror(result)); tf_task_reject_promise(socket->_task, data->promise, JS_ThrowInternalError(context, "%s", error)); - free(data); + tf_free(data); } JS_FreeCString(context, node); @@ -479,7 +481,7 @@ void _socket_onResolvedForConnect(uv_getaddrinfo_t* resolver, int status, struct } else { - uv_connect_t* request = malloc(sizeof(uv_connect_t)); + uv_connect_t* request = tf_malloc(sizeof(uv_connect_t)); memset(request, 0, sizeof(*request)); request->data = (void*)(intptr_t)data->promise; int connectResult = uv_tcp_connect(request, &data->socket->_socket, result->ai_addr, _socket_onConnect); @@ -491,7 +493,7 @@ void _socket_onResolvedForConnect(uv_getaddrinfo_t* resolver, int status, struct } } uv_freeaddrinfo(result); - free(data); + tf_free(data); } void _socket_onConnect(uv_connect_t* request, int status) @@ -512,7 +514,7 @@ void _socket_onConnect(uv_connect_t* request, int status) tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "%s", error)); } } - free(request); + tf_free(request); } JSValue _socket_listen(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) @@ -607,7 +609,7 @@ JSValue _socket_shutdown(JSContext* context, JSValueConst this_val, int argc, JS void _socket_shutdownInternal(socket_t* socket, promiseid_t promise) { - uv_shutdown_t* request = malloc(sizeof(uv_shutdown_t)); + uv_shutdown_t* request = tf_malloc(sizeof(uv_shutdown_t)); memset(request, 0, sizeof(*request)); request->data = (void*)(intptr_t)promise; int result = uv_shutdown(request, (uv_stream_t*)&socket->_socket, _socket_onShutdown); @@ -616,7 +618,7 @@ void _socket_shutdownInternal(socket_t* socket, promiseid_t promise) char error[256]; snprintf(error, sizeof(error), "uv_shutdown: %s", uv_strerror(result)); tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "%s", error)); - free(request); + tf_free(request); } } @@ -641,7 +643,7 @@ void _socket_onTlsShutdown(uv_write_t* request, int status) socket_t* socket = request->handle->data; promiseid_t promise = (intptr_t)request->data; _socket_processTlsShutdown(socket, promise); - free(request); + tf_free(request); } JSValue _socket_onError(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) @@ -684,7 +686,7 @@ JSValue _socket_read(JSContext* context, JSValueConst this_val, int argc, JSValu void _socket_allocateBuffer(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buf) { - *buf = uv_buf_init(malloc(suggestedSize), suggestedSize); + *buf = uv_buf_init(tf_malloc(suggestedSize), suggestedSize); } void _socket_onRead(uv_stream_t* stream, ssize_t readSize, const uv_buf_t* buffer) @@ -777,7 +779,7 @@ void _socket_onRead(uv_stream_t* stream, ssize_t readSize, const uv_buf_t* buffe _socket_notifyDataRead(socket, buffer->base, readSize); } } - free(buffer->base); + tf_free(buffer->base); JS_FreeValue(context, ref); } @@ -851,7 +853,7 @@ int _socket_writeBytes(socket_t* socket, promiseid_t promise, int (*callback)(so int _socket_writeInternal(socket_t* socket, promiseid_t promise, const char* data, size_t length) { - char* rawBuffer = malloc(sizeof(uv_write_t) + length); + char* rawBuffer = tf_malloc(sizeof(uv_write_t) + length); uv_write_t* request = (uv_write_t*)rawBuffer; memcpy(rawBuffer + sizeof(uv_write_t), data, length); @@ -933,7 +935,7 @@ void _socket_onWrite(uv_write_t* request, int status) tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), error)); } } - free(request); + tf_free(request); } JSValue _socket_isConnected(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) @@ -978,7 +980,7 @@ void _socket_onShutdown(uv_shutdown_t* request, int status) snprintf(error, sizeof(error), "uv_shutdown: %s", uv_strerror(status)); tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "%s", error)); } - free(request); + tf_free(request); } JSValue _socket_getPeerName(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) diff --git a/src/ssb.c b/src/ssb.c index df11afcf..5b9671a2 100644 --- a/src/ssb.c +++ b/src/ssb.c @@ -1,14 +1,12 @@ #include "ssb.h" +#include "mem.h" #include "ssb.connections.h" #include "ssb.db.h" #include "trace.h" #include -#include #include -//#include -//#include #include #include #include @@ -264,7 +262,7 @@ static void _tf_ssb_connection_on_tcp_alloc(uv_handle_t* handle, size_t suggeste { tf_ssb_connection_t* connection = handle->data; size_t malloc_size = sizeof(connection->recv_buffer) - connection->recv_size; - buf->base = malloc_size ? malloc(malloc_size) : NULL; + buf->base = malloc_size ? tf_malloc(malloc_size) : NULL; buf->len = malloc_size; } @@ -275,19 +273,19 @@ static void _tf_ssb_connection_on_write(uv_write_t* req, int status) tf_ssb_connection_t* connection = req->data; _tf_ssb_connection_close(connection, "write failed asynchronously"); } - free(req); + tf_free(req); } static void _tf_ssb_write(tf_ssb_connection_t* connection, void* data, size_t size) { - uv_write_t* write = malloc(sizeof(uv_write_t) + size); + uv_write_t* write = tf_malloc(sizeof(uv_write_t) + size); *write = (uv_write_t) { .data = connection }; memcpy(write + 1, data, size); int result = uv_write(write, (uv_stream_t*)&connection->tcp, &(uv_buf_t) { .base = (char*)(write + 1), .len = size }, 1, _tf_ssb_connection_on_write); if (result) { _tf_ssb_connection_close(connection, "write failed"); - free(write); + tf_free(write); } } @@ -372,7 +370,7 @@ static void _tf_ssb_nonce_inc(uint8_t* nonce) static void _tf_ssb_connection_box_stream_send(tf_ssb_connection_t* connection, const uint8_t* message, size_t size) { - uint8_t* message_enc = malloc(size + 34); + uint8_t* message_enc = tf_malloc(size + 34); uint8_t nonce1[crypto_secretbox_NONCEBYTES]; memcpy(nonce1, connection->send_nonce, sizeof(nonce1)); @@ -384,7 +382,7 @@ static void _tf_ssb_connection_box_stream_send(tf_ssb_connection_t* connection, if (crypto_secretbox_easy(message_enc + 34 - 16, message, size, nonce2, connection->c_to_s_box_key) != 0) { _tf_ssb_connection_close(connection, "unable to secretbox message"); - free(message_enc); + tf_free(message_enc); return; } @@ -394,12 +392,12 @@ static void _tf_ssb_connection_box_stream_send(tf_ssb_connection_t* connection, if (crypto_secretbox_easy(message_enc, header, sizeof(header), nonce1, connection->c_to_s_box_key) != 0) { _tf_ssb_connection_close(connection, "unable to secretbox header"); - free(message_enc); + tf_free(message_enc); return; } _tf_ssb_write(connection, message_enc, size + 34); - free(message_enc); + tf_free(message_enc); } static bool _tf_ssb_connection_get_request_callback(tf_ssb_connection_t* connection, int32_t request_number, tf_ssb_rpc_callback_t** out_callback, void** out_user_data) @@ -431,7 +429,7 @@ void tf_ssb_connection_add_request(tf_ssb_connection_t* connection, int32_t requ /* TODO: This leaks the callback. */ return; } - tf_ssb_request_t* request = malloc(sizeof(tf_ssb_request_t)); + tf_ssb_request_t* request = tf_malloc(sizeof(tf_ssb_request_t)); *request = (tf_ssb_request_t) { .next = connection->requests, @@ -454,7 +452,7 @@ static void _tf_ssb_connection_remove_request(tf_ssb_connection_t* connection, i JS_FreeValue(tf_ssb_connection_get_context(connection), JS_MKPTR(JS_TAG_OBJECT, found->user_data)); } *it = found->next; - free(found); + tf_free(found); break; } } @@ -470,7 +468,7 @@ void tf_ssb_connection_rpc_send(tf_ssb_connection_t* connection, uint8_t flags, { tf_ssb_connection_add_request(connection, request_number, callback, user_data); } - uint8_t* combined = malloc(9 + size); + uint8_t* combined = tf_malloc(9 + size); *combined = flags; uint32_t u32size = htonl((uint32_t)size); memcpy(combined + 1, &u32size, sizeof(u32size)); @@ -478,7 +476,7 @@ void tf_ssb_connection_rpc_send(tf_ssb_connection_t* connection, uint8_t flags, memcpy(combined + 1 + sizeof(uint32_t), &rn, sizeof(rn)); memcpy(combined + 1 + 2 * sizeof(uint32_t), message, size); _tf_ssb_connection_box_stream_send(connection, combined, 1 + 2 * sizeof(uint32_t) + size); - free(combined); + tf_free(combined); printf("RPC SEND flags=%x RN=%d: %.*s\n", flags, request_number, (int)size, message); connection->ssb->rpc_out++; } @@ -543,7 +541,7 @@ void tf_ssb_calculate_message_id(JSContext* context, JSValue message, char* out_ size_t len = 0; const char* messagestr = JS_ToCStringLen(context, &len, idval); - char* latin1 = strdup(messagestr); + char* latin1 = tf_strdup(messagestr); uint8_t* write_pos = (uint8_t*)latin1; const uint8_t* p = (const uint8_t*)messagestr; while (p && *p) @@ -573,7 +571,7 @@ void tf_ssb_calculate_message_id(JSContext* context, JSValue message, char* out_ snprintf(out_id, out_id_size, "%%%s.sha256", id_base64); - free(latin1); + tf_free(latin1); JS_FreeCString(context, messagestr); JS_FreeValue(context, idval); } @@ -1372,7 +1370,7 @@ void _tf_ssb_connection_destroy(tf_ssb_connection_t* connection, const char* rea !connection->tcp.data && !connection->connect.data) { - free(connection); + tf_free(connection); } } @@ -1394,7 +1392,7 @@ static void _tf_ssb_connection_on_tcp_recv(uv_stream_t* stream, ssize_t nread, c if (connection->recv_size + nread > sizeof(connection->recv_buffer)) { _tf_ssb_connection_close(connection, "recv buffer overflow"); - free(buf->base); + tf_free(buf->base); return; } memcpy(connection->recv_buffer + connection->recv_size, buf->base, nread); @@ -1474,7 +1472,7 @@ static void _tf_ssb_connection_on_tcp_recv(uv_stream_t* stream, ssize_t nread, c { _tf_ssb_connection_close(connection, "read zero"); } - free(buf->base); + tf_free(buf->base); } static void _tf_ssb_connection_client_send_hello(uv_stream_t* stream) @@ -1539,7 +1537,7 @@ static bool _tf_ssb_load_keys(tf_ssb_t* ssb) bool result = false; char* json = NULL; size_t path_size = strlen(home) + strlen(ssb->secrets_path) + 1; - char* path = malloc(path_size); + char* path = tf_malloc(path_size); snprintf(path, path_size, "%s%s", home, ssb->secrets_path); FILE* file = fopen(path, "rb"); @@ -1562,7 +1560,7 @@ static bool _tf_ssb_load_keys(tf_ssb_t* ssb) goto failed; } - json = malloc(len + 1); + json = tf_malloc(len + 1); if (fread(json, 1, len, file) != (size_t)len) { printf("Failed to read %s: %s\n.", path, strerror(errno)); @@ -1599,7 +1597,7 @@ static bool _tf_ssb_load_keys(tf_ssb_t* ssb) failed: if (json) { - free(json); + tf_free(json); } if (file) { @@ -1607,7 +1605,7 @@ failed: } if (path) { - free(path); + tf_free(path); } return result; } @@ -1634,7 +1632,7 @@ static bool _tf_ssb_save_keys(tf_ssb_t* ssb) } size_t path_size = strlen(home) + strlen(ssb->secrets_path) + 1; - char* path = malloc(path_size); + char* path = tf_malloc(path_size); snprintf(path, path_size, "%s%s", home, ssb->secrets_path); JSContext* context = ssb->context; @@ -1659,7 +1657,7 @@ static bool _tf_ssb_save_keys(tf_ssb_t* ssb) JS_FreeValue(context, jsonval); JS_FreeValue(context, root); - free(path); + tf_free(path); return result; } @@ -1716,7 +1714,7 @@ void tf_ssb_get_stats(tf_ssb_t* ssb, tf_ssb_stats_t* out_stats) tf_ssb_t* tf_ssb_create(uv_loop_t* loop, JSContext* context, sqlite3* db, const char* secrets_path) { - tf_ssb_t* ssb = malloc(sizeof(tf_ssb_t)); + tf_ssb_t* ssb = tf_malloc(sizeof(tf_ssb_t)); memset(ssb, 0, sizeof(*ssb)); ssb->secrets_path = secrets_path ? secrets_path : k_secrets_path; if (context) @@ -1886,7 +1884,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb) node->cleanup(ssb, node->user_data); node->cleanup = NULL; } - free(node); + tf_free(node); } while (ssb->connections_changed) { @@ -1897,7 +1895,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb) { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } while (ssb->message_added) { @@ -1908,7 +1906,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb) { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } while (ssb->blob_want_added) { @@ -1919,7 +1917,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb) { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } while (ssb->broadcasts_changed) { @@ -1930,7 +1928,7 @@ void tf_ssb_destroy(tf_ssb_t* ssb) { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } if (ssb->own_context) { @@ -1946,9 +1944,9 @@ void tf_ssb_destroy(tf_ssb_t* ssb) tf_ssb_broadcast_t* broadcast = ssb->broadcasts; ssb->broadcasts = broadcast->next; ssb->broadcasts_count--; - free(broadcast); + tf_free(broadcast); } - free(ssb); + tf_free(ssb); } void tf_ssb_run(tf_ssb_t* ssb) @@ -2034,7 +2032,7 @@ tf_ssb_connection_t* tf_ssb_connection_create(tf_ssb_t* ssb, const char* host, c } JSContext* context = ssb->context; - tf_ssb_connection_t* connection = malloc(sizeof(tf_ssb_connection_t)); + tf_ssb_connection_t* connection = tf_malloc(sizeof(tf_ssb_connection_t)); memset(connection, 0, sizeof(*connection)); connection->ssb = ssb; connection->tcp.data = connection; @@ -2097,13 +2095,13 @@ static void _tf_on_connect_getaddrinfo(uv_getaddrinfo_t* addrinfo, int result, s { printf("getaddrinfo => %s\n", uv_strerror(result)); } - free(connect); + tf_free(connect); uv_freeaddrinfo(info); } void tf_ssb_connect(tf_ssb_t* ssb, const char* host, int port, const uint8_t* key) { - connect_t* connect = malloc(sizeof(connect_t)); + connect_t* connect = tf_malloc(sizeof(connect_t)); *connect = (connect_t) { .ssb = ssb, @@ -2116,7 +2114,7 @@ void tf_ssb_connect(tf_ssb_t* ssb, const char* host, int port, const uint8_t* ke if (r < 0) { printf("uv_getaddrinfo: %s\n", uv_strerror(r)); - free(connect); + tf_free(connect); } } @@ -2129,7 +2127,7 @@ static void _tf_ssb_on_connection(uv_stream_t* stream, int status) return; } - tf_ssb_connection_t* connection = malloc(sizeof(tf_ssb_connection_t)); + tf_ssb_connection_t* connection = tf_malloc(sizeof(tf_ssb_connection_t)); memset(connection, 0, sizeof(*connection)); connection->ssb = ssb; connection->tcp.data = connection; @@ -2310,7 +2308,7 @@ void tf_ssb_connect_str(tf_ssb_t* ssb, const char* address) static void _tf_ssb_on_broadcast_listener_alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) { - buf->base = malloc(suggested_size); + buf->base = tf_malloc(suggested_size); buf->len = suggested_size; } @@ -2353,7 +2351,7 @@ static void _tf_ssb_add_broadcast(tf_ssb_t* ssb, const tf_ssb_broadcast_t* broad } printf("Received new broadcast: host=%s, pub=%s.\n", broadcast->host, key); - tf_ssb_broadcast_t* node = malloc(sizeof(tf_ssb_broadcast_t)); + tf_ssb_broadcast_t* node = tf_malloc(sizeof(tf_ssb_broadcast_t)); *node = *broadcast; node->next = ssb->broadcasts; node->ctime = time(NULL); @@ -2368,7 +2366,7 @@ static void _tf_ssb_on_broadcast_listener_recv(uv_udp_t* handle, ssize_t nread, { if (nread <= 0) { - free(buf->base); + tf_free(buf->base); return; } @@ -2387,7 +2385,7 @@ static void _tf_ssb_on_broadcast_listener_recv(uv_udp_t* handle, ssize_t nread, } entry = strtok_r(NULL, k_delim, &state); } - free(buf->base); + tf_free(buf->base); } void tf_ssb_visit_broadcasts(tf_ssb_t* ssb, void (*callback)(const struct sockaddr_in* addr, const uint8_t* pub, void* user_data), void* user_data) @@ -2415,7 +2413,7 @@ static void _tf_ssb_broadcast_cleanup_timer(uv_timer_t* timer) { tf_ssb_broadcast_t* node = *it; *it = node->next; - free(node); + tf_free(node); ssb->broadcasts_count--; modified++; } @@ -2487,7 +2485,7 @@ const char** tf_ssb_get_connection_ids(tf_ssb_t* ssb) } } - char* buffer = malloc(sizeof(char*) * (count + 1) + k_id_base64_len * count); + char* buffer = tf_malloc(sizeof(char*) * (count + 1) + k_id_base64_len * count); char** array = (char**)buffer; char* strings = buffer + sizeof(char*) * (count + 1); int i = 0; @@ -2518,7 +2516,7 @@ int tf_ssb_get_connections(tf_ssb_t* ssb, tf_ssb_connection_t** out_connections, void tf_ssb_add_broadcasts_changed_callback(tf_ssb_t* ssb, tf_ssb_broadcasts_changed_callback_t* callback, tf_ssb_callback_cleanup_t* cleanup, void* user_data) { - tf_ssb_broadcasts_changed_callback_node_t* node = malloc(sizeof(tf_ssb_broadcasts_changed_callback_node_t)); + tf_ssb_broadcasts_changed_callback_node_t* node = tf_malloc(sizeof(tf_ssb_broadcasts_changed_callback_node_t)); *node = (tf_ssb_broadcasts_changed_callback_node_t) { .callback = callback, @@ -2545,7 +2543,7 @@ void tf_ssb_remove_broadcasts_changed_callback(tf_ssb_t* ssb, tf_ssb_broadcasts_ { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } else { @@ -2556,7 +2554,7 @@ void tf_ssb_remove_broadcasts_changed_callback(tf_ssb_t* ssb, tf_ssb_broadcasts_ void tf_ssb_add_connections_changed_callback(tf_ssb_t* ssb, tf_ssb_connections_changed_callback_t* callback, tf_ssb_callback_cleanup_t* cleanup, void* user_data) { - tf_ssb_connections_changed_callback_node_t* node = malloc(sizeof(tf_ssb_connections_changed_callback_node_t)); + tf_ssb_connections_changed_callback_node_t* node = tf_malloc(sizeof(tf_ssb_connections_changed_callback_node_t)); *node = (tf_ssb_connections_changed_callback_node_t) { .callback = callback, @@ -2583,7 +2581,7 @@ void tf_ssb_remove_connections_changed_callback(tf_ssb_t* ssb, tf_ssb_connection { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } else { @@ -2601,7 +2599,7 @@ void tf_ssb_add_rpc_callback(tf_ssb_t* ssb, const char** name, tf_ssb_rpc_callba name_count++; name_len += strlen(name[i]) + 1; } - tf_ssb_rpc_callback_node_t* node = malloc(sizeof(tf_ssb_rpc_callback_node_t) + (name_count + 1) * sizeof(const char*) + name_len); + tf_ssb_rpc_callback_node_t* node = tf_malloc(sizeof(tf_ssb_rpc_callback_node_t) + (name_count + 1) * sizeof(const char*) + name_len); *node = (tf_ssb_rpc_callback_node_t) { .name = (const char**)(node + 1), @@ -2650,7 +2648,7 @@ JSValue tf_ssb_connection_get_object(tf_ssb_connection_t* connection) void tf_ssb_add_message_added_callback(tf_ssb_t* ssb, void (*callback)(tf_ssb_t* ssb, const char* id, void* user_data), void (*cleanup)(tf_ssb_t* ssb, void* user_data), void* user_data) { - tf_ssb_message_added_callback_node_t* node = malloc(sizeof(tf_ssb_message_added_callback_node_t)); + tf_ssb_message_added_callback_node_t* node = tf_malloc(sizeof(tf_ssb_message_added_callback_node_t)); *node = (tf_ssb_message_added_callback_node_t) { .callback = callback, @@ -2677,7 +2675,7 @@ void tf_ssb_remove_message_added_callback(tf_ssb_t* ssb, tf_ssb_message_added_ca { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } else { @@ -2699,7 +2697,7 @@ void tf_ssb_notify_message_added(tf_ssb_t* ssb, const char* id) void tf_ssb_add_blob_want_added_callback(tf_ssb_t* ssb, void (*callback)(tf_ssb_t* ssb, const char* id, void* user_data), void (*cleanup)(tf_ssb_t* ssb, void* user_data), void* user_data) { - tf_ssb_blob_want_added_callback_node_t* node = malloc(sizeof(tf_ssb_blob_want_added_callback_node_t)); + tf_ssb_blob_want_added_callback_node_t* node = tf_malloc(sizeof(tf_ssb_blob_want_added_callback_node_t)); *node = (tf_ssb_blob_want_added_callback_node_t) { .callback = callback, @@ -2726,7 +2724,7 @@ void tf_ssb_remove_blob_want_added_callback(tf_ssb_t* ssb, tf_ssb_blob_want_adde { node->cleanup(ssb, node->user_data); } - free(node); + tf_free(node); } else { diff --git a/src/ssb.connections.c b/src/ssb.connections.c index 95277ec3..ce9fc48f 100644 --- a/src/ssb.connections.c +++ b/src/ssb.connections.c @@ -1,11 +1,11 @@ #include "ssb.connections.h" +#include "mem.h" #include "ssb.h" #include #include -#include #include #if !defined(_countof) @@ -97,7 +97,7 @@ static void _tf_ssb_connections_timer(uv_timer_t* timer) tf_ssb_connections_t* tf_ssb_connections_create(tf_ssb_t* ssb) { - tf_ssb_connections_t* connections = malloc(sizeof(tf_ssb_connections_t)); + tf_ssb_connections_t* connections = tf_malloc(sizeof(tf_ssb_connections_t)); memset(connections, 0, sizeof(*connections)); connections->ssb = ssb; connections->db = tf_ssb_get_db(ssb); @@ -117,7 +117,7 @@ static void _tf_ssb_connections_on_handle_close(uv_handle_t* handle) { tf_ssb_connections_t* connections = handle->data; handle->data = NULL; - free(connections); + tf_free(connections); } void tf_ssb_connections_destroy(tf_ssb_connections_t* connections) diff --git a/src/ssb.db.c b/src/ssb.db.c index b053ffd4..23a19a3c 100644 --- a/src/ssb.db.c +++ b/src/ssb.db.c @@ -1,5 +1,6 @@ #include "ssb.db.h" +#include "mem.h" #include "ssb.h" #include "trace.h" @@ -248,7 +249,7 @@ bool tf_ssb_db_message_content_get(tf_ssb_t* ssb, const char* id, uint8_t** out_ int size = sqlite3_column_bytes(statement, 0); if (out_blob) { - *out_blob = malloc(size + 1); + *out_blob = tf_malloc(size + 1); memcpy(*out_blob, blob, size); (*out_blob)[size] = '\0'; } @@ -277,7 +278,7 @@ bool tf_ssb_db_blob_get(tf_ssb_t* ssb, const char* id, uint8_t** out_blob, size_ int size = sqlite3_column_bytes(statement, 0); if (out_blob) { - *out_blob = malloc(size + 1); + *out_blob = tf_malloc(size + 1); if (size) { memcpy(*out_blob, blob, size); @@ -376,7 +377,7 @@ bool tf_ssb_db_get_message_by_author_and_sequence(tf_ssb_t* ssb, const char* aut } if (out_content) { - *out_content = strdup((const char*)sqlite3_column_text(statement, 2)); + *out_content = tf_strdup((const char*)sqlite3_column_text(statement, 2)); } found = true; } diff --git a/src/ssb.export.c b/src/ssb.export.c index e18b7f9d..00379dbc 100644 --- a/src/ssb.export.c +++ b/src/ssb.export.c @@ -1,5 +1,6 @@ #include "ssb.export.h" +#include "mem.h" #include "ssb.db.h" #include "ssb.h" @@ -87,7 +88,7 @@ void tf_ssb_export(tf_ssb_t* ssb, const char* key) _write_file(file_path, blob, size); JSContext* context = tf_ssb_get_context(ssb); JSValue app = JS_ParseJSON(context, (const char*)blob, size, NULL); - free(blob); + tf_free(blob); JSValue files = JS_GetPropertyStr(context, app, "files"); JSPropertyEnum* ptab = NULL; @@ -109,7 +110,7 @@ void tf_ssb_export(tf_ssb_t* ssb, const char* key) { snprintf(file_path, sizeof(file_path), "apps/%s/%s/%s", user, path, file_name); _write_file(file_path, file_blob, file_size); - free(file_blob); + tf_free(file_blob); } JS_FreeCString(context, file_name); diff --git a/src/ssb.import.c b/src/ssb.import.c index edb11914..05efd57b 100644 --- a/src/ssb.import.c +++ b/src/ssb.import.c @@ -1,5 +1,6 @@ #include "ssb.import.h" +#include "mem.h" #include "ssb.db.h" #include "ssb.h" @@ -26,7 +27,7 @@ static void _tf_ssb_import_file_close(uv_fs_t* req) tf_import_file_t* file = req->data; (*file->work_left)--; uv_fs_req_cleanup(req); - free(req->data); + tf_free(req->data); } static void _tf_ssb_import_add_app(tf_ssb_t* ssb, const char* user, const char* app) @@ -127,7 +128,7 @@ static void _tf_ssb_import_scandir(uv_fs_t* req) while (uv_fs_scandir_next(req, &ent) == 0) { size_t len = strlen(import->parent) + strlen(ent.name) + 2; - char* path = malloc(len); + char* path = tf_malloc(len); snprintf(path, len, "%s/%s", import->parent, ent.name); if (ent.type == UV_DIRENT_DIR) { @@ -136,7 +137,7 @@ static void _tf_ssb_import_scandir(uv_fs_t* req) else { size_t size = sizeof(tf_import_file_t) + strlen(import->parent) +1 + strlen(ent.name) + 1; - tf_import_file_t* file = malloc(size); + tf_import_file_t* file = tf_malloc(size); memset(file, 0, size); file->ssb = import->ssb; file->user = import->user; @@ -152,11 +153,11 @@ static void _tf_ssb_import_scandir(uv_fs_t* req) if (r < 0) { printf("Failed to open %s: %s.\n", path, uv_strerror(r)); - free(file); + tf_free(file); import->work_left--; } } - free(path); + tf_free(path); } import->work_left--; } diff --git a/src/ssb.js.c b/src/ssb.js.c index cf411b1b..7644368e 100644 --- a/src/ssb.js.c +++ b/src/ssb.js.c @@ -1,12 +1,12 @@ #include "ssb.js.h" #include "database.js.h" +#include "mem.h" #include "ssb.db.h" #include "ssb.h" #include "task.h" #include "util.js.h" -#include #include #include #include @@ -48,7 +48,7 @@ static JSValue _tf_ssb_getMessage(JSContext* context, JSValueConst this_val, int result = JS_NewObject(context); JS_SetPropertyStr(context, result, "timestamp", JS_NewFloat64(context, timestamp)); JS_SetPropertyStr(context, result, "content", JS_NewString(context, contents)); - free(contents); + tf_free(contents); } JS_FreeCString(context, id); } @@ -67,7 +67,7 @@ static JSValue _tf_ssb_blobGet(JSContext* context, JSValueConst this_val, int ar if (tf_ssb_db_blob_get(ssb, id, &blob, &size)) { result = JS_NewArrayBufferCopy(context, blob, size); - free(blob); + tf_free(blob); } JS_FreeCString(context, id); } @@ -133,7 +133,7 @@ static JSValue _tf_ssb_messageContentGet(JSContext* context, JSValueConst this_v if (tf_ssb_db_message_content_get(ssb, id, &blob, &size)) { result = JS_NewArrayBufferCopy(context, blob, size); - free(blob); + tf_free(blob); } JS_FreeCString(context, id); } @@ -155,7 +155,7 @@ static JSValue _tf_ssb_connections(JSContext* context, JSValueConst this_val, in { JS_SetPropertyUint32(context, result, i, JS_NewString(context, *p)); } - free(connections); + tf_free(connections); } } return result; @@ -618,7 +618,7 @@ void tf_ssb_run_file(JSContext* context, const char* file_name) fseek(file, 0, SEEK_END); long file_size = ftell(file); fseek(file, 0, SEEK_SET); - source = malloc(file_size + 1); + source = tf_malloc(file_size + 1); fread(source, 1, file_size, file); source[file_size] = '\0'; fclose(file); @@ -663,7 +663,7 @@ void tf_ssb_run_file(JSContext* context, const char* file_name) } JS_FreeValue(context, result); - free(source); + tf_free(source); } static JSValue _tf_ssb_add_event_listener(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) diff --git a/src/ssb.tests.c b/src/ssb.tests.c index 98e945eb..37773351 100644 --- a/src/ssb.tests.c +++ b/src/ssb.tests.c @@ -1,5 +1,6 @@ #include "ssb.h" +#include "mem.h" #include "ssb.db.h" #include "ssb.js.h" #include "tests.h" @@ -48,7 +49,7 @@ static void _ssb_test_connections_changed(tf_ssb_t* ssb, tf_ssb_change_t change, { count++; } - free(c); + tf_free(c); if (ssb == test->ssb0) { @@ -294,7 +295,7 @@ void tf_ssb_test_following(const tf_test_options_t* options) printf("* %s\n", *p); \ } \ printf("\n"); \ - free(f); \ + tf_free(f); \ } \ while (0) #endif diff --git a/src/task.c b/src/task.c index e74703b8..fb1e55f0 100644 --- a/src/task.c +++ b/src/task.c @@ -3,6 +3,7 @@ #include "bcrypt.js.h" #include "database.js.h" #include "file.js.h" +#include "mem.h" #include "packetstream.h" #include "serialize.h" #include "socket.js.h" @@ -138,7 +139,7 @@ static bool _export_record_release(tf_task_t* task, export_record_t** export) { JS_FreeValue(task->_context, (*export)->_function); (*export)->_function = JS_UNDEFINED; - free(*export); + tf_free(*export); int index = export - task->_exports; if (task->_export_count - index) { @@ -232,7 +233,7 @@ static bool _import_record_release(import_record_t** import) } task->_import_count--; - free(record); + tf_free(record); return true; } return false; @@ -288,7 +289,7 @@ void tf_task_send_error_to_parent(tf_task_t* task, JSValue error) size_t size = 0; tf_serialize_store(task, task->_parent, &buffer, &size, error); tf_packetstream_send(tf_taskstub_get_stream(task->_parent), kTaskError, buffer, size); - free(buffer); + tf_free(buffer); } } @@ -301,7 +302,7 @@ static const char* _task_loadFile(const char* fileName) fseek(file, 0, SEEK_END); long fileSize = ftell(file); fseek(file, 0, SEEK_SET); - result = malloc(fileSize + 1); + result = tf_malloc(fileSize + 1); fread(result, 1, fileSize, file); result[fileSize] = '\0'; fclose(file); @@ -331,18 +332,18 @@ int tf_task_execute(tf_task_t* task, const char* fileName) } if (!task->_path) { - char* path = strdup(fileName); + char* path = tf_strdup(fileName); char* slash = strrchr(path, '/'); if (slash) { *slash = '\0'; - task->_path = strdup(path); + task->_path = tf_strdup(path); } else { - task->_path = strdup("./"); + task->_path = tf_strdup("./"); } - free(path); + tf_free(path); } if (source) { @@ -353,7 +354,7 @@ int tf_task_execute(tf_task_t* task, const char* fileName) executed = true; } JS_FreeValue(task->_context, result); - free((void*)source); + tf_free((void*)source); } else { @@ -579,12 +580,12 @@ void tf_task_send_promise_message(tf_task_t* from, tf_taskstub_t* to, tf_task_me size_t size; tf_serialize_store(from, to, &buffer, &size, payload); - char* copy = (char*)malloc(sizeof(promise) + size); + char* copy = tf_malloc(sizeof(promise) + size); memcpy(copy, &promise, sizeof(promise)); memcpy(copy + sizeof(promise), buffer, size); tf_packetstream_send(tf_taskstub_get_stream(to), type, copy, size + sizeof(promise)); - free(buffer); - free(copy); + tf_free(buffer); + tf_free(copy); } else { @@ -597,13 +598,13 @@ static void _tf_task_sendPromiseExportMessage(tf_task_t* from, tf_taskstub_t* to void* buffer; size_t size; tf_serialize_store(from, to, &buffer, &size, result); - char* copy = (char*)malloc(sizeof(promise) + sizeof(exportId) + size); + char* copy = tf_malloc(sizeof(promise) + sizeof(exportId) + size); memcpy(copy, &promise, sizeof(promise)); memcpy(copy + sizeof(promise), &exportId, sizeof(exportId)); memcpy(copy + sizeof(promise) + sizeof(exportId), buffer, size); tf_packetstream_send(tf_taskstub_get_stream(to), messageType, copy, sizeof(promise) + sizeof(exportId) + size); - free(buffer); - free(copy); + tf_free(buffer); + tf_free(copy); } JSValue _tf_task_get_parent(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) @@ -662,7 +663,7 @@ exportid_t tf_task_export_function(tf_task_t* task, tf_taskstub_t* to, JSValue f id = task->_nextExport++; } while (_task_get_export(task, id)); - export = malloc(sizeof(export_record_t)); + export = tf_malloc(sizeof(export_record_t)); *export = (export_record_t) { ._export_id = id, @@ -671,7 +672,7 @@ exportid_t tf_task_export_function(tf_task_t* task, tf_taskstub_t* to, JSValue f }; int index = _insert_index(&id, task->_exports, task->_export_count, sizeof(export_record_t*), _export_compare); - task->_exports = realloc(task->_exports, sizeof(export_record_t*) * (task->_export_count + 1)); + task->_exports = tf_realloc(task->_exports, sizeof(export_record_t*) * (task->_export_count + 1)); if (task->_export_count - index) { memmove(task->_exports + index + 1, task->_exports + index, sizeof(export_record_t*) * (task->_export_count - index)); @@ -710,7 +711,7 @@ static JSValue _tf_task_trace(JSContext* context, JSValueConst this_val, int arg char* trace = tf_trace_export(task->_trace); JSValue result = JS_NewString(context, trace); - free(trace); + tf_free(trace); return result; } @@ -739,8 +740,9 @@ static JSValue _tf_task_getStats(JSContext* context, JSValueConst this_val, int JS_ComputeMemoryUsage(runtime, &js); JS_SetPropertyStr(context, result, "js_malloc_percent", JS_NewFloat64(context, 100.0f * js.malloc_size / total_memory)); - JS_SetPropertyStr(context, result, "uv_malloc_percent", JS_NewFloat64(context, 100.0f * tf_util_get_uv_malloc_size() / total_memory)); - JS_SetPropertyStr(context, result, "tls_malloc_percent", JS_NewFloat64(context, 100.0f * tf_util_get_tls_malloc_size() / total_memory)); + JS_SetPropertyStr(context, result, "uv_malloc_percent", JS_NewFloat64(context, 100.0f * tf_mem_get_uv_malloc_size() / total_memory)); + JS_SetPropertyStr(context, result, "tls_malloc_percent", JS_NewFloat64(context, 100.0f * tf_mem_get_tls_malloc_size() / total_memory)); + JS_SetPropertyStr(context, result, "tf_malloc_percent", JS_NewFloat64(context, 100.0f * tf_mem_get_tf_malloc_size() / total_memory)); JS_SetPropertyStr(context, result, "socket_count", JS_NewInt32(context, tf_socket_get_count())); JS_SetPropertyStr(context, result, "socket_open_count", JS_NewInt32(context, tf_socket_get_open_count())); @@ -988,7 +990,7 @@ static const char* _tf_task_resolveRequire(tf_task_t* task, const char* require) uv_fs_t request; if (uv_fs_access(&task->_loop, &request, test, R_OK, 0) == 0) { - return strdup(test); + return tf_strdup(test); } return NULL; } @@ -1024,12 +1026,12 @@ JSValue _tf_task_require(JSContext* context, JSValueConst this_val, int argc, JS if (it) { result = JS_DupValue(task->_context, it->value); - free((void*)path); + tf_free((void*)path); } else { JSValue exports = JS_NewObject(task->_context); - script_export_t* export = malloc(sizeof(script_export_t)); + script_export_t* export = tf_malloc(sizeof(script_export_t)); *export = (script_export_t) { .name = path, @@ -1058,7 +1060,7 @@ JSValue _tf_task_require(JSContext* context, JSValueConst this_val, int argc, JS JS_FreeValue(task->_context, eval); JS_SetPropertyStr(task->_context, global, "exports", oldExports); JS_FreeValue(task->_context, global); - free((void*)source); + tf_free((void*)source); } else { @@ -1110,7 +1112,7 @@ JSValue _tf_task_sandbox_require(JSContext* context, JSValueConst this_val, int uint8_t* array = tf_util_try_get_array_buffer(context, &length, value); if (array) { - char* source = malloc(length + 1); + char* source = tf_malloc(length + 1); memcpy(source, array, length); source[length] = '\0'; JSValue global = JS_GetGlobalObject(context); @@ -1120,7 +1122,7 @@ JSValue _tf_task_sandbox_require(JSContext* context, JSValueConst this_val, int tf_util_report_error(context, result); JS_SetPropertyStr(context, global, "exports", oldExports); JS_FreeValue(context, global); - free(source); + tf_free(source); return exports; } else if (JS_IsString(value)) @@ -1198,7 +1200,7 @@ JSValue tf_task_allocate_promise(tf_task_t* task, promiseid_t* out_promise) }; JSValue result = JS_NewPromiseCapability(task->_context, promise.values); int index = _insert_index((void*)(intptr_t)promiseId, task->_promises, task->_promise_count, sizeof(promise_t), _promise_compare); - task->_promises = realloc(task->_promises, sizeof(promise_t) * (task->_promise_count + 1)); + task->_promises = tf_realloc(task->_promises, sizeof(promise_t) * (task->_promise_count + 1)); if (task->_promise_count - index) { memmove(task->_promises + index + 1, task->_promises + index, sizeof(promise_t) * (task->_promise_count - index)); @@ -1260,7 +1262,7 @@ taskid_t tf_task_allocate_task_id(tf_task_t* task, tf_taskstub_t* stub) id = task->_nextTask++; } while (id == k_task_parent_id || _tf_task_get_stub(task, id)); - task_child_node_t* node = malloc(sizeof(task_child_node_t)); + task_child_node_t* node = tf_malloc(sizeof(task_child_node_t)); *node = (task_child_node_t) { .id = id, @@ -1284,7 +1286,7 @@ void tf_task_remove_child(tf_task_t* task, tf_taskstub_t* child) { task_child_node_t* node = *it; *it = node->next; - free(node); + tf_free(node); task->_child_count--; break; } @@ -1408,7 +1410,7 @@ JSModuleDef* _tf_task_module_loader(JSContext* context, const char* module_name, uint8_t* array = tf_util_try_get_array_buffer(context, &length, source_value); if (array) { - source = malloc(length + 1); + source = tf_malloc(length + 1); memcpy(source, array, length); source[length] = '\0'; } @@ -1421,7 +1423,7 @@ JSModuleDef* _tf_task_module_loader(JSContext* context, const char* module_name, } JSValue result = JS_Eval(context, source, length, module_name, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY); - free(source); + tf_free(source); if (tf_util_report_error(task->_context, result)) { return NULL; @@ -1434,7 +1436,7 @@ JSModuleDef* _tf_task_module_loader(JSContext* context, const char* module_name, tf_task_t* tf_task_create() { - tf_task_t* task = malloc(sizeof(tf_task_t)); + tf_task_t* task = tf_malloc(sizeof(tf_task_t)); *task = (tf_task_t) { 0 }; ++_count; task->_runtime = JS_NewRuntime(); @@ -1509,7 +1511,7 @@ void tf_task_activate(tf_task_t* task) if (task->_args) { char* saveptr = NULL; - char* copy = strdup(task->_args); + char* copy = tf_strdup(task->_args); char* start = copy; while (true) { @@ -1531,7 +1533,7 @@ void tf_task_activate(tf_task_t* task) exit(1); } } - free(copy); + tf_free(copy); } JS_SetPropertyStr(context, global, "tildefriends", tildefriends); @@ -1606,18 +1608,18 @@ void tf_task_destroy(tf_task_t* task) for (int i = 0; i < task->_import_count; i++) { JS_FreeValue(task->_context, task->_imports[i]->_function); - free(task->_imports[i]); + tf_free(task->_imports[i]); } - free(task->_imports); + tf_free(task->_imports); task->_imports = NULL; task->_import_count = 0; for (int i = 0; i < task->_export_count; i++) { JS_FreeValue(task->_context, task->_exports[i]->_function); - free(task->_exports[i]); + tf_free(task->_exports[i]); } - free(task->_exports); + tf_free(task->_exports); task->_exports = NULL; task->_export_count = 0; @@ -1626,7 +1628,7 @@ void tf_task_destroy(tf_task_t* task) task_child_node_t* node = task->_children; tf_taskstub_destroy(node->stub); task->_children = node->next; - free(node); + tf_free(node); } if (task->_parent) { @@ -1636,7 +1638,7 @@ void tf_task_destroy(tf_task_t* task) { tf_task_reject_promise(task, task->_promises[task->_promise_count - 1].id, JS_NULL); } - free(task->_promises); + tf_free(task->_promises); task->_promises = NULL; JS_FreeValue(task->_context, task->_requires); JS_FreeValue(task->_context, task->_loadedFiles); @@ -1645,8 +1647,8 @@ void tf_task_destroy(tf_task_t* task) script_export_t* export = task->_scriptExports; JS_FreeValue(task->_context, export->value); task->_scriptExports = export->next; - free((void*)export->name); - free(export); + tf_free((void*)export->name); + tf_free(export); } if (task->_ssb) @@ -1689,8 +1691,8 @@ void tf_task_destroy(tf_task_t* task) tf_trace_destroy(task->_trace); } --_count; - free((void*)task->_path); - free(task); + tf_free((void*)task->_path); + tf_free(task); } JSValue tf_task_add_import(tf_task_t* task, taskid_t stub_id, exportid_t export_id) @@ -1703,7 +1705,7 @@ JSValue tf_task_add_import(tf_task_t* task, taskid_t stub_id, exportid_t export_ } JSValue function = JS_NewObjectClass(task->_context, _import_class_id); - import_record_t* import = malloc(sizeof(import_record_t)); + import_record_t* import = tf_malloc(sizeof(import_record_t)); JS_SetOpaque(function, import); *import = (import_record_t) { @@ -1715,7 +1717,7 @@ JSValue tf_task_add_import(tf_task_t* task, taskid_t stub_id, exportid_t export_ }; int index = _insert_index(import, task->_imports, task->_import_count, sizeof(import_record_t*), _import_compare); - task->_imports = realloc(task->_imports, sizeof(import_record_t*) * (task->_import_count + 1)); + task->_imports = tf_realloc(task->_imports, sizeof(import_record_t*) * (task->_import_count + 1)); if (task->_import_count - index) { memmove(task->_imports + index + 1, task->_imports + index, sizeof(import_record_t*) * (task->_import_count - index)); @@ -1739,7 +1741,7 @@ void tf_task_print(tf_task_t* task, int argc, JSValueConst* argv) size_t size; tf_serialize_store(task, task->_parent, &buffer, &size, array); tf_packetstream_send(tf_taskstub_get_stream(task->_parent), kPrint, buffer, size); - free(buffer); + tf_free(buffer); JS_FreeValue(task->_context, array); } diff --git a/src/taskstub.js.c b/src/taskstub.js.c index b86055f6..72356e35 100644 --- a/src/taskstub.js.c +++ b/src/taskstub.js.c @@ -1,11 +1,11 @@ #include "taskstub.js.h" +#include "mem.h" #include "packetstream.h" #include "serialize.h" #include "task.h" #include "util.js.h" -#include #include #include @@ -68,7 +68,7 @@ static void _taskstub_finalizer(JSRuntime *runtime, JSValue value); static JSValue _taskstub_create(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) { tf_task_t* parent = tf_task_get(context); - tf_taskstub_t* stub = malloc(sizeof(tf_taskstub_t)); + tf_taskstub_t* stub = tf_malloc(sizeof(tf_taskstub_t)); memset(stub, 0, sizeof(*stub)); stub->_stream = tf_packetstream_create(); @@ -216,7 +216,7 @@ tf_task_t* tf_taskstub_get_owner(const tf_taskstub_t* stub) tf_taskstub_t* tf_taskstub_create_parent(tf_task_t* task, uv_file file) { JSValue parentObject = JS_NewObject(tf_task_get_context(task)); - tf_taskstub_t* parentStub = malloc(sizeof(tf_taskstub_t)); + tf_taskstub_t* parentStub = tf_malloc(sizeof(tf_taskstub_t)); memset(parentStub, 0, sizeof(tf_taskstub_t)); parentStub->_stream = tf_packetstream_create(); parentStub->_on_exit = JS_UNDEFINED; @@ -249,7 +249,7 @@ static void _taskstub_cleanup(tf_taskstub_t* stub) JS_IsUndefined(stub->_object) && stub->_finalized) { - free(stub); + tf_free(stub); } } @@ -321,7 +321,7 @@ static JSValue _taskstub_setImports(JSContext* context, JSValueConst this_val, i size_t size; tf_serialize_store(tf_task_get(context), stub, &buffer, &size, argv[0]); tf_packetstream_send(stub->_stream, kSetImports, (char*)buffer, size); - free(buffer); + tf_free(buffer); return JS_UNDEFINED; } @@ -332,7 +332,7 @@ static JSValue _taskstub_setRequires(JSContext* context, JSValueConst this_val, size_t size; tf_serialize_store(tf_task_get(context), stub, &buffer, &size, argv[0]); tf_packetstream_send(stub->_stream, kSetRequires, (char*)buffer, size); - free(buffer); + tf_free(buffer); return JS_UNDEFINED; } @@ -343,7 +343,7 @@ static JSValue _taskstub_loadFile(JSContext* context, JSValueConst this_val, int size_t size; tf_serialize_store(tf_task_get(context), stub, &buffer, &size, argv[0]); tf_packetstream_send(stub->_stream, kLoadFile, (char*)buffer, size); - free(buffer); + tf_free(buffer); return JS_UNDEFINED; } diff --git a/src/tests.c b/src/tests.c index 34db242e..7e085b5b 100644 --- a/src/tests.c +++ b/src/tests.c @@ -1,5 +1,6 @@ #include "tests.h" +#include "mem.h" #include "ssb.tests.h" #include @@ -559,7 +560,7 @@ static void _tf_test_run(const tf_test_options_t* options, const char* name, voi bool specified = false; if (options->tests) { - char* dup = strdup(options->tests); + char* dup = tf_strdup(options->tests); char* state = NULL; const char* t = NULL; while ((t = strtok_r(t ? NULL : dup, ",", &state)) != NULL) @@ -570,7 +571,7 @@ static void _tf_test_run(const tf_test_options_t* options, const char* name, voi break; } } - free(dup); + tf_free(dup); } if (!options->tests || specified) diff --git a/src/tls.c b/src/tls.c index 1dbfbeca..5ac976b1 100644 --- a/src/tls.c +++ b/src/tls.c @@ -1,8 +1,9 @@ #include "tls.h" +#include "mem.h" + #if defined(_WIN32) #define TF_TLS_SCHANNEL -#include #elif defined(__MACH__) #define TF_TLS_APPLE #else @@ -1050,7 +1051,7 @@ TlsContext* TlsContext::create() tf_tls_context_t* tf_tls_context_create() { - tf_tls_context_t* context = malloc(sizeof(tf_tls_context_t)); + tf_tls_context_t* context = tf_malloc(sizeof(tf_tls_context_t)); memset(context, 0, sizeof(*context)); #if defined(TF_TLS_OPENSSL) SSL_library_init(); @@ -1135,7 +1136,7 @@ bool tf_tls_context_add_trusted_certificate(tf_tls_context_t* context, const cha tf_tls_session_t* tf_tls_context_create_session(tf_tls_context_t* context) { #if defined(TF_TLS_OPENSSL) - tf_tls_session_t* session = malloc(sizeof(tf_tls_session_t)); + tf_tls_session_t* session = tf_malloc(sizeof(tf_tls_session_t)); memset(session, 0, sizeof(*session)); session->context = context; session->bio_in = BIO_new(BIO_s_mem()); @@ -1151,7 +1152,7 @@ void tf_tls_context_destroy(tf_tls_context_t* context) { #if defined(TF_TLS_OPENSSL) SSL_CTX_free(context->context); - free(context); + tf_free(context); #elif defined(TF_TLS_APPLE) #elif defined(TF_TLS_SCHANNEL) #endif @@ -1166,9 +1167,9 @@ void tf_tls_session_destroy(tf_tls_session_t* session) } if (session->hostname) { - free((void*)session->hostname); + tf_free((void*)session->hostname); } - free(session); + tf_free(session); #elif defined(TF_TLS_APPLE) #elif defined(TF_TLS_SCHANNEL) #endif @@ -1179,12 +1180,12 @@ void tf_tls_session_set_hostname(tf_tls_session_t* session, const char* hostname #if defined(TF_TLS_OPENSSL) if (session->hostname) { - free((void*)session->hostname); + tf_free((void*)session->hostname); session->hostname = NULL; } if (hostname) { - session->hostname = strdup(hostname); + session->hostname = tf_strdup(hostname); } #elif defined(TF_TLS_APPLE) #elif defined(TF_TLS_SCHANNEL) diff --git a/src/tlscontext.js.c b/src/tlscontext.js.c index 01f8bf0f..b21943d4 100644 --- a/src/tlscontext.js.c +++ b/src/tlscontext.js.c @@ -1,5 +1,6 @@ #include "tlscontext.js.h" +#include "mem.h" #include "task.h" #include "tls.h" @@ -78,7 +79,7 @@ int tf_tls_context_get_count() JSValue _tls_context_create(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) { - tf_tls_context_t* tls = malloc(sizeof(tf_tls_context_t)); + tf_tls_context_t* tls = tf_malloc(sizeof(tf_tls_context_t)); memset(tls, 0, sizeof(*tls)); ++_count; @@ -104,5 +105,5 @@ void _tls_context_finalizer(JSRuntime *runtime, JSValue value) tls->context = NULL; } --_count; - free(tls); + tf_free(tls); } diff --git a/src/trace.c b/src/trace.c index 1242aa1d..70b209de 100644 --- a/src/trace.c +++ b/src/trace.c @@ -1,7 +1,8 @@ #include "trace.h" +#include "mem.h" + #include -#include #include #include #include @@ -56,7 +57,7 @@ static void _trace_append(tf_trace_t* trace, const char* buffer, size_t size, vo tf_trace_t* tf_trace_create() { - tf_trace_t* trace = malloc(sizeof(tf_trace_t)); + tf_trace_t* trace = tf_malloc(sizeof(tf_trace_t)); memset(trace, 0, sizeof(*trace)); trace->callback = _trace_append; return trace; @@ -68,9 +69,9 @@ void tf_trace_destroy(tf_trace_t* trace) { tf_trace_stack_t* stack = trace->stack; trace->stack = stack->next; - free(stack); + tf_free(stack); } - free(trace); + tf_free(trace); } void tf_trace_raw(tf_trace_t* trace, const char* buffer, size_t size) @@ -116,7 +117,7 @@ void tf_trace_begin(tf_trace_t* trace, const char* name) if (!trace->stack || trace->stack->count + 1 > _countof(trace->stack->names)) { - tf_trace_stack_t* stack = malloc(sizeof(tf_trace_stack_t)); + tf_trace_stack_t* stack = tf_malloc(sizeof(tf_trace_stack_t)); memset(stack, 0, sizeof(*stack)); stack->next = trace->stack; trace->stack = stack; @@ -205,7 +206,7 @@ char* tf_trace_export(tf_trace_t* trace) } static const int k_extra_size = 1024; - char* buffer = malloc(k_buffer_size + k_extra_size); + char* buffer = tf_malloc(k_buffer_size + k_extra_size); const char* newline = strchr(trace->buffer + trace->write_offset, '\n'); int begin = newline ? newline - trace->buffer : 0; size_t size = 0; diff --git a/src/util.js.c b/src/util.js.c index 113373a4..724c39d9 100644 --- a/src/util.js.c +++ b/src/util.js.c @@ -1,5 +1,6 @@ #include "util.js.h" +#include "mem.h" #include "task.h" #include "trace.h" @@ -7,128 +8,8 @@ #include -#include - #include -static int64_t s_uv_malloc_size; -static int64_t s_tls_malloc_size; - -static void* _tf_alloc(int64_t* total, size_t size) -{ - void* ptr = malloc(size + sizeof(size_t)); - if (ptr) - { - __atomic_add_fetch(total, size, __ATOMIC_RELAXED); - memcpy(ptr, &size, sizeof(size_t)); - return (void*)((intptr_t)ptr + sizeof(size_t)); - } - else - { - return NULL; - } -} - -static void* _tf_realloc(int64_t* total, void* ptr, size_t size) -{ - void* old_ptr = ptr ? (void*)((intptr_t)ptr - sizeof(size_t)) : NULL; - size_t old_size = 0; - if (old_ptr) - { - memcpy(&old_size, old_ptr, sizeof(size_t)); - } - void* new_ptr = realloc(old_ptr, size + sizeof(size_t)); - if (new_ptr) - { - __atomic_add_fetch(total, (int64_t)size - (int64_t)old_size, __ATOMIC_RELAXED); - memcpy(new_ptr, &size, sizeof(size_t)); - return (void*)((intptr_t)new_ptr + sizeof(size_t)); - } - else - { - __atomic_sub_fetch(total, old_size, __ATOMIC_RELAXED); - return NULL; - } -} - -static void _tf_free(int64_t* total, void* ptr) -{ - if (ptr) - { - void* old_ptr = (void*)((intptr_t)ptr - sizeof(size_t)); - size_t size = 0; - memcpy(&size, old_ptr, sizeof(size_t)); - __atomic_sub_fetch(total, size, __ATOMIC_RELAXED); - free(old_ptr); - } -} - -static void* _tf_uv_alloc(size_t size) -{ - return _tf_alloc(&s_uv_malloc_size, size); -} - -static void* _tf_uv_realloc(void* ptr, size_t size) -{ - return _tf_realloc(&s_uv_malloc_size, ptr, size); -} - -static void* _tf_uv_calloc(size_t nmemb, size_t size) -{ - void* ptr = calloc(1, nmemb * size + sizeof(size_t)); - if (ptr) - { - size_t total_size = nmemb * size; - __atomic_add_fetch(&s_uv_malloc_size, total_size, __ATOMIC_RELAXED); - memcpy(ptr, &total_size, sizeof(size_t)); - return (void*)((intptr_t)ptr + sizeof(size_t)); - } - else - { - return NULL; - } -} - -static void _tf_uv_free(void* ptr) -{ - _tf_free(&s_uv_malloc_size, ptr); -} - -void tf_util_replace_uv_allocator() -{ - uv_replace_allocator(_tf_uv_alloc, _tf_uv_realloc, _tf_uv_calloc, _tf_uv_free); -} - -size_t tf_util_get_uv_malloc_size() -{ - return s_uv_malloc_size; -} - -void* _tf_tls_alloc(size_t size, const char* file, int line) -{ - return _tf_alloc(&s_tls_malloc_size, size); -} - -void* _tf_tls_realloc(void* ptr, size_t size, const char* file, int line) -{ - return _tf_realloc(&s_tls_malloc_size, ptr, size); -} - -void _tf_tls_free(void* ptr, const char* file, int line) -{ - _tf_free(&s_tls_malloc_size, ptr); -} - -void tf_util_replace_tls_allocator() -{ - CRYPTO_set_mem_functions(_tf_tls_alloc, _tf_tls_realloc, _tf_tls_free); -} - -size_t tf_util_get_tls_malloc_size() -{ - return s_tls_malloc_size; -} - static JSValue _util_utf8_encode(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv) { size_t length = 0; @@ -271,7 +152,7 @@ typedef struct _timeout_t { static void _handle_closed(uv_handle_t* handle) { - free(handle); + tf_free(handle); } static void _util_timeoutCallback(uv_timer_t* handle) @@ -288,7 +169,7 @@ static void _util_timeoutCallback(uv_timer_t* handle) tf_util_report_error(context, result); JS_FreeValue(context, result); tf_trace_end(tf_task_get_trace(timeout->_task)); - free(timeout); + tf_free(timeout); uv_close((uv_handle_t*)handle, _handle_closed); } @@ -296,14 +177,14 @@ static JSValue _util_setTimeout(JSContext* context, JSValueConst this_val, int a { tf_task_t* task = JS_GetContextOpaque(context); - timeout_t* timeout = malloc(sizeof(timeout_t)); + timeout_t* timeout = tf_malloc(sizeof(timeout_t)); *timeout = (timeout_t) { ._task = task, ._callback = JS_DupValue(context, argv[0]), }; - uv_timer_t* timer = malloc(sizeof(uv_timer_t)); + uv_timer_t* timer = tf_malloc(sizeof(uv_timer_t)); memset(timer, 0, sizeof(uv_timer_t)); uv_timer_init(tf_task_get_loop(task), timer); timer->data = timeout; diff --git a/src/util.js.h b/src/util.js.h index cfb01f86..42e3e404 100644 --- a/src/util.js.h +++ b/src/util.js.h @@ -4,12 +4,6 @@ #include -void tf_util_replace_uv_allocator(); -size_t tf_util_get_uv_malloc_size(); - -void tf_util_replace_tls_allocator(); -size_t tf_util_get_tls_malloc_size(); - void tf_util_register(JSContext* context); JSValue tf_util_utf8_decode(JSContext* context, JSValue value); uint8_t* tf_util_try_get_array_buffer(JSContext* context, size_t* psize, JSValueConst obj);