Turn dynamic borrow panics into HostErrors

soroban-env-host/src/budget.rs

@@ -7,6 +7,7 @@ use std::{
 use soroban_env_common::xdr::{ScErrorCode, ScErrorType};
 
 use crate::{
+ host::error::TryBorrowOrErr,
  xdr::{ContractCostParamEntry, ContractCostParams, ContractCostType, ExtensionPoint},
  Host, HostError,
 };
@@ -412,13 +413,13 @@ pub struct Budget(pub(crate) Rc<RefCell<BudgetImpl>>);
 
 impl Debug for Budget {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- writeln!(f, "{:?}", self.0.borrow())
+ writeln!(f, "{:?}", self.0.try_borrow().map_err(|_| std::fmt::Error)?)
  }
 }
 
 impl Display for Budget {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- writeln!(f, "{}", self.0.borrow())
+ writeln!(f, "{}", self.0.try_borrow().map_err(|_| std::fmt::Error)?)
  }
 }
 
@@ -465,7 +466,7 @@ impl Budget {
  where
  F: FnOnce(RefMut<BudgetImpl>) -> Result<T, HostError>,
  {
- f(self.0.borrow_mut())
+ f(self.0.try_borrow_mut_or_err()?)
  }
 
  fn charge_in_bulk(
@@ -474,7 +475,7 @@ impl Budget {
  iterations: u64,
  input: Option<u64>,
  ) -> Result<(), HostError> {
- if !self.0.borrow().enabled {
+ if !self.0.try_borrow_or_err()?.enabled {
  return Ok(());
  }
 
@@ -562,98 +563,97 @@ impl Budget {
  res
  }
 
- pub fn get_tracker(&self, ty: ContractCostType) -> (u64, Option<u64>) {
- self.0.borrow().tracker[ty as usize]
+ pub fn get_tracker(&self, ty: ContractCostType) -> Result<(u64, Option<u64>), HostError> {
+ Ok(self.0.try_borrow_or_err()?.tracker[ty as usize])
  }
 
  pub(crate) fn get_tracker_mut<F>(&self, ty: ContractCostType, f: F) -> Result<(), HostError>
  where
  F: FnOnce(&mut (u64, Option<u64>)) -> Result<(), HostError>,
  {
- f(&mut self.0.borrow_mut().tracker[ty as usize])
+ f(&mut self.0.try_borrow_mut_or_err()?.tracker[ty as usize])
  }
 
- pub fn get_cpu_insns_consumed(&self) -> u64 {
- self.0.borrow().cpu_insns.get_total_count()
+ pub fn get_cpu_insns_consumed(&self) -> Result<u64, HostError> {
+ Ok(self.0.try_borrow_or_err()?.cpu_insns.get_total_count())
  }
 
- pub fn get_mem_bytes_consumed(&self) -> u64 {
- self.0.borrow().mem_bytes.get_total_count()
+ pub fn get_mem_bytes_consumed(&self) -> Result<u64, HostError> {
+ Ok(self.0.try_borrow_or_err()?.mem_bytes.get_total_count())
  }
 
- pub fn get_cpu_insns_remaining(&self) -> u64 {
- self.0.borrow().cpu_insns.get_remaining()
+ pub fn get_cpu_insns_remaining(&self) -> Result<u64, HostError> {
+ Ok(self.0.try_borrow_or_err()?.cpu_insns.get_remaining())
  }
 
- pub fn get_mem_bytes_remaining(&self) -> u64 {
- self.0.borrow().mem_bytes.get_remaining()
+ pub fn get_mem_bytes_remaining(&self) -> Result<u64, HostError> {
+ Ok(self.0.try_borrow_or_err()?.mem_bytes.get_remaining())
  }
 
- pub fn reset_default(&self) {
- *self.0.borrow_mut() = BudgetImpl::default()
+ pub fn reset_default(&self) -> Result<(), HostError> {
+ *self.0.try_borrow_mut_or_err()? = BudgetImpl::default();
+ Ok(())
  }
 
- pub fn reset_unlimited(&self) {
- self.reset_unlimited_cpu();
- self.reset_unlimited_mem();
+ pub fn reset_unlimited(&self) -> Result<(), HostError> {
+ self.reset_unlimited_cpu()?;
+ self.reset_unlimited_mem()?;
+ Ok(())
  }
 
- pub fn reset_unlimited_cpu(&self) {
+ pub fn reset_unlimited_cpu(&self) -> Result<(), HostError> {
  self.mut_budget(|mut b| {
  b.cpu_insns.reset(u64::MAX);
  Ok(())
- })
- .unwrap(); // panic means multiple-mut-borrow bug
+ })?; // panic means multiple-mut-borrow bug
  self.reset_tracker()
  }
 
- pub fn reset_unlimited_mem(&self) {
+ pub fn reset_unlimited_mem(&self) -> Result<(), HostError> {
  self.mut_budget(|mut b| {
  b.mem_bytes.reset(u64::MAX);
  Ok(())
- })
- .unwrap(); // panic means multiple-mut-borrow bug
+ })?;
  self.reset_tracker()
  }
 
- pub fn reset_tracker(&self) {
- for tracker in self.0.borrow_mut().tracker.iter_mut() {
+ pub fn reset_tracker(&self) -> Result<(), HostError> {
+ for tracker in self.0.try_borrow_mut_or_err()?.tracker.iter_mut() {
  tracker.0 = 0;
  tracker.1 = tracker.1.map(|_| 0);
  }
+ Ok(())
  }
 
- pub fn reset_limits(&self, cpu: u64, mem: u64) {
+ pub fn reset_limits(&self, cpu: u64, mem: u64) -> Result<(), HostError> {
  self.mut_budget(|mut b| {
  b.cpu_insns.reset(cpu);
  b.mem_bytes.reset(mem);
  Ok(())
- })
- .unwrap(); // impossible to panic
-
+ })?;
  self.reset_tracker()
  }
 
  #[cfg(test)]
- pub fn reset_models(&self) {
+ pub fn reset_models(&self) -> Result<(), HostError> {
  self.mut_budget(|mut b| {
  b.cpu_insns.reset_models();
  b.mem_bytes.reset_models();
  Ok(())
  })
- .unwrap(); // impossible to panic
  }
 
  #[cfg(any(test, feature = "testutils"))]
- pub fn reset_fuel_config(&self) {
- self.0.borrow_mut().fuel_config.reset()
+ pub fn reset_fuel_config(&self) -> Result<(), HostError> {
+ self.0.try_borrow_mut_or_err()?.fuel_config.reset();
+ Ok(())
  }
 
  fn get_cpu_insns_remaining_as_fuel(&self) -> Result<u64, HostError> {
- let cpu_remaining = self.get_cpu_insns_remaining();
+ let cpu_remaining = self.get_cpu_insns_remaining()?;
  let cpu_per_fuel = self
  .0
- .borrow()
+ .try_borrow_or_err()?
  .cpu_insns
  .get_cost_model(ContractCostType::WasmInsnExec)
  .linear_term;
@@ -676,10 +676,10 @@ impl Budget {
  }
 
  fn get_mem_bytes_remaining_as_fuel(&self) -> Result<u64, HostError> {
- let bytes_remaining = self.get_mem_bytes_remaining();
+ let bytes_remaining = self.get_mem_bytes_remaining()?;
  let bytes_per_fuel = self
  .0
- .borrow()
+ .try_borrow_or_err()?
  .mem_bytes
  .get_cost_model(ContractCostType::WasmMemAlloc)
  .linear_term;
@@ -699,15 +699,15 @@ impl Budget {
  }
 
  // generate a wasmi fuel cost schedule based on our calibration
- pub fn wasmi_fuel_costs(&self) -> FuelCosts {
- let config = &self.0.borrow().fuel_config;
+ pub fn wasmi_fuel_costs(&self) -> Result<FuelCosts, HostError> {
+ let config = &self.0.try_borrow_or_err()?.fuel_config;
  let mut costs = FuelCosts::default();
  costs.base = config.base;
  costs.entity = config.entity;
  costs.load = config.load;
  costs.store = config.store;
  costs.call = config.call;
- costs
+ Ok(costs)
  }
 }
 

soroban-env-host/src/cost_runner/cost_types/vm_ops.rs

@@ -52,10 +52,19 @@ impl CostRunner for VmMemReadRun {
  _iter: u64,
  mut sample: Self::SampleType,
  ) -> Self::RecycledType {
- black_box(sample.vm.with_vmcaller(|caller| {
- host.metered_vm_read_bytes_from_linear_memory(caller, &sample.vm, 0, &mut sample.buf)
- .unwrap()
- }));
+ black_box(
+ sample
+ .vm
+ .with_vmcaller(|caller| {
+ host.metered_vm_read_bytes_from_linear_memory(
+ caller,
+ &sample.vm,
+ 0,
+ &mut sample.buf,
+ )
+ })
+ .unwrap(),
+ );
  sample
  }
 
@@ -82,10 +91,19 @@ impl CostRunner for VmMemWriteRun {
  _iter: u64,
  mut sample: Self::SampleType,
  ) -> Self::RecycledType {
- black_box(sample.vm.with_vmcaller(|caller| {
- host.metered_vm_write_bytes_to_linear_memory(caller, &sample.vm, 0, &mut sample.buf)
- .unwrap()
- }));
+ black_box(
+ sample
+ .vm
+ .with_vmcaller(|caller| {
+ host.metered_vm_write_bytes_to_linear_memory(
+ caller,
+ &sample.vm,
+ 0,
+ &mut sample.buf,
+ )
+ })
+ .unwrap(),
+ );
  sample
  }
 

soroban-env-host/src/cost_runner/runner.rs

@@ -66,6 +66,6 @@ pub trait CostRunner: Sized {
  /// actual input from the host's perspective. So use it carefully. This should be
  /// after the `run`, outside of the CPU-and-memory tracking machineary.
  fn get_tracker(host: &Host) -> (u64, Option<u64>) {
- host.0.budget.get_tracker(Self::COST_TYPE)
+ host.0.budget.get_tracker(Self::COST_TYPE).unwrap()
  }
 }

soroban-env-host/src/events/diagnostic.rs

@@ -21,17 +21,21 @@ pub enum DiagnosticLevel {
 
 /// None of these functions are metered, which is why they're behind the is_debug check
 impl Host {
- pub fn set_diagnostic_level(&self, diagnostic_level: DiagnosticLevel) {
- *self.0.diagnostic_level.borrow_mut() = diagnostic_level;
+ pub fn set_diagnostic_level(&self, diagnostic_level: DiagnosticLevel) -> Result<(), HostError> {
+ *self.try_borrow_diagnostic_level_mut()? = diagnostic_level;
+ Ok(())
  }
 
  // As above, avoids having to import DiagnosticLevel.
- pub fn enable_debug(&self) {
+ pub fn enable_debug(&self) -> Result<(), HostError> {
  self.set_diagnostic_level(DiagnosticLevel::Debug)
  }
 
- pub fn is_debug(&self) -> bool {
- matches!(*self.0.diagnostic_level.borrow(), DiagnosticLevel::Debug)
+ pub fn is_debug(&self) -> Result<bool, HostError> {
+ Ok(matches!(
+ *self.try_borrow_diagnostic_level()?,
+ DiagnosticLevel::Debug
+ ))
  }
 
  /// Records a `System` contract event. `topics` is expected to be a `SCVec`
@@ -70,7 +74,7 @@ impl Host {
  }
 
  pub fn log_diagnostics(&self, msg: &str, args: &[Val]) -> Result<(), HostError> {
- if !self.is_debug() {
+ if !self.is_debug()? {
  return Ok(());
  }
  let calling_contract = self.get_current_contract_id_unmetered()?;
@@ -92,7 +96,7 @@ impl Host {
  msg: &str,
  args: &[Val],
  ) -> Result<(), HostError> {
- if !self.is_debug() {
+ if !self.is_debug()? {
  return Ok(());
  }
 
@@ -130,7 +134,7 @@ impl Host {
  func: &Symbol,
  args: &[Val],
  ) -> Result<(), HostError> {
- if !self.is_debug() {
+ if !self.is_debug()? {
  return Ok(());
  }
 
@@ -162,7 +166,7 @@ impl Host {
  func: &Symbol,
  res: &Val,
  ) -> Result<(), HostError> {
- if !self.is_debug() {
+ if !self.is_debug()? {
  return Ok(());
  }
 

soroban-env-host/src/events/mod.rs

@@ -145,11 +145,11 @@ impl Host {
  where
  F: FnOnce(&mut InternalEventsBuffer) -> Result<U, HostError>,
  {
- f(&mut self.0.events.borrow_mut())
+ f(&mut *self.try_borrow_events_mut()?)
  }
 
  pub fn get_events(&self) -> Result<Events, HostError> {
- self.0.events.borrow().externalize(self)
+ self.try_borrow_events()?.externalize(self)
  }
 
  // Records a contract event.