1// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROMIUMOS_WIDE_PROFILING_PERF_READER_H_
6#define CHROMIUMOS_WIDE_PROFILING_PERF_READER_H_
7
8#include <stdint.h>
9
10#include <map>
11#include <set>
12#include <string>
13#include <type_traits>
14#include <vector>
15
16#include "base/macros.h"
17
18#include "perf_internals.h"
19#include "quipper_string.h"
20#include "perf_utils.h"
21
22namespace quipper {
23
24struct PerfFileAttr {
25  struct perf_event_attr attr;
26  std::vector<u64> ids;
27};
28
29// Based on code in tools/perf/util/header.c, the metadata are of the following
30// formats:
31
32// Based on kernel/perf_internals.h
33const size_t kBuildIDArraySize = 20;
34const size_t kBuildIDStringLength = kBuildIDArraySize * 2;
35
36struct CStringWithLength {
37  u32 len;
38  string str;
39};
40
41struct PerfStringMetadata {
42  u32 type;
43  std::vector<CStringWithLength> data;
44};
45
46struct PerfUint32Metadata {
47  u32 type;
48  std::vector<uint32_t> data;
49};
50
51struct PerfUint64Metadata {
52  u32 type;
53  std::vector<uint64_t> data;
54};
55
56typedef u32 num_siblings_type;
57
58struct PerfCPUTopologyMetadata {
59  std::vector<CStringWithLength> core_siblings;
60  std::vector<CStringWithLength> thread_siblings;
61};
62
63struct PerfNodeTopologyMetadata {
64  u32 id;
65  u64 total_memory;
66  u64 free_memory;
67  CStringWithLength cpu_list;
68};
69
70struct BufferWithSize;
71struct ConstBufferWithSize;
72
73class PerfReader {
74 public:
75  PerfReader() : sample_type_(0),
76                 read_format_(0),
77                 is_cross_endian_(0) {}
78  ~PerfReader();
79
80  // Makes |build_id| fit the perf format, by either truncating it or adding
81  // zeros to the end so that it has length kBuildIDStringLength.
82  static void PerfizeBuildIDString(string* build_id);
83
84  // Changes |build_id| to the best guess of what the build id was before going
85  // through perf.  Specifically, it keeps removing trailing sequences of four
86  // zero bytes (or eight '0' characters) until there are no more such
87  // sequences, or the build id would be empty if the process were repeated.
88  static void UnperfizeBuildIDString(string* build_id);
89
90  bool ReadFile(const string& filename);
91  bool ReadFromVector(const std::vector<char>& data);
92  bool ReadFromString(const string& str);
93  bool ReadFromPointer(const char* perf_data, size_t size);
94
95  // TODO(rohinmshah): GetSize should not use RegenerateHeader (so that it can
96  // be const).  Ideally, RegenerateHeader would be deleted and instead of
97  // having out_header_ as an instance variable, it would be computed
98  // dynamically whenever needed.
99
100  // Returns the size in bytes that would be written by any of the methods that
101  // write the entire perf data file (WriteFile, WriteToPointer, etc).
102  size_t GetSize();
103
104  bool WriteFile(const string& filename);
105  bool WriteToVector(std::vector<char>* data);
106  bool WriteToString(string* str);
107  bool WriteToPointer(char* buffer, size_t size);
108
109  bool RegenerateHeader();
110
111  // Stores the mapping from filenames to build ids in build_id_events_.
112  // Returns true on success.
113  // Note: If |filenames_to_build_ids| contains a mapping for a filename for
114  // which there is already a build_id_event in build_id_events_, a duplicate
115  // build_id_event will be created, and the old build_id_event will NOT be
116  // deleted.
117  bool InjectBuildIDs(const std::map<string, string>& filenames_to_build_ids);
118
119  // Replaces existing filenames with filenames from |build_ids_to_filenames|
120  // by joining on build ids.  If a build id in |build_ids_to_filenames| is not
121  // present in this parser, it is ignored.
122  bool Localize(const std::map<string, string>& build_ids_to_filenames);
123
124  // Same as Localize, but joins on filenames instead of build ids.
125  bool LocalizeUsingFilenames(const std::map<string, string>& filename_map);
126
127  // Stores a list of unique filenames found in MMAP/MMAP2 events into
128  // |filenames|.  Any existing data in |filenames| will be lost.
129  void GetFilenames(std::vector<string>* filenames) const;
130  void GetFilenamesAsSet(std::set<string>* filenames) const;
131
132  // Uses build id events to populate |filenames_to_build_ids|.
133  // Any existing data in |filenames_to_build_ids| will be lost.
134  // Note:  A filename returned by GetFilenames need not be present in this map,
135  // since there may be no build id event corresponding to the MMAP/MMAP2.
136  void GetFilenamesToBuildIDs(
137      std::map<string, string>* filenames_to_build_ids) const;
138
139  static bool IsSupportedEventType(uint32_t type);
140
141  // If a program using PerfReader calls events(), it could work with the
142  // resulting events by importing kernel/perf_internals.h.  This would also
143  // apply to other forms of data (attributes, event types, build ids, etc.)
144  // However, there is no easy way to work with the sample info within events.
145  // The following two methods have been added for this purpose.
146
147  // Extracts from a perf event |event| info about the perf sample that
148  // contains the event.  Stores info in |sample|.
149  bool ReadPerfSampleInfo(const event_t& event,
150                          struct perf_sample* sample) const;
151  // Writes |sample| info back to a perf event |event|.
152  bool WritePerfSampleInfo(const perf_sample& sample,
153                           event_t* event) const;
154
155  // Accessor funcs.
156  const std::vector<PerfFileAttr>& attrs() const {
157    return attrs_;
158  }
159
160  const std::vector<malloced_unique_ptr<event_t>>& events() const {
161    return events_;
162  }
163
164  const std::vector<perf_trace_event_type>& event_types() const {
165    return event_types_;
166  }
167
168  const std::vector<build_id_event*>& build_id_events() const {
169    return build_id_events_;
170  }
171
172  const std::vector<char>& tracing_data() const {
173    return tracing_data_;
174  }
175
176 protected:
177  bool ReadHeader(const ConstBufferWithSize& data);
178
179  bool ReadAttrs(const ConstBufferWithSize& data);
180  bool ReadAttr(const ConstBufferWithSize& data, size_t* offset);
181  bool ReadEventAttr(const ConstBufferWithSize& data, size_t* offset,
182                     perf_event_attr* attr);
183  bool ReadUniqueIDs(const ConstBufferWithSize& data, size_t num_ids,
184                     size_t* offset, std::vector<u64>* ids);
185
186  bool ReadEventTypes(const ConstBufferWithSize& data);
187  bool ReadEventType(const ConstBufferWithSize& data, size_t* offset);
188
189  bool ReadData(const ConstBufferWithSize& data);
190
191  // Reads metadata in normal mode.
192  bool ReadMetadata(const ConstBufferWithSize& data);
193  bool ReadTracingMetadata(const ConstBufferWithSize& data,
194                           size_t offset, size_t size);
195  bool ReadBuildIDMetadata(const ConstBufferWithSize& data, u32 type,
196                           size_t offset, size_t size);
197  bool ReadStringMetadata(const ConstBufferWithSize& data, u32 type,
198                          size_t offset, size_t size);
199  bool ReadUint32Metadata(const ConstBufferWithSize& data, u32 type,
200                          size_t offset, size_t size);
201  bool ReadUint64Metadata(const ConstBufferWithSize& data, u32 type,
202                          size_t offset, size_t size);
203  bool ReadCPUTopologyMetadata(const ConstBufferWithSize& data, u32 type,
204                               size_t offset, size_t size);
205  bool ReadNUMATopologyMetadata(const ConstBufferWithSize& data, u32 type,
206                                size_t offset, size_t size);
207
208  // Read perf data from piped perf output data.
209  bool ReadPipedData(const ConstBufferWithSize& data);
210  bool ReadTracingMetadataEvent(const ConstBufferWithSize& data, size_t offset);
211
212  // Like WriteToPointer, but does not check if the buffer is large enough.
213  bool WriteToPointerWithoutCheckingSize(char* buffer, size_t size);
214
215  bool WriteHeader(const BufferWithSize& data) const;
216  bool WriteAttrs(const BufferWithSize& data) const;
217  bool WriteEventTypes(const BufferWithSize& data) const;
218  bool WriteData(const BufferWithSize& data) const;
219  bool WriteMetadata(const BufferWithSize& data) const;
220
221  // For writing the various types of metadata.
222  bool WriteBuildIDMetadata(u32 type, size_t* offset,
223                            const BufferWithSize& data) const;
224  bool WriteStringMetadata(u32 type, size_t* offset,
225                           const BufferWithSize& data) const;
226  bool WriteUint32Metadata(u32 type, size_t* offset,
227                           const BufferWithSize& data) const;
228  bool WriteUint64Metadata(u32 type, size_t* offset,
229                           const BufferWithSize& data) const;
230  bool WriteEventDescMetadata(u32 type, size_t* offset,
231                              const BufferWithSize& data) const;
232  bool WriteCPUTopologyMetadata(u32 type, size_t* offset,
233                                const BufferWithSize& data) const;
234  bool WriteNUMATopologyMetadata(u32 type, size_t* offset,
235                                 const BufferWithSize& data) const;
236
237  // For reading event blocks within piped perf data.
238  bool ReadAttrEventBlock(const ConstBufferWithSize& data, size_t offset,
239                          size_t size);
240  bool ReadPerfEventBlock(const event_t& event);
241
242  // Returns the number of types of metadata stored.
243  size_t GetNumMetadata() const;
244
245  // For computing the sizes of the various types of metadata.
246  size_t GetBuildIDMetadataSize() const;
247  size_t GetStringMetadataSize() const;
248  size_t GetUint32MetadataSize() const;
249  size_t GetUint64MetadataSize() const;
250  size_t GetEventDescMetadataSize() const;
251  size_t GetCPUTopologyMetadataSize() const;
252  size_t GetNUMATopologyMetadataSize() const;
253
254  // Returns true if we should write the number of strings for the string
255  // metadata of type |type|.
256  bool NeedsNumberOfStringData(u32 type) const;
257
258  // Replaces existing filenames in MMAP/MMAP2 events based on |filename_map|.
259  // This method does not change |build_id_events_|.
260  bool LocalizeMMapFilenames(const std::map<string, string>& filename_map);
261
262  std::vector<PerfFileAttr> attrs_;
263  std::vector<perf_trace_event_type> event_types_;
264  std::vector<malloced_unique_ptr<event_t>> events_;
265  std::vector<build_id_event*> build_id_events_;
266  std::vector<PerfStringMetadata> string_metadata_;
267  std::vector<PerfUint32Metadata> uint32_metadata_;
268  std::vector<PerfUint64Metadata> uint64_metadata_;
269  PerfCPUTopologyMetadata cpu_topology_;
270  std::vector<PerfNodeTopologyMetadata> numa_topology_;
271  std::vector<char> tracing_data_;
272  uint64_t sample_type_;
273  uint64_t read_format_;
274  uint64_t metadata_mask_;
275
276  // Indicates that the perf data being read is from machine with a different
277  // endianness than the current machine.
278  bool is_cross_endian_;
279
280 private:
281  u32 ReadPerfEventAttrSize(const ConstBufferWithSize& data,
282                            size_t attr_offset);
283
284  // The file header is either a normal header or a piped header.
285  union {
286    struct perf_file_header header_;
287    struct perf_pipe_file_header piped_header_;
288  };
289  struct perf_file_header out_header_;
290
291  DISALLOW_COPY_AND_ASSIGN(PerfReader);
292};
293
294}  // namespace quipper
295
296#endif  // CHROMIUMOS_WIDE_PROFILING_PERF_READER_H_
297