moto-runtime 0.2.6

Motor OS Runtime.
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

use crate::mutex::Mutex;
use alloc::borrow::ToOwned;
use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use moto_sys::syscalls::*;
use moto_sys::ErrorCode;

pub(super) unsafe fn create_remote_env(
    address_space: SysHandle,
    env: Vec<(String, String)>,
) -> Result<u64, ErrorCode> {
    let mut flat_vec = Vec::new();
    for (k, v) in env {
        if k.is_empty() {
            continue;
        }
        flat_vec.push(k);
        flat_vec.push(v);
    }

    super::args::create_remote_args(address_space, &Vec::new(), &flat_vec, false)
}

struct EnvRt {
    pointer: *mut BTreeMap<String, String>,
}

unsafe impl Send for EnvRt {}
unsafe impl Sync for EnvRt {}

impl EnvRt {
    const fn new() -> Self {
        Self {
            pointer: core::ptr::null_mut(),
        }
    }

    fn get_all() -> Vec<(String, String)> {
        Self::ensure_init();

        let env = ENV.lock();
        let map = unsafe { env.pointer.as_ref().unwrap_unchecked() };

        let mut result = alloc::vec![];

        for (k, v) in map.iter() {
            result.push((k.clone(), v.clone()))
        }

        result
    }

    fn get(key: &str) -> Option<String> {
        Self::ensure_init();

        let env = ENV.lock();
        let map = unsafe { env.pointer.as_ref().unwrap_unchecked() };
        map.get(key).map(|s| s.clone())
    }

    fn set(key: &str, val: &str) {
        Self::ensure_init();

        let env = ENV.lock();
        let map = unsafe { env.pointer.as_mut().unwrap_unchecked() };
        map.insert(key.to_owned(), val.to_owned());
    }

    fn unset(key: &str) {
        Self::ensure_init();

        let env = ENV.lock();
        let map = unsafe { env.pointer.as_mut().unwrap_unchecked() };
        map.remove(key);
    }

    fn ensure_init() {
        let mut env = ENV.lock();

        if !env.pointer.is_null() {
            return;
        }

        use alloc::boxed::Box;

        env.pointer = Box::leak(Box::new(BTreeMap::new()));
        unsafe {
            let map = env.pointer.as_mut().unwrap_unchecked();
            match crate::rt_api::process::ProcessData::get() {
                Some(pd) => {
                    for (k, v) in pd.env().into_iter() {
                        map.insert(
                            core::str::from_utf8(k).unwrap().to_owned(),
                            core::str::from_utf8(v).unwrap().to_owned(),
                        );
                    }
                }
                None => {}
            }
        }
    }
}

static ENV: Mutex<EnvRt> = Mutex::new(EnvRt::new());

pub fn env() -> alloc::vec::Vec<(String, String)> {
    EnvRt::get_all()
}

pub fn getenv(key: &str) -> Option<String> {
    EnvRt::get(key)
}

pub fn setenv(key: &str, val: &str) {
    EnvRt::set(key, val);
}

pub fn unsetenv(key: &str) {
    EnvRt::unset(key)
}