OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

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
 -----BEGIN PGP SIGNATURE-----
 
 iQJGBAABCAAwFiEEzS913cjjpNwuT1Fz8ww4vT8vvjwFAl3CxOQSHGxhdXJlbnRA
 dml2aWVyLmV1AAoJEPMMOL0/L748In0P/iw6tUeoIY7P2mlhGhR6Zy3q2ggHTVhJ
 PweOWWyXDk/IFkcraZMwq4yu2lThrcsMT3+9AGz0wVtoc0jukHli8CqZJV1XoeR6
 yRuEZxMSPYv7mqgHa+0vrtk//Rlc21C+ckIXaanS2jof76kJmSS3oSYpJSgBfEL9
 2Yb7/SN9ZGdg4dRPFSLUaML/NRFHXn3z+BdUWEbgMu4tBhCeQO4GBJ+0W6c2/U51
 UwNBGRjSioSik/rmzj9KN3sj+5IEod4ENxgkywRSYuH3CbWfy7qYRVfcaEi2Qw08
 42Wnct1pDLb3s1qPyW12Y/mOdxSmcxKGYrciQ/KiRbO6cC5+2hkEogYWmUFThCmb
 0b2lW9QBCgNm0Bsfqx4Utp4zSlpYd+i8/qclu+sNiexrk7cCPUpPiH2o/6qGai6w
 13hombmwacgLGsdWQyHHOyREnCLoRIxoki0abPhu5T8NV9NAUFQODWVtTo3M0iaH
 uf+G4FcUuulHbnN8kTCTskOBt6C+afOsCa4F0XebE5q6pchOFptgBCRLkzTsmtVr
 EvYv9xXXGeUuB8ATwnQuMJA66fwgZDmlES4KPPs7j75ppgUQ/vZDVIyNTKFVrInL
 ypqQNm/wn6khYWbTTrjSB/ffRjoHKf88eKKSn1AbrAIeFThBKJR3d/ZnnYGCVR2q
 JgP4xX+k7O1c
 =btyq
 -----END PGP SIGNATURE-----

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

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
linux-user/aarch64/target_cpu.h
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

16
linux-user/alpha/target_cpu.h
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)

7
linux-user/arm/target_cpu.h
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)) {

7
linux-user/cris/target_cpu.h
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;

7
linux-user/hppa/target_cpu.h
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;

7
linux-user/i386/target_cpu.h
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);

7
linux-user/m68k/target_cpu.h
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);

7
linux-user/microblaze/target_cpu.h
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;

7
linux-user/mips/target_cpu.h
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;

7
linux-user/nios2/target_cpu.h
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)
{
/*

8
linux-user/openrisc/target_cpu.h
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);

7
linux-user/ppc/target_cpu.h
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)

7
linux-user/riscv/target_cpu.h
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;

7
linux-user/s390x/target_cpu.h
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;

7
linux-user/sh4/target_cpu.h
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;

100
linux-user/sparc/signal.c
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) {

64
linux-user/sparc/target_cpu.h
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

107
linux-user/syscall.c
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);
}
}

7
linux-user/tilegx/target_cpu.h
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;

8
linux-user/xtensa/target_cpu.h
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;

8
scripts/qemu-binfmt-conf.sh
View File

@ -1,8 +1,8 @@
#!/bin/sh
# Enable automatic program execution by the kernel.
qemu_target_list="i386 i486 alpha arm armeb sparc32plus ppc ppc64 ppc64le m68k \
mips mipsel mipsn32 mipsn32el mips64 mips64el \
qemu_target_list="i386 i486 alpha arm armeb sparc sparc32plus sparc64 \
ppc ppc64 ppc64le m68k mips mipsel mipsn32 mipsn32el mips64 mips64el \
sh4 sh4eb s390x aarch64 aarch64_be hppa riscv32 riscv64 xtensa xtensaeb \
microblaze microblazeel or1k x86_64"
@ -38,6 +38,10 @@ sparc32plus_magic='\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x
sparc32plus_mask='\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff'
sparc32plus_family=sparc
sparc64_magic='\x7fELF\x02\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b'
sparc64_mask='\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff'
sparc64_family=sparc
ppc_magic='\x7fELF\x01\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x14'
ppc_mask='\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff'
ppc_family=ppc

33
target/sparc/cpu.h
View File

@ -13,6 +13,39 @@
/*#define EXCP_INTERRUPT 0x100*/
/* Windowed register indexes. */
enum {
WREG_O0,
WREG_O1,
WREG_O2,
WREG_O3,
WREG_O4,
WREG_O5,
WREG_O6,
WREG_O7,
WREG_L0,
WREG_L1,
WREG_L2,
WREG_L3,
WREG_L4,
WREG_L5,
WREG_L6,
WREG_L7,
WREG_I0,
WREG_I1,
WREG_I2,
WREG_I3,
WREG_I4,
WREG_I5,
WREG_I6,
WREG_I7,
WREG_SP = WREG_O6,
WREG_FP = WREG_I6,
};
/* trap definitions */
#ifndef TARGET_SPARC64
#define TT_TFAULT 0x01

3
tests/tcg/multiarch/linux-test.c
View File

@ -503,8 +503,9 @@ static void test_shm(void)
shmid = chk_error(shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0777));
ptr = shmat(shmid, NULL, 0);
if (!ptr)
if (ptr == (void *)-1) {
error("shmat");
}
memset(ptr, 0, SHM_SIZE);