1 /*
2 * Copyright (C) 2016 The Android Open Source Project
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 * http://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
17 #include <sys/ptrace.h>
18
19 #include <elf.h>
20 #include <err.h>
21 #include <fcntl.h>
22 #include <sched.h>
23 #include <sys/prctl.h>
24 #include <sys/ptrace.h>
25 #include <sys/uio.h>
26 #include <sys/user.h>
27 #include <sys/wait.h>
28 #include <unistd.h>
29
30 #include <chrono>
31 #include <thread>
32
33 #include <gtest/gtest.h>
34
35 #include <android-base/macros.h>
36 #include <android-base/unique_fd.h>
37
38 #include "utils.h"
39
40 using namespace std::chrono_literals;
41
42 using android::base::unique_fd;
43
44 class ChildGuard {
45 public:
ChildGuard(pid_t pid)46 explicit ChildGuard(pid_t pid) : pid(pid) {}
47
~ChildGuard()48 ~ChildGuard() {
49 kill(pid, SIGKILL);
50 int status;
51 TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
52 }
53
54 private:
55 pid_t pid;
56 };
57
58 enum class HwFeature { Watchpoint, Breakpoint };
59
check_hw_feature_supported(pid_t child,HwFeature feature)60 static void check_hw_feature_supported(pid_t child, HwFeature feature) {
61 #if defined(__arm__)
62 errno = 0;
63 long capabilities;
64 long result = ptrace(PTRACE_GETHBPREGS, child, 0, &capabilities);
65 if (result == -1) {
66 EXPECT_ERRNO(EIO);
67 GTEST_SKIP() << "Hardware debug support disabled at kernel configuration time";
68 }
69 uint8_t hb_count = capabilities & 0xff;
70 capabilities >>= 8;
71 uint8_t wp_count = capabilities & 0xff;
72 capabilities >>= 8;
73 uint8_t max_wp_size = capabilities & 0xff;
74 if (max_wp_size == 0) {
75 GTEST_SKIP() << "Kernel reports zero maximum watchpoint size";
76 } else if (feature == HwFeature::Watchpoint && wp_count == 0) {
77 GTEST_SKIP() << "Kernel reports zero hardware watchpoints";
78 } else if (feature == HwFeature::Breakpoint && hb_count == 0) {
79 GTEST_SKIP() << "Kernel reports zero hardware breakpoints";
80 }
81 #elif defined(__aarch64__)
82 user_hwdebug_state dreg_state;
83 iovec iov;
84 iov.iov_base = &dreg_state;
85 iov.iov_len = sizeof(dreg_state);
86
87 errno = 0;
88 long result = ptrace(PTRACE_GETREGSET, child,
89 feature == HwFeature::Watchpoint ? NT_ARM_HW_WATCH : NT_ARM_HW_BREAK, &iov);
90 if (result == -1) {
91 ASSERT_ERRNO(EINVAL);
92 GTEST_SKIP() << "Hardware support missing";
93 } else if ((dreg_state.dbg_info & 0xff) == 0) {
94 if (feature == HwFeature::Watchpoint) {
95 GTEST_SKIP() << "Kernel reports zero hardware watchpoints";
96 } else {
97 GTEST_SKIP() << "Kernel reports zero hardware breakpoints";
98 }
99 }
100 #else
101 // We assume watchpoints and breakpoints are always supported on x86.
102 UNUSED(child);
103 UNUSED(feature);
104 #endif
105 }
106
set_watchpoint(pid_t child,uintptr_t address,size_t size)107 static void set_watchpoint(pid_t child, uintptr_t address, size_t size) {
108 ASSERT_EQ(0u, address & 0x7) << "address: " << address;
109 #if defined(__arm__) || defined(__aarch64__)
110 const unsigned byte_mask = (1 << size) - 1;
111 const unsigned type = 2; // Write.
112 const unsigned enable = 1;
113 const unsigned control = byte_mask << 5 | type << 3 | enable;
114
115 #ifdef __arm__
116 ASSERT_EQ(0, ptrace(PTRACE_SETHBPREGS, child, -1, &address)) << strerror(errno);
117 ASSERT_EQ(0, ptrace(PTRACE_SETHBPREGS, child, -2, &control)) << strerror(errno);
118 #else // aarch64
119 user_hwdebug_state dreg_state;
120 memset(&dreg_state, 0, sizeof dreg_state);
121 dreg_state.dbg_regs[0].addr = address;
122 dreg_state.dbg_regs[0].ctrl = control;
123
124 iovec iov;
125 iov.iov_base = &dreg_state;
126 iov.iov_len = offsetof(user_hwdebug_state, dbg_regs) + sizeof(dreg_state.dbg_regs[0]);
127
128 ASSERT_EQ(0, ptrace(PTRACE_SETREGSET, child, NT_ARM_HW_WATCH, &iov)) << strerror(errno);
129 #endif
130 #elif defined(__i386__) || defined(__x86_64__)
131 ASSERT_EQ(0, ptrace(PTRACE_POKEUSER, child, offsetof(user, u_debugreg[0]), address)) << strerror(errno);
132 errno = 0;
133 unsigned data = ptrace(PTRACE_PEEKUSER, child, offsetof(user, u_debugreg[7]), nullptr);
134 ASSERT_ERRNO(0);
135
136 const unsigned size_flag = (size == 8) ? 2 : size - 1;
137 const unsigned enable = 1;
138 const unsigned type = 1; // Write.
139
140 const unsigned mask = 3 << 18 | 3 << 16 | 1;
141 const unsigned value = size_flag << 18 | type << 16 | enable;
142 data &= mask;
143 data |= value;
144 ASSERT_EQ(0, ptrace(PTRACE_POKEUSER, child, offsetof(user, u_debugreg[7]), data)) << strerror(errno);
145 #else
146 UNUSED(child);
147 UNUSED(address);
148 UNUSED(size);
149 #endif
150 }
151
152 template <typename T>
run_watchpoint_test(std::function<void (T &)> child_func,size_t offset,size_t size)153 static void run_watchpoint_test(std::function<void(T&)> child_func, size_t offset, size_t size) {
154 alignas(16) T data{};
155
156 pid_t child = fork();
157 ASSERT_NE(-1, child) << strerror(errno);
158 if (child == 0) {
159 // Extra precaution: make sure we go away if anything happens to our parent.
160 if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0) == -1) {
161 perror("prctl(PR_SET_PDEATHSIG)");
162 _exit(1);
163 }
164
165 if (ptrace(PTRACE_TRACEME, 0, nullptr, nullptr) == -1) {
166 perror("ptrace(PTRACE_TRACEME)");
167 _exit(2);
168 }
169
170 child_func(data);
171 _exit(0);
172 }
173
174 ChildGuard guard(child);
175
176 int status;
177 ASSERT_EQ(child, TEMP_FAILURE_RETRY(waitpid(child, &status, __WALL))) << strerror(errno);
178 ASSERT_TRUE(WIFSTOPPED(status)) << "Status was: " << status;
179 ASSERT_EQ(SIGSTOP, WSTOPSIG(status)) << "Status was: " << status;
180
181 check_hw_feature_supported(child, HwFeature::Watchpoint);
182 if (::testing::Test::IsSkipped()) {
183 return;
184 }
185
186 set_watchpoint(child, uintptr_t(untag_address(&data)) + offset, size);
187
188 ASSERT_EQ(0, ptrace(PTRACE_CONT, child, nullptr, nullptr)) << strerror(errno);
189 ASSERT_EQ(child, TEMP_FAILURE_RETRY(waitpid(child, &status, __WALL))) << strerror(errno);
190 ASSERT_TRUE(WIFSTOPPED(status)) << "Status was: " << status;
191 ASSERT_EQ(SIGTRAP, WSTOPSIG(status)) << "Status was: " << status;
192
193 siginfo_t siginfo;
194 ASSERT_EQ(0, ptrace(PTRACE_GETSIGINFO, child, nullptr, &siginfo)) << strerror(errno);
195 ASSERT_EQ(TRAP_HWBKPT, siginfo.si_code);
196 #if defined(__arm__) || defined(__aarch64__)
197 ASSERT_LE(&data, siginfo.si_addr);
198 ASSERT_GT((&data) + 1, siginfo.si_addr);
199 #endif
200 }
201
202 template <typename T>
watchpoint_stress_child(unsigned cpu,T & data)203 static void watchpoint_stress_child(unsigned cpu, T& data) {
204 cpu_set_t cpus;
205 CPU_ZERO(&cpus);
206 CPU_SET(cpu, &cpus);
207 if (sched_setaffinity(0, sizeof cpus, &cpus) == -1) {
208 perror("sched_setaffinity");
209 _exit(3);
210 }
211 raise(SIGSTOP); // Synchronize with the tracer, let it set the watchpoint.
212
213 data = 1; // Now trigger the watchpoint.
214 }
215
216 template <typename T>
run_watchpoint_stress(size_t cpu)217 static void run_watchpoint_stress(size_t cpu) {
218 run_watchpoint_test<T>(std::bind(watchpoint_stress_child<T>, cpu, std::placeholders::_1), 0,
219 sizeof(T));
220 }
221
222 // Test watchpoint API. The test is considered successful if our watchpoints get hit OR the
223 // system reports that watchpoint support is not present. We run the test for different
224 // watchpoint sizes, while pinning the process to each cpu in turn, for better coverage.
TEST(sys_ptrace,watchpoint_stress)225 TEST(sys_ptrace, watchpoint_stress) {
226 cpu_set_t available_cpus;
227 ASSERT_EQ(0, sched_getaffinity(0, sizeof available_cpus, &available_cpus));
228
229 for (size_t cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
230 if (!CPU_ISSET(cpu, &available_cpus)) continue;
231
232 run_watchpoint_stress<uint8_t>(cpu);
233 if (::testing::Test::IsSkipped()) {
234 // Only check first case, since all others would skip for same reason.
235 return;
236 }
237 run_watchpoint_stress<uint16_t>(cpu);
238 run_watchpoint_stress<uint32_t>(cpu);
239 #if defined(__LP64__)
240 run_watchpoint_stress<uint64_t>(cpu);
241 #endif
242 }
243 }
244
245 struct Uint128_t {
246 uint64_t data[2];
247 };
watchpoint_imprecise_child(Uint128_t & data)248 static void watchpoint_imprecise_child(Uint128_t& data) {
249 raise(SIGSTOP); // Synchronize with the tracer, let it set the watchpoint.
250
251 #if defined(__i386__) || defined(__x86_64__)
252 asm volatile("movdqa %%xmm0, %0" : : "m"(data));
253 #elif defined(__arm__)
254 asm volatile("stm %0, { r0, r1, r2, r3 }" : : "r"(&data));
255 #elif defined(__aarch64__)
256 asm volatile("stp x0, x1, %0" : : "m"(data));
257 #elif defined(__riscv)
258 UNUSED(data);
259 GTEST_LOG_(INFO) << "missing riscv64 instruction to store > 64 bits in one instruction";
260 #endif
261 }
262
263 // Test that the kernel is able to handle the case when the instruction writes
264 // to a larger block of memory than the one we are watching. If you see this
265 // test fail on arm64, you will likely need to cherry-pick fdfeff0f into your
266 // kernel.
TEST(sys_ptrace,watchpoint_imprecise)267 TEST(sys_ptrace, watchpoint_imprecise) {
268 // This test relies on the infrastructure to timeout if the test hangs.
269 run_watchpoint_test<Uint128_t>(watchpoint_imprecise_child, 8, sizeof(void*));
270 }
271
breakpoint_func()272 static void __attribute__((noinline)) breakpoint_func() {
273 asm volatile("");
274 }
275
breakpoint_fork_child()276 static void __attribute__((noreturn)) breakpoint_fork_child() {
277 // Extra precaution: make sure we go away if anything happens to our parent.
278 if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0) == -1) {
279 perror("prctl(PR_SET_PDEATHSIG)");
280 _exit(1);
281 }
282
283 if (ptrace(PTRACE_TRACEME, 0, nullptr, nullptr) == -1) {
284 perror("ptrace(PTRACE_TRACEME)");
285 _exit(2);
286 }
287
288 raise(SIGSTOP); // Synchronize with the tracer, let it set the breakpoint.
289
290 breakpoint_func(); // Now trigger the breakpoint.
291
292 _exit(0);
293 }
294
set_breakpoint(pid_t child)295 static void set_breakpoint(pid_t child) {
296 uintptr_t address = uintptr_t(breakpoint_func);
297 #if defined(__arm__) || defined(__aarch64__)
298 address &= ~3;
299 const unsigned byte_mask = 0xf;
300 const unsigned enable = 1;
301 const unsigned control = byte_mask << 5 | enable;
302
303 #ifdef __arm__
304 ASSERT_EQ(0, ptrace(PTRACE_SETHBPREGS, child, 1, &address)) << strerror(errno);
305 ASSERT_EQ(0, ptrace(PTRACE_SETHBPREGS, child, 2, &control)) << strerror(errno);
306 #else // aarch64
307 user_hwdebug_state dreg_state;
308 memset(&dreg_state, 0, sizeof dreg_state);
309 dreg_state.dbg_regs[0].addr = reinterpret_cast<uintptr_t>(address);
310 dreg_state.dbg_regs[0].ctrl = control;
311
312 iovec iov;
313 iov.iov_base = &dreg_state;
314 iov.iov_len = offsetof(user_hwdebug_state, dbg_regs) + sizeof(dreg_state.dbg_regs[0]);
315
316 ASSERT_EQ(0, ptrace(PTRACE_SETREGSET, child, NT_ARM_HW_BREAK, &iov)) << strerror(errno);
317 #endif
318 #elif defined(__i386__) || defined(__x86_64__)
319 ASSERT_EQ(0, ptrace(PTRACE_POKEUSER, child, offsetof(user, u_debugreg[0]), address))
320 << strerror(errno);
321 errno = 0;
322 unsigned data = ptrace(PTRACE_PEEKUSER, child, offsetof(user, u_debugreg[7]), nullptr);
323 ASSERT_ERRNO(0);
324
325 const unsigned size = 0;
326 const unsigned enable = 1;
327 const unsigned type = 0; // Execute
328
329 const unsigned mask = 3 << 18 | 3 << 16 | 1;
330 const unsigned value = size << 18 | type << 16 | enable;
331 data &= mask;
332 data |= value;
333 ASSERT_EQ(0, ptrace(PTRACE_POKEUSER, child, offsetof(user, u_debugreg[7]), data))
334 << strerror(errno);
335 #else
336 UNUSED(child);
337 UNUSED(address);
338 #endif
339 }
340
341 // Test hardware breakpoint API. The test is considered successful if the breakpoints get hit OR the
342 // system reports that hardware breakpoint support is not present.
TEST(sys_ptrace,hardware_breakpoint)343 TEST(sys_ptrace, hardware_breakpoint) {
344 pid_t child = fork();
345 ASSERT_NE(-1, child) << strerror(errno);
346 if (child == 0) breakpoint_fork_child();
347
348 ChildGuard guard(child);
349
350 int status;
351 ASSERT_EQ(child, TEMP_FAILURE_RETRY(waitpid(child, &status, __WALL))) << strerror(errno);
352 ASSERT_TRUE(WIFSTOPPED(status)) << "Status was: " << status;
353 ASSERT_EQ(SIGSTOP, WSTOPSIG(status)) << "Status was: " << status;
354
355 check_hw_feature_supported(child, HwFeature::Breakpoint);
356 if (::testing::Test::IsSkipped()) {
357 return;
358 }
359
360 set_breakpoint(child);
361
362 ASSERT_EQ(0, ptrace(PTRACE_CONT, child, nullptr, nullptr)) << strerror(errno);
363 ASSERT_EQ(child, TEMP_FAILURE_RETRY(waitpid(child, &status, __WALL))) << strerror(errno);
364 ASSERT_TRUE(WIFSTOPPED(status)) << "Status was: " << status;
365 ASSERT_EQ(SIGTRAP, WSTOPSIG(status)) << "Status was: " << status;
366
367 siginfo_t siginfo;
368 ASSERT_EQ(0, ptrace(PTRACE_GETSIGINFO, child, nullptr, &siginfo)) << strerror(errno);
369 ASSERT_EQ(TRAP_HWBKPT, siginfo.si_code);
370 }
371
372 class PtraceResumptionTest : public ::testing::Test {
373 public:
374 unique_fd worker_pipe_write;
375
376 pid_t worker = -1;
377 pid_t tracer = -1;
378
PtraceResumptionTest()379 PtraceResumptionTest() {
380 unique_fd worker_pipe_read;
381 if (!android::base::Pipe(&worker_pipe_read, &worker_pipe_write)) {
382 err(1, "failed to create pipe");
383 }
384
385 // Second pipe to synchronize the Yama ptracer setup.
386 unique_fd worker_pipe_setup_read, worker_pipe_setup_write;
387 if (!android::base::Pipe(&worker_pipe_setup_read, &worker_pipe_setup_write)) {
388 err(1, "failed to create pipe");
389 }
390
391 worker = fork();
392 if (worker == -1) {
393 err(1, "failed to fork worker");
394 } else if (worker == 0) {
395 char buf;
396 // Allow the tracer process, which is not a direct process ancestor, to
397 // be able to use ptrace(2) on this process when Yama LSM is active.
398 if (prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0) == -1) {
399 // if Yama is off prctl(PR_SET_PTRACER) returns EINVAL - don't log in this
400 // case since it's expected behaviour.
401 if (errno != EINVAL) {
402 err(1, "prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY) failed for pid %d", getpid());
403 }
404 }
405 worker_pipe_setup_write.reset();
406
407 worker_pipe_write.reset();
408 TEMP_FAILURE_RETRY(read(worker_pipe_read.get(), &buf, sizeof(buf)));
409 exit(0);
410 } else {
411 // Wait until the Yama ptracer is setup.
412 char buf;
413 worker_pipe_setup_write.reset();
414 TEMP_FAILURE_RETRY(read(worker_pipe_setup_read.get(), &buf, sizeof(buf)));
415 }
416 }
417
~PtraceResumptionTest()418 ~PtraceResumptionTest() override {
419 }
420
421 void AssertDeath(int signo);
422
StartTracer(std::function<void ()> f)423 void StartTracer(std::function<void()> f) {
424 tracer = fork();
425 ASSERT_NE(-1, tracer);
426 if (tracer == 0) {
427 f();
428 if (HasFatalFailure()) {
429 exit(1);
430 }
431 exit(0);
432 }
433 }
434
WaitForTracer()435 bool WaitForTracer() {
436 if (tracer == -1) {
437 errx(1, "tracer not started");
438 }
439
440 int result;
441 pid_t rc = TEMP_FAILURE_RETRY(waitpid(tracer, &result, 0));
442 if (rc != tracer) {
443 printf("waitpid returned %d (%s)\n", rc, strerror(errno));
444 return false;
445 }
446
447 if (!WIFEXITED(result) && !WIFSIGNALED(result)) {
448 printf("!WIFEXITED && !WIFSIGNALED\n");
449 return false;
450 }
451
452 if (WIFEXITED(result)) {
453 if (WEXITSTATUS(result) != 0) {
454 printf("tracer failed\n");
455 return false;
456 }
457 }
458
459 return true;
460 }
461
WaitForWorker()462 bool WaitForWorker() {
463 if (worker == -1) {
464 errx(1, "worker not started");
465 }
466
467 int result;
468 pid_t rc = TEMP_FAILURE_RETRY(waitpid(worker, &result, WNOHANG));
469 if (rc != 0) {
470 printf("worker exited prematurely\n");
471 return false;
472 }
473
474 worker_pipe_write.reset();
475
476 rc = TEMP_FAILURE_RETRY(waitpid(worker, &result, 0));
477 if (rc != worker) {
478 printf("waitpid for worker returned %d (%s)\n", rc, strerror(errno));
479 return false;
480 }
481
482 if (!WIFEXITED(result)) {
483 printf("worker didn't exit\n");
484 return false;
485 }
486
487 if (WEXITSTATUS(result) != 0) {
488 printf("worker exited with status %d\n", WEXITSTATUS(result));
489 return false;
490 }
491
492 return true;
493 }
494 };
495
wait_for_ptrace_stop(pid_t pid)496 static void wait_for_ptrace_stop(pid_t pid) {
497 while (true) {
498 int status;
499 pid_t rc = TEMP_FAILURE_RETRY(waitpid(pid, &status, __WALL));
500 if (rc != pid) {
501 abort();
502 }
503 if (WIFSTOPPED(status)) {
504 return;
505 }
506 }
507 }
508
TEST_F(PtraceResumptionTest,smoke)509 TEST_F(PtraceResumptionTest, smoke) {
510 // Make sure that the worker doesn't exit before the tracer stops tracing.
511 StartTracer([this]() {
512 ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno);
513 ASSERT_EQ(0, ptrace(PTRACE_INTERRUPT, worker, 0, 0)) << strerror(errno);
514 wait_for_ptrace_stop(worker);
515 std::this_thread::sleep_for(500ms);
516 });
517
518 worker_pipe_write.reset();
519 std::this_thread::sleep_for(250ms);
520
521 int result;
522 ASSERT_EQ(0, TEMP_FAILURE_RETRY(waitpid(worker, &result, WNOHANG)));
523 ASSERT_TRUE(WaitForTracer());
524 ASSERT_EQ(worker, TEMP_FAILURE_RETRY(waitpid(worker, &result, 0)));
525 }
526
TEST_F(PtraceResumptionTest,seize)527 TEST_F(PtraceResumptionTest, seize) {
528 StartTracer([this]() { ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno); });
529 ASSERT_TRUE(WaitForTracer());
530 ASSERT_TRUE(WaitForWorker());
531 }
532
TEST_F(PtraceResumptionTest,seize_interrupt)533 TEST_F(PtraceResumptionTest, seize_interrupt) {
534 StartTracer([this]() {
535 ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno);
536 ASSERT_EQ(0, ptrace(PTRACE_INTERRUPT, worker, 0, 0)) << strerror(errno);
537 wait_for_ptrace_stop(worker);
538 });
539 ASSERT_TRUE(WaitForTracer());
540 ASSERT_TRUE(WaitForWorker());
541 }
542
TEST_F(PtraceResumptionTest,seize_interrupt_cont)543 TEST_F(PtraceResumptionTest, seize_interrupt_cont) {
544 StartTracer([this]() {
545 ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno);
546 ASSERT_EQ(0, ptrace(PTRACE_INTERRUPT, worker, 0, 0)) << strerror(errno);
547 wait_for_ptrace_stop(worker);
548 ASSERT_EQ(0, ptrace(PTRACE_CONT, worker, 0, 0)) << strerror(errno);
549 });
550 ASSERT_TRUE(WaitForTracer());
551 ASSERT_TRUE(WaitForWorker());
552 }
553
TEST_F(PtraceResumptionTest,zombie_seize)554 TEST_F(PtraceResumptionTest, zombie_seize) {
555 StartTracer([this]() { ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno); });
556 ASSERT_TRUE(WaitForWorker());
557 ASSERT_TRUE(WaitForTracer());
558 }
559
TEST_F(PtraceResumptionTest,zombie_seize_interrupt)560 TEST_F(PtraceResumptionTest, zombie_seize_interrupt) {
561 StartTracer([this]() {
562 ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno);
563 ASSERT_EQ(0, ptrace(PTRACE_INTERRUPT, worker, 0, 0)) << strerror(errno);
564 wait_for_ptrace_stop(worker);
565 });
566 ASSERT_TRUE(WaitForWorker());
567 ASSERT_TRUE(WaitForTracer());
568 }
569
TEST_F(PtraceResumptionTest,zombie_seize_interrupt_cont)570 TEST_F(PtraceResumptionTest, zombie_seize_interrupt_cont) {
571 StartTracer([this]() {
572 ASSERT_EQ(0, ptrace(PTRACE_SEIZE, worker, 0, 0)) << strerror(errno);
573 ASSERT_EQ(0, ptrace(PTRACE_INTERRUPT, worker, 0, 0)) << strerror(errno);
574 wait_for_ptrace_stop(worker);
575 ASSERT_EQ(0, ptrace(PTRACE_CONT, worker, 0, 0)) << strerror(errno);
576 });
577 ASSERT_TRUE(WaitForWorker());
578 ASSERT_TRUE(WaitForTracer());
579 }
580