gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Cleanup old features (#15391)

Browse Source
This commit is contained in:
Jack May
2021-02-18 09:56:11 -08:00
committed by GitHub
parent 82850781c9
commit 02432a548f
9 changed files with 57 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cli/src/program.rs
View File

@ -1374,7 +1374,7 @@ fn read_and_verify_elf(program_location: &str) -> Result<Vec<u8>, Box<dyn std::e
// Verify the program // Verify the program
Executable::<BPFError, ThisInstructionMeter>::from_elf( Executable::<BPFError, ThisInstructionMeter>::from_elf(
&program_data, &program_data,
Some(|x| bpf_verifier::check(x, false)), Some(|x| bpf_verifier::check(x)),
Config::default(), Config::default(),
) )
.map_err(|err| format!("ELF error: {}", err))?; .map_err(|err| format!("ELF error: {}", err))?;

8
programs/bpf/tests/programs.rs
View File

@ -27,7 +27,7 @@ use solana_sdk::{
client::SyncClient, client::SyncClient,
clock::{DEFAULT_SLOTS_PER_EPOCH, MAX_PROCESSING_AGE}, clock::{DEFAULT_SLOTS_PER_EPOCH, MAX_PROCESSING_AGE},
entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS}, entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS},
feature_set::try_find_program_address_syscall_enabled, feature_set::ristretto_mul_syscall_enabled,
instruction::{AccountMeta, CompiledInstruction, Instruction, InstructionError}, instruction::{AccountMeta, CompiledInstruction, Instruction, InstructionError},
keyed_account::KeyedAccount, keyed_account::KeyedAccount,
message::Message, message::Message,
@ -1216,7 +1216,7 @@ fn assert_instruction_count() {
("noop", 57), ("noop", 57),
("relative_call", 10), ("relative_call", 10),
("sanity", 176), ("sanity", 176),
("sanity++", 176), ("sanity++", 177),
("struct_pass", 8), ("struct_pass", 8),
("struct_ret", 22), ("struct_ret", 22),
]); ]);
@ -2195,7 +2195,7 @@ fn test_program_bpf_syscall_feature_activation() {
.. ..
} = create_genesis_config(50); } = create_genesis_config(50);
let mut bank = Bank::new(&genesis_config); let mut bank = Bank::new(&genesis_config);
bank.deactivate_feature(&try_find_program_address_syscall_enabled::id()); bank.deactivate_feature(&ristretto_mul_syscall_enabled::id());
let (name, id, entrypoint) = solana_bpf_loader_program!(); let (name, id, entrypoint) = solana_bpf_loader_program!();
bank.add_builtin(&name, id, entrypoint); bank.add_builtin(&name, id, entrypoint);
let bank = Arc::new(bank); let bank = Arc::new(bank);
@ -2212,7 +2212,7 @@ fn test_program_bpf_syscall_feature_activation() {
assert!(result.is_ok()); assert!(result.is_ok());
let mut bank = Bank::new_from_parent(&bank, &Pubkey::default(), 1); let mut bank = Bank::new_from_parent(&bank, &Pubkey::default(), 1);
bank.activate_feature(&try_find_program_address_syscall_enabled::id()); bank.activate_feature(&ristretto_mul_syscall_enabled::id());
let bank = Arc::new(bank); let bank = Arc::new(bank);
let bank_client = BankClient::new_shared(&bank); let bank_client = BankClient::new_shared(&bank);

8
programs/bpf_loader/src/bpf_verifier.rs
View File

@ -58,11 +58,11 @@ fn adj_insn_ptr(insn_ptr: usize) -> usize {
insn_ptr + ebpf::ELF_INSN_DUMP_OFFSET insn_ptr + ebpf::ELF_INSN_DUMP_OFFSET
} }
fn check_prog_len(prog: &[u8], is_program_size_cap: bool) -> Result<(), BPFError> { fn check_prog_len(prog: &[u8]) -> Result<(), BPFError> {
if prog.len() % ebpf::INSN_SIZE != 0 { if prog.len() % ebpf::INSN_SIZE != 0 {
return Err(VerifierError::ProgramLengthNotMultiple.into()); return Err(VerifierError::ProgramLengthNotMultiple.into());
} }
if is_program_size_cap && prog.len() > ebpf::PROG_MAX_SIZE { if prog.len() > ebpf::PROG_MAX_SIZE {
return Err(VerifierError::ProgramTooLarge(prog.len() / ebpf::INSN_SIZE).into()); return Err(VerifierError::ProgramTooLarge(prog.len() / ebpf::INSN_SIZE).into());
} }
@ -149,8 +149,8 @@ fn check_imm_register(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), Verifier
} }
#[rustfmt::skip] #[rustfmt::skip]
pub fn check(prog: &[u8], is_program_size_cap: bool) -> Result<(), BPFError> { pub fn check(prog: &[u8]) -> Result<(), BPFError> {
check_prog_len(prog, is_program_size_cap)?; check_prog_len(prog)?;
let mut insn_ptr: usize = 0; let mut insn_ptr: usize = 0;
while insn_ptr * ebpf::INSN_SIZE < prog.len() { while insn_ptr * ebpf::INSN_SIZE < prog.len() {

18
programs/bpf_loader/src/lib.rs
View File

@ -27,10 +27,7 @@ use solana_sdk::{
bpf_loader_upgradeable::{self, UpgradeableLoaderState}, bpf_loader_upgradeable::{self, UpgradeableLoaderState},
clock::Clock, clock::Clock,
entrypoint::SUCCESS, entrypoint::SUCCESS,
feature_set::{ feature_set::matching_buffer_upgrade_authorities,
bpf_compute_budget_balancing, matching_buffer_upgrade_authorities,
prevent_upgrade_and_invoke,
},
ic_logger_msg, ic_msg, ic_logger_msg, ic_msg,
instruction::InstructionError, instruction::InstructionError,
keyed_account::{from_keyed_account, next_keyed_account, KeyedAccount}, keyed_account::{from_keyed_account, next_keyed_account, KeyedAccount},
@ -90,11 +87,8 @@ pub fn create_and_cache_executor(
let (_, elf_bytes) = program let (_, elf_bytes) = program
.get_text_bytes() .get_text_bytes()
.map_err(|e| map_ebpf_error(invoke_context, e))?; .map_err(|e| map_ebpf_error(invoke_context, e))?;
bpf_verifier::check( bpf_verifier::check(elf_bytes)
elf_bytes, .map_err(|e| map_ebpf_error(invoke_context, EbpfError::UserError(e)))?;
!invoke_context.is_feature_active(&bpf_compute_budget_balancing::id()),
)
.map_err(|e| map_ebpf_error(invoke_context, EbpfError::UserError(e)))?;
let syscall_registry = syscalls::register_syscalls(invoke_context).map_err(|e| { let syscall_registry = syscalls::register_syscalls(invoke_context).map_err(|e| {
ic_msg!(invoke_context, "Failed to register syscalls: {}", e); ic_msg!(invoke_context, "Failed to register syscalls: {}", e);
InstructionError::ProgramEnvironmentSetupFailure InstructionError::ProgramEnvironmentSetupFailure
@ -491,9 +485,7 @@ fn process_loader_upgradeable_instruction(
ic_logger_msg!(logger, "Program account not executable"); ic_logger_msg!(logger, "Program account not executable");
return Err(InstructionError::AccountNotExecutable); return Err(InstructionError::AccountNotExecutable);
} }
if !program.is_writable() if !program.is_writable() {
&& invoke_context.is_feature_active(&prevent_upgrade_and_invoke::id())
{
ic_logger_msg!(logger, "Program account not writeable"); ic_logger_msg!(logger, "Program account not writeable");
return Err(InstructionError::InvalidArgument); return Err(InstructionError::InvalidArgument);
} }
@ -911,7 +903,7 @@ mod tests {
let prog = &[ let prog = &[
0x18, 0x00, 0x00, 0x00, 0x88, 0x77, 0x66, 0x55, // first half of lddw 0x18, 0x00, 0x00, 0x00, 0x88, 0x77, 0x66, 0x55, // first half of lddw
]; ];
bpf_verifier::check(prog, true).unwrap(); bpf_verifier::check(prog).unwrap();
} }
#[test] #[test]

92
programs/bpf_loader/src/syscalls.rs
View File

@ -16,25 +16,18 @@ use solana_sdk::{
bpf_loader, bpf_loader_deprecated, bpf_loader, bpf_loader_deprecated,
bpf_loader_upgradeable::{self, UpgradeableLoaderState}, bpf_loader_upgradeable::{self, UpgradeableLoaderState},
entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS}, entrypoint::{MAX_PERMITTED_DATA_INCREASE, SUCCESS},
feature_set::{ feature_set::{per_byte_logging_cost, ristretto_mul_syscall_enabled, use_loaded_executables},
abort_on_all_cpi_failures, limit_cpi_loader_invoke, per_byte_logging_cost,
pubkey_log_syscall_enabled, ristretto_mul_syscall_enabled, sha256_syscall_enabled,
sol_log_compute_units_syscall, try_find_program_address_syscall_enabled,
use_loaded_executables, use_loaded_program_accounts,
},
hash::{Hasher, HASH_BYTES}, hash::{Hasher, HASH_BYTES},
ic_msg, ic_msg,
instruction::{AccountMeta, Instruction, InstructionError}, instruction::{AccountMeta, Instruction, InstructionError},
keyed_account::KeyedAccount, keyed_account::KeyedAccount,
native_loader, native_loader,
process_instruction::{stable_log, ComputeMeter, InvokeContext, Logger}, process_instruction::{stable_log, ComputeMeter, InvokeContext, Logger},
program_error::ProgramError,
pubkey::{Pubkey, PubkeyError, MAX_SEEDS}, pubkey::{Pubkey, PubkeyError, MAX_SEEDS},
}; };
use std::{ use std::{
alloc::Layout, alloc::Layout,
cell::{Ref, RefCell, RefMut}, cell::{Ref, RefCell, RefMut},
convert::TryFrom,
mem::{align_of, size_of}, mem::{align_of, size_of},
rc::Rc, rc::Rc,
slice::from_raw_parts_mut, slice::from_raw_parts_mut,
@ -110,18 +103,12 @@ pub fn register_syscalls(
syscall_registry.register_syscall_by_name(b"sol_log_", SyscallLog::call)?; syscall_registry.register_syscall_by_name(b"sol_log_", SyscallLog::call)?;
syscall_registry.register_syscall_by_name(b"sol_log_64_", SyscallLogU64::call)?; syscall_registry.register_syscall_by_name(b"sol_log_64_", SyscallLogU64::call)?;
if invoke_context.is_feature_active(&sol_log_compute_units_syscall::id()) { syscall_registry
syscall_registry .register_syscall_by_name(b"sol_log_compute_units_", SyscallLogBpfComputeUnits::call)?;
.register_syscall_by_name(b"sol_log_compute_units_", SyscallLogBpfComputeUnits::call)?;
}
if invoke_context.is_feature_active(&pubkey_log_syscall_enabled::id()) { syscall_registry.register_syscall_by_name(b"sol_log_pubkey", SyscallLogPubkey::call)?;
syscall_registry.register_syscall_by_name(b"sol_log_pubkey", SyscallLogPubkey::call)?;
}
if invoke_context.is_feature_active(&sha256_syscall_enabled::id()) { syscall_registry.register_syscall_by_name(b"sol_sha256", SyscallSha256::call)?;
syscall_registry.register_syscall_by_name(b"sol_sha256", SyscallSha256::call)?;
}
if invoke_context.is_feature_active(&ristretto_mul_syscall_enabled::id()) { if invoke_context.is_feature_active(&ristretto_mul_syscall_enabled::id()) {
syscall_registry syscall_registry
@ -132,12 +119,10 @@ pub fn register_syscalls(
b"sol_create_program_address", b"sol_create_program_address",
SyscallCreateProgramAddress::call, SyscallCreateProgramAddress::call,
)?; )?;
if invoke_context.is_feature_active(&try_find_program_address_syscall_enabled::id()) { syscall_registry.register_syscall_by_name(
syscall_registry.register_syscall_by_name( b"sol_try_find_program_address",
b"sol_try_find_program_address", SyscallTryFindProgramAddress::call,
SyscallTryFindProgramAddress::call, )?;
)?;
}
syscall_registry syscall_registry
.register_syscall_by_name(b"sol_invoke_signed_c", SyscallInvokeSignedC::call)?; .register_syscall_by_name(b"sol_invoke_signed_c", SyscallInvokeSignedC::call)?;
syscall_registry syscall_registry
@ -202,40 +187,34 @@ pub fn bind_syscall_context_objects<'a>(
None, None,
)?; )?;
bind_feature_gated_syscall_context_object!( vm.bind_syscall_context_object(
vm,
invoke_context,
&sol_log_compute_units_syscall::id(),
Box::new(SyscallLogBpfComputeUnits { Box::new(SyscallLogBpfComputeUnits {
cost: 0, cost: 0,
compute_meter: invoke_context.get_compute_meter(), compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(), logger: invoke_context.get_logger(),
}), }),
); None,
)?;
bind_feature_gated_syscall_context_object!( vm.bind_syscall_context_object(
vm,
invoke_context,
&pubkey_log_syscall_enabled::id(),
Box::new(SyscallLogPubkey { Box::new(SyscallLogPubkey {
cost: bpf_compute_budget.log_pubkey_units, cost: bpf_compute_budget.log_pubkey_units,
compute_meter: invoke_context.get_compute_meter(), compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(), logger: invoke_context.get_logger(),
loader_id, loader_id,
}), }),
); None,
)?;
bind_feature_gated_syscall_context_object!( vm.bind_syscall_context_object(
vm,
invoke_context,
&sha256_syscall_enabled::id(),
Box::new(SyscallSha256 { Box::new(SyscallSha256 {
sha256_base_cost: bpf_compute_budget.sha256_base_cost, sha256_base_cost: bpf_compute_budget.sha256_base_cost,
sha256_byte_cost: bpf_compute_budget.sha256_byte_cost, sha256_byte_cost: bpf_compute_budget.sha256_byte_cost,
compute_meter: invoke_context.get_compute_meter(), compute_meter: invoke_context.get_compute_meter(),
loader_id, loader_id,
}), }),
); None,
)?;
bind_feature_gated_syscall_context_object!( bind_feature_gated_syscall_context_object!(
vm, vm,
@ -257,16 +236,14 @@ pub fn bind_syscall_context_objects<'a>(
None, None,
)?; )?;
bind_feature_gated_syscall_context_object!( vm.bind_syscall_context_object(
vm,
invoke_context,
&try_find_program_address_syscall_enabled::id(),
Box::new(SyscallTryFindProgramAddress { Box::new(SyscallTryFindProgramAddress {
cost: bpf_compute_budget.create_program_address_units, cost: bpf_compute_budget.create_program_address_units,
compute_meter: invoke_context.get_compute_meter(), compute_meter: invoke_context.get_compute_meter(),
loader_id, loader_id,
}), }),
); None,
)?;
// Cross-program invocation syscalls // Cross-program invocation syscalls
@ -1450,8 +1427,7 @@ where
SyscallError::InstructionError(InstructionError::MissingAccount) SyscallError::InstructionError(InstructionError::MissingAccount)
})?; })?;
if (invoke_context.is_feature_active(&use_loaded_program_accounts::id()) if i == program_account_index
&& i == program_account_index)
|| (invoke_context.is_feature_active(&use_loaded_executables::id()) || (invoke_context.is_feature_active(&use_loaded_executables::id())
&& account.borrow().executable) && account.borrow().executable)
{ {
@ -1511,7 +1487,6 @@ fn check_account_infos(
> invoke_context > invoke_context
.get_bpf_compute_budget() .get_bpf_compute_budget()
.max_cpi_instruction_size .max_cpi_instruction_size
&& invoke_context.is_feature_active(&use_loaded_program_accounts::id())
{ {
// Cap the number of account_infos a caller can pass to approximate // Cap the number of account_infos a caller can pass to approximate
// maximum that accounts that could be passed in an instruction // maximum that accounts that could be passed in an instruction
@ -1580,14 +1555,7 @@ fn call<'a>(
signers_seeds_len: u64, signers_seeds_len: u64,
memory_mapping: &MemoryMapping, memory_mapping: &MemoryMapping,
) -> Result<u64, EbpfError<BPFError>> { ) -> Result<u64, EbpfError<BPFError>> {
let ( let (message, executables, accounts, account_refs, caller_privileges) = {
message,
executables,
accounts,
account_refs,
caller_privileges,
abort_on_all_cpi_failures,
) = {
let invoke_context = syscall.get_context()?; let invoke_context = syscall.get_context()?;
invoke_context invoke_context
@ -1633,9 +1601,7 @@ fn call<'a>(
} }
}) })
.collect::<Vec<bool>>(); .collect::<Vec<bool>>();
if invoke_context.is_feature_active(&limit_cpi_loader_invoke::id()) { check_authorized_program(&callee_program_id, &instruction.data)?;
check_authorized_program(&callee_program_id, &instruction.data)?;
}
let (accounts, account_refs) = syscall.translate_accounts( let (accounts, account_refs) = syscall.translate_accounts(
&message.account_keys, &message.account_keys,
callee_program_id_index, callee_program_id_index,
@ -1668,7 +1634,6 @@ fn call<'a>(
accounts, accounts,
account_refs, account_refs,
caller_privileges, caller_privileges,
invoke_context.is_feature_active(&abort_on_all_cpi_failures::id()),
) )
}; };
@ -1684,14 +1649,7 @@ fn call<'a>(
) { ) {
Ok(()) => (), Ok(()) => (),
Err(err) => { Err(err) => {
if abort_on_all_cpi_failures { return Err(SyscallError::InstructionError(err).into());
return Err(SyscallError::InstructionError(err).into());
} else {
match ProgramError::try_from(err) {
Ok(err) => return Ok(err.into()),
Err(err) => return Err(SyscallError::InstructionError(err).into()),
}
}
} }
} }

2
runtime/src/bank.rs
View File

@ -2879,7 +2879,7 @@ impl Bank {
let mut transaction_log_messages = Vec::with_capacity(txs.len()); let mut transaction_log_messages = Vec::with_capacity(txs.len());
let bpf_compute_budget = self let bpf_compute_budget = self
.bpf_compute_budget .bpf_compute_budget
.unwrap_or_else(|| BpfComputeBudget::new(&self.feature_set)); .unwrap_or_else(BpfComputeBudget::new);
let executed: Vec<TransactionExecutionResult> = loaded_accounts let executed: Vec<TransactionExecutionResult> = loaded_accounts
.iter_mut() .iter_mut()

12
runtime/src/message_processor.rs
View File

@ -1645,7 +1645,7 @@ mod tests {
executors.clone(), executors.clone(),
None, None,
Arc::new(FeatureSet::all_enabled()), Arc::new(FeatureSet::all_enabled()),
BpfComputeBudget::new(&FeatureSet::all_enabled()), BpfComputeBudget::new(),
); );
assert_eq!(result, Ok(())); assert_eq!(result, Ok(()));
assert_eq!(accounts[0].borrow().lamports, 100); assert_eq!(accounts[0].borrow().lamports, 100);
@ -1670,7 +1670,7 @@ mod tests {
executors.clone(), executors.clone(),
None, None,
Arc::new(FeatureSet::all_enabled()), Arc::new(FeatureSet::all_enabled()),
BpfComputeBudget::new(&FeatureSet::all_enabled()), BpfComputeBudget::new(),
); );
assert_eq!( assert_eq!(
result, result,
@ -1699,7 +1699,7 @@ mod tests {
executors, executors,
None, None,
Arc::new(FeatureSet::all_enabled()), Arc::new(FeatureSet::all_enabled()),
BpfComputeBudget::new(&FeatureSet::all_enabled()), BpfComputeBudget::new(),
); );
assert_eq!( assert_eq!(
result, result,
@ -1812,7 +1812,7 @@ mod tests {
executors.clone(), executors.clone(),
None, None,
Arc::new(FeatureSet::all_enabled()), Arc::new(FeatureSet::all_enabled()),
BpfComputeBudget::new(&FeatureSet::all_enabled()), BpfComputeBudget::new(),
); );
assert_eq!( assert_eq!(
result, result,
@ -1841,7 +1841,7 @@ mod tests {
executors.clone(), executors.clone(),
None, None,
Arc::new(FeatureSet::all_enabled()), Arc::new(FeatureSet::all_enabled()),
BpfComputeBudget::new(&FeatureSet::all_enabled()), BpfComputeBudget::new(),
); );
assert_eq!(result, Ok(())); assert_eq!(result, Ok(()));
@ -1867,7 +1867,7 @@ mod tests {
executors, executors,
None, None,
Arc::new(FeatureSet::all_enabled()), Arc::new(FeatureSet::all_enabled()),
BpfComputeBudget::new(&FeatureSet::all_enabled()), BpfComputeBudget::new(),
); );
assert_eq!(result, Ok(())); assert_eq!(result, Ok(()));
assert_eq!(accounts[0].borrow().lamports, 80); assert_eq!(accounts[0].borrow().lamports, 80);

65
sdk/src/feature_set.rs
View File

@ -47,18 +47,6 @@ pub mod spl_token_v2_multisig_fix {
solana_sdk::declare_id!("E5JiFDQCwyC6QfT9REFyMpfK2mHcmv1GUDySU1Ue7TYv"); solana_sdk::declare_id!("E5JiFDQCwyC6QfT9REFyMpfK2mHcmv1GUDySU1Ue7TYv");
} }
pub mod bpf_loader2_program {
solana_sdk::declare_id!("DFBnrgThdzH4W6wZ12uGPoWcMnvfZj11EHnxHcVxLPhD");
}
pub mod bpf_compute_budget_balancing {
solana_sdk::declare_id!("HxvjqDSiF5sYdSYuCXsUnS8UeAoWsMT9iGoFP8pgV1mB");
}
pub mod sha256_syscall_enabled {
solana_sdk::declare_id!("D7KfP7bZxpkYtD4Pc38t9htgs1k5k47Yhxe4rp6WDVi8");
}
pub mod no_overflow_rent_distribution { pub mod no_overflow_rent_distribution {
solana_sdk::declare_id!("4kpdyrcj5jS47CZb2oJGfVxjYbsMm2Kx97gFyZrxxwXz"); solana_sdk::declare_id!("4kpdyrcj5jS47CZb2oJGfVxjYbsMm2Kx97gFyZrxxwXz");
} }
@ -67,26 +55,10 @@ pub mod ristretto_mul_syscall_enabled {
solana_sdk::declare_id!("HRe7A6aoxgjKzdjbBv6HTy7tJ4YWqE6tVmYCGho6S9Aq"); solana_sdk::declare_id!("HRe7A6aoxgjKzdjbBv6HTy7tJ4YWqE6tVmYCGho6S9Aq");
} }
pub mod max_invoke_depth_4 {
solana_sdk::declare_id!("EdM9xggY5y7AhNMskRG8NgGMnaP4JFNsWi8ZZtyT1af5");
}
pub mod max_program_call_depth_64 {
solana_sdk::declare_id!("YCKSgA6XmjtkQrHBQjpyNrX6EMhJPcYcLWMVgWn36iv");
}
pub mod cumulative_rent_related_fixes { pub mod cumulative_rent_related_fixes {
solana_sdk::declare_id!("FtjnuAtJTWwX3Kx9m24LduNEhzaGuuPfDW6e14SX2Fy5"); solana_sdk::declare_id!("FtjnuAtJTWwX3Kx9m24LduNEhzaGuuPfDW6e14SX2Fy5");
} }
pub mod sol_log_compute_units_syscall {
solana_sdk::declare_id!("BHuZqHAj7JdZc68wVgZZcy51jZykvgrx4zptR44RyChe");
}
pub mod pubkey_log_syscall_enabled {
solana_sdk::declare_id!("MoqiU1vryuCGQSxFKA1SZ316JdLEFFhoAu6cKUNk7dN");
}
pub mod pull_request_ping_pong_check { pub mod pull_request_ping_pong_check {
solana_sdk::declare_id!("5RzEHTnf6D7JPZCvwEzjM19kzBsyjSU3HoMfXaQmVgnZ"); solana_sdk::declare_id!("5RzEHTnf6D7JPZCvwEzjM19kzBsyjSU3HoMfXaQmVgnZ");
} }
@ -111,30 +83,10 @@ pub mod bpf_loader_upgradeable_program {
solana_sdk::declare_id!("FbhK8HN9qvNHvJcoFVHAEUCNkagHvu7DTWzdnLuVQ5u4"); solana_sdk::declare_id!("FbhK8HN9qvNHvJcoFVHAEUCNkagHvu7DTWzdnLuVQ5u4");
} }
pub mod try_find_program_address_syscall_enabled {
solana_sdk::declare_id!("EMsMNadQNhCYDyGpYH5Tx6dGHxiUqKHk782PU5XaWfmi");
}
pub mod stake_program_v3 { pub mod stake_program_v3 {
solana_sdk::declare_id!("Ego6nTu7WsBcZBvVqJQKp6Yku2N3mrfG8oYCfaLZkAeK"); solana_sdk::declare_id!("Ego6nTu7WsBcZBvVqJQKp6Yku2N3mrfG8oYCfaLZkAeK");
} }
pub mod max_cpi_instruction_size_ipv6_mtu {
solana_sdk::declare_id!("5WLtuUJA5VVA1Cc28qULPfGs8anhoBev8uNqaaXeasnf");
}
pub mod limit_cpi_loader_invoke {
solana_sdk::declare_id!("xGbcW7EEC7zMRJ6LaJCob65EJxKryWjwM4rv8f57SRM");
}
pub mod use_loaded_program_accounts {
solana_sdk::declare_id!("FLjgLeg1PJkZimQCVa5sVFtaq6VmSDPw3NvH8iQ3nyHn");
}
pub mod abort_on_all_cpi_failures {
solana_sdk::declare_id!("ED5D5a2hQaECHaMmKpnU48GdsfafdCjkb3pgAw5RKbb2");
}
pub mod use_loaded_executables { pub mod use_loaded_executables {
solana_sdk::declare_id!("3Jq7mE2chDpf6oeEDsuGK7orTYEgyQjCPvaRppTNdVGK"); solana_sdk::declare_id!("3Jq7mE2chDpf6oeEDsuGK7orTYEgyQjCPvaRppTNdVGK");
} }
@ -143,10 +95,6 @@ pub mod turbine_retransmit_peers_patch {
solana_sdk::declare_id!("5Lu3JnWSFwRYpXzwDMkanWSk6XqSuF2i5fpnVhzB5CTc"); solana_sdk::declare_id!("5Lu3JnWSFwRYpXzwDMkanWSk6XqSuF2i5fpnVhzB5CTc");
} }
pub mod prevent_upgrade_and_invoke {
solana_sdk::declare_id!("BiNjYd8jCYDgAwMqP91uwZs6skWpuHtKrZbckuKESs8N");
}
pub mod track_writable_deescalation { pub mod track_writable_deescalation {
solana_sdk::declare_id!("HVPSxqskEtRLRT2ZeEMmkmt9FWqoFX4vrN6f5VaadLED"); solana_sdk::declare_id!("HVPSxqskEtRLRT2ZeEMmkmt9FWqoFX4vrN6f5VaadLED");
} }
@ -181,31 +129,18 @@ lazy_static! {
(pico_inflation::id(), "pico inflation"), (pico_inflation::id(), "pico inflation"),
(full_inflation::devnet_and_testnet::id(), "full inflation on devnet and testnet"), (full_inflation::devnet_and_testnet::id(), "full inflation on devnet and testnet"),
(spl_token_v2_multisig_fix::id(), "spl-token multisig fix"), (spl_token_v2_multisig_fix::id(), "spl-token multisig fix"),
(bpf_loader2_program::id(), "bpf_loader2 program"),
(bpf_compute_budget_balancing::id(), "compute budget balancing"),
(sha256_syscall_enabled::id(), "sha256 syscall"),
(no_overflow_rent_distribution::id(), "no overflow rent distribution"), (no_overflow_rent_distribution::id(), "no overflow rent distribution"),
(ristretto_mul_syscall_enabled::id(), "ristretto multiply syscall"), (ristretto_mul_syscall_enabled::id(), "ristretto multiply syscall"),
(max_invoke_depth_4::id(), "max invoke call depth 4"),
(max_program_call_depth_64::id(), "max program call depth 64"),
(cumulative_rent_related_fixes::id(), "rent fixes (#10206, #10468, #11342)"), (cumulative_rent_related_fixes::id(), "rent fixes (#10206, #10468, #11342)"),
(sol_log_compute_units_syscall::id(), "sol_log_compute_units syscall (#13243)"),
(pubkey_log_syscall_enabled::id(), "pubkey log syscall"),
(pull_request_ping_pong_check::id(), "ping-pong packet check #12794"), (pull_request_ping_pong_check::id(), "ping-pong packet check #12794"),
(stake_program_v2::id(), "solana_stake_program v2"), (stake_program_v2::id(), "solana_stake_program v2"),
(rewrite_stake::id(), "rewrite stake"), (rewrite_stake::id(), "rewrite stake"),
(filter_stake_delegation_accounts::id(), "filter stake_delegation_accounts #14062"), (filter_stake_delegation_accounts::id(), "filter stake_delegation_accounts #14062"),
(simple_capitalization::id(), "simple capitalization"), (simple_capitalization::id(), "simple capitalization"),
(bpf_loader_upgradeable_program::id(), "upgradeable bpf loader"), (bpf_loader_upgradeable_program::id(), "upgradeable bpf loader"),
(try_find_program_address_syscall_enabled::id(), "add try_find_program_address syscall"),
(stake_program_v3::id(), "solana_stake_program v3"), (stake_program_v3::id(), "solana_stake_program v3"),
(max_cpi_instruction_size_ipv6_mtu::id(), "max cross-program invocation size 1280"),
(limit_cpi_loader_invoke::id(), "loader not authorized via CPI"),
(use_loaded_program_accounts::id(), "use loaded program accounts"),
(abort_on_all_cpi_failures::id(), "abort on all CPI failures"),
(use_loaded_executables::id(), "use loaded executable accounts"), (use_loaded_executables::id(), "use loaded executable accounts"),
(turbine_retransmit_peers_patch::id(), "turbine retransmit peers patch #14631"), (turbine_retransmit_peers_patch::id(), "turbine retransmit peers patch #14631"),
(prevent_upgrade_and_invoke::id(), "prevent upgrade and invoke in same tx batch"),
(track_writable_deescalation::id(), "track account writable deescalation"), (track_writable_deescalation::id(), "track account writable deescalation"),
(require_custodian_for_locked_stake_authorize::id(), "require custodian to authorize withdrawer change for locked stake"), (require_custodian_for_locked_stake_authorize::id(), "require custodian to authorize withdrawer change for locked stake"),
(spl_token_v2_self_transfer_fix::id(), "spl-token self-transfer fix"), (spl_token_v2_self_transfer_fix::id(), "spl-token self-transfer fix"),

65
sdk/src/process_instruction.rs
View File

@ -1,9 +1,5 @@
use solana_sdk::{ use solana_sdk::{
account::Account, account::Account,
feature_set::{
bpf_compute_budget_balancing, max_cpi_instruction_size_ipv6_mtu, max_invoke_depth_4,
max_program_call_depth_64, pubkey_log_syscall_enabled, FeatureSet,
},
instruction::{CompiledInstruction, Instruction, InstructionError}, instruction::{CompiledInstruction, Instruction, InstructionError},
keyed_account::KeyedAccount, keyed_account::KeyedAccount,
message::Message, message::Message,
@ -127,64 +123,25 @@ pub struct BpfComputeBudget {
} }
impl Default for BpfComputeBudget { impl Default for BpfComputeBudget {
fn default() -> Self { fn default() -> Self {
Self::new(&FeatureSet::all_enabled()) Self::new()
} }
} }
impl BpfComputeBudget { impl BpfComputeBudget {
pub fn new(feature_set: &FeatureSet) -> Self { pub fn new() -> Self {
let mut bpf_compute_budget =
// Original
BpfComputeBudget { BpfComputeBudget {
max_units: 100_000, max_units: 200_000,
log_units: 0, log_units: 100,
log_64_units: 0, log_64_units: 100,
create_program_address_units: 0, create_program_address_units: 1500,
invoke_units: 0, invoke_units: 1000,
max_invoke_depth: 1, max_invoke_depth: 4,
sha256_base_cost: 85, sha256_base_cost: 85,
sha256_byte_cost: 1, sha256_byte_cost: 1,
max_call_depth: 20, max_call_depth: 64,
stack_frame_size: 4_096, stack_frame_size: 4_096,
log_pubkey_units: 0, log_pubkey_units: 100,
max_cpi_instruction_size: std::usize::MAX, max_cpi_instruction_size: 1280, // IPv6 Min MTU size
};
if feature_set.is_active(&bpf_compute_budget_balancing::id()) {
bpf_compute_budget = BpfComputeBudget {
max_units: 200_000,
log_units: 100,
log_64_units: 100,
create_program_address_units: 1500,
invoke_units: 1000,
..bpf_compute_budget
};
} }
if feature_set.is_active(&max_invoke_depth_4::id()) {
bpf_compute_budget = BpfComputeBudget {
max_invoke_depth: 4,
..bpf_compute_budget
};
}
if feature_set.is_active(&max_program_call_depth_64::id()) {
bpf_compute_budget = BpfComputeBudget {
max_call_depth: 64,
..bpf_compute_budget
};
}
if feature_set.is_active(&pubkey_log_syscall_enabled::id()) {
bpf_compute_budget = BpfComputeBudget {
log_pubkey_units: 100,
..bpf_compute_budget
};
}
if feature_set.is_active(&max_cpi_instruction_size_ipv6_mtu::id()) {
bpf_compute_budget = BpfComputeBudget {
max_cpi_instruction_size: 1280, // IPv6 Min MTU size
..bpf_compute_budget
};
}
bpf_compute_budget
} }
} }