Add support for deprecated loader (#11946)

programs/bpf/Cargo.lock

@@ -1669,6 +1669,13 @@ dependencies = [
  "solana-sdk",
 ]
 
+[[package]]
+name = "solana-bpf-rust-deprecated_loader"
+version = "1.4.0"
+dependencies = [
+ "solana-sdk",
+]
+
 [[package]]
 name = "solana-bpf-rust-dup-accounts"
 version = "1.4.0"

programs/bpf/Cargo.toml

@@ -37,6 +37,7 @@ members = [
     "rust/128bit_dep",
     "rust/alloc",
     "rust/dep_crate",
+    "rust/deprecated_loader",
     "rust/dup_accounts",
     "rust/error_handling",
     "rust/external_spend",

programs/bpf/build.rs

@@ -68,6 +68,7 @@ fn main() {
             "128bit",
             "alloc",
             "dep_crate",
+            "deprecated_loader",
             "dup_accounts",
             "error_handling",
             "external_spend",

programs/bpf/c/src/deprecated_loader/deprecated_loader.c

@@ -0,0 +1,23 @@
+/**
+ * @brief Example C-based BPF program that prints out the parameters
+ * passed to it
+ */
+#include <solana_sdk.h>
+#include <deserialize_deprecated.h>
+
+extern uint64_t entrypoint(const uint8_t *input) {
+  SolAccountInfo ka[1];
+  SolParameters params = (SolParameters) { .ka = ka };
+
+  sol_log(__FILE__);
+
+  if (!sol_deserialize_deprecated(input, &params, SOL_ARRAY_SIZE(ka))) {
+    return ERROR_INVALID_ARGUMENT;
+  }
+
+  // Log the provided input parameters.  In the case of  the no-op
+  // program, no account keys or input data are expected but real
+  // programs will have specific requirements so they can do their work.
+  sol_log_params(&params);
+  return SUCCESS;
+}

programs/bpf/rust/deprecated_loader/Cargo.toml

@@ -0,0 +1,26 @@
+
+# Note: This crate must be built using do.sh
+
+[package]
+name = "solana-bpf-rust-deprecated_loader"
+version = "1.4.0"
+description = "Solana BPF test program written in Rust"
+authors = ["Solana Maintainers <maintainers@solana.foundation>"]
+repository = "https://github.com/solana-labs/solana"
+license = "Apache-2.0"
+homepage = "https://solana.com/"
+edition = "2018"
+
+[dependencies]
+solana-sdk = { path = "../../../../sdk/", version = "1.4.0", default-features = false }
+
+[features]
+program = ["solana-sdk/program"]
+default = ["program", "solana-sdk/default"]
+
+[lib]
+name = "solana_bpf_rust_deprecated_loader"
+crate-type = ["cdylib"]
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

programs/bpf/rust/deprecated_loader/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

programs/bpf/rust/deprecated_loader/src/lib.rs

@@ -0,0 +1,77 @@
+//! @brief Example Rust-based BPF program that supports the deprecated loader
+
+#![allow(unreachable_code)]
+
+extern crate solana_sdk;
+use solana_sdk::{
+    account_info::AccountInfo, bpf_loader, entrypoint_deprecated,
+    entrypoint_deprecated::ProgramResult, info, log::*, pubkey::Pubkey,
+};
+
+#[derive(Debug, PartialEq)]
+struct SStruct {
+    x: u64,
+    y: u64,
+    z: u64,
+}
+
+#[inline(never)]
+fn return_sstruct() -> SStruct {
+    SStruct { x: 1, y: 2, z: 3 }
+}
+
+entrypoint_deprecated!(process_instruction);
+fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    info!("Program identifier:");
+    program_id.log();
+
+    assert!(!bpf_loader::check_id(program_id));
+
+    // Log the provided account keys and instruction input data.  In the case of
+    // the no-op program, no account keys or input data are expected but real
+    // programs will have specific requirements so they can do their work.
+    info!("Account keys and instruction input data:");
+    sol_log_params(accounts, instruction_data);
+
+    {
+        // Test - use std methods, unwrap
+
+        // valid bytes, in a stack-allocated array
+        let sparkle_heart = [240, 159, 146, 150];
+        let result_str = std::str::from_utf8(&sparkle_heart).unwrap();
+        assert_eq!(4, result_str.len());
+        assert_eq!("💖", result_str);
+        info!(result_str);
+    }
+
+    {
+        // Test - struct return
+
+        let s = return_sstruct();
+        assert_eq!(s.x + s.y + s.z, 6);
+    }
+
+    {
+        // Test - arch config
+        #[cfg(not(target_arch = "bpf"))]
+        panic!();
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    // Pull in syscall stubs when building for non-BPF targets
+    solana_sdk::program_stubs!();
+
+    #[test]
+    fn test_return_sstruct() {
+        assert_eq!(SStruct { x: 1, y: 2, z: 3 }, return_sstruct());
+    }
+}

programs/bpf/tests/programs.rs

@@ -11,7 +11,7 @@ use solana_runtime::{
 };
 use solana_sdk::{
     account::Account,
-    bpf_loader,
+    bpf_loader, bpf_loader_deprecated,
     client::SyncClient,
     clock::DEFAULT_SLOTS_PER_EPOCH,
     entrypoint::MAX_PERMITTED_DATA_INCREASE,
@@ -40,12 +40,17 @@ fn create_bpf_path(name: &str) -> PathBuf {
     pathbuf
 }
 
-fn load_bpf_program(bank_client: &BankClient, payer_keypair: &Keypair, name: &str) -> Pubkey {
+fn load_bpf_program(
+    bank_client: &BankClient,
+    loader_id: &Pubkey,
+    payer_keypair: &Keypair,
+    name: &str,
+) -> Pubkey {
     let path = create_bpf_path(name);
     let mut file = File::open(path).unwrap();
     let mut elf = Vec::new();
     file.read_to_end(&mut elf).unwrap();
-    load_program(bank_client, payer_keypair, &bpf_loader::id(), elf)
+    load_program(bank_client, payer_keypair, loader_id, elf)
 }
 
 #[test]
@@ -101,7 +106,8 @@ fn test_program_bpf_sanity() {
         let bank_client = BankClient::new(bank);
 
         // Call user program
-        let program_id = load_bpf_program(&bank_client, &mint_keypair, program.0);
+        let program_id =
+            load_bpf_program(&bank_client, &bpf_loader::id(), &mint_keypair, program.0);
         let account_metas = vec![
             AccountMeta::new(mint_keypair.pubkey(), true),
             AccountMeta::new(Keypair::new().pubkey(), false),
@@ -122,6 +128,47 @@ fn test_program_bpf_sanity() {
     }
 }
 
+#[test]
+#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
+fn test_program_bpf_loader_deprecated() {
+    solana_logger::setup();
+
+    let mut programs = Vec::new();
+    #[cfg(feature = "bpf_c")]
+    {
+        programs.extend_from_slice(&[("deprecated_loader")]);
+    }
+    #[cfg(feature = "bpf_rust")]
+    {
+        programs.extend_from_slice(&[("solana_bpf_rust_deprecated_loader")]);
+    }
+
+    for program in programs.iter() {
+        println!("Test program: {:?}", program);
+
+        let GenesisConfigInfo {
+            genesis_config,
+            mint_keypair,
+            ..
+        } = create_genesis_config(50);
+        let mut bank = Bank::new(&genesis_config);
+        let (name, id, entrypoint) = solana_bpf_loader_deprecated_program!();
+        bank.add_builtin_loader(&name, id, entrypoint);
+        let bank_client = BankClient::new(bank);
+
+        let program_id = load_bpf_program(
+            &bank_client,
+            &bpf_loader_deprecated::id(),
+            &mint_keypair,
+            program,
+        );
+        let account_metas = vec![AccountMeta::new(mint_keypair.pubkey(), true)];
+        let instruction = Instruction::new(program_id, &1u8, account_metas);
+        let result = bank_client.send_and_confirm_instruction(&mint_keypair, instruction);
+        assert!(result.is_ok());
+    }
+}
+
 #[test]
 fn test_program_bpf_duplicate_accounts() {
     solana_logger::setup();
@@ -149,7 +196,7 @@ fn test_program_bpf_duplicate_accounts() {
         bank.add_builtin_loader(&name, id, entrypoint);
         let bank = Arc::new(bank);
         let bank_client = BankClient::new_shared(&bank);
-        let program_id = load_bpf_program(&bank_client, &mint_keypair, program);
+        let program_id = load_bpf_program(&bank_client, &bpf_loader::id(), &mint_keypair, program);
         let payee_account = Account::new(10, 1, &program_id);
         let payee_pubkey = Pubkey::new_rand();
         bank.store_account(&payee_pubkey, &payee_account);
@@ -233,7 +280,7 @@ fn test_program_bpf_error_handling() {
         let (name, id, entrypoint) = solana_bpf_loader_program!();
         bank.add_builtin_loader(&name, id, entrypoint);
         let bank_client = BankClient::new(bank);
-        let program_id = load_bpf_program(&bank_client, &mint_keypair, program);
+        let program_id = load_bpf_program(&bank_client, &bpf_loader::id(), &mint_keypair, program);
         let account_metas = vec![AccountMeta::new(mint_keypair.pubkey(), true)];
 
         let instruction = Instruction::new(program_id, &1u8, account_metas.clone());
@@ -342,8 +389,10 @@ fn test_program_bpf_invoke() {
         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);
-        let invoked_program_id = load_bpf_program(&bank_client, &mint_keypair, program.1);
+        let invoke_program_id =
+            load_bpf_program(&bank_client, &bpf_loader::id(), &mint_keypair, program.0);
+        let invoked_program_id =
+            load_bpf_program(&bank_client, &bpf_loader::id(), &mint_keypair, program.1);
 
         let argument_keypair = Keypair::new();
         let account = Account::new(42, 100, &invoke_program_id);