Xenomai  3.0-rc3
task.h
1 /*
2  * Copyright (C) 2011 Philippe Gerum <rpm@xenomai.org>.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13 
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
17  */
18 #ifndef _XENOMAI_ALCHEMY_TASK_H
19 #define _XENOMAI_ALCHEMY_TASK_H
20 
21 #include <sys/types.h>
22 #include <stdint.h>
23 #include <xeno_config.h>
24 #include <boilerplate/list.h>
25 #include <copperplate/threadobj.h>
26 #include <alchemy/timer.h>
27 #include <alchemy/compat.h>
28 
35 #define T_LOPRIO 0
36 #define T_HIPRIO 99
37 
39 #define T_LOCK __THREAD_M_LOCK
40 
41 #define T_WARNSW __THREAD_M_WARNSW
42 #define T_CONFORMING __THREAD_M_CONFORMING
43 #define T_JOINABLE __THREAD_M_SPARE0
44 
45 struct RT_TASK {
46  uintptr_t handle;
47  pthread_t thread;
48 };
49 
50 typedef struct RT_TASK RT_TASK;
51 
52 struct RT_TASK_MCB {
53  int flowid;
54  int opcode;
55  void *data;
56  ssize_t size;
57 };
58 
59 typedef struct RT_TASK_MCB RT_TASK_MCB;
60 
68 struct RT_TASK_INFO {
72  int prio;
76  struct threadobj_stat stat;
80  char name[XNOBJECT_NAME_LEN];
84  pid_t pid;
85 };
86 
87 typedef struct RT_TASK_INFO RT_TASK_INFO;
88 
89 #define NO_ALCHEMY_TASK ((RT_TASK){ 0, 0 })
90 
91 #ifdef __cplusplus
92 extern "C" {
93 #endif
94 
95 CURRENT_DECL(int, rt_task_create(RT_TASK *task,
96  const char *name,
97  int stksize,
98  int prio,
99  int mode));
100 
101 int rt_task_delete(RT_TASK *task);
102 
103 int rt_task_set_affinity(RT_TASK *task,
104  const cpu_set_t *cpus);
105 
106 int rt_task_start(RT_TASK *task,
107  void (*entry)(void *arg),
108  void *arg);
109 
110 CURRENT_DECL(int, rt_task_spawn(RT_TASK *task, const char *name,
111  int stksize, int prio, int mode,
112  void (*entry)(void *arg),
113  void *arg));
114 
115 int rt_task_shadow(RT_TASK *task,
116  const char *name,
117  int prio,
118  int mode);
119 
120 int rt_task_join(RT_TASK *task);
121 
122 CURRENT_DECL(int, rt_task_set_periodic(RT_TASK *task,
123  RTIME idate, RTIME period));
124 
125 int rt_task_wait_period(unsigned long *overruns_r);
126 
127 int rt_task_sleep(RTIME delay);
128 
129 int rt_task_sleep_until(RTIME date);
130 
131 int rt_task_same(RT_TASK *task1, RT_TASK *task2);
132 
133 int rt_task_suspend(RT_TASK *task);
134 
135 int rt_task_resume(RT_TASK *task);
136 
137 RT_TASK *rt_task_self(void);
138 
139 int rt_task_set_priority(RT_TASK *task, int prio);
140 
141 int rt_task_set_mode(int clrmask, int setmask,
142  int *mode_r);
143 
144 int rt_task_yield(void);
145 
146 int rt_task_unblock(RT_TASK *task);
147 
148 int rt_task_slice(RT_TASK *task, RTIME quantum);
149 
150 int rt_task_inquire(RT_TASK *task,
151  RT_TASK_INFO *info);
152 
153 ssize_t rt_task_send_timed(RT_TASK *task,
154  RT_TASK_MCB *mcb_s, RT_TASK_MCB *mcb_r,
155  const struct timespec *abs_timeout);
156 
157 static inline
158 ssize_t rt_task_send_until(RT_TASK *task,
159  RT_TASK_MCB *mcb_s, RT_TASK_MCB *mcb_r,
160  RTIME timeout)
161 {
162  struct timespec ts;
163  return rt_task_send_timed(task, mcb_s, mcb_r,
164  alchemy_abs_timeout(timeout, &ts));
165 }
166 
167 static inline
168 ssize_t rt_task_send(RT_TASK *task,
169  RT_TASK_MCB *mcb_s, RT_TASK_MCB *mcb_r,
170  RTIME timeout)
171 {
172  struct timespec ts;
173  return rt_task_send_timed(task, mcb_s, mcb_r,
174  alchemy_rel_timeout(timeout, &ts));
175 }
176 
177 int rt_task_receive_timed(RT_TASK_MCB *mcb_r,
178  const struct timespec *abs_timeout);
179 
180 static inline
181 int rt_task_receive_until(RT_TASK_MCB *mcb_r, RTIME timeout)
182 {
183  struct timespec ts;
184  return rt_task_receive_timed(mcb_r,
185  alchemy_abs_timeout(timeout, &ts));
186 }
187 
188 static inline
189 int rt_task_receive(RT_TASK_MCB *mcb_r, RTIME timeout)
190 {
191  struct timespec ts;
192  return rt_task_receive_timed(mcb_r,
193  alchemy_rel_timeout(timeout, &ts));
194 }
195 
196 int rt_task_reply(int flowid,
197  RT_TASK_MCB *mcb_s);
198 
199 int rt_task_bind(RT_TASK *task,
200  const char *name, RTIME timeout);
201 
202 int rt_task_unbind(RT_TASK *task);
203 
204 #ifdef __cplusplus
205 }
206 #endif
207 
210 #endif /* _XENOMAI_ALCHEMY_TASK_H */
int rt_task_start(RT_TASK *task, void(*entry)(void *arg), void *arg)
Start a real-time task.
Definition: task.c:619
int rt_task_unblock(RT_TASK *task)
Unblock a real-time task.
Definition: task.c:1330
struct threadobj_stat stat
Task status.
Definition: task.h:76
int rt_task_create(RT_TASK *task, const char *name, int stksize, int prio, int mode)
Create a real-time task.
Definition: task.c:410
int rt_task_join(RT_TASK *task)
Wait on the termination of a real-time task.
Definition: task.c:535
static ssize_t rt_task_send(RT_TASK *task, RT_TASK_MCB *mcb_s, RT_TASK_MCB *mcb_r, RTIME timeout)
Send a message to a real-time task (with relative scalar timeout).
Definition: task.h:168
static int rt_task_receive_until(RT_TASK_MCB *mcb_r, RTIME timeout)
Receive a message from a real-time task (with absolute scalar timeout).
Definition: task.h:181
int rt_task_inquire(RT_TASK *task, RT_TASK_INFO *info)
Retrieve information about a real-time task.
Definition: task.c:1538
int rt_task_same(RT_TASK *task1, RT_TASK *task2)
Compare real-time task descriptors.
Definition: task.c:1081
RT_TASK * rt_task_self(void)
Retrieve the current task descriptor.
Definition: task.c:1206
static int rt_task_receive(RT_TASK_MCB *mcb_r, RTIME timeout)
Receive a message from a real-time task (with relative scalar timeout).
Definition: task.h:189
int rt_task_yield(void)
Manual round-robin.
Definition: task.c:1299
int rt_task_slice(RT_TASK *task, RTIME quantum)
Set a task's round-robin quantum.
Definition: task.c:1385
int rt_task_delete(RT_TASK *task)
Delete a real-time task.
Definition: task.c:477
static ssize_t rt_task_send_until(RT_TASK *task, RT_TASK_MCB *mcb_s, RT_TASK_MCB *mcb_r, RTIME timeout)
Send a message to a real-time task (with absolute scalar timeout).
Definition: task.h:158
int rt_task_set_mode(int clrmask, int setmask, int *mode_r)
Change the current task mode.
Definition: task.c:1482
int rt_task_receive_timed(RT_TASK_MCB *mcb_r, const struct timespec *abs_timeout)
Receive a message from a real-time task.
Definition: task.c:1867
int rt_task_sleep(RTIME delay)
Delay the current real-time task (with relative delay).
Definition: task.c:992
int rt_task_wait_period(unsigned long *overruns_r)
Wait for the next periodic release point.
Definition: task.c:910
Task status descriptor.
Definition: task.h:68
int rt_task_reply(int flowid, RT_TASK_MCB *mcb_s)
Reply to a remote task message.
Definition: task.c:1982
pid_t pid
Host pid.
Definition: task.h:84
int prio
Task priority.
Definition: task.h:72
ssize_t rt_task_send_timed(RT_TASK *task, RT_TASK_MCB *mcb_s, RT_TASK_MCB *mcb_r, const struct timespec *abs_timeout)
Send a message to a real-time task.
Definition: task.c:1698
int rt_task_set_affinity(RT_TASK *task, const cpu_set_t *cpus)
Set CPU affinity of real-time task.
Definition: task.c:570
int rt_task_sleep_until(RTIME date)
Delay the current real-time task (with absolute wakeup date).
Definition: task.c:950
int rt_task_bind(RT_TASK *task, const char *name, RTIME timeout)
Bind to a task.
Definition: task.c:2090
char name[XNOBJECT_NAME_LEN]
Name of task.
Definition: task.h:80
int rt_task_unbind(RT_TASK *task)
Unbind from a task.
Definition: task.c:2112
int rt_task_suspend(RT_TASK *task)
Suspend a real-time task.
Definition: task.c:1128
int rt_task_set_priority(RT_TASK *task, int prio)
Change the base priority of a real-time task.
Definition: task.c:1252
int rt_task_resume(RT_TASK *task)
Resume a real-time task.
Definition: task.c:1172
int rt_task_shadow(RT_TASK *task, const char *name, int prio, int mode)
Turn caller into a real-time task.
Definition: task.c:720
int rt_task_set_periodic(RT_TASK *task, RTIME idate, RTIME period)
Make a real-time task periodic.
Definition: task.c:826
int rt_task_spawn(RT_TASK *task, const char *name, int stksize, int prio, int mode, void(*entry)(void *arg), void *arg)
Create and start a real-time task.
Definition: task.c:1050