wasmer-wasix 0.702.0

WASI and WASIX implementation library for Wasmer WebAssembly runtime
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

use crate::{WasiEnv, WasiError};
use tracing::instrument;
use wasmer::{AsStoreRef, FunctionEnvMut, MemoryView};
use wasmer_wasix_types::wasi::Errno;

/// Destroy a suspended or terminated context
///
/// After a successful call its identifier becomes invalid and its
/// resources are released. Destroying an already deleted context is a no-op.
///
/// Refer to the wasix-libc [`wasix/context.h`] header for authoritative
/// documentation.
///
/// [`wasix/context.h`]: https://github.com/wasix-org/wasix-libc/blob/main/libc-bottom-half/headers/public/wasix/context.h
#[instrument(level = "trace", skip(ctx), ret)]
pub fn context_destroy(
    mut ctx: FunctionEnvMut<'_, WasiEnv>,
    target_context_id: u64,
) -> Result<Errno, WasiError> {
    WasiEnv::do_pending_operations(&mut ctx)?;

    let env = ctx.data();
    let memory: MemoryView<'_> = unsafe { env.memory_view(&ctx) };

    // Verify that we are in an async context
    let environment = match &env.context_switching_environment {
        Some(c) => c,
        None => {
            tracing::warn!(
                "The WASIX context-switching API is only available in a context-switching environment"
            );
            return Ok(Errno::Notsup);
        }
    };

    let own_context_id = environment.active_context_id();
    let main_context_id = environment.main_context_id();

    if own_context_id == target_context_id {
        tracing::trace!(
            "Context {} tried to delete itself, which is not allowed",
            target_context_id
        );
        return Ok(Errno::Inval);
    }

    if target_context_id == main_context_id {
        tracing::trace!(
            "Context {} tried to delete the main context, which is not allowed",
            own_context_id
        );
        return Ok(Errno::Inval);
    }

    let removed_unblocker = environment.destroy_context(&target_context_id);
    // As soon as the Sender is dropped, the corresponding context will be able unblocked,
    // the executor will continue executing it. The context will respond to the
    // cancelation by terminating gracefully.

    if !removed_unblocker {
        // Context did not exist, so we do not need to remove it
        tracing::trace!(
            "Context {} tried to delete context {} but it is already removed",
            own_context_id,
            target_context_id
        );
        return Ok(Errno::Success);
    };

    Ok(Errno::Success)
}