gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor: Cleanup program-runtime dyn Traits (#21395)

Browse Source 
* Unifies dyn Trait ComputeMeter, ThisComputeMeter and TransactionComputeMeter.

* Unifies dyn Trait Logger and ThisLogger.

* Moves Logger to log_collector.rs

* Unifies Logger and LogCollector.

* Removes inner RefCell from LogCollector.

* Adds the log::debug!() message to ic_logger_msg!() again.
This commit is contained in:
Alexander Meißner
2021-11-23 13:23:40 +01:00
committed by GitHub
parent cd5a39ee43
commit 22a2537aac
9 changed files with 302 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -17,7 +17,8 @@ use solana_measure::measure::Measure;
use solana_program_runtime::{
ic_logger_msg, ic_msg,
instruction_processor::{Executor, InstructionProcessor},
invoke_context::{ComputeMeter, InvokeContext, Logger},
invoke_context::{ComputeMeter, InvokeContext},
log_collector::LogCollector,
stable_log,
};
use solana_rbpf::{
@ -209,7 +210,7 @@ fn process_instruction_common(
invoke_context: &mut dyn InvokeContext,
use_jit: bool,
) -> Result<(), InstructionError> {
let logger = invoke_context.get_logger();
let log_collector = invoke_context.get_log_collector();
let program_id = invoke_context.get_caller()?;
let keyed_accounts = invoke_context.get_keyed_accounts()?;
@ -225,7 +226,7 @@ fn process_instruction_common(
(second_account?, first_instruction_account + 1)
} else {
if first_account.executable()? {
ic_logger_msg!(logger, "BPF loader is executable");
ic_logger_msg!(log_collector, "BPF loader is executable");
return Err(InstructionError::IncorrectProgramId);
}
(first_account, first_instruction_account)
@ -238,7 +239,10 @@ fn process_instruction_common(
);
if !check_loader_id(&program.owner()?) {
ic_logger_msg!(logger, "Executable account not owned by the BPF loader");
ic_logger_msg!(
log_collector,
"Executable account not owned by the BPF loader"
);
return Err(InstructionError::IncorrectProgramId);
}
@ -248,7 +252,10 @@ fn process_instruction_common(
} = program.state()?
{
if programdata_address != *first_account.unsigned_key() {
ic_logger_msg!(logger, "Wrong ProgramData account for this Program account");
ic_logger_msg!(
log_collector,
"Wrong ProgramData account for this Program account"
);
return Err(InstructionError::InvalidArgument);
}
if !matches!(
@ -258,12 +265,12 @@ fn process_instruction_common(
upgrade_authority_address: _,
}
) {
ic_logger_msg!(logger, "Program has been closed");
ic_logger_msg!(log_collector, "Program has been closed");
return Err(InstructionError::InvalidAccountData);
}
UpgradeableLoaderState::programdata_data_offset()?
} else {
ic_logger_msg!(logger, "Invalid Program account");
ic_logger_msg!(log_collector, "Invalid Program account");
return Err(InstructionError::InvalidAccountData);
}
} else {
@ -308,7 +315,7 @@ fn process_instruction_common(
use_jit,
)
} else {
ic_logger_msg!(logger, "Invalid BPF loader id");
ic_logger_msg!(log_collector, "Invalid BPF loader id");
Err(InstructionError::IncorrectProgramId)
}
}
@ -320,7 +327,7 @@ fn process_loader_upgradeable_instruction(
invoke_context: &mut dyn InvokeContext,
use_jit: bool,
) -> Result<(), InstructionError> {
let logger = invoke_context.get_logger();
let log_collector = invoke_context.get_log_collector();
let program_id = invoke_context.get_caller()?;
let keyed_accounts = invoke_context.get_keyed_accounts()?;
@ -329,7 +336,7 @@ fn process_loader_upgradeable_instruction(
let buffer = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
if UpgradeableLoaderState::Uninitialized != buffer.state()? {
ic_logger_msg!(logger, "Buffer account already initialized");
ic_logger_msg!(log_collector, "Buffer account already initialized");
return Err(InstructionError::AccountAlreadyInitialized);
}
@ -345,19 +352,19 @@ fn process_loader_upgradeable_instruction(
if let UpgradeableLoaderState::Buffer { authority_address } = buffer.state()? {
if authority_address.is_none() {
ic_logger_msg!(logger, "Buffer is immutable");
ic_logger_msg!(log_collector, "Buffer is immutable");
return Err(InstructionError::Immutable); // TODO better error code
}
if authority_address != Some(*authority.unsigned_key()) {
ic_logger_msg!(logger, "Incorrect buffer authority provided");
ic_logger_msg!(log_collector, "Incorrect buffer authority provided");
return Err(InstructionError::IncorrectAuthority);
}
if authority.signer_key().is_none() {
ic_logger_msg!(logger, "Buffer authority did not sign");
ic_logger_msg!(log_collector, "Buffer authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
} else {
ic_logger_msg!(logger, "Invalid Buffer account");
ic_logger_msg!(log_collector, "Invalid Buffer account");
return Err(InstructionError::InvalidAccountData);
}
write_program_data(
@ -388,15 +395,15 @@ fn process_loader_upgradeable_instruction(
// Verify Program account
if UpgradeableLoaderState::Uninitialized != program.state()? {
ic_logger_msg!(logger, "Program account already initialized");
ic_logger_msg!(log_collector, "Program account already initialized");
return Err(InstructionError::AccountAlreadyInitialized);
}
if program.data_len()? < UpgradeableLoaderState::program_len()? {
ic_logger_msg!(logger, "Program account too small");
ic_logger_msg!(log_collector, "Program account too small");
return Err(InstructionError::AccountDataTooSmall);
}
if program.lamports()? < rent.minimum_balance(program.data_len()?) {
ic_logger_msg!(logger, "Program account not rent-exempt");
ic_logger_msg!(log_collector, "Program account not rent-exempt");
return Err(InstructionError::ExecutableAccountNotRentExempt);
}
@ -406,15 +413,15 @@ fn process_loader_upgradeable_instruction(
if let UpgradeableLoaderState::Buffer { authority_address } = buffer.state()? {
if authority_address != upgrade_authority_address {
ic_logger_msg!(logger, "Buffer and upgrade authority don't match");
ic_logger_msg!(log_collector, "Buffer and upgrade authority don't match");
return Err(InstructionError::IncorrectAuthority);
}
if upgrade_authority_signer {
ic_logger_msg!(logger, "Upgrade authority did not sign");
ic_logger_msg!(log_collector, "Upgrade authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
} else {
ic_logger_msg!(logger, "Invalid Buffer account");
ic_logger_msg!(log_collector, "Invalid Buffer account");
return Err(InstructionError::InvalidArgument);
}
@ -426,15 +433,18 @@ fn process_loader_upgradeable_instruction(
if buffer.data_len()? < UpgradeableLoaderState::buffer_data_offset()?
|| buffer_data_len == 0
{
ic_logger_msg!(logger, "Buffer account too small");
ic_logger_msg!(log_collector, "Buffer account too small");
return Err(InstructionError::InvalidAccountData);
}
if max_data_len < buffer_data_len {
ic_logger_msg!(logger, "Max data length is too small to hold Buffer data");
ic_logger_msg!(
log_collector,
"Max data length is too small to hold Buffer data"
);
return Err(InstructionError::AccountDataTooSmall);
}
if programdata_len > MAX_PERMITTED_DATA_LENGTH as usize {
ic_logger_msg!(logger, "Max data length is too large");
ic_logger_msg!(log_collector, "Max data length is too large");
return Err(InstructionError::InvalidArgument);
}
@ -443,7 +453,7 @@ fn process_loader_upgradeable_instruction(
let (derived_address, bump_seed) =
Pubkey::find_program_address(&[new_program_id.as_ref()], program_id);
if derived_address != *programdata.unsigned_key() {
ic_logger_msg!(logger, "ProgramData address is not derived");
ic_logger_msg!(log_collector, "ProgramData address is not derived");
return Err(InstructionError::InvalidArgument);
}
@ -517,7 +527,7 @@ fn process_loader_upgradeable_instruction(
buffer.try_account_ref_mut()?.set_lamports(0);
}
ic_logger_msg!(logger, "Deployed program {:?}", new_program_id);
ic_logger_msg!(log_collector, "Deployed program {:?}", new_program_id);
}
UpgradeableLoaderInstruction::Upgrade => {
let programdata = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
@ -536,15 +546,15 @@ fn process_loader_upgradeable_instruction(
// Verify Program account
if !program.executable()? {
ic_logger_msg!(logger, "Program account not executable");
ic_logger_msg!(log_collector, "Program account not executable");
return Err(InstructionError::AccountNotExecutable);
}
if !program.is_writable() {
ic_logger_msg!(logger, "Program account not writeable");
ic_logger_msg!(log_collector, "Program account not writeable");
return Err(InstructionError::InvalidArgument);
}
if &program.owner()? != program_id {
ic_logger_msg!(logger, "Program account not owned by loader");
ic_logger_msg!(log_collector, "Program account not owned by loader");
return Err(InstructionError::IncorrectProgramId);
}
if let UpgradeableLoaderState::Program {
@ -552,11 +562,11 @@ fn process_loader_upgradeable_instruction(
} = program.state()?
{
if programdata_address != *programdata.unsigned_key() {
ic_logger_msg!(logger, "Program and ProgramData account mismatch");
ic_logger_msg!(log_collector, "Program and ProgramData account mismatch");
return Err(InstructionError::InvalidArgument);
}
} else {
ic_logger_msg!(logger, "Invalid Program account");
ic_logger_msg!(log_collector, "Invalid Program account");
return Err(InstructionError::InvalidAccountData);
}
@ -566,15 +576,15 @@ fn process_loader_upgradeable_instruction(
if let UpgradeableLoaderState::Buffer { authority_address } = buffer.state()? {
if authority_address != Some(*authority.unsigned_key()) {
ic_logger_msg!(logger, "Buffer and upgrade authority don't match");
ic_logger_msg!(log_collector, "Buffer and upgrade authority don't match");
return Err(InstructionError::IncorrectAuthority);
}
if authority.signer_key().is_none() {
ic_logger_msg!(logger, "Upgrade authority did not sign");
ic_logger_msg!(log_collector, "Upgrade authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
} else {
ic_logger_msg!(logger, "Invalid Buffer account");
ic_logger_msg!(log_collector, "Invalid Buffer account");
return Err(InstructionError::InvalidArgument);
}
@ -586,18 +596,21 @@ fn process_loader_upgradeable_instruction(
if buffer.data_len()? < UpgradeableLoaderState::buffer_data_offset()?
|| buffer_data_len == 0
{
ic_logger_msg!(logger, "Buffer account too small");
ic_logger_msg!(log_collector, "Buffer account too small");
return Err(InstructionError::InvalidAccountData);
}
// Verify ProgramData account
if programdata.data_len()? < UpgradeableLoaderState::programdata_len(buffer_data_len)? {
ic_logger_msg!(logger, "ProgramData account not large enough");
ic_logger_msg!(log_collector, "ProgramData account not large enough");
return Err(InstructionError::AccountDataTooSmall);
}
if programdata.lamports()? + buffer.lamports()? < programdata_balance_required {
ic_logger_msg!(logger, "Buffer account balance too low to fund upgrade");
ic_logger_msg!(
log_collector,
"Buffer account balance too low to fund upgrade"
);
return Err(InstructionError::InsufficientFunds);
}
if let UpgradeableLoaderState::ProgramData {
@ -606,19 +619,19 @@ fn process_loader_upgradeable_instruction(
} = programdata.state()?
{
if upgrade_authority_address.is_none() {
ic_logger_msg!(logger, "Program not upgradeable");
ic_logger_msg!(log_collector, "Program not upgradeable");
return Err(InstructionError::Immutable);
}
if upgrade_authority_address != Some(*authority.unsigned_key()) {
ic_logger_msg!(logger, "Incorrect upgrade authority provided");
ic_logger_msg!(log_collector, "Incorrect upgrade authority provided");
return Err(InstructionError::IncorrectAuthority);
}
if authority.signer_key().is_none() {
ic_logger_msg!(logger, "Upgrade authority did not sign");
ic_logger_msg!(log_collector, "Upgrade authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
} else {
ic_logger_msg!(logger, "Invalid ProgramData account");
ic_logger_msg!(log_collector, "Invalid ProgramData account");
return Err(InstructionError::InvalidAccountData);
}
@ -662,7 +675,7 @@ fn process_loader_upgradeable_instruction(
.try_account_ref_mut()?
.set_lamports(programdata_balance_required);
ic_logger_msg!(logger, "Upgraded program {:?}", new_program_id);
ic_logger_msg!(log_collector, "Upgraded program {:?}", new_program_id);
}
UpgradeableLoaderInstruction::SetAuthority => {
let account = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
@ -676,19 +689,19 @@ fn process_loader_upgradeable_instruction(
match account.state()? {
UpgradeableLoaderState::Buffer { authority_address } => {
if new_authority.is_none() {
ic_logger_msg!(logger, "Buffer authority is not optional");
ic_logger_msg!(log_collector, "Buffer authority is not optional");
return Err(InstructionError::IncorrectAuthority);
}
if authority_address.is_none() {
ic_logger_msg!(logger, "Buffer is immutable");
ic_logger_msg!(log_collector, "Buffer is immutable");
return Err(InstructionError::Immutable);
}
if authority_address != Some(*present_authority.unsigned_key()) {
ic_logger_msg!(logger, "Incorrect buffer authority provided");
ic_logger_msg!(log_collector, "Incorrect buffer authority provided");
return Err(InstructionError::IncorrectAuthority);
}
if present_authority.signer_key().is_none() {
ic_logger_msg!(logger, "Buffer authority did not sign");
ic_logger_msg!(log_collector, "Buffer authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
account.set_state(&UpgradeableLoaderState::Buffer {
@ -700,15 +713,15 @@ fn process_loader_upgradeable_instruction(
upgrade_authority_address,
} => {
if upgrade_authority_address.is_none() {
ic_logger_msg!(logger, "Program not upgradeable");
ic_logger_msg!(log_collector, "Program not upgradeable");
return Err(InstructionError::Immutable);
}
if upgrade_authority_address != Some(*present_authority.unsigned_key()) {
ic_logger_msg!(logger, "Incorrect upgrade authority provided");
ic_logger_msg!(log_collector, "Incorrect upgrade authority provided");
return Err(InstructionError::IncorrectAuthority);
}
if present_authority.signer_key().is_none() {
ic_logger_msg!(logger, "Upgrade authority did not sign");
ic_logger_msg!(log_collector, "Upgrade authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
account.set_state(&UpgradeableLoaderState::ProgramData {
@ -717,19 +730,22 @@ fn process_loader_upgradeable_instruction(
})?;
}
_ => {
ic_logger_msg!(logger, "Account does not support authorities");
ic_logger_msg!(log_collector, "Account does not support authorities");
return Err(InstructionError::InvalidArgument);
}
}
ic_logger_msg!(logger, "New authority {:?}", new_authority);
ic_logger_msg!(log_collector, "New authority {:?}", new_authority);
}
UpgradeableLoaderInstruction::Close => {
let close_account = keyed_account_at_index(keyed_accounts, first_instruction_account)?;
let recipient_account =
keyed_account_at_index(keyed_accounts, first_instruction_account + 1)?;
if close_account.unsigned_key() == recipient_account.unsigned_key() {
ic_logger_msg!(logger, "Recipient is the same as the account being closed");
ic_logger_msg!(
log_collector,
"Recipient is the same as the account being closed"
);
return Err(InstructionError::InvalidArgument);
}
@ -741,7 +757,7 @@ fn process_loader_upgradeable_instruction(
close_account.try_account_ref_mut()?.set_lamports(0);
ic_logger_msg!(
logger,
log_collector,
"Closed Uninitialized {}",
close_account.unsigned_key()
);
@ -755,10 +771,14 @@ fn process_loader_upgradeable_instruction(
authority,
close_account,
recipient_account,
logger.clone(),
&log_collector,
)?;
ic_logger_msg!(logger, "Closed Buffer {}", close_account.unsigned_key());
ic_logger_msg!(
log_collector,
"Closed Buffer {}",
close_account.unsigned_key()
);
}
UpgradeableLoaderState::ProgramData {
slot: _,
@ -768,11 +788,11 @@ fn process_loader_upgradeable_instruction(
keyed_account_at_index(keyed_accounts, first_instruction_account + 3)?;
if !program_account.is_writable() {
ic_logger_msg!(logger, "Program account is not writable");
ic_logger_msg!(log_collector, "Program account is not writable");
return Err(InstructionError::InvalidArgument);
}
if &program_account.owner()? != program_id {
ic_logger_msg!(logger, "Program account not owned by loader");
ic_logger_msg!(log_collector, "Program account not owned by loader");
return Err(InstructionError::IncorrectProgramId);
}
@ -782,7 +802,7 @@ fn process_loader_upgradeable_instruction(
} => {
if programdata_address != *close_account.unsigned_key() {
ic_logger_msg!(
logger,
log_collector,
"ProgramData account does not match ProgramData account"
);
return Err(InstructionError::InvalidArgument);
@ -797,19 +817,23 @@ fn process_loader_upgradeable_instruction(
authority,
close_account,
recipient_account,
logger.clone(),
&log_collector,
)?;
}
_ => {
ic_logger_msg!(logger, "Invalid Program account");
ic_logger_msg!(log_collector, "Invalid Program account");
return Err(InstructionError::InvalidArgument);
}
}
ic_logger_msg!(logger, "Closed Program {}", program_account.unsigned_key());
ic_logger_msg!(
log_collector,
"Closed Program {}",
program_account.unsigned_key()
);
}
_ => {
ic_logger_msg!(logger, "Account does not support closing");
ic_logger_msg!(log_collector, "Account does not support closing");
return Err(InstructionError::InvalidArgument);
}
}
@ -824,18 +848,18 @@ fn common_close_account(
authority_account: &KeyedAccount,
close_account: &KeyedAccount,
recipient_account: &KeyedAccount,
logger: Rc<RefCell<dyn Logger>>,
log_collector: &Option<Rc<RefCell<LogCollector>>>,
) -> Result<(), InstructionError> {
if authority_address.is_none() {
ic_logger_msg!(logger, "Account is immutable");
ic_logger_msg!(log_collector, "Account is immutable");
return Err(InstructionError::Immutable);
}
if *authority_address != Some(*authority_account.unsigned_key()) {
ic_logger_msg!(logger, "Incorrect authority provided");
ic_logger_msg!(log_collector, "Incorrect authority provided");
return Err(InstructionError::IncorrectAuthority);
}
if authority_account.signer_key().is_none() {
ic_logger_msg!(logger, "Authority did not sign");
ic_logger_msg!(log_collector, "Authority did not sign");
return Err(InstructionError::MissingRequiredSignature);
}
@ -901,10 +925,10 @@ fn process_loader_instruction(
/// Passed to the VM to enforce the compute budget
pub struct ThisInstructionMeter {
pub compute_meter: Rc<RefCell<dyn ComputeMeter>>,
pub compute_meter: Rc<RefCell<ComputeMeter>>,
}
impl ThisInstructionMeter {
fn new(compute_meter: Rc<RefCell<dyn ComputeMeter>>) -> Self {
fn new(compute_meter: Rc<RefCell<ComputeMeter>>) -> Self {
Self { compute_meter }
}
}
@ -939,7 +963,7 @@ impl Executor for BpfExecutor {
invoke_context: &mut dyn InvokeContext,
use_jit: bool,
) -> Result<(), InstructionError> {
let logger = invoke_context.get_logger();
let log_collector = invoke_context.get_log_collector();
let invoke_depth = invoke_context.invoke_depth();
let mut serialize_time = Measure::start("serialize");
@ -968,14 +992,14 @@ impl Executor for BpfExecutor {
) {
Ok(info) => info,
Err(e) => {
ic_logger_msg!(logger, "Failed to create BPF VM: {}", e);
ic_logger_msg!(log_collector, "Failed to create BPF VM: {}", e);
return Err(InstructionError::ProgramEnvironmentSetupFailure);
}
};
create_vm_time.stop();
execute_time = Measure::start("execute");
stable_log::program_invoke(&logger, program_id, invoke_depth);
stable_log::program_invoke(&log_collector, program_id, invoke_depth);
let mut instruction_meter = ThisInstructionMeter::new(compute_meter.clone());
let before = compute_meter.borrow().get_remaining();
let result = if use_jit {
@ -985,7 +1009,7 @@ impl Executor for BpfExecutor {
};
let after = compute_meter.borrow().get_remaining();
ic_logger_msg!(
logger,
log_collector,
"Program {} consumed {} of {} compute units",
program_id,
before - after,
@ -1001,13 +1025,13 @@ impl Executor for BpfExecutor {
drop(vm);
let (program_id, return_data) = invoke_context.get_return_data();
if !return_data.is_empty() {
stable_log::program_return(&logger, &program_id, return_data);
stable_log::program_return(&log_collector, &program_id, return_data);
}
match result {
Ok(status) => {
if status != SUCCESS {
let error: InstructionError = status.into();
stable_log::program_failure(&logger, &program_id, &error);
stable_log::program_failure(&log_collector, &program_id, &error);
return Err(error);
}
}
@ -1017,11 +1041,11 @@ impl Executor for BpfExecutor {
SyscallError::InstructionError(error),
)) => error,
err => {
ic_logger_msg!(logger, "Program failed to complete: {}", err);
ic_logger_msg!(log_collector, "Program failed to complete: {}", err);
InstructionError::ProgramFailedToComplete
}
};
stable_log::program_failure(&logger, &program_id, &error);
stable_log::program_failure(&log_collector, &program_id, &error);
return Err(error);
}
}
@ -1044,7 +1068,7 @@ impl Executor for BpfExecutor {
deserialize_time.as_us(),
);
let program_id = invoke_context.get_caller()?;
stable_log::program_success(&logger, program_id);
stable_log::program_success(&log_collector, program_id);
Ok(())
}
}

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

@ -1,9 +1,10 @@
use crate::{alloc, BpfError};
use alloc::Alloc;
use solana_program_runtime::{
ic_msg,
ic_logger_msg, ic_msg,
instruction_processor::InstructionProcessor,
invoke_context::{ComputeMeter, InvokeContext, Logger},
invoke_context::{ComputeMeter, InvokeContext},
log_collector::LogCollector,
stable_log,
};
use solana_rbpf::{
@ -97,7 +98,7 @@ impl From<SyscallError> for EbpfError<BpfError> {
trait SyscallConsume {
fn consume(&mut self, amount: u64) -> Result<(), EbpfError<BpfError>>;
}
impl SyscallConsume for Rc<RefCell<dyn ComputeMeter>> {
impl SyscallConsume for Rc<RefCell<ComputeMeter>> {
fn consume(&mut self, amount: u64) -> Result<(), EbpfError<BpfError>> {
self.try_borrow_mut()
.map_err(|_| SyscallError::InvokeContextBorrowFailed)?
@ -229,7 +230,7 @@ pub fn bind_syscall_context_objects<'a>(
vm.bind_syscall_context_object(
Box::new(SyscallLog {
compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(),
log_collector: invoke_context.get_log_collector(),
loader_id,
}),
None,
@ -238,7 +239,7 @@ pub fn bind_syscall_context_objects<'a>(
Box::new(SyscallLogU64 {
cost: compute_budget.log_64_units,
compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(),
log_collector: invoke_context.get_log_collector(),
}),
None,
)?;
@ -247,7 +248,7 @@ pub fn bind_syscall_context_objects<'a>(
Box::new(SyscallLogBpfComputeUnits {
cost: 0,
compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(),
log_collector: invoke_context.get_log_collector(),
}),
None,
)?;
@ -256,7 +257,7 @@ pub fn bind_syscall_context_objects<'a>(
Box::new(SyscallLogPubkey {
cost: compute_budget.log_pubkey_units,
compute_meter: invoke_context.get_compute_meter(),
logger: invoke_context.get_logger(),
log_collector: invoke_context.get_log_collector(),
loader_id,
}),
None,
@ -580,7 +581,7 @@ impl SyscallObject<BpfError> for SyscallAbort {
/// Causes the BPF program to be halted immediately
/// Log a user's info message
pub struct SyscallPanic<'a> {
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallPanic<'a> {
@ -607,8 +608,8 @@ impl<'a> SyscallObject<BpfError> for SyscallPanic<'a> {
/// Log a user's info message
pub struct SyscallLog<'a> {
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
logger: Rc<RefCell<dyn Logger>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
log_collector: Option<Rc<RefCell<LogCollector>>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallLog<'a> {
@ -630,7 +631,7 @@ impl<'a> SyscallObject<BpfError> for SyscallLog<'a> {
len,
self.loader_id,
&mut |string: &str| {
stable_log::program_log(&self.logger, string);
stable_log::program_log(&self.log_collector, string);
Ok(0)
},
),
@ -643,8 +644,8 @@ impl<'a> SyscallObject<BpfError> for SyscallLog<'a> {
/// Log 5 64-bit values
pub struct SyscallLogU64 {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
logger: Rc<RefCell<dyn Logger>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
log_collector: Option<Rc<RefCell<LogCollector>>>,
}
impl SyscallObject<BpfError> for SyscallLogU64 {
fn call(
@ -659,7 +660,7 @@ impl SyscallObject<BpfError> for SyscallLogU64 {
) {
question_mark!(self.compute_meter.consume(self.cost), result);
stable_log::program_log(
&self.logger,
&self.log_collector,
&format!(
"{:#x}, {:#x}, {:#x}, {:#x}, {:#x}",
arg1, arg2, arg3, arg4, arg5
@ -672,8 +673,8 @@ impl SyscallObject<BpfError> for SyscallLogU64 {
/// Log current compute consumption
pub struct SyscallLogBpfComputeUnits {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
logger: Rc<RefCell<dyn Logger>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
log_collector: Option<Rc<RefCell<LogCollector>>>,
}
impl SyscallObject<BpfError> for SyscallLogBpfComputeUnits {
fn call(
@ -687,18 +688,11 @@ impl SyscallObject<BpfError> for SyscallLogBpfComputeUnits {
result: &mut Result<u64, EbpfError<BpfError>>,
) {
question_mark!(self.compute_meter.consume(self.cost), result);
let logger = question_mark!(
self.logger
.try_borrow_mut()
.map_err(|_| SyscallError::InvokeContextBorrowFailed),
result
ic_logger_msg!(
self.log_collector,
"Program consumption: {} units remaining",
self.compute_meter.borrow().get_remaining()
);
if logger.log_enabled() {
logger.log(&format!(
"Program consumption: {} units remaining",
self.compute_meter.borrow().get_remaining()
));
}
*result = Ok(0);
}
}
@ -706,8 +700,8 @@ impl SyscallObject<BpfError> for SyscallLogBpfComputeUnits {
/// Log 5 64-bit values
pub struct SyscallLogPubkey<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
logger: Rc<RefCell<dyn Logger>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
log_collector: Option<Rc<RefCell<LogCollector>>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallLogPubkey<'a> {
@ -726,7 +720,7 @@ impl<'a> SyscallObject<BpfError> for SyscallLogPubkey<'a> {
translate_type::<Pubkey>(memory_mapping, pubkey_addr, self.loader_id,),
result
);
stable_log::program_log(&self.logger, &pubkey.to_string());
stable_log::program_log(&self.log_collector, &pubkey.to_string());
*result = Ok(0);
}
}
@ -809,7 +803,7 @@ fn translate_and_check_program_address_inputs<'a>(
/// Create a program address
struct SyscallCreateProgramAddress<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a> {
@ -855,7 +849,7 @@ impl<'a> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a> {
/// Create a program address
struct SyscallTryFindProgramAddress<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a> {
@ -916,7 +910,7 @@ impl<'a> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a> {
pub struct SyscallSha256<'a> {
sha256_base_cost: u64,
sha256_byte_cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallSha256<'a> {
@ -1097,7 +1091,7 @@ impl<'a> SyscallObject<BpfError> for SyscallGetRentSysvar<'a> {
pub struct SyscallKeccak256<'a> {
base_cost: u64,
byte_cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallKeccak256<'a> {
@ -1158,7 +1152,7 @@ fn check_overlapping(src_addr: u64, dst_addr: u64, n: u64) -> bool {
/// memcpy
pub struct SyscallMemcpy<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallMemcpy<'a> {
@ -1195,7 +1189,7 @@ impl<'a> SyscallObject<BpfError> for SyscallMemcpy<'a> {
/// memmove
pub struct SyscallMemmove<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallMemmove<'a> {
@ -1227,7 +1221,7 @@ impl<'a> SyscallObject<BpfError> for SyscallMemmove<'a> {
/// memcmp
pub struct SyscallMemcmp<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallMemcmp<'a> {
@ -1272,7 +1266,7 @@ impl<'a> SyscallObject<BpfError> for SyscallMemcmp<'a> {
/// memset
pub struct SyscallMemset<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallMemset<'a> {
@ -1301,7 +1295,7 @@ impl<'a> SyscallObject<BpfError> for SyscallMemset<'a> {
/// secp256k1_recover
pub struct SyscallSecp256k1Recover<'a> {
cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
libsecp256k1_0_5_upgrade_enabled: bool,
}
@ -1392,7 +1386,7 @@ impl<'a> SyscallObject<BpfError> for SyscallSecp256k1Recover<'a> {
pub struct SyscallBlake3<'a> {
base_cost: u64,
byte_cost: u64,
compute_meter: Rc<RefCell<dyn ComputeMeter>>,
compute_meter: Rc<RefCell<ComputeMeter>>,
loader_id: &'a Pubkey,
}
impl<'a> SyscallObject<BpfError> for SyscallBlake3<'a> {
@ -2429,9 +2423,9 @@ impl<'a> SyscallObject<BpfError> for SyscallLogData<'a> {
));
}
let logger = invoke_context.get_logger();
let log_collector = invoke_context.get_log_collector();
stable_log::program_data(&logger, &fields);
stable_log::program_data(&log_collector, &fields);
*result = Ok(0);
}
@ -2441,7 +2435,7 @@ impl<'a> SyscallObject<BpfError> for SyscallLogData<'a> {
mod tests {
use super::*;
use solana_program_runtime::{
invoke_context::{ThisComputeMeter, ThisInvokeContext, ThisLogger},
invoke_context::{ComputeMeter, ThisInvokeContext},
log_collector::LogCollector,
};
use solana_rbpf::{
@ -2776,7 +2770,7 @@ mod tests {
)
.unwrap();
let compute_meter = ThisComputeMeter::new_ref(string.len() as u64 - 1);
let compute_meter = ComputeMeter::new_ref(string.len() as u64 - 1);
let mut syscall_panic = SyscallPanic {
compute_meter,
loader_id: &bpf_loader::id(),
@ -2798,7 +2792,7 @@ mod tests {
result
);
let compute_meter = ThisComputeMeter::new_ref(string.len() as u64);
let compute_meter = ComputeMeter::new_ref(string.len() as u64);
let mut syscall_panic = SyscallPanic {
compute_meter,
loader_id: &bpf_loader::id(),
@ -2835,12 +2829,12 @@ mod tests {
&config,
)
.unwrap();
let log = Rc::new(LogCollector::default());
let log = LogCollector::new_ref();
{
let mut syscall_sol_log = SyscallLog {
compute_meter: ThisComputeMeter::new_ref(string.len() as u64),
logger: ThisLogger::new_ref(Some(log.clone())),
compute_meter: ComputeMeter::new_ref(string.len() as u64),
log_collector: Some(log.clone()),
loader_id: &bpf_loader::id(),
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
@ -2857,15 +2851,15 @@ mod tests {
}
let log: Vec<String> = match Rc::try_unwrap(log) {
Ok(log) => log.into(),
Ok(log) => log.into_inner().into(),
Err(_) => panic!("Unwrap failed"),
};
assert_eq!(log.len(), 1);
assert_eq!(log[0], "Program log: Gaggablaghblagh!");
let mut syscall_sol_log = SyscallLog {
compute_meter: ThisComputeMeter::new_ref(string.len() as u64 * 3),
logger: ThisLogger::new_ref(None),
compute_meter: ComputeMeter::new_ref(string.len() as u64 * 3),
log_collector: None,
loader_id: &bpf_loader::id(),
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
@ -2902,8 +2896,8 @@ mod tests {
);
let mut syscall_sol_log = SyscallLog {
compute_meter: ThisComputeMeter::new_ref((string.len() as u64 * 2) - 1),
logger: ThisLogger::new_ref(None),
compute_meter: ComputeMeter::new_ref((string.len() as u64 * 2) - 1),
log_collector: None,
loader_id: &bpf_loader::id(),
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
@ -2937,13 +2931,13 @@ mod tests {
#[test]
fn test_syscall_sol_log_u64() {
let log = Rc::new(LogCollector::default());
let log = LogCollector::new_ref();
{
let mut syscall_sol_log_u64 = SyscallLogU64 {
cost: 0,
compute_meter: ThisComputeMeter::new_ref(std::u64::MAX),
logger: ThisLogger::new_ref(Some(log.clone())),
compute_meter: ComputeMeter::new_ref(std::u64::MAX),
log_collector: Some(log.clone()),
};
let config = Config::default();
let memory_mapping = MemoryMapping::new::<UserError>(vec![], &config).unwrap();
@ -2953,7 +2947,7 @@ mod tests {
}
let log: Vec<String> = match Rc::try_unwrap(log) {
Ok(log) => log.into(),
Ok(log) => log.into_inner().into(),
Err(_) => panic!("Unwrap failed"),
};
assert_eq!(log.len(), 1);
@ -2979,13 +2973,13 @@ mod tests {
&config,
)
.unwrap();
let log = Rc::new(LogCollector::default());
let log = LogCollector::new_ref();
{
let mut syscall_sol_pubkey = SyscallLogPubkey {
cost: 1,
compute_meter: ThisComputeMeter::new_ref(1),
logger: ThisLogger::new_ref(Some(log.clone())),
compute_meter: ComputeMeter::new_ref(1),
log_collector: Some(log.clone()),
loader_id: &bpf_loader::id(),
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
@ -2994,7 +2988,7 @@ mod tests {
}
let log: Vec<String> = match Rc::try_unwrap(log) {
Ok(log) => log.into(),
Ok(log) => log.into_inner().into(),
Err(_) => panic!("Unwrap failed"),
};
assert_eq!(log.len(), 1);
@ -3005,8 +2999,8 @@ mod tests {
let mut syscall_sol_pubkey = SyscallLogPubkey {
cost: 1,
compute_meter: ThisComputeMeter::new_ref(1),
logger: ThisLogger::new_ref(None),
compute_meter: ComputeMeter::new_ref(1),
log_collector: None,
loader_id: &bpf_loader::id(),
};
let mut result: Result<u64, EbpfError<BpfError>> = Ok(0);
@ -3210,7 +3204,7 @@ mod tests {
&config,
)
.unwrap();
let compute_meter = ThisComputeMeter::new_ref((bytes1.len() + bytes2.len()) as u64);
let compute_meter = ComputeMeter::new_ref((bytes1.len() + bytes2.len()) as u64);
let mut syscall = SyscallSha256 {
sha256_base_cost: 0,
sha256_byte_cost: 2,
@ -3564,7 +3558,7 @@ mod tests {
) -> Result<Pubkey, EbpfError<BpfError>> {
let mut syscall = SyscallCreateProgramAddress {
cost: 1,
compute_meter: ThisComputeMeter::new_ref(remaining),
compute_meter: ComputeMeter::new_ref(remaining),
loader_id: &bpf_loader::id(),
};
let (address, _) = call_program_address_common(seeds, program_id, &mut syscall)?;
@ -3578,7 +3572,7 @@ mod tests {
) -> Result<(Pubkey, u8), EbpfError<BpfError>> {
let mut syscall = SyscallTryFindProgramAddress {
cost: 1,
compute_meter: ThisComputeMeter::new_ref(remaining),
compute_meter: ComputeMeter::new_ref(remaining),
loader_id: &bpf_loader::id(),
};
call_program_address_common(seeds, program_id, &mut syscall)