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 "src/trace_processor/importers/proto/android_probes_module.h"
18
19 #include "perfetto/base/build_config.h"
20 #include "perfetto/protozero/scattered_heap_buffer.h"
21 #include "src/trace_processor/importers/proto/android_probes_parser.h"
22 #include "src/trace_processor/timestamped_trace_piece.h"
23 #include "src/trace_processor/trace_sorter.h"
24
25 #include "protos/perfetto/config/trace_config.pbzero.h"
26 #include "protos/perfetto/trace/power/power_rails.pbzero.h"
27 #include "protos/perfetto/trace/trace_packet.pbzero.h"
28
29 namespace perfetto {
30 namespace trace_processor {
31
32 using perfetto::protos::pbzero::TracePacket;
33
AndroidProbesModule(TraceProcessorContext * context)34 AndroidProbesModule::AndroidProbesModule(TraceProcessorContext* context)
35 : parser_(context), context_(context) {
36 RegisterForField(TracePacket::kBatteryFieldNumber, context);
37 RegisterForField(TracePacket::kPowerRailsFieldNumber, context);
38 RegisterForField(TracePacket::kAndroidLogFieldNumber, context);
39 RegisterForField(TracePacket::kPackagesListFieldNumber, context);
40 }
41
TokenizePacket(const protos::pbzero::TracePacket_Decoder &,TraceBlobView * packet,int64_t packet_timestamp,PacketSequenceState * state,uint32_t field_id)42 ModuleResult AndroidProbesModule::TokenizePacket(
43 const protos::pbzero::TracePacket_Decoder&,
44 TraceBlobView* packet,
45 int64_t packet_timestamp,
46 PacketSequenceState* state,
47 uint32_t field_id) {
48 if (field_id != TracePacket::kPowerRailsFieldNumber)
49 return ModuleResult::Ignored();
50
51 // Power rails are similar to ftrace in that they have many events, each with
52 // their own timestamp, packed inside a single TracePacket. This means that,
53 // similar to ftrace, we need to unpack them and individually sort them.
54
55 // However, as these events are not perf sensitive, it's not worth adding
56 // a lot of machinery to shepherd these events through the sorting queues
57 // in a special way. Therefore, we just forge new packets and sort them as if
58 // they came from the underlying trace.
59
60 protos::pbzero::TracePacket::Decoder decoder(packet->data(),
61 packet->length());
62 auto power_rails = decoder.power_rails();
63 protos::pbzero::PowerRails::Decoder evt(power_rails.data, power_rails.size);
64
65 // Break out the rail descriptor into its own packet with the same timestamp
66 // as the packet itself.
67 if (evt.has_rail_descriptor()) {
68 protozero::HeapBuffered<protos::pbzero::TracePacket> desc_packet;
69 desc_packet->set_timestamp(static_cast<uint64_t>(packet_timestamp));
70
71 auto* rails = desc_packet->set_power_rails();
72 for (auto it = evt.rail_descriptor(); it; ++it) {
73 protozero::ConstBytes desc = *it;
74 rails->add_rail_descriptor()->AppendRawProtoBytes(desc.data, desc.size);
75 }
76
77 std::vector<uint8_t> vec = desc_packet.SerializeAsArray();
78 std::unique_ptr<uint8_t[]> buffer(new uint8_t[vec.size()]);
79 memcpy(buffer.get(), vec.data(), vec.size());
80 context_->sorter->PushTracePacket(
81 packet_timestamp, state,
82 TraceBlobView(std::move(buffer), 0, vec.size()));
83 }
84
85 // For each energy data message, turn it into its own trace packet
86 // making sure its timestamp is consistent between the packet level and
87 // the EnergyData level.
88 for (auto it = evt.energy_data(); it; ++it) {
89 protozero::ConstBytes bytes = *it;
90 protos::pbzero::PowerRails_EnergyData_Decoder data(bytes.data, bytes.size);
91 int64_t actual_ts =
92 data.has_timestamp_ms()
93 ? static_cast<int64_t>(data.timestamp_ms()) * 1000000
94 : packet_timestamp;
95
96 protozero::HeapBuffered<protos::pbzero::TracePacket> data_packet;
97 data_packet->set_timestamp(static_cast<uint64_t>(actual_ts));
98
99 auto* energy = data_packet->set_power_rails()->add_energy_data();
100 energy->set_energy(data.energy());
101 energy->set_index(data.index());
102 energy->set_timestamp_ms(static_cast<uint64_t>(actual_ts / 1000000));
103
104 std::vector<uint8_t> vec = data_packet.SerializeAsArray();
105 std::unique_ptr<uint8_t[]> buffer(new uint8_t[vec.size()]);
106 memcpy(buffer.get(), vec.data(), vec.size());
107 context_->sorter->PushTracePacket(
108 actual_ts, state, TraceBlobView(std::move(buffer), 0, vec.size()));
109 }
110
111 return ModuleResult::Handled();
112 }
113
ParsePacket(const TracePacket::Decoder & decoder,const TimestampedTracePiece & ttp,uint32_t field_id)114 void AndroidProbesModule::ParsePacket(const TracePacket::Decoder& decoder,
115 const TimestampedTracePiece& ttp,
116 uint32_t field_id) {
117 switch (field_id) {
118 case TracePacket::kBatteryFieldNumber:
119 parser_.ParseBatteryCounters(ttp.timestamp, decoder.battery());
120 return;
121 case TracePacket::kPowerRailsFieldNumber:
122 parser_.ParsePowerRails(ttp.timestamp, decoder.power_rails());
123 return;
124 case TracePacket::kAndroidLogFieldNumber:
125 parser_.ParseAndroidLogPacket(decoder.android_log());
126 return;
127 case TracePacket::kPackagesListFieldNumber:
128 parser_.ParseAndroidPackagesList(decoder.packages_list());
129 return;
130 }
131 }
132
ParseTraceConfig(const protos::pbzero::TraceConfig::Decoder & decoder)133 void AndroidProbesModule::ParseTraceConfig(
134 const protos::pbzero::TraceConfig::Decoder& decoder) {
135 if (decoder.has_statsd_metadata()) {
136 parser_.ParseStatsdMetadata(decoder.statsd_metadata());
137 }
138 }
139
140 } // namespace trace_processor
141 } // namespace perfetto
142