RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity
Files
c42be504c92d76d2e06d0fc8ebd05fc913376d2d
rtems/testsuites/psxtests/psxconfig01/init.c
Sebastian Huber c42be504c9 posix: Add self-contained pthread spinlock 
Turn pthread_spinlock_t into a self-contained object.  On uni-processor
configurations, interrupts are disabled in the lock/trylock operations
and the previous interrupt status is restored in the corresponding
unlock operations.  On SMP configurations, a ticket lock is a acquired
and released in addition.

The self-contained pthread_spinlock_t object is defined by Newlib in
<sys/_pthreadtypes.h>.

typedef struct {
  struct _Ticket_lock_Control _lock;
  __uint32_t                  _interrupt_state;
} pthread_spinlock_t;

This implementation is simple and efficient.  However, this test case of
the Linux Test Project would fail due to call of printf() and sleep()
during spin lock ownership:

https://github.com/linux-test-project/ltp/blob/master/testcases/open_posix_testsuite/conformance/interfaces/pthread_spin_lock/1-2.c

There is only limited support for profiling on SMP configurations.

Delete CORE spinlock implementation.

Update #2674.
2016-11-23 12:52:06 +01:00

548 lines
15 KiB
C
Raw Blame History

/**
* @file
*
* @ingroup psxtests
*
* @brief Test that the workspace size estimate is correct.
*/
/*
* Copyright (c) 2014. On-Line Applications Research Corporation (OAR).
* Copyright (c) 2011-2014 embedded brains GmbH. All rights reserved.
*
* embedded brains GmbH
* Dornierstr. 4
* 82178 Puchheim
* Germany
* <rtems@embedded-brains.de>
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.org/license/LICENSE.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <rtems/test.h>
#include <tmacros.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <inttypes.h>
#include <mqueue.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <stdio.h>
#include <time.h>
#include <limits.h>
#include <rtems/libcsupport.h>
const char rtems_test_name[] = "PSXCONFIG 1";
#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 5
#define CONFIGURE_MAXIMUM_POSIX_KEYS 23
#ifdef CONFIGURE_MAXIMUM_POSIX_KEYS
#define CONFIGURE_MAXIMUM_POSIX_KEY_VALUE_PAIRS CONFIGURE_MAXIMUM_POSIX_KEYS
#endif
#define CONFIGURE_MAXIMUM_BARRIERS 2
#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 7
#define CONFIGURE_MAXIMUM_PARTITIONS 37
#define CONFIGURE_MAXIMUM_PERIODS 41
#define CONFIGURE_MAXIMUM_REGIONS 43
#define CONFIGURE_MAXIMUM_SEMAPHORES 47
#define CONFIGURE_MAXIMUM_TASKS 11
#define CONFIGURE_MAXIMUM_TIMERS 59
#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 17
#define CONFIGURE_MAXIMUM_POSIX_BARRIERS 31
#define CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES 29
#define POSIX_MQ_COUNT 5
#define CONFIGURE_MAXIMUM_POSIX_MUTEXES 19
#define CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS 7
#define CONFIGURE_MAXIMUM_POSIX_RWLOCKS 31
#define CONFIGURE_MAXIMUM_POSIX_SEMAPHORES 41
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
#define CONFIGURE_MAXIMUM_POSIX_THREADS 3
#define CONFIGURE_MAXIMUM_POSIX_TIMERS 47
#ifndef CONFIGURE_MAXIMUM_TASKS
#define CONFIGURE_MAXIMUM_TASKS 1
#endif
#ifdef CONFIGURE_MAXIMUM_MESSAGE_QUEUES
#define MQ_0_COUNT 2
#define MQ_1_COUNT 3
#define MQ_2_COUNT 5
#define MQ_3_COUNT 7
#define MQ_4_COUNT 11
#define MQ_5_COUNT 13
#define MQ_6_COUNT 17
#define MQ_0_SIZE 101
#define MQ_1_SIZE 103
#define MQ_2_SIZE 107
#define MQ_3_SIZE 109
#define MQ_4_SIZE 113
#define MQ_5_SIZE 127
#define MQ_6_SIZE 131
#define MQ_BUFFER_MEMORY \
(CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_0_COUNT, MQ_0_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_1_COUNT, MQ_1_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_2_COUNT, MQ_2_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_3_COUNT, MQ_3_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_4_COUNT, MQ_4_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_5_COUNT, MQ_5_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MQ_6_COUNT, MQ_6_SIZE))
static const uint8_t mq_counts [CONFIGURE_MAXIMUM_MESSAGE_QUEUES] = {
MQ_0_COUNT,
MQ_1_COUNT,
MQ_2_COUNT,
MQ_3_COUNT,
MQ_4_COUNT,
MQ_5_COUNT,
MQ_6_COUNT
};
static const uint8_t mq_sizes [CONFIGURE_MAXIMUM_MESSAGE_QUEUES] = {
MQ_0_SIZE,
MQ_1_SIZE,
MQ_2_SIZE,
MQ_3_SIZE,
MQ_4_SIZE,
MQ_5_SIZE,
MQ_6_SIZE
};
#else
#define MQ_BUFFER_MEMORY 0
#endif
#ifdef POSIX_MQ_COUNT
#define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES POSIX_MQ_COUNT
#define POSIX_MQ_0_COUNT 2
#define POSIX_MQ_1_COUNT 3
#define POSIX_MQ_2_COUNT 5
#define POSIX_MQ_3_COUNT 7
#define POSIX_MQ_4_COUNT 11
#define POSIX_MQ_0_SIZE 137
#define POSIX_MQ_1_SIZE 139
#define POSIX_MQ_2_SIZE 149
#define POSIX_MQ_3_SIZE 151
#define POSIX_MQ_4_SIZE 157
#define POSIX_MQ_BUFFER_MEMORY \
(CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(POSIX_MQ_0_COUNT, POSIX_MQ_0_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(POSIX_MQ_1_COUNT, POSIX_MQ_1_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(POSIX_MQ_2_COUNT, POSIX_MQ_2_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(POSIX_MQ_3_COUNT, POSIX_MQ_3_SIZE) \
+ CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(POSIX_MQ_4_COUNT, POSIX_MQ_4_SIZE))
static const uint8_t posix_mq_counts [POSIX_MQ_COUNT] = {
POSIX_MQ_0_COUNT,
POSIX_MQ_1_COUNT,
POSIX_MQ_2_COUNT,
POSIX_MQ_3_COUNT,
POSIX_MQ_4_COUNT
};
static const uint8_t posix_mq_sizes [POSIX_MQ_COUNT] = {
POSIX_MQ_0_SIZE,
POSIX_MQ_1_SIZE,
POSIX_MQ_2_SIZE,
POSIX_MQ_3_SIZE,
POSIX_MQ_4_SIZE
};
#else
#define POSIX_MQ_BUFFER_MEMORY 0
#endif
#define CONFIGURE_MESSAGE_BUFFER_MEMORY \
(MQ_BUFFER_MEMORY + POSIX_MQ_BUFFER_MEMORY)
#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
#define CONFIGURE_MAXIMUM_DRIVERS 2
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
#define CONFIGURE_INIT
static rtems_task Init(rtems_task_argument argument);
#include <rtems/confdefs.h>
typedef struct {
uint64_t data [16];
} area;
#ifdef CONFIGURE_MAXIMUM_PARTITIONS
static area partition_areas [CONFIGURE_MAXIMUM_PARTITIONS];
#endif
#ifdef CONFIGURE_MAXIMUM_REGIONS
static area region_areas [CONFIGURE_MAXIMUM_REGIONS];
#endif
static char posix_name [_POSIX_PATH_MAX + 1];
static char *get_posix_name(char a, char b, char c, int i)
{
posix_name [_POSIX_PATH_MAX - 4] = a;
posix_name [_POSIX_PATH_MAX - 3] = b;
posix_name [_POSIX_PATH_MAX - 2] = c;
posix_name [_POSIX_PATH_MAX - 1] = 'A' + i;
return posix_name;
}
static void *posix_thread(void *arg RTEMS_UNUSED)
{
rtems_test_assert(0);
}
static void posix_key_dtor(void *key RTEMS_UNUSED)
{
/* Do nothing */
}
static void print_info(void)
{
Heap_Information_block info;
bool ok = rtems_workspace_get_information(&info);
rtems_test_assert(ok);
printf(
"used blocks = %" PRIu32 ", "
"largest used block = %" PRIu32 ", "
"used space = %" PRIu32 "\n"
"free blocks = %" PRIu32 ", "
"largest free block = %" PRIu32 ", "
"free space = %" PRIu32 "\n",
info.Used.number,
info.Used.largest,
info.Used.total,
info.Free.number,
info.Free.largest,
info.Free.total
);
}
static rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int eno = 0;
int rv = 0;
rtems_id id = RTEMS_ID_NONE;
rtems_name name = rtems_build_name('C', 'O', 'N', 'F');
rtems_extensions_table table;
rtems_resource_snapshot snapshot;
int i = 0;
pthread_key_t key;
TEST_BEGIN();
memset(posix_name, 'P', sizeof(posix_name) - 1);
print_info();
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(rtems_resource_snapshot_equal(&snapshot, &snapshot));
rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
#ifdef CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS
for (i = 3; i < CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS; ++i) {
int oflag = O_WRONLY | O_CREAT | O_TRUNC;
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
char path [] = { 'F', 'I', 'L', 'E', 'A' + i, '\0' };
int fd = open(path, oflag, mode);
rtems_test_assert(fd == i);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.open_files == CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS
);
#endif
#ifdef CONFIGURE_MAXIMUM_USER_EXTENSIONS
memset(&table, 0, sizeof(table));
for (i = 0; i < CONFIGURE_MAXIMUM_USER_EXTENSIONS; ++i) {
sc = rtems_extension_create(name, &table, &id);
directive_failed(sc, "rtems_extension_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_extensions == CONFIGURE_MAXIMUM_USER_EXTENSIONS
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_KEYS
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_KEYS; ++i) {
eno = pthread_key_create(&key, posix_key_dtor);
rtems_test_assert(eno == 0);
eno = pthread_setspecific(key, (void *) (uintptr_t)(i + 1));
rtems_test_assert(eno == 0);
}
eno = pthread_key_create(&key, posix_key_dtor);
rtems_test_assert(eno == EAGAIN);
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.active_posix_keys == CONFIGURE_POSIX_KEYS
);
rtems_test_assert(
snapshot.active_posix_key_value_pairs == CONFIGURE_MAXIMUM_POSIX_KEYS
);
#else
(void) key;
#endif
#ifdef CONFIGURE_MAXIMUM_BARRIERS
for (i = 0; i < CONFIGURE_MAXIMUM_BARRIERS; ++i) {
sc = rtems_barrier_create(name, RTEMS_DEFAULT_ATTRIBUTES, 1, &id);
directive_failed(sc, "rtems_barrier_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_barriers == CONFIGURE_MAXIMUM_BARRIERS
);
#endif
#ifdef CONFIGURE_MAXIMUM_MESSAGE_QUEUES
for (i = 0; i < CONFIGURE_MAXIMUM_MESSAGE_QUEUES; ++i) {
sc = rtems_message_queue_create(
name,
mq_counts [i],
mq_sizes [i],
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed(sc, "rtems_message_queue_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_message_queues
== CONFIGURE_MAXIMUM_MESSAGE_QUEUES
);
#endif
#ifdef CONFIGURE_MAXIMUM_PARTITIONS
for (i = 0; i < CONFIGURE_MAXIMUM_PARTITIONS; ++i) {
sc = rtems_partition_create(
name,
partition_areas + i,
sizeof(partition_areas [0]),
sizeof(partition_areas [0]),
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed(sc, "rtems_partition_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_partitions == CONFIGURE_MAXIMUM_PARTITIONS
);
#endif
#ifdef CONFIGURE_MAXIMUM_PERIODS
for (i = 0; i < CONFIGURE_MAXIMUM_PERIODS; ++i) {
sc = rtems_rate_monotonic_create(name, &id);
directive_failed(sc, "rtems_rate_monotonic_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_periods == CONFIGURE_MAXIMUM_PERIODS
);
#endif
#ifdef CONFIGURE_MAXIMUM_REGIONS
for (i = 0; i < CONFIGURE_MAXIMUM_REGIONS; ++i) {
sc = rtems_region_create(
name,
region_areas + i,
sizeof(region_areas [0]),
1,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed(sc, "rtems_region_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_regions == CONFIGURE_MAXIMUM_REGIONS
);
#endif
#ifdef CONFIGURE_MAXIMUM_SEMAPHORES
for (i = 0; i < CONFIGURE_MAXIMUM_SEMAPHORES; ++i) {
sc = rtems_semaphore_create(
name,
0,
RTEMS_DEFAULT_ATTRIBUTES,
0,
&id
);
directive_failed(sc, "rtems_semaphore_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_semaphores >= CONFIGURE_MAXIMUM_SEMAPHORES
);
#endif
#ifdef CONFIGURE_MAXIMUM_TASKS
for (i = 1; i < CONFIGURE_MAXIMUM_TASKS; ++i) {
sc = rtems_task_create(
name,
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_LOCAL | RTEMS_FLOATING_POINT,
&id
);
directive_failed(sc, "rtems_task_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_tasks == CONFIGURE_MAXIMUM_TASKS
);
#endif
#ifdef CONFIGURE_MAXIMUM_TIMERS
for (i = 0; i < CONFIGURE_MAXIMUM_TIMERS; ++i) {
sc = rtems_timer_create(name, &id);
directive_failed(sc, "rtems_timer_create");
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.rtems_api.active_timers == CONFIGURE_MAXIMUM_TIMERS
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_BARRIERS
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_BARRIERS; ++i) {
pthread_barrier_t barrier;
eno = pthread_barrier_init(&barrier, NULL, 1);
rtems_test_assert(eno == 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_barriers == CONFIGURE_MAXIMUM_POSIX_BARRIERS
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES; ++i) {
pthread_cond_t cond;
eno = pthread_cond_init(&cond, NULL);
rtems_test_assert(eno == 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_condition_variables
== CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES
);
#endif
#ifdef POSIX_MQ_COUNT
for (i = 0; i < POSIX_MQ_COUNT; ++i) {
int oflag = O_RDWR | O_CREAT | O_EXCL;
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
struct mq_attr attr = {
.mq_maxmsg = posix_mq_counts [i],
.mq_msgsize = posix_mq_sizes [i]
};
char *path = get_posix_name('M', 'S', 'Q', i);
mqd_t mq = mq_open(path, oflag, mode, &attr);
rtems_test_assert(mq >= 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_message_queues
== CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_MUTEXES
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_MUTEXES; ++i) {
pthread_mutex_t mutex;
eno = pthread_mutex_init(&mutex, NULL);
rtems_test_assert(eno == 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_mutexes == CONFIGURE_MAXIMUM_POSIX_MUTEXES
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_RWLOCKS
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_RWLOCKS; ++i) {
pthread_rwlock_t rwlock;
eno = pthread_rwlock_init(&rwlock, NULL);
rtems_test_assert(eno == 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_rwlocks == CONFIGURE_MAXIMUM_POSIX_RWLOCKS
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_SEMAPHORES
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_SEMAPHORES; ++i) {
int oflag = O_RDWR | O_CREAT | O_EXCL;
mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
unsigned int value = 0;
char *path = get_posix_name('S', 'E', 'M', i);
sem_t *sem = sem_open(path, oflag, mode, value);
rtems_test_assert(sem != SEM_FAILED);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_semaphores == CONFIGURE_MAXIMUM_POSIX_SEMAPHORES
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_THREADS
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_THREADS; ++i) {
pthread_t thread;
eno = pthread_create(&thread, NULL, posix_thread, NULL);
rtems_test_assert(eno == 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_threads == CONFIGURE_MAXIMUM_POSIX_THREADS
);
#endif
#ifdef CONFIGURE_MAXIMUM_POSIX_TIMERS
for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_TIMERS; ++i) {
timer_t timer_id;
rv = timer_create(CLOCK_REALTIME, NULL, &timer_id);
rtems_test_assert(rv == 0);
}
rtems_resource_snapshot_take(&snapshot);
rtems_test_assert(
snapshot.posix_api.active_timers == CONFIGURE_MAXIMUM_POSIX_TIMERS
);
#endif
printf("object creation done\n");
print_info();
TEST_END();
rtems_test_exit(0);
}
View Git Blame Copy Permalink