thread_safety 0.1.1 → 0.1.3

data/ext/gc-4.0/gc/gc.h

@@ -0,0 +1,262 @@
+#ifndef GC_GC_H
+#define GC_GC_H
+/**
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Private header for the default GC and other GC implementations
+ *             first introduced for [Feature #20470].
+ */
+#include "ruby/ruby.h"
+
+#if USE_MODULAR_GC
+#include "ruby/thread_native.h"
+
+struct rb_gc_vm_context {
+    rb_nativethread_lock_t lock;
+
+    struct rb_execution_context_struct *ec;
+};
+#endif
+
+typedef int (*vm_table_foreach_callback_func)(VALUE value, void *data);
+typedef int (*vm_table_update_callback_func)(VALUE *value, void *data);
+
+enum rb_gc_vm_weak_tables {
+    RB_GC_VM_CI_TABLE,
+    RB_GC_VM_OVERLOADED_CME_TABLE,
+    RB_GC_VM_GLOBAL_SYMBOLS_TABLE,
+    RB_GC_VM_ID2REF_TABLE,
+    RB_GC_VM_GENERIC_FIELDS_TABLE,
+    RB_GC_VM_FROZEN_STRINGS_TABLE,
+    RB_GC_VM_CC_REFINEMENT_TABLE,
+    RB_GC_VM_WEAK_TABLE_COUNT
+};
+
+#define RB_GC_VM_LOCK() rb_gc_vm_lock(__FILE__, __LINE__)
+#define RB_GC_VM_UNLOCK(lev) rb_gc_vm_unlock(lev, __FILE__, __LINE__)
+#define RB_GC_CR_LOCK() rb_gc_cr_lock(__FILE__, __LINE__)
+#define RB_GC_CR_UNLOCK(lev) rb_gc_cr_unlock(lev, __FILE__, __LINE__)
+#define RB_GC_VM_LOCK_NO_BARRIER() rb_gc_vm_lock_no_barrier(__FILE__, __LINE__)
+#define RB_GC_VM_UNLOCK_NO_BARRIER(lev) rb_gc_vm_unlock_no_barrier(lev, __FILE__, __LINE__)
+
+#if USE_MODULAR_GC
+# define MODULAR_GC_FN
+#else
+// This takes advantage of internal linkage winning when appearing first.
+// See C99 6.2.2p4.
+# define MODULAR_GC_FN static
+#endif
+
+#if USE_MODULAR_GC
+RUBY_SYMBOL_EXPORT_BEGIN
+#endif
+
+// These functions cannot be defined as static because they are used by other
+// files in Ruby.
+size_t rb_size_mul_or_raise(size_t x, size_t y, VALUE exc);
+void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
+const char *rb_raw_obj_info(char *const buff, const size_t buff_size, VALUE obj);
+const char *rb_obj_info(VALUE obj);
+size_t rb_obj_memsize_of(VALUE obj);
+bool ruby_free_at_exit_p(void);
+void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *passing_data);
+void rb_gc_verify_shareable(VALUE);
+
+MODULAR_GC_FN unsigned int rb_gc_vm_lock(const char *file, int line);
+MODULAR_GC_FN void rb_gc_vm_unlock(unsigned int lev, const char *file, int line);
+MODULAR_GC_FN unsigned int rb_gc_cr_lock(const char *file, int line);
+MODULAR_GC_FN void rb_gc_cr_unlock(unsigned int lev, const char *file, int line);
+MODULAR_GC_FN unsigned int rb_gc_vm_lock_no_barrier(const char *file, int line);
+MODULAR_GC_FN void rb_gc_vm_unlock_no_barrier(unsigned int lev, const char *file, int line);
+MODULAR_GC_FN void rb_gc_vm_barrier(void);
+MODULAR_GC_FN size_t rb_gc_obj_optimal_size(VALUE obj);
+MODULAR_GC_FN void rb_gc_mark_children(void *objspace, VALUE obj);
+MODULAR_GC_FN void rb_gc_vm_weak_table_foreach(vm_table_foreach_callback_func callback, vm_table_update_callback_func update_callback, void *data, bool weak_only, enum rb_gc_vm_weak_tables table);
+MODULAR_GC_FN void rb_gc_update_object_references(void *objspace, VALUE obj);
+MODULAR_GC_FN void rb_gc_update_vm_references(void *objspace);
+MODULAR_GC_FN void rb_gc_event_hook(VALUE obj, rb_event_flag_t event);
+MODULAR_GC_FN void *rb_gc_get_objspace(void);
+MODULAR_GC_FN void rb_gc_run_obj_finalizer(VALUE objid, long count, VALUE (*callback)(long i, void *data), void *data);
+MODULAR_GC_FN void rb_gc_set_pending_interrupt(void);
+MODULAR_GC_FN void rb_gc_unset_pending_interrupt(void);
+MODULAR_GC_FN void rb_gc_obj_free_vm_weak_references(VALUE obj);
+MODULAR_GC_FN bool rb_gc_obj_free(void *objspace, VALUE obj);
+MODULAR_GC_FN void rb_gc_save_machine_context(void);
+MODULAR_GC_FN void rb_gc_mark_roots(void *objspace, const char **categoryp);
+MODULAR_GC_FN void rb_gc_ractor_newobj_cache_foreach(void (*func)(void *cache, void *data), void *data);
+MODULAR_GC_FN bool rb_gc_multi_ractor_p(void);
+MODULAR_GC_FN bool rb_gc_shutdown_call_finalizer_p(VALUE obj);
+MODULAR_GC_FN uint32_t rb_gc_get_shape(VALUE obj);
+MODULAR_GC_FN void rb_gc_set_shape(VALUE obj, uint32_t shape_id);
+MODULAR_GC_FN uint32_t rb_gc_rebuild_shape(VALUE obj, size_t heap_id);
+MODULAR_GC_FN void rb_gc_prepare_heap_process_object(VALUE obj);
+MODULAR_GC_FN bool rb_memerror_reentered(void);
+MODULAR_GC_FN bool rb_obj_id_p(VALUE);
+MODULAR_GC_FN void rb_gc_before_updating_jit_code(void);
+MODULAR_GC_FN void rb_gc_after_updating_jit_code(void);
+MODULAR_GC_FN bool rb_gc_obj_shareable_p(VALUE);
+MODULAR_GC_FN void rb_gc_rp(VALUE);
+
+#if USE_MODULAR_GC
+MODULAR_GC_FN bool rb_gc_event_hook_required_p(rb_event_flag_t event);
+MODULAR_GC_FN void *rb_gc_get_ractor_newobj_cache(void);
+MODULAR_GC_FN void rb_gc_initialize_vm_context(struct rb_gc_vm_context *context);
+MODULAR_GC_FN void rb_gc_worker_thread_set_vm_context(struct rb_gc_vm_context *context);
+MODULAR_GC_FN void rb_gc_worker_thread_unset_vm_context(struct rb_gc_vm_context *context);
+#endif
+
+#if USE_MODULAR_GC
+RUBY_SYMBOL_EXPORT_END
+#endif
+
+void rb_ractor_finish_marking(void);
+
+// -------------------Private section begin------------------------
+// Functions in this section are private to the default GC and gc.c
+
+#ifdef BUILDING_MODULAR_GC
+RBIMPL_WARNING_PUSH()
+RBIMPL_WARNING_IGNORED(-Wunused-function)
+#endif
+
+/* RGENGC_CHECK_MODE
+ * 0: disable all assertions
+ * 1: enable assertions (to debug RGenGC)
+ * 2: enable internal consistency check at each GC (for debugging)
+ * 3: enable internal consistency check at each GC steps (for debugging)
+ * 4: enable liveness check
+ * 5: show all references
+ */
+#ifndef RGENGC_CHECK_MODE
+# define RGENGC_CHECK_MODE  0
+#endif
+
+#ifndef GC_ASSERT
+# define GC_ASSERT(expr, ...) RUBY_ASSERT_MESG_WHEN(RGENGC_CHECK_MODE > 0, expr, #expr RBIMPL_VA_OPT_ARGS(__VA_ARGS__))
+#endif
+
+static int
+hash_foreach_replace_value(st_data_t key, st_data_t value, st_data_t argp, int error)
+{
+    if (rb_gc_location((VALUE)value) != (VALUE)value) {
+        return ST_REPLACE;
+    }
+    return ST_CONTINUE;
+}
+
+static int
+hash_replace_ref_value(st_data_t *key, st_data_t *value, st_data_t argp, int existing)
+{
+    *value = rb_gc_location((VALUE)*value);
+
+    return ST_CONTINUE;
+}
+
+static void
+gc_ref_update_table_values_only(st_table *tbl)
+{
+    if (!tbl || tbl->num_entries == 0) return;
+
+    if (st_foreach_with_replace(tbl, hash_foreach_replace_value, hash_replace_ref_value, 0)) {
+        rb_raise(rb_eRuntimeError, "hash modified during iteration");
+    }
+}
+
+static int
+gc_mark_tbl_no_pin_i(st_data_t key, st_data_t value, st_data_t data)
+{
+    rb_gc_mark_movable((VALUE)value);
+
+    return ST_CONTINUE;
+}
+
+static int
+hash_foreach_replace(st_data_t key, st_data_t value, st_data_t argp, int error)
+{
+    if (rb_gc_location((VALUE)key) != (VALUE)key) {
+        return ST_REPLACE;
+    }
+
+    if (rb_gc_location((VALUE)value) != (VALUE)value) {
+        return ST_REPLACE;
+    }
+
+    return ST_CONTINUE;
+}
+
+static int
+hash_replace_ref(st_data_t *key, st_data_t *value, st_data_t argp, int existing)
+{
+    if (rb_gc_location((VALUE)*key) != (VALUE)*key) {
+        *key = rb_gc_location((VALUE)*key);
+    }
+
+    if (rb_gc_location((VALUE)*value) != (VALUE)*value) {
+        *value = rb_gc_location((VALUE)*value);
+    }
+
+    return ST_CONTINUE;
+}
+
+static void
+gc_update_table_refs(st_table *tbl)
+{
+    if (!tbl || tbl->num_entries == 0) return;
+
+    if (st_foreach_with_replace(tbl, hash_foreach_replace, hash_replace_ref, 0)) {
+        rb_raise(rb_eRuntimeError, "hash modified during iteration");
+    }
+}
+
+static inline size_t
+xmalloc2_size(const size_t count, const size_t elsize)
+{
+    return rb_size_mul_or_raise(count, elsize, rb_eArgError);
+}
+
+static VALUE
+type_sym(size_t type)
+{
+    switch (type) {
+#define COUNT_TYPE(t) case (t): return ID2SYM(rb_intern(#t)); break;
+        COUNT_TYPE(T_NONE);
+        COUNT_TYPE(T_OBJECT);
+        COUNT_TYPE(T_CLASS);
+        COUNT_TYPE(T_MODULE);
+        COUNT_TYPE(T_FLOAT);
+        COUNT_TYPE(T_STRING);
+        COUNT_TYPE(T_REGEXP);
+        COUNT_TYPE(T_ARRAY);
+        COUNT_TYPE(T_HASH);
+        COUNT_TYPE(T_STRUCT);
+        COUNT_TYPE(T_BIGNUM);
+        COUNT_TYPE(T_FILE);
+        COUNT_TYPE(T_DATA);
+        COUNT_TYPE(T_MATCH);
+        COUNT_TYPE(T_COMPLEX);
+        COUNT_TYPE(T_RATIONAL);
+        COUNT_TYPE(T_NIL);
+        COUNT_TYPE(T_TRUE);
+        COUNT_TYPE(T_FALSE);
+        COUNT_TYPE(T_SYMBOL);
+        COUNT_TYPE(T_FIXNUM);
+        COUNT_TYPE(T_IMEMO);
+        COUNT_TYPE(T_UNDEF);
+        COUNT_TYPE(T_NODE);
+        COUNT_TYPE(T_ICLASS);
+        COUNT_TYPE(T_ZOMBIE);
+        COUNT_TYPE(T_MOVED);
+#undef COUNT_TYPE
+        default:              return SIZET2NUM(type); break;
+    }
+}
+
+#ifdef BUILDING_MODULAR_GC
+RBIMPL_WARNING_POP()
+#endif
+// -------------------Private section end------------------------
+
+#endif

data/ext/gc-4.0/gc/gc_impl.h

@@ -0,0 +1,124 @@
+#ifndef GC_GC_IMPL_H
+#define GC_GC_IMPL_H
+/**
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Header for GC implementations introduced in [Feature #20470].
+ */
+#include "ruby/ruby.h"
+
+#ifndef RB_GC_OBJECT_METADATA_ENTRY_DEFINED
+# define RB_GC_OBJECT_METADATA_ENTRY_DEFINED
+struct rb_gc_object_metadata_entry {
+    ID name;
+    VALUE val;
+};
+#endif
+
+#ifdef BUILDING_MODULAR_GC
+# define GC_IMPL_FN
+#else
+// `GC_IMPL_FN` is an implementation detail of `!USE_MODULAR_GC` builds
+// to have the default GC in the same translation unit as gc.c for
+// the sake of optimizer visibility. It expands to nothing unless
+// you're the default GC.
+//
+// For the default GC, do not copy-paste this when implementing
+// these functions. This takes advantage of internal linkage winning
+// when appearing first. See C99 6.2.2p4.
+# define GC_IMPL_FN static
+#endif
+
+// Bootup
+GC_IMPL_FN void *rb_gc_impl_objspace_alloc(void);
+GC_IMPL_FN void rb_gc_impl_objspace_init(void *objspace_ptr);
+GC_IMPL_FN void *rb_gc_impl_ractor_cache_alloc(void *objspace_ptr, void *ractor);
+GC_IMPL_FN void rb_gc_impl_set_params(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_init(void);
+GC_IMPL_FN size_t *rb_gc_impl_heap_sizes(void *objspace_ptr);
+// Shutdown
+GC_IMPL_FN void rb_gc_impl_shutdown_free_objects(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_objspace_free(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_ractor_cache_free(void *objspace_ptr, void *cache);
+// GC
+GC_IMPL_FN void rb_gc_impl_start(void *objspace_ptr, bool full_mark, bool immediate_mark, bool immediate_sweep, bool compact);
+GC_IMPL_FN bool rb_gc_impl_during_gc_p(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_prepare_heap(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_gc_enable(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_gc_disable(void *objspace_ptr, bool finish_current_gc);
+GC_IMPL_FN bool rb_gc_impl_gc_enabled_p(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_stress_set(void *objspace_ptr, VALUE flag);
+GC_IMPL_FN VALUE rb_gc_impl_stress_get(void *objspace_ptr);
+GC_IMPL_FN VALUE rb_gc_impl_config_get(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_config_set(void *objspace_ptr, VALUE hash);
+// Object allocation
+GC_IMPL_FN VALUE rb_gc_impl_new_obj(void *objspace_ptr, void *cache_ptr, VALUE klass, VALUE flags, bool wb_protected, size_t alloc_size);
+GC_IMPL_FN size_t rb_gc_impl_obj_slot_size(VALUE obj);
+GC_IMPL_FN size_t rb_gc_impl_heap_id_for_size(void *objspace_ptr, size_t size);
+GC_IMPL_FN bool rb_gc_impl_size_allocatable_p(size_t size);
+// Malloc
+/*
+ * BEWARE: These functions may or may not run under GVL.
+ *
+ * You might want to make them thread-safe.
+ * Garbage collecting inside is possible if and only if you
+ * already have GVL.  Also raising exceptions without one is a
+ * total disaster.
+ *
+ * When you absolutely cannot allocate the requested amount of
+ * memory just return NULL (with appropriate errno set).
+ * The caller side takes care of that situation.
+ */
+GC_IMPL_FN void *rb_gc_impl_malloc(void *objspace_ptr, size_t size, bool gc_allowed);
+GC_IMPL_FN void *rb_gc_impl_calloc(void *objspace_ptr, size_t size, bool gc_allowed);
+GC_IMPL_FN void *rb_gc_impl_realloc(void *objspace_ptr, void *ptr, size_t new_size, size_t old_size, bool gc_allowed);
+GC_IMPL_FN void rb_gc_impl_free(void *objspace_ptr, void *ptr, size_t old_size);
+GC_IMPL_FN void rb_gc_impl_adjust_memory_usage(void *objspace_ptr, ssize_t diff);
+// Marking
+GC_IMPL_FN void rb_gc_impl_mark(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_mark_and_move(void *objspace_ptr, VALUE *ptr);
+GC_IMPL_FN void rb_gc_impl_mark_and_pin(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_mark_maybe(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_mark_weak(void *objspace_ptr, VALUE *ptr);
+GC_IMPL_FN void rb_gc_impl_remove_weak(void *objspace_ptr, VALUE parent_obj, VALUE *ptr);
+// Compaction
+GC_IMPL_FN bool rb_gc_impl_object_moved_p(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN VALUE rb_gc_impl_location(void *objspace_ptr, VALUE value);
+// Write barriers
+GC_IMPL_FN void rb_gc_impl_writebarrier(void *objspace_ptr, VALUE a, VALUE b);
+GC_IMPL_FN void rb_gc_impl_writebarrier_unprotect(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_writebarrier_remember(void *objspace_ptr, VALUE obj);
+// Heap walking
+GC_IMPL_FN void rb_gc_impl_each_objects(void *objspace_ptr, int (*callback)(void *, void *, size_t, void *), void *data);
+GC_IMPL_FN void rb_gc_impl_each_object(void *objspace_ptr, void (*func)(VALUE obj, void *data), void *data);
+// Finalizers
+GC_IMPL_FN void rb_gc_impl_make_zombie(void *objspace_ptr, VALUE obj, void (*dfree)(void *), void *data);
+GC_IMPL_FN VALUE rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block);
+GC_IMPL_FN void rb_gc_impl_undefine_finalizer(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_copy_finalizer(void *objspace_ptr, VALUE dest, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_shutdown_call_finalizer(void *objspace_ptr);
+// Forking
+GC_IMPL_FN void rb_gc_impl_before_fork(void *objspace_ptr);
+GC_IMPL_FN void rb_gc_impl_after_fork(void *objspace_ptr, rb_pid_t pid);
+// Statistics
+GC_IMPL_FN void rb_gc_impl_set_measure_total_time(void *objspace_ptr, VALUE flag);
+GC_IMPL_FN bool rb_gc_impl_get_measure_total_time(void *objspace_ptr);
+GC_IMPL_FN unsigned long long rb_gc_impl_get_total_time(void *objspace_ptr);
+GC_IMPL_FN size_t rb_gc_impl_gc_count(void *objspace_ptr);
+GC_IMPL_FN VALUE rb_gc_impl_latest_gc_info(void *objspace_ptr, VALUE key);
+GC_IMPL_FN VALUE rb_gc_impl_stat(void *objspace_ptr, VALUE hash_or_sym);
+GC_IMPL_FN VALUE rb_gc_impl_stat_heap(void *objspace_ptr, VALUE heap_name, VALUE hash_or_sym);
+GC_IMPL_FN const char *rb_gc_impl_active_gc_name(void);
+// Miscellaneous
+GC_IMPL_FN struct rb_gc_object_metadata_entry *rb_gc_impl_object_metadata(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN bool rb_gc_impl_pointer_to_heap_p(void *objspace_ptr, const void *ptr);
+GC_IMPL_FN bool rb_gc_impl_garbage_object_p(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN void rb_gc_impl_set_event_hook(void *objspace_ptr, const rb_event_flag_t event);
+GC_IMPL_FN void rb_gc_impl_copy_attributes(void *objspace_ptr, VALUE dest, VALUE obj);
+
+#undef GC_IMPL_FN
+
+#endif

data/ext/thread_safety.c

@@ -1,43 +1,94 @@
 #include "ruby/ruby.h"
+#include "ruby/version.h"
 #include "ruby/debug.h"
 #include "gc/gc.h"
 #include "gc/gc_impl.h"
 
-#define RVALUE_OVERHEAD (sizeof(VALUE))
+// RVALUE_OVERHEAD must account for both ractor checking (when enabled) and our
+// fiber/thread tracking. The ractor system uses index 0 (as uint32_t, but aligned
+// to sizeof(VALUE)), so we use indices 1 and 2 for our data.
+#define RVALUE_OVERHEAD (sizeof(VALUE) * 3)
 
-static VALUE main_thread_id = INT2FIX(-1);
+#define OVERHEAD_FIBER_INDEX 1
+#define OVERHEAD_THREAD_INDEX 2
+
+static VALUE root_fiber = Qnil;
+static VALUE rb_cFiber;
+static bool ruby_vm_booted = false, thread_safety_globally_enabled = false;
 static VALUE mThreadSafety;
-static ID id_report_offense, id_thread_safety_disabled;
+static ID id_report_offense, id_thread_safety_enabled;
 
 size_t rb_gc_impl_obj_slot_size(VALUE obj);
 
 static VALUE
-get_owner_thread_id(VALUE obj)
+get_owner_fiber(VALUE obj)
 {
-    return *(VALUE *)(obj + rb_gc_impl_obj_slot_size(obj));
+    VALUE fiber = ((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj)))[OVERHEAD_FIBER_INDEX];
+    return fiber == Qnil ? root_fiber : fiber;
 }
 
 static VALUE
-get_current_thread_id(void)
+get_owner_thread(VALUE obj)
 {
-    VALUE thread = rb_thread_current();
+    return ((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj)))[OVERHEAD_THREAD_INDEX];
+}
 
-    if (thread == 0 || thread == rb_thread_main()) {
-        return main_thread_id;
+static VALUE
+get_current_fiber(void)
+{
+    if (!ruby_vm_booted) {
+        return Qnil;
     }
 
-    return rb_obj_id(thread);
+    return rb_fiber_current();
+}
+
+static VALUE
+get_current_thread(void)
+{
+    VALUE thread = rb_thread_current();
+    return thread == 0 ? Qnil : thread;
 }
 
+static void
+rb_gc_mark_children_patched(void *objspace, VALUE obj)
+{
+    rb_gc_mark(get_owner_fiber(obj));
+    rb_gc_mark(get_owner_thread(obj));
+
+    rb_gc_mark_children(objspace, obj);
+}
+#define rb_gc_mark_children rb_gc_mark_children_patched
+
 #define PATCH_GC_FUNC(ret_type, name, ...) \
     ret_type rb_gc_impl_##name##_original(__VA_ARGS__); \
     ret_type rb_gc_impl_##name(__VA_ARGS__)
 
+// Ruby 4.0 changed the modular GC interface - removed v1, v2, v3 from new_obj
+#if RUBY_API_VERSION_MAJOR >= 4
+PATCH_GC_FUNC(VALUE, new_obj, void *objspace_ptr, void *cache_ptr, VALUE klass, VALUE flags, bool wb_protected, size_t alloc_size)
+{
+    VALUE obj = rb_gc_impl_new_obj_original(objspace_ptr, cache_ptr, klass, flags, wb_protected, alloc_size);
+#else
 PATCH_GC_FUNC(VALUE, new_obj, void *objspace_ptr, void *cache_ptr, VALUE klass, VALUE flags, VALUE v1, VALUE v2, VALUE v3, bool wb_protected, size_t alloc_size)
 {
     VALUE obj = rb_gc_impl_new_obj_original(objspace_ptr, cache_ptr, klass, flags, v1, v2, v3, wb_protected, alloc_size);
-
-    *((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj))) = get_current_thread_id();
+#endif
+
+    if (// Skip imemo types like call caches.
+            (flags & RUBY_T_MASK) != T_IMEMO &&
+            // klass of 0 means that it is a hidden object.
+            klass != 0 &&
+            // First time calling rb_fiber_current will allocate a Fiber object,
+            // which would cause an infinite loop here because it calls rb_fiber_current.
+            klass != rb_cFiber) {
+        ((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj)))[OVERHEAD_FIBER_INDEX] = get_current_fiber();
+        ((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj)))[OVERHEAD_THREAD_INDEX] = get_current_thread();
+    }
+    else {
+        ((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj)))[OVERHEAD_FIBER_INDEX] = Qfalse;
+        ((VALUE *)(obj + rb_gc_impl_obj_slot_size(obj)))[OVERHEAD_THREAD_INDEX] = Qfalse;
+    }
 
     return obj;
 }
@@ -45,43 +96,91 @@ PATCH_GC_FUNC(VALUE, new_obj, void *objspace_ptr, void *cache_ptr, VALUE klass,
 
 PATCH_GC_FUNC(void, writebarrier, void *objspace_ptr, VALUE a, VALUE b)
 {
-    VALUE owner_thread_id = get_owner_thread_id(a);
-    VALUE current_thread_id = get_current_thread_id();
-    VALUE current_thread = rb_thread_current();
-    if (owner_thread_id != current_thread_id &&
-            // Skip imemo types like call caches.
-            RB_BUILTIN_TYPE(a) != T_IMEMO &&
+    if (!ruby_vm_booted) goto skip;
+
+    VALUE current_fiber = rb_fiber_current();
+    int type_a = RB_BUILTIN_TYPE(a);
+    if (// Skip imemo types like call caches.
+            type_a != T_IMEMO &&
+            // Skip Class and Module objects (internal Ruby operations).
+            type_a != T_CLASS &&
+            type_a != T_MODULE &&
+            type_a != T_ICLASS &&
             // Skip imemo types like call caches.
-            (RB_IMMEDIATE_P(b) || RB_BUILTIN_TYPE(b) != T_IMEMO) &&
+            (RB_SPECIAL_CONST_P(b) || RB_BUILTIN_TYPE(b) != T_IMEMO) &&
             // Class of 0 means that it is a hidden object.
             CLASS_OF(a) != 0 &&
             // When we create a new thread, the owner is the parent thread but
             // may be written to during execution.
-            CLASS_OF(a) != rb_cThread &&
-            !RTEST(rb_thread_local_aref(current_thread, id_thread_safety_disabled))) {
-        bool prev_gc_enabled = !rb_gc_impl_gc_enabled_p(objspace_ptr);
-        if (prev_gc_enabled) rb_gc_impl_gc_disable(objspace_ptr, false);
+            CLASS_OF(a) != rb_cThread) {
+        VALUE current_thread = rb_thread_current();
 
-        rb_thread_local_aset(current_thread, id_thread_safety_disabled, Qtrue);
+        VALUE fiber_enabled = rb_ivar_get(current_fiber, id_thread_safety_enabled);
+        VALUE thread_enabled = rb_ivar_get(current_thread, id_thread_safety_enabled);
 
-        rb_funcall(mThreadSafety, id_report_offense, 3, a, owner_thread_id, rb_thread_current());
+        // Skip if thread_safety is not explicitly enabled on this Fiber or Thread and not enabled globally.
+        if (fiber_enabled == Qnil && thread_enabled == Qnil && !thread_safety_globally_enabled) goto skip;
+        // Skip if thread_safety is explicitly turned off on this Fiber or Thread.
+        if (fiber_enabled == Qfalse || thread_enabled == Qfalse) goto skip;
 
-        rb_thread_local_aset(current_thread, id_thread_safety_disabled, Qfalse);
+        VALUE owner_fiber = get_owner_fiber(a);
+        VALUE owner_thread = get_owner_thread(a);
 
-        if (prev_gc_enabled) rb_gc_impl_gc_enable(objspace_ptr);
+        if (owner_fiber != current_fiber) {
+            bool prev_gc_enabled = !rb_gc_impl_gc_enabled_p(objspace_ptr);
+            if (prev_gc_enabled) rb_gc_impl_gc_disable(objspace_ptr, false);
+
+            rb_ivar_set(current_fiber, id_thread_safety_enabled, Qfalse);
+
+            rb_funcall(mThreadSafety, id_report_offense, 3, a, owner_fiber, owner_thread);
+
+            rb_ivar_set(current_fiber, id_thread_safety_enabled, fiber_enabled);
+
+            if (prev_gc_enabled) rb_gc_impl_gc_enable(objspace_ptr);
+        }
     }
 
+  skip:
     rb_gc_impl_writebarrier_original(objspace_ptr, a, b);
 }
 #define rb_gc_impl_writebarrier rb_gc_impl_writebarrier_original
 
+PATCH_GC_FUNC(const char *, active_gc_name, void)
+{
+    return "thread_safety";
+}
+#define rb_gc_impl_active_gc_name rb_gc_impl_active_gc_name_original
+
+static VALUE
+thread_safety_vm_booted_bang(VALUE self)
+{
+    root_fiber = rb_fiber_current();
+    rb_cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
+    ruby_vm_booted = true;
+
+    return Qnil;
+}
+
+static VALUE
+thread_safety_enabled_set(VALUE self, VALUE val)
+{
+    thread_safety_globally_enabled = RTEST(val);
+
+    return Qnil;
+}
+
 PATCH_GC_FUNC(void, init, void)
 {
     rb_gc_register_address(&mThreadSafety);
     mThreadSafety = rb_define_module("ThreadSafety");
+    rb_define_private_method(rb_singleton_class(mThreadSafety), "vm_booted!", thread_safety_vm_booted_bang, 0);
+    rb_define_singleton_method(mThreadSafety, "enabled=", thread_safety_enabled_set, 1);
 
     id_report_offense = rb_intern("report_offense");
-    id_thread_safety_disabled = rb_intern("thread_safety_disabled");
+    id_thread_safety_enabled = rb_intern("@thread_safety_enabled");
+
+    rb_global_variable(&root_fiber);
+    rb_global_variable(&rb_cFiber);
 
     rb_gc_impl_init_original();
 }

data/lib/thread_safety/offense.rb

@@ -2,30 +2,22 @@
 
 module ThreadSafety
   class Offense
-    attr_reader :object, :backtrace, :access_thread
+    attr_reader :object, :backtrace, :created_fiber, :created_thread, :access_fiber, :access_thread
 
-    def initialize(object, created_thread_obj_id, access_thread)
-      @object = object
-      @created_thread_obj_id = created_thread_obj_id
-      @access_thread = access_thread
-      @backtrace = caller_locations(2).freeze
-    end
+    # Ruby 3.4 includes an extra `Class#new` frame in the call stack compared to Ruby 4.0
+    CALLER_SKIP = RUBY_VERSION >= "4.0" ? 2 : 3
 
-    def created_thread
-      @created_thread = find_thread_from_obj_id(@created_thread_obj_id)
+    def initialize(object, created_fiber, created_thread)
+      @object = object
+      @created_fiber = created_fiber
+      @created_thread = created_thread
+      @access_fiber = Fiber.current
+      @access_thread = Thread.current
+      @backtrace = caller_locations(CALLER_SKIP).freeze
     end
 
     def to_s
       "#<ThreadSafety::Offense object=#{object} created_thread=#{created_thread} access_thread=#{access_thread} backtrace=#{backtrace[0]}>"
     end
-
-    private
-
-    def find_thread_from_obj_id(obj_id)
-      # -1 is the main_thread_id
-      return Thread.main if obj_id == -1
-
-      Thread.list.find { |t| t.object_id == obj_id }
-    end
   end
 end

data/lib/thread_safety/patches.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ThreadSafety
+  module Patches
+    def thread_safety_enabled=(val)
+      @thread_safety_enabled = val
+    end
+  end
+end
+
+Thread.prepend(ThreadSafety::Patches)
+Fiber.prepend(ThreadSafety::Patches)

data/lib/thread_safety/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ThreadSafety
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end