blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

cleanup old features (#19956)

This commit is contained in:
Jack May 2021-09-17 09:46:49 -07:00 committed by GitHub
parent 37d6f5013f
commit 7b0bf64404
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 54 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
program-runtime/benches/instruction_processor.rs
View File

@ -26,7 +26,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post,
&mut ExecuteDetailsTimings::default(),
false,
true,
),
Ok(())
);
@ -40,7 +39,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post,
&mut ExecuteDetailsTimings::default(),
false,
true,
)
.unwrap();
});
@ -65,7 +63,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post,
&mut ExecuteDetailsTimings::default(),
false,
true,
)
.unwrap();
});

20
program-runtime/src/instruction_processor.rs
View File

@ -116,7 +116,6 @@ impl PreAccount {
post: &AccountSharedData,
timings: &mut ExecuteDetailsTimings,
outermost_call: bool,
updated_verify_policy: bool,
) -> Result<(), InstructionError> {
let pre = self.account.borrow();
@ -185,14 +184,9 @@ impl PreAccount {
if !rent.is_exempt(post.lamports(), post.data().len()) {
return Err(InstructionError::ExecutableAccountNotRentExempt);
}
let owner = if updated_verify_policy {
post.owner()
} else {
pre.owner()
};
if !is_writable // line coverage used to get branch coverage
|| pre.executable()
|| program_id != owner
|| program_id != post.owner()
{
return Err(InstructionError::ExecutableModified);
}
@ -703,7 +697,6 @@ impl InstructionProcessor {
write_privileges: &[bool],
timings: &mut ExecuteDetailsTimings,
logger: Rc<RefCell<dyn Logger>>,
updated_verify_policy: bool,
) -> Result<(), InstructionError> {
// Verify the per-account instruction results
let (mut pre_sum, mut post_sum) = (0_u128, 0_u128);
@ -722,15 +715,7 @@ impl InstructionProcessor {
}
let account = account.borrow();
pre_account
.verify(
program_id,
is_writable,
rent,
&account,
timings,
false,
updated_verify_policy,
)
.verify(program_id, is_writable, rent, &account, timings, false)
.map_err(|err| {
ic_logger_msg!(logger, "failed to verify account {}: {}", key, err);
err
@ -848,7 +833,6 @@ mod tests {
&self.post,
&mut ExecuteDetailsTimings::default(),
false,
true,
)
}
}

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

@ -23,8 +23,8 @@ use solana_sdk::{
feature_set::{
allow_native_ids, blake3_syscall_enabled, check_seed_length,
close_upgradeable_program_accounts, demote_program_write_locks, disable_fees_sysvar,
enforce_aligned_host_addrs, libsecp256k1_0_5_upgrade_enabled, mem_overlap_fix,
return_data_syscall_enabled, secp256k1_recover_syscall_enabled,
libsecp256k1_0_5_upgrade_enabled, mem_overlap_fix, return_data_syscall_enabled,
secp256k1_recover_syscall_enabled,
},
hash::{Hasher, HASH_BYTES},
ic_msg,
@ -208,8 +208,6 @@ pub fn bind_syscall_context_objects<'a>(
heap: AlignedMemory,
) -> Result<(), EbpfError<BpfError>> {
let compute_budget = invoke_context.get_compute_budget();
let enforce_aligned_host_addrs =
invoke_context.is_feature_active(&enforce_aligned_host_addrs::id());
// Syscall functions common across languages
@ -218,7 +216,6 @@ pub fn bind_syscall_context_objects<'a>(
Box::new(SyscallPanic {
compute_meter: invoke_context.get_compute_meter(),
loader_id,
enforce_aligned_host_addrs,
}),
None,
)?;
@ -227,7 +224,6 @@ pub fn bind_syscall_context_objects<'a>(
compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(),
loader_id,
enforce_aligned_host_addrs,
}),
None,
)?;
@ -255,7 +251,6 @@ pub fn bind_syscall_context_objects<'a>(
compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(),
loader_id,
enforce_aligned_host_addrs,
}),
None,
)?;
@ -267,7 +262,6 @@ pub fn bind_syscall_context_objects<'a>(
cost: compute_budget.create_program_address_units,
compute_meter: invoke_context.get_compute_meter(),
loader_id,
enforce_aligned_host_addrs,
allow_native_ids,
check_seed_length,
}),
@ -278,7 +272,6 @@ pub fn bind_syscall_context_objects<'a>(
cost: compute_budget.create_program_address_units,
compute_meter: invoke_context.get_compute_meter(),
loader_id,
enforce_aligned_host_addrs,
allow_native_ids,
check_seed_length,
}),
@ -291,7 +284,6 @@ pub fn bind_syscall_context_objects<'a>(
sha256_byte_cost: compute_budget.sha256_byte_cost,
compute_meter: invoke_context.get_compute_meter(),
loader_id,
enforce_aligned_host_addrs,
}),
None,
)?;
@ -461,19 +453,10 @@ fn translate_type_inner<'a, T>(
access_type: AccessType,
vm_addr: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
) -> Result<&'a mut T, EbpfError<BpfError>> {
if !enforce_aligned_host_addrs
&& loader_id != &bpf_loader_deprecated::id()
&& (vm_addr as *mut T).align_offset(align_of::<T>()) != 0
{
return Err(SyscallError::UnalignedPointer.into());
}
let host_addr = translate(memory_mapping, access_type, vm_addr, size_of::<T>() as u64)?;
if enforce_aligned_host_addrs
&& loader_id != &bpf_loader_deprecated::id()
if loader_id != &bpf_loader_deprecated::id()
&& (host_addr as *mut T).align_offset(align_of::<T>()) != 0
{
return Err(SyscallError::UnalignedPointer.into());
@ -484,30 +467,16 @@ fn translate_type_mut<'a, T>(
memory_mapping: &MemoryMapping,
vm_addr: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
) -> Result<&'a mut T, EbpfError<BpfError>> {
translate_type_inner::<T>(
memory_mapping,
AccessType::Store,
vm_addr,
loader_id,
enforce_aligned_host_addrs,
)
translate_type_inner::<T>(memory_mapping, AccessType::Store, vm_addr, loader_id)
}
fn translate_type<'a, T>(
memory_mapping: &MemoryMapping,
vm_addr: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
) -> Result<&'a T, EbpfError<BpfError>> {
translate_type_inner::<T>(
memory_mapping,
AccessType::Load,
vm_addr,
loader_id,
enforce_aligned_host_addrs,
)
.map(|value| &*value)
translate_type_inner::<T>(memory_mapping, AccessType::Load, vm_addr, loader_id)
.map(|value| &*value)
}
fn translate_slice_inner<'a, T>(
@ -516,14 +485,7 @@ fn translate_slice_inner<'a, T>(
vm_addr: u64,
len: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
) -> Result<&'a mut [T], EbpfError<BpfError>> {
if !enforce_aligned_host_addrs
&& loader_id != &bpf_loader_deprecated::id()
&& (vm_addr as u64 as *mut T).align_offset(align_of::<T>()) != 0
{
return Err(SyscallError::UnalignedPointer.into());
}
if len == 0 {
return Ok(&mut []);
}
@ -535,8 +497,7 @@ fn translate_slice_inner<'a, T>(
len.saturating_mul(size_of::<T>() as u64),
)?;
if enforce_aligned_host_addrs
&& loader_id != &bpf_loader_deprecated::id()
if loader_id != &bpf_loader_deprecated::id()
&& (host_addr as *mut T).align_offset(align_of::<T>()) != 0
{
return Err(SyscallError::UnalignedPointer.into());
@ -548,33 +509,17 @@ fn translate_slice_mut<'a, T>(
vm_addr: u64,
len: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
) -> Result<&'a mut [T], EbpfError<BpfError>> {
translate_slice_inner::<T>(
memory_mapping,
AccessType::Store,
vm_addr,
len,
loader_id,
enforce_aligned_host_addrs,
)
translate_slice_inner::<T>(memory_mapping, AccessType::Store, vm_addr, len, loader_id)
}
fn translate_slice<'a, T>(
memory_mapping: &MemoryMapping,
vm_addr: u64,
len: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
) -> Result<&'a [T], EbpfError<BpfError>> {
translate_slice_inner::<T>(
memory_mapping,
AccessType::Load,
vm_addr,
len,
loader_id,
enforce_aligned_host_addrs,
)
.map(|value| &*value)
translate_slice_inner::<T>(memory_mapping, AccessType::Load, vm_addr, len, loader_id)
.map(|value| &*value)
}
/// Take a virtual pointer to a string (points to BPF VM memory space), translate it
@ -584,16 +529,9 @@ fn translate_string_and_do(
addr: u64,
len: u64,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
work: &mut dyn FnMut(&str) -> Result<u64, EbpfError<BpfError>>,
) -> Result<u64, EbpfError<BpfError>> {
let buf = translate_slice::<u8>(
memory_mapping,
addr,
len,
loader_id,
enforce_aligned_host_addrs,
)?;
let buf = translate_slice::<u8>(memory_mapping, addr, len, loader_id)?;
let i = match buf.iter().position(|byte| *byte == 0) {
Some(i) => i,
None => len as usize,
@ -630,7 +568,6 @@ impl SyscallObject<BpfError> for SyscallAbort {
pub struct SyscallPanic<'a> {
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
loader_id: &'a Pubkey,
enforce_aligned_host_addrs: bool,
}
impl<'a> SyscallObject<BpfError> for SyscallPanic<'a> {
fn call(
@ -649,7 +586,6 @@ impl<'a> SyscallObject<BpfError> for SyscallPanic<'a> {
file,
len,
self.loader_id,
self.enforce_aligned_host_addrs,
&mut |string: &str| Err(SyscallError::Panic(string.to_string(), line, column).into()),
);
}
@ -660,7 +596,6 @@ pub struct SyscallLog<'a> {
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
logger: Rc<RefCell<dyn Logger>>,
loader_id: &'a Pubkey,
enforce_aligned_host_addrs: bool,
}
impl<'a> SyscallObject<BpfError> for SyscallLog<'a> {
fn call(
@ -680,7 +615,6 @@ impl<'a> SyscallObject<BpfError> for SyscallLog<'a> {
addr,
len,
self.loader_id,
self.enforce_aligned_host_addrs,
&mut |string: &str| {
stable_log::program_log(&self.logger, string);
Ok(0)
@ -761,7 +695,6 @@ pub struct SyscallLogPubkey<'a> {
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
logger: Rc<RefCell<dyn Logger>>,
loader_id: &'a Pubkey,
enforce_aligned_host_addrs: bool,
}
impl<'a> SyscallObject<BpfError> for SyscallLogPubkey<'a> {
fn call(
@ -776,12 +709,7 @@ impl<'a> SyscallObject<BpfError> for SyscallLogPubkey<'a> {
) {
question_mark!(self.compute_meter.consume(self.cost), result);
let pubkey = question_mark!(
translate_type::<Pubkey>(
memory_mapping,
pubkey_addr,
self.loader_id,
self.enforce_aligned_host_addrs,
),
translate_type::<Pubkey>(memory_mapping, pubkey_addr, self.loader_id,),
result
);
stable_log::program_log(&self.logger, &pubkey.to_string());
@ -840,16 +768,10 @@ fn translate_and_check_program_address_inputs<'a>(
program_id_addr: u64,
memory_mapping: &MemoryMapping,
loader_id: &Pubkey,
enforce_aligned_host_addrs: bool,
check_seed_length: bool,
) -> Result<(Vec<&'a [u8]>, &'a Pubkey), EbpfError<BpfError>> {
let untranslated_seeds = translate_slice::<&[&u8]>(
memory_mapping,
seeds_addr,
seeds_len,
loader_id,
enforce_aligned_host_addrs,
)?;
let untranslated_seeds =
translate_slice::<&[&u8]>(memory_mapping, seeds_addr, seeds_len, loader_id)?;
if untranslated_seeds.len() > MAX_SEEDS {
return Err(SyscallError::BadSeeds(PubkeyError::MaxSeedLengthExceeded).into());
}
@ -864,16 +786,10 @@ fn translate_and_check_program_address_inputs<'a>(
untranslated_seed.as_ptr() as *const _ as u64,
untranslated_seed.len() as u64,
loader_id,
enforce_aligned_host_addrs,
)
})
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
let program_id = translate_type::<Pubkey>(
memory_mapping,
program_id_addr,
loader_id,
enforce_aligned_host_addrs,
)?;
let program_id = translate_type::<Pubkey>(memory_mapping, program_id_addr, loader_id)?;
Ok((seeds, program_id))
}
@ -911,7 +827,6 @@ struct SyscallCreateProgramAddress<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
loader_id: &'a Pubkey,
enforce_aligned_host_addrs: bool,
allow_native_ids: bool,
check_seed_length: bool,
}
@ -937,7 +852,6 @@ impl<'a> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a> {
program_id_addr,
memory_mapping,
self.loader_id,
self.enforce_aligned_host_addrs,
self.check_seed_length,
),
result
@ -960,13 +874,7 @@ impl<'a> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a> {
}
};
let address = question_mark!(
translate_slice_mut::<u8>(
memory_mapping,
address_addr,
32,
self.loader_id,
self.enforce_aligned_host_addrs,
),
translate_slice_mut::<u8>(memory_mapping, address_addr, 32, self.loader_id,),
result
);
address.copy_from_slice(new_address.as_ref());
@ -979,7 +887,6 @@ struct SyscallTryFindProgramAddress<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
loader_id: &'a Pubkey,
enforce_aligned_host_addrs: bool,
allow_native_ids: bool,
check_seed_length: bool,
}
@ -1005,7 +912,6 @@ impl<'a> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a> {
program_id_addr,
memory_mapping,
self.loader_id,
self.enforce_aligned_host_addrs,
self.check_seed_length,
),
result
@ -1030,7 +936,6 @@ impl<'a> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a> {
memory_mapping,
bump_seed_addr,
self.loader_id,
self.enforce_aligned_host_addrs,
),
result
);
@ -1040,7 +945,6 @@ impl<'a> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a> {
address_addr,
32,
self.loader_id,
self.enforce_aligned_host_addrs,
),
result
);
@ -1066,7 +970,6 @@ pub struct SyscallSha256<'a> {
sha256_byte_cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
loader_id: &'a Pubkey,
enforce_aligned_host_addrs: bool,
}
impl<'a> SyscallObject<BpfError> for SyscallSha256<'a> {
fn call(
@ -1086,20 +989,13 @@ impl<'a> SyscallObject<BpfError> for SyscallSha256<'a> {
result_addr,
HASH_BYTES as u64,
self.loader_id,
self.enforce_aligned_host_addrs,
),
result
);
let mut hasher = Hasher::default();
if vals_len > 0 {
let vals = question_mark!(
translate_slice::<&[u8]>(
memory_mapping,
vals_addr,
vals_len,
self.loader_id,
self.enforce_aligned_host_addrs,
),
translate_slice::<&[u8]>(memory_mapping, vals_addr, vals_len, self.loader_id,),
result
);
for val in vals.iter() {
@ -1109,7 +1005,6 @@ impl<'a> SyscallObject<BpfError> for SyscallSha256<'a> {
val.as_ptr() as u64,
val.len() as u64,
self.loader_id,
self.enforce_aligned_host_addrs,
),
result
);
@ -1140,12 +1035,7 @@ fn get_sysvar<T: std::fmt::Debug + Sysvar + SysvarId>(
invoke_context
.get_compute_meter()
.consume(invoke_context.get_compute_budget().sysvar_base_cost + size_of::<T>() as u64)?;
let var = translate_type_mut::<T>(
memory_mapping,
var_addr,
loader_id,
invoke_context.is_feature_active(&enforce_aligned_host_addrs::id()),
)?;
let var = translate_type_mut::<T>(memory_mapping, var_addr, loader_id)?;
*var = process_instruction::get_sysvar::<T>(*invoke_context, id)
.map_err(SyscallError::InstructionError)?;
@ -1280,14 +1170,13 @@ impl<'a> SyscallObject<BpfError> for SyscallKeccak256<'a> {
result_addr,
keccak::HASH_BYTES as u64,
self.loader_id,
true,
),
result
);
let mut hasher = keccak::Hasher::default();
if vals_len > 0 {
let vals = question_mark!(
translate_slice::<&[u8]>(memory_mapping, vals_addr, vals_len, self.loader_id, true),
translate_slice::<&[u8]>(memory_mapping, vals_addr, vals_len, self.loader_id),
result
);
for val in vals.iter() {
@ -1297,7 +1186,6 @@ impl<'a> SyscallObject<BpfError> for SyscallKeccak256<'a> {
val.as_ptr() as u64,
val.len() as u64,
self.loader_id,
true,
),
result
);
@ -1348,11 +1236,11 @@ impl<'a> SyscallObject<BpfError> for SyscallMemcpy<'a> {
question_mark!(self.compute_meter.consume(n / self.cost), result);
let dst = question_mark!(
translate_slice_mut::<u8>(memory_mapping, dst_addr, n, self.loader_id, true),
translate_slice_mut::<u8>(memory_mapping, dst_addr, n, self.loader_id),
result
);
let src = question_mark!(
translate_slice::<u8>(memory_mapping, src_addr, n, self.loader_id, true),
translate_slice::<u8>(memory_mapping, src_addr, n, self.loader_id),
result
);
unsafe {
@ -1380,11 +1268,11 @@ impl<'a> SyscallObject<BpfError> for SyscallMemmove<'a> {
) {
question_mark!(self.compute_meter.consume(n / self.cost), result);
let dst = question_mark!(
translate_slice_mut::<u8>(memory_mapping, dst_addr, n, self.loader_id, true),
translate_slice_mut::<u8>(memory_mapping, dst_addr, n, self.loader_id),
result
);
let src = question_mark!(
translate_slice::<u8>(memory_mapping, src_addr, n, self.loader_id, true),
translate_slice::<u8>(memory_mapping, src_addr, n, self.loader_id),
result
);
unsafe {
@ -1412,15 +1300,15 @@ impl<'a> SyscallObject<BpfError> for SyscallMemcmp<'a> {
) {
question_mark!(self.compute_meter.consume(n / self.cost), result);
let s1 = question_mark!(
translate_slice::<u8>(memory_mapping, s1_addr, n, self.loader_id, true),
translate_slice::<u8>(memory_mapping, s1_addr, n, self.loader_id),
result
);
let s2 = question_mark!(
translate_slice::<u8>(memory_mapping, s2_addr, n, self.loader_id, true),
translate_slice::<u8>(memory_mapping, s2_addr, n, self.loader_id),
result
);
let cmp_result = question_mark!(
translate_type_mut::<i32>(memory_mapping, cmp_result_addr, self.loader_id, true),
translate_type_mut::<i32>(memory_mapping, cmp_result_addr, self.loader_id),
result
);
let mut i = 0;
@ -1457,7 +1345,7 @@ impl<'a> SyscallObject<BpfError> for SyscallMemset<'a> {
) {
question_mark!(self.compute_meter.consume(n / self.cost), result);
let s = question_mark!(
translate_slice_mut::<u8>(memory_mapping, s_addr, n, self.loader_id, true),
translate_slice_mut::<u8>(memory_mapping, s_addr, n, self.loader_id),
result
);
for val in s.iter_mut().take(n as usize) {
@ -1494,7 +1382,6 @@ impl<'a> SyscallObject<BpfError> for SyscallSecp256k1Recover<'a> {
hash_addr,
keccak::HASH_BYTES as u64,
self.loader_id,
true,
),
result
);
@ -1504,7 +1391,6 @@ impl<'a> SyscallObject<BpfError> for SyscallSecp256k1Recover<'a> {
signature_addr,
SECP256K1_SIGNATURE_LENGTH as u64,
self.loader_id,
true,
),
result
);
@ -1514,7 +1400,6 @@ impl<'a> SyscallObject<BpfError> for SyscallSecp256k1Recover<'a> {
result_addr,
SECP256K1_PUBLIC_KEY_LENGTH as u64,
self.loader_id,
true,
),
result
);
@ -1585,14 +1470,13 @@ impl<'a> SyscallObject<BpfError> for SyscallBlake3<'a> {
result_addr,
blake3::HASH_BYTES as u64,
self.loader_id,
true,
),
result
);
let mut hasher = blake3::Hasher::default();
if vals_len > 0 {
let vals = question_mark!(
translate_slice::<&[u8]>(memory_mapping, vals_addr, vals_len, self.loader_id, true),
translate_slice::<&[u8]>(memory_mapping, vals_addr, vals_len, self.loader_id),
result
);
for val in vals.iter() {
@ -1602,7 +1486,6 @@ impl<'a> SyscallObject<BpfError> for SyscallBlake3<'a> {
val.as_ptr() as u64,
val.len() as u64,
self.loader_id,
true,
),
result
);
@ -1646,7 +1529,6 @@ trait SyscallInvokeSigned<'a> {
&self,
addr: u64,
memory_mapping: &MemoryMapping,
enforce_aligned_host_addrs: bool,
) -> Result<Instruction, EbpfError<BpfError>>;
fn translate_accounts(
&self,
@ -1662,7 +1544,6 @@ trait SyscallInvokeSigned<'a> {
signers_seeds_addr: u64,
signers_seeds_len: u64,
memory_mapping: &MemoryMapping,
enforce_aligned_host_addrs: bool,
) -> Result<Vec<Pubkey>, EbpfError<BpfError>>;
}
@ -1686,14 +1567,8 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
&self,
addr: u64,
memory_mapping: &MemoryMapping,
enforce_aligned_host_addrs: bool,
) -> Result<Instruction, EbpfError<BpfError>> {
let ix = translate_type::<Instruction>(
memory_mapping,
addr,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let ix = translate_type::<Instruction>(memory_mapping, addr, self.loader_id)?;
check_instruction_size(
ix.accounts.len(),
@ -1706,7 +1581,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
ix.accounts.as_ptr() as u64,
ix.accounts.len() as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?
.to_vec();
let data = translate_slice::<u8>(
@ -1714,7 +1588,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
ix.data.as_ptr() as u64,
ix.data.len() as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?
.to_vec();
Ok(Instruction {
@ -1733,15 +1606,12 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
memory_mapping: &MemoryMapping,
) -> Result<TranslatedAccounts<'a>, EbpfError<BpfError>> {
let invoke_context = self.invoke_context.borrow();
let enforce_aligned_host_addrs =
invoke_context.is_feature_active(&enforce_aligned_host_addrs::id());
let account_infos = translate_slice::<AccountInfo>(
memory_mapping,
account_infos_addr,
account_infos_len,
self.loader_id,
enforce_aligned_host_addrs,
)?;
check_account_infos(account_infos.len(), &invoke_context)?;
let account_info_keys = account_infos
@ -1751,7 +1621,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
memory_mapping,
account_info.key as *const _ as u64,
self.loader_id,
enforce_aligned_host_addrs,
)
})
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
@ -1766,20 +1635,13 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
memory_mapping,
account_info.lamports.as_ptr() as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
translate_type_mut::<u64>(
memory_mapping,
*ptr,
self.loader_id,
enforce_aligned_host_addrs,
)?
translate_type_mut::<u64>(memory_mapping, *ptr, self.loader_id)?
};
let owner = translate_type_mut::<Pubkey>(
memory_mapping,
account_info.owner as *const _ as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let (data, vm_data_addr, ref_to_len_in_vm, serialized_len_ptr) = {
@ -1788,7 +1650,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
memory_mapping,
account_info.data.as_ptr() as *const _ as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
invoke_context.get_compute_meter().consume(
@ -1807,7 +1668,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
memory_mapping,
ref_of_len_in_input_buffer as *const _ as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let vm_data_addr = data.as_ptr() as u64;
(
@ -1816,7 +1676,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
vm_data_addr,
data.len() as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?,
vm_data_addr,
ref_to_len_in_vm,
@ -1859,7 +1718,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
signers_seeds_addr: u64,
signers_seeds_len: u64,
memory_mapping: &MemoryMapping,
enforce_aligned_host_addrs: bool,
) -> Result<Vec<Pubkey>, EbpfError<BpfError>> {
let mut signers = Vec::new();
if signers_seeds_len > 0 {
@ -1868,7 +1726,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
signers_seeds_addr,
signers_seeds_len,
self.loader_id,
enforce_aligned_host_addrs,
)?;
if signers_seeds.len() > MAX_SIGNERS {
return Err(SyscallError::TooManySigners.into());
@ -1879,7 +1736,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
signer_seeds.as_ptr() as *const _ as u64,
signer_seeds.len() as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
if untranslated_seeds.len() > MAX_SEEDS {
return Err(SyscallError::InstructionError(
@ -1895,7 +1751,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
untranslated_seed.as_ptr() as *const _ as u64,
untranslated_seed.len() as u64,
self.loader_id,
enforce_aligned_host_addrs,
)
})
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
@ -1999,50 +1854,34 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
&self,
addr: u64,
memory_mapping: &MemoryMapping,
enforce_aligned_host_addrs: bool,
) -> Result<Instruction, EbpfError<BpfError>> {
let ix_c = translate_type::<SolInstruction>(
memory_mapping,
addr,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let ix_c = translate_type::<SolInstruction>(memory_mapping, addr, self.loader_id)?;
check_instruction_size(
ix_c.accounts_len,
ix_c.data_len,
&self.invoke_context.borrow(),
)?;
let program_id = translate_type::<Pubkey>(
memory_mapping,
ix_c.program_id_addr,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let program_id =
translate_type::<Pubkey>(memory_mapping, ix_c.program_id_addr, self.loader_id)?;
let meta_cs = translate_slice::<SolAccountMeta>(
memory_mapping,
ix_c.accounts_addr,
ix_c.accounts_len as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let data = translate_slice::<u8>(
memory_mapping,
ix_c.data_addr,
ix_c.data_len as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?
.to_vec();
let accounts = meta_cs
.iter()
.map(|meta_c| {
let pubkey = translate_type::<Pubkey>(
memory_mapping,
meta_c.pubkey_addr,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let pubkey =
translate_type::<Pubkey>(memory_mapping, meta_c.pubkey_addr, self.loader_id)?;
Ok(AccountMeta {
pubkey: *pubkey,
is_signer: meta_c.is_signer,
@ -2067,26 +1906,18 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
memory_mapping: &MemoryMapping,
) -> Result<TranslatedAccounts<'a>, EbpfError<BpfError>> {
let invoke_context = self.invoke_context.borrow();
let enforce_aligned_host_addrs =
invoke_context.is_feature_active(&enforce_aligned_host_addrs::id());
let account_infos = translate_slice::<SolAccountInfo>(
memory_mapping,
account_infos_addr,
account_infos_len,
self.loader_id,
enforce_aligned_host_addrs,
)?;
check_account_infos(account_infos.len(), &invoke_context)?;
let account_info_keys = account_infos
.iter()
.map(|account_info| {
translate_type::<Pubkey>(
memory_mapping,
account_info.key_addr,
self.loader_id,
enforce_aligned_host_addrs,
)
translate_type::<Pubkey>(memory_mapping, account_info.key_addr, self.loader_id)
})
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
@ -2098,13 +1929,11 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
memory_mapping,
account_info.lamports_addr,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let owner = translate_type_mut::<Pubkey>(
memory_mapping,
account_info.owner_addr,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let vm_data_addr = account_info.data_addr;
@ -2117,7 +1946,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
vm_data_addr,
account_info.data_len,
self.loader_id,
enforce_aligned_host_addrs,
)?;
let first_info_addr = &account_infos[0] as *const _ as u64;
@ -2137,7 +1965,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
memory_mapping,
ref_of_len_in_input_buffer as *const _ as u64,
self.loader_id,
enforce_aligned_host_addrs,
)?;
Ok((
@ -2175,7 +2002,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
signers_seeds_addr: u64,
signers_seeds_len: u64,
memory_mapping: &MemoryMapping,
enforce_aligned_host_addrs: bool,
) -> Result<Vec<Pubkey>, EbpfError<BpfError>> {
if signers_seeds_len > 0 {
let signers_seeds = translate_slice::<SolSignerSeedC>(
@ -2183,7 +2009,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
signers_seeds_addr,
signers_seeds_len,
self.loader_id,
enforce_aligned_host_addrs,
)?;
if signers_seeds.len() > MAX_SIGNERS {
return Err(SyscallError::TooManySigners.into());
@ -2196,7 +2021,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
signer_seeds.addr,
signer_seeds.len,
self.loader_id,
enforce_aligned_host_addrs,
)?;
if seeds.len() > MAX_SEEDS {
return Err(SyscallError::InstructionError(
@ -2212,7 +2036,6 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
seed.addr,
seed.len,
self.loader_id,
enforce_aligned_host_addrs,
)
})
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
@ -2412,26 +2235,18 @@ fn call<'a>(
.get_compute_meter()
.consume(invoke_context.get_compute_budget().invoke_units)?;
let enforce_aligned_host_addrs =
invoke_context.is_feature_active(&enforce_aligned_host_addrs::id());
let caller_program_id = invoke_context
.get_caller()
.map_err(SyscallError::InstructionError)?;
// Translate and verify caller's data
let instruction = syscall.translate_instruction(
instruction_addr,
memory_mapping,
enforce_aligned_host_addrs,
)?;
let instruction = syscall.translate_instruction(instruction_addr, memory_mapping)?;
let signers = syscall.translate_signers(
caller_program_id,
signers_seeds_addr,
signers_seeds_len,
memory_mapping,
enforce_aligned_host_addrs,
)?;
let keyed_account_refs = invoke_context
.get_keyed_accounts()
@ -2565,7 +2380,6 @@ fn call<'a>(
account_ref.vm_data_addr,
account.data().len() as u64,
&bpf_loader_deprecated::id(), // Don't care since it is byte aligned
true,
)?;
*account_ref.ref_to_len_in_vm = account.data().len() as u64;
*account_ref.serialized_len_ptr = account.data().len() as u64;
@ -2622,7 +2436,7 @@ impl<'a> SyscallObject<BpfError> for SyscallSetReturnData<'a> {
invoke_context.set_return_data(None);
} else {
let return_data = question_mark!(
translate_slice::<u8>(memory_mapping, addr, len, self.loader_id, true),
translate_slice::<u8>(memory_mapping, addr, len, self.loader_id),
result
);
@ -2688,7 +2502,6 @@ impl<'a> SyscallObject<BpfError> for SyscallGetReturnData<'a> {
return_data_addr,
length,
self.loader_id,
true,
),
result
);
@ -2701,7 +2514,6 @@ impl<'a> SyscallObject<BpfError> for SyscallGetReturnData<'a> {
program_id_addr,
1,
self.loader_id,
true,
),
result
);
@ -2813,8 +2625,7 @@ mod tests {
)
.unwrap();
let translated_pubkey =
translate_type::<Pubkey>(&memory_mapping, 0x100000000, &bpf_loader::id(), true)
.unwrap();
translate_type::<Pubkey>(&memory_mapping, 0x100000000, &bpf_loader::id()).unwrap();
assert_eq!(pubkey, *translated_pubkey);
// Instruction
@ -2839,17 +2650,13 @@ mod tests {
)
.unwrap();
let translated_instruction =
translate_type::<Instruction>(&memory_mapping, 0x100000000, &bpf_loader::id(), true)
.unwrap();
translate_type::<Instruction>(&memory_mapping, 0x100000000, &bpf_loader::id()).unwrap();
assert_eq!(instruction, *translated_instruction);
memory_mapping.resize_region::<BpfError>(1, 1).unwrap();
assert!(translate_type::<Instruction>(
&memory_mapping,
0x100000000,
&bpf_loader::id(),
true
)
.is_err());
assert!(
translate_type::<Instruction>(&memory_mapping, 0x100000000, &bpf_loader::id(),)
.is_err()
);
}
#[test]
@ -2874,14 +2681,9 @@ mod tests {
&config,
)
.unwrap();
let translated_data = translate_slice::<u8>(
&memory_mapping,
data.as_ptr() as u64,
0,
&bpf_loader::id(),
true,
)
.unwrap();
let translated_data =
translate_slice::<u8>(&memory_mapping, data.as_ptr() as u64, 0, &bpf_loader::id())
.unwrap();
assert_eq!(data, translated_data);
assert_eq!(0, translated_data.len());
@ -2907,7 +2709,6 @@ mod tests {
0x100000000,
data.len() as u64,
&bpf_loader::id(),
true,
)
.unwrap();
assert_eq!(data, translated_data);
@ -2918,7 +2719,6 @@ mod tests {
data.as_ptr() as u64,
u64::MAX,
&bpf_loader::id(),
true,
)
.is_err());
@ -2927,7 +2727,6 @@ mod tests {
0x100000000 - 1,
data.len() as u64,
&bpf_loader::id(),
true,
)
.is_err());
@ -2953,20 +2752,15 @@ mod tests {
0x100000000,
data.len() as u64,
&bpf_loader::id(),
true,
)
.unwrap();
assert_eq!(data, translated_data);
data[0] = 10;
assert_eq!(data, translated_data);
assert!(translate_slice::<u64>(
&memory_mapping,
0x100000000,
u64::MAX,
&bpf_loader::id(),
true,
)
.is_err());
assert!(
translate_slice::<u64>(&memory_mapping, 0x100000000, u64::MAX, &bpf_loader::id(),)
.is_err()
);
// Pubkeys
let mut data = vec![solana_sdk::pubkey::new_rand(); 5];
@ -2990,7 +2784,6 @@ mod tests {
0x100000000,
data.len() as u64,
&bpf_loader::id(),
true,
)
.unwrap();
assert_eq!(data, translated_data);
@ -3024,7 +2817,6 @@ mod tests {
0x100000000,
string.len() as u64,
&bpf_loader::id(),
true,
&mut |string: &str| {
assert_eq!(string, "Gaggablaghblagh!");
Ok(42)
@ -3082,7 +2874,6 @@ mod tests {
let mut syscall_panic = SyscallPanic {
compute_meter,
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
syscall_panic.call(
@ -3108,7 +2899,6 @@ mod tests {
let mut syscall_panic = SyscallPanic {
compute_meter,
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
syscall_panic.call(
@ -3137,7 +2927,6 @@ mod tests {
compute_meter,
logger,
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
};
let config = Config::default();
let memory_mapping = MemoryMapping::new::<UserError>(
@ -3211,7 +3000,6 @@ mod tests {
compute_meter,
logger,
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
syscall_sol_log.call(
@ -3282,7 +3070,6 @@ mod tests {
compute_meter,
logger,
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
};
let config = Config::default();
let memory_mapping = MemoryMapping::new::<UserError>(
@ -3518,7 +3305,6 @@ mod tests {
sha256_byte_cost: 2,
compute_meter,
loader_id: &bpf_loader_deprecated::id(),
enforce_aligned_host_addrs: true,
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
@ -3859,7 +3645,6 @@ mod tests {
cost: 1,
compute_meter: compute_meter.clone(),
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
allow_native_ids: true,
check_seed_length: true,
};
@ -3878,7 +3663,6 @@ mod tests {
cost: 1,
compute_meter: compute_meter.clone(),
loader_id: &bpf_loader::id(),
enforce_aligned_host_addrs: true,
allow_native_ids: true,
check_seed_length: true,
};

7
runtime/src/message_processor.rs
View File

@ -10,8 +10,7 @@ use solana_sdk::{
account::{AccountSharedData, ReadableAccount, WritableAccount},
compute_budget::ComputeBudget,
feature_set::{
demote_program_write_locks, neon_evm_compute_budget, tx_wide_compute_cap,
updated_verify_policy, FeatureSet,
demote_program_write_locks, neon_evm_compute_budget, tx_wide_compute_cap, FeatureSet,
},
fee_calculator::FeeCalculator,
hash::Hash,
@ -232,7 +231,6 @@ impl<'a> InvokeContext for ThisInvokeContext<'a> {
write_privileges,
&mut self.timings,
logger,
self.feature_set.is_active(&updated_verify_policy::id()),
)
}
fn get_caller(&self) -> Result<&Pubkey, InstructionError> {
@ -427,7 +425,6 @@ impl MessageProcessor {
rent: &Rent,
timings: &mut ExecuteDetailsTimings,
logger: Rc<RefCell<dyn Logger>>,
updated_verify_policy: bool,
demote_program_write_locks: bool,
) -> Result<(), InstructionError> {
// Verify all executable accounts have zero outstanding refs
@ -454,7 +451,6 @@ impl MessageProcessor {
&account,
timings,
true,
updated_verify_policy,
)
.map_err(|err| {
ic_logger_msg!(
@ -563,7 +559,6 @@ impl MessageProcessor {
&rent_collector.rent,
timings,
invoke_context.get_logger(),
invoke_context.is_feature_active(&updated_verify_policy::id()),
invoke_context.is_feature_active(&demote_program_write_locks::id()),
)?;

10
sdk/src/feature_set.rs
View File

@ -83,10 +83,6 @@ pub mod check_init_vote_data {
solana_sdk::declare_id!("3ccR6QpxGYsAbWyfevEtBNGfWV4xBffxRj2tD6A9i39F");
}
pub mod enforce_aligned_host_addrs {
solana_sdk::declare_id!("6Qob9Z4RwGdf599FDVCqsjuKjR8ZFR3oVs2ByRLWBsua");
}
pub mod stake_program_v4 {
solana_sdk::declare_id!("Dc7djyhP9aLfdq2zktpvskeAjpG56msCU1yexpxXiWZb");
}
@ -123,10 +119,6 @@ pub mod vote_stake_checked_instructions {
solana_sdk::declare_id!("BcWknVcgvonN8sL4HE4XFuEVgfcee5MwxWPAgP6ZV89X");
}
pub mod updated_verify_policy {
solana_sdk::declare_id!("k15tVxtkgsmo7dy6iJ56N5hBCxuQAtqRgYwoTDuwbia");
}
pub mod neon_evm_compute_budget {
solana_sdk::declare_id!("GLrVvDPkQi5PMYUrsYWT9doZhSHr1BVZXqj5DbFps3rS");
}
@ -231,7 +223,6 @@ lazy_static! {
(full_inflation::mainnet::certusone::vote::id(), "community vote allowing Certus One to enable full inflation"),
(warp_timestamp_again::id(), "warp timestamp again, adjust bounding to 25% fast 80% slow #15204"),
(check_init_vote_data::id(), "check initialized Vote data"),
(enforce_aligned_host_addrs::id(), "enforce aligned host addresses"),
(stake_program_v4::id(), "solana_stake_program v4"),
(secp256k1_recover_syscall_enabled::id(), "secp256k1_recover syscall"),
(add_missing_program_error_mappings::id(), "add missing program error mappings"),
@ -241,7 +232,6 @@ lazy_static! {
(deterministic_shred_seed_enabled::id(), "deterministic shred seed"),
(verify_tx_signatures_len::id(), "prohibit extra transaction signatures"),
(vote_stake_checked_instructions::id(), "vote/state program checked instructions #18345"),
(updated_verify_policy::id(), "update verify policy"),
(neon_evm_compute_budget::id(), "bump neon_evm's compute budget"),
(rent_for_sysvars::id(), "collect rent from accounts owned by sysvars"),
(libsecp256k1_0_5_upgrade_enabled::id(), "upgrade libsecp256k1 to v0.5.0"),