Linux Sandbox: Stop GPU watchdog in accountable way.

sandbox/linux/services/thread_helpers.cc

Index: sandbox/linux/services/thread_helpers.cc
diff --git a/sandbox/linux/services/thread_helpers.cc b/sandbox/linux/services/thread_helpers.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5b180e90c070240ba3f7703b061d49458861d3b0
--- /dev/null
+++ b/sandbox/linux/services/thread_helpers.cc
@@ -0,0 +1,84 @@
+// Copyright 2014 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 "sandbox/linux/services/thread_helpers.h"
+
+#include <errno.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/threading/platform_thread.h"
+#include "base/threading/thread.h"
+
+namespace sandbox {
+
+bool ThreadHelpers::IsSingleThreaded(int proc_self_task) {
+  CHECK_LE(0, proc_self_task);
+  struct stat task_stat;
+  int fstat_ret = fstat(proc_self_task, &task_stat);
+  PCHECK(0 == fstat_ret);
+
+  // At least "..", "." and the current thread should be present.
+  CHECK_LE(3UL, task_stat.st_nlink);
+  // Counting threads via /proc/self/task could be racy. For the purpose of
+  // determining if the current proces is monothreaded it works: if at any
+  // time it becomes monothreaded, it'll stay so.
+  return task_stat.st_nlink == 3;
+}
+
+bool ThreadHelpers::StopThreadAndWatchProcFS(int proc_self_task,
+                                             base::Thread* thread) {
+  DCHECK_LE(0, proc_self_task);
+  DCHECK(thread);
+  const base::PlatformThreadId thread_id = thread->thread_id();
+  const std::string thread_id_dir_str = base::IntToString(thread_id) + "/";
+
+  // The kernel is at liberty to wake the thread id futex before updating
+  // /proc. Following Stop(), the thread is joined, but entries in /proc may
+  // not have been updated.
+  thread->Stop();
+
+  unsigned int iterations = 0;
+  bool thread_present_in_procfs = true;
+  // Poll /proc with an exponential back-off, sleeping 2^iterations nanoseconds
+  // in nanosleep(2).
+  // Note: the clock may not allow for nanosecond granularity, in this case the
+  // first iterations would sleep a tiny bit more instead, which would not
+  // change the calculations significantly.
+  while (thread_present_in_procfs) {
+    struct stat task_stat;
+    const int fstat_ret =
+        fstatat(proc_self_task, thread_id_dir_str.c_str(), &task_stat, 0);
+    if (fstat_ret < 0) {
+      PCHECK(ENOENT == errno);
+      // The thread disappeared from /proc, we're done.
+      thread_present_in_procfs = false;
+      break;
+    }
+    // Increase the waiting time exponentially.
+    struct timespec ts = {0, 1L << iterations /* nanoseconds */};
+    PCHECK(0 == HANDLE_EINTR(nanosleep(&ts, &ts)));
+    ++iterations;
+
+    // Crash after 30 iterations, which means having spent roughly 2s in

[Jorge Lucangeli Obes, 2014/02/07 22:30:34]

This seems high, but maybe it doesn't matter in practice.

[jln (very slow on Chromium), 2014/02/07 22:53:07]

Yeah, I wanted something ridiculously high before crashing. The DCHECK below is
here to check that it's very fast, as expected.

+    // nanosleep(2) cumulatively.
+    CHECK_GT(30U, iterations);
+    // In practice, this never goes through more than a couple iterations. In
+    // debug mode, crash after 2 microseconds (or 10 times the granularity of
+    // the clock).
+    DCHECK_GT(10U, iterations);
+  }
+
+  return true;
+}
+
+}  // namespace sandbox