mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
363 lines
7.2 KiB
363 lines
7.2 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
#include <errno.h> |
|
#include <unistd.h> |
|
#include <stdio.h> |
|
#include <string.h> |
|
#include <sys/types.h> |
|
#include <sys/stat.h> |
|
#include <fcntl.h> |
|
#include <stdlib.h> |
|
#include <linux/kernel.h> |
|
|
|
#include "vdso.h" |
|
#include "dso.h" |
|
#include <internal/lib.h> |
|
#include "map.h" |
|
#include "symbol.h" |
|
#include "machine.h" |
|
#include "thread.h" |
|
#include "linux/string.h" |
|
#include <linux/zalloc.h> |
|
#include "debug.h" |
|
|
|
/* |
|
* Include definition of find_map() also used in perf-read-vdso.c for |
|
* building perf-read-vdso32 and perf-read-vdsox32. |
|
*/ |
|
#include "find-map.c" |
|
|
|
#define VDSO__TEMP_FILE_NAME "/tmp/perf-vdso.so-XXXXXX" |
|
|
|
struct vdso_file { |
|
bool found; |
|
bool error; |
|
char temp_file_name[sizeof(VDSO__TEMP_FILE_NAME)]; |
|
const char *dso_name; |
|
const char *read_prog; |
|
}; |
|
|
|
struct vdso_info { |
|
struct vdso_file vdso; |
|
#if BITS_PER_LONG == 64 |
|
struct vdso_file vdso32; |
|
struct vdso_file vdsox32; |
|
#endif |
|
}; |
|
|
|
static struct vdso_info *vdso_info__new(void) |
|
{ |
|
static const struct vdso_info vdso_info_init = { |
|
.vdso = { |
|
.temp_file_name = VDSO__TEMP_FILE_NAME, |
|
.dso_name = DSO__NAME_VDSO, |
|
}, |
|
#if BITS_PER_LONG == 64 |
|
.vdso32 = { |
|
.temp_file_name = VDSO__TEMP_FILE_NAME, |
|
.dso_name = DSO__NAME_VDSO32, |
|
.read_prog = "perf-read-vdso32", |
|
}, |
|
.vdsox32 = { |
|
.temp_file_name = VDSO__TEMP_FILE_NAME, |
|
.dso_name = DSO__NAME_VDSOX32, |
|
.read_prog = "perf-read-vdsox32", |
|
}, |
|
#endif |
|
}; |
|
|
|
return memdup(&vdso_info_init, sizeof(vdso_info_init)); |
|
} |
|
|
|
static char *get_file(struct vdso_file *vdso_file) |
|
{ |
|
char *vdso = NULL; |
|
char *buf = NULL; |
|
void *start, *end; |
|
size_t size; |
|
int fd; |
|
|
|
if (vdso_file->found) |
|
return vdso_file->temp_file_name; |
|
|
|
if (vdso_file->error || find_map(&start, &end, VDSO__MAP_NAME)) |
|
return NULL; |
|
|
|
size = end - start; |
|
|
|
buf = memdup(start, size); |
|
if (!buf) |
|
return NULL; |
|
|
|
fd = mkstemp(vdso_file->temp_file_name); |
|
if (fd < 0) |
|
goto out; |
|
|
|
if (size == (size_t) write(fd, buf, size)) |
|
vdso = vdso_file->temp_file_name; |
|
|
|
close(fd); |
|
|
|
out: |
|
free(buf); |
|
|
|
vdso_file->found = (vdso != NULL); |
|
vdso_file->error = !vdso_file->found; |
|
return vdso; |
|
} |
|
|
|
void machine__exit_vdso(struct machine *machine) |
|
{ |
|
struct vdso_info *vdso_info = machine->vdso_info; |
|
|
|
if (!vdso_info) |
|
return; |
|
|
|
if (vdso_info->vdso.found) |
|
unlink(vdso_info->vdso.temp_file_name); |
|
#if BITS_PER_LONG == 64 |
|
if (vdso_info->vdso32.found) |
|
unlink(vdso_info->vdso32.temp_file_name); |
|
if (vdso_info->vdsox32.found) |
|
unlink(vdso_info->vdsox32.temp_file_name); |
|
#endif |
|
|
|
zfree(&machine->vdso_info); |
|
} |
|
|
|
static struct dso *__machine__addnew_vdso(struct machine *machine, const char *short_name, |
|
const char *long_name) |
|
{ |
|
struct dso *dso; |
|
|
|
dso = dso__new(short_name); |
|
if (dso != NULL) { |
|
__dsos__add(&machine->dsos, dso); |
|
dso__set_long_name(dso, long_name, false); |
|
/* Put dso here because __dsos_add already got it */ |
|
dso__put(dso); |
|
} |
|
|
|
return dso; |
|
} |
|
|
|
static enum dso_type machine__thread_dso_type(struct machine *machine, |
|
struct thread *thread) |
|
{ |
|
enum dso_type dso_type = DSO__TYPE_UNKNOWN; |
|
struct map *map; |
|
|
|
maps__for_each_entry(thread->maps, map) { |
|
struct dso *dso = map->dso; |
|
if (!dso || dso->long_name[0] != '/') |
|
continue; |
|
dso_type = dso__type(dso, machine); |
|
if (dso_type != DSO__TYPE_UNKNOWN) |
|
break; |
|
} |
|
|
|
return dso_type; |
|
} |
|
|
|
#if BITS_PER_LONG == 64 |
|
|
|
static int vdso__do_copy_compat(FILE *f, int fd) |
|
{ |
|
char buf[4096]; |
|
size_t count; |
|
|
|
while (1) { |
|
count = fread(buf, 1, sizeof(buf), f); |
|
if (ferror(f)) |
|
return -errno; |
|
if (feof(f)) |
|
break; |
|
if (count && writen(fd, buf, count) != (ssize_t)count) |
|
return -errno; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int vdso__copy_compat(const char *prog, int fd) |
|
{ |
|
FILE *f; |
|
int err; |
|
|
|
f = popen(prog, "r"); |
|
if (!f) |
|
return -errno; |
|
|
|
err = vdso__do_copy_compat(f, fd); |
|
|
|
if (pclose(f) == -1) |
|
return -errno; |
|
|
|
return err; |
|
} |
|
|
|
static int vdso__create_compat_file(const char *prog, char *temp_name) |
|
{ |
|
int fd, err; |
|
|
|
fd = mkstemp(temp_name); |
|
if (fd < 0) |
|
return -errno; |
|
|
|
err = vdso__copy_compat(prog, fd); |
|
|
|
if (close(fd) == -1) |
|
return -errno; |
|
|
|
return err; |
|
} |
|
|
|
static const char *vdso__get_compat_file(struct vdso_file *vdso_file) |
|
{ |
|
int err; |
|
|
|
if (vdso_file->found) |
|
return vdso_file->temp_file_name; |
|
|
|
if (vdso_file->error) |
|
return NULL; |
|
|
|
err = vdso__create_compat_file(vdso_file->read_prog, |
|
vdso_file->temp_file_name); |
|
if (err) { |
|
pr_err("%s failed, error %d\n", vdso_file->read_prog, err); |
|
vdso_file->error = true; |
|
return NULL; |
|
} |
|
|
|
vdso_file->found = true; |
|
|
|
return vdso_file->temp_file_name; |
|
} |
|
|
|
static struct dso *__machine__findnew_compat(struct machine *machine, |
|
struct vdso_file *vdso_file) |
|
{ |
|
const char *file_name; |
|
struct dso *dso; |
|
|
|
dso = __dsos__find(&machine->dsos, vdso_file->dso_name, true); |
|
if (dso) |
|
goto out; |
|
|
|
file_name = vdso__get_compat_file(vdso_file); |
|
if (!file_name) |
|
goto out; |
|
|
|
dso = __machine__addnew_vdso(machine, vdso_file->dso_name, file_name); |
|
out: |
|
return dso; |
|
} |
|
|
|
static int __machine__findnew_vdso_compat(struct machine *machine, |
|
struct thread *thread, |
|
struct vdso_info *vdso_info, |
|
struct dso **dso) |
|
{ |
|
enum dso_type dso_type; |
|
|
|
dso_type = machine__thread_dso_type(machine, thread); |
|
|
|
#ifndef HAVE_PERF_READ_VDSO32 |
|
if (dso_type == DSO__TYPE_32BIT) |
|
return 0; |
|
#endif |
|
#ifndef HAVE_PERF_READ_VDSOX32 |
|
if (dso_type == DSO__TYPE_X32BIT) |
|
return 0; |
|
#endif |
|
|
|
switch (dso_type) { |
|
case DSO__TYPE_32BIT: |
|
*dso = __machine__findnew_compat(machine, &vdso_info->vdso32); |
|
return 1; |
|
case DSO__TYPE_X32BIT: |
|
*dso = __machine__findnew_compat(machine, &vdso_info->vdsox32); |
|
return 1; |
|
case DSO__TYPE_UNKNOWN: |
|
case DSO__TYPE_64BIT: |
|
default: |
|
return 0; |
|
} |
|
} |
|
|
|
#endif |
|
|
|
static struct dso *machine__find_vdso(struct machine *machine, |
|
struct thread *thread) |
|
{ |
|
struct dso *dso = NULL; |
|
enum dso_type dso_type; |
|
|
|
dso_type = machine__thread_dso_type(machine, thread); |
|
switch (dso_type) { |
|
case DSO__TYPE_32BIT: |
|
dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO32, true); |
|
if (!dso) { |
|
dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO, |
|
true); |
|
if (dso && dso_type != dso__type(dso, machine)) |
|
dso = NULL; |
|
} |
|
break; |
|
case DSO__TYPE_X32BIT: |
|
dso = __dsos__find(&machine->dsos, DSO__NAME_VDSOX32, true); |
|
break; |
|
case DSO__TYPE_64BIT: |
|
case DSO__TYPE_UNKNOWN: |
|
default: |
|
dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO, true); |
|
break; |
|
} |
|
|
|
return dso; |
|
} |
|
|
|
struct dso *machine__findnew_vdso(struct machine *machine, |
|
struct thread *thread) |
|
{ |
|
struct vdso_info *vdso_info; |
|
struct dso *dso = NULL; |
|
|
|
down_write(&machine->dsos.lock); |
|
if (!machine->vdso_info) |
|
machine->vdso_info = vdso_info__new(); |
|
|
|
vdso_info = machine->vdso_info; |
|
if (!vdso_info) |
|
goto out_unlock; |
|
|
|
dso = machine__find_vdso(machine, thread); |
|
if (dso) |
|
goto out_unlock; |
|
|
|
#if BITS_PER_LONG == 64 |
|
if (__machine__findnew_vdso_compat(machine, thread, vdso_info, &dso)) |
|
goto out_unlock; |
|
#endif |
|
|
|
dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO, true); |
|
if (!dso) { |
|
char *file; |
|
|
|
file = get_file(&vdso_info->vdso); |
|
if (file) |
|
dso = __machine__addnew_vdso(machine, DSO__NAME_VDSO, file); |
|
} |
|
|
|
out_unlock: |
|
dso__get(dso); |
|
up_write(&machine->dsos.lock); |
|
return dso; |
|
} |
|
|
|
bool dso__is_vdso(struct dso *dso) |
|
{ |
|
return !strcmp(dso->short_name, DSO__NAME_VDSO) || |
|
!strcmp(dso->short_name, DSO__NAME_VDSO32) || |
|
!strcmp(dso->short_name, DSO__NAME_VDSOX32); |
|
}
|
|
|