From 551747491d6677e4cc6cac8750462887a09bc722 Mon Sep 17 00:00:00 2001 From: Juan Quintela Date: Mon, 11 Jan 2016 12:40:21 +0000 Subject: [PATCH 1/8] vmstate: introduce CPU_DoubleU arrays Add vmstate support for migrating arrays of CPU_DoubleU via VMSTATE_CPUDOUBLE_ARRAY. Signed-off-by: Juan Quintela [PMM: rebased, since files have all moved since 2012; added VMSTATE_CPUDOUBLE_ARRAY_V for consistency with FLOAT64] Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- include/migration/vmstate.h | 7 +++++++ migration/vmstate.c | 23 +++++++++++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h index 97d44d3953..9b516c1bfe 100644 --- a/include/migration/vmstate.h +++ b/include/migration/vmstate.h @@ -156,6 +156,7 @@ extern const VMStateInfo vmstate_info_uint32; extern const VMStateInfo vmstate_info_uint64; extern const VMStateInfo vmstate_info_float64; +extern const VMStateInfo vmstate_info_cpudouble; extern const VMStateInfo vmstate_info_timer; extern const VMStateInfo vmstate_info_buffer; @@ -781,6 +782,12 @@ extern const VMStateInfo vmstate_info_bitmap; #define VMSTATE_FLOAT64_ARRAY(_f, _s, _n) \ VMSTATE_FLOAT64_ARRAY_V(_f, _s, _n, 0) +#define VMSTATE_CPUDOUBLE_ARRAY_V(_f, _s, _n, _v) \ + VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_cpudouble, CPU_DoubleU) + +#define VMSTATE_CPUDOUBLE_ARRAY(_f, _s, _n) \ + VMSTATE_CPUDOUBLE_ARRAY_V(_f, _s, _n, 0) + #define VMSTATE_BUFFER_V(_f, _s, _v) \ VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f))) diff --git a/migration/vmstate.c b/migration/vmstate.c index e8ccf22f67..f70fe59a3c 100644 --- a/migration/vmstate.c +++ b/migration/vmstate.c @@ -794,6 +794,29 @@ const VMStateInfo vmstate_info_float64 = { .put = put_float64, }; +/* CPU_DoubleU type */ + +static int get_cpudouble(QEMUFile *f, void *pv, size_t size) +{ + CPU_DoubleU *v = pv; + qemu_get_be32s(f, &v->l.upper); + qemu_get_be32s(f, &v->l.lower); + return 0; +} + +static void put_cpudouble(QEMUFile *f, void *pv, size_t size) +{ + CPU_DoubleU *v = pv; + qemu_put_be32s(f, &v->l.upper); + qemu_put_be32s(f, &v->l.lower); +} + +const VMStateInfo vmstate_info_cpudouble = { + .name = "CPU_Double_U", + .get = get_cpudouble, + .put = put_cpudouble, +}; + /* uint8_t buffers */ static int get_buffer(QEMUFile *f, void *pv, size_t size) From b47d3af7559b6fe17a2a86a1f0bf69f386873753 Mon Sep 17 00:00:00 2001 From: Juan Quintela Date: Mon, 11 Jan 2016 12:40:22 +0000 Subject: [PATCH 2/8] vmstate: Introduce VMSTATE_VARRAY_MULTPLY This allows to send a partial array where the size is another structure field multiplied by a constant. Signed-off-by: Juan Quintela [PMM: updated to current master] Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- include/migration/vmstate.h | 11 +++++++++++ migration/vmstate.c | 4 ++++ 2 files changed, 15 insertions(+) diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h index 9b516c1bfe..a4b81bb5f6 100644 --- a/include/migration/vmstate.h +++ b/include/migration/vmstate.h @@ -102,6 +102,7 @@ enum VMStateFlags { VMS_VARRAY_UINT32 = 0x800, /* Array with size in uint32_t field*/ VMS_MUST_EXIST = 0x1000, /* Field must exist in input */ VMS_ALLOC = 0x2000, /* Alloc a buffer on the destination */ + VMS_MULTIPLY_ELEMENTS = 0x4000, /* multiply varray size by field->num */ }; typedef struct { @@ -246,6 +247,16 @@ extern const VMStateInfo vmstate_info_bitmap; .offset = vmstate_offset_2darray(_state, _field, _type, _n1, _n2), \ } +#define VMSTATE_VARRAY_MULTIPLY(_field, _state, _field_num, _multiply, _info, _type) { \ + .name = (stringify(_field)), \ + .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\ + .num = (_multiply), \ + .info = &(_info), \ + .size = sizeof(_type), \ + .flags = VMS_VARRAY_UINT32|VMS_MULTIPLY_ELEMENTS, \ + .offset = offsetof(_state, _field), \ +} + #define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\ .name = (stringify(_field)), \ .field_exists = (_test), \ diff --git a/migration/vmstate.c b/migration/vmstate.c index f70fe59a3c..a7ad7f2216 100644 --- a/migration/vmstate.c +++ b/migration/vmstate.c @@ -28,6 +28,10 @@ static int vmstate_n_elems(void *opaque, VMStateField *field) n_elems = *(uint8_t *)(opaque+field->num_offset); } + if (field->flags & VMS_MULTIPLY_ELEMENTS) { + n_elems *= field->num; + } + return n_elems; } From 365162f7c09a428f16d2278e025328e73539ae8b Mon Sep 17 00:00:00 2001 From: Juan Quintela Date: Mon, 11 Jan 2016 12:40:23 +0000 Subject: [PATCH 3/8] vmstate: define vmstate_info_uinttl We are going to define arrays of this type, so we need the integer type. Signed-off-by: Juan Quintela [PMM: updated to apply on current QEMU; renamed to 'uinttl' rather than 'uinttls' to match other vmstate naming] Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- include/hw/hw.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/hw/hw.h b/include/hw/hw.h index c78adae06a..cd3d410f97 100644 --- a/include/hw/hw.h +++ b/include/hw/hw.h @@ -49,6 +49,7 @@ void qemu_unregister_reset(QEMUResetHandler *func, void *opaque); VMSTATE_UINT64_EQUAL_V(_f, _s, _v) #define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \ VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) +#define vmstate_info_uinttl vmstate_info_uint64 #else #define VMSTATE_UINTTL_V(_f, _s, _v) \ VMSTATE_UINT32_V(_f, _s, _v) @@ -56,6 +57,7 @@ void qemu_unregister_reset(QEMUResetHandler *func, void *opaque); VMSTATE_UINT32_EQUAL_V(_f, _s, _v) #define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \ VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) +#define vmstate_info_uinttl vmstate_info_uint32 #endif #define VMSTATE_UINTTL(_f, _s) \ VMSTATE_UINTTL_V(_f, _s, 0) From 4552a09dd4055c806b7df8c595dc0fb8951834be Mon Sep 17 00:00:00 2001 From: Peter Maydell Date: Mon, 11 Jan 2016 12:40:24 +0000 Subject: [PATCH 4/8] target-sparc: Split cpu_put_psr into side-effect and no-side-effect parts For inbound migration we really want to be able to set the PSR without having any side effects, but cpu_put_psr() calls cpu_check_irqs() which might try to deliver CPU interrupts. Split cpu_put_psr() into the no-side-effect and side-effect parts. This includes reordering the cpu_check_irqs() to the end of cpu_put_psr(), because that function may actually end up calling cpu_interrupt(), which does not seem like a good thing to happen in the middle of updating the PSR. Suggested-by: Blue Swirl Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- target-sparc/cpu.h | 1 + target-sparc/win_helper.c | 19 ++++++++++++------- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/target-sparc/cpu.h b/target-sparc/cpu.h index 4aa689ed0b..d9635079e1 100644 --- a/target-sparc/cpu.h +++ b/target-sparc/cpu.h @@ -539,6 +539,7 @@ int cpu_sparc_exec(CPUState *cpu); /* win_helper.c */ target_ulong cpu_get_psr(CPUSPARCState *env1); void cpu_put_psr(CPUSPARCState *env1, target_ulong val); +void cpu_put_psr_raw(CPUSPARCState *env1, target_ulong val); #ifdef TARGET_SPARC64 target_ulong cpu_get_ccr(CPUSPARCState *env1); void cpu_put_ccr(CPUSPARCState *env1, target_ulong val); diff --git a/target-sparc/win_helper.c b/target-sparc/win_helper.c index f01ae08f6c..5b6d7b5ae3 100644 --- a/target-sparc/win_helper.c +++ b/target-sparc/win_helper.c @@ -64,23 +64,28 @@ target_ulong cpu_get_psr(CPUSPARCState *env) #endif } -void cpu_put_psr(CPUSPARCState *env, target_ulong val) +void cpu_put_psr_raw(CPUSPARCState *env, target_ulong val) { env->psr = val & PSR_ICC; #if !defined(TARGET_SPARC64) env->psref = (val & PSR_EF) ? 1 : 0; env->psrpil = (val & PSR_PIL) >> 8; -#endif -#if ((!defined(TARGET_SPARC64)) && !defined(CONFIG_USER_ONLY)) - cpu_check_irqs(env); -#endif -#if !defined(TARGET_SPARC64) env->psrs = (val & PSR_S) ? 1 : 0; env->psrps = (val & PSR_PS) ? 1 : 0; env->psret = (val & PSR_ET) ? 1 : 0; - cpu_set_cwp(env, val & PSR_CWP); #endif env->cc_op = CC_OP_FLAGS; +#if !defined(TARGET_SPARC64) + cpu_set_cwp(env, val & PSR_CWP); +#endif +} + +void cpu_put_psr(CPUSPARCState *env, target_ulong val) +{ + cpu_put_psr_raw(env, val); +#if ((!defined(TARGET_SPARC64)) && !defined(CONFIG_USER_ONLY)) + cpu_check_irqs(env); +#endif } int cpu_cwp_inc(CPUSPARCState *env, int cwp) From 232afac113dab9880a5e3a002d63b61d554a4b89 Mon Sep 17 00:00:00 2001 From: Peter Maydell Date: Mon, 11 Jan 2016 12:40:25 +0000 Subject: [PATCH 5/8] target-sparc: Don't flush TLB in cpu_load function There's no need to flush the TLB in the SPARC cpu_load function: we're guaranteed to be loading state into a fresh clean configuration. Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- target-sparc/machine.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/target-sparc/machine.c b/target-sparc/machine.c index 3f3de4c65a..9d221ecfb8 100644 --- a/target-sparc/machine.c +++ b/target-sparc/machine.c @@ -112,7 +112,6 @@ void cpu_save(QEMUFile *f, void *opaque) int cpu_load(QEMUFile *f, void *opaque, int version_id) { CPUSPARCState *env = opaque; - SPARCCPU *cpu = sparc_env_get_cpu(env); int i; uint32_t tmp; @@ -213,6 +212,5 @@ int cpu_load(QEMUFile *f, void *opaque, int version_id) qemu_get_be64s(f, &env->ssr); cpu_get_timer(f, env->hstick); #endif - tlb_flush(CPU(cpu), 1); return 0; } From df32c8d436d4eb3f40b00647ca0df2bbc7f6bf6f Mon Sep 17 00:00:00 2001 From: Juan Quintela Date: Mon, 11 Jan 2016 12:40:26 +0000 Subject: [PATCH 6/8] target-sparc: Convert to VMStateDescription Convert the SPARC CPU from cpu_load/save functions to VMStateDescription. We preserve migration compatibility with the previous version (required for SPARC32 but not necessarily for SPARC64). Signed-off-by: Juan Quintela [PMM: * Rebase and update to apply to master * VMSTATE_STRUCT_POINTER now takes type, not pointer-to-type * QEMUTimer* are migrated via VMSTATE_TIMER_PTR * Put CPUTimer vmstate struct inside TARGET_SPARC64 ifdef * Convert handling of PSR to use a vmstate_psr, like Alpha and ARM ] Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- hw/sparc64/sun4u.c | 24 -- target-sparc/cpu-qom.h | 4 + target-sparc/cpu.c | 1 + target-sparc/cpu.h | 6 - target-sparc/machine.c | 645 ++++++++++++++++++++++++++++------------- 5 files changed, 451 insertions(+), 229 deletions(-) diff --git a/hw/sparc64/sun4u.c b/hw/sparc64/sun4u.c index 1925a1cef9..861727f7e3 100644 --- a/hw/sparc64/sun4u.c +++ b/hw/sparc64/sun4u.c @@ -358,30 +358,6 @@ typedef struct ResetData { uint64_t prom_addr; } ResetData; -void cpu_put_timer(QEMUFile *f, CPUTimer *s) -{ - qemu_put_be32s(f, &s->frequency); - qemu_put_be32s(f, &s->disabled); - qemu_put_be64s(f, &s->disabled_mask); - qemu_put_be32s(f, &s->npt); - qemu_put_be64s(f, &s->npt_mask); - qemu_put_sbe64s(f, &s->clock_offset); - - timer_put(f, s->qtimer); -} - -void cpu_get_timer(QEMUFile *f, CPUTimer *s) -{ - qemu_get_be32s(f, &s->frequency); - qemu_get_be32s(f, &s->disabled); - qemu_get_be64s(f, &s->disabled_mask); - qemu_get_be32s(f, &s->npt); - qemu_get_be64s(f, &s->npt_mask); - qemu_get_sbe64s(f, &s->clock_offset); - - timer_get(f, s->qtimer); -} - static CPUTimer *cpu_timer_create(const char *name, SPARCCPU *cpu, QEMUBHFunc *cb, uint32_t frequency, uint64_t disabled_mask, uint64_t npt_mask) diff --git a/target-sparc/cpu-qom.h b/target-sparc/cpu-qom.h index 477c4d5136..5096b10472 100644 --- a/target-sparc/cpu-qom.h +++ b/target-sparc/cpu-qom.h @@ -75,6 +75,10 @@ static inline SPARCCPU *sparc_env_get_cpu(CPUSPARCState *env) #define ENV_OFFSET offsetof(SPARCCPU, env) +#ifndef CONFIG_USER_ONLY +extern const struct VMStateDescription vmstate_sparc_cpu; +#endif + void sparc_cpu_do_interrupt(CPUState *cpu); void sparc_cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf, int flags); diff --git a/target-sparc/cpu.c b/target-sparc/cpu.c index d98682b563..c197a0f48a 100644 --- a/target-sparc/cpu.c +++ b/target-sparc/cpu.c @@ -855,6 +855,7 @@ static void sparc_cpu_class_init(ObjectClass *oc, void *data) cc->do_unassigned_access = sparc_cpu_unassigned_access; cc->do_unaligned_access = sparc_cpu_do_unaligned_access; cc->get_phys_page_debug = sparc_cpu_get_phys_page_debug; + cc->vmsd = &vmstate_sparc_cpu; #endif cc->disas_set_info = cpu_sparc_disas_set_info; diff --git a/target-sparc/cpu.h b/target-sparc/cpu.h index d9635079e1..58ff4743b4 100644 --- a/target-sparc/cpu.h +++ b/target-sparc/cpu.h @@ -374,10 +374,6 @@ struct CPUTimer typedef struct CPUTimer CPUTimer; -struct QEMUFile; -void cpu_put_timer(struct QEMUFile *f, CPUTimer *s); -void cpu_get_timer(struct QEMUFile *f, CPUTimer *s); - typedef struct CPUSPARCState CPUSPARCState; struct CPUSPARCState { @@ -599,8 +595,6 @@ int cpu_sparc_signal_handler(int host_signum, void *pinfo, void *puc); #define cpu_signal_handler cpu_sparc_signal_handler #define cpu_list sparc_cpu_list -#define CPU_SAVE_VERSION 7 - /* MMU modes definitions */ #if defined (TARGET_SPARC64) #define MMU_USER_IDX 0 diff --git a/target-sparc/machine.c b/target-sparc/machine.c index 9d221ecfb8..bb9e44c4ce 100644 --- a/target-sparc/machine.c +++ b/target-sparc/machine.c @@ -4,213 +4,460 @@ #include "cpu.h" -void cpu_save(QEMUFile *f, void *opaque) -{ - CPUSPARCState *env = opaque; - int i; - uint32_t tmp; +#ifdef TARGET_SPARC64 +static const VMStateDescription vmstate_cpu_timer = { + .name = "cpu_timer", + .version_id = 1, + .minimum_version_id = 1, + .minimum_version_id_old = 1, + .fields = (VMStateField[]) { + VMSTATE_UINT32(frequency, CPUTimer), + VMSTATE_UINT32(disabled, CPUTimer), + VMSTATE_UINT64(disabled_mask, CPUTimer), + VMSTATE_UINT32(npt, CPUTimer), + VMSTATE_UINT64(npt_mask, CPUTimer), + VMSTATE_INT64(clock_offset, CPUTimer), + VMSTATE_TIMER_PTR(qtimer, CPUTimer), + VMSTATE_END_OF_LIST() + } +}; - // if env->cwp == env->nwindows - 1, this will set the ins of the last - // window as the outs of the first window - cpu_set_cwp(env, env->cwp); +#define VMSTATE_CPU_TIMER(_f, _s) \ + VMSTATE_STRUCT_POINTER(_f, _s, vmstate_cpu_timer, CPUTimer) - for(i = 0; i < 8; i++) - qemu_put_betls(f, &env->gregs[i]); - qemu_put_be32s(f, &env->nwindows); - for(i = 0; i < env->nwindows * 16; i++) - qemu_put_betls(f, &env->regbase[i]); +static const VMStateDescription vmstate_trap_state = { + .name = "trap_state", + .version_id = 1, + .minimum_version_id = 1, + .minimum_version_id_old = 1, + .fields = (VMStateField[]) { + VMSTATE_UINT64(tpc, trap_state), + VMSTATE_UINT64(tnpc, trap_state), + VMSTATE_UINT64(tstate, trap_state), + VMSTATE_UINT32(tt, trap_state), + VMSTATE_END_OF_LIST() + } +}; - /* FPU */ - for (i = 0; i < TARGET_DPREGS; i++) { - qemu_put_be32(f, env->fpr[i].l.upper); - qemu_put_be32(f, env->fpr[i].l.lower); +static const VMStateDescription vmstate_tlb_entry = { + .name = "tlb_entry", + .version_id = 1, + .minimum_version_id = 1, + .minimum_version_id_old = 1, + .fields = (VMStateField[]) { + VMSTATE_UINT64(tag, SparcTLBEntry), + VMSTATE_UINT64(tte, SparcTLBEntry), + VMSTATE_END_OF_LIST() } - - qemu_put_betls(f, &env->pc); - qemu_put_betls(f, &env->npc); - qemu_put_betls(f, &env->y); - tmp = cpu_get_psr(env); - qemu_put_be32(f, tmp); - qemu_put_betls(f, &env->fsr); - qemu_put_betls(f, &env->tbr); - tmp = env->interrupt_index; - qemu_put_be32(f, tmp); - qemu_put_be32s(f, &env->pil_in); -#ifndef TARGET_SPARC64 - qemu_put_be32s(f, &env->wim); - /* MMU */ - for (i = 0; i < 32; i++) - qemu_put_be32s(f, &env->mmuregs[i]); - for (i = 0; i < 4; i++) { - qemu_put_be64s(f, &env->mxccdata[i]); - } - for (i = 0; i < 8; i++) { - qemu_put_be64s(f, &env->mxccregs[i]); - } - qemu_put_be32s(f, &env->mmubpctrv); - qemu_put_be32s(f, &env->mmubpctrc); - qemu_put_be32s(f, &env->mmubpctrs); - qemu_put_be64s(f, &env->mmubpaction); - for (i = 0; i < 4; i++) { - qemu_put_be64s(f, &env->mmubpregs[i]); - } -#else - qemu_put_be64s(f, &env->lsu); - for (i = 0; i < 16; i++) { - qemu_put_be64s(f, &env->immuregs[i]); - qemu_put_be64s(f, &env->dmmuregs[i]); - } - for (i = 0; i < 64; i++) { - qemu_put_be64s(f, &env->itlb[i].tag); - qemu_put_be64s(f, &env->itlb[i].tte); - qemu_put_be64s(f, &env->dtlb[i].tag); - qemu_put_be64s(f, &env->dtlb[i].tte); - } - qemu_put_be32s(f, &env->mmu_version); - for (i = 0; i < MAXTL_MAX; i++) { - qemu_put_be64s(f, &env->ts[i].tpc); - qemu_put_be64s(f, &env->ts[i].tnpc); - qemu_put_be64s(f, &env->ts[i].tstate); - qemu_put_be32s(f, &env->ts[i].tt); - } - qemu_put_be32s(f, &env->xcc); - qemu_put_be32s(f, &env->asi); - qemu_put_be32s(f, &env->pstate); - qemu_put_be32s(f, &env->tl); - qemu_put_be32s(f, &env->cansave); - qemu_put_be32s(f, &env->canrestore); - qemu_put_be32s(f, &env->otherwin); - qemu_put_be32s(f, &env->wstate); - qemu_put_be32s(f, &env->cleanwin); - for (i = 0; i < 8; i++) - qemu_put_be64s(f, &env->agregs[i]); - for (i = 0; i < 8; i++) - qemu_put_be64s(f, &env->bgregs[i]); - for (i = 0; i < 8; i++) - qemu_put_be64s(f, &env->igregs[i]); - for (i = 0; i < 8; i++) - qemu_put_be64s(f, &env->mgregs[i]); - qemu_put_be64s(f, &env->fprs); - qemu_put_be64s(f, &env->tick_cmpr); - qemu_put_be64s(f, &env->stick_cmpr); - cpu_put_timer(f, env->tick); - cpu_put_timer(f, env->stick); - qemu_put_be64s(f, &env->gsr); - qemu_put_be32s(f, &env->gl); - qemu_put_be64s(f, &env->hpstate); - for (i = 0; i < MAXTL_MAX; i++) - qemu_put_be64s(f, &env->htstate[i]); - qemu_put_be64s(f, &env->hintp); - qemu_put_be64s(f, &env->htba); - qemu_put_be64s(f, &env->hver); - qemu_put_be64s(f, &env->hstick_cmpr); - qemu_put_be64s(f, &env->ssr); - cpu_put_timer(f, env->hstick); +}; #endif -} -int cpu_load(QEMUFile *f, void *opaque, int version_id) +static int get_psr(QEMUFile *f, void *opaque, size_t size) { - CPUSPARCState *env = opaque; - int i; - uint32_t tmp; + SPARCCPU *cpu = opaque; + CPUSPARCState *env = &cpu->env; + uint32_t val = qemu_get_be32(f); - if (version_id < 6) - return -EINVAL; - for(i = 0; i < 8; i++) - qemu_get_betls(f, &env->gregs[i]); - qemu_get_be32s(f, &env->nwindows); - for(i = 0; i < env->nwindows * 16; i++) - qemu_get_betls(f, &env->regbase[i]); + /* needed to ensure that the wrapping registers are correctly updated */ + env->cwp = 0; + cpu_put_psr_raw(env, val); - /* FPU */ - for (i = 0; i < TARGET_DPREGS; i++) { - env->fpr[i].l.upper = qemu_get_be32(f); - env->fpr[i].l.lower = qemu_get_be32(f); - } - - qemu_get_betls(f, &env->pc); - qemu_get_betls(f, &env->npc); - qemu_get_betls(f, &env->y); - tmp = qemu_get_be32(f); - env->cwp = 0; /* needed to ensure that the wrapping registers are - correctly updated */ - cpu_put_psr(env, tmp); - qemu_get_betls(f, &env->fsr); - qemu_get_betls(f, &env->tbr); - tmp = qemu_get_be32(f); - env->interrupt_index = tmp; - qemu_get_be32s(f, &env->pil_in); -#ifndef TARGET_SPARC64 - qemu_get_be32s(f, &env->wim); - /* MMU */ - for (i = 0; i < 32; i++) - qemu_get_be32s(f, &env->mmuregs[i]); - for (i = 0; i < 4; i++) { - qemu_get_be64s(f, &env->mxccdata[i]); - } - for (i = 0; i < 8; i++) { - qemu_get_be64s(f, &env->mxccregs[i]); - } - qemu_get_be32s(f, &env->mmubpctrv); - qemu_get_be32s(f, &env->mmubpctrc); - qemu_get_be32s(f, &env->mmubpctrs); - qemu_get_be64s(f, &env->mmubpaction); - for (i = 0; i < 4; i++) { - qemu_get_be64s(f, &env->mmubpregs[i]); - } -#else - qemu_get_be64s(f, &env->lsu); - for (i = 0; i < 16; i++) { - qemu_get_be64s(f, &env->immuregs[i]); - qemu_get_be64s(f, &env->dmmuregs[i]); - } - for (i = 0; i < 64; i++) { - qemu_get_be64s(f, &env->itlb[i].tag); - qemu_get_be64s(f, &env->itlb[i].tte); - qemu_get_be64s(f, &env->dtlb[i].tag); - qemu_get_be64s(f, &env->dtlb[i].tte); - } - qemu_get_be32s(f, &env->mmu_version); - for (i = 0; i < MAXTL_MAX; i++) { - qemu_get_be64s(f, &env->ts[i].tpc); - qemu_get_be64s(f, &env->ts[i].tnpc); - qemu_get_be64s(f, &env->ts[i].tstate); - qemu_get_be32s(f, &env->ts[i].tt); - } - qemu_get_be32s(f, &env->xcc); - qemu_get_be32s(f, &env->asi); - qemu_get_be32s(f, &env->pstate); - qemu_get_be32s(f, &env->tl); - qemu_get_be32s(f, &env->cansave); - qemu_get_be32s(f, &env->canrestore); - qemu_get_be32s(f, &env->otherwin); - qemu_get_be32s(f, &env->wstate); - qemu_get_be32s(f, &env->cleanwin); - for (i = 0; i < 8; i++) - qemu_get_be64s(f, &env->agregs[i]); - for (i = 0; i < 8; i++) - qemu_get_be64s(f, &env->bgregs[i]); - for (i = 0; i < 8; i++) - qemu_get_be64s(f, &env->igregs[i]); - for (i = 0; i < 8; i++) - qemu_get_be64s(f, &env->mgregs[i]); - qemu_get_be64s(f, &env->fprs); - qemu_get_be64s(f, &env->tick_cmpr); - qemu_get_be64s(f, &env->stick_cmpr); - cpu_get_timer(f, env->tick); - cpu_get_timer(f, env->stick); - qemu_get_be64s(f, &env->gsr); - qemu_get_be32s(f, &env->gl); - qemu_get_be64s(f, &env->hpstate); - for (i = 0; i < MAXTL_MAX; i++) - qemu_get_be64s(f, &env->htstate[i]); - qemu_get_be64s(f, &env->hintp); - qemu_get_be64s(f, &env->htba); - qemu_get_be64s(f, &env->hver); - qemu_get_be64s(f, &env->hstick_cmpr); - qemu_get_be64s(f, &env->ssr); - cpu_get_timer(f, env->hstick); -#endif return 0; } + +static void put_psr(QEMUFile *f, void *opaque, size_t size) +{ + SPARCCPU *cpu = opaque; + CPUSPARCState *env = &cpu->env; + uint32_t val; + + val = cpu_get_psr(env); + + qemu_put_be32(f, val); +} + +static const VMStateInfo vmstate_psr = { + .name = "psr", + .get = get_psr, + .put = put_psr, +}; + +static void cpu_pre_save(void *opaque) +{ + SPARCCPU *cpu = opaque; + CPUSPARCState *env = &cpu->env; + + /* if env->cwp == env->nwindows - 1, this will set the ins of the last + * window as the outs of the first window + */ + cpu_set_cwp(env, env->cwp); +} + +const VMStateDescription vmstate_sparc_cpu = { + .name = "cpu", + .version_id = 7, + .minimum_version_id = 7, + .minimum_version_id_old = 7, + .pre_save = cpu_pre_save, + .fields = (VMStateField[]) { + VMSTATE_UINTTL_ARRAY(env.gregs, SPARCCPU, 8), + VMSTATE_UINT32(env.nwindows, SPARCCPU), + VMSTATE_VARRAY_MULTIPLY(env.regbase, SPARCCPU, env.nwindows, 16, + vmstate_info_uinttl, target_ulong), + VMSTATE_CPUDOUBLE_ARRAY(env.fpr, SPARCCPU, TARGET_DPREGS), + VMSTATE_UINTTL(env.pc, SPARCCPU), + VMSTATE_UINTTL(env.npc, SPARCCPU), + VMSTATE_UINTTL(env.y, SPARCCPU), + { + + .name = "psr", + .version_id = 0, + .size = sizeof(uint32_t), + .info = &vmstate_psr, + .flags = VMS_SINGLE, + .offset = 0, + }, + VMSTATE_UINTTL(env.fsr, SPARCCPU), + VMSTATE_UINTTL(env.tbr, SPARCCPU), + VMSTATE_INT32(env.interrupt_index, SPARCCPU), + VMSTATE_UINT32(env.pil_in, SPARCCPU), +#ifndef TARGET_SPARC64 + /* MMU */ + VMSTATE_UINT32(env.wim, SPARCCPU), + VMSTATE_UINT32_ARRAY(env.mmuregs, SPARCCPU, 32), + VMSTATE_UINT64_ARRAY(env.mxccdata, SPARCCPU, 4), + VMSTATE_UINT64_ARRAY(env.mxccregs, SPARCCPU, 8), + VMSTATE_UINT32(env.mmubpctrv, SPARCCPU), + VMSTATE_UINT32(env.mmubpctrc, SPARCCPU), + VMSTATE_UINT32(env.mmubpctrs, SPARCCPU), + VMSTATE_UINT64(env.mmubpaction, SPARCCPU), + VMSTATE_UINT64_ARRAY(env.mmubpregs, SPARCCPU, 4), +#else + VMSTATE_UINT64(env.lsu, SPARCCPU), + /* Unfortunately we cannot use vmstate arrays for these because + * the pre-VMState migration code sent the contents on the wire + * interleaved rather than one array at a time. + */ + VMSTATE_UINT64(env.immuregs[0], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[0], SPARCCPU), + VMSTATE_UINT64(env.immuregs[1], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[1], SPARCCPU), + VMSTATE_UINT64(env.immuregs[2], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[2], SPARCCPU), + VMSTATE_UINT64(env.immuregs[3], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[3], SPARCCPU), + VMSTATE_UINT64(env.immuregs[4], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[4], SPARCCPU), + VMSTATE_UINT64(env.immuregs[5], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[5], SPARCCPU), + VMSTATE_UINT64(env.immuregs[6], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[6], SPARCCPU), + VMSTATE_UINT64(env.immuregs[7], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[7], SPARCCPU), + VMSTATE_UINT64(env.immuregs[8], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[8], SPARCCPU), + VMSTATE_UINT64(env.immuregs[9], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[9], SPARCCPU), + VMSTATE_UINT64(env.immuregs[10], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[10], SPARCCPU), + VMSTATE_UINT64(env.immuregs[11], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[11], SPARCCPU), + VMSTATE_UINT64(env.immuregs[12], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[12], SPARCCPU), + VMSTATE_UINT64(env.immuregs[13], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[13], SPARCCPU), + VMSTATE_UINT64(env.immuregs[14], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[14], SPARCCPU), + VMSTATE_UINT64(env.immuregs[15], SPARCCPU), + VMSTATE_UINT64(env.dmmuregs[15], SPARCCPU), + VMSTATE_STRUCT(env.itlb[0], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[0], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[1], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[1], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[2], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[2], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[3], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[3], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[4], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[4], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[5], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[5], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[6], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[6], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[7], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[7], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[8], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[8], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[9], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[9], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[10], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[10], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[11], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[11], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[12], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[12], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[13], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[13], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[14], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[14], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[15], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[15], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[16], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[16], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[17], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[17], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[18], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[18], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[19], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[19], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[20], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[20], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[21], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[21], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[22], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[22], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[23], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[23], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[24], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[24], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[25], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[25], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[26], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[26], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[27], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[27], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[28], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[28], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[29], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[29], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[30], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[30], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[31], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[31], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[32], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[32], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[33], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[33], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[34], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[34], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[35], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[35], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[36], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[36], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[37], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[37], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[38], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[38], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[39], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[39], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[40], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[40], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[41], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[41], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[42], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[42], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[43], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[43], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[44], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[44], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[45], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[45], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[46], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[46], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[47], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[47], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[48], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[48], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[49], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[49], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[50], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[50], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[51], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[51], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[52], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[52], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[53], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[53], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[54], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[54], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[55], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[55], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[56], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[56], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[57], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[57], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[58], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[58], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[59], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[59], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[60], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[60], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[61], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[61], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[62], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[62], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.itlb[63], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_STRUCT(env.dtlb[63], SPARCCPU, 0, vmstate_tlb_entry, + SparcTLBEntry), + VMSTATE_UINT32(env.mmu_version, SPARCCPU), + VMSTATE_STRUCT_ARRAY(env.ts, SPARCCPU, MAXTL_MAX, 0, + vmstate_trap_state, trap_state), + VMSTATE_UINT32(env.xcc, SPARCCPU), + VMSTATE_UINT32(env.asi, SPARCCPU), + VMSTATE_UINT32(env.pstate, SPARCCPU), + VMSTATE_UINT32(env.tl, SPARCCPU), + VMSTATE_UINT32(env.cansave, SPARCCPU), + VMSTATE_UINT32(env.canrestore, SPARCCPU), + VMSTATE_UINT32(env.otherwin, SPARCCPU), + VMSTATE_UINT32(env.wstate, SPARCCPU), + VMSTATE_UINT32(env.cleanwin, SPARCCPU), + VMSTATE_UINT64_ARRAY(env.agregs, SPARCCPU, 8), + VMSTATE_UINT64_ARRAY(env.bgregs, SPARCCPU, 8), + VMSTATE_UINT64_ARRAY(env.igregs, SPARCCPU, 8), + VMSTATE_UINT64_ARRAY(env.mgregs, SPARCCPU, 8), + VMSTATE_UINT64(env.fprs, SPARCCPU), + VMSTATE_UINT64(env.tick_cmpr, SPARCCPU), + VMSTATE_UINT64(env.stick_cmpr, SPARCCPU), + VMSTATE_CPU_TIMER(env.tick, SPARCCPU), + VMSTATE_CPU_TIMER(env.stick, SPARCCPU), + VMSTATE_UINT64(env.gsr, SPARCCPU), + VMSTATE_UINT32(env.gl, SPARCCPU), + VMSTATE_UINT64(env.hpstate, SPARCCPU), + VMSTATE_UINT64_ARRAY(env.htstate, SPARCCPU, MAXTL_MAX), + VMSTATE_UINT64(env.hintp, SPARCCPU), + VMSTATE_UINT64(env.htba, SPARCCPU), + VMSTATE_UINT64(env.hver, SPARCCPU), + VMSTATE_UINT64(env.hstick_cmpr, SPARCCPU), + VMSTATE_UINT64(env.ssr, SPARCCPU), + VMSTATE_CPU_TIMER(env.hstick, SPARCCPU), +#endif + VMSTATE_END_OF_LIST() + }, +}; From 0e88d45a33928445aa3031ee76af354b4f6b3088 Mon Sep 17 00:00:00 2001 From: Peter Maydell Date: Mon, 11 Jan 2016 12:40:27 +0000 Subject: [PATCH 7/8] target-sparc: Use VMState arrays for SPARC64 TLB/MMU state Use VMState arrays for SPARC64 TLB/MMU state. This is a migration-break for SPARC64 (but not for SPARC32), which is acceptable because currently migration does not work for any SPARC64 machines due to the lack of any migration of interrupt controller state. Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- target-sparc/machine.c | 314 +++-------------------------------------- 1 file changed, 19 insertions(+), 295 deletions(-) diff --git a/target-sparc/machine.c b/target-sparc/machine.c index bb9e44c4ce..f8eebdde3f 100644 --- a/target-sparc/machine.c +++ b/target-sparc/machine.c @@ -93,11 +93,21 @@ static void cpu_pre_save(void *opaque) cpu_set_cwp(env, env->cwp); } +/* 32-bit SPARC retains migration compatibility with older versions + * of QEMU; 64-bit SPARC has had a migration break since then, so the + * versions are different. + */ +#ifndef TARGET_SPARC64 +#define SPARC_VMSTATE_VER 7 +#else +#define SPARC_VMSTATE_VER 8 +#endif + const VMStateDescription vmstate_sparc_cpu = { .name = "cpu", - .version_id = 7, - .minimum_version_id = 7, - .minimum_version_id_old = 7, + .version_id = SPARC_VMSTATE_VER, + .minimum_version_id = SPARC_VMSTATE_VER, + .minimum_version_id_old = SPARC_VMSTATE_VER, .pre_save = cpu_pre_save, .fields = (VMStateField[]) { VMSTATE_UINTTL_ARRAY(env.gregs, SPARCCPU, 8), @@ -134,298 +144,12 @@ const VMStateDescription vmstate_sparc_cpu = { VMSTATE_UINT64_ARRAY(env.mmubpregs, SPARCCPU, 4), #else VMSTATE_UINT64(env.lsu, SPARCCPU), - /* Unfortunately we cannot use vmstate arrays for these because - * the pre-VMState migration code sent the contents on the wire - * interleaved rather than one array at a time. - */ - VMSTATE_UINT64(env.immuregs[0], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[0], SPARCCPU), - VMSTATE_UINT64(env.immuregs[1], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[1], SPARCCPU), - VMSTATE_UINT64(env.immuregs[2], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[2], SPARCCPU), - VMSTATE_UINT64(env.immuregs[3], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[3], SPARCCPU), - VMSTATE_UINT64(env.immuregs[4], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[4], SPARCCPU), - VMSTATE_UINT64(env.immuregs[5], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[5], SPARCCPU), - VMSTATE_UINT64(env.immuregs[6], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[6], SPARCCPU), - VMSTATE_UINT64(env.immuregs[7], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[7], SPARCCPU), - VMSTATE_UINT64(env.immuregs[8], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[8], SPARCCPU), - VMSTATE_UINT64(env.immuregs[9], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[9], SPARCCPU), - VMSTATE_UINT64(env.immuregs[10], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[10], SPARCCPU), - VMSTATE_UINT64(env.immuregs[11], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[11], SPARCCPU), - VMSTATE_UINT64(env.immuregs[12], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[12], SPARCCPU), - VMSTATE_UINT64(env.immuregs[13], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[13], SPARCCPU), - VMSTATE_UINT64(env.immuregs[14], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[14], SPARCCPU), - VMSTATE_UINT64(env.immuregs[15], SPARCCPU), - VMSTATE_UINT64(env.dmmuregs[15], SPARCCPU), - VMSTATE_STRUCT(env.itlb[0], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[0], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[1], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[1], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[2], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[2], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[3], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[3], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[4], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[4], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[5], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[5], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[6], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[6], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[7], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[7], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[8], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[8], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[9], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[9], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[10], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[10], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[11], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[11], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[12], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[12], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[13], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[13], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[14], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[14], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[15], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[15], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[16], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[16], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[17], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[17], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[18], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[18], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[19], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[19], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[20], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[20], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[21], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[21], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[22], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[22], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[23], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[23], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[24], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[24], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[25], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[25], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[26], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[26], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[27], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[27], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[28], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[28], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[29], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[29], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[30], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[30], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[31], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[31], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[32], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[32], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[33], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[33], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[34], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[34], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[35], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[35], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[36], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[36], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[37], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[37], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[38], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[38], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[39], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[39], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[40], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[40], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[41], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[41], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[42], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[42], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[43], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[43], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[44], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[44], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[45], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[45], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[46], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[46], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[47], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[47], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[48], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[48], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[49], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[49], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[50], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[50], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[51], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[51], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[52], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[52], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[53], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[53], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[54], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[54], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[55], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[55], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[56], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[56], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[57], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[57], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[58], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[58], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[59], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[59], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[60], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[60], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[61], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[61], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[62], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[62], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.itlb[63], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), - VMSTATE_STRUCT(env.dtlb[63], SPARCCPU, 0, vmstate_tlb_entry, - SparcTLBEntry), + VMSTATE_UINT64_ARRAY(env.immuregs, SPARCCPU, 16), + VMSTATE_UINT64_ARRAY(env.dmmuregs, SPARCCPU, 16), + VMSTATE_STRUCT_ARRAY(env.itlb, SPARCCPU, 64, 0, + vmstate_tlb_entry, SparcTLBEntry), + VMSTATE_STRUCT_ARRAY(env.dtlb, SPARCCPU, 64, 0, + vmstate_tlb_entry, SparcTLBEntry), VMSTATE_UINT32(env.mmu_version, SPARCCPU), VMSTATE_STRUCT_ARRAY(env.ts, SPARCCPU, MAXTL_MAX, 0, vmstate_trap_state, trap_state), From 6d5322442a6904fef51a409ec40f2945581220d6 Mon Sep 17 00:00:00 2001 From: Peter Maydell Date: Mon, 11 Jan 2016 12:40:28 +0000 Subject: [PATCH 8/8] target-sparc: Migrate CWP and PIL for SPARC64 In SPARC32 the env->cwp and env->psrpil state is part of the PSR register, and gets migrated as part of that register. In SPARC64 this state is in separate CWP and PIL registers, but we were not doing anything to migrate those. Add the missing fields to the migration vmstate (which is a migration break, but without these fields migration is completely broken anyway). This change means that trying a save/load of a SPARC64 target at the boot rom prompt now produces a system which at least responds to keyboard input after the restore. Reported-by: Paolo Bonzini Signed-off-by: Peter Maydell Signed-off-by: Mark Cave-Ayland --- target-sparc/machine.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/target-sparc/machine.c b/target-sparc/machine.c index f8eebdde3f..aecbe2cedb 100644 --- a/target-sparc/machine.c +++ b/target-sparc/machine.c @@ -100,7 +100,7 @@ static void cpu_pre_save(void *opaque) #ifndef TARGET_SPARC64 #define SPARC_VMSTATE_VER 7 #else -#define SPARC_VMSTATE_VER 8 +#define SPARC_VMSTATE_VER 9 #endif const VMStateDescription vmstate_sparc_cpu = { @@ -181,6 +181,9 @@ const VMStateDescription vmstate_sparc_cpu = { VMSTATE_UINT64(env.hstick_cmpr, SPARCCPU), VMSTATE_UINT64(env.ssr, SPARCCPU), VMSTATE_CPU_TIMER(env.hstick, SPARCCPU), + /* On SPARC32 env.psrpil and env.cwp are migrated as part of the PSR */ + VMSTATE_UINT32(env.psrpil, SPARCCPU), + VMSTATE_UINT32(env.cwp, SPARCCPU), #endif VMSTATE_END_OF_LIST() },