1 /*
2 * Copyright (C) 2017 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 <errno.h>
18 #include <signal.h>
19 #include <stdint.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <sys/mman.h>
24 #include <sys/ptrace.h>
25 #include <sys/types.h>
26 #include <sys/uio.h>
27 #include <sys/wait.h>
28 #include <unistd.h>
29
30 #include <memory>
31 #include <vector>
32
33 #include <benchmark/benchmark.h>
34
35 #include <backtrace/Backtrace.h>
36
37 #define AT_COMMON_SIZES Arg(1)->Arg(4)->Arg(8)->Arg(16)->Arg(100)->Arg(200)->Arg(500)->Arg(1024)
38
Attach(pid_t pid)39 static void Attach(pid_t pid) {
40 if (ptrace(PTRACE_ATTACH, pid, 0, 0) == -1) {
41 perror("Failed to attach");
42 abort();
43 }
44
45 siginfo_t si;
46 // Wait for up to 5 seconds.
47 for (size_t i = 0; i < 5000; i++) {
48 if (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) == 0) {
49 return;
50 }
51 usleep(1000);
52 }
53 printf("Remote process failed to stop in five seconds.\n");
54 abort();
55 }
56
57 class ScopedPidReaper {
58 public:
ScopedPidReaper(pid_t pid)59 ScopedPidReaper(pid_t pid) : pid_(pid) {}
~ScopedPidReaper()60 ~ScopedPidReaper() {
61 kill(pid_, SIGKILL);
62 waitpid(pid_, nullptr, 0);
63 }
64
65 private:
66 pid_t pid_;
67 };
68
ProcessVmRead(pid_t pid,uint64_t remote_src,void * dst,size_t len)69 static size_t ProcessVmRead(pid_t pid, uint64_t remote_src, void* dst, size_t len) {
70 struct iovec dst_iov = {
71 .iov_base = dst, .iov_len = len,
72 };
73
74 struct iovec src_iov = {
75 .iov_base = reinterpret_cast<void*>(remote_src), .iov_len = len,
76 };
77
78 ssize_t rc = process_vm_readv(pid, &dst_iov, 1, &src_iov, 1, 0);
79 return rc == -1 ? 0 : rc;
80 }
81
PtraceReadLong(pid_t pid,uint64_t addr,long * value)82 static bool PtraceReadLong(pid_t pid, uint64_t addr, long* value) {
83 // ptrace() returns -1 and sets errno when the operation fails.
84 // To disambiguate -1 from a valid result, we clear errno beforehand.
85 errno = 0;
86 *value = ptrace(PTRACE_PEEKTEXT, pid, reinterpret_cast<void*>(addr), nullptr);
87 if (*value == -1 && errno) {
88 return false;
89 }
90 return true;
91 }
92
PtraceRead(pid_t pid,uint64_t addr,void * dst,size_t bytes)93 static size_t PtraceRead(pid_t pid, uint64_t addr, void* dst, size_t bytes) {
94 size_t bytes_read = 0;
95 long data;
96 for (size_t i = 0; i < bytes / sizeof(long); i++) {
97 if (!PtraceReadLong(pid, addr, &data)) {
98 return bytes_read;
99 }
100 memcpy(dst, &data, sizeof(long));
101 dst = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(dst) + sizeof(long));
102 addr += sizeof(long);
103 bytes_read += sizeof(long);
104 }
105
106 size_t left_over = bytes & (sizeof(long) - 1);
107 if (left_over) {
108 if (!PtraceReadLong(pid, addr, &data)) {
109 return bytes_read;
110 }
111 memcpy(dst, &data, left_over);
112 bytes_read += left_over;
113 }
114 return bytes_read;
115 }
116
CreateRemoteProcess(size_t size,void ** map,pid_t * pid)117 static void CreateRemoteProcess(size_t size, void** map, pid_t* pid) {
118 *map = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
119 if (*map == MAP_FAILED) {
120 perror("Can't allocate memory");
121 abort();
122 }
123 memset(*map, 0xaa, size);
124
125 if ((*pid = fork()) == 0) {
126 for (volatile int i = 0;; i++)
127 ;
128 exit(1);
129 }
130 if (*pid < 0) {
131 perror("Failed to fork");
132 abort();
133 }
134 Attach(*pid);
135 // Don't need this map in the current process any more.
136 munmap(*map, size);
137 }
138
BM_read_with_ptrace(benchmark::State & state)139 static void BM_read_with_ptrace(benchmark::State& state) {
140 void* map;
141 pid_t pid;
142 CreateRemoteProcess(state.range(0), &map, &pid);
143 ScopedPidReaper reap(pid);
144
145 std::vector<uint8_t> read_buffer(state.range(0));
146 uint64_t addr = reinterpret_cast<uint64_t>(map);
147 while (state.KeepRunning()) {
148 if (PtraceRead(pid, addr, read_buffer.data(), read_buffer.size()) != read_buffer.size()) {
149 printf("Unexpected bad read.\n");
150 abort();
151 }
152 }
153 ptrace(PTRACE_DETACH, pid, 0, 0);
154 }
155 BENCHMARK(BM_read_with_ptrace)->AT_COMMON_SIZES;
156
BM_read_with_process_vm_read(benchmark::State & state)157 static void BM_read_with_process_vm_read(benchmark::State& state) {
158 void* map;
159 pid_t pid;
160 CreateRemoteProcess(state.range(0), &map, &pid);
161 ScopedPidReaper reap(pid);
162
163 std::vector<uint8_t> read_buffer(state.range(0));
164 uint64_t addr = reinterpret_cast<uint64_t>(map);
165 while (state.KeepRunning()) {
166 if (ProcessVmRead(pid, addr, read_buffer.data(), read_buffer.size()) != read_buffer.size()) {
167 printf("Unexpected bad read.\n");
168 abort();
169 }
170 }
171 ptrace(PTRACE_DETACH, pid, 0, 0);
172 }
173 BENCHMARK(BM_read_with_process_vm_read)->AT_COMMON_SIZES;
174
BM_read_with_backtrace_object(benchmark::State & state)175 static void BM_read_with_backtrace_object(benchmark::State& state) {
176 void* map;
177 pid_t pid;
178 CreateRemoteProcess(state.range(0), &map, &pid);
179 ScopedPidReaper reap(pid);
180
181 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD));
182 if (backtrace.get() == nullptr) {
183 printf("Failed to create backtrace.\n");
184 abort();
185 }
186
187 uint64_t addr = reinterpret_cast<uint64_t>(map);
188 std::vector<uint8_t> read_buffer(state.range(0));
189 while (state.KeepRunning()) {
190 if (backtrace->Read(addr, read_buffer.data(), read_buffer.size()) != read_buffer.size()) {
191 printf("Unexpected bad read.\n");
192 abort();
193 }
194 }
195 ptrace(PTRACE_DETACH, pid, 0, 0);
196 }
197 BENCHMARK(BM_read_with_backtrace_object)->AT_COMMON_SIZES;
198