NO_INLINE void G_GNUC_COLD
assertion_failure_log(const assertion_data * const data,
const char * const fmt, ...)
{
va_list args;
const char *msg;
assertion_message(data, TRUE);
/*
* Record the root cause of the assertion failure to be able to log it
* in the crash log in case they don't have gdb available.
*/
crash_assert_failure(data);
/*
* Record additional message in the crash log as well.
*/
va_start(args, fmt);
msg = crash_assert_logv(fmt, args);
va_end(args);
/*
* Log additional message.
*/
if (msg != NULL) {
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (FATAL-): ")];
unsigned stid = thread_small_id();
DECLARE_STR(4);
crash_time(time_buf, sizeof time_buf);
print_str(time_buf);
if (0 == stid) {
print_str(" (FATAL): ");
} else {
str_bprintf(prefix, sizeof prefix, " (FATAL-%u): ", stid);
print_str(prefix);
}
print_str(msg);
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
assertion_abort();
}
void Airplane::printDebug(const int cur_time, const planeDebugType dtype) {
std::cout << "[" << cur_time << "]";
switch (dtype) {
case DBG_LREQ:
std::cout << " new landing req: will crash @" << crash_time();
break;
case DBG_TREQ:
std::cout << " new takeoff req";
break;
case DBG_LAND:
std::cout << " landed plane: entered @" << start_time()
<< ", would crash @" << crash_time();
break;
case DBG_TOFF:
std::cout << " plane takeoff: entered @" << start_time();
break;
case DBG_CRASH:
std::cout << " found crashed plane: entered @" << start_time()
<< ", crashed @" << crash_time();
break;
}
std::cout << std::endl;
}
NO_INLINE void G_GNUC_COLD
assertion_warning_log(const assertion_data * const data,
const char * const fmt, ...)
{
static str_t *str;
va_list args;
assertion_message(data, FALSE);
if G_UNLIKELY(NULL == str)
str = str_new_not_leaking(512);
/*
* Log additional message.
*/
va_start(args, fmt);
str_vprintf(str, fmt, args);
va_end(args);
{
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (WARNING-): ")];
unsigned stid = thread_small_id();
DECLARE_STR(4);
crash_time(time_buf, sizeof time_buf);
print_str(time_buf);
if (0 == stid) {
print_str(" (WARNING): ");
} else {
str_bprintf(prefix, sizeof prefix, " (WARNING-%u): ", stid);
print_str(prefix);
}
print_str(str_2c(str));
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
assertion_stacktrace();
}
/**
* @note For maximum safety this is kept signal-safe, so that we can
* even use assertions in signal handlers. See also:
* http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html
*/
static G_GNUC_COLD void
assertion_message(const assertion_data * const data, int fatal)
{
char line_buf[22];
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (WARNING-): ")];
unsigned stid;
DECLARE_STR(16);
crash_time(time_buf, sizeof time_buf);
stid = thread_small_id();
print_str(time_buf);
if (0 == stid) {
print_str(fatal ? " (FATAL): " : " (WARNING): ");
} else {
str_bprintf(prefix, sizeof prefix, " (%s-%u): ",
fatal ? "FATAL" : "WARNING", stid);
print_str(prefix);
}
if (data->expr) {
print_str("Assertion failure at ");
} else {
print_str("Code should not have been reached at ");
}
print_str(data->file);
print_str(":");
print_str(print_number(line_buf, sizeof line_buf, data->line));
if (data->expr) {
print_str(": \"");
print_str(data->expr);
print_str("\"");
}
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
/**
* @note For maximum safety this is kept signal-safe, so that we can
* even use assertions in signal handlers. See also:
* http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html
*/
static G_GNUC_COLD void
assertion_message(const assertion_data * const data, int fatal)
{
char line_buf[ULONG_DEC_BUFLEN];
char time_buf[CRASH_TIME_BUFLEN];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (WARNING-): ")];
unsigned stid, line;
bool assertion;
DECLARE_STR(16);
crash_time(time_buf, sizeof time_buf);
stid = thread_small_id();
/*
* When an assertion failed in some thread, things are likely to break in
* all the other threads and we want to avoid a cascade of failures being
* reported. We suspend after computing the crash time, in case we were
* not suspended due to a fatal error.
*/
thread_check_suspended();
print_str(time_buf);
if (0 == stid) {
print_str(fatal ? " (FATAL): " : " (WARNING): ");
} else {
str_bprintf(prefix, sizeof prefix, " (%s-%u): ",
fatal ? "FATAL" : "WARNING", stid);
print_str(prefix);
}
/*
* If the FAST_ASSERT_NOT_REACHED bit is set in the line number,
* then it does not indicate an assertion failure but rather that
* we reached a point in the code that should never have been reached.
* --RAM, 2013-10-28
*/
line = data->line & ~FAST_ASSERT_NOT_REACHED;
assertion = line == data->line;
if (assertion) {
print_str("Assertion failure at ");
} else {
print_str("Code should not have been reached in ");
print_str(data->expr); /* Routine name */
print_str("() at ");
}
print_str(data->file);
print_str(":");
print_str(PRINT_NUMBER(line_buf, line));
if (assertion) {
print_str(": \"");
print_str(data->expr);
print_str("\"");
}
print_str("\n");
flush_err_str_atomic();
if (log_stdout_is_distinct())
flush_str_atomic(STDOUT_FILENO);
}
// returns true if plane has exceeded it's crash time
bool Airplane::hasCrashed(const int cur_time)
{
return cur_time < crash_time();
}