1 /*
2  * Copyright (C) 2016 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 "perf_clock.h"
18 
19 #include <sys/mman.h>
20 #include <sys/syscall.h>
21 
22 #include <atomic>
23 #include <chrono>
24 #include <thread>
25 
26 #include <android-base/logging.h>
27 
28 #include "environment.h"
29 #include "event_attr.h"
30 #include "event_fd.h"
31 #include "event_type.h"
32 #include "record.h"
33 
34 static bool perf_clock_initialized = false;
35 static int64_t perf_clock_and_system_clock_diff_in_ns = 0;
36 
37 struct ThreadArg {
38   std::atomic<pid_t> thread_a_tid;
39   std::atomic<bool> start_mmap;
40   std::atomic<uint64_t> mmap_start_addr;
41   uint64_t system_time_in_ns;
42   std::atomic<bool> has_error;
43 };
44 
45 static void ThreadA(ThreadArg* thread_arg) {
46   thread_arg->thread_a_tid = syscall(SYS_gettid);
47   while (!thread_arg->start_mmap) {
48     usleep(1000);
49   }
50 
51   size_t TRY_MMAP_COUNT = 10;
52 
53   struct TryMmap {
54     void* mmap_start_addr;
55     uint64_t start_system_time_in_ns;
56     uint64_t end_system_time_in_ns;
57   };
58   TryMmap array[TRY_MMAP_COUNT];
59 
60   // In case current thread is preempted by other threads, we run mmap()
61   // multiple times and use the one with the smallest time interval.
62   for (size_t i = 0; i < TRY_MMAP_COUNT; ++i) {
63     array[i].start_system_time_in_ns = GetSystemClock();
64     array[i].mmap_start_addr =
65         mmap(NULL, 4096, PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
66     if (array[i].mmap_start_addr == MAP_FAILED) {
67       PLOG(ERROR) << "mmap() failed";
68       thread_arg->has_error = true;
69       return;
70     }
71 
72     array[i].end_system_time_in_ns = GetSystemClock();
73   }
74   size_t best_index = 0;
75   uint64_t min_duration_in_ns = UINT64_MAX;
76   for (size_t i = 0; i < TRY_MMAP_COUNT; ++i) {
77     uint64_t d =
78         array[i].end_system_time_in_ns - array[i].start_system_time_in_ns;
79     if (min_duration_in_ns > d) {
80       min_duration_in_ns = d;
81       best_index = i;
82     }
83     munmap(array[i].mmap_start_addr, 4096);
84   }
85   thread_arg->mmap_start_addr =
86       reinterpret_cast<uint64_t>(array[best_index].mmap_start_addr);
87   // Perf time is generated at the end of mmap() syscall, which is close to
88   // the end time instead of the start time.
89   thread_arg->system_time_in_ns = array[best_index].end_system_time_in_ns;
90 }
91 
92 static bool GetClockDiff(int64_t* clock_diff_in_ns) {
93   ThreadArg thread_arg;
94   thread_arg.thread_a_tid = 0;
95   thread_arg.start_mmap = false;
96   thread_arg.has_error = false;
97   std::thread thread_a(ThreadA, &thread_arg);
98   while (thread_arg.thread_a_tid == 0) {
99     usleep(1000);
100   }
101   std::unique_ptr<EventTypeAndModifier> event_type =
102       ParseEventType("cpu-clock");
103   if (event_type == nullptr) {
104     return false;
105   }
106   perf_event_attr attr = CreateDefaultPerfEventAttr(event_type->event_type);
107   attr.comm = 0;
108   attr.mmap_data = 1;
109   attr.mmap = 0;
110   attr.inherit = 0;
111   attr.sample_id_all = 1;
112   attr.freq = 0;
113   attr.sample_period = 1ULL << 62;  // Sample records are not needed.
114   std::unique_ptr<EventFd> event_fd =
115       EventFd::OpenEventFile(attr, thread_arg.thread_a_tid, -1, nullptr);
116   if (event_fd == nullptr) {
117     return false;
118   }
119   if (!event_fd->CreateMappedBuffer(4, true)) {
120     return false;
121   }
122 
123   thread_arg.start_mmap = true;
124   thread_a.join();
125 
126   if (thread_arg.has_error) {
127     return false;
128   }
129 
130   std::vector<char> buffer;
131   size_t buffer_pos = 0;
132   size_t size = event_fd->GetAvailableMmapData(buffer, buffer_pos);
133   std::vector<std::unique_ptr<Record>> records =
134       ReadRecordsFromBuffer(attr, buffer.data(), size);
135   uint64_t perf_time_in_ns = 0;
136   for (auto& r : records) {
137     if (r->type() == PERF_RECORD_MMAP) {
138       auto& record = *static_cast<MmapRecord*>(r.get());
139       if (record.data->addr == thread_arg.mmap_start_addr) {
140         perf_time_in_ns = record.Timestamp();
141       }
142     }
143   }
144   if (perf_time_in_ns == 0) {
145     LOG(ERROR) << "GetPerfClockAndSystemClockDiff: can't get perf time.";
146     return false;
147   }
148 
149   *clock_diff_in_ns = perf_time_in_ns - thread_arg.system_time_in_ns;
150   LOG(VERBOSE) << "perf_time is " << perf_time_in_ns << " ns, system_time is "
151                << thread_arg.system_time_in_ns << " ns , clock_diff is "
152                << *clock_diff_in_ns << " ns.";
153   return true;
154 }
155 
156 bool InitPerfClock() {
157   if (!perf_clock_initialized) {
158     if (!GetClockDiff(&perf_clock_and_system_clock_diff_in_ns)) {
159       return false;
160     }
161     perf_clock_initialized = true;
162   }
163   return true;
164 }
165 
166 uint64_t GetPerfClock() {
167   CHECK(perf_clock_initialized);
168   return GetSystemClock() + perf_clock_and_system_clock_diff_in_ns;
169 }
170