RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

score: Delete Thread_Wait_information::id

Browse Source 
This field was only by the monitor in non-multiprocessing
configurations.  Add new field Thread_Wait_information::remote_id in
multiprocessing configurations and use it for the remote procedure call
thread queue.

Add _Thread_Wait_get_id() to obtain the object identifier for debug and
system information tools.  Ensure the object layout via static asserts.
Add test cases to sptests/spthreadq01.
This commit is contained in:
Sebastian Huber
2016-04-05 14:36:30 +02:00
parent d2c8693e15
commit 97312fcc6d
34 changed files with 561 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
cpukit/libmisc/monitor/mon-task.c
View File

@@ -14,26 +14,46 @@
#include <stdio.h>
#include <string.h> /* memcpy() */
static void
rtems_monitor_task_wait_info(
rtems_monitor_task_t *canonical_task,
Thread_Control *rtems_thread
)
{
ISR_lock_Context lock_context;
void *lock;
lock = _Thread_Lock_acquire( rtems_thread, &lock_context );
canonical_task->state = rtems_thread->current_state;
canonical_task->wait_id = _Thread_Wait_get_id( rtems_thread );
canonical_task->wait_queue = rtems_thread->Wait.queue;
canonical_task->wait_operations = rtems_thread->Wait.operations;
_Thread_Lock_release( lock, &lock_context );
}
void
rtems_monitor_task_canonical(
rtems_monitor_task_t *canonical_task,
const void *thread_void
)
{
const Thread_Control *rtems_thread = (const Thread_Control *) thread_void;
Thread_Control *rtems_thread;
RTEMS_API_Control *api;
rtems_thread =
RTEMS_DECONST( Thread_Control *, (const Thread_Control *) thread_void );
api = rtems_thread->API_Extensions[ THREAD_API_RTEMS ];
rtems_monitor_task_wait_info( canonical_task, rtems_thread );
canonical_task->entry = rtems_thread->Start.Entry;
canonical_task->stack = rtems_thread->Start.Initial_stack.area;
canonical_task->stack_size = rtems_thread->Start.Initial_stack.size;
canonical_task->cpu = _Per_CPU_Get_index( _Thread_Get_CPU( rtems_thread ) );
canonical_task->priority = rtems_thread->current_priority;
canonical_task->state = rtems_thread->current_state;
canonical_task->wait_id = rtems_thread->Wait.id;
canonical_task->wait_queue = rtems_thread->Wait.queue;
canonical_task->wait_operations = rtems_thread->Wait.operations;
canonical_task->events = api->Event.pending_events;
/*
* FIXME: make this optionally cpu_time_executed

2
cpukit/posix/include/rtems/posix/cond.h
View File

@@ -42,9 +42,9 @@ extern "C" {
typedef struct {
Objects_Control Object;
Thread_queue_Control Wait_queue;
int process_shared;
pthread_mutex_t Mutex;
Thread_queue_Control Wait_queue;
} POSIX_Condition_variables_Control;
#ifdef __cplusplus

2
cpukit/posix/include/rtems/posix/mqueue.h
View File

@@ -54,11 +54,11 @@ extern "C" {
typedef struct {
Objects_Control Object;
CORE_message_queue_Control Message_queue;
int process_shared;
bool named;
bool linked;
uint32_t open_count;
CORE_message_queue_Control Message_queue;
struct sigevent notification;
} POSIX_Message_queue_Control;

2
cpukit/posix/include/rtems/posix/mutex.h
View File

@@ -42,8 +42,8 @@ extern "C" {
typedef struct {
Objects_Control Object;
int process_shared;
CORE_mutex_Control Mutex;
int process_shared;
} POSIX_Mutex_Control;
/** @} */

2
cpukit/posix/include/rtems/posix/semaphore.h
View File

@@ -42,11 +42,11 @@ extern "C" {
typedef struct {
Objects_Control Object;
CORE_semaphore_Control Semaphore;
int process_shared;
bool named;
bool linked;
uint32_t open_count;
CORE_semaphore_Control Semaphore;
/*
* sem_t is 32-bit. If Object_Id is 16-bit, then they are not
* interchangeable. We have to be able to return a pointer to

7
cpukit/posix/src/condwaitsupp.c
View File

@@ -24,9 +24,15 @@
#include <rtems/system.h>
#include <rtems/score/watchdog.h>
#include <rtems/score/statesimpl.h>
#include <rtems/score/threadimpl.h>
#include <rtems/posix/condimpl.h>
#include <rtems/posix/muteximpl.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT(
POSIX_Condition_variables_Control,
Wait_queue
);
int _POSIX_Condition_variables_Wait_support(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
@@ -75,7 +81,6 @@ int _POSIX_Condition_variables_Wait_support(
executing = _Thread_Executing;
executing->Wait.return_code = 0;
executing->Wait.id = *cond;
_Thread_queue_Enqueue(
&the_cond->Wait_queue,

6
cpukit/posix/src/mqueuerecvsupp.c
View File

@@ -28,9 +28,15 @@
#include <rtems/system.h>
#include <rtems/score/watchdog.h>
#include <rtems/score/threadimpl.h>
#include <rtems/seterr.h>
#include <rtems/posix/mqueueimpl.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT(
POSIX_Message_queue_Control,
Message_queue.Wait_queue
);
/*
* _POSIX_Message_queue_Receive_support
*

3
cpukit/posix/src/mutexlocksupp.c
View File

@@ -24,9 +24,12 @@
#include <rtems/system.h>
#include <rtems/score/coremuteximpl.h>
#include <rtems/score/watchdog.h>
#include <rtems/score/threadimpl.h>
#include <rtems/posix/muteximpl.h>
#include <rtems/posix/priorityimpl.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT( POSIX_Mutex_Control, Mutex.Wait_queue );
/*
* _POSIX_Mutex_Lock_support
*

4
cpukit/posix/src/pbarrierwait.c
View File

@@ -22,7 +22,9 @@
#include <errno.h>
#include <rtems/posix/barrierimpl.h>
#include <rtems/score/thread.h>
#include <rtems/score/threadimpl.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT( POSIX_Barrier_Control, Barrier.Wait_queue );
/**
* This directive allows a thread to wait at a barrier.

4
cpukit/posix/src/prwlockwrlock.c
View File

@@ -24,7 +24,9 @@
#include <errno.h>
#include <rtems/posix/rwlockimpl.h>
#include <rtems/score/thread.h>
#include <rtems/score/threadimpl.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT( POSIX_RWLock_Control, RWLock.Wait_queue );
/*
* pthread_rwlock_wrlock

6
cpukit/posix/src/semaphorewaitsupp.c
View File

@@ -27,9 +27,15 @@
#include <limits.h>
#include <rtems/system.h>
#include <rtems/score/threadimpl.h>
#include <rtems/posix/semaphoreimpl.h>
#include <rtems/seterr.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT(
POSIX_Semaphore_Control,
Semaphore.Wait_queue
);
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,

4
cpukit/rtems/include/rtems/rtems/barrier.h
View File

@@ -55,10 +55,10 @@ extern "C" {
typedef struct {
/** This is used to manage a barrier as an object. */
Objects_Control Object;
/** This is used to specify the attributes of a barrier. */
rtems_attribute attribute_set;
/** This is used to implement the barrier. */
CORE_barrier_Control Barrier;
/** This is used to specify the attributes of a barrier. */
rtems_attribute attribute_set;
} Barrier_Control;
/**

4
cpukit/rtems/include/rtems/rtems/message.h
View File

@@ -53,10 +53,10 @@ extern "C" {
typedef struct {
/** This field is the inherited object characteristics. */
Objects_Control Object;
/** This field is the attribute set as defined by the API. */
rtems_attribute attribute_set;
/** This field is the instance of the SuperCore Message Queue. */
CORE_message_queue_Control message_queue;
/** This field is the attribute set as defined by the API. */
rtems_attribute attribute_set;
} Message_queue_Control;
/**

14
cpukit/rtems/include/rtems/rtems/sem.h
View File

@@ -64,13 +64,6 @@ typedef struct {
/** This field is the object management portion of a Semaphore instance. */
Objects_Control Object;
/**
* This is the Classic API attribute provided to the create directive.
* It is translated into behavioral attributes on the SuperCore Semaphore
* or Mutex instance.
*/
rtems_attribute attribute_set;
/**
* This contains the memory associated with the SuperCore Semaphore or
* Mutex instance that provides the primary functionality of each
@@ -97,6 +90,13 @@ typedef struct {
MRSP_Control mrsp;
#endif
} Core_control;
/**
* This is the Classic API attribute provided to the create directive.
* It is translated into behavioral attributes on the SuperCore Semaphore
* or Mutex instance.
*/
rtems_attribute attribute_set;
} Semaphore_Control;
/**

4
cpukit/rtems/src/barrierwait.c
View File

@@ -22,7 +22,9 @@
#include <rtems/rtems/status.h>
#include <rtems/rtems/support.h>
#include <rtems/rtems/barrierimpl.h>
#include <rtems/score/thread.h>
#include <rtems/score/threadimpl.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT( Barrier_Control, Barrier.Wait_queue );
rtems_status_code rtems_barrier_wait(
rtems_id id,

7
cpukit/rtems/src/msgqreceive.c
View File

@@ -22,7 +22,7 @@
#include <rtems/score/chain.h>
#include <rtems/score/isr.h>
#include <rtems/score/coremsgimpl.h>
#include <rtems/score/thread.h>
#include <rtems/score/threadimpl.h>
#include <rtems/score/wkspace.h>
#include <rtems/rtems/status.h>
#include <rtems/rtems/attrimpl.h>
@@ -30,6 +30,11 @@
#include <rtems/rtems/optionsimpl.h>
#include <rtems/rtems/support.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT(
Message_queue_Control,
message_queue.Wait_queue
);
rtems_status_code rtems_message_queue_receive(
rtems_id id,
void *buffer,

1
cpukit/rtems/src/regiongetsegment.c
View File

@@ -75,7 +75,6 @@ rtems_status_code rtems_region_get_segment(
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
executing->Wait.id = id;
executing->Wait.count = size;
executing->Wait.return_argument = segment;

12
cpukit/rtems/src/semobtain.c
View File

@@ -27,10 +27,20 @@
#include <rtems/rtems/semimpl.h>
#include <rtems/score/coremuteximpl.h>
#include <rtems/score/coresemimpl.h>
#include <rtems/score/thread.h>
#include <rtems/score/threadimpl.h>
#include <rtems/score/interr.h>
THREAD_WAIT_QUEUE_OBJECT_ASSERT(
Semaphore_Control,
Core_control.mutex.Wait_queue
);
THREAD_WAIT_QUEUE_OBJECT_ASSERT(
Semaphore_Control,
Core_control.semaphore.Wait_queue
);
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,

1
cpukit/score/Makefile.am
View File

@@ -308,6 +308,7 @@ libscore_a_SOURCES += src/threadentryadaptorpointer.c
libscore_a_SOURCES += src/threadgetcputimeused.c
libscore_a_SOURCES += src/threadglobalconstruction.c
libscore_a_SOURCES += src/threadtimeout.c
libscore_a_SOURCES += src/threadwaitgetid.c
libscore_a_SOURCES += src/threadyield.c
if HAS_SMP

1
cpukit/score/include/rtems/score/coremuteximpl.h
View File

@@ -265,7 +265,6 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize_body(
executing->Wait.return_code =
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT;
} else {
executing->Wait.id = id;
_CORE_mutex_Seize_interrupt_blocking(
the_mutex,
executing,

1
cpukit/score/include/rtems/score/coresemimpl.h
View File

@@ -251,7 +251,6 @@ RTEMS_INLINE_ROUTINE void _CORE_semaphore_Seize(
return;
}
executing->Wait.id = id;
_Thread_queue_Enqueue_critical(
&the_semaphore->Wait_queue.Queue,
the_semaphore->operations,

9
cpukit/score/include/rtems/score/thread.h
View File

@@ -291,8 +291,13 @@ typedef struct {
RBTree_Node RBTree;
} Node;
/** This field is the Id of the object this thread is waiting upon. */
Objects_Id id;
#if defined(RTEMS_MULTIPROCESSING)
/*
* @brief This field is the identifier of the remote object this thread is
* waiting upon.
*/
Objects_Id remote_id;
#endif
/** This field is used to return an integer while when blocked. */
uint32_t count;
/** This field is for a pointer to a user return argument. */

36
cpukit/score/include/rtems/score/threadimpl.h
View File

@@ -1448,6 +1448,42 @@ RTEMS_INLINE_ROUTINE void _Thread_Wait_set_timeout_code(
the_thread->Wait.timeout_code = timeout_code;
}
/**
* @brief Helper structure to ensure that all objects containing a thread queue
* have the right layout.
*
* @see _Thread_Wait_get_id() and THREAD_WAIT_QUEUE_OBJECT_ASSERT().
*/
typedef struct {
Objects_Control Object;
Thread_queue_Control Wait_queue;
} Thread_Wait_queue_object;
#define THREAD_WAIT_QUEUE_OBJECT_ASSERT( object_type, wait_queue_member ) \
RTEMS_STATIC_ASSERT( \
offsetof( object_type, wait_queue_member ) \
== offsetof( Thread_Wait_queue_object, Wait_queue ) \
&& ( &( ( (object_type *) 0 )->wait_queue_member ) \
== ( &( (Thread_Wait_queue_object *) 0 )->Wait_queue ) ), \
object_type \
)
/**
* @brief Returns the object identifier of the object containing the current
* thread wait queue.
*
* This function may be used for debug and system information purposes. The
* caller must be the owner of the thread lock.
*
* @retval 0 The thread waits on no thread queue currently, the thread wait
* queue is not contained in an object, or the current thread state provides
* insufficient information, e.g. the thread is in the middle of a blocking
* operation.
* @retval other The object identifier of the object containing the thread wait
* queue.
*/
Objects_Id _Thread_Wait_get_id( const Thread_Control *the_thread );
/**
* @brief General purpose thread wait timeout.
*

2
cpukit/score/src/corebarrierwait.c
View File

@@ -47,8 +47,6 @@ void _CORE_barrier_Wait(
}
}
executing->Wait.id = id;
_Thread_queue_Enqueue_critical(
&the_barrier->Wait_queue.Queue,
CORE_BARRIER_TQ_OPERATIONS,

1
cpukit/score/src/coremsgseize.c
View File

@@ -127,7 +127,6 @@ void _CORE_message_queue_Seize(
return;
}
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */

1
cpukit/score/src/coremsgsubmit.c
View File

@@ -126,7 +126,6 @@ CORE_message_queue_Status _CORE_message_queue_Submit(
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
executing->Wait.id = id;
executing->Wait.return_argument_second.immutable_object = buffer;
executing->Wait.option = (uint32_t) size;
executing->Wait.count = submit_type;

1
cpukit/score/src/corerwlockobtainread.c
View File

@@ -81,7 +81,6 @@ void _CORE_RWLock_Obtain_for_reading(
* We need to wait to enter this critical section
*/
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;

1
cpukit/score/src/corerwlockobtainwrite.c
View File

@@ -68,7 +68,6 @@ void _CORE_RWLock_Obtain_for_writing(
* We need to wait to enter this critical section
*/
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;

2
cpukit/score/src/mpci.c
View File

@@ -242,7 +242,7 @@ uint32_t _MPCI_Send_request_packet (
the_packet->to_convert =
( the_packet->to_convert - sizeof(MP_packet_Prefix) ) / sizeof(uint32_t);
executing->Wait.id = the_packet->id;
executing->Wait.remote_id = the_packet->id;
(*_MPCI_table->send_packet)( destination, the_packet );

1
cpukit/score/src/threadmp.c
View File

@@ -95,7 +95,6 @@ Thread_Control *_Thread_MP_Allocate_proxy (
the_proxy->current_state = _States_Set( STATES_DORMANT, the_state );
the_proxy->Wait.id = executing->Wait.id;
the_proxy->Wait.count = executing->Wait.count;
the_proxy->Wait.return_argument = executing->Wait.return_argument;
the_proxy->Wait.return_argument_second = executing->Wait.return_argument_second;

2
cpukit/score/src/threadqextractwithproxy.c
View File

@@ -41,7 +41,7 @@ void _Thread_queue_Extract_with_proxy(
Objects_Information *the_information;
Objects_Thread_queue_Extract_callout proxy_extract_callout;
id = the_thread->Wait.id;
id = the_thread->Wait.remote_id;
the_information = _Objects_Get_information_id( id );
proxy_extract_callout = the_information->extract;

54
cpukit/score/src/threadwaitgetid.c Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright (c) 2016 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.
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include <rtems/score/threadimpl.h>
#define THREAD_WAIT_QUEUE_OBJECT_STATES \
( STATES_WAITING_FOR_BARRIER \
| STATES_WAITING_FOR_CONDITION_VARIABLE \
| STATES_WAITING_FOR_MESSAGE \
| STATES_WAITING_FOR_MUTEX \
| STATES_WAITING_FOR_RWLOCK \
| STATES_WAITING_FOR_SEMAPHORE )
Objects_Id _Thread_Wait_get_id( const Thread_Control *the_thread )
{
States_Control current_state;
current_state = the_thread->current_state;
#if defined(RTEMS_MULTIPROCESSING)
if ( ( current_state & STATES_WAITING_FOR_RPC_REPLY ) != 0 ) {
return the_thread->Wait.remote_id;
}
#endif
if ( ( current_state & THREAD_WAIT_QUEUE_OBJECT_STATES ) != 0 ) {
const Thread_Wait_queue_object *queue_object;
queue_object = RTEMS_CONTAINER_OF(
the_thread->Wait.queue,
Thread_Wait_queue_object,
Wait_queue.Queue
);
return queue_object->Object.id;
}
return 0;
}

367
testsuites/sptests/spthreadq01/init.c
View File

@@ -2,6 +2,8 @@
* COPYRIGHT (c) 1989-2009.
* On-Line Applications Research Corporation (OAR).
*
* Copyright (c) 2016 embedded brains GmbH.
*
* 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.
@@ -13,17 +15,354 @@
#include <tmacros.h>
#include <sys/types.h>
#include <rtems/score/threadqimpl.h>
#include <rtems.h>
#include <rtems/score/threadimpl.h>
#if defined(RTEMS_POSIX_API)
#include <fcntl.h>
#include <mqueue.h>
#include <semaphore.h>
#include <string.h>
#include <pthread.h>
#include <rtems/posix/mqueueimpl.h>
#endif
const char rtems_test_name[] = "SPTHREADQ 1";
static Thread_queue_Control queue = THREAD_QUEUE_INITIALIZER( "Queue" );
typedef struct {
Thread_Control *master;
rtems_id master_id;
rtems_id worker_id;
rtems_id sem;
rtems_id mtx;
rtems_id mq;
rtems_id br;
#if defined(RTEMS_POSIX_API)
sem_t psem;
pthread_mutex_t pmtx;
pthread_cond_t pcv;
pthread_rwlock_t prw;
mqd_t pmq;
#endif
} test_context;
static test_context test_instance;
static void wait_for_worker(test_context *ctx)
{
rtems_status_code sc;
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void wake_up_master(test_context *ctx)
{
rtems_status_code sc;
sc = rtems_event_transient_send(ctx->master_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static rtems_id get_wait_id(test_context *ctx)
{
ISR_lock_Context lock_context;
void *lock;
rtems_id id;
lock = _Thread_Lock_acquire(ctx->master, &lock_context);
id = _Thread_Wait_get_id(ctx->master);
_Thread_Lock_release(lock, &lock_context);
return id;
}
static void classic_worker(test_context *ctx)
{
rtems_status_code sc;
char buf[1];
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->sem);
sc = rtems_semaphore_release(ctx->sem);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->mtx);
sc = rtems_semaphore_release(ctx->mtx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->mq);
buf[0] = 'X';
sc = rtems_message_queue_send(ctx->mq, &buf[0], sizeof(buf));
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->br);
sc = rtems_barrier_wait(ctx->br, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void posix_worker(test_context *ctx)
{
#if defined(RTEMS_POSIX_API)
int rv;
int eno;
char buf[1];
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
ISR_lock_Context lock_context;
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->psem);
rv = sem_post(&ctx->psem);
rtems_test_assert(rv == 0);
eno = pthread_mutex_lock(&ctx->pmtx);
rtems_test_assert(eno == 0);
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->pmtx);
eno = pthread_mutex_unlock(&ctx->pmtx);
rtems_test_assert(eno == 0);
eno = pthread_mutex_lock(&ctx->pmtx);
rtems_test_assert(eno == 0);
rtems_test_assert(get_wait_id(ctx) == ctx->pcv);
eno = pthread_cond_signal(&ctx->pcv);
rtems_test_assert(eno == 0);
eno = pthread_mutex_unlock(&ctx->pmtx);
rtems_test_assert(eno == 0);
eno = pthread_rwlock_wrlock(&ctx->prw);
rtems_test_assert(eno == 0);
wake_up_master(ctx);
rtems_test_assert(get_wait_id(ctx) == ctx->prw);
eno = pthread_rwlock_unlock(&ctx->prw);
rtems_test_assert(eno == 0);
wake_up_master(ctx);
the_mq_fd = _POSIX_Message_queue_Get_fd_interrupt_disable(
ctx->pmq,
&location,
&lock_context
);
_ISR_lock_ISR_enable(&lock_context);
rtems_test_assert(the_mq_fd != NULL);
rtems_test_assert(location == OBJECTS_LOCAL);
rtems_test_assert(get_wait_id(ctx) == the_mq_fd->Queue->Object.id);
buf[0] = 'x';
rv = mq_send(ctx->pmq, &buf[0], sizeof(buf), 0);
rtems_test_assert(rv == 0);
#endif
}
static rtems_task worker(rtems_task_argument arg)
{
test_context *ctx = (test_context *) arg;
rtems_test_assert(get_wait_id(ctx) == 0);
classic_worker(ctx);
posix_worker(ctx);
}
static void test_classic_init(test_context *ctx)
{
rtems_status_code sc;
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', ' '),
0,
RTEMS_COUNTING_SEMAPHORE,
0,
&ctx->sem
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('M', 'T', 'X', ' '),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
0,
&ctx->mtx
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_message_queue_create(
rtems_build_name('M', 'Q', ' ', ' '),
1,
1,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->mq
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_barrier_create(
rtems_build_name('B', 'R', ' ', ' '),
RTEMS_BARRIER_AUTOMATIC_RELEASE,
2,
&ctx->br
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void test_posix_init(test_context *ctx)
{
#if defined(RTEMS_POSIX_API)
int rv;
int eno;
struct mq_attr attr;
rv = sem_init(&ctx->psem, 0, 0);
rtems_test_assert(rv == 0);
eno = pthread_mutex_init(&ctx->pmtx, NULL);
rtems_test_assert(eno == 0);
eno = pthread_cond_init(&ctx->pcv, NULL);
rtems_test_assert(eno == 0);
eno = pthread_rwlock_init(&ctx->prw, NULL);
rtems_test_assert(eno == 0);
memset(&attr, 0, sizeof(attr));
attr.mq_maxmsg = 1;
attr.mq_msgsize = sizeof(char);
ctx->pmq = mq_open("mq", O_CREAT | O_RDWR, 0x777, &attr);
rtems_test_assert(ctx->mq != -1);
#endif
}
static void test_context_init(test_context *ctx)
{
rtems_status_code sc;
ctx->master = _Thread_Get_executing();
ctx->master_id = rtems_task_self();
test_classic_init(ctx);
test_posix_init(ctx);
sc = rtems_task_create(
rtems_build_name('W', 'O', 'R', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->worker_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->worker_id, worker, (rtems_task_argument) ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void test_classic_obj(test_context *ctx)
{
rtems_status_code sc;
char buf[1];
size_t n;
wait_for_worker(ctx);
sc = rtems_semaphore_obtain(ctx->sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wait_for_worker(ctx);
sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
wait_for_worker(ctx);
buf[0] = 'Y';
n = 123;
sc = rtems_message_queue_receive(
ctx->mq,
&buf[0],
&n,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(buf[0] == 'X');
rtems_test_assert(n == sizeof(buf));
wait_for_worker(ctx);
sc = rtems_barrier_wait(ctx->br, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void test_posix_obj(test_context *ctx)
{
#if defined(RTEMS_POSIX_API)
int rv;
int eno;
char buf[1];
unsigned prio;
ssize_t n;
wait_for_worker(ctx);
rv = sem_wait(&ctx->psem);
rtems_test_assert(rv == 0);
wait_for_worker(ctx);
eno = pthread_mutex_lock(&ctx->pmtx);
rtems_test_assert(eno == 0);
eno = pthread_cond_wait(&ctx->pcv, &ctx->pmtx);
rtems_test_assert(eno == 0);
eno = pthread_mutex_unlock(&ctx->pmtx);
rtems_test_assert(eno == 0);
wait_for_worker(ctx);
eno = pthread_rwlock_wrlock(&ctx->prw);
rtems_test_assert(eno == 0);
wait_for_worker(ctx);
buf[0] = 'y';
prio = 1;
n = mq_receive(ctx->pmq, &buf[0], sizeof(buf), &prio);
rtems_test_assert(n == (ssize_t) sizeof(buf));
rtems_test_assert(buf[0] == 'x');
rtems_test_assert(prio == 0);
#endif
}
static rtems_task Init(
rtems_task_argument ignored
)
{
test_context *ctx = &test_instance;
TEST_BEGIN();
puts( "Init - _Thread_queue_Extract - thread not blocked on a thread queue" );
@@ -32,6 +371,10 @@ static rtems_task Init(
_Thread_Enable_dispatch();
/* is there more to check? */
test_context_init(ctx);
test_classic_obj(ctx);
test_posix_obj(ctx);
rtems_test_assert( queue.Queue.heads == NULL );
TEST_END();
@@ -43,7 +386,25 @@ static rtems_task Init(
#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER
#define CONFIGURE_MAXIMUM_TASKS 1
#define CONFIGURE_MAXIMUM_TASKS 2
#define CONFIGURE_MAXIMUM_SEMAPHORES 2
#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 1
#define CONFIGURE_MAXIMUM_BARRIERS 1
#if defined(RTEMS_POSIX_API)
#define CONFIGURE_MAXIMUM_POSIX_SEMAPHORES 1
#define CONFIGURE_MAXIMUM_POSIX_MUTEXES 1
#define CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES 1
#define CONFIGURE_MAXIMUM_POSIX_RWLOCKS 1
#define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES 1
#define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUE_DESCRIPTORS 1
#define CONFIGURE_MESSAGE_BUFFER_MEMORY \
(2 * CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(1, 1))
#else
#define CONFIGURE_MESSAGE_BUFFER_MEMORY \
CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(1, 1)
#endif
#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
#define CONFIGURE_RTEMS_INIT_TASKS_TABLE

10
testsuites/sptests/spthreadq01/spthreadq01.doc
View File

@@ -12,9 +12,15 @@ test set name: spthreadq01
directives:
_Threadq_Extract
- THREAD_QUEUE_INITIALIZER()
- _Thread_queue_Extract()
- _Thread_Wait_get_id()
concepts:
+ Ensure that when an attempt is made to extract a thread which is not blocked
- Ensure that the thread queue initializer correctly initializes the thread
queue.
- Ensure that when an attempt is made to extract a thread which is not blocked
on a thread queue, that the behavior is as expected.
- Ensure that _Thread_Wait_get_id() returns the right object identifier for
various high-level objects.