Add CPI support for upgradeable loader (#14193)

programs/bpf/Cargo.lock

@@ -1985,6 +1985,13 @@ dependencies = [
  "solana-program",
 ]
 
+[[package]]
+name = "solana-bpf-rust-invoke-and-return"
+version = "1.6.0"
+dependencies = [
+ "solana-program",
+]
+
 [[package]]
 name = "solana-bpf-rust-invoked"
 version = "1.6.0"

programs/bpf/Cargo.toml

@@ -51,6 +51,7 @@ members = [
     "rust/invoke",
     "rust/invoke_and_error",
     "rust/invoke_and_ok",
+    "rust/invoke_and_return",
     "rust/invoked",
     "rust/iter",
     "rust/many_args",

programs/bpf/build.rs

@@ -72,6 +72,7 @@ fn main() {
             "invoke",
             "invoke_and_error",
             "invoke_and_ok",
+            "invoke_and_return",
             "invoked",
             "iter",
             "many_args",

programs/bpf/rust/invoke_and_return/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "solana-bpf-rust-invoke-and-return"
+version = "1.6.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-program = { path = "../../../../sdk/program", version = "1.6.0" }
+
+[lib]
+crate-type = ["cdylib"]
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

programs/bpf/rust/invoke_and_return/Xargo.toml

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

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

@@ -0,0 +1,36 @@
+//! @brief Invokes an instruction and returns an error, the instruction invoked
+//! uses the instruction data provided and all the accounts
+
+use solana_program::{
+    account_info::AccountInfo, bpf_loader_upgradeable, entrypoint, entrypoint::ProgramResult,
+    instruction::AccountMeta, instruction::Instruction, program::invoke, pubkey::Pubkey,
+};
+
+entrypoint!(process_instruction);
+#[allow(clippy::unnecessary_wraps)]
+fn process_instruction(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let to_call = accounts[0].key;
+    let infos = accounts;
+    let last = if bpf_loader_upgradeable::check_id(accounts[0].owner) {
+        accounts.len() - 1
+    } else {
+        accounts.len()
+    };
+    let instruction = Instruction {
+        accounts: accounts[1..last]
+            .iter()
+            .map(|acc| AccountMeta {
+                pubkey: *acc.key,
+                is_signer: acc.is_signer,
+                is_writable: acc.is_writable,
+            })
+            .collect(),
+        data: instruction_data.to_owned(),
+        program_id: *to_call,
+    };
+    invoke(&instruction, &infos)
+}

programs/bpf/tests/programs.rs

@@ -21,7 +21,9 @@ use solana_runtime::{
 };
 use solana_sdk::{
     account::Account,
+    account_utils::StateMut,
     bpf_loader, bpf_loader_deprecated,
+    bpf_loader_upgradeable::UpgradeableLoaderState,
     client::SyncClient,
     clock::{DEFAULT_SLOTS_PER_EPOCH, MAX_PROCESSING_AGE},
     entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS},
@@ -1557,3 +1559,58 @@ fn test_program_bpf_upgrade() {
         TransactionError::InstructionError(0, InstructionError::Custom(42))
     );
 }
+
+#[cfg(feature = "bpf_rust")]
+#[test]
+fn test_program_bpf_invoke_upgradeable() {
+    solana_logger::setup();
+
+    let GenesisConfigInfo {
+        genesis_config,
+        mint_keypair,
+        ..
+    } = create_genesis_config(50);
+    let mut bank = Bank::new(&genesis_config);
+    let (name, id, entrypoint) = solana_bpf_loader_program!();
+    bank.add_builtin(&name, id, entrypoint);
+    let (name, id, entrypoint) = solana_bpf_loader_upgradeable_program!();
+    bank.add_builtin(&name, id, entrypoint);
+    let bank_client = BankClient::new(bank);
+    let invoke_and_return = load_bpf_program(
+        &bank_client,
+        &bpf_loader::id(),
+        &mint_keypair,
+        "solana_bpf_rust_invoke_and_return",
+    );
+
+    // deploy upgrade program
+    let (program_id, _) =
+        load_upgradeable_bpf_program(&bank_client, &mint_keypair, "solana_bpf_rust_upgradeable");
+
+    let data = bank_client.get_account(&program_id).unwrap().unwrap();
+    let programdata_address = if let UpgradeableLoaderState::Program {
+        programdata_address,
+    } = data.state().unwrap()
+    {
+        programdata_address
+    } else {
+        panic!("Not a program");
+    };
+
+    // call invoker program to invoke the upgradeable program
+    let instruction = Instruction::new(
+        invoke_and_return,
+        &[0],
+        vec![
+            AccountMeta::new(program_id, false),
+            AccountMeta::new(clock::id(), false),
+            AccountMeta::new(fees::id(), false),
+            AccountMeta::new(programdata_address, false),
+        ],
+    );
+    let result = bank_client.send_and_confirm_instruction(&mint_keypair, instruction);
+    assert_eq!(
+        result.unwrap_err().unwrap(),
+        TransactionError::InstructionError(0, InstructionError::Custom(42))
+    );
+}