simpleperf/event_selection_set.cpp

   1 /*
   2  * Copyright (C) 2015 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 "event_selection_set.h"
  18
  19 #include <poll.h>
  20
  21 #include <android-base/logging.h>
  22 #include <android-base/stringprintf.h>
  23
  24 #include "environment.h"
  25 #include "event_attr.h"
  26 #include "event_type.h"
  27 #include "perf_regs.h"
  28
  29 bool IsBranchSamplingSupported() {
  30   const EventType* type = FindEventTypeByName("cpu-cycles");
  31   if (type == nullptr) {
  32     return false;
  33   }
  34   perf_event_attr attr = CreateDefaultPerfEventAttr(*type);
  35   attr.sample_type |= PERF_SAMPLE_BRANCH_STACK;
  36   attr.branch_sample_type = PERF_SAMPLE_BRANCH_ANY;
  37   return IsEventAttrSupportedByKernel(attr);
  38 }
  39
  40 bool IsDwarfCallChainSamplingSupported() {
  41   const EventType* type = FindEventTypeByName("cpu-cycles");
  42   if (type == nullptr) {
  43     return false;
  44   }
  45   perf_event_attr attr = CreateDefaultPerfEventAttr(*type);
  46   attr.sample_type |= PERF_SAMPLE_CALLCHAIN | PERF_SAMPLE_REGS_USER | PERF_SAMPLE_STACK_USER;
  47   attr.exclude_callchain_user = 1;
  48   attr.sample_regs_user = GetSupportedRegMask(GetBuildArch());
  49   attr.sample_stack_user = 8192;
  50   return IsEventAttrSupportedByKernel(attr);
  51 }
  52
  53 bool EventSelectionSet::AddEventType(const EventTypeAndModifier& event_type_modifier) {
  54   EventSelection selection;
  55   selection.event_type_modifier = event_type_modifier;
  56   selection.event_attr = CreateDefaultPerfEventAttr(event_type_modifier.event_type);
  57   selection.event_attr.exclude_user = event_type_modifier.exclude_user;
  58   selection.event_attr.exclude_kernel = event_type_modifier.exclude_kernel;
  59   selection.event_attr.exclude_hv = event_type_modifier.exclude_hv;
  60   selection.event_attr.exclude_host = event_type_modifier.exclude_host;
  61   selection.event_attr.exclude_guest = event_type_modifier.exclude_guest;
  62   selection.event_attr.precise_ip = event_type_modifier.precise_ip;
  63   if (!IsEventAttrSupportedByKernel(selection.event_attr)) {
  64     LOG(ERROR) << "Event type '" << event_type_modifier.name << "' is not supported by the kernel";
  65     return false;
  66   }
  67   selections_.push_back(std::move(selection));
  68   UnionSampleType();
  69   return true;
  70 }
  71
  72 // Union the sample type of different event attrs can make reading sample records in perf.data
  73 // easier.
  74 void EventSelectionSet::UnionSampleType() {
  75   uint64_t sample_type = 0;
  76   for (auto& selection : selections_) {
  77     sample_type |= selection.event_attr.sample_type;
  78   }
  79   for (auto& selection : selections_) {
  80     selection.event_attr.sample_type = sample_type;
  81   }
  82 }
  83
  84 void EventSelectionSet::SetEnableOnExec(bool enable) {
  85   for (auto& selection : selections_) {
  86     // If sampling is enabled on exec, then it is disabled at startup, otherwise
  87     // it should be enabled at startup. Don't use ioctl(PERF_EVENT_IOC_ENABLE)
  88     // to enable it after perf_event_open(). Because some android kernels can't
  89     // handle ioctl() well when cpu-hotplug happens. See http://b/25193162.
  90     if (enable) {
  91       selection.event_attr.enable_on_exec = 1;
  92       selection.event_attr.disabled = 1;
  93     } else {
  94       selection.event_attr.enable_on_exec = 0;
  95       selection.event_attr.disabled = 0;
  96     }
  97   }
  98 }
  99
 100 bool EventSelectionSet::GetEnableOnExec() {
 101   for (auto& selection : selections_) {
 102     if (selection.event_attr.enable_on_exec == 0) {
 103       return false;
 104     }
 105   }
 106   return true;
 107 }
 108
 109 void EventSelectionSet::SampleIdAll() {
 110   for (auto& selection : selections_) {
 111     selection.event_attr.sample_id_all = 1;
 112   }
 113 }
 114
 115 void EventSelectionSet::SetSampleFreq(uint64_t sample_freq) {
 116   for (auto& selection : selections_) {
 117     perf_event_attr& attr = selection.event_attr;
 118     attr.freq = 1;
 119     attr.sample_freq = sample_freq;
 120   }
 121 }
 122
 123 void EventSelectionSet::SetSamplePeriod(uint64_t sample_period) {
 124   for (auto& selection : selections_) {
 125     perf_event_attr& attr = selection.event_attr;
 126     attr.freq = 0;
 127     attr.sample_period = sample_period;
 128   }
 129 }
 130
 131 bool EventSelectionSet::SetBranchSampling(uint64_t branch_sample_type) {
 132   if (branch_sample_type != 0 &&
 133       (branch_sample_type & (PERF_SAMPLE_BRANCH_ANY | PERF_SAMPLE_BRANCH_ANY_CALL |
 134                              PERF_SAMPLE_BRANCH_ANY_RETURN | PERF_SAMPLE_BRANCH_IND_CALL)) == 0) {
 135     LOG(ERROR) << "Invalid branch_sample_type: 0x" << std::hex << branch_sample_type;
 136     return false;
 137   }
 138   if (branch_sample_type != 0 && !IsBranchSamplingSupported()) {
 139     LOG(ERROR) << "branch stack sampling is not supported on this device.";
 140     return false;
 141   }
 142   for (auto& selection : selections_) {
 143     perf_event_attr& attr = selection.event_attr;
 144     if (branch_sample_type != 0) {
 145       attr.sample_type |= PERF_SAMPLE_BRANCH_STACK;
 146     } else {
 147       attr.sample_type &= ~PERF_SAMPLE_BRANCH_STACK;
 148     }
 149     attr.branch_sample_type = branch_sample_type;
 150   }
 151   return true;
 152 }
 153
 154 void EventSelectionSet::EnableFpCallChainSampling() {
 155   for (auto& selection : selections_) {
 156     selection.event_attr.sample_type |= PERF_SAMPLE_CALLCHAIN;
 157   }
 158 }
 159
 160 bool EventSelectionSet::EnableDwarfCallChainSampling(uint32_t dump_stack_size) {
 161   if (!IsDwarfCallChainSamplingSupported()) {
 162     LOG(ERROR) << "dwarf callchain sampling is not supported on this device.";
 163     return false;
 164   }
 165   for (auto& selection : selections_) {
 166     selection.event_attr.sample_type |=
 167         PERF_SAMPLE_CALLCHAIN | PERF_SAMPLE_REGS_USER | PERF_SAMPLE_STACK_USER;
 168     selection.event_attr.exclude_callchain_user = 1;
 169     selection.event_attr.sample_regs_user = GetSupportedRegMask(GetBuildArch());
 170     selection.event_attr.sample_stack_user = dump_stack_size;
 171   }
 172   return true;
 173 }
 174
 175 void EventSelectionSet::SetInherit(bool enable) {
 176   for (auto& selection : selections_) {
 177     selection.event_attr.inherit = (enable ? 1 : 0);
 178   }
 179 }
 180
 181 static bool CheckIfCpusOnline(const std::vector<int>& cpus) {
 182   std::vector<int> online_cpus = GetOnlineCpus();
 183   for (const auto& cpu : cpus) {
 184     if (std::find(online_cpus.begin(), online_cpus.end(), cpu) == online_cpus.end()) {
 185       LOG(ERROR) << "cpu " << cpu << " is not online.";
 186       return false;
 187     }
 188   }
 189   return true;
 190 }
 191
 192 bool EventSelectionSet::OpenEventFilesForCpus(const std::vector<int>& cpus) {
 193   return OpenEventFilesForThreadsOnCpus({-1}, cpus);
 194 }
 195
 196 bool EventSelectionSet::OpenEventFilesForThreadsOnCpus(const std::vector<pid_t>& threads,
 197                                                        std::vector<int> cpus) {
 198   if (!cpus.empty()) {
 199     if (!CheckIfCpusOnline(cpus)) {
 200       return false;
 201     }
 202   } else {
 203     cpus = GetOnlineCpus();
 204   }
 205   return OpenEventFiles(threads, cpus);
 206 }
 207
 208 bool EventSelectionSet::OpenEventFiles(const std::vector<pid_t>& threads,
 209                                        const std::vector<int>& cpus) {
 210   for (auto& selection : selections_) {
 211     for (auto& tid : threads) {
 212       size_t open_per_thread = 0;
 213       for (auto& cpu : cpus) {
 214         auto event_fd = EventFd::OpenEventFile(selection.event_attr, tid, cpu);
 215         if (event_fd != nullptr) {
 216           LOG(VERBOSE) << "OpenEventFile for tid " << tid << ", cpu " << cpu;
 217           selection.event_fds.push_back(std::move(event_fd));
 218           ++open_per_thread;
 219         }
 220       }
 221       // As the online cpus can be enabled or disabled at runtime, we may not open event file for
 222       // all cpus successfully. But we should open at least one cpu successfully.
 223       if (open_per_thread == 0) {
 224         PLOG(ERROR) << "failed to open perf event file for event_type "
 225                     << selection.event_type_modifier.name << " for "
 226                     << (tid == -1 ? "all threads" : android::base::StringPrintf(" thread %d", tid));
 227         return false;
 228       }
 229     }
 230   }
 231   return true;
 232 }
 233
 234 bool EventSelectionSet::ReadCounters(std::vector<CountersInfo>* counters) {
 235   counters->clear();
 236   for (auto& selection : selections_) {
 237     CountersInfo counters_info;
 238     counters_info.event_type = &selection.event_type_modifier;
 239     for (auto& event_fd : selection.event_fds) {
 240       CountersInfo::CounterInfo counter_info;
 241       if (!event_fd->ReadCounter(&counter_info.counter)) {
 242         return false;
 243       }
 244       counter_info.tid = event_fd->ThreadId();
 245       counter_info.cpu = event_fd->Cpu();
 246       counters_info.counters.push_back(counter_info);
 247     }
 248     counters->push_back(counters_info);
 249   }
 250   return true;
 251 }
 252
 253 void EventSelectionSet::PreparePollForEventFiles(std::vector<pollfd>* pollfds) {
 254   for (auto& selection : selections_) {
 255     for (auto& event_fd : selection.event_fds) {
 256       pollfd poll_fd;
 257       event_fd->PreparePollForMmapData(&poll_fd);
 258       pollfds->push_back(poll_fd);
 259     }
 260   }
 261 }
 262
 263 bool EventSelectionSet::MmapEventFiles(size_t mmap_pages) {
 264   for (auto& selection : selections_) {
 265     for (auto& event_fd : selection.event_fds) {
 266       if (!event_fd->MmapContent(mmap_pages)) {
 267         return false;
 268       }
 269     }
 270   }
 271   return true;
 272 }
 273
 274 static bool ReadMmapEventDataForFd(std::unique_ptr<EventFd>& event_fd,
 275                                    std::function<bool(const char*, size_t)> callback,
 276                                    bool* have_data) {
 277   *have_data = false;
 278   while (true) {
 279     char* data;
 280     size_t size = event_fd->GetAvailableMmapData(&data);
 281     if (size == 0) {
 282       break;
 283     }
 284     if (!callback(data, size)) {
 285       return false;
 286     }
 287     *have_data = true;
 288   }
 289   return true;
 290 }
 291
 292 bool EventSelectionSet::ReadMmapEventData(std::function<bool(const char*, size_t)> callback) {
 293   for (auto& selection : selections_) {
 294     for (auto& event_fd : selection.event_fds) {
 295       while (true) {
 296         bool have_data;
 297         if (!ReadMmapEventDataForFd(event_fd, callback, &have_data)) {
 298           return false;
 299         }
 300         if (!have_data) {
 301           break;
 302         }
 303       }
 304     }
 305   }
 306   return true;
 307 }
 308
 309 EventSelectionSet::EventSelection* EventSelectionSet::FindSelectionByType(
 310     const EventTypeAndModifier& event_type_modifier) {
 311   for (auto& selection : selections_) {
 312     if (selection.event_type_modifier.name == event_type_modifier.name) {
 313       return &selection;
 314     }
 315   }
 316   return nullptr;
 317 }
 318
 319 const perf_event_attr* EventSelectionSet::FindEventAttrByType(
 320     const EventTypeAndModifier& event_type_modifier) {
 321   EventSelection* selection = FindSelectionByType(event_type_modifier);
 322   return (selection != nullptr) ? &selection->event_attr : nullptr;
 323 }
 324
 325 const std::vector<std::unique_ptr<EventFd>>* EventSelectionSet::FindEventFdsByType(
 326     const EventTypeAndModifier& event_type_modifier) {
 327   EventSelection* selection = FindSelectionByType(event_type_modifier);
 328   return (selection != nullptr) ? &selection->event_fds : nullptr;
 329 }