1 /*
2 * Copyright (C) 2023 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/network_trace_module.h"
18
19 #include "src/trace_processor/importers/common/args_tracker.h"
20 #include "src/trace_processor/importers/common/args_translation_table.h"
21 #include "src/trace_processor/importers/common/async_track_set_tracker.h"
22 #include "src/trace_processor/importers/common/global_args_tracker.h"
23 #include "src/trace_processor/importers/common/slice_tracker.h"
24 #include "src/trace_processor/importers/common/slice_translation_table.h"
25 #include "src/trace_processor/importers/common/track_tracker.h"
26 #include "src/trace_processor/importers/proto/proto_trace_parser.h"
27 #include "src/trace_processor/importers/proto/proto_trace_reader.h"
28 #include "src/trace_processor/sorter/trace_sorter.h"
29 #include "src/trace_processor/types/trace_processor_context.h"
30 #include "test/gtest_and_gmock.h"
31
32 namespace perfetto {
33 namespace trace_processor {
34 namespace {
35 using ::perfetto::protos::pbzero::TrafficDirection;
36
37 class NetworkTraceModuleTest : public testing::Test {
38 public:
NetworkTraceModuleTest()39 NetworkTraceModuleTest() {
40 context_.storage.reset(new TraceStorage());
41 storage_ = context_.storage.get();
42
43 context_.track_tracker.reset(new TrackTracker(&context_));
44 context_.slice_tracker.reset(new SliceTracker(&context_));
45 context_.args_tracker.reset(new ArgsTracker(&context_));
46 context_.global_args_tracker.reset(new GlobalArgsTracker(storage_));
47 context_.slice_translation_table.reset(new SliceTranslationTable(storage_));
48 context_.args_translation_table.reset(new ArgsTranslationTable(storage_));
49 context_.async_track_set_tracker.reset(new AsyncTrackSetTracker(&context_));
50 context_.sorter.reset(new TraceSorter(
51 &context_, std::make_unique<ProtoTraceParser>(&context_),
52 TraceSorter::SortingMode::kFullSort));
53 }
54
TokenizeAndParse()55 util::Status TokenizeAndParse() {
56 context_.chunk_reader.reset(new ProtoTraceReader(&context_));
57
58 trace_->Finalize();
59 std::vector<uint8_t> v = trace_.SerializeAsArray();
60 trace_.Reset();
61
62 auto status = context_.chunk_reader->Parse(
63 TraceBlobView(TraceBlob::CopyFrom(v.data(), v.size())));
64 context_.sorter->ExtractEventsForced();
65 context_.slice_tracker->FlushPendingSlices();
66 context_.args_tracker->Flush();
67 return status;
68 }
69
HasArg(ArgSetId set_id,base::StringView key,Variadic value)70 bool HasArg(ArgSetId set_id, base::StringView key, Variadic value) {
71 StringId key_id = storage_->InternString(key);
72 const auto& args = storage_->arg_table();
73 RowMap rm = args.FilterToRowMap({args.arg_set_id().eq(set_id)});
74 bool found = false;
75 for (auto it = rm.IterateRows(); it; it.Next()) {
76 if (args.key()[it.index()] == key_id) {
77 EXPECT_EQ(args.flat_key()[it.index()], key_id);
78 if (storage_->GetArgValue(it.index()) == value) {
79 found = true;
80 break;
81 }
82 }
83 }
84 return found;
85 }
86
87 protected:
88 protozero::HeapBuffered<protos::pbzero::Trace> trace_;
89 TraceProcessorContext context_;
90 TraceStorage* storage_;
91 };
92
TEST_F(NetworkTraceModuleTest,ParseAndFormatPacket)93 TEST_F(NetworkTraceModuleTest, ParseAndFormatPacket) {
94 NetworkTraceModule module(&context_);
95
96 auto* packet = trace_->add_packet();
97 packet->set_timestamp(123);
98
99 auto* event = packet->set_network_packet();
100 event->set_direction(TrafficDirection::DIR_EGRESS);
101 event->set_length(72);
102 event->set_uid(1010);
103 event->set_tag(0x407);
104 event->set_local_port(5100);
105 event->set_remote_port(443);
106 event->set_tcp_flags(0b10010);
107 event->set_ip_proto(6);
108 event->set_interface("wlan");
109
110 ASSERT_TRUE(TokenizeAndParse().ok());
111
112 const auto& slices = storage_->slice_table();
113 ASSERT_EQ(slices.row_count(), 1u);
114 EXPECT_EQ(slices.ts()[0], 123);
115
116 EXPECT_TRUE(HasArg(1u, "packet_length", Variadic::Integer(72)));
117 EXPECT_TRUE(HasArg(1u, "socket_uid", Variadic::Integer(1010)));
118 EXPECT_TRUE(HasArg(1u, "local_port", Variadic::Integer(5100)));
119 EXPECT_TRUE(HasArg(1u, "remote_port", Variadic::Integer(443)));
120 EXPECT_TRUE(HasArg(1u, "packet_transport",
121 Variadic::String(storage_->InternString("IPPROTO_TCP"))));
122 EXPECT_TRUE(HasArg(1u, "socket_tag",
123 Variadic::String(storage_->InternString("0x407"))));
124 EXPECT_TRUE(HasArg(1u, "packet_tcp_flags",
125 Variadic::String(storage_->InternString(".s..a..."))));
126 }
127
TEST_F(NetworkTraceModuleTest,TokenizeAndParsePerPacketBundle)128 TEST_F(NetworkTraceModuleTest, TokenizeAndParsePerPacketBundle) {
129 NetworkTraceModule module(&context_);
130
131 auto* packet = trace_->add_packet();
132 packet->set_timestamp(123);
133
134 protozero::PackedVarInt timestamps;
135 timestamps.Append(0);
136 timestamps.Append(10);
137
138 protozero::PackedVarInt lengths;
139 lengths.Append(72);
140 lengths.Append(100);
141
142 auto* event = packet->set_network_packet_bundle();
143 event->set_packet_timestamps(timestamps);
144 event->set_packet_lengths(lengths);
145
146 auto* ctx = event->set_ctx();
147 ctx->set_uid(456);
148
149 ASSERT_TRUE(TokenizeAndParse().ok());
150
151 const auto& slices = storage_->slice_table();
152 ASSERT_EQ(slices.row_count(), 2u);
153 EXPECT_EQ(slices.ts()[0], 123);
154 EXPECT_EQ(slices.ts()[1], 133);
155
156 EXPECT_TRUE(HasArg(1u, "packet_length", Variadic::Integer(72)));
157 EXPECT_TRUE(HasArg(2u, "packet_length", Variadic::Integer(100)));
158 }
159
TEST_F(NetworkTraceModuleTest,TokenizeAndParseAggregateBundle)160 TEST_F(NetworkTraceModuleTest, TokenizeAndParseAggregateBundle) {
161 NetworkTraceModule module(&context_);
162
163 auto* packet = trace_->add_packet();
164 packet->set_timestamp(123);
165
166 auto* event = packet->set_network_packet_bundle();
167 event->set_total_packets(2);
168 event->set_total_duration(10);
169 event->set_total_length(172);
170
171 auto* ctx = event->set_ctx();
172 ctx->set_uid(456);
173
174 ASSERT_TRUE(TokenizeAndParse().ok());
175
176 const auto& slices = storage_->slice_table();
177 ASSERT_EQ(slices.row_count(), 1u);
178 EXPECT_EQ(slices.ts()[0], 123);
179 EXPECT_EQ(slices.dur()[0], 10);
180
181 EXPECT_TRUE(HasArg(1u, "packet_length", Variadic::UnsignedInteger(172)));
182 EXPECT_TRUE(HasArg(1u, "packet_count", Variadic::UnsignedInteger(2)));
183 }
184
185 } // namespace
186 } // namespace trace_processor
187 } // namespace perfetto
188