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

Pacify clippy

This commit is contained in:
Michael Vines 2021-02-18 23:42:09 -08:00
parent fd3b71a2c6
commit 5df36aec7d
40 changed files with 446 additions and 451 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
banking-bench/src/main.rs
View File

@ -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!(

4
cli/src/program.rs
View File

@ -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(),

2
core/src/banking_stage.rs
View File

@ -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();
}

2
core/src/broadcast_stage.rs
View File

@ -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));
}
}
}

2
core/src/cluster_info.rs
View File

@ -1507,7 +1507,7 @@ impl ClusterInfo {
1
);
error!("retransmit result {:?}", e);
return Err(Error::IO(e));
return Err(Error::Io(e));
}
}
}

8
core/src/commitment_service.rs
View File

@ -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);

17
core/src/consensus.rs
View File

@ -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]

2
core/src/non_circulating_supply.rs
View File

@ -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(),

4
core/src/optimistically_confirmed_bank_tracker.rs
View File

@ -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,

8
core/src/poh_service.rs
View File

@ -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() {

22
core/src/replay_stage.rs
View File

@ -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
core/src/result.rs
View File

@ -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() {

10
core/src/rpc.rs
View File

@ -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

6
core/src/tvu.rs
View File

@ -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,
};

2
core/src/validator.rs
View File

@ -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());

6
core/tests/snapshots.rs
View File

@ -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;

32
frozen-abi/src/abi_digester.rs
View File

@ -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),
}
}
}

10
ledger/src/blockstore.rs
View File

@ -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: {}{}",

2
ledger/src/blockstore_db.rs
View File

@ -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,

16
ledger/src/entry.rs
View File

@ -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),

6
log-analyzer/src/main.rs
View File

@ -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")

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

@ -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),
);

8
programs/bpf/benches/bpf_loader.rs
View File

@ -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();

6
programs/bpf_loader/src/allocator_bump.rs
View File

@ -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

18
programs/bpf_loader/src/bpf_verifier.rs
View File

@ -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;

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

@ -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();

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

@ -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

2
remote-wallet/src/ledger_error.rs
View File

@ -37,7 +37,7 @@ pub enum LedgerError {
SdkTimeout = 0x6810,
#[error("Ledger PIC exception")]
SdkExceptionPIC = 0x6811,
SdkExceptionPic = 0x6811,
#[error("Ledger app exit exception")]
SdkExceptionAppExit = 0x6812,

16
runtime/src/accounts.rs
View File

@ -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);

16
runtime/src/accounts_background_service.rs
View File

@ -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,
};

292
runtime/src/accounts_db.rs
View File

File diff suppressed because it is too large Load Diff

6
runtime/src/bank.rs
View File

@ -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

12
runtime/src/bank_forks.rs
View File

@ -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();

2
runtime/src/hardened_unpack.rs
View File

@ -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),
}

22
runtime/src/serde_snapshot.rs
View File

@ -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,

4
runtime/src/serde_snapshot/future.rs
View File

@ -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,

28
runtime/src/serde_snapshot/tests.rs
View File

@ -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")]

22
runtime/src/snapshot_utils.rs
View File

@ -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]

10
runtime/tests/accounts.rs
View File

@ -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();

2
streamer/src/streamer.rs
View File

@ -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),