1 // Copyright 2014 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 "sandbox/linux/services/thread_helpers.h" 6 7 #include <errno.h> 8 #include <fcntl.h> 9 #include <signal.h> 10 #include <sys/types.h> 11 #include <sys/stat.h> 12 #include <unistd.h> 13 14 #include <string> 15 16 #include "base/basictypes.h" 17 #include "base/logging.h" 18 #include "base/posix/eintr_wrapper.h" 19 #include "base/strings/string_number_conversions.h" 20 #include "base/threading/platform_thread.h" 21 #include "base/threading/thread.h" 22 23 namespace sandbox { 24 25 namespace { 26 27 bool IsSingleThreadedImpl(int proc_self_task) { 28 CHECK_LE(0, proc_self_task); 29 struct stat task_stat; 30 int fstat_ret = fstat(proc_self_task, &task_stat); 31 PCHECK(0 == fstat_ret); 32 33 // At least "..", "." and the current thread should be present. 34 CHECK_LE(3UL, task_stat.st_nlink); 35 // Counting threads via /proc/self/task could be racy. For the purpose of 36 // determining if the current proces is monothreaded it works: if at any 37 // time it becomes monothreaded, it'll stay so. 38 return task_stat.st_nlink == 3; 39 } 40 41 } // namespace 42 43 bool ThreadHelpers::IsSingleThreaded(int proc_self_task) { 44 DCHECK_LE(-1, proc_self_task); 45 if (-1 == proc_self_task) { 46 const int task_fd = open("/proc/self/task/", O_RDONLY | O_DIRECTORY); 47 PCHECK(0 <= task_fd); 48 const bool result = IsSingleThreadedImpl(task_fd); 49 PCHECK(0 == IGNORE_EINTR(close(task_fd))); 50 return result; 51 } else { 52 return IsSingleThreadedImpl(proc_self_task); 53 } 54 } 55 56 bool ThreadHelpers::StopThreadAndWatchProcFS(int proc_self_task, 57 base::Thread* thread) { 58 DCHECK_LE(0, proc_self_task); 59 DCHECK(thread); 60 const base::PlatformThreadId thread_id = thread->thread_id(); 61 const std::string thread_id_dir_str = base::IntToString(thread_id) + "/"; 62 63 // The kernel is at liberty to wake the thread id futex before updating 64 // /proc. Following Stop(), the thread is joined, but entries in /proc may 65 // not have been updated. 66 thread->Stop(); 67 68 unsigned int iterations = 0; 69 bool thread_present_in_procfs = true; 70 // Poll /proc with an exponential back-off, sleeping 2^iterations nanoseconds 71 // in nanosleep(2). 72 // Note: the clock may not allow for nanosecond granularity, in this case the 73 // first iterations would sleep a tiny bit more instead, which would not 74 // change the calculations significantly. 75 while (thread_present_in_procfs) { 76 struct stat task_stat; 77 const int fstat_ret = 78 fstatat(proc_self_task, thread_id_dir_str.c_str(), &task_stat, 0); 79 if (fstat_ret < 0) { 80 PCHECK(ENOENT == errno); 81 // The thread disappeared from /proc, we're done. 82 thread_present_in_procfs = false; 83 break; 84 } 85 // Increase the waiting time exponentially. 86 struct timespec ts = {0, 1L << iterations /* nanoseconds */}; 87 PCHECK(0 == HANDLE_EINTR(nanosleep(&ts, &ts))); 88 ++iterations; 89 90 // Crash after 30 iterations, which means having spent roughly 2s in 91 // nanosleep(2) cumulatively. 92 CHECK_GT(30U, iterations); 93 // In practice, this never goes through more than a couple iterations. In 94 // debug mode, crash after 64ms (+ eventually 25 times the granularity of 95 // the clock) in nanosleep(2). 96 DCHECK_GT(25U, iterations); 97 } 98 99 return true; 100 } 101 102 } // namespace sandbox 103