20745264ce
Though CloudABI is strongly inspired by POSIX, its absence of features that don't work well with capability-based sandboxing makes it different enough that adding bits to sys/unix will make things a mess. This change therefore adds CloudABI specific platform code under sys/cloudabi and borrows parts from sys/unix that can be used without changes. One of the goals of this implementation is to build as much as possible directly on top of CloudABI's system call layer, as opposed to using the C library. This is preferred, as the system call layer is supposed to be stable, whereas the C library ABI technically is not. An advantage of this approach is that it allows us to implement certain interfaces, such as mutexes and condition variables more optimally. They can be lighter than the ones provided by pthreads. This change disables some modules that cannot realistically be implemented right now. For example, libstd's pathname abstraction is not designed with POSIX *at() (e.g., openat()) in mind. The *at() functions are the only set of file system APIs available on CloudABI. There is no global file system namespace, nor a process working directory. Discussions on how to port these modules over are outside the scope of this change. Apart from this change, there are still some other minor fixups that need to be made to platform independent code to make things build. These will be sent out separately, so they can be reviewed more thoroughly.
80 lines
2.0 KiB
Rust
80 lines
2.0 KiB
Rust
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use io;
|
|
use sys::cloudabi::abi;
|
|
|
|
pub struct Stdin(());
|
|
pub struct Stdout(());
|
|
pub struct Stderr(());
|
|
|
|
impl Stdin {
|
|
pub fn new() -> io::Result<Stdin> {
|
|
Ok(Stdin(()))
|
|
}
|
|
|
|
pub fn read(&self, _: &mut [u8]) -> io::Result<usize> {
|
|
Ok(0)
|
|
}
|
|
}
|
|
|
|
impl Stdout {
|
|
pub fn new() -> io::Result<Stdout> {
|
|
Ok(Stdout(()))
|
|
}
|
|
|
|
pub fn write(&self, _: &[u8]) -> io::Result<usize> {
|
|
Err(io::Error::new(
|
|
io::ErrorKind::BrokenPipe,
|
|
"Stdout is not connected to any output in this environment",
|
|
))
|
|
}
|
|
|
|
pub fn flush(&self) -> io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Stderr {
|
|
pub fn new() -> io::Result<Stderr> {
|
|
Ok(Stderr(()))
|
|
}
|
|
|
|
pub fn write(&self, _: &[u8]) -> io::Result<usize> {
|
|
Err(io::Error::new(
|
|
io::ErrorKind::BrokenPipe,
|
|
"Stderr is not connected to any output in this environment",
|
|
))
|
|
}
|
|
|
|
pub fn flush(&self) -> io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// FIXME: right now this raw stderr handle is used in a few places because
|
|
// std::io::stderr_raw isn't exposed, but once that's exposed this impl
|
|
// should go away
|
|
impl io::Write for Stderr {
|
|
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
|
|
Stderr::write(self, data)
|
|
}
|
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
Stderr::flush(self)
|
|
}
|
|
}
|
|
|
|
pub fn is_ebadf(err: &io::Error) -> bool {
|
|
err.raw_os_error() == Some(abi::errno::BADF as i32)
|
|
}
|
|
|
|
pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
|