Make BPF Loader static

bench-exchange/tests/bench_exchange.rs

@@ -7,7 +7,7 @@ use solana_exchange_program::id;
 use solana_exchange_program::solana_exchange_program;
 use solana_faucet::faucet::run_local_faucet;
 use solana_local_cluster::local_cluster::{ClusterConfig, LocalCluster};
-use solana_runtime::bank::Bank;
+use solana_runtime::bank::{Bank, BuiltinEntrypoint};
 use solana_runtime::bank_client::BankClient;
 use solana_sdk::genesis_config::create_genesis_config;
 use solana_sdk::signature::{Keypair, Signer};
@@ -86,7 +86,11 @@ fn test_exchange_bank_client() {
     solana_logger::setup();
     let (genesis_config, identity) = create_genesis_config(100_000_000_000_000);
     let mut bank = Bank::new(&genesis_config);
-    bank.add_builtin_program("exchange_program", id(), process_instruction);
+    bank.add_builtin(
+        "exchange_program",
+        id(),
+        BuiltinEntrypoint::Program(process_instruction),
+    );
     let clients = vec![BankClient::new(bank)];
 
     let mut config = Config::default();

core/src/validator.rs

@@ -190,7 +190,7 @@ impl Validator {
         }
         report_target_features();
 
-        info!("entrypoint: {:?}", entrypoint_info_option);
+        // info!("entrypoint: {:?}", entrypoint_info_option);
 
         if solana_perf::perf_libs::api().is_some() {
             info!("Initializing sigverify, this could take a while...");
@@ -868,10 +868,10 @@ impl TestValidator {
             42,
             bootstrap_validator_lamports,
         );
-        genesis_config
-            .native_instruction_processors
-            .push(solana_bpf_loader_program!());
-
+        // TODO
+        // genesis_config
+        // .native_instruction_processors
+        // .push(solana_bpf_loader_program!());
         genesis_config.rent.lamports_per_byte_year = 1;
         genesis_config.rent.exemption_threshold = 1.0;
         genesis_config.fee_rate_governor = FeeRateGovernor::new(fees, 0);

genesis-programs/src/lib.rs

@@ -1,6 +1,3 @@
-use solana_sdk::{
-    clock::Epoch, genesis_config::OperatingMode, inflation::Inflation, pubkey::Pubkey,
-};
 
 #[macro_use]
 extern crate solana_bpf_loader_program;
@@ -12,7 +9,11 @@ extern crate solana_exchange_program;
 extern crate solana_vest_program;
 
 use log::*;
-use solana_runtime::bank::{Bank, EnteredEpochCallback};
+use solana_runtime::bank::{Bank, BuiltinEntrypoint, EnteredEpochCallback};
+use solana_sdk::{
+    bpf_loader, clock::Epoch, genesis_config::OperatingMode, inflation::Inflation,
+    pubkey::Pubkey,
+};
 
 pub fn get_inflation(operating_mode: OperatingMode, epoch: Epoch) -> Option<Inflation> {
     match operating_mode {
@@ -45,17 +46,28 @@ pub fn get_inflation(operating_mode: OperatingMode, epoch: Epoch) -> Option<Infl
     }
 }
 
-pub fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<(String, Pubkey)>> {
+// TODO Need to be public?
+pub enum Program {
+    Native((String, Pubkey)),
+    Builtin(String, Pubkey, BuiltinEntrypoint),
+}
+
+pub fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<Program>> {
+    println!("get_progarms {:?} {:?}", operating_mode, epoch);
     match operating_mode {
         OperatingMode::Development => {
             if epoch == 0 {
                 Some(vec![
                     // Enable all Stable programs
-                    solana_bpf_loader_program!(),
-                    solana_vest_program!(),
+                    Program::Builtin(
+                        "bpf_loader_program".to_string(),
+                        bpf_loader::id(),
+                        BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+                    ),
+                    Program::Native(solana_vest_program!()),
                     // Programs that are only available in Development mode
-                    solana_budget_program!(),
-                    solana_exchange_program!(),
+                    Program::Native(solana_budget_program!()),
+                    Program::Native(solana_exchange_program!()),
                 ])
             } else {
                 None
@@ -65,29 +77,56 @@ pub fn get_programs(operating_mode: OperatingMode, epoch: Epoch) -> Option<Vec<(
             if epoch == std::u64::MAX - 1 {
                 // The epoch of std::u64::MAX - 1 is a placeholder and is expected to be reduced in
                 // a future hard fork.
-                Some(vec![solana_bpf_loader_program!()])
+                Some(vec![Program::Builtin(
+                    "bpf_loader_program".to_string(),
+                    bpf_loader::id(),
+                    BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+                )])
             } else if epoch == std::u64::MAX {
                 // The epoch of std::u64::MAX is a placeholder and is expected to be reduced in a
                 // future hard fork.
-                Some(vec![solana_vest_program!()])
+                Some(vec![Program::Native(solana_vest_program!())])
             } else {
                 None
             }
         }
         OperatingMode::Preview => {
             if epoch == 0 {
-                Some(vec![solana_bpf_loader_program!()])
+                Some(vec![Program::Builtin(
+                    "bpf_loader_program".to_string(),
+                    bpf_loader::id(),
+                    BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+                )])
             } else if epoch == std::u64::MAX {
                 // The epoch of std::u64::MAX is a placeholder and is expected to be reduced in a
                 // future hard fork.
-                Some(vec![solana_vest_program!()])
+                Some(vec![Program::Native(solana_vest_program!())])
             } else {
                 None
             }
         }
     }
 }
 
+pub fn get_native_programs(
+    operating_mode: OperatingMode,
+    epoch: Epoch,
+) -> Option<Vec<(String, Pubkey)>> {
+    println!("get_native_progarms {:?} {:?}", operating_mode, epoch);
+    match get_programs(operating_mode, epoch) {
+        Some(programs) => {
+            let mut native_programs = vec![];
+            for program in programs {
+                if let Program::Native((string, key)) = program {
+                    native_programs.push((string, key));
+                }
+            }
+            Some(native_programs)
+        }
+        None => None,
+    }
+}
+
 pub fn get_entered_epoch_callback(operating_mode: OperatingMode) -> EnteredEpochCallback {
     Box::new(move |bank: &mut Bank| {
         info!(
@@ -99,10 +138,18 @@ pub fn get_entered_epoch_callback(operating_mode: OperatingMode) -> EnteredEpoch
             info!("Entering new epoch with inflation {:?}", inflation);
             bank.set_inflation(inflation);
         }
-        if let Some(new_programs) = get_programs(operating_mode, bank.epoch()) {
-            for (name, program_id) in new_programs.iter() {
-                info!("Registering {} at {}", name, program_id);
-                bank.add_native_program(name, program_id);
+        if let Some(programs) = get_programs(operating_mode, bank.epoch()) {
+            for program in programs {
+                match program {
+                    Program::Native((name, program_id)) => {
+                        info!("Registering {} at {}", name, program_id);
+                        bank.add_native_program(&name, &program_id);
+                    }
+                    Program::Builtin(name, program_id, entrypoint) => {
+                        info!("Registering builtin {} at {}", name, program_id);
+                        bank.add_builtin(&name, program_id, entrypoint);
+                    }
+                }
             }
         }
         if OperatingMode::Stable == operating_mode {
@@ -121,8 +168,13 @@ mod tests {
     #[test]
     fn test_id_uniqueness() {
         let mut unique = HashSet::new();
-        let ids = get_programs(OperatingMode::Development, 0).unwrap();
-        assert!(ids.into_iter().all(move |id| unique.insert(id)));
+        let programs = get_programs(OperatingMode::Development, 0).unwrap();
+        for program in programs {
+            match program {
+                Program::Native((name, id)) => assert!(unique.insert((name, id))),
+                Program::Builtin(name, id, _) => assert!(unique.insert((name, id))),
+            }
+        }
     }
 
     #[test]
@@ -140,7 +192,18 @@ mod tests {
             get_programs(OperatingMode::Development, 0).unwrap().len(),
             4
         );
-        assert_eq!(get_programs(OperatingMode::Development, 1), None);
+        assert!(get_programs(OperatingMode::Development, 1).is_none());
+    }
+
+    #[test]
+    fn test_native_development_programs() {
+        assert_eq!(
+            get_native_programs(OperatingMode::Development, 0)
+                .unwrap()
+                .len(),
+            4
+        );
+        assert!(get_native_programs(OperatingMode::Development, 1).is_none());
     }
 
     #[test]
@@ -158,7 +221,7 @@ mod tests {
 
     #[test]
     fn test_softlaunch_programs() {
-        assert_eq!(get_programs(OperatingMode::Stable, 1), None);
+        assert!(get_programs(OperatingMode::Stable, 1).is_none());
         assert!(get_programs(OperatingMode::Stable, std::u64::MAX - 1).is_some());
         assert!(get_programs(OperatingMode::Stable, std::u64::MAX).is_some());
     }

genesis/src/main.rs

@@ -467,8 +467,9 @@ fn main() -> Result<(), Box<dyn error::Error>> {
         matches.is_present("enable_warmup_epochs"),
     );
 
+    // TODO does not include bpf loader in development operating mode
     let native_instruction_processors =
-        solana_genesis_programs::get_programs(operating_mode, 0).unwrap_or_else(Vec::new);
+        solana_genesis_programs::get_native_programs(operating_mode, 0).unwrap_or_else(Vec::new);
     let inflation = solana_genesis_programs::get_inflation(operating_mode, 0).unwrap();
 
     let mut genesis_config = GenesisConfig {

local-cluster/src/local_cluster.rs

@@ -171,7 +171,7 @@ impl LocalCluster {
         match genesis_config.operating_mode {
             OperatingMode::Stable | OperatingMode::Preview => {
                 genesis_config.native_instruction_processors =
-                    solana_genesis_programs::get_programs(genesis_config.operating_mode, 0)
+                    solana_genesis_programs::get_native_programs(genesis_config.operating_mode, 0)
                         .unwrap_or_default()
             }
             _ => (),

metrics/src/metrics.rs

@@ -242,7 +242,7 @@ impl MetricsAgent {
                         points.push(point);
                     }
                     MetricsCommand::SubmitCounter(counter, level, bucket) => {
-                        debug!("{:?}", counter);
+                        // debug!("{:?}", counter);
                         let (counters, _) = points_map
                             .entry(level)
                             .or_insert((HashMap::new(), Vec::new()));

programs/bpf/tests/programs.rs

@@ -1,8 +1,7 @@
 #[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
 mod bpf {
-    use solana_bpf_loader_program::solana_bpf_loader_program;
     use solana_runtime::{
-        bank::Bank,
+        bank::{Bank, BuiltinEntrypoint},
         bank_client::BankClient,
         genesis_utils::{create_genesis_config, GenesisConfigInfo},
         loader_utils::load_program,
@@ -84,14 +83,18 @@ mod bpf {
             println!("Test program: {:?}", program.0);
 
             let GenesisConfigInfo {
-                mut genesis_config,
+                genesis_config,
                 mint_keypair,
                 ..
             } = create_genesis_config(50);
-            genesis_config
-                .native_instruction_processors
-                .push(solana_bpf_loader_program!());
-            let bank = Arc::new(Bank::new(&genesis_config));
+            let mut bank = Bank::new(&genesis_config);
+            bank.add_builtin(
+                "solana_bpf_loader_program",
+                bpf_loader::id(),
+                BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+            );
+            let bank = Arc::new(bank);
+
             // Create bank with a specific slot, used by solana_bpf_rust_sysvar test
             let bank =
                 Bank::new_from_parent(&bank, &Pubkey::default(), DEFAULT_SLOTS_PER_EPOCH + 1);
@@ -137,14 +140,17 @@ mod bpf {
             println!("Test program: {:?}", program);
 
             let GenesisConfigInfo {
-                mut genesis_config,
+                genesis_config,
                 mint_keypair,
                 ..
             } = create_genesis_config(50);
-            genesis_config
-                .native_instruction_processors
-                .push(solana_bpf_loader_program!());
-            let bank = Arc::new(Bank::new(&genesis_config));
+            let mut bank = Bank::new(&genesis_config);
+            bank.add_builtin(
+                "solana_bpf_loader_program",
+                bpf_loader::id(),
+                BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+            );
+            let bank = Arc::new(bank);
             let bank_client = BankClient::new_shared(&bank);
             let program_id = load_bpf_program(&bank_client, &mint_keypair, program);
             let payee_account = Account::new(10, 1, &program_id);
@@ -222,14 +228,16 @@ mod bpf {
             println!("Test program: {:?}", program);
 
             let GenesisConfigInfo {
-                mut genesis_config,
+                genesis_config,
                 mint_keypair,
                 ..
             } = create_genesis_config(50);
-            genesis_config
-                .native_instruction_processors
-                .push(solana_bpf_loader_program!());
-            let bank = Bank::new(&genesis_config);
+            let mut bank = Bank::new(&genesis_config);
+            bank.add_builtin(
+                "solana_bpf_loader_program",
+                bpf_loader::id(),
+                BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+            );
             let bank_client = BankClient::new(bank);
             let program_id = load_bpf_program(&bank_client, &mint_keypair, program);
             let account_metas = vec![AccountMeta::new(mint_keypair.pubkey(), true)];
@@ -333,14 +341,17 @@ mod bpf {
             println!("Test program: {:?}", program);
 
             let GenesisConfigInfo {
-                mut genesis_config,
+                genesis_config,
                 mint_keypair,
                 ..
             } = create_genesis_config(50);
-            genesis_config
-                .native_instruction_processors
-                .push(solana_bpf_loader_program!());
-            let bank = Arc::new(Bank::new(&genesis_config));
+            let mut bank = Bank::new(&genesis_config);
+            bank.add_builtin(
+                "solana_bpf_loader_program",
+                bpf_loader::id(),
+                BuiltinEntrypoint::Loader(solana_bpf_loader_program::process_instruction),
+            );
+            let bank = Arc::new(bank);
             let bank_client = BankClient::new_shared(&bank);
 
             let invoke_program_id = load_bpf_program(&bank_client, &mint_keypair, program.0);