| tkernel_2/kernel/tkernel/src/task.h | bare source | permlink (0.05 seconds) |
1: /* 2: *---------------------------------------------------------------------- 3: * T-Kernel 2.0 Software Package 4: * 5: * Copyright 2011 by Ken Sakamura. 6: * This software is distributed under the latest version of T-License 2.x. 7: *---------------------------------------------------------------------- 8: * 9: * Released by T-Engine Forum(http://www.t-engine.org/) at 2011/05/17. 10: * Modified by T-Engine Forum at 2012/10/24. 11: * Modified by TRON Forum(http://www.tron.org/) at 2015/06/01. 12: * 13: *---------------------------------------------------------------------- 14: */ 15: 16: /* 17: * task.h (T-Kernel/OS) 18: * Task Definition 19: */ 20: 21: #ifndef _TASK_ 22: #define _TASK_ 23: 24: #ifndef __mtxcb__ 25: #define __mtxcb__ 26: typedef struct mutex_control_block MTXCB; 27: #endif 28: 29: #ifndef __tcb__ 30: #define __tcb__ 31: typedef struct task_control_block TCB; 32: #endif 33: 34: #include <sys/queue.h> 35: #include <sys/str_align.h> 36: #include "timer.h" 37: #include "winfo.h" 38: 39: /* 40: * Internal expression of task state 41: * Can check with 'state & TS_WAIT' whether the task is in the wait state. 42: * Can check with 'state & TS_SUSPEND' whether the task is in the forced 43: * wait state. 44: */ 45: typedef enum { 46: TS_NONEXIST = 0, /* Unregistered state */ 47: TS_READY = 1, /* RUN or READY state */ 48: TS_WAIT = 2, /* WAIT state */ 49: TS_SUSPEND = 4, /* SUSPEND state */ 50: TS_WAITSUS = 6, /* Both WAIT and SUSPEND state */ 51: TS_DORMANT = 8 /* DORMANT state */ 52: } TSTAT; 53: 54: /* 55: * If the task is alive ( except NON-EXISTENT,DORMANT ), return TRUE. 56: */ 57: Inline BOOL task_alive( TSTAT state ) 58: { 59: return ( (state & (TS_READY|TS_WAIT|TS_SUSPEND)) != 0 ); 60: } 61: 62: /* 63: * Task priority internal/external expression conversion macro 64: */ 65: #define int_priority(x) ( (INT)((x) - MIN_PRI) ) 66: #define ext_tskpri(x) ( (PRI)((x) + MIN_PRI) ) 67: 68: /* 69: * Task control block (TCB) 70: */ 71: struct task_control_block { 72: QUEUE tskque; /* Task queue */ 73: ID tskid; /* Task ID */ 74: void *exinf; /* Extended information */ 75: ATR tskatr; /* Task attribute */ 76: FP task; /* Task startup address */ 77: ID resid; /* Assigned resource group ID */ 78: 79: INT stksz; /* User stack size */ 80: INT sstksz; /* System stack size */ 81: 82: INT :0; /* ### From here */ 83: UB reqdct; /* DCT request (Depends on implementation, 84: the usage is different) */ 85: B isysmode; /* Task operation mode initial value */ 86: H sysmode; /* Task operation mode, quasi task part 87: call level */ 88: INT :0; /* ### To here, since it might be accessed 89: from outside of the critical section, 90: need to be assigned as an independent 91: word. Also, there is a case where one 92: word is read from 'reqdct' and is read 93: all at once from 'reqdct', 'isysmode', 94: and 'sysmode', so do not change the 95: order and size. */ 96: 97: UB ipriority; /* Priority at task startup */ 98: UB bpriority; /* Base priority */ 99: UB priority; /* Current priority */ 100: 101: UB /*TSTAT*/ state; /* Task state (Int. expression) */ 102: 103: BOOL nodiswai:1; /* TRUE at wait disable 104: (Valid only for wait state) */ 105: BOOL klockwait:1; /* TRUE at wait kernel lock */ 106: BOOL klocked:1; /* TRUE at hold kernel lock */ 107: 108: CONST WSPEC *wspec; /* Wait specification */ 109: ID wid; /* Wait object ID */ 110: INT wupcnt; /* Number of wakeup requests queuing */ 111: INT suscnt; /* Number of SUSPEND request nests */ 112: ER *wercd; /* Wait error code set area */ 113: WINFO winfo; /* Wait information */ 114: TMEB wtmeb; /* Wait timer event block */ 115: UINT waitmask; /* Disabled wait factor */ 116: 117: #ifdef NUM_PORID 118: RNO wrdvno; /* For creating rendezvous number */ 119: #endif 120: #ifdef NUM_MTXID 121: MTXCB *mtxlist; /* List of hold mutexes */ 122: #endif 123: UB tskevt; /* Task event occurrence state */ 124: 125: SVCLOCK svclock; /* Kernel lock for Extended SVC exclusion */ 126: SVCLOCK *svclocked; /* List of lock */ 127: 128: FP texhdr; /* Task exception handler */ 129: UINT texmask; /* Task exception which is enabled */ 130: UINT pendtex; /* Task exception which is now suspended */ 131: UINT exectex; /* Task exception in break processing */ 132: 133: UH texflg; /* Task exception control flag */ 134: #define TEX0_RUNNING 0x0001U /* Task exception code '0' handler 135: is in execution */ 136: #define TEX1_RUNNING 0x0002U /* Task exception code '1-31' handler 137: is in execution */ 138: #define SSFN_RUNNING 0x0004U /* Subsystem function is in execution 139: (Task exception is suspended) */ 140: 141: ID execssid:16; /* Subsystem ID of extended SVC in 142: execution (MSB=1 break handler was 143: already executed) */ 144: #define BREAK_RAN 0x8000U /* execssid MSB */ 145: 146: RELTIM_U slicetime; /* Maximum continuous execution time (us) */ 147: RELTIM_U slicecnt; /* Continuous execution time counter (us) */ 148: 149: RELTIM_U stime; /* System execution time (us) */ 150: RELTIM_U utime; /* User execution time (us) */ 151: 152: void *istack; /* User stack pointer initial value */ 153: void *isstack; /* System stack pointer initial value */ 154: #if TA_GP 155: void *gp; /* Global pointer */ 156: #endif 157: _align64 /* alignment for CTXB.ssp */ 158: CTXB tskctxb; /* Task context block */ 159: #if USE_OBJECT_NAME 160: UB name[OBJECT_NAME_LENGTH]; /* name */ 161: #endif 162: }; 163: 164: /* 165: * Task dispatch disable state 166: * 0 = DDS_ENABLE : ENABLE 167: * 1 = DDS_DISABLE_IMPLICIT : DISABLE with implicit process 168: * 2 = DDS_DISABLE : DISABLE with tk_dis_dsp() 169: * | | 170: * | use in *.c 171: * use in *.S 172: * --> Do NOT change these literals, because using in assembler code 173: * 174: * 'dipatch_disabled' records dispatch disable status set by tk_dis_dsp() 175: * for some CPU, that accepts delayed interrupt. 176: * In this case, you can NOT refer the dispatch disabled status 177: * only by 'dispatch_disabled'. 178: * Use 'in_ddsp()' to refer the task dispatch status. 179: * 'in_ddsp()' is a macro definition in CPU-dependent definition files. 180: */ 181: #define DDS_ENABLE (0) 182: #define DDS_DISABLE_IMPLICIT (1) /* set with implicit process */ 183: #define DDS_DISABLE (2) /* set by tk_dis_dsp() */ 184: IMPORT INT dispatch_disabled; 185: 186: /* 187: * Task in execution 188: * ctxtsk is a variable that indicates TCB task in execution 189: * (= the task that CPU holds context). During system call processing, 190: * when checking information about the task that requested system call, 191: * use 'ctxtsk'. Only task dispatcher changes 'ctxtsk'. 192: */ 193: IMPORT TCB *ctxtsk; 194: 195: /* 196: * Task which should be executed 197: * 'schedtsk' is a variable that indicates the task TCB to be executed. 198: * If a dispatch is delayed by the delayed dispatch or dispatch disable, 199: * it does not match with 'ctxtsk.' 200: */ 201: IMPORT TCB *schedtsk; 202: 203: /* 204: * Task control information 205: */ 206: IMPORT TCB *tcb_table; /* Task control block */ 207: IMPORT QUEUE free_tcb; /* FreeQue */ 208: 209: /* 210: * Get TCB from task ID. 211: */ 212: #define get_tcb(id) ( &tcb_table[INDEX_TSK(id)] ) 213: #define get_tcb_self(id) ( ( (id) == TSK_SELF )? ctxtsk: get_tcb(id) ) 214: 215: /* 216: * Prepare task execution. 217: */ 218: IMPORT void make_dormant( TCB *tcb ); 219: 220: /* 221: * Make task executable. 222: * If the 'tcb' task priority is higher than the executed task, 223: * make it executable. If the priority is lower, connect the task to the 224: * ready queue. 225: */ 226: IMPORT void make_ready( TCB *tcb ); 227: 228: /* 229: * Make task non-executable. 230: * Change the 'tcb' task state to be a non-executable state (wait state, 231: * forced wait, or dormant state). When calling this function, the 232: * task must be executable. Change 'tcb->state' on the caller side 233: * after returning from this function. 234: */ 235: IMPORT void make_non_ready( TCB *tcb ); 236: 237: /* 238: * Change task priority. 239: * Change 'tcb' task priority to 'priority'. 240: * Then make the required task state transition occur. 241: */ 242: IMPORT void change_task_priority( TCB *tcb, INT priority ); 243: 244: /* 245: * Rotate ready queue. 246: * 'rotate_ready_queue' rotates the priority ready queue at 'priority'. 247: * 'rotate_ready_queue_run' rotates the ready queue including the highest 248: * priority task in the ready queue. 249: */ 250: IMPORT void rotate_ready_queue( INT priority ); 251: IMPORT void rotate_ready_queue_run( void ); 252: 253: /* 254: * Scheduling by time slice 255: */ 256: IMPORT TCB* time_slice_schedule( TCB *tcb ); 257: 258: #endif /* _TASK_ */