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(LIB
, FRR_PTHREAD
, "FRR POSIX Thread");
32 DEFINE_MTYPE(LIB
, PTHREAD_PRIM
, "POSIX synchronization 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
);
38 /* default frr_pthread attributes */
39 struct frr_pthread_attr frr_pthread_attr_default
= {
44 /* list to keep track of all frr_pthreads */
45 static pthread_mutex_t frr_pthread_list_mtx
= PTHREAD_MUTEX_INITIALIZER
;
46 static struct list
*frr_pthread_list
;
48 /* ------------------------------------------------------------------------ */
50 void frr_pthread_init()
52 pthread_mutex_lock(&frr_pthread_list_mtx
);
54 frr_pthread_list
= list_new();
55 frr_pthread_list
->del
= (void (*)(void *))&frr_pthread_destroy
;
57 pthread_mutex_unlock(&frr_pthread_list_mtx
);
60 void frr_pthread_finish()
62 pthread_mutex_lock(&frr_pthread_list_mtx
);
64 list_delete(&frr_pthread_list
);
66 pthread_mutex_unlock(&frr_pthread_list_mtx
);
69 struct frr_pthread
*frr_pthread_new(struct frr_pthread_attr
*attr
,
70 const char *name
, const char *os_name
)
72 struct frr_pthread
*fpt
= NULL
;
74 attr
= attr
? attr
: &frr_pthread_attr_default
;
76 fpt
= XCALLOC(MTYPE_FRR_PTHREAD
, sizeof(struct frr_pthread
));
77 /* initialize mutex */
78 pthread_mutex_init(&fpt
->mtx
, NULL
);
79 /* create new thread master */
80 fpt
->master
= thread_master_create(name
);
83 name
= (name
? name
: "Anonymous thread");
84 fpt
->name
= XSTRDUP(MTYPE_FRR_PTHREAD
, name
);
86 snprintf(fpt
->os_name
, OS_THREAD_NAMELEN
, "%s", os_name
);
87 /* initialize startup synchronization primitives */
88 fpt
->running_cond_mtx
= XCALLOC(
89 MTYPE_PTHREAD_PRIM
, sizeof(pthread_mutex_t
));
90 fpt
->running_cond
= XCALLOC(MTYPE_PTHREAD_PRIM
,
91 sizeof(pthread_cond_t
));
92 pthread_mutex_init(fpt
->running_cond_mtx
, NULL
);
93 pthread_cond_init(fpt
->running_cond
, NULL
);
95 pthread_mutex_lock(&frr_pthread_list_mtx
);
97 listnode_add(frr_pthread_list
, fpt
);
99 pthread_mutex_unlock(&frr_pthread_list_mtx
);
104 void frr_pthread_destroy(struct frr_pthread
*fpt
)
106 thread_master_free(fpt
->master
);
108 pthread_mutex_destroy(&fpt
->mtx
);
109 pthread_mutex_destroy(fpt
->running_cond_mtx
);
110 pthread_cond_destroy(fpt
->running_cond
);
112 XFREE(MTYPE_FRR_PTHREAD
, fpt
->name
);
113 XFREE(MTYPE_PTHREAD_PRIM
, fpt
->running_cond_mtx
);
114 XFREE(MTYPE_PTHREAD_PRIM
, fpt
->running_cond
);
115 XFREE(MTYPE_FRR_PTHREAD
, fpt
);
118 int frr_pthread_set_name(struct frr_pthread
*fpt
, const char *name
,
124 pthread_mutex_lock(&fpt
->mtx
);
127 XFREE(MTYPE_FRR_PTHREAD
, fpt
->name
);
128 fpt
->name
= XSTRDUP(MTYPE_FRR_PTHREAD
, name
);
130 pthread_mutex_unlock(&fpt
->mtx
);
131 thread_master_set_name(fpt
->master
, name
);
135 pthread_mutex_lock(&fpt
->mtx
);
136 snprintf(fpt
->os_name
, OS_THREAD_NAMELEN
, "%s", os_name
);
137 pthread_mutex_unlock(&fpt
->mtx
);
138 #ifdef HAVE_PTHREAD_SETNAME_NP
140 ret
= pthread_setname_np(fpt
->thread
, fpt
->os_name
);
142 ret
= pthread_setname_np(fpt
->thread
, fpt
->os_name
, NULL
);
144 #elif defined(HAVE_PTHREAD_SET_NAME_NP)
145 pthread_set_name_np(fpt
->thread
, fpt
->os_name
);
152 int frr_pthread_run(struct frr_pthread
*fpt
, const pthread_attr_t
*attr
)
156 ret
= pthread_create(&fpt
->thread
, attr
, fpt
->attr
.start
, fpt
);
159 * Per pthread_create(3), the contents of fpt->thread are undefined if
160 * pthread_create() did not succeed. Reset this value to zero.
163 memset(&fpt
->thread
, 0x00, sizeof(fpt
->thread
));
168 void frr_pthread_wait_running(struct frr_pthread
*fpt
)
170 pthread_mutex_lock(fpt
->running_cond_mtx
);
172 while (!fpt
->running
)
173 pthread_cond_wait(fpt
->running_cond
,
174 fpt
->running_cond_mtx
);
176 pthread_mutex_unlock(fpt
->running_cond_mtx
);
179 void frr_pthread_notify_running(struct frr_pthread
*fpt
)
181 pthread_mutex_lock(fpt
->running_cond_mtx
);
184 pthread_cond_signal(fpt
->running_cond
);
186 pthread_mutex_unlock(fpt
->running_cond_mtx
);
189 int frr_pthread_stop(struct frr_pthread
*fpt
, void **result
)
191 int ret
= (*fpt
->attr
.stop
)(fpt
, result
);
192 memset(&fpt
->thread
, 0x00, sizeof(fpt
->thread
));
196 void frr_pthread_stop_all()
198 pthread_mutex_lock(&frr_pthread_list_mtx
);
201 struct frr_pthread
*fpt
;
202 for (ALL_LIST_ELEMENTS_RO(frr_pthread_list
, n
, fpt
))
203 frr_pthread_stop(fpt
, NULL
);
205 pthread_mutex_unlock(&frr_pthread_list_mtx
);
209 * ----------------------------------------------------------------------------
211 * ----------------------------------------------------------------------------
214 /* dummy task for sleeper pipe */
215 static int fpt_dummy(struct thread
*thread
)
220 /* poison pill task to end event loop */
221 static int fpt_finish(struct thread
*thread
)
223 struct frr_pthread
*fpt
= THREAD_ARG(thread
);
225 atomic_store_explicit(&fpt
->running
, false, memory_order_relaxed
);
229 /* stop function, called from other threads to halt this one */
230 static int fpt_halt(struct frr_pthread
*fpt
, void **res
)
232 thread_add_event(fpt
->master
, &fpt_finish
, fpt
, 0, NULL
);
233 pthread_join(fpt
->thread
, res
);
239 * Entry pthread function & main event loop.
241 * Upon thread start the following actions occur:
243 * - frr_pthread's owner field is set to pthread ID.
244 * - All signals are blocked (except for unblockable signals).
245 * - Pthread's threadmaster is set to never handle pending signals
246 * - Poker pipe for poll() is created and queued as I/O source
247 * - The frr_pthread->running_cond condition variable is signalled to indicate
248 * that the previous actions have completed. It is not safe to assume any of
249 * the above have occurred before receiving this signal.
251 * After initialization is completed, the event loop begins running. Each tick,
252 * the following actions are performed before running the usual event system
255 * - Verify that the running boolean is set
256 * - Verify that there are no pending cancellation requests
257 * - Verify that there are tasks scheduled
259 * So long as the conditions are met, the event loop tick is run and the
260 * returned task is executed.
262 * If any of these conditions are not met, the event loop exits, closes the
263 * pipes and dies without running any cleanup functions.
265 static void *fpt_run(void *arg
)
267 struct frr_pthread
*fpt
= arg
;
268 fpt
->master
->owner
= pthread_self();
272 thread_add_read(fpt
->master
, &fpt_dummy
, NULL
, sleeper
[0], NULL
);
274 fpt
->master
->handle_signals
= false;
277 frr_pthread_set_name(fpt
, NULL
, fpt
->os_name
);
279 frr_pthread_notify_running(fpt
);
282 while (atomic_load_explicit(&fpt
->running
, memory_order_relaxed
)) {
283 pthread_testcancel();
284 if (thread_fetch(fpt
->master
, &task
)) {