]> mj.ucw.cz Git - libucw.git/blob - lib/mainloop.c
Added bit_array_assign(), replaced BIT_ARRAY_ALLOC by functions.
[libucw.git] / lib / mainloop.c
1 /*
2  *      UCW Library -- Main Loop
3  *
4  *      (c) 2004--2006 Martin Mares <mj@ucw.cz>
5  *
6  *      This software may be freely distributed and used according to the terms
7  *      of the GNU Lesser General Public License.
8  */
9
10 #undef LOCAL_DEBUG
11
12 #include "lib/lib.h"
13 #include "lib/mainloop.h"
14
15 #include <stdio.h>
16 #include <string.h>
17 #include <unistd.h>
18 #include <signal.h>
19 #include <fcntl.h>
20 #include <errno.h>
21 #include <time.h>
22 #include <sys/poll.h>
23 #include <sys/wait.h>
24 #include <sys/time.h>
25
26 timestamp_t main_now;
27 sh_time_t main_now_seconds;
28 uns main_shutdown;
29
30 clist main_timer_list, main_file_list, main_hook_list, main_process_list;
31 static uns main_file_cnt;
32 static uns main_poll_table_obsolete, main_poll_table_size;
33 static struct pollfd *main_poll_table;
34 static uns main_sigchld_set_up;
35
36 void
37 main_get_time(void)
38 {
39   struct timeval tv;
40   gettimeofday(&tv, NULL);
41   main_now_seconds = tv.tv_sec;
42   main_now = (timestamp_t)tv.tv_sec * 1000 + tv.tv_usec / 1000;
43   // DBG("It's %Ld o'clock", (long long) main_now);
44 }
45
46 void
47 main_init(void)
48 {
49   DBG("MAIN: Initializing");
50   clist_init(&main_timer_list);
51   clist_init(&main_file_list);
52   clist_init(&main_hook_list);
53   clist_init(&main_process_list);
54   main_file_cnt = 0;
55   main_poll_table_obsolete = 1;
56   main_get_time();
57 }
58
59 void
60 timer_add(struct main_timer *tm, timestamp_t expires)
61 {
62   if (expires)
63     DBG("MAIN: Setting timer %p (expire at now+%Ld)", tm, (long long)(expires-main_now));
64   else
65     DBG("MAIN: Clearing timer %p", tm);
66   if (tm->expires)
67     clist_remove(&tm->n);
68   tm->expires = expires;
69   if (expires)
70     {
71       cnode *t = main_timer_list.head.next;
72       while (t != &main_timer_list.head && ((struct main_timer *) t)->expires < expires)
73         t = t->next;
74       clist_insert_before(&tm->n, t);
75     }
76 }
77
78 void
79 timer_del(struct main_timer *tm)
80 {
81   timer_add(tm, 0);
82 }
83
84 static void
85 file_timer_expired(struct main_timer *tm)
86 {
87   struct main_file *fi = tm->data;
88   timer_del(&fi->timer);
89   if (fi->error_handler)
90     fi->error_handler(fi, MFERR_TIMEOUT);
91 }
92
93 void
94 file_add(struct main_file *fi)
95 {
96   DBG("MAIN: Adding file %p (fd=%d)", fi, fi->fd);
97   ASSERT(!fi->n.next);
98   clist_add_tail(&main_file_list, &fi->n);
99   fi->timer.handler = file_timer_expired;
100   fi->timer.data = fi;
101   main_file_cnt++;
102   main_poll_table_obsolete = 1;
103   if (fcntl(fi->fd, F_SETFL, O_NONBLOCK) < 0)
104     log(L_ERROR, "Error setting fd %d to non-blocking mode: %m. Keep fingers crossed.", fi->fd);
105 }
106
107 void
108 file_chg(struct main_file *fi)
109 {
110   struct pollfd *p = fi->pollfd;
111   if (p)
112     {
113       p->events = 0;
114       if (fi->read_handler)
115         p->events |= POLLIN | POLLHUP | POLLERR;
116       if (fi->write_handler)
117         p->events |= POLLOUT | POLLERR;
118     }
119 }
120
121 void
122 file_del(struct main_file *fi)
123 {
124   DBG("MAIN: Deleting file %p (fd=%d)", fi, fi->fd);
125   ASSERT(fi->n.next);
126   timer_del(&fi->timer);
127   clist_remove(&fi->n);
128   main_file_cnt--;
129   main_poll_table_obsolete = 1;
130   fi->n.next = fi->n.prev = NULL;
131 }
132
133 static int
134 file_read_handler(struct main_file *fi)
135 {
136   while (fi->rpos < fi->rlen)
137     {
138       int l = read(fi->fd, fi->rbuf + fi->rpos, fi->rlen - fi->rpos);
139       DBG("MAIN: FD %d: read %d", fi->fd, l);
140       if (l < 0)
141         {
142           if (errno != EINTR && errno != EAGAIN && fi->error_handler)
143             fi->error_handler(fi, MFERR_READ);
144           return 0;
145         }
146       else if (!l)
147         break;
148       fi->rpos += l;
149     }
150   DBG("MAIN: FD %d done read %d of %d", fi->fd, fi->rpos, fi->rlen);
151   fi->read_handler = NULL;
152   file_chg(fi);
153   fi->read_done(fi);
154   return 1;
155 }
156
157 static int
158 file_write_handler(struct main_file *fi)
159 {
160   while (fi->wpos < fi->wlen)
161     {
162       int l = write(fi->fd, fi->wbuf + fi->wpos, fi->wlen - fi->wpos);
163       DBG("MAIN: FD %d: write %d", fi->fd, l);
164       if (l < 0)
165         {
166           if (errno != EINTR && errno != EAGAIN && fi->error_handler)
167             fi->error_handler(fi, MFERR_WRITE);
168           return 0;
169         }
170       fi->wpos += l;
171     }
172   DBG("MAIN: FD %d done write %d", fi->fd, fi->wpos);
173   fi->write_handler = NULL;
174   file_chg(fi);
175   fi->write_done(fi);
176   return 1;
177 }
178
179 void
180 file_read(struct main_file *fi, void *buf, uns len)
181 {
182   ASSERT(fi->n.next);
183   if (len)
184     {
185       fi->read_handler = file_read_handler;
186       fi->rbuf = buf;
187       fi->rpos = 0;
188       fi->rlen = len;
189     }
190   else
191     {
192       fi->read_handler = NULL;
193       fi->rbuf = NULL;
194       fi->rpos = fi->rlen = 0;
195     }
196   file_chg(fi);
197 }
198
199 void
200 file_write(struct main_file *fi, void *buf, uns len)
201 {
202   ASSERT(fi->n.next);
203   if (len)
204     {
205       fi->write_handler = file_write_handler;
206       fi->wbuf = buf;
207       fi->wpos = 0;
208       fi->wlen = len;
209     }
210   else
211     {
212       fi->write_handler = NULL;
213       fi->wbuf = NULL;
214       fi->wpos = fi->wlen = 0;
215     }
216   file_chg(fi);
217 }
218
219 void
220 file_set_timeout(struct main_file *fi, timestamp_t expires)
221 {
222   ASSERT(fi->n.next);
223   timer_add(&fi->timer, expires);
224 }
225
226 void
227 file_close_all(void)
228 {
229   CLIST_FOR_EACH(struct main_file *, f, main_file_list)
230     close(f->fd);
231 }
232
233 void
234 hook_add(struct main_hook *ho)
235 {
236   DBG("MAIN: Adding hook %p", ho);
237   ASSERT(!ho->n.next);
238   clist_add_tail(&main_hook_list, &ho->n);
239 }
240
241 void
242 hook_del(struct main_hook *ho)
243 {
244   DBG("MAIN: Deleting hook %p", ho);
245   ASSERT(ho->n.next);
246   clist_remove(&ho->n);
247   ho->n.next = ho->n.prev = NULL;
248 }
249
250 static void
251 main_sigchld_handler(int x UNUSED)
252 {
253   DBG("SIGCHLD received");
254 }
255
256 void
257 process_add(struct main_process *mp)
258 {
259   DBG("MAIN: Adding process %p (pid=%d)", mp, mp->pid);
260   ASSERT(!mp->n.next);
261   ASSERT(mp->handler);
262   clist_add_tail(&main_process_list, &mp->n);
263   if (!main_sigchld_set_up)
264     {
265       struct sigaction sa;
266       bzero(&sa, sizeof(sa));
267       sa.sa_handler = main_sigchld_handler;
268       sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
269       sigaction(SIGCHLD, &sa, NULL);
270       main_sigchld_set_up = 1;
271     }
272 }
273
274 void
275 process_del(struct main_process *mp)
276 {
277   DBG("MAIN: Deleting process %p (pid=%d)", mp, mp->pid);
278   ASSERT(mp->n.next);
279   clist_remove(&mp->n);
280   mp->pid = 0;
281   mp->n.next = NULL;
282 }
283
284 int
285 process_fork(struct main_process *mp)
286 {
287   ASSERT(!mp->pid);
288   pid_t pid = fork();
289   if (pid < 0)
290     {
291       DBG("MAIN: Fork failed");
292       mp->status = -1;
293       format_exit_status(mp->status_msg, -1);
294       mp->handler(mp);
295       return 1;
296     }
297   else if (!pid)
298     return 0;
299   else
300     {
301       DBG("MAIN: Forked process %d", (int) pid);
302       mp->pid = pid;
303       process_add(mp);
304       return 1;
305     }
306 }
307
308 void
309 main_debug(void)
310 {
311 #ifdef CONFIG_DEBUG
312   log(L_DEBUG, "### Main loop status on %Ld", (long long)main_now);
313   log(L_DEBUG, "\tActive timers:");
314   struct main_timer *tm;
315   CLIST_WALK(tm, main_timer_list)
316     log(L_DEBUG, "\t\t%p (expires %Ld, data %p)", tm, (long long)(tm->expires ? tm->expires-main_now : 999999), tm->data);
317   struct main_file *fi;
318   log(L_DEBUG, "\tActive files:");
319   CLIST_WALK(fi, main_file_list)
320     log(L_DEBUG, "\t\t%p (fd %d, rh %p, wh %p, eh %p, expires %Ld, data %p)",
321         fi, fi->fd, fi->read_handler, fi->write_handler, fi->error_handler,
322         (long long)(fi->timer.expires ? fi->timer.expires-main_now : 999999), fi->data);
323   log(L_DEBUG, "\tActive hooks:");
324   struct main_hook *ho;
325   CLIST_WALK(ho, main_hook_list)
326     log(L_DEBUG, "\t\t%p (func %p, data %p)", ho, ho->handler, ho->data);
327   log(L_DEBUG, "\tActive processes:");
328   struct main_process *pr;
329   CLIST_WALK(pr, main_process_list)
330     log(L_DEBUG, "\t\t%p (pid %d, data %p)", pr, pr->pid, pr->data);
331 #endif
332 }
333
334 static void
335 main_rebuild_poll_table(void)
336 {
337   struct main_file *fi;
338   if (main_poll_table_size < main_file_cnt)
339     {
340       if (main_poll_table)
341         xfree(main_poll_table);
342       else
343         main_poll_table_size = 1;
344       while (main_poll_table_size < main_file_cnt)
345         main_poll_table_size *= 2;
346       main_poll_table = xmalloc(sizeof(struct pollfd) * main_poll_table_size);
347     }
348   struct pollfd *p = main_poll_table;
349   DBG("MAIN: Rebuilding poll table: %d of %d entries set", main_file_cnt, main_poll_table_size);
350   CLIST_WALK(fi, main_file_list)
351     {
352       p->fd = fi->fd;
353       fi->pollfd = p++;
354       file_chg(fi);
355     }
356   main_poll_table_obsolete = 0;
357 }
358
359 void
360 main_loop(void)
361 {
362   DBG("MAIN: Entering main_loop");
363   ASSERT(main_timer_list.head.next);
364
365   struct main_file *fi;
366   struct main_hook *ho;
367   struct main_timer *tm;
368   struct main_process *pr;
369   cnode *tmp;
370
371   for (;;)
372     {
373       main_get_time();
374       timestamp_t wake = main_now + 1000000000;
375       while ((tm = clist_head(&main_timer_list)) && tm->expires <= main_now)
376         {
377           DBG("MAIN: Timer %p expired at now-%Ld", tm, (long long)(main_now - tm->expires));
378           tm->handler(tm);
379         }
380       int hook_min = HOOK_RETRY;
381       int hook_max = HOOK_SHUTDOWN;
382       CLIST_WALK_DELSAFE(ho, main_hook_list, tmp)
383         {
384           DBG("MAIN: Hook %p", ho);
385           int ret = ho->handler(ho);
386           hook_min = MIN(hook_min, ret);
387           hook_max = MAX(hook_max, ret);
388         }
389       if (hook_min == HOOK_SHUTDOWN ||
390           hook_min == HOOK_DONE && hook_max == HOOK_DONE ||
391           main_shutdown)
392         {
393           DBG("MAIN: Shut down by %s", main_shutdown ? "main_shutdown" : "a hook");
394           return;
395         }
396       if (hook_max == HOOK_RETRY)
397         wake = 0;
398       if (main_poll_table_obsolete)
399         main_rebuild_poll_table();
400       if (!clist_empty(&main_process_list))
401         {
402           int stat;
403           pid_t pid;
404           wake = MIN(wake, main_now + 10000);
405           while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
406             {
407               DBG("MAIN: Child %d exited with status %x", pid, stat);
408               CLIST_WALK(pr, main_process_list)
409                 if (pr->pid == pid)
410                   {
411                     pr->status = stat;
412                     process_del(pr);
413                     format_exit_status(pr->status_msg, pr->status);
414                     DBG("MAIN: Calling process exit handler");
415                     pr->handler(pr);
416                     break;
417                   }
418               wake = 0;
419             }
420         }
421       /* FIXME: Here is a small race window where SIGCHLD can come unnoticed. */
422       if ((tm = clist_head(&main_timer_list)) && tm->expires < wake)
423         wake = tm->expires;
424       int timeout = (wake ? wake - main_now : 0);
425       DBG("MAIN: Poll for %d fds and timeout %d ms", main_file_cnt, timeout);
426       if (poll(main_poll_table, main_file_cnt, timeout))
427         {
428           struct pollfd *p = main_poll_table;
429           main_get_time();
430           CLIST_WALK(fi, main_file_list)
431             {
432               if (p->revents & (POLLIN | POLLHUP | POLLERR))
433                 {
434                   do
435                     DBG("MAIN: Read event on fd %d", p->fd);
436                   while (fi->read_handler && fi->read_handler(fi) && !main_poll_table_obsolete);
437                   if (main_poll_table_obsolete) /* File entries have been inserted or deleted => better not risk continuing to nowhere */
438                     break;
439                 }
440               if (p->revents & (POLLOUT | POLLERR))
441                 {
442                   do
443                     DBG("MAIN: Write event on fd %d", p->fd);
444                   while (fi->write_handler && fi->write_handler(fi) && !main_poll_table_obsolete);
445                   if (main_poll_table_obsolete)
446                     break;
447                 }
448               p++;
449             }
450         }
451     }
452 }
453
454 #ifdef TEST
455
456 static struct main_process mp;
457 static struct main_file fin, fout;
458 static struct main_hook hook;
459 static struct main_timer tm;
460
461 static byte rb[16];
462
463 static void dread(struct main_file *fi)
464 {
465   if (fi->rpos < fi->rlen)
466     {
467       log(L_INFO, "Read EOF");
468       file_del(fi);
469     }
470   else
471     {
472       log(L_INFO, "Read done");
473       file_read(fi, rb, sizeof(rb));
474     }
475 }
476
477 static void derror(struct main_file *fi, int cause)
478 {
479   log(L_INFO, "Error: %m !!! (cause %d)", cause);
480   file_del(fi);
481 }
482
483 static void dwrite(struct main_file *fi UNUSED)
484 {
485   log(L_INFO, "Write done");
486 }
487
488 static int dhook(struct main_hook *ho UNUSED)
489 {
490   log(L_INFO, "Hook called");
491   return 0;
492 }
493
494 static void dtimer(struct main_timer *tm)
495 {
496   log(L_INFO, "Timer tick");
497   timer_add(tm, main_now + 10000);
498 }
499
500 static void dentry(void)
501 {
502   log(L_INFO, "*** SUBPROCESS START ***");
503   sleep(2);
504   log(L_INFO, "*** SUBPROCESS FINISH ***");
505   exit(0);
506 }
507
508 static void dexit(struct main_process *pr)
509 {
510   log(L_INFO, "Subprocess %d exited with status %x", pr->pid, pr->status);
511 }
512
513 int
514 main(void)
515 {
516   log_init(NULL);
517   main_init();
518
519   fin.fd = 0;
520   fin.read_done = dread;
521   fin.error_handler = derror;
522   file_add(&fin);
523   file_read(&fin, rb, sizeof(rb));
524
525   fout.fd = 1;
526   fout.write_done = dwrite;
527   fout.error_handler = derror;
528   file_add(&fout);
529   file_write(&fout, "Hello, world!\n", 14);
530
531   hook.handler = dhook;
532   hook_add(&hook);
533
534   tm.handler = dtimer;
535   timer_add(&tm, main_now + 1000);
536
537   mp.handler = dexit;
538   if (!process_fork(&mp))
539     dentry();
540
541   main_debug();
542
543   main_loop();
544   log(L_INFO, "Finished.");
545 }
546
547 #endif