2 * Utilities and interfaces for managing POSIX threads within FRR.
3 * Copyright (C) 2017 Cumulus Networks, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; see the file COPYING; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #ifdef HAVE_PTHREAD_NP_H
23 #include <pthread_np.h>
27 #include "frr_pthread.h"
31 DEFINE_MTYPE_STATIC(LIB
, FRR_PTHREAD
, "FRR POSIX Thread")
32 DEFINE_MTYPE_STATIC(LIB
, PTHREAD_PRIM
, "POSIX sync primitives")
34 /* default frr_pthread start/stop routine prototypes */
35 static void *fpt_run(void *arg
);
36 static int fpt_halt(struct frr_pthread
*fpt
, void **res
);
39 static void frr_pthread_destroy_nolock(struct frr_pthread
*fpt
);
41 /* default frr_pthread attributes */
42 const struct frr_pthread_attr frr_pthread_attr_default
= {
47 /* list to keep track of all frr_pthreads */
48 static pthread_mutex_t frr_pthread_list_mtx
= PTHREAD_MUTEX_INITIALIZER
;
49 static struct list
*frr_pthread_list
;
51 /* ------------------------------------------------------------------------ */
53 void frr_pthread_init(void)
55 frr_with_mutex(&frr_pthread_list_mtx
) {
56 frr_pthread_list
= list_new();
60 void frr_pthread_finish(void)
62 frr_pthread_stop_all();
64 frr_with_mutex(&frr_pthread_list_mtx
) {
65 struct listnode
*n
, *nn
;
66 struct frr_pthread
*fpt
;
68 for (ALL_LIST_ELEMENTS(frr_pthread_list
, n
, nn
, fpt
)) {
69 listnode_delete(frr_pthread_list
, fpt
);
70 frr_pthread_destroy_nolock(fpt
);
73 list_delete(&frr_pthread_list
);
77 struct frr_pthread
*frr_pthread_new(const struct frr_pthread_attr
*attr
,
78 const char *name
, const char *os_name
)
80 struct frr_pthread
*fpt
= NULL
;
82 attr
= attr
? attr
: &frr_pthread_attr_default
;
84 fpt
= XCALLOC(MTYPE_FRR_PTHREAD
, sizeof(struct frr_pthread
));
85 /* initialize mutex */
86 pthread_mutex_init(&fpt
->mtx
, NULL
);
87 /* create new thread master */
88 fpt
->master
= thread_master_create(name
);
91 name
= (name
? name
: "Anonymous thread");
92 fpt
->name
= XSTRDUP(MTYPE_FRR_PTHREAD
, name
);
94 strlcpy(fpt
->os_name
, os_name
, OS_THREAD_NAMELEN
);
96 strlcpy(fpt
->os_name
, name
, OS_THREAD_NAMELEN
);
97 /* initialize startup synchronization primitives */
98 fpt
->running_cond_mtx
= XCALLOC(
99 MTYPE_PTHREAD_PRIM
, sizeof(pthread_mutex_t
));
100 fpt
->running_cond
= XCALLOC(MTYPE_PTHREAD_PRIM
,
101 sizeof(pthread_cond_t
));
102 pthread_mutex_init(fpt
->running_cond_mtx
, NULL
);
103 pthread_cond_init(fpt
->running_cond
, NULL
);
105 frr_with_mutex(&frr_pthread_list_mtx
) {
106 listnode_add(frr_pthread_list
, fpt
);
112 static void frr_pthread_destroy_nolock(struct frr_pthread
*fpt
)
114 thread_master_free(fpt
->master
);
115 pthread_mutex_destroy(&fpt
->mtx
);
116 pthread_mutex_destroy(fpt
->running_cond_mtx
);
117 pthread_cond_destroy(fpt
->running_cond
);
118 XFREE(MTYPE_FRR_PTHREAD
, fpt
->name
);
119 XFREE(MTYPE_PTHREAD_PRIM
, fpt
->running_cond_mtx
);
120 XFREE(MTYPE_PTHREAD_PRIM
, fpt
->running_cond
);
121 XFREE(MTYPE_FRR_PTHREAD
, fpt
);
124 void frr_pthread_destroy(struct frr_pthread
*fpt
)
126 frr_with_mutex(&frr_pthread_list_mtx
) {
127 listnode_delete(frr_pthread_list
, fpt
);
130 frr_pthread_destroy_nolock(fpt
);
133 int frr_pthread_set_name(struct frr_pthread
*fpt
)
137 #ifdef HAVE_PTHREAD_SETNAME_NP
139 ret
= pthread_setname_np(fpt
->thread
, fpt
->os_name
);
140 # elif defined(__NetBSD__)
141 ret
= pthread_setname_np(fpt
->thread
, fpt
->os_name
, NULL
);
143 #elif defined(HAVE_PTHREAD_SET_NAME_NP)
144 pthread_set_name_np(fpt
->thread
, fpt
->os_name
);
150 static void *frr_pthread_inner(void *arg
)
152 struct frr_pthread
*fpt
= arg
;
154 rcu_thread_start(fpt
->rcu_thread
);
155 return fpt
->attr
.start(fpt
);
158 int frr_pthread_run(struct frr_pthread
*fpt
, const pthread_attr_t
*attr
)
162 fpt
->rcu_thread
= rcu_thread_prepare();
163 ret
= pthread_create(&fpt
->thread
, attr
, frr_pthread_inner
, fpt
);
166 * Per pthread_create(3), the contents of fpt->thread are undefined if
167 * pthread_create() did not succeed. Reset this value to zero.
170 rcu_thread_unprepare(fpt
->rcu_thread
);
171 memset(&fpt
->thread
, 0x00, sizeof(fpt
->thread
));
177 void frr_pthread_wait_running(struct frr_pthread
*fpt
)
179 frr_with_mutex(fpt
->running_cond_mtx
) {
180 while (!fpt
->running
)
181 pthread_cond_wait(fpt
->running_cond
,
182 fpt
->running_cond_mtx
);
186 void frr_pthread_notify_running(struct frr_pthread
*fpt
)
188 frr_with_mutex(fpt
->running_cond_mtx
) {
190 pthread_cond_signal(fpt
->running_cond
);
194 int frr_pthread_stop(struct frr_pthread
*fpt
, void **result
)
196 int ret
= (*fpt
->attr
.stop
)(fpt
, result
);
197 memset(&fpt
->thread
, 0x00, sizeof(fpt
->thread
));
201 void frr_pthread_stop_all(void)
203 frr_with_mutex(&frr_pthread_list_mtx
) {
205 struct frr_pthread
*fpt
;
206 for (ALL_LIST_ELEMENTS_RO(frr_pthread_list
, n
, fpt
)) {
207 if (atomic_load_explicit(&fpt
->running
,
208 memory_order_relaxed
))
209 frr_pthread_stop(fpt
, NULL
);
215 * ----------------------------------------------------------------------------
217 * ----------------------------------------------------------------------------
220 /* dummy task for sleeper pipe */
221 static int fpt_dummy(struct thread
*thread
)
226 /* poison pill task to end event loop */
227 static int fpt_finish(struct thread
*thread
)
229 struct frr_pthread
*fpt
= THREAD_ARG(thread
);
231 atomic_store_explicit(&fpt
->running
, false, memory_order_relaxed
);
235 /* stop function, called from other threads to halt this one */
236 static int fpt_halt(struct frr_pthread
*fpt
, void **res
)
238 thread_add_event(fpt
->master
, &fpt_finish
, fpt
, 0, NULL
);
239 pthread_join(fpt
->thread
, res
);
245 * Entry pthread function & main event loop.
247 * Upon thread start the following actions occur:
249 * - frr_pthread's owner field is set to pthread ID.
250 * - All signals are blocked (except for unblockable signals).
251 * - Pthread's threadmaster is set to never handle pending signals
252 * - Poker pipe for poll() is created and queued as I/O source
253 * - The frr_pthread->running_cond condition variable is signalled to indicate
254 * that the previous actions have completed. It is not safe to assume any of
255 * the above have occurred before receiving this signal.
257 * After initialization is completed, the event loop begins running. Each tick,
258 * the following actions are performed before running the usual event system
261 * - Verify that the running boolean is set
262 * - Verify that there are no pending cancellation requests
263 * - Verify that there are tasks scheduled
265 * So long as the conditions are met, the event loop tick is run and the
266 * returned task is executed.
268 * If any of these conditions are not met, the event loop exits, closes the
269 * pipes and dies without running any cleanup functions.
271 static void *fpt_run(void *arg
)
273 struct frr_pthread
*fpt
= arg
;
274 fpt
->master
->owner
= pthread_self();
278 thread_add_read(fpt
->master
, &fpt_dummy
, NULL
, sleeper
[0], NULL
);
280 fpt
->master
->handle_signals
= false;
282 frr_pthread_set_name(fpt
);
284 frr_pthread_notify_running(fpt
);
287 while (atomic_load_explicit(&fpt
->running
, memory_order_relaxed
)) {
288 pthread_testcancel();
289 if (thread_fetch(fpt
->master
, &task
)) {