static void test_with_request_server(void)
{
rtems_status_code sc;
rtems_id id;
request req;
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
req.client = rtems_task_self();
req.complete = false;
sc = rtems_task_create(
rtems_build_name('S', 'E', 'R', 'V'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(id, server_task, (rtems_task_argument) &req);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(req.complete);
}
static void test_with_timeout(void)
{
rtems_status_code sc;
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_event_transient_receive(RTEMS_WAIT, 1);
rtems_test_assert(sc == RTEMS_TIMEOUT);
sc = rtems_event_transient_receive(RTEMS_NO_WAIT, 0);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
}
static void wait(void)
{
rtems_status_code sc;
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static rtems_status_code i2c_wait_done(stm32f4_i2c_bus_entry *e)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bsp_interrupt_vector_enable(e->vector);
e->task_id = rtems_task_self();
return rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
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);
}
void rtems_printer_task_drain( rtems_printer_task_context *ctx )
{
printer_task_buffer buffer;
buffer.action_kind = ACTION_DRAIN;
buffer.action_data.task = rtems_task_self();
printer_task_append_buffer( ctx, &ctx->todo_buffers, &buffer );
rtems_event_send( ctx->task, PRINT_TASK_WAKE_UP );
rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT );
}
static void test_no_preempt( void )
{
rtems_status_code sc;
rtems_id id;
rtems_test_assert( test_no_preempt_step == 0 );
sc = rtems_task_delete( Task_id[ 2 ] );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_delete( Task_id[ 3 ] );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_create(
rtems_build_name( 'H', 'I', 'G', 'H' ),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&high_task_id
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_create(
rtems_build_name( 'L', 'O', 'W', ' ' ),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_NO_PREEMPT,
RTEMS_DEFAULT_ATTRIBUTES,
&low_task_id
);
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_timer_create( rtems_build_name( 'N', 'O', 'P', 'R' ), &id );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_timer_fire_after( id, 1, no_preempt_timer, NULL );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_timer_delete( id );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_delete( high_task_id );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
sc = rtems_task_delete( low_task_id );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
rtems_test_assert( test_no_preempt_step == 3 );
}
/**
* This routine is not defined in the POSIX 1003.1b standard but
* in some form is supported on most UNIX and POSIX systems. This
* routine is necessary to mount instantiations of a file system
* into the file system name space.
*/
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_instance_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_status_code sc = rtems_event_transient_receive(
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( sc != RTEMS_SUCCESSFUL ) {
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
static void test_mrsp_timeout_and_not_owner_of_resource(void)
{
rtems_status_code sc;
rtems_id id;
rtems_id task_id;
test_mrsp_context ctx;
puts("test MrsP timeout and not owner of resource");
sc = rtems_semaphore_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
| RTEMS_BINARY_SEMAPHORE,
1,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
ctx.semaphore_id = id;
ctx.task_id = rtems_task_self();
sc = rtems_task_start(task_id, test_mrsp_task, (rtems_task_argument) &ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static int imx_i2c_transfer(i2c_bus *base, i2c_msg *msgs, uint32_t n)
{
imx_i2c_bus *bus;
int supported_flags;
uint32_t i;
volatile imx_i2c *regs;
int eno;
rtems_status_code sc;
supported_flags = I2C_M_RD;
for (i = 0; i < n; ++i) {
if ((msgs[i].flags & ~supported_flags) != 0) {
return -EINVAL;
}
supported_flags |= I2C_M_NOSTART;
}
bus = (imx_i2c_bus *) base;
regs = bus->regs;
eno = imx_i2c_wait_for_not_busy(regs);
if (eno != 0) {
return -eno;
}
bus->msg_todo = n;
bus->msg = &msgs[0];
bus->restart = 0;
bus->task_id = rtems_task_self();
bus->eno = 0;
regs->i2sr = 0;
imx_i2c_setup_chunk(bus, regs);
sc = rtems_event_transient_receive(RTEMS_WAIT, bus->base.timeout);
if (sc != RTEMS_SUCCESSFUL) {
imx_i2c_stop(bus->regs);
rtems_event_transient_clear();
return -ETIMEDOUT;
}
return -bus->eno;
}
static void close_task(rtems_task_argument arg)
{
test_context *ctx = (test_context *) arg;
while (true) {
rtems_status_code sc;
int rv;
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
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 test(void)
{
test_context *ctx;
rtems_status_code sc;
size_t i;
ctx = &test_instance;
ctx->master_id = rtems_task_self();
for (i = 0; i < TASK_COUNT; ++i) {
sc = rtems_task_create(
NAME,
P(i),
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->task_ids[i]
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->task_ids[i], do_nothing_task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
sc = rtems_timer_create(NAME, &ctx->timer_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_timer_fire_after(ctx->timer_id, 1, timer, ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
for (i = 0; i < TASK_COUNT; ++i) {
sc = rtems_task_delete(ctx->task_ids[i]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
sc = rtems_timer_delete(ctx->timer_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
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 void test(void)
{
rtems_status_code sc;
rtems_id task_id;
rtems_id scheduler_id;
rtems_id scheduler_a_id;
rtems_id scheduler_b_id;
rtems_id scheduler_c_id;
rtems_task_priority prio;
cpu_set_t cpuset;
cpu_set_t first_cpu;
cpu_set_t second_cpu;
cpu_set_t all_cpus;
cpu_set_t online_cpus;
uint32_t cpu_count;
rtems_test_assert(rtems_get_current_processor() == 0);
cpu_count = rtems_get_processor_count();
main_task_id = rtems_task_self();
CPU_ZERO(&first_cpu);
CPU_SET(0, &first_cpu);
CPU_ZERO(&second_cpu);
CPU_SET(1, &second_cpu);
CPU_FILL(&all_cpus);
CPU_ZERO(&online_cpus);
CPU_SET(0, &online_cpus);
if (cpu_count > 1) {
CPU_SET(1, &online_cpus);
}
sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
if (cpu_count > 1) {
sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_a_id != scheduler_b_id);
}
sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('C', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING,
1,
&cmtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('I', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
1,
&imtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = 2;
sc = rtems_semaphore_set_priority(cmtx_id, scheduler_a_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
if (cpu_count > 1) {
prio = 1;
sc = rtems_semaphore_set_priority(cmtx_id, scheduler_b_id, prio, &prio);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
rtems_test_assert(prio == 2);
}
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_a_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu));
if (cpu_count > 1) {
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_b_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu));
}
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_a_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &online_cpus));
rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1);
rtems_test_assert(sched_get_priority_max(SCHED_RR) == 254);
sc = rtems_task_set_scheduler(task_id, scheduler_c_id, 1);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_task_set_scheduler(task_id, scheduler_c_id + 1, 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
if (cpu_count > 1) {
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &online_cpus));
sc = rtems_task_set_affinity(task_id, sizeof(all_cpus), &all_cpus);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(first_cpu), &first_cpu);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_task_set_affinity(task_id, sizeof(online_cpus), &online_cpus);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(second_cpu), &second_cpu);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_a_id, 1);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_semaphore_obtain(imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Ensure that the other task waits for the mutex owned by us */
sc = rtems_task_wake_after(2);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(RTEMS_SELF, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
sc = rtems_semaphore_release(imtx_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_semaphore_delete(cmtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(imtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
test_scheduler_add_remove_processors();
}
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);
}
}
rtems_resource_snapshot_take(&snapshot);
sc = rtems_task_create(
rtems_build_name('N', 'M', 'E', 'M'),
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_FLOATING_POINT,
&id
);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(id, no_mem_task, (rtems_task_argument) &test);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(id);
assert(sc == RTEMS_SUCCESSFUL);
assert(rtems_resource_snapshot_check(&snapshot));
}
static const char prog_name[] = "prog";
static int
invalid_prog(void *ctx)
{
(void) ctx;
static void test(void)
{
rtems_status_code sc;
rtems_id task_id;
rtems_id scheduler_id;
rtems_id scheduler_a_id;
rtems_id scheduler_b_id;
rtems_id scheduler_c_id;
cpu_set_t cpuset;
cpu_set_t first_cpu;
cpu_set_t second_cpu;
cpu_set_t all_cpus;
main_task_id = rtems_task_self();
CPU_ZERO(&first_cpu);
CPU_SET(0, &first_cpu);
CPU_ZERO(&second_cpu);
CPU_SET(1, &second_cpu);
CPU_ZERO(&all_cpus);
CPU_SET(0, &all_cpus);
CPU_SET(1, &all_cpus);
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_a_id != scheduler_b_id);
sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_a_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu));
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_b_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu));
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_a_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu));
sc = rtems_task_set_scheduler(task_id, scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id + 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu));
sc = rtems_task_set_affinity(task_id, sizeof(all_cpus), &all_cpus);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(first_cpu), &first_cpu);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_task_set_affinity(task_id, sizeof(second_cpu), &second_cpu);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_task_start(task_id, task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_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);
}
static void test(void)
{
rtems_status_code sc;
rtems_id task_id;
rtems_id scheduler_id;
rtems_id scheduler_a_id;
rtems_id scheduler_b_id;
rtems_id scheduler_c_id;
rtems_task_priority prio;
cpu_set_t cpuset;
cpu_set_t first_cpu;
cpu_set_t second_cpu;
cpu_set_t all_cpus;
uint32_t cpu_count;
main_task_id = rtems_task_self();
CPU_ZERO(&first_cpu);
CPU_SET(0, &first_cpu);
CPU_ZERO(&second_cpu);
CPU_SET(1, &second_cpu);
CPU_ZERO(&all_cpus);
CPU_SET(0, &all_cpus);
CPU_SET(1, &all_cpus);
cpu_count = rtems_get_processor_count();
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
if (cpu_count > 1) {
sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_a_id != scheduler_b_id);
}
sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_semaphore_create(
SCHED_A,
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING,
1,
&sema_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = 2;
sc = rtems_semaphore_set_priority(sema_id, scheduler_a_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
if (cpu_count > 1) {
prio = 1;
sc = rtems_semaphore_set_priority(sema_id, scheduler_b_id, prio, &prio);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
rtems_test_assert(prio == 2);
}
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_a_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu));
if (cpu_count > 1) {
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_b_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu));
}
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_a_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu));
rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1);
rtems_test_assert(sched_get_priority_max(SCHED_RR) == 254);
if (cpu_count > 1) {
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id + 1, 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu));
sc = rtems_task_set_affinity(task_id, sizeof(all_cpus), &all_cpus);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(first_cpu), &first_cpu);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_task_set_affinity(task_id, sizeof(second_cpu), &second_cpu);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_task_start(task_id, task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
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_semaphore_delete(sema_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void do_test(
rtems_attribute attr,
bool extract /* TRUE if extract, not release */
)
{
rtems_status_code status;
rtems_task_argument i;
Variant = ( ( attr & RTEMS_PRIORITY ) != 0 ? PRIORITY : FIFO );
Obtain_counter = 0;
status = rtems_semaphore_create(
rtems_build_name( 'S', 'E', 'M', '0' ), /* name = SEM0 */
0, /* locked */
RTEMS_BINARY_SEMAPHORE | attr, /* mutex w/desired discipline */
0, /* IGNORED */
&Semaphore
);
directive_failed( status, "rtems_semaphore_create" );
for (i = 0 ; i < MAX_TASKS ; i++ ) {
Task_name[ i ] = rtems_build_name(
'T',
'A',
'0' + (char)(i/10),
'0' + (char)(i%10)
);
status = rtems_task_create(
Task_name[ i ],
Priorities[ i ],
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ i ]
);
directive_failed( status, "rtems_task_create" );
status = rtems_task_start( Task_id[ i ], Locker_task, i );
directive_failed( status, "rtems_task_start" );
}
if ( extract ) {
for (i = 0 ; i< MAX_TASKS ; i++ ) {
status = rtems_task_delete( Task_id[ i ] );
directive_failed( status, "rtems_task_delete" );
}
}
/* do the initial release */
status = rtems_semaphore_release( Semaphore );
directive_failed( status, "rtems_semaphore_release" );
if ( !extract ) {
status = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT );
directive_failed( status, "rtems_event_transient_receive" );
}
/* now delete the semaphore since no one is waiting and it is unlocked */
status = rtems_semaphore_delete( Semaphore );
directive_failed( status, "rtems_semaphore_delete" );
}
void rtems_test_parallel(
rtems_test_parallel_context *ctx,
rtems_test_parallel_worker_setup worker_setup,
const rtems_test_parallel_job *jobs,
size_t job_count
)
{
rtems_status_code sc;
size_t worker_index;
rtems_task_priority worker_priority;
_Atomic_Init_ulong(&ctx->stop, 0);
_SMP_barrier_Control_initialize(&ctx->barrier);
ctx->worker_count = rtems_get_processor_count();
ctx->worker_ids[0] = rtems_task_self();
if (RTEMS_ARRAY_SIZE(ctx->worker_ids) < ctx->worker_count) {
rtems_fatal_error_occurred(0xdeadbeef);
}
sc = rtems_task_set_priority(
RTEMS_SELF,
RTEMS_CURRENT_PRIORITY,
&worker_priority
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
sc = rtems_timer_create(
rtems_build_name('S', 'T', 'O', 'P'),
&ctx->stop_worker_timer_id
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
for (worker_index = 1; worker_index < ctx->worker_count; ++worker_index) {
worker_arg warg = {
.ctx = ctx,
.jobs = jobs,
.job_count = job_count,
.worker_index = worker_index
};
rtems_id worker_id;
sc = rtems_task_create(
rtems_build_name(
'W',
digit(worker_index, 100),
digit(worker_index, 10),
digit(worker_index, 1)
),
worker_priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&worker_id
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred(0xdeadbeef);
}
ctx->worker_ids[worker_index] = worker_id;
if (worker_setup != NULL) {
(*worker_setup)(ctx, worker_index, worker_id);
}
sc = rtems_task_start(worker_id, worker_task, (rtems_task_argument) &warg);
_Assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
_Assert(sc == RTEMS_SUCCESSFUL);
}
run_tests(ctx, jobs, job_count, 0);
for (worker_index = 1; worker_index < ctx->worker_count; ++worker_index) {
sc = rtems_task_delete(ctx->worker_ids[worker_index]);
_Assert(sc == RTEMS_SUCCESSFUL);
}
sc = rtems_timer_delete(ctx->stop_worker_timer_id);
_Assert(sc == RTEMS_SUCCESSFUL);
}