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..e820449cb703607862da639f604b7134c22b79d8 |
--- /dev/null |
+++ b/sandbox/linux/services/thread_helpers.cc |
@@ -0,0 +1,102 @@ |
+// 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 <fcntl.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 { |
+ |
+namespace { |
+ |
+bool IsSingleThreadedImpl(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; |
+} |
+ |
+} // namespace |
+ |
+bool ThreadHelpers::IsSingleThreaded(int proc_self_task) { |
+ DCHECK_LE(-1, proc_self_task); |
+ if (-1 == proc_self_task) { |
+ const int task_fd = open("/proc/self/task/", O_RDONLY | O_DIRECTORY); |
+ PCHECK(0 <= task_fd); |
+ const bool result = IsSingleThreadedImpl(task_fd); |
+ PCHECK(0 == IGNORE_EINTR(close(task_fd))); |
+ return result; |
+ } else { |
+ return IsSingleThreadedImpl(proc_self_task); |
+ } |
+} |
+ |
+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 |
+ // nanosleep(2) cumulatively. |
+ CHECK_GT(30U, iterations); |
+ // In practice, this never goes through more than a couple iterations. In |
+ // debug mode, crash after 64ms (+ eventually 25 times the granularity of |
+ // the clock) in nanosleep(2). |
+ DCHECK_GT(25U, iterations); |
+ } |
+ |
+ return true; |
+} |
+ |
+} // namespace sandbox |