From 7b0bf644041322d557a116bc86a61a57569fa5dc Mon Sep 17 00:00:00 2001 From: Jack May Date: Fri, 17 Sep 2021 09:46:49 -0700 Subject: [PATCH] cleanup old features (#19956) --- .../benches/instruction_processor.rs | 3 - program-runtime/src/instruction_processor.rs | 20 +- programs/bpf_loader/src/syscalls.rs | 318 +++--------------- runtime/src/message_processor.rs | 7 +- sdk/src/feature_set.rs | 10 - 5 files changed, 54 insertions(+), 304 deletions(-) diff --git a/program-runtime/benches/instruction_processor.rs b/program-runtime/benches/instruction_processor.rs index 5de050e80..5b6f4dd4e 100644 --- a/program-runtime/benches/instruction_processor.rs +++ b/program-runtime/benches/instruction_processor.rs @@ -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(); }); diff --git a/program-runtime/src/instruction_processor.rs b/program-runtime/src/instruction_processor.rs index 26f62f93a..c7b27e730 100644 --- a/program-runtime/src/instruction_processor.rs +++ b/program-runtime/src/instruction_processor.rs @@ -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>, - 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, ) } } diff --git a/programs/bpf_loader/src/syscalls.rs b/programs/bpf_loader/src/syscalls.rs index 2fc5639d8..d031bef67 100644 --- a/programs/bpf_loader/src/syscalls.rs +++ b/programs/bpf_loader/src/syscalls.rs @@ -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> { 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> { - if !enforce_aligned_host_addrs - && loader_id != &bpf_loader_deprecated::id() - && (vm_addr as *mut T).align_offset(align_of::()) != 0 - { - return Err(SyscallError::UnalignedPointer.into()); - } - let host_addr = translate(memory_mapping, access_type, vm_addr, size_of::() 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::()) != 0 { return Err(SyscallError::UnalignedPointer.into()); @@ -484,30 +467,16 @@ fn translate_type_mut<'a, T>( memory_mapping: &MemoryMapping, vm_addr: u64, loader_id: &Pubkey, - enforce_aligned_host_addrs: bool, ) -> Result<&'a mut T, EbpfError> { - translate_type_inner::( - memory_mapping, - AccessType::Store, - vm_addr, - loader_id, - enforce_aligned_host_addrs, - ) + translate_type_inner::(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> { - translate_type_inner::( - memory_mapping, - AccessType::Load, - vm_addr, - loader_id, - enforce_aligned_host_addrs, - ) - .map(|value| &*value) + translate_type_inner::(memory_mapping, AccessType::Load, vm_addr, loader_id) + .map(|value| &*value) } fn translate_slice_inner<'a, T>( @@ -516,14 +485,7 @@ fn translate_slice_inner<'a, T>( vm_addr: u64, len: u64, loader_id: &Pubkey, - enforce_aligned_host_addrs: bool, ) -> Result<&'a mut [T], EbpfError> { - if !enforce_aligned_host_addrs - && loader_id != &bpf_loader_deprecated::id() - && (vm_addr as u64 as *mut T).align_offset(align_of::()) != 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::() 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::()) != 0 { return Err(SyscallError::UnalignedPointer.into()); @@ -548,33 +509,17 @@ fn translate_slice_mut<'a, T>( vm_addr: u64, len: u64, loader_id: &Pubkey, - enforce_aligned_host_addrs: bool, ) -> Result<&'a mut [T], EbpfError> { - translate_slice_inner::( - memory_mapping, - AccessType::Store, - vm_addr, - len, - loader_id, - enforce_aligned_host_addrs, - ) + translate_slice_inner::(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> { - translate_slice_inner::( - memory_mapping, - AccessType::Load, - vm_addr, - len, - loader_id, - enforce_aligned_host_addrs, - ) - .map(|value| &*value) + translate_slice_inner::(memory_mapping, AccessType::Load, vm_addr, len, loader_id) + .map(|value| &*value) } /// Take a virtual pointer to a string (points to BPF VM memory space), translate it @@ -584,16 +529,9 @@ fn translate_string_and_do( addr: u64, len: u64, loader_id: &Pubkey, - enforce_aligned_host_addrs: bool, work: &mut dyn FnMut(&str) -> Result>, ) -> Result> { - let buf = translate_slice::( - memory_mapping, - addr, - len, - loader_id, - enforce_aligned_host_addrs, - )?; + let buf = translate_slice::(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 for SyscallAbort { pub struct SyscallPanic<'a> { compute_meter: Rc>, loader_id: &'a Pubkey, - enforce_aligned_host_addrs: bool, } impl<'a> SyscallObject for SyscallPanic<'a> { fn call( @@ -649,7 +586,6 @@ impl<'a> SyscallObject 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>, logger: Rc>, loader_id: &'a Pubkey, - enforce_aligned_host_addrs: bool, } impl<'a> SyscallObject for SyscallLog<'a> { fn call( @@ -680,7 +615,6 @@ impl<'a> SyscallObject 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>, logger: Rc>, loader_id: &'a Pubkey, - enforce_aligned_host_addrs: bool, } impl<'a> SyscallObject for SyscallLogPubkey<'a> { fn call( @@ -776,12 +709,7 @@ impl<'a> SyscallObject for SyscallLogPubkey<'a> { ) { question_mark!(self.compute_meter.consume(self.cost), result); let pubkey = question_mark!( - translate_type::( - memory_mapping, - pubkey_addr, - self.loader_id, - self.enforce_aligned_host_addrs, - ), + translate_type::(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> { - 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::, EbpfError>>()?; - let program_id = translate_type::( - memory_mapping, - program_id_addr, - loader_id, - enforce_aligned_host_addrs, - )?; + let program_id = translate_type::(memory_mapping, program_id_addr, loader_id)?; Ok((seeds, program_id)) } @@ -911,7 +827,6 @@ struct SyscallCreateProgramAddress<'a> { cost: u64, compute_meter: Rc>, loader_id: &'a Pubkey, - enforce_aligned_host_addrs: bool, allow_native_ids: bool, check_seed_length: bool, } @@ -937,7 +852,6 @@ impl<'a> SyscallObject 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 for SyscallCreateProgramAddress<'a> { } }; let address = question_mark!( - translate_slice_mut::( - memory_mapping, - address_addr, - 32, - self.loader_id, - self.enforce_aligned_host_addrs, - ), + translate_slice_mut::(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>, loader_id: &'a Pubkey, - enforce_aligned_host_addrs: bool, allow_native_ids: bool, check_seed_length: bool, } @@ -1005,7 +912,6 @@ impl<'a> SyscallObject 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 for SyscallTryFindProgramAddress<'a> { memory_mapping, bump_seed_addr, self.loader_id, - self.enforce_aligned_host_addrs, ), result ); @@ -1040,7 +945,6 @@ impl<'a> SyscallObject 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>, loader_id: &'a Pubkey, - enforce_aligned_host_addrs: bool, } impl<'a> SyscallObject for SyscallSha256<'a> { fn call( @@ -1086,20 +989,13 @@ impl<'a> SyscallObject 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 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( invoke_context .get_compute_meter() .consume(invoke_context.get_compute_budget().sysvar_base_cost + size_of::() as u64)?; - let var = translate_type_mut::( - memory_mapping, - var_addr, - loader_id, - invoke_context.is_feature_active(&enforce_aligned_host_addrs::id()), - )?; + let var = translate_type_mut::(memory_mapping, var_addr, loader_id)?; *var = process_instruction::get_sysvar::(*invoke_context, id) .map_err(SyscallError::InstructionError)?; @@ -1280,14 +1170,13 @@ impl<'a> SyscallObject 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 for SyscallKeccak256<'a> { val.as_ptr() as u64, val.len() as u64, self.loader_id, - true, ), result ); @@ -1348,11 +1236,11 @@ impl<'a> SyscallObject for SyscallMemcpy<'a> { question_mark!(self.compute_meter.consume(n / self.cost), result); let dst = question_mark!( - translate_slice_mut::(memory_mapping, dst_addr, n, self.loader_id, true), + translate_slice_mut::(memory_mapping, dst_addr, n, self.loader_id), result ); let src = question_mark!( - translate_slice::(memory_mapping, src_addr, n, self.loader_id, true), + translate_slice::(memory_mapping, src_addr, n, self.loader_id), result ); unsafe { @@ -1380,11 +1268,11 @@ impl<'a> SyscallObject for SyscallMemmove<'a> { ) { question_mark!(self.compute_meter.consume(n / self.cost), result); let dst = question_mark!( - translate_slice_mut::(memory_mapping, dst_addr, n, self.loader_id, true), + translate_slice_mut::(memory_mapping, dst_addr, n, self.loader_id), result ); let src = question_mark!( - translate_slice::(memory_mapping, src_addr, n, self.loader_id, true), + translate_slice::(memory_mapping, src_addr, n, self.loader_id), result ); unsafe { @@ -1412,15 +1300,15 @@ impl<'a> SyscallObject for SyscallMemcmp<'a> { ) { question_mark!(self.compute_meter.consume(n / self.cost), result); let s1 = question_mark!( - translate_slice::(memory_mapping, s1_addr, n, self.loader_id, true), + translate_slice::(memory_mapping, s1_addr, n, self.loader_id), result ); let s2 = question_mark!( - translate_slice::(memory_mapping, s2_addr, n, self.loader_id, true), + translate_slice::(memory_mapping, s2_addr, n, self.loader_id), result ); let cmp_result = question_mark!( - translate_type_mut::(memory_mapping, cmp_result_addr, self.loader_id, true), + translate_type_mut::(memory_mapping, cmp_result_addr, self.loader_id), result ); let mut i = 0; @@ -1457,7 +1345,7 @@ impl<'a> SyscallObject for SyscallMemset<'a> { ) { question_mark!(self.compute_meter.consume(n / self.cost), result); let s = question_mark!( - translate_slice_mut::(memory_mapping, s_addr, n, self.loader_id, true), + translate_slice_mut::(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 for SyscallSecp256k1Recover<'a> { hash_addr, keccak::HASH_BYTES as u64, self.loader_id, - true, ), result ); @@ -1504,7 +1391,6 @@ impl<'a> SyscallObject for SyscallSecp256k1Recover<'a> { signature_addr, SECP256K1_SIGNATURE_LENGTH as u64, self.loader_id, - true, ), result ); @@ -1514,7 +1400,6 @@ impl<'a> SyscallObject for SyscallSecp256k1Recover<'a> { result_addr, SECP256K1_PUBLIC_KEY_LENGTH as u64, self.loader_id, - true, ), result ); @@ -1585,14 +1470,13 @@ impl<'a> SyscallObject 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 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>; 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, EbpfError>; } @@ -1686,14 +1567,8 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> { &self, addr: u64, memory_mapping: &MemoryMapping, - enforce_aligned_host_addrs: bool, ) -> Result> { - let ix = translate_type::( - memory_mapping, - addr, - self.loader_id, - enforce_aligned_host_addrs, - )?; + let ix = translate_type::(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::( @@ -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, EbpfError> { 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::( 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::, EbpfError>>()?; @@ -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::( - memory_mapping, - *ptr, - self.loader_id, - enforce_aligned_host_addrs, - )? + translate_type_mut::(memory_mapping, *ptr, self.loader_id)? }; let owner = translate_type_mut::( 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, EbpfError> { 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::, EbpfError>>()?; @@ -1999,50 +1854,34 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> { &self, addr: u64, memory_mapping: &MemoryMapping, - enforce_aligned_host_addrs: bool, ) -> Result> { - let ix_c = translate_type::( - memory_mapping, - addr, - self.loader_id, - enforce_aligned_host_addrs, - )?; + let ix_c = translate_type::(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::( - memory_mapping, - ix_c.program_id_addr, - self.loader_id, - enforce_aligned_host_addrs, - )?; + let program_id = + translate_type::(memory_mapping, ix_c.program_id_addr, self.loader_id)?; let meta_cs = translate_slice::( memory_mapping, ix_c.accounts_addr, ix_c.accounts_len as u64, self.loader_id, - enforce_aligned_host_addrs, )?; let data = translate_slice::( 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::( - memory_mapping, - meta_c.pubkey_addr, - self.loader_id, - enforce_aligned_host_addrs, - )?; + let pubkey = + translate_type::(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, EbpfError> { 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::( 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::( - memory_mapping, - account_info.key_addr, - self.loader_id, - enforce_aligned_host_addrs, - ) + translate_type::(memory_mapping, account_info.key_addr, self.loader_id) }) .collect::, EbpfError>>()?; @@ -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::( 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, EbpfError> { if signers_seeds_len > 0 { let signers_seeds = translate_slice::( @@ -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::, EbpfError>>()?; @@ -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 for SyscallSetReturnData<'a> { invoke_context.set_return_data(None); } else { let return_data = question_mark!( - translate_slice::(memory_mapping, addr, len, self.loader_id, true), + translate_slice::(memory_mapping, addr, len, self.loader_id), result ); @@ -2688,7 +2502,6 @@ impl<'a> SyscallObject for SyscallGetReturnData<'a> { return_data_addr, length, self.loader_id, - true, ), result ); @@ -2701,7 +2514,6 @@ impl<'a> SyscallObject for SyscallGetReturnData<'a> { program_id_addr, 1, self.loader_id, - true, ), result ); @@ -2813,8 +2625,7 @@ mod tests { ) .unwrap(); let translated_pubkey = - translate_type::(&memory_mapping, 0x100000000, &bpf_loader::id(), true) - .unwrap(); + translate_type::(&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::(&memory_mapping, 0x100000000, &bpf_loader::id(), true) - .unwrap(); + translate_type::(&memory_mapping, 0x100000000, &bpf_loader::id()).unwrap(); assert_eq!(instruction, *translated_instruction); memory_mapping.resize_region::(1, 1).unwrap(); - assert!(translate_type::( - &memory_mapping, - 0x100000000, - &bpf_loader::id(), - true - ) - .is_err()); + assert!( + translate_type::(&memory_mapping, 0x100000000, &bpf_loader::id(),) + .is_err() + ); } #[test] @@ -2874,14 +2681,9 @@ mod tests { &config, ) .unwrap(); - let translated_data = translate_slice::( - &memory_mapping, - data.as_ptr() as u64, - 0, - &bpf_loader::id(), - true, - ) - .unwrap(); + let translated_data = + translate_slice::(&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::( - &memory_mapping, - 0x100000000, - u64::MAX, - &bpf_loader::id(), - true, - ) - .is_err()); + assert!( + translate_slice::(&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> = 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> = 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::( @@ -3211,7 +3000,6 @@ mod tests { compute_meter, logger, loader_id: &bpf_loader::id(), - enforce_aligned_host_addrs: true, }; let mut result: Result> = 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::( @@ -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> = 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, }; diff --git a/runtime/src/message_processor.rs b/runtime/src/message_processor.rs index 1357aad11..a2c945975 100644 --- a/runtime/src/message_processor.rs +++ b/runtime/src/message_processor.rs @@ -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>, - 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()), )?; diff --git a/sdk/src/feature_set.rs b/sdk/src/feature_set.rs index 4f6d82f8b..1f8272e06 100644 --- a/sdk/src/feature_set.rs +++ b/sdk/src/feature_set.rs @@ -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"),