map.c 3.6 KB
Newer Older
1 2 3 4 5
#include "event.h"
#include "symbol.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
6
#include "debug.h"
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

static inline int is_anon_memory(const char *filename)
{
	return strcmp(filename, "//anon") == 0;
}

static int strcommon(const char *pathname, char *cwd, int cwdlen)
{
	int n = 0;

	while (n < cwdlen && pathname[n] == cwd[n])
		++n;

	return n;
}

23 24 25 26 27 28 29 30 31 32 33 34
void map__init(struct map *self, u64 start, u64 end, u64 pgoff,
	       struct dso *dso)
{
	self->start    = start;
	self->end      = end;
	self->pgoff    = pgoff;
	self->dso      = dso;
	self->map_ip   = map__map_ip;
	self->unmap_ip = map__unmap_ip;
	RB_CLEAR_NODE(&self->rb_node);
}

35
struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen)
36 37 38 39 40 41
{
	struct map *self = malloc(sizeof(*self));

	if (self != NULL) {
		const char *filename = event->filename;
		char newfilename[PATH_MAX];
42
		struct dso *dso;
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
		int anon;

		if (cwd) {
			int n = strcommon(filename, cwd, cwdlen);

			if (n == cwdlen) {
				snprintf(newfilename, sizeof(newfilename),
					 ".%s", filename + n);
				filename = newfilename;
			}
		}

		anon = is_anon_memory(filename);

		if (anon) {
			snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
			filename = newfilename;
		}

62
		dso = dsos__findnew(filename);
63
		if (dso == NULL)
64 65
			goto out_delete;

66 67 68
		map__init(self, event->start, event->start + event->len,
			  event->pgoff, dso);

69
		if (self->dso == vdso || anon)
70
			self->map_ip = self->unmap_ip = identity__map_ip;
71 72 73 74 75 76 77
	}
	return self;
out_delete:
	free(self);
	return NULL;
}

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
void map__delete(struct map *self)
{
	free(self);
}

void map__fixup_start(struct map *self)
{
	struct rb_node *nd = rb_first(&self->dso->syms);
	if (nd != NULL) {
		struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
		self->start = sym->start;
	}
}

void map__fixup_end(struct map *self)
{
	struct rb_node *nd = rb_last(&self->dso->syms);
	if (nd != NULL) {
		struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
		self->end = sym->end;
	}
}

101 102
#define DSO__DELETED "(deleted)"

103 104 105 106 107 108 109
struct symbol *
map__find_symbol(struct map *self, u64 ip, symbol_filter_t filter)
{
	if (!self->dso->loaded) {
		int nr = dso__load(self->dso, self, filter);

		if (nr < 0) {
110 111 112 113 114 115 116 117 118 119 120 121
			if (self->dso->has_build_id) {
				char sbuild_id[BUILD_ID_SIZE * 2 + 1];

				build_id__sprintf(self->dso->build_id,
						  sizeof(self->dso->build_id),
						  sbuild_id);
				pr_warning("%s with build id %s not found",
					   self->dso->long_name, sbuild_id);
			} else
				pr_warning("Failed to open %s",
					   self->dso->long_name);
			pr_warning(", continuing without symbols\n");
122 123
			return NULL;
		} else if (nr == 0) {
124 125 126 127 128
			const char *name = self->dso->long_name;
			const size_t len = strlen(name);
			const size_t real_len = len - sizeof(DSO__DELETED);

			if (len > sizeof(DSO__DELETED) &&
129 130 131 132 133 134
			    strcmp(name + real_len + 1, DSO__DELETED) == 0) {
				pr_warning("%.*s was updated, restart the long running apps that use it!\n",
					   (int)real_len, name);
			} else {
				pr_warning("no symbols found in %s, maybe install a debug package?\n", name);
			}
135 136 137 138 139 140 141
			return NULL;
		}
	}

	return self->dso->find_symbol(self->dso, ip);
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
struct map *map__clone(struct map *self)
{
	struct map *map = malloc(sizeof(*self));

	if (!map)
		return NULL;

	memcpy(map, self, sizeof(*self));

	return map;
}

int map__overlap(struct map *l, struct map *r)
{
	if (l->start > r->start) {
		struct map *t = l;
		l = r;
		r = t;
	}

	if (l->end > r->start)
		return 1;

	return 0;
}

size_t map__fprintf(struct map *self, FILE *fp)
{
	return fprintf(fp, " %Lx-%Lx %Lx %s\n",
		       self->start, self->end, self->pgoff, self->dso->name);
}