Adding write capabilities and SetOtherNotificationFlags cDAC API (#118141)

* * adding target write capabilities to cDAC
* implementing SetOtherNotificationFlags cDAC API

* adding writebuffer

* Apply suggestions from code review

Co-authored-by: Copilot <[email protected]>

---------

Author: rcj1

src/coreclr/debug/daccess/cdac.cpp

@@ -43,6 +43,16 @@ namespace
         return S_OK;
     }
 
+    int WriteToTargetCallback(uint64_t addr, const uint8_t* buff, uint32_t count, void* context)
+    {
+        ICorDebugMutableDataTarget* target = static_cast<ICorDebugMutableDataTarget*>(context);
+        HRESULT hr = target->WriteVirtual((CORDB_ADDRESS)addr, buff, count);
+        if (FAILED(hr))
+            return hr;
+
+        return S_OK;
+    }
+
     int ReadThreadContext(uint32_t threadId, uint32_t contextFlags, uint32_t contextBufferSize, uint8_t* contextBuffer, void* context)
     {
         ICorDebugDataTarget* target = reinterpret_cast<ICorDebugDataTarget*>(context);
@@ -54,7 +64,7 @@ namespace
     }
 }
 
-CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugDataTarget* target, IUnknown* legacyImpl)
+CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugMutableDataTarget* target, IUnknown* legacyImpl)
 {
     HMODULE cdacLib;
     if (!TryLoadCDACLibrary(&cdacLib))
@@ -64,7 +74,7 @@ CDAC CDAC::Create(uint64_t descriptorAddr, ICorDebugDataTarget* target, IUnknown
     _ASSERTE(init != nullptr);
 
     intptr_t handle;
-    if (init(descriptorAddr, &ReadFromTargetCallback, &ReadThreadContext, target, &handle) != 0)
+    if (init(descriptorAddr, &ReadFromTargetCallback, &WriteToTargetCallback, &ReadThreadContext, target, &handle) != 0)
     {
         ::FreeLibrary(cdacLib);
         return {};

src/coreclr/debug/daccess/cdac.h

@@ -7,7 +7,7 @@
 class CDAC final
 {
 public: // static
-    static CDAC Create(uint64_t descriptorAddr, ICorDebugDataTarget *pDataTarget, IUnknown* legacyImpl);
+    static CDAC Create(uint64_t descriptorAddr, ICorDebugMutableDataTarget *pDataTarget, IUnknown* legacyImpl);
 
 public:
     CDAC() = default;

src/coreclr/debug/daccess/daccess.cpp

@@ -7033,7 +7033,7 @@ CLRDataCreateInstance(REFIID iid,
                 HRESULT qiRes = pClrDataAccess->QueryInterface(IID_IUnknown, (void**)&thisImpl);
                 _ASSERTE(SUCCEEDED(qiRes));
                 CDAC& cdac = pClrDataAccess->m_cdac;
-                cdac = CDAC::Create(contractDescriptorAddr, pClrDataAccess->m_pTarget, thisImpl);
+                cdac = CDAC::Create(contractDescriptorAddr, pClrDataAccess->m_pMutableTarget, thisImpl);
                 if (cdac.IsValid())
                 {
                     // Get SOS interfaces from the cDAC if available.

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Target.cs

@@ -72,6 +72,13 @@ public abstract class Target
     /// <param name="buffer">Destination to copy the bytes, the number of bytes to read is the span length</param>
     public abstract void ReadBuffer(ulong address, Span<byte> buffer);
 
+    /// <summary>
+    /// Write some bytes to the target
+    /// </summary>
+    /// <param name="address">The address where to start writing</param>
+    /// <param name="buffer">Source of the bytes to write, the number of bytes to write is the span length</param>
+    public abstract void WriteBuffer(ulong address, Span<byte> buffer);
+
     /// <summary>
     /// Read a null-terminated UTF-8 string from the target
     /// </summary>
@@ -133,6 +140,15 @@ public abstract class Target
     /// <returns>Value read from the target</returns>
     public abstract T Read<T>(ulong address) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>;
 
+    /// <summary>
+    /// Write a value to the target in target endianness
+    /// </summary>
+    /// <typeparam name="T">Type of value to write</typeparam>
+    /// <param name="address">Address to start writing to</param>
+    /// <param name="value">Value to write</param>
+    /// <returns>True if the write was successful, false otherwise</returns>
+    public abstract bool Write<T>(ulong address, T value) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>;
+
     /// <summary>
     /// Read a target pointer from a span of bytes
     /// </summary>

src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader/ContractDescriptorTarget.cs

@@ -32,8 +32,8 @@ private readonly struct Configuration
     }
 
     private readonly Configuration _config;
-    private readonly Reader _reader;
 
+    private readonly DataTargetDelegates _dataTargetDelegates;
     private readonly Dictionary<string, int> _contracts = [];
     private readonly IReadOnlyDictionary<string, GlobalValue> _globals = new Dictionary<string, GlobalValue>();
     private readonly Dictionary<DataType, Target.TypeInfo> _knownTypes = [];
@@ -43,6 +43,7 @@ private readonly struct Configuration
     public override DataCache ProcessedData { get; }
 
     public delegate int ReadFromTargetDelegate(ulong address, Span<byte> bufferToFill);
+    public delegate int WriteToTargetDelegate(ulong address, Span<byte> bufferToWrite);
     public delegate int GetTargetThreadContextDelegate(uint threadId, uint contextFlags, Span<byte> bufferToFill);
 
     /// <summary>
@@ -56,18 +57,19 @@ private readonly struct Configuration
     public static bool TryCreate(
         ulong contractDescriptor,
         ReadFromTargetDelegate readFromTarget,
+        WriteToTargetDelegate writeToTarget,
         GetTargetThreadContextDelegate getThreadContext,
         [NotNullWhen(true)] out ContractDescriptorTarget? target)
     {
-        Reader reader = new Reader(readFromTarget, getThreadContext);
+        DataTargetDelegates dataTargetDelegates = new DataTargetDelegates(readFromTarget, writeToTarget, getThreadContext);
         if (TryReadContractDescriptor(
             contractDescriptor,
-            reader,
+            dataTargetDelegates,
             out Configuration config,
             out ContractDescriptorParser.ContractDescriptor? descriptor,
             out TargetPointer[] pointerData))
         {
-            target = new ContractDescriptorTarget(config, descriptor!, pointerData, reader);
+            target = new ContractDescriptorTarget(config, descriptor!, pointerData, dataTargetDelegates);
             return true;
         }
 
@@ -89,6 +91,7 @@ public static ContractDescriptorTarget Create(
         ContractDescriptorParser.ContractDescriptor contractDescriptor,
         TargetPointer[] globalPointerValues,
         ReadFromTargetDelegate readFromTarget,
+        WriteToTargetDelegate writeToTarget,
         GetTargetThreadContextDelegate getThreadContext,
         bool isLittleEndian,
         int pointerSize)
@@ -97,15 +100,15 @@ public static ContractDescriptorTarget Create(
             new Configuration { IsLittleEndian = isLittleEndian, PointerSize = pointerSize },
             contractDescriptor,
             globalPointerValues,
-            new Reader(readFromTarget, getThreadContext));
+            new DataTargetDelegates(readFromTarget, writeToTarget, getThreadContext));
     }
 
-    private ContractDescriptorTarget(Configuration config, ContractDescriptorParser.ContractDescriptor descriptor, TargetPointer[] pointerData, Reader reader)
+    private ContractDescriptorTarget(Configuration config, ContractDescriptorParser.ContractDescriptor descriptor, TargetPointer[] pointerData, DataTargetDelegates dataTargetDelegates)
     {
         Contracts = new CachingContractRegistry(this, this.TryGetContractVersion);
         ProcessedData = new DataCache(this);
         _config = config;
-        _reader = reader;
+        _dataTargetDelegates = dataTargetDelegates;
 
         _contracts = descriptor.Contracts ?? [];
 
@@ -187,7 +190,7 @@ private struct GlobalValue
     // See docs/design/datacontracts/contract-descriptor.md
     private static bool TryReadContractDescriptor(
         ulong address,
-        Reader reader,
+        DataTargetDelegates dataTargetDelegates,
         out Configuration config,
         out ContractDescriptorParser.ContractDescriptor? descriptor,
         out TargetPointer[] pointerData)
@@ -198,7 +201,7 @@ private static bool TryReadContractDescriptor(
 
         // Magic - uint64_t
         Span<byte> buffer = stackalloc byte[sizeof(ulong)];
-        if (reader.ReadFromTarget(address, buffer) < 0)
+        if (dataTargetDelegates.ReadFromTarget(address, buffer) < 0)
             return false;
 
         address += sizeof(ulong);
@@ -209,7 +212,7 @@ private static bool TryReadContractDescriptor(
             return false;
 
         // Flags - uint32_t
-        if (!TryRead(address, isLittleEndian, reader, out uint flags))
+        if (!TryRead(address, isLittleEndian, dataTargetDelegates, out uint flags))
             return false;
 
         address += sizeof(uint);
@@ -220,19 +223,19 @@ private static bool TryReadContractDescriptor(
         config = new Configuration { IsLittleEndian = isLittleEndian, PointerSize = pointerSize };
 
         // Descriptor size - uint32_t
-        if (!TryRead(address, config.IsLittleEndian, reader, out uint descriptorSize))
+        if (!TryRead(address, config.IsLittleEndian, dataTargetDelegates, out uint descriptorSize))
             return false;
 
         address += sizeof(uint);
 
         // Descriptor - char*
-        if (!TryReadPointer(address, config, reader, out TargetPointer descriptorAddr))
+        if (!TryReadPointer(address, config, dataTargetDelegates, out TargetPointer descriptorAddr))
             return false;
 
         address += (uint)pointerSize;
 
         // Pointer data count - uint32_t
-        if (!TryRead(address, config.IsLittleEndian, reader, out uint pointerDataCount))
+        if (!TryRead(address, config.IsLittleEndian, dataTargetDelegates, out uint pointerDataCount))
             return false;
 
         address += sizeof(uint);
@@ -241,14 +244,14 @@ private static bool TryReadContractDescriptor(
         address += sizeof(uint);
 
         // Pointer data - uintptr_t*
-        if (!TryReadPointer(address, config, reader, out TargetPointer pointerDataAddr))
+        if (!TryReadPointer(address, config, dataTargetDelegates, out TargetPointer pointerDataAddr))
             return false;
 
         // Read descriptor
         Span<byte> descriptorBuffer = descriptorSize <= StackAllocByteThreshold
             ? stackalloc byte[(int)descriptorSize]
             : new byte[(int)descriptorSize];
-        if (reader.ReadFromTarget(descriptorAddr.Value, descriptorBuffer) < 0)
+        if (dataTargetDelegates.ReadFromTarget(descriptorAddr.Value, descriptorBuffer) < 0)
             return false;
 
         descriptor = ContractDescriptorParser.ParseCompact(descriptorBuffer);
@@ -259,7 +262,7 @@ private static bool TryReadContractDescriptor(
         pointerData = new TargetPointer[pointerDataCount];
         for (int i = 0; i < pointerDataCount; i++)
         {
-            if (!TryReadPointer(pointerDataAddr.Value + (uint)(i * pointerSize), config, reader, out pointerData[i]))
+            if (!TryReadPointer(pointerDataAddr.Value + (uint)(i * pointerSize), config, dataTargetDelegates, out pointerData[i]))
                 return false;
         }
 
@@ -280,7 +283,7 @@ private static DataType GetDataType(string type)
     public override bool TryGetThreadContext(ulong threadId, uint contextFlags, Span<byte> buffer)
     {
         // Underlying API only supports 32-bit thread IDs, mask off top 32 bits
-        int hr = _reader.GetThreadContext((uint)(threadId & uint.MaxValue), contextFlags, buffer);
+        int hr = _dataTargetDelegates.GetThreadContext((uint)(threadId & uint.MaxValue), contextFlags, buffer);
         return hr == 0;
     }
 
@@ -292,24 +295,50 @@ public override bool TryGetThreadContext(ulong threadId, uint contextFlags, Span
     /// <returns>Value read from the target</returns>
     public override T Read<T>(ulong address)
     {
-        if (!TryRead(address, _config.IsLittleEndian, _reader, out T value))
+        if (!TryRead(address, _config.IsLittleEndian, _dataTargetDelegates, out T value))
             throw new InvalidOperationException($"Failed to read {typeof(T)} at 0x{address:x8}.");
 
         return value;
     }
 
-    private static bool TryRead<T>(ulong address, bool isLittleEndian, Reader reader, out T value) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>
+    private static bool TryRead<T>(ulong address, bool isLittleEndian, DataTargetDelegates dataTargetDelegates, out T value) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>
     {
         value = default;
         Span<byte> buffer = stackalloc byte[sizeof(T)];
-        if (reader.ReadFromTarget(address, buffer) < 0)
+        if (dataTargetDelegates.ReadFromTarget(address, buffer) < 0)
             return false;
 
         return isLittleEndian
             ? T.TryReadLittleEndian(buffer, !IsSigned<T>(), out value)
             : T.TryReadBigEndian(buffer, !IsSigned<T>(), out value);
     }
 
+    /// <summary>
+    /// Write a value to the target in target endianness
+    /// </summary>
+    /// <typeparam name="T">Type of value to write</typeparam>
+    /// <param name="address">Address to start writing to</param>
+    /// <returns>True if the value is successfully written. Throws an InvalidOperationException otherwise.</returns>
+    public override bool Write<T>(ulong address, T value)
+    {
+        if (!TryWrite(address, _config.IsLittleEndian, _dataTargetDelegates, value))
+            throw new InvalidOperationException($"Failed to write {typeof(T)} at 0x{address:x8}.");
+        return true;
+    }
+
+    private static bool TryWrite<T>(ulong address, bool isLittleEndian, DataTargetDelegates dataTargetDelegates, T value) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>
+    {
+        Span<byte> buffer = stackalloc byte[sizeof(T)];
+        int bytesWritten = default;
+        bool success = isLittleEndian
+            ? value.TryWriteLittleEndian(buffer, out bytesWritten)
+            : value.TryWriteBigEndian(buffer, out bytesWritten);
+        if (!success || bytesWritten != buffer.Length || dataTargetDelegates.WriteToTarget(address, buffer) < 0)
+            return false;
+
+        return true;
+    }
+
     private static T Read<T>(ReadOnlySpan<byte> bytes, bool isLittleEndian) where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>
     {
         if (sizeof(T) != bytes.Length)
@@ -335,7 +364,18 @@ public override void ReadBuffer(ulong address, Span<byte> buffer)
 
     private bool TryReadBuffer(ulong address, Span<byte> buffer)
     {
-        return _reader.ReadFromTarget(address, buffer) >= 0;
+        return _dataTargetDelegates.ReadFromTarget(address, buffer) >= 0;
+    }
+
+    public override void WriteBuffer(ulong address, Span<byte> buffer)
+    {
+        if (!TryWriteBuffer(address, buffer))
+            throw new InvalidOperationException($"Failed to write {buffer.Length} bytes at 0x{address:x8}.");
+    }
+
+    private bool TryWriteBuffer(ulong address, Span<byte> buffer)
+    {
+        return _dataTargetDelegates.WriteToTarget(address, buffer) >= 0;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -351,7 +391,7 @@ private static bool IsSigned<T>() where T : struct, INumberBase<T>, IMinMaxValue
     /// <returns>Pointer read from the target</returns>}
     public override TargetPointer ReadPointer(ulong address)
     {
-        if (!TryReadPointer(address, _config, _reader, out TargetPointer pointer))
+        if (!TryReadPointer(address, _config, _dataTargetDelegates, out TargetPointer pointer))
             throw new InvalidOperationException($"Failed to read pointer at 0x{address:x8}.");
 
         return pointer;
@@ -456,33 +496,33 @@ public override string ReadUtf16String(ulong address)
     /// <returns>Value read from the target</returns>
     public override TargetNUInt ReadNUInt(ulong address)
     {
-        if (!TryReadNUInt(address, _config, _reader, out ulong value))
+        if (!TryReadNUInt(address, _config, _dataTargetDelegates, out ulong value))
             throw new InvalidOperationException($"Failed to read nuint at 0x{address:x8}.");
 
         return new TargetNUInt(value);
     }
 
-    private static bool TryReadPointer(ulong address, Configuration config, Reader reader, out TargetPointer pointer)
+    private static bool TryReadPointer(ulong address, Configuration config, DataTargetDelegates dataTargetDelegates, out TargetPointer pointer)
     {
         pointer = TargetPointer.Null;
-        if (!TryReadNUInt(address, config, reader, out ulong value))
+        if (!TryReadNUInt(address, config, dataTargetDelegates, out ulong value))
             return false;
 
         pointer = new TargetPointer(value);
         return true;
     }
 
-    private static bool TryReadNUInt(ulong address, Configuration config, Reader reader, out ulong value)
+    private static bool TryReadNUInt(ulong address, Configuration config, DataTargetDelegates dataTargetDelegates, out ulong value)
     {
         value = 0;
         if (config.PointerSize == sizeof(uint)
-            && TryRead(address, config.IsLittleEndian, reader, out uint value32))
+            && TryRead(address, config.IsLittleEndian, dataTargetDelegates, out uint value32))
         {
             value = value32;
             return true;
         }
         else if (config.PointerSize == sizeof(ulong)
-            && TryRead(address, config.IsLittleEndian, reader, out ulong value64))
+            && TryRead(address, config.IsLittleEndian, dataTargetDelegates, out ulong value64))
         {
             value = value64;
             return true;
@@ -657,8 +697,9 @@ public void Clear()
         }
     }
 
-    private readonly struct Reader(
+    private readonly struct DataTargetDelegates(
         ReadFromTargetDelegate readFromTarget,
+        WriteToTargetDelegate writeToTarget,
         GetTargetThreadContextDelegate getThreadContext)
     {
         public int ReadFromTarget(ulong address, Span<byte> buffer)
@@ -673,5 +714,9 @@ public int GetThreadContext(uint threadId, uint contextFlags, Span<byte> buffer)
         {
             return getThreadContext(threadId, contextFlags, buffer);
         }
+        public int WriteToTarget(ulong address, Span<byte> buffer)
+        {
+            return writeToTarget(address, buffer);
+        }
     }
 }

src/native/managed/cdac/inc/cdac_reader.h

@@ -18,6 +18,7 @@ extern "C"
 int cdac_reader_init(
     uint64_t descriptor,
     int(*read_from_target)(uint64_t, uint8_t*, uint32_t, void*),
+    int(*write_to_target)(uint64_t, const uint8_t*, uint32_t, void*),
     int(*read_thread_context)(uint32_t, uint32_t, uint32_t, uint8_t*, void*),
     void* read_context,
     /*out*/ intptr_t* handle);