Add all missing sequential layout directives to corlib and system.

[mono.git] / mcs / class / corlib / System.Runtime.InteropServices / SafeHandle.cs

diff --git a/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs b/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs
index 438bb7998bfd158cee47c7bcc23ec86e86142264..52e48cda10ea798161a44672c54fb2eb7214d5e4 100644 (file)
--- a/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs
+++ b/mcs/class/corlib/System.Runtime.InteropServices/SafeHandle.cs
@@ -30,25 +30,30 @@
 //     For details, see:
 //     http://blogs.msdn.com/cbrumme/archive/2004/02/20/77460.aspx
 //
+//     CER-like behavior is implemented for Close and DangerousAddRef
+//     via the try/finally uninterruptible pattern in case of async
+//     exceptions like ThreadAbortException.
+//
 // On implementing SafeHandles:
 //     http://blogs.msdn.com/bclteam/archive/2005/03/15/396335.aspx
 //
 // Issues:
-//     The System.Runtime.ConstrainedExecution.ReliabilityContractAttribute has
-//     not been applied to any APIs here yet.
 //
 //     TODO: Although DangerousAddRef has been implemented, I need to
 //     find out whether the runtime performs the P/Invoke if the
 //     handle has been disposed already.
 //
+//
 
-#if NET_2_0
 using System;
 using System.Runtime.InteropServices;
 using System.Runtime.ConstrainedExecution;
+using System.Runtime.CompilerServices;
+using System.Threading;
 
 namespace System.Runtime.InteropServices
 {
+       [StructLayout (LayoutKind.Sequential)]
        public abstract class SafeHandle : CriticalFinalizerObject, IDisposable {
                //
                // Warning: the offset of handle is mapped inside the runtime
@@ -56,11 +61,17 @@ namespace System.Runtime.InteropServices
                // MonoSafeHandle
                //
                protected IntPtr handle;
-               object handle_lock = new object ();
                IntPtr invalid_handle_value;
                int refcount = 0;
                bool owns_handle;
                
+#if NET_2_1
+               protected SafeHandle ()
+               {
+                       throw new NotImplementedException ();
+               }
+#endif
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.MayFail)]
                protected SafeHandle (IntPtr invalidHandleValue, bool ownsHandle)
                {
                        invalid_handle_value = invalidHandleValue;
@@ -68,16 +79,32 @@ namespace System.Runtime.InteropServices
                        refcount = 1;
                }
 
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                public void Close ()
                {
                        if (refcount == 0)
                                throw new ObjectDisposedException (GetType ().FullName);
 
-                       lock (handle_lock){
-                               refcount--;
-                               if (refcount == 0 && owns_handle){
+                       int newcount = 0, current = 0;
+                       bool registered = false;
+                       RuntimeHelpers.PrepareConstrainedRegions ();
+                       try {
+                               do {
+                                       current = refcount;
+                                       newcount = current-1;
+
+                                       // perform changes in finally to avoid async interruptions
+                                       try {}
+                                       finally {
+                                               if (Interlocked.CompareExchange (ref refcount, newcount, current) == current)
+                                                       registered = true;
+                                       }
+                               } while (!registered);
+                       } finally {
+                               if (registered && newcount == 0 && owns_handle && !IsInvalid){
                                        ReleaseHandle ();
                                        handle = invalid_handle_value;
+                                       refcount = -1;
                                }
                        }
                }
@@ -91,13 +118,19 @@ namespace System.Runtime.InteropServices
                // try { x.DangerousAddRef (ref release); ... }
                // finally { if (release) x.DangerousRelease (); }
                //
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.MayFail)]
                public void DangerousAddRef (ref bool success)
                {
-                       if (refcount == 0)
+                       if (refcount <= 0)
                                throw new ObjectDisposedException (GetType ().FullName);
 
-                       lock (handle_lock){
-                               if (handle == invalid_handle_value || refcount == 0){
+                       bool registered = false;
+                       int newcount, current;
+                       do {
+                               current = refcount;
+                               newcount = current + 1;
+                               
+                               if (current <= 0){
                                        //
                                        // In MS, calling sf.Close () followed by a call
                                        // to P/Invoke with SafeHandles throws this, but
@@ -106,36 +139,47 @@ namespace System.Runtime.InteropServices
                                        //
                                        throw new ObjectDisposedException (GetType ().FullName);
                                }
-                               
-                               refcount++;
-                               success = true;
-                       }
+
+                               // perform changes in finally to avoid async interruptions
+                               RuntimeHelpers.PrepareConstrainedRegions ();
+                               try {}
+                               finally {
+                                       if (Interlocked.CompareExchange (ref refcount, newcount, current) == current)
+                                               registered = success = true;
+                               }
+                       } while (!registered);
                }
 
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                public IntPtr DangerousGetHandle ()
                {
-                       if (refcount == 0){
+                       if (refcount <= 0){
                                throw new ObjectDisposedException (GetType ().FullName);
                        }
 
                        return handle;
                }
 
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                public void DangerousRelease ()
                {
-                       if (refcount == 0)
+                       if (refcount <= 0)
                                throw new ObjectDisposedException (GetType ().FullName);
 
-                       lock (handle_lock){
-                               refcount--;
-                               if (refcount == 0 && owns_handle){
-                                       ReleaseHandle ();
-                                       handle = invalid_handle_value;
-                               }
+                       int newcount, current;
+                       do {
+                               current = refcount;
+                               newcount = current-1;
+                       } while (Interlocked.CompareExchange (ref refcount, newcount, current) != current);
+
+                       if (newcount == 0 && owns_handle && !IsInvalid){
+                               ReleaseHandle ();
+                               handle = invalid_handle_value;
                        }
                }
 
-               public virtual void Dispose ()
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
+               public void Dispose ()
                {
                        Dispose (true);
                        GC.SuppressFinalize (this);
@@ -145,11 +189,13 @@ namespace System.Runtime.InteropServices
                // See documentation, this invalidates the handle without
                // closing it.
                //
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                public void SetHandleAsInvalid ()
                {
                        handle = invalid_handle_value;
                }
                
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                protected virtual void Dispose (bool disposing)
                {
                        if (disposing)
@@ -164,30 +210,33 @@ namespace System.Runtime.InteropServices
                        }
                }
 
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                protected abstract bool ReleaseHandle ();
 
+               [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                protected void SetHandle (IntPtr handle)
                {
                        this.handle = handle;
                }
 
                public bool IsClosed {
+                       [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                        get {
-                               return refcount == 0;
+                               return refcount <= 0;
                        }
                }
 
                public abstract bool IsInvalid {
+                       [ReliabilityContract (Consistency.WillNotCorruptState, Cer.Success)]
                        get;
                }
 
                ~SafeHandle ()
                {
-                       if (owns_handle){
+                       if (owns_handle && !IsInvalid){
                                ReleaseHandle ();
                                handle = invalid_handle_value;
                        }
                }
        }
 }
-#endif