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

cpu: Move cpu_write_elfXX_note() functions to CPUState

Browse Source 
Convert cpu_write_elfXX_note() functions to CPUClass methods and pass
CPUState as argument. Update target-i386 accordingly.

Signed-off-by: Jens Freimann <jfrei@linux.vnet.ibm.com>
[AF: Retain stubs as CPUClass' default method implementation; style changes]
Signed-off-by: Andreas Färber <afaerber@suse.de>
This commit is contained in:
Jens Freimann 2013-04-19 16:45:06 +02:00 committed by Andreas Färber
parent 5f8df3ce6e
commit c72bf46825
8 changed files with 153 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
dump-stub.c
View File

@ -24,34 +24,6 @@ void qmp_dump_guest_memory(bool paging, const char *file, bool has_begin,
error_set(errp, QERR_UNSUPPORTED); error_set(errp, QERR_UNSUPPORTED);
} }
int cpu_write_elf64_note(write_core_dump_function f,
CPUArchState *env, int cpuid,
void *opaque)
{
return -1;
}
int cpu_write_elf32_note(write_core_dump_function f,
CPUArchState *env, int cpuid,
void *opaque)
{
return -1;
}
int cpu_write_elf64_qemunote(write_core_dump_function f,
CPUArchState *env,
void *opaque)
{
return -1;
}
int cpu_write_elf32_qemunote(write_core_dump_function f,
CPUArchState *env,
void *opaque)
{
return -1;
}
int cpu_get_dump_info(ArchDumpInfo *info) int cpu_get_dump_info(ArchDumpInfo *info)
{ {
return -1; return -1;

8
dump.c
View File

@ -282,7 +282,7 @@ static int write_elf64_notes(DumpState *s)
for (env = first_cpu; env != NULL; env = env->next_cpu) { for (env = first_cpu; env != NULL; env = env->next_cpu) {
cpu = ENV_GET_CPU(env); cpu = ENV_GET_CPU(env);
id = cpu_index(cpu); id = cpu_index(cpu);
ret = cpu_write_elf64_note(fd_write_vmcore, env, id, s); ret = cpu_write_elf64_note(fd_write_vmcore, cpu, id, s);
if (ret < 0) { if (ret < 0) {
dump_error(s, "dump: failed to write elf notes.\n"); dump_error(s, "dump: failed to write elf notes.\n");
return -1; return -1;
@ -290,7 +290,7 @@ static int write_elf64_notes(DumpState *s)
} }
for (env = first_cpu; env != NULL; env = env->next_cpu) { for (env = first_cpu; env != NULL; env = env->next_cpu) {
ret = cpu_write_elf64_qemunote(fd_write_vmcore, env, s); ret = cpu_write_elf64_qemunote(fd_write_vmcore, cpu, s);
if (ret < 0) { if (ret < 0) {
dump_error(s, "dump: failed to write CPU status.\n"); dump_error(s, "dump: failed to write CPU status.\n");
return -1; return -1;
@ -334,7 +334,7 @@ static int write_elf32_notes(DumpState *s)
for (env = first_cpu; env != NULL; env = env->next_cpu) { for (env = first_cpu; env != NULL; env = env->next_cpu) {
cpu = ENV_GET_CPU(env); cpu = ENV_GET_CPU(env);
id = cpu_index(cpu); id = cpu_index(cpu);
ret = cpu_write_elf32_note(fd_write_vmcore, env, id, s); ret = cpu_write_elf32_note(fd_write_vmcore, cpu, id, s);
if (ret < 0) { if (ret < 0) {
dump_error(s, "dump: failed to write elf notes.\n"); dump_error(s, "dump: failed to write elf notes.\n");
return -1; return -1;
@ -342,7 +342,7 @@ static int write_elf32_notes(DumpState *s)
} }
for (env = first_cpu; env != NULL; env = env->next_cpu) { for (env = first_cpu; env != NULL; env = env->next_cpu) {
ret = cpu_write_elf32_qemunote(fd_write_vmcore, env, s); ret = cpu_write_elf32_qemunote(fd_write_vmcore, cpu, s);
if (ret < 0) { if (ret < 0) {
dump_error(s, "dump: failed to write CPU status.\n"); dump_error(s, "dump: failed to write CPU status.\n");
return -1; return -1;

49
include/qom/cpu.h
View File

@ -24,6 +24,8 @@
#include "hw/qdev-core.h" #include "hw/qdev-core.h"
#include "qemu/thread.h" #include "qemu/thread.h"
typedef int (*WriteCoreDumpFunction)(void *buf, size_t size, void *opaque);
/** /**
* SECTION:cpu * SECTION:cpu
* @section_id: QEMU-cpu * @section_id: QEMU-cpu
@ -62,6 +64,14 @@ typedef struct CPUClass {
int64_t (*get_arch_id)(CPUState *cpu); int64_t (*get_arch_id)(CPUState *cpu);
const struct VMStateDescription *vmsd; const struct VMStateDescription *vmsd;
int (*write_elf64_note)(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque);
int (*write_elf64_qemunote)(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque);
int (*write_elf32_note)(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque);
int (*write_elf32_qemunote)(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque);
} CPUClass; } CPUClass;
struct KVMState; struct KVMState;
@ -127,6 +137,45 @@ struct CPUState {
uint32_t halted; /* used by alpha, cris, ppc TCG */ uint32_t halted; /* used by alpha, cris, ppc TCG */
}; };
/**
* cpu_write_elf64_note:
* @f: pointer to a function that writes memory to a file
* @cpu: The CPU whose memory is to be dumped
* @cpuid: ID number of the CPU
* @opaque: pointer to the CPUState struct
*/
int cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque);
/**
* cpu_write_elf64_qemunote:
* @f: pointer to a function that writes memory to a file
* @cpu: The CPU whose memory is to be dumped
* @cpuid: ID number of the CPU
* @opaque: pointer to the CPUState struct
*/
int cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque);
/**
* cpu_write_elf32_note:
* @f: pointer to a function that writes memory to a file
* @cpu: The CPU whose memory is to be dumped
* @cpuid: ID number of the CPU
* @opaque: pointer to the CPUState struct
*/
int cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque);
/**
* cpu_write_elf32_qemunote:
* @f: pointer to a function that writes memory to a file
* @cpu: The CPU whose memory is to be dumped
* @cpuid: ID number of the CPU
* @opaque: pointer to the CPUState struct
*/
int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque);
/** /**
* cpu_reset: * cpu_reset:

9
include/sysemu/dump.h
View File

@ -20,15 +20,6 @@ typedef struct ArchDumpInfo {
int d_class; /* ELFCLASS32 or ELFCLASS64 */ int d_class; /* ELFCLASS32 or ELFCLASS64 */
} ArchDumpInfo; } ArchDumpInfo;
typedef int (*write_core_dump_function)(void *buf, size_t size, void *opaque);
int cpu_write_elf64_note(write_core_dump_function f, CPUArchState *env,
int cpuid, void *opaque);
int cpu_write_elf32_note(write_core_dump_function f, CPUArchState *env,
int cpuid, void *opaque);
int cpu_write_elf64_qemunote(write_core_dump_function f, CPUArchState *env,
void *opaque);
int cpu_write_elf32_qemunote(write_core_dump_function f, CPUArchState *env,
void *opaque);
int cpu_get_dump_info(ArchDumpInfo *info); int cpu_get_dump_info(ArchDumpInfo *info);
ssize_t cpu_get_note_size(int class, int machine, int nr_cpus); ssize_t cpu_get_note_size(int class, int machine, int nr_cpus);

63
qom/cpu.c
View File

@ -64,6 +64,65 @@ void cpu_reset_interrupt(CPUState *cpu, int mask)
cpu->interrupt_request &= ~mask; cpu->interrupt_request &= ~mask;
} }
int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque)
{
CPUClass *cc = CPU_GET_CLASS(cpu);
return (*cc->write_elf32_qemunote)(f, cpu, opaque);
}
static int cpu_common_write_elf32_qemunote(WriteCoreDumpFunction f,
CPUState *cpu, void *opaque)
{
return -1;
}
int cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque)
{
CPUClass *cc = CPU_GET_CLASS(cpu);
return (*cc->write_elf32_note)(f, cpu, cpuid, opaque);
}
static int cpu_common_write_elf32_note(WriteCoreDumpFunction f,
CPUState *cpu, int cpuid,
void *opaque)
{
return -1;
}
int cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque)
{
CPUClass *cc = CPU_GET_CLASS(cpu);
return (*cc->write_elf64_qemunote)(f, cpu, opaque);
}
static int cpu_common_write_elf64_qemunote(WriteCoreDumpFunction f,
CPUState *cpu, void *opaque)
{
return -1;
}
int cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque)
{
CPUClass *cc = CPU_GET_CLASS(cpu);
return (*cc->write_elf64_note)(f, cpu, cpuid, opaque);
}
static int cpu_common_write_elf64_note(WriteCoreDumpFunction f,
CPUState *cpu, int cpuid,
void *opaque)
{
return -1;
}
void cpu_reset(CPUState *cpu) void cpu_reset(CPUState *cpu)
{ {
CPUClass *klass = CPU_GET_CLASS(cpu); CPUClass *klass = CPU_GET_CLASS(cpu);
@ -117,6 +176,10 @@ static void cpu_class_init(ObjectClass *klass, void *data)
k->class_by_name = cpu_common_class_by_name; k->class_by_name = cpu_common_class_by_name;
k->reset = cpu_common_reset; k->reset = cpu_common_reset;
k->get_arch_id = cpu_common_get_arch_id; k->get_arch_id = cpu_common_get_arch_id;
k->write_elf32_qemunote = cpu_common_write_elf32_qemunote;
k->write_elf32_note = cpu_common_write_elf32_note;
k->write_elf64_qemunote = cpu_common_write_elf64_qemunote;
k->write_elf64_note = cpu_common_write_elf64_note;
dc->realize = cpu_common_realizefn; dc->realize = cpu_common_realizefn;
dc->no_user = 1; dc->no_user = 1;
} }

38
target-i386/arch_dump.c
View File

@ -34,7 +34,7 @@ typedef struct {
char pad3[8]; char pad3[8];
} x86_64_elf_prstatus; } x86_64_elf_prstatus;
static int x86_64_write_elf64_note(write_core_dump_function f, static int x86_64_write_elf64_note(WriteCoreDumpFunction f,
CPUArchState *env, int id, CPUArchState *env, int id,
void *opaque) void *opaque)
{ {
@ -144,7 +144,7 @@ static void x86_fill_elf_prstatus(x86_elf_prstatus *prstatus, CPUArchState *env,
prstatus->pid = id; prstatus->pid = id;
} }
static int x86_write_elf64_note(write_core_dump_function f, CPUArchState *env, static int x86_write_elf64_note(WriteCoreDumpFunction f, CPUArchState *env,
int id, void *opaque) int id, void *opaque)
{ {
x86_elf_prstatus prstatus; x86_elf_prstatus prstatus;
@ -179,18 +179,19 @@ static int x86_write_elf64_note(write_core_dump_function f, CPUArchState *env,
return 0; return 0;
} }
int cpu_write_elf64_note(write_core_dump_function f, CPUArchState *env, int x86_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs,
int cpuid, void *opaque) int cpuid, void *opaque)
{ {
X86CPU *cpu = X86_CPU(cs);
int ret; int ret;
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
bool lma = !!(first_cpu->hflags & HF_LMA_MASK); bool lma = !!(first_cpu->hflags & HF_LMA_MASK);
if (lma) { if (lma) {
ret = x86_64_write_elf64_note(f, env, cpuid, opaque); ret = x86_64_write_elf64_note(f, &cpu->env, cpuid, opaque);
} else { } else {
#endif #endif
ret = x86_write_elf64_note(f, env, cpuid, opaque); ret = x86_write_elf64_note(f, &cpu->env, cpuid, opaque);
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
} }
#endif #endif
@ -198,9 +199,10 @@ int cpu_write_elf64_note(write_core_dump_function f, CPUArchState *env,
return ret; return ret;
} }
int cpu_write_elf32_note(write_core_dump_function f, CPUArchState *env, int x86_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
int cpuid, void *opaque) int cpuid, void *opaque)
{ {
X86CPU *cpu = X86_CPU(cs);
x86_elf_prstatus prstatus; x86_elf_prstatus prstatus;
Elf32_Nhdr *note; Elf32_Nhdr *note;
char *buf; char *buf;
@ -208,7 +210,7 @@ int cpu_write_elf32_note(write_core_dump_function f, CPUArchState *env,
const char *name = "CORE"; const char *name = "CORE";
int ret; int ret;
x86_fill_elf_prstatus(&prstatus, env, cpuid); x86_fill_elf_prstatus(&prstatus, &cpu->env, cpuid);
descsz = sizeof(x86_elf_prstatus); descsz = sizeof(x86_elf_prstatus);
note_size = ((sizeof(Elf32_Nhdr) + 3) / 4 + (name_size + 3) / 4 + note_size = ((sizeof(Elf32_Nhdr) + 3) / 4 + (name_size + 3) / 4 +
(descsz + 3) / 4) * 4; (descsz + 3) / 4) * 4;
@ -317,7 +319,7 @@ static void qemu_get_cpustate(QEMUCPUState *s, CPUArchState *env)
s->cr[4] = env->cr[4]; s->cr[4] = env->cr[4];
} }
static inline int cpu_write_qemu_note(write_core_dump_function f, static inline int cpu_write_qemu_note(WriteCoreDumpFunction f,
CPUArchState *env, CPUArchState *env,
void *opaque, void *opaque,
int type) int type)
@ -370,16 +372,20 @@ static inline int cpu_write_qemu_note(write_core_dump_function f,
return 0; return 0;
} }
int cpu_write_elf64_qemunote(write_core_dump_function f, CPUArchState *env, int x86_cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cs,
void *opaque) void *opaque)
{ {
return cpu_write_qemu_note(f, env, opaque, 1); X86CPU *cpu = X86_CPU(cs);
return cpu_write_qemu_note(f, &cpu->env, opaque, 1);
} }
int cpu_write_elf32_qemunote(write_core_dump_function f, CPUArchState *env, int x86_cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cs,
void *opaque) void *opaque)
{ {
return cpu_write_qemu_note(f, env, opaque, 0); X86CPU *cpu = X86_CPU(cs);
return cpu_write_qemu_note(f, &cpu->env, opaque, 0);
} }
int cpu_get_dump_info(ArchDumpInfo *info) int cpu_get_dump_info(ArchDumpInfo *info)

9
target-i386/cpu-qom.h
View File

@ -86,4 +86,13 @@ extern const struct VMStateDescription vmstate_x86_cpu;
*/ */
void x86_cpu_do_interrupt(CPUState *cpu); void x86_cpu_do_interrupt(CPUState *cpu);
int x86_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque);
int x86_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
int cpuid, void *opaque);
int x86_cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque);
int x86_cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
void *opaque);
#endif #endif

6
target-i386/cpu.c
View File

@ -2351,6 +2351,12 @@ static void x86_cpu_common_class_init(ObjectClass *oc, void *data)
cc->reset = x86_cpu_reset; cc->reset = x86_cpu_reset;
cc->do_interrupt = x86_cpu_do_interrupt; cc->do_interrupt = x86_cpu_do_interrupt;
#ifndef CONFIG_USER_ONLY
cc->write_elf64_note = x86_cpu_write_elf64_note;
cc->write_elf64_qemunote = x86_cpu_write_elf64_qemunote;
cc->write_elf32_note = x86_cpu_write_elf32_note;
cc->write_elf32_qemunote = x86_cpu_write_elf32_qemunote;
#endif
cpu_class_set_vmsd(cc, &vmstate_x86_cpu); cpu_class_set_vmsd(cc, &vmstate_x86_cpu);
cc->get_arch_id = x86_cpu_get_arch_id; cc->get_arch_id = x86_cpu_get_arch_id;