/*
*
* DiagThresholdTest.c
* DiagThresholdTest
* Test suite for the memory diagnostics thresholds kernel.
* Copyright (c) 2022 Apple Inc. All rights reserved.
*
*/
#include "vm/diag_threshold_test.h"
#include <sys/kern_memorystatus.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <signal.h>
#include <sys/resource.h>
#include <errno.h>
#define TIMEOUT_MAX_SECONDS 10
/**
* Preprocessor declarations
*/
/**
* Global variables
*/
static mach_port_t exception_port; /** Port used to receive exception information*/
static semaphore_t exception_semaphore; /** Termination semaphore when the exception is caught */
static exception_mask_t mask = EXC_MASK_CORPSE_NOTIFY; /** Kind of exception we are interested in*/
static char main_thread_name[COMMAND_LINE_MAX]; /** Name of the main thread, for restauration */
static struct sigaction original_action; /** Original signal handler for the process */
/**
* Data types private
*/
static test_context_t *current_test_info; /** Data type used to handle working information on the current test*/
/**
* Function prototypes (private)
*/
static void prepare_harness(void); /** Preparation of the exception port and other miscs */
static void init_mach_exceptions_port(void); /** Creation of the exception port */
static void wait_for_exceptions_thread(test_context_t *tests_info); /** Wait for for the startup of the exception handler thread */
static void *test_executor_thread(void *); /** Code of the exception handler thread */
static void wait_for_executor_thread(test_context_t *info); /** Wait for the initialization of the worker thread */
static void create_exception_handler_thread(test_context_t *); /** Creator of the exception handler thread */
static void create_executor_handler_thread(test_context_t *param); /** Creation of the worker thread, the one that performs really the test code */
static void terminate_exception_handler_thread(test_context_t *); /** Order to terminate the current exception handler thread (by sending a user posix signal)*/
static void terminate_executor_handler_thread(test_context_t *param); /** Order to terminate the current worker thread (by sending a user posix signal)*/
static void set_exception_ports(test_context_t *param); /** Function that sets the exception port for the current test */
static void save_exception_ports(test_context_t *param); /** Save the current exception mach configuration to restore after the test */
static void restore_exception_ports(test_context_t *param); /** Restauration of the exception mach configuration after each test */
static void wait_for_exceptions_ready(test_context_t *info); /** Synch point between the worker and the test harness, to allow workers to capture exceptions */
static void set_sig_handler(void); /** Initialization of the SIGUSR1 posix signal handler, used to terminate threads */
static void reset_sig_handler(void); /** Reset the signal handler */
static void enable_coredumps(void); /** Since debug of this app is not possible with lldb, that allows to create core files for debugging */
static void deinit_mach_exceptions_port(void); /** Destroys the mach port used to exceptions*/
static void execute_one_test(test_case_t *test); /** Perform the exeuction of a single test */
static void remove_harness(void); /** Remove the test harness for this process*/
static uint64_t get_hw_memory_size(void); /** Get the ammount of RAM available on this device */
static const char *g_sysctl_memsize_name = "hw.memsize";
void
diag_mem_threshold_set_setup(__unused test_case_t *test)
{
T_QUIET; T_ASSERT_POSIX_ZERO( pthread_setname_np("Test controller"), "Verification thread set name");
enable_coredumps();
set_sig_handler();
prepare_harness();
execute_one_test(test);
}
/**
* Shutdown the test environment
*/
void
diag_mem_threshold_set_shutdown(void)
{
T_QUIET; T_ASSERT_POSIX_ZERO( pthread_getname_np(pthread_self(), main_thread_name, sizeof(main_thread_name)), "Verification thread get name");
remove_harness();
reset_sig_handler();
deinit_mach_exceptions_port();
}
/**
* Once the test worker is created, this function waits for a period of time (TIMEOUT_MAX_SECONDS) for an exception
* and returns TRUE if the exception is seen, or FALSE if not.
* - Parameter param: test execution information, used to mark in the test if the exception is seen.
* */
bool
diag_mem_threshold_wait_for_exception(test_context_t *param)
{
int seconds_execution = 0;
param->exception_seen = FALSE;
mach_timespec_t wait_time = {.tv_sec = 1, .tv_nsec = 0};
while (seconds_execution++ < TIMEOUT_MAX_SECONDS) {
if (!semaphore_timedwait(exception_semaphore, wait_time)) {
param->exception_seen = TRUE;
diag_mem_threshold_log_test("Semaphore done, exiting\n");
/* Cleanup any residual values in the semahore */
wait_time.tv_sec = 0;
while (!semaphore_timedwait(exception_semaphore, wait_time)) {
NULL;
}
return TRUE;
}
diag_mem_threshold_log_test("Waiting\n");
}
return FALSE;
}
/**
* Execute only one test
*/
void
execute_one_test(test_case_t *test)
{
test_context_t info = {
.test = test,
.exception_semaphore = exception_semaphore,
.exception_thread_start_sema = dispatch_semaphore_create(0),
.executor_thread_start_sema = dispatch_semaphore_create(0),
.executor_thread_end_sema = dispatch_semaphore_create(0),
.executor_ready_for_exceptions = dispatch_semaphore_create(0),
};
uint64_t this_system_ram_size = get_hw_memory_size();
current_test_info = &info;
/** If this test required a certain ammount of memory in the device, and is
* not present, just pass the test.
*/
if (test->required_minimum_hw_ram_size != 0) {
if (this_system_ram_size < test->required_minimum_hw_ram_size) {
T_SKIP("This system have less memory as required to run this test (Required %llu MB found %llu MB). Skipping", test->required_minimum_hw_ram_size >> 20ULL, this_system_ram_size >> 20ULL);
test->did_pass = TRUE;
return;
}
}
diag_mem_threshold_log_test("This system have %llu MB RAM\n", (this_system_ram_size >> 20ULL));
save_exception_ports(&info);
create_exception_handler_thread(&info);
create_executor_handler_thread(&info);
set_exception_ports(&info);
wait_for_exceptions_thread(&info);
wait_for_executor_thread(&info);
wait_for_exceptions_ready(&info);
if (test->exceptions_handled_in_test == false) {
bool wait_result = diag_mem_threshold_wait_for_exception(&info);
/** If the test expects to have an exception at end, and is seen.. */
if ((test->result_already_present == FALSE) && (wait_result == TRUE)) {
test->did_pass = TRUE;
} else if (test->exception_not_expected == TRUE && wait_result == FALSE) {
/** If the test expects to NOT have an exception at end, and NOT seen.. */
test->did_pass = TRUE;
} else {
test->did_pass = FALSE;
}
} else {
pthread_join(info.executor_handler_thread_id, NULL);
}
T_EXPECT_TRUE(test->did_pass, "Test result");
restore_exception_ports(&info);
if (test->exceptions_handled_in_test == false) {
terminate_executor_handler_thread(&info);
}
terminate_exception_handler_thread(&info);
if (info.test->did_pass) {
diag_mem_threshold_log_test("Test success\n");
} else {
diag_mem_threshold_log_test("Test failed\n");
}
}
/**
* Thread that really performs the test execution, sets its thread name, signals
* the semaphore of executor ready and calls to the test code. Finally
* it marks another semaphore to signal that the test code is complete.
* - Parameter params: parameters of the test execution
*/
static void *
test_executor_thread(void *params)
{
char thread_name[MAX_MESSAGE];
test_context_t info = *(test_context_t *)params;
snprintf(thread_name, sizeof(thread_name), "Exec: %s", info.test->short_name);
pthread_setname_np(thread_name);
diag_mem_threshold_log_test("Startup of executor for test %s\n", info.test->short_name);
dispatch_semaphore_signal(info.executor_thread_start_sema);
info.test->test_code(info.test, &info);
dispatch_semaphore_signal(info.executor_thread_end_sema);
return NULL;
}
/**
* Set the exception port for the current task, did not manage to make it work with execution thread..
* - Parameter param: paramers of the exeuction, not used at the moment
*/
static void
set_exception_ports(__unused test_context_t *param)
{
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, task_set_exception_ports(mach_task_self(), mask, exception_port, (exception_behavior_t) (EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY), MACHINE_THREAD_STATE), "Cannot set exception port");
}
/**
* Allocates and sets rights for the exceptions port
*/
static void
init_mach_exceptions_port(void)
{
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &exception_port), "Verification allocation port for exceptions");
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, mach_port_insert_right(mach_task_self(), exception_port, exception_port, MACH_MSG_TYPE_MAKE_SEND), "Verification set port rights");
}
/**
* Destroys the used mach port for exceptions.
*/
static void
deinit_mach_exceptions_port(void)
{
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, mach_port_deallocate(mach_task_self(), exception_port), "Verification exceptions port deallocation");
}
/**
* Saves the current task exception port on the current test context.
* - Parameter info: test context.
*/
static void
save_exception_ports(test_context_t *info)
{
info->size_mask = NUM_MASKS;
kern_return_t ret;
ret = task_get_exception_ports(
mach_task_self(),
mask,
info->old_mask,
&info->size_mask,
info->old_handlers,
info->old_behaviors,
info->old_flavors);
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, ret, "Verification get old exception ports");
}
/**
* Once the test is completed, this function restores all the mach task exception configuration to its original state
* - Parameter info: test context.
*/
static void
restore_exception_ports(test_context_t *info)
{
kern_return_t ret;
ret = task_swap_exception_ports(
mach_task_self(),
mask,
MACH_PORT_NULL,
EXCEPTION_DEFAULT,
THREAD_STATE_NONE,
(exception_mask_array_t) &info->old_mask,
&info->size_mask,
info->old_handlers,
info->old_behaviors,
info->old_flavors);
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, ret, "Verification restore exception ports");
}
/**
* Create the pthread used to handle exceptions from this test.
* - Parameter param: Test context.
*/
static void
create_exception_handler_thread(test_context_t *param)
{
T_QUIET; T_ASSERT_POSIX_ZERO( pthread_create(¶m->exception_handler_thread_id, NULL, exception_thread, (void *)param), "Creation of exception handler thread");
}
/**
* Create the pthread used to really run the test code
* - Parameter param: Test context.
*/
static void
create_executor_handler_thread(test_context_t *param)
{
T_QUIET; T_ASSERT_POSIX_ZERO(pthread_create(¶m->executor_handler_thread_id, NULL, test_executor_thread, (void *)param), "Creation test worker thread");
}
/**
* Terminates the exception handler by sending a SIGUSR1 posix signal to the thread. On arrival it will terminate
* - Parameter param: Test context.
*/
static void
terminate_exception_handler_thread(test_context_t *param)
{
void *ret_value;
T_QUIET; T_ASSERT_POSIX_ZERO( pthread_kill(param->exception_handler_thread_id, SIGUSR1), "Verification send terminate signal to the exception handler thread");
T_QUIET; T_ASSERT_POSIX_ZERO( pthread_join(param->exception_handler_thread_id, &ret_value), "Verification join to exception handler thread");
}
/**
* Terminates the test code executior by sending a SIGUSR1 posix signal to the thread. On arrival it will terminate
* - Parameter param: Test context.
*/
static void
terminate_executor_handler_thread(test_context_t *param)
{
void *ret_value;
int pthread_kill_val = pthread_kill(param->executor_handler_thread_id, SIGUSR1);
T_QUIET; T_ASSERT_TRUE((pthread_kill_val == 0 || pthread_kill_val == ESRCH) ? TRUE : FALSE, "Verification send terminate to worker thread");
T_QUIET; T_ASSERT_POSIX_ZERO( pthread_join(param->executor_handler_thread_id, &ret_value), "Verification join to the test worker thread");
}
/**
* Exception handler thread. Receives the mach exception port messages, and dispatch them by using
* a standard mach_exc_server. It reads the messages one by one to allow some logging.
* Also sets its thread name to the EH test_name (EH from exception handler).
* Signals to the main thread that is ready to run the test by using the semaphore exception_thread_start_sema
*
* Please note that, in order to avoid problems it creates a working copy of the thread context, so, if the main loop
* discards the current test context, it can work with a copy.
* - Parameter param: Test context.
*/
void *
exception_thread(void *params)
{
char thread_name[MAX_MESSAGE];
test_context_t info = *(test_context_t *)params;
snprintf(thread_name, sizeof(thread_name), "EH %s", info.test->short_name);
pthread_setname_np(thread_name);
diag_mem_threshold_log_test("Startup of exception handler for test %s\n", info.test->short_name);
dispatch_semaphore_signal(info.exception_thread_start_sema);
while (1) {
/* Handle exceptions on exc_port */
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, mach_msg_server_once(mach_exc_server, 4096, exception_port, 0), "Verification of obtain a exception message");
diag_mem_threshold_log_test("Exception arrived\n");
}
return NULL;
}
/**
* Helper to test the diagnostics threshold limits for the tests. In order to ensure that everything works
* as expected, it also verifies the limit agains the ledger.
* - Parameter limit_param: new limit in bytes, -1 means "disable the threshold limit"
*
*/
bool
set_memory_diagnostics_threshold_limits(uint64_t limit_param, bool assert_on_error)
{
memorystatus_diag_memlimit_properties_t limit;
memorystatus_diag_memlimit_properties_t limit_verify;
diag_mem_threshold_log_test("Set threshold limit to %d MB\n", limit_param >> 20);
int pid = getpid();
limit.memlimit = limit_param;
int retValue = memorystatus_control(
MEMORYSTATUS_CMD_SET_DIAG_LIMIT,
pid,
0,
&limit, sizeof(limit)
);
T_ASSERT_MACH_SUCCESS( retValue, "Verification diagnostics threshold limit adjustment");
if (assert_on_error) {
retValue = memorystatus_control(
MEMORYSTATUS_CMD_GET_DIAG_LIMIT,
pid,
0,
&limit_verify, sizeof(limit_verify)
);
T_ASSERT_MACH_SUCCESS(retValue, "Verification memory diagnostics limit");
T_ASSERT_EQ(limit.memlimit, limit_verify.memlimit, "Verification of diag threshold mem limit");
}
return (retValue == KERN_SUCCESS) ? true : false;
}
/**
* Helper that allows to waste memory and afterwards free it. It uses kernel memory to ensure is allocated really.
* - Parameter ammount: ammount of memory to waste in bytes.
*/
void
diag_mem_threshold_waste_memory(uint64_t ammount)
{
mach_vm_address_t global_addr = 0;
vm_size_t global_size = ammount;
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, mach_vm_allocate(mach_task_self(), &global_addr, global_size, VM_FLAGS_ANYWHERE ), "Allocate memory for test threshold");
diag_mem_threshold_log_test("Going to waste memory (%d MB)\n", ammount >> 20);
memset((void *)global_addr, 0xaa, ammount);
diag_mem_threshold_log_test("Memory wasted\n");
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, mach_vm_deallocate(mach_task_self(), global_addr, global_size), "Deallocation of memory from test threshold");
}
/**
* Helper that allows to set a jetsam watermark
* - Parameter ammount: ammount of memory to waste in bytes.
*/
void
diag_mem_set_jetsam_watermark(uint ammount)
{
diag_mem_threshold_log_test("Set jetsam watermark to %d MB\n", ammount >> 20);
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, memorystatus_control(MEMORYSTATUS_CMD_SET_JETSAM_HIGH_WATER_MARK, getpid(), ammount >> 20, NULL, 0), "Set jetsam watermark");
}
/**
* Helper that allows to set a jetsam watermark
* - Parameter ammount: ammount of memory to waste in bytes.
*/
void
diag_mem_set_jetsam_limit(uint ammount)
{
diag_mem_threshold_log_test("Set jetsam limit to %d MB\n", ammount >> 20);
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, memorystatus_control(MEMORYSTATUS_CMD_SET_JETSAM_TASK_LIMIT, getpid(), ammount >> 20, NULL, 0), "Set jetsam watermark");
}
/**
* Standard mach exception handler invoked by mach_server
* - Parameters:
* - exception_port: see mach documentation
* - thread: see mach documentation
* - task: see mach documentation
* - exception: see mach documentation
* - code: see mach documentation
* - code_count: see mach documentation
*/
kern_return_t
catch_mach_exception_raise( __unused mach_port_t port, __unused mach_port_t thread, __unused mach_port_t task, __unused exception_type_t exception, __unused exception_data_t code, __unused mach_msg_type_number_t code_count)
{
#ifdef VERBOSE
diag_mem_threshold_log_test("catch_mach_exception_raise:Have exception (expected) type 0x%x code len %d\n", exception, code_count);
unsigned int j;
for (j = 0; j < code_count << 1; j++) {
diag_mem_threshold_log_test("catch_mach_exception_raise:Code[%d]=0x%x\n", j, code[j]);
}
#endif
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, semaphore_signal(exception_semaphore), "Verification of signal of exception semaphore");
return KERN_SUCCESS;
}
/**
* Standard mach exception handler invoked by mach_server, not used in this application
* - Parameters:
* - exception_port: see mach documentation
* - exception: see mach documentation
* - code: see mach documentation
* - codeCnt: see mach documentation
* - flavor: see mach documentation
* - old_state: see mach documentation
* - old_stateCnt: see mach documentation
* - new_state: see mach documentation
* - new_stateCnt: see mach documentation
*/
kern_return_t
catch_mach_exception_raise_state(__unused mach_port_t port, __unused exception_type_t exception, __unused const exception_data_t code, __unused mach_msg_type_number_t codeCnt, __unused int *flavor, __unused const thread_state_t old_state, __unused mach_msg_type_number_t old_stateCnt, __unused thread_state_t new_state, __unused mach_msg_type_number_t *new_stateCnt)
{
diag_mem_threshold_log_test("catch_mach_exception_raise_state:Have exception (expected) type 0x%x code len %d\n", exception, codeCnt);
T_QUIET; T_ASSERT_TRUE(FALSE, "Unexpected exception handler called");
return KERN_FAILURE;
}
/**
* Standard mach exception handler invoked by mach_server, not used in this application
* - Parameters:
* - exception_port: see mach documentation
* - exception: see mach documentation
* - code: see mach documentation
* - codeCnt: see mach documentation
* - flavor: see mach documentation
* - old_state: see mach documentation
* - old_stateCnt: see mach documentation
* - new_state: see mach documentation
* - new_stateCnt: see mach documentation
*/
kern_return_t
catch_mach_exception_raise_state_identity(__unused mach_port_t port, __unused mach_port_t thread, __unused mach_port_t task, __unused exception_type_t exception, __unused mach_exception_data_t code, __unused mach_msg_type_number_t codeCnt, __unused int *flavor, __unused thread_state_t old_state, __unused mach_msg_type_number_t old_stateCnt, __unused thread_state_t new_state, __unused mach_msg_type_number_t *new_stateCnt)
{
#ifdef VERBOSE
diag_mem_threshold_log_test("catch_mach_exception_raise_state_identity:Have exception (expected) exception_port %x thread %x task %x exception %x code %x codeCnt %x flavor %x old_statd %x old_stateCnt %x new_state %x new_stateCnt %x",
port,
thread,
task,
exception,
*code,
codeCnt,
*flavor,
old_state,
old_stateCnt,
new_state,
new_stateCnt);
for (unsigned int j = 0; j < codeCnt; j++) {
diag_mem_threshold_log_test("catch_mach_exception_raise_state_identity:Code[%d]=0x%llx\n", j, code[j]);
}
#endif
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, semaphore_signal(exception_semaphore), "Verification of signal of exception semaphore");
diag_mem_threshold_log_test("catch_mach_exception_raise_state_identity:Semaphore signalled");
return KERN_SUCCESS;
}
/**
* getter of the current exception port as a helper.
*/
mach_port_t
diag_mem_threshold_get_exception_port(void)
{
return exception_port;
}
/**
* Getter of the configured exceptions masks for this execution
*/
exception_mask_t
diag_mem_threshold_get_exceptions_mask(void)
{
return mask;
}
/**
* Wait until the exceptions thread is ready.
* - Parameter info: test context.
*/
static void
wait_for_exceptions_thread(test_context_t *info)
{
dispatch_semaphore_wait(info->exception_thread_start_sema, DISPATCH_TIME_FOREVER);
}
/**
* Wait until the executoir thread is ready.
* - Parameter info: test context.
*/
static void
wait_for_executor_thread(test_context_t *info)
{
dispatch_semaphore_wait(info->executor_thread_start_sema, DISPATCH_TIME_FOREVER);
}
/**
* Wait until the executor thread is ready to accept exceptions from the test launcher. It is used to handle also internally
* exceptions by the test worker thread. An example of that is the double limit test, where an app sets a limit, it passes it, and
* wants to re-enable the threshold limt. In this case part of the exception verification is done inside the test, and the rest (second exception)
* is delegated to the test launcher. Test launcher will not consider exceptions before this semaphore is signalled.
* - Parameter info: test context.
*/
static void
wait_for_exceptions_ready(test_context_t *info)
{
dispatch_semaphore_wait(info->executor_ready_for_exceptions, DISPATCH_TIME_FOREVER);
}
/* Temporally block signals while logging */
static sigset_t
thread_block_signal(int blocking_signal_mask)
{
sigset_t signal_mask;
sigset_t signal_mask_return;
sigemptyset(&signal_mask);
sigaddset(&signal_mask, blocking_signal_mask);
int mask_set_ret_value = pthread_sigmask(SIG_BLOCK, &signal_mask, &signal_mask_return);
assert( mask_set_ret_value == 0);
return signal_mask_return;
}
/* Restore the signals configuration */
static void
thread_unblock_signal(sigset_t unblocking_signal_mask)
{
assert(pthread_sigmask(SIG_SETMASK, &unblocking_signal_mask, NULL) == 0);
}
/**
*
* Simple log routine that adds information about the thread that is logging
*/
void
diag_mem_threshold_log_test(const char *fmt, ...)
{
char log_string[MAX_MESSAGE];
char thread_name[MAX_MESSAGE];
va_list valist;
/**
* To avoid problems with the xnu testing library log support, lets avoid signals while
* logging
*/
sigset_t sig_mask = thread_block_signal(SIGUSR1);
va_start(valist, fmt);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
vsnprintf(log_string, sizeof(log_string), (const char *)fmt, valist);
#pragma clang diagnostic pop
assert(pthread_getname_np(pthread_self(), thread_name, sizeof(thread_name)) == 0);
T_LOG("[%-32.32s] %s", thread_name, log_string);
/* And restore the signals */
thread_unblock_signal(sig_mask);
}
/**
* Prepare all the semaphores and other stuff required for all the tests
*/
static void
prepare_harness(void)
{
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, semaphore_create(mach_task_self(), &exception_semaphore, SYNC_POLICY_FIFO, 0), "Creation of semaphore for exceptions");
init_mach_exceptions_port();
}
/**
* Prepare all the semaphores and other stuff required for all the tests
*/
static void
remove_harness(void)
{
T_QUIET; T_ASSERT_EQ(KERN_SUCCESS, semaphore_destroy(mach_task_self(), exception_semaphore), "Destruction of exceptions semaphore");
deinit_mach_exceptions_port();
}
/**
* Handler of the SIGUSR1 signal, just terminates the current thread.
*/
static void
termination_handler(__unused int signo, __unused siginfo_t *info, __unused void *extra)
{
diag_mem_threshold_log_test("End of thread\n");
pthread_exit(NULL);
// We should never reach that point..
T_QUIET; T_ASSERT_MACH_SUCCESS(0, "Cannot kill this thread");
}
/**
* Standard function to set a singal handler routine. Sets the handler for SIGUSR1 to the
* termination_handler routine, and indeed terminates current thread.
*/
static void
set_sig_handler(void)
{
struct sigaction action;
action.sa_flags = SA_SIGINFO;
action.sa_sigaction = termination_handler;
T_QUIET; T_ASSERT_MACH_SUCCESS(sigaction(SIGUSR1, &action, &original_action), "Verification of adjustment of signal handler");
}
/**
* Standard function to set a singal handler routine. Sets the handler for SIGUSR1 to the
* termination_handler routine, and indeed terminates current thread.
*/
static void
reset_sig_handler(void)
{
T_QUIET; T_ASSERT_MACH_SUCCESS(sigaction(SIGUSR1, &original_action, NULL), "Verification of reset signal handler");
}
/**
* Since lldb do not work with CORPSE exceptions, that allows to
* store a task coredump for further analysis.
*/
static void
enable_coredumps(void)
{
struct rlimit limits = {
.rlim_cur = UINT64_MAX,
.rlim_max = UINT64_MAX
};
T_QUIET; T_ASSERT_MACH_SUCCESS( getrlimit(RLIMIT_CORE, &limits), "obtain coredump limits");
limits.rlim_cur = 0x7fffffffffffffff;
T_QUIET; T_ASSERT_MACH_SUCCESS( setrlimit(RLIMIT_CORE, &limits), "set coredump limits");
}
/**
* Return the ammount of memory available on this device
*/
static uint64_t
get_hw_memory_size(void)
{
int ret;
uint64_t max_mem;
size_t max_mem_size = sizeof(max_mem);
ret = sysctlbyname(g_sysctl_memsize_name, &max_mem, &max_mem_size, NULL, 0);
T_QUIET; T_ASSERT_POSIX_SUCCESS(ret, "memsize sysctl failed");
return max_mem;
}