Hot-Reloading Refactor

Signed-off-by: Jason Volk <jason@zemos.net>

src/core/mods/canary.rs

@@ -0,0 +1,28 @@
+use std::sync::atomic::{AtomicI32, Ordering};
+
+const ORDERING: Ordering = Ordering::Relaxed;
+static STATIC_DTORS: AtomicI32 = AtomicI32::new(0);
+
+/// Called by Module::unload() to indicate module is about to be unloaded and
+/// static destruction is intended. This will allow verifying it actually took
+/// place.
+pub(crate) fn prepare() {
+	let count = STATIC_DTORS.fetch_sub(1, ORDERING);
+	debug_assert!(count <= 0, "STATIC_DTORS should not be greater than zero.");
+}
+
+/// Called by static destructor of a module. This call should only be found
+/// inside a mod_fini! macro. Do not call from anywhere else.
+#[inline(always)]
+pub fn report() { let _count = STATIC_DTORS.fetch_add(1, ORDERING); }
+
+/// Called by Module::unload() (see check()) with action in case a check()
+/// failed. This can allow a stuck module to be noted while allowing for other
+/// independent modules to be diagnosed.
+pub(crate) fn check_and_reset() -> bool { STATIC_DTORS.swap(0, ORDERING) == 0 }
+
+/// Called by Module::unload() after unload to verify static destruction took
+/// place. A call to prepare() must be made prior to Module::unload() and making
+/// this call.
+#[allow(dead_code)]
+pub(crate) fn check() -> bool { STATIC_DTORS.load(ORDERING) == 0 }

src/core/mods/macros.rs

@@ -0,0 +1,44 @@
+#[macro_export]
+macro_rules! mod_ctor {
+	( $($body:block)? ) => {
+		$crate::mod_init! {{
+			$crate::debug_info!("Module loaded");
+			$($body)?
+		}}
+	}
+}
+
+#[macro_export]
+macro_rules! mod_dtor {
+	( $($body:block)? ) => {
+		$crate::mod_fini! {{
+			$crate::debug_info!("Module unloading");
+			$($body)?
+			$crate::mods::canary::report();
+		}}
+	}
+}
+
+#[macro_export]
+macro_rules! mod_init {
+	($body:block) => {
+		#[used]
+		#[cfg_attr(target_family = "unix", link_section = ".init_array")]
+		static MOD_INIT: extern "C" fn() = { _mod_init };
+
+		#[cfg_attr(target_family = "unix", link_section = ".text.startup")]
+		extern "C" fn _mod_init() -> () $body
+	};
+}
+
+#[macro_export]
+macro_rules! mod_fini {
+	($body:block) => {
+		#[used]
+		#[cfg_attr(target_family = "unix", link_section = ".fini_array")]
+		static MOD_FINI: extern "C" fn() = { _mod_fini };
+
+		#[cfg_attr(target_family = "unix", link_section = ".text.startup")]
+		extern "C" fn _mod_fini() -> () $body
+	};
+}

src/core/mods/mod.rs

@@ -0,0 +1,11 @@
+#![cfg(feature = "mods")]
+
+pub(crate) use libloading::os::unix::{Library, Symbol};
+
+pub mod canary;
+pub mod macros;
+pub mod module;
+pub mod new;
+pub mod path;
+
+pub use module::Module;

src/core/mods/module.rs

@@ -0,0 +1,74 @@
+use std::{
+	ffi::{CString, OsString},
+	time::SystemTime,
+};
+
+use super::{canary, new, path, Library, Symbol};
+use crate::{error, Result};
+
+pub struct Module {
+	handle: Option<Library>,
+	loaded: SystemTime,
+	path: OsString,
+}
+
+impl Module {
+	pub fn from_name(name: &str) -> Result<Self> { Self::from_path(path::from_name(name)?) }
+
+	pub fn from_path(path: OsString) -> Result<Self> {
+		Ok(Self {
+			handle: Some(new::from_path(&path)?),
+			loaded: SystemTime::now(),
+			path,
+		})
+	}
+
+	pub fn unload(&mut self) {
+		canary::prepare();
+		self.close();
+		if !canary::check_and_reset() {
+			let name = self.name().expect("Module is named");
+			error!("Module {name:?} is stuck and failed to unload.");
+		}
+	}
+
+	pub(crate) fn close(&mut self) {
+		if let Some(handle) = self.handle.take() {
+			handle.close().expect("Module handle closed");
+		}
+	}
+
+	pub fn get<Prototype>(&self, name: &str) -> Result<Symbol<Prototype>> {
+		let cname = CString::new(name.to_owned()).expect("terminated string from provided name");
+		let handle = self
+			.handle
+			.as_ref()
+			.expect("backing library loaded by this instance");
+		// SAFETY: Calls dlsym(3) on unix platforms. This might not have to be unsafe
+		// if wrapped in libloading with_dlerror().
+		let sym = unsafe { handle.get::<Prototype>(cname.as_bytes()) };
+		let sym = sym.expect("symbol found; binding successful");
+
+		Ok(sym)
+	}
+
+	pub fn deleted(&self) -> Result<bool> {
+		let mtime = path::mtime(self.path())?;
+		let res = mtime > self.loaded;
+
+		Ok(res)
+	}
+
+	pub fn name(&self) -> Result<String> { path::to_name(self.path()) }
+
+	#[must_use]
+	pub fn path(&self) -> &OsString { &self.path }
+}
+
+impl Drop for Module {
+	fn drop(&mut self) {
+		if self.handle.is_some() {
+			self.unload();
+		}
+	}
+}

src/core/mods/new.rs

@@ -0,0 +1,23 @@
+use std::ffi::OsStr;
+
+use super::{path, Library};
+use crate::{Error, Result};
+
+const OPEN_FLAGS: i32 = libloading::os::unix::RTLD_LAZY | libloading::os::unix::RTLD_GLOBAL;
+
+pub fn from_name(name: &str) -> Result<Library> {
+	let path = path::from_name(name)?;
+	from_path(&path)
+}
+
+pub fn from_path(path: &OsStr) -> Result<Library> {
+	//SAFETY: Calls dlopen(3) on unix platforms. This might not have to be unsafe
+	// if wrapped in with_dlerror.
+	let lib = unsafe { Library::open(Some(path), OPEN_FLAGS) };
+	if let Err(e) = lib {
+		let name = path::to_name(path)?;
+		return Err(Error::Err(format!("Loading module {name:?} failed: {e}")));
+	}
+
+	Ok(lib.expect("module loaded"))
+}

src/core/mods/path.rs

@@ -0,0 +1,40 @@
+use std::{
+	env::current_exe,
+	ffi::{OsStr, OsString},
+	path::{Path, PathBuf},
+	time::SystemTime,
+};
+
+use libloading::library_filename;
+
+use crate::Result;
+
+pub fn from_name(name: &str) -> Result<OsString> {
+	let root = PathBuf::new();
+	let exe_path = current_exe()?;
+	let exe_dir = exe_path.parent().unwrap_or(&root);
+	let mut mod_path = exe_dir.to_path_buf();
+	let mod_file = library_filename(name);
+	mod_path.push(mod_file);
+
+	Ok(mod_path.into_os_string())
+}
+
+pub fn to_name(path: &OsStr) -> Result<String> {
+	let path = Path::new(path);
+	let name = path
+		.file_stem()
+		.expect("path file stem")
+		.to_str()
+		.expect("name string");
+	let name = name.strip_prefix("lib").unwrap_or(name).to_owned();
+
+	Ok(name)
+}
+
+pub fn mtime(path: &OsStr) -> Result<SystemTime> {
+	let meta = std::fs::metadata(path)?;
+	let mtime = meta.modified()?;
+
+	Ok(mtime)
+}