mcs/class/corlib/Mono/Runtime.cs

   1 //
   2 // Mono Runtime gateway functions
   3 //
   4 //
   5
   6 //
   7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.IO;
  31 using System.Runtime.CompilerServices;
  32 using System.Runtime.InteropServices;
  33
  34 namespace Mono {
  35
  36 #if MOBILE || XAMMAC_4_5
  37         public
  38 #endif
  39         static class Runtime
  40         {
  41
  42                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  43                 private static extern void mono_runtime_install_handlers ();
  44
  45 #if MOBILE || XAMMAC_4_5
  46                 public
  47 #else
  48                 internal
  49 #endif
  50                 static void InstallSignalHandlers ()
  51                 {
  52                         mono_runtime_install_handlers ();
  53                 }
  54
  55 #if MOBILE || XAMMAC_4_5
  56                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  57                 static extern void mono_runtime_cleanup_handlers ();
  58
  59                 public static void RemoveSignalHandlers ()
  60                 {
  61                         mono_runtime_cleanup_handlers ();
  62                 }
  63 #endif
  64
  65                 // Should not be removed intended for external use
  66                 // Safe to be called using reflection
  67                 // Format is undefined only for use as a string for reporting
  68                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  69 #if MOBILE || XAMMAC_4_5
  70                 public
  71 #else
  72                 internal
  73 #endif
  74                 static extern string GetDisplayName ();
  75
  76                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  77                 static extern string GetNativeStackTrace (Exception exception);
  78
  79                 public static bool SetGCAllowSynchronousMajor (bool flag)
  80                 {
  81                         // No longer used
  82                         return true;
  83                 }
  84
  85                 static object exception_capture = new object ();
  86
  87                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  88                 static extern string ExceptionToState_internal (Exception exc, out ulong portable_hash, out ulong unportable_hash);
  89
  90                 static Tuple<String, ulong, ulong>
  91                 ExceptionToState (Exception exc)
  92                 {
  93                         ulong portable_hash;
  94                         ulong unportable_hash;
  95                         string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
  96
  97                         return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
  98                 }
  99
 100
 101 #if !MOBILE
 102                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 103                 static extern void DisableMicrosoftTelemetry ();
 104
 105                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 106                 static extern void EnableMicrosoftTelemetry_internal (IntPtr appBundleID, IntPtr appSignature, IntPtr appVersion, IntPtr merpGUIPath, IntPtr appPath, IntPtr configDir);
 107
 108                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 109                 static extern void SendMicrosoftTelemetry_internal (IntPtr payload, ulong portable_hash, ulong unportable_hash);
 110
 111                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 112                 static extern void WriteStateToFile_internal (IntPtr payload, ulong portable_hash, ulong unportable_hash);
 113
 114                 static void
 115                 WriteStateToFile (Exception exc)
 116                 {
 117                         ulong portable_hash;
 118                         ulong unportable_hash;
 119                         string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
 120                         using (var payload_chars = RuntimeMarshal.MarshalString (payload_str))
 121                         {
 122                                 WriteStateToFile_internal (payload_chars.Value, portable_hash, unportable_hash);
 123                         }
 124                 }
 125
 126                 static void SendMicrosoftTelemetry (string payload_str, ulong portable_hash, ulong unportable_hash)
 127                 {
 128                         if (RuntimeInformation.IsOSPlatform (OSPlatform.OSX)) {
 129                                 using (var payload_chars = RuntimeMarshal.MarshalString (payload_str))
 130                                 {
 131                                         SendMicrosoftTelemetry_internal (payload_chars.Value, portable_hash, unportable_hash);
 132                                 }
 133                         } else {
 134                                 throw new PlatformNotSupportedException("Merp support is currently only supported on OSX.");
 135                         }
 136                 }
 137
 138                 // Usage:
 139                 //
 140                 // catch (Exception exc) {
 141                 //   var monoType = Type.GetType ("Mono.Runtime", false);
 142                 //   var m = monoType.GetMethod("SendExceptionToTelemetry", BindingFlags.NonPublic | BindingFlags.Static);
 143                 //   m.Invoke(null, new object[] { exc });
 144                 // }
 145                 static void SendExceptionToTelemetry (Exception exc)
 146                 {
 147                         ulong portable_hash;
 148                         ulong unportable_hash;
 149                         lock (exception_capture)
 150                         {
 151                                 string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
 152                                 SendMicrosoftTelemetry (payload_str, portable_hash, unportable_hash);
 153                         }
 154                 }
 155
 156                 // All must be set except for configDir_str
 157                 static void EnableMicrosoftTelemetry (string appBundleID_str, string appSignature_str, string appVersion_str, string merpGUIPath_str, string unused /* eventType_str */, string appPath_str, string configDir_str)
 158                 {
 159                         if (RuntimeInformation.IsOSPlatform (OSPlatform.OSX)) {
 160                                 using (var appBundleID_chars = RuntimeMarshal.MarshalString (appBundleID_str))
 161                                 using (var appSignature_chars = RuntimeMarshal.MarshalString (appSignature_str))
 162                                 using (var appVersion_chars = RuntimeMarshal.MarshalString (appVersion_str))
 163                                 using (var merpGUIPath_chars = RuntimeMarshal.MarshalString (merpGUIPath_str))
 164                                 using (var appPath_chars = RuntimeMarshal.MarshalString (appPath_str))
 165                                 using (var configDir_chars = RuntimeMarshal.MarshalString (configDir_str))
 166                                 {
 167                                         EnableMicrosoftTelemetry_internal (appBundleID_chars.Value, appSignature_chars.Value, appVersion_chars.Value, merpGUIPath_chars.Value, appPath_chars.Value, configDir_chars.Value);
 168                                 }
 169                         } else {
 170                                 throw new PlatformNotSupportedException("Merp support is currently only supported on OSX.");
 171                         }
 172                 }
 173 #endif
 174
 175                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 176                 static extern string DumpStateSingle_internal (out ulong portable_hash, out ulong unportable_hash);
 177
 178                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 179                 static extern string DumpStateTotal_internal (out ulong portable_hash, out ulong unportable_hash);
 180
 181                 static Tuple<String, ulong, ulong>
 182                 DumpStateSingle ()
 183                 {
 184                         ulong portable_hash;
 185                         ulong unportable_hash;
 186                         string payload_str = DumpStateSingle_internal (out portable_hash, out unportable_hash);
 187
 188                         return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
 189                 }
 190
 191                 static Tuple<String, ulong, ulong>
 192                 DumpStateTotal ()
 193                 {
 194                         ulong portable_hash;
 195                         ulong unportable_hash;
 196                         string payload_str = DumpStateTotal_internal (out portable_hash, out unportable_hash);
 197
 198                         return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
 199                 }
 200
 201                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 202                 static extern void RegisterReportingForAllNativeLibs_internal ();
 203
 204                 static void RegisterReportingForAllNativeLibs ()
 205                 {
 206                         RegisterReportingForAllNativeLibs_internal ();
 207                 }
 208
 209                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 210                 static extern void RegisterReportingForNativeLib_internal (IntPtr modulePathSuffix, IntPtr moduleName);
 211
 212                 static void RegisterReportingForNativeLib (string modulePathSuffix_str, string moduleName_str)
 213                 {
 214                         using (var modulePathSuffix_chars = RuntimeMarshal.MarshalString (modulePathSuffix_str))
 215                         using (var moduleName_chars = RuntimeMarshal.MarshalString (moduleName_str))
 216                         {
 217                                 RegisterReportingForNativeLib_internal (modulePathSuffix_chars.Value, moduleName_chars.Value);
 218                         }
 219                 }
 220
 221                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 222                 static extern void EnableCrashReportLog_internal (IntPtr directory);
 223
 224                 static void EnableCrashReportLog (string directory_str)
 225                 {
 226                         using (var directory_chars = RuntimeMarshal.MarshalString (directory_str))
 227                         {
 228                                 EnableCrashReportLog_internal (directory_chars.Value);
 229                         }
 230                 }
 231
 232                 enum CrashReportLogLevel : int {
 233                         MonoSummaryNone = 0,
 234                         MonoSummarySetup,
 235                         MonoSummarySuspendHandshake,
 236                         MonoSummaryUnmanagedStacks,
 237                         MonoSummaryManagedStacks,
 238                         MonoSummaryStateWriter,
 239                         MonoSummaryStateWriterDone,
 240                         MonoSummaryMerpWriter,
 241                         MonoSummaryMerpInvoke,
 242                         MonoSummaryCleanup,
 243                         MonoSummaryDone,
 244
 245                         MonoSummaryDoubleFault
 246                 }
 247
 248                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 249                 static extern int CheckCrashReportLog_internal (IntPtr directory, bool clear);
 250
 251                 static CrashReportLogLevel CheckCrashReportLog (string directory_str, bool clear)
 252                 {
 253                         using (var directory_chars = RuntimeMarshal.MarshalString (directory_str))
 254                         {
 255                                 return (CrashReportLogLevel) CheckCrashReportLog_internal (directory_chars.Value, clear);
 256                         }
 257                 }
 258
 259                 static string get_breadcrumb_value (string file_prefix, string directory_str, bool clear)
 260                 {
 261                         var allfiles = Directory.GetFiles (directory_str, $"{file_prefix}_*" );
 262                         if (allfiles.Length == 0)
 263                                 return string.Empty;
 264
 265                         if (allfiles.Length > 1) {
 266                                 // it's impossible to tell which breadcrumb is the last one (let's not trust filesystem timestamps)
 267                                 // delete the multiple files so at least next crash can make sense
 268                                 try {
 269                                         Array.ForEach (allfiles, f => File.Delete (f) );
 270                                 } catch (Exception) { }
 271
 272                                 return string.Empty;
 273                         }
 274
 275                         if (clear)
 276                                 File.Delete (allfiles [0]);
 277
 278                         var filename = Path.GetFileName (allfiles [0]);
 279                         return filename.Substring (file_prefix.Length + 1);
 280                 }
 281
 282                 static long CheckCrashReportHash (string directory_str, bool clear)
 283                 {
 284                         var value = get_breadcrumb_value ("crash_hash", directory_str, clear);
 285                         if (value == string.Empty)
 286                                 return 0;
 287                         else
 288                                 return Convert.ToInt64 (value, 16);
 289                 }
 290
 291                 static string CheckCrashReportReason (string directory_str, bool clear)
 292                 {
 293                         return get_breadcrumb_value ("crash_reason", directory_str, clear);
 294                 }
 295
 296                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 297                 static extern void AnnotateMicrosoftTelemetry_internal (IntPtr key, IntPtr val);
 298
 299                 static void AnnotateMicrosoftTelemetry (string key, string val)
 300                 {
 301                         using (var key_chars = RuntimeMarshal.MarshalString (key))
 302                         using (var val_chars = RuntimeMarshal.MarshalString (val))
 303                         {
 304                                 AnnotateMicrosoftTelemetry_internal (key_chars.Value, val_chars.Value);
 305                         }
 306                 }
 307         }
 308 }