wasmer_wasi/state/
types.rs

1/// types for use in the WASI filesystem
2#[cfg(feature = "enable-serde")]
3use serde::{Deserialize, Serialize};
4#[cfg(all(unix, feature = "sys-poll"))]
5use std::convert::TryInto;
6use std::{
7    collections::VecDeque,
8    io::{self, Read, Seek, Write},
9    sync::{Arc, Mutex},
10    time::Duration,
11};
12use wasmer_vbus::BusError;
13use wasmer_wasi_types::wasi::{BusErrno, Errno};
14
15#[cfg(feature = "host-fs")]
16pub use wasmer_vfs::host_fs::{Stderr, Stdin, Stdout};
17#[cfg(feature = "mem-fs")]
18pub use wasmer_vfs::mem_fs::{Stderr, Stdin, Stdout};
19
20use wasmer_vfs::{FsError, VirtualFile};
21use wasmer_vnet::NetworkError;
22
23pub fn fs_error_from_wasi_err(err: Errno) -> FsError {
24    match err {
25        Errno::Badf => FsError::InvalidFd,
26        Errno::Exist => FsError::AlreadyExists,
27        Errno::Io => FsError::IOError,
28        Errno::Addrinuse => FsError::AddressInUse,
29        Errno::Addrnotavail => FsError::AddressNotAvailable,
30        Errno::Pipe => FsError::BrokenPipe,
31        Errno::Connaborted => FsError::ConnectionAborted,
32        Errno::Connrefused => FsError::ConnectionRefused,
33        Errno::Connreset => FsError::ConnectionReset,
34        Errno::Intr => FsError::Interrupted,
35        Errno::Inval => FsError::InvalidInput,
36        Errno::Notconn => FsError::NotConnected,
37        Errno::Nodev => FsError::NoDevice,
38        Errno::Noent => FsError::EntityNotFound,
39        Errno::Perm => FsError::PermissionDenied,
40        Errno::Timedout => FsError::TimedOut,
41        Errno::Proto => FsError::UnexpectedEof,
42        Errno::Again => FsError::WouldBlock,
43        Errno::Nospc => FsError::WriteZero,
44        Errno::Notempty => FsError::DirectoryNotEmpty,
45        _ => FsError::UnknownError,
46    }
47}
48
49pub fn fs_error_into_wasi_err(fs_error: FsError) -> Errno {
50    match fs_error {
51        FsError::AlreadyExists => Errno::Exist,
52        FsError::AddressInUse => Errno::Addrinuse,
53        FsError::AddressNotAvailable => Errno::Addrnotavail,
54        FsError::BaseNotDirectory => Errno::Notdir,
55        FsError::BrokenPipe => Errno::Pipe,
56        FsError::ConnectionAborted => Errno::Connaborted,
57        FsError::ConnectionRefused => Errno::Connrefused,
58        FsError::ConnectionReset => Errno::Connreset,
59        FsError::Interrupted => Errno::Intr,
60        FsError::InvalidData => Errno::Io,
61        FsError::InvalidFd => Errno::Badf,
62        FsError::InvalidInput => Errno::Inval,
63        FsError::IOError => Errno::Io,
64        FsError::NoDevice => Errno::Nodev,
65        FsError::NotAFile => Errno::Inval,
66        FsError::NotConnected => Errno::Notconn,
67        FsError::EntityNotFound => Errno::Noent,
68        FsError::PermissionDenied => Errno::Perm,
69        FsError::TimedOut => Errno::Timedout,
70        FsError::UnexpectedEof => Errno::Proto,
71        FsError::WouldBlock => Errno::Again,
72        FsError::WriteZero => Errno::Nospc,
73        FsError::DirectoryNotEmpty => Errno::Notempty,
74        FsError::Lock | FsError::UnknownError => Errno::Io,
75    }
76}
77
78pub fn net_error_into_wasi_err(net_error: NetworkError) -> Errno {
79    match net_error {
80        NetworkError::InvalidFd => Errno::Badf,
81        NetworkError::AlreadyExists => Errno::Exist,
82        NetworkError::Lock => Errno::Io,
83        NetworkError::IOError => Errno::Io,
84        NetworkError::AddressInUse => Errno::Addrinuse,
85        NetworkError::AddressNotAvailable => Errno::Addrnotavail,
86        NetworkError::BrokenPipe => Errno::Pipe,
87        NetworkError::ConnectionAborted => Errno::Connaborted,
88        NetworkError::ConnectionRefused => Errno::Connrefused,
89        NetworkError::ConnectionReset => Errno::Connreset,
90        NetworkError::Interrupted => Errno::Intr,
91        NetworkError::InvalidData => Errno::Io,
92        NetworkError::InvalidInput => Errno::Inval,
93        NetworkError::NotConnected => Errno::Notconn,
94        NetworkError::NoDevice => Errno::Nodev,
95        NetworkError::PermissionDenied => Errno::Perm,
96        NetworkError::TimedOut => Errno::Timedout,
97        NetworkError::UnexpectedEof => Errno::Proto,
98        NetworkError::WouldBlock => Errno::Again,
99        NetworkError::WriteZero => Errno::Nospc,
100        NetworkError::Unsupported => Errno::Notsup,
101        NetworkError::UnknownError => Errno::Io,
102    }
103}
104
105pub fn bus_error_into_wasi_err(bus_error: BusError) -> BusErrno {
106    use BusError::*;
107    match bus_error {
108        Serialization => BusErrno::Ser,
109        Deserialization => BusErrno::Des,
110        InvalidWapm => BusErrno::Wapm,
111        FetchFailed => BusErrno::Fetch,
112        CompileError => BusErrno::Compile,
113        InvalidABI => BusErrno::Abi,
114        Aborted => BusErrno::Aborted,
115        BadHandle => BusErrno::Badhandle,
116        InvalidTopic => BusErrno::Topic,
117        BadCallback => BusErrno::Badcb,
118        Unsupported => BusErrno::Unsupported,
119        BadRequest => BusErrno::Badrequest,
120        AccessDenied => BusErrno::Denied,
121        InternalError => BusErrno::Internal,
122        MemoryAllocationFailed => BusErrno::Alloc,
123        InvokeFailed => BusErrno::Invoke,
124        AlreadyConsumed => BusErrno::Consumed,
125        MemoryAccessViolation => BusErrno::Memviolation,
126        UnknownError => BusErrno::Unknown,
127    }
128}
129
130pub fn wasi_error_into_bus_err(bus_error: BusErrno) -> BusError {
131    use BusError::*;
132    match bus_error {
133        BusErrno::Success => UnknownError,
134        BusErrno::Ser => Serialization,
135        BusErrno::Des => Deserialization,
136        BusErrno::Wapm => InvalidWapm,
137        BusErrno::Fetch => FetchFailed,
138        BusErrno::Compile => CompileError,
139        BusErrno::Abi => InvalidABI,
140        BusErrno::Aborted => Aborted,
141        BusErrno::Badhandle => BadHandle,
142        BusErrno::Topic => InvalidTopic,
143        BusErrno::Badcb => BadCallback,
144        BusErrno::Unsupported => Unsupported,
145        BusErrno::Badrequest => BadRequest,
146        BusErrno::Denied => AccessDenied,
147        BusErrno::Internal => InternalError,
148        BusErrno::Alloc => MemoryAllocationFailed,
149        BusErrno::Invoke => InvokeFailed,
150        BusErrno::Consumed => AlreadyConsumed,
151        BusErrno::Memviolation => MemoryAccessViolation,
152        BusErrno::Unknown => UnknownError,
153    }
154}
155
156#[derive(Debug, Clone)]
157#[allow(clippy::enum_variant_names)]
158pub enum PollEvent {
159    /// Data available to read
160    PollIn = 1,
161    /// Data available to write (will still block if data is greater than space available unless
162    /// the fd is configured to not block)
163    PollOut = 2,
164    /// Something didn't work. ignored as input
165    PollError = 4,
166    /// Connection closed. ignored as input
167    PollHangUp = 8,
168    /// Invalid request. ignored as input
169    PollInvalid = 16,
170}
171
172impl PollEvent {
173    fn from_i16(raw_num: i16) -> Option<PollEvent> {
174        Some(match raw_num {
175            1 => PollEvent::PollIn,
176            2 => PollEvent::PollOut,
177            4 => PollEvent::PollError,
178            8 => PollEvent::PollHangUp,
179            16 => PollEvent::PollInvalid,
180            _ => return None,
181        })
182    }
183}
184
185#[derive(Debug, Clone)]
186pub struct PollEventBuilder {
187    inner: PollEventSet,
188}
189
190pub type PollEventSet = i16;
191
192#[derive(Debug)]
193pub struct PollEventIter {
194    pes: PollEventSet,
195    i: usize,
196}
197
198impl Iterator for PollEventIter {
199    type Item = PollEvent;
200
201    fn next(&mut self) -> Option<Self::Item> {
202        if self.pes == 0 || self.i > 15 {
203            None
204        } else {
205            while self.i < 16 {
206                let result = PollEvent::from_i16(self.pes & (1 << self.i));
207                self.pes &= !(1 << self.i);
208                self.i += 1;
209                if let Some(r) = result {
210                    return Some(r);
211                }
212            }
213            unreachable!("Internal logic error in PollEventIter");
214        }
215    }
216}
217
218pub fn iterate_poll_events(pes: PollEventSet) -> PollEventIter {
219    PollEventIter { pes, i: 0 }
220}
221
222#[cfg(all(unix, feature = "sys-poll"))]
223fn poll_event_set_to_platform_poll_events(mut pes: PollEventSet) -> i16 {
224    let mut out = 0;
225    for i in 0..16 {
226        out |= match PollEvent::from_i16(pes & (1 << i)) {
227            Some(PollEvent::PollIn) => libc::POLLIN,
228            Some(PollEvent::PollOut) => libc::POLLOUT,
229            Some(PollEvent::PollError) => libc::POLLERR,
230            Some(PollEvent::PollHangUp) => libc::POLLHUP,
231            Some(PollEvent::PollInvalid) => libc::POLLNVAL,
232            _ => 0,
233        };
234        pes &= !(1 << i);
235    }
236    out
237}
238
239#[cfg(all(unix, feature = "sys-poll"))]
240fn platform_poll_events_to_pollevent_set(mut num: i16) -> PollEventSet {
241    let mut peb = PollEventBuilder::new();
242    for i in 0..16 {
243        peb = match num & (1 << i) {
244            libc::POLLIN => peb.add(PollEvent::PollIn),
245            libc::POLLOUT => peb.add(PollEvent::PollOut),
246            libc::POLLERR => peb.add(PollEvent::PollError),
247            libc::POLLHUP => peb.add(PollEvent::PollHangUp),
248            libc::POLLNVAL => peb.add(PollEvent::PollInvalid),
249            _ => peb,
250        };
251        num &= !(1 << i);
252    }
253    peb.build()
254}
255
256#[allow(dead_code)]
257impl PollEventBuilder {
258    pub fn new() -> PollEventBuilder {
259        PollEventBuilder { inner: 0 }
260    }
261
262    pub fn add(mut self, event: PollEvent) -> PollEventBuilder {
263        self.inner |= event as PollEventSet;
264        self
265    }
266
267    pub fn build(self) -> PollEventSet {
268        self.inner
269    }
270}
271
272#[cfg(all(unix, feature = "sys-poll"))]
273pub(crate) fn poll(
274    selfs: &[&(dyn VirtualFile + Send + Sync + 'static)],
275    events: &[PollEventSet],
276    seen_events: &mut [PollEventSet],
277    timeout: Duration,
278) -> Result<u32, FsError> {
279    if !(selfs.len() == events.len() && events.len() == seen_events.len()) {
280        return Err(FsError::InvalidInput);
281    }
282    let mut fds = selfs
283        .iter()
284        .enumerate()
285        .filter_map(|(i, s)| s.get_fd().map(|rfd| (i, rfd)))
286        .map(|(i, host_fd)| libc::pollfd {
287            fd: host_fd.try_into().unwrap(),
288            events: poll_event_set_to_platform_poll_events(events[i]),
289            revents: 0,
290        })
291        .collect::<Vec<_>>();
292    let result = unsafe {
293        libc::poll(
294            fds.as_mut_ptr(),
295            selfs.len() as _,
296            timeout.as_millis() as i32,
297        )
298    };
299
300    if result < 0 {
301        // TODO: check errno and return value
302        return Err(FsError::IOError);
303    }
304    // convert result and write back values
305    for (i, fd) in fds.into_iter().enumerate() {
306        seen_events[i] = platform_poll_events_to_pollevent_set(fd.revents);
307    }
308    // unwrap is safe because we check for negative values above
309    Ok(result.try_into().unwrap())
310}
311
312#[cfg(any(not(unix), not(feature = "sys-poll")))]
313pub(crate) fn poll(
314    files: &[&(dyn VirtualFile + Send + Sync + 'static)],
315    events: &[PollEventSet],
316    seen_events: &mut [PollEventSet],
317    timeout: Duration,
318) -> Result<u32, FsError> {
319    if !(files.len() == events.len() && events.len() == seen_events.len()) {
320        tracing::debug!("the slice length of 'files', 'events' and 'seen_events' must be the same (files={}, events={}, seen_events={})", files.len(), events.len(), seen_events.len());
321        return Err(FsError::InvalidInput);
322    }
323
324    let mut ret = 0;
325    for n in 0..files.len() {
326        let mut builder = PollEventBuilder::new();
327
328        let file = files[n];
329        let can_read = file.bytes_available_read()?.map(|_| true).unwrap_or(false);
330        let can_write = file
331            .bytes_available_write()?
332            .map(|s| s > 0)
333            .unwrap_or(false);
334        let is_closed = file.is_open() == false;
335
336        tracing::debug!(
337            "poll_evt can_read={} can_write={} is_closed={}",
338            can_read,
339            can_write,
340            is_closed
341        );
342
343        for event in iterate_poll_events(events[n]) {
344            match event {
345                PollEvent::PollIn if can_read => {
346                    builder = builder.add(PollEvent::PollIn);
347                }
348                PollEvent::PollOut if can_write => {
349                    builder = builder.add(PollEvent::PollOut);
350                }
351                PollEvent::PollHangUp if is_closed => {
352                    builder = builder.add(PollEvent::PollHangUp);
353                }
354                PollEvent::PollInvalid if is_closed => {
355                    builder = builder.add(PollEvent::PollInvalid);
356                }
357                PollEvent::PollError if is_closed => {
358                    builder = builder.add(PollEvent::PollError);
359                }
360                _ => {}
361            }
362        }
363        let revents = builder.build();
364        if revents != 0 {
365            ret += 1;
366        }
367        seen_events[n] = revents;
368    }
369
370    if ret == 0 && timeout > Duration::ZERO {
371        return Err(FsError::WouldBlock);
372    }
373
374    Ok(ret)
375}
376
377pub trait WasiPath {}
378
379/// For piping stdio. Stores all output / input in a byte-vector.
380#[derive(Debug, Clone, Default)]
381#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
382pub struct Pipe {
383    buffer: Arc<Mutex<VecDeque<u8>>>,
384}
385
386impl Pipe {
387    pub fn new() -> Self {
388        Self::default()
389    }
390}
391
392impl Read for Pipe {
393    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
394        let mut buffer = self.buffer.lock().unwrap();
395        let amt = std::cmp::min(buf.len(), buffer.len());
396        let buf_iter = buffer.drain(..amt).enumerate();
397        for (i, byte) in buf_iter {
398            buf[i] = byte;
399        }
400        Ok(amt)
401    }
402}
403
404impl Write for Pipe {
405    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
406        let mut buffer = self.buffer.lock().unwrap();
407        buffer.extend(buf);
408        Ok(buf.len())
409    }
410    fn flush(&mut self) -> io::Result<()> {
411        Ok(())
412    }
413}
414
415impl Seek for Pipe {
416    fn seek(&mut self, _pos: io::SeekFrom) -> io::Result<u64> {
417        Err(io::Error::new(
418            io::ErrorKind::Other,
419            "can not seek in a pipe",
420        ))
421    }
422}
423
424//#[cfg_attr(feature = "enable-serde", typetag::serde)]
425impl VirtualFile for Pipe {
426    fn last_accessed(&self) -> u64 {
427        0
428    }
429    fn last_modified(&self) -> u64 {
430        0
431    }
432    fn created_time(&self) -> u64 {
433        0
434    }
435    fn size(&self) -> u64 {
436        let buffer = self.buffer.lock().unwrap();
437        buffer.len() as u64
438    }
439    fn set_len(&mut self, len: u64) -> Result<(), FsError> {
440        let mut buffer = self.buffer.lock().unwrap();
441        buffer.resize(len as usize, 0);
442        Ok(())
443    }
444    fn unlink(&mut self) -> Result<(), FsError> {
445        Ok(())
446    }
447    fn bytes_available_read(&self) -> Result<Option<usize>, FsError> {
448        let buffer = self.buffer.lock().unwrap();
449        Ok(Some(buffer.len()))
450    }
451}
452
453/*
454TODO: Think about using this
455trait WasiFdBacking: std::fmt::Debug {
456    fn get_stat(&self) -> &Filestat;
457    fn get_stat_mut(&mut self) -> &mut Filestat;
458    fn is_preopened(&self) -> bool;
459    fn get_name(&self) -> &str;
460}
461*/
wasmer_wasi/state/types.rs

wasmer_wasi/state/
types.rs
