[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 this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef _ZEBRA_THREAD_H
#define _ZEBRA_THREAD_H

#include <zebra.h>
#include <pthread.h>
#include <poll.h>
#include "monotime.h"
#include "frratomic.h"

#ifdef __cplusplus
extern "C" {
#endif

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;

struct fd_handler {
	/* number of pfd that fit in the allocated space of pfds. This is a
	 * constant
	 * and is the same for both pfds and copy. */
	nfds_t pfdsize;

	/* file descriptors to monitor for i/o */
	struct pollfd *pfds;
	/* number of pollfds stored in pfds */
	nfds_t pfdcount;

	/* chunk used for temp copy of pollfds */
	struct pollfd *copy;
	/* number of pollfds stored in copy */
	nfds_t copycount;
};

struct cancel_req {
	struct thread *thread;
	void *eventobj;
	struct thread **threadref;
};

/* Master of the theads. */
struct thread_master {
	char *name;

	struct thread **read;
	struct thread **write;
	struct pqueue *timer;
	struct thread_list event;
	struct thread_list ready;
	struct thread_list unuse;
	struct list *cancel_req;
	bool canceled;
	pthread_cond_t cancel_cond;
	struct hash *cpu_record;
	int io_pipe[2];
	int fd_limit;
	struct fd_handler handler;
	unsigned long alloc;
	long selectpoll_timeout;
	bool spin;
	bool handle_signals;
	pthread_mutex_t mtx;
	pthread_t owner;
};

/* Thread itself. */
struct thread {
	uint8_t type;		  /* thread type */
	uint8_t add_type;	  /* thread type */
	struct thread *next;	  /* next pointer of the thread */
	struct thread *prev;	  /* previous pointer of the thread */
	struct thread **ref;	  /* external reference (if given) */
	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 r/w */
		struct timeval sands; /* rest of time sands value. */
	} u;
	int index; /* queue position for timers */
	struct timeval real;
	struct cpu_thread_history *hist; /* cache pointer to cpu_history */
	unsigned long yield;		 /* yield time in microseconds */
	const char *funcname;		 /* name of thread function */
	const char *schedfrom; /* source file thread was scheduled from */
	int schedfrom_line;    /* line number of source file */
	pthread_mutex_t mtx;   /* mutex for thread.c functions */
};

struct cpu_thread_history {
	int (*func)(struct thread *);
	atomic_uint_fast32_t total_calls;
	atomic_uint_fast32_t total_active;
	struct time_stats {
		atomic_size_t total, max;
	} real;
	struct time_stats cpu;
	atomic_uint_fast32_t 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_UNUSED         5
#define THREAD_EXECUTE        6

/* 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_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,t) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_write(m,f,a,v,t) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_timer(m,f,a,v,t) funcname_thread_add_timer(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_timer_msec(m,f,a,v,t) funcname_thread_add_timer_msec(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_timer_tv(m,f,a,v,t) funcname_thread_add_timer_tv(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_add_event(m,f,a,v,t) funcname_thread_add_event(m,f,a,v,t,#f,__FILE__,__LINE__)
#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f,__FILE__,__LINE__)
#define thread_execute_name(m, f, a, v, n)				\
	funcname_thread_execute(m, f, a, v, n, __FILE__, __LINE__)

/* Prototypes. */
extern struct thread_master *thread_master_create(const char *);
void thread_master_set_name(struct thread_master *master, const char *name);
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,
			       struct thread **, debugargdef);

extern struct thread *funcname_thread_add_timer(struct thread_master *,
						int (*)(struct thread *),
						void *, long, struct thread **,
						debugargdef);

extern struct thread *
funcname_thread_add_timer_msec(struct thread_master *, int (*)(struct thread *),
			       void *, long, struct thread **, debugargdef);

extern struct thread *funcname_thread_add_timer_tv(struct thread_master *,
						   int (*)(struct thread *),
						   void *, struct timeval *,
						   struct thread **,
						   debugargdef);

extern struct thread *funcname_thread_add_event(struct thread_master *,
						int (*)(struct thread *),
						void *, int, struct thread **,
						debugargdef);

extern void funcname_thread_execute(struct thread_master *,
				    int (*)(struct thread *), void *, int,
				    debugargdef);
#undef debugargdef

extern void thread_cancel(struct thread *);
extern void thread_cancel_async(struct thread_master *, struct thread **,
				void *);
extern void 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 unsigned long thread_timer_remain_msec(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 pthread_key_t thread_current;

#ifdef __cplusplus
}
#endif

#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	*
896014f4 DL	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
718e3744	19	*/
	20
	21	#ifndef _ZEBRA_THREAD_H
	22	#define _ZEBRA_THREAD_H
	23
5734509c	24	#include <zebra.h>
1189d95f	25	#include <pthread.h>
75bcb355 QY	26	#include <poll.h>
75bcb355 QY	27	#include "monotime.h"
fbcac826	28	#include "frratomic.h"
5734509c	29
5e244469 RW	30	#ifdef __cplusplus
	31	extern "C" {
	32	#endif
	33
d62a17ae	34	struct rusage_t {
	35	struct rusage cpu;
	36	struct timeval real;
8b70d0b0	37	};
	38	#define RUSAGE_T struct rusage_t
	39
db9c0df9	40	#define GETRUSAGE(X) thread_getrusage(X)
718e3744	41
718e3744	42	/* Linked list of thread. */
d62a17ae	43	struct thread_list {
	44	struct thread *head;
	45	struct thread *tail;
	46	int count;
718e3744	47	};
718e3744	48
4becea72 CF	49	struct pqueue;
4becea72 CF	50
d62a17ae	51	struct fd_handler {
	52	/* number of pfd that fit in the allocated space of pfds. This is a
	53	* constant
	54	* and is the same for both pfds and copy. */
	55	nfds_t pfdsize;
	56
	57	/* file descriptors to monitor for i/o */
	58	struct pollfd *pfds;
	59	/* number of pollfds stored in pfds */
	60	nfds_t pfdcount;
	61
	62	/* chunk used for temp copy of pollfds */
	63	struct pollfd *copy;
	64	/* number of pollfds stored in copy */
	65	nfds_t copycount;
0a95a0d0	66	};
0a95a0d0	67
63ccb9cb	68	struct cancel_req {
d62a17ae	69	struct thread *thread;
	70	void *eventobj;
	71	struct thread **threadref;
63ccb9cb QY	72	};
63ccb9cb QY	73
718e3744	74	/* Master of the theads. */
d62a17ae	75	struct thread_master {
	76	char *name;
	77
	78	struct thread **read;
	79	struct thread **write;
	80	struct pqueue *timer;
	81	struct thread_list event;
	82	struct thread_list ready;
	83	struct thread_list unuse;
	84	struct list *cancel_req;
	85	bool canceled;
	86	pthread_cond_t cancel_cond;
	87	struct hash *cpu_record;
	88	int io_pipe[2];
	89	int fd_limit;
	90	struct fd_handler handler;
	91	unsigned long alloc;
	92	long selectpoll_timeout;
	93	bool spin;
	94	bool handle_signals;
	95	pthread_mutex_t mtx;
	96	pthread_t owner;
718e3744	97	};
	98
	99	/* Thread itself. */
d62a17ae	100	struct thread {
fbcac826 QY	101	uint8_t type; /* thread type */
fbcac826 QY	102	uint8_t add_type; /* thread type */
d62a17ae	103	struct thread next; / next pointer of the thread */
	104	struct thread prev; / previous pointer of the thread */
	105	struct thread *ref; / external reference (if given) */
	106	struct thread_master master; / pointer to the struct thread_master */
	107	int (func)(struct thread ); /* event function */
	108	void arg; / event argument */
	109	union {
	110	int val; /* second argument of the event. */
	111	int fd; /* file descriptor in case of r/w */
	112	struct timeval sands; /* rest of time sands value. */
	113	} u;
	114	int index; /* queue position for timers */
	115	struct timeval real;
	116	struct cpu_thread_history hist; / cache pointer to cpu_history */
	117	unsigned long yield; /* yield time in microseconds */
	118	const char funcname; / name of thread function */
	119	const char schedfrom; / source file thread was scheduled from */
	120	int schedfrom_line; /* line number of source file */
	121	pthread_mutex_t mtx; /* mutex for thread.c functions */
e04ab74d	122	};
e04ab74d	123
d62a17ae	124	struct cpu_thread_history {
d62a17ae	125	int (func)(struct thread );
c8a65463 DL	126	atomic_uint_fast32_t total_calls;
c8a65463 DL	127	atomic_uint_fast32_t total_active;
d62a17ae	128	struct time_stats {
c8a65463	129	atomic_size_t total, max;
d62a17ae	130	} real;
d62a17ae	131	struct time_stats cpu;
c8a65463	132	atomic_uint_fast32_t types;
d62a17ae	133	const char *funcname;
718e3744	134	};
718e3744	135
ca1f4309 DS	136	/* Struct timeval's tv_usec one second value. */
	137	#define TIMER_SECOND_MICRO 1000000L
	138
718e3744	139	/* Thread types. */
	140	#define THREAD_READ 0
	141	#define THREAD_WRITE 1
	142	#define THREAD_TIMER 2
	143	#define THREAD_EVENT 3
	144	#define THREAD_READY 4
a587d00b QY	145	#define THREAD_UNUSED 5
a587d00b QY	146	#define THREAD_EXECUTE 6
718e3744	147
718e3744	148	/* Thread yield time. */
17fc128d	149	#define THREAD_YIELD_TIME_SLOT 10 * 1000L /* 10ms */
718e3744	150
	151	/* Macros. */
	152	#define THREAD_ARG(X) ((X)->arg)
	153	#define THREAD_FD(X) ((X)->u.fd)
	154	#define THREAD_VAL(X) ((X)->u.val)
	155
d62a17ae	156	#define THREAD_OFF(thread) \
	157	do { \
	158	if (thread) { \
	159	thread_cancel(thread); \
	160	thread = NULL; \
	161	} \
	162	} while (0)
718e3744	163
	164	#define THREAD_READ_OFF(thread) THREAD_OFF(thread)
	165	#define THREAD_WRITE_OFF(thread) THREAD_OFF(thread)
	166	#define THREAD_TIMER_OFF(thread) THREAD_OFF(thread)
	167
9c7753e4 DL	168	#define debugargdef const char funcname, const char schedfrom, int fromln
9c7753e4 DL	169
ffa2c898 QY	170	#define thread_add_read(m,f,a,v,t) funcname_thread_add_read_write(THREAD_READ,m,f,a,v,t,#f,__FILE__,__LINE__)
	171	#define thread_add_write(m,f,a,v,t) funcname_thread_add_read_write(THREAD_WRITE,m,f,a,v,t,#f,__FILE__,__LINE__)
	172	#define thread_add_timer(m,f,a,v,t) funcname_thread_add_timer(m,f,a,v,t,#f,__FILE__,__LINE__)
	173	#define thread_add_timer_msec(m,f,a,v,t) funcname_thread_add_timer_msec(m,f,a,v,t,#f,__FILE__,__LINE__)
	174	#define thread_add_timer_tv(m,f,a,v,t) funcname_thread_add_timer_tv(m,f,a,v,t,#f,__FILE__,__LINE__)
	175	#define thread_add_event(m,f,a,v,t) funcname_thread_add_event(m,f,a,v,t,#f,__FILE__,__LINE__)
9c7753e4	176	#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f,__FILE__,__LINE__)
b7fb24ce DS	177	#define thread_execute_name(m, f, a, v, n) \
b7fb24ce DS	178	funcname_thread_execute(m, f, a, v, n, __FILE__, __LINE__)
fb9e46bb	179
718e3744	180	/* Prototypes. */
d62a17ae	181	extern struct thread_master thread_master_create(const char );
d8a8a8de	182	void thread_master_set_name(struct thread_master master, const char name);
d62a17ae	183	extern void thread_master_free(struct thread_master *);
495f0b13	184	extern void thread_master_free_unused(struct thread_master *);
8cc4198f	185
d62a17ae	186	extern struct thread *
	187	funcname_thread_add_read_write(int dir, struct thread_master *,
	188	int ()(struct thread ), void *, int,
	189	struct thread **, debugargdef);
	190
	191	extern struct thread funcname_thread_add_timer(struct thread_master ,
	192	int ()(struct thread ),
	193	void , long, struct thread *,
	194	debugargdef);
	195
	196	extern struct thread *
	197	funcname_thread_add_timer_msec(struct thread_master , int ()(struct thread *),
	198	void , long, struct thread *, debugargdef);
	199
	200	extern struct thread funcname_thread_add_timer_tv(struct thread_master ,
	201	int ()(struct thread ),
	202	void , struct timeval ,
	203	struct thread **,
	204	debugargdef);
	205
	206	extern struct thread funcname_thread_add_event(struct thread_master ,
	207	int ()(struct thread ),
	208	void , int, struct thread *,
	209	debugargdef);
	210
	211	extern void funcname_thread_execute(struct thread_master *,
	212	int ()(struct thread ), void *, int,
	213	debugargdef);
9c7753e4 DL	214	#undef debugargdef
9c7753e4 DL	215
d62a17ae	216	extern void thread_cancel(struct thread *);
	217	extern void thread_cancel_async(struct thread_master , struct thread *,
	218	void *);
	219	extern void thread_cancel_event(struct thread_master , void );
	220	extern struct thread thread_fetch(struct thread_master , struct thread *);
	221	extern void thread_call(struct thread *);
	222	extern unsigned long thread_timer_remain_second(struct thread *);
	223	extern struct timeval thread_timer_remain(struct thread *);
78ca0342	224	extern unsigned long thread_timer_remain_msec(struct thread *);
d62a17ae	225	extern int thread_should_yield(struct thread *);
50596be0	226	/* set yield time for thread */
d62a17ae	227	extern void thread_set_yield_time(struct thread *, unsigned long);
718e3744	228
55c72803	229	/* Internal libfrr exports */
d62a17ae	230	extern void thread_getrusage(RUSAGE_T *);
d62a17ae	231	extern void thread_cmd_init(void);
e04ab74d	232
8b70d0b0	233	/* Returns elapsed real (wall clock) time. */
	234	extern unsigned long thread_consumed_time(RUSAGE_T after, RUSAGE_T before,
	235	unsigned long *cpu_time_elapsed);
	236
d1265948	237	/* only for use in logging functions! */
e0bebc7c	238	extern pthread_key_t thread_current;
d1265948	239
5e244469 RW	240	#ifdef __cplusplus
	241	}
	242	#endif
	243
718e3744	244	#endif /* _ZEBRA_THREAD_H */