static void task(rtems_task_argument arg)
{
rtems_status_code sc;
(void) arg;
rtems_test_assert(rtems_get_current_processor() == 1);
rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1);
rtems_test_assert(sched_get_priority_max(SCHED_RR) == INT_MAX - 1);
sc = rtems_semaphore_obtain(cmtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(imtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (1) {
/* Do nothing */
}
}
static void wake_up_main(const test_context *ctx)
{
rtems_status_code sc;
sc = rtems_event_transient_send(ctx->main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void bsp_interrupt_server_helper(void *arg)
{
bsp_interrupt_server_helper_data *hd = arg;
*hd->link = hd->action;
rtems_event_transient_send(hd->task);
}
static void wake_up_master(void)
{
rtems_status_code sc;
sc = rtems_event_transient_send(master_task);
assert(sc == RTEMS_SUCCESSFUL);
}
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 void request_close(test_context *ctx)
{
rtems_status_code sc;
sc = rtems_event_transient_send(ctx->close_task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
/*
* Use a timer to execute the actions, since it runs with thread dispatching
* disabled. This is necessary to check the expected processor allocations.
*/
static void timer(rtems_id id, void *arg)
{
test_context *ctx;
rtems_status_code sc;
size_t i;
ctx = arg;
i = ctx->action_index;
if (i == 0) {
sc = rtems_task_suspend(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
if (i < RTEMS_ARRAY_SIZE(test_actions)) {
const test_action *action = &test_actions[i];
rtems_id task;
ctx->action_index = i + 1;
task = ctx->task_ids[action->index];
switch (action->kind) {
case KIND_SET_PRIORITY:
set_priority(task, action->data.priority);
break;
case KIND_SET_AFFINITY:
set_affinity(task, action->data.cpu_set);
break;
case KIND_BLOCK:
sc = rtems_task_suspend(task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
break;
case KIND_UNBLOCK:
sc = rtems_task_resume(task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
break;
default:
rtems_test_assert(action->kind == KIND_RESET);
reset(ctx);
break;
}
check_cpu_allocations(ctx, action);
sc = rtems_timer_reset(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
} else {
sc = rtems_task_resume(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
static void imx_i2c_done(imx_i2c_bus *bus, int eno)
{
/*
* Generates a stop in case of transmit, otherwise, only disables interrupts
* (IMX_I2C_I2CR_MSTA is already cleared).
*/
imx_i2c_stop(bus->regs);
bus->eno = eno;
rtems_event_transient_send(bus->task_id);
}
static void high_task( rtems_task_argument arg )
{
rtems_status_code sc;
rtems_test_assert( test_no_preempt_step == 2 );
test_no_preempt_step = 3;
sc = rtems_event_transient_send( Task_id[ 1 ] );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
rtems_task_suspend(RTEMS_SELF);
rtems_test_assert(0);
}
static void server_task(rtems_task_argument arg)
{
rtems_status_code sc;
request *req = (request *) arg;
req->complete = true;
sc = rtems_event_transient_send(req->client);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(RTEMS_SELF);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void close_task(rtems_task_argument arg)
{
test_context *ctx = (test_context *) arg;
while (true) {
rtems_status_code sc;
int rv;
rv = close(ctx->fd);
rtems_test_assert(rv == 0);
sc = rtems_event_transient_send(ctx->main_task);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
static void task(rtems_task_argument arg)
{
rtems_status_code sc;
(void) arg;
rtems_test_assert(rtems_get_current_processor() == 1);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (1) {
/* Do nothing */
}
}
static void worker_task(rtems_task_argument arg)
{
worker_arg warg = *(worker_arg *) arg;
rtems_status_code sc;
sc = rtems_event_transient_send(warg.ctx->worker_ids[0]);
_Assert(sc == RTEMS_SUCCESSFUL);
(void) sc;
run_tests(warg.ctx, warg.jobs, warg.job_count, warg.worker_index);
while (true) {
/* Wait for delete by master worker */
}
}
static void test_with_request_self(void)
{
rtems_status_code sc;
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_event_transient_send(rtems_task_self());
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_event_transient_clear();
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
}
static void
no_mem_task(rtems_task_argument arg)
{
const no_mem_test *self = (const no_mem_test *) arg;
rtems_status_code sc;
void *greedy;
assert(rtems_configuration_get_unified_work_area());
greedy = rtems_workspace_greedy_allocate(NULL, 0);
(*self->body)(self->fd);
rtems_workspace_greedy_free(greedy);
sc = rtems_event_transient_send(self->master_task);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_suspend(RTEMS_SELF);
assert(sc == RTEMS_SUCCESSFUL);
}
static void test_mrsp_task(rtems_task_argument arg)
{
test_mrsp_context *ctx = (test_mrsp_context *) arg;
rtems_status_code sc;
sc = rtems_semaphore_release(ctx->semaphore_id);
rtems_test_assert(sc == RTEMS_NOT_OWNER_OF_RESOURCE);
sc = rtems_semaphore_obtain(ctx->semaphore_id, RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_semaphore_obtain(ctx->semaphore_id, RTEMS_WAIT, 1);
rtems_test_assert(sc == RTEMS_TIMEOUT);
sc = rtems_event_transient_send(ctx->task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_task_delete(RTEMS_SELF);
rtems_test_assert(0);
}
static void sticky_task(rtems_task_argument arg)
{
rtems_status_code sc;
rtems_id mtx_id;
(void) arg;
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_semaphore_create(
rtems_build_name(' ', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING,
2,
&mtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(mtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
ready = true;
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(mtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(mtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (1) {
/* Do nothing */
}
}
static rtems_task Locker_task(
rtems_task_argument task_index
)
{
rtems_id tid;
rtems_status_code status;
rtems_task_argument my_obtain_counter;
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &tid );
directive_failed( status, "rtems_task_ident" );
rtems_test_assert( task_index == task_number( tid ) - 1 );
status = rtems_semaphore_obtain( Semaphore, RTEMS_DEFAULT_OPTIONS, 0 );
directive_failed( status, "rtems_semaphore_obtain" );
put_name( Task_name[ task_index ], FALSE );
puts( " - unblocked - OK" );
status = rtems_task_wake_after( 10 );
directive_failed( status, "rtems_task_wake_after" );
my_obtain_counter = Obtain_counter;
rtems_test_assert( task_index == Obtain_order[ Variant ][ Obtain_counter ] );
++Obtain_counter;
status = rtems_semaphore_release( Semaphore );
directive_failed( status, "rtems_semaphore_release" );
if ( my_obtain_counter == MAX_TASKS - 1 ) {
status = rtems_event_transient_send( Master );
directive_failed( status, "rtems_event_transient_send" );
}
(void) rtems_task_delete( RTEMS_SELF );
}
static void stm32f4_i2c_handler(void *arg)
{
/* This handler implements the suggested read method from stm32f103xx
* reference manual if the handler is not the one with the highest priority */
stm32f4_i2c_bus_entry *e = arg;
volatile stm32f4_i2c *regs = e->regs;
uint32_t sr1 = regs->sr1;
uint8_t *data = e->data;
uint8_t *last = e->last;
bool read = e->read;
bool wake_task = false;
uint32_t cr1;
if(sr1 & STM32F4_I2C_SR1_SB) {
/* Start condition sent. */
regs->dr = e->addr_with_rw;
}
if(read) {
size_t len = e->len;
if(len == 1) {
/* special case for one single byte */
if(sr1 & STM32F4_I2C_SR1_ADDR) {
cr1 = regs->cr1;
cr1 &= ~STM32F4_I2C_CR1_ACK;
regs->cr1 = cr1;
/* Read sr2 to clear flag */
regs->sr2;
cr1 = regs->cr1;
cr1 |= STM32F4_I2C_CR1_STOP;
regs->cr1 = cr1;
} else if(sr1 & STM32F4_I2C_SR1_RxNE) {
*data = regs->dr;
wake_task = true;
}
} else if (len == 2) {
/* special case for two bytes */
if(sr1 & STM32F4_I2C_SR1_ADDR) {
/* Read sr2 to clear flag */
regs->sr2;
cr1 = regs->cr1;
cr1 &= ~STM32F4_I2C_CR1_ACK;
regs->cr1 = cr1;
} else if(sr1 & STM32F4_I2C_SR1_BTF) {
cr1 = regs->cr1;
cr1 |= STM32F4_I2C_CR1_STOP;
regs->cr1 = cr1;
*data = regs->dr;
++data;
*data = regs->dr;
wake_task = true;
}
} else {
/* more than two bytes */
if(sr1 & STM32F4_I2C_SR1_ADDR) {
/* Read sr2 to clear flag */
regs->sr2;
} else if(sr1 & STM32F4_I2C_SR1_BTF && data == last - 2) {
cr1 = regs->cr1;
cr1 &= ~STM32F4_I2C_CR1_ACK;
regs->cr1 = cr1;
*data = regs->dr;
++data;
cr1 = regs->cr1;
cr1 |= STM32F4_I2C_CR1_STOP;
regs->cr1 = cr1;
*data = regs->dr;
++data;
} else if((sr1 & STM32F4_I2C_SR1_RxNE) && (data != last - 2)) {
*data = regs->dr;
if(data == last) {
wake_task = true;
} else {
++data;
}
}
}
} else /* write */ {
if(sr1 & STM32F4_I2C_SR1_ADDR) {
/* Address sent */
regs->sr2;
}
if((sr1 & (STM32F4_I2C_SR1_ADDR | STM32F4_I2C_SR1_TxE)) && (data <= last)) {
regs->dr = *data;
++data;
} else if(sr1 & STM32F4_I2C_SR1_BTF) {
uint32_t cr1 = regs->cr1;
cr1 |= STM32F4_I2C_CR1_STOP;
regs->cr1 = cr1;
wake_task = true;
}
}
e->data = data;
if(wake_task) {
bsp_interrupt_vector_disable(e->vector);
rtems_event_transient_send(e->task_id);
}
}
static void test_scheduler_add_remove_processors(void)
{
rtems_status_code sc;
rtems_id scheduler_a_id;
rtems_id scheduler_c_id;
sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_add_processor(scheduler_c_id, 62);
rtems_test_assert(sc == RTEMS_NOT_CONFIGURED);
sc = rtems_scheduler_add_processor(scheduler_c_id, 63);
rtems_test_assert(sc == RTEMS_INCORRECT_STATE);
sc = rtems_scheduler_remove_processor(scheduler_c_id, 62);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_scheduler_remove_processor(scheduler_a_id, 0);
rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
if (rtems_get_processor_count() > 1) {
rtems_id scheduler_id;
rtems_id scheduler_b_id;
rtems_id task_id;
cpu_set_t first_cpu;
sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_remove_processor(scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_add_processor(scheduler_a_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_scheduler_remove_processor(scheduler_a_id, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(rtems_get_current_processor() == 1);
CPU_ZERO(&first_cpu);
CPU_SET(0, &first_cpu);
sc = rtems_scheduler_ident_by_processor_set(
sizeof(first_cpu),
&first_cpu,
&scheduler_id
);
rtems_test_assert(sc == RTEMS_INCORRECT_STATE);
sc = rtems_scheduler_add_processor(scheduler_a_id, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(rtems_get_current_processor() == 1);
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, sticky_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (!ready) {
/* Wait */
}
sc = rtems_scheduler_remove_processor(scheduler_a_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_event_transient_send(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_add_processor(scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
