aboutsummaryrefslogtreecommitdiff
path: root/linux-user
diff options
context:
space:
mode:
Diffstat (limited to 'linux-user')
-rw-r--r--linux-user/gen-vdso-elfn.c.inc98
-rw-r--r--linux-user/gen-vdso.c40
-rw-r--r--linux-user/main.c12
-rw-r--r--linux-user/signal-common.h2
-rw-r--r--linux-user/signal.c108
5 files changed, 187 insertions, 73 deletions
diff --git a/linux-user/gen-vdso-elfn.c.inc b/linux-user/gen-vdso-elfn.c.inc
index 95856eb839..b47019e136 100644
--- a/linux-user/gen-vdso-elfn.c.inc
+++ b/linux-user/gen-vdso-elfn.c.inc
@@ -68,28 +68,45 @@ static void elfN(search_symtab)(ElfN(Shdr) *shdr, unsigned sym_idx,
void *buf, bool need_bswap)
{
unsigned str_idx = shdr[sym_idx].sh_link;
- ElfN(Sym) *sym = buf + shdr[sym_idx].sh_offset;
- unsigned sym_n = shdr[sym_idx].sh_size / sizeof(*sym);
+ ElfN(Sym) *target_sym = buf + shdr[sym_idx].sh_offset;
+ unsigned sym_n = shdr[sym_idx].sh_size / sizeof(*target_sym);
const char *str = buf + shdr[str_idx].sh_offset;
for (unsigned i = 0; i < sym_n; ++i) {
const char *name;
+ ElfN(Sym) sym;
+ memcpy(&sym, &target_sym[i], sizeof(sym));
if (need_bswap) {
- elfN(bswap_sym)(sym + i);
+ elfN(bswap_sym)(&sym);
}
- name = str + sym[i].st_name;
+ name = str + sym.st_name;
if (sigreturn_sym && strcmp(sigreturn_sym, name) == 0) {
- sigreturn_addr = sym[i].st_value;
+ sigreturn_addr = sym.st_value;
}
if (rt_sigreturn_sym && strcmp(rt_sigreturn_sym, name) == 0) {
- rt_sigreturn_addr = sym[i].st_value;
+ rt_sigreturn_addr = sym.st_value;
}
}
}
-static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
+static void elfN(bswap_ps_hdrs)(ElfN(Ehdr) *ehdr)
+{
+ ElfN(Phdr) *phdr = (void *)ehdr + ehdr->e_phoff;
+ ElfN(Shdr) *shdr = (void *)ehdr + ehdr->e_shoff;
+ ElfN(Half) i;
+
+ for (i = 0; i < ehdr->e_phnum; ++i) {
+ elfN(bswap_phdr)(&phdr[i]);
+ }
+
+ for (i = 0; i < ehdr->e_shnum; ++i) {
+ elfN(bswap_shdr)(&shdr[i]);
+ }
+}
+
+static void elfN(process)(FILE *outf, void *buf, long len, bool need_bswap)
{
ElfN(Ehdr) *ehdr = buf;
ElfN(Phdr) *phdr;
@@ -103,24 +120,14 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
int errors = 0;
if (need_bswap) {
- elfN(bswap_ehdr)(ehdr);
+ elfN(bswap_ehdr)(buf);
+ elfN(bswap_ps_hdrs)(buf);
}
phnum = ehdr->e_phnum;
phdr = buf + ehdr->e_phoff;
- if (need_bswap) {
- for (unsigned i = 0; i < phnum; ++i) {
- elfN(bswap_phdr)(phdr + i);
- }
- }
-
shnum = ehdr->e_shnum;
shdr = buf + ehdr->e_shoff;
- if (need_bswap) {
- for (unsigned i = 0; i < shnum; ++i) {
- elfN(bswap_shdr)(shdr + i);
- }
- }
for (unsigned i = 0; i < shnum; ++i) {
switch (shdr[i].sh_type) {
case SHT_SYMTAB:
@@ -154,7 +161,24 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
fprintf(stderr, "LOAD segment not loaded at address 0\n");
errors++;
}
- first_segsz = phdr[i].p_filesz;
+ /*
+ * Extend the program header to cover the entire VDSO, so that
+ * load_elf_vdso() loads everything, including section headers.
+ *
+ * Require that there is no .bss, since it would break this
+ * approach.
+ */
+ if (phdr[i].p_filesz != phdr[i].p_memsz) {
+ fprintf(stderr, "LOAD segment's filesz and memsz differ\n");
+ errors++;
+ }
+ if (phdr[i].p_filesz > len) {
+ fprintf(stderr, "LOAD segment is larger than the whole VDSO\n");
+ errors++;
+ }
+ phdr[i].p_filesz = len;
+ phdr[i].p_memsz = len;
+ first_segsz = len;
if (first_segsz < ehdr->e_phoff + phnum * sizeof(*phdr)) {
fprintf(stderr, "LOAD segment does not cover PHDRs\n");
errors++;
@@ -197,17 +221,24 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
output_reloc(outf, buf, &phdr[i].p_paddr);
}
+ /* Relocate the section headers. */
+ for (unsigned i = 0; i < shnum; ++i) {
+ output_reloc(outf, buf, &shdr[i].sh_addr);
+ }
+
/* Relocate the DYNAMIC entries. */
if (dynamic_addr) {
- ElfN(Dyn) *dyn = buf + dynamic_ofs;
- __typeof(dyn->d_tag) tag;
+ ElfN(Dyn) *target_dyn = buf + dynamic_ofs;
+ __typeof(((ElfN(Dyn) *)target_dyn)->d_tag) tag;
do {
+ ElfN(Dyn) dyn;
+ memcpy(&dyn, target_dyn, sizeof(dyn));
if (need_bswap) {
- elfN(bswap_dyn)(dyn);
+ elfN(bswap_dyn)(&dyn);
}
- tag = dyn->d_tag;
+ tag = dyn.d_tag;
switch (tag) {
case DT_HASH:
@@ -218,7 +249,7 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
case DT_PLTGOT:
case DT_ADDRRNGLO ... DT_ADDRRNGHI:
/* These entries store an address in the entry. */
- output_reloc(outf, buf, &dyn->d_un.d_val);
+ output_reloc(outf, buf, &target_dyn->d_un.d_val);
break;
case DT_NULL:
@@ -235,7 +266,7 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
break;
case DT_SYMENT:
- if (dyn->d_un.d_val != sizeof(ElfN(Sym))) {
+ if (dyn.d_un.d_val != sizeof(ElfN(Sym))) {
fprintf(stderr, "VDSO has incorrect dynamic symbol size\n");
errors++;
}
@@ -251,7 +282,7 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
* ??? The RISC-V toolchain will emit these even when there
* are no relocations. Validate zeros.
*/
- if (dyn->d_un.d_val != 0) {
+ if (dyn.d_un.d_val != 0) {
fprintf(stderr, "VDSO has dynamic relocations\n");
errors++;
}
@@ -287,7 +318,7 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
errors++;
break;
}
- dyn++;
+ target_dyn++;
} while (tag != DT_NULL);
if (errors) {
exit(EXIT_FAILURE);
@@ -296,11 +327,11 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
/* Relocate the dynamic symbol table. */
if (dynsym_idx) {
- ElfN(Sym) *sym = buf + shdr[dynsym_idx].sh_offset;
- unsigned sym_n = shdr[dynsym_idx].sh_size / sizeof(*sym);
+ ElfN(Sym) *target_sym = buf + shdr[dynsym_idx].sh_offset;
+ unsigned sym_n = shdr[dynsym_idx].sh_size / sizeof(*target_sym);
for (unsigned i = 0; i < sym_n; ++i) {
- output_reloc(outf, buf, &sym[i].st_value);
+ output_reloc(outf, buf, &target_sym[i].st_value);
}
}
@@ -311,4 +342,9 @@ static void elfN(process)(FILE *outf, void *buf, bool need_bswap)
if (symtab_idx) {
elfN(search_symtab)(shdr, symtab_idx, buf, need_bswap);
}
+
+ if (need_bswap) {
+ elfN(bswap_ps_hdrs)(buf);
+ elfN(bswap_ehdr)(buf);
+ }
}
diff --git a/linux-user/gen-vdso.c b/linux-user/gen-vdso.c
index 31e333be80..721f38d5a3 100644
--- a/linux-user/gen-vdso.c
+++ b/linux-user/gen-vdso.c
@@ -132,23 +132,6 @@ int main(int argc, char **argv)
fclose(inf);
/*
- * Write out the vdso image now, before we make local changes.
- */
-
- fprintf(outf,
- "/* Automatically generated from linux-user/gen-vdso.c. */\n"
- "\n"
- "static const uint8_t %s_image[] = {",
- prefix);
- for (long i = 0; i < total_len; ++i) {
- if (i % 12 == 0) {
- fputs("\n ", outf);
- }
- fprintf(outf, " 0x%02x,", buf[i]);
- }
- fprintf(outf, "\n};\n\n");
-
- /*
* Identify which elf flavor we're processing.
* The first 16 bytes of the file are e_ident.
*/
@@ -179,14 +162,17 @@ int main(int argc, char **argv)
* Output relocation addresses as we go.
*/
- fprintf(outf, "static const unsigned %s_relocs[] = {\n", prefix);
+ fprintf(outf,
+ "/* Automatically generated by linux-user/gen-vdso.c. */\n"
+ "\n"
+ "static const unsigned %s_relocs[] = {\n", prefix);
switch (buf[EI_CLASS]) {
case ELFCLASS32:
- elf32_process(outf, buf, need_bswap);
+ elf32_process(outf, buf, total_len, need_bswap);
break;
case ELFCLASS64:
- elf64_process(outf, buf, need_bswap);
+ elf64_process(outf, buf, total_len, need_bswap);
break;
default:
fprintf(stderr, "%s: invalid elf EI_CLASS (%u)\n",
@@ -196,6 +182,20 @@ int main(int argc, char **argv)
fprintf(outf, "};\n\n"); /* end vdso_relocs. */
+ /*
+ * Write out the vdso image now, after we made local changes.
+ */
+ fprintf(outf,
+ "static const uint8_t %s_image[] = {",
+ prefix);
+ for (long i = 0; i < total_len; ++i) {
+ if (i % 12 == 0) {
+ fputs("\n ", outf);
+ }
+ fprintf(outf, " 0x%02x,", buf[i]);
+ }
+ fprintf(outf, "\n};\n\n");
+
fprintf(outf, "static const VdsoImageInfo %s_image_info = {\n", prefix);
fprintf(outf, " .image = %s_image,\n", prefix);
fprintf(outf, " .relocs = %s_relocs,\n", prefix);
diff --git a/linux-user/main.c b/linux-user/main.c
index 8143a0d4b0..b09af8d436 100644
--- a/linux-user/main.c
+++ b/linux-user/main.c
@@ -412,6 +412,13 @@ static void handle_arg_reserved_va(const char *arg)
reserved_va = val ? val - 1 : 0;
}
+static const char *rtsig_map = CONFIG_QEMU_RTSIG_MAP;
+
+static void handle_arg_rtsig_map(const char *arg)
+{
+ rtsig_map = arg;
+}
+
static void handle_arg_one_insn_per_tb(const char *arg)
{
opt_one_insn_per_tb = true;
@@ -494,6 +501,9 @@ static const struct qemu_argument arg_table[] = {
"address", "set guest_base address to 'address'"},
{"R", "QEMU_RESERVED_VA", true, handle_arg_reserved_va,
"size", "reserve 'size' bytes for guest virtual address space"},
+ {"t", "QEMU_RTSIG_MAP", true, handle_arg_rtsig_map,
+ "tsig hsig n[,...]",
+ "map target rt signals [tsig,tsig+n) to [hsig,hsig+n]"},
{"d", "QEMU_LOG", true, handle_arg_log,
"item[,...]", "enable logging of specified items "
"(use '-d help' for a list of items)"},
@@ -1002,7 +1012,7 @@ int main(int argc, char **argv, char **envp)
target_set_brk(info->brk);
syscall_init();
- signal_init();
+ signal_init(rtsig_map);
/* Now that we've loaded the binary, GUEST_BASE is fixed. Delay
generating the prologue until now so that the prologue can take
diff --git a/linux-user/signal-common.h b/linux-user/signal-common.h
index f4cbe6185e..8584d9ecc2 100644
--- a/linux-user/signal-common.h
+++ b/linux-user/signal-common.h
@@ -56,7 +56,7 @@ void setup_rt_frame(int sig, struct target_sigaction *ka,
target_sigset_t *set, CPUArchState *env);
void process_pending_signals(CPUArchState *cpu_env);
-void signal_init(void);
+void signal_init(const char *rtsig_map);
void queue_signal(CPUArchState *env, int sig, int si_type,
target_siginfo_t *info);
void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info);
diff --git a/linux-user/signal.c b/linux-user/signal.c
index 63ac2df53b..9b6d772882 100644
--- a/linux-user/signal.c
+++ b/linux-user/signal.c
@@ -18,6 +18,7 @@
*/
#include "qemu/osdep.h"
#include "qemu/bitops.h"
+#include "qemu/cutils.h"
#include "gdbstub/user.h"
#include "exec/page-protection.h"
#include "hw/core/tcg-cpu-ops.h"
@@ -513,20 +514,81 @@ static int core_dump_signal(int sig)
}
}
-static void signal_table_init(void)
+static void signal_table_init(const char *rtsig_map)
{
int hsig, tsig, count;
+ if (rtsig_map) {
+ /*
+ * Map host RT signals to target RT signals according to the
+ * user-provided specification.
+ */
+ const char *s = rtsig_map;
+
+ while (true) {
+ int i;
+
+ if (qemu_strtoi(s, &s, 10, &tsig) || *s++ != ' ') {
+ fprintf(stderr, "Malformed target signal in QEMU_RTSIG_MAP\n");
+ exit(EXIT_FAILURE);
+ }
+ if (qemu_strtoi(s, &s, 10, &hsig) || *s++ != ' ') {
+ fprintf(stderr, "Malformed host signal in QEMU_RTSIG_MAP\n");
+ exit(EXIT_FAILURE);
+ }
+ if (qemu_strtoi(s, &s, 10, &count) || (*s && *s != ',')) {
+ fprintf(stderr, "Malformed signal count in QEMU_RTSIG_MAP\n");
+ exit(EXIT_FAILURE);
+ }
+
+ for (i = 0; i < count; i++, tsig++, hsig++) {
+ if (tsig < TARGET_SIGRTMIN || tsig > TARGET_NSIG) {
+ fprintf(stderr, "%d is not a target rt signal\n", tsig);
+ exit(EXIT_FAILURE);
+ }
+ if (hsig < SIGRTMIN || hsig > SIGRTMAX) {
+ fprintf(stderr, "%d is not a host rt signal\n", hsig);
+ exit(EXIT_FAILURE);
+ }
+ if (host_to_target_signal_table[hsig]) {
+ fprintf(stderr, "%d already maps %d\n",
+ hsig, host_to_target_signal_table[hsig]);
+ exit(EXIT_FAILURE);
+ }
+ host_to_target_signal_table[hsig] = tsig;
+ }
+
+ if (*s) {
+ s++;
+ } else {
+ break;
+ }
+ }
+ } else {
+ /*
+ * Default host-to-target RT signal mapping.
+ *
+ * Signals are supported starting from TARGET_SIGRTMIN and going up
+ * until we run out of host realtime signals. Glibc uses the lower 2
+ * RT signals and (hopefully) nobody uses the upper ones.
+ * This is why SIGRTMIN (34) is generally greater than __SIGRTMIN (32).
+ * To fix this properly we would need to do manual signal delivery
+ * multiplexed over a single host signal.
+ * Attempts for configure "missing" signals via sigaction will be
+ * silently ignored.
+ *
+ * Reserve one signal for internal usage (see below).
+ */
+
+ hsig = SIGRTMIN + 1;
+ for (tsig = TARGET_SIGRTMIN;
+ hsig <= SIGRTMAX && tsig <= TARGET_NSIG;
+ hsig++, tsig++) {
+ host_to_target_signal_table[hsig] = tsig;
+ }
+ }
+
/*
- * Signals are supported starting from TARGET_SIGRTMIN and going up
- * until we run out of host realtime signals. Glibc uses the lower 2
- * RT signals and (hopefully) nobody uses the upper ones.
- * This is why SIGRTMIN (34) is generally greater than __SIGRTMIN (32).
- * To fix this properly we would need to do manual signal delivery
- * multiplexed over a single host signal.
- * Attempts for configure "missing" signals via sigaction will be
- * silently ignored.
- *
* Remap the target SIGABRT, so that we can distinguish host abort
* from guest abort. When the guest registers a signal handler or
* calls raise(SIGABRT), the host will raise SIG_RTn. If the guest
@@ -536,21 +598,27 @@ static void signal_table_init(void)
* parent sees the correct mapping from wait status.
*/
- hsig = SIGRTMIN;
host_to_target_signal_table[SIGABRT] = 0;
- host_to_target_signal_table[hsig++] = TARGET_SIGABRT;
-
- for (tsig = TARGET_SIGRTMIN;
- hsig <= SIGRTMAX && tsig <= TARGET_NSIG;
- hsig++, tsig++) {
- host_to_target_signal_table[hsig] = tsig;
+ for (hsig = SIGRTMIN; hsig <= SIGRTMAX; hsig++) {
+ if (!host_to_target_signal_table[hsig]) {
+ host_to_target_signal_table[hsig] = TARGET_SIGABRT;
+ break;
+ }
+ }
+ if (hsig > SIGRTMAX) {
+ fprintf(stderr, "No rt signals left for SIGABRT mapping\n");
+ exit(EXIT_FAILURE);
}
/* Invert the mapping that has already been assigned. */
for (hsig = 1; hsig < _NSIG; hsig++) {
tsig = host_to_target_signal_table[hsig];
if (tsig) {
- assert(target_to_host_signal_table[tsig] == 0);
+ if (target_to_host_signal_table[tsig]) {
+ fprintf(stderr, "%d is already mapped to %d\n",
+ tsig, target_to_host_signal_table[tsig]);
+ exit(EXIT_FAILURE);
+ }
target_to_host_signal_table[tsig] = hsig;
}
}
@@ -573,13 +641,13 @@ static void signal_table_init(void)
trace_signal_table_init(count);
}
-void signal_init(void)
+void signal_init(const char *rtsig_map)
{
TaskState *ts = get_task_state(thread_cpu);
struct sigaction act, oact;
/* initialize signal conversion tables */
- signal_table_init();
+ signal_table_init(rtsig_map);
/* Set the signal mask from the host mask. */
sigprocmask(0, 0, &ts->signal_mask);
generated by cgit v1.2.3 (git 2.26.2) at 2024-11-26 19:59:54 +0000