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

Refactor: Remove Rc from PreAccount and InvokeContext::get_account() (#21882) 

* Removes Rc and RefCell from PreAccount

* Splits get_account() into find_index_of_account() and get_account_at_index()
in order to remove Rc from return type.
This commit is contained in:
Alexander Meißner 2021-12-14 15:44:31 +01:00 committed by GitHub
parent c92c09a8be
commit 4adc8b133f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 74 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -17,7 +17,7 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
let non_owner = pubkey::new_rand();
let pre = PreAccount::new(
&pubkey::new_rand(),
&AccountSharedData::new(0, BUFSIZE, &owner),
AccountSharedData::new(0, BUFSIZE, &owner),
);
let post = AccountSharedData::new(0, BUFSIZE, &owner);
assert_eq!(
@ -57,7 +57,7 @@ fn bench_verify_account_changes_data(bencher: &mut Bencher) {
let pre = PreAccount::new(
&pubkey::new_rand(),
&AccountSharedData::new(0, BUFSIZE, &owner),
AccountSharedData::new(0, BUFSIZE, &owner),
);
bencher.iter(|| {
pre.verify(

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

@ -257,9 +257,9 @@ impl<'a> InvokeContext<'a> {
self.pre_accounts = Vec::with_capacity(instruction.accounts.len());
let mut work = |_unique_index: usize, account_index: usize| {
if account_index < self.accounts.len() {
let account = self.accounts[account_index].1.borrow();
let account = self.accounts[account_index].1.borrow().clone();
self.pre_accounts
.push(PreAccount::new(&self.accounts[account_index].0, &account));
.push(PreAccount::new(&self.accounts[account_index].0, account));
return Ok(());
}
Err(InstructionError::MissingAccount)
@ -461,7 +461,7 @@ impl<'a> InvokeContext<'a> {
.checked_add(u128::from(account.lamports()))
.ok_or(InstructionError::UnbalancedInstruction)?;
if is_writable && !pre_account.executable() {
pre_account.update(&account);
pre_account.update(account.clone());
}
return Ok(());
}
@ -489,12 +489,12 @@ impl<'a> InvokeContext<'a> {
let mut account_indices = Vec::with_capacity(message.account_keys.len());
let mut prev_account_sizes = Vec::with_capacity(message.account_keys.len());
for account_key in message.account_keys.iter() {
let (account_index, account) = self
.get_account(account_key)
let account_index = self
.find_index_of_account(account_key)
.ok_or(InstructionError::MissingAccount)?;
let account_length = account.borrow().data().len();
let account_length = self.accounts[account_index].1.borrow().data().len();
account_indices.push(account_index);
prev_account_sizes.push((account, account_length));
prev_account_sizes.push((account_index, account_length));
}
if let Some(instruction_recorder) = &self.instruction_recorder {
@ -510,8 +510,10 @@ impl<'a> InvokeContext<'a> {
// Verify the called program has not misbehaved
let do_support_realloc = self.feature_set.is_active(&do_support_realloc::id());
for (account, prev_size) in prev_account_sizes.iter() {
if !do_support_realloc && *prev_size != account.borrow().data().len() && *prev_size != 0
for (account_index, prev_size) in prev_account_sizes.into_iter() {
if !do_support_realloc
&& prev_size != self.accounts[account_index].1.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
@ -595,26 +597,27 @@ impl<'a> InvokeContext<'a> {
// Find and validate executables / program accounts
let callee_program_id = instruction.program_id;
let (program_account_index, program_account) = callee_keyed_accounts
let program_account_index = callee_keyed_accounts
.iter()
.find(|keyed_account| &callee_program_id == keyed_account.unsigned_key())
.and_then(|_keyed_account| self.get_account(&callee_program_id))
.and_then(|_keyed_account| self.find_index_of_account(&callee_program_id))
.ok_or_else(|| {
ic_msg!(self, "Unknown program {}", callee_program_id);
InstructionError::MissingAccount
})?;
if !program_account.borrow().executable() {
let program_account = self.accounts[program_account_index].1.borrow();
if !program_account.executable() {
ic_msg!(self, "Account {} is not executable", callee_program_id);
return Err(InstructionError::AccountNotExecutable);
}
let mut program_indices = vec![];
if program_account.borrow().owner() == &bpf_loader_upgradeable::id() {
if program_account.owner() == &bpf_loader_upgradeable::id() {
if let UpgradeableLoaderState::Program {
programdata_address,
} = program_account.borrow().state()?
} = program_account.state()?
{
if let Some((programdata_account_index, _programdata_account)) =
self.get_account(&programdata_address)
if let Some(programdata_account_index) =
self.find_index_of_account(&programdata_address)
{
program_indices.push(programdata_account_index);
} else {
@ -797,16 +800,21 @@ impl<'a> InvokeContext<'a> {
self.executors.borrow().get(pubkey)
}
/// Find an account_index and account by its key
pub fn get_account(&self, pubkey: &Pubkey) -> Option<(usize, Rc<RefCell<AccountSharedData>>)> {
for (index, (key, account)) in self.accounts.iter().enumerate().rev() {
/// Finds an account_index by its key
pub fn find_index_of_account(&self, pubkey: &Pubkey) -> Option<usize> {
for (index, (key, _account)) in self.accounts.iter().enumerate().rev() {
if key == pubkey {
return Some((index, account.clone()));
return Some(index);
}
}
None
}
/// Returns an account by its account_index
pub fn get_account_at_index(&self, account_index: usize) -> &RefCell<AccountSharedData> {
&self.accounts[account_index].1
}
/// Get this invocation's compute budget
pub fn get_compute_budget(&self) -> &ComputeBudget {
&self.current_compute_budget

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

@ -8,11 +8,7 @@ use {
system_instruction::MAX_PERMITTED_DATA_LENGTH,
system_program,
},
std::{
cell::{Ref, RefCell},
fmt::Debug,
rc::Rc,
},
std::fmt::Debug,
};
// The relevant state of an account before an Instruction executes, used
@ -20,14 +16,14 @@ use {
#[derive(Clone, Debug, Default)]
pub struct PreAccount {
key: Pubkey,
account: Rc<RefCell<AccountSharedData>>,
account: AccountSharedData,
changed: bool,
}
impl PreAccount {
pub fn new(key: &Pubkey, account: &AccountSharedData) -> Self {
pub fn new(key: &Pubkey, account: AccountSharedData) -> Self {
Self {
key: *key,
account: Rc::new(RefCell::new(account.clone())),
account,
changed: false,
}
}
@ -42,7 +38,7 @@ impl PreAccount {
outermost_call: bool,
do_support_realloc: bool,
) -> Result<(), InstructionError> {
let pre = self.account.borrow();
let pre = &self.account;
// Only the owner of the account may change owner and
// only if the account is writable and
@ -157,11 +153,10 @@ impl PreAccount {
Ok(())
}
pub fn update(&mut self, account: &AccountSharedData) {
let mut pre = self.account.borrow_mut();
let rent_epoch = pre.rent_epoch();
*pre = account.clone();
pre.set_rent_epoch(rent_epoch);
pub fn update(&mut self, account: AccountSharedData) {
let rent_epoch = self.account.rent_epoch();
self.account = account;
self.account.set_rent_epoch(rent_epoch);
self.changed = true;
}
@ -170,16 +165,16 @@ impl PreAccount {
&self.key
}
pub fn data(&self) -> Ref<[u8]> {
Ref::map(self.account.borrow(), |account| account.data())
pub fn data(&self) -> &[u8] {
self.account.data()
}
pub fn lamports(&self) -> u64 {
self.account.borrow().lamports()
self.account.lamports()
}
pub fn executable(&self) -> bool {
self.account.borrow().executable()
self.account.executable()
}
pub fn is_zeroed(buf: &[u8]) -> bool {
@ -236,10 +231,9 @@ mod tests {
is_writable: true,
pre: PreAccount::new(
&solana_sdk::pubkey::new_rand(),
&AccountSharedData::from(Account {
AccountSharedData::from(Account {
owner: *owner,
lamports: std::u64::MAX,
data: vec![],
..Account::default()
}),
),
@ -255,12 +249,12 @@ mod tests {
self
}
pub fn executable(mut self, pre: bool, post: bool) -> Self {
self.pre.account.borrow_mut().set_executable(pre);
self.pre.account.set_executable(pre);
self.post.set_executable(post);
self
}
pub fn lamports(mut self, pre: u64, post: u64) -> Self {
self.pre.account.borrow_mut().set_lamports(pre);
self.pre.account.set_lamports(pre);
self.post.set_lamports(post);
self
}
@ -269,12 +263,12 @@ mod tests {
self
}
pub fn data(mut self, pre: Vec<u8>, post: Vec<u8>) -> Self {
self.pre.account.borrow_mut().set_data(pre);
self.pre.account.set_data(pre);
self.post.set_data(post);
self
}
pub fn rent_epoch(mut self, pre: u64, post: u64) -> Self {
self.pre.account.borrow_mut().set_rent_epoch(pre);
self.pre.account.set_rent_epoch(pre);
self.post.set_rent_epoch(post);
self
}

24
program-test/src/lib.rs
View File

@ -261,8 +261,8 @@ impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
let mut account_indices = Vec::with_capacity(message.account_keys.len());
let mut accounts = Vec::with_capacity(message.account_keys.len());
for (i, account_key) in message.account_keys.iter().enumerate() {
let ((account_index, account), account_info) = invoke_context
.get_account(account_key)
let (account_index, account_info) = invoke_context
.find_index_of_account(account_key)
.zip(
account_infos
.iter()
@ -271,7 +271,9 @@ impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
.ok_or(InstructionError::MissingAccount)
.unwrap();
{
let mut account = account.borrow_mut();
let mut account = invoke_context
.get_account_at_index(account_index)
.borrow_mut();
account.copy_into_owner_from_slice(account_info.owner.as_ref());
account.set_data_from_slice(&account_info.try_borrow_data().unwrap());
account.set_lamports(account_info.lamports());
@ -284,10 +286,9 @@ impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
None
};
account_indices.push(account_index);
accounts.push((account, account_info));
accounts.push((account_index, account_info));
}
let (program_account_index, _program_account) =
invoke_context.get_account(&program_id).unwrap();
let program_account_index = invoke_context.find_index_of_account(&program_id).unwrap();
let program_indices = vec![program_account_index];
// Check Signers
@ -329,19 +330,20 @@ impl solana_sdk::program_stubs::SyscallStubs for SyscallStubs {
.map_err(|err| ProgramError::try_from(err).unwrap_or_else(|err| panic!("{}", err)))?;
// Copy writeable account modifications back into the caller's AccountInfos
for (account, account_info) in accounts.iter() {
for (account_index, account_info) in accounts.into_iter() {
if let Some(account_info) = account_info {
**account_info.try_borrow_mut_lamports().unwrap() = account.borrow().lamports();
let mut data = account_info.try_borrow_mut_data()?;
let account = invoke_context.get_account_at_index(account_index);
let account_borrow = account.borrow();
**account_info.try_borrow_mut_lamports().unwrap() = account_borrow.lamports();
let mut data = account_info.try_borrow_mut_data()?;
let new_data = account_borrow.data();
if account_info.owner != account.borrow().owner() {
if account_info.owner != account_borrow.owner() {
// TODO Figure out a better way to allow the System Program to set the account owner
#[allow(clippy::transmute_ptr_to_ptr)]
#[allow(mutable_transmutes)]
let account_info_mut =
unsafe { transmute::<&Pubkey, &mut Pubkey>(account_info.owner) };
*account_info_mut = *account.borrow().owner();
*account_info_mut = *account_borrow.owner();
}
// TODO: Figure out how to allow the System Program to resize the account data
assert!(

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

@ -17,7 +17,7 @@ use {
vm::{EbpfVm, SyscallObject, SyscallRegistry},
},
solana_sdk::{
account::{AccountSharedData, ReadableAccount, WritableAccount},
account::{ReadableAccount, WritableAccount},
account_info::AccountInfo,
blake3, bpf_loader, bpf_loader_deprecated, bpf_loader_upgradeable,
clock::Clock,
@ -1667,10 +1667,7 @@ struct CallerAccount<'a> {
executable: bool,
rent_epoch: u64,
}
type TranslatedAccounts<'a> = (
Vec<usize>,
Vec<(Rc<RefCell<AccountSharedData>>, Option<CallerAccount<'a>>)>,
);
type TranslatedAccounts<'a> = (Vec<usize>, Vec<(usize, Option<CallerAccount<'a>>)>);
/// Implemented by language specific data structure translators
trait SyscallInvokeSigned<'a, 'b> {
@ -2210,13 +2207,14 @@ where
let mut account_indices = Vec::with_capacity(message.account_keys.len());
let mut accounts = Vec::with_capacity(message.account_keys.len());
for (i, account_key) in message.account_keys.iter().enumerate() {
if let Some((account_index, account)) = invoke_context.get_account(account_key) {
if let Some(account_index) = invoke_context.find_index_of_account(account_key) {
let account = invoke_context.get_account_at_index(account_index);
if i == message.instructions[0].program_id_index as usize
|| account.borrow().executable()
{
// Use the known account
account_indices.push(account_index);
accounts.push((account, None));
accounts.push((account_index, None));
continue;
} else if let Some(caller_account_index) =
account_info_keys.iter().position(|key| *key == account_key)
@ -2265,7 +2263,7 @@ where
None
};
account_indices.push(account_index);
accounts.push((account, caller_account));
accounts.push((account_index, caller_account));
continue;
}
}
@ -2400,9 +2398,11 @@ fn call<'a, 'b: 'a>(
.map_err(SyscallError::InstructionError)?;
// Copy results back to caller
for (callee_account, caller_account) in accounts.iter_mut() {
for (callee_account_index, caller_account) in accounts.iter_mut() {
if let Some(caller_account) = caller_account {
let callee_account = callee_account.borrow();
let callee_account = invoke_context
.get_account_at_index(*callee_account_index)
.borrow();
*caller_account.lamports = callee_account.lamports();
*caller_account.owner = *callee_account.owner();
let new_len = callee_account.data().len();
@ -2672,7 +2672,9 @@ mod tests {
solana_rbpf::{
ebpf::HOST_ALIGN, memory_region::MemoryRegion, user_error::UserError, vm::Config,
},
solana_sdk::{bpf_loader, fee_calculator::FeeCalculator, hash::hashv},
solana_sdk::{
account::AccountSharedData, bpf_loader, fee_calculator::FeeCalculator, hash::hashv,
},
std::str::FromStr,
};