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

cleanup feature; do_support_realloc (#25882)

This commit is contained in:
Jack May 2022-06-10 15:33:19 -07:00 committed by GitHub
parent 0fffccb4a3
commit 9fb0e76dc2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 41 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -28,7 +28,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post,
&mut ExecuteDetailsTimings::default(),
false,
true,
),
Ok(())
);
@ -42,7 +41,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post,
&mut ExecuteDetailsTimings::default(),
false,
true,
)
.unwrap();
});
@ -67,7 +65,6 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
&post,
&mut ExecuteDetailsTimings::default(),
false,
true,
)
.unwrap();
});

29
program-runtime/src/invoke_context.rs
View File

@ -16,7 +16,7 @@ use {
account::{AccountSharedData, ReadableAccount},
bpf_loader_upgradeable::{self, UpgradeableLoaderState},
feature_set::{
cap_accounts_data_len, do_support_realloc, neon_evm_compute_budget,
cap_accounts_data_len, neon_evm_compute_budget,
record_instruction_in_transaction_context_push,
reject_empty_instruction_without_program, requestable_heap_size, tx_wide_compute_cap,
FeatureSet,
@ -494,7 +494,6 @@ impl<'a> InvokeContext<'a> {
instruction_accounts: &[InstructionAccount],
program_indices: &[usize],
) -> Result<(), InstructionError> {
let do_support_realloc = self.feature_set.is_active(&do_support_realloc::id());
let cap_accounts_data_len = self.feature_set.is_active(&cap_accounts_data_len::id());
let instruction_context = self
.transaction_context
@ -544,7 +543,6 @@ impl<'a> InvokeContext<'a> {
&account,
&mut self.timings,
true,
do_support_realloc,
)
.map_err(|err| {
ic_logger_msg!(
@ -589,7 +587,6 @@ impl<'a> InvokeContext<'a> {
instruction_accounts: &[InstructionAccount],
before_instruction_context_push: bool,
) -> Result<(), InstructionError> {
let do_support_realloc = self.feature_set.is_active(&do_support_realloc::id());
let cap_accounts_data_len = self.feature_set.is_active(&cap_accounts_data_len::id());
let transaction_context = &self.transaction_context;
let instruction_context = transaction_context.get_current_instruction_context()?;
@ -638,7 +635,6 @@ impl<'a> InvokeContext<'a> {
&account,
&mut self.timings,
false,
do_support_realloc,
)
.map_err(|err| {
ic_logger_msg!(
@ -710,29 +706,6 @@ impl<'a> InvokeContext<'a> {
&mut ExecuteTimings::default(),
)?;
// Verify the called program has not misbehaved
let do_support_realloc = self.feature_set.is_active(&do_support_realloc::id());
for (account_index, prev_size) in prev_account_sizes.into_iter() {
if !do_support_realloc
&& prev_size
!= self
.transaction_context
.get_account_at_index(account_index)?
.borrow()
.data()
.len()
&& prev_size != 0
{
// Only support for `CreateAccount` at this time.
// Need a way to limit total realloc size across multiple CPI calls
ic_msg!(
self,
"Inner instructions do not support realloc, only SystemProgram::CreateAccount",
);
return Err(InstructionError::InvalidRealloc);
}
}
Ok(())
}

35
program-runtime/src/pre_account.rs
View File

@ -6,7 +6,6 @@ use {
pubkey::Pubkey,
rent::Rent,
system_instruction::MAX_PERMITTED_DATA_LENGTH,
system_program,
},
std::fmt::Debug,
};
@ -36,7 +35,6 @@ impl PreAccount {
post: &AccountSharedData,
timings: &mut ExecuteDetailsTimings,
outermost_call: bool,
do_support_realloc: bool,
) -> Result<(), InstructionError> {
let pre = &self.account;
@ -72,30 +70,16 @@ impl PreAccount {
}
}
let data_len_changed = if do_support_realloc {
// Account data size cannot exceed a maxumum length
if post.data().len() > MAX_PERMITTED_DATA_LENGTH as usize {
return Err(InstructionError::InvalidRealloc);
}
// Account data size cannot exceed a maxumum length
if post.data().len() > MAX_PERMITTED_DATA_LENGTH as usize {
return Err(InstructionError::InvalidRealloc);
}
// The owner of the account can change the size of the data
let data_len_changed = pre.data().len() != post.data().len();
if data_len_changed && program_id != pre.owner() {
return Err(InstructionError::AccountDataSizeChanged);
}
data_len_changed
} else {
// Only the system program can change the size of the data
// and only if the system program owns the account
let data_len_changed = pre.data().len() != post.data().len();
if data_len_changed
&& (!system_program::check_id(program_id) // line coverage used to get branch coverage
|| !system_program::check_id(pre.owner()))
{
return Err(InstructionError::AccountDataSizeChanged);
}
data_len_changed
};
// The owner of the account can change the size of the data
let data_len_changed = pre.data().len() != post.data().len();
if data_len_changed && program_id != pre.owner() {
return Err(InstructionError::AccountDataSizeChanged);
}
// Only the owner may change account data
// and if the account is writable
@ -283,7 +267,6 @@ mod tests {
&self.post,
&mut ExecuteDetailsTimings::default(),
false,
true,
)
}
}

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

@ -313,7 +313,6 @@ fn run_program(name: &str) -> u64 {
.unwrap(),
parameter_bytes.as_slice(),
&account_lengths,
true,
)
.unwrap();
}

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

@ -43,9 +43,8 @@ use {
feature_set::{
cap_accounts_data_len, disable_bpf_deprecated_load_instructions,
disable_bpf_unresolved_symbols_at_runtime, disable_deploy_of_alloc_free_syscall,
disable_deprecated_loader, do_support_realloc,
error_on_syscall_bpf_function_hash_collisions, reduce_required_deploy_balance,
reject_callx_r10, requestable_heap_size,
disable_deprecated_loader, error_on_syscall_bpf_function_hash_collisions,
reduce_required_deploy_balance, reject_callx_r10, requestable_heap_size,
},
instruction::{AccountMeta, InstructionError},
loader_instruction::LoaderInstruction,
@ -1277,9 +1276,6 @@ impl Executor for BpfExecutor {
.get_current_instruction_context()?,
parameter_bytes.as_slice(),
invoke_context.get_orig_account_lengths()?,
invoke_context
.feature_set
.is_active(&do_support_realloc::id()),
)
});
deserialize_time.stop();

28
programs/bpf_loader/src/serialization.rs
View File

@ -46,7 +46,6 @@ pub fn deserialize_parameters(
instruction_context: &InstructionContext,
buffer: &[u8],
account_lengths: &[usize],
do_support_realloc: bool,
) -> Result<(), InstructionError> {
let is_loader_deprecated = *instruction_context
.try_borrow_program_account(transaction_context)?
@ -65,7 +64,6 @@ pub fn deserialize_parameters(
instruction_context,
buffer,
account_lengths,
do_support_realloc,
)
}
}
@ -291,7 +289,6 @@ pub fn deserialize_parameters_aligned(
instruction_context: &InstructionContext,
buffer: &[u8],
account_lengths: &[usize],
do_support_realloc: bool,
) -> Result<(), InstructionError> {
let mut start = size_of::<u64>(); // number of accounts
for (index_in_instruction, pre_len) in (instruction_context.get_number_of_program_accounts()
@ -328,22 +325,13 @@ pub fn deserialize_parameters_aligned(
.ok_or(InstructionError::InvalidArgument)?,
) as usize;
start += size_of::<u64>(); // data length
let data_end = if do_support_realloc {
if post_len.saturating_sub(*pre_len) > MAX_PERMITTED_DATA_INCREASE
|| post_len > MAX_PERMITTED_DATA_LENGTH as usize
{
return Err(InstructionError::InvalidRealloc);
}
start + post_len
} else {
let mut data_end = start + *pre_len;
if post_len != *pre_len
&& (post_len.saturating_sub(*pre_len)) <= MAX_PERMITTED_DATA_INCREASE
{
data_end = start + post_len;
}
data_end
};
if post_len.saturating_sub(*pre_len) > MAX_PERMITTED_DATA_INCREASE
|| post_len > MAX_PERMITTED_DATA_LENGTH as usize
{
return Err(InstructionError::InvalidRealloc);
}
let data_end = start + post_len;
let _ = borrowed_account.set_data(
buffer
.get(start..data_end)
@ -542,7 +530,6 @@ mod tests {
instruction_context,
serialized.as_slice(),
&account_lengths,
true,
)
.unwrap();
for (index_in_transaction, (_key, original_account)) in original_accounts.iter().enumerate()
@ -608,7 +595,6 @@ mod tests {
instruction_context,
serialized.as_slice(),
&account_lengths,
true,
)
.unwrap();
for (index_in_transaction, (_key, original_account)) in original_accounts.iter().enumerate()

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

@ -23,11 +23,11 @@ use {
entrypoint::{BPF_ALIGN_OF_U128, MAX_PERMITTED_DATA_INCREASE, SUCCESS},
feature_set::{
blake3_syscall_enabled, check_physical_overlapping, check_slice_translation_size,
curve25519_syscall_enabled, disable_fees_sysvar, do_support_realloc,
executables_incur_cpi_data_cost, fixed_memcpy_nonoverlapping_check,
libsecp256k1_0_5_upgrade_enabled, limit_secp256k1_recovery_id,
prevent_calling_precompiles_as_programs, quick_bail_on_panic, syscall_saturated_math,
update_syscall_base_costs, zk_token_sdk_enabled,
curve25519_syscall_enabled, disable_fees_sysvar, executables_incur_cpi_data_cost,
fixed_memcpy_nonoverlapping_check, libsecp256k1_0_5_upgrade_enabled,
limit_secp256k1_recovery_id, prevent_calling_precompiles_as_programs,
quick_bail_on_panic, syscall_saturated_math, update_syscall_base_costs,
zk_token_sdk_enabled,
},
hash::{Hasher, HASH_BYTES},
instruction::{
@ -3092,9 +3092,6 @@ fn call<'a, 'b: 'a>(
invoke_context
.get_compute_meter()
.consume(invoke_context.get_compute_budget().invoke_units)?;
let do_support_realloc = invoke_context
.feature_set
.is_active(&do_support_realloc::id());
// Translate and verify caller's data
let instruction =
@ -3150,45 +3147,18 @@ fn call<'a, 'b: 'a>(
*caller_account.owner = *callee_account.owner();
let new_len = callee_account.data().len();
if caller_account.data.len() != new_len {
if !do_support_realloc && !caller_account.data.is_empty() {
// Only support for `CreateAccount` at this time.
// Need a way to limit total realloc size across multiple CPI calls
ic_msg!(
invoke_context,
"Inner instructions do not support realloc, only SystemProgram::CreateAccount",
);
return Err(
SyscallError::InstructionError(InstructionError::InvalidRealloc).into(),
);
}
let data_overflow = if do_support_realloc {
if invoke_context
.feature_set
.is_active(&syscall_saturated_math::id())
{
new_len
> caller_account
.original_data_len
.saturating_add(MAX_PERMITTED_DATA_INCREASE)
} else {
#[allow(clippy::integer_arithmetic)]
{
new_len > caller_account.original_data_len + MAX_PERMITTED_DATA_INCREASE
}
}
} else if invoke_context
let data_overflow = if invoke_context
.feature_set
.is_active(&syscall_saturated_math::id())
{
new_len
> caller_account
.data
.len()
.original_data_len
.saturating_add(MAX_PERMITTED_DATA_INCREASE)
} else {
#[allow(clippy::integer_arithmetic)]
{
new_len > caller_account.data.len() + MAX_PERMITTED_DATA_INCREASE
new_len > caller_account.original_data_len + MAX_PERMITTED_DATA_INCREASE
}
};
if data_overflow {

39
runtime/src/account_rent_state.rs
View File

@ -31,18 +31,10 @@ impl RentState {
}
}
pub(crate) fn transition_allowed_from(
&self,
pre_rent_state: &RentState,
do_support_realloc: bool,
) -> bool {
pub(crate) fn transition_allowed_from(&self, pre_rent_state: &RentState) -> bool {
if let Self::RentPaying(post_data_size) = self {
if let Self::RentPaying(pre_data_size) = pre_rent_state {
if do_support_realloc {
post_data_size == pre_data_size // Cannot be RentPaying if resized
} else {
true // RentPaying can continue to be RentPaying
}
post_data_size == pre_data_size // Cannot be RentPaying if resized
} else {
false // Only RentPaying can continue to be RentPaying
}
@ -72,7 +64,6 @@ pub(crate) fn check_rent_state(
post_rent_state: Option<&RentState>,
transaction_context: &TransactionContext,
index: usize,
do_support_realloc: bool,
include_account_index_in_err: bool,
) -> Result<()> {
if let Some((pre_rent_state, post_rent_state)) = pre_rent_state.zip(post_rent_state) {
@ -87,7 +78,6 @@ pub(crate) fn check_rent_state(
.get_account_at_index(index)
.expect(expect_msg)
.borrow(),
do_support_realloc,
include_account_index_in_err.then(|| index),
)?;
}
@ -99,12 +89,11 @@ pub(crate) fn check_rent_state_with_account(
post_rent_state: &RentState,
address: &Pubkey,
account_state: &AccountSharedData,
do_support_realloc: bool,
account_index: Option<usize>,
) -> Result<()> {
submit_rent_state_metrics(pre_rent_state, post_rent_state);
if !solana_sdk::incinerator::check_id(address)
&& !post_rent_state.transition_allowed_from(pre_rent_state, do_support_realloc)
&& !post_rent_state.transition_allowed_from(pre_rent_state)
{
debug!(
"Account {} not rent exempt, state {:?}",
@ -174,20 +163,20 @@ mod tests {
#[test]
fn test_transition_allowed_from() {
let post_rent_state = RentState::Uninitialized;
assert!(post_rent_state.transition_allowed_from(&RentState::Uninitialized, true));
assert!(post_rent_state.transition_allowed_from(&RentState::RentExempt, true));
assert!(post_rent_state.transition_allowed_from(&RentState::RentPaying(0), true));
assert!(post_rent_state.transition_allowed_from(&RentState::Uninitialized));
assert!(post_rent_state.transition_allowed_from(&RentState::RentExempt));
assert!(post_rent_state.transition_allowed_from(&RentState::RentPaying(0)));
let post_rent_state = RentState::RentExempt;
assert!(post_rent_state.transition_allowed_from(&RentState::Uninitialized, true));
assert!(post_rent_state.transition_allowed_from(&RentState::RentExempt, true));
assert!(post_rent_state.transition_allowed_from(&RentState::RentPaying(0), true));
assert!(post_rent_state.transition_allowed_from(&RentState::Uninitialized));
assert!(post_rent_state.transition_allowed_from(&RentState::RentExempt));
assert!(post_rent_state.transition_allowed_from(&RentState::RentPaying(0)));
let post_rent_state = RentState::RentPaying(2);
assert!(!post_rent_state.transition_allowed_from(&RentState::Uninitialized, true));
assert!(!post_rent_state.transition_allowed_from(&RentState::RentExempt, true));
assert!(!post_rent_state.transition_allowed_from(&RentState::RentPaying(3), true));
assert!(!post_rent_state.transition_allowed_from(&RentState::RentPaying(1), true));
assert!(post_rent_state.transition_allowed_from(&RentState::RentPaying(2), true));
assert!(!post_rent_state.transition_allowed_from(&RentState::Uninitialized));
assert!(!post_rent_state.transition_allowed_from(&RentState::RentExempt));
assert!(!post_rent_state.transition_allowed_from(&RentState::RentPaying(3)));
assert!(!post_rent_state.transition_allowed_from(&RentState::RentPaying(1)));
assert!(post_rent_state.transition_allowed_from(&RentState::RentPaying(2)));
}
}

1
runtime/src/accounts.rs
View File

@ -432,7 +432,6 @@ impl Accounts {
&payer_post_rent_state,
payer_address,
payer_account,
feature_set.is_active(&feature_set::do_support_realloc::id()),
feature_set
.is_active(&feature_set::include_account_index_in_rent_error::ID)
.then(|| payer_index),

4
runtime/src/bank/transaction_account_state_info.rs
View File

@ -58,9 +58,6 @@ impl Bank {
let require_rent_exempt_accounts = self
.feature_set
.is_active(&feature_set::require_rent_exempt_accounts::id());
let do_support_realloc = self
.feature_set
.is_active(&feature_set::do_support_realloc::id());
let include_account_index_in_err = self
.feature_set
.is_active(&feature_set::include_account_index_in_rent_error::id());
@ -72,7 +69,6 @@ impl Bank {
post_state_info.rent_state.as_ref(),
transaction_context,
i,
do_support_realloc,
include_account_index_in_err,
) {
// Feature gate only wraps the actual error return so that the metrics and debug