Fix/Ignore tests

The following kinds of tests have been ignored:
1. need threads
2. need libc
3. are unix specific
4. need rust_test_helpers
5. need stack-unwinding
6. need backtrace-rs

The following kinds of tests have been fixed:
1. Use static linking for tests on UEFI
2. Implement thread::sleep using Stall
3. Implement Instant
4. Update compiler_builtins
5. Some conditional compilation tests

Signed-off-by: Ayush Singh <ayushsingh1325@gmail.com>

library/std/src/os/uefi/raw.rs

@@ -37,6 +37,10 @@ impl<T> VariableSizeType<T> {
     pub(crate) fn as_ref(&self) -> &T {
         unsafe { self.inner.as_ref() }
     }
+
+    pub(crate) fn size(&self) -> usize {
+        self.layout.size()
+    }
 }
 
 impl<T> Drop for VariableSizeType<T> {

library/std/src/sys/uefi/fs.rs

@@ -4,7 +4,6 @@ use crate::ffi::{OsStr, OsString};
 use crate::fmt;
 use crate::hash::Hash;
 use crate::io::{self, IoSlice, IoSliceMut, ReadBuf, SeekFrom};
-// use crate::os::uefi::ffi::{OsStrExt, OsStringExt};
 use crate::path::{Path, PathBuf};
 use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
@@ -39,6 +38,7 @@ pub struct OpenOptions {
     open_mode: u64,
     attr: u64,
     append: bool,
+    truncate: bool,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -172,7 +172,7 @@ impl DirEntry {
 impl OpenOptions {
     pub fn new() -> OpenOptions {
         // These options open file in readonly mode
-        OpenOptions { open_mode: file::MODE_READ, attr: 0, append: false }
+        OpenOptions { open_mode: file::MODE_READ, attr: 0, append: false, truncate: false }
     }
 
     pub fn read(&mut self, read: bool) {
@@ -196,8 +196,9 @@ impl OpenOptions {
         self.append = append;
     }
 
-    // FIXME: Should be possible to implement
-    pub fn truncate(&mut self, _truncate: bool) {}
+    pub fn truncate(&mut self, truncate: bool) {
+        self.truncate = truncate;
+    }
 
     pub fn create(&mut self, create: bool) {
         if create {
@@ -214,6 +215,9 @@ impl OpenOptions {
 impl File {
     pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
         let file_opened = uefi_fs::FileProtocol::from_path(path, opts.open_mode, opts.attr)?;
+        if opts.truncate {
+            file_opened.set_file_info(0)?;
+        }
         let file = File { ptr: file_opened };
         if opts.append {
             file.seek(SeekFrom::End(0))?;
@@ -376,7 +380,7 @@ pub fn link(_src: &Path, _dst: &Path) -> io::Result<()> {
 }
 
 pub fn stat(p: &Path) -> io::Result<FileAttr> {
-    let opts = OpenOptions { open_mode: file::MODE_READ, attr: 0, append: false };
+    let opts = OpenOptions { open_mode: file::MODE_READ, attr: 0, append: false, truncate: false };
     File::open(p, &opts)?.file_attr()
 }
 
@@ -657,6 +661,22 @@ mod uefi_fs {
             }
         }
 
+        pub fn set_file_info(&self, file_size: u64) -> io::Result<()> {
+            let old_info = self.get_file_info()?;
+            // Update fields with new values
+            unsafe {
+                (*old_info.as_ptr()).file_size = file_size;
+            }
+            unsafe {
+                Self::set_info_raw(
+                    self.inner.as_ptr(),
+                    file::INFO_ID,
+                    old_info.size(),
+                    old_info.as_ptr().cast(),
+                )
+            }
+        }
+
         pub fn delete(self) -> io::Result<()> {
             let file = crate::mem::ManuallyDrop::new(self);
             unsafe { Self::delete_raw(file.inner.as_ptr()) }
@@ -721,6 +741,16 @@ mod uefi_fs {
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
         }
 
+        unsafe fn set_info_raw(
+            protocol: *mut file::Protocol,
+            mut info_guid: r_efi::efi::Guid,
+            buf_size: usize,
+            buf: *mut crate::ffi::c_void,
+        ) -> io::Result<()> {
+            let r = unsafe { ((*protocol).set_info)(protocol, &mut info_guid, buf_size, buf) };
+            if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }
+        }
+
         unsafe fn delete_raw(protocol: *mut file::Protocol) -> io::Result<()> {
             let r = unsafe { ((*protocol).delete)(protocol) };
             if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) }

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

@@ -30,7 +30,6 @@ pub mod path;
 pub mod pipe;
 pub mod process;
 pub mod stdio;
-#[path = "../unsupported/thread.rs"]
 pub mod thread;
 #[path = "../unsupported/thread_local_key.rs"]
 pub mod thread_local_key;

library/std/src/sys/uefi/thread.rs

@@ -0,0 +1,52 @@
+use super::unsupported;
+use crate::ffi::CStr;
+use crate::io;
+use crate::num::NonZeroUsize;
+use crate::os::uefi;
+use crate::time::Duration;
+
+pub struct Thread(());
+
+pub const DEFAULT_MIN_STACK_SIZE: usize = 4096;
+
+impl Thread {
+    // unsafe: see thread::Builder::spawn_unchecked for safety requirements
+    pub unsafe fn new(_stack: usize, _p: Box<dyn FnOnce()>) -> io::Result<Thread> {
+        unsupported()
+    }
+
+    pub fn yield_now() {
+        // do nothing
+    }
+
+    pub fn set_name(_name: &CStr) {
+        // nope
+    }
+
+    pub fn sleep(dur: Duration) {
+        if let Some(boot_services) = uefi::env::get_boot_services() {
+            let _ = unsafe { ((*boot_services.as_ptr()).stall)(dur.as_micros() as usize) };
+        } else {
+            panic!("Boot services needed for sleep")
+        }
+    }
+
+    pub fn join(self) {
+        self.0
+    }
+}
+
+pub fn available_parallelism() -> io::Result<NonZeroUsize> {
+    // UEFI is single threaded
+    Ok(NonZeroUsize::new(1).unwrap())
+}
+
+pub mod guard {
+    pub type Guard = !;
+    pub unsafe fn current() -> Option<Guard> {
+        None
+    }
+    pub unsafe fn init() -> Option<Guard> {
+        None
+    }
+}

library/std/src/sys/uefi/time.rs

@@ -9,10 +9,22 @@ pub struct SystemTime(Duration);
 
 pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::ZERO);
 
-// FIXME: Implement using `EFI_TIMESTAMP_PROTOCOL.GetTimestamp()`
+// FIXME: Maybe optionally use `EFI_TIMESTAMP_PROTOCOL.GetTimestamp()`?
 impl Instant {
     pub fn now() -> Instant {
-        panic!("time not implemented on this platform")
+        if let Some(runtime_services) = uefi::env::get_runtime_services() {
+            let mut t = r_efi::efi::Time::default();
+            let r =
+                unsafe { ((*runtime_services.as_ptr()).get_time)(&mut t, crate::ptr::null_mut()) };
+
+            if r.is_error() {
+                panic!("time not implemented on this platform")
+            } else {
+                Instant(uefi_time_to_duration(t))
+            }
+        } else {
+            panic!("Runtime Services are needed for Time to work")
+        }
     }
 
     pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
@@ -42,7 +54,7 @@ impl SystemTime {
                 SystemTime::from(t)
             }
         } else {
-            panic!("time not implemented on this platform")
+            panic!("Runtime Services are needed for Time to work")
         }
     }
 
@@ -60,24 +72,28 @@ impl SystemTime {
 }
 
 impl From<r_efi::system::Time> for SystemTime {
-    // FIXME: Don't know how to use Daylight Saving thing
     fn from(t: r_efi::system::Time) -> Self {
-        const SEC_IN_MIN: u64 = 60;
-        const SEC_IN_HOUR: u64 = SEC_IN_MIN * 60;
-        const SEC_IN_DAY: u64 = SEC_IN_HOUR * 24;
-        const SEC_IN_YEAR: u64 = SEC_IN_DAY * 365;
-        const MONTH_DAYS: [u64; 12] = [0, 31, 59, 90, 120, 151, 181, 211, 242, 272, 303, 333];
-
-        let localtime_epoch: u64 = u64::from(t.year - 1970) * SEC_IN_YEAR
-            + u64::from((t.year - 1968) / 4) * SEC_IN_DAY
-            + MONTH_DAYS[usize::from(t.month - 1)] * SEC_IN_DAY
-            + u64::from(t.day - 1) * SEC_IN_DAY
-            + u64::from(t.hour) * SEC_IN_HOUR
-            + u64::from(t.minute) * SEC_IN_MIN
-            + u64::from(t.second);
-        let timezone_epoch: i64 = i64::from(t.timezone) * (SEC_IN_MIN as i64);
-        let utc_epoch: u64 = ((localtime_epoch as i64) + timezone_epoch) as u64;
-
-        SystemTime(Duration::new(utc_epoch, t.nanosecond))
+        SystemTime(uefi_time_to_duration(t))
     }
 }
+
+// FIXME: Don't know how to use Daylight Saving thing
+fn uefi_time_to_duration(t: r_efi::system::Time) -> Duration {
+    const SEC_IN_MIN: u64 = 60;
+    const SEC_IN_HOUR: u64 = SEC_IN_MIN * 60;
+    const SEC_IN_DAY: u64 = SEC_IN_HOUR * 24;
+    const SEC_IN_YEAR: u64 = SEC_IN_DAY * 365;
+    const MONTH_DAYS: [u64; 12] = [0, 31, 59, 90, 120, 151, 181, 211, 242, 272, 303, 333];
+
+    let localtime_epoch: u64 = u64::from(t.year - 1970) * SEC_IN_YEAR
+        + u64::from((t.year - 1968) / 4) * SEC_IN_DAY
+        + MONTH_DAYS[usize::from(t.month - 1)] * SEC_IN_DAY
+        + u64::from(t.day - 1) * SEC_IN_DAY
+        + u64::from(t.hour) * SEC_IN_HOUR
+        + u64::from(t.minute) * SEC_IN_MIN
+        + u64::from(t.second);
+    let timezone_epoch: i64 = i64::from(t.timezone) * (SEC_IN_MIN as i64);
+    let utc_epoch: u64 = ((localtime_epoch as i64) + timezone_epoch) as u64;
+
+    Duration::new(utc_epoch, t.nanosecond)
+}