izzy/xemu
0
0
Fork 0
mirror of https://github.com/izzy2lost/xemu.git synced 2026-07-06 00:20:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-4.2-pull-request' into staging

Browse Source 
sparc/sparc64 fixes: this doesn't fix debian chroot for me
but they are a step in the good direction.
Fix Netlink support.
Trivial fix for alpha

PULL v2: fix checkpatch warnings

# gpg: Signature made Wed 06 Nov 2019 13:04:36 GMT
# gpg:                using RSA key CD2F75DDC8E3A4DC2E4F5173F30C38BD3F2FBE3C
# gpg:                issuer "laurent@vivier.eu"
# gpg: Good signature from "Laurent Vivier <lvivier@redhat.com>" [full]
# gpg:                 aka "Laurent Vivier <laurent@vivier.eu>" [full]
# gpg:                 aka "Laurent Vivier (Red Hat) <lvivier@redhat.com>" [full]
# Primary key fingerprint: CD2F 75DD C8E3 A4DC 2E4F  5173 F30C 38BD 3F2F BE3C

* remotes/vivier2/tags/linux-user-for-4.2-pull-request:
  linux-user/alpha: Set r20 secondary return value
  linux-user/sparc: Fix cpu_clone_regs_*
  linux-user: Introduce cpu_clone_regs_parent
  linux-user: Rename cpu_clone_regs to cpu_clone_regs_child
  linux-user/sparc64: Fix target_signal_frame
  linux-user/sparc: Fix WREG usage in setup_frame
  linux-user/sparc: Use WREG_SP constant in sparc/signal.c
  linux-user/sparc: Begin using WREG constants in sparc/signal.c
  linux-user/sparc: Use WREG constants in sparc/target_cpu.h
  target/sparc: Define an enumeration for accessing env->regwptr
  tests/tcg/multiarch/linux-test: Fix error check for shmat
  scripts/qemu-binfmt-conf: Update for sparc64
  linux-user: Support for NETLINK socket options

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
2019-11-06 21:28:15 +00:00
parent 80d1c10b22 5849dfe410
commit 374b63590e
23 changed files with 339 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
linux-user/aarch64/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef AARCH64_TARGET_CPU_H
#define AARCH64_TARGET_CPU_H
static inline void cpu_clone_regs(CPUARMState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUARMState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->xregs[31] = newsp;
@@ -27,6 +28,10 @@ static inline void cpu_clone_regs(CPUARMState *env, target_ulong newsp)
env->xregs[0] = 0;
}
static inline void cpu_clone_regs_parent(CPUARMState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUARMState *env, target_ulong newtls)
{
/* Note that AArch64 Linux keeps the TLS pointer in TPIDR; this is
linux-user/alpha/target_cpu.h
+15 -1
View File
@@ -19,13 +19,27 @@
#ifndef ALPHA_TARGET_CPU_H
#define ALPHA_TARGET_CPU_H
static inline void cpu_clone_regs(CPUAlphaState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUAlphaState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->ir[IR_SP] = newsp;
}
env->ir[IR_V0] = 0;
env->ir[IR_A3] = 0;
env->ir[IR_A4] = 1; /* OSF/1 secondary return: child */
}
static inline void cpu_clone_regs_parent(CPUAlphaState *env, unsigned flags)
{
/*
* OSF/1 secondary return: parent
* Note that the kernel does not do this if SETTLS, because the
* settls argument register is still live after copy_thread.
*/
if (!(flags & CLONE_SETTLS)) {
env->ir[IR_A4] = 0;
}
}
static inline void cpu_set_tls(CPUAlphaState *env, target_ulong newtls)
linux-user/arm/target_cpu.h
+6 -1
View File
@@ -41,7 +41,8 @@ static inline unsigned long arm_max_reserved_va(CPUState *cs)
}
#define MAX_RESERVED_VA arm_max_reserved_va
static inline void cpu_clone_regs(CPUARMState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUARMState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[13] = newsp;
@@ -49,6 +50,10 @@ static inline void cpu_clone_regs(CPUARMState *env, target_ulong newsp)
env->regs[0] = 0;
}
static inline void cpu_clone_regs_parent(CPUARMState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUARMState *env, target_ulong newtls)
{
if (access_secure_reg(env)) {
linux-user/cris/target_cpu.h
+6 -1
View File
@@ -20,7 +20,8 @@
#ifndef CRIS_TARGET_CPU_H
#define CRIS_TARGET_CPU_H
static inline void cpu_clone_regs(CPUCRISState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUCRISState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[14] = newsp;
@@ -28,6 +29,10 @@ static inline void cpu_clone_regs(CPUCRISState *env, target_ulong newsp)
env->regs[10] = 0;
}
static inline void cpu_clone_regs_parent(CPUCRISState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUCRISState *env, target_ulong newtls)
{
env->pregs[PR_PID] = (env->pregs[PR_PID] & 0xff) | newtls;
linux-user/hppa/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef HPPA_TARGET_CPU_H
#define HPPA_TARGET_CPU_H
static inline void cpu_clone_regs(CPUHPPAState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUHPPAState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->gr[30] = newsp;
@@ -31,6 +32,10 @@ static inline void cpu_clone_regs(CPUHPPAState *env, target_ulong newsp)
env->iaoq_b = env->gr[31] + 4;
}
static inline void cpu_clone_regs_parent(CPUHPPAState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUHPPAState *env, target_ulong newtls)
{
env->cr[27] = newtls;
linux-user/i386/target_cpu.h
+6 -1
View File
@@ -20,7 +20,8 @@
#ifndef I386_TARGET_CPU_H
#define I386_TARGET_CPU_H
static inline void cpu_clone_regs(CPUX86State *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUX86State *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[R_ESP] = newsp;
@@ -28,6 +29,10 @@ static inline void cpu_clone_regs(CPUX86State *env, target_ulong newsp)
env->regs[R_EAX] = 0;
}
static inline void cpu_clone_regs_parent(CPUX86State *env, unsigned flags)
{
}
#if defined(TARGET_ABI32)
abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr);
linux-user/m68k/target_cpu.h
+6 -1
View File
@@ -21,7 +21,8 @@
#ifndef M68K_TARGET_CPU_H
#define M68K_TARGET_CPU_H
static inline void cpu_clone_regs(CPUM68KState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUM68KState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->aregs[7] = newsp;
@@ -29,6 +30,10 @@ static inline void cpu_clone_regs(CPUM68KState *env, target_ulong newsp)
env->dregs[0] = 0;
}
static inline void cpu_clone_regs_parent(CPUM68KState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUM68KState *env, target_ulong newtls)
{
CPUState *cs = env_cpu(env);
linux-user/microblaze/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef MICROBLAZE_TARGET_CPU_H
#define MICROBLAZE_TARGET_CPU_H
static inline void cpu_clone_regs(CPUMBState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUMBState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[R_SP] = newsp;
@@ -27,6 +28,10 @@ static inline void cpu_clone_regs(CPUMBState *env, target_ulong newsp)
env->regs[3] = 0;
}
static inline void cpu_clone_regs_parent(CPUMBState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUMBState *env, target_ulong newtls)
{
env->regs[21] = newtls;
linux-user/mips/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef MIPS_TARGET_CPU_H
#define MIPS_TARGET_CPU_H
static inline void cpu_clone_regs(CPUMIPSState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUMIPSState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->active_tc.gpr[29] = newsp;
@@ -28,6 +29,10 @@ static inline void cpu_clone_regs(CPUMIPSState *env, target_ulong newsp)
env->active_tc.gpr[2] = 0;
}
static inline void cpu_clone_regs_parent(CPUMIPSState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUMIPSState *env, target_ulong newtls)
{
env->active_tc.CP0_UserLocal = newtls;
linux-user/nios2/target_cpu.h
+6 -1
View File
@@ -20,7 +20,8 @@
#ifndef NIOS2_TARGET_CPU_H
#define NIOS2_TARGET_CPU_H
static inline void cpu_clone_regs(CPUNios2State *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUNios2State *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[R_SP] = newsp;
@@ -28,6 +29,10 @@ static inline void cpu_clone_regs(CPUNios2State *env, target_ulong newsp)
env->regs[R_RET0] = 0;
}
static inline void cpu_clone_regs_parent(CPUNios2State *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUNios2State *env, target_ulong newtls)
{
/*
linux-user/openrisc/target_cpu.h
+7 -1
View File
@@ -20,7 +20,9 @@
#ifndef OPENRISC_TARGET_CPU_H
#define OPENRISC_TARGET_CPU_H
static inline void cpu_clone_regs(CPUOpenRISCState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUOpenRISCState *env,
target_ulong newsp,
unsigned flags)
{
if (newsp) {
cpu_set_gpr(env, 1, newsp);
@@ -28,6 +30,10 @@ static inline void cpu_clone_regs(CPUOpenRISCState *env, target_ulong newsp)
cpu_set_gpr(env, 11, 0);
}
static inline void cpu_clone_regs_parent(CPUOpenRISCState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUOpenRISCState *env, target_ulong newtls)
{
cpu_set_gpr(env, 10, newtls);
linux-user/ppc/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef PPC_TARGET_CPU_H
#define PPC_TARGET_CPU_H
static inline void cpu_clone_regs(CPUPPCState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUPPCState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->gpr[1] = newsp;
@@ -27,6 +28,10 @@ static inline void cpu_clone_regs(CPUPPCState *env, target_ulong newsp)
env->gpr[3] = 0;
}
static inline void cpu_clone_regs_parent(CPUPPCState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUPPCState *env, target_ulong newtls)
{
#if defined(TARGET_PPC64)
linux-user/riscv/target_cpu.h
+6 -1
View File
@@ -1,7 +1,8 @@
#ifndef RISCV_TARGET_CPU_H
#define RISCV_TARGET_CPU_H
static inline void cpu_clone_regs(CPURISCVState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPURISCVState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->gpr[xSP] = newsp;
@@ -10,6 +11,10 @@ static inline void cpu_clone_regs(CPURISCVState *env, target_ulong newsp)
env->gpr[xA0] = 0;
}
static inline void cpu_clone_regs_parent(CPURISCVState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPURISCVState *env, target_ulong newtls)
{
env->gpr[xTP] = newtls;
linux-user/s390x/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef S390X_TARGET_CPU_H
#define S390X_TARGET_CPU_H
static inline void cpu_clone_regs(CPUS390XState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUS390XState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[15] = newsp;
@@ -27,6 +28,10 @@ static inline void cpu_clone_regs(CPUS390XState *env, target_ulong newsp)
env->regs[2] = 0;
}
static inline void cpu_clone_regs_parent(CPUS390XState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUS390XState *env, target_ulong newtls)
{
env->aregs[0] = newtls >> 32;
linux-user/sh4/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef SH4_TARGET_CPU_H
#define SH4_TARGET_CPU_H
static inline void cpu_clone_regs(CPUSH4State *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUSH4State *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->gregs[15] = newsp;
@@ -27,6 +28,10 @@ static inline void cpu_clone_regs(CPUSH4State *env, target_ulong newsp)
env->gregs[0] = 0;
}
static inline void cpu_clone_regs_parent(CPUSH4State *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUSH4State *env, target_ulong newtls)
{
env->gbr = newtls;
linux-user/sparc/signal.c
+34 -66
View File
@@ -87,7 +87,7 @@ struct target_signal_frame {
struct sparc_stackf ss;
__siginfo_t info;
abi_ulong fpu_save;
abi_ulong insns[2] __attribute__ ((aligned (8)));
uint32_t insns[2] QEMU_ALIGNED(8);
abi_ulong extramask[TARGET_NSIG_WORDS - 1];
abi_ulong extra_size; /* Should be 0 */
qemu_siginfo_fpu_t fpu_state;
@@ -98,26 +98,12 @@ struct target_rt_signal_frame {
abi_ulong regs[20];
sigset_t mask;
abi_ulong fpu_save;
unsigned int insns[2];
uint32_t insns[2];
stack_t stack;
unsigned int extra_size; /* Should be 0 */
qemu_siginfo_fpu_t fpu_state;
};
#define UREG_O0 16
#define UREG_O6 22
#define UREG_I0 0
#define UREG_I1 1
#define UREG_I2 2
#define UREG_I3 3
#define UREG_I4 4
#define UREG_I5 5
#define UREG_I6 6
#define UREG_I7 7
#define UREG_L0 8
#define UREG_FP UREG_I6
#define UREG_SP UREG_O6
static inline abi_ulong get_sigframe(struct target_sigaction *sa,
CPUSPARCState *env,
unsigned long framesize)
@@ -159,30 +145,12 @@ setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
__put_user(env->gregs[i], &si->si_regs.u_regs[i]);
}
for (i=0; i < 8; i++) {
__put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
__put_user(env->regwptr[WREG_O0 + i], &si->si_regs.u_regs[i + 8]);
}
__put_user(mask, &si->si_mask);
return err;
}
#if 0
static int
setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
CPUSPARCState *env, unsigned long mask)
{
int err = 0;
__put_user(mask, &sc->sigc_mask);
__put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
__put_user(env->pc, &sc->sigc_pc);
__put_user(env->npc, &sc->sigc_npc);
__put_user(env->psr, &sc->sigc_psr);
__put_user(env->gregs[1], &sc->sigc_g1);
__put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
return err;
}
#endif
#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
void setup_frame(int sig, struct target_sigaction *ka,
@@ -221,20 +189,20 @@ void setup_frame(int sig, struct target_sigaction *ka,
}
for (i = 0; i < 8; i++) {
__put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
__put_user(env->regwptr[i + WREG_L0], &sf->ss.locals[i]);
}
for (i = 0; i < 8; i++) {
__put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
__put_user(env->regwptr[i + WREG_I0], &sf->ss.ins[i]);
}
if (err)
goto sigsegv;
/* 3. signal handler back-trampoline and parameters */
env->regwptr[UREG_FP] = sf_addr;
env->regwptr[UREG_I0] = sig;
env->regwptr[UREG_I1] = sf_addr +
env->regwptr[WREG_SP] = sf_addr;
env->regwptr[WREG_O0] = sig;
env->regwptr[WREG_O1] = sf_addr +
offsetof(struct target_signal_frame, info);
env->regwptr[UREG_I2] = sf_addr +
env->regwptr[WREG_O2] = sf_addr +
offsetof(struct target_signal_frame, info);
/* 4. signal handler */
@@ -242,11 +210,11 @@ void setup_frame(int sig, struct target_sigaction *ka,
env->npc = (env->pc + 4);
/* 5. return to kernel instructions */
if (ka->ka_restorer) {
env->regwptr[UREG_I7] = ka->ka_restorer;
env->regwptr[WREG_O7] = ka->ka_restorer;
} else {
uint32_t val32;
env->regwptr[UREG_I7] = sf_addr +
env->regwptr[WREG_O7] = sf_addr +
offsetof(struct target_signal_frame, insns) - 2 * 4;
/* mov __NR_sigreturn, %g1 */
@@ -284,7 +252,7 @@ long do_sigreturn(CPUSPARCState *env)
sigset_t host_set;
int i;
sf_addr = env->regwptr[UREG_FP];
sf_addr = env->regwptr[WREG_SP];
trace_user_do_sigreturn(env, sf_addr);
if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
goto segv_and_exit;
@@ -316,7 +284,7 @@ long do_sigreturn(CPUSPARCState *env)
__get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
}
for (i=0; i < 8; i++) {
__get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
__get_user(env->regwptr[i + WREG_O0], &sf->info.si_regs.u_regs[i + 8]);
}
/* FIXME: implement FPU save/restore:
@@ -433,7 +401,7 @@ void sparc64_set_context(CPUSPARCState *env)
abi_ulong fp, i7, w_addr;
unsigned int i;
ucp_addr = env->regwptr[UREG_I0];
ucp_addr = env->regwptr[WREG_O0];
if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {
goto do_sigsegv;
}
@@ -443,7 +411,7 @@ void sparc64_set_context(CPUSPARCState *env)
if ((pc | npc) & 3) {
goto do_sigsegv;
}
if (env->regwptr[UREG_I1]) {
if (env->regwptr[WREG_O1]) {
target_sigset_t target_set;
sigset_t set;
@@ -474,19 +442,19 @@ void sparc64_set_context(CPUSPARCState *env)
__get_user(env->gregs[5], (&(*grp)[SPARC_MC_G5]));
__get_user(env->gregs[6], (&(*grp)[SPARC_MC_G6]));
__get_user(env->gregs[7], (&(*grp)[SPARC_MC_G7]));
__get_user(env->regwptr[UREG_I0], (&(*grp)[SPARC_MC_O0]));
__get_user(env->regwptr[UREG_I1], (&(*grp)[SPARC_MC_O1]));
__get_user(env->regwptr[UREG_I2], (&(*grp)[SPARC_MC_O2]));
__get_user(env->regwptr[UREG_I3], (&(*grp)[SPARC_MC_O3]));
__get_user(env->regwptr[UREG_I4], (&(*grp)[SPARC_MC_O4]));
__get_user(env->regwptr[UREG_I5], (&(*grp)[SPARC_MC_O5]));
__get_user(env->regwptr[UREG_I6], (&(*grp)[SPARC_MC_O6]));
__get_user(env->regwptr[UREG_I7], (&(*grp)[SPARC_MC_O7]));
__get_user(env->regwptr[WREG_O0], (&(*grp)[SPARC_MC_O0]));
__get_user(env->regwptr[WREG_O1], (&(*grp)[SPARC_MC_O1]));
__get_user(env->regwptr[WREG_O2], (&(*grp)[SPARC_MC_O2]));
__get_user(env->regwptr[WREG_O3], (&(*grp)[SPARC_MC_O3]));
__get_user(env->regwptr[WREG_O4], (&(*grp)[SPARC_MC_O4]));
__get_user(env->regwptr[WREG_O5], (&(*grp)[SPARC_MC_O5]));
__get_user(env->regwptr[WREG_O6], (&(*grp)[SPARC_MC_O6]));
__get_user(env->regwptr[WREG_O7], (&(*grp)[SPARC_MC_O7]));
__get_user(fp, &(ucp->tuc_mcontext.mc_fp));
__get_user(i7, &(ucp->tuc_mcontext.mc_i7));
w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
w_addr = TARGET_STACK_BIAS + env->regwptr[WREG_O6];
if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
abi_ulong) != 0) {
goto do_sigsegv;
@@ -534,7 +502,7 @@ void sparc64_get_context(CPUSPARCState *env)
target_sigset_t target_set;
sigset_t set;
ucp_addr = env->regwptr[UREG_I0];
ucp_addr = env->regwptr[WREG_O0];
if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {
goto do_sigsegv;
}
@@ -580,16 +548,16 @@ void sparc64_get_context(CPUSPARCState *env)
__put_user(env->gregs[5], &((*grp)[SPARC_MC_G5]));
__put_user(env->gregs[6], &((*grp)[SPARC_MC_G6]));
__put_user(env->gregs[7], &((*grp)[SPARC_MC_G7]));
__put_user(env->regwptr[UREG_I0], &((*grp)[SPARC_MC_O0]));
__put_user(env->regwptr[UREG_I1], &((*grp)[SPARC_MC_O1]));
__put_user(env->regwptr[UREG_I2], &((*grp)[SPARC_MC_O2]));
__put_user(env->regwptr[UREG_I3], &((*grp)[SPARC_MC_O3]));
__put_user(env->regwptr[UREG_I4], &((*grp)[SPARC_MC_O4]));
__put_user(env->regwptr[UREG_I5], &((*grp)[SPARC_MC_O5]));
__put_user(env->regwptr[UREG_I6], &((*grp)[SPARC_MC_O6]));
__put_user(env->regwptr[UREG_I7], &((*grp)[SPARC_MC_O7]));
__put_user(env->regwptr[WREG_O0], &((*grp)[SPARC_MC_O0]));
__put_user(env->regwptr[WREG_O1], &((*grp)[SPARC_MC_O1]));
__put_user(env->regwptr[WREG_O2], &((*grp)[SPARC_MC_O2]));
__put_user(env->regwptr[WREG_O3], &((*grp)[SPARC_MC_O3]));
__put_user(env->regwptr[WREG_O4], &((*grp)[SPARC_MC_O4]));
__put_user(env->regwptr[WREG_O5], &((*grp)[SPARC_MC_O5]));
__put_user(env->regwptr[WREG_O6], &((*grp)[SPARC_MC_O6]));
__put_user(env->regwptr[WREG_O7], &((*grp)[SPARC_MC_O7]));
w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
w_addr = TARGET_STACK_BIAS + env->regwptr[WREG_O6];
fp = i7 = 0;
if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
abi_ulong) != 0) {
linux-user/sparc/target_cpu.h
+46 -18
View File
@@ -20,20 +20,54 @@
#ifndef SPARC_TARGET_CPU_H
#define SPARC_TARGET_CPU_H
static inline void cpu_clone_regs(CPUSPARCState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUSPARCState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regwptr[22] = newsp;
}
/* syscall return for clone child: 0, and clear CF since
* this counts as a success return value.
/*
* After cpu_copy, env->regwptr is pointing into the old env.
* Update the new cpu to use its own register window.
*/
env->regwptr[0] = 0;
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
env->xcc &= ~PSR_CARRY;
env->regwptr = env->regbase + (env->cwp * 16);
if (newsp) {
/* When changing stacks, do it with clean register windows. */
#ifdef TARGET_SPARC64
env->cansave = env->nwindows - 2;
env->cleanwin = env->nwindows - 2;
env->canrestore = 0;
#else
env->psr &= ~PSR_CARRY;
env->wim = 1 << env->cwp;
#endif
/* ??? The kernel appears to copy one stack frame to the new stack. */
/* ??? The kernel force aligns the new stack. */
env->regwptr[WREG_SP] = newsp;
}
if (flags & CLONE_VM) {
/*
* Syscall return for clone child: %o0 = 0 and clear CF since this
* counts as a success return value. Advance the PC past the syscall.
* For fork child, all of this happens in cpu_loop, and we must not
* do the pc advance twice.
*/
env->regwptr[WREG_O0] = 0;
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
env->xcc &= ~PSR_CARRY;
#else
env->psr &= ~PSR_CARRY;
#endif
env->pc = env->npc;
env->npc = env->npc + 4;
}
/* Set the second return value for the child: %o1 = 1. */
env->regwptr[WREG_O1] = 1;
}
static inline void cpu_clone_regs_parent(CPUSPARCState *env, unsigned flags)
{
/* Set the second return value for the parent: %o1 = 0. */
env->regwptr[WREG_O1] = 0;
}
static inline void cpu_set_tls(CPUSPARCState *env, target_ulong newtls)
@@ -41,15 +75,9 @@ static inline void cpu_set_tls(CPUSPARCState *env, target_ulong newtls)
env->gregs[7] = newtls;
}
#ifndef UREG_I6
#define UREG_I6 6
#endif
#ifndef UREG_FP
#define UREG_FP UREG_I6
#endif
static inline abi_ulong get_sp_from_cpustate(CPUSPARCState *state)
{
return state->regwptr[UREG_FP];
return state->regwptr[WREG_SP];
}
#endif
linux-user/syscall.c
+105 -2
View File
@@ -2248,6 +2248,39 @@ set_timeout:
return -TARGET_EFAULT;
ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
break;
#ifdef SOL_NETLINK
case SOL_NETLINK:
switch (optname) {
case NETLINK_PKTINFO:
case NETLINK_ADD_MEMBERSHIP:
case NETLINK_DROP_MEMBERSHIP:
case NETLINK_BROADCAST_ERROR:
case NETLINK_NO_ENOBUFS:
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
case NETLINK_LISTEN_ALL_NSID:
case NETLINK_CAP_ACK:
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
case NETLINK_EXT_ACK:
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
case NETLINK_GET_STRICT_CHK:
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
break;
default:
goto unimplemented;
}
val = 0;
if (optlen < sizeof(uint32_t)) {
return -TARGET_EINVAL;
}
if (get_user_u32(val, optval_addr)) {
return -TARGET_EFAULT;
}
ret = get_errno(setsockopt(sockfd, SOL_NETLINK, optname, &val,
sizeof(val)));
break;
#endif /* SOL_NETLINK */
default:
unimplemented:
gemu_log("Unsupported setsockopt level=%d optname=%d\n", level, optname);
@@ -2532,6 +2565,74 @@ static abi_long do_getsockopt(int sockfd, int level, int optname,
break;
}
break;
#ifdef SOL_NETLINK
case SOL_NETLINK:
switch (optname) {
case NETLINK_PKTINFO:
case NETLINK_BROADCAST_ERROR:
case NETLINK_NO_ENOBUFS:
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
case NETLINK_LISTEN_ALL_NSID:
case NETLINK_CAP_ACK:
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0)
case NETLINK_EXT_ACK:
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 20, 0)
case NETLINK_GET_STRICT_CHK:
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) */
if (get_user_u32(len, optlen)) {
return -TARGET_EFAULT;
}
if (len != sizeof(val)) {
return -TARGET_EINVAL;
}
lv = len;
ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
if (ret < 0) {
return ret;
}
if (put_user_u32(lv, optlen)
|| put_user_u32(val, optval_addr)) {
return -TARGET_EFAULT;
}
break;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
case NETLINK_LIST_MEMBERSHIPS:
{
uint32_t *results;
int i;
if (get_user_u32(len, optlen)) {
return -TARGET_EFAULT;
}
if (len < 0) {
return -TARGET_EINVAL;
}
results = lock_user(VERIFY_WRITE, optval_addr, len, 1);
if (!results) {
return -TARGET_EFAULT;
}
lv = len;
ret = get_errno(getsockopt(sockfd, level, optname, results, &lv));
if (ret < 0) {
unlock_user(results, optval_addr, 0);
return ret;
}
/* swap host endianess to target endianess. */
for (i = 0; i < (len / sizeof(uint32_t)); i++) {
results[i] = tswap32(results[i]);
}
if (put_user_u32(lv, optlen)) {
return -TARGET_EFAULT;
}
unlock_user(results, optval_addr, 0);
break;
}
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) */
default:
goto unimplemented;
}
#endif /* SOL_NETLINK */
default:
unimplemented:
gemu_log("getsockopt level=%d optname=%d not yet supported\n",
@@ -5719,7 +5820,8 @@ static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
/* we create a new CPU instance. */
new_env = cpu_copy(env);
/* Init regs that differ from the parent. */
cpu_clone_regs(new_env, newsp);
cpu_clone_regs_child(new_env, newsp, flags);
cpu_clone_regs_parent(env, flags);
new_cpu = env_cpu(new_env);
new_cpu->opaque = ts;
ts->bprm = parent_ts->bprm;
@@ -5798,7 +5900,7 @@ static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
ret = fork();
if (ret == 0) {
/* Child Process. */
cpu_clone_regs(env, newsp);
cpu_clone_regs_child(env, newsp, flags);
fork_end(1);
/* There is a race condition here. The parent process could
theoretically read the TID in the child process before the child
@@ -5816,6 +5918,7 @@ static int do_fork(CPUArchState *env, unsigned int flags, abi_ulong newsp,
if (flags & CLONE_CHILD_CLEARTID)
ts->child_tidptr = child_tidptr;
} else {
cpu_clone_regs_parent(env, flags);
fork_end(0);
}
}
linux-user/tilegx/target_cpu.h
+6 -1
View File
@@ -19,7 +19,8 @@
#ifndef TILEGX_TARGET_CPU_H
#define TILEGX_TARGET_CPU_H
static inline void cpu_clone_regs(CPUTLGState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUTLGState *env, target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[TILEGX_R_SP] = newsp;
@@ -27,6 +28,10 @@ static inline void cpu_clone_regs(CPUTLGState *env, target_ulong newsp)
env->regs[TILEGX_R_RE] = 0;
}
static inline void cpu_clone_regs_parent(CPUTLGState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUTLGState *env, target_ulong newtls)
{
env->regs[TILEGX_R_TP] = newtls;
linux-user/xtensa/target_cpu.h
+7 -1
View File
@@ -4,7 +4,9 @@
#ifndef XTENSA_TARGET_CPU_H
#define XTENSA_TARGET_CPU_H
static inline void cpu_clone_regs(CPUXtensaState *env, target_ulong newsp)
static inline void cpu_clone_regs_child(CPUXtensaState *env,
target_ulong newsp,
unsigned flags)
{
if (newsp) {
env->regs[1] = newsp;
@@ -14,6 +16,10 @@ static inline void cpu_clone_regs(CPUXtensaState *env, target_ulong newsp)
env->regs[2] = 0;
}
static inline void cpu_clone_regs_parent(CPUXtensaState *env, unsigned flags)
{
}
static inline void cpu_set_tls(CPUXtensaState *env, target_ulong newtls)
{
env->uregs[THREADPTR] = newtls;

Some files were not shown because too many files have changed in this diff Show More