Unify WASIp{2,3} context structures (#11370)

This removes `wasmtime_wasi::p{2,3}::{WasiCtx, WasiCtxBuilder,
WasiView}` in favor of only having `wasmtime_wasi::{WasiCtx,
WasiCtxBuilder, WasiView}` instead. Conceptually these revisions of WASI
all provide the same functionality just with a different veneer that the
component model offers, so having only one way to configure host-side
behavior will make it easier to both organize implementations internally
(e.g. more sharing of code) as well as for embedders to configure (only
one context to create/manage).

Author: alexcrichton

Cargo.lock

@@ -6,15 +6,15 @@ use std::process::Command;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::thread;
-use wasi_common::{WasiCtx, sync::WasiCtxBuilder};
 use wasmtime::*;
+use wasmtime_wasi::{WasiCtx, preview1::WasiP1Ctx};
 
-fn store(engine: &Engine) -> Store<WasiCtx> {
-    let wasi = WasiCtxBuilder::new().build();
+fn store(engine: &Engine) -> Store<WasiP1Ctx> {
+    let wasi = WasiCtx::builder().build_p1();
     Store::new(engine, wasi)
 }
 
-fn instantiate(pre: &InstancePre<WasiCtx>, engine: &Engine) -> Result<()> {
+fn instantiate(pre: &InstancePre<WasiP1Ctx>, engine: &Engine) -> Result<()> {
     let mut store = store(engine);
     let _instance = pre.instantiate(&mut store)?;
     Ok(())
@@ -49,7 +49,7 @@ fn bench_sequential(c: &mut Criterion, path: &Path) {
             // benchmark programs.
             linker.func_wrap("bench", "start", || {}).unwrap();
             linker.func_wrap("bench", "end", || {}).unwrap();
-            wasi_common::sync::add_to_linker(&mut linker, |cx| cx).unwrap();
+            wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |cx| cx).unwrap();
             let pre = linker
                 .instantiate_pre(&module)
                 .expect("failed to pre-instantiate");
@@ -83,7 +83,7 @@ fn bench_parallel(c: &mut Criterion, path: &Path) {
             // benchmark programs.
             linker.func_wrap("bench", "start", || {}).unwrap();
             linker.func_wrap("bench", "end", || {}).unwrap();
-            wasi_common::sync::add_to_linker(&mut linker, |cx| cx).unwrap();
+            wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |cx| cx).unwrap();
             let pre = Arc::new(
                 linker
                     .instantiate_pre(&module)

benches/instantiation.rs

@@ -2,8 +2,8 @@
 
 use criterion::{Criterion, criterion_group, criterion_main};
 use std::{fs::File, path::Path, time::Instant};
-use wasi_common::{WasiCtx, sync::WasiCtxBuilder};
 use wasmtime::{Engine, Linker, Module, Store, TypedFunc};
+use wasmtime_wasi::{DirPerms, FilePerms, WasiCtx, preview1::WasiP1Ctx};
 
 criterion_group!(benches, bench_wasi);
 criterion_main!(benches);
@@ -47,43 +47,34 @@ fn bench_wasi(c: &mut Criterion) {
 /// - execute the body of the function for that number of loop iterations
 /// - return a single `u64` indicating how many loop iterations were executed
 ///   (to double-check)
-fn instantiate(wat: &[u8]) -> (Store<WasiCtx>, TypedFunc<u64, u64>) {
+fn instantiate(wat: &[u8]) -> (Store<WasiP1Ctx>, TypedFunc<u64, u64>) {
     let engine = Engine::default();
     let wasi = wasi_context();
     let mut store = Store::new(&engine, wasi);
     let module = Module::new(&engine, wat).unwrap();
     let mut linker = Linker::new(&engine);
-    wasi_common::sync::add_to_linker(&mut linker, |cx| cx).unwrap();
+    wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |cx| cx).unwrap();
     let instance = linker.instantiate(&mut store, &module).unwrap();
     let run = instance.get_typed_func(&mut store, "run").unwrap();
     (store, run)
 }
 
 /// Build a WASI context with some actual data to retrieve.
-fn wasi_context() -> WasiCtx {
-    WasiCtxBuilder::new()
+fn wasi_context() -> WasiP1Ctx {
+    WasiCtx::builder()
         .envs(&[
             ("a".to_string(), "b".to_string()),
             ("b".to_string(), "c".to_string()),
             ("c".to_string(), "d".to_string()),
         ])
-        .unwrap()
         .args(&[
             "exe".to_string(),
             "--flag1".to_string(),
             "--flag2".to_string(),
             "--flag3".to_string(),
             "--flag4".to_string(),
         ])
+        .preopened_dir("benches/wasi", "/", DirPerms::READ, FilePerms::READ)
         .unwrap()
-        .preopened_dir(
-            wasi_common::sync::Dir::open_ambient_dir(
-                "benches/wasi",
-                wasi_common::sync::ambient_authority(),
-            )
-            .unwrap(),
-            "/",
-        )
-        .unwrap()
-        .build()
+        .build_p1()
 }

benches/wasi.rs

@@ -26,7 +26,7 @@ wasmtime = { workspace = true, default-features = true, features = ["winch", "pu
 wasmtime-cli-flags = { workspace = true, default-features = true, features = [
     "cranelift",
 ] }
-wasi-common = { workspace = true, default-features = true }
+wasmtime-wasi = { workspace = true, features = ['preview1'] }
 wasmtime-wasi-nn = { workspace = true, optional = true }
 cap-std = { workspace = true }
 clap = { workspace = true }

crates/bench-api/Cargo.toml

@@ -141,9 +141,10 @@ use clap::Parser;
 use std::os::raw::{c_int, c_void};
 use std::slice;
 use std::{env, path::PathBuf};
-use wasi_common::{I32Exit, WasiCtx, sync::WasiCtxBuilder};
 use wasmtime::{Engine, Instance, Linker, Module, Store};
 use wasmtime_cli_flags::CommonOptions;
+use wasmtime_wasi::cli::{InputFile, OutputFile};
+use wasmtime_wasi::{DirPerms, FilePerms, I32Exit, WasiCtx, preview1::WasiP1Ctx};
 
 pub type ExitCode = c_int;
 pub const OK: ExitCode = 0;
@@ -272,15 +273,6 @@ pub extern "C" fn wasm_bench_create(
 ) -> ExitCode {
     let result = (|| -> Result<_> {
         let working_dir = config.working_dir()?;
-        let working_dir =
-            cap_std::fs::Dir::open_ambient_dir(&working_dir, cap_std::ambient_authority())
-                .with_context(|| {
-                    format!(
-                        "failed to preopen the working directory: {}",
-                        working_dir.display(),
-                    )
-                })?;
-
         let stdout_path = config.stdout_path()?;
         let stderr_path = config.stderr_path()?;
         let stdin_path = config.stdin_path()?;
@@ -298,39 +290,33 @@ pub extern "C" fn wasm_bench_create(
             config.execution_start,
             config.execution_end,
             move || {
-                let mut cx = WasiCtxBuilder::new();
+                let mut cx = WasiCtx::builder();
 
                 let stdout = std::fs::File::create(&stdout_path)
                     .with_context(|| format!("failed to create {}", stdout_path.display()))?;
-                let stdout = cap_std::fs::File::from_std(stdout);
-                let stdout = wasi_common::sync::file::File::from_cap_std(stdout);
-                cx.stdout(Box::new(stdout));
+                cx.stdout(OutputFile::new(stdout));
 
                 let stderr = std::fs::File::create(&stderr_path)
                     .with_context(|| format!("failed to create {}", stderr_path.display()))?;
-                let stderr = cap_std::fs::File::from_std(stderr);
-                let stderr = wasi_common::sync::file::File::from_cap_std(stderr);
-                cx.stderr(Box::new(stderr));
+                cx.stderr(OutputFile::new(stderr));
 
                 if let Some(stdin_path) = &stdin_path {
                     let stdin = std::fs::File::open(stdin_path)
                         .with_context(|| format!("failed to open {}", stdin_path.display()))?;
-                    let stdin = cap_std::fs::File::from_std(stdin);
-                    let stdin = wasi_common::sync::file::File::from_cap_std(stdin);
-                    cx.stdin(Box::new(stdin));
+                    cx.stdin(InputFile::new(stdin));
                 }
 
                 // Allow access to the working directory so that the benchmark can read
                 // its input workload(s).
-                cx.preopened_dir(working_dir.try_clone()?, ".")?;
+                cx.preopened_dir(working_dir.clone(), ".", DirPerms::READ, FilePerms::READ)?;
 
                 // Pass this env var along so that the benchmark program can use smaller
                 // input workload(s) if it has them and that has been requested.
                 if let Ok(val) = env::var("WASM_BENCH_USE_SMALL_WORKLOAD") {
-                    cx.env("WASM_BENCH_USE_SMALL_WORKLOAD", &val)?;
+                    cx.env("WASM_BENCH_USE_SMALL_WORKLOAD", &val);
                 }
 
-                Ok(cx.build())
+                Ok(cx.build_p1())
             },
         )?);
         Ok(Box::into_raw(state) as _)
@@ -407,15 +393,15 @@ struct BenchState {
     instantiation_timer: *mut u8,
     instantiation_start: extern "C" fn(*mut u8),
     instantiation_end: extern "C" fn(*mut u8),
-    make_wasi_cx: Box<dyn FnMut() -> Result<WasiCtx>>,
+    make_wasi_cx: Box<dyn FnMut() -> Result<WasiP1Ctx>>,
     module: Option<Module>,
     store_and_instance: Option<(Store<HostState>, Instance)>,
     epoch_interruption: bool,
     fuel: Option<u64>,
 }
 
 struct HostState {
-    wasi: WasiCtx,
+    wasi: WasiP1Ctx,
     #[cfg(feature = "wasi-nn")]
     wasi_nn: wasmtime_wasi_nn::witx::WasiNnCtx,
 }
@@ -432,7 +418,7 @@ impl BenchState {
         execution_timer: *mut u8,
         execution_start: extern "C" fn(*mut u8),
         execution_end: extern "C" fn(*mut u8),
-        make_wasi_cx: impl FnMut() -> Result<WasiCtx> + 'static,
+        make_wasi_cx: impl FnMut() -> Result<WasiP1Ctx> + 'static,
     ) -> Result<Self> {
         let mut config = options.config(None)?;
         // NB: always disable the compilation cache.
@@ -459,7 +445,7 @@ impl BenchState {
         let fuel = options.wasm.fuel;
 
         if options.wasi.common != Some(false) {
-            wasi_common::sync::add_to_linker(&mut linker, |cx| &mut cx.wasi)?;
+            wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |cx| &mut cx.wasi)?;
         }
 
         #[cfg(feature = "wasi-nn")]

crates/bench-api/src/lib.rs

@@ -100,13 +100,13 @@ pub struct WasmtimeStoreData {
     pub(crate) resource_table: wasmtime::component::ResourceTable,
 
     #[cfg(all(feature = "component-model", feature = "wasi"))]
-    pub(crate) wasip2: Option<wasmtime_wasi::p2::WasiCtx>,
+    pub(crate) wasip2: Option<wasmtime_wasi::WasiCtx>,
 }
 
 #[cfg(all(feature = "component-model", feature = "wasi"))]
-impl wasmtime_wasi::p2::WasiView for WasmtimeStoreData {
-    fn ctx(&mut self) -> wasmtime_wasi::p2::WasiCtxView<'_> {
-        wasmtime_wasi::p2::WasiCtxView {
+impl wasmtime_wasi::WasiView for WasmtimeStoreData {
+    fn ctx(&mut self) -> wasmtime_wasi::WasiCtxView<'_> {
+        wasmtime_wasi::WasiCtxView {
             ctx: self.wasip2.as_mut().unwrap(),
             table: &mut self.resource_table,
         }

crates/c-api/src/store.rs

@@ -6,7 +6,7 @@ use std::ffi::{CStr, c_char};
 use std::fs::File;
 use std::path::Path;
 use std::slice;
-use wasmtime_wasi::p2::WasiCtxBuilder;
+use wasmtime_wasi::WasiCtxBuilder;
 use wasmtime_wasi::preview1::WasiP1Ctx;
 
 unsafe fn cstr_to_path<'a>(path: *const c_char) -> Option<&'a Path> {

crates/c-api/src/wasi.rs

@@ -1,12 +1,12 @@
 #[repr(transparent)]
 pub struct wasmtime_wasip2_config_t {
-    pub(crate) builder: wasmtime_wasi::p2::WasiCtxBuilder,
+    pub(crate) builder: wasmtime_wasi::WasiCtxBuilder,
 }
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn wasmtime_wasip2_config_new() -> Box<wasmtime_wasip2_config_t> {
     Box::new(wasmtime_wasip2_config_t {
-        builder: wasmtime_wasi::p2::WasiCtxBuilder::new(),
+        builder: wasmtime_wasi::WasiCtxBuilder::new(),
     })
 }
 

crates/c-api/src/wasip2.rs

@@ -4,7 +4,7 @@ use std::sync::{Arc, Mutex};
 use std::task::Waker;
 
 use wasmtime::component::{HasData, ResourceTable};
-use wasmtime_wasi::p2::{WasiCtx, WasiCtxView, WasiView};
+use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};
 
 pub mod borrowing_host;
 pub mod closed_streams;

crates/misc/component-async-tests/src/lib.rs

@@ -7,7 +7,7 @@ use anyhow::Result;
 use futures::stream::{FuturesUnordered, TryStreamExt};
 use wasmtime::component::{Linker, ResourceTable};
 use wasmtime::{Engine, Store};
-use wasmtime_wasi::p2::WasiCtxBuilder;
+use wasmtime_wasi::WasiCtxBuilder;
 
 #[tokio::test]
 pub async fn async_borrowing_caller() -> Result<()> {