zrip 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50caa1679bd74290e01032b2564ab2ac083633f00ad7070f2e3e597572ffe22b
-  data.tar.gz: d89a94b7221aba11a0084f8ffeab771428f682ddf19908a647c2bce862b43ffe
+  metadata.gz: 8a16cab574ece332812f7e25c48b75152a11c63418619527273e974353c7279b
+  data.tar.gz: 9504303323b72ca6b079ddcb528a3be99d550a56125241c669613221d5aea4e7
 SHA512:
-  metadata.gz: 74bc8d13edae353144da41a66e80d41440157dc11c9555726c2c01659d88a02c8ffd0a7410b0157fb011a45677c54448a808ed463a1f9b1d99bd9a2769e42926
-  data.tar.gz: 91c282a2f5275e2e0cd72a9a2cf089a0582e47d256acce3c9bf67be6f494ab89a046bfece175d23f9543e7162b90b8bf66cc0dd97e5ebd5c9a695c3462e23d01
+  metadata.gz: f80dfc72c92ce4a072d186ba75efa88f88281aab64cc94a19d15e3e15f1548aa52fa7b9cec4d7593db1dc6b4a8ac37cf28e37d14cb38beb059d85f7b6c460288
+  data.tar.gz: 910c850499f28d49c02fdfca756770a4d182ac7688891efa7cccc920f1dd2180b30fbcb984cf8b34e143d049374cd0d6da947f5f8f55998a89d9183753a17c9b

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-11
+
+- Update the `zrip` crate dependency to 0.8.11 and `rb-sys` to 0.9.130.
+- Make `FrameCodec` instances Ractor-shareable as documented, with native
+  dictionary copies that leave caller strings mutable.
+- Unlock input strings and free native results when Ruby interrupts a call
+  that released the GVL.
+- Protect mutable inputs when mutex contention releases the GVL, including
+  calls below the normal size threshold.
+- Catch Rust panics inside native callbacks instead of aborting the process.
+- Preserve Ruby exceptions, `Thread#kill`, and `catch`/`throw` through
+  protected native calls.
+- Avoid trainer deadlocks during sample coercion and borrow decompression
+  input after size coercion.
+- Enforce `max_output_size:` inside the native decoder across concatenated
+  frames, before allocating or decoding past the limit.
+- Validate complete frame headers when reading frame content sizes.
+- Correct the README compression level example to the supported maximum.
+- Update GitHub Actions checkout to v7 and check Rust tests, formatting, and
+  Clippy in CI.
+
 ## [0.2.0] - 2026-08-07
 
 - Release the Ruby GVL around large frame/block compression and frame

data/Cargo.lock

@@ -31,9 +31,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.13.1"
+version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "cexpr"
@@ -46,9 +46,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
 
 [[package]]
 name = "clang-sys"
@@ -63,15 +63,15 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.17.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
 
 [[package]]
 name = "fearless_simd"
-version = "0.6.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0f5f895dac0865bc235f1364793899569a7db538137f1024dccea56bf41c78d"
+checksum = "3296eb97d869113eaf148a6bdf01884e90b3828ad7ae2340b0f93362fc158611"
 
 [[package]]
 name = "glob"
@@ -90,15 +90,15 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
 
 [[package]]
 name = "libc"
-version = "0.2.189"
+version = "0.2.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
 
 [[package]]
 name = "libloading"
@@ -152,18 +152,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
+checksum = "02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -234,9 +234,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.24"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
 
 [[package]]
 name = "windows-link"
@@ -246,17 +246,17 @@ checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "zrip"
-version = "0.1.2"
+version = "0.2.1"
 dependencies = [
  "rb-sys",
- "zrip 0.8.5",
+ "zrip 0.8.11",
 ]
 
 [[package]]
 name = "zrip"
-version = "0.8.5"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa05c09787b3aaaaa57870dca9fd9f3b4934018cbb5dde1b112017e2e70ec491"
+checksum = "9e85bd0b02784d8753fe5cc435dfb65043be505cb621643a3ac4a0c43eb49e4a"
 dependencies = [
  "zrip-core",
  "zrip-decode",
@@ -265,15 +265,15 @@ dependencies = [
 
 [[package]]
 name = "zrip-core"
-version = "0.9.1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9335acd94c1f09f729178fc339f9d49790254c1e98ba076f88df3a3f534c4e7d"
+checksum = "6dec95be8c75252532ba0ef5e738d9da26a6f51ad52cb45f4ed90c89979727c1"
 
 [[package]]
 name = "zrip-decode"
-version = "0.8.5"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1801cd8b5d374e2bc31cd8a231182dd47e621492fa0bf68ca7d3033e001cd06b"
+checksum = "aca029cf83b6a6e282008a9aa1079e13f216b28bac670eb1fb0769c1d256cb0e"
 dependencies = [
  "fearless_simd",
  "zrip-core",
@@ -281,9 +281,10 @@ dependencies = [
 
 [[package]]
 name = "zrip-encode"
-version = "0.8.4"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38e7e22b665b947f0240b44805713e87a15c34e86d0891cbe2856c575c5cda1d"
+checksum = "b657fa83287fe6799596e53540a7b1f179ca34ffd8589d5c576a5b8a1bcc4260"
 dependencies = [
+ "fearless_simd",
  "zrip-core",
 ]

data/Cargo.toml

@@ -6,4 +6,3 @@ resolver = "2"
 opt-level     = 3
 lto           = true
 codegen-units = 1
-panic         = "abort"

data/README.md

@@ -58,7 +58,7 @@ original   = codec.decompress(compressed)
 
 ```ruby
 fast   = Zrip::FrameCodec.new(level: -3)   # negative = faster
-strong = Zrip::FrameCodec.new(level: 19)    # higher = smaller output
+strong = Zrip::FrameCodec.new(level: 4)    # highest supported level
 ```
 
 ### Bounded decompression

data/ext/zrip/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name    = "zrip"
-version = "0.1.2"
+version = "0.2.1"
 edition = "2021"
 build   = "build.rs"
 
@@ -9,8 +9,8 @@ name       = "zrip"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-zstd   = { version = "0.8.5", package = "zrip", features = ["frame", "dict_builder"] }
-rb-sys = "0.9"
+zstd   = { version = "0.8.11", package = "zrip", features = ["frame", "dict_builder"] }
+rb-sys = "0.9.130"
 
 [build-dependencies]
-rb-sys = "0.9"
+rb-sys = "0.9.130"

data/ext/zrip/src/lib.rs

@@ -1,7 +1,6 @@
 mod rb;
 
 use std::ffi::c_void;
-use std::io::Read;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::{Mutex, OnceLock, TryLockError};
 
@@ -18,7 +17,6 @@ static OUTPUT_SIZE_LIMIT_ERROR: OnceLock<GlobalValue> = OnceLock::new();
 
 const GVL_COMPRESS_THRESHOLD: usize = 64 * 1024;
 const GVL_FRAME_DECOMPRESS_THRESHOLD: usize = 64 * 1024;
-const DECOMPRESS_READ_CHUNK: usize = 16 * 1024;
 
 #[derive(Copy, Clone)]
 struct GlobalValue(VALUE);
@@ -52,27 +50,38 @@ fn should_release_frame_decompress_gvl(output_len: usize) -> bool {
     output_len >= GVL_FRAME_DECOMPRESS_THRESHOLD
 }
 
-fn with_mutex<T, R, F>(mutex: &Mutex<T>, release_gvl: bool, name: &str, func: F) -> RbResult<R>
+fn with_mutex<T, R, F>(
+    mutex: &Mutex<T>,
+    release_gvl: bool,
+    name: &str,
+    input: &mut rb::InputBytes,
+    func: F,
+) -> RbResult<R>
 where
-    F: FnOnce(&mut T) -> RbResult<R>,
+    F: FnOnce(&mut T, &[u8]) -> RbResult<R>,
 {
     if release_gvl {
+        input.lock_for_without_gvl(true)?;
         return rb::maybe_without_gvl(true, || {
             let mut guard = mutex
                 .lock()
                 .map_err(|_| RubyErr::runtime(format!("{name} mutex poisoned")))?;
-            func(&mut guard)
-        });
+            func(&mut guard, input.as_slice())
+        })?;
     }
 
     match mutex.try_lock() {
-        Ok(mut guard) => func(&mut guard),
-        Err(TryLockError::WouldBlock) => rb::maybe_without_gvl(true, || {
-            let mut guard = mutex
-                .lock()
-                .map_err(|_| RubyErr::runtime(format!("{name} mutex poisoned")))?;
-            func(&mut guard)
-        }),
+        Ok(mut guard) => func(&mut guard, input.as_slice()),
+        Err(TryLockError::WouldBlock) => {
+            // Even a small input needs protection when contention releases GVL.
+            input.lock_for_without_gvl(true)?;
+            rb::maybe_without_gvl(true, || {
+                let mut guard = mutex
+                    .lock()
+                    .map_err(|_| RubyErr::runtime(format!("{name} mutex poisoned")))?;
+                func(&mut guard, input.as_slice())
+            })?
+        }
         Err(TryLockError::Poisoned(_)) => Err(RubyErr::runtime(format!("{name} mutex poisoned"))),
     }
 }
@@ -89,119 +98,36 @@ enum BoundedError {
 }
 
 fn parse_frame_content_size(input: &[u8]) -> Result<Option<u64>, BoundedError> {
-    if input.len() < 5 {
-        return Err(BoundedError::BadMagic);
-    }
-    if input[..4] != ZSTD_FRAME_MAGIC {
-        return Err(BoundedError::BadMagic);
-    }
-    let fhd = input[4];
-    let fcs_flag = (fhd >> 6) & 3;
-    let single_segment = (fhd >> 5) & 1;
-    let dict_id_flag = fhd & 3;
-
-    let window_desc_size = if single_segment == 0 { 1usize } else { 0 };
-    let dict_id_size = [0usize, 1, 2, 4][dict_id_flag as usize];
-    let fcs_field_size = match fcs_flag {
-        0 => {
-            if single_segment == 1 {
-                1usize
-            } else {
-                return Ok(None);
-            }
-        }
-        1 => 2,
-        2 => 4,
-        3 => 8,
-        _ => unreachable!(),
-    };
-
-    let fcs_offset = 5 + window_desc_size + dict_id_size;
-    if input.len() < fcs_offset + fcs_field_size {
-        return Err(BoundedError::BadMagic);
-    }
-
-    let fcs_bytes = &input[fcs_offset..fcs_offset + fcs_field_size];
-    let value = match fcs_field_size {
-        1 => fcs_bytes[0] as u64,
-        2 => u16::from_le_bytes([fcs_bytes[0], fcs_bytes[1]]) as u64 + 256,
-        4 => u32::from_le_bytes([fcs_bytes[0], fcs_bytes[1], fcs_bytes[2], fcs_bytes[3]]) as u64,
-        8 => u64::from_le_bytes(fcs_bytes.try_into().unwrap()),
-        _ => unreachable!(),
-    };
-
-    Ok(Some(value))
-}
-
-fn io_error_is_output_too_small(err: &std::io::Error) -> bool {
-    matches!(
-        err.get_ref()
-            .and_then(|inner| inner.downcast_ref::<zstd::error::DecompressError>()),
-        Some(zstd::error::DecompressError::OutputTooSmall)
-    )
-}
-
-fn read_decoder_bounded<R: Read>(
-    decoder: &mut R,
-    max_output: usize,
-) -> Result<Vec<u8>, BoundedError> {
-    let mut output = Vec::new();
-    let mut buf = [0u8; DECOMPRESS_READ_CHUNK];
-
-    loop {
-        let n = decoder.read(&mut buf).map_err(|e| {
-            if io_error_is_output_too_small(&e) {
-                BoundedError::OutputSizeLimit {
-                    limit: max_output as u64,
-                }
-            } else {
-                BoundedError::DecoderFailed(format!("{e}"))
-            }
-        })?;
-        if n == 0 {
-            return Ok(output);
-        }
-
-        let Some(next_len) = output.len().checked_add(n) else {
-            return Err(BoundedError::OutputSizeLimit {
-                limit: max_output as u64,
-            });
-        };
-        if next_len > max_output {
-            return Err(BoundedError::OutputSizeLimit {
-                limit: max_output as u64,
-            });
-        }
-
-        output.extend_from_slice(&buf[..n]);
-    }
+    zstd::frame::header::parse_frame_header(input)
+        .map(|header| header.frame_content_size)
+        .map_err(|err| match err {
+            zstd::DecompressError::BadMagic => BoundedError::BadMagic,
+            _ => BoundedError::DecoderFailed(err.to_string()),
+        })
 }
 
 fn decompress_bounded(
     compressed: &[u8],
     max_output: usize,
     dctx: &mut DecompressContext,
-    dict: Option<&Dictionary>,
 ) -> Result<Vec<u8>, BoundedError> {
     if compressed.len() < ZSTD_FRAME_MAGIC.len() || compressed[..4] != ZSTD_FRAME_MAGIC {
         return Err(BoundedError::BadMagic);
     }
 
-    let result = if max_output == 0 {
-        dctx.decompress_with_limit(compressed, usize::MAX)
-            .map(|out| out.into_owned())
-            .map_err(|e| BoundedError::DecoderFailed(format!("{e}")))?
+    let limit = if max_output == 0 {
+        usize::MAX
     } else {
-        let mut decoder = match dict {
-            Some(dict) => {
-                zstd::FrameDecoder::with_dict_and_limit(compressed, dict.clone(), usize::MAX)
-            }
-            None => zstd::FrameDecoder::with_limit(compressed, usize::MAX),
-        };
-        read_decoder_bounded(&mut decoder, max_output)?
+        max_output
     };
-
-    Ok(result)
+    dctx.decompress_with_limit(compressed, limit)
+        .map(|out| out.into_owned())
+        .map_err(|err| match err {
+            zstd::DecompressError::OutputTooSmall => BoundedError::OutputSizeLimit {
+                limit: max_output as u64,
+            },
+            _ => BoundedError::DecoderFailed(err.to_string()),
+        })
 }
 
 fn decompress_work_size(compressed: &[u8], max_output: usize) -> usize {
@@ -277,7 +203,7 @@ fn make_frame_codec_data_type() -> rb_data_type_t {
         },
         parent: std::ptr::null(),
         data: std::ptr::null_mut(),
-        flags: 1,
+        flags: rb::frozen_shareable_flags(),
     }
 }
 
@@ -372,7 +298,6 @@ unsafe fn dict_trainer_ref(value: VALUE) -> RbResult<&'static RbDictTrainer> {
 struct FrameCodec {
     dict_len: usize,
     dict_id: Option<u32>,
-    dict: Option<Dictionary>,
     level: i32,
     cctx: Mutex<CompressContext>,
     dctx: Mutex<DecompressContext>,
@@ -382,16 +307,10 @@ unsafe impl Send for FrameCodec {}
 unsafe impl Sync for FrameCodec {}
 
 fn frame_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -> RbResult<VALUE> {
-    let rb_dict = if rb_dict == rb::qnil() {
-        None
-    } else {
-        let rb_dict = rb::string_value(rb_dict)?;
-        rb::freeze_value(rb_dict)?;
-        Some(rb::value_to_bytes(rb_dict)?)
-    };
+    let rb_dict = rb::value_to_option_bytes(rb_dict)?;
     let id = rb::value_to_u32(id)?;
     let level = rb::value_to_i32(level)?;
-    let (dict_len, dict_id, dict, cctx, dctx) = match rb_dict {
+    let (dict_len, dict_id, cctx, dctx) = match rb_dict {
         None => {
             let cctx = CompressContext::new(level).map_err(|e| {
                 RubyErr::new(
@@ -399,7 +318,7 @@ fn frame_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -
                     format!("CompressContext::new failed: {e}"),
                 )
             })?;
-            (0, None, None, cctx, DecompressContext::new())
+            (0, None, cctx, DecompressContext::new())
         }
         Some(bytes) => {
             let dict = load_dict(&bytes)?;
@@ -411,36 +330,42 @@ fn frame_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -
                 )
             })?;
             let dctx = DecompressContext::with_dict(dict.clone());
-            (dl, Some(id), Some(dict), cctx, dctx)
+            (dl, Some(id), cctx, dctx)
         }
     };
 
-    unsafe {
+    let codec = unsafe {
         rb::wrap_typed_data(
             class,
             Box::new(FrameCodec {
                 dict_len,
                 dict_id,
-                dict,
                 level,
                 cctx: Mutex::new(cctx),
                 dctx: Mutex::new(dctx),
             }),
             frame_codec_data_type(),
-        )
-    }
+        )?
+    };
+    rb::make_shareable(codec)?;
+    Ok(codec)
 }
 
 fn frame_codec_compress_impl(rb_self: VALUE, rb_input: VALUE) -> RbResult<VALUE> {
     let rb_self = unsafe { frame_codec_ref(rb_self)? };
     let mut input = rb::input_bytes(rb_input)?;
     let release_gvl = should_release_compress_gvl(input.len());
-    input.lock_for_without_gvl(release_gvl)?;
-    let out = with_mutex(&rb_self.cctx, release_gvl, "FrameCodec CCtx", |cctx| {
-        cctx.compress(input.as_slice())
-            .map(|out| out.into_owned())
-            .map_err(|e| RubyErr::new(compress_error(), format!("zstd compress failed: {e}")))
-    })?;
+    let out = with_mutex(
+        &rb_self.cctx,
+        release_gvl,
+        "FrameCodec CCtx",
+        &mut input,
+        |cctx, input| {
+            cctx.compress(input)
+                .map(|out| out.into_owned())
+                .map_err(|e| RubyErr::new(compress_error(), format!("zstd compress failed: {e}")))
+        },
+    )?;
     rb::new_binary_string(&out)
 }
 
@@ -450,18 +375,22 @@ fn frame_codec_decompress_impl(
     max_output: VALUE,
 ) -> RbResult<VALUE> {
     let rb_self = unsafe { frame_codec_ref(rb_self)? };
-    let mut compressed = rb::input_bytes(rb_input)?;
     let max_output = rb::value_to_usize(max_output)?;
+    let mut compressed = rb::input_bytes(rb_input)?;
     let release_gvl = should_release_frame_decompress_gvl(decompress_work_size(
         compressed.as_slice(),
         max_output,
     ));
-    compressed.lock_for_without_gvl(release_gvl)?;
-    let dict = rb_self.dict.clone();
-    let out = with_mutex(&rb_self.dctx, release_gvl, "FrameCodec DCtx", |dctx| {
-        decompress_bounded(compressed.as_slice(), max_output, dctx, dict.as_ref())
-            .map_err(|e| bounded_err(e, "zstd frame decode failed"))
-    })?;
+    let out = with_mutex(
+        &rb_self.dctx,
+        release_gvl,
+        "FrameCodec DCtx",
+        &mut compressed,
+        |dctx, compressed| {
+            decompress_bounded(compressed, max_output, dctx)
+                .map_err(|e| bounded_err(e, "zstd frame decode failed"))
+        },
+    )?;
     rb::new_binary_string(&out)
 }
 
@@ -543,7 +472,6 @@ unsafe extern "C" fn frame_codec_get_frame_content_size(_class: VALUE, rb_input:
 struct BlockCodec {
     dict_len: usize,
     dict_id: Option<u32>,
-    dict: Option<Dictionary>,
     level: i32,
     cctx: Mutex<CompressContext>,
     dctx: Mutex<DecompressContext>,
@@ -553,7 +481,7 @@ fn block_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -
     let rb_dict = rb::value_to_option_bytes(rb_dict)?;
     let id = rb::value_to_u32(id)?;
     let level = rb::value_to_i32(level)?;
-    let (dict_len, dict_id, dict, cctx, dctx) = match rb_dict {
+    let (dict_len, dict_id, cctx, dctx) = match rb_dict {
         None => {
             let cctx = CompressContext::new(level).map_err(|e| {
                 RubyErr::new(
@@ -561,7 +489,7 @@ fn block_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -
                     format!("CompressContext::new failed: {e}"),
                 )
             })?;
-            (0, None, None, cctx, DecompressContext::new())
+            (0, None, cctx, DecompressContext::new())
         }
         Some(bytes) => {
             let dict = load_dict(&bytes)?;
@@ -573,7 +501,7 @@ fn block_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -
                 )
             })?;
             let dctx = DecompressContext::with_dict(dict.clone());
-            (dl, Some(id), Some(dict), cctx, dctx)
+            (dl, Some(id), cctx, dctx)
         }
     };
 
@@ -583,7 +511,6 @@ fn block_codec_new_impl(class: VALUE, rb_dict: VALUE, id: VALUE, level: VALUE) -
             Box::new(BlockCodec {
                 dict_len,
                 dict_id,
-                dict,
                 level,
                 cctx: Mutex::new(cctx),
                 dctx: Mutex::new(dctx),
@@ -597,12 +524,17 @@ fn block_codec_compress_impl(rb_self: VALUE, rb_input: VALUE) -> RbResult<VALUE>
     let rb_self = unsafe { block_codec_ref(rb_self)? };
     let mut input = rb::input_bytes(rb_input)?;
     let release_gvl = should_release_compress_gvl(input.len());
-    input.lock_for_without_gvl(release_gvl)?;
-    let out = with_mutex(&rb_self.cctx, release_gvl, "BlockCodec CCtx", |cctx| {
-        cctx.compress(input.as_slice())
-            .map(|out| out.into_owned())
-            .map_err(|e| RubyErr::new(compress_error(), format!("zstd compress failed: {e}")))
-    })?;
+    let out = with_mutex(
+        &rb_self.cctx,
+        release_gvl,
+        "BlockCodec CCtx",
+        &mut input,
+        |cctx, input| {
+            cctx.compress(input)
+                .map(|out| out.into_owned())
+                .map_err(|e| RubyErr::new(compress_error(), format!("zstd compress failed: {e}")))
+        },
+    )?;
     rb::new_binary_string(&out)
 }
 
@@ -612,17 +544,18 @@ fn block_codec_decompress_impl(
     max_output: VALUE,
 ) -> RbResult<VALUE> {
     let rb_self = unsafe { block_codec_ref(rb_self)? };
-    let compressed = rb::input_bytes(rb_input)?;
     let max_output = rb::value_to_usize(max_output)?;
-    let out = with_mutex(&rb_self.dctx, false, "BlockCodec DCtx", |dctx| {
-        decompress_bounded(
-            compressed.as_slice(),
-            max_output,
-            dctx,
-            rb_self.dict.as_ref(),
-        )
-        .map_err(|e| bounded_err(e, "zstd block decode failed"))
-    })?;
+    let mut compressed = rb::input_bytes(rb_input)?;
+    let out = with_mutex(
+        &rb_self.dctx,
+        false,
+        "BlockCodec DCtx",
+        &mut compressed,
+        |dctx, compressed| {
+            decompress_bounded(compressed, max_output, dctx)
+                .map_err(|e| bounded_err(e, "zstd block decode failed"))
+        },
+    )?;
     rb::new_binary_string(&out)
 }
 
@@ -704,6 +637,7 @@ fn dict_trainer_new_impl(class: VALUE, max_dict_size: VALUE) -> RbResult<VALUE>
 }
 
 fn dict_trainer_add_sample_impl(rb_self: VALUE, rb_data: VALUE) -> RbResult<VALUE> {
+    let data = rb::value_to_bytes(rb_data)?;
     let rb_self = unsafe { dict_trainer_ref(rb_self)? };
     let mut borrow = rb_self
         .inner
@@ -712,7 +646,6 @@ fn dict_trainer_add_sample_impl(rb_self: VALUE, rb_data: VALUE) -> RbResult<VALU
     let state = borrow
         .as_mut()
         .ok_or_else(|| RubyErr::runtime("DictTrainer already consumed by #train"))?;
-    let data = rb::value_to_bytes(rb_data)?;
     if data.len() < 4 {
         return Ok(rb::qnil());
     }
@@ -960,11 +893,11 @@ mod tests {
         compressed.extend_from_slice(&zstd::compress(&[b'b'; 100], 1).unwrap());
 
         assert!(matches!(
-            decompress_bounded(&compressed, 199, &mut dctx, None),
+            decompress_bounded(&compressed, 199, &mut dctx),
             Err(BoundedError::OutputSizeLimit { .. })
         ));
         assert_eq!(
-            decompress_bounded(&compressed, 200, &mut dctx, None)
+            decompress_bounded(&compressed, 200, &mut dctx)
                 .unwrap()
                 .len(),
             200

data/ext/zrip/src/rb.rs

@@ -1,6 +1,4 @@
 use std::ffi::{c_char, c_long, c_void, CStr, CString};
-#[cfg(ruby_engine = "mri")]
-use std::mem::MaybeUninit;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::ptr;
 
@@ -32,7 +30,7 @@ unsafe extern "C" {
 
 #[derive(Debug)]
 pub enum RubyErr {
-    Exception(VALUE),
+    Jump(i32),
     Error { class: VALUE, message: String },
 }
 
@@ -55,15 +53,6 @@ impl RubyErr {
     pub fn type_error(message: impl Into<String>) -> Self {
         Self::new(unsafe { rb_sys::rb_eTypeError }, message)
     }
-
-    fn current_exception() -> Self {
-        let err = unsafe { rb_sys::rb_errinfo() };
-        if err == qnil() {
-            Self::runtime("Ruby exception")
-        } else {
-            Self::Exception(err)
-        }
-    }
 }
 
 pub fn wrap<F>(f: F) -> VALUE
@@ -89,12 +78,15 @@ where
 }
 
 pub fn raise(err: RubyErr) -> ! {
-    let exc = match err {
-        RubyErr::Exception(exc) => exc,
-        RubyErr::Error { class, message } => error_exception(class, message),
-    };
-
-    unsafe { rb_sys::rb_exc_raise(exc) }
+    match err {
+        // Preserve Ruby's tag and pending error info for Thread#kill and
+        // catch/throw, as well as ordinary exceptions.
+        RubyErr::Jump(state) => unsafe { rb_sys::rb_jump_tag(state) },
+        RubyErr::Error { class, message } => {
+            let exc = error_exception(class, message);
+            unsafe { rb_sys::rb_exc_raise(exc) }
+        }
+    }
 }
 
 fn error_exception(class: VALUE, message: String) -> VALUE {
@@ -145,7 +137,7 @@ where
     };
 
     if state != 0 {
-        Err(RubyErr::current_exception())
+        Err(RubyErr::Jump(state))
     } else if data.panicked {
         Err(RubyErr::runtime("native Rust panic"))
     } else {
@@ -167,7 +159,7 @@ where
 #[cfg(ruby_engine = "mri")]
 struct WithoutGvlData<F, R> {
     func: Option<F>,
-    output: MaybeUninit<R>,
+    output: Option<std::thread::Result<R>>,
 }
 
 #[cfg(ruby_engine = "mri")]
@@ -176,49 +168,55 @@ where
     F: FnOnce() -> R,
 {
     let data = unsafe { &mut *(data.cast::<WithoutGvlData<F, R>>()) };
-    let func = data.func.take().expect("missing without-GVL function");
-    data.output.write(func());
+    // Rust panics must be caught before returning through the C callback.
+    data.output = Some(catch_unwind(AssertUnwindSafe(|| {
+        data.func.take().expect("missing without-GVL function")()
+    })));
     ptr::null_mut()
 }
 
 #[cfg(ruby_engine = "mri")]
-fn without_gvl<F, R>(func: F) -> R
+fn without_gvl<F, R>(func: F) -> RbResult<R>
 where
     F: FnOnce() -> R,
 {
     let mut data = WithoutGvlData {
         func: Some(func),
-        output: MaybeUninit::uninit(),
+        output: None,
     };
-    unsafe {
+    // Ruby checks interrupts before and after the callback. Protect the call
+    // so an exception still drops native output and unlocks borrowed strings.
+    protect_unit(|| unsafe {
         rb_thread_call_without_gvl(
             Some(without_gvl_trampoline::<F, R>),
             (&mut data as *mut WithoutGvlData<F, R>).cast::<c_void>(),
             None,
             ptr::null_mut(),
         );
-        data.output.assume_init()
-    }
+    })?;
+    data.output
+        .ok_or_else(|| RubyErr::runtime("without-GVL callback did not run"))?
+        .map_err(|_| RubyErr::runtime("native Rust panic"))
 }
 
 #[cfg(ruby_engine = "mri")]
-pub fn maybe_without_gvl<F, R>(release_gvl: bool, func: F) -> R
+pub fn maybe_without_gvl<F, R>(release_gvl: bool, func: F) -> RbResult<R>
 where
     F: FnOnce() -> R,
 {
     if release_gvl {
         without_gvl(func)
     } else {
-        func()
+        Ok(func())
     }
 }
 
 #[cfg(not(ruby_engine = "mri"))]
-pub fn maybe_without_gvl<F, R>(_release_gvl: bool, func: F) -> R
+pub fn maybe_without_gvl<F, R>(_release_gvl: bool, func: F) -> RbResult<R>
 where
     F: FnOnce() -> R,
 {
-    func()
+    Ok(func())
 }
 
 pub const fn qnil() -> VALUE {
@@ -255,8 +253,23 @@ pub fn string_value(value: VALUE) -> RbResult<VALUE> {
     protect_value(|| unsafe { rb_sys::rb_str_to_str(value) })
 }
 
-pub fn freeze_value(value: VALUE) -> RbResult<()> {
-    protect_unit(|| unsafe { rb_sys::RB_OBJ_FREEZE(value) })
+pub fn frozen_shareable_flags() -> VALUE {
+    #[cfg(ruby_engine = "mri")]
+    {
+        // RUBY_TYPED_FROZEN_SHAREABLE equals RUBY_FL_SHAREABLE in Ruby headers.
+        1 | rb_sys::ruby_fl_type::RUBY_FL_SHAREABLE as VALUE
+    }
+    #[cfg(not(ruby_engine = "mri"))]
+    {
+        1
+    }
+}
+
+pub fn make_shareable(value: VALUE) -> RbResult<()> {
+    protect_unit(|| unsafe { rb_sys::RB_OBJ_FREEZE(value) })?;
+    #[cfg(ruby_engine = "mri")]
+    protect_value(|| unsafe { rb_sys::rb_ractor_make_shareable(value) })?;
+    Ok(())
 }
 
 pub fn value_to_bytes(value: VALUE) -> RbResult<Vec<u8>> {
@@ -613,3 +626,42 @@ unsafe fn transmute_3(
 fn c_long_len(len: usize) -> RbResult<c_long> {
     c_long::try_from(len).map_err(|_| RubyErr::arg("length too large"))
 }
+
+#[cfg(all(test, ruby_engine = "mri"))]
+mod tests {
+    use super::*;
+
+    fn run_callback<F, R>(func: F) -> std::thread::Result<R>
+    where
+        F: FnOnce() -> R,
+    {
+        let mut data = WithoutGvlData {
+            func: Some(func),
+            output: None,
+        };
+        unsafe {
+            without_gvl_trampoline::<F, R>(
+                (&mut data as *mut WithoutGvlData<F, R>).cast::<c_void>(),
+            );
+        }
+        data.output.unwrap()
+    }
+
+    #[test]
+    fn callback_catches_panics_before_returning_to_c() {
+        let dropped = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+        struct OnDrop(std::sync::Arc<std::sync::atomic::AtomicBool>);
+        impl Drop for OnDrop {
+            fn drop(&mut self) {
+                self.0.store(true, std::sync::atomic::Ordering::SeqCst);
+            }
+        }
+        let captured = OnDrop(dropped.clone());
+        let result = run_callback(move || {
+            let _captured = captured;
+            panic!("callback panic");
+        });
+        assert!(result.is_err());
+        assert!(dropped.load(std::sync::atomic::Ordering::SeqCst));
+    }
+}

data/lib/zrip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zrip
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zrip
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Patrik Wenger
@@ -16,6 +16,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -23,6 +26,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.130
 description: Ruby bindings (via Rust/rb-sys) for zrip, a pure-Rust Zstandard implementation.
   Frame-format and block-format compress/decompress with optional dictionary support,
   configurable compression levels, and FastCOVER-based dictionary training. Ractor-safe.
@@ -54,7 +60,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/paddor/zrip-rb
-  source_code_uri: https://github.com/paddor/zrip-rb
+  source_code_uri: https://github.com/paddor/zrip-rb/tree/main
   documentation_uri: https://rubydoc.info/gems/zrip
   changelog_uri: https://github.com/paddor/zrip-rb/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
@@ -72,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ractor-safe Zstandard bindings for Ruby (pure-Rust zrip backend)
 test_files: []