src/libstd/sys/hermit/mod.rs

   1 //! System bindings for HermitCore
   2 //!
   3 //! This module contains the facade (aka platform-specific) implementations of
   4 //! OS level functionality for HermitCore.
   5 //!
   6 //! This is all super highly experimental and not actually intended for
   7 //! wide/production use yet, it's still all in the experimental category. This
   8 //! will likely change over time.
   9 //!
  10 //! Currently all functions here are basically stubs that immediately return
  11 //! errors. The hope is that with a portability lint we can turn actually just
  12 //! remove all this and just omit parts of the standard library if we're
  13 //! compiling for wasm. That way it's a compile time error for something that's
  14 //! guaranteed to be a runtime error!
  15
  16 use crate::intrinsics;
  17 use crate::os::raw::c_char;
  18
  19 pub mod alloc;
  20 pub mod args;
  21 pub mod cmath;
  22 pub mod condvar;
  23 pub mod env;
  24 pub mod fast_thread_local;
  25 pub mod fd;
  26 pub mod fs;
  27 pub mod io;
  28 pub mod memchr;
  29 pub mod mutex;
  30 pub mod net;
  31 pub mod os;
  32 pub mod path;
  33 pub mod pipe;
  34 pub mod process;
  35 pub mod rwlock;
  36 pub mod stack_overflow;
  37 pub mod stdio;
  38 pub mod thread;
  39 pub mod thread_local;
  40 pub mod time;
  41
  42 use crate::io::ErrorKind;
  43 pub use crate::sys_common::os_str_bytes as os_str;
  44
  45 #[allow(unused_extern_crates)]
  46 pub extern crate hermit_abi as abi;
  47
  48 pub fn unsupported<T>() -> crate::io::Result<T> {
  49     Err(unsupported_err())
  50 }
  51
  52 pub fn unsupported_err() -> crate::io::Error {
  53     crate::io::Error::new(crate::io::ErrorKind::Other, "operation not supported on HermitCore yet")
  54 }
  55
  56 // This enum is used as the storage for a bunch of types which can't actually
  57 // exist.
  58 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
  59 pub enum Void {}
  60
  61 pub unsafe fn strlen(start: *const c_char) -> usize {
  62     let mut str = start;
  63
  64     while *str != 0 {
  65         str = str.offset(1);
  66     }
  67
  68     (str as usize) - (start as usize)
  69 }
  70
  71 #[no_mangle]
  72 pub extern "C" fn floor(x: f64) -> f64 {
  73     unsafe { intrinsics::floorf64(x) }
  74 }
  75
  76 pub unsafe fn abort_internal() -> ! {
  77     abi::abort();
  78 }
  79
  80 // FIXME: just a workaround to test the system
  81 pub fn hashmap_random_keys() -> (u64, u64) {
  82     (1, 2)
  83 }
  84
  85 // This function is needed by the panic runtime. The symbol is named in
  86 // pre-link args for the target specification, so keep that in sync.
  87 #[cfg(not(test))]
  88 #[no_mangle]
  89 // NB. used by both libunwind and libpanic_abort
  90 pub unsafe extern "C" fn __rust_abort() {
  91     abort_internal();
  92 }
  93
  94 #[cfg(not(test))]
  95 pub fn init() {
  96     unsafe {
  97         let _ = net::init();
  98     }
  99 }
 100
 101 #[cfg(not(test))]
 102 #[no_mangle]
 103 pub unsafe extern "C" fn runtime_entry(
 104     argc: i32,
 105     argv: *const *const c_char,
 106     env: *const *const c_char,
 107 ) -> ! {
 108     extern "C" {
 109         fn main(argc: isize, argv: *const *const c_char) -> i32;
 110     }
 111
 112     // initialize environment
 113     os::init_environment(env as *const *const i8);
 114
 115     let result = main(argc as isize, argv);
 116
 117     abi::exit(result);
 118 }
 119
 120 pub fn decode_error_kind(errno: i32) -> ErrorKind {
 121     match errno {
 122         x if x == 13 as i32 => ErrorKind::PermissionDenied,
 123         x if x == 98 as i32 => ErrorKind::AddrInUse,
 124         x if x == 99 as i32 => ErrorKind::AddrNotAvailable,
 125         x if x == 11 as i32 => ErrorKind::WouldBlock,
 126         x if x == 103 as i32 => ErrorKind::ConnectionAborted,
 127         x if x == 111 as i32 => ErrorKind::ConnectionRefused,
 128         x if x == 104 as i32 => ErrorKind::ConnectionReset,
 129         x if x == 17 as i32 => ErrorKind::AlreadyExists,
 130         x if x == 4 as i32 => ErrorKind::Interrupted,
 131         x if x == 22 as i32 => ErrorKind::InvalidInput,
 132         x if x == 2 as i32 => ErrorKind::NotFound,
 133         x if x == 107 as i32 => ErrorKind::NotConnected,
 134         x if x == 1 as i32 => ErrorKind::PermissionDenied,
 135         x if x == 32 as i32 => ErrorKind::BrokenPipe,
 136         x if x == 110 as i32 => ErrorKind::TimedOut,
 137         _ => ErrorKind::Other,
 138     }
 139 }
 140
 141 pub fn cvt(result: i32) -> crate::io::Result<usize> {
 142     if result < 0 { Err(crate::io::Error::from_raw_os_error(-result)) } else { Ok(result as usize) }
 143 }