Module context

This module provides several Context structs, intended to bundle together current relevant objects in the hierarchy.

These are meant to replace worker_getActiveThread, etc. Passing around the current context explicitly instead of putting them in globals both allows us to avoid interior mutability (and its associated runtime cost and fallibility), and lets us keep a hierarchical object structure (e.g. allow holding a mutable Process and a mutable Thread belonging to that process simultaneously).

Most code (e.g. syscall handlers) can take a ThreadContext argument and use that to manipulate anything on the Host. The current Thread and Process should typically be accessed directly. e.g. since a mutable reference to the current Thread exists at ThreadContext::thread, it cannot also be accessible via ThreadContext::process or ThreadContext::host.

The manner in which they’re unavailable isn’t implemented yet, but the current plan is that they’ll be temporarily removed from their collections. e.g. something conceptually like:

impl Process {
    pub fn continue_thread(&mut self, host_ctx: &mut HostContext, tid: ThreadId) {
        let thread = self.threads.get_mut(tid).take();
        thread.continue(&mut host_ctx.add_process(self));
        self.threads.get_mut(tid).replace(thread);
    }
}

The Context objects are designed to allow simultaneously borrowing from multiple of their objects. This is currently implemented by exposing their fields directly - Rust then allows each field to be borrowed independently. This could alternatively be implemented by providing methods that borrow some or all of their internal references simultaneously.

Structs

HostContext

Represent the “current” Host.

ProcessContext

Represent the “current” Host and Process.

ThreadContext

Represent the “current” Host, Process, and Thread.

ThreadContextObjs

Shadow’s C code doesn’t know about contexts. In places where C code calls Rust code, we can build them from C pointers.