feat(compress): move CCtx custom memory copy into Rust

Replace the remaining CCtx-copy custom-memory callback with explicit source and
destination pointers. Rust now copies the ABI-checked ZSTD_customMem payload in
its original position before reset, while C retains private context access and
the surrounding workspace and table operations.

Test Plan:
- ulimit -v 41943040 cargo fmt --manifest-path rust/Cargo.toml -- --check
- ulimit -v 41943040 CARGO_BUILD_JOBS=1 cargo clippy --manifest-path rust/Cargo.toml --all-targets -- -D warnings
- ulimit -v 41943040 CARGO_BUILD_JOBS=1 cargo test --manifest-path rust/Cargo.toml
- ulimit -v 41943040 make -j1
- ulimit -v 41943040 make -j1 -C tests test-zstream ZSTREAM_TESTTIME=-T2s
- ulimit -v 41943040 make -j1 -C tests test-fuzzer FUZZERTEST=-T3s FUZZER_FLAGS=--no-big-tests

lib/compress/zstd_compress.c

@@ -459,8 +459,6 @@ typedef char ZSTD_rust_reset_cctx_state_layout[
         ? 1 : -1];
 typedef size_t (*ZSTD_rust_copyCCtxCheckStage_f)(
         void* context, const void* srcCCtx);
-typedef void (*ZSTD_rust_copyCCtxCopyState_f)(
-        void* context, const void* srcCCtx);
 typedef size_t (*ZSTD_rust_copyCCtxReset_f)(
         void* context, const void* srcCCtx,
         const ZSTD_frameParameters* fParams,
@@ -474,7 +472,8 @@ typedef struct {
     const ZSTD_frameParameters* fParams;
     U64 pledgedSrcSize;
     ZSTD_rust_copyCCtxCheckStage_f checkStage;
-    ZSTD_rust_copyCCtxCopyState_f copyCustomMem;
+    void* destinationCustomMem;
+    const void* sourceCustomMem;
     ZSTD_rust_copyCCtxReset_f reset;
     ZSTD_rust_copyCCtxMarkTables_f markTablesDirty;
     ZSTD_rust_copyCCtxCopyTables_f copyTables;
@@ -536,7 +535,7 @@ typedef char ZSTD_rust_copy_cctx_internal_state_layout[
                 == 3 * sizeof(void*) + sizeof(U64)
          && offsetof(ZSTD_rust_copyCCtxInternalState, zbuff)
                 == 3 * sizeof(void*) + sizeof(U64)
-                 + 18 * sizeof(void*)
+                 + 19 * sizeof(void*)
          && sizeof(ZSTD_rust_copyCCtxInternalState)
                 == ((offsetof(ZSTD_rust_copyCCtxInternalState, zbuff)
                      + sizeof(int) + sizeof(void*) - 1) / sizeof(void*))
@@ -4756,14 +4755,6 @@ static size_t ZSTD_rust_copyCCtx_check_stage(
     return 0;
 }
 
-static void ZSTD_rust_copyCCtx_copy_custom_mem(
-        void* context, const void* srcCCtx)
-{
-    ZSTD_CCtx* const dst = (ZSTD_CCtx*)context;
-    const ZSTD_CCtx* const src = (const ZSTD_CCtx*)srcCCtx;
-    ZSTD_memcpy(&dst->customMem, &src->customMem, sizeof(ZSTD_customMem));
-}
-
 static size_t ZSTD_rust_copyCCtx_reset(
         void* context, const void* srcCCtx,
         const ZSTD_frameParameters* fParams,
@@ -4846,7 +4837,10 @@ static size_t ZSTD_rust_copyCCtx_internal_callback(
     state.fParams = fParams;
     state.pledgedSrcSize = pledgedSrcSize;
     state.checkStage = ZSTD_rust_copyCCtx_check_stage;
-    state.copyCustomMem = ZSTD_rust_copyCCtx_copy_custom_mem;
+    state.destinationCustomMem =
+            &((ZSTD_CCtx*)context)->customMem;
+    state.sourceCustomMem =
+            &((const ZSTD_CCtx*)srcCCtx)->customMem;
     state.reset = ZSTD_rust_copyCCtx_reset;
     state.markTablesDirty = ZSTD_rust_copyCCtx_mark_tables_dirty;
     state.copyTables = ZSTD_rust_copyCCtx_copy_tables;

rust/src/zstd_compress.rs

@@ -32,7 +32,7 @@ use crate::zstd_compress_params::{
     ZSTD_RUST_CPM_NO_ATTACH_DICT, ZSTD_RUST_PS_AUTO, ZSTD_RUST_PS_DISABLE, ZSTD_RUST_PS_ENABLE,
 };
 use crate::zstd_compress_params_api::{
-    ZSTD_CCtxParams_setParameter, ZSTD_CCtx_params, ZSTD_rust_isUpdateAuthorized,
+    ZSTD_CCtxParams_setParameter, ZSTD_CCtx_params, ZSTD_customMem, ZSTD_rust_isUpdateAuthorized,
 };
 use crate::zstd_compress_sequences::SeqDef;
 use crate::zstd_compress_stats::{
@@ -1673,7 +1673,6 @@ pub unsafe extern "C" fn ZSTD_rust_copyCCtx(state: *const ZSTD_rust_copyCCtxStat
 }
 
 type CopyCCtxCheckStageFn = unsafe extern "C" fn(*mut c_void, *const c_void) -> usize;
-type CopyCCtxCopyStateFn = unsafe extern "C" fn(*mut c_void, *const c_void);
 type CopyCCtxResetFn = unsafe extern "C" fn(
     *mut c_void,
     *const c_void,
@@ -1715,6 +1714,10 @@ const _: () = {
     );
 };
 
+const _: () = {
+    assert!(size_of::<ZSTD_customMem>() == 3 * size_of::<usize>());
+};
+
 /// Projection for the private `ZSTD_copyCCtx_internal` operation.
 ///
 /// Rust owns the stage/error branch and the order of the reset, workspace,
@@ -1727,7 +1730,8 @@ pub struct ZSTD_rust_copyCCtxInternalState {
     f_params: *const ZSTD_frameParameters,
     pledged_src_size: u64,
     check_stage: Option<CopyCCtxCheckStageFn>,
-    copy_custom_mem: Option<CopyCCtxCopyStateFn>,
+    destination_custom_mem: *mut c_void,
+    source_custom_mem: *const c_void,
     reset: Option<CopyCCtxResetFn>,
     mark_tables_dirty: Option<CopyCCtxMarkTablesFn>,
     copy_tables: Option<CopyCCtxCopyTablesFn>,
@@ -1749,7 +1753,6 @@ pub struct ZSTD_rust_copyCCtxInternalState {
 
 const _: () = {
     assert!(size_of::<CopyCCtxCheckStageFn>() == size_of::<usize>());
-    assert!(size_of::<CopyCCtxCopyStateFn>() == size_of::<usize>());
     assert!(size_of::<CopyCCtxResetFn>() == size_of::<usize>());
     assert!(size_of::<CopyCCtxMarkTablesFn>() == size_of::<usize>());
     assert!(size_of::<CopyCCtxCopyTablesFn>() == size_of::<usize>());
@@ -1765,7 +1768,7 @@ const _: () = {
     );
     assert!(
         offset_of!(ZSTD_rust_copyCCtxInternalState, zbuff)
-            == 3 * size_of::<usize>() + size_of::<u64>() + 18 * size_of::<usize>()
+            == 3 * size_of::<usize>() + size_of::<u64>() + 19 * size_of::<usize>()
     );
     assert!(
         size_of::<ZSTD_rust_copyCCtxInternalState>()
@@ -1787,14 +1790,12 @@ pub unsafe extern "C" fn ZSTD_rust_copyCCtxInternal(
     let state = unsafe { &*state };
     let (
         Some(check_stage),
-        Some(copy_custom_mem),
         Some(reset),
         Some(mark_tables_dirty),
         Some(copy_tables),
         Some(mark_tables_clean),
     ) = (
         state.check_stage,
-        state.copy_custom_mem,
         state.reset,
         state.mark_tables_dirty,
         state.copy_tables,
@@ -1806,6 +1807,8 @@ pub unsafe extern "C" fn ZSTD_rust_copyCCtxInternal(
     if state.callback_context.is_null()
         || state.src_cctx.is_null()
         || state.f_params.is_null()
+        || state.destination_custom_mem.is_null()
+        || state.source_custom_mem.is_null()
         || state.destination_window.is_null()
         || state.source_window.is_null()
         || state.destination_next_to_update.is_null()
@@ -1828,7 +1831,11 @@ pub unsafe extern "C" fn ZSTD_rust_copyCCtxInternal(
     }
 
     unsafe {
-        copy_custom_mem(state.callback_context, state.src_cctx);
+        ptr::copy(
+            state.source_custom_mem.cast::<ZSTD_customMem>(),
+            state.destination_custom_mem.cast::<ZSTD_customMem>(),
+            1,
+        );
         let reset_error = reset(
             state.callback_context,
             state.src_cctx,
@@ -13915,15 +13922,6 @@ mod tests {
         context.stage_result
     }
 
-    unsafe extern "C" fn copy_cctx_internal_test_copy_state(
-        context: *mut c_void,
-        _src_cctx: *const c_void,
-    ) {
-        unsafe { copy_cctx_internal_test_context(context) }
-            .events
-            .push("custom");
-    }
-
     unsafe extern "C" fn copy_cctx_internal_test_reset(
         context: *mut c_void,
         _src_cctx: *const c_void,
@@ -13963,6 +13961,8 @@ mod tests {
         context: &mut CopyCCtxInternalTestContext,
         src_cctx: *const c_void,
         f_params: &ZSTD_frameParameters,
+        destination_custom_mem: *mut c_void,
+        source_custom_mem: *const c_void,
         destination_window: *mut c_void,
         source_window: *const c_void,
         destination_next_to_update: *mut c_uint,
@@ -13982,7 +13982,8 @@ mod tests {
             f_params,
             pledged_src_size: 123,
             check_stage: Some(copy_cctx_internal_test_check_stage),
-            copy_custom_mem: Some(copy_cctx_internal_test_copy_state),
+            destination_custom_mem,
+            source_custom_mem,
             reset: Some(copy_cctx_internal_test_reset),
             mark_tables_dirty: Some(copy_cctx_internal_test_mark_tables_dirty),
             copy_tables: Some(copy_cctx_internal_test_copy_tables),
@@ -14011,6 +14012,8 @@ mod tests {
             checksumFlag: 1,
             noDictIDFlag: 1,
         };
+        let source_custom_mem = [0x11usize, 0x22, 0x33];
+        let mut destination_custom_mem = [0usize; 3];
         let mut source_block_state =
             unsafe { MaybeUninit::<ZSTD_compressedBlockState_t>::zeroed().assume_init() };
         source_block_state.rep = [15, 16, 17];
@@ -14048,6 +14051,8 @@ mod tests {
             &mut context,
             0x5000usize as *const c_void,
             &f_params,
+            (&mut destination_custom_mem as *mut [usize; 3]).cast(),
+            (&source_custom_mem as *const [usize; 3]).cast(),
             (&mut destination_window as *mut ZSTD_rust_copyWindowState).cast(),
             (&source_window as *const ZSTD_rust_copyWindowState).cast(),
             &mut destination_next_to_update,
@@ -14067,11 +14072,12 @@ mod tests {
         assert_eq!(result, 0);
         assert_eq!(
             context.events,
-            ["check", "custom", "reset", "dirty", "tables", "clean"]
+            ["check", "reset", "dirty", "tables", "clean"]
         );
         assert_eq!(context.frame_params, f_params);
         assert_eq!(context.pledged_src_size, 123);
         assert_eq!(context.zbuff, 7);
+        assert_eq!(destination_custom_mem, source_custom_mem);
         assert_eq!(destination_window, source_window);
         assert_eq!(destination_next_to_update, source_next_to_update);
         assert_eq!(destination_loaded_dict_end, source_loaded_dict_end);
@@ -14095,6 +14101,8 @@ mod tests {
             ..CopyCCtxInternalTestContext::default()
         };
         let f_params = ZSTD_frameParameters::default();
+        let source_custom_mem = [0usize; 3];
+        let mut destination_custom_mem = [0usize; 3];
         let mut destination_block_state =
             unsafe { MaybeUninit::<ZSTD_compressedBlockState_t>::zeroed().assume_init() };
         let mut destination_block_state_slot =
@@ -14109,6 +14117,8 @@ mod tests {
             &mut context,
             0x5000usize as *const c_void,
             &f_params,
+            (&mut destination_custom_mem as *mut [usize; 3]).cast(),
+            (&source_custom_mem as *const [usize; 3]).cast(),
             ptr::dangling_mut(),
             ptr::dangling(),
             ptr::dangling_mut(),
@@ -14136,6 +14146,8 @@ mod tests {
             ..CopyCCtxInternalTestContext::default()
         };
         let f_params = ZSTD_frameParameters::default();
+        let source_custom_mem = [0usize; 3];
+        let mut destination_custom_mem = [0usize; 3];
         let mut destination_block_state =
             unsafe { MaybeUninit::<ZSTD_compressedBlockState_t>::zeroed().assume_init() };
         let mut destination_block_state_slot =
@@ -14150,6 +14162,8 @@ mod tests {
             &mut context,
             0x5000usize as *const c_void,
             &f_params,
+            (&mut destination_custom_mem as *mut [usize; 3]).cast(),
+            (&source_custom_mem as *const [usize; 3]).cast(),
             ptr::dangling_mut(),
             ptr::dangling(),
             ptr::dangling_mut(),
@@ -14167,7 +14181,7 @@ mod tests {
         let result = unsafe { ZSTD_rust_copyCCtxInternal(&state) };
 
         assert_eq!(result, ERROR(ZstdErrorCode::MemoryAllocation));
-        assert_eq!(context.events, ["check", "custom", "reset"]);
+        assert_eq!(context.events, ["check", "reset"]);
     }
 
     #[derive(Default)]