DECLARE_TEST(error, context) { error_context_t* context = 0; context = error_context(); if (context) EXPECT_EQ(context->depth, 0); error_context_push(STRING_CONST("error test"), STRING_CONST("data")); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 1); EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test"))); EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data"))); #else EXPECT_EQ(context, 0); #endif error_context_pop(); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 0); #else EXPECT_EQ(context, 0); #endif error_context_push(STRING_CONST("error test"), STRING_CONST("data")); error_context_push(STRING_CONST("another test"), STRING_CONST("more data")); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 2); EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test"))); EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data"))); EXPECT_CONSTSTRINGEQ(context->frame[1].name, string_const(STRING_CONST("another test"))); EXPECT_CONSTSTRINGEQ(context->frame[1].data, string_const(STRING_CONST("more data"))); #else EXPECT_EQ(context, 0); #endif error_context_pop(); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 1); EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test"))); EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data"))); #else EXPECT_EQ(context, 0); #endif error_context_pop(); return 0; }
static int mce_severity_intel(struct mce *m, int tolerant, char **msg, bool is_excp) { enum exception excp = (is_excp ? EXCP_CONTEXT : NO_EXCP); enum context ctx = error_context(m); struct severity *s; for (s = severities;; s++) { if ((m->status & s->mask) != s->result) continue; if ((m->mcgstatus & s->mcgmask) != s->mcgres) continue; if (s->ser == SER_REQUIRED && !mca_cfg.ser) continue; if (s->ser == NO_SER && mca_cfg.ser) continue; if (s->context && ctx != s->context) continue; if (s->excp && excp != s->excp) continue; if (msg) *msg = s->msg; s->covered = 1; if (s->sev >= MCE_UC_SEVERITY && ctx == IN_KERNEL) { if (tolerant < 1) return MCE_PANIC_SEVERITY; } return s->sev; } }
int htmllex() { #ifdef HAVE_EXPAT static char *begin_html = "<HTML>"; static char *end_html = "</HTML>"; char *s; char *endp = 0; int len, llen; int rv; state.tok = 0; do { if (state.mode == 2) return EOF; if (state.mode == 0) { state.mode = 1; s = begin_html; len = strlen(s); endp = 0; } else { s = state.ptr; if (*s == '\0') { state.mode = 2; s = end_html; len = strlen(s); } else { endp = findNext(s,&state.lb); len = endp - s; } } state.prevtok = state.currtok; state.prevtoklen = state.currtoklen; state.currtok = s; state.currtoklen = len; if ((llen = agxblen(&state.lb))) rv = XML_Parse(state.parser, agxbuse(&state.lb),llen, 0); else rv = XML_Parse(state.parser, s, len, (len ? 0 : 1)); if (rv == XML_STATUS_ERROR) { if (!state.error) { agerr(AGERR, "%s in line %d \n", XML_ErrorString(XML_GetErrorCode(state.parser)), htmllineno()); error_context(); state.error = 1; state.tok = T_error; } } if (endp) state.ptr = endp; } while (state.tok == 0); #if DEBUG printTok (state.tok); #endif return state.tok; #else return EOF; #endif }
int mce_severity(struct mce *m, int tolerant, char **msg) { enum context ctx = error_context(m); struct severity *s; for (s = severities;; s++) { if ((m->status & s->mask) != s->result) continue; if ((m->mcgstatus & s->mcgmask) != s->mcgres) continue; if (s->ser == SER_REQUIRED && !mce_ser) continue; if (s->ser == NO_SER && mce_ser) continue; if (s->context && ctx != s->context) continue; if (msg) *msg = s->msg; s->covered = 1; if (s->sev >= MCE_UC_SEVERITY && ctx == IN_KERNEL) { if (panic_on_oops || tolerant < 1) return MCE_PANIC_SEVERITY; } return s->sev; } }
/* htmlerror: * yyerror - called by yacc output */ void htmlerror(const char *msg) { if (state.error) return; state.error = 1; agerr(AGERR, "%s in line %d \n", msg, htmllineno()); error_context(); }
bool check_error() { if (error_is_valid) { struct local_error *context = error_context(); return context->is_error; } else { return false; } }
void log_error_context( uint64_t context, error_level_t error_level ) { int i; error_context_t* err_context = error_context(); if( err_context && ( log_suppress( context ) < error_level ) ) { error_frame_t* frame = err_context->frame; for( i = 0; i < err_context->depth; ++i, ++frame ) _log_error_contextf( context, error_level, error_level > ERRORLEVEL_WARNING ? stderr : stdout, "When %s: %s", frame->name ? frame->name : "<something>", frame->data ? frame->data : "" ); } }
const wchar_t *clear_error() { if (error_is_valid) { struct local_error *context = error_context(); if (context->is_error) { context->is_error = false; return context->error_message; } } return NULL; }
/* * See AMD Error Scope Hierarchy table in a newer BKDG. For example * 49125_15h_Models_30h-3Fh_BKDG.pdf, section "RAS Features" */ static int mce_severity_amd(struct mce *m, int tolerant, char **msg, bool is_excp) { enum context ctx = error_context(m); /* Processor Context Corrupt, no need to fumble too much, die! */ if (m->status & MCI_STATUS_PCC) return MCE_PANIC_SEVERITY; if (m->status & MCI_STATUS_UC) { /* * On older systems where overflow_recov flag is not present, we * should simply panic if an error overflow occurs. If * overflow_recov flag is present and set, then software can try * to at least kill process to prolong system operation. */ if (mce_flags.overflow_recov) { if (mce_flags.smca) return mce_severity_amd_smca(m, ctx); /* software can try to contain */ if (!(m->mcgstatus & MCG_STATUS_RIPV) && (ctx == IN_KERNEL)) return MCE_PANIC_SEVERITY; /* kill current process */ return MCE_AR_SEVERITY; } else { /* at least one error was not logged */ if (m->status & MCI_STATUS_OVER) return MCE_PANIC_SEVERITY; } /* * For any other case, return MCE_UC_SEVERITY so that we log the * error and exit #MC handler. */ return MCE_UC_SEVERITY; } /* * deferred error: poll handler catches these and adds to mce_ring so * memory-failure can take recovery actions. */ if (m->status & MCI_STATUS_DEFERRED) return MCE_DEFERRED_SEVERITY; /* * corrected error: poll handler catches these and passes responsibility * of decoding the error to EDAC */ return MCE_KEEP_SEVERITY; }
const char *errno_error(int err) { if (error_is_valid) { struct local_error *context = error_context(); #if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE if (strerror_r(err, context->errno_message, HAKA_ERROR_SIZE) == 0) { context->error_message[HAKA_ERROR_SIZE-1] = 0; return context->errno_message; } #else const char *res = strerror_r(err, context->errno_message, HAKA_ERROR_SIZE); if (res) return res; #endif } return "Unknown error"; }
void error(const wchar_t *error, ...) { if (error_is_valid) { struct local_error *context = error_context(); if (!context->is_error) { va_list ap; va_start(ap, error); vswprintf(context->error_message, HAKA_ERROR_SIZE, error, ap); context->error_message[HAKA_ERROR_SIZE-1] = 0; va_end(ap); context->is_error = true; BREAKPOINT; } } }
static void* error_test_thread(void) { error_context_t* context = 0; EXPECT_EQ(error(), ERROR_NONE); EXPECT_EQ(error(), ERROR_NONE); error_report(ERRORLEVEL_WARNING, ERROR_ACCESS_DENIED); EXPECT_EQ(error(), ERROR_ACCESS_DENIED); EXPECT_EQ(error(), ERROR_NONE); error_report(ERRORLEVEL_ERROR, ERROR_INVALID_VALUE); EXPECT_EQ(error(), ERROR_INVALID_VALUE); EXPECT_EQ(error(), ERROR_NONE); context = error_context(); if (context) EXPECT_EQ(context->depth, 0); error_context_push(STRING_CONST("error test"), STRING_CONST("data")); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 1); EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test"))); EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data"))); #else EXPECT_EQ(context, 0); #endif error_context_pop(); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 0); #else EXPECT_EQ(context, 0); #endif error_context_push(STRING_CONST("error test"), STRING_CONST("data")); error_context_push(STRING_CONST("another test"), STRING_CONST("more data")); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 2); EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test"))); EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data"))); EXPECT_CONSTSTRINGEQ(context->frame[1].name, string_const(STRING_CONST("another test"))); EXPECT_CONSTSTRINGEQ(context->frame[1].data, string_const(STRING_CONST("more data"))); #else EXPECT_EQ(context, 0); #endif error_context_pop(); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(context, 0); EXPECT_EQ(context->depth, 1); EXPECT_CONSTSTRINGEQ(context->frame[0].name, string_const(STRING_CONST("error test"))); EXPECT_CONSTSTRINGEQ(context->frame[0].data, string_const(STRING_CONST("data"))); #else EXPECT_EQ(context, 0); #endif error_context_pop(); return 0; }
DECLARE_TEST( error, context ) { error_context_t* context = 0; context = error_context(); if( context ) EXPECT_EQ( context->depth, 0 ); error_context_push( "error test", "data" ); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE( context, 0 ); EXPECT_EQ( context->depth, 1 ); EXPECT_STREQ( context->frame[0].name, "error test" ); EXPECT_STREQ( context->frame[0].data, "data" ); #else EXPECT_EQ( context, 0 ); #endif error_context_pop(); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE( context, 0 ); EXPECT_EQ( context->depth, 0 ); #else EXPECT_EQ( context, 0 ); #endif error_context_push( "error test", "data" ); error_context_push( "another test", "more data" ); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE( context, 0 ); EXPECT_EQ( context->depth, 2 ); EXPECT_STREQ( context->frame[0].name, "error test" ); EXPECT_STREQ( context->frame[0].data, "data" ); EXPECT_STREQ( context->frame[1].name, "another test" ); EXPECT_STREQ( context->frame[1].data, "more data" ); #else EXPECT_EQ( context, 0 ); #endif error_context_pop(); context = error_context(); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE( context, 0 ); EXPECT_EQ( context->depth, 1 ); EXPECT_STREQ( context->frame[0].name, "error test" ); EXPECT_STREQ( context->frame[0].data, "data" ); #else EXPECT_EQ( context, 0 ); #endif error_context_pop(); return 0; }
void DisassemblerContext::print_functional_term(const ValuePtr<FunctionalValue>& term, bool bracket) { if (ValuePtr<BooleanValue> bool_value = dyn_cast<BooleanValue>(term)) { *m_output << (bool_value->value() ? "true" : "false"); } else if (ValuePtr<IntegerType> int_type = dyn_cast<IntegerType>(term)) { if (!int_type->is_signed()) *m_output << 'u'; *m_output << 'i'; const char *width; switch (int_type->width()) { case IntegerType::i8: width = "8"; break; case IntegerType::i16: width = "16"; break; case IntegerType::i32: width = "32"; break; case IntegerType::i64: width = "64"; break; case IntegerType::i128: width = "128"; break; case IntegerType::iptr: width = "ptr"; break; default: PSI_FAIL("unknown integer width"); } *m_output << width; } else if (ValuePtr<IntegerValue> int_value = dyn_cast<IntegerValue>(term)) { ValuePtr<IntegerType> type = int_value->type(); *m_output << '#'; if (!type->is_signed()) *m_output << 'u'; char width; switch (type->width()) { case IntegerType::i8: width = 'b'; break; case IntegerType::i16: width = 's'; break; case IntegerType::i32: width = 'i'; break; case IntegerType::i64: width = 'l'; break; case IntegerType::i128: width = 'q'; break; case IntegerType::iptr: width = 'p'; break; default: PSI_FAIL("unknown integer width"); } *m_output << width; int_value->value().print(error_context().bind(term->location()), *m_output, type->is_signed()); } else if (ValuePtr<FloatType> float_type = dyn_cast<FloatType>(term)) { const char *width; switch (float_type->width()) { case FloatType::fp32: width = "fp32"; break; case FloatType::fp64: width = "fp64"; break; case FloatType::fp128: width = "fp128"; break; case FloatType::fp_x86_80: width = "fp-x86-80"; break; case FloatType::fp_ppc_128: width = "fp-ppc-128"; break; default: PSI_FAIL("unknown integer width"); } *m_output << width; } else if (ValuePtr<ResolvedParameter> resolved_param = dyn_cast<ResolvedParameter>(term)) { ParameterNameList::reverse_iterator it = m_parameter_names.rbegin(); if (resolved_param->depth() < m_parameter_names.size()) { std::advance(it, resolved_param->depth()); PSI_ASSERT(resolved_param->index() < it->size()); *m_output << (*it)[resolved_param->index()]; } else { *m_output << "[unknown parameter : "; print_term(resolved_param->type(), false); *m_output << "]"; } } else if (ValuePtr<UnwrapParameter> unwrap_param = dyn_cast<UnwrapParameter>(term)) { *m_output << "unwrap_param "; print_term(unwrap_param->value(), true); *m_output << " " << unwrap_param->index(); } else { class MyVisitor : public FunctionalValueVisitor { DisassemblerContext *m_self; const char *m_operation; bool m_bracket; bool m_first; public: MyVisitor(DisassemblerContext *self, const char *operation, bool bracket) : m_self(self), m_operation(operation), m_bracket(bracket), m_first(true) {} virtual void next(const ValuePtr<>& ptr) { if (m_first) { if (m_bracket) *m_self->m_output << '('; *m_self->m_output << m_operation; m_first = false; } *m_self->m_output << ' '; m_self->print_term(ptr, true); } bool empty() const {return m_first;} }; MyVisitor my_visitor(this, term->operation_name(), bracket); term->functional_visit(my_visitor); if (my_visitor.empty()) { *m_output << term->operation_name(); } else if (bracket) { *m_output << ')'; } } }
DECLARE_TEST(exception, error) { error_handler_fn handler; int ret; error(); EXPECT_EQ(error(), ERROR_NONE); error_report(ERRORLEVEL_ERROR, ERROR_NONE); EXPECT_EQ(error(), ERROR_NONE); error_report(ERRORLEVEL_ERROR, ERROR_EXCEPTION); EXPECT_EQ(error(), ERROR_EXCEPTION); handler = error_handler(); error_set_handler(_error_handler_test); ret = error_report(ERRORLEVEL_WARNING, ERROR_INVALID_VALUE); EXPECT_EQ(error(), ERROR_INVALID_VALUE); EXPECT_EQ(ret, 2); EXPECT_EQ(_error_level_test, ERRORLEVEL_WARNING); EXPECT_EQ(_error_test, ERROR_INVALID_VALUE); EXPECT_EQ(error_handler(), _error_handler_test); error_set_handler(handler); { #if BUILD_ENABLE_ERROR_CONTEXT const char context_data[] = "another message"; #endif char context_buffer[512]; string_t contextstr; error_context_clear(); error_context_push(STRING_CONST("test context"), STRING_CONST("some message")); error_context_push(STRING_CONST("foo bar"), 0, 0); error_context_pop(); error_context_pop(); error_context_pop(); error_context_push(STRING_CONST("test context"), STRING_CONST(context_data)); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE(error_context(), 0); EXPECT_EQ(error_context()->depth, 1); EXPECT_CONSTSTRINGEQ(error_context()->frame[0].name, string_const(STRING_CONST("test context"))); EXPECT_EQ(error_context()->frame[0].data.str, context_data); EXPECT_EQ(error_context()->frame[0].data.length, sizeof(context_data) - 1); #endif contextstr = error_context_buffer(context_buffer, 512); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_NE_MSGFORMAT(string_find_string(STRING_ARGS(contextstr), STRING_CONST("test context"), 0), STRING_NPOS, "context name 'test context' not found in buffer: %s", context_buffer); EXPECT_NE_MSGFORMAT(string_find_string(STRING_ARGS(contextstr), STRING_CONST(context_data), 0), STRING_NPOS, "context data '%s' not found in buffer: %s", context_data, context_buffer); #else EXPECT_EQ(contextstr.length, 0); #endif error_context_clear(); contextstr = error_context_buffer(context_buffer, 512); #if BUILD_ENABLE_ERROR_CONTEXT EXPECT_STRINGEQ(contextstr, string_empty()); #endif } return 0; }