Avoid gpu watchdog crash on timeout if X is un-responsive.

content/gpu/gpu_watchdog_thread.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/gpu/gpu_watchdog_thread.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/process/process.h"
 #include "build/build_config.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 
+#if defined(USE_X11)
+extern "C" {
+#include <X11/Xlib.h>
+}
+#include "ui/gfx/x/x11_types.h"
+#endif
+
 namespace content {
 namespace {
 const int64 kCheckPeriodMs = 2000;
 #if defined(OS_CHROMEOS)
 const base::FilePath::CharType
     kTtyFilePath[] = FILE_PATH_LITERAL("/sys/class/tty/tty0/active");
 #endif
 }  // namespace
 
 GpuWatchdogThread::GpuWatchdogThread(int timeout)
     : base::Thread("Watchdog"),
       watched_message_loop_(base::MessageLoop::current()),
       timeout_(base::TimeDelta::FromMilliseconds(timeout)),
       armed_(false),
 #if defined(OS_WIN)
       watched_thread_handle_(0),
       arm_cpu_time_(),
 #endif
       task_observer_(this),
       suspended_(false),
+#if defined(USE_X11)
+      x_server_active(true),
+#endif
       weak_factory_(this) {
   DCHECK(timeout >= 0);
 
 #if defined(OS_WIN)
   // GetCurrentThread returns a pseudo-handle that cannot be used by one thread
   // to identify another. DuplicateHandle creates a "real" handle that can be
   // used for this purpose.
   BOOL result = DuplicateHandle(GetCurrentProcess(),
                                 GetCurrentThread(),
                                 GetCurrentProcess(),
@@ skipping 125 matching lines @@
   base::TimeDelta timeout = timeout_ * (after_suspend ? 3 : 1);
   suspension_timeout_ = base::Time::Now() + timeout * 2;
 
   // Post a task to the monitored thread that does nothing but wake up the
   // TaskObserver. Any other tasks that are pending on the watched thread will
   // also wake up the observer. This simply ensures there is at least one.
   watched_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&base::DoNothing));
 
-  // Post a task to the watchdog thread to exit if the monitored thread does
-  // not respond in time.
-  message_loop()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(
-          &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
-          weak_factory_.GetWeakPtr()),
-      timeout);
+#if defined(USE_X11)
+  // Post a task to the watchdog thread to check XServer is active
+  // if the monitored thread does not respond in time.
+  if (x_server_active) {
+    message_loop()->PostDelayedTask(
+        FROM_HERE, base::Bind(&GpuWatchdogThread::CheckXServerActive,
+                              weak_factory_.GetWeakPtr()),
+        timeout);
+  } else
+#endif
+  {
+    // Post a task to the watchdog thread to exit if the monitored thread does
+    // not respond in time.
+    message_loop()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
+                   weak_factory_.GetWeakPtr()),
+        timeout);
+  }
 }
 
 // Use the --disable-gpu-watchdog command line switch to disable this.
 void GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang() {
   // Should not get here while the system is suspended.
   DCHECK(!suspended_);
 
 #if defined(OS_WIN)
   // Defer termination until a certain amount of CPU time has elapsed on the
   // watched thread.
@@ skipping 47 matching lines @@
 
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_.InMilliseconds() << " ms.";
 
   // Deliberately crash the process to create a crash dump.
   *((volatile int*)0) = 0x1337;
 
   terminated = true;
 }
 
+#if defined(USE_X11)
+void GpuWatchdogThread::CheckXServerActive() {
+  if (!XDisplayString(gfx::GetXDisplay())) {

[danakj, 2015/01/06 00:29:19]

What does this do if the X server is not the active VT?

[sohanjg, 2015/01/06 12:21:45]

Hmm..i was assuming this would return NULL in that case, but there is no
documentation for it.
But it seems, in OpenNewXDisplay, we send display string as NULL, so this query
wouldnt be of much help i guess.

My idea was to use a less complex X-api do that we do not need to plumb all the
params that XChangeProperty would have required in gpu wtachdog thread.

We may also use, XDefaultScreen, and XDisplayHeight to get display height. And i
assume (not documented though) we will get it as 0, if X is not active VT.
Please suggest what should be best here.

I checked fgconsole man page,
http://man7.org/linux/man-pages/man1/fgconsole.1.html 
It seems if we check --next-available param here, we may understand whether X is
the active VT.
But would that help?

+    x_server_active = false;
+    timeout_ /= 2;
+  } else {
+    x_server_active = true;
+  }
+}
+#endif
 void GpuWatchdogThread::AddPowerObserver() {
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&GpuWatchdogThread::OnAddPowerObserver, this));
 }
 
 void GpuWatchdogThread::OnAddPowerObserver() {
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   DCHECK(power_monitor);
   power_monitor->AddObserver(this);
@@ skipping 42 matching lines @@
   // not increasing. The other is where either the kernel hangs and never
   // returns to user level or where user level code
   // calls into kernel level repeatedly, giving up its quanta before it is
   // tracked, for example a loop that repeatedly Sleeps.
   return base::TimeDelta::FromMilliseconds(static_cast<int64>(
       (user_time64.QuadPart + kernel_time64.QuadPart) / 10000));
 }
 #endif
 
 }  // namespace content