mono/utils/mono-merp.c

   1 /**
   2  * \file
   3  * Support for interop with the Microsoft Error Reporting tool
   4  *
   5  * Author:
   6  *   Alexander Kyte (alkyte@microsoft.com)
   7  *
   8  * (C) 2018 Microsoft, Inc.
   9  *
  10  */
  11
  12 #include <config.h>
  13 #include <glib.h>
  14
  15 #if defined(TARGET_OSX) && !defined(DISABLE_CRASH_REPORTING)
  16 #include "mono-merp.h"
  17
  18 #include <unistd.h>
  19 #include <spawn.h>
  20
  21 // OSX OS stuff now, for merpGUI interop
  22 #include <mach/mach.h>
  23 #include <mach/task_info.h>
  24 #include <mach/mach_types.h>
  25 #include <mach/mach_traps.h>
  26 #include <servers/bootstrap.h>
  27
  28 #include <metadata/locales.h>
  29 #include <mini/jit.h>
  30
  31 #if defined(HAVE_SYS_UTSNAME_H)
  32 #include <sys/utsname.h>
  33 #endif
  34
  35 // To get the apple machine model
  36 #include <sys/param.h>
  37 #include <sys/sysctl.h>
  38 #include <fcntl.h>
  39
  40 #include <mono/utils/json.h>
  41 #include <mono/utils/mono-state.h>
  42 #include <utils/mono-threads-debug.h>
  43
  44 static const char *
  45 kernel_version_string (void)
  46 {
  47 #ifdef HAVE_SYS_UTSNAME_H
  48         static struct utsname name;
  49         static const char *version_string;
  50
  51         if (!version_string) {
  52                 // WSL does not always nul terminate. WSL was fixed February 2018.
  53                 // Restore memset if variable made non-static.
  54                 //memset (&name, 0, sizeof (name));
  55
  56                 if (uname (&name) >= 0)
  57                         version_string = name.release;
  58         }
  59         if (!version_string)
  60                 version_string = "";
  61
  62         return version_string;
  63 #endif
  64         return "";
  65 }
  66
  67 static gboolean
  68 starts_with (const char *pre, size_t pre_sz, const char *str)
  69 {
  70     return strncmp (pre, str, pre_sz) == 0;
  71 }
  72
  73 static const char *
  74 macos_version_string (void)
  75 {
  76         /* Can't allocate in here, could be called from a signal handler in a
  77          * crashed process.
  78          */
  79         static const char *version_string;
  80         static char buf[256];
  81         static const size_t buf_size = sizeof (buf);
  82
  83         if (version_string)
  84                 return version_string;
  85
  86         /* macOS 10.13.6 or later */
  87         if (!version_string) {
  88                 size_t size = 0;
  89                 if (sysctlbyname ("kern.osproductversion", NULL, &size, NULL, 0) < 0 || size >= buf_size) {
  90                         /* if we couldn't get the size or if it needs more space that we have in buf, leave it empty */
  91                         version_string = "";
  92                         return version_string;
  93                 }
  94
  95                 if (sysctlbyname ("kern.osproductversion", (char*)buf, &size, NULL, 0) >= 0)
  96                         version_string = &buf[0];
  97         }
  98         /* macOS 10.13.5 or older */
  99         if (!version_string) {
 100                 const char *kv_string = kernel_version_string ();
 101                 if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("17"), kv_string))
 102                         version_string = "10.13"; // High Sierra
 103                 else if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("16"), kv_string))
 104                         version_string = "10.12"; // Sierra
 105                 else if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("15"), kv_string))
 106                         version_string = "10.11"; // El Capitan
 107                 else if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("14"), kv_string))
 108                         version_string = "10.10"; // Yosemite
 109                 else if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("13"), kv_string))
 110                         version_string = "10.9"; // Mavericks
 111                 else if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("12"), kv_string))
 112                         version_string = "10.8"; // Mountain Lion
 113                 else if (starts_with (G_STRING_CONSTANT_AND_LENGTH ("11"), kv_string))
 114                         version_string = "10.7"; // Lion
 115         }
 116         if (!version_string)
 117                 version_string = "";
 118
 119         return version_string;
 120 }
 121
 122 // To get the path of the running process
 123 #include <libproc.h>
 124
 125 typedef enum {
 126         MerpArchInvalid = 0,
 127
 128         MerpArchx86_64 = 1,
 129         MerpArchx86 = 2,
 130         MerpArchPPC = 3,
 131         MerpArchPPC64 = 4
 132 } MerpArch;
 133
 134 typedef enum
 135 {
 136         MERP_EXC_NONE = 0,
 137
 138         MERP_EXC_FORCE_QUIT = 1,
 139         MERP_EXC_SIGSEGV = 2,
 140         MERP_EXC_SIGABRT = 3,
 141         MERP_EXC_SIGSYS  = 4,
 142         MERP_EXC_SIGILL = 5,
 143         MERP_EXC_SIGBUS = 6,
 144         MERP_EXC_SIGFPE = 7 ,
 145         MERP_EXC_SIGTRAP = 8,
 146         MERP_EXC_SIGKILL = 9,
 147         MERP_EXC_HANG  = 10
 148 } MERPExcType;
 149
 150 typedef struct {
 151         const char *merpFilePath;
 152         const char *crashLogPath;
 153         const char *werXmlPath;
 154
 155         const char *bundleIDArg; // App Bundle ID (required for bucketization)
 156         const char *versionArg; // App Version (required for bucketization)
 157
 158         MerpArch archArg; // Arch, MacOS only, bails out if not found also required for bucketization. (required)
 159         MERPExcType exceptionArg; // Exception type (refer to merpcommon.h and mach/exception_types.h for more info (optional)
 160
 161         const char *serviceNameArg; // This is the Bootstrap service name that MERP GUI will create to receive mach_task_self on a port created. Bails out if MERP GUI fails to receive mach_task_self from the crashed app. (Required for crash log generation)
 162         const char *servicePathArg; // The path to the executable, used to relaunch the crashed app.
 163
 164         const char *moduleName;
 165         const char *moduleVersion;
 166         size_t moduleOffset;
 167
 168         const char *osVersion;
 169         int uiLidArg; // MONO_LOCALE_INVARIANT 0x007F
 170
 171         char systemModel [100];
 172         const char *systemManufacturer;
 173
 174         const char *eventType; /* Must be MONO_MERP_EVENT_TYPE_STR */
 175
 176         MonoStackHash hashes;
 177         GSList *annotations;
 178 } MERPStruct;
 179
 180 /* The event type determines the format of the fields that are reported.  It
 181  * must be MonoAppCrash for the rest of our report to make sense.
 182  */
 183 #define MONO_MERP_EVENT_TYPE_STR "MonoAppCrash"
 184
 185
 186 typedef struct {
 187         gboolean enable_merp;
 188
 189         const char *appBundleID;
 190         const char *appPath;
 191         const char *appSignature;
 192         const char *appVersion;
 193         const char *merpGUIPath;
 194         const char *eventType;
 195         const char *merpFilePath;
 196         const char *crashLogPath;
 197         const char *werXmlPath;
 198         const char *moduleVersion;
 199
 200         gboolean log;
 201         GSList *annotations;
 202 } MerpOptions;
 203
 204 static MerpOptions config;
 205
 206 typedef struct {
 207         char *key;
 208         char *value;
 209 } MonoMerpAnnotationEntry;
 210
 211 static const char *
 212 get_merp_bitness (MerpArch arch)
 213 {
 214         switch (arch) {
 215                 case MerpArchx86_64:
 216                         return "x64";
 217                 case MerpArchx86:
 218                         return "x32";
 219                 default:
 220                         g_assert_not_reached ();
 221         }
 222 }
 223
 224 static MerpArch
 225 get_merp_arch (void)
 226 {
 227 #ifdef TARGET_X86
 228         return MerpArchx86;
 229 #elif defined(TARGET_AMD64)
 230         return MerpArchx86_64;
 231 #elif defined(TARGET_POWERPC)
 232         return MerpArchPPC;
 233 #elif defined(TARGET_POWERPC64)
 234         return MerpArchPPC64;
 235 #else
 236         g_assert_not_reached ();
 237 #endif
 238 }
 239
 240 static const char *
 241 get_merp_exctype (MERPExcType exc)
 242 {
 243         switch (exc) {
 244                 case MERP_EXC_FORCE_QUIT:
 245                         return "0x10000000";
 246                 case MERP_EXC_SIGSEGV:
 247                         return "0x20000000";
 248                 case MERP_EXC_SIGABRT:
 249                         return "0x30000000";
 250                 case MERP_EXC_SIGSYS:
 251                         return "0x40000000";
 252                 case MERP_EXC_SIGILL:
 253                         return "0x50000000";
 254                 case MERP_EXC_SIGBUS:
 255                         return "0x60000000";
 256                 case MERP_EXC_SIGFPE:
 257                         return "0x70000000";
 258                 case MERP_EXC_SIGTRAP:
 259                         return "0x03000000";
 260                 case MERP_EXC_SIGKILL:
 261                         return "0x04000000";
 262                 case MERP_EXC_HANG:
 263                         return "0x02000000";
 264                 case MERP_EXC_NONE:
 265                         // Exception type documented as optional, not optional
 266                         g_assert_not_reached ();
 267                 default:
 268                         g_assert_not_reached ();
 269         }
 270 }
 271
 272 static MERPExcType
 273 parse_exception_type (const char *signal)
 274 {
 275         if (!strcmp (signal, "SIGSEGV"))
 276                 return MERP_EXC_SIGSEGV;
 277
 278         if (!strcmp (signal, "SIGFPE"))
 279                 return MERP_EXC_SIGFPE;
 280
 281         if (!strcmp (signal, "SIGILL"))
 282                 return MERP_EXC_SIGILL;
 283
 284         if (!strcmp (signal, "SIGABRT"))
 285                 return MERP_EXC_SIGABRT;
 286
 287         // Force quit == hang?
 288         // We need a default for this
 289         if (!strcmp (signal, "SIGTERM"))
 290                 return MERP_EXC_HANG;
 291
 292         // FIXME: There are no other such signal
 293         // strings passed to mono_handle_native_crash at the
 294         // time of writing this
 295         g_error ("Merp doesn't know how to handle %s\n", signal);
 296 }
 297
 298 static int merp_file_permissions = S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH;
 299
 300 static gboolean
 301 mono_merp_write_params (MERPStruct *merp)
 302 {
 303         int handle = g_open (merp->merpFilePath, O_TRUNC | O_WRONLY | O_CREAT, merp_file_permissions);
 304         g_assertf (handle != -1, "Could not open MERP file at %s", merp->merpFilePath);
 305
 306         g_async_safe_fprintf(handle, "ApplicationBundleId: %s\n", merp->bundleIDArg);
 307         g_async_safe_fprintf(handle, "ApplicationVersion: %s\n", merp->versionArg);
 308         g_async_safe_fprintf(handle, "ApplicationBitness: %s\n", get_merp_bitness (merp->archArg));
 309
 310         g_async_safe_fprintf(handle, "ApplicationName: %s\n", merp->serviceNameArg);
 311         g_async_safe_fprintf(handle, "ApplicationPath: %s\n", merp->servicePathArg);
 312         g_async_safe_fprintf(handle, "BlameModuleName: %s\n", merp->moduleName);
 313         g_async_safe_fprintf(handle, "BlameModuleVersion: %s\n", merp->moduleVersion);
 314         g_async_safe_fprintf(handle, "BlameModuleOffset: 0x%llx\n", (unsigned long long)merp->moduleOffset);
 315         g_async_safe_fprintf(handle, "ExceptionType: %s\n", get_merp_exctype (merp->exceptionArg));
 316         g_async_safe_fprintf(handle, "StackChecksum: 0x%llx\n", merp->hashes.offset_free_hash);
 317         g_async_safe_fprintf(handle, "StackHash: 0x%llx\n", merp->hashes.offset_rich_hash);
 318
 319         // Provided by icall
 320         g_async_safe_fprintf(handle, "OSVersion: %s\n", merp->osVersion);
 321         g_async_safe_fprintf(handle, "LanguageID: 0x%x\n", merp->uiLidArg);
 322         g_async_safe_fprintf(handle, "SystemManufacturer: %s\n", merp->systemManufacturer);
 323         g_async_safe_fprintf(handle, "SystemModel: %s\n", merp->systemModel);
 324         g_async_safe_fprintf(handle, "EventType: %s\n", merp->eventType);
 325
 326         close (handle);
 327         return TRUE;
 328 }
 329
 330 static gboolean
 331 mono_merp_send (MERPStruct *merp)
 332 {
 333         gboolean invoke_success = FALSE;
 334
 335 #if defined(HAVE_EXECV) && defined(HAVE_FORK)
 336         pid_t pid = (pid_t) fork ();
 337
 338         // Only one we define on OSX
 339         if (pid == 0) {
 340                 const char *open_path = "/usr/bin/open";
 341                 const char *argvOpen[] = {open_path, "-a", config.merpGUIPath, NULL};
 342                 execv (open_path, (char**)argvOpen);
 343                 exit (-1);
 344         } else {
 345                 int status;
 346                 int exit_status = FALSE;
 347
 348                 while (TRUE) {
 349                         if (waitpid(pid, &status, WUNTRACED | WCONTINUED) == -1)
 350                                 break;
 351
 352                         if (WIFEXITED(status)) {
 353                                 exit_status = WEXITSTATUS(status);
 354                                 invoke_success = (exit_status == 0);
 355                                 break;
 356                         } else if (WIFSIGNALED(status)) {
 357                                 break;
 358                         }
 359                 }
 360         }
 361
 362         // // Create process to launch merp gui application
 363 #endif
 364
 365         return invoke_success;
 366 }
 367
 368 static void
 369 get_apple_model (char *buffer, size_t max_length)
 370 {
 371         size_t sz = 0;
 372
 373         // Get the number of bytes to copy
 374         sysctlbyname("hw.model", NULL, &sz, NULL, 0);
 375
 376         if (sz > max_length) {
 377                 buffer[0] = '\0';
 378                 return;
 379         }
 380
 381         sysctlbyname("hw.model", buffer, &sz, NULL, 0);
 382 }
 383
 384 static void
 385 mono_init_merp (const intptr_t crashed_pid, const char *signal, MonoStackHash *hashes, MERPStruct *merp)
 386 {
 387         mono_memory_barrier ();
 388         g_assert (mono_merp_enabled ());
 389
 390         merp->merpFilePath = config.merpFilePath;
 391         merp->crashLogPath = config.crashLogPath;
 392         merp->werXmlPath = config.werXmlPath;
 393
 394         // If these aren't set, icall wasn't made
 395         // don't do merp? / don't set the variable to use merp;
 396         g_assert (config.appBundleID);
 397         g_assert (config.appVersion);
 398         merp->bundleIDArg = config.appSignature;
 399         merp->versionArg = config.appVersion;
 400
 401         merp->archArg = get_merp_arch ();
 402         merp->exceptionArg = parse_exception_type (signal);
 403
 404         merp->serviceNameArg = config.appBundleID;
 405         merp->servicePathArg = config.appPath;
 406
 407         merp->moduleName = "Mono Exception";
 408         merp->moduleVersion = config.moduleVersion;
 409
 410         merp->moduleOffset = 0;
 411
 412         merp->uiLidArg = MONO_LOCALE_INVARIANT;
 413 #if defined (TARGET_OSX)
 414         merp->osVersion = macos_version_string ();
 415 #else
 416         merp->osVersion = kernel_version_string ();
 417 #endif
 418
 419         // FIXME: THis is apple-only for now
 420         merp->systemManufacturer = "apple";
 421         get_apple_model ((char *) merp->systemModel, sizeof (merp->systemModel));
 422
 423         merp->eventType = MONO_MERP_EVENT_TYPE_STR;
 424
 425         merp->hashes = *hashes;
 426
 427         merp->annotations = config.annotations;
 428 }
 429
 430 static gboolean
 431 mono_merp_write_fingerprint_payload (const char *non_param_data, const MERPStruct *merp)
 432 {
 433         int handle = g_open (merp->crashLogPath, O_TRUNC | O_WRONLY | O_CREAT, merp_file_permissions);
 434         g_assertf (handle != -1, "Could not open crash log file at %s", merp->crashLogPath);
 435
 436         g_async_safe_fprintf(handle, "{\n");
 437         g_async_safe_fprintf(handle, "\t\"payload\" : \n");
 438         g_write (handle, non_param_data, (guint32)strlen (non_param_data));
 439         g_async_safe_fprintf(handle, ",\n");
 440
 441         g_async_safe_fprintf(handle, "\t\"parameters\" : \n{\n");
 442         g_async_safe_fprintf(handle, "\t\t\"ApplicationBundleId\" : \"%s\",\n", merp->bundleIDArg);
 443         g_async_safe_fprintf(handle, "\t\t\"ApplicationVersion\" : \"%s\",\n", merp->versionArg);
 444         g_async_safe_fprintf(handle, "\t\t\"ApplicationBitness\" : \"%s\",\n", get_merp_bitness (merp->archArg));
 445         g_async_safe_fprintf(handle, "\t\t\"ApplicationName\" : \"%s\",\n", merp->serviceNameArg);
 446         g_async_safe_fprintf(handle, "\t\t\"BlameModuleName\" : \"%s\",\n", merp->moduleName);
 447         g_async_safe_fprintf(handle, "\t\t\"BlameModuleVersion\" : \"%s\",\n", merp->moduleVersion);
 448         g_async_safe_fprintf(handle, "\t\t\"BlameModuleOffset\" : \"0x%lx\",\n", merp->moduleOffset);
 449         g_async_safe_fprintf(handle, "\t\t\"ExceptionType\" : \"%s\",\n", get_merp_exctype (merp->exceptionArg));
 450         g_async_safe_fprintf(handle, "\t\t\"StackChecksum\" : \"0x%llx\",\n", merp->hashes.offset_free_hash);
 451         g_async_safe_fprintf(handle, "\t\t\"StackHash\" : \"0x%llx\",\n", merp->hashes.offset_rich_hash);
 452         g_async_safe_fprintf(handle, "\t\t\"Extra\" : \n\t\t{\n");
 453
 454         for (GSList *cursor = merp->annotations; cursor; cursor = cursor->next) {
 455                 MonoMerpAnnotationEntry *iter = (MonoMerpAnnotationEntry *) cursor->data;
 456                 g_async_safe_fprintf(handle, "\t\t\t\"%s\" : \"%s\"\n", iter->key, iter->value);
 457         }
 458
 459         g_async_safe_fprintf(handle, "\t\t},\n");
 460
 461         // Provided by icall
 462         g_async_safe_fprintf(handle, "\t\t\"OSVersion\" : \"%s\",\n", merp->osVersion);
 463         g_async_safe_fprintf(handle, "\t\t\"LanguageID\" : \"0x%x\",\n", merp->uiLidArg);
 464         g_async_safe_fprintf(handle, "\t\t\"SystemManufacturer\" : \"%s\",\n", merp->systemManufacturer);
 465         g_async_safe_fprintf(handle, "\t\t\"SystemModel\" : \"%s\",\n", merp->systemModel);
 466         g_async_safe_fprintf(handle, "\t\t\"EventType\" : \"%s\"\n", merp->eventType);
 467
 468         // End of parameters
 469         g_async_safe_fprintf(handle, "\t}\n");
 470         g_async_safe_fprintf(handle, "}\n");
 471
 472         // End of object
 473         close (handle);
 474
 475         return TRUE;
 476 }
 477
 478 static gboolean
 479 mono_write_wer_template (MERPStruct *merp)
 480 {
 481         // Note about missing ProcessInformation block: we have no PID that makes sense
 482         // and when mono is embedded and used to run functions without an entry point,
 483         // there is no image that would make any semantic sense to send either.
 484         // It's a nuanced problem, each way we can run mono would need a separate fix.
 485
 486         int handle = g_open (merp->werXmlPath, O_WRONLY | O_CREAT | O_TRUNC, merp_file_permissions);
 487         g_assertf (handle != -1, "Could not open WER XML file at %s", merp->werXmlPath);
 488
 489         // Provided by icall
 490         g_async_safe_fprintf(handle, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 491         g_async_safe_fprintf(handle, "<WERReportMetadata>\n");
 492         g_async_safe_fprintf(handle, "<ProblemSignatures>\n");
 493         g_async_safe_fprintf(handle, "<EventType>%s</EventType>\n", merp->eventType);
 494
 495         int i=0;
 496         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->bundleIDArg, i);
 497         i++;
 498         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->versionArg, i);
 499         i++;
 500         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, get_merp_bitness (merp->archArg), i);
 501         i++;
 502         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->serviceNameArg, i);
 503         i++;
 504         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->moduleName, i);
 505         i++;
 506         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->moduleVersion, i);
 507         i++;
 508         g_async_safe_fprintf(handle, "<Parameter%d>0x%zx</Parameter%d>\n", i, merp->moduleOffset, i);
 509         i++;
 510         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, get_merp_exctype (merp->exceptionArg), i);
 511         i++;
 512         g_async_safe_fprintf(handle, "<Parameter%d>0x%llx</Parameter%d>\n", i, merp->hashes.offset_free_hash, i);
 513         i++;
 514         g_async_safe_fprintf(handle, "<Parameter%d>0x%llx</Parameter%d>\n", i, merp->hashes.offset_rich_hash, i);
 515         i++;
 516         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->osVersion, i);
 517         i++;
 518         g_async_safe_fprintf(handle, "<Parameter%d>0x%x</Parameter%d>\n", i, merp->uiLidArg, i);
 519         i++;
 520         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->systemManufacturer, i);
 521         i++;
 522         g_async_safe_fprintf(handle, "<Parameter%d>%s</Parameter%d>\n", i, merp->systemModel, i);
 523         i++;
 524
 525         g_async_safe_fprintf(handle, "</ProblemSignatures>\n");
 526         g_async_safe_fprintf(handle, "</WERReportMetadata>\n");
 527
 528         close (handle);
 529
 530         return TRUE;
 531 }
 532
 533 // Returns success
 534 gboolean
 535 mono_merp_invoke (const intptr_t crashed_pid, const char *signal, const char *non_param_data, MonoStackHash *hashes)
 536 {
 537         MonoStateMem mem;
 538         int merp_tmp_file_tag = 2;
 539         gboolean alloc_success = mono_state_alloc_mem (&mem, merp_tmp_file_tag, sizeof (MERPStruct));
 540         if (!alloc_success)
 541                 return FALSE;
 542
 543         MERPStruct *merp = (MERPStruct *) mem.mem;
 544         memset (merp, 0, sizeof (*merp));
 545
 546         mono_summarize_timeline_phase_log (MonoSummaryMerpWriter);
 547
 548         mono_init_merp (crashed_pid, signal, hashes, merp);
 549
 550         if (!mono_merp_write_params (merp))
 551                 return FALSE;
 552
 553         if (!mono_merp_write_fingerprint_payload (non_param_data, merp))
 554                 return FALSE;
 555
 556         if (!mono_write_wer_template (merp))
 557                 return FALSE;
 558
 559         // Start program
 560         mono_summarize_timeline_phase_log (MonoSummaryMerpInvoke);
 561         gboolean success = mono_merp_send (merp);
 562
 563         if (success)
 564                 mono_summarize_timeline_phase_log (MonoSummaryCleanup);
 565
 566         mono_state_free_mem (&mem);
 567
 568         return success;
 569 }
 570
 571 void
 572 mono_merp_add_annotation (const char *key, const char *value)
 573 {
 574         MonoMerpAnnotationEntry *entry = g_new0 (MonoMerpAnnotationEntry, 1);
 575         entry->key = g_strdup (key);
 576         entry->value = g_strdup (value);
 577         config.annotations = g_slist_prepend (config.annotations, entry);
 578 }
 579
 580 void
 581 mono_merp_disable (void)
 582 {
 583         mono_memory_barrier ();
 584
 585         if (!config.enable_merp)
 586                 return;
 587
 588         g_free ((char*)config.appBundleID); // cast away const
 589         g_free ((char*)config.appSignature);
 590         g_free ((char*)config.appVersion);
 591         g_free ((char*)config.merpGUIPath);
 592         g_free ((char*)config.appPath);
 593         g_free ((char*)config.moduleVersion);
 594         g_slist_free (config.annotations);
 595         memset (&config, 0, sizeof (config));
 596
 597         mono_memory_barrier ();
 598 }
 599
 600 void
 601 mono_merp_enable (const char *appBundleID, const char *appSignature, const char *appVersion, const char *merpGUIPath, const char *appPath, const char *configDir)
 602 {
 603         mono_memory_barrier ();
 604
 605         g_assert (!config.enable_merp);
 606
 607         char *prefix = NULL;
 608
 609         if (!configDir) {
 610                 const char *home = g_get_home_dir ();
 611                 prefix = g_strdup_printf ("%s/Library/Group Containers/UBF8T346G9.ms/", home);
 612         } else {
 613                 prefix = g_strdup (configDir);
 614         }
 615         config.merpFilePath = g_strdup_printf ("%s%s", prefix, "MERP.uploadparams.txt");
 616         config.crashLogPath = g_strdup_printf ("%s%s", prefix, "lastcrashlog.txt");
 617         config.werXmlPath = g_strdup_printf ("%s%s", prefix, "CustomLogsMetadata.xml");
 618         g_free (prefix);
 619
 620         config.moduleVersion = mono_get_runtime_callbacks ()->get_runtime_build_info ();
 621
 622         config.appBundleID = g_strdup (appBundleID);
 623         config.appSignature = g_strdup (appSignature);
 624         config.appVersion = g_strdup (appVersion);
 625         config.merpGUIPath = g_strdup (merpGUIPath);
 626         config.appPath = g_strdup (appPath);
 627
 628         config.log = g_getenv ("MONO_MERP_VERBOSE") != NULL;
 629
 630         config.enable_merp = TRUE;
 631
 632         mono_memory_barrier ();
 633 }
 634
 635 gboolean
 636 mono_merp_enabled (void)
 637 {
 638         return config.enable_merp;
 639 }
 640
 641 #else
 642
 643 #include <mono/utils/mono-compiler.h>
 644
 645 MONO_EMPTY_SOURCE_FILE (mono_merp);
 646
 647 #endif // TARGET_OSX