Track correctly the number of secure command channel connections

src/trusted/sel_universal/reverse_emulate.cc

 // 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/trusted/sel_universal/reverse_emulate.h"
 #include <stdio.h>
 #include <map>
 #include <set>
 #include <string>
 
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/platform/nacl_log.h"
+#include "native_client/src/shared/platform/nacl_sync.h"
+#include "native_client/src/shared/platform/nacl_threads.h"
 #include "native_client/src/shared/platform/scoped_ptr_refcount.h"
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
 #include "native_client/src/trusted/reverse_service/reverse_service.h"
 #include "native_client/src/trusted/sel_universal/rpc_universal.h"
 #include "native_client/src/trusted/sel_universal/srpc_helper.h"
 
 
 // Mock of ReverseInterface for use by nexes.
@@ skipping 52 matching lines @@
   HandleToLauncherMap;
 
 /*
  * TODO(phosek): Rather than using global ctor, SelLdrLauncher shall inherit
  * from RefCountBase class and we shall use nacl::scoped_ptr_refcount to
  * automatically manage the reference and dispose it once it's no longer
  * being used (http://code.google.com/p/nativeclient/issues/detail?id=3050).
  */
 HandleToLauncherMap g_handle_to_launcher;
 
+/*
+ * TODO(phosek): These variables should be instance variables of Reverse
+ * Emulate. However, we cannot make them such at the moment because they're
+ * also being used by command handlers. This will require more significant
+ * redesign/refactoring.
+ */
+int g_exited;
+NaClMutex g_exit_mu;
+NaClCondVar g_exit_cv;
+
 }  // end namespace
 
 
 bool ReverseEmulateInit(NaClSrpcChannel* command_channel,
                         nacl::SelLdrLauncherStandalone* launcher) {
   // Do the SRPC to the command channel to set up the reverse channel.
   // This returns a NaClDesc* containing a socket address.
   NaClLog(1, "ReverseEmulateInit: launching reverse RPC service\n");
   NaClDesc* h;
   NaClSrpcResultCodes rpc_result =
       NaClSrpcInvokeBySignature(command_channel, "reverse_setup::h", &h);
   if (NACL_SRPC_RESULT_OK != rpc_result) {
     NaClLog(LOG_ERROR, "ReverseEmulateInit: reverse setup failed\n");
     return false;
   }
   // Make a nacl::DescWrapper* from the NaClDesc*
   nacl::scoped_ptr<nacl::DescWrapper> conn_cap(launcher->WrapCleanup(h));
   if (conn_cap == NULL) {
     NaClLog(LOG_ERROR, "ReverseEmulateInit: reverse desc wrap failed\n");
     return false;
   }
   // The implementation of the ReverseInterface is our emulator class.
   nacl::scoped_ptr<ReverseEmulate> reverse_interface(new ReverseEmulate());
+  // Construct locks guarding exit status.
+  NaClXMutexCtor(&g_exit_mu);
+  NaClXCondVarCtor(&g_exit_cv);
+  g_exited = false;
   // Create an instance of ReverseService, which connects to the socket
   // address and exports the services from our emulator.
   g_reverse_service.reset(new nacl::ReverseService(conn_cap.get(),
                                                    reverse_interface->Ref()));
   if (g_reverse_service == NULL) {
     NaClLog(LOG_ERROR, "ReverseEmulateInit: reverse service ctor failed\n");
     return false;
   }
   // Successful creation of ReverseService took ownership of these.
   reverse_interface.release();
   conn_cap.release();
   // Starts the RPC handler for the reverse interface.
   if (!g_reverse_service->Start()) {
     NaClLog(LOG_ERROR, "ReverseEmulateInit: reverse service start failed\n");
     return false;
   }
   return true;
 }
 
 void ReverseEmulateFini() {
   CHECK(g_reverse_service != NULL);
   g_reverse_service->WaitForServiceThreadsToExit();
   g_reverse_service.reset(NULL);
+  NaClMutexDtor(&g_exit_mu);
+  NaClCondVarDtor(&g_exit_cv);
 }
 
 bool HandlerReverseEmuAddManifestMapping(NaClCommandLoop* ncl,
                                          const std::vector<string>& args) {
   UNREFERENCED_PARAMETER(ncl);
   if (args.size() < 3) {
     NaClLog(LOG_ERROR, "not enough args\n");
     return false;
   }
   NaClLog(1, "HandlerReverseEmulateAddManifestMapping(%s) -> %s\n",
@@ skipping 12 matching lines @@
   }
   printf("ReverseEmulate manifest mappings:\n");
   for (KeyToFileMap::iterator i = g_key_to_file.begin();
        i != g_key_to_file.end();
        ++i) {
     printf("'%s': '%s'\n", i->first.c_str(), i->second.c_str());
   }
   return true;
 }
 
+bool HandlerWaitForExit(NaClCommandLoop* ncl,
+                        const std::vector<string>& args) {
+  UNREFERENCED_PARAMETER(ncl);
+  UNREFERENCED_PARAMETER(args);
+
+  NaClXMutexLock(&g_exit_mu);
+  while (!g_exited) {
+    NaClXCondVarWait(&g_exit_cv, &g_exit_mu);
+  }
+  NaClXMutexUnlock(&g_exit_mu);
+
+  return true;
+}
+
 ReverseEmulate::ReverseEmulate() {
   NaClLog(1, "ReverseEmulate::ReverseEmulate\n");
 }
 
 ReverseEmulate::~ReverseEmulate() {
   NaClLog(1, "ReverseEmulate::~ReverseEmulate\n");
 }
 
 void ReverseEmulate::Log(nacl::string message) {
   NaClLog(1, "ReverseEmulate::Log (message=%s)\n", message.c_str());
@@ skipping 34 matching lines @@
 }
 
 bool ReverseEmulate::CloseManifestEntry(int32_t desc) {
   NaClLog(1, "ReverseEmulate::CloseManifestEntry (desc=%d)\n", desc);
   CLOSE(desc);
   return true;
 }
 
 void ReverseEmulate::ReportCrash() {
   NaClLog(1, "ReverseEmulate::ReportCrash\n");
+  NaClXMutexLock(&g_exit_mu);
+  g_exited = true;
+  NaClXCondVarBroadcast(&g_exit_cv);
+  NaClXMutexUnlock(&g_exit_mu);
 }
 
 void ReverseEmulate::ReportExitStatus(int exit_status) {
   NaClLog(1, "ReverseEmulate::ReportExitStatus (exit_status=%d)\n",
           exit_status);
+  NaClXMutexLock(&g_exit_mu);
+  g_exited = true;
+  NaClXCondVarBroadcast(&g_exit_cv);
+  NaClXMutexUnlock(&g_exit_mu);
 }
 
 void ReverseEmulate::DoPostMessage(nacl::string message) {
   NaClLog(1, "ReverseEmulate::DoPostMessage (message=%s)\n", message.c_str());
 }
 
 int ReverseEmulate::CreateProcess(nacl::DescWrapper** out_sock_addr,
                                   nacl::DescWrapper** out_app_addr) {
   NaClLog(1, "ReverseEmulate::CreateProcess)\n");
   vector<nacl::string> command_prefix;
@@ skipping 27 matching lines @@
 }
 
 int64_t ReverseEmulate::RequestQuotaForWrite(nacl::string file_id,
                                              int64_t offset,
                                              int64_t length) {
   NaClLog(1, "ReverseEmulate::RequestQuotaForWrite (file_id=%s, offset=%"
           NACL_PRId64", length=%"NACL_PRId64")\n", file_id.c_str(), offset,
           length);
   return length;
 }