rust-libutee 0.1.0

Rust library for UTEE-related functionality.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// SPDX-License-Identifier: Apache-2.0
// Copyright (C) 2025 KylinSoft Co., Ltd. <https://www.kylinos.cn/>
// See LICENSES for license details.
//
// This file has been modified by KylinSoft on 2025.

use std::{
    alloc::{Layout, alloc, alloc_zeroed, realloc},
    ffi::c_void,
    ptr,
    sync::atomic::{AtomicPtr, Ordering},
};

use crate::{
    api::tee_api_panic::TEE_Panic,
    tee_api_defines::{TEE_MALLOC_FILL_ZERO, TEE_MALLOC_NO_FILL, TEE_MALLOC_NO_SHARE, TEE_SUCCESS},
    tee_api_types::TEE_Result,
};

static TEE_API_INSTANCE_DATA: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());

/*
 * return a known non-NULL invalid pointer when the
 * requested size is zeros
 */
pub const TEE_NULL_SIZED_VA: *mut c_void = 1 as *mut c_void;
pub const TEE_NULL_SIZED_NO_SHARE_VA: *mut c_void = 2 as *mut c_void;

/* Hint implementation defines */
pub const TEE_USER_MEM_HINT_NO_FILL_ZERO: u32 = 0x80000000;

#[unsafe(no_mangle)]
pub extern "C" fn TEE_CheckMemoryAccessRights(
    _accessFlags: u32,
    _buffer: *mut c_void,
    _size: usize,
) -> TEE_Result {
    TEE_SUCCESS
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_SetInstanceData(instanceData: *const c_void) {
    TEE_API_INSTANCE_DATA.store(instanceData as _, Ordering::Release);
}
#[unsafe(no_mangle)]
pub extern "C" fn TEE_GetInstanceData() -> *const c_void {
    TEE_API_INSTANCE_DATA.load(Ordering::Acquire)
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_Malloc(size: usize, hint: u32) -> *mut c_void {
    let layout = match Layout::from_size_align(size, std::mem::align_of::<u8>()) {
        Ok(layout) => layout,
        Err(_) => return ptr::null_mut(),
    };

    match hint {
        TEE_MALLOC_FILL_ZERO => {
            if size == 0 {
                return TEE_NULL_SIZED_VA;
            }
            unsafe { alloc_zeroed(layout) as _ }
        }
        TEE_MALLOC_NO_FILL => {
            TEE_Panic(0);
            ptr::null_mut()
        }
        TEE_MALLOC_NO_SHARE => {
            if size == 0 {
                return TEE_NULL_SIZED_NO_SHARE_VA;
            }
            unsafe { alloc_zeroed(layout) as _ }
        }
        hint if hint == TEE_MALLOC_NO_FILL | TEE_MALLOC_NO_SHARE => {
            if size == 0 {
                return TEE_NULL_SIZED_NO_SHARE_VA;
            }
            unsafe { alloc(layout) as _ }
        }
        TEE_USER_MEM_HINT_NO_FILL_ZERO => {
            if size == 0 {
                return TEE_NULL_SIZED_VA;
            }
            unsafe { alloc(layout) as _ }
        }
        _ => {
            eprintln!("Invalid hint: 0x{:x}", hint);
            ptr::null_mut()
        }
    }
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_Realloc(buffer: *mut c_void, newSize: usize) -> *mut c_void {
    let layout = match Layout::from_size_align(newSize, std::mem::align_of::<u8>()) {
        Ok(layout) => layout,
        Err(_) => return ptr::null_mut(),
    };

    if newSize == 0 {
        TEE_Free(buffer);
    }

    unsafe { realloc(buffer as _, layout, newSize) as _ }
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_Free(buffer: *mut c_void) {
    unsafe { libc::free(buffer) }
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_MemMove(dest: *mut c_void, src: *const c_void, size: usize) {
    unsafe { libc::memmove(dest, src, size) };
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_MemCompare(
    _buffer1: *const c_void,
    _buffer2: *const c_void,
    _size: usize,
) -> i32 {
    -1
}

#[unsafe(no_mangle)]
pub extern "C" fn TEE_MemFill(buff: *mut c_void, x: u32, size: usize) {
    unsafe { libc::memset(buff, x as _, size) };
}