th_com.inc

   1 /*
   2  * Copyright (C) 2024 Mikulas Patocka
   3  *
   4  * This file is part of Ajla.
   5  *
   6  * Ajla is free software: you can redistribute it and/or modify it under the
   7  * terms of the GNU General Public License as published by the Free Software
   8  * Foundation, either version 3 of the License, or (at your option) any later
   9  * version.
  10  *
  11  * Ajla is distributed in the hope that it will be useful, but WITHOUT ANY
  12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  13  * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * Ajla. If not, see <https://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifdef DEBUG_OBJECT_POSSIBLE
  20 #include "obj_reg.h"
  21 #endif
  22
  23 #ifdef DEBUG_OBJECT_POSSIBLE
  24 static bool mutex_debug = false;
  25 static bool thread_debug = false;
  26 #else
  27 static const bool mutex_debug = false;
  28 static const bool thread_debug = false;
  29 #endif
  30
  31 #if defined(DEBUG_OBJECT_POSSIBLE) || !defined(THREAD_NONE)
  32
  33 void mutex_init_position(mutex_t *m argument_position)
  34 {
  35         if (unlikely(mutex_debug))
  36                 obj_registry_insert(OBJ_TYPE_MUTEX, ptr_to_num((void *)m), position_arg);
  37         do_mutex_init(m);
  38 }
  39
  40 void mutex_done_position(mutex_t *m argument_position)
  41 {
  42         if (unlikely(mutex_debug))
  43                 obj_registry_remove(OBJ_TYPE_MUTEX, ptr_to_num((void *)m), position_arg);
  44         do_mutex_done(m);
  45 }
  46
  47 void attr_fastcall mutex_lock_position(mutex_t *m argument_position)
  48 {
  49         if (unlikely(mutex_debug))
  50                 obj_registry_verify(OBJ_TYPE_MUTEX, ptr_to_num((void *)m), position_arg);
  51         do_mutex_lock(m);
  52 }
  53
  54 bool attr_fastcall mutex_trylock_position(mutex_t *m argument_position)
  55 {
  56         if (unlikely(mutex_debug))
  57                 obj_registry_verify(OBJ_TYPE_MUTEX, ptr_to_num((void *)m), position_arg);
  58         do_mutex_trylock(m);
  59         not_reached();
  60         return false;
  61 }
  62
  63 void attr_fastcall mutex_unlock_position(mutex_t *m argument_position)
  64 {
  65         if (unlikely(mutex_debug))
  66                 obj_registry_verify(OBJ_TYPE_MUTEX, ptr_to_num((void *)m), position_arg);
  67         do_mutex_unlock(m);
  68 }
  69
  70 #endif
  71
  72
  73 #if defined(DEBUG_OBJECT_POSSIBLE) || !defined(THREAD_NONE)
  74
  75 void rwmutex_init_position(rwmutex_t *m argument_position)
  76 {
  77         if (unlikely(mutex_debug))
  78                 obj_registry_insert(OBJ_TYPE_RWMUTEX, ptr_to_num((void *)m), position_arg);
  79         do_rwmutex_init(m);
  80 }
  81
  82 void rwmutex_done_position(rwmutex_t *m argument_position)
  83 {
  84         if (unlikely(mutex_debug))
  85                 obj_registry_remove(OBJ_TYPE_RWMUTEX, ptr_to_num((void *)m), position_arg);
  86         do_rwmutex_done(m);
  87 }
  88
  89 void attr_fastcall rwmutex_lock_read_position(rwmutex_t *m argument_position)
  90 {
  91         if (unlikely(mutex_debug))
  92                 obj_registry_verify(OBJ_TYPE_RWMUTEX, ptr_to_num((void *)m), position_arg);
  93         do_rwmutex_lock_read(m);
  94 }
  95
  96 void attr_fastcall rwmutex_unlock_read_position(rwmutex_t *m argument_position)
  97 {
  98         if (unlikely(mutex_debug))
  99                 obj_registry_verify(OBJ_TYPE_RWMUTEX, ptr_to_num((void *)m), position_arg);
 100         do_rwmutex_unlock_read(m);
 101 }
 102
 103 void attr_fastcall rwmutex_lock_write_position(rwmutex_t *m argument_position)
 104 {
 105         if (unlikely(mutex_debug))
 106                 obj_registry_verify(OBJ_TYPE_RWMUTEX, ptr_to_num((void *)m), position_arg);
 107         do_rwmutex_lock_write(m);
 108 }
 109
 110 void attr_fastcall rwmutex_unlock_write_position(rwmutex_t *m argument_position)
 111 {
 112         if (unlikely(mutex_debug))
 113                 obj_registry_verify(OBJ_TYPE_RWMUTEX, ptr_to_num((void *)m), position_arg);
 114         do_rwmutex_unlock_write(m);
 115 }
 116
 117 #endif
 118
 119
 120 #if defined(DEBUG_OBJECT_POSSIBLE) || !defined(THREAD_NONE)
 121
 122 void cond_init_position(cond_t *c argument_position)
 123 {
 124         if (unlikely(mutex_debug))
 125                 obj_registry_insert(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 126         do_cond_init(c);
 127 }
 128
 129 void cond_done_position(cond_t *c argument_position)
 130 {
 131         if (unlikely(mutex_debug))
 132                 obj_registry_remove(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 133         do_cond_done(c);
 134 }
 135
 136 void attr_fastcall cond_lock_position(cond_t *c argument_position)
 137 {
 138         if (unlikely(mutex_debug))
 139                 obj_registry_verify(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 140         do_cond_lock(c);
 141 }
 142
 143 void attr_fastcall cond_unlock_position(cond_t *c argument_position)
 144 {
 145         if (unlikely(mutex_debug))
 146                 obj_registry_verify(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 147         do_cond_unlock(c);
 148 }
 149
 150 void attr_fastcall cond_unlock_signal_position(cond_t *c argument_position)
 151 {
 152         if (unlikely(mutex_debug))
 153                 obj_registry_verify(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 154         do_cond_unlock_signal(c);
 155 }
 156
 157 void attr_fastcall cond_unlock_broadcast_position(cond_t *c argument_position)
 158 {
 159         if (unlikely(mutex_debug))
 160                 obj_registry_verify(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 161         do_cond_unlock_broadcast(c);
 162 }
 163
 164 void attr_fastcall cond_wait_position(cond_t *c argument_position)
 165 {
 166         if (unlikely(mutex_debug))
 167                 obj_registry_verify(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 168         do_cond_wait(c);
 169 }
 170
 171 bool attr_fastcall cond_wait_us_position(cond_t *c, uint32_t us argument_position)
 172 {
 173         if (unlikely(mutex_debug))
 174                 obj_registry_verify(OBJ_TYPE_COND, ptr_to_num(c), position_arg);
 175         do_cond_wait_us(c, us);
 176         not_reached();
 177         return false;
 178 }
 179
 180 #endif
 181
 182
 183 #ifndef THREAD_NONE
 184 bool thread_spawn_position(thread_t *t, thread_function_t *function, void *arg, thread_priority_t attr_unused priority, ajla_error_t *err argument_position)
 185 {
 186         do_thread_spawn(t, function, arg, priority, err);
 187         if (unlikely(thread_debug) && sizeof(thread_t) <= sizeof(obj_id)) {
 188                 obj_id id = 0;
 189                 memcpy(&id, t, sizeof(thread_t));
 190                 obj_registry_insert(OBJ_TYPE_THREAD, id, position_arg);
 191         }
 192         return true;
 193 }
 194
 195 void thread_join_position(thread_t *t argument_position)
 196 {
 197         if (unlikely(thread_debug) && sizeof(thread_t) <= sizeof(obj_id)) {
 198                 obj_id id = 0;
 199                 memcpy(&id, t, sizeof(thread_t));
 200                 obj_registry_remove(OBJ_TYPE_THREAD, id, position_arg);
 201         }
 202         do_thread_join(t);
 203 }
 204 #endif
 205
 206
 207 #if defined(HAVE___THREAD)
 208 #define do_tls_init(m)          do { } while (0)
 209 #define do_tls_done(m)          do { } while (0)
 210 #endif
 211
 212 void tls_init__position(tls_t_ attr_unused *m argument_position)
 213 {
 214         if (unlikely(mutex_debug))
 215                 obj_registry_insert(OBJ_TYPE_TLS, ptr_to_num(m), position_arg);
 216         do_tls_init(m);
 217 }
 218
 219 void tls_done__position(tls_t_ attr_unused *m argument_position)
 220 {
 221         if (unlikely(mutex_debug))
 222                 obj_registry_remove(OBJ_TYPE_TLS, ptr_to_num(m), position_arg);
 223         do_tls_done(m);
 224 }
 225
 226 #if !defined(HAVE___THREAD)
 227
 228 uintptr_t attr_fastcall tls_get__position(const tls_t_ *m argument_position)
 229 {
 230         uintptr_t ret;
 231         if (unlikely(mutex_debug))
 232                 obj_registry_verify(OBJ_TYPE_TLS, ptr_to_num(m), position_arg);
 233         do_tls_get(m, &ret);
 234         return ret;
 235 }
 236
 237 void attr_fastcall tls_set__position(const tls_t_ *m, uintptr_t val argument_position)
 238 {
 239         if (unlikely(mutex_debug))
 240                 obj_registry_verify(OBJ_TYPE_TLS, ptr_to_num(m), position_arg);
 241         do_tls_set(m, val);
 242 }
 243
 244 uintptr_t attr_fastcall tls_get__nocheck(const tls_t_ *m)
 245 {
 246 #ifdef DEBUG_TRACK_FILE_LINE
 247         const char attr_unused *position_arg = "tls_get__nocheck";
 248 #endif
 249         uintptr_t ret;
 250         do_tls_get(m, &ret);
 251         return ret;
 252 }
 253
 254 void attr_fastcall tls_set__nocheck(const tls_t_ *m, uintptr_t val)
 255 {
 256 #ifdef DEBUG_TRACK_FILE_LINE
 257         const char attr_unused *position_arg = "tls_set__nocheck";
 258 #endif
 259         do_tls_set(m, val);
 260 }
 261
 262 #endif
 263
 264
 265 #ifndef THREAD_NONE
 266
 267 static tls_decl(tls_destructor_t *, tls_destructors);
 268
 269 void tls_destructor_position(tls_destructor_t *destr, tls_destructor_fn *fn argument_position)
 270 {
 271         destr->fn = fn;
 272         destr->previous = tls_get(tls_destructor_t *, tls_destructors);
 273         tls_set(tls_destructor_t *, tls_destructors, destr);
 274 }
 275
 276 void tls_destructor_call(void)
 277 {
 278         tls_destructor_t *destr;
 279         while ((destr = tls_get(tls_destructor_t *, tls_destructors))) {
 280                 tls_set(tls_destructor_t *, tls_destructors, destr->previous);
 281                 destr->fn(destr);
 282         }
 283 }
 284
 285 #ifdef DEBUG_TRACE
 286 static tls_decl(int, thread_id);
 287
 288 void thread_set_id(int id)
 289 {
 290         tls_set(int, thread_id, id);
 291 }
 292
 293 int thread_get_id(void)
 294 {
 295         return tls_get(int, thread_id);
 296 }
 297 #endif
 298
 299 static void thread_common_init(void)
 300 {
 301         tls_init(tls_destructor_t *, tls_destructors);
 302 #ifdef DEBUG_TRACE
 303         tls_init(int, thread_id);
 304 #endif
 305 }
 306
 307 static void thread_common_done(void)
 308 {
 309         tls_destructor_call();
 310         tls_done(tls_destructor_t *, tls_destructors);
 311 #ifdef DEBUG_TRACE
 312         tls_done(int, thread_id);
 313 #endif
 314 }
 315
 316 #endif
 317
 318
 319 bool thread_enable_debugging_option(const char *option, size_t l)
 320 {
 321 #ifndef DEBUG_OBJECT_POSSIBLE
 322         bool attr_unused mutex_debug = false;
 323         bool attr_unused thread_debug = false;
 324 #endif
 325         if (!option)
 326                 mutex_debug = thread_debug = true;
 327         else if (l == 5 && !strncmp(option, "mutex", 5))
 328                 mutex_debug = true;
 329         else if (l == 16 && !strncmp(option, "mutex-errorcheck", 16))
 330                 mutex_debug = true;
 331         else if (l == 6 && !strncmp(option, "thread", 6))
 332                 thread_debug = true;
 333         else
 334                 return false;
 335 #if defined(OS_OS2) || defined(OS_WIN32)
 336         mutex_debug = false;
 337 #endif
 338         return true;
 339 }