threadqimpl.h

Go to the documentation of this file.

/*
 *  COPYRIGHT (c) 1989-2014.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  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.
 */

#ifndef _RTEMS_SCORE_THREADQIMPL_H
#define _RTEMS_SCORE_THREADQIMPL_H

#include <rtems/score/threadq.h>
#include <rtems/score/chainimpl.h>
#include <rtems/score/rbtreeimpl.h>
#include <rtems/score/thread.h>

#ifdef __cplusplus
extern "C" {
#endif

RTEMS_INLINE_ROUTINE void _Thread_queue_Acquire_critical(
  Thread_queue_Control *the_thread_queue,
  ISR_lock_Context     *lock_context
)
{
  _ISR_lock_Acquire( &the_thread_queue->Lock, lock_context );
}

RTEMS_INLINE_ROUTINE void _Thread_queue_Acquire(
  Thread_queue_Control *the_thread_queue,
  ISR_lock_Context     *lock_context
)
{
  _ISR_lock_ISR_disable( lock_context );
  _Thread_queue_Acquire_critical( the_thread_queue, lock_context );
}

RTEMS_INLINE_ROUTINE void _Thread_queue_Release(
  Thread_queue_Control *the_thread_queue,
  ISR_lock_Context     *lock_context
)
{
  _ISR_lock_Release_and_ISR_enable( &the_thread_queue->Lock, lock_context );
}

typedef void ( *Thread_queue_Flush_callout )(
                  Thread_Control *
             );

Thread_Control *_Thread_queue_Dequeue(
  Thread_queue_Control *the_thread_queue
);

void _Thread_queue_Enqueue_critical(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  States_Control        state,
  Watchdog_Interval     timeout,
  uint32_t              timeout_code,
  ISR_lock_Context     *lock_context
);

RTEMS_INLINE_ROUTINE void _Thread_queue_Enqueue(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  States_Control        state,
  Watchdog_Interval     timeout,
  uint32_t              timeout_code
)
{
  ISR_lock_Context lock_context;

  _Thread_queue_Acquire( the_thread_queue, &lock_context );
  _Thread_queue_Enqueue_critical(
    the_thread_queue,
    the_thread,
    state,
    timeout,
    timeout_code,
    &lock_context
  );
}

void _Thread_queue_Extract_locked(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
);

void _Thread_queue_Unblock_critical(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_lock_Context     *lock_context
);

void _Thread_queue_Extract_critical(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_lock_Context     *lock_context
);

void _Thread_queue_Extract( Thread_Control *the_thread );

void _Thread_queue_Extract_with_proxy(
  Thread_Control       *the_thread
);

RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked(
  Thread_queue_Control *the_thread_queue
)
{
  return ( *the_thread_queue->operations->first )( the_thread_queue );
}

Thread_Control *_Thread_queue_First(
  Thread_queue_Control *the_thread_queue
);

void _Thread_queue_Flush(
  Thread_queue_Control       *the_thread_queue,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
);

void _Thread_queue_Initialize(
  Thread_queue_Control     *the_thread_queue,
  Thread_queue_Disciplines  the_discipline
);

#if defined(RTEMS_SMP)
  #define THREAD_QUEUE_FIFO_INITIALIZER( designator, name ) { \
      .Queues = { \
        .Fifo = CHAIN_INITIALIZER_EMPTY( designator.Queues.Fifo ) \
      }, \
      .operations = &_Thread_queue_Operations_FIFO, \
      .Lock = ISR_LOCK_INITIALIZER( name ) \
    }

  #define THREAD_QUEUE_PRIORITY_INITIALIZER( designator, name ) { \
      .Queues = { \
        .Priority = RBTREE_INITIALIZER_EMPTY( designator.Queues.Priority ) \
      }, \
      .operations = &_Thread_queue_Operations_priority, \
      .Lock = ISR_LOCK_INITIALIZER( name ) \
    }
#else
  #define THREAD_QUEUE_FIFO_INITIALIZER( designator, name ) { \
      .Queues = { \
        .Fifo = CHAIN_INITIALIZER_EMPTY( designator.Queues.Fifo ) \
      }, \
      .operations = &_Thread_queue_Operations_FIFO \
    }

  #define THREAD_QUEUE_PRIORITY_INITIALIZER( designator, name ) { \
      .Queues = { \
        .Priority = RBTREE_INITIALIZER_EMPTY( designator.Queues.Priority ) \
      }, \
      .operations = &_Thread_queue_Operations_priority \
    }
#endif

RTEMS_INLINE_ROUTINE void _Thread_queue_Destroy(
  Thread_queue_Control *the_thread_queue
)
{
  _ISR_lock_Destroy( &the_thread_queue->Lock );
}

RBTree_Compare_result _Thread_queue_Compare_priority(
  const RBTree_Node *left,
  const RBTree_Node *right
);

extern const Thread_queue_Operations _Thread_queue_Operations_default;

extern const Thread_queue_Operations _Thread_queue_Operations_FIFO;

extern const Thread_queue_Operations _Thread_queue_Operations_priority;

#ifdef __cplusplus
}
#endif

#endif
/* end of include file */