1 /*
2 * Copyright (C) 2018 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/common/process_tracker.h"
18
19 #include <memory>
20 #include <optional>
21
22 #include "perfetto/ext/base/string_view.h"
23 #include "src/trace_processor/importers/common/args_tracker.h"
24 #include "src/trace_processor/importers/common/event_tracker.h"
25 #include "src/trace_processor/importers/common/global_args_tracker.h"
26 #include "src/trace_processor/storage/trace_storage.h"
27 #include "test/gtest_and_gmock.h"
28
29 namespace perfetto::trace_processor {
30 namespace {
31
32 using ::testing::_;
33 using ::testing::InSequence;
34 using ::testing::Invoke;
35
36 class ProcessTrackerTest : public ::testing::Test {
37 public:
ProcessTrackerTest()38 ProcessTrackerTest() {
39 context.storage = std::make_shared<TraceStorage>();
40 context.global_args_tracker =
41 std::make_unique<GlobalArgsTracker>(context.storage.get());
42 context.args_tracker = std::make_unique<ArgsTracker>(&context);
43 context.process_tracker = std::make_unique<ProcessTracker>(&context);
44 context.event_tracker = std::make_unique<EventTracker>(&context);
45 }
46
47 protected:
48 TraceProcessorContext context;
49 };
50
TEST_F(ProcessTrackerTest,PushProcess)51 TEST_F(ProcessTrackerTest, PushProcess) {
52 context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
53 base::StringView());
54 auto opt_upid = context.process_tracker->UpidForPidForTesting(1);
55 ASSERT_EQ(opt_upid.value_or(-1), 1u);
56 }
57
TEST_F(ProcessTrackerTest,GetOrCreateNewProcess)58 TEST_F(ProcessTrackerTest, GetOrCreateNewProcess) {
59 auto upid = context.process_tracker->GetOrCreateProcess(123);
60 ASSERT_EQ(context.process_tracker->GetOrCreateProcess(123), upid);
61 }
62
TEST_F(ProcessTrackerTest,StartNewProcess)63 TEST_F(ProcessTrackerTest, StartNewProcess) {
64 auto upid = context.process_tracker->StartNewProcess(
65 1000, 0u, 123, kNullStringId, ThreadNamePriority::kFtrace);
66 ASSERT_EQ(context.process_tracker->GetOrCreateProcess(123), upid);
67 ASSERT_EQ(context.storage->process_table()[upid].start_ts(), 1000);
68 }
69
TEST_F(ProcessTrackerTest,PushTwoProcessEntries_SamePidAndName)70 TEST_F(ProcessTrackerTest, PushTwoProcessEntries_SamePidAndName) {
71 context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
72 base::StringView());
73 context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
74 base::StringView());
75 auto opt_upid = context.process_tracker->UpidForPidForTesting(1);
76 ASSERT_EQ(opt_upid.value_or(-1), 1u);
77 }
78
TEST_F(ProcessTrackerTest,PushTwoProcessEntries_DifferentPid)79 TEST_F(ProcessTrackerTest, PushTwoProcessEntries_DifferentPid) {
80 context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
81 base::StringView());
82 context.process_tracker->SetProcessMetadata(3, std::nullopt, "test",
83 base::StringView());
84 auto opt_upid = context.process_tracker->UpidForPidForTesting(1);
85 ASSERT_EQ(opt_upid.value_or(-1), 1u);
86 opt_upid = context.process_tracker->UpidForPidForTesting(3);
87 ASSERT_EQ(opt_upid.value_or(-1), 2u);
88 }
89
TEST_F(ProcessTrackerTest,AddProcessEntry_CorrectName)90 TEST_F(ProcessTrackerTest, AddProcessEntry_CorrectName) {
91 context.process_tracker->SetProcessMetadata(1, std::nullopt, "test",
92 base::StringView());
93 auto name = context.storage->process_table()[1].name();
94 ASSERT_EQ(context.storage->GetString(*name), "test");
95 }
96
TEST_F(ProcessTrackerTest,UpdateThreadCreate)97 TEST_F(ProcessTrackerTest, UpdateThreadCreate) {
98 context.process_tracker->UpdateThread(12, 2);
99
100 // We expect 3 threads: Invalid thread, main thread for pid, tid 12.
101 ASSERT_EQ(context.storage->thread_table().row_count(), 3u);
102
103 auto tid_it = context.process_tracker->UtidsForTidForTesting(12);
104 ASSERT_NE(tid_it.first, tid_it.second);
105 ASSERT_EQ(context.storage->thread_table()[1].upid().value(), 1u);
106 auto opt_upid = context.process_tracker->UpidForPidForTesting(2);
107 ASSERT_TRUE(opt_upid.has_value());
108 ASSERT_EQ(context.storage->process_table().row_count(), 2u);
109 }
110
TEST_F(ProcessTrackerTest,PidReuseWithoutStartAndEndThread)111 TEST_F(ProcessTrackerTest, PidReuseWithoutStartAndEndThread) {
112 UniquePid p1 = context.process_tracker->StartNewProcess(
113 std::nullopt, std::nullopt, /*pid=*/1, kNullStringId,
114 ThreadNamePriority::kFtrace);
115 UniqueTid t1 = context.process_tracker->UpdateThread(/*tid=*/2, /*pid=*/1);
116
117 UniquePid p2 = context.process_tracker->StartNewProcess(
118 std::nullopt, std::nullopt, /*pid=*/1, kNullStringId,
119 ThreadNamePriority::kFtrace);
120 UniqueTid t2 = context.process_tracker->UpdateThread(/*tid=*/2, /*pid=*/1);
121
122 ASSERT_NE(p1, p2);
123 ASSERT_NE(t1, t2);
124
125 // We expect 3 processes: idle process, 2x pid 1.
126 ASSERT_EQ(context.storage->process_table().row_count(), 3u);
127 // We expect 5 threads: Invalid thread, 2x (main thread + sub thread).
128 ASSERT_EQ(context.storage->thread_table().row_count(), 5u);
129 }
130
TEST_F(ProcessTrackerTest,Cmdline)131 TEST_F(ProcessTrackerTest, Cmdline) {
132 UniquePid upid = context.process_tracker->SetProcessMetadata(
133 1, std::nullopt, "test", "cmdline blah");
134 auto cmdline = *context.storage->process_table()[upid].cmdline();
135 ASSERT_EQ(context.storage->GetString(cmdline), "cmdline blah");
136 }
137
TEST_F(ProcessTrackerTest,UpdateThreadName)138 TEST_F(ProcessTrackerTest, UpdateThreadName) {
139 auto name1 = context.storage->InternString("name1");
140 auto name2 = context.storage->InternString("name2");
141 auto name3 = context.storage->InternString("name3");
142
143 context.process_tracker->UpdateThreadName(1, name1,
144 ThreadNamePriority::kFtrace);
145 ASSERT_EQ(context.storage->thread_table().row_count(), 2u);
146 ASSERT_EQ(context.storage->thread_table()[1].name(), name1);
147
148 context.process_tracker->UpdateThreadName(1, name2,
149 ThreadNamePriority::kProcessTree);
150 // The priority is higher: the name should change.
151 ASSERT_EQ(context.storage->thread_table().row_count(), 2u);
152 ASSERT_EQ(context.storage->thread_table()[1].name(), name2);
153
154 context.process_tracker->UpdateThreadName(1, name3,
155 ThreadNamePriority::kFtrace);
156 // The priority is lower: the name should stay the same.
157 ASSERT_EQ(context.storage->thread_table().row_count(), 2u);
158 ASSERT_EQ(context.storage->thread_table()[1].name(), name2);
159 }
160
TEST_F(ProcessTrackerTest,SetStartTsIfUnset)161 TEST_F(ProcessTrackerTest, SetStartTsIfUnset) {
162 auto upid = context.process_tracker->StartNewProcess(
163 /*timestamp=*/std::nullopt, 0u, 123, kNullStringId,
164 ThreadNamePriority::kFtrace);
165 context.process_tracker->SetStartTsIfUnset(upid, 1000);
166 ASSERT_EQ(context.storage->process_table()[upid].start_ts(), 1000);
167
168 context.process_tracker->SetStartTsIfUnset(upid, 3000);
169 ASSERT_EQ(context.storage->process_table()[upid].start_ts(), 1000);
170 }
171
TEST_F(ProcessTrackerTest,PidReuseAfterExplicitEnd)172 TEST_F(ProcessTrackerTest, PidReuseAfterExplicitEnd) {
173 UniquePid upid = context.process_tracker->GetOrCreateProcess(123);
174 context.process_tracker->EndThread(100, 123);
175
176 UniquePid reuse = context.process_tracker->GetOrCreateProcess(123);
177 ASSERT_NE(upid, reuse);
178 }
179
TEST_F(ProcessTrackerTest,TidReuseAfterExplicitEnd)180 TEST_F(ProcessTrackerTest, TidReuseAfterExplicitEnd) {
181 UniqueTid utid = context.process_tracker->UpdateThread(123, 123);
182 context.process_tracker->EndThread(100, 123);
183
184 UniqueTid reuse = context.process_tracker->UpdateThread(123, 123);
185 ASSERT_NE(utid, reuse);
186
187 UniqueTid reuse_again = context.process_tracker->UpdateThread(123, 123);
188 ASSERT_EQ(reuse, reuse_again);
189 }
190
TEST_F(ProcessTrackerTest,EndThreadAfterProcessEnd)191 TEST_F(ProcessTrackerTest, EndThreadAfterProcessEnd) {
192 context.process_tracker->StartNewProcess(
193 100, std::nullopt, 123, kNullStringId, ThreadNamePriority::kFtrace);
194 context.process_tracker->UpdateThread(124, 123);
195
196 context.process_tracker->EndThread(200, 123);
197 context.process_tracker->EndThread(201, 124);
198
199 // We expect two processes: the idle process and 123.
200 ASSERT_EQ(context.storage->process_table().row_count(), 2u);
201
202 // We expect three theads: the idle thread, 123 and 124.
203 ASSERT_EQ(context.storage->thread_table().row_count(), 3u);
204 }
205
TEST_F(ProcessTrackerTest,UpdateTrustedPid)206 TEST_F(ProcessTrackerTest, UpdateTrustedPid) {
207 context.process_tracker->UpdateTrustedPid(/*trusted_pid=*/123, /*uuid=*/1001);
208 context.process_tracker->UpdateTrustedPid(/*trusted_pid=*/456, /*uuid=*/1002);
209
210 ASSERT_EQ(context.process_tracker->GetTrustedPid(1001).value(), 123u);
211 ASSERT_EQ(context.process_tracker->GetTrustedPid(1002).value(), 456u);
212
213 // PID reuse. Multiple track UUIDs map to the same trusted_pid.
214 context.process_tracker->UpdateTrustedPid(/*trusted_pid=*/123, /*uuid=*/1003);
215 ASSERT_EQ(context.process_tracker->GetTrustedPid(1001).value(), 123u);
216 ASSERT_EQ(context.process_tracker->GetTrustedPid(1003).value(), 123u);
217 }
218
TEST_F(ProcessTrackerTest,NamespacedProcessesAndThreads)219 TEST_F(ProcessTrackerTest, NamespacedProcessesAndThreads) {
220 context.process_tracker->UpdateNamespacedProcess(/*pid=*/1001,
221 /*nspid=*/{1001, 190, 1});
222 context.process_tracker->UpdateNamespacedThread(/*pid=*/1001, /*tid=*/1002,
223 /*nstid=*/{1002, 192, 2});
224 context.process_tracker->UpdateNamespacedThread(1001, 1003, {1003, 193, 3});
225
226 context.process_tracker->UpdateNamespacedProcess(/*pid=*/1023,
227 /*nspid=*/{1023, 201, 21});
228 context.process_tracker->UpdateNamespacedThread(/*pid=*/1023, /*tid=*/1026,
229 {1026, 196, 26});
230 context.process_tracker->UpdateNamespacedThread(/*pid=*/1023, /*tid=*/1027,
231 {1027, 197, 27});
232
233 context.process_tracker->UpdateNamespacedProcess(/*pid=*/1024,
234 /*nspid=*/{1024, 202, 22});
235 context.process_tracker->UpdateNamespacedThread(/*pid=*/1024, /*tid=*/1028,
236 /*nstid=*/{1028, 198, 28});
237 context.process_tracker->UpdateNamespacedThread(/*pid=*/1024, /*tid=*/1029,
238 /*nstid=*/{1029, 198, 29});
239
240 // Don't resolve if the process/thread isn't namespaced.
241 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(2001, 2002),
242 std::nullopt);
243
244 // Resolve from namespace-local PID to root-level PID.
245 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1001, 1).value(),
246 1001u);
247 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1023, 21).value(),
248 1023u);
249 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1024, 22).value(),
250 1024u);
251
252 // Resolve from namespace-local TID to root-level TID.
253 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1001, 2).value(),
254 1002u);
255 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1001, 3).value(),
256 1003u);
257 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1023, 26).value(),
258 1026u);
259 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1023, 27).value(),
260 1027u);
261 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1024, 28).value(),
262 1028u);
263 ASSERT_EQ(context.process_tracker->ResolveNamespacedTid(1024, 29).value(),
264 1029u);
265 }
266
267 } // namespace
268 } // namespace perfetto::trace_processor
269