thread_safety 0.1.0

data/ext/gc/gc.h

@@ -0,0 +1,232 @@
+#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_WEAK_TABLE_COUNT
+};
+
+RUBY_SYMBOL_EXPORT_BEGIN
+unsigned int rb_gc_vm_lock(void);
+void rb_gc_vm_unlock(unsigned int lev);
+unsigned int rb_gc_cr_lock(void);
+void rb_gc_cr_unlock(unsigned int lev);
+unsigned int rb_gc_vm_lock_no_barrier(void);
+void rb_gc_vm_unlock_no_barrier(unsigned int lev);
+void rb_gc_vm_barrier(void);
+size_t rb_gc_obj_optimal_size(VALUE obj);
+void rb_gc_mark_children(void *objspace, VALUE obj);
+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);
+void rb_gc_update_object_references(void *objspace, VALUE obj);
+void rb_gc_update_vm_references(void *objspace);
+void rb_gc_event_hook(VALUE obj, rb_event_flag_t event);
+void *rb_gc_get_objspace(void);
+size_t rb_size_mul_or_raise(size_t x, size_t y, VALUE exc);
+void rb_gc_run_obj_finalizer(VALUE objid, long count, VALUE (*callback)(long i, void *data), void *data);
+void rb_gc_set_pending_interrupt(void);
+void rb_gc_unset_pending_interrupt(void);
+void rb_gc_obj_free_vm_weak_references(VALUE obj);
+bool rb_gc_obj_free(void *objspace, VALUE obj);
+void rb_gc_save_machine_context(void);
+void rb_gc_mark_roots(void *objspace, const char **categoryp);
+void rb_gc_ractor_newobj_cache_foreach(void (*func)(void *cache, void *data), void *data);
+bool rb_gc_multi_ractor_p(void);
+void rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *passing_data);
+void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
+void rb_obj_info_dump(VALUE obj);
+const char *rb_obj_info(VALUE obj);
+bool rb_gc_shutdown_call_finalizer_p(VALUE obj);
+uint32_t rb_gc_get_shape(VALUE obj);
+void rb_gc_set_shape(VALUE obj, uint32_t shape_id);
+uint32_t rb_gc_rebuild_shape(VALUE obj, size_t heap_id);
+size_t rb_obj_memsize_of(VALUE obj);
+void rb_gc_prepare_heap_process_object(VALUE obj);
+bool ruby_free_at_exit_p(void);
+bool rb_memerror_reentered(void);
+bool rb_obj_id_p(VALUE);
+
+#if USE_MODULAR_GC
+bool rb_gc_event_hook_required_p(rb_event_flag_t event);
+void *rb_gc_get_ractor_newobj_cache(void);
+void rb_gc_initialize_vm_context(struct rb_gc_vm_context *context);
+void rb_gc_worker_thread_set_vm_context(struct rb_gc_vm_context *context);
+void rb_gc_worker_thread_unset_vm_context(struct rb_gc_vm_context *context);
+#endif
+RUBY_SYMBOL_EXPORT_END
+
+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)
+#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/gc_impl.h

@@ -0,0 +1,127 @@
+#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, VALUE v1, VALUE v2, VALUE v3, 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);
+GC_IMPL_FN void *rb_gc_impl_calloc(void *objspace_ptr, size_t size);
+GC_IMPL_FN void *rb_gc_impl_realloc(void *objspace_ptr, void *ptr, size_t new_size, size_t old_size);
+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);
+// Object ID
+GC_IMPL_FN VALUE rb_gc_impl_object_id(void *objspace_ptr, VALUE obj);
+GC_IMPL_FN VALUE rb_gc_impl_object_id_to_ref(void *objspace_ptr, VALUE object_id);
+// 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

@@ -0,0 +1,90 @@
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+#include "gc/gc.h"
+#include "gc/gc_impl.h"
+
+#define RVALUE_OVERHEAD (sizeof(VALUE))
+
+static VALUE main_thread_id = INT2FIX(-1);
+static VALUE mThreadSafety;
+static ID id_report_offense, id_thread_safety_disabled;
+
+size_t rb_gc_impl_obj_slot_size(VALUE obj);
+
+static VALUE
+get_owner_thread_id(VALUE obj)
+{
+    return *(VALUE *)(obj + rb_gc_impl_obj_slot_size(obj));
+}
+
+static VALUE
+get_current_thread_id(void)
+{
+    VALUE thread = rb_thread_current();
+
+    if (thread == 0 || thread == rb_thread_main()) {
+        return main_thread_id;
+    }
+
+    return rb_obj_id(thread);
+}
+
+#define PATCH_GC_FUNC(ret_type, name, ...) \
+    ret_type rb_gc_impl_##name##_original(__VA_ARGS__); \
+    ret_type rb_gc_impl_##name(__VA_ARGS__)
+
+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();
+
+    return obj;
+}
+#define rb_gc_impl_new_obj rb_gc_impl_new_obj_original
+
+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 &&
+            // Skip imemo types like call caches.
+            (RB_IMMEDIATE_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);
+
+        rb_thread_local_aset(current_thread, id_thread_safety_disabled, Qtrue);
+
+        rb_funcall(mThreadSafety, id_report_offense, 3, a, owner_thread_id, rb_thread_current());
+
+        rb_thread_local_aset(current_thread, id_thread_safety_disabled, Qfalse);
+
+        if (prev_gc_enabled) rb_gc_impl_gc_enable(objspace_ptr);
+    }
+
+    rb_gc_impl_writebarrier_original(objspace_ptr, a, b);
+}
+#define rb_gc_impl_writebarrier rb_gc_impl_writebarrier_original
+
+PATCH_GC_FUNC(void, init, void)
+{
+    rb_gc_register_address(&mThreadSafety);
+    mThreadSafety = rb_define_module("ThreadSafety");
+
+    id_report_offense = rb_intern("report_offense");
+    id_thread_safety_disabled = rb_intern("thread_safety_disabled");
+
+    rb_gc_impl_init_original();
+}
+#define rb_gc_impl_init rb_gc_impl_init_original
+
+#include "gc/default/default.c"

data/lib/thread_safety/offense.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ThreadSafety
+  class Offense
+    attr_reader :object, :backtrace, :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
+
+    def created_thread
+      @created_thread = find_thread_from_obj_id(@created_thread_obj_id)
+    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/version.rb

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

data/lib/thread_safety.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "thread_safety/offense"
+require_relative "thread_safety/version"
+
+module ThreadSafety
+  class << self
+    attr_reader :callback
+
+    def callback=(cb)
+      @callback = cb
+    end
+
+    def suppress_warnings(&block)
+      original_thread_safety_disabled = Thread.current[:thread_safety_disabled]
+      Thread.current[:thread_safety_disabled] = true
+      yield
+    ensure
+      Thread.current[:thread_safety_disabled] = original_thread_safety_disabled
+    end
+
+    private
+
+    def report_offense(...)
+      return unless callback
+
+      callback.call(Offense.new(...))
+    rescue => e
+      $stderr.puts "[ThreadSafety]: callback raised #{e.inspect}"
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: thread_safety
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Zhu
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- peter@peterzhu.ca
+executables:
+- thread_safety
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- exe/thread_safety
+- ext/ccan/build_assert/build_assert.h
+- ext/ccan/check_type/check_type.h
+- ext/ccan/container_of/container_of.h
+- ext/ccan/licenses/BSD-MIT
+- ext/ccan/licenses/CC0
+- ext/ccan/list/list.h
+- ext/ccan/str/str.h
+- ext/darray.h
+- ext/extconf.rb
+- ext/extconf_base.rb
+- ext/gc/default/default.c
+- ext/gc/gc.h
+- ext/gc/gc_impl.h
+- ext/thread_safety.c
+- lib/thread_safety.rb
+- lib/thread_safety/offense.rb
+- lib/thread_safety/version.rb
+homepage: https://github.com/Shopify/thread_safety
+licenses: []
+metadata:
+  homepage_uri: https://github.com/Shopify/thread_safety
+  source_code_uri: https://github.com/Shopify/thread_safety
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.0.dev
+specification_version: 4
+summary: Thread Safety is a tool that plugs into Ruby's Modular GC feature to detect
+  potential thread-safety issues.
+test_files: []