Add a switch for changing the fd limit on Mac/Linux....

chrome/browser/browser_main.cc

 // Copyright (c) 2006-2009 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.
 
 #include "build/build_config.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 42 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/net_resources.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_module.h"
 #include "net/http/http_network_session.h"
 
 #if defined(OS_POSIX)
 // TODO(port): get rid of this include. It's used just to provide declarations
 // and stub definitions for classes we encouter during the porting effort.
 #include "chrome/common/temp_scaffolding_stubs.h"
+#include <errno.h>
 #include <signal.h>
+#include <sys/resource.h>
 #endif
 
 #if defined(OS_LINUX)
 #include "chrome/app/breakpad_linux.h"
 #endif
 
 // TODO(port): several win-only methods have been pulled out of this, but
 // BrowserMain() as a whole needs to be broken apart so that it's usable by
 // other platforms. For now, it's just a stub. This is a serious work in
 // progress and should not be taken as an indication of a real refactoring.
@@ skipping 116 matching lines @@
   MessageLoopForUI::current()->Run(browser_process->accelerator_handler());
 #elif defined(OS_POSIX)
   MessageLoopForUI::current()->Run();
 #endif
 }
 
 #if defined(OS_POSIX)
 // See comment below, where sigaction is called.
 void SIGCHLDHandler(int signal) {
 }
+
+// Sets the file descriptor soft limit to |max_descriptors| or the OS hard
+// limit, whichever is lower.
+void SetFileDescriptorLimit(unsigned int max_descriptors) {
+  struct rlimit limits;
+  if (getrlimit(RLIMIT_NOFILE, &limits) == 0) {
+    unsigned int new_limit = max_descriptors;
+    if (limits.rlim_max > 0 && limits.rlim_max < max_descriptors) {
+      new_limit = limits.rlim_max;
+    }
+    limits.rlim_cur = new_limit;
+    if (setrlimit(RLIMIT_NOFILE, &limits) != 0) {
+      LOG(INFO) << "Failed to set file descriptor limit: " << strerror(errno);
+    }
+  } else {
+    LOG(INFO) << "Failed to get file descriptor limit: " << strerror(errno);
+  }
+}
 #endif
 
 #if defined(OS_WIN)
 void AddFirstRunNewTabs(BrowserInit* browser_init,
                         const std::vector<std::wstring>& new_tabs) {
   std::vector<std::wstring>::const_iterator it = new_tabs.begin();
   while (it != new_tabs.end()) {
     GURL url(*it);
     if (url.is_valid())
       browser_init->AddFirstRunTab(url);
@@ skipping 28 matching lines @@
   tracked_objects::AutoTracking tracking_objects;
 #endif
 
 #if defined(OS_POSIX)
   // We need to accept SIGCHLD, even though our handler is a no-op because
   // otherwise we cannot wait on children. (According to POSIX 2001.)
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_handler = SIGCHLDHandler;
   CHECK(sigaction(SIGCHLD, &action, NULL) == 0);
-#endif
+
+  const std::wstring fd_limit_string =
+      parsed_command_line.GetSwitchValue(switches::kFileDescriptorLimit);
+  int fd_limit = 0;
+  if (!fd_limit_string.empty()) {
+    StringToInt(WideToUTF16Hack(fd_limit_string), &fd_limit);
+  }
+#if defined(OS_MACOSX)
+  // We use quite a few file descriptors for our IPC, and the default limit on
+  // the Mac is low (256), so bump it up if there is no explicit override.
+  if (fd_limit == 0) {
+    fd_limit = 1024;
+  }
+#endif  // OS_MACOSX
+  if (fd_limit > 0) {
+    SetFileDescriptorLimit(fd_limit);
+  }
+#endif  // OS_POSIX
 
   // Do platform-specific things (such as finishing initializing Cocoa)
   // prior to instantiating the message loop. This could be turned into a
   // broadcast notification.
   Platform::WillInitializeMainMessageLoop(parsed_command_line);
 
   MessageLoop main_message_loop(MessageLoop::TYPE_UI);
 
   // Initialize the SystemMonitor
   base::SystemMonitor::Start();
@@ skipping 507 matching lines @@
   if (metrics)
     metrics->Stop();
 
   // browser_shutdown takes care of deleting browser_process, so we need to
   // release it.
   browser_process.release();
   browser_shutdown::Shutdown();
 
   return result_code;
 }