cleanup old features (#19956)
This commit is contained in:
parent
37d6f5013f
commit
7b0bf64404
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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,29 +467,15 @@ 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,
|
||||
)
|
||||
translate_type_inner::<T>(memory_mapping, AccessType::Load, vm_addr, loader_id)
|
||||
.map(|value| &*value)
|
||||
}
|
||||
|
||||
|
@ -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,32 +509,16 @@ 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,
|
||||
)
|
||||
translate_slice_inner::<T>(memory_mapping, AccessType::Load, vm_addr, len, loader_id)
|
||||
.map(|value| &*value)
|
||||
}
|
||||
|
||||
|
@ -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,13 +2681,8 @@ mod tests {
|
|||
&config,
|
||||
)
|
||||
.unwrap();
|
||||
let translated_data = translate_slice::<u8>(
|
||||
&memory_mapping,
|
||||
data.as_ptr() as u64,
|
||||
0,
|
||||
&bpf_loader::id(),
|
||||
true,
|
||||
)
|
||||
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,
|
||||
};
|
||||
|
|
|
@ -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()),
|
||||
)?;
|
||||
|
||||
|
|
|
@ -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"),
|
||||
|
|
Loading…
Reference in New Issue