Pacify clippy
This commit is contained in:
parent
fd3b71a2c6
commit
5df36aec7d
|
@ -19,7 +19,7 @@ use solana_ledger::{
|
|||
use solana_measure::measure::Measure;
|
||||
use solana_perf::packet::to_packets_chunked;
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender, bank::Bank, bank_forks::BankForks,
|
||||
accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
|
||||
};
|
||||
use solana_sdk::{
|
||||
hash::Hash,
|
||||
|
@ -326,7 +326,7 @@ fn main() {
|
|||
poh_recorder.lock().unwrap().set_bank(&bank);
|
||||
assert!(poh_recorder.lock().unwrap().bank().is_some());
|
||||
if bank.slot() > 32 {
|
||||
bank_forks.set_root(root, &ABSRequestSender::default(), None);
|
||||
bank_forks.set_root(root, &AbsRequestSender::default(), None);
|
||||
root += 1;
|
||||
}
|
||||
debug!(
|
||||
|
|
|
@ -10,7 +10,7 @@ use bincode::serialize;
|
|||
use bip39::{Language, Mnemonic, MnemonicType, Seed};
|
||||
use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
|
||||
use log::*;
|
||||
use solana_bpf_loader_program::{bpf_verifier, BPFError, ThisInstructionMeter};
|
||||
use solana_bpf_loader_program::{bpf_verifier, BpfError, ThisInstructionMeter};
|
||||
use solana_clap_utils::{self, input_parsers::*, input_validators::*, keypair::*};
|
||||
use solana_cli_output::{
|
||||
display::new_spinner_progress_bar, CliProgramAccountType, CliProgramAuthority,
|
||||
|
@ -1372,7 +1372,7 @@ fn read_and_verify_elf(program_location: &str) -> Result<Vec<u8>, Box<dyn std::e
|
|||
.map_err(|err| format!("Unable to read program file: {}", err))?;
|
||||
|
||||
// Verify the program
|
||||
Executable::<BPFError, ThisInstructionMeter>::from_elf(
|
||||
Executable::<BpfError, ThisInstructionMeter>::from_elf(
|
||||
&program_data,
|
||||
Some(|x| bpf_verifier::check(x)),
|
||||
Config::default(),
|
||||
|
|
|
@ -592,7 +592,7 @@ impl BankingStage {
|
|||
processed_transactions_indexes,
|
||||
);
|
||||
}
|
||||
Err(e) => panic!(format!("Poh recorder returned unexpected error: {:?}", e)),
|
||||
Err(e) => panic!("Poh recorder returned unexpected error: {:?}", e),
|
||||
}
|
||||
poh_record.stop();
|
||||
}
|
||||
|
|
|
@ -402,7 +402,7 @@ pub fn broadcast_shreds(
|
|||
match send_mmsg(s, &packets[sent..]) {
|
||||
Ok(n) => sent += n,
|
||||
Err(e) => {
|
||||
return Err(Error::IO(e));
|
||||
return Err(Error::Io(e));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1507,7 +1507,7 @@ impl ClusterInfo {
|
|||
1
|
||||
);
|
||||
error!("retransmit result {:?}", e);
|
||||
return Err(Error::IO(e));
|
||||
return Err(Error::Io(e));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -249,7 +249,7 @@ mod tests {
|
|||
use super::*;
|
||||
use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender,
|
||||
accounts_background_service::AbsRequestSender,
|
||||
bank_forks::BankForks,
|
||||
genesis_utils::{create_genesis_config_with_vote_accounts, ValidatorVoteKeypairs},
|
||||
};
|
||||
|
@ -534,7 +534,7 @@ mod tests {
|
|||
&working_bank,
|
||||
);
|
||||
for x in 0..root {
|
||||
bank_forks.set_root(x, &ABSRequestSender::default(), None);
|
||||
bank_forks.set_root(x, &AbsRequestSender::default(), None);
|
||||
}
|
||||
|
||||
// Add an additional bank/vote that will root slot 2
|
||||
|
@ -573,7 +573,7 @@ mod tests {
|
|||
.highest_confirmed_root();
|
||||
bank_forks.set_root(
|
||||
root,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
Some(highest_confirmed_root),
|
||||
);
|
||||
let highest_confirmed_root_bank = bank_forks.get(highest_confirmed_root);
|
||||
|
@ -642,7 +642,7 @@ mod tests {
|
|||
.highest_confirmed_root();
|
||||
bank_forks.set_root(
|
||||
root,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
Some(highest_confirmed_root),
|
||||
);
|
||||
let highest_confirmed_root_bank = bank_forks.get(highest_confirmed_root);
|
||||
|
|
|
@ -845,10 +845,9 @@ impl Tower {
|
|||
assert!(
|
||||
self.last_vote == Vote::default() && self.lockouts.votes.is_empty()
|
||||
|| self.last_vote != Vote::default() && !self.lockouts.votes.is_empty(),
|
||||
format!(
|
||||
"last vote: {:?} lockouts.votes: {:?}",
|
||||
self.last_vote, self.lockouts.votes
|
||||
)
|
||||
"last vote: {:?} lockouts.votes: {:?}",
|
||||
self.last_vote,
|
||||
self.lockouts.votes
|
||||
);
|
||||
|
||||
if let Some(last_voted_slot) = self.last_voted_slot() {
|
||||
|
@ -1131,7 +1130,7 @@ impl Tower {
|
|||
#[derive(Error, Debug)]
|
||||
pub enum TowerError {
|
||||
#[error("IO Error: {0}")]
|
||||
IOError(#[from] std::io::Error),
|
||||
IoError(#[from] std::io::Error),
|
||||
|
||||
#[error("Serialization Error: {0}")]
|
||||
SerializeError(#[from] bincode::Error),
|
||||
|
@ -1157,7 +1156,7 @@ pub enum TowerError {
|
|||
|
||||
impl TowerError {
|
||||
pub fn is_file_missing(&self) -> bool {
|
||||
if let TowerError::IOError(io_err) = &self {
|
||||
if let TowerError::IoError(io_err) = &self {
|
||||
io_err.kind() == std::io::ErrorKind::NotFound
|
||||
} else {
|
||||
false
|
||||
|
@ -1246,7 +1245,7 @@ pub mod test {
|
|||
};
|
||||
use solana_ledger::{blockstore::make_slot_entries, get_tmp_ledger_path};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender,
|
||||
accounts_background_service::AbsRequestSender,
|
||||
bank::Bank,
|
||||
bank_forks::BankForks,
|
||||
genesis_utils::{
|
||||
|
@ -1417,7 +1416,7 @@ pub mod test {
|
|||
new_root,
|
||||
&self.bank_forks,
|
||||
&mut self.progress,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
None,
|
||||
&mut self.heaviest_subtree_fork_choice,
|
||||
)
|
||||
|
@ -2704,7 +2703,7 @@ pub mod test {
|
|||
remove_file(path).unwrap();
|
||||
},
|
||||
);
|
||||
assert_matches!(loaded, Err(TowerError::IOError(_)))
|
||||
assert_matches!(loaded, Err(TowerError::IoError(_)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -31,7 +31,7 @@ pub fn calculate_non_circulating_supply(bank: &Arc<Bank>) -> NonCirculatingSuppl
|
|||
bank.get_filtered_indexed_accounts(
|
||||
&IndexKey::ProgramId(solana_stake_program::id()),
|
||||
// The program-id account index checks for Account owner on inclusion. However, due to
|
||||
// the current AccountsDB implementation, an account may remain in storage as a
|
||||
// the current AccountsDb implementation, an account may remain in storage as a
|
||||
// zero-lamport Account::Default() after being wiped and reinitialized in later
|
||||
// updates. We include the redundant filter here to avoid returning these accounts.
|
||||
|account| account.owner == solana_stake_program::id(),
|
||||
|
|
|
@ -168,7 +168,7 @@ mod tests {
|
|||
use super::*;
|
||||
use solana_ledger::genesis_utils::{create_genesis_config, GenesisConfigInfo};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender, commitment::BlockCommitmentCache,
|
||||
accounts_background_service::AbsRequestSender, commitment::BlockCommitmentCache,
|
||||
};
|
||||
use solana_sdk::pubkey::Pubkey;
|
||||
|
||||
|
@ -284,7 +284,7 @@ mod tests {
|
|||
bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.set_root(7, &ABSRequestSender::default(), None);
|
||||
.set_root(7, &AbsRequestSender::default(), None);
|
||||
OptimisticallyConfirmedBankTracker::process_notification(
|
||||
BankNotification::OptimisticallyConfirmed(6),
|
||||
&bank_forks,
|
||||
|
|
|
@ -248,11 +248,9 @@ mod tests {
|
|||
if entry.is_tick() {
|
||||
assert!(
|
||||
entry.num_hashes <= poh_config.hashes_per_tick.unwrap(),
|
||||
format!(
|
||||
"{} <= {}",
|
||||
entry.num_hashes,
|
||||
poh_config.hashes_per_tick.unwrap()
|
||||
)
|
||||
"{} <= {}",
|
||||
entry.num_hashes,
|
||||
poh_config.hashes_per_tick.unwrap()
|
||||
);
|
||||
|
||||
if entry.num_hashes == poh_config.hashes_per_tick.unwrap() {
|
||||
|
|
|
@ -28,7 +28,7 @@ use solana_ledger::{
|
|||
use solana_measure::{measure::Measure, thread_mem_usage};
|
||||
use solana_metrics::inc_new_counter_info;
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender, bank::Bank, bank_forks::BankForks,
|
||||
accounts_background_service::AbsRequestSender, bank::Bank, bank_forks::BankForks,
|
||||
commitment::BlockCommitmentCache, vote_sender_types::ReplayVoteSender,
|
||||
};
|
||||
use solana_sdk::{
|
||||
|
@ -98,7 +98,7 @@ pub struct ReplayStageConfig {
|
|||
pub subscriptions: Arc<RpcSubscriptions>,
|
||||
pub leader_schedule_cache: Arc<LeaderScheduleCache>,
|
||||
pub latest_root_senders: Vec<Sender<Slot>>,
|
||||
pub accounts_background_request_sender: ABSRequestSender,
|
||||
pub accounts_background_request_sender: AbsRequestSender,
|
||||
pub block_commitment_cache: Arc<RwLock<BlockCommitmentCache>>,
|
||||
pub transaction_status_sender: Option<TransactionStatusSender>,
|
||||
pub rewards_recorder_sender: Option<RewardsRecorderSender>,
|
||||
|
@ -1070,7 +1070,7 @@ impl ReplayStage {
|
|||
blockstore: &Arc<Blockstore>,
|
||||
leader_schedule_cache: &Arc<LeaderScheduleCache>,
|
||||
lockouts_sender: &Sender<CommitmentAggregationData>,
|
||||
accounts_background_request_sender: &ABSRequestSender,
|
||||
accounts_background_request_sender: &AbsRequestSender,
|
||||
latest_root_senders: &[Sender<Slot>],
|
||||
subscriptions: &Arc<RpcSubscriptions>,
|
||||
block_commitment_cache: &Arc<RwLock<BlockCommitmentCache>>,
|
||||
|
@ -1835,7 +1835,7 @@ impl ReplayStage {
|
|||
new_root: Slot,
|
||||
bank_forks: &RwLock<BankForks>,
|
||||
progress: &mut ProgressMap,
|
||||
accounts_background_request_sender: &ABSRequestSender,
|
||||
accounts_background_request_sender: &AbsRequestSender,
|
||||
highest_confirmed_root: Option<Slot>,
|
||||
heaviest_subtree_fork_choice: &mut HeaviestSubtreeForkChoice,
|
||||
) {
|
||||
|
@ -2013,7 +2013,7 @@ pub(crate) mod tests {
|
|||
},
|
||||
};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender,
|
||||
accounts_background_service::AbsRequestSender,
|
||||
commitment::BlockCommitment,
|
||||
genesis_utils::{self, GenesisConfigInfo, ValidatorVoteKeypairs},
|
||||
};
|
||||
|
@ -2249,7 +2249,7 @@ pub(crate) mod tests {
|
|||
root,
|
||||
&bank_forks,
|
||||
&mut progress,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
None,
|
||||
&mut heaviest_subtree_fork_choice,
|
||||
);
|
||||
|
@ -2293,7 +2293,7 @@ pub(crate) mod tests {
|
|||
root,
|
||||
&bank_forks,
|
||||
&mut progress,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
Some(confirmed_root),
|
||||
&mut heaviest_subtree_fork_choice,
|
||||
);
|
||||
|
@ -3245,7 +3245,7 @@ pub(crate) mod tests {
|
|||
bank_forks.insert(Bank::new_from_parent(&bank0, &Pubkey::default(), 9));
|
||||
let bank9 = bank_forks.get(9).unwrap().clone();
|
||||
bank_forks.insert(Bank::new_from_parent(&bank9, &Pubkey::default(), 10));
|
||||
bank_forks.set_root(9, &ABSRequestSender::default(), None);
|
||||
bank_forks.set_root(9, &AbsRequestSender::default(), None);
|
||||
let total_epoch_stake = bank0.total_epoch_stake();
|
||||
|
||||
// Insert new ForkProgress for slot 10 and its
|
||||
|
@ -3336,7 +3336,7 @@ pub(crate) mod tests {
|
|||
.get_propagated_stats_mut(0)
|
||||
.unwrap()
|
||||
.is_leader_slot = true;
|
||||
bank_forks.set_root(0, &ABSRequestSender::default(), None);
|
||||
bank_forks.set_root(0, &AbsRequestSender::default(), None);
|
||||
let total_epoch_stake = bank_forks.root_bank().total_epoch_stake();
|
||||
|
||||
// Insert new ForkProgress representing a slot for all slots 1..=num_banks. Only
|
||||
|
@ -3416,7 +3416,7 @@ pub(crate) mod tests {
|
|||
.get_propagated_stats_mut(0)
|
||||
.unwrap()
|
||||
.is_leader_slot = true;
|
||||
bank_forks.set_root(0, &ABSRequestSender::default(), None);
|
||||
bank_forks.set_root(0, &AbsRequestSender::default(), None);
|
||||
|
||||
let total_epoch_stake = num_validators as u64 * stake_per_validator;
|
||||
|
||||
|
@ -3761,7 +3761,7 @@ pub(crate) mod tests {
|
|||
bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.set_root(3, &ABSRequestSender::default(), None);
|
||||
.set_root(3, &AbsRequestSender::default(), None);
|
||||
let mut descendants = bank_forks.read().unwrap().descendants().clone();
|
||||
let mut ancestors = bank_forks.read().unwrap().ancestors();
|
||||
let slot_3_descendants = descendants.get(&3).unwrap().clone();
|
||||
|
|
|
@ -10,8 +10,8 @@ use std::any::Any;
|
|||
|
||||
#[derive(Debug)]
|
||||
pub enum Error {
|
||||
IO(std::io::Error),
|
||||
JSON(serde_json::Error),
|
||||
Io(std::io::Error),
|
||||
Json(serde_json::Error),
|
||||
AddrParse(std::net::AddrParseError),
|
||||
JoinError(Box<dyn Any + Send + 'static>),
|
||||
RecvError(std::sync::mpsc::RecvError),
|
||||
|
@ -108,7 +108,7 @@ impl std::convert::From<Box<dyn Any + Send + 'static>> for Error {
|
|||
}
|
||||
impl std::convert::From<std::io::Error> for Error {
|
||||
fn from(e: std::io::Error) -> Error {
|
||||
Error::IO(e)
|
||||
Error::Io(e)
|
||||
}
|
||||
}
|
||||
impl std::convert::From<fs_extra::error::Error> for Error {
|
||||
|
@ -118,7 +118,7 @@ impl std::convert::From<fs_extra::error::Error> for Error {
|
|||
}
|
||||
impl std::convert::From<serde_json::Error> for Error {
|
||||
fn from(e: serde_json::Error) -> Error {
|
||||
Error::JSON(e)
|
||||
Error::Json(e)
|
||||
}
|
||||
}
|
||||
impl std::convert::From<std::net::AddrParseError> for Error {
|
||||
|
@ -199,7 +199,7 @@ mod tests {
|
|||
assert_matches!(send_error(), Err(Error::SendError));
|
||||
assert_matches!(join_error(), Err(Error::JoinError(_)));
|
||||
let ioe = io::Error::new(io::ErrorKind::NotFound, "hi");
|
||||
assert_matches!(Error::from(ioe), Error::IO(_));
|
||||
assert_matches!(Error::from(ioe), Error::Io(_));
|
||||
}
|
||||
#[test]
|
||||
fn fmt_test() {
|
||||
|
|
|
@ -1402,7 +1402,7 @@ impl JsonRpcRequestProcessor {
|
|||
{
|
||||
bank.get_filtered_indexed_accounts(&IndexKey::ProgramId(*program_id), |account| {
|
||||
// The program-id account index checks for Account owner on inclusion. However, due
|
||||
// to the current AccountsDB implementation, an account may remain in storage as a
|
||||
// to the current AccountsDb implementation, an account may remain in storage as a
|
||||
// zero-lamport Account::Default() after being wiped and reinitialized in later
|
||||
// updates. We include the redundant filters here to avoid returning these
|
||||
// accounts.
|
||||
|
@ -1421,7 +1421,7 @@ impl JsonRpcRequestProcessor {
|
|||
mut filters: Vec<RpcFilterType>,
|
||||
) -> Vec<(Pubkey, Account)> {
|
||||
// The by-owner accounts index checks for Token Account state and Owner address on
|
||||
// inclusion. However, due to the current AccountsDB implementation, an account may remain
|
||||
// inclusion. However, due to the current AccountsDb implementation, an account may remain
|
||||
// in storage as a zero-lamport Account::Default() after being wiped and reinitialized in
|
||||
// later updates. We include the redundant filters here to avoid returning these accounts.
|
||||
//
|
||||
|
@ -1461,7 +1461,7 @@ impl JsonRpcRequestProcessor {
|
|||
mut filters: Vec<RpcFilterType>,
|
||||
) -> Vec<(Pubkey, Account)> {
|
||||
// The by-mint accounts index checks for Token Account state and Mint address on inclusion.
|
||||
// However, due to the current AccountsDB implementation, an account may remain in storage
|
||||
// However, due to the current AccountsDb implementation, an account may remain in storage
|
||||
// as be zero-lamport Account::Default() after being wiped and reinitialized in later
|
||||
// updates. We include the redundant filters here to avoid returning these accounts.
|
||||
//
|
||||
|
@ -3035,7 +3035,7 @@ pub mod tests {
|
|||
genesis_utils::{create_genesis_config, GenesisConfigInfo},
|
||||
};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::ABSRequestSender, commitment::BlockCommitment,
|
||||
accounts_background_service::AbsRequestSender, commitment::BlockCommitment,
|
||||
};
|
||||
use solana_sdk::{
|
||||
clock::MAX_RECENT_BLOCKHASHES,
|
||||
|
@ -3152,7 +3152,7 @@ pub mod tests {
|
|||
bank_forks
|
||||
.write()
|
||||
.unwrap()
|
||||
.set_root(*root, &ABSRequestSender::default(), Some(0));
|
||||
.set_root(*root, &AbsRequestSender::default(), Some(0));
|
||||
let mut stakes = HashMap::new();
|
||||
stakes.insert(leader_vote_keypair.pubkey(), (1, Account::default()));
|
||||
let block_time = bank_forks
|
||||
|
|
|
@ -30,7 +30,7 @@ use solana_ledger::{
|
|||
};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::{
|
||||
ABSRequestHandler, ABSRequestSender, AccountsBackgroundService, SendDroppedBankCallback,
|
||||
AbsRequestHandler, AbsRequestSender, AccountsBackgroundService, SendDroppedBankCallback,
|
||||
SnapshotRequestHandler,
|
||||
},
|
||||
bank_forks::{BankForks, SnapshotConfig},
|
||||
|
@ -228,9 +228,9 @@ impl Tvu {
|
|||
))));
|
||||
}
|
||||
|
||||
let accounts_background_request_sender = ABSRequestSender::new(snapshot_request_sender);
|
||||
let accounts_background_request_sender = AbsRequestSender::new(snapshot_request_sender);
|
||||
|
||||
let accounts_background_request_handler = ABSRequestHandler {
|
||||
let accounts_background_request_handler = AbsRequestHandler {
|
||||
snapshot_request_handler,
|
||||
pruned_banks_receiver,
|
||||
};
|
||||
|
|
|
@ -1048,7 +1048,7 @@ fn new_banks_from_ledger(
|
|||
));
|
||||
bank_forks.set_root(
|
||||
warp_slot,
|
||||
&solana_runtime::accounts_background_service::ABSRequestSender::default(),
|
||||
&solana_runtime::accounts_background_service::AbsRequestSender::default(),
|
||||
Some(warp_slot),
|
||||
);
|
||||
leader_schedule_cache.set_root(&bank_forks.root_bank());
|
||||
|
|
|
@ -45,7 +45,7 @@ mod tests {
|
|||
snapshot_packager_service::{PendingSnapshotPackage, SnapshotPackagerService},
|
||||
};
|
||||
use solana_runtime::{
|
||||
accounts_background_service::{ABSRequestSender, SnapshotRequestHandler},
|
||||
accounts_background_service::{AbsRequestSender, SnapshotRequestHandler},
|
||||
accounts_db,
|
||||
bank::{Bank, BankSlotDelta},
|
||||
bank_forks::{ArchiveFormat, BankForks, SnapshotConfig},
|
||||
|
@ -203,7 +203,7 @@ mod tests {
|
|||
|
||||
let (s, snapshot_request_receiver) = unbounded();
|
||||
let (accounts_package_sender, _r) = channel();
|
||||
let request_sender = ABSRequestSender::new(Some(s));
|
||||
let request_sender = AbsRequestSender::new(Some(s));
|
||||
let snapshot_request_handler = SnapshotRequestHandler {
|
||||
snapshot_config: snapshot_test_config.snapshot_config.clone(),
|
||||
snapshot_request_receiver,
|
||||
|
@ -518,7 +518,7 @@ mod tests {
|
|||
(*add_root_interval * num_set_roots * 2) as u64,
|
||||
);
|
||||
let mut current_bank = snapshot_test_config.bank_forks[0].clone();
|
||||
let request_sender = ABSRequestSender::new(Some(snapshot_sender));
|
||||
let request_sender = AbsRequestSender::new(Some(snapshot_sender));
|
||||
for _ in 0..num_set_roots {
|
||||
for _ in 0..*add_root_interval {
|
||||
let new_slot = current_bank.slot() + 1;
|
||||
|
|
|
@ -1,15 +1,11 @@
|
|||
use crate::abi_example::{normalize_type_name, AbiEnumVisitor};
|
||||
use crate::hash::{Hash, Hasher};
|
||||
|
||||
use log::*;
|
||||
|
||||
use serde::ser::Error as SerdeError;
|
||||
use serde::ser::*;
|
||||
use serde::{Serialize, Serializer};
|
||||
|
||||
use std::any::type_name;
|
||||
use std::io::Write;
|
||||
|
||||
use thiserror::Error;
|
||||
|
||||
#[derive(Debug)]
|
||||
|
@ -561,21 +557,21 @@ mod tests {
|
|||
#[frozen_abi(digest = "GttWH8FAY3teUjTaSds9mL3YbiDQ7qWw7WAvDXKd4ZzX")]
|
||||
type TestUnitStruct = std::marker::PhantomData<i8>;
|
||||
|
||||
#[frozen_abi(digest = "2zvXde11f8sNnFbc9E6ZZeFxV7D2BTVLKEZmNTsCDBpS")]
|
||||
#[frozen_abi(digest = "6kj3mPXbzWTwZho48kZWxZjuseLU2oiqhbpqca4DmcRq")]
|
||||
#[derive(Serialize, AbiExample, AbiEnumVisitor)]
|
||||
enum TestEnum {
|
||||
VARIANT1,
|
||||
VARIANT2,
|
||||
Variant1,
|
||||
Variant2,
|
||||
}
|
||||
|
||||
#[frozen_abi(digest = "6keb3v7GXLahhL6zoinzCWwSvB3KhmvZMB3tN2mamAm3")]
|
||||
#[frozen_abi(digest = "3WqYwnbQEdu6iPZi5LJa2b5kw55hxBtZdqFqiViFCKPo")]
|
||||
#[derive(Serialize, AbiExample, AbiEnumVisitor)]
|
||||
enum TestTupleVariant {
|
||||
VARIANT1(u8, u16),
|
||||
VARIANT2(u8, u16),
|
||||
Variant1(u8, u16),
|
||||
Variant2(u8, u16),
|
||||
}
|
||||
|
||||
#[frozen_abi(digest = "DywMfwKq8HZCbUfTwnemHWMN8LvMZCvipQuLddQ2ywwG")]
|
||||
#[frozen_abi(digest = "4E9gJjvKiETBeZ8dybZPAQ7maaHTHFucmLqgX2m6yrBh")]
|
||||
#[derive(Serialize, AbiExample)]
|
||||
struct TestVecEnum {
|
||||
enums: Vec<TestTupleVariant>,
|
||||
|
@ -642,21 +638,21 @@ mod tests {
|
|||
_skipped_test_field: i8,
|
||||
}
|
||||
|
||||
#[frozen_abi(digest = "2zvXde11f8sNnFbc9E6ZZeFxV7D2BTVLKEZmNTsCDBpS")]
|
||||
#[frozen_abi(digest = "6kj3mPXbzWTwZho48kZWxZjuseLU2oiqhbpqca4DmcRq")]
|
||||
#[derive(Serialize, AbiExample, AbiEnumVisitor)]
|
||||
enum TestEnum {
|
||||
VARIANT1,
|
||||
VARIANT2,
|
||||
Variant1,
|
||||
Variant2,
|
||||
#[serde(skip)]
|
||||
#[allow(dead_code)]
|
||||
VARIANT3,
|
||||
Variant3,
|
||||
}
|
||||
|
||||
#[frozen_abi(digest = "6keb3v7GXLahhL6zoinzCWwSvB3KhmvZMB3tN2mamAm3")]
|
||||
#[frozen_abi(digest = "3WqYwnbQEdu6iPZi5LJa2b5kw55hxBtZdqFqiViFCKPo")]
|
||||
#[derive(Serialize, AbiExample, AbiEnumVisitor)]
|
||||
enum TestTupleVariant {
|
||||
VARIANT1(u8, u16),
|
||||
VARIANT2(u8, u16, #[serde(skip)] u32),
|
||||
Variant1(u8, u16),
|
||||
Variant2(u8, u16, #[serde(skip)] u32),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -45,7 +45,7 @@ use std::{
|
|||
cmp,
|
||||
collections::{HashMap, HashSet},
|
||||
fs,
|
||||
io::{Error as IOError, ErrorKind},
|
||||
io::{Error as IoError, ErrorKind},
|
||||
path::{Path, PathBuf},
|
||||
rc::Rc,
|
||||
sync::{
|
||||
|
@ -2082,7 +2082,7 @@ impl Blockstore {
|
|||
Some((slot, _)) => {
|
||||
let confirmed_block =
|
||||
self.get_confirmed_block(slot, false).map_err(|err| {
|
||||
BlockstoreError::IO(IOError::new(
|
||||
BlockstoreError::Io(IoError::new(
|
||||
ErrorKind::Other,
|
||||
format!("Unable to get confirmed block: {}", err),
|
||||
))
|
||||
|
@ -2133,7 +2133,7 @@ impl Blockstore {
|
|||
Some((slot, _)) => {
|
||||
let confirmed_block =
|
||||
self.get_confirmed_block(slot, false).map_err(|err| {
|
||||
BlockstoreError::IO(IOError::new(
|
||||
BlockstoreError::Io(IoError::new(
|
||||
ErrorKind::Other,
|
||||
format!("Unable to get confirmed block: {}", err),
|
||||
))
|
||||
|
@ -3256,7 +3256,7 @@ pub fn create_new_ledger(
|
|||
error!("tar stdout: {}", from_utf8(&output.stdout).unwrap_or("?"));
|
||||
error!("tar stderr: {}", from_utf8(&output.stderr).unwrap_or("?"));
|
||||
|
||||
return Err(BlockstoreError::IO(IOError::new(
|
||||
return Err(BlockstoreError::Io(IoError::new(
|
||||
ErrorKind::Other,
|
||||
format!(
|
||||
"Error trying to generate snapshot archive: {}",
|
||||
|
@ -3303,7 +3303,7 @@ pub fn create_new_ledger(
|
|||
error_messages += &format!("/failed to stash problematic rocksdb: {}", e)
|
||||
});
|
||||
|
||||
return Err(BlockstoreError::IO(IOError::new(
|
||||
return Err(BlockstoreError::Io(IoError::new(
|
||||
ErrorKind::Other,
|
||||
format!(
|
||||
"Error checking to unpack genesis archive: {}{}",
|
||||
|
|
|
@ -64,7 +64,7 @@ pub enum BlockstoreError {
|
|||
RocksDb(#[from] rocksdb::Error),
|
||||
SlotNotRooted,
|
||||
DeadSlot,
|
||||
IO(#[from] std::io::Error),
|
||||
Io(#[from] std::io::Error),
|
||||
Serialize(#[from] Box<bincode::ErrorKind>),
|
||||
FsExtraError(#[from] fs_extra::error::Error),
|
||||
SlotCleanedUp,
|
||||
|
|
|
@ -214,8 +214,8 @@ pub struct GpuVerificationData {
|
|||
}
|
||||
|
||||
pub enum DeviceVerificationData {
|
||||
CPU(),
|
||||
GPU(GpuVerificationData),
|
||||
Cpu(),
|
||||
Gpu(GpuVerificationData),
|
||||
}
|
||||
|
||||
pub struct EntryVerificationState {
|
||||
|
@ -257,7 +257,7 @@ impl EntryVerificationState {
|
|||
|
||||
pub fn finish_verify(&mut self, entries: &[Entry]) -> bool {
|
||||
match &mut self.device_verification_data {
|
||||
DeviceVerificationData::GPU(verification_state) => {
|
||||
DeviceVerificationData::Gpu(verification_state) => {
|
||||
let gpu_time_us = verification_state.thread_h.take().unwrap().join().unwrap();
|
||||
|
||||
let mut verify_check_time = Measure::start("verify_check");
|
||||
|
@ -297,7 +297,7 @@ impl EntryVerificationState {
|
|||
};
|
||||
res
|
||||
}
|
||||
DeviceVerificationData::CPU() => {
|
||||
DeviceVerificationData::Cpu() => {
|
||||
self.verification_status == EntryVerificationStatus::Success
|
||||
}
|
||||
}
|
||||
|
@ -380,7 +380,7 @@ impl EntrySlice for [Entry] {
|
|||
},
|
||||
poh_duration_us,
|
||||
transaction_duration_us: 0,
|
||||
device_verification_data: DeviceVerificationData::CPU(),
|
||||
device_verification_data: DeviceVerificationData::Cpu(),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -464,7 +464,7 @@ impl EntrySlice for [Entry] {
|
|||
},
|
||||
poh_duration_us,
|
||||
transaction_duration_us: 0,
|
||||
device_verification_data: DeviceVerificationData::CPU(),
|
||||
device_verification_data: DeviceVerificationData::Cpu(),
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -527,7 +527,7 @@ impl EntrySlice for [Entry] {
|
|||
verification_status: EntryVerificationStatus::Failure,
|
||||
transaction_duration_us,
|
||||
poh_duration_us: 0,
|
||||
device_verification_data: DeviceVerificationData::CPU(),
|
||||
device_verification_data: DeviceVerificationData::Cpu(),
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -607,7 +607,7 @@ impl EntrySlice for [Entry] {
|
|||
})
|
||||
});
|
||||
|
||||
let device_verification_data = DeviceVerificationData::GPU(GpuVerificationData {
|
||||
let device_verification_data = DeviceVerificationData::Gpu(GpuVerificationData {
|
||||
thread_h: Some(gpu_verify_thread),
|
||||
tx_hashes,
|
||||
hashes: Some(hashes),
|
||||
|
|
|
@ -11,7 +11,7 @@ use std::ops::Sub;
|
|||
use std::path::PathBuf;
|
||||
|
||||
#[derive(Deserialize, Serialize, Debug)]
|
||||
struct IPAddrMapping {
|
||||
struct IpAddrMapping {
|
||||
private: String,
|
||||
public: String,
|
||||
}
|
||||
|
@ -90,7 +90,7 @@ impl Sub for &LogLine {
|
|||
}
|
||||
}
|
||||
|
||||
fn map_ip_address(mappings: &[IPAddrMapping], target: String) -> String {
|
||||
fn map_ip_address(mappings: &[IpAddrMapping], target: String) -> String {
|
||||
for mapping in mappings {
|
||||
if target.contains(&mapping.private) {
|
||||
return target.replace(&mapping.private, mapping.public.as_str());
|
||||
|
@ -100,7 +100,7 @@ fn map_ip_address(mappings: &[IPAddrMapping], target: String) -> String {
|
|||
}
|
||||
|
||||
fn process_iftop_logs(matches: &ArgMatches) {
|
||||
let mut map_list: Vec<IPAddrMapping> = vec![];
|
||||
let mut map_list: Vec<IpAddrMapping> = vec![];
|
||||
if let ("map-IP", Some(args_matches)) = matches.subcommand() {
|
||||
let mut list = args_matches
|
||||
.value_of("list")
|
||||
|
|
|
@ -873,7 +873,7 @@ impl ProgramTestContext {
|
|||
));
|
||||
bank_forks.set_root(
|
||||
pre_warp_slot,
|
||||
&solana_runtime::accounts_background_service::ABSRequestSender::default(),
|
||||
&solana_runtime::accounts_background_service::AbsRequestSender::default(),
|
||||
Some(warp_slot),
|
||||
);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@ extern crate solana_bpf_loader_program;
|
|||
|
||||
use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
|
||||
use solana_bpf_loader_program::{
|
||||
create_vm, serialization::serialize_parameters, syscalls::register_syscalls, BPFError,
|
||||
create_vm, serialization::serialize_parameters, syscalls::register_syscalls, BpfError,
|
||||
ThisInstructionMeter,
|
||||
};
|
||||
use solana_measure::measure::Measure;
|
||||
|
@ -76,7 +76,7 @@ fn bench_program_create_executable(bencher: &mut Bencher) {
|
|||
|
||||
bencher.iter(|| {
|
||||
let _ =
|
||||
Executable::<BPFError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
|
||||
Executable::<BpfError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
|
||||
.unwrap();
|
||||
});
|
||||
}
|
||||
|
@ -95,7 +95,7 @@ fn bench_program_alu(bencher: &mut Bencher) {
|
|||
|
||||
let elf = load_elf("bench_alu").unwrap();
|
||||
let mut executable =
|
||||
Executable::<BPFError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
|
||||
Executable::<BpfError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
|
||||
.unwrap();
|
||||
executable.set_syscall_registry(register_syscalls(&mut invoke_context).unwrap());
|
||||
executable.jit_compile().unwrap();
|
||||
|
@ -221,7 +221,7 @@ fn bench_instruction_count_tuner(_bencher: &mut Bencher) {
|
|||
|
||||
let elf = load_elf("tuner").unwrap();
|
||||
let mut executable =
|
||||
Executable::<BPFError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
|
||||
Executable::<BpfError, ThisInstructionMeter>::from_elf(&elf, None, Config::default())
|
||||
.unwrap();
|
||||
executable.set_syscall_registry(register_syscalls(&mut invoke_context).unwrap());
|
||||
let compute_meter = invoke_context.get_compute_meter();
|
||||
|
|
|
@ -4,14 +4,14 @@ use alloc::{Alloc, AllocErr};
|
|||
use std::alloc::Layout;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct BPFAllocator {
|
||||
pub struct BpfAllocator {
|
||||
heap: Vec<u8>,
|
||||
start: u64,
|
||||
len: u64,
|
||||
pos: u64,
|
||||
}
|
||||
|
||||
impl BPFAllocator {
|
||||
impl BpfAllocator {
|
||||
pub fn new(heap: Vec<u8>, virtual_address: u64) -> Self {
|
||||
let len = heap.len() as u64;
|
||||
Self {
|
||||
|
@ -23,7 +23,7 @@ impl BPFAllocator {
|
|||
}
|
||||
}
|
||||
|
||||
impl Alloc for BPFAllocator {
|
||||
impl Alloc for BpfAllocator {
|
||||
fn alloc(&mut self, layout: Layout) -> Result<u64, AllocErr> {
|
||||
let bytes_to_align = (self.pos as *const u8).align_offset(layout.align()) as u64;
|
||||
if self
|
||||
|
|
|
@ -1,4 +1,6 @@
|
|||
use crate::BPFError;
|
||||
#![allow(clippy::upper_case_acronyms)]
|
||||
|
||||
use crate::BpfError;
|
||||
use solana_rbpf::ebpf;
|
||||
use thiserror::Error;
|
||||
|
||||
|
@ -58,7 +60,7 @@ fn adj_insn_ptr(insn_ptr: usize) -> usize {
|
|||
insn_ptr + ebpf::ELF_INSN_DUMP_OFFSET
|
||||
}
|
||||
|
||||
fn check_prog_len(prog: &[u8]) -> Result<(), BPFError> {
|
||||
fn check_prog_len(prog: &[u8]) -> Result<(), BpfError> {
|
||||
if prog.len() % ebpf::INSN_SIZE != 0 {
|
||||
return Err(VerifierError::ProgramLengthNotMultiple.into());
|
||||
}
|
||||
|
@ -72,21 +74,21 @@ fn check_prog_len(prog: &[u8]) -> Result<(), BPFError> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
fn check_imm_nonzero(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), BPFError> {
|
||||
fn check_imm_nonzero(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), BpfError> {
|
||||
if insn.imm == 0 {
|
||||
return Err(VerifierError::DivisionByZero(adj_insn_ptr(insn_ptr)).into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn check_imm_endian(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), BPFError> {
|
||||
fn check_imm_endian(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), BpfError> {
|
||||
match insn.imm {
|
||||
16 | 32 | 64 => Ok(()),
|
||||
_ => Err(VerifierError::UnsupportedLEBEArgument(adj_insn_ptr(insn_ptr)).into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn check_load_dw(prog: &[u8], insn_ptr: usize) -> Result<(), BPFError> {
|
||||
fn check_load_dw(prog: &[u8], insn_ptr: usize) -> Result<(), BpfError> {
|
||||
if insn_ptr + 1 >= (prog.len() / ebpf::INSN_SIZE) {
|
||||
// Last instruction cannot be LD_DW because there would be no 2nd DW
|
||||
return Err(VerifierError::LDDWCannotBeLast.into());
|
||||
|
@ -98,7 +100,7 @@ fn check_load_dw(prog: &[u8], insn_ptr: usize) -> Result<(), BPFError> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
fn check_jmp_offset(prog: &[u8], insn_ptr: usize) -> Result<(), BPFError> {
|
||||
fn check_jmp_offset(prog: &[u8], insn_ptr: usize) -> Result<(), BpfError> {
|
||||
let insn = ebpf::get_insn(prog, insn_ptr);
|
||||
// if insn.off == -1 {
|
||||
// return Err(VerifierError::InfiniteLoop(adj_insn_ptr(insn_ptr)).into());
|
||||
|
@ -121,7 +123,7 @@ fn check_jmp_offset(prog: &[u8], insn_ptr: usize) -> Result<(), BPFError> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
fn check_registers(insn: &ebpf::Insn, store: bool, insn_ptr: usize) -> Result<(), BPFError> {
|
||||
fn check_registers(insn: &ebpf::Insn, store: bool, insn_ptr: usize) -> Result<(), BpfError> {
|
||||
if insn.src > 10 {
|
||||
return Err(VerifierError::InvalidSourceRegister(adj_insn_ptr(insn_ptr)).into());
|
||||
}
|
||||
|
@ -149,7 +151,7 @@ fn check_imm_register(insn: &ebpf::Insn, insn_ptr: usize) -> Result<(), Verifier
|
|||
}
|
||||
|
||||
#[rustfmt::skip]
|
||||
pub fn check(prog: &[u8]) -> Result<(), BPFError> {
|
||||
pub fn check(prog: &[u8]) -> Result<(), BpfError> {
|
||||
check_prog_len(prog)?;
|
||||
|
||||
let mut insn_ptr: usize = 0;
|
||||
|
|
|
@ -50,17 +50,17 @@ solana_sdk::declare_builtin!(
|
|||
|
||||
/// Errors returned by functions the BPF Loader registers with the VM
|
||||
#[derive(Debug, Error, PartialEq)]
|
||||
pub enum BPFError {
|
||||
pub enum BpfError {
|
||||
#[error("{0}")]
|
||||
VerifierError(#[from] VerifierError),
|
||||
#[error("{0}")]
|
||||
SyscallError(#[from] SyscallError),
|
||||
}
|
||||
impl UserDefinedError for BPFError {}
|
||||
impl UserDefinedError for BpfError {}
|
||||
|
||||
fn map_ebpf_error(
|
||||
invoke_context: &mut dyn InvokeContext,
|
||||
e: EbpfError<BPFError>,
|
||||
e: EbpfError<BpfError>,
|
||||
) -> InstructionError {
|
||||
ic_msg!(invoke_context, "{}", e);
|
||||
InstructionError::InvalidAccountData
|
||||
|
@ -71,9 +71,9 @@ pub fn create_and_cache_executor(
|
|||
data: &[u8],
|
||||
invoke_context: &mut dyn InvokeContext,
|
||||
use_jit: bool,
|
||||
) -> Result<Arc<BPFExecutor>, InstructionError> {
|
||||
) -> Result<Arc<BpfExecutor>, InstructionError> {
|
||||
let bpf_compute_budget = invoke_context.get_bpf_compute_budget();
|
||||
let mut program = Executable::<BPFError, ThisInstructionMeter>::from_elf(
|
||||
let mut program = Executable::<BpfError, ThisInstructionMeter>::from_elf(
|
||||
data,
|
||||
None,
|
||||
Config {
|
||||
|
@ -100,7 +100,7 @@ pub fn create_and_cache_executor(
|
|||
return Err(InstructionError::ProgramFailedToCompile);
|
||||
}
|
||||
}
|
||||
let executor = Arc::new(BPFExecutor { program });
|
||||
let executor = Arc::new(BpfExecutor { program });
|
||||
invoke_context.add_executor(key, executor.clone());
|
||||
Ok(executor)
|
||||
}
|
||||
|
@ -138,11 +138,11 @@ const DEFAULT_HEAP_SIZE: usize = 32 * 1024;
|
|||
/// Create the BPF virtual machine
|
||||
pub fn create_vm<'a>(
|
||||
loader_id: &'a Pubkey,
|
||||
program: &'a dyn Executable<BPFError, ThisInstructionMeter>,
|
||||
program: &'a dyn Executable<BpfError, ThisInstructionMeter>,
|
||||
parameter_bytes: &mut [u8],
|
||||
parameter_accounts: &'a [KeyedAccount<'a>],
|
||||
invoke_context: &'a mut dyn InvokeContext,
|
||||
) -> Result<EbpfVm<'a, BPFError, ThisInstructionMeter>, EbpfError<BPFError>> {
|
||||
) -> Result<EbpfVm<'a, BpfError, ThisInstructionMeter>, EbpfError<BpfError>> {
|
||||
let heap = vec![0_u8; DEFAULT_HEAP_SIZE];
|
||||
let heap_region = MemoryRegion::new_from_slice(&heap, MM_HEAP_START, 0, true);
|
||||
let mut vm = EbpfVm::new(program, parameter_bytes, &[heap_region])?;
|
||||
|
@ -743,18 +743,18 @@ impl InstructionMeter for ThisInstructionMeter {
|
|||
}
|
||||
|
||||
/// BPF Loader's Executor implementation
|
||||
pub struct BPFExecutor {
|
||||
program: Box<dyn Executable<BPFError, ThisInstructionMeter>>,
|
||||
pub struct BpfExecutor {
|
||||
program: Box<dyn Executable<BpfError, ThisInstructionMeter>>,
|
||||
}
|
||||
|
||||
// Well, implement Debug for solana_rbpf::vm::Executable in solana-rbpf...
|
||||
impl Debug for BPFExecutor {
|
||||
impl Debug for BpfExecutor {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
||||
write!(f, "BPFExecutor({:p})", self)
|
||||
write!(f, "BpfExecutor({:p})", self)
|
||||
}
|
||||
}
|
||||
|
||||
impl Executor for BPFExecutor {
|
||||
impl Executor for BpfExecutor {
|
||||
fn execute(
|
||||
&self,
|
||||
loader_id: &Pubkey,
|
||||
|
@ -814,7 +814,7 @@ impl Executor for BPFExecutor {
|
|||
}
|
||||
Err(error) => {
|
||||
let error = match error {
|
||||
EbpfError::UserError(BPFError::SyscallError(
|
||||
EbpfError::UserError(BpfError::SyscallError(
|
||||
SyscallError::InstructionError(error),
|
||||
)) => error,
|
||||
err => {
|
||||
|
@ -884,14 +884,14 @@ mod tests {
|
|||
];
|
||||
let input = &mut [0x00];
|
||||
|
||||
let program = Executable::<BPFError, TestInstructionMeter>::from_text_bytes(
|
||||
let program = Executable::<BpfError, TestInstructionMeter>::from_text_bytes(
|
||||
program,
|
||||
None,
|
||||
Config::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let mut vm =
|
||||
EbpfVm::<BPFError, TestInstructionMeter>::new(program.as_ref(), input, &[]).unwrap();
|
||||
EbpfVm::<BpfError, TestInstructionMeter>::new(program.as_ref(), input, &[]).unwrap();
|
||||
let mut instruction_meter = TestInstructionMeter { remaining: 10 };
|
||||
vm.execute_program_interpreted(&mut instruction_meter)
|
||||
.unwrap();
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
use crate::{alloc, BPFError};
|
||||
use crate::{alloc, BpfError};
|
||||
use alloc::Alloc;
|
||||
use curve25519_dalek::{ristretto::RistrettoPoint, scalar::Scalar};
|
||||
use solana_rbpf::{
|
||||
|
@ -66,17 +66,17 @@ pub enum SyscallError {
|
|||
#[error("Too many accounts passed to inner instruction")]
|
||||
TooManyAccounts,
|
||||
}
|
||||
impl From<SyscallError> for EbpfError<BPFError> {
|
||||
impl From<SyscallError> for EbpfError<BpfError> {
|
||||
fn from(error: SyscallError) -> Self {
|
||||
EbpfError::UserError(error.into())
|
||||
}
|
||||
}
|
||||
|
||||
trait SyscallConsume {
|
||||
fn consume(&mut self, amount: u64) -> Result<(), EbpfError<BPFError>>;
|
||||
fn consume(&mut self, amount: u64) -> Result<(), EbpfError<BpfError>>;
|
||||
}
|
||||
impl SyscallConsume for Rc<RefCell<dyn ComputeMeter>> {
|
||||
fn consume(&mut self, amount: u64) -> Result<(), EbpfError<BPFError>> {
|
||||
fn consume(&mut self, amount: u64) -> Result<(), EbpfError<BpfError>> {
|
||||
self.try_borrow_mut()
|
||||
.map_err(|_| SyscallError::InvokeContextBorrowFailed)?
|
||||
.consume(amount)
|
||||
|
@ -91,11 +91,11 @@ impl SyscallConsume for Rc<RefCell<dyn ComputeMeter>> {
|
|||
/// Only one allocator is currently supported
|
||||
|
||||
/// Simple bump allocator, never frees
|
||||
use crate::allocator_bump::BPFAllocator;
|
||||
use crate::allocator_bump::BpfAllocator;
|
||||
|
||||
pub fn register_syscalls(
|
||||
invoke_context: &mut dyn InvokeContext,
|
||||
) -> Result<SyscallRegistry, EbpfError<BPFError>> {
|
||||
) -> Result<SyscallRegistry, EbpfError<BpfError>> {
|
||||
let mut syscall_registry = SyscallRegistry::default();
|
||||
|
||||
syscall_registry.register_syscall_by_name(b"abort", SyscallAbort::call)?;
|
||||
|
@ -147,11 +147,11 @@ macro_rules! bind_feature_gated_syscall_context_object {
|
|||
|
||||
pub fn bind_syscall_context_objects<'a>(
|
||||
loader_id: &'a Pubkey,
|
||||
vm: &mut EbpfVm<'a, BPFError, crate::ThisInstructionMeter>,
|
||||
vm: &mut EbpfVm<'a, BpfError, crate::ThisInstructionMeter>,
|
||||
callers_keyed_accounts: &'a [KeyedAccount<'a>],
|
||||
invoke_context: &'a mut dyn InvokeContext,
|
||||
heap: Vec<u8>,
|
||||
) -> Result<(), EbpfError<BPFError>> {
|
||||
) -> Result<(), EbpfError<BpfError>> {
|
||||
let bpf_compute_budget = invoke_context.get_bpf_compute_budget();
|
||||
|
||||
// Syscall functions common across languages
|
||||
|
@ -270,7 +270,7 @@ pub fn bind_syscall_context_objects<'a>(
|
|||
vm.bind_syscall_context_object(
|
||||
Box::new(SyscallAllocFree {
|
||||
aligned: *loader_id != bpf_loader_deprecated::id(),
|
||||
allocator: BPFAllocator::new(heap, MM_HEAP_START),
|
||||
allocator: BpfAllocator::new(heap, MM_HEAP_START),
|
||||
}),
|
||||
None,
|
||||
)?;
|
||||
|
@ -283,8 +283,8 @@ fn translate(
|
|||
access_type: AccessType,
|
||||
vm_addr: u64,
|
||||
len: u64,
|
||||
) -> Result<u64, EbpfError<BPFError>> {
|
||||
memory_mapping.map::<BPFError>(access_type, vm_addr, len)
|
||||
) -> Result<u64, EbpfError<BpfError>> {
|
||||
memory_mapping.map::<BpfError>(access_type, vm_addr, len)
|
||||
}
|
||||
|
||||
fn translate_type_inner<'a, T>(
|
||||
|
@ -292,7 +292,7 @@ fn translate_type_inner<'a, T>(
|
|||
access_type: AccessType,
|
||||
vm_addr: u64,
|
||||
loader_id: &Pubkey,
|
||||
) -> Result<&'a mut T, EbpfError<BPFError>> {
|
||||
) -> Result<&'a mut T, EbpfError<BpfError>> {
|
||||
if loader_id != &bpf_loader_deprecated::id()
|
||||
&& (vm_addr as u64 as *mut T).align_offset(align_of::<T>()) != 0
|
||||
{
|
||||
|
@ -310,14 +310,14 @@ fn translate_type_mut<'a, T>(
|
|||
memory_mapping: &MemoryMapping,
|
||||
vm_addr: u64,
|
||||
loader_id: &Pubkey,
|
||||
) -> Result<&'a mut T, EbpfError<BPFError>> {
|
||||
) -> Result<&'a mut T, EbpfError<BpfError>> {
|
||||
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,
|
||||
) -> Result<&'a T, EbpfError<BPFError>> {
|
||||
) -> Result<&'a T, EbpfError<BpfError>> {
|
||||
match translate_type_inner::<T>(memory_mapping, AccessType::Load, vm_addr, loader_id) {
|
||||
Ok(value) => Ok(&*value),
|
||||
Err(e) => Err(e),
|
||||
|
@ -330,7 +330,7 @@ fn translate_slice_inner<'a, T>(
|
|||
vm_addr: u64,
|
||||
len: u64,
|
||||
loader_id: &Pubkey,
|
||||
) -> Result<&'a mut [T], EbpfError<BPFError>> {
|
||||
) -> Result<&'a mut [T], EbpfError<BpfError>> {
|
||||
if loader_id != &bpf_loader_deprecated::id()
|
||||
&& (vm_addr as u64 as *mut T).align_offset(align_of::<T>()) != 0
|
||||
{
|
||||
|
@ -354,7 +354,7 @@ fn translate_slice_mut<'a, T>(
|
|||
vm_addr: u64,
|
||||
len: u64,
|
||||
loader_id: &Pubkey,
|
||||
) -> Result<&'a mut [T], EbpfError<BPFError>> {
|
||||
) -> Result<&'a mut [T], EbpfError<BpfError>> {
|
||||
translate_slice_inner::<T>(memory_mapping, AccessType::Store, vm_addr, len, loader_id)
|
||||
}
|
||||
fn translate_slice<'a, T>(
|
||||
|
@ -362,7 +362,7 @@ fn translate_slice<'a, T>(
|
|||
vm_addr: u64,
|
||||
len: u64,
|
||||
loader_id: &Pubkey,
|
||||
) -> Result<&'a [T], EbpfError<BPFError>> {
|
||||
) -> Result<&'a [T], EbpfError<BpfError>> {
|
||||
match translate_slice_inner::<T>(memory_mapping, AccessType::Load, vm_addr, len, loader_id) {
|
||||
Ok(value) => Ok(&*value),
|
||||
Err(e) => Err(e),
|
||||
|
@ -376,8 +376,8 @@ fn translate_string_and_do(
|
|||
addr: u64,
|
||||
len: u64,
|
||||
loader_id: &Pubkey,
|
||||
work: &mut dyn FnMut(&str) -> Result<u64, EbpfError<BPFError>>,
|
||||
) -> Result<u64, EbpfError<BPFError>> {
|
||||
work: &mut dyn FnMut(&str) -> Result<u64, EbpfError<BpfError>>,
|
||||
) -> Result<u64, EbpfError<BpfError>> {
|
||||
let buf = translate_slice::<u8>(memory_mapping, addr, len, loader_id)?;
|
||||
let i = match buf.iter().position(|byte| *byte == 0) {
|
||||
Some(i) => i,
|
||||
|
@ -394,7 +394,7 @@ fn translate_string_and_do(
|
|||
/// `abort()` is not intended to be called explicitly by the program.
|
||||
/// Causes the BPF program to be halted immediately
|
||||
pub struct SyscallAbort {}
|
||||
impl SyscallObject<BPFError> for SyscallAbort {
|
||||
impl SyscallObject<BpfError> for SyscallAbort {
|
||||
fn call(
|
||||
&mut self,
|
||||
_arg1: u64,
|
||||
|
@ -403,7 +403,7 @@ impl SyscallObject<BPFError> for SyscallAbort {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
_memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
*result = Err(SyscallError::Abort.into());
|
||||
}
|
||||
|
@ -416,7 +416,7 @@ pub struct SyscallPanic<'a> {
|
|||
compute_meter: Option<Rc<RefCell<dyn ComputeMeter>>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallPanic<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallPanic<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
file: u64,
|
||||
|
@ -425,7 +425,7 @@ impl<'a> SyscallObject<BPFError> for SyscallPanic<'a> {
|
|||
column: u64,
|
||||
_arg5: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
if let Some(ref mut compute_meter) = self.compute_meter {
|
||||
question_mark!(compute_meter.consume(len), result);
|
||||
|
@ -448,7 +448,7 @@ pub struct SyscallLog<'a> {
|
|||
logger: Rc<RefCell<dyn Logger>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallLog<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallLog<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
addr: u64,
|
||||
|
@ -457,7 +457,7 @@ impl<'a> SyscallObject<BPFError> for SyscallLog<'a> {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
if self.per_byte_cost {
|
||||
question_mark!(self.compute_meter.consume(len), result);
|
||||
|
@ -487,7 +487,7 @@ pub struct SyscallLogU64 {
|
|||
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
||||
logger: Rc<RefCell<dyn Logger>>,
|
||||
}
|
||||
impl SyscallObject<BPFError> for SyscallLogU64 {
|
||||
impl SyscallObject<BpfError> for SyscallLogU64 {
|
||||
fn call(
|
||||
&mut self,
|
||||
arg1: u64,
|
||||
|
@ -496,7 +496,7 @@ impl SyscallObject<BPFError> for SyscallLogU64 {
|
|||
arg4: u64,
|
||||
arg5: u64,
|
||||
_memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
question_mark!(self.compute_meter.consume(self.cost), result);
|
||||
stable_log::program_log(
|
||||
|
@ -516,7 +516,7 @@ pub struct SyscallLogBpfComputeUnits {
|
|||
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
||||
logger: Rc<RefCell<dyn Logger>>,
|
||||
}
|
||||
impl SyscallObject<BPFError> for SyscallLogBpfComputeUnits {
|
||||
impl SyscallObject<BpfError> for SyscallLogBpfComputeUnits {
|
||||
fn call(
|
||||
&mut self,
|
||||
_arg1: u64,
|
||||
|
@ -525,7 +525,7 @@ impl SyscallObject<BPFError> for SyscallLogBpfComputeUnits {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
_memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
question_mark!(self.compute_meter.consume(self.cost), result);
|
||||
let logger = question_mark!(
|
||||
|
@ -551,7 +551,7 @@ pub struct SyscallLogPubkey<'a> {
|
|||
logger: Rc<RefCell<dyn Logger>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallLogPubkey<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallLogPubkey<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
pubkey_addr: u64,
|
||||
|
@ -560,7 +560,7 @@ impl<'a> SyscallObject<BPFError> for SyscallLogPubkey<'a> {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
question_mark!(self.compute_meter.consume(self.cost), result);
|
||||
let pubkey = question_mark!(
|
||||
|
@ -580,9 +580,9 @@ impl<'a> SyscallObject<BPFError> for SyscallLogPubkey<'a> {
|
|||
/// to the VM to use for enforcement.
|
||||
pub struct SyscallAllocFree {
|
||||
aligned: bool,
|
||||
allocator: BPFAllocator,
|
||||
allocator: BpfAllocator,
|
||||
}
|
||||
impl SyscallObject<BPFError> for SyscallAllocFree {
|
||||
impl SyscallObject<BpfError> for SyscallAllocFree {
|
||||
fn call(
|
||||
&mut self,
|
||||
size: u64,
|
||||
|
@ -591,7 +591,7 @@ impl SyscallObject<BPFError> for SyscallAllocFree {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
_memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
let align = if self.aligned {
|
||||
align_of::<u128>()
|
||||
|
@ -623,7 +623,7 @@ fn translate_program_address_inputs<'a>(
|
|||
program_id_addr: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
loader_id: &Pubkey,
|
||||
) -> Result<(Vec<&'a [u8]>, &'a Pubkey), EbpfError<BPFError>> {
|
||||
) -> Result<(Vec<&'a [u8]>, &'a Pubkey), EbpfError<BpfError>> {
|
||||
let untranslated_seeds =
|
||||
translate_slice::<&[&u8]>(memory_mapping, seeds_addr, seeds_len, loader_id)?;
|
||||
if untranslated_seeds.len() > MAX_SEEDS {
|
||||
|
@ -639,7 +639,7 @@ fn translate_program_address_inputs<'a>(
|
|||
loader_id,
|
||||
)
|
||||
})
|
||||
.collect::<Result<Vec<_>, EbpfError<BPFError>>>()?;
|
||||
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
|
||||
let program_id = translate_type::<Pubkey>(memory_mapping, program_id_addr, loader_id)?;
|
||||
Ok((seeds, program_id))
|
||||
}
|
||||
|
@ -650,7 +650,7 @@ struct SyscallCreateProgramAddress<'a> {
|
|||
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallCreateProgramAddress<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
seeds_addr: u64,
|
||||
|
@ -659,7 +659,7 @@ impl<'a> SyscallObject<BPFError> for SyscallCreateProgramAddress<'a> {
|
|||
address_addr: u64,
|
||||
_arg5: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
let (seeds, program_id) = question_mark!(
|
||||
translate_program_address_inputs(
|
||||
|
@ -695,7 +695,7 @@ struct SyscallTryFindProgramAddress<'a> {
|
|||
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallTryFindProgramAddress<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
seeds_addr: u64,
|
||||
|
@ -704,7 +704,7 @@ impl<'a> SyscallObject<BPFError> for SyscallTryFindProgramAddress<'a> {
|
|||
address_addr: u64,
|
||||
bump_seed_addr: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
let (seeds, program_id) = question_mark!(
|
||||
translate_program_address_inputs(
|
||||
|
@ -754,7 +754,7 @@ pub struct SyscallSha256<'a> {
|
|||
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallSha256<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallSha256<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
vals_addr: u64,
|
||||
|
@ -763,7 +763,7 @@ impl<'a> SyscallObject<BPFError> for SyscallSha256<'a> {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
question_mark!(self.compute_meter.consume(self.sha256_base_cost), result);
|
||||
let hash_result = question_mark!(
|
||||
|
@ -810,7 +810,7 @@ pub struct SyscallRistrettoMul<'a> {
|
|||
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
|
||||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallRistrettoMul<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallRistrettoMul<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
point_addr: u64,
|
||||
|
@ -819,7 +819,7 @@ impl<'a> SyscallObject<BPFError> for SyscallRistrettoMul<'a> {
|
|||
_arg4: u64,
|
||||
_arg5: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
question_mark!(self.compute_meter.consume(self.cost), result);
|
||||
|
||||
|
@ -859,14 +859,14 @@ type TranslatedAccounts<'a> = (
|
|||
|
||||
/// Implemented by language specific data structure translators
|
||||
trait SyscallInvokeSigned<'a> {
|
||||
fn get_context_mut(&self) -> Result<RefMut<&'a mut dyn InvokeContext>, EbpfError<BPFError>>;
|
||||
fn get_context(&self) -> Result<Ref<&'a mut dyn InvokeContext>, EbpfError<BPFError>>;
|
||||
fn get_context_mut(&self) -> Result<RefMut<&'a mut dyn InvokeContext>, EbpfError<BpfError>>;
|
||||
fn get_context(&self) -> Result<Ref<&'a mut dyn InvokeContext>, EbpfError<BpfError>>;
|
||||
fn get_callers_keyed_accounts(&self) -> &'a [KeyedAccount<'a>];
|
||||
fn translate_instruction(
|
||||
&self,
|
||||
addr: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<Instruction, EbpfError<BPFError>>;
|
||||
) -> Result<Instruction, EbpfError<BpfError>>;
|
||||
fn translate_accounts(
|
||||
&self,
|
||||
account_keys: &[Pubkey],
|
||||
|
@ -874,14 +874,14 @@ trait SyscallInvokeSigned<'a> {
|
|||
account_infos_addr: u64,
|
||||
account_infos_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BPFError>>;
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BpfError>>;
|
||||
fn translate_signers(
|
||||
&self,
|
||||
program_id: &Pubkey,
|
||||
signers_seeds_addr: u64,
|
||||
signers_seeds_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<Vec<Pubkey>, EbpfError<BPFError>>;
|
||||
) -> Result<Vec<Pubkey>, EbpfError<BpfError>>;
|
||||
}
|
||||
|
||||
/// Cross-program invocation called from Rust
|
||||
|
@ -891,12 +891,12 @@ pub struct SyscallInvokeSignedRust<'a> {
|
|||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
||||
fn get_context_mut(&self) -> Result<RefMut<&'a mut dyn InvokeContext>, EbpfError<BPFError>> {
|
||||
fn get_context_mut(&self) -> Result<RefMut<&'a mut dyn InvokeContext>, EbpfError<BpfError>> {
|
||||
self.invoke_context
|
||||
.try_borrow_mut()
|
||||
.map_err(|_| SyscallError::InvokeContextBorrowFailed.into())
|
||||
}
|
||||
fn get_context(&self) -> Result<Ref<&'a mut dyn InvokeContext>, EbpfError<BPFError>> {
|
||||
fn get_context(&self) -> Result<Ref<&'a mut dyn InvokeContext>, EbpfError<BpfError>> {
|
||||
self.invoke_context
|
||||
.try_borrow()
|
||||
.map_err(|_| SyscallError::InvokeContextBorrowFailed.into())
|
||||
|
@ -908,7 +908,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
|||
&self,
|
||||
addr: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<Instruction, EbpfError<BPFError>> {
|
||||
) -> Result<Instruction, EbpfError<BpfError>> {
|
||||
let ix = translate_type::<Instruction>(memory_mapping, addr, self.loader_id)?;
|
||||
|
||||
check_instruction_size(
|
||||
|
@ -945,7 +945,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
|||
account_infos_addr: u64,
|
||||
account_infos_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BPFError>> {
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BpfError>> {
|
||||
let invoke_context = self.invoke_context.borrow();
|
||||
|
||||
let account_infos = translate_slice::<AccountInfo>(
|
||||
|
@ -964,7 +964,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
|||
self.loader_id,
|
||||
)
|
||||
})
|
||||
.collect::<Result<Vec<_>, EbpfError<BPFError>>>()?;
|
||||
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
|
||||
|
||||
let translate = |account_info: &AccountInfo| {
|
||||
// Translate the account from user space
|
||||
|
@ -1052,7 +1052,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
|||
signers_seeds_addr: u64,
|
||||
signers_seeds_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<Vec<Pubkey>, EbpfError<BPFError>> {
|
||||
) -> Result<Vec<Pubkey>, EbpfError<BpfError>> {
|
||||
let mut signers = Vec::new();
|
||||
if signers_seeds_len > 0 {
|
||||
let signers_seeds = translate_slice::<&[&[u8]]>(
|
||||
|
@ -1087,7 +1087,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
|||
self.loader_id,
|
||||
)
|
||||
})
|
||||
.collect::<Result<Vec<_>, EbpfError<BPFError>>>()?;
|
||||
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
|
||||
let signer = Pubkey::create_program_address(&seeds, program_id)
|
||||
.map_err(SyscallError::BadSeeds)?;
|
||||
signers.push(signer);
|
||||
|
@ -1098,7 +1098,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedRust<'a> {
|
|||
}
|
||||
}
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallInvokeSignedRust<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallInvokeSignedRust<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
instruction_addr: u64,
|
||||
|
@ -1107,7 +1107,7 @@ impl<'a> SyscallObject<BPFError> for SyscallInvokeSignedRust<'a> {
|
|||
signers_seeds_addr: u64,
|
||||
signers_seeds_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
*result = call(
|
||||
self,
|
||||
|
@ -1174,12 +1174,12 @@ pub struct SyscallInvokeSignedC<'a> {
|
|||
loader_id: &'a Pubkey,
|
||||
}
|
||||
impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
||||
fn get_context_mut(&self) -> Result<RefMut<&'a mut dyn InvokeContext>, EbpfError<BPFError>> {
|
||||
fn get_context_mut(&self) -> Result<RefMut<&'a mut dyn InvokeContext>, EbpfError<BpfError>> {
|
||||
self.invoke_context
|
||||
.try_borrow_mut()
|
||||
.map_err(|_| SyscallError::InvokeContextBorrowFailed.into())
|
||||
}
|
||||
fn get_context(&self) -> Result<Ref<&'a mut dyn InvokeContext>, EbpfError<BPFError>> {
|
||||
fn get_context(&self) -> Result<Ref<&'a mut dyn InvokeContext>, EbpfError<BpfError>> {
|
||||
self.invoke_context
|
||||
.try_borrow()
|
||||
.map_err(|_| SyscallError::InvokeContextBorrowFailed.into())
|
||||
|
@ -1193,7 +1193,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
|||
&self,
|
||||
addr: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<Instruction, EbpfError<BPFError>> {
|
||||
) -> Result<Instruction, EbpfError<BpfError>> {
|
||||
let ix_c = translate_type::<SolInstruction>(memory_mapping, addr, self.loader_id)?;
|
||||
|
||||
check_instruction_size(
|
||||
|
@ -1227,7 +1227,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
|||
is_writable: meta_c.is_writable,
|
||||
})
|
||||
})
|
||||
.collect::<Result<Vec<AccountMeta>, EbpfError<BPFError>>>()?;
|
||||
.collect::<Result<Vec<AccountMeta>, EbpfError<BpfError>>>()?;
|
||||
|
||||
Ok(Instruction {
|
||||
program_id: *program_id,
|
||||
|
@ -1243,7 +1243,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
|||
account_infos_addr: u64,
|
||||
account_infos_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BPFError>> {
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BpfError>> {
|
||||
let invoke_context = self.invoke_context.borrow();
|
||||
|
||||
let account_infos = translate_slice::<SolAccountInfo>(
|
||||
|
@ -1258,7 +1258,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
|||
.map(|account_info| {
|
||||
translate_type::<Pubkey>(memory_mapping, account_info.key_addr, self.loader_id)
|
||||
})
|
||||
.collect::<Result<Vec<_>, EbpfError<BPFError>>>()?;
|
||||
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
|
||||
|
||||
let translate = |account_info: &SolAccountInfo| {
|
||||
// Translate the account from user space
|
||||
|
@ -1335,7 +1335,7 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
|||
signers_seeds_addr: u64,
|
||||
signers_seeds_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<Vec<Pubkey>, EbpfError<BPFError>> {
|
||||
) -> Result<Vec<Pubkey>, EbpfError<BpfError>> {
|
||||
if signers_seeds_len > 0 {
|
||||
let signers_seeds = translate_slice::<SolSignerSeedC>(
|
||||
memory_mapping,
|
||||
|
@ -1371,17 +1371,17 @@ impl<'a> SyscallInvokeSigned<'a> for SyscallInvokeSignedC<'a> {
|
|||
self.loader_id,
|
||||
)
|
||||
})
|
||||
.collect::<Result<Vec<_>, EbpfError<BPFError>>>()?;
|
||||
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?;
|
||||
Pubkey::create_program_address(&seeds_bytes, program_id)
|
||||
.map_err(|err| SyscallError::BadSeeds(err).into())
|
||||
})
|
||||
.collect::<Result<Vec<_>, EbpfError<BPFError>>>()?)
|
||||
.collect::<Result<Vec<_>, EbpfError<BpfError>>>()?)
|
||||
} else {
|
||||
Ok(vec![])
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'a> SyscallObject<BPFError> for SyscallInvokeSignedC<'a> {
|
||||
impl<'a> SyscallObject<BpfError> for SyscallInvokeSignedC<'a> {
|
||||
fn call(
|
||||
&mut self,
|
||||
instruction_addr: u64,
|
||||
|
@ -1390,7 +1390,7 @@ impl<'a> SyscallObject<BPFError> for SyscallInvokeSignedC<'a> {
|
|||
signers_seeds_addr: u64,
|
||||
signers_seeds_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
result: &mut Result<u64, EbpfError<BPFError>>,
|
||||
result: &mut Result<u64, EbpfError<BpfError>>,
|
||||
) {
|
||||
*result = call(
|
||||
self,
|
||||
|
@ -1411,9 +1411,9 @@ fn get_translated_accounts<'a, T, F>(
|
|||
account_infos: &[T],
|
||||
invoke_context: &Ref<&mut dyn InvokeContext>,
|
||||
do_translate: F,
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BPFError>>
|
||||
) -> Result<TranslatedAccounts<'a>, EbpfError<BpfError>>
|
||||
where
|
||||
F: Fn(&T) -> Result<TranslatedAccount<'a>, EbpfError<BPFError>>,
|
||||
F: Fn(&T) -> Result<TranslatedAccount<'a>, EbpfError<BpfError>>,
|
||||
{
|
||||
let mut accounts = Vec::with_capacity(account_keys.len());
|
||||
let mut refs = Vec::with_capacity(account_keys.len());
|
||||
|
@ -1466,7 +1466,7 @@ fn check_instruction_size(
|
|||
num_accounts: usize,
|
||||
data_len: usize,
|
||||
invoke_context: &Ref<&mut dyn InvokeContext>,
|
||||
) -> Result<(), EbpfError<BPFError>> {
|
||||
) -> Result<(), EbpfError<BpfError>> {
|
||||
let size = num_accounts
|
||||
.saturating_mul(size_of::<AccountMeta>())
|
||||
.saturating_add(data_len);
|
||||
|
@ -1482,7 +1482,7 @@ fn check_instruction_size(
|
|||
fn check_account_infos(
|
||||
len: usize,
|
||||
invoke_context: &Ref<&mut dyn InvokeContext>,
|
||||
) -> Result<(), EbpfError<BPFError>> {
|
||||
) -> Result<(), EbpfError<BpfError>> {
|
||||
if len * size_of::<Pubkey>()
|
||||
> invoke_context
|
||||
.get_bpf_compute_budget()
|
||||
|
@ -1498,7 +1498,7 @@ fn check_account_infos(
|
|||
fn check_authorized_program(
|
||||
program_id: &Pubkey,
|
||||
instruction_data: &[u8],
|
||||
) -> Result<(), EbpfError<BPFError>> {
|
||||
) -> Result<(), EbpfError<BpfError>> {
|
||||
if native_loader::check_id(program_id)
|
||||
|| bpf_loader::check_id(program_id)
|
||||
|| bpf_loader_deprecated::check_id(program_id)
|
||||
|
@ -1514,7 +1514,7 @@ fn get_upgradeable_executable(
|
|||
callee_program_id: &Pubkey,
|
||||
program_account: &RefCell<Account>,
|
||||
invoke_context: &Ref<&mut dyn InvokeContext>,
|
||||
) -> Result<Option<(Pubkey, RefCell<Account>)>, EbpfError<BPFError>> {
|
||||
) -> Result<Option<(Pubkey, RefCell<Account>)>, EbpfError<BpfError>> {
|
||||
if program_account.borrow().owner == bpf_loader_upgradeable::id() {
|
||||
match program_account.borrow().state() {
|
||||
Ok(UpgradeableLoaderState::Program {
|
||||
|
@ -1554,7 +1554,7 @@ fn call<'a>(
|
|||
signers_seeds_addr: u64,
|
||||
signers_seeds_len: u64,
|
||||
memory_mapping: &MemoryMapping,
|
||||
) -> Result<u64, EbpfError<BPFError>> {
|
||||
) -> Result<u64, EbpfError<BpfError>> {
|
||||
let (message, executables, accounts, account_refs, caller_privileges) = {
|
||||
let invoke_context = syscall.get_context()?;
|
||||
|
||||
|
@ -1812,7 +1812,7 @@ mod tests {
|
|||
let translated_instruction =
|
||||
translate_type::<Instruction>(&memory_mapping, 96, &bpf_loader::id()).unwrap();
|
||||
assert_eq!(instruction, *translated_instruction);
|
||||
memory_mapping.resize_region::<BPFError>(0, 1).unwrap();
|
||||
memory_mapping.resize_region::<BpfError>(0, 1).unwrap();
|
||||
assert!(translate_type::<Instruction>(&memory_mapping, 100, &bpf_loader::id()).is_err());
|
||||
}
|
||||
|
||||
|
@ -1950,7 +1950,7 @@ mod tests {
|
|||
#[should_panic(expected = "UserError(SyscallError(Abort))")]
|
||||
fn test_syscall_abort() {
|
||||
let memory_mapping = MemoryMapping::new(vec![MemoryRegion::default()], &DEFAULT_CONFIG);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
SyscallAbort::call(
|
||||
&mut SyscallAbort {},
|
||||
0,
|
||||
|
@ -1988,7 +1988,7 @@ mod tests {
|
|||
compute_meter: Some(compute_meter),
|
||||
loader_id: &bpf_loader::id(),
|
||||
};
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_panic.call(
|
||||
100,
|
||||
string.len() as u64,
|
||||
|
@ -1999,7 +1999,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_eq!(
|
||||
Err(EbpfError::UserError(BPFError::SyscallError(
|
||||
Err(EbpfError::UserError(BpfError::SyscallError(
|
||||
SyscallError::InstructionError(InstructionError::ComputationalBudgetExceeded)
|
||||
))),
|
||||
result
|
||||
|
@ -2009,7 +2009,7 @@ mod tests {
|
|||
compute_meter: None,
|
||||
loader_id: &bpf_loader::id(),
|
||||
};
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_panic.call(
|
||||
100,
|
||||
string.len() as u64,
|
||||
|
@ -2050,7 +2050,7 @@ mod tests {
|
|||
&DEFAULT_CONFIG,
|
||||
);
|
||||
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log.call(
|
||||
100,
|
||||
string.len() as u64,
|
||||
|
@ -2064,7 +2064,7 @@ mod tests {
|
|||
assert_eq!(log.borrow().len(), 1);
|
||||
assert_eq!(log.borrow()[0], "Program log: Gaggablaghblagh!");
|
||||
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log.call(
|
||||
101, // AccessViolation
|
||||
string.len() as u64,
|
||||
|
@ -2075,7 +2075,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_access_violation!(result, 101, string.len() as u64);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log.call(
|
||||
100,
|
||||
string.len() as u64 * 2, // AccessViolation
|
||||
|
@ -2086,7 +2086,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_access_violation!(result, 100, string.len() as u64 * 2);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log.call(
|
||||
100,
|
||||
string.len() as u64,
|
||||
|
@ -2097,7 +2097,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_eq!(
|
||||
Err(EbpfError::UserError(BPFError::SyscallError(
|
||||
Err(EbpfError::UserError(BpfError::SyscallError(
|
||||
SyscallError::InstructionError(InstructionError::ComputationalBudgetExceeded)
|
||||
))),
|
||||
result
|
||||
|
@ -2115,7 +2115,7 @@ mod tests {
|
|||
logger,
|
||||
loader_id: &bpf_loader::id(),
|
||||
};
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log.call(
|
||||
100,
|
||||
string.len() as u64,
|
||||
|
@ -2126,7 +2126,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
result.unwrap();
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log.call(
|
||||
100,
|
||||
string.len() as u64,
|
||||
|
@ -2137,7 +2137,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_eq!(
|
||||
Err(EbpfError::UserError(BPFError::SyscallError(
|
||||
Err(EbpfError::UserError(BpfError::SyscallError(
|
||||
SyscallError::InstructionError(InstructionError::ComputationalBudgetExceeded)
|
||||
))),
|
||||
result
|
||||
|
@ -2160,7 +2160,7 @@ mod tests {
|
|||
};
|
||||
let memory_mapping = MemoryMapping::new(vec![], &DEFAULT_CONFIG);
|
||||
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_log_u64.call(1, 2, 3, 4, 5, &memory_mapping, &mut result);
|
||||
result.unwrap();
|
||||
|
||||
|
@ -2195,7 +2195,7 @@ mod tests {
|
|||
&DEFAULT_CONFIG,
|
||||
);
|
||||
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_pubkey.call(100, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
result.unwrap();
|
||||
assert_eq!(log.borrow().len(), 1);
|
||||
|
@ -2203,7 +2203,7 @@ mod tests {
|
|||
log.borrow()[0],
|
||||
"Program log: MoqiU1vryuCGQSxFKA1SZ316JdLEFFhoAu6cKUNk7dN"
|
||||
);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_pubkey.call(
|
||||
101, // AccessViolation
|
||||
32,
|
||||
|
@ -2214,10 +2214,10 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_access_violation!(result, 101, 32);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall_sol_pubkey.call(100, 32, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_eq!(
|
||||
Err(EbpfError::UserError(BPFError::SyscallError(
|
||||
Err(EbpfError::UserError(BpfError::SyscallError(
|
||||
SyscallError::InstructionError(InstructionError::ComputationalBudgetExceeded)
|
||||
))),
|
||||
result
|
||||
|
@ -2235,15 +2235,15 @@ mod tests {
|
|||
);
|
||||
let mut syscall = SyscallAllocFree {
|
||||
aligned: true,
|
||||
allocator: BPFAllocator::new(heap, MM_HEAP_START),
|
||||
allocator: BpfAllocator::new(heap, MM_HEAP_START),
|
||||
};
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(100, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_ne!(result.unwrap(), 0);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(100, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_eq!(result.unwrap(), 0);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(u64::MAX, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_eq!(result.unwrap(), 0);
|
||||
}
|
||||
|
@ -2256,14 +2256,14 @@ mod tests {
|
|||
);
|
||||
let mut syscall = SyscallAllocFree {
|
||||
aligned: false,
|
||||
allocator: BPFAllocator::new(heap, MM_HEAP_START),
|
||||
allocator: BpfAllocator::new(heap, MM_HEAP_START),
|
||||
};
|
||||
for _ in 0..100 {
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(1, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_ne!(result.unwrap(), 0);
|
||||
}
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(100, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_eq!(result.unwrap(), 0);
|
||||
}
|
||||
|
@ -2276,14 +2276,14 @@ mod tests {
|
|||
);
|
||||
let mut syscall = SyscallAllocFree {
|
||||
aligned: true,
|
||||
allocator: BPFAllocator::new(heap, MM_HEAP_START),
|
||||
allocator: BpfAllocator::new(heap, MM_HEAP_START),
|
||||
};
|
||||
for _ in 0..12 {
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(1, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_ne!(result.unwrap(), 0);
|
||||
}
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(100, 0, 0, 0, 0, &memory_mapping, &mut result);
|
||||
assert_eq!(result.unwrap(), 0);
|
||||
}
|
||||
|
@ -2297,9 +2297,9 @@ mod tests {
|
|||
);
|
||||
let mut syscall = SyscallAllocFree {
|
||||
aligned: true,
|
||||
allocator: BPFAllocator::new(heap, MM_HEAP_START),
|
||||
allocator: BpfAllocator::new(heap, MM_HEAP_START),
|
||||
};
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(
|
||||
size_of::<u8>() as u64,
|
||||
0,
|
||||
|
@ -2386,13 +2386,13 @@ mod tests {
|
|||
loader_id: &bpf_loader_deprecated::id(),
|
||||
};
|
||||
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(ro_va, ro_len, rw_va, 0, 0, &memory_mapping, &mut result);
|
||||
result.unwrap();
|
||||
|
||||
let hash_local = hashv(&[bytes1.as_ref(), bytes2.as_ref()]).to_bytes();
|
||||
assert_eq!(hash_result, hash_local);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(
|
||||
ro_va - 1, // AccessViolation
|
||||
ro_len,
|
||||
|
@ -2403,7 +2403,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_access_violation!(result, ro_va - 1, ro_len);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(
|
||||
ro_va,
|
||||
ro_len + 1, // AccessViolation
|
||||
|
@ -2414,7 +2414,7 @@ mod tests {
|
|||
&mut result,
|
||||
);
|
||||
assert_access_violation!(result, ro_va, ro_len + 1);
|
||||
let mut result: Result<u64, EbpfError<BPFError>> = Ok(0);
|
||||
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
|
||||
syscall.call(
|
||||
ro_va,
|
||||
ro_len,
|
||||
|
@ -2428,7 +2428,7 @@ mod tests {
|
|||
|
||||
syscall.call(ro_va, ro_len, rw_va, 0, 0, &memory_mapping, &mut result);
|
||||
assert_eq!(
|
||||
Err(EbpfError::UserError(BPFError::SyscallError(
|
||||
Err(EbpfError::UserError(BpfError::SyscallError(
|
||||
SyscallError::InstructionError(InstructionError::ComputationalBudgetExceeded)
|
||||
))),
|
||||
result
|
||||
|
|
|
@ -37,7 +37,7 @@ pub enum LedgerError {
|
|||
SdkTimeout = 0x6810,
|
||||
|
||||
#[error("Ledger PIC exception")]
|
||||
SdkExceptionPIC = 0x6811,
|
||||
SdkExceptionPic = 0x6811,
|
||||
|
||||
#[error("Ledger app exit exception")]
|
||||
SdkExceptionAppExit = 0x6812,
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
use crate::{
|
||||
accounts_db::{AccountsDB, BankHashInfo, ErrorCounters, LoadedAccount, ScanStorageResult},
|
||||
accounts_db::{AccountsDb, BankHashInfo, ErrorCounters, LoadedAccount, ScanStorageResult},
|
||||
accounts_index::{AccountIndex, Ancestors, IndexKey},
|
||||
bank::{
|
||||
NonceRollbackFull, NonceRollbackInfo, TransactionCheckResult, TransactionExecutionResult,
|
||||
|
@ -51,8 +51,8 @@ pub struct Accounts {
|
|||
/// my epoch
|
||||
pub epoch: Epoch,
|
||||
|
||||
/// Single global AccountsDB
|
||||
pub accounts_db: Arc<AccountsDB>,
|
||||
/// Single global AccountsDb
|
||||
pub accounts_db: Arc<AccountsDb>,
|
||||
|
||||
/// set of writable accounts which are currently in the pipeline
|
||||
pub(crate) account_locks: Mutex<HashSet<Pubkey>>,
|
||||
|
@ -93,7 +93,7 @@ impl Accounts {
|
|||
caching_enabled: bool,
|
||||
) -> Self {
|
||||
Self {
|
||||
accounts_db: Arc::new(AccountsDB::new_with_config(
|
||||
accounts_db: Arc::new(AccountsDb::new_with_config(
|
||||
paths,
|
||||
cluster_type,
|
||||
account_indexes,
|
||||
|
@ -117,7 +117,7 @@ impl Accounts {
|
|||
}
|
||||
}
|
||||
|
||||
pub(crate) fn new_empty(accounts_db: AccountsDB) -> Self {
|
||||
pub(crate) fn new_empty(accounts_db: AccountsDb) -> Self {
|
||||
Self {
|
||||
accounts_db: Arc::new(accounts_db),
|
||||
account_locks: Mutex::new(HashSet::new()),
|
||||
|
@ -553,14 +553,14 @@ impl Accounts {
|
|||
|total_capitalization: &mut u64, (_pubkey, loaded_account, _slot)| {
|
||||
let lamports = loaded_account.lamports();
|
||||
if Self::is_loadable(lamports) {
|
||||
let account_cap = AccountsDB::account_balance_for_capitalization(
|
||||
let account_cap = AccountsDb::account_balance_for_capitalization(
|
||||
lamports,
|
||||
&loaded_account.owner(),
|
||||
loaded_account.executable(),
|
||||
simple_capitalization_enabled,
|
||||
);
|
||||
|
||||
*total_capitalization = AccountsDB::checked_iterative_sum_for_capitalization(
|
||||
*total_capitalization = AccountsDb::checked_iterative_sum_for_capitalization(
|
||||
*total_capitalization,
|
||||
account_cap,
|
||||
);
|
||||
|
@ -1624,7 +1624,7 @@ mod tests {
|
|||
let accounts =
|
||||
Accounts::new_with_config(Vec::new(), &ClusterType::Development, HashSet::new(), false);
|
||||
|
||||
// Load accounts owned by various programs into AccountsDB
|
||||
// Load accounts owned by various programs into AccountsDb
|
||||
let pubkey0 = solana_sdk::pubkey::new_rand();
|
||||
let account0 = Account::new(1, 0, &Pubkey::new(&[2; 32]));
|
||||
accounts.store_slow_uncached(0, &pubkey0, &account0);
|
||||
|
|
|
@ -205,13 +205,13 @@ impl SnapshotRequestHandler {
|
|||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct ABSRequestSender {
|
||||
pub struct AbsRequestSender {
|
||||
snapshot_request_sender: Option<SnapshotRequestSender>,
|
||||
}
|
||||
|
||||
impl ABSRequestSender {
|
||||
impl AbsRequestSender {
|
||||
pub fn new(snapshot_request_sender: Option<SnapshotRequestSender>) -> Self {
|
||||
ABSRequestSender {
|
||||
AbsRequestSender {
|
||||
snapshot_request_sender,
|
||||
}
|
||||
}
|
||||
|
@ -232,12 +232,12 @@ impl ABSRequestSender {
|
|||
}
|
||||
}
|
||||
|
||||
pub struct ABSRequestHandler {
|
||||
pub struct AbsRequestHandler {
|
||||
pub snapshot_request_handler: Option<SnapshotRequestHandler>,
|
||||
pub pruned_banks_receiver: DroppedSlotsReceiver,
|
||||
}
|
||||
|
||||
impl ABSRequestHandler {
|
||||
impl AbsRequestHandler {
|
||||
// Returns the latest requested snapshot block height, if one exists
|
||||
pub fn handle_snapshot_requests(
|
||||
&self,
|
||||
|
@ -275,7 +275,7 @@ impl AccountsBackgroundService {
|
|||
pub fn new(
|
||||
bank_forks: Arc<RwLock<BankForks>>,
|
||||
exit: &Arc<AtomicBool>,
|
||||
request_handler: ABSRequestHandler,
|
||||
request_handler: AbsRequestHandler,
|
||||
accounts_db_caching_enabled: bool,
|
||||
test_hash_calculation: bool,
|
||||
use_index_hash_calculation: bool,
|
||||
|
@ -378,7 +378,7 @@ impl AccountsBackgroundService {
|
|||
|
||||
fn remove_dead_slots(
|
||||
bank: &Bank,
|
||||
request_handler: &ABSRequestHandler,
|
||||
request_handler: &AbsRequestHandler,
|
||||
removed_slots_count: &mut usize,
|
||||
total_remove_slots_time: &mut u64,
|
||||
) {
|
||||
|
@ -411,7 +411,7 @@ mod test {
|
|||
let genesis = create_genesis_config(10);
|
||||
let bank0 = Arc::new(Bank::new(&genesis.genesis_config));
|
||||
let (pruned_banks_sender, pruned_banks_receiver) = unbounded();
|
||||
let request_handler = ABSRequestHandler {
|
||||
let request_handler = AbsRequestHandler {
|
||||
snapshot_request_handler: None,
|
||||
pruned_banks_receiver,
|
||||
};
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1067,7 +1067,7 @@ impl Bank {
|
|||
new.ancestors.insert(p.slot(), i + 1);
|
||||
});
|
||||
|
||||
// Following code may touch AccountsDB, requiring proper ancestors
|
||||
// Following code may touch AccountsDb, requiring proper ancestors
|
||||
let parent_epoch = parent.epoch();
|
||||
if parent_epoch < new.epoch() {
|
||||
new.apply_feature_activations(false);
|
||||
|
@ -2169,7 +2169,7 @@ impl Bank {
|
|||
|
||||
self.capitalization.fetch_sub(account.lamports, Relaxed);
|
||||
|
||||
// Resetting account balance to 0 is needed to really purge from AccountsDB and
|
||||
// Resetting account balance to 0 is needed to really purge from AccountsDb and
|
||||
// flush the Stakes cache
|
||||
account.lamports = 0;
|
||||
self.store_account(&program_id, &account);
|
||||
|
@ -2189,7 +2189,7 @@ impl Bank {
|
|||
),
|
||||
Some(account) => {
|
||||
if *name == String::from_utf8_lossy(&account.data) {
|
||||
// nop; it seems that already AccountsDB is updated.
|
||||
// nop; it seems that already AccountsDb is updated.
|
||||
return;
|
||||
}
|
||||
// continue to replace account
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
//! The `bank_forks` module implements BankForks a DAG of checkpointed Banks
|
||||
|
||||
use crate::{
|
||||
accounts_background_service::{ABSRequestSender, SnapshotRequest},
|
||||
accounts_background_service::{AbsRequestSender, SnapshotRequest},
|
||||
bank::Bank,
|
||||
};
|
||||
use log::*;
|
||||
|
@ -187,7 +187,7 @@ impl BankForks {
|
|||
pub fn set_root(
|
||||
&mut self,
|
||||
root: Slot,
|
||||
accounts_background_request_sender: &ABSRequestSender,
|
||||
accounts_background_request_sender: &AbsRequestSender,
|
||||
highest_confirmed_root: Option<Slot>,
|
||||
) {
|
||||
let old_epoch = self.root_bank().epoch();
|
||||
|
@ -428,7 +428,7 @@ mod tests {
|
|||
|
||||
let bank0 = Bank::new(&genesis_config);
|
||||
let mut bank_forks0 = BankForks::new(bank0);
|
||||
bank_forks0.set_root(0, &ABSRequestSender::default(), None);
|
||||
bank_forks0.set_root(0, &AbsRequestSender::default(), None);
|
||||
|
||||
let bank1 = Bank::new(&genesis_config);
|
||||
let mut bank_forks1 = BankForks::new(bank1);
|
||||
|
@ -460,7 +460,7 @@ mod tests {
|
|||
|
||||
// Set root in bank_forks0 to truncate the ancestor history
|
||||
bank_forks0.insert(child1);
|
||||
bank_forks0.set_root(slot, &ABSRequestSender::default(), None);
|
||||
bank_forks0.set_root(slot, &AbsRequestSender::default(), None);
|
||||
|
||||
// Don't set root in bank_forks1 to keep the ancestor history
|
||||
bank_forks1.insert(child2);
|
||||
|
@ -514,7 +514,7 @@ mod tests {
|
|||
);
|
||||
bank_forks.set_root(
|
||||
2,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
None, // highest confirmed root
|
||||
);
|
||||
banks[2].squash();
|
||||
|
@ -573,7 +573,7 @@ mod tests {
|
|||
);
|
||||
bank_forks.set_root(
|
||||
2,
|
||||
&ABSRequestSender::default(),
|
||||
&AbsRequestSender::default(),
|
||||
Some(1), // highest confirmed root
|
||||
);
|
||||
banks[2].squash();
|
||||
|
|
|
@ -19,7 +19,7 @@ use thiserror::Error;
|
|||
#[derive(Error, Debug)]
|
||||
pub enum UnpackError {
|
||||
#[error("IO error: {0}")]
|
||||
IO(#[from] std::io::Error),
|
||||
Io(#[from] std::io::Error),
|
||||
#[error("Archive error: {0}")]
|
||||
Archive(String),
|
||||
}
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
use {
|
||||
crate::{
|
||||
accounts::Accounts,
|
||||
accounts_db::{AccountStorageEntry, AccountsDB, AppendVecId, BankHashInfo},
|
||||
accounts_db::{AccountStorageEntry, AccountsDb, AppendVecId, BankHashInfo},
|
||||
accounts_index::{AccountIndex, Ancestors},
|
||||
append_vec::AppendVec,
|
||||
bank::{Bank, BankFieldsToDeserialize, BankRc, Builtins},
|
||||
|
@ -59,7 +59,7 @@ pub(crate) use crate::accounts_db::{SnapshotStorage, SnapshotStorages};
|
|||
|
||||
#[derive(Copy, Clone, Eq, PartialEq)]
|
||||
pub(crate) enum SerdeStyle {
|
||||
NEWER,
|
||||
Newer,
|
||||
}
|
||||
|
||||
const MAX_STREAM_SIZE: u64 = 32 * 1024 * 1024 * 1024;
|
||||
|
@ -82,7 +82,7 @@ trait TypeContext<'a> {
|
|||
|
||||
fn serialize_accounts_db_fields<S: serde::ser::Serializer>(
|
||||
serializer: S,
|
||||
serializable_db: &SerializableAccountsDB<'a, Self>,
|
||||
serializable_db: &SerializableAccountsDb<'a, Self>,
|
||||
) -> std::result::Result<S::Ok, S::Error>
|
||||
where
|
||||
Self: std::marker::Sized;
|
||||
|
@ -155,7 +155,7 @@ where
|
|||
}};
|
||||
}
|
||||
match serde_style {
|
||||
SerdeStyle::NEWER => INTO!(TypeContextFuture),
|
||||
SerdeStyle::Newer => INTO!(TypeContextFuture),
|
||||
}
|
||||
.map_err(|err| {
|
||||
warn!("bankrc_from_stream error: {:?}", err);
|
||||
|
@ -185,7 +185,7 @@ where
|
|||
};
|
||||
}
|
||||
match serde_style {
|
||||
SerdeStyle::NEWER => INTO!(TypeContextFuture),
|
||||
SerdeStyle::Newer => INTO!(TypeContextFuture),
|
||||
}
|
||||
.map_err(|err| {
|
||||
warn!("bankrc_to_stream error: {:?}", err);
|
||||
|
@ -208,14 +208,14 @@ impl<'a, C: TypeContext<'a>> Serialize for SerializableBankAndStorage<'a, C> {
|
|||
}
|
||||
}
|
||||
|
||||
struct SerializableAccountsDB<'a, C> {
|
||||
accounts_db: &'a AccountsDB,
|
||||
struct SerializableAccountsDb<'a, C> {
|
||||
accounts_db: &'a AccountsDb,
|
||||
slot: Slot,
|
||||
account_storage_entries: &'a [SnapshotStorage],
|
||||
phantom: std::marker::PhantomData<C>,
|
||||
}
|
||||
|
||||
impl<'a, C: TypeContext<'a>> Serialize for SerializableAccountsDB<'a, C> {
|
||||
impl<'a, C: TypeContext<'a>> Serialize for SerializableAccountsDb<'a, C> {
|
||||
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
|
||||
where
|
||||
S: serde::ser::Serializer,
|
||||
|
@ -225,7 +225,7 @@ impl<'a, C: TypeContext<'a>> Serialize for SerializableAccountsDB<'a, C> {
|
|||
}
|
||||
|
||||
#[cfg(RUSTC_WITH_SPECIALIZATION)]
|
||||
impl<'a, C> IgnoreAsHelper for SerializableAccountsDB<'a, C> {}
|
||||
impl<'a, C> IgnoreAsHelper for SerializableAccountsDb<'a, C> {}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn reconstruct_bank_from_fields<E, P>(
|
||||
|
@ -273,12 +273,12 @@ fn reconstruct_accountsdb_from_fields<E, P>(
|
|||
cluster_type: &ClusterType,
|
||||
account_indexes: HashSet<AccountIndex>,
|
||||
caching_enabled: bool,
|
||||
) -> Result<AccountsDB, Error>
|
||||
) -> Result<AccountsDb, Error>
|
||||
where
|
||||
E: SerializableStorage,
|
||||
P: AsRef<Path>,
|
||||
{
|
||||
let mut accounts_db = AccountsDB::new_with_config(
|
||||
let mut accounts_db = AccountsDb::new_with_config(
|
||||
account_paths.to_vec(),
|
||||
cluster_type,
|
||||
account_indexes,
|
||||
|
|
|
@ -215,7 +215,7 @@ impl<'a> TypeContext<'a> for Context {
|
|||
{
|
||||
(
|
||||
SerializableVersionedBank::from(serializable_bank.bank.get_fields_to_serialize()),
|
||||
SerializableAccountsDB::<'a, Self> {
|
||||
SerializableAccountsDb::<'a, Self> {
|
||||
accounts_db: &*serializable_bank.bank.rc.accounts.accounts_db,
|
||||
slot: serializable_bank.bank.rc.slot,
|
||||
account_storage_entries: serializable_bank.snapshot_storages,
|
||||
|
@ -227,7 +227,7 @@ impl<'a> TypeContext<'a> for Context {
|
|||
|
||||
fn serialize_accounts_db_fields<S: serde::ser::Serializer>(
|
||||
serializer: S,
|
||||
serializable_db: &SerializableAccountsDB<'a, Self>,
|
||||
serializable_db: &SerializableAccountsDb<'a, Self>,
|
||||
) -> std::result::Result<S::Ok, S::Error>
|
||||
where
|
||||
Self: std::marker::Sized,
|
||||
|
|
|
@ -21,7 +21,7 @@ use {
|
|||
|
||||
#[cfg(test)]
|
||||
fn copy_append_vecs<P: AsRef<Path>>(
|
||||
accounts_db: &AccountsDB,
|
||||
accounts_db: &AccountsDb,
|
||||
output_dir: P,
|
||||
) -> std::io::Result<()> {
|
||||
let storage_entries = accounts_db.get_snapshot_storages(Slot::max_value());
|
||||
|
@ -57,7 +57,7 @@ fn context_accountsdb_from_stream<'a, C, R, P>(
|
|||
stream: &mut BufReader<R>,
|
||||
account_paths: &[PathBuf],
|
||||
stream_append_vecs_path: P,
|
||||
) -> Result<AccountsDB, Error>
|
||||
) -> Result<AccountsDb, Error>
|
||||
where
|
||||
C: TypeContext<'a>,
|
||||
R: Read,
|
||||
|
@ -80,13 +80,13 @@ fn accountsdb_from_stream<R, P>(
|
|||
stream: &mut BufReader<R>,
|
||||
account_paths: &[PathBuf],
|
||||
stream_append_vecs_path: P,
|
||||
) -> Result<AccountsDB, Error>
|
||||
) -> Result<AccountsDb, Error>
|
||||
where
|
||||
R: Read,
|
||||
P: AsRef<Path>,
|
||||
{
|
||||
match serde_style {
|
||||
SerdeStyle::NEWER => context_accountsdb_from_stream::<TypeContextFuture, R, P>(
|
||||
SerdeStyle::Newer => context_accountsdb_from_stream::<TypeContextFuture, R, P>(
|
||||
stream,
|
||||
account_paths,
|
||||
stream_append_vecs_path,
|
||||
|
@ -98,7 +98,7 @@ where
|
|||
fn accountsdb_to_stream<W>(
|
||||
serde_style: SerdeStyle,
|
||||
stream: &mut W,
|
||||
accounts_db: &AccountsDB,
|
||||
accounts_db: &AccountsDb,
|
||||
slot: Slot,
|
||||
account_storage_entries: &[SnapshotStorage],
|
||||
) -> Result<(), Error>
|
||||
|
@ -106,9 +106,9 @@ where
|
|||
W: Write,
|
||||
{
|
||||
match serde_style {
|
||||
SerdeStyle::NEWER => serialize_into(
|
||||
SerdeStyle::Newer => serialize_into(
|
||||
stream,
|
||||
&SerializableAccountsDB::<TypeContextFuture> {
|
||||
&SerializableAccountsDb::<TypeContextFuture> {
|
||||
accounts_db,
|
||||
slot,
|
||||
account_storage_entries,
|
||||
|
@ -230,13 +230,13 @@ fn test_bank_serialize_style(serde_style: SerdeStyle) {
|
|||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn reconstruct_accounts_db_via_serialization(
|
||||
accounts: &AccountsDB,
|
||||
accounts: &AccountsDb,
|
||||
slot: Slot,
|
||||
) -> AccountsDB {
|
||||
) -> AccountsDb {
|
||||
let mut writer = Cursor::new(vec![]);
|
||||
let snapshot_storages = accounts.get_snapshot_storages(slot);
|
||||
accountsdb_to_stream(
|
||||
SerdeStyle::NEWER,
|
||||
SerdeStyle::Newer,
|
||||
&mut writer,
|
||||
&accounts,
|
||||
slot,
|
||||
|
@ -249,17 +249,17 @@ pub(crate) fn reconstruct_accounts_db_via_serialization(
|
|||
let copied_accounts = TempDir::new().unwrap();
|
||||
// Simulate obtaining a copy of the AppendVecs from a tarball
|
||||
copy_append_vecs(&accounts, copied_accounts.path()).unwrap();
|
||||
accountsdb_from_stream(SerdeStyle::NEWER, &mut reader, &[], copied_accounts.path()).unwrap()
|
||||
accountsdb_from_stream(SerdeStyle::Newer, &mut reader, &[], copied_accounts.path()).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_accounts_serialize_newer() {
|
||||
test_accounts_serialize_style(SerdeStyle::NEWER)
|
||||
test_accounts_serialize_style(SerdeStyle::Newer)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bank_serialize_newer() {
|
||||
test_bank_serialize_style(SerdeStyle::NEWER)
|
||||
test_bank_serialize_style(SerdeStyle::Newer)
|
||||
}
|
||||
|
||||
#[cfg(all(test, RUSTC_WITH_SPECIALIZATION))]
|
||||
|
@ -268,7 +268,7 @@ mod test_bank_serialize {
|
|||
|
||||
// These some what long test harness is required to freeze the ABI of
|
||||
// Bank's serialization due to versioned nature
|
||||
#[frozen_abi(digest = "9CqwEeiVycBp9wVDLz19XUJXRMZ68itGfYVEe29S8JmA")]
|
||||
#[frozen_abi(digest = "DuRGntVwLGNAv5KooafUSpxk67BPAx2yC7Z8A9c8wr2G")]
|
||||
#[derive(Serialize, AbiExample)]
|
||||
pub struct BankAbiTestWrapperFuture {
|
||||
#[serde(serialize_with = "wrapper_future")]
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
use crate::{
|
||||
accounts_db::AccountsDB,
|
||||
accounts_db::AccountsDb,
|
||||
accounts_index::AccountIndex,
|
||||
bank::{Bank, BankSlotDelta, Builtins},
|
||||
bank_forks::ArchiveFormat,
|
||||
|
@ -25,7 +25,7 @@ use std::{
|
|||
cmp::Ordering,
|
||||
fmt,
|
||||
fs::{self, File},
|
||||
io::{self, BufReader, BufWriter, Error as IOError, ErrorKind, Read, Seek, SeekFrom, Write},
|
||||
io::{self, BufReader, BufWriter, Error as IoError, ErrorKind, Read, Seek, SeekFrom, Write},
|
||||
path::{Path, PathBuf},
|
||||
process::{self, ExitStatus},
|
||||
str::FromStr,
|
||||
|
@ -108,7 +108,7 @@ pub struct SlotSnapshotPaths {
|
|||
#[derive(Error, Debug)]
|
||||
pub enum SnapshotError {
|
||||
#[error("I/O error: {0}")]
|
||||
IO(#[from] std::io::Error),
|
||||
Io(#[from] std::io::Error),
|
||||
|
||||
#[error("serialization error: {0}")]
|
||||
Serialize(#[from] bincode::Error),
|
||||
|
@ -319,7 +319,7 @@ pub fn archive_snapshot_package(snapshot_package: &AccountsPackage) -> Result<()
|
|||
|
||||
match &mut tar.stdout {
|
||||
None => {
|
||||
return Err(SnapshotError::IO(IOError::new(
|
||||
return Err(SnapshotError::Io(IoError::new(
|
||||
ErrorKind::Other,
|
||||
"tar stdout unavailable".to_string(),
|
||||
)));
|
||||
|
@ -521,7 +521,7 @@ pub fn add_snapshot<P: AsRef<Path>>(
|
|||
let mut bank_serialize = Measure::start("bank-serialize-ms");
|
||||
let bank_snapshot_serializer = move |stream: &mut BufWriter<File>| -> Result<()> {
|
||||
let serde_style = match snapshot_version {
|
||||
SnapshotVersion::V1_2_0 => SerdeStyle::NEWER,
|
||||
SnapshotVersion::V1_2_0 => SerdeStyle::Newer,
|
||||
};
|
||||
bank_to_stream(serde_style, stream.by_ref(), bank, snapshot_storages)?;
|
||||
Ok(())
|
||||
|
@ -797,7 +797,7 @@ where
|
|||
let bank = deserialize_snapshot_data_file(&root_paths.snapshot_file_path, |mut stream| {
|
||||
Ok(match snapshot_version_enum {
|
||||
SnapshotVersion::V1_2_0 => bank_from_stream(
|
||||
SerdeStyle::NEWER,
|
||||
SerdeStyle::Newer,
|
||||
&mut stream,
|
||||
&append_vecs_path,
|
||||
account_paths,
|
||||
|
@ -841,7 +841,7 @@ fn get_bank_snapshot_dir<P: AsRef<Path>>(path: P, slot: Slot) -> PathBuf {
|
|||
|
||||
fn get_io_error(error: &str) -> SnapshotError {
|
||||
warn!("Snapshot Error: {:?}", error);
|
||||
SnapshotError::IO(IOError::new(ErrorKind::Other, error))
|
||||
SnapshotError::Io(IoError::new(ErrorKind::Other, error))
|
||||
}
|
||||
|
||||
pub fn verify_snapshot_archive<P, Q, R>(
|
||||
|
@ -968,7 +968,7 @@ pub fn process_accounts_package_pre(
|
|||
|
||||
let hash = accounts_package.hash; // temporarily remaining here
|
||||
if let Some(expected_hash) = accounts_package.hash_for_testing {
|
||||
let (hash, lamports) = AccountsDB::calculate_accounts_hash_without_index(
|
||||
let (hash, lamports) = AccountsDb::calculate_accounts_hash_without_index(
|
||||
&accounts_package.storages,
|
||||
accounts_package.simple_capitalization_testing,
|
||||
thread_pool,
|
||||
|
@ -1039,7 +1039,7 @@ mod tests {
|
|||
Ok(())
|
||||
},
|
||||
);
|
||||
assert_matches!(result, Err(SnapshotError::IO(ref message)) if message.to_string().starts_with("too large snapshot data file to serialize"));
|
||||
assert_matches!(result, Err(SnapshotError::Io(ref message)) if message.to_string().starts_with("too large snapshot data file to serialize"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -1088,7 +1088,7 @@ mod tests {
|
|||
expected_consumed_size - 1,
|
||||
|stream| Ok(deserialize_from::<_, u32>(stream)?),
|
||||
);
|
||||
assert_matches!(result, Err(SnapshotError::IO(ref message)) if message.to_string().starts_with("too large snapshot data file to deserialize"));
|
||||
assert_matches!(result, Err(SnapshotError::Io(ref message)) if message.to_string().starts_with("too large snapshot data file to deserialize"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -1113,7 +1113,7 @@ mod tests {
|
|||
expected_consumed_size * 2,
|
||||
|stream| Ok(deserialize_from::<_, u32>(stream)?),
|
||||
);
|
||||
assert_matches!(result, Err(SnapshotError::IO(ref message)) if message.to_string().starts_with("invalid snapshot data file"));
|
||||
assert_matches!(result, Err(SnapshotError::Io(ref message)) if message.to_string().starts_with("invalid snapshot data file"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
use log::*;
|
||||
use rand::{thread_rng, Rng};
|
||||
use rayon::prelude::*;
|
||||
use solana_runtime::{accounts_db::AccountsDB, accounts_index::Ancestors};
|
||||
use solana_runtime::{accounts_db::AccountsDb, accounts_index::Ancestors};
|
||||
use solana_sdk::genesis_config::ClusterType;
|
||||
use solana_sdk::{account::Account, clock::Slot, pubkey::Pubkey};
|
||||
use std::collections::HashSet;
|
||||
|
@ -15,7 +15,7 @@ fn test_shrink_and_clean() {
|
|||
|
||||
// repeat the whole test scenario
|
||||
for _ in 0..5 {
|
||||
let accounts = Arc::new(AccountsDB::new_single());
|
||||
let accounts = Arc::new(AccountsDb::new_single());
|
||||
let accounts_for_shrink = accounts.clone();
|
||||
|
||||
// spawn the slot shrinking background thread
|
||||
|
@ -31,7 +31,7 @@ fn test_shrink_and_clean() {
|
|||
let mut alive_accounts = vec![];
|
||||
let owner = Pubkey::default();
|
||||
|
||||
// populate the AccountsDB with plenty of food for slot shrinking
|
||||
// populate the AccountsDb with plenty of food for slot shrinking
|
||||
// also this simulates realistic some heavy spike account updates in the wild
|
||||
for current_slot in 0..100 {
|
||||
while alive_accounts.len() <= 10 {
|
||||
|
@ -66,7 +66,7 @@ fn test_shrink_and_clean() {
|
|||
fn test_bad_bank_hash() {
|
||||
solana_logger::setup();
|
||||
use solana_sdk::signature::{Keypair, Signer};
|
||||
let db = AccountsDB::new(Vec::new(), &ClusterType::Development);
|
||||
let db = AccountsDb::new(Vec::new(), &ClusterType::Development);
|
||||
|
||||
let some_slot: Slot = 0;
|
||||
let ancestors: Ancestors = [(some_slot, 0)].iter().copied().collect();
|
||||
|
@ -113,7 +113,7 @@ fn test_bad_bank_hash() {
|
|||
for (key, account) in &account_refs {
|
||||
assert_eq!(
|
||||
db.load_account_hash(&ancestors, &key),
|
||||
AccountsDB::hash_account(some_slot, &account, &key, &ClusterType::Development)
|
||||
AccountsDb::hash_account(some_slot, &account, &key, &ClusterType::Development)
|
||||
);
|
||||
}
|
||||
existing.clear();
|
||||
|
|
|
@ -19,7 +19,7 @@ pub type PacketSender = Sender<Packets>;
|
|||
#[derive(Error, Debug)]
|
||||
pub enum StreamerError {
|
||||
#[error("I/O error")]
|
||||
IO(#[from] std::io::Error),
|
||||
Io(#[from] std::io::Error),
|
||||
|
||||
#[error("receive timeout error")]
|
||||
RecvTimeoutError(#[from] RecvTimeoutError),
|
||||
|
|
Loading…
Reference in New Issue