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:
33: /* Recent absolute time of day */
34: struct timeval recent_time;
35: static struct timeval last_recent_time;
36: /* Relative time, since startup */
37: static struct timeval relative_time;
38: static struct timeval relative_time_base;
39: /* init flag */
40: static unsigned short timers_inited;
41:
42: static struct hash *cpu_record = NULL;
43:
44: /* Struct timeval's tv_usec one second value. */
45: #define TIMER_SECOND_MICRO 1000000L
46:
47: /* Adjust so that tv_usec is in the range [0,TIMER_SECOND_MICRO).
48: And change negative values to 0. */
49: static struct timeval
50: timeval_adjust (struct timeval a)
51: {
52: while (a.tv_usec >= TIMER_SECOND_MICRO)
53: {
54: a.tv_usec -= TIMER_SECOND_MICRO;
55: a.tv_sec++;
56: }
57:
58: while (a.tv_usec < 0)
59: {
60: a.tv_usec += TIMER_SECOND_MICRO;
61: a.tv_sec--;
62: }
63:
64: if (a.tv_sec < 0)
65: /* Change negative timeouts to 0. */
66: a.tv_sec = a.tv_usec = 0;
67:
68: return a;
69: }
70:
71: static struct timeval
72: timeval_subtract (struct timeval a, struct timeval b)
73: {
74: struct timeval ret;
75:
76: ret.tv_usec = a.tv_usec - b.tv_usec;
77: ret.tv_sec = a.tv_sec - b.tv_sec;
78:
79: return timeval_adjust (ret);
80: }
81:
82: static long
83: timeval_cmp (struct timeval a, struct timeval b)
84: {
85: return (a.tv_sec == b.tv_sec
86: ? a.tv_usec - b.tv_usec : a.tv_sec - b.tv_sec);
87: }
88:
89: static unsigned long
90: timeval_elapsed (struct timeval a, struct timeval b)
91: {
92: return (((a.tv_sec - b.tv_sec) * TIMER_SECOND_MICRO)
93: + (a.tv_usec - b.tv_usec));
94: }
95:
96: #ifndef HAVE_CLOCK_MONOTONIC
97: static void
98: quagga_gettimeofday_relative_adjust (void)
99: {
100: struct timeval diff;
101: if (timeval_cmp (recent_time, last_recent_time) < 0)
102: {
103: relative_time.tv_sec++;
104: relative_time.tv_usec = 0;
105: }
106: else
107: {
108: diff = timeval_subtract (recent_time, last_recent_time);
109: relative_time.tv_sec += diff.tv_sec;
110: relative_time.tv_usec += diff.tv_usec;
111: relative_time = timeval_adjust (relative_time);
112: }
113: last_recent_time = recent_time;
114: }
115: #endif /* !HAVE_CLOCK_MONOTONIC */
116:
117: /* gettimeofday wrapper, to keep recent_time updated */
118: static int
119: quagga_gettimeofday (struct timeval *tv)
120: {
121: int ret;
122:
123: assert (tv);
124:
125: if (!(ret = gettimeofday (&recent_time, NULL)))
126: {
127: /* init... */
128: if (!timers_inited)
129: {
130: relative_time_base = last_recent_time = recent_time;
131: timers_inited = 1;
132: }
133: /* avoid copy if user passed recent_time pointer.. */
134: if (tv != &recent_time)
135: *tv = recent_time;
136: return 0;
137: }
138: return ret;
139: }
140:
141: static int
142: quagga_get_relative (struct timeval *tv)
143: {
144: int ret;
145:
146: #ifdef HAVE_CLOCK_MONOTONIC
147: {
148: struct timespec tp;
149: if (!(ret = clock_gettime (CLOCK_MONOTONIC, &tp)))
150: {
151: relative_time.tv_sec = tp.tv_sec;
152: relative_time.tv_usec = tp.tv_nsec / 1000;
153: }
154: }
155: #else /* !HAVE_CLOCK_MONOTONIC */
156: if (!(ret = quagga_gettimeofday (&recent_time)))
157: quagga_gettimeofday_relative_adjust();
158: #endif /* HAVE_CLOCK_MONOTONIC */
159:
160: if (tv)
161: *tv = relative_time;
162:
163: return ret;
164: }
165:
166: /* Get absolute time stamp, but in terms of the internal timer
167: * Could be wrong, but at least won't go back.
168: */
169: static void
170: quagga_real_stabilised (struct timeval *tv)
171: {
172: *tv = relative_time_base;
173: tv->tv_sec += relative_time.tv_sec;
174: tv->tv_usec += relative_time.tv_usec;
175: *tv = timeval_adjust (*tv);
176: }
177:
178: /* Exported Quagga timestamp function.
179: * Modelled on POSIX clock_gettime.
180: */
181: int
182: quagga_gettime (enum quagga_clkid clkid, struct timeval *tv)
183: {
184: switch (clkid)
185: {
186: case QUAGGA_CLK_REALTIME:
187: return quagga_gettimeofday (tv);
188: case QUAGGA_CLK_MONOTONIC:
189: return quagga_get_relative (tv);
190: case QUAGGA_CLK_REALTIME_STABILISED:
191: quagga_real_stabilised (tv);
192: return 0;
193: default:
194: errno = EINVAL;
195: return -1;
196: }
197: }
198:
199: /* time_t value in terms of stabilised absolute time.
200: * replacement for POSIX time()
201: */
202: time_t
203: quagga_time (time_t *t)
204: {
205: struct timeval tv;
206: quagga_real_stabilised (&tv);
207: if (t)
208: *t = tv.tv_sec;
209: return tv.tv_sec;
210: }
211:
212: /* Public export of recent_relative_time by value */
213: struct timeval
214: recent_relative_time (void)
215: {
216: return relative_time;
217: }
218:
219: static unsigned int
220: cpu_record_hash_key (struct cpu_thread_history *a)
221: {
222: return (uintptr_t) a->func;
223: }
224:
225: static int
226: cpu_record_hash_cmp (const struct cpu_thread_history *a,
227: const struct cpu_thread_history *b)
228: {
229: return a->func == b->func;
230: }
231:
232: static void *
233: cpu_record_hash_alloc (struct cpu_thread_history *a)
234: {
235: struct cpu_thread_history *new;
236: new = XCALLOC (MTYPE_THREAD_STATS, sizeof (struct cpu_thread_history));
237: new->func = a->func;
238: new->funcname = XSTRDUP(MTYPE_THREAD_FUNCNAME, a->funcname);
239: return new;
240: }
241:
242: static void
243: cpu_record_hash_free (void *a)
244: {
245: struct cpu_thread_history *hist = a;
246:
247: XFREE (MTYPE_THREAD_FUNCNAME, hist->funcname);
248: XFREE (MTYPE_THREAD_STATS, hist);
249: }
250:
251: static inline void
252: vty_out_cpu_thread_history(struct vty* vty,
253: struct cpu_thread_history *a)
254: {
255: #ifdef HAVE_RUSAGE
256: vty_out(vty, "%7ld.%03ld %9d %8ld %9ld %8ld %9ld",
257: a->cpu.total/1000, a->cpu.total%1000, a->total_calls,
258: a->cpu.total/a->total_calls, a->cpu.max,
259: a->real.total/a->total_calls, a->real.max);
260: #else
261: vty_out(vty, "%7ld.%03ld %9d %8ld %9ld",
262: a->real.total/1000, a->real.total%1000, a->total_calls,
263: a->real.total/a->total_calls, a->real.max);
264: #endif
265: vty_out(vty, " %c%c%c%c%c%c %s%s",
266: a->types & (1 << THREAD_READ) ? 'R':' ',
267: a->types & (1 << THREAD_WRITE) ? 'W':' ',
268: a->types & (1 << THREAD_TIMER) ? 'T':' ',
269: a->types & (1 << THREAD_EVENT) ? 'E':' ',
270: a->types & (1 << THREAD_EXECUTE) ? 'X':' ',
271: a->types & (1 << THREAD_BACKGROUND) ? 'B' : ' ',
272: a->funcname, VTY_NEWLINE);
273: }
274:
275: static void
276: cpu_record_hash_print(struct hash_backet *bucket,
277: void *args[])
278: {
279: struct cpu_thread_history *totals = args[0];
280: struct vty *vty = args[1];
281: thread_type *filter = args[2];
282: struct cpu_thread_history *a = bucket->data;
283:
284: a = bucket->data;
285: if ( !(a->types & *filter) )
286: return;
287: vty_out_cpu_thread_history(vty,a);
288: totals->total_calls += a->total_calls;
289: totals->real.total += a->real.total;
290: if (totals->real.max < a->real.max)
291: totals->real.max = a->real.max;
292: #ifdef HAVE_RUSAGE
293: totals->cpu.total += a->cpu.total;
294: if (totals->cpu.max < a->cpu.max)
295: totals->cpu.max = a->cpu.max;
296: #endif
297: }
298:
299: static void
300: cpu_record_print(struct vty *vty, thread_type filter)
301: {
302: struct cpu_thread_history tmp;
303: void *args[3] = {&tmp, vty, &filter};
304:
305: memset(&tmp, 0, sizeof tmp);
306: tmp.funcname = (char *)"TOTAL";
307: tmp.types = filter;
308:
309: #ifdef HAVE_RUSAGE
310: vty_out(vty, "%21s %18s %18s%s",
311: "", "CPU (user+system):", "Real (wall-clock):", VTY_NEWLINE);
312: #endif
313: vty_out(vty, "Runtime(ms) Invoked Avg uSec Max uSecs");
314: #ifdef HAVE_RUSAGE
315: vty_out(vty, " Avg uSec Max uSecs");
316: #endif
317: vty_out(vty, " Type Thread%s", VTY_NEWLINE);
318: hash_iterate(cpu_record,
319: (void(*)(struct hash_backet*,void*))cpu_record_hash_print,
320: args);
321:
322: if (tmp.total_calls > 0)
323: vty_out_cpu_thread_history(vty, &tmp);
324: }
325:
326: DEFUN(show_thread_cpu,
327: show_thread_cpu_cmd,
328: "show thread cpu [FILTER]",
329: SHOW_STR
330: "Thread information\n"
331: "Thread CPU usage\n"
332: "Display filter (rwtexb)\n")
333: {
334: int i = 0;
335: thread_type filter = (thread_type) -1U;
336:
337: if (argc > 0)
338: {
339: filter = 0;
340: while (argv[0][i] != '\0')
341: {
342: switch ( argv[0][i] )
343: {
344: case 'r':
345: case 'R':
346: filter |= (1 << THREAD_READ);
347: break;
348: case 'w':
349: case 'W':
350: filter |= (1 << THREAD_WRITE);
351: break;
352: case 't':
353: case 'T':
354: filter |= (1 << THREAD_TIMER);
355: break;
356: case 'e':
357: case 'E':
358: filter |= (1 << THREAD_EVENT);
359: break;
360: case 'x':
361: case 'X':
362: filter |= (1 << THREAD_EXECUTE);
363: break;
364: case 'b':
365: case 'B':
366: filter |= (1 << THREAD_BACKGROUND);
367: break;
368: default:
369: break;
370: }
371: ++i;
372: }
373: if (filter == 0)
374: {
375: vty_out(vty, "Invalid filter \"%s\" specified,"
376: " must contain at least one of 'RWTEXB'%s",
377: argv[0], VTY_NEWLINE);
378: return CMD_WARNING;
379: }
380: }
381:
382: cpu_record_print(vty, filter);
383: return CMD_SUCCESS;
384: }
385:
386: static void
387: cpu_record_hash_clear (struct hash_backet *bucket,
388: void *args)
389: {
390: thread_type *filter = args;
391: struct cpu_thread_history *a = bucket->data;
392:
393: a = bucket->data;
394: if ( !(a->types & *filter) )
395: return;
396:
397: hash_release (cpu_record, bucket->data);
398: }
399:
400: static void
401: cpu_record_clear (thread_type filter)
402: {
403: thread_type *tmp = &filter;
404: hash_iterate (cpu_record,
405: (void (*) (struct hash_backet*,void*)) cpu_record_hash_clear,
406: tmp);
407: }
408:
409: DEFUN(clear_thread_cpu,
410: clear_thread_cpu_cmd,
411: "clear thread cpu [FILTER]",
412: "Clear stored data\n"
413: "Thread information\n"
414: "Thread CPU usage\n"
415: "Display filter (rwtexb)\n")
416: {
417: int i = 0;
418: thread_type filter = (thread_type) -1U;
419:
420: if (argc > 0)
421: {
422: filter = 0;
423: while (argv[0][i] != '\0')
424: {
425: switch ( argv[0][i] )
426: {
427: case 'r':
428: case 'R':
429: filter |= (1 << THREAD_READ);
430: break;
431: case 'w':
432: case 'W':
433: filter |= (1 << THREAD_WRITE);
434: break;
435: case 't':
436: case 'T':
437: filter |= (1 << THREAD_TIMER);
438: break;
439: case 'e':
440: case 'E':
441: filter |= (1 << THREAD_EVENT);
442: break;
443: case 'x':
444: case 'X':
445: filter |= (1 << THREAD_EXECUTE);
446: break;
447: case 'b':
448: case 'B':
449: filter |= (1 << THREAD_BACKGROUND);
450: break;
451: default:
452: break;
453: }
454: ++i;
455: }
456: if (filter == 0)
457: {
458: vty_out(vty, "Invalid filter \"%s\" specified,"
459: " must contain at least one of 'RWTEXB'%s",
460: argv[0], VTY_NEWLINE);
461: return CMD_WARNING;
462: }
463: }
464:
465: cpu_record_clear (filter);
466: return CMD_SUCCESS;
467: }
468:
469: /* List allocation and head/tail print out. */
470: static void
471: thread_list_debug (struct thread_list *list)
472: {
473: printf ("count [%d] head [%p] tail [%p]\n",
474: list->count, list->head, list->tail);
475: }
476:
477: /* Debug print for thread_master. */
478: static void __attribute__ ((unused))
479: thread_master_debug (struct thread_master *m)
480: {
481: printf ("-----------\n");
482: printf ("readlist : ");
483: thread_list_debug (&m->read);
484: printf ("writelist : ");
485: thread_list_debug (&m->write);
486: printf ("timerlist : ");
487: thread_list_debug (&m->timer);
488: printf ("eventlist : ");
489: thread_list_debug (&m->event);
490: printf ("unuselist : ");
491: thread_list_debug (&m->unuse);
492: printf ("bgndlist : ");
493: thread_list_debug (&m->background);
494: printf ("total alloc: [%ld]\n", m->alloc);
495: printf ("-----------\n");
496: }
497:
498: /* Allocate new thread master. */
499: struct thread_master *
500: thread_master_create ()
501: {
502: if (cpu_record == NULL)
503: cpu_record
504: = hash_create_size (1011, (unsigned int (*) (void *))cpu_record_hash_key,
505: (int (*) (const void *, const void *))cpu_record_hash_cmp);
506:
507: return (struct thread_master *) XCALLOC (MTYPE_THREAD_MASTER,
508: sizeof (struct thread_master));
509: }
510:
511: /* Add a new thread to the list. */
512: static void
513: thread_list_add (struct thread_list *list, struct thread *thread)
514: {
515: thread->next = NULL;
516: thread->prev = list->tail;
517: if (list->tail)
518: list->tail->next = thread;
519: else
520: list->head = thread;
521: list->tail = thread;
522: list->count++;
523: }
524:
525: /* Add a new thread just before the point. */
526: static void
527: thread_list_add_before (struct thread_list *list,
528: struct thread *point,
529: struct thread *thread)
530: {
531: thread->next = point;
532: thread->prev = point->prev;
533: if (point->prev)
534: point->prev->next = thread;
535: else
536: list->head = thread;
537: point->prev = thread;
538: list->count++;
539: }
540:
541: /* Delete a thread from the list. */
542: static struct thread *
543: thread_list_delete (struct thread_list *list, struct thread *thread)
544: {
545: if (thread->next)
546: thread->next->prev = thread->prev;
547: else
548: list->tail = thread->prev;
549: if (thread->prev)
550: thread->prev->next = thread->next;
551: else
552: list->head = thread->next;
553: thread->next = thread->prev = NULL;
554: list->count--;
555: return thread;
556: }
557:
558: /* Move thread to unuse list. */
559: static void
560: thread_add_unuse (struct thread_master *m, struct thread *thread)
561: {
562: assert (m != NULL && thread != NULL);
563: assert (thread->next == NULL);
564: assert (thread->prev == NULL);
565: assert (thread->type == THREAD_UNUSED);
566: thread_list_add (&m->unuse, thread);
567: /* XXX: Should we deallocate funcname here? */
568: }
569:
570: /* Free all unused thread. */
571: static void
572: thread_list_free (struct thread_master *m, struct thread_list *list)
573: {
574: struct thread *t;
575: struct thread *next;
576:
577: for (t = list->head; t; t = next)
578: {
579: next = t->next;
580: if (t->funcname)
581: XFREE (MTYPE_THREAD_FUNCNAME, t->funcname);
582: XFREE (MTYPE_THREAD, t);
583: list->count--;
584: m->alloc--;
585: }
586: }
587:
588: /* Stop thread scheduler. */
589: void
590: thread_master_free (struct thread_master *m)
591: {
592: thread_list_free (m, &m->read);
593: thread_list_free (m, &m->write);
594: thread_list_free (m, &m->timer);
595: thread_list_free (m, &m->event);
596: thread_list_free (m, &m->ready);
597: thread_list_free (m, &m->unuse);
598: thread_list_free (m, &m->background);
599:
600: XFREE (MTYPE_THREAD_MASTER, m);
601:
602: if (cpu_record)
603: {
604: hash_clean (cpu_record, cpu_record_hash_free);
605: hash_free (cpu_record);
606: cpu_record = NULL;
607: }
608: }
609:
610: /* Thread list is empty or not. */
611: static inline int
612: thread_empty (struct thread_list *list)
613: {
614: return list->head ? 0 : 1;
615: }
616:
617: /* Delete top of the list and return it. */
618: static struct thread *
619: thread_trim_head (struct thread_list *list)
620: {
621: if (!thread_empty (list))
622: return thread_list_delete (list, list->head);
623: return NULL;
624: }
625:
626: /* Return remain time in second. */
627: unsigned long
628: thread_timer_remain_second (struct thread *thread)
629: {
630: quagga_get_relative (NULL);
631:
632: if (thread->u.sands.tv_sec - relative_time.tv_sec > 0)
633: return thread->u.sands.tv_sec - relative_time.tv_sec;
634: else
635: return 0;
636: }
637:
638: /* Trim blankspace and "()"s */
639: static char *
640: strip_funcname (const char *funcname)
641: {
642: char buff[100];
643: char tmp, *ret, *e, *b = buff;
644:
645: strncpy(buff, funcname, sizeof(buff));
646: buff[ sizeof(buff) -1] = '\0';
647: e = buff +strlen(buff) -1;
648:
649: /* Wont work for funcname == "Word (explanation)" */
650:
651: while (*b == ' ' || *b == '(')
652: ++b;
653: while (*e == ' ' || *e == ')')
654: --e;
655: e++;
656:
657: tmp = *e;
658: *e = '\0';
659: ret = XSTRDUP (MTYPE_THREAD_FUNCNAME, b);
660: *e = tmp;
661:
662: return ret;
663: }
664:
665: /* Get new thread. */
666: static struct thread *
667: thread_get (struct thread_master *m, u_char type,
668: int (*func) (struct thread *), void *arg, const char* funcname)
669: {
670: struct thread *thread;
671:
672: if (!thread_empty (&m->unuse))
673: {
674: thread = thread_trim_head (&m->unuse);
675: if (thread->funcname)
676: XFREE(MTYPE_THREAD_FUNCNAME, thread->funcname);
677: }
678: else
679: {
680: thread = XCALLOC (MTYPE_THREAD, sizeof (struct thread));
681: m->alloc++;
682: }
683: thread->type = type;
684: thread->add_type = type;
685: thread->master = m;
686: thread->func = func;
687: thread->arg = arg;
688:
689: thread->funcname = strip_funcname(funcname);
690:
691: return thread;
692: }
693:
694: /* Add new read thread. */
695: struct thread *
696: funcname_thread_add_read (struct thread_master *m,
697: int (*func) (struct thread *), void *arg, int fd, const char* funcname)
698: {
699: struct thread *thread;
700:
701: assert (m != NULL);
702:
703: if (FD_ISSET (fd, &m->readfd))
704: {
705: zlog (NULL, LOG_WARNING, "There is already read fd [%d]", fd);
706: return NULL;
707: }
708:
709: thread = thread_get (m, THREAD_READ, func, arg, funcname);
710: FD_SET (fd, &m->readfd);
711: thread->u.fd = fd;
712: thread_list_add (&m->read, thread);
713:
714: return thread;
715: }
716:
717: /* Add new write thread. */
718: struct thread *
719: funcname_thread_add_write (struct thread_master *m,
720: int (*func) (struct thread *), void *arg, int fd, const char* funcname)
721: {
722: struct thread *thread;
723:
724: assert (m != NULL);
725:
726: if (FD_ISSET (fd, &m->writefd))
727: {
728: zlog (NULL, LOG_WARNING, "There is already write fd [%d]", fd);
729: return NULL;
730: }
731:
732: thread = thread_get (m, THREAD_WRITE, func, arg, funcname);
733: FD_SET (fd, &m->writefd);
734: thread->u.fd = fd;
735: thread_list_add (&m->write, thread);
736:
737: return thread;
738: }
739:
740: static struct thread *
741: funcname_thread_add_timer_timeval (struct thread_master *m,
742: int (*func) (struct thread *),
743: int type,
744: void *arg,
745: struct timeval *time_relative,
746: const char* funcname)
747: {
748: struct thread *thread;
749: struct thread_list *list;
750: struct timeval alarm_time;
751: struct thread *tt;
752:
753: assert (m != NULL);
754:
755: assert (type == THREAD_TIMER || type == THREAD_BACKGROUND);
756: assert (time_relative);
757:
758: list = ((type == THREAD_TIMER) ? &m->timer : &m->background);
759: thread = thread_get (m, type, func, arg, funcname);
760:
761: /* Do we need jitter here? */
762: quagga_get_relative (NULL);
763: alarm_time.tv_sec = relative_time.tv_sec + time_relative->tv_sec;
764: alarm_time.tv_usec = relative_time.tv_usec + time_relative->tv_usec;
765: thread->u.sands = timeval_adjust(alarm_time);
766:
767: /* Sort by timeval. */
768: for (tt = list->head; tt; tt = tt->next)
769: if (timeval_cmp (thread->u.sands, tt->u.sands) <= 0)
770: break;
771:
772: if (tt)
773: thread_list_add_before (list, tt, thread);
774: else
775: thread_list_add (list, thread);
776:
777: return thread;
778: }
779:
780:
781: /* Add timer event thread. */
782: struct thread *
783: funcname_thread_add_timer (struct thread_master *m,
784: int (*func) (struct thread *),
785: void *arg, long timer, const char* funcname)
786: {
787: struct timeval trel;
788:
789: assert (m != NULL);
790:
791: trel.tv_sec = timer;
792: trel.tv_usec = 0;
793:
794: return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg,
795: &trel, funcname);
796: }
797:
798: /* Add timer event thread with "millisecond" resolution */
799: struct thread *
800: funcname_thread_add_timer_msec (struct thread_master *m,
801: int (*func) (struct thread *),
802: void *arg, long timer, const char* funcname)
803: {
804: struct timeval trel;
805:
806: assert (m != NULL);
807:
808: trel.tv_sec = timer / 1000;
809: trel.tv_usec = 1000*(timer % 1000);
810:
811: return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER,
812: arg, &trel, funcname);
813: }
814:
815: /* Add a background thread, with an optional millisec delay */
816: struct thread *
817: funcname_thread_add_background (struct thread_master *m,
818: int (*func) (struct thread *),
819: void *arg, long delay,
820: const char *funcname)
821: {
822: struct timeval trel;
823:
824: assert (m != NULL);
825:
826: if (delay)
827: {
828: trel.tv_sec = delay / 1000;
829: trel.tv_usec = 1000*(delay % 1000);
830: }
831: else
832: {
833: trel.tv_sec = 0;
834: trel.tv_usec = 0;
835: }
836:
837: return funcname_thread_add_timer_timeval (m, func, THREAD_BACKGROUND,
838: arg, &trel, funcname);
839: }
840:
841: /* Add simple event thread. */
842: struct thread *
843: funcname_thread_add_event (struct thread_master *m,
844: int (*func) (struct thread *), void *arg, int val, const char* funcname)
845: {
846: struct thread *thread;
847:
848: assert (m != NULL);
849:
850: thread = thread_get (m, THREAD_EVENT, func, arg, funcname);
851: thread->u.val = val;
852: thread_list_add (&m->event, thread);
853:
854: return thread;
855: }
856:
857: /* Cancel thread from scheduler. */
858: void
859: thread_cancel (struct thread *thread)
860: {
861: struct thread_list *list;
862:
863: switch (thread->type)
864: {
865: case THREAD_READ:
866: assert (FD_ISSET (thread->u.fd, &thread->master->readfd));
867: FD_CLR (thread->u.fd, &thread->master->readfd);
868: list = &thread->master->read;
869: break;
870: case THREAD_WRITE:
871: assert (FD_ISSET (thread->u.fd, &thread->master->writefd));
872: FD_CLR (thread->u.fd, &thread->master->writefd);
873: list = &thread->master->write;
874: break;
875: case THREAD_TIMER:
876: list = &thread->master->timer;
877: break;
878: case THREAD_EVENT:
879: list = &thread->master->event;
880: break;
881: case THREAD_READY:
882: list = &thread->master->ready;
883: break;
884: case THREAD_BACKGROUND:
885: list = &thread->master->background;
886: break;
887: default:
888: return;
889: break;
890: }
891: thread_list_delete (list, thread);
892: thread->type = THREAD_UNUSED;
893: thread_add_unuse (thread->master, thread);
894: }
895:
896: /* Delete all events which has argument value arg. */
897: unsigned int
898: thread_cancel_event (struct thread_master *m, void *arg)
899: {
900: unsigned int ret = 0;
901: struct thread *thread;
902:
903: thread = m->event.head;
904: while (thread)
905: {
906: struct thread *t;
907:
908: t = thread;
909: thread = t->next;
910:
911: if (t->arg == arg)
912: {
913: ret++;
914: thread_list_delete (&m->event, t);
915: t->type = THREAD_UNUSED;
916: thread_add_unuse (m, t);
917: }
918: }
919: return ret;
920: }
921:
922: static struct timeval *
923: thread_timer_wait (struct thread_list *tlist, struct timeval *timer_val)
924: {
925: if (!thread_empty (tlist))
926: {
927: *timer_val = timeval_subtract (tlist->head->u.sands, relative_time);
928: return timer_val;
929: }
930: return NULL;
931: }
932:
933: static struct thread *
934: thread_run (struct thread_master *m, struct thread *thread,
935: struct thread *fetch)
936: {
937: *fetch = *thread;
938: thread->type = THREAD_UNUSED;
939: thread->funcname = NULL; /* thread_call will free fetch's copied pointer */
940: thread_add_unuse (m, thread);
941: return fetch;
942: }
943:
944: static int
945: thread_process_fd (struct thread_list *list, fd_set *fdset, fd_set *mfdset)
946: {
947: struct thread *thread;
948: struct thread *next;
949: int ready = 0;
950:
951: assert (list);
952:
953: for (thread = list->head; thread; thread = next)
954: {
955: next = thread->next;
956:
957: if (FD_ISSET (THREAD_FD (thread), fdset))
958: {
959: assert (FD_ISSET (THREAD_FD (thread), mfdset));
960: FD_CLR(THREAD_FD (thread), mfdset);
961: thread_list_delete (list, thread);
962: thread_list_add (&thread->master->ready, thread);
963: thread->type = THREAD_READY;
964: ready++;
965: }
966: }
967: return ready;
968: }
969:
970: /* Add all timers that have popped to the ready list. */
971: static unsigned int
972: thread_timer_process (struct thread_list *list, struct timeval *timenow)
973: {
974: struct thread *thread;
975: unsigned int ready = 0;
976:
977: for (thread = list->head; thread; thread = thread->next)
978: {
979: if (timeval_cmp (*timenow, thread->u.sands) < 0)
980: return ready;
981: thread_list_delete (list, thread);
982: thread->type = THREAD_READY;
983: thread_list_add (&thread->master->ready, thread);
984: ready++;
985: }
986: return ready;
987: }
988:
989: /* process a list en masse, e.g. for event thread lists */
990: static unsigned int
991: thread_process (struct thread_list *list)
992: {
993: struct thread *thread;
994: unsigned int ready = 0;
995:
996: for (thread = list->head; thread; thread = thread->next)
997: {
998: thread_list_delete (list, thread);
999: thread->type = THREAD_READY;
1000: thread_list_add (&thread->master->ready, thread);
1001: ready++;
1002: }
1003: return ready;
1004: }
1005:
1006:
1007: /* Fetch next ready thread. */
1008: struct thread *
1009: thread_fetch (struct thread_master *m, struct thread *fetch)
1010: {
1011: struct thread *thread;
1012: fd_set readfd;
1013: fd_set writefd;
1014: fd_set exceptfd;
1015: struct timeval timer_val = { .tv_sec = 0, .tv_usec = 0 };
1016: struct timeval timer_val_bg;
1017: struct timeval *timer_wait = &timer_val;
1018: struct timeval *timer_wait_bg;
1019:
1020: while (1)
1021: {
1022: int num = 0;
1023:
1024: /* Signals pre-empt everything */
1025: quagga_sigevent_process ();
1026:
1027: /* Drain the ready queue of already scheduled jobs, before scheduling
1028: * more.
1029: */
1030: if ((thread = thread_trim_head (&m->ready)) != NULL)
1031: return thread_run (m, thread, fetch);
1032:
1033: /* To be fair to all kinds of threads, and avoid starvation, we
1034: * need to be careful to consider all thread types for scheduling
1035: * in each quanta. I.e. we should not return early from here on.
1036: */
1037:
1038: /* Normal event are the next highest priority. */
1039: thread_process (&m->event);
1040:
1041: /* Structure copy. */
1042: readfd = m->readfd;
1043: writefd = m->writefd;
1044: exceptfd = m->exceptfd;
1045:
1046: /* Calculate select wait timer if nothing else to do */
1047: if (m->ready.count == 0)
1048: {
1049: quagga_get_relative (NULL);
1050: timer_wait = thread_timer_wait (&m->timer, &timer_val);
1051: timer_wait_bg = thread_timer_wait (&m->background, &timer_val_bg);
1052:
1053: if (timer_wait_bg &&
1054: (!timer_wait || (timeval_cmp (*timer_wait, *timer_wait_bg) > 0)))
1055: timer_wait = timer_wait_bg;
1056: }
1057:
1058: num = select (FD_SETSIZE, &readfd, &writefd, &exceptfd, timer_wait);
1059:
1060: /* Signals should get quick treatment */
1061: if (num < 0)
1062: {
1063: if (errno == EINTR)
1064: continue; /* signal received - process it */
1065: zlog_warn ("select() error: %s", safe_strerror (errno));
1066: return NULL;
1067: }
1068:
1069: /* Check foreground timers. Historically, they have had higher
1070: priority than I/O threads, so let's push them onto the ready
1071: list in front of the I/O threads. */
1072: quagga_get_relative (NULL);
1073: thread_timer_process (&m->timer, &relative_time);
1074:
1075: /* Got IO, process it */
1076: if (num > 0)
1077: {
1078: /* Normal priority read thead. */
1079: thread_process_fd (&m->read, &readfd, &m->readfd);
1080: /* Write thead. */
1081: thread_process_fd (&m->write, &writefd, &m->writefd);
1082: }
1083:
1084: #if 0
1085: /* If any threads were made ready above (I/O or foreground timer),
1086: perhaps we should avoid adding background timers to the ready
1087: list at this time. If this is code is uncommented, then background
1088: timer threads will not run unless there is nothing else to do. */
1089: if ((thread = thread_trim_head (&m->ready)) != NULL)
1090: return thread_run (m, thread, fetch);
1091: #endif
1092:
1093: /* Background timer/events, lowest priority */
1094: thread_timer_process (&m->background, &relative_time);
1095:
1096: if ((thread = thread_trim_head (&m->ready)) != NULL)
1097: return thread_run (m, thread, fetch);
1098: }
1099: }
1100:
1101: unsigned long
1102: thread_consumed_time (RUSAGE_T *now, RUSAGE_T *start, unsigned long *cputime)
1103: {
1104: #ifdef HAVE_RUSAGE
1105: /* This is 'user + sys' time. */
1106: *cputime = timeval_elapsed (now->cpu.ru_utime, start->cpu.ru_utime) +
1107: timeval_elapsed (now->cpu.ru_stime, start->cpu.ru_stime);
1108: #else
1109: *cputime = 0;
1110: #endif /* HAVE_RUSAGE */
1111: return timeval_elapsed (now->real, start->real);
1112: }
1113:
1114: /* We should aim to yield after THREAD_YIELD_TIME_SLOT milliseconds.
1115: Note: we are using real (wall clock) time for this calculation.
1116: It could be argued that CPU time may make more sense in certain
1117: contexts. The things to consider are whether the thread may have
1118: blocked (in which case wall time increases, but CPU time does not),
1119: or whether the system is heavily loaded with other processes competing
1120: for CPU time. On balance, wall clock time seems to make sense.
1121: Plus it has the added benefit that gettimeofday should be faster
1122: than calling getrusage. */
1123: int
1124: thread_should_yield (struct thread *thread)
1125: {
1126: quagga_get_relative (NULL);
1127: return (timeval_elapsed(relative_time, thread->ru.real) >
1128: THREAD_YIELD_TIME_SLOT);
1129: }
1130:
1131: void
1132: thread_getrusage (RUSAGE_T *r)
1133: {
1134: quagga_get_relative (NULL);
1135: #ifdef HAVE_RUSAGE
1136: getrusage(RUSAGE_SELF, &(r->cpu));
1137: #endif
1138: r->real = relative_time;
1139:
1140: #ifdef HAVE_CLOCK_MONOTONIC
1141: /* quagga_get_relative() only updates recent_time if gettimeofday
1142: * based, not when using CLOCK_MONOTONIC. As we export recent_time
1143: * and guarantee to update it before threads are run...
1144: */
1145: quagga_gettimeofday(&recent_time);
1146: #endif /* HAVE_CLOCK_MONOTONIC */
1147: }
1148:
1149: /* We check thread consumed time. If the system has getrusage, we'll
1150: use that to get in-depth stats on the performance of the thread in addition
1151: to wall clock time stats from gettimeofday. */
1152: void
1153: thread_call (struct thread *thread)
1154: {
1155: unsigned long realtime, cputime;
1156: RUSAGE_T ru;
1157:
1158: /* Cache a pointer to the relevant cpu history thread, if the thread
1159: * does not have it yet.
1160: *
1161: * Callers submitting 'dummy threads' hence must take care that
1162: * thread->cpu is NULL
1163: */
1164: if (!thread->hist)
1165: {
1166: struct cpu_thread_history tmp;
1167:
1168: tmp.func = thread->func;
1169: tmp.funcname = thread->funcname;
1170:
1171: thread->hist = hash_get (cpu_record, &tmp,
1172: (void * (*) (void *))cpu_record_hash_alloc);
1173: }
1174:
1175: GETRUSAGE (&thread->ru);
1176:
1177: (*thread->func) (thread);
1178:
1179: GETRUSAGE (&ru);
1180:
1181: realtime = thread_consumed_time (&ru, &thread->ru, &cputime);
1182: thread->hist->real.total += realtime;
1183: if (thread->hist->real.max < realtime)
1184: thread->hist->real.max = realtime;
1185: #ifdef HAVE_RUSAGE
1186: thread->hist->cpu.total += cputime;
1187: if (thread->hist->cpu.max < cputime)
1188: thread->hist->cpu.max = cputime;
1189: #endif
1190:
1191: ++(thread->hist->total_calls);
1192: thread->hist->types |= (1 << thread->add_type);
1193:
1194: #ifdef CONSUMED_TIME_CHECK
1195: if (realtime > CONSUMED_TIME_CHECK)
1196: {
1197: /*
1198: * We have a CPU Hog on our hands.
1199: * Whinge about it now, so we're aware this is yet another task
1200: * to fix.
1201: */
1202: zlog_warn ("SLOW THREAD: task %s (%lx) ran for %lums (cpu time %lums)",
1203: thread->funcname,
1204: (unsigned long) thread->func,
1205: realtime/1000, cputime/1000);
1206: }
1207: #endif /* CONSUMED_TIME_CHECK */
1208:
1209: XFREE (MTYPE_THREAD_FUNCNAME, thread->funcname);
1210: }
1211:
1212: /* Execute thread */
1213: struct thread *
1214: funcname_thread_execute (struct thread_master *m,
1215: int (*func)(struct thread *),
1216: void *arg,
1217: int val,
1218: const char* funcname)
1219: {
1220: struct thread dummy;
1221:
1222: memset (&dummy, 0, sizeof (struct thread));
1223:
1224: dummy.type = THREAD_EVENT;
1225: dummy.add_type = THREAD_EXECUTE;
1226: dummy.master = NULL;
1227: dummy.func = func;
1228: dummy.arg = arg;
1229: dummy.u.val = val;
1230: dummy.funcname = strip_funcname (funcname);
1231: thread_call (&dummy);
1232:
1233: XFREE (MTYPE_THREAD_FUNCNAME, dummy.funcname);
1234:
1235: return NULL;
1236: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to thread.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib