Annotation of libaitsched/src/tasks.c, revision 1.1.1.1
1.1 misho 1: /*************************************************************************
2: * (C) 2011 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
6: * $Id: aitcrc.c,v 1.4.2.1 2011/05/10 20:48:49 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /*
50: * schedRead() - Add READ task to scheduler queue
51: * @root = root task
52: * @func = task execution function
53: * @arg = 1st func argument
54: * @... = next func arguments, like fd handle
55: * return: NULL error or !=NULL new queued task
56: */
57: sched_task_t *
58: schedRead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, ...)
59: {
60: sched_task_t *task;
61: void *ptr;
62: va_list lst;
63:
64: if (!root || !func)
65: return NULL;
66:
67: /* get new task */
68: if ((task = TAILQ_FIRST(&root->root_unuse)))
69: TAILQ_REMOVE(&root->root_unuse, task, task_node);
70: else {
71: task = malloc(sizeof(sched_task_t));
72: if (!task) {
73: LOGERR;
74: return NULL;
75: }
76: }
77:
78: memset(task, 0, sizeof(sched_task_t));
79: task->task_id = 0;
80: task->task_type = taskREAD;
81: task->task_root = root;
82: task->task_func = func;
83:
84: TASK_ARG(task) = arg;
85: va_start(lst, arg);
86: TASK_FD(task) = va_arg(lst, int);
87: va_end(lst);
88:
89: if (root->root_hooks.hook_add.read)
90: ptr = root->root_hooks.hook_add.read(task, NULL);
91: else
92: ptr = NULL;
93:
94: if (!ptr)
95: TAILQ_INSERT_TAIL(&root->root_read, task, task_node);
96: else {
97: task->task_type = taskUNUSE;
98: TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
99: task = NULL;
100: }
101:
102: return task;
103: }
104:
105: /*
106: * schedWrite() - Add WRITE task to scheduler queue
107: * @root = root task
108: * @func = task execution function
109: * @arg = 1st func argument
110: * @... = next func arguments, like fd handle
111: * return: NULL error or !=NULL new queued task
112: */
113: sched_task_t *
114: schedWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, ...)
115: {
116: sched_task_t *task;
117: void *ptr;
118: va_list lst;
119:
120: if (!root || !func)
121: return NULL;
122:
123: /* get new task */
124: if ((task = TAILQ_FIRST(&root->root_unuse)))
125: TAILQ_REMOVE(&root->root_unuse, task, task_node);
126: else {
127: task = malloc(sizeof(sched_task_t));
128: if (!task) {
129: LOGERR;
130: return NULL;
131: }
132: }
133:
134: memset(task, 0, sizeof(sched_task_t));
135: task->task_id = 0;
136: task->task_type = taskWRITE;
137: task->task_root = root;
138: task->task_func = func;
139:
140: TASK_ARG(task) = arg;
141: va_start(lst, arg);
142: TASK_FD(task) = va_arg(lst, int);
143: va_end(lst);
144:
145: if (root->root_hooks.hook_add.write)
146: ptr = root->root_hooks.hook_add.write(task, NULL);
147: else
148: ptr = NULL;
149:
150: if (!ptr)
151: TAILQ_INSERT_TAIL(&root->root_write, task, task_node);
152: else {
153: task->task_type = taskUNUSE;
154: TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
155: task = NULL;
156: }
157:
158: return task;
159: }
160:
161: /*
162: * schedTimer() - Add TIMER task to scheduler queue
163: * @root = root task
164: * @func = task execution function
165: * @arg = 1st func argument
166: * @... = next func arguments in microSecs, define period 1sec == 1000000
167: * return: NULL error or !=NULL new queued task
168: */
169: sched_task_t *
170: schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, ...)
171: {
172: sched_task_t *task, *t = NULL;
173: void *ptr;
174: va_list lst;
175: struct timeval now;
176: struct timespec nw;
177: u_int tim;
178:
179: if (!root || !func)
180: return NULL;
181:
182: /* get new task */
183: if ((task = TAILQ_FIRST(&root->root_unuse)))
184: TAILQ_REMOVE(&root->root_unuse, task, task_node);
185: else {
186: task = malloc(sizeof(sched_task_t));
187: if (!task) {
188: LOGERR;
189: return NULL;
190: }
191: }
192:
193: memset(task, 0, sizeof(sched_task_t));
194: task->task_id = 0;
195: task->task_type = taskTIMER;
196: task->task_root = root;
197: task->task_func = func;
198:
199: TASK_ARG(task) = arg;
200: va_start(lst, arg);
201: tim = va_arg(lst, u_int);
202: va_end(lst);
203:
204: /* calculate timeval structure */
205: clock_gettime(CLOCK_MONOTONIC, &nw);
206: now.tv_sec = nw.tv_sec + tim / 1000000;
207: now.tv_usec = nw.tv_nsec / 1000 + (tim % 1000000);
208: if (now.tv_usec >= 1000000) {
209: now.tv_sec++;
210: now.tv_usec -= 1000000;
211: } else if (now.tv_usec < 0) {
212: now.tv_sec--;
213: now.tv_usec += 1000000;
214: }
215: TASK_TV(task) = now;
216:
217: if (root->root_hooks.hook_add.timer)
218: ptr = root->root_hooks.hook_add.timer(task, NULL);
219: else
220: ptr = NULL;
221:
222: if (!ptr) {
223: #ifdef TIMER_WITHOUT_SORT
224: TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
225: #else
226: TAILQ_FOREACH(t, &root->root_timer, task_node)
227: if (timercmp(&TASK_TV(task), &TASK_TV(t), -) < 1)
228: break;
229: if (!t)
230: TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
231: else
232: TAILQ_INSERT_BEFORE(t, task, task_node);
233: #endif
234: } else {
235: task->task_type = taskUNUSE;
236: TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
237: task = NULL;
238: }
239:
240: return task;
241: }
242:
243: /*
244: * schedEvent() - Add EVENT task to scheduler queue
245: * @root = root task
246: * @func = task execution function
247: * @arg = 1st func argument
248: * @... = next func arguments, like u_long
249: * return: NULL error or !=NULL new queued task
250: */
251: sched_task_t *
252: schedEvent(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, ...)
253: {
254: sched_task_t *task;
255: void *ptr;
256: va_list lst;
257:
258: if (!root || !func)
259: return NULL;
260:
261: /* get new task */
262: if ((task = TAILQ_FIRST(&root->root_unuse)))
263: TAILQ_REMOVE(&root->root_unuse, task, task_node);
264: else {
265: task = malloc(sizeof(sched_task_t));
266: if (!task) {
267: LOGERR;
268: return NULL;
269: }
270: }
271:
272: memset(task, 0, sizeof(sched_task_t));
273: task->task_id = 0;
274: task->task_type = taskEVENT;
275: task->task_root = root;
276: task->task_func = func;
277:
278: TASK_ARG(task) = arg;
279: va_start(lst, arg);
280: TASK_VAL(task) = va_arg(lst, u_long);
281: va_end(lst);
282:
283: if (root->root_hooks.hook_add.event)
284: ptr = root->root_hooks.hook_add.event(task, NULL);
285: else
286: ptr = NULL;
287:
288: if (!ptr)
289: TAILQ_INSERT_TAIL(&root->root_event, task, task_node);
290: else {
291: task->task_type = taskUNUSE;
292: TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
293: task = NULL;
294: }
295:
296: return task;
297: }
298:
299:
300: /*
301: * schedEventLo() - Add EVENT_Lo task to scheduler queue
302: * @root = root task
303: * @func = task execution function
304: * @arg = 1st func argument
305: * @... = next func arguments, like u_long
306: * return: NULL error or !=NULL new queued task
307: */
308: sched_task_t *
309: schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, ...)
310: {
311: sched_task_t *task;
312: void *ptr;
313: va_list lst;
314:
315: if (!root || !func)
316: return NULL;
317:
318: /* get new task */
319: if ((task = TAILQ_FIRST(&root->root_unuse)))
320: TAILQ_REMOVE(&root->root_unuse, task, task_node);
321: else {
322: task = malloc(sizeof(sched_task_t));
323: if (!task) {
324: LOGERR;
325: return NULL;
326: }
327: }
328:
329: memset(task, 0, sizeof(sched_task_t));
330: task->task_id = 0;
331: task->task_type = taskEVENT;
332: task->task_root = root;
333: task->task_func = func;
334:
335: TASK_ARG(task) = arg;
336: va_start(lst, arg);
337: TASK_VAL(task) = va_arg(lst, u_long);
338: va_end(lst);
339:
340: if (root->root_hooks.hook_add.eventlo)
341: ptr = root->root_hooks.hook_add.eventlo(task, NULL);
342: else
343: ptr = NULL;
344:
345: if (!ptr)
346: TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);
347: else {
348: task->task_type = taskUNUSE;
349: TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
350: task = NULL;
351: }
352:
353: return task;
354: }
355:
356: /*
357: * schedCallOnce() - Call once from scheduler
358: * @root = root task
359: * @func = task execution function
360: * @arg = 1st func argument
361: * @... = next func arguments, like u_long
362: * return: NULL error or !=NULL new queued task
363: */
364: sched_task_t *
365: schedCallOnce(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, ...)
366: {
367: sched_task_t *task;
368: va_list lst;
369:
370: if (!root || !func)
371: return NULL;
372:
373: /* get new task */
374: if ((task = TAILQ_FIRST(&root->root_unuse)))
375: TAILQ_REMOVE(&root->root_unuse, task, task_node);
376: else {
377: task = malloc(sizeof(sched_task_t));
378: if (!task) {
379: LOGERR;
380: return NULL;
381: }
382: }
383:
384: memset(task, 0, sizeof(sched_task_t));
385: task->task_id = 0;
386: task->task_type = taskEVENT;
387: task->task_root = root;
388: task->task_func = func;
389:
390: TASK_ARG(task) = arg;
391: va_start(lst, arg);
392: TASK_VAL(task) = va_arg(lst, u_long);
393: va_end(lst);
394:
395: if (schedCall(task)) {
396: task->task_type = taskUNUSE;
397: TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);
398: task = NULL;
399: }
400:
401: return task;
402: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tasks.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / src