Function TEEC_ReleaseSharedMemory 

#[unsafe(no_mangle)]
pub extern "C" fn TEEC_ReleaseSharedMemory(
    shm: *mut TEEC_SharedMemory,
)

TEEC_ReleaseSharedMemory() - 释放或取消注册共享内存。

@param sharedMem 要释放或取消注册的共享内存指针。

Examples found in repository

examples/cc-teec.rs (line 283)

fn memref_whole_input_output(session: &mut Client_Session) -> Result<()> {
    let input_data = vec![1u8, 2, 3, 4, 5, 6, 7, 8];
    let output_size = 8;

    // 分配输入共享内存
    let mut input_shm =
        allocate_shared_memory(session.context_mut(), input_data.len(), raw::TEEC_MEM_INPUT)?;
    copy_to_shm(&input_data, &input_shm);

    // 分配输出共享内存
    let mut output_shm =
        allocate_shared_memory(session.context_mut(), output_size, raw::TEEC_MEM_OUTPUT)?;

    // 创建操作：参数0为INPUT，参数1为OUTPUT
    // SAFETY: `TEEC_Operation` 是 POD 类型，零初始化是有效的。
    let mut op: raw::TEEC_Operation = unsafe { mem::zeroed() };
    op.paramTypes = raw::TEEC_PARAM_TYPES(
        raw::TEEC_MEMREF_WHOLE,
        raw::TEEC_MEMREF_WHOLE,
        raw::TEEC_NONE,
        raw::TEEC_NONE,
    );
    op.params[0].memref.parent = &mut input_shm as *mut _;
    op.params[0].memref.size = input_data.len();
    op.params[1].memref.parent = &mut output_shm as *mut _;
    op.params[1].memref.size = output_size;

    session.invoke_command(Command::MemrefWholeInputOutput.into(), &mut op)?;

    let output_data = read_from_shm(&output_shm, output_size);
    println!("  WHOLE_INPUT+OUTPUT: {:?} → {:?}", input_data, output_data);

    TEEC_ReleaseSharedMemory(&mut input_shm);
    TEEC_ReleaseSharedMemory(&mut output_shm);

    Ok(())
}

// MEMREF WHOLE INOUT 演示（使用 AllocateSharedMemory）
fn memref_whole_inout_allocated(session: &mut Client_Session) -> Result<()> {
    let mut data = vec![1u8, 2, 3, 4, 5, 6, 7, 8];
    let original = data.clone();
    let flags = raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT;
    let mut shm = allocate_shared_memory(session.context_mut(), data.len(), flags)?;

    copy_to_shm(&data, &shm);

    let mut op = create_memref_operation(&mut shm, data.len());

    session.invoke_command(Command::MemrefWholeInout.into(), &mut op)?;

    copy_from_shm(&shm, &mut data);

    println!("  WHOLE_INOUT (Alloc): {:?} → {:?}", original, data);

    TEEC_ReleaseSharedMemory(&mut shm);

    Ok(())
}

// MEMREF WHOLE INOUT 演示（使用 RegisterSharedMemory）
fn memref_whole_inout_registered(session: &mut Client_Session) -> Result<()> {
    let mut data = vec![1u8, 2, 3, 4, 5, 6, 7, 8];
    let original = data.clone();
    let flags = raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT;

    // 注册栈上分配的缓冲区为共享内存
    let mut shm = register_shared_memory(
        session.context_mut(),
        data.as_mut_ptr() as *mut c_void,
        data.len(),
        flags,
    )?;

    let mut op = create_memref_operation(&mut shm, data.len());
    session.invoke_command(Command::MemrefWholeInout.into(), &mut op)?;

    // RegisterSharedMemory 直接操作 CA 的栈内存，TA 修改后数据应自动可见
    // 但通过 vsock-manager 通信时，数据经过序列化/反序列化，需要手动同步
    copy_from_shm(&shm, &mut data);

    println!("  WHOLE_INOUT (Register): {:?} → {:?}", original, data);

    TEEC_ReleaseSharedMemory(&mut shm);

    Ok(())
}

fn memref_whole(session: &mut Client_Session) -> Result<()> {
    println!("\nMEMREF WHOLE 参数类型");
    memref_whole_input_output(session)?;
    memref_whole_inout_allocated(session)?;
    memref_whole_inout_registered(session)?;
    Ok(())
}

fn allocate_shared_memory(
    ctx: &mut raw::TEEC_Context,
    size: usize,
    flags: u32,
) -> Result<raw::TEEC_SharedMemory> {
    // SAFETY: `TEEC_SharedMemory` 是 POD 类型，零初始化是有效的。
    let mut shm: raw::TEEC_SharedMemory = unsafe { mem::zeroed() };
    shm.size = size;
    shm.flags = flags;

    let res = TEEC_AllocateSharedMemory(ctx, &mut shm);
    if res != raw::TEEC_SUCCESS {
        return Err(Error::from_raw_os_error(res as i32));
    }

    Ok(shm)
}

// 注册已有的内存块为共享内存
fn register_shared_memory(
    ctx: &mut raw::TEEC_Context,
    buffer: *mut c_void,
    size: usize,
    flags: u32,
) -> Result<raw::TEEC_SharedMemory> {
    // SAFETY: `TEEC_SharedMemory` 是 POD 类型，零初始化是有效的。
    let mut shm: raw::TEEC_SharedMemory = unsafe { mem::zeroed() };
    shm.buffer = buffer;
    shm.size = size;
    shm.flags = flags;

    let res = TEEC_RegisterSharedMemory(ctx, &mut shm);
    if res != raw::TEEC_SUCCESS {
        return Err(Error::from_raw_os_error(res as i32));
    }

    Ok(shm)
}

// 复制数据到共享内存
fn copy_to_shm(data: &[u8], shm: &raw::TEEC_SharedMemory) {
    // SAFETY:
    // - `data.as_ptr()` 对读取 `data.len()` 字节有效（来自 slice 保证）
    // - `shm.buffer` 对写入有效（由 TEEC_AllocateSharedMemory 分配或注册）
    // - 源和目标不重叠（不同的内存区域）
    unsafe {
        ptr::copy_nonoverlapping(data.as_ptr(), shm.buffer as *mut u8, data.len());
    }
}

// 从共享内存复制数据到缓冲区
fn copy_from_shm(shm: &raw::TEEC_SharedMemory, data: &mut [u8]) {
    // SAFETY:
    // - `shm.buffer` 对读取有效（已分配/注册的共享内存）
    // - `data.as_mut_ptr()` 对写入 `data.len()` 字节有效（来自可变 slice）
    // - 源和目标不重叠
    unsafe {
        ptr::copy_nonoverlapping(shm.buffer as *const u8, data.as_mut_ptr(), data.len());
    }
}

// 从共享内存读取数据
fn read_from_shm(shm: &raw::TEEC_SharedMemory, size: usize) -> Vec<u8> {
    let mut data = vec![0u8; size];
    // SAFETY:
    // - `shm.buffer` 对读取 `size` 字节有效（共享内存保证）
    // - `data.as_mut_ptr()` 对写入有效（新分配的 Vec）
    // - 源和目标不重叠
    unsafe {
        ptr::copy_nonoverlapping(shm.buffer as *const u8, data.as_mut_ptr(), size);
    }
    data
}

// 从共享内存指定偏移量读取数据
fn read_from_shm_offset(shm: &raw::TEEC_SharedMemory, offset: usize, size: usize) -> Vec<u8> {
    let mut data = vec![0u8; size];
    // SAFETY:
    // - `(shm.buffer as *const u8).add(offset)` 在边界内（调用者确保 offset + size <= shm.size）
    // - `data.as_mut_ptr()` 对写入有效（新分配的 Vec）
    // - 源和目标不重叠
    unsafe {
        ptr::copy_nonoverlapping(
            (shm.buffer as *const u8).add(offset),
            data.as_mut_ptr(),
            size,
        );
    }
    data
}

// 复制数据到共享内存指定偏移量
fn copy_to_shm_offset(data: &[u8], shm: &raw::TEEC_SharedMemory, offset: usize) {
    // SAFETY:
    // - `data.as_ptr()` 对读取有效（来自 slice 保证）
    // - `(shm.buffer as *mut u8).add(offset)` 在边界内（调用者确保 offset + data.len() <= shm.size）
    // - 源和目标不重叠
    unsafe {
        ptr::copy_nonoverlapping(
            data.as_ptr(),
            (shm.buffer as *mut u8).add(offset),
            data.len(),
        );
    }
}

// 创建 MEMREF 操作参数
fn create_memref_operation(shm: &mut raw::TEEC_SharedMemory, size: usize) -> raw::TEEC_Operation {
    // SAFETY: `TEEC_Operation` 是 POD 类型，零初始化是有效的。
    let mut op: raw::TEEC_Operation = unsafe { mem::zeroed() };
    op.paramTypes = raw::TEEC_PARAM_TYPES(
        raw::TEEC_MEMREF_WHOLE,
        raw::TEEC_NONE,
        raw::TEEC_NONE,
        raw::TEEC_NONE,
    );
    op.params[0].memref.parent = shm;
    op.params[0].memref.size = size;
    op
}

// MEMREF PARTIAL INPUT + OUTPUT 演示
fn memref_partial_input_output(
    session: &mut Client_Session,
    shm: &mut raw::TEEC_SharedMemory,
    page_size: usize,
) -> Result<()> {
    let input_data = vec![0x10, 0x20, 0x30, 0x40];
    let output_size = 8;
    let input_offset = 0; // 使用共享内存的起始区域
    let output_offset = page_size; // 使用共享内存的第 2 个页（偏移 4096）

    // 将输入数据复制到共享内存的指定偏移位置
    copy_to_shm_offset(&input_data, shm, input_offset);

    // SAFETY: `TEEC_Operation` 是 POD 类型，零初始化是有效的。
    let mut op: raw::TEEC_Operation = unsafe { mem::zeroed() };
    op.paramTypes = raw::TEEC_PARAM_TYPES(
        raw::TEEC_MEMREF_PARTIAL_INPUT,
        raw::TEEC_MEMREF_PARTIAL_OUTPUT,
        raw::TEEC_NONE,
        raw::TEEC_NONE,
    );
    // 参数 0: PARTIAL INPUT
    op.params[0].memref.parent = shm;
    op.params[0].memref.offset = input_offset;
    op.params[0].memref.size = input_data.len();
    // 参数 1: PARTIAL OUTPUT
    op.params[1].memref.parent = shm;
    op.params[1].memref.offset = output_offset;
    op.params[1].memref.size = output_size;

    session.invoke_command(Command::MemrefPartialInputOutput.into(), &mut op)?;

    // 从共享内存的指定偏移位置读取结果
    let output_data = read_from_shm_offset(shm, output_offset, output_size);
    println!(
        "  PARTIAL_INPUT+OUTPUT:\toffset[0]={:?} → offset[{}]={:?}",
        input_data, output_offset, output_data
    );

    Ok(())
}

// MEMREF PARTIAL INOUT 演示
fn memref_partial_inout(
    session: &mut Client_Session,
    shm: &mut raw::TEEC_SharedMemory,
    page_size: usize,
) -> Result<()> {
    let data = vec![0x01, 0x02, 0x03, 0x04];
    let key = 0x55u8;
    let original = data.clone();

    let offset = 2 * page_size; // 使用共享内存的第 3 个页（偏移 8192）

    // 将数据复制到共享内存的指定偏移位置
    copy_to_shm_offset(&data, shm, offset);

    // SAFETY: `TEEC_Operation` 是 POD 类型，零初始化是有效的。
    let mut op: raw::TEEC_Operation = unsafe { mem::zeroed() };

    // 混合参数：VALUE_INPUT + MEMREF_PARTIAL_INOUT
    op.paramTypes = raw::TEEC_PARAM_TYPES(
        raw::TEEC_VALUE_INPUT,
        raw::TEEC_MEMREF_PARTIAL_INOUT,
        raw::TEEC_NONE,
        raw::TEEC_NONE,
    );
    op.params[0].value.a = key as u32;
    // PARTIAL 参数：只引用共享内存的一部分
    op.params[1].memref.parent = shm;
    op.params[1].memref.offset = offset;
    op.params[1].memref.size = data.len();

    session.invoke_command(Command::MemrefPartialInout.into(), &mut op)?;

    // 从共享内存的指定偏移位置读取 XOR 加密后的结果
    let result = read_from_shm_offset(shm, offset, data.len());
    println!(
        "  PARTIAL_INOUT: offset[{}]={:?} ^ 0x{:02X} → {:?}",
        offset, original, key, result
    );

    Ok(())
}

fn memref_partial(session: &mut Client_Session) -> Result<()> {
    println!("\nMEMREF PARTIAL 参数类型");
    // 分配共享内存（需要足够大以支持多个 PARTIAL 引用）
    // 内存布局：
    //   [0 ~ 4095]       : PARTIAL INPUT 使用的区域
    //   [4096 ~ 8191]    : PARTIAL OUTPUT 使用的区域
    //   [8192 ~ 12287]   : PARTIAL INOUT 使用的区域
    //   [12288 ~ 32767]  : 未使用
    let page_size = 4096;
    let shm_size = 8 * page_size; // 32KB
    let mut shm = allocate_shared_memory(
        session.context_mut(),
        shm_size,
        raw::TEEC_MEM_INPUT | raw::TEEC_MEM_OUTPUT,
    )?;

    memref_partial_input_output(session, &mut shm, page_size)?;
    memref_partial_inout(session, &mut shm, page_size)?;

    TEEC_ReleaseSharedMemory(&mut shm);

    Ok(())
}