Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

write the coredump to the configured path (#14779)

Xia Chaodcfbea188d3e
diff --git a/src/commands.rs b/src/commands.rs
index 9c19dd0893..ed70d5f837 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -49,3 +49,29 @@ pub use self::hot_blocks::*;
mod wizer;
#[cfg(feature = "wizer")]
pub use self::wizer::*;
+
+#[cfg(all(
+ feature = "coredump",
+ any(feature = "run", feature = "wizer", feature = "serve")
+))]
+fn write_core_dump(
+ store: &mut impl wasmtime::AsContextMut,
+ err: &wasmtime::Error,
+ name: &str,
+ path: &str,
+) -> wasmtime::Result<()> {
+ use std::fs::File;
+ use std::io::Write;
+ use wasmtime::error::Context as _;
+
+ let core_dump = err
+ .downcast_ref::<wasmtime::WasmCoreDump>()
+ .expect("should have been configured to capture core dumps");
+ let core_dump = core_dump.serialize(store, name);
+ let mut core_dump_file =
+ File::create(path).with_context(|| format!("failed to create file at `{path}`"))?;
+ core_dump_file
+ .write_all(&core_dump)
+ .with_context(|| format!("failed to write core dump file at `{path}`"))?;
+ Ok(())
+}
diff --git a/src/commands/run.rs b/src/commands/run.rs
index 5f04e76c8b..e007aaf176 100644
--- a/src/commands/run.rs
+++ b/src/commands/run.rs
@@ -1122,7 +1122,8 @@ impl RunCommand {
.to_str()
.unwrap_or_else(|| "unknown");
- if let Err(coredump_err) = write_core_dump(store, &err, &source_name, coredump_path) {
+ if let Err(coredump_err) = super::write_core_dump(store, &err, &source_name, coredump_path)
+ {
eprintln!("warning: coredump failed to generate: {coredump_err}");
err
} else {
@@ -1433,27 +1434,3 @@ impl wasmtime_wasi_tls::WasiTlsView for Host {
}
}
}
-
-#[cfg(feature = "coredump")]
-fn write_core_dump(
- store: &mut Store<Host>,
- err: &wasmtime::Error,
- name: &str,
- path: &str,
-) -> Result<()> {
- use std::fs::File;
- use std::io::Write;
-
- let core_dump = err
- .downcast_ref::<wasmtime::WasmCoreDump>()
- .expect("should have been configured to capture core dumps");
-
- let core_dump = core_dump.serialize(store, name);
-
- let mut core_dump_file =
- File::create(path).with_context(|| format!("failed to create file at `{path}`"))?;
- core_dump_file
- .write_all(&core_dump)
- .with_context(|| format!("failed to write core dump file at `{path}`"))?;
- Ok(())
-}
diff --git a/src/commands/serve.rs b/src/commands/serve.rs
index 3d05e06840..af09cee643 100644
--- a/src/commands/serve.rs
+++ b/src/commands/serve.rs
@@ -914,6 +914,10 @@ struct HostWorkerState {
max_instance_reuse_count: usize,
max_instance_concurrent_reuse_count: usize,
request_timeout: Duration,
+ #[cfg(feature = "coredump")]
+ coredump: Option<String>,
+ #[cfg(feature = "coredump")]
+ coredump_name: String,
}
impl WorkerState for HostWorkerState {
@@ -947,6 +951,8 @@ impl WorkerState for HostWorkerState {
fn drop(&self, mut store: Store<Self::StoreData>, result: Result<(), wasmtime::Error>) {
if let Err(error) = result {
eprintln!("worker failed: {error:?}");
+ #[cfg(feature = "coredump")]
+ write_serve_coredump(self, &mut store, &error);
}
if let Some(write_profile) = store.data_mut().write_profile.take() {
@@ -957,6 +963,20 @@ impl WorkerState for HostWorkerState {
}
}
+#[cfg(feature = "coredump")]
+fn write_serve_coredump(state: &HostWorkerState, store: &mut Store<Host>, error: &wasmtime::Error) {
+ let Some(path) = &state.coredump else {
+ return;
+ };
+ if error.downcast_ref::<wasmtime::WasmCoreDump>().is_none() {
+ return;
+ }
+ match super::write_core_dump(store, error, &state.coredump_name, path) {
+ Ok(()) => eprintln!("core dumped at {path}"),
+ Err(coredump_err) => eprintln!("warning: coredump failed to generate: {coredump_err}"),
+ }
+}
+
struct HostHandlerState {
cmd: ServeCommand,
component: Component,
@@ -1010,6 +1030,10 @@ impl HandlerState for HostHandlerState {
max_instance_concurrent_reuse_count: self.max_instance_concurrent_reuse_count,
instance_id,
request_timeout: self.cmd.run.common.wasm.timeout.unwrap_or(Duration::MAX),
+ #[cfg(feature = "coredump")]
+ coredump: self.cmd.run.common.debug.coredump.clone(),
+ #[cfg(feature = "coredump")]
+ coredump_name: self.cmd.component.to_str().unwrap_or("unknown").to_string(),
},
})
}
diff --git a/tests/all/cli_tests.rs b/tests/all/cli_tests.rs
index bf301742c9..7ec323b7b4 100644
--- a/tests/all/cli_tests.rs
+++ b/tests/all/cli_tests.rs
@@ -2442,6 +2442,41 @@ start a print 1234
p2_cli_serve_guest_never_invoked_set(P2_CLI_SERVE_TRAP_BEFORE_SET_COMPONENT).await
}
+ #[tokio::test]
+ async fn serve_coredump_smoketest() -> Result<()> {
+ let dir = tempfile::tempdir()?;
+ let core = dir.path().join("core");
+ let server = WasmtimeServe::new(P2_CLI_SERVE_TRAP_BEFORE_SET_COMPONENT, |cmd| {
+ cmd.arg("-Scli")
+ .arg(format!("-Dcoredump={}", core.display()));
+ })?;
+ let res = server
+ .send_request(
+ hyper::Request::builder()
+ .uri("http://localhost/")
+ .body(String::new())
+ .context("failed to make request")?,
+ )
+ .await?;
+ assert_eq!(res.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
+ let (_stdout, stderr) = server.finish()?;
+ let dumped = std::fs::read(&core)?;
+ let head = dumped.get(..16).unwrap_or(&dumped);
+ println!(
+ "observed guest={} path={} len={} magic={:02x?} head16={:02x?}",
+ P2_CLI_SERVE_TRAP_BEFORE_SET_COMPONENT,
+ core.display(),
+ dumped.len(),
+ dumped.get(..4).unwrap_or(&[]),
+ head,
+ );
+ assert!(core.exists(), "coredump file was not written: {stderr}");
+ assert!(stderr.contains(&format!("core dumped at {}", core.display())));
+ assert_eq!(dumped.get(..4), Some(&[0x00, 0x61, 0x73, 0x6d][..]));
+ assert_eq!(dumped.get(12..16), Some(&b"core"[..]));
+ Ok(())
+ }
+
#[test]
fn p3_cli_hello_stdout() -> Result<()> {
let output = run_wasmtime(&[