From 5f9f617ee7e78b7e812f289b0954165d7798071f Mon Sep 17 00:00:00 2001 From: Snaipe Date: Sat, 19 Sep 2015 18:08:37 +0200 Subject: [PATCH] Added inheritable heap to fork process --- CMakeLists.txt | 3 ++ include/criterion/alloc.h | 100 ++++++++++++++++++++++++++++++++++++++ src/compat/alloc.c | 94 +++++++++++++++++++++++++++++++++++ src/compat/alloc.h | 35 +++++++++++++ src/compat/process.c | 5 ++ test/alloc.cc | 36 ++++++++++++++ 6 files changed, 273 insertions(+) create mode 100644 include/criterion/alloc.h create mode 100644 src/compat/alloc.c create mode 100644 src/compat/alloc.h create mode 100644 test/alloc.cc diff --git a/CMakeLists.txt b/CMakeLists.txt index 27c56669..246a3021 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -101,6 +101,8 @@ set(SOURCE_FILES src/compat/time.c src/compat/time.h src/compat/posix.h + src/compat/alloc.c + src/compat/alloc.h src/io/redirect.c src/io/event.c src/io/event.h @@ -140,6 +142,7 @@ set(INTERFACE_FILES include/criterion/asprintf-compat.h include/criterion/designated-initializer-compat.h include/criterion/preprocess.h + include/criterion/alloc.h ) # Generate the configure file diff --git a/include/criterion/alloc.h b/include/criterion/alloc.h new file mode 100644 index 00000000..d39c25ab --- /dev/null +++ b/include/criterion/alloc.h @@ -0,0 +1,100 @@ +/* + * The MIT License (MIT) + * + * Copyright © 2015 Franklin "Snaipe" Mathieu + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef CRITERION_ALLOC_H_ +# define CRITERION_ALLOC_H_ + +# include +# include "common.h" + +CR_BEGIN_C_API + +CR_API void *cr_malloc(size_t size); +CR_API void *cr_calloc(size_t nmemb, size_t size); +CR_API void *cr_realloc(void *ptr, size_t size); +CR_API void cr_free(void *ptr); + +CR_END_C_API + +# ifdef __cplusplus +# include + +namespace criterion { + + void *(*const malloc)(size_t) = cr_malloc; + void (*const free)(void *) = cr_free; + void *(*const calloc)(size_t, size_t) = cr_calloc; + void *(*const realloc)(void *, size_t) = cr_realloc; + + template + T* new_obj(Params... params) { + T* obj = static_cast(cr_malloc(sizeof (T))); + new (obj) T(params...); + return obj; + } + + template + typename std::enable_if::value>::type* + new_arr(size_t len) { + void *ptr = cr_malloc(sizeof (size_t) + sizeof (T) * len); + *(static_cast(ptr)) = len; + T* arr = static_cast(static_cast(ptr) + 1); + return arr; + } + + template + T* new_arr(size_t len) { + void *ptr = cr_malloc(sizeof (size_t) + sizeof (T) * len); + *(static_cast(ptr)) = len; + + T* arr = static_cast(static_cast(ptr) + 1); + for (size_t i = 0; i < len; ++i) + new (arr + i) T(); + return arr; + } + + template + void delete_obj(T* ptr) { + ptr->~T(); + cr_free(ptr); + } + + template + void delete_arr(typename std::enable_if::value>::type* ptr) { + cr_free(ptr); + } + + template + void delete_arr(T* ptr) { + size_t len = *(static_cast(ptr)); + T* arr = static_cast(static_cast(ptr) + 1); + for (int i = 0; i < len; ++i) { + arr[i].~T(); + } + cr_free(ptr); + } + +} +# endif + +#endif /* !CRITERION_ALLOC_H_ */ diff --git a/src/compat/alloc.c b/src/compat/alloc.c new file mode 100644 index 00000000..2480ef2c --- /dev/null +++ b/src/compat/alloc.c @@ -0,0 +1,94 @@ +/* + * The MIT License (MIT) + * + * Copyright © 2015 Franklin "Snaipe" Mathieu + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#include "alloc.h" +#include "internal.h" +#include + +#ifdef VANILLA_WIN32 +HANDLE g_heap; + +void init_inheritable_heap(void) { + g_heap = HeapCreate(0, 0, 0); + if (g_heap == (HANDLE) NULL) { + fputs("Could not create the private inheritable heap.", stderr); + abort(); + } +} + +int inherit_heap(HANDLE child_process) { + PROCESS_HEAP_ENTRY entry = { .lpData = NULL }; + + while (HeapWalk(g_heap, &entry)) { + if (!(entry.wFlags & PROCESS_HEAP_REGION)) + continue; + + if (!VirtualAllocEx(child_process, + entry.lpData, + entry.cbData + entry.cbOverhead, + MEM_COMMIT, + PAGE_READWRITE)) + return -1; + + if (!WriteProcessMemory(child_process, + entry.lpData, + entry.lpData, + entry.cbData + entry.cbOverhead, + NULL)) + return -1; + } + return 0; +} +#endif + +void *cr_malloc(size_t size) { +#ifdef VANILLA_WIN32 + return HeapAlloc(g_heap, 0, size); +#else + return malloc(size); +#endif +} + +void *cr_calloc(size_t nmemb, size_t size) { +#ifdef VANILLA_WIN32 + return HeapAlloc(g_heap, HEAP_ZERO_MEMORY, nmemb * size); +#else + return calloc(nmemb, size); +#endif +} + +void *cr_realloc(void *ptr, size_t size) { +#ifdef VANILLA_WIN32 + return HeapReAlloc(g_heap, 0, ptr, size); +#else + return realloc(ptr, size); +#endif +} + +void cr_free(void *ptr) { +#ifdef VANILLA_WIN32 + HeapFree(g_heap, 0, ptr); +#else + free(ptr); +#endif +} diff --git a/src/compat/alloc.h b/src/compat/alloc.h new file mode 100644 index 00000000..3440e188 --- /dev/null +++ b/src/compat/alloc.h @@ -0,0 +1,35 @@ +/* + * The MIT License (MIT) + * + * Copyright © 2015 Franklin "Snaipe" Mathieu + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +#ifndef COMPAT_ALLOC_H_ +# define COMPAT_ALLOC_H_ + +# include "criterion/alloc.h" +# include "posix.h" + +# ifdef VANILLA_WIN32 +void init_inheritable_heap(void); +int inherit_heap(HANDLE child_process); +# endif + +#endif /* !COMPAT_ALLOC_H_ */ diff --git a/src/compat/process.c b/src/compat/process.c index 8a676231..cf2281d4 100644 --- a/src/compat/process.c +++ b/src/compat/process.c @@ -30,6 +30,7 @@ #include "process.h" #include "internal.h" #include "pipe-internal.h" +#include "alloc.h" #include @@ -168,6 +169,8 @@ static void CALLBACK handle_child_terminated(PVOID lpParameter, int resume_child(void) { #ifdef VANILLA_WIN32 + init_inheritable_heap(); + TCHAR mapping_name[128]; _sntprintf(mapping_name, 128, g_mapping_name, GetCurrentProcessId()); @@ -322,6 +325,8 @@ s_proc_handle *fork_process() { if (g_worker_context.suite->data) ctx->suite_data = *g_worker_context.suite->data; + inherit_heap(info.hProcess); + if (ResumeThread(info.hThread) == (DWORD) -1) goto failure; diff --git a/test/alloc.cc b/test/alloc.cc new file mode 100644 index 00000000..2d8366f3 --- /dev/null +++ b/test/alloc.cc @@ -0,0 +1,36 @@ +#include "criterion/criterion.h" +#include "criterion/alloc.h" + +struct Obj { + int foo; + long bar; + + Obj() {} + Obj(int foo, long bar) : foo(foo), bar(bar) {} +}; + +Test(alloc, object) { + Obj *o = criterion::new_obj(42, 314); + cr_assert_not_null(o); + + cr_assert_eq(o->foo, 42); + cr_assert_eq(o->bar, 314); + + criterion::delete_obj(o); +} + +Test(alloc, array) { + Obj *o = criterion::new_arr(3); + cr_assert_not_null(o); + + new (&o[0]) Obj(1, 2); + new (&o[1]) Obj(2, 4); + new (&o[2]) Obj(3, 6); + + for (int i = 0; i < 3; ++i) { + cr_assert_eq(o[i].foo, i + 1); + cr_assert_eq(o[i].bar, 2 * (i + 1)); + } + + criterion::delete_arr(o); +}