obj_reg.c

   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 #include "ajla.h"
  20
  21 #include "tree.h"
  22 #include "list.h"
  23 #include "str.h"
  24 #include "thread.h"
  25 #include "rwlock.h"
  26 #include "os.h"
  27
  28 #include "obj_reg.h"
  29
  30 #ifdef DEBUG_OBJECT_POSSIBLE
  31
  32 static int obj_registry_active = 0;
  33
  34 struct registry {
  35         struct tree head;
  36 };
  37
  38 struct object {
  39         struct tree_entry entry;
  40         obj_id id;
  41         position_t position;
  42 };
  43
  44 static struct registry registry[N_OBJ_TYPES];
  45
  46 static bool registry_threads_initialized;
  47
  48 static unsigned obj_registry_recursion_singlethreaded = 0;
  49 static tls_decl(unsigned, obj_registry_recursion);
  50
  51 rwlock_decl(obj_registry_rwlock);
  52
  53 bool obj_registry_start_recursion(void)
  54 {
  55         unsigned recursion;
  56         if (unlikely(!registry_threads_initialized)) {
  57                 return obj_registry_recursion_singlethreaded++ != 0;
  58         }
  59         recursion = tls_get_nocheck(unsigned, obj_registry_recursion);
  60         tls_set_nocheck(unsigned, obj_registry_recursion, recursion + 1);
  61         return recursion != 0;
  62 }
  63
  64 void obj_registry_end_recursion(void)
  65 {
  66         unsigned recursion;
  67         if (unlikely(!registry_threads_initialized)) {
  68                 if (unlikely(!obj_registry_recursion_singlethreaded))
  69                         internal(file_line, "obj_registry_end_recursion: obj_registry_recursion_singlethreaded underflow");
  70                 obj_registry_recursion_singlethreaded--;
  71                 return;
  72         }
  73         recursion = tls_get_nocheck(unsigned, obj_registry_recursion);
  74         if (unlikely(!recursion))
  75                 internal(file_line, "obj_registry_end_recursion: obj_registry_recursion underflow");
  76         tls_set_nocheck(unsigned, obj_registry_recursion, recursion - 1);
  77 }
  78
  79 /*
  80  * warning: memory allocation or freeing must not be done when holding
  81  * the object registry lock
  82  */
  83 static void obj_registry_lock_read(void)
  84 {
  85         if (unlikely(!registry_threads_initialized))
  86                 return;
  87         rwlock_lock_read(&obj_registry_rwlock);
  88 }
  89
  90 static void obj_registry_unlock_read(void)
  91 {
  92         if (unlikely(!registry_threads_initialized))
  93                 return;
  94         rwlock_unlock_read(&obj_registry_rwlock);
  95 }
  96
  97 static void obj_registry_lock_write(void)
  98 {
  99         if (unlikely(!registry_threads_initialized))
 100                 return;
 101         rwlock_lock_write(&obj_registry_rwlock);
 102 }
 103
 104 static void obj_registry_unlock_write(void)
 105 {
 106         if (unlikely(!registry_threads_initialized))
 107                 return;
 108         rwlock_unlock_write(&obj_registry_rwlock);
 109 }
 110
 111
 112 static char attr_cold *print_obj_id(obj_id id)
 113 {
 114 #if 1
 115         static char buffer[sizeof(obj_id) * 2 + 1];
 116         char *b = buffer;
 117         str_add_unsigned(&b, NULL, (uintbig_t)id, 16);
 118         return buffer;
 119 #else
 120         /* this causes memory allocation and may trigger infinite recursion on some errors */
 121         return str_from_unsigned(id, 16);
 122 #endif
 123 }
 124
 125 static struct registry *obj_registry_get(obj_id type, position_t position)
 126 {
 127         if (unlikely(type >= N_OBJ_TYPES))
 128                 internal(position_string(position), "obj_registry_get: invalid type %u", (unsigned)type);
 129         return &registry[type];
 130 }
 131
 132
 133 static int object_test(const struct tree_entry *e, uintptr_t id)
 134 {
 135         const struct object *o = get_struct(e, struct object, entry);
 136         if (o->id == id) return 0;
 137         if (o->id > id) return 1;
 138         return -1;
 139 }
 140
 141 static struct object *obj_registry_find(struct registry *r, obj_id id)
 142 {
 143         struct tree_entry *e;
 144
 145         e = tree_find(&r->head, object_test, id);
 146         if (likely(e != NULL))
 147                 return get_struct(e, struct object, entry);
 148         else
 149                 return NULL;
 150 }
 151
 152 void obj_registry_insert(obj_type type, obj_id id, position_t position)
 153 {
 154         struct registry *r;
 155         struct tree_entry *e;
 156         struct tree_insert_position ins;
 157         struct object *o;
 158
 159         if (likely(!((obj_registry_active >> (int)type) & 1)))
 160                 return;
 161
 162         o = malloc(sizeof(struct object));
 163         if (unlikely(!o))
 164                 fatal("unable to allocate struct object");
 165         o->id = id;
 166         o->position = position;
 167
 168         obj_registry_start_recursion();
 169         obj_registry_lock_write();
 170
 171         r = obj_registry_get(type, position);
 172         e = tree_find_for_insert(&r->head, object_test, o->id, &ins);
 173         if (unlikely(e != NULL)) {
 174                 struct object *of = get_struct(e, struct object, entry);
 175                 obj_registry_unlock_write();
 176                 internal(position_string(position), "object already present, type %u, id %s, allocated at %s", (unsigned)type, print_obj_id(id), position_string(of->position));
 177         }
 178         tree_insert_after_find(&o->entry, &ins);
 179
 180         obj_registry_unlock_write();
 181         obj_registry_end_recursion();
 182 }
 183
 184 void obj_registry_remove(obj_type type, obj_id id, position_t position)
 185 {
 186         struct registry *r;
 187         struct object *o;
 188
 189         if (likely(!((obj_registry_active >> (int)type) & 1)))
 190                 return;
 191
 192         obj_registry_start_recursion();
 193         obj_registry_lock_write();
 194
 195         r = obj_registry_get(type, position);
 196         if (unlikely(!(o = obj_registry_find(r, id)))) {
 197                 obj_registry_unlock_write();
 198                 internal(position_string(position), "object not found, type %u, id %s", (unsigned)type, print_obj_id(id));
 199         }
 200         tree_delete(&o->entry);
 201
 202         obj_registry_unlock_write();
 203         obj_registry_end_recursion();
 204
 205         free(o);
 206 }
 207
 208 void obj_registry_verify(obj_type type, obj_id id, position_t position)
 209 {
 210         struct registry *r;
 211
 212         if (likely(!((obj_registry_active >> (int)type) & 1)))
 213                 return;
 214
 215         if (obj_registry_start_recursion()) {
 216                 obj_registry_end_recursion();
 217                 return;
 218         }
 219         obj_registry_lock_read();
 220
 221         r = obj_registry_get(type, position);
 222         if (unlikely(!obj_registry_find(r, id))) {
 223                 obj_registry_unlock_read();
 224                 internal(position_string(position), "object not found, type %u, id %s", (unsigned)type, print_obj_id(id));
 225         }
 226
 227         obj_registry_unlock_read();
 228         obj_registry_end_recursion();
 229 }
 230
 231 static attr_noreturn attr_cold obj_registry_dump_leaks(void)
 232 {
 233         obj_id t;
 234         char *s;
 235         size_t sl;
 236         bool first = true;
 237         const char *first_pos = "";
 238
 239         str_init(&s, &sl);
 240         str_add_string(&s, &sl, "object leak, list of objects: ");
 241
 242         for (t = 0; t < N_OBJ_TYPES; t++) {
 243                 struct tree_entry *lv;
 244                 for (lv = tree_first(&registry[t].head); lv; lv = tree_next(lv)) {
 245                         struct object *o = get_struct(lv, struct object, entry);
 246                         const char *pos_str = position_string(o->position);
 247
 248                         if (first) first_pos = pos_str;
 249                         else str_add_string(&s, &sl, ", ");
 250                         first = false;
 251
 252                         str_add_unsigned(&s, &sl, t, 10);
 253                         str_add_string(&s, &sl, ":");
 254                         str_add_string(&s, &sl, print_obj_id(o->id));
 255                         str_add_string(&s, &sl, " @ ");
 256                         str_add_string(&s, &sl, pos_str);
 257                 }
 258         }
 259
 260         str_finish(&s, &sl);
 261
 262         internal(first_pos, "%s", s);
 263 }
 264
 265 void obj_registry_init(void)
 266 {
 267         obj_id t;
 268         registry_threads_initialized = false;
 269         for (t = 0; t < N_OBJ_TYPES; t++)
 270                 tree_init(&registry[t].head);
 271 }
 272
 273 void obj_registry_init_multithreaded(void)
 274 {
 275         if (unlikely(registry_threads_initialized))
 276                 internal(file_line, "obj_registry_init_multithreaded: registry_threads_initialized already set");
 277         tls_init(unsigned, obj_registry_recursion);
 278         rwlock_init(&obj_registry_rwlock);
 279         registry_threads_initialized = true;
 280 }
 281
 282 void obj_registry_done_multithreaded(void)
 283 {
 284         if (unlikely(!registry_threads_initialized))
 285                 internal(file_line, "obj_registry_done_multithreaded: registry_threads_initialized not set");
 286         registry_threads_initialized = false;
 287         rwlock_done(&obj_registry_rwlock);
 288         tls_done(unsigned, obj_registry_recursion);
 289 }
 290
 291 void obj_registry_done(void)
 292 {
 293         obj_id t;
 294         if (unlikely(registry_threads_initialized))
 295                 internal(file_line, "obj_registry_done: registry_threads_initialized set");
 296         for (t = 0; t < N_OBJ_TYPES; t++) {
 297                 if (!tree_is_empty(&registry[t].head))
 298                         obj_registry_dump_leaks();
 299         }
 300 }
 301
 302 #endif
 303
 304 bool obj_registry_enable_debugging_option(const char *option, size_t l)
 305 {
 306 #ifndef DEBUG_OBJECT_POSSIBLE
 307         int obj_registry_active = 0;
 308 #endif
 309         if (!option)
 310                 obj_registry_active = -1;
 311         else if (l == 5 && !strncmp(option, "mutex", l))
 312                 obj_registry_active |= 1 << OBJ_TYPE_MUTEX;
 313         else if (l == 4 && !strncmp(option, "cond", l))
 314                 obj_registry_active |= 1 << OBJ_TYPE_COND;
 315         else if (l == 6 && !strncmp(option, "thread", l))
 316                 obj_registry_active |= 1 << OBJ_TYPE_THREAD;
 317         else if (l == 3 && !strncmp(option, "tls", l))
 318                 obj_registry_active |= 1 << OBJ_TYPE_TLS;
 319         else if (l == 7 && !strncmp(option, "handles", l))
 320                 obj_registry_active |= 1 << OBJ_TYPE_HANDLE;
 321         else if (l == 7 && !strncmp(option, "objects", l))
 322                 obj_registry_active = -1;
 323         else
 324                 return false;
 325         return true;
 326 }