static void* __irq_func(void *data)
{
(void)data;
int ret = kp_irq_func();
printf("[KEYP] Warning: irq handler returned with:%d\n", ret);
l4_sleep_forever();
}
int main(void)
{
pthread_t thread;
if (pthread_create(&thread, NULL, isr_thread, NULL))
return 1;
l4_sleep_forever();
return 0;
}
int main(void)
{
pthread_t one;
// create new shared memory area, 8K in size
if (l4shmc_create("testshm", 8192))
return 1;
pthread_create(&one, 0, thread_producer, 0);
l4_sleep_forever();
return 0;
}
static void *thread_producer(void *d)
{
(void)d;
l4shmc_chunk_t p_one;
l4shmc_signal_t s_one, s_done;
l4shmc_area_t shmarea;
l4_debugger_set_object_name(pthread_getl4cap(pthread_self()), "prod");
// attach this thread to the shm object
CHK(l4shmc_attach("testshm", &shmarea));
// add a chunk
CHK(l4shmc_add_chunk(&shmarea, "one", 1024, &p_one));
// add a signal
CHK(l4shmc_add_signal(&shmarea, "prod", &s_one));
// connect chunk and signal
CHK(l4shmc_connect_chunk_signal(&p_one, &s_one));
CHK(l4shmc_attach_signal_to(&shmarea, "done",
pthread_getl4cap(pthread_self()), 10000, &s_done));
printf("PRODUCER: ready\n");
while (1)
{
while (l4shmc_chunk_try_to_take(&p_one))
printf("Uh, should not happen!\n"); //l4_thread_yield();
set_some_data();
memcpy(l4shmc_chunk_ptr(&p_one), some_data, sizeof(some_data));
CHK(l4shmc_chunk_ready_sig(&p_one, sizeof(some_data)));
printf("PRODUCER: Sent data %s\n", some_data);
CHK(l4shmc_wait_signal(&s_done));
l4_sleep(5000);
}
l4_sleep_forever();
return NULL;
}
int main(void)
{
pthread_t one, two;
// create new shared memory area, 8K in size
if (l4shmc_create("testshm", 8192))
return 1;
// create two threads, one for producer, one for consumer
pthread_create(&one, 0, thread_producer, 0);
pthread_create(&two, 0, thread_consume, 0);
// now sleep, the two threads are doing the work
l4_sleep_forever();
return 0;
}
int main(void)
{
CU_pSuite suite = NULL;
int error = CU_initialize_registry();
if (error == CUE_SUCCESS)
LOG("Intialized test registry.");
else
LOG("Registry initialization failed.");
suite = CU_add_suite("cunit_simple", init_test_suite, cleanup_test_suite);
if (suite)
LOG("Test suite initialized.");
else {
CU_ErrorCode e = CU_get_error();
LOG("Error initializing test suite.");
LOG("Error was: %d", e);
}
CU_ADD_TEST(suite, test_maxi);
LOG("added test_maxi to suite.");
CU_ADD_TEST(suite, test_mini);
LOG("added test_mini to suite.");
LOG("Running tests in NORMAL mode.");
CU_basic_set_mode(CU_BRM_NORMAL);
CU_basic_run_tests();
LOG("Running tests in SILENT mode.");
CU_basic_set_mode(CU_BRM_SILENT);
CU_basic_run_tests();
LOG("Running tests in VERBOSE mode.");
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
CU_cleanup_registry();
LOG("Registry cleaned up.");
l4_sleep_forever();
return 0;
}
/* Pull down the entire world */
void VG_(exit)( Int status )
{
#if defined(VGO_linux)
(void)VG_(do_syscall1)(__NR_exit_group, status );
#elif defined(VGO_aix5) || defined(VGO_darwin)
(void)VG_(do_syscall1)(__NR_exit, status );
#elif defined(VGO_l4re)
VG_(printf)("Valgrind exitting. Status = %lx\n", status);
enter_kdebug("VG_(exit)");
l4_sleep_forever();
#else
# error Unknown OS
#endif
/*NOTREACHED*/
// We really shouldn't reach here. Just in case we do, use some very crude
// methods to force abort
__builtin_trap();
*(volatile Int*)0 = 'x';
}
/* Run a thread all the way to the end, then do appropriate exit actions
(this is the last-one-out-turn-off-the-lights bit). */
static void run_a_thread_NORETURN ( Word tidW )
{
ThreadId tid = (ThreadId)tidW;
VgSchedReturnCode src;
Int c;
VG_(debugLog)(1, "syswrap-l4re",
"run_a_thread_NORETURN(tid=%lld): pre-thread_wrapper\n",
(ULong)tidW);
/* Run the thread all the way through. */
src = thread_wrapper(tid);
VG_(debugLog)(1, "syswrap-l4re",
"run_a_thread_NORETURN(tid=%lld): post-thread_wrapper\n",
(ULong)tidW);
c = VG_(count_living_threads)();
vg_assert(c >= 1); /* stay sane */
// Tell the tool this thread is exiting
VG_TRACK( pre_thread_ll_exit, tid );
if (c == 1) {
VG_(debugLog)(1, "syswrap-l4re",
"run_a_thread_NORETURN(tid=%lld): "
"last one standing\n",
(ULong)tidW);
/* We are the last one standing. Keep hold of the lock and
carry on to show final tool results, then exit the entire system.
Use the continuation pointer set at startup in m_main. */
( * VG_(address_of_m_main_shutdown_actions_NORETURN) ) (tid, src);
} else {
ThreadState *tst;
VG_(debugLog)(1, "syswrap-l4re",
"run_a_thread_NORETURN(tid=%lld): "
"not last one standing\n",
(ULong)tidW);
/* OK, thread is dead, but others still exist. Just exit. */
tst = VG_(get_ThreadState)(tid);
/* This releases the run lock */
VG_(exit_thread)(tid);
vg_assert(tst->status == VgTs_Zombie);
/* We have to use this sequence to terminate the thread to
prevent a subtle race. If VG_(exit_thread)() had left the
ThreadState as Empty, then it could have been reallocated,
reusing the stack while we're doing these last cleanups.
Instead, VG_(exit_thread) leaves it as Zombie to prevent
reallocation. We need to make sure we don't touch the stack
between marking it Empty and exiting. Hence the
assembler. */
#if defined(VGO_l4re)
//XXX: some other threads still exists, so only this thread should exit
l4_sleep_forever();
enter_kdebug("hmm!");
#else
# error Unknown platform
#endif
VG_(core_panic)("Thread exit failed?\n");
}
/*NOTREACHED*/
vg_assert(0);
}
