openvmm_entry/
crash_dump.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Guest crash dump helpers.

use anyhow::Context;
use futures::StreamExt;
use futures_concurrency::stream::Merge;
use get_resources::crash::GuestCrashDeviceHandle;
use mesh::OneshotReceiver;
use mesh::channel;
use mesh::rpc::FailableRpc;
use pal_async::task::Spawn;
use pal_async::task::Task;
use std::fs::File;
use std::path::Path;
use std::path::PathBuf;
use unicycle::FuturesUnordered;
use vm_resource::IntoResource;
use vm_resource::Resource;
use vm_resource::kind::VmbusDeviceHandleKind;

/// Spawns a crash dump handling task and returns a resource to instantiate a
/// guest crash device.
pub fn spawn_dump_handler(
    spawner: impl Spawn,
    dump_path: PathBuf,
    max_file_size: Option<u64>,
) -> (Resource<VmbusDeviceHandleKind>, Task<()>) {
    const DEFAULT_MAX_DUMP_SIZE: u64 = 256 * 1024 * 1024;

    let (send, recv) = channel::<FailableRpc<_, _>>();
    let task = spawner.spawn("crash_dumps", async move {
        handle_dump_requests(&dump_path, recv).await
    });
    let config = GuestCrashDeviceHandle {
        request_dump: send,
        max_dump_size: max_file_size.unwrap_or(DEFAULT_MAX_DUMP_SIZE),
    };
    (config.into_resource(), task)
}

/// Handles dump requests from the crash dump device by opening files in the
/// provided path.
pub async fn handle_dump_requests(
    dump_path: &Path,
    mut recv: mesh::Receiver<
        mesh::rpc::Rpc<OneshotReceiver<()>, Result<File, mesh::error::RemoteError>>,
    >,
) {
    let mut tasks = FuturesUnordered::new();
    while let Some(rpc) = ((&mut recv).map(Some), (&mut tasks).map(|()| None))
        .merge()
        .next()
        .await
    {
        let Some(rpc) = rpc else { continue };
        rpc.handle_failable_sync(|done| {
            let tempfile = tempfile::Builder::new()
                .prefix("underhill.")
                .suffix(".core")
                .tempfile_in(dump_path)
                .context("failed to create file")?;

            let file = tempfile
                .as_file()
                .try_clone()
                .context("failed to clone file")?;

            tracing::info!(path = %tempfile.path().display(), "writing VTL2 crash dump");
            tasks.push(wait_for_dump(done, tempfile));
            anyhow::Ok(file)
        })
    }
}

async fn wait_for_dump(done: OneshotReceiver<()>, tempfile: tempfile::NamedTempFile) {
    if let Ok(()) = done.await {
        match tempfile.keep() {
            Ok((_, path)) => {
                tracing::info!(
                    path = %path.display(),
                    "wrote VTL2 crash dump"
                );
            }
            Err(err) => {
                tracing::error!(
                    path = %err.file.path().display(),
                    "failed to persist VTL2 dump file"
                );
            }
        }
    } else {
        tracing::info!(
            path = %tempfile.path().display(),
            "VTL2 crash dump did not complete, removing"
        );
        drop(tempfile);
    }
}