1 //
2 // Copyright 2018 The Abseil Authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // https://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 #include "absl/debugging/internal/stack_consumption.h"
17
18 #ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
19
20 #include <signal.h>
21 #include <sys/mman.h>
22 #include <unistd.h>
23
24 #include <string.h>
25
26 #include "absl/base/attributes.h"
27 #include "absl/base/internal/raw_logging.h"
28
29 namespace absl {
30 ABSL_NAMESPACE_BEGIN
31 namespace debugging_internal {
32 namespace {
33
34 // This code requires that we know the direction in which the stack
35 // grows. It is commonly believed that this can be detected by putting
36 // a variable on the stack and then passing its address to a function
37 // that compares the address of this variable to the address of a
38 // variable on the function's own stack. However, this is unspecified
39 // behavior in C++: If two pointers p and q of the same type point to
40 // different objects that are not members of the same object or
41 // elements of the same array or to different functions, or if only
42 // one of them is null, the results of p<q, p>q, p<=q, and p>=q are
43 // unspecified. Therefore, instead we hardcode the direction of the
44 // stack on platforms we know about.
45 #if defined(__i386__) || defined(__x86_64__) || defined(__ppc__)
46 constexpr bool kStackGrowsDown = true;
47 #else
48 #error Need to define kStackGrowsDown
49 #endif
50
51 // To measure the stack footprint of some code, we create a signal handler
52 // (for SIGUSR2 say) that exercises this code on an alternate stack. This
53 // alternate stack is initialized to some known pattern (0x55, 0x55, 0x55,
54 // ...). We then self-send this signal, and after the signal handler returns,
55 // look at the alternate stack buffer to see what portion has been touched.
56 //
57 // This trick gives us the the stack footprint of the signal handler. But the
58 // signal handler, even before the code for it is exercised, consumes some
59 // stack already. We however only want the stack usage of the code inside the
60 // signal handler. To measure this accurately, we install two signal handlers:
61 // one that does nothing and just returns, and the user-provided signal
62 // handler. The difference between the stack consumption of these two signals
63 // handlers should give us the stack foorprint of interest.
64
EmptySignalHandler(int)65 void EmptySignalHandler(int) {}
66
67 // This is arbitrary value, and could be increase further, at the cost of
68 // memset()ting it all to known sentinel value.
69 constexpr int kAlternateStackSize = 64 << 10; // 64KiB
70
71 constexpr int kSafetyMargin = 32;
72 constexpr char kAlternateStackFillValue = 0x55;
73
74 // These helper functions look at the alternate stack buffer, and figure
75 // out what portion of this buffer has been touched - this is the stack
76 // consumption of the signal handler running on this alternate stack.
77 // This function will return -1 if the alternate stack buffer has not been
78 // touched. It will abort the program if the buffer has overflowed or is about
79 // to overflow.
GetStackConsumption(const void * const altstack)80 int GetStackConsumption(const void* const altstack) {
81 const char* begin;
82 int increment;
83 if (kStackGrowsDown) {
84 begin = reinterpret_cast<const char*>(altstack);
85 increment = 1;
86 } else {
87 begin = reinterpret_cast<const char*>(altstack) + kAlternateStackSize - 1;
88 increment = -1;
89 }
90
91 for (int usage_count = kAlternateStackSize; usage_count > 0; --usage_count) {
92 if (*begin != kAlternateStackFillValue) {
93 ABSL_RAW_CHECK(usage_count <= kAlternateStackSize - kSafetyMargin,
94 "Buffer has overflowed or is about to overflow");
95 return usage_count;
96 }
97 begin += increment;
98 }
99
100 ABSL_RAW_LOG(FATAL, "Unreachable code");
101 return -1;
102 }
103
104 } // namespace
105
GetSignalHandlerStackConsumption(void (* signal_handler)(int))106 int GetSignalHandlerStackConsumption(void (*signal_handler)(int)) {
107 // The alt-signal-stack cannot be heap allocated because there is a
108 // bug in glibc-2.2 where some signal handler setup code looks at the
109 // current stack pointer to figure out what thread is currently running.
110 // Therefore, the alternate stack must be allocated from the main stack
111 // itself.
112 void* altstack = mmap(nullptr, kAlternateStackSize, PROT_READ | PROT_WRITE,
113 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
114 ABSL_RAW_CHECK(altstack != MAP_FAILED, "mmap() failed");
115
116 // Set up the alt-signal-stack (and save the older one).
117 stack_t sigstk;
118 memset(&sigstk, 0, sizeof(sigstk));
119 sigstk.ss_sp = altstack;
120 sigstk.ss_size = kAlternateStackSize;
121 sigstk.ss_flags = 0;
122 stack_t old_sigstk;
123 memset(&old_sigstk, 0, sizeof(old_sigstk));
124 ABSL_RAW_CHECK(sigaltstack(&sigstk, &old_sigstk) == 0,
125 "sigaltstack() failed");
126
127 // Set up SIGUSR1 and SIGUSR2 signal handlers (and save the older ones).
128 struct sigaction sa;
129 memset(&sa, 0, sizeof(sa));
130 struct sigaction old_sa1, old_sa2;
131 sigemptyset(&sa.sa_mask);
132 sa.sa_flags = SA_ONSTACK;
133
134 // SIGUSR1 maps to EmptySignalHandler.
135 sa.sa_handler = EmptySignalHandler;
136 ABSL_RAW_CHECK(sigaction(SIGUSR1, &sa, &old_sa1) == 0, "sigaction() failed");
137
138 // SIGUSR2 maps to signal_handler.
139 sa.sa_handler = signal_handler;
140 ABSL_RAW_CHECK(sigaction(SIGUSR2, &sa, &old_sa2) == 0, "sigaction() failed");
141
142 // Send SIGUSR1 signal and measure the stack consumption of the empty
143 // signal handler.
144 // The first signal might use more stack space. Run once and ignore the
145 // results to get that out of the way.
146 ABSL_RAW_CHECK(kill(getpid(), SIGUSR1) == 0, "kill() failed");
147
148 memset(altstack, kAlternateStackFillValue, kAlternateStackSize);
149 ABSL_RAW_CHECK(kill(getpid(), SIGUSR1) == 0, "kill() failed");
150 int base_stack_consumption = GetStackConsumption(altstack);
151
152 // Send SIGUSR2 signal and measure the stack consumption of signal_handler.
153 ABSL_RAW_CHECK(kill(getpid(), SIGUSR2) == 0, "kill() failed");
154 int signal_handler_stack_consumption = GetStackConsumption(altstack);
155
156 // Now restore the old alt-signal-stack and signal handlers.
157 if (old_sigstk.ss_sp == nullptr && old_sigstk.ss_size == 0 &&
158 (old_sigstk.ss_flags & SS_DISABLE)) {
159 // https://git.musl-libc.org/cgit/musl/commit/src/signal/sigaltstack.c?id=7829f42a2c8944555439380498ab8b924d0f2070
160 // The original stack has ss_size==0 and ss_flags==SS_DISABLE, but some
161 // versions of musl have a bug that rejects ss_size==0. Work around this by
162 // setting ss_size to MINSIGSTKSZ, which should be ignored by the kernel
163 // when SS_DISABLE is set.
164 old_sigstk.ss_size = MINSIGSTKSZ;
165 }
166 ABSL_RAW_CHECK(sigaltstack(&old_sigstk, nullptr) == 0,
167 "sigaltstack() failed");
168 ABSL_RAW_CHECK(sigaction(SIGUSR1, &old_sa1, nullptr) == 0,
169 "sigaction() failed");
170 ABSL_RAW_CHECK(sigaction(SIGUSR2, &old_sa2, nullptr) == 0,
171 "sigaction() failed");
172
173 ABSL_RAW_CHECK(munmap(altstack, kAlternateStackSize) == 0, "munmap() failed");
174 if (signal_handler_stack_consumption != -1 && base_stack_consumption != -1) {
175 return signal_handler_stack_consumption - base_stack_consumption;
176 }
177 return -1;
178 }
179
180 } // namespace debugging_internal
181 ABSL_NAMESPACE_END
182 } // namespace absl
183
184 #endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
185