Imported Upstream version 5.2.0.175

Former-commit-id: bb0468d0f257ff100aa895eb5fe583fb5dfbf900

mcs/class/Mono.Posix/Mono.Unix.Android/AndroidUtils.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Reflection;
+
+// using Android.Runtime;
+// using Android.Util;
+
+namespace Mono.Unix.Android
+{
+	internal sealed class AndroidUtils
+	{
+		const string TAG = "Mono.Posix";
+
+		delegate void DetectCPUAndArchitecture (out ushort builtForCPU, out ushort runningOnCPU, out bool is64bit);
+
+		readonly static DetectCPUAndArchitecture detectCPUAndArchitecture;
+
+		static AndroidUtils ()
+		{
+			Type androidRuntime = Type.GetType ("Android.Runtime.AndroidEnvironment, Mono.Android", true);
+
+			MethodInfo mi = androidRuntime.GetMethod ("DetectCPUAndArchitecture", BindingFlags.NonPublic | BindingFlags.Static);
+			detectCPUAndArchitecture = (DetectCPUAndArchitecture) Delegate.CreateDelegate (typeof(DetectCPUAndArchitecture), mi);
+		}
+
+		public static bool AreRealTimeSignalsSafe ()
+		{
+			ushort built_for_cpu;
+			ushort running_on_cpu;
+			bool is64bit;
+
+			detectCPUAndArchitecture (out built_for_cpu, out running_on_cpu, out is64bit);
+
+			// CPUArchitecture builtForCPU = Enum.IsDefined (typeof (CPUArchitecture), built_for_cpu) ? (CPUArchitecture)built_for_cpu : CPUArchitecture.Unknown;
+			// CPUArchitecture runningOnCPU = Enum.IsDefined (typeof (CPUArchitecture), running_on_cpu) ? (CPUArchitecture)running_on_cpu : CPUArchitecture.Unknown;
+
+			// Log.Info (TAG, " Built for CPU: {0}", builtForCPU);
+			// Log.Info (TAG, "Running on CPU: {0}", runningOnCPU);
+			// Log.Info (TAG, "64-bit process: {0}", is64bit ? "yes" : "no");
+
+			// For now real-time signals aren't safe at all, alas
+			bool safe = false;
+			// Log.Info (TAG, "Real-time signals are {0}safe on this platform", safe ? String.Empty : "not ");
+			
+			return safe;
+		}
+	}
+}

mcs/class/Mono.Posix/Mono.Unix.Native/NativeConvert.cs

@@ -8,6 +8,9 @@ using System;
 using System.IO;
 using System.Runtime.InteropServices;
 using Mono.Unix.Native;
+#if MONODROID
+using Mono.Unix.Android;
+#endif
 
 namespace Mono.Unix.Native {
 
@@ -17,7 +20,17 @@ namespace Mono.Unix.Native {
 		//
 		// Non-generated exports
 		//
-#if !MONODROID
+#if MONODROID
+		[DllImport (LIB, EntryPoint="Mono_Posix_FromRealTimeSignum")]
+		static extern int HelperFromRealTimeSignum (Int32 offset, out Int32 rval);
+
+		static int FromRealTimeSignum (Int32 offset, out Int32 rval)
+		{
+			if (!AndroidUtils.AreRealTimeSignalsSafe ())
+				throw new PlatformNotSupportedException ("Real-time signals are not supported on this Android architecture");
+			return HelperFromRealTimeSignum (offset, out rval);
+		}
+#else
 		[DllImport (LIB, EntryPoint="Mono_Posix_FromRealTimeSignum")]
 		private static extern int FromRealTimeSignum (Int32 offset, out Int32 rval);
 #endif

mcs/class/Mono.Posix/Mono.Unix.Native/Stdlib.cs

@@ -426,14 +426,20 @@ namespace Mono.Unix.Native {
 
 		public static Errno GetLastError ()
 		{
+			// Always call Marshal.GetLastWin32Error() before the OS check,
+			// even on Windows where we don't use the return value. If we do
+			// the OS check first Environment.OSVersion (if it happens to be
+			// the first ever access) will clobber Marshal.GetLastWin32Error()
+			// and we won't get the desired errno value on non-Windows platforms.
+			int errno = Marshal.GetLastWin32Error ();
 			if (Environment.OSVersion.Platform != PlatformID.Unix) {
 				// On Windows Marshal.GetLastWin32Error() doesn't take errno
 				// into account so we need to call Mono_Posix_Stdlib_GetLastError()
 				// which returns the value of errno in the C runtime
 				// libMonoPosixHelper.dll was linked against.
-				return (Errno) _GetLastError ();
+				errno = _GetLastError ();
 			}
-			return NativeConvert.ToErrno (Marshal.GetLastWin32Error ());
+			return NativeConvert.ToErrno (errno);
 		}
 
 		[DllImport (MPH, CallingConvention=CallingConvention.Cdecl,

mcs/class/Mono.Posix/Mono.Unix/UnixSignal.cs

@@ -188,6 +188,8 @@ namespace Mono.Unix {
 			AssertValid ();
 			if (exitContext)
 				throw new InvalidOperationException ("exitContext is not supported");
+			if (millisecondsTimeout == 0)
+				return IsSet;		
 			return WaitAny (new UnixSignal[]{this}, millisecondsTimeout) == 0;
 		}
 		#endregion

mcs/class/Mono.Posix/monodroid_Mono.Posix.dll.sources

@@ -0,0 +1,2 @@
+#include Mono.Posix.dll.sources
+./Mono.Unix.Android/AndroidUtils.cs