1use crate::{
2 I32Exit, SystemTimeSpec, WasiCtx,
3 dir::{DirEntry, OpenResult, ReaddirCursor, ReaddirEntity, TableDirExt},
4 file::{
5 Advice, FdFlags, FdStat, FileAccessMode, FileEntry, FileType, Filestat, OFlags, RiFlags,
6 RoFlags, SdFlags, SiFlags, TableFileExt, WasiFile,
7 },
8 sched::{
9 Poll, Userdata,
10 subscription::{RwEventFlags, SubscriptionResult},
11 },
12};
13use cap_std::time::{Duration, SystemClock};
14use std::borrow::Cow;
15use std::io::{IoSlice, IoSliceMut};
16use std::ops::Deref;
17use std::sync::Arc;
18use wiggle::GuestMemory;
19use wiggle::GuestPtr;
20
21pub mod error;
22use error::{Error, ErrorExt};
23
24pub(crate) const MAX_SHARED_BUFFER_SIZE: usize = 1 << 16;
27
28wiggle::from_witx!({
29 witx: ["witx/preview1/wasi_snapshot_preview1.witx"],
30 errors: { errno => trappable Error },
31 async: *,
35 wasmtime: false,
36});
37
38impl wiggle::GuestErrorType for types::Errno {
39 fn success() -> Self {
40 Self::Success
41 }
42}
43
44#[wiggle::async_trait]
45impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
46 async fn args_get(
47 &mut self,
48 memory: &mut GuestMemory<'_>,
49 argv: GuestPtr<GuestPtr<u8>>,
50 argv_buf: GuestPtr<u8>,
51 ) -> Result<(), Error> {
52 self.args.write_to_guest(memory, argv_buf, argv)
53 }
54
55 async fn args_sizes_get(
56 &mut self,
57 _memory: &mut GuestMemory<'_>,
58 ) -> Result<(types::Size, types::Size), Error> {
59 Ok((self.args.number_elements(), self.args.cumulative_size()))
60 }
61
62 async fn environ_get(
63 &mut self,
64 memory: &mut GuestMemory<'_>,
65 environ: GuestPtr<GuestPtr<u8>>,
66 environ_buf: GuestPtr<u8>,
67 ) -> Result<(), Error> {
68 self.env.write_to_guest(memory, environ_buf, environ)
69 }
70
71 async fn environ_sizes_get(
72 &mut self,
73 _memory: &mut GuestMemory<'_>,
74 ) -> Result<(types::Size, types::Size), Error> {
75 Ok((self.env.number_elements(), self.env.cumulative_size()))
76 }
77
78 async fn clock_res_get(
79 &mut self,
80 _memory: &mut GuestMemory<'_>,
81 id: types::Clockid,
82 ) -> Result<types::Timestamp, Error> {
83 let resolution = match id {
84 types::Clockid::Realtime => Ok(self.clocks.system()?.resolution()),
85 types::Clockid::Monotonic => Ok(self.clocks.monotonic()?.abs_clock.resolution()),
86 types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
87 Err(Error::badf().context("process and thread clocks are not supported"))
88 }
89 }?;
90 Ok(resolution.as_nanos().try_into()?)
91 }
92
93 async fn clock_time_get(
94 &mut self,
95 _memory: &mut GuestMemory<'_>,
96 id: types::Clockid,
97 precision: types::Timestamp,
98 ) -> Result<types::Timestamp, Error> {
99 let precision = Duration::from_nanos(precision);
100 match id {
101 types::Clockid::Realtime => {
102 let now = self.clocks.system()?.now(precision).into_std();
103 let d = now
104 .duration_since(std::time::SystemTime::UNIX_EPOCH)
105 .map_err(|_| {
106 Error::trap(anyhow::Error::msg("current time before unix epoch"))
107 })?;
108 Ok(d.as_nanos().try_into()?)
109 }
110 types::Clockid::Monotonic => {
111 let clock = self.clocks.monotonic()?;
112 let now = clock.abs_clock.now(precision);
113 let d = now.duration_since(clock.creation_time);
114 Ok(d.as_nanos().try_into()?)
115 }
116 types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
117 Err(Error::badf().context("process and thread clocks are not supported"))
118 }
119 }
120 }
121
122 async fn fd_advise(
123 &mut self,
124 _memory: &mut GuestMemory<'_>,
125 fd: types::Fd,
126 offset: types::Filesize,
127 len: types::Filesize,
128 advice: types::Advice,
129 ) -> Result<(), Error> {
130 self.table()
131 .get_file(u32::from(fd))?
132 .file
133 .advise(offset, len, advice.into())
134 .await?;
135 Ok(())
136 }
137
138 async fn fd_allocate(
139 &mut self,
140 _memory: &mut GuestMemory<'_>,
141 fd: types::Fd,
142 _offset: types::Filesize,
143 _len: types::Filesize,
144 ) -> Result<(), Error> {
145 let _ = self.table().get_file(u32::from(fd))?;
148 Err(Error::not_supported())
154 }
155
156 async fn fd_close(
157 &mut self,
158 _memory: &mut GuestMemory<'_>,
159 fd: types::Fd,
160 ) -> Result<(), Error> {
161 let table = self.table();
162 let fd = u32::from(fd);
163
164 if !table.contains_key(fd) {
166 return Err(Error::badf().context("key not in table"));
167 }
168 if table.is::<FileEntry>(fd) {
170 let _ = table.delete::<FileEntry>(fd);
171 } else if table.is::<DirEntry>(fd) {
172 let _ = table.delete::<DirEntry>(fd);
173 } else {
174 return Err(Error::badf().context("key does not refer to file or directory"));
175 }
176
177 Ok(())
178 }
179
180 async fn fd_datasync(
181 &mut self,
182 _memory: &mut GuestMemory<'_>,
183 fd: types::Fd,
184 ) -> Result<(), Error> {
185 self.table()
186 .get_file(u32::from(fd))?
187 .file
188 .datasync()
189 .await?;
190 Ok(())
191 }
192
193 async fn fd_fdstat_get(
194 &mut self,
195 _memory: &mut GuestMemory<'_>,
196 fd: types::Fd,
197 ) -> Result<types::Fdstat, Error> {
198 let table = self.table();
199 let fd = u32::from(fd);
200 if table.is::<FileEntry>(fd) {
201 let file_entry: Arc<FileEntry> = table.get(fd)?;
202 let fdstat = file_entry.get_fdstat().await?;
203 Ok(types::Fdstat::from(&fdstat))
204 } else if table.is::<DirEntry>(fd) {
205 let _dir_entry: Arc<DirEntry> = table.get(fd)?;
206 let dir_fdstat = types::Fdstat {
207 fs_filetype: types::Filetype::Directory,
208 fs_rights_base: directory_base_rights(),
209 fs_rights_inheriting: directory_inheriting_rights(),
210 fs_flags: types::Fdflags::empty(),
211 };
212 Ok(dir_fdstat)
213 } else {
214 Err(Error::badf())
215 }
216 }
217
218 async fn fd_fdstat_set_flags(
219 &mut self,
220 _memory: &mut GuestMemory<'_>,
221 fd: types::Fd,
222 flags: types::Fdflags,
223 ) -> Result<(), Error> {
224 if let Some(table) = self.table_mut() {
225 table
226 .get_file_mut(u32::from(fd))?
227 .file
228 .set_fdflags(FdFlags::from(flags))
229 .await
230 } else {
231 log::warn!(
232 "`fd_fdstat_set_flags` does not work with wasi-threads enabled; see https://github.com/bytecodealliance/wasmtime/issues/5643"
233 );
234 Err(Error::not_supported())
235 }
236 }
237
238 async fn fd_fdstat_set_rights(
239 &mut self,
240 _memory: &mut GuestMemory<'_>,
241 fd: types::Fd,
242 _fs_rights_base: types::Rights,
243 _fs_rights_inheriting: types::Rights,
244 ) -> Result<(), Error> {
245 let table = self.table();
246 let fd = u32::from(fd);
247 if table.is::<FileEntry>(fd) {
248 let _file_entry: Arc<FileEntry> = table.get(fd)?;
249 Ok(())
250 } else if table.is::<DirEntry>(fd) {
251 let _dir_entry: Arc<DirEntry> = table.get(fd)?;
252 Ok(())
253 } else {
254 Err(Error::badf())
255 }
256 }
257
258 async fn fd_filestat_get(
259 &mut self,
260 _memory: &mut GuestMemory<'_>,
261 fd: types::Fd,
262 ) -> Result<types::Filestat, Error> {
263 let table = self.table();
264 let fd = u32::from(fd);
265 if table.is::<FileEntry>(fd) {
266 let filestat = table.get_file(fd)?.file.get_filestat().await?;
267 Ok(filestat.into())
268 } else if table.is::<DirEntry>(fd) {
269 let filestat = table.get_dir(fd)?.dir.get_filestat().await?;
270 Ok(filestat.into())
271 } else {
272 Err(Error::badf())
273 }
274 }
275
276 async fn fd_filestat_set_size(
277 &mut self,
278 _memory: &mut GuestMemory<'_>,
279 fd: types::Fd,
280 size: types::Filesize,
281 ) -> Result<(), Error> {
282 self.table()
283 .get_file(u32::from(fd))?
284 .file
285 .set_filestat_size(size)
286 .await?;
287 Ok(())
288 }
289
290 async fn fd_filestat_set_times(
291 &mut self,
292 _memory: &mut GuestMemory<'_>,
293 fd: types::Fd,
294 atim: types::Timestamp,
295 mtim: types::Timestamp,
296 fst_flags: types::Fstflags,
297 ) -> Result<(), Error> {
298 let fd = u32::from(fd);
299 let table = self.table();
300 let set_atim = fst_flags.contains(types::Fstflags::ATIM);
302 let set_atim_now = fst_flags.contains(types::Fstflags::ATIM_NOW);
303 let set_mtim = fst_flags.contains(types::Fstflags::MTIM);
304 let set_mtim_now = fst_flags.contains(types::Fstflags::MTIM_NOW);
305
306 let atim = systimespec(set_atim, atim, set_atim_now).map_err(|e| e.context("atim"))?;
307 let mtim = systimespec(set_mtim, mtim, set_mtim_now).map_err(|e| e.context("mtim"))?;
308
309 if table.is::<FileEntry>(fd) {
310 table
311 .get_file(fd)
312 .expect("checked that entry is file")
313 .file
314 .set_times(atim, mtim)
315 .await
316 } else if table.is::<DirEntry>(fd) {
317 table
318 .get_dir(fd)
319 .expect("checked that entry is dir")
320 .dir
321 .set_times(".", atim, mtim, false)
322 .await
323 } else {
324 Err(Error::badf())
325 }
326 }
327
328 async fn fd_read(
329 &mut self,
330 memory: &mut GuestMemory<'_>,
331 fd: types::Fd,
332 iovs: types::IovecArray,
333 ) -> Result<types::Size, Error> {
334 let f = self.table().get_file(u32::from(fd))?;
335 if !f.access_mode.contains(FileAccessMode::READ) {
337 Err(types::Errno::Badf)?
338 }
339 let f = &f.file;
340
341 let iovs: Vec<wiggle::GuestPtr<[u8]>> = iovs
342 .iter()
343 .map(|iov_ptr| {
344 let iov_ptr = iov_ptr?;
345 let iov: types::Iovec = memory.read(iov_ptr)?;
346 Ok(iov.buf.as_array(iov.buf_len))
347 })
348 .collect::<Result<_, Error>>()?;
349
350 let is_shared_memory = memory.is_shared_memory();
363 let bytes_read: u64 = if is_shared_memory {
364 let iov = iovs.into_iter().next();
368 if let Some(iov) = iov {
369 let mut buffer = vec![0; (iov.len() as usize).min(MAX_SHARED_BUFFER_SIZE)];
370 let bytes_read = f.read_vectored(&mut [IoSliceMut::new(&mut buffer)]).await?;
371 let iov = iov
372 .get_range(0..bytes_read.try_into()?)
373 .expect("it should always be possible to slice the iov smaller");
374 memory.copy_from_slice(&buffer[0..bytes_read.try_into()?], iov)?;
375 bytes_read
376 } else {
377 return Ok(0);
378 }
379 } else {
380 let guest_slice: &mut [u8] = match iovs.into_iter().filter(|iov| iov.len() > 0).next() {
387 Some(iov) => memory.as_slice_mut(iov)?.unwrap(),
388 None => return Ok(0),
389 };
390
391 f.read_vectored(&mut [IoSliceMut::new(guest_slice)]).await?
393 };
394
395 Ok(types::Size::try_from(bytes_read)?)
396 }
397
398 async fn fd_pread(
399 &mut self,
400 memory: &mut GuestMemory<'_>,
401 fd: types::Fd,
402 iovs: types::IovecArray,
403 offset: types::Filesize,
404 ) -> Result<types::Size, Error> {
405 let f = self.table().get_file(u32::from(fd))?;
406 if !f.access_mode.contains(FileAccessMode::READ) {
408 Err(types::Errno::Badf)?
409 }
410 let f = &f.file;
411
412 let iovs: Vec<wiggle::GuestPtr<[u8]>> = iovs
413 .iter()
414 .map(|iov_ptr| {
415 let iov_ptr = iov_ptr?;
416 let iov: types::Iovec = memory.read(iov_ptr)?;
417 Ok(iov.buf.as_array(iov.buf_len))
418 })
419 .collect::<Result<_, Error>>()?;
420
421 let is_shared_memory = memory.is_shared_memory();
434 let bytes_read: u64 = if is_shared_memory {
435 let iov = iovs.into_iter().next();
439 if let Some(iov) = iov {
440 let mut buffer = vec![0; (iov.len() as usize).min(MAX_SHARED_BUFFER_SIZE)];
441 let bytes_read = f
442 .read_vectored_at(&mut [IoSliceMut::new(&mut buffer)], offset)
443 .await?;
444 let iov = iov
445 .get_range(0..bytes_read.try_into()?)
446 .expect("it should always be possible to slice the iov smaller");
447 memory.copy_from_slice(&buffer[0..bytes_read.try_into()?], iov)?;
448 bytes_read
449 } else {
450 return Ok(0);
451 }
452 } else {
453 let guest_slice: &mut [u8] = match iovs.into_iter().filter(|iov| iov.len() > 0).next() {
455 Some(iov) => memory.as_slice_mut(iov)?.unwrap(),
456 None => return Ok(0),
457 };
458
459 f.read_vectored_at(&mut [IoSliceMut::new(guest_slice)], offset)
461 .await?
462 };
463
464 Ok(types::Size::try_from(bytes_read)?)
465 }
466
467 async fn fd_write(
468 &mut self,
469 memory: &mut GuestMemory<'_>,
470 fd: types::Fd,
471 ciovs: types::CiovecArray,
472 ) -> Result<types::Size, Error> {
473 let f = self.table().get_file(u32::from(fd))?;
474 if !f.access_mode.contains(FileAccessMode::WRITE) {
476 Err(types::Errno::Badf)?
477 }
478 let f = &f.file;
479
480 let guest_slices: Vec<Cow<[u8]>> = ciovs
481 .iter()
482 .map(|iov_ptr| {
483 let iov_ptr = iov_ptr?;
484 let iov: types::Ciovec = memory.read(iov_ptr)?;
485 Ok(memory.as_cow(iov.buf.as_array(iov.buf_len))?)
486 })
487 .collect::<Result<_, Error>>()?;
488
489 let ioslices: Vec<IoSlice> = guest_slices
490 .iter()
491 .map(|s| IoSlice::new(s.deref()))
492 .collect();
493 let bytes_written = f.write_vectored(&ioslices).await?;
494
495 Ok(types::Size::try_from(bytes_written)?)
496 }
497
498 async fn fd_pwrite(
499 &mut self,
500 memory: &mut GuestMemory<'_>,
501 fd: types::Fd,
502 ciovs: types::CiovecArray,
503 offset: types::Filesize,
504 ) -> Result<types::Size, Error> {
505 let f = self.table().get_file(u32::from(fd))?;
506 if !f.access_mode.contains(FileAccessMode::WRITE) {
508 Err(types::Errno::Badf)?
509 }
510 let f = &f.file;
511
512 let guest_slices: Vec<Cow<[u8]>> = ciovs
513 .iter()
514 .map(|iov_ptr| {
515 let iov_ptr = iov_ptr?;
516 let iov: types::Ciovec = memory.read(iov_ptr)?;
517 Ok(memory.as_cow(iov.buf.as_array(iov.buf_len))?)
518 })
519 .collect::<Result<_, Error>>()?;
520
521 let ioslices: Vec<IoSlice> = guest_slices
522 .iter()
523 .map(|s| IoSlice::new(s.deref()))
524 .collect();
525 let bytes_written = f.write_vectored_at(&ioslices, offset).await?;
526
527 Ok(types::Size::try_from(bytes_written)?)
528 }
529
530 async fn fd_prestat_get(
531 &mut self,
532 _memory: &mut GuestMemory<'_>,
533 fd: types::Fd,
534 ) -> Result<types::Prestat, Error> {
535 let table = self.table();
536 let dir_entry: Arc<DirEntry> = table.get(u32::from(fd)).map_err(|_| Error::badf())?;
537 if let Some(preopen) = dir_entry.preopen_path() {
538 let path_str = preopen.to_str().ok_or_else(|| Error::not_supported())?;
539 let pr_name_len = u32::try_from(path_str.as_bytes().len())?;
540 Ok(types::Prestat::Dir(types::PrestatDir { pr_name_len }))
541 } else {
542 Err(Error::not_supported().context("file is not a preopen"))
543 }
544 }
545
546 async fn fd_prestat_dir_name(
547 &mut self,
548 memory: &mut GuestMemory<'_>,
549 fd: types::Fd,
550 path: GuestPtr<u8>,
551 path_max_len: types::Size,
552 ) -> Result<(), Error> {
553 let table = self.table();
554 let dir_entry: Arc<DirEntry> = table.get(u32::from(fd)).map_err(|_| Error::not_dir())?;
555 if let Some(preopen) = dir_entry.preopen_path() {
556 let path_bytes = preopen
557 .to_str()
558 .ok_or_else(|| Error::not_supported())?
559 .as_bytes();
560 let path_len = path_bytes.len();
561 if path_len > path_max_len as usize {
562 return Err(Error::name_too_long());
563 }
564 let path = path.as_array(path_len as u32);
565 memory.copy_from_slice(path_bytes, path)?;
566 Ok(())
567 } else {
568 Err(Error::not_supported())
569 }
570 }
571 async fn fd_renumber(
572 &mut self,
573 _memory: &mut GuestMemory<'_>,
574 from: types::Fd,
575 to: types::Fd,
576 ) -> Result<(), Error> {
577 let table = self.table();
578 let from = u32::from(from);
579 let to = u32::from(to);
580 if !table.contains_key(from) {
581 return Err(Error::badf());
582 }
583 table.renumber(from, to)
584 }
585
586 async fn fd_seek(
587 &mut self,
588 _memory: &mut GuestMemory<'_>,
589 fd: types::Fd,
590 offset: types::Filedelta,
591 whence: types::Whence,
592 ) -> Result<types::Filesize, Error> {
593 use std::io::SeekFrom;
594 let whence = match whence {
595 types::Whence::Cur => SeekFrom::Current(offset),
596 types::Whence::End => SeekFrom::End(offset),
597 types::Whence::Set => {
598 SeekFrom::Start(offset.try_into().map_err(|_| Error::invalid_argument())?)
599 }
600 };
601 let newoffset = self
602 .table()
603 .get_file(u32::from(fd))?
604 .file
605 .seek(whence)
606 .await?;
607 Ok(newoffset)
608 }
609
610 async fn fd_sync(&mut self, _memory: &mut GuestMemory<'_>, fd: types::Fd) -> Result<(), Error> {
611 self.table().get_file(u32::from(fd))?.file.sync().await?;
612 Ok(())
613 }
614
615 async fn fd_tell(
616 &mut self,
617 _memory: &mut GuestMemory<'_>,
618 fd: types::Fd,
619 ) -> Result<types::Filesize, Error> {
620 let offset = self
621 .table()
622 .get_file(u32::from(fd))?
623 .file
624 .seek(std::io::SeekFrom::Current(0))
625 .await?;
626 Ok(offset)
627 }
628
629 async fn fd_readdir(
630 &mut self,
631 memory: &mut GuestMemory<'_>,
632 fd: types::Fd,
633 mut buf: GuestPtr<u8>,
634 buf_len: types::Size,
635 cookie: types::Dircookie,
636 ) -> Result<types::Size, Error> {
637 let mut bufused = 0;
638 for entity in self
639 .table()
640 .get_dir(u32::from(fd))?
641 .dir
642 .readdir(ReaddirCursor::from(cookie))
643 .await?
644 {
645 let entity = entity?;
646 let dirent_raw = dirent_bytes(types::Dirent::try_from(&entity)?);
647 let dirent_len: types::Size = dirent_raw.len().try_into()?;
648 let name_raw = entity.name.as_bytes();
649 let name_len: types::Size = name_raw.len().try_into()?;
650
651 let dirent_copy_len = std::cmp::min(dirent_len, buf_len - bufused);
653 let raw = buf.as_array(dirent_copy_len);
654 memory.copy_from_slice(&dirent_raw[..dirent_copy_len as usize], raw)?;
655
656 if dirent_copy_len < dirent_len {
659 return Ok(buf_len);
660 }
661
662 buf = buf.add(dirent_copy_len)?;
663 bufused += dirent_copy_len;
664
665 let name_copy_len = std::cmp::min(name_len, buf_len - bufused);
667 let raw = buf.as_array(name_copy_len);
668 memory.copy_from_slice(&name_raw[..name_copy_len as usize], raw)?;
669
670 if name_copy_len < name_len {
674 return Ok(buf_len);
675 }
676
677 buf = buf.add(name_copy_len)?;
678 bufused += name_copy_len;
679 }
680 Ok(bufused)
681 }
682
683 async fn path_create_directory(
684 &mut self,
685 memory: &mut GuestMemory<'_>,
686 dirfd: types::Fd,
687 path: GuestPtr<str>,
688 ) -> Result<(), Error> {
689 self.table()
690 .get_dir(u32::from(dirfd))?
691 .dir
692 .create_dir(memory.as_cow_str(path)?.deref())
693 .await
694 }
695
696 async fn path_filestat_get(
697 &mut self,
698 memory: &mut GuestMemory<'_>,
699 dirfd: types::Fd,
700 flags: types::Lookupflags,
701 path: GuestPtr<str>,
702 ) -> Result<types::Filestat, Error> {
703 let filestat = self
704 .table()
705 .get_dir(u32::from(dirfd))?
706 .dir
707 .get_path_filestat(
708 memory.as_cow_str(path)?.deref(),
709 flags.contains(types::Lookupflags::SYMLINK_FOLLOW),
710 )
711 .await?;
712 Ok(types::Filestat::from(filestat))
713 }
714
715 async fn path_filestat_set_times(
716 &mut self,
717 memory: &mut GuestMemory<'_>,
718 dirfd: types::Fd,
719 flags: types::Lookupflags,
720 path: GuestPtr<str>,
721 atim: types::Timestamp,
722 mtim: types::Timestamp,
723 fst_flags: types::Fstflags,
724 ) -> Result<(), Error> {
725 let set_atim = fst_flags.contains(types::Fstflags::ATIM);
726 let set_atim_now = fst_flags.contains(types::Fstflags::ATIM_NOW);
727 let set_mtim = fst_flags.contains(types::Fstflags::MTIM);
728 let set_mtim_now = fst_flags.contains(types::Fstflags::MTIM_NOW);
729
730 let atim = systimespec(set_atim, atim, set_atim_now).map_err(|e| e.context("atim"))?;
731 let mtim = systimespec(set_mtim, mtim, set_mtim_now).map_err(|e| e.context("mtim"))?;
732 self.table()
733 .get_dir(u32::from(dirfd))?
734 .dir
735 .set_times(
736 memory.as_cow_str(path)?.deref(),
737 atim,
738 mtim,
739 flags.contains(types::Lookupflags::SYMLINK_FOLLOW),
740 )
741 .await
742 }
743
744 async fn path_link(
745 &mut self,
746 memory: &mut GuestMemory<'_>,
747 src_fd: types::Fd,
748 src_flags: types::Lookupflags,
749 src_path: GuestPtr<str>,
750 target_fd: types::Fd,
751 target_path: GuestPtr<str>,
752 ) -> Result<(), Error> {
753 let table = self.table();
754 let src_dir = table.get_dir(u32::from(src_fd))?;
755 let target_dir = table.get_dir(u32::from(target_fd))?;
756 let symlink_follow = src_flags.contains(types::Lookupflags::SYMLINK_FOLLOW);
757 if symlink_follow {
758 return Err(Error::invalid_argument()
759 .context("symlink following on path_link is not supported"));
760 }
761
762 src_dir
763 .dir
764 .hard_link(
765 memory.as_cow_str(src_path)?.deref(),
766 target_dir.dir.deref(),
767 memory.as_cow_str(target_path)?.deref(),
768 )
769 .await
770 }
771
772 async fn path_open(
773 &mut self,
774 memory: &mut GuestMemory<'_>,
775 dirfd: types::Fd,
776 dirflags: types::Lookupflags,
777 path: GuestPtr<str>,
778 oflags: types::Oflags,
779 fs_rights_base: types::Rights,
780 _fs_rights_inheriting: types::Rights,
781 fdflags: types::Fdflags,
782 ) -> Result<types::Fd, Error> {
783 let table = self.table();
784 let dirfd = u32::from(dirfd);
785 if table.is::<FileEntry>(dirfd) {
786 return Err(Error::not_dir());
787 }
788 let dir_entry = table.get_dir(dirfd)?;
789
790 let symlink_follow = dirflags.contains(types::Lookupflags::SYMLINK_FOLLOW);
791
792 let oflags = OFlags::from(&oflags);
793 let fdflags = FdFlags::from(fdflags);
794 let path = memory.as_cow_str(path)?;
795
796 let read = fs_rights_base.contains(types::Rights::FD_READ);
797 let write = fs_rights_base.contains(types::Rights::FD_WRITE);
798 let access_mode = if read {
799 FileAccessMode::READ
800 } else {
801 FileAccessMode::empty()
802 } | if write {
803 FileAccessMode::WRITE
804 } else {
805 FileAccessMode::empty()
806 };
807
808 let file = dir_entry
809 .dir
810 .open_file(symlink_follow, path.deref(), oflags, read, write, fdflags)
811 .await?;
812 drop(dir_entry);
813
814 let fd = match file {
815 OpenResult::File(file) => table.push(Arc::new(FileEntry::new(file, access_mode)))?,
816 OpenResult::Dir(child_dir) => table.push(Arc::new(DirEntry::new(None, child_dir)))?,
817 };
818 Ok(types::Fd::from(fd))
819 }
820
821 async fn path_readlink(
822 &mut self,
823 memory: &mut GuestMemory<'_>,
824 dirfd: types::Fd,
825 path: GuestPtr<str>,
826 buf: GuestPtr<u8>,
827 buf_len: types::Size,
828 ) -> Result<types::Size, Error> {
829 let link = self
830 .table()
831 .get_dir(u32::from(dirfd))?
832 .dir
833 .read_link(memory.as_cow_str(path)?.deref())
834 .await?
835 .into_os_string()
836 .into_string()
837 .map_err(|_| Error::illegal_byte_sequence().context("link contents"))?;
838 let link_bytes = link.as_bytes();
839 let link_len = std::cmp::min(link_bytes.len(), buf_len as usize);
842 let buf = buf.as_array(link_len as u32);
843 memory.copy_from_slice(&link_bytes[..link_len], buf)?;
844 Ok(link_len as types::Size)
845 }
846
847 async fn path_remove_directory(
848 &mut self,
849 memory: &mut GuestMemory<'_>,
850 dirfd: types::Fd,
851 path: GuestPtr<str>,
852 ) -> Result<(), Error> {
853 self.table()
854 .get_dir(u32::from(dirfd))?
855 .dir
856 .remove_dir(memory.as_cow_str(path)?.deref())
857 .await
858 }
859
860 async fn path_rename(
861 &mut self,
862 memory: &mut GuestMemory<'_>,
863 src_fd: types::Fd,
864 src_path: GuestPtr<str>,
865 dest_fd: types::Fd,
866 dest_path: GuestPtr<str>,
867 ) -> Result<(), Error> {
868 let table = self.table();
869 let src_dir = table.get_dir(u32::from(src_fd))?;
870 let dest_dir = table.get_dir(u32::from(dest_fd))?;
871 src_dir
872 .dir
873 .rename(
874 memory.as_cow_str(src_path)?.deref(),
875 dest_dir.dir.deref(),
876 memory.as_cow_str(dest_path)?.deref(),
877 )
878 .await
879 }
880
881 async fn path_symlink(
882 &mut self,
883 memory: &mut GuestMemory<'_>,
884 src_path: GuestPtr<str>,
885 dirfd: types::Fd,
886 dest_path: GuestPtr<str>,
887 ) -> Result<(), Error> {
888 self.table()
889 .get_dir(u32::from(dirfd))?
890 .dir
891 .symlink(
892 memory.as_cow_str(src_path)?.deref(),
893 memory.as_cow_str(dest_path)?.deref(),
894 )
895 .await
896 }
897
898 async fn path_unlink_file(
899 &mut self,
900 memory: &mut GuestMemory<'_>,
901 dirfd: types::Fd,
902 path: GuestPtr<str>,
903 ) -> Result<(), Error> {
904 self.table()
905 .get_dir(u32::from(dirfd))?
906 .dir
907 .unlink_file(memory.as_cow_str(path)?.deref())
908 .await
909 }
910
911 async fn poll_oneoff(
912 &mut self,
913 memory: &mut GuestMemory<'_>,
914 subs: GuestPtr<types::Subscription>,
915 events: GuestPtr<types::Event>,
916 nsubscriptions: types::Size,
917 ) -> Result<types::Size, Error> {
918 if nsubscriptions == 0 {
919 return Err(Error::invalid_argument().context("nsubscriptions must be nonzero"));
920 }
921
922 if nsubscriptions == 1 {
927 let sub = memory.read(subs)?;
928 if let types::SubscriptionU::Clock(clocksub) = sub.u {
929 if !clocksub
930 .flags
931 .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME)
932 {
933 self.sched
934 .sleep(Duration::from_nanos(clocksub.timeout))
935 .await?;
936 memory.write(
937 events,
938 types::Event {
939 userdata: sub.userdata,
940 error: types::Errno::Success,
941 type_: types::Eventtype::Clock,
942 fd_readwrite: fd_readwrite_empty(),
943 },
944 )?;
945 return Ok(1);
946 }
947 }
948 }
949
950 let table = &self.table;
951 let mut read_refs: Vec<(Arc<FileEntry>, Option<Userdata>)> = Vec::new();
953 let mut write_refs: Vec<(Arc<FileEntry>, Option<Userdata>)> = Vec::new();
954
955 let mut poll = Poll::new();
956
957 let subs = subs.as_array(nsubscriptions);
958 for sub_elem in subs.iter() {
959 let sub_ptr = sub_elem?;
960 let sub = memory.read(sub_ptr)?;
961 match sub.u {
962 types::SubscriptionU::Clock(clocksub) => match clocksub.id {
963 types::Clockid::Monotonic => {
964 let clock = self.clocks.monotonic()?;
965 let precision = Duration::from_nanos(clocksub.precision);
966 let duration = Duration::from_nanos(clocksub.timeout);
967 let start = if clocksub
968 .flags
969 .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME)
970 {
971 clock.creation_time
972 } else {
973 clock.abs_clock.now(precision)
974 };
975 let deadline = start
976 .checked_add(duration)
977 .ok_or_else(|| Error::overflow().context("deadline"))?;
978 poll.subscribe_monotonic_clock(
979 &*clock.abs_clock,
980 deadline,
981 precision,
982 sub.userdata.into(),
983 )
984 }
985 types::Clockid::Realtime => {
986 let clock = self.clocks.monotonic()?;
992 let precision = Duration::from_nanos(clocksub.precision);
993 let duration = Duration::from_nanos(clocksub.timeout);
994 let deadline = if clocksub
995 .flags
996 .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME)
997 {
998 return Err(Error::not_supported());
999 } else {
1000 clock
1001 .abs_clock
1002 .now(precision)
1003 .checked_add(duration)
1004 .ok_or_else(|| Error::overflow().context("deadline"))?
1005 };
1006 poll.subscribe_monotonic_clock(
1007 &*clock.abs_clock,
1008 deadline,
1009 precision,
1010 sub.userdata.into(),
1011 )
1012 }
1013 _ => Err(Error::invalid_argument()
1014 .context("timer subscriptions only support monotonic timer"))?,
1015 },
1016 types::SubscriptionU::FdRead(readsub) => {
1017 let fd = readsub.file_descriptor;
1018 let file_ref = table.get_file(u32::from(fd))?;
1019 read_refs.push((file_ref, Some(sub.userdata.into())));
1020 }
1021 types::SubscriptionU::FdWrite(writesub) => {
1022 let fd = writesub.file_descriptor;
1023 let file_ref = table.get_file(u32::from(fd))?;
1024 write_refs.push((file_ref, Some(sub.userdata.into())));
1025 }
1026 }
1027 }
1028
1029 let mut read_mut_refs: Vec<(&dyn WasiFile, Userdata)> = Vec::new();
1030 for (file_lock, userdata) in read_refs.iter_mut() {
1031 read_mut_refs.push((file_lock.file.deref(), userdata.take().unwrap()));
1032 }
1033
1034 for (f, ud) in read_mut_refs.iter_mut() {
1035 poll.subscribe_read(*f, *ud);
1036 }
1037
1038 let mut write_mut_refs: Vec<(&dyn WasiFile, Userdata)> = Vec::new();
1039 for (file_lock, userdata) in write_refs.iter_mut() {
1040 write_mut_refs.push((file_lock.file.deref(), userdata.take().unwrap()));
1041 }
1042
1043 for (f, ud) in write_mut_refs.iter_mut() {
1044 poll.subscribe_write(*f, *ud);
1045 }
1046
1047 self.sched.poll_oneoff(&mut poll).await?;
1048
1049 let results = poll.results();
1050 let num_results = results.len();
1051 assert!(
1052 num_results <= nsubscriptions as usize,
1053 "results exceeds subscriptions"
1054 );
1055 let events = events.as_array(
1056 num_results
1057 .try_into()
1058 .expect("not greater than nsubscriptions"),
1059 );
1060 for ((result, userdata), event_elem) in results.into_iter().zip(events.iter()) {
1061 let event_ptr = event_elem?;
1062 let userdata: types::Userdata = userdata.into();
1063 memory.write(
1064 event_ptr,
1065 match result {
1066 SubscriptionResult::Read(r) => {
1067 let type_ = types::Eventtype::FdRead;
1068 match r {
1069 Ok((nbytes, flags)) => types::Event {
1070 userdata,
1071 error: types::Errno::Success,
1072 type_,
1073 fd_readwrite: types::EventFdReadwrite {
1074 nbytes,
1075 flags: types::Eventrwflags::from(&flags),
1076 },
1077 },
1078 Err(e) => types::Event {
1079 userdata,
1080 error: e.downcast().map_err(Error::trap)?,
1081 type_,
1082 fd_readwrite: fd_readwrite_empty(),
1083 },
1084 }
1085 }
1086 SubscriptionResult::Write(r) => {
1087 let type_ = types::Eventtype::FdWrite;
1088 match r {
1089 Ok((nbytes, flags)) => types::Event {
1090 userdata,
1091 error: types::Errno::Success,
1092 type_,
1093 fd_readwrite: types::EventFdReadwrite {
1094 nbytes,
1095 flags: types::Eventrwflags::from(&flags),
1096 },
1097 },
1098 Err(e) => types::Event {
1099 userdata,
1100 error: e.downcast().map_err(Error::trap)?,
1101 type_,
1102 fd_readwrite: fd_readwrite_empty(),
1103 },
1104 }
1105 }
1106 SubscriptionResult::MonotonicClock(r) => {
1107 let type_ = types::Eventtype::Clock;
1108 types::Event {
1109 userdata,
1110 error: match r {
1111 Ok(()) => types::Errno::Success,
1112 Err(e) => e.downcast().map_err(Error::trap)?,
1113 },
1114 type_,
1115 fd_readwrite: fd_readwrite_empty(),
1116 }
1117 }
1118 },
1119 )?;
1120 }
1121
1122 Ok(num_results.try_into().expect("results fit into memory"))
1123 }
1124
1125 async fn proc_exit(
1126 &mut self,
1127 _memory: &mut GuestMemory<'_>,
1128 status: types::Exitcode,
1129 ) -> anyhow::Error {
1130 if status < 126 {
1132 I32Exit(status as i32).into()
1133 } else {
1134 anyhow::Error::msg("exit with invalid exit status outside of [0..126)")
1135 }
1136 }
1137
1138 async fn proc_raise(
1139 &mut self,
1140 _memory: &mut GuestMemory<'_>,
1141 _sig: types::Signal,
1142 ) -> Result<(), Error> {
1143 Err(Error::trap(anyhow::Error::msg("proc_raise unsupported")))
1144 }
1145
1146 async fn sched_yield(&mut self, _memory: &mut GuestMemory<'_>) -> Result<(), Error> {
1147 self.sched.sched_yield().await
1148 }
1149
1150 async fn random_get(
1151 &mut self,
1152 memory: &mut GuestMemory<'_>,
1153 buf: GuestPtr<u8>,
1154 buf_len: types::Size,
1155 ) -> Result<(), Error> {
1156 let buf = buf.as_array(buf_len);
1157 if memory.is_shared_memory() {
1158 let mut copied: u32 = 0;
1163 while copied < buf.len() {
1164 let len = (buf.len() - copied).min(MAX_SHARED_BUFFER_SIZE as u32);
1165 let mut tmp = vec![0; len as usize];
1166 self.random.lock().unwrap().try_fill_bytes(&mut tmp)?;
1167 let dest = buf.get_range(copied..copied + len).unwrap();
1168 memory.copy_from_slice(&tmp, dest)?;
1169 copied += len;
1170 }
1171 } else {
1172 let mem = &mut memory.as_slice_mut(buf)?.unwrap();
1175 self.random.lock().unwrap().try_fill_bytes(mem)?;
1176 }
1177 Ok(())
1178 }
1179
1180 async fn sock_accept(
1181 &mut self,
1182 _memory: &mut GuestMemory<'_>,
1183 fd: types::Fd,
1184 flags: types::Fdflags,
1185 ) -> Result<types::Fd, Error> {
1186 let table = self.table();
1187 let f = table.get_file(u32::from(fd))?;
1188 let file = f.file.sock_accept(FdFlags::from(flags)).await?;
1189 let fd = table.push(Arc::new(FileEntry::new(file, FileAccessMode::all())))?;
1190 Ok(types::Fd::from(fd))
1191 }
1192
1193 async fn sock_recv(
1194 &mut self,
1195 memory: &mut GuestMemory<'_>,
1196 fd: types::Fd,
1197 ri_data: types::IovecArray,
1198 ri_flags: types::Riflags,
1199 ) -> Result<(types::Size, types::Roflags), Error> {
1200 let f = self.table().get_file(u32::from(fd))?;
1201
1202 let iovs: Vec<wiggle::GuestPtr<[u8]>> = ri_data
1203 .iter()
1204 .map(|iov_ptr| {
1205 let iov_ptr = iov_ptr?;
1206 let iov: types::Iovec = memory.read(iov_ptr)?;
1207 Ok(iov.buf.as_array(iov.buf_len))
1208 })
1209 .collect::<Result<_, Error>>()?;
1210
1211 let is_shared_memory = memory.is_shared_memory();
1224 let (bytes_read, ro_flags) = if is_shared_memory {
1225 let iov = iovs.into_iter().next();
1229 if let Some(iov) = iov {
1230 let mut buffer = vec![0; (iov.len() as usize).min(MAX_SHARED_BUFFER_SIZE)];
1231 let (bytes_read, ro_flags) = f
1232 .file
1233 .sock_recv(&mut [IoSliceMut::new(&mut buffer)], RiFlags::from(ri_flags))
1234 .await?;
1235 let iov = iov
1236 .get_range(0..bytes_read.try_into()?)
1237 .expect("it should always be possible to slice the iov smaller");
1238 memory.copy_from_slice(&buffer[0..bytes_read.try_into()?], iov)?;
1239 (bytes_read, ro_flags)
1240 } else {
1241 return Ok((0, RoFlags::empty().into()));
1242 }
1243 } else {
1244 let guest_slice: &mut [u8] = match iovs.into_iter().filter(|iov| iov.len() > 0).next() {
1249 Some(iov) => memory.as_slice_mut(iov)?.unwrap(),
1250 None => &mut [],
1251 };
1252
1253 f.file
1255 .sock_recv(&mut [IoSliceMut::new(guest_slice)], RiFlags::from(ri_flags))
1256 .await?
1257 };
1258
1259 Ok((types::Size::try_from(bytes_read)?, ro_flags.into()))
1260 }
1261
1262 async fn sock_send(
1263 &mut self,
1264 memory: &mut GuestMemory<'_>,
1265 fd: types::Fd,
1266 si_data: types::CiovecArray,
1267 _si_flags: types::Siflags,
1268 ) -> Result<types::Size, Error> {
1269 let f = self.table().get_file(u32::from(fd))?;
1270
1271 let guest_slices: Vec<Cow<[u8]>> = si_data
1272 .iter()
1273 .map(|iov_ptr| {
1274 let iov_ptr = iov_ptr?;
1275 let iov: types::Ciovec = memory.read(iov_ptr)?;
1276 Ok(memory.as_cow(iov.buf.as_array(iov.buf_len))?)
1277 })
1278 .collect::<Result<_, Error>>()?;
1279
1280 let ioslices: Vec<IoSlice> = guest_slices
1281 .iter()
1282 .map(|s| IoSlice::new(s.deref()))
1283 .collect();
1284 let bytes_written = f.file.sock_send(&ioslices, SiFlags::empty()).await?;
1285
1286 Ok(types::Size::try_from(bytes_written)?)
1287 }
1288
1289 async fn sock_shutdown(
1290 &mut self,
1291 _memory: &mut GuestMemory<'_>,
1292 fd: types::Fd,
1293 how: types::Sdflags,
1294 ) -> Result<(), Error> {
1295 let f = self.table().get_file(u32::from(fd))?;
1296
1297 f.file.sock_shutdown(SdFlags::from(how)).await
1298 }
1299}
1300
1301impl From<types::Advice> for Advice {
1302 fn from(advice: types::Advice) -> Advice {
1303 match advice {
1304 types::Advice::Normal => Advice::Normal,
1305 types::Advice::Sequential => Advice::Sequential,
1306 types::Advice::Random => Advice::Random,
1307 types::Advice::Willneed => Advice::WillNeed,
1308 types::Advice::Dontneed => Advice::DontNeed,
1309 types::Advice::Noreuse => Advice::NoReuse,
1310 }
1311 }
1312}
1313
1314impl From<&FdStat> for types::Fdstat {
1315 fn from(fdstat: &FdStat) -> types::Fdstat {
1316 let mut fs_rights_base = types::Rights::empty();
1317 if fdstat.access_mode.contains(FileAccessMode::READ) {
1318 fs_rights_base |= types::Rights::FD_READ;
1319 }
1320 if fdstat.access_mode.contains(FileAccessMode::WRITE) {
1321 fs_rights_base |= types::Rights::FD_WRITE;
1322 }
1323 types::Fdstat {
1324 fs_filetype: types::Filetype::from(&fdstat.filetype),
1325 fs_rights_base,
1326 fs_rights_inheriting: types::Rights::empty(),
1327 fs_flags: types::Fdflags::from(fdstat.flags),
1328 }
1329 }
1330}
1331
1332impl From<&FileType> for types::Filetype {
1333 fn from(ft: &FileType) -> types::Filetype {
1334 match ft {
1335 FileType::Directory => types::Filetype::Directory,
1336 FileType::BlockDevice => types::Filetype::BlockDevice,
1337 FileType::CharacterDevice => types::Filetype::CharacterDevice,
1338 FileType::RegularFile => types::Filetype::RegularFile,
1339 FileType::SocketDgram => types::Filetype::SocketDgram,
1340 FileType::SocketStream => types::Filetype::SocketStream,
1341 FileType::SymbolicLink => types::Filetype::SymbolicLink,
1342 FileType::Unknown => types::Filetype::Unknown,
1343 FileType::Pipe => types::Filetype::Unknown,
1344 }
1345 }
1346}
1347
1348macro_rules! convert_flags {
1349 ($from:ty, $to:ty, $($flag:ident),+) => {
1350 impl From<$from> for $to {
1351 fn from(f: $from) -> $to {
1352 let mut out = <$to>::empty();
1353 $(
1354 if f.contains(<$from>::$flag) {
1355 out |= <$to>::$flag;
1356 }
1357 )+
1358 out
1359 }
1360 }
1361 }
1362}
1363
1364macro_rules! convert_flags_bidirectional {
1365 ($from:ty, $to:ty, $($rest:tt)*) => {
1366 convert_flags!($from, $to, $($rest)*);
1367 convert_flags!($to, $from, $($rest)*);
1368 }
1369}
1370
1371convert_flags_bidirectional!(
1372 FdFlags,
1373 types::Fdflags,
1374 APPEND,
1375 DSYNC,
1376 NONBLOCK,
1377 RSYNC,
1378 SYNC
1379);
1380
1381convert_flags_bidirectional!(RiFlags, types::Riflags, RECV_PEEK, RECV_WAITALL);
1382
1383convert_flags_bidirectional!(RoFlags, types::Roflags, RECV_DATA_TRUNCATED);
1384
1385convert_flags_bidirectional!(SdFlags, types::Sdflags, RD, WR);
1386
1387impl From<&types::Oflags> for OFlags {
1388 fn from(oflags: &types::Oflags) -> OFlags {
1389 let mut out = OFlags::empty();
1390 if oflags.contains(types::Oflags::CREAT) {
1391 out = out | OFlags::CREATE;
1392 }
1393 if oflags.contains(types::Oflags::DIRECTORY) {
1394 out = out | OFlags::DIRECTORY;
1395 }
1396 if oflags.contains(types::Oflags::EXCL) {
1397 out = out | OFlags::EXCLUSIVE;
1398 }
1399 if oflags.contains(types::Oflags::TRUNC) {
1400 out = out | OFlags::TRUNCATE;
1401 }
1402 out
1403 }
1404}
1405
1406impl From<&OFlags> for types::Oflags {
1407 fn from(oflags: &OFlags) -> types::Oflags {
1408 let mut out = types::Oflags::empty();
1409 if oflags.contains(OFlags::CREATE) {
1410 out = out | types::Oflags::CREAT;
1411 }
1412 if oflags.contains(OFlags::DIRECTORY) {
1413 out = out | types::Oflags::DIRECTORY;
1414 }
1415 if oflags.contains(OFlags::EXCLUSIVE) {
1416 out = out | types::Oflags::EXCL;
1417 }
1418 if oflags.contains(OFlags::TRUNCATE) {
1419 out = out | types::Oflags::TRUNC;
1420 }
1421 out
1422 }
1423}
1424impl From<Filestat> for types::Filestat {
1425 fn from(stat: Filestat) -> types::Filestat {
1426 types::Filestat {
1427 dev: stat.device_id,
1428 ino: stat.inode,
1429 filetype: types::Filetype::from(&stat.filetype),
1430 nlink: stat.nlink,
1431 size: stat.size,
1432 atim: stat
1433 .atim
1434 .map(|t| t.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() as u64)
1435 .unwrap_or(0),
1436 mtim: stat
1437 .mtim
1438 .map(|t| t.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() as u64)
1439 .unwrap_or(0),
1440 ctim: stat
1441 .ctim
1442 .map(|t| t.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() as u64)
1443 .unwrap_or(0),
1444 }
1445 }
1446}
1447
1448impl TryFrom<&ReaddirEntity> for types::Dirent {
1449 type Error = Error;
1450 fn try_from(e: &ReaddirEntity) -> Result<types::Dirent, Error> {
1451 Ok(types::Dirent {
1452 d_ino: e.inode,
1453 d_namlen: e.name.as_bytes().len().try_into()?,
1454 d_type: types::Filetype::from(&e.filetype),
1455 d_next: e.next.into(),
1456 })
1457 }
1458}
1459
1460fn dirent_bytes(dirent: types::Dirent) -> Vec<u8> {
1461 use wiggle::GuestType;
1462 assert_eq!(
1463 types::Dirent::guest_size(),
1464 std::mem::size_of::<types::Dirent>() as u32,
1465 "Dirent guest repr and host repr should match"
1466 );
1467 assert_eq!(
1468 1,
1469 std::mem::size_of_val(&dirent.d_type),
1470 "Dirent member d_type should be endian-invariant"
1471 );
1472 let size = types::Dirent::guest_size()
1473 .try_into()
1474 .expect("Dirent is smaller than 2^32");
1475 let mut bytes = Vec::with_capacity(size);
1476 bytes.resize(size, 0);
1477 let ptr = bytes.as_mut_ptr().cast::<types::Dirent>();
1478 let guest_dirent = types::Dirent {
1479 d_ino: dirent.d_ino.to_le(),
1480 d_namlen: dirent.d_namlen.to_le(),
1481 d_type: dirent.d_type, d_next: dirent.d_next.to_le(),
1483 };
1484 unsafe { ptr.write_unaligned(guest_dirent) };
1485 bytes
1486}
1487
1488impl From<&RwEventFlags> for types::Eventrwflags {
1489 fn from(flags: &RwEventFlags) -> types::Eventrwflags {
1490 let mut out = types::Eventrwflags::empty();
1491 if flags.contains(RwEventFlags::HANGUP) {
1492 out = out | types::Eventrwflags::FD_READWRITE_HANGUP;
1493 }
1494 out
1495 }
1496}
1497
1498fn fd_readwrite_empty() -> types::EventFdReadwrite {
1499 types::EventFdReadwrite {
1500 nbytes: 0,
1501 flags: types::Eventrwflags::empty(),
1502 }
1503}
1504
1505fn systimespec(
1506 set: bool,
1507 ts: types::Timestamp,
1508 now: bool,
1509) -> Result<Option<SystemTimeSpec>, Error> {
1510 if set && now {
1511 Err(Error::invalid_argument())
1512 } else if set {
1513 Ok(Some(SystemTimeSpec::Absolute(
1514 SystemClock::UNIX_EPOCH + Duration::from_nanos(ts),
1515 )))
1516 } else if now {
1517 Ok(Some(SystemTimeSpec::SymbolicNow))
1518 } else {
1519 Ok(None)
1520 }
1521}
1522
1523pub(crate) fn directory_base_rights() -> types::Rights {
1527 types::Rights::PATH_CREATE_DIRECTORY
1528 | types::Rights::PATH_CREATE_FILE
1529 | types::Rights::PATH_LINK_SOURCE
1530 | types::Rights::PATH_LINK_TARGET
1531 | types::Rights::PATH_OPEN
1532 | types::Rights::FD_READDIR
1533 | types::Rights::PATH_READLINK
1534 | types::Rights::PATH_RENAME_SOURCE
1535 | types::Rights::PATH_RENAME_TARGET
1536 | types::Rights::PATH_SYMLINK
1537 | types::Rights::PATH_REMOVE_DIRECTORY
1538 | types::Rights::PATH_UNLINK_FILE
1539 | types::Rights::PATH_FILESTAT_GET
1540 | types::Rights::PATH_FILESTAT_SET_TIMES
1541 | types::Rights::FD_FILESTAT_GET
1542 | types::Rights::FD_FILESTAT_SET_TIMES
1543}
1544
1545pub(crate) fn directory_inheriting_rights() -> types::Rights {
1549 types::Rights::FD_DATASYNC
1550 | types::Rights::FD_READ
1551 | types::Rights::FD_SEEK
1552 | types::Rights::FD_FDSTAT_SET_FLAGS
1553 | types::Rights::FD_SYNC
1554 | types::Rights::FD_TELL
1555 | types::Rights::FD_WRITE
1556 | types::Rights::FD_ADVISE
1557 | types::Rights::FD_ALLOCATE
1558 | types::Rights::FD_FILESTAT_GET
1559 | types::Rights::FD_FILESTAT_SET_SIZE
1560 | types::Rights::FD_FILESTAT_SET_TIMES
1561 | types::Rights::POLL_FD_READWRITE
1562 | directory_base_rights()
1563}