Rev 328 | Rev 657 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
2 | pj | 1 | /* |
2 | * Project: S.Ha.R.K. |
||
3 | * |
||
4 | * Coordinators: |
||
5 | * Giorgio Buttazzo <giorgio@sssup.it> |
||
6 | * Paolo Gai <pj@gandalf.sssup.it> |
||
7 | * |
||
8 | * Authors : |
||
9 | * Paolo Gai <pj@gandalf.sssup.it> |
||
10 | * Massimiliano Giorgi <massy@gandalf.sssup.it> |
||
11 | * Luca Abeni <luca@gandalf.sssup.it> |
||
12 | * (see the web pages for full authors list) |
||
13 | * |
||
14 | * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
||
15 | * |
||
16 | * http://www.sssup.it |
||
17 | * http://retis.sssup.it |
||
18 | * http://shark.sssup.it |
||
19 | */ |
||
20 | |||
21 | |||
22 | /** |
||
23 | ------------ |
||
512 | giacomo | 24 | CVS : $Id: model.h,v 1.5 2004-03-19 12:37:41 giacomo Exp $ |
2 | pj | 25 | |
26 | File: $File$ |
||
512 | giacomo | 27 | Revision: $Revision: 1.5 $ |
28 | Last update: $Date: 2004-03-19 12:37:41 $ |
||
2 | pj | 29 | ------------ |
30 | |||
31 | This file contains the definitions of the task and resource models. |
||
32 | |||
33 | **/ |
||
34 | |||
35 | /* |
||
36 | * Copyright (C) 2000 Paolo Gai |
||
37 | * |
||
38 | * This program is free software; you can redistribute it and/or modify |
||
39 | * it under the terms of the GNU General Public License as published by |
||
40 | * the Free Software Foundation; either version 2 of the License, or |
||
41 | * (at your option) any later version. |
||
42 | * |
||
43 | * This program is distributed in the hope that it will be useful, |
||
44 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
45 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
46 | * GNU General Public License for more details. |
||
47 | * |
||
48 | * You should have received a copy of the GNU General Public License |
||
49 | * along with this program; if not, write to the Free Software |
||
50 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
||
51 | * |
||
52 | */ |
||
53 | |||
54 | #ifndef __KERNEL_MODEL_H__ |
||
55 | #define __KERNEL_MODEL_H__ |
||
56 | |||
57 | #include "ll/ll.h" |
||
38 | pj | 58 | #include "kernel/types.h" |
79 | pj | 59 | #include "ll/sys/cdefs.h" |
2 | pj | 60 | |
79 | pj | 61 | __BEGIN_DECLS |
62 | |||
2 | pj | 63 | /* ----------------------------------------------------------------------- |
64 | ----------------------------------------------------------------------- |
||
65 | ----------------------------------------------------------------------- |
||
66 | ----------------------------------------------------------------------- |
||
67 | TASK MODELS |
||
68 | ----------------------------------------------------------------------- |
||
69 | ----------------------------------------------------------------------- |
||
70 | ----------------------------------------------------------------------- |
||
71 | ----------------------------------------------------------------------- */ |
||
72 | |||
73 | |||
74 | /* ----------------------------------------------------------------------- |
||
75 | TASK_MODELS: the base struct |
||
76 | ----------------------------------------------------------------------- */ |
||
77 | |||
78 | /*+ |
||
79 | TASK_MODEL |
||
80 | |||
81 | IMPORTANT: this structure shall not be used by the end-user!!! |
||
82 | |||
83 | This structure is only used to group together a set of optional |
||
84 | parameters describing the task model. This structure is passed |
||
85 | to the task_create primitive. |
||
86 | |||
87 | The control field is used to set special task processing |
||
88 | functions. |
||
89 | |||
90 | Currently it supports: |
||
91 | |||
92 | - USE_FPU bit |
||
93 | If the hw architecture is not smart enough to allow automatic |
||
94 | FPU context switch, this information is used at the VM level |
||
95 | to perform transparently the preemption of a FPU-task |
||
96 | |||
97 | - NO_KILL bit |
||
98 | If this bit is set, the task can't be killed via the task_kill |
||
99 | function. To make a task unkillable for short periods of time, |
||
100 | use the cancellability functions instead. |
||
101 | |||
102 | - NO_PREEMPT bit |
||
103 | If this bit is set, the task can't be preempted. To set/reset it, |
||
104 | use the primitive task_preempt/task_no_preempt |
||
105 | |||
106 | - SYSTEM_TASK bit |
||
107 | If this bit is set, the task is a system task. The whole system exit |
||
108 | only when all the non-system tasks are terminated. |
||
109 | |||
110 | - JET_ENABLED bit |
||
111 | If this bit is set the Generic Kernel records the Job Execution Times |
||
112 | for the task. See the jet_XXX functions... |
||
113 | |||
114 | - TASK_JOINABLE bit |
||
115 | If this bit is set the task is joinable with task_join, otherwise the |
||
116 | task is detached... |
||
117 | |||
118 | - STACKADDR_SPECIFIED bit |
||
119 | This bit is set when the task was created if we specify in the model |
||
120 | the stack address. When the task ends, if this bi is set, the stack |
||
121 | is not freed. |
||
122 | |||
123 | |||
124 | - KILL_* bits |
||
125 | These bits are used to memorize the cancelability state of the task. |
||
126 | |||
127 | - CONTROL_CAP bit |
||
128 | This flag has to be set in the scheduling modules (NOT by the end-user) |
||
129 | only if the kernel has to check the capacity for the task. The kernel |
||
130 | uses only the avail_time field of the process descriptor. |
||
131 | |||
132 | - TASK_DOING_SIGNALS bit |
||
133 | It is an internal flag used with signal handling. It is set only when |
||
134 | the task is executing a signal handler |
||
135 | |||
136 | - FREEZE_ACTIVATION |
||
137 | If this bit is set, the task_activate primitive doesn't activate any task; |
||
138 | instead, it increment a counter. See task_[un]block_activations in kern.c |
||
139 | |||
140 | - WAIT_FOR_JOIN |
||
141 | The flag is set when the task terminates; the descriptor is not |
||
142 | freed because we wait a task_join |
||
143 | |||
144 | - DESCRIPTOR_DISCARDED |
||
145 | This bit is set when the task descriptor is discarded by task_createn |
||
146 | (the wait_for_join flag is set and the task was inserted in the free |
||
147 | queue by a scheduling level). The task will be reinserted into the |
||
148 | free queue by task_join... |
||
149 | |||
150 | All the models redefines the TASK_MODEL structure |
||
151 | - adding new fields if needed |
||
152 | - using a unique number in the pclass variable |
||
153 | |||
154 | When the user wants to create a task, he must specify a task model. |
||
155 | First, he have to define a XXX_TASK_MODEL, then he must initialize it with |
||
156 | a XXX_task_default_model. |
||
157 | |||
158 | Then, he can specify some attributes that characterize the model. |
||
159 | |||
160 | Not all the fields of a task model are mandatory, but a scheduling level |
||
161 | or an ahard server may require some of them. |
||
162 | For example, if the user wants to create an ahard tasks, he may specify |
||
163 | a wcet. The wcet is not required by a Deferrable Server, but it is mandatory |
||
164 | for a TBS!!!. |
||
165 | |||
166 | +*/ |
||
167 | |||
168 | |||
169 | typedef struct { |
||
170 | WORD pclass; |
||
38 | pj | 171 | LEVEL level; |
2 | pj | 172 | size_t stacksize; |
173 | void *stackaddr; |
||
174 | WORD group; |
||
175 | void *arg; |
||
176 | DWORD control; |
||
177 | } TASK_MODEL; |
||
178 | |||
179 | /*+ Value for the control field, It is set if +*/ |
||
180 | #define USE_FPU 0x0001 /*+ the task use FPU registers +*/ |
||
181 | #define NO_KILL 0x0002 /*+ the task isn't killable at all +*/ |
||
182 | #define NO_PREEMPT 0x0004 /*+ the task isn't preemptable +*/ |
||
183 | #define SYSTEM_TASK 0x0008 /*+ the task is a system task. +*/ |
||
184 | #define JET_ENABLED 0x0010 /*+ execution time monitoring enabled +*/ |
||
185 | #define TASK_JOINABLE 0x0020 /*+ the task is joinable (see task_join)+*/ |
||
186 | #define STACKADDR_SPECIFIED 0x0040 /*+ the stackaddr was specified +*/ |
||
187 | #define TRACE_TASK 0x20000 /*+ the task must be traced +*/ |
||
188 | |||
189 | /*+ flags contained in the control field, usettables from the models: +*/ |
||
190 | #define KILLED_ON_CONDITION 0x0080 /*+ the task is killed but it is waiting |
||
191 | to die because it must reaquire |
||
192 | the mutex +*/ |
||
193 | #define KILL_ENABLED 0x0100 /*+ cancelability enabled +*/ |
||
194 | #define KILL_DEFERRED 0x0200 /*+ cancelability type deferred/async. +*/ |
||
195 | #define KILL_REQUEST 0x0400 /*+ kill issued but not executed +*/ |
||
196 | #define CONTROL_CAP 0x0800 /*+ Capacity control enabled +*/ |
||
197 | #define TASK_DOING_SIGNALS 0x1000 /*+ see kern_deliver_pending_signals |
||
198 | in signal.c +*/ |
||
199 | #define FREEZE_ACTIVATION 0x2000 /*+ see task_block_activation in kern.c +*/ |
||
200 | |||
201 | /* flags used in the implementation of the task_join */ |
||
202 | #define WAIT_FOR_JOIN 0x4000 /*+ the task is terminated, but the |
||
203 | descriptor is not freed because we wait |
||
204 | a task_join +*/ |
||
205 | #define DESCRIPTOR_DISCARDED 0x8000 /*+ the task descriptor is discarded by |
||
206 | task_createn because the wait_for_join |
||
207 | flag is set and it was inserted in the |
||
208 | free queue by a scheduling level +*/ |
||
209 | |||
210 | /* flag used in the implementation of the sig_timedwait */ |
||
211 | #define SIGTIMEOUT_EXPIRED 0x10000 /*+ if the sigwait timer expires this |
||
212 | flag is set... +*/ |
||
213 | |||
328 | giacomo | 214 | /* flag to avoid task_makefree called 2 times */ |
215 | #define TASK_MAKEFREE 0x100000 |
||
2 | pj | 216 | |
217 | /* Some macros to set various task-model parameters */ |
||
218 | #define task_default_model(m,p) (m).pclass = (p), \ |
||
38 | pj | 219 | (m).level = 0; \ |
2 | pj | 220 | (m).stacksize = 4096, \ |
221 | (m).stackaddr = NULL, \ |
||
222 | (m).group = 0, \ |
||
223 | (m).arg = NULL,\ |
||
224 | (m).control = 0 |
||
38 | pj | 225 | #define task_def_level(m,l) (m).level = (l) |
2 | pj | 226 | #define task_def_arg(m,a) (m).arg = (a) |
227 | #define task_def_stack(m,s) (m).stacksize = (s) |
||
228 | #define task_def_stackaddr(m,s) (m).stackaddr = (s) |
||
229 | #define task_def_group(m,g) (m).group = (g) |
||
230 | #define task_def_usemath(m) (m).control |= USE_FPU |
||
231 | #define task_def_system(m) (m).control |= SYSTEM_TASK |
||
232 | #define task_def_nokill(m) (m).control |= NO_KILL |
||
233 | #define task_def_ctrl_jet(m) (m).control |= JET_ENABLED |
||
234 | #define task_def_joinable(m) (m).control |= TASK_JOINABLE |
||
235 | #define task_def_unjoinable(m) (m).control &= ~TASK_JOINABLE |
||
236 | #define task_def_trace(m) (m).control |= TRACE_TASK |
||
237 | #define task_def_notrace(m) (m).control &= ~TRACE_TASK |
||
238 | |||
239 | |||
240 | |||
241 | |||
242 | /* ----------------------------------------------------------------------- |
||
243 | PCLASS values |
||
244 | ----------------------------------------------------------------------- */ |
||
245 | |||
38 | pj | 246 | /* These are the value for the pclass field */ |
2 | pj | 247 | |
38 | pj | 248 | #define DUMMY_PCLASS 0 |
249 | #define HARD_PCLASS 1 |
||
250 | #define SOFT_PCLASS 2 |
||
251 | #define NRT_PCLASS 3 |
||
252 | #define JOB_PCLASS 4 |
||
2 | pj | 253 | |
254 | |||
255 | /* ----------------------------------------------------------------------- |
||
256 | Useful stuffs |
||
257 | ----------------------------------------------------------------------- */ |
||
258 | |||
259 | #define PERIODIC 0 |
||
260 | #define APERIODIC 1 |
||
512 | giacomo | 261 | #define INTDRIVE 2 |
2 | pj | 262 | |
263 | #define SAVE_ARRIVALS 0 |
||
264 | #define SKIP_ARRIVALS 1 |
||
265 | |||
266 | |||
267 | |||
268 | /* ----------------------------------------------------------------------- |
||
269 | DUMMY_TASK_MODEL: model used only for the dummy task |
||
270 | ----------------------------------------------------------------------- */ |
||
271 | |||
272 | /*+ the dummy task doesn't add any new field +*/ |
||
273 | typedef TASK_MODEL DUMMY_TASK_MODEL; |
||
274 | |||
275 | #define dummy_task_default_model(m) task_default_model(m,DUMMY_PCLASS) |
||
276 | #define dummy_task_def_level(m,l) task_def_level(m,l) |
||
277 | #define dummy_task_def_system(m) task_def_system(m) |
||
278 | #define dummy_task_def_nokill(m) task_def_nokill(m) |
||
279 | #define dummy_task_def_ctrl_jet(m) task_def_ctrl_jet(m) |
||
280 | |||
281 | |||
282 | |||
283 | |||
284 | |||
285 | |||
286 | /* ----------------------------------------------------------------------- |
||
287 | HARD_TASK_MODEL: hard Tasks |
||
288 | ----------------------------------------------------------------------- */ |
||
289 | |||
290 | /* A Hard Task model can be used to model periodic and sporadic tasks. |
||
291 | These tasks are usually guaranteed basing on their minimum interarrival |
||
292 | time (mit) and wcet, and may have a relative deadline. |
||
293 | |||
294 | A hard task can raise these exceptions: |
||
295 | XDEADLINE_MISS XWCET_VIOLATION XACTIVATION |
||
296 | |||
297 | The default model sets wcet, mit and relative deadline to 0, and |
||
298 | the periodicity to PERIODIC. |
||
299 | */ |
||
300 | |||
301 | typedef struct { |
||
302 | TASK_MODEL t; |
||
303 | TIME mit; |
||
304 | TIME drel; |
||
305 | TIME wcet; |
||
306 | int periodicity; |
||
307 | } HARD_TASK_MODEL; |
||
308 | |||
309 | #define hard_task_default_model(m) \ |
||
310 | task_default_model((m).t,HARD_PCLASS), \ |
||
311 | (m).mit = 0, \ |
||
312 | (m).drel = 0, \ |
||
313 | (m).wcet = 0, \ |
||
314 | (m).periodicity = PERIODIC |
||
315 | #define hard_task_def_level(m,l) task_def_level((m).t,l) |
||
316 | #define hard_task_def_arg(m,a) task_def_arg((m).t,a) |
||
317 | #define hard_task_def_stack(m,s) task_def_stack((m).t,s) |
||
318 | #define hard_task_def_stackaddr(m,s) task_def_stackaddr((m).t,s) |
||
319 | #define hard_task_def_group(m,g) task_def_group((m).t,g) |
||
320 | #define hard_task_def_usemath(m) task_def_usemath((m).t) |
||
321 | #define hard_task_def_system(m) task_def_system((m).t) |
||
322 | #define hard_task_def_nokill(m) task_def_nokill((m).t) |
||
323 | #define hard_task_def_ctrl_jet(m) task_def_ctrl_jet((m).t) |
||
324 | #define hard_task_def_mit(m,p) (m).mit = (p) |
||
325 | #define hard_task_def_drel(m,d) (m).drel = (d) |
||
326 | #define hard_task_def_wcet(m,w) (m).wcet = (w) |
||
327 | #define hard_task_def_periodic(m) (m).periodicity = PERIODIC |
||
328 | #define hard_task_def_aperiodic(m) (m).periodicity = APERIODIC |
||
512 | giacomo | 329 | #define hard_task_def_interrupt(m) (m).periodicity = INTDRIVE |
2 | pj | 330 | #define hard_task_def_joinable(m) task_def_joinable((m).t) |
331 | #define hard_task_def_unjoinable(m) task_def_unjoinable((m).t) |
||
332 | #define hard_task_def_trace(m) task_def_trace((m).t) |
||
333 | #define hard_task_def_notrace(m) task_def_notrace((m).t) |
||
334 | |||
335 | |||
336 | |||
337 | /* ----------------------------------------------------------------------- |
||
338 | SOFT_TASK_MODEL: Soft Tasks |
||
339 | ----------------------------------------------------------------------- */ |
||
340 | |||
341 | /* A Soft Task model can be used to model periodic and aperiodic tasks |
||
342 | usually not guaranteed or guaranteed basing on their period and mean |
||
343 | execution time (met). A Soft task can also record pending activations if |
||
344 | the arrivals are set to SAVE. |
||
345 | |||
346 | A wcet field is also present for those servers that need if (i.e., TBS) |
||
347 | |||
348 | The default model sets met, period and wcet to 0, the periodicity to |
||
349 | PERIODIC and the arrivals to SAVE. |
||
350 | |||
351 | A Soft Task don't raise any exception. |
||
352 | */ |
||
353 | |||
354 | typedef struct { |
||
355 | TASK_MODEL t; |
||
356 | TIME period; |
||
357 | TIME met; |
||
358 | TIME wcet; |
||
359 | int periodicity; |
||
360 | int arrivals; |
||
361 | } SOFT_TASK_MODEL; |
||
362 | |||
363 | #define soft_task_default_model(m) \ |
||
364 | task_default_model((m).t,SOFT_PCLASS), \ |
||
365 | (m).period = 0, \ |
||
366 | (m).met = 0, \ |
||
367 | (m).wcet = 0, \ |
||
368 | (m).periodicity = PERIODIC, \ |
||
369 | (m).arrivals = SAVE_ARRIVALS |
||
370 | #define soft_task_def_level(m,l) task_def_level((m).t,l) |
||
371 | #define soft_task_def_arg(m,a) task_def_arg((m).t,a) |
||
372 | #define soft_task_def_stack(m,s) task_def_stack((m).t,s) |
||
373 | #define soft_task_def_stackaddr(m,s) task_def_stackaddr((m).t,s) |
||
374 | #define soft_task_def_group(m,g) task_def_group((m).t,g) |
||
375 | #define soft_task_def_usemath(m) task_def_usemath((m).t) |
||
376 | #define soft_task_def_system(m) task_def_system((m).t) |
||
377 | #define soft_task_def_nokill(m) task_def_nokill((m).t) |
||
378 | #define soft_task_def_ctrl_jet(m) task_def_ctrl_jet((m).t) |
||
379 | #define soft_task_def_period(m,p) (m).period = (p) |
||
380 | #define soft_task_def_met(m,d) (m).met = (d) |
||
381 | #define soft_task_def_wcet(m,w) (m).wcet = (w) |
||
382 | #define soft_task_def_periodic(m) (m).periodicity = PERIODIC |
||
383 | #define soft_task_def_aperiodic(m) (m).periodicity = APERIODIC |
||
384 | #define soft_task_def_save_arrivals(m) (m).arrivals = SAVE_ARRIVALS |
||
385 | #define soft_task_def_skip_arrivals(m) (m).arrivals = SKIP_ARRIVALS |
||
386 | #define soft_task_def_joinable(m) task_def_joinable((m).t) |
||
387 | #define soft_task_def_unjoinable(m) task_def_unjoinable((m).t) |
||
388 | #define soft_task_def_trace(m) task_def_trace((m).t) |
||
389 | #define soft_task_def_notrace(m) task_def_notrace((m).t) |
||
390 | |||
391 | /* ----------------------------------------------------------------------- |
||
392 | NRT_TASK_MODEL: Non Realtime Tasks |
||
393 | ----------------------------------------------------------------------- */ |
||
394 | |||
395 | /* A NRT task has a weight and a time slice, plus a policy attribute. |
||
396 | It can be used to model Round Robin, Proportional Share, POSIX, |
||
397 | and Priority tasks. |
||
398 | |||
399 | Policy and inherit is inserted in the model to support posix |
||
400 | compliant scheduling... |
||
401 | |||
402 | The default model set weight and slice to 0, policy to RR, and inherit |
||
403 | to explicit. |
||
404 | */ |
||
405 | |||
406 | #define NRT_RR_POLICY 0 |
||
407 | #define NRT_FIFO_POLICY 1 |
||
408 | |||
409 | #define NRT_INHERIT_SCHED 0 |
||
410 | #define NRT_EXPLICIT_SCHED 1 |
||
411 | |||
412 | typedef struct { |
||
413 | TASK_MODEL t; |
||
414 | int weight; |
||
415 | TIME slice; |
||
416 | int arrivals; |
||
417 | int policy; |
||
418 | int inherit; |
||
419 | } NRT_TASK_MODEL; |
||
420 | |||
421 | #define nrt_task_default_model(m) task_default_model((m).t,NRT_PCLASS), \ |
||
422 | (m).weight = 0, \ |
||
423 | (m).slice = 0, \ |
||
424 | (m).arrivals = SAVE_ARRIVALS, \ |
||
425 | (m).policy = NRT_RR_POLICY, \ |
||
426 | (m).inherit = NRT_EXPLICIT_SCHED |
||
427 | #define nrt_task_def_level(m,l) task_def_level((m).t,l) |
||
428 | #define nrt_task_def_arg(m,a) task_def_arg((m).t,a) |
||
429 | #define nrt_task_def_stack(m,s) task_def_stack((m).t,s) |
||
430 | #define nrt_task_def_stackaddr(m,s) task_def_stackaddr((m).t,s) |
||
431 | #define nrt_task_def_group(m,g) task_def_group((m).t,g) |
||
432 | #define nrt_task_def_usemath(m) task_def_usemath((m).t) |
||
433 | #define nrt_task_def_system(m) task_def_system((m).t) |
||
434 | #define nrt_task_def_nokill(m) task_def_nokill((m).t) |
||
435 | #define nrt_task_def_ctrl_jet(m) task_def_ctrl_jet((m).t) |
||
436 | #define nrt_task_def_joinable(m) task_def_joinable((m).t) |
||
437 | #define nrt_task_def_unjoinable(m) task_def_unjoinable((m).t) |
||
438 | #define nrt_task_def_weight(m,w) (m).weight = (w) |
||
439 | #define nrt_task_def_slice(m,s) (m).slice = (s) |
||
440 | #define nrt_task_def_save_arrivals(m) (m).arrivals = SAVE_ARRIVALS |
||
441 | #define nrt_task_def_skip_arrivals(m) (m).arrivals = SKIP_ARRIVALS |
||
442 | #define nrt_task_def_policy(m,p) (m).policy = (p) |
||
443 | #define nrt_task_def_inherit(m,i) (m).inherit = (i) |
||
444 | #define nrt_task_def_trace(m) task_def_trace((m).t) |
||
445 | #define nrt_task_def_notrace(m) task_def_notrace((m).t) |
||
446 | |||
447 | |||
448 | /* ----------------------------------------------------------------------- |
||
449 | JOB_TASK_MODEL: Job Task |
||
450 | ----------------------------------------------------------------------- */ |
||
451 | |||
452 | /* This model implements a Job with an optional period and a starting |
||
453 | deadline (for the first activation). |
||
454 | |||
455 | A Job task can raise a XDEADLINE_MISS exception; |
||
456 | if the flag noraiseexc is != 0, the exception is not raised. |
||
457 | |||
458 | It represent a SINGLE job activation. Typically, a task with this |
||
459 | model NEVER call a task_sleep or task_endcycle. Why? because it is |
||
460 | a single activation. |
||
461 | |||
462 | In fact, this model is normally used with aperiodic |
||
463 | servers: the aperiodic server insert a guest task in another level |
||
464 | with that model; then, when the current activation is ended (e.g. a |
||
465 | task_sleep() is called) the level, into the XXX_task_sleep, calls |
||
466 | the XXX_guest_end to terminate the actual activation. |
||
467 | |||
468 | Note that there is no capacity control on this model. |
||
469 | Note that the task that accept this task DOESN'T reactivate the |
||
470 | task after a period... There is NOT a guest_endcycle defined |
||
471 | for this model... |
||
472 | |||
473 | The default model set noraiseexc and period to 0, and accept a deadline |
||
474 | */ |
||
475 | |||
476 | typedef struct { |
||
477 | TASK_MODEL t; |
||
478 | TIME period; |
||
479 | struct timespec deadline; |
||
480 | int noraiseexc; |
||
481 | } JOB_TASK_MODEL; |
||
482 | |||
483 | #define job_task_default_model(m,dl) \ |
||
484 | task_default_model((m).t,JOB_PCLASS), \ |
||
485 | (m).period = 0, \ |
||
486 | TIMESPEC_ASSIGN(&((m).deadline),&(dl)),\ |
||
487 | (m).noraiseexc = 0 |
||
488 | #define job_task_def_level(m,l) task_def_level((m).t,l) |
||
489 | #define job_task_def_arg(m,a) task_def_arg((m).t,a) |
||
490 | #define job_task_def_stack(m,s) task_def_stack((m).t,s) |
||
491 | #define job_task_def_stackaddr(m,s) task_def_stackaddr((m).t,s) |
||
492 | #define job_task_def_group(m,g) task_def_group((m).t,g) |
||
493 | #define job_task_def_usemath(m) task_def_usemath((m).t) |
||
494 | #define job_task_def_system(m) task_def_system((m).t) |
||
495 | #define job_task_def_nokill(m) task_def_nokill((m).t) |
||
496 | #define job_task_def_ctrl_jet(m) task_def_ctrl_jet((m).t) |
||
497 | #define job_task_def_period(m,per) (m).period = (per) |
||
498 | #define job_task_def_deadline(m,dl) TIMESPEC_ASSIGN(&((m).deadline),&(dl)) |
||
499 | #define job_task_def_noexc(m) (m).noraiseexc = 1 |
||
500 | #define job_task_def_yesexc(m) (m).noraiseexc = 0 |
||
501 | #define job_task_def_joinable(m) task_def_joinable((m).t) |
||
502 | #define job_task_def_unjoinable(m) task_def_unjoinable((m).t) |
||
503 | #define job_task_def_trace(m) task_def_trace((m).t) |
||
504 | #define job_task_def_notrace(m) task_def_notrace((m).t) |
||
505 | |||
506 | |||
507 | |||
508 | |||
509 | |||
510 | |||
511 | |||
512 | |||
513 | |||
514 | |||
515 | |||
516 | /* ----------------------------------------------------------------------- |
||
517 | ----------------------------------------------------------------------- |
||
518 | ----------------------------------------------------------------------- |
||
519 | ----------------------------------------------------------------------- |
||
520 | RESOURCE MODELS |
||
521 | ----------------------------------------------------------------------- |
||
522 | ----------------------------------------------------------------------- |
||
523 | ----------------------------------------------------------------------- |
||
524 | ----------------------------------------------------------------------- */ |
||
525 | |||
526 | |||
527 | |||
528 | |||
529 | |||
530 | |||
531 | |||
532 | /* ----------------------------------------------------------------------- |
||
533 | RTYPE values |
||
534 | ----------------------------------------------------------------------- */ |
||
535 | |||
536 | /* These are the values for the rtype field of a resource descriptor. |
||
537 | The value in the rtype field is used to distinguish the interface really |
||
538 | implemented by the resource object. |
||
539 | |||
540 | For example, a mutex resource descriptor "inherit" from a resource_des |
||
541 | and implements also all the mutex functions as "virtual", so a type field |
||
542 | is added to the resource descriptor to distinguish witch interface is |
||
543 | really added. +*/ |
||
544 | |||
545 | #define DEFAULT_RTYPE 0 /*+ no fields added to resource_des +*/ |
||
546 | #define MUTEX_RTYPE 1 /*+ the structure implements a mutex |
||
547 | protocol, so a cast to mutex_resource_des |
||
548 | is legal +*/ |
||
549 | |||
550 | |||
551 | |||
552 | /* ----------------------------------------------------------------------- |
||
553 | RES_MODEL - the base struct |
||
554 | ----------------------------------------------------------------------- */ |
||
555 | |||
556 | /*+ |
||
557 | RES_MODEL |
||
558 | |||
559 | This structure is used like the TASK_MODEL. |
||
560 | It groups together a set of optional parameters describing |
||
561 | the resource model used by a task. |
||
562 | |||
563 | It contains only a field; the others are model-dependent. |
||
564 | +*/ |
||
565 | |||
566 | typedef struct { |
||
38 | pj | 567 | int rclass; /* protocol */ |
568 | RLEVEL level; /* level */ |
||
2 | pj | 569 | } RES_MODEL; |
570 | |||
38 | pj | 571 | #define res_default_model(r, p) (r).rclass = (p), (r).level = 0 |
572 | #define res_def_level(r,l) (r).level = (l) |
||
2 | pj | 573 | |
574 | |||
575 | |||
576 | /* ----------------------------------------------------------------------- |
||
577 | RCLASS values |
||
578 | ----------------------------------------------------------------------- */ |
||
579 | |||
580 | /*+ These are the values for the type field in the resource models |
||
581 | a resource level l that accept a resource model with rclass r |
||
582 | accept also the alias pclass (p | l) |
||
583 | => the LSByte MUST be 0 (256 levels maximum) (as for PCLASS!!!) +*/ |
||
584 | |||
585 | #define PC_RCLASS 0x0100 |
||
586 | #define SRP_RCLASS 0x0200 |
||
587 | #define SRP2_RCLASS 0x0300 |
||
588 | |||
589 | #define BDEDF_RCLASS 0x0400 |
||
590 | #define BDPSCAN_RCLASS 0x0500 |
||
591 | |||
592 | /* ----------------------------------------------------------------------- |
||
593 | PC_RES_MODEL: BlockDevice EDF resource model |
||
594 | ----------------------------------------------------------------------- */ |
||
595 | |||
596 | typedef struct { |
||
597 | RES_MODEL r; |
||
598 | TIME dl; |
||
599 | } BDEDF_RES_MODEL; |
||
600 | |||
601 | #define BDEDF_res_default_model(res) \ |
||
602 | res_default_model((res).r,BDEDF_RCLASS); \ |
||
603 | (res).dl=0 |
||
604 | #define BDEDF_res_def_level(res,l) res_def_level((res).r,l) |
||
605 | #define BDEDF_res_def_dl(res,reldl) (res).dl=reldl |
||
606 | |||
607 | /* ----------------------------------------------------------------------- |
||
608 | PC_RES_MODEL: BlockDevice PSCAN resource model |
||
609 | ----------------------------------------------------------------------- */ |
||
610 | |||
611 | typedef struct { |
||
612 | RES_MODEL r; |
||
613 | int priority; |
||
614 | } BDPSCAN_RES_MODEL; |
||
615 | |||
616 | #define BDPSCAN_res_default_model(res) \ |
||
617 | res_default_model((res).r,BDPSCAN_RCLASS); \ |
||
618 | (res).priority=255 |
||
619 | #define BDPSCAN_res_def_level(res,l) res_def_level((res).r,l) |
||
620 | #define BDPSCAN_res_def_priority(res,pri) (res).priority=pri |
||
621 | |||
622 | /* ----------------------------------------------------------------------- |
||
623 | PC_RES_MODEL: Priority ceiling resource model |
||
624 | ----------------------------------------------------------------------- */ |
||
625 | |||
626 | /* the tasks created without using this resource models are assumed to have |
||
627 | priority = MAX_DWORD (the lowest). */ |
||
628 | |||
629 | typedef struct { |
||
630 | RES_MODEL r; |
||
631 | DWORD priority; |
||
632 | } PC_RES_MODEL; |
||
633 | |||
634 | #define PC_res_default_model(res, prio) \ |
||
635 | res_default_model((res).r, PC_RCLASS); \ |
||
636 | (res).priority = (prio) |
||
637 | #define PC_res_def_level(res,l) res_def_level(res,l) |
||
638 | |||
639 | /* ----------------------------------------------------------------------- |
||
640 | SRP_RES_MODEL: Stack Resource Policy resource model |
||
641 | ----------------------------------------------------------------------- */ |
||
642 | |||
643 | /* the tasks created without using this resource model are not allowed to |
||
644 | lock any SRP mutex. if two of this models are passed to the task_create, |
||
645 | one of them is chosen, in a nondeterministic way, so use only one of |
||
646 | this resource model per task!!! |
||
647 | |||
648 | The First SRP version uses another resource model that is embedded into |
||
649 | the mutex structure. refer to kernel/modules/srp.c. this second resource |
||
650 | model has the SRP2_RCLASS |
||
651 | */ |
||
652 | |||
653 | typedef struct { |
||
654 | RES_MODEL r; |
||
655 | DWORD preempt; /* the preemption level of a task */ |
||
656 | } SRP_RES_MODEL; |
||
657 | |||
658 | #define SRP_res_default_model(res, pre) \ |
||
659 | res_default_model((res).r, SRP_RCLASS); \ |
||
660 | (res).preempt = (pre) |
||
661 | #define SRP_res_def_level(res,l) res_def_level(res,l) |
||
662 | |||
663 | |||
664 | /* ----------------------------------------------------------------------- |
||
665 | MUTEX Attributes |
||
666 | ----------------------------------------------------------------------- */ |
||
667 | |||
668 | /*+ |
||
669 | MUTEX ATTRIBUTES |
||
670 | |||
671 | A mutexattr object act as the task model for the tasks in the system: |
||
672 | It specifies the particular options used by a protocol. |
||
673 | |||
674 | From this basic attribute object many other objects can be derived |
||
675 | as done for the TASK_MODEL. These objects are used to initialize a mutex |
||
676 | with a specified protocol. |
||
677 | +*/ |
||
678 | typedef struct { |
||
679 | int mclass; /* the protocol type... */ |
||
680 | } mutexattr_t; |
||
681 | |||
682 | #define mutexattr_default(a, c) (a).mclass = (c) |
||
683 | |||
684 | |||
685 | /* ----------------------------------------------------------------------- |
||
686 | MCLASS values |
||
687 | ----------------------------------------------------------------------- */ |
||
688 | |||
689 | /*+ These are the value for the mclass field; |
||
690 | a mutex level l that accept a task model with mclass m |
||
691 | accept also the alias mclass (m | l) |
||
692 | => the LSByte MUST be 0 (256 levels maximum) +*/ |
||
693 | |||
694 | #define NPP_MCLASS 0x0100 |
||
695 | #define PI_MCLASS 0x0200 |
||
696 | #define PC_MCLASS 0x0300 |
||
697 | #define SRP_MCLASS 0x0400 |
||
698 | #define NOP_MCLASS 0x0500 |
||
699 | #define NOPM_MCLASS 0x0600 |
||
700 | |||
701 | /* ----------------------------------------------------------------------- |
||
702 | PI_mutexattr_t: Priority Inheritance Mutex Attribute |
||
703 | ----------------------------------------------------------------------- */ |
||
704 | |||
705 | typedef mutexattr_t PI_mutexattr_t; |
||
706 | |||
707 | #define PI_MUTEXATTR_INITIALIZER {PI_MCLASS} |
||
708 | #define PI_mutexattr_default(a) mutexattr_default(a, PI_MCLASS) |
||
709 | |||
710 | /* ----------------------------------------------------------------------- |
||
711 | NPP_mutexattr_t: Non Preemptive Protocol Mutex Attribute |
||
712 | ----------------------------------------------------------------------- */ |
||
713 | |||
714 | typedef mutexattr_t NPP_mutexattr_t; |
||
715 | |||
716 | #define NPP_MUUEXATTR_INITIALIZER {NPP_MCLASS} |
||
717 | #define NPP_mutexattr_default(a) mutexattr_default(a, NPP_MCLASS) |
||
718 | |||
719 | /* ----------------------------------------------------------------------- |
||
720 | PC_mutexattr_t: Priority Ceiling Mutex Attribute |
||
721 | ----------------------------------------------------------------------- */ |
||
722 | |||
723 | typedef struct { |
||
724 | mutexattr_t a; |
||
725 | DWORD ceiling; |
||
726 | } PC_mutexattr_t; |
||
727 | |||
728 | #define PC_MUTEXATTR_INITIALIZER {{PC_MCLASS},MAX_DWORD} |
||
729 | #define PC_mutexattr_default(at,c) mutexattr_default((at).a, PC_MCLASS); \ |
||
730 | (at).ceiling = (c) |
||
731 | |||
732 | /* ----------------------------------------------------------------------- |
||
733 | SRP_mutexattr_t: Stack Resource Policy Mutex Attribute |
||
734 | ----------------------------------------------------------------------- */ |
||
735 | |||
736 | typedef mutexattr_t SRP_mutexattr_t; |
||
737 | |||
738 | #define SRP_MUTEXATTR_INITIALIZER {SRP_MCLASS} |
||
739 | #define SRP_mutexattr_default(a) mutexattr_default(a, SRP_MCLASS) |
||
740 | |||
741 | /* ----------------------------------------------------------------------- |
||
742 | NOP_mutexattr_t: No Protocol Mutex Attribute |
||
743 | ----------------------------------------------------------------------- */ |
||
744 | |||
745 | typedef mutexattr_t NOP_mutexattr_t; |
||
746 | |||
747 | #define NOP_MUTEXATTR_INITIALIZER {NOP_MCLASS} |
||
748 | #define NOP_mutexattr_default(a) mutexattr_default(a, NOP_MCLASS) |
||
749 | |||
750 | /* ----------------------------------------------------------------------- |
||
751 | NOPM_mutexattr_t: No Protocol Multiple lock Mutex Attribute |
||
752 | ----------------------------------------------------------------------- */ |
||
753 | |||
754 | typedef mutexattr_t NOPM_mutexattr_t; |
||
755 | |||
756 | #define NOPM_MUTEXATTR_INITIALIZER {NOPM_MCLASS} |
||
757 | #define NOPM_mutexattr_default(a) mutexattr_default(a, NOPM_MCLASS) |
||
758 | |||
79 | pj | 759 | __END_DECLS |
2 | pj | 760 | #endif /* __MODEL_H__ */ |
761 |