Fix data race in decompressed-assembly cache writer

The background writer thread read directly from the shared
uncompressed_assemblies_data_buffer, but on a cache miss that same
buffer is handed to the runtime once the decompress lock is released,
and the runtime may write into the assembly image (the reason the
cache-hit path maps the file MAP_PRIVATE / COW). Concurrent writes
could persist a torn or post-mutation image; since the staleness footer
only hashes the *compressed* payload, that corrupt image would then be
reloaded from cache as if pristine on the next launch.

Take a private snapshot of the decompressed bytes in enqueue_write,
while the caller still holds assembly_decompress_mutex and before the
buffer is exposed to the runtime, so the writer only ever touches
immutable memory it owns. On allocation failure we skip caching that
assembly rather than aborting.

Trade-off: this adds one memcpy per newly-cached assembly on the
first-launch (cache-miss) path and holds the queued snapshots (up to
the touched working set) transiently until the writer drains them.
Subsequent launches hit the mmap path and never enqueue.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: simonrozsival

src/native/clr/host/assembly-store.cc

@@ -1,7 +1,9 @@
 #include <cerrno>
 #include <cstdlib>
+#include <cstring>
 #include <condition_variable>
 #include <deque>
+#include <memory>
 #include <string>
 #include <thread>
 
@@ -48,10 +50,15 @@ namespace {
 
 		struct WriteRequest final
 		{
-			std::string    path;
-			const uint8_t *data; // stable pointer into uncompressed_assemblies_data_buffer
-			size_t         size;
-			uint64_t       token;
+			std::string                path;
+			// Private snapshot of the decompressed bytes, taken at enqueue time
+			// while the shared decompression buffer is still pristine. Owning a
+			// copy (rather than pointing into uncompressed_assemblies_data_buffer)
+			// avoids racing with the runtime, which may write into the image it
+			// receives once the decompress lock is released.
+			std::unique_ptr<uint8_t[]> data;
+			size_t                     size;
+			uint64_t                   token;
 		};
 
 		std::mutex               state_lock;
@@ -90,7 +97,7 @@ namespace {
 				bool ok = true;
 				size_t off = 0;
 				while (off < req.size) {
-					ssize_t written = write (fd, req.data + off, req.size - off);
+					ssize_t written = write (fd, req.data.get () + off, req.size - off);
 					if (written < 0) {
 						if (errno == EINTR) {
 							continue;
@@ -212,19 +219,30 @@ namespace {
 			return static_cast<uint8_t*>(mapped);
 		}
 
-		// Queues a freshly decompressed assembly to be persisted. The data
-		// pointer must remain valid and immutable for the process lifetime
-		// (it points into uncompressed_assemblies_data_buffer).
+		// Queues a freshly decompressed assembly to be persisted. Takes a private
+		// snapshot of the bytes up front: the caller holds assembly_decompress_mutex
+		// and has not yet handed the shared buffer to the runtime, so the data is
+		// still pristine here. Copying now (rather than letting the background
+		// thread read the shared buffer later) avoids racing with the runtime,
+		// which may write into the image once the lock is released.
 		// Must be called while holding assembly_decompress_mutex.
 		void enqueue_write (std::string_view name, const uint8_t *data, size_t size, uint64_t token) noexcept
 		{
 			if (!enabled) {
 				return;
 			}
 
+			auto snapshot = std::unique_ptr<uint8_t[]> (new (std::nothrow) uint8_t[size]);
+			if (snapshot == nullptr) {
+				// Out of memory: skip caching this assembly. Not fatal — the next
+				// launch simply decompresses it again.
+				return;
+			}
+			memcpy (snapshot.get (), data, size);
+
 			WriteRequest req {
 				.path  = build_path (name),
-				.data  = data,
+				.data  = std::move (snapshot),
 				.size  = size,
 				.token = token,
 			};