upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-04-11 11:56:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
haproxy/include/haproxy/thread.h

705 lines
21 KiB
C
Raw Normal View History

MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
/*
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
* include/haproxy/thread.h
* definitions, macros and inline functions used by threads.
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
*
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
* Copyright (C) 2017 Christopher Faulet - cfaulet@haproxy.com
* Copyright (C) 2020 Willy Tarreau - w@1wt.eu
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#ifndef _HAPROXY_THREAD_H
#define _HAPROXY_THREAD_H
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
MINOR: threads: implement ha_tkill() and ha_tkillall() These functions are used respectively to signal one thread or all threads. When multithreading is disabled, it's always the current thread which is signaled.
2019-05-22 02:43:34 -04:00
#include <signal.h>
MINOR: thread: implement ha_thread_relax() At some places we're using a painful ifdef to decide whether to use sched_yield() or pl_cpu_relax() to relax in loops, this is hardly exportable. Let's move this to ha_thread_relax() instead and une this one only.
2019-05-17 10:33:13 -04:00
#include <unistd.h>
#ifdef _POSIX_PRIORITY_SCHEDULING
#include <sched.h>
#endif
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
REORG: include: update all files to use haproxy/api.h or api-t.h if needed All files that were including one of the following include files have been updated to only include haproxy/api.h or haproxy/api-t.h once instead: - common/config.h - common/compat.h - common/compiler.h - common/defaults.h - common/initcall.h - common/tools.h The choice is simple: if the file only requires type definitions, it includes api-t.h, otherwise it includes the full api.h. In addition, in these files, explicit includes for inttypes.h and limits.h were dropped since these are now covered by api.h and api-t.h. No other change was performed, given that this patch is large and affects 201 files. At least one (tools.h) was already freestanding and didn't get the new one added.
2020-05-27 06:58:42 -04:00
#include <haproxy/api.h>
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#include <haproxy/thread-t.h>
REORG: includes: create tinfo.h for the thread_info struct The thread_info struct is convenient to store various per-thread info without having to resort to a painful thread_local storage which is slow and painful to initialize. The problem is, by having this one in thread.h it's very difficult to add more entries there because everyone already includes thread.h so conversely thread.h cannot reference certain types. There's no point in having this there, instead let's create a new pair of files, tinfo{,-t}.h, which declare the structure. This way it will become possible to extend them with other includes and have certain files store their own types there.
2020-06-29 03:57:23 -04:00
#include <haproxy/tinfo.h>
MINOR: thread: implement ha_thread_relax() At some places we're using a painful ifdef to decide whether to use sched_yield() or pl_cpu_relax() to relax in loops, this is hardly exportable. Let's move this to ha_thread_relax() instead and une this one only.
2019-05-17 10:33:13 -04:00
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
/* Note: this file mainly contains 5 sections:
* - a small common part, which also corresponds to the common API
* - one used solely when USE_THREAD is *not* set
* - one used solely when USE_THREAD is set
* - one used solely when USE_THREAD is set WITHOUT debugging
* - one used solely when USE_THREAD is set WITH debugging
*
MINOR: threads: move "nbthread" parsing to hathreads.c The purpose is to make sure that all variables which directly depend on this nbthread argument are set at the right moment. For now only all_threads_mask needs to be set. It used to be set while calling thread_sync_init() which is called too late for certain checks. The same function handles threads and non-threads, which removes the need for some thread-specific knowledge from cfgparse.c.
2018-07-30 04:34:35 -04:00
*/
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
/* Generic exports */
int parse_nbthread(const char *arg, char **err);
int thread_get_default_count();
extern int thread_cpus_enabled_at_boot;
MINOR: threads: add a "stuck" flag to the thread_info struct This flag is constantly cleared by the scheduler and will be set by the watchdog timer to detect stuck threads. It is also set by the "show threads" command so that it is easy to spot if the situation has evolved between two subsequent calls : if the first "show threads" shows no stuck thread and the second one shows such a stuck thread, it indicates that this thread didn't manage to make any forward progress since the previous call, which is extremely suspicious.
2019-05-22 01:06:44 -04:00
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
#ifndef USE_THREAD
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
/********************** THREADS DISABLED ************************/
MINOR: threads: add more consistency between certain variables in no-thread case When threads are disabled, some variables such as tid and tid_bit are still checked everywhere, the MAX_THREADS_MASK macro is ~0UL while MAX_THREADS is 1, and the all_threads_mask variable is replaced with a macro forced to zero. The compiler cannot optimize away all this code involving checks on tid and tid_bit, and we end up in special cases where all_threads_mask has to be specifically tested for being zero or not. It is not even certain the code paths are always equivalent when testing without threads and with nbthread 1. Let's change this to make sure we always present a single thread when threads are disabled, and have the relevant values declared as constants so that the compiler can optimize all the tests away. Now we have MAX_THREADS_MASK set to 1, all_threads_mask set to 1, tid set to zero and tid_bit set to 1. Doing just this has removed 4 kB of code in the no-thread case. A few checks for all_threads_mask==0 have been removed since it never happens anymore.
2018-08-01 13:12:20 -04:00
/* Only way found to replace variables with constants that are optimized away
* at build time.
*/
enum { all_threads_mask = 1UL };
MINOR: threads: make threads_{harmless|want_rdv}_mask constant 0 without threads Some code starts to add ifdefs everywhere to work around the lack of threads_harmless_mask when threads are not compiled in. This one is often used to indicate a thread having joined the rendez-vous point or a thread sleeping in the poller. By setting it to zero we translate what usually is required in debugging code (i.e. the only thread is currently working) and for signal handlers we can use a combination of threads_harmless_mask and sleeping_threads_mask to detect the polling cases as well. Similarly do the same with threads_want_rdv_mask which is less often used though.
2019-05-22 01:48:18 -04:00
enum { threads_harmless_mask = 0 };
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
enum { threads_sync_mask = 0 };
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
enum { threads_want_rdv_mask = 0 };
MINOR: threads: add more consistency between certain variables in no-thread case When threads are disabled, some variables such as tid and tid_bit are still checked everywhere, the MAX_THREADS_MASK macro is ~0UL while MAX_THREADS is 1, and the all_threads_mask variable is replaced with a macro forced to zero. The compiler cannot optimize away all this code involving checks on tid and tid_bit, and we end up in special cases where all_threads_mask has to be specifically tested for being zero or not. It is not even certain the code paths are always equivalent when testing without threads and with nbthread 1. Let's change this to make sure we always present a single thread when threads are disabled, and have the relevant values declared as constants so that the compiler can optimize all the tests away. Now we have MAX_THREADS_MASK set to 1, all_threads_mask set to 1, tid set to zero and tid_bit set to 1. Doing just this has removed 4 kB of code in the no-thread case. A few checks for all_threads_mask==0 have been removed since it never happens anymore.
2018-08-01 13:12:20 -04:00
enum { tid_bit = 1UL };
enum { tid = 0 };
MINOR: threads: add a MAX_THREADS define instead of LONGBITS This one allows not to inflate some structures when threads are disabled. Now struct global is 1.4 kB instead of 33 kB. Should be backported to 1.8 for ease of backporting of upcoming patches.
2018-01-20 12:19:22 -05:00
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_SPIN_INIT(l) do { /* do nothing */ } while(0)
#define HA_SPIN_DESTROY(l) do { /* do nothing */ } while(0)
#define HA_SPIN_LOCK(lbl, l) do { /* do nothing */ } while(0)
#define HA_SPIN_TRYLOCK(lbl, l) ({ 0; })
#define HA_SPIN_UNLOCK(lbl, l) do { /* do nothing */ } while(0)
MINOR: threads: add a thread-local thread_info pointer "ti" Since we're likely to access this thread_info struct more frequently in the future, let's reserve the thread-local symbol to access it directly and avoid always having to combine thread_info and tid. This pointer is set when tid is set.
2019-05-20 12:57:53 -04:00
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_RWLOCK_INIT(l) do { /* do nothing */ } while(0)
#define HA_RWLOCK_DESTROY(l) do { /* do nothing */ } while(0)
#define HA_RWLOCK_WRLOCK(lbl, l) do { /* do nothing */ } while(0)
BUILD: threads: Rename SPIN/RWLOCK macros using HA_ prefix This remove any name conflicts, especially on Solaris.
2017-11-07 04:42:54 -05:00
#define HA_RWLOCK_TRYWRLOCK(lbl, l) ({ 0; })
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_RWLOCK_WRUNLOCK(lbl, l) do { /* do nothing */ } while(0)
#define HA_RWLOCK_RDLOCK(lbl, l) do { /* do nothing */ } while(0)
BUILD: threads: Rename SPIN/RWLOCK macros using HA_ prefix This remove any name conflicts, especially on Solaris.
2017-11-07 04:42:54 -05:00
#define HA_RWLOCK_TRYRDLOCK(lbl, l) ({ 0; })
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_RWLOCK_RDUNLOCK(lbl, l) do { /* do nothing */ } while(0)
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
BUG/MINOR: signals: ha_sigmask macro for multithreading The behavior of sigprocmask in an multithreaded environment is undefined. The new macro ha_sigmask() calls either pthreads_sigmask() or sigprocmask() if haproxy was built with thread support or not. This should be backported to 1.8.
2018-06-07 05:23:40 -04:00
#define ha_sigmask(how, set, oldset) sigprocmask(how, set, oldset)
MINOR: threads: add more consistency between certain variables in no-thread case When threads are disabled, some variables such as tid and tid_bit are still checked everywhere, the MAX_THREADS_MASK macro is ~0UL while MAX_THREADS is 1, and the all_threads_mask variable is replaced with a macro forced to zero. The compiler cannot optimize away all this code involving checks on tid and tid_bit, and we end up in special cases where all_threads_mask has to be specifically tested for being zero or not. It is not even certain the code paths are always equivalent when testing without threads and with nbthread 1. Let's change this to make sure we always present a single thread when threads are disabled, and have the relevant values declared as constants so that the compiler can optimize all the tests away. Now we have MAX_THREADS_MASK set to 1, all_threads_mask set to 1, tid set to zero and tid_bit set to 1. Doing just this has removed 4 kB of code in the no-thread case. A few checks for all_threads_mask==0 have been removed since it never happens anymore.
2018-08-01 13:12:20 -04:00
static inline void ha_set_tid(unsigned int tid)
{
BUILD/MEDIUM: threads: rename thread_info struct to ha_thread_info On Darwin, the thread_info name exists as a standard function thus we need to rename our array to ha_thread_info to fix this conflict.
2019-09-13 00:03:12 -04:00
ti = &ha_thread_info[tid];
MINOR: threads: add more consistency between certain variables in no-thread case When threads are disabled, some variables such as tid and tid_bit are still checked everywhere, the MAX_THREADS_MASK macro is ~0UL while MAX_THREADS is 1, and the all_threads_mask variable is replaced with a macro forced to zero. The compiler cannot optimize away all this code involving checks on tid and tid_bit, and we end up in special cases where all_threads_mask has to be specifically tested for being zero or not. It is not even certain the code paths are always equivalent when testing without threads and with nbthread 1. Let's change this to make sure we always present a single thread when threads are disabled, and have the relevant values declared as constants so that the compiler can optimize all the tests away. Now we have MAX_THREADS_MASK set to 1, all_threads_mask set to 1, tid set to zero and tid_bit set to 1. Doing just this has removed 4 kB of code in the no-thread case. A few checks for all_threads_mask==0 have been removed since it never happens anymore.
2018-08-01 13:12:20 -04:00
}
BUG/MINOR: signals: ha_sigmask macro for multithreading The behavior of sigprocmask in an multithreaded environment is undefined. The new macro ha_sigmask() calls either pthreads_sigmask() or sigprocmask() if haproxy was built with thread support or not. This should be backported to 1.8.
2018-06-07 05:23:40 -04:00
BUG/MINOR: debug: properly use long long instead of long for the thread ID I changed my mind twice on this one and pushed after the last test with threads disabled, without re-enabling long long, causing this rightful build warning. This needs to be backported if the previous commit ff64d3b027 ("MINOR: threads: export the POSIX thread ID in panic dumps") is backported as well.
2020-05-01 06:26:03 -04:00
static inline unsigned long long ha_get_pthread_id(unsigned int thr)
MINOR: threads: export the POSIX thread ID in panic dumps It is very difficult to map a panic dump against a gdb thread dump because the thread numbers do not match. However gdb provides the pthread ID but this one is supposed to be opaque and not to be cast to a scalar. This patch provides a fnuction, ha_get_pthread_id() which retrieves the pthread ID of the indicated thread and casts it to an unsigned long long so as to lose the least possible amount of information from it. This is done cleanly using a union to maintain alignment so as long as these IDs are stored on 1..8 bytes they will be properly reported. This ID is now presented in the panic dumps so it now becomes possible to map these threads. When threads are disabled, zero is returned. For example, this is a panic dump: Thread 1 is about to kill the process. *>Thread 1 : id=0x7fe92b825180 act=0 glob=0 wq=1 rq=0 tl=0 tlsz=0 rqsz=0 stuck=1 prof=0 harmless=0 wantrdv=0 cpu_ns: poll=5119122 now=2009446995 diff=2004327873 curr_task=0xc99bf0 (task) calls=4 last=0 fct=0x592440(task_run_applet) ctx=0xca9c50(<CLI>) strm=0xc996a0 src=unix fe=GLOBAL be=GLOBAL dst=<CLI> rqf=848202 rqa=0 rpf=80048202 rpa=0 sif=EST,200008 sib=EST,204018 af=(nil),0 csf=0xc9ba40,8200 ab=0xca9c50,4 csb=(nil),0 cof=0xbf0e50,1300:PASS(0xc9cee0)/RAW((nil))/unix_stream(20) cob=(nil),0:NONE((nil))/NONE((nil))/NONE(0) call trace(20): | 0x59e4cf [48 83 c4 10 5b 5d 41 5c]: wdt_handler+0xff/0x10c | 0x7fe92c170690 [48 c7 c0 0f 00 00 00 0f]: libpthread:+0x13690 | 0x7ffce29519d9 [48 c1 e2 20 48 09 d0 48]: linux-vdso:+0x9d9 | 0x7ffce2951d54 [eb d9 f3 90 e9 1c ff ff]: linux-vdso:__vdso_gettimeofday+0x104/0x133 | 0x57b484 [48 89 e6 48 8d 7c 24 10]: main+0x157114 | 0x50ee6a [85 c0 75 76 48 8b 55 38]: main+0xeaafa | 0x50f69c [48 63 54 24 20 85 c0 0f]: main+0xeb32c | 0x59252c [48 c7 c6 d8 ff ff ff 44]: task_run_applet+0xec/0x88c Thread 2 : id=0x7fe92b6e6700 act=0 glob=0 wq=0 rq=0 tl=0 tlsz=0 rqsz=0 stuck=0 prof=0 harmless=1 wantrdv=0 cpu_ns: poll=786738 now=1086955 diff=300217 curr_task=0 Thread 3 : id=0x7fe92aee5700 act=0 glob=0 wq=0 rq=0 tl=0 tlsz=0 rqsz=0 stuck=0 prof=0 harmless=1 wantrdv=0 cpu_ns: poll=828056 now=1129738 diff=301682 curr_task=0 Thread 4 : id=0x7fe92a6e4700 act=0 glob=0 wq=0 rq=0 tl=0 tlsz=0 rqsz=0 stuck=0 prof=0 harmless=1 wantrdv=0 cpu_ns: poll=818900 now=1153551 diff=334651 curr_task=0 And this is the gdb output: (gdb) info thr Id Target Id Frame * 1 Thread 0x7fe92b825180 (LWP 15234) 0x00007fe92ba81d6b in raise () from /lib64/libc.so.6 2 Thread 0x7fe92b6e6700 (LWP 15235) 0x00007fe92bb56a56 in epoll_wait () from /lib64/libc.so.6 3 Thread 0x7fe92a6e4700 (LWP 15237) 0x00007fe92bb56a56 in epoll_wait () from /lib64/libc.so.6 4 Thread 0x7fe92aee5700 (LWP 15236) 0x00007fe92bb56a56 in epoll_wait () from /lib64/libc.so.6 We can clearly see that while threads 1 and 2 are the same, gdb's threads 3 and 4 respectively are haproxy's threads 4 and 3. This may be backported to 2.0 as it removes some confusion in github issues.
2020-05-01 05:28:49 -04:00
{
return 0;
}
MINOR: thread: implement ha_thread_relax() At some places we're using a painful ifdef to decide whether to use sched_yield() or pl_cpu_relax() to relax in loops, this is hardly exportable. Let's move this to ha_thread_relax() instead and une this one only.
2019-05-17 10:33:13 -04:00
static inline void ha_thread_relax(void)
{
#if _POSIX_PRIORITY_SCHEDULING
sched_yield();
#endif
}
MINOR: threads: implement ha_tkill() and ha_tkillall() These functions are used respectively to signal one thread or all threads. When multithreading is disabled, it's always the current thread which is signaled.
2019-05-22 02:43:34 -04:00
/* send signal <sig> to thread <thr> */
static inline void ha_tkill(unsigned int thr, int sig)
{
raise(sig);
}
/* send signal <sig> to all threads */
static inline void ha_tkillall(int sig)
{
raise(sig);
}
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
static inline void thread_harmless_now()
{
}
static inline void thread_harmless_end()
{
}
static inline void thread_isolate()
{
}
static inline void thread_release()
{
}
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
static inline void thread_sync_release()
{
}
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
static inline unsigned long thread_isolated()
{
return 1;
}
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#else /* !USE_THREAD */
/********************** THREADS ENABLED ************************/
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <import/plock.h>
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
void thread_harmless_till_end();
void thread_isolate();
void thread_release();
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
void thread_sync_release();
MINOR: threads: implement ha_tkill() and ha_tkillall() These functions are used respectively to signal one thread or all threads. When multithreading is disabled, it's always the current thread which is signaled.
2019-05-22 02:43:34 -04:00
void ha_tkill(unsigned int thr, int sig);
void ha_tkillall(int sig);
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
void ha_spin_init(HA_SPINLOCK_T *l);
void ha_rwlock_init(HA_RWLOCK_T *l);
MEDIUM: threads: Adds a set of functions to handle sync-point A sync-point is a protected area where you have the warranty that no concurrency access is possible. It is implementated as a thread barrier to enter in the sync-point and another one to exit from it. Inside the sync-point, all threads that must do some syncrhonous processing will be called one after the other while all other threads will wait. All threads will then exit from the sync-point at the same time. A sync-point will be evaluated only when necessary because it is a costly operation. To limit the waiting time of each threads, we must have a mechanism to wakeup all threads. This is done with a pipe shared by all threads. By writting in this pipe, we will interrupt all threads blocked on a poller. The pipe is then flushed before exiting from the sync-point.
2017-10-19 05:59:15 -04:00
BUG/MEDIUM: threads: Fix the exit condition of the thread barrier In thread_sync_barrier, we exit when all threads have set their own bit in the barrier mask. It is done by comparing it to all_threads_mask. But we must not use a simple equality to do so, becaue all_threads_mask may change. Since commit ba86c6c25 ("MINOR: threads: Be sure to remove threads from all_threads_mask on exit"), when a thread exit, its bit is removed from all_threads_mask. Instead, we must use a bitwise AND to test is all bits of all_threads_mask are set. This also requires that all_threads_mask is set to volatile if we want to catch changes. This patch must be backported in 1.8.
2018-07-20 03:31:53 -04:00
extern volatile unsigned long all_threads_mask;
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
extern volatile unsigned long threads_harmless_mask;
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
extern volatile unsigned long threads_sync_mask;
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
extern volatile unsigned long threads_want_rdv_mask;
extern THREAD_LOCAL unsigned long tid_bit; /* The bit corresponding to the thread id */
extern THREAD_LOCAL unsigned int tid; /* The thread id */
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
/* explanation for threads_want_rdv_mask, threads_harmless_mask, and
* threads_sync_mask :
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
* - threads_want_rdv_mask is a bit field indicating all threads that have
* requested a rendez-vous of other threads using thread_isolate().
* - threads_harmless_mask is a bit field indicating all threads that are
* currently harmless in that they promise not to access a shared resource.
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
* - threads_sync_mask is a bit field indicating that a thread waiting for
* others to finish wants to leave synchronized with others and as such
* promises to do so as well using thread_sync_release().
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
*
* For a given thread, its bits in want_rdv and harmless can be translated like
* this :
*
* ----------+----------+----------------------------------------------------
* want_rdv | harmless | description
* ----------+----------+----------------------------------------------------
* 0 | 0 | thread not interested in RDV, possibly harmful
* 0 | 1 | thread not interested in RDV but harmless
* 1 | 1 | thread interested in RDV and waiting for its turn
* 1 | 0 | thread currently working isolated from others
* ----------+----------+----------------------------------------------------
MEDIUM: threads: add thread_sync_release() to synchronize steps This function provides an alternate way to leave a critical section run under thread_isolate(). Currently, a thread may remain in thread_release() without having the time to notice that the rdv mask was released and taken again by another thread entering thread_isolate() (often the same that just released it). This is because threads wait in harmless mode in the loop, which is compatible with the conditions to enter thread_isolate(). It's not possible to make them wait with the harmless bit off or we cannot know when the job is finished for the next thread to start in thread_isolate(), and if we don't clear the rdv bit when going there, we create another race on the start point of thread_isolate(). This new synchronous variant of thread_release() makes use of an extra mask to indicate the threads that want to be synchronously released. In this case, they will be marked harmless before releasing their sync bit, and will wait for others to release their bit as well, guaranteeing that thread_isolate() cannot be started by any of them before they all left thread_sync_release(). This allows to construct synchronized blocks like this : thread_isolate() /* optionally do something alone here */ thread_sync_release() /* do something together here */ thread_isolate() /* optionally do something alone here */ thread_sync_release() And so on. This is particularly useful during initialization where several steps have to be respected and no thread must start a step before the previous one is completed by other threads. This one must not be placed after any call to thread_release() or it would risk to block an earlier call to thread_isolate() which the current thread managed to leave without waiting for others to complete, and end up here with the thread's harmless bit cleared, blocking others. This might be improved in the future.
2019-06-09 06:20:02 -04:00
*
* thread_sync_mask only delays the leaving of threads_sync_release() to make
* sure that each thread's harmless bit is cleared before leaving the function.
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
*/
BUG/MEDIUM: pollers: Use a global list for fd shared between threads. With the old model, any fd shared by multiple threads, such as listeners or dns sockets, would only be updated on one threads, so that could lead to missed event, or spurious wakeups. To avoid this, add a global list for fd that are shared, using the same implementation as the fd cache, and only remove entries from this list when every thread as updated its poller. [wt: this will need to be backported to 1.8 but differently so this patch must not be backported as-is]
2018-04-25 10:58:25 -04:00
BUG/MINOR: signals: ha_sigmask macro for multithreading The behavior of sigprocmask in an multithreaded environment is undefined. The new macro ha_sigmask() calls either pthreads_sigmask() or sigprocmask() if haproxy was built with thread support or not. This should be backported to 1.8.
2018-06-07 05:23:40 -04:00
#define ha_sigmask(how, set, oldset) pthread_sigmask(how, set, oldset)
MINOR: threads: add more consistency between certain variables in no-thread case When threads are disabled, some variables such as tid and tid_bit are still checked everywhere, the MAX_THREADS_MASK macro is ~0UL while MAX_THREADS is 1, and the all_threads_mask variable is replaced with a macro forced to zero. The compiler cannot optimize away all this code involving checks on tid and tid_bit, and we end up in special cases where all_threads_mask has to be specifically tested for being zero or not. It is not even certain the code paths are always equivalent when testing without threads and with nbthread 1. Let's change this to make sure we always present a single thread when threads are disabled, and have the relevant values declared as constants so that the compiler can optimize all the tests away. Now we have MAX_THREADS_MASK set to 1, all_threads_mask set to 1, tid set to zero and tid_bit set to 1. Doing just this has removed 4 kB of code in the no-thread case. A few checks for all_threads_mask==0 have been removed since it never happens anymore.
2018-08-01 13:12:20 -04:00
/* sets the thread ID and the TID bit for the current thread */
static inline void ha_set_tid(unsigned int data)
{
tid = data;
tid_bit = (1UL << tid);
BUILD/MEDIUM: threads: rename thread_info struct to ha_thread_info On Darwin, the thread_info name exists as a standard function thus we need to rename our array to ha_thread_info to fix this conflict.
2019-09-13 00:03:12 -04:00
ti = &ha_thread_info[tid];
MINOR: threads: add more consistency between certain variables in no-thread case When threads are disabled, some variables such as tid and tid_bit are still checked everywhere, the MAX_THREADS_MASK macro is ~0UL while MAX_THREADS is 1, and the all_threads_mask variable is replaced with a macro forced to zero. The compiler cannot optimize away all this code involving checks on tid and tid_bit, and we end up in special cases where all_threads_mask has to be specifically tested for being zero or not. It is not even certain the code paths are always equivalent when testing without threads and with nbthread 1. Let's change this to make sure we always present a single thread when threads are disabled, and have the relevant values declared as constants so that the compiler can optimize all the tests away. Now we have MAX_THREADS_MASK set to 1, all_threads_mask set to 1, tid set to zero and tid_bit set to 1. Doing just this has removed 4 kB of code in the no-thread case. A few checks for all_threads_mask==0 have been removed since it never happens anymore.
2018-08-01 13:12:20 -04:00
}
MINOR: threads: export the POSIX thread ID in panic dumps It is very difficult to map a panic dump against a gdb thread dump because the thread numbers do not match. However gdb provides the pthread ID but this one is supposed to be opaque and not to be cast to a scalar. This patch provides a fnuction, ha_get_pthread_id() which retrieves the pthread ID of the indicated thread and casts it to an unsigned long long so as to lose the least possible amount of information from it. This is done cleanly using a union to maintain alignment so as long as these IDs are stored on 1..8 bytes they will be properly reported. This ID is now presented in the panic dumps so it now becomes possible to map these threads. When threads are disabled, zero is returned. For example, this is a panic dump: Thread 1 is about to kill the process. *>Thread 1 : id=0x7fe92b825180 act=0 glob=0 wq=1 rq=0 tl=0 tlsz=0 rqsz=0 stuck=1 prof=0 harmless=0 wantrdv=0 cpu_ns: poll=5119122 now=2009446995 diff=2004327873 curr_task=0xc99bf0 (task) calls=4 last=0 fct=0x592440(task_run_applet) ctx=0xca9c50(<CLI>) strm=0xc996a0 src=unix fe=GLOBAL be=GLOBAL dst=<CLI> rqf=848202 rqa=0 rpf=80048202 rpa=0 sif=EST,200008 sib=EST,204018 af=(nil),0 csf=0xc9ba40,8200 ab=0xca9c50,4 csb=(nil),0 cof=0xbf0e50,1300:PASS(0xc9cee0)/RAW((nil))/unix_stream(20) cob=(nil),0:NONE((nil))/NONE((nil))/NONE(0) call trace(20): | 0x59e4cf [48 83 c4 10 5b 5d 41 5c]: wdt_handler+0xff/0x10c | 0x7fe92c170690 [48 c7 c0 0f 00 00 00 0f]: libpthread:+0x13690 | 0x7ffce29519d9 [48 c1 e2 20 48 09 d0 48]: linux-vdso:+0x9d9 | 0x7ffce2951d54 [eb d9 f3 90 e9 1c ff ff]: linux-vdso:__vdso_gettimeofday+0x104/0x133 | 0x57b484 [48 89 e6 48 8d 7c 24 10]: main+0x157114 | 0x50ee6a [85 c0 75 76 48 8b 55 38]: main+0xeaafa | 0x50f69c [48 63 54 24 20 85 c0 0f]: main+0xeb32c | 0x59252c [48 c7 c6 d8 ff ff ff 44]: task_run_applet+0xec/0x88c Thread 2 : id=0x7fe92b6e6700 act=0 glob=0 wq=0 rq=0 tl=0 tlsz=0 rqsz=0 stuck=0 prof=0 harmless=1 wantrdv=0 cpu_ns: poll=786738 now=1086955 diff=300217 curr_task=0 Thread 3 : id=0x7fe92aee5700 act=0 glob=0 wq=0 rq=0 tl=0 tlsz=0 rqsz=0 stuck=0 prof=0 harmless=1 wantrdv=0 cpu_ns: poll=828056 now=1129738 diff=301682 curr_task=0 Thread 4 : id=0x7fe92a6e4700 act=0 glob=0 wq=0 rq=0 tl=0 tlsz=0 rqsz=0 stuck=0 prof=0 harmless=1 wantrdv=0 cpu_ns: poll=818900 now=1153551 diff=334651 curr_task=0 And this is the gdb output: (gdb) info thr Id Target Id Frame * 1 Thread 0x7fe92b825180 (LWP 15234) 0x00007fe92ba81d6b in raise () from /lib64/libc.so.6 2 Thread 0x7fe92b6e6700 (LWP 15235) 0x00007fe92bb56a56 in epoll_wait () from /lib64/libc.so.6 3 Thread 0x7fe92a6e4700 (LWP 15237) 0x00007fe92bb56a56 in epoll_wait () from /lib64/libc.so.6 4 Thread 0x7fe92aee5700 (LWP 15236) 0x00007fe92bb56a56 in epoll_wait () from /lib64/libc.so.6 We can clearly see that while threads 1 and 2 are the same, gdb's threads 3 and 4 respectively are haproxy's threads 4 and 3. This may be backported to 2.0 as it removes some confusion in github issues.
2020-05-01 05:28:49 -04:00
/* Retrieves the opaque pthread_t of thread <thr> cast to an unsigned long long
* since POSIX took great care of not specifying its representation, making it
* hard to export for post-mortem analysis. For this reason we copy it into a
* union and will use the smallest scalar type at least as large as its size,
* which will keep endianness and alignment for all regular sizes. As a last
* resort we end up with a long long ligned to the first bytes in memory, which
* will be endian-dependent if pthread_t is larger than a long long (not seen
* yet).
*/
static inline unsigned long long ha_get_pthread_id(unsigned int thr)
{
union {
pthread_t t;
unsigned long long ll;
unsigned int i;
unsigned short s;
unsigned char c;
} u;
memset(&u, 0, sizeof(u));
u.t = ha_thread_info[thr].pthread;
if (sizeof(u.t) <= sizeof(u.c))
return u.c;
else if (sizeof(u.t) <= sizeof(u.s))
return u.s;
else if (sizeof(u.t) <= sizeof(u.i))
return u.i;
return u.ll;
}
MINOR: thread: implement ha_thread_relax() At some places we're using a painful ifdef to decide whether to use sched_yield() or pl_cpu_relax() to relax in loops, this is hardly exportable. Let's move this to ha_thread_relax() instead and une this one only.
2019-05-17 10:33:13 -04:00
static inline void ha_thread_relax(void)
{
#if _POSIX_PRIORITY_SCHEDULING
sched_yield();
#else
pl_cpu_relax();
#endif
}
MEDIUM: hathreads: implement a more flexible rendez-vous point The current synchronization point enforces certain restrictions which are hard to workaround in certain areas of the code. The fact that the critical code can only be called from the sync point itself is a problem for some callback-driven parts. The "show fd" command for example is fragile regarding this. Also it is expensive in terms of CPU usage because it wakes every other thread just to be sure all of them join to the rendez-vous point. It's a problem because the sleeping threads would not need to be woken up just to know they're doing nothing. Here we implement a different approach. We keep track of harmless threads, which are defined as those either doing nothing, or doing harmless things. The rendez-vous is used "for others" as a way for a thread to isolate itself. A thread then requests to be alone using thread_isolate() when approaching the dangerous area, and then waits until all other threads are either doing the same or are doing something harmless (typically polling). The function only returns once the thread is guaranteed to be alone, and the critical section is terminated using thread_release().
2018-08-02 04:16:17 -04:00
/* Marks the thread as harmless. Note: this must be true, i.e. the thread must
* not be touching any unprotected shared resource during this period. Usually
* this is called before poll(), but it may also be placed around very slow
* calls (eg: some crypto operations). Needs to be terminated using
* thread_harmless_end().
*/
static inline void thread_harmless_now()
{
HA_ATOMIC_OR(&threads_harmless_mask, tid_bit);
}
/* Ends the harmless period started by thread_harmless_now(). Usually this is
* placed after the poll() call. If it is discovered that a job was running and
* is relying on the thread still being harmless, the thread waits for the
* other one to finish.
*/
static inline void thread_harmless_end()
{
while (1) {
HA_ATOMIC_AND(&threads_harmless_mask, ~tid_bit);
if (likely((threads_want_rdv_mask & all_threads_mask) == 0))
break;
thread_harmless_till_end();
}
}
/* an isolated thread has harmless cleared and want_rdv set */
static inline unsigned long thread_isolated()
{
return threads_want_rdv_mask & ~threads_harmless_mask & tid_bit;
}
BUG/MINOR: signals: ha_sigmask macro for multithreading The behavior of sigprocmask in an multithreaded environment is undefined. The new macro ha_sigmask() calls either pthreads_sigmask() or sigprocmask() if haproxy was built with thread support or not. This should be backported to 1.8.
2018-06-07 05:23:40 -04:00
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#if !defined(DEBUG_THREAD) && !defined(DEBUG_FULL)
/* Thread debugging is DISABLED, these are the regular locking functions */
#define HA_SPIN_INIT(l) ({ (*l) = 0; })
#define HA_SPIN_DESTROY(l) ({ (*l) = 0; })
#define HA_SPIN_LOCK(lbl, l) pl_take_s(l)
BUILD: thread: add parenthesis around values of locking macros clang just failed on fd.c with this error: src/fd.c:491:9: error: logical not is only applied to the left hand side of this comparison [-Werror,-Wlogical-not-parentheses] while (HA_SPIN_TRYLOCK(OTHER_LOCK, &log_lock) != 0) { ^ ~~ That's because this expands to this: while (!pl_try_s(&log_lock) != 0) { Let's just add parenthesis in the TRYLOCK macros to avoid this. This may need to be backported if commit df187875d ("BUG/MEDIUM: log: don't hold the log lock during writev() on a file descriptor") is backported as well as it seems to be the first one to trigger it.
2020-06-12 05:42:25 -04:00
#define HA_SPIN_TRYLOCK(lbl, l) (!pl_try_s(l))
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_SPIN_UNLOCK(lbl, l) pl_drop_s(l)
#define HA_RWLOCK_INIT(l) ({ (*l) = 0; })
#define HA_RWLOCK_DESTROY(l) ({ (*l) = 0; })
#define HA_RWLOCK_WRLOCK(lbl,l) pl_take_w(l)
BUILD: thread: add parenthesis around values of locking macros clang just failed on fd.c with this error: src/fd.c:491:9: error: logical not is only applied to the left hand side of this comparison [-Werror,-Wlogical-not-parentheses] while (HA_SPIN_TRYLOCK(OTHER_LOCK, &log_lock) != 0) { ^ ~~ That's because this expands to this: while (!pl_try_s(&log_lock) != 0) { Let's just add parenthesis in the TRYLOCK macros to avoid this. This may need to be backported if commit df187875d ("BUG/MEDIUM: log: don't hold the log lock during writev() on a file descriptor") is backported as well as it seems to be the first one to trigger it.
2020-06-12 05:42:25 -04:00
#define HA_RWLOCK_TRYWRLOCK(lbl,l) (!pl_try_w(l))
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_RWLOCK_WRUNLOCK(lbl,l) pl_drop_w(l)
#define HA_RWLOCK_RDLOCK(lbl,l) pl_take_r(l)
BUILD: thread: add parenthesis around values of locking macros clang just failed on fd.c with this error: src/fd.c:491:9: error: logical not is only applied to the left hand side of this comparison [-Werror,-Wlogical-not-parentheses] while (HA_SPIN_TRYLOCK(OTHER_LOCK, &log_lock) != 0) { ^ ~~ That's because this expands to this: while (!pl_try_s(&log_lock) != 0) { Let's just add parenthesis in the TRYLOCK macros to avoid this. This may need to be backported if commit df187875d ("BUG/MEDIUM: log: don't hold the log lock during writev() on a file descriptor") is backported as well as it seems to be the first one to trigger it.
2020-06-12 05:42:25 -04:00
#define HA_RWLOCK_TRYRDLOCK(lbl,l) (!pl_try_r(l))
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define HA_RWLOCK_RDUNLOCK(lbl,l) pl_drop_r(l)
#else /* !defined(DEBUG_THREAD) && !defined(DEBUG_FULL) */
/* Thread debugging is ENABLED, these are the instrumented functions */
#define __SPIN_INIT(l) ({ (*l) = 0; })
#define __SPIN_DESTROY(l) ({ (*l) = 0; })
#define __SPIN_LOCK(l) pl_take_s(l)
BUILD: thread: add parenthesis around values of locking macros clang just failed on fd.c with this error: src/fd.c:491:9: error: logical not is only applied to the left hand side of this comparison [-Werror,-Wlogical-not-parentheses] while (HA_SPIN_TRYLOCK(OTHER_LOCK, &log_lock) != 0) { ^ ~~ That's because this expands to this: while (!pl_try_s(&log_lock) != 0) { Let's just add parenthesis in the TRYLOCK macros to avoid this. This may need to be backported if commit df187875d ("BUG/MEDIUM: log: don't hold the log lock during writev() on a file descriptor") is backported as well as it seems to be the first one to trigger it.
2020-06-12 05:42:25 -04:00
#define __SPIN_TRYLOCK(l) (!pl_try_s(l))
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define __SPIN_UNLOCK(l) pl_drop_s(l)
#define __RWLOCK_INIT(l) ({ (*l) = 0; })
#define __RWLOCK_DESTROY(l) ({ (*l) = 0; })
#define __RWLOCK_WRLOCK(l) pl_take_w(l)
BUILD: thread: add parenthesis around values of locking macros clang just failed on fd.c with this error: src/fd.c:491:9: error: logical not is only applied to the left hand side of this comparison [-Werror,-Wlogical-not-parentheses] while (HA_SPIN_TRYLOCK(OTHER_LOCK, &log_lock) != 0) { ^ ~~ That's because this expands to this: while (!pl_try_s(&log_lock) != 0) { Let's just add parenthesis in the TRYLOCK macros to avoid this. This may need to be backported if commit df187875d ("BUG/MEDIUM: log: don't hold the log lock during writev() on a file descriptor") is backported as well as it seems to be the first one to trigger it.
2020-06-12 05:42:25 -04:00
#define __RWLOCK_TRYWRLOCK(l) (!pl_try_w(l))
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define __RWLOCK_WRUNLOCK(l) pl_drop_w(l)
#define __RWLOCK_RDLOCK(l) pl_take_r(l)
BUILD: thread: add parenthesis around values of locking macros clang just failed on fd.c with this error: src/fd.c:491:9: error: logical not is only applied to the left hand side of this comparison [-Werror,-Wlogical-not-parentheses] while (HA_SPIN_TRYLOCK(OTHER_LOCK, &log_lock) != 0) { ^ ~~ That's because this expands to this: while (!pl_try_s(&log_lock) != 0) { Let's just add parenthesis in the TRYLOCK macros to avoid this. This may need to be backported if commit df187875d ("BUG/MEDIUM: log: don't hold the log lock during writev() on a file descriptor") is backported as well as it seems to be the first one to trigger it.
2020-06-12 05:42:25 -04:00
#define __RWLOCK_TRYRDLOCK(l) (!pl_try_r(l))
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#define __RWLOCK_RDUNLOCK(l) pl_drop_r(l)
#define HA_SPIN_INIT(l) __spin_init(l)
#define HA_SPIN_DESTROY(l) __spin_destroy(l)
#define HA_SPIN_LOCK(lbl, l) __spin_lock(lbl, l, __func__, __FILE__, __LINE__)
#define HA_SPIN_TRYLOCK(lbl, l) __spin_trylock(lbl, l, __func__, __FILE__, __LINE__)
#define HA_SPIN_UNLOCK(lbl, l) __spin_unlock(lbl, l, __func__, __FILE__, __LINE__)
#define HA_RWLOCK_INIT(l) __ha_rwlock_init((l))
#define HA_RWLOCK_DESTROY(l) __ha_rwlock_destroy((l))
#define HA_RWLOCK_WRLOCK(lbl,l) __ha_rwlock_wrlock(lbl, l, __func__, __FILE__, __LINE__)
#define HA_RWLOCK_TRYWRLOCK(lbl,l) __ha_rwlock_trywrlock(lbl, l, __func__, __FILE__, __LINE__)
#define HA_RWLOCK_WRUNLOCK(lbl,l) __ha_rwlock_wrunlock(lbl, l, __func__, __FILE__, __LINE__)
#define HA_RWLOCK_RDLOCK(lbl,l) __ha_rwlock_rdlock(lbl, l)
#define HA_RWLOCK_TRYRDLOCK(lbl,l) __ha_rwlock_tryrdlock(lbl, l)
#define HA_RWLOCK_RDUNLOCK(lbl,l) __ha_rwlock_rdunlock(lbl, l)
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
/* WARNING!!! if you update this enum, please also keep lock_label() up to date
* below.
*/
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
enum lock_label {
MAJOR: threads/task: handle multithread on task scheduler 2 global locks have been added to protect, respectively, the run queue and the wait queue. And a process mask has been added on each task. Like for FDs, this mask is used to know which threads are allowed to process a task. For many tasks, all threads are granted. And this must be your first intension when you create a new task, else you have a good reason to make a task sticky on some threads. This is then the responsibility to the process callback to lock what have to be locked in the task context. Nevertheless, all tasks linked to a session must be sticky on the thread creating the session. It is important that I/O handlers processing session FDs and these tasks run on the same thread to avoid conflicts.
2017-09-27 08:59:38 -04:00
TASK_RQ_LOCK,
TASK_WQ_LOCK,
MEDIUM: threads/pool: Make pool thread-safe by locking all access to a pool A lock has been added for each memory pool. It is used to protect the pool during allocations and releases. It is also used when pool info are dumped.
2017-08-29 03:52:38 -04:00
POOL_LOCK,
MEDIUM: threads/listeners: Make listeners thread-safe First, we use atomic operations to update jobs/totalconn/actconn variables, listener's nbconn variable and listener's counters. Then we add a lock on listeners to protect access to their information. And finally, listener queues (global and per proxy) are also protected by a lock. Here, because access to these queues are unusal, we use the same lock for all queues instead of a global one for the global queue and a lock per proxy for others.
2017-05-30 09:36:50 -04:00
LISTENER_LOCK,
MEDIUM: threads/proxy: Add a lock per proxy and atomically update proxy vars Now, each proxy contains a lock that must be used when necessary to protect it. Moreover, all proxy's counters are now updated using atomic operations.
2017-06-02 09:33:24 -04:00
PROXY_LOCK,
MEDIUM: threads/server: Add a lock per server and atomically update server vars The server's lock is use, among other things, to lock acces to the active connection list of a server.
2017-06-08 08:04:45 -04:00
SERVER_LOCK,
MEDIUM: threads/lb: Make LB algorithms (lb_*.c) thread-safe A lock for LB parameters has been added inside the proxy structure and atomic operations have been used to update server variables releated to lb. The only significant change is about lb_map. Because the servers status are updated in the sync-point, we can call recalc_server_map function synchronously in map_set_server_status_up/down function.
2017-06-09 08:17:53 -04:00
LBPRM_LOCK,
MEDIUM: threads/signal: Add a lock to make signals thread-safe A global lock has been added to protect the signal processing. So when a signal it triggered, only one thread will catch it.
2017-05-30 09:34:30 -04:00
SIGNALS_LOCK,
MEDIUM: threads/stick-tables: handle multithreads on stick tables The stick table API was slightly reworked: A global spin lock on stick table was added to perform lookup and insert in a thread safe way. The handling of refcount on entries is now handled directly by stick tables functions under protection of this lock and was removed from the code of callers. The "stktable_store" function is no more externalized and users should now use "stktable_set_entry" in any case of insertion. This last one performs a lookup followed by a store if not found. So the code using "stktable_store" was re-worked. Lookup, and set_entry functions automatically increase the refcount of the returned/stored entry. The function "sticktable_touch" was renamed "sticktable_touch_local" and is now able to decrease the refcount if last arg is set to true. It is allowing to release the entry without taking the lock twice. A new function "sticktable_touch_remote" is now used to insert entries coming from remote peers at the right place in the update tree. The code of peer update was re-worked to use this new function. This function is also able to decrease the refcount if wanted. The function "stksess_kill" also handle a parameter to decrease the refcount on the entry. A read/write lock is added on each entry to protect the data content updates of the entry.
2017-06-13 13:37:32 -04:00
STK_TABLE_LOCK,
STK_SESS_LOCK,
MAJOR: threads/applet: Handle multithreading for applets A global lock has been added to protect accesses to the list of active applets. A process mask has also been added on each applet. Like for FDs and tasks, it is used to know which threads are allowed to process an applet. Because applets are, most of time, linked to a session, it should be sticky on the same thread. But in all cases, it is the responsibility of the applet handler to lock what have to be protected in the applet context.
2017-06-19 06:38:55 -04:00
APPLETS_LOCK,
MAJOR: threads/peers: Make peers thread safe A lock is used to protect accesses to a peer structure. A the lock is taken in the applet handler when the peer is identified and released living the applet handler. In the scheduling task for peers section, the lock is taken for every listed peer and released at the end of the process task function. The peer 'force shutdown' function was also re-worked.
2017-06-19 11:46:37 -04:00
PEER_LOCK,
MEDIUM: threads/stream: Make streams list thread safe Adds a global lock to protect the full streams list used to dump sessions on stats socket.
2017-06-30 10:23:45 -04:00
STRMS_LOCK,
MAJOR: threads/ssl: Make SSL part thread-safe First, OpenSSL is now initialized to be thread-safe. This is done by setting 2 callbacks. The first one is ssl_locking_function. It handles the locks and unlocks. The second one is ssl_id_function. It returns the current thread id. During the init step, we create as much as R/W locks as needed, ie the number returned by CRYPTO_num_locks function. Next, The reusable SSL session in the server context is now thread-local. Shctx is now also initialized if HAProxy is started with several threads. And finally, a global lock has been added to protect the LRU cache used to store generated certificates. The function ssl_sock_get_generated_cert is now deprecated because the retrieved certificate can be removed by another threads in same time. Instead, a new function has been added, ssl_sock_assign_generated_cert. It must be used to search a certificate in the cache and set it immediatly if found.
2017-06-15 10:37:39 -04:00
SSL_LOCK,
SSL_GEN_CERTS_LOCK,
MAJOR: threads/map: Make acls/maps thread safe locks have been added in pat_ref and pattern_expr structures to protect all accesses to an instance of on of them. Moreover, a global lock has been added to protect the LRU cache used for pattern matching. Patterns are now duplicated after a successfull matching, to avoid modification by other threads when the result is used. Finally, the function reloading a pattern list has been modified to be thread-safe.
2017-07-03 05:34:05 -04:00
PATREF_LOCK,
PATEXP_LOCK,
MEDIUM: thread/vars: Make vars thread-safe A RW lock has been added to the vars structure to protect each list of variables. And a global RW lock is used to protect registered names. When a varibable is fetched, we duplicate sample data because the variable could be modified by another thread.
2017-07-24 10:30:34 -04:00
VARS_LOCK,
MEDIUM: threads/compression: Make HTTP compression thread-safe
2017-07-25 05:07:15 -04:00
COMP_POOL_LOCK,
MEDIUM: threads/lua: Add locks around the Lua execution parts. Note that the Lua processing is not really thread safe. It provides heavy system which consists to add our own lock function in the Lua code and recompile the library. This system will probably not accepted by maintainers of various distribs. Our main excution point of the Lua is the function lua_resume(). A quick looking on the Lua sources displays a lua_lock() a the start of function and a lua_unlock() at the end of the function. So I conclude that the Lua thread safe mode just perform a mutex around all execution. So I prefer to do this in the HAProxy code, it will be easier for distro maintainers. Note that the HAProxy lua functions rounded by the macro SET_SAFE_LJMP and RESET_SAFE_LJMP manipulates the Lua stack, so it will be careful to set mutex around these functions.
2017-07-12 05:41:21 -04:00
LUA_LOCK,
MEDIUM: threads/tasks: Add lock around notifications This patch add lock around some notification calls
2017-07-16 18:14:07 -04:00
NOTIF_LOCK,
MEDIUM: thread/spoe: Make the SPOE thread-safe Because there is not migration mechanism yet, all runtime information about an SPOE agent are thread-local and async exchanges with agents are disabled when we have serveral threads. Howerver, pipelining is still available. So for now, the thread part of the SPOE is pretty simple.
2017-09-25 08:48:02 -04:00
SPOE_APPLET_LOCK,
MEDIUM: thread/dns: Make DNS thread-safe
2017-10-04 10:17:58 -04:00
DNS_LOCK,
MINOR: threads/checks: Add a lock to protect the pid list used by external checks
2017-10-20 09:40:23 -04:00
PID_LIST_LOCK,
MINOR: threads/mailers: Add a lock to protect queues of email alerts
2017-10-23 09:54:24 -04:00
EMAIL_ALERTS_LOCK,
BUG/MEDIUM: splice/threads: pipe reuse list was not protected. The list is now protected using a global spinlock.
2017-11-07 05:19:48 -05:00
PIPES_LOCK,
BUG/MINOR: ssl/threads: Make management of the TLS ticket keys files thread-safe A TLS ticket keys file can be updated on the CLI and used in same time. So we need to protect it to be sure all accesses are thread-safe. Because updates are infrequent, a R/W lock has been used. This patch must be backported in 1.8
2018-02-16 05:23:49 -05:00
TLSKEYS_REF_LOCK,
BUG/MEDIUM: auth/threads: use of crypt() is not thread-safe It was reported here that authentication may fail when threads are enabled : https://bugzilla.redhat.com/show_bug.cgi?id=1643941 While I couldn't reproduce the issue, it's obvious that there is a problem with the use of the non-reentrant crypt() function there. On Linux systems there's crypt_r() but not on the vast majority of other ones. Thus a first approach consists in placing a lock around this crypt() call. Another patch may relax it when crypt_r() is available. This fix must be backported to 1.8. Thanks to Ryan O'Hara for the quick notification.
2018-10-29 13:02:54 -04:00
AUTH_LOCK,
MINOR: log: Enable the log sampling and load-balancing feature. This patch implements the sampling and load-balancing of log servers configured with "sample" new keyword implemented by this commit: 'MINOR: log: Add "sample" new keyword to "log" lines'. As the list of ranges used to sample the log to balance is ordered, we only have to maintain ->curr_idx member of smp_info struct which is the index of the sample and check if it belongs or not to the current range to decide if we must send it to the log server or not.
2019-04-25 01:42:09 -04:00
LOGSRV_LOCK,
MINOR: dict: Add dictionary new data structure. This patch adds minimalistic definitions to implement dictionary new data structure which is an ebtree of ebpt_node structs with strings as keys. Note that this has nothing to see with real dictionary data structure (maps of keys in association with values).
2019-05-28 08:47:17 -04:00
DICT_LOCK,
BUILD: threads: add the definition of PROTO_LOCK This one was added by commit daacf3664 ("BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff") but I forgot to add it to the include file, breaking DEBUG_THREAD.
2019-07-25 01:53:56 -04:00
PROTO_LOCK,
MEDIUM: ssl/cli: 'set ssl cert' updates a certificate from the CLI $ echo -e "set ssl cert certificate.pem <<\n$(cat certificate2.pem)\n" | \ socat stdio /var/run/haproxy.stat Certificate updated! The operation is locked at the ckch level with a HA_SPINLOCK_T which prevents the ckch architecture (ckch_store, ckch_inst..) to be modified at the same time. So you can't do a certificate update at the same time from multiple CLI connections. SNI trees are also locked with a HA_RWLOCK_T so reading operations are locked only during a certificate update. Bundles are supported but you need to update each file (.rsa|ecdsa|.dsa) independently. If a file is used in the configuration as a bundle AND as a unique certificate, both will be updated. Bundles, directories and crt-list are supported, however filters in crt-list are currently unsupported. The code tries to allocate every SNIs and certificate instances first, so it can rollback the operation if that was unsuccessful. If you have too much instances of the certificate (at least 20000 in my tests on my laptop), the function can take too much time and be killed by the watchdog. This will be fixed later. Also with too much certificates it's possible that socat exits before the end of the generation without displaying a message, consider changing the socat timeout in this case (-t2 for example). The size of the certificate is currently limited by the maximum size of a payload, that must fit in a buffer.
2019-09-19 11:12:49 -04:00
CKCH_LOCK,
SNI_LOCK,
MEDIUM: ring: add server statement to forward messages from a ring This patch adds new statement "server" into ring section, and the related "timeout connect" and "timeout server". server <name> <address> [param*] Used to configure a syslog tcp server to forward messages from ring buffer. This supports for all "server" parameters found in 5.2 paragraph. Some of these parameters are irrelevant for "ring" sections. timeout connect <timeout> Set the maximum time to wait for a connection attempt to a server to succeed. Arguments : <timeout> is the timeout value specified in milliseconds by default, but can be in any other unit if the number is suffixed by the unit, as explained at the top of this document. timeout server <timeout> Set the maximum time for pending data staying into output buffer. Arguments : <timeout> is the timeout value specified in milliseconds by default, but can be in any other unit if the number is suffixed by the unit, as explained at the top of this document. Example: global log ring@myring local7 ring myring description "My local buffer" format rfc3164 maxlen 1200 size 32764 timeout connect 5s timeout server 10s server mysyslogsrv 127.0.0.1:6514
2020-05-28 05:13:15 -04:00
SFT_LOCK, /* sink forward target */
MEDIUM: 51d: Enabled multi threaded operation in the 51Degrees module. The existing threading flag in the 51Degrees API (FIFTYONEDEGREES_NO_THREADING) has now been mapped to the HAProxy threading flag (USE_THREAD), and the 51Degrees module code has been made thread safe. In Pattern, the cache is now locked with a spin lock from hathreads.h using a new lable 'OTHER_LOCK'. The workset pool is now created with the same size as the number of threads to avoid any time waiting on a worket. In Hash Trie, the global device offsets structure is only used in single threaded operation. Multi threaded operation creates a new offsets structure in each thread.
2019-02-05 08:24:00 -05:00
OTHER_LOCK,
MEDIUM: threads: Adds a set of functions to handle sync-point A sync-point is a protected area where you have the warranty that no concurrency access is possible. It is implementated as a thread barrier to enter in the sync-point and another one to exit from it. Inside the sync-point, all threads that must do some syncrhonous processing will be called one after the other while all other threads will wait. All threads will then exit from the sync-point at the same time. A sync-point will be evaluated only when necessary because it is a costly operation. To limit the waiting time of each threads, we must have a mechanism to wakeup all threads. This is done with a pipe shared by all threads. By writting in this pipe, we will interrupt all threads blocked on a poller. The pipe is then flushed before exiting from the sync-point.
2017-10-19 05:59:15 -04:00
LOCK_LABELS
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
};
extern struct lock_stat lock_stats[LOCK_LABELS];
BUG/MINOR: threads: Update labels array because of changes in lock_label enum Recent changes to the enum were not synchronized with the lock debugging code. Now we use a switch/case instead of an array so that the compiler throws a warning if there is any inconsistency. To be backported to 1.8 (at least to add the START entry).
2018-01-30 05:04:29 -05:00
static inline const char *lock_label(enum lock_label label)
{
switch (label) {
case TASK_RQ_LOCK: return "TASK_RQ";
case TASK_WQ_LOCK: return "TASK_WQ";
case POOL_LOCK: return "POOL";
case LISTENER_LOCK: return "LISTENER";
case PROXY_LOCK: return "PROXY";
case SERVER_LOCK: return "SERVER";
case LBPRM_LOCK: return "LBPRM";
case SIGNALS_LOCK: return "SIGNALS";
case STK_TABLE_LOCK: return "STK_TABLE";
case STK_SESS_LOCK: return "STK_SESS";
case APPLETS_LOCK: return "APPLETS";
case PEER_LOCK: return "PEER";
case STRMS_LOCK: return "STRMS";
case SSL_LOCK: return "SSL";
case SSL_GEN_CERTS_LOCK: return "SSL_GEN_CERTS";
case PATREF_LOCK: return "PATREF";
case PATEXP_LOCK: return "PATEXP";
case VARS_LOCK: return "VARS";
case COMP_POOL_LOCK: return "COMP_POOL";
case LUA_LOCK: return "LUA";
case NOTIF_LOCK: return "NOTIF";
case SPOE_APPLET_LOCK: return "SPOE_APPLET";
case DNS_LOCK: return "DNS";
case PID_LIST_LOCK: return "PID_LIST";
case EMAIL_ALERTS_LOCK: return "EMAIL_ALERTS";
case PIPES_LOCK: return "PIPES";
BUG/MINOR: ssl/threads: Make management of the TLS ticket keys files thread-safe A TLS ticket keys file can be updated on the CLI and used in same time. So we need to protect it to be sure all accesses are thread-safe. Because updates are infrequent, a R/W lock has been used. This patch must be backported in 1.8
2018-02-16 05:23:49 -05:00
case TLSKEYS_REF_LOCK: return "TLSKEYS_REF";
BUG/MEDIUM: auth/threads: use of crypt() is not thread-safe It was reported here that authentication may fail when threads are enabled : https://bugzilla.redhat.com/show_bug.cgi?id=1643941 While I couldn't reproduce the issue, it's obvious that there is a problem with the use of the non-reentrant crypt() function there. On Linux systems there's crypt_r() but not on the vast majority of other ones. Thus a first approach consists in placing a lock around this crypt() call. Another patch may relax it when crypt_r() is available. This fix must be backported to 1.8. Thanks to Ryan O'Hara for the quick notification.
2018-10-29 13:02:54 -04:00
case AUTH_LOCK: return "AUTH";
MINOR: log: Enable the log sampling and load-balancing feature. This patch implements the sampling and load-balancing of log servers configured with "sample" new keyword implemented by this commit: 'MINOR: log: Add "sample" new keyword to "log" lines'. As the list of ranges used to sample the log to balance is ordered, we only have to maintain ->curr_idx member of smp_info struct which is the index of the sample and check if it belongs or not to the current range to decide if we must send it to the log server or not.
2019-04-25 01:42:09 -04:00
case LOGSRV_LOCK: return "LOGSRV";
MINOR: dict: Add dictionary new data structure. This patch adds minimalistic definitions to implement dictionary new data structure which is an ebtree of ebpt_node structs with strings as keys. Note that this has nothing to see with real dictionary data structure (maps of keys in association with values).
2019-05-28 08:47:17 -04:00
case DICT_LOCK: return "DICT";
BUILD: threads: add the definition of PROTO_LOCK This one was added by commit daacf3664 ("BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff") but I forgot to add it to the include file, breaking DEBUG_THREAD.
2019-07-25 01:53:56 -04:00
case PROTO_LOCK: return "PROTO";
MEDIUM: ssl/cli: 'set ssl cert' updates a certificate from the CLI $ echo -e "set ssl cert certificate.pem <<\n$(cat certificate2.pem)\n" | \ socat stdio /var/run/haproxy.stat Certificate updated! The operation is locked at the ckch level with a HA_SPINLOCK_T which prevents the ckch architecture (ckch_store, ckch_inst..) to be modified at the same time. So you can't do a certificate update at the same time from multiple CLI connections. SNI trees are also locked with a HA_RWLOCK_T so reading operations are locked only during a certificate update. Bundles are supported but you need to update each file (.rsa|ecdsa|.dsa) independently. If a file is used in the configuration as a bundle AND as a unique certificate, both will be updated. Bundles, directories and crt-list are supported, however filters in crt-list are currently unsupported. The code tries to allocate every SNIs and certificate instances first, so it can rollback the operation if that was unsuccessful. If you have too much instances of the certificate (at least 20000 in my tests on my laptop), the function can take too much time and be killed by the watchdog. This will be fixed later. Also with too much certificates it's possible that socat exits before the end of the generation without displaying a message, consider changing the socat timeout in this case (-t2 for example). The size of the certificate is currently limited by the maximum size of a payload, that must fit in a buffer.
2019-09-19 11:12:49 -04:00
case CKCH_LOCK: return "CKCH";
case SNI_LOCK: return "SNI";
MEDIUM: ring: add server statement to forward messages from a ring This patch adds new statement "server" into ring section, and the related "timeout connect" and "timeout server". server <name> <address> [param*] Used to configure a syslog tcp server to forward messages from ring buffer. This supports for all "server" parameters found in 5.2 paragraph. Some of these parameters are irrelevant for "ring" sections. timeout connect <timeout> Set the maximum time to wait for a connection attempt to a server to succeed. Arguments : <timeout> is the timeout value specified in milliseconds by default, but can be in any other unit if the number is suffixed by the unit, as explained at the top of this document. timeout server <timeout> Set the maximum time for pending data staying into output buffer. Arguments : <timeout> is the timeout value specified in milliseconds by default, but can be in any other unit if the number is suffixed by the unit, as explained at the top of this document. Example: global log ring@myring local7 ring myring description "My local buffer" format rfc3164 maxlen 1200 size 32764 timeout connect 5s timeout server 10s server mysyslogsrv 127.0.0.1:6514
2020-05-28 05:13:15 -04:00
case SFT_LOCK: return "SFT";
MEDIUM: 51d: Enabled multi threaded operation in the 51Degrees module. The existing threading flag in the 51Degrees API (FIFTYONEDEGREES_NO_THREADING) has now been mapped to the HAProxy threading flag (USE_THREAD), and the 51Degrees module code has been made thread safe. In Pattern, the cache is now locked with a spin lock from hathreads.h using a new lable 'OTHER_LOCK'. The workset pool is now created with the same size as the number of threads to avoid any time waiting on a worket. In Hash Trie, the global device offsets structure is only used in single threaded operation. Multi threaded operation creates a new offsets structure in each thread.
2019-02-05 08:24:00 -05:00
case OTHER_LOCK: return "OTHER";
BUG/MINOR: threads: Update labels array because of changes in lock_label enum Recent changes to the enum were not synchronized with the lock debugging code. Now we use a switch/case instead of an array so that the compiler throws a warning if there is any inconsistency. To be backported to 1.8 (at least to add the START entry).
2018-01-30 05:04:29 -05:00
case LOCK_LABELS: break; /* keep compiler happy */
};
/* only way to come here is consecutive to an internal bug */
abort();
}
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
static inline void show_lock_stats()
{
int lbl;
for (lbl = 0; lbl < LOCK_LABELS; lbl++) {
fprintf(stderr,
"Stats about Lock %s: \n"
"\t # write lock : %lu\n"
"\t # write unlock: %lu (%ld)\n"
"\t # wait time for write : %.3f msec\n"
"\t # wait time for write/lock: %.3f nsec\n"
"\t # read lock : %lu\n"
"\t # read unlock : %lu (%ld)\n"
"\t # wait time for read : %.3f msec\n"
"\t # wait time for read/lock : %.3f nsec\n",
BUG/MINOR: threads: Update labels array because of changes in lock_label enum Recent changes to the enum were not synchronized with the lock debugging code. Now we use a switch/case instead of an array so that the compiler throws a warning if there is any inconsistency. To be backported to 1.8 (at least to add the START entry).
2018-01-30 05:04:29 -05:00
lock_label(lbl),
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
lock_stats[lbl].num_write_locked,
lock_stats[lbl].num_write_unlocked,
lock_stats[lbl].num_write_unlocked - lock_stats[lbl].num_write_locked,
(double)lock_stats[lbl].nsec_wait_for_write / 1000000.0,
lock_stats[lbl].num_write_locked ? ((double)lock_stats[lbl].nsec_wait_for_write / (double)lock_stats[lbl].num_write_locked) : 0,
lock_stats[lbl].num_read_locked,
lock_stats[lbl].num_read_unlocked,
lock_stats[lbl].num_read_unlocked - lock_stats[lbl].num_read_locked,
(double)lock_stats[lbl].nsec_wait_for_read / 1000000.0,
lock_stats[lbl].num_read_locked ? ((double)lock_stats[lbl].nsec_wait_for_read / (double)lock_stats[lbl].num_read_locked) : 0);
}
}
/* Following functions are used to collect some stats about locks. We wrap
* pthread functions to known how much time we wait in a lock. */
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
static uint64_t nsec_now(void)
{
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ((uint64_t) ts.tv_sec * 1000000000ULL +
(uint64_t) ts.tv_nsec);
}
static inline void __ha_rwlock_init(struct ha_rwlock *l)
{
memset(l, 0, sizeof(struct ha_rwlock));
__RWLOCK_INIT(&l->lock);
}
static inline void __ha_rwlock_destroy(struct ha_rwlock *l)
{
__RWLOCK_DESTROY(&l->lock);
memset(l, 0, sizeof(struct ha_rwlock));
}
static inline void __ha_rwlock_wrlock(enum lock_label lbl, struct ha_rwlock *l,
const char *func, const char *file, int line)
{
uint64_t start_time;
if (unlikely(l->info.cur_writer & tid_bit)) {
/* the thread is already owning the lock for write */
abort();
}
if (unlikely(l->info.cur_readers & tid_bit)) {
/* the thread is already owning the lock for read */
abort();
}
HA_ATOMIC_OR(&l->info.wait_writers, tid_bit);
start_time = nsec_now();
__RWLOCK_WRLOCK(&l->lock);
HA_ATOMIC_ADD(&lock_stats[lbl].nsec_wait_for_write, (nsec_now() - start_time));
HA_ATOMIC_ADD(&lock_stats[lbl].num_write_locked, 1);
l->info.cur_writer = tid_bit;
l->info.last_location.function = func;
l->info.last_location.file = file;
l->info.last_location.line = line;
HA_ATOMIC_AND(&l->info.wait_writers, ~tid_bit);
}
static inline int __ha_rwlock_trywrlock(enum lock_label lbl, struct ha_rwlock *l,
const char *func, const char *file, int line)
{
uint64_t start_time;
int r;
if (unlikely(l->info.cur_writer & tid_bit)) {
/* the thread is already owning the lock for write */
abort();
}
if (unlikely(l->info.cur_readers & tid_bit)) {
/* the thread is already owning the lock for read */
abort();
}
/* We set waiting writer because trywrlock could wait for readers to quit */
HA_ATOMIC_OR(&l->info.wait_writers, tid_bit);
start_time = nsec_now();
r = __RWLOCK_TRYWRLOCK(&l->lock);
HA_ATOMIC_ADD(&lock_stats[lbl].nsec_wait_for_write, (nsec_now() - start_time));
if (unlikely(r)) {
HA_ATOMIC_AND(&l->info.wait_writers, ~tid_bit);
return r;
}
HA_ATOMIC_ADD(&lock_stats[lbl].num_write_locked, 1);
l->info.cur_writer = tid_bit;
l->info.last_location.function = func;
l->info.last_location.file = file;
l->info.last_location.line = line;
HA_ATOMIC_AND(&l->info.wait_writers, ~tid_bit);
return 0;
}
static inline void __ha_rwlock_wrunlock(enum lock_label lbl,struct ha_rwlock *l,
const char *func, const char *file, int line)
{
if (unlikely(!(l->info.cur_writer & tid_bit))) {
/* the thread is not owning the lock for write */
abort();
}
l->info.cur_writer = 0;
l->info.last_location.function = func;
l->info.last_location.file = file;
l->info.last_location.line = line;
__RWLOCK_WRUNLOCK(&l->lock);
HA_ATOMIC_ADD(&lock_stats[lbl].num_write_unlocked, 1);
}
static inline void __ha_rwlock_rdlock(enum lock_label lbl,struct ha_rwlock *l)
{
uint64_t start_time;
if (unlikely(l->info.cur_writer & tid_bit)) {
/* the thread is already owning the lock for write */
abort();
}
if (unlikely(l->info.cur_readers & tid_bit)) {
/* the thread is already owning the lock for read */
abort();
}
HA_ATOMIC_OR(&l->info.wait_readers, tid_bit);
start_time = nsec_now();
__RWLOCK_RDLOCK(&l->lock);
HA_ATOMIC_ADD(&lock_stats[lbl].nsec_wait_for_read, (nsec_now() - start_time));
HA_ATOMIC_ADD(&lock_stats[lbl].num_read_locked, 1);
HA_ATOMIC_OR(&l->info.cur_readers, tid_bit);
HA_ATOMIC_AND(&l->info.wait_readers, ~tid_bit);
}
static inline int __ha_rwlock_tryrdlock(enum lock_label lbl,struct ha_rwlock *l)
{
int r;
if (unlikely(l->info.cur_writer & tid_bit)) {
/* the thread is already owning the lock for write */
abort();
}
if (unlikely(l->info.cur_readers & tid_bit)) {
/* the thread is already owning the lock for read */
abort();
}
/* try read should never wait */
r = __RWLOCK_TRYRDLOCK(&l->lock);
if (unlikely(r))
return r;
HA_ATOMIC_ADD(&lock_stats[lbl].num_read_locked, 1);
HA_ATOMIC_OR(&l->info.cur_readers, tid_bit);
return 0;
}
static inline void __ha_rwlock_rdunlock(enum lock_label lbl,struct ha_rwlock *l)
{
if (unlikely(!(l->info.cur_readers & tid_bit))) {
/* the thread is not owning the lock for read */
abort();
}
HA_ATOMIC_AND(&l->info.cur_readers, ~tid_bit);
__RWLOCK_RDUNLOCK(&l->lock);
HA_ATOMIC_ADD(&lock_stats[lbl].num_read_unlocked, 1);
}
static inline void __spin_init(struct ha_spinlock *l)
{
memset(l, 0, sizeof(struct ha_spinlock));
__SPIN_INIT(&l->lock);
}
static inline void __spin_destroy(struct ha_spinlock *l)
{
__SPIN_DESTROY(&l->lock);
memset(l, 0, sizeof(struct ha_spinlock));
}
static inline void __spin_lock(enum lock_label lbl, struct ha_spinlock *l,
const char *func, const char *file, int line)
{
uint64_t start_time;
if (unlikely(l->info.owner & tid_bit)) {
/* the thread is already owning the lock */
abort();
}
HA_ATOMIC_OR(&l->info.waiters, tid_bit);
start_time = nsec_now();
__SPIN_LOCK(&l->lock);
HA_ATOMIC_ADD(&lock_stats[lbl].nsec_wait_for_write, (nsec_now() - start_time));
HA_ATOMIC_ADD(&lock_stats[lbl].num_write_locked, 1);
l->info.owner = tid_bit;
l->info.last_location.function = func;
l->info.last_location.file = file;
l->info.last_location.line = line;
HA_ATOMIC_AND(&l->info.waiters, ~tid_bit);
}
static inline int __spin_trylock(enum lock_label lbl, struct ha_spinlock *l,
const char *func, const char *file, int line)
{
int r;
if (unlikely(l->info.owner & tid_bit)) {
/* the thread is already owning the lock */
abort();
}
/* try read should never wait */
r = __SPIN_TRYLOCK(&l->lock);
if (unlikely(r))
return r;
HA_ATOMIC_ADD(&lock_stats[lbl].num_write_locked, 1);
l->info.owner = tid_bit;
l->info.last_location.function = func;
l->info.last_location.file = file;
l->info.last_location.line = line;
return 0;
}
static inline void __spin_unlock(enum lock_label lbl, struct ha_spinlock *l,
const char *func, const char *file, int line)
{
if (unlikely(!(l->info.owner & tid_bit))) {
/* the thread is not owning the lock */
abort();
}
l->info.owner = 0;
l->info.last_location.function = func;
l->info.last_location.file = file;
l->info.last_location.line = line;
BUG/MINOR: thread: fix a typo in the debug code __spin_unlock() used to call RWLOCK_WRUNLOCK() to unlock in the debug code. It's harmless as they happen to be identical.
2017-11-02 11:26:02 -04:00
__SPIN_UNLOCK(&l->lock);
MEDIUM: threads: Add hathreads header file This file contains all functions and macros used to deal with concurrency in HAProxy. It contains all high-level function to do atomic operation (HA_ATOMIC_*). Note, for now, we rely on "__atomic" GCC builtins to do atomic operation. So HAProxy can be compiled with the thread support iff these builtins are available. It also contains wrappers around plocks to use spin or read/write locks. These wrappers are used to abstract the internal representation of the locking system and to add information to help debugging, when compiled with suitable options. To add extra info on locks, you need to add DEBUG=-DDEBUG_THREAD or DEBUG=-DDEBUG_FULL compilation option. In addition to timing info on locks, we keep info on where a lock was acquired the last time (function name, file and line). There are also the thread id and a flag to know if it is still locked or not. This will be useful to debug deadlocks.
2017-10-12 10:09:09 -04:00
HA_ATOMIC_ADD(&lock_stats[lbl].num_write_unlocked, 1);
}
#endif /* DEBUG_THREAD */
#endif /* USE_THREAD */
REORG: include: split hathreads into haproxy/thread.h and haproxy/thread-t.h This splits the hathreads.h file into types+macros and functions. Given that most users of this file used to include it only to get the definition of THREAD_LOCAL and MAXTHREADS, the bare minimum was placed into thread-t.h (i.e. types and macros). All the thread management was left to haproxy/thread.h. It's worth noting the drop of the trailing "s" in the name, to remove the permanent confusion that arises between this one and the system implementation (no "s") and the makefile's option (no "s"). For consistency, src/hathreads.c was also renamed thread.c. A number of files were updated to only include thread-t which is the one they really needed. Some future improvements are possible like replacing empty inlined functions with macros for the thread-less case, as building at -O0 disables inlining and causes these ones to be emitted. But this really is cosmetic.
2020-05-28 09:29:19 -04:00
#endif /* _HAPROXY_THREAD_H */
Reference in a new issue Copy permalink