1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Convert sample address to data type using DWARF debug info. 4 * 5 * Written by Namhyung Kim <namhyung@kernel.org> 6 */ 7 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <inttypes.h> 11 12 #include "annotate-data.h" 13 #include "debuginfo.h" 14 #include "debug.h" 15 #include "dso.h" 16 #include "evsel.h" 17 #include "evlist.h" 18 #include "map.h" 19 #include "map_symbol.h" 20 #include "strbuf.h" 21 #include "symbol.h" 22 #include "symbol_conf.h" 23 24 /* 25 * Compare type name and size to maintain them in a tree. 26 * I'm not sure if DWARF would have information of a single type in many 27 * different places (compilation units). If not, it could compare the 28 * offset of the type entry in the .debug_info section. 29 */ 30 static int data_type_cmp(const void *_key, const struct rb_node *node) 31 { 32 const struct annotated_data_type *key = _key; 33 struct annotated_data_type *type; 34 35 type = rb_entry(node, struct annotated_data_type, node); 36 37 if (key->self.size != type->self.size) 38 return key->self.size - type->self.size; 39 return strcmp(key->self.type_name, type->self.type_name); 40 } 41 42 static bool data_type_less(struct rb_node *node_a, const struct rb_node *node_b) 43 { 44 struct annotated_data_type *a, *b; 45 46 a = rb_entry(node_a, struct annotated_data_type, node); 47 b = rb_entry(node_b, struct annotated_data_type, node); 48 49 if (a->self.size != b->self.size) 50 return a->self.size < b->self.size; 51 return strcmp(a->self.type_name, b->self.type_name) < 0; 52 } 53 54 /* Recursively add new members for struct/union */ 55 static int __add_member_cb(Dwarf_Die *die, void *arg) 56 { 57 struct annotated_member *parent = arg; 58 struct annotated_member *member; 59 Dwarf_Die member_type, die_mem; 60 Dwarf_Word size, loc; 61 Dwarf_Attribute attr; 62 struct strbuf sb; 63 int tag; 64 65 if (dwarf_tag(die) != DW_TAG_member) 66 return DIE_FIND_CB_SIBLING; 67 68 member = zalloc(sizeof(*member)); 69 if (member == NULL) 70 return DIE_FIND_CB_END; 71 72 strbuf_init(&sb, 32); 73 die_get_typename(die, &sb); 74 75 die_get_real_type(die, &member_type); 76 if (dwarf_aggregate_size(&member_type, &size) < 0) 77 size = 0; 78 79 if (!dwarf_attr_integrate(die, DW_AT_data_member_location, &attr)) 80 loc = 0; 81 else 82 dwarf_formudata(&attr, &loc); 83 84 member->type_name = strbuf_detach(&sb, NULL); 85 /* member->var_name can be NULL */ 86 if (dwarf_diename(die)) 87 member->var_name = strdup(dwarf_diename(die)); 88 member->size = size; 89 member->offset = loc + parent->offset; 90 INIT_LIST_HEAD(&member->children); 91 list_add_tail(&member->node, &parent->children); 92 93 tag = dwarf_tag(&member_type); 94 switch (tag) { 95 case DW_TAG_structure_type: 96 case DW_TAG_union_type: 97 die_find_child(&member_type, __add_member_cb, member, &die_mem); 98 break; 99 default: 100 break; 101 } 102 return DIE_FIND_CB_SIBLING; 103 } 104 105 static void add_member_types(struct annotated_data_type *parent, Dwarf_Die *type) 106 { 107 Dwarf_Die die_mem; 108 109 die_find_child(type, __add_member_cb, &parent->self, &die_mem); 110 } 111 112 static void delete_members(struct annotated_member *member) 113 { 114 struct annotated_member *child, *tmp; 115 116 list_for_each_entry_safe(child, tmp, &member->children, node) { 117 list_del(&child->node); 118 delete_members(child); 119 free(child->type_name); 120 free(child->var_name); 121 free(child); 122 } 123 } 124 125 static struct annotated_data_type *dso__findnew_data_type(struct dso *dso, 126 Dwarf_Die *type_die) 127 { 128 struct annotated_data_type *result = NULL; 129 struct annotated_data_type key; 130 struct rb_node *node; 131 struct strbuf sb; 132 char *type_name; 133 Dwarf_Word size; 134 135 strbuf_init(&sb, 32); 136 if (die_get_typename_from_type(type_die, &sb) < 0) 137 strbuf_add(&sb, "(unknown type)", 14); 138 type_name = strbuf_detach(&sb, NULL); 139 dwarf_aggregate_size(type_die, &size); 140 141 /* Check existing nodes in dso->data_types tree */ 142 key.self.type_name = type_name; 143 key.self.size = size; 144 node = rb_find(&key, &dso->data_types, data_type_cmp); 145 if (node) { 146 result = rb_entry(node, struct annotated_data_type, node); 147 free(type_name); 148 return result; 149 } 150 151 /* If not, add a new one */ 152 result = zalloc(sizeof(*result)); 153 if (result == NULL) { 154 free(type_name); 155 return NULL; 156 } 157 158 result->self.type_name = type_name; 159 result->self.size = size; 160 INIT_LIST_HEAD(&result->self.children); 161 162 if (symbol_conf.annotate_data_member) 163 add_member_types(result, type_die); 164 165 rb_add(&result->node, &dso->data_types, data_type_less); 166 return result; 167 } 168 169 static bool find_cu_die(struct debuginfo *di, u64 pc, Dwarf_Die *cu_die) 170 { 171 Dwarf_Off off, next_off; 172 size_t header_size; 173 174 if (dwarf_addrdie(di->dbg, pc, cu_die) != NULL) 175 return cu_die; 176 177 /* 178 * There are some kernels don't have full aranges and contain only a few 179 * aranges entries. Fallback to iterate all CU entries in .debug_info 180 * in case it's missing. 181 */ 182 off = 0; 183 while (dwarf_nextcu(di->dbg, off, &next_off, &header_size, 184 NULL, NULL, NULL) == 0) { 185 if (dwarf_offdie(di->dbg, off + header_size, cu_die) && 186 dwarf_haspc(cu_die, pc)) 187 return true; 188 189 off = next_off; 190 } 191 return false; 192 } 193 194 /* The type info will be saved in @type_die */ 195 static int check_variable(Dwarf_Die *var_die, Dwarf_Die *type_die, int offset) 196 { 197 Dwarf_Word size; 198 199 /* Get the type of the variable */ 200 if (die_get_real_type(var_die, type_die) == NULL) { 201 pr_debug("variable has no type\n"); 202 ann_data_stat.no_typeinfo++; 203 return -1; 204 } 205 206 /* 207 * It expects a pointer type for a memory access. 208 * Convert to a real type it points to. 209 */ 210 if (dwarf_tag(type_die) != DW_TAG_pointer_type || 211 die_get_real_type(type_die, type_die) == NULL) { 212 pr_debug("no pointer or no type\n"); 213 ann_data_stat.no_typeinfo++; 214 return -1; 215 } 216 217 /* Get the size of the actual type */ 218 if (dwarf_aggregate_size(type_die, &size) < 0) { 219 pr_debug("type size is unknown\n"); 220 ann_data_stat.invalid_size++; 221 return -1; 222 } 223 224 /* Minimal sanity check */ 225 if ((unsigned)offset >= size) { 226 pr_debug("offset: %d is bigger than size: %" PRIu64 "\n", offset, size); 227 ann_data_stat.bad_offset++; 228 return -1; 229 } 230 231 return 0; 232 } 233 234 /* The result will be saved in @type_die */ 235 static int find_data_type_die(struct debuginfo *di, u64 pc, 236 int reg, int offset, Dwarf_Die *type_die) 237 { 238 Dwarf_Die cu_die, var_die; 239 Dwarf_Die *scopes = NULL; 240 int ret = -1; 241 int i, nr_scopes; 242 243 /* Get a compile_unit for this address */ 244 if (!find_cu_die(di, pc, &cu_die)) { 245 pr_debug("cannot find CU for address %" PRIx64 "\n", pc); 246 ann_data_stat.no_cuinfo++; 247 return -1; 248 } 249 250 /* Get a list of nested scopes - i.e. (inlined) functions and blocks. */ 251 nr_scopes = die_get_scopes(&cu_die, pc, &scopes); 252 253 /* Search from the inner-most scope to the outer */ 254 for (i = nr_scopes - 1; i >= 0; i--) { 255 /* Look up variables/parameters in this scope */ 256 if (!die_find_variable_by_reg(&scopes[i], pc, reg, &var_die)) 257 continue; 258 259 /* Found a variable, see if it's correct */ 260 ret = check_variable(&var_die, type_die, offset); 261 goto out; 262 } 263 if (ret < 0) 264 ann_data_stat.no_var++; 265 266 out: 267 free(scopes); 268 return ret; 269 } 270 271 /** 272 * find_data_type - Return a data type at the location 273 * @ms: map and symbol at the location 274 * @ip: instruction address of the memory access 275 * @reg: register that holds the base address 276 * @offset: offset from the base address 277 * 278 * This functions searches the debug information of the binary to get the data 279 * type it accesses. The exact location is expressed by (ip, reg, offset). 280 * It return %NULL if not found. 281 */ 282 struct annotated_data_type *find_data_type(struct map_symbol *ms, u64 ip, 283 int reg, int offset) 284 { 285 struct annotated_data_type *result = NULL; 286 struct dso *dso = map__dso(ms->map); 287 struct debuginfo *di; 288 Dwarf_Die type_die; 289 u64 pc; 290 291 di = debuginfo__new(dso->long_name); 292 if (di == NULL) { 293 pr_debug("cannot get the debug info\n"); 294 return NULL; 295 } 296 297 /* 298 * IP is a relative instruction address from the start of the map, as 299 * it can be randomized/relocated, it needs to translate to PC which is 300 * a file address for DWARF processing. 301 */ 302 pc = map__rip_2objdump(ms->map, ip); 303 if (find_data_type_die(di, pc, reg, offset, &type_die) < 0) 304 goto out; 305 306 result = dso__findnew_data_type(dso, &type_die); 307 308 out: 309 debuginfo__delete(di); 310 return result; 311 } 312 313 static int alloc_data_type_histograms(struct annotated_data_type *adt, int nr_entries) 314 { 315 int i; 316 size_t sz = sizeof(struct type_hist); 317 318 sz += sizeof(struct type_hist_entry) * adt->self.size; 319 320 /* Allocate a table of pointers for each event */ 321 adt->nr_histograms = nr_entries; 322 adt->histograms = calloc(nr_entries, sizeof(*adt->histograms)); 323 if (adt->histograms == NULL) 324 return -ENOMEM; 325 326 /* 327 * Each histogram is allocated for the whole size of the type. 328 * TODO: Probably we can move the histogram to members. 329 */ 330 for (i = 0; i < nr_entries; i++) { 331 adt->histograms[i] = zalloc(sz); 332 if (adt->histograms[i] == NULL) 333 goto err; 334 } 335 return 0; 336 337 err: 338 while (--i >= 0) 339 free(adt->histograms[i]); 340 free(adt->histograms); 341 return -ENOMEM; 342 } 343 344 static void delete_data_type_histograms(struct annotated_data_type *adt) 345 { 346 for (int i = 0; i < adt->nr_histograms; i++) 347 free(adt->histograms[i]); 348 free(adt->histograms); 349 } 350 351 void annotated_data_type__tree_delete(struct rb_root *root) 352 { 353 struct annotated_data_type *pos; 354 355 while (!RB_EMPTY_ROOT(root)) { 356 struct rb_node *node = rb_first(root); 357 358 rb_erase(node, root); 359 pos = rb_entry(node, struct annotated_data_type, node); 360 delete_members(&pos->self); 361 delete_data_type_histograms(pos); 362 free(pos->self.type_name); 363 free(pos); 364 } 365 } 366 367 /** 368 * annotated_data_type__update_samples - Update histogram 369 * @adt: Data type to update 370 * @evsel: Event to update 371 * @offset: Offset in the type 372 * @nr_samples: Number of samples at this offset 373 * @period: Event count at this offset 374 * 375 * This function updates type histogram at @ofs for @evsel. Samples are 376 * aggregated before calling this function so it can be called with more 377 * than one samples at a certain offset. 378 */ 379 int annotated_data_type__update_samples(struct annotated_data_type *adt, 380 struct evsel *evsel, int offset, 381 int nr_samples, u64 period) 382 { 383 struct type_hist *h; 384 385 if (adt == NULL) 386 return 0; 387 388 if (adt->histograms == NULL) { 389 int nr = evsel->evlist->core.nr_entries; 390 391 if (alloc_data_type_histograms(adt, nr) < 0) 392 return -1; 393 } 394 395 if (offset < 0 || offset >= adt->self.size) 396 return -1; 397 398 h = adt->histograms[evsel->core.idx]; 399 400 h->nr_samples += nr_samples; 401 h->addr[offset].nr_samples += nr_samples; 402 h->period += period; 403 h->addr[offset].period += period; 404 return 0; 405 } 406