uloop: make SIGCHLD signal handling optional
[project/libubox.git] / examples / runqueue-example.c
1 /*
2  * runqueue-example.c
3  *
4  * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
5  *
6  * Permission to use, copy, modify, and/or distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <unistd.h>
22
23 #include "uloop.h"
24 #include "runqueue.h"
25
26 static struct runqueue q;
27
28 struct sleeper {
29         struct runqueue_process proc;
30         int val;
31 };
32
33 static void q_empty(struct runqueue *q)
34 {
35         fprintf(stderr, "All done!\n");
36         uloop_end();
37 }
38
39 static void q_sleep_run(struct runqueue *q, struct runqueue_task *t)
40 {
41         struct sleeper *s = container_of(t, struct sleeper, proc.task);
42         char str[32];
43         pid_t pid;
44
45         fprintf(stderr, "[%d/%d] start 'sleep %d'\n", q->running_tasks, q->max_running_tasks, s->val);
46
47         pid = fork();
48         if (pid < 0)
49                 return;
50
51         if (pid) {
52                 runqueue_process_add(q, &s->proc, pid);
53                 return;
54         }
55
56         sprintf(str, "%d", s->val);
57         execlp("sleep", "sleep", str, NULL);
58         exit(1);
59 }
60
61 static void q_sleep_cancel(struct runqueue *q, struct runqueue_task *t, int type)
62 {
63         struct sleeper *s = container_of(t, struct sleeper, proc.task);
64
65         fprintf(stderr, "[%d/%d] cancel 'sleep %d'\n", q->running_tasks, q->max_running_tasks, s->val);
66         runqueue_process_cancel_cb(q, t, type);
67 }
68
69 static void q_sleep_complete(struct runqueue *q, struct runqueue_task *p)
70 {
71         struct sleeper *s = container_of(p, struct sleeper, proc.task);
72
73         fprintf(stderr, "[%d/%d] finish 'sleep %d'\n", q->running_tasks, q->max_running_tasks, s->val);
74         free(s);
75 }
76
77 static void add_sleeper(int val)
78 {
79         static const struct runqueue_task_type sleeper_type = {
80                 .run = q_sleep_run,
81                 .cancel = q_sleep_cancel,
82                 .kill = runqueue_process_kill_cb,
83         };
84         struct sleeper *s;
85
86         s = calloc(1, sizeof(*s));
87         s->proc.task.type = &sleeper_type;
88         s->proc.task.run_timeout = 500;
89         s->proc.task.complete = q_sleep_complete;
90         s->val = val;
91         runqueue_task_add(&q, &s->proc.task, false);
92 }
93
94 int main(int argc, char **argv)
95 {
96         uloop_init();
97
98         runqueue_init(&q);
99         q.empty_cb = q_empty;
100         q.max_running_tasks = 1;
101
102         if (argc > 1)
103                 q.max_running_tasks = atoi(argv[1]);
104
105         add_sleeper(1);
106         add_sleeper(1);
107         add_sleeper(1);
108         uloop_run();
109         uloop_done();
110
111         return 0;
112 }