1 //===-- esan_sideline_linux.cpp ---------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is a part of EfficiencySanitizer, a family of performance tuners.
11 //
12 // Support for a separate or "sideline" tool thread on Linux.
13 //===----------------------------------------------------------------------===//
14 
15 #include "sanitizer_common/sanitizer_platform.h"
16 #if SANITIZER_LINUX
17 
18 #include "esan_sideline.h"
19 #include "sanitizer_common/sanitizer_atomic.h"
20 #include "sanitizer_common/sanitizer_common.h"
21 #include "sanitizer_common/sanitizer_linux.h"
22 #include <errno.h>
23 #include <sched.h>
24 #include <sys/prctl.h>
25 #include <sys/signal.h>
26 #include <sys/time.h>
27 #include <sys/types.h>
28 #include <sys/wait.h>
29 
30 namespace __esan {
31 
32 static const int SigAltStackSize = 4*1024;
33 static const int SidelineStackSize = 4*1024;
34 static const uptr SidelineIdUninitialized = 1;
35 
36 // FIXME: we'll need some kind of TLS (can we trust that a pthread key will
37 // work in our non-POSIX thread?) to access our data in our signal handler
38 // with multiple sideline threads.  For now we assume there is only one
39 // sideline thread and we use a dirty solution of a global var.
40 static SidelineThread *TheThread;
41 
42 // We aren't passing SA_NODEFER so the same signal is blocked while here.
43 void SidelineThread::handleSidelineSignal(int SigNum, void *SigInfo,
44                                           void *Ctx) {
45   VPrintf(3, "Sideline signal %d\n", SigNum);
46   CHECK_EQ(SigNum, SIGALRM);
47   // See above about needing TLS to avoid this global var.
48   SidelineThread *Thread = TheThread;
49   if (atomic_load(&Thread->SidelineExit, memory_order_relaxed) != 0)
50     return;
51   Thread->sampleFunc(Thread->FuncArg);
52 }
53 
54 void SidelineThread::registerSignal(int SigNum) {
55   __sanitizer_sigaction SigAct;
56   internal_memset(&SigAct, 0, sizeof(SigAct));
57   SigAct.sigaction = handleSidelineSignal;
58   // We do not pass SA_NODEFER as we want to block the same signal.
59   SigAct.sa_flags = SA_ONSTACK | SA_SIGINFO;
60   int Res = internal_sigaction(SigNum, &SigAct, nullptr);
61   CHECK_EQ(Res, 0);
62 }
63 
64 int SidelineThread::runSideline(void *Arg) {
65   VPrintf(1, "Sideline thread starting\n");
66   SidelineThread *Thread = static_cast<SidelineThread*>(Arg);
67 
68   // If the parent dies, we want to exit also.
69   internal_prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
70 
71   // Set up a signal handler on an alternate stack for safety.
72   InternalScopedBuffer<char> StackMap(SigAltStackSize);
73   stack_t SigAltStack;
74   SigAltStack.ss_sp = StackMap.data();
75   SigAltStack.ss_size = SigAltStackSize;
76   SigAltStack.ss_flags = 0;
77   internal_sigaltstack(&SigAltStack, nullptr);
78 
79   // We inherit the signal mask from the app thread.  In case
80   // we weren't created at init time, we ensure the mask is empty.
81   __sanitizer_sigset_t SigSet;
82   internal_sigfillset(&SigSet);
83   int Res = internal_sigprocmask(SIG_UNBLOCK, &SigSet, nullptr);
84   CHECK_EQ(Res, 0);
85 
86   registerSignal(SIGALRM);
87 
88   bool TimerSuccess = Thread->adjustTimer(Thread->Freq);
89   CHECK(TimerSuccess);
90 
91   // We loop, doing nothing but handling itimer signals.
92   while (atomic_load(&TheThread->SidelineExit, memory_order_relaxed) == 0)
93     sched_yield();
94 
95   if (!Thread->adjustTimer(0))
96     VPrintf(1, "Failed to disable timer\n");
97 
98   VPrintf(1, "Sideline thread exiting\n");
99   return 0;
100 }
101 
102 bool SidelineThread::launchThread(SidelineFunc takeSample, void *Arg,
103                                   u32 FreqMilliSec) {
104   // This can only be called once.  However, we can't clear a field in
105   // the constructor and check for that here as the constructor for
106   // a static instance is called *after* our module_ctor and thus after
107   // this routine!  Thus we rely on the TheThread check below.
108   CHECK(TheThread == nullptr); // Only one sideline thread is supported.
109   TheThread = this;
110   sampleFunc = takeSample;
111   FuncArg = Arg;
112   Freq = FreqMilliSec;
113   atomic_store(&SidelineExit, 0, memory_order_relaxed);
114 
115   // We do without a guard page.
116   Stack = static_cast<char*>(MmapOrDie(SidelineStackSize, "SidelineStack"));
117   // We need to handle the return value from internal_clone() not having been
118   // assigned yet (for our CHECK in adjustTimer()) so we ensure this has a
119   // sentinel value.
120   SidelineId = SidelineIdUninitialized;
121   // By omitting CLONE_THREAD, the child is in its own thread group and will not
122   // receive any of the application's signals.
123   SidelineId = internal_clone(
124       runSideline, Stack + SidelineStackSize,
125       CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_UNTRACED,
126       this, nullptr /* parent_tidptr */,
127       nullptr /* newtls */, nullptr /* child_tidptr */);
128   int ErrCode;
129   if (internal_iserror(SidelineId, &ErrCode)) {
130     Printf("FATAL: EfficiencySanitizer failed to spawn a thread (code %d).\n",
131            ErrCode);
132     Die();
133     return false; // Not reached.
134   }
135   return true;
136 }
137 
138 bool SidelineThread::joinThread() {
139   VPrintf(1, "Joining sideline thread\n");
140   bool Res = true;
141   atomic_store(&SidelineExit, 1, memory_order_relaxed);
142   while (true) {
143     uptr Status = internal_waitpid(SidelineId, nullptr, __WALL);
144     int ErrCode;
145     if (!internal_iserror(Status, &ErrCode))
146       break;
147     if (ErrCode == EINTR)
148       continue;
149     VPrintf(1, "Failed to join sideline thread (errno %d)\n", ErrCode);
150     Res = false;
151     break;
152   }
153   UnmapOrDie(Stack, SidelineStackSize);
154   return Res;
155 }
156 
157 // Must be called from the sideline thread itself.
158 bool SidelineThread::adjustTimer(u32 FreqMilliSec) {
159   // The return value of internal_clone() may not have been assigned yet:
160   CHECK(internal_getpid() == SidelineId ||
161         SidelineId == SidelineIdUninitialized);
162   Freq = FreqMilliSec;
163   struct itimerval TimerVal;
164   TimerVal.it_interval.tv_sec = (time_t) Freq / 1000;
165   TimerVal.it_interval.tv_usec = (time_t) (Freq % 1000) * 1000;
166   TimerVal.it_value.tv_sec = (time_t) Freq / 1000;
167   TimerVal.it_value.tv_usec = (time_t) (Freq % 1000) * 1000;
168   // As we're in a different thread group, we cannot use either
169   // ITIMER_PROF or ITIMER_VIRTUAL without taking up scheduled
170   // time ourselves: thus we must use real time.
171   int Res = setitimer(ITIMER_REAL, &TimerVal, nullptr);
172   return (Res == 0);
173 }
174 
175 } // namespace __esan
176 
177 #endif // SANITIZER_LINUX
178