Module shadow_rs::host::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.