I have a heap corruption in my multi-threaded managed program. Doing some tests I found that the corruption happens only when the background threads active in the program (they are switchable). The threads use some 3rd party components.
After examining the code of the threads and 3rd party components (with .NET Reflector) I found that they are all managed, i.e. no "unsafe" or "DllImportAttribute" or "P/Invoke". It seems that the purely managed code causes a heap corruption, is this possible?
UPDATE
Apart from using Marshal class, is it possible to corrupt the heap with threads not being correctly synchronized? An example would be very appreciated.
Heap corruption occurs when a program damages the allocator's view of the heap. The outcome can be relatively benign and cause a memory leak (where some memory isn't returned to the heap and is inaccessible to the program afterward), or it may be fatal and cause a memory fault, usually within the allocator itself.
It's definitely possible to corrupt the heap without any use of unsafe code. The Marshal class is your friend / enemy here
IntPtr ptr = new IntPtr(50000); // Random memory
byte[] b = new byte[100];
Marshalp.Copy(b, 0, ptr, 100);
This effectively copies 100 consecutive 0's into the heap at address 50000.
Another way is with explicit struct layouts
[StructLayout(LayoutKind.Explicit)]
struct S1
{
[FieldOffset(0)]
internal string str;
[FieldOffset(0)]
internal object obj;
}
S1 s = new S1();
s.obj = new Program();
s.str.Trim(); // Hope that works ... :)
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With