1
Fork 0

STD support for the ESP-IDF framework

This commit is contained in:
ivmarkov 2021-07-29 20:18:22 +03:00 committed by ivmarkov
parent ae90dcf020
commit 459eaa6bae
29 changed files with 580 additions and 46 deletions

View file

@ -1880,9 +1880,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
[[package]] [[package]]
name = "libc" name = "libc"
version = "0.2.98" version = "0.2.99"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320cfe77175da3a483efed4bc0adc1968ca050b098ce4f2f1c13a56626128790" checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765"
dependencies = [ dependencies = [
"rustc-std-workspace-core", "rustc-std-workspace-core",
] ]

View file

@ -903,6 +903,7 @@ supported_targets! {
("riscv32i-unknown-none-elf", riscv32i_unknown_none_elf), ("riscv32i-unknown-none-elf", riscv32i_unknown_none_elf),
("riscv32imc-unknown-none-elf", riscv32imc_unknown_none_elf), ("riscv32imc-unknown-none-elf", riscv32imc_unknown_none_elf),
("riscv32imc-esp-espidf", riscv32imc_esp_espidf),
("riscv32imac-unknown-none-elf", riscv32imac_unknown_none_elf), ("riscv32imac-unknown-none-elf", riscv32imac_unknown_none_elf),
("riscv32gc-unknown-linux-gnu", riscv32gc_unknown_linux_gnu), ("riscv32gc-unknown-linux-gnu", riscv32gc_unknown_linux_gnu),
("riscv32gc-unknown-linux-musl", riscv32gc_unknown_linux_musl), ("riscv32gc-unknown-linux-musl", riscv32gc_unknown_linux_musl),

View file

@ -0,0 +1,37 @@
use crate::spec::{LinkerFlavor, PanicStrategy, RelocModel};
use crate::spec::{Target, TargetOptions};
pub fn target() -> Target {
Target {
data_layout: "e-m:e-p:32:32-i64:64-n32-S128".to_string(),
llvm_target: "riscv32".to_string(),
pointer_width: 32,
arch: "riscv32".to_string(),
options: TargetOptions {
families: vec!["unix".to_string()],
os: "espidf".to_string(),
env: "newlib".to_string(),
vendor: "espressif".to_string(),
linker_flavor: LinkerFlavor::Gcc,
linker: Some("riscv32-esp-elf-gcc".to_string()),
cpu: "generic-rv32".to_string(),
// While the RiscV32IMC architecture does not natively support atomics, ESP-IDF does support
// the __atomic* and __sync* GCC builtins, so setting `max_atomic_width` to `Some(32)`
// and `atomic_cas` to `true` will cause the compiler to emit libcalls to these builtins.
//
// Support for atomics is necessary for the Rust STD library, which is supported by the ESP-IDF framework.
max_atomic_width: Some(32),
atomic_cas: true,
features: "+m,+c".to_string(),
executables: true,
panic_strategy: PanicStrategy::Abort,
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
eh_frame_header: false,
..Default::default()
},
}
}

View file

@ -45,7 +45,7 @@ cfg_if::cfg_if! {
} else if #[cfg(any( } else if #[cfg(any(
all(target_family = "windows", target_env = "gnu"), all(target_family = "windows", target_env = "gnu"),
target_os = "psp", target_os = "psp",
target_family = "unix", all(target_family = "unix", not(target_os = "espidf")),
all(target_vendor = "fortanix", target_env = "sgx"), all(target_vendor = "fortanix", target_env = "sgx"),
))] { ))] {
// Rust runtime's startup objects depend on these symbols, so make them public. // Rust runtime's startup objects depend on these symbols, so make them public.
@ -58,6 +58,7 @@ cfg_if::cfg_if! {
// - arch=wasm32 // - arch=wasm32
// - os=none ("bare metal" targets) // - os=none ("bare metal" targets)
// - os=uefi // - os=uefi
// - os=espidf
// - nvptx64-nvidia-cuda // - nvptx64-nvidia-cuda
// - arch=avr // - arch=avr
#[path = "dummy.rs"] #[path = "dummy.rs"]

View file

@ -15,7 +15,7 @@ cfg-if = { version = "0.1.8", features = ['rustc-dep-of-std'] }
panic_unwind = { path = "../panic_unwind", optional = true } panic_unwind = { path = "../panic_unwind", optional = true }
panic_abort = { path = "../panic_abort" } panic_abort = { path = "../panic_abort" }
core = { path = "../core" } core = { path = "../core" }
libc = { version = "0.2.98", default-features = false, features = ['rustc-dep-of-std'] } libc = { version = "0.2.99", default-features = false, features = ['rustc-dep-of-std'] }
compiler_builtins = { version = "0.1.44" } compiler_builtins = { version = "0.1.44" }
profiler_builtins = { path = "../profiler_builtins", optional = true } profiler_builtins = { path = "../profiler_builtins", optional = true }
unwind = { path = "../unwind" } unwind = { path = "../unwind" }

View file

@ -26,6 +26,7 @@ fn main() {
|| target.contains("vxworks") || target.contains("vxworks")
|| target.contains("wasm32") || target.contains("wasm32")
|| target.contains("asmjs") || target.contains("asmjs")
|| target.contains("espidf")
{ {
// These platforms don't have any special requirements. // These platforms don't have any special requirements.
} else { } else {

View file

@ -0,0 +1,117 @@
#![stable(feature = "metadata_ext", since = "1.1.0")]
use crate::fs::Metadata;
use crate::sys_common::AsInner;
#[allow(deprecated)]
use crate::os::espidf::raw;
/// OS-specific extensions to [`fs::Metadata`].
///
/// [`fs::Metadata`]: crate::fs::Metadata
#[stable(feature = "metadata_ext", since = "1.1.0")]
pub trait MetadataExt {
#[stable(feature = "metadata_ext", since = "1.1.0")]
#[rustc_deprecated(
since = "1.8.0",
reason = "deprecated in favor of the accessor \
methods of this trait"
)]
#[allow(deprecated)]
fn as_raw_stat(&self) -> &raw::stat;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_dev(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_ino(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_mode(&self) -> u32;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_nlink(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_uid(&self) -> u32;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_gid(&self) -> u32;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_rdev(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_size(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_atime(&self) -> i64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_atime_nsec(&self) -> i64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_mtime(&self) -> i64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_mtime_nsec(&self) -> i64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_ctime(&self) -> i64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_ctime_nsec(&self) -> i64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_blksize(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_blocks(&self) -> u64;
#[stable(feature = "metadata_ext2", since = "1.8.0")]
fn st_spare4(&self) -> [u32; 2];
}
#[stable(feature = "metadata_ext", since = "1.1.0")]
impl MetadataExt for Metadata {
#[allow(deprecated)]
fn as_raw_stat(&self) -> &raw::stat {
unsafe { &*(self.as_inner().as_inner() as *const libc::stat as *const raw::stat) }
}
fn st_dev(&self) -> u64 {
self.as_inner().as_inner().st_dev as u64
}
fn st_ino(&self) -> u64 {
self.as_inner().as_inner().st_ino as u64
}
fn st_mode(&self) -> u32 {
self.as_inner().as_inner().st_mode as u32
}
fn st_nlink(&self) -> u64 {
self.as_inner().as_inner().st_nlink as u64
}
fn st_uid(&self) -> u32 {
self.as_inner().as_inner().st_uid as u32
}
fn st_gid(&self) -> u32 {
self.as_inner().as_inner().st_gid as u32
}
fn st_rdev(&self) -> u64 {
self.as_inner().as_inner().st_rdev as u64
}
fn st_size(&self) -> u64 {
self.as_inner().as_inner().st_size as u64
}
fn st_atime(&self) -> i64 {
self.as_inner().as_inner().st_atime as i64
}
fn st_atime_nsec(&self) -> i64 {
0
}
fn st_mtime(&self) -> i64 {
self.as_inner().as_inner().st_mtime as i64
}
fn st_mtime_nsec(&self) -> i64 {
0
}
fn st_ctime(&self) -> i64 {
self.as_inner().as_inner().st_ctime as i64
}
fn st_ctime_nsec(&self) -> i64 {
0
}
fn st_blksize(&self) -> u64 {
self.as_inner().as_inner().st_blksize as u64
}
fn st_blocks(&self) -> u64 {
self.as_inner().as_inner().st_blocks as u64
}
fn st_spare4(&self) -> [u32; 2] {
let spare4 = self.as_inner().as_inner().st_spare4;
[spare4[0] as u32, spare4[1] as u32]
}
}

View file

@ -0,0 +1,6 @@
//! Definitions for the ESP-IDF framework.
#![stable(feature = "raw_ext", since = "1.1.0")]
pub mod fs;
pub mod raw;

View file

@ -0,0 +1,69 @@
//! Raw type definitions for the ESP-IDF framework.
#![stable(feature = "raw_ext", since = "1.1.0")]
#![rustc_deprecated(
since = "1.8.0",
reason = "these type aliases are no longer supported by \
the standard library, the `libc` crate on \
crates.io should be used instead for the correct \
definitions"
)]
use crate::os::raw::c_long;
use crate::os::unix::raw::{gid_t, uid_t};
#[stable(feature = "pthread_t", since = "1.8.0")]
pub type pthread_t = libc::pthread_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type blkcnt_t = libc::blkcnt_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type blksize_t = libc::blksize_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type dev_t = libc::dev_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type ino_t = libc::ino_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type mode_t = libc::mode_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type nlink_t = libc::nlink_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type off_t = libc::off_t;
#[stable(feature = "raw_ext", since = "1.1.0")]
pub type time_t = libc::time_t;
#[repr(C)]
#[derive(Clone)]
#[stable(feature = "raw_ext", since = "1.1.0")]
pub struct stat {
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_dev: dev_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_ino: ino_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_mode: mode_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_nlink: nlink_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_uid: uid_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_gid: gid_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_rdev: dev_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_size: off_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_atime: time_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_mtime: time_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_ctime: time_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_blksize: blksize_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_blocks: blkcnt_t,
#[stable(feature = "raw_ext", since = "1.1.0")]
pub st_spare4: [c_long; 2usize],
}

View file

@ -80,6 +80,8 @@ mod imp {
pub mod dragonfly; pub mod dragonfly;
#[cfg(target_os = "emscripten")] #[cfg(target_os = "emscripten")]
pub mod emscripten; pub mod emscripten;
#[cfg(target_os = "espidf")]
pub mod espidf;
#[cfg(target_os = "freebsd")] #[cfg(target_os = "freebsd")]
pub mod freebsd; pub mod freebsd;
#[cfg(target_os = "fuchsia")] #[cfg(target_os = "fuchsia")]

View file

@ -40,6 +40,8 @@ mod platform {
pub use crate::os::dragonfly::*; pub use crate::os::dragonfly::*;
#[cfg(target_os = "emscripten")] #[cfg(target_os = "emscripten")]
pub use crate::os::emscripten::*; pub use crate::os::emscripten::*;
#[cfg(target_os = "espidf")]
pub use crate::os::espidf::*;
#[cfg(target_os = "freebsd")] #[cfg(target_os = "freebsd")]
pub use crate::os::freebsd::*; pub use crate::os::freebsd::*;
#[cfg(target_os = "fuchsia")] #[cfg(target_os = "fuchsia")]

View file

@ -14,7 +14,8 @@ use crate::ptr;
target_arch = "asmjs", target_arch = "asmjs",
target_arch = "wasm32", target_arch = "wasm32",
target_arch = "hexagon", target_arch = "hexagon",
target_arch = "riscv32" target_arch = "riscv32",
target_arch = "xtensa"
)))] )))]
pub const MIN_ALIGN: usize = 8; pub const MIN_ALIGN: usize = 8;
#[cfg(all(any( #[cfg(all(any(

View file

@ -57,7 +57,8 @@ cfg_if::cfg_if! {
target_os = "android", target_os = "android",
target_os = "illumos", target_os = "illumos",
target_os = "redox", target_os = "redox",
target_os = "solaris" target_os = "solaris",
target_os = "espidf"
))] { ))] {
#[inline] #[inline]
unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 { unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {

View file

@ -246,3 +246,15 @@ mod imp {
Args { iter: res.into_iter() } Args { iter: res.into_iter() }
} }
} }
#[cfg(target_os = "espidf")]
mod imp {
use super::Args;
#[inline(always)]
pub unsafe fn init(_argc: isize, _argv: *const *const u8) {}
pub fn args() -> Args {
Args { iter: Vec::new().into_iter() }
}
}

View file

@ -34,12 +34,23 @@ impl Condvar {
))] ))]
pub unsafe fn init(&mut self) {} pub unsafe fn init(&mut self) {}
// NOTE: ESP-IDF's PTHREAD_COND_INITIALIZER support is not released yet
// So on that platform, init() should always be called
// Moreover, that platform does not have pthread_condattr_setclock support,
// hence that initialization should be skipped as well
#[cfg(target_os = "espidf")]
pub unsafe fn init(&mut self) {
let r = libc::pthread_cond_init(self.inner.get(), crate::ptr::null());
assert_eq!(r, 0);
}
#[cfg(not(any( #[cfg(not(any(
target_os = "macos", target_os = "macos",
target_os = "ios", target_os = "ios",
target_os = "l4re", target_os = "l4re",
target_os = "android", target_os = "android",
target_os = "redox" target_os = "redox",
target_os = "espidf"
)))] )))]
pub unsafe fn init(&mut self) { pub unsafe fn init(&mut self) {
use crate::mem::MaybeUninit; use crate::mem::MaybeUninit;
@ -76,7 +87,12 @@ impl Condvar {
// where we configure condition variable to use monotonic clock (instead of // where we configure condition variable to use monotonic clock (instead of
// default system clock). This approach avoids all problems that result // default system clock). This approach avoids all problems that result
// from changes made to the system time. // from changes made to the system time.
#[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "android")))] #[cfg(not(any(
target_os = "macos",
target_os = "ios",
target_os = "android",
target_os = "espidf"
)))]
pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool { pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
use crate::mem; use crate::mem;
@ -103,7 +119,12 @@ impl Condvar {
// This implementation is modeled after libcxx's condition_variable // This implementation is modeled after libcxx's condition_variable
// https://github.com/llvm-mirror/libcxx/blob/release_35/src/condition_variable.cpp#L46 // https://github.com/llvm-mirror/libcxx/blob/release_35/src/condition_variable.cpp#L46
// https://github.com/llvm-mirror/libcxx/blob/release_35/include/__mutex_base#L367 // https://github.com/llvm-mirror/libcxx/blob/release_35/include/__mutex_base#L367
#[cfg(any(target_os = "macos", target_os = "ios", target_os = "android"))] #[cfg(any(
target_os = "macos",
target_os = "ios",
target_os = "android",
target_os = "espidf"
))]
pub unsafe fn wait_timeout(&self, mutex: &Mutex, mut dur: Duration) -> bool { pub unsafe fn wait_timeout(&self, mutex: &Mutex, mut dur: Duration) -> bool {
use crate::ptr; use crate::ptr;
use crate::time::Instant; use crate::time::Instant;

View file

@ -184,3 +184,14 @@ pub mod os {
pub const EXE_SUFFIX: &str = ""; pub const EXE_SUFFIX: &str = "";
pub const EXE_EXTENSION: &str = ""; pub const EXE_EXTENSION: &str = "";
} }
#[cfg(target_os = "espidf")]
pub mod os {
pub const FAMILY: &str = "unix";
pub const OS: &str = "espidf";
pub const DLL_PREFIX: &str = "lib";
pub const DLL_SUFFIX: &str = ".so";
pub const DLL_EXTENSION: &str = "so";
pub const EXE_SUFFIX: &str = "";
pub const EXE_EXTENSION: &str = "";
}

View file

@ -91,6 +91,7 @@ impl FileDesc {
Ok(ret as usize) Ok(ret as usize)
} }
#[cfg(not(target_os = "espidf"))]
pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
let ret = cvt(unsafe { let ret = cvt(unsafe {
libc::readv( libc::readv(
@ -102,9 +103,14 @@ impl FileDesc {
Ok(ret as usize) Ok(ret as usize)
} }
#[cfg(target_os = "espidf")]
pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
return crate::io::default_read_vectored(|b| self.read(b), bufs);
}
#[inline] #[inline]
pub fn is_read_vectored(&self) -> bool { pub fn is_read_vectored(&self) -> bool {
true cfg!(not(target_os = "espidf"))
} }
pub fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> { pub fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
@ -148,6 +154,7 @@ impl FileDesc {
Ok(ret as usize) Ok(ret as usize)
} }
#[cfg(not(target_os = "espidf"))]
pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
let ret = cvt(unsafe { let ret = cvt(unsafe {
libc::writev( libc::writev(
@ -159,9 +166,14 @@ impl FileDesc {
Ok(ret as usize) Ok(ret as usize)
} }
#[cfg(target_os = "espidf")]
pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
return crate::io::default_write_vectored(|b| self.write(b), bufs);
}
#[inline] #[inline]
pub fn is_write_vectored(&self) -> bool { pub fn is_write_vectored(&self) -> bool {
true cfg!(not(target_os = "espidf"))
} }
pub fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> { pub fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
@ -217,7 +229,7 @@ impl FileDesc {
} }
} }
#[cfg(any( #[cfg(any(
target_env = "newlib", all(target_env = "newlib", not(target_os = "espidf")),
target_os = "solaris", target_os = "solaris",
target_os = "illumos", target_os = "illumos",
target_os = "emscripten", target_os = "emscripten",
@ -238,6 +250,12 @@ impl FileDesc {
Ok(()) Ok(())
} }
} }
#[cfg(target_os = "espidf")]
pub fn set_cloexec(&self) -> io::Result<()> {
// FD_CLOEXEC is not supported in ESP-IDF but there's no need to,
// because ESP-IDF does not support spawning processes either.
Ok(())
}
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> { pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
@ -268,7 +286,17 @@ impl FileDesc {
// We want to atomically duplicate this file descriptor and set the // We want to atomically duplicate this file descriptor and set the
// CLOEXEC flag, and currently that's done via F_DUPFD_CLOEXEC. This // CLOEXEC flag, and currently that's done via F_DUPFD_CLOEXEC. This
// is a POSIX flag that was added to Linux in 2.6.24. // is a POSIX flag that was added to Linux in 2.6.24.
let fd = cvt(unsafe { libc::fcntl(self.raw(), libc::F_DUPFD_CLOEXEC, 0) })?; #[cfg(not(target_os = "espidf"))]
let cmd = libc::F_DUPFD_CLOEXEC;
// For ESP-IDF, F_DUPFD is used instead, because the CLOEXEC semantics
// will never be supported, as this is a bare metal framework with
// no capabilities for multi-process execution. While F_DUPFD is also
// not supported yet, it might be (currently it returns ENOSYS).
#[cfg(target_os = "espidf")]
let cmd = libc::F_DUPFD;
let fd = cvt(unsafe { libc::fcntl(self.raw(), cmd, 0) })?;
Ok(FileDesc::new(fd)) Ok(FileDesc::new(fd))
} }
} }

View file

@ -312,7 +312,7 @@ impl FileAttr {
#[cfg(not(target_os = "netbsd"))] #[cfg(not(target_os = "netbsd"))]
impl FileAttr { impl FileAttr {
#[cfg(not(target_os = "vxworks"))] #[cfg(all(not(target_os = "vxworks"), not(target_os = "espidf")))]
pub fn modified(&self) -> io::Result<SystemTime> { pub fn modified(&self) -> io::Result<SystemTime> {
Ok(SystemTime::from(libc::timespec { Ok(SystemTime::from(libc::timespec {
tv_sec: self.stat.st_mtime as libc::time_t, tv_sec: self.stat.st_mtime as libc::time_t,
@ -320,7 +320,7 @@ impl FileAttr {
})) }))
} }
#[cfg(target_os = "vxworks")] #[cfg(any(target_os = "vxworks", target_os = "espidf"))]
pub fn modified(&self) -> io::Result<SystemTime> { pub fn modified(&self) -> io::Result<SystemTime> {
Ok(SystemTime::from(libc::timespec { Ok(SystemTime::from(libc::timespec {
tv_sec: self.stat.st_mtime as libc::time_t, tv_sec: self.stat.st_mtime as libc::time_t,
@ -328,7 +328,7 @@ impl FileAttr {
})) }))
} }
#[cfg(not(target_os = "vxworks"))] #[cfg(all(not(target_os = "vxworks"), not(target_os = "espidf")))]
pub fn accessed(&self) -> io::Result<SystemTime> { pub fn accessed(&self) -> io::Result<SystemTime> {
Ok(SystemTime::from(libc::timespec { Ok(SystemTime::from(libc::timespec {
tv_sec: self.stat.st_atime as libc::time_t, tv_sec: self.stat.st_atime as libc::time_t,
@ -336,7 +336,7 @@ impl FileAttr {
})) }))
} }
#[cfg(target_os = "vxworks")] #[cfg(any(target_os = "vxworks", target_os = "espidf"))]
pub fn accessed(&self) -> io::Result<SystemTime> { pub fn accessed(&self) -> io::Result<SystemTime> {
Ok(SystemTime::from(libc::timespec { Ok(SystemTime::from(libc::timespec {
tv_sec: self.stat.st_atime as libc::time_t, tv_sec: self.stat.st_atime as libc::time_t,
@ -609,7 +609,8 @@ impl DirEntry {
target_os = "l4re", target_os = "l4re",
target_os = "fuchsia", target_os = "fuchsia",
target_os = "redox", target_os = "redox",
target_os = "vxworks" target_os = "vxworks",
target_os = "espidf"
))] ))]
pub fn ino(&self) -> u64 { pub fn ino(&self) -> u64 {
self.entry.d_ino as u64 self.entry.d_ino as u64
@ -648,7 +649,8 @@ impl DirEntry {
target_os = "emscripten", target_os = "emscripten",
target_os = "l4re", target_os = "l4re",
target_os = "haiku", target_os = "haiku",
target_os = "vxworks" target_os = "vxworks",
target_os = "espidf"
))] ))]
fn name_bytes(&self) -> &[u8] { fn name_bytes(&self) -> &[u8] {
unsafe { CStr::from_ptr(self.entry.d_name.as_ptr()).to_bytes() } unsafe { CStr::from_ptr(self.entry.d_name.as_ptr()).to_bytes() }
@ -1106,8 +1108,8 @@ pub fn link(original: &Path, link: &Path) -> io::Result<()> {
let original = cstr(original)?; let original = cstr(original)?;
let link = cstr(link)?; let link = cstr(link)?;
cfg_if::cfg_if! { cfg_if::cfg_if! {
if #[cfg(any(target_os = "vxworks", target_os = "redox", target_os = "android"))] { if #[cfg(any(target_os = "vxworks", target_os = "redox", target_os = "android", target_os = "espidf"))] {
// VxWorks and Redox lack `linkat`, so use `link` instead. POSIX leaves // VxWorks, Redox and ESP-IDF lack `linkat`, so use `link` instead. POSIX leaves
// it implementation-defined whether `link` follows symlinks, so rely on the // it implementation-defined whether `link` follows symlinks, so rely on the
// `symlink_hard_link` test in library/std/src/fs/tests.rs to check the behavior. // `symlink_hard_link` test in library/std/src/fs/tests.rs to check the behavior.
// Android has `linkat` on newer versions, but we happen to know `link` // Android has `linkat` on newer versions, but we happen to know `link`
@ -1199,6 +1201,18 @@ fn open_from(from: &Path) -> io::Result<(crate::fs::File, crate::fs::Metadata)>
Ok((reader, metadata)) Ok((reader, metadata))
} }
#[cfg(target_os = "espidf")]
fn open_to_and_set_permissions(
to: &Path,
reader_metadata: crate::fs::Metadata,
) -> io::Result<(crate::fs::File, crate::fs::Metadata)> {
use crate::fs::OpenOptions;
let writer = OpenOptions::new().open(to)?;
let writer_metadata = writer.metadata()?;
Ok((writer, writer_metadata))
}
#[cfg(not(target_os = "espidf"))]
fn open_to_and_set_permissions( fn open_to_and_set_permissions(
to: &Path, to: &Path,
reader_metadata: crate::fs::Metadata, reader_metadata: crate::fs::Metadata,

View file

@ -5,6 +5,7 @@ use crate::io::ErrorKind;
pub use self::rand::hashmap_random_keys; pub use self::rand::hashmap_random_keys;
pub use libc::strlen; pub use libc::strlen;
#[cfg(not(target_os = "espidf"))]
#[macro_use] #[macro_use]
pub mod weak; pub mod weak;
@ -43,6 +44,10 @@ pub mod thread_local_dtor;
pub mod thread_local_key; pub mod thread_local_key;
pub mod time; pub mod time;
#[cfg(target_os = "espidf")]
pub fn init(argc: isize, argv: *const *const u8) {}
#[cfg(not(target_os = "espidf"))]
// SAFETY: must be called only once during runtime initialization. // SAFETY: must be called only once during runtime initialization.
// NOTE: this is not guaranteed to run, for example when Rust code is called externally. // NOTE: this is not guaranteed to run, for example when Rust code is called externally.
pub unsafe fn init(argc: isize, argv: *const *const u8) { pub unsafe fn init(argc: isize, argv: *const *const u8) {
@ -304,3 +309,19 @@ cfg_if::cfg_if! {
extern "C" {} extern "C" {}
} }
} }
#[cfg(target_os = "espidf")]
mod unsupported {
use crate::io;
pub fn unsupported<T>() -> io::Result<T> {
Err(unsupported_err())
}
pub fn unsupported_err() -> io::Error {
io::Error::new_const(
io::ErrorKind::Unsupported,
&"operation not supported on this platform",
)
}
}

View file

@ -9,7 +9,7 @@ use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr};
use crate::sys_common::{AsInner, FromInner, IntoInner}; use crate::sys_common::{AsInner, FromInner, IntoInner};
use crate::time::{Duration, Instant}; use crate::time::{Duration, Instant};
use libc::{c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK}; use libc::{c_int, c_void, size_t, sockaddr, socklen_t, MSG_PEEK};
pub use crate::sys::{cvt, cvt_r}; pub use crate::sys::{cvt, cvt_r};
@ -30,13 +30,19 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> {
// We may need to trigger a glibc workaround. See on_resolver_failure() for details. // We may need to trigger a glibc workaround. See on_resolver_failure() for details.
on_resolver_failure(); on_resolver_failure();
if err == EAI_SYSTEM { #[cfg(not(target_os = "espidf"))]
if err == libc::EAI_SYSTEM {
return Err(io::Error::last_os_error()); return Err(io::Error::last_os_error());
} }
#[cfg(not(target_os = "espidf"))]
let detail = unsafe { let detail = unsafe {
str::from_utf8(CStr::from_ptr(libc::gai_strerror(err)).to_bytes()).unwrap().to_owned() str::from_utf8(CStr::from_ptr(libc::gai_strerror(err)).to_bytes()).unwrap().to_owned()
}; };
#[cfg(target_os = "espidf")]
let detail = "";
Err(io::Error::new( Err(io::Error::new(
io::ErrorKind::Uncategorized, io::ErrorKind::Uncategorized,
&format!("failed to lookup address information: {}", detail)[..], &format!("failed to lookup address information: {}", detail)[..],

View file

@ -128,6 +128,12 @@ pub fn error_string(errno: i32) -> String {
} }
} }
#[cfg(target_os = "espidf")]
pub fn getcwd() -> io::Result<PathBuf> {
Ok(PathBuf::from("/"))
}
#[cfg(not(target_os = "espidf"))]
pub fn getcwd() -> io::Result<PathBuf> { pub fn getcwd() -> io::Result<PathBuf> {
let mut buf = Vec::with_capacity(512); let mut buf = Vec::with_capacity(512);
loop { loop {
@ -154,6 +160,12 @@ pub fn getcwd() -> io::Result<PathBuf> {
} }
} }
#[cfg(target_os = "espidf")]
pub fn chdir(p: &path::Path) -> io::Result<()> {
super::unsupported::unsupported()
}
#[cfg(not(target_os = "espidf"))]
pub fn chdir(p: &path::Path) -> io::Result<()> { pub fn chdir(p: &path::Path) -> io::Result<()> {
let p: &OsStr = p.as_ref(); let p: &OsStr = p.as_ref();
let p = CString::new(p.as_bytes())?; let p = CString::new(p.as_bytes())?;
@ -432,6 +444,11 @@ pub fn current_exe() -> io::Result<PathBuf> {
path.canonicalize() path.canonicalize()
} }
#[cfg(target_os = "espidf")]
pub fn current_exe() -> io::Result<PathBuf> {
super::unsupported::unsupported()
}
pub struct Env { pub struct Env {
iter: vec::IntoIter<(OsString, OsString)>, iter: vec::IntoIter<(OsString, OsString)>,
} }
@ -541,6 +558,7 @@ pub fn unsetenv(n: &OsStr) -> io::Result<()> {
} }
} }
#[cfg(not(target_os = "espidf"))]
pub fn page_size() -> usize { pub fn page_size() -> usize {
unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize } unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
} }
@ -563,7 +581,8 @@ pub fn home_dir() -> Option<PathBuf> {
target_os = "ios", target_os = "ios",
target_os = "emscripten", target_os = "emscripten",
target_os = "redox", target_os = "redox",
target_os = "vxworks" target_os = "vxworks",
target_os = "espidf"
))] ))]
unsafe fn fallback() -> Option<OsString> { unsafe fn fallback() -> Option<OsString> {
None None
@ -573,7 +592,8 @@ pub fn home_dir() -> Option<PathBuf> {
target_os = "ios", target_os = "ios",
target_os = "emscripten", target_os = "emscripten",
target_os = "redox", target_os = "redox",
target_os = "vxworks" target_os = "vxworks",
target_os = "espidf"
)))] )))]
unsafe fn fallback() -> Option<OsString> { unsafe fn fallback() -> Option<OsString> {
let amt = match libc::sysconf(libc::_SC_GETPW_R_SIZE_MAX) { let amt = match libc::sysconf(libc::_SC_GETPW_R_SIZE_MAX) {

View file

@ -13,6 +13,9 @@ cfg_if::cfg_if! {
} else if #[cfg(target_os = "vxworks")] { } else if #[cfg(target_os = "vxworks")] {
#[path = "process_vxworks.rs"] #[path = "process_vxworks.rs"]
mod process_inner; mod process_inner;
} else if #[cfg(target_os = "espidf")] {
#[path = "process_unsupported.rs"]
mod process_inner;
} else { } else {
#[path = "process_unix.rs"] #[path = "process_unix.rs"]
mod process_inner; mod process_inner;

View file

@ -0,0 +1,122 @@
use crate::convert::{TryFrom, TryInto};
use crate::fmt;
use crate::io;
use crate::io::ErrorKind;
use crate::num::NonZeroI32;
use crate::os::raw::NonZero_c_int;
use crate::sys;
use crate::sys::cvt;
use crate::sys::pipe::AnonPipe;
use crate::sys::process::process_common::*;
use crate::sys::unix::unsupported::*;
use libc::{c_int, pid_t};
////////////////////////////////////////////////////////////////////////////////
// Command
////////////////////////////////////////////////////////////////////////////////
impl Command {
pub fn spawn(
&mut self,
default: Stdio,
needs_stdin: bool,
) -> io::Result<(Process, StdioPipes)> {
unsupported()
}
pub fn exec(&mut self, default: Stdio) -> io::Error {
unsupported_err()
}
}
////////////////////////////////////////////////////////////////////////////////
// Processes
////////////////////////////////////////////////////////////////////////////////
pub struct Process {
handle: pid_t,
}
impl Process {
pub fn id(&self) -> u32 {
0
}
pub fn kill(&mut self) -> io::Result<()> {
unsupported()
}
pub fn wait(&mut self) -> io::Result<ExitStatus> {
unsupported()
}
pub fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
unsupported()
}
}
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct ExitStatus(c_int);
impl ExitStatus {
pub fn success(&self) -> bool {
self.code() == Some(0)
}
pub fn exit_ok(&self) -> Result<(), ExitStatusError> {
Err(ExitStatusError(1.try_into().unwrap()))
}
pub fn code(&self) -> Option<i32> {
None
}
pub fn signal(&self) -> Option<i32> {
None
}
pub fn core_dumped(&self) -> bool {
false
}
pub fn stopped_signal(&self) -> Option<i32> {
None
}
pub fn continued(&self) -> bool {
false
}
pub fn into_raw(&self) -> c_int {
0
}
}
/// Converts a raw `c_int` to a type-safe `ExitStatus` by wrapping it without copying.
impl From<c_int> for ExitStatus {
fn from(a: c_int) -> ExitStatus {
ExitStatus(a as i32)
}
}
impl fmt::Display for ExitStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "exit code: {}", self.0)
}
}
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub struct ExitStatusError(NonZero_c_int);
impl Into<ExitStatus> for ExitStatusError {
fn into(self) -> ExitStatus {
ExitStatus(self.0.into())
}
}
impl ExitStatusError {
pub fn code(self) -> Option<NonZeroI32> {
ExitStatus(self.0.into()).code().map(|st| st.try_into().unwrap())
}
}

View file

@ -44,12 +44,17 @@ mod imp {
unsafe { getrandom(buf.as_mut_ptr().cast(), buf.len(), libc::GRND_NONBLOCK) } unsafe { getrandom(buf.as_mut_ptr().cast(), buf.len(), libc::GRND_NONBLOCK) }
} }
#[cfg(not(any(target_os = "linux", target_os = "android")))] #[cfg(target_os = "espidf")]
fn getrandom(buf: &mut [u8]) -> libc::ssize_t {
unsafe { libc::getrandom(buf.as_mut_ptr().cast(), buf.len(), 0) }
}
#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "espidf")))]
fn getrandom_fill_bytes(_buf: &mut [u8]) -> bool { fn getrandom_fill_bytes(_buf: &mut [u8]) -> bool {
false false
} }
#[cfg(any(target_os = "linux", target_os = "android"))] #[cfg(any(target_os = "linux", target_os = "android", target_os = "espidf"))]
fn getrandom_fill_bytes(v: &mut [u8]) -> bool { fn getrandom_fill_bytes(v: &mut [u8]) -> bool {
use crate::sync::atomic::{AtomicBool, Ordering}; use crate::sync::atomic::{AtomicBool, Ordering};
use crate::sys::os::errno; use crate::sys::os::errno;

View file

@ -9,12 +9,14 @@ use crate::time::Duration;
#[cfg(any(target_os = "linux", target_os = "solaris", target_os = "illumos"))] #[cfg(any(target_os = "linux", target_os = "solaris", target_os = "illumos"))]
use crate::sys::weak::weak; use crate::sys::weak::weak;
#[cfg(not(any(target_os = "l4re", target_os = "vxworks")))] #[cfg(not(any(target_os = "l4re", target_os = "vxworks", target_os = "espidf")))]
pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024;
#[cfg(target_os = "l4re")] #[cfg(target_os = "l4re")]
pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024; pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
#[cfg(target_os = "vxworks")] #[cfg(target_os = "vxworks")]
pub const DEFAULT_MIN_STACK_SIZE: usize = 256 * 1024; pub const DEFAULT_MIN_STACK_SIZE: usize = 256 * 1024;
#[cfg(target_os = "espidf")]
pub const DEFAULT_MIN_STACK_SIZE: usize = 0; // 0 indicates that the stack size configured in the ESP-IDF menuconfig system should be used
#[cfg(target_os = "fuchsia")] #[cfg(target_os = "fuchsia")]
mod zircon { mod zircon {
@ -50,22 +52,35 @@ impl Thread {
let mut attr: libc::pthread_attr_t = mem::zeroed(); let mut attr: libc::pthread_attr_t = mem::zeroed();
assert_eq!(libc::pthread_attr_init(&mut attr), 0); assert_eq!(libc::pthread_attr_init(&mut attr), 0);
let stack_size = cmp::max(stack, min_stack_size(&attr)); #[cfg(target_os = "espidf")]
if stack > 0 {
// Only set the stack if a non-zero value is passed
// 0 is used as an indication that the default stack size configured in the ESP-IDF menuconfig system should be used
assert_eq!(
libc::pthread_attr_setstacksize(&mut attr, cmp::max(stack, min_stack_size(&attr))),
0
);
}
match libc::pthread_attr_setstacksize(&mut attr, stack_size) { #[cfg(not(target_os = "espidf"))]
0 => {} {
n => { let stack_size = cmp::max(stack, min_stack_size(&attr));
assert_eq!(n, libc::EINVAL);
// EINVAL means |stack_size| is either too small or not a match libc::pthread_attr_setstacksize(&mut attr, stack_size) {
// multiple of the system page size. Because it's definitely 0 => {}
// >= PTHREAD_STACK_MIN, it must be an alignment issue. n => {
// Round up to the nearest page and try again. assert_eq!(n, libc::EINVAL);
let page_size = os::page_size(); // EINVAL means |stack_size| is either too small or not a
let stack_size = // multiple of the system page size. Because it's definitely
(stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1); // >= PTHREAD_STACK_MIN, it must be an alignment issue.
assert_eq!(libc::pthread_attr_setstacksize(&mut attr, stack_size), 0); // Round up to the nearest page and try again.
} let page_size = os::page_size();
}; let stack_size =
(stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1);
assert_eq!(libc::pthread_attr_setstacksize(&mut attr, stack_size), 0);
}
};
}
let ret = libc::pthread_create(&mut native, &attr, thread_start, p as *mut _); let ret = libc::pthread_create(&mut native, &attr, thread_start, p as *mut _);
// Note: if the thread creation fails and this assert fails, then p will // Note: if the thread creation fails and this assert fails, then p will
@ -183,6 +198,7 @@ impl Thread {
// Newlib, Emscripten, and VxWorks have no way to set a thread name. // Newlib, Emscripten, and VxWorks have no way to set a thread name.
} }
#[cfg(not(target_os = "espidf"))]
pub fn sleep(dur: Duration) { pub fn sleep(dur: Duration) {
let mut secs = dur.as_secs(); let mut secs = dur.as_secs();
let mut nsecs = dur.subsec_nanos() as _; let mut nsecs = dur.subsec_nanos() as _;
@ -208,6 +224,19 @@ impl Thread {
} }
} }
#[cfg(target_os = "espidf")]
pub fn sleep(dur: Duration) {
let mut micros = dur.as_micros();
unsafe {
while micros > 0 {
let st = if micros > u32::MAX as u128 { u32::MAX } else { micros as u32 };
libc::usleep(st);
micros -= st as u128;
}
}
}
pub fn join(self) { pub fn join(self) {
unsafe { unsafe {
let ret = libc::pthread_join(self.id, ptr::null_mut()); let ret = libc::pthread_join(self.id, ptr::null_mut());

View file

@ -361,9 +361,9 @@ mod inner {
} }
} }
#[cfg(not(target_os = "dragonfly"))] #[cfg(not(any(target_os = "dragonfly", target_os = "espidf")))]
pub type clock_t = libc::c_int; pub type clock_t = libc::c_int;
#[cfg(target_os = "dragonfly")] #[cfg(any(target_os = "dragonfly", target_os = "espidf"))]
pub type clock_t = libc::c_ulong; pub type clock_t = libc::c_ulong;
fn now(clock: clock_t) -> Timespec { fn now(clock: clock_t) -> Timespec {

View file

@ -1,4 +1,6 @@
pub const DEFAULT_BUF_SIZE: usize = 8 * 1024; // Bare metal platforms usually have very small amounts of RAM
// (in the order of hundreds of KB)
pub const DEFAULT_BUF_SIZE: usize = if cfg!(target_os = "espidf") { 512 } else { 8 * 1024 };
#[cfg(test)] #[cfg(test)]
#[allow(dead_code)] // not used on emscripten #[allow(dead_code)] // not used on emscripten

View file

@ -13,6 +13,7 @@ cfg_if::cfg_if! {
} else if #[cfg(any( } else if #[cfg(any(
target_os = "l4re", target_os = "l4re",
target_os = "none", target_os = "none",
target_os = "espidf",
))] { ))] {
// These "unix" family members do not have unwinder. // These "unix" family members do not have unwinder.
// Note this also matches x86_64-unknown-none-linuxkernel. // Note this also matches x86_64-unknown-none-linuxkernel.

View file

@ -256,6 +256,7 @@ target | std | host | notes
`powerpc64le-unknown-linux-musl` | ? | | `powerpc64le-unknown-linux-musl` | ? | |
`riscv32gc-unknown-linux-gnu` | | | RISC-V Linux (kernel 5.4, glibc 2.33) `riscv32gc-unknown-linux-gnu` | | | RISC-V Linux (kernel 5.4, glibc 2.33)
`riscv32gc-unknown-linux-musl` | | | RISC-V Linux (kernel 5.4, musl + RISCV32 support patches) `riscv32gc-unknown-linux-musl` | | | RISC-V Linux (kernel 5.4, musl + RISCV32 support patches)
`riscv32imc-esp-espidf` | ✓ | | RISC-V ESP-IDF
`riscv64gc-unknown-linux-musl` | | | RISC-V Linux (kernel 4.20, musl 1.2.0) `riscv64gc-unknown-linux-musl` | | | RISC-V Linux (kernel 4.20, musl 1.2.0)
`s390x-unknown-linux-musl` | | | S390x Linux (kernel 2.6.32, MUSL) `s390x-unknown-linux-musl` | | | S390x Linux (kernel 2.6.32, MUSL)
`sparc-unknown-linux-gnu` | ✓ | | 32-bit SPARC Linux `sparc-unknown-linux-gnu` | ✓ | | 32-bit SPARC Linux