Struct hotpatch::Patchable

pub struct Patchable<Args, Ret> { /* fields omitted */ }

Created by #[patchable]. A functor capable of overwriting its own function.

Implementations

impl<Args: 'static, Ret: 'static> Patchable<Args, Ret>

pub fn hotpatch_lib(&self, lib_name: &str) -> Result<(), Box<dyn Error>>

Hotpatch this functor with functionality defined in lib_name. Will search a shared object cdylib file for #[patch] exports, finding the definition that matches module path and signature.

Example

#[patchable]
fn foo() {}

fn main() -> Result<(), Box<dyn std::error::Error>> {
  foo(); // does something
  foo.hotpatch_lib("libtest.so")?;
  foo(); // does something else
  Ok(())
}

pub fn try_hotpatch_lib(&self, lib_name: &str) -> Result<(), Box<dyn Error>>

Like hotpatch_lib but uses RwLock::try_write.

pub unsafe fn force_hotpatch_lib(
    &self,
    lib_name: &str
) -> Result<(), Box<dyn Error>>

Like hotpatch_lib but uses unsafe features to completly bypass the RwLock. Can be used to patch the current function or parent functions. Use with caution.

pub fn restore_default(&self) -> Result<(), Box<dyn Error>>

Hotpatch this functor back to its original definition.

Example

#[patchable]
fn foo() {}

fn main() -> Result<(), Box<dyn std::error::Error>> {
  foo(); // does A
  foo.hotpatch_lib("libtest.so")?;
  foo(); // does B
  foo.restore_default();
  foo(); // does A again
  Ok(())
}

pub fn try_restore_default(&self) -> Result<(), Box<dyn Error>>

Like restore_default but uses RwLock::try_write.

pub unsafe fn force_restore_default(&self) -> Result<(), Box<dyn Error>>

Like restore_default but uses unsafe features to completly bypass the RwLock. Can be used to patch the current function or parent functions. Use with caution.

impl<VaGen: 'static, Ret: 'static> Patchable<VaGen, Ret>

pub fn hotpatch_fn<F: Send + Sync + 'static>(
    &self,
    ptr: F
) -> Result<(), Box<dyn Error>> where
    F: Fn(VaGen) -> Ret, 

Hotpatch this functor with functionality defined in ptr. ptr can be a function pointer or move closure with the same type signature as the functor's function.

Example

#[patchable]
fn foo(_: i32, _: i32, _: i32) {}

fn bar(_: i32, _: i32, _: i32) {}
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
  foo.hotpatch_fn(bar)?;
  foo.hotpatch_fn(move |a, b, c| println!("{} {} {}", a, b, c))?;
  Ok(())
}

VaArgs Note

Implementation is defined with the variadic_generics crate. This means a macro is used to define a finite but large number of templated inputs. If using functions with large numbers of inputs and hotpatch_fn does not appear to be defined, compile hotpatch with the large-signatures feature to increase the number of supported arguements.

This is the only place where large_signatures is needed. Large signature functions are supported out of the box for hotpatch_lib and restore_default.

pub fn try_hotpatch_fn<F: Send + Sync + 'static>(
    &self,
    ptr: F
) -> Result<(), Box<dyn Error>> where
    F: Fn(VaGen) -> Ret, 

Like hotpatch_fn but uses RwLock::try_write.

pub unsafe fn force_hotpatch_fn<F: Send + Sync + 'static>(
    &self,
    ptr: F
) -> Result<(), Box<dyn Error>> where
    F: Fn(VaGen) -> Ret, 

Like hotpatch_fn but uses unsafe features to completly bypass the RwLock. Can be used to patch the current function or parent functions. Use with caution.

Trait Implementations

impl<Args, Ret> Fn<Args> for Patchable<Args, Ret>

pub extern "rust-call" fn call(&self, args: Args) -> Ret

🔬 This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<Args, Ret> FnMut<Args> for Patchable<Args, Ret>

pub extern "rust-call" fn call_mut(&mut self, args: Args) -> Ret

🔬 This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<Args, Ret> FnOnce<Args> for Patchable<Args, Ret>

type Output = Ret

The returned type after the call operator is used.

pub extern "rust-call" fn call_once(self, args: Args) -> Ret

🔬 This is a nightly-only experimental API. (fn_traits)

Performs the call operation.