lib/thread.c

   1 /* Thread management routine
   2  * Copyright (C) 1998, 2000 Kunihiro Ishiguro <kunihiro@zebra.org>
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 /* #define DEBUG */
  23
  24 #include <zebra.h>
  25
  26 #include "thread.h"
  27 #include "memory.h"
  28 #include "log.h"
  29 #include "hash.h"
  30 #include "command.h"
  31 #include "sigevent.h"
  32 \f
  33 static struct hash *cpu_record = NULL;
  34 \f
  35 /* Struct timeval's tv_usec one second value.  */
  36 #define TIMER_SECOND_MICRO 1000000L
  37
  38 struct timeval
  39 timeval_adjust (struct timeval a)
  40 {
  41   while (a.tv_usec >= TIMER_SECOND_MICRO)
  42     {
  43       a.tv_usec -= TIMER_SECOND_MICRO;
  44       a.tv_sec++;
  45     }
  46
  47   while (a.tv_usec < 0)
  48     {
  49       a.tv_usec += TIMER_SECOND_MICRO;
  50       a.tv_sec--;
  51     }
  52
  53   if (a.tv_sec < 0)
  54     {
  55       a.tv_sec = 0;
  56       a.tv_usec = 10;
  57     }
  58
  59   if (a.tv_sec > TIMER_SECOND_MICRO)
  60     a.tv_sec = TIMER_SECOND_MICRO;
  61
  62   return a;
  63 }
  64
  65 static struct timeval
  66 timeval_subtract (struct timeval a, struct timeval b)
  67 {
  68   struct timeval ret;
  69
  70   ret.tv_usec = a.tv_usec - b.tv_usec;
  71   ret.tv_sec = a.tv_sec - b.tv_sec;
  72
  73   return timeval_adjust (ret);
  74 }
  75
  76 static int
  77 timeval_cmp (struct timeval a, struct timeval b)
  78 {
  79   return (a.tv_sec == b.tv_sec
  80           ? a.tv_usec - b.tv_usec : a.tv_sec - b.tv_sec);
  81 }
  82
  83 static unsigned long
  84 timeval_elapsed (struct timeval a, struct timeval b)
  85 {
  86   return (((a.tv_sec - b.tv_sec) * TIMER_SECOND_MICRO)
  87           + (a.tv_usec - b.tv_usec));
  88 }
  89 \f
  90 static unsigned int
  91 cpu_record_hash_key (struct cpu_thread_history *a)
  92 {
  93   return (unsigned int) a->func;
  94 }
  95
  96 static int
  97 cpu_record_hash_cmp (struct cpu_thread_history *a,
  98                      struct cpu_thread_history *b)
  99 {
 100   return a->func == b->func;
 101 }
 102
 103 static void*
 104 cpu_record_hash_alloc (struct cpu_thread_history *a)
 105 {
 106   struct cpu_thread_history *new;
 107   new = XCALLOC (MTYPE_THREAD_STATS, sizeof (struct cpu_thread_history));
 108   new->func = a->func;
 109   new->funcname = XSTRDUP(MTYPE_THREAD_FUNCNAME, a->funcname);
 110   return new;
 111 }
 112
 113 static inline void
 114 vty_out_cpu_thread_history(struct vty* vty,
 115                            struct cpu_thread_history *a)
 116 {
 117   vty_out(vty, " %7ld.%03ld  %9d  %8ld  %10ld %c%c%c%c%c %s%s",
 118           a->total/1000, a->total%1000, a->total_calls,
 119           a->total/a->total_calls, a->max,
 120           a->types & (1 << THREAD_READ) ? 'R':' ',
 121           a->types & (1 << THREAD_WRITE) ? 'W':' ',
 122           a->types & (1 << THREAD_TIMER) ? 'T':' ',
 123           a->types & (1 << THREAD_EVENT) ? 'E':' ',
 124           a->types & (1 << THREAD_EXECUTE) ? 'X':' ',
 125           a->funcname, VTY_NEWLINE);
 126 }
 127
 128 static void
 129 cpu_record_hash_print(struct hash_backet *bucket,
 130                       void *args[])
 131 {
 132   struct cpu_thread_history *totals = args[0];
 133   struct vty *vty = args[1];
 134   unsigned char *filter = args[2];
 135   struct cpu_thread_history *a = bucket->data;
 136
 137
 138   a = bucket->data;
 139   if ( !(a->types & *filter) )
 140        return;
 141   vty_out_cpu_thread_history(vty,a);
 142   totals->total += a->total;
 143   totals->total_calls += a->total_calls;
 144   if (totals->max < a->max)
 145     totals->max = a->max;
 146 }
 147
 148 static void
 149 cpu_record_print(struct vty *vty, unsigned char filter)
 150 {
 151   struct cpu_thread_history tmp;
 152   void *args[3] = {&tmp, vty, &filter};
 153
 154   memset(&tmp, 0, sizeof tmp);
 155   tmp.funcname = "TOTAL";
 156   tmp.types = filter;
 157
 158   vty_out(vty,
 159           " Runtime(ms)    Invoked Avg uSecs   Max uSecs  Type Thread%s",
 160           VTY_NEWLINE);
 161   hash_iterate(cpu_record,
 162                (void(*)(struct hash_backet*,void*))cpu_record_hash_print,
 163                args);
 164
 165   if (tmp.total_calls > 0)
 166     vty_out_cpu_thread_history(vty, &tmp);
 167 }
 168
 169 DEFUN(show_thread_cpu,
 170       show_thread_cpu_cmd,
 171       "show thread cpu [FILTER]",
 172       SHOW_STR
 173       "Thread information\n"
 174       "Thread CPU usage\n"
 175       "Display filter (rwtex)\n")
 176 {
 177   int i = 0;
 178   unsigned char filter = 0xff;
 179
 180   if (argc > 0)
 181     {
 182       filter = 0;
 183       while (argv[0][i] != '\0')
 184         {
 185           switch ( argv[0][i] )
 186             {
 187             case 'r':
 188             case 'R':
 189               filter |= (1 << THREAD_READ);
 190               break;
 191             case 'w':
 192             case 'W':
 193               filter |= (1 << THREAD_WRITE);
 194               break;
 195             case 't':
 196             case 'T':
 197               filter |= (1 << THREAD_TIMER);
 198               break;
 199             case 'e':
 200             case 'E':
 201               filter |= (1 << THREAD_EVENT);
 202               break;
 203             case 'x':
 204             case 'X':
 205               filter |= (1 << THREAD_EXECUTE);
 206               break;
 207             default:
 208               break;
 209             }
 210           ++i;
 211         }
 212       if (filter == 0)
 213         {
 214           vty_out(vty, "Invalid filter \"%s\" specified, must contain at least one of 'RWTEX'%s",
 215                   argv[0], VTY_NEWLINE);
 216           return CMD_WARNING;
 217         }
 218     }
 219
 220   cpu_record_print(vty, filter);
 221   return CMD_SUCCESS;
 222 }
 223 \f
 224 /* List allocation and head/tail print out. */
 225 static void
 226 thread_list_debug (struct thread_list *list)
 227 {
 228   printf ("count [%d] head [%p] tail [%p]\n",
 229           list->count, list->head, list->tail);
 230 }
 231
 232 /* Debug print for thread_master. */
 233 void
 234 thread_master_debug (struct thread_master *m)
 235 {
 236   printf ("-----------\n");
 237   printf ("readlist  : ");
 238   thread_list_debug (&m->read);
 239   printf ("writelist : ");
 240   thread_list_debug (&m->write);
 241   printf ("timerlist : ");
 242   thread_list_debug (&m->timer);
 243   printf ("eventlist : ");
 244   thread_list_debug (&m->event);
 245   printf ("unuselist : ");
 246   thread_list_debug (&m->unuse);
 247   printf ("total alloc: [%ld]\n", m->alloc);
 248   printf ("-----------\n");
 249 }
 250 \f
 251 /* Allocate new thread master.  */
 252 struct thread_master *
 253 thread_master_create ()
 254 {
 255   if (cpu_record == NULL)
 256     {
 257       cpu_record = hash_create_size( 1011, cpu_record_hash_key, cpu_record_hash_cmp);
 258     }
 259   return (struct thread_master *) XCALLOC (MTYPE_THREAD_MASTER,
 260                                            sizeof (struct thread_master));
 261 }
 262
 263 /* Add a new thread to the list.  */
 264 static void
 265 thread_list_add (struct thread_list *list, struct thread *thread)
 266 {
 267   thread->next = NULL;
 268   thread->prev = list->tail;
 269   if (list->tail)
 270     list->tail->next = thread;
 271   else
 272     list->head = thread;
 273   list->tail = thread;
 274   list->count++;
 275 }
 276
 277 /* Add a new thread just before the point.  */
 278 static void
 279 thread_list_add_before (struct thread_list *list,
 280                         struct thread *point,
 281                         struct thread *thread)
 282 {
 283   thread->next = point;
 284   thread->prev = point->prev;
 285   if (point->prev)
 286     point->prev->next = thread;
 287   else
 288     list->head = thread;
 289   point->prev = thread;
 290   list->count++;
 291 }
 292
 293 /* Delete a thread from the list. */
 294 static struct thread *
 295 thread_list_delete (struct thread_list *list, struct thread *thread)
 296 {
 297   if (thread->next)
 298     thread->next->prev = thread->prev;
 299   else
 300     list->tail = thread->prev;
 301   if (thread->prev)
 302     thread->prev->next = thread->next;
 303   else
 304     list->head = thread->next;
 305   thread->next = thread->prev = NULL;
 306   list->count--;
 307   return thread;
 308 }
 309
 310 /* Move thread to unuse list. */
 311 static void
 312 thread_add_unuse (struct thread_master *m, struct thread *thread)
 313 {
 314   assert (m != NULL);
 315   assert (thread->next == NULL);
 316   assert (thread->prev == NULL);
 317   assert (thread->type == THREAD_UNUSED);
 318   thread_list_add (&m->unuse, thread);
 319   /* XXX: Should we deallocate funcname here? */
 320 }
 321
 322 /* Free all unused thread. */
 323 static void
 324 thread_list_free (struct thread_master *m, struct thread_list *list)
 325 {
 326   struct thread *t;
 327   struct thread *next;
 328
 329   for (t = list->head; t; t = next)
 330     {
 331       next = t->next;
 332       XFREE (MTYPE_THREAD_FUNCNAME, t->funcname);
 333       XFREE (MTYPE_THREAD, t);
 334       list->count--;
 335       m->alloc--;
 336     }
 337 }
 338
 339 /* Stop thread scheduler. */
 340 void
 341 thread_master_free (struct thread_master *m)
 342 {
 343   thread_list_free (m, &m->read);
 344   thread_list_free (m, &m->write);
 345   thread_list_free (m, &m->timer);
 346   thread_list_free (m, &m->event);
 347   thread_list_free (m, &m->ready);
 348   thread_list_free (m, &m->unuse);
 349
 350   XFREE (MTYPE_THREAD_MASTER, m);
 351 }
 352
 353 /* Delete top of the list and return it. */
 354 static struct thread *
 355 thread_trim_head (struct thread_list *list)
 356 {
 357   if (list->head)
 358     return thread_list_delete (list, list->head);
 359   return NULL;
 360 }
 361
 362 /* Thread list is empty or not.  */
 363 int
 364 thread_empty (struct thread_list *list)
 365 {
 366   return  list->head ? 0 : 1;
 367 }
 368
 369 /* Return remain time in second. */
 370 unsigned long
 371 thread_timer_remain_second (struct thread *thread)
 372 {
 373   struct timeval timer_now;
 374
 375   gettimeofday (&timer_now, NULL);
 376
 377   if (thread->u.sands.tv_sec - timer_now.tv_sec > 0)
 378     return thread->u.sands.tv_sec - timer_now.tv_sec;
 379   else
 380     return 0;
 381 }
 382
 383 /* Trim blankspace and "()"s */
 384 static char *
 385 strip_funcname (const char *funcname)
 386 {
 387   char buff[100];
 388   char tmp, *ret, *e, *b = buff;
 389
 390   strncpy(buff, funcname, sizeof(buff));
 391   buff[ sizeof(buff) -1] = '\0';
 392   e = buff +strlen(buff) -1;
 393
 394   /* Wont work for funcname ==  "Word (explanation)"  */
 395
 396   while (*b == ' ' || *b == '(')
 397     ++b;
 398   while (*e == ' ' || *e == ')')
 399     --e;
 400   e++;
 401
 402   tmp = *e;
 403   *e = '\0';
 404   ret  = XSTRDUP (MTYPE_THREAD_FUNCNAME, b);
 405   *e = tmp;
 406
 407   return ret;
 408 }
 409
 410 /* Get new thread.  */
 411 static struct thread *
 412 thread_get (struct thread_master *m, u_char type,
 413             int (*func) (struct thread *), void *arg, const char* funcname)
 414 {
 415   struct thread *thread;
 416
 417   if (m->unuse.head)
 418     {
 419       thread = thread_trim_head (&m->unuse);
 420       if (thread->funcname)
 421         XFREE(MTYPE_THREAD_FUNCNAME, thread->funcname);
 422     }
 423   else
 424     {
 425       thread = XCALLOC (MTYPE_THREAD, sizeof (struct thread));
 426       m->alloc++;
 427     }
 428   thread->type = type;
 429   thread->add_type = type;
 430   thread->master = m;
 431   thread->func = func;
 432   thread->arg = arg;
 433
 434   thread->funcname = strip_funcname(funcname);
 435
 436   return thread;
 437 }
 438
 439 /* Add new read thread. */
 440 struct thread *
 441 funcname_thread_add_read (struct thread_master *m,
 442                  int (*func) (struct thread *), void *arg, int fd, const char* funcname)
 443 {
 444   struct thread *thread;
 445
 446   assert (m != NULL);
 447
 448   if (FD_ISSET (fd, &m->readfd))
 449     {
 450       zlog (NULL, LOG_WARNING, "There is already read fd [%d]", fd);
 451       return NULL;
 452     }
 453
 454   thread = thread_get (m, THREAD_READ, func, arg, funcname);
 455   FD_SET (fd, &m->readfd);
 456   thread->u.fd = fd;
 457   thread_list_add (&m->read, thread);
 458
 459   return thread;
 460 }
 461
 462 /* Add new write thread. */
 463 struct thread *
 464 funcname_thread_add_write (struct thread_master *m,
 465                  int (*func) (struct thread *), void *arg, int fd, const char* funcname)
 466 {
 467   struct thread *thread;
 468
 469   assert (m != NULL);
 470
 471   if (FD_ISSET (fd, &m->writefd))
 472     {
 473       zlog (NULL, LOG_WARNING, "There is already write fd [%d]", fd);
 474       return NULL;
 475     }
 476
 477   thread = thread_get (m, THREAD_WRITE, func, arg, funcname);
 478   FD_SET (fd, &m->writefd);
 479   thread->u.fd = fd;
 480   thread_list_add (&m->write, thread);
 481
 482   return thread;
 483 }
 484
 485 static struct thread *
 486 funcname_thread_add_timer_timeval (struct thread_master *m,
 487                                    int (*func) (struct thread *),
 488                                   void *arg,
 489                                   struct timeval *time_relative,
 490                                   const char* funcname)
 491 {
 492   struct thread *thread;
 493   struct timeval timer_now;
 494 #ifndef TIMER_NO_SORT
 495   struct thread *tt;
 496 #endif /* TIMER_NO_SORT */
 497
 498   assert (m != NULL);
 499
 500   thread = thread_get (m, THREAD_TIMER, func, arg, funcname);
 501
 502   /* Do we need jitter here? */
 503   gettimeofday (&timer_now, NULL);
 504   timer_now.tv_sec += time_relative->tv_sec;
 505   timer_now.tv_usec += time_relative->tv_usec;
 506   timeval_adjust (timer_now);
 507   thread->u.sands = timer_now;
 508
 509   /* Sort by timeval. */
 510 #ifdef TIMER_NO_SORT
 511   thread_list_add (&m->timer, thread);
 512 #else
 513   for (tt = m->timer.head; tt; tt = tt->next)
 514     if (timeval_cmp (thread->u.sands, tt->u.sands) <= 0)
 515       break;
 516
 517   if (tt)
 518     thread_list_add_before (&m->timer, tt, thread);
 519   else
 520     thread_list_add (&m->timer, thread);
 521 #endif /* TIMER_NO_SORT */
 522
 523   return thread;
 524 }
 525
 526
 527 /* Add timer event thread. */
 528 struct thread *
 529 funcname_thread_add_timer (struct thread_master *m,
 530                            int (*func) (struct thread *),
 531                            void *arg, long timer, const char* funcname)
 532 {
 533   struct timeval trel;
 534
 535   assert (m != NULL);
 536
 537   trel.tv_sec = timer;
 538   trel.tv_usec = 0;
 539
 540   return funcname_thread_add_timer_timeval (m, func, arg, &trel, funcname);
 541 }
 542
 543 /* Add timer event thread with "millisecond" resolution */
 544 struct thread *
 545 funcname_thread_add_timer_msec (struct thread_master *m,
 546                                 int (*func) (struct thread *),
 547                                 void *arg, long timer, const char* funcname)
 548 {
 549   struct timeval trel;
 550
 551   assert (m != NULL);
 552
 553   timer = 1000*timer; /* milli -> micro */
 554
 555   trel.tv_sec = timer / TIMER_SECOND_MICRO;
 556   trel.tv_usec = (timer % TIMER_SECOND_MICRO);
 557
 558   return funcname_thread_add_timer_timeval (m, func, arg, &trel, funcname);
 559 }
 560
 561 /* Add simple event thread. */
 562 struct thread *
 563 funcname_thread_add_event (struct thread_master *m,
 564                   int (*func) (struct thread *), void *arg, int val, const char* funcname)
 565 {
 566   struct thread *thread;
 567
 568   assert (m != NULL);
 569
 570   thread = thread_get (m, THREAD_EVENT, func, arg, funcname);
 571   thread->u.val = val;
 572   thread_list_add (&m->event, thread);
 573
 574   return thread;
 575 }
 576
 577 /* Cancel thread from scheduler. */
 578 void
 579 thread_cancel (struct thread *thread)
 580 {
 581   switch (thread->type)
 582     {
 583     case THREAD_READ:
 584       assert (FD_ISSET (thread->u.fd, &thread->master->readfd));
 585       FD_CLR (thread->u.fd, &thread->master->readfd);
 586       thread_list_delete (&thread->master->read, thread);
 587       break;
 588     case THREAD_WRITE:
 589       assert (FD_ISSET (thread->u.fd, &thread->master->writefd));
 590       FD_CLR (thread->u.fd, &thread->master->writefd);
 591       thread_list_delete (&thread->master->write, thread);
 592       break;
 593     case THREAD_TIMER:
 594       thread_list_delete (&thread->master->timer, thread);
 595       break;
 596     case THREAD_EVENT:
 597       thread_list_delete (&thread->master->event, thread);
 598       break;
 599     case THREAD_READY:
 600       thread_list_delete (&thread->master->ready, thread);
 601       break;
 602     default:
 603       break;
 604     }
 605   thread->type = THREAD_UNUSED;
 606   thread_add_unuse (thread->master, thread);
 607 }
 608
 609 /* Delete all events which has argument value arg. */
 610 void
 611 thread_cancel_event (struct thread_master *m, void *arg)
 612 {
 613   struct thread *thread;
 614
 615   thread = m->event.head;
 616   while (thread)
 617     {
 618       struct thread *t;
 619
 620       t = thread;
 621       thread = t->next;
 622
 623       if (t->arg == arg)
 624         {
 625           thread_list_delete (&m->event, t);
 626           t->type = THREAD_UNUSED;
 627           thread_add_unuse (m, t);
 628         }
 629     }
 630 }
 631
 632 #ifdef TIMER_NO_SORT
 633 struct timeval *
 634 thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
 635 {
 636   struct timeval timer_now;
 637   struct timeval timer_min;
 638   struct timeval *timer_wait;
 639
 640   gettimeofday (&timer_now, NULL);
 641
 642   timer_wait = NULL;
 643   for (thread = m->timer.head; thread; thread = thread->next)
 644     {
 645       if (! timer_wait)
 646         timer_wait = &thread->u.sands;
 647       else if (timeval_cmp (thread->u.sands, *timer_wait) < 0)
 648         timer_wait = &thread->u.sands;
 649     }
 650
 651   if (m->timer.head)
 652     {
 653       timer_min = *timer_wait;
 654       timer_min = timeval_subtract (timer_min, timer_now);
 655       if (timer_min.tv_sec < 0)
 656         {
 657           timer_min.tv_sec = 0;
 658           timer_min.tv_usec = 10;
 659         }
 660       timer_wait = &timer_min;
 661     }
 662   else
 663     timer_wait = NULL;
 664
 665   if (timer_wait)
 666     {
 667       *timer_val = timer_wait;
 668       return timer_val;
 669     }
 670   return NULL;
 671 }
 672 #else /* ! TIMER_NO_SORT */
 673 struct timeval *
 674 thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
 675 {
 676   struct timeval timer_now;
 677   struct timeval timer_min;
 678
 679   if (m->timer.head)
 680     {
 681       gettimeofday (&timer_now, NULL);
 682       timer_min = m->timer.head->u.sands;
 683       timer_min = timeval_subtract (timer_min, timer_now);
 684       if (timer_min.tv_sec < 0)
 685         {
 686           timer_min.tv_sec = 0;
 687           timer_min.tv_usec = 10;
 688         }
 689       *timer_val = timer_min;
 690       return timer_val;
 691     }
 692   return NULL;
 693 }
 694 #endif /* TIMER_NO_SORT */
 695
 696 struct thread *
 697 thread_run (struct thread_master *m, struct thread *thread,
 698             struct thread *fetch)
 699 {
 700   *fetch = *thread;
 701   thread->type = THREAD_UNUSED;
 702   thread_add_unuse (m, thread);
 703   return fetch;
 704 }
 705
 706 int
 707 thread_process_fd (struct thread_master *m, struct thread_list *list,
 708                    fd_set *fdset, fd_set *mfdset)
 709 {
 710   struct thread *thread;
 711   struct thread *next;
 712   int ready = 0;
 713
 714   for (thread = list->head; thread; thread = next)
 715     {
 716       next = thread->next;
 717
 718       if (FD_ISSET (THREAD_FD (thread), fdset))
 719         {
 720           assert (FD_ISSET (THREAD_FD (thread), mfdset));
 721           FD_CLR(THREAD_FD (thread), mfdset);
 722           thread_list_delete (list, thread);
 723           thread_list_add (&m->ready, thread);
 724           thread->type = THREAD_READY;
 725           ready++;
 726         }
 727     }
 728   return ready;
 729 }
 730
 731 /* Fetch next ready thread. */
 732 struct thread *
 733 thread_fetch (struct thread_master *m, struct thread *fetch)
 734 {
 735   int num;
 736   int ready;
 737   struct thread *thread;
 738   fd_set readfd;
 739   fd_set writefd;
 740   fd_set exceptfd;
 741   struct timeval timer_now;
 742   struct timeval timer_val;
 743   struct timeval *timer_wait;
 744   struct timeval timer_nowait;
 745
 746   timer_nowait.tv_sec = 0;
 747   timer_nowait.tv_usec = 0;
 748
 749   while (1)
 750     {
 751       /* Signals are highest priority */
 752       quagga_sigevent_process ();
 753
 754       /* Normal event are the next highest priority.  */
 755       if ((thread = thread_trim_head (&m->event)) != NULL)
 756         return thread_run (m, thread, fetch);
 757
 758       /* Execute timer.  */
 759       gettimeofday (&timer_now, NULL);
 760
 761       for (thread = m->timer.head; thread; thread = thread->next)
 762         if (timeval_cmp (timer_now, thread->u.sands) >= 0)
 763           {
 764             thread_list_delete (&m->timer, thread);
 765             return thread_run (m, thread, fetch);
 766           }
 767
 768       /* If there are any ready threads, process top of them.  */
 769       if ((thread = thread_trim_head (&m->ready)) != NULL)
 770         return thread_run (m, thread, fetch);
 771
 772       /* Structure copy.  */
 773       readfd = m->readfd;
 774       writefd = m->writefd;
 775       exceptfd = m->exceptfd;
 776
 777       /* Calculate select wait timer. */
 778       timer_wait = thread_timer_wait (m, &timer_val);
 779
 780       num = select (FD_SETSIZE, &readfd, &writefd, &exceptfd, timer_wait);
 781
 782       if (num == 0)
 783         continue;
 784
 785       if (num < 0)
 786         {
 787           if (errno == EINTR)
 788             {
 789               /* signal received */
 790               quagga_sigevent_process ();
 791               continue;
 792             }
 793
 794           zlog_warn ("select() error: %s", safe_strerror (errno));
 795             return NULL;
 796         }
 797
 798       /* Normal priority read thead. */
 799       ready = thread_process_fd (m, &m->read, &readfd, &m->readfd);
 800
 801       /* Write thead. */
 802       ready = thread_process_fd (m, &m->write, &writefd, &m->writefd);
 803
 804       if ((thread = thread_trim_head (&m->ready)) != NULL)
 805         return thread_run (m, thread, fetch);
 806     }
 807 }
 808
 809 static unsigned long
 810 thread_consumed_time (RUSAGE_T *now, RUSAGE_T *start)
 811 {
 812   unsigned long thread_time;
 813
 814 #ifdef HAVE_RUSAGE
 815   /* This is 'user + sys' time.  */
 816   thread_time = timeval_elapsed (now->ru_utime, start->ru_utime);
 817   thread_time += timeval_elapsed (now->ru_stime, start->ru_stime);
 818 #else
 819   /* When rusage is not available, simple elapsed time is used.  */
 820   thread_time = timeval_elapsed (*now, *start);
 821 #endif /* HAVE_RUSAGE */
 822
 823   return thread_time;
 824 }
 825
 826 /* We should aim to yield after THREAD_YIELD_TIME_SLOT
 827    milliseconds.  */
 828 int
 829 thread_should_yield (struct thread *thread)
 830 {
 831   RUSAGE_T ru;
 832
 833   GETRUSAGE (&ru);
 834
 835   if (thread_consumed_time (&ru, &thread->ru) > THREAD_YIELD_TIME_SLOT)
 836     return 1;
 837   else
 838     return 0;
 839 }
 840
 841 /* We check thread consumed time. If the system has getrusage, we'll
 842    use that to get indepth stats on the performance of the thread.  If
 843    not - we'll use gettimeofday for some guestimation.  */
 844 void
 845 thread_call (struct thread *thread)
 846 {
 847   unsigned long thread_time;
 848   RUSAGE_T ru;
 849   struct cpu_thread_history tmp, *cpu;
 850
 851   tmp.func = thread->func;
 852   tmp.funcname = thread->funcname;
 853   cpu = hash_get(cpu_record, &tmp, cpu_record_hash_alloc);
 854
 855   GETRUSAGE (&thread->ru);
 856
 857   (*thread->func) (thread);
 858
 859   GETRUSAGE (&ru);
 860
 861   thread_time = thread_consumed_time (&ru, &thread->ru);
 862   cpu->total += thread_time;
 863   if (cpu->max < thread_time)
 864     cpu->max = thread_time;
 865
 866   ++cpu->total_calls;
 867   cpu->types |= (1 << thread->add_type);
 868
 869 #ifdef THREAD_CONSUMED_TIME_CHECK
 870   if (thread_time > 200000L)
 871     {
 872       /*
 873        * We have a CPU Hog on our hands.
 874        * Whinge about it now, so we're aware this is yet another task
 875        * to fix.
 876        */
 877       zlog_err ("CPU HOG task %s (%lx) ran for %ldms",
 878                 thread->funcname,
 879                 (unsigned long) thread->func,
 880                 thread_time / 1000L);
 881     }
 882 #endif /* THREAD_CONSUMED_TIME_CHECK */
 883 }
 884
 885 /* Execute thread */
 886 struct thread *
 887 funcname_thread_execute (struct thread_master *m,
 888                 int (*func)(struct thread *),
 889                 void *arg,
 890                 int val,
 891                 const char* funcname)
 892 {
 893   struct thread dummy;
 894
 895   memset (&dummy, 0, sizeof (struct thread));
 896
 897   dummy.type = THREAD_EVENT;
 898   dummy.add_type = THREAD_EXECUTE;
 899   dummy.master = NULL;
 900   dummy.func = func;
 901   dummy.arg = arg;
 902   dummy.u.val = val;
 903   dummy.funcname = strip_funcname (funcname);
 904   thread_call (&dummy);
 905
 906   XFREE (MTYPE_THREAD_FUNCNAME, dummy.funcname);
 907
 908   return NULL;
 909 }