pf2 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d576aec57e600cc77194fabb8c1b7b3c782c4ab76a03ec3b0f24581eb4c317ae
-  data.tar.gz: a290d23df802601977622f1afe39f1f2d6cd92a9350b25d203e97c3b6da6db16
+  metadata.gz: 29a7c92a2a313dec57af9a3427cd723224f64bf53cf74a488253741e1098c12d
+  data.tar.gz: 4958d188fdddec9fb8143a1b864e9c40d989bbb3360745eb0846687cefc97b9d
 SHA512:
-  metadata.gz: a8d72fa4ccb3395f0fdd9203885c1e0cb8a00429597a6dd756e80fb70e0d8092c084992bd9595ee21789a4aaf2550e2284b6d3f81b448dc330088b325d822d85
-  data.tar.gz: 8f93c98574ef7077336232bb1b51a4af1ac4ba2561914a299209a5c2879fe9af3e8998c8df264836f698fea05c8d028f7ae985de3c18e9889f05568ec2740bc1
+  metadata.gz: 2a2a7ecd0a4cb0d84f022c3ec1e0844e2c537cfad88f91b0051609006d8c2f4d596f15a1fd259709c97c1ffccbae87e96758a4bcfb70293d88fb44d7888f4071
+  data.tar.gz: 28b108cd63c75d7ead6f34fdd88fdaa867a9601a0217899b024176a4e5508ef9dec7395bf7ae77513de6eb4cc765be90e010146bdd114b989b33359e4ac55068

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## [Unreleased]
 
+
+## [0.5.1] - 2024-03-25
+
+### Fixed
+
+- Fixed compilation on non-Linux environments.
+
+
+## [0.5.0] - 2024-03-25
+
+### Added
+
+- `pf2 serve` subcommand
+  - `pf2 serve -- ruby target.rb`
+  - Profile programs without any change
+- New option: `threads: :all`
+  - When specified, Pf2 will track all active threads.
+  - `threads: nil` / omitting the `threads` option has the same effect.
+- Introduce `Pf2::Session` (https://github.com/osyoyu/pf2/pull/16)
+  - `Session` will be responsible for managing Profiles and Schedulers
+
+### Removed
+
+- `Pf2::SignalScheduler` and `Pf2::TimerThreadScheduler` are now hidden from Ruby.
+- `track_all_threads` option is removed in favor of `threads: :all`.
+
+
+## [0.4.0] - 2024-03-22
+
 ### Added
 
 - New option: `track_all_threads`

data/Cargo.lock

@@ -456,9 +456,9 @@ checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
 
 [[package]]
 name = "shlex"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "syn"

data/README.md

@@ -13,6 +13,19 @@ Notable Capabilites
 Usage
 --------
 
+### Quickstart
+
+Run your Ruby program through `pf2 serve`.
+Wait a while until Pf2 collects profiles (or until the target program exits), then open the displayed link for visualization.
+
+```
+$ pf2 serve -- ruby target.rb
+[Pf2] Listening on localhost:51502.
+[Pf2] Open https://profiler.firefox.com/from-url/http%3A%2F%2Flocalhost%3A51502%2Fprofile for visualization.
+
+I'm the target program!
+```
+
 ### Profiling
 
 Pf2 will collect samples every 10 ms of wall time by default.
@@ -55,11 +68,10 @@ Pf2 accepts the following configuration keys:
 ```rb
 Pf2.start(
   interval_ms: 49,        # Integer: The sampling interval in milliseconds (default: 49)
-  threads: [],            # Array<Thread>: A list of Ruby Threads to be tracked (default: `Thread.list`)
   time_mode: :cpu,        # `:cpu` or `:wall`: The sampling timer's mode
                           # (default: `:cpu` for SignalScheduler, `:wall` for TimerThreadScheduler)
-  track_all_threads: true # Boolean: Whether to track all Threads regardless of `threads` option
-                          # (default: false)
+  threads: [th1, th2],    # `Array<Thread>` | `:all`: A list of Ruby Threads to be tracked.
+                          # When `:all` or unspecified, Pf2 will track all active Threads.
 )
 ```
 

data/ext/pf2/src/lib.rs

@@ -9,8 +9,12 @@ mod profile;
 mod profile_serializer;
 mod ringbuffer;
 mod sample;
+mod scheduler;
+mod session;
 #[cfg(target_os = "linux")]
 mod signal_scheduler;
+#[cfg(not(target_os = "linux"))]
+mod signal_scheduler_unsupported_platform;
 mod timer_thread_scheduler;
 mod util;
 

data/ext/pf2/src/profile_serializer.rs

@@ -6,6 +6,7 @@ use rb_sys::*;
 
 use crate::backtrace::Backtrace;
 use crate::profile::Profile;
+use crate::util::RTEST;
 
 #[derive(Debug, Deserialize, Serialize)]
 pub struct ProfileSerializer {
@@ -62,6 +63,10 @@ struct FrameTableEntry {
     id: FrameTableId,
     entry_type: FrameTableEntryType,
     full_label: String,
+    file_name: Option<String>,
+    function_first_lineno: Option<i32>,
+    callsite_lineno: Option<i32>,
+    address: Option<usize>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -77,6 +82,11 @@ struct ProfileSample {
     stack_tree_id: StackTreeNodeId,
 }
 
+struct NativeFunctionFrame {
+    pub symbol_name: String,
+    pub address: Option<usize>,
+}
+
 impl ProfileSerializer {
     pub fn serialize(profile: &Profile) -> String {
         let mut sequence = 1;
@@ -92,49 +102,46 @@ impl ProfileSerializer {
 
                 // Process C-level stack
 
-                // A vec to keep the "programmer's" C stack trace.
-                // A single PC may be mapped to multiple inlined frames,
-                // so we keep the expanded stack frame in this Vec.
-                let mut c_stack: Vec<String> = vec![];
+                let mut c_stack: Vec<NativeFunctionFrame> = vec![];
+                // Rebuild the original backtrace (including inlined functions) from the PC.
                 for i in 0..sample.c_backtrace_pcs[0] {
                     let pc = sample.c_backtrace_pcs[i + 1];
                     Backtrace::backtrace_syminfo(
                         &profile.backtrace_state,
                         pc,
-                        |_pc: usize, symname: *const c_char, _symval: usize, _symsize: usize| {
+                        |_pc: usize, symname: *const c_char, symval: usize, _symsize: usize| {
                             if symname.is_null() {
-                                c_stack.push("(no symbol information)".to_owned());
+                                c_stack.push(NativeFunctionFrame {
+                                    symbol_name: "(no symbol information)".to_owned(),
+                                    address: None,
+                                });
                             } else {
-                                c_stack.push(CStr::from_ptr(symname).to_str().unwrap().to_owned());
+                                c_stack.push(NativeFunctionFrame {
+                                    symbol_name: CStr::from_ptr(symname)
+                                        .to_str()
+                                        .unwrap()
+                                        .to_owned(),
+                                    address: Some(symval),
+                                });
                             }
                         },
                         Some(Backtrace::backtrace_error_callback),
                     );
                 }
-
-                // Strip the C stack trace:
-                // - Remove Pf2-related frames which are always captured
-                // - Remove frames below rb_vm_exec
-                let mut reached_ruby = false;
-                c_stack.retain(|frame| {
-                    if reached_ruby {
-                        return false;
-                    }
-                    if frame.contains("pf2") {
-                        return false;
-                    }
-                    if frame.contains("rb_vm_exec") || frame.contains("vm_call_cfunc_with_frame") {
-                        reached_ruby = true;
-                        return false;
+                for frame in c_stack.iter() {
+                    if frame.symbol_name.contains("pf2") {
+                        // Skip Pf2-related frames
+                        continue;
                     }
-                    true
-                });
 
-                for frame in c_stack.iter() {
                     merged_stack.push(FrameTableEntry {
-                        id: calculate_id_for_c_frame(frame),
+                        id: calculate_id_for_c_frame(&frame.symbol_name),
                         entry_type: FrameTableEntryType::Native,
-                        full_label: frame.to_string(),
+                        full_label: frame.symbol_name.clone(),
+                        file_name: None,
+                        function_first_lineno: None,
+                        callsite_lineno: None,
+                        address: frame.address,
                     });
                 }
 
@@ -143,15 +150,52 @@ impl ProfileSerializer {
                 let ruby_stack_depth = sample.line_count;
                 for i in 0..ruby_stack_depth {
                     let frame: VALUE = sample.frames[i as usize];
+                    let lineno: i32 = sample.linenos[i as usize];
+                    let address: Option<usize> = {
+                        let cme = frame
+                            as *mut crate::ruby_internal_apis::rb_callable_method_entry_struct;
+                        let cme = &*cme;
+
+                        if (*(cme.def)).type_ == 1 {
+                            // The cme is a Cfunc
+                            Some((*(cme.def)).cfunc.func as usize)
+                        } else {
+                            // The cme is an ISeq (Ruby code) or some other type
+                            None
+                        }
+                    };
+                    let mut frame_full_label: VALUE = rb_profile_frame_full_label(frame);
+                    let frame_full_label: String = if RTEST(frame_full_label) {
+                        CStr::from_ptr(rb_string_value_cstr(&mut frame_full_label))
+                            .to_str()
+                            .unwrap()
+                            .to_owned()
+                    } else {
+                        "(unknown)".to_owned()
+                    };
+                    let mut frame_path: VALUE = rb_profile_frame_path(frame);
+                    let frame_path: String = if RTEST(frame_path) {
+                        CStr::from_ptr(rb_string_value_cstr(&mut frame_path))
+                            .to_str()
+                            .unwrap()
+                            .to_owned()
+                    } else {
+                        "(unknown)".to_owned()
+                    };
+                    let frame_first_lineno: VALUE = rb_profile_frame_first_lineno(frame);
+                    let frame_first_lineno: Option<i32> = if RTEST(frame_first_lineno) {
+                        Some(rb_num2int(frame_first_lineno).try_into().unwrap())
+                    } else {
+                        None
+                    };
                     merged_stack.push(FrameTableEntry {
                         id: frame,
                         entry_type: FrameTableEntryType::Ruby,
-                        full_label: CStr::from_ptr(rb_string_value_cstr(
-                            &mut rb_profile_frame_full_label(frame),
-                        ))
-                        .to_str()
-                        .unwrap()
-                        .to_owned(),
+                        full_label: frame_full_label,
+                        file_name: Some(frame_path),
+                        function_first_lineno: frame_first_lineno,
+                        callsite_lineno: Some(lineno),
+                        address,
                     });
                 }
 

data/ext/pf2/src/ruby_init.rs

@@ -2,9 +2,7 @@
 
 use rb_sys::*;
 
-#[cfg(target_os = "linux")]
-use crate::signal_scheduler::SignalScheduler;
-use crate::timer_thread_scheduler::TimerThreadScheduler;
+use crate::session::ruby_object::SessionRubyObject;
 use crate::util::*;
 
 #[allow(non_snake_case)]
@@ -21,53 +19,24 @@ extern "C" fn Init_pf2() {
     unsafe {
         let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
 
-        #[cfg(target_os = "linux")]
-        {
-            let rb_mPf2_SignalScheduler =
-                rb_define_class_under(rb_mPf2, cstr!("SignalScheduler"), rb_cObject);
-            rb_define_alloc_func(rb_mPf2_SignalScheduler, Some(SignalScheduler::rb_alloc));
-            rb_define_method(
-                rb_mPf2_SignalScheduler,
-                cstr!("initialize"),
-                Some(to_ruby_cfunc_with_args(SignalScheduler::rb_initialize)),
-                -1,
-            );
-            rb_define_method(
-                rb_mPf2_SignalScheduler,
-                cstr!("start"),
-                Some(to_ruby_cfunc_with_no_args(SignalScheduler::rb_start)),
-                0,
-            );
-            rb_define_method(
-                rb_mPf2_SignalScheduler,
-                cstr!("stop"),
-                Some(to_ruby_cfunc_with_no_args(SignalScheduler::rb_stop)),
-                0,
-            );
-        }
-
-        let rb_mPf2_TimerThreadScheduler =
-            rb_define_class_under(rb_mPf2, cstr!("TimerThreadScheduler"), rb_cObject);
-        rb_define_alloc_func(
-            rb_mPf2_TimerThreadScheduler,
-            Some(TimerThreadScheduler::rb_alloc),
-        );
+        let rb_mPf2_Session = rb_define_class_under(rb_mPf2, cstr!("Session"), rb_cObject);
+        rb_define_alloc_func(rb_mPf2_Session, Some(SessionRubyObject::rb_alloc));
         rb_define_method(
-            rb_mPf2_TimerThreadScheduler,
+            rb_mPf2_Session,
             cstr!("initialize"),
-            Some(to_ruby_cfunc_with_args(TimerThreadScheduler::rb_initialize)),
+            Some(to_ruby_cfunc_with_args(SessionRubyObject::rb_initialize)),
             -1,
         );
         rb_define_method(
-            rb_mPf2_TimerThreadScheduler,
+            rb_mPf2_Session,
             cstr!("start"),
-            Some(to_ruby_cfunc_with_no_args(TimerThreadScheduler::rb_start)),
+            Some(to_ruby_cfunc_with_no_args(SessionRubyObject::rb_start)),
             0,
         );
         rb_define_method(
-            rb_mPf2_TimerThreadScheduler,
+            rb_mPf2_Session,
             cstr!("stop"),
-            Some(to_ruby_cfunc_with_no_args(TimerThreadScheduler::rb_stop)),
+            Some(to_ruby_cfunc_with_no_args(SessionRubyObject::rb_stop)),
             0,
         );
     }

data/ext/pf2/src/ruby_internal_apis.rs

@@ -1,12 +1,42 @@
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
 
-use libc::{clockid_t, pthread_getcpuclockid, pthread_t};
+use libc::{clockid_t, pthread_t};
 use rb_sys::{rb_check_typeddata, rb_data_type_struct, RTypedData, VALUE};
-use std::ffi::{c_char, c_int};
+use std::ffi::{c_char, c_int, c_void};
 use std::mem::MaybeUninit;
 
+#[cfg(target_os = "linux")]
+use libc::pthread_getcpuclockid;
+
+#[cfg(not(target_os = "linux"))]
+pub unsafe fn pthread_getcpuclockid(thread: pthread_t, clk_id: *mut clockid_t) -> c_int {
+    unimplemented!()
+}
+
 // Types and structs from Ruby 3.4.0.
+#[repr(C)]
+pub struct rb_callable_method_entry_struct {
+    /* same fields with rb_method_entry_t */
+    pub flags: VALUE,
+    _padding_defined_class: VALUE,
+    pub def: *mut rb_method_definition_struct,
+    // ...
+}
+
+#[repr(C)]
+pub struct rb_method_definition_struct {
+    pub type_: c_int,
+    _padding: [c_char; 4],
+    pub cfunc: rb_method_cfunc_struct,
+    // ...
+}
+
+#[repr(C)]
+pub struct rb_method_cfunc_struct {
+    pub func: *mut c_void,
+    // ...
+}
 
 type rb_nativethread_id_t = libc::pthread_t;
 

data/ext/pf2/src/scheduler.rs

@@ -0,0 +1,10 @@
+use rb_sys::{size_t, VALUE};
+
+pub trait Scheduler {
+    fn start(&self) -> VALUE;
+    fn stop(&self) -> VALUE;
+    fn on_new_thread(&self, thread: VALUE);
+    fn dmark(&self);
+    fn dfree(&self);
+    fn dsize(&self) -> size_t;
+}

data/ext/pf2/src/session/configuration.rs

@@ -0,0 +1,106 @@
+use std::collections::HashSet;
+use std::str::FromStr;
+use std::time::Duration;
+
+use rb_sys::*;
+
+use crate::util::cstr;
+
+pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::Signal;
+pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(49);
+pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::CpuTime;
+
+#[derive(Clone, Debug)]
+pub struct Configuration {
+    pub scheduler: Scheduler,
+    pub interval: Duration,
+    pub time_mode: TimeMode,
+    pub target_ruby_threads: Threads,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Scheduler {
+    Signal,
+    TimerThread,
+}
+
+impl FromStr for Scheduler {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "signal" => Ok(Self::Signal),
+            "timer_thread" => Ok(Self::TimerThread),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum TimeMode {
+    CpuTime,
+    WallTime,
+}
+
+impl FromStr for TimeMode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "cpu" => Ok(Self::CpuTime),
+            "wall" => Ok(Self::WallTime),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Threads {
+    All,
+    Targeted(HashSet<VALUE>),
+}
+
+impl Configuration {
+    pub fn validate(&self) -> Result<(), String> {
+        if self.scheduler == Scheduler::TimerThread && self.time_mode == TimeMode::CpuTime {
+            return Err("TimerThread scheduler does not support `time_mode: :cpu`.".to_owned());
+        }
+        if self.scheduler == Scheduler::TimerThread && self.target_ruby_threads == Threads::All {
+            return Err(concat!(
+                "TimerThread scheduler does not support `threads: :all` at the moment. ",
+                "Consider using `threads: Thread.list` for watching all threads at profiler start."
+            )
+            .to_owned());
+        }
+
+        Ok(())
+    }
+
+    pub fn to_rb_hash(&self) -> VALUE {
+        let hash: VALUE = unsafe { rb_hash_new() };
+        unsafe {
+            rb_hash_aset(
+                hash,
+                rb_id2sym(rb_intern(cstr!("scheduler"))),
+                rb_id2sym(rb_intern(match self.scheduler {
+                    Scheduler::Signal => cstr!("signal"),
+                    Scheduler::TimerThread => cstr!("timer_thread"),
+                })),
+            );
+            rb_hash_aset(
+                hash,
+                rb_id2sym(rb_intern(cstr!("interval_ms"))),
+                rb_int2inum(self.interval.as_millis().try_into().unwrap()),
+            );
+            rb_hash_aset(
+                hash,
+                rb_id2sym(rb_intern(cstr!("time_mode"))),
+                rb_id2sym(rb_intern(match self.time_mode {
+                    TimeMode::CpuTime => cstr!("cpu"),
+                    TimeMode::WallTime => cstr!("wall"),
+                })),
+            );
+        }
+        hash
+    }
+}

data/ext/pf2/src/session/new_thread_watcher.rs

@@ -0,0 +1,80 @@
+use std::collections::HashSet;
+use std::ffi::c_void;
+use std::mem::ManuallyDrop;
+use std::ptr::null_mut;
+use std::rc::Rc;
+use std::sync::Mutex;
+
+use rb_sys::*;
+
+/// A helper to watch new Ruby threads.
+///
+/// `NewThreadWatcher` operates on the Events Hooks API.
+/// Instead of relying on the `THREAD_EVENT_STARTED` event, it combines the
+/// `THREAD_EVENT_RESUMED` event and an internal _known-threads_ record.
+///
+/// This is to support operations requiring the underlying pthread. Ruby Threads
+/// are not guaranteed to be fully initialized at the time
+/// `THREAD_EVENT_STARTED` is triggered; i.e. the underlying pthread has not
+/// been created yet and `Thread#native_thread_id` returns `nil`.
+pub struct NewThreadWatcher {
+    inner: Rc<Mutex<Inner>>,
+    event_hook: *mut rb_internal_thread_event_hook_t,
+}
+
+struct Inner {
+    known_threads: HashSet<VALUE>,
+    on_new_thread: Box<dyn Fn(VALUE)>,
+}
+
+impl NewThreadWatcher {
+    pub fn watch<F>(callback: F) -> Self
+    where
+        F: Fn(VALUE) + 'static,
+    {
+        let mut watcher = Self {
+            inner: Rc::new(Mutex::new(Inner {
+                known_threads: HashSet::new(),
+                on_new_thread: Box::new(callback),
+            })),
+            event_hook: null_mut(),
+        };
+
+        let inner_ptr = Rc::into_raw(Rc::clone(&watcher.inner));
+        unsafe {
+            watcher.event_hook = rb_internal_thread_add_event_hook(
+                Some(Self::on_thread_resume),
+                RUBY_INTERNAL_THREAD_EVENT_RESUMED,
+                inner_ptr as *mut c_void,
+            );
+        };
+
+        watcher
+    }
+
+    unsafe extern "C" fn on_thread_resume(
+        _flag: rb_event_flag_t,
+        data: *const rb_internal_thread_event_data,
+        custom_data: *mut c_void,
+    ) {
+        let ruby_thread: VALUE = unsafe { (*data).thread };
+
+        // A pointer to Box<Inner> is passed as custom_data
+        let inner = unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Inner>)) };
+        let mut inner = inner.lock().unwrap();
+
+        if !inner.known_threads.contains(&ruby_thread) {
+            inner.known_threads.insert(ruby_thread);
+            (inner.on_new_thread)(ruby_thread);
+        }
+    }
+}
+
+impl Drop for NewThreadWatcher {
+    fn drop(&mut self) {
+        log::trace!("Cleaning up event hook");
+        unsafe {
+            rb_internal_thread_remove_event_hook(self.event_hook);
+        }
+    }
+}

data/ext/pf2/src/session/ruby_object.rs

@@ -0,0 +1,90 @@
+use std::ffi::{c_int, c_void};
+use std::mem;
+use std::mem::ManuallyDrop;
+use std::ptr::null_mut;
+
+use rb_sys::*;
+
+use crate::util::cstr;
+
+use super::Session;
+
+pub struct SessionRubyObject {
+    session: Option<Session>,
+}
+
+impl SessionRubyObject {
+    pub unsafe extern "C" fn rb_initialize(
+        argc: c_int,
+        argv: *const VALUE,
+        rbself: VALUE,
+    ) -> VALUE {
+        let mut obj = unsafe { Self::get_struct_from(rbself) };
+        obj.session = Some(Session::new_from_rb_initialize(argc, argv, rbself));
+        Qnil.into()
+    }
+
+    pub unsafe extern "C" fn rb_start(rbself: VALUE) -> VALUE {
+        let mut obj = Self::get_struct_from(rbself);
+        match &mut obj.session {
+            Some(session) => session.start(),
+            None => panic!("Session is not initialized"),
+        }
+    }
+
+    pub unsafe extern "C" fn rb_stop(rbself: VALUE) -> VALUE {
+        let mut obj = Self::get_struct_from(rbself);
+        match &mut obj.session {
+            Some(session) => session.stop(),
+            None => panic!("Session is not initialized"),
+        }
+    }
+
+    // Extract the SessionRubyObject struct from a Ruby object
+    unsafe fn get_struct_from(obj: VALUE) -> ManuallyDrop<Box<Self>> {
+        unsafe {
+            let ptr = rb_check_typeddata(obj, &RBDATA);
+            ManuallyDrop::new(Box::from_raw(ptr as *mut SessionRubyObject))
+        }
+    }
+
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn rb_alloc(_rbself: VALUE) -> VALUE {
+        let obj = Box::new(SessionRubyObject { session: None });
+
+        let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
+        let rb_cSession = rb_define_class_under(rb_mPf2, cstr!("Session"), rb_cObject);
+        // Wrap the struct into a Ruby object
+        rb_data_typed_object_wrap(rb_cSession, Box::into_raw(obj) as *mut c_void, &RBDATA)
+    }
+
+    unsafe extern "C" fn dmark(ptr: *mut c_void) {
+        let obj = ManuallyDrop::new(Box::from_raw(ptr as *mut SessionRubyObject));
+        if let Some(session) = &obj.session {
+            session.dmark()
+        }
+    }
+
+    unsafe extern "C" fn dfree(ptr: *mut c_void) {
+        drop(Box::from_raw(ptr as *mut SessionRubyObject));
+    }
+
+    unsafe extern "C" fn dsize(_: *const c_void) -> size_t {
+        // FIXME: Report something better
+        mem::size_of::<SessionRubyObject>() as size_t
+    }
+}
+
+static mut RBDATA: rb_data_type_t = rb_data_type_t {
+    wrap_struct_name: cstr!("SessionRubyObject"),
+    function: rb_data_type_struct__bindgen_ty_1 {
+        dmark: Some(SessionRubyObject::dmark),
+        dfree: Some(SessionRubyObject::dfree),
+        dsize: Some(SessionRubyObject::dsize),
+        dcompact: None,
+        reserved: [null_mut(); 1],
+    },
+    parent: null_mut(),
+    data: null_mut(),
+    flags: 0,
+};