• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

include/native/task.h

Go to the documentation of this file.
00001 
00022 #ifndef _XENO_TASK_H
00023 #define _XENO_TASK_H
00024 
00025 #include <nucleus/sched.h>
00026 #include <native/types.h>
00027 
00028 /* Creation flags. */
00029 #define T_FPU     XNFPU
00030 #define T_SUSP    XNSUSP
00031 /* <!> High bits must not conflict with XNFPU|XNSHADOW|XNSUSP. */
00032 #define T_CPU(cpu) (1 << (24 + (cpu & 7))) /* Up to 8 cpus [0-7] */
00033 #define T_CPUMASK  0xff000000
00034 
00042 #define T_BLOCKED  XNPEND     
00043 #define T_DELAYED  XNDELAY    
00044 #define T_READY    XNREADY    
00045 #define T_DORMANT  XNDORMANT  
00046 #define T_STARTED  XNSTARTED  
00047 #define T_BOOST    XNBOOST    
00048 #define T_LOCK     XNLOCK     
00049 #define T_NOSIG    XNASDI     
00050 #define T_WARNSW   XNTRAPSW   
00051 #define T_RPIOFF   XNRPIOFF   
00053 /* Pseudo-status bits (no conflict with other T_* bits) */
00054 #define T_CONFORMING  0x00000200
00055 #define T_JOINABLE    0x00000400
00056  /* Ends doxygen-group native_task_status */
00057 
00058 /* Task hook types. */
00059 #define T_HOOK_START  XNHOOK_THREAD_START
00060 #define T_HOOK_SWITCH XNHOOK_THREAD_SWITCH
00061 #define T_HOOK_DELETE XNHOOK_THREAD_DELETE
00062 #define T_DESC(cookie) thread2rtask(cookie)
00063 
00064 /* Priority range (POSIXish, same bounds as Xenomai's). */
00065 #define T_LOPRIO  XNSCHED_LOW_PRIO
00066 #define T_HIPRIO  XNSCHED_HIGH_PRIO
00067 
00068 typedef struct rt_task_placeholder {
00069     xnhandle_t opaque;
00070     unsigned long opaque2;
00071 } RT_TASK_PLACEHOLDER;
00072 
00073 struct rt_queue_msg;
00074 struct rt_task;
00075 
00080 typedef struct rt_task_info {
00081 
00082     int bprio;  
00084     int cprio; 
00086     unsigned status; 
00088     RTIME relpoint; 
00090     char name[XNOBJECT_NAME_LEN];  
00092     RTIME exectime; 
00094     int modeswitches; 
00096     int ctxswitches; 
00098     int pagefaults; 
00100 } RT_TASK_INFO;
00101 
00102 #define RT_MCB_FSTORE_LIMIT  64
00103 
00107 typedef struct rt_task_mcb {
00108 
00109     int flowid;   
00111     int opcode;   
00113     caddr_t data; 
00115     size_t size;  
00117 } RT_TASK_MCB;
00118 
00119 #if (defined(__KERNEL__) || defined(__XENO_SIM__)) && !defined(DOXYGEN_CPP)
00120 
00121 #include <nucleus/synch.h>
00122 
00123 #define XENO_TASK_MAGIC 0x55550101
00124 
00125 typedef struct rt_task {
00126 
00127     unsigned magic;   /* !< Magic code - must be first */
00128 
00129     xnholder_t link;
00130 
00131 #define link2rtask(ln)          container_of(ln, RT_TASK, link)
00132 
00133     xnthread_t thread_base;
00134 
00135     char rname[XNOBJECT_NAME_LEN]; /* !< Name in registry. Not the same as
00136                                       thread name for anonymous threads. */
00137     int suspend_depth;
00138 
00139     int overrun;
00140 
00141     xnsynch_t safesynch;        /* !< Safe synchronization object. */
00142 
00143     u_long safelock;            /* !< Safe lock count. */
00144 
00145     u_long cstamp;              /* !< Creation stamp. */
00146 
00147     xnarch_cpumask_t affinity;
00148 
00149     union { /* Saved args for current synch. wait operation. */
00150 
00151         struct {
00152             int mode;
00153             unsigned long mask;
00154         } event;
00155 
00156 #ifdef CONFIG_XENO_OPT_NATIVE_MPS
00157         struct {
00158             RT_TASK_MCB mcb_s; /* Send area. */
00159             RT_TASK_MCB mcb_r; /* Reply area. */
00160         } mps;
00161 #endif /* CONFIG_XENO_OPT_NATIVE_MPS */
00162 
00163     } wait_args;
00164 
00165 #ifdef CONFIG_XENO_OPT_NATIVE_MPS
00166     xnsynch_t mrecv,
00167               msendq;
00168 
00169     int flowgen;                /* !< Flow id. generator. */
00170 #endif /* CONFIG_XENO_OPT_NATIVE_MPS */
00171 
00172 } RT_TASK;
00173 
00174 static inline RT_TASK *thread2rtask (xnthread_t *t)
00175 {
00176     return t ? container_of(t, RT_TASK, thread_base) : NULL;
00177 }
00178 
00179 #define xeno_current_task() thread2rtask(xnpod_current_thread())
00180 
00181 #ifdef __cplusplus
00182 extern "C" {
00183 #endif
00184 
00185 void __native_task_safe(RT_TASK *task);
00186 
00187 void __native_task_unsafe(RT_TASK *task);
00188 
00189 int __native_task_safewait(RT_TASK *task);
00190 
00191 int __native_task_pkg_init(void);
00192 
00193 void __native_task_pkg_cleanup(void);
00194 
00195 /* Public kernel interface */
00196 
00197 int rt_task_add_hook(int type,
00198                      void (*routine)(void *cookie));
00199 
00200 int rt_task_remove_hook(int type,
00201                         void (*routine)(void *cookie));
00202 
00203 int rt_task_catch(void (*handler)(rt_sigset_t));
00204 
00205 static inline int rt_task_same(RT_TASK *task1, RT_TASK *task2)
00206 {
00207         return task1 == task2;
00208 }
00209 
00210 #ifdef __cplusplus
00211 }
00212 #endif
00213 
00214 #else /* !(__KERNEL__ || __XENO_SIM__) */
00215 
00216 typedef RT_TASK_PLACEHOLDER RT_TASK;
00217 
00218 #ifdef __cplusplus
00219 extern "C" {
00220 #endif
00221 
00222 int rt_task_shadow(RT_TASK *task,
00223                    const char *name,
00224                    int prio,
00225                    int mode);
00226 
00227 int rt_task_bind(RT_TASK *task,
00228                  const char *name,
00229                  RTIME timeout);
00230 
00231 static inline int rt_task_unbind (RT_TASK *task)
00232 
00233 {
00234     task->opaque = XN_NO_HANDLE;
00235     return 0;
00236 }
00237 
00238 int rt_task_join(RT_TASK *task);
00239 
00240 #ifdef __cplusplus
00241 }
00242 #endif
00243 
00244 #endif /* __KERNEL__ || __XENO_SIM__ */
00245 
00246 #ifdef __cplusplus
00247 extern "C" {
00248 #endif
00249 
00250 /* Public interface */
00251 
00252 int rt_task_create(RT_TASK *task,
00253                    const char *name,
00254                    int stksize,
00255                    int prio,
00256                    int mode) __deprecated_in_kernel__;
00257 
00258 int rt_task_start(RT_TASK *task,
00259                   void (*fun)(void *cookie),
00260                   void *cookie);
00261 
00262 int rt_task_suspend(RT_TASK *task);
00263 
00264 int rt_task_resume(RT_TASK *task);
00265 
00266 int rt_task_delete(RT_TASK *task);
00267 
00268 int rt_task_yield(void);
00269 
00270 int rt_task_set_periodic(RT_TASK *task,
00271                          RTIME idate,
00272                          RTIME period);
00273 
00274 int rt_task_wait_period(unsigned long *overruns_r);
00275 
00276 int rt_task_set_priority(RT_TASK *task,
00277                          int prio);
00278 
00279 int rt_task_sleep(RTIME delay);
00280 
00281 int rt_task_sleep_until(RTIME date);
00282 
00283 int rt_task_unblock(RT_TASK *task);
00284 
00285 int rt_task_inquire(RT_TASK *task,
00286                      RT_TASK_INFO *info);
00287 
00288 int rt_task_notify(RT_TASK *task,
00289                    rt_sigset_t signals);
00290 
00291 int rt_task_set_mode(int clrmask,
00292                      int setmask,
00293                      int *mode_r);
00294 
00295 RT_TASK *rt_task_self(void);
00296 
00297 int rt_task_slice(RT_TASK *task,
00298                   RTIME quantum);
00299 
00300 ssize_t rt_task_send(RT_TASK *task,
00301                      RT_TASK_MCB *mcb_s,
00302                      RT_TASK_MCB *mcb_r,
00303                      RTIME timeout);
00304 
00305 int rt_task_receive(RT_TASK_MCB *mcb_r,
00306                     RTIME timeout);
00307 
00308 int rt_task_reply(int flowid,
00309                   RT_TASK_MCB *mcb_s);
00310 
00311 static inline int rt_task_spawn(RT_TASK *task,
00312                                 const char *name,
00313                                 int stksize,
00314                                 int prio,
00315                                 int mode,
00316                                 void (*entry)(void *cookie),
00317                                 void *cookie)
00318 {
00319     int err = rt_task_create(task,name,stksize,prio,mode);
00320 
00321     if (!err)
00322         err = rt_task_start(task,entry,cookie);
00323 
00324     return err;
00325 }
00326 
00327 int rt_task_same(RT_TASK *task1, RT_TASK *task2);
00328 
00329 #ifdef __cplusplus
00330 }
00331 #endif
00332 
00333 #endif /* !_XENO_TASK_H */

Generated on Wed Jan 23 2013 13:24:01 for Xenomai API by  doxygen 1.7.1