content/gpu/gpu_main.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stdlib.h>
   6
   7 #if defined(OS_WIN)
   8 #include <windows.h>
   9 #endif
  10
  11 #include "base/debug/trace_event.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/rand_util.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/threading/platform_thread.h"
  18 #include "build/build_config.h"
  19 #include "content/child/child_process.h"
  20 #include "content/common/content_constants_internal.h"
  21 #include "content/common/gpu/gpu_config.h"
  22 #include "content/common/gpu/gpu_messages.h"
  23 #include "content/common/sandbox_linux.h"
  24 #include "content/gpu/gpu_child_thread.h"
  25 #include "content/gpu/gpu_process.h"
  26 #include "content/gpu/gpu_watchdog_thread.h"
  27 #include "content/public/common/content_client.h"
  28 #include "content/public/common/content_switches.h"
  29 #include "content/public/common/main_function_params.h"
  30 #include "crypto/hmac.h"
  31 #include "gpu/config/gpu_info_collector.h"
  32 #include "ui/gl/gl_implementation.h"
  33 #include "ui/gl/gl_surface.h"
  34 #include "ui/gl/gl_switches.h"
  35 #include "ui/gl/gpu_switching_manager.h"
  36
  37 #if defined(OS_WIN)
  38 #include "base/win/scoped_com_initializer.h"
  39 #include "content/common/gpu/media/dxva_video_decode_accelerator.h"
  40 #include "sandbox/win/src/sandbox.h"
  41 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
  42 #include "content/common/gpu/media/exynos_video_decode_accelerator.h"
  43 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
  44 #include "content/common/gpu/media/vaapi_wrapper.h"
  45 #endif
  46
  47 #if defined(USE_X11)
  48 #include "ui/base/x/x11_util.h"
  49 #endif
  50
  51 #if defined(OS_LINUX)
  52 #include "content/public/common/sandbox_init.h"
  53 #endif
  54
  55 const int kGpuTimeout = 10000;
  56
  57 namespace content {
  58
  59 namespace {
  60
  61 bool WarmUpSandbox(const CommandLine& command_line);
  62 #if defined(OS_LINUX)
  63 bool StartSandboxLinux(const gpu::GPUInfo&, GpuWatchdogThread*, bool);
  64 #elif defined(OS_WIN)
  65 bool StartSandboxWindows(const sandbox::SandboxInterfaceInfo*);
  66 #endif
  67
  68 base::LazyInstance<GpuChildThread::DeferredMessages> deferred_messages =
  69     LAZY_INSTANCE_INITIALIZER;
  70
  71 bool GpuProcessLogMessageHandler(int severity,
  72                                  const char* file, int line,
  73                                  size_t message_start,
  74                                  const std::string& str) {
  75   std::string header = str.substr(0, message_start);
  76   std::string message = str.substr(message_start);
  77   deferred_messages.Get().push(new GpuHostMsg_OnLogMessage(
  78       severity, header, message));
  79   return false;
  80 }
  81
  82 }  // namespace anonymous
  83
  84 // Main function for starting the Gpu process.
  85 int GpuMain(const MainFunctionParams& parameters) {
  86   TRACE_EVENT0("gpu", "GpuMain");
  87   base::debug::TraceLog::GetInstance()->SetProcessName("GPU Process");
  88   base::debug::TraceLog::GetInstance()->SetProcessSortIndex(
  89       kTraceEventGpuProcessSortIndex);
  90
  91   const CommandLine& command_line = parameters.command_line;
  92   if (command_line.HasSwitch(switches::kGpuStartupDialog)) {
  93     ChildProcess::WaitForDebugger("Gpu");
  94   }
  95
  96   base::Time start_time = base::Time::Now();
  97
  98   bool in_browser_process = command_line.HasSwitch(switches::kSingleProcess) ||
  99                             command_line.HasSwitch(switches::kInProcessGPU);
 100
 101   if (!in_browser_process) {
 102 #if defined(OS_WIN)
 103     // Prevent Windows from displaying a modal dialog on failures like not being
 104     // able to load a DLL.
 105     SetErrorMode(
 106         SEM_FAILCRITICALERRORS |
 107         SEM_NOGPFAULTERRORBOX |
 108         SEM_NOOPENFILEERRORBOX);
 109 #elif defined(USE_X11)
 110     ui::SetDefaultX11ErrorHandlers();
 111 #endif
 112
 113     logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
 114   }
 115
 116   if (command_line.HasSwitch(switches::kSupportsDualGpus) &&
 117       command_line.HasSwitch(switches::kGpuSwitching)) {
 118     std::string option = command_line.GetSwitchValueASCII(
 119         switches::kGpuSwitching);
 120     if (option == switches::kGpuSwitchingOptionNameForceDiscrete)
 121       ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
 122     else if (option == switches::kGpuSwitchingOptionNameForceIntegrated)
 123       ui::GpuSwitchingManager::GetInstance()->ForceUseOfIntegratedGpu();
 124   }
 125
 126   // Initialization of the OpenGL bindings may fail, in which case we
 127   // will need to tear down this process. However, we can not do so
 128   // safely until the IPC channel is set up, because the detection of
 129   // early return of a child process is implemented using an IPC
 130   // channel error. If the IPC channel is not fully set up between the
 131   // browser and GPU process, and the GPU process crashes or exits
 132   // early, the browser process will never detect it.  For this reason
 133   // we defer tearing down the GPU process until receiving the
 134   // GpuMsg_Initialize message from the browser.
 135   bool dead_on_arrival = false;
 136
 137   base::MessageLoop::Type message_loop_type = base::MessageLoop::TYPE_IO;
 138 #if defined(OS_WIN)
 139   // Unless we're running on desktop GL, we don't need a UI message
 140   // loop, so avoid its use to work around apparent problems with some
 141   // third-party software.
 142   if (command_line.HasSwitch(switches::kUseGL) &&
 143       command_line.GetSwitchValueASCII(switches::kUseGL) ==
 144           gfx::kGLImplementationDesktopName) {
 145     message_loop_type = base::MessageLoop::TYPE_UI;
 146   }
 147 #elif defined(OS_LINUX)
 148   message_loop_type = base::MessageLoop::TYPE_DEFAULT;
 149 #endif
 150
 151   base::MessageLoop main_message_loop(message_loop_type);
 152   base::PlatformThread::SetName("CrGpuMain");
 153
 154   // In addition to disabling the watchdog if the command line switch is
 155   // present, disable the watchdog on valgrind because the code is expected
 156   // to run slowly in that case.
 157   bool enable_watchdog =
 158       !command_line.HasSwitch(switches::kDisableGpuWatchdog) &&
 159       !RunningOnValgrind();
 160
 161   // Disable the watchdog in debug builds because they tend to only be run by
 162   // developers who will not appreciate the watchdog killing the GPU process.
 163 #ifndef NDEBUG
 164   enable_watchdog = false;
 165 #endif
 166
 167   bool delayed_watchdog_enable = false;
 168
 169 #if defined(OS_CHROMEOS)
 170   // Don't start watchdog immediately, to allow developers to switch to VT2 on
 171   // startup.
 172   delayed_watchdog_enable = true;
 173 #endif
 174
 175   scoped_refptr<GpuWatchdogThread> watchdog_thread;
 176
 177   // Start the GPU watchdog only after anything that is expected to be time
 178   // consuming has completed, otherwise the process is liable to be aborted.
 179   if (enable_watchdog && !delayed_watchdog_enable) {
 180     watchdog_thread = new GpuWatchdogThread(kGpuTimeout);
 181     watchdog_thread->Start();
 182   }
 183
 184   gpu::GPUInfo gpu_info;
 185   // Get vendor_id, device_id, driver_version from browser process through
 186   // commandline switches.
 187   DCHECK(command_line.HasSwitch(switches::kGpuVendorID) &&
 188          command_line.HasSwitch(switches::kGpuDeviceID) &&
 189          command_line.HasSwitch(switches::kGpuDriverVersion));
 190   bool success = base::HexStringToInt(
 191       command_line.GetSwitchValueASCII(switches::kGpuVendorID),
 192       reinterpret_cast<int*>(&(gpu_info.gpu.vendor_id)));
 193   DCHECK(success);
 194   success = base::HexStringToInt(
 195       command_line.GetSwitchValueASCII(switches::kGpuDeviceID),
 196       reinterpret_cast<int*>(&(gpu_info.gpu.device_id)));
 197   DCHECK(success);
 198   gpu_info.driver_vendor =
 199       command_line.GetSwitchValueASCII(switches::kGpuDriverVendor);
 200   gpu_info.driver_version =
 201       command_line.GetSwitchValueASCII(switches::kGpuDriverVersion);
 202   GetContentClient()->SetGpuInfo(gpu_info);
 203
 204   // Warm up resources that don't need access to GPUInfo.
 205   if (WarmUpSandbox(command_line)) {
 206 #if defined(OS_LINUX)
 207     bool initialized_sandbox = false;
 208     bool initialized_gl_context = false;
 209     bool should_initialize_gl_context = false;
 210 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
 211     // On Chrome OS ARM, GPU driver userspace creates threads when initializing
 212     // a GL context, so start the sandbox early.
 213     gpu_info.sandboxed = StartSandboxLinux(gpu_info, watchdog_thread.get(),
 214                                            should_initialize_gl_context);
 215     initialized_sandbox = true;
 216 #endif
 217 #endif  // defined(OS_LINUX)
 218
 219     // Load and initialize the GL implementation and locate the GL entry points.
 220     if (gfx::GLSurface::InitializeOneOff()) {
 221       // We need to collect GL strings (VENDOR, RENDERER) for blacklisting
 222       // purposes. However, on Mac we don't actually use them. As documented in
 223       // crbug.com/222934, due to some driver issues, glGetString could take
 224       // multiple seconds to finish, which in turn cause the GPU process to
 225       // crash.
 226       // By skipping the following code on Mac, we don't really lose anything,
 227       // because the basic GPU information is passed down from browser process
 228       // and we already registered them through SetGpuInfo() above.
 229 #if !defined(OS_MACOSX)
 230       if (!gpu::CollectContextGraphicsInfo(&gpu_info))
 231         VLOG(1) << "gpu::CollectGraphicsInfo failed";
 232       GetContentClient()->SetGpuInfo(gpu_info);
 233
 234 #if defined(OS_LINUX)
 235       initialized_gl_context = true;
 236 #if !defined(OS_CHROMEOS)
 237       if (gpu_info.gpu.vendor_id == 0x10de &&  // NVIDIA
 238           gpu_info.driver_vendor == "NVIDIA") {
 239         base::ThreadRestrictions::AssertIOAllowed();
 240         if (access("/dev/nvidiactl", R_OK) != 0) {
 241           VLOG(1) << "NVIDIA device file /dev/nvidiactl access denied";
 242           dead_on_arrival = true;
 243         }
 244       }
 245 #endif  // !defined(OS_CHROMEOS)
 246 #endif  // defined(OS_LINUX)
 247 #endif  // !defined(OS_MACOSX)
 248     } else {
 249       VLOG(1) << "gfx::GLSurface::InitializeOneOff failed";
 250       dead_on_arrival = true;
 251     }
 252
 253     if (enable_watchdog && delayed_watchdog_enable) {
 254       watchdog_thread = new GpuWatchdogThread(kGpuTimeout);
 255       watchdog_thread->Start();
 256     }
 257
 258     // OSMesa is expected to run very slowly, so disable the watchdog in that
 259     // case.
 260     if (enable_watchdog &&
 261         gfx::GetGLImplementation() == gfx::kGLImplementationOSMesaGL) {
 262       watchdog_thread->Stop();
 263       watchdog_thread = NULL;
 264     }
 265
 266 #if defined(OS_LINUX)
 267     should_initialize_gl_context = !initialized_gl_context &&
 268                                    !dead_on_arrival;
 269
 270     if (!initialized_sandbox) {
 271       gpu_info.sandboxed = StartSandboxLinux(gpu_info, watchdog_thread.get(),
 272                                              should_initialize_gl_context);
 273     }
 274 #elif defined(OS_WIN)
 275     gpu_info.sandboxed = StartSandboxWindows(parameters.sandbox_info);
 276 #endif
 277   } else {
 278     dead_on_arrival = true;
 279   }
 280
 281   logging::SetLogMessageHandler(NULL);
 282
 283   GpuProcess gpu_process;
 284
 285   GpuChildThread* child_thread = new GpuChildThread(watchdog_thread.get(),
 286                                                     dead_on_arrival,
 287                                                     gpu_info,
 288                                                     deferred_messages.Get());
 289   while (!deferred_messages.Get().empty())
 290     deferred_messages.Get().pop();
 291
 292   child_thread->Init(start_time);
 293
 294   gpu_process.set_main_thread(child_thread);
 295
 296   if (watchdog_thread)
 297     watchdog_thread->AddPowerObserver();
 298
 299   {
 300     TRACE_EVENT0("gpu", "Run Message Loop");
 301     main_message_loop.Run();
 302   }
 303
 304   child_thread->StopWatchdog();
 305
 306   return 0;
 307 }
 308
 309 namespace {
 310
 311 #if defined(OS_LINUX)
 312 void CreateDummyGlContext() {
 313   scoped_refptr<gfx::GLSurface> surface(
 314       gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1)));
 315   if (!surface.get()) {
 316     VLOG(1) << "gfx::GLSurface::CreateOffscreenGLSurface failed";
 317     return;
 318   }
 319
 320   // On Linux, this is needed to make sure /dev/nvidiactl has
 321   // been opened and its descriptor cached.
 322   scoped_refptr<gfx::GLContext> context(gfx::GLContext::CreateGLContext(
 323       NULL, surface.get(), gfx::PreferDiscreteGpu));
 324   if (!context.get()) {
 325     VLOG(1) << "gfx::GLContext::CreateGLContext failed";
 326     return;
 327   }
 328
 329   // Similarly, this is needed for /dev/nvidia0.
 330   if (context->MakeCurrent(surface.get())) {
 331     context->ReleaseCurrent(surface.get());
 332   } else {
 333     VLOG(1)  << "gfx::GLContext::MakeCurrent failed";
 334   }
 335 }
 336 #endif
 337
 338 bool WarmUpSandbox(const CommandLine& command_line) {
 339   {
 340     TRACE_EVENT0("gpu", "Warm up rand");
 341     // Warm up the random subsystem, which needs to be done pre-sandbox on all
 342     // platforms.
 343     (void) base::RandUint64();
 344   }
 345   {
 346     TRACE_EVENT0("gpu", "Warm up HMAC");
 347     // Warm up the crypto subsystem, which needs to done pre-sandbox on all
 348     // platforms.
 349     crypto::HMAC hmac(crypto::HMAC::SHA256);
 350     unsigned char key = '\0';
 351     if (!hmac.Init(&key, sizeof(key))) {
 352       LOG(ERROR) << "WarmUpSandbox() failed with crypto::HMAC::Init()";
 353       return false;
 354     }
 355   }
 356
 357 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
 358   ExynosVideoDecodeAccelerator::PreSandboxInitialization();
 359 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
 360   VaapiWrapper::PreSandboxInitialization();
 361 #endif
 362
 363 #if defined(OS_WIN)
 364   {
 365     TRACE_EVENT0("gpu", "Preload setupapi.dll");
 366     // Preload this DLL because the sandbox prevents it from loading.
 367     if (LoadLibrary(L"setupapi.dll") == NULL) {
 368       LOG(ERROR) << "WarmUpSandbox() failed with loading setupapi.dll";
 369       return false;
 370     }
 371   }
 372
 373   if (!command_line.HasSwitch(switches::kDisableAcceleratedVideoDecode)) {
 374     TRACE_EVENT0("gpu", "Initialize DXVA");
 375     // Initialize H/W video decoding stuff which fails in the sandbox.
 376     DXVAVideoDecodeAccelerator::PreSandboxInitialization();
 377   }
 378 #endif
 379   return true;
 380 }
 381
 382 #if defined(OS_LINUX)
 383 void WarmUpSandboxNvidia(const gpu::GPUInfo& gpu_info,
 384                          bool should_initialize_gl_context) {
 385   // We special case Optimus since the vendor_id we see may not be Nvidia.
 386   bool uses_nvidia_driver = (gpu_info.gpu.vendor_id == 0x10de &&  // NVIDIA.
 387                              gpu_info.driver_vendor == "NVIDIA") ||
 388                             gpu_info.optimus;
 389   if (uses_nvidia_driver && should_initialize_gl_context) {
 390     // We need this on Nvidia to pre-open /dev/nvidiactl and /dev/nvidia0.
 391     CreateDummyGlContext();
 392   }
 393 }
 394
 395 bool StartSandboxLinux(const gpu::GPUInfo& gpu_info,
 396                        GpuWatchdogThread* watchdog_thread,
 397                        bool should_initialize_gl_context) {
 398   TRACE_EVENT0("gpu", "Initialize sandbox");
 399
 400   bool res = false;
 401
 402   WarmUpSandboxNvidia(gpu_info, should_initialize_gl_context);
 403
 404   if (watchdog_thread)
 405     watchdog_thread->Stop();
 406   // LinuxSandbox::InitializeSandbox() must always be called
 407   // with only one thread.
 408   res = LinuxSandbox::InitializeSandbox();
 409   if (watchdog_thread)
 410     watchdog_thread->Start();
 411
 412   return res;
 413 }
 414 #endif  // defined(OS_LINUX)
 415
 416 #if defined(OS_WIN)
 417 bool StartSandboxWindows(const sandbox::SandboxInterfaceInfo* sandbox_info) {
 418   TRACE_EVENT0("gpu", "Lower token");
 419
 420   // For Windows, if the target_services interface is not zero, the process
 421   // is sandboxed and we must call LowerToken() before rendering untrusted
 422   // content.
 423   sandbox::TargetServices* target_services = sandbox_info->target_services;
 424   if (target_services) {
 425     target_services->LowerToken();
 426     return true;
 427   }
 428
 429   return false;
 430 }
 431 #endif  // defined(OS_WIN)
 432
 433 }  // namespace.
 434
 435 }  // namespace content