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 "content/browser/gpu/gpu_process_host.h" 6 7 #include "base/base64.h" 8 #include "base/base_switches.h" 9 #include "base/basictypes.h" 10 #include "base/bind.h" 11 #include "base/callback_helpers.h" 12 #include "base/command_line.h" 13 #include "base/debug/trace_event.h" 14 #include "base/logging.h" 15 #include "base/memory/ref_counted.h" 16 #include "base/metrics/histogram.h" 17 #include "base/sha1.h" 18 #include "base/threading/thread.h" 19 #include "content/browser/browser_child_process_host_impl.h" 20 #include "content/browser/gpu/gpu_data_manager_impl.h" 21 #include "content/browser/gpu/gpu_process_host_ui_shim.h" 22 #include "content/browser/gpu/shader_disk_cache.h" 23 #include "content/browser/renderer_host/render_widget_helper.h" 24 #include "content/browser/renderer_host/render_widget_host_impl.h" 25 #include "content/common/child_process_host_impl.h" 26 #include "content/common/gpu/gpu_messages.h" 27 #include "content/common/view_messages.h" 28 #include "content/public/browser/browser_thread.h" 29 #include "content/public/browser/content_browser_client.h" 30 #include "content/public/browser/render_process_host.h" 31 #include "content/public/browser/render_widget_host_view.h" 32 #include "content/public/browser/render_widget_host_view_frame_subscriber.h" 33 #include "content/public/common/content_client.h" 34 #include "content/public/common/content_switches.h" 35 #include "content/public/common/result_codes.h" 36 #include "content/public/common/sandboxed_process_launcher_delegate.h" 37 #include "gpu/command_buffer/service/gpu_switches.h" 38 #include "ipc/ipc_channel_handle.h" 39 #include "ipc/ipc_switches.h" 40 #include "ipc/message_filter.h" 41 #include "media/base/media_switches.h" 42 #include "ui/events/latency_info.h" 43 #include "ui/gl/gl_switches.h" 44 45 46 #if defined(OS_WIN) 47 #include "base/win/windows_version.h" 48 #include "content/common/sandbox_win.h" 49 #include "sandbox/win/src/sandbox_policy.h" 50 #include "ui/gfx/switches.h" 51 #endif 52 53 #if defined(USE_OZONE) 54 #include "ui/ozone/ozone_switches.h" 55 #endif 56 57 #if defined(USE_X11) && !defined(OS_CHROMEOS) 58 #include "ui/gfx/x/x11_switches.h" 59 #endif 60 61 namespace content { 62 63 bool GpuProcessHost::gpu_enabled_ = true; 64 bool GpuProcessHost::hardware_gpu_enabled_ = true; 65 66 namespace { 67 68 enum GPUProcessLifetimeEvent { 69 LAUNCHED, 70 DIED_FIRST_TIME, 71 DIED_SECOND_TIME, 72 DIED_THIRD_TIME, 73 DIED_FOURTH_TIME, 74 GPU_PROCESS_LIFETIME_EVENT_MAX = 100 75 }; 76 77 // Indexed by GpuProcessKind. There is one of each kind maximum. This array may 78 // only be accessed from the IO thread. 79 GpuProcessHost* g_gpu_process_hosts[GpuProcessHost::GPU_PROCESS_KIND_COUNT]; 80 81 82 void SendGpuProcessMessage(GpuProcessHost::GpuProcessKind kind, 83 CauseForGpuLaunch cause, 84 IPC::Message* message) { 85 GpuProcessHost* host = GpuProcessHost::Get(kind, cause); 86 if (host) { 87 host->Send(message); 88 } else { 89 delete message; 90 } 91 } 92 93 // NOTE: changes to this class need to be reviewed by the security team. 94 class GpuSandboxedProcessLauncherDelegate 95 : public SandboxedProcessLauncherDelegate { 96 public: 97 GpuSandboxedProcessLauncherDelegate(CommandLine* cmd_line, 98 ChildProcessHost* host) 99 #if defined(OS_WIN) 100 : cmd_line_(cmd_line) {} 101 #elif defined(OS_POSIX) 102 : ipc_fd_(host->TakeClientFileDescriptor()) {} 103 #endif 104 105 virtual ~GpuSandboxedProcessLauncherDelegate() {} 106 107 #if defined(OS_WIN) 108 virtual bool ShouldSandbox() OVERRIDE { 109 bool sandbox = !cmd_line_->HasSwitch(switches::kDisableGpuSandbox); 110 if(! sandbox) { 111 DVLOG(1) << "GPU sandbox is disabled"; 112 } 113 return sandbox; 114 } 115 116 virtual void PreSandbox(bool* disable_default_policy, 117 base::FilePath* exposed_dir) OVERRIDE { 118 *disable_default_policy = true; 119 } 120 121 // For the GPU process we gotten as far as USER_LIMITED. The next level 122 // which is USER_RESTRICTED breaks both the DirectX backend and the OpenGL 123 // backend. Note that the GPU process is connected to the interactive 124 // desktop. 125 virtual void PreSpawnTarget(sandbox::TargetPolicy* policy, 126 bool* success) { 127 if (base::win::GetVersion() > base::win::VERSION_XP) { 128 if (cmd_line_->GetSwitchValueASCII(switches::kUseGL) == 129 gfx::kGLImplementationDesktopName) { 130 // Open GL path. 131 policy->SetTokenLevel(sandbox::USER_RESTRICTED_SAME_ACCESS, 132 sandbox::USER_LIMITED); 133 SetJobLevel(*cmd_line_, sandbox::JOB_UNPROTECTED, 0, policy); 134 policy->SetDelayedIntegrityLevel(sandbox::INTEGRITY_LEVEL_LOW); 135 } else { 136 policy->SetTokenLevel(sandbox::USER_RESTRICTED_SAME_ACCESS, 137 sandbox::USER_LIMITED); 138 139 // UI restrictions break when we access Windows from outside our job. 140 // However, we don't want a proxy window in this process because it can 141 // introduce deadlocks where the renderer blocks on the gpu, which in 142 // turn blocks on the browser UI thread. So, instead we forgo a window 143 // message pump entirely and just add job restrictions to prevent child 144 // processes. 145 SetJobLevel(*cmd_line_, 146 sandbox::JOB_LIMITED_USER, 147 JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS | 148 JOB_OBJECT_UILIMIT_DESKTOP | 149 JOB_OBJECT_UILIMIT_EXITWINDOWS | 150 JOB_OBJECT_UILIMIT_DISPLAYSETTINGS, 151 policy); 152 153 policy->SetIntegrityLevel(sandbox::INTEGRITY_LEVEL_LOW); 154 } 155 } else { 156 SetJobLevel(*cmd_line_, sandbox::JOB_UNPROTECTED, 0, policy); 157 policy->SetTokenLevel(sandbox::USER_UNPROTECTED, 158 sandbox::USER_LIMITED); 159 } 160 161 // Allow the server side of GPU sockets, which are pipes that have 162 // the "chrome.gpu" namespace and an arbitrary suffix. 163 sandbox::ResultCode result = policy->AddRule( 164 sandbox::TargetPolicy::SUBSYS_NAMED_PIPES, 165 sandbox::TargetPolicy::NAMEDPIPES_ALLOW_ANY, 166 L"\\\\.\\pipe\\chrome.gpu.*"); 167 if (result != sandbox::SBOX_ALL_OK) { 168 *success = false; 169 return; 170 } 171 172 // Block this DLL even if it is not loaded by the browser process. 173 policy->AddDllToUnload(L"cmsetac.dll"); 174 175 #ifdef USE_AURA 176 // GPU also needs to add sections to the browser for aura 177 // TODO(jschuh): refactor the GPU channel to remove this. crbug.com/128786 178 result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_HANDLES, 179 sandbox::TargetPolicy::HANDLES_DUP_BROKER, 180 L"Section"); 181 if (result != sandbox::SBOX_ALL_OK) { 182 *success = false; 183 return; 184 } 185 #endif 186 187 if (cmd_line_->HasSwitch(switches::kEnableLogging)) { 188 base::string16 log_file_path = logging::GetLogFileFullPath(); 189 if (!log_file_path.empty()) { 190 result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES, 191 sandbox::TargetPolicy::FILES_ALLOW_ANY, 192 log_file_path.c_str()); 193 if (result != sandbox::SBOX_ALL_OK) { 194 *success = false; 195 return; 196 } 197 } 198 } 199 } 200 #elif defined(OS_POSIX) 201 202 virtual int GetIpcFd() OVERRIDE { 203 return ipc_fd_; 204 } 205 #endif // OS_WIN 206 207 private: 208 #if defined(OS_WIN) 209 CommandLine* cmd_line_; 210 #elif defined(OS_POSIX) 211 int ipc_fd_; 212 #endif // OS_WIN 213 }; 214 215 } // anonymous namespace 216 217 // static 218 bool GpuProcessHost::ValidateHost(GpuProcessHost* host) { 219 // The Gpu process is invalid if it's not using SwiftShader, the card is 220 // blacklisted, and we can kill it and start over. 221 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) || 222 CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU) || 223 (host->valid_ && 224 (host->swiftshader_rendering_ || 225 !GpuDataManagerImpl::GetInstance()->ShouldUseSwiftShader()))) { 226 return true; 227 } 228 229 host->ForceShutdown(); 230 return false; 231 } 232 233 // static 234 GpuProcessHost* GpuProcessHost::Get(GpuProcessKind kind, 235 CauseForGpuLaunch cause) { 236 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 237 238 // Don't grant further access to GPU if it is not allowed. 239 GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance(); 240 DCHECK(gpu_data_manager); 241 if (!gpu_data_manager->GpuAccessAllowed(NULL)) 242 return NULL; 243 244 if (g_gpu_process_hosts[kind] && ValidateHost(g_gpu_process_hosts[kind])) 245 return g_gpu_process_hosts[kind]; 246 247 if (cause == CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH) 248 return NULL; 249 250 static int last_host_id = 0; 251 int host_id; 252 host_id = ++last_host_id; 253 254 UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLaunchCause", 255 cause, 256 CAUSE_FOR_GPU_LAUNCH_MAX_ENUM); 257 258 GpuProcessHost* host = new GpuProcessHost(host_id, kind); 259 if (host->Init()) 260 return host; 261 262 delete host; 263 return NULL; 264 } 265 266 // static 267 void GpuProcessHost::GetProcessHandles( 268 const GpuDataManager::GetGpuProcessHandlesCallback& callback) { 269 if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) { 270 BrowserThread::PostTask( 271 BrowserThread::IO, 272 FROM_HERE, 273 base::Bind(&GpuProcessHost::GetProcessHandles, callback)); 274 return; 275 } 276 std::list<base::ProcessHandle> handles; 277 for (size_t i = 0; i < arraysize(g_gpu_process_hosts); ++i) { 278 GpuProcessHost* host = g_gpu_process_hosts[i]; 279 if (host && ValidateHost(host)) 280 handles.push_back(host->process_->GetHandle()); 281 } 282 BrowserThread::PostTask( 283 BrowserThread::UI, 284 FROM_HERE, 285 base::Bind(callback, handles)); 286 } 287 288 // static 289 void GpuProcessHost::SendOnIO(GpuProcessKind kind, 290 CauseForGpuLaunch cause, 291 IPC::Message* message) { 292 if (!BrowserThread::PostTask( 293 BrowserThread::IO, FROM_HERE, 294 base::Bind( 295 &SendGpuProcessMessage, kind, cause, message))) { 296 delete message; 297 } 298 } 299 300 GpuMainThreadFactoryFunction g_gpu_main_thread_factory = NULL; 301 302 void GpuProcessHost::RegisterGpuMainThreadFactory( 303 GpuMainThreadFactoryFunction create) { 304 g_gpu_main_thread_factory = create; 305 } 306 307 // static 308 GpuProcessHost* GpuProcessHost::FromID(int host_id) { 309 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 310 311 for (int i = 0; i < GPU_PROCESS_KIND_COUNT; ++i) { 312 GpuProcessHost* host = g_gpu_process_hosts[i]; 313 if (host && host->host_id_ == host_id && ValidateHost(host)) 314 return host; 315 } 316 317 return NULL; 318 } 319 320 GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind) 321 : host_id_(host_id), 322 valid_(true), 323 in_process_(false), 324 swiftshader_rendering_(false), 325 kind_(kind), 326 process_launched_(false), 327 initialized_(false), 328 uma_memory_stats_received_(false) { 329 if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) || 330 CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU)) { 331 in_process_ = true; 332 } 333 334 // If the 'single GPU process' policy ever changes, we still want to maintain 335 // it for 'gpu thread' mode and only create one instance of host and thread. 336 DCHECK(!in_process_ || g_gpu_process_hosts[kind] == NULL); 337 338 g_gpu_process_hosts[kind] = this; 339 340 // Post a task to create the corresponding GpuProcessHostUIShim. The 341 // GpuProcessHostUIShim will be destroyed if either the browser exits, 342 // in which case it calls GpuProcessHostUIShim::DestroyAll, or the 343 // GpuProcessHost is destroyed, which happens when the corresponding GPU 344 // process terminates or fails to launch. 345 BrowserThread::PostTask( 346 BrowserThread::UI, 347 FROM_HERE, 348 base::Bind(base::IgnoreResult(&GpuProcessHostUIShim::Create), host_id)); 349 350 process_.reset(new BrowserChildProcessHostImpl(PROCESS_TYPE_GPU, this)); 351 } 352 353 GpuProcessHost::~GpuProcessHost() { 354 DCHECK(CalledOnValidThread()); 355 356 SendOutstandingReplies(); 357 358 // Maximum number of times the gpu process is allowed to crash in a session. 359 // Once this limit is reached, any request to launch the gpu process will 360 // fail. 361 const int kGpuMaxCrashCount = 3; 362 363 // Number of times the gpu process has crashed in the current browser session. 364 static int gpu_crash_count = 0; 365 static int gpu_recent_crash_count = 0; 366 static base::Time last_gpu_crash_time; 367 static bool crashed_before = false; 368 static int swiftshader_crash_count = 0; 369 370 bool disable_crash_limit = CommandLine::ForCurrentProcess()->HasSwitch( 371 switches::kDisableGpuProcessCrashLimit); 372 373 // Ending only acts as a failure if the GPU process was actually started and 374 // was intended for actual rendering (and not just checking caps or other 375 // options). 376 if (process_launched_ && kind_ == GPU_PROCESS_KIND_SANDBOXED) { 377 if (swiftshader_rendering_) { 378 UMA_HISTOGRAM_ENUMERATION("GPU.SwiftShaderLifetimeEvents", 379 DIED_FIRST_TIME + swiftshader_crash_count, 380 GPU_PROCESS_LIFETIME_EVENT_MAX); 381 382 if (++swiftshader_crash_count >= kGpuMaxCrashCount && 383 !disable_crash_limit) { 384 // SwiftShader is too unstable to use. Disable it for current session. 385 gpu_enabled_ = false; 386 } 387 } else { 388 ++gpu_crash_count; 389 UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents", 390 std::min(DIED_FIRST_TIME + gpu_crash_count, 391 GPU_PROCESS_LIFETIME_EVENT_MAX - 1), 392 GPU_PROCESS_LIFETIME_EVENT_MAX); 393 394 // Allow about 1 GPU crash per hour to be removed from the crash count, 395 // so very occasional crashes won't eventually add up and prevent the 396 // GPU process from launching. 397 ++gpu_recent_crash_count; 398 base::Time current_time = base::Time::Now(); 399 if (crashed_before) { 400 int hours_different = (current_time - last_gpu_crash_time).InHours(); 401 gpu_recent_crash_count = 402 std::max(0, gpu_recent_crash_count - hours_different); 403 } 404 405 crashed_before = true; 406 last_gpu_crash_time = current_time; 407 408 if ((gpu_recent_crash_count >= kGpuMaxCrashCount && !disable_crash_limit) 409 || !initialized_) { 410 #if !defined(OS_CHROMEOS) 411 // The gpu process is too unstable to use. Disable it for current 412 // session. 413 hardware_gpu_enabled_ = false; 414 GpuDataManagerImpl::GetInstance()->DisableHardwareAcceleration(); 415 #endif 416 } 417 } 418 } 419 420 // In case we never started, clean up. 421 while (!queued_messages_.empty()) { 422 delete queued_messages_.front(); 423 queued_messages_.pop(); 424 } 425 426 // This is only called on the IO thread so no race against the constructor 427 // for another GpuProcessHost. 428 if (g_gpu_process_hosts[kind_] == this) 429 g_gpu_process_hosts[kind_] = NULL; 430 431 // If there are any remaining offscreen contexts at the point the 432 // GPU process exits, assume something went wrong, and block their 433 // URLs from accessing client 3D APIs without prompting. 434 BlockLiveOffscreenContexts(); 435 436 UMA_HISTOGRAM_COUNTS_100("GPU.AtExitSurfaceCount", 437 GpuSurfaceTracker::Get()->GetSurfaceCount()); 438 UMA_HISTOGRAM_BOOLEAN("GPU.AtExitReceivedMemoryStats", 439 uma_memory_stats_received_); 440 441 if (uma_memory_stats_received_) { 442 UMA_HISTOGRAM_COUNTS_100("GPU.AtExitManagedMemoryClientCount", 443 uma_memory_stats_.client_count); 444 UMA_HISTOGRAM_COUNTS_100("GPU.AtExitContextGroupCount", 445 uma_memory_stats_.context_group_count); 446 UMA_HISTOGRAM_CUSTOM_COUNTS( 447 "GPU.AtExitMBytesAllocated", 448 uma_memory_stats_.bytes_allocated_current / 1024 / 1024, 1, 2000, 50); 449 UMA_HISTOGRAM_CUSTOM_COUNTS( 450 "GPU.AtExitMBytesAllocatedMax", 451 uma_memory_stats_.bytes_allocated_max / 1024 / 1024, 1, 2000, 50); 452 UMA_HISTOGRAM_CUSTOM_COUNTS( 453 "GPU.AtExitMBytesLimit", 454 uma_memory_stats_.bytes_limit / 1024 / 1024, 1, 2000, 50); 455 } 456 457 std::string message; 458 if (!in_process_) { 459 int exit_code; 460 base::TerminationStatus status = process_->GetTerminationStatus( 461 false /* known_dead */, &exit_code); 462 UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessTerminationStatus", 463 status, 464 base::TERMINATION_STATUS_MAX_ENUM); 465 466 if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION || 467 status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION) { 468 UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessExitCode", 469 exit_code, 470 RESULT_CODE_LAST_CODE); 471 } 472 473 switch (status) { 474 case base::TERMINATION_STATUS_NORMAL_TERMINATION: 475 message = "The GPU process exited normally. Everything is okay."; 476 break; 477 case base::TERMINATION_STATUS_ABNORMAL_TERMINATION: 478 message = base::StringPrintf( 479 "The GPU process exited with code %d.", 480 exit_code); 481 break; 482 case base::TERMINATION_STATUS_PROCESS_WAS_KILLED: 483 message = "You killed the GPU process! Why?"; 484 break; 485 case base::TERMINATION_STATUS_PROCESS_CRASHED: 486 message = "The GPU process crashed!"; 487 break; 488 default: 489 break; 490 } 491 } 492 493 BrowserThread::PostTask(BrowserThread::UI, 494 FROM_HERE, 495 base::Bind(&GpuProcessHostUIShim::Destroy, 496 host_id_, 497 message)); 498 } 499 500 bool GpuProcessHost::Init() { 501 init_start_time_ = base::TimeTicks::Now(); 502 503 TRACE_EVENT_INSTANT0("gpu", "LaunchGpuProcess", TRACE_EVENT_SCOPE_THREAD); 504 505 std::string channel_id = process_->GetHost()->CreateChannel(); 506 if (channel_id.empty()) 507 return false; 508 509 if (in_process_) { 510 DCHECK(g_gpu_main_thread_factory); 511 CommandLine* command_line = CommandLine::ForCurrentProcess(); 512 command_line->AppendSwitch(switches::kDisableGpuWatchdog); 513 514 GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance(); 515 DCHECK(gpu_data_manager); 516 gpu_data_manager->AppendGpuCommandLine(command_line); 517 518 in_process_gpu_thread_.reset(g_gpu_main_thread_factory(channel_id)); 519 in_process_gpu_thread_->Start(); 520 521 OnProcessLaunched(); // Fake a callback that the process is ready. 522 } else if (!LaunchGpuProcess(channel_id)) { 523 return false; 524 } 525 526 if (!Send(new GpuMsg_Initialize())) 527 return false; 528 529 return true; 530 } 531 532 void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) { 533 BrowserThread::PostTask( 534 BrowserThread::UI, 535 FROM_HERE, 536 base::Bind(&RouteToGpuProcessHostUIShimTask, host_id_, message)); 537 } 538 539 bool GpuProcessHost::Send(IPC::Message* msg) { 540 DCHECK(CalledOnValidThread()); 541 if (process_->GetHost()->IsChannelOpening()) { 542 queued_messages_.push(msg); 543 return true; 544 } 545 546 bool result = process_->Send(msg); 547 if (!result) { 548 // Channel is hosed, but we may not get destroyed for a while. Send 549 // outstanding channel creation failures now so that the caller can restart 550 // with a new process/channel without waiting. 551 SendOutstandingReplies(); 552 } 553 return result; 554 } 555 556 void GpuProcessHost::AddFilter(IPC::MessageFilter* filter) { 557 DCHECK(CalledOnValidThread()); 558 process_->GetHost()->AddFilter(filter); 559 } 560 561 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) { 562 DCHECK(CalledOnValidThread()); 563 IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message) 564 IPC_MESSAGE_HANDLER(GpuHostMsg_Initialized, OnInitialized) 565 IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished) 566 IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated) 567 IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyCommandBuffer, OnDestroyCommandBuffer) 568 IPC_MESSAGE_HANDLER(GpuHostMsg_ImageCreated, OnImageCreated) 569 IPC_MESSAGE_HANDLER(GpuHostMsg_GpuMemoryBufferCreated, 570 OnGpuMemoryBufferCreated) 571 IPC_MESSAGE_HANDLER(GpuHostMsg_DidCreateOffscreenContext, 572 OnDidCreateOffscreenContext) 573 IPC_MESSAGE_HANDLER(GpuHostMsg_DidLoseContext, OnDidLoseContext) 574 IPC_MESSAGE_HANDLER(GpuHostMsg_DidDestroyOffscreenContext, 575 OnDidDestroyOffscreenContext) 576 IPC_MESSAGE_HANDLER(GpuHostMsg_GpuMemoryUmaStats, 577 OnGpuMemoryUmaStatsReceived) 578 #if defined(OS_MACOSX) 579 IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped, 580 OnAcceleratedSurfaceBuffersSwapped) 581 #endif 582 IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyChannel, 583 OnDestroyChannel) 584 IPC_MESSAGE_HANDLER(GpuHostMsg_CacheShader, 585 OnCacheShader) 586 587 IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message)) 588 IPC_END_MESSAGE_MAP() 589 590 return true; 591 } 592 593 void GpuProcessHost::OnChannelConnected(int32 peer_pid) { 594 TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelConnected"); 595 596 while (!queued_messages_.empty()) { 597 Send(queued_messages_.front()); 598 queued_messages_.pop(); 599 } 600 } 601 602 void GpuProcessHost::EstablishGpuChannel( 603 int client_id, 604 bool share_context, 605 const EstablishChannelCallback& callback) { 606 DCHECK(CalledOnValidThread()); 607 TRACE_EVENT0("gpu", "GpuProcessHost::EstablishGpuChannel"); 608 609 // If GPU features are already blacklisted, no need to establish the channel. 610 if (!GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL)) { 611 DVLOG(1) << "GPU blacklisted, refusing to open a GPU channel."; 612 callback.Run(IPC::ChannelHandle(), gpu::GPUInfo()); 613 return; 614 } 615 616 if (Send(new GpuMsg_EstablishChannel(client_id, share_context))) { 617 channel_requests_.push(callback); 618 } else { 619 DVLOG(1) << "Failed to send GpuMsg_EstablishChannel."; 620 callback.Run(IPC::ChannelHandle(), gpu::GPUInfo()); 621 } 622 623 if (!CommandLine::ForCurrentProcess()->HasSwitch( 624 switches::kDisableGpuShaderDiskCache)) { 625 CreateChannelCache(client_id); 626 } 627 } 628 629 void GpuProcessHost::CreateViewCommandBuffer( 630 const gfx::GLSurfaceHandle& compositing_surface, 631 int surface_id, 632 int client_id, 633 const GPUCreateCommandBufferConfig& init_params, 634 int route_id, 635 const CreateCommandBufferCallback& callback) { 636 TRACE_EVENT0("gpu", "GpuProcessHost::CreateViewCommandBuffer"); 637 638 DCHECK(CalledOnValidThread()); 639 640 if (!compositing_surface.is_null() && 641 Send(new GpuMsg_CreateViewCommandBuffer( 642 compositing_surface, surface_id, client_id, init_params, route_id))) { 643 create_command_buffer_requests_.push(callback); 644 surface_refs_.insert(std::make_pair(surface_id, 645 GpuSurfaceTracker::GetInstance()->GetSurfaceRefForSurface(surface_id))); 646 } else { 647 // Could distinguish here between compositing_surface being NULL 648 // and Send failing, if desired. 649 callback.Run(CREATE_COMMAND_BUFFER_FAILED_AND_CHANNEL_LOST); 650 } 651 } 652 653 void GpuProcessHost::CreateImage(gfx::PluginWindowHandle window, 654 int client_id, 655 int image_id, 656 const CreateImageCallback& callback) { 657 TRACE_EVENT0("gpu", "GpuProcessHost::CreateImage"); 658 659 DCHECK(CalledOnValidThread()); 660 661 if (Send(new GpuMsg_CreateImage(window, client_id, image_id))) { 662 create_image_requests_.push(callback); 663 } else { 664 callback.Run(gfx::Size()); 665 } 666 } 667 668 void GpuProcessHost::DeleteImage(int client_id, 669 int image_id, 670 int sync_point) { 671 TRACE_EVENT0("gpu", "GpuProcessHost::DeleteImage"); 672 673 DCHECK(CalledOnValidThread()); 674 675 Send(new GpuMsg_DeleteImage(client_id, image_id, sync_point)); 676 } 677 678 void GpuProcessHost::CreateGpuMemoryBuffer( 679 const gfx::GpuMemoryBufferHandle& handle, 680 const gfx::Size& size, 681 unsigned internalformat, 682 unsigned usage, 683 const CreateGpuMemoryBufferCallback& callback) { 684 TRACE_EVENT0("gpu", "GpuProcessHost::CreateGpuMemoryBuffer"); 685 686 DCHECK(CalledOnValidThread()); 687 688 if (Send(new GpuMsg_CreateGpuMemoryBuffer( 689 handle, size, internalformat, usage))) { 690 create_gpu_memory_buffer_requests_.push(callback); 691 } else { 692 callback.Run(gfx::GpuMemoryBufferHandle()); 693 } 694 } 695 696 void GpuProcessHost::DestroyGpuMemoryBuffer( 697 const gfx::GpuMemoryBufferHandle& handle, 698 int sync_point) { 699 TRACE_EVENT0("gpu", "GpuProcessHost::DestroyGpuMemoryBuffer"); 700 701 DCHECK(CalledOnValidThread()); 702 703 Send(new GpuMsg_DestroyGpuMemoryBuffer(handle, sync_point)); 704 } 705 706 void GpuProcessHost::OnInitialized(bool result, const gpu::GPUInfo& gpu_info) { 707 UMA_HISTOGRAM_BOOLEAN("GPU.GPUProcessInitialized", result); 708 initialized_ = result; 709 710 if (!initialized_) 711 GpuDataManagerImpl::GetInstance()->OnGpuProcessInitFailure(); 712 else if (!in_process_) 713 GpuDataManagerImpl::GetInstance()->UpdateGpuInfo(gpu_info); 714 } 715 716 void GpuProcessHost::OnChannelEstablished( 717 const IPC::ChannelHandle& channel_handle) { 718 TRACE_EVENT0("gpu", "GpuProcessHost::OnChannelEstablished"); 719 720 if (channel_requests_.empty()) { 721 // This happens when GPU process is compromised. 722 RouteOnUIThread(GpuHostMsg_OnLogMessage( 723 logging::LOG_WARNING, 724 "WARNING", 725 "Received a ChannelEstablished message but no requests in queue.")); 726 return; 727 } 728 EstablishChannelCallback callback = channel_requests_.front(); 729 channel_requests_.pop(); 730 731 // Currently if any of the GPU features are blacklisted, we don't establish a 732 // GPU channel. 733 if (!channel_handle.name.empty() && 734 !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL)) { 735 Send(new GpuMsg_CloseChannel(channel_handle)); 736 callback.Run(IPC::ChannelHandle(), gpu::GPUInfo()); 737 RouteOnUIThread(GpuHostMsg_OnLogMessage( 738 logging::LOG_WARNING, 739 "WARNING", 740 "Hardware acceleration is unavailable.")); 741 return; 742 } 743 744 callback.Run(channel_handle, 745 GpuDataManagerImpl::GetInstance()->GetGPUInfo()); 746 } 747 748 void GpuProcessHost::OnCommandBufferCreated(CreateCommandBufferResult result) { 749 TRACE_EVENT0("gpu", "GpuProcessHost::OnCommandBufferCreated"); 750 751 if (create_command_buffer_requests_.empty()) 752 return; 753 754 CreateCommandBufferCallback callback = 755 create_command_buffer_requests_.front(); 756 create_command_buffer_requests_.pop(); 757 callback.Run(result); 758 } 759 760 void GpuProcessHost::OnDestroyCommandBuffer(int32 surface_id) { 761 TRACE_EVENT0("gpu", "GpuProcessHost::OnDestroyCommandBuffer"); 762 SurfaceRefMap::iterator it = surface_refs_.find(surface_id); 763 if (it != surface_refs_.end()) { 764 surface_refs_.erase(it); 765 } 766 } 767 768 void GpuProcessHost::OnImageCreated(const gfx::Size size) { 769 TRACE_EVENT0("gpu", "GpuProcessHost::OnImageCreated"); 770 771 if (create_image_requests_.empty()) 772 return; 773 774 CreateImageCallback callback = create_image_requests_.front(); 775 create_image_requests_.pop(); 776 callback.Run(size); 777 } 778 779 void GpuProcessHost::OnGpuMemoryBufferCreated( 780 const gfx::GpuMemoryBufferHandle& handle) { 781 TRACE_EVENT0("gpu", "GpuProcessHost::OnGpuMemoryBufferCreated"); 782 783 if (create_gpu_memory_buffer_requests_.empty()) 784 return; 785 786 CreateGpuMemoryBufferCallback callback = 787 create_gpu_memory_buffer_requests_.front(); 788 create_gpu_memory_buffer_requests_.pop(); 789 callback.Run(handle); 790 } 791 792 void GpuProcessHost::OnDidCreateOffscreenContext(const GURL& url) { 793 urls_with_live_offscreen_contexts_.insert(url); 794 } 795 796 void GpuProcessHost::OnDidLoseContext(bool offscreen, 797 gpu::error::ContextLostReason reason, 798 const GURL& url) { 799 // TODO(kbr): would be nice to see the "offscreen" flag too. 800 TRACE_EVENT2("gpu", "GpuProcessHost::OnDidLoseContext", 801 "reason", reason, 802 "url", 803 url.possibly_invalid_spec()); 804 805 if (!offscreen || url.is_empty()) { 806 // Assume that the loss of the compositor's or accelerated canvas' 807 // context is a serious event and blame the loss on all live 808 // offscreen contexts. This more robustly handles situations where 809 // the GPU process may not actually detect the context loss in the 810 // offscreen context. 811 BlockLiveOffscreenContexts(); 812 return; 813 } 814 815 GpuDataManagerImpl::DomainGuilt guilt; 816 switch (reason) { 817 case gpu::error::kGuilty: 818 guilt = GpuDataManagerImpl::DOMAIN_GUILT_KNOWN; 819 break; 820 case gpu::error::kUnknown: 821 guilt = GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN; 822 break; 823 case gpu::error::kInnocent: 824 return; 825 default: 826 NOTREACHED(); 827 return; 828 } 829 830 GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(url, guilt); 831 } 832 833 void GpuProcessHost::OnDidDestroyOffscreenContext(const GURL& url) { 834 urls_with_live_offscreen_contexts_.erase(url); 835 } 836 837 void GpuProcessHost::OnGpuMemoryUmaStatsReceived( 838 const GPUMemoryUmaStats& stats) { 839 TRACE_EVENT0("gpu", "GpuProcessHost::OnGpuMemoryUmaStatsReceived"); 840 uma_memory_stats_received_ = true; 841 uma_memory_stats_ = stats; 842 } 843 844 #if defined(OS_MACOSX) 845 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped( 846 const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) { 847 TRACE_EVENT0("gpu", "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped"); 848 849 if (!ui::LatencyInfo::Verify(params.latency_info, 850 "GpuHostMsg_AcceleratedSurfaceBuffersSwapped")) 851 return; 852 853 gfx::AcceleratedWidget native_widget = 854 GpuSurfaceTracker::Get()->AcquireNativeWidget(params.surface_id); 855 if (native_widget) { 856 RenderWidgetHelper::OnNativeSurfaceBuffersSwappedOnIOThread(this, params); 857 return; 858 } 859 860 gfx::GLSurfaceHandle surface_handle = 861 GpuSurfaceTracker::Get()->GetSurfaceHandle(params.surface_id); 862 // Compositor window is always gfx::kNullPluginWindow. 863 // TODO(jbates) http://crbug.com/105344 This will be removed when there are no 864 // plugin windows. 865 if (surface_handle.handle != gfx::kNullPluginWindow || 866 surface_handle.transport_type == gfx::TEXTURE_TRANSPORT) { 867 RouteOnUIThread(GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params)); 868 return; 869 } 870 871 AcceleratedSurfaceMsg_BufferPresented_Params ack_params; 872 ack_params.sync_point = 0; 873 874 int render_process_id = 0; 875 int render_widget_id = 0; 876 if (!GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface( 877 params.surface_id, &render_process_id, &render_widget_id)) { 878 Send(new AcceleratedSurfaceMsg_BufferPresented(params.route_id, 879 ack_params)); 880 return; 881 } 882 RenderWidgetHelper* helper = 883 RenderWidgetHelper::FromProcessHostID(render_process_id); 884 if (!helper) { 885 Send(new AcceleratedSurfaceMsg_BufferPresented(params.route_id, 886 ack_params)); 887 return; 888 } 889 890 // Pass the SwapBuffers on to the RenderWidgetHelper to wake up the UI thread 891 // if the browser is waiting for a new frame. Otherwise the RenderWidgetHelper 892 // will forward to the RenderWidgetHostView via RenderProcessHostImpl and 893 // RenderWidgetHostImpl. 894 ViewHostMsg_CompositorSurfaceBuffersSwapped_Params view_params; 895 view_params.surface_id = params.surface_id; 896 view_params.surface_handle = params.surface_handle; 897 view_params.route_id = params.route_id; 898 view_params.size = params.size; 899 view_params.scale_factor = params.scale_factor; 900 view_params.gpu_process_host_id = host_id_; 901 view_params.latency_info = params.latency_info; 902 helper->DidReceiveBackingStoreMsg(ViewHostMsg_CompositorSurfaceBuffersSwapped( 903 render_widget_id, 904 view_params)); 905 } 906 #endif // OS_MACOSX 907 908 void GpuProcessHost::OnProcessLaunched() { 909 UMA_HISTOGRAM_TIMES("GPU.GPUProcessLaunchTime", 910 base::TimeTicks::Now() - init_start_time_); 911 } 912 913 void GpuProcessHost::OnProcessCrashed(int exit_code) { 914 SendOutstandingReplies(); 915 GpuDataManagerImpl::GetInstance()->ProcessCrashed( 916 process_->GetTerminationStatus(true /* known_dead */, NULL)); 917 } 918 919 GpuProcessHost::GpuProcessKind GpuProcessHost::kind() { 920 return kind_; 921 } 922 923 void GpuProcessHost::ForceShutdown() { 924 // This is only called on the IO thread so no race against the constructor 925 // for another GpuProcessHost. 926 if (g_gpu_process_hosts[kind_] == this) 927 g_gpu_process_hosts[kind_] = NULL; 928 929 process_->ForceShutdown(); 930 } 931 932 void GpuProcessHost::BeginFrameSubscription( 933 int surface_id, 934 base::WeakPtr<RenderWidgetHostViewFrameSubscriber> subscriber) { 935 frame_subscribers_[surface_id] = subscriber; 936 } 937 938 void GpuProcessHost::EndFrameSubscription(int surface_id) { 939 frame_subscribers_.erase(surface_id); 940 } 941 942 bool GpuProcessHost::LaunchGpuProcess(const std::string& channel_id) { 943 if (!(gpu_enabled_ && 944 GpuDataManagerImpl::GetInstance()->ShouldUseSwiftShader()) && 945 !hardware_gpu_enabled_) { 946 SendOutstandingReplies(); 947 return false; 948 } 949 950 const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess(); 951 952 CommandLine::StringType gpu_launcher = 953 browser_command_line.GetSwitchValueNative(switches::kGpuLauncher); 954 955 #if defined(OS_LINUX) 956 int child_flags = gpu_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF : 957 ChildProcessHost::CHILD_NORMAL; 958 #else 959 int child_flags = ChildProcessHost::CHILD_NORMAL; 960 #endif 961 962 base::FilePath exe_path = ChildProcessHost::GetChildPath(child_flags); 963 if (exe_path.empty()) 964 return false; 965 966 CommandLine* cmd_line = new CommandLine(exe_path); 967 cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess); 968 cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id); 969 970 if (kind_ == GPU_PROCESS_KIND_UNSANDBOXED) 971 cmd_line->AppendSwitch(switches::kDisableGpuSandbox); 972 973 // Propagate relevant command line switches. 974 static const char* const kSwitchNames[] = { 975 switches::kDisableAcceleratedVideoDecode, 976 switches::kDisableBreakpad, 977 switches::kDisableGpuSandbox, 978 switches::kDisableGpuWatchdog, 979 switches::kDisableLogging, 980 switches::kDisableSeccompFilterSandbox, 981 #if defined(ENABLE_WEBRTC) 982 switches::kDisableWebRtcHWEncoding, 983 #endif 984 switches::kEnableLogging, 985 switches::kEnableShareGroupAsyncTextureUpload, 986 switches::kGpuStartupDialog, 987 switches::kGpuSandboxAllowSysVShm, 988 switches::kGpuSandboxFailuresFatal, 989 switches::kGpuSandboxStartAfterInitialization, 990 switches::kIgnoreResolutionLimitsForAcceleratedVideoDecode, 991 switches::kLoggingLevel, 992 switches::kNoSandbox, 993 switches::kTestGLLib, 994 switches::kTraceStartup, 995 switches::kV, 996 switches::kVModule, 997 #if defined(OS_MACOSX) 998 switches::kEnableSandboxLogging, 999 #endif 1000 #if defined(USE_AURA) 1001 switches::kUIPrioritizeInGpuProcess, 1002 #endif 1003 #if defined(USE_OZONE) 1004 switches::kOzonePlatform, 1005 #endif 1006 #if defined(USE_X11) && !defined(OS_CHROMEOS) 1007 switches::kX11Display, 1008 #endif 1009 }; 1010 cmd_line->CopySwitchesFrom(browser_command_line, kSwitchNames, 1011 arraysize(kSwitchNames)); 1012 cmd_line->CopySwitchesFrom( 1013 browser_command_line, switches::kGpuSwitches, switches::kNumGpuSwitches); 1014 cmd_line->CopySwitchesFrom( 1015 browser_command_line, switches::kGLSwitchesCopiedFromGpuProcessHost, 1016 switches::kGLSwitchesCopiedFromGpuProcessHostNumSwitches); 1017 1018 GetContentClient()->browser()->AppendExtraCommandLineSwitches( 1019 cmd_line, process_->GetData().id); 1020 1021 GpuDataManagerImpl::GetInstance()->AppendGpuCommandLine(cmd_line); 1022 1023 if (cmd_line->HasSwitch(switches::kUseGL)) { 1024 swiftshader_rendering_ = 1025 (cmd_line->GetSwitchValueASCII(switches::kUseGL) == "swiftshader"); 1026 } 1027 1028 UMA_HISTOGRAM_BOOLEAN("GPU.GPU.GPUProcessSoftwareRendering", 1029 swiftshader_rendering_); 1030 1031 // If specified, prepend a launcher program to the command line. 1032 if (!gpu_launcher.empty()) 1033 cmd_line->PrependWrapper(gpu_launcher); 1034 1035 process_->Launch( 1036 new GpuSandboxedProcessLauncherDelegate(cmd_line, 1037 process_->GetHost()), 1038 cmd_line); 1039 process_launched_ = true; 1040 1041 UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents", 1042 LAUNCHED, GPU_PROCESS_LIFETIME_EVENT_MAX); 1043 return true; 1044 } 1045 1046 void GpuProcessHost::SendOutstandingReplies() { 1047 valid_ = false; 1048 // First send empty channel handles for all EstablishChannel requests. 1049 while (!channel_requests_.empty()) { 1050 EstablishChannelCallback callback = channel_requests_.front(); 1051 channel_requests_.pop(); 1052 callback.Run(IPC::ChannelHandle(), gpu::GPUInfo()); 1053 } 1054 1055 while (!create_command_buffer_requests_.empty()) { 1056 CreateCommandBufferCallback callback = 1057 create_command_buffer_requests_.front(); 1058 create_command_buffer_requests_.pop(); 1059 callback.Run(CREATE_COMMAND_BUFFER_FAILED_AND_CHANNEL_LOST); 1060 } 1061 } 1062 1063 void GpuProcessHost::BlockLiveOffscreenContexts() { 1064 for (std::multiset<GURL>::iterator iter = 1065 urls_with_live_offscreen_contexts_.begin(); 1066 iter != urls_with_live_offscreen_contexts_.end(); ++iter) { 1067 GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs( 1068 *iter, GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN); 1069 } 1070 } 1071 1072 std::string GpuProcessHost::GetShaderPrefixKey() { 1073 if (shader_prefix_key_.empty()) { 1074 gpu::GPUInfo info = GpuDataManagerImpl::GetInstance()->GetGPUInfo(); 1075 1076 std::string in_str = GetContentClient()->GetProduct() + "-" + 1077 info.gl_vendor + "-" + info.gl_renderer + "-" + 1078 info.driver_version + "-" + info.driver_vendor; 1079 1080 base::Base64Encode(base::SHA1HashString(in_str), &shader_prefix_key_); 1081 } 1082 1083 return shader_prefix_key_; 1084 } 1085 1086 void GpuProcessHost::LoadedShader(const std::string& key, 1087 const std::string& data) { 1088 std::string prefix = GetShaderPrefixKey(); 1089 if (!key.compare(0, prefix.length(), prefix)) 1090 Send(new GpuMsg_LoadedShader(data)); 1091 } 1092 1093 void GpuProcessHost::CreateChannelCache(int32 client_id) { 1094 TRACE_EVENT0("gpu", "GpuProcessHost::CreateChannelCache"); 1095 1096 scoped_refptr<ShaderDiskCache> cache = 1097 ShaderCacheFactory::GetInstance()->Get(client_id); 1098 if (!cache.get()) 1099 return; 1100 1101 cache->set_host_id(host_id_); 1102 1103 client_id_to_shader_cache_[client_id] = cache; 1104 } 1105 1106 void GpuProcessHost::OnDestroyChannel(int32 client_id) { 1107 TRACE_EVENT0("gpu", "GpuProcessHost::OnDestroyChannel"); 1108 client_id_to_shader_cache_.erase(client_id); 1109 } 1110 1111 void GpuProcessHost::OnCacheShader(int32 client_id, 1112 const std::string& key, 1113 const std::string& shader) { 1114 TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader"); 1115 ClientIdToShaderCacheMap::iterator iter = 1116 client_id_to_shader_cache_.find(client_id); 1117 // If the cache doesn't exist then this is an off the record profile. 1118 if (iter == client_id_to_shader_cache_.end()) 1119 return; 1120 iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader); 1121 } 1122 1123 } // namespace content 1124