Add a load_status callback hook that is invoked at the end of chrome LoadApp.

src/trusted/service_runtime/sel_main_chrome.c

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "native_client/src/public/chrome_main.h"
 
 #include "native_client/src/include/build_config.h"
 #include "native_client/src/include/portability.h"
@@ skipping 26 matching lines @@
 #include "native_client/src/trusted/service_runtime/sel_ldr.h"
 #include "native_client/src/trusted/service_runtime/sel_main_common.h"
 #include "native_client/src/trusted/service_runtime/sel_qualify.h"
 #include "native_client/src/trusted/service_runtime/win/exception_patch/ntdll_patch.h"
 #include "native_client/src/trusted/validator/rich_file_info.h"
 #include "native_client/src/trusted/validator/validation_metadata.h"
 
 static int g_initialized = 0;
 
 static void (*g_fatal_error_handler)(const char *data, size_t bytes) = NULL;
+static void (*g_load_status_callback)(int load_status) = NULL;
 
 static const int default_argc = 1;
 static const char *const default_argv[1] = {"NaClMain"};
 
 #if NACL_LINUX || NACL_OSX
 void NaClChromeMainSetUrandomFd(int urandom_fd) {
   CHECK(!g_initialized);
   NaClSecureRngModuleSetUrandomFd(urandom_fd);
 }
 #endif
@@ skipping 12 matching lines @@
 }
 
 void NaClSetFatalErrorCallback(void (*func)(const char *data, size_t bytes)) {
   CHECK(g_initialized);
   if (g_fatal_error_handler != NULL)
     NaClLog(LOG_FATAL, "NaClSetFatalErrorCallback called twice.\n");
   g_fatal_error_handler = func;
   NaClErrorLogHookInit(NaClFatalErrorHandlerCallback, NULL);
 }
 
+void NaClSetLoadStatusCallback(void (*func)(int load_status)) {
+  CHECK(g_initialized);
+  if (g_load_status_callback != NULL)
+    NaClLog(LOG_FATAL, "NaClSetLoadStatusCallback called twice.\n");
+  g_load_status_callback = func;
+}
+
 struct NaClChromeMainArgs *NaClChromeMainArgsCreate(void) {
   struct NaClChromeMainArgs *args;
 
   CHECK(g_initialized);
   args = malloc(sizeof(*args));
   if (args == NULL)
     return NULL;
   args->imc_bootstrap_handle = NACL_INVALID_HANDLE;
   args->irt_fd = -1;
   args->irt_desc = NULL;
@@ skipping 275 matching lines @@
     if (!NaClDebugInit(nap)) {
       goto done;
     }
 #if NACL_WINDOWS
     if (NULL != args->debug_stub_server_port_selected_handler_func) {
       args->debug_stub_server_port_selected_handler_func(nap->debug_stub_port);
     }
 #endif
   }
 
+  if (g_load_status_callback != NULL) {
+    g_load_status_callback(LOAD_OK);
+  }
   return LOAD_OK;
 
 done:
   fflush(stdout);
 
   /*
-   * If there is a secure command channel, we sent an RPC reply with
-   * the reason that the nexe was rejected.  If we exit now, that
-   * reply may still be in-flight and the various channel closure (esp
-   * reverse channel) may be detected first.  This would result in a
-   * crash being reported, rather than the error in the RPC reply.
+   * If there is a load_status_callback, call that now. TODO(jvoung): remove
+   * NaClBlockIfCommandChannelExists() and just call g_load_status_callback
+   * to indicate the load_status.
+   */
+  if (g_load_status_callback != NULL) {
+    /* Don't return LOAD_OK if we had some failure loading. */
+    if (LOAD_OK == errcode) {
+      errcode = LOAD_INTERNAL;
+    }
+    g_load_status_callback(errcode);
+    NaClLog(LOG_ERROR, "reap logs\n");
+    NaClLogRunAbortBehavior();
+    return errcode;
+  }
+  /*
+   * If there is no load_status_callback, but there is a secure command channel,
+   * we sent an RPC reply with the reason that the nexe was rejected.
+   * If we exit now, that reply may still be in-flight and the various
+   * channel closure (esp reverse channel) may be detected first.  This would
+   * result in a crash being reported, rather than the error in the RPC reply.
    * Instead, we wait for the hard-shutdown on the command channel.
    */
   if (LOAD_OK != errcode) {
     NaClBlockIfCommandChannelExists(nap);
   } else {
     /*
      * Don't return LOAD_OK if we had some failure loading.
      */
     errcode = LOAD_INTERNAL;
   }
@@ skipping 43 matching lines @@
 int NaClChromeMainStart(struct NaClApp *nap,
                         struct NaClChromeMainArgs *args,
                         int *exit_status) {
   int load_ok = LOAD_OK == LoadApp(nap, args);
   if (load_ok) {
     *exit_status = StartApp(nap, args);
   }
   free(args);
   return load_ok;
 }