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

declare syscalls with macro (#24564)

This commit is contained in:
Jack May 2022-04-22 11:15:06 -07:00 committed by GitHub
parent 948abf00ac
commit 38bdb401a3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 164 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -515,19 +515,31 @@ fn translate_string_and_do(
type SyscallContext<'a, 'b> = Rc<RefCell<&'a mut InvokeContext<'b>>>; type SyscallContext<'a, 'b> = Rc<RefCell<&'a mut InvokeContext<'b>>>;
/// Abort syscall functions, called when the BPF program calls `abort()` macro_rules! declare_syscall {
/// LLVM will insert calls to `abort()` if it detects an untenable situation, ($(#[$attr:meta])* $name:ident, $call:item) => {
/// `abort()` is not intended to be called explicitly by the program. $(#[$attr])*
/// Causes the BPF program to be halted immediately pub struct $name<'a, 'b> {
pub struct SyscallAbort<'a, 'b> { invoke_context: SyscallContext<'a, 'b>,
invoke_context: SyscallContext<'a, 'b>, }
impl<'a, 'b> $name<'a, 'b> {
pub fn init(
invoke_context: SyscallContext<'a, 'b>,
) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for $name<'a, 'b> {
$call
}
};
} }
impl<'a, 'b> SyscallAbort<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> { declare_syscall!(
Box::new(Self { invoke_context }) /// Abort syscall functions, called when the BPF program calls `abort()`
} /// LLVM will insert calls to `abort()` if it detects an untenable situation,
} /// `abort()` is not intended to be called explicitly by the program.
impl<'a, 'b> SyscallObject<BpfError> for SyscallAbort<'a, 'b> { /// Causes the BPF program to be halted immediately
SyscallAbort,
fn call( fn call(
&mut self, &mut self,
_arg1: u64, _arg1: u64,
@ -546,20 +558,12 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallAbort<'a, 'b> {
); );
*result = Err(SyscallError::Abort.into()); *result = Err(SyscallError::Abort.into());
} }
} );
/// Panic syscall function, called when the BPF program calls 'sol_panic_()` declare_syscall!(
/// Causes the BPF program to be halted immediately /// Panic syscall function, called when the BPF program calls 'sol_panic_()`
/// Log a user's info message /// Causes the BPF program to be halted immediately
pub struct SyscallPanic<'a, 'b> { SyscallPanic,
invoke_context: SyscallContext<'a, 'b>,
}
impl<'a, 'b> SyscallPanic<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallPanic<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
file: u64, file: u64,
@ -592,18 +596,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallPanic<'a, 'b> {
&mut |string: &str| Err(SyscallError::Panic(string.to_string(), line, column).into()), &mut |string: &str| Err(SyscallError::Panic(string.to_string(), line, column).into()),
); );
} }
} );
/// Log a user's info message declare_syscall!(
pub struct SyscallLog<'a, 'b> { /// Log a user's info message
invoke_context: SyscallContext<'a, 'b>, SyscallLog,
}
impl<'a, 'b> SyscallLog<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallLog<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
addr: u64, addr: u64,
@ -649,18 +646,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallLog<'a, 'b> {
); );
*result = Ok(0); *result = Ok(0);
} }
} );
/// Log 5 64-bit values declare_syscall!(
pub struct SyscallLogU64<'a, 'b> { /// Log 5 64-bit values
invoke_context: SyscallContext<'a, 'b>, SyscallLogU64,
}
impl<'a, 'b> SyscallLogU64<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallLogU64<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
arg1: u64, arg1: u64,
@ -689,18 +679,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallLogU64<'a, 'b> {
); );
*result = Ok(0); *result = Ok(0);
} }
} );
/// Log current compute consumption declare_syscall!(
pub struct SyscallLogBpfComputeUnits<'a, 'b> { /// Log current compute consumption
invoke_context: SyscallContext<'a, 'b>, SyscallLogBpfComputeUnits,
}
impl<'a, 'b> SyscallLogBpfComputeUnits<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallLogBpfComputeUnits<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
_arg1: u64, _arg1: u64,
@ -734,18 +717,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallLogBpfComputeUnits<'a, 'b> {
); );
*result = Ok(0); *result = Ok(0);
} }
} );
/// Log 5 64-bit values declare_syscall!(
pub struct SyscallLogPubkey<'a, 'b> { /// Log 5 64-bit values
invoke_context: SyscallContext<'a, 'b>, SyscallLogPubkey,
}
impl<'a, 'b> SyscallLogPubkey<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallLogPubkey<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
pubkey_addr: u64, pubkey_addr: u64,
@ -776,23 +752,16 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallLogPubkey<'a, 'b> {
stable_log::program_log(&invoke_context.get_log_collector(), &pubkey.to_string()); stable_log::program_log(&invoke_context.get_log_collector(), &pubkey.to_string());
*result = Ok(0); *result = Ok(0);
} }
} );
/// Dynamic memory allocation syscall called when the BPF program calls declare_syscall!(
/// `sol_alloc_free_()`. The allocator is expected to allocate/free /// Dynamic memory allocation syscall called when the BPF program calls
/// from/to a given chunk of memory and enforce size restrictions. The /// `sol_alloc_free_()`. The allocator is expected to allocate/free
/// memory chunk is given to the allocator during allocator creation and /// from/to a given chunk of memory and enforce size restrictions. The
/// information about that memory (start address and size) is passed /// memory chunk is given to the allocator during allocator creation and
/// to the VM to use for enforcement. /// information about that memory (start address and size) is passed
pub struct SyscallAllocFree<'a, 'b> { /// to the VM to use for enforcement.
invoke_context: SyscallContext<'a, 'b>, SyscallAllocFree,
}
impl<'a, 'b> SyscallAllocFree<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallAllocFree<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
size: u64, size: u64,
@ -844,7 +813,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallAllocFree<'a, 'b> {
Ok(0) Ok(0)
}; };
} }
} );
fn translate_and_check_program_address_inputs<'a>( fn translate_and_check_program_address_inputs<'a>(
seeds_addr: u64, seeds_addr: u64,
@ -883,16 +852,9 @@ fn translate_and_check_program_address_inputs<'a>(
Ok((seeds, program_id)) Ok((seeds, program_id))
} }
/// Create a program address declare_syscall!(
struct SyscallCreateProgramAddress<'a, 'b> { /// Create a program address
invoke_context: SyscallContext<'a, 'b>, SyscallCreateProgramAddress,
}
impl<'a, 'b> SyscallCreateProgramAddress<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
seeds_addr: u64, seeds_addr: u64,
@ -946,18 +908,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallCreateProgramAddress<'a, 'b> {
address.copy_from_slice(new_address.as_ref()); address.copy_from_slice(new_address.as_ref());
*result = Ok(0); *result = Ok(0);
} }
} );
/// Create a program address declare_syscall!(
struct SyscallTryFindProgramAddress<'a, 'b> { /// Create a program address
invoke_context: SyscallContext<'a, 'b>, SyscallTryFindProgramAddress,
}
impl<'a, 'b> SyscallTryFindProgramAddress<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
seeds_addr: u64, seeds_addr: u64,
@ -1029,18 +984,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallTryFindProgramAddress<'a, 'b> {
} }
*result = Ok(1); *result = Ok(1);
} }
} );
/// SHA256 declare_syscall!(
pub struct SyscallSha256<'a, 'b> { /// SHA256
invoke_context: SyscallContext<'a, 'b>, SyscallSha256,
}
impl<'a, 'b> SyscallSha256<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallSha256<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
vals_addr: u64, vals_addr: u64,
@ -1133,7 +1081,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallSha256<'a, 'b> {
hash_result.copy_from_slice(&hasher.result().to_bytes()); hash_result.copy_from_slice(&hasher.result().to_bytes());
*result = Ok(0); *result = Ok(0);
} }
} );
fn get_sysvar<T: std::fmt::Debug + Sysvar + SysvarId + Clone>( fn get_sysvar<T: std::fmt::Debug + Sysvar + SysvarId + Clone>(
sysvar: Result<Arc<T>, InstructionError>, sysvar: Result<Arc<T>, InstructionError>,
@ -1156,16 +1104,9 @@ fn get_sysvar<T: std::fmt::Debug + Sysvar + SysvarId + Clone>(
Ok(SUCCESS) Ok(SUCCESS)
} }
/// Get a Clock sysvar declare_syscall!(
struct SyscallGetClockSysvar<'a, 'b> { /// Get a Clock sysvar
invoke_context: SyscallContext<'a, 'b>, SyscallGetClockSysvar,
}
impl<'a, 'b> SyscallGetClockSysvar<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetClockSysvar<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
var_addr: u64, var_addr: u64,
@ -1190,17 +1131,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetClockSysvar<'a, 'b> {
&mut invoke_context, &mut invoke_context,
); );
} }
} );
/// Get a EpochSchedule sysvar
struct SyscallGetEpochScheduleSysvar<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// Get a EpochSchedule sysvar
} SyscallGetEpochScheduleSysvar,
impl<'a, 'b> SyscallGetEpochScheduleSysvar<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetEpochScheduleSysvar<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
var_addr: u64, var_addr: u64,
@ -1225,18 +1160,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetEpochScheduleSysvar<'a, 'b> {
&mut invoke_context, &mut invoke_context,
); );
} }
} );
/// Get a Fees sysvar
struct SyscallGetFeesSysvar<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// Get a Fees sysvar
} SyscallGetFeesSysvar,
impl<'a, 'b> SyscallGetFeesSysvar<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
#[allow(deprecated)]
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetFeesSysvar<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
var_addr: u64, var_addr: u64,
@ -1253,25 +1181,22 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetFeesSysvar<'a, 'b> {
.map_err(|_| SyscallError::InvokeContextBorrowFailed), .map_err(|_| SyscallError::InvokeContextBorrowFailed),
result result
); );
*result = get_sysvar( #[allow(deprecated)]
invoke_context.get_sysvar_cache().get_fees(), {
var_addr, *result = get_sysvar(
invoke_context.get_check_aligned(), invoke_context.get_sysvar_cache().get_fees(),
memory_mapping, var_addr,
&mut invoke_context, invoke_context.get_check_aligned(),
); memory_mapping,
&mut invoke_context,
);
}
} }
} );
/// Get a Rent sysvar
struct SyscallGetRentSysvar<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// Get a Rent sysvar
} SyscallGetRentSysvar,
impl<'a, 'b> SyscallGetRentSysvar<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetRentSysvar<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
var_addr: u64, var_addr: u64,
@ -1296,18 +1221,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetRentSysvar<'a, 'b> {
&mut invoke_context, &mut invoke_context,
); );
} }
} );
// Keccak256 declare_syscall!(
pub struct SyscallKeccak256<'a, 'b> { // Keccak256
invoke_context: SyscallContext<'a, 'b>, SyscallKeccak256,
}
impl<'a, 'b> SyscallKeccak256<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallKeccak256<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
vals_addr: u64, vals_addr: u64,
@ -1400,7 +1318,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallKeccak256<'a, 'b> {
hash_result.copy_from_slice(&hasher.result().to_bytes()); hash_result.copy_from_slice(&hasher.result().to_bytes());
*result = Ok(0); *result = Ok(0);
} }
} );
/// This function is incorrect due to arithmetic overflow and only exists for /// This function is incorrect due to arithmetic overflow and only exists for
/// backwards compatibility. Instead use program_stubs::is_nonoverlapping. /// backwards compatibility. Instead use program_stubs::is_nonoverlapping.
@ -1428,16 +1346,9 @@ fn mem_op_consume<'a, 'b>(
invoke_context.get_compute_meter().consume(cost) invoke_context.get_compute_meter().consume(cost)
} }
/// memcpy declare_syscall!(
pub struct SyscallMemcpy<'a, 'b> { /// memcpy
invoke_context: SyscallContext<'a, 'b>, SyscallMemcpy,
}
impl<'a, 'b> SyscallMemcpy<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallMemcpy<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
dst_addr: u64, dst_addr: u64,
@ -1526,17 +1437,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallMemcpy<'a, 'b> {
} }
*result = Ok(0); *result = Ok(0);
} }
} );
/// memmove
pub struct SyscallMemmove<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// memmove
} SyscallMemmove,
impl<'a, 'b> SyscallMemmove<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallMemmove<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
dst_addr: u64, dst_addr: u64,
@ -1580,17 +1485,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallMemmove<'a, 'b> {
} }
*result = Ok(0); *result = Ok(0);
} }
} );
/// memcmp
pub struct SyscallMemcmp<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// memcmp
} SyscallMemcmp,
impl<'a, 'b> SyscallMemcmp<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallMemcmp<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
s1_addr: u64, s1_addr: u64,
@ -1661,17 +1560,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallMemcmp<'a, 'b> {
*cmp_result = 0; *cmp_result = 0;
*result = Ok(0); *result = Ok(0);
} }
} );
/// memset
pub struct SyscallMemset<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// memset
} SyscallMemset,
impl<'a, 'b> SyscallMemset<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallMemset<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
s_addr: u64, s_addr: u64,
@ -1705,18 +1598,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallMemset<'a, 'b> {
} }
*result = Ok(0); *result = Ok(0);
} }
} );
/// secp256k1_recover declare_syscall!(
pub struct SyscallSecp256k1Recover<'a, 'b> { /// secp256k1_recover
invoke_context: SyscallContext<'a, 'b>, SyscallSecp256k1Recover,
}
impl<'a, 'b> SyscallSecp256k1Recover<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallSecp256k1Recover<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
hash_addr: u64, hash_addr: u64,
@ -1823,17 +1709,10 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallSecp256k1Recover<'a, 'b> {
secp256k1_recover_result.copy_from_slice(&public_key[1..65]); secp256k1_recover_result.copy_from_slice(&public_key[1..65]);
*result = Ok(SUCCESS); *result = Ok(SUCCESS);
} }
} );
pub struct SyscallZkTokenElgamalOp<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, SyscallZkTokenElgamalOp,
}
impl<'a, 'b> SyscallZkTokenElgamalOp<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallZkTokenElgamalOp<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
op: u64, op: u64,
@ -1890,17 +1769,10 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallZkTokenElgamalOp<'a, 'b> {
*result = Ok(1); *result = Ok(1);
} }
} }
} );
pub struct SyscallZkTokenElgamalOpWithLoHi<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, SyscallZkTokenElgamalOpWithLoHi,
}
impl<'a, 'b> SyscallZkTokenElgamalOpWithLoHi<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallZkTokenElgamalOpWithLoHi<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
op: u64, op: u64,
@ -1965,17 +1837,10 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallZkTokenElgamalOpWithLoHi<'a, 'b>
*result = Ok(1); *result = Ok(1);
} }
} }
} );
pub struct SyscallZkTokenElgamalOpWithScalar<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, SyscallZkTokenElgamalOpWithScalar,
}
impl<'a, 'b> SyscallZkTokenElgamalOpWithScalar<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallZkTokenElgamalOpWithScalar<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
op: u64, op: u64,
@ -2024,18 +1889,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallZkTokenElgamalOpWithScalar<'a, '
*result = Ok(1); *result = Ok(1);
} }
} }
} );
// Blake3 declare_syscall!(
pub struct SyscallBlake3<'a, 'b> { // Blake3
invoke_context: SyscallContext<'a, 'b>, SyscallBlake3,
}
impl<'a, 'b> SyscallBlake3<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallBlake3<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
vals_addr: u64, vals_addr: u64,
@ -2136,7 +1994,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallBlake3<'a, 'b> {
hash_result.copy_from_slice(&hasher.result().to_bytes()); hash_result.copy_from_slice(&hasher.result().to_bytes());
*result = Ok(0); *result = Ok(0);
} }
} );
// Cross-program invocation syscalls // Cross-program invocation syscalls
@ -2181,16 +2039,9 @@ trait SyscallInvokeSigned<'a, 'b> {
) -> Result<Vec<Pubkey>, EbpfError<BpfError>>; ) -> Result<Vec<Pubkey>, EbpfError<BpfError>>;
} }
/// Cross-SyscallInvokeSignedRust invocation called from Rust declare_syscall!(
pub struct SyscallInvokeSignedRust<'a, 'b> { /// Cross-program invocation called from Rust
invoke_context: SyscallContext<'a, 'b>, SyscallInvokeSignedRust,
}
impl<'a, 'b> SyscallInvokeSignedRust<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallInvokeSignedRust<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
instruction_addr: u64, instruction_addr: u64,
@ -2211,7 +2062,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallInvokeSignedRust<'a, 'b> {
memory_mapping, memory_mapping,
); );
} }
} );
impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedRust<'a, 'b> { impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedRust<'a, 'b> {
fn get_context_mut(&self) -> Result<RefMut<&'a mut InvokeContext<'b>>, EbpfError<BpfError>> { fn get_context_mut(&self) -> Result<RefMut<&'a mut InvokeContext<'b>>, EbpfError<BpfError>> {
@ -2479,16 +2330,9 @@ struct SolSignerSeedsC {
len: u64, len: u64,
} }
/// Cross-program invocation called from C declare_syscall!(
pub struct SyscallInvokeSignedC<'a, 'b> { /// Cross-program invocation called from C
invoke_context: SyscallContext<'a, 'b>, SyscallInvokeSignedC,
}
impl<'a, 'b> SyscallInvokeSignedC<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallInvokeSignedC<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
instruction_addr: u64, instruction_addr: u64,
@ -2509,7 +2353,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallInvokeSignedC<'a, 'b> {
memory_mapping, memory_mapping,
); );
} }
} );
impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedC<'a, 'b> { impl<'a, 'b> SyscallInvokeSigned<'a, 'b> for SyscallInvokeSignedC<'a, 'b> {
fn get_context_mut(&self) -> Result<RefMut<&'a mut InvokeContext<'b>>, EbpfError<BpfError>> { fn get_context_mut(&self) -> Result<RefMut<&'a mut InvokeContext<'b>>, EbpfError<BpfError>> {
@ -3079,16 +2923,9 @@ fn call<'a, 'b: 'a>(
Ok(SUCCESS) Ok(SUCCESS)
} }
// Return data handling declare_syscall!(
pub struct SyscallSetReturnData<'a, 'b> { /// Set return data
invoke_context: SyscallContext<'a, 'b>, SyscallSetReturnData,
}
impl<'a, 'b> SyscallSetReturnData<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallSetReturnData<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
addr: u64, addr: u64,
@ -3160,17 +2997,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallSetReturnData<'a, 'b> {
*result = Ok(0); *result = Ok(0);
} }
} );
pub struct SyscallGetReturnData<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// Get return data
} SyscallGetReturnData,
impl<'a, 'b> SyscallGetReturnData<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetReturnData<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
return_data_addr: u64, return_data_addr: u64,
@ -3253,18 +3084,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetReturnData<'a, 'b> {
// Return the actual length, rather the length returned // Return the actual length, rather the length returned
*result = Ok(return_data.len() as u64); *result = Ok(return_data.len() as u64);
} }
} );
// Log data handling declare_syscall!(
pub struct SyscallLogData<'a, 'b> { /// Log data handling
invoke_context: SyscallContext<'a, 'b>, SyscallLogData,
}
impl<'a, 'b> SyscallLogData<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallLogData<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
addr: u64, addr: u64,
@ -3339,17 +3163,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallLogData<'a, 'b> {
*result = Ok(0); *result = Ok(0);
} }
} );
pub struct SyscallGetProcessedSiblingInstruction<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// Get a processed sigling instruction
} SyscallGetProcessedSiblingInstruction,
impl<'a, 'b> SyscallGetProcessedSiblingInstruction<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetProcessedSiblingInstruction<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
index: u64, index: u64,
@ -3473,17 +3291,11 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetProcessedSiblingInstruction<'
} }
*result = Ok(false as u64); *result = Ok(false as u64);
} }
} );
pub struct SyscallGetStackHeight<'a, 'b> { declare_syscall!(
invoke_context: SyscallContext<'a, 'b>, /// Get current call stack height
} SyscallGetStackHeight,
impl<'a, 'b> SyscallGetStackHeight<'a, 'b> {
pub fn init(invoke_context: SyscallContext<'a, 'b>) -> Box<(dyn SyscallObject<BpfError> + 'a)> {
Box::new(Self { invoke_context })
}
}
impl<'a, 'b> SyscallObject<BpfError> for SyscallGetStackHeight<'a, 'b> {
fn call( fn call(
&mut self, &mut self,
_arg1: u64, _arg1: u64,
@ -3511,7 +3323,7 @@ impl<'a, 'b> SyscallObject<BpfError> for SyscallGetStackHeight<'a, 'b> {
*result = Ok(invoke_context.get_stack_height() as u64); *result = Ok(invoke_context.get_stack_height() as u64);
} }
} );
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {