sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
c42c9f4aef
nuttx/sched/os_internal.h
patacongo b08a86171f NuttX RTOS 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@3 42af7a65-404d-4744-a932-0658087f49c3
2007-02-17 23:21:28 +00:00

268 lines
9.6 KiB
C
Raw Blame History

/************************************************************
* os_internal.h
*
* Copyright (C) 2007 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name Gregory Nutt nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
************************************************************/
#ifndef __OS_INTERNAL_H
#define __OS_INTERNAL_H
/************************************************************
* Included Files
************************************************************/
#include <queue.h>
#include <sched.h>
#include <nuttx/kmalloc.h>
#include <nuttx/os_external.h>
/************************************************************
* Definitions
************************************************************/
/* OS CRASH CODES */
enum os_crash_codes_e
{
OSERR_NOERROR = 0, /* No error */
OSERR_NOTIMPLEMENTED, /* Feature is not implemented */
OSERR_INTERNAL, /* Internal logic error */
OSERR_UNEXPECTEDISR, /* Received unexpected interrupt */
OSERR_UNDEFINEDINSN, /* Undefined instruction */
OSERR_ERREXCEPTION, /* Other CPU-detected errors */
OSERR_OUTOFMEMORY, /* Insufficient memory */
OSERR_OUTOFMESSAGES, /* Out of messages */
OSERR_NOIDLETASK, /* There is no idle task */
OSERR_MQNONEMPTYCOUNT, /* Expected waiter for non-empty queue */
OSERR_MQNOTFULLCOUNT, /* Expected waiter for non-full queue */
OSERR_BADWAITSEM, /* Already waiting for a semaphore */
OSERR_BADMSGTYPE, /* Tried to free a bad message type */
OSERR_FAILEDTOADDSIGNAL, /* Failed to add pending signal */
OSERR_FAILEDTOREMOVESIGNAL, /* Failed to remove pending signal */
OSERR_TIMEOUTNOTCB, /* Timed out, but not TCB registered */
OSERR_NOPENDINGSIGNAL, /* Expected a signal to be pending */
OSERR_BADDELETESTATE, /* Bad state in task deletion */
OSERR_WDOGNOTFOUND, /* Active watchdog not found */
OSERR_EXITFROMINTERRUPT, /* Interrupt code attempted to exit */
OSERR_BADUNBLOCKSTATE, /* Attempt to unblock from bad state */
OSERR_BADBLOCKSTATE, /* Attempt to block from bad state */
OSERR_BADREPRIORITIZESTATE, /* Attempt to reprioritize in bad state or priority */
};
/* Special task IDS */
#define NULL_TASK_PROCESS_ID 0
#define INVALID_PROCESS_ID 0
/* Although task IDs can take the (positive, non-zero)
* range of pid_t, the number of tasks that will be supported
* at any one time is (artificially) limited by the following
* definition. Limiting the number of tasks speeds certain
* OS functions (this is the only limitation in the number of
* tasks built into the design).
*/
#define MAX_TASKS_ALLOWED 64
#define MAX_TASKS_MASK 0x3f
#define PIDHASH(pid) ((pid) & MAX_TASKS_MASK)
/* Stubs used when there are no file descriptors */
#if CONFIG_NFILE_DESCRIPTORS <= 0
# define sched_setupidlefiles(t) (OK)
# define sched_setuptaskfiles(t) (OK)
# define sched_setuppthreadfiles(t) (OK)
# define sched_releasefiles(t) (OK)
#endif
/* A more efficient ways to access the errno */
#define SET_ERRNO(e) \
{ _TCB *rtcb = _TCB*)g_readytorun.head; rtcb->errno = (e); }
#define _SET_TCB_ERRNO(t,e) \
{ (t)->errno = (e); }
/************************************************************
* Public Type Definitions
************************************************************/
/* This structure defines the format of the hash table that
* is used to (1) determine if a task ID is unique, and (2)
* to map a process ID to its corresponding TCB.
*/
struct pidhash_s
{
_TCB *tcb;
pid_t pid;
};
typedef struct pidhash_s pidhash_t;
/* This structure defines an element of the g_tasklisttable[].
* This table is used to map a task_state enumeration to the
* corresponding task list.
*/
struct tasklist_s
{
dq_queue_t *list; /* Pointer to the task list */
boolean prioritized; /* TRUE if the list is prioritized */
};
typedef struct tasklist_s tasklist_t;
/************************************************************
* Global Variables
************************************************************/
/* Declared in os_start.c ***********************************/
/* The state of a task is indicated both by the task_state field
* of the TCB and by a series of task lists. All of these
* tasks lists are declared below. Although it is not always
* necessary, most of these lists are prioritized so that common
* list handling logic can be used (only the g_readytorun,
* the g_pendingtasks, and the g_waitingforsemaphore lists need
* to be prioritized).
*/
/* This is the list of all tasks that are ready to run. The head
* of this list is the currently active task; the tail of this
* list is always the idle task.
*/
extern dq_queue_t g_readytorun;
/* This is the list of all tasks that are ready-to-run, but
* cannot be placed in the g_readytorun list because: (1) They
* are higher priority than the currently active task at the head
* of the g_readytorun list, and (2) the currenly active task has
* disabled pre-emption.
*/
extern dq_queue_t g_pendingtasks;
/* This is the list of all tasks that are blocked waiting for a semaphore */
extern dq_queue_t g_waitingforsemaphore;
/* This is the list of all tasks that are blocked waiting for a signal */
extern dq_queue_t g_waitingforsignal;
/* This is the list of all tasks that are blocked waiting for a message
* queue to become non-empty.
*/
extern dq_queue_t g_waitingformqnotempty;
/* This is the list of all tasks that are blocked waiting for a message
* queue to become non-full.
*/
extern dq_queue_t g_waitingformqnotfull;
/* This the list of all tasks that have been initialized, but not yet
* activated. NOTE: This is the only list that is not prioritized.
*/
extern dq_queue_t g_inactivetasks;
/* This is the list of dayed memory deallocations that need to be handled
* within the IDLE loop. These deallocations get queued by sched_free()
* if the OS attempts to deallocate memory while it is within an interrupt
* handler.
*/
extern sq_queue_t g_delayeddeallocations;
/* This is the value of the last process ID assigned to a task */
extern pid_t g_lastpid;
/* The following hash table is used for two things:
* 1. This hash table greatly speeds the determination of
* a new unique process ID for a task, and
* 2. Is used to quickly map a process ID into a TCB.
* It has the side effects of using more memory and limiting
* the number of tasks to MAX_TASKS_ALLOWED.
*/
extern pidhash_t g_pidhash[MAX_TASKS_ALLOWED];
/* This is a table of task lists. This table is indexed by
* the task state enumeration type (tstate_t) and provides
* a pointer to the associated static task list (if there
* is one) as well as a boolean indication as to if the list
* is an ordered list or not.
*/
extern const tasklist_t g_tasklisttable[NUM_TASK_STATES];
/************************************************************
* Public Inline Functions
************************************************************/
/************************************************************
* Public Function Prototypes
************************************************************/
extern STATUS _task_init(_TCB *tcb, char *name, int priority,
start_t start, main_t main,
boolean pthread,
char *arg1, char *arg2,
char *arg3, char *arg4);
extern boolean sched_addreadytorun(_TCB *rtrtcb);
extern boolean sched_removereadytorun(_TCB *rtrtcb);
extern boolean sched_addprioritized(_TCB *newTcb,
dq_queue_t *list);
extern boolean sched_mergepending(void);
extern void sched_addblocked(_TCB *btcb, tstate_t task_state);
extern void sched_removeblocked(_TCB *btcb);
extern _TCB *sched_gettcb(pid_t pid);
#if CONFIG_NFILE_DESCRIPTORS > 0
extern int sched_setupidlefiles(_TCB *tcb);
extern int sched_setuptaskfiles(_TCB *tcb);
extern int sched_setuppthreadfiles(_TCB *tcb);
#if CONFIG_NFILE_STREAMS > 0
extern int sched_setupstreams(_TCB *tcb);
extern int sched_flushfiles(_TCB *tcb);
#endif
extern int sched_releasefiles(_TCB *tcb);
#endif
extern int sched_releasetcb(_TCB *tcb);
#endif /* __OS_INTERNAL_H */
Reference in New Issue View Git Blame Copy Permalink