kernal.h

一种操作系统源码核

#if !defined(__TASK_H)
#define __TASK_H
/*
*********************************************************************************************************
*                                          TASK COMPOENT HEADER FILE
*********************************************************************************************************
*/
#define  MAX_SIGNALS  32
#define  OR      0
#define  AND     1
#define  TASK_FINISHED  0x00000001
#define  TASK_TERMINATED 0x00000002
#define  TASK_SUSPENDED  0x00000004
#define  INIT          0
#define  TASK          1 
#define  HISR          2
#define  SIG           3
#define  SIG_TASK           3
#define  IO_INITIALIZE    0 
#define  IO_OPEN          1
#define  IO_CLOSE         2 
#define  IO_INPUT         3 
#define  IO_OUTPUT        4 
#define  IO_SEEK          5
#define  IO_CTL           6
#define  IO_STATUS        7 

//task status

#define  READY          0
#define  PURE_SUSPEND   1
#define  EVENT_SUSPEND  2
#define  SIGNAL_SUSPEND 4
#define  TIMER_SUSPEND  8
#define TERMINATED      16
#define FINISHED       32

//add list type
#define FIFO        0
#define PRIORITY    1
//task wait type
#define NO_SUSPEND  -1
#define SUSPEND     0
//timer constant
#define TIMESLICE    0
#define TIMELIMIT    1
#define APPTIMER    0
#define TASKTIMER  1
#define FREE   0
#define ENABLE 1
#define DISABLE 2


//ctrl op
#define SET_PRIORITY  0
#define GET_PRIOROTY 1
#define TIMER_ACTIVE 2
#define TIME_SLICE     3
#define TIME_LIMIT    4
#define SUSPEND_TYPE  5
#define QUEUE_SIZE    6
#define PIPE_SIZE     7
#define PIPE_TYPE     8

//queue
#define QUEUE_KIND
#define FIX_TYPE 0
#define VAR_TYPE 1
#define  MAX_MINOR_DEVICES  26
//sched








/*
*********************************************************************************************************
*                                COMMON UNIT MODULE STRUCTURES
*********************************************************************************************************
*/


typedef struct LIST_NODE_STRUCT{
	struct LIST_NODE_STRUCT   *next;
	struct LIST_NODE_STRUCT   *previous;

	UNSIGNED             priority;


}LIST_NODE;


/*
*********************************************************************************************************
*                                TIMER MODULE STRUCTURES
*********************************************************************************************************
*/

typedef struct TIMER_TCB_STRUCT{
	struct TIMER_TCB_STRUCT   *next_timer;  //指向下一个定时器
	struct TIMER_TCB_STRUCT   *previous_timer;
	INT16U  	remaining_time;  //在定时器激活表中的排序值
	UNSIGNED        timer_type;
	void  		*information;  //
}TIMER_TCB;
typedef struct APP_TIMER_STRUCT{
	struct APP_TIMER_STRUCT  *next_timer;  //指向下一个定时器
	struct APP_TIMER_STRUCT *previous_timer;
	INT16U    expiration_time;           //定时器过期时间
	UNSIGNED  type_id ;           //  任务的标示符
	void     *information;  //
	void (*expiration_routine)(UNSIGNED);  //A pointer to the timer expiration function
	UNSIGNED  status;                 //标志指示定时器的允许
	UNSIGNED expiration_id;
	UNSIGNED id;
}APP_TIMER;

typedef struct{
	INT16U initial_time;
	UNSIGNED  enable;                 //标志指示定时器的允许
	UNSIGNED id;
	
	
}TIMER_DATA;

typedef struct{
	LIST_NODE   linknode;
	UNSIGNED    timer_type;    //定时器类型(slice,limit)
	void        *information;  //
}TIMER_TABLE;

/*
*********************************************************************************************************
*                                   TASK MODULE STRUCTURES
*********************************************************************************************************
*/
#define   MAX_SIGNALS    32
struct signal_struct{
	UNSIGNED src;
	void (*signal_handler[MAX_SIGNALS])(void);
 };

typedef struct task_struct{
	struct task_struct *next;
	struct task_struct *previous;
 	UNSIGNED   id;                         //  任务的ID
 	void       *current_protect ;          //  指向在该保护结构上挂起线程的头指针
 	INT8U      priority;          		//   当前优先级
 	INT8U      type;
 	INT8U      status;   		       //  当前状态
 	BOOLEAN   preemption;                   //任务是否允许强占
 
 	INT16U     scheduled;                 //  已调度次数
 	UNSIGNED       *stack_start;              //  指向堆栈开始地址
 	UNSIGNED       *stack_end;   	       //  指向堆栈结束地址
 	void       *stack_pointer;            //  堆栈指针
 	//UNSIGNED   stack_size;                // 堆栈大小
	// UNSIGNED   stack_minimum;             //剩余的最小堆栈
 	struct     task_struct *prevrdy;
 	struct     task_struct *nextrdy;
 	void       (*entry)(void);            // 任务入口函数
 	UNSIGNED   argc;       	       // 任务参数个数
 	void       *argv;		       //  参数数祖
 	TIMER_TCB  timer_control;              //  定时器控制块
 	void       (*cleanup)();              // 清除函数
 	void       *cleanup_info;             // 清除信息

	#if ENABLE_SIGNAL_HANDLE==TRUE
 		
 		struct signal_struct   *sig;                      //指向一个信号结构指针
 		UNSIGNED   signals;
 		UNSIGNED   enabled_signals ;             //包含允许信号掩码
 		void       *saved_stack_ptr;             //   保存的信号处理线程的堆栈指针
 
	#endif

 	UNSIGNED   task_timeout;                 // 当前任务运行最大时间限制
 	INT8U      save_type;
 	BOOLEAN      timer_active;                 //   定时器的激活标志
 	INT8U      time_slice;                //  任务切换时间片
  	INT8U      reserved[1];
 
}TASK_TCB;


typedef struct {
	INT8U    priority;           //   当前优先级
  	INT8U      status;   		       //  当前状态
 	BOOLEAN   preemption;                   //任务是否允许强占
 	INT8U      time_slice;                //  任务切换时间片
 	BOOLEAN      timer_active;                 //   定时器的激活标志
  	INT16U     scheduled;                 //  已调度次数
 	UNSIGNED   task_timeout;                 // 当前任务运行最大时间限制
 	UNSIGNED       *stack_start;              //  指向堆栈开始地址
 	UNSIGNED       *stack_end;   	       //  指向堆栈结束地址

}TASK_DATA;

typedef struct hisr_struct{
 	struct   hisr_struct *next;
 	struct   hisr_struct *previous;

 	UNSIGNED id ;                //   HISR的ID
 	void     *current_protect;   //   指向当前的保护线程，正操作该结构的线程
 	INT8U    priority;           //   当前优先级
 	INT8U    type;
 	INT8U    reserved;
 	INT8U    time_slice;         //   HISR的运行时间片
 	INT16U   scheduled;          //   HISR的调度次数
 	void     *stack_start;       //   指向HISR的堆栈开始地址
 	void     *stack_end;         //   指向HISR的堆栈结束地址
 	void     *stack_pointer;     //   HISR的堆栈地址
	// UNSIGNED stack_size;         //   HISR的堆栈尺寸
 	//UNSIGNED stack_minimum;      //   HISR剩余的最小堆栈
 	struct   hisr_struct *prevrdy;
 	struct   hisr_struct *nextrdy;
 	void     (*entry)(void);           // 任务入口函数
 	UNSIGNED activation_count;         //   HISR的激活次数

}TASK_HCB;

typedef struct {
 
 	INT8U    priority;           //   当前优先级
  	UNSIGNED activation_count;         //   HISR的激活次数

}HISR_DATA;

struct MAILBOX_REQUEST{
	UNSIGNED   *message_area;       //指向挂起任务的消息缓冲区
};

struct MEM_REQUEST{
	UNSIGNED request_size;
	void     *return_pointer;       //请求得到的存储区的地址
};


struct QUEUE_REQUEST{
	UNSIGNED message_size;
	void * message_area;
};

struct SEM_REQUEST{
	UNSIGNED return_status;
};
struct EVENT_REQUEST{
	UNSIGNED  requested_events;
	INT8U operation;
	INT8U return_status;
};
struct DRIVER_REQUEST {
	INT8U return_status;
};

/*
*********************************************************************************************************
*                               suspend Structure
*********************************************************************************************************
*/
typedef struct WAIT_QUEUE_STRUCT{
	struct WAIT_QUEUE_STRUCT  *next;
	struct WAIT_QUEUE_STRUCT   *previous;
	UNSIGNED             priority;
	#if WAIT_QUEUE_ALLOC_MODE  == FALSE
		struct WAIT_QUEUE_STRUCT *queue_ptr;
	#endif
	TASK_TCB *    task_ptr;     //挂起任务

	union{
    		struct MAILBOX_REQUEST  mailbox_reqinfo;
    		struct MEM_REQUEST      mem_reqinfo;
    		struct QUEUE_REQUEST    queue_reqinfo;
    		struct SEM_REQUEST      sem_reqinfo;
    		struct EVENT_REQUEST    event_reqinfo;
    		struct DRIVER_REQUEST   driver_reqinfo;
   	}event_info;
}WAIT_QUEUE;
#define mail_message            event_info.mailbox_reqinfo.message_area
#define mem_request_size        event_info.mem_reqinfo.request_size
#define mem_return_pointer      event_info.mem_reqinfo.return_pointer
#define queue_message_size      event_info.queue_reqinfo.message_size
#define queue_message           event_info.queue_reqinfo.message_area
#define sem_return_status       event_info.sem_reqinfo.return_status
#define event_requested_events  event_info.event_reqinfo.requested_events
#define event_operation         event_info.event_reqinfo.operation
#define event_return_status     event_info.event_reqinfo.return_status
#define driver_return_status     event_info.driver_reqinfo.return_status

/*
*********************************************************************************************************
*                                     Mem_MEMory Pool Header Structure
*********************************************************************************************************
*/


struct	BLOCK_STRUCT{
	struct	BLOCK_STRUCT	*next;
	struct	BLOCK_STRUCT	*prev;
	INT16U	block_size;
	};

typedef struct	mem_struct{
	struct mem_struct *next;
       	WAIT_QUEUE *task_wait_header;  //存储分区池挂起结构列表的头指针
       	UNSIGNED    id;                //用户定义的存储分区池的ID
        void   *current_protect;      //指向当前的保护线程，正操作该结构的线程
        INT8U    suspend_type;         //标志指示任务在存储分区池上挂起的类型
        INT8U reserved[3];
        UNSIGNED tasks_waiting;
        UNSIGNED ref_count;           
        UNSIGNED    availables;
        INT32U      pool_size;
        UNSIGNED    partition_size;       //存储分区池分区的尺寸
        INT8       *start_address;        //存储分区池的开始地址
        struct	BLOCK_STRUCT *available_header;
        
       
}MEM_MCB;
typedef struct	{
	
        INT8U    suspend_type;         //标志指示任务在存储分区池上挂起的类型
        UNSIGNED tasks_waiting;
        UNSIGNED ref_count;           
        UNSIGNED    availables;
        UNSIGNED task_id;
  
}POOL_DATA;

/*
*********************************************************************************************************
*                                   Mem_MEMory Pool Suspension Structure
*********************************************************************************************************
*/


/*
*********************************************************************************************************
*                                  mailbox  control Structure
*********************************************************************************************************
*/


typedef struct  mailbox_struct{
	struct  mailbox_struct *next;
	WAIT_QUEUE * task_wait_header;   //邮箱挂起结构列表的头指针

	UNSIGNED        id;              //邮箱的ID
	void    *current_protect ;       //指向当前的保护线程，正操作该结构的线程
	UNSIGNED    *message_area;       //消息的存储区域
	INT8U        suspend_type;       //标志指示任务在邮箱上挂起的次序
	INT8U  resverd[3];
	UNSIGNED tasks_waiting;


}MAILBOX_MCB;
typedef struct{
	INT8U        suspend_type;       //标志指示任务在邮箱上挂起的次序
	UNSIGNED tasks_waiting;
	UNSIGNED    task_id;       //消息的存储区域

}MAILBOX_DATA;
/*
*********************************************************************************************************
*                                  queue  control Structure
*********************************************************************************************************
*/