1/*
2 * Copyright (C) 2015 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 <libgen.h>
18#include <poll.h>
19#include <signal.h>
20#include <string>
21#include <vector>
22
23#include <base/logging.h>
24#include <base/strings.h>
25
26#include "command.h"
27#include "environment.h"
28#include "event_selection_set.h"
29#include "event_type.h"
30#include "read_elf.h"
31#include "record.h"
32#include "record_file.h"
33#include "utils.h"
34#include "workload.h"
35
36static std::string default_measured_event_type = "cpu-cycles";
37
38class RecordCommandImpl {
39 public:
40  RecordCommandImpl()
41      : use_sample_freq_(true),
42        sample_freq_(1000),
43        system_wide_collection_(false),
44        measured_event_type_(nullptr),
45        perf_mmap_pages_(256),
46        record_filename_("perf.data") {
47    // We need signal SIGCHLD to break poll().
48    saved_sigchild_handler_ = signal(SIGCHLD, [](int) {});
49  }
50
51  ~RecordCommandImpl() {
52    signal(SIGCHLD, saved_sigchild_handler_);
53  }
54
55  bool Run(const std::vector<std::string>& args);
56
57  static bool ReadMmapDataCallback(const char* data, size_t size);
58
59 private:
60  bool ParseOptions(const std::vector<std::string>& args, std::vector<std::string>* non_option_args);
61  bool SetMeasuredEventType(const std::string& event_type_name);
62  void SetEventSelection();
63  bool WriteData(const char* data, size_t size);
64  bool DumpKernelAndModuleMmaps();
65  bool DumpThreadCommAndMmaps();
66  bool DumpAdditionalFeatures();
67  bool DumpBuildIdFeature();
68
69  bool use_sample_freq_;    // Use sample_freq_ when true, otherwise using sample_period_.
70  uint64_t sample_freq_;    // Sample 'sample_freq_' times per second.
71  uint64_t sample_period_;  // Sample once when 'sample_period_' events occur.
72
73  bool system_wide_collection_;
74  const EventType* measured_event_type_;
75  EventSelectionSet event_selection_set_;
76
77  // mmap pages used by each perf event file, should be power of 2.
78  const size_t perf_mmap_pages_;
79
80  std::string record_filename_;
81  std::unique_ptr<RecordFileWriter> record_file_writer_;
82
83  sighandler_t saved_sigchild_handler_;
84};
85
86bool RecordCommandImpl::Run(const std::vector<std::string>& args) {
87  // 1. Parse options, and use default measured event type if not given.
88  std::vector<std::string> workload_args;
89  if (!ParseOptions(args, &workload_args)) {
90    return false;
91  }
92  if (measured_event_type_ == nullptr) {
93    if (!SetMeasuredEventType(default_measured_event_type)) {
94      return false;
95    }
96  }
97  SetEventSelection();
98
99  // 2. Create workload.
100  if (workload_args.empty()) {
101    // TODO: change default workload to sleep 99999, and run record until Ctrl-C.
102    workload_args = std::vector<std::string>({"sleep", "1"});
103  }
104  std::unique_ptr<Workload> workload = Workload::CreateWorkload(workload_args);
105  if (workload == nullptr) {
106    return false;
107  }
108
109  // 3. Open perf_event_files, create memory mapped buffers for perf_event_files, add prepare poll
110  //    for perf_event_files.
111  if (system_wide_collection_) {
112    if (!event_selection_set_.OpenEventFilesForAllCpus()) {
113      return false;
114    }
115  } else {
116    event_selection_set_.EnableOnExec();
117    if (!event_selection_set_.OpenEventFilesForProcess(workload->GetPid())) {
118      return false;
119    }
120  }
121  if (!event_selection_set_.MmapEventFiles(perf_mmap_pages_)) {
122    return false;
123  }
124  std::vector<pollfd> pollfds;
125  event_selection_set_.PreparePollForEventFiles(&pollfds);
126
127  // 4. Open record file writer, and dump kernel/modules/threads mmap information.
128  record_file_writer_ = RecordFileWriter::CreateInstance(
129      record_filename_, event_selection_set_.FindEventAttrByType(*measured_event_type_),
130      event_selection_set_.FindEventFdsByType(*measured_event_type_));
131  if (record_file_writer_ == nullptr) {
132    return false;
133  }
134  if (!DumpKernelAndModuleMmaps()) {
135    return false;
136  }
137  if (system_wide_collection_ && !DumpThreadCommAndMmaps()) {
138    return false;
139  }
140
141  // 5. Write records in mmap buffers of perf_event_files to output file while workload is running.
142
143  // If monitoring only one process, we use the enable_on_exec flag, and don't need to start
144  // recording manually.
145  if (system_wide_collection_) {
146    if (!event_selection_set_.EnableEvents()) {
147      return false;
148    }
149  }
150  if (!workload->Start()) {
151    return false;
152  }
153  auto callback =
154      std::bind(&RecordCommandImpl::WriteData, this, std::placeholders::_1, std::placeholders::_2);
155  while (true) {
156    if (!event_selection_set_.ReadMmapEventData(callback)) {
157      return false;
158    }
159    if (workload->IsFinished()) {
160      break;
161    }
162    poll(&pollfds[0], pollfds.size(), -1);
163  }
164
165  // 6. Dump additional features, and close record file.
166  if (!DumpAdditionalFeatures()) {
167    return false;
168  }
169  if (!record_file_writer_->Close()) {
170    return false;
171  }
172  return true;
173}
174
175bool RecordCommandImpl::ParseOptions(const std::vector<std::string>& args,
176                                     std::vector<std::string>* non_option_args) {
177  size_t i;
178  for (i = 1; i < args.size() && args[i].size() > 0 && args[i][0] == '-'; ++i) {
179    if (args[i] == "-a") {
180      system_wide_collection_ = true;
181    } else if (args[i] == "-c") {
182      if (!NextArgumentOrError(args, &i)) {
183        return false;
184      }
185      char* endptr;
186      sample_period_ = strtoull(args[i].c_str(), &endptr, 0);
187      if (*endptr != '\0' || sample_period_ == 0) {
188        LOG(ERROR) << "Invalid sample period: '" << args[i] << "'";
189        return false;
190      }
191      use_sample_freq_ = false;
192    } else if (args[i] == "-e") {
193      if (!NextArgumentOrError(args, &i)) {
194        return false;
195      }
196      if (!SetMeasuredEventType(args[i])) {
197        return false;
198      }
199    } else if (args[i] == "-f" || args[i] == "-F") {
200      if (!NextArgumentOrError(args, &i)) {
201        return false;
202      }
203      char* endptr;
204      sample_freq_ = strtoull(args[i].c_str(), &endptr, 0);
205      if (*endptr != '\0' || sample_freq_ == 0) {
206        LOG(ERROR) << "Invalid sample frequency: '" << args[i] << "'";
207        return false;
208      }
209      use_sample_freq_ = true;
210    } else if (args[i] == "-o") {
211      if (!NextArgumentOrError(args, &i)) {
212        return false;
213      }
214      record_filename_ = args[i];
215    } else {
216      LOG(ERROR) << "Unknown option for record command: '" << args[i] << "'\n";
217      LOG(ERROR) << "Try `simpleperf help record`";
218      return false;
219    }
220  }
221
222  if (non_option_args != nullptr) {
223    non_option_args->clear();
224    for (; i < args.size(); ++i) {
225      non_option_args->push_back(args[i]);
226    }
227  }
228  return true;
229}
230
231bool RecordCommandImpl::SetMeasuredEventType(const std::string& event_type_name) {
232  const EventType* event_type = EventTypeFactory::FindEventTypeByName(event_type_name);
233  if (event_type == nullptr) {
234    return false;
235  }
236  measured_event_type_ = event_type;
237  return true;
238}
239
240void RecordCommandImpl::SetEventSelection() {
241  event_selection_set_.AddEventType(*measured_event_type_);
242  if (use_sample_freq_) {
243    event_selection_set_.SetSampleFreq(sample_freq_);
244  } else {
245    event_selection_set_.SetSamplePeriod(sample_period_);
246  }
247  event_selection_set_.SampleIdAll();
248}
249
250bool RecordCommandImpl::WriteData(const char* data, size_t size) {
251  return record_file_writer_->WriteData(data, size);
252}
253
254bool RecordCommandImpl::DumpKernelAndModuleMmaps() {
255  KernelMmap kernel_mmap;
256  std::vector<ModuleMmap> module_mmaps;
257  if (!GetKernelAndModuleMmaps(&kernel_mmap, &module_mmaps)) {
258    return false;
259  }
260  const perf_event_attr& attr = event_selection_set_.FindEventAttrByType(*measured_event_type_);
261  MmapRecord mmap_record = CreateMmapRecord(attr, true, UINT_MAX, 0, kernel_mmap.start_addr,
262                                            kernel_mmap.len, kernel_mmap.pgoff, kernel_mmap.name);
263  if (!record_file_writer_->WriteData(mmap_record.BinaryFormat())) {
264    return false;
265  }
266  for (auto& module_mmap : module_mmaps) {
267    std::string filename = module_mmap.filepath;
268    if (filename.empty()) {
269      filename = "[" + module_mmap.name + "]";
270    }
271    MmapRecord mmap_record = CreateMmapRecord(attr, true, UINT_MAX, 0, module_mmap.start_addr,
272                                              module_mmap.len, 0, filename);
273    if (!record_file_writer_->WriteData(mmap_record.BinaryFormat())) {
274      return false;
275    }
276  }
277  return true;
278}
279
280bool RecordCommandImpl::DumpThreadCommAndMmaps() {
281  std::vector<ThreadComm> thread_comms;
282  if (!GetThreadComms(&thread_comms)) {
283    return false;
284  }
285  const perf_event_attr& attr = event_selection_set_.FindEventAttrByType(*measured_event_type_);
286  for (auto& thread : thread_comms) {
287    CommRecord record = CreateCommRecord(attr, thread.tgid, thread.tid, thread.comm);
288    if (!record_file_writer_->WriteData(record.BinaryFormat())) {
289      return false;
290    }
291    if (thread.is_process) {
292      std::vector<ThreadMmap> thread_mmaps;
293      if (!GetThreadMmapsInProcess(thread.tgid, &thread_mmaps)) {
294        // The thread may exit before we get its info.
295        continue;
296      }
297      for (auto& thread_mmap : thread_mmaps) {
298        if (thread_mmap.executable == 0) {
299          continue;  // No need to dump non-executable mmap info.
300        }
301        MmapRecord record =
302            CreateMmapRecord(attr, false, thread.tgid, thread.tid, thread_mmap.start_addr,
303                             thread_mmap.len, thread_mmap.pgoff, thread_mmap.name);
304        if (!record_file_writer_->WriteData(record.BinaryFormat())) {
305          return false;
306        }
307      }
308    }
309  }
310  return true;
311}
312
313bool RecordCommandImpl::DumpAdditionalFeatures() {
314  if (!record_file_writer_->WriteFeatureHeader(1)) {
315    return false;
316  }
317  return DumpBuildIdFeature();
318}
319
320bool RecordCommandImpl::DumpBuildIdFeature() {
321  std::vector<std::string> hit_kernel_modules;
322  std::vector<std::string> hit_user_files;
323  if (!record_file_writer_->GetHitModules(&hit_kernel_modules, &hit_user_files)) {
324    return false;
325  }
326  std::vector<BuildIdRecord> build_id_records;
327  BuildId build_id;
328  // Add build_ids for kernel/modules.
329  for (auto& filename : hit_kernel_modules) {
330    if (filename == DEFAULT_KERNEL_MMAP_NAME) {
331      if (!GetKernelBuildId(&build_id)) {
332        LOG(DEBUG) << "can't read build_id for kernel";
333        continue;
334      }
335      build_id_records.push_back(
336          CreateBuildIdRecord(true, UINT_MAX, build_id, DEFAULT_KERNEL_FILENAME_FOR_BUILD_ID));
337    } else {
338      std::string module_name = basename(&filename[0]);
339      if (android::base::EndsWith(module_name, ".ko")) {
340        module_name = module_name.substr(0, module_name.size() - 3);
341      }
342      if (!GetModuleBuildId(module_name, &build_id)) {
343        LOG(DEBUG) << "can't read build_id for module " << module_name;
344        continue;
345      }
346      build_id_records.push_back(CreateBuildIdRecord(true, UINT_MAX, build_id, filename));
347    }
348  }
349  // Add build_ids for user elf files.
350  for (auto& filename : hit_user_files) {
351    if (filename == DEFAULT_EXECNAME_FOR_THREAD_MMAP) {
352      continue;
353    }
354    if (!GetBuildIdFromElfFile(filename, &build_id)) {
355      LOG(DEBUG) << "can't read build_id from file " << filename;
356      continue;
357    }
358    build_id_records.push_back(CreateBuildIdRecord(false, UINT_MAX, build_id, filename));
359  }
360  if (!record_file_writer_->WriteBuildIdFeature(build_id_records)) {
361    return false;
362  }
363  return true;
364}
365
366class RecordCommand : public Command {
367 public:
368  RecordCommand()
369      : Command("record", "record sampling info in perf.data",
370                "Usage: simpleperf record [options] [command [command-args]]\n"
371                "    Gather sampling information when running [command]. If [command]\n"
372                "    is not specified, sleep 1 is used instead.\n"
373                "    -a           System-wide collection.\n"
374                "    -c count     Set event sample period.\n"
375                "    -e event     Select the event to sample (Use `simpleperf list`)\n"
376                "                 to find all possible event names.\n"
377                "    -f freq      Set event sample frequency.\n"
378                "    -F freq      Same as '-f freq'.\n"
379                "    -o record_file_name    Set record file name, default is perf.data.\n") {
380  }
381
382  bool Run(const std::vector<std::string>& args) override {
383    RecordCommandImpl impl;
384    return impl.Run(args);
385  }
386};
387
388RecordCommand record_command;
389