Revert "Support registering custom syscalls" (#127)

Author: buffalojoec

Cargo.lock

@@ -29,7 +29,6 @@ audit:
 # Build test programs
 build-test-programs:
 	@cargo build-sbf --manifest-path test-programs/cpi-target/Cargo.toml
-	@cargo build-sbf --manifest-path test-programs/custom-syscall/Cargo.toml
 	@cargo build-sbf --manifest-path test-programs/primary/Cargo.toml
 
 # Pre-publish checks
@@ -85,7 +84,6 @@ check-features:
 
 # Run tests
 test:
-	@$(MAKE) build-test-programs
 	@cargo test --all-features
 
 # Run all checks in sequence

Makefile

@@ -503,7 +503,6 @@ impl Default for Mollusk {
              solana_runtime::message_processor=debug,\
              solana_runtime::system_instruction_processor=trace",
         );
-        let compute_budget = ComputeBudget::default();
         #[cfg(feature = "fuzz")]
         let feature_set = {
             // Omit "test features" (they have the same u64 ID).
@@ -516,13 +515,12 @@ impl Default for Mollusk {
         };
         #[cfg(not(feature = "fuzz"))]
         let feature_set = FeatureSet::all_enabled();
-        let program_cache = ProgramCache::new(&feature_set, &compute_budget);
         Self {
             config: Config::default(),
-            compute_budget,
+            compute_budget: ComputeBudget::default(),
             feature_set,
             logger: None,
-            program_cache,
+            program_cache: ProgramCache::default(),
             sysvars: Sysvars::default(),
             #[cfg(feature = "fuzz-fd")]
             slot: 0,
@@ -575,7 +573,13 @@ impl Mollusk {
         elf: &[u8],
         loader_key: &Pubkey,
     ) {
-        self.program_cache.add_program(program_id, loader_key, elf);
+        self.program_cache.add_program(
+            program_id,
+            loader_key,
+            elf,
+            &self.compute_budget,
+            &self.feature_set,
+        );
     }
 
     /// Warp the test environment to a slot by updating sysvars.

harness/src/lib.rs

@@ -8,12 +8,8 @@ use {
     solana_loader_v3_interface::state::UpgradeableLoaderState,
     solana_loader_v4_interface::state::{LoaderV4State, LoaderV4Status},
     solana_program_runtime::{
-        invoke_context::{BuiltinFunctionWithContext, InvokeContext},
+        invoke_context::BuiltinFunctionWithContext,
         loaded_programs::{LoadProgramMetrics, ProgramCacheEntry, ProgramCacheForTxBatch},
-        solana_sbpf::{
-            elf::ElfError,
-            program::{BuiltinFunction, BuiltinProgram},
-        },
     },
     solana_pubkey::Pubkey,
     solana_rent::Rent,
@@ -61,23 +57,13 @@ pub struct ProgramCache {
     //
     // K: program ID, V: loader key
     entries_cache: Rc<RefCell<HashMap<Pubkey, Pubkey>>>,
-    // The function registry (syscalls) to use for verifying and loading
-    // program ELFs.
-    program_runtime_environment: BuiltinProgram<InvokeContext<'static>>,
 }
 
-impl ProgramCache {
-    pub fn new(feature_set: &FeatureSet, compute_budget: &ComputeBudget) -> Self {
+impl Default for ProgramCache {
+    fn default() -> Self {
         let me = Self {
             cache: Rc::new(RefCell::new(ProgramCacheForTxBatch::default())),
             entries_cache: Rc::new(RefCell::new(HashMap::new())),
-            program_runtime_environment: create_program_runtime_environment_v1(
-                feature_set,
-                compute_budget,
-                /* reject_deployment_of_broken_elfs */ false,
-                /* debugging_features */ false,
-            )
-            .unwrap(),
         };
         BUILTINS.iter().for_each(|builtin| {
             let program_id = builtin.program_id;
@@ -86,7 +72,9 @@ impl ProgramCache {
         });
         me
     }
+}
 
+impl ProgramCache {
     pub(crate) fn cache(&self) -> RefMut<ProgramCacheForTxBatch> {
         self.cache.borrow_mut()
     }
@@ -106,24 +94,18 @@ impl ProgramCache {
     }
 
     /// Add a program to the cache.
-    pub fn add_program(&mut self, program_id: &Pubkey, loader_key: &Pubkey, elf: &[u8]) {
-        // This might look rough, but it's actually functionally the same as
-        // calling `create_program_runtime_environment_v1` on every addition.
-        let environment = {
-            let config = self.program_runtime_environment.get_config().clone();
-            let mut loader = BuiltinProgram::new_loader(config);
-
-            for (_key, (name, value)) in self
-                .program_runtime_environment
-                .get_function_registry()
-                .iter()
-            {
-                let name = std::str::from_utf8(name).unwrap();
-                loader.register_function(name, value).unwrap();
-            }
-
-            Arc::new(loader)
-        };
+    pub fn add_program(
+        &mut self,
+        program_id: &Pubkey,
+        loader_key: &Pubkey,
+        elf: &[u8],
+        compute_budget: &ComputeBudget,
+        feature_set: &FeatureSet,
+    ) {
+        let environment = Arc::new(
+            create_program_runtime_environment_v1(feature_set, compute_budget, false, false)
+                .unwrap(),
+        );
         self.replenish(
             *program_id,
             Arc::new(
@@ -167,19 +149,6 @@ impl ProgramCache {
             })
             .collect()
     }
-
-    /// Register a new function (syscall) with the program runtime environment.
-    ///
-    /// **Important**: You should register all custom syscalls BEFORE adding any
-    /// programs to the store that will use them.
-    pub fn register_function(
-        &mut self,
-        name: &str,
-        value: BuiltinFunction<InvokeContext<'static>>,
-    ) -> Result<(), ElfError> {
-        self.program_runtime_environment
-            .register_function(name, value)
-    }
 }
 
 pub struct Builtin {