[mirror_frr.git] / lib / thread.h

/* Thread management routine header.
 * Copyright (C) 1998 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GNU Zebra; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.  
 */

#ifndef _ZEBRA_THREAD_H
#define _ZEBRA_THREAD_H

#include <zebra.h>
#include "monotime.h"

struct rusage_t
{
  struct rusage cpu;
  struct timeval real;
};
#define RUSAGE_T        struct rusage_t

#define GETRUSAGE(X) thread_getrusage(X)

/* Linked list of thread. */
struct thread_list
{
  struct thread *head;
  struct thread *tail;
  int count;
};

struct pqueue;

/*
 * Abstract it so we can use different methodologies to
 * select on data.
 */
typedef fd_set thread_fd_set;

#if defined(HAVE_POLL)
#include <poll.h>
struct fd_handler
{
  /* number of pfd stored in pfds */
  nfds_t pfdcount;
  /* number of pfd stored in pfds + number of snmp pfd */
  nfds_t pfdcountsnmp;
  /* number of pfd that fit in the allocated space of pfds */
  nfds_t pfdsize;
  struct pollfd *pfds;
};
#else
struct fd_handler
{
  fd_set readfd;
  fd_set writefd;
  fd_set exceptfd;
};
#endif

/* Master of the theads. */
struct thread_master
{
  struct thread **read;
  struct thread **write;
  struct pqueue *timer;
  struct thread_list event;
  struct thread_list ready;
  struct thread_list unuse;
  struct pqueue *background;
  int fd_limit;
  struct fd_handler handler;
  unsigned long alloc;
};

typedef unsigned char thread_type;

/* Thread itself. */
struct thread
{
  thread_type type;		/* thread type */
  thread_type add_type;		/* thread type */
  struct thread *next;		/* next pointer of the thread */   
  struct thread *prev;		/* previous pointer of the thread */
  struct thread_master *master;	/* pointer to the struct thread_master. */
  int (*func) (struct thread *); /* event function */
  void *arg;			/* event argument */
  union {
    int val;			/* second argument of the event. */
    int fd;			/* file descriptor in case of read/write. */
    struct timeval sands;	/* rest of time sands value. */
  } u;
  int index;			/* used for timers to store position in queue */
  struct timeval real;
  struct cpu_thread_history *hist; /* cache pointer to cpu_history */
  unsigned long yield; /* yield time in us */
  const char *funcname;
  const char *schedfrom;
  int schedfrom_line;
};

struct cpu_thread_history 
{
  int (*func)(struct thread *);
  unsigned int total_calls;
  unsigned int total_active;
  struct time_stats
  {
    unsigned long total, max;
  } real;
  struct time_stats cpu;
  thread_type types;
  const char *funcname;
};

/* Struct timeval's tv_usec one second value.  */
#define TIMER_SECOND_MICRO 1000000L

/* Thread types. */
#define THREAD_READ           0
#define THREAD_WRITE          1
#define THREAD_TIMER          2
#define THREAD_EVENT          3
#define THREAD_READY          4
#define THREAD_BACKGROUND     5
#define THREAD_UNUSED         6
#define THREAD_EXECUTE        7

/* Thread yield time.  */
#define THREAD_YIELD_TIME_SLOT     10 * 1000L /* 10ms */

/* Macros. */
#define THREAD_ARG(X) ((X)->arg)
#define THREAD_FD(X)  ((X)->u.fd)
#define THREAD_VAL(X) ((X)->u.val)

#define THREAD_READ_ON(master,thread,func,arg,sock) \
  do { \
    if (! thread) \
      thread = thread_add_read (master, func, arg, sock); \
  } while (0)

#define THREAD_WRITE_ON(master,thread,func,arg,sock) \
  do { \
    if (! thread) \
      thread = thread_add_write (master, func, arg, sock); \
  } while (0)

#define THREAD_TIMER_ON(master,thread,func,arg,time) \
  do { \
    if (! thread) \
      thread = thread_add_timer (master, func, arg, time); \
  } while (0)

#define THREAD_TIMER_MSEC_ON(master,thread,func,arg,time) \
  do { \
    if (! thread) \
      thread = thread_add_timer_msec (master, func, arg, time); \
  } while (0)

#define THREAD_OFF(thread) \
  do { \
    if (thread) \
      { \
        thread_cancel (thread); \
        thread = NULL; \
      } \
  } while (0)

#define THREAD_READ_OFF(thread)  THREAD_OFF(thread)
#define THREAD_WRITE_OFF(thread)  THREAD_OFF(thread)
#define THREAD_TIMER_OFF(thread)  THREAD_OFF(thread)

#define debugargdef  const char *funcname, const char *schedfrom, int fromln

#define thread_add_read(m,f,a,v) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_write(m,f,a,v) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_timer(m,f,a,v) funcname_thread_add_timer(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_timer_msec(m,f,a,v) funcname_thread_add_timer_msec(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_timer_tv(m,f,a,v) funcname_thread_add_timer_tv(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_add_event(m,f,a,v) funcname_thread_add_event(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f,__FILE__,__LINE__)

/* The 4th arg to thread_add_background is the # of milliseconds to delay. */
#define thread_add_background(m,f,a,v) funcname_thread_add_background(m,f,a,v,#f,__FILE__,__LINE__)

/* Prototypes. */
extern struct thread_master *thread_master_create (void);
extern void thread_master_free (struct thread_master *);
extern void thread_master_free_unused(struct thread_master *);

extern struct thread *funcname_thread_add_read_write (int dir, struct thread_master *,
				                int (*)(struct thread *),
				                void *, int, debugargdef);
extern struct thread *funcname_thread_add_timer (struct thread_master *,
				                 int (*)(struct thread *),
				                 void *, long, debugargdef);
extern struct thread *funcname_thread_add_timer_msec (struct thread_master *,
				                      int (*)(struct thread *),
				                      void *, long, debugargdef);
extern struct thread *funcname_thread_add_timer_tv (struct thread_master *,
				                    int (*)(struct thread *),
				                    void *, struct timeval *,
						    debugargdef);
extern struct thread *funcname_thread_add_event (struct thread_master *,
				                 int (*)(struct thread *),
				                 void *, int, debugargdef);
extern struct thread *funcname_thread_add_background (struct thread_master *,
                                               int (*func)(struct thread *),
				               void *arg,
				               long milliseconds_to_delay,
					       debugargdef);
extern struct thread *funcname_thread_execute (struct thread_master *,
                                               int (*)(struct thread *),
                                               void *, int, debugargdef);
#undef debugargdef

extern void thread_cancel (struct thread *);
extern unsigned int thread_cancel_event (struct thread_master *, void *);
extern struct thread *thread_fetch (struct thread_master *, struct thread *);
extern void thread_call (struct thread *);
extern unsigned long thread_timer_remain_second (struct thread *);
extern struct timeval thread_timer_remain(struct thread*);
extern int thread_should_yield (struct thread *);
/* set yield time for thread */
extern void thread_set_yield_time (struct thread *, unsigned long);

/* Internal libfrr exports */
extern void thread_getrusage (RUSAGE_T *);
extern void thread_cmd_init (void);

/* Returns elapsed real (wall clock) time. */
extern unsigned long thread_consumed_time(RUSAGE_T *after, RUSAGE_T *before,
					  unsigned long *cpu_time_elapsed);

/* only for use in logging functions! */
extern struct thread *thread_current;

#endif /* _ZEBRA_THREAD_H */
Commit	Line	Data
718e3744	1	/* Thread management routine header.
	2	* Copyright (C) 1998 Kunihiro Ishiguro
	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	#ifndef _ZEBRA_THREAD_H
	23	#define _ZEBRA_THREAD_H
	24
5734509c	25	#include <zebra.h>
cf672a86	26	#include "monotime.h"
5734509c	27
8b70d0b0	28	struct rusage_t
8b70d0b0	29	{
8b70d0b0	30	struct rusage cpu;
8b70d0b0	31	struct timeval real;
	32	};
	33	#define RUSAGE_T struct rusage_t
	34
db9c0df9	35	#define GETRUSAGE(X) thread_getrusage(X)
718e3744	36
	37	/* Linked list of thread. */
	38	struct thread_list
	39	{
	40	struct thread *head;
	41	struct thread *tail;
	42	int count;
	43	};
	44
4becea72 CF	45	struct pqueue;
4becea72 CF	46
209a72a6 DS	47	/*
	48	* Abstract it so we can use different methodologies to
	49	* select on data.
	50	*/
	51	typedef fd_set thread_fd_set;
	52
0a95a0d0 DS	53	#if defined(HAVE_POLL)
	54	#include <poll.h>
	55	struct fd_handler
	56	{
	57	/* number of pfd stored in pfds */
	58	nfds_t pfdcount;
	59	/* number of pfd stored in pfds + number of snmp pfd */
	60	nfds_t pfdcountsnmp;
	61	/* number of pfd that fit in the allocated space of pfds */
	62	nfds_t pfdsize;
	63	struct pollfd *pfds;
	64	};
	65	#else
	66	struct fd_handler
	67	{
	68	fd_set readfd;
	69	fd_set writefd;
	70	fd_set exceptfd;
	71	};
	72	#endif
	73
718e3744	74	/* Master of the theads. */
	75	struct thread_master
	76	{
308d14ae DV	77	struct thread **read;
308d14ae DV	78	struct thread **write;
4becea72	79	struct pqueue *timer;
718e3744	80	struct thread_list event;
	81	struct thread_list ready;
	82	struct thread_list unuse;
4becea72	83	struct pqueue *background;
308d14ae	84	int fd_limit;
0a95a0d0	85	struct fd_handler handler;
718e3744	86	unsigned long alloc;
	87	};
	88
41b2373c PJ	89	typedef unsigned char thread_type;
41b2373c PJ	90
718e3744	91	/* Thread itself. */
	92	struct thread
	93	{
41b2373c PJ	94	thread_type type; /* thread type */
41b2373c PJ	95	thread_type add_type; /* thread type */
a48b4e6d	96	struct thread next; / next pointer of the thread */
718e3744	97	struct thread prev; / previous pointer of the thread */
	98	struct thread_master master; / pointer to the struct thread_master. */
	99	int (func) (struct thread ); /* event function */
	100	void arg; / event argument */
	101	union {
	102	int val; /* second argument of the event. */
	103	int fd; /* file descriptor in case of read/write. */
	104	struct timeval sands; /* rest of time sands value. */
	105	} u;
4becea72	106	int index; /* used for timers to store position in queue */
41af338e	107	struct timeval real;
cc8b13a0	108	struct cpu_thread_history hist; / cache pointer to cpu_history */
50596be0	109	unsigned long yield; /* yield time in us */
9c7753e4 DL	110	const char *funcname;
	111	const char *schedfrom;
	112	int schedfrom_line;
e04ab74d	113	};
e04ab74d	114
8b70d0b0	115	struct cpu_thread_history
8b70d0b0	116	{
e04ab74d	117	int (func)(struct thread );
e04ab74d	118	unsigned int total_calls;
f7c62e11	119	unsigned int total_active;
8b70d0b0	120	struct time_stats
	121	{
	122	unsigned long total, max;
	123	} real;
8b70d0b0	124	struct time_stats cpu;
41b2373c	125	thread_type types;
9c7753e4	126	const char *funcname;
718e3744	127	};
718e3744	128
ca1f4309 DS	129	/* Struct timeval's tv_usec one second value. */
	130	#define TIMER_SECOND_MICRO 1000000L
	131
718e3744	132	/* Thread types. */
	133	#define THREAD_READ 0
	134	#define THREAD_WRITE 1
	135	#define THREAD_TIMER 2
	136	#define THREAD_EVENT 3
	137	#define THREAD_READY 4
a48b4e6d	138	#define THREAD_BACKGROUND 5
	139	#define THREAD_UNUSED 6
	140	#define THREAD_EXECUTE 7
718e3744	141
718e3744	142	/* Thread yield time. */
17fc128d	143	#define THREAD_YIELD_TIME_SLOT 10 * 1000L /* 10ms */
718e3744	144
	145	/* Macros. */
	146	#define THREAD_ARG(X) ((X)->arg)
	147	#define THREAD_FD(X) ((X)->u.fd)
	148	#define THREAD_VAL(X) ((X)->u.val)
	149
	150	#define THREAD_READ_ON(master,thread,func,arg,sock) \
	151	do { \
	152	if (! thread) \
	153	thread = thread_add_read (master, func, arg, sock); \
	154	} while (0)
	155
	156	#define THREAD_WRITE_ON(master,thread,func,arg,sock) \
	157	do { \
	158	if (! thread) \
	159	thread = thread_add_write (master, func, arg, sock); \
	160	} while (0)
	161
	162	#define THREAD_TIMER_ON(master,thread,func,arg,time) \
	163	do { \
	164	if (! thread) \
	165	thread = thread_add_timer (master, func, arg, time); \
	166	} while (0)
	167
e8540959 EM	168	#define THREAD_TIMER_MSEC_ON(master,thread,func,arg,time) \
	169	do { \
	170	if (! thread) \
	171	thread = thread_add_timer_msec (master, func, arg, time); \
	172	} while (0)
	173
718e3744	174	#define THREAD_OFF(thread) \
	175	do { \
	176	if (thread) \
	177	{ \
	178	thread_cancel (thread); \
	179	thread = NULL; \
	180	} \
	181	} while (0)
	182
	183	#define THREAD_READ_OFF(thread) THREAD_OFF(thread)
	184	#define THREAD_WRITE_OFF(thread) THREAD_OFF(thread)
	185	#define THREAD_TIMER_OFF(thread) THREAD_OFF(thread)
	186
9c7753e4 DL	187	#define debugargdef const char funcname, const char schedfrom, int fromln
	188
	189	#define thread_add_read(m,f,a,v) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,#f,__FILE__,__LINE__)
	190	#define thread_add_write(m,f,a,v) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,#f,__FILE__,__LINE__)
	191	#define thread_add_timer(m,f,a,v) funcname_thread_add_timer(m,f,a,v,#f,__FILE__,__LINE__)
	192	#define thread_add_timer_msec(m,f,a,v) funcname_thread_add_timer_msec(m,f,a,v,#f,__FILE__,__LINE__)
d03c4cbd	193	#define thread_add_timer_tv(m,f,a,v) funcname_thread_add_timer_tv(m,f,a,v,#f,__FILE__,__LINE__)
9c7753e4 DL	194	#define thread_add_event(m,f,a,v) funcname_thread_add_event(m,f,a,v,#f,__FILE__,__LINE__)
9c7753e4 DL	195	#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f,__FILE__,__LINE__)
fb9e46bb	196
fb9e46bb	197	/* The 4th arg to thread_add_background is the # of milliseconds to delay. */
9c7753e4	198	#define thread_add_background(m,f,a,v) funcname_thread_add_background(m,f,a,v,#f,__FILE__,__LINE__)
e04ab74d	199
718e3744	200	/* Prototypes. */
8cc4198f	201	extern struct thread_master *thread_master_create (void);
8cc4198f	202	extern void thread_master_free (struct thread_master *);
495f0b13	203	extern void thread_master_free_unused(struct thread_master *);
8cc4198f	204
8dadcae7	205	extern struct thread funcname_thread_add_read_write (int dir, struct thread_master ,
8cc4198f	206	int ()(struct thread ),
9c7753e4	207	void *, int, debugargdef);
8cc4198f	208	extern struct thread funcname_thread_add_timer (struct thread_master ,
8cc4198f	209	int ()(struct thread ),
9c7753e4	210	void *, long, debugargdef);
8cc4198f	211	extern struct thread funcname_thread_add_timer_msec (struct thread_master ,
8cc4198f	212	int ()(struct thread ),
9c7753e4	213	void *, long, debugargdef);
d03c4cbd DL	214	extern struct thread funcname_thread_add_timer_tv (struct thread_master ,
	215	int ()(struct thread ),
	216	void , struct timeval ,
	217	debugargdef);
8cc4198f	218	extern struct thread funcname_thread_add_event (struct thread_master ,
8cc4198f	219	int ()(struct thread ),
9c7753e4	220	void *, int, debugargdef);
8cc4198f	221	extern struct thread funcname_thread_add_background (struct thread_master ,
8cc4198f	222	int (func)(struct thread ),
fb9e46bb	223	void *arg,
fb9e46bb	224	long milliseconds_to_delay,
9c7753e4	225	debugargdef);
8cc4198f	226	extern struct thread funcname_thread_execute (struct thread_master ,
8cc4198f	227	int ()(struct thread ),
9c7753e4 DL	228	void *, int, debugargdef);
	229	#undef debugargdef
	230
8cc4198f	231	extern void thread_cancel (struct thread *);
dc81807a	232	extern unsigned int thread_cancel_event (struct thread_master , void );
8cc4198f	233	extern struct thread thread_fetch (struct thread_master , struct thread *);
	234	extern void thread_call (struct thread *);
	235	extern unsigned long thread_timer_remain_second (struct thread *);
6ac44687	236	extern struct timeval thread_timer_remain(struct thread*);
8cc4198f	237	extern int thread_should_yield (struct thread *);
50596be0 DS	238	/* set yield time for thread */
50596be0 DS	239	extern void thread_set_yield_time (struct thread *, unsigned long);
718e3744	240
55c72803	241	/* Internal libfrr exports */
db9c0df9	242	extern void thread_getrusage (RUSAGE_T *);
0b84f294	243	extern void thread_cmd_init (void);
e04ab74d	244
8b70d0b0	245	/* Returns elapsed real (wall clock) time. */
	246	extern unsigned long thread_consumed_time(RUSAGE_T after, RUSAGE_T before,
	247	unsigned long *cpu_time_elapsed);
	248
d1265948 DL	249	/* only for use in logging functions! */
	250	extern struct thread *thread_current;
	251
718e3744	252	#endif /* _ZEBRA_THREAD_H */