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"
 
@@ skipping 21 matching lines @@
     : 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),
+      display_(NULL),
+      window_(1),

[piman, 2015/02/04 01:03:05]

why 1?

[sohanjg, 2015/02/06 10:40:58]

Done.

+      atom_(None),
+#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(),
                                 &watched_thread_handle_,
                                 THREAD_QUERY_INFORMATION,
                                 FALSE,
                                 0);
   DCHECK(result);
 #endif
 
 #if defined(OS_CHROMEOS)
   tty_file_ = base::OpenFile(base::FilePath(kTtyFilePath), "r");
 #endif
+#if defined(USE_X11)
+  SetupXServer();
+#endif
   watched_message_loop_->AddTaskObserver(&task_observer_);
 }
 
 void GpuWatchdogThread::PostAcknowledge() {
   // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
   // the method factory. Rely on reference counting instead.
   message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&GpuWatchdogThread::OnAcknowledge, this));
 }
@@ skipping 105 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.
+#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.
+  SetupXChangeProp();
   message_loop()->PostDelayedTask(

[sohanjg, 2015/02/02 14:17:19]

Should we post a delayed task here, or explicitly call CheckXServerActive, and
poll there till timeout ?

-      FROM_HERE,
-      base::Bind(
-          &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
-          weak_factory_.GetWeakPtr()),
+      FROM_HERE, base::Bind(&GpuWatchdogThread::CheckXServerActive,
+                            weak_factory_.GetWeakPtr()),
       timeout);
+  if (!x_server_active_)
+#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() {
+  unsigned long nitems = 0;
+  unsigned long nbytes = 0;
+  XAtom prop_type = None;
+  int prop_format = 0;
+  unsigned char* property_data = NULL;
+  if (XGetWindowProperty(display_, window_, atom_, 0, 65535, False,
+                         AnyPropertyType, &prop_type, &prop_format, &nitems,
+                         &nbytes, &property_data) == Success) {

[piman, 2015/02/04 01:03:05]

If X is blocked, this will block. I don't think that's what we want, is it?
I would think instead we'd want to check in
DeliberatelyTerminateToRecoverFromHang, after we think the main thread is
blocked.
Then you would want to do a non-blocking round trip to X. Maybe setting a
property, flushing, and then polling for a property change (i.e. XSelectInput
with PropertyChangeMask - prior to setting the property - and then checking for
events with XCheckWindowEvent in a poll() loop over the Display's
ConnectionNumber, with a timeout).

[sohanjg, 2015/02/06 10:40:58]

Done.

+    if (prop_type == XA_STRING && prop_format == 8 && nitems == 5) {
+      x_server_active_ = true;
+      return;
+    }
+  }
+  x_server_active_ = false;
+}
+
+void GpuWatchdogThread::SetupXServer() {
+  display_ = XOpenDisplay(NULL);
+  window_ = XCreateWindow(display_, DefaultRootWindow(display_), 0, 0, 1, 1, 0,
+                          CopyFromParent, InputOutput, CopyFromParent, 0, NULL);
+}
+
+void GpuWatchdogThread::SetupXChangeProp() {
+  unsigned char text[20] = "check";
+  atom_ = XInternAtom(display_, "CHK", False);
+  XChangeProperty(display_, window_, atom_, XA_STRING, 8, PropModeReplace, text,
+                  5);
+}
+#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