cranelift

Commit Graph

Author	SHA1	Message	Date
Alex Crichton	94b3e84e90	Enable the component model by default (#7821 ) * Enable the component model by default This commit enables the component model by default in the embedding API and the CLI. This means that an opt-in of `-W component-model` is no longer required and additionally `.wasm_component_model(true)` is no longer required. Note that this won't impact existing embeddings since the component model feature doesn't do much less `wasmtime::component` is used, and if that's being used this is probably good news for you. * Fix non-component model build	10 months ago
Andrew Brown	27fe3c5b4e	mpk: add `--memory-protection-keys` to the CLI options (#7788 ) * mpk: allow configuring MPK from the command line This allows the following usage: ```console $ wasmtime --pooling-allocator=y --memory-protection-keys=y ... ``` * mpk: add CLI test for failure * review: move `bail!` outside the pooling allocator block * fix: use absolute dependency path	10 months ago
Ryan Levick	82fbd0c038	Add a test for allow-ip-name-lookup=no (#7657 ) The test simply tries looking up example.com and ensuring it fails with `PermanentResolverFailure`. Additionally, `PermanentResolverFailure` is removed as one of the allowed errors in the normal ip name lookup test as those allowed errors should only be transient lookup errors and `PermanentResolverFailure` is very much not a transient error. Signed-off-by: Ryan Levick <ryan.levick@fermyon.com>	11 months ago
Ryan Levick	63e260693d	Ensure `remote-address` is allowed when creating UDP stream (#7648 ) * Ensure remote_address is allowed when creating UDP stream Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> * Check addr validity after UDP state check and wrap pool in Arc Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> * Check provided addr in outgoing stream Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> * Add test for turning off udp Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> * Model pool on UDP types as optional to catch bad state bugs Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> --------- Signed-off-by: Ryan Levick <ryan.levick@fermyon.com>	11 months ago
Ryan Levick	576db0196d	Add options to WasiCtx for toggling TCP and UDP on and off (#7647 ) * Add options to WasiCtx for toggling TCP and UDP on and off Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> * Address PR feedback Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> * Add test for turning off tcp Signed-off-by: Ryan Levick <ryan.levick@fermyon.com> --------- Signed-off-by: Ryan Levick <ryan.levick@fermyon.com>	11 months ago
Alex Crichton	49c32d2de8	Implement WASI "preview0" in `wasmtime-wasi` (#7548 ) This commit implements the `wasi_unstable` module, sometimes referred to as "preview0", in the `wasmtime-wasi` crate. Previously this was only implemented by the `wasi-common` crate but now this is implemented for both meaning that the switch to preview2 won't lose this functionality. The preview0 WITX files are vendored like the preview1 files and the implementation of preview0 is exclusively implemented by delegating to the preview1 implementation.	12 months ago
Alex Crichton	e9d62746ef	Fix writes being flushed to stdio (#7441 ) * Fix writes being flushed to stdio This commit fixes an accidental issue with writing to stdout with the `wasi-common` implementation where writes were line-buffered by the Rust standard library rather than being flushed out immediately as WASI semantics required. Closes #7437 * Fix warning in test	1 year ago
Alex Crichton	efeeaf5135	Fix parsing f32/f64 CLI arguments as floats (#7440 ) Type inference wasn't enough for this situation since floats are stored as `u32` and `u64` while they're at rest to avoid modification. Closes #7401	1 year ago
Alex Crichton	698952b1bc	Add support for `::` in `--dir` to old CLI (#7416 ) In Wasmtime 13 and prior the `--dir` argument was unconditionally used to open a host dir as the same name and in the guest. In Wasmtime 14+ though this argument is being repurposed with an optional trailing `::GUEST` to configure the guest directory. This means that `--dir`-with-remapping behavior is actually unusable without the environment variable configuration from #7385 due to it parsing differently in the old and the new. This commit updates the situation by adding `::`-parsing to the old CLI meaning that both the old and the new parse this the same way. This will break any scripts that open host directories with two colons in their path, but that seems niche enough we can handle that later.	1 year ago
Alex Crichton	519808fc5c	Add compatibility shims for Wasmtime 13 CLI (#7385 ) * Add compatibility shims for Wasmtime 13 CLI This commit introduces a compatibility shim for the Wasmtime 13 CLI and prior. The goal of this commit is to address concerns raised in #7336 and other locations as well. While the new CLI cannot be un-shipped at this point this PR attempts to ameliorate the situation somewhat through a few avenues: * A complete copy of the old CLI parser is now included in `wasmtime` by default. * The `WASMTIME_NEW_CLI=0` environment variable can force usage of the old CLI parser for the `run` and `compile` commands. * The `WASMTIME_NEW_CLI=1` environment variable can force usage of the new CLI parser. * Otherwise both the old and the new CLI parser are executed. Depending on the result one is selected to be executed, possibly with a warning printed. * If both CLI parsers succeed but produce the same result, then no warning is emitted and execution continues as usual. * If both CLI parsers succeed but produce different results then a warning is emitted indicating this. The warning points to #7384 which has further examples of how to squash the warning. The warning also mentions the above env var to turn the warning off. In this situation the old semantics are used at this time instead of the new semantics. It's intended that eventually this will change in the future. * If the new CLI succeeds and the old CLI fails then the new semantics are executed without warning. * If the old CLI succeeds and the new CLI fails then a warning is issued and the old semantics are used. * If both the old and the new CLI fail to parse then the error message for the new CLI is emitted. Note that this doesn't add up to a perfect transition. The hope is that most of the major cases of change at the very least have something printed. My plan is to land this on `main` and then backport it to the 14.0.0 branch as a 14.0.3 release. * Wordsmith messages * Update messages * More wording updates * Fix grammar * More updates	1 year ago
Alex Crichton	5ea563fb81	Enable the new preview1 implementation by default (#7365 ) Currently Wasmtime has two implementations of the `wasi_snapshot_preview1` set of APIs. The now-historical implementation lives in the `wasi-common` crate and the more recent implementation lives in the `wasmtime-wasi` crate. The main difference is that the `wasmtime-wasi` implementation is based on the implementation of preview2, meaning that the preview1 implementation is a shim in that direction. Additionally currently the preview2 implementation of preview1 is accessible via the `-Spreview2` flag on the CLI. This commit updates the interpretation of the `-Spreview2` flag and the defaults around which implementation to choose. By default the preview1-built-on-preview2 implementation (the new `wasmtime-wasi` implementation) is selected now. This means that the `wasi-common` implementation is disabled by default. There are still two use cases to keep running the `wasi-common` implementation, however: * When running modules that import from `wasi_unstable`, the "snapshot" before `wasi_snapshot_preview1`, currently `wasi-common` is required. The shims to implement `wasi_unstable` have not yet been implemented in the `wasmtime-wasi` crate. * When running with WASI threads (`-Sthreads`) the preview2 implementation does not work. This is because the preview2 implementation expects mutable access to the table which is not granted when threads are enabled. Tests using `wasi_unstable` now pass `-Spreview2=n` to explicitly request the old `wasi-common` implementation. Additionally the `wasi-common` implementation is still selected by default when `-Sthreads` is passed (enabling the WASI threads proposal).	1 year ago
Alex Crichton	183cb0f2f8	Swap the order of directories in `--dir` (#7301 ) This commit changes the `--dir` argument on the `wasmtime` CLI to be `HOST::GUEST` rather than `GUEST::HOST`. This matches Docker for example and is a little more consistent with only `--dir path` where the first argument is always treated as a host directory. In terms of breaking-ness the movement from `--mapdir` to `--dir` hasn't been released with Wasmtime 14 yet so my hope is that this can land on both `main` and Wasmtime 14.0.0 before it's released to avoid any breakage other than existing scripts migrating from `--mapdir` to `--dir`.	1 year ago
Pat Hickey	99be9b0855	Implement stream splice, delete forward (#7234 ) * wit: splice and blocking-splice borrow input-stream. delete forward. * minimum viable implementation of splice and blocking splice * add cli test for splice * sync wits * improve wit docs for splice * code golf	1 year ago
Alex Crichton	079ddd4bf7	Minor logging tweaks (#7242 ) Some things I noticed from #7239 which are very much not critical but I figure might be nice-to-haves: * Move the logging configuration to the `wasmtime-cli-flags` crate with the other logging configuration to keep it in one place. * Remove `pretty_env_logger` since `tracing-subscriber` probably supplants it. * Don't explicitly inherit env vars in tests since that happens automatically with `Command`.	1 year ago
Pat Hickey	f952ff2744	wasmtime-cli: add tracing output on `WASMTIME_LOG` (#7239 ) * wasmtime cli: install tracing-subscriber, listen to WASMTIME_LOG, log to stderr * enable tracing colors * audit supply chain for tracing subscriber	1 year ago
Pat Hickey	88bc013783	Minor preview2 related test cleanups (#7232 ) * delete redundant cli test cli_panic is almost exactly the same as cli_exit_panic, so delete the first one * split stream pollable lifetimes test into two preview2 tests	1 year ago
Alex Crichton	f4be360648	Refactor the test-programs test suite (#7182 ) * Refactor the test-programs test suite This commit is a large refactoring that reorganizes `test-programs` and how we tests wasms in Wasmtime. Often writing tests requires complicated interactions with the guest which can't be done via hand-written `.wat` syntax and requires a compiler to get engaged. For this purpose Wasmtime currently has the `crates/test-programs/` test suite which builds files from source and then runs the tests. This has been somewhat cumbersome in the past though and it's not been easy to extend this over time, so this commit attempts to address this. The scheme implemented in this PR looks like: * All wasm test programs live in `crates/test-programs/src/bin/.rs`. All of them, no exceptions. Wasm tests have shared support located at `crates/test-programs/src/lib.rs` and its submodules, such as bindings generation for WASI. * Wasm tests are built by a new `crates/test-programs/artifacts` crate. This crate compiles modules and additionally creates components for all test programs. The crate itself only records the path to these outputs and a small amount of testing support, but otherwise doesn't interact with `wasmtime`-the-crate itself. * All tests in `crates/test-programs/tests/.rs` have moved. For example wasi-http tests now live at `crates/wasi-http/tests/.rs`. Legacy tests of wasi-common now live at `crates/wasi-common/tests/.rs`. Modern tests for preview2 live at `crates/wasi/tests/.rs`. * Wasm tests are bucketed based on their filename prefix. For example `preview1_` is tested in wasi-common and wasmtime-wasi. The `preview2_` prefix is only tested with wasmtime-wasi, however. * A new `cli_` prefix is used to execute tests as part of `tests/all/main.rs`. This is a new submodule in `tests/all/cli_tests.rs` which executes these components on the command line. Many old "command" tests were migrated here. Helper macros are generated to assert that a test suite is run in its entirety. This way if a `preview1_` test is added it's asserted to get added to both wasi-common and wasmtime-wasi in the various modes they run tests. Overall this moved a number of tests around and refactored some edges of the tests, but this should not lose any tests (except one that wasn't actually testing anything). Additionally the hope is that it's much easier to add tests in the future. The process is to add a new file in `crates/test-programs/src/bin/.rs` named appropriately. For example a preview2 executable is `preview2_` and a CLI tests is `cli_`. When building the test suite an error is generated in the appropriate module then of "please write a test here", and then a test is written in the same manner as the other tests in the module. * Remove no-longer-needed fetches prtest:full * I'm worried wasi is running low on semicolons * Add the WASI target in all CI actions * Add unknown-unknown target on all CI builders too * Fix building test artifacts under miri Need to avoid wrappers for these cross-compiled targets * Break circular dependency for packaging Don't use the workspace dep for `wasmtime-wasi` since it injects a version, instead use a `path = '..'` dependency to fool Cargo into dropping the dependency during the package phase. * Fix some merge conflicts with tests * Fix rebase for new tests * Remove stray comment * Fix some flaky tests * Fix network tests in synchronous mode This commit is an attempt to fix some networking tests in synchronous mode in our test suite. Currently networking tests don't actually run in synchronous mode on CI which is why no failures have been surfaced yet, but the refactoring in #7182 is going to start doing this. Currently the `udp_sample_application.rs` test blocks infinitely in synchronous mode for me locally, most of the time. This appears to be an interaction between how Tokio handles readiness and how we're entering the event loop. We're effectively entering the Tokio event loop with a future that's always ready which ends up starving Tokio of otherwise performing its background work such as updating flags for readiness of reading/writing. The fix here is to add a yield at the start of an `in_tokio` block which is used in synchronous mode. This is a kludge fix but the intention is to enable Tokio to have a chance to update readiness flags and process events from epoll/kqueue/etc. An additional fix to this issue is WebAssembly/wasi-sockets#64 where the test is waiting on `READABLE` or `WRITABLE`, but in this specific case it should only wait on `READABLE`. If it waited on just this then that would also fix this issue. Nevertheless having a `yield_now` is expected to have little-to-no overhead and otherwise fix this edge case of an always-ready future. * Fix passing empty arguments on the CLI * Add another blocking accept * Update crates/test-programs/src/bin/api_proxy.rs Co-authored-by: Trevor Elliott <awesomelyawesome@gmail.com> --------- Co-authored-by: Trevor Elliott <awesomelyawesome@gmail.com>	1 year ago
Eduardo de Moura Rodrigues	6a3d9d05fd	fix(wasmtime-cli): wrong linker in wasi http (#7167 ) * chore: convert wasi http cli test to component * fix(wasmtime-cli): wrong linker in wasi http * fix(wasmtime-cli): fix multiple functions added to linker We will allow shadowing in linker when using WASI HTTP in order to prevent the following error: > import of `wasi:clocks/wall-clock` defined twice * chore: update to latest io streams wit definition * chore: rename main function of core module prtest:full * fix(wasmtime-cli): add only http functions to linker * chore: add test building http request and response * chore: disable temporarily wasi http test	1 year ago
Dan Gohman	3e5b30bd96	Start to port Wasmtime to the new wasi-io API with resources. (#7029 ) * Rename `Host` things to avoid name conflicts with bindings. Update to the latest resource-enabled wit files. * Adapting the code to the new bindings. * Update wasi-http to the resource-enabled wit deps. * Start adapting the wasi-http code to the new bindings. * Make `get_directories` always return new owned handles. * Simplify the `poll_one` implementation. * Update the wasi-preview1-component-adapter. FIXME: temporarily disable wasi-http tests. Add logging to the cli world, since stderr is now a reseource that can only be claimed once. * Work around a bug hit by poll-list, fix a bug in poll-one. * Comment out `test_fd_readwrite_invalid_fd`, which panics now. * Fix a few FIXMEs. * Use `.as_ref().trapping_unwrap()` instead of `TrappingUnwrapRef`. * Use `drop_in_place`. * Remove `State::with_mut`. * Remove the `RefCell` around the `State`. * Update to wit-bindgen 0.12. * Update wasi-http to use resources for poll and I/O. This required making incoming-body and outgoing-body resourrces too, to work with `push_input_stream_child` and `push_output_stream_child`. * Re-enable disabled tests, remove logging from the worlds. * Remove the `poll_list` workarounds that are no longer needed. * Remove logging from the adapter. That said, there is no replacement yet, so add a FIXME comment. * Reenable a test that now passes. * Remove `.descriptors_mut` and use `with_descriptors_mut` instead. Replace `.descriptors()` and `.descriptors_mut()` with functions that take closures, which limits their scope, to prevent them from invalid aliasing. * Implement dynamic borrow checking for descriptors. * Add a cargo-vet audit for wasmtime-wmemcheck. * Update cargo vet for wit-bindgen 0.12. * Cut down on duplicate sync/async resource types (#1) * Allow calling `get-directories` more than once (#2) For now `Clone` the directories into new descriptor slots as needed. * Start to lift restriction of stdio only once (#3) * Start to lift restriction of stdio only once This commit adds new `{Stdin,Stdout}Stream` traits which take over the job of the stdio streams in `WasiCtxBuilder` and `WasiCtx`. These traits bake in the ability to create a stream at any time to satisfy the API of `wasi:cli`. The TTY functionality is folded into them as while I was at it. The implementation for stdin is relatively trivial since the stdin implementation already handles multiple streams reading it. Built-in impls of the `StdinStream` trait are also provided for helper types in `preview2::pipe` which resulted in the implementation of `MemoryInputPipe` being updated to support `Clone` where all clones read the same original data. * Get tests building * Un-ignore now-passing test * Remove unneeded argument from `WasiCtxBuilder::build` * Fix tests * Remove some workarounds Stdio functions can now be called multiple times. * If `poll_oneoff` fails part-way through, clean up properly. Fix the `Drop` implementation for pollables to only drop the pollables that have been successfully added to the list. This fixes the poll_oneoff_files failure and removes a FIXME. --------- Co-authored-by: Alex Crichton <alex@alexcrichton.com>	1 year ago
Trevor Elliott	30ee0dc8d9	Use wasi-streams in the wasi-http implementation (#7056 ) * Start refactoring wasi-http * Checkpoint * Initial implementation of response future handling * Lazily initialize response headers and body * make wasmtime-wasi-http compile * wasi-http wit: make a way to reject outgoing-request in outgoing-handler before waiting for the future to resolve * wasi: sync wit from wasi-http * outgoing handler impl: report errors to userland * test-programs: get wasi-http-components kicking over, delete modules and components-sync tests wasi-http-components-sync will come back once we get done with other stuff, but its superfulous for now. wasi-http-modules will not be returning. * Process headers * Add HostIncomingBody::new * Add trailers functions * Add TODO for body task outline * Rework incoming-response-consume to return a future-trailers value as well * Fix the wit * First cut at the worker loop * wasi-http: change how we represent bodies/trailers, and annotate own/borrow/child throughout * Update types_impl.rs for wit changes * Split body management into its own module * Checkpoint * more work on incoming body and future trailers * Fill out some more functions * Implement future-trailers-{subscribe,get} * Implement drop-future-trailers * Rework fields, but make the borrow checker mad * Fix borrow error * wasi-http-tests: fix build * test-runner: report errors with stdout/stderr properly * fix two trivial wasi-http tests the error type here changed from a types::Error to an outbound_handler::Error * Remove unnecessary drops * Convert a `bail!` to a `todo!` * Remove a TODO that documented the body worker structure * fill in a bunch more of OutputBody * Remove the custom FrameFut future in favor of using http_body_util * Move the outgoing body types to body.rs * Rework the handling of outgoing bodies * Fix the `outgoing request get` test * Avoid deadlocking the post tests * future_incoming_request_get shouldn't delete the resource * Fix the invalid_dnsname test * implement drop-future-incoming-response * Fix invalid_port and invalid_dnsname tests * Fix the post test * Passing a too large string to println! caused the large post test to fail * Format * Plumb through `between_bytes_timeout` * Downgrade hyper * Revert "Downgrade hyper" This reverts commit fa0750e0c42823cb785288fcf6c0507c5ae9fd64. * Restore old https connection setup * Sync the wasi and wasi-http http deps * Fix tests * Remove the module and component-sync tests, as they are currently not supported * Fix the reference to the large_post test in the components test * Fix wasi-http integration * sync implementation of wasi-http * Slightly more robust error checking * Ignore the wasi-http cli test prtest:full * Consistent ignore attributes between sync and async tests * Fix doc errors * code motion: introduce intermediate `HostIncomingBodyBuilder` rather than a tuple * explain design * Turn FieldMap into a type synonym * Tidy up some future state (#7073) Co-authored-by: Pat Hickey <phickey@fastly.com> * body HostInputStream: report runtime errors with StreamRuntimeError HostInputStream is designed wrong to need that in the first place. We will fix it in a follow-up as soon as resources land. --------- Co-authored-by: Pat Hickey <phickey@fastly.com> Co-authored-by: Alex Crichton <alex@alexcrichton.com>	1 year ago
Alex Crichton	a4d036ca8e	wasi: Fix a few issues around stdin (#7063 ) * wasi: Fix a few issues around stdin This commit is intended to address #6986 and some other issues related to stdin and reading it, notably: * Previously once EOF was reached the `closed` flag was mistakenly not set. * Previously data would be infinitely buffered regardless of how fast the guest program would consume it. * Previously stdin would be immediately ready by Wasmtime regardless of whether the guest wanted to read stdin or not. * The host-side preview1-to-preview2 adapter didn't perform a blocking read meaning that it never blocked. These issues are addressed by refactoring the code in question. Note that this is similar to the logic of `AsyncReadStream` somewhat but that type is not appropriate in this context due to the singleton nature of stdin meaning that the per-stream helper task and per-stream buffer of `AsyncReadStream` are not appropriate. Closees #6986 * Increase slop size for windows	1 year ago
Alex Crichton	f7d0e870d5	Require Wasmtime options come before wasm modules (#6946 ) This commit implements a new behavior for the CLI of the `wasmtime` executable which will require that options for Wasmtime itself come before the wasm module being run. Currently they're allowed to come afterwards, but instead all arguments and flags coming after a module will be interpreted as arguments for the module itself. This feature has a bit of a storied history at this point, and the breadcrumbs are: * Originally landed in #6737 * Reverted for 12.0.0 in #6830 * Reverted for 13.0.0 in #6944 This PR is intended to be landed as a sibling of #6925, another independent overhaul of Wasmtime's own options on the CLI, for the Wasmtime 14.0.0 release. More information about the motivation for this change, as well as consequences of the fallout, can be found on #6737.	1 year ago
Alex Crichton	85889ab217	Un-ignore now-passing test (#7007 ) With the merging of #6877 prints to stdout with preview2 should now work without requiring extra sleeps or such.	1 year ago
Alex Crichton	8995750aa4	Redesign Wasmtime's CLI (#6925 ) * Redesign Wasmtime's CLI This commit follows through on discussion from #6741 to redesign the flags that the `wasmtime` binary accepts on the CLI. Almost all flags have been renamed/moved and will require callers to update. The main motivation here is to cut down on the forest of options in `wasmtime -h` which are difficult to mentally group together and understand. The main change implemented here is to move options behind "option groups" which are intended to be abbreviated with a single letter: * `-O foo` - an optimization or performance-tuning related option * `-C foo` - a codegen option affecting the compilation process. * `-D foo` - a debug-related option * `-W foo` - a wasm-related option, for example changing wasm semantics * `-S foo` - a WASI-related option, configuring various proposals for example Each option group can be explored by passing `help`, for example `-O help`. This will print all options within the group along with their help message. Additionally `-O help-long` can be passed to print the full comment for each option if desired. Option groups can be specified multiple times on the command line, for example `-Wrelaxed-simd -Wthreads`. They can also be combined together with commas as `-Wrelaxed-simd,threads`. Configuration works as a "last option wins" so `-Ccache,cache=n` would end up with a compilation cache disabled. Boolean options can be specified as `-C foo` to enable `foo`, or they can be specified with `-Cfoo=$val` with any of `y`, `n`, `yes`, `no`, `true`, or `false`. All other options require a `=foo` value to be passed and the parsing depends on the type. This commit additionally applies a few small refactorings to the CLI as well. For example the help text no longer prints information about wasm features after printing the option help. This is still available via `-Whelp` as all wasm features have moved from `--wasm-features` to `-W`. Additionally flags are no longer conditionally compiled in, but instead all flags are always supported. A runtime error is returned if support for a flag is not compiled in. Additionally the "experimental" name of WASI proposals has been dropped in favor of just the name of the proposal, for example `--wasi nn` instead of `--wasi-modules experimental-wasi-nn`. This is intended to mirror how wasm proposals don't have "experimental" in the name and an opt-in is required regardless. A full listing of flags and how they have changed is: \| old cli flag \| new cli flag \| \|-----------------------------------------------\|-------------------------------------------------\| \| `-O, --optimize` \| removed \| \| `--opt-level <LEVEL>` \| `-O opt-level=N` \| \| `--dynamic-memory-guard-size <SIZE>` \| `-O dynamic-memory-guard-size=...` \| \| `--static-memory-forced` \| `-O static-memory-forced` \| \| `--static-memory-guard-size <SIZE>` \| `-O static-memory-guard-size=N` \| \| `--static-memory-maximum-size <MAXIMUM>` \| `-O static-memory-maximum-size=N` \| \| `--dynamic-memory-reserved-for-growth <SIZE>` \| `-O dynamic-memory-reserved-for-growth=...` \| \| `--pooling-allocator` \| `-O pooling-allocator` \| \| `--disable-memory-init-cow` \| `-O memory-init-cow=no` \| \| `--compiler <COMPILER>` \| `-C compiler=..` \| \| `--enable-cranelift-debug-verifier` \| `-C cranelift-debug-verifier` \| \| `--cranelift-enable <SETTING>` \| `-C cranelift-NAME` \| \| `--cranelift-set <NAME=VALUE>` \| `-C cranelift-NAME=VALUE` \| \| `--config <CONFIG_PATH>` \| `-C cache-config=..` \| \| `--disable-cache` \| `-C cache=no` \| \| `--disable-parallel-compilation` \| `-C parallel-compilation=no` \| \| `-g` \| `-D debug-info` \| \| `--disable-address-map` \| `-D address-map=no` \| \| `--disable-logging` \| `-D logging=no` \| \| `--log-to-files` \| `-D log-to-files` \| \| `--coredump-on-trap <PATH>` \| `-D coredump=..` \| \| `--wasm-features all` \| `-W all-proposals` \| \| `--wasm-features -all` \| `-W all-proposals=n` \| \| `--wasm-features bulk-memory` \| `-W bulk-memory` \| \| `--wasm-features multi-memory` \| `-W multi-memory` \| \| `--wasm-features multi-value` \| `-W multi-value` \| \| `--wasm-features reference-types` \| `-W reference-types` \| \| `--wasm-features simd` \| `-W simd` \| \| `--wasm-features tail-call` \| `-W tail-call` \| \| `--wasm-features threads` \| `-W threads` \| \| `--wasm-features memory64` \| `-W memory64` \| \| `--wasm-features copmonent-model` \| `-W component-model` \| \| `--wasm-features function-references` \| `-W function-references` \| \| `--relaxed-simd-deterministic` \| `-W relaxed-simd-deterministic` \| \| `--enable-cranelift-nan-canonicalization` \| `-W nan-canonicalization` \| \| `--fuel <N>` \| `-W fuel=N` \| \| `--epoch-interruption` \| `-W epoch-interruption` \| \| `--allow-unknown-exports` \| `-W unknown-exports-allow` \| \| `--trap-unknown-imports` \| `-W unknown-imports-trap` \| \| `--default-values-unknown-imports` \| `-W unknown-imports-default` \| \| `--max-instances <MAX_INSTANCES>` \| `-W max-instances=N` \| \| `--max-memories <MAX_MEMORIES>` \| `-W max-memories=N` \| \| `--max-memory-size <BYTES>` \| `-W max-memory-size=N` \| \| `--max-table-elements <MAX_TABLE_ELEMENTS>` \| `-W max-table-elements=N` \| \| `--max-tables <MAX_TABLES>` \| `-W max-tables=N` \| \| `--max-wasm-stack <MAX_WASM_STACK>` \| `-W max-wasm-stack=N` \| \| `--trap-on-grow-failure` \| `-W trap-on-grow-failure` \| \| `--wasm-timeout <TIME>` \| `-W timeout=N` \| \| `--wmemcheck` \| `-W wmemcheck` \| \| `--wasi-modules default` \| removed \| \| `--wasi-modules -default` \| removed \| \| `--wasi-modules wasi-common` \| `-S common` \| \| `--wasi-modules -wasi-common` \| `-S common=n` \| \| `--wasi-modules experimental-wasi-nn` \| `-S nn` \| \| `--wasi-modules experimental-wasi-threads` \| `-S threads` \| \| `--wasi-modules experimental-wasi-http` \| `-S http` \| \| `--listenfd` \| `-S listenfd` \| \| `--tcplisten <SOCKET ADDRESS>` \| `-S tcplisten=...` \| \| `--wasi-nn-graph <FORMAT::HOST>` \| `-S nn-graph=FORMAT::HOST` \| \| `--preview2` \| `-S preview2` \| \| `--dir <DIRECTORY>` \| `--dir ...` \| \| `--mapdir <GUEST_DIR::HOST_DIR>` \| `--dir a::b` \| * Be more descriptive with help text * Document `=val` is optional for `-Ccranelift-xxx` * Fix compile after rebase * Fix rebase of `--inherit-network` * Fix wasi-http test * Fix compile without pooling allocator support * Update some flags in docs * Fix bench-api build * Update flags for gdb/lldb tests * Fixup optimization flags prtest:full	1 year ago
Eduardo de Moura Rodrigues	8eefa7c3af	feat(wasmtime-cli): restore support for wasi http module (#6878 ) * feat(wasmtime-cli): add async support flag Within the wasmtime CLI, the current default behavior is to only inject the synchronous functions to linkers. This will add a flag called `--async` that will inject the asynchronous one instead. * chore: refactor wasi http crate * feat(wasmtime-wasi): make in_tokio function public * feat(wasi-http): define default feature called sync * Revert "feat(wasmtime-cli): add async support flag" This reverts commit b743ff2003a2e391972330aa8e8437c6356e580a. * chore: improve flaky tests for wasi http * feat(wasi-http): expose sync api for components * chore: add tests for sync api of wasi http components * feat(wasmtime-cli): restore support for wasi http module * chore: revert change to outbound http request invalid test * chore: have extra tracing to help debugging * feat(wasi-http): allow modules with sync functions in linker * fix(wasi-http): missing response body in sync api * feat: include blocking for io streams * chore: add tests for wasi http module in cli * chore: disable preview2 flag in wasi http test * chore: use preview2 flag in wasi http test * fix(wasi-http): missing stream output in sync api * chore: fix tests for wasi http * chore: add tracing for poll oneoff call * chore: send exit signal on wasi http test * chore: swap println to tracing debug * chore: set http server timeout to 50 secs by default * chore: add test posting large file * chore: revert formatting in cargo toml * chore: fix wasi-http feature and skip failing tests prtest:full --------- Co-authored-by: Eduardo Rodrigues <eduardomourar@users.noreply.github.com>	1 year ago
Alex Crichton	df8d3698b1	Partially revert CLI argument changes from #6737 (#6944 ) * Partially revert CLI argument changes from #6737 This commit is a partial revert of #6737. That change was reverted in #6830 for the 12.0.0 release of Wasmtime and otherwise it's currently slated to get released with the 13.0.0 release of Wasmtime. Discussion at today's Wasmtime meeting concluded that it's best to couple this change with #6925 as a single release rather than spread out across multiple releases. This commit is thus the revert of #6737, although it's a partial revert in that I've kept many of the new tests added to showcase the differences before/after when the change lands. This means that Wasmtime 13.0.0 will exhibit the same CLI behavior as 12.0.0 and all prior releases. The 14.0.0 release will have both a new CLI and new argument passing semantics. I'll revert this revert (aka re-land #6737) once the 13.0.0 release branch is created and `main` becomes 14.0.0. * Update release notes	1 year ago
Alex Crichton	55350477ce	Handle more failures with `--trap-on-grow-failure` (#6885 ) * Handle more failures with `--trap-on-grow-failure` This debugging tool was missing a few cases about `memory.grow` or `table.grow` returning -1, namely when the OS reported failure in the `memory.grow` case or in the case for tables when the computation overflowed for the new table size. This commit updates the `_grow_failed` methods, which were already hooking these errors, to return a `Result<()>` which enables returning a trap from them as well. Fix test	1 year ago
Alex Crichton	367bdc8c66	Refactor Wasmtime CLI to support components (#6836 ) This commit refactors the `wasmtime` CLI executable to be able to support not only compiling components but additionally executing components. While I was doing this I've additionally added a new `--preview2` argument to enable using the new experimental implementation of preview1 based on preview2 type/structs. This is off-by-default but is expected to become the default in the future. Some notable features of this change are: * The preview1-implemented-with-preview2 module now sports `add_to_linker_{async,sync}` to replace the previous `add_to_linker` which always did async. * Some trait bounds in the preview1-implemented-with-preview2 module are simplified. * Some minor changes were made to `wiggle`'s macros to support a "block on" that isn't the default wiggle dummy executor (as now we actually do need Tokio) * Many options related to core wasm `Linker` configuration, such as `--default-values-unknown-imports`, are not implemented for components at this time. When used with components these options return an error. * Construction of WASI contexts has been refactored to pass around fewer arguments to avoid threading through lots of values for both preview1 and preview2. * Reading the input to the Wasmtime CLI has been updated to read the input in the `run` subcommand before handing it off to the `wasmtime` crate's API to enable the CLI to use the contents of what's loaded to determine what to do next. * Our generic `./ci/run-tests.sh` script has been updated to pass the `--features component-model` flag to ensure that this CLI support is tested during the normal test suite. * The CLI support for `wasi-nn` supports components as well as core wasm modules.	1 year ago
Alex Crichton	615d697a0b	Update preview1 to trap on misaligned pointers (#6776 ) * Update preview1 to trap on misaligned pointers Previously Wasmtime would return `EINVAL` to a guest but the upstream documentation indicates that misaligned pointers should trap, so this commit updates the alignment error to get converted into a trap rather than than being returned to the guest. * Change OOB errors to traps too * Update preview2's implementation of preview1 * Handle some more errors	1 year ago
Alex Crichton	8091556514	Require wasmtime options are first when running modules (#6737 ) * Require wasmtime options are first when running modules Currently the way we've configured argument parsing it's valid to execute a command such as: wasmtime run foo.wasm -O which is the same as: wasmtime run -O foo.wasm or otherwise all flags are attempted to be parsed as Wasmtime flags and an error is generated when they're not wasmtime flags. I've personally found this a bit confusing in the past and I find myself frequently executing: wasmtime run -- foo.wasm -other -arguments While this works my general impression is that many other "wrapper commands" don't behave this way and typically don't require `--` to pass flags to the target executable. This commit reconfigures argument parsing to consider any argument after the WebAssembly module itself to be an argument to the wasm program rather than an argument to Wasmtime. This means that all Wasmtime options must come between the `run` command and the `foo.wasm` WebAssembly argument. * Update wasi testsuite runner * Support `wasmtime -- run` Additionally use more clap features to avoid manually checking against subcommands. * Remove stale comment * Reorder wasi-nn arguments * Reorder more flags * Fix unused import on Windows * Don't run a stdio test on Windows * Update gdb/lldb tests * Don't assert that the write succeeds prtest:full	1 year ago
Alex Crichton	2f6cec97eb	Add ability to inherit an env var on the CLI (#6746 ) In addition to Wasmtime's preexisting support for `--env FOO=bar` this commit additionally adds support for `--env FOO` which is inspired by Docker to inherit the environment variable `FOO` from the calling process as a shortcut for `--env FOO=$FOO`.	1 year ago
Andrew Brown	9aacf31ad2	wasi-threads: check module shape at spawn time (#6492 ) This change relaxes what kinds of modules can be run when wasi-threads is enabled via `--wasi-modules experimental-wasi-threads`. Previously, as reported in #6153, simple modules that made no use of thread spawning or shared memories were preemptively rejected when the wasi-threads context was created. This is too restrictive. Instead, this change does the following: - it moves the check for whether a module is valid according to the wasi-threads specification to the point a new thread is spawned; this resolves #6153 - as noted in #6153, this change also adds a better error message indicating that wasi-threads expects a shared memory import - the way this is implemented also improves the module instantiation: by constructing an `InstancePre` once when the `WasiThreadsCtx` is built, we might shave off a bit of time from the "spawn a thread" call; this supercedes a similar effort in #5741	1 year ago
Rainy Sinclair	b0be673afb	Update core dump generation in the cli to use wasm-encoder (#6306 ) * Update coredump generation in the cli to use wasm_encoder * Add deny.toml exception for wasm-encoder 0.25.0 * add missing newline * update custom section in fuzzing crate	2 years ago
Andrew Brown	1a6b3ec15f	test: add cases from `wasi-testsuite` (#6341 ) * wasi: add the `wasi-testsuite` tests for wasi-common As described [here], this uses the `prod/testsuite-base` branch in which the tests are built as `.wasm` files. [here]: https://github.com/WebAssembly/wasi-testsuite/#getting-started * chore: update `walkdir` everywhere to its latest version This is done in order to use it for `wasi_testsuite` testing. * vet: extend `walkdir`'s exemption * test: factor out `get_wasmtime_command` This will be helpful for `wasi_testsuite` testing. * test: use all `wasi-testsuite` test cases This change alters the `wasi_testsuite` test to run all of the available test cases in [wasi-testsuite]. This involved making the test runner a bit more robust to the various shapes of JSON specifications in that project. Unfortunately, the `wasi_testsuite` test fails some of the cases, so I added a `WASI_COMMON_IGNORE_LIST` to avoid these temporarily. (This may remind some of the Wasm testsuite ignore lists in Cranelift; those relied on `build.rs` to create a `#[test]` for each test case, which I felt is not yet needed here). It's unclear to me why the tests are failing. It could be because: - wasi-common has a bug - wasi-testsuite overspecifies (or incorrectly specifies) a test - the test runner incorrectly configures Wasmtime's CLI execution. But this change makes it easier to resolve this. Remove the file from `WASI_COMMON_IGNORE_LIST` and run `cargo test wasi_testsuite -- --nocapture`. The printed output will show the expected result, the actual result, and a command to replicate the failure from the command line. [wasi-testsuite]: https://github.com/WebAssembly/wasi-testsuite * review: add "shrinking" comment	2 years ago
Alex Crichton	c0bb341d95	Run some tests in MIRI on CI (#6332 ) * Run some tests in MIRI on CI This commit is an implementation of getting at least chunks of Wasmtime to run in MIRI on CI. The full test suite is not possible to run in MIRI because MIRI cannot run Cranelift-produced code at runtime (aka it doesn't support JITs). Running MIRI, however, is still quite valuable if we can manage it because it would have trivially detected GHSA-ch89-5g45-qwc7, our most recent security advisory. The goal of this PR is to select a subset of the test suite to execute in CI under MIRI and boost our confidence in the copious amount of `unsafe` code in Wasmtime's runtime. Under MIRI's default settings, which is to use the [Stacked Borrows][stacked] model, much of the code in `Instance` and `VMContext` is considered invalid. Under the optional [Tree Borrows][tree] model, however, this same code is accepted. After some [extremely helpful discussion][discuss] on the Rust Zulip my current conclusion is that what we're doing is not fundamentally un-sound but we need to model it in a different way. This PR, however, uses the Tree Borrows model for MIRI to get something onto CI sooner rather than later, and I hope to follow this up with something that passed Stacked Borrows. Additionally that'll hopefully make this diff smaller and easier to digest. Given all that, the end result of this PR is to get 131 separate unit tests executing on CI. These unit tests largely exercise the embedding API where wasm function compilation is not involved. Some tests compile wasm functions but don't run them, but compiling wasm through Cranelift in MIRI is so slow that it doesn't seem worth it at this time. This does mean that there's a pretty big hole in MIRI's test coverage, but that's to be expected as we're a JIT compiler after all. To get tests working in MIRI this PR uses a number of strategies: * When platform-specific code is involved there's now `#[cfg(miri)]` for MIRI's version. For example there's a custom-built "mmap" just for MIRI now. Many of these are simple noops, some are `unimplemented!()` as they shouldn't be reached, and some are slightly nontrivial implementations such as mmaps and trap handling (for native-to-native function calls). * Many test modules are simply excluded via `#![cfg(not(miri))]` at the top of the file. This excludes the entire module's worth of tests from MIRI. Other modules have `#[cfg_attr(miri, ignore)]` annotations to ignore tests by default on MIRI. The latter form is used in modules where some tests work and some don't. This means that all future test additions will need to be effectively annotated whether they work in MIRI or not. My hope though is that there's enough precedent in the test suite of what to do to not cause too much burden. * A number of locations are fixed with respect to MIRI's analysis. For example `ComponentInstance`, the component equivalent of `wasmtime_runtime::Instance`, was actually left out from the fix for the CVE by accident. MIRI dutifully highlighted the issues here and I've fixed them locally. Some locations fixed for MIRI are changed to something that looks similar but is subtly different. For example retaining items in a `Store<T>` is now done with a Wasmtime-specific `StoreBox<T>` type. This is because, with MIRI's analyses, moving a `Box<T>` invalidates all pointers derived from this `Box<T>`. We don't want these semantics, so we effectively have a custom `Box<T>` to suit our needs in this regard. * Some default configuration is different under MIRI. For example most linear memories are dynamic with no guards and no space reserved for growth. Settings such as parallel compilation are disabled. These are applied to make MIRI "work by default" in more places ideally. Some tests which perform N iterations of something perform fewer iterations on MIRI to not take quite so long. This PR is not intended to be a one-and-done-we-never-look-at-it-again kind of thing. Instead this is intended to lay the groundwork to continuously run MIRI in CI to catch any soundness issues. This feels, to me, overdue given the amount of `unsafe` code inside of Wasmtime. My hope is that over time we can figure out how to run Wasm in MIRI but that may take quite some time. Regardless this will be adding nontrivial maintenance work to contributors to Wasmtime. MIRI will be run on CI for merges, MIRI will have test failures when everything else passes, MIRI's errors will need to be deciphered by those who have probably never run MIRI before, things like that. Despite all this to me it seems worth the cost at this time. Just getting this running caught two possible soundness bugs in the component implementation that could have had a real-world impact in the future! [stacked]: https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md [tree]: https://perso.crans.org/vanille/treebor/ [discuss]: https://rust-lang.zulipchat.com/#narrow/stream/269128-miri/topic/Tree.20vs.20Stacked.20Borrows.20.26.20a.20debugging.20question * Update alignment comment	2 years ago
Andrew Brown	ad584f428a	wasi-threads: run test suite (#5907 ) * wasi-threads: run test suite This change enables the running of the wasi-threads [test suite]. It relies on a Wasmtime CLI binary being available and runs all `.wasm` and `.wat` files present in the test suite directory. The results of each execution are compared against a JSON spec file with the same base name as the WebAssembly module. The spec file defines the expected exit code, e.g. This commit does not yet build any `.c` or `.s` files from the test suite. That could be done later, perhaps upstream; in the meantime, this work is still valuable as it lays the foundation for running other WASI tests from the in-progress [wasi-testsuite] which share the same JSON spec infrastructure. [test suite]: https://github.com/WebAssembly/wasi-threads/tree/main/test/testsuite [wasi-testsuite]: https://github.com/WebAssembly/wasi-testsuite * review: move testsuite to top-level tests * fix: remove now-unnecessary wasi-threads test * fix: update testsuite submodule name * fix: ignore tests on Windows prtest:full * fix: `cfg_attr` syntax prtest:full	2 years ago
Andrew Brown	edfa10d607	wasi-threads: an initial implementation (#5484 ) This commit includes a set of changes that add initial support for `wasi-threads` to Wasmtime: * feat: remove mutability from the WasiCtx Table This patch adds interior mutability to the WasiCtx Table and the Table elements. Major pain points: * `File` only needs `RwLock<cap_std::fs::File>` to implement `File::set_fdflags()` on Windows, because of [1] * Because `File` needs a `RwLock` and `RwLockGuard` cannot be hold across an `.await`, The `async` from `async fn num_ready_bytes(&self)` had to be removed Because `File` needs a `RwLock` and `RwLockGuard` cannot be dereferenced in `pollable`, the signature of `fn pollable(&self) -> Option<rustix::fd::BorrowedFd>` changed to `fn pollable(&self) -> Option<Arc<dyn AsFd + '_>>` [1] `da238e324e/src/fs/fd_flags.rs (L210-L217)` wasi-threads: add an initial implementation This change is a first step toward implementing `wasi-threads` in Wasmtime. We may find that it has some missing pieces, but the core functionality is there: when `wasi::thread_spawn` is called by a running WebAssembly module, a function named `wasi_thread_start` is found in the module's exports and called in a new instance. The shared memory of the original instance is reused in the new instance. This new WASI proposal is in its early stages and details are still being hashed out in the [spec] and [wasi-libc] repositories. Due to its experimental state, the `wasi-threads` functionality is hidden behind both a compile-time and runtime flag: one must build with `--features wasi-threads` but also run the Wasmtime CLI with `--wasm-features threads` and `--wasi-modules experimental-wasi-threads`. One can experiment with `wasi-threads` by running: ```console $ cargo run --features wasi-threads -- \ --wasm-features threads --wasi-modules experimental-wasi-threads \ <a threads-enabled module> ``` Threads-enabled Wasm modules are not yet easy to build. Hopefully this is resolved soon, but in the meantime see the use of `THREAD_MODEL=posix` in the [wasi-libc] repository for some clues on what is necessary. Wiggle complicates things by requiring the Wasm memory to be exported with a certain name and `wasi-threads` also expects that memory to be imported; this build-time obstacle can be overcome with the `--import-memory --export-memory` flags only available in the latest Clang tree. Due to all of this, the included tests are written directly in WAT--run these with: ```console $ cargo test --features wasi-threads -p wasmtime-cli -- cli_tests ``` [spec]: https://github.com/WebAssembly/wasi-threads [wasi-libc]: https://github.com/WebAssembly/wasi-libc This change does not protect the WASI implementations themselves from concurrent access. This is already complete in previous commits or left for future commits in certain cases (e.g., wasi-nn). * wasi-threads: factor out process exit logic As is being discussed [elsewhere], either calling `proc_exit` or trapping in any thread should halt execution of all threads. The Wasmtime CLI already has logic for adapting a WebAssembly error code to a code expected in each OS. This change factors out this logic to a new function, `maybe_exit_on_error`, for use within the `wasi-threads` implementation. This will work reasonably well for CLI users of Wasmtime + `wasi-threads`, but embedders will want something better in the future: when a `wasi-threads` threads fails, they may not want their application to exit. Handling this is tricky, because it will require cancelling the threads spawned by the `wasi-threads` implementation, something that is not trivial to do in Rust. With this change, we defer that work until later in order to provide a working implementation of `wasi-threads` for experimentation. [elsewhere]: https://github.com/WebAssembly/wasi-threads/pull/17 * review: work around `fd_fdstat_set_flags` In order to make progress with wasi-threads, this change temporarily works around limitations induced by `wasi-common`'s `fd_fdstat_set_flags` to allow `&mut self` use in the implementation. Eventual resolution is tracked in https://github.com/bytecodealliance/wasmtime/issues/5643. This change makes several related helper functions (e.g., `set_fdflags`) take `&mut self` as well. * test: use `wait`/`notify` to improve `threads.wat` test Previously, the test simply executed in a loop for some hardcoded number of iterations. This changes uses `wait` and `notify` and atomic operations to keep track of when the spawned threads are done and join on the main thread appropriately. * various fixes and tweaks due to the PR review --------- Signed-off-by: Harald Hoyer <harald@profian.com> Co-authored-by: Harald Hoyer <harald@profian.com> Co-authored-by: Alex Crichton <alex@alexcrichton.com>	2 years ago
Nam Junghyun	ebb693aa18	Move precompiled module detection into wasmtime (#5342 ) * Treat `-` as an alias to `/dev/stdin` This applies to unix targets only, as Windows does not have an appropriate alternative. * Add tests for piped modules from stdin This applies to unix targets only, as Windows does not have an appropriate alternative. * Move precompiled module detection into wasmtime Previously, wasmtime-cli checked the module to be loaded is precompiled or not, by pre-opening the given file path to check if the "\x7FELF" header exists. This commit moves this branch into the `Module::from_trusted_file`, which is only invoked with `--allow-precompiled` flag on CLI. The initial motivation of the commit is, feeding a module to wasmtime from piped inputs, is blocked by the pre-opening of the module. The `Module::from_trusted_file`, assumes the --allow-precompiled flag so there is no piped inputs, happily mmap-ing the module to test if the header exists. If --allow-precompiled is not supplied, the existing `Module::from_file` will be used, without the additional header check as the precompiled modules are intentionally not allowed on piped inputs for security measures. One caveat of this approach is that the user may be confused if he or she tries to execute a precompiled module without --allow-precompiled, as wasmtime shows an 'input bytes aren't valid utf-8' error, not directly getting what's going wrong. So this commit includes a hack-ish workaround for this. Thanks to @jameysharp for suggesting this idea with a detailed guidance.	2 years ago
Alex Crichton	2afaac5181	Return `anyhow::Error` from host functions instead of `Trap`, redesign `Trap` (#5149 ) * Return `anyhow::Error` from host functions instead of `Trap` This commit refactors how errors are modeled when returned from host functions and additionally refactors how custom errors work with `Trap`. At a high level functions in Wasmtime that previously worked with `Result<T, Trap>` now work with `Result<T>` instead where the error is `anyhow::Error`. This includes functions such as: * Host-defined functions in a `Linker<T>` * `TypedFunc::call` * Host-related callbacks like call hooks Errors are now modeled primarily as `anyhow::Error` throughout Wasmtime. This subsequently removes the need for `Trap` to have the ability to represent all host-defined errors as it previously did. Consequently the `From` implementations for any error into a `Trap` have been removed here and the only embedder-defined way to create a `Trap` is to use `Trap::new` with a custom string. After this commit the distinction between a `Trap` and a host error is the wasm backtrace that it contains. Previously all errors in host functions would flow through a `Trap` and get a wasm backtrace attached to them, but now this only happens if a `Trap` itself is created meaning that arbitrary host-defined errors flowing from a host import to the other side won't get backtraces attached. Some internals of Wasmtime itself were updated or preserved to use `Trap::new` to capture a backtrace where it seemed useful, such as when fuel runs out. The main motivation for this commit is that it now enables hosts to thread a concrete error type from a host function all the way through to where a wasm function was invoked. Previously this could not be done since the host error was wrapped in a `Trap` that didn't provide the ability to get at the internals. A consequence of this commit is that when a host error is returned that isn't a `Trap` we'll capture a backtrace and then won't have a `Trap` to attach it to. To avoid losing the contextual information this commit uses the `Error::context` method to attach the backtrace as contextual information to ensure that the backtrace is itself not lost. This is a breaking change for likely all users of Wasmtime, but it's hoped to be a relatively minor change to workaround. Most use cases can likely change `-> Result<T, Trap>` to `-> Result<T>` and otherwise explicit creation of a `Trap` is largely no longer necessary. * Fix some doc links * add some tests and make a backtrace type public (#55) * Trap: avoid a trailing newline in the Display impl which in turn ends up with three newlines between the end of the backtrace and the `Caused by` in the anyhow Debug impl * make BacktraceContext pub, and add tests showing downcasting behavior of anyhow::Error to traps or backtraces * Remove now-unnecesary `Trap` downcasts in `Linker::module` * Fix test output expectations * Remove `Trap::i32_exit` This commit removes special-handling in the `wasmtime::Trap` type for the i32 exit code required by WASI. This is now instead modeled as a specific `I32Exit` error type in the `wasmtime-wasi` crate which is returned by the `proc_exit` hostcall. Embedders which previously tested for i32 exits now downcast to the `I32Exit` value. * Remove the `Trap::new` constructor This commit removes the ability to create a trap with an arbitrary error message. The purpose of this commit is to continue the prior trend of leaning into the `anyhow::Error` type instead of trying to recreate it with `Trap`. A subsequent simplification to `Trap` after this commit is that `Trap` will simply be an `enum` of trap codes with no extra information. This commit is doubly-motivated by the desire to always use the new `BacktraceContext` type instead of sometimes using that and sometimes using `Trap`. Most of the changes here were around updating `Trap::new` calls to `bail!` calls instead. Tests which assert particular error messages additionally often needed to use the `:?` formatter instead of the `{}` formatter because the prior formats the whole `anyhow::Error` and the latter only formats the top-most error, which now contains the backtrace. * Merge `Trap` and `TrapCode` With prior refactorings there's no more need for `Trap` to be opaque or otherwise contain a backtrace. This commit parse down `Trap` to simply an `enum` which was the old `TrapCode`. All various tests and such were updated to handle this. The main consequence of this commit is that all errors have a `BacktraceContext` context attached to them. This unfortunately means that the backtrace is printed first before the error message or trap code, but given all the prior simplifications that seems worth it at this time. * Rename `BacktraceContext` to `WasmBacktrace` This feels like a better name given how this has turned out, and additionally this commit removes having both `WasmBacktrace` and `BacktraceContext`. * Soup up documentation for errors and traps * Fix build of the C API Co-authored-by: Pat Hickey <pat@moreproductive.org>	2 years ago
Saúl Cabrera	52524d258c	Expose `TrapCode::Interrupt` on epoch based interruption (#4105 )	3 years ago
Alex Crichton	c22033bf93	Delete historical interruptable support in Wasmtime (#3925 ) * Delete historical interruptable support in Wasmtime This commit removes the `Config::interruptable` configuration along with the `InterruptHandle` type from the `wasmtime` crate. The original support for adding interruption to WebAssembly was added pretty early on in the history of Wasmtime when there was no other method to prevent an infinite loop from the host. Nowadays, however, there are alternative methods for interruption such as fuel or epoch-based interruption. One of the major downsides of `Config::interruptable` is that even when it's not enabled it forces an atomic swap to happen when entering WebAssembly code. This technically could be a non-atomic swap if the configuration option isn't enabled but that produces even more branch-y code on entry into WebAssembly which is already something we try to optimize. Calling into WebAssembly is on the order of a dozens of nanoseconds at this time and an atomic swap, even uncontended, can add up to 5ns on some platforms. The main goal of this PR is to remove this atomic swap on entry into WebAssembly. This is done by removing the `Config::interruptable` field entirely, moving all existing consumers to epochs instead which are suitable for the same purposes. This means that the stack overflow check is no longer entangled with the interruption check and perhaps one day we could continue to optimize that further as well. Some consequences of this change are: * Epochs are now the only method of remote-thread interruption. * There are no more Wasmtime traps that produces the `Interrupted` trap code, although we may wish to move future traps to this so I left it in place. * The C API support for interrupt handles was also removed and bindings for epoch methods were added. * Function-entry checks for interruption are a tiny bit less efficient since one check is performed for the stack limit and a second is performed for the epoch as opposed to the `Config::interruptable` style of bundling the stack limit and the interrupt check in one. It's expected though that this is likely to not really be measurable. * The old `VMInterrupts` structure is renamed to `VMRuntimeLimits`.	3 years ago
Alex Crichton	4d4779b563	Restore running precompiled modules with the CLI (#3343 ) * Restore running precompiled modules with the CLI This was accidentally broken when `Module::deserialize` was split out of `Module::new` long ago, so this adds the detection in the CLI to call the appropriate method to load the module. This feature is gated behind an `--allow-precompiled` flag to enable, by default, passing arbitrary user input to the `wasmtime` command. Closes #3338 * Fix test on Windows	3 years ago
Andrew Brown	4deed8fe50	refactor: move Wasm test files to tests/all/cli_tests Previously the inputs to `tests/all/cli_tests.rs` were contained in `tests/wasm`. This change moves them to the more obvious `tests/all/cli_tests` directory and updates the paths that point to them.	3 years ago
Alex Crichton	29949505d6	Fix printing float results from the CLI (#2797 ) Previously their bit patterns were printed interpreted as decimals, now they're printed as floats.	4 years ago
Peter Huene	b391817c0f	Add a test case for unwind with saved FPRs on Windows. This commit adds a simple test case that reproduces the problem in	4 years ago
Dan Gohman	3715e19c67	Reactor support. (#1565 ) * Reactor support. This implements the new WASI ABI described here: https://github.com/WebAssembly/WASI/blob/master/design/application-abi.md It adds APIs to `Instance` and `Linker` with support for running WASI programs, and also simplifies the process of instantiating WASI API modules. This currently only includes Rust API support. * Add comments and fix a typo in a comment. * Fix a rustdoc warning. * Tidy an unneeded `mut`. * Factor out instance initialization with `NewInstance`. This also separates instantiation from initialization in a manner similar to https://github.com/bytecodealliance/lucet/pull/506. * Update fuzzing oracles for the API changes. * Remove `wasi_linker` and clarify that Commands/Reactors aren't connected to WASI. * Move Command/Reactor semantics into the Linker. * C API support. * Fix fuzzer build. * Update usage syntax from "::" to "=". * Remove `NewInstance` and `start()`. * Elaborate on Commands and Reactors and add a spec link. * Add more comments. * Fix wat syntax. * Fix wat. * Use the `Debug` formatter to format an anyhow::Error. * Fix wat.	5 years ago
Dan Gohman	fb0b9e3ae6	Change `proc_exit` to unwind the stack rather than exiting the host process. (#1646 ) * Remove Cranelift's OutOfBounds trap, which is no longer used. * Change proc_exit to unwind instead of exit the host process. This implements the semantics in https://github.com/WebAssembly/WASI/pull/235. Fixes #783. Fixes #993. * Fix exit-status tests on Windows. * Revert the wiggle changes and re-introduce the wasi-common implementations. * Move `wasi_proc_exit` into the wasmtime-wasi crate. * Revert the spec_testsuite change. * Remove the old proc_exit implementations. * Make `TrapReason` an implementation detail. * Allow exit status 2 on Windows too. * Fix a documentation link. * Really fix a documentation link.	5 years ago
Alex Crichton	db92dcd990	Update test ignore annotations for aarch64 (#1643 ) Looks like everything is in general passing now so it's probably time to close #1521 and all other remaining tests that are failing are classified under new more focused issues. Closes #1521	5 years ago
Alex Crichton	d8920c0125	Sync expected successful tests on AArch64 (#1581 ) * Sync expected successful tests on AArch64 Fixes CI for recent merges which have fixed features on AArch64! * Enable more passing tests	5 years ago
Alex Crichton	d1aa86f91a	Add AArch64 tests to CI (#1526 ) * Add AArch64 tests to CI This commit enhances our CI with an AArch64 builder. Currently we have no physical hardware to run on so for now we run all tests in an emulator. The AArch64 build is cross-compiled from x86_64 from Linux. Tests all happen in release mode with a recent version of QEMU (recent version because it's so much faster, and in release mode because debug mode tests take quite a long time in an emulator). The goal here was not to get all tests passing on CI, but rather to get AArch64 running on CI and get it green at the same time. To achieve that goal many tests are now ignored on aarch64 platforms. Many tests fail due to unimplemented functionality in the aarch64 backend (#1521), and all wasmtime tests involving compilation are also disabled due to panicking attempting to generate generate instruction offset information for trap symbolication (#1523). Despite this, though, all Cranelift tests and other wasmtime tests should be runnin on AArch64 through QEMU with this PR. Additionally we'll have an AArch64 binary release of Wasmtime for Linux, although it won't be too useful just yet since it will panic on almost all wasm modules. * Review comments	5 years ago

1 2

52 Commits (039bbc240d64a221855ec50c7d4fc57f0583c95e)