formalize codegen toggles, add that and version info to modules

also add a check in lucet-runtime that modules loaded have capabilities
(and thus, version information) present, rejecting modules that do not

Author: awortman-fastly

lucet-analyze/src/main.rs

@@ -2,6 +2,7 @@
 
 use lucet_module::{
     FunctionSpec, Module, ModuleData, SerializedModule, TableElement, TrapManifest, TrapSite,
+    VersionInfo,
 };
 
 use byteorder::{LittleEndian, ReadBytesExt};
@@ -102,7 +103,12 @@ impl<'a> ArtifactSummary<'a> {
                 .unwrap();
             let mut rdr = Cursor::new(buffer);
 
+            let version = unsafe {
+                std::mem::transmute::<u64, VersionInfo>(rdr.read_u64::<LittleEndian>().unwrap())
+            };
+
             SerializedModule {
+                version,
                 module_data_ptr: rdr.read_u64::<LittleEndian>().unwrap(),
                 module_data_len: rdr.read_u64::<LittleEndian>().unwrap(),
                 tables_ptr: rdr.read_u64::<LittleEndian>().unwrap(),
@@ -211,6 +217,7 @@ fn load_module<'b, 'a: 'b>(
         )
     };
     Module {
+        version: serialized_module.version.clone(),
         module_data,
         tables,
         function_manifest,

lucet-module/src/lib.rs

@@ -17,6 +17,7 @@ mod signature;
 mod tables;
 mod traps;
 mod types;
+mod version_info;
 
 pub use crate::error::Error;
 pub use crate::functions::{
@@ -32,6 +33,7 @@ pub use crate::signature::{ModuleSignature, PublicKey};
 pub use crate::tables::TableElement;
 pub use crate::traps::{TrapCode, TrapManifest, TrapSite};
 pub use crate::types::{Signature, ValueType};
+pub use crate::version_info::{Capabilities, CapabilitiesBuilder, VersionInfo};
 
 /// Owned variants of the module data types, useful for serialization and testing.
 pub mod owned {

lucet-module/src/module.rs

@@ -1,12 +1,14 @@
 use crate::functions::FunctionSpec;
 use crate::module_data::ModuleData;
 use crate::tables::TableElement;
+use crate::version_info::VersionInfo;
 
 pub const LUCET_MODULE_SYM: &str = "lucet_module";
 
 /// Module is the exposed structure that contains all the data backing a Lucet-compiled object.
 #[derive(Debug)]
 pub struct Module<'a> {
+    pub version: VersionInfo,
     pub module_data: ModuleData<'a>,
     pub tables: &'a [&'a [TableElement]],
     pub function_manifest: &'a [FunctionSpec],
@@ -18,6 +20,7 @@ pub struct Module<'a> {
 #[repr(C)]
 #[derive(Debug)]
 pub struct SerializedModule {
+    pub version: VersionInfo,
     pub module_data_ptr: u64,
     pub module_data_len: u64,
     pub tables_ptr: u64,

lucet-module/src/version_info.rs

@@ -0,0 +1,112 @@
+/// VersionInfo is information about a Lucet module to allow the Lucet runtime to determine if or
+/// how the module can be loaded, if so requested. The information here describes implementation
+/// details in runtime support for `lucetc`-produced modules, and nothing higher level.
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct VersionInfo {
+    major: u8,
+    minor: u8,
+    patch: u8,
+    reserved: u8,
+    pub capabilities: Capabilities,
+}
+
+impl VersionInfo {
+    pub fn current() -> Self {
+        VersionInfo {
+            major: 0,
+            minor: 1,
+            patch: 0,
+            reserved: 0,
+            capabilities: Capabilities::default(),
+        }
+    }
+}
+
+const INSTRUCTIONS_COUNTED_BIT: u8 = 0;
+
+// This bit will always be 1 if capabilities and version info are present.
+//
+// The reasoning for this is as follows:
+// `SerializedModule`, in version before version information was introduced, began with a pointer -
+// `module_data_ptr`. This pointer would be relocated to somewhere in user space for the embedder
+// of `lucet-runtime`. On x86_64, hopefully, that's userland code in some OS, meaning the pointer
+// will be a pointer to user memory, and will be below 0x8000_0000_0000_0000. By setting bit 31 in
+// capabilities, we set what would be the highest bit in `module_data_ptr` in an old
+// `lucet-runtime` and guarantee a segmentation fault when loading these newer modules with version
+// information.
+const CAPABILITIES_BIT: u8 = 31;
+
+/// In addition to structure compatibility, a module can declare capabilities to the runtime. These
+/// do not necessarily require any runtime support, but indicate variations to the module that the
+/// runtime may find interesting.
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct Capabilities {
+    caps: u32,
+}
+
+impl From<u32> for Capabilities {
+    fn from(caps: u32) -> Capabilities {
+        Capabilities { caps }
+    }
+}
+
+impl Capabilities {
+    fn get_bit(&self, bit_num: u8) -> bool {
+        assert!(bit_num < 32);
+        let bit = (self.caps >> bit_num) & 1;
+        if bit == 0 {
+            false
+        } else {
+            true
+        }
+    }
+
+    pub fn instructions_counted(&self) -> bool {
+        self.get_bit(INSTRUCTIONS_COUNTED_BIT)
+    }
+
+    pub fn present(&self) -> bool {
+        self.get_bit(CAPABILITIES_BIT)
+    }
+}
+
+impl Default for Capabilities {
+    fn default() -> Self {
+        CapabilitiesBuilder::new().build()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct CapabilitiesBuilder {
+    caps: u32,
+}
+
+impl CapabilitiesBuilder {
+    /// A CapabilitiesBuilder with all capabilities disabled
+    pub fn new() -> Self {
+        let mut caps = CapabilitiesBuilder { caps: 0u32 };
+        caps.set_bit(CAPABILITIES_BIT, true);
+        caps
+    }
+
+    fn set_bit(&mut self, bit_num: u8, setting: bool) {
+        assert!(bit_num < 32);
+        self.caps &= !(1 << bit_num);
+        self.caps |= (setting as u32) << bit_num;
+    }
+
+    pub fn instructions_counted(&mut self, setting: bool) {
+        self.set_bit(INSTRUCTIONS_COUNTED_BIT, setting);
+    }
+
+    pub fn with_instructions_counted(mut self, setting: bool) -> Self {
+        self.instructions_counted(setting);
+        self
+    }
+
+    pub fn build(self) -> Capabilities {
+        self.caps.into()
+    }
+}

lucet-runtime/lucet-runtime-internals/src/module/dl.rs

@@ -61,6 +61,12 @@ impl DlModule {
         let serialized_module: &SerializedModule =
             unsafe { serialized_module_ptr.as_ref().unwrap() };
 
+        let version = serialized_module.version.clone();
+
+        if !version.capabilities.present() {
+            return Err(lucet_incorrect_module!("error loading module: capabilities are not present. This module is likely too old for this lucet-runtime to load."));
+        }
+
         // Deserialize the slice into ModuleData, which will hold refs into the loaded
         // shared object file in `module_data_slice`. Both of these get a 'static lifetime because
         // Rust doesn't have a safe way to describe that their lifetime matches the containing
@@ -115,6 +121,7 @@ impl DlModule {
             lib,
             fbase,
             module: lucet_module::Module {
+                version,
                 module_data,
                 tables,
                 function_manifest,

lucet-spectest/src/script.rs

@@ -1,5 +1,6 @@
 use crate::bindings;
 use failure::{format_err, Error, Fail};
+use lucet_module::CapabilitiesBuilder;
 use lucet_runtime::{self, MmapRegion, Module as LucetModule, Region, UntypedRetVal, Val};
 use lucetc::{Compiler, HeapSettings, LucetcError, LucetcErrorKind, OptLevel};
 use std::io;
@@ -72,7 +73,9 @@ impl ScriptEnv {
             OptLevel::Fast,
             &bindings,
             HeapSettings::default(),
-            true,
+            CapabilitiesBuilder::new()
+                .with_instructions_counted(true)
+                .build(),
         )
         .map_err(program_error)?;
 

lucet-wasi-sdk/tests/lucetc.rs

@@ -2,6 +2,7 @@
 mod lucetc_tests {
     use failure::Error;
     use lucet_module::bindings::Bindings;
+    use lucet_module::Capabilities;
     use lucet_wasi_sdk::*;
     use lucetc::{Compiler, HeapSettings, OptLevel};
     use std::collections::HashMap;
@@ -39,7 +40,8 @@ mod lucetc_tests {
         let m = module_from_c(&["empty"], &[]).expect("build module for empty");
         let b = Bindings::empty();
         let h = HeapSettings::default();
-        let c = Compiler::new(&m, OptLevel::Fast, &b, h, false).expect("compile empty");
+        let c = Compiler::new(&m, OptLevel::Fast, &b, h, Capabilities::default())
+            .expect("compile empty");
         let mdata = c.module_data().unwrap();
         assert!(mdata.heap_spec().is_some());
         // clang creates 3 globals:
@@ -74,7 +76,8 @@ mod lucetc_tests {
         let m = module_from_c(&["c"], &["c"]).expect("build module for c");
         let b = Bindings::empty();
         let h = HeapSettings::default();
-        let c = Compiler::new(&m, OptLevel::Fast, &b, h, false).expect("compile c");
+        let c =
+            Compiler::new(&m, OptLevel::Fast, &b, h, Capabilities::default()).expect("compile c");
         let mdata = c.module_data().unwrap();
         assert_eq!(mdata.import_functions().len(), 0, "import functions");
         assert_eq!(mdata.export_functions().len(), 1, "export functions");
@@ -91,7 +94,8 @@ mod lucetc_tests {
         let m = module_from_c(&["d"], &["d"]).expect("build module for d");
         let b = d_only_test_bindings();
         let h = HeapSettings::default();
-        let c = Compiler::new(&m, OptLevel::Fast, &b, h, false).expect("compile d");
+        let c =
+            Compiler::new(&m, OptLevel::Fast, &b, h, Capabilities::default()).expect("compile d");
         let mdata = c.module_data().unwrap();
         assert_eq!(mdata.import_functions().len(), 1, "import functions");
         assert_eq!(mdata.export_functions().len(), 1, "export functions");
@@ -107,7 +111,8 @@ mod lucetc_tests {
         let m = module_from_c(&["c", "d"], &["c", "d"]).expect("build module for c & d");
         let b = Bindings::empty();
         let h = HeapSettings::default();
-        let c = Compiler::new(&m, OptLevel::Fast, &b, h, false).expect("compile c & d");
+        let c = Compiler::new(&m, OptLevel::Fast, &b, h, Capabilities::default())
+            .expect("compile c & d");
         let mdata = c.module_data().unwrap();
         assert_eq!(mdata.import_functions().len(), 0, "import functions");
         assert_eq!(mdata.export_functions().len(), 2, "export functions");

lucetc/src/compiler.rs

@@ -19,7 +19,7 @@ use cranelift_native;
 use cranelift_wasm::{translate_module, FuncTranslator, WasmError};
 use failure::{format_err, Fail, ResultExt};
 use lucet_module::bindings::Bindings;
-use lucet_module::{FunctionSpec, ModuleData, MODULE_DATA_SYM};
+use lucet_module::{Capabilities, FunctionSpec, ModuleData, MODULE_DATA_SYM};
 
 #[derive(Debug, Clone, Copy)]
 pub enum OptLevel {
@@ -48,7 +48,7 @@ pub struct Compiler<'a> {
     decls: ModuleDecls<'a>,
     clif_module: ClifModule<FaerieBackend>,
     opt_level: OptLevel,
-    count_instructions: bool,
+    capabilities: Capabilities,
 }
 
 impl<'a> Compiler<'a> {
@@ -57,7 +57,7 @@ impl<'a> Compiler<'a> {
         opt_level: OptLevel,
         bindings: &'a Bindings,
         heap_settings: HeapSettings,
-        count_instructions: bool,
+        capabilities: Capabilities,
     ) -> Result<Self, LucetcError> {
         let isa = Self::target_isa(opt_level);
 
@@ -108,7 +108,7 @@ impl<'a> Compiler<'a> {
             decls,
             clif_module,
             opt_level,
-            count_instructions,
+            capabilities,
         })
     }
 
@@ -120,7 +120,8 @@ impl<'a> Compiler<'a> {
         let mut func_translator = FuncTranslator::new();
 
         for (ref func, (code, code_offset)) in self.decls.function_bodies() {
-            let mut func_info = FuncInfo::new(&self.decls, self.count_instructions);
+            let mut func_info =
+                FuncInfo::new(&self.decls, self.capabilities.instructions_counted());
             let mut clif_context = ClifContext::new();
             clif_context.func.name = func.name.as_externalname();
             clif_context.func.signature = func.signature.clone();
@@ -175,7 +176,8 @@ impl<'a> Compiler<'a> {
         let mut func_translator = FuncTranslator::new();
 
         for (ref func, (code, code_offset)) in self.decls.function_bodies() {
-            let mut func_info = FuncInfo::new(&self.decls, self.count_instructions);
+            let mut func_info =
+                FuncInfo::new(&self.decls, self.capabilities.instructions_counted());
             let mut clif_context = ClifContext::new();
             clif_context.func.name = func.name.as_externalname();
             clif_context.func.signature = func.signature.clone();

lucetc/src/lib.rs

@@ -31,6 +31,7 @@ pub use crate::{
 };
 use failure::{format_err, Error, ResultExt};
 pub use lucet_module::bindings::Bindings;
+use lucet_module::CapabilitiesBuilder;
 use signature::{PublicKey, SecretKey};
 use std::env;
 use std::path::{Path, PathBuf};
@@ -51,7 +52,7 @@ pub struct Lucetc {
     pk: Option<PublicKey>,
     sign: bool,
     verify: bool,
-    count_instructions: bool,
+    capabilities: CapabilitiesBuilder,
 }
 
 pub trait AsLucetc {
@@ -207,12 +208,12 @@ impl<T: AsLucetc> LucetcOpts for T {
         self
     }
 
-    fn count_instructions(&mut self, count_instructions: bool) {
-        self.as_lucetc().count_instructions = count_instructions;
+    fn count_instructions(&mut self, count: bool) {
+        self.as_lucetc().capabilities.instructions_counted(count);
     }
 
-    fn with_count_instructions(mut self, count_instructions: bool) -> Self {
-        self.count_instructions(count_instructions);
+    fn with_count_instructions(mut self, count: bool) -> Self {
+        self.count_instructions(count);
         self
     }
 }
@@ -230,7 +231,7 @@ impl Lucetc {
             sk: None,
             sign: false,
             verify: false,
-            count_instructions: false,
+            capabilities: CapabilitiesBuilder::new(),
         }
     }
 
@@ -246,7 +247,7 @@ impl Lucetc {
             sk: None,
             sign: false,
             verify: false,
-            count_instructions: false,
+            capabilities: CapabilitiesBuilder::new(),
         })
     }
 
@@ -286,7 +287,7 @@ impl Lucetc {
             self.opt_level,
             &bindings,
             self.heap.clone(),
-            self.count_instructions,
+            self.capabilities.clone().build(),
         )?;
         let obj = compiler.object_file()?;
 
@@ -302,7 +303,7 @@ impl Lucetc {
             self.opt_level,
             &bindings,
             self.heap.clone(),
-            self.count_instructions,
+            self.capabilities.clone().build(),
         )?;
 
         compiler