Apply rustc-0023-Add-Trusty-OS-support-to-Rust-std.patch

Author: randomPoison

library/std/build.rs

@@ -42,6 +42,7 @@ fn main() {
  || target_os == "fuchsia"
  || (target_vendor == "fortanix" && target_env == "sgx")
  || target_os == "hermit"
+ || target_os == ("trusty")
  || target_os == "l4re"
  || target_os == "redox"
  || target_os == "haiku"

library/std/src/sys/alloc/mod.rs

@@ -72,6 +72,7 @@ cfg_if::cfg_if! {
  target_family = "unix",
  target_os = "wasi",
  target_os = "teeos",
+ target_os = "trusty",
 ))]{
 mod unix;
 } else if #[cfg(target_os = "windows")]{

library/std/src/sys/pal/mod.rs

@@ -37,6 +37,9 @@ cfg_if::cfg_if! {
 } else if #[cfg(target_os = "hermit")]{
 mod hermit;
 pubuseself::hermit::*;
+} else if #[cfg(target_os = "trusty")]{
+mod trusty;
+pubuseself::trusty::*;
 } else if #[cfg(all(target_os = "wasi", target_env = "p2"))]{
 mod wasip2;
 pubuseself::wasip2::*;

library/std/src/sys/pal/trusty/mod.rs

@@ -0,0 +1,28 @@
+//! System bindings for the Trusty OS.
+
+#[path = "../unsupported/args.rs"]
+pubmod args;
+#[path = "../unsupported/env.rs"]
+pubmod env;
+#[path = "../unsupported/fs.rs"]
+pubmod fs;
+#[path = "../unsupported/io.rs"]
+pubmod io;
+#[path = "../unsupported/net.rs"]
+pubmod net;
+#[path = "../unsupported/os.rs"]
+pubmod os;
+#[path = "../unsupported/pipe.rs"]
+pubmod pipe;
+#[path = "../unsupported/process.rs"]
+pubmod process;
+pubmod stdio;
+#[path = "../unsupported/time.rs"]
+pubmod time;
+#[path = "../unsupported/thread.rs"]
+pubmod thread;
+#[path = "../unsupported/common.rs"]
+#[deny(unsafe_op_in_unsafe_fn)]
+mod common;
+
+pubuse common::*;

library/std/src/sys/pal/trusty/stdio.rs

@@ -0,0 +1,82 @@
+usecrate::io;
+
+pubstructStdin;
+pubstructStdout;
+pubstructStderr;
+
+implStdin{
+pubconstfnnew() -> Stdin{
+Stdin
+}
+}
+
+impl io::ReadforStdin{
+fnread(&mutself,_buf:&mut[u8]) -> io::Result<usize>{
+Ok(0)
+}
+}
+
+implStdout{
+pubconstfnnew() -> Stdout{
+Stdout
+}
+}
+
+impl io::WriteforStdout{
+fnwrite(&mutself,buf:&[u8]) -> io::Result<usize>{
+_write(libc::STDOUT_FILENO, buf)
+}
+
+fnflush(&mutself) -> io::Result<()>{
+Ok(())
+}
+}
+
+implStderr{
+pubconstfnnew() -> Stderr{
+Stderr
+}
+}
+
+impl io::WriteforStderr{
+fnwrite(&mutself,buf:&[u8]) -> io::Result<usize>{
+_write(libc::STDERR_FILENO, buf)
+}
+
+fnflush(&mutself) -> io::Result<()>{
+Ok(())
+}
+}
+
+pubconstSTDIN_BUF_SIZE:usize = 0;
+
+pubfnis_ebadf(_err:&io::Error) -> bool{
+true
+}
+
+pubfnpanic_output() -> Option<impl io::Write>{
+Some(Stderr)
+}
+
+fn_write(fd:i32,message:&[u8]) -> io::Result<usize>{
+letmut iov =
+ libc::iovec{iov_base: message.as_ptr()as*mut_,iov_len: message.len()};
+loop{
+// SAFETY: syscall, safe arguments.
+let ret = unsafe{ libc::writev(fd,&iov,1)};
+if ret < 0{
+returnErr(io::Error::last_os_error());
+}
+let ret = ret asusize;
+if ret > iov.iov_len{
+returnErr(io::Error::last_os_error());
+}
+if ret == iov.iov_len{
+returnOk(message.len());
+}
+// SAFETY: ret has been checked to be less than the length of
+// the buffer
+ iov.iov_base = unsafe{ iov.iov_base.add(ret)};
+ iov.iov_len -= ret;
+}
+}

library/std/src/sys/random/mod.rs

@@ -60,6 +60,9 @@ cfg_if::cfg_if! {
 } else if #[cfg(target_os = "teeos")]{
 mod teeos;
 pubuse teeos::fill_bytes;
+} else if #[cfg(target_os = "trusty")]{
+mod trusty;
+pubuse trusty::fill_bytes;
 } else if #[cfg(target_os = "uefi")]{
 mod uefi;
 pubuse uefi::fill_bytes;

library/std/src/sys/random/trusty.rs

@@ -0,0 +1,7 @@
+extern"C"{
+fntrusty_rng_secure_rand(randomBuffer:*mut core::ffi::c_void,randomBufferLen: libc::size_t);
+}
+
+pubfnfill_bytes(bytes:&mut[u8]){
+unsafe{trusty_rng_secure_rand(bytes.as_mut_ptr().cast(), bytes.len())}
+}

library/std/src/sys/thread_local/key/trusty.rs

@@ -0,0 +1,30 @@
+usecrate::ptr;
+
+pubtypeKey = usize;
+typeDtor = unsafeextern"C"fn(*mutu8);
+
+staticmutSTORAGE:crate::vec::Vec<(*mutu8,Option<Dtor>)> = Vec::new();
+
+#[inline]
+pubfncreate(dtor:Option<Dtor>) -> Key{
+unsafe{
+#[allow(static_mut_refs)]
+let key = STORAGE.len();
+#[allow(static_mut_refs)]
+STORAGE.push((ptr::null_mut(), dtor));
+ key
+}
+}
+
+#[inline]
+pubunsafefnset(key:Key,value:*mutu8){
+unsafe{STORAGE[key].0 = value };
+}
+
+#[inline]
+pubunsafefnget(key:Key) -> *mutu8{
+unsafe{STORAGE[key].0}
+}
+
+#[inline]
+pubfndestroy(_key:Key){}

library/std/src/sys/thread_local/mod.rs

@@ -170,6 +170,15 @@ pub(crate) mod key {
 pub(crate)use xous::destroy_tls;
 pub(super)use xous::{Key, get, set};
 use xous::{create, destroy};
+} else if #[cfg(target_os = "trusty")]{
+ #[allow(unused_unsafe)]
+mod racy;
+ #[cfg(test)]
+mod tests;
+mod trusty;
+pub(super)use racy::LazyKey;
+pub(super)use trusty::{Key, get, set};
+use trusty::{create, destroy};
 }
 }
 }