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