Importing rustc-1.56.0
Change-Id: I98941481270706fa55f8fb2cb91686ae3bd30f38
diff --git a/library/std/src/sys/wasi/fd.rs b/library/std/src/sys/wasi/fd.rs
index ba66eba..e4f4456 100644
--- a/library/std/src/sys/wasi/fd.rs
+++ b/library/std/src/sys/wasi/fd.rs
@@ -5,10 +5,12 @@
use crate::io::{self, IoSlice, IoSliceMut, SeekFrom};
use crate::mem;
use crate::net::Shutdown;
+use crate::os::wasi::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
+use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
#[derive(Debug)]
pub struct WasiFd {
- fd: wasi::Fd,
+ fd: OwnedFd,
}
fn iovec<'a>(a: &'a mut [IoSliceMut<'_>]) -> &'a [wasi::Iovec] {
@@ -26,38 +28,26 @@
}
impl WasiFd {
- pub unsafe fn from_raw(fd: wasi::Fd) -> WasiFd {
- WasiFd { fd }
- }
-
- pub fn into_raw(self) -> wasi::Fd {
- let ret = self.fd;
- mem::forget(self);
- ret
- }
-
- pub fn as_raw(&self) -> wasi::Fd {
- self.fd
- }
-
pub fn datasync(&self) -> io::Result<()> {
- unsafe { wasi::fd_datasync(self.fd).map_err(err2io) }
+ unsafe { wasi::fd_datasync(self.as_raw_fd() as wasi::Fd).map_err(err2io) }
}
pub fn pread(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
- unsafe { wasi::fd_pread(self.fd, iovec(bufs), offset).map_err(err2io) }
+ unsafe { wasi::fd_pread(self.as_raw_fd() as wasi::Fd, iovec(bufs), offset).map_err(err2io) }
}
pub fn pwrite(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
- unsafe { wasi::fd_pwrite(self.fd, ciovec(bufs), offset).map_err(err2io) }
+ unsafe {
+ wasi::fd_pwrite(self.as_raw_fd() as wasi::Fd, ciovec(bufs), offset).map_err(err2io)
+ }
}
pub fn read(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
- unsafe { wasi::fd_read(self.fd, iovec(bufs)).map_err(err2io) }
+ unsafe { wasi::fd_read(self.as_raw_fd() as wasi::Fd, iovec(bufs)).map_err(err2io) }
}
pub fn write(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
- unsafe { wasi::fd_write(self.fd, ciovec(bufs)).map_err(err2io) }
+ unsafe { wasi::fd_write(self.as_raw_fd() as wasi::Fd, ciovec(bufs)).map_err(err2io) }
}
pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> {
@@ -66,37 +56,42 @@
SeekFrom::End(pos) => (wasi::WHENCE_END, pos),
SeekFrom::Current(pos) => (wasi::WHENCE_CUR, pos),
};
- unsafe { wasi::fd_seek(self.fd, offset, whence).map_err(err2io) }
+ unsafe { wasi::fd_seek(self.as_raw_fd() as wasi::Fd, offset, whence).map_err(err2io) }
}
pub fn tell(&self) -> io::Result<u64> {
- unsafe { wasi::fd_tell(self.fd).map_err(err2io) }
+ unsafe { wasi::fd_tell(self.as_raw_fd() as wasi::Fd).map_err(err2io) }
}
// FIXME: __wasi_fd_fdstat_get
pub fn set_flags(&self, flags: wasi::Fdflags) -> io::Result<()> {
- unsafe { wasi::fd_fdstat_set_flags(self.fd, flags).map_err(err2io) }
+ unsafe { wasi::fd_fdstat_set_flags(self.as_raw_fd() as wasi::Fd, flags).map_err(err2io) }
}
pub fn set_rights(&self, base: wasi::Rights, inheriting: wasi::Rights) -> io::Result<()> {
- unsafe { wasi::fd_fdstat_set_rights(self.fd, base, inheriting).map_err(err2io) }
+ unsafe {
+ wasi::fd_fdstat_set_rights(self.as_raw_fd() as wasi::Fd, base, inheriting)
+ .map_err(err2io)
+ }
}
pub fn sync(&self) -> io::Result<()> {
- unsafe { wasi::fd_sync(self.fd).map_err(err2io) }
+ unsafe { wasi::fd_sync(self.as_raw_fd() as wasi::Fd).map_err(err2io) }
}
pub fn advise(&self, offset: u64, len: u64, advice: wasi::Advice) -> io::Result<()> {
- unsafe { wasi::fd_advise(self.fd, offset, len, advice).map_err(err2io) }
+ unsafe {
+ wasi::fd_advise(self.as_raw_fd() as wasi::Fd, offset, len, advice).map_err(err2io)
+ }
}
pub fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
- unsafe { wasi::fd_allocate(self.fd, offset, len).map_err(err2io) }
+ unsafe { wasi::fd_allocate(self.as_raw_fd() as wasi::Fd, offset, len).map_err(err2io) }
}
pub fn create_directory(&self, path: &str) -> io::Result<()> {
- unsafe { wasi::path_create_directory(self.fd, path).map_err(err2io) }
+ unsafe { wasi::path_create_directory(self.as_raw_fd() as wasi::Fd, path).map_err(err2io) }
}
pub fn link(
@@ -107,7 +102,14 @@
new_path: &str,
) -> io::Result<()> {
unsafe {
- wasi::path_link(self.fd, old_flags, old_path, new_fd.fd, new_path).map_err(err2io)
+ wasi::path_link(
+ self.as_raw_fd() as wasi::Fd,
+ old_flags,
+ old_path,
+ new_fd.as_raw_fd() as wasi::Fd,
+ new_path,
+ )
+ .map_err(err2io)
}
}
@@ -122,7 +124,7 @@
) -> io::Result<WasiFd> {
unsafe {
wasi::path_open(
- self.fd,
+ self.as_raw_fd() as wasi::Fd,
dirflags,
path,
oflags,
@@ -130,25 +132,39 @@
fs_rights_inheriting,
fs_flags,
)
- .map(|fd| WasiFd::from_raw(fd))
+ .map(|fd| WasiFd::from_raw_fd(fd as RawFd))
.map_err(err2io)
}
}
pub fn readdir(&self, buf: &mut [u8], cookie: wasi::Dircookie) -> io::Result<usize> {
- unsafe { wasi::fd_readdir(self.fd, buf.as_mut_ptr(), buf.len(), cookie).map_err(err2io) }
+ unsafe {
+ wasi::fd_readdir(self.as_raw_fd() as wasi::Fd, buf.as_mut_ptr(), buf.len(), cookie)
+ .map_err(err2io)
+ }
}
pub fn readlink(&self, path: &str, buf: &mut [u8]) -> io::Result<usize> {
- unsafe { wasi::path_readlink(self.fd, path, buf.as_mut_ptr(), buf.len()).map_err(err2io) }
+ unsafe {
+ wasi::path_readlink(self.as_raw_fd() as wasi::Fd, path, buf.as_mut_ptr(), buf.len())
+ .map_err(err2io)
+ }
}
pub fn rename(&self, old_path: &str, new_fd: &WasiFd, new_path: &str) -> io::Result<()> {
- unsafe { wasi::path_rename(self.fd, old_path, new_fd.fd, new_path).map_err(err2io) }
+ unsafe {
+ wasi::path_rename(
+ self.as_raw_fd() as wasi::Fd,
+ old_path,
+ new_fd.as_raw_fd() as wasi::Fd,
+ new_path,
+ )
+ .map_err(err2io)
+ }
}
pub fn filestat_get(&self) -> io::Result<wasi::Filestat> {
- unsafe { wasi::fd_filestat_get(self.fd).map_err(err2io) }
+ unsafe { wasi::fd_filestat_get(self.as_raw_fd() as wasi::Fd).map_err(err2io) }
}
pub fn filestat_set_times(
@@ -157,11 +173,14 @@
mtim: wasi::Timestamp,
fstflags: wasi::Fstflags,
) -> io::Result<()> {
- unsafe { wasi::fd_filestat_set_times(self.fd, atim, mtim, fstflags).map_err(err2io) }
+ unsafe {
+ wasi::fd_filestat_set_times(self.as_raw_fd() as wasi::Fd, atim, mtim, fstflags)
+ .map_err(err2io)
+ }
}
pub fn filestat_set_size(&self, size: u64) -> io::Result<()> {
- unsafe { wasi::fd_filestat_set_size(self.fd, size).map_err(err2io) }
+ unsafe { wasi::fd_filestat_set_size(self.as_raw_fd() as wasi::Fd, size).map_err(err2io) }
}
pub fn path_filestat_get(
@@ -169,7 +188,9 @@
flags: wasi::Lookupflags,
path: &str,
) -> io::Result<wasi::Filestat> {
- unsafe { wasi::path_filestat_get(self.fd, flags, path).map_err(err2io) }
+ unsafe {
+ wasi::path_filestat_get(self.as_raw_fd() as wasi::Fd, flags, path).map_err(err2io)
+ }
}
pub fn path_filestat_set_times(
@@ -181,21 +202,30 @@
fstflags: wasi::Fstflags,
) -> io::Result<()> {
unsafe {
- wasi::path_filestat_set_times(self.fd, flags, path, atim, mtim, fstflags)
- .map_err(err2io)
+ wasi::path_filestat_set_times(
+ self.as_raw_fd() as wasi::Fd,
+ flags,
+ path,
+ atim,
+ mtim,
+ fstflags,
+ )
+ .map_err(err2io)
}
}
pub fn symlink(&self, old_path: &str, new_path: &str) -> io::Result<()> {
- unsafe { wasi::path_symlink(old_path, self.fd, new_path).map_err(err2io) }
+ unsafe {
+ wasi::path_symlink(old_path, self.as_raw_fd() as wasi::Fd, new_path).map_err(err2io)
+ }
}
pub fn unlink_file(&self, path: &str) -> io::Result<()> {
- unsafe { wasi::path_unlink_file(self.fd, path).map_err(err2io) }
+ unsafe { wasi::path_unlink_file(self.as_raw_fd() as wasi::Fd, path).map_err(err2io) }
}
pub fn remove_directory(&self, path: &str) -> io::Result<()> {
- unsafe { wasi::path_remove_directory(self.fd, path).map_err(err2io) }
+ unsafe { wasi::path_remove_directory(self.as_raw_fd() as wasi::Fd, path).map_err(err2io) }
}
pub fn sock_recv(
@@ -203,11 +233,15 @@
ri_data: &mut [IoSliceMut<'_>],
ri_flags: wasi::Riflags,
) -> io::Result<(usize, wasi::Roflags)> {
- unsafe { wasi::sock_recv(self.fd, iovec(ri_data), ri_flags).map_err(err2io) }
+ unsafe {
+ wasi::sock_recv(self.as_raw_fd() as wasi::Fd, iovec(ri_data), ri_flags).map_err(err2io)
+ }
}
pub fn sock_send(&self, si_data: &[IoSlice<'_>], si_flags: wasi::Siflags) -> io::Result<usize> {
- unsafe { wasi::sock_send(self.fd, ciovec(si_data), si_flags).map_err(err2io) }
+ unsafe {
+ wasi::sock_send(self.as_raw_fd() as wasi::Fd, ciovec(si_data), si_flags).map_err(err2io)
+ }
}
pub fn sock_shutdown(&self, how: Shutdown) -> io::Result<()> {
@@ -216,14 +250,54 @@
Shutdown::Write => wasi::SDFLAGS_WR,
Shutdown::Both => wasi::SDFLAGS_WR | wasi::SDFLAGS_RD,
};
- unsafe { wasi::sock_shutdown(self.fd, how).map_err(err2io) }
+ unsafe { wasi::sock_shutdown(self.as_raw_fd() as wasi::Fd, how).map_err(err2io) }
}
}
-impl Drop for WasiFd {
- fn drop(&mut self) {
- // FIXME: can we handle the return code here even though we can't on
- // unix?
- let _ = unsafe { wasi::fd_close(self.fd) };
+impl AsInner<OwnedFd> for WasiFd {
+ fn as_inner(&self) -> &OwnedFd {
+ &self.fd
+ }
+}
+
+impl AsInnerMut<OwnedFd> for WasiFd {
+ fn as_inner_mut(&mut self) -> &mut OwnedFd {
+ &mut self.fd
+ }
+}
+
+impl IntoInner<OwnedFd> for WasiFd {
+ fn into_inner(self) -> OwnedFd {
+ self.fd
+ }
+}
+
+impl FromInner<OwnedFd> for WasiFd {
+ fn from_inner(owned_fd: OwnedFd) -> Self {
+ Self { fd: owned_fd }
+ }
+}
+
+impl AsFd for WasiFd {
+ fn as_fd(&self) -> BorrowedFd<'_> {
+ self.fd.as_fd()
+ }
+}
+
+impl AsRawFd for WasiFd {
+ fn as_raw_fd(&self) -> RawFd {
+ self.fd.as_raw_fd()
+ }
+}
+
+impl IntoRawFd for WasiFd {
+ fn into_raw_fd(self) -> RawFd {
+ self.fd.into_raw_fd()
+ }
+}
+
+impl FromRawFd for WasiFd {
+ unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
+ unsafe { Self { fd: FromRawFd::from_raw_fd(raw_fd) } }
}
}
