1 /*
2 * Copyright (C) 2019 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 <android-base/file.h>
18 #include <android-base/test_utils.h>
19 #include <gtest/gtest.h>
20
21 #include "command.h"
22 #include "get_test_data.h"
23 #include "test_util.h"
24 #include "utils.h"
25
26 using namespace simpleperf;
27
InjectCmd()28 static std::unique_ptr<Command> InjectCmd() {
29 return CreateCommandInstance("inject");
30 }
31
RunInjectCmd(std::vector<std::string> && args)32 static bool RunInjectCmd(std::vector<std::string>&& args) {
33 bool has_input = std::find(args.begin(), args.end(), "-i") != args.end();
34 if (!has_input) {
35 args.insert(args.end(), {"-i", GetTestData(PERF_DATA_ETM_TEST_LOOP)});
36 }
37 args.insert(args.end(), {"--symdir", GetTestDataDir() + "etm"});
38 return InjectCmd()->Run(args);
39 }
40
RunInjectCmd(std::vector<std::string> && args,std::string * output)41 static bool RunInjectCmd(std::vector<std::string>&& args, std::string* output) {
42 TemporaryFile tmpfile;
43 close(tmpfile.release());
44 args.insert(args.end(), {"-o", tmpfile.path});
45 if (!RunInjectCmd(std::move(args))) {
46 return false;
47 }
48 if (output != nullptr) {
49 return android::base::ReadFileToString(tmpfile.path, output);
50 }
51 return true;
52 }
53
CheckMatchingExpectedData(const std::string & name,std::string & data)54 static void CheckMatchingExpectedData(const std::string& name, std::string& data) {
55 std::string expected_data;
56 ASSERT_TRUE(android::base::ReadFileToString(
57 GetTestData(std::string("etm") + OS_PATH_SEPARATOR + name), &expected_data));
58 data.erase(std::remove(data.begin(), data.end(), '\r'), data.end());
59 ASSERT_EQ(data, expected_data);
60 }
61
62 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,smoke)63 TEST(cmd_inject, smoke) {
64 std::string data;
65 ASSERT_TRUE(RunInjectCmd({}, &data));
66 // Test that we can find instr range in etm_test_loop binary.
67 ASSERT_NE(data.find("etm_test_loop"), std::string::npos);
68 CheckMatchingExpectedData("perf_inject.data", data);
69 }
70
71 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,binary_option)72 TEST(cmd_inject, binary_option) {
73 // Test that data for etm_test_loop is generated when selected by --binary.
74 std::string data;
75 ASSERT_TRUE(RunInjectCmd({"--binary", "etm_test_loop"}, &data));
76 ASSERT_NE(data.find("etm_test_loop"), std::string::npos);
77
78 // Test that data for etm_test_loop is generated when selected by regex.
79 ASSERT_TRUE(RunInjectCmd({"--binary", "etm_t.*_loop"}, &data));
80 ASSERT_NE(data.find("etm_test_loop"), std::string::npos);
81
82 // Test that data for etm_test_loop isn't generated when not selected by --binary.
83 ASSERT_TRUE(RunInjectCmd({"--binary", "no_etm_test_loop"}, &data));
84 ASSERT_EQ(data.find("etm_test_loop"), std::string::npos);
85
86 // Test that data for etm_test_loop isn't generated when not selected by regex.
87 ASSERT_TRUE(RunInjectCmd({"--binary", "no_etm_test_.*"}, &data));
88 ASSERT_EQ(data.find("etm_test_loop"), std::string::npos);
89 }
90
91 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,exclude_perf_option)92 TEST(cmd_inject, exclude_perf_option) {
93 ASSERT_TRUE(RunInjectCmd({"--exclude-perf"}, nullptr));
94 }
95
96 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,output_option)97 TEST(cmd_inject, output_option) {
98 TemporaryFile tmpfile;
99 close(tmpfile.release());
100 ASSERT_TRUE(RunInjectCmd({"--output", "autofdo", "-o", tmpfile.path}));
101 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-o", tmpfile.path}));
102 std::string autofdo_data;
103 ASSERT_TRUE(RunInjectCmd({"-i", tmpfile.path, "--output", "autofdo"}, &autofdo_data));
104 CheckMatchingExpectedData("perf_inject.data", autofdo_data);
105 std::string bolt_data;
106 ASSERT_TRUE(RunInjectCmd({"-i", tmpfile.path, "--output", "bolt"}, &bolt_data));
107 CheckMatchingExpectedData("perf_inject_bolt.data", bolt_data);
108 }
109
110 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,compress_option)111 TEST(cmd_inject, compress_option) {
112 TemporaryFile tmpfile;
113 close(tmpfile.release());
114 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-z", "-o", tmpfile.path}));
115 std::string autofdo_data;
116 ASSERT_TRUE(RunInjectCmd({"-i", tmpfile.path, "--output", "autofdo"}, &autofdo_data));
117 CheckMatchingExpectedData("perf_inject.data", autofdo_data);
118 }
119
120 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,skip_empty_output_file)121 TEST(cmd_inject, skip_empty_output_file) {
122 TemporaryFile tmpfile;
123 close(tmpfile.release());
124 ASSERT_TRUE(RunInjectCmd(
125 {"--binary", "not_exist_binary", "--output", "branch-list", "-o", tmpfile.path}));
126 // The empty output file should not be produced.
127 ASSERT_FALSE(IsRegularFile(tmpfile.path));
128 tmpfile.DoNotRemove();
129 }
130
131 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,inject_kernel_data)132 TEST(cmd_inject, inject_kernel_data) {
133 const std::string recording_file =
134 GetTestData(std::string("etm") + OS_PATH_SEPARATOR + "perf_kernel.data");
135
136 // Inject directly to autofdo format.
137 TemporaryFile tmpfile;
138 close(tmpfile.release());
139 ASSERT_TRUE(RunInjectCmd({"-i", recording_file, "-o", tmpfile.path}));
140 std::string autofdo_output;
141 ASSERT_TRUE(android::base::ReadFileToString(tmpfile.path, &autofdo_output));
142 ASSERT_NE(autofdo_output.find("rq_stats.ko"), std::string::npos);
143
144 // Inject through etm branch list.
145 TemporaryFile tmpfile2;
146 close(tmpfile2.release());
147 ASSERT_TRUE(RunInjectCmd({"-i", recording_file, "-o", tmpfile.path, "--output", "branch-list"}));
148 ASSERT_TRUE(RunInjectCmd({"-i", tmpfile.path, "-o", tmpfile2.path}));
149 std::string output;
150 ASSERT_TRUE(android::base::ReadFileToString(tmpfile2.path, &output));
151 ASSERT_EQ(output, autofdo_output);
152 }
153
154 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,unformatted_trace)155 TEST(cmd_inject, unformatted_trace) {
156 std::string data;
157 std::string perf_with_unformatted_trace =
158 GetTestData(std::string("etm") + OS_PATH_SEPARATOR + "perf_with_unformatted_trace.data");
159 ASSERT_TRUE(RunInjectCmd({"-i", perf_with_unformatted_trace}, &data));
160 // Test that we can find instr range in etm_test_loop binary.
161 ASSERT_NE(data.find("etm_test_loop"), std::string::npos);
162 CheckMatchingExpectedData("perf_inject.data", data);
163 }
164
165 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,multiple_input_files)166 TEST(cmd_inject, multiple_input_files) {
167 std::string data;
168 std::string perf_data = GetTestData(PERF_DATA_ETM_TEST_LOOP);
169 std::string perf_with_unformatted_trace =
170 GetTestData(std::string("etm") + OS_PATH_SEPARATOR + "perf_with_unformatted_trace.data");
171
172 // Test input files separated by comma.
173 ASSERT_TRUE(RunInjectCmd({"-i", perf_with_unformatted_trace + "," + perf_data}, &data));
174 ASSERT_NE(data.find("106c->1074:200"), std::string::npos);
175
176 // Test input files from different -i options.
177 ASSERT_TRUE(RunInjectCmd({"-i", perf_with_unformatted_trace, "-i", perf_data}, &data));
178 ASSERT_NE(data.find("106c->1074:200"), std::string::npos);
179
180 // Test input files provided by input_file_list.
181 TemporaryFile tmpfile;
182 std::string input_file_list = perf_data + "\n" + perf_with_unformatted_trace + "\n";
183 ASSERT_TRUE(android::base::WriteStringToFd(input_file_list, tmpfile.fd));
184 close(tmpfile.release());
185 ASSERT_TRUE(RunInjectCmd({"-i", std::string("@") + tmpfile.path}, &data));
186 ASSERT_NE(data.find("106c->1074:200"), std::string::npos);
187 }
188
189 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,merge_branch_list_files)190 TEST(cmd_inject, merge_branch_list_files) {
191 TemporaryFile tmpfile;
192 close(tmpfile.release());
193 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-o", tmpfile.path}));
194 TemporaryFile tmpfile2;
195 close(tmpfile2.release());
196 ASSERT_TRUE(RunInjectCmd({"-i", std::string(tmpfile.path) + "," + tmpfile.path, "--output",
197 "branch-list", "-o", tmpfile2.path}));
198 std::string autofdo_data;
199 ASSERT_TRUE(RunInjectCmd({"-i", tmpfile2.path, "--output", "autofdo"}, &autofdo_data));
200 ASSERT_NE(autofdo_data.find("106c->1074:200"), std::string::npos);
201
202 // Accept invalid branch list files.
203 TemporaryFile tmpfile3;
204 close(tmpfile3.release());
205 ASSERT_TRUE(android::base::WriteStringToFile("bad content", tmpfile3.path));
206 ASSERT_TRUE(RunInjectCmd({"-i", std::string(tmpfile.path) + "," + tmpfile3.path, "--output",
207 "branch-list", "-o", tmpfile2.path}));
208 }
209
210 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,report_warning_when_overflow)211 TEST(cmd_inject, report_warning_when_overflow) {
212 CapturedStderr capture;
213 std::vector<std::unique_ptr<TemporaryFile>> branch_list_files;
214 std::vector<std::unique_ptr<TemporaryFile>> input_files;
215
216 branch_list_files.emplace_back(new TemporaryFile);
217 close(branch_list_files.back()->release());
218 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-o", branch_list_files.back()->path}));
219 for (size_t i = 1; i <= 7; i++) {
220 // Create input file list, repeating branch list file for 1000 times.
221 std::string s;
222 for (size_t j = 0; j < 1000; j++) {
223 s += std::string(branch_list_files.back()->path) + "\n";
224 }
225 input_files.emplace_back(new TemporaryFile);
226 ASSERT_TRUE(android::base::WriteStringToFd(s, input_files.back()->fd));
227 close(input_files.back()->release());
228
229 // Merge branch list files.
230 branch_list_files.emplace_back(new TemporaryFile);
231 close(branch_list_files.back()->release());
232 ASSERT_TRUE(
233 RunInjectCmd({"--output", "branch-list", "-i", std::string("@") + input_files.back()->path,
234 "-o", branch_list_files.back()->path}));
235 }
236 capture.Stop();
237 const std::string WARNING_MSG = "Branch count overflow happened.";
238 ASSERT_NE(capture.str().find(WARNING_MSG), std::string::npos);
239
240 // Warning also happens when converting branch lists to AutoFDO format.
241 capture.Reset();
242 capture.Start();
243 std::string autofdo_data;
244 ASSERT_TRUE(RunInjectCmd({"-i", branch_list_files.back()->path}, &autofdo_data));
245 capture.Stop();
246 ASSERT_NE(capture.str().find(WARNING_MSG), std::string::npos);
247 ASSERT_NE(autofdo_data.find("106c->1074:18446744073709551615"), std::string::npos);
248 }
249
250 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,accept_missing_aux_data)251 TEST(cmd_inject, accept_missing_aux_data) {
252 // Recorded with "-e cs-etm:u --user-buffer-size 64k sleep 1".
253 std::string perf_data = GetTestData("etm/perf_with_missing_aux_data.data");
254 TemporaryFile tmpfile;
255 close(tmpfile.release());
256 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-i", perf_data, "-o", tmpfile.path}));
257 }
258
259 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,read_lbr_data)260 TEST(cmd_inject, read_lbr_data) {
261 // Convert perf.data to AutoFDO text format.
262 auto get_autofdo_data = [&](std::vector<std::string>&& args, std::string* data) {
263 args.insert(args.end(), {"--symdir", GetTestDataDir() + "lbr", "--allow-mismatched-build-id"});
264 return RunInjectCmd(std::move(args), data);
265 };
266
267 const std::string perf_data_path = GetTestData("lbr/perf_lbr.data");
268 std::string data;
269 ASSERT_TRUE(get_autofdo_data({"-i", perf_data_path}, &data));
270 data.erase(std::remove(data.begin(), data.end(), '\r'), data.end());
271
272 std::string expected_data;
273 ASSERT_TRUE(android::base::ReadFileToString(
274 GetTestData(std::string("lbr") + OS_PATH_SEPARATOR + "inject_lbr.data"), &expected_data));
275 ASSERT_EQ(data, expected_data);
276
277 // Convert perf.data to branch_list.proto format.
278 // Then convert branch_list.proto format to AutoFDO text format.
279 TemporaryFile branch_list_file;
280 close(branch_list_file.release());
281 ASSERT_TRUE(
282 RunInjectCmd({"-i", perf_data_path, "--output", "branch-list", "-o", branch_list_file.path}));
283 ASSERT_TRUE(get_autofdo_data({"-i", branch_list_file.path}, &data));
284 ASSERT_EQ(data, expected_data);
285
286 // Test binary filter on LBR data.
287 ASSERT_TRUE(get_autofdo_data({"-i", perf_data_path, "--binary", "no_lbr_test_loop"}, &data));
288 ASSERT_EQ(data.find("lbr_test_loop"), data.npos);
289
290 // Test binary filter on branch list file.
291 ASSERT_TRUE(
292 get_autofdo_data({"-i", branch_list_file.path, "--binary", "no_lbr_test_loop"}, &data));
293 ASSERT_EQ(data.find("lbr_test_loop"), data.npos);
294
295 // Test multiple input files.
296 ASSERT_TRUE(get_autofdo_data(
297 {
298 "-i",
299 std::string(branch_list_file.path) + "," + branch_list_file.path,
300 },
301 &data));
302 ASSERT_NE(data.find("94d->940:706"), data.npos);
303 }
304
305 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,inject_small_binary)306 TEST(cmd_inject, inject_small_binary) {
307 // etm_test_loop_small, a binary compiled with
308 // "-Wl,-z,noseparate-code", where the file is smaller than its text
309 // section mapped into memory.
310 std::string data;
311 std::string perf_data = GetTestData("etm/perf_for_small_binary.data");
312 ASSERT_TRUE(RunInjectCmd({"-i", perf_data}, &data));
313 CheckMatchingExpectedData("perf_inject_small.data", data);
314
315 ASSERT_TRUE(RunInjectCmd({"-i", perf_data, "--output", "bolt"}, &data));
316 CheckMatchingExpectedData("perf_inject_small_bolt.data", data);
317 }
318
319 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,j_option)320 TEST(cmd_inject, j_option) {
321 TemporaryFile tmpfile;
322 close(tmpfile.release());
323 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-o", tmpfile.path}));
324 std::string autofdo_data;
325 ASSERT_TRUE(RunInjectCmd(
326 {"-i", std::string(tmpfile.path) + "," + tmpfile.path, "--output", "autofdo", "-j", "1"},
327 &autofdo_data));
328 ASSERT_NE(autofdo_data.find("106c->1074:200"), std::string::npos);
329
330 ASSERT_TRUE(RunInjectCmd(
331 {"-i", std::string(tmpfile.path) + "," + tmpfile.path, "--output", "autofdo", "-j", "2"},
332 &autofdo_data));
333 ASSERT_NE(autofdo_data.find("106c->1074:200"), std::string::npos);
334
335 // Invalid job count.
336 ASSERT_FALSE(RunInjectCmd(
337 {"-i", std::string(tmpfile.path) + "," + tmpfile.path, "--output", "autofdo", "-j", "0"},
338 &autofdo_data));
339 }
340
341 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,dump_option)342 TEST(cmd_inject, dump_option) {
343 TemporaryFile tmpfile;
344 close(tmpfile.release());
345 ASSERT_TRUE(RunInjectCmd({"--output", "branch-list", "-o", tmpfile.path}));
346
347 CaptureStdout capture;
348 ASSERT_TRUE(capture.Start());
349 ASSERT_TRUE(InjectCmd()->Run({"--dump", tmpfile.path}));
350 std::string data = capture.Finish();
351 ASSERT_NE(data.find("binary[0].build_id: 0x0c9a20bf9c009d0e4e8bbf9fad0300ae00000000"),
352 std::string::npos);
353
354 ASSERT_TRUE(RunInjectCmd(
355 {"--output", "branch-list", "-o", tmpfile.path, "-i", GetTestData("lbr/perf_lbr.data")}));
356
357 ASSERT_TRUE(capture.Start());
358 ASSERT_TRUE(InjectCmd()->Run({"--dump", tmpfile.path}));
359 data = capture.Finish();
360 ASSERT_NE(data.find("binary[0].path: /home/yabinc/lbr_test_loop"), std::string::npos);
361 }
362
363 // @CddTest = 6.1/C-0-2
TEST(cmd_inject,exclude_process_name_option)364 TEST(cmd_inject, exclude_process_name_option) {
365 TemporaryFile tmpfile;
366 close(tmpfile.release());
367 ASSERT_TRUE(RunInjectCmd(
368 {"--output", "branch-list", "--exclude-process-name", "etm_test_loop", "-o", tmpfile.path}));
369 struct stat st;
370 ASSERT_EQ(stat(tmpfile.path, &st), -1);
371 ASSERT_EQ(errno, ENOENT);
372 }
373