Open source experimental in-guest interception

Differential Revision: D41099658

fbshipit-source-id: 52b414e27abd3c0c3a6367dea225724f4220793b

Author: jasonwhite

experimental/nostd-print/Cargo.toml

@@ -0,0 +1,11 @@
+# @generated by autocargo
+
+[package]
+name = "nostd-print"
+version = "0.1.0"
+authors = ["Meta Platforms"]
+edition = "2021"
+license = "BSD-2-Clause"
+
+[dependencies]
+syscalls = { version = "0.6.7", features = ["serde"] }

experimental/nostd-print/src/lib.rs

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+//! Provides helpers for printing formatted messages to stdout/stderr without
+//! relying on std.
+
+use core::fmt;
+use core::fmt::Write;
+
+use syscalls::syscall3;
+use syscalls::Errno;
+use syscalls::Sysno;
+
+#[inline(always)]
+fn sys_write(fd: i32, buf: &[u8]) -> Result<usize, Errno> {
+    unsafe { syscall3(Sysno::write, fd as usize, buf.as_ptr() as usize, buf.len()) }
+}
+
+fn sys_write_all(fd: i32, mut buf: &[u8]) -> Result<(), Errno> {
+    while !buf.is_empty() {
+        match sys_write(fd, buf) {
+            Ok(n) => buf = &buf[n..],
+            Err(Errno::EINTR) => continue,
+            Err(errno) => return Err(errno),
+        }
+    }
+    Ok(())
+}
+
+struct Stdio<const N: usize = 4096> {
+    fd: i32,
+    buf: [u8; N],
+    len: usize,
+}
+
+impl<const N: usize> Stdio<N> {
+    pub fn new(fd: i32) -> Self {
+        Self {
+            fd,
+            buf: [0; N],
+            len: 0,
+        }
+    }
+
+    pub fn write_all(&mut self, mut buf: &[u8]) -> Result<(), Errno> {
+        while !buf.is_empty() {
+            if self.buf[self.len..].is_empty() {
+                self.flush()?;
+            }
+            let remaining = &mut self.buf[self.len..];
+            let count = remaining.len().min(buf.len());
+            remaining[0..count].copy_from_slice(&buf[0..count]);
+            self.len += count;
+            buf = &buf[count..];
+        }
+
+        Ok(())
+    }
+
+    /// Flushes the buffered writes to the file descriptor.
+    pub fn flush(&mut self) -> Result<(), Errno> {
+        sys_write_all(self.fd, &self.buf[0..self.len])?;
+        self.len = 0;
+        Ok(())
+    }
+}
+
+impl<const N: usize> Drop for Stdio<N> {
+    fn drop(&mut self) {
+        let _ = self.flush();
+    }
+}
+
+impl fmt::Write for Stdio {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_all(s.as_bytes()).map_err(|_| fmt::Error)
+    }
+}
+
+fn _inner_print(fd: i32, args: fmt::Arguments<'_>, newline: bool) -> fmt::Result {
+    let mut f = Stdio::new(fd);
+    f.write_fmt(args)?;
+
+    if newline {
+        f.write_str("\n")?;
+    }
+
+    Ok(())
+}
+
+#[doc(hidden)]
+pub fn _print(fd: i32, args: fmt::Arguments<'_>, newline: bool) {
+    // Ignore the error.
+    let _ = _inner_print(fd, args, newline);
+}
+
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::_print(1, ::core::format_args!($($arg)*), false));
+}
+
+#[macro_export]
+macro_rules! eprint {
+    ($($arg:tt)*) => ($crate::_print(2, ::core::format_args!($($arg)*), false));
+}
+
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ({
+        // Purposefully avoiding format_args_nl because it requires a nightly
+        // feature.
+        $crate::_print(1, ::core::format_args!($($arg)*), true);
+    })
+}
+
+#[macro_export]
+macro_rules! eprintln {
+    () => ($crate::eprint!("\n"));
+    ($($arg:tt)*) => ({
+        // Purposefully avoiding format_args_nl because it requires a nightly
+        // feature.
+        $crate::_print(2, ::core::format_args!($($arg)*), true);
+    })
+}

experimental/reverie-host/Cargo.toml

@@ -0,0 +1,17 @@
+# @generated by autocargo
+
+[package]
+name = "reverie-host"
+version = "0.1.0"
+authors = ["Meta Platforms"]
+edition = "2021"
+license = "BSD-2-Clause"
+
+[dependencies]
+anyhow = "1.0.65"
+dirs = "2.0"
+reverie-process = { version = "0.1.0", path = "../../reverie-process" }
+reverie-rpc = { version = "0.1.0", path = "../reverie-rpc" }
+serde = { version = "1.0.136", features = ["derive", "rc"] }
+tempfile = "3.3"
+tokio = { version = "1.21.2", features = ["full", "test-util", "tracing"] }

experimental/reverie-host/src/codec.rs

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+use core::marker::Unpin;
+use std::io;
+
+use serde::Deserialize;
+use serde::Serialize;
+use tokio::io::AsyncRead;
+use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWrite;
+use tokio::io::AsyncWriteExt;
+
+pub async fn read<'a, T, S>(stream: &mut S, buf: &'a mut Vec<u8>) -> io::Result<T>
+where
+    T: Deserialize<'a>,
+    S: AsyncRead + Unpin,
+{
+    let len = stream.read_u32().await? as usize;
+
+    buf.resize(len, 0);
+
+    stream.read_exact(buf).await?;
+
+    reverie_rpc::decode_frame(buf)
+}
+
+pub async fn write<T, S>(stream: &mut S, buf: &mut Vec<u8>, item: T) -> io::Result<()>
+where
+    T: Serialize,
+    S: AsyncWrite + Unpin,
+{
+    buf.clear();
+
+    reverie_rpc::encode(&item, buf)?;
+
+    stream.write_all(buf).await
+}

experimental/reverie-host/src/lib.rs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+//! This crate does two main things:
+//!  * Handles launching the root child process.
+//!  * Provides an interface for managing global state for in-guest backends.
+
+mod codec;
+mod server;
+mod tracer;
+
+pub use server::*;
+pub use tracer::*;

experimental/reverie-host/src/server.rs

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+use std::path::Path;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use reverie_rpc::Service;
+use tempfile::NamedTempFile;
+use tokio::net::UnixListener;
+
+use super::codec;
+
+/// A global state server.
+pub struct Server {
+    socket: NamedTempFile<UnixListener>,
+}
+
+impl Server {
+    /// Creates the server, but does not yet listen for incoming connections.
+    pub fn new() -> Result<Self> {
+        let sock_dir = dirs::runtime_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+
+        let prefix = format!("reverie-{}-", std::process::id());
+        let socket = tempfile::Builder::new()
+            .prefix(&prefix)
+            .suffix(".sock")
+            .make_in(sock_dir, |path| UnixListener::bind(path))?;
+
+        Ok(Self { socket })
+    }
+
+    /// Returns the path to the socket.
+    pub fn sock_path(&self) -> &Path {
+        self.socket.path()
+    }
+
+    /// Accepts new socket connections and processes them.
+    pub async fn serve<S>(&self, service: S) -> !
+    where
+        S: Service + Clone + Send + Sync + 'static,
+    {
+        loop {
+            match self.socket.as_file().accept().await {
+                Ok((mut stream, _addr)) => {
+                    let service = service.clone();
+
+                    tokio::spawn(async move {
+                        let mut reader_buf = Vec::with_capacity(1024);
+                        let mut writer_buf = Vec::with_capacity(1024);
+
+                        while let Ok(request) = codec::read(&mut stream, &mut reader_buf).await {
+                            if let Some(response) = service.call(request).await {
+                                // Only send back a response if this request has
+                                // an associated response. This lets us have
+                                // "send-only" messages, which are useful for
+                                // accumulating state.
+                                codec::write(&mut stream, &mut writer_buf, response)
+                                    .await
+                                    .unwrap();
+                            }
+                        }
+                    });
+                }
+                Err(e) => {
+                    eprintln!("connection failed: {}", e);
+                }
+            }
+        }
+    }
+}