Use chain-loading for Linux nacl_helper

chrome/nacl/nacl_helper_linux.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A mini-zygote specifically for Native Client.
 
 #include "chrome/common/nacl_helper_linux.h"
 
 #include <errno.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "chrome/nacl/nacl_listener.h"
 #include "content/common/main_function_params.h"
 #include "content/common/unix_domain_socket_posix.h"
 #include "ipc/ipc_switches.h"
+#include "native_client/src/trusted/service_runtime/sel_memory.h"
 
 namespace {
 
 bool g_suid_sandbox_active;
 
 // The child must mimic the behavior of zygote_main_linux.cc on the child
 // side of the fork. See zygote_main_linux.cc:HandleForkRequest from
 //   if (!child) {
 // Note: this code doesn't attempt to support SELINUX or the SECCOMP sandbox.
 void BecomeNaClLoader(const std::vector<int>& child_fds) {
@@ skipping 73 matching lines @@
   // Now tell childpid to the Chrome zygote.
   if (HANDLE_EINTR(send(kNaClZygoteDescriptor,
                         &childpid, sizeof(childpid), MSG_EOR))
       != sizeof(childpid)) {
     LOG(ERROR) << "*** send() to zygote failed";
   }
 }
 
 }  // namespace
 
-static const void* g_nacl_reserved_space = NULL;
-extern "C" __attribute__((visibility("default")))
-const void* nacl_helper_get_1G_address() {
-  return g_nacl_reserved_space;
-}
+static const char kNaClHelperAtZero[] = "at-zero";
 
-// nacl_helper_init does the real work of this module. It is invoked as
-// a static constructor and never returns, preventing main() from the
-// nacl_helper_bootstrap program from being called.
-//
-// NOTE This routine must not return.
-extern "C" __attribute__((visibility("default")))
-void nacl_helper_init(int argc, char *argv[],
-                      const char *nacl_reserved_space) {
+int main(int argc, char *argv[]) {
   CommandLine::Init(argc, argv);
   base::AtExitManager exit_manager;
   base::RandUint64();  // acquire /dev/urandom fd before sandbox is raised
   std::vector<int> empty; // for SendMsg() calls
 
   g_suid_sandbox_active = (NULL != getenv("SBX_D"));
-  g_nacl_reserved_space = nacl_reserved_space;
-  if (!nacl_reserved_space) {
-    VLOG(1) << "nacl_reserved_space is NULL";
-  } else {
-    VLOG(1) << "nacl_reserved_space is at "
-            << (void *)nacl_reserved_space;
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kNaClHelperAtZero)) {
+    g_nacl_prereserved_sandbox_addr = (void *) (uintptr_t) 0x10000;
   }
+
   // Send the zygote a message to let it know we are ready to help
   if (!UnixDomainSocket::SendMsg(kNaClZygoteDescriptor,
                                  kNaClHelperStartupAck,
                                  sizeof(kNaClHelperStartupAck), empty)) {
     LOG(ERROR) << "*** send() to zygote failed";
   }
 
   while (true) {
     int badpid = -1;
     std::vector<int> fds;
@@ skipping 21 matching lines @@
       }
     }
     // if fork fails, send PID=-1 to zygote
     if (!UnixDomainSocket::SendMsg(kNaClZygoteDescriptor, &badpid,
                                    sizeof(badpid), empty)) {
       LOG(ERROR) << "*** send() to zygote failed";
     }
   }
   CHECK(false);  // This routine must not return
 }