5 files changed, 41 insertions, 22 deletions

diff --git a/view/sharedcache/core/FileAccessorCache.cpp b/view/sharedcache/core/FileAccessorCache.cpp
index 5fa965b3..28aab15d 100644
--- a/view/sharedcache/core/FileAccessorCache.cpp
+++ b/view/sharedcache/core/FileAccessorCache.cpp
@@ -68,6 +68,12 @@ WeakFileAccessor FileAccessorCache::Open(const std::string& filePath)
 	return WeakFileAccessor(sharedAccessor, filePath);
 }
 
+void FileAccessorCache::RemoveAccessor(const CacheAccessorID id)
+{
+	std::unique_lock lock(m_mutex);
+	m_accessors.erase(id);
+}
+
 std::shared_ptr<MappedFileAccessor> WeakFileAccessor::lock()
 {
 	auto sharedPtr = m_weakPtr.lock();
@@ -86,4 +92,4 @@ std::shared_ptr<MappedFileAccessor> WeakFileAccessor::lock()
 	}
 
 	return sharedPtr;
-}
\ No newline at end of file
+}
diff --git a/view/sharedcache/core/FileAccessorCache.h b/view/sharedcache/core/FileAccessorCache.h
index 811aea78..46de6fcc 100644
--- a/view/sharedcache/core/FileAccessorCache.h
+++ b/view/sharedcache/core/FileAccessorCache.h
@@ -34,12 +34,16 @@ public:
 	// accessor and inserting itself back into its related cache.
 	WeakFileAccessor Open(const std::string& filePath);
 
+	void RemoveAccessor(CacheAccessorID id);
+
 	// Adjust the cache size limit.
 	// This will NOT evict current cache entries, as they are already available.
 	// Any subsequent call to `Open` will assume this cache size, evicting until the size is equal to the cache size.
 	void SetCacheSize(const uint64_t size) { m_cacheSize = size; };
 
 	size_t GetCacheSize() const { return m_cacheSize; }
+
+	size_t GetCacheCount() const { return m_accessors.size(); }
 };
 
 class WeakFileAccessor
diff --git a/view/sharedcache/core/SharedCacheController.cpp b/view/sharedcache/core/SharedCacheController.cpp
index e0cd036f..6e275b4b 100644
--- a/view/sharedcache/core/SharedCacheController.cpp
+++ b/view/sharedcache/core/SharedCacheController.cpp
@@ -13,39 +13,49 @@ std::shared_mutex GlobalControllersMutex;
 std::map<ViewId, DSCRef<SharedCacheController>>& GlobalControllers()
 {
 	// To make initialization order consistent we place the static in a function.
-	static std::map<ViewId, DSCRef<SharedCacheController>> g_dscViews = {};
-	return g_dscViews;
+	static std::map<ViewId, DSCRef<SharedCacheController>> g_controllers = {};
+	return g_controllers;
 }
 
-ViewId GetViewIdFromView(BinaryView& view)
+ViewId GetViewIdFromFileMetadata(const FileMetadata& file)
 {
 	// Currently the view id is just the views session id.
 	// NOTE: If we want more than one shared cache controller per view we would need to make this more unique.
-	return view.GetFile()->GetSessionId();
+	return file.GetSessionId();
 }
 
-void DeleteController(BinaryView& view)
+void DeleteController(const FileMetadata& file)
 {
-	const auto id = GetViewIdFromView(view);
+	const auto id = GetViewIdFromFileMetadata(file);
 	std::unique_lock<std::shared_mutex> lock(GlobalControllersMutex);
-	auto& dscViews = GlobalControllers();
-	if (auto it = dscViews.find(id); it != dscViews.end())
+	auto& controllers = GlobalControllers();
+	if (auto it = controllers.find(id); it != controllers.end())
 	{
+		auto controller = it->second;
 		// Someone is still holding the controller, lets warn about this.
-		if (it->second->m_refs > 1)
+		if (controller->m_refs > 1)
 			LogWarn("Deleting SharedCacheController for view %llx, but there are still %d references", id,
-				it->second->m_refs.load());
-		dscViews.erase(it);
-		LogDebug("Deleted SharedCacheController for view %s", view.GetFile()->GetFilename().c_str());
+				controller->m_refs.load());
+
+		// Go through the file accessor cache and remove the entries we reference.
+		auto& fileAccessorCache = FileAccessorCache::Global();
+		for (const auto& entry : controller->GetCache().GetEntries())
+		{
+			auto accessorId = GetCacheAccessorID(entry.GetFilePath());
+			fileAccessorCache.RemoveAccessor(accessorId);
+		}
+
+		controllers.erase(it);
+		LogDebug("Deleted SharedCacheController for view %s", file.GetFilename().c_str());
 	}
 }
 
 void RegisterSharedCacheControllerDestructor()
 {
 	BNObjectDestructionCallbacks callbacks = {};
-	callbacks.destructBinaryView = [](void* ctx, BNBinaryView* obj) -> void {
-		auto view = BinaryView(obj);
-		DeleteController(view);
+	callbacks.destructFileMetadata = [](void* ctx, BNFileMetadata* obj) -> void {
+		const auto file = FileMetadata(obj);
+		DeleteController(file);
 	};
 	BNRegisterObjectDestructionCallbacks(&callbacks);
 }
@@ -63,7 +73,7 @@ SharedCacheController::SharedCacheController(SharedCache&& cache, Ref<Logger> lo
 
 DSCRef<SharedCacheController> SharedCacheController::Initialize(BinaryView& view, SharedCache&& cache)
 {
-	auto id = GetViewIdFromView(view);
+	auto id = GetViewIdFromFileMetadata(*view.GetFile());
 	std::unique_lock<std::shared_mutex> lock(GlobalControllersMutex);
 	auto logger = new Logger("SharedCache.Controller", view.GetFile()->GetSessionId());
 	DSCRef<SharedCacheController> controller = new SharedCacheController(std::move(cache), logger);
@@ -94,9 +104,9 @@ DSCRef<SharedCacheController> SharedCacheController::Initialize(BinaryView& view
 	return controller;
 }
 
-DSCRef<SharedCacheController> SharedCacheController::FromView(BinaryView& view)
+DSCRef<SharedCacheController> SharedCacheController::FromView(const BinaryView& view)
 {
-	auto id = GetViewIdFromView(view);
+	auto id = GetViewIdFromFileMetadata(*view.GetFile());
 	std::shared_lock<std::shared_mutex> lock(GlobalControllersMutex);
 	auto& dscViews = GlobalControllers();
 	auto dscView = dscViews.find(id);
diff --git a/view/sharedcache/core/SharedCacheController.h b/view/sharedcache/core/SharedCacheController.h
index 3a6c76dc..cda3653c 100644
--- a/view/sharedcache/core/SharedCacheController.h
+++ b/view/sharedcache/core/SharedCacheController.h
@@ -42,7 +42,7 @@ namespace BinaryNinja::DSC {
 		static DSCRef<SharedCacheController> Initialize(BinaryView& view, SharedCache&& cache);
 
 		// NOTE: This will not create one if it does not exist. To create one for the view call `Initialize`.
-		static DSCRef<SharedCacheController> FromView(BinaryView& view);
+		static DSCRef<SharedCacheController> FromView(const BinaryView& view);
 
 		SharedCache& GetCache() { return m_cache; };
 		const std::unordered_set<uint64_t>& GetLoadedRegions() { return m_loadedRegions; };
diff --git a/view/sharedcache/core/SharedCacheView.cpp b/view/sharedcache/core/SharedCacheView.cpp
index 4218a2fe..0cd4d82e 100644
--- a/view/sharedcache/core/SharedCacheView.cpp
+++ b/view/sharedcache/core/SharedCacheView.cpp
@@ -20,8 +20,7 @@ void SharedCacheViewType::Register()
 
 	// Adjust the global accessor cache to the fdlimit.
 	FileAccessorCache::Global().SetCacheSize(fdLimit);
-
-	// TODO: Register object destructor to clear accessor cache
+	
 	RegisterSharedCacheControllerDestructor();
 
 	static SharedCacheViewType type;