include/urcu/tls-compat.h

   1 #ifndef _URCU_TLS_COMPAT_H
   2 #define _URCU_TLS_COMPAT_H
   3
   4 /*
   5  * urcu/tls-compat.h
   6  *
   7  * Userspace RCU library - Thread-Local Storage Compatibility Header
   8  *
   9  * Copyright 2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  */
  25
  26 #include <stdlib.h>
  27 #include <urcu/config.h>
  28 #include <urcu/compiler.h>
  29 #include <urcu/arch.h>
  30
  31 #ifdef __cplusplus
  32 extern "C" {
  33 #endif
  34
  35 #ifdef CONFIG_RCU_TLS
  36
  37 /*
  38  * Default to '__thread' on all C and C++ compilers except MSVC. While C11 has
  39  * '_Thread_local' and C++11 has 'thread_local', only '__thread' seems to have
  40  * a compatible implementation when linking public extern symbols across
  41  * language boundaries.
  42  *
  43  * For more details, see 'https://gcc.gnu.org/onlinedocs/gcc/Thread-Local.html'.
  44  */
  45 #if defined(_MSC_VER)
  46 # define URCU_TLS_STORAGE_CLASS __declspec(thread)
  47 #else
  48 # define URCU_TLS_STORAGE_CLASS __thread
  49 #endif
  50
  51 /*
  52  * Hint: How to define/declare TLS variables of compound types
  53  *       such as array or function pointers?
  54  *
  55  * Answer: Use typedef to assign a type_name to the compound type.
  56  * Example: Define a TLS variable which is an int array with len=4:
  57  *
  58  *      typedef int my_int_array_type[4];
  59  *      DEFINE_URCU_TLS(my_int_array_type, var_name);
  60  *
  61  * Another example:
  62  *      typedef void (*call_rcu_flavor)(struct rcu_head *, XXXX);
  63  *      DECLARE_URCU_TLS(call_rcu_flavor, p_call_rcu);
  64  *
  65  * NOTE: URCU_TLS() is NOT async-signal-safe, you can't use it
  66  * inside any function which can be called from signal handler.
  67  *
  68  * But if pthread_getspecific() is async-signal-safe in your
  69  * platform, you can make URCU_TLS() async-signal-safe via:
  70  * ensuring the first call to URCU_TLS() of a given TLS variable of
  71  * all threads is called earliest from a non-signal handler function.
  72  *
  73  * Example: In any thread, the first call of URCU_TLS(rcu_reader)
  74  * is called from rcu_register_thread(), so we can ensure all later
  75  * URCU_TLS(rcu_reader) in any thread is async-signal-safe.
  76  *
  77  * Moreover, URCU_TLS variables should not be touched from signal
  78  * handlers setup with with sigaltstack(2).
  79  */
  80
  81 # define DECLARE_URCU_TLS(type, name)   \
  82         URCU_TLS_STORAGE_CLASS type name
  83
  84 # define DEFINE_URCU_TLS(type, name)    \
  85         URCU_TLS_STORAGE_CLASS type name
  86
  87 # define DEFINE_URCU_TLS_INIT(type, name, init) \
  88         URCU_TLS_STORAGE_CLASS type name = (init)
  89
  90 # define URCU_TLS(name)         (name)
  91
  92 #else /* #ifndef CONFIG_RCU_TLS */
  93
  94 /*
  95  * The *_1() macros ensure macro parameters are expanded.
  96  */
  97
  98 # include <pthread.h>
  99
 100 struct urcu_tls {
 101         pthread_key_t key;
 102         pthread_mutex_t init_mutex;
 103         int init_done;
 104 };
 105
 106 # define DECLARE_URCU_TLS_1(type, name)                         \
 107         type *__tls_access_ ## name(void)
 108 # define DECLARE_URCU_TLS(type, name)                           \
 109         DECLARE_URCU_TLS_1(type, name)
 110
 111 /*
 112  * Note: we don't free memory at process exit, since it will be dealt
 113  * with by the OS.
 114  */
 115 # define DEFINE_URCU_TLS_INIT_1(type, name, do_init)            \
 116         type *__tls_access_ ## name(void)                       \
 117         {                                                       \
 118                 static struct urcu_tls __tls_ ## name = {       \
 119                         .key = 0,                               \
 120                         .init_mutex = PTHREAD_MUTEX_INITIALIZER,\
 121                         .init_done = 0,                         \
 122                 };                                              \
 123                 __typeof__(type) *__tls_p;                      \
 124                 if (!__tls_ ## name.init_done) {                \
 125                         /* Mutex to protect concurrent init */  \
 126                         pthread_mutex_lock(&__tls_ ## name.init_mutex); \
 127                         if (!__tls_ ## name.init_done) {        \
 128                                 (void) pthread_key_create(&__tls_ ## name.key, \
 129                                         free);                  \
 130                                 cmm_smp_wmb();  /* create key before write init_done */ \
 131                                 __tls_ ## name.init_done = 1;   \
 132                         }                                       \
 133                         pthread_mutex_unlock(&__tls_ ## name.init_mutex); \
 134                 }                                               \
 135                 cmm_smp_rmb();  /* read init_done before getting key */ \
 136                 __tls_p = (__typeof__(type) *) pthread_getspecific(__tls_ ## name.key); \
 137                 if (caa_unlikely(__tls_p == NULL)) {            \
 138                         __tls_p = (__typeof__(type) *) calloc(1, sizeof(type)); \
 139                         do_init                                 \
 140                         (void) pthread_setspecific(__tls_ ## name.key,  \
 141                                 __tls_p);                       \
 142                 }                                               \
 143                 return __tls_p;                                 \
 144         }
 145
 146 # define _URCU_TLS_INIT(init)                                   \
 147         *__tls_p = (init);
 148
 149 # define DEFINE_URCU_TLS_INIT(type, name, init)                 \
 150         DEFINE_URCU_TLS_INIT_1(type, name, _URCU_TLS_INIT(init))
 151
 152 # define DEFINE_URCU_TLS(type, name)                            \
 153         DEFINE_URCU_TLS_INIT_1(type, name, /* empty */)
 154
 155 # define URCU_TLS_1(name)       (*__tls_access_ ## name())
 156
 157 # define URCU_TLS(name)         URCU_TLS_1(name)
 158
 159 #endif  /* #else #ifndef CONFIG_RCU_TLS */
 160
 161 #ifdef __cplusplus
 162 }
 163 #endif
 164
 165 #endif /* _URCU_TLS_COMPAT_H */