Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

perf map: Add set_ methods for map->{start,end,pgoff,pgoff,reloc,erange_warned,dso,map_ip,unmap_ip,priv}

To have a way to intercept usage of the reference counted struct map.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

+132 -65
+2 -2
tools/perf/builtin-top.c
··· 191 191 if (use_browser <= 0) 192 192 sleep(5); 193 193 194 - map->erange_warned = true; 194 + map__set_erange_warned(map, true); 195 195 } 196 196 197 197 static void perf_top__record_precise_ip(struct perf_top *top, ··· 225 225 */ 226 226 mutex_unlock(&he->hists->lock); 227 227 228 - if (err == -ERANGE && !he->ms.map->erange_warned) 228 + if (err == -ERANGE && !map__erange_warned(he->ms.map)) 229 229 ui__warn_map_erange(he->ms.map, sym, ip); 230 230 else if (err == -ENOMEM) { 231 231 pr_err("Not enough memory for annotating '%s' symbol!\n",
+8 -8
tools/perf/tests/maps.c
··· 95 95 map = dso__new_map(bpf_progs[i].name); 96 96 TEST_ASSERT_VAL("failed to create map", map); 97 97 98 - map->start = bpf_progs[i].start; 99 - map->end = bpf_progs[i].end; 98 + map__set_start(map, bpf_progs[i].start); 99 + map__set_end(map, bpf_progs[i].end); 100 100 TEST_ASSERT_VAL("failed to insert map", maps__insert(maps, map) == 0); 101 101 map__put(map); 102 102 } ··· 111 111 TEST_ASSERT_VAL("failed to create map", map_kcore3); 112 112 113 113 /* kcore1 map overlaps over all bpf maps */ 114 - map_kcore1->start = 100; 115 - map_kcore1->end = 1000; 114 + map__set_start(map_kcore1, 100); 115 + map__set_end(map_kcore1, 1000); 116 116 117 117 /* kcore2 map hides behind bpf_prog_2 */ 118 - map_kcore2->start = 550; 119 - map_kcore2->end = 570; 118 + map__set_start(map_kcore2, 550); 119 + map__set_end(map_kcore2, 570); 120 120 121 121 /* kcore3 map hides behind bpf_prog_3, kcore1 and adds new map */ 122 - map_kcore3->start = 880; 123 - map_kcore3->end = 1100; 122 + map__set_start(map_kcore3, 880); 123 + map__set_end(map_kcore3, 1100); 124 124 125 125 ret = maps__merge_in(maps, map_kcore1); 126 126 TEST_ASSERT_VAL("failed to merge map", !ret);
+2 -2
tools/perf/tests/vmlinux-kallsyms.c
··· 304 304 dso->short_name : 305 305 dso->name)); 306 306 if (pair) { 307 - pair->priv = 1; 307 + map__set_priv(pair, 1); 308 308 } else { 309 309 if (!header_printed) { 310 310 pr_info("WARN: Maps only in vmlinux:\n"); ··· 340 340 pr_info(":\nWARN: *%" PRIx64 "-%" PRIx64 " %" PRIx64, 341 341 map__start(pair), map__end(pair), map__pgoff(pair)); 342 342 pr_info(" %s\n", dso->name); 343 - pair->priv = 1; 343 + map__set_priv(pair, 1); 344 344 } 345 345 } 346 346
+12 -11
tools/perf/util/machine.c
··· 910 910 dso__set_loaded(dso); 911 911 } 912 912 913 - map->start = event->ksymbol.addr; 914 - map->end = map__start(map) + event->ksymbol.len; 913 + map__set_start(map, event->ksymbol.addr); 914 + map__set_end(map, map__start(map) + event->ksymbol.len); 915 915 err = maps__insert(machine__kernel_maps(machine), map); 916 916 if (err) { 917 917 err = -ENOMEM; ··· 1218 1218 if (!map) 1219 1219 return -ENOMEM; 1220 1220 1221 - map->end = xm->end; 1222 - map->pgoff = xm->pgoff; 1221 + map__set_end(map, xm->end); 1222 + map__set_pgoff(map, xm->pgoff); 1223 1223 1224 1224 kmap = map__kmap(map); 1225 1225 ··· 1291 1291 1292 1292 dest_map = maps__find(kmaps, map__pgoff(map)); 1293 1293 if (dest_map != map) 1294 - map->pgoff = map__map_ip(dest_map, map__pgoff(map)); 1294 + map__set_pgoff(map, map__map_ip(dest_map, map__pgoff(map))); 1295 1295 found = true; 1296 1296 } 1297 1297 if (found || machine->trampolines_mapped) ··· 1342 1342 if (machine->vmlinux_map == NULL) 1343 1343 return -ENOMEM; 1344 1344 1345 - machine->vmlinux_map->map_ip = machine->vmlinux_map->unmap_ip = identity__map_ip; 1345 + map__set_map_ip(machine->vmlinux_map, identity__map_ip); 1346 + map__set_unmap_ip(machine->vmlinux_map, identity__map_ip); 1346 1347 return maps__insert(machine__kernel_maps(machine), machine->vmlinux_map); 1347 1348 } 1348 1349 ··· 1624 1623 map = machine__addnew_module_map(machine, start, name); 1625 1624 if (map == NULL) 1626 1625 return -1; 1627 - map->end = start + size; 1626 + map__set_end(map, start + size); 1628 1627 1629 1628 dso__kernel_module_get_build_id(map__dso(map), machine->root_dir); 1630 1629 map__put(map); ··· 1660 1659 static void machine__set_kernel_mmap(struct machine *machine, 1661 1660 u64 start, u64 end) 1662 1661 { 1663 - machine->vmlinux_map->start = start; 1664 - machine->vmlinux_map->end = end; 1662 + map__set_start(machine->vmlinux_map, start); 1663 + map__set_end(machine->vmlinux_map, end); 1665 1664 /* 1666 1665 * Be a bit paranoid here, some perf.data file came with 1667 1666 * a zero sized synthesized MMAP event for the kernel. 1668 1667 */ 1669 1668 if (start == 0 && end == 0) 1670 - machine->vmlinux_map->end = ~0ULL; 1669 + map__set_end(machine->vmlinux_map, ~0ULL); 1671 1670 } 1672 1671 1673 1672 static int machine__update_kernel_mmap(struct machine *machine, ··· 1811 1810 if (map == NULL) 1812 1811 goto out_problem; 1813 1812 1814 - map->end = map__start(map) + xm->end - xm->start; 1813 + map__set_end(map, map__start(map) + xm->end - xm->start); 1815 1814 1816 1815 if (build_id__is_defined(bid)) 1817 1816 dso__set_build_id(map__dso(map), bid);
+10 -10
tools/perf/util/map.c
··· 104 104 105 105 void map__init(struct map *map, u64 start, u64 end, u64 pgoff, struct dso *dso) 106 106 { 107 - map->start = start; 108 - map->end = end; 109 - map->pgoff = pgoff; 110 - map->reloc = 0; 111 - map->dso = dso__get(dso); 112 - map->map_ip = map__dso_map_ip; 113 - map->unmap_ip = map__dso_unmap_ip; 114 - map->erange_warned = false; 107 + map__set_start(map, start); 108 + map__set_end(map, end); 109 + map__set_pgoff(map, pgoff); 110 + map__set_reloc(map, 0); 111 + map__set_dso(map, dso__get(dso)); 112 + map__set_map_ip(map, map__dso_map_ip); 113 + map__set_unmap_ip(map, map__dso_unmap_ip); 114 + map__set_erange_warned(map, false); 115 115 refcount_set(map__refcnt(map), 1); 116 116 } 117 117 ··· 317 317 if (nd != NULL) { 318 318 struct symbol *sym = rb_entry(nd, struct symbol, rb_node); 319 319 320 - map->start = sym->start; 320 + map__set_start(map, sym->start); 321 321 } 322 322 } 323 323 ··· 329 329 330 330 if (nd != NULL) { 331 331 struct symbol *sym = rb_entry(nd, struct symbol, rb_node); 332 - map->end = sym->end; 332 + map__set_end(map, sym->end); 333 333 } 334 334 } 335 335
+65
tools/perf/util/map.h
··· 62 62 return map->unmap_ip(map, ip); 63 63 } 64 64 65 + static inline void *map__map_ip_ptr(struct map *map) 66 + { 67 + return map->map_ip; 68 + } 69 + 70 + static inline void* map__unmap_ip_ptr(struct map *map) 71 + { 72 + return map->unmap_ip; 73 + } 74 + 65 75 static inline u64 map__start(const struct map *map) 66 76 { 67 77 return map->start; ··· 110 100 static inline refcount_t *map__refcnt(struct map *map) 111 101 { 112 102 return &map->refcnt; 103 + } 104 + 105 + static inline bool map__erange_warned(struct map *map) 106 + { 107 + return map->erange_warned; 113 108 } 114 109 115 110 static inline size_t map__size(const struct map *map) ··· 245 230 return !strncmp(filename, "[stack", 6) || 246 231 !strncmp(filename, "/SYSV", 5) || 247 232 !strcmp(filename, "[heap]"); 233 + } 234 + 235 + static inline void map__set_start(struct map *map, u64 start) 236 + { 237 + map->start = start; 238 + } 239 + 240 + static inline void map__set_end(struct map *map, u64 end) 241 + { 242 + map->end = end; 243 + } 244 + 245 + static inline void map__set_pgoff(struct map *map, u64 pgoff) 246 + { 247 + map->pgoff = pgoff; 248 + } 249 + 250 + static inline void map__add_pgoff(struct map *map, u64 inc) 251 + { 252 + map->pgoff += inc; 253 + } 254 + 255 + static inline void map__set_reloc(struct map *map, u64 reloc) 256 + { 257 + map->reloc = reloc; 258 + } 259 + 260 + static inline void map__set_priv(struct map *map, int priv) 261 + { 262 + map->priv = priv; 263 + } 264 + 265 + static inline void map__set_erange_warned(struct map *map, bool erange_warned) 266 + { 267 + map->erange_warned = erange_warned; 268 + } 269 + 270 + static inline void map__set_dso(struct map *map, struct dso *dso) 271 + { 272 + map->dso = dso; 273 + } 274 + 275 + static inline void map__set_map_ip(struct map *map, u64 (*map_ip)(const struct map *map, u64 ip)) 276 + { 277 + map->map_ip = map_ip; 278 + } 279 + 280 + static inline void map__set_unmap_ip(struct map *map, u64 (*unmap_ip)(const struct map *map, u64 rip)) 281 + { 282 + map->unmap_ip = unmap_ip; 248 283 } 249 284 #endif /* __PERF_MAP_H */
+3 -3
tools/perf/util/maps.c
··· 339 339 goto put_map; 340 340 } 341 341 342 - before->end = map__start(map); 342 + map__set_end(before, map__start(map)); 343 343 err = __maps__insert(maps, before); 344 344 if (err) { 345 345 map__put(before); ··· 359 359 goto put_map; 360 360 } 361 361 362 - after->start = map__end(map); 363 - after->pgoff += map__end(map) - map__start(pos->map); 362 + map__set_start(after, map__end(map)); 363 + map__add_pgoff(after, map__end(map) - map__start(pos->map)); 364 364 assert(map__map_ip(pos->map, map__end(map)) == 365 365 map__map_ip(after, map__end(map))); 366 366 err = __maps__insert(maps, after);
+13 -13
tools/perf/util/symbol-elf.c
··· 1354 1354 */ 1355 1355 if (*remap_kernel && dso->kernel && !kmodule) { 1356 1356 *remap_kernel = false; 1357 - map->start = shdr->sh_addr + ref_reloc(kmap); 1358 - map->end = map__start(map) + shdr->sh_size; 1359 - map->pgoff = shdr->sh_offset; 1360 - map->map_ip = map__dso_map_ip; 1361 - map->unmap_ip = map__dso_unmap_ip; 1357 + map__set_start(map, shdr->sh_addr + ref_reloc(kmap)); 1358 + map__set_end(map, map__start(map) + shdr->sh_size); 1359 + map__set_pgoff(map, shdr->sh_offset); 1360 + map__set_map_ip(map, map__dso_map_ip); 1361 + map__set_unmap_ip(map, map__dso_unmap_ip); 1362 1362 /* Ensure maps are correctly ordered */ 1363 1363 if (kmaps) { 1364 1364 int err; ··· 1379 1379 */ 1380 1380 if (*remap_kernel && kmodule) { 1381 1381 *remap_kernel = false; 1382 - map->pgoff = shdr->sh_offset; 1382 + map__set_pgoff(map, shdr->sh_offset); 1383 1383 } 1384 1384 1385 1385 *curr_mapp = map; ··· 1414 1414 map__kmap(curr_map)->kmaps = kmaps; 1415 1415 1416 1416 if (adjust_kernel_syms) { 1417 - curr_map->start = shdr->sh_addr + ref_reloc(kmap); 1418 - curr_map->end = map__start(curr_map) + shdr->sh_size; 1419 - curr_map->pgoff = shdr->sh_offset; 1417 + map__set_start(curr_map, shdr->sh_addr + ref_reloc(kmap)); 1418 + map__set_end(curr_map, map__start(curr_map) + shdr->sh_size); 1419 + map__set_pgoff(curr_map, shdr->sh_offset); 1420 1420 } else { 1421 - curr_map->map_ip = curr_map->unmap_ip = identity__map_ip; 1421 + map__set_map_ip(curr_map, identity__map_ip); 1422 + map__set_unmap_ip(curr_map, identity__map_ip); 1422 1423 } 1423 1424 curr_dso->symtab_type = dso->symtab_type; 1424 1425 if (maps__insert(kmaps, curr_map)) ··· 1526 1525 if (strcmp(elf_name, kmap->ref_reloc_sym->name)) 1527 1526 continue; 1528 1527 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value; 1529 - map->reloc = kmap->ref_reloc_sym->addr - 1530 - kmap->ref_reloc_sym->unrelocated_addr; 1528 + map__set_reloc(map, kmap->ref_reloc_sym->addr - kmap->ref_reloc_sym->unrelocated_addr); 1531 1529 break; 1532 1530 } 1533 1531 } ··· 1536 1536 * attempted to prelink vdso to its virtual address. 1537 1537 */ 1538 1538 if (dso__is_vdso(dso)) 1539 - map->reloc = map__start(map) - dso->text_offset; 1539 + map__set_reloc(map, map__start(map) - dso->text_offset); 1540 1540 1541 1541 dso->adjust_symbols = runtime_ss->adjust_symbols || ref_reloc(kmap); 1542 1542 /*
+17 -16
tools/perf/util/symbol.c
··· 279 279 280 280 maps__for_each_entry(maps, curr) { 281 281 if (prev != NULL && !map__end(prev->map)) 282 - prev->map->end = map__start(curr->map); 282 + map__set_end(prev->map, map__start(curr->map)); 283 283 284 284 prev = curr; 285 285 } ··· 289 289 * last map final address. 290 290 */ 291 291 if (curr && !map__end(curr->map)) 292 - curr->map->end = ~0ULL; 292 + map__set_end(curr->map, ~0ULL); 293 293 294 294 up_write(maps__lock(maps)); 295 295 } ··· 944 944 return -1; 945 945 } 946 946 947 - curr_map->map_ip = curr_map->unmap_ip = identity__map_ip; 947 + map__set_map_ip(curr_map, identity__map_ip); 948 + map__set_unmap_ip(curr_map, identity__map_ip); 948 949 if (maps__insert(kmaps, curr_map)) { 949 950 dso__put(ndso); 950 951 return -1; ··· 1251 1250 return -ENOMEM; 1252 1251 } 1253 1252 1254 - list_node->map->end = map__start(list_node->map) + len; 1255 - list_node->map->pgoff = pgoff; 1253 + map__set_end(list_node->map, map__start(list_node->map) + len); 1254 + map__set_pgoff(list_node->map, pgoff); 1256 1255 1257 1256 list_add(&list_node->node, &md->maps); 1258 1257 ··· 1287 1286 * |new......| -> |new..| 1288 1287 * |old....| -> |old....| 1289 1288 */ 1290 - new_map->end = map__start(old_map); 1289 + map__set_end(new_map, map__start(old_map)); 1291 1290 } else { 1292 1291 /* 1293 1292 * |new.............| -> |new..| |new..| ··· 1307 1306 goto out; 1308 1307 } 1309 1308 1310 - m->map->end = map__start(old_map); 1309 + map__set_end(m->map, map__start(old_map)); 1311 1310 list_add_tail(&m->node, &merged); 1312 - new_map->pgoff += map__end(old_map) - map__start(new_map); 1313 - new_map->start = map__end(old_map); 1311 + map__add_pgoff(new_map, map__end(old_map) - map__start(new_map)); 1312 + map__set_start(new_map, map__end(old_map)); 1314 1313 } 1315 1314 } else { 1316 1315 /* ··· 1330 1329 * |new......| -> |new...| 1331 1330 * |old....| -> |old....| 1332 1331 */ 1333 - new_map->pgoff += map__end(old_map) - map__start(new_map); 1334 - new_map->start = map__end(old_map); 1332 + map__add_pgoff(new_map, map__end(old_map) - map__start(new_map)); 1333 + map__set_start(new_map, map__end(old_map)); 1335 1334 } 1336 1335 } 1337 1336 } ··· 1458 1457 list_del_init(&new_node->node); 1459 1458 1460 1459 if (new_map == replacement_map) { 1461 - map->start = map__start(new_map); 1462 - map->end = map__end(new_map); 1463 - map->pgoff = map__pgoff(new_map); 1464 - map->map_ip = new_map->map_ip; 1465 - map->unmap_ip = new_map->unmap_ip; 1460 + map__set_start(map, map__start(new_map)); 1461 + map__set_end(map, map__end(new_map)); 1462 + map__set_pgoff(map, map__pgoff(new_map)); 1463 + map__set_map_ip(map, map__map_ip_ptr(new_map)); 1464 + map__set_unmap_ip(map, map__unmap_ip_ptr(new_map)); 1466 1465 /* Ensure maps are correctly ordered */ 1467 1466 map__get(map); 1468 1467 maps__remove(kmaps, map);