tools/perf/util/map.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __PERF_MAP_H
   3 #define __PERF_MAP_H
   4
   5 #include <linux/refcount.h>
   6 #include <linux/compiler.h>
   7 #include <linux/list.h>
   8 #include <linux/rbtree.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <stdbool.h>
  12 #include <linux/types.h>
  13 #include <internal/rc_check.h>
  14
  15 struct dso;
  16 struct maps;
  17 struct machine;
  18
  19 enum mapping_type {
  20         /* map__map_ip/map__unmap_ip are given as offsets in the DSO. */
  21         MAPPING_TYPE__DSO,
  22         /* map__map_ip/map__unmap_ip are just the given ip value. */
  23         MAPPING_TYPE__IDENTITY,
  24 };
  25
  26 DECLARE_RC_STRUCT(map) {
  27         u64                     start;
  28         u64                     end;
  29         u64                     pgoff;
  30         u64                     reloc;
  31         struct dso              *dso;
  32         refcount_t              refcnt;
  33         u32                     prot;
  34         u32                     flags;
  35         enum mapping_type       mapping_type:8;
  36         bool                    erange_warned;
  37         bool                    priv;
  38 };
  39
  40 struct kmap;
  41
  42 struct kmap *__map__kmap(struct map *map);
  43 struct kmap *map__kmap(struct map *map);
  44 struct maps *map__kmaps(struct map *map);
  45
  46 static inline struct dso *map__dso(const struct map *map)
  47 {
  48         return RC_CHK_ACCESS(map)->dso;
  49 }
  50
  51 static inline u64 map__start(const struct map *map)
  52 {
  53         return RC_CHK_ACCESS(map)->start;
  54 }
  55
  56 static inline u64 map__end(const struct map *map)
  57 {
  58         return RC_CHK_ACCESS(map)->end;
  59 }
  60
  61 static inline u64 map__pgoff(const struct map *map)
  62 {
  63         return RC_CHK_ACCESS(map)->pgoff;
  64 }
  65
  66 static inline u64 map__reloc(const struct map *map)
  67 {
  68         return RC_CHK_ACCESS(map)->reloc;
  69 }
  70
  71 static inline u32 map__flags(const struct map *map)
  72 {
  73         return RC_CHK_ACCESS(map)->flags;
  74 }
  75
  76 static inline u32 map__prot(const struct map *map)
  77 {
  78         return RC_CHK_ACCESS(map)->prot;
  79 }
  80
  81 static inline bool map__priv(const struct map *map)
  82 {
  83         return RC_CHK_ACCESS(map)->priv;
  84 }
  85
  86 static inline refcount_t *map__refcnt(struct map *map)
  87 {
  88         return &RC_CHK_ACCESS(map)->refcnt;
  89 }
  90
  91 static inline bool map__erange_warned(struct map *map)
  92 {
  93         return RC_CHK_ACCESS(map)->erange_warned;
  94 }
  95
  96 static inline size_t map__size(const struct map *map)
  97 {
  98         return map__end(map) - map__start(map);
  99 }
 100
 101 /* ip -> dso rip */
 102 static inline u64 map__dso_map_ip(const struct map *map, u64 ip)
 103 {
 104         return ip - map__start(map) + map__pgoff(map);
 105 }
 106
 107 /* dso rip -> ip */
 108 static inline u64 map__dso_unmap_ip(const struct map *map, u64 rip)
 109 {
 110         return rip + map__start(map) - map__pgoff(map);
 111 }
 112
 113 static inline u64 map__map_ip(const struct map *map, u64 ip_or_rip)
 114 {
 115         if ((RC_CHK_ACCESS(map)->mapping_type) == MAPPING_TYPE__DSO)
 116                 return map__dso_map_ip(map, ip_or_rip);
 117         else
 118                 return ip_or_rip;
 119 }
 120
 121 static inline u64 map__unmap_ip(const struct map *map, u64 ip_or_rip)
 122 {
 123         if ((RC_CHK_ACCESS(map)->mapping_type) == MAPPING_TYPE__DSO)
 124                 return map__dso_unmap_ip(map, ip_or_rip);
 125         else
 126                 return ip_or_rip;
 127 }
 128
 129 /* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
 130 u64 map__rip_2objdump(struct map *map, u64 rip);
 131
 132 /* objdump address -> memory address */
 133 u64 map__objdump_2mem(struct map *map, u64 ip);
 134
 135 struct symbol;
 136 struct thread;
 137
 138 /* map__for_each_symbol - iterate over the symbols in the given map
 139  *
 140  * @map: the 'struct map *' in which symbols are iterated
 141  * @pos: the 'struct symbol *' to use as a loop cursor
 142  * @n: the 'struct rb_node *' to use as a temporary storage
 143  * Note: caller must ensure map->dso is not NULL (map is loaded).
 144  */
 145 #define map__for_each_symbol(map, pos, n)       \
 146         dso__for_each_symbol(map__dso(map), pos, n)
 147
 148 /* map__for_each_symbol_with_name - iterate over the symbols in the given map
 149  *                                  that have the given name
 150  *
 151  * @map: the 'struct map *' in which symbols are iterated
 152  * @sym_name: the symbol name
 153  * @pos: the 'struct symbol *' to use as a loop cursor
 154  * @idx: the cursor index in the symbol names array
 155  */
 156 #define __map__for_each_symbol_by_name(map, sym_name, pos, idx)         \
 157         for (pos = map__find_symbol_by_name_idx(map, sym_name, &idx);   \
 158              pos &&                                             \
 159              !symbol__match_symbol_name(pos->name, sym_name,    \
 160                                         SYMBOL_TAG_INCLUDE__DEFAULT_ONLY); \
 161              pos = dso__next_symbol_by_name(map__dso(map), &idx))
 162
 163 #define map__for_each_symbol_by_name(map, sym_name, pos, idx)   \
 164         __map__for_each_symbol_by_name(map, sym_name, (pos), idx)
 165
 166 void map__init(struct map *map,
 167                u64 start, u64 end, u64 pgoff, struct dso *dso);
 168
 169 struct dso_id;
 170 struct build_id;
 171
 172 struct map *map__new(struct machine *machine, u64 start, u64 len,
 173                      u64 pgoff, struct dso_id *id, u32 prot, u32 flags,
 174                      struct build_id *bid, char *filename, struct thread *thread);
 175 struct map *map__new2(u64 start, struct dso *dso);
 176 void map__delete(struct map *map);
 177 struct map *map__clone(struct map *map);
 178
 179 static inline struct map *map__get(struct map *map)
 180 {
 181         struct map *result;
 182
 183         if (RC_CHK_GET(result, map))
 184                 refcount_inc(map__refcnt(map));
 185
 186         return result;
 187 }
 188
 189 void map__put(struct map *map);
 190
 191 static inline void __map__zput(struct map **map)
 192 {
 193         map__put(*map);
 194         *map = NULL;
 195 }
 196
 197 #define map__zput(map) __map__zput(&map)
 198
 199 size_t map__fprintf(struct map *map, FILE *fp);
 200 size_t map__fprintf_dsoname(struct map *map, FILE *fp);
 201 size_t map__fprintf_dsoname_dsoff(struct map *map, bool print_off, u64 addr, FILE *fp);
 202 char *map__srcline(struct map *map, u64 addr, struct symbol *sym);
 203 int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
 204                          FILE *fp);
 205
 206 int map__load(struct map *map);
 207 struct symbol *map__find_symbol(struct map *map, u64 addr);
 208 struct symbol *map__find_symbol_by_name(struct map *map, const char *name);
 209 struct symbol *map__find_symbol_by_name_idx(struct map *map, const char *name, size_t *idx);
 210 void map__fixup_start(struct map *map);
 211 void map__fixup_end(struct map *map);
 212
 213 int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name,
 214                                     u64 addr);
 215
 216 bool __map__is_kernel(const struct map *map);
 217 bool __map__is_extra_kernel_map(const struct map *map);
 218 bool __map__is_bpf_prog(const struct map *map);
 219 bool __map__is_bpf_image(const struct map *map);
 220 bool __map__is_ool(const struct map *map);
 221
 222 static inline bool __map__is_kmodule(const struct map *map)
 223 {
 224         return !__map__is_kernel(map) && !__map__is_extra_kernel_map(map) &&
 225                !__map__is_bpf_prog(map) && !__map__is_ool(map) &&
 226                !__map__is_bpf_image(map);
 227 }
 228
 229 bool map__has_symbols(const struct map *map);
 230
 231 bool map__contains_symbol(const struct map *map, const struct symbol *sym);
 232
 233 #define ENTRY_TRAMPOLINE_NAME "__entry_SYSCALL_64_trampoline"
 234
 235 static inline bool is_entry_trampoline(const char *name)
 236 {
 237         return !strcmp(name, ENTRY_TRAMPOLINE_NAME);
 238 }
 239
 240 static inline bool is_bpf_image(const char *name)
 241 {
 242         return strncmp(name, "bpf_trampoline_", sizeof("bpf_trampoline_") - 1) == 0 ||
 243                strncmp(name, "bpf_dispatcher_", sizeof("bpf_dispatcher_") - 1) == 0;
 244 }
 245
 246 static inline int is_anon_memory(const char *filename)
 247 {
 248         return !strcmp(filename, "//anon") ||
 249                !strncmp(filename, "/dev/zero", sizeof("/dev/zero") - 1) ||
 250                !strncmp(filename, "/anon_hugepage", sizeof("/anon_hugepage") - 1);
 251 }
 252
 253 static inline int is_no_dso_memory(const char *filename)
 254 {
 255         return !strncmp(filename, "[stack", 6) ||
 256                !strncmp(filename, "/SYSV", 5)  ||
 257                !strcmp(filename, "[heap]");
 258 }
 259
 260 static inline void map__set_start(struct map *map, u64 start)
 261 {
 262         RC_CHK_ACCESS(map)->start = start;
 263 }
 264
 265 static inline void map__set_end(struct map *map, u64 end)
 266 {
 267         RC_CHK_ACCESS(map)->end = end;
 268 }
 269
 270 static inline void map__set_pgoff(struct map *map, u64 pgoff)
 271 {
 272         RC_CHK_ACCESS(map)->pgoff = pgoff;
 273 }
 274
 275 static inline void map__add_pgoff(struct map *map, u64 inc)
 276 {
 277         RC_CHK_ACCESS(map)->pgoff += inc;
 278 }
 279
 280 static inline void map__set_reloc(struct map *map, u64 reloc)
 281 {
 282         RC_CHK_ACCESS(map)->reloc = reloc;
 283 }
 284
 285 static inline void map__set_priv(struct map *map, int priv)
 286 {
 287         RC_CHK_ACCESS(map)->priv = priv;
 288 }
 289
 290 static inline void map__set_erange_warned(struct map *map, bool erange_warned)
 291 {
 292         RC_CHK_ACCESS(map)->erange_warned = erange_warned;
 293 }
 294
 295 static inline void map__set_dso(struct map *map, struct dso *dso)
 296 {
 297         RC_CHK_ACCESS(map)->dso = dso;
 298 }
 299
 300 static inline void map__set_mapping_type(struct map *map, enum mapping_type type)
 301 {
 302         RC_CHK_ACCESS(map)->mapping_type = type;
 303 }
 304
 305 static inline enum mapping_type map__mapping_type(struct map *map)
 306 {
 307         return RC_CHK_ACCESS(map)->mapping_type;
 308 }
 309 #endif /* __PERF_MAP_H */