Imported Upstream version 5.18.0.161

Former-commit-id: 4db48158d3a35497b8f118ab21b5f08ac3d86d98

mcs/class/corlib/Mono/Runtime.cs

@@ -105,6 +105,21 @@ namespace Mono {
 		[MethodImplAttribute (MethodImplOptions.InternalCall)]
 		static extern void SendMicrosoftTelemetry_internal (IntPtr payload, ulong portable_hash, ulong unportable_hash);
 
+		[MethodImplAttribute (MethodImplOptions.InternalCall)]
+		static extern void WriteStateToFile_internal (IntPtr payload, ulong portable_hash, ulong unportable_hash);
+
+		static void
+		WriteStateToFile (Exception exc)
+		{
+			ulong portable_hash;
+			ulong unportable_hash;
+			string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
+			using (var payload_chars = RuntimeMarshal.MarshalString (payload_str))
+			{
+				WriteStateToFile_internal (payload_chars.Value, portable_hash, unportable_hash);
+			}
+		}
+
 		static void SendMicrosoftTelemetry (string payload_str, ulong portable_hash, ulong unportable_hash)
 		{
 			if (RuntimeInformation.IsOSPlatform (OSPlatform.OSX)) {
@@ -150,5 +165,43 @@ namespace Mono {
 		}
 #endif
 
+		[MethodImplAttribute (MethodImplOptions.InternalCall)]
+		static extern string DumpStateSingle_internal (out ulong portable_hash, out ulong unportable_hash);
+
+		[MethodImplAttribute (MethodImplOptions.InternalCall)]
+		static extern string DumpStateTotal_internal (out ulong portable_hash, out ulong unportable_hash);
+
+		static Tuple<String, ulong, ulong>
+		DumpStateSingle ()
+		{
+			ulong portable_hash;
+			ulong unportable_hash;
+			string payload_str = DumpStateSingle_internal (out portable_hash, out unportable_hash);
+
+			return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
+		}
+
+		static Tuple<String, ulong, ulong>
+		DumpStateTotal ()
+		{
+			ulong portable_hash;
+			ulong unportable_hash;
+			string payload_str = DumpStateTotal_internal (out portable_hash, out unportable_hash);
+
+			return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
+		}
+
+		[MethodImplAttribute (MethodImplOptions.InternalCall)]
+		static extern void RegisterReportingForNativeLib_internal (IntPtr modulePathSuffix, IntPtr moduleName);
+
+		static void RegisterReportingForNativeLib (string modulePathSuffix_str, string moduleName_str)
+		{
+			using (var modulePathSuffix_chars = RuntimeMarshal.MarshalString (modulePathSuffix_str))
+			using (var moduleName_chars = RuntimeMarshal.MarshalString (moduleName_str))
+			{
+				RegisterReportingForNativeLib_internal (modulePathSuffix_chars.Value, moduleName_chars.Value);
+			}
+		}
+
 	}
 }

mcs/class/corlib/System/Console.cs

@@ -243,7 +243,7 @@ namespace System
 			if (newError == null)
 				throw new ArgumentNullException ("newError");
 
-			stderr = newError;
+			stderr = TextWriter.Synchronized (newError);
 		}
 
 		[SecurityPermission (SecurityAction.Demand, UnmanagedCode = true)]
@@ -252,7 +252,7 @@ namespace System
 			if (newIn == null)
 				throw new ArgumentNullException ("newIn");
 
-			stdin = newIn;
+			stdin = TextReader.Synchronized (newIn);
 		}
 
 		[SecurityPermission (SecurityAction.Demand, UnmanagedCode = true)]
@@ -261,7 +261,7 @@ namespace System
 			if (newOut == null)
 				throw new ArgumentNullException ("newOut");
 
-			stdout = newOut;
+			stdout = TextWriter.Synchronized (newOut);
 		}
 
 		public static void Write (bool value)

mcs/class/corlib/Test/System/ExceptionTest.cs

@@ -17,6 +17,8 @@ using System.Reflection;
 
 using NUnit.Framework;
 
+using System.Threading.Tasks;
+
 namespace MonoTests.System
 {
 	[TestFixture]
@@ -473,6 +475,102 @@ namespace MonoTests.System
 				//  }
 			}
 		}
+
+		void DumpSingle ()
+		{
+			var monoType = Type.GetType ("Mono.Runtime", false);
+			var convert = monoType.GetMethod("DumpStateSingle", BindingFlags.NonPublic | BindingFlags.Static);
+			var output = (Tuple<String, ulong, ulong>) convert.Invoke(null, Array.Empty<object> ());
+
+			var dump = output.Item1;
+			var portable_hash = output.Item2;
+			var unportable_hash = output.Item3;
+
+			Assert.IsTrue (portable_hash != 0, "#1");
+			Assert.IsTrue (unportable_hash != 0, "#2");
+			Assert.IsTrue (dump.Length > 0, "#3");
+		}
+
+		void DumpTotal ()
+		{
+			var monoType = Type.GetType ("Mono.Runtime", false);
+			var convert = monoType.GetMethod("DumpStateTotal", BindingFlags.NonPublic | BindingFlags.Static);
+			var output = (Tuple<String, ulong, ulong>) convert.Invoke(null, Array.Empty<object> ());
+
+			var dump = output.Item1;
+			var portable_hash = output.Item2;
+			var unportable_hash = output.Item3;
+
+			Assert.IsTrue (portable_hash != 0, "#1");
+			Assert.IsTrue (unportable_hash != 0, "#2");
+			Assert.IsTrue (dump.Length > 0, "#3");
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallSingleOnce ()
+		{
+			DumpSingle ();
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallSingleConcurrent ()
+		{
+			// checks that self-dumping works in parallel, locklessly
+			int amt = 20;
+			var tasks = new Task [amt];
+			for (int i=0; i < amt; i++)
+				tasks [i] = Task.Run(() => DumpSingle ());
+			Task.WaitAll (tasks);
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallSingleAsync ()
+		{
+			// checks that dumping works in an async context
+			var t = Task.Run(() => DumpSingle ());
+			t.Wait ();
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallTotalOnce ()
+		{
+			DumpTotal ();
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallTotalRepeated ()
+		{
+			// checks that the state doesn't get broken with repeated use
+			DumpTotal ();
+			DumpTotal ();
+			DumpTotal ();
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallTotalAsync ()
+		{
+			// checks that dumping works in an async context
+			var t = Task.Run(() => DumpTotal ());
+			t.Wait ();
+		}
+
+		[Test]
+		[Category("NotOnWindows")]
+		public void DumpICallTotalConcurrent ()
+		{
+			int amt = 3;
+			var tasks = new Task [amt];
+			for (int i=0; i < amt; i++)
+				tasks [i] = Task.Run(() => DumpTotal ());
+			Task.WaitAll (tasks);
+		}
+
 #endif
 
 		[Test]