Fork Sync: Update from parent repository

src/agent/debuggable-module/Cargo.toml

@@ -6,6 +6,7 @@ license = "MIT"
 
 [dependencies]
 anyhow = "1.0"
+elsa = "1.7.0"
 gimli = "0.26.2"
 goblin = "0.6.0"
 iced-x86 = "1.17"

src/agent/debuggable-module/src/loader.rs

@@ -1,84 +1,38 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use std::collections::HashMap;
-use std::sync::Mutex;
-
 use anyhow::Result;
-use thiserror::Error;
 
 use crate::path::FilePath;
 
-#[derive(Clone, Copy)]
-struct Leaked(&'static [u8]);
-
-impl Leaked {
-    pub fn into_raw(self) -> *mut [u8] {
-        self.0 as *const _ as *mut _
-    }
+pub struct Loader {
+    loaded: elsa::sync::FrozenMap<FilePath, Box<[u8]>>,
 }
 
-impl From<Vec<u8>> for Leaked {
-    fn from(data: Vec<u8>) -> Self {
-        let data = Box::leak(data.into_boxed_slice());
-        Leaked(data)
+impl Default for Loader {
+    fn default() -> Self {
+        Self {
+            // sync version doesn't have a Default impl
+            loaded: elsa::sync::FrozenMap::new(),
+        }
     }
 }
 
-#[derive(Default)]
-pub struct Loader {
-    loaded: Mutex<HashMap<FilePath, Leaked>>,
-}
-
 impl Loader {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn load(&self, path: &FilePath) -> Result<&[u8]> {
-        if let Some(data) = self.get(path)? {
-            Ok(data)
-        } else {
-            self.load_new(path)
-        }
-    }
-
-    fn load_new(&self, path: &FilePath) -> Result<&[u8]> {
-        let mut loaded = self.loaded.lock().map_err(|_| LoaderError::PoisonedMutex)?;
-        let data = std::fs::read(path)?;
-        let leaked = Leaked::from(data);
-        loaded.insert(path.clone(), leaked);
+        // Note: if we ever have this callable in parallel from
+        //       multiple threads, we should use some kind of
+        //       lock to prevent loading the same file multiple times.
 
-        Ok(leaked.0)
-    }
-
-    pub fn get(&self, path: &FilePath) -> Result<Option<&[u8]>> {
-        let loaded = self.loaded.lock().map_err(|_| LoaderError::PoisonedMutex)?;
-
-        let data = loaded.get(path).map(|l| l.0);
-
-        Ok(data)
-    }
-}
-
-impl Drop for Loader {
-    fn drop(&mut self) {
-        if let Ok(mut loaded) = self.loaded.lock() {
-            for (_, leaked) in loaded.drain() {
-                unsafe {
-                    let raw = leaked.into_raw();
-                    let owned = Box::from_raw(raw);
-                    drop(owned);
-                }
-            }
-
-            debug_assert!(loaded.is_empty());
+        if let Some(data) = self.loaded.get(path) {
+            return Ok(data);
         }
-    }
-}
 
-#[derive(Error, Debug)]
-pub enum LoaderError {
-    #[error("internal mutex poisoned")]
-    PoisonedMutex,
+        let data: Box<[u8]> = std::fs::read(path)?.into();
+        Ok(self.loaded.insert(path.clone(), data))
+    }
 }