void reader() {
gx_mfd *mfd_r;
gx_eventloop_init (mfd_events);
gx_sleep(0,500); // Give the writer enough time to get the file set up.
_N( mfd_r = acquire_gx_mfd(mfd_pool) ) _abort();
_ ( gx_mfd_create_r(mfd_r,10,"tmp/writer-file.dat")) _abort();
_ ( mfd_events_add_misc(mfd_r->notify_fd, mfd_r) ) _abort();
_ ( mfd_events_wait(-1, on_readfile_changed) ) _abort();
}
int main(int argc, char **argv) {
pid_t pid;
int status=0;
_N( mfd_pool = new_gx_mfd_pool(2) ) _abort();
_ (pid = fork() ) _abort();
if(pid) /* child */ writer();
else /* parent */ {reader(); waitpid(pid, &status, 0);}
return status;
}
void writer() {
int i;
gx_mfd *mfd_w;
char msg[] = "something blah blah";
_N( mfd_w = acquire_gx_mfd(mfd_pool) ) _abort();
_ ( gx_mfd_create_w(mfd_w,10,"tmp/writer-file.dat")) _abort();
gx_sleep(1);
for(i=0; i < 5; i++) {
gx_sleep(0,500);
log_info("CHILD: Writing some stuff");
mfd_write(mfd_w, msg, sizeof(msg));
}
//printf("writer: %llX\n", (unsigned long long int)(mfd_w->head->sig));
gx_sleep(1);
}
void _optlink()
{
LNKINIT();
// command lines all read, ready to go...
// start at head of OBJ_LIST and process OBJ_FILES
PASS1_STUFF(); // reads objs and libs
MIDDLE_STUFF(); // org segs and publics, etc
PASS2_STUFF(); // fixup and relocate
// NEED TO WAIT FOR ANY OUTPUT THREADS TO FINISH...
// WAIT FOR MAP THREAD TO FINISH
if (_HOST_THREADED)
{
if (!MAP_THREAD_HANDLE)
goto L7;
WaitForSingleObject(MAP_THREAD_HANDLE, -1);
_close_handle(MAP_THREAD_HANDLE);
MAP_THREAD_HANDLE = 0;
}
if (MAPFILE_GINDEX)
{
// FLUSH LAST BUFFER OF MAP FILE
MAP_FLUSHED = 0xFF;
_flush_trunc_close(MAP_DEVICE);
}
L7: ;
_NO_CANCEL_FLAG = 0xFF;
_abort();
}
NPError NPN_GetValue(NPP instance, NPNVariable variable, void *ret_value) {
notice("...getValue: %d", (int) variable);
{
uint32_t *p = ret_value;
notice(" %x %x %x %x", p[0], p[1], p[2], p[3]);
}
if(variable >= ((NPNVariable)1000) && variable <= ((NPNVariable)1011)) {
iface_getvalue(variable, ret_value);
return 0;
}
switch(variable) {
case kSupportedDrawingModel_ANPGetValue:
// This is not a mistake: it replicates a bug in Android.
*((uint32_t *) ret_value) = kBitmap_ANPDrawingModel & kSurface_ANPDrawingModel;
break;
case kJavaContext_ANPGetValue:
notice("kJavaContext_ANPGetValue");
*((jobject *) ret_value) = android_context;
break;
case NPNVWindowNPObject: {
int window_id;
if(get_window_object(food, &window_id)) {
perror("get_window_object");
_abort();
}
*((NPObject **) ret_value) = new_idproxy_object(window_id);
break;
}
default:
notice("unknown GetValue! returning with error");
*((uint32_t *) ret_value) = 0xdeadbee1;
return NPERR_GENERIC_ERROR;
}
return 0;
}
void MobileRecoveryUnit::abortUnitOfWork() {
invariant(_inUnitOfWork);
RECOVERY_UNIT_TRACE() << " Unit of work aborted, marked inactive.";
_inUnitOfWork = false;
_abort();
}
WiredTigerRecoveryUnit::~WiredTigerRecoveryUnit() {
invariant(!_inUnitOfWork);
_abort();
if (_session) {
_sessionCache->releaseSession(_session);
_session = NULL;
}
}
WiredTigerRecoveryUnit::~WiredTigerRecoveryUnit() {
invariant( _depth == 0 );
_abort();
if ( _session ) {
_sessionCache->releaseSession( _session );
_session = NULL;
}
}
void *Malloc(size_t size)
{
void *p = memalign(CACHE_LINE_SIZE, size);
if (!p) {
/* Fatal Error. We must abort. */
_abort();
}
return p;
}
/////////////////////////////////////////////////////////////////////////////
// Customized HardFault Handler which prints out debugging informations
/////////////////////////////////////////////////////////////////////////////
void HardFault_Handler_c(unsigned int * hardfault_args)
{
// from the book: "The definiteve guide to the ARM Cortex-M3"
volatile unsigned int stacked_r0;
volatile unsigned int stacked_r1;
volatile unsigned int stacked_r2;
volatile unsigned int stacked_r3;
volatile unsigned int stacked_r12;
volatile unsigned int stacked_lr;
volatile unsigned int stacked_pc;
volatile unsigned int stacked_psr;
stacked_r0 = ((unsigned long) hardfault_args[0]);
stacked_r1 = ((unsigned long) hardfault_args[1]);
stacked_r2 = ((unsigned long) hardfault_args[2]);
stacked_r3 = ((unsigned long) hardfault_args[3]);
stacked_r12 = ((unsigned long) hardfault_args[4]);
stacked_lr = ((unsigned long) hardfault_args[5]);
stacked_pc = ((unsigned long) hardfault_args[6]);
stacked_psr = ((unsigned long) hardfault_args[7]);
MIOS32_MIDI_SendDebugMessage("Hard Fault PC = %08x\n", stacked_pc); // ensure that at least the PC will be sent
MIOS32_MIDI_SendDebugMessage("==================\n");
MIOS32_MIDI_SendDebugMessage("!!! HARD FAULT !!!\n");
MIOS32_MIDI_SendDebugMessage("==================\n");
MIOS32_MIDI_SendDebugMessage("R0 = %08x\n", stacked_r0);
MIOS32_MIDI_SendDebugMessage("R1 = %08x\n", stacked_r1);
MIOS32_MIDI_SendDebugMessage("R2 = %08x\n", stacked_r2);
MIOS32_MIDI_SendDebugMessage("R3 = %08x\n", stacked_r3);
MIOS32_MIDI_SendDebugMessage("R12 = %08x\n", stacked_r12);
MIOS32_MIDI_SendDebugMessage("LR = %08x\n", stacked_lr);
MIOS32_MIDI_SendDebugMessage("PC = %08x\n", stacked_pc);
MIOS32_MIDI_SendDebugMessage("PSR = %08x\n", stacked_psr);
MIOS32_MIDI_SendDebugMessage("BFAR = %08x\n", (*((volatile unsigned long *)(0xE000ED38))));
MIOS32_MIDI_SendDebugMessage("CFSR = %08x\n", (*((volatile unsigned long *)(0xE000ED28))));
MIOS32_MIDI_SendDebugMessage("HFSR = %08x\n", (*((volatile unsigned long *)(0xE000ED2C))));
MIOS32_MIDI_SendDebugMessage("DFSR = %08x\n", (*((volatile unsigned long *)(0xE000ED30))));
MIOS32_MIDI_SendDebugMessage("AFSR = %08x\n", (*((volatile unsigned long *)(0xE000ED3C))));
#ifndef MIOS32_DONT_USE_LCD
// TODO: here we should select the normal font - but only if available!
// MIOS32_LCD_FontInit((u8 *)GLCD_FONT_NORMAL);
MIOS32_LCD_BColourSet(0xffffff);
MIOS32_LCD_FColourSet(0x000000);
MIOS32_LCD_DeviceSet(0);
MIOS32_LCD_Clear();
MIOS32_LCD_CursorSet(0, 0);
MIOS32_LCD_PrintString("!! HARD FAULT !!");
MIOS32_LCD_CursorSet(0, 1);
MIOS32_LCD_PrintFormattedString("at PC=0x%08x", stacked_pc);
#endif
_abort();
}
void __noreturn assert_fail(const char *msg)
{
/**
* @fwts-label FailedAssert
* @fwts-advice OPAL hit an assert(). During normal usage (even
* testing) we should never hit an assert. There are other code
* paths for controlled shutdown/panic in the event of catastrophic
* errors.
*/
prlog(PR_EMERG, "Assert fail: %s\n", msg);
_abort(msg);
}
int main(int argc, char **argv) {
int i;
log_info("Spawning 20,000 shortlived light threads");
for(i=0; i < 20000; i++) {
_(gx_clone(&child, NULL)) _abort();
}
log_info("(all-spawned - waiting a couple of seconds as they continue to die)");
gx_sleep(2);
return 0;
}
void writeImage(char* fileName, imageData idata) {
png_structp png_ptr;
png_infop info_ptr;
//Reverse the y-axis
png_bytep temp_row;
int front, back = idata.height-1;
pixelData pd = idata.pdata;
for (front=0; front<back; front++, back--) {
temp_row = pd[front];
idata.pdata[front] = pd[back];
idata.pdata[back] = temp_row;
}
//Open file
FILE *fp = fopen(fileName, "wb");
if (!fp) _abort("Could not open file %s for writing.", fileName);
//Libpng!
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) _abort("Problem getting libpng write struct.");
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) _abort("Problem getting info pointer.");
png_init_io(png_ptr, fp);
png_set_IHDR(png_ptr, info_ptr, idata.width, idata.height,
8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_write_info(png_ptr, info_ptr);
png_write_image(png_ptr, idata.pdata);
png_write_end(png_ptr, NULL);
fclose(fp);
}
void rasterLine(imageData idata, int x0, int y0, int x1, int y1)
{
printf("Line from (%d,%d) to (%d, %d)\n", x0, y0, x1, y1);
if (x0<0 || y0<0 || x1>=idata.width || y1>=idata.height)
_abort("Requested line out of image bounds");
int rise = y1-y0;
int run = x1-x0;
int x,y;
//f(x,y) == (y0-y1)x + (x1-x0)y +x0y1 - x1y0 = 0
// f(x+1, y+0.5) < 0
rgb lineColor = {0,255,0};
int mult=1;
if (abs(rise)<=abs(run)) { //abs(slope) < 1
if (x0>x1) { //scan left to right
swap(&x0, &x1);
swap(&y0, &y1);
}
if ((y1-y0)<0) mult = -1;
for (x=x0,y=y0; x<=x1; x++) {
setPixelT(idata, x, y, lineColor);
if ( mult*((y0-y1)*(x+1) + (x1-x0)*(y+0.5*mult) + x0*y1 - x1*y0) < 0 )
y += mult;
}
} else { //abs(slope)>1
if (y0>y1) { //scan bottom to top
swap(&x0, &x1);
swap(&y0, &y1);
}
if ((x1-x0)<0) mult = -1;
for (y=y0,x=x0; y<=y1; y++) {
setPixelT(idata, x, y, lineColor);
if ( mult*((y0-y1)*(x+0.5*mult) + (x1-x0)*(y+1) + x0*y1 - x1*y0) > 0 )
x+= mult;
}
}
}
void vApplicationStackOverflowHook(xTaskHandle xTask, signed portCHAR *pcTaskName)
{
MIOS32_MIDI_SendDebugMessage("======================\n");
MIOS32_MIDI_SendDebugMessage("!!! STACK OVERFLOW !!!\n");
MIOS32_MIDI_SendDebugMessage("======================\n");
MIOS32_MIDI_SendDebugMessage("Function: %s\n", pcTaskName);
#ifndef MIOS32_DONT_USE_LCD
// TODO: here we should select the normal font - but only if available!
// MIOS32_LCD_FontInit((u8 *)GLCD_FONT_NORMAL);
MIOS32_LCD_BColourSet(0xffffff);
MIOS32_LCD_FColourSet(0x000000);
MIOS32_LCD_DeviceSet(0);
MIOS32_LCD_Clear();
MIOS32_LCD_CursorSet(0, 0);
MIOS32_LCD_PrintString("!! STACK OVERFLOW !!");
MIOS32_LCD_CursorSet(0, 1);
MIOS32_LCD_PrintFormattedString("in Task %s", pcTaskName);
#endif
_abort();
}
/////////////////////////////////////////////////////////////////////////////
// enabled in FreeRTOSConfig.h
/////////////////////////////////////////////////////////////////////////////
void vApplicationMallocFailedHook(void)
{
#ifndef MIOS32_DONT_USE_LCD
// TODO: here we should select the normal font - but only if available!
// MIOS32_LCD_FontInit((u8 *)GLCD_FONT_NORMAL);
MIOS32_LCD_BColourSet(0xffffff);
MIOS32_LCD_FColourSet(0x000000);
MIOS32_LCD_DeviceSet(0);
MIOS32_LCD_Clear();
MIOS32_LCD_CursorSet(0, 0);
MIOS32_LCD_PrintString("FATAL: FreeRTOS "); // 16 chars
MIOS32_LCD_CursorSet(0, 1);
MIOS32_LCD_PrintString("Malloc Error!!! "); // 16 chars
#endif
#ifndef MIOS32_DONT_USE_MIDI
// Note: message won't be sent if MIDI task cannot be created!
MIOS32_MIDI_SendDebugMessage("FATAL: FreeRTOS Malloc Error!!!\n");
#endif
_abort();
}
/////////////////////////////////////////////////////////////////////////////
// _exit() for newer newlib versions
/////////////////////////////////////////////////////////////////////////////
void exit(int par)
{
#ifndef MIOS32_DONT_USE_LCD
// TODO: here we should select the normal font - but only if available!
// MIOS32_LCD_FontInit((u8 *)GLCD_FONT_NORMAL);
MIOS32_LCD_BColourSet(0xffffff);
MIOS32_LCD_FColourSet(0x000000);
MIOS32_LCD_DeviceSet(0);
MIOS32_LCD_Clear();
MIOS32_LCD_CursorSet(0, 0);
MIOS32_LCD_PrintString("Goodbye!");
#endif
#ifndef MIOS32_DONT_USE_MIDI
// Note: message won't be sent if MIDI task cannot be created!
MIOS32_MIDI_SendDebugMessage("Goodbye!\n");
#endif
// pro forma: since this is a noreturn function, loop endless and call _abort (which will never exit)
while( 1 )
_abort();
}
void main(int argc, char **argv)
{
propinfo = defpropinfo;
XDefProps(&propinfo);
InitInter(&argc, argv, &propinfo);
if (argc != 3 && argc != 4) {
error:
Error("call: ox com1 com2 [-old]\n");
}
if (strlen(argv[1]) + strlen(TO_PRAEFIX) > 90 ||
strlen(argv[2]) + strlen(TO_PRAEFIX) > 90 ||
strlen(argv[1]) + strlen(FROM_PRAEFIX) > 90 ||
strlen(argv[2]) + strlen(FROM_PRAEFIX) > 90)
Error("Id zu lang");
if (argv[3])
if (!strcmp(argv[3], "-old")) f_old = true;
else goto error;
sprintf(TO_1, "%s"TO_PRAEFIX, argv[1]);
sprintf(FROM_1, "%s"FROM_PRAEFIX, argv[1]);
sprintf(TO_2, "%s"TO_PRAEFIX, argv[2]);
sprintf(FROM_2, "%s"FROM_PRAEFIX, argv[2]);
Loop();
_abort();
}
bool idproxyConstruct(NPObject *npobj, const NPVariant *args, uint32_t argCount, NPVariant *result) {
err("! idproxyConstruct");
_abort();
}
void TerarkDbRecoveryUnit::abortUnitOfWork() {
invariant(_inUnitOfWork);
_inUnitOfWork = false;
_abort();
}
TerarkDbRecoveryUnit::~TerarkDbRecoveryUnit() {
invariant(!_inUnitOfWork);
_abort();
}
void WiredTigerRecoveryUnit::abortUnitOfWork() {
invariant(_inUnitOfWork);
_inUnitOfWork = false;
_abort();
}
bool idproxyRemoveProperty(NPObject *npobj, NPIdentifier name) {
err("! idproxyRemoveProperty: %@", name);
_abort();
}
bool idproxyEnumeration(NPObject *npobj, NPIdentifier **value, uint32_t *count) {
err("! idproxyEnumeration");
_abort();
}
void WiredTigerRecoveryUnit::abortUnitOfWork() {
invariant(_inUnitOfWork(), toString(_state));
_abort();
}
static void sigabort(int aa)
{
_abort() ;
}
WiredTigerRecoveryUnit::~WiredTigerRecoveryUnit() {
invariant(!_inUnitOfWork);
_abort();
}
void RocksRecoveryUnit::endUnitOfWork() {
_depth--;
if (_depth == 0) {
_abort();
}
}
RocksRecoveryUnit::~RocksRecoveryUnit() {
_abort();
RocksRecoveryUnit::_totalLiveRecoveryUnits.fetch_sub(1, std::memory_order_relaxed);
}
void WiredTigerRecoveryUnit::endUnitOfWork() {
_depth--;
if ( _depth == 0 ) {
_abort();
}
}
