Set up NaClChromeMainArgs number_of_cores member so apps can size threadpools appropriately

chrome/nacl/nacl_helper_linux.cc

 // Copyright (c) 2012 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 <fcntl.h>
@@ skipping 22 matching lines @@
 #include "ipc/ipc_switches.h"
 #include "sandbox/linux/services/libc_urandom_override.h"
 
 namespace {
 
 // 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,
-                      size_t prereserved_sandbox_size) {
+                      size_t prereserved_sandbox_size,
+                      int number_of_cores) {
   VLOG(1) << "NaCl loader: setting up IPC descriptor";
   // don't need zygote FD any more
   if (HANDLE_EINTR(close(kNaClZygoteDescriptor)) != 0)
     LOG(ERROR) << "close(kNaClZygoteDescriptor) failed.";
   base::GlobalDescriptors::GetInstance()->Set(kPrimaryIPCChannel,
                                               child_fds[kNaClBrowserFDIndex]);
 
   MessageLoopForIO main_message_loop;
   NaClListener listener;
   listener.set_prereserved_sandbox_size(prereserved_sandbox_size);
+  listener.set_number_of_cores(number_of_cores);
   listener.Listen();
   _exit(0);
 }
 
 // Some of this code was lifted from
 // content/browser/zygote_main_linux.cc:ForkWithRealPid()
 void HandleForkRequest(const std::vector<int>& child_fds,
-                       size_t prereserved_sandbox_size) {
+                       size_t prereserved_sandbox_size,
+                       int number_of_cores) {
   VLOG(1) << "nacl_helper: forking";
   pid_t childpid = fork();
   if (childpid < 0) {
     perror("fork");
     LOG(ERROR) << "*** HandleForkRequest failed\n";
     // fall through to parent case below
   } else if (childpid == 0) {  // In the child process.
     bool validack = false;
     const size_t kMaxReadSize = 1024;
     char buffer[kMaxReadSize];
@@ skipping 17 matching lines @@
             switches::kProcessChannelID,
             std::string(&buffer[len], nread - len));
         validack = true;
       }
     }
     if (HANDLE_EINTR(close(child_fds[kNaClDummyFDIndex])) != 0)
       LOG(ERROR) << "close(child_fds[kNaClDummyFDIndex]) failed";
     if (HANDLE_EINTR(close(child_fds[kNaClParentFDIndex])) != 0)
       LOG(ERROR) << "close(child_fds[kNaClParentFDIndex]) failed";
     if (validack) {
-      BecomeNaClLoader(child_fds, prereserved_sandbox_size);
+      BecomeNaClLoader(child_fds, prereserved_sandbox_size, number_of_cores);
     } else {
       LOG(ERROR) << "Failed to synch with zygote";
     }
     // NOTREACHED
     return;
   }
   // I am the parent.
   // First, close the dummy_fd so the sandbox won't find me when
   // looking for the child's pid in /proc. Also close other fds.
   for (size_t i = 0; i < child_fds.size(); i++) {
@@ skipping 119 matching lines @@
   // Without this line on Linux, HMAC::Init will instantiate a singleton that
   // in turn attempts to open a file.  Disabling this behavior avoids a ~70 ms
   // stall the first time HMAC is used.
   crypto::ForceNSSNoDBInit();
   // Load shared libraries before sandbox is raised.
   // NSS is needed to perform hashing for validation caching.
   crypto::LoadNSSLibraries();
 #endif
   std::vector<int> empty; // for SendMsg() calls
   size_t prereserved_sandbox_size = CheckReservedAtZero();
+  int number_of_cores = sysconf(_SC_NPROCESSORS_ONLN);
 
   CheckRDebug(argv[0]);
 
   // Check that IsSandboxed() works. We should not be sandboxed at this point.
   CHECK(!IsSandboxed()) << "Unexpectedly sandboxed!";
 
   // Send the zygote a message to let it know we are ready to help
   if (!UnixDomainSocket::SendMsg(kNaClZygoteDescriptor,
                                  kNaClHelperStartupAck,
                                  sizeof(kNaClHelperStartupAck), empty)) {
@@ skipping 16 matching lines @@
     }
     if (msglen == 0 || (msglen == -1 && errno == ECONNRESET)) {
       // EOF from the browser. Goodbye!
       _exit(0);
     } else if (msglen < 0) {
       LOG(ERROR) << "nacl_helper: receive from zygote failed, errno = "
                  << errno;
     } else if (msglen == sizeof(kNaClForkRequest) - 1 &&
                memcmp(buf, kNaClForkRequest, msglen) == 0) {
       if (kNaClParentFDIndex + 1 == fds.size()) {
-        HandleForkRequest(fds, prereserved_sandbox_size);
+        HandleForkRequest(fds, prereserved_sandbox_size, number_of_cores);
         continue;  // fork succeeded. Note: child does not return
       } else {
         LOG(ERROR) << "nacl_helper: unexpected number of fds, got "
                    << fds.size();
       }
     } else {
       LOG(ERROR) << "nacl_helper unrecognized request: "
                  << base::GetDoubleQuotedJson(std::string(buf, buf + msglen));
       _exit(-1);
     }
     // 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
 }