2 * UCW Library -- Main Loop
4 * (c) 2004--2006 Martin Mares <mj@ucw.cz>
6 * This software may be freely distributed and used according to the terms
7 * of the GNU Lesser General Public License.
14 #include "ucw/mainloop.h"
28 ucw_time_t main_now_seconds;
29 timestamp_t main_idle_time;
32 #define GBUF_PREFIX(x) main_timer_table_##x
33 #define GBUF_TYPE struct main_timer *
35 static uns main_timer_cnt;
36 static main_timer_table_t main_timer_table;
37 #define MAIN_TIMER_LESS(x,y) ((x)->expires < (y)->expires)
38 #define MAIN_TIMER_SWAP(heap,a,b,t) (t=heap[a], heap[a]=heap[b], heap[b]=t, heap[a]->index=(a), heap[b]->index=(b))
40 clist main_file_list, main_hook_list, main_hook_done_list, main_process_list;
41 static uns main_file_cnt;
42 static uns main_poll_table_obsolete, main_poll_table_size;
43 static struct pollfd *main_poll_table;
44 static uns main_sigchld_set_up;
45 static volatile sig_atomic_t chld_received = 0;
48 // On recent Linux systems, O_CLOEXEC flag is available and we can get around
49 // the race condition of poll().
51 static int sig_pipe_recv, sig_pipe_send;
58 gettimeofday(&tv, NULL);
59 main_now_seconds = tv.tv_sec;
60 main_now = (timestamp_t)tv.tv_sec * 1000 + tv.tv_usec / 1000;
61 // DBG("It's %lld o'clock", (long long) main_now);
67 DBG("MAIN: Initializing");
69 clist_init(&main_file_list);
70 clist_init(&main_hook_list);
71 clist_init(&main_hook_done_list);
72 clist_init(&main_process_list);
74 main_poll_table_obsolete = 1;
79 timer_add(struct main_timer *tm, timestamp_t expires)
82 DBG("MAIN: Setting timer %p (expire at now+%lld)", tm, (long long)(expires-main_now));
84 DBG("MAIN: Clearing timer %p", tm);
85 if (tm->expires < expires)
89 tm->expires = expires;
90 tm->index = ++main_timer_cnt;
91 main_timer_table_grow(&main_timer_table, tm->index + 1);
92 main_timer_table.ptr[tm->index] = tm;
93 HEAP_INSERT(struct main_timer *, main_timer_table.ptr, main_timer_cnt, MAIN_TIMER_LESS, MAIN_TIMER_SWAP);
97 tm->expires = expires;
98 HEAP_INCREASE(struct main_timer *, main_timer_table.ptr, main_timer_cnt, MAIN_TIMER_LESS, MAIN_TIMER_SWAP, tm->index);
101 else if (tm->expires > expires)
105 ASSERT(tm->index && tm->index <= main_timer_cnt);
106 HEAP_DELETE(struct main_timer *, main_timer_table.ptr, main_timer_cnt, MAIN_TIMER_LESS, MAIN_TIMER_SWAP, tm->index);
112 tm->expires = expires;
113 HEAP_DECREASE(struct main_timer *, main_timer_table.ptr, main_timer_cnt, MAIN_TIMER_LESS, MAIN_TIMER_SWAP, tm->index);
119 timer_del(struct main_timer *tm)
125 file_timer_expired(struct main_timer *tm)
127 struct main_file *fi = tm->data;
128 timer_del(&fi->timer);
129 if (fi->error_handler)
130 fi->error_handler(fi, MFERR_TIMEOUT);
134 file_add(struct main_file *fi)
136 DBG("MAIN: Adding file %p (fd=%d)", fi, fi->fd);
138 clist_add_tail(&main_file_list, &fi->n);
139 fi->timer.handler = file_timer_expired;
142 main_poll_table_obsolete = 1;
143 if (fcntl(fi->fd, F_SETFL, O_NONBLOCK) < 0)
144 msg(L_ERROR, "Error setting fd %d to non-blocking mode: %m. Keep fingers crossed.", fi->fd);
148 file_chg(struct main_file *fi)
150 struct pollfd *p = fi->pollfd;
154 if (fi->read_handler)
155 p->events |= POLLIN | POLLHUP | POLLERR;
156 if (fi->write_handler)
157 p->events |= POLLOUT | POLLERR;
162 file_del(struct main_file *fi)
164 DBG("MAIN: Deleting file %p (fd=%d)", fi, fi->fd);
166 timer_del(&fi->timer);
167 clist_remove(&fi->n);
169 main_poll_table_obsolete = 1;
170 fi->n.next = fi->n.prev = NULL;
174 file_read_handler(struct main_file *fi)
176 while (fi->rpos < fi->rlen)
178 int l = read(fi->fd, fi->rbuf + fi->rpos, fi->rlen - fi->rpos);
179 DBG("MAIN: FD %d: read %d", fi->fd, l);
182 if (errno != EINTR && errno != EAGAIN && fi->error_handler)
183 fi->error_handler(fi, MFERR_READ);
190 DBG("MAIN: FD %d done read %d of %d", fi->fd, fi->rpos, fi->rlen);
191 fi->read_handler = NULL;
198 file_write_handler(struct main_file *fi)
200 while (fi->wpos < fi->wlen)
202 int l = write(fi->fd, fi->wbuf + fi->wpos, fi->wlen - fi->wpos);
203 DBG("MAIN: FD %d: write %d", fi->fd, l);
206 if (errno != EINTR && errno != EAGAIN && fi->error_handler)
207 fi->error_handler(fi, MFERR_WRITE);
212 DBG("MAIN: FD %d done write %d", fi->fd, fi->wpos);
213 fi->write_handler = NULL;
220 file_read(struct main_file *fi, void *buf, uns len)
225 fi->read_handler = file_read_handler;
232 fi->read_handler = NULL;
234 fi->rpos = fi->rlen = 0;
240 file_write(struct main_file *fi, void *buf, uns len)
245 fi->write_handler = file_write_handler;
252 fi->write_handler = NULL;
254 fi->wpos = fi->wlen = 0;
260 file_set_timeout(struct main_file *fi, timestamp_t expires)
263 timer_add(&fi->timer, expires);
269 CLIST_FOR_EACH(struct main_file *, f, main_file_list)
274 hook_add(struct main_hook *ho)
276 DBG("MAIN: Adding hook %p", ho);
278 clist_add_tail(&main_hook_list, &ho->n);
282 hook_del(struct main_hook *ho)
284 DBG("MAIN: Deleting hook %p", ho);
286 clist_remove(&ho->n);
287 ho->n.next = ho->n.prev = NULL;
292 main_sigchld_handler(int x UNUSED)
294 int old_errno = errno;
295 DBG("SIGCHLD received");
298 while((result = write(sig_pipe_send, "c", 1)) == -1 && errno == EINTR);
299 if(result == -1 && errno != EAGAIN)
300 msg(L_SIGHANDLER|L_ERROR, "Could not write to self-pipe: %m");
305 dummy_read_handler(struct main_file *mp)
308 ssize_t result = read(mp->fd, buffer, 1024);
309 if(result == -1 && errno != EAGAIN)
310 msg(L_ERROR, "Could not read from selfpipe: %m");
312 return result == 1024;
316 pipe_configure(int fd)
319 if((flags = fcntl(fd, F_GETFL)) == -1 || fcntl(fd, F_SETFL, flags|O_NONBLOCK))
320 die("Could not set file descriptor %d to non-blocking: %m", fd);
321 if((flags = fcntl(fd, F_GETFD)) == -1 || fcntl(fd, F_SETFD, flags|O_CLOEXEC))
322 die("Could not set file descriptor %d to close-on-exec: %m", fd);
326 main_sigchld_handler(int x UNUSED)
328 DBG("SIGCHLD received");
333 process_add(struct main_process *mp)
335 DBG("MAIN: Adding process %p (pid=%d)", mp, mp->pid);
338 clist_add_tail(&main_process_list, &mp->n);
339 if (!main_sigchld_set_up)
343 if(pipe(pipe_result) == -1)
344 die("Could not create selfpipe:%m");
345 pipe_configure(pipe_result[0]);
346 pipe_configure(pipe_result[1]);
347 sig_pipe_recv = pipe_result[0];
348 sig_pipe_send = pipe_result[1];
349 static struct main_file self_pipe;
350 self_pipe = (struct main_file) {
352 .read_handler = dummy_read_handler
354 file_add(&self_pipe);
357 bzero(&sa, sizeof(sa));
358 sa.sa_handler = main_sigchld_handler;
359 sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
360 sigaction(SIGCHLD, &sa, NULL);
361 main_sigchld_set_up = 1;
362 chld_received = 1; // The signal may have come before the handler
367 process_del(struct main_process *mp)
369 DBG("MAIN: Deleting process %p (pid=%d)", mp, mp->pid);
371 clist_remove(&mp->n);
376 process_fork(struct main_process *mp)
381 DBG("MAIN: Fork failed");
383 format_exit_status(mp->status_msg, -1);
391 DBG("MAIN: Forked process %d", (int) pid);
402 msg(L_DEBUG, "### Main loop status on %lld", (long long)main_now);
403 msg(L_DEBUG, "\tActive timers:");
404 for (uns i = 1; i <= main_timer_cnt; i++)
406 struct main_timer *tm = main_timer_table.ptr[i];
407 msg(L_DEBUG, "\t\t%p (expires %lld, data %p)", tm, (long long)(tm->expires ? tm->expires-main_now : 999999), tm->data);
409 struct main_file *fi;
410 msg(L_DEBUG, "\tActive files:");
411 CLIST_WALK(fi, main_file_list)
412 msg(L_DEBUG, "\t\t%p (fd %d, rh %p, wh %p, eh %p, expires %lld, data %p)",
413 fi, fi->fd, fi->read_handler, fi->write_handler, fi->error_handler,
414 (long long)(fi->timer.expires ? fi->timer.expires-main_now : 999999), fi->data);
415 msg(L_DEBUG, "\tActive hooks:");
416 struct main_hook *ho;
417 CLIST_WALK(ho, main_hook_done_list)
418 msg(L_DEBUG, "\t\t%p (func %p, data %p)", ho, ho->handler, ho->data);
419 CLIST_WALK(ho, main_hook_list)
420 msg(L_DEBUG, "\t\t%p (func %p, data %p)", ho, ho->handler, ho->data);
421 msg(L_DEBUG, "\tActive processes:");
422 struct main_process *pr;
423 CLIST_WALK(pr, main_process_list)
424 msg(L_DEBUG, "\t\t%p (pid %d, data %p)", pr, pr->pid, pr->data);
429 main_rebuild_poll_table(void)
431 struct main_file *fi;
432 if (main_poll_table_size < main_file_cnt)
435 xfree(main_poll_table);
437 main_poll_table_size = 1;
438 while (main_poll_table_size < main_file_cnt)
439 main_poll_table_size *= 2;
440 main_poll_table = xmalloc(sizeof(struct pollfd) * main_poll_table_size);
442 struct pollfd *p = main_poll_table;
443 DBG("MAIN: Rebuilding poll table: %d of %d entries set", main_file_cnt, main_poll_table_size);
444 CLIST_WALK(fi, main_file_list)
450 main_poll_table_obsolete = 0;
456 DBG("MAIN: Entering main_loop");
457 ASSERT(main_hook_list.head.next);
459 struct main_file *fi;
460 struct main_hook *ho;
461 struct main_timer *tm;
462 struct main_process *pr;
467 timestamp_t wake = main_now + 1000000000;
468 while (main_timer_cnt && (tm = main_timer_table.ptr[1])->expires <= main_now)
470 DBG("MAIN: Timer %p expired at now-%lld", tm, (long long)(main_now - tm->expires));
473 int hook_min = HOOK_RETRY;
474 int hook_max = HOOK_SHUTDOWN;
475 while (ho = clist_remove_head(&main_hook_list))
477 clist_add_tail(&main_hook_done_list, &ho->n);
478 DBG("MAIN: Hook %p", ho);
479 int ret = ho->handler(ho);
480 hook_min = MIN(hook_min, ret);
481 hook_max = MAX(hook_max, ret);
483 clist_move(&main_hook_list, &main_hook_done_list);
484 if (hook_min == HOOK_SHUTDOWN ||
485 hook_min == HOOK_DONE && hook_max == HOOK_DONE ||
488 DBG("MAIN: Shut down by %s", main_shutdown ? "main_shutdown" : "a hook");
491 if (hook_max == HOOK_RETRY)
493 if (main_poll_table_obsolete)
494 main_rebuild_poll_table();
495 #ifndef USE_SELF_PIPE
496 // We don't have a reliable flag without the self-pipe.
499 if (chld_received && !clist_empty(&main_process_list))
503 wake = MIN(wake, main_now + 10000);
505 while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
507 DBG("MAIN: Child %d exited with status %x", pid, stat);
508 CLIST_WALK(pr, main_process_list)
513 format_exit_status(pr->status_msg, pr->status);
514 DBG("MAIN: Calling process exit handler");
521 if (main_timer_cnt && (tm = main_timer_table.ptr[1])->expires < wake)
524 int timeout = ((wake > main_now) ? wake - main_now : 0);
525 DBG("MAIN: Poll for %d fds and timeout %d ms", main_file_cnt, timeout);
526 int p = poll(main_poll_table, main_file_cnt, timeout);
527 timestamp_t old_now = main_now;
529 main_idle_time += main_now - old_now;
532 struct pollfd *p = main_poll_table;
533 CLIST_WALK(fi, main_file_list)
535 if (p->revents & (POLLIN | POLLHUP | POLLERR))
538 DBG("MAIN: Read event on fd %d", p->fd);
539 while (fi->read_handler && fi->read_handler(fi) && !main_poll_table_obsolete);
540 if (main_poll_table_obsolete) /* File entries have been inserted or deleted => better not risk continuing to nowhere */
543 if (p->revents & (POLLOUT | POLLERR))
546 DBG("MAIN: Write event on fd %d", p->fd);
547 while (fi->write_handler && fi->write_handler(fi) && !main_poll_table_obsolete);
548 if (main_poll_table_obsolete)
559 static struct main_process mp;
560 static struct main_file fin, fout;
561 static struct main_hook hook;
562 static struct main_timer tm;
566 static void dread(struct main_file *fi)
568 if (fi->rpos < fi->rlen)
570 msg(L_INFO, "Read EOF");
575 msg(L_INFO, "Read done");
576 file_read(fi, rb, sizeof(rb));
580 static void derror(struct main_file *fi, int cause)
582 msg(L_INFO, "Error: %m !!! (cause %d)", cause);
586 static void dwrite(struct main_file *fi UNUSED)
588 msg(L_INFO, "Write done");
591 static int dhook(struct main_hook *ho UNUSED)
593 msg(L_INFO, "Hook called");
597 static void dtimer(struct main_timer *tm)
599 msg(L_INFO, "Timer tick");
600 timer_add(tm, main_now + 10000);
603 static void dentry(void)
605 msg(L_INFO, "*** SUBPROCESS START ***");
607 msg(L_INFO, "*** SUBPROCESS FINISH ***");
611 static void dexit(struct main_process *pr)
613 msg(L_INFO, "Subprocess %d exited with status %x", pr->pid, pr->status);
623 fin.read_done = dread;
624 fin.error_handler = derror;
626 file_read(&fin, rb, sizeof(rb));
629 fout.write_done = dwrite;
630 fout.error_handler = derror;
632 file_write(&fout, "Hello, world!\n", 14);
634 hook.handler = dhook;
638 timer_add(&tm, main_now + 1000);
641 if (!process_fork(&mp))
647 msg(L_INFO, "Finished.");