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_attr.h" 18 19 #include <inttypes.h> 20 #include <stdio.h> 21 #include <string> 22 #include <unordered_map> 23 24 #include <android-base/logging.h> 25 26 #include "environment.h" 27 #include "event_type.h" 28 #include "utils.h" 29 30 static std::string BitsToString(const std::string& name, uint64_t bits, 31 const std::vector<std::pair<int, std::string>>& bit_names) { 32 std::string result; 33 for (auto& p : bit_names) { 34 if (bits & p.first) { 35 bits &= ~p.first; 36 if (!result.empty()) { 37 result += ", "; 38 } 39 result += p.second; 40 } 41 } 42 if (bits != 0) { 43 LOG(DEBUG) << "unknown " << name << " bits: " << std::hex << bits; 44 } 45 return result; 46 } 47 48 static std::string SampleTypeToString(uint64_t sample_type) { 49 static std::vector<std::pair<int, std::string>> sample_type_names = { 50 {PERF_SAMPLE_ADDR, "addr"}, 51 {PERF_SAMPLE_BRANCH_STACK, "branch_stack"}, 52 {PERF_SAMPLE_CALLCHAIN, "callchain"}, 53 {PERF_SAMPLE_CPU, "cpu"}, 54 {PERF_SAMPLE_ID, "id"}, 55 {PERF_SAMPLE_IP, "ip"}, 56 {PERF_SAMPLE_PERIOD, "period"}, 57 {PERF_SAMPLE_RAW, "raw"}, 58 {PERF_SAMPLE_READ, "read"}, 59 {PERF_SAMPLE_REGS_USER, "regs_user"}, 60 {PERF_SAMPLE_STACK_USER, "stack_user"}, 61 {PERF_SAMPLE_STREAM_ID, "stream_id"}, 62 {PERF_SAMPLE_TID, "tid"}, 63 {PERF_SAMPLE_TIME, "time"}, 64 }; 65 return BitsToString("sample_type", sample_type, sample_type_names); 66 } 67 68 static std::string ReadFormatToString(uint64_t read_format) { 69 static std::vector<std::pair<int, std::string>> read_format_names = { 70 {PERF_FORMAT_TOTAL_TIME_ENABLED, "total_time_enabled"}, 71 {PERF_FORMAT_TOTAL_TIME_RUNNING, "total_time_running"}, 72 {PERF_FORMAT_ID, "id"}, 73 {PERF_FORMAT_GROUP, "group"}, 74 }; 75 return BitsToString("read_format", read_format, read_format_names); 76 } 77 78 perf_event_attr CreateDefaultPerfEventAttr(const EventType& event_type) { 79 perf_event_attr attr; 80 memset(&attr, 0, sizeof(attr)); 81 attr.size = sizeof(perf_event_attr); 82 attr.type = event_type.type; 83 attr.config = event_type.config; 84 attr.disabled = 0; 85 // Changing read_format affects the layout of the data read from perf_event_file, namely 86 // PerfCounter in event_fd.h. 87 attr.read_format = 88 PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING | PERF_FORMAT_ID; 89 attr.sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_TIME | PERF_SAMPLE_PERIOD | 90 PERF_SAMPLE_CPU | PERF_SAMPLE_ID; 91 92 if (attr.type == PERF_TYPE_TRACEPOINT) { 93 // Tracepoint information are stored in raw data in sample records. 94 if (CanRecordRawData()) { 95 attr.sample_type |= PERF_SAMPLE_RAW; 96 } 97 } 98 return attr; 99 } 100 101 void DumpPerfEventAttr(const perf_event_attr& attr, size_t indent) { 102 std::string event_name = GetEventNameByAttr(attr); 103 PrintIndented(indent, "event_attr: for event type %s\n", event_name.c_str()); 104 105 PrintIndented(indent + 1, "type %u, size %u, config %llu\n", attr.type, attr.size, attr.config); 106 107 if (attr.freq != 0) { 108 PrintIndented(indent + 1, "sample_freq %llu\n", attr.sample_freq); 109 } else { 110 PrintIndented(indent + 1, "sample_period %llu\n", attr.sample_period); 111 } 112 113 PrintIndented(indent + 1, "sample_type (0x%llx) %s\n", attr.sample_type, 114 SampleTypeToString(attr.sample_type).c_str()); 115 116 PrintIndented(indent + 1, "read_format (0x%llx) %s\n", attr.read_format, 117 ReadFormatToString(attr.read_format).c_str()); 118 119 PrintIndented(indent + 1, "disabled %u, inherit %u, pinned %u, exclusive %u\n", attr.disabled, 120 attr.inherit, attr.pinned, attr.exclusive); 121 122 PrintIndented(indent + 1, "exclude_user %u, exclude_kernel %u, exclude_hv %u\n", 123 attr.exclude_user, attr.exclude_kernel, attr.exclude_hv); 124 125 PrintIndented(indent + 1, "exclude_idle %u, mmap %u, mmap2 %u, comm %u, freq %u\n", 126 attr.exclude_idle, attr.mmap, attr.mmap2, attr.comm, attr.freq); 127 128 PrintIndented(indent + 1, "inherit_stat %u, enable_on_exec %u, task %u\n", attr.inherit_stat, 129 attr.enable_on_exec, attr.task); 130 131 PrintIndented(indent + 1, "watermark %u, precise_ip %u, mmap_data %u\n", attr.watermark, 132 attr.precise_ip, attr.mmap_data); 133 134 PrintIndented(indent + 1, "sample_id_all %u, exclude_host %u, exclude_guest %u\n", 135 attr.sample_id_all, attr.exclude_host, attr.exclude_guest); 136 PrintIndented(indent + 1, "config2 0x%llx\n", attr.config2); 137 PrintIndented(indent + 1, "branch_sample_type 0x%" PRIx64 "\n", attr.branch_sample_type); 138 PrintIndented(indent + 1, "exclude_callchain_kernel %u, exclude_callchain_user %u\n", 139 attr.exclude_callchain_kernel, attr.exclude_callchain_user); 140 PrintIndented(indent + 1, "sample_regs_user 0x%" PRIx64 "\n", attr.sample_regs_user); 141 PrintIndented(indent + 1, "sample_stack_user 0x%" PRIx64 "\n", attr.sample_stack_user); 142 } 143 144 bool GetCommonEventIdPositionsForAttrs(std::vector<perf_event_attr>& attrs, 145 size_t* event_id_pos_in_sample_records, 146 size_t* event_id_reverse_pos_in_non_sample_records) { 147 // When there are more than one perf_event_attrs, we need to read event id 148 // in each record to decide current record should use which attr. So 149 // we need to determine the event id position in a record here. 150 std::vector<uint64_t> sample_types; 151 for (const auto& attr : attrs) { 152 sample_types.push_back(attr.sample_type); 153 } 154 // First determine event_id_pos_in_sample_records. 155 // If PERF_SAMPLE_IDENTIFIER is enabled, it is just after perf_event_header. 156 // If PERF_SAMPLE_ID is enabled, then PERF_SAMPLE_IDENTIFIER | IP | TID | TIME | ADDR 157 // should also be the same. 158 bool identifier_enabled = true; 159 bool id_enabled = true; 160 uint64_t flags_before_id_mask = PERF_SAMPLE_IDENTIFIER | PERF_SAMPLE_IP | PERF_SAMPLE_TID | 161 PERF_SAMPLE_TIME | PERF_SAMPLE_ADDR; 162 uint64_t flags_before_id = sample_types[0] & flags_before_id_mask; 163 bool flags_before_id_are_the_same = true; 164 for (auto type : sample_types) { 165 identifier_enabled &= (type & PERF_SAMPLE_IDENTIFIER) != 0; 166 id_enabled &= (type & PERF_SAMPLE_ID) != 0; 167 flags_before_id_are_the_same &= (type & flags_before_id_mask) == flags_before_id; 168 } 169 if (identifier_enabled) { 170 *event_id_pos_in_sample_records = sizeof(perf_event_header); 171 } else if (id_enabled && flags_before_id_are_the_same) { 172 uint64_t pos = sizeof(perf_event_header); 173 while (flags_before_id != 0) { 174 // Each flags takes 8 bytes in sample records. 175 flags_before_id &= flags_before_id - 1; 176 pos += 8; 177 } 178 *event_id_pos_in_sample_records = pos; 179 } else { 180 LOG(ERROR) << "perf_event_attrs don't have a common event id position in sample records"; 181 return false; 182 } 183 184 // Secondly determine event_id_reverse_pos_in_non_sample_record. 185 // If sample_id_all is not enabled, there is no event id in non sample records. 186 // If PERF_SAMPLE_IDENTIFIER is enabled, it is at the last 8 bytes of the record. 187 // If PERF_SAMPLE_ID is enabled, then PERF_SAMPLE_IDENTIFIER | CPU | STREAM_ID should 188 // also be the same. 189 bool sample_id_all_enabled = true; 190 for (const auto& attr : attrs) { 191 if (attr.sample_id_all == 0) { 192 sample_id_all_enabled = false; 193 } 194 } 195 if (!sample_id_all_enabled) { 196 LOG(ERROR) << "there are perf_event_attrs not enabling sample_id_all, so can't determine " 197 << "perf_event_attr for non sample records"; 198 return false; 199 } 200 uint64_t flags_after_id_mask = PERF_SAMPLE_IDENTIFIER | PERF_SAMPLE_CPU | PERF_SAMPLE_STREAM_ID; 201 uint64_t flags_after_id = sample_types[0] & flags_after_id_mask; 202 bool flags_after_id_are_the_same = true; 203 for (auto type : sample_types) { 204 flags_after_id_are_the_same &= (type & flags_after_id_mask) == flags_after_id; 205 } 206 if (identifier_enabled) { 207 *event_id_reverse_pos_in_non_sample_records = 8; 208 } else if (id_enabled && flags_after_id_are_the_same) { 209 uint64_t pos = 8; 210 while (flags_after_id != 0) { 211 // Each flag takes 8 bytes in sample_id of non sample records. 212 flags_after_id &= flags_after_id - 1; 213 pos += 8; 214 } 215 *event_id_reverse_pos_in_non_sample_records = pos; 216 } else { 217 LOG(ERROR) << "perf_event_attrs don't have a common event id reverse position in non sample records"; 218 return false; 219 } 220 return true; 221 } 222 223 bool IsTimestampSupported(const perf_event_attr& attr) { 224 return attr.sample_id_all && (attr.sample_type & PERF_SAMPLE_TIME); 225 } 226 227 bool IsCpuSupported(const perf_event_attr& attr) { 228 return attr.sample_id_all && (attr.sample_type & PERF_SAMPLE_CPU); 229 } 230 231 std::string GetEventNameByAttr(const perf_event_attr& attr) { 232 for (const auto& event_type : GetAllEventTypes()) { 233 // An event type uses both type and config value to define itself. But etm event type 234 // only uses type value (whose config value is used to set etm options). 235 if (event_type.type == attr.type && 236 (event_type.config == attr.config || IsEtmEventType(event_type.type))) { 237 std::string name = event_type.name; 238 if (attr.exclude_user && !attr.exclude_kernel) { 239 name += ":k"; 240 } else if (attr.exclude_kernel && !attr.exclude_user) { 241 name += ":u"; 242 } 243 return name; 244 } 245 } 246 return "unknown"; 247 } 248