rtems_task task_1(rtems_task_argument argument){
while(1){
rtems_status_code returning;
rtems_event_set out;
printf("Waiting Task is now started... \nWaiting for event to be received...\n");
returning = rtems_event_receive(
RTEMS_EVENT_1,
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out
);
switch(returning){
case RTEMS_SUCCESSFUL: printf("Received Event Successfully..."); break;
default: printf("Event NOT received successfully...\n"); break;
};
rtems_task_wake_after(500);
printf("Quitting current task... \n");
rtems_task_delete ( RTEMS_SELF );
exit(1);
}
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_status_code sc;
rtems_event_set out;
int resets;
puts( "\n\n*** TEST INTERRUPT CRITICAL SECTION 10 ***" );
puts( "Init - Test may not be able to detect case is hit reliably" );
puts( "Init - Trying to generate timeout while blocking on event" );
Main_task = rtems_task_self();
interrupt_critical_section_test_support_initialize( NULL );
for (resets=0 ; resets< 2 ;) {
if ( interrupt_critical_section_test_support_delay() )
resets++;
sc = rtems_event_receive( 0x01, RTEMS_DEFAULT_OPTIONS, 1, &out );
fatal_directive_status( sc, RTEMS_TIMEOUT, "event_receive timeout" );
}
puts( "*** END OF TEST INTERRUPT CRITICAL SECTION 10 ***" );
rtems_test_exit(0);
}
static void
subTask2 (rtems_task_argument arg)
{
rtems_status_code sc;
rtems_event_set ev;
rtems_task_wake_after (ticksPerSecond * 1);
sc = rtems_event_receive(
1,
RTEMS_WAIT|RTEMS_EVENT_ANY,
RTEMS_NO_TIMEOUT,
&ev
);
if (sc != RTEMS_SUCCESSFUL) {
printf ("subTask2 - Can't receive event (%d)\n", sc);
rtems_task_suspend (RTEMS_SELF);
}
printf ("subTask2 - Task 1 suspended? - should be 0: %d\n",
isSuspended (taskId1));
rtems_task_wake_after (ticksPerSecond * 4);
printf ("subTask2 - Task 1 suspended? - should be 1: %d\n",
isSuspended (taskId1));
rtems_task_resume (taskId1);
printf ("subTask2 - Task 1 suspended? - should be 0: %d\n",
isSuspended (taskId1));
rtems_task_wake_after (ticksPerSecond * 4);
printf ("subTask2 - Task 1 suspended? - should be 1: %d\n",
isSuspended (taskId1));
puts( "*** END OF TEST 26 ***" );
rtems_test_exit( 0 );
}
static void bsp_interrupt_server_task(rtems_task_argument arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
while (true) {
rtems_event_set events = 0;
bsp_interrupt_server_entry *e = NULL;
sc = rtems_event_receive(
BSP_INTERRUPT_EVENT,
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&events
);
if (sc != RTEMS_SUCCESSFUL) {
break;
}
while ((e = bsp_interrupt_server_get_entry()) != NULL) {
(*e->handler)(e->arg);
bsp_interrupt_vector_enable(e->vector);
}
}
rtems_task_delete(RTEMS_SELF);
}
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
struct rtems_termios_tty *tty = (struct rtems_termios_tty *)argument;
rtems_event_set the_event;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
tty->txTaskId = 0;
rtems_task_delete(RTEMS_SELF);
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
}
}
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_event_set out;
int resets;
puts( "\n\n*** TEST INTERRUPT CRITICAL SECTION " TEST_NAME " ***" );
puts( "Init - Test may not be able to detect case is hit reliably" );
puts( "Init - Trying to generate event send from ISR while blocking" );
puts( "Init - Variation is: " TEST_STRING );
Main_task = rtems_task_self();
interrupt_critical_section_test_support_initialize( test_release_from_isr );
for (resets=0 ; resets< 2 ;) {
if ( interrupt_critical_section_test_support_delay() )
resets++;
(void) rtems_event_receive( EVENTS_TO_RECEIVE, RTEMS_EVENT_ANY, 1, &out );
}
puts( "*** END OF TEST INTERRUPT CRITICAL SECTION " TEST_NAME " ***" );
rtems_test_exit(0);
}
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
struct rtems_termios_tty *tty = (struct rtems_termios_tty *)argument;
rtems_event_set the_event;
int c;
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
tty->rxTaskId = 0;
rtems_task_delete(RTEMS_SELF);
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters (
tty,&c_buf,1);
}
}
}
}
static void printer_task( rtems_task_argument arg )
{
rtems_printer_task_context *ctx;
int fd;
ctx = (rtems_printer_task_context *) arg;
fd = ctx->fd;
while ( true ) {
rtems_event_set unused;
printer_task_buffer *buffer;
rtems_event_receive(
PRINT_TASK_WAKE_UP,
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&unused
);
while (
( buffer = printer_task_get_buffer( ctx, &ctx->todo_buffers ) ) != NULL
) {
switch ( buffer->action_kind ) {
case ACTION_WRITE:
write( fd, &buffer->data[ 0 ], buffer->action_data.size );
printer_task_append_buffer( ctx, &ctx->free_buffers, buffer );
break;
case ACTION_DRAIN:
fsync(fd);
rtems_event_transient_send( buffer->action_data.task );
break;
}
}
}
}
static bool test_body_timeout_before_all_satisfy(void *arg)
{
test_context *ctx = arg;
rtems_event_set out;
rtems_status_code sc;
out = DEADBEEF;
sc = rtems_event_receive(EVENTS, RTEMS_EVENT_ALL | RTEMS_WAIT, 1, &out);
rtems_test_assert(sc == RTEMS_TIMEOUT);
rtems_test_assert(out == DEADBEEF);
out = DEADBEEF;
sc = rtems_event_receive(EVENTS, RTEMS_EVENT_ALL | RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(out == EVENTS);
return ctx->hit;
}
static bool test_body_any_satisfy_before_timeout(void *arg)
{
test_context *ctx = arg;
rtems_status_code sc;
rtems_event_set out;
out = DEADBEEF;
sc = rtems_event_receive(EVENTS, RTEMS_EVENT_ANY | RTEMS_WAIT, 1, &out);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(out == GREEN);
out = DEADBEEF;
sc = rtems_event_receive(EVENTS, RTEMS_EVENT_ANY | RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(out == RED);
return ctx->hit;
}
static rtems_task ppp_rxdaemon(rtems_task_argument arg)
{
rtems_event_set events;
rtems_interrupt_level level;
struct ppp_softc *sc = (struct ppp_softc *)arg;
struct mbuf *mp = (struct mbuf *)0;
struct mbuf *m;
/* enter processing loop */
while ( 1 ) {
/* wait for event */
rtems_event_receive(RX_PACKET|RX_MBUF|RX_EMPTY,RTEMS_WAIT|RTEMS_EVENT_ANY,RTEMS_NO_TIMEOUT,&events);
if ( events & RX_EMPTY ) {
printf("RX: QUEUE is EMPTY\n");
events &= ~RX_EMPTY;
}
if ( events ) {
/* get the network semaphore */
rtems_bsdnet_semaphore_obtain();
/* check to see if new packet was received */
if ( events & RX_PACKET ) {
/* get received packet mbuf chain */
rtems_interrupt_disable(level);
IF_DEQUEUE(&sc->sc_rawq, m);
rtems_interrupt_enable(level);
/* ensure packet was retrieved */
if ( m != (struct mbuf *)0 ) {
/* process the received packet */
mp = ppp_inproc(sc, m);
}
}
/* allocate a new mbuf to replace one */
if ( mp == NULL ) {
pppallocmbuf(sc, &mp);
}
/* place mbuf on freeq */
rtems_interrupt_disable(level);
IF_ENQUEUE(&sc->sc_freeq, mp);
rtems_interrupt_enable(level);
mp = (struct mbuf *)0;
/* release the network semaphore */
rtems_bsdnet_semaphore_release();
/* check to see if queue is empty */
if ( sc->sc_rawq.ifq_head ) {
/* queue is not empty - post another event */
rtems_event_send(sc->sc_rxtask, RX_PACKET);
}
}
}
}
/*PAGE
*
* session
*
* This task handles single session. It is waked up when the FTP daemon gets a
* service request from a remote machine. Here, we watch for commands that
* will come through the control connection. These commands are then parsed
* and executed until the connection is closed, either unintentionally or
* intentionally with the "QUIT" command.
*
* Input parameters:
* arg - pointer to corresponding SessionInfo.
*
* Output parameters:
* NONE
*/
static void
session(rtems_task_argument arg)
{
FTPD_SessionInfo_t *const info = (FTPD_SessionInfo_t *)arg;
int chroot_made = 0;
rtems_libio_set_private_env();
/* chroot() can fail here because the directory may not exist yet. */
chroot_made = chroot(ftpd_root) == 0;
while(1)
{
rtems_event_set set;
rtems_event_receive(FTPD_RTEMS_EVENT, RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT,
&set);
chroot_made = chroot_made || chroot(ftpd_root) == 0;
chdir("/");
errno = 0;
send_reply(info, 220, FTPD_SERVER_MESSAGE);
while (1)
{
char buf[FTPD_BUFSIZE];
char *cmd, *opts, *args;
if (fgets(buf, FTPD_BUFSIZE, info->ctrl_fp) == NULL)
{
syslog(LOG_INFO, "ftpd: Connection aborted.");
break;
}
split_command(buf, &cmd, &opts, &args);
if (!strcmp("QUIT", cmd))
{
send_reply(info, 221, "Goodbye.");
break;
}
else
{
exec_command(info, cmd, args);
}
}
/* Close connection and put ourselves back into the task pool. */
close_data_socket(info);
close_stream(info);
task_pool_release(info);
}
}
rtems_status_code
rtems_monitor_suspend(rtems_interval timeout)
{
rtems_event_set event_set;
rtems_status_code status;
status = rtems_event_receive(MONITOR_WAKEUP_EVENT,
RTEMS_DEFAULT_OPTIONS,
timeout,
&event_set);
return status;
}
static bool test_body_event_from_isr( void *arg )
{
rtems_status_code status;
rtems_event_set out;
(void) arg;
status = rtems_event_receive( 0x01, RTEMS_DEFAULT_OPTIONS, 0, &out );
rtems_test_assert( status == RTEMS_SUCCESSFUL );
return case_hit;
}
static void obtain_callback(rtems_id timer_id, void *arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
char buf [1];
size_t size = sizeof(buf);
void *new_region_item = NULL;
rtems_event_set events = 0;
assert_time(T1);
rtems_test_assert(
!release_happened
&& !interrupt_happened
&& !delayed_happened
&& !interrupt_triggered_happened
&& !server_triggered_happened
);
obtain_try = true;
switch (resource_type) {
case SEMAPHORE:
sc = rtems_semaphore_obtain(semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
break;
case MUTEX:
sc = rtems_semaphore_obtain(mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
break;
case MESSAGE_QUEUE:
sc = rtems_message_queue_receive(
message_queue, buf, &size, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
break;
case REGION:
sc = rtems_region_get_segment(
region, 1, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &new_region_item);
break;
case EVENT:
sc = rtems_event_receive(
RTEMS_EVENT_0, RTEMS_EVENT_ALL | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &events);
break;
case BARRIER:
sc = rtems_barrier_wait(barrier, RTEMS_NO_TIMEOUT);
break;
case TASK_WAKE_AFTER:
sc = rtems_task_wake_after(T4 - T1);
break;
default:
rtems_test_assert(false);
break;
}
directive_failed(sc, "obtain");
obtain_done = true;
}
static void test_isr_level_for_new_threads( ISR_Level last_proper_level )
{
ISR_Level mask = CPU_MODES_INTERRUPT_MASK;
ISR_Level current;
test_isr_level_context ctx = {
.master_task_id = rtems_task_self()
};
for ( current = 0 ; current <= mask ; ++current ) {
rtems_mode initial_modes = RTEMS_INTERRUPT_LEVEL(current);
rtems_id id;
rtems_status_code sc;
rtems_event_set events;
ctx.actual_level = 0xffffffff;
sc = rtems_task_create(
rtems_build_name('I', 'S', 'R', 'L'),
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
initial_modes,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_start(
id,
isr_level_check_task,
(rtems_task_argument) &ctx
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_event_receive(
TEST_ISR_EVENT,
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&events
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
rtems_test_assert( events == TEST_ISR_EVENT );
if ( current <= last_proper_level ) {
rtems_test_assert( ctx.actual_level == current );
} else {
rtems_test_assert( ctx.actual_level == last_proper_level );
}
sc = rtems_task_delete( id ) ;
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
}
}
static void fec_wait_for_event(struct mcf548x_enet_struct *sc)
{
rtems_event_set out;
FEC_UNLOCK(sc);
rtems_event_receive(
FEC_EVENT,
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out
);
FEC_LOCK(sc);
}
static void test_with_normal_and_system_event(void)
{
rtems_status_code sc;
rtems_event_set out;
/* Assert no events pending */
sc = rtems_event_receive(EVENT, RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_event_system_receive(EVENT, RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
/* Send system event */
sc = rtems_event_system_send(rtems_task_self(), EVENT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_receive(EVENT, RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
out = 0;
sc = rtems_event_system_receive(EVENT, RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(out == EVENT);
/* Send normal event */
sc = rtems_event_send(rtems_task_self(), EVENT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
out = 0;
sc = rtems_event_receive(EVENT, RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(out == EVENT);
sc = rtems_event_system_receive(EVENT, RTEMS_NO_WAIT, 0, &out);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
}
int unmount( const char *path )
{
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
rv = (*mt_point_ops->unmount_h)( mt_entry );
if ( rv == 0 ) {
rtems_id self_task_id = rtems_task_self();
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
mt_entry->unmount_task = self_task_id;
mt_entry->mounted = false;
rtems_filesystem_mt_entry_unlock( lock_context );
}
} else {
errno = EBUSY;
rv = -1;
}
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
if ( rv == 0 ) {
rtems_event_set out;
rtems_status_code sc = rtems_event_receive(
RTEMS_FILESYSTEM_UNMOUNT_EVENT,
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out
);
if ( sc != RTEMS_SUCCESSFUL ) {
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
rtems_task High_tasks(
rtems_task_argument argument
)
{
if ( time_set )
(void) rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&eventout
);
else {
time_set = true;
/* start blocking rtems_event_receive time */
benchmark_timer_initialize();
(void) rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&eventout
);
}
}
static void wait_for_finish(void)
{
rtems_status_code sc;
rtems_event_set out;
sc = rtems_event_receive(
FINISH_EVENT,
RTEMS_WAIT | RTEMS_EVENT_ALL,
RTEMS_NO_TIMEOUT,
&out
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(out == FINISH_EVENT);
}
rtems_task test_task(
rtems_task_argument my_number
)
{
rtems_event_set out;
printf( "task %" PRIdrtems_task_argument " has started.\n", my_number);
rtems_event_receive(1, RTEMS_WAIT | RTEMS_EVENT_ANY, 0, &out);
printf( "task %" PRIdrtems_task_argument " ending.\n", my_number);
rtems_task_delete(RTEMS_SELF);
}
static rtems_event_set wait_for_events(void)
{
rtems_event_set events;
rtems_status_code sc;
sc = rtems_event_receive(
RTEMS_ALL_EVENTS,
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&events
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
return events;
}
static rtems_task pppTask(rtems_task_argument arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_option options;
rtems_event_set in;
rtems_event_set out;
int iStatus;
/* call function to setup ppp line discipline */
pppasyncattach();
/* enter processing loop */
in = (RTEMS_EVENT_29 | RTEMS_EVENT_30);
options = (RTEMS_EVENT_ANY | RTEMS_WAIT);
while ( sc == RTEMS_SUCCESSFUL ) {
/* wait for the next event */
sc = rtems_event_receive(in, options, RTEMS_NO_TIMEOUT, &out);
if ( sc == RTEMS_SUCCESSFUL ) {
/* determine which event was sent */
if ( out & RTEMS_EVENT_29 ) {
/* terminate event received */
/* set value to break out of event loop */
sc = RTEMS_UNSATISFIED;
}
else if ( out & RTEMS_EVENT_30 ) {
/* connect request */
/* execute the pppd main code */
iStatus = pppdmain(0, NULL);
if ( iStatus == EXIT_OK ) {
/* check exit callback */
if ( rtems_pppd_exitfp ) {
(*rtems_pppd_exitfp)();
}
}
else {
/* check error callback */
if ( rtems_pppd_errorfp ) {
(*rtems_pppd_errorfp)();
}
}
}
}
}
/* terminate myself */
rtems_pppd_taskid = 0;
rtems_task_delete(RTEMS_SELF);
}
static rtems_task pppdapp(rtems_task_argument arg)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_interval tickspersecond = 0;
rtems_option options;
rtems_event_set in;
rtems_event_set out;
/* initialize ticks per second */
tickspersecond = rtems_clock_get_ticks_per_second();
if ( tickspersecond == 0 ) {
/* ensure value is greater than zero */
tickspersecond = 100;
}
/* initiate connection */
pppdapp_setup();
rtems_pppd_connect();
/* enter processing loop */
in = (RTEMS_EVENT_10 | RTEMS_EVENT_11);
options = (RTEMS_EVENT_ANY | RTEMS_WAIT);
while ( sc == RTEMS_SUCCESSFUL ) {
/* wait for the next event */
sc = rtems_event_receive(in, options, RTEMS_NO_TIMEOUT, &out);
if ( sc == RTEMS_SUCCESSFUL ) {
/* determine which event was sent */
if ( out & RTEMS_EVENT_10 ) {
/* ip up recived */
/* call disconnect function */
rtems_pppd_disconnect();
}
if ( out & RTEMS_EVENT_11 ) {
/* ip down recived */
/* sleep 10 seconds and call connect function */
rtems_task_wake_after(10*tickspersecond);
rtems_pppd_connect();
}
}
}
/* terminate myself */
rtems_task_delete(RTEMS_SELF);
}
rtems_task Delayed_events_task(
rtems_task_argument argument
)
{
uint32_t count;
uint32_t previous_mode;
rtems_status_code status;
rtems_event_set events;
status = rtems_task_mode(
RTEMS_PREEMPT | RTEMS_TIMESLICE,
RTEMS_PREEMPT_MASK | RTEMS_TIMESLICE_MASK,
&previous_mode
);
directive_failed( status, "rtems_task_mode" );
status = rtems_timer_create( Timer_name[ 1 ], &Timer_id[ 1 ] );
directive_failed( status, "rtems_timer_create" );
while ( Stop_Test == FALSE ) {
for ( count=DELAYED_EVENT_DOT_COUNT; Stop_Test == FALSE && count; count-- ){
status = rtems_timer_fire_after(
Timer_id[ 1 ],
1,
Delayed_send_event,
NULL
);
directive_failed( status, "rtems_timer_reset" );
status = rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&events
);
directive_failed( status, "rtems_event_receive" );
}
put_dot('.');
}
Exit_test();
}
/**
* BDBUf wait for the wait event.
*/
rtems_status_code
bdbuf_wait (const char* who, unsigned long timeout)
{
rtems_status_code sc;
rtems_event_set out;
sc = rtems_event_receive (RTEMS_EVENT_0,
RTEMS_WAIT | RTEMS_EVENT_ANY,
TOD_MICROSECONDS_TO_TICKS (timeout * 1000),
&out);
if (sc != RTEMS_SUCCESSFUL)
{
bdbuf_test_printf ("%s: wait: receive failed: ", who);
bdbuf_test_print_sc (sc, true);
}
else if ((out & RTEMS_EVENT_0) == 0)
{
bdbuf_test_printf ("%s: wait: received wrong event: %08x", who, out);
}
return sc;
}
/*
* wait_input - wait until there is data available,
* for the length of time specified by *timo (indefinite
* if timo is NULL).
*/
void
wait_input(
struct timeval *timo)
{
rtems_event_set events;
rtems_interval ticks = 0;
rtems_option wait = RTEMS_WAIT;
if(timo) {
if(timo->tv_sec == 0 && timo->tv_usec == 0)
wait = RTEMS_NO_WAIT;
else {
ticks = (timo->tv_sec * 1000000 + timo->tv_usec) /
rtems_configuration_get_microseconds_per_tick();
if(ticks <= 0)
ticks = 1;
}
}
rtems_event_receive(RTEMS_EVENT_31, RTEMS_EVENT_ANY | wait, ticks, &events);
}
/**
* BDBUf wait for the wait event.
*/
static rtems_status_code
bdbuf_watch (unsigned long timeout)
{
rtems_status_code sc;
rtems_event_set out;
sc = rtems_event_receive (RTEMS_EVENT_1,
RTEMS_WAIT | RTEMS_EVENT_ANY,
RTEMS_MICROSECONDS_TO_TICKS (timeout * 1000),
&out);
if (sc != RTEMS_SUCCESSFUL)
{
bdbuf_test_printf ("watch: receive failed: ");
bdbuf_test_print_sc (sc, true);
}
else if ((out & RTEMS_EVENT_1) == 0)
{
bdbuf_test_printf ("watch: received wrong event: %08x", out);
}
return sc;
}
static void test(void)
{
rtems_event_set events;
rtems_status_code sc;
rtems_task_argument task_index;
task_ids[0] = rtems_task_self();
for (task_index = 1; task_index < TASK_COUNT; ++task_index) {
rtems_id task_id;
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
FIRST_TASK_PRIORITY + task_index,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, task, task_index);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
task_ids[task_index] = task_id;
}
sc = rtems_event_receive(
SECOND_TASK_READY,
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&events
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(events == SECOND_TASK_READY);
test_scheduler_cross();
test_scheduler_move_heir();
}
