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

cleanup old features (#19956)

Browse Source
This commit is contained in:
Jack May
2021-09-17 09:46:49 -07:00
committed by GitHub
parent 37d6f5013f
commit 7b0bf64404
5 changed files with 54 additions and 304 deletions
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, &post,
&mut ExecuteDetailsTimings::default(), &mut ExecuteDetailsTimings::default(),
false, false,
true,
), ),
Ok(()) Ok(())
); );
@ -40,7 +39,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post, &post,
&mut ExecuteDetailsTimings::default(), &mut ExecuteDetailsTimings::default(),
false, false,
true,
) )
.unwrap(); .unwrap();
}); });
@ -65,7 +63,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post, &post,
&mut ExecuteDetailsTimings::default(), &mut ExecuteDetailsTimings::default(),
false, false,
true,
) )
.unwrap(); .unwrap();
}); });

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

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

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

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

7
runtime/src/message_processor.rs
View File

@ -10,8 +10,7 @@ use solana_sdk::{
account::{AccountSharedData, ReadableAccount, WritableAccount}, account::{AccountSharedData, ReadableAccount, WritableAccount},
compute_budget::ComputeBudget, compute_budget::ComputeBudget,
feature_set::{ feature_set::{
demote_program_write_locks, neon_evm_compute_budget, tx_wide_compute_cap, demote_program_write_locks, neon_evm_compute_budget, tx_wide_compute_cap, FeatureSet,
updated_verify_policy, FeatureSet,
}, },
fee_calculator::FeeCalculator, fee_calculator::FeeCalculator,
hash::Hash, hash::Hash,
@ -232,7 +231,6 @@ impl<'a> InvokeContext for ThisInvokeContext<'a> {
write_privileges, write_privileges,
&mut self.timings, &mut self.timings,
logger, logger,
self.feature_set.is_active(&updated_verify_policy::id()),
) )
} }
fn get_caller(&self) -> Result<&Pubkey, InstructionError> { fn get_caller(&self) -> Result<&Pubkey, InstructionError> {
@ -427,7 +425,6 @@ impl MessageProcessor {
rent: &Rent, rent: &Rent,
timings: &mut ExecuteDetailsTimings, timings: &mut ExecuteDetailsTimings,
logger: Rc<RefCell<dyn Logger>>, logger: Rc<RefCell<dyn Logger>>,
updated_verify_policy: bool,
demote_program_write_locks: bool, demote_program_write_locks: bool,
) -> Result<(), InstructionError> { ) -> Result<(), InstructionError> {
// Verify all executable accounts have zero outstanding refs // Verify all executable accounts have zero outstanding refs
@ -454,7 +451,6 @@ impl MessageProcessor {
&account, &account,
timings, timings,
true, true,
updated_verify_policy,
) )
.map_err(|err| { .map_err(|err| {
ic_logger_msg!( ic_logger_msg!(
@ -563,7 +559,6 @@ impl MessageProcessor {
&rent_collector.rent, &rent_collector.rent,
timings, timings,
invoke_context.get_logger(), invoke_context.get_logger(),
invoke_context.is_feature_active(&updated_verify_policy::id()),
invoke_context.is_feature_active(&demote_program_write_locks::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"); solana_sdk::declare_id!("3ccR6QpxGYsAbWyfevEtBNGfWV4xBffxRj2tD6A9i39F");
} }
pub mod enforce_aligned_host_addrs {
solana_sdk::declare_id!("6Qob9Z4RwGdf599FDVCqsjuKjR8ZFR3oVs2ByRLWBsua");
}
pub mod stake_program_v4 { pub mod stake_program_v4 {
solana_sdk::declare_id!("Dc7djyhP9aLfdq2zktpvskeAjpG56msCU1yexpxXiWZb"); solana_sdk::declare_id!("Dc7djyhP9aLfdq2zktpvskeAjpG56msCU1yexpxXiWZb");
} }
@ -123,10 +119,6 @@ pub mod vote_stake_checked_instructions {
solana_sdk::declare_id!("BcWknVcgvonN8sL4HE4XFuEVgfcee5MwxWPAgP6ZV89X"); solana_sdk::declare_id!("BcWknVcgvonN8sL4HE4XFuEVgfcee5MwxWPAgP6ZV89X");
} }
pub mod updated_verify_policy {
solana_sdk::declare_id!("k15tVxtkgsmo7dy6iJ56N5hBCxuQAtqRgYwoTDuwbia");
}
pub mod neon_evm_compute_budget { pub mod neon_evm_compute_budget {
solana_sdk::declare_id!("GLrVvDPkQi5PMYUrsYWT9doZhSHr1BVZXqj5DbFps3rS"); 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"), (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"), (warp_timestamp_again::id(), "warp timestamp again, adjust bounding to 25% fast 80% slow #15204"),
(check_init_vote_data::id(), "check initialized Vote data"), (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"), (stake_program_v4::id(), "solana_stake_program v4"),
(secp256k1_recover_syscall_enabled::id(), "secp256k1_recover syscall"), (secp256k1_recover_syscall_enabled::id(), "secp256k1_recover syscall"),
(add_missing_program_error_mappings::id(), "add missing program error mappings"), (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"), (deterministic_shred_seed_enabled::id(), "deterministic shred seed"),
(verify_tx_signatures_len::id(), "prohibit extra transaction signatures"), (verify_tx_signatures_len::id(), "prohibit extra transaction signatures"),
(vote_stake_checked_instructions::id(), "vote/state program checked instructions #18345"), (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"), (neon_evm_compute_budget::id(), "bump neon_evm's compute budget"),
(rent_for_sysvars::id(), "collect rent from accounts owned by sysvars"), (rent_for_sysvars::id(), "collect rent from accounts owned by sysvars"),
(libsecp256k1_0_5_upgrade_enabled::id(), "upgrade libsecp256k1 to v0.5.0"), (libsecp256k1_0_5_upgrade_enabled::id(), "upgrade libsecp256k1 to v0.5.0"),